Example #1
0
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;
}
Example #2
0
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;
}
Example #3
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;
}
Example #4
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.");

}