Changeset: ee8ec0b37510 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=ee8ec0b37510
Modified Files:
        clients/odbc/driver/ODBCConvert.c
        clients/odbc/driver/ODBCUtil.c
        common/utils/muuid.c
        configure.ag
        monetdb5/modules/atoms/uuid.c
        
sql/test/BugTracker-2018/Tests/sqlitelogictest-select-not-in-wrong.Bug-6602.sql
        
sql/test/BugTracker-2018/Tests/sqlitelogictest-select-not-in-wrong.Bug-6602.stable.out
Branch: default
Log Message:

Merge with linear-hashing branch.


diffs (truncated from 672 to 300 lines):

diff --git a/clients/odbc/driver/ODBCConvert.c 
b/clients/odbc/driver/ODBCConvert.c
--- a/clients/odbc/driver/ODBCConvert.c
+++ b/clients/odbc/driver/ODBCConvert.c
@@ -39,6 +39,15 @@ typedef struct {
 #endif
 } bignum_t;
 
+typedef union {
+       SQLGUID g;
+       struct {
+               uint32_t d1;
+               uint16_t d2, d3;
+               uint8_t d4[8];
+       } d;
+} uuid_t;
+
 /* Parse a number and store in a bignum_t.
  * 1 is returned if all is well;
  * 2 is returned if there is loss of precision (i.e. overflow of the value);
@@ -1064,6 +1073,7 @@ ODBCFetch(ODBCStmt *stmt,
        /* see SQLExecute.c for possible types */
        switch (sql_type) {
        case SQL_DECIMAL:
+       case SQL_NUMERIC:
        case SQL_TINYINT:
        case SQL_SMALLINT:
        case SQL_INTEGER:
@@ -1122,6 +1132,7 @@ ODBCFetch(ODBCStmt *stmt,
                }
                break;
        case SQL_DOUBLE:
+       case SQL_FLOAT:
        case SQL_REAL:
                if (!parsedouble(data, &fval)) {
                        /* Invalid character value for cast specification */
@@ -1299,6 +1310,7 @@ ODBCFetch(ODBCStmt *stmt,
                                *lenp = sz;
                        break;
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_BIT: {
                        uint64_t f;
                        int n;
@@ -1350,6 +1362,7 @@ ODBCFetch(ODBCStmt *stmt,
                        break;
                }
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                case SQL_REAL: {
                        data = (char *) ptr;
 
@@ -1867,6 +1880,7 @@ ODBCFetch(ODBCStmt *stmt,
                case SQL_WCHAR:
                case SQL_WVARCHAR:
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -1874,6 +1888,7 @@ ODBCFetch(ODBCStmt *stmt,
                case SQL_HUGEINT:
                case SQL_REAL:
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                case SQL_BIT:
                case SQL_TYPE_DATE:
                case SQL_TYPE_TIME:
@@ -1974,6 +1989,7 @@ ODBCFetch(ODBCStmt *stmt,
                        /* fall through */
                case SQL_REAL:
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                        if (fval < 0 || fval >= 2) {
                                /* Numeric value out of range */
                                addStmtError(stmt, "22003", NULL, 0);
@@ -1987,6 +2003,7 @@ ODBCFetch(ODBCStmt *stmt,
                        }
                        break;
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2067,6 +2084,7 @@ ODBCFetch(ODBCStmt *stmt,
                case SQL_WCHAR:
                case SQL_WVARCHAR:
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                case SQL_REAL:
                        /* reparse double and float, parse char */
                        if (!parseint(data, &nval)) {
@@ -2077,6 +2095,7 @@ ODBCFetch(ODBCStmt *stmt,
                        }
                        /* fall through */
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2169,6 +2188,7 @@ ODBCFetch(ODBCStmt *stmt,
                case SQL_WCHAR:
                case SQL_WVARCHAR:
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                case SQL_REAL:
                        /* reparse double and float, parse char */
                        if (!parseint(data, &nval)) {
@@ -2179,6 +2199,7 @@ ODBCFetch(ODBCStmt *stmt,
                        }
                        /* fall through */
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2236,6 +2257,7 @@ ODBCFetch(ODBCStmt *stmt,
                case SQL_WCHAR:
                case SQL_WVARCHAR:
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                case SQL_REAL:
                        /* reparse double and float, parse char */
                        if (!(i = parseint(data, &nval))) {
@@ -2251,6 +2273,7 @@ ODBCFetch(ODBCStmt *stmt,
 
                        /* fall through */
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2305,9 +2328,11 @@ ODBCFetch(ODBCStmt *stmt,
                        }
                        break;
                case SQL_DOUBLE:
+               case SQL_FLOAT:
                case SQL_REAL:
                        break;
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2516,6 +2541,7 @@ ODBCFetch(ODBCStmt *stmt,
                        }
                        break;
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2598,6 +2624,7 @@ ODBCFetch(ODBCStmt *stmt,
                        }
                        break;
                case SQL_DECIMAL:
+               case SQL_NUMERIC:
                case SQL_TINYINT:
                case SQL_SMALLINT:
                case SQL_INTEGER:
@@ -2777,44 +2804,22 @@ ODBCFetch(ODBCStmt *stmt,
 #ifdef ODBCDEBUG
                ODBCLOG("Writing 16 bytes to %p\n", ptr);
 #endif
-               for (i = 0; i < 16; i++) {
-                       if (i == 8 || i == 12 || i == 16 || i == 20) {
-                               if (*data != '-') {
-                                       /* Restricted data type
-                                        * attribute violation */
-                                       addStmtError(stmt, "07006", NULL, 0);
-                                       return SQL_ERROR;
-                               }
-                               data++;
-                       }
-                       if (isdigit((unsigned char) *data))
-                               ((unsigned char *) ptr)[i] = *data - '0';
-                       else if ('a' <= *data && *data <= 'f')
-                               ((unsigned char *) ptr)[i] = *data - 'a' + 10;
-                       else if ('A' <= *data && *data <= 'F')
-                               ((unsigned char *) ptr)[i] = *data - 'A' + 10;
-                       else {
-                               /* Restricted data type attribute
-                                * violation */
-                               addStmtError(stmt, "07006", NULL, 0);
-                               return SQL_ERROR;
-                       }
-                       ((unsigned char *) ptr)[i] <<= 4;
-                       data++;
-                       if (isdigit((unsigned char) *data))
-                               ((unsigned char *) ptr)[i] |= *data - '0';
-                       else if ('a' <= *data && *data <= 'f')
-                               ((unsigned char *) ptr)[i] |= *data - 'a' + 10;
-                       else if ('A' <= *data && *data <= 'F')
-                               ((unsigned char *) ptr)[i] |= *data - 'A' + 10;
-                       else {
-                               /* Restricted data type attribute
-                                * violation */
-                               addStmtError(stmt, "07006", NULL, 0);
-                               return SQL_ERROR;
-                       }
-                       data++;
+               uuid_t u;
+               if (sscanf(data, "%8"SCNx32"-%4"SCNx16"-%4"SCNx16
+                          "-%2"SCNx8"%2"SCNx8"-%2"SCNx8"%2"SCNx8
+                          "%2"SCNx8"%2"SCNx8"%2"SCNx8"%2"SCNx8,
+                          &u.d.d1, &u.d.d2, &u.d.d3, &u.d.d4[0],
+                          &u.d.d4[1], &u.d.d4[2], &u.d.d4[3],
+                          &u.d.d4[4], &u.d.d4[5], &u.d.d4[6],
+                          &u.d.d4[7]) != 11) {
+                       /* Restricted data type attribute
+                        * violation */
+                       addStmtError(stmt, "07006", NULL, 0);
+                       return SQL_ERROR;
                }
+               WriteData(ptr, u.g, SQLGUID);
+               if (lenp)
+                       *lenp = sizeof(SQLGUID);
                break;
        default:
                /* Invalid application buffer type */
@@ -2884,6 +2889,7 @@ ODBCStore(ODBCStmt *stmt,
        TIMESTAMP_STRUCT tsval;
        int ivalprec = 0;       /* interval second precision */
        SQL_INTERVAL_STRUCT ival;
+       uuid_t u;
        char *buf = *bufp;
        size_t bufpos = *bufposp;
        size_t buflen = *buflenp;
@@ -3347,25 +3353,16 @@ ODBCStore(ODBCStmt *stmt,
                        }
                        break;
                case SQL_C_GUID:
+                       u.g = *(SQLGUID *)ptr;
                        snprintf(data, sizeof(data),
-                                "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
-                                "%02x%02x-%02x%02x%02x%02x%02x%02x",
-                                ((unsigned char *) ptr)[0],
-                                ((unsigned char *) ptr)[1],
-                                ((unsigned char *) ptr)[2],
-                                ((unsigned char *) ptr)[3],
-                                ((unsigned char *) ptr)[4],
-                                ((unsigned char *) ptr)[5],
-                                ((unsigned char *) ptr)[6],
-                                ((unsigned char *) ptr)[7],
-                                ((unsigned char *) ptr)[8],
-                                ((unsigned char *) ptr)[9],
-                                ((unsigned char *) ptr)[10],
-                                ((unsigned char *) ptr)[11],
-                                ((unsigned char *) ptr)[12],
-                                ((unsigned char *) ptr)[13],
-                                ((unsigned char *) ptr)[14],
-                                ((unsigned char *) ptr)[15]);
+                                "%08"PRIx32"-%04"PRIx16"-%04"PRIx16
+                                "-%02"PRIx8"%02"PRIx8
+                                "-%02"PRIx8"%02"PRIx8"%02"PRIx8
+                                "%02"PRIx8"%02"PRIx8"%02"PRIx8,
+                                u.d.d1, u.d.d2, u.d.d3, u.d.d4[0],
+                                u.d.d4[1], u.d.d4[2], u.d.d4[3],
+                                u.d.d4[4], u.d.d4[5], u.d.d4[6],
+                                u.d.d4[7]);
                        break;
                }
                assign(buf, bufpos, buflen, '\'', stmt);
@@ -3646,6 +3643,7 @@ ODBCStore(ODBCStmt *stmt,
                assigns(buf, bufpos, buflen, "' DAY TO SECOND", stmt);
                break;
        case SQL_DECIMAL:
+       case SQL_NUMERIC:
        case SQL_SMALLINT:
        case SQL_INTEGER:
        case SQL_BIGINT:
@@ -3763,12 +3761,16 @@ ODBCStore(ODBCStmt *stmt,
                                snprintf(data, sizeof(data), "%s%" PRIu64, 
nval.sign ? "" : "-", (uint64_t) (nval.val / f));
                                assigns(buf, bufpos, buflen, data, stmt);
                                if (nval.scale > 0) {
-                                       if (sqltype == SQL_DECIMAL) {
+                                       switch (sqltype) {
+                                       case SQL_DECIMAL:
+                                       case SQL_NUMERIC:
                                                snprintf(data, sizeof(data), 
".%0*" PRIu64, nval.scale, (uint64_t) (nval.val % f));
                                                assigns(buf, bufpos, buflen, 
data, stmt);
-                                       } else {
+                                               break;
+                                       default:
                                                /* Fractional truncation */
                                                addStmtError(stmt, "01S07", 
NULL, 0);
+                                               break;
                                        }
                                } else {
                                        for (i = nval.scale; i < 0; i++)
@@ -3779,6 +3781,7 @@ ODBCStore(ODBCStmt *stmt,
                break;
        case SQL_REAL:
        case SQL_DOUBLE:
+       case SQL_FLOAT:
                switch (ctype) {
                case SQL_C_CHAR:
                case SQL_C_WCHAR:
@@ -3895,19 +3898,18 @@ ODBCStore(ODBCStmt *stmt,
                        snprintf(data, sizeof(data), "%.36s", sval);
                        break;
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to