예제 #1
0
void changeDataType(char *string, Record *rec, Schema *s, int index) {
	Value *value;
	char *tempString;
		bool boolVal;
		int intVal;
		float floatVal;

	switch (s->dataTypes[index]) {
	case DT_STRING:
		MAKE_STRING_VALUE(value, string);
		setAttributeVal(rec, s, index, value,10);
		break;
	case DT_BOOL:
		if (string[0] == 't')
			boolVal = TRUE;
		else
			boolVal = FALSE;
		MAKE_VALUE(value, DT_BOOL, boolVal);
		setAttributeVal(rec, s, index, value,10);
		break;
	case DT_INT:
		intVal = strtol(string, &tempString, 10);
		MAKE_VALUE(value, DT_INT, intVal);
		setAttributeVal(rec, s, index, value,10);
		break;
	case DT_FLOAT:
		floatVal = strtof(string, NULL);
		MAKE_VALUE(value, DT_FLOAT, floatVal);
		setAttributeVal(rec, s, index, value,10);
		break;
	}
	freeVal(value);
}
예제 #2
0
Record *
testRecord(Schema *schema, int a, char *b, int c)
{
	Record *result;
	Value *value;

	TEST_CHECK(createRecord(&result, schema));

	MAKE_VALUE(value, DT_INT, a);
	TEST_CHECK(setAttr(result, schema, 0, value));
	freeVal(value);

	MAKE_STRING_VALUE(value, b);
	TEST_CHECK(setAttr(result, schema, 1, value));
	freeVal(value);

	MAKE_VALUE(value, DT_INT, c);
	TEST_CHECK(setAttr(result, schema, 2, value));
	freeVal(value);

	return result;
}
예제 #3
0
Record *
testRecord(Schema *schema, int a, char *b, int c)
{
	//printf("\n in here test");
  Record *result;
  Value *value;

  TEST_CHECK(createRecord(&result, schema));
	printf("\n created record");
  MAKE_VALUE(value, DT_INT, a);
  TEST_CHECK(setAttr(result, schema, 0, value));
  freeVal(value);

  MAKE_STRING_VALUE(value, b);
  TEST_CHECK(setAttr(result, schema, 1, value));
  freeVal(value);

  MAKE_VALUE(value, DT_INT, c);
  TEST_CHECK(setAttr(result, schema, 2, value));
 // printf("\n outta here %s",result->data);
  freeVal(value);

  return result;
}
예제 #4
0
char*
deserializeRecordKey(char *desiralize_record_str, Schema *schema)
{

	int i, lastAttr = schema->numAttr-1;
	int intVal;
	float floatVal;
	bool boolVal;

	Value *value;
	Record *record = (Record*)malloc(sizeof(Record*));
	record->data = (char*)malloc(sizeof(char*));

	char *splitStart, *splitEnd;
	char *resultRecord;

	splitStart = strtok(desiralize_record_str,"(");
	strcpy(resultRecord,"");
	for(i=0;i< schema->numAttr;i++)
	{
		splitEnd = strtok(NULL,":");

		if(i == lastAttr)
		{
			splitEnd = strtok(NULL,")");
		}
		else
		{
			splitEnd = strtok(NULL,",");
		}

		switch(schema->dataTypes[i])
		{
		case DT_INT:
			intVal = strtol(splitEnd, &splitStart, 10);
			strcat(resultRecord,splitEnd);
			strcat(resultRecord,",");
			MAKE_VALUE(value,DT_INT,intVal);
			setAttr(record,schema,i,value);
			free(value);
			break;

		case DT_FLOAT:
			floatVal = strtof(splitEnd, NULL);
			strcat(resultRecord,splitEnd);
			strcat(resultRecord,",");
			MAKE_VALUE(value,DT_FLOAT,floatVal);
			setAttr(record,schema,i,value);
			free(value);
			break;

		case DT_BOOL:
			boolVal = (splitEnd[0] == 't') ? TRUE: FALSE;
			strcat(resultRecord,splitEnd);
			strcat(resultRecord,",");
			MAKE_VALUE(value,DT_BOOL,boolVal);
			setAttr(record,schema,i,value);
			free(value);
			break;

		case DT_STRING:
			MAKE_STRING_VALUE(value,splitEnd);
			strcat(resultRecord,splitEnd);
			strcat(resultRecord,",");
			setAttr (record,schema,i,value);
			freeVal(value);
			break;
		}

	}

return resultRecord;
}
예제 #5
0
파일: parser.c 프로젝트: ngosala/Projects
/*
 * AUTHOR: Nikhil  
 * DESC: Parse the sql stmts and execute the respective methods
 */
int main(int argc, char *argv[]){

    char readline[ARRAY_LENGTH];
    char temparray[ARRAY_LENGTH];
    char *temp;
    char *temp1;
    char *tableName;
    char *length;
    int charLength;
    int numattr=0,k,count=0,numTuples=0;
    Schema *schema;
    RID *rids;
    char columns[ARRAY_LENGTH][ARRAY_LENGTH];
    
   
    int i=0,j=0;
    
        if(fork() == 0) {
			execv("/usr/bin/clear", argv);
			exit(1);
		}
	else wait(NULL);
        
        printf("\n SQL parser\n");
        
        while(1){
        printf("\n >>");
        
        fflush(stdin);
        gets(readline);
        
        memcpy(temparray,readline,sizeof(readline));
        
        if(strstr(readline,"create table") || strstr(readline,"CREATE TABLE")){
        
            parser(readline,argv);
            
            tableName=strtok(argv[2],"(");
            
            temp=strstr(temparray,"(");
            
            temp++;
            
            temp1=strtok(temp,",");
            while(temp1!=NULL){
                strcpy(columns[i],temp1);
            temp1=strtok(NULL,",");
            i++;
            }
            j=i;
            numattr=j;
   strcpy(columns[i-1],strtok(columns[i-1],")"));

    char* colname[numattr];
    char* datatype[numattr];
    DataType dt[numattr];
    int sizes[numattr];
     int keyattr[numattr];
            for(i=0;i<j;i++){
          
       
                parser(columns[i],argv);
                
                colname[i]=argv[0];
                datatype[i]=argv[1];
                if(strstr(Upper(datatype[i]),"VARCHAR")) {
                     dt[i]=DT_STRING;
                    length=strtok(datatype[i],"(");
                    length=strtok(NULL,"(");
                    charLength=strtok(length,")");
                    if(length==NULL){
                    
                        printf("\nWrong Format");
                                 break;
                    }
                        sizes[i]=atoi(charLength);
                }
                        if(strstr(Upper(datatype[i]),"INT")){
                        dt[i]=DT_INT;
                        }
                         else if(strstr(Upper(datatype[i]),"FLOAT")){
                            dt[i]=DT_FLOAT;
                        }
                    else if(strstr(Upper(datatype[i]),"BOOL")){
                            dt[i]=DT_BOOL;                        }
                
                
                else{
                 sizes[i]=0;
                }
                
                if(strstr(Upper(datatype[i]),"PRIMARYKEY")){
                    
                keyattr[i]=1;
                    
                }
                else{
                 keyattr[i]=0;
                }
               
                
            }
     
     for(k=0;k<sizeof(keyattr)/sizeof(keyattr[0]);k++){
         if(keyattr[i]==1){
             count++;
          
          }
   
     }
     if(count>0){
         
         printf("wrong format...cannot contain more than one primary key");
         break;
     
     }
 
     schema=testSchema(numattr,colname,dt,sizes,keyattr);
     initRecordManager(NULL);
     createTable(Upper(tableName),schema);
     printf("Table Created Successfully");
     shutdownRecordManager();

        }
        
        if(strstr(Upper(readline),"INSERT INTO")){
        
              parser(readline,argv);
            
            tableName=strtok(argv[2],"(");
            
            temp=strtok(temparray,"(");
            temp=strtok(NULL,"(");
            strcpy(columns[0],temp);
       strcpy(columns[0],strtok(columns[0],")"));
       
        char* values[i];
        i=0;
       values[0]=strtok(columns[0],",");
       while(values[i]!=NULL){
           i++;
          values[i]=strtok(NULL,",");
       }
       
             numTuples=i;
             rids = (RID *) malloc(sizeof(RID) * numTuples);
             RM_TableData *table = (RM_TableData *) malloc(sizeof(RM_TableData));
             initRecordManager(NULL);
        int fd = open(Upper(tableName), O_WRONLY);    
        if(fd<0){
            printf("Database Doesn't Exist");
            break;
        }

                openTable(table, tableName);
                schema=table->schema;
                 Record *result;
                 Value *value;
                createRecord(&result, schema);
                for(i = 0; i < numTuples; i++)
                {
                  if(schema->dataTypes[i]==DT_INT || schema->dataTypes[i]==DT_FLOAT || schema->dataTypes[i]==DT_BOOL){
                  MAKE_VALUE(value, schema->dataTypes[i], atoi(values[i]));
                  }
                  if(schema->dataTypes[i]==DT_STRING){
                  MAKE_STRING_VALUE(value, values[i]);
                  }
               
                   setAttr(result, schema, i, value);
                   freeVal(value);
                 
                }
                  insertRecord(table,result); 
                  rids[i] = result->id;
printf("Inserted Successfully");
               closeTable(table);
               shutdownRecordManager();
              
             
                  }
        
         if(strstr(Upper(readline),"UPDATE TABLE")){
             
           parser(readline,argv);
            
            tableName=strtok(argv[2],"(");
            
            temp1=strtok(temparray,"(");
            temp=strtok(NULL,"(");
            strcpy(columns[0],temp);
       strcpy(columns[0],strtok(columns[0],")"));
       
       temp1=strtok(temp1,"=");
       temp1=strtok(NULL,"=");
       
        char* values[i];
        i=0;
       values[0]=strtok(columns[0],",");
       while(values[i]!=NULL){
           i++;
          values[i]=strtok(NULL,",");
       }
       
             numTuples=i;
             rids = (RID *) malloc(sizeof(RID) * numTuples);
             RM_TableData *table = (RM_TableData *) malloc(sizeof(RM_TableData));
             initRecordManager(NULL);
        int fd = open(Upper(tableName), O_WRONLY);    
        if(fd<0){
            printf("Database Doesn't Exist");
            break;
        }
       
                openTable(table, Upper(tableName));
                schema=table->schema;
                               
                  Record *result;
                  Value *value;
                  createRecord(&result, schema);
                for(i = 0; i < numTuples; i++)

                {
                  if(schema->dataTypes[i]==DT_INT || schema->dataTypes[i]==DT_FLOAT || schema->dataTypes[i]==DT_BOOL){
                  MAKE_VALUE(value, schema->dataTypes[i], atoi(values[i]));
                  }
                  if(schema->dataTypes[i]==DT_STRING){
                  MAKE_STRING_VALUE(value, values[i]);
                  }
               
                   setAttr(result, schema, i, value);
                   freeVal(value);
            
                   
                }
                       result->id=rids[i] ;
                   updateRecord(table,result);
printf("Updated Successfully");
               closeTable(table);
               shutdownRecordManager();
               
         }
        
         if(strstr(Upper(readline),"DELETE FROM")){
             
           parser(readline,argv);
            
            tableName=strtok(argv[2],"(");
            
            temp=strtok(temparray,"(");
            temp=strtok(NULL,"(");
            strcpy(columns[0],temp);
       strcpy(columns[0],strtok(columns[0],")"));
       
       int r_id=atoi(columns[0]);
             numTuples=i;
             rids = (RID *) malloc(sizeof(RID) * numTuples);
RM_TableData *table = (RM_TableData *) malloc(sizeof(RM_TableData));
                           initRecordManager(NULL);
        int fd = open(Upper(tableName), O_WRONLY);    
        if(fd<0){
            printf("Database Doesn't Exist");
            break;
        }

                openTable(table, Upper(tableName));
                schema=table->schema;
               deleteRecord(table,rids[r_id]);
printf("Deleted Successfully");
               closeTable(table);
               shutdownRecordManager();
         }
              
        
        }
        }
예제 #6
0
int
main (void) 
{
    initRecordManager(NULL);
    int in;
    int cl = 0;
    while(cl == 0){
        printf("What to do:\n1.Add new table\n2.insert\n3.update\n4.delete\n5.scan\n6.print table\n7.close\n");
        in=0;
        scanf("%d",&in);
        RM_TableData *table;
        Record *result,*r;
        Value *value,*v;
        int i,j;
        switch(in)
        {
            case 0:
                printf("invalid input\n");
                break;
            case 1:
                printf("\nAdding new table:\n");
                printf("Table name: ");
                char tbn[50];
                scanf("%s",tbn);
                char* tbnp = (char *) malloc(sizeof(char)*sizeof(tbn));
                memcpy(tbnp,tbn,sizeof(tbn));
                printf("number of attributes: ");
                int nat = 0;
                scanf("%d",&nat);
                printf("number of keys: ");
                int nk = 0;
                scanf("%d",&nk);
                Schema *sch;
                char **names = (char **) malloc(sizeof(char*) * nat);
                DataType* dt = (DataType *) malloc(sizeof(DataType) * nat);
                int* sizes = (int *) malloc(sizeof(int) * nat);
                int* keys = (int *) malloc(sizeof(int) * nk);
                int kptr = 0;
                for(i=0;i<nat;i++){
                    printf("Attribute %d name:  ", i+1);
                    char buf[100];
                    scanf("%s", buf);
                    char* tmp = (char *) malloc(sizeof(char)*sizeof(buf));
                    memcpy(tmp,buf,sizeof(buf));
                    names[i] = tmp;
                    printf("Attribute %d datatype: [I/S/F/B]: ", i+1);
                    char dtp;
                    scanf(" %c", &dtp);
                    //printf("\ndtp = %c", dtp);
                    switch(dtp)
                    {
                        case 'I':
                            dt[i] = DT_INT;
                            sizes[i] = 0;
                            break;
                        case 'S':
                            dt[i] = DT_STRING;
                            printf("Attribute %d length:  ", i+1);
                            scanf("%d",&sizes[i]);
                            printf("length is: %d\n", sizes[i]);
                            break;
                        case 'F':
                            dt[i] = DT_FLOAT;
                            sizes[i] = 0;
                            break;
                        case 'B':
                            dt[i] = DT_BOOL;
                            sizes[i] = 0;
                            break;
                            
                    }
                    printf("Is Attribute %d a key?: [Y/N] ", i+1);
                    char isk;
                    scanf(" %c", &isk);
                    if(isk == 'Y'){
                        keys[kptr] = i;
                        kptr++;
                    }
                    //printf("schema add: %s,%d,%c\n",names[i],sizes[i],isk);
                }
                sch = createSchema(nat,names,dt,sizes,nk,keys);
                createTable(tbnp,sch);
                break;
            case 2:
                printf("Insert record\n");
                printf("table name: ");
                char buf2[100];
                scanf("%s", buf2);
                char* tmp2 = (char *) malloc(sizeof(char)*sizeof(buf2));
                memcpy(tmp2,buf2,sizeof(buf2));
                table = (RM_TableData *) malloc(sizeof(RM_TableData));
                openTable(table, tmp2);
                createRecord(&result, table->schema);
               for(i=0;i<table->schema->numAttr;i++){
                    if(table->schema->dataTypes[i] == DT_INT)
                    {
                        printf("intput int attr[%d/%d] value -- %s: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                        int intt = 0;
                        scanf("%d",&intt);
                        //printf("\n%d is %d\n", i, intt);
                        MAKE_VALUE(value,DT_INT,intt);
                        setAttr(result, table->schema, i, value);
                        freeVal(value);
                    } else if (table->schema->dataTypes[i] == DT_STRING)
                    {
                        printf("intput string attr[%d/%d] value -- %s: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                        char instrbuf[100];
                        scanf("%s",instrbuf);
                        char* instr = (char *) malloc(sizeof(char)*sizeof(instrbuf));
                        memcpy(instr,instrbuf,sizeof(instrbuf));
                        MAKE_STRING_VALUE(value,instr);
                        setAttr(result, table->schema, i, value);
                        freeVal(value);
                    } else if (table->schema->dataTypes[i] == DT_FLOAT)
                    {
                        printf("intput float attr[%d/%d] value -- %s: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                        float infl;
                        scanf("%fl",&infl);
                        MAKE_VALUE(value,DT_FLOAT,infl);
                        setAttr(result, table->schema, i, value);
                        freeVal(value);
                    } else if (table->schema->dataTypes[i] == DT_BOOL)
                    {
                        printf("intput boolean attr[%d/%d] value -- %s [T/F]: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                        char inbl;
                        scanf(" %c",&inbl);
                        if(inbl == 'T'){
                            MAKE_VALUE(value,DT_BOOL,true);
                        }
                        else if (inbl == 'F'){
                            MAKE_VALUE(value,DT_BOOL,false);
                        }
                        setAttr(result, table->schema, i, value);
                        freeVal(value);
                    }
                    if(i==table->schema->numAttr-1){
                        printf("\n");
                    }
                }
                insertRecord(table,result);
                
                break;
            case 3:
                printf("update record\n");
                printf("table name: ");
                char buf3[100];
                scanf("%s", buf3);
                char* tmp3 = (char *) malloc(sizeof(char)*sizeof(buf3));
                memcpy(tmp3,buf3,sizeof(buf3));
                table = (RM_TableData *) malloc(sizeof(RM_TableData));
                openTable(table, tmp3);
                createRecord(&result, table->schema);
                
                r = (Record *) malloc(sizeof(Record));
                RM_ScanHandle *sc = (RM_ScanHandle *) malloc(sizeof(RM_ScanHandle));
                startScan(table, sc, NULL);
                
                printf("Select record to update: \n");
                j=0;
                int rids[100][2];
                while(next(sc, r) == RC_OK){
                    printf("(%d)   ",j+1);
                    rids[j][0] = r->id.page;
                    rids[j][1] = r->id.slot;
                    for(i=0;i<table->schema->numAttr;i++){
                        if(table->schema->dataTypes[i] == DT_INT)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15d",v->v.intV);
                        } else if(table->schema->dataTypes[i] == DT_STRING)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15s",v->v.stringV);
                        } else if(table->schema->dataTypes[i] == DT_FLOAT)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15fl",v->v.floatV);
                        } else if(table->schema->dataTypes[i] == DT_BOOL)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15s",v->v.boolV ? "true" : "false");
                        }
                    }
                    printf("\n");
                    j++;
                }
                
                int sele;
                scanf("%d", &sele);
                sele--;
                if(sele >= 0 && sele < j+1){
                    createRecord(&result, table->schema);
                    for(i=0;i<table->schema->numAttr;i++){
                        if(table->schema->dataTypes[i] == DT_INT)
                        {
                            printf("intput int attr[%d/%d] value -- %s: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                            int intt = 0;
                            scanf("%d",&intt);
                            //printf("\n%d is %d\n", i, intt);
                            MAKE_VALUE(value,DT_INT,intt);
                            setAttr(result, table->schema, i, value);
                            freeVal(value);
                        } else if (table->schema->dataTypes[i] == DT_STRING)
                        {
                            printf("intput string attr[%d/%d] value -- %s: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                            char instrbuf[100];
                            scanf("%s",instrbuf);
                            char* instr = (char *) malloc(sizeof(char)*sizeof(instrbuf));
                            memcpy(instr,instrbuf,sizeof(instrbuf));
                            MAKE_STRING_VALUE(value,instr);
                            setAttr(result, table->schema, i, value);
                            freeVal(value);
                        } else if (table->schema->dataTypes[i] == DT_FLOAT)
                        {
                            printf("intput float attr[%d/%d] value -- %s: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                            float infl;
                            scanf("%fl",&infl);
                            MAKE_VALUE(value,DT_FLOAT,infl);
                            setAttr(result, table->schema, i, value);
                            freeVal(value);
                        } else if (table->schema->dataTypes[i] == DT_BOOL)
                        {
                            printf("intput boolean attr[%d/%d] value -- %s [T/F]: ", i+1,table->schema->numAttr,table->schema->attrNames[i]);
                            char inbl;
                            scanf(" %c",&inbl);
                            if(inbl == 'T'){
                                MAKE_VALUE(value,DT_BOOL,true);
                            }
                            else if (inbl == 'F'){
                                MAKE_VALUE(value,DT_BOOL,false);
                            }
                            setAttr(result, table->schema, i, value);
                            freeVal(value);
                        }
                        if(i==table->schema->numAttr-1){
                            printf("\n");
                        }
                    }
                    result->id.page = rids[sele][0];
                    result->id.slot = rids[sele][1];
                    updateRecord(table,result);
                }
                break;
            case 4:
                printf("delete record\n");
                printf("table name: ");
                char buf4[100];
                scanf("%s", buf4);
                char* tmp4 = (char *) malloc(sizeof(char)*sizeof(buf3));
                memcpy(tmp4,buf4,sizeof(buf4));
                table = (RM_TableData *) malloc(sizeof(RM_TableData));
                openTable(table, tmp4);
                createRecord(&result, table->schema);
                
                r = (Record *) malloc(sizeof(Record));
                RM_ScanHandle *sc2 = (RM_ScanHandle *) malloc(sizeof(RM_ScanHandle));
                startScan(table, sc2, NULL);
                
                printf("Select record to delete: \n");
                j=0;
                int rids2[100][2];
                while(next(sc2, r) == RC_OK){
                    printf("(%d)   ",j+1);
                    rids2[j][0] = r->id.page;
                    rids2[j][1] = r->id.slot;
                    for(i=0;i<table->schema->numAttr;i++){
                        if(table->schema->dataTypes[i] == DT_INT)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15d",v->v.intV);
                        } else if(table->schema->dataTypes[i] == DT_STRING)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15s",v->v.stringV);
                        } else if(table->schema->dataTypes[i] == DT_FLOAT)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15fl",v->v.floatV);
                        } else if(table->schema->dataTypes[i] == DT_BOOL)
                        {
                            getAttr(r,table->schema,i,&v);
                            printf("%-15s",v->v.boolV ? "true" : "false");
                        }
                    }
                    printf("\n");
                    j++;
                }
                
                int sele2;
                scanf("%d", &sele2);
                sele2--;
                if(sele2 >= 0 && sele2 < j+1){
                    RID rid;
                    rid.page = rids[sele2][0];
                    rid.slot = rids[sele2][1];
                    deleteRecord(table,rid);
                }
                break;
            case 5:
                printf("scan\n");
                break;
            case 6:
                printf("table name: ");
                char buf[100];
                scanf("%s", buf);
                char* tmp = (char *) malloc(sizeof(char)*sizeof(buf));
                memcpy(tmp,buf,sizeof(buf));
                printtable(buf);
                break;
            case 7:
                cl = 1;
                break;
            default:
                printf("invalid input\n");
                break;
        }
    }
}