Changeset: 4cb314abc8b2 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=4cb314abc8b2
Added Files:
        sql/test/BugTracker-2019/Tests/count-distinct.Bug-6790.sql
        sql/test/BugTracker-2019/Tests/count-distinct.Bug-6790.stable.err
        sql/test/BugTracker-2019/Tests/count-distinct.Bug-6790.stable.out
Modified Files:
        MonetDB.spec
        clients/Tests/exports.stable.out
        clients/mapiclient/mhelp.c
        debian/changelog
        gdk/gdk_analytic.h
        gdk/gdk_analytic_func.c
        gdk/gdk_utils.c
        monetdb5/optimizer/opt_postfix.c
        sql/backends/monet5/sql_rank.c
        sql/backends/monet5/sql_upgrades.c
        sql/server/rel_optimizer.c
        
sql/test/BugTracker-2018/Tests/sqlitelogictest-having-not-null-not-in.Bug-6557.sql
        sql/test/BugTracker-2019/Tests/All
        sql/test/analytics/Tests/analytics01.sql
        sql/test/analytics/Tests/analytics01.stable.err
        sql/test/analytics/Tests/analytics01.stable.out
        sql/test/analytics/Tests/analytics13.sql
        sql/test/analytics/Tests/analytics13.stable.out
        sql/test/emptydb-upgrade-chain-hge/Tests/upgrade.stable.out.int128
        
sql/test/emptydb-upgrade-chain-hge/Tests/upgrade.stable.out.powerpc64.int128
        sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out
        sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.32bit
        sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.int128
        sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.powerpc64
        sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.powerpc64.int128
        sql/test/emptydb-upgrade-hge/Tests/upgrade.stable.out.int128
        sql/test/emptydb-upgrade/Tests/upgrade.stable.out
        sql/test/emptydb-upgrade/Tests/upgrade.stable.out.32bit
        sql/test/emptydb-upgrade/Tests/upgrade.stable.out.int128
        sql/test/testdb-upgrade-chain-hge/Tests/upgrade.stable.out.int128
        sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out
        sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out.32bit
        sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out.int128
        sql/test/testdb-upgrade-hge/Tests/upgrade.stable.out.int128
        sql/test/testdb-upgrade/Tests/upgrade.stable.out
        sql/test/testdb-upgrade/Tests/upgrade.stable.out.32bit
        sql/test/testdb-upgrade/Tests/upgrade.stable.out.int128
        tools/mserver/mserver5.c
Branch: json
Log Message:

Merge with default


diffs (truncated from 134725 to 300 lines):

diff --git a/MonetDB.spec b/MonetDB.spec
--- a/MonetDB.spec
+++ b/MonetDB.spec
@@ -1063,8 +1063,6 @@ fi
 - Rebuilt.
 - BZ#3533: SQL aggregate functions avg(), sum() and median() return an
   error when used on a column with datatype interval second
-- BZ#6723: columns aliases duplicates should not be allowed. automatic
-  aliasing required.
 
 * Mon Nov 18 2019 Sjoerd Mullender <sjo...@acm.org> - 11.35.1-20191118
 - Rebuilt.
diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -223,7 +223,7 @@ gdk_return GDKanalyticallead(BAT *r, BAT
 gdk_return GDKanalyticalmax(BAT *r, BAT *b, BAT *s, BAT *e, int tpe);
 gdk_return GDKanalyticalmin(BAT *r, BAT *b, BAT *s, BAT *e, int tpe);
 gdk_return GDKanalyticalnthvalue(BAT *r, BAT *b, BAT *s, BAT *e, BAT *l, const 
void *restrict bound, int tp1, int tp2);
-gdk_return GDKanalyticalntile(BAT *r, BAT *b, BAT *p, int tpe, const void 
*restrict ntile);
+gdk_return GDKanalyticalntile(BAT *r, BAT *b, BAT *p, BAT *n, int tpe, const 
void *restrict ntile);
 gdk_return GDKanalyticalprod(BAT *r, BAT *b, BAT *s, BAT *e, int tp1, int tp2);
 gdk_return GDKanalyticalsum(BAT *r, BAT *b, BAT *s, BAT *e, int tp1, int tp2);
 gdk_return GDKanalyticalwindowbounds(BAT *r, BAT *b, BAT *p, BAT *l, const 
void *restrict bound, int tp1, int tp2, int unit, bool preceding, lng 
first_half);
diff --git a/clients/mapiclient/mhelp.c b/clients/mapiclient/mhelp.c
--- a/clients/mapiclient/mhelp.c
+++ b/clients/mapiclient/mhelp.c
@@ -72,9 +72,9 @@ SQLhelp sqlhelp1[] = {
         "See also https://www.monetdb.org/Documentation/SQLreference/Alter"},
        {"ALTER SEQUENCE",
         "",
-        "ALTER SEQUENCE ident [ AS data_type] [ RESTART [WITH start]] 
[INCREMENT BY increment]\n"
-        "[MINVALUE minvalue | NO MINVALUE] [MAXVALUE maxvalue | NO MAXVALUE] 
[CACHE cachevalue] [[NO] CYCLE]",
-        "ident,data_type",
+        "ALTER SEQUENCE qname [ AS int_datatype] [ RESTART [WITH intval]] 
[INCREMENT BY intval]\n"
+        "[MINVALUE intval | NO MINVALUE] [MAXVALUE intval | NO MAXVALUE] 
[CACHE intval] [[NO] CYCLE]",
+        "int_datatype,intval",
         "See also 
https://www.monetdb.org/Documentation/Manuals/SQLreference/SerialTypes"},
        {"ALTER USER",
         "Change a user's login name or password or default schema",
@@ -209,9 +209,9 @@ SQLhelp sqlhelp1[] = {
         "See also https://www.monetdb.org/Documentation/SQLreference/Schema"},
        {"CREATE SEQUENCE",
         "Define a new integer number sequence generator",
-        "CREATE SEQUENCE ident [ AS data_type] [ START [WITH start]] 
[INCREMENT BY increment]\n"
-        "[MINVALUE minvalue | NO MINVALUE] [MAXVALUE maxvalue | NO MAXVALUE] 
[CACHE cachevalue] [[NO] CYCLE]",
-        "ident,data_type",
+        "CREATE SEQUENCE qname [ AS int_datatype] [ START [WITH intval]] 
[INCREMENT BY intval]\n"
+        "[MINVALUE intval | NO MINVALUE] [MAXVALUE intval | NO MAXVALUE] 
[CACHE intval] [[NO] CYCLE]",
+        "int_datatype,intval",
         "See also 
https://www.monetdb.org/Documentation/Manuals/SQLreference/SerialTypes"},
        {"CREATE STREAM TABLE",
         "Temporary table, locked during updates/ continues query processing",
@@ -548,8 +548,8 @@ SQLhelp sqlhelp2[] = {
         NULL},
        {"column_def",
         NULL,
-        "COLUMN { data_type [ column_option ... ] | SERIAL | BIGSERIAL }",
-        "data_type,column_option",
+        "ident { data_type [ column_option ... ] | SERIAL | BIGSERIAL }",
+        "ident,data_type,column_option",
         NULL},
        {"column_list",
         NULL,
@@ -652,6 +652,11 @@ SQLhelp sqlhelp2[] = {
         "ident [',' ...]",
         "ident",
         NULL},
+       {"int_datatype",
+        NULL,
+        "BIGINT | INTEGER | INT | SMALLINT | TINYINT",
+        NULL,
+        NULL},
        {"interval",
         NULL,
         "INTERVAL [ '+' | '-' ] string start_field TO end_field",
diff --git a/debian/changelog b/debian/changelog
--- a/debian/changelog
+++ b/debian/changelog
@@ -3,8 +3,6 @@ monetdb (11.35.3) unstable; urgency=low
   * Rebuilt.
   * BZ#3533: SQL aggregate functions avg(), sum() and median() return an
     error when used on a column with datatype interval second
-  * BZ#6723: columns aliases duplicates should not be allowed. automatic
-    aliasing required.
 
  -- Sjoerd Mullender <sjo...@acm.org>  Mon, 25 Nov 2019 12:34:22 +0100
 
diff --git a/gdk/gdk_analytic.h b/gdk/gdk_analytic.h
--- a/gdk/gdk_analytic.h
+++ b/gdk/gdk_analytic.h
@@ -18,7 +18,7 @@
 
 gdk_export gdk_return GDKanalyticaldiff(BAT *r, BAT *b, BAT *p, int tpe);
 
-gdk_export gdk_return GDKanalyticalntile(BAT *r, BAT *b, BAT *p, int tpe, 
const void *restrict ntile);
+gdk_export gdk_return GDKanalyticalntile(BAT *r, BAT *b, BAT *p, BAT *n, int 
tpe, const void *restrict ntile);
 gdk_export gdk_return GDKanalyticallag(BAT *r, BAT *b, BAT *p, BUN lag, const 
void *restrict default_value, int tpe);
 gdk_export gdk_return GDKanalyticallead(BAT *r, BAT *b, BAT *p, BUN lead, 
const void *restrict default_value, int tpe);
 
diff --git a/gdk/gdk_analytic_func.c b/gdk/gdk_analytic_func.c
--- a/gdk/gdk_analytic_func.c
+++ b/gdk/gdk_analytic_func.c
@@ -133,102 +133,133 @@ GDKanalyticaldiff(BAT *r, BAT *b, BAT *p
        return GDK_SUCCEED;
 }
 
-#define NTILE_CALC                                     \
-       do {                                            \
-               if (bval >= ncnt) {                     \
-                       j = 1;                          \
-                       for (; rb < rp; j++, rb++)      \
-                               *rb = j;                \
-               } else if (ncnt % bval == 0) {          \
-                       buckets = ncnt / bval;          \
-                       for (; rb < rp; i++, rb++) {    \
-                               if (i == buckets) {     \
-                                       j++;            \
-                                       i = 0;          \
-                               }                       \
-                               *rb = j;                \
-                       }                               \
-               } else {                                \
-                       buckets = ncnt / bval;          \
-                       for (; rb < rp; i++, rb++) {    \
-                               *rb = j;                \
-                               if (i == buckets) {     \
-                                       j++;            \
-                                       i = 0;          \
-                               }                       \
-                       }                               \
-               }                                       \
+#define NTILE_CALC(TPE, NEXT_VALUE, NEXT_CAST) \
+       do {                                    \
+               TPE buckets, i, j; \
+               for (; rb < rp; rb++) { \
+                       TPE val = NEXT_VALUE; \
+                       if (is_##TPE##_nil(val)) {      \
+                               has_nils = true;        \
+                               *rb = TPE##_nil;        \
+                       } else { \
+                               BUN bval = (BUN) val; \
+                               if (bval >= ncnt) {     \
+                                       *rb = (TPE) ((rb - prb1) + 1);  \
+                               } else { \
+                                       buckets = (TPE) (ncnt / bval);  \
+                                       i = (ncnt % bval == 0) ? 1 : 0; \
+                                       j = 1; \
+                                       for (prb2 = prb1; prb2 < rb; i++, 
prb2++) {     \
+                                               if (i == buckets) {     \
+                                                       j++;    \
+                                                       i = 0;  \
+                                               }       \
+                                       } \
+                                       *rb = j;        \
+                               } \
+                       } \
+               } \
        } while (0)
 
-#define ANALYTICAL_NTILE_IMP(TPE)                              \
+#define ANALYTICAL_NTILE_IMP(TPE, NEXT_VALUE, NEXT_CAST)       \
        do {                                                    \
-               TPE j = 1, *rp, *rb, val = *(TPE*) ntile;       \
-               BUN bval = (BUN) val;                           \
-               rb = rp = (TPE*)Tloc(r, 0);                     \
-               if (is_##TPE##_nil(val)) {                      \
-                       TPE *end = rp + cnt;                    \
-                       has_nils = true;                        \
-                       for (; rp < end; rp++)                  \
-                               *rp = TPE##_nil;                \
-               } else if (p) {                                 \
-                       pnp = np = (bit*)Tloc(p, 0);            \
+               TPE *rp, *rb, *prb1, *prb2;     \
+               prb1 = rb = rp = (TPE*)Tloc(r, 0);              \
+               if (p) {                                        \
+                       pnp = np = (bit*)Tloc(p, 0);    \
                        end = np + cnt;                         \
-                       for (; np < end; np++) {                \
+                       for (; np < end; np++) {        \
                                if (*np) {                      \
-                                       i = 0;                  \
-                                       j = 1;                  \
                                        ncnt = np - pnp;        \
                                        rp += ncnt;             \
-                                       NTILE_CALC;             \
-                                       pnp = np;               \
+                                       NTILE_CALC(TPE, NEXT_VALUE, NEXT_CAST);\
+                                       pnp = np;       \
+                                       prb1 = rp;      \
                                }                               \
                        }                                       \
-                       i = 0;                                  \
-                       j = 1;                                  \
                        ncnt = np - pnp;                        \
                        rp += ncnt;                             \
-                       NTILE_CALC;                             \
+                       NTILE_CALC(TPE, NEXT_VALUE, NEXT_CAST); \
                } else {                                        \
                        rp += cnt;                              \
-                       NTILE_CALC;                             \
+                       NTILE_CALC(TPE, NEXT_VALUE, NEXT_CAST);\
                }                                               \
        } while (0)
 
+#define ANALYTICAL_NTILE_SINGLE_IMP(TPE, NEXT_CAST) \
+       do {    \
+               TPE ntl = *(TPE*) ntile; \
+               ANALYTICAL_NTILE_IMP(TPE, ntl, NEXT_CAST); \
+       } while (0)
+
+#define ANALYTICAL_NTILE_MULTI_IMP(TPE, NEXT_CAST) \
+       do {    \
+               BUN k = 0; \
+               TPE *restrict nn = (TPE*)Tloc(n, 0);    \
+               ANALYTICAL_NTILE_IMP(TPE, nn[k++], NEXT_CAST); \
+       } while (0)
+
 gdk_return
-GDKanalyticalntile(BAT *r, BAT *b, BAT *p, int tpe, const void *restrict ntile)
+GDKanalyticalntile(BAT *r, BAT *b, BAT *p, BAT *n, int tpe, const void 
*restrict ntile)
 {
-       BUN cnt = BATcount(b), ncnt = cnt, buckets, i = 0;
+       BUN cnt = BATcount(b), ncnt = cnt;
        bit *np, *pnp, *end;
        bool has_nils = false;
 
-       assert(ntile);
+       assert((n && !ntile) || (!n && ntile));
 
-       switch (tpe) {
-       case TYPE_bte:
-               ANALYTICAL_NTILE_IMP(bte);
-               break;
-       case TYPE_sht:
-               ANALYTICAL_NTILE_IMP(sht);
-               break;
-       case TYPE_int:
-               ANALYTICAL_NTILE_IMP(int);
-               break;
-       case TYPE_lng:
-               ANALYTICAL_NTILE_IMP(lng);
-               break;
+       if (ntile) {
+               switch (tpe) {
+               case TYPE_bte:
+                       ANALYTICAL_NTILE_SINGLE_IMP(bte, val);
+                       break;
+               case TYPE_sht:
+                       ANALYTICAL_NTILE_SINGLE_IMP(sht, val);
+                       break;
+               case TYPE_int:
+                       ANALYTICAL_NTILE_SINGLE_IMP(int, val);
+                       break;
+               case TYPE_lng:
+                       ANALYTICAL_NTILE_SINGLE_IMP(lng, val);
+                       break;
 #ifdef HAVE_HGE
-       case TYPE_hge:
-               ANALYTICAL_NTILE_IMP(hge);
+               case TYPE_hge:
+                       ANALYTICAL_NTILE_SINGLE_IMP(hge, ((val > (hge) 
GDK_lng_max) ? GDK_lng_max : (lng) val));
                break;
 #endif
-       default:
-               GDKerror("GDKanalyticalntile: type %s not supported.\n", 
ATOMname(tpe));
-               return GDK_FAIL;
+               default:
+                       goto nosupport;
+               }
+       } else {
+               switch (tpe) {
+               case TYPE_bte:
+                       ANALYTICAL_NTILE_MULTI_IMP(bte, val);
+                       break;
+               case TYPE_sht:
+                       ANALYTICAL_NTILE_MULTI_IMP(sht, val);
+                       break;
+               case TYPE_int:
+                       ANALYTICAL_NTILE_MULTI_IMP(int, val);
+                       break;
+               case TYPE_lng:
+                       ANALYTICAL_NTILE_MULTI_IMP(lng, val);
+                       break;
+#ifdef HAVE_HGE
+               case TYPE_hge:
+                       ANALYTICAL_NTILE_MULTI_IMP(hge, ((val > (hge) 
GDK_lng_max) ? GDK_lng_max : (lng) val));
+               break;
+#endif
+               default:
+                       goto nosupport;
+               }
        }
        BATsetcount(r, cnt);
        r->tnonil = !has_nils;
        r->tnil = has_nils;
        return GDK_SUCCEED;
+nosupport:
+       GDKerror("GDKanalyticalntile: type %s not supported for the ntile 
type.\n", ATOMname(tpe));
+       return GDK_FAIL;
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to