Skip to content

Commit

Permalink
get and set Attr implemented.
Browse files Browse the repository at this point in the history
  • Loading branch information
@vxtals
vxtals committed Nov 14, 2016
1 parent ddf3983 commit 782bd45
Show file tree
Hide file tree
Showing 2 changed files with 144 additions and 74 deletions.
63 changes: 27 additions & 36 deletions assign3/dev_test.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,46 +13,37 @@ main (void)

char *attrNames[3] = {"id","name","age"};
DataType dataTypes[3] = {DT_INT, DT_STRING, DT_INT};
int typeLength[3] = {4,255,4};
int typeLength[3] = {0,10,0};
int keyAttrs[2] = {0, 2};
Schema *people = createSchema(3, attrNames, dataTypes, typeLength, 2, keyAttrs);

createTable("prueba1", people);
createTable("people", people);
RM_TableData *rel = malloc(sizeof(RM_TableData));
openTable(rel, "prueba1");
Record *record = malloc(sizeof(Record));
record->data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
insertRecord(rel, record);
deleteRecord(rel, record->id);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
insertRecord(rel, record);
Record *record2 = malloc(sizeof(Record));
(record2->id).page = 1;
(record2->id).slot = 12;
deleteRecord(rel, record2->id);
record2->data = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
insertRecord(rel, record2);
insertRecord(rel, record2);
Record *record3 = malloc(sizeof(Record));
(record3->id).page = 1;
(record3->id).slot = 10;
deleteRecord(rel, record3->id);
record3->data = "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc";
insertRecord(rel, record3);
insertRecord(rel, record3);
openTable(rel, "people");
Value *value1 = malloc(sizeof(Value));
value1->dt = DT_INT;
value1->v.intV = 5;
Value *value2 = malloc(sizeof(Value));
value2->dt = DT_STRING;
value2->v.stringV = "123";
Value *value3 = malloc(sizeof(Value));
value3->dt = DT_FLOAT;
value3->v.intV = 5;
Record *record6;
createRecord(&record6, people);
setAttr(record6, people, 0, value1);
setAttr(record6, people, 2, value3);
setAttr(record6, people, 1, value2);
insertRecord(rel,record6);
Record *record7;
createRecord(&record7, people);
getRecord(rel,record6->id,record7);
Value *value5;
getAttr(record7, people, 1, &value5);
printf("%s\n", value5->v.stringV);
closeTable(rel);
return 0;
}



155 changes: 117 additions & 38 deletions assign3/record_mgr.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,9 +8,11 @@
#include "expr.h"
#include "tables.h"

#define FULL_SLOT 0x01

short getNumPagesSchema(char *name);
int calculatePageCap(Schema *schema);

int getAttrOffset(Schema *schema, int attrNum);
void printSchema(Schema *schema);

typedef struct TableHandle
Expand Down Expand Up @@ -109,7 +111,9 @@ RC closeTable (RM_TableData *rel){
//TODO: UPDATE INFO: FREE SPACE
//TODO: CALL BUFFER TO FINISH
TableHandle *tableHandle = rel->mgmtData;
freeSchema(rel->schema);
shutdownBufferPool(tableHandle->bm);
free(tableHandle);
return RC_OK;
}
RC deleteTable (char *name){
Expand All @@ -126,32 +130,27 @@ int getNumTuples (RM_TableData *rel){

// handling records in a table
RC insertRecord (RM_TableData *rel, Record *record){
//TODO: Busqueda de pagina
// TEMPORAL
int page, freeSlot, newFreeSlot, recordOffset;
char *pageData;
TableHandle *tableHandle = rel->mgmtData;
BM_PageHandle *pageHandle = malloc(sizeof(BM_PageHandle));
//READ PAGE FROM DISK IF IS NOT ALREADY IN BUFFER
int page = tableHandle->freeSpacePage;
pinPage (tableHandle->bm, pageHandle, page);
page = tableHandle->freeSpacePage;
pinPage(tableHandle->bm, pageHandle, page);
//LOOK FOR FREE SLOT
int freeSlot = pageHandle->data[0];
char *data = pageHandle->data + sizeof(int);
// int freeSlot = 0;
// char full = 0x01;
// while(((pageHandle->data[freeSlot*sizeof(char)]) == 0x01) && freeSlot < tableHandle->pageCap){
// freeSlot++;
// }
freeSlot = pageHandle->data[0];
pageData = pageHandle->data + sizeof(int);
if(freeSlot >= 0){
data[freeSlot*sizeof(char)] = 0x01; //SET SLOT TO FULL
int recordOffset = tableHandle->pageCap*sizeof(char) + freeSlot*(tableHandle->recordSize+sizeof(RID));
data[recordOffset] = page;
pageData[freeSlot*sizeof(char)] = FULL_SLOT; //SET SLOT TO FULL
recordOffset = tableHandle->pageCap*sizeof(char) + freeSlot*(tableHandle->recordSize+sizeof(RID));
pageData[recordOffset] = page;
recordOffset += sizeof(int);
data[recordOffset] = freeSlot;
pageData[recordOffset] = freeSlot;
recordOffset += sizeof(int);
(record->id).page = page;
(record->id).slot = freeSlot;
// WRITE RECORD DATA
memcpy(data + recordOffset, record->data, tableHandle->recordSize);
memcpy(pageData + recordOffset, record->data, tableHandle->recordSize);
// BUFFER MANAGER OPERATIONS
}else{
//FULL PAGE
Expand All @@ -163,9 +162,8 @@ RC insertRecord (RM_TableData *rel, Record *record){
unpinPage(tableHandle->bm, pageHandle);
return insertRecord(rel, record);
}
int newFreeSlot = freeSlot;
char full = 0x01;
while(((data[newFreeSlot*sizeof(char)]) == 0x01) && newFreeSlot < tableHandle->pageCap){
newFreeSlot = freeSlot;
while(((pageData[newFreeSlot*sizeof(char)]) == FULL_SLOT) && newFreeSlot < tableHandle->pageCap){
newFreeSlot++;
}
if(newFreeSlot < tableHandle->pageCap){
Expand All @@ -178,13 +176,14 @@ RC insertRecord (RM_TableData *rel, Record *record){
return RC_OK;
}
RC deleteRecord (RM_TableData *rel, RID id){
int recordOffset;
TableHandle *tableHandle = rel->mgmtData;
BM_PageHandle *pageHandle = malloc(sizeof(BM_PageHandle));
pinPage (tableHandle->bm, pageHandle, id.page);
// SET TO EMPTY IN HEADER DIRECTORY
pageHandle->data[sizeof(int) + id.slot*sizeof(char)] = 0x00;
// I THINK THIS IS OPTIONAL
int recordOffset = sizeof(int) + tableHandle->pageCap * sizeof(char) + id.slot*(tableHandle->recordSize + sizeof(RID));
recordOffset = sizeof(int) + tableHandle->pageCap * sizeof(char) + id.slot*(tableHandle->recordSize + sizeof(RID));
memset(pageHandle->data + recordOffset,0,tableHandle->recordSize + sizeof(RID)); // Set record to 0
// BUFFER MANAGER OPERATIONS
if(pageHandle->data[0] > id.slot || pageHandle->data[0] == -1){
Expand All @@ -203,24 +202,25 @@ RC deleteRecord (RM_TableData *rel, RID id){
return RC_OK;
}
RC updateRecord (RM_TableData *rel, Record *record){
int recordOffset;
RID id;
TableHandle *tableHandle = rel->mgmtData;
BM_PageHandle *pageHandle = malloc(sizeof(BM_PageHandle));
RID id = record->id;
id = record->id;
pinPage (tableHandle->bm, pageHandle, id.page);
int recordOffset = sizeof(int) + tableHandle->pageCap * sizeof(char) + id.slot*(tableHandle->recordSize + sizeof(RID)) + sizeof(RID);
printf("record offset %i\n", recordOffset);
recordOffset = sizeof(int) + tableHandle->pageCap * sizeof(char) + id.slot*(tableHandle->recordSize + sizeof(RID)) + sizeof(RID);
memcpy(pageHandle->data + recordOffset, record->data, tableHandle->recordSize);
markDirty(tableHandle->bm, pageHandle);
unpinPage(tableHandle->bm, pageHandle);
// GESTION DE ERRORES? SI NO HAY RECORD EN ESA UBICACION?
return RC_OK;
}
RC getRecord (RM_TableData *rel, RID id, Record *record){
int recordOffset;
TableHandle *tableHandle = rel->mgmtData;
BM_PageHandle *pageHandle = malloc(sizeof(BM_PageHandle));
pinPage (tableHandle->bm, pageHandle, id.page);
int recordOffset = sizeof(int) + tableHandle->pageCap * sizeof(char) + id.slot*(tableHandle->recordSize + sizeof(RID)) + sizeof(RID);
printf("%i\n", recordOffset);
recordOffset = sizeof(int) + tableHandle->pageCap * sizeof(char) + id.slot*(tableHandle->recordSize + sizeof(RID)) + sizeof(RID);
char *data = malloc(tableHandle->recordSize);
memcpy(data, pageHandle->data + recordOffset, tableHandle->recordSize);
unpinPage(tableHandle->bm, pageHandle);
Expand All @@ -244,7 +244,7 @@ RC closeScan (RM_ScanHandle *scan){
// dealing with schemas
int getRecordSize (Schema *schema){
int recordSize = 0;
for(int i = 0; i < schema->numAttr; i++){
for(int i = 0; i < schema->numAttr && recordSize != RC_RM_UNKOWN_DATATYPE; i++){
switch(schema->dataTypes[i]){
case DT_INT:
recordSize += sizeof(int);
Expand All @@ -258,6 +258,8 @@ int getRecordSize (Schema *schema){
case DT_BOOL:
recordSize += sizeof(bool);
break;
default:
recordSize = RC_RM_UNKOWN_DATATYPE;
}
}
return recordSize;
Expand All @@ -273,32 +275,108 @@ Schema *createSchema (int numAttr, char **attrNames, DataType *dataTypes, int *t
return newSchema;
}
RC freeSchema (Schema *schema){
//TODO: QUE HACE ESTO?
free(schema->attrNames);
free(schema->dataTypes);
free(schema->typeLength);
free(schema->keyAttrs);
free(schema);
return RC_OK;
}

// dealing with records and attribute values
RC createRecord (Record **record, Schema *schema){
//TODO
// PORQUE ES UN DOBLE PUNTERO ??
*record = malloc(sizeof(Record));
(*record)->data = calloc(1, getRecordSize(schema));
return RC_OK;
}

RC freeRecord (Record *record){
// TODO
// QUE HACE ESTO
free(record->data);
free(record);
return RC_OK;
}
RC getAttr (Record *record, Schema *schema, int attrNum, Value **value){
//TODO: 2/10
return RC_OK;
int attrOffset;
RC code = RC_OK;
if((attrOffset = getAttrOffset(schema, attrNum)) >= 0){
switch(schema->dataTypes[attrNum]){
case DT_INT:
*value = malloc(sizeof(DataType) + sizeof(int));
memcpy(&((*value)->v.intV),record->data + attrOffset, sizeof(int));
break;
case DT_STRING:
*value = malloc(sizeof(DataType) + schema->typeLength[attrNum] + 1);
memcpy((*value)->v.stringV,record->data + attrOffset, schema->typeLength[attrNum]);
// Adds end of string
(*value)->v.stringV[schema->typeLength[attrNum]] = 0x00;
break;
case DT_FLOAT:
*value = malloc(sizeof(DataType) + sizeof(float));
memcpy(&((*value)->v.floatV),record->data + attrOffset, sizeof(float));
break;
case DT_BOOL:
*value = malloc(sizeof(DataType) + sizeof(bool));
memcpy(&((*value)->v.boolV),record->data + attrOffset, sizeof(bool));
break;
default:
code = RC_RM_UNKOWN_DATATYPE;
}
}else{
code = RC_RM_UNKOWN_DATATYPE;
}
return code;
}
RC setAttr (Record *record, Schema *schema, int attrNum, Value *value){
//TODO: 2/10
return RC_OK;
int attrOffset;
RC code = RC_OK;
if((attrOffset = getAttrOffset(schema, attrNum)) >= 0){
switch(schema->dataTypes[attrNum]){
case DT_INT:
memcpy(record->data + attrOffset, &(value->v.intV), sizeof(int));
break;
case DT_STRING:
memcpy(record->data + attrOffset, value->v.stringV, strlen(value->v.stringV));
break;
case DT_FLOAT:
memcpy(record->data + attrOffset, &(value->v.floatV), sizeof(float));
break;
case DT_BOOL:
memcpy(record->data + attrOffset, &(value->v.boolV), sizeof(bool));
break;
default:
code = RC_RM_UNKOWN_DATATYPE;
}
}else{
code = RC_RM_UNKOWN_DATATYPE;
}
return code;
}

// Auxiliary functions

int getAttrOffset(Schema *schema, int attrNum){
int attrOffset = 0;
for(int i = 0; i < attrNum && attrOffset >= 0; i++){
switch(schema->dataTypes[i]){
case DT_INT:
attrOffset += sizeof(int);
break;
case DT_STRING:
attrOffset += schema->typeLength[i];
break;
case DT_FLOAT:
attrOffset += sizeof(float);
break;
case DT_BOOL:
attrOffset += sizeof(bool);
break;
default:
attrOffset = -1;
}
}
return attrOffset;
}

short getNumPagesSchema(char *name){
FILE *file = fopen(name, "r+");
fseek(file, sizeof(SM_FileHeader), SEEK_SET);
Expand All @@ -308,9 +386,10 @@ short getNumPagesSchema(char *name){
}

int calculatePageCap(Schema *schema){
int recordSize = getRecordSize(schema) + (int)sizeof(RID);
int recordSize, numRecords;
recordSize = getRecordSize(schema) + (int)sizeof(RID);
// -1 is for free slot pointer
int numRecords = (PAGE_SIZE - 1)/(sizeof(char) + recordSize);
numRecords = (PAGE_SIZE - 1)/(sizeof(char) + recordSize);
}

void printSchema(Schema *schema){
Expand Down

0 comments on commit 782bd45

Please sign in to comment.