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); }