int main(int argc, char **argv) {
void* shmptr;
/* Create a database with custom key and 2M size */
shmptr=wg_attach_database("9273", 2000000);
/* Using default key and size:
shmptr=wg_attach_database(NULL, 0);
*/
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
/* We have successfully attached, run the demo code */
run_demo(shmptr);
/* Clean up. The shared memory area is released. This is
* useful for the purposes of this demo, but might best be
* avoided for more persistent databases. */
wg_delete_database("9273");
/* Database with default key:
wg_delete_database(NULL);
*/
exit(0);
}
int main(int argc, char **argv) {
void *db, *rec;
char *name="10";
int i;
int count=0;
wg_query *query;
wg_query_arg arglist[5];
db = wg_attach_database(name, 1000000000);
if (!db) { printf("db attaching failed \n"); exit(0); }
// outer loop is just for sensible timing: do the same thing 1000 times
for(i=0;i<1000000;i++) {
arglist[0].column = 3;
arglist[0].cond = WG_COND_EQUAL;
arglist[0].value = wg_encode_query_param_int(db,123);
query = wg_make_query(db, NULL, 0, arglist, 1);
if(!query) { printf("query creation failed \n"); exit(0); }
while((rec = wg_fetch(db, query))) {
count++;
//wg_print_record(db, rec); printf("\n");
}
wg_free_query(db,query);
}
printf("count altogether for i %d runs: %d\n", i, count);
return 0;
}
int main(int argc, char **argv) {
void *db, *ctrl, *rec;
char *name=DB_NAME;
int i,ptrfld,ptrs,rc;
wg_int encptr,tmp,first,next,last;
pthread_t threads[MAX_THREADS];
struct thread_data tdata[MAX_THREADS];
pthread_attr_t attr;
long tid;
db = wg_attach_database(name, 1000000000);
if (!db) { printf("db creation failed \n"); exit(0); }
// get values from cntrl record
ctrl=wg_get_first_record(db);
ptrfld=wg_decode_int(db,wg_get_field(db,ctrl,1));
first=wg_get_field(db,ctrl,2);
for(ptrs=0;ptrs<10000;ptrs++) {
tmp=wg_get_field(db,ctrl,3+ptrs);
if ((int)tmp==0) break;
last=tmp;
}
printf("\nsegments found: %d \n",ptrs);
if (ptrs>=MAX_THREADS) {
printf("List segment nr larger than MAX_THREADS, exiting\n");
wg_detach_database(db);
pthread_exit(NULL);
return 0;
}
// prepare and create threads
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for(tid=0;tid<ptrs;tid++) {
first=wg_get_field(db,ctrl,2+tid);
next=wg_get_field(db,ctrl,2+tid+1);
tdata[tid].thread_id=tid;
tdata[tid].db=db;
tdata[tid].fptr=first;
tdata[tid].lptr=next;
tdata[tid].ptrfld=ptrfld;
tdata[tid].res=0;
rc=pthread_create(&threads[tid], &attr, process, (void *) &tdata[tid]);
}
// wait for all threads to finish
for(tid=0;tid<ptrs;tid++) {
pthread_join(threads[tid],NULL);
//printf("thread %d finished with res %d\n",
// tdata[tid].thread_id,tdata[tid].res);
}
printf("\nall threads finished\n");
wg_detach_database(db);
pthread_exit(NULL);
return 0;
}
int main(int argc, char **argv) {
char* shmname = NULL;
void* shmptr;
int rcnt = -1, wcnt = -1;
#ifndef _WIN32
struct timeval tv;
#endif
unsigned long long start_ms, end_ms;
if(argc==4) {
shmname = argv[1];
rcnt = atol(argv[2]);
wcnt = atol(argv[3]);
}
if(rcnt<0 || wcnt<0) {
fprintf(stderr, "usage: %s <shmname> <readers> <writers>\n", argv[0]);
exit(1);
}
shmptr=wg_attach_database(shmname,DBSIZE);
if (shmptr==NULL)
exit(2);
if(prepare_data(shmptr)) {
wg_delete_database(shmname);
exit(3);
}
#ifdef _WIN32
start_ms = (unsigned long long) GetTickCount();
#else
gettimeofday(&tv, NULL);
start_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
run_workers(shmptr, rcnt, wcnt);
#ifdef _WIN32
end_ms = (unsigned long long) GetTickCount();
#else
gettimeofday(&tv, NULL);
end_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
check_data(shmptr, wcnt);
fprintf(stdout, "elapsed: %d ms\n", (int) (end_ms - start_ms));
wg_delete_database(shmname);
exit(0);
}
int main(int argc, char **argv) {
void *db;
char *name="1";
int i;
for(i=0;i<1000;i++) { // 100000
db = wg_attach_database(name,1000000000); // 10000000
if (!db) { printf("failed at try %d\n", i); exit(0); }
wg_detach_database(db);
wg_delete_database(name);
}
printf("i %d\n", i);
return 0;
}
static void* op_create_database(thread_data_p tdata,char* database,long size) {
void* db;
char* sizestr;
long max_size=0;
int i;
int found=0;
//printf("op_create_database called\n");
if (database==NULL) {
#ifdef DEFAULT_DATABASE
database=DEFAULT_DATABASE;
#endif
if ((tdata->global)->conf->default_dbase.used>0)
database=(tdata->global)->conf->default_dbase.vals[0];
}
if (size<=0) {
#ifdef DEFAULT_DATABASE_SIZE
size=DEFAULT_DATABASE_SIZE;
#endif
if ((tdata->global)->conf->default_dbase_size.used>0) {
sizestr=(tdata->global)->conf->default_dbase_size.vals[0];
size=atol(sizestr);
}
}
#ifdef MAX_DATABASE_SIZE
max_size=MAX_DATABASE_SIZE;
#else
max_size=LONG_MAX;
#endif
if ((tdata->global)->conf->max_dbase_size.used>0) {
sizestr=(tdata->global)->conf->max_dbase_size.vals[0];
max_size=atol(sizestr);
}
if (database==NULL) return NULL;
// check if access allowed in the conf file
if ((tdata->global)->conf->dbases.used>0) {
for(i=0;i<(tdata->global)->conf->dbases.used;i++) {
if (!strcmp(database,(tdata->global)->conf->dbases.vals[i])) {
found=1;
break;
}
}
if (!found) return NULL;
}
if (size<=0) return NULL;
if (size>max_size) return NULL;
db = wg_attach_database(database,size);
return db;
}
int main(int argc, char **argv) {
void *db, *rec;
char *name="2";
int i;
db = wg_attach_database(name, 1000000000);
if (!db) { printf("db creation failed \n"); exit(0); }
for(i=0;i<10000000;i++) {
rec = wg_create_record(db, 9);
if (!rec) { printf("record creation failed \n"); exit(0); }
}
printf("i %d\n", i);
wg_detach_database(db);
wg_delete_database(name);
return 0;
}
int main(int argc, char **argv) {
void *db, *rec, *rec2;
wg_int enc, enc2;
db = wg_attach_database("1000", 2000000);
rec = wg_create_record(db, 10);
rec2 = wg_create_record(db, 2);
enc = wg_encode_int(db, 443);
enc2 = wg_encode_str(db, "this is my string", NULL);
wg_set_field(db, rec, 7, enc);
wg_set_field(db, rec2, 0, enc2);
return 0;
}
void * GetDatabase(struct wdbTableOptions *table_options) {
bool found;
wdbConnCacheEntry* entry;
wdbConnCacheKey key;
/* First time through, initialize connection cache hashtable */
if (ConnectionHash == NULL)
{
HASHCTL ctl;
MemSet(&ctl, 0, sizeof(ctl));
ctl.keysize = sizeof(wdbConnCacheKey);
ctl.entrysize = sizeof(wdbConnCacheEntry);
ctl.hash = tag_hash;
/* allocate ConnectionHash in the cache context */
ctl.hcxt = CacheMemoryContext;
ConnectionHash = hash_create("wdb_fdw connections", 8,
&ctl,
HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
}
/* Create hash key for the entry. Assume no pad bytes in key struct */
key.serverId = table_options->serverId;
key.userId = table_options->userId;
/*
* Find or create cached entry for requested connection.
*/
entry = hash_search(ConnectionHash, &key, HASH_ENTER, &found);
if (!found) {
/* initialize new hashtable entry (key is already filled in) */
entry->db = NULL;
entry->xact_depth = 0;
}
if (entry->db == NULL) {
entry->db = wg_attach_database(table_options->address, table_options->size);
if(!entry->db) {
elog(ERROR,"Could not attach to database");
}
}
return entry->db;
}
int main(int argc, char **argv) {
void *db, *rec;
char *name="51";
int i,j,count=0;
db = wg_attach_database(name, 1000000000);
if (!db) { printf("db creation failed \n"); exit(0); }
for(i=0;i<10000000;i++) {
rec = wg_create_raw_record(db, 5);
if (!rec) { printf("record creation failed \n"); exit(0); }
for (j=0;j<5;j++) {
wg_set_new_field(db,rec,j,wg_encode_int(db,i+j));
//count+=wg_decode_int(db,wg_get_field(db, rec, j));
}
}
printf("i %d count %d\n", i,count);
wg_detach_database(db);
wg_delete_database(name);
return 0;
}
int main(int argc, char **argv){
const char* test_str = "TEST STRING HEAP";
// create new db pointer used for allocate db
void* db;
// in order to use db, we have to attach the db with shared memroy allocated by OS.
db = wg_attach_database("1000", 2000000);
char* tp = NULL;
int i = 0;
// test: allocate 200000 times and try to copy something into allocaed space
// inorder to test basic feature and memroy leak
for( i = 0; i < 2000000; ++i) {
// allocate
// this statement shows basic way to use dbmalloc: it is almost the same as system one
// except for the first paramater: db pointer
// (we have to let malloc know which heap it is using now.)
// second paramater is size of space, in byte.
tp = (char*)dbmalloc(db,1024*sizeof(char));
strcpy(tp,test_str);
//free
//the free function is the same as system, execept for first paramater pointing to db that is being used
dbfree(db,tp);
}
//delete data base that we used in this program
wg_delete_database("1000");
return 0;
}
int main(int argc, char **argv) {
char *shmname = NULL;
void *shmptr = NULL;
int i, scan_to;
gint shmsize;
wg_int rlock = 0;
wg_int wlock = 0;
/* look for commands in argv[1] or argv[2] */
if(argc < 3) scan_to = argc;
else scan_to = 3;
shmsize = 0; /* 0 size causes default size to be used */
/* 1st loop through, shmname is NULL for default. If
* the first argument is not a recognizable command, it
* is assumed to be the shmname and the next argument
* is checked against known commands.
*/
for(i=1; i<scan_to; i++) {
if (!strcmp(argv[i],"help") || !strcmp(argv[i],"-h")) {
usage(argv[0]);
exit(0);
}
if (!strcmp(argv[i],"version") || !strcmp(argv[i],"-v")) {
wg_print_code_version();
exit(0);
}
if (!strcmp(argv[i],"free")) {
/* free shared memory */
wg_delete_database(shmname);
exit(0);
}
if(argc>(i+1) && !strcmp(argv[i],"import")){
wg_int err, minsize, maxsize;
int flags = 0;
if(argv[i+1][0] == '-') {
flags = parse_flag(argv[++i]);
if(argc<=(i+1)) {
/* Filename argument missing */
usage(argv[0]);
exit(1);
}
}
err = wg_check_dump(NULL, argv[i+1], &minsize, &maxsize);
if(err) {
fprintf(stderr, "Import failed.\n");
break;
}
shmptr=wg_attach_memsegment(shmname, minsize, maxsize, 1,
(flags & FLAGS_LOGGING));
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
/* Locking is handled internally by the dbdump.c functions */
err = wg_import_dump(shmptr,argv[i+1]);
if(!err)
printf("Database imported.\n");
else if(err<-1)
fprintf(stderr, "Fatal error in wg_import_dump, db may have"\
" become corrupt\n");
else
fprintf(stderr, "Import failed.\n");
break;
}
else if(argc>(i+1) && !strcmp(argv[i],"export")){
wg_int err;
int flags = 0;
if(argv[i+1][0] == '-') {
flags = parse_flag(argv[++i]);
if(argc<=(i+1)) {
/* Filename argument missing */
usage(argv[0]);
exit(1);
}
}
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
/* Locking is handled internally by the dbdump.c functions */
if(flags & FLAGS_FORCE)
err = wg_dump_internal(shmptr,argv[i+1], 0);
else
err = wg_dump(shmptr,argv[i+1]);
if(err<-1)
fprintf(stderr, "Fatal error in wg_dump, db may have"\
" become corrupt\n");
else if(err)
fprintf(stderr, "Export failed.\n");
break;
}
#ifdef USE_DBLOG
else if(argc>(i+1) && !strcmp(argv[i],"replay")){
wg_int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
WLOCK(shmptr, wlock);
err = wg_replay_log(shmptr,argv[i+1]);
WULOCK(shmptr, wlock);
if(!err)
printf("Log suggessfully imported from file.\n");
else if(err<-1)
fprintf(stderr, "Fatal error when importing, database may have "\
"become corrupt\n");
else
fprintf(stderr, "Failed to import log (database unmodified).\n");
break;
}
#endif
else if(argc>(i+1) && !strcmp(argv[i],"exportcsv")){
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
RLOCK(shmptr, wlock);
wg_export_db_csv(shmptr,argv[i+1]);
RULOCK(shmptr, wlock);
break;
}
else if(argc>(i+1) && !strcmp(argv[i],"importcsv")){
wg_int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
WLOCK(shmptr, wlock);
err = wg_import_db_csv(shmptr,argv[i+1]);
WULOCK(shmptr, wlock);
if(!err)
printf("Data imported from file.\n");
else if(err<-1)
fprintf(stderr, "Fatal error when importing, data may be partially"\
" imported\n");
else
fprintf(stderr, "Import failed.\n");
break;
}
#ifdef USE_REASONER
else if(argc>(i+1) && !strcmp(argv[i],"importprolog")){
wg_int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
err = wg_import_prolog_file(shmptr,argv[i+1]);
if(!err)
printf("Data imported from prolog file.\n");
else if(err<-1)
fprintf(stderr, "Fatal error when importing, data may be partially"\
" imported\n");
else
fprintf(stderr, "Import failed.\n");
break;
}
else if(argc>(i+1) && !strcmp(argv[i],"importotter")){
wg_int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
err = wg_import_otter_file(shmptr,argv[i+1]);
if(!err)
printf("Data imported from otter file.\n");
else if(err<-1)
fprintf(stderr, "Fatal error when importing otter file, data may be partially"\
" imported\n");
else
fprintf(stderr, "Import failed.\n");
break;
}
else if(argc>i && !strcmp(argv[i],"runreasoner")){
wg_int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
//printf("about to call wg_run_reasoner\n");
err = wg_run_reasoner(shmptr,argc,argv);
//if(!err);
//printf("wg_run_reasoner finished ok.\n");
//else
//fprintf(stderr, "wg_run_reasoner finished with an error %d.\n",err);
//break;
break;
}
else if(argc>i && !strcmp(argv[i],"testreasoner")){
wg_int err;
//printf("about to call wg_test_reasoner\n");
err = wg_test_reasoner(argc,argv);
//if(!err);
//printf("wg_test_reasoner finished ok.\n");
//else
//fprintf(stderr, "wg_test_reasoner finished with an error %d.\n",err);
//break;
break;
}
#endif
#ifdef HAVE_RAPTOR
else if(argc>(i+2) && !strcmp(argv[i],"exportrdf")){
wg_int err;
int pref_fields = atol(argv[i+1]);
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
printf("Exporting with %d prefix fields.\n", pref_fields);
RLOCK(shmptr, wlock);
err = wg_export_raptor_rdfxml_file(shmptr, pref_fields, argv[i+2]);
RULOCK(shmptr, wlock);
if(err)
fprintf(stderr, "Export failed.\n");
break;
}
else if(argc>(i+3) && !strcmp(argv[i],"importrdf")){
wg_int err;
int pref_fields = atol(argv[i+1]);
int suff_fields = atol(argv[i+2]);
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
printf("Importing with %d prefix fields, %d suffix fields.\n,",
pref_fields, suff_fields);
WLOCK(shmptr, wlock);
err = wg_import_raptor_file(shmptr, pref_fields, suff_fields,
wg_rdfparse_default_callback, argv[i+3]);
WULOCK(shmptr, wlock);
if(!err)
printf("Data imported from file.\n");
else if(err<-1)
fprintf(stderr, "Fatal error when importing, data may be partially"\
" imported\n");
else
fprintf(stderr, "Import failed.\n");
break;
}
#endif
else if(!strcmp(argv[i],"test")) {
/* This test function does it's own memory allocation. */
wg_run_tests(WG_TEST_QUICK, 2);
break;
}
else if(!strcmp(argv[i],"fulltest")) {
wg_run_tests(WG_TEST_FULL, 2);
break;
}
else if(!strcmp(argv[i], "header")) {
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
RLOCK(shmptr, wlock);
wg_show_db_memsegment_header(shmptr);
RULOCK(shmptr, wlock);
break;
}
#ifdef _WIN32
else if(!strcmp(argv[i],"server")) {
int flags = 0;
if(argc>(i+1) && argv[i+1][0] == '-') {
flags = parse_flag(argv[++i]);
}
if(argc>(i+1)) {
shmsize = parse_shmsize(argv[i+1]);
if(!shmsize)
fprintf(stderr, "Failed to parse memory size, using default.\n");
}
shmptr=wg_attach_memsegment(shmname, shmsize, shmsize, 1,
(flags & FLAGS_LOGGING));
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
printf("Press Ctrl-C to end and release the memory.\n");
while(_getch() != 3);
break;
}
#else
else if(!strcmp(argv[i],"create")) {
int flags = 0;
if(argc>(i+1) && argv[i+1][0] == '-') {
flags = parse_flag(argv[++i]);
}
if(argc>(i+1)) {
shmsize = parse_shmsize(argv[i+1]);
if(!shmsize)
fprintf(stderr, "Failed to parse memory size, using default.\n");
}
shmptr=wg_attach_memsegment(shmname, shmsize, shmsize, 1,
(flags & FLAGS_LOGGING));
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
break;
}
#endif
else if(argc>(i+1) && !strcmp(argv[i], "fill")) {
int rows = atol(argv[i+1]);
if(!rows) {
fprintf(stderr, "Invalid number of rows.\n");
exit(1);
}
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
WLOCK(shmptr, wlock);
if(argc > (i+2) && !strcmp(argv[i+2], "mix"))
wg_genintdata_mix(shmptr, rows, TESTREC_SIZE);
else if(argc > (i+2) && !strcmp(argv[i+2], "desc"))
wg_genintdata_desc(shmptr, rows, TESTREC_SIZE);
else
wg_genintdata_asc(shmptr, rows, TESTREC_SIZE);
WULOCK(shmptr, wlock);
printf("Data inserted\n");
break;
}
else if(argc>(i+1) && !strcmp(argv[i],"select")) {
int rows = atol(argv[i+1]);
int from = 0;
if(!rows) {
fprintf(stderr, "Invalid number of rows.\n");
exit(1);
}
if(argc > (i+2))
from = atol(argv[i+2]);
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
RLOCK(shmptr, wlock);
selectdata(shmptr, rows, from);
RULOCK(shmptr, wlock);
break;
}
else if(argc>(i+1) && !strcmp(argv[i],"add")) {
int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
WLOCK(shmptr, wlock);
err = add_row(shmptr, argv+i+1, argc-i-1);
WULOCK(shmptr, wlock);
if(!err)
printf("Row added.\n");
break;
}
else if(argc>(i+2) && !strcmp(argv[i],"del")) {
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
/* Delete works like query(), except deletes the matching rows */
del(shmptr, argv+i+1, argc-i-1);
break;
break;
}
else if(argc>(i+3) && !strcmp(argv[i],"query")) {
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
/* Query handles it's own locking */
query(shmptr, argv+i+1, argc-i-1);
break;
}
else if(argc>i && !strcmp(argv[i],"addjson")){
wg_int err;
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
WLOCK(shmptr, wlock);
/* the filename parameter is optional */
err = wg_parse_json_file(shmptr, (argc>(i+1) ? argv[i+1] : NULL));
WULOCK(shmptr, wlock);
if(!err)
printf("JSON document imported.\n");
else if(err<-1)
fprintf(stderr, "Fatal error when importing, data may be partially"\
" imported\n");
else
fprintf(stderr, "Import failed.\n");
break;
}
else if(argc>(i+1) && !strcmp(argv[i],"findjson")) {
shmptr=wg_attach_database(shmname, shmsize);
if(!shmptr) {
fprintf(stderr, "Failed to attach to database.\n");
exit(1);
}
WLOCK(shmptr, wlock);
findjson(shmptr, argv[i+1]);
WULOCK(shmptr, wlock);
break;
}
shmname = argv[1]; /* no match, assume shmname was given */
}
if(i==scan_to) {
/* loop completed normally ==> no commands found */
usage(argv[0]);
}
if(shmptr) {
RULOCK(shmptr, rlock);
WULOCK(shmptr, wlock);
wg_detach_database(shmptr);
}
exit(0);
}
