Changeset: d4e56d19e67b for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=d4e56d19e67b
Added Files:
        monetdb5/extras/jaql/jaqltests/Tests/in.jaql
        monetdb5/extras/jaql/jaqltests/Tests/in.stable.err
        monetdb5/extras/jaql/jaqltests/Tests/in.stable.out
Modified Files:
        configure.ag
        monetdb5/extras/jaql/jaqlgencode.c
        monetdb5/extras/jaql/jaqltests/Tests/All
        monetdb5/extras/jaql/parser/jaql.l
        sql/backends/monet5/sql_scenario.c
Branch: default
Log Message:

Merge with Jul2012 branch.


diffs (truncated from 859 to 300 lines):

diff --git a/monetdb5/extras/jaql/jaqlgencode.c 
b/monetdb5/extras/jaql/jaqlgencode.c
--- a/monetdb5/extras/jaql/jaqlgencode.c
+++ b/monetdb5/extras/jaql/jaqlgencode.c
@@ -486,6 +486,458 @@ dumprefvar(jc *j, MalBlkPtr mb, tree *t,
 }
 
 /* returns bat with in the head the oids from elems that match the
+ * in condition */
+static int
+dumpin(jc *j, Client cntxt, MalBlkPtr mb, tree *t, int elems)
+{
+       int ink = 0, inn = 0, ind = 0, ins = 0;
+       int a, b, c, g = 0;
+       InstrPtr q;
+
+       assert(
+                       (t->tval3->type == j_json_arr &&
+                               (t->tval1->type == j_var || t->tval1->type == 
j_operation))
+                       || (t->tval3->type == j_var &&
+                               (t->tval1->type == j_var || t->tval1->type == 
j_operation
+                                || t->tval1->type == j_num || t->tval1->type 
== j_dbl
+                                || t->tval1->type == j_str || t->tval1->type 
== j_bool
+                                || t->tval1->type == j_null))
+                 );
+
+       switch (t->tval3->type) {
+               case j_json_arr:
+                       if (t->tval1->type == j_operation) {
+                               a = dumpvariabletransformation(j, cntxt, mb, 
t->tval1, elems);
+                       } else if (t->tval1->type == j_var) {
+                               a = dumprefvar(j, mb, t->tval1, elems);
+                       } else /* literal */ {
+                               a = -1;
+                               assert(0);
+                       }
+
+                       /* we will create 4 BATs, one for kind matches (t, f, 
n),
+                        * and one for num, dbl and str each */
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, newRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushType(mb, q, TYPE_oid);
+                       q = pushType(mb, q, TYPE_bte);
+                       ink = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, newRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushType(mb, q, TYPE_oid);
+                       q = pushType(mb, q, TYPE_lng);
+                       inn = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, newRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushType(mb, q, TYPE_oid);
+                       q = pushType(mb, q, TYPE_dbl);
+                       ind = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, newRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushType(mb, q, TYPE_oid);
+                       q = pushType(mb, q, TYPE_str);
+                       ins = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       if (t->tval3->tval1 != NULL) {
+                               tree *n;
+                               for (n = t->tval3->tval1; n != NULL; n = 
n->next) {
+                                       switch (n->type) {
+                                               case j_num:
+                                                       q = newInstruction(mb, 
ASSIGNsymbol);
+                                                       setModuleId(q, batRef);
+                                                       setFunctionId(q, 
insertRef;);
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, TYPE_any));
+                                                       q = pushArgument(mb, q, 
inn);
+                                                       q = pushNil(mb, q, 
TYPE_oid);
+                                                       q = pushLng(mb, q, 
n->nval);
+                                                       inn = getArg(q, 0);
+                                                       pushInstruction(mb, q);
+                                                       break;
+                                               case j_dbl:
+                                                       q = newInstruction(mb, 
ASSIGNsymbol);
+                                                       setModuleId(q, batRef);
+                                                       setFunctionId(q, 
insertRef;);
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, TYPE_any));
+                                                       q = pushArgument(mb, q, 
ind);
+                                                       q = pushNil(mb, q, 
TYPE_oid);
+                                                       q = pushDbl(mb, q, 
n->dval);
+                                                       ind = getArg(q, 0);
+                                                       pushInstruction(mb, q);
+                                                       break;
+                                               case j_str:
+                                                       q = newInstruction(mb, 
ASSIGNsymbol);
+                                                       setModuleId(q, batRef);
+                                                       setFunctionId(q, 
insertRef;);
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, TYPE_any));
+                                                       q = pushArgument(mb, q, 
ins);
+                                                       q = pushNil(mb, q, 
TYPE_oid);
+                                                       q = pushStr(mb, q, 
n->sval);
+                                                       ins = getArg(q, 0);
+                                                       pushInstruction(mb, q);
+                                                       break;
+                                               case j_bool:
+                                                       q = newInstruction(mb, 
ASSIGNsymbol);
+                                                       setModuleId(q, batRef);
+                                                       setFunctionId(q, 
insertRef;);
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, TYPE_any));
+                                                       q = pushArgument(mb, q, 
ink);
+                                                       q = pushNil(mb, q, 
TYPE_oid);
+                                                       q = pushBte(mb, q, 
n->nval ? 't' : 'f');
+                                                       ink = getArg(q, 0);
+                                                       pushInstruction(mb, q);
+                                                       break;
+                                               case j_null:
+                                                       q = newInstruction(mb, 
ASSIGNsymbol);
+                                                       setModuleId(q, batRef);
+                                                       setFunctionId(q, 
insertRef;);
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, TYPE_any));
+                                                       q = pushArgument(mb, q, 
ink);
+                                                       q = pushNil(mb, q, 
TYPE_oid);
+                                                       q = pushBte(mb, q, 'n');
+                                                       ink = getArg(q, 0);
+                                                       pushInstruction(mb, q);
+                                                       break;
+                                               default:
+                                                       assert(0);
+                                       }
+                               }
+                       }
+
+                       /* perform joins with ins, inn, ind, ink */
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, newRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushType(mb, q, TYPE_oid);
+                       q = pushType(mb, q, TYPE_oid);
+                       g = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       /* string */
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, a);
+                       q = pushArgument(mb, q, j->j2);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, reverseRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, b);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, ins);
+                       q = pushArgument(mb, q, b);
+                       c = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, insertRef;);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, g);
+                       q = pushArgument(mb, q, c);
+                       g = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       /* int */
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, a);
+                       q = pushArgument(mb, q, j->j3);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, reverseRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, b);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, inn);
+                       q = pushArgument(mb, q, b);
+                       c = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, insertRef;);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, g);
+                       q = pushArgument(mb, q, c);
+                       g = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       /* double */
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, a);
+                       q = pushArgument(mb, q, j->j4);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, reverseRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, b);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, ind);
+                       q = pushArgument(mb, q, b);
+                       c = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, insertRef;);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, g);
+                       q = pushArgument(mb, q, c);
+                       g = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       /* kind */
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, a);
+                       q = pushArgument(mb, q, j->j1);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, reverseRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, b);
+                       b = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, algebraRef);
+                       setFunctionId(q, joinRef);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, ink);
+                       q = pushArgument(mb, q, b);
+                       c = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, insertRef;);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, g);
+                       q = pushArgument(mb, q, c);
+                       g = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       /* get elem ids on the left again */    
+                       q = newInstruction(mb, ASSIGNsymbol);
+                       setModuleId(q, batRef);
+                       setFunctionId(q, reverseRef;);
+                       q = pushReturn(mb, q, newTmpVariable(mb, TYPE_any));
+                       q = pushArgument(mb, q, g);
+                       g = getArg(q, 0);
+                       pushInstruction(mb, q);
+
+                       break;
+               case j_var:
+                       a = dumprefvar(j, mb, t->tval3, elems);
+
+                       /* take all arrays from a */
+                       q = newInstruction(mb, ASSIGNsymbol);
_______________________________________________
Checkin-list mailing list
Checkin-list@monetdb.org
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to