join.c

linux 下用c++ 开发的一个小型数据库系统

#include "catalog.h"
#include "query.h"
#include "sort.h"

extern JoinType JoinMethod;

const int matchRec(const Record & outerRec,
		   const Record & innerRec,
		   const AttrDesc & attrDesc1,
		   const AttrDesc & attrDesc2);

/*
 * Joins two relations.
 *
 * Returns:
 * 	OK on success
 * 	an error code otherwise
 */

// implementation of nested loops join goes here
const Status QU_NL_Join(const string & result, 
		     const int projCnt, 
		     const attrInfo projNames[],
		     const attrInfo *attr1, 
		     const Operator op, 
		     const attrInfo *attr2)
{
    Status status;
    //cout << "Doing NL Join" << endl;
    // part 5 
    string	relstr, atrstr;
    int 	i, n, op1, op2 ;
    RelDesc	rds ;
    AttrDesc	ads, ads1, ads2 ;
    int		len, k ;
    char	*mydata ;
    HeapFileScan *hfs, *hfs1 ;
    InsertFileScan *ifs ;
    Record	rec, rec1 ; 
    RID		rid, rid1, rid2 ;
    char	*cmp1, *cmp2 ;

    relstr.append("checkrel") ;
    for (i = 0; i < projCnt; i++){
      relstr.erase(1) ;
      n = strlen(projNames[i].relName) ;
      relstr.replace( 0, n, projNames[i].relName) ;
      if ((status = relCat->getInfo( relstr, rds)) != OK) return status ;
    }
   
    len = 0 ; 
    relstr.append("checkatr") ;
    atrstr.append("checkatr") ;   
    for (i = 0; i < projCnt; i++){
      atrstr.erase(1) ;
      relstr.erase(1) ;
      n = strlen(projNames[i].attrName) ;
      atrstr.replace( 0, n, projNames[i].attrName) ;
      n = strlen(projNames[i].relName) ;
      relstr.replace( 0, n, projNames[i].relName) ;
      if ((status = attrCat->getInfo( relstr, atrstr, ads)) != OK) 
        return status ;
      len = len + ads.attrLen ;
    }

    relstr.erase(1) ;
    atrstr.erase(1) ;
    n = strlen(attr1[0].attrName) ;
    atrstr.replace( 0, n, attr1[0].attrName) ;
    n = strlen(attr1[0].relName) ;
    relstr.replace( 0, n, attr1[0].relName) ;
    if ((status = attrCat->getInfo( relstr, atrstr, ads)) != OK)
      return status ;
    op1 = ads.attrType ;

    relstr.erase(1) ;
    atrstr.erase(1) ;
    n = strlen(attr2[0].attrName) ;
    atrstr.replace( 0, n, attr2[0].attrName) ;
    n = strlen(attr2[0].relName) ;
    relstr.replace( 0, n, attr2[0].relName) ;
    if ((status = attrCat->getInfo( relstr, atrstr, ads1)) != OK)
      return status ;
    op2 = ads.attrType ;
    
    // check between of op
    if (op1 != op2) return DIFBTWOP ;
    
    relstr.erase(1) ;
    n = strlen(attr1[0].relName) ;
    relstr.replace( 0, n, attr1[0].relName) ;
    atrstr.erase(1) ;
    n = strlen(attr2[0].relName) ;
    atrstr.replace( 0, n, attr2[0].relName) ;
    
    hfs = new HeapFileScan( relstr, status) ;
    if (status != OK) return status ;
    hfs1 = new HeapFileScan( atrstr, status) ;
    if (status != OK){
      delete hfs ;
      return status ;
    }
    ifs = new InsertFileScan( result, status) ;
    if (status != OK){
      delete hfs ;
      delete hfs1 ;
      return status ;
    }
      
    mydata = new char[len] ;
    int tempi, tempi1 ;
    int tempf, tempf1 ;
    int kg = 1 , cmplen;
/*
    if (op == EQ){ 
      hfs->startScan( 0, 0,(Datatype)ads.attrType, NULL, EQ) ;
      while(hfs->scanNext(rid) != FILEEOF){
        hfs->getRecord(rec) ;
        cmp1 = (char *)rec.data + ads.attrOffset;
        switch((Datatype)ads.attrType) {
          case INTEGER:
            memcpy(&tempi, cmp1, sizeof(int));
            break;
          case FLOAT:
            memcpy(&tempf, cmp1, sizeof(float));
            break;
        }

        hfs1->startScan( 0, 0, (Datatype)ads1.attrType, NULL, EQ) ;
        while(hfs1->scanNext(rid1) != FILEEOF){

          hfs1->getRecord(rec1) ;
          cmp2 = (char *)rec1.data + ads1.attrOffset ;
          switch((Datatype)ads.attrType) {
            case INTEGER:
              memcpy(&tempi1, cmp2, sizeof(int));
              if (tempi1 == tempi) kg = 0 ;

              break;
            case FLOAT:
              memcpy(&tempf1, cmp2, sizeof(float));
              if (tempf1 == tempf) kg = 0 ;

              break;
            case STRING:
              if (strcmp( cmp1, cmp2) == 0) kg = 0 ;

           }
          if (kg == 0){
   
            k = 0 ; 
            for ( i = 0; i < len; i++) mydata[i] = 0 ;

            relstr.append("makerec") ;
            atrstr.append("makerec") ;
            for (i = 0; i < projCnt; i++){
              atrstr.erase(1) ;
              relstr.erase(1) ;
              n = strlen(projNames[i].attrName) ;
              atrstr.replace( 0, n, projNames[i].attrName) ;
              n = strlen(projNames[i].relName) ;
              relstr.replace( 0, n, projNames[i].relName) ;
              attrCat->getInfo( relstr, atrstr, ads2) ;
              if (strcmp(attr1[0].relName, relstr.c_str()) == 0){
                memcpy( mydata + k,(char *)rec.data + ads2.attrOffset, ads2.attrLen) ;
                k = k + ads2.attrLen ;
              }
              else{
                memcpy( mydata + k,(char *)rec1.data + ads2.attrOffset, ads2.attrLen);
                k = k + ads2.attrLen ;
              }
            }
            rec1.data = mydata ;
            rec1.length = len ;
            ifs->insertRecord( rec1, rid2) ;
            kg = 1 ;
          }
        }
      }
      delete hfs ;
      delete hfs1 ;
      delete ifs ;
      delete [] mydata ;
      return OK ;
    } 
*/
      hfs->startScan( 0, 0,(Datatype)ads.attrType, NULL, EQ) ;
      while(hfs->scanNext(rid) != FILEEOF){
        hfs->getRecord(rec) ;
        cmp1 = (char *)rec.data + ads.attrOffset;
        switch((Datatype)ads.attrType) {
          case INTEGER:
            memcpy(&tempi, cmp1, sizeof(int));
            break;
          case FLOAT:
            memcpy(&tempf, cmp1, sizeof(float));
            break;
        }

        hfs1->startScan( 0, 0, (Datatype)ads1.attrType, NULL, EQ) ;
        while(hfs1->scanNext(rid1) != FILEEOF){

          hfs1->getRecord(rec1) ;
          cmp2 = (char *)rec1.data + ads1.attrOffset ;
          switch((Datatype)ads.attrType) {
            case INTEGER:
              memcpy(&tempi1, cmp2, sizeof(int));
              switch(op){
                case LT:
                  if (tempi <  tempi1) kg = 0 ;
                  break ;
                case LTE:
                  if (tempi <= tempi1) kg = 0 ;
                  break ;
                case GTE:
                  if (tempi >= tempi1) kg = 0 ;
                  break ;
                case GT:
                  if (tempi > tempi1) kg = 0 ;
                  break ;
                case NE:
                  if (tempi != tempi1) kg = 0 ;
                  break ;
                case EQ:
                  if (tempi1 == tempi) kg = 0 ;
              }
              break;
            case FLOAT:
              memcpy(&tempf1, cmp2, sizeof(float));
              switch(op){
                case LT:
                  if (tempf < tempf1) kg = 0 ;
                  break ;
                case LTE:
                  if (tempf <= tempf1) kg = 0 ;
                  break ;
                case GTE:
                  if (tempf >= tempf1) kg = 0 ;
                  break ;
                case GT:
                  if (tempf > tempf1) kg = 0 ;
                  break ;
                case NE:
                  if (tempf != tempf1) kg = 0 ;
                  break ;
                case EQ:
                  if (tempf1 == tempf) kg = 0 ;
              }
              break;
            case STRING:
              switch (op){
                case LT:
                  if (strcmp( cmp1, cmp2) < 0) kg = 0 ;
                  break ;
                case GT:
                  if (strcmp( cmp1, cmp2) > 0) kg = 0 ;
                  break ;
                case EQ:
                  if (strcmp( cmp1, cmp2) == 0) kg = 0 ;
                  break ;
                case NE:
                  if (strcmp( cmp1, cmp2) != 0) kg = 0 ;
              }
           }
          if (kg == 0){

            k = 0 ;
            for ( i = 0; i < len; i++) mydata[i] = 0 ;
            relstr.append("makerec") ;
            atrstr.append("makerec") ;
            for (i = 0; i < projCnt; i++){
              atrstr.erase(1) ;
              relstr.erase(1) ;
              n = strlen(projNames[i].attrName) ;
              atrstr.replace( 0, n, projNames[i].attrName) ;
              n = strlen(projNames[i].relName) ;
              relstr.replace( 0, n, projNames[i].relName) ;
              attrCat->getInfo( relstr, atrstr, ads2) ;
              if (strcmp(attr1[0].relName, relstr.c_str()) == 0){
                memcpy( mydata + k,(char *)rec.data + ads2.attrOffset, ads2.attrLen) ;
                k = k + ads2.attrLen ;
              }
              else{
                memcpy( mydata + k,(char *)rec1.data + ads2.attrOffset, ads2.attrLen);
                k = k + ads2.attrLen ;
              }
            }
            rec1.data = mydata ;
            rec1.length = len ;
            ifs->insertRecord( rec1, rid2) ;
            kg = 1 ;
          }
        }
      }
      delete hfs ;
      delete hfs1 ;
      delete ifs ;
      delete [] mydata ;

    return OK;
}

// implementation of sort merge join goes here
const Status QU_SM_Join(const string & result, 
		     const int projCnt, 
		     const attrInfo projNames[],
		     const attrInfo *attr1, 
		     const Operator op, 
		     const attrInfo *attr2)
{
    Status status;
    cout << "Doing SM Join" << endl;
    // part 5

    return OK;
}


// implementation of hash join goes here
const Status QU_Hash_Join(const string & result, 
		     const int projCnt, 
		     const attrInfo projNames[],
		     const attrInfo *attr1, 
		     const Operator op, 
		     const attrInfo *attr2)
{
    Status status;
    cout << "Doing Hash Join" << endl;
    // part5

    return OK;
}

const Status QU_Join(const string & result, 
		     const int projCnt, 
		     const attrInfo projNames[],
		     const attrInfo *attr1, 
		     const Operator op, 
		     const attrInfo *attr2)
{

  if ((JoinMethod == NLJoin) || ((JoinMethod == HashJoin) && (op != EQ)))
  {
	return QU_NL_Join (result, projCnt, projNames, attr1, op, attr2);
  }
  else
  if (JoinMethod == SMJoin)
  {
	return QU_SM_Join (result, projCnt, projNames, attr1, op, attr2);
  }
  else return QU_Hash_Join (result, projCnt, projNames, attr1, op, attr2);
}



const int matchRec(const Record & outerRec,
		   const Record & innerRec,
		   const AttrDesc & attrDesc1,
		   const AttrDesc & attrDesc2)
{
  int tmpInt1, tmpInt2;
  float tmpFloat1, tmpFloat2;

  switch(attrDesc1.attrType)
    {
    case INTEGER:
      memcpy(&tmpInt1, (char *)outerRec.data + attrDesc1.attrOffset, sizeof(int));
      memcpy(&tmpInt2, (char *)innerRec.data + attrDesc2.attrOffset, sizeof(int));
      return tmpInt1 - tmpInt2;

    case FLOAT:
      memcpy(&tmpFloat1, (char *)outerRec.data + attrDesc1.attrOffset, sizeof(float));
      memcpy(&tmpFloat2, (char *)innerRec.data + attrDesc2.attrOffset, sizeof(float));
      return int(tmpFloat1 - tmpFloat2);

    case STRING:
      return strcmp((char *)outerRec.data + attrDesc1.attrOffset, 
		    (char *)innerRec.data + attrDesc2.attrOffset);
    }

  return 0;
}