int UT_Init( char * dbname )
{
/* Arxikopoioume ta katwtera epipeda */
HF_Init();
AM_Init();
/* kai metaferomaste sto fakelo ths database */
if ( chdir( dbname ) ) {
printf( "Error: Database %s does not exist", dbname );
return AMINIREL_GE;
}
/* initialize twn fileDescriptors se non valid timh */
this_db.attrCatDesc = this_db.relCatDesc = this_db.viewAttrCatDesc = this_db.viewCatDesc = AMINIREL_INVALID;
/* Anoigma twn 4 vasikwn arxeiwn mias database pou tha mas xreiastoun argotera */
if (( this_db.attrCatDesc = HF_OpenFile( "attrCat" ) ) < HFE_OK ) {
HF_PrintError( "Couldn't open attrCat" );
return AMINIREL_GE;
}
if (( this_db.relCatDesc = HF_OpenFile( "relCat" ) ) < HFE_OK ) {
HF_PrintError( "Couldn't open relCat" );
return AMINIREL_GE;
}
if (( this_db.viewAttrCatDesc = HF_OpenFile( "viewAttrCat" ) ) < HFE_OK ) {
HF_PrintError( "Couldn't open viewAttrCat" );
return AMINIREL_GE;
}
if (( this_db.viewCatDesc = HF_OpenFile( "viewCat" ) ) < HFE_OK ) {
HF_PrintError( "Couldn't open viewCat" );
return AMINIREL_GE;
}
return AMINIREL_OK;
}
int main(int argc, char* argv[]){
char* dbname;
if(argc!=2){
printf("Usage: %s dbname \n",argv[0]);
return 1;
}
dbname=argv[1];
if(chdir(dbname)){
printf("Cannot open database!\n");
return 1;
}
BF_Init();
HF_Init();
AM_Init();
if ((relCatFd = HF_OpenFile("relCat")) < 0) {
printf("Cannot open file relCat\n");
return 1;
}
if ((attrCatFd = HF_OpenFile("attrCat")) < 0) {
printf("Cannot open file relCat\n");
return 1;
}
/* Κλήση της συνάρτησης yyparse ή οποία */
/* θα καλεί αυτόματα τις συναρτήσεις σας */
while(yyparse() == RESTART);
system("Pause");
return 0;
}
int main()
{
int athletesFd;
int eventsFd;
int partsFd;
int athletesIndexFd0;
int athletesIndexFd1;
int athletesIndexFd2;
int eventsIndexFd0;
int eventsIndexFd1;
int partsIndexFd0;
int partsIndexFd1;
int partsIndexFd2;
int recId;
char *athleteRec;
char *eventRec;
char *partRec;
int athId;
char surname[AM_MAIN_NAME_SIZE];
char name[AM_MAIN_NAME_SIZE];
int eventId;
char eventName[AM_MAIN_EVENT_NAME_SIZE];
char partDate[AM_MAIN_DATE_SIZE];
/* Αρχικοποίηση Επιπέδου HF */
HF_Init();
/* Αρχικοποίηση Επιπέδου AM */
AM_Init();
/* ’νοιγμα Αρχείου ATHLETES */
athletesFd = HF_OpenFile("ATHLETES");
if (athletesFd < 0)
{
HF_PrintError("Error in HF_OpenFile called on ATHLETES.");
return -1;
}
/* ’νοιγμα Αρχείου EVENTS */
eventsFd = HF_OpenFile("EVENTS");
if (eventsFd < 0)
{
HF_PrintError("Error in HF_OpenFile called on EVENTS.");
return -1;
}
/* ’νοιγμα Αρχείου PARTICIPATIONS */
partsFd = HF_OpenFile("PARTICIPATIONS");
if (partsFd < 0)
{
HF_PrintError("Error in HF_OpenFile called on PARTICIPATIONS.");
return -1;
}
/*Δημιουργία ευρετηρίου στο 1ο πεδίο του αρχείου ATHLETES*/
if (AM_CreateIndex("ATHLETES", 0, 'i', sizeof(int)) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on ATHLETES.0.");
}
/*’νοιγμα του 1ου ευρετηρίου στο αρχείο ATHLETES*/
athletesIndexFd0 = AM_OpenIndex("ATHLETES", 0);
if (athletesIndexFd0 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on ATHLETES.0.");
return -1;
}
/*Δημιουργία ευρετηρίου στο 2ο πεδίο του αρχείου ATHLETES*/
if (AM_CreateIndex("ATHLETES", 1, 'c', AM_MAIN_NAME_SIZE) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on ATHLETES.1.");
}
/* //’νοιγμα του 2ου ευρετηρίου στο αρχείο ATHLETES*/
athletesIndexFd1 = AM_OpenIndex("ATHLETES", 1);
if (athletesIndexFd1 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on ATHLETES.1.");
return -1;
}
/* //Δημιουργία ευρετηρίου στο 3ο πεδίο του αρχείου ATHLETES */
if (AM_CreateIndex("ATHLETES", 2, 'c', AM_MAIN_NAME_SIZE) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on ATHLETES.2.");
}
/* //’νοιγμα του 3ου ευρετηρίου στο αρχείο ATHLETES*/
athletesIndexFd2 = AM_OpenIndex("ATHLETES", 2);
if (athletesIndexFd2 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on ATHLETES.2.");
return -1;
}
athleteRec = (char *) malloc(AM_MAIN_ATHLETE_REC_SIZE);
if (athleteRec == NULL)
{
printf("Athlete record malloc failed\n");
return -1;
}
/* // Εισαγωγή δεδομένων στα ευρετήρια του αρχείου ATHLETES*/
recId = HF_GetFirstRec(athletesFd, athleteRec, AM_MAIN_ATHLETE_REC_SIZE);
while (recId >= 0)
{
memcpy((void *) &athId, (void *) athleteRec, sizeof(int));
athleteRec += sizeof(int);
strcpy(surname, athleteRec);
athleteRec += AM_MAIN_NAME_SIZE;
strcpy(name, athleteRec);
athleteRec += AM_MAIN_NAME_SIZE;
athleteRec -= AM_MAIN_ATHLETE_REC_SIZE;
if (AM_InsertEntry(athletesIndexFd0, 'i', sizeof(int), (char *) &athId, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
if (AM_InsertEntry(athletesIndexFd1, 'c', AM_MAIN_NAME_SIZE, surname, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
if (AM_InsertEntry(athletesIndexFd2, 'c', AM_MAIN_NAME_SIZE, name, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
recId = HF_GetNextRec(athletesFd, recId, athleteRec, AM_MAIN_ATHLETE_REC_SIZE);
}
/* //Δημιουργία ευρετηρίου στο 1ο πεδίο του αρχείου EVENTS*/
if (AM_CreateIndex("EVENTS", 0, 'i', sizeof(int)) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on EVENTS.0.");
}
/* //’νοιγμα του 1ου ευρετηρίου στο αρχείο EVENTS*/
eventsIndexFd0 = AM_OpenIndex("EVENTS", 0);
if (eventsIndexFd0 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on EVENTS.0.");
return -1;
}
/* //Δημιουργία ευρετηρίου στο 2ο πεδίο του αρχείου EVENTS*/
if (AM_CreateIndex("EVENTS", 1, 'c', AM_MAIN_EVENT_NAME_SIZE) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on EVENTS.1.");
}
/* //’νοιγμα του 2ου ευρετηρίου στο αρχείο EVENTS*/
eventsIndexFd1 = AM_OpenIndex("EVENTS", 1);
if (eventsIndexFd1 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on EVENTS.1.");
return -1;
}
eventRec = (char *) malloc(AM_MAIN_EVENT_REC_SIZE);
if (eventRec == NULL)
{
printf("Event record malloc failed\n");
return -1;
}
/* // Εισαγωγή δεδομένων στα ευρετήρια του αρχείου EVENTS*/
recId = HF_GetFirstRec(eventsFd, eventRec, AM_MAIN_EVENT_REC_SIZE);
while (recId >= 0)
{
memcpy((void *) &eventId, (void *) eventRec, sizeof(int));
eventRec += sizeof(int);
strcpy(eventName, eventRec);
eventRec += AM_MAIN_EVENT_NAME_SIZE;
eventRec -= AM_MAIN_EVENT_REC_SIZE;
if (AM_InsertEntry(eventsIndexFd0, 'i', sizeof(int), (char *) &eventId, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
if (AM_InsertEntry(eventsIndexFd1, 'c', AM_MAIN_EVENT_NAME_SIZE, eventName, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
recId = HF_GetNextRec(eventsFd, recId, eventRec, AM_MAIN_ATHLETE_REC_SIZE);
}
/* //Δημιουργία ευρετηρίου στο 1ο πεδίο του αρχείου PARTICIPATIONS*/
if (AM_CreateIndex("PARTICIPATIONS", 0, 'i', sizeof(int)) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on PARTICIPATIONS.0.");
}
/* //’νοιγμα του 1ου ευρετηρίου στο αρχείο PARTICIPATIONS*/
partsIndexFd0 = AM_OpenIndex("PARTICIPATIONS", 0);
if (partsIndexFd0 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on PARTICIPATIONS.0.");
return -1;
}
/* //Δημιουργία ευρετηρίου στο 2ο πεδίο του αρχείου PARTICIPATIONS*/
if (AM_CreateIndex("PARTICIPATIONS", 1, 'i', sizeof(int)) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on PARTICIPATIONS.1.");
}
/* //’νοιγμα του 2ου ευρετηρίου στο αρχείο PARTICIPATIONS*/
partsIndexFd1 = AM_OpenIndex("PARTICIPATIONS", 1);
if (partsIndexFd1 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on PARTICIPATIONS.1.");
return -1;
}
/* //Δημιουργία ευρετηρίου στο 3ο πεδίο του αρχείου PARTICIPATIONS*/
if (AM_CreateIndex("PARTICIPATIONS", 2, 'c', AM_MAIN_DATE_SIZE) != AME_OK)
{
AM_PrintError("Error in AM_CreateIndex called on PARTICIPATIONS.2.");
}
/* //’νοιγμα του 3ου ευρετηρίου στο αρχείο PARTICIPATIONS*/
partsIndexFd2 = AM_OpenIndex("PARTICIPATIONS", 2);
if (partsIndexFd2 < 0)
{
AM_PrintError("Error in AM_OpenIndex called on PARTICIPATIONS.2.");
return -1;
}
partRec = (char *) malloc(AM_MAIN_PARTICIPATION_REC_SIZE);
if (partRec == NULL)
{
printf("Participation record malloc failed\n");
return -1;
}
/* // Εισαγωγή δεδομένων στα ευρετήρια του αρχείου PARTICIPATIONS*/
recId = HF_GetFirstRec(partsFd, partRec, AM_MAIN_PARTICIPATION_REC_SIZE);
while (recId >= 0)
{
memcpy((void *) &athId, (void *) partRec, sizeof(int));
partRec += sizeof(int);
memcpy((void *) &eventId, (void *) partRec, sizeof(int));
partRec += sizeof(int);
strcpy(partDate, partRec);
partRec += AM_MAIN_DATE_SIZE;
partRec -= AM_MAIN_PARTICIPATION_REC_SIZE;
if (AM_InsertEntry(partsIndexFd0, 'i', sizeof(int), (char *) &athId, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
if (AM_InsertEntry(partsIndexFd1, 'i', sizeof(int), (char *) &eventId, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
if (AM_InsertEntry(partsIndexFd2, 'c', AM_MAIN_DATE_SIZE, partDate, recId) != AME_OK)
AM_PrintError("Failed to insert entry.");
recId = HF_GetNextRec(partsFd, recId, partRec, AM_MAIN_PARTICIPATION_REC_SIZE);
}
free(athleteRec);
free(eventRec);
free(partRec);
/* //Κλείσιμο Αρχείων*/
if (HF_CloseFile(athletesFd) != HFE_OK)
HF_PrintError("Error in HF_CloseFile called on ATHLETES.");
if (HF_CloseFile(eventsFd) != HFE_OK)
HF_PrintError("Error in HF_CloseFile called on EVENTS.");
if (HF_CloseFile(partsFd) != HFE_OK)
HF_PrintError("Error in HF_CloseFile called on PARTICIPATIONS.");
if (AM_CloseIndex(athletesIndexFd0) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on ATHLETES.0.");
if (AM_CloseIndex(athletesIndexFd1) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on ATHLETES.1.");
if (AM_CloseIndex(athletesIndexFd2) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on ATHLETES.2.");
if (AM_CloseIndex(eventsIndexFd0) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on EVENTS.0.");
if (AM_CloseIndex(eventsIndexFd1) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on EVENTS.1.");
if (AM_CloseIndex(partsIndexFd0) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on PARTICIPATIONS.0.");
if (AM_CloseIndex(partsIndexFd1) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on PARTICIPATIONS.1.");
if (AM_CloseIndex(partsIndexFd2) != AME_OK)
AM_PrintError("Error in AM_CloseIndex called on PARTICIPATIONS.2.");
return 0;
}
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.");
}
