int wr_equal_ptr_primitives(glb* g, gint a, gint b, int uniquestrflag) { gint t1,t2; gint l1,l2,ol; char* s1; char* s2; //printf("equal_ptr_primitives called with %d and %d\n",a,b); switch(a&NORMALPTRMASK) { // last 3 bits case FULLINTBITSV0: case FULLINTBITSV1: if (isfullint(b) && (dbfetch(g->db,decode_fullint_offset(a))==dbfetch(g->db,decode_fullint_offset(b))) ) return 1; else return 0; case FULLDOUBLEBITS: if (isfulldouble(b) && wg_decode_double(g->db,a)==wg_decode_double(g->db,b) ) return 1; else return 0; case SHORTSTRBITS: //printf("shortstrbits \n"); if (isshortstr(b) && !memcmp((void*)(offsettoptr(g->db,decode_shortstr_offset(a))), (void*)(offsettoptr(g->db,decode_shortstr_offset(b))), SHORTSTR_SIZE)) return 1; else return 0; case LONGSTRBITS: if (uniquestrflag) { if (a==b) return 1; else return 0; } else { t1=wg_get_encoded_type(g->db,a); t2=wg_get_encoded_type(g->db,b); if (t1!=t2) return 0; l1=wg_decode_unistr_lang_len(g->db,a,t1); l2=wg_decode_unistr_lang_len(g->db,b,t2); if (11!=l2) return 0; ol=l1; l1=wg_decode_unistr_len(g->db,a,t1); l2=wg_decode_unistr_len(g->db,b,t2); if (11!=l2) return 0; s1=wg_decode_unistr_lang(g->db,a,t1); s2=wg_decode_unistr_lang(g->db,b,t2); if (s1!=s2 && (s1==NULL || s2==NULL || memcmp(s1,s2,ol))) return 0; s1=wg_decode_unistr(g->db,a,t1); s2=wg_decode_unistr(g->db,b,t2); if (s1!=s2 && (s1==NULL || s2==NULL || memcmp(s1,s2,l1))) return 0; return 1; } } return 0; }
int wg_right_strhash_bucket (void* db, gint longstr, char* cstr, char* cextrastr, gint ctype, gint cstrsize) { char* str; char* extrastr; int strsize; gint type; //printf("wg_right_strhash_bucket called with %s %s type %d size %d\n", // cstr,cextrastr,ctype,cstrsize); type=wg_get_encoded_type(db,longstr); if (type!=ctype) return 0; strsize=wg_decode_str_len(db,longstr)+1; if (strsize!=cstrsize) return 0; str=wg_decode_str(db,longstr); if ((cstr==NULL && str!=NULL) || (cstr!=NULL && str==NULL)) return 0; if ((cstr!=NULL) && (memcmp(str,cstr,cstrsize))) return 0; extrastr=wg_decode_str_lang(db,longstr); if ((cextrastr==NULL && extrastr!=NULL) || (cextrastr!=NULL && extrastr==NULL)) return 0; if ((cextrastr!=NULL) && (strcmp(extrastr,cextrastr))) return 0; return 1; }
/** Compare two encoded values * a, b - encoded values * returns WG_GREATER, WG_EQUAL or WG_LESSTHAN * assumes that a and b themselves are not equal and so * their decoded values need to be examined (which could still * be equal for some data types). * depth - recursion depth for records */ gint wg_compare(void *db, gint a, gint b, int depth) { /* a very simplistic version of the function: * - we get the types of the variables * - if the types match, compare the decoded values * - otherwise compare the type codes (not really scientific, * but will provide a means of ordering values). * * One important point that should be observed here is * that the returned values should be consistent when * comparing A to B and then B to A. This applies to cases * where we have no reason to think one is greater than * the other from the *user's* point of view, but for use * in T-tree index and similar, values need to be consistently * ordered. Examples include unknown types and record pointers * (once recursion depth runs out). */ /* XXX: might be able to save time here to mask and compare * the type bits instead */ gint typea = wg_get_encoded_type(db, a); gint typeb = wg_get_encoded_type(db, b); /* assume types are >2 (NULLs are always equal) and * <13 (not implemented as of now) * XXX: all of this will fall apart if type codes * are somehow rearranged :-) */ if(typeb==typea) { if(typea>WG_CHARTYPE) { /* > 9, not a string */ if(typea>WG_FIXPOINTTYPE) { /* date or time. Compare decoded gints */ gint deca, decb; if(typea==WG_DATETYPE) { deca = wg_decode_date(db, a); decb = wg_decode_date(db, b); } else if(typea==WG_TIMETYPE) { deca = wg_decode_time(db, a); decb = wg_decode_time(db, b); } else if(typea==WG_VARTYPE) { deca = wg_decode_var(db, a); decb = wg_decode_var(db, b); } else { /* anon const or other new type, no idea how to compare */ return (a>b ? WG_GREATER : WG_LESSTHAN); } return (deca>decb ? WG_GREATER : WG_LESSTHAN); } else { /* fixpoint, need to compare doubles */ double deca, decb; deca = wg_decode_fixpoint(db, a); decb = wg_decode_fixpoint(db, b); return (deca>decb ? WG_GREATER : WG_LESSTHAN); } } else if(typea<WG_STRTYPE) { /* < 5, still not a string */ if(typea==WG_RECORDTYPE) { void *deca, *decb; deca = wg_decode_record(db, a); decb = wg_decode_record(db, b); if(!depth) { /* No more recursion allowed and pointers aren't equal. * So while we're technically comparing the addresses here, * the main point is that the returned value != WG_EQUAL */ return ((gint) deca> (gint) decb ? WG_GREATER : WG_LESSTHAN); } else { int i; #ifdef USE_CHILD_DB void *parenta, *parentb; #endif int lena = wg_get_record_len(db, deca); int lenb = wg_get_record_len(db, decb); #ifdef USE_CHILD_DB /* Determine, if the records are inside the memory area beloning * to our current base address. If it is outside, the encoded * values inside the record contain offsets in relation to * a different base address and need to be translated. */ parenta = wg_get_rec_owner(db, deca); parentb = wg_get_rec_owner(db, decb); #endif /* XXX: Currently we're considering records of differing lengths * non-equal without comparing the elements */ if(lena!=lenb) return (lena>lenb ? WG_GREATER : WG_LESSTHAN); /* Recursively check each element in the record. If they * are not equal, break and return with the obtained value */ for(i=0; i<lena; i++) { gint elema = wg_get_field(db, deca, i); gint elemb = wg_get_field(db, decb, i); #ifdef USE_CHILD_DB if(parenta != dbmemseg(db)) { elema = wg_translate_hdroffset(db, parenta, elema); } if(parentb != dbmemseg(db)) { elemb = wg_translate_hdroffset(db, parentb, elemb); } #endif if(elema != elemb) { gint cr = wg_compare(db, elema, elemb, depth - 1); if(cr != WG_EQUAL) return cr; } } return WG_EQUAL; /* all elements matched */ } } else if(typea==WG_INTTYPE) { gint deca, decb; deca = wg_decode_int(db, a); decb = wg_decode_int(db, b); if(deca==decb) return WG_EQUAL; /* large ints can be equal */ return (deca>decb ? WG_GREATER : WG_LESSTHAN); } else { /* WG_DOUBLETYPE */ double deca, decb; deca = wg_decode_double(db, a); decb = wg_decode_double(db, b); if(deca==decb) return WG_EQUAL; /* decoded doubles can be equal */ return (deca>decb ? WG_GREATER : WG_LESSTHAN); } } else { /* string */ /* Need to compare the characters. In case of 0-terminated * strings we use strcmp() directly, which in glibc is heavily * optimised. In case of blob type we need to query the length * and use memcmp(). */ char *deca, *decb, *exa=NULL, *exb=NULL; char buf[4]; gint res; if(typea==WG_STRTYPE) { /* lang is ignored */ deca = wg_decode_str(db, a); decb = wg_decode_str(db, b); } else if(typea==WG_URITYPE) { exa = wg_decode_uri_prefix(db, a); exb = wg_decode_uri_prefix(db, b); deca = wg_decode_uri(db, a); decb = wg_decode_uri(db, b); } else if(typea==WG_XMLLITERALTYPE) { exa = wg_decode_xmlliteral_xsdtype(db, a); exb = wg_decode_xmlliteral_xsdtype(db, b); deca = wg_decode_xmlliteral(db, a); decb = wg_decode_xmlliteral(db, b); } else if(typea==WG_CHARTYPE) { buf[0] = wg_decode_char(db, a); buf[1] = '\0'; buf[2] = wg_decode_char(db, b); buf[3] = '\0'; deca = buf; decb = &buf[2]; } else { /* WG_BLOBTYPE */ deca = wg_decode_blob(db, a); decb = wg_decode_blob(db, b); } if(exa || exb) { /* String type where extra information is significant * (we're ignoring this for plain strings and blobs). * If extra part is equal, normal comparison continues. If * one string is missing altogether, it is considered to be * smaller than the other string. */ if(!exb) { if(exa[0]) return WG_GREATER; } else if(!exa) { if(exb[0]) return WG_LESSTHAN; } else { res = strcmp(exa, exb); if(res > 0) return WG_GREATER; else if(res < 0) return WG_LESSTHAN; } } #if 0 /* paranoia check */ if(!deca || !decb) { if(decb) if(decb[0]) return WG_LESSTHAN; } else if(deca) { if(deca[0]) return WG_GREATER; } return WG_EQUAL; } #endif if(typea==WG_BLOBTYPE) { /* Blobs are not 0-terminated */ int lena = wg_decode_blob_len(db, a); int lenb = wg_decode_blob_len(db, b); res = memcmp(deca, decb, (lena < lenb ? lena : lenb)); if(!res) res = lena - lenb; } else { res = strcmp(deca, decb); } if(res > 0) return WG_GREATER; else if(res < 0) return WG_LESSTHAN; else return WG_EQUAL; } }
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); } }
char* recids(char* database, char* inparams[], char* invalues[], int incount, int* hformat) { int i,j,x,gcount; char* cids; wg_int ids[MAXIDS]; int count=MAXCOUNT; void* db=NULL; // actual database pointer void* rec; char* res; int res_size=INITIAL_MALLOC; wg_int lock_id=0; // non-0 iff lock set int maxdepth=MAX_DEPTH_DEFAULT; // rec depth limit for printer int showid=0; // add record id as first extra elem: 0: no, 1: yes int format=1; // 0: csv, 1:json int escape=2; // string special chars escaping: 0: just ", 1: urlencode, 2: json, 3: csv char errbuf[200]; // used for building variable-content input param error strings only char* strbuffer; // main result string buffer start (malloced later) int strbufferlen; // main result string buffer length char* strbufferptr; // current output location ptr in the main result string buffer // -------check and parse cgi parameters, attach database ------------ // set ids to defaults for(i=0;i<MAXIDS;i++) { ids[i]=0; } // find ids and display format parameters for(i=0;i<incount;i++) { if (strncmp(inparams[i],"recids",MAXQUERYLEN)==0) { cids=invalues[i]; x=0; // split csv int list to ids int array for(j=0;j<strlen(cids);j++) { if (atoi(cids+j) && atoi(cids+j)>0) ids[x++]=atoi(cids+j); if (x>=MAXIDS) break; for(;j<strlen(cids) && cids[j]!=','; j++) {}; } } else if (strncmp(inparams[i],"depth",MAXQUERYLEN)==0) { maxdepth=atoi(invalues[i]); } else if (strncmp(inparams[i],"showid",MAXQUERYLEN)==0) { if (strncmp(invalues[i],"yes",MAXQUERYLEN)==0) showid=1; else if (strncmp(invalues[i],"no",MAXQUERYLEN)==0) showid=0; else { snprintf(errbuf,100,UNKNOWN_PARAM_VALUE_ERR,invalues[i],inparams[i]); errhalt(errbuf); } } else if (strncmp(inparams[i],"format",MAXQUERYLEN)==0) { if (strncmp(invalues[i],"csv",MAXQUERYLEN)==0) format=0; else if (strncmp(invalues[i],"json",MAXQUERYLEN)==0) format=1; else { snprintf(errbuf,100,UNKNOWN_PARAM_VALUE_ERR,invalues[i],inparams[i]); errhalt(errbuf); } } else if (strncmp(inparams[i],"escape",MAXQUERYLEN)==0) { if (strncmp(invalues[i],"no",MAXQUERYLEN)==0) escape=0; else if (strncmp(invalues[i],"url",MAXQUERYLEN)==0) escape=1; else if (strncmp(invalues[i],"json",MAXQUERYLEN)==0) escape=2; else { snprintf(errbuf,100,UNKNOWN_PARAM_VALUE_ERR,invalues[i],inparams[i]); errhalt(errbuf); } } else if (strncmp(inparams[i],"db",MAXQUERYLEN)==0) { // correct parameter, no action here } else if (strncmp(inparams[i],"op",MAXQUERYLEN)==0) { // correct parameter, no action here } else { // incorrect/unrecognized parameter snprintf(errbuf,100,UNKNOWN_PARAM_ERR,inparams[i]); errhalt(errbuf); } } // all parameters and values were understood if (format==0) { // csv maxdepth=0; // record structure not printed for csv escape=3; // only " replaced with "" *hformat=0; // store to caller for content-type header global_format=0; // for error handler only } // attach to database db = wg_attach_existing_database(database); global_db=db; if (!db) errhalt(DB_ATTACH_ERR); res=malloc(res_size); if (!res) { err_clear_detach_halt(db,0,MALLOC_ERR); } // database attached OK // create output string buffer (may be reallocated later) strbuffer=str_new(INITIAL_MALLOC); strbufferlen=INITIAL_MALLOC; strbufferptr=strbuffer; // take a read lock and loop over ids gcount=0; lock_id = wg_start_read(db); // get read lock global_lock_id=lock_id; // only for handling errors if (!lock_id) err_clear_detach_halt(db,0,LOCK_ERR); str_guarantee_space(&strbuffer,&strbufferlen,&strbufferptr,MIN_STRLEN); if (format!=0) { // json snprintf(strbufferptr,MIN_STRLEN,"[\n"); strbufferptr+=2; } if (maxdepth>MAX_DEPTH_HARD) maxdepth=MAX_DEPTH_HARD; for(j=0; ids[j]!=0 && j<MAXIDS; j++) { x=wg_get_encoded_type(db,ids[j]); if (x!=WG_RECORDTYPE) continue; rec=wg_decode_record(db,ids[j]); if (rec==NULL) continue; x=wg_get_record_len(db,rec); if (x<=0) continue; gcount++; if (gcount>count) break; str_guarantee_space(&strbuffer,&strbufferlen,&strbufferptr,MIN_STRLEN); if (gcount>1 && format!=0) { // json and not first row snprintf(strbufferptr,MIN_STRLEN,",\n"); strbufferptr+=2; } sprint_record(db,rec,&strbuffer,&strbufferlen,&strbufferptr,format,showid,0,maxdepth,escape); if (format==0) { // csv str_guarantee_space(&strbuffer,&strbufferlen,&strbufferptr,MIN_STRLEN); snprintf(strbufferptr,MIN_STRLEN,"\r\n"); strbufferptr+=2; } rec=wg_get_next_record(db,rec); } if (!wg_end_read(db, lock_id)) { // release read lock err_clear_detach_halt(db,lock_id,LOCK_RELEASE_ERR); } global_lock_id=0; // only for handling errors wg_detach_database(db); global_db=NULL; // only for handling errors str_guarantee_space(&strbuffer,&strbufferlen,&strbufferptr,MIN_STRLEN); if (format!=0) { // json snprintf(strbufferptr,MIN_STRLEN,"\n]"); strbufferptr+=3; } return strbuffer; }
/* * Return an encoded value as a decoded byte array. * It should be freed afterwards. * returns the number of bytes in the array. * returns 0 if the decode failed. * * NOTE: to differentiate between identical byte strings * the value is prefixed with a type identifier. * TODO: For values with varying length that can contain * '\0' bytes, add length to the prefix. */ gint wg_decode_for_hashing(void *db, gint enc, char **decbytes) { gint len; gint type; gint ptrdata; int intdata; double doubledata; char *bytedata; char *exdata, *buf = NULL, *outbuf; type = wg_get_encoded_type(db, enc); switch(type) { case WG_NULLTYPE: len = sizeof(gint); ptrdata = 0; bytedata = (char *) &ptrdata; break; case WG_RECORDTYPE: len = sizeof(gint); ptrdata = enc; bytedata = (char *) &ptrdata; break; case WG_INTTYPE: len = sizeof(int); intdata = wg_decode_int(db, enc); bytedata = (char *) &intdata; break; case WG_DOUBLETYPE: len = sizeof(double); doubledata = wg_decode_double(db, enc); bytedata = (char *) &doubledata; break; case WG_FIXPOINTTYPE: len = sizeof(double); doubledata = wg_decode_fixpoint(db, enc); bytedata = (char *) &doubledata; break; case WG_STRTYPE: len = wg_decode_str_len(db, enc); bytedata = wg_decode_str(db, enc); break; case WG_URITYPE: len = wg_decode_uri_len(db, enc); bytedata = wg_decode_uri(db, enc); exdata = wg_decode_uri_prefix(db, enc); CONCAT_FOR_HASHING(db, bytedata, exdata, len, buf, enc) break; case WG_XMLLITERALTYPE: len = wg_decode_xmlliteral_len(db, enc); bytedata = wg_decode_xmlliteral(db, enc); exdata = wg_decode_xmlliteral_xsdtype(db, enc); CONCAT_FOR_HASHING(db, bytedata, exdata, len, buf, enc) break; case WG_CHARTYPE: len = sizeof(int); intdata = wg_decode_char(db, enc); bytedata = (char *) &intdata; break; case WG_DATETYPE: len = sizeof(int); intdata = wg_decode_date(db, enc); bytedata = (char *) &intdata; break; case WG_TIMETYPE: len = sizeof(int); intdata = wg_decode_time(db, enc); bytedata = (char *) &intdata; break; case WG_VARTYPE: len = sizeof(int); intdata = wg_decode_var(db, enc); bytedata = (char *) &intdata; break; case WG_ANONCONSTTYPE: /* Ignore anonconst */ default: return 0; } /* Form the hashable buffer. It is not 0-terminated */ outbuf = malloc(len + 1); if(outbuf) { outbuf[0] = (char) type; memcpy(outbuf + 1, bytedata, len++); *decbytes = outbuf; } else { /* Indicate failure */ len = 0; } if(buf) free(buf); return len; }
static char* search(thread_data_p tdata, char* inparams[], char* invalues[], int incount, int opcode) { char* database=tdata->database; char *token=NULL; int i,j,x,itmp; wg_int type=0; char* fields[MAXPARAMS]; // search fields char* values[MAXPARAMS]; // search values char* compares[MAXPARAMS]; // search comparisons char* types[MAXPARAMS]; // search value types char* cids=NULL; wg_int ids[MAXIDS]; // select these ids only int fcount=0, vcount=0, ccount=0, tcount=0; // array el counters for above char* sfields[MAXPARAMS]; // set / selected fields char* svalues[MAXPARAMS]; // set field values char* stypes[MAXPARAMS]; // set field types int sfcount; // array el counters for above int from=0; unsigned long count,rcount,gcount,handlecount; void* db=NULL; // actual database pointer void *rec, *oldrec; char* res; wg_query *wgquery; // query datastructure built later wg_query_arg wgargs[MAXPARAMS]; wg_int lock_id=0; // non-0 iff lock set int searchtype=0; // 0: full scan, 1: record ids, 2: by fields char errbuf[ERRBUF_LEN]; // used for building variable-content input param error strings only // default max nr of rows shown/handled if (opcode==COUNT_CODE) count=LONG_MAX; else count=MAXCOUNT; // -------check and parse cgi parameters, attach database ------------ // set params to defaults for(i=0;i<MAXPARAMS;i++) { fields[i]=NULL; values[i]=NULL; compares[i]=NULL; types[i]=NULL; sfields[i]=NULL; svalues[i]=NULL; stypes[i]=NULL; } // set printing params to defaults tdata->format=1; // 1: json tdata->maxdepth=MAX_DEPTH_DEFAULT; // rec depth limit for printer tdata->showid=0; // add record id as first extra elem: 0: no, 1: yes tdata->strenc=2; // string special chars escaping: 0: just ", 1: urlencode, 2: json, 3: csv // find search parameters for(i=0;i<incount;i++) { if (strncmp(inparams[i],"recids",MAXQUERYLEN)==0) { cids=invalues[i]; x=0; // set ids to defaults for(j=0;j<MAXIDS;j++) ids[j]=0; // split csv int list to ids int array for(j=0;j<strlen(cids);j++) { if (atoi(cids+j) && atoi(cids+j)>0) ids[x++]=atoi(cids+j); if (x>=MAXIDS) break; for(;j<strlen(cids) && cids[j]!=','; j++) {}; } } else if (strncmp(inparams[i],"fld",MAXQUERYLEN)==0) { res=handle_fld_param(tdata,inparams[i],invalues[i], &sfields[sfcount],&svalues[sfcount],&stypes[sfcount],sfcount,errbuf); if (res!=NULL) return res; // return error string sfcount++; } else if (strncmp(inparams[i],"field",MAXQUERYLEN)==0) { fields[fcount++]=invalues[i]; } else if (strncmp(inparams[i],"value",MAXQUERYLEN)==0) { values[vcount++]=invalues[i]; } else if (strncmp(inparams[i],"compare",MAXQUERYLEN)==0) { compares[ccount++]=invalues[i]; } else if (strncmp(inparams[i],"type",MAXQUERYLEN)==0) { types[tcount++]=invalues[i]; } else if (strncmp(inparams[i],"from",MAXQUERYLEN)==0) { from=atoi(invalues[i]); } else if (strncmp(inparams[i],"count",MAXQUERYLEN)==0) { count=atoi(invalues[i]); } else { // handle generic parameters for all queries: at end of param check res=handle_generic_param(tdata,inparams[i],invalues[i],&token,errbuf); if (res!=NULL) return res; // return error string } } // authorization if (opcode==DELETE_CODE || opcode==UPDATE_CODE) { if (!authorize(WRITE_LEVEL,tdata,database,token)) return errhalt(NOT_AUTHORIZED_ERR,tdata); } else { if (!authorize(READ_LEVEL,tdata,database,token)) return errhalt(NOT_AUTHORIZED_ERR,tdata); } // all parameters and values were understood if (tdata->format==0) { // csv tdata->maxdepth=0; // record structure not printed for csv tdata->strenc=3; // only " replaced with "" } // check search parameters if (cids!=NULL) { // query by record ids if (fcount) return errhalt(RECIDS_COMBINED_ERR,tdata); searchtype=1; } else if (!fcount) { // no search fields given if (vcount || ccount || tcount) return errhalt(NO_FIELD_ERR,tdata); else searchtype=0; // scan everything } else { // search by fields searchtype=2; } // attach to database db=op_attach_database(tdata,database,READ_LEVEL); if (!db) return errhalt(DB_ATTACH_ERR,tdata); // database attached OK // create output string buffer (may be reallocated later) tdata->buf=str_new(INITIAL_MALLOC); if (tdata->buf==NULL) return errhalt(MALLOC_ERR,tdata); tdata->bufsize=INITIAL_MALLOC; tdata->bufptr=tdata->buf; // check printing depth if (tdata->maxdepth>MAX_DEPTH_HARD) tdata->maxdepth=MAX_DEPTH_HARD; // initial print if(!op_print_data_start(tdata,opcode==SEARCH_CODE)) return err_clear_detach_halt(MALLOC_ERR,tdata); // zero counters rcount=0; gcount=0; handlecount=0; // actual nr of records handled // get lock if (tdata->realthread && tdata->common->shutdown) return NULL; // for multithreading only lock_id = wg_start_read(db); // get read lock tdata->lock_id=lock_id; tdata->lock_type=READ_LOCK_TYPE; if (!lock_id) return err_clear_detach_halt(LOCK_ERR,tdata); // handle one of the cases if (searchtype==0) { // ------- full scan case --- rec=wg_get_first_record(db); while (rec!=NULL) { if (rcount>=from) { gcount++; if (gcount>count) break; if (opcode==COUNT_CODE) { handlecount++; } else if (opcode==SEARCH_CODE) { itmp=op_print_record(tdata,rec,gcount); if (!itmp) return err_clear_detach_halt(MALLOC_ERR,tdata); } else if (opcode==UPDATE_CODE) { itmp=op_update_record(tdata,db,rec,0,0); if (!itmp) handlecount++; } } oldrec=rec; rec=wg_get_next_record(db,rec); if (opcode==DELETE_CODE) { x=wg_get_record_len(db,oldrec); if (x>0) { itmp=op_delete_record(tdata,oldrec); if (!itmp) handlecount++; //else err_clear_detach_halt(DELETE_ERR,tdata); } } rcount++; } } else if (searchtype==1) { // ------------ search by record ids: ------------ for(j=0; ids[j]!=0 && j<MAXIDS; j++) { x=wg_get_encoded_type(db,ids[j]); if (x!=WG_RECORDTYPE) continue; rec=wg_decode_record(db,ids[j]); if (rec==NULL) continue; x=wg_get_record_len(db,rec); if (x<=0) continue; gcount++; if (gcount>count) break; if (opcode==COUNT_CODE) handlecount++; else if (opcode==SEARCH_CODE) { itmp=op_print_record(tdata,rec,gcount); if (!itmp) return err_clear_detach_halt(MALLOC_ERR,tdata); } else if (opcode==UPDATE_CODE) { itmp=op_update_record(tdata,db,rec,0,0); if (!itmp) handlecount++; } else if (opcode==DELETE_CODE) { // test that db is not null, otherwise we may corrupt the database oldrec=wg_get_first_record(db); if (oldrec!=NULL) { //wg_int objecthead=dbfetch((void*)db,(void*)rec); //printf("isfreeobject %d\n",isfreeobject((int)objecthead)); wg_print_record(db,rec); itmp=op_delete_record(tdata,rec); printf("deletion result %d\n",itmp); if (!itmp) handlecount++; //else return err_clear_detach_halt(DELETE_ERR,tdata); } } } } else if (searchtype==2) { // ------------by field search case: --------- // create a query list datastructure for(i=0;i<fcount;i++) { // field num if (!isint(fields[i])) return err_clear_detach_halt(NO_FIELD_ERR,tdata); itmp=atoi(fields[i]); if(itmp<0) return err_clear_detach_halt(NO_FIELD_ERR,tdata); // column to compare wgargs[i].column = itmp; // comparison op: default equal wgargs[i].cond = encode_incomp(db,compares[i]); if (wgargs[i].cond==BAD_WG_VALUE) return err_clear_detach_halt(COND_ERR,tdata); // valuetype: default guess from value later type=encode_intype(db,types[i]); if (type==BAD_WG_VALUE) return err_clear_detach_halt(INTYPE_ERR,tdata); // encode value to compare with wgargs[i].value = encode_invalue(db,values[i],type); if (wgargs[i].value==WG_ILLEGAL) return err_clear_detach_halt(INTYPE_ERR,tdata); } // make the query structure wgquery = wg_make_query(db, NULL, 0, wgargs, i); if (!wgquery) return err_clear_detach_halt(QUERY_ERR,tdata); // actually perform the query if (tdata->maxdepth>MAX_DEPTH_HARD) tdata->maxdepth=MAX_DEPTH_HARD; while((rec = wg_fetch(db, wgquery))) { if (rcount>=from) { gcount++; if (opcode==COUNT_CODE) handlecount++; else if (opcode==SEARCH_CODE) { itmp=op_print_record(tdata,rec,gcount); if (!itmp) return err_clear_detach_halt(MALLOC_ERR,tdata); } else if (opcode==UPDATE_CODE) { itmp=op_update_record(tdata,db,rec,0,0); if (!itmp) handlecount++; } else if (opcode==DELETE_CODE) { itmp=op_delete_record(tdata,rec); if (!itmp) handlecount++; //else return err_clear_detach_halt(DELETE_ERR,tdata); } } rcount++; if (gcount>=count) break; } // free query datastructure, for(i=0;i<fcount;i++) wg_free_query_param(db, wgargs[i].value); wg_free_query(db,wgquery); } // ----- cases handled ------ // print a single number for count and delete if (opcode==COUNT_CODE || opcode==DELETE_CODE) { if(!str_guarantee_space(tdata,MIN_STRLEN)) return err_clear_detach_halt(MALLOC_ERR,tdata); itmp=snprintf(tdata->bufptr,MIN_STRLEN,"%lu",handlecount); tdata->bufptr+=itmp; } // release locks and detach if (!wg_end_read(db, lock_id)) { // release read lock return err_clear_detach_halt(LOCK_RELEASE_ERR,tdata); } tdata->lock_id=0; op_detach_database(tdata,db); if(!op_print_data_end(tdata,opcode==SEARCH_CODE)) return err_clear_detach_halt(MALLOC_ERR,tdata); return tdata->buf; }