int hammy_put(ErlNifEnv *env, hammy_db *db, unsigned char *key, int key_size, unsigned char *value, int value_size) {
ham_key_t k;
ham_record_t rec;
ham_txn_t *txn;
int rc;
setup_key(&k, key, key_size);
setup_record(&rec, value, value_size);
ham_txn_begin(&txn, db->databases[0], 0);
rc = ham_insert(db->databases[0], txn, &k, &rec, HAM_OVERWRITE);
if (rc == HAM_SUCCESS) {
ham_txn_commit(txn, 0);
return HAMMY_TRUE;
}
else {
ham_txn_abort(txn, 0);
return HAMMY_FALSE;
}
}
int
main(int argc, char **argv)
{
ham_status_t st; /* status variable */
ham_db_t *db; /* hamsterdb database object */
ham_cursor_t *cursor; /* a database cursor */
char line[1024*4]; /* a buffer for reading lines */
ham_key_t key;
ham_record_t record;
memset(&key, 0, sizeof(key));
memset(&record, 0, sizeof(record));
printf("This sample uses hamsterdb to list all words in the "
"original order.\n");
printf("Reading from stdin...\n");
/*
* first step: create a new hamsterdb object
*/
st=ham_new(&db);
if (st!=HAM_SUCCESS) {
printf("ham_new() failed with error %d\n", st);
return (-1);
}
/*
* second step: create a new hamsterdb "record number" Database
*
* we could create an in-memory-database to speed up the sorting.
*/
st=ham_create(db, "test.db", HAM_RECORD_NUMBER, 0664);
if (st!=HAM_SUCCESS) {
printf("ham_create() failed with error %d\n", st);
return (-1);
}
/*
* now we read each line from stdin and split it in words; then each
* word is inserted into the database
*/
while (fgets(line, sizeof(line), stdin)) {
char *start=line, *p;
/*
* strtok is not the best function because it's not threadsafe
* and not flexible, but it's good enough for this example.
*/
while ((p=strtok(start, " \t\r\n"))) {
ham_u64_t recno;
key.flags=HAM_KEY_USER_ALLOC;
key.data=&recno;
key.size=sizeof(recno);
record.data=p;
record.size=(ham_size_t)strlen(p)+1; /* also store terminating 0 */
st=ham_insert(db, 0, &key, &record, 0);
if (st!=HAM_SUCCESS && st!=HAM_DUPLICATE_KEY) {
printf("ham_insert() failed with error %d\n", st);
return (-1);
}
printf(".");
start=0;
}
}
/*
* create a cursor
*/
st=ham_cursor_create(db, 0, 0, &cursor);
if (st!=HAM_SUCCESS) {
printf("ham_cursor_create() failed with error %d\n", st);
return (-1);
}
/*
* iterate over all items and print the records
*/
while (1) {
st=ham_cursor_move(cursor, &key, &record, HAM_CURSOR_NEXT);
if (st!=HAM_SUCCESS) {
/* reached end of the database? */
if (st==HAM_KEY_NOT_FOUND)
break;
else {
printf("ham_cursor_next() failed with error %d\n", st);
return (-1);
}
}
/*
* print the record number and the word
*/
#if WIN32
printf("%I64u: %s\n", *(ham_u64_t *)key.data,
(const char *)record.data);
#else
printf("%llu: %s\n", *(unsigned long long *)key.data,
(const char *)record.data);
#endif
}
/*
* then close the database handle; the flag
* HAM_AUTO_CLEANUP will automatically close all cursors, and we
* do not need to call ham_cursor_close
*/
st=ham_close(db, HAM_AUTO_CLEANUP);
if (st!=HAM_SUCCESS) {
printf("ham_close() failed with error %d\n", st);
return (-1);
}
/*
* delete the database object to avoid memory leaks
*/
ham_delete(db);
/*
* success!
*/
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, c2o_key;
ham_record_t record, cust_record, ord_record, c2o_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));
memset(&c2o_key, 0, sizeof(c2o_key));
memset(&c2o_record, 0, sizeof(c2o_record));
/*
* first, create a new hamsterdb environment
*/
st=ham_env_new(&env);
if (st!=HAM_SUCCESS)
error("ham_env_new", st);
/*
* then create the database objects
*/
for (i=0; i<MAX_DBS; i++) {
st=ham_new(&db[i]);
if (st!=HAM_SUCCESS)
error("ham_new", st);
}
/*
* Now create a new database file for the Environment
*/
st=ham_env_create_ex(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"; the third manages our 1:n relation and
* therefore needs to enable duplicate keys
*/
st=ham_env_create_db(env, db[DBIDX_CUSTOMER], DBNAME_CUSTOMER, 0, 0);
if (st!=HAM_SUCCESS)
error("ham_env_create_db(customer)", st);
st=ham_env_create_db(env, db[DBIDX_ORDER], DBNAME_ORDER, 0, 0);
if (st!=HAM_SUCCESS)
error("ham_env_create_db(order)", st);
st=ham_env_create_db(env, db[DBIDX_C2O], DBNAME_C2O,
HAM_ENABLE_DUPLICATES, 0);
if (st!=HAM_SUCCESS)
error("ham_env_create_db(c2o)", st);
/*
* create a Cursor for each Database
*/
for (i=0; i<MAX_DBS; i++) {
st=ham_cursor_create(db[i], 0, 0, &cursor[i]);
if (st!=HAM_SUCCESS)
error("ham_cursor_create" , st);
}
/*
* Insert the customers in the customer table
*
* INSERT INTO customers VALUES (1, "Alan Antonov Corp.");
* INSERT INTO customers VALUES (2, "Barry Broke Inc.");
* etc
*/
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_insert(db[0], 0, &key, &record, 0);
if (st!=HAM_SUCCESS)
error("ham_insert (customer)", st);
}
/*
* And now the orders in the second Database; contrary to env1,
* we only store the assignee, not the whole structure
*
* INSERT INTO orders VALUES (1, "Joe");
* INSERT INTO orders VALUES (2, "Tom");
*/
for (i=0; i<MAX_ORDERS; i++) {
key.size=sizeof(int);
key.data=&orders[i].id;
record.size=sizeof(orders[i].assignee);
record.data=orders[i].assignee;
st=ham_insert(db[1], 0, &key, &record, 0);
if (st!=HAM_SUCCESS)
error("ham_insert (order)", st);
}
/*
* and now the 1:n relationships; the flag HAM_DUPLICATE creates
* a duplicate key, if the key already exists
*
* INSERT INTO c2o VALUES (1, 1);
* INSERT INTO c2o VALUES (2, 1);
* etc
*/
for (i=0; i<MAX_ORDERS; i++) {
key.size=sizeof(int);
key.data=&orders[i].customer_id;
record.size=sizeof(int);
record.data=&orders[i].id;
st=ham_insert(db[2], 0, &key, &record, HAM_DUPLICATE);
if (st!=HAM_SUCCESS)
error("ham_insert(c2o)", st);
}
/*
* now start the query - we want to dump each customer with his
* orders
*
* loop over the customer; for each customer, loop over the 1:n table
* and pick those orders with the customer id. then load the order
* and print it
*
* the outer loop is similar to
* SELECT * FROM customers WHERE 1;
*/
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);
/*
* loop over the 1:n table
*
* before we start the loop, we move the cursor to the
* first duplicate key
*
* SELECT * FROM customers, orders, c2o
* WHERE c2o.customer_id=customers.id AND
* c2o.order_id=orders.id;
*/
c2o_key.data=&customer->id;
c2o_key.size=sizeof(int);
st=ham_cursor_find(cursor[2], &c2o_key, 0);
if (st!=HAM_SUCCESS) {
if (st==HAM_KEY_NOT_FOUND)
continue;
error("ham_cursor_find(c2o)", st);
}
st=ham_cursor_move(cursor[2], 0, &c2o_record, 0);
if (st!=HAM_SUCCESS)
error("ham_cursor_move(c2o)", st);
do {
int order_id;
order_id=*(int *)c2o_record.data;
ord_key.data=&order_id;
ord_key.size=sizeof(int);
/*
* load the order
* SELECT * FROM orders WHERE id = order_id;
*/
st=ham_find(db[1], 0, &ord_key, &ord_record, 0);
if (st!=HAM_SUCCESS)
error("ham_find(order)", st);
printf(" order: %d (assigned to %s)\n",
order_id, (char *)ord_record.data);
/*
* the flag HAM_ONLY_DUPLICATES restricts the cursor
* movement to the duplicate list.
*/
st=ham_cursor_move(cursor[2], &c2o_key,
&c2o_record, HAM_CURSOR_NEXT|HAM_ONLY_DUPLICATES);
if (st!=HAM_SUCCESS) {
/* reached end of the database? */
if (st==HAM_KEY_NOT_FOUND)
break;
else
error("ham_cursor_next(c2o)", 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);
for (i=0; i<MAX_DBS; i++)
ham_delete(db[i]);
ham_env_delete(env);
#if UNDER_CE
error("success", 0);
#endif
printf("success!\n");
return (0);
}
int
main(int argc, char **argv)
{
int i;
ham_status_t st; /* status variable */
ham_db_t *db; /* hamsterdb database object */
ham_key_t key; /* the structure for a key */
ham_record_t record; /* the structure for a record */
memset(&key, 0, sizeof(key));
memset(&record, 0, sizeof(record));
/*
* first step: create a new hamsterdb object
*/
st=ham_new(&db);
if (st!=HAM_SUCCESS)
error("ham_new", st);
/*
* second step: create a new hamsterdb database
*
* we could also use ham_create_ex() if we wanted to specify the
* page size, key size or cache size limits
*/
st=ham_create_ex(db, "test.db", 0, 0664, 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.data=&i;
record.size=sizeof(i);
st=ham_insert(db, 0, &key, &record, 0);
if (st!=HAM_SUCCESS)
error("ham_insert", st);
}
/*
* now lookup all values
*
* for ham_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_find(db, 0, &key, &record, 0);
if (st!=HAM_SUCCESS)
error("ham_find", st);
/*
* check if the value is ok
*/
if (*(int *)record.data!=i) {
printf("ham_find() ok, but returned bad value\n");
return (-1);
}
}
/*
* close the database handle, then re-open it (to demonstrate the
* call ham_open)
*/
st=ham_close(db, 0);
if (st!=HAM_SUCCESS)
error("ham_close", st);
st=ham_open_ex(db, "test.db", 0, 0);
if (st!=HAM_SUCCESS)
error("ham_open", st);
/*
* now erase all values
*/
for (i=0; i<LOOP; i++) {
key.size=sizeof(i);
key.data=&i;
st=ham_erase(db, 0, &key, 0);
if (st!=HAM_SUCCESS)
error("ham_erase", st);
}
/*
* once more we try to find all values... every ham_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_find(db, 0, &key, &record, 0);
if (st!=HAM_KEY_NOT_FOUND)
error("ham_find", st);
}
/*
* we're done! close the database handle
*/
st=ham_close(db, 0);
if (st!=HAM_SUCCESS)
error("ham_close", st);
/*
* delete the database object to avoid memory leaks
*/
ham_delete(db);
#if UNDER_CE
error("success", 0);
#endif
printf("success!\n");
return (0);
}