Changeset: ae9ec61e9d7c for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=ae9ec61e9d7c
Modified Files:
        sql/backends/monet5/rel_bin.c
        sql/server/rel_exp.c
        sql/server/rel_partition.c
        sql/server/rel_propagate.c
        sql/server/rel_psm.c
        sql/server/rel_rel.c
        sql/server/rel_select.c
        sql/server/rel_unnest.c
        sql/server/sql_partition.c
        
sql/test/BugTracker-2008/Tests/too_many_nested_operators.SF-2102167.stable.err
        sql/test/BugTracker-2016/Tests/trigger_bulk.Bug-4045.stable.err
        sql/test/pg_regress/Tests/interval.stable.err
        sql/test/pg_regress/Tests/interval.stable.err.int128
        sql/test/pg_regress/Tests/interval.stable.out
        sql/test/pg_regress/Tests/interval.stable.out.int128
Branch: default
Log Message:

Merge with Nov2019


diffs (truncated from 593 to 300 lines):

diff --git a/sql/backends/monet5/rel_bin.c b/sql/backends/monet5/rel_bin.c
--- a/sql/backends/monet5/rel_bin.c
+++ b/sql/backends/monet5/rel_bin.c
@@ -453,7 +453,7 @@ exp_bin(backend *be, sql_exp *e, stmt *l
        stmt *s = NULL;
 
        if (THRhighwater())
-               return sql_error(be->mvc, 10, SQLSTATE(42000) "query too 
complex: running out of stack space");
+               return sql_error(be->mvc, 10, SQLSTATE(42000) "Query too 
complex: running out of stack space");
 
        if (!e) {
                assert(0);
@@ -1441,7 +1441,7 @@ exp2bin_args(backend *be, sql_exp *e, li
        mvc *sql = be->mvc;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (!e)
                return args;
@@ -1519,7 +1519,7 @@ static list *
 rel2bin_args(backend *be, sql_rel *rel, list *args)
 {
        if (THRhighwater())
-               return sql_error(be->mvc, 10, SQLSTATE(42000) "query too 
complex: running out of stack space");
+               return sql_error(be->mvc, 10, SQLSTATE(42000) "Query too 
complex: running out of stack space");
 
        if (!rel)
                return args;
@@ -3220,7 +3220,7 @@ sql_parse(backend *be, sql_allocator *sa
        bstream * bst;
 
        if (THRhighwater())
-               return sql_error(m, 10, SQLSTATE(42000) "SELECT: too many 
nested operators");
+               return sql_error(m, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        o = MNEW(mvc);
        if (!o)
@@ -5593,7 +5593,7 @@ subrel_bin(backend *be, sql_rel *rel, li
        stmt *s = NULL;
 
        if (THRhighwater())
-               return sql_error(be->mvc, 10, SQLSTATE(42000) "query too 
complex: running out of stack space");;
+               return sql_error(be->mvc, 10, SQLSTATE(42000) "Query too 
complex: running out of stack space");;
 
        if (!rel)
                return s;
diff --git a/sql/server/rel_exp.c b/sql/server/rel_exp.c
--- a/sql/server/rel_exp.c
+++ b/sql/server/rel_exp.c
@@ -2217,7 +2217,7 @@ static int
 exp_set_list_recurse(mvc *sql, sql_subtype *type, sql_exp *e, const char 
**relname, const char** expname)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return -1;
        }
        assert(*relname && *expname);
@@ -2243,7 +2243,7 @@ static int
 exp_set_type_recurse(mvc *sql, sql_subtype *type, sql_exp *e, const char 
**relname, const char** expname)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return -1;
        }
        assert(*relname && *expname);
@@ -2333,7 +2333,7 @@ int
 rel_set_type_recurse(mvc *sql, sql_subtype *type, sql_rel *rel, const char 
**relname, const char **expname)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return -1;
        }
        assert(*relname && *expname);
diff --git a/sql/server/rel_partition.c b/sql/server/rel_partition.c
--- a/sql/server/rel_partition.c
+++ b/sql/server/rel_partition.c
@@ -45,7 +45,7 @@ static void
 find_basetables(mvc *sql, sql_rel *rel, list *tables )
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return;
        }
 
@@ -143,7 +143,7 @@ sql_rel *
 rel_partition(mvc *sql, sql_rel *rel) 
 {
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
        (void)sql;
        if (rel->op == op_basetable) {
                rel->flag = REL_PARTITION;
diff --git a/sql/server/rel_propagate.c b/sql/server/rel_propagate.c
--- a/sql/server/rel_propagate.c
+++ b/sql/server/rel_propagate.c
@@ -411,7 +411,7 @@ static sql_exp*
 exp_change_column_table(mvc *sql, sql_exp *e, sql_table* oldt, sql_table* newt)
 {
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (!e)
                return NULL;
@@ -487,7 +487,7 @@ static sql_rel*
 rel_change_base_table(mvc* sql, sql_rel* rel, sql_table* oldt, sql_table* newt)
 {
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (!rel)
                return NULL;
diff --git a/sql/server/rel_psm.c b/sql/server/rel_psm.c
--- a/sql/server/rel_psm.c
+++ b/sql/server/rel_psm.c
@@ -611,7 +611,7 @@ sequential_block (sql_query *query, sql_
        assert(!restype || !restypelist);
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "SELECT: too many 
nested operators");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (blk->h)
                l = sa_list(sql->sa);
diff --git a/sql/server/rel_rel.c b/sql/server/rel_rel.c
--- a/sql/server/rel_rel.c
+++ b/sql/server/rel_rel.c
@@ -197,7 +197,7 @@ rel_bind_column_(mvc *sql, sql_rel **p, 
        sql_rel *l = NULL, *r = NULL;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        switch(rel->op) {
        case op_join:
@@ -934,7 +934,7 @@ list *
        int include_subquery = (intern==2)?1:0;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (!rel || (!include_subquery && is_subquery(rel) && rel->op == 
op_project))
                return new_exp_list(sql->sa);
@@ -1023,7 +1023,7 @@ rel_bind_path_(mvc *sql, sql_rel *rel, s
        int found = 0;
 
        if (THRhighwater()) {
-               sql_error(sql, 10, SQLSTATE(42000) "query too complex: running 
out of stack space");
+               sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running 
out of stack space");
                return 0;
        }
 
@@ -1525,7 +1525,7 @@ static int
 exp_deps(mvc *sql, sql_exp *e, list *refs, list *l)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return -1;
        }
 
@@ -1608,7 +1608,7 @@ static int
 rel_deps(mvc *sql, sql_rel *r, list *refs, list *l)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return -1;
        }
 
diff --git a/sql/server/rel_select.c b/sql/server/rel_select.c
--- a/sql/server/rel_select.c
+++ b/sql/server/rel_select.c
@@ -37,7 +37,7 @@ rel_table_projections( mvc *sql, sql_rel
        list *exps;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (!rel)
                return NULL;
@@ -2253,7 +2253,7 @@ rel_logical_value_exp(sql_query *query, 
                return NULL;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "SELECT: too many 
nested operators");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        switch (sc->token) {
        case SQL_OR:
@@ -3059,7 +3059,7 @@ rel_logical_exp(sql_query *query, sql_re
                return NULL;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "SELECT: too many 
nested operators");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        switch (sc->token) {
        case SQL_OR:
@@ -5063,7 +5063,7 @@ get_window_clauses(mvc *sql, char* ident
        int pos;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "SELECT: too many 
nested window definitions");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if((window_specification = stack_get_window_def(sql, ident, &pos)) == 
NULL)
                return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window '%s' 
not found", ident);
@@ -5651,7 +5651,7 @@ rel_value_exp2(sql_query *query, sql_rel
                return NULL;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "SELECT: too many 
nested operators");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        if (rel && *rel && (*rel)->card == CARD_AGGR) { //group by expression 
case, handle it before
                sql_exp *exp = stack_get_groupby_expression(sql, se);
@@ -5915,7 +5915,7 @@ rel_value_exp(sql_query *query, sql_rel 
                return NULL;
 
        if (THRhighwater())
-               return sql_error(query->sql, 10, SQLSTATE(42000) "SELECT: too 
many nested operators");
+               return sql_error(query->sql, 10, SQLSTATE(42000) "Query too 
complex: running out of stack space");
 
        e = rel_value_exp2(query, rel, se, f, ek, &is_last);
        if (e && (se->token == SQL_SELECT || se->token == SQL_TABLE) && 
!is_last) {
diff --git a/sql/server/rel_unnest.c b/sql/server/rel_unnest.c
--- a/sql/server/rel_unnest.c
+++ b/sql/server/rel_unnest.c
@@ -37,7 +37,7 @@ int
 exp_has_freevar(mvc *sql, sql_exp *e)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return 0;
        }
 
@@ -75,7 +75,7 @@ exps_have_freevar(mvc *sql, list *exps)
        node *n;
 
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return 0;
        }
        if (!exps)
@@ -92,7 +92,7 @@ int
 rel_has_freevar(mvc *sql, sql_rel *rel)
 {
        if (THRhighwater()) {
-               (void) sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
                return 0;
        }
 
@@ -129,7 +129,7 @@ static list *
 exp_freevar(mvc *sql, sql_exp *e)
 {
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
 
        switch(e->type) {
        case e_column:
@@ -178,7 +178,7 @@ exps_freevar(mvc *sql, list *exps)
        list *c = NULL;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
        if (!exps)
                return NULL;
        for (n = exps->h; n; n = n->next) {
@@ -196,7 +196,7 @@ rel_freevar(mvc *sql, sql_rel *rel)
        list *lexps = NULL, *rexps = NULL, *exps = NULL;
 
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
        if (!rel)
                return NULL;
        switch(rel->op) {
@@ -328,7 +328,7 @@ static sql_exp *
 push_up_project_exp(mvc *sql, sql_rel *rel, sql_exp *e)
 {
        if (THRhighwater())
-               return sql_error(sql, 10, SQLSTATE(42000) "query too complex: 
running out of stack space");
+               return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: 
running out of stack space");
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to