int UT_buildindex( int argc, char* argv[] )
{
relDesc * relInfo;
attrDesc * attrInfo;
char * relName, * attrName, * record, * value;
int relRecId, attrRecId, return_val, recId, indexFileDesc, fileDesc;
if ( argc != 3 ) {
printf( "Error: Three arguments expected for function UT_buildindex\n" );
return AMINIREL_GE;
}
inline cleanup() {
/* apodesmeush dynamikhs mnhmhs */
if ( relInfo != NULL ) {
free( relInfo );
}
if ( attrInfo != NULL ) {
free( attrInfo );
}
if ( record != NULL ) {
free( record );
}
/* Kleinoyme arxeia pou isws anoiksame */
/* kleinoyme to arxeio ths sxeshs */
if ( fileDesc >= 0 ) {
if ( HF_CloseFile( fileDesc ) != HFE_OK ) {
HF_PrintError( "Could not close relation's file" );
return_val = AMINIREL_GE;
}
}
/* kleinoyme to eyrethrio */
if ( indexFileDesc >= 0 ) {
if ( AM_CloseIndex( indexFileDesc ) != AME_OK ) {
AM_PrintError( "Could not close index" );
return_val = AMINIREL_GE;
}
}
}
/* initialization */
relName = argv[1];
attrName = argv[2];
relInfo = NULL;
attrInfo = NULL;
record = NULL;
return_val = AMINIREL_OK;
fileDesc = indexFileDesc = AMINIREL_INVALID;
/* kanoume retrieve tis plhrofories gia th sxesh me onoma relName */
if (( relInfo = getRelation( relName, &relRecId ) ) == NULL ) {
printf( "Error: Could not retrieve information about relation '%s'\n", relName );
return AMINIREL_GE;
}
/* Mias kai mporoume na exoume to poly 1 eurethrio gia kathe attribute, an o arithmos twn eurethriwn
isoutai me ton arithmo twn attributes tote de ginetai na ftiaksoume allo index */
if ( relInfo->attrcnt == relInfo->indexcnt ) {
printf( "Error: Cannot create yet another index for any of %s's attributes, delete one first\n", relName );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* afou mporesame na vroume th sxesh relName, twra kanoume retrieve tis plhrofories gia to attribute ths */
if (( attrInfo = getAttribute( relName, attrName, &attrRecId ) ) == NULL ) {
printf( "Error: Could not retrieve information about attribute '%s' of relation %s\n", attrName, relName );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* Vrhkame to attribute, twra elegxoume an yparxei hdh ena eurethrio gia to attribute! */
if ( attrInfo->indexed == TRUE ) {
printf( "Error: There is already an index for attribute '%s' of relation '%s'\n", attrName, relName );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
else {
/* Mporoume na ftiaksoume neo eurethrio! :v */
/* Enhmerwnoume to indexed kai indexno tou attrInfo */
attrInfo->indexed = TRUE;
attrInfo->indexno = relInfo->indexcnt;
/* Enhmerwnoume ton indexcnt tou relInfo */
( relInfo->indexcnt )++;
/* Mias kai to HF epipedo mas epistrefei antigrafa twn records, emeis twra pou exoume tis nees versions twn records
prepei na diagrapsoume ta original kai na eisagoume pali ta kainourgia! */
/* Diagrafh ths eggrafhs sto relCat */
if ( HF_DeleteRec( this_db.relCatDesc, relRecId, sizeof( relDesc ) ) != HFE_OK ) {
HF_PrintError( "Could not Destroy record in relCat " );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* Diagrafh ths eggrafhs sto attrCat */
if ( HF_DeleteRec( this_db.attrCatDesc, attrRecId, sizeof( attrDesc ) ) != HFE_OK ) {
HF_PrintError( "Could not Destroy record in attrCat " );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* Eisagwgh twn updated records sto relCat */
if ( updateRelCat( relInfo ) != AMINIREL_OK ) {
printf( "ton hpie h update relcat\n" ) ;
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* kai sto attrCat */
if ( updateAttrCat( attrInfo ) != AMINIREL_OK ) {
printf( "ton hpie h update attrcat\n" ) ;
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* Telos, dhmioyrgoyme to eurethrio */
if ( AM_CreateIndex( relName, attrInfo->indexno, attrInfo->attrtype, attrInfo->attrlength ) != AME_OK ) {
AM_PrintError( "Could not Create Index in UT_buildindex() " );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/*
Twra pou dhmioyrghsame to eyrethrio, prepei oses eggrafes yparxoun sto arxeio ths sxeshs na perastoun sto
eurethrio!
*/
/* Desmeuoume xwro gia to xwro pou tha apothikeuetai to kathe record tou arxeiou */
if (( record = malloc( relInfo->relwidth ) ) == NULL ) {
printf( MEM_ERROR );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
memset( record, 0, relInfo->relwidth );
/* Anoigoume to eurethrio */
if (( indexFileDesc = AM_OpenIndex( relName, attrInfo->indexno ) ) < 0 ) {
AM_PrintError( "Could not Open Index in UT_buildindex() " );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* Anoigoume to arxeio ths sxeshs */
if (( fileDesc = HF_OpenFile( relName ) ) < 0 ) {
HF_PrintError( "Could not Open relation's file in UT_buildindex() " );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* ksekiname me thn prwth eggrafh */
if (( recId = HF_GetFirstRec( fileDesc, record, relInfo->relwidth ) ) < 0 ) {
/* Yparxei h periptwsh to arxeio na mhn exei eggrafes */
if ( recId != HFE_EOF ) {
HF_PrintError( "Could not retrieve first Record from relation's file" );
return_val = AMINIREL_GE;
}
cleanup();
return return_val;
}
/* Eisagoume oles tis eggrafes tou arxeiou ths sxeshs, sto eurethrio */
do {
/* Thetoume ton pointer value sto swsto shmeio ths eggrafhs ap opou tha paroume tin timh mas */
value = record + attrInfo->offset;
/* Eisagoume thn eggrafh sto eurethrio */
if ( AM_InsertEntry( indexFileDesc, attrInfo->attrtype, attrInfo->attrlength, value, recId ) != AME_OK ) {
AM_PrintError( "Could not insert into index" );
return_val = AMINIREL_GE;
}
}
while (( recId = HF_GetNextRec( fileDesc, recId, record , relInfo->relwidth ) ) >= 0 );
if ( recId != HFE_EOF ) {
HF_PrintError( "Error: Cannot build index\n" );
cleanup();
return return_val;
}
return_val = AMINIREL_OK;
}
cleanup();
return return_val;
}
int UT_destroy( int argc, char* argv[] )
{
int recId, attrcnt, indexcnt, return_val;
char * relName, * record;
relDesc * relPtr;
if ( argc != 2 ) {
printf( "Error: Two arguments expected for function UT_destroy\n" );
return AMINIREL_GE;
}
return_val = AMINIREL_OK;
inline cleanup() {
if ( record != NULL ) {
free( record );
}
if ( attrcnt > 0 ) {
printf( "Error: De diagraftikan ola ta records twn attributes ths sxeshs '%s'\n", relName );
return_val = AMINIREL_GE;
}
if ( indexcnt > 0 ) {
printf( "Error: De diagraftikan ola ta indeces twn attributes ths sxeshs '%s'\n", relName );
return_val = AMINIREL_GE;
}
if ( relName != NULL ) {
if ( HF_DestroyFile( relName ) != HFE_OK ) {
HF_PrintError( "Could not destroy relation in UT_destroy() " );
return_val = AMINIREL_GE;
}
}
}
/* Arxikopoihseis */
relName = argv[1];
record = NULL;
/* Kanoume retrieve tis plhrofories gia thn relation */
if (( relPtr = getRelation( relName, &recId ) ) == NULL ) {
printf( "Error: Cannot destroy relation '%s'. Could not retrieve information about relation.\n", argv[1] );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* an th vrhkame, swzoume posa attributes kai indeces exei, kai th diagrafoume */
attrcnt = relPtr->attrcnt;
indexcnt = relPtr->indexcnt;
free( relPtr );
/* Diagrafoume thn eggrafh sto relCat */
if ( HF_DeleteRec( this_db.relCatDesc, recId, sizeof( relDesc ) ) != HFE_OK ) {
HF_PrintError( "Error in UT Destroy: Could not delete record from relCat\n" );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* An th vrhkame sto relCat arxeio, anoigoume to attrCat arxeio gia na diagrapsoume ola ta records gia ta
attrcnt synolika attributes ths */
/* sto record tha apothikeyetai h eggrafh tou arxeiou attrCat */
if (( record = malloc( sizeof( attrDesc ) ) ) == NULL ) {
printf( MEM_ERROR );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
/* Ksekiname to psaksimo apo thn arxh tou arxeiou */
if (( recId = HF_GetFirstRec( this_db.attrCatDesc, record, sizeof( attrDesc ) ) ) < 0 ) {
HF_PrintError( "Could not retrieve first Record from file relCat" );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
do {
/* To onoma ths sxeshs einai sthn arxh tou record */
if ( !strcmp( record, relName ) ) {
char * pch;
int indexed;
/* to pch twra deixnei sto 'indexed' melos tou struct attrDesc */
pch = record + 2 * MAXNAME * sizeof( char ) + 2 * sizeof( int ) + sizeof( char );
memcpy( &indexed, pch, sizeof( int ) );
/* An exei eurethrio, prepei na diagrafei kai auto */
if ( indexed == TRUE ) {
int indexno;
/* to pch twra deixnei sto indexno melos tou struct attrDesc */
pch += sizeof( int );
memcpy( &indexno, pch, sizeof( int ) );
/* diagrafoume to eurethrio */
if ( AM_DestroyIndex( relName, indexno ) != AME_OK ) {
AM_PrintError( "Could not delete index: " );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
indexcnt--;
}
/* diagrafoume thn eggrafh tou attribute sto attrCat */
if ( HF_DeleteRec( this_db.attrCatDesc, recId, sizeof( attrDesc ) ) != HFE_OK ) {
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
attrcnt--;
}
}
while (( recId = HF_GetNextRec( this_db.attrCatDesc, recId, record , sizeof( attrDesc ) ) ) >= 0 );
if ( recId != HFE_EOF ) {
HF_PrintError( "Error in UT Destroy while deleting records from file attrCat\n" );
return_val = AMINIREL_GE;
cleanup();
return return_val;
}
cleanup();
return return_val;
}
void main()
{
int athletesFd;
int eventsFd;
int partsFd;
char *athleteRec;
char *eventRec;
char *partsRec;
int athletesScan;
int eventsScan;
int partsScan;
int eventId;
int eventRecId;
int partRecId;
int partsCounter = 0;
//Αρχικοποίηση Επιπέδου HF
HF_Init();
//’νοιγμα Αρχείου EVENTS
eventsFd = HF_OpenFile("EVENTS");
if (eventsFd < 0)
{
HF_PrintError("Error in HF_OpenFile called on EVENTS.");
return;
}
//’νοιγμα Αρχείου PARTICIPATIONS
partsFd = HF_OpenFile("PARTICIPATIONS");
if (partsFd < 0)
{
HF_PrintError("Error in HF_OpenFile called on PARTICIPATIONS.");
return;
}
//’νοιγμα Αρχείου ATHLETES
athletesFd = HF_OpenFile("ATHLETES");
if (athletesFd < 0)
{
HF_PrintError("Error in HF_OpenFile called on ATHLETES.");
return;
}
eventId= 30;
//Scan στο Αρχείο EVENTS με συνθήκη eventId >= "30"
eventsScan = HF_OpenFileScan(eventsFd,
HF_MAIN_EVENT_REC_SIZE,
'i',
sizeof(int),
0,
5,
(char *) &eventId);
if (eventsScan < 0)
{
HF_PrintError("HF_OpenFileScan on EVENTS failed");
return;
}
eventRec = (char *) malloc(HF_MAIN_EVENT_REC_SIZE);
if (eventRec == NULL)
{
printf("Event Record malloc failed\n");
return;
}
printf("Scan of file EVENTS with condition: eventId >= %d\n\n", eventId);
while ( (eventRecId = HF_FindNextRec(eventsScan, eventRec)) >= 0)
{
int recEventId;
char *eventName = (char *) malloc(HF_MAIN_EVENT_NAME_SIZE);
if (eventName == NULL)
{
printf("Event Name malloc failed\n");
return;
}
memcpy((void *) &recEventId, (void *) eventRec, sizeof(int));
eventRec += sizeof(int);
memcpy((void *) eventName, (void *) eventRec, HF_MAIN_EVENT_NAME_SIZE);
eventRec += HF_MAIN_EVENT_NAME_SIZE;
printf("Found Event Record: recId=%d, data=(%d, %s)\n", eventRecId, recEventId, eventName);
eventRec -= HF_MAIN_EVENT_REC_SIZE;
//Επαλήθευση της τιμής που ανακτήθηκε
if (recEventId < eventId)
{
printf("Invalid Event record\n");
return;
}
//Scan στο Αρχείο PARTICIPATIONS με συνθήκη eventId = recEventId
partsScan = HF_OpenFileScan(partsFd,
HF_MAIN_PARTICIPATION_REC_SIZE,
'i',
sizeof(int),
sizeof(int),
1,
(char *) &recEventId);
if (partsScan < 0)
{
HF_PrintError("HF_OpenFileScan on PARTICIPATIONS failed");
return;
}
partsRec = (char *) malloc(HF_MAIN_PARTICIPATION_REC_SIZE);
if (partsRec == NULL)
{
printf("Participation Record malloc failed\n");
return;
}
printf("Scan of file PARTICIPATIONS with condition: eventId = %d\n", recEventId);
while ( (partRecId = HF_FindNextRec(partsScan, partsRec)) >= 0)
{
int partAthId, partEvId;
char *partDate;
partDate = (char *) malloc(HF_MAIN_DATE_SIZE);
if (partDate == NULL)
{
printf("Participation Date malloc failed\n");
return;
}
memcpy((void *) &partAthId, (void *)partsRec, sizeof(int));
partsRec += sizeof(int);
memcpy((void *) &partEvId, (void *)partsRec, sizeof(int));
partsRec += sizeof(int);
memcpy((void *) partDate, (void *)partsRec, HF_MAIN_DATE_SIZE);
partsRec += HF_MAIN_DATE_SIZE;
printf("Found Participation Record: recId=%d, data=(%d, %d, %s)\n", partRecId, partAthId, partEvId, partDate);
partsRec -= HF_MAIN_PARTICIPATION_REC_SIZE;
//Επαλήθευση της τιμής που ανακτήθηκε
if (partEvId != recEventId)
{
HF_PrintError("Invalid Participation Record\n");
return;
}
//Scan στο Αρχείο ATHLETES με συνθήκη athleteId = partAthId
athletesScan = HF_OpenFileScan(athletesFd,
HF_MAIN_ATHLETE_REC_SIZE,
'i',
sizeof(int),
0,
1,
(char *) &partAthId);
if (athletesScan < 0)
{
HF_PrintError("HF_OpenFileScan on ATHLETES failed");
return;
}
athleteRec = (char *) malloc(HF_MAIN_ATHLETE_REC_SIZE);
if (athleteRec == NULL)
{
printf("Athlete Record malloc failed\n");
return;
}
printf("Scan of file ATHLETES with condition: athleteId = %d\n", partAthId);
if (HF_FindNextRec(athletesScan, athleteRec) >= 0)
{
int athleteId;
char *athleteName;
char *athleteSurname;
athleteName = (char *) malloc(HF_MAIN_NAME_SIZE);
if (athleteName == NULL)
{
printf("Athlete Name malloc failed\n");
return;
}
athleteSurname = (char *) malloc(HF_MAIN_NAME_SIZE);
if (athleteSurname == NULL)
{
printf("Athlete Surname malloc failed\n");
return;
}
memcpy((void *) &athleteId, (void *) athleteRec, sizeof(int));
athleteRec += sizeof(int);
memcpy((void *) athleteSurname, (void *) athleteRec, HF_MAIN_NAME_SIZE);
athleteRec += HF_MAIN_NAME_SIZE;
memcpy((void *) athleteName, (void *) athleteRec, HF_MAIN_NAME_SIZE);
athleteRec += HF_MAIN_NAME_SIZE;
athleteRec -= HF_MAIN_ATHLETE_REC_SIZE;
printf("Found Athlete Record: (%d, %s, %s)\n", athleteId, athleteSurname, athleteName);
//Επαλήθευση της τιμής που ανακτήθηκε
if (athleteId != partAthId)
{
HF_PrintError("Invalid Athlete Record\n");
return;
}
printf("Athlete %s, %s participated in %s on %s.\n", athleteSurname, athleteName, eventName, partDate);
free(athleteSurname);
free(athleteName);
}
if (HF_FindNextRec(athletesScan, athleteRec) >= 0)
{
HF_PrintError("File Scan on Athletes returned a second Athlete record");
return;
}
free(athleteRec);
//Κλείσιμο του Scan στο Αρχείο ATHLETES
if (HF_CloseFileScan(athletesScan) != HFE_OK)
{
HF_PrintError("Close of Scan on ATHLETES Failed.");
return;
}
printf("Deleting Participation Record %d\n", partRecId);
if (HF_DeleteRec(partsFd, partRecId, HF_MAIN_PARTICIPATION_REC_SIZE) != HFE_OK)
{
HF_PrintError("Deletion of Participation Record failed.");
return;
}
partsCounter++;
free(partDate);
}
free(partsRec);
//Κλείσιμο του Scan στο Αρχείο PARTICIPATIONS
if (HF_CloseFileScan(partsScan) != HFE_OK)
{
HF_PrintError("Close of Scan on PARTICIPATIONS Failed.");
return;
}
printf("Deleting Event Record: recId=%d, data=(%d, %s)\n\n", eventRecId, recEventId, eventName);
if (HF_DeleteRec(eventsFd, eventRecId, HF_MAIN_EVENT_REC_SIZE) != HFE_OK)
{
HF_PrintError("Deletion of Event Record failed.");
return;
}
free(eventName);
}
free(eventRec);
printf("Deleted %d participations\n", partsCounter);
//Κλείσιμο Αρχείου PARTICIPATIONS
if (HF_CloseFile(partsFd) != HFE_OK)
HF_PrintError("Error in HF_CloseFile called on PARTICIPATIONS.");
//Κλείσιμο Αρχείου EVENTS
if (HF_CloseFile(eventsFd) != HFE_OK)
HF_PrintError("Error in HF_CloseFile called on EVENTS.");
//Κλείσιμο Αρχείου ATHLETES
if (HF_CloseFile(athletesFd) != HFE_OK)
HF_PrintError("Error in HF_CloseFile called on ATHLETES.");
}
