Modify getting_started example_c code to an In-Memory application

Question

I am learning Berkeley DB In-Memory Application. I use
db-4.7.25/examples_c as a base code and made a simply modifications. Please see
below. It appears that something I missed or I don't understand how to
write an In-Memory Application with Berkeley DB. It would be very
appreciated if you could point me where I missed and what I did wrong.
gettingstarted_common.c:
/* Opens a database */
int
open_database(DB **dbpp, const char *file_name,
const char program_name, FILE error_file_pointer,
int is_secondary)
DB dbp;    / For convenience */
u_int32_t open_flags;
int ret;
/* Initialize the DB handle */
ret = db_create(&dbp, NULL, 0);
if (ret != 0) {
fprintf(error_file_pointer, "%s: %s\n", program_name,
db_strerror(ret));
return (ret);
/* set the cache size here */
ret = dbp->set_cachesize(dbp,
0, /* 0 gigabytes */
10 * 1024 * 1024, /* 10 megabytes */
1); /* create 1 cashe, all memory will
* be allocated contigously */
if (ret != 0){
dbp->err(dbp, ret, "Database open failed");
return (ret);
/* Point to the memory malloc'd by db_create() */
*dbpp = dbp;
/* Set up error handling for this database */
dbp->set_errfile(dbp, error_file_pointer);
dbp->set_errpfx(dbp, program_name);
* If this is a secondary database, then we want to allow
* sorted duplicates.
if (is_secondary) {
ret = dbp->set_flags(dbp, DB_DUPSORT);
if (ret != 0) {
dbp->err(dbp, ret, "Attempt to set DUPSORT flags failed.",
file_name);
return (ret);
/* Set the open flags */
open_flags = DB_CREATE; /* Allow database creation */
/* Now open the database */
ret = dbp->open(dbp, /* Pointer to the database */
NULL, /* Txn pointer */
NULL, /* File name */
file_name, /* Logical db name */
DB_BTREE, /* Database type (using btree) */
open_flags, /* Open flags */
0); /* File mode. Using defaults */
if (ret != 0) {
dbp->err(dbp, ret, "Database '%s' open failed.", file_name);
return (ret);
return (0);
/* opens all databases */
int
databases_setup(STOCK_DBS my_stock, const char program_name,
FILE *error_file_pointer)
int ret;
const char *db_vendor = "in_mem_vendor";
const char *db_inventory = "in_mem_inventory";
const char *db_itemname = "in_mem_itemname";
/* Open the vendor database */
ret = open_database(&(my_stock->vendor_dbp),
// my_stock->vendor_db_name,
db_vendor,
program_name, error_file_pointer,
PRIMARY_DB);
if (ret != 0)
* Error reporting is handled in open_database() so just return
* the return code.
return (ret);
/* Open the inventory database */
ret = open_database(&(my_stock->inventory_dbp),
// my_stock->inventory_db_name,
db_inventory,
program_name, error_file_pointer,
PRIMARY_DB);
if (ret != 0)
* Error reporting is handled in open_database() so just return
* the return code.
return (ret);
* Open the itemname secondary database. This is used to
* index the product names found in the inventory
* database.
ret = open_database(&(my_stock->itemname_sdbp),
// my_stock->itemname_db_name,
db_itemname,
program_name, error_file_pointer,
SECONDARY_DB);
if (ret != 0)
* Error reporting is handled in open_database() so just return
* the return code.
return (0);
* Associate the itemname db with its primary db
* (inventory db).
my_stock->inventory_dbp->associate(
my_stock->inventory_dbp, /* Primary db */
NULL, /* txn id */
my_stock->itemname_sdbp, /* Secondary db */
get_item_name, /* Secondary key creator */
0); /* Flags */
printf("databases opened successfully\n");
return (0);
example_database_load.c:
* 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);
example_database_read.c:
* Searches for a inventory item based on that item's name. The search is
* performed using the item name secondary database. Displays all
* inventory items that use the specified name, as well as the vendor
* associated with that inventory item.
* If no item name is provided, then all inventory items are displayed.
int
main(int argc, char *argv[])
STOCK_DBS my_stock;
int ch, ret;
char *itemname;
/* Initialize the STOCK_DBS struct */
initialize_stockdbs(&my_stock);
/* Parse the command line arguments */
itemname = NULL;
while ((ch = getopt(argc, argv, "h:i:?")) != EOF)
switch (ch) {
case 'h':
if (optarg[strlen(optarg)-1] != '/' &&
optarg[strlen(optarg)-1] != '\\')
return (usage());
my_stock.db_home_dir = optarg;
break;
case 'i':
itemname = optarg;
break;
case '?':
default:
return (usage());
/* Identify the files that hold our databases */
// set_db_filenames(&my_stock);
/* Open all databases */
ret = databases_setup(&my_stock, "example_database_read", stderr);
if (ret != 0) {
fprintf(stderr, "Error opening databases\n");
databases_close(&my_stock);
return (ret);
if (itemname == NULL)
ret = show_all_records(&my_stock);
else
ret = show_records(&my_stock, itemname);
/* close our databases */
databases_close(&my_stock);
return (ret);
Run test results:
[user@localhost in_memory]$ ls
build_command.txt example_database_read.c gettingstarted_common.h load vendors.txt
example_database_load.c example_database_read.o gettingstarted_common.o makefile
example_database_load.o gettingstarted_common.c inventory.txt read
[user@localhost in_memory]$ ./load
databases opened successfully
databases closed.
Done loading databases.
[user@localhost in_memory]$ ls
build_command.txt example_database_read.c gettingstarted_common.h load vendors.txt
example_database_load.c example_database_read.o gettingstarted_common.o makefile
example_database_load.o gettingstarted_common.c inventory.txt read
[user@localhost in_memory]$ ./read -i "Zulu Nut"
databases opened successfully
No records found for 'Zulu Nut'
databases closed.
[user@localhost in_memory]$ ./read
databases opened successfully
databases closed.

Answer 1

Hello. This behavior looks correct to me, could you please specify what you were expecting to see?
load creates an in-memory database because you don't specify a file name, and that database is lost when load finishes. If you want a database to persist after a program exits, it needs to be written to disk.
Ben Schmeckpeper