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); }
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; /* 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); }
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(void) { ham_db_t *db; ham_env_t *env; ham_srv_t *srv; ham_srv_config_t cfg; ham_status_t st; char input[1024]; ham_env_new(&env); st=ham_env_create_ex(env, "env1.db", HAM_ENABLE_TRANSACTIONS, 0644, 0); if (st) { printf("ham_env_create_ex: %d\n", st); exit(-1); } ham_new(&db); st=ham_env_create_db(env, db, 12, HAM_ENABLE_DUPLICATES, 0); if (st) { printf("ham_env_create_db: %d\n", st); exit(-1); } ham_close(db, 0); st=ham_env_create_db(env, db, 13, HAM_ENABLE_DUPLICATES, 0); if (st) { printf("ham_env_create_db: %d\n", st); exit(-1); } ham_close(db, 0); st=ham_env_create_db(env, db, 33, HAM_RECORD_NUMBER|HAM_ENABLE_DUPLICATES, 0); if (st) { printf("ham_env_create_db: %d\n", st); exit(-1); } ham_close(db, 0); memset(&cfg, 0, sizeof(cfg)); cfg.port=8080; ham_srv_init(&cfg, &srv); ham_srv_add_env(srv, env, "/env1.db"); printf("server1%s started - please run sample 'client1%s' for a test\n", EXT, EXT); printf("type 'exit' to end the server\n"); while (1) { printf("> "); scanf("%s", &input[0]); if (!strcmp(input, "exit")) { printf("exiting...\n"); break; } printf("unknown command\n"); } ham_srv_close(srv); ham_env_close(env, HAM_AUTO_CLEANUP); ham_env_delete(env); ham_delete(db); return (0); }