LCOV - code coverage report
Current view: top level - sql/server - rel_select.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3740 4072 91.8 %
Date: 2024-11-14 20:04:02 Functions: 116 117 99.1 %

          Line data    Source code
       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : #include "monetdb_config.h"
      14             : #include "rel_select.h"
      15             : #include "sql_tokens.h"
      16             : #include "sql_privileges.h"
      17             : #include "sql_env.h"
      18             : #include "sql_decimal.h"
      19             : #include "sql_qc.h"
      20             : #include "rel_rel.h"
      21             : #include "rel_basetable.h"
      22             : #include "rel_exp.h"
      23             : #include "rel_xml.h"
      24             : #include "rel_dump.h"
      25             : #include "rel_prop.h"
      26             : #include "rel_psm.h"
      27             : #include "rel_schema.h"
      28             : #include "rel_unnest.h"
      29             : #include "rel_sequence.h"
      30             : #include "rel_file_loader.h"
      31             : 
      32             : #define VALUE_FUNC(f) (f->func->type == F_FUNC || f->func->type == F_FILT)
      33             : #define check_card(card,f) ((card == card_none && !f->res) || (CARD_VALUE(card) && f->res && VALUE_FUNC(f)) || card == card_loader || (card == card_relation && f->func->type == F_UNION))
      34             : 
      35             : /* return all expressions, with table name == tname */
      36             : static list *
      37       57039 : rel_table_projections( mvc *sql, sql_rel *rel, char *tname, int level )
      38             : {
      39       57552 :         list *exps;
      40             : 
      41       57552 :         if (mvc_highwater(sql))
      42           0 :                 return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
      43             : 
      44       57552 :         if (!rel)
      45             :                 return NULL;
      46             : 
      47       57552 :         if (!tname)
      48       41812 :                 return _rel_projections(sql, rel, NULL, 1, 0, 1);
      49             : 
      50       15740 :         switch(rel->op) {
      51         521 :         case op_join:
      52             :         case op_left:
      53             :         case op_right:
      54             :         case op_full:
      55         521 :                 exps = rel_table_projections( sql, rel->l, tname, level+1);
      56         521 :                 if (exps)
      57             :                         return exps;
      58          13 :                 return rel_table_projections( sql, rel->r, tname, level+1);
      59         500 :         case op_semi:
      60             :         case op_anti:
      61             :         case op_select:
      62         500 :                 return rel_table_projections( sql, rel->l, tname, level+1);
      63             : 
      64          54 :         case op_topn:
      65             :         case op_sample:
      66             :         case op_groupby:
      67             :         case op_union:
      68             :         case op_except:
      69             :         case op_inter:
      70             :         case op_project:
      71          54 :                 if (!is_processed(rel) && level == 0)
      72           0 :                         return rel_table_projections( sql, rel->l, tname, level+1);
      73             :                 /* fall through */
      74             :         case op_munion:
      75          60 :                 if (!is_processed(rel) && level == 0) {
      76           0 :                         node *n = ((list*)rel->l)->h;
      77           0 :                         if (n)
      78           0 :                                 return rel_table_projections(sql, n->data, tname, level+1);
      79             :                 }
      80             :         /* fall through */
      81             :         case op_table:
      82             :         case op_basetable:
      83       14719 :                 if (is_basetable(rel->op) && !rel->exps)
      84       14159 :                         return rel_base_project_all(sql, rel, tname);
      85         560 :                 if (rel->exps) {
      86         560 :                         int rename = 0;
      87         560 :                         node *en;
      88             : 
      89             :                         /* first check alias */
      90         560 :                         if (!is_base(rel->op) && !level) {
      91          54 :                                 list *exps = sa_list(sql->sa);
      92             : 
      93         409 :                                 for (en = rel->exps->h; en && !rename; en = en->next) {
      94         355 :                                         sql_exp *e = en->data;;
      95             : 
      96         355 :                                         if ((is_basecol(e) && exp_relname(e) && strcmp(exp_relname(e), tname) == 0) ||
      97         138 :                                             (is_basecol(e) && !exp_relname(e) && e->l && strcmp(e->l, tname) == 0)) {
      98         217 :                                                 if (exp_name(e) && exps_bind_column2(exps, tname, exp_name(e), NULL))
      99             :                                                         rename = 1;
     100             :                                                 else
     101         217 :                                                         append(exps, e);
     102             :                                         }
     103             :                                 }
     104             :                         }
     105             : 
     106         560 :                         exps = new_exp_list(sql->sa);
     107        4930 :                         for (en = rel->exps->h; en; en = en->next) {
     108        4370 :                                 sql_exp *e = en->data;
     109        4370 :                                 if (is_basecol(e) && exp_relname(e) && strcmp(exp_relname(e), tname) == 0) {
     110        4230 :                                         if (rename)
     111           0 :                                                 append(exps, exp_alias_ref(sql, e));
     112             :                                         else {
     113        4230 :                                                 sql_exp *ne = exp_ref(sql, e);
     114        4230 :                                                 exp_setname(sql, ne, tname, exp_name(e));
     115        4230 :                                                 append(exps, ne);
     116             :                                         }
     117             :                                 }
     118        4370 :                                 if (is_basecol(e) && !exp_relname(e) && e->l && strcmp(e->l, tname) == 0) {
     119           0 :                                         if (rename)
     120           0 :                                                 append(exps, exp_alias_ref(sql, e));
     121             :                                         else {
     122           0 :                                                 sql_exp *ne = exp_ref(sql, e);
     123           0 :                                                 exp_setname(sql, ne, tname, exp_name(e));
     124           0 :                                                 append(exps, ne);
     125             :                                         }
     126             :                                 }
     127             : 
     128             :                         }
     129         560 :                         if (exps && list_length(exps))
     130             :                                 return exps;
     131             :                 }
     132             :                 /* fall through */
     133             :         default:
     134             :                 return NULL;
     135             :         }
     136             : }
     137             : 
     138             : static sql_exp *
     139           0 : rel_lastexp(mvc *sql, sql_rel *rel )
     140             : {
     141           0 :         sql_exp *e;
     142             : 
     143           0 :         if (!is_processed(rel) || is_topn(rel->op) || is_sample(rel->op))
     144           0 :                 rel = rel_parent(rel);
     145           0 :         assert(list_length(rel->exps));
     146           0 :         if (rel->op == op_project) {
     147           0 :                 list_hash_clear(rel->exps);
     148           0 :                 return exp_ref(sql, rel->exps->t->data);
     149             :         }
     150           0 :         assert(is_project(rel->op));
     151           0 :         e = rel->exps->t->data;
     152           0 :         return exp_ref(sql, e);
     153             : }
     154             : 
     155             : static sql_rel *
     156       36639 : rel_orderby(mvc *sql, sql_rel *l)
     157             : {
     158       36639 :         sql_rel *rel = rel_create(sql->sa);
     159       36639 :         if (!rel)
     160             :                 return NULL;
     161             : 
     162       36639 :         assert(l->op == op_project && !l->r);
     163       36639 :         rel->l = l;
     164       36639 :         rel->r = NULL;
     165       36639 :         rel->op = op_project;
     166       36639 :         rel->exps = rel_projections(sql, l, NULL, 1, 0);
     167       36639 :         rel->card = l->card;
     168       36639 :         rel->nrcols = l->nrcols;
     169       36639 :         return rel;
     170             : }
     171             : 
     172             : /* forward refs */
     173             : static sql_rel * rel_setquery(sql_query *query, symbol *sq);
     174             : static sql_rel * rel_joinquery(sql_query *query, symbol *sq, list *refs);
     175             : 
     176             : static sql_rel *
     177      202504 : rel_table_optname(mvc *sql, sql_rel *sq, symbol *optname, list *refs)
     178             : {
     179      202504 :         sql_rel *osq = sq;
     180      202504 :         node *ne;
     181             : 
     182      202504 :         if (optname && optname->token == SQL_NAME) {
     183       17991 :                 dlist *columnrefs = NULL;
     184       17991 :                 char *tname = optname->data.lval->h->data.sval;
     185       17991 :                 list *l = sa_list(sql->sa);
     186             : 
     187       17991 :                 columnrefs = optname->data.lval->h->next->data.lval;
     188       17991 :                 if (is_topn(sq->op) || is_sample(sq->op) || ((is_simple_project(sq->op) || is_groupby(sq->op)) && sq->r) || is_base(sq->op)) {
     189         110 :                         sq = rel_project(sql->sa, sq, rel_projections(sql, sq, NULL, 1, 0));
     190         110 :                         osq = sq;
     191             :                 }
     192       17991 :                 if (columnrefs && dlist_length(columnrefs) != list_length(sq->exps))
     193           6 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: The number of aliases don't match the number of columns (%d != %d)", dlist_length(columnrefs), sq->nrcols);
     194        5030 :                 if (columnrefs && sq->exps) {
     195        5030 :                         dnode *d = columnrefs->h;
     196             : 
     197        5030 :                         ne = sq->exps->h;
     198        5030 :                         list_hash_clear(sq->exps);
     199       20760 :                         for (; d && ne; d = d->next, ne = ne->next) {
     200       10701 :                                 sql_exp *e = ne->data;
     201             : 
     202       10701 :                                 if (exps_bind_column2(l, tname, d->data.sval, NULL))
     203           1 :                                         return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: Duplicate column name '%s.%s'", tname, d->data.sval);
     204       10700 :                                 exp_setname(sql, e, tname, d->data.sval );
     205       10700 :                                 if (!is_intern(e))
     206       10700 :                                         set_basecol(e);
     207       10700 :                                 append(l, e);
     208             :                         }
     209             :                 }
     210       17984 :                 if (!columnrefs && sq->exps) {
     211       12955 :                         ne = sq->exps->h;
     212       12955 :                         list_hash_clear(sq->exps);
     213      126652 :                         for (; ne; ne = ne->next) {
     214      100742 :                                 sql_exp *e = ne->data;
     215      100742 :                                 char *name = NULL;
     216             : 
     217      100742 :                                 if (!is_intern(e)) {
     218      100742 :                                         if (!exp_name(e))
     219         108 :                                                 name = make_label(sql->sa, ++sql->label);
     220      100742 :                                         noninternexp_setname(sql, e, tname, name);
     221      100742 :                                         set_basecol(e);
     222             :                                 }
     223             :                         }
     224             :                 }
     225       17984 :                 if (refs) { /* if this relation is under a FROM clause, check for duplicate names */
     226       17934 :                         if (list_find(refs, tname, (fcmp) &strcmp))
     227           6 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: relation name \"%s\" specified more than once", tname);
     228       17928 :                         assert(tname);
     229       17928 :                         list_append(refs, tname);
     230             :                 }
     231             :         } else {
     232      184513 :                 if (!is_project(sq->op) || is_topn(sq->op) || is_sample(sq->op) || ((is_simple_project(sq->op) || is_groupby(sq->op)) && sq->r)) {
     233       58598 :                         sq = rel_project(sql->sa, sq, rel_projections(sql, sq, NULL, 1, 1));
     234       58598 :                         osq = sq;
     235             :                 }
     236     2320434 :                 for (ne = osq->exps->h; ne; ne = ne->next) {
     237     2135921 :                         sql_exp *e = ne->data;
     238             : 
     239     2135921 :                         if (!is_intern(e))
     240     2009343 :                                 set_basecol(e);
     241             :                 }
     242             :         }
     243             :         return osq;
     244             : }
     245             : 
     246             : static sql_rel *
     247       97537 : rel_subquery_optname(sql_query *query, symbol *ast, list *refs)
     248             : {
     249       97537 :         mvc *sql = query->sql;
     250       97537 :         SelectNode *sn = (SelectNode *) ast;
     251       97537 :         exp_kind ek = {type_value, card_relation, TRUE};
     252       97537 :         sql_rel *sq = rel_subquery(query, ast, ek);
     253             : 
     254       97537 :         assert(ast->token == SQL_SELECT);
     255       97537 :         if (!sq)
     256             :                 return NULL;
     257             : 
     258       97520 :         return rel_table_optname(sql, sq, sn->name, refs);
     259             : }
     260             : 
     261             : sql_rel *
     262        6933 : rel_with_query(sql_query *query, symbol *q )
     263             : {
     264        6933 :         mvc *sql = query->sql;
     265        6933 :         dnode *d = q->data.lval->h;
     266        6933 :         symbol *next = d->next->data.sym;
     267        6933 :         sql_rel *rel;
     268             : 
     269        6933 :         if (!stack_push_frame(sql, NULL))
     270           0 :                 return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
     271             :         /* first handle all with's (ie inlined views) */
     272       19667 :         for (d = d->data.lval->h; d; d = d->next) {
     273       12740 :                 symbol *sym = d->data.sym;
     274       12740 :                 dnode *dn = sym->data.lval->h;
     275       12740 :                 char *rname = qname_schema_object(dn->data.lval);
     276       12740 :                 sql_rel *nrel;
     277             : 
     278       12740 :                 if (frame_find_rel_view(sql, rname)) {
     279           1 :                         stack_pop_frame(sql);
     280           1 :                         return sql_error(sql, 01, SQLSTATE(42000) "View '%s' already declared", rname);
     281             :                 }
     282       12739 :                 nrel = rel_semantic(query, sym);
     283       12739 :                 if (!nrel) {
     284           5 :                         stack_pop_frame(sql);
     285           5 :                         return NULL;
     286             :                 }
     287       12734 :                 if (!stack_push_rel_view(sql, rname, nrel)) {
     288           0 :                         stack_pop_frame(sql);
     289           0 :                         return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
     290             :                 }
     291       12734 :                 if (!is_project(nrel->op)) {
     292           0 :                         if (is_topn(nrel->op) || is_sample(nrel->op)) {
     293           0 :                                 nrel = rel_project(sql->sa, nrel, rel_projections(sql, nrel, NULL, 1, 1));
     294             :                         } else {
     295           0 :                                 stack_pop_frame(sql);
     296           0 :                                 return NULL;
     297             :                         }
     298             :                 }
     299       12734 :                 assert(is_project(nrel->op));
     300       12734 :                 if (is_project(nrel->op) && nrel->exps) {
     301       12734 :                         node *ne = nrel->exps->h;
     302             : 
     303       56477 :                         for (; ne; ne = ne->next) {
     304       43743 :                                 sql_exp *e = ne->data;
     305       43743 :                                 char *name = NULL;
     306             : 
     307       43743 :                                 if (!is_intern(e)) {
     308       43743 :                                         if (!exp_name(e))
     309          13 :                                                 name = make_label(sql->sa, ++sql->label);
     310       43743 :                                         noninternexp_setname(sql, e, rname, name);
     311       43743 :                                         set_basecol(e);
     312             :                                 }
     313             :                         }
     314       12734 :                         list_hash_clear(nrel->exps);
     315             :                 }
     316             :         }
     317        6927 :         rel = rel_semantic(query, next);
     318        6927 :         stack_pop_frame(sql);
     319        6927 :         return rel;
     320             : }
     321             : 
     322             : static sql_rel *
     323       59657 : query_exp_optname(sql_query *query, symbol *q, list *refs)
     324             : {
     325       59657 :         mvc *sql = query->sql;
     326       59657 :         switch (q->token) {
     327         943 :         case SQL_WITH:
     328             :         {
     329         943 :                 sql_rel *tq = rel_with_query(query, q);
     330             : 
     331         943 :                 if (!tq)
     332             :                         return NULL;
     333         943 :                 if (q->data.lval->t->type == type_symbol)
     334         943 :                         return rel_table_optname(sql, tq, q->data.lval->t->data.sym, refs);
     335             :                 return tq;
     336             :         }
     337       58714 :         case SQL_JOIN:
     338             :         {
     339       58714 :                 sql_rel *tq = rel_joinquery(query, q, refs);
     340             : 
     341       58714 :                 if (!tq)
     342             :                         return NULL;
     343       58673 :                 return rel_table_optname(sql, tq, q->data.lval->t->data.sym, NULL);
     344             :         }
     345           0 :         default:
     346           0 :                 (void) sql_error(sql, 02, SQLSTATE(42000) "case %d %s", (int) q->token, token2string(q->token));
     347             :         }
     348           0 :         return NULL;
     349             : }
     350             : 
     351             : static sql_subfunc *
     352      113240 : bind_func_(mvc *sql, char *sname, char *fname, list *ops, sql_ftype type, bool private, bool *found, bool exact)
     353             : {
     354      113240 :         sql_subfunc *sf = NULL;
     355             : 
     356      113465 :         if (sql->forward && strcmp(fname, sql->forward->base.name) == 0 &&
     357         225 :             list_cmp(sql->forward->ops, ops, (fcmp)&arg_subtype_cmp) == 0 &&
     358           0 :             execute_priv(sql, sql->forward) && type == sql->forward->type)
     359           0 :                 return sql_dup_subfunc(sql->sa, sql->forward, NULL, NULL);
     360      113240 :         sf = sql_bind_func_(sql, sname, fname, ops, type, private, exact);
     361      113240 :         if (found)
     362      112710 :                 *found |= sf != NULL;
     363      113240 :         if (sf && execute_priv(sql, sf->func))
     364             :                 return sf;
     365             :         return NULL;
     366             : }
     367             : 
     368             : static sql_subfunc *
     369      617176 : bind_func(mvc *sql, char *sname, char *fname, sql_subtype *t1, sql_subtype *t2, int nr, sql_ftype type, bool private, bool *found, bool exact)
     370             : {
     371      617176 :         list *tl = sa_list(sql->sa);
     372      617176 :         assert(nr >= 1 && nr <= 2);
     373      617176 :         append(tl, t1);
     374      617176 :         if (nr == 2)
     375      522627 :                 append(tl, t2);
     376      617176 :         sql_subfunc *sf = NULL;
     377             : 
     378      617176 :         if (sql->forward) {
     379      131598 :                 if (execute_priv(sql, sql->forward) &&
     380      131598 :                     strcmp(fname, sql->forward->base.name) == 0 &&
     381         230 :                    ((!t1 && list_length(sql->forward->ops) == 0) ||
     382         232 :                     (!t2 && list_length(sql->forward->ops) == 1 && arg_subtype_cmp(sql->forward->ops->h->data, t1) == 0) ||
     383         228 :                     (list_length(sql->forward->ops) == 2 &&
     384           0 :                         arg_subtype_cmp(sql->forward->ops->h->data, t1) == 0 &&
     385           2 :                         arg_subtype_cmp(sql->forward->ops->h->next->data, t2) == 0)) && type == sql->forward->type) {
     386           2 :                         return sql_dup_subfunc(sql->sa, sql->forward, NULL, NULL);
     387             :                 }
     388             :         }
     389      617174 :         sf = sql_bind_func_(sql, sname, fname, tl, type, private, exact);
     390      617174 :         if (found)
     391      617174 :                 *found |= sf != NULL;
     392      617174 :         if (sf && execute_priv(sql, sf->func))
     393             :                 return sf;
     394             :         return NULL;
     395             : }
     396             : 
     397             : static sql_subfunc *
     398      636547 : find_func(mvc *sql, char *sname, char *fname, int len, sql_ftype type, bool private, sql_subfunc *prev, bool *found)
     399             : {
     400      636547 :         sql_subfunc *sf = NULL;
     401             : 
     402      636547 :         if (sql->forward && strcmp(fname, sql->forward->base.name) == 0 && list_length(sql->forward->ops) == len && execute_priv(sql, sql->forward) && type == sql->forward->type)
     403           0 :                 return sql_dup_subfunc(sql->sa, sql->forward, NULL, NULL);
     404      636547 :         sf = sql_find_func(sql, sname, fname, len, type, private, prev);
     405      636547 :         if (found)
     406           0 :                 *found |= sf != NULL;
     407      636547 :         if (sf && execute_priv(sql, sf->func))
     408             :                 return sf;
     409             :         return NULL;
     410             : }
     411             : 
     412             : static sql_exp *
     413      694575 : exp_fix_scale(mvc *sql, sql_subtype *ct, sql_exp *e)
     414             : {
     415      694575 :         sql_subtype *et = exp_subtype(e);
     416             : 
     417      694575 :         if (ct->type->scale == SCALE_FIX && et->type->scale == SCALE_FIX) {
     418       82854 :                 int scale_diff = ((int) ct->scale - (int) et->scale);
     419             : 
     420       82854 :                 if (scale_diff) {
     421         132 :                         if (scale_diff < 0)
     422             :                                 return e;
     423         102 :                         sql_subtype st;
     424         102 :                         int scale = ct->scale;
     425         102 :                         int digits = ((et->type->eclass == EC_NUM)?bits2digits(et->digits):et->digits)-et->scale+scale;
     426         102 :                         (void)sql_find_subtype(&st, ct->type->base.name, digits, scale);
     427         102 :                         return exp_convert(sql, e, et, &st);
     428             :                 }
     429             :         }
     430             :         return e;
     431             : }
     432             : 
     433             : static lng
     434        9649 : rel_get_count(sql_rel *rel)
     435             : {
     436       31093 :         if (!rel)
     437             :                 return 0;
     438       31089 :         prop *p = NULL;
     439       31089 :         if (rel->p && (p = find_prop(rel->p, PROP_COUNT)) != NULL)
     440        3041 :                 return p->value.lval;
     441       28048 :         else if(is_munion(rel->op)) {
     442         168 :                 lng cnt = 0;
     443         168 :                 list *l = rel->l;
     444         504 :                 for (node *n = l->h; n; n = n->next) {
     445         336 :                         lng lcnt = rel_get_count(n->data);
     446         336 :                         if (lcnt == BUN_MAX)
     447             :                                 return BUN_MAX;
     448         336 :                         cnt += lcnt;
     449             :                 }
     450         168 :                 return cnt;
     451       27880 :         } else if(rel->l) {
     452       25209 :                 if (is_select(rel->op) || is_project(rel->op))
     453             :                         return rel_get_count(rel->l);
     454             :         }
     455             :         return 0;
     456             : }
     457             : 
     458             : #define is_sum_aggr(f) (f->type == F_AGGR && strcmp(f->base.name, "sum") == 0)
     459             : 
     460             : list *
     461      737858 : check_arguments_and_find_largest_any_type(mvc *sql, sql_rel *rel, list *exps, sql_subfunc *sf, int maybe_zero_or_one, bool internal)
     462             : {
     463      737858 :         list *nexps = new_exp_list(sql->sa);
     464      737858 :         sql_subtype *atp = NULL, super, *res = !list_empty(sf->res) ? sf->res->h->data: NULL;
     465      737858 :         unsigned int digits = 0, scale = 0;
     466             : 
     467             :         /* find largest any type argument */
     468     2178460 :         for (node *n = exps->h, *m = sf->func->ops->h; n && m; n = n->next, m = m->next) {
     469     1440602 :                 sql_arg *a = m->data;
     470     1440602 :                 sql_exp *e = n->data;
     471     1440602 :                 sql_subtype *t = exp_subtype(e);
     472             : 
     473     1440602 :                 if (a->type.type->eclass == EC_ANY) {
     474      265520 :                         if (t && atp) {
     475      114498 :                                 supertype(&super, t, atp);
     476      114498 :                                 atp = &super;
     477      151022 :                         } else if (t) {
     478             :                                 atp = t;
     479             :                         }
     480             :                 }
     481     1440599 :                 if (t && sf->func->fix_scale == SCALE_FIX && t->type->eclass == EC_DEC) {
     482        1264 :                         if (digits < t->digits)
     483             :                                 digits = t->digits;
     484        1264 :                         if (scale < t->scale)
     485             :                                 scale = t->scale;
     486             :                 }
     487             :         }
     488      737858 :         if (!atp && !list_empty(exps))
     489      586837 :                 atp = exp_subtype(exps->h->data);
     490             : 
     491      737858 :         if ((atp && atp->type->localtype == TYPE_void) || !atp) /* NULL */
     492        9418 :                 atp = sql_bind_localtype("str");
     493             : 
     494      737858 :         node *n, *m;
     495     2178460 :         for (n = exps->h, m = sf->func->ops->h; n && m; n = n->next, m = m->next) {
     496     1440602 :                 sql_arg *a = m->data;
     497     1440602 :                 sql_exp *e = n->data;
     498     1440602 :                 sql_subtype *ntp = &a->type, *t = exp_subtype(e);
     499             : 
     500     1440602 :                 if (!t) {
     501          38 :                         if (a->type.type->eclass == EC_ANY && atp)
     502           3 :                                 ntp = sql_create_subtype(sql->sa, atp->type, atp->digits, atp->scale);
     503          61 :                         rel_set_type_param(sql, ntp, rel, e, sf->func->fix_scale != INOUT && !UDF_LANG(sf->func->lang));
     504     1440564 :                 } else if (a->type.type->eclass == EC_ANY && atp) {
     505      265517 :                         ntp = sql_create_subtype(sql->sa, atp->type, atp->digits, atp->scale);
     506     1175047 :                 } else if (t && ntp->digits == 0 && EC_VARCHAR(a->type.type->eclass)) {
     507      510889 :                         ntp = sql_create_subtype(sql->sa, a->type.type, type_digits_to_char_digits(t), 0);
     508      664158 :                 } else if (t && ntp->digits > 0 && a->type.type->eclass == EC_NUM && t->type->eclass == EC_NUM) {
     509      359239 :                         ntp = sql_create_subtype(sql->sa, a->type.type, t->digits, 0);
     510      304919 :                 } else if (t && ntp->scale == 0 && ntp->type->eclass == EC_DEC && EC_VARCHAR(t->type->eclass)) {
     511           0 :                         sql_subtype *res = SA_NEW(sql->sa, sql_subtype);
     512           0 :                         int digits = t->digits?t->digits+3:ntp->digits;
     513           0 :                         (void)sql_find_subtype(res, a->type.type->base.name, digits, 3);
     514           0 :                         ntp = res;
     515      304919 :                 } else if (t && ntp->scale == 0 && ntp->type->eclass == EC_DEC) {
     516        4869 :                         ntp = sql_create_subtype(sql->sa, a->type.type, t->type->eclass == EC_NUM?bits2digits(t->digits):t->digits, t->scale);
     517      300050 :                 } else if (t->type == ntp->type) {
     518      297952 :                         ntp = t;
     519             :                 }
     520     1440602 :                 if (!(e = exp_check_type(sql, ntp, rel, e, type_equal)))
     521             :                         return NULL;
     522     1440602 :                 if (sf->func->fix_scale == SCALE_FIX) {
     523      523340 :                         ntp = sql_create_subtype(sql->sa, a->type.type->localtype?a->type.type:t?t->type:atp->type, digits, scale);
     524      523340 :                         e = exp_fix_scale(sql, ntp, e);
     525      917262 :                 } else if (sf->func->fix_scale == SCALE_EQ) {
     526      171235 :                         e = exp_fix_scale(sql, &a->type, e);
     527             :                 }
     528     1440602 :                 if (maybe_zero_or_one && e->card > CARD_ATOM) {
     529          22 :                         sql_subfunc *zero_or_one = sql_bind_func(sql, "sys", "zero_or_one", exp_subtype(e), NULL, F_AGGR, true, false);
     530          22 :                         e = exp_aggr1(sql->sa, e, zero_or_one, 0, 0, CARD_ATOM, has_nil(e));
     531             :                 }
     532     1440602 :                 append(nexps, e);
     533             :         }
     534             :         /* handle any extra arguments for rel_dump/analytic funcs */
     535      738077 :         for ( ; n; n = n->next)
     536         219 :                 append(nexps, n->data);
     537      737858 :         if (sf->func->fix_scale == SCALE_FIX || IS_ANALYTIC(sf->func)) {
     538      270489 :                 exps_scale_fix(sf, nexps, atp);
     539      467369 :         } else if (sf->func->fix_scale == MAX_BITS) {
     540      111651 :                 exps_max_bits(sf, nexps);
     541      355718 :         } else if (sf->func->fix_scale == SCALE_MUL) {
     542       25185 :                 exps_sum_scales(sf, nexps);
     543      330533 :         } else if (!internal && sf->func->fix_scale == SCALE_DIV) {
     544        2604 :                 if (!exps_scale_algebra(sql, sf, rel, nexps))
     545             :                         return NULL;
     546      327929 :         } else if (sf->func->fix_scale == DIGITS_ADD) {
     547      181313 :                 exps_digits_add(sf, nexps);
     548      146616 :         } else if (sf->func->fix_scale == INOUT) {
     549       19015 :                 exps_inout(sf, nexps);
     550      127601 :         } else if (is_sum_aggr(sf->func))
     551        9313 :                 exps_largest_int(sf, nexps, rel_get_count(rel));
     552             : 
     553             :         /* dirty hack */
     554      737856 :         if (sf->func->type != F_PROC && sf->func->type != F_UNION && sf->func->type != F_LOADER && res) {
     555      733188 :                 if (res->type->eclass == EC_ANY && atp)
     556          73 :                         sf->res->h->data = sql_create_subtype(sql->sa, atp->type, atp->digits, atp->scale);
     557             :         }
     558             :         return nexps;
     559             : }
     560             : 
     561             : static char *
     562          32 : nary_function_arg_types_2str(mvc *sql, list* types, int N)
     563             : {
     564          32 :         char *arg_list = NULL;
     565          32 :         int i = 0;
     566             : 
     567         116 :         for (node *n = types->h; n && i < N; n = n->next) {
     568          84 :                 sql_subtype *t = (sql_subtype *) n->data;
     569          84 :                 char *tpe = t ? sql_subtype_string(sql->ta, t) : "?";
     570             : 
     571          84 :                 if (arg_list) {
     572          52 :                         arg_list = sa_message(sql->ta, "%s, %s", arg_list, tpe);
     573             :                 } else {
     574             :                         arg_list = tpe;
     575             :                 }
     576          84 :                 i++;
     577             :         }
     578          32 :         return arg_list;
     579             : }
     580             : 
     581             : static char *
     582          33 : file_loader_add_table_column_types(mvc *sql, sql_subfunc *f, list *exps, list *res_exps, char *tname)
     583             : {
     584          33 :         sql_exp *file = exps->h->data;
     585          33 :         if (!exp_is_atom(file))
     586             :                 return "Filename missing";
     587             : 
     588          33 :         atom *a = file->l;
     589          33 :         if (a->data.vtype != TYPE_str || !a->data.val.sval)
     590             :                 return "Filename missing";
     591             : 
     592          33 :         char *filename = a->data.val.sval;
     593          33 :         if (strcmp(filename, "") == 0)
     594             :                 return "Filename missing";
     595             : 
     596          31 :         char *ext = strrchr(filename, '.'), *ep = ext;
     597             : 
     598          31 :         if (ext) {
     599          28 :                 ext = ext + 1;
     600          28 :                 ext = mkLower(sa_strdup(sql->sa, ext));
     601             :         }
     602          28 :         if (!ext)
     603           3 :                 return "Filename extension missing";
     604             : 
     605          28 :         file_loader_t *fl = fl_find(ext);
     606          28 :         if (!fl) {
     607             :                 /* maybe compressed */
     608          10 :                 char *p = ep - 1;
     609          66 :                 while (p > filename && *p != '.')
     610          56 :                         p--;
     611          10 :                 if (p != filename) {
     612           8 :                         ext = p + 1;
     613           8 :                         ext = sa_strdup(sql->sa, ext);
     614           8 :                         char *d = strchr(ext, '.');
     615           8 :                         assert(d);
     616           8 :                         *d = 0;
     617           8 :                         fl = fl_find(ext);
     618             :                 }
     619          10 :                 if (!fl) /* fallback */
     620           2 :                         fl = fl_find("csv");
     621           2 :                 if (!fl) /* not expected */
     622           0 :                         return sa_message(sql->ta, "Filename extension '%s' missing", ext?ext:"");
     623             :         }
     624          28 :         str err = fl->add_types(sql, f, filename, res_exps, tname);
     625          28 :         if (err)
     626             :                 return err;
     627          14 :         sql_subtype *st = sql_bind_localtype("str");
     628          14 :         sql_exp *ext_exp = exp_atom(sql->sa, atom_string(sql->sa, st, ext));
     629          14 :         if (!ext_exp)
     630             :                 return MAL_MALLOC_FAIL;
     631          14 :         append(exps, ext_exp);
     632          14 :         return NULL;
     633             : }
     634             : 
     635             : static sql_rel *
     636          33 : rel_file_loader(mvc *sql, list *exps, list *tl, char *tname)
     637             : {
     638          33 :         sql_subfunc *f = NULL;
     639          33 :         bool found = false;
     640             : 
     641          33 :         if ((f = bind_func_(sql, NULL, "file_loader", tl, F_UNION, true, &found, false))) {
     642          33 :                 list *nexps = exps;
     643          33 :                 if (list_empty(tl) || f->func->vararg || (nexps = check_arguments_and_find_largest_any_type(sql, NULL, exps, f, 1, false))) {
     644          33 :                         list *res_exps = sa_list(sql->sa);
     645          33 :                         if (list_length(exps) == 1 && f && f->func->varres && strlen(f->func->mod) == 0 && strlen(f->func->imp) == 0) {
     646          33 :                                 char *err = file_loader_add_table_column_types(sql, f, nexps, res_exps, tname);
     647          33 :                                 if (err)
     648          19 :                                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: file_loader function failed '%s'", err);
     649             :                         }
     650          14 :                         sql_exp *e = exp_op(sql->sa, nexps, f);
     651          14 :                         sql_rel *rel = rel_table_func(sql->sa, NULL, e, res_exps, TABLE_PROD_FUNC);
     652          14 :                         if (rel)
     653          14 :                                 rel = rel_project(sql->sa, rel, exps_alias(sql, res_exps));
     654          14 :                         return rel;
     655             :                 }
     656             :         }
     657             :         return NULL;
     658             : }
     659             : 
     660             : sql_exp *
     661       10743 : find_table_function(mvc *sql, char *sname, char *fname, list *exps, list *tl, sql_ftype type)
     662             : {
     663       10743 :         bool found = false;
     664       10743 :         sql_subfunc *f = NULL;
     665             : 
     666       10743 :         assert(type == F_UNION || type == F_LOADER);
     667       10743 :         if ((f = bind_func_(sql, sname, fname, tl, type, false, &found, false))) {
     668       10723 :                 list *nexps = exps;
     669       10723 :                 if (list_empty(tl) || f->func->vararg || (nexps = check_arguments_and_find_largest_any_type(sql, NULL, exps, f, 1, false)))
     670       10723 :                         return exp_op(sql->sa, nexps, f);
     671           0 :                 found = false;
     672             :         }
     673          20 :         char *arg_list = list_length(tl) ? nary_function_arg_types_2str(sql, tl, list_length(tl)) : NULL;
     674          55 :         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s %s function %s%s%s'%s'(%s)",
     675          20 :                                          found ? "insufficient privileges for" : "no such", type == F_UNION ? "table returning" : "loader", sname ? "'":"", sname ? sname : "",
     676             :                                          sname ? "'.":"", fname, arg_list ? arg_list : "");
     677             : }
     678             : 
     679             : static sql_rel *
     680       10757 : rel_named_table_function(sql_query *query, sql_rel *rel, symbol *ast, int lateral, list *refs)
     681             : {
     682       10757 :         mvc *sql = query->sql;
     683       10757 :         list *exps = NULL, *tl;
     684       10757 :         node *m;
     685       10757 :         exp_kind ek = {type_value, card_relation, TRUE};
     686       10757 :         sql_rel *sq = NULL, *outer = NULL;
     687       10757 :         sql_exp *e = NULL;
     688       10757 :         sql_subfunc *sf = NULL;
     689       10757 :         symbol *sym = ast->data.lval->h->data.sym, *subquery = NULL;
     690       10757 :         dnode *l = sym->data.lval->h, *n;
     691       10757 :         char *tname = NULL;
     692       10757 :         char *fname = qname_schema_object(l->data.lval);
     693       10757 :         char *sname = qname_schema(l->data.lval);
     694             : 
     695       10757 :         tl = sa_list(sql->sa);
     696       10757 :         exps = sa_list(sql->sa);
     697       10757 :         if (l->next)
     698       10757 :                 l = l->next; /* skip distinct */
     699       10757 :         if (l->next) { /* table call with subquery */
     700        1032 :                 int is_value = 1;
     701        1032 :                 if (l->next->type == type_symbol || l->next->type == type_list) {
     702        1032 :                         exp_kind iek = {type_value, card_set, TRUE};
     703        1032 :                         int count = 0;
     704             : 
     705        1032 :                         if (l->next->type == type_symbol)
     706             :                                 n = l->next;
     707             :                         else
     708         673 :                                 n = l->next->data.lval->h;
     709             : 
     710        3663 :                         for (dnode *m = n; m; m = m->next) {
     711        2631 :                                 if (m->type == type_symbol && m->data.sym->token == SQL_SELECT)
     712        2631 :                                         subquery = m->data.sym;
     713        2631 :                                 count++;
     714             :                         }
     715        1032 :                         if (subquery && count > 1)
     716          17 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: The input for the table returning function %s%s%s'%s' must be either a single sub query, or a list of values",
     717             :                                                                  sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
     718             : 
     719        1027 :                         if (subquery) {
     720          40 :                                 if (!(sq = rel_subquery(query, subquery, ek)))
     721             :                                         return NULL;
     722             :                                 is_value = 0;
     723             :                         } else {
     724        3557 :                                 for ( ; n; n = n->next) {
     725        2576 :                                         sql_exp *e = rel_value_exp(query, &outer, n->data.sym, sql_sel | sql_from, iek);
     726             : 
     727        2576 :                                         if (!e)
     728             :                                                 return NULL;
     729        2570 :                                         append(exps, e);
     730        2570 :                                         is_value &= exp_is_atom(e);
     731             :                                 }
     732         981 :                                 if (!is_value || (lateral && outer))
     733          14 :                                         sq = rel_project(sql->sa, NULL, exps);
     734          14 :                                 if (lateral && outer) {
     735           0 :                                         sq = rel_crossproduct(sql->sa, sq, outer, op_join);
     736           0 :                                         set_dependent(sq);
     737           0 :                                         set_processed(sq);
     738             :                                 }
     739             :                         }
     740             :                 }
     741        1020 :                 if (!is_value && (!sq || (!lateral && outer)))
     742           0 :                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: no such table returning function %s%s%s'%s'", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
     743        1020 :                 if (!is_value) {
     744          53 :                         if (list_length(exps))
     745          14 :                                 exps = sa_list(sql->sa);
     746         171 :                         for (node *en = sq->exps->h; en; en = en->next) {
     747         118 :                                 sql_exp *e = en->data;
     748             : 
     749         118 :                                 if (!e->alias.label)
     750          28 :                                         exp_label(sql->sa, e, ++sql->label);
     751         118 :                                 sql_exp *ne = exp_ref(sql, e);
     752             :                                 /* allow for table functions with table input */
     753         118 :                                 ne->card = CARD_ATOM;
     754         118 :                                 exp_setname(sql, ne, tname, exp_name(e));
     755         118 :                                 append(exps, ne);
     756         118 :                                 append(tl, exp_subtype(e));
     757             :                         }
     758             :                 } else {
     759        3512 :                         for (node *en = exps->h; en; en = en->next)
     760        2545 :                                 append(tl, exp_subtype(en->data));
     761             :                 }
     762             :         }
     763             : 
     764       10745 :         rel = NULL;
     765       10745 :         if (ast->data.lval->t->type == type_symbol && ast->data.lval->t->data.sym)
     766        1191 :                 tname = ast->data.lval->t->data.sym->data.lval->h->data.sval;
     767             :         else
     768        9554 :                 tname = make_label(sql->sa, ++sql->label);
     769             : 
     770       10745 :         if (!sname && strcmp(fname, "file_loader") == 0) {
     771          33 :                 rel = rel_file_loader(sql, exps, tl, tname);
     772          33 :                 if (!rel)
     773             :                         return NULL;
     774       20437 :         } else if (!(e = find_table_function(sql, sname, fname, list_empty(exps) ? NULL : exps, tl, F_UNION)))
     775             :                 return NULL;
     776             : 
     777       10693 :         if (!rel) {
     778       10693 :                 rel = sq;
     779             : 
     780             :                 /* column or table function */
     781       10693 :                 sf = e->f;
     782       10693 :                 if (e->type != e_func || sf->func->type != F_UNION)
     783           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: '%s' does not return a table", exp_func_name(e));
     784             : 
     785       10693 :                 if (sq) {
     786         171 :                         for (node *n = sq->exps->h, *m = sf->func->ops->h ; n && m ; n = n->next, m = m->next) {
     787         118 :                                 sql_exp *e = (sql_exp*) n->data;
     788         118 :                                 sql_arg *a = (sql_arg*) m->data;
     789         118 :                                 if (!exp_subtype(e) && rel_set_type_param(sql, &(a->type), sq, e, 0) < 0)
     790             :                                         return NULL;
     791             :                         }
     792             :                 }
     793             : 
     794             :                 /* for each column add table.column name */
     795       10693 :                 exps = new_exp_list(sql->sa);
     796      105730 :                 for (m = sf->func->res->h; m; m = m->next) {
     797       95037 :                         sql_arg *a = m->data;
     798       95037 :                         sql_exp *e = exp_column(sql->sa, tname, a->name, &a->type, CARD_MULTI, 1, 0, 0);
     799       95037 :                         e->alias.label = -(sql->nid++);
     800             : 
     801       95037 :                         set_basecol(e);
     802       95037 :                         append(exps, e);
     803             :                 }
     804       21333 :                 rel = rel_table_func(sql->sa, rel, e, exps, (sq)?TABLE_FROM_RELATION:TABLE_PROD_FUNC);
     805             :         }
     806       10707 :         if (ast->data.lval->t->type == type_symbol && ast->data.lval->t->data.sym && ast->data.lval->t->data.sym->data.lval->h->next->data.lval) {
     807          25 :                 rel = rel_table_optname(sql, rel, ast->data.lval->t->data.sym, refs);
     808       10682 :         } else if (refs) { /* if this relation is under a FROM clause, check for duplicate names */
     809       10682 :                 if (list_find(refs, tname, (fcmp) &strcmp))
     810           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: relation name \"%s\" specified more than once", tname);
     811       10682 :                 list_append(refs, tname);
     812             :         }
     813             :         return rel;
     814             : }
     815             : 
     816             : static sql_exp *
     817        1827 : rel_op_(mvc *sql, char *sname, char *fname, exp_kind ek)
     818             : {
     819        1827 :         bool found = false;
     820        1827 :         sql_subfunc *f = NULL;
     821        1827 :         sql_ftype type = (ek.card == card_loader)?F_LOADER:((ek.card == card_none)?F_PROC:
     822             :                    ((ek.card == card_relation)?F_UNION:F_FUNC));
     823             : 
     824        1827 :         if ((f = bind_func_(sql, sname, fname, NULL, type, false, &found, true))) {
     825        1811 :                 if (check_card(ek.card, f))
     826        1811 :                         return exp_op(sql->sa, NULL, f);
     827           0 :                 found = false;
     828             :         }
     829          32 :         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s operator %s%s%s'%s'()",
     830          16 :                                          found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
     831             : }
     832             : 
     833             : static sql_exp*
     834        4100 : exp_tuples_set_supertype(mvc *sql, list *tuple_values, sql_exp *tuples)
     835             : {
     836        4100 :         assert(is_values(tuples));
     837        4100 :         list *vals = exp_get_values(tuples);
     838        4100 :         if (!vals || !vals->h)
     839             :                 return NULL;
     840             : 
     841        4100 :         int tuple_width = list_length(tuple_values), i;
     842        4100 :         sql_subtype *types = SA_NEW_ARRAY(sql->sa, sql_subtype, tuple_width);
     843        4100 :         bool *has_type = SA_NEW_ARRAY(sql->sa, bool, tuple_width);
     844        4100 :         node *n;
     845             : 
     846        4100 :         memset(has_type, 0, sizeof(bool)*tuple_width);
     847       13345 :         for(n = tuple_values->h, i = 0; n; n = n->next, i++) {
     848        9245 :                 sql_exp *e = n->data;
     849        9245 :                 if (exp_subtype(e)) {
     850        9243 :                         types[i] = *exp_subtype(e);
     851        9243 :                         has_type[i] = 1;
     852             :                 }
     853             :         }
     854             : 
     855        8202 :         for (node *m = vals->h; m; m = m->next) {
     856        4102 :                 sql_exp *tuple = m->data;
     857        4102 :                 if (is_values(tuple)) {
     858           3 :                         list *exps = tuple->f;
     859           9 :                         for(n = exps->h, i = 0; n; n = n->next, i++) {
     860           6 :                                 sql_subtype *tpe;
     861           6 :                                 sql_exp *e = n->data;
     862             : 
     863           6 :                                 if (has_type[i] && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
     864           0 :                                         if (set_type_param(sql, types+i, e->flag) == 0)
     865           0 :                                                 e->tpe = types[i];
     866             :                                         else
     867             :                                                 return NULL;
     868             :                                 }
     869           6 :                                 tpe = exp_subtype(e);
     870           6 :                                 if (!tpe)
     871             :                                         return NULL;
     872           6 :                                 if (has_type[i] && tpe) {
     873           6 :                                         supertype(types+i, types+i, tpe);
     874             :                                 } else {
     875           0 :                                         has_type[i] = 1;
     876           0 :                                         types[i] = *tpe;
     877             :                                 }
     878             :                         }
     879             :                 } else {
     880        4099 :                         sql_rel *tuple_relation = exp_rel_get_rel(sql->sa, tuple);
     881             : 
     882       13342 :                         for(n = tuple_relation->exps->h, i = 0; n; n = n->next, i++) {
     883        9243 :                                 sql_subtype *tpe;
     884        9243 :                                 sql_exp *e = n->data;
     885             : 
     886        9243 :                                 if (has_type[i] && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
     887           5 :                                         if (set_type_param(sql, types+i, e->flag) == 0)
     888           5 :                                                 e->tpe = types[i];
     889             :                                         else
     890             :                                                 return NULL;
     891             :                                 }
     892        9243 :                                 tpe = exp_subtype(e);
     893        9243 :                                 if (!tpe)
     894             :                                         return NULL;
     895        9243 :                                 if (has_type[i] && tpe) {
     896        9241 :                                         cmp_supertype(types+i, types+i, tpe);
     897             :                                 } else {
     898           2 :                                         has_type[i] = 1;
     899           2 :                                         types[i] = *tpe;
     900             :                                 }
     901             :                         }
     902             :                 }
     903             :         }
     904             : 
     905        8202 :         for (node *m = vals->h; m; m = m->next) {
     906        4102 :                 sql_exp *tuple = m->data;
     907        4102 :                 if (is_values(tuple)) {
     908           3 :                         list *exps = tuple->f;
     909           3 :                         list *nexps = sa_list(sql->sa);
     910           9 :                         for(n = exps->h, i = 0; n; n = n->next, i++) {
     911           6 :                                 sql_exp *e = n->data;
     912             : 
     913           6 :                                 e = exp_check_type(sql, types+i, NULL, e, type_equal);
     914           6 :                                 if (!e)
     915             :                                         return NULL;
     916           6 :                                 exp_label(sql->sa, e, ++sql->label);
     917           6 :                                 append(nexps, e);
     918             :                         }
     919           3 :                         tuple->f = nexps;
     920             :                 } else {
     921        4099 :                         sql_rel *tuple_relation = exp_rel_get_rel(sql->sa, tuple);
     922             : 
     923        4099 :                         list *nexps = sa_list(sql->sa);
     924       13342 :                         for(n = tuple_relation->exps->h, i = 0; n; n = n->next, i++) {
     925        9243 :                                 sql_exp *e = n->data;
     926             : 
     927        9243 :                                 e = exp_check_type(sql, types+i, NULL, e, type_equal);
     928        9243 :                                 if (!e)
     929             :                                         return NULL;
     930        9243 :                                 append(nexps, e);
     931             :                         }
     932        4099 :                         tuple_relation->exps = nexps;
     933             :                 }
     934             :         }
     935             :         return tuples;
     936             : }
     937             : 
     938             : static int
     939        9245 : rel_binop_check_types(mvc *sql, sql_rel *rel, sql_exp *ls, sql_exp *rs, int upcast)
     940             : {
     941        9245 :         sql_subtype *t1 = exp_subtype(ls), *t2 = exp_subtype(rs);
     942             : 
     943        9245 :         if (!t1 || !t2) {
     944           2 :                 if (t2 && !t1 && rel_set_type_param(sql, t2, rel, ls, upcast) < 0)
     945             :                         return -1;
     946           2 :                 if (t1 && !t2 && rel_set_type_param(sql, t1, rel, rs, upcast) < 0)
     947             :                         return -1;
     948             :         }
     949        9245 :         if (!exp_subtype(ls) && !exp_subtype(rs)) {
     950           0 :                 (void) sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
     951           0 :                 return -1;
     952             :         }
     953             :         return 0;
     954             : }
     955             : 
     956             : static list *
     957        4100 : tuples_check_types(mvc *sql, list *tuple_values, sql_exp *tuples)
     958             : {
     959        4100 :         list *tuples_list = exp_get_values(tuples);
     960        4100 :         sql_exp *first_tuple = tuples_list->h->data;
     961        4100 :         list *nvalues = sa_list(sql->sa);
     962        4100 :         if (is_values(first_tuple)) {
     963           1 :                 list *vals = first_tuple->f;
     964             : 
     965           3 :                 for (node *n = tuple_values->h, *m = vals->h; n && m; n = n->next, m = m->next) {
     966           2 :                         sql_exp *le = n->data, *re = m->data;
     967             : 
     968           2 :                         if (rel_binop_check_types(sql, NULL, le, re, 0) < 0)
     969             :                                 return NULL;
     970           2 :                         if ((le = exp_check_type(sql, exp_subtype(re), NULL, le, type_equal)) == NULL)
     971             :                                 return NULL;
     972           2 :                         append(nvalues, le);
     973             :                 }
     974             :                 return nvalues;
     975             :         } else {
     976        4099 :                 sql_rel *tuple_relation = exp_rel_get_rel(sql->sa, first_tuple);
     977             : 
     978        4099 :                 assert(list_length(tuple_values) == list_length(tuple_relation->exps));
     979       13342 :                 for (node *n = tuple_values->h, *m = tuple_relation->exps->h; n && m; n = n->next, m = m->next) {
     980        9243 :                         sql_exp *le = n->data, *re = m->data;
     981             : 
     982        9243 :                         if (rel_binop_check_types(sql, NULL, le, re, 0) < 0)
     983             :                                 return NULL;
     984        9243 :                         if ((le = exp_check_type(sql, exp_subtype(re), NULL, le, type_equal)) == NULL)
     985             :                                 return NULL;
     986        9243 :                         append(nvalues, le);
     987             :                 }
     988             :                 return nvalues;
     989             :         }
     990             :         return tuple_values;
     991             : }
     992             : 
     993             : static sql_rel *
     994        3752 : rel_values(sql_query *query, symbol *tableref, list *refs)
     995             : {
     996        3752 :         mvc *sql = query->sql;
     997        3752 :         sql_rel *r = NULL;
     998        3752 :         dlist *rowlist = tableref->data.lval->h->data.lval;
     999        3752 :         symbol *optname = tableref->data.lval->t->type == type_symbol ? tableref->data.lval->t->data.sym : NULL;
    1000        3752 :         node *m;
    1001        3752 :         list *exps = sa_list(sql->sa);
    1002        3752 :         exp_kind ek = {type_value, card_value, TRUE};
    1003             : 
    1004       15026 :         for (dnode *o = rowlist->h; o; o = o->next) {
    1005       11284 :                 dlist *values = o->data.lval;
    1006             : 
    1007       11284 :                 if (!list_empty(exps) && list_length(exps) != dlist_length(values)) {
    1008           3 :                         return sql_error(sql, 02, SQLSTATE(42000) "VALUES: number of columns doesn't match between rows");
    1009             :                 } else {
    1010       11281 :                         dnode *n;
    1011             : 
    1012       11281 :                         if (list_empty(exps)) {
    1013       10704 :                                 for (n = values->h; n; n = n->next) {
    1014        6952 :                                         sql_exp *vals = exp_values(sql->sa, sa_list(sql->sa));
    1015             : 
    1016        6952 :                                         exp_label(sql->sa, vals, ++sql->label);
    1017        6952 :                                         list_append(exps, vals);
    1018             :                                 }
    1019             :                         }
    1020       34512 :                         for (n = values->h, m = exps->h; n && m; n = n->next, m = m->next) {
    1021       23238 :                                 sql_exp *vals = m->data;
    1022       23238 :                                 list *vals_list = vals->f;
    1023       23238 :                                 sql_exp *e = rel_value_exp(query, NULL, n->data.sym, sql_sel | sql_values, ek);
    1024       23238 :                                 if (!e)
    1025             :                                         return NULL;
    1026       23231 :                                 list_append(vals_list, e);
    1027             :                         }
    1028             :                 }
    1029             :         }
    1030             : 
    1031             :         /* loop to check types and cardinality */
    1032        3742 :         unsigned int card = exps->h && list_length(((sql_exp*)exps->h->data)->f) > 1 ? CARD_MULTI : CARD_ATOM;
    1033       10677 :         for (m = exps->h; m; m = m->next) {
    1034        6938 :                 sql_exp *e = m->data;
    1035             : 
    1036        6938 :                 if (!(e = exp_values_set_supertype(sql, e, NULL)))
    1037             :                         return NULL;
    1038        6935 :                 e->card = card;
    1039        6935 :                 m->data = e;
    1040             :         }
    1041             : 
    1042        3739 :         r = rel_project(sql->sa, NULL, exps);
    1043        3739 :         r->nrcols = list_length(exps);
    1044        3739 :         r->card = card;
    1045        3739 :         return rel_table_optname(sql, r, optname, refs);
    1046             : }
    1047             : 
    1048             : static int
    1049      497183 : check_is_lateral(symbol *tableref)
    1050             : {
    1051      497183 :         if (tableref->token == SQL_NAME || tableref->token == SQL_TABLE ||
    1052             :                 tableref->token == SQL_VALUES) {
    1053      445782 :                 if (dlist_length(tableref->data.lval) == 3)
    1054      444949 :                         return tableref->data.lval->h->next->data.i_val;
    1055             :                 return 0;
    1056             :         } else if (tableref->token == SQL_WITH) {
    1057         941 :                 if (dlist_length(tableref->data.lval) == 4)
    1058           5 :                         return tableref->data.lval->h->next->next->data.i_val;
    1059             :                 return 0;
    1060             :         } else if (tableref->token == SQL_SELECT) {
    1061        3612 :                 SelectNode *sn = (SelectNode *) tableref;
    1062        3612 :                 return sn->lateral;
    1063             :         } else if (tableref->token == SQL_EXCEPT || tableref->token == SQL_INTERSECT ||
    1064             :                            tableref->token == SQL_UNION) {
    1065       10678 :                 if (dlist_length(tableref->data.lval) == 6)
    1066        9016 :                         return tableref->data.lval->h->next->next->next->next->data.i_val;
    1067             :                 return 0;
    1068             :         } else {
    1069             :                 return 0;
    1070             :         }
    1071             : }
    1072             : 
    1073             : static sql_rel *
    1074          25 : rel_reduce_on_column_privileges(mvc *sql, sql_rel *rel, sql_table *t)
    1075             : {
    1076          25 :         list *exps = sa_list(sql->sa);
    1077             : 
    1078          99 :         for (node *n = rel->exps->h, *m = ol_first_node(t->columns); n && m; n = n->next, m = m->next) {
    1079          74 :                 sql_exp *e = n->data;
    1080          74 :                 sql_column *c = m->data;
    1081             : 
    1082          74 :                 if (column_privs(sql, c, PRIV_SELECT))
    1083          12 :                         append(exps, e);
    1084             :         }
    1085          25 :         if (!list_empty(exps)) {
    1086           9 :                 rel->exps = exps;
    1087           9 :                 return rel;
    1088             :         }
    1089             :         return NULL;
    1090             : }
    1091             : 
    1092             : sql_rel *
    1093      678108 : table_ref(sql_query *query, symbol *tableref, int lateral, list *refs)
    1094             : {
    1095      678108 :         mvc *sql = query->sql;
    1096      678108 :         char *tname = NULL;
    1097      678108 :         sql_table *t = NULL;
    1098      678108 :         sql_rel *res = NULL;
    1099             : 
    1100      678108 :         if (tableref->token == SQL_NAME) {
    1101      467198 :                 dlist *name = tableref->data.lval->h->data.lval;
    1102      467198 :                 sql_rel *temp_table = NULL;
    1103      467198 :                 char *sname = qname_schema(name);
    1104      467198 :                 int allowed = 1;
    1105             : 
    1106      467198 :                 tname = qname_schema_object(name);
    1107             : 
    1108      467198 :                 if (dlist_length(name) > 2)
    1109           4 :                         return sql_error(sql, 02, SQLSTATE(3F000) "SELECT: only a schema and table name expected");
    1110             : 
    1111      467194 :                 if (!sname)
    1112      113436 :                         temp_table = stack_find_rel_view(sql, tname);
    1113      113436 :                 if (!temp_table)
    1114      450362 :                         t = find_table_or_view_on_scope(sql, NULL, sname, tname, "SELECT", false);
    1115      467194 :                 if (!t && !temp_table)
    1116             :                         return NULL;
    1117      467095 :                 if (!temp_table && !table_privs(sql, t, PRIV_SELECT))
    1118      467095 :                         allowed = 0;
    1119             : 
    1120      467095 :                 if (tableref->data.lval->t->type == type_symbol && tableref->data.lval->t->data.sym) /* AS */
    1121      273261 :                         tname = tableref->data.lval->t->data.sym->data.lval->h->data.sval;
    1122      467095 :                 if (temp_table && !t) {
    1123       16832 :                         node *n;
    1124       16832 :                         int needed = !is_simple_project(temp_table->op);
    1125             : 
    1126       16832 :                         if (is_basetable(temp_table->op) && !temp_table->exps) {
    1127           0 :                                 if (strcmp(rel_base_name(temp_table), tname) != 0)
    1128           0 :                                         rel_base_rename(temp_table, tname);
    1129             :                         } else {
    1130       60214 :                                 for (n = temp_table->exps->h; n && !needed; n = n->next) {
    1131       43382 :                                         sql_exp *e = n->data;
    1132             : 
    1133       43382 :                                         if (!exp_relname(e) || strcmp(exp_relname(e), tname) != 0)
    1134             :                                                 needed = 1;
    1135             :                                 }
    1136             : 
    1137       16832 :                                 if (needed) {
    1138        6817 :                                         list *exps = rel_projections(sql, temp_table, NULL, 1, 1);
    1139             : 
    1140        6817 :                                         temp_table = rel_project(sql->sa, temp_table, exps);
    1141       24458 :                                         for (n = exps->h; n; n = n->next) {
    1142       17641 :                                                 sql_exp *e = n->data;
    1143             : 
    1144       17641 :                                                 noninternexp_setname(sql, e, tname, NULL);
    1145       17641 :                                                 set_basecol(e);
    1146             :                                         }
    1147        6817 :                                         list_hash_clear(exps);
    1148             :                                 }
    1149             :                         }
    1150       16832 :                         if (temp_table && tableref->data.lval->t->type == type_symbol && tableref->data.lval->t->data.sym && tableref->data.lval->t->data.sym->data.lval->h->next->data.lval) /* AS with column aliases */
    1151           1 :                                 temp_table = rel_table_optname(sql, temp_table, tableref->data.lval->t->data.sym, refs);
    1152       16832 :                         if (allowed)
    1153             :                                 return temp_table;
    1154           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: access denied for %s to table '%s'", get_string_global_var(sql, "current_user"), tname);
    1155      450263 :                 } else if (isView(t)) {
    1156             :                         /* instantiate base view */
    1157       69486 :                         node *n,*m;
    1158       69486 :                         sql_rel *rel;
    1159             : 
    1160       69486 :                         if (sql->emode == m_deps) {
    1161       24382 :                                 rel = rel_basetable(sql, t, tname);
    1162       24382 :                                 if (!allowed)
    1163           0 :                                         rel_base_disallow(rel);
    1164             :                         } else {
    1165             :                                 /* when recreating a view, the view itself can't be found */
    1166       45104 :                                 if (sql->objid && sql->objid == t->base.id)
    1167           1 :                                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: attempting to recursively bind view '%s'.'%s'", t->s->base.name, tname);
    1168       45103 :                                 rel = rel_parse(sql, t->s, t->query, m_instantiate);
    1169       45103 :                                 if (rel && sql->emode == m_deps)
    1170           0 :                                         rel = rel_unnest(sql, rel);
    1171             :                         }
    1172             : 
    1173       69483 :                         if (!rel)
    1174           2 :                                 return NULL;
    1175             :                         /* Rename columns of the rel_parse relation */
    1176       69483 :                         if (sql->emode != m_deps) {
    1177       45101 :                                 assert(is_project(rel->op));
    1178       45101 :                                 set_processed(rel);
    1179       45101 :                                 if (is_mset(rel->op) || is_simple_project(rel->op) || (is_groupby(rel->op) && !list_empty(rel->r))) {
    1180             :                                         /* it's unsafe to set the projection names because of possible dependent sorting/grouping columns */
    1181       45101 :                                         rel = rel_project(sql->sa, rel, rel_projections(sql, rel, NULL, 0, 0));
    1182       45101 :                                         set_processed(rel);
    1183             :                                 }
    1184      407526 :                                 for (n = ol_first_node(t->columns), m = rel->exps->h; n && m; n = n->next, m = m->next) {
    1185      362425 :                                         sql_column *c = n->data;
    1186      362425 :                                         sql_exp *e = m->data;
    1187             : 
    1188      362425 :                                         exp_setname(sql, e, tname, c->base.name);
    1189      362425 :                                         set_basecol(e);
    1190             :                                 }
    1191       45101 :                                 list_hash_clear(rel->exps);
    1192             :                         }
    1193       69483 :                         if (rel && !allowed && t->query && (rel = rel_reduce_on_column_privileges(sql, rel, t)) == NULL)
    1194          16 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: access denied for %s to view '%s.%s'", get_string_global_var(sql, "current_user"), t->s->base.name, tname);
    1195       69467 :                         return rel;
    1196             :                 }
    1197      380777 :                 if ((isMergeTable(t) || isReplicaTable(t)) && list_length(t->members)==0)
    1198          14 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s '%s'.'%s' should have at least one table associated",
    1199          14 :                                                         TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->s->base.name, tname);
    1200      380763 :                 res = rel_basetable(sql, t, tname);
    1201      380763 :                 if (!allowed) {
    1202          53 :                         rel_base_disallow(res);
    1203          53 :                         if (rel_base_has_column_privileges(sql, res) == 0)
    1204          62 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: access denied for %s to %s '%s.%s'", get_string_global_var(sql, "current_user"), isView(t) ? "view" : "table", t->s->base.name, tname);
    1205             :                 }
    1206      380732 :                 if (tableref->data.lval->t->type == type_symbol && tableref->data.lval->t->data.sym && tableref->data.lval->t->data.sym->data.lval->h->next->data.lval) { /* AS with column aliases */
    1207           8 :                         res = rel_table_optname(sql, res, tableref->data.lval->t->data.sym, refs);
    1208      380724 :                 } else if (refs) { /* if this relation is under a FROM clause, check for duplicate names */
    1209      380719 :                         if (list_find(refs, tname, (fcmp) &strcmp))
    1210           7 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: relation name \"%s\" specified more than once", tname);
    1211      380712 :                         assert(tname);
    1212      380712 :                         list_append(refs, tname);
    1213             :                 }
    1214      380725 :                 return res;
    1215             :         } else if (tableref->token == SQL_VALUES) {
    1216        1361 :                 return rel_values(query, tableref, refs);
    1217             :         } else if (tableref->token == SQL_TABLE) {
    1218       10757 :                 return rel_named_table_function(query, NULL, tableref, lateral, refs);
    1219             :         } else if (tableref->token == SQL_SELECT) {
    1220       97537 :                 return rel_subquery_optname(query, tableref, refs);
    1221             :         } else if (tableref->token == SQL_UNION || tableref->token == SQL_EXCEPT || tableref->token == SQL_INTERSECT) {
    1222             :                 /* subqueries will be called, ie no need to test for duplicate references */
    1223       41598 :                 sql_rel *tq = rel_setquery(query, tableref);
    1224             : 
    1225       41598 :                 if (!tq)
    1226             :                         return NULL;
    1227             :                 /* look for lateral joins */
    1228       41595 :                 symbol *optname = tableref->data.lval->t->type == type_symbol ? tableref->data.lval->t->data.sym : NULL;
    1229       41595 :                 return rel_table_optname(sql, tq, optname, refs);
    1230             :         } else {
    1231       59657 :                 return query_exp_optname(query, tableref, refs);
    1232             :         }
    1233             : }
    1234             : 
    1235             : static sql_exp *
    1236      120836 : rel_exp_variable_on_scope(mvc *sql, const char *sname, const char *vname)
    1237             : {
    1238      120836 :         sql_subtype *tpe = NULL;
    1239      120836 :         sql_var *var = NULL;
    1240      120836 :         sql_arg *a = NULL;
    1241      120836 :         int level = 1;
    1242             : 
    1243      120836 :         if (find_variable_on_scope(sql, sname, vname, &var, &a, &tpe, &level, "SELECT")) {
    1244      119930 :                 if (var) /* if variable is known from the stack or a global var */
    1245       37360 :                         return exp_param_or_declared(sql->sa, var->sname ? sa_strdup(sql->sa, var->sname) : NULL, sa_strdup(sql->sa, var->name), &(var->var.tpe), level);
    1246       87550 :                 if (a) /* if variable is a parameter */
    1247       87550 :                         return exp_param_or_declared(sql->sa, NULL, sa_strdup(sql->sa, vname), &(a->type), level);
    1248             :         }
    1249             :         return NULL;
    1250             : }
    1251             : 
    1252             : static sql_exp *
    1253        9247 : exps_get_exp(list *exps, int nth)
    1254             : {
    1255        9247 :         node *n = NULL;
    1256        9247 :         int i = 0;
    1257             : 
    1258        9247 :         if (exps)
    1259       27170 :                 for (n=exps->h, i=1; n && i<nth; n=n->next, i++)
    1260             :                         ;
    1261        9247 :         if (n && i == nth)
    1262        9244 :                 return n->data;
    1263             :         return NULL;
    1264             : }
    1265             : 
    1266             : static sql_rel *
    1267       27679 : rel_find_groupby(sql_rel *groupby)
    1268             : {
    1269       27679 :         if (groupby && !is_processed(groupby) && !is_base(groupby->op)) {
    1270       37275 :                 while(!is_processed(groupby) && !is_base(groupby->op)) {
    1271       29477 :                         if (is_groupby(groupby->op) || !groupby->l)
    1272             :                                 break;
    1273             :                         if (groupby->l)
    1274             :                                 groupby = groupby->l;
    1275             :                 }
    1276       27555 :                 if (groupby && is_groupby(groupby->op))
    1277       19757 :                         return groupby;
    1278             :         }
    1279             :         return NULL;
    1280             : }
    1281             : 
    1282             : static int
    1283         306 : is_groupby_col(sql_rel *gb, sql_exp *e)
    1284             : {
    1285         306 :         gb = rel_find_groupby(gb);
    1286             : 
    1287         306 :         if (gb) {
    1288         174 :                 if (exp_relname(e)) {
    1289         163 :                         if (exp_name(e) && exps_bind_column2(gb->r, exp_relname(e), exp_name(e), NULL))
    1290             :                                 return 1;
    1291             :                 } else {
    1292          11 :                         if (exp_name(e) && exps_bind_column(gb->r, exp_name(e), NULL, NULL, 1))
    1293             :                                 return 1;
    1294             :                 }
    1295             :         }
    1296             :         return 0;
    1297             : }
    1298             : 
    1299             : static void
    1300        4722 : set_dependent_( sql_rel *r)
    1301             : {
    1302        4722 :         if (is_select(r->op))
    1303        3582 :                 r = r->l;
    1304        4722 :         if (r && is_join(r->op))
    1305        1194 :                 set_dependent(r);
    1306        4722 : }
    1307             : 
    1308             : static
    1309          15 : sql_rel* find_union(visitor *v, sql_rel *rel) {
    1310          15 :         if (rel->op == op_union || rel->op == op_munion)
    1311           1 :                 v->data = rel;
    1312          15 :         return rel;
    1313             : }
    1314             : 
    1315             : static inline
    1316          54 : bool group_by_pk_project_uk_cond(mvc* sql, sql_rel* inner, sql_exp* exp,const char* sname, const char* tname) {
    1317          54 :         sql_table* t = find_table_or_view_on_scope(sql, NULL, sname, tname, "SELECT", false);
    1318          54 :         bool allow = false;
    1319          54 :         if (t) {
    1320          17 :                 sql_idx* pki = NULL;
    1321          17 :                 list *ukil = sa_list(sql->sa);
    1322             : 
    1323          23 :                 for (node * n = ol_first_node(t->idxs); n; n = n->next) {
    1324           6 :                         sql_idx *i = n->data;
    1325           6 :                         if (!i->key)
    1326           1 :                                 continue;
    1327           5 :                         switch (i->key->type) {
    1328           3 :                         case pkey:
    1329           3 :                                 pki = i;
    1330           3 :                                 continue;
    1331           2 :                         case ukey:
    1332             :                         case unndkey:
    1333           2 :                                 list_append(ukil, i);
    1334           2 :                                 continue;
    1335           0 :                         default:
    1336           0 :                                 continue;
    1337             :                         }
    1338             :                 }
    1339          17 :                 if (pki && pki->columns->cnt == 1 && inner->r && ((list*) inner->r)->cnt == 1) {
    1340             :                         /* for now only check simple case where primary key and group by expression is a single column*/
    1341           3 :                         sql_exp* gbe = ((list*) inner->r)->h->data;
    1342           3 :                         sql_column* pkc = ((sql_kc *)pki->columns->h->data)->c;
    1343           3 :                         if (gbe->type == e_column && strcmp(gbe->alias.name, pkc->base.name) == 0) {
    1344           2 :                                 node *n;
    1345           2 :                                 for (n = ukil->h; n; n = n->next){
    1346           2 :                                         sql_idx* uki = n->data;
    1347           2 :                                         if (uki->columns->cnt == 1) {
    1348             :                                                 /* for now only check simple case where unique key is a single column*/
    1349           2 :                                                 sql_column* ukc = ((sql_kc *)uki->columns->h->data)->c;
    1350           2 :                                                 if (strcmp(exp->alias.name, ukc->base.name) == 0) {
    1351             :                                                         allow = true;
    1352             :                                                         break;
    1353             :                                                 }
    1354             :                                         }
    1355             :                                 }
    1356             :                         }
    1357             :                 }
    1358             : 
    1359           2 :                 if (allow) {
    1360             :                         /* sufficiency condition: abort if relation contains union subrelation
    1361             :                         * because it may break functional dependency between pk and uk */
    1362           2 :                         visitor v = {.sql=sql};
    1363           2 :                         rel_visitor_topdown(&v, inner, &find_union);
    1364           2 :                         if (v.data)
    1365           1 :                                 allow = false;
    1366             :                 }
    1367             :         }
    1368             : 
    1369          54 :         return allow;
    1370             : 
    1371             : }
    1372             : 
    1373             : static sql_exp *
    1374     2338346 : rel_column_ref(sql_query *query, sql_rel **rel, symbol *column_r, int f)
    1375             : {
    1376     2338346 :         mvc *sql = query->sql;
    1377     2338346 :         sql_exp *exp = NULL;
    1378     2338346 :         dlist *l = NULL;
    1379     2338346 :         sql_rel *inner = rel?*rel:NULL, *outer = NULL;
    1380     2338346 :         int used_lower_after_processed = 0;
    1381             : 
    1382     2338346 :         assert((column_r->token == SQL_COLUMN || column_r->token == SQL_IDENT) && column_r->type == type_list);
    1383     2338346 :         l = column_r->data.lval;
    1384             : 
    1385     2338346 :         if (dlist_length(l) == 1) {
    1386     1104431 :                 const char *name = l->h->data.sval;
    1387             : 
    1388     1104431 :                 if (!exp && inner)
    1389     1010082 :                         if (!(exp = rel_bind_column(sql, inner, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    1390             :                                 return NULL;
    1391     1104417 :                 if (!exp && inner && ((is_sql_aggr(f) && (is_groupby(inner->op) || is_select(inner->op))) ||
    1392       23870 :                                                      (is_groupby(inner->op) && inner->flag))) {
    1393             :                         /* if inner is selection, ie having clause, get the left relation to reach group by */
    1394             :                         sql_rel *gp = inner;
    1395         258 :                         while (gp && is_select(gp->op))
    1396          27 :                                 gp = gp->l;
    1397         231 :                         if (gp && !is_basetable(gp->op) && gp->l && !(exp = rel_bind_column(sql, gp->l, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    1398             :                                 return NULL;
    1399             :                 }
    1400     1104417 :                 if (!exp && query && query_has_outer(query)) {
    1401         448 :                         int i;
    1402             : 
    1403         501 :                         for (i=query_has_outer(query)-1; i>= 0 && !exp && (outer = query_fetch_outer(query,i)); i--) {
    1404         472 :                                 if (!(exp = rel_bind_column(sql, outer, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    1405             :                                         return NULL;
    1406          84 :                                 if (!exp && is_groupby(outer->op)) {
    1407          31 :                                         if (!(exp = rel_bind_column(sql, outer->l, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    1408             :                                                 return NULL;
    1409             :                                         else
    1410          31 :                                                 used_lower_after_processed = is_processed(outer);
    1411             :                                 }
    1412         472 :                                 if (exp && is_simple_project(outer->op) && !rel_find_exp(outer, exp))
    1413           0 :                                         exp = rel_project_add_exp(sql, outer, exp);
    1414         419 :                                 if (exp)
    1415             :                                         break;
    1416             :                         }
    1417         448 :                         if (exp && exp->card != CARD_AGGR && is_groupby(outer->op) && !is_sql_aggr(f) && rel_find_exp(outer->l, exp))
    1418           5 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
    1419         443 :                         if (exp && outer && outer->card <= CARD_AGGR && exp->card > CARD_AGGR && !is_sql_aggr(f))
    1420           0 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
    1421         443 :                         if (exp && outer && !is_sql_aggr(f) && !is_sql_aggr(query_fetch_outer_state(query, i))) {
    1422         275 :                                 if (used_lower_after_processed || query_outer_used_exp( query, i, exp, f)) {
    1423           0 :                                         sql_exp *lu = used_lower_after_processed?exp:query_outer_last_used(query, i);
    1424           0 :                                         if (exp_name(lu) && exp_relname(lu) && !has_label(lu))
    1425           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(lu), exp_name(lu));
    1426           0 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
    1427             :                                 }
    1428             :                         }
    1429         443 :                         if (exp) {
    1430         414 :                                 int of = query_fetch_outer_state(query, i);
    1431         414 :                                 if (is_groupby(outer->op) && !is_sql_aggr(f)) {
    1432          37 :                                         exp = rel_groupby_add_aggr(sql, outer, exp);
    1433          37 :                                         exp->card = CARD_ATOM;
    1434         377 :                                 } else if (is_groupby(outer->op) && is_sql_aggr(f) && exps_any_match(outer->exps, exp))
    1435          57 :                                         exp = exp_ref(sql, exp);
    1436             :                                 else
    1437         320 :                                         exp->card = CARD_ATOM;
    1438         414 :                                 set_freevar(exp, i);
    1439             :                                 /*
    1440             :                                 if (exp->alias.label == exp->nid)
    1441             :                                         exp->alias.label = -(sql->nid++);
    1442             :                                         */
    1443         414 :                                 if (!is_sql_where(of) && !is_sql_aggr(of) && !is_sql_aggr(f) && !outer->grouped)
    1444         125 :                                         set_outer(outer);
    1445             :                         }
    1446         443 :                         if (exp && outer && (is_select(outer->op) || is_join(outer->op)))
    1447          31 :                                 set_dependent_(outer);
    1448             :                 }
    1449             : 
    1450             :                 /* some views are just in the stack, like before and after updates views */
    1451     1104412 :                 if (rel && sql->use_views) {
    1452          13 :                         sql_rel *v = NULL;
    1453          13 :                         int dup = stack_find_rel_view_projection_columns(sql, name, &v); /* trigger views are basetables relations, so those may conflict */
    1454             : 
    1455          13 :                         if (dup < 0 || (v && exp && *rel && is_base(v->op) && v != *rel)) /* comparing pointers, ugh */
    1456           2 :                                 return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: identifier '%s' ambiguous", name);
    1457          11 :                         if (v && !exp) {
    1458           4 :                                 if (*rel)
    1459           1 :                                         *rel = rel_crossproduct(sql->sa, *rel, rel_dup(v), op_join);
    1460             :                                 else
    1461           3 :                                         *rel = rel_dup(v);
    1462           4 :                                 exp = rel_bind_column(sql, *rel, name, f, 0);
    1463             :                         }
    1464             :                 }
    1465     1104410 :                 if (!exp) /* If no column was found, try a variable or parameter */
    1466      117829 :                         exp = rel_exp_variable_on_scope(sql, NULL, name);
    1467             : 
    1468      117829 :                 if (!exp) {
    1469         906 :                         if (inner && !is_sql_aggr(f) && is_groupby(inner->op) && inner->l && (exp = rel_bind_column(sql, inner->l, name, f, 0)))
    1470          46 :                                 return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
    1471             :                 }
    1472             : 
    1473     1103504 :                 if (!exp)
    1474         860 :                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: identifier '%s' unknown", name);
    1475     1103504 :                 if (exp && inner && inner->card <= CARD_AGGR && exp->card > CARD_AGGR && (is_sql_sel(f) || is_sql_having(f)) && (!is_sql_aggr(f) && !(inner->flag)))
    1476           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
    1477     1103504 :                 if (exp && inner && is_groupby(inner->op) && !is_sql_aggr(f) && !is_freevar(exp) && !inner->flag)
    1478       25016 :                         exp = rel_groupby_add_aggr(sql, inner, exp);
    1479     1233915 :         } else if (dlist_length(l) == 2 || dlist_length(l) == 3) {
    1480     1233915 :                 const char *sname = NULL;
    1481     1233915 :                 const char *tname = l->h->data.sval;
    1482     1233915 :                 const char *cname = l->h->next->data.sval;
    1483     1233915 :                 if (dlist_length(l) == 3) {
    1484           1 :                         sname = l->h->data.sval;
    1485           1 :                         tname = l->h->next->data.sval;
    1486           1 :                         cname = l->h->next->next->data.sval;
    1487             :                 }
    1488             : 
    1489     1233915 :                 if (!exp && rel && inner)
    1490     1233788 :                         if (!(exp = rel_bind_column3(sql, inner, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
    1491             :                                 return NULL;
    1492     1233914 :                 if (!exp && inner && is_sql_aggr(f) && (is_groupby(inner->op) || is_select(inner->op))) {
    1493             :                         /* if inner is selection, ie having clause, get the left relation to reach group by */
    1494             :                         sql_rel *gp = inner;
    1495          56 :                         while (gp && is_select(gp->op))
    1496           4 :                                 gp = gp->l;
    1497          52 :                         if (gp && !is_basetable(gp->op) && gp->l && !(exp = rel_bind_column3(sql, gp->l, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
    1498             :                                 return NULL;
    1499             :                 }
    1500     1233914 :                 if (!exp && query && query_has_outer(query)) {
    1501       11809 :                         int i;
    1502             : 
    1503       12019 :                         for (i=query_has_outer(query)-1; i>= 0 && !exp && (outer = query_fetch_outer(query,i)); i--) {
    1504       12018 :                                 if (!(exp = rel_bind_column3(sql, outer, sname, tname, cname, f | sql_outer)) && sql->session->status == -ERR_AMBIGUOUS)
    1505             :                                         return NULL;
    1506         293 :                                 if (!exp && is_groupby(outer->op)) {
    1507         102 :                                         if (!(exp = rel_bind_column3(sql, outer->l, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
    1508             :                                                 return NULL;
    1509             :                                         else
    1510         102 :                                                 used_lower_after_processed = is_processed(outer);
    1511             :                                 }
    1512       12018 :                                 if (exp && is_simple_project(outer->op) && !rel_find_exp(outer, exp))
    1513           0 :                                         exp = rel_project_add_exp(sql, outer, exp);
    1514       11808 :                                 if (exp)
    1515             :                                         break;
    1516             :                         }
    1517       11809 :                         if (exp && exp->card != CARD_AGGR && is_groupby(outer->op) && !is_sql_aggr(f) && rel_find_exp(outer->l, exp))
    1518           6 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
    1519       11803 :                         if (exp && outer && outer->card <= CARD_AGGR && exp->card > CARD_AGGR && !is_sql_aggr(f))
    1520           0 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
    1521       11803 :                         if (exp && outer && !is_sql_aggr(f)) {
    1522       11528 :                                 if (used_lower_after_processed || query_outer_used_exp( query, i, exp, f)) {
    1523           0 :                                         sql_exp *lu = used_lower_after_processed?exp:query_outer_last_used(query, i);
    1524           0 :                                         if (exp_name(lu) && exp_relname(lu) && !has_label(lu))
    1525           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(lu), exp_name(lu));
    1526           0 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
    1527             :                                 }
    1528             :                         }
    1529       11803 :                         if (exp) {
    1530       11802 :                                 int of = query_fetch_outer_state(query, i);
    1531       11802 :                                 if (is_groupby(outer->op) && !is_sql_aggr(f)) {
    1532          64 :                                         exp = rel_groupby_add_aggr(sql, outer, exp);
    1533          64 :                                         exp->card = CARD_ATOM;
    1534       11738 :                                 } else if (is_groupby(outer->op) && is_sql_aggr(f) && exps_any_match(outer->exps, exp))
    1535          52 :                                         exp = exp_ref(sql, exp);
    1536             :                                 else
    1537       11686 :                                         exp->card = CARD_ATOM;
    1538       11802 :                                 set_freevar(exp, i);
    1539             :                                 /*
    1540             :                                 if (exp->alias.label == exp->nid)
    1541             :                                         exp->alias.label = -(sql->nid++);
    1542             :                                         */
    1543       11802 :                                 if (!is_sql_where(of) && !is_sql_aggr(of) && !is_sql_aggr(f) && !outer->grouped)
    1544       10113 :                                         set_outer(outer);
    1545             :                         }
    1546       11803 :                         if (exp && outer && (is_select(outer->op) || is_join(outer->op)))
    1547        4691 :                                 set_dependent_(outer);
    1548             :                 }
    1549             : 
    1550             :                 /* some views are just in the stack, like before and after updates views */
    1551     1233908 :                 if (rel && sql->use_views) {
    1552          40 :                         sql_rel *v = stack_find_rel_view(sql, tname);
    1553             : 
    1554          40 :                         if (v && exp && *rel && is_base(v->op) && v != *rel) /* trigger views are basetables relations, so those may conflict */
    1555           0 :                                 return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: identifier '%s.%s' ambiguous", tname, cname);
    1556          40 :                         if (v && !exp) {
    1557          20 :                                 if (*rel)
    1558           0 :                                         *rel = rel_crossproduct(sql->sa, *rel, rel_dup(v), op_join);
    1559             :                                 else
    1560          20 :                                         *rel = rel_dup(v);
    1561          20 :                                 if (!(exp = rel_bind_column3(sql, *rel, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
    1562             :                                         return NULL;
    1563             :                         }
    1564             :                 }
    1565     1233888 :                 if (!exp) { /* If no column was found, try a global variable */
    1566       66270 :                         sql_var *var = NULL;
    1567       66270 :                         sql_subtype *tpe = NULL;
    1568       66270 :                         int level = 0;
    1569       66270 :                         sql_arg *a = NULL;
    1570             : 
    1571       66270 :                         if (find_variable_on_scope(sql, tname, cname, &var, &a, &tpe, &level, "SELECT")) { /* search schema with table name, ugh */
    1572          10 :                                 assert(level == 0);
    1573          10 :                                 exp = exp_param_or_declared(sql->sa, sa_strdup(sql->sa, var->sname), sa_strdup(sql->sa, var->name), &(var->var.tpe), 0);
    1574             :                         }
    1575             :                 }
    1576       66270 :                 if (!exp) {
    1577       66260 :                         if (inner && !is_sql_aggr(f) && is_groupby(inner->op) && inner->l && (exp = rel_bind_column3(sql, inner->l, sname, tname, cname, f))) {
    1578          54 :                                 if (group_by_pk_project_uk_cond(sql, inner, exp, sname, tname)) {
    1579             :                                         /* SQL23 feature: very special case where primary key is used in GROUP BY expression and
    1580             :                                          * unique key is in the project list or ORDER BY clause */
    1581           1 :                                         sql->session->status = 0;
    1582           1 :                                         sql->errstr[0] = 0;
    1583           1 :                                         exp->card = CARD_AGGR;
    1584           1 :                                         list_append(inner->exps, exp);
    1585             :                                 }
    1586             :                                 else
    1587          53 :                                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
    1588             :                         }
    1589             :                 }
    1590             : 
    1591           1 :                 if (!exp)
    1592       66206 :                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42S22) "SELECT: no such column '%s.%s'", tname, cname);
    1593     1167649 :                 if (exp && inner && inner->card <= CARD_AGGR && exp->card > CARD_AGGR && (is_sql_sel(f) || is_sql_having(f)) && !is_sql_aggr(f))
    1594           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
    1595     1167649 :                 if (exp && inner && is_groupby(inner->op) && !is_sql_aggr(f) && !is_freevar(exp))
    1596        5655 :                         exp = rel_groupby_add_aggr(sql, inner, exp);
    1597           0 :         } else if (dlist_length(l) > 3) {
    1598           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "cross-database references are not implemented");
    1599             :         }
    1600     2271153 :         if (exp && !exp_is_atom(exp) && rel && !outer) {
    1601     2142010 :                 if (query->last_exp && query->last_rel == *rel && !is_sql_aggr(query->last_state) && is_sql_aggr(f)) {
    1602          52 :                         if (!is_groupby(query->last_rel->op) || list_empty(query->last_rel->r) || !exps_find_exp(query->last_rel->r, query->last_exp)) {
    1603          31 :                                 if (exp_relname(query->last_exp) && exp_name(query->last_exp) && !has_label(query->last_exp))
    1604          31 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(query->last_exp), exp_name(query->last_exp));
    1605           0 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    1606             :                         }
    1607             :                 }
    1608     2141979 :                 query->prev = query->last_exp;
    1609     2141979 :                 query->last_exp = exp;
    1610     2141979 :                 query->last_state = f;
    1611     2141979 :                 query->last_rel = *rel;
    1612             :         }
    1613             :         return exp;
    1614             : }
    1615             : 
    1616             : int
    1617      976878 : rel_convert_types(mvc *sql, sql_rel *ll, sql_rel *rr, sql_exp **L, sql_exp **R, int scale_fixing, check_type tpe)
    1618             : {
    1619      976878 :         sql_exp *ls = *L;
    1620      976878 :         sql_exp *rs = *R;
    1621      976878 :         sql_subtype *lt = exp_subtype(ls);
    1622      976878 :         sql_subtype *rt = exp_subtype(rs);
    1623             : 
    1624      976878 :         if (!rt && !lt) {
    1625           2 :                 sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
    1626           2 :                 return -1;
    1627             :         }
    1628      976876 :         if (rt && (!lt || !lt->type))
    1629           7 :                  return rel_set_type_param(sql, rt, ll, ls, 0);
    1630      976869 :         if (lt && (!rt || !rt->type))
    1631         648 :                  return rel_set_type_param(sql, lt, rr, rs, 0);
    1632             : 
    1633      976221 :         if (rt && lt) {
    1634      976221 :                 sql_subtype *i = lt;
    1635      976221 :                 sql_subtype *r = rt;
    1636             : 
    1637      976221 :                 if (subtype_cmp(lt, rt) != 0 || (tpe == type_equal_no_any && (lt->type->localtype==0 || rt->type->localtype==0))) {
    1638      268522 :                         sql_subtype super;
    1639             : 
    1640      268522 :                         cmp_supertype(&super, r, i);
    1641      268522 :                         if (scale_fixing) {
    1642             :                                 /* convert ls to super type */
    1643      268522 :                                 ls = exp_check_type(sql, &super, ll, ls, tpe);
    1644             :                                 /* convert rs to super type */
    1645      268522 :                                 rs = exp_check_type(sql, &super, rr, rs, tpe);
    1646             :                         } else {
    1647             :                                 /* convert ls to super type */
    1648           0 :                                 super.scale = lt->scale;
    1649           0 :                                 ls = exp_check_type(sql, &super, ll, ls, tpe);
    1650             :                                 /* convert rs to super type */
    1651           0 :                                 super.scale = rt->scale;
    1652           0 :                                 rs = exp_check_type(sql, &super, rr, rs, tpe);
    1653             :                         }
    1654             :                 }
    1655      976221 :                 *L = ls;
    1656      976221 :                 *R = rs;
    1657      976221 :                 if (!ls || !rs)
    1658             :                         return -1;
    1659             :                 return 0;
    1660             :         }
    1661             :         return -1;
    1662             : }
    1663             : 
    1664             : static sql_rel *
    1665      108707 : push_select_exp(mvc *sql, sql_rel *rel, sql_exp *e, sql_exp *ls, int f)
    1666             : {
    1667      108707 :         if (is_outerjoin(rel->op)) {
    1668        1178 :                 if ((is_left(rel->op) || is_full(rel->op)) && rel_find_exp(rel->l, ls)) {
    1669          38 :                         rel_join_add_exp(sql->sa, rel, e);
    1670          38 :                         return rel;
    1671        1140 :                 } else if ((is_right(rel->op) || is_full(rel->op)) && rel_find_exp(rel->r, ls)) {
    1672           5 :                         rel_join_add_exp(sql->sa, rel, e);
    1673           5 :                         return rel;
    1674             :                 }
    1675        1135 :                 if (is_left(rel->op) && rel_find_exp(rel->r, ls)) {
    1676        1109 :                         rel->r = rel_push_select(sql, rel->r, ls, e, f);
    1677        1109 :                         return rel;
    1678          26 :                 } else if (is_right(rel->op) && rel_find_exp(rel->l, ls)) {
    1679          11 :                         rel->l = rel_push_select(sql, rel->l, ls, e, f);
    1680          11 :                         return rel;
    1681             :                 }
    1682             :         }
    1683             :         /* push select into the given relation */
    1684      107544 :         return rel_push_select(sql, rel, ls, e, f);
    1685             : }
    1686             : 
    1687             : static sql_rel *
    1688      204980 : push_join_exp(mvc *sql, sql_rel *rel, sql_exp *e, sql_exp *L, sql_exp *R, sql_exp *R2, int f)
    1689             : {
    1690      204980 :         sql_rel *r;
    1691      204980 :         if (/*is_semi(rel->op) ||*/ (is_outerjoin(rel->op) && !is_processed((rel)))) {
    1692       22027 :                 rel_join_add_exp(sql->sa, rel, e);
    1693       22027 :                 return rel;
    1694             :         }
    1695             :         /* push join into the given relation */
    1696      182953 :         if ((r = rel_push_join(sql, rel, L, R, R2, e, f)) != NULL)
    1697             :                 return r;
    1698           0 :         rel_join_add_exp(sql->sa, rel, e);
    1699           0 :         return rel;
    1700             : }
    1701             : 
    1702             : static sql_rel *
    1703        3358 : rel_select_push_filter_exp_down(mvc *sql, sql_rel *rel, sql_exp *e, list *l, list *r, int ff)
    1704             : {
    1705        3358 :         sql_exp *ll, *rr;
    1706        3358 :         if (exps_card(r) <= CARD_ATOM && (exps_are_atoms(r) || exps_have_freevar(sql, r) || exps_have_freevar(sql, l))) {
    1707        3262 :                 if (exps_card(l) == exps_card(r) || rel->processed)  /* bin compare op */
    1708          98 :                         return rel_select(sql->sa, rel, e);
    1709        3164 :                 if ((ll = exps_find_one_multi_exp(l)))
    1710        3164 :                         return push_select_exp(sql, rel, e, ll, ff);
    1711          96 :         } else if ((ll = exps_find_one_multi_exp(l)) && (rr = exps_find_one_multi_exp(r))) { /* join */
    1712          57 :                 return push_join_exp(sql, rel, e, ll, rr, NULL, ff);
    1713             :         }
    1714          39 :         if (is_outerjoin(rel->op))
    1715           3 :                 return rel_select(sql->sa, rel, e);
    1716          36 :         return rel_select_add_exp(sql->sa, rel, e);
    1717             : }
    1718             : 
    1719             : static sql_rel *
    1720        3357 : rel_filter(mvc *sql, sql_rel *rel, list *l, list *r, char *sname, char *filter_op, int anti, int ff)
    1721             : {
    1722        3357 :         node *n;
    1723        3357 :         sql_exp *e = NULL;
    1724        3357 :         sql_subfunc *f = NULL;
    1725        3357 :         list *tl = sa_list(sql->sa);
    1726        3357 :         bool found = false;
    1727             : 
    1728        6714 :         for (n = l->h; n; n = n->next){
    1729        3357 :                 sql_exp *e = n->data;
    1730             : 
    1731        3357 :                 list_append(tl, exp_subtype(e));
    1732             :         }
    1733       13351 :         for (n = r->h; n; n = n->next){
    1734        9994 :                 sql_exp *e = n->data;
    1735             : 
    1736        9994 :                 list_append(tl, exp_subtype(e));
    1737             :         }
    1738             :         /* find filter function */
    1739        3357 :         f = bind_func_(sql, sname, filter_op, tl, F_FILT, false, &found, false);
    1740        3357 :         if (f) {
    1741        3355 :                 node *n,*m = f->func->ops->h;
    1742        3355 :                 list *nexps = sa_list(sql->sa);
    1743             : 
    1744        6710 :                 for(n=l->h; m && n; m = m->next, n = n->next) {
    1745        3355 :                         sql_arg *a = m->data;
    1746        3355 :                         sql_exp *e = n->data;
    1747             : 
    1748        3355 :                         e = exp_check_type(sql, &a->type, rel, e, type_equal);
    1749        3355 :                         if (!e)
    1750             :                                 return NULL;
    1751        3355 :                         list_append(nexps, e);
    1752             :                 }
    1753        3355 :                 l = nexps;
    1754        3355 :                 nexps = sa_list(sql->sa);
    1755       13341 :                 for(n=r->h; m && n; m = m->next, n = n->next) {
    1756        9986 :                         sql_arg *a = m->data;
    1757        9986 :                         sql_exp *e = n->data;
    1758             : 
    1759        9986 :                         e = exp_check_type(sql, &a->type, rel, e, type_equal);
    1760        9986 :                         if (!e)
    1761             :                                 return NULL;
    1762        9986 :                         list_append(nexps, e);
    1763             :                 }
    1764             :                 r = nexps;
    1765             :         }
    1766        3357 :         if (!f)
    1767           4 :                 return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s FILTER function %s%s%s'%s'",
    1768           2 :                                                  found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", filter_op);
    1769        3355 :         e = exp_filter(sql->sa, l, r, f, anti);
    1770             : 
    1771        3355 :         if (exps_one_is_rel(l) || exps_one_is_rel(r)) /* uncorrelated subquery case */
    1772           9 :                 return rel_select(sql->sa, rel, e);
    1773             :         /* atom or row => select */
    1774        6692 :         for (node *n=l->h; n; n = n->next) {
    1775        3346 :                 sql_exp *ls = n->data;
    1776             : 
    1777        3346 :                 if (ls->card > rel->card) {
    1778           0 :                         if (exp_name(ls) && !has_label(ls))
    1779           0 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(ls));
    1780           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    1781             :                 }
    1782             :         }
    1783       13305 :         for (node *n=r->h; n; n = n->next) {
    1784        9959 :                 sql_exp *rs = n->data;
    1785             : 
    1786        9959 :                 if (rs->card > rel->card) {
    1787           0 :                         if (exp_name(rs) && !has_label(rs))
    1788           0 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(rs));
    1789           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    1790             :                 }
    1791             :         }
    1792        3346 :         return rel_select_push_filter_exp_down(sql, rel, e, l, r, ff);
    1793             : }
    1794             : 
    1795             : static sql_rel *
    1796        3297 : rel_filter_exp_(mvc *sql, sql_rel *rel, sql_exp *ls, sql_exp *r1, sql_exp *r2, sql_exp *r3, char *filter_op, int anti, int f)
    1797             : {
    1798        3297 :         list *l = sa_list(sql->sa);
    1799        3297 :         list *r = sa_list(sql->sa);
    1800             : 
    1801        3297 :         list_append(l, ls);
    1802        3297 :         list_append(r, r1);
    1803        3297 :         if (r2)
    1804        3297 :                 list_append(r, r2);
    1805        3297 :         if (r3)
    1806        3297 :                 list_append(r, r3);
    1807        3297 :         return rel_filter(sql, rel, l, r, "sys", filter_op, anti, f);
    1808             : }
    1809             : 
    1810             : static sql_rel *
    1811      378645 : rel_select_push_compare_exp_down(mvc *sql, sql_rel *rel, sql_exp *e, sql_exp *ls, sql_exp *rs, sql_exp *rs2, int f)
    1812             : {
    1813      378645 :         if (!is_join(rel->op) && !is_select(rel->op))
    1814       85794 :                 return rel_select(sql->sa, rel, e);
    1815      381315 :         if ((rs->card <= CARD_ATOM || (rs2 && ls->card <= CARD_ATOM)) &&
    1816      176928 :                 (exp_is_atom(rs) || (rs2 && exp_is_atom(ls)) || exp_has_freevar(sql, rs) || exp_has_freevar(sql, ls)) &&
    1817         485 :                 (!rs2 || (rs2->card <= CARD_ATOM && (exp_is_atom(rs2) || exp_has_freevar(sql, rs2))))) {
    1818       87928 :                 if (ls->card == rs->card || (rs2 && (ls->card == rs2->card || rs->card == rs2->card)) || rel->processed) /* bin compare op */
    1819         994 :                         return rel_select(sql->sa, rel, e);
    1820             : 
    1821       86934 :                 return push_select_exp(sql, rel, e, ls, f);
    1822             :         } else { /* join */
    1823      204923 :                 return push_join_exp(sql, rel, e, ls, rs, rs2, f);
    1824             :         }
    1825             :         return rel;
    1826             : }
    1827             : 
    1828             : static sql_rel *
    1829      352012 : rel_compare_exp_(sql_query *query, sql_rel *rel, sql_exp *ls, sql_exp *rs, sql_exp *rs2, int type, int anti, int quantifier, int f, int symmetric, int is_semantics)
    1830             : {
    1831      352012 :         mvc *sql = query->sql;
    1832      352012 :         sql_exp *e = NULL;
    1833             : 
    1834      352012 :         if (quantifier || exp_is_rel(ls) || exp_is_rel(rs) || (rs2 && exp_is_rel(rs2))) {
    1835        3306 :                 if (rs2) {
    1836           7 :                         e = exp_compare2(sql->sa, ls, rs, rs2, type, symmetric);
    1837           7 :                         if (anti)
    1838           0 :                                 set_anti(e);
    1839             :                 } else {
    1840        3299 :                         assert(!symmetric);
    1841        3299 :                         if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
    1842             :                                 return NULL;
    1843        3299 :                         e = exp_compare_func(sql, ls, rs, compare_func((comp_type)type, anti), quantifier);
    1844             :                 }
    1845        3306 :                 return rel_select(sql->sa, rel, e);
    1846      348706 :         } else if (!rs2) {
    1847      345759 :                 assert(!symmetric);
    1848      345759 :                 if (ls->card < rs->card) {
    1849       12636 :                         sql_exp *swap = ls;
    1850       12636 :                         ls = rs;
    1851       12636 :                         rs = swap;
    1852       12636 :                         type = (int)swap_compare((comp_type)type);
    1853             :                 }
    1854      345759 :                 if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
    1855             :                         return NULL;
    1856      345756 :                 e = exp_compare(sql->sa, ls, rs, type);
    1857      345756 :                 if (is_semantics) set_semantics(e);
    1858             :         } else {
    1859        2947 :                 assert(rs2);
    1860        2947 :                 if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
    1861             :                         return NULL;
    1862        2947 :                 if (!(rs2 = exp_check_type(sql, exp_subtype(ls), rel, rs2, type_equal)))
    1863             :                         return NULL;
    1864        2947 :                 e = exp_compare2(sql->sa, ls, rs, rs2, type, symmetric);
    1865             :         }
    1866      348703 :         if (anti)
    1867         847 :                 set_anti(e);
    1868             : 
    1869      348703 :         if (!rel)
    1870           0 :                 return rel_select(sql->sa, rel_project_exp(sql, exp_atom_bool(sql->sa, 1)), e);
    1871             : 
    1872             :         /* atom or row => select */
    1873      348703 :         if (ls->card > rel->card || rs->card > rel->card || (rs2 && rs2->card > rel->card)) {
    1874           0 :                 sql_exp *e = ls->card > rel->card ? ls : rs->card > rel->card ? rs : rs2;
    1875           0 :                 if (exp_name(e) && !has_label(e))
    1876           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(e));
    1877           0 :                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    1878             :         }
    1879      348703 :         return rel_select_push_compare_exp_down(sql, rel, e, ls, rs, rs2, f);
    1880             : }
    1881             : 
    1882             : static sql_rel *
    1883      349058 : rel_compare_exp(sql_query *query, sql_rel *rel, sql_exp *ls, sql_exp *rs, char *compare_op, int reduce, int quantifier, int need_not, int f, int is_semantics)
    1884             : {
    1885      349058 :         mvc *sql = query->sql;
    1886      349058 :         comp_type type = cmp_equal;
    1887             : 
    1888      349058 :         if (!ls || !rs)
    1889             :                 return NULL;
    1890             : 
    1891      349058 :         if (!quantifier && ((!rel && !query_has_outer(query)) || !reduce)) {
    1892             :                 /* TODO to handle filters here */
    1893           0 :                 sql_exp *e;
    1894             : 
    1895           0 :                 if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
    1896             :                         return NULL;
    1897           0 :                 e = rel_binop_(sql, rel, ls, rs, "sys", compare_op, card_value, true);
    1898             : 
    1899           0 :                 if (!e)
    1900             :                         return NULL;
    1901           0 :                 if (!reduce) {
    1902           0 :                         if (rel->op == op_project) {
    1903           0 :                                 append(rel->exps, e);
    1904             :                         } else {
    1905           0 :                                 list *exps = new_exp_list(sql->sa);
    1906             : 
    1907           0 :                                 append(exps, e);
    1908           0 :                                 return rel_project(sql->sa, rel, exps);
    1909             :                         }
    1910             :                 } else {
    1911           0 :                         return rel_select(sql->sa, rel, e);
    1912             :                 }
    1913             :         }
    1914      349058 :         type = compare_str2type(compare_op);
    1915      349058 :         assert(type != cmp_filter);
    1916      349058 :         return rel_compare_exp_(query, rel, ls, rs, NULL, type, need_not, quantifier, f, 0, is_semantics);
    1917             : }
    1918             : 
    1919             : static sql_rel *
    1920      349038 : rel_compare(sql_query *query, sql_rel *rel, symbol *sc, symbol *lo, symbol *ro, char *compare_op, int f, exp_kind k, int quantifier, int is_semantics)
    1921             : {
    1922      349038 :         mvc *sql = query->sql;
    1923      349038 :         sql_exp *rs = NULL, *ls;
    1924      349038 :         comp_type cmp_type = compare_str2type(compare_op);
    1925      349038 :         exp_kind ek = {type_value, card_column, FALSE};
    1926      349038 :         int need_not = 0;
    1927             : 
    1928      349038 :         if ((quantifier == 1 && cmp_type == cmp_equal) ||
    1929      349003 :             (quantifier == 2 && cmp_type == cmp_notequal)) {
    1930          63 :                 dnode *n = sc->data.lval->h;
    1931          63 :                 dlist *dl = dlist_create(sql->sa);
    1932             :                 /* map into IN/NOT IN */
    1933          63 :                 sc->token = cmp_type==cmp_equal?SQL_IN:SQL_NOT_IN;
    1934          63 :                 n->next->type = type_list;
    1935          63 :                 n->next->data.lval = dl;
    1936          63 :                 n->next->next->next = NULL; /* remove quantifier */
    1937          63 :                 dl->h = n->next->next;
    1938          63 :                 n->next->next = NULL; /* (remove comparison) moved righthand side */
    1939          63 :                 return rel_logical_exp(query, rel, sc, f);
    1940             :         }
    1941             :         /* <> ANY -> NOT (= ALL) */
    1942      348975 :         if (quantifier == 1 && cmp_type == cmp_notequal) {
    1943           5 :                 need_not = 1;
    1944           5 :                 quantifier = 2;
    1945           5 :                 cmp_type = cmp_equal;
    1946           5 :                 compare_op = "=";
    1947             :         }
    1948             : 
    1949      348975 :         if ((lo->token == SQL_SELECT || lo->token == SQL_UNION || lo->token == SQL_EXCEPT || lo->token == SQL_INTERSECT || lo->token == SQL_VALUES) &&
    1950          43 :                 (ro->token != SQL_SELECT && ro->token != SQL_UNION && ro->token != SQL_EXCEPT && ro->token != SQL_INTERSECT && ro->token != SQL_VALUES)) {
    1951          30 :                 symbol *tmp = lo; /* swap subquery to the right hand side */
    1952             : 
    1953          30 :                 lo = ro;
    1954          30 :                 ro = tmp;
    1955             : 
    1956          30 :                 if (compare_op[0] == '>')
    1957          16 :                         compare_op[0] = '<';
    1958          14 :                 else if (compare_op[0] == '<' && compare_op[1] != '>')
    1959           1 :                         compare_op[0] = '>';
    1960          30 :                 cmp_type = swap_compare(cmp_type);
    1961             :         }
    1962             : 
    1963      348975 :         ls = rel_value_exp(query, &rel, lo, f|sql_farg, ek);
    1964      348975 :         if (!ls)
    1965             :                 return NULL;
    1966      348926 :         if (ls && rel && exp_has_freevar(sql, ls) && is_sql_sel(f))
    1967           0 :                 ls = rel_project_add_exp(sql, rel, ls);
    1968      348926 :         if (quantifier)
    1969          58 :                 ek.card = card_set;
    1970             : 
    1971      348926 :         rs = rel_value_exp(query, &rel, ro, f|sql_farg, ek);
    1972      348926 :         if (!rs)
    1973             :                 return NULL;
    1974      348898 :         if (ls->card > rs->card && rs->card == CARD_AGGR && is_sql_having(f)) {
    1975           0 :                 if (exp_name(ls) && exp_relname(ls) && !has_label(ls))
    1976           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(ls), exp_name(ls));
    1977           0 :                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    1978             :         }
    1979      348898 :         if (rs->card > ls->card && ls->card == CARD_AGGR && is_sql_having(f)) {
    1980           0 :                 if (exp_name(rs) && exp_relname(rs) && !has_label(rs))
    1981           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(rs), exp_name(rs));
    1982           0 :                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    1983             :         }
    1984      348898 :         return rel_compare_exp(query, rel, ls, rs, compare_op, k.reduce, quantifier, need_not, f, is_semantics);
    1985             : }
    1986             : 
    1987             : static sql_exp*
    1988       78858 : _rel_nop(mvc *sql, char *sname, char *fname, list *tl, sql_rel *rel, list *exps, exp_kind ek)
    1989             : {
    1990       78858 :         bool found = false;
    1991       78858 :         int table_func = (ek.card == card_relation);
    1992       78858 :         sql_ftype type = (ek.card == card_loader)?F_LOADER:((ek.card == card_none)?F_PROC:
    1993             :                    ((ek.card == card_relation)?F_UNION:F_FUNC));
    1994             : 
    1995       78858 :         sql_subfunc *f = bind_func_(sql, sname, fname, tl, type, false, &found, false);
    1996       78858 :         if (f && !(exps = check_arguments_and_find_largest_any_type(sql, rel, exps, f, table_func, false)))
    1997             :                 f = NULL;
    1998             : 
    1999       78842 :         if (f)
    2000       78842 :                 return exp_op(sql->sa, exps, f);
    2001          16 :         char *arg_list = nary_function_arg_types_2str(sql, tl, list_length(tl));
    2002          32 :         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s operator %s%s%s'%s'(%s)",
    2003          16 :                                          found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname, arg_list ? arg_list : "");
    2004             : }
    2005             : 
    2006             : static sql_exp *
    2007        2053 : exp_exist(sql_query *query, sql_rel *rel, sql_exp *le, int exists)
    2008             : {
    2009        2053 :         mvc *sql = query->sql;
    2010        2053 :         sql_subfunc *exists_func = NULL;
    2011        2053 :         sql_subtype *t;
    2012        2053 :         sql_exp *res;
    2013             : 
    2014        2053 :         if (!exp_name(le))
    2015         753 :                 exp_label(sql->sa, le, ++sql->label);
    2016        2053 :         if (exp_is_rel(le)) { /* for the subquery case, propagate to the inner query */
    2017        2053 :                 sql_rel *r = exp_rel_get_rel(sql->sa, le);
    2018        2053 :                 if (is_project(r->op) && !list_empty(r->exps)) {
    2019        5862 :                         for (node *n = r->exps->h; n; n = n->next)
    2020        3809 :                                 if (!exp_subtype(n->data) && rel_set_type_param(sql, sql_bind_localtype("bit"), r, n->data, 0) < 0) /* workaround */
    2021             :                                         return NULL;
    2022        2053 :                         le->tpe = *exp_subtype(r->exps->h->data); /* just take the first expression type */
    2023             :                 }
    2024           0 :         } else if (!exp_subtype(le) && rel_set_type_param(sql, sql_bind_localtype("bit"), rel, le, 0) < 0) /* workaround */
    2025             :                 return NULL;
    2026        2053 :         t = exp_subtype(le);
    2027             : 
    2028        2114 :         if (!(exists_func = sql_bind_func(sql, "sys", exists ? "sql_exists" : "sql_not_exists", t, NULL, F_FUNC, true, true)))
    2029           0 :                 return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "exist operator on type %s missing", t ? t->type->base.name : "unknown");
    2030        2053 :         res = exp_unop(sql->sa, le, exists_func);
    2031        2053 :         set_has_no_nil(res);
    2032        2053 :         return res;
    2033             : }
    2034             : 
    2035             : static sql_exp *
    2036        1073 : rel_exists_value_exp(sql_query *query, sql_rel **rel, symbol *sc, int f)
    2037             : {
    2038        1073 :         exp_kind ek = {type_value, card_exists, FALSE};
    2039        1073 :         sql_exp *le, *e;
    2040             : 
    2041        1073 :         le = rel_value_exp(query, rel, sc->data.sym, f|sql_farg, ek);
    2042        1073 :         if (!le)
    2043             :                 return NULL;
    2044        1072 :         if (!(e = exp_exist(query, rel ? *rel : NULL, le, sc->token == SQL_EXISTS)))
    2045             :                 return NULL;
    2046             :         /* only freevar should have CARD_AGGR */
    2047        1072 :         e->card = CARD_ATOM;
    2048        1072 :         return e;
    2049             : }
    2050             : 
    2051             : static sql_rel *
    2052         987 : rel_exists_exp(sql_query *query, sql_rel *rel, symbol *sc, int f)
    2053             : {
    2054         987 :         exp_kind ek = {type_value, card_exists, TRUE};
    2055         987 :         mvc *sql = query->sql;
    2056         987 :         sql_rel *sq = NULL;
    2057             : 
    2058         987 :         if (is_psm_call(f) || is_sql_merge(f))
    2059           3 :                 return sql_error(sql, 02, SQLSTATE(42000) "%s: subqueries not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
    2060         986 :         if (rel) {
    2061         986 :                 query_processed(query);
    2062         986 :                 query_push_outer(query, rel, f);
    2063             :         }
    2064         986 :         sq = rel_subquery(query, sc->data.sym, ek);
    2065         986 :         if (rel)
    2066         986 :                 rel = query_pop_outer(query);
    2067         986 :         assert(!is_sql_sel(f));
    2068         986 :         if (sq) {
    2069         981 :                 sql_exp *e = exp_rel(sql, sq);
    2070         981 :                 if (!(e = exp_exist(query, rel, e, sc->token == SQL_EXISTS)))
    2071             :                         return NULL;
    2072             :                 /* only freevar should have CARD_AGGR */
    2073         981 :                 e->card = CARD_ATOM;
    2074         981 :                 rel = rel_select_add_exp(sql->sa, rel, e);
    2075         981 :                 return rel;
    2076             :         }
    2077             :         return NULL;
    2078             : }
    2079             : 
    2080             : static int
    2081        7018 : is_project_true(sql_rel *r)
    2082             : {
    2083        7018 :         if (r && !r->l && list_length(r->exps) == 1) {
    2084          82 :                 sql_exp *e = r->exps->h->data;
    2085          82 :                 if (exp_is_atom(e) && exp_is_true(e))
    2086             :                         return 1;
    2087             :         }
    2088             :         return 0;
    2089             : }
    2090             : 
    2091             : static sql_exp *
    2092       62285 : rel_in_value_exp(sql_query *query, sql_rel **rel, symbol *sc, int f)
    2093             : {
    2094       62285 :         mvc *sql = query->sql;
    2095       62285 :         exp_kind ek = {type_value, card_column, TRUE};
    2096       62285 :         dlist *dl = sc->data.lval;
    2097       62285 :         symbol *lo = NULL;
    2098       62285 :         dnode *n = dl->h->next, *dn = NULL;
    2099       62285 :         sql_exp *le = NULL, *re, *e = NULL;
    2100       62285 :         list *ll = sa_list(sql->sa);
    2101       62285 :         int is_tuple = 0, add_select = 0;
    2102             : 
    2103             :         /* complex case */
    2104       62285 :         if (dl->h->type == type_list) { /* (a,b..) in (.. ) */
    2105        4109 :                 dn = dl->h->data.lval->h;
    2106        4109 :                 lo = dn->data.sym;
    2107        4109 :                 dn = dn->next;
    2108             :         } else {
    2109       58176 :                 lo = dl->h->data.sym;
    2110             :         }
    2111      197155 :         for( ; lo; lo = dn?dn->data.sym:NULL, dn = dn?dn->next:NULL ) {
    2112       67439 :                 le = rel_value_exp(query, rel, lo, f|sql_farg, ek);
    2113       67439 :                 if (!le)
    2114             :                         return NULL;
    2115       67435 :                 append(ll, le);
    2116             :         }
    2117       62281 :         if (list_length(ll) == 1) {
    2118       58172 :                 le = ll->h->data;
    2119       58172 :                 ek.card = card_set;
    2120             :         } else {
    2121        4109 :                 le = exp_values(sql->sa, ll);
    2122        4109 :                 exp_label(sql->sa, le, ++sql->label);
    2123        4109 :                 ek.type = list_length(ll);
    2124        4109 :                 is_tuple = list_length(ll);
    2125             :         }
    2126             :         /* list of values or subqueries */
    2127             :         /* 3 right hand side cases,
    2128             :          *      1 - value/tuple list of atoms
    2129             :          *      2 - list of scalar sub queries (needs check on 1 row/column per query)
    2130             :          *      3 - single tabular ie. multi column, multi row query
    2131             :          */
    2132       62281 :         if (n->type == type_list) {
    2133       62281 :                 sql_exp *values;
    2134       62281 :                 list *vals = sa_list(sql->sa);
    2135             : 
    2136       62281 :                 n = dl->h->next;
    2137       62281 :                 n = n->data.lval->h;
    2138             : 
    2139      309001 :                 for (; n; n = n->next) {
    2140      246752 :                         if (n->type == type_list) {
    2141           3 :                                 dnode *m = n->data.lval->h;
    2142           3 :                                 list *rl = sa_list(sql->sa);
    2143          12 :                                 for (; m; m = m->next) {
    2144           6 :                                         assert(m->type == type_symbol);
    2145           6 :                                         sql_exp *re = rel_value_exp(query, rel, m->data.sym, f|sql_farg, ek);
    2146           6 :                                         if (!re)
    2147             :                                                 return NULL;
    2148           6 :                                         append(rl, re);
    2149             :                                 }
    2150           3 :                                 re = exp_values(sql->sa, rl);
    2151             :                         } else {
    2152      246749 :                                 assert(n->type == type_symbol);
    2153      246749 :                                 re = rel_value_exp(query, rel, n->data.sym, f|sql_farg, ek);
    2154             :                         }
    2155      246752 :                         if (!re)
    2156             :                                 return NULL;
    2157      246729 :                         if (is_tuple && (!exp_is_rel(re) && !is_values(re)))
    2158           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "Cannot match a tuple to a single value");
    2159        8210 :                         if (is_tuple && exp_is_rel(re)) {
    2160        4108 :                                 sql_rel *r = exp_rel_get_rel(sql->sa, re);
    2161             : 
    2162        4108 :                                 if (!r)
    2163           0 :                                         return sql_error(sql, 02, SQLSTATE(42000) "Subquery missing");
    2164        4108 :                                 if (r->nrcols != ek.type)
    2165          12 :                                         return sql_error(sql, 02, SQLSTATE(42000) "Subquery has too %s columns", (r->nrcols < ek.type) ? "few" : "many");
    2166        4099 :                                 re = exp_rel_label(sql, re);
    2167      242621 :                         } else if (exp_is_rel(re)) {
    2168        7019 :                                 sql_rel *r = exp_rel_get_rel(sql->sa, re);
    2169        7019 :                                 add_select = 1;
    2170        7019 :                                 if (rel && *rel && is_join((*rel)->op))
    2171        2935 :                                         set_dependent((*rel));
    2172        7019 :                                 if (is_project(r->op) && is_project_true(r->l) && list_length(r->exps) == 1)
    2173          80 :                                         re = r->exps->h->data;
    2174      235602 :                         } else if (is_values(re) && is_tuple != list_length(exp_get_values(re))) {
    2175           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "Tuple sizes do not match");
    2176             :                         }
    2177      246720 :                         append(vals, re);
    2178             :                 }
    2179             : 
    2180       62249 :                 if (list_empty(vals))
    2181           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "The list of values for IN operator cannot be empty");
    2182             : 
    2183       62249 :                 values = exp_values(sql->sa, vals);
    2184       62249 :                 exp_label(sql->sa, values, ++sql->label);
    2185       62249 :                 if (is_tuple) {
    2186        4100 :                         if (!(values = exp_tuples_set_supertype(sql, exp_get_values(le), values)))
    2187             :                                 return NULL;
    2188        4100 :                         if (!(le->f = tuples_check_types(sql, exp_get_values(le), values)))
    2189             :                                 return NULL;
    2190             :                 } else { /* if it's not a tuple, enforce coercion on the type for every element on the list */
    2191       58149 :                         sql_subtype super, *le_tpe = exp_subtype(le), *values_tpe = NULL;
    2192             : 
    2193      300766 :                         for (node *m = vals->h; m; m = m->next) { /* first get values supertype */
    2194      242617 :                                 sql_exp *e = m->data;
    2195      242617 :                                 sql_subtype *tpe = exp_subtype(e);
    2196             : 
    2197      242617 :                                 if (values_tpe && tpe) {
    2198      184465 :                                         cmp_supertype(&super, values_tpe, tpe);
    2199      184465 :                                         *values_tpe = super;
    2200       58152 :                                 } else if (!values_tpe && tpe) {
    2201       58145 :                                         super = *tpe;
    2202       58145 :                                         values_tpe = &super;
    2203             :                                 }
    2204             :                         }
    2205       58149 :                         if (!le_tpe)
    2206           2 :                                 le_tpe = values_tpe;
    2207       58149 :                         if (!values_tpe)
    2208           4 :                                 values_tpe = le_tpe;
    2209       58149 :                         if (!le_tpe || !values_tpe)
    2210           1 :                                 return sql_error(sql, 01, SQLSTATE(42000) "For the IN operator, both sides must have a type defined");
    2211       58148 :                         cmp_supertype(&super, values_tpe, le_tpe); /* compute supertype */
    2212             : 
    2213             :                         /* on selection/join cases we can generate cmp expressions instead of anyequal for trivial cases */
    2214       58148 :                         if ((is_sql_where(f) || is_sql_having(f)) && !is_sql_farg(f) && !exp_has_rel(le) && exps_are_atoms(vals)) {
    2215       23997 :                                 if (list_length(vals) == 1) { /* use cmp_equal instead of cmp_in for 1 expression */
    2216         115 :                                         sql_exp *first = vals->h->data;
    2217         115 :                                         if (rel_convert_types(sql, rel ? *rel : NULL, rel ? *rel : NULL, &le, &first, 1, type_equal_no_any) < 0)
    2218           0 :                                                 return NULL;
    2219         140 :                                         e = exp_compare(sql->sa, le, first, (sc->token == SQL_IN) ? cmp_equal : cmp_notequal);
    2220             :                                 } else { /* use cmp_in instead of anyequal for n simple expressions */
    2221      120760 :                                         for (node *n = vals->h ; n ; n = n->next)
    2222       96878 :                                                 if ((n->data = exp_check_type(sql, &super, rel ? *rel : NULL, n->data, type_equal)) == NULL)
    2223             :                                                         return NULL;
    2224       23882 :                                         if ((le = exp_check_type(sql, &super, rel ? *rel : NULL, le, type_equal)) == NULL)
    2225             :                                                 return NULL;
    2226       32476 :                                         e = exp_in(sql->sa, le, vals, (sc->token == SQL_IN) ? cmp_in : cmp_notin);
    2227             :                                 }
    2228             :                         }
    2229       23997 :                         if (!e) { /* after computing supertype, check types for each IN value */
    2230      179774 :                                 for (node *n = vals->h ; n ; n = n->next)
    2231      145623 :                                         if ((n->data = exp_check_type(sql, &super, rel ? *rel : NULL, n->data, type_equal)) == NULL)
    2232             :                                                 return NULL;
    2233       34151 :                                 values->tpe = *exp_subtype(vals->h->data);
    2234       34151 :                                 if (!(le = exp_check_type(sql, &super, rel ? *rel : NULL, le, type_equal)))
    2235             :                                         return NULL;
    2236             :                         }
    2237             :                 }
    2238       58148 :                 if (!e) {
    2239       38251 :                         if (add_select && rel && *rel && !is_project((*rel)->op) && !is_select((*rel)->op) && !is_base((*rel)->op))
    2240        2934 :                                 *rel = rel_select(sql->sa, *rel, NULL);
    2241       38251 :                         if ((rel && *rel) || exp_has_rel(le) || exp_has_rel(values))
    2242       32689 :                                 e = exp_in_func(sql, le, values, (sc->token == SQL_IN), is_tuple);
    2243             :                         else
    2244        5562 :                                 e = exp_in_aggr(sql, le, values, (sc->token == SQL_IN), is_tuple);
    2245             :                 }
    2246             :         }
    2247             :         return e;
    2248             : }
    2249             : 
    2250             : static sql_rel *
    2251       32581 : rel_in_exp(sql_query *query, sql_rel *rel, symbol *sc, int f)
    2252             : {
    2253       32581 :         mvc *sql = query->sql;
    2254       32581 :         sql_exp *e = rel_in_value_exp(query, &rel, sc, f);
    2255             : 
    2256       32581 :         assert(!is_sql_sel(f));
    2257       32581 :         if (!e || !rel)
    2258             :                 return NULL;
    2259             : 
    2260       32557 :         if (e->type == e_cmp) { /* it's a exp_in or cmp_equal of simple expressions, push down early on if possible */
    2261       23995 :                 sql_exp *ls = e->l;
    2262       23995 :                 bool rlist = (e->flag == cmp_in || e->flag == cmp_notin);
    2263       23995 :                 unsigned int rcard = rlist ? exps_card(e->r) : exp_card(e->r);
    2264       23995 :                 int r_is_atoms = rlist ? exps_are_atoms(e->r) : exp_is_atom(e->r);
    2265       23995 :                 int r_has_freevar = rlist ? exps_have_freevar(sql, e->r) : exp_has_freevar(sql, e->r);
    2266             : 
    2267       23995 :                 if (rcard <= CARD_ATOM && (r_is_atoms || r_has_freevar || exp_has_freevar(sql, ls))) {
    2268       23995 :                         if ((exp_card(ls) == rcard) || rel->processed) /* bin compare op */
    2269        5386 :                                 return rel_select(sql->sa, rel, e);
    2270             : 
    2271       18609 :                         return push_select_exp(sql, rel, e, ls, f);
    2272             :                 } else { /* join */
    2273           0 :                         sql_exp *rs = rlist ? exps_find_one_multi_exp(e->r) : e->r;
    2274           0 :                         if (rs)
    2275           0 :                                 return push_join_exp(sql, rel, e, ls, rs, NULL, f);
    2276             :                 }
    2277             :         }
    2278        8562 :         if (is_outerjoin(rel->op))
    2279          13 :                 return rel_select(sql->sa, rel, e);
    2280        8549 :         return rel_select_add_exp(sql->sa, rel, e);
    2281             : }
    2282             : 
    2283             : static bool
    2284       52581 : not_symbol_can_be_propagated(mvc *sql, symbol *sc)
    2285             : {
    2286       52581 :         switch (sc->token) {
    2287             :         case SQL_IN:
    2288             :         case SQL_NOT_IN:
    2289             :         case SQL_EXISTS:
    2290             :         case SQL_NOT_EXISTS:
    2291             :         case SQL_LIKE:
    2292             :         case SQL_NOT_LIKE:
    2293             :         case SQL_BETWEEN:
    2294             :         case SQL_NOT_BETWEEN:
    2295             :         case SQL_IS_NULL:
    2296             :         case SQL_IS_NOT_NULL:
    2297             :         case SQL_NOT:
    2298             :         case SQL_COMPARE:
    2299             :                 return true;
    2300        6822 :         case SQL_AND:
    2301             :         case SQL_OR: {
    2302        6822 :                 symbol *lo = sc->data.lval->h->data.sym;
    2303        6822 :                 symbol *ro = sc->data.lval->h->next->data.sym;
    2304        6826 :                 return not_symbol_can_be_propagated(sql, lo) && not_symbol_can_be_propagated(sql, ro);
    2305             :         }
    2306       36511 :         default:
    2307       36511 :                 return false;
    2308             :         }
    2309             : }
    2310             : 
    2311             : /* Warning, this function assumes the entire bison tree can be negated, so call it after 'not_symbol_can_be_propagated' */
    2312             : static symbol *
    2313       16065 : negate_symbol_tree(mvc *sql, symbol *sc)
    2314             : {
    2315       16065 :         switch (sc->token) {
    2316        1454 :         case SQL_IN:
    2317        1454 :                 sc->token = SQL_NOT_IN;
    2318        1454 :                 break;
    2319          22 :         case SQL_NOT_IN:
    2320          22 :                 sc->token = SQL_IN;
    2321          22 :                 break;
    2322           0 :         case SQL_EXISTS:
    2323           0 :                 sc->token = SQL_NOT_EXISTS;
    2324           0 :                 break;
    2325           0 :         case SQL_NOT_EXISTS:
    2326           0 :                 sc->token = SQL_EXISTS;
    2327           0 :                 break;
    2328           7 :         case SQL_LIKE:
    2329           7 :                 sc->token = SQL_NOT_LIKE;
    2330           7 :                 break;
    2331           0 :         case SQL_NOT_LIKE:
    2332           0 :                 sc->token = SQL_LIKE;
    2333           0 :                 break;
    2334          17 :         case SQL_BETWEEN:
    2335          17 :                 sc->token = SQL_NOT_BETWEEN;
    2336          17 :                 break;
    2337          11 :         case SQL_NOT_BETWEEN:
    2338          11 :                 sc->token = SQL_BETWEEN;
    2339          11 :                 break;
    2340          32 :         case SQL_IS_NULL:
    2341          32 :                 sc->token = SQL_IS_NOT_NULL;
    2342          32 :                 break;
    2343          15 :         case SQL_IS_NOT_NULL:
    2344          15 :                 sc->token = SQL_IS_NULL;
    2345          15 :                 break;
    2346          27 :         case SQL_NOT: { /* nested NOTs eliminate each other */
    2347          27 :                 if (sc->data.sym->token == SQL_ATOM) {
    2348           5 :                         AtomNode *an = (AtomNode*) sc->data.sym;
    2349           5 :                         sc = newAtomNode(sql->sa, an->a);
    2350          22 :                 } else if (sc->data.sym->token == SQL_SELECT) {
    2351           2 :                         SelectNode *sn = (SelectNode*) sc->data.sym;
    2352           2 :                         sc = newSelectNode(sql->sa, sn->distinct, sn->selection, sn->into, sn->from, sn->where, sn->groupby, sn->having,
    2353             :                                                            sn->orderby, sn->name, sn->limit, sn->offset, sn->sample, sn->seed, sn->window);
    2354             :                 } else {
    2355          20 :                         memmove(sc, sc->data.sym, sizeof(symbol));
    2356             :                 }
    2357             :         } break;
    2358        7662 :         case SQL_COMPARE: {
    2359        7662 :                 dnode *cmp_n = sc->data.lval->h;
    2360        7662 :                 comp_type neg_cmp_type = negate_compare(compare_str2type(cmp_n->next->data.sval)); /* negate the comparator */
    2361        7662 :                 if (cmp_n->next->next->next) {
    2362          22 :                         switch(cmp_n->next->next->next->data.i_val)
    2363             :                         {
    2364          12 :                         case 0: /* negating ANY/ALL */
    2365          12 :                                 cmp_n->next->next->next->data.i_val = 1;
    2366          12 :                                 break;
    2367           7 :                         case 1: /* negating ANY/ALL */
    2368           7 :                                 cmp_n->next->next->next->data.i_val = 0;
    2369           7 :                                 break;
    2370           2 :                         case 2: /* negating IS [NOT] DINSTINCT FROM */
    2371           2 :                                 cmp_n->next->next->next->data.i_val = 3;
    2372           2 :                                 break;
    2373           1 :                         case 3: /* negating IS [NOT] DINSTINCT FROM */
    2374           1 :                                 cmp_n->next->next->next->data.i_val = 2;
    2375           1 :                                 break;
    2376             :                         }
    2377             :                 }
    2378        7662 :                 cmp_n->next->data.sval = sa_strdup(sql->sa, compare_func(neg_cmp_type, 0));
    2379        7662 :         } break;
    2380        6818 :         case SQL_AND:
    2381             :         case SQL_OR: {
    2382        6818 :                 sc->data.lval->h->data.sym = negate_symbol_tree(sql, sc->data.lval->h->data.sym);
    2383        6818 :                 sc->data.lval->h->next->data.sym= negate_symbol_tree(sql, sc->data.lval->h->next->data.sym);
    2384        6818 :                 sc->token = sc->token == SQL_AND ? SQL_OR : SQL_AND;
    2385        6818 :         } break;
    2386             :         default:
    2387             :                 break;
    2388             :         }
    2389       16065 :         return sc;
    2390             : }
    2391             : 
    2392             : static int
    2393        3111 : exp_between_check_types(sql_subtype *res, sql_subtype *t1, sql_subtype *t2, sql_subtype *t3)
    2394             : {
    2395        3111 :         bool type_found = false;
    2396        3111 :         sql_subtype super;
    2397             : 
    2398        3111 :         if (t1 && t2) {
    2399        3105 :                 cmp_supertype(&super, t2, t1);
    2400        3105 :                 type_found = true;
    2401           6 :         } else if (t1) {
    2402           3 :                 super = *t1;
    2403           3 :                 type_found = true;
    2404           3 :         } else if (t2) {
    2405           1 :                 super = *t2;
    2406           1 :                 type_found = true;
    2407             :         }
    2408        3111 :         if (t3) {
    2409        3108 :                 if (type_found)
    2410        3107 :                         cmp_supertype(&super, t3, &super);
    2411             :                 else
    2412           1 :                         super = *t3;
    2413             :                 type_found = true;
    2414             :         }
    2415           3 :         if (!type_found)
    2416             :                 return -1;
    2417        3110 :         *res = super;
    2418        3110 :         return 0;
    2419             : }
    2420             : 
    2421             : static bool
    2422      116670 : exp_is_null_no_value_opt(sql_exp *e)
    2423             : {
    2424      116670 :         if (!e)
    2425             :                 return false;
    2426      120584 :         while (is_convert(e->type))
    2427        3914 :                 e = e->l;
    2428      233313 :         return e->type == e_atom && e->l && atom_null(e->l);
    2429             : }
    2430             : 
    2431             : sql_exp *
    2432     2535857 : rel_logical_value_exp(sql_query *query, sql_rel **rel, symbol *sc, int f, exp_kind ek)
    2433             : {
    2434     2535956 :         mvc *sql = query->sql;
    2435             : 
    2436     2535956 :         if (!sc)
    2437             :                 return NULL;
    2438             : 
    2439     2535956 :         if (mvc_highwater(sql))
    2440           0 :                 return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
    2441             : 
    2442     2535956 :         switch (sc->token) {
    2443       51518 :         case SQL_OR:
    2444             :         case SQL_AND:
    2445             :         {
    2446       51518 :                 symbol *lo = sc->data.lval->h->data.sym;
    2447       51518 :                 symbol *ro = sc->data.lval->h->next->data.sym;
    2448       51518 :                 sql_exp *ls, *rs;
    2449             : 
    2450       51518 :                 if (!(ls = rel_value_exp(query, rel, lo, f|sql_farg, ek)))
    2451             :                         return NULL;
    2452       51517 :                 if (!(rs = rel_value_exp(query, rel, ro, f|sql_farg, ek)))
    2453             :                         return NULL;
    2454       90916 :                 return rel_binop_(sql, rel ? *rel : NULL, ls, rs, "sys", sc->token == SQL_OR ? "or": "and", card_value, false);
    2455             :         }
    2456           5 :         case SQL_FILTER:
    2457             :                 /* [ x,..] filter [ y,..] */
    2458             :                 /* todo add anti, [ x,..] not filter [ y,...] */
    2459             :                 /* no correlation */
    2460             :         {
    2461           5 :                 dnode *ln = sc->data.lval->h->data.lval->h;
    2462           5 :                 dnode *rn = sc->data.lval->h->next->next->data.lval->h;
    2463           5 :                 dlist *filter_op = sc->data.lval->h->next->data.lval;
    2464           5 :                 char *fname = qname_schema_object(filter_op);
    2465           5 :                 char *sname = qname_schema(filter_op);
    2466           5 :                 list *exps, *tl;
    2467           5 :                 sql_subtype *obj_type = NULL;
    2468             : 
    2469           5 :                 exps = sa_list(sql->sa);
    2470           5 :                 tl = sa_list(sql->sa);
    2471          15 :                 for (; ln; ln = ln->next) {
    2472           5 :                         symbol *sym = ln->data.sym;
    2473             : 
    2474           5 :                         sql_exp *e = rel_value_exp(query, rel, sym, f|sql_farg, ek);
    2475           5 :                         if (!e)
    2476             :                                 return NULL;
    2477           5 :                         if (!obj_type)
    2478           5 :                                 obj_type = exp_subtype(e);
    2479           5 :                         list_append(exps, e);
    2480           5 :                         append(tl, exp_subtype(e));
    2481             :                 }
    2482          13 :                 for (; rn; rn = rn->next) {
    2483          10 :                         symbol *sym = rn->data.sym;
    2484             : 
    2485          10 :                         sql_exp *e = rel_value_exp(query, rel, sym, f|sql_farg, ek);
    2486          10 :                         if (!e)
    2487             :                                 return NULL;
    2488           8 :                         list_append(exps, e);
    2489           8 :                         append(tl, exp_subtype(e));
    2490             :                 }
    2491             :                 /* find the predicate filter function */
    2492           3 :                 return _rel_nop(sql, sname, fname, tl, rel ? *rel : NULL, exps, ek);
    2493             :         }
    2494      116386 :         case SQL_COMPARE:
    2495             :         {
    2496      116386 :                 dnode *n = sc->data.lval->h;
    2497      116386 :                 symbol *lo = n->data.sym;
    2498      116386 :                 symbol *ro = n->next->next->data.sym;
    2499      116386 :                 char *compare_op = n->next->data.sval;
    2500      116386 :                 int quantifier = 0, need_not = 0;
    2501      116386 :                 sql_exp *rs = NULL, *ls;
    2502      116386 :                 comp_type cmp_type = compare_str2type(compare_op);
    2503      116386 :                 bool is_not_distinct_from = false;
    2504      116386 :                 bool is_distinct_from = false;
    2505             : 
    2506             :                 /*
    2507             :                  * = ANY -> IN, <> ALL -> NOT( = ANY) -> NOT IN
    2508             :                  * = ALL -> all(groupby(all, nil)), <> ANY -> NOT ( = ALL )
    2509             :                  */
    2510      116386 :                 if (n->next->next->next)
    2511         256 :                         quantifier = n->next->next->next->data.i_val + 1;
    2512         256 :                 assert(quantifier == 0 || quantifier == 1 || quantifier == 2 || quantifier == 3 || quantifier == 4);
    2513             : 
    2514             :                 /* [NOT] DISTINCT FROM */
    2515      116386 :                 if (quantifier == 3) {
    2516             :                                 is_not_distinct_from = true;
    2517             :                                 quantifier = 0;
    2518             :                 }
    2519      116373 :                 else if (quantifier == 4) {
    2520          14 :                                 is_distinct_from = true;
    2521          14 :                                 quantifier = 0;
    2522             :                 }
    2523             : 
    2524      116386 :                 if ((quantifier == 1 && cmp_type == cmp_equal) ||
    2525      116320 :                     (quantifier == 2 && cmp_type == cmp_notequal)) {
    2526          93 :                         dlist *dl = dlist_create(sql->sa);
    2527             :                         /* map into IN/NOT IN */
    2528          93 :                         sc->token = cmp_type==cmp_equal?SQL_IN:SQL_NOT_IN;
    2529          93 :                         n->next->type = type_list;
    2530          93 :                         n->next->data.lval = dl;
    2531          93 :                         n->next->next->next = NULL; /* remove quantifier */
    2532          93 :                         dl->h = n->next->next;
    2533          93 :                         n->next->next = NULL; /* (remove comparison) moved righthand side */
    2534          93 :                         return rel_logical_value_exp(query, rel, sc, f, ek);
    2535             :                 }
    2536             :                 /* <> ANY -> NOT (= ALL) */
    2537      116293 :                 if (quantifier == 1 && cmp_type == cmp_notequal) {
    2538          15 :                         need_not = 1;
    2539          15 :                         quantifier = 2;
    2540          15 :                         cmp_type = cmp_equal;
    2541          15 :                         compare_op = "=";
    2542             :                 }
    2543             : 
    2544      116293 :                 ls = rel_value_exp(query, rel, lo, f|sql_farg, ek);
    2545      116293 :                 if (!ls)
    2546             :                         return NULL;
    2547      116281 :                 if (quantifier)
    2548         136 :                         ek.card = card_set;
    2549             : 
    2550      116281 :                 rs = rel_value_exp(query, rel, ro, f|sql_farg, ek);
    2551      116281 :                 if (!rs)
    2552             :                         return NULL;
    2553             : 
    2554      116271 :                 if (is_distinct_from || is_not_distinct_from) {
    2555          27 :                         if (rel_convert_types(sql, rel ? *rel : NULL, rel ? *rel : NULL, &ls, &rs, 1, type_equal_no_any) < 0)
    2556             :                                 return NULL;
    2557          41 :                         sql_exp* e = exp_compare(sql->sa, ls, rs, is_not_distinct_from?cmp_equal:cmp_notequal);
    2558          27 :                         set_semantics(e);
    2559          27 :                         return e;
    2560             :                 }
    2561             : 
    2562      116244 :                 if (rs->type == e_atom)
    2563      104948 :                         quantifier = 0;
    2564             : 
    2565      116244 :                 if (!exp_is_rel(ls) && !exp_is_rel(rs) && ls->card < rs->card) {
    2566          14 :                         sql_exp *swap = ls; /* has to swap parameters like in the rel_logical_exp case */
    2567          14 :                         ls = rs;
    2568          14 :                         rs = swap;
    2569          14 :                         cmp_type = swap_compare(cmp_type);
    2570             :                 }
    2571             : 
    2572      116244 :                 if (rel_convert_types(sql, rel ? *rel : NULL, rel ? *rel : NULL, &ls, &rs, 1, type_equal_no_any) < 0)
    2573             :                         return NULL;
    2574      116241 :                 if (exp_is_null_no_value_opt(ls) && exp_is_null_no_value_opt(rs))
    2575           7 :                         return exp_atom(sql->sa, atom_general(sql->sa, sql_bind_localtype("bit"), NULL, 0));
    2576             : 
    2577      116234 :                 return exp_compare_func(sql, ls, rs, compare_func(cmp_type, need_not), quantifier);
    2578             :         }
    2579             :         /* Set Member ship */
    2580       29704 :         case SQL_IN:
    2581             :         case SQL_NOT_IN:
    2582       29704 :                 return rel_in_value_exp(query, rel, sc, f);
    2583        1073 :         case SQL_EXISTS:
    2584             :         case SQL_NOT_EXISTS:
    2585        1073 :                 return rel_exists_value_exp(query, rel, sc, f);
    2586         347 :         case SQL_LIKE:
    2587             :         case SQL_NOT_LIKE:
    2588             :         {
    2589         347 :                 symbol *lo = sc->data.lval->h->data.sym;
    2590         347 :                 symbol *ro = sc->data.lval->h->next->data.sym;
    2591         347 :                 int insensitive = sc->data.lval->h->next->next->data.i_val;
    2592         347 :                 int anti = (sc->token == SQL_NOT_LIKE) != (sc->data.lval->h->next->next->next->data.i_val != 0);
    2593         347 :                 sql_subtype *st = sql_bind_localtype("str");
    2594         347 :                 sql_exp *le = rel_value_exp(query, rel, lo, f|sql_farg, ek), *re, *ee = NULL, *ie = exp_atom_bool(sql->sa, insensitive);
    2595             : 
    2596         347 :                 if (!le)
    2597             :                         return NULL;
    2598             : 
    2599         347 :                 if (!exp_subtype(le))
    2600           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameter not allowed on "
    2601             :                                         "left hand side of LIKE operator");
    2602             : 
    2603         347 :                 lo = ro->data.lval->h->data.sym;
    2604             :                 /* like uses a single string pattern */
    2605         347 :                 ek.card = card_value;
    2606         347 :                 re = rel_value_exp(query, rel, lo, f|sql_farg, ek);
    2607         347 :                 if (!re)
    2608             :                         return NULL;
    2609         343 :                 if ((re = exp_check_type(sql, st, rel ? *rel : NULL, re, type_equal)) == NULL)
    2610           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
    2611         343 :                 if ((le = exp_check_type(sql, st, rel ? *rel : NULL, le, type_equal)) == NULL)
    2612           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
    2613             :                 /* Do we need to escape ? */
    2614         343 :                 if (dlist_length(ro->data.lval) == 2) {
    2615          63 :                         char *escape = ro->data.lval->h->next->data.sval;
    2616          63 :                         ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, escape)));
    2617             :                 } else {
    2618         280 :                         ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, "")));
    2619             :                 }
    2620         573 :                 return rel_nop_(sql, rel ? *rel : NULL, le, re, ee, ie, "sys", anti ? "not_like" : "like", card_value);
    2621             :         }
    2622         164 :         case SQL_BETWEEN:
    2623             :         case SQL_NOT_BETWEEN:
    2624             :         {
    2625         164 :                 symbol *lo = sc->data.lval->h->data.sym;
    2626         164 :                 int symmetric = sc->data.lval->h->next->data.i_val;
    2627         164 :                 symbol *ro1 = sc->data.lval->h->next->next->data.sym;
    2628         164 :                 symbol *ro2 = sc->data.lval->h->next->next->next->data.sym;
    2629         164 :                 sql_exp *le, *re1, *re2;
    2630         164 :                 sql_subtype super;
    2631             : 
    2632         164 :                 assert(sc->data.lval->h->next->type == type_int);
    2633             : 
    2634         164 :                 if (!(le = rel_value_exp(query, rel, lo, f|sql_farg, ek)))
    2635             :                         return NULL;
    2636         163 :                 if (!(re1 = rel_value_exp(query, rel, ro1, f|sql_farg, ek)))
    2637             :                         return NULL;
    2638         160 :                 if (!(re2 = rel_value_exp(query, rel, ro2, f|sql_farg, ek)))
    2639             :                         return NULL;
    2640             : 
    2641         155 :                 if (exp_between_check_types(&super, exp_subtype(le), exp_subtype(re1), exp_subtype(re2)) < 0)
    2642           0 :                         return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
    2643             : 
    2644         155 :                 if ((le = exp_check_type(sql, &super, rel ? *rel:NULL, le, type_equal)) == NULL ||
    2645         155 :                     (re1 = exp_check_type(sql, &super, rel ? *rel:NULL, re1, type_equal)) == NULL ||
    2646         155 :                     (re2 = exp_check_type(sql, &super, rel ? *rel:NULL, re2, type_equal)) == NULL)
    2647           0 :                         return NULL;
    2648             : 
    2649         155 :                 le = exp_compare2(sql->sa, le, re1, re2, 3, symmetric);
    2650         155 :                 if (sc->token == SQL_NOT_BETWEEN)
    2651          56 :                         set_anti(le);
    2652             :                 return le;
    2653             :         }
    2654       16277 :         case SQL_IS_NULL:
    2655             :         case SQL_IS_NOT_NULL:
    2656             :         /* is (NOT) NULL */
    2657             :         {
    2658       16277 :                 sql_exp *le = rel_value_exp(query, rel, sc->data.sym, f|sql_farg, ek);
    2659             : 
    2660       16277 :                 if (!le)
    2661             :                         return NULL;
    2662       20527 :                 le = rel_unop_(sql, rel ? *rel : NULL, le, "sys", sc->token == SQL_IS_NULL ? "isnull" : "isnotnull", card_value);
    2663       16274 :                 if (!le)
    2664             :                         return NULL;
    2665       16274 :                 set_has_no_nil(le);
    2666       16274 :                 return le;
    2667             :         }
    2668       18895 :         case SQL_NOT: {
    2669       18895 :                 if (not_symbol_can_be_propagated(sql, sc->data.sym)) {
    2670          99 :                         sc->data.sym = negate_symbol_tree(sql, sc->data.sym);
    2671          99 :                         return rel_logical_value_exp(query, rel, sc->data.sym, f, ek);
    2672             :                 }
    2673       18796 :                 sql_exp *le = rel_value_exp(query, rel, sc->data.sym, f|sql_farg, ek);
    2674             : 
    2675       18796 :                 if (!le)
    2676             :                         return NULL;
    2677       18795 :                 return rel_unop_(sql, rel ? *rel : NULL, le, "sys", "not", card_value);
    2678             :         }
    2679             :         case SQL_ATOM: {
    2680     2280689 :                 AtomNode *an = (AtomNode *) sc;
    2681     2280689 :                 assert(an && an->a);
    2682     2280689 :                 return exp_atom(sql->sa, an->a);
    2683             :         }
    2684       20381 :         case SQL_IDENT:
    2685             :         case SQL_COLUMN:
    2686       20381 :                 return rel_column_ref(query, rel, sc, f);
    2687         201 :         case SQL_UNION:
    2688             :         case SQL_EXCEPT:
    2689             :         case SQL_INTERSECT: {
    2690         201 :                 sql_rel *sq;
    2691             : 
    2692         201 :                 if (is_psm_call(f) || is_sql_merge(f))
    2693           4 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: subqueries not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
    2694         199 :                 if (rel && *rel)
    2695         141 :                         query_push_outer(query, *rel, f);
    2696         199 :                 sq = rel_setquery(query, sc);
    2697         199 :                 if (rel && *rel) {
    2698         141 :                         *rel = query_pop_outer(query);
    2699         141 :                         if (is_sql_join(f) && is_groupby((*rel)->op)) {
    2700           0 :                                 return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
    2701         141 :                         } else if (is_sql_where(f) && is_groupby((*rel)->op)) {
    2702           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
    2703         141 :                         } else if ((is_sql_update_set(f) || is_sql_psm(f)) && is_groupby((*rel)->op)) {
    2704           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
    2705             :                         }
    2706             :                 }
    2707         199 :                 if (!sq)
    2708             :                         return NULL;
    2709         197 :                 if (ek.type == type_value && ek.card <= card_set && is_project(sq->op) && list_length(sq->exps) > 1)
    2710           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery must return only one column");
    2711         196 :                 if (ek.type == type_relation && is_project(sq->op) && list_length(sq->exps) != ek.type)
    2712           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery has too %s columns", list_length(sq->exps) < ek.type ? "few" : "many");
    2713         302 :                 if (ek.type == type_value && ek.card < card_set && sq->card >= CARD_AGGR && (is_sql_sel(f) | is_sql_having(f) | is_sql_farg(f) |
    2714         106 :                         ( is_sql_where(f) && rel && (!*rel || is_basetable((*rel)->op) || is_simple_project((*rel)->op) || is_joinop((*rel)->op)))))
    2715         106 :                         sq = rel_zero_or_one(sql, sq, ek);
    2716         196 :                 return exp_rel(sql, sq);
    2717             :         }
    2718           1 :         case SQL_DEFAULT:
    2719           1 :                 return sql_error(sql, 02, SQLSTATE(42000) "DEFAULT keyword not allowed outside insert and update statements");
    2720         315 :         default: {
    2721         315 :                 sql_exp *le = rel_value_exp(query, rel, sc, f|sql_farg, ek);
    2722         315 :                 sql_subtype bt;
    2723             : 
    2724         315 :                 if (!le)
    2725             :                         return NULL;
    2726         313 :                 sql_find_subtype(&bt, "boolean", 0, 0);
    2727         313 :                 if ((le = exp_check_type(sql, &bt, rel ? *rel : NULL, le, type_equal)) == NULL)
    2728             :                         return NULL;
    2729         313 :                 return rel_binop_(sql, rel ? *rel : NULL, le, exp_atom_bool(sql->sa, 1), "sys", "=", 0, true);
    2730             :         }
    2731             :         }
    2732             :         /* never reached, as all switch cases have a `return` */
    2733             : }
    2734             : 
    2735             : sql_rel *
    2736      631982 : rel_logical_exp(sql_query *query, sql_rel *rel, symbol *sc, int f)
    2737             : {
    2738      631982 :         mvc *sql = query->sql;
    2739      631982 :         exp_kind ek = {type_value, card_column, TRUE};
    2740             : 
    2741      631982 :         if (!sc)
    2742             :                 return NULL;
    2743             : 
    2744      631982 :         if (mvc_highwater(sql))
    2745           0 :                 return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
    2746             : 
    2747      631982 :         switch (sc->token) {
    2748       18966 :         case SQL_OR:
    2749             :         {
    2750       18966 :                 list *exps = NULL, *lexps = NULL, *rexps = NULL;
    2751       18966 :                 symbol *lo = sc->data.lval->h->data.sym;
    2752       18966 :                 symbol *ro = sc->data.lval->h->next->data.sym;
    2753       18966 :                 sql_rel *lr, *rr;
    2754             : 
    2755       18966 :                 if (!rel)
    2756             :                         return NULL;
    2757             : 
    2758       18966 :                 lr = rel;
    2759       18966 :                 rr = rel_dup(lr);
    2760             : 
    2761       18966 :                 if (is_outerjoin(rel->op) && !is_processed(rel)) {
    2762          44 :                         exps = rel->exps;
    2763             : 
    2764          44 :                         lr = rel_select_copy(sql->sa, lr, sa_list(sql->sa));
    2765          44 :                         lr = rel_logical_exp(query, lr, lo, f | sql_or);
    2766          44 :                         if (!lr)
    2767             :                                 return NULL;
    2768          43 :                         query_processed(query);
    2769          43 :                         rr = rel_select_copy(sql->sa, rr, sa_list(sql->sa));
    2770          43 :                         rr = rel_logical_exp(query, rr, ro, f | sql_or);
    2771          43 :                         if (!rr)
    2772             :                                 return NULL;
    2773          42 :                         if (lr->l == rr->l) {
    2774          42 :                                 lexps = lr->exps;
    2775          42 :                                 lr = lr->l;
    2776          42 :                                 rexps = rr->exps;
    2777          42 :                                 rr = rr->l;
    2778             :                         }
    2779          42 :                         rel = NULL;
    2780             :                 } else {
    2781       18922 :                         lr = rel_logical_exp(query, lr, lo, f | sql_or);
    2782       18922 :                         if (!lr)
    2783             :                                 return NULL;
    2784       18920 :                         rr = rel_logical_exp(query, rr, ro, f | sql_or);
    2785             :                 }
    2786             : 
    2787       18962 :                 if (!lr || !rr)
    2788             :                         return NULL;
    2789       18962 :                 return rel_or(sql, rel, lr, rr, exps, lexps, rexps);
    2790             :         }
    2791      191771 :         case SQL_AND:
    2792             :         {
    2793      191771 :                 symbol *lo = sc->data.lval->h->data.sym;
    2794      191771 :                 symbol *ro = sc->data.lval->h->next->data.sym;
    2795      191771 :                 rel = rel_logical_exp(query, rel, lo, f);
    2796      191771 :                 if (!rel)
    2797             :                         return NULL;
    2798      191764 :                 return rel_logical_exp(query, rel, ro, f);
    2799             :         }
    2800          60 :         case SQL_FILTER:
    2801             :                 /* [ x,..] filter [ y,..] */
    2802             :                 /* todo add anti, [ x,..] NOT filter [ y,...] */
    2803             :                 /* no correlation */
    2804             :         {
    2805          60 :                 dnode *ln = sc->data.lval->h->data.lval->h;
    2806          60 :                 dnode *rn = sc->data.lval->h->next->next->data.lval->h;
    2807          60 :                 dlist *filter_op = sc->data.lval->h->next->data.lval;
    2808          60 :                 char *fname = qname_schema_object(filter_op);
    2809          60 :                 char *sname = qname_schema(filter_op);
    2810          60 :                 list *l, *r;
    2811             : 
    2812          60 :                 l = sa_list(sql->sa);
    2813          60 :                 r = sa_list(sql->sa);
    2814         180 :                 for (; ln; ln = ln->next) {
    2815          60 :                         symbol *sym = ln->data.sym;
    2816             : 
    2817          60 :                         sql_exp *e = rel_value_exp(query, &rel, sym, f|sql_farg, ek);
    2818          60 :                         if (!e)
    2819             :                                 return NULL;
    2820          60 :                         list_append(l, e);
    2821             :                 }
    2822         163 :                 for (; rn; rn = rn->next) {
    2823         103 :                         symbol *sym = rn->data.sym;
    2824             : 
    2825         103 :                         sql_exp *e = rel_value_exp(query, &rel, sym, f|sql_farg, ek);
    2826         103 :                         if (!e)
    2827             :                                 return NULL;
    2828         103 :                         list_append(r, e);
    2829             :                 }
    2830          60 :                 return rel_filter(sql, rel, l, r, sname, fname, 0, f);
    2831             :         }
    2832      349038 :         case SQL_COMPARE:
    2833             :         {
    2834      349038 :                 dnode *n = sc->data.lval->h;
    2835      349038 :                 symbol *lo = n->data.sym;
    2836      349038 :                 symbol *ro = n->next->next->data.sym;
    2837      349038 :                 char *compare_op = n->next->data.sval;
    2838      349038 :                 int quantifier = 0;
    2839      349038 :                 int is_semantics = 0;
    2840      349038 :                 bool is_distinct_from = false;
    2841             : 
    2842      349038 :                 if (n->next->next->next)
    2843         131 :                         quantifier = n->next->next->next->data.i_val + 1;
    2844         131 :                 assert(quantifier == 0 || quantifier == 1 || quantifier == 2 || quantifier == 3 || quantifier == 4);
    2845             : 
    2846      349038 :                 if (quantifier >= 3) {
    2847          10 :                         if (quantifier == 4) {
    2848           6 :                                 is_distinct_from = true;
    2849           6 :                                 compare_op = "<>";
    2850             :                         }
    2851             :                         quantifier = 0;
    2852             :                         is_semantics = 1;
    2853             :                 }
    2854      349038 :                 if (is_distinct_from) {
    2855           6 :                         sql_exp* ls = rel_value_exp(query, &rel, lo, f|sql_farg, ek);
    2856           6 :                         if (!ls)
    2857             :                                 return NULL;
    2858           6 :                         sql_exp* rs = rel_value_exp(query, &rel, ro, f|sql_farg, ek);
    2859           6 :                         if (!rs)
    2860             :                                 return NULL;
    2861             : 
    2862           6 :                         bool ls_is_non_null_atom = exp_is_atom(ls) && exp_is_not_null(ls);
    2863           6 :                         bool rs_is_non_null_atom = exp_is_atom(rs) && exp_is_not_null(rs);
    2864             : 
    2865           6 :                         if (ls_is_non_null_atom || rs_is_non_null_atom) {
    2866           4 :                                 sql_rel *r = rel_dup(rel);
    2867           4 :                                 sql_rel* l = rel_compare(query, rel, sc, lo, ro, compare_op, f | sql_or, ek, quantifier, 0);
    2868           4 :                                 if (!l)
    2869             :                                         return NULL;
    2870           3 :                                 sql_subtype *t;
    2871           5 :                                 if (!(t = exp_subtype(rs_is_non_null_atom?ls:rs)))
    2872           0 :                                         return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter for IS NULL operator");
    2873           3 :                                 sql_exp* e = exp_compare(sql->sa, rs_is_non_null_atom?ls:rs, exp_atom(sql->sa, atom_general(sql->sa, t, NULL, 0)), cmp_equal);
    2874           3 :                                 set_has_no_nil(e);
    2875           3 :                                 set_semantics(e);
    2876             : 
    2877           3 :                                 r = rel_select_push_compare_exp_down(sql, r, e, e->l, e->r, NULL, f | sql_or);
    2878           3 :                                 if (!r)
    2879             :                                         return NULL;
    2880           3 :                                 return rel_or(sql, rel, l, r, NULL, NULL, NULL);
    2881             :                         }
    2882             :                 }
    2883             : 
    2884             :                 /* [NOT] DISTINCT FROM */
    2885      349034 :                 return rel_compare(query, rel, sc, lo, ro, compare_op, f, ek, quantifier, is_semantics);
    2886             :         }
    2887             :         /* Set Member ship */
    2888       32581 :         case SQL_IN:
    2889             :         case SQL_NOT_IN:
    2890       32581 :                 return rel_in_exp(query, rel, sc, f);
    2891         987 :         case SQL_EXISTS:
    2892             :         case SQL_NOT_EXISTS:
    2893         987 :                 return rel_exists_exp(query, rel , sc, f);
    2894        3300 :         case SQL_LIKE:
    2895             :         case SQL_NOT_LIKE:
    2896             :         {
    2897        3300 :                 symbol *lo = sc->data.lval->h->data.sym;
    2898        3300 :                 symbol *ro = sc->data.lval->h->next->data.sym;
    2899        3300 :                 int insensitive = sc->data.lval->h->next->next->data.i_val;
    2900        3300 :                 int anti = (sc->token == SQL_NOT_LIKE) != (sc->data.lval->h->next->next->next->data.i_val != 0);
    2901        3300 :                 sql_subtype *st = sql_bind_localtype("str");
    2902        3300 :                 sql_exp *le = rel_value_exp(query, &rel, lo, f|sql_farg, ek), *re, *ee = NULL, *ie = exp_atom_bool(sql->sa, insensitive);
    2903             : 
    2904        3300 :                 if (!le)
    2905             :                         return NULL;
    2906             : 
    2907        3298 :                 if (!exp_subtype(le))
    2908           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameter not allowed on "
    2909             :                                         "left hand side of LIKE operator");
    2910             : 
    2911             :                 /* Do we need to escape ? */
    2912        3298 :                 if (dlist_length(ro->data.lval) == 2) {
    2913          82 :                         char *escape = ro->data.lval->h->next->data.sval;
    2914          82 :                         ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, escape)));
    2915             :                 } else {
    2916        3216 :                         ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, "")));
    2917             :                 }
    2918        3298 :                 ro = ro->data.lval->h->data.sym;
    2919        3298 :                 re = rel_value_exp(query, &rel, ro, f|sql_farg, ek);
    2920        3298 :                 if (!re)
    2921             :                         return NULL;
    2922        3297 :                 if ((re = exp_check_type(sql, st, rel, re, type_equal)) == NULL)
    2923           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
    2924        3297 :                 if ((le = exp_check_type(sql, st, rel, le, type_equal)) == NULL)
    2925           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
    2926        3297 :                 return rel_filter_exp_(sql, rel, le, re, ee, ie, "like", anti, f);
    2927             :         }
    2928        2960 :         case SQL_BETWEEN:
    2929             :         case SQL_NOT_BETWEEN:
    2930             :         {
    2931        2960 :                 symbol *lo = sc->data.lval->h->data.sym;
    2932        2960 :                 int symmetric = sc->data.lval->h->next->data.i_val;
    2933        2960 :                 symbol *ro1 = sc->data.lval->h->next->next->data.sym;
    2934        2960 :                 symbol *ro2 = sc->data.lval->h->next->next->next->data.sym;
    2935        2960 :                 sql_exp *le, *re1, *re2;
    2936        2960 :                 sql_subtype super;
    2937             : 
    2938        2960 :                 assert(sc->data.lval->h->next->type == type_int);
    2939             : 
    2940        2960 :                 if (!(le = rel_value_exp(query, &rel, lo, f|sql_farg, ek)))
    2941             :                         return NULL;
    2942        2958 :                 if (!(re1 = rel_value_exp(query, &rel, ro1, f|sql_farg, ek)))
    2943             :                         return NULL;
    2944        2956 :                 if (!(re2 = rel_value_exp(query, &rel, ro2, f|sql_farg, ek)))
    2945             :                         return NULL;
    2946             : 
    2947        2956 :                 if (exp_between_check_types(&super, exp_subtype(le), exp_subtype(re1), exp_subtype(re2)) < 0)
    2948           1 :                         return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
    2949             : 
    2950        2955 :                 if ((le = exp_check_type(sql, &super, rel, le, type_equal)) == NULL ||
    2951        2955 :                     (re1 = exp_check_type(sql, &super, rel, re1, type_equal)) == NULL ||
    2952        2955 :                     (re2 = exp_check_type(sql, &super, rel, re2, type_equal)) == NULL)
    2953           1 :                         return NULL;
    2954             : 
    2955        2954 :                 return rel_compare_exp_(query, rel, le, re1, re2, 3, sc->token == SQL_NOT_BETWEEN ? 1 : 0, 0, f, symmetric, 0);
    2956             :         }
    2957       10601 :         case SQL_IS_NULL:
    2958             :         case SQL_IS_NOT_NULL:
    2959             :         /* is (NOT) NULL */
    2960             :         {
    2961       10601 :                 sql_exp *le = rel_value_exp(query, &rel, sc->data.sym, f|sql_farg, ek);
    2962       10601 :                 sql_subtype *t;
    2963             : 
    2964       10601 :                 if (!le)
    2965             :                         return NULL;
    2966       10597 :                 if (!(t = exp_subtype(le)))
    2967           1 :                         return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) for IS%s NULL operator", sc->token == SQL_IS_NOT_NULL ? " NOT" : "");
    2968       10596 :                 le = exp_compare(sql->sa, le, exp_atom(sql->sa, atom_general(sql->sa, t, NULL, 0)), cmp_equal);
    2969       10596 :                 if (sc->token == SQL_IS_NOT_NULL)
    2970        2582 :                         set_anti(le);
    2971       10596 :                 set_has_no_nil(le);
    2972       10596 :                 set_semantics(le);
    2973       10596 :                 return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, NULL, f);
    2974             :         }
    2975       20045 :         case SQL_NOT: {
    2976       20045 :                 if (not_symbol_can_be_propagated(sql, sc->data.sym)) {
    2977        2330 :                         sc->data.sym = negate_symbol_tree(sql, sc->data.sym);
    2978        2330 :                         return rel_logical_exp(query, rel, sc->data.sym, f);
    2979             :                 }
    2980       17715 :                 sql_exp *le = rel_value_exp(query, &rel, sc->data.sym, f|sql_farg, ek);
    2981       17715 :                 sql_subtype bt;
    2982             : 
    2983       17715 :                 sql_find_subtype(&bt, "boolean", 0, 0);
    2984       17715 :                 if (!le || !(le = exp_check_type(sql, &bt, rel, le, type_equal)))
    2985           1 :                         return NULL;
    2986       17714 :                 le = exp_compare(sql->sa, le, exp_atom_bool(sql->sa, 0), cmp_equal);
    2987       17714 :                 return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, NULL, f);
    2988             :         }
    2989         627 :         case SQL_ATOM: {
    2990             :                 /* TRUE or FALSE */
    2991         627 :                 sql_rel *or = rel;
    2992         627 :                 AtomNode *an = (AtomNode *) sc;
    2993         627 :                 sql_exp *e = exp_atom(sql->sa, an->a);
    2994             : 
    2995         627 :                 if (e) {
    2996         627 :                         sql_subtype bt;
    2997             : 
    2998         627 :                         sql_find_subtype(&bt, "boolean", 0, 0);
    2999         627 :                         e = exp_check_type(sql, &bt, rel, e, type_equal);
    3000             :                 }
    3001         627 :                 if (!e || or != rel)
    3002           2 :                         return NULL;
    3003         625 :                 e = exp_compare(sql->sa, e, exp_atom_bool(sql->sa, 1), cmp_equal);
    3004         625 :                 return rel_select_push_compare_exp_down(sql, rel, e, e->l, e->r, NULL, f);
    3005             :         }
    3006         708 :         case SQL_IDENT:
    3007             :         case SQL_COLUMN: {
    3008         708 :                 sql_rel *or = rel;
    3009         708 :                 sql_exp *e = rel_column_ref(query, &rel, sc, f);
    3010             : 
    3011         708 :                 if (e) {
    3012         705 :                         sql_subtype bt;
    3013             : 
    3014         705 :                         sql_find_subtype(&bt, "boolean", 0, 0);
    3015         705 :                         e = exp_check_type(sql, &bt, rel, e, type_equal);
    3016             :                 }
    3017         705 :                 if (!e || or != rel)
    3018           3 :                         return NULL;
    3019         705 :                 e = exp_compare(sql->sa, e, exp_atom_bool(sql->sa, 1), cmp_equal);
    3020         705 :                 return rel_select_push_compare_exp_down(sql, rel, e, e->l, e->r, NULL, f);
    3021             :         }
    3022          12 :         case SQL_UNION:
    3023             :         case SQL_EXCEPT:
    3024             :         case SQL_INTERSECT: {
    3025          12 :                 sql_rel *sq;
    3026             : 
    3027          12 :                 if (is_psm_call(f) || is_sql_merge(f))
    3028           3 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: set operations not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
    3029          11 :                 if (rel)
    3030          11 :                         query_push_outer(query, rel, f);
    3031          11 :                 sq = rel_setquery(query, sc);
    3032          11 :                 if (rel) {
    3033          11 :                         rel = query_pop_outer(query);
    3034          11 :                         if (is_sql_join(f) && is_groupby(rel->op)) {
    3035           0 :                                 return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
    3036          11 :                         } else if (is_sql_where(f) && is_groupby(rel->op)) {
    3037           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
    3038          11 :                         } else if ((is_sql_update_set(f) || is_sql_psm(f)) && is_groupby(rel->op)) {
    3039           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
    3040             :                         }
    3041             :                 }
    3042          11 :                 if (!sq)
    3043             :                         return NULL;
    3044          11 :                 assert(ek.type == type_value); /* I don't expect IN tuple matching calls to land here */
    3045          11 :                 if (is_sql_where(f) && is_groupby(rel->op))
    3046           0 :                         assert(0);
    3047          11 :                 if (ek.card <= card_set && is_project(sq->op) && list_length(sq->exps) > 1)
    3048           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery must return only one column");
    3049          10 :                 if (!rel)
    3050             :                         return sq;
    3051          10 :                 sq = rel_zero_or_one(sql, sq, ek);
    3052          10 :                 if (is_sql_where(f) || is_sql_having(f)) {
    3053          10 :                         sql_exp *le = exp_rel(sql, sq);
    3054          10 :                         sql_subtype bt;
    3055             : 
    3056          10 :                         sql_find_subtype(&bt, "boolean", 0, 0);
    3057          10 :                         le = exp_check_type(sql, &bt, rel, le, type_equal);
    3058          10 :                         if (!le)
    3059             :                                 return NULL;
    3060          10 :                         le = exp_compare(sql->sa, le, exp_atom_bool(sql->sa, 1), cmp_equal);
    3061          10 :                         return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, NULL, f);
    3062             :                 } else {
    3063           0 :                         sq = rel_crossproduct(sql->sa, rel, sq, (f==sql_sel || is_single(sq))?op_left:op_join);
    3064           0 :                         set_processed(sq);
    3065             :                 }
    3066           0 :                 return sq;
    3067             :         }
    3068           0 :         case SQL_DEFAULT:
    3069           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "DEFAULT keyword not allowed outside insert and update statements");
    3070         326 :         default: {
    3071         326 :                 sql_exp *le = rel_value_exp(query, &rel, sc, f|sql_farg, ek);
    3072         326 :                 sql_subtype bt;
    3073             : 
    3074         326 :                 if (!le)
    3075             :                         return NULL;
    3076         301 :                 if (le && (!is_compare(le->type) || le->flag > cmp_filter)) {
    3077         288 :                         sql_find_subtype(&bt, "boolean", 0, 0);
    3078         288 :                         if (!(le = exp_check_type(sql, &bt, rel, le, type_equal)))
    3079             :                                 return NULL;
    3080         288 :                         le = exp_compare(sql->sa, le, exp_atom_bool(sql->sa, 1), cmp_equal);
    3081             :                 }
    3082         301 :                 if (le->flag == cmp_filter)
    3083          12 :                         return rel_select_push_filter_exp_down(sql, rel, le, le->l, le->r, f);
    3084             :                 else
    3085         289 :                         return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, le->f, f);
    3086             :         }
    3087             :         }
    3088             :         /* never reached, as all switch cases have a `return` */
    3089             : }
    3090             : 
    3091             : static sql_exp * _rel_aggr(sql_query *query, sql_rel **rel, int distinct, char *sname, char *aname, dnode *arguments, int f);
    3092             : static sql_exp *rel_aggr(sql_query *query, sql_rel **rel, symbol *se, int f);
    3093             : 
    3094             : static sql_exp *
    3095        1827 : rel_op(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek )
    3096             : {
    3097        1827 :         mvc *sql = query->sql;
    3098        1827 :         dnode *l = se->data.lval->h;
    3099        1827 :         char *fname = qname_schema_object(l->data.lval);
    3100        1827 :         char *sname = qname_schema(l->data.lval);
    3101             : 
    3102        1827 :         if (find_func(sql, sname, fname, 0, F_AGGR, false, NULL, NULL))
    3103           0 :                 return _rel_aggr(query, rel, 0, sname, fname, NULL, f);
    3104        1827 :         sql->session->status = 0; /* if the function was not found clean the error */
    3105        1827 :         sql->errstr[0] = '\0';
    3106        1827 :         return rel_op_(sql, sname, fname, ek);
    3107             : }
    3108             : 
    3109             : sql_exp *
    3110       94549 : rel_unop_(mvc *sql, sql_rel *rel, sql_exp *e, char *sname, char *fname, int card)
    3111             : {
    3112       94549 :         bool found = false;
    3113       94549 :         sql_subtype *t = exp_subtype(e);
    3114       94549 :         sql_ftype type = (card == card_loader)?F_LOADER:((card == card_none)?F_PROC:
    3115             :                    ((card == card_relation)?F_UNION:F_FUNC));
    3116             : 
    3117       94549 :         sql_subfunc *f = bind_func(sql, sname, fname, t, NULL, 1, type, false, &found, false);
    3118       94549 :         if (f && !f->func->vararg) {
    3119       94477 :                 sql_arg *a = f->func->ops->h->data;
    3120       94477 :                 t = &a->type;
    3121             :         }
    3122       94549 :         if (f && t && type_has_tz(t) && f->func->fix_scale == SCALE_FIX) {
    3123             :                 /* set timezone (using msec (.3)) */
    3124           0 :                 sql_subtype *intsec = sql_bind_subtype(sql->sa, "sec_interval", 10 /*hour to second */, 3);
    3125           0 :                 atom *a = atom_int(sql->sa, intsec, sql->timezone);
    3126           0 :                 sql_exp *tz = exp_atom(sql->sa, a);
    3127             : 
    3128           0 :                 e = rel_binop_(sql, rel, e, tz, "sys", "sql_add", card, true);
    3129           0 :                 if (!e)
    3130             :                         return NULL;
    3131             :         }
    3132       94527 :         if (f) {
    3133       94478 :                 if (check_card(card, f)) {
    3134       94478 :                         list *args = list_append(sa_list(sql->sa), e);
    3135       94478 :                         if (!f->func->vararg)
    3136      188954 :                                 args = check_arguments_and_find_largest_any_type(sql, rel, args, f, card == card_relation && e->card > CARD_ATOM, false);
    3137       94478 :                         if (args)
    3138       94478 :                                 return exp_op(sql->sa, args, f);
    3139             :                 }
    3140           0 :                 found = false; /* reset found */
    3141           0 :                 f = NULL;
    3142             :         }
    3143             :         /* reset error */
    3144          71 :         sql->session->status = 0;
    3145          71 :         sql->errstr[0] = '\0';
    3146         212 :         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s unary operator %s%s%s'%s'(%s)",
    3147         141 :                                          found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname, t ? t->type->base.name : "?");
    3148             : }
    3149             : 
    3150             : static sql_exp *
    3151       77527 : rel_unop(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek)
    3152             : {
    3153       77527 :         mvc *sql = query->sql;
    3154       77527 :         dnode *l = se->data.lval->h;
    3155       77527 :         char *fname = qname_schema_object(l->data.lval);
    3156       77527 :         char *sname = qname_schema(l->data.lval);
    3157       77527 :         exp_kind iek = {type_value, card_column, FALSE};
    3158       77527 :         sql_exp *e = NULL;
    3159             : 
    3160       77527 :         if (find_func(sql, sname, fname, 1, F_AGGR, false, NULL, NULL))
    3161       18824 :                 return rel_aggr(query, rel, se, f);
    3162             : 
    3163       58703 :         sql->session->status = 0; /* if the function was not found clean the error */
    3164       58703 :         sql->errstr[0] = '\0';
    3165       58703 :         if (!(e = rel_value_exp(query, rel, l->next->next->data.sym, f|sql_farg, iek)))
    3166             :                 return NULL;
    3167       58689 :         return rel_unop_(sql, rel ? *rel : NULL, e, sname, fname, ek.card);
    3168             : }
    3169             : 
    3170             : sql_exp *
    3171      522627 : rel_binop_(mvc *sql, sql_rel *rel, sql_exp *l, sql_exp *r, char *sname, char *fname, int card, bool exact)
    3172             : {
    3173      522627 :         sql_subtype *t1 = exp_subtype(l), *t2 = exp_subtype(r);
    3174      522627 :         sql_ftype type = (card == card_loader)?F_LOADER:((card == card_none)?F_PROC:((card == card_relation)?F_UNION:F_FUNC));
    3175      522627 :         bool found = false;
    3176             : 
    3177      522627 :         if (card == card_loader)
    3178           0 :                 card = card_none;
    3179             : 
    3180      522627 :         if (is_commutative(sname, fname) && l->card < r->card) { /* move constants to the right if possible */
    3181             :                 sql_subtype *tmp = t1;
    3182      522627 :                 t1 = t2;
    3183      522627 :                 t2 = tmp;
    3184             :                 sql_exp *res = l;
    3185      522627 :                 l = r;
    3186      522627 :                 r = res;
    3187             :         }
    3188             :         /* swap complex types (intervals) to left side of +, * */
    3189      522627 :         if (t1 && t2 && is_commutative(sname, fname)) {
    3190      121298 :                 if ((EC_INTERVAL(t1->type->eclass) && EC_TEMP(t2->type->eclass)) ||
    3191      121296 :            ((!EC_TEMP(t1->type->eclass) && !EC_INTERVAL(t1->type->eclass)) && EC_INTERVAL(t2->type->eclass))) {
    3192             :                         sql_subtype *tmp = t1;
    3193      522627 :                         t1 = t2;
    3194      522627 :                         t2 = tmp;
    3195             :                         sql_exp *res = l;
    3196      522627 :                         l = r;
    3197      522627 :                         r = res;
    3198             :                 }
    3199             :         }
    3200             : 
    3201      522627 :         sql_subfunc *f = bind_func(sql, sname, fname, t1, t2, 2, type, false, &found, exact);
    3202      522627 :         if (f && check_card(card,f)) {
    3203      522465 :                 t1 = exp_subtype(l);
    3204      522465 :                 t2 = exp_subtype(r);
    3205      522465 :                 list *args = list_append(list_append(sa_list(sql->sa), l), r);
    3206      522465 :                 if (!f->func->vararg)
    3207      522464 :                         args = check_arguments_and_find_largest_any_type(sql, rel, args, f, 0, false);
    3208      522465 :                 if (args)
    3209      522463 :                                 return exp_op(sql->sa, args, f);
    3210             :                 return NULL;
    3211             :         }
    3212             : 
    3213         162 :         if (!exp_subtype(l) || !exp_subtype(r))
    3214           0 :                 return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
    3215         162 :         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s binary operator %s%s%s'%s'(%s,%s)",
    3216         162 :                                          found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname,
    3217         162 :                                          exp_subtype(l)->type->base.name, exp_subtype(r)->type->base.name);
    3218             : }
    3219             : 
    3220             : static sql_exp *
    3221      373867 : rel_binop(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek)
    3222             : {
    3223      373867 :         mvc *sql = query->sql;
    3224      373867 :         dnode *dl = se->data.lval->h;
    3225      373867 :         sql_exp *l, *r;
    3226      373867 :         char *fname = qname_schema_object(dl->data.lval);
    3227      373867 :         char *sname = qname_schema(dl->data.lval);
    3228      373867 :         exp_kind iek = {type_value, card_column, FALSE};
    3229             : 
    3230      373867 :         if (find_func(sql, sname, fname, 2, F_AGGR, false, NULL, NULL))
    3231        4190 :                 return rel_aggr(query, rel, se, f);
    3232             : 
    3233      369677 :         sql->session->status = 0; /* if the function was not found clean the error */
    3234      369677 :         sql->errstr[0] = '\0';
    3235      369677 :         if (!(l = rel_value_exp(query, rel, dl->next->next->data.sym, f|sql_farg, iek)))
    3236             :                 return NULL;
    3237      369648 :         if (!(r = rel_value_exp(query, rel, dl->next->next->next->data.sym, f|sql_farg, iek)))
    3238             :                 return NULL;
    3239      369609 :         return rel_binop_(sql, rel ? *rel : NULL, l, r, sname, fname, ek.card, false);
    3240             : }
    3241             : 
    3242             : sql_exp *
    3243         530 : rel_nop_(mvc *sql, sql_rel *rel, sql_exp *a1, sql_exp *a2, sql_exp *a3, sql_exp *a4, char *sname, char *fname, int card)
    3244             : {
    3245         530 :         list *tl = sa_list(sql->sa);
    3246         530 :         sql_subfunc *f = NULL;
    3247         530 :         sql_ftype type = (card == card_none)?F_PROC:((card == card_relation)?F_UNION:F_FUNC);
    3248             : 
    3249             :         /* rel_nop_ should only be called for functions available to everyone, ie defined at sql_types! */
    3250         530 :         (void) rel;
    3251         530 :         append(tl, exp_subtype(a1));
    3252         530 :         append(tl, exp_subtype(a2));
    3253         530 :         append(tl, exp_subtype(a3));
    3254         530 :         if (a4)
    3255         371 :                 append(tl, exp_subtype(a4));
    3256             : 
    3257         530 :         if (!(f = bind_func_(sql, sname, fname, tl, type, false, NULL, true)))
    3258             :                 return NULL;
    3259         530 :         if (!a4)
    3260         159 :                 return exp_op3(sql->sa, a1,a2,a3,f);
    3261         371 :         return exp_op4(sql->sa, a1,a2,a3,a4,f);
    3262             : }
    3263             : 
    3264             : static sql_func *
    3265           3 : inplace_func(mvc *sql)
    3266             : {
    3267           3 :         sql_func *f = SA_NEW(sql->sa, sql_func);
    3268             : 
    3269           3 :     *f = (sql_func) {
    3270             :         .mod = "",
    3271             :         .imp = "",
    3272             :         .type = F_PROC,
    3273             :         .lang = FUNC_LANG_INT,
    3274             :         .query = NULL,
    3275           3 :         .ops = sql->params,
    3276             :         .res = NULL,
    3277             :     };
    3278           3 :     base_init(sql->sa, &f->base, 0, true, NULL);
    3279           3 :     f->base.new = 1;
    3280           3 :     f->base.id = -1;
    3281           3 :     f->base.name = "-1";
    3282           3 :     f->instantiated = TRUE;
    3283           3 :         return f;
    3284             : }
    3285             : 
    3286             : static list *
    3287           3 : reorder_args(mvc *sql, list *exps, list *names, list *params)
    3288             : {
    3289           3 :         list *nexps = sa_list(sql->sa);
    3290           8 :         for(node *n = params->h; n; n = n->next) {
    3291           5 :                 sql_arg *a = n->data;
    3292           5 :                 int found =0;
    3293           7 :                 for(node *m = names->h, *o = exps->h; m && o; m = m->next, o = o->next) {
    3294           7 :                         if (strcmp(m->data, a->name) == 0) {
    3295           5 :                                 append(nexps, o->data);
    3296           5 :                                 found = 1;
    3297           5 :                                 break;
    3298             :                         }
    3299             :                 }
    3300           5 :                 if (!found)
    3301             :                         return NULL;
    3302             :         }
    3303             :         return nexps;
    3304             : }
    3305             : 
    3306             : static sql_exp *
    3307       84770 : rel_nop(sql_query *query, sql_rel **rel, symbol *se, int fs, exp_kind ek)
    3308             : {
    3309       84770 :         mvc *sql = query->sql;
    3310       84770 :         int nr_args = 0, err = 0;
    3311       84770 :         dnode *l = se->data.lval->h;
    3312       84770 :         dnode *ops = l->next->next->data.lval?l->next->next->data.lval->h:NULL;
    3313       84770 :         list *exps = sa_list(sql->sa), *tl = sa_list(sql->sa);
    3314       84770 :         exp_kind iek = {type_value, card_column, FALSE};
    3315       84770 :         char buf[ERRSIZE];
    3316       84770 :         int split = (l->type == type_int && l->data.i_val == -1);
    3317       84770 :         list *names = NULL;
    3318             : 
    3319           3 :         if (split)
    3320           3 :                 names = sa_list(sql->sa);
    3321      348678 :         for (; ops; ops = ops->next, nr_args++) {
    3322      263908 :                 if (!err) { /* we need the nr_args count at the end, but if an error is found, stop calling rel_value_exp */
    3323      263886 :                         sql_exp *e = rel_value_exp(query, rel, ops->data.sym, fs|sql_farg, iek);
    3324      263886 :                         if (!e) {
    3325           6 :                                 err = sql->session->status;
    3326           6 :                                 strcpy(buf, sql->errstr);
    3327           6 :                                 continue;
    3328             :                         }
    3329      263880 :                         if (split) {
    3330           5 :                                 ops = ops->next;
    3331           5 :                                 append(names, ops->data.sval);
    3332             :                         }
    3333      263880 :                         append(exps, e);
    3334      263880 :                         append(tl, exp_subtype(e));
    3335             :                 }
    3336             :         }
    3337       84770 :         if (l->type == type_int) {
    3338             :                 /* exec nr (ops)*/
    3339        5909 :                 int nr = l->data.i_val;
    3340        5909 :                 cq *q = NULL;
    3341             : 
    3342        5909 :                 if (err)
    3343             :                         return NULL;
    3344        5908 :                 if (nr == -1 || (q = qc_find(sql->qc, nr))) {
    3345        5906 :                         list *nexps = new_exp_list(sql->sa);
    3346        5906 :                         sql_func *f = q?q->f:inplace_func(sql);
    3347        5906 :                         list *ops = q?f->ops:sql->params;
    3348             : 
    3349        5906 :                         tl = sa_list(sql->sa);
    3350        5906 :                         if (list_length(ops) != list_length(exps))
    3351           3 :                                 return sql_error(sql, 02, SQLSTATE(42000) "EXEC called with wrong number of arguments: expected %d, got %d", list_length(ops), list_length(exps));
    3352        5903 :                         if (split) {
    3353           3 :                                 exps = reorder_args(sql, exps, names, ops);
    3354           3 :                                 if (!exps)
    3355           0 :                                         return sql_error(sql, 02, SQLSTATE(42000) "EXEC called with wrong arguments");
    3356             :                         }
    3357        5903 :                         if (exps->h && ops) {
    3358       21927 :                                 for (node *n = exps->h, *m = ops->h; n && m; n = n->next, m = m->next) {
    3359       16115 :                                         sql_arg *a = m->data;
    3360       16115 :                                         sql_exp *e = n->data;
    3361       16115 :                                         sql_subtype *ntp = &a->type;
    3362             : 
    3363       16115 :                                         if (ntp && ntp->type)
    3364       16115 :                                                 e = exp_check_type(sql, ntp, NULL, e, type_equal);
    3365             :                                         else
    3366           0 :                                                 a->type = *exp_subtype(e);
    3367       16115 :                                         if (!e) {
    3368           1 :                                                 err = sql->session->status;
    3369           1 :                                                 strcpy(buf, sql->errstr);
    3370           1 :                                                 break;
    3371             :                                         }
    3372       16114 :                                         append(nexps, e);
    3373       16114 :                                         append(tl, exp_subtype(e));
    3374             :                                 }
    3375             :                         }
    3376             : 
    3377        5903 :                         if (err)
    3378             :                                 return NULL;
    3379        5902 :                         if (q)
    3380        5899 :                                 sql->type = q->type;
    3381        5992 :                         return exp_op(sql->sa, list_empty(nexps) ? NULL : nexps, sql_dup_subfunc(sql->sa, f, tl, NULL));
    3382             :                 } else {
    3383           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "EXEC: PREPARED Statement missing '%d'", nr);
    3384             :                 }
    3385             :         }
    3386       78861 :         char *fname = qname_schema_object(l->data.lval);
    3387       78861 :         char *sname = qname_schema(l->data.lval);
    3388             : 
    3389       78861 :         if (!sname && strcmp(fname, "field") == 0) { /* map into join */
    3390           2 :                 if (err)
    3391           2 :                         return NULL;
    3392           1 :                 if (list_length(exps) < 2)
    3393           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "Field function called with not enough arguments");
    3394           0 :                 sql_exp *le = exps->h->data;
    3395           0 :                 set_freevar(le, 1);
    3396           0 :                 list_remove_data(exps, NULL, le);
    3397           0 :                 sql_exp *re = exp_values(sql->sa, exps);
    3398           0 :                 exp_label(sql->sa, re, ++sql->label);
    3399           0 :                 sql_rel *r = rel_project(sql->sa, NULL, append(sa_list(sql->sa), re));
    3400           0 :                 sql_exp *id = NULL;
    3401           0 :                 rel_add_identity(sql, r, &id);
    3402           0 :                 re = exp_ref(sql, re);
    3403           0 :                 id = exp_ref(sql, id);
    3404           0 :                 if (r) {
    3405           0 :                         r->nrcols = list_length(exps);
    3406           0 :                         sql_exp *e = exp_compare(sql->sa, le, re, cmp_equal);
    3407           0 :                         r = rel_select(sql->sa, r, e);
    3408           0 :                         r = rel_project(sql->sa, r, append(sa_list(sql->sa), exp_convert(sql, id, exp_subtype(id), sql_bind_localtype("int"))));
    3409           0 :                         re = exp_rel(sql, r);
    3410           0 :                         return re;
    3411             :                 }
    3412             :         }
    3413             :         /* first try aggregate */
    3414       78859 :         if (find_func(sql, sname, fname, nr_args, F_AGGR, false, NULL, NULL)) { /* We have to pass the arguments properly, so skip call to rel_aggr */
    3415             :                 /* reset error */
    3416           2 :                 sql->session->status = 0;
    3417           2 :                 sql->errstr[0] = '\0';
    3418           2 :                 return _rel_aggr(query, rel, l->next->data.i_val, sname, fname, l->next->next->data.lval->h, fs);
    3419             :         }
    3420       78857 :         if (err) {
    3421           2 :                 sql->session->status = err;
    3422           2 :                 strcpy(sql->errstr, buf);
    3423           2 :                 return NULL;
    3424             :         }
    3425       78855 :         sql->session->status = 0; /* if the function was not found clean the error */
    3426       78855 :         sql->errstr[0] = '\0';
    3427       78855 :         return _rel_nop(sql, sname, fname, tl, rel ? *rel : NULL, exps, ek);
    3428             : }
    3429             : 
    3430             : typedef struct aggr_input {
    3431             :         sql_query *query;
    3432             :         int groupby;
    3433             :         char *err;
    3434             : } aggr_input;
    3435             : 
    3436             : static sql_exp *
    3437         372 : exp_valid(visitor *v, sql_rel *rel, sql_exp *e, int depth)
    3438             : {
    3439         372 :         aggr_input *ai = v->data;
    3440         372 :         (void)rel; (void)depth;
    3441             : 
    3442         372 :         int vf = is_freevar(e);
    3443         372 :         if (!v->changes && vf && vf < ai->groupby) { /* check need with outer query */
    3444          14 :                 sql_rel *sq = query_fetch_outer(ai->query, vf-1);
    3445             : 
    3446             :                 /* problem freevar have cardinality CARD_ATOM */
    3447          14 :                 if (sq->card <= CARD_AGGR && exp_card(e) != CARD_AGGR && is_alias(e->type)) {
    3448           4 :                         if (!exps_bind_column(sq->exps, e->l, e->r, NULL, 0)) {
    3449           1 :                                 v->changes = 1;
    3450           1 :                                 ai->err = SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query";
    3451             :                         }
    3452             :                 }
    3453         358 :         } else if (!v->changes && vf && vf == ai->groupby) { /* check if input is already aggregated */
    3454         279 :                 sql_rel *sq = query_fetch_outer(ai->query, vf-1);
    3455         279 :                 sql_exp *a = NULL;
    3456             : 
    3457         279 :                 if (sq->card <= CARD_AGGR && is_alias(e->type)) {
    3458         187 :                         if ((a = exps_bind_column(sq->exps, e->l, e->r, NULL, 0)) && is_aggr(a->type)) { /* aggregate */
    3459           9 :                                 v->changes = 1;
    3460           9 :                                 ai->err = SQLSTATE(42000) "SELECT: aggregate function calls cannot be nested";
    3461             :                         }
    3462             :                 }
    3463             :         }
    3464         372 :         return e;
    3465             : }
    3466             : 
    3467             : static char *
    3468         272 : exps_valid(sql_query *query, list *exps, int groupby)
    3469             : {
    3470         272 :         aggr_input ai = { .query = query, .groupby = groupby };
    3471         272 :         visitor v = { .sql = query->sql, .data = &ai };
    3472             : 
    3473         272 :         exps_exp_visitor_topdown(&v, NULL, exps, 0, &exp_valid, true);
    3474         272 :         if (v.changes)
    3475          10 :                 return ai.err;
    3476             :         return NULL;
    3477             : }
    3478             : 
    3479             : static sql_exp *
    3480       41741 : _rel_aggr(sql_query *query, sql_rel **rel, int distinct, char *sname, char *aname, dnode *args, int f)
    3481             : {
    3482       41741 :         mvc *sql = query->sql;
    3483       41741 :         exp_kind ek = {type_value, card_column, FALSE};
    3484       41741 :         sql_subfunc *a = NULL;
    3485       41741 :         int no_nil = 0, group = 0, all_aggr = query_has_outer(query), i;
    3486       41741 :         unsigned int all_freevar = 0;
    3487       41741 :         sql_rel *groupby = rel ? *rel : NULL, *sel = NULL, *gr, *og = NULL, *res = groupby;
    3488       41741 :         sql_rel *subquery = NULL;
    3489       41741 :         list *exps = NULL, *ungrouped_cols = NULL;
    3490       41741 :         bool is_grouping = !strcmp(aname, "grouping"), has_args = false, found = false, used_rel = false;
    3491             : 
    3492       41741 :         if (!all_aggr) {
    3493       27512 :                 if (!groupby) {
    3494           4 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3495           4 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: missing group by", toUpperCopy(uaname, aname));
    3496       27508 :                 } else if (is_sql_groupby(f)) {
    3497           8 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3498           8 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate function '%s' not allowed in GROUP BY clause", toUpperCopy(uaname, aname), aname);
    3499       27500 :                 } else if (is_sql_values(f)) {
    3500           1 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3501           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed on an unique value", toUpperCopy(uaname, aname));
    3502       27499 :                 } else if (is_sql_join(f)) { /* the is_sql_join test must come before is_sql_where, because the join conditions are handled with sql_where */
    3503           3 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3504           3 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in JOIN conditions", toUpperCopy(uaname, aname));
    3505       27496 :                 } else if (is_sql_where(f)) {
    3506           4 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3507           4 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in WHERE clause", toUpperCopy(uaname, aname));
    3508       27492 :                 } else if (is_sql_update_set(f) || is_sql_psm(f)) {
    3509           1 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3510           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses (use subquery)", toUpperCopy(uaname, aname));
    3511       27491 :                 } else if (is_sql_aggr(f)) {
    3512           4 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3513           4 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
    3514       27487 :                 } else if (is_psm_call(f)) {
    3515           0 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3516           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed inside CALL", toUpperCopy(uaname, aname));
    3517       27487 :                 } else if (is_sql_from(f)) {
    3518           0 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3519           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in functions in FROM", toUpperCopy(uaname, aname));
    3520             :                 }
    3521             :         }
    3522             : 
    3523       41716 :         exps = sa_list(sql->sa);
    3524       41716 :         if (args && args->data.sym) {
    3525       23106 :                 bool arguments_correlated = true, all_const = true;
    3526             : 
    3527       23106 :                 all_freevar = all_aggr?1:0;
    3528       50424 :                 for (i = 0; args && args->data.sym; args = args->next, i++) {
    3529       27375 :                         int base = (!groupby || !is_project(groupby->op) || is_base(groupby->op) || is_processed(groupby));
    3530       19508 :                         sql_rel *gl = base?groupby:groupby->l, *ogl = gl; /* handle case of subqueries without correlation */
    3531       27375 :                         sql_exp *e = rel_value_exp(query, &gl, args->data.sym, (f | sql_aggr)& ~sql_farg, ek);
    3532       27375 :                         bool found_one_freevar = false;
    3533             : 
    3534       27375 :                         if (!e)
    3535          57 :                                 return NULL;
    3536       27324 :                         used_rel |= (rel_has_exp(gl, e, true) == 0);
    3537       27324 :                         has_args = true;
    3538       27324 :                         if (gl && gl != ogl) {
    3539           5 :                                 if (gl->grouped) {
    3540           5 :                                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3541           5 :                                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
    3542             :                                 }
    3543           0 :                                 if (!base)
    3544           0 :                                         groupby->l = subquery = gl;
    3545             :                                 else
    3546             :                                         groupby = subquery = gl;
    3547             :                         }
    3548       27319 :                         sql_subtype *t = exp_subtype(e);
    3549       27319 :                         if (!t) { /* we also do not expect parameters here */
    3550           1 :                                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3551           1 :                                 return sql_error(sql, 02, SQLSTATE(42000) "%s: parameters not allowed as arguments to aggregate functions", toUpperCopy(uaname, aname));
    3552             :                         }
    3553       27318 :                         if (!t->type->localtype) {
    3554          47 :                                 if (e->type == e_atom && !e->f) {
    3555          44 :                                         t = sql_bind_localtype("bte");
    3556          44 :                                         e->tpe = *t;
    3557          44 :                                         if (e->l)
    3558          44 :                                                 e->l = atom_set_type(sql->sa, e->l, t);
    3559             :                                 }
    3560             :                         }
    3561             : 
    3562       27318 :                         all_aggr &= (exp_card(e) <= CARD_AGGR && !exp_is_atom(e) && is_aggr(e->type) && !is_func(e->type) && (!groupby || !is_groupby(groupby->op) || !groupby->r || !exps_find_exp(groupby->r, e)));
    3563       27318 :                         exp_only_freevar(query, e, &arguments_correlated, &found_one_freevar, &ungrouped_cols);
    3564       27318 :                         all_freevar &= (arguments_correlated && found_one_freevar) || (is_atom(e->type)?all_freevar:0); /* no uncorrelated variables must be found, plus at least one correlated variable to push this aggregate to an outer query */
    3565       27318 :                         all_const &= is_atom(e->type);
    3566       27318 :                         list_append(exps, e);
    3567             :                 }
    3568       23049 :                 if (all_const)
    3569         203 :                         all_freevar = 0;
    3570             :         }
    3571       41659 :         if (!all_freevar) {
    3572       41367 :                 if (is_sql_groupby(f)) {
    3573           1 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3574           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate function '%s' not allowed in GROUP BY clause", toUpperCopy(uaname, aname), aname);
    3575       41366 :                 } else if (is_sql_from(f)) {
    3576           2 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3577           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in functions in FROM", toUpperCopy(uaname, aname));
    3578       41364 :                 } else if (is_sql_aggr(f) && groupby->grouped) {
    3579           2 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3580           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
    3581       41362 :                 } else if (is_sql_values(f)) {
    3582           1 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3583           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed on an unique value", toUpperCopy(uaname, aname));
    3584       41361 :                 } else if (is_sql_join(f)) { /* the is_sql_join test must come before is_sql_where, because the join conditions are handled with sql_where */
    3585           1 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3586           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in JOIN conditions", toUpperCopy(uaname, aname));
    3587       41360 :                 } else if (is_sql_where(f)) {
    3588           5 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3589           5 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in WHERE clause", toUpperCopy(uaname, aname));
    3590       41355 :                 } else if (!all_aggr && !list_empty(ungrouped_cols)) {
    3591         123 :                         for (node *n = ungrouped_cols->h ; n ; n = n->next) {
    3592          66 :                                 sql_rel *outer;
    3593          66 :                                 sql_exp *e = (sql_exp*) n->data;
    3594             : 
    3595          66 :                                 if ((outer = query_fetch_outer(query, is_freevar(e)-1))) {
    3596          66 :                                         int of = query_fetch_outer_state(query, is_freevar(e)-1);
    3597          66 :                                         if (outer->grouped) {
    3598          24 :                                                 bool err = false, was_processed = false;
    3599             : 
    3600          24 :                                                 if (is_processed(outer)) {
    3601           5 :                                                         was_processed = true;
    3602           5 :                                                         reset_processed(outer);
    3603             :                                                 }
    3604          24 :                                                 if (!is_groupby_col(outer, e))
    3605           3 :                                                         err = true;
    3606          24 :                                                 if (was_processed)
    3607           5 :                                                         set_processed(outer);
    3608          24 :                                                 if (err) {
    3609           3 :                                                         if (exp_name(e) && exp_relname(e) && !has_label(e))
    3610           3 :                                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(e), exp_name(e));
    3611           0 :                                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
    3612             :                                                 }
    3613          42 :                                         } else if (!used_rel && is_sql_where(of)) {
    3614           2 :                                                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3615           2 :                                                 return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in WHERE clause", toUpperCopy(uaname, aname));
    3616          40 :                                         } else if (!is_sql_aggr(of)) {
    3617          36 :                                                 set_outer(outer);
    3618             :                                         }
    3619             :                                 }
    3620             :                         }
    3621             :                 }
    3622             :         }
    3623             : 
    3624       41642 :         if (all_freevar) { /* case 2, ie use outer */
    3625         292 :                 int card;
    3626         292 :                 sql_exp *exp = NULL;
    3627             :                 /* find proper groupby relation */
    3628         591 :                 for (node *n = exps->h; n; n = n->next) {
    3629         299 :                         sql_exp *e = n->data;
    3630             : 
    3631         299 :                         int vf = exp_freevar_offset(sql, e);
    3632         299 :                         if (vf > (int)all_freevar)
    3633          23 :                                 all_freevar = vf;
    3634         299 :                         exp = e;
    3635             :                 }
    3636         292 :                 if (query_has_outer(query) >= all_freevar) {
    3637         292 :                         int sql_state = query_fetch_outer_state(query,all_freevar-1);
    3638         292 :                         res = groupby = query_fetch_outer(query, all_freevar-1);
    3639         292 :                         card = query_outer_used_card(query, all_freevar-1);
    3640             :                         /* given groupby validate all input expressions */
    3641         292 :                         char *err;
    3642         292 :                         if (groupby && !is_groupby(groupby->op)) {
    3643         111 :                                 sql_exp *p = query_outer_last_used(query, all_freevar-1);
    3644         111 :                                 if (p && !is_aggr(p->type) && !is_groupby_col(groupby, p)) {
    3645          20 :                                         if (p->type == e_column)
    3646          20 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", (char*)p->l, (char*)p->r);
    3647           0 :                                         if (exp_name(p) && exp_relname(p) && !has_label(p))
    3648           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(p), exp_name(p));
    3649           0 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    3650             :                                 }
    3651             :                         }
    3652         272 :                         if ((err = exps_valid(query, exps, all_freevar)) != NULL) {
    3653          10 :                                 strcpy(sql->errstr, err);
    3654          10 :                                 sql->session->status = -ERR_GROUPBY;
    3655          10 :                                 return NULL;
    3656             :                         }
    3657         262 :                         if (exp && !is_groupby_col(res, exp)) {
    3658         191 :                                 if (is_sql_groupby(sql_state))
    3659           2 :                                         return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate function '%s' not allowed in GROUP BY clause", aname);
    3660         189 :                                 if (is_sql_aggr(sql_state) && groupby->grouped) {
    3661           3 :                                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3662           3 :                                         return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
    3663             :                                 }
    3664         186 :                                 if (is_sql_values(sql_state))
    3665           0 :                                         return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed on an unique value");
    3666         186 :                                 if (is_sql_update_set(sql_state) || is_sql_psm(f))
    3667           2 :                                         return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
    3668         184 :                                 if (is_sql_join(sql_state))
    3669           4 :                                         return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
    3670         180 :                                 if (is_sql_where(sql_state))
    3671           3 :                                         return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
    3672         177 :                                 if (is_psm_call(sql_state))
    3673           0 :                                         return sql_error(sql, 05, SQLSTATE(42000) "CALL: aggregate functions not allowed inside CALL");
    3674         177 :                                 if (is_sql_from(sql_state))
    3675           0 :                                         return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in functions in FROM");
    3676         177 :                                 if (card > CARD_AGGR) { /* used an expression before on the non grouped relation */
    3677           0 :                                         sql_exp *lu = query_outer_last_used(query, all_freevar-1);
    3678           0 :                                         if (lu->type == e_column)
    3679           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", (char*)lu->l, (char*)lu->r);
    3680           0 :                                         if (exp_name(lu) && exp_relname(lu) && !has_label(lu))
    3681           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(lu), exp_name(lu));
    3682           0 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
    3683             :                                 }
    3684         177 :                                 if (is_outer(groupby))
    3685           2 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
    3686             :                         }
    3687             :                 } else {
    3688             :                         all_freevar = 0;
    3689             :                 }
    3690       41350 :         } else if (!subquery && groupby && is_outer(groupby) && !is_groupby(groupby->op))
    3691           1 :                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
    3692             : 
    3693             :         /* find having select */
    3694       41595 :         if (!subquery && groupby && !is_processed(groupby) && is_sql_having(f)) {
    3695         104 :                 og = groupby;
    3696         104 :                 while(!is_processed(groupby) && !is_base(groupby->op)) {
    3697          59 :                         if (is_select(groupby->op) || !groupby->l)
    3698             :                                 break;
    3699             :                         if (groupby->l)
    3700             :                                 groupby = groupby->l;
    3701             :                 }
    3702          63 :                 if (groupby && is_select(groupby->op) && !is_processed(groupby)) {
    3703          18 :                         group = 1;
    3704          18 :                         sel = groupby;
    3705             :                         /* At the end we switch back to the old projection relation og.
    3706             :                          * During the partitioning and ordering we add the expressions to the intermediate relations. */
    3707             :                 }
    3708          18 :                 if (!sel)
    3709             :                         groupby = og;
    3710          18 :                 if (sel && sel->l)
    3711          18 :                         groupby = sel->l;
    3712             :         }
    3713             : 
    3714             :         /* find groupby */
    3715       41595 :         if (!subquery && groupby && !is_processed(groupby) && !is_base(groupby->op)) {
    3716       27373 :                 og = groupby;
    3717       27373 :                 groupby = rel_find_groupby(groupby);
    3718       27373 :                 if (groupby)
    3719             :                         group = 1;
    3720             :                 else
    3721             :                         groupby = og;
    3722             :         }
    3723             : 
    3724        7790 :         if (!groupby && exps_card(exps) > CARD_ATOM) {
    3725           0 :                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3726           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "%s: missing group by", toUpperCopy(uaname, aname));
    3727             :         }
    3728             : 
    3729       41595 :         if (!subquery && groupby && groupby->op != op_groupby) {             /* implicit groupby */
    3730       20282 :                 if (!all_freevar && query->last_exp && !is_sql_aggr(query->last_state)) {
    3731           9 :                         if (exp_relname(query->last_exp) && exp_name(query->last_exp) && !has_label(query->last_exp))
    3732           9 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(query->last_exp), exp_name(query->last_exp));
    3733           0 :                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    3734             :                 }
    3735       20273 :                 res = groupby = rel_groupby(sql, groupby, NULL);
    3736             :         }
    3737       41586 :         if (subquery) {
    3738           0 :                 assert(!all_freevar);
    3739           0 :                 res = groupby;
    3740           0 :                 if (is_sql_sel(f) && is_left(subquery->op) && !is_groupby(groupby->op)) {
    3741           0 :                         res = groupby = rel_groupby(sql, groupby, NULL);
    3742           0 :                         exps_set_freevar(sql, exps, groupby); /* mark free variables */
    3743           0 :                 } else if (!is_groupby(groupby->op)) {
    3744           0 :                         res = groupby = rel_groupby(sql, groupby, NULL);
    3745             :                 }
    3746           0 :                 assert(!is_base(groupby->op));
    3747             :         }
    3748       41586 :         if ((!exps || exps_card(exps) > CARD_ATOM) && (!res || !groupby))
    3749             :                 return NULL;
    3750             : 
    3751       41586 :         if (all_freevar) {
    3752         246 :                 query_update_outer(query, res, all_freevar-1);
    3753       41340 :         } else if (rel) {
    3754       41340 :                 *rel = res;
    3755       41340 :                 if (query->last_rel != res) {
    3756       37410 :                         query->last_rel = res;
    3757       37410 :                         query->last_state |= sql_aggr;
    3758             :                 }
    3759             :         }
    3760             : 
    3761       41586 :         if (!has_args) {        /* count(*) case */
    3762       18606 :                 sql_exp *e;
    3763             : 
    3764       18606 :                 if (strcmp(aname, "count") != 0) {
    3765           2 :                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3766           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: unable to perform '%s(*)'", toUpperCopy(uaname, aname), aname);
    3767             :                 }
    3768       18604 :                 a = sql_bind_func(sql, "sys", aname, sql_bind_localtype("void"), NULL, F_AGGR, true, true);
    3769       18604 :                 e = exp_aggr(sql->sa, NULL, a, distinct, 0, groupby?groupby->card:CARD_ATOM, 0);
    3770             : 
    3771       18604 :                 if (!groupby)
    3772             :                         return e;
    3773       18604 :                 if (all_freevar)
    3774           0 :                         query_outer_used_exp(query, all_freevar-1, e, sql_aggr);
    3775       18604 :                 e = rel_groupby_add_aggr(sql, groupby, e);
    3776       18604 :                 if (!group && !all_freevar)
    3777             :                         return e;
    3778        3202 :                 if (all_freevar) {
    3779           0 :                         assert(!is_simple_project(res->op));
    3780           0 :                         e->card = CARD_ATOM;
    3781           0 :                         set_freevar(e, all_freevar-1);
    3782           0 :                         return e;
    3783             :                 }
    3784             :                 return e;
    3785             :         }
    3786             : 
    3787             :         /* use cnt as nils shouldn't be counted */
    3788       22980 :         no_nil = 1;
    3789             : 
    3790       22980 :         gr = groupby;
    3791       22980 :         if (gr && gr->op == op_project && gr->l)
    3792             :                 gr = gr->l;
    3793             : 
    3794       22980 :         if (is_grouping) {
    3795         109 :                 sql_subtype *tpe;
    3796         109 :                 list *l = (list*) groupby->r;
    3797             : 
    3798         109 :                 if (list_length(l) <= 7)
    3799         107 :                         tpe = sql_bind_localtype("bte");
    3800           2 :                 else if (list_length(l) <= 15)
    3801           2 :                         tpe = sql_bind_localtype("sht");
    3802           0 :                 else if (list_length(l) <= 31)
    3803           0 :                         tpe = sql_bind_localtype("int");
    3804           0 :                 else if (list_length(l) <= 63)
    3805           0 :                         tpe = sql_bind_localtype("lng");
    3806             : #ifdef HAVE_HGE
    3807           0 :                 else if (list_length(l) <= 127)
    3808           0 :                         tpe = sql_bind_localtype("hge");
    3809             : #endif
    3810             :                 else
    3811           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: GROUPING the number of grouping columns is larger"
    3812             :                                                                 " than the maximum number of representable bits from this server (%d > %d)", list_length(l),
    3813             : #ifdef HAVE_HGE
    3814             :                                                         127
    3815             : #else
    3816             :                                                          63
    3817             : #endif
    3818             :                                                         );
    3819         109 :                 a = sql_bind_func_result(sql, sname, aname, F_AGGR, true, tpe, 1, exp_subtype(exps->h->data));
    3820             :         } else
    3821       22871 :                 a = sql_bind_func_(sql, sname, aname, exp_types(sql->sa, exps), F_AGGR, false, false);
    3822             : 
    3823       22980 :         if (a) {
    3824       22975 :                 found = true;
    3825       22975 :                 if (!execute_priv(sql, a->func))
    3826           0 :                         a = NULL;
    3827       22975 :                 if (!is_grouping && a && !(exps = check_arguments_and_find_largest_any_type(sql, rel ? *rel : NULL, exps, a, 0, false)))
    3828           0 :                         a = NULL;
    3829             :         }
    3830             : 
    3831       22980 :         if (a) {
    3832       22975 :                 bool hasnil = have_nil(exps) || (strcmp(aname, "count") != 0 && (!groupby || list_empty(groupby->r))); /* for global case, the aggregate may return NULL */
    3833       22975 :                 sql_exp *e = exp_aggr(sql->sa, exps, a, distinct, no_nil, groupby?groupby->card:CARD_ATOM, hasnil);
    3834             : 
    3835       22975 :                 if (!groupby)
    3836             :                         return e;
    3837       22975 :                 if (all_freevar)
    3838         246 :                         query_outer_aggregated(query, all_freevar-1, e);
    3839       22975 :                 e = rel_groupby_add_aggr(sql, groupby, e);
    3840       22975 :                 if (!group && !all_freevar)
    3841             :                         return e;
    3842       16494 :                 if (all_freevar) {
    3843         246 :                         rel_bind_vars(sql, groupby->l, exps);
    3844         246 :                         assert(!is_simple_project(res->op));
    3845         246 :                         e->card = CARD_ATOM;
    3846         246 :                         set_freevar(e, all_freevar-1);
    3847         246 :                         return e;
    3848             :                 }
    3849             :                 return e;
    3850             :         }
    3851           5 :         const char *type = "unknown";
    3852           5 :         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    3853             : 
    3854           5 :         if (!list_empty(exps)) {
    3855           5 :                 sql_exp *e = exps->h->data;
    3856           5 :                 type = exp_subtype(e)->type->base.name;
    3857             :         }
    3858          15 :         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s: %s aggregate %s%s%s'%s'(%s)", toUpperCopy(uaname, aname), found ? "insufficient privileges for" : "no such",
    3859             :                                          sname ? "'":"", sname ? sname : "", sname ? "'.":"", aname, type);
    3860             : }
    3861             : 
    3862             : static sql_exp *
    3863       41739 : rel_aggr(sql_query *query, sql_rel **rel, symbol *se, int f)
    3864             : {
    3865       41739 :         dlist *l = se->data.lval;
    3866       41739 :         dnode *d = l->h->next->next;
    3867       41739 :         int distinct = l->h->next->data.i_val;
    3868       41739 :         char *aname = qname_schema_object(l->h->data.lval);
    3869       41739 :         char *sname = qname_schema(l->h->data.lval);
    3870             : 
    3871       41739 :         return _rel_aggr(query, rel, distinct, sname, aname, d, f);
    3872             : }
    3873             : 
    3874             : static sql_exp *
    3875      100655 : rel_case(sql_query *query, sql_rel **rel, symbol *opt_cond, dlist *when_search_list, symbol *opt_else, int f)
    3876             : {
    3877      100655 :         mvc *sql = query->sql;
    3878      100655 :         sql_subtype *tpe = NULL;
    3879      100655 :         list *conds = new_exp_list(sql->sa), *results = new_exp_list(sql->sa);
    3880      100655 :         sql_subtype *restype = NULL, *condtype = NULL, ctype, rtype, bt;
    3881      100655 :         sql_exp *res = NULL, *opt_cond_exp = NULL;
    3882      100655 :         exp_kind ek = {type_value, card_column, FALSE};
    3883             : 
    3884      100655 :         if (opt_cond) {
    3885        9436 :                 if (!(opt_cond_exp = rel_value_exp(query, rel, opt_cond, f, ek)))
    3886             :                         return NULL;
    3887        9435 :                 condtype = exp_subtype(opt_cond_exp);
    3888             :         }
    3889             : 
    3890      248365 :         for (dnode *dn = when_search_list->h; dn; dn = dn->next) {
    3891      147720 :                 sql_exp *cond = NULL, *result = NULL;
    3892      147720 :                 dlist *when = dn->data.sym->data.lval;
    3893             : 
    3894      147720 :                 if (opt_cond)
    3895       45602 :                         cond = rel_value_exp(query, rel, when->h->data.sym, f, ek);
    3896             :                 else
    3897      102118 :                         cond = rel_logical_value_exp(query, rel, when->h->data.sym, f, ek);
    3898      147720 :                 if (!cond)
    3899             :                         return NULL;
    3900      147714 :                 append(conds, cond);
    3901      147714 :                 tpe = exp_subtype(cond);
    3902      147714 :                 if (tpe && condtype) {
    3903       56495 :                         result_datatype(&ctype, condtype, tpe);
    3904       56495 :                         condtype = &ctype;
    3905       91219 :                 } else if (tpe) {
    3906       91217 :                         condtype = tpe;
    3907             :                 }
    3908             : 
    3909      147714 :                 if (!(result = rel_value_exp(query, rel, when->h->next->data.sym, f, ek)))
    3910             :                         return NULL;
    3911      147711 :                 append(results, result);
    3912      147711 :                 tpe = exp_subtype(result);
    3913      147711 :                 if (tpe && restype) {
    3914       47063 :                         result_datatype(&rtype, restype, tpe);
    3915       47063 :                         restype = &rtype;
    3916      100648 :                 } else if (tpe) {
    3917      100642 :                         restype = tpe;
    3918             :                 }
    3919             :         }
    3920      100645 :         if (opt_else) {
    3921       98075 :                 if (!(res = rel_value_exp(query, rel, opt_else, f, ek)))
    3922             :                         return NULL;
    3923             : 
    3924       98075 :                 tpe = exp_subtype(res);
    3925       98075 :                 if (tpe && restype) {
    3926       98070 :                         result_datatype(&rtype, restype, tpe);
    3927       98070 :                         restype = &rtype;
    3928           5 :                 } else if (tpe) {
    3929             :                         restype = tpe;
    3930             :                 }
    3931             : 
    3932       98073 :                 if (!restype)
    3933           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "Result type missing");
    3934       98073 :                 if (restype->type->localtype == TYPE_void) /* NULL */
    3935           0 :                         restype = sql_bind_localtype("str");
    3936             : 
    3937       98073 :                 if (!(res = exp_check_type(sql, restype, rel ? *rel : NULL, res, type_equal)))
    3938             :                         return NULL;
    3939             :         } else {
    3940        2570 :                 if (!restype)
    3941           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "Result type missing");
    3942        2570 :                 if (restype->type->localtype == TYPE_void) /* NULL */
    3943           7 :                         restype = sql_bind_localtype("str");
    3944        2570 :                 res = exp_null(sql->sa, restype);
    3945             :         }
    3946             : 
    3947      100643 :         if (!condtype)
    3948           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "Condition type missing");
    3949      100643 :         if (condtype->type->localtype == TYPE_void) /* NULL */
    3950           0 :                 condtype = sql_bind_localtype("str");
    3951      100643 :         if (opt_cond_exp && !(opt_cond_exp = exp_check_type(sql, condtype, rel ? *rel : NULL, opt_cond_exp, type_equal)))
    3952             :                 return NULL;
    3953      100643 :         sql_find_subtype(&bt, "boolean", 0, 0);
    3954      100643 :         list *args = sa_list(sql->sa);
    3955      100643 :         if (opt_cond_exp)
    3956        9429 :                 append(args, opt_cond_exp);
    3957      248347 :         for (node *n = conds->h, *m = results->h; n && m; n = n->next, m = m->next) {
    3958      147705 :                 sql_exp *cond = n->data;
    3959      147705 :                 sql_exp *result = m->data;
    3960             : 
    3961      147705 :                 if (!(result = exp_check_type(sql, restype, rel ? *rel : NULL, result, type_equal)))
    3962             :                         return NULL;
    3963             : 
    3964      147705 :                 if (!(cond = exp_check_type(sql, condtype, rel ? *rel : NULL, cond, type_equal)))
    3965             :                         return NULL;
    3966      147704 :                 if (!opt_cond_exp && !(cond = exp_check_type(sql, &bt, rel ? *rel : NULL, cond, type_equal)))
    3967             :                         return NULL;
    3968      147704 :                 append(args, cond);
    3969      147704 :                 append(args, result);
    3970             :         }
    3971      100642 :         assert(res);
    3972      100642 :         list_append(args, res);
    3973      100642 :         list *types = sa_list(sql->sa);
    3974      100642 :         types = append(append(types, restype), restype);
    3975      191856 :         sql_subfunc *case_func = find_func(sql, NULL, opt_cond_exp?"casewhen":"case", list_length(types), F_FUNC, true, NULL, NULL);
    3976      100642 :         res = exp_op(sql->sa, args, case_func);
    3977      100642 :         ((sql_subfunc*)res->f)->res->h->data = sql_create_subtype(sql->sa, restype->type, restype->digits, restype->scale);
    3978      100642 :         return res;
    3979             : }
    3980             : 
    3981             : static sql_exp *
    3982        3838 : rel_complex_case(sql_query *query, sql_rel **rel, dlist *case_args, int f, str func)
    3983             : {
    3984        3838 :         exp_kind ek = {type_value, card_column, FALSE};
    3985        3838 :         list *args = sa_list(query->sql->sa);
    3986        3838 :         sql_subtype *restype = NULL, rtype;
    3987        3838 :         sql_exp *res;
    3988             : 
    3989             :         /* generate nested func calls */
    3990       11970 :         for(dnode *dn = case_args->h; dn; dn = dn->next) {
    3991        8145 :                 sql_exp *a = rel_value_exp(query, rel, dn->data.sym, f, ek);
    3992        8145 :                 if (!a)
    3993             :                         return NULL;
    3994        8132 :                 append(args, a);
    3995             :                 /* all arguments should have the same type */
    3996        8132 :                 sql_subtype *tpe = exp_subtype(a);
    3997        8132 :                 if (tpe && restype) {
    3998        4296 :                         result_datatype(&rtype, restype, tpe);
    3999        4296 :                         restype = &rtype;
    4000        3836 :                 } else if (tpe) {
    4001        3836 :                         restype = tpe;
    4002             :                 }
    4003             :         }
    4004        3825 :         if (!restype)
    4005           0 :                 return sql_error(query->sql, 02, SQLSTATE(42000) "Result type missing");
    4006        3825 :         if (restype->type->localtype == TYPE_void) /* NULL */
    4007           0 :                 restype = sql_bind_localtype("str");
    4008        3825 :         list *nargs = sa_list(query->sql->sa);
    4009       11942 :         for (node *m = args->h; m; m = m->next) {
    4010        8117 :                 sql_exp *result = m->data;
    4011             : 
    4012        8117 :                 if (!(result = exp_check_type(query->sql, restype, rel ? *rel : NULL, result, type_equal)))
    4013             :                         return NULL;
    4014        8117 :                 append(nargs, result);
    4015             :         }
    4016        3825 :         list *types = append(append(sa_list(query->sql->sa), restype), restype);
    4017        3825 :         sql_subfunc *fnc = find_func(query->sql, NULL, func, list_length(types), F_FUNC, true, NULL, NULL);
    4018        3825 :         res = exp_op(query->sql->sa, nargs, fnc);
    4019        3825 :         ((sql_subfunc*)res->f)->res->h->data = sql_create_subtype(query->sql->sa, restype->type, restype->digits, restype->scale);
    4020        3825 :         return res;
    4021             : }
    4022             : 
    4023             : static sql_exp *
    4024      104493 : rel_case_exp(sql_query *query, sql_rel **rel, symbol *se, int f)
    4025             : {
    4026      104493 :         dlist *l = se->data.lval;
    4027             : 
    4028      104493 :         if (se->token == SQL_COALESCE) {
    4029        3687 :                 return rel_complex_case(query, rel, l, f | sql_farg, "coalesce");
    4030      100806 :         } else if (se->token == SQL_NULLIF) {
    4031         151 :                 return rel_complex_case(query, rel, l, f | sql_farg, "nullif");
    4032      100655 :         } else if (l->h->type == type_list) {
    4033       91219 :                 dlist *when_search_list = l->h->data.lval;
    4034       91219 :                 symbol *opt_else = l->h->next->data.sym;
    4035             : 
    4036       91219 :                 return rel_case(query, rel, NULL, when_search_list, opt_else, f | sql_farg);
    4037             :         } else {
    4038        9436 :                 symbol *scalar_exp = l->h->data.sym;
    4039        9436 :                 dlist *when_value_list = l->h->next->data.lval;
    4040        9436 :                 symbol *opt_else = l->h->next->next->data.sym;
    4041             : 
    4042        9436 :                 return rel_case(query, rel, scalar_exp, when_value_list, opt_else, f | sql_farg);
    4043             :         }
    4044             : }
    4045             : 
    4046             : #define E_ATOM_STRING(e) ((atom*)(e)->l)->data.val.sval
    4047             : 
    4048             : static sql_exp *
    4049      169049 : rel_cast(sql_query *query, sql_rel **rel, symbol *se, int f)
    4050             : {
    4051      169049 :         mvc *sql = query->sql;
    4052      169049 :         dlist *dl = se->data.lval;
    4053      169049 :         symbol *s = dl->h->data.sym;
    4054      169049 :         sql_subtype *tpe = &dl->h->next->data.typeval;
    4055      169049 :         exp_kind ek = {type_value, card_column, FALSE};
    4056      169049 :         sql_exp *e = rel_value_exp(query, rel, s, f|sql_farg, ek);
    4057             : 
    4058      169049 :         if (!e)
    4059             :                 return NULL;
    4060             : 
    4061             :         /* strings may need to be truncated */
    4062      169034 :         if (EC_VARCHAR(tpe->type->eclass) && tpe->digits > 0) {
    4063       82568 :                 sql_subtype *et = exp_subtype(e);
    4064             :                 /* truncate only if the number of digits are smaller or from clob */
    4065       82568 :                 if (et && EC_VARCHAR(et->type->eclass) && (tpe->digits < et->digits || et->digits == 0)) {
    4066        2870 :                         sql_subfunc *c = sql_bind_func(sql, "sys", "truncate", et, sql_bind_localtype("int"), F_FUNC, true, true);
    4067        2870 :                         if (c)
    4068        2870 :                                 e = exp_binop(sql->sa, e, exp_atom_int(sql->sa, tpe->digits), c);
    4069             :                 }
    4070             :         }
    4071             : 
    4072      169034 :         if (tpe->type->eclass == EC_DEC) {
    4073         447 :                 sql_subtype *et = exp_subtype(e);
    4074         447 :                 if (e->type == e_atom && !tpe->digits) {
    4075           9 :                         if (et->type->eclass == EC_NUM || et->type->eclass == EC_DEC) {
    4076           6 :                                 tpe->digits = atom_num_digits(e->l);
    4077           6 :                                 tpe = sql_bind_subtype(sql->sa, "decimal", tpe->digits, et->scale);
    4078           3 :                         } else if (EC_VARCHAR(et->type->eclass)) {
    4079           2 :                                 char *s = E_ATOM_STRING(e);
    4080           2 :                                 unsigned int min_precision = 0, min_scale = 0;
    4081           2 :                                 bool dot_seen = false;
    4082          16 :                                 for (size_t i = 0; i < strlen(s); i++) {
    4083          14 :                                         if (isdigit(s[i])) {
    4084          12 :                                                 min_precision++;
    4085          12 :                                                 if (dot_seen)
    4086          10 :                                                         min_scale++;
    4087           2 :                                         } else if (s[i] == '.') {
    4088           2 :                                                 dot_seen = true;
    4089             :                                         }
    4090             :                                 }
    4091           2 :                                 tpe = sql_bind_subtype(sql->sa, "decimal", min_precision, min_scale);
    4092             :                         } else { /* fallback */
    4093           1 :                                 tpe = sql_bind_subtype(sql->sa, "decimal", 18, 3);
    4094             :                         }
    4095         438 :                 } else if (!tpe->digits && !tpe->scale) {
    4096         105 :                         if (et->type->eclass == EC_NUM)
    4097          36 :                                 tpe = sql_bind_subtype(sql->sa, "decimal", et->digits, 0);
    4098             :                         else /* fallback */
    4099          69 :                                 tpe = sql_bind_subtype(sql->sa, "decimal", 18, 3);
    4100             :                 }
    4101             :         }
    4102             : 
    4103      169034 :         if (e)
    4104      169034 :                 e = exp_check_type(sql, tpe, rel ? *rel : NULL, e, type_cast);
    4105             : 
    4106      169034 :         if (e && e->type == e_convert)
    4107       48042 :                 exp_label(sql->sa, e, ++sql->label);
    4108             : 
    4109             :         return e;
    4110             : }
    4111             : 
    4112             : static sql_exp *
    4113        1584 : rel_next_value_for( mvc *sql, symbol *se )
    4114             : {
    4115        1584 :         char *sname = qname_schema(se->data.lval);
    4116        1584 :         char *seqname = qname_schema_object(se->data.lval);
    4117        1584 :         sql_sequence *seq = NULL;
    4118        1584 :         sql_subtype t;
    4119        1584 :         sql_subfunc *f;
    4120             : 
    4121        1584 :         if (!stack_find_rel_view(sql, seqname)) {
    4122        1388 :                 if (!(seq = find_sequence_on_scope(sql, sname, seqname, "NEXT VALUE FOR")))
    4123             :                         return NULL;
    4124        1386 :                 if (!mvc_schema_privs(sql, seq->s))
    4125           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "NEXT VALUE FOR: access denied for %s to schema '%s'", get_string_global_var(sql, "current_user"), seq->s->base.name);
    4126             :         }
    4127        1582 :         sql_find_subtype(&t, "varchar", 0, 0);
    4128        1582 :         f = sql_bind_func(sql, "sys", "next_value_for", &t, &t, F_FUNC, true, true);
    4129        1582 :         assert(f);
    4130             :         /* sequence found in the stack. use session's schema? */
    4131        1582 :         return exp_binop(sql->sa, exp_atom_str(sql->sa, seq && seq->s ? seq->s->base.name : "sys", &t), exp_atom_str(sql->sa, seqname, &t), f);
    4132             : }
    4133             : 
    4134             : /* some users like to use aliases already in the groupby */
    4135             : static sql_exp *
    4136         165 : rel_selection_ref(sql_query *query, sql_rel **rel, char *name, dlist *selection)
    4137             : {
    4138         165 :         allocator *sa = query->sql->sa;
    4139         165 :         dlist *nl;
    4140         165 :         exp_kind ek = {type_value, card_column, FALSE};
    4141         165 :         sql_exp *res = NULL;
    4142         165 :         symbol *nsym;
    4143             : 
    4144         165 :         if (!selection)
    4145             :                 return NULL;
    4146             : 
    4147         679 :         for (dnode *n = selection->h; n; n = n->next) {
    4148             :                 /* we only look for columns */
    4149         517 :                 tokens to = n->data.sym->token;
    4150         517 :                 if (to == SQL_COLUMN || to == SQL_IDENT) {
    4151         515 :                         dlist *l = n->data.sym->data.lval;
    4152             :                         /* AS name */
    4153         515 :                         if (l->h->next->data.sval && strcmp(l->h->next->data.sval, name) == 0) {
    4154         146 :                                 sql_exp *ve = rel_value_exp(query, rel, l->h->data.sym, sql_sel|sql_groupby, ek);
    4155         146 :                                 if (ve) {
    4156         145 :                                         if (res)
    4157           1 :                                                 return sql_error(query->sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: identifier '%s' ambiguous", name);
    4158         144 :                                         res = ve;
    4159             : 
    4160         144 :                                         nl = dlist_create(sa);
    4161         144 :                                         exp_setname(query->sql, ve, NULL, name);
    4162             :                                         /* now we should rewrite the selection such that it uses the new group by column */
    4163         144 :                                         dlist_append_string(sa, nl, sa_strdup(sa, name));
    4164         144 :                                         nsym = symbol_create_list(sa, to, nl);
    4165         144 :                                         nl = dlist_create(sa);
    4166         144 :                                         dlist_append_symbol(sa, nl, nsym);
    4167             :                                         /* no alias */
    4168         144 :                                         dlist_append_symbol(sa, nl, NULL);
    4169         144 :                                         n->data.sym = symbol_create_list(sa, to, nl);
    4170             :                                 }
    4171             :                         }
    4172             :                 }
    4173             :         }
    4174             :         return res;
    4175             : }
    4176             : 
    4177             : static char*
    4178         197 : symbol_get_identifier(symbol *sym)
    4179             : {
    4180         197 :         dlist *syml;
    4181             : 
    4182         197 :         if (sym->token != SQL_COLUMN && sym->token != SQL_IDENT)
    4183             :                 return NULL;
    4184         182 :         syml = sym->data.lval;
    4185         182 :         if (dlist_length(syml) > 1)
    4186             :                 return NULL;
    4187             : 
    4188         165 :         return syml->h->data.sval;
    4189             : }
    4190             : 
    4191             : static sql_exp*
    4192       23642 : rel_group_column(sql_query *query, sql_rel **rel, symbol *grp, dlist *selection, list *exps, int f)
    4193             : {
    4194       23642 :         sql_query *lquery = query_create(query->sql);
    4195       23642 :         mvc *sql = query->sql;
    4196       23642 :         exp_kind ek = {type_value, card_value, TRUE};
    4197       23642 :         sql_exp *e = rel_value_exp2(lquery, rel, grp, f, ek);
    4198             : 
    4199       23642 :         if (e && exp_is_atom(e)) {
    4200          34 :                 sql_subtype *tpe = exp_subtype(e);
    4201          34 :                 if (!is_atom(e->type) ||!tpe || tpe->type->eclass != EC_NUM) {
    4202           2 :                         if (!tpe)
    4203           2 :                                 return sql_error(sql, 02, SQLSTATE(42000) "Cannot have a parameter (?) for group by column");
    4204           3 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: non-integer constant in GROUP BY");
    4205             :                 }
    4206             :         }
    4207             : 
    4208         192 :         if (!e) {
    4209         192 :                 char buf[ERRSIZE], *name;
    4210         192 :                 int status = sql->session->status;
    4211         192 :                 strcpy(buf, sql->errstr);
    4212             :                 /* reset error */
    4213         192 :                 sql->session->status = 0;
    4214         192 :                 sql->errstr[0] = '\0';
    4215             : 
    4216         192 :                 if ((name = symbol_get_identifier(grp))) {
    4217         163 :                         e = rel_selection_ref(query, rel, name, selection);
    4218         163 :                         if (!e) { /* attempt to find in the existing list of group by expressions */
    4219          29 :                                 for (node *n = exps->h ; n && !e ; n = n->next) {
    4220           9 :                                         sql_exp *ge = (sql_exp *) n->data;
    4221           9 :                                         const char *gen = exp_name(ge);
    4222             : 
    4223           9 :                                         if (gen && strcmp(name, gen) == 0)
    4224           5 :                                                 e = exp_ref(sql, ge);
    4225             :                                 }
    4226             :                         }
    4227             :                 }
    4228          49 :                 if (!e && query_has_outer(query)) {
    4229             :                         /* reset error */
    4230          32 :                         sql->session->status = 0;
    4231          32 :                         sql->errstr[0] = '\0';
    4232          32 :                         e = rel_value_exp2(query, rel, grp, f, ek);
    4233             :                 }
    4234          44 :                 if (!e) {
    4235          13 :                         if (sql->errstr[0] == 0) {
    4236          10 :                                 sql->session->status = status;
    4237          10 :                                 strcpy(sql->errstr, buf);
    4238             :                         }
    4239          13 :                         return NULL;
    4240             :                 }
    4241             :         }
    4242       23624 :         if (!exp_subtype(e))
    4243           0 :                 return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) for group by column");
    4244             :         return e;
    4245             : }
    4246             : 
    4247             : static list*
    4248          44 : list_power_set(allocator *sa, list* input) /* cube */
    4249             : {
    4250          44 :         list *res = sa_list(sa);
    4251             :         /* N stores total number of subsets */
    4252          44 :         int N = (int) pow(2, input->cnt);
    4253             : 
    4254             :         /* generate each subset one by one */
    4255         266 :         for (int i = 0; i < N; i++) {
    4256         222 :                 list *ll = sa_list(sa);
    4257         222 :                 int j = 0; /* check every bit of i */
    4258         844 :                 for (node *n = input->h ; n ; n = n->next) {
    4259             :                         /* if j'th bit of i is set, then append */
    4260         622 :                         if (i & (1 << j))
    4261         311 :                                 list_prepend(ll, n->data);
    4262         622 :                         j++;
    4263             :                 }
    4264         222 :                 list_prepend(res, ll);
    4265             :         }
    4266          44 :         return res;
    4267             : }
    4268             : 
    4269             : static list*
    4270          61 : list_rollup(allocator *sa, list* input)
    4271             : {
    4272          61 :         list *res = sa_list(sa);
    4273             : 
    4274         188 :         for (int counter = input->cnt; counter > 0; counter--) {
    4275         127 :                 list *ll = sa_list(sa);
    4276         127 :                 int j = 0;
    4277         376 :                 for (node *n = input->h; n && j < counter; j++, n = n->next)
    4278         249 :                         list_append(ll, n->data);
    4279         127 :                 list_append(res, ll);
    4280             :         }
    4281          61 :         list_append(res, sa_list(sa)); /* global aggregate case */
    4282          61 :         return res;
    4283             : }
    4284             : 
    4285             : static int
    4286         320 : list_equal(list* list1, list* list2)
    4287             : {
    4288         375 :         for (node *n = list1->h; n ; n = n->next) {
    4289         328 :                 sql_exp *e = (sql_exp*) n->data;
    4290         328 :                 if (!exps_find_exp(list2, e))
    4291             :                         return 1;
    4292             :         }
    4293          78 :         for (node *n = list2->h; n ; n = n->next) {
    4294          47 :                 sql_exp *e = (sql_exp*) n->data;
    4295          47 :                 if (!exps_find_exp(list1, e))
    4296             :                         return 1;
    4297             :         }
    4298             :         return 0;
    4299             : }
    4300             : 
    4301             : static list*
    4302          26 : lists_cartesian_product_and_distinct(allocator *sa, list *l1, list *l2)
    4303             : {
    4304          26 :         list *res = sa_list(sa);
    4305             : 
    4306             :         /* for each list of l2, merge into each list of l1 while removing duplicates */
    4307         116 :         for (node *n = l1->h ; n ; n = n->next) {
    4308          90 :                 list *sub_list = (list*) n->data;
    4309             : 
    4310         279 :                 for (node *m = l2->h ; m ; m = m->next) {
    4311         189 :                         list *other = (list*) m->data;
    4312         189 :                         list_append(res, list_distinct(list_merge(list_dup(sub_list, (fdup) NULL), other, (fdup) NULL), (fcmp) list_equal, (fdup) NULL));
    4313             :                 }
    4314             :         }
    4315          26 :         return res;
    4316             : }
    4317             : 
    4318             : static list*
    4319        9801 : rel_groupings(sql_query *query, sql_rel **rel, symbol *groupby, dlist *selection, int f, bool grouping_sets, list **sets)
    4320             : {
    4321        9801 :         mvc *sql = query->sql;
    4322        9801 :         list *exps = new_exp_list(sql->sa);
    4323             : 
    4324        9801 :         if (mvc_highwater(sql))
    4325           0 :                 return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
    4326             : 
    4327       33351 :         for (dnode *o = groupby->data.lval->h; o; o = o->next) {
    4328       23569 :                 symbol *grouping = o->data.sym;
    4329       23569 :                 list *next_set = NULL;
    4330             : 
    4331       23569 :                 if (grouping->token == SQL_GROUPING_SETS) { /* call recursively, and merge the generated sets */
    4332          39 :                         list *other = rel_groupings(query, rel, grouping, selection, f, true, &next_set);
    4333          39 :                         if (!other)
    4334          19 :                                 return NULL;
    4335          39 :                         exps = list_distinct(list_merge(exps, other, (fdup) NULL), (fcmp) exp_equal, (fdup) NULL);
    4336             :                 } else {
    4337       23530 :                         dlist *dl = grouping->data.lval;
    4338       23530 :                         if (dl) {
    4339       23504 :                                 list *set_cols = new_exp_list(sql->sa); /* columns and combination of columns to be used for the next set */
    4340             : 
    4341       47098 :                                 for (dnode *oo = dl->h; oo; oo = oo->next) {
    4342       23612 :                                         symbol *grp = oo->data.sym;
    4343       23612 :                                         list *next_tuple = new_exp_list(sql->sa); /* next tuple of columns */
    4344             : 
    4345       23612 :                                         if (grp->token == SQL_COLUMN_GROUP) { /* set of columns */
    4346          71 :                                                 assert(is_sql_group_totals(f));
    4347         172 :                                                 for (dnode *ooo = grp->data.lval->h; ooo; ooo = ooo->next) {
    4348         101 :                                                         symbol *elm = ooo->data.sym;
    4349         101 :                                                         sql_exp *e = rel_group_column(query, rel, elm, selection, exps, f);
    4350         101 :                                                         if (!e)
    4351             :                                                                 return NULL;
    4352         101 :                                                         assert(e->type == e_column);
    4353         101 :                                                         list_append(next_tuple, e);
    4354         101 :                                                         list_append(exps, e);
    4355             :                                                 }
    4356             :                                         } else { /* single column or expression */
    4357       23541 :                                                 sql_exp *e = rel_group_column(query, rel, grp, selection, exps, f);
    4358       23541 :                                                 if (!e)
    4359             :                                                         return NULL;
    4360       23523 :                                                 if (e->type != e_column && !exp_is_atom(e)) { /* store group by expressions in the stack */
    4361         140 :                                                         if (is_sql_group_totals(f))
    4362           0 :                                                                 return sql_error(sql, 02, SQLSTATE(42000) "GROUP BY: grouping expressions not possible with ROLLUP, CUBE and GROUPING SETS");
    4363         140 :                                                         if (!exp_has_rel(e) && !frame_push_groupby_expression(sql, grp, e))
    4364             :                                                                 return NULL;
    4365             :                                                 }
    4366       23523 :                                                 list_append(next_tuple, e);
    4367       23523 :                                                 list_append(exps, e);
    4368             :                                         }
    4369       23594 :                                         list_append(set_cols, next_tuple);
    4370             :                                 }
    4371       23486 :                                 if (is_sql_group_totals(f)) {
    4372         178 :                                         if (grouping->token == SQL_ROLLUP)
    4373          61 :                                                 next_set = list_rollup(sql->sa, set_cols);
    4374         117 :                                         else if (grouping->token == SQL_CUBE)
    4375          44 :                                                 next_set = list_power_set(sql->sa, set_cols);
    4376             :                                         else /* the list of sets is not used in the "GROUP BY a, b, ..." case */
    4377          73 :                                                 next_set = list_append(new_exp_list(sql->sa), set_cols);
    4378             :                                 }
    4379          26 :                         } else if (is_sql_group_totals(f) && grouping_sets) /* The GROUP BY () case is the global aggregate which is always added by ROLLUP and CUBE */
    4380          17 :                                 next_set = list_append(new_exp_list(sql->sa), new_exp_list(sql->sa));
    4381             :                 }
    4382       23551 :                 if (is_sql_group_totals(f)) { /* if there are no sets, set the found one, otherwise calculate cartesian product and merge the distinct ones */
    4383         235 :                         if (!next_set)
    4384           1 :                                 return sql_error(sql, 02, SQLSTATE(42000) "GROUP BY: GROUPING SETS is empty");
    4385         234 :                         if (!*sets)
    4386         157 :                                 *sets = next_set;
    4387             :                         else
    4388          77 :                                 *sets = grouping_sets ? list_merge(*sets, next_set, (fdup) NULL) : lists_cartesian_product_and_distinct(sql->sa, *sets, next_set);
    4389             :                 }
    4390             :         }
    4391             :         return exps;
    4392             : }
    4393             : 
    4394             : static list*
    4395        8208 : rel_partition_groupings(sql_query *query, sql_rel **rel, symbol *partitionby, dlist *selection, int f)
    4396             : {
    4397        8208 :         mvc *sql = query->sql;
    4398        8208 :         dnode *o = partitionby->data.lval->h;
    4399        8208 :         list *exps = new_exp_list(sql->sa);
    4400             : 
    4401       24650 :         for (; o; o = o->next) {
    4402        8242 :                 symbol *grp = o->data.sym;
    4403        8242 :                 exp_kind ek = {type_value, card_value, TRUE};
    4404        8242 :                 sql_exp *e = rel_value_exp2(query, rel, grp, f, ek);
    4405             : 
    4406        8242 :                 if (!e) {
    4407           5 :                         int status = sql->session->status;
    4408           5 :                         char buf[ERRSIZE], *name;
    4409             : 
    4410             :                         /* reset error */
    4411           5 :                         sql->session->status = 0;
    4412           5 :                         strcpy(buf, sql->errstr);
    4413           5 :                         sql->errstr[0] = '\0';
    4414             : 
    4415           5 :                         if ((name = symbol_get_identifier(grp))) {
    4416           2 :                                 e = rel_selection_ref(query, rel, name, selection);
    4417           2 :                                 if (!e) { /* attempt to find in the existing list of partition by expressions */
    4418           3 :                                         for (node *n = exps->h ; n ; n = n->next) {
    4419           1 :                                                 sql_exp *ge = (sql_exp *) n->data;
    4420           1 :                                                 const char *gen = exp_name(ge);
    4421             : 
    4422           1 :                                                 if (gen && strcmp(name, gen) == 0) {
    4423           0 :                                                         e = exp_ref(sql, ge);
    4424           0 :                                                         break;
    4425             :                                                 }
    4426             :                                         }
    4427             :                                 }
    4428             :                         }
    4429           5 :                         if (!e) {
    4430           5 :                                 if (sql->errstr[0] == 0) {
    4431           5 :                                         sql->session->status = status;
    4432           5 :                                         strcpy(sql->errstr, buf);
    4433             :                                 }
    4434           5 :                                 return NULL;
    4435             :                         }
    4436             :                 }
    4437             : 
    4438        8237 :                 if (exp_has_rel(e))
    4439           3 :                         return sql_error(sql, 02, SQLSTATE(42000) "PARTITION BY: subqueries not allowed in PARTITION BY clause");
    4440             : 
    4441        8234 :                 if (e->type != e_column) { /* store group by expressions in the stack */
    4442          36 :                         if (!frame_push_groupby_expression(sql, grp, e))
    4443             :                                 return NULL;
    4444             :                 }
    4445             : 
    4446        8234 :                 if (e->card > CARD_AGGR)
    4447        8114 :                         e->card = CARD_AGGR;
    4448        8234 :                 append(exps, e);
    4449             :         }
    4450             :         return exps;
    4451             : }
    4452             : 
    4453             : /* find selection expressions matching the order by column expression */
    4454             : /* complex columns only */
    4455             : static sql_exp *
    4456       66961 : rel_order_by_column_exp(sql_query *query, sql_rel **R, symbol *column_r, int needs_distinct, int f)
    4457             : {
    4458       66961 :         mvc *sql = query->sql;
    4459       66961 :         sql_rel *r = *R, *p = NULL;
    4460       66961 :         sql_exp *e = NULL, *found = NULL;
    4461       66961 :         exp_kind ek = {type_value, card_column, FALSE};
    4462             : 
    4463       66961 :         if (!r)
    4464             :                 return e;
    4465             : 
    4466       66961 :         if (is_simple_project(r->op) && r->l && is_processed(r)) {
    4467       66899 :                 p = r;
    4468       66899 :                 r = r->l;
    4469             :         }
    4470             : 
    4471       66961 :         e = rel_value_exp(query, &r, column_r, f, ek);
    4472             : 
    4473       66961 :         if (r && !p)
    4474          62 :                 *R = r;
    4475       66899 :         else if (r)
    4476       66899 :                 p->l = r;
    4477       66961 :         if (e && p) {
    4478       66872 :                 if (is_project(p->op) && (found = exps_any_match(p->exps, e))) { /* if one of the projections matches, return a reference to it */
    4479       59401 :                         e = exp_ref(sql, found);
    4480             :                 } else {
    4481        7471 :                         if (needs_distinct)
    4482           2 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: with DISTINCT ORDER BY expressions must appear in select list");
    4483        7469 :                         e = rel_project_add_exp(sql, p, e);
    4484        7469 :                         if (r) {
    4485      121107 :                                 for (node *n = p->exps->h ; n ; n = n->next) {
    4486      113640 :                                         sql_exp *ee = n->data;
    4487             : 
    4488      113640 :                                         if (ee->card > r->card) {
    4489           2 :                                                 if (exp_name(ee) && !has_label(ee))
    4490           2 :                                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(ee));
    4491           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    4492             :                                         }
    4493             :                                 }
    4494             :                         }
    4495             :                 }
    4496       66868 :                 return e;
    4497             :         }
    4498          89 :         if (e && r && is_project(r->op)) {
    4499          28 :                 sql_exp *found = exps_find_exp(r->exps, e);
    4500             : 
    4501          28 :                 if (!found) {
    4502           8 :                         if (needs_distinct)
    4503           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: with DISTINCT ORDER BY expressions must appear in select list");
    4504           8 :                         if (!is_simple_project(r->op) && !is_groupby(r->op))
    4505           1 :                                 *R = r = rel_project(sql->sa, r, rel_projections(sql, r, NULL, 1, 0));
    4506           8 :                         append(r->exps, e);
    4507             :                 } else {
    4508             :                         e = found;
    4509             :                 }
    4510          28 :                 e = exp_ref(sql, e);
    4511             :         }
    4512             :         return e;
    4513             : }
    4514             : 
    4515             : static dlist *
    4516      114627 : simple_selection(symbol *sq)
    4517             : {
    4518      114627 :         if (sq->token == SQL_SELECT) {
    4519          13 :                 SelectNode *sn;
    4520          13 :                 sn = (SelectNode *) sq;
    4521             : 
    4522          13 :                 if (!sn->from && !sn->where && !sn->distinct && !sn->window && dlist_length(sn->selection) == 1)
    4523           7 :                         return sn->selection;
    4524             :         }
    4525             :         return NULL;
    4526             : }
    4527             : 
    4528             : static list *
    4529       45503 : rel_order_by(sql_query *query, sql_rel **R, symbol *orderby, int needs_distinct, int f)
    4530             : {
    4531       45503 :         mvc *sql = query->sql;
    4532       45503 :         sql_rel *rel = *R, *or = rel; /* the order by relation */
    4533       45503 :         list *exps = new_exp_list(sql->sa);
    4534             : 
    4535       45503 :         if (!orderby->data.lval) { /* by all */
    4536           2 :                 if (is_sql_orderby(f)) {
    4537           2 :                         assert(is_project(rel->op));
    4538           6 :                         for(node *n = rel->exps->h; n; n = n->next) {
    4539           4 :                                 sql_exp *e = n->data;
    4540           4 :                                 append(exps, exp_ref(sql, e));
    4541             :                         }
    4542             :                         return exps;
    4543             :                 }
    4544             :                 return NULL;
    4545             :         }
    4546             : 
    4547       45501 :         dnode *o = orderby->data.lval->h;
    4548       45501 :         dlist *selection = NULL;
    4549             : 
    4550       45501 :         if (is_sql_orderby(f)) {
    4551       36637 :                 assert(is_project(rel->op));
    4552       36637 :                 rel = rel->l;
    4553             :         }
    4554             : 
    4555      160081 :         for (; o; o = o->next) {
    4556      114627 :                 symbol *order = o->data.sym;
    4557             : 
    4558      114627 :                 if (order->token == SQL_COLUMN || order->token == SQL_IDENT) {
    4559      114627 :                         symbol *col = order->data.lval->h->data.sym;
    4560      114627 :                         int direction = order->data.lval->h->next->data.i_val;
    4561      114627 :                         sql_exp *e = NULL;
    4562             : 
    4563      114627 :                         assert(order->data.lval->h->next->type == type_int);
    4564      114627 :                         if ((selection = simple_selection(col)) != NULL) {
    4565           7 :                                 dnode *o = selection->h;
    4566           7 :                                 order = o->data.sym;
    4567           7 :                                 if (order->data.lval->h->type == type_symbol)
    4568           6 :                                         col = order->data.lval->h->data.sym;
    4569             :                                 /* remove optional name from selection */
    4570           7 :                                 order->data.lval->h->next = NULL;
    4571             :                         }
    4572             : 
    4573      114627 :                         if (col->token == SQL_COLUMN || col->token == SQL_IDENT || col->token == SQL_ATOM) {
    4574      114405 :                                 exp_kind ek = {type_value, card_column, FALSE};
    4575             : 
    4576      114405 :                                 e = rel_value_exp2(query, &rel, col, f, ek);
    4577             : 
    4578      114405 :                                 if (e && e->card <= CARD_ATOM) {
    4579        9364 :                                         sql_subtype *tpe = exp_subtype(e);
    4580             :                                         /* integer atom on the stack */
    4581        9364 :                                         if (!is_sql_window(f) && e->type == e_atom &&
    4582        9256 :                                             tpe->type->eclass == EC_NUM) {
    4583        9247 :                                                 atom *a = e->l;
    4584        9247 :                                                 int nr = (int)atom_get_int(a);
    4585             : 
    4586        9247 :                                                 e = exps_get_exp(rel->exps, nr);
    4587        9247 :                                                 if (!e)
    4588           3 :                                                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: the order by column number (%d) is not in the number of projections range (%d)", nr, list_length(rel->exps));
    4589        9244 :                                                 e = exp_ref(sql, e);
    4590             :                                         }
    4591       38297 :                                 } else if (e && exp_card(e) > rel->card) {
    4592           0 :                                         if (exp_name(e) && !has_label(e))
    4593           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(e));
    4594           0 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    4595             :                                 }
    4596      114402 :                                 if (e && !exp_name(e))
    4597          23 :                                         exp_label(sql->sa, e, ++sql->label);
    4598       47658 :                                 if (e && rel && is_project(rel->op)) {
    4599       39370 :                                         sql_exp *found = exps_find_exp(rel->exps, e);
    4600             : 
    4601       39370 :                                         if (!found) {
    4602          33 :                                                 if (needs_distinct)
    4603           0 :                                                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: with DISTINCT ORDER BY expressions must appear in select list");
    4604          33 :                                                 if (!is_freevar(e))
    4605          16 :                                                         append(rel->exps, e);
    4606             :                                         } else {
    4607             :                                                 e = found;
    4608             :                                         }
    4609       39370 :                                         if (!is_freevar(e))
    4610       39353 :                                                 e = exp_ref(sql, e);
    4611             :                                 }
    4612             :                         }
    4613             : 
    4614      114624 :                         if (rel && !e && sql->session->status != -ERR_AMBIGUOUS) {
    4615             :                                 /* reset error */
    4616       66961 :                                 sql->session->status = 0;
    4617       66961 :                                 sql->errstr[0] = '\0';
    4618             : 
    4619       66961 :                                 e = rel_order_by_column_exp(query, &rel, col, needs_distinct, sql_sel | sql_orderby | (f & sql_group_totals) | (f & sql_window));
    4620             :                         }
    4621       66966 :                         if (!e)
    4622             :                                 return NULL;
    4623      114581 :                         if (!exp_subtype(e))
    4624           1 :                                 return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) for order by column");
    4625      114580 :                         set_direction(e, direction);
    4626      114580 :                         list_append(exps, e);
    4627             :                 } else {
    4628           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: order not of type SQL_COLUMN");
    4629             :                 }
    4630             :         }
    4631       45454 :         if (is_sql_orderby(f) && or != rel)
    4632       36597 :                 or->l = rel;
    4633       45454 :         if (is_sql_window(f))
    4634        8857 :                 *R = rel;
    4635             :         return exps;
    4636             : }
    4637             : 
    4638             : static int
    4639         814 : generate_window_bound(tokens sql_token, bool first_half)
    4640             : {
    4641         814 :         switch (sql_token) {
    4642         408 :                 case SQL_PRECEDING:
    4643         408 :                         return first_half ? BOUND_FIRST_HALF_PRECEDING : BOUND_SECOND_HALF_PRECEDING;
    4644         284 :                 case SQL_FOLLOWING:
    4645         284 :                         return first_half ? BOUND_FIRST_HALF_FOLLOWING : BOUND_SECOND_HALF_FOLLOWING;
    4646         122 :                 case SQL_CURRENT_ROW:
    4647         122 :                         return first_half ? CURRENT_ROW_PRECEDING : CURRENT_ROW_FOLLOWING;
    4648             :                 default:
    4649           0 :                         assert(0);
    4650             :         }
    4651             :         return 0;
    4652             : }
    4653             : 
    4654             : /* window functions */
    4655             : static sql_exp*
    4656         407 : generate_window_bound_call(mvc *sql, sql_exp **estart, sql_exp **eend, sql_exp *pe, sql_exp *e,
    4657             :                                                    sql_exp *start, sql_exp *fend, int frame_type, int excl, tokens t1, tokens t2)
    4658             : {
    4659         407 :         list *rargs1 = sa_list(sql->sa), *rargs2 = sa_list(sql->sa), *targs1 = sa_list(sql->sa), *targs2 = sa_list(sql->sa);
    4660         407 :         sql_subfunc *dc1, *dc2;
    4661         407 :         sql_subtype *it = sql_bind_localtype("int");
    4662             : 
    4663         407 :         if (pe) {
    4664         186 :                 append(targs1, exp_subtype(pe));
    4665         186 :                 append(targs2, exp_subtype(pe));
    4666         186 :                 append(rargs1, exp_copy(sql, pe));
    4667         186 :                 append(rargs2, exp_copy(sql, pe));
    4668             :         }
    4669         407 :         append(rargs1, exp_copy(sql, e));
    4670         407 :         append(rargs2, exp_copy(sql, e));
    4671         407 :         append(targs1, exp_subtype(e));
    4672         407 :         append(targs2, exp_subtype(e));
    4673         407 :         append(targs1, it);
    4674         407 :         append(targs2, it);
    4675         407 :         append(targs1, it);
    4676         407 :         append(targs2, it);
    4677         407 :         append(targs1, it);
    4678         407 :         append(targs2, it);
    4679         407 :         append(targs1, exp_subtype(start));
    4680         407 :         append(targs2, exp_subtype(fend));
    4681             : 
    4682         407 :         dc1 = sql_bind_func_(sql, "sys", "window_bound", targs1, F_ANALYTIC, true, false);
    4683         407 :         dc2 = sql_bind_func_(sql, "sys", "window_bound", targs2, F_ANALYTIC, true, false);
    4684         407 :         if (!dc1 || !dc2)
    4685           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: function 'window_bound' not found");
    4686         407 :         append(rargs1, exp_atom_int(sql->sa, frame_type));
    4687         407 :         append(rargs2, exp_atom_int(sql->sa, frame_type));
    4688         407 :         append(rargs1, exp_atom_int(sql->sa, generate_window_bound(t1, true)));
    4689         407 :         append(rargs2, exp_atom_int(sql->sa, generate_window_bound(t2, false)));
    4690         407 :         append(rargs1, exp_atom_int(sql->sa, excl));
    4691         407 :         append(rargs2, exp_atom_int(sql->sa, excl));
    4692         407 :         append(rargs1, start);
    4693         407 :         append(rargs2, fend);
    4694             : 
    4695         407 :         *estart = exp_op(sql->sa, rargs1, dc1);
    4696         407 :         *eend = exp_op(sql->sa, rargs2, dc2);
    4697         407 :         return e; /* return something to say there were no errors */
    4698             : }
    4699             : 
    4700             : #define EC_NUMERIC(e) (e==EC_NUM||EC_INTERVAL(e)||e==EC_DEC||e==EC_FLT)
    4701             : 
    4702             : static sql_exp*
    4703         601 : calculate_window_bound(sql_query *query, sql_rel *p, tokens token, symbol *bound, sql_exp *ie, int frame_type, int f)
    4704             : {
    4705         601 :         mvc *sql = query->sql;
    4706         601 :         sql_subtype *bt, *bound_tp = sql_bind_localtype("lng"), *iet = exp_subtype(ie);
    4707         601 :         sql_exp *res = NULL;
    4708             : 
    4709         792 :         if ((bound->token == SQL_PRECEDING || bound->token == SQL_FOLLOWING || bound->token == SQL_CURRENT_ROW) && bound->type == type_int) {
    4710         191 :                 atom *a = NULL;
    4711         191 :                 bt = (frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) ? bound_tp : iet;
    4712             : 
    4713         191 :                 if ((bound->data.i_val == UNBOUNDED_PRECEDING_BOUND || bound->data.i_val == UNBOUNDED_FOLLOWING_BOUND)) {
    4714          69 :                         a = atom_max_value(sql->sa, EC_NUMERIC(bt->type->eclass) ? bt : bound_tp);
    4715         122 :                 } else if (bound->data.i_val == CURRENT_ROW_BOUND) {
    4716         124 :                         a = atom_zero_value(sql->sa, EC_NUMERIC(bt->type->eclass) ? bt : bound_tp);
    4717             :                 } else {
    4718           0 :                         assert(0);
    4719             :                 }
    4720         191 :                 res = exp_atom(sql->sa, a);
    4721             :         } else { /* arbitrary expression case */
    4722         410 :                 exp_kind ek = {type_value, card_column, FALSE};
    4723         410 :                 const char *bound_desc = (token == SQL_PRECEDING) ? "PRECEDING" : "FOLLOWING";
    4724             : 
    4725         410 :                 assert(token == SQL_PRECEDING || token == SQL_FOLLOWING);
    4726         410 :                 if (!(res = rel_value_exp2(query, &p, bound, f, ek)))
    4727           3 :                         return NULL;
    4728         410 :                 if (!(bt = exp_subtype(res))) { /* frame bound is a parameter */
    4729           3 :                         sql_subtype *t = (frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) ? bound_tp : iet;
    4730           3 :                         if (rel_set_type_param(sql, t, p, res, 0) < 0) /* workaround */
    4731             :                                 return NULL;
    4732           3 :                         bt = exp_subtype(res);
    4733             :                 }
    4734         410 :                 if (exp_is_null_no_value_opt(res))
    4735           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s offset must not be NULL", bound_desc);
    4736         409 :                 if ((frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) && bt->type->eclass != EC_NUM && !(res = exp_check_type(sql, bound_tp, p, res, type_equal)))
    4737             :                         return NULL;
    4738         409 :                 if (frame_type == FRAME_RANGE) {
    4739          70 :                         sql_class iet_class = iet->type->eclass;
    4740             : 
    4741          70 :                         if (!EC_NUMERIC(iet_class) && !EC_TEMP(iet_class))
    4742           1 :                                 return sql_error(sql, 02, SQLSTATE(42000) "Ranges with arbitrary expressions are available to numeric, interval and temporal types only");
    4743          12 :                         if (EC_NUMERIC(iet_class) && !(res = exp_check_type(sql, iet, p, res, type_equal)))
    4744             :                                 return NULL;
    4745          69 :                         if ((iet_class == EC_TIME || iet_class == EC_TIME_TZ) && bt->type->eclass != EC_SEC) {
    4746           1 :                                 (void) sql_error(sql, 02, SQLSTATE(42000) "For %s input the %s boundary must be an interval type up to the day", subtype2string2(sql->ta, iet), bound_desc);
    4747           1 :                                 sa_reset(sql->ta);
    4748           1 :                                 return NULL;
    4749             :                         }
    4750          68 :                         if (EC_TEMP(iet->type->eclass) && !EC_INTERVAL(bt->type->eclass)) {
    4751           0 :                                 (void) sql_error(sql, 02, SQLSTATE(42000) "For %s input the %s boundary must be an interval type", subtype2string2(sql->ta, iet), bound_desc);
    4752           0 :                                 sa_reset(sql->ta);
    4753           0 :                                 return NULL;
    4754             :                         }
    4755             :                 }
    4756             :         }
    4757             :         return res;
    4758             : }
    4759             : 
    4760             : static dlist*
    4761          16 : get_window_clauses(mvc *sql, char* ident, symbol **partition_by_clause, symbol **order_by_clause, symbol **frame_clause)
    4762             : {
    4763          16 :         dlist *window_specification = NULL;
    4764          16 :         char *window_ident;
    4765          16 :         int pos;
    4766             : 
    4767          16 :         if (mvc_highwater(sql))
    4768           0 :                 return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
    4769             : 
    4770          16 :         if ((window_specification = frame_get_window_def(sql, ident, &pos)) == NULL)
    4771           1 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window '%s' not found", ident);
    4772             : 
    4773             :         /* avoid infinite lookups */
    4774          15 :         if (frame_check_var_visited(sql, pos))
    4775           1 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: cyclic references to window '%s' found", ident);
    4776          14 :         frame_set_var_visited(sql, pos);
    4777             : 
    4778          14 :         if (window_specification->h->next->data.sym) {
    4779           2 :                 if (*partition_by_clause)
    4780           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: redefinition of PARTITION BY clause from window '%s'", ident);
    4781           2 :                 *partition_by_clause = window_specification->h->next->data.sym;
    4782             :         }
    4783          14 :         if (window_specification->h->next->next->data.sym) {
    4784           4 :                 if (*order_by_clause)
    4785           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: redefinition of ORDER BY clause from window '%s'", ident);
    4786           3 :                 *order_by_clause = window_specification->h->next->next->data.sym;
    4787             :         }
    4788          13 :         if (window_specification->h->next->next->next->data.sym) {
    4789           0 :                 if (*frame_clause)
    4790           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: redefinition of frame clause from window '%s'", ident);
    4791           0 :                 *frame_clause = window_specification->h->next->next->next->data.sym;
    4792             :         }
    4793             : 
    4794          13 :         window_ident = window_specification->h->data.sval;
    4795          13 :         if (window_ident && !get_window_clauses(sql, window_ident, partition_by_clause, order_by_clause, frame_clause))
    4796             :                 return NULL; /* the error was already set */
    4797             : 
    4798             :         return window_specification; /* return something to say there were no errors */
    4799             : }
    4800             : 
    4801             : /*
    4802             :  * select x, y, rank_op() over (partition by x order by y) as, ...
    4803             :                 aggr_op(z) over (partition by y order by x) as, ...
    4804             :  * from table [x,y,z,w,v]
    4805             :  *
    4806             :  * project and order by over x,y / y,x
    4807             :  * a = project( table ) [ x, y, z, w, v ], [ x, y]
    4808             :  * b = project( table ) [ x, y, z, w, v ], [ y, x]
    4809             :  *
    4810             :  * project with order dependent operators, ie combined prev/current value
    4811             :  * aa = project (a) [ x, y, r = rank_op(diff(x) (marks a new partition), rediff(diff(x), y) (marks diff value with in partition)), z, w, v ]
    4812             :  * project(aa) [ aa.x, aa.y, aa.r ] -- only keep current output list
    4813             :  * bb = project (b) [ x, y, a = aggr_op(z, diff(y), rediff(diff(y), x)), z, w, v ]
    4814             :  * project(bb) [ bb.x, bb.y, bb.a ]  -- only keep current output list
    4815             :  */
    4816             : static sql_exp *
    4817       17947 : rel_rankop(sql_query *query, sql_rel **rel, symbol *se, int f)
    4818             : {
    4819       17947 :         mvc *sql = query->sql;
    4820       17947 :         node *n;
    4821       17947 :         dlist *l = se->data.lval, *window_specification = NULL;
    4822       17947 :         symbol *window_function = l->h->data.sym, *partition_by_clause = NULL, *order_by_clause = NULL, *frame_clause = NULL;
    4823       17947 :         char *aname = NULL, *sname = NULL, *window_ident = NULL;
    4824       17947 :         sql_subfunc *wf = NULL;
    4825       17947 :         sql_exp *in = NULL, *pe = NULL, *oe = NULL, *call = NULL, *start = NULL, *eend = NULL, *fstart = NULL, *fend = NULL, *ie = NULL;
    4826       17947 :         sql_rel *p;
    4827       17947 :         list *gbe = NULL, *obe = NULL, *args = NULL, *types = NULL, *fargs = NULL;
    4828       17947 :         dnode *dn = window_function->data.lval->h, *dargs = NULL;
    4829       17947 :         int distinct = 0, frame_type, pos, nf = f, nfargs = 0;
    4830       17947 :         bool is_nth_value, supports_frames, found = false;
    4831             : 
    4832       17947 :         frame_clear_visited_flag(sql); /* clear visited flags before iterating */
    4833             : 
    4834       17947 :         if (l->h->next->type == type_list) {
    4835       17931 :                 window_specification = l->h->next->data.lval;
    4836          16 :         } else if (l->h->next->type == type_string) {
    4837          16 :                 const char* window_alias = l->h->next->data.sval;
    4838          16 :                 if ((window_specification = frame_get_window_def(sql, window_alias, &pos)) == NULL)
    4839           1 :                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: window '%s' not found", window_alias);
    4840          15 :                 frame_set_var_visited(sql, pos);
    4841             :         } else {
    4842           0 :                 assert(0);
    4843             :         }
    4844             : 
    4845       17946 :         window_ident = window_specification->h->data.sval;
    4846       17946 :         partition_by_clause = window_specification->h->next->data.sym;
    4847       17946 :         order_by_clause = window_specification->h->next->next->data.sym;
    4848       17946 :         frame_clause = window_specification->h->next->next->next->data.sym;
    4849             : 
    4850       17946 :         if (window_ident && !get_window_clauses(sql, window_ident, &partition_by_clause, &order_by_clause, &frame_clause))
    4851             :                 return NULL;
    4852             : 
    4853       17943 :         frame_type = frame_clause ? frame_clause->data.lval->h->next->next->data.i_val : FRAME_RANGE;
    4854       17943 :         aname = qname_schema_object(dn->data.lval);
    4855       17943 :         sname = qname_schema(dn->data.lval);
    4856             : 
    4857       17943 :         is_nth_value = !strcmp(aname, "nth_value");
    4858       17943 :         bool is_value = is_nth_value || !strcmp(aname, "first_value") || !strcmp(aname, "last_value");
    4859       17943 :         supports_frames = window_function->token != SQL_RANK || is_value;
    4860             : 
    4861       17943 :         if (is_sql_update_set(f) || is_sql_psm(f) || is_sql_values(f) || is_sql_join(f) || is_sql_where(f) || is_sql_groupby(f) || is_sql_having(f) || is_psm_call(f) || is_sql_from(f)) {
    4862          13 :                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4863          13 :                 const char *clause = is_sql_update_set(f)||is_sql_psm(f)?"in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses (use subquery)":is_sql_values(f)?"on an unique value":
    4864           8 :                                                          is_sql_join(f)?"in JOIN conditions":is_sql_where(f)?"in WHERE clause":is_sql_groupby(f)?"in GROUP BY clause":
    4865           4 :                                                          is_psm_call(f)?"in CALL":is_sql_from(f)?"in functions in FROM":"in HAVING clause";
    4866          13 :                 return sql_error(sql, 02, SQLSTATE(42000) "%s: window function '%s' not allowed %s", toUpperCopy(uaname, aname), aname, clause);
    4867       17930 :         } else if (is_sql_aggr(f)) {
    4868           2 :                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4869           2 :                 return sql_error(sql, 02, SQLSTATE(42000) "%s: window functions not allowed inside aggregation functions", toUpperCopy(uaname, aname));
    4870       17928 :         } else if (is_sql_window(f)) {
    4871           6 :                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4872           6 :                 return sql_error(sql, 02, SQLSTATE(42000) "%s: window functions cannot be nested", toUpperCopy(uaname, aname));
    4873             :         }
    4874       17922 :         if (window_function->token == SQL_UNOP || window_function->token == SQL_OP) {
    4875        3246 :                 window_function->token = SQL_NOP;
    4876        3246 :                 dn->next->next->data.lval = dlist_append_symbol(sql->sa, dlist_create( sql->sa ), dn->next->next->data.sym); /* make a list */
    4877             :         }
    4878       17922 :         if (window_function->token == SQL_BINOP) {
    4879        5149 :                 window_function->token = SQL_NOP;
    4880        5149 :                 dn->next->next->data.lval = dlist_append_symbol(sql->sa, dlist_append_symbol(sql->sa, dlist_create( sql->sa ), dn->next->next->data.sym), dn->next->next->next->data.sym); /* make a list */
    4881        5149 :                 dn->next->next->next = dn->next->next->next->next; /* skip second arg */
    4882             :         }
    4883       17922 :         if (window_function->token == SQL_AGGR)
    4884         106 :                 dn->next->next->data.lval = dlist_append_symbol(sql->sa, dlist_create( sql->sa ), dn->next->next->data.sym); /* make a list */
    4885       17922 :         if (window_function->token == SQL_NOP)
    4886        8397 :                 window_function->token = SQL_AGGR;
    4887       17922 :         if (window_function->token != SQL_RANK && window_function->token != SQL_AGGR) {
    4888           0 :                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4889           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window function '%s' unknown", toUpperCopy(uaname, aname));
    4890             :         }
    4891             : 
    4892             :         /* window operations are only allowed in the projection */
    4893       17922 :         if (!is_sql_sel(f))
    4894           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "OVER: only possible within the selection");
    4895             : 
    4896       17922 :         p = *rel;
    4897             :         /* Partition By */
    4898       17922 :         if (partition_by_clause) {
    4899        8208 :                 gbe = rel_partition_groupings(query, &p, partition_by_clause, NULL /* cannot use (selection) column references, as this result is a selection column */, nf | sql_window);
    4900        8208 :                 if (!gbe)
    4901             :                         return NULL;
    4902       16431 :                 for (n = gbe->h ; n ; n = n->next) {
    4903        8231 :                         sql_exp *en = n->data;
    4904             : 
    4905        8231 :                         set_ascending(en);
    4906        8231 :                         set_nulls_first(en);
    4907             :                 }
    4908             :         }
    4909             : 
    4910             :         /* Order By */
    4911       17914 :         if (order_by_clause) {
    4912        8864 :                 obe = rel_order_by(query, &p, order_by_clause, 0, sql_window);
    4913        8864 :                 if (!obe)
    4914             :                         return NULL;
    4915             :         }
    4916             : 
    4917       17907 :         fargs = sa_list(sql->sa);
    4918       17907 :         if (window_function->token == SQL_RANK) { /* rank function call */
    4919        9414 :                 dlist *dl = dn->next->next->data.lval;
    4920        9414 :                 bool is_lag = !strcmp(aname, "lag"), is_lead = !strcmp(aname, "lead"),
    4921        9414 :                          extra_input = !strcmp(aname, "ntile") || !strcmp(aname, "rank") || !strcmp(aname, "dense_rank") || !strcmp(aname, "row_number") || !strcmp(aname, "percent_rank") || !strcmp(aname, "cume_dist");
    4922             : 
    4923        9414 :                 distinct = dn->next->data.i_val;
    4924        9414 :                 if (extra_input) { /* pass an input column for analytic functions that don't require it */
    4925        9230 :                         sql_subfunc *star = sql_bind_func(sql, "sys", "star", NULL, NULL, F_FUNC, true, true);
    4926        9230 :                         in = exp_op(sql->sa, NULL, star);
    4927        9230 :                         append(fargs, in);
    4928             :                 }
    4929        9414 :                 if (dl)
    4930         593 :                         for (dargs = dl->h ; dargs ; dargs = dargs->next) {
    4931         339 :                                 exp_kind ek = {type_value, card_column, FALSE};
    4932         339 :                                 sql_subtype *empty = sql_bind_localtype("void"), *bte = sql_bind_localtype("bte");
    4933             : 
    4934         339 :                                 in = rel_value_exp2(query, &p, dargs->data.sym, f | sql_window | sql_farg, ek);
    4935         339 :                                 if (!in)
    4936           0 :                                         return NULL;
    4937         339 :                                 if (!exp_subtype(in)) { /* we also do not expect parameters here */
    4938           0 :                                         char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4939           0 :                                         return sql_error(sql, 02, SQLSTATE(42000) "%s: parameters not allowed as arguments to window functions", toUpperCopy(uaname, aname));
    4940             :                                 }
    4941         339 :                                 if (!exp_name(in))
    4942         151 :                                         exp_label(sql->sa, in, ++sql->label);
    4943             : 
    4944             :                                 /* corner case, if the argument is null convert it into something countable such as bte */
    4945         339 :                                 if (subtype_cmp(exp_subtype(in), empty) == 0)
    4946          20 :                                         in = exp_convert(sql, in, empty, bte);
    4947         339 :                                 if ((is_lag || is_lead) && nfargs == 2) { /* lag and lead 3rd arg must have same type as 1st arg */
    4948          10 :                                         sql_exp *first = (sql_exp*) fargs->h->data;
    4949          10 :                                         if (!(in = exp_check_type(sql, exp_subtype(first), p, in, type_equal)))
    4950             :                                                 return NULL;
    4951             :                                 }
    4952         329 :                                 if (!in)
    4953             :                                         return NULL;
    4954             : 
    4955         339 :                                 append(fargs, in);
    4956         339 :                                 in = exp_ref_save(sql, in);
    4957         339 :                                 nfargs++;
    4958             :                         }
    4959             :         } else { /* aggregation function call */
    4960        8493 :                 distinct = dn->next->data.i_val;
    4961       22022 :                 for (dargs = dn->next->next->data.lval->h ; dargs && dargs->data.sym ; dargs = dargs->next) {
    4962       13537 :                         exp_kind ek = {type_value, card_column, FALSE};
    4963       13537 :                         sql_subtype *empty = sql_bind_localtype("void"), *bte = sql_bind_localtype("bte");
    4964             : 
    4965       13537 :                         in = rel_value_exp2(query, &p, dargs->data.sym, f | sql_window | sql_farg, ek);
    4966       13537 :                         if (!in)
    4967           8 :                                 return NULL;
    4968       13530 :                         if (!exp_subtype(in)) { /* we also do not expect parameters here */
    4969           1 :                                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4970           1 :                                 return sql_error(sql, 02, SQLSTATE(42000) "%s: parameters not allowed as arguments to window functions", toUpperCopy(uaname, aname));
    4971             :                         }
    4972       13529 :                         if (!exp_name(in))
    4973       10112 :                                 exp_label(sql->sa, in, ++sql->label);
    4974             : 
    4975             :                         /* corner case, if the argument is null convert it into something countable such as bte */
    4976       13529 :                         if (subtype_cmp(exp_subtype(in), empty) == 0)
    4977          46 :                                 in = exp_convert(sql, in, empty, bte);
    4978       13529 :                         if (!in)
    4979             :                                 return NULL;
    4980             : 
    4981       13529 :                         append(fargs, in);
    4982       13529 :                         in = exp_ref_save(sql, in);
    4983       13529 :                         nfargs++;
    4984             : 
    4985       13529 :                         if (!strcmp(aname, "count"))
    4986          86 :                                 append(fargs, exp_atom_bool(sql->sa, 1)); /* ignore nills */
    4987             :                 }
    4988             : 
    4989        8485 :                 if (!nfargs) { /* count(*) */
    4990         109 :                         if (window_function->token == SQL_AGGR && strcmp(aname, "count") != 0) {
    4991           2 :                                 char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
    4992           2 :                                 return sql_error(sql, 02, SQLSTATE(42000) "%s: unable to perform '%s(*)'", toUpperCopy(uaname, aname), aname);
    4993             :                         }
    4994         107 :                         sql_subfunc *star = sql_bind_func(sql, "sys", "star", NULL, NULL, F_FUNC, true, true);
    4995         107 :                         in = exp_op(sql->sa, NULL, star);
    4996         107 :                         append(fargs, in);
    4997         107 :                         append(fargs, exp_atom_bool(sql->sa, 0)); /* don't ignore nills */
    4998             :                 }
    4999             :         }
    5000             : 
    5001       17897 :         if (distinct)
    5002           4 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: DISTINCT clause is not implemented for window functions");
    5003             : 
    5004             :         /* diff for partitions */
    5005       17893 :         if (gbe) {
    5006        8191 :                 sql_subtype *bt = sql_bind_localtype("bit");
    5007             : 
    5008       16412 :                 for( n = gbe->h; n; n = n->next) {
    5009        8222 :                         sql_subfunc *df;
    5010        8222 :                         sql_exp *e = n->data;
    5011             : 
    5012        8222 :                         if (!exp_subtype(e))
    5013           1 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameters not allowed at PARTITION BY clause from window functions");
    5014             : 
    5015        8221 :                         e = exp_copy(sql, e);
    5016        8221 :                         args = sa_list(sql->sa);
    5017        8221 :                         if (pe) {
    5018          31 :                                 df = sql_bind_func(sql, "sys", "diff", bt, exp_subtype(e), F_ANALYTIC, true, true);
    5019          31 :                                 append(args, pe);
    5020             :                         } else {
    5021        8190 :                                 df = sql_bind_func(sql, "sys", "diff", exp_subtype(e), NULL, F_ANALYTIC, true, true);
    5022             :                         }
    5023        8221 :                         if (!df)
    5024           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: function 'diff' not found");
    5025        8221 :                         append(args, e);
    5026        8221 :                         pe = exp_op(sql->sa, args, df);
    5027             :                 }
    5028             :         } else {
    5029        9702 :                 pe = exp_atom_bool(sql->sa, 0);
    5030             :         }
    5031             : 
    5032             :         /* diff for orderby */
    5033       17892 :         if (obe) {
    5034        8855 :                 sql_subtype *bt = sql_bind_localtype("bit");
    5035             : 
    5036       17756 :                 for( n = obe->h; n; n = n->next) {
    5037        8901 :                         sql_subfunc *df;
    5038        8901 :                         sql_exp *e = n->data;
    5039             : 
    5040        8901 :                         if (!exp_subtype(e))
    5041           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameters not allowed at ORDER BY clause from window functions");
    5042             : 
    5043        8901 :                         e = exp_copy(sql, e);
    5044        8901 :                         args = sa_list(sql->sa);
    5045        8901 :                         if (oe) {
    5046          46 :                                 df = sql_bind_func(sql, "sys", "diff", bt, exp_subtype(e), F_ANALYTIC, true, true);
    5047          46 :                                 append(args, oe);
    5048             :                         } else {
    5049        8855 :                                 df = sql_bind_func(sql, "sys", "diff", exp_subtype(e), NULL, F_ANALYTIC, true, true);
    5050             :                         }
    5051        8901 :                         if (!df)
    5052           0 :                                 return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: function 'diff' not found");
    5053        8901 :                         append(args, e);
    5054        8901 :                         oe = exp_op(sql->sa, args, df);
    5055             :                 }
    5056             :         } else {
    5057        9037 :                 oe = exp_atom_bool(sql->sa, 0);
    5058             :         }
    5059             : 
    5060       17892 :         if (frame_clause || supports_frames) {
    5061        8596 :                 if (frame_type == FRAME_RANGE)
    5062        8285 :                         ie = obe ? (sql_exp*) obe->t->data : in;
    5063             :                 else
    5064         311 :                         ie = obe ? oe : in;
    5065             :         }
    5066       17892 :         assert(oe && pe);
    5067             : 
    5068       17892 :         types = exp_types(sql->sa, fargs);
    5069       17892 :         wf = bind_func_(sql, sname, aname, types, F_ANALYTIC, false, &found, false);
    5070       17892 :         if (wf && !list_empty(fargs) && !(fargs = check_arguments_and_find_largest_any_type(sql, NULL, fargs, wf, 0, false)))
    5071             :                 wf = NULL;
    5072       17887 :         if (!wf) {
    5073           5 :                 char *arg_list = nfargs ? nary_function_arg_types_2str(sql, types, nfargs) : NULL;
    5074          10 :                 return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s window function %s%s%s'%s'(%s)",
    5075           5 :                                                  found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", aname, arg_list ? arg_list : "");
    5076             :         }
    5077             : 
    5078             :         /* Frame */
    5079       17887 :         if (frame_clause) {
    5080         410 :                 dnode *d = frame_clause->data.lval->h;
    5081         410 :                 symbol *wstart = d->data.sym, *wend = d->next->data.sym, *rstart = wstart->data.lval->h->data.sym,
    5082         410 :                            *rend = wend->data.lval->h->data.sym;
    5083         410 :                 int excl = d->next->next->next->data.i_val;
    5084         410 :                 bool shortcut = false;
    5085             : 
    5086         410 :                 if (!supports_frames)
    5087           4 :                         return sql_error(sql, 02, SQLSTATE(42000) "OVER: frame extend only possible with aggregation and first_value, last_value and nth_value functions");
    5088         406 :                 if (excl != EXCLUDE_NONE)
    5089           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "Only EXCLUDE NO OTHERS exclusion is currently implemented");
    5090         406 :                 if (list_empty(obe) && frame_type == FRAME_GROUPS)
    5091           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "GROUPS frame requires an order by expression");
    5092         404 :                 if (wstart->token == SQL_FOLLOWING && wend->token == SQL_PRECEDING)
    5093           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "FOLLOWING offset must come after PRECEDING offset");
    5094         403 :                 if (wstart->token == SQL_CURRENT_ROW && wend->token == SQL_PRECEDING)
    5095           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "CURRENT ROW offset must come after PRECEDING offset");
    5096         402 :                 if (wstart->token == SQL_FOLLOWING && wend->token == SQL_CURRENT_ROW)
    5097           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "FOLLOWING offset must come after CURRENT ROW offset");
    5098         401 :                 if (wstart->token != SQL_CURRENT_ROW && wend->token != SQL_CURRENT_ROW && wstart->token == wend->token && frame_type != FRAME_ROWS)
    5099           4 :                         return sql_error(sql, 02, SQLSTATE(42000) "Non-centered windows are only supported in row frames");
    5100         367 :                 if (frame_type == FRAME_RANGE) {
    5101          97 :                         if (((wstart->token == SQL_PRECEDING || wstart->token == SQL_FOLLOWING) && rstart->token != SQL_PRECEDING && rstart->token != SQL_CURRENT_ROW && rstart->token != SQL_FOLLOWING) ||
    5102          59 :                                 ((wend->token == SQL_PRECEDING || wend->token == SQL_FOLLOWING) && rend->token != SQL_PRECEDING && rend->token != SQL_CURRENT_ROW && rend->token != SQL_FOLLOWING)) {
    5103          40 :                                 if (list_empty(obe))
    5104           2 :                                         return sql_error(sql, 02, SQLSTATE(42000) "RANGE frame with PRECEDING/FOLLOWING offset requires an order by expression");
    5105          38 :                                 if (list_length(obe) > 1)
    5106           0 :                                         return sql_error(sql, 02, SQLSTATE(42000) "RANGE with offset PRECEDING/FOLLOWING requires exactly one ORDER BY column");
    5107             :                         }
    5108             :                 }
    5109             : 
    5110         395 :                 if (list_empty(obe) && frame_type == FRAME_RANGE) { /* window functions are weird */
    5111             :                         frame_type = FRAME_ALL;
    5112             :                         shortcut = true;
    5113         383 :                 } else if (!is_value && (rstart->token == SQL_PRECEDING || rstart->token == SQL_CURRENT_ROW || rstart->token == SQL_FOLLOWING) && rstart->type == type_int &&
    5114         150 :                         (rend->token == SQL_PRECEDING || rend->token == SQL_CURRENT_ROW || rend->token == SQL_FOLLOWING) && rend->type == type_int) {
    5115             :                          /* special cases, don't calculate bounds */
    5116         146 :                         if (frame_type != FRAME_ROWS && rstart->data.i_val == UNBOUNDED_PRECEDING_BOUND && rend->data.i_val == CURRENT_ROW_BOUND) {
    5117             :                                 frame_type = FRAME_UNBOUNDED_TILL_CURRENT_ROW;
    5118             :                                 shortcut = true;
    5119          21 :                         } else if (frame_type != FRAME_ROWS && rstart->data.i_val == CURRENT_ROW_BOUND && rend->data.i_val == UNBOUNDED_FOLLOWING_BOUND) {
    5120             :                                 frame_type = FRAME_CURRENT_ROW_TILL_UNBOUNDED;
    5121             :                                 shortcut = true;
    5122          86 :                         } else if (rstart->data.i_val == UNBOUNDED_PRECEDING_BOUND && rend->data.i_val == UNBOUNDED_FOLLOWING_BOUND) {
    5123             :                                 frame_type = FRAME_ALL;
    5124             :                                 shortcut = true;
    5125          76 :                         } else if (rstart->data.i_val == CURRENT_ROW_BOUND && rend->data.i_val == CURRENT_ROW_BOUND) {
    5126         395 :                                 frame_type = FRAME_CURRENT_ROW;
    5127         395 :                                 shortcut = true;
    5128             :                         }
    5129             :                 }
    5130         395 :                 if (!shortcut) {
    5131         302 :                         if (!(fstart = calculate_window_bound(query, p, wstart->token, rstart, ie, frame_type, f | sql_window)))
    5132             :                                 return NULL;
    5133         299 :                         if (!(fend = calculate_window_bound(query, p, wend->token, rend, ie, frame_type, f | sql_window)))
    5134             :                                 return NULL;
    5135         471 :                         if (!generate_window_bound_call(sql, &start, &eend, gbe ? pe : NULL, ie, fstart, fend, frame_type, excl,
    5136             :                                                                                         wstart->token, wend->token))
    5137             :                                 return NULL;
    5138             :                 }
    5139       17477 :         } else if (supports_frames) { /* for analytic functions with no frame clause, we use the standard default values */
    5140        8183 :                 if (is_value) {
    5141         108 :                         sql_subtype *bound_tp = sql_bind_localtype("lng"), *bt = (frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) ? bound_tp : exp_subtype(ie);
    5142         108 :                         unsigned char sclass = bt->type->eclass;
    5143             : 
    5144         135 :                         fstart = exp_atom(sql->sa, atom_max_value(sql->sa, EC_NUMERIC(sclass) ? bt : bound_tp));
    5145         108 :                         fend = order_by_clause ? exp_atom(sql->sa, atom_zero_value(sql->sa, EC_NUMERIC(sclass) ? bt : bound_tp)) :
    5146          33 :                                                                          exp_atom(sql->sa, atom_max_value(sql->sa, EC_NUMERIC(sclass) ? bt : bound_tp));
    5147             : 
    5148         157 :                         if (generate_window_bound_call(sql, &start, &eend, gbe ? pe : NULL, ie, fstart, fend, frame_type, EXCLUDE_NONE, SQL_PRECEDING, SQL_FOLLOWING) == NULL)
    5149             :                                 return NULL;
    5150             :                 } else {
    5151        8075 :                         frame_type = list_empty(obe) ? FRAME_ALL : FRAME_UNBOUNDED_TILL_CURRENT_ROW;
    5152             :                 }
    5153             :         }
    5154             : 
    5155       17869 :         args = sa_list(sql->sa);
    5156       41217 :         for (node *n = fargs->h ; n ; n = n->next)
    5157       23348 :                 list_append(args, n->data);
    5158       17869 :         list_append(args, pe);
    5159       17869 :         list_append(args, oe);
    5160       17869 :         if (supports_frames) {
    5161        8575 :                 list_append(args, exp_atom_int(sql->sa, frame_type));
    5162        8575 :                 list_append(args, start ? start : exp_atom_oid(sql->sa, 1));
    5163        8575 :                 list_append(args, eend ? eend : exp_atom_oid(sql->sa, 1));
    5164             :         }
    5165       17869 :         call = exp_rank_op(sql->sa, list_empty(args) ? NULL : args, gbe, obe, wf);
    5166       17869 :         *rel = p;
    5167       17869 :         return call;
    5168             : }
    5169             : 
    5170             : sql_exp *
    5171     5746098 : rel_value_exp2(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek)
    5172             : {
    5173     5746098 :         mvc *sql = query->sql;
    5174     5746098 :         if (!se)
    5175             :                 return NULL;
    5176             : 
    5177     5746098 :         if (mvc_highwater(sql))
    5178          16 :                 return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
    5179             : 
    5180     5746085 :         if (rel && *rel && (*rel)->card == CARD_AGGR) { /* group by expression case, handle it before */
    5181      105569 :                 sql_exp *exp = NULL;
    5182      105569 :                 if (!is_sql_aggr(f) && !is_sql_window(f))
    5183      105111 :                         exp = frame_get_groupby_expression(sql, se);
    5184      105569 :                 if (sql->errstr[0] != '\0')
    5185             :                         return NULL;
    5186      105569 :                 if (exp) {
    5187          78 :                         sql_exp *res = exp_ref(sql, exp);
    5188          78 :                         res->card = (*rel)->card;
    5189          78 :                         if (se->token == SQL_AGGR) {
    5190           0 :                                 dlist *l = se->data.lval;
    5191           0 :                                 int distinct = l->h->next->data.i_val;
    5192           0 :                                 if (distinct)
    5193           0 :                                         set_distinct(res);
    5194             :                         }
    5195          78 :                         if (!query_has_outer(query) && is_groupby((*rel)->op))
    5196          74 :                                 res = rel_groupby_add_aggr(sql, *rel, res);
    5197          78 :                         return res;
    5198             :                 }
    5199             :         }
    5200             : 
    5201     5746007 :         switch (se->token) {
    5202        1827 :         case SQL_OP:
    5203        1827 :                 return rel_op(query, rel, se, f, ek);
    5204       77527 :         case SQL_UNOP:
    5205       77527 :                 return rel_unop(query, rel, se, f, ek);
    5206      373867 :         case SQL_BINOP:
    5207      373867 :                 return rel_binop(query, rel, se, f, ek);
    5208       84770 :         case SQL_NOP:
    5209       84770 :                 return rel_nop(query, rel, se, f, ek);
    5210       18725 :         case SQL_AGGR:
    5211       18725 :                 return rel_aggr(query, rel, se, f);
    5212       17947 :         case SQL_WINDOW:
    5213       17947 :                 return rel_rankop(query, rel, se, f);
    5214     2317257 :         case SQL_IDENT:
    5215             :         case SQL_COLUMN:
    5216     2317257 :                 return rel_column_ref(query, rel, se, f );
    5217        3007 :         case SQL_NAME: {
    5218        3007 :                 dlist *l = se->data.lval;
    5219        3007 :                 const char *sname = qname_schema(l);
    5220        3007 :                 const char *vname = qname_schema_object(l);
    5221        3007 :                 return rel_exp_variable_on_scope(sql, sname, vname);
    5222             :         }
    5223       48145 :         case SQL_VALUES:
    5224             :         case SQL_WITH:
    5225             :         case SQL_SELECT: {
    5226       48145 :                 sql_rel *r = NULL;
    5227             : 
    5228       48145 :                 if (is_psm_call(f) || is_sql_merge(f))
    5229           8 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: subqueries not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
    5230       48141 :                 if (rel && *rel)
    5231       34116 :                         query_push_outer(query, *rel, f);
    5232       48141 :                 if (se->token == SQL_WITH) {
    5233          30 :                         r = rel_with_query(query, se);
    5234       48111 :                 } else if (se->token == SQL_VALUES) {
    5235         214 :                         r = rel_values(query, se, NULL);
    5236             :                 } else {
    5237       47897 :                         assert(se->token == SQL_SELECT);
    5238       47897 :                         exp_kind nek = ek;
    5239       47897 :                         nek.aggr = is_sql_aggr(f);
    5240       47897 :                         if (is_sql_no_subquery(f))
    5241           2 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery not allowed");
    5242             : 
    5243       47895 :                         r = rel_subquery(query, se, nek);
    5244       47895 :                         if (r)
    5245       47795 :                                 exps_label(sql, r->exps);
    5246             :                 }
    5247       48139 :                 if (rel && *rel) {
    5248       34114 :                         *rel = query_pop_outer(query);
    5249       34114 :                         if (is_sql_join(f) && is_groupby((*rel)->op)) {
    5250           0 :                                 return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
    5251       34114 :                         } else if (is_sql_where(f) && is_groupby((*rel)->op)) {
    5252           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
    5253       34114 :                         } else if ((is_sql_update_set(f) || is_sql_psm(f)) && is_groupby((*rel)->op)) {
    5254           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
    5255             :                         }
    5256             :                 }
    5257       48139 :                 if (!r)
    5258             :                         return NULL;
    5259       48036 :                 if (ek.type == type_value && ek.card <= card_set && is_project(r->op) && list_length(r->exps) > 1)
    5260          16 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery must return only one column");
    5261       48020 :                 if (ek.type == type_relation && is_project(r->op) && list_length(r->exps) != ek.type)
    5262           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery has too %s columns", list_length(r->exps) < ek.type ? "few" : "many");
    5263       48020 :                 if (ek.type == type_value && list_length(r->exps) == 1 && !is_sql_psm(f)) /* for now don't rename multi attribute results */
    5264       35861 :                         r = rel_zero_or_one(sql, r, ek);
    5265       48020 :                 return exp_rel(sql, r);
    5266             :         }
    5267         215 :         case SQL_TABLE: {
    5268             :                 /* turn a subquery into a tabular result */
    5269         215 :                 *rel = rel_selects(query, se->data.sym);
    5270         215 :                 if (*rel)
    5271         213 :                         return lastexp(*rel);
    5272             :                 return NULL;
    5273             :         }
    5274        1612 :         case SQL_PARAMETER: {
    5275        1612 :                 assert(se->type == type_int);
    5276        1612 :                 sql_arg *a = sql_bind_paramnr(sql, se->data.i_val);
    5277        1612 :                 if (sql->emode != m_prepare) {
    5278           1 :                         if (a && a->name && a->name[0])
    5279           1 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: named placeholder ('%s') but named values list is missing", a->name);
    5280             :                         else
    5281           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameters ('?') not allowed in normal queries, use PREPARE");
    5282             :                 }
    5283        1611 :                 return exp_atom_ref(sql->sa, se->data.i_val, a?&a->type:NULL);
    5284             :         }
    5285      105270 :         case SQL_NULL:
    5286      105270 :                 return exp_null(sql->sa, sql_bind_localtype("void"));
    5287        1584 :         case SQL_NEXT:
    5288        1584 :                 return rel_next_value_for(sql, se);
    5289      169049 :         case SQL_CAST:
    5290      169049 :                 return rel_cast(query, rel, se, f);
    5291      104493 :         case SQL_CASE:
    5292             :         case SQL_COALESCE:
    5293             :         case SQL_NULLIF:
    5294      104493 :                 return rel_case_exp(query, rel, se, f);
    5295           1 :         case SQL_RANK:
    5296           1 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window function %s requires an OVER clause", qname_schema_object(se->data.lval->h->data.lval));
    5297          25 :         case SQL_XMLELEMENT:
    5298             :         case SQL_XMLFOREST:
    5299             :         case SQL_XMLCOMMENT:
    5300             :         case SQL_XMLATTRIBUTE:
    5301             :         case SQL_XMLCONCAT:
    5302             :         case SQL_XMLDOCUMENT:
    5303             :         case SQL_XMLPI:
    5304             :         case SQL_XMLTEXT:
    5305          25 :                 return rel_xml(query, rel, se, f, ek);
    5306     2420686 :         default:
    5307     2420686 :                 return rel_logical_value_exp(query, rel, se, f, ek);
    5308             :         }
    5309             : }
    5310             : 
    5311             : static int exps_has_rank(list *exps);
    5312             : 
    5313             : static int
    5314             : exp_has_rank(sql_exp *e)
    5315             : {
    5316             :         switch(e->type) {
    5317             :         case e_convert:
    5318             :                 return exp_has_rank(e->l);
    5319             :         case e_func:
    5320             :                 if (e->r)
    5321             :                         return 1;
    5322             :                 /* fall through */
    5323             :         case e_aggr:
    5324             :                 return exps_has_rank(e->l);
    5325             :         case e_cmp:
    5326             :                 if (e->flag == cmp_or || e->flag == cmp_filter)
    5327             :                         return exps_has_rank(e->l) || exps_has_rank(e->r);
    5328             :                 if (e->flag == cmp_in || e->flag == cmp_notin)
    5329             :                         return exp_has_rank(e->l) || exps_has_rank(e->r);
    5330             :                 return exp_has_rank(e->l) || exp_has_rank(e->r) || (e->f && exp_has_rank(e->f));
    5331             :         default:
    5332             :                 return 0;
    5333             :         }
    5334             : }
    5335             : 
    5336             : /* TODO create exps_has (list, fptr ) */
    5337             : static int
    5338             : exps_has_rank(list *exps)
    5339             : {
    5340             :         if (!exps || list_empty(exps))
    5341             :                 return 0;
    5342             :         for(node *n = exps->h; n; n=n->next){
    5343             :                 sql_exp *e = n->data;
    5344             : 
    5345             :                 if (exp_has_rank(e))
    5346             :                         return 1;
    5347             :         }
    5348             :         return 0;
    5349             : }
    5350             : 
    5351             : sql_exp *
    5352     4425485 : rel_value_exp(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek)
    5353             : {
    5354     4425485 :         if (!se)
    5355             :                 return NULL;
    5356             : 
    5357     4425485 :         if (mvc_highwater(query->sql))
    5358           2 :                 return sql_error(query->sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
    5359             : 
    5360     4425483 :         sql_exp *e = rel_value_exp2(query, rel, se, f, ek);
    5361     4425467 :         if (e && (se->token == SQL_SELECT || se->token == SQL_TABLE) && !exp_is_rel(e)) {
    5362           0 :                 assert(*rel);
    5363           0 :                 return rel_lastexp(query->sql, *rel);
    5364             :         }
    5365             :         return e;
    5366             : }
    5367             : 
    5368             : static sql_exp *
    5369     1304453 : column_exp(sql_query *query, sql_rel **rel, symbol *column_e, int f)
    5370             : {
    5371     1304453 :         dlist *l = column_e->data.lval;
    5372     1304453 :         exp_kind ek = {type_value, card_column, FALSE};
    5373     1304453 :         sql_exp *ve;
    5374             : 
    5375     1304453 :         if (f == sql_sel && rel && *rel && (*rel)->card < CARD_AGGR)
    5376       82411 :                 ek.card = card_value;
    5377     1304453 :         ve = rel_value_exp(query, rel, l->h->data.sym, f, ek);
    5378     1304438 :         if (!ve)
    5379             :                 return NULL;
    5380             :         /* AS name */
    5381     1303330 :         if (ve && l->h->next->data.sval)
    5382      492716 :                 exp_setname(query->sql, ve, NULL, l->h->next->data.sval);
    5383             :         return ve;
    5384             : }
    5385             : 
    5386             : static int
    5387      806634 : exp_is_not_intern(sql_exp *e)
    5388             : {
    5389      806634 :         return is_intern(e)?-1:0;
    5390             : }
    5391             : 
    5392             : static void
    5393      122251 : rel_remove_internal_exp(sql_rel *rel)
    5394             : {
    5395      122251 :         if (rel->exps) {
    5396      122251 :                 list *n_exps = list_select(rel->exps, rel, (fcmp)&exp_is_not_intern, (fdup)NULL);
    5397             : 
    5398      122251 :                 rel->exps = n_exps;
    5399             :         }
    5400      122251 : }
    5401             : 
    5402             : static inline int
    5403          16 : exp_key(sql_exp *e)
    5404             : {
    5405          16 :         if (e->alias.name)
    5406          16 :                 return hash_key(e->alias.name);
    5407             :         return 0;
    5408             : }
    5409             : 
    5410             : static list *
    5411           5 : group_merge_exps(mvc *sql, list *gexps, list *exps)
    5412             : {
    5413           5 :         int nexps = list_length(gexps) + list_length(exps);
    5414             : 
    5415           5 :         sql_hash *ht = hash_new(sql->ta, nexps, (fkeyvalue)&exp_key);
    5416             : 
    5417           9 :         for (node *n = gexps->h; n ; n = n->next) { /* first add grouping expressions */
    5418           4 :                 sql_exp *e = n->data;
    5419           4 :                 int key = ht->key(e);
    5420             : 
    5421           4 :                 hash_add(ht, key, e);
    5422             :         }
    5423             : 
    5424          17 :         for (node *n = exps->h; n ; n = n->next) { /* then test if the new grouping expressions are already there */
    5425          12 :                 sql_exp *e = n->data;
    5426          12 :                 int key = ht->key(e);
    5427          12 :                 sql_hash_e *he = ht->buckets[key&(ht->size-1)];
    5428          12 :                 bool duplicates = false;
    5429             : 
    5430          16 :                 for (; he && !duplicates; he = he->chain) {
    5431           4 :                         sql_exp *f = he->value;
    5432             : 
    5433           4 :                         if (!exp_equal(e, f))
    5434           4 :                                 duplicates = true;
    5435             :                 }
    5436          12 :                 hash_add(ht, key, e);
    5437          12 :                 if (!duplicates) {
    5438           8 :                         list_append(gexps, e);
    5439           8 :                         n->data = exp_ref(sql, e);
    5440             :                 }
    5441             :         }
    5442           5 :         return gexps;
    5443             : }
    5444             : 
    5445             : static list *
    5446       58029 : rel_table_exp(sql_query *query, sql_rel **rel, symbol *column_e, bool single_exp )
    5447             : {
    5448       58029 :         mvc *sql = query->sql;
    5449       58029 :         if (column_e->token == SQL_TABLE && column_e->data.lval->h->type == type_symbol) {
    5450           0 :                 sql_rel *r;
    5451             : 
    5452           0 :                 if (!is_project((*rel)->op))
    5453             :                         return NULL;
    5454           0 :                 r = rel_named_table_function(query, (*rel)->l, column_e, 0, NULL);
    5455           0 :                 if (!r)
    5456             :                         return NULL;
    5457           0 :                 *rel = r;
    5458           0 :                 return sa_list(sql->sa);
    5459       58029 :         } else if (column_e->token == SQL_TABLE) {
    5460       56921 :                 char *tname = column_e->data.lval->h->data.sval;
    5461       56921 :                 list *exps = NULL;
    5462       56921 :                 sql_rel *project = *rel, *groupby = NULL;
    5463             : 
    5464             :                 /* if there's a group by relation in the tree, skip it for the '*' case and use the underlying projection */
    5465       56921 :                 if (project) {
    5466       66300 :                         while (is_groupby(project->op) || is_select(project->op)) {
    5467        9379 :                                 if (is_groupby(project->op))
    5468           5 :                                         groupby = project;
    5469        9379 :                                 if (project->l)
    5470        9379 :                                         project = project->l;
    5471             :                         }
    5472             :                         assert(project);
    5473             :                 }
    5474             : 
    5475       56921 :                 if (project->op == op_project && project->l && project == *rel && !tname && !rel_is_ref(project) && !need_distinct(project) && single_exp) {
    5476         410 :                         sql_rel *l = project->l;
    5477         410 :                         if (!l || !is_project(l->op) || list_length(project->exps) == list_length(l->exps)) {
    5478         403 :                                 rel_remove_internal_exp(*rel);
    5479         403 :                                 exps = project->exps;
    5480         403 :                                 *rel = project->l;
    5481             :                         }
    5482             :                 }
    5483       56921 :                 if ((exps || (exps = rel_table_projections(sql, project, tname, 0)) != NULL) && !list_empty(exps)) {
    5484       56917 :                         if (!(exps = check_distinct_exp_names(sql, exps)))
    5485           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "Duplicate column names in table%s%s%s projection list", tname ? " '" : "", tname ? tname : "", tname ? "'" : "");
    5486       56917 :                         if (groupby) {
    5487           5 :                                 groupby->exps = group_merge_exps(sql, groupby->exps, exps);
    5488           9 :                                 for (node *n = groupby->exps->h ; n ; n = n->next) {
    5489           8 :                                         sql_exp *e = n->data;
    5490             : 
    5491           8 :                                         if (e->card > groupby->card) {
    5492           4 :                                                 if (exp_name(e) && !has_label(e))
    5493           4 :                                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(e));
    5494           0 :                                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    5495             :                                         }
    5496             :                                 }
    5497             :                         }
    5498       56913 :                         return exps;
    5499             :                 }
    5500           4 :                 if (!tname)
    5501           2 :                         return sql_error(sql, 02, SQLSTATE(42000) "Table expression without table name");
    5502           2 :                 return sql_error(sql, 02, SQLSTATE(42000) "Column expression Table '%s' unknown", tname);
    5503             :         }
    5504             :         return NULL;
    5505             : }
    5506             : 
    5507             : sql_exp *
    5508     1361375 : rel_column_exp(sql_query *query, sql_rel **rel, symbol *column_e, int f)
    5509             : {
    5510     1361375 :         if (column_e->token == SQL_COLUMN || column_e->token == SQL_IDENT)
    5511     1304453 :                 return column_exp(query, rel, column_e, f);
    5512             :         return NULL;
    5513             : }
    5514             : 
    5515             : static sql_rel*
    5516      368671 : rel_where_groupby_nodes(sql_query *query, sql_rel *rel, SelectNode *sn, int *group_totals)
    5517             : {
    5518      368671 :         mvc *sql = query->sql;
    5519             : 
    5520      368671 :         if (sn->where) {
    5521      144847 :                 rel = rel_logical_exp(query, rel, sn->where, sql_where);
    5522      144847 :                 if (!rel) {
    5523          73 :                         if (sql->errstr[0] == 0)
    5524           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "Subquery result missing");
    5525             :                         return NULL;
    5526             :                 }
    5527             :         }
    5528      368598 :         query_processed(query);
    5529             : 
    5530      368596 :         if (rel && sn->groupby) {
    5531        9770 :                 list *gbe = NULL, *sets = NULL;
    5532        9770 :                 int all = 0;
    5533        9770 :                 if (sn->groupby->data.lval == NULL) { /* ALL */
    5534             :                         all = 1;
    5535             :                 } else {
    5536       33104 :                         for (dnode *o = sn->groupby->data.lval->h; o ; o = o->next) {
    5537       23461 :                                 symbol *grouping = o->data.sym;
    5538       23461 :                                 if (grouping->token == SQL_ROLLUP || grouping->token == SQL_CUBE || grouping->token == SQL_GROUPING_SETS) {
    5539         119 :                                         *group_totals |= sql_group_totals;
    5540         119 :                                         break;
    5541             :                                 }
    5542             :                         }
    5543        9762 :                         gbe = rel_groupings(query, &rel, sn->groupby, sn->selection, sql_sel | sql_groupby | *group_totals, false, &sets);
    5544        9762 :                         if (!gbe)
    5545          19 :                                 return NULL;
    5546             :                 }
    5547        9751 :                 rel = rel_groupby(sql, rel, gbe);
    5548        9751 :                 if (rel && all)
    5549           8 :                         rel->flag = 2;
    5550        9751 :                 if (sets && list_length(sets) > 1) { /* if there is only one combination, there is no reason to generate unions */
    5551         114 :                         prop *p = prop_create(sql->sa, PROP_GROUPINGS, rel->p);
    5552         114 :                         p->value.pval = sets;
    5553         114 :                         rel->p = p;
    5554             :                 }
    5555             :         }
    5556             : 
    5557      368577 :         if (rel && sn->having) {
    5558             :                 /* having implies group by, ie if not supplied do a group by */
    5559        1764 :                 if (rel->op != op_groupby)
    5560         128 :                         rel = rel_groupby(sql, rel, NULL);
    5561             :         }
    5562      368577 :         query_processed(query);
    5563      368575 :         return rel;
    5564             : }
    5565             : 
    5566             : static sql_rel*
    5567      367436 : rel_having_limits_nodes(sql_query *query, sql_rel *rel, SelectNode *sn, exp_kind ek, int group_totals)
    5568             : {
    5569      367436 :         mvc *sql = query->sql;
    5570      367436 :         sql_rel *inner = NULL;
    5571      367436 :         int single_value = 1;
    5572             : 
    5573      367436 :         if (is_project(rel->op) && rel->l) {
    5574      367436 :                 inner = rel->l;
    5575      367436 :                 single_value = 0;
    5576             :         }
    5577             : 
    5578      367436 :         if (sn->having) {
    5579        1752 :                 if (inner && is_groupby(inner->op))
    5580        1752 :                         set_processed(inner);
    5581        1752 :                 if (!(inner = rel_logical_exp(query, inner, sn->having, sql_having | group_totals)))
    5582             :                         return NULL;
    5583        1713 :                 if (inner->exps && exps_card(inner->exps) > CARD_AGGR)
    5584           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: cannot compare sets with values, probably an aggregate function missing");
    5585        1713 :                 if (!single_value)
    5586        1713 :                         rel->l = inner;
    5587             :         }
    5588             : 
    5589      367397 :         if (rel && sn->distinct)
    5590        1027 :                 rel = rel_distinct(rel);
    5591             : 
    5592      367397 :         if (rel && sn->orderby) {
    5593       36639 :                 list *obe = NULL;
    5594       36639 :                 sql_rel *sel = NULL, *l = rel->l;
    5595             : 
    5596             :                 /* project( select ) */
    5597       36639 :                 if (sn->having && is_select(l->op)) {
    5598          52 :                         sel = l;
    5599          52 :                         rel->l = l->l;
    5600             :                 }
    5601       36639 :                 rel = rel_orderby(sql, rel);
    5602       36639 :                 set_processed(rel);
    5603       36639 :                 obe = rel_order_by(query, &rel, sn->orderby, sn->distinct, sql_orderby | group_totals);
    5604       36639 :                 if (!obe)
    5605             :                         return NULL;
    5606       36599 :                 rel->r = obe;
    5607       36599 :                 if (sel) {
    5608          51 :                         sql_rel *o = rel, *p = o->l;
    5609          51 :                         p->l = sel;
    5610             :                 }
    5611             :         }
    5612      367357 :         if (!rel)
    5613             :                 return NULL;
    5614             : 
    5615      367357 :         if (sn->limit || sn->offset) {
    5616       16534 :                 sql_subtype *lng = sql_bind_localtype("lng");
    5617       16542 :                 list *exps = new_exp_list(sql->sa);
    5618             : 
    5619       16542 :                 if (sn->limit) {
    5620       16512 :                         sql_exp *l = rel_value_exp(query, NULL, sn->limit, 0, ek);
    5621             : 
    5622       16512 :                         if (!l || !(l=exp_check_type(sql, lng, NULL, l, type_equal)))
    5623           0 :                                 return NULL;
    5624       16512 :                         if ((ek.card != card_relation && sn->limit) &&
    5625             :                                 (ek.card == card_value && sn->limit)) {
    5626          11 :                                 sql_subfunc *zero_or_one = sql_bind_func(sql, "sys", "zero_or_one", exp_subtype(l), NULL, F_AGGR, true, true);
    5627          11 :                                 l = exp_aggr1(sql->sa, l, zero_or_one, 0, 0, CARD_ATOM, has_nil(l));
    5628             :                         }
    5629       16512 :                         list_append(exps, l);
    5630             :                 } else
    5631          30 :                         list_append(exps, exp_atom(sql->sa, atom_general(sql->sa, lng, NULL, 0)));
    5632       16542 :                 if (sn->offset) {
    5633          97 :                         sql_exp *o = rel_value_exp( query, NULL, sn->offset, 0, ek);
    5634          97 :                         if (!o || !(o=exp_check_type(sql, lng, NULL, o, type_equal)))
    5635           0 :                                 return NULL;
    5636          97 :                         list_append(exps, o);
    5637             :                 }
    5638       16542 :                 rel = rel_topn(sql->sa, rel, exps);
    5639             :         }
    5640             : 
    5641      367365 :         if (sn->sample || sn->seed) {
    5642          21 :                 list *exps = new_exp_list(sql->sa);
    5643             : 
    5644          24 :                 if (sn->sample) {
    5645          23 :                         sql_exp *s = rel_value_exp(query, NULL, sn->sample, 0, ek);
    5646          23 :                         if (!s)
    5647             :                                 return NULL;
    5648          23 :                         if (!exp_subtype(s) && rel_set_type_param(sql, sql_bind_localtype("lng"), NULL, s, 0) < 0)
    5649             :                                 return NULL;
    5650          23 :                         list_append(exps, s);
    5651             :                 } else {
    5652           1 :                         assert(sn->seed);
    5653           1 :                         return sql_error(sql, 02, SQLSTATE(42000) "SEED: cannot have SEED without SAMPLE");
    5654             :                 }
    5655          23 :                 if (sn->seed) {
    5656          12 :                         sql_exp *e = rel_value_exp(query, NULL, sn->seed, 0, ek);
    5657          12 :                         if (!e || !(e=exp_check_type(sql, sql_bind_localtype("int"), NULL, e, type_equal)))
    5658           0 :                                 return NULL;
    5659          12 :                         list_append(exps, e);
    5660             :                 }
    5661          23 :                 rel = rel_sample(sql->sa, rel, exps);
    5662             :         }
    5663             : 
    5664             :         /* after parsing the current query, set the group by relation as processed */
    5665      367367 :         if (!sn->having && inner && is_groupby(inner->op))
    5666       28264 :                 set_processed(inner);
    5667      367367 :         if (rel)
    5668      367367 :                 set_processed(rel);
    5669             :         return rel;
    5670             : }
    5671             : 
    5672             : static sql_rel *
    5673          60 : join_on_column_name(sql_query *query, sql_rel *rel, sql_rel *t1, sql_rel *t2, int op, int l_nil, int r_nil)
    5674             : {
    5675          60 :         mvc *sql = query->sql;
    5676          60 :         int found = 0, full = (op == op_full), right = (op == op_right);
    5677          60 :         list *exps = rel_projections(sql, t1, NULL, 1, 0);
    5678          60 :         list *r_exps = rel_projections(sql, t2, NULL, 1, 0);
    5679          60 :         list *outexps = new_exp_list(sql->sa);
    5680             : 
    5681          60 :         if (!exps || !r_exps)
    5682             :                 return NULL;
    5683         236 :         for (node *n = exps->h; n; n = n->next) {
    5684         179 :                 sql_exp *le = n->data;
    5685         179 :                 int multi = 0;
    5686         179 :                 const char *rname = exp_relname(le), *name = exp_name(le);
    5687         179 :                 sql_exp *re = exps_bind_column(r_exps, name, NULL, &multi, 0);
    5688             : 
    5689         179 :                 if (re) {
    5690         136 :                         if (multi)
    5691           3 :                                 return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "NATURAL JOIN: common column name '%s' appears more than once in right table", rname);
    5692         134 :                         multi = 0;
    5693         134 :                         le = exps_bind_column(exps, name, NULL, &multi, 0);
    5694         134 :                         if (multi)
    5695           0 :                                 return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "NATURAL JOIN: common column name '%s' appears more than once in left table", rname);
    5696             : 
    5697         134 :                         found = 1;
    5698         134 :                         if (!(rel = rel_compare_exp(query, rel, le, re, "=", TRUE, 0, 0, 0, 0)))
    5699             :                                 return NULL;
    5700         133 :                         list_remove_data(r_exps, NULL, re);
    5701         133 :                         if (full) {
    5702          12 :                                 sql_exp *cond = rel_unop_(sql, rel, le, "sys", "isnull", card_value);
    5703          12 :                                 if (!cond)
    5704             :                                         return NULL;
    5705          12 :                                 set_has_no_nil(cond);
    5706          12 :                                 if (rel_convert_types(sql, NULL, NULL, &le, &re, 1, type_equal_no_any) < 0)
    5707             :                                         return NULL;
    5708          12 :                                 if (!(le = rel_nop_(sql, rel, cond, re, le, NULL, "sys", "ifthenelse", card_value)))
    5709             :                                         return NULL;
    5710         121 :                         } else if (right) {
    5711           3 :                                 le = re;
    5712             :                         }
    5713         133 :                         exp_setname(sql, le, rname, name);
    5714         133 :                         set_not_unique(le);
    5715         133 :                         append(outexps, le);
    5716             :                 } else {
    5717          43 :                         if (l_nil)
    5718           5 :                                 set_has_nil(le);
    5719          43 :                         set_not_unique(le);
    5720          43 :                         append(outexps, le);
    5721             :                 }
    5722             :         }
    5723          57 :         if (!found)
    5724           2 :                 return sql_error(sql, 02, SQLSTATE(42000) "JOIN: no columns of tables '%s' and '%s' match", rel_name(t1)?rel_name(t1):"", rel_name(t2)?rel_name(t2):"");
    5725          86 :         for (node *n = r_exps->h; n; n = n->next) {
    5726          31 :                 sql_exp *re = n->data;
    5727          31 :                 if (r_nil)
    5728           3 :                         set_has_nil(re);
    5729          31 :                 set_not_unique(re);
    5730          31 :                 append(outexps, re);
    5731             :         }
    5732          55 :         rel = rel_project(sql->sa, rel, outexps);
    5733          55 :         return rel;
    5734             : }
    5735             : 
    5736             : static sql_rel *
    5737      368673 : rel_select_exp(sql_query *query, sql_rel *rel, SelectNode *sn, exp_kind ek)
    5738             : {
    5739      368673 :         mvc *sql = query->sql;
    5740      368673 :         sql_rel *inner = NULL;
    5741      368673 :         int group_totals = 0;
    5742      368673 :         list *pexps = NULL;
    5743             : 
    5744      368673 :         assert(sn->s.token == SQL_SELECT);
    5745      368673 :         if (!sn->selection)
    5746           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: the selection or from part is missing");
    5747             : 
    5748      368673 :         if (!rel)
    5749       72564 :                 rel = rel_project_exp(sql, exp_atom_bool(sql->sa, 1));
    5750      368667 :         rel = rel_where_groupby_nodes(query, rel, sn, &group_totals);
    5751      368668 :         if (sql->session->status) /* rel might be NULL as input, so we have to check for the session status for errors */
    5752             :                 return NULL;
    5753             : 
    5754      368576 :         inner = rel;
    5755      368576 :         pexps = sa_list(sql->sa);
    5756     1728820 :         for (dnode *n = sn->selection->h; n; n = n->next) {
    5757             :                 /* Here we could get real column expressions
    5758             :                  * (including single atoms) but also table results.
    5759             :                  * Therefore we try both rel_column_exp
    5760             :                  * and rel_table_exp.
    5761             :                  */
    5762     1361371 :                 list *te = NULL;
    5763     2722685 :                 sql_exp *ce = rel_column_exp(query, &inner, n->data.sym, sql_sel | group_totals | (ek.aggr?sql_aggr:0));
    5764             : 
    5765     1361360 :                 if (ce) {
    5766     1303331 :                         if (inner && inner->flag && is_groupby(inner->op)) {
    5767          62 :                                 int found = 0;
    5768          62 :                                 list *gbe = inner->r;
    5769             :                                 /* flag == 2 just add to group by/ aggrs and ref-to pexps*/
    5770             :                                 /* flag == 1 find group by exp referencing this column nr */
    5771          62 :                                 if (inner->flag == 2) {
    5772          25 :                                         if (ce->card > CARD_AGGR) {
    5773           9 :                                                 if (!gbe)
    5774           8 :                                                         inner->r = gbe = sa_list(sql->sa);
    5775           9 :                                                 append(gbe, ce);
    5776           9 :                                                 ce = exp_ref(sql, ce);
    5777           9 :                                                 ce->card = CARD_AGGR;
    5778           9 :                                                 list_append(inner->exps, ce);
    5779           9 :                                                 ce = exp_ref(sql, ce);
    5780           9 :                                                 found = 1;
    5781             :                                         }
    5782             :                                 } else {
    5783          81 :                                         for(node *n = gbe->h; n && !found; n = n->next) {
    5784          44 :                                                 sql_exp *e = n->data;
    5785          44 :                                                 if (is_atom(e->type) && !e->alias.name) {
    5786          29 :                                                         atom *a = e->l;
    5787          29 :                                                         int nr = (int)atom_get_int(a);
    5788          29 :                                                         if (nr == (list_length(pexps) + 1)) {
    5789          27 :                                                                 n->data = ce;
    5790          27 :                                                                 ce = exp_ref(sql, ce);
    5791          27 :                                                                 ce->card = CARD_AGGR;
    5792          27 :                                                                 list_append(inner->exps, ce);
    5793          27 :                                                                 ce = exp_ref(sql, ce);
    5794          27 :                                                                 found = 1;
    5795             :                                                         }
    5796             :                                                 }
    5797             :                                         }
    5798             :                                 }
    5799             :                         }
    5800     1303331 :                         pexps = append(pexps, ce);
    5801     1303331 :                         rel = inner;
    5802     1303331 :                         continue;
    5803             :                 } else {
    5804       63041 :                         te = rel_table_exp(query, &rel, n->data.sym, !list_length(pexps) && !n->next);
    5805             :                 }
    5806       58029 :                 if (!ce && !te) {
    5807        1116 :                         if (sql->errstr[0])
    5808             :                                 return NULL;
    5809           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery result missing");
    5810             :                 }
    5811             :                 /* here we should merge the column expressions we
    5812             :                  * obtained so far with the table expression, ie
    5813             :                  * t1.* or a subquery.
    5814             :                  */
    5815       56913 :                 pexps = list_merge(pexps, te, (fdup)NULL);
    5816             :         }
    5817      367449 :         if (rel && is_groupby(rel->op) && rel->flag) {
    5818          34 :                 list *gbe = rel->r;
    5819          34 :                 if (!list_empty(gbe)) {
    5820          68 :                         for (node *n=gbe->h; n; n = n->next) {
    5821          37 :                                 sql_exp *e = n->data;
    5822          37 :                                 if (rel->flag == 1 && is_atom(e->type) && !e->alias.name) {
    5823           1 :                                         atom *a = e->l;
    5824           1 :                                         int nr = (int)atom_get_int(a);
    5825           1 :                                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: GROUP BY position %d is not in select list", nr);
    5826             :                                 }
    5827          36 :                                 if (exp_has_aggr(rel, e))
    5828           2 :                                         return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions are not allowed in GROUP BY");
    5829             :                         }
    5830             :                 }
    5831             :         }
    5832      367446 :         if (rel && is_groupby(rel->op) && (!sn->groupby || rel->flag) && !is_processed(rel)) {
    5833       41666 :                 for (node *n=pexps->h; n; n = n->next) {
    5834       21296 :                         sql_exp *ce = n->data;
    5835       21296 :                         if (rel->card < ce->card && !exp_is_aggr(rel, ce)) {
    5836           0 :                                 if (exp_name(ce) && !has_label(ce))
    5837           0 :                                         return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(ce));
    5838           0 :                                 return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
    5839             :                         }
    5840             :                 }
    5841       20370 :                 set_processed(rel);
    5842             :         }
    5843      367446 :         rel = rel_project(sql->sa, rel, pexps);
    5844             : 
    5845      367437 :         rel = rel_having_limits_nodes(query, rel, sn, ek, group_totals);
    5846      367437 :         return rel;
    5847             : }
    5848             : 
    5849             : static sql_rel*
    5850      121800 : rel_unique_names(mvc *sql, sql_rel *rel)
    5851             : {
    5852      121800 :         list *l;
    5853             : 
    5854      121800 :         if (!is_project(rel->op))
    5855             :                 return rel;
    5856      121800 :         l = sa_list(sql->sa);
    5857      925982 :         for (node *n = rel->exps->h; n; n = n->next) {
    5858      804182 :                 sql_exp *e = n->data;
    5859      804182 :                 const char *name = exp_name(e);
    5860             : 
    5861             :                 /* If there are two identical expression names, there will be ambiguity */
    5862      804182 :                 if (!name || exps_bind_column(l, name, NULL, NULL, 0))
    5863       55459 :                         exp_label(sql->sa, e, ++sql->label);
    5864      804182 :                 append(l,e);
    5865             :         }
    5866      121800 :         rel->exps = l;
    5867      121800 :         return rel;
    5868             : }
    5869             : 
    5870             : static sql_rel *
    5871      368966 : rel_query(sql_query *query, symbol *sq, exp_kind ek)
    5872             : {
    5873      368966 :         mvc *sql = query->sql;
    5874      368966 :         sql_rel *res = NULL;
    5875      368966 :         SelectNode *sn = NULL;
    5876             : 
    5877      368966 :         if (sq->token != SQL_SELECT)
    5878          22 :                 return table_ref(query, sq, 0, NULL);
    5879             : 
    5880             :         /* select ... into is currently not handled here ! */
    5881      368944 :         sn = (SelectNode *) sq;
    5882      368944 :         if (sn->into)
    5883             :                 return NULL;
    5884             : 
    5885      368944 :         if (ek.card != card_relation && sn->orderby)
    5886           0 :                 return sql_error(sql, 01, SQLSTATE(42000) "SELECT: ORDER BY only allowed on outermost SELECT");
    5887             : 
    5888      368944 :         if (sn->window) {
    5889          20 :                 dlist *wl = sn->window->data.lval;
    5890          51 :                 for (dnode *n = wl->h; n ; n = n->next) {
    5891          32 :                         dlist *wd = n->data.sym->data.lval;
    5892          32 :                         const char *name = wd->h->data.sval;
    5893          32 :                         dlist *wdef = wd->h->next->data.lval;
    5894          32 :                         if (frame_get_window_def(sql, name, NULL)) {
    5895           1 :                                 return sql_error(sql, 01, SQLSTATE(42000) "SELECT: Redefinition of window '%s'", name);
    5896          31 :                         } else if (!frame_push_window_def(sql, name, wdef)) {
    5897           0 :                                 return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5898             :                         }
    5899             :                 }
    5900             :         }
    5901             : 
    5902      368943 :         if (sn->from) {
    5903      296378 :                 dlist *fl = sn->from->data.lval;
    5904      296378 :                 sql_rel *fnd = NULL;
    5905      296378 :                 list *refs = new_exp_list(sql->sa); /* Keep list of relation names in order to test for duplicates */
    5906             : 
    5907      734841 :                 for (dnode *n = fl->h; n ; n = n->next) {
    5908      438733 :                         int lateral = check_is_lateral(n->data.sym);
    5909             : 
    5910             :                         /* just used current expression */
    5911      438733 :                         if (lateral && res)
    5912          11 :                                 query_push_outer(query, res, sql_from);
    5913      438733 :                         fnd = table_ref(query, n->data.sym, lateral, refs);
    5914      438733 :                         if (lateral && res)
    5915          11 :                                 res = query_pop_outer(query);
    5916      438733 :                         if (!fnd)
    5917             :                                 break;
    5918      438463 :                         if (res) {
    5919      142341 :                                 res = rel_crossproduct(sql->sa, res, fnd, op_join);
    5920      142341 :                                 if (lateral)
    5921          11 :                                         set_dependent(res);
    5922             :                         } else {
    5923             :                                 res = fnd;
    5924             :                         }
    5925             :                 }
    5926      296378 :                 if (!fnd) {
    5927         270 :                         if (res)
    5928          14 :                                 rel_destroy(res);
    5929         270 :                         return NULL;
    5930             :                 }
    5931       72565 :         } else if (!query_has_outer(query) || !res) {/* only on top level query */
    5932       72563 :                 return rel_select_exp(query, NULL, sn, ek);
    5933             :         }
    5934             : 
    5935      296108 :         sql_rel *rel = NULL;
    5936      296108 :         if (res)
    5937      296108 :                 rel = rel_select_exp(query, res, sn, ek);
    5938      296108 :         if (!rel && res)
    5939        1048 :                 rel_destroy(res);
    5940             :         return rel;
    5941             : }
    5942             : 
    5943             : /* NOTE: does NOT "set" query but instead generate set ops (union, except, intersect) */
    5944             : static sql_rel *
    5945          23 : rel_setquery_corresponding(sql_query *query, sql_rel *l, sql_rel *r, dlist *cols, int op, int outer, bool n_ary_op)
    5946             : {
    5947          23 :         mvc *sql = query->sql;
    5948          23 :         const char *opname = op==SQL_EXCEPT?"EXCEPT":op==SQL_INTERSECT?"INTERSECT":outer?"OUTER UNION":"UNION";
    5949          23 :         list *lexps = sa_list(query->sql->sa), *rexps = sa_list(query->sql->sa);
    5950          23 :         if (!lexps || !rexps)
    5951             :                 return NULL;
    5952          23 :         assert(cols);
    5953          23 :         if (dlist_length(cols)) {
    5954          22 :                 for (dnode *dn = cols->h; dn; dn = dn ->next) {
    5955          13 :                         char *nm = dn->data.sym->data.lval->h->data.sval;
    5956          13 :                         sql_exp *ls, *rs;
    5957             : 
    5958          13 :                         if (!(ls = rel_bind_column(sql, l, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    5959             :                                 return NULL;
    5960          13 :                         if (!(rs = rel_bind_column(sql, r, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    5961             :                                 return NULL;
    5962          13 :                         if ((!outer && (!ls || !rs)) || (outer && !ls && !rs))
    5963           2 :                                 return sql_error(sql, 02, SQLSTATE(42000) "%s: tables '%s' and '%s' do not have a matching column '%s'", opname, rel_name(l)?rel_name(l):"", rel_name(r)?rel_name(r):"", nm);
    5964          11 :                         if (outer && !ls)
    5965           4 :                                 ls = exp_null(sql->sa, exp_subtype(rs));
    5966          11 :                         if (outer && !rs)
    5967           4 :                                 rs = exp_null(sql->sa, exp_subtype(ls));
    5968          11 :                         append(lexps, ls);
    5969          11 :                         append(rexps, rs);
    5970             :                 }
    5971             :         } else {
    5972          12 :                 int found = 0;
    5973          12 :                 list *exps = rel_projections(sql, l, NULL, 1, 0), *r_exps = rel_projections(sql, r, NULL, 1, 0);
    5974          12 :                 if (!exps || !r_exps)
    5975             :                         return NULL;
    5976             :                 /* find cols which exist on both sides */
    5977          35 :                 for (node *n = exps->h; n; n = n->next) {
    5978          23 :                         sql_exp *le = n->data;
    5979          23 :                         int multi = 0;
    5980          23 :                         const char *rname = exp_relname(le), *name = exp_name(le);
    5981          23 :                         sql_exp *re = exps_bind_column(r_exps, name, NULL, &multi, 0);
    5982          23 :                         if (re) {
    5983          13 :                                 if (multi)
    5984           0 :                                         return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "%s: common column name '%s' appears more than once in right table", opname, rname);
    5985          13 :                                 multi = 0;
    5986          13 :                                 le = exps_bind_column(exps, name, NULL, &multi, 0);
    5987          13 :                                 if (multi)
    5988           0 :                                         return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "%s: common column name '%s' appears more than once in left table", opname, rname);
    5989             : 
    5990          13 :                                 found = 1;
    5991          13 :                                 append(lexps, le);
    5992          13 :                                 append(rexps, re);
    5993          13 :                                 list_remove_data(r_exps, NULL, re);
    5994          10 :                         } else if (outer) {
    5995           3 :                                 append(lexps, le);
    5996           3 :                                 re = exp_null(sql->sa, exp_subtype(le));
    5997           3 :                                 append(rexps, re); /* nils */
    5998             :                         }
    5999             :                 }
    6000          12 :                 if (!found)
    6001           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "%s: no columns of tables '%s' and '%s' match", opname, rel_name(l)?rel_name(l):"", rel_name(r)?rel_name(r):"");
    6002          12 :                 if (outer) {
    6003           7 :                         for (node *n = r_exps->h; n; n = n->next) {
    6004           4 :                                 sql_exp *re = n->data, *le;
    6005           4 :                                 append(rexps, re);
    6006           4 :                                 le = exp_null(sql->sa, exp_subtype(re));
    6007           4 :                                 append(lexps, le); /* nils */
    6008             :                         }
    6009             :                 }
    6010             :         }
    6011          21 :         return n_ary_op ?
    6012          21 :                 rel_setop_n_ary_check_types(sql, l, r, lexps, rexps, (operator_type)op) :
    6013           2 :                 rel_setop_check_types(sql, l, r, lexps, rexps, (operator_type)op);
    6014             : }
    6015             : 
    6016             : static sql_rel *
    6017        2481 : rel_setquery_(sql_query *query, sql_rel *l, sql_rel *r, dlist *cols, int op, int outer)
    6018             : {
    6019        2481 :         mvc *sql = query->sql;
    6020        2481 :         sql_rel *rel;
    6021             : 
    6022        2481 :         if (outer && !cols)
    6023           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "UNION: OUTER needs to be combined with CORRESPONDING [ BY ( column list ) ]");
    6024        2481 :         if (!cols) {
    6025        2479 :                 list *ls, *rs;
    6026             : 
    6027        2479 :                 l = rel_unique_names(sql, l);
    6028        2479 :                 r = rel_unique_names(sql, r);
    6029        2479 :                 ls = rel_projections(sql, l, NULL, 0, 1);
    6030        2479 :                 rs = rel_projections(sql, r, NULL, 0, 1);
    6031        2479 :                 rel = rel_setop_check_types(sql, l, r, ls, rs, (operator_type)op);
    6032             :         } else {
    6033           2 :                 rel = rel_setquery_corresponding(query, l, r, cols, op, outer, false);
    6034             :         }
    6035        2481 :         if (rel) {
    6036        2478 :                 rel_setop_set_exps(sql, rel, rel_projections(sql, rel, NULL, 0, 1), false);
    6037        2478 :                 set_processed(rel);
    6038             :         }
    6039             :         return rel;
    6040             : }
    6041             : 
    6042             : /* Generate n-ary set operator */
    6043             : static sql_rel *
    6044       58442 : rel_setquery_n_ary_(sql_query *query, sql_rel *l, sql_rel *r, dlist *cols, int op, int outer)
    6045             : {
    6046             :         /* even though this is for a general n-ary operators in this phase of the query
    6047             :          * processing we gonna have only two operands (so technically it's binary). In
    6048             :          * general this op supports arbitrary number of operands.
    6049             :          */
    6050             :         // TODO: for now we support only multi-union
    6051       58442 :         assert(op == op_munion);
    6052             : 
    6053       58442 :         mvc *sql = query->sql;
    6054       58442 :         sql_rel *rel;
    6055             : 
    6056       58442 :         if (outer && !cols)
    6057           0 :                         return sql_error(sql, 02, SQLSTATE(42000) "UNION: OUTER needs to be combined with CORRESPONDING [ BY ( column list ) ]");
    6058       58442 :         if (!cols) {
    6059             :                 // TODO: make rel_setop_n_ary_check_types to accept a list of rels
    6060             :                 // and a list of lists of exps
    6061       58421 :                 list *ls, *rs;
    6062             : 
    6063       58421 :                 l = rel_unique_names(sql, l);
    6064       58421 :                 r = rel_unique_names(sql, r);
    6065       58421 :                 ls = rel_projections(sql, l, NULL, 0, 1);
    6066       58421 :                 rs = rel_projections(sql, r, NULL, 0, 1);
    6067       58421 :                 rel = rel_setop_n_ary_check_types(sql, l, r, ls, rs, (operator_type)op);
    6068             :         } else {
    6069          21 :                 rel = rel_setquery_corresponding(query, l, r, cols, op, outer, true);
    6070             :         }
    6071             : 
    6072       58442 :         if (rel) {
    6073       58436 :                 rel_setop_n_ary_set_exps(sql, rel, rel_projections(sql, rel, NULL, 0, 1), false);
    6074       58436 :                 set_processed(rel);
    6075             :         }
    6076             : 
    6077             :         return rel;
    6078             : 
    6079             : }
    6080             : 
    6081             : static sql_rel *
    6082       60930 : rel_setquery(sql_query *query, symbol *q)
    6083             : {
    6084       60930 :         mvc *sql = query->sql;
    6085       60930 :         sql_rel *res = NULL;
    6086       60930 :         dnode *n = q->data.lval->h;
    6087       60930 :         symbol *tab_ref1 = n->data.sym;
    6088       60930 :         int distinct = n->next->data.i_val;
    6089       60930 :         dlist *corresponding = n->next->next->data.lval;
    6090       60930 :         symbol *tab_ref2 = n->next->next->next->data.sym;
    6091       60930 :         sql_rel *t1, *t2;
    6092             : 
    6093       60930 :         assert(n->next->type == type_int);
    6094       60930 :         t1 = table_ref(query, tab_ref1, 0, NULL);
    6095       60930 :         if (!t1)
    6096             :                 return NULL;
    6097       60926 :         t2 = table_ref(query, tab_ref2, 0, NULL);
    6098       60926 :         if (!t2)
    6099             :                 return NULL;
    6100             : 
    6101       60924 :         rel_remove_internal_exp(t1);
    6102       60924 :         rel_remove_internal_exp(t2);
    6103       60924 :         if (!corresponding && list_length(t1->exps) != list_length(t2->exps)) {
    6104           1 :                 int t1nrcols = list_length(t1->exps);
    6105           1 :                 int t2nrcols = list_length(t2->exps);
    6106           1 :                 const char *op = "UNION";
    6107           1 :                 if (q->token == SQL_EXCEPT)
    6108             :                         op = "EXCEPT";
    6109           0 :                 else if (q->token == SQL_INTERSECT)
    6110           0 :                         op = "INTERSECT";
    6111           1 :                 rel_destroy(t1);
    6112           1 :                 rel_destroy(t2);
    6113           1 :                 return sql_error(sql, 02, SQLSTATE(42000) "%s: column counts (%d and %d) do not match", op, t1nrcols, t2nrcols);
    6114             :         }
    6115       60923 :         if ( q->token == SQL_UNION) {
    6116       58442 :                 int outer = n->next->next->next->next->data.i_val;
    6117             :                 /* For EXCEPT/INTERSECT the group by is always done within the implementation */
    6118             :                 /* TODO add those later in an optimizer ! */
    6119       58442 :                 if (t1 && distinct)
    6120        2006 :                         t1 = rel_distinct(t1);
    6121       58442 :                 if (t2 && distinct)
    6122        2006 :                         t2 = rel_distinct(t2);
    6123             :                 // TODO: this has to be fixed
    6124             :                 /*res = rel_setquery_(query, t1, t2, corresponding, op_union, outer);*/
    6125       58442 :                 res = rel_setquery_n_ary_(query, t1, t2, corresponding, op_munion, outer);
    6126        2481 :         } else if ( q->token == SQL_EXCEPT)
    6127        2023 :                 res = rel_setquery_(query, t1, t2, corresponding, op_except, 0);
    6128         458 :         else if ( q->token == SQL_INTERSECT)
    6129         458 :                 res = rel_setquery_(query, t1, t2, corresponding, op_inter, 0);
    6130       60923 :         if (res) {
    6131       60914 :                 set_processed(res);
    6132       60914 :                 if (distinct)
    6133        4361 :                         res = rel_distinct(res);
    6134             :         }
    6135             :         return res;
    6136             : }
    6137             : 
    6138             : static sql_rel *
    6139       58714 : rel_joinquery_(sql_query *query, symbol *tab1, int natural, jt jointype, symbol *tab2, symbol *js, list *refs)
    6140             : {
    6141       58714 :         mvc *sql = query->sql;
    6142       58714 :         operator_type op = op_join;
    6143       58714 :         sql_rel *t1 = NULL, *t2 = NULL, *inner, *rel = NULL;
    6144       58714 :         int l_nil = 0, r_nil = 0, lateral = 0;
    6145             : 
    6146       58714 :         switch(jointype) {
    6147             :         case jt_inner:
    6148             :         case jt_cross: op = op_join;
    6149             :                 break;
    6150             :         case jt_left: op = op_left;
    6151             :                 r_nil = 1;
    6152             :                 break;
    6153             :         case jt_right: op = op_right;
    6154             :                 l_nil = 1;
    6155             :                 break;
    6156             :         case jt_full: op = op_full;
    6157             :                 l_nil = 1;
    6158             :                 r_nil = 1;
    6159             :                 break;
    6160             :         }
    6161             : 
    6162             :         /* a dependent join cannot depend on the right side, so disable lateral check for right and full joins */
    6163       58714 :         lateral = (op == op_join || op == op_left) && check_is_lateral(tab2);
    6164       58714 :         t1 = table_ref(query, tab1, 0, refs);
    6165       58714 :         if (t1) {
    6166       58709 :                 if (!lateral) {
    6167       58674 :                         t2 = table_ref(query, tab2, 0, refs);
    6168             :                 } else {
    6169          35 :                         query_processed(query);
    6170          35 :                         query_push_outer(query, t1, sql_from);
    6171          35 :                         t2 = table_ref(query, tab2, 0, refs);
    6172          35 :                         t1 = query_pop_outer(query);
    6173             :                 }
    6174             :         }
    6175       58714 :         if (!t1 || !t2)
    6176             :                 return NULL;
    6177             : 
    6178       58691 :         query_processed(query);
    6179       58691 :         if (strcmp(rel_name(t1), rel_name(t2)) == 0) {
    6180           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: ERROR:  table name '%s' specified more than once", rel_name(t1));
    6181             :         }
    6182       58691 :         inner = rel = rel_crossproduct(sql->sa, t1, t2, op);
    6183       58691 :         if (!rel)
    6184             :                 return NULL;
    6185       58691 :         if (lateral)
    6186          34 :                 set_dependent(rel);
    6187             : 
    6188       58691 :         assert(jointype != jt_cross || (!natural && !js)); /* there are no natural cross joins, or cross joins with conditions */
    6189       58691 :         if (js && natural)
    6190           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: cannot have a NATURAL JOIN with a join specification (ON or USING)");
    6191       58691 :         if (jointype != jt_cross && !js && !natural)
    6192           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: must have NATURAL JOIN or a JOIN with a join specification (ON or USING)");
    6193             : 
    6194       58691 :         if (js && js->token != SQL_USING) {  /* On sql_logical_exp */
    6195       58520 :                 rel = rel_logical_exp(query, rel, js, sql_where | sql_join);
    6196         171 :         } else if (js) {        /* using */
    6197          20 :                 char rname[16], *rnme;
    6198          20 :                 dnode *n = js->data.lval->h;
    6199          20 :                 list *outexps = new_exp_list(sql->sa), *exps;
    6200          20 :                 node *m;
    6201             : 
    6202          20 :                 rnme = sa_strdup(sql->sa, number2name(rname, sizeof(rname), ++sql->label));
    6203          46 :                 for (; n; n = n->next) {
    6204          26 :                         char *nm = n->data.sval;
    6205          26 :                         sql_exp *cond, *ls, *rs;
    6206             : 
    6207          26 :                         if (!(ls = rel_bind_column(sql, t1, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    6208           0 :                                 return NULL;
    6209          26 :                         if (!(rs = rel_bind_column(sql, t2, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
    6210             :                                 return NULL;
    6211          26 :                         if (!ls || !rs)
    6212           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "JOIN: tables '%s' and '%s' do not have a matching column '%s'", rel_name(t1)?rel_name(t1):"", rel_name(t2)?rel_name(t2):"", nm);
    6213          26 :                         if (!(rel = rel_compare_exp(query, rel, ls, rs, "=", TRUE, 0, 0, 0, 0)))
    6214             :                                 return NULL;
    6215          26 :                         if (op != op_join) {
    6216          12 :                                 if (!(cond = rel_unop_(sql, rel, ls, "sys", "isnull", card_value)))
    6217             :                                         return NULL;
    6218          12 :                                 set_has_no_nil(cond);
    6219          12 :                                 if (rel_convert_types(sql, t1, t2, &ls, &rs, 1, type_equal) < 0)
    6220             :                                         return NULL;
    6221          12 :                                 if (!(ls = rel_nop_(sql, rel, cond, rs, ls, NULL, "sys", "ifthenelse", card_value)))
    6222             :                                         return NULL;
    6223             :                         }
    6224          26 :                         exp_setname(sql, ls, rnme, nm);
    6225          26 :                         append(outexps, ls);
    6226          26 :                         if (!rel)
    6227             :                                 return NULL;
    6228             :                 }
    6229          20 :                 exps = rel_projections(sql, t1, NULL, 1, 1);
    6230         199 :                 for (m = exps->h; m; m = m->next) {
    6231         179 :                         const char *nm = exp_name(m->data);
    6232         179 :                         int fnd = 0;
    6233             : 
    6234         429 :                         for (n = js->data.lval->h; n; n = n->next) {
    6235         276 :                                 if (strcmp(nm, n->data.sval) == 0) {
    6236             :                                         fnd = 1;
    6237             :                                         break;
    6238             :                                 }
    6239             :                         }
    6240         179 :                         if (!fnd) {
    6241         153 :                                 sql_exp *ls = m->data;
    6242         153 :                                 if (l_nil)
    6243          18 :                                         set_has_nil(ls);
    6244         153 :                                 set_not_unique(ls);
    6245         153 :                                 append(outexps, ls);
    6246             :                         }
    6247             :                 }
    6248          20 :                 exps = rel_projections(sql, t2, NULL, 1, 1);
    6249         100 :                 for (m = exps->h; m; m = m->next) {
    6250          80 :                         const char *nm = exp_name(m->data);
    6251          80 :                         int fnd = 0;
    6252             : 
    6253         230 :                         for (n = js->data.lval->h; n; n = n->next) {
    6254         176 :                                 if (strcmp(nm, n->data.sval) == 0) {
    6255             :                                         fnd = 1;
    6256             :                                         break;
    6257             :                                 }
    6258             :                         }
    6259          80 :                         if (!fnd) {
    6260          54 :                                 sql_exp *rs = m->data;
    6261          54 :                                 if (r_nil)
    6262          14 :                                         set_has_nil(rs);
    6263          54 :                                 set_not_unique(rs);
    6264          54 :                                 append(outexps, rs);
    6265             :                         }
    6266             :                 }
    6267          20 :                 rel = rel_project(sql->sa, rel, outexps);
    6268         151 :         } else if (jointype != jt_cross) {              /* ! js -> natural join */
    6269          60 :                 rel = join_on_column_name(query, rel, t1, t2, op, l_nil, r_nil);
    6270             :         }
    6271       58691 :         if (!rel)
    6272             :                 return NULL;
    6273       58673 :         if (inner && is_outerjoin(inner->op))
    6274       21689 :                 set_processed(inner);
    6275       58673 :         set_processed(rel);
    6276       58673 :         query_processed(query);
    6277       58673 :         return rel;
    6278             : }
    6279             : 
    6280             : static sql_rel *
    6281       58714 : rel_joinquery(sql_query *query, symbol *q, list *refs)
    6282             : {
    6283       58714 :         dnode *n = q->data.lval->h;
    6284       58714 :         symbol *tab_ref1 = n->data.sym;
    6285       58714 :         int natural = n->next->data.i_val;
    6286       58714 :         jt jointype = (jt) n->next->next->data.i_val;
    6287       58714 :         symbol *tab_ref2 = n->next->next->next->data.sym;
    6288       58714 :         symbol *joinspec = n->next->next->next->next->data.sym;
    6289             : 
    6290       58714 :         assert(n->next->type == type_int);
    6291       58714 :         assert(n->next->next->type == type_int);
    6292       58714 :         return rel_joinquery_(query, tab_ref1, natural, jointype, tab_ref2, joinspec, refs);
    6293             : }
    6294             : 
    6295             : sql_rel *
    6296      368966 : rel_subquery(sql_query *query, symbol *sq, exp_kind ek)
    6297             : {
    6298      368966 :         mvc *sql = query->sql;
    6299             : 
    6300      368966 :         query_processed(query);
    6301      368966 :         if (!stack_push_frame(sql, NULL))
    6302           0 :                 return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
    6303      368964 :         sql_rel *rel = rel_query(query, sq, ek);
    6304      368963 :         stack_pop_frame(sql);
    6305      368965 :         if (!query_has_outer(query))
    6306      332939 :                 query_processed(query);
    6307      368963 :         if (rel && ek.type == type_relation && ek.card < card_set && rel->card >= CARD_AGGR)
    6308          15 :                 return rel_zero_or_one(sql, rel, ek);
    6309             :         return rel;
    6310             : }
    6311             : 
    6312             : sql_rel *
    6313      238082 : rel_selects(sql_query *query, symbol *s)
    6314             : {
    6315      238082 :         mvc *sql = query->sql;
    6316      238082 :         sql_rel *ret = NULL;
    6317             : 
    6318      238082 :         switch (s->token) {
    6319        5663 :         case SQL_WITH:
    6320        5663 :                 ret = rel_with_query(query, s);
    6321        5663 :                 sql->type = Q_TABLE;
    6322        5663 :                 break;
    6323        2177 :         case SQL_VALUES:
    6324        2177 :                 ret = rel_values(query, s, NULL);
    6325        2177 :                 sql->type = Q_TABLE;
    6326        2177 :                 break;
    6327      211120 :         case SQL_SELECT: {
    6328      211120 :                 exp_kind ek = {type_value, card_relation, TRUE};
    6329      211120 :                 SelectNode *sn = (SelectNode *) s;
    6330             : 
    6331      211120 :                 if (sn->into) {
    6332           1 :                         sql->type = Q_SCHEMA;
    6333           1 :                         ret = rel_select_with_into(query, s);
    6334             :                 } else {
    6335      211119 :                         ret = rel_subquery(query, s, ek);
    6336      211115 :                         sql->type = Q_TABLE;
    6337             :                 }
    6338      211116 :         }       break;
    6339           0 :         case SQL_JOIN:
    6340           0 :                 ret = rel_joinquery(query, s, NULL);
    6341           0 :                 sql->type = Q_TABLE;
    6342           0 :                 break;
    6343       19122 :         case SQL_UNION:
    6344             :         case SQL_EXCEPT:
    6345             :         case SQL_INTERSECT:
    6346       19122 :                 ret = rel_setquery(query, s);
    6347       19122 :                 sql->type = Q_TABLE;
    6348       19122 :                 break;
    6349             :         default:
    6350             :                 return NULL;
    6351             :         }
    6352      238078 :         if (!ret && sql->errstr[0] == 0)
    6353           0 :                 (void) sql_error(sql, 02, SQLSTATE(42000) "relational query without result");
    6354             :         return ret;
    6355             : }
    6356             : 
    6357             : sql_rel *
    6358       79023 : schema_selects(sql_query *query, sql_schema *schema, symbol *s)
    6359             : {
    6360       79023 :         mvc *sql = query->sql;
    6361       79023 :         sql_rel *res;
    6362       79023 :         sql_schema *os = cur_schema(sql);
    6363             : 
    6364       79023 :         sql->session->schema = schema;
    6365       79023 :         res = rel_selects(query, s);
    6366       79023 :         sql->session->schema = os;
    6367       79023 :         return res;
    6368             : }
    6369             : 
    6370             : sql_rel *
    6371          26 : rel_loader_function(sql_query *query, symbol* fcall, list *fexps, sql_subfunc **loader_function)
    6372             : {
    6373          26 :         mvc *sql = query->sql;
    6374          26 :         sql_rel *sq = NULL;
    6375          26 :         dnode *l = fcall->data.lval->h;
    6376          26 :         char *sname = qname_schema(l->data.lval);
    6377          26 :         char *fname = qname_schema_object(l->data.lval);
    6378             : 
    6379          26 :         list *tl = sa_list(sql->sa);
    6380          26 :         list *exps = sa_list(sql->sa);
    6381          26 :         if (l->next)
    6382          26 :                 l = l->next; /* skip distinct */
    6383          26 :         if (l->next) { /* table call with subquery */
    6384          22 :                 if (l->next->type == type_symbol || l->next->type == type_list) {
    6385          22 :                         int count = 0;
    6386          22 :                         symbol *subquery = NULL;
    6387          22 :                         dnode *n = NULL;
    6388             : 
    6389          22 :                         if (l->next->type == type_symbol)
    6390             :                                 n = l->next;
    6391             :                         else
    6392           1 :                                 n = l->next->data.lval->h;
    6393             : 
    6394          66 :                         for (dnode *m = n; m; m = m->next) {
    6395          44 :                                 if (m->type == type_symbol && m->data.sym->token == SQL_SELECT)
    6396          44 :                                         subquery = m->data.sym;
    6397          44 :                                 count++;
    6398             :                         }
    6399          22 :                         if (subquery && count > 1)
    6400           0 :                                 return sql_error(sql, 02, SQLSTATE(42000) "SELECT: The input for the loader function '%s' must be either a single sub query, or a list of values", fname);
    6401             : 
    6402          22 :                         if (subquery) {
    6403           0 :                                 exp_kind ek = { type_value, card_relation, TRUE };
    6404           0 :                                 if (!(sq = rel_subquery(query, subquery, ek)))
    6405           0 :                                         return NULL;
    6406             :                         } else {
    6407          22 :                                 exp_kind ek = { type_value, card_column, TRUE };
    6408          22 :                                 list *exps = sa_list(sql->sa);
    6409          88 :                                 for ( ; n; n = n->next) {
    6410          44 :                                         sql_exp *e = rel_value_exp(query, NULL, n->data.sym, sql_sel | sql_from, ek);
    6411             : 
    6412          44 :                                         if (!e)
    6413           0 :                                                 return NULL;
    6414          44 :                                         append(exps, e);
    6415             :                                 }
    6416          22 :                                 sq = rel_project(sql->sa, NULL, exps);
    6417             :                         }
    6418             :                 }
    6419          22 :                 if (!sq)
    6420           0 :                         return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: no such loader function %s%s%s'%s'", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
    6421          66 :                 for (node *en = sq->exps->h; en; en = en->next) {
    6422          44 :                         sql_exp *e = en->data;
    6423             : 
    6424          44 :                         append(exps, e = exp_ref(sql, e));
    6425          44 :                         append(tl, exp_subtype(e));
    6426             :                 }
    6427             :         }
    6428             : 
    6429          26 :         sql_exp *e = NULL;
    6430          26 :         if (!(e = find_table_function(sql, sname, fname, exps, tl, F_LOADER)))
    6431             :                 return NULL;
    6432          25 :         sql_subfunc *sf = e->f;
    6433          25 :         if (sq) {
    6434          66 :                 for (node *n = sq->exps->h, *m = sf->func->ops->h ; n && m ; n = n->next, m = m->next) {
    6435          44 :                         sql_exp *e = (sql_exp*) n->data;
    6436          44 :                         sql_arg *a = (sql_arg*) m->data;
    6437          44 :                         if (!exp_subtype(e) && rel_set_type_param(sql, &(a->type), sq, e, 0) < 0)
    6438             :                                 return NULL;
    6439             :                 }
    6440             :         }
    6441             : 
    6442          25 :         if (loader_function)
    6443          25 :                 *loader_function = sf;
    6444             : 
    6445          28 :         return rel_table_func(sql->sa, sq, e, fexps, (sq)?TABLE_FROM_RELATION:TABLE_PROD_FUNC);
    6446             : }

Generated by: LCOV version 1.14