Changeset: 111a20aab56b for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=111a20aab56b
Modified Files:
        monetdb5/modules/kernel/arrays.mal
        sql/backends/monet5/rel_bin.c
        sql/backends/monet5/sql_gencode.c
        sql/backends/monet5/sql_statement.c
        sql/backends/monet5/sql_statement.h
        sql/server/rel_exp.c
Branch: arrays
Log Message:

added code to project cells after performing selections over them + fixed 
subselects + fixed thetasubselects when having arrays


diffs (truncated from 562 to 300 lines):

diff --git a/monetdb5/modules/kernel/arrays.mal 
b/monetdb5/modules/kernel/arrays.mal
--- a/monetdb5/modules/kernel/arrays.mal
+++ b/monetdb5/modules/kernel/arrays.mal
@@ -14,6 +14,11 @@ address ALGdimensionSubselect1;
 command algebra.subselect(dims:ptr, dim:ptr, candDims:ptr, 
candBat:bat[:oid,:oid], low:any, high:any, li:bit, hi:bit, anti:bit) (:ptr, 
:bat[:oid, :oid])
 address ALGdimensionSubselect2;
 
+command algebra.thetasubselect(dims:ptr, dim:ptr, val:any_1, op:str) (:ptr, 
:bat[:oid,:oid])
+address ALGdimensionThetasubselect1;
+command algebra.thetasubselect(dims:ptr, dim:ptr, candDims:ptr, 
candBat:bat[:oid,:oid], val:any_1, op:str) (:ptr, :bat[:oid,:oid])
+address ALGdimensionThetasubselect2;
+
 command algebra.cellsProject(candDims:ptr, candBAT:bat[:oid,:oid]) 
:bat[:oid,:oid]
 address ALGproject;
  
diff --git a/sql/backends/monet5/rel_bin.c b/sql/backends/monet5/rel_bin.c
--- a/sql/backends/monet5/rel_bin.c
+++ b/sql/backends/monet5/rel_bin.c
@@ -1217,9 +1217,6 @@ rel2bin_basetable( mvc *sql, sql_rel *re
                t = c->t;
     dels = stmt_tid(sql->sa, t);
 
-//     if(isArray(t))
-//             list_append(l, stmt_cells(sql->sa, t));
-
        /* add aliases */
        assert(rel->exps);
        for( en = rel->exps->h; en; en = en->next ) {
@@ -2369,6 +2366,7 @@ topn_offset( sql_rel *rel )
        return NULL;
 }
 
+
 static stmt *
 rel2bin_project( mvc *sql, sql_rel *rel, list *refs, sql_rel *topn)
 {
@@ -2376,6 +2374,7 @@ rel2bin_project( mvc *sql, sql_rel *rel,
        node *en, *n;
        stmt *sub = NULL, *psub = NULL;
        stmt *l = NULL;
+       stmt *cells = NULL;
 
        if (topn) {
                sql_exp *le = topn_limit(topn);
@@ -2414,10 +2413,9 @@ rel2bin_project( mvc *sql, sql_rel *rel,
        pl = sa_list(sql->sa);
        if (sub)
                pl->expected_cnt = list_length(sub->op4.lval);
+               
        psub = stmt_list(sql->sa, pl);
-//     //if an array we need the cells
-//     if(((stmt*)sub->op4.lval->h->data)->type == st_cells)
-//             list_append(pl, ((stmt*)sub->op4.lval->h->data));       
+
        for( en = rel->exps->h; en; en = en->next ) {
                sql_exp *exp = en->data;
                stmt *s = exp_bin(sql, exp, sub, psub, NULL, NULL, NULL, NULL);
@@ -2426,6 +2424,8 @@ rel2bin_project( mvc *sql, sql_rel *rel,
                        assert(0);
                        return NULL;
                }
+               if(cells && s->type == st_join && (s->op1->type == st_uselect 
|| s->op1->type == st_uselect2))
+                       s->op1 = cells;
                /* single value with limit */
                if (topn && rel->r && sub && sub->nrcols == 0)
                        s = const_column(sql->sa, s);
@@ -2536,6 +2536,46 @@ rel2bin_predicate(mvc *sql)
        return const_column(sql->sa, stmt_bool(sql->sa, 1));
 }
 
+/*
+static stmt* find_before_uselect(stmt *s) {
+       stmt *us = NULL;
+       if(!s)
+               return NULL;
+       if(s->op1 && (s->op1->type == st_uselect || s->op1->type == 
st_uselect2))
+               return s;
+       if(s->op2 && (s->op2->type == st_uselect || s->op2->type == 
st_uselect2))
+               return s;
+       us = find_before_uselect(s->op1);
+       if(!us)
+               return find_before_uselect(s->op2);
+       return us;
+}
+*/
+static stmt* addCells(mvc *sql, stmt *s) {
+       //find where the selections over the dimensions start and put an 
st_cells
+       if((s->type == st_uselect || s->type == st_uselect2) && s->op1->type == 
st_dimension) {
+               s = stmt_cells(sql->sa, s);
+       } else if(s->op3)
+               return addCells(sql, s->op3);
+       return s;
+}
+/*
+static stmt *projectCells(mvc *sql, stmt* s) {
+       if(s->type == st_list) {
+               node *n;
+               for(n=s->op4.lval->h; n; n=n->next) {
+                       stmt *elStmt = (stmt*)n->data;
+                       //find the uselect (if there)
+                       stmt *us = find_before_uselect(elStmt);
+                       if(us->op1 && (us->op1->type == st_uselect || 
us->op1->type == st_uselect2))
+                               us->op1 = addCells(sql, us->op1);
+                       else if(us->op2 && (us->op2->type == st_uselect || 
us->op2->type == st_uselect2))
+                               us->op2 = addCells(sql, us->op2);
+               }
+       }
+       return s;
+}*/
+
 static stmt *
 rel2bin_select( mvc *sql, sql_rel *rel, list *refs)
 {
@@ -2590,9 +2630,13 @@ rel2bin_select( mvc *sql, sql_rel *rel, 
                        sel = stmt_uselect(sql->sa, s, stmt_bool(sql->sa, 1), 
cmp_equal, NULL);
                } else {
                        sel = s;
-               }
+               }       
        }
 
+       //if it is an array we need to roject the cells
+       sel = addCells(sql, sel);
+
+
        /* construct relation */
        l = sa_list(sql->sa);
        if (sub && sel) {
@@ -4684,6 +4728,28 @@ rel_bin(mvc *sql, sql_rel *rel)
        return s;
 }
 
+#if 0
+static stmt *array_output(mvc *sql, stmt* s) {
+       if(s->type == st_output) {
+               stmt *lStmt = s->op1;
+               if(lStmt->type == st_list) {
+                       node *n;
+                       for(n=lStmt->op4.lval->h; n; n=n->next) {
+                               stmt *elStmt = (stmt*)n->data;
+                               //find the uselect (if there)
+                               stmt *us = find_before_uselect(elStmt);
+                               if(us->op1 && (us->op1->type == st_uselect || 
us->op1->type == st_uselect2))
+                                       us->op1 = addCells(sql, us->op1);
+                               else if(us->op2 && (us->op2->type == st_uselect 
|| us->op2->type == st_uselect2))
+                                       us->op2 = addCells(sql, us->op2);
+                       }
+               }
+       }
+
+       return s;
+}
+#endif
+
 stmt *
 output_rel_bin(mvc *sql, sql_rel *rel ) 
 {
@@ -4694,7 +4760,9 @@ output_rel_bin(mvc *sql, sql_rel *rel )
        if (sqltype == Q_SCHEMA)
                sql->type = sqltype;  /* reset */
 
-       if (!is_ddl(rel->op) && s && s->type != st_none && sql->type == Q_TABLE)
+       if (!is_ddl(rel->op) && s && s->type != st_none && sql->type == 
Q_TABLE) {
                s = stmt_output(sql->sa, s);
+//             s = array_output(sql, s);
+       }
        return s;
 }
diff --git a/sql/backends/monet5/sql_gencode.c 
b/sql/backends/monet5/sql_gencode.c
--- a/sql/backends/monet5/sql_gencode.c
+++ b/sql/backends/monet5/sql_gencode.c
@@ -1429,103 +1429,104 @@ static int
                                }
 
                                switch (s->flag) {
-                               case cmp_equal:{
-                                       q = newStmt2(mb, algebraRef, cmd);
-                                       if(s->op1->type == st_dimension) {
-                                               char nme[SMALLBUFSIZ];
-                       int uval = -1;
-
-                       snprintf(nme, SMALLBUFSIZ, "Y_%d", l);
-                       uval = findVariable(mb, nme);
-                       assert(uval >= 0);
-
-                                               setVarType(mb, getArg(q, 0), 
TYPE_ptr);
-                                               setVarUDFtype(mb, getArg(q, 0));
-                                               q = pushReturn(mb, q, 
newTmpVariable(mb, newBatType(TYPE_oid, TYPE_oid)));
-                                               q = pushArgument(mb, q, l); 
//all the dimensions
-                                               q = pushArgument(mb, q, uval); 
//the current dimension
-
-                                               if(sub > 0) { //candidates
-                                                       snprintf(nme, 
SMALLBUFSIZ, "Y_%d", sub);
+                                       case cmp_equal:
+                                       case cmp_notequal: {
+                                               q = newStmt2(mb, algebraRef, 
cmd);
+                                               if(s->op1->type == 
st_dimension) {
+                                                       char nme[SMALLBUFSIZ];
+                               int uval = -1;
+
+                               snprintf(nme, SMALLBUFSIZ, "Y_%d", l);
+                               uval = findVariable(mb, nme);
+                               assert(uval >= 0);
+
+                                                       setVarType(mb, 
getArg(q, 0), TYPE_ptr);
+                                                       setVarUDFtype(mb, 
getArg(q, 0));
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, newBatType(TYPE_oid, TYPE_oid)));
+                                                       q = pushArgument(mb, q, 
l); //all the dimensions
+                                                       q = pushArgument(mb, q, 
uval); //the current dimension
+
+                                                       if(sub > 0) { 
//candidates
+                                                               snprintf(nme, 
SMALLBUFSIZ, "Y_%d", sub);
+                                       uval = findVariable(mb, nme);
+                                       assert(uval >= 0);
+
+                                                               q = 
pushArgument(mb, q, sub);
+                                                               q = 
pushArgument(mb, q, uval);
+                                                       }
+                                               } else {
+                                                       q = pushArgument(mb, q, 
l);
+
+                                                       if (sub > 0)
+                                                               q = 
pushArgument(mb, q, sub);
+                                               }
+                                               q = pushArgument(mb, q, r);
+                                               q = pushArgument(mb, q, r);
+                                               q = pushBit(mb, q, TRUE);
+                                               q = pushBit(mb, q, TRUE);
+                                       } break;
+                                       case cmp_lt:
+                                       case cmp_lte:
+                                       case cmp_gt:
+                                       case cmp_gte: {
+                                               q = newStmt2(mb, algebraRef, 
cmd);
+                                               if(s->op1->type == 
st_dimension) {
+                                                       char nme[SMALLBUFSIZ];
+                               int uval = -1;
+
+                               snprintf(nme, SMALLBUFSIZ, "Y_%d", l);
                                uval = findVariable(mb, nme);
                                assert(uval >= 0);
 
-                                                       q = pushArgument(mb, q, 
sub);
-                                                       q = pushArgument(mb, q, 
uval);
-                                               }
-                                       } else {
-                                               q = pushArgument(mb, q, l);
-
-                                               if (sub > 0)
-                                                       q = pushArgument(mb, q, 
sub);
-                                       }
-                                       q = pushArgument(mb, q, r);
-                                       q = pushArgument(mb, q, r);
-                                       q = pushBit(mb, q, TRUE);
-                                       q = pushBit(mb, q, TRUE);
-                                       q = pushBit(mb, q, FALSE);
-                                       
-                                       if (q == NULL)
-                                               return -1;
-                                       break;
+                                                       setVarType(mb, 
getArg(q, 0), TYPE_ptr);
+                                                       setVarUDFtype(mb, 
getArg(q, 0));
+                                                       q = pushReturn(mb, q, 
newTmpVariable(mb, newBatType(TYPE_oid, TYPE_oid)));
+                                                       q = pushArgument(mb, q, 
l); //all the dimensions
+                                                       q = pushArgument(mb, q, 
uval); //the current dimension
+
+                                                       if(sub > 0) { 
//candidates
+                                                               snprintf(nme, 
SMALLBUFSIZ, "Y_%d", sub);
+                                       uval = findVariable(mb, nme);
+                                       assert(uval >= 0);
+
+                                                               q = 
pushArgument(mb, q, sub);
+                                                               q = 
pushArgument(mb, q, uval);
+                                                       }
+                                               } else {
+                                                       q = pushArgument(mb, q, 
l);
+                                                       if (sub > 0)
+                                                               q = 
pushArgument(mb, q, sub);
+                                               }       
+                                               q = pushArgument(mb, q, r);
+                                       } break;
+                                       default:
+                                               showException(GDKout, SQL, 
"sql", "SQL2MAL: error impossible subselect compare\n");
                                }
-                               case cmp_notequal:{
-                                       q = newStmt2(mb, algebraRef, cmd);
-                                       q = pushArgument(mb, q, l);
-                                       if (sub > 0)
-                                               q = pushArgument(mb, q, sub);
-                                       q = pushArgument(mb, q, r);
-                                       q = pushArgument(mb, q, r);
-                                       q = pushBit(mb, q, TRUE);
-                                       q = pushBit(mb, q, TRUE);
-                                       q = pushBit(mb, q, TRUE);
-                                       if (q == NULL)
-                                               return -1;
-                                       break;
+
+                               switch(s->flag) { //set the last argument
+                                       case cmp_equal:
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to