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