Edit File: example_database_load.c
/*- * See the file LICENSE for redistribution information. * * Copyright (c) 2004,2008 Oracle. All rights reserved. */ #include "gettingstarted_common.h" /* Forward declarations */ int usage(void); int load_vendors_database(STOCK_DBS, char *); size_t pack_string(char *, char *, size_t); int load_inventory_database(STOCK_DBS, char *); int usage() { fprintf(stderr, "example_database_load [-b <path to data files>]"); fprintf(stderr, " [-h <database_home_directory>]\n"); fprintf(stderr, "\tNote: Any path specified must end with your"); fprintf(stderr, " system's path delimiter (/ or \\)\n"); return (-1); } /* * Loads the contents of vendors.txt and inventory.txt into * Berkeley DB databases. Also causes the itemname secondary * database to be created and loaded. */ int main(int argc, char *argv[]) { STOCK_DBS my_stock; int ch, ret; size_t size; char *basename, *inventory_file, *vendor_file; /* Initialize the STOCK_DBS struct */ initialize_stockdbs(&my_stock); /* Initialize the base path. */ basename = "./"; /* Parse the command line arguments */ while ((ch = getopt(argc, argv, "b:h:")) != EOF) switch (ch) { case 'h': if (optarg[strlen(optarg)-1] != '/' && optarg[strlen(optarg)-1] != '\\') return (usage()); my_stock.db_home_dir = optarg; break; case 'b': if (basename[strlen(basename)-1] != '/' && basename[strlen(basename)-1] != '\\') return (usage()); basename = optarg; break; case '?': default: return (usage()); } /* Identify the files that will hold our databases */ set_db_filenames(&my_stock); /* Find our input files */ size = strlen(basename) + strlen(INVENTORY_FILE) + 1; inventory_file = malloc(size); snprintf(inventory_file, size, "%s%s", basename, INVENTORY_FILE); size = strlen(basename) + strlen(VENDORS_FILE) + 1; vendor_file = malloc(size); snprintf(vendor_file, size, "%s%s", basename, VENDORS_FILE); /* Open all databases */ ret = databases_setup(&my_stock, "example_database_load", stderr); if (ret) { fprintf(stderr, "Error opening databases\n"); databases_close(&my_stock); return (ret); } ret = load_vendors_database(my_stock, vendor_file); if (ret) { fprintf(stderr, "Error loading vendors database.\n"); databases_close(&my_stock); return (ret); } ret = load_inventory_database(my_stock, inventory_file); if (ret) { fprintf(stderr, "Error loading inventory database.\n"); databases_close(&my_stock); return (ret); } /* close our environment and databases */ databases_close(&my_stock); printf("Done loading databases.\n"); return (ret); } /* * Loads the contents of the vendors.txt file into * a database. */ int load_vendors_database(STOCK_DBS my_stock, char *vendor_file) { DBT key, data; char buf[MAXLINE]; FILE *ifp; VENDOR my_vendor; /* Load the vendors database */ ifp = fopen(vendor_file, "r"); if (ifp == NULL) { fprintf(stderr, "Error opening file '%s'\n", vendor_file); return (-1); } while (fgets(buf, MAXLINE, ifp) != NULL) { /* zero out the structure */ memset(&my_vendor, 0, sizeof(VENDOR)); /* Zero out the DBTs */ memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); /* * Scan the line into the structure. * Convenient, but not particularly safe. * In a real program, there would be a lot more * defensive code here. */ sscanf(buf, "%20[^#]#%20[^#]#%20[^#]#%3[^#]#%6[^#]#%13[^#]#%20[^#]#%20[^\n]", my_vendor.name, my_vendor.street, my_vendor.city, my_vendor.state, my_vendor.zipcode, my_vendor.phone_number, my_vendor.sales_rep, my_vendor.sales_rep_phone); /* Now that we have our structure we can load it into the database. */ /* Set up the database record's key */ key.data = my_vendor.name; key.size = (u_int32_t)strlen(my_vendor.name) + 1; /* Set up the database record's data */ data.data = &my_vendor; data.size = sizeof(VENDOR); /* * Note that given the way we built our struct, there's extra * bytes in it. Essentially we're using fixed-width fields with * the unused portion of some fields padded with zeros. This * is the easiest thing to do, but it does result in a bloated * database. Look at load_inventory_data() for an example of how * to avoid this. */ /* Put the data into the database */ my_stock.vendor_dbp->put(my_stock.vendor_dbp, 0, &key, &data, 0); } /* end vendors database while loop */ fclose(ifp); return (0); } /* * Simple little convenience function that takes a buffer, a string, * and an offset and copies that string into the buffer at the * appropriate location. Used to ensure that all our strings * are contained in a single contiguous chunk of memory. */ size_t pack_string(char *buffer, char *string, size_t start_pos) { size_t string_size; string_size = strlen(string) + 1; memcpy(buffer+start_pos, string, string_size); return (start_pos + string_size); } /* * Loads the contents of the inventory.txt file into * a database. Note that because the itemname * secondary database is associated to the inventorydb * (see env_setup() in gettingstarted_common.c), the * itemname index is automatically created when this * database is loaded. */ int load_inventory_database(STOCK_DBS my_stock, char *inventory_file) { DBT key, data; char buf[MAXLINE]; char databuf[MAXDATABUF]; size_t bufLen, dataLen; FILE *ifp; /* * Rather than lining everything up nicely in a struct, we're being * deliberately a bit sloppy here. This function illustrates how to * store mixed data that might be obtained from various locations * in your application. */ float price; int quantity; char category[MAXFIELD], name[MAXFIELD]; char vendor[MAXFIELD], sku[MAXFIELD]; /* Load the inventory database */ ifp = fopen(inventory_file, "r"); if (ifp == NULL) { fprintf(stderr, "Error opening file '%s'\n", inventory_file); return (-1); } while (fgets(buf, MAXLINE, ifp) != NULL) { /* * Scan the line into the appropriate buffers and variables. * Convenient, but not particularly safe. In a real * program, there would be a lot more defensive code here. */ sscanf(buf, "%20[^#]#%20[^#]#%f#%i#%20[^#]#%20[^\n]", name, sku, &price, &quantity, category, vendor); /* * Now pack it into a single contiguous memory location for * storage. */ memset(databuf, 0, MAXDATABUF); bufLen = 0; dataLen = 0; dataLen = sizeof(float); memcpy(databuf, &price, dataLen); bufLen += dataLen; dataLen = sizeof(int); memcpy(databuf + bufLen, &quantity, dataLen); bufLen += dataLen; bufLen = pack_string(databuf, name, bufLen); bufLen = pack_string(databuf, sku, bufLen); bufLen = pack_string(databuf, category, bufLen); bufLen = pack_string(databuf, vendor, bufLen); /* Zero out the DBTs */ memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); /* The key is the item's SKU */ key.data = sku; key.size = (u_int32_t)strlen(sku) + 1; /* The data is the information that we packed into databuf. */ data.data = databuf; data.size = (u_int32_t)bufLen; /* Put the data into the database */ my_stock.vendor_dbp->put(my_stock.inventory_dbp, 0, &key, &data, 0); } /* end vendors database while loop */ /* Cleanup */ fclose(ifp); return (0); }
Back to File Manager