static void
print_environment(ham_env_t *env)
{
/*
* we need a temp. database
*/
ham_db_t *db;
ham_status_t st;
st=ham_new(&db);
if (st)
error("ham_new", st);
st=ham_env_open_db(env, db, 0xf001, 0, 0);
if (st)
error("ham_env_open_db", st);
printf("environment\n");
printf(" pagesize: %u\n", env_get_pagesize(env));
printf(" version: %u.%u.%u.%u\n",
env_get_version(env, 0),
env_get_version(env, 1),
env_get_version(env, 2),
env_get_version(env, 3));
printf(" serialno: %u\n", env_get_serialno(env));
printf(" max databases: %u\n", env_get_max_databases(env));
st=ham_close(db, 0);
if (st)
error("ham_close", st);
ham_delete(db);
}
/** Opens an existing Database in the Environment. */
db open_db(uint16_t name, uint32_t flags = 0,
const ham_parameter_t *param = 0) {
ham_db_t *dbh;
ham_status_t st = ham_env_open_db(m_env, &dbh, name, flags, param);
if (st)
throw error(st);
return (hamsterdb::db(dbh));
}
int
main(int argc, char **argv) {
ham_status_t st;
ham_env_t *env = 0;
ham_db_t *src_db = 0;
ham_db_t *dest_db = 0;
ham_u16_t src_name;
ham_u16_t dest_name;
const char *env_path = 0;
/* check and parse the command line parameters */
if (argc != 4)
usage();
env_path = argv[1];
src_name = atoi(argv[2]);
dest_name = atoi(argv[3]);
if (src_name == 0 || dest_name == 0)
usage();
/* open the Environment */
st = ham_env_open(&env, env_path, 0, 0);
if (st)
error("ham_env_open", st);
/* open the source database */
st = ham_env_open_db(env, &src_db, src_name, 0, 0);
if (st)
error("ham_env_open_db", st);
/* create the destination database */
st = ham_env_create_db(env, &dest_db, dest_name,
HAM_ENABLE_DUPLICATE_KEYS, 0);
if (st)
error("ham_env_create_db", st);
/* copy the data */
copy_db(src_db, dest_db);
/* clean up and return */
st = ham_env_close(env, HAM_AUTO_CLEANUP);
if (st)
error("ham_env_close", st);
printf("\nsuccess!\n");
return (0);
}
int hammy_setup_env(ErlNifEnv *env, hammy_db *db) {
int retval = HAMMY_TRUE;
ham_size_t count = HAMMY_MAX_DB;
ham_u16_t *names = (ham_u16_t *) enif_alloc_compat(env, sizeof(ham_u16_t) * HAMMY_MAX_DB);
ham_new(&(db->databases[0]));
if ( ham_env_get_database_names(db->env, names, &count) == HAM_SUCCESS) {
/* New env, so let's setup data database */
if (count == 0) {
/* Database 1 is data */
ham_env_create_db(db->env, db->databases[0], 1, HAM_USE_BTREE, HAMMY_DB_OPTS);
db->db_count = 1;
}
else {
ham_env_open_db(db->env, db->databases[0], 1, 0, EMPTY_OPTS);
/* TODO: Load existing user-defined indices */
db->db_count = 1;
}
}
else {
retval = HAMMY_FALSE;
}
enif_free_compat(env, names);
return retval;
}
int
main(int argc, char **argv)
{
unsigned opt;
char *param, *filename=0, *endptr=0;
unsigned short dbname=0xffff;
int full=0;
ham_u16_t names[1024];
ham_size_t i, names_count=1024;
ham_status_t st;
ham_env_t *env;
ham_db_t *db;
ham_u32_t maj, min, rev;
const char *licensee, *product;
ham_get_license(&licensee, &product);
ham_get_version(&maj, &min, &rev);
getopts_init(argc, argv, "ham_info");
while ((opt=getopts(&opts[0], ¶m))) {
switch (opt) {
case ARG_DBNAME:
if (!param) {
printf("Parameter `dbname' is missing.\n");
return (-1);
}
dbname=(short)strtoul(param, &endptr, 0);
if (endptr && *endptr) {
printf("Invalid parameter `dbname'; numerical value "
"expected.\n");
return (-1);
}
break;
case ARG_FULL:
full=1;
break;
case GETOPTS_PARAMETER:
if (filename) {
printf("Multiple files specified. Please specify "
"only one filename.\n");
return (-1);
}
filename=param;
break;
case ARG_HELP:
printf("hamsterdb %d.%d.%d - Copyright (C) 2005-2007 "
"Christoph Rupp ([email protected]).\n\n",
maj, min, rev);
if (licensee[0]=='\0')
printf(
"This program is free software; you can redistribute "
"it and/or modify it\nunder the terms of the GNU "
"General Public License as published by the Free\n"
"Software Foundation; either version 2 of the License,\n"
"or (at your option) any later version.\n\n"
"See file COPYING.GPL2 and COPYING.GPL3 for License "
"information.\n\n");
else
printf("Commercial version; licensed for %s (%s)\n\n",
licensee, product);
printf("usage: ham_info [-db DBNAME] [-f] file\n");
printf("usage: ham_info -h\n");
printf(" -h: this help screen (alias: --help)\n");
printf(" -db DBNAME: only print info about "
"this database (alias: --dbname=<arg>)\n");
printf(" -f: print full information "
"(alias: --full)\n");
return (0);
default:
printf("Invalid or unknown parameter `%s'. "
"Enter `ham_info --help' for usage.", param);
return (-1);
}
}
if (!filename) {
printf("Filename is missing. Enter `ham_info --help' for usage.\n");
return (-1);
}
/*
* open the environment
*/
st=ham_env_new(&env);
if (st!=HAM_SUCCESS)
error("ham_env_new", st);
st=ham_env_open(env, filename, HAM_READ_ONLY);
if (st==HAM_FILE_NOT_FOUND) {
printf("File `%s' not found or unable to open it\n", filename);
return (-1);
}
else if (st!=HAM_SUCCESS)
error("ham_env_open", st);
/*
* print information about the environment
*/
print_environment(env);
/*
* get a list of all databases
*/
st=ham_env_get_database_names(env, names, &names_count);
if (st!=HAM_SUCCESS)
error("ham_env_get_database_names", st);
/*
* did the user specify a database name? if yes, show only this database
*/
if (dbname!=0xffff) {
st=ham_new(&db);
if (st)
error("ham_new", st);
st=ham_env_open_db(env, db, dbname, 0, 0);
if (st==HAM_DATABASE_NOT_FOUND) {
printf("Database %u (0x%x) not found\n", dbname, dbname);
return (-1);
}
else if (st)
error("ham_env_open_db", st);
print_database(db, dbname, full);
st=ham_close(db, 0);
if (st)
error("ham_close", st);
ham_delete(db);
}
else {
/*
* otherwise: for each database: print information about the database
*/
for (i=0; i<names_count; i++) {
st=ham_new(&db);
if (st)
error("ham_new", st);
st=ham_env_open_db(env, db, names[i], 0, 0);
if (st)
error("ham_env_open_db", st);
print_database(db, names[i], full);
st=ham_close(db, 0);
if (st)
error("ham_close", st);
ham_delete(db);
}
}
/*
* clean up
*/
st=ham_env_close(env, 0);
if (st!=HAM_SUCCESS)
error("ham_env_close", st);
ham_env_delete(env);
return (0);
}
int
main(int argc, char **argv) {
int i;
ham_status_t st; /* status variable */
ham_env_t *env; /* hamsterdb Environment object */
ham_db_t *db; /* hamsterdb Database object */
ham_key_t key = {0}; /* the structure for a key */
ham_record_t record = {0}; /* the structure for a record */
/*
* Connect to the server which should listen at 8080. The server is
* implemented in server1.c.
*/
st = ham_env_create(&env, "ham://localhost:8080/env1.db", 0, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_create", st);
/* now open a Database in this Environment */
st = ham_env_open_db(env, &db, 13, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_open_db", st);
/* now we can insert, delete or lookup values in the database */
for (i = 0; i < LOOP; i++) {
key.data = &i;
key.size = sizeof(i);
record.size = key.size;
record.data = key.data;
st = ham_db_insert(db, 0, &key, &record, 0);
if (st != HAM_SUCCESS)
error("ham_db_insert", st);
}
/* now lookup all values */
for (i = 0; i < LOOP; i++) {
key.data = &i;
key.size = sizeof(i);
st = ham_db_find(db, 0, &key, &record, 0);
if (st != HAM_SUCCESS)
error("ham_db_find", st);
/* check if the value is ok */
if (*(int *)record.data != i) {
printf("ham_db_find() ok, but returned bad value\n");
return (-1);
}
}
/* erase everything */
for (i = 0; i < LOOP; i++) {
key.data = &i;
key.size = sizeof(i);
st = ham_db_erase(db, 0, &key, 0);
if (st != HAM_SUCCESS)
error("ham_db_erase", st);
}
/* and make sure that the database is empty */
for (i = 0; i < LOOP; i++) {
key.data = &i;
key.size = sizeof(i);
st = ham_db_find(db, 0, &key, &record, 0);
if (st != HAM_KEY_NOT_FOUND)
error("ham_db_find", st);
}
/* close the database handle */
st = ham_db_close(db, 0);
if (st != HAM_SUCCESS)
error("ham_db_close", st);
/* close the environment handle */
st = ham_env_close(env, 0);
if (st != HAM_SUCCESS)
error("ham_env_close", st);
printf("success!\n");
return (0);
}
int
main(int argc, char **argv) {
int i;
ham_status_t st; /* status variable */
ham_db_t *db[MAX_DBS]; /* hamsterdb database objects */
ham_env_t *env; /* hamsterdb environment */
ham_cursor_t *cursor[MAX_DBS]; /* a cursor for each database */
ham_key_t key, cust_key, ord_key;
ham_record_t record, cust_record, ord_record;
customer_t customers[MAX_CUSTOMERS] = {
{ 1, "Alan Antonov Corp." },
{ 2, "Barry Broke Inc." },
{ 3, "Carl Caesar Lat." },
{ 4, "Doris Dove Brd." }
};
order_t orders[MAX_ORDERS] = {
{ 1, 1, "Joe" },
{ 2, 1, "Tom" },
{ 3, 3, "Joe" },
{ 4, 4, "Tom" },
{ 5, 3, "Ben" },
{ 6, 3, "Ben" },
{ 7, 4, "Chris" },
{ 8, 1, "Ben" }
};
memset(&key, 0, sizeof(key));
memset(&record, 0, sizeof(record));
memset(&cust_key, 0, sizeof(cust_key));
memset(&cust_record, 0, sizeof(cust_record));
memset(&ord_key, 0, sizeof(ord_key));
memset(&ord_record, 0, sizeof(ord_record));
/* Now create a new hamsterdb Environment */
st = ham_env_create(&env, "test.db", 0, 0664, 0);
if (st != HAM_SUCCESS)
error("ham_env_create", st);
/*
* Then create the two Databases in this Environment; each Database
* has a name - the first is our "customer" Database, the second
* is for the "orders"
*/
st = ham_env_create_db(env, &db[0], DBNAME_CUSTOMER, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_create_db (customer)", st);
st = ham_env_create_db(env, &db[1], DBNAME_ORDER, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_create_db (order)", st);
/* Create a Cursor for each Database */
for (i = 0; i < MAX_DBS; i++) {
st = ham_cursor_create(&cursor[i], db[i], 0, 0);
if (st != HAM_SUCCESS) {
printf("ham_cursor_create() failed with error %d\n", st);
return (-1);
}
}
/* Insert a few customers in the first database */
for (i = 0; i < MAX_CUSTOMERS; i++) {
key.size = sizeof(int);
key.data = &customers[i].id;
record.size = sizeof(customer_t);
record.data = &customers[i];
st = ham_db_insert(db[0], 0, &key, &record, 0);
if (st != HAM_SUCCESS)
error("ham_db_insert (customer)", st);
}
/* And now the orders in the second database */
for (i = 0; i < MAX_ORDERS; i++) {
key.size = sizeof(int);
key.data = &orders[i].id;
record.size = sizeof(order_t);
record.data = &orders[i];
st = ham_db_insert(db[1], 0, &key, &record, 0);
if (st != HAM_SUCCESS)
error("ham_db_insert (order)", st);
}
/*
* To demonstrate even more functions: close all objects, then
* re-open the environment and the two databases.
*
* Note that ham_env_close automatically calls ham_db_close on all
* databases.
*/
for (i = 0; i < MAX_DBS; i++) {
st = ham_cursor_close(cursor[i]);
if (st != HAM_SUCCESS)
error("ham_cursor_close", st);
}
st = ham_env_close(env, 0);
if (st != HAM_SUCCESS)
error("ham_env_close", st);
/* Now reopen the environment and the databases */
st = ham_env_open(&env, "test.db", 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_open", st);
st = ham_env_open_db(env, &db[0], DBNAME_CUSTOMER, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_open_db (customer)", st);
st = ham_env_open_db(env, &db[1], DBNAME_ORDER, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_open_db (order)", st);
/* Re-create a cursor for each database */
for (i = 0; i < MAX_DBS; i++) {
st = ham_cursor_create(&cursor[i], db[i], 0, 0);
if (st != HAM_SUCCESS) {
printf("ham_cursor_create() failed with error %d\n", st);
return (-1);
}
}
/*
* Now start the query - we want to dump each customer with his
* orders
*
* We have a loop with two cursors - the first cursor looping over
* the database with customers, the second loops over the orders.
*/
while (1) {
customer_t *customer;
st = ham_cursor_move(cursor[0], &cust_key, &cust_record,
HAM_CURSOR_NEXT);
if (st != HAM_SUCCESS) {
/* reached end of the database? */
if (st == HAM_KEY_NOT_FOUND)
break;
else
error("ham_cursor_next(customer)", st);
}
customer = (customer_t *)cust_record.data;
/* print the customer id and name */
printf("customer %d ('%s')\n", customer->id, customer->name);
/*
* The inner loop prints all orders of this customer. Move the
* cursor to the first entry.
*/
st = ham_cursor_move(cursor[1], &ord_key, &ord_record,
HAM_CURSOR_FIRST);
if (st != HAM_SUCCESS) {
/* reached end of the database? */
if (st == HAM_KEY_NOT_FOUND)
continue;
else
error("ham_cursor_next(order)", st);
}
do {
order_t *order = (order_t *)ord_record.data;
/* print this order, if it belongs to the current customer */
if (order->customer_id == customer->id)
printf(" order: %d (assigned to %s)\n",
order->id, order->assignee);
st = ham_cursor_move(cursor[1], &ord_key,
&ord_record, HAM_CURSOR_NEXT);
if (st != HAM_SUCCESS) {
/* reached end of the database? */
if (st == HAM_KEY_NOT_FOUND)
break;
else
error("ham_cursor_next(order)", st);
}
} while (1);
}
/*
* Now close the environment handle; the flag HAM_AUTO_CLEANUP will
* automatically close all databases and cursors
*/
st = ham_env_close(env, HAM_AUTO_CLEANUP);
if (st != HAM_SUCCESS)
error("ham_env_close", st);
printf("success!\n");
return (0);
}
int
main(int argc, char **argv) {
uint32_t i;
ham_status_t st; /* status variable */
ham_env_t *env; /* hamsterdb environment object */
ham_db_t *db; /* hamsterdb database object */
ham_key_t key = {0}; /* the structure for a key */
ham_record_t record = {0}; /* the structure for a record */
ham_parameter_t params[] = { /* parameters for ham_env_create_db */
{HAM_PARAM_KEY_TYPE, HAM_TYPE_UINT32},
{HAM_PARAM_RECORD_SIZE, sizeof(uint32_t)},
{0, }
};
/* First create a new hamsterdb Environment */
st = ham_env_create(&env, "test.db", 0, 0664, 0);
if (st != HAM_SUCCESS)
error("ham_create", st);
/* And in this Environment we create a new Database for uint32-keys
* and uint32-records. */
st = ham_env_create_db(env, &db, DATABASE_NAME, 0, ¶ms[0]);
if (st != HAM_SUCCESS)
error("ham_create", st);
/*
* now we can insert, delete or lookup values in the database
*
* for our test program, we just insert a few values, then look them
* up, then delete them and try to look them up again (which will fail).
*/
for (i = 0; i < LOOP; i++) {
key.data = &i;
key.size = sizeof(i);
record.size = key.size;
record.data = key.data;
st = ham_db_insert(db, 0, &key, &record, 0);
if (st != HAM_SUCCESS)
error("ham_db_insert", st);
}
/*
* now lookup all values
*
* for ham_db_find(), we could use the flag HAM_RECORD_USER_ALLOC, if WE
* allocate record.data (otherwise the memory is automatically allocated
* by hamsterdb)
*/
for (i = 0; i < LOOP; i++) {
key.data = &i;
key.size = sizeof(i);
st = ham_db_find(db, 0, &key, &record, 0);
if (st != HAM_SUCCESS)
error("ham_db_find", st);
/*
* check if the value is ok
*/
if (*(int *)record.data != i) {
printf("ham_db_find() ok, but returned bad value\n");
return (-1);
}
}
/*
* close the database handle, then re-open it (to demonstrate how to open
* an Environment and a Database)
*/
st = ham_db_close(db, 0);
if (st != HAM_SUCCESS)
error("ham_db_close", st);
st = ham_env_close(env, 0);
if (st != HAM_SUCCESS)
error("ham_env_close", st);
st = ham_env_open(&env, "test.db", 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_open", st);
st = ham_env_open_db(env, &db, DATABASE_NAME, 0, 0);
if (st != HAM_SUCCESS)
error("ham_env_open_db", st);
/* now erase all values */
for (i = 0; i < LOOP; i++) {
key.size = sizeof(i);
key.data = &i;
st = ham_db_erase(db, 0, &key, 0);
if (st != HAM_SUCCESS)
error("ham_db_erase", st);
}
/*
* once more we try to find all values... every ham_db_find() call must
* now fail with HAM_KEY_NOT_FOUND
*/
for (i = 0; i < LOOP; i++) {
key.size = sizeof(i);
key.data = &i;
st = ham_db_find(db, 0, &key, &record, 0);
if (st != HAM_KEY_NOT_FOUND)
error("ham_db_find", st);
}
/* we're done! close the handles. HAM_AUTO_CLEANUP will also close the
* 'db' handle */
st = ham_env_close(env, HAM_AUTO_CLEANUP);
if (st != HAM_SUCCESS)
error("ham_env_close", st);
printf("success!\n");
return (0);
}
