static struct jx_pair * jx_eval_pair( struct jx_pair *pair, struct jx *context )
{
if(!pair) return 0;
return jx_pair(
jx_eval(pair->key,context),
jx_eval(pair->value,context),
jx_eval_pair(pair->next,context)
);
}
struct jx *catalog_query_read(struct catalog_query *q, time_t stoptime)
{
while(q && q->current) {
int keepit = 1;
if(q->filter_expr) {
struct jx * b;
b = jx_eval(q->filter_expr,q->current->value);
if(jx_istype(b, JX_BOOLEAN) && b->u.boolean_value) {
keepit = 1;
} else {
keepit = 0;
}
jx_delete(b);
} else {
keepit = 1;
}
if(keepit) {
struct jx *result = jx_copy(q->current->value);
q->current = q->current->next;
return result;
}
q->current = q->current->next;
}
return 0;
}
int deltadb_boolean_expr( struct jx *expr, struct jx *data )
{
if(!expr) return 1;
struct jx *j = jx_eval(expr,data);
int result = j && !jx_istype(j, JX_ERROR) && j->type==JX_BOOLEAN && j->u.boolean_value;
jx_delete(j);
return result;
}
static struct jx_item * jx_eval_item( struct jx_item *item, struct jx *context )
{
if(!item) return 0;
return jx_item(
jx_eval(item->value,context),
jx_eval_item(item->next,context)
);
}
static void display_reduce_exprs( struct deltadb *db, time_t current )
{
struct list_node *n;
/* Reset all reductions. */
for(n=db->reduce_exprs->head;n;n=n->next) {
deltadb_reduction_reset(n->data);
}
/* For each item in the hash table: */
char *key;
struct jx *jobject;
hash_table_firstkey(db->table);
while(hash_table_nextkey(db->table,&key,(void**)&jobject)) {
/* Skip if the where expression doesn't match */
if(!deltadb_boolean_expr(db->where_expr,jobject)) continue;
/* Update each reduction with its value. */
for(n=db->reduce_exprs->head;n;n=n->next) {
struct deltadb_reduction *r = n->data;
struct jx *value = jx_eval(r->expr,jobject);
if(value && !jx_istype(value, JX_ERROR)) {
if(value->type==JX_INTEGER) {
deltadb_reduction_update(n->data,(double)value->u.integer_value);
} else if(value->type==JX_DOUBLE) {
deltadb_reduction_update(n->data,value->u.double_value);
} else {
// treat non-numerics as 1, to facilitate operations like COUNT
deltadb_reduction_update(n->data,1);
}
jx_delete(value);
}
}
}
/* Emit the current time */
if(db->epoch_mode) {
printf("%lld\t",(long long) current);
} else {
char str[32];
strftime(str,sizeof(str),"%F %T",localtime(¤t));
printf("%s\t",str);
}
/* For each reduction, display the final value. */
for(n=db->reduce_exprs->head;n;n=n->next) {
printf("%lf\t",deltadb_reduction_value(n->data));
}
printf("\n");
}
static void display_output_exprs( struct deltadb *db, time_t current )
{
/* For each item in the table... */
char *key;
struct jx *jobject;
hash_table_firstkey(db->table);
while(hash_table_nextkey(db->table,&key,(void**)&jobject)) {
/* Skip if the where expression doesn't match */
if(!deltadb_boolean_expr(db->where_expr,jobject)) continue;
/* Emit the current time */
if(db->epoch_mode) {
printf("%lld\t",(long long) current);
} else {
char str[32];
strftime(str,sizeof(str),"%F %T",localtime(¤t));
printf("%s\t",str);
}
/* For each output expression, compute the value and print. */
struct list_node *n;
for(n=db->output_exprs->head;n;n=n->next) {
struct jx *jvalue = jx_eval(n->data,jobject);
jx_print_stream(jvalue,stdout);
printf("\t");
jx_delete(jvalue);
}
printf("\n");
}
}
static struct jx * jx_eval_operator( struct jx_operator *o, struct jx *context )
{
if(!o) return 0;
struct jx *left = jx_eval(o->left,context);
struct jx *right = jx_eval(o->right,context);
if((left && right) && (left->type!=right->type) ) {
if( left->type==JX_INTEGER && right->type==JX_DOUBLE) {
struct jx *n = jx_double(left->u.integer_value);
jx_delete(left);
left = n;
} else if( left->type==JX_DOUBLE && right->type==JX_INTEGER) {
struct jx *n = jx_double(right->u.integer_value);
jx_delete(right);
right = n;
} else if(o->type==JX_OP_EQ) {
jx_delete(left);
jx_delete(right);
return jx_boolean(0);
} else if(o->type==JX_OP_NE) {
jx_delete(left);
jx_delete(right);
return jx_boolean(1);
} else if(o->type==JX_OP_LOOKUP) {
struct jx *r = jx_eval_lookup(left,right);
jx_delete(left);
jx_delete(right);
return r;
} else {
jx_delete(left);
jx_delete(right);
return jx_null();
}
}
struct jx *result;
switch(right->type) {
case JX_NULL:
result = jx_eval_null(o->type);
break;
case JX_BOOLEAN:
result = jx_eval_boolean(o->type,left,right);
break;
case JX_INTEGER:
result = jx_eval_integer(o->type,left,right);
break;
case JX_DOUBLE:
result = jx_eval_double(o->type,left,right);
break;
case JX_STRING:
result = jx_eval_string(o->type,left,right);
break;
default:
result = jx_null();
break;
}
jx_delete(left);
jx_delete(right);
return result;
}
