void run_demo(void* db) {
void *rec = NULL, *firstrec = NULL, *nextrec = NULL;
/* Pointers to a database record */
wg_int enc; /* Encoded data */
wg_int lock_id; /* Id of an acquired lock (for releasing it later) */
wg_int len;
int i;
int intdata, datedata, timedata;
char strbuf[80];
printf("********* Starting demo ************\n");
/* Begin by creating a simple record of 3 fields and fill it
* with integer data.
*/
printf("Creating first record.\n");
rec=wg_create_record(db, 3);
if (rec==NULL) {
printf("rec creation error.\n");
return;
}
/* Encode a field, checking for errors */
enc = wg_encode_int(db, 44);
if(enc==WG_ILLEGAL) {
printf("failed to encode an integer.\n");
return;
}
/* Negative return value shows that an error occurred */
if(wg_set_field(db, rec, 0, enc) < 0) {
printf("failed to store a field.\n");
return;
}
/* Skip error checking for the sake of brevity for the rest of fields */
enc = wg_encode_int(db, -199999);
wg_set_field(db, rec, 1, enc);
wg_set_field(db, rec, 2, wg_encode_int(db, 0));
/* Now examine the record we have created. Get record length,
* encoded value of each field, data type and decoded value.
*/
/* Negative return value shows an error. */
len = wg_get_record_len(db, rec);
if(len < 0) {
printf("failed to get record length.\n");
return;
}
printf("Size of created record at %p was: %d\n", rec, (int) len);
for(i=0; i<len; i++) {
printf("Reading field %d:", i);
enc = wg_get_field(db, rec, i);
if(wg_get_encoded_type(db, enc) != WG_INTTYPE) {
printf("data was of unexpected type.\n");
return;
}
intdata = wg_decode_int(db, enc);
/* No error checking here. All integers are valid. */
printf(" %d\n", intdata);
}
/* Fields can be erased by setting their value to 0 which always stands for NULL value. */
printf("Clearing field 1.\n");
wg_set_field(db, rec, 1, 0);
if(wg_get_field(db, rec, 1)==0) {
printf("Re-reading field 1 returned a 0 (NULL) field.\n");
} else {
printf("unexpected value \n");
return;
}
/* Fields can be updated with data of any type (the type is not fixed). */
printf("Updating field 0 to a floating-point number.\n");
enc = wg_encode_double(db, 56.9988);
wg_set_field(db, rec, 0, enc);
enc = wg_get_field(db, rec, 0);
if(wg_get_encoded_type(db, enc) == WG_DOUBLETYPE) {
printf("Re-reading field 0 returned %f.\n", wg_decode_double(db, enc));
} else {
printf("data was of unexpected type.\n");
return;
}
/* Create a next record. Let's assume we're in an environment where
* the database is used concurrently, so there's a need to use locking.
*/
printf("Creating second record.\n");
/* Lock id of 0 means that the operation failed */
lock_id = wg_start_write(db);
if(!lock_id) {
printf("failed to acquire lock.\n");
return;
}
/* Do the write operation we acquired the lock for. */
rec=wg_create_record(db, 6);
/* Failing to release the lock would be fatal to database operation. */
if(!wg_end_write(db, lock_id)) {
printf("failed to release lock.\n");
return;
}
if (!rec) {
printf("rec creation error.\n");
return;
}
/* Reading also requires locking./ */
lock_id = wg_start_read(db);
if(!lock_id) {
printf("failed to acquire lock.\n");
return;
}
/* Do our read operation... */
len = wg_get_record_len(db, rec);
/* ... and unlock immediately */
if(!wg_end_read(db, lock_id)) {
printf("failed to release lock.\n");
return;
}
if(len < 0) {
printf("failed to get record length.\n");
return;
}
printf("Size of created record at %p was: %d\n", rec, (int) len);
/* Let's find the first record in the database */
lock_id = wg_start_read(db);
firstrec = wg_get_first_record(db);
wg_end_read(db, lock_id);
if(!firstrec) {
printf("Failed to find first record.\n");
return;
}
printf("First record of database had address %p.\n", firstrec);
/* Let's check what the next record is to demonstrate scanning records. */
nextrec = firstrec;
lock_id = wg_start_read(db);
do {
nextrec = wg_get_next_record(db, nextrec);
if(nextrec)
printf("Next record had address %p.\n", nextrec);
} while(nextrec);
printf("Finished scanning database records.\n");
wg_end_read(db, lock_id);
/* Set fields to various values. Field 0 is not touched at all (un-
* initialized). Field 1 is set to point to another record.
*/
printf("Populating second record with data.\n");
/* Let's use the first record we found to demonstrate storing
* a link to a record in a field inside another record. */
lock_id = wg_start_write(db);
enc = wg_encode_record(db, firstrec);
wg_set_field(db, rec, 1, enc);
wg_end_write(db, lock_id);
/* Now set other fields to various data types. To keep the example shorter,
* the locking and unlocking operations are omitted (in real applications,
* this would be incorrect usage if concurrent access is expected).
*/
wg_set_field(db, rec, 2, wg_encode_str(db, "This is a char array", NULL));
wg_set_field(db, rec, 3, wg_encode_char(db, 'a'));
/* For time and date, we use current time in local timezone */
enc = wg_encode_date(db, wg_current_localdate(db));
if(enc==WG_ILLEGAL) {
printf("failed to encode date.\n");
return;
}
wg_set_field(db, rec, 4, enc);
enc = wg_encode_time(db, wg_current_localtime(db));
if(enc==WG_ILLEGAL) {
printf("failed to encode time.\n");
return;
}
wg_set_field(db, rec, 5, enc);
/* Now read and print all the fields. */
wg_print_record(db, (wg_int *) rec);
printf("\n");
/* Date and time can be handled together as a datetime object. */
datedata = wg_decode_date(db, wg_get_field(db, rec, 4));
timedata = wg_decode_time(db, wg_get_field(db, rec, 5));
wg_strf_iso_datetime(db, datedata, timedata, strbuf);
printf("Reading datetime: %s.\n", strbuf);
printf("Setting date and time to 2010-03-31, 12:59\n");
/* Update date and time to arbitrary values using wg_strp_iso_date/time */
wg_set_field(db, rec, 4,
wg_encode_date(db, wg_strp_iso_date(db, "2010-03-31")));
wg_set_field(db, rec, 5,
wg_encode_time(db, wg_strp_iso_time(db, "12:59:00.33")));
printf("Dumping the contents of the database:\n");
wg_print_db(db);
printf("********* Demo ended ************\n");
}
char* sprint_value(void *db, wg_int enc, char **buf, int *bufsize, char **bptr,
int format, int showid, int depth, int maxdepth, int strenc) {
wg_int *ptrdata;
int intdata,strl,strl1,strl2;
char *strdata, *exdata;
double doubledata;
char strbuf[80]; // tmp area for dates
int limit=MIN_STRLEN;
switch(wg_get_encoded_type(db, enc)) {
case WG_NULLTYPE:
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
if (format!=0) {
// json
snprintf(*bptr, limit, JS_NULL);
return *bptr+strlen(*bptr);
}
return *bptr;
case WG_RECORDTYPE:
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
if (!format || depth>=maxdepth) {
snprintf(*bptr, limit,"%d", (int)enc); // record offset (i.e. id)
return *bptr+strlen(*bptr);
} else {
// recursive print
ptrdata = wg_decode_record(db, enc);
sprint_record(db,ptrdata,buf,bufsize,bptr,format,showid,depth+1,maxdepth,strenc);
**bptr='\0';
return *bptr;
}
break;
case WG_INTTYPE:
intdata = wg_decode_int(db, enc);
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, "%d", intdata);
return *bptr+strlen(*bptr);
case WG_DOUBLETYPE:
doubledata = wg_decode_double(db, enc);
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, DOUBLE_FORMAT, doubledata);
return *bptr+strlen(*bptr);
case WG_FIXPOINTTYPE:
doubledata = wg_decode_fixpoint(db, enc);
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, DOUBLE_FORMAT, doubledata);
return *bptr+strlen(*bptr);
case WG_STRTYPE:
strdata = wg_decode_str(db, enc);
exdata = wg_decode_str_lang(db,enc);
if (strdata!=NULL) strl1=strlen(strdata);
else strl1=0;
if (exdata!=NULL) strl2=strlen(exdata);
else strl2=0;
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN+STRLEN_FACTOR*(strl1+strl2));
sprint_string(*bptr,(strl1+strl2),strdata,strenc);
if (exdata!=NULL) {
snprintf(*bptr+strl1+1,limit,"@%s\"", exdata);
}
return *bptr+strlen(*bptr);
case WG_URITYPE:
strdata = wg_decode_uri(db, enc);
exdata = wg_decode_uri_prefix(db, enc);
if (strdata!=NULL) strl1=strlen(strdata);
else strl1=0;
if (exdata!=NULL) strl2=strlen(exdata);
else strl2=0;
limit=MIN_STRLEN+STRLEN_FACTOR*(strl1+strl2);
str_guarantee_space(buf, bufsize, bptr, limit);
if (exdata==NULL)
snprintf(*bptr, limit, "\"%s\"", strdata);
else
snprintf(*bptr, limit, "\"%s:%s\"", exdata, strdata);
return *bptr+strlen(*bptr);
case WG_XMLLITERALTYPE:
strdata = wg_decode_xmlliteral(db, enc);
exdata = wg_decode_xmlliteral_xsdtype(db, enc);
if (strdata!=NULL) strl1=strlen(strdata);
else strl1=0;
if (exdata!=NULL) strl2=strlen(exdata);
else strl2=0;
limit=MIN_STRLEN+STRLEN_FACTOR*(strl1+strl2);
str_guarantee_space(buf, bufsize, bptr, limit);
snprintf(*bptr, limit, "\"%s:%s\"", exdata, strdata);
return *bptr+strlen(*bptr);
case WG_CHARTYPE:
intdata = wg_decode_char(db, enc);
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, "\"%c\"", (char) intdata);
return *bptr+strlen(*bptr);
case WG_DATETYPE:
intdata = wg_decode_date(db, enc);
wg_strf_iso_datetime(db,intdata,0,strbuf);
strbuf[10]=0;
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, "\"%s\"",strbuf);
return *bptr+strlen(*bptr);
case WG_TIMETYPE:
intdata = wg_decode_time(db, enc);
wg_strf_iso_datetime(db,1,intdata,strbuf);
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, "\"%s\"",strbuf+11);
return *bptr+strlen(*bptr);
case WG_VARTYPE:
intdata = wg_decode_var(db, enc);
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, "\"?%d\"", intdata);
return *bptr+strlen(*bptr);
case WG_BLOBTYPE:
strdata = wg_decode_blob(db, enc);
strl=wg_decode_blob_len(db, enc);
limit=MIN_STRLEN+STRLEN_FACTOR*strlen(strdata);
str_guarantee_space(buf, bufsize, bptr, limit);
sprint_blob(*bptr,strl,strdata,strenc);
return *bptr+strlen(*bptr);
default:
str_guarantee_space(buf, bufsize, bptr, MIN_STRLEN);
snprintf(*bptr, limit, JS_TYPE_ERR);
return *bptr+strlen(*bptr);
}
}
