sortmerge.c

mini database sort-merge join

#include <string.h>
#include <assert.h>
#include "sortMerge.h"

// Error Protocall:

enum ErrCodes {};

static const char* ErrMsgs[] = 	{};

static error_string_table ErrTable( JOINS, ErrMsgs );

sortMerge::sortMerge(
    char*           filename1,      // Name of heapfile for relation R
    int             len_in1,        // # of columns in R.
    AttrType        in1[],          // Array containing field types of R.
    short           t1_str_sizes[], // Array containing size of columns in R
    int             join_col_in1,   // The join column of R 

    char*           filename2,      // Name of heapfile for relation S
    int             len_in2,        // # of columns in S.
    AttrType        in2[],          // Array containing field types of S.
    short           t2_str_sizes[], // Array containing size of columns in S
    int             join_col_in2,   // The join column of S

    char*           filename3,      // Name of heapfile for merged results
    int             amt_of_mem,     // Number of pages available
    TupleOrder      order,          // Sorting order: Ascending or Descending
    Status&         s               // Status of constructor
){

	//char *out_filename1,*out_filename2;
	//Scan *Tr,*Ts,*Gs;
	int R_rid_len=0,S_rid_len=0;
	for(int i=0;i<len_in1;i++){
		R_rid_len+=t1_str_sizes[i];
	}
	
	for(int i=0;i<len_in2;i++){
		R_rid_len+=t2_str_sizes[i];
	}
	RID R_key,S_key,out_rid;
	char R_Prt[R_rid_len];
	char tempS_Prt[S_rid_len];
	char S_Prt[S_rid_len];
	char out_recPtr[R_rid_len+S_rid_len];
	char *R,*S,*G;
	Status  s_R,s_S;

	//*************
	//sort
	//*************

	Sort(filename1,"R",len_in1,in1,t1_str_sizes,join_col_in1,order,amt_of_mem,s);

	Sort(filename2,"S",len_in1,in2,t2_str_sizes,join_col_in2,order,amt_of_mem,s);


	//*************
	//open and initial file
	//**********
	HeapFile R_file("R", s );
	
	HeapFile S_file("S",s);
	
	HeapFile *G_file=new HeapFile(filename3,s);
	
	//*************
	//Merge
	//**********


	Scan* Tr=R_file.openScan(s);
	Scan* Ts=S_file.openScan(s);
	Scan* Gs=S_file.openScan(s);

	R=&R_Prt[R_rid_len];
	S=&S_Prt[S_rid_len];
	G=&out_recPtr[R_rid_len+S_rid_len];

	

	s_R=Tr->getNext(R_key,R,R_rid_len);
	s_S=Ts->getNext(S_key,S,S_rid_len);
	

	//scan

	
	while((s_R==OK)&&(s_S==OK))
	{
		while(tupleCmp (R_Prt, S_Prt)==-1){
			s_R=Tr->getNext(R_key,R_Prt,R_rid_len);
		}
		while(tupleCmp (R_Prt, S_Prt)==1){
			s_S=Gs->getNext(S_key,S_Prt,S_rid_len);
			
		}
		tempS_Prt=S_Prt;
		while(tupleCmp (R_Prt, S_Prt)==0){
			tempS_Prt=S_Prt;
			while(tupleCmp (R_Prt, tempS_Prt)==0){

				memcpy((char *)(out_recPtr), R, R_rid_len);
				memcpy((char *)(out_recPtr+R_rid_len),S, S_rid_len);
				G_file->insertRecord(out_recPtr, R_rid_len+S_rid_len, out_rid );
				s_S= Ts->getNext(S_key, tempS_Prt, S_rid_len);
				
			}
			if (s_R!=OK) break;
			s_R= Tr->getNext(R_key, R_Prt, R_rid_len);
			if (s_R!=OK) break;
		}
		S_Prt=tempS_Prt;
					
	}
	//delete
	delete Gs;
	delete Tr;
	delete Ts;
	R_file.deleteFile();
	S_file.deleteFile();


}

sortMerge::~sortMerge()
{

}