C Assignment Help

C Assignment Help For any help regarding C Assignment Help

Visit : https://www.programminghomeworkhelp.com/, Email : support@programminghomeworkhelp.com or call us at - +1 678 648 4277 programminghomeworkhelp.com

Problems Problem :1 In this problem, we will be utilizing the SQLite serverless database library to load and query a database file. The required library libsqlite3.so and header file sqlite3.h appear to be installed on some Athena workstations (but not on the Athena1 server).

If you cannot find it on your own machine’s distribution. Generally, for your machine, you will have to compile the library yourself. For Linux, use the .tar.gz source code amalgamation package that contains the configure and make file support. To compile for Linux, extract the files, run ./configure, make, and make install. For other platforms, you will need to compile and install the library yourself. (a) Download the source codeprob1.c and movie database file movies.db from Stellar.

The database contains a list of movies indexed by BarCode. The list also contains the MovieTitle, MovieCategory, ProductionYear, Format, Language, and Web fields for each movie. In this part, we will use the sqlite3 library to load this database and perform simple SQL queries. (In case you’re curious, the database lists information for movies available from the library in the Sidney Pacific dormitory.)

The source code will get you started. programminghomeworkhelp.com

For this part, you need to fill in the missing code to open the database file, perform an SQL query, and close the database. In particular, you will be expected to use the sqlite3 open(), sqlite3 exec(), and sqlite3 close() functions in your code.

Read the documentation available on the SQLite website for details.

Via Stellar, turn in your code for this part, as well as your program’s output for the first three SQL queries provided in your code. (b) In this part, you will read the entire table into a B-tree, sorted by the name of the movie (assumed to be unique). In the provided code, you will find mostly completed for the B-tree. Complete the missing lines in the B-tree functions. For this and future parts, use the final SQL query, which reads the entire movies table.

Once you have done this, add code to your main() function to print the results of an inorder traversal of the B-tree to a file (second command line argument to the program). Via Stellar, submit online your code and the file containing the result of the traversal. (c) Now, modify your code to ask the user for a movie title. Use the find value() function to locate the movie and print the movie information using display record() to the console. Your program should continue to ask the user until the input string is an empty line. Be sure to remove the trailing newline ’\n’ character from the end of the string returned from fgets( ). programminghomeworkhelp.com

Submit via Stellar your code for this part and your console output for a few illuminating test cases. For instance, "Citizen Kane", "Casablanca" and "Gone with the Wind" are all in the database. (d) For this final part, you will create your own library from the code you wrote for your program. In particular, you should provide the following functions: – int initialize db (const char ∗ filename); – loads the SQLite database from file filename and reads the contents into a B-tree, sorted by movie title. The function should return zero if successful, or non-zero otherwise. Don’t forget to close the database when you’re done loading from it.

– int locate movie(const char ∗ title); – searches the B-tree for the movie with title title and writes the result to the console. The function should return non-zero if a record was found, or zero if no record matches the specified title.

– void dump sorted list(const char ∗ filename); – performs an in order traversal of the B-tree, dumping the sorted list of movies to the file specified by filename. This function does not return anything.

– void cleanup(void); – this function should free the memory used by the B-tree and its records. This function does not return anything. programminghomeworkhelp.com

Be sure to remove your main function from the library, and go ahead and compile this library. On Stellar, you will find the program prob1d.c that will use the library. Compile the program, either statically or dynamically linking it against your library (and sqlite3).

Submit via Stellar a copy of your code and the output of running the program defined in prob1d.c. /* * prob1.c * * Created on: * Author: */

#include <stdio.h> #include <stdlib.h> #include <string.h> /* the include file for the SQLite library */ /* do not use sqlite.h or sqlite3ext.h */ #include <sqlite3.h> /* T defines minimum number of children in non-root nodes * 2*T is maximum number of children in all nodes * 2*T-1 is maximum number of keys in all nodes */ #define T 3 typedef char * nodekey; /* record structure */ typedef struct s_record { unsigned int irecord; /* index of record in main database */ char * name; /* movie name used as key */ char * category; unsigned int year; char * format; char * language; programminghomeworkhelp.com char * url;

} nodevalue; /* B-tree node structure */ typedef struct s_tnode { nodekey keys[2*T-1]; /* keys */ nodevalue * values[2*T-1]; /* values */ unsigned int nkeys; /* number of keys, < 2*T */ struct s_tnode * parent; /* pointer to parent */ struct s_tnode * children[2*T]; /* pointers to children */ } * p_tnode; /* static variables for the root of the tree and number of records */ static p_tnode ptreeroot = NULL; static unsigned int record_count = 0; /* alloc_record() - allocate a new record on the heap */ struct s_record * alloc_record() { struct s_record * precord = (struct s_record *)malloc(sizeof(struct s_record)); precord->irecord = 0; precord->name = NULL; /* movie name used as key */ precord->category = NULL; precord->year = 0; precord->format = NULL; precord->language = NULL; precord->url = NULL; return precord; } /* free_record() - frees the record structure and associated strings */ void free_record(struct s_record * precord) { if (precord->name) free(precord->name); if (precord->category) free(precord->category); if (precord->format) free(precord->format); if (precord->language) free(precord->language); if (precord->url) free(precord->url); free(precord); programminghomeworkhelp.com

} /* display_record -- output record information to file pointer fp */ void display_record(struct s_record * precord, FILE * fp) { fprintf(fp, "[#%d] %s (%d): %s, %s, %s, <%s>\n", precord->irecord, precord->name, precord->year, precord->category, precord>format, precord->language, precord->url); } /* alloc_tnode() - creates a new B-tree node on the heap */ p_tnode alloc_tnode(void) { int n; p_tnode pnode = (p_tnode)malloc(sizeof(struct s_tnode)); pnode->nkeys = 0; for (n = 0; n < 2*T; n++) pnode->children[n] = NULL; pnode->parent = NULL; return pnode; } /* free_tnode() - frees a node in the B-tree, * its associated record, and all its children from memory */ void free_tnode(p_tnode pnode) { unsigned int n; for (n = 0; n < 2*T; n++) { if (pnode->children[n] != NULL) free_tnode(pnode->children[n]); } for (n = 0; n < pnode->nkeys; n++) { if (pnode->values[n]) free_record(pnode->values[n]); } free(pnode); } /* function for comparing two keys; simply calls the case-insensitive programminghomeworkhelp.com

* string comparison function strcasecmp() declared in string.h. * Returns zero if both equal, positive if key1 > key2, negative if key1 < key2 */ int key_compare(const nodekey key1, const nodekey key2) { return strcasecmp(key1, key2); } /* find_index() - performs binary search of list of keys in node * to find either the index of the existing key, or the insertion * point of a new key. Returns nonnegative index of insertion point * if new key, or -(index+1) for existing key found at index * * TODO: fill in the binary search while loop */ int find_index(nodekey key, p_tnode pnode) { /* find in between */ int icmp, L = 0, R = pnode->nkeys-1, M; int ibetween = 0; /* index to return */ /* TODO: complete binary search; * use key_compare() to compare two keys. */ while (L <= R) { } return ibetween;

} /* split_node() - splits a full node in the B-tree into two separate nodes, * possibly creating a new root node in the process * should be no need to modify this function */ void split_node(p_tnode * ppnode, int * poffset) { p_tnode pnode = *ppnode; int median = pnode->nkeys>>1, i; p_tnode parent = pnode->parent, split = alloc_tnode(); programminghomeworkhelp.com

if (poffset != NULL) { /* update offset index and ppnode to point to new insertion point */ if (*poffset > median) { /* move to new (split) node */ *poffset -= (median+1); *ppnode = split; } } if (parent) { int insert = find_index(pnode->keys[median],parent); /* move median into parent */ for (i = parent->nkeys; i > insert; i--) { parent->keys[i] = parent->keys[i-1]; parent->values[i] = parent->values[i-1]; parent->children[i+1] = parent->children[i]; } parent->keys[insert] = pnode->keys[median]; parent->values[insert] = pnode->values[median]; parent->children[insert] = pnode; parent->nkeys++; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[insert+1] = split; split->parent = parent; programminghomeworkhelp.com

} else {

/* split root */ parent = ptreeroot = alloc_tnode(); parent->keys[0] = pnode->keys[median]; parent->values[0] = pnode->values[median]; parent->children[0] = pnode; parent->nkeys = 1; pnode->parent = parent; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[1] = split; split->parent = parent; } } /* add_element() - add the record with the specified key to the B-tree. * returns a pointer to an already existing record with the same key, * in which case, the new record was not inserted, or NULL on success * should be no need to modify this function */ nodevalue * add_element(nodekey key, nodevalue * pvalue) { /* find leaf */ p_tnode pleaf = ptreeroot, parent = NULL; int ichild, i; programminghomeworkhelp.com

while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* already exists */ return pleaf->values[-(ichild+1)]; if (pleaf->nkeys == 2*T-1) { /* split leaf into two nodes */ split_node(&pleaf, &ichild); } parent = pleaf; pleaf = pleaf->children[ichild]; } pleaf = parent; record_count++; /* record actually added to tree */ /* enough room, just add to leaf */ for (i = pleaf->nkeys; i > ichild; i--) { pleaf->keys[i] = pleaf->keys[i-1]; pleaf->values[i] = pleaf->values[i-1]; } pleaf->keys[ichild] = key; pleaf->values[ichild] = pvalue; pleaf->nkeys++; }

return NULL;

/* inorder_traversal() - traverse B-tree, in sorted order * similar to binary search tree traversal (except nodes have multiple values and children) * writes record info to file pointer fp * * TODO: fill in this function */ void inorder_traversal(p_tnode pnode, FILE * fp) { int n; for (n = 0; n < pnode->nkeys; n++) { programminghomeworkhelp.com

/* TODO: traverse children and keys, in order */ } if (pnode->children[n] != NULL) { /* TODO: don't forget about the last child */ } } /* find_value() - locate value for specified key in B-tree * need to return pointer to record structure, or NULL if record not found * TODO: fill in this function */ nodevalue * find_value(const nodekey key) { int ichild; p_tnode pleaf = ptreeroot; /* start at root */ /* TODO: iterate pleaf down to leaves of tree, or until key is found */ }

return NULL; /* didn't find it */

/* display_result() - print information from the database * this function is a valid callback for use with sqlite3_exec() * pextra is unused * * needs to return zero (nonzero aborts SQL query) */ int display_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n;

}

for (n = 0; n < nfields; n++) { printf("%s: [%s] ", arrfieldnames[n], arrvalues[n]); } printf("\n"); return 0; programminghomeworkhelp.com

/* store_result() - store record from database in B-tree * this function is also a valid callback for use with sqlite3_exec() * pextra is again unused * * needs to return zero (nonzero aborts SQL query) */ int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n; /* allocate record on heap */ struct s_record * prec = alloc_record(); prec->irecord = record_count+1; for (n = 0; n < nfields; n++) { if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0) prec->name = strdup(arrvalues[n]); /* key */ else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0) prec->category = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0) prec->year = atoi(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Format") == 0) prec->format = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Language") == 0) prec->language = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Web") == 0) prec->url = strdup(arrvalues[n]); } /* add record to B-tree */ if (add_element(prec->name, prec) != NULL) { /* element already exists -- don't add record */ printf("Duplicate record exists: "); /* diagnostic value only */ display_record(prec, stdout); free_record(prec); } }

return 0;

programminghomeworkhelp.com

int main(int argc, char * argv[]) { /* part (a): execute the first three SQL queries */ const char sql[] = "SELECT * FROM movies WHERE ProductionYear < 1950"; /* const char sql[] = "SELECT * FROM movies WHERE Format == \"VHS\""; */ /* const char sql[] = "SELECT * FROM movies WHERE Language == \"Spanish\""; */ /* part (b, c, d): use this SQL query to read the entire table */ /* const char sql[] = "SELECT * FROM movies"; */ if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } /* TODO: load the database, probably using sqlite3_open() */ /* TODO: execute the SQL query, probably using sqlite3_exec() */ /* TODO: close the database when you're done with it */ return 0; } /* * prob1d.c * * Created on: Jan 20, 2010 * Author: dweller */#include <stdio.h>#include <stdlib.h>#include <string.h>/* functions defined in your code */int initialize_db (const char * filename);int locate_movie(char * title );void dump_sorted_list(const char * filename);void cleanup(void);#define NUM_TITLES 10int main(int argc, char * argv[]) { int nresult, n; char strtitles[NUM_TITLES][256] = {"Citizen Kane", "Ponderosa", "Gosford Park", "Transformers", "Gone with the Wind", "When Harry Met Sally", "Avatar", "Simpsons Movie, The", "American Pie 2", "Superman Returns"}; struct s_record * pvalue; if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } if (argc < 3) { fprintf(stderr,"Error: output file name not specified!\n"); return 1; } /* initialize B-tree and fill with database */ if ( (nresult = initialize_db(argv[1])) != 0) { cleanup(); return nresult; /* error during initialization */ } dump_sorted_list(argv[2]); for (n = 0; n < NUM_TITLES; n++) { if ( (nresult = locate_movie(strtitles[n])) == 0) printf("Movie \"%s\" not found!\n", strtitles[n]); } cleanup(); return 0;} programminghomeworkhelp.com

/* * prob1asol.c * * Created on: Jan 20, 2010 * Author: dweller */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* the include file for the SQLite library */ /* do not use sqlite.h or sqlite3ext.h */ #include <sqlite3.h> /* T defines minimum number of children in non-root nodes * 2*T is maximum number of children in all nodes * 2*T-1 is maximum number of keys in all nodes */ #define T 3 typedef char * nodekey; /* record structure */ typedef struct s_record { unsigned int irecord; /* index of record in main database */ char * name; /* movie name used as key */ char * category; unsigned int year; char * format; char * language; char * url; } nodevalue; /* B-tree node structure */ typedef struct s_tnode { nodekey keys[2*T-1]; /* keys */

programminghomeworkhelp.com

nodevalue * values[2*T-1]; /* values */ unsigned int nkeys; /* number of keys, < 2*T */ struct s_tnode * parent; /* pointer to parent */ struct s_tnode * children[2*T]; /* pointers to children */ } * p_tnode; /* static variables for the root of the tree and number of records */ static p_tnode ptreeroot = NULL; static unsigned int record_count = 0; /* alloc_record() - allocate a new record on the heap */ struct s_record * alloc_record() { struct s_record * precord = (struct s_record *)malloc(sizeof(struct s_record)); precord->irecord = 0; precord->name = NULL; /* movie name used as key */ precord->category = NULL; precord->year = 0; precord->format = NULL; precord->language = NULL; precord->url = NULL; return precord; } /* free_record() - frees the record structure and associated strings */ void free_record(struct s_record * precord) { if (precord->name) free(precord->name); if (precord->category) free(precord->category); if (precord->format) free(precord->format); if (precord->language) free(precord->language); if (precord->url) free(precord->url); free(precord); } /* display_record -- output record information to file pointer fp */ void display_record(struct s_record * precord, FILE * fp) { programminghomeworkhelp.com

fprintf(fp, "[#%d] %s (%d): %s, %s, %s, <%s>\n", precord->irecord, precord->name, precord->year, precord->category, precord->format, precord>language, precord->url); } /* alloc_tnode() - creates a new B-tree node on the heap */ p_tnode alloc_tnode(void) { int n; p_tnode pnode = (p_tnode)malloc(sizeof(struct s_tnode)); pnode->nkeys = 0; for (n = 0; n < 2*T; n++) pnode->children[n] = NULL; pnode->parent = NULL; return pnode; } /* free_tnode() - frees a node in the B-tree, * its associated record, and all its children from memory */ void free_tnode(p_tnode pnode) { unsigned int n; for (n = 0; n < 2*T; n++) { if (pnode->children[n] != NULL) free_tnode(pnode->children[n]); } for (n = 0; n < pnode->nkeys; n++) { if (pnode->values[n]) free_record(pnode->values[n]); } }

free(pnode);

/* function for comparing two keys; simply calls the case-insensitive * string comparison function strcasecmp() declared in string.h. * Returns zero if both equal, positive if key1 > key2, negative if key1 < key2 */ int key_compare(const nodekey key1, const nodekey key2) { programminghomeworkhelp.com

}

return strcasecmp(key1, key2);

/* find_index() - performs binary search of list of keys in node * to find either the index of the existing key, or the insertion * point of a new key. Returns nonnegative index of insertion point * if new key, or -(index+1) for existing key found at index * * TODO: fill in the binary search while loop */ int find_index(nodekey key, p_tnode pnode) { /* find in between */ int icmp, L = 0, R = pnode->nkeys-1, M; int ibetween = 0; /* index to return */

}

/* TODO: complete binary search; * use key_compare() to compare two keys. */ return ibetween;

/* split_node() - splits a full node in the B-tree into two separate nodes, * possibly creating a new root node in the process * should be no need to modify this function */ void split_node(p_tnode * ppnode, int * poffset) { p_tnode pnode = *ppnode; int median = pnode->nkeys>>1, i; p_tnode parent = pnode->parent, split = alloc_tnode(); if (poffset != NULL) { /* update offset index and ppnode to point to new insertion point */ if (*poffset > median) { /* move to new (split) node */ *poffset -= (median+1); *ppnode = split; } programminghomeworkhelp.com

}

if (parent) { int insert = find_index(pnode->keys[median],parent); /* move median into parent */ for (i = parent->nkeys; i > insert; i--) { parent->keys[i] = parent->keys[i-1]; parent->values[i] = parent->values[i-1]; parent->children[i+1] = parent->children[i]; } parent->keys[insert] = pnode->keys[median]; parent->values[insert] = pnode->values[median]; parent->children[insert] = pnode; parent->nkeys++;

} else {

/* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[insert+1] = split; split->parent = parent; /* split root */ parent = ptreeroot = alloc_tnode(); parent->keys[0] = pnode->keys[median]; parent->values[0] = pnode->values[median]; programminghomeworkhelp.com

parent->children[0] = pnode; parent->nkeys = 1; pnode->parent = parent;

}

}

/* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[1] = split; split->parent = parent;

/* add_element() - add the record with the specified key to the B-tree. * returns a pointer to an already existing record with the same key, * in which case, the new record was not inserted, or NULL on success * should be no need to modify this function */ nodevalue * add_element(nodekey key, nodevalue * pvalue) { /* find leaf */ p_tnode pleaf = ptreeroot, parent = NULL; int ichild, i; while (pleaf != NULL) { ichild = find_index(key, pleaf); programminghomeworkhelp.com

if (ichild < 0) /* already exists */ return pleaf->values[-(ichild+1)]; if (pleaf->nkeys == 2*T-1) { /* split leaf into two nodes */ split_node(&pleaf, &ichild); } parent = pleaf; pleaf = pleaf->children[ichild]; } pleaf = parent; record_count++; /* record actually added to tree */ /* enough room, just add to leaf */ for (i = pleaf->nkeys; i > ichild; i--) { pleaf->keys[i] = pleaf->keys[i-1]; pleaf->values[i] = pleaf->values[i-1]; } pleaf->keys[ichild] = key; pleaf->values[ichild] = pvalue; pleaf->nkeys++; }

return NULL;

/* inorder_traversal() - traverse B-tree, in sorted order * similar to binary search tree traversal (except nodes have multiple values and children) * writes record info to file pointer fp * * TODO: fill in this function */ void inorder_traversal(p_tnode pnode, FILE * fp) { int n; for (n = 0; n < pnode->nkeys; n++) { programminghomeworkhelp.com

/* TODO: traverse children and keys, in order */ } if (pnode->children[n] != NULL) { /* TODO: don't forget about the last child */ } } /* find_value() - locate value for specified key in B-tree * need to return pointer to record structure, or NULL if record not found * TODO: fill in this function */ nodevalue * find_value(const nodekey key) { int ichild; p_tnode pleaf = ptreeroot; /* start at root */ /* TODO: iterate pleaf down to leaves of tree, or until key is found */ }

return NULL; /* didn't find it */

/* display_result() - print information from the database * this function is a valid callback for use with sqlite3_exec() * pextra is unused * * needs to return zero (nonzero aborts SQL query) */ int display_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n;

}

for (n = 0; n < nfields; n++) { printf("%s: [%s] ", arrfieldnames[n], arrvalues[n]); } printf("\n"); return 0; programminghomeworkhelp.com

/* store_result() - store record from database in B-tree * this function is also a valid callback for use with sqlite3_exec() * pextra is again unused * * needs to return zero (nonzero aborts SQL query) */ int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n; /* allocate record on heap */ struct s_record * prec = alloc_record(); prec->irecord = record_count+1; for (n = 0; n < nfields; n++) { if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0) prec->name = strdup(arrvalues[n]); /* key */ else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0) prec->category = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0) prec->year = atoi(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Format") == 0) prec->format = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Language") == 0) prec->language = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Web") == 0) prec->url = strdup(arrvalues[n]); } /* add record to B-tree */ if (add_element(prec->name, prec) != NULL) { /* element already exists -- don't add record */ printf("Duplicate record exists: "); /* diagnostic value only */ display_record(prec, stdout); free_record(prec); } programminghomeworkhelp.com

return 0;

} int main(int argc, char * argv[]) { sqlite3 * pDb = NULL; int nresult; /* part (a): execute the first three SQL queries */ const char sql[] = "SELECT * FROM movies WHERE ProductionYear < 1950"; /* const char sql[] = "SELECT * FROM movies WHERE Format == \"VHS\""; */ /* const char sql[] = "SELECT * FROM movies WHERE Language == \"Spanish\""; */ /* part (b, c, d): use this SQL query to read the entire table */ /* const char sql[] = "SELECT * FROM movies"; */ if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } /* TODO: load the database, probably using sqlite3_open() */ if ( (nresult = sqlite3_open(argv[1],&pDb)) != SQLITE_OK) fprintf(stderr,"Error: the database could not be opened. %s (%d)\n", sqlite3_errmsg(pDb), nresult); else { char * errmsg = NULL; /* TODO: execute the SQL query, probably using sqlite3_exec() */ nresult = sqlite3_exec(pDb, sql, display_result, NULL, &errmsg);

}

if (errmsg) { fprintf(stderr, "Error executing SQL query: %s.\n", errmsg); sqlite3_free(errmsg); } /* TODO: close the database when you're done with it */ sqlite3_close(pDb);

}

return 0;

programminghomeworkhelp.com

Solutions: /* * prob1asol.c * * Created on: Jan 20, 2010 * Author: dweller */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* the include file for the SQLite library */ /* do not use sqlite.h or sqlite3ext.h */ #include <sqlite3.h> /* T defines minimum number of children in non-root nodes * 2*T is maximum number of children in all nodes * 2*T-1 is maximum number of keys in all nodes */ #define T 3 typedef char * nodekey; /* record structure */ typedef struct s_record { unsigned int irecord; /* index of record in main database */ char * name; /* movie name used as key */ char * category; unsigned int year; char * format; char * language; char * url; } nodevalue; /* B-tree node structure */ typedef struct s_tnode {

programminghomeworkhelp.com

nodekey keys[2*T-1]; /* keys */ nodevalue * values[2*T-1]; /* values */ unsigned int nkeys; /* number of keys, < 2*T */ struct s_tnode * parent; /* pointer to parent */ struct s_tnode * children[2*T]; /* pointers to children */ } * p_tnode; /* static variables for the root of the tree and number of records */ static p_tnode ptreeroot = NULL; static unsigned int record_count = 0; /* alloc_record() - allocate a new record on the heap */ struct s_record * alloc_record() { struct s_record * precord = (struct s_record *)malloc(sizeof(struct s_record)); precord->irecord = 0; precord->name = NULL; /* movie name used as key */ precord->category = NULL; precord->year = 0; precord->format = NULL; precord->language = NULL; precord->url = NULL; return precord; } /* free_record() - frees the record structure and associated strings */ void free_record(struct s_record * precord) { if (precord->name) free(precord->name); if (precord->category) free(precord->category); if (precord->format) free(precord->format); if (precord->language) free(precord->language); if (precord->url) free(precord->url); free(precord); } /* display_record -- output record information to file pointer fp */ void display_record(struct s_record * precord, FILE * fp) { fprintf(fp, "[#%d] %s (%d): %s, %s, %s, <%s>\n", precord->irecord, precord->name, precord->year, precord->category, precord->format, precord->language, precord->url); }

programminghomeworkhelp.com

/* alloc_tnode() - creates a new B-tree node on the heap */ p_tnode alloc_tnode(void) { int n; p_tnode pnode = (p_tnode)malloc(sizeof(struct s_tnode)); pnode->nkeys = 0; for (n = 0; n < 2*T; n++) pnode->children[n] = NULL; pnode->parent = NULL; return pnode; } /* free_tnode() - frees a node in the B-tree, * its associated record, and all its children from memory */ void free_tnode(p_tnode pnode) { unsigned int n; for (n = 0; n < 2*T; n++) { if (pnode->children[n] != NULL) free_tnode(pnode->children[n]); } for (n = 0; n < pnode->nkeys; n++) { if (pnode->values[n]) free_record(pnode->values[n]); } }

free(pnode);

/* function for comparing two keys; simply calls the case-insensitive * string comparison function strcasecmp() declared in string.h. * Returns zero if both equal, positive if key1 > key2, negative if key1 < key2 */ int key_compare(const nodekey key1, const nodekey key2) { return strcasecmp(key1, key2); } /* find_index() - performs binary search of list of keys in node * to find either the index of the existing key, or the insertion * point of a new key. Returns nonnegative index of insertion point

programminghomeworkhelp.com

* if new key, or -(index+1) for existing key found at index * * TODO: fill in the binary search while loop */ int find_index(nodekey key, p_tnode pnode) { /* find in between */ int icmp, L = 0, R = pnode->nkeys-1, M; int ibetween = 0; /* index to return */

}

/* TODO: complete binary search; * use key_compare() to compare two keys. */ return ibetween;

/* split_node() - splits a full node in the B-tree into two separate nodes, * possibly creating a new root node in the process * should be no need to modify this function */ void split_node(p_tnode * ppnode, int * poffset) { p_tnode pnode = *ppnode; int median = pnode->nkeys>>1, i; p_tnode parent = pnode->parent, split = alloc_tnode(); if (poffset != NULL) { /* update offset index and ppnode to point to new insertion point */ if (*poffset > median) { /* move to new (split) node */ *poffset -= (median+1); *ppnode = split; } } if (parent) { int insert = find_index(pnode->keys[median],parent); /* move median into parent */ for (i = parent->nkeys; i > insert; i--) { parent->keys[i] = parent->keys[i-1]; parent->values[i] = parent->values[i-1]; parent->children[i+1] = parent->children[i];

programminghomeworkhelp.com

}

parent->keys[insert] = pnode->keys[median]; parent->values[insert] = pnode->values[median]; parent->children[insert] = pnode; parent->nkeys++; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[insert+1] = split; split->parent = parent; } else { /* split root */ parent = ptreeroot = alloc_tnode(); parent->keys[0] = pnode->keys[median]; parent->values[0] = pnode->values[median]; parent->children[0] = pnode; parent->nkeys = 1; pnode->parent = parent; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL;

programminghomeworkhelp.com

}

}

}

split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[1] = split; split->parent = parent;

/* add_element() - add the record with the specified key to the B-tree. * returns a pointer to an already existing record with the same key, * in which case, the new record was not inserted, or NULL on success * should be no need to modify this function */ nodevalue * add_element(nodekey key, nodevalue * pvalue) { /* find leaf */ p_tnode pleaf = ptreeroot, parent = NULL; int ichild, i; while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* already exists */ return pleaf->values[-(ichild+1)]; if (pleaf->nkeys == 2*T-1) { /* split leaf into two nodes */ split_node(&pleaf, &ichild); } parent = pleaf; pleaf = pleaf->children[ichild]; } pleaf = parent; record_count++; /* record actually added to tree */ /* enough room, just add to leaf */ for (i = pleaf->nkeys; i > ichild; i--) { pleaf->keys[i] = pleaf->keys[i-1]; pleaf->values[i] = pleaf->values[i-1]; }

programminghomeworkhelp.com

pleaf->keys[ichild] = key; pleaf->values[ichild] = pvalue; pleaf->nkeys++; }

return NULL;

/* inorder_traversal() - traverse B-tree, in sorted order * similar to binary search tree traversal (except nodes have multiple values and children) * writes record info to file pointer fp * * TODO: fill in this function */ void inorder_traversal(p_tnode pnode, FILE * fp) { int n; for (n = 0; n < pnode->nkeys; n++) { /* TODO: traverse children and keys, in order */ } if (pnode->children[n] != NULL) { /* TODO: don't forget about the last child */ } } /* find_value() - locate value for specified key in B-tree * need to return pointer to record structure, or NULL if record not found * TODO: fill in this function */ nodevalue * find_value(const nodekey key) { int ichild; p_tnode pleaf = ptreeroot; /* start at root */ /* TODO: iterate pleaf down to leaves of tree, or until key is found */ return NULL; /* didn't find it */ } /* display_result() - print information from the database * this function is a valid callback for use with sqlite3_exec() * pextra is unused * * needs to return zero (nonzero aborts SQL query) */

programminghomeworkhelp.com

int display_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n;

}

for (n = 0; n < nfields; n++) { printf("%s: [%s] ", arrfieldnames[n], arrvalues[n]); } printf("\n"); return 0;

/* store_result() - store record from database in B-tree * this function is also a valid callback for use with sqlite3_exec() * pextra is again unused * * needs to return zero (nonzero aborts SQL query) */ int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n; /* allocate record on heap */ struct s_record * prec = alloc_record(); prec->irecord = record_count+1; for (n = 0; n < nfields; n++) { if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0) prec->name = strdup(arrvalues[n]); /* key */ else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0) prec->category = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0) prec->year = atoi(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Format") == 0) prec->format = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Language") == 0) prec->language = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Web") == 0) prec->url = strdup(arrvalues[n]); }

programminghomeworkhelp.com

/* add record to B-tree */ if (add_element(prec->name, prec) != NULL) { /* element already exists -- don't add record */ printf("Duplicate record exists: "); /* diagnostic value only */ display_record(prec, stdout); free_record(prec); } }

return 0;

int main(int argc, char * argv[]) { sqlite3 * pDb = NULL; int nresult; /* part (a): execute the first three SQL queries */ const char sql[] = "SELECT * FROM movies WHERE ProductionYear < 1950"; /* const char sql[] = "SELECT * FROM movies WHERE Format == \"VHS\""; */ /* const char sql[] = "SELECT * FROM movies WHERE Language == \"Spanish\""; */ /* part (b, c, d): use this SQL query to read the entire table */ /* const char sql[] = "SELECT * FROM movies"; */ if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } /* TODO: load the database, probably using sqlite3_open() */ if ( (nresult = sqlite3_open(argv[1],&pDb)) != SQLITE_OK) fprintf(stderr,"Error: the database could not be opened. %s (%d)\n", sqlite3_errmsg(pDb), nresult); else { char * errmsg = NULL; /* TODO: execute the SQL query, probably using sqlite3_exec() */ nresult = sqlite3_exec(pDb, sql, display_result, NULL, &errmsg); if (errmsg) {

programminghomeworkhelp.com

fprintf(stderr, "Error executing SQL query: %s.\n", errmsg); sqlite3_free(errmsg); } } /* TODO: close the database when you're done with it */ sqlite3_close(pDb); return 0; } /* * prob1bsol.c * * Created on: Jan 20, 2010 * Author: dweller */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* the include file for the SQLite library */ /* do not use sqlite.h or sqlite3ext.h */ #include <sqlite3.h> /* T defines minimum number of children in non-root nodes * 2*T is maximum number of children in all nodes * 2*T-1 is maximum number of keys in all nodes */ #define T 3 typedef char * nodekey; /* record structure */ typedef struct s_record { unsigned int irecord; /* index of record in main database */ char * name; /* movie name used as key */ char * category;

programminghomeworkhelp.com

unsigned int year; char * format; char * language; char * url; } nodevalue; /* B-tree node structure */ typedef struct s_tnode { nodekey keys[2*T-1]; /* keys */ nodevalue * values[2*T-1]; /* values */ unsigned int nkeys; /* number of keys, < 2*T */ struct s_tnode * parent; /* pointer to parent */ struct s_tnode * children[2*T]; /* pointers to children */ } * p_tnode; /* static variables for the root of the tree and number of records */ static p_tnode ptreeroot = NULL; static unsigned int record_count = 0; /* alloc_record() - allocate a new record on the heap */ struct s_record * alloc_record() { struct s_record * precord = (struct s_record *)malloc(sizeof(struct s_record)); precord->irecord = 0; precord->name = NULL; /* movie name used as key */ precord->category = NULL; precord->year = 0; precord->format = NULL; precord->language = NULL; precord->url = NULL; return precord; } /* free_record() - frees the record structure and associated strings */ void free_record(struct s_record * precord) { if (precord->name) free(precord->name); if (precord->category) free(precord->category); if (precord->format) free(precord->format); if (precord->language) free(precord->language); if (precord->url) free(precord->url);

programminghomeworkhelp.com

}

free(precord);

/* display_record -- output record information to file pointer fp */ void display_record(struct s_record * precord, FILE * fp) { fprintf(fp, "[#%d] %s (%d): %s, %s, %s, <%s>\n", precord->irecord, precord->name, precord->year, precord->category, precord->format, precord>language, precord->url); } /* alloc_tnode() - creates a new B-tree node on the heap */ p_tnode alloc_tnode(void) { int n; p_tnode pnode = (p_tnode)malloc(sizeof(struct s_tnode)); pnode->nkeys = 0; for (n = 0; n < 2*T; n++) pnode->children[n] = NULL; pnode->parent = NULL; return pnode; } /* free_tnode() - frees a node in the B-tree, * its associated record, and all its children from memory */ void free_tnode(p_tnode pnode) { unsigned int n; for (n = 0; n < 2*T; n++) { if (pnode->children[n] != NULL) free_tnode(pnode->children[n]); } for (n = 0; n < pnode->nkeys; n++) { if (pnode->values[n]) free_record(pnode->values[n]); } }

free(pnode);

/* function for comparing two keys; simply calls the case-insensitive * string comparison function strcasecmp() declared in string.h.

programminghomeworkhelp.com

* Returns zero if both equal, positive if key1 > key2, negative if key1 < key2 */ int key_compare(const nodekey key1, const nodekey key2) { return strcasecmp(key1, key2); } /* find_index() - performs binary search of list of keys in node * to find either the index of the existing key, or the insertion * point of a new key. Returns nonnegative index of insertion point * if new key, or -(index+1) for existing key found at index * * TODO: fill in the binary search while loop */ int find_index(nodekey key, p_tnode pnode) { /* find in between */ int icmp, L = 0, R = pnode->nkeys-1, M; int ibetween = 0; /* index to return */

}

/* TODO: complete binary search; * use key_compare() to compare two keys. */ while (L <= R) { M = (L+R) >> 1; icmp = key_compare(key, pnode->keys[M]); if (icmp == 0) { /* key exists */ return -(M+1); } else if (icmp > 0) { L = M+1; ibetween = L; } else { R = M-1; ibetween = R+1; } } return ibetween;

/* split_node() - splits a full node in the B-tree into two separate nodes, * possibly creating a new root node in the process

programminghomeworkhelp.com

* should be no need to modify this function */ void split_node(p_tnode * ppnode, int * poffset) { p_tnode pnode = *ppnode; int median = pnode->nkeys>>1, i; p_tnode parent = pnode->parent, split = alloc_tnode();

}

if (poffset != NULL) { /* update offset index and ppnode to point to new insertion point */ if (*poffset > median) { /* move to new (split) node */ *poffset -= (median+1); *ppnode = split; } if (parent) { int insert = find_index(pnode->keys[median],parent); /* move median into parent */ for (i = parent->nkeys; i > insert; i--) { parent->keys[i] = parent->keys[i-1]; parent->values[i] = parent->values[i-1]; parent->children[i+1] = parent->children[i]; } parent->keys[insert] = pnode->keys[median]; parent->values[insert] = pnode->values[median]; parent->children[insert] = pnode; parent->nkeys++; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL;

programminghomeworkhelp.com

}

split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[insert+1] = split; split->parent = parent;

} else {

}

/* split root */ parent = ptreeroot = alloc_tnode(); parent->keys[0] = pnode->keys[median]; parent->values[0] = pnode->values[median]; parent->children[0] = pnode; parent->nkeys = 1; pnode->parent = parent;

}

/* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[1] = split; split->parent = parent;

/* add_element() - add the record with the specified key to the B-tree. * returns a pointer to an already existing record with the same key, * in which case, the new record was not inserted, or NULL on success * should be no need to modify this function */ nodevalue * add_element(nodekey key, nodevalue * pvalue) { /* find leaf */

programminghomeworkhelp.com

p_tnode pleaf = ptreeroot, parent = NULL; int ichild, i; while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* already exists */ return pleaf->values[-(ichild+1)]; if (pleaf->nkeys == 2*T-1) { /* split leaf into two nodes */ split_node(&pleaf, &ichild); } parent = pleaf; pleaf = pleaf->children[ichild]; } pleaf = parent; record_count++; /* record actually added to tree */ /* enough room, just add to leaf */ for (i = pleaf->nkeys; i > ichild; i--) { pleaf->keys[i] = pleaf->keys[i-1]; pleaf->values[i] = pleaf->values[i-1]; } pleaf->keys[ichild] = key; pleaf->values[ichild] = pvalue; pleaf->nkeys++; }

return NULL;

/* inorder_traversal() - traverse B-tree, in sorted order * similar to binary search tree traversal (except nodes have multiple values and children) * writes record info to file pointer fp * * TODO: fill in this function */ void inorder_traversal(p_tnode pnode, FILE * fp) { int n;

programminghomeworkhelp.com

for (n = 0; n < pnode->nkeys; n++) { /* TODO: traverse children and keys, in order */ if (pnode->children[n] != NULL) inorder_traversal(pnode->children[n], fp); display_record(pnode->values[n], fp); } if (pnode->children[n] != NULL) { /* TODO: don't forget about the last child */ inorder_traversal(pnode->children[n], fp); } } /* find_value() - locate value for specified key in B-tree * need to return pointer to record structure, or NULL if record not found * TODO: fill in this function */ nodevalue * find_value(const nodekey key) { int ichild; p_tnode pleaf = ptreeroot; /* start at root */ /* TODO: iterate pleaf down to leaves of tree, or until key is found */ }

return NULL; /* didn't find it */

/* display_result() - print information from the database * this function is a valid callback for use with sqlite3_exec() * pextra is unused * * needs to return zero (nonzero aborts SQL query) */ int display_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n; for (n = 0; n < nfields; n++) { printf("%s: [%s] ", arrfieldnames[n], arrvalues[n]); } printf("\n"); return 0;

programminghomeworkhelp.com

} /* store_result() - store record from database in B-tree * this function is also a valid callback for use with sqlite3_exec() * pextra is again unused * * needs to return zero (nonzero aborts SQL query) */ int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n; /* allocate record on heap */ struct s_record * prec = alloc_record(); prec->irecord = record_count+1; for (n = 0; n < nfields; n++) { if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0) prec->name = strdup(arrvalues[n]); /* key */ else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0) prec->category = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0) prec->year = atoi(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Format") == 0) prec->format = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Language") == 0) prec->language = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Web") == 0) prec->url = strdup(arrvalues[n]); } /* add record to B-tree */ if (add_element(prec->name, prec) != NULL) { /* element already exists -- don't add record */ printf("Duplicate record exists: "); /* diagnostic value only */ display_record(prec, stdout); free_record(prec); } return 0;

programminghomeworkhelp.com

} int main(int argc, char * argv[]) { sqlite3 * pDb = NULL; int nresult; /* part (a): execute the first three SQL queries */ /* const char sql[] = "SELECT * FROM movies WHERE ProductionYear < 1950"; */ /* const char sql[] = "SELECT * FROM movies WHERE Format == \"VHS\""; */ /* const char sql[] = "SELECT * FROM movies WHERE Language == \"Spanish\""; */ /* part (b, c, d): use this SQL query to read the entire table */ const char sql[] = "SELECT * FROM movies"; if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } ptreeroot = alloc_tnode(); /* TODO: load the database, probably using sqlite3_open() */ if ( (nresult = sqlite3_open(argv[1],&pDb)) != SQLITE_OK) fprintf(stderr,"Error: the database could not be opened. %s (%d)\n", sqlite3_errmsg(pDb), nresult); else { char * errmsg = NULL; /* TODO: execute the SQL query, probably using sqlite3_exec() */ nresult = sqlite3_exec(pDb, sql, store_result, NULL, &errmsg); if (errmsg) { fprintf(stderr, "Error executing SQL query: %s.\n", errmsg); sqlite3_free(errmsg); } }

programminghomeworkhelp.com

/* TODO: close the database when you're done with it */ sqlite3_close(pDb); if (argc >= 3) { FILE * fp = fopen(argv[2], "w"); if (fp != NULL) { inorder_traversal(ptreeroot, fp); fclose(fp); } } free_tnode(ptreeroot); return 0; } /* * prob1csol.c * * Created on: Jan 20, 2010 * Author: dweller */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* the include file for the SQLite library */ /* do not use sqlite.h or sqlite3ext.h */ #include <sqlite3.h> /* T defines minimum number of children in non-root nodes * 2*T is maximum number of children in all nodes * 2*T-1 is maximum number of keys in all nodes */ #define T 3 typedef char * nodekey; /* record structure */ typedef struct s_record { unsigned int irecord; /* index of record in main database */

programminghomeworkhelp.com

char * name; /* movie name used as key */ char * category; unsigned int year; char * format; char * language; char * url; } nodevalue; /* B-tree node structure */ typedef struct s_tnode { nodekey keys[2*T-1]; /* keys */ nodevalue * values[2*T-1]; /* values */ unsigned int nkeys; /* number of keys, < 2*T */ struct s_tnode * parent; /* pointer to parent */ struct s_tnode * children[2*T]; /* pointers to children */ } * p_tnode; /* static variables for the root of the tree and number of records */ static p_tnode ptreeroot = NULL; static unsigned int record_count = 0; /* alloc_record() - allocate a new record on the heap */ struct s_record * alloc_record() { struct s_record * precord = (struct s_record *)malloc(sizeof(struct s_record)); precord->irecord = 0; precord->name = NULL; /* movie name used as key */ precord->category = NULL; precord->year = 0; precord->format = NULL; precord->language = NULL; precord->url = NULL; return precord; } /* free_record() - frees the record structure and associated strings */ void free_record(struct s_record * precord) { if (precord->name) free(precord->name); if (precord->category) free(precord->category);

programminghomeworkhelp.com

if (precord->format) free(precord->format); if (precord->language) free(precord->language); if (precord->url) free(precord->url); free(precord); } /* display_record -- output record information to file pointer fp */ void display_record(struct s_record * precord, FILE * fp) { fprintf(fp, "[#%d] %s (%d): %s, %s, %s, <%s>\n", precord->irecord, precord->name, precord->year, precord->category, precord->format, precord>language, precord->url); } /* alloc_tnode() - creates a new B-tree node on the heap */ p_tnode alloc_tnode(void) { int n; p_tnode pnode = (p_tnode)malloc(sizeof(struct s_tnode)); pnode->nkeys = 0; for (n = 0; n < 2*T; n++) pnode->children[n] = NULL; pnode->parent = NULL; return pnode; } /* free_tnode() - frees a node in the B-tree, * its associated record, and all its children from memory */ void free_tnode(p_tnode pnode) { unsigned int n; for (n = 0; n < 2*T; n++) { if (pnode->children[n] != NULL) free_tnode(pnode->children[n]); } for (n = 0; n < pnode->nkeys; n++) { if (pnode->values[n]) free_record(pnode->values[n]); } }

free(pnode);

programminghomeworkhelp.com

/* function for comparing two keys; simply calls the case-insensitive * string comparison function strcasecmp() declared in string.h. * Returns zero if both equal, positive if key1 > key2, negative if key1 < key2 */ int key_compare(const nodekey key1, const nodekey key2) { return strcasecmp(key1, key2); } /* find_index() - performs binary search of list of keys in node * to find either the index of the existing key, or the insertion * point of a new key. Returns nonnegative index of insertion point * if new key, or -(index+1) for existing key found at index * * TODO: fill in the binary search while loop */ int find_index(nodekey key, p_tnode pnode) { /* find in between */ int icmp, L = 0, R = pnode->nkeys-1, M; int ibetween = 0; /* index to return */

}

/* TODO: complete binary search; * use key_compare() to compare two keys. */ while (L <= R) { M = (L+R) >> 1; icmp = key_compare(key, pnode->keys[M]); if (icmp == 0) { /* key exists */ return -(M+1); } else if (icmp > 0) { L = M+1; ibetween = L; } else { R = M-1; ibetween = R+1; } } return ibetween;

programminghomeworkhelp.com

/* split_node() - splits a full node in the B-tree into two separate nodes, * possibly creating a new root node in the process * should be no need to modify this function */ void split_node(p_tnode * ppnode, int * poffset) { p_tnode pnode = *ppnode; int median = pnode->nkeys>>1, i; p_tnode parent = pnode->parent, split = alloc_tnode(); if (poffset != NULL) { /* update offset index and ppnode to point to new insertion point */ if (*poffset > median) { /* move to new (split) node */ *poffset -= (median+1); *ppnode = split; } } if (parent) { int insert = find_index(pnode->keys[median],parent); /* move median into parent */ for (i = parent->nkeys; i > insert; i--) { parent->keys[i] = parent->keys[i-1]; parent->values[i] = parent->values[i-1]; parent->children[i+1] = parent->children[i]; } parent->keys[insert] = pnode->keys[median]; parent->values[insert] = pnode->values[median]; parent->children[insert] = pnode; parent->nkeys++; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split;

programminghomeworkhelp.com

pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[insert+1] = split; split->parent = parent; } else { /* split root */ parent = ptreeroot = alloc_tnode(); parent->keys[0] = pnode->keys[median]; parent->values[0] = pnode->values[median]; parent->children[0] = pnode; parent->nkeys = 1; pnode->parent = parent;

}

}

/* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[1] = split; split->parent = parent;

/* add_element() - add the record with the specified key to the B-tree. * returns a pointer to an already existing record with the same key, * in which case, the new record was not inserted, or NULL on success * should be no need to modify this function */

programminghomeworkhelp.com

nodevalue * add_element(nodekey key, nodevalue * pvalue) { /* find leaf */ p_tnode pleaf = ptreeroot, parent = NULL; int ichild, i; while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* already exists */ return pleaf->values[-(ichild+1)]; if (pleaf->nkeys == 2*T-1) { /* split leaf into two nodes */ split_node(&pleaf, &ichild); } parent = pleaf; pleaf = pleaf->children[ichild]; } pleaf = parent; record_count++; /* record actually added to tree */ /* enough room, just add to leaf */ for (i = pleaf->nkeys; i > ichild; i--) { pleaf->keys[i] = pleaf->keys[i-1]; pleaf->values[i] = pleaf->values[i-1]; } pleaf->keys[ichild] = key; pleaf->values[ichild] = pvalue; pleaf->nkeys++; }

return NULL;

/* inorder_traversal() - traverse B-tree, in sorted order * similar to binary search tree traversal (except nodes have multiple values and children) * writes record info to file pointer fp * * TODO: fill in this function */ void inorder_traversal(p_tnode pnode, FILE * fp) { int n;

programminghomeworkhelp.com

for (n = 0; n < pnode->nkeys; n++) { /* TODO: traverse children and keys, in order */ if (pnode->children[n] != NULL) inorder_traversal(pnode->children[n], fp); display_record(pnode->values[n], fp); } if (pnode->children[n] != NULL) { /* TODO: don't forget about the last child */ inorder_traversal(pnode->children[n], fp); } } /* find_value() - locate value for specified key in B-tree * need to return pointer to record structure, or NULL if record not found * TODO: fill in this function */ nodevalue * find_value(const nodekey key) { int ichild; p_tnode pleaf = ptreeroot; /* start at root */ /* TODO: iterate pleaf down to leaves of tree, or until key is found */ while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* found it */ return pleaf->values[-(ichild+1)]; pleaf = pleaf->children[ichild]; } }

return NULL; /* didn't find it */

/* display_result() - print information from the database * this function is a valid callback for use with sqlite3_exec() * pextra is unused * * needs to return zero (nonzero aborts SQL query) */ int display_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n;

programminghomeworkhelp.com

}

for (n = 0; n < nfields; n++) { printf("%s: [%s] ", arrfieldnames[n], arrvalues[n]); } printf("\n"); return 0;

/* store_result() - store record from database in B-tree * this function is also a valid callback for use with sqlite3_exec() * pextra is again unused * * needs to return zero (nonzero aborts SQL query) */ int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n;

/* allocate record on heap */ struct s_record * prec = alloc_record(); prec->irecord = record_count+1; for (n = 0; n < nfields; n++) { if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0) prec->name = strdup(arrvalues[n]); /* key */ else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0) prec->category = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0) prec->year = atoi(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Format") == 0) prec->format = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Language") == 0) prec->language = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Web") == 0) prec->url = strdup(arrvalues[n]); }

programminghomeworkhelp.com

/* add record to B-tree */ if (add_element(prec->name, prec) != NULL) { /* element already exists -- don't add record */ printf("Duplicate record exists: "); /* diagnostic value only */ display_record(prec, stdout); free_record(prec); } }

return 0;

#define MAX_TITLE 256 int main(int argc, char * argv[]) { sqlite3 * pDb = NULL; int nresult, len; char strtext[MAX_TITLE]; struct s_record * pvalue; /* part (a): execute the first three SQL queries */ /* const char sql[] = "SELECT * FROM movies WHERE ProductionYear < 1950"; */ /* const char sql[] = "SELECT * FROM movies WHERE Format == \"VHS\""; */ /* const char sql[] = "SELECT * FROM movies WHERE Language == \"Spanish\""; */ /* part (b, c, d): use this SQL query to read the entire table */ const char sql[] = "SELECT * FROM movies"; if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } ptreeroot = alloc_tnode(); /* TODO: load the database, probably using sqlite3_open() */ if ( (nresult = sqlite3_open(argv[1],&pDb)) != SQLITE_OK) fprintf(stderr,"Error: the database could not be opened. %s (%d)\n", sqlite3_errmsg(pDb), nresult); else { char * errmsg = NULL;

programminghomeworkhelp.com

/* TODO: execute the SQL query, probably using sqlite3_exec() */ nresult = sqlite3_exec(pDb, sql, store_result, NULL, &errmsg); if (errmsg) { fprintf(stderr, "Error executing SQL query: %s.\n", errmsg); sqlite3_free(errmsg); } } /* TODO: close the database when you're done with it */ sqlite3_close(pDb); do {

if (fgets(strtext,MAX_TITLE,stdin) == NULL) break; len = strlen(strtext); if (len > 0 && strtext[len-1] == '\n') strtext[--len] = '\0'; if (len == 0) break; pvalue = find_value(strtext); if (pvalue == NULL) printf("Movie \"%s\" not found!\n", strtext); else { printf("Found: "); display_record(pvalue, stdout); }

} while (len > 0); free_tnode(ptreeroot); }

return 0;

programminghomeworkhelp.com

/* * prob1d.c * * Created on: Jan 20, 2010 * Author: dweller */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* functions defined in your code */ int initialize_db (const char * filename); int locate_movie(char * title ); void dump_sorted_list(const char * filename); void cleanup(void); #define NUM_TITLES 10 int main(int argc, char * argv[]) { int nresult, n; char strtitles[NUM_TITLES][256] = {"Citizen Kane", "Ponderosa", "Gosford Park", "Transformers", "Gone with the Wind", "When Harry Met Sally", "Avatar", "Simpsons Movie, The", "American Pie 2", "Superman Returns"}; struct s_record * pvalue; if (argc < 2) { fprintf(stderr,"Error: database name not specified!\n"); return 1; } if (argc < 3) { fprintf(stderr,"Error: output file name not specified!\n"); return 1; } /* initialize B-tree and fill with database */ if ( (nresult = initialize_db(argv[1])) != 0) { cleanup(); return nresult; /* error during initialization */

programminghomeworkhelp.com

} dump_sorted_list(argv[2]); for (n = 0; n < NUM_TITLES; n++) { if ( (nresult = locate_movie(strtitles[n])) == 0) printf("Movie \"%s\" not found!\n", strtitles[n]); } cleanup(); }

return 0;

/* * prob1dsol.c * * Created on: Jan 20, 2010 * Author: dweller */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* the include file for the SQLite library */ /* do not use sqlite.h or sqlite3ext.h */ #include <sqlite3.h> /* T defines minimum number of children in non-root nodes * 2*T is maximum number of children in all nodes * 2*T-1 is maximum number of keys in all nodes */ #define T 3 typedef char * nodekey; /* record structure */ typedef struct s_record {

programminghomeworkhelp.com

unsigned int irecord; /* index of record in main database */ char * name; /* movie name used as key */ char * category; unsigned int year; char * format; char * language; char * url; } nodevalue; /* B-tree node structure */ typedef struct s_tnode { nodekey keys[2*T-1]; /* keys */ nodevalue * values[2*T-1]; /* values */ unsigned int nkeys; /* number of keys, < 2*T */ struct s_tnode * parent; /* pointer to parent */ struct s_tnode * children[2*T]; /* pointers to children */ } * p_tnode; /* static variables for the root of the tree and number of records */ static p_tnode ptreeroot = NULL; static unsigned int record_count = 0; /* alloc_record() - allocate a new record on the heap */ struct s_record * alloc_record() { struct s_record * precord = (struct s_record *)malloc(sizeof(struct s_record)); precord->irecord = 0; precord->name = NULL; /* movie name used as key */ precord->category = NULL; precord->year = 0; precord->format = NULL; precord->language = NULL; precord->url = NULL; return precord; } /* free_record() - frees the record structure and associated strings */ void free_record(struct s_record * precord) { if (precord->name) free(precord->name);

programminghomeworkhelp.com

if (precord->category) free(precord->category); if (precord->format) free(precord->format); if (precord->language) free(precord->language); if (precord->url) free(precord->url); free(precord); } /* display_record -- output record information to file pointer fp */ void display_record(struct s_record * precord, FILE * fp) { fprintf(fp, "[#%d] %s (%d): %s, %s, %s, <%s>\n", precord->irecord, precord->name, precord->year, precord->category, precord->format, precord>language, precord->url); } /* alloc_tnode() - creates a new B-tree node on the heap */ p_tnode alloc_tnode(void) { int n; p_tnode pnode = (p_tnode)malloc(sizeof(struct s_tnode)); pnode->nkeys = 0; for (n = 0; n < 2*T; n++) pnode->children[n] = NULL; pnode->parent = NULL; return pnode; } /* free_tnode() - frees a node in the B-tree, * its associated record, and all its children from memory */ void free_tnode(p_tnode pnode) { unsigned int n; for (n = 0; n < 2*T; n++) { if (pnode->children[n] != NULL) free_tnode(pnode->children[n]); } for (n = 0; n < pnode->nkeys; n++) { if (pnode->values[n]) free_record(pnode->values[n]); }

programminghomeworkhelp.com

}

free(pnode);

/* function for comparing two keys; simply calls the case-insensitive * string comparison function strcasecmp() declared in string.h. * Returns zero if both equal, positive if key1 > key2, negative if key1 < key2 */ int key_compare(const nodekey key1, const nodekey key2) { return strcasecmp(key1, key2); } /* find_index() - performs binary search of list of keys in node * to find either the index of the existing key, or the insertion * point of a new key. Returns nonnegative index of insertion point * if new key, or -(index+1) for existing key found at index * * TODO: fill in the binary search while loop */ int find_index(nodekey key, p_tnode pnode) { /* find in between */ int icmp, L = 0, R = pnode->nkeys-1, M; int ibetween = 0; /* index to return */ /* TODO: complete binary search; * use key_compare() to compare two keys. */ while (L <= R) { M = (L+R) >> 1; icmp = key_compare(key, pnode->keys[M]); if (icmp == 0) { /* key exists */ return -(M+1); } else if (icmp > 0) { L = M+1; ibetween = L; } else { R = M-1; ibetween = R+1; }

programminghomeworkhelp.com

} }

return ibetween;

/* split_node() - splits a full node in the B-tree into two separate nodes, * possibly creating a new root node in the process * should be no need to modify this function */ void split_node(p_tnode * ppnode, int * poffset) { p_tnode pnode = *ppnode; int median = pnode->nkeys>>1, i; p_tnode parent = pnode->parent, split = alloc_tnode(); if (poffset != NULL) { /* update offset index and ppnode to point to new insertion point */ if (*poffset > median) { /* move to new (split) node */ *poffset -= (median+1); *ppnode = split; } } if (parent) { int insert = find_index(pnode->keys[median],parent); /* move median into parent */ for (i = parent->nkeys; i > insert; i--) { parent->keys[i] = parent->keys[i-1]; parent->values[i] = parent->values[i-1]; parent->children[i+1] = parent->children[i]; } parent->keys[insert] = pnode->keys[median]; parent->values[insert] = pnode->values[median]; parent->children[insert] = pnode; parent->nkeys++; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i];

programminghomeworkhelp.com

}

} else {

}

}

for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[insert+1] = split; split->parent = parent; /* split root */ parent = ptreeroot = alloc_tnode(); parent->keys[0] = pnode->keys[median]; parent->values[0] = pnode->values[median]; parent->children[0] = pnode; parent->nkeys = 1; pnode->parent = parent; /* move half from pnode into new node */ for (i = median + 1; i < pnode->nkeys; i++) { split->keys[i-(median+1)] = pnode->keys[i]; split->values[i-(median+1)] = pnode->values[i]; } for (i = median + 1; i < pnode->nkeys+1; i++) { split->children[i-(median+1)] = pnode->children[i]; if (pnode->children[i] != NULL) pnode->children[i]->parent = split; pnode->children[i] = NULL; } split->nkeys = pnode->nkeys - (median+1); pnode->nkeys = median; parent->children[1] = split; split->parent = parent;

programminghomeworkhelp.com

/* add_element() - add the record with the specified key to the B-tree. * returns a pointer to an already existing record with the same key, * in which case, the new record was not inserted, or NULL on success * should be no need to modify this function */ nodevalue * add_element(nodekey key, nodevalue * pvalue) { /* find leaf */ p_tnode pleaf = ptreeroot, parent = NULL; int ichild, i; while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* already exists */ return pleaf->values[-(ichild+1)]; if (pleaf->nkeys == 2*T-1) { /* split leaf into two nodes */ split_node(&pleaf, &ichild); } parent = pleaf; pleaf = pleaf->children[ichild]; } pleaf = parent; record_count++; /* record actually added to tree */ /* enough room, just add to leaf */ for (i = pleaf->nkeys; i > ichild; i--) { pleaf->keys[i] = pleaf->keys[i-1]; pleaf->values[i] = pleaf->values[i-1]; } pleaf->keys[ichild] = key; pleaf->values[ichild] = pvalue; pleaf->nkeys++; }

return NULL;

/* inorder_traversal() - traverse B-tree, in sorted order

programminghomeworkhelp.com

* similar to binary search tree traversal (except nodes have multiple values and children) * writes record info to file pointer fp * * TODO: fill in this function */ void inorder_traversal(p_tnode pnode, FILE * fp) { int n; for (n = 0; n < pnode->nkeys; n++) { /* TODO: traverse children and keys, in order */ if (pnode->children[n] != NULL) inorder_traversal(pnode->children[n], fp); display_record(pnode->values[n], fp); } if (pnode->children[n] != NULL) { /* TODO: don't forget about the last child */ inorder_traversal(pnode->children[n], fp); } } /* find_value() - locate value for specified key in B-tree * need to return pointer to record structure, or NULL if record not found * TODO: fill in this function */ nodevalue * find_value(const nodekey key) { int ichild; p_tnode pleaf = ptreeroot; /* start at root */ /* TODO: iterate pleaf down to leaves of tree, or until key is found */ while (pleaf != NULL) { ichild = find_index(key, pleaf); if (ichild < 0) /* found it */ return pleaf->values[-(ichild+1)]; pleaf = pleaf->children[ichild]; } }

return NULL; /* didn't find it */

programminghomeworkhelp.com

/* display_result() - print information from the database * this function is a valid callback for use with sqlite3_exec() * pextra is unused * * needs to return zero (nonzero aborts SQL query) */ int display_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n;

}

for (n = 0; n < nfields; n++) { printf("%s: [%s] ", arrfieldnames[n], arrvalues[n]); } printf("\n"); return 0;

/* store_result() - store record from database in B-tree * this function is also a valid callback for use with sqlite3_exec() * pextra is again unused * * needs to return zero (nonzero aborts SQL query) */ int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) { int n; /* allocate record on heap */ struct s_record * prec = alloc_record(); prec->irecord = record_count+1; for (n = 0; n < nfields; n++) { if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0) prec->name = strdup(arrvalues[n]); /* key */ else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0) prec->category = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0) prec->year = atoi(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Format") == 0) prec->format = strdup(arrvalues[n]); else if (strcasecmp(arrfieldnames[n], "Language") == 0) prec->language = strdup(arrvalues[n]);

programminghomeworkhelp.com

else if (strcasecmp(arrfieldnames[n], "Web") == 0) prec->url = strdup(arrvalues[n]); } /* add record to B-tree */ if (add_element(prec->name, prec) != NULL) { /* element already exists -- don't add record */ printf("Duplicate record exists: "); /* diagnostic value only */ display_record(prec, stdout); free_record(prec); } }

return 0;

int initialize_db (const char * filename) { const char sql[] = "SELECT * FROM movies"; sqlite3 * pDb = NULL; int nresult, ret = 0; ptreeroot = alloc_tnode(); if ( (nresult = sqlite3_open(filename,&pDb)) != SQLITE_OK) { fprintf(stderr,"Error: the database could not be opened. %s (%d)\n", sqlite3_errmsg(pDb), nresult); ret = 1; } else { char * errmsg = NULL; nresult = sqlite3_exec(pDb, sql, store_result, NULL, &errmsg); if (errmsg) { fprintf(stderr, "Error executing SQL query: %s.\n", errmsg); sqlite3_free(errmsg); ret = 2; } } sqlite3_close(pDb); return ret;

programminghomeworkhelp.com

} int locate_movie(char * title ) { struct s_record * pvalue;

}

pvalue = find_value(title); if (pvalue != NULL) { printf("Found: "); display_record(pvalue, stdout); } return pvalue != NULL;

void dump_sorted_list(const char * filename) { FILE * fp = fopen(filename, "w"); if (fp != NULL) { inorder_traversal(ptreeroot, fp); fclose(fp); } } void cleanup(void) { if (ptreeroot) { free_tnode(ptreeroot); ptreeroot = NULL; } }

programminghomeworkhelp.com