LCOV - code coverage report
Current view: top level - sql/server - sql_atom.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 555 810 68.5 %
Date: 2021-10-13 02:24:04 Functions: 25 28 89.3 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "sql_atom.h"
      11             : #include "sql_string.h"
      12             : #include "sql_decimal.h"
      13             : #include "blob.h"
      14             : #include "gdk_time.h"
      15             : 
      16             : void
      17       52845 : atom_init( atom *a )
      18             : {
      19       52845 :         a->isnull = 1;
      20       52845 :         a->data.vtype = 0;
      21       52845 :         a->tpe.type = NULL;
      22       52845 : }
      23             : 
      24             : static atom *
      25     3380368 : atom_create( sql_allocator *sa )
      26             : {
      27     3380368 :         atom *a = SA_NEW(sa, atom);
      28             : 
      29     3380368 :         if (!a)
      30             :                 return NULL;
      31     3380368 :         *a = (atom) {
      32             :                 .data = (ValRecord) {.vtype = TYPE_void,},
      33             :         };
      34     3380368 :         return a;
      35             : }
      36             : 
      37             : atom *
      38      196859 : atom_bool( sql_allocator *sa, sql_subtype *tpe, bit val)
      39             : {
      40      196859 :         atom *a = atom_create(sa);
      41      196859 :         if(!a)
      42             :                 return NULL;
      43             : 
      44      196859 :         a->isnull = 0;
      45      196859 :         a->tpe = *tpe;
      46      196859 :         a->data.vtype = tpe->type->localtype;
      47      196859 :         a->data.val.btval = val;
      48      196859 :         a->data.len = 0;
      49      196859 :         return a;
      50             : }
      51             : 
      52             : atom *
      53     1561044 : atom_int( sql_allocator *sa, sql_subtype *tpe,
      54             : #ifdef HAVE_HGE
      55             :         hge val
      56             : #else
      57             :         lng val
      58             : #endif
      59             : )
      60             : {
      61     1561044 :         if (tpe->type->eclass == EC_FLT) {
      62           0 :                 return atom_float(sa, tpe, (dbl) val);
      63             :         } else {
      64     1561044 :                 atom *a = atom_create(sa);
      65     1561044 :                 if(!a)
      66             :                         return NULL;
      67             : 
      68     1561044 :                 a->isnull = 0;
      69     1561044 :                 a->tpe = *tpe;
      70     1561044 :                 a->data.vtype = tpe->type->localtype;
      71     1561044 :                 switch (ATOMstorage(a->data.vtype)) {
      72      570791 :                 case TYPE_bte:
      73      570791 :                         a->data.val.btval = (bte) val;
      74      570791 :                         break;
      75      301018 :                 case TYPE_sht:
      76      301018 :                         a->data.val.shval = (sht) val;
      77      301018 :                         break;
      78      581397 :                 case TYPE_int:
      79      581397 :                         a->data.val.ival = (int) val;
      80      581397 :                         break;
      81           0 :                 case TYPE_oid:
      82           0 :                         a->data.val.oval = (oid) val;
      83           0 :                         break;
      84      107749 :                 case TYPE_lng:
      85      107749 :                         a->data.val.lval = (lng) val;
      86      107749 :                         break;
      87             : #ifdef HAVE_HGE
      88          89 :                 case TYPE_hge:
      89          89 :                         a->data.val.hval = val;
      90          89 :                         break;
      91             : #endif
      92             :                 default:
      93           0 :                         assert(0);
      94             :                 }
      95     1561044 :                 a->data.len = 0;
      96     1561044 :                 return a;
      97             :         }
      98             : }
      99             : 
     100             : #ifdef HAVE_HGE
     101             : hge
     102             : #else
     103             : lng
     104             : #endif
     105        9488 : atom_get_int(atom *a)
     106             : {
     107             : #ifdef HAVE_HGE
     108             :         hge r = 0;
     109             : #else
     110             :         lng r = 0;
     111             : #endif
     112             : 
     113        9488 :         if (!a->isnull) {
     114        9488 :                 switch (ATOMstorage(a->data.vtype)) {
     115        9207 :                 case TYPE_bte:
     116        9207 :                         r = a->data.val.btval;
     117        9207 :                         break;
     118           0 :                 case TYPE_sht:
     119           0 :                         r = a->data.val.shval;
     120           0 :                         break;
     121         281 :                 case TYPE_int:
     122         281 :                         r = a->data.val.ival;
     123         281 :                         break;
     124           0 :                 case TYPE_oid:
     125           0 :                         r = a->data.val.oval;
     126           0 :                         break;
     127           0 :                 case TYPE_lng:
     128           0 :                         r = a->data.val.lval;
     129           0 :                         break;
     130             : #ifdef HAVE_HGE
     131           0 :                 case TYPE_hge:
     132           0 :                         r = a->data.val.hval;
     133           0 :                         break;
     134             : #endif
     135             :                 }
     136           0 :         }
     137        9488 :         return r;
     138             : }
     139             : 
     140             : atom *
     141        8191 : atom_dec(sql_allocator *sa, sql_subtype *tpe,
     142             : #ifdef HAVE_HGE
     143             :         hge val)
     144             : #else
     145             :         lng val)
     146             : #endif
     147             : {
     148        8191 :         return atom_int(sa, tpe, val);
     149             : }
     150             : 
     151             : atom *
     152     1241287 : atom_string(sql_allocator *sa, sql_subtype *tpe, const char *val)
     153             : {
     154     1241287 :         atom *a = atom_create(sa);
     155     1241287 :         if(!a)
     156             :                 return NULL;
     157             : 
     158     1241287 :         a->isnull = 1;
     159     1241287 :         a->tpe = *tpe;
     160     1241287 :         a->data.val.sval = NULL;
     161     1241287 :         a->data.vtype = TYPE_str;
     162     1241287 :         a->data.len = 0;
     163     1241287 :         if (val) {
     164     1226730 :                 a->isnull = 0;
     165     1226730 :                 a->data.val.sval = (char*)val;
     166     1226730 :                 a->data.len = strlen(a->data.val.sval);
     167             :         }
     168             :         return a;
     169             : }
     170             : 
     171             : atom *
     172        2394 : atom_float(sql_allocator *sa, sql_subtype *tpe, dbl val)
     173             : {
     174        2394 :         atom *a = atom_create(sa);
     175        2394 :         if(!a)
     176             :                 return NULL;
     177             : 
     178        2394 :         a->isnull = 0;
     179        2394 :         a->tpe = *tpe;
     180        2394 :         if (tpe->type->localtype == TYPE_dbl)
     181        2394 :                 a->data.val.dval = val;
     182             :         else {
     183           0 :                 assert((dbl) GDK_flt_min <= val && val <= (dbl) GDK_flt_max);
     184           0 :                 a->data.val.fval = (flt) val;
     185             :         }
     186        2394 :         a->data.vtype = tpe->type->localtype;
     187        2394 :         a->data.len = 0;
     188        2394 :         return a;
     189             : }
     190             : 
     191             : #ifdef HAVE_HGE
     192             : hge scales[39] = {
     193             :         (hge) LL_CONSTANT(1),
     194             :         (hge) LL_CONSTANT(10),
     195             :         (hge) LL_CONSTANT(100),
     196             :         (hge) LL_CONSTANT(1000),
     197             :         (hge) LL_CONSTANT(10000),
     198             :         (hge) LL_CONSTANT(100000),
     199             :         (hge) LL_CONSTANT(1000000),
     200             :         (hge) LL_CONSTANT(10000000),
     201             :         (hge) LL_CONSTANT(100000000),
     202             :         (hge) LL_CONSTANT(1000000000),
     203             :         (hge) LL_CONSTANT(10000000000),
     204             :         (hge) LL_CONSTANT(100000000000),
     205             :         (hge) LL_CONSTANT(1000000000000),
     206             :         (hge) LL_CONSTANT(10000000000000),
     207             :         (hge) LL_CONSTANT(100000000000000),
     208             :         (hge) LL_CONSTANT(1000000000000000),
     209             :         (hge) LL_CONSTANT(10000000000000000),
     210             :         (hge) LL_CONSTANT(100000000000000000),
     211             :         (hge) LL_CONSTANT(1000000000000000000),
     212             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1),
     213             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10),
     214             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(100),
     215             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1000),
     216             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10000),
     217             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(100000),
     218             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1000000),
     219             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10000000),
     220             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(100000000),
     221             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1000000000),
     222             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10000000000),
     223             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(100000000000),
     224             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1000000000000),
     225             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10000000000000),
     226             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(100000000000000),
     227             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1000000000000000),
     228             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10000000000000000),
     229             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(100000000000000000),
     230             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(1000000000000000000),
     231             :         (hge) LL_CONSTANT(10000000000000000000U) * LL_CONSTANT(10000000000000000000U)
     232             : };
     233             : #else
     234             : lng scales[19] = {
     235             :         LL_CONSTANT(1),
     236             :         LL_CONSTANT(10),
     237             :         LL_CONSTANT(100),
     238             :         LL_CONSTANT(1000),
     239             :         LL_CONSTANT(10000),
     240             :         LL_CONSTANT(100000),
     241             :         LL_CONSTANT(1000000),
     242             :         LL_CONSTANT(10000000),
     243             :         LL_CONSTANT(100000000),
     244             :         LL_CONSTANT(1000000000),
     245             :         LL_CONSTANT(10000000000),
     246             :         LL_CONSTANT(100000000000),
     247             :         LL_CONSTANT(1000000000000),
     248             :         LL_CONSTANT(10000000000000),
     249             :         LL_CONSTANT(100000000000000),
     250             :         LL_CONSTANT(1000000000000000),
     251             :         LL_CONSTANT(10000000000000000),
     252             :         LL_CONSTANT(100000000000000000),
     253             :         LL_CONSTANT(1000000000000000000)
     254             : };
     255             : #endif
     256             : 
     257             : atom *
     258      166551 : atom_general(sql_allocator *sa, sql_subtype *tpe, const char *val)
     259             : {
     260      166551 :         atom *a = atom_create(sa);
     261             : 
     262      166551 :         if(!a)
     263             :                 return NULL;
     264      166551 :         a->tpe = *tpe;
     265      166551 :         a->data.vtype = tpe->type->localtype;
     266      166551 :         assert(a->data.vtype >= 0);
     267             : 
     268      166551 :         if (!strNil(val)) {
     269             :                 int type = a->data.vtype;
     270             : 
     271        6198 :                 if (type == TYPE_str) {
     272          28 :                         a->data.len = strLen(val);
     273          28 :                         a->data.val.sval = sa_alloc(sa, a->data.len);
     274          28 :                         memcpy(a->data.val.sval, val, a->data.len);
     275             :                 } else {
     276        6170 :                         ptr p = NULL;
     277        6170 :                         ssize_t res = ATOMfromstr(type, &p, &a->data.len, val, false);
     278             : 
     279             :                         /* no result or nil means error (SQL has NULL not nil) */
     280        6170 :                         if (res < 0 || !p || ATOMcmp(type, p, ATOMnilptr(type)) == 0) {
     281         124 :                                 GDKfree(p);
     282         124 :                                 GDKclrerr();
     283         124 :                                 return NULL;
     284             :                         }
     285        6046 :                         VALset(&a->data, a->data.vtype, p);
     286        6046 :                         SA_VALcopy(sa, &a->data, &a->data);
     287        6046 :                         if (tpe->type->eclass == EC_TIME && tpe->digits <= 7) {
     288        2307 :                                 unsigned int diff = 6-(tpe->digits-1);
     289             : 
     290             :                                 assert(diff < MAX_SCALE);
     291             : #ifdef HAVE_HGE
     292        2307 :                                 hge d = scales[diff];
     293             : #else
     294             :                                 lng d = scales[diff];
     295             : #endif
     296             : 
     297        2307 :                                 a->data.val.lval /= d;
     298        2307 :                                 a->data.val.lval *= d;
     299             :                         }
     300        6046 :                         GDKfree(p);
     301             :                 }
     302             :         } else {
     303      160353 :                 VALset(&a->data, a->data.vtype, (ptr) ATOMnilptr(a->data.vtype));
     304      160353 :                 a->isnull = 1;
     305             :         }
     306             :         return a;
     307             : }
     308             : 
     309             : atom *
     310      204166 : atom_ptr( sql_allocator *sa, sql_subtype *tpe, void *v)
     311             : {
     312      204166 :         atom *a = atom_create(sa);
     313      204166 :         if(!a)
     314             :                 return NULL;
     315      204166 :         a->tpe = *tpe;
     316      204166 :         a->isnull = 0;
     317      204166 :         a->data.vtype = TYPE_ptr;
     318      204166 :         VALset(&a->data, a->data.vtype, &v);
     319      204166 :         a->data.len = 0;
     320      204166 :         return a;
     321             : }
     322             : 
     323             : atom *
     324         864 : atom_general_ptr( sql_allocator *sa, sql_subtype *tpe, void *v)
     325             : {
     326         864 :         atom *a = atom_create(sa);
     327         864 :         if(!a)
     328             :                 return NULL;
     329         864 :         a->tpe = *tpe;
     330         864 :         a->data.vtype = tpe->type->localtype;
     331         864 :         if (!ATOMextern(a->data.vtype)) {
     332         860 :                 VALset(&a->data, a->data.vtype, v);
     333           4 :         } else if (a->data.vtype == TYPE_str) {
     334             :                 const char *p = (const char*) v;
     335           4 :                 a->data.len = strLen(p);
     336           4 :                 a->data.val.sval = sa_alloc(sa, a->data.len);
     337           4 :                 memcpy(a->data.val.sval, p, a->data.len);
     338             :         } else {
     339           0 :                 a->data.len = ATOMlen(a->data.vtype, v);
     340           0 :                 a->data.val.pval = sa_alloc(sa, a->data.len);
     341           0 :                 memcpy(a->data.val.pval, v, a->data.len);
     342             :         } 
     343         864 :         a->isnull = VALisnil(&a->data);
     344         864 :         return a;
     345             : }
     346             : 
     347             : char *
     348           0 : atom2string(sql_allocator *sa, atom *a)
     349             : {
     350             :         char buf[BUFSIZ], *p = NULL;
     351             :         void *v;
     352             : 
     353           0 :         if (a->isnull)
     354           0 :                 return sa_strdup(sa, "NULL");
     355           0 :         switch (a->data.vtype) {
     356             : #ifdef HAVE_HGE
     357           0 :         case TYPE_hge:
     358           0 :         {       char *_buf = buf;
     359           0 :                 size_t _bufsiz = BUFSIZ;
     360           0 :                 hgeToStr(&_buf, &_bufsiz, &a->data.val.hval, true);
     361             :                 break;
     362             :         }
     363             : #endif
     364           0 :         case TYPE_lng:
     365           0 :                 sprintf(buf, LLFMT, a->data.val.lval);
     366           0 :                 break;
     367           0 :         case TYPE_oid:
     368           0 :                 sprintf(buf, OIDFMT "@0", a->data.val.oval);
     369           0 :                 break;
     370           0 :         case TYPE_int:
     371           0 :                 sprintf(buf, "%d", a->data.val.ival);
     372           0 :                 break;
     373           0 :         case TYPE_sht:
     374           0 :                 sprintf(buf, "%d", a->data.val.shval);
     375           0 :                 break;
     376           0 :         case TYPE_bte:
     377           0 :                 sprintf(buf, "%d", a->data.val.btval);
     378           0 :                 break;
     379           0 :         case TYPE_bit:
     380           0 :                 if (a->data.val.btval)
     381           0 :                         return sa_strdup(sa, "true");
     382           0 :                 return sa_strdup(sa, "false");
     383           0 :         case TYPE_flt:
     384           0 :                 sprintf(buf, "%f", a->data.val.fval);
     385           0 :                 break;
     386           0 :         case TYPE_dbl:
     387           0 :                 sprintf(buf, "%f", a->data.val.dval);
     388           0 :                 break;
     389           0 :         case TYPE_str:
     390           0 :                 assert(a->data.val.sval);
     391           0 :                 return sa_strdup(sa, a->data.val.sval);
     392           0 :         default:
     393           0 :                 v = &a->data.val.ival;
     394           0 :                 if (ATOMvarsized(a->data.vtype))
     395           0 :                         v = a->data.val.pval;
     396           0 :                 if ((p = ATOMformat(a->data.vtype, v)) == NULL) {
     397           0 :                         snprintf(buf, BUFSIZ, "atom2string(TYPE_%d) not implemented", a->data.vtype);
     398             :                 } else {
     399           0 :                          char *r = sa_strdup(sa, p);
     400           0 :                          GDKfree(p);
     401           0 :                          return r;
     402             :                 }
     403             :         }
     404           0 :         return sa_strdup(sa, buf);
     405             : }
     406             : 
     407             : char *
     408         840 : atom2sql(sql_allocator *sa, atom *a, int timezone)
     409             : {
     410         840 :         sql_class ec = a->tpe.type->eclass;
     411             :         char buf[BUFSIZ];
     412             : 
     413         840 :         if (a->data.vtype == TYPE_str && EC_INTERVAL(ec))
     414             :                 ec = EC_STRING;
     415         840 :         if (a->isnull)
     416             :                 return "NULL";
     417         840 :         switch (ec) {
     418         395 :         case EC_BIT:
     419         395 :                 assert( a->data.vtype == TYPE_bit);
     420         395 :                 if (a->data.val.btval)
     421         189 :                         return "true";
     422             :                 return "false";
     423         154 :         case EC_CHAR:
     424             :         case EC_STRING: {
     425             :                 char *val, *res;
     426         154 :                 assert(a->data.vtype == TYPE_str && a->data.val.sval);
     427             : 
     428         154 :                 if (!(val = sql_escape_str(sa, a->data.val.sval)))
     429             :                         return NULL;
     430         154 :                 if ((res = SA_NEW_ARRAY(sa, char, strlen(val) + 3)))
     431         154 :                         stpcpy(stpcpy(stpcpy(res, "'"), val), "'");
     432             :                 return res;
     433             :         } break;
     434           2 :         case EC_BLOB: {
     435             :                 char *res;
     436           2 :                 blob *b = (blob*)a->data.val.pval;
     437           2 :                 size_t blobstr_size = b->nitems * 2 + 1;
     438             : 
     439           2 :                 if ((res = SA_NEW_ARRAY(sa, char, blobstr_size + 8))) {
     440           2 :                         char *tail = stpcpy(res, "blob '");
     441           2 :                         ssize_t blobstr_offset = BLOBtostr(&tail, &blobstr_size, b, true);
     442           2 :                         strcpy(res + blobstr_offset + 6, "'");
     443             :                 }
     444             :                 return res;
     445             :         } break;
     446           4 :         case EC_MONTH:
     447             :         case EC_SEC: {
     448             :                 lng v;
     449             :                 switch (a->data.vtype) {
     450           3 :                 case TYPE_lng:
     451           3 :                         v = a->data.val.lval;
     452           3 :                         break;
     453           1 :                 case TYPE_int:
     454           1 :                         v = a->data.val.ival;
     455           1 :                         break;
     456           0 :                 case TYPE_sht:
     457           0 :                         v = a->data.val.shval;
     458           0 :                         break;
     459           0 :                 case TYPE_bte:
     460           0 :                         v = a->data.val.btval;
     461           0 :                         break;
     462             :                 default:
     463             :                         v = 0;
     464             :                         break;
     465             :                 }
     466           4 :                 switch (a->tpe.digits) {
     467           0 :                 case 1:         /* year */
     468           0 :                         v /= 12;
     469           0 :                         break;
     470             :                 case 2:         /* year to month */
     471             :                 case 3:         /* month */
     472             :                         break;
     473           0 :                 case 4:         /* day */
     474           0 :                         v /= 60 * 60 * 24;
     475           0 :                         break;
     476           0 :                 case 5:         /* day to hour */
     477             :                 case 8:         /* hour */
     478           0 :                         v /= 60 * 60;
     479           0 :                         break;
     480           0 :                 case 6:         /* day to minute */
     481             :                 case 9:         /* hour to minute */
     482             :                 case 11:        /* minute */
     483           0 :                         v /= 60;
     484           0 :                         break;
     485             :                 case 7:         /* day to second */
     486             :                 case 10:        /* hour to second */
     487             :                 case 12:        /* minute to second */
     488             :                 case 13:        /* second */
     489             :                         break;
     490             :                 }
     491           7 :                 sprintf(buf, "interval '" LLFMT "' %s", ec == EC_MONTH ? v : v/1000, ec == EC_MONTH ? "month" : "second");
     492           4 :                 break;
     493             :         }
     494         253 :         case EC_NUM:
     495             :                 switch (a->data.vtype) {
     496             : #ifdef HAVE_HGE
     497           0 :                 case TYPE_hge:
     498           0 :                 {       char *_buf = buf;
     499           0 :                         size_t _bufsiz = BUFSIZ;
     500           0 :                         hgeToStr(&_buf, &_bufsiz, &a->data.val.hval, true);
     501             :                         break;
     502             :                 }
     503             : #endif
     504           0 :                 case TYPE_lng:
     505           0 :                         sprintf(buf, LLFMT, a->data.val.lval);
     506           0 :                         break;
     507           6 :                 case TYPE_int:
     508           6 :                         sprintf(buf, "%d", a->data.val.ival);
     509           6 :                         break;
     510          74 :                 case TYPE_sht:
     511          74 :                         sprintf(buf, "%d", a->data.val.shval);
     512          74 :                         break;
     513         173 :                 case TYPE_bte:
     514         173 :                         sprintf(buf, "%d", a->data.val.btval);
     515         173 :                         break;
     516             :                 default:
     517             :                         break;
     518             :                 }
     519             :                 break;
     520          23 :         case EC_DEC: {
     521             : #ifdef HAVE_HGE
     522             :                 hge v = 0;
     523             : #else
     524             :                 lng v = 0;
     525             : #endif
     526             :                 switch (a->data.vtype) {
     527             : #ifdef HAVE_HGE
     528           0 :                 case TYPE_hge: v = a->data.val.hval; break;
     529             : #endif
     530           0 :                 case TYPE_lng: v = a->data.val.lval; break;
     531          16 :                 case TYPE_int: v = a->data.val.ival; break;
     532           2 :                 case TYPE_sht: v = a->data.val.shval; break;
     533           5 :                 case TYPE_bte: v = a->data.val.btval; break;
     534             :                 default: break;
     535             :                 }
     536          23 :                 return decimal_to_str(sa, v, &a->tpe);
     537             :         }
     538           0 :         case EC_FLT:
     539           0 :                 if (a->data.vtype == TYPE_dbl)
     540           0 :                         sprintf(buf, "%f", a->data.val.dval);
     541             :                 else
     542           0 :                         sprintf(buf, "%f", a->data.val.fval);
     543             :                 break;
     544           9 :         case EC_TIME:
     545             :         case EC_TIME_TZ:
     546             :         case EC_DATE:
     547             :         case EC_TIMESTAMP:
     548             :         case EC_TIMESTAMP_TZ: {
     549           9 :                 char val1[64], sbuf[64], *val2 = sbuf, *res;
     550           9 :                 size_t len = sizeof(sbuf);
     551             : 
     552             :                 switch (ec) {
     553           3 :                 case EC_TIME:
     554             :                 case EC_TIME_TZ:
     555             :                 case EC_TIMESTAMP:
     556             :                 case EC_TIMESTAMP_TZ: {
     557           3 :                         char *n = stpcpy(val1, (ec == EC_TIME || ec == EC_TIME_TZ) ? "TIME" : "TIMESTAMP");
     558           3 :                         if (a->tpe.digits) {
     559             :                                 char str[16];
     560           3 :                                 sprintf(str, "%u", a->tpe.digits);
     561           3 :                                 n = stpcpy(stpcpy(stpcpy(n, " ("), str), ")");
     562             :                         }
     563           3 :                         if (ec == EC_TIME_TZ || ec == EC_TIMESTAMP_TZ)
     564           0 :                                 stpcpy(n, " WITH TIME ZONE");
     565             :                 } break;
     566           6 :                 case EC_DATE:
     567           6 :                         strcpy(val1, "DATE");
     568           6 :                 break;
     569             :                 default:
     570           0 :                         assert(0);
     571             :                 }
     572             : 
     573             :                 switch (ec) {
     574           2 :                 case EC_TIME:
     575             :                 case EC_TIME_TZ: {
     576           2 :                         daytime dt = a->data.val.lval;
     577           2 :                         unsigned int digits = a->tpe.digits ? a->tpe.digits - 1 : 0;
     578           2 :                         char *s = val2;
     579             :                         ssize_t lens;
     580             : 
     581           2 :                         if (ec == EC_TIME_TZ)
     582           0 :                                 dt = daytime_add_usec_modulo(dt, timezone * 1000);
     583           2 :                         if ((lens = daytime_precision_tostr(&s, &len, dt, (int) digits, true)) < 0)
     584           0 :                                 assert(0);
     585             : 
     586           2 :                         if (ec == EC_TIME_TZ) {
     587           0 :                                 lng timezone_hours = llabs(timezone / 60000);
     588             :                                 char *end = sbuf + sizeof(sbuf) - 1;
     589             : 
     590           0 :                                 s += lens;
     591           0 :                                 snprintf(s, end - s, "%c%02d:%02d", (timezone >= 0) ? '+' : '-', (int) (timezone_hours / 60), (int) (timezone_hours % 60));
     592             :                         }
     593           2 :                 } break;
     594           6 :                 case EC_DATE: {
     595           6 :                         date dt = a->data.val.ival;
     596           6 :                         if (date_tostr(&val2, &len, &dt, false) < 0)
     597           0 :                                 assert(0);
     598           6 :                 } break;
     599           1 :                 case EC_TIMESTAMP:
     600             :                 case EC_TIMESTAMP_TZ: {
     601           1 :                         timestamp ts = a->data.val.lval;
     602           1 :                         unsigned int digits = a->tpe.digits ? a->tpe.digits - 1 : 0;
     603           1 :                         char *s = val2;
     604             :                         size_t nlen;
     605             :                         ssize_t lens;
     606             :                         date days;
     607             :                         daytime usecs;
     608             : 
     609           1 :                         if (ec == EC_TIMESTAMP_TZ)
     610           0 :                                 ts = timestamp_add_usec(ts, timezone * 1000);
     611           1 :                         days = timestamp_date(ts);
     612           1 :                         if ((lens = date_tostr(&s, &len, &days, true)) < 0)
     613           0 :                                 assert(0);
     614             : 
     615           1 :                         s += lens;
     616           1 :                         *s++ = ' ';
     617           1 :                         nlen = len - lens - 1;
     618           1 :                         assert(nlen < len);
     619             : 
     620           1 :                         usecs = timestamp_daytime(ts);
     621           1 :                         if ((lens = daytime_precision_tostr(&s, &nlen, usecs, (int) digits, true)) < 0)
     622           0 :                                 assert(0);
     623             : 
     624           1 :                         if (ec == EC_TIMESTAMP_TZ) {
     625           0 :                                 lng timezone_hours = llabs(timezone / 60000);
     626             :                                 char *end = sbuf + sizeof(sbuf) - 1;
     627             : 
     628           0 :                                 s += lens;
     629           0 :                                 snprintf(s, end - s, "%c%02d:%02d", (timezone >= 0) ? '+' : '-', (int) (timezone_hours / 60), (int) (timezone_hours % 60));
     630             :                         }
     631           1 :                 } break;
     632             :                 default:
     633           0 :                         assert(0);
     634             :                 }
     635             : 
     636           9 :                 if ((res = SA_NEW_ARRAY(sa, char, strlen(val1) + strlen(val2) + 4)))
     637           9 :                         stpcpy(stpcpy(stpcpy(stpcpy(res, val1)," '"), val2), "'");
     638             :                 return res;
     639             :         } break;
     640           0 :         default:
     641           0 :                 snprintf(buf, BUFSIZ, "atom2sql(TYPE_%d) not implemented", a->data.vtype);
     642             :         }
     643         257 :         return sa_strdup(sa, buf);
     644             : }
     645             : 
     646             : sql_subtype *
     647    23033987 : atom_type(atom *a)
     648             : {
     649    23033987 :         return &a->tpe;
     650             : }
     651             : 
     652             : void
     653        9181 : atom_set_type(atom *a, sql_subtype *t)
     654             : {
     655        9181 :         a->tpe = *t;
     656        9181 : }
     657             : 
     658             : unsigned int
     659          53 : atom_num_digits( atom *a )
     660             : {
     661             : #ifdef HAVE_HGE
     662             :         hge v = 0;
     663             : #else
     664             :         lng v = 0;
     665             : #endif
     666             :         unsigned int inlen = 1;
     667             : 
     668          53 :         switch (a->tpe.type->localtype) {
     669          23 :         case TYPE_bte:
     670          23 :                 v = a->data.val.btval;
     671          23 :                 break;
     672           2 :         case TYPE_sht:
     673           2 :                 v = a->data.val.shval;
     674           2 :                 break;
     675           8 :         case TYPE_int:
     676           8 :                 v = a->data.val.ival;
     677           8 :                 break;
     678          10 :         case TYPE_lng:
     679          10 :                 v = a->data.val.lval;
     680          10 :                 break;
     681             : #ifdef HAVE_HGE
     682          10 :         case TYPE_hge:
     683          10 :                 v = a->data.val.hval;
     684          10 :                 break;
     685             : #endif
     686             :         default:
     687             :                 return 64;
     688             :         }
     689             :         /* count the number of digits in the input */
     690         513 :         while (v /= 10)
     691         460 :                 inlen++;
     692             :         return inlen;
     693             : }
     694             : 
     695             : /* cast atom a to type tp (success == 1, fail == 0) */
     696             : int
     697     1930323 : atom_cast(sql_allocator *sa, atom *a, sql_subtype *tp)
     698             : {
     699     1930323 :         sql_subtype *at = &a->tpe;
     700             : 
     701     1930323 :         if (!a->isnull) {
     702     1912823 :                 if (subtype_cmp(at, tp) == 0)
     703             :                         return 1;
     704             :                 /* need to do a cast, start simple is atom type a subtype of tp */
     705     1141675 :                 if ((at->type->eclass == tp->type->eclass ||
     706      294410 :                     (EC_VARCHAR(at->type->eclass) && EC_VARCHAR(tp->type->eclass))) &&
     707     1129709 :                     at->type->localtype == tp->type->localtype &&
     708      434985 :                    (EC_TEMP(tp->type->eclass) || !tp->digits|| at->digits <= tp->digits) &&
     709      434971 :                    (!tp->type->scale || at->scale == tp->scale)) {
     710      434949 :                         *at = *tp;
     711      434949 :                         return 1;
     712             :                 }
     713      706726 :                 if (at->type->eclass == EC_NUM && tp->type->eclass == EC_NUM) {
     714      694708 :                         if (at->type->localtype <= tp->type->localtype) { /* cast to a larger numeric */
     715      694624 :                                 switch (tp->type->localtype) {
     716           0 :                                 case TYPE_bte:
     717           0 :                                         if (at->type->localtype != TYPE_bte)
     718             :                                                 return 0;
     719             :                                         break;
     720       81005 :                                 case TYPE_sht:
     721       81005 :                                         if (at->type->localtype == TYPE_bte)
     722       81005 :                                                 a->data.val.shval = a->data.val.btval;
     723           0 :                                         else if (at->type->localtype != TYPE_sht)
     724             :                                                 return 0;
     725             :                                         break;
     726      580828 :                                 case TYPE_int:
     727             : #if SIZEOF_OID == SIZEOF_INT
     728             :                                 case TYPE_oid:
     729             : #endif
     730      580828 :                                         if (at->type->localtype == TYPE_bte)
     731      316540 :                                                 a->data.val.ival = a->data.val.btval;
     732      264288 :                                         else if (at->type->localtype == TYPE_sht)
     733      264288 :                                                 a->data.val.ival = a->data.val.shval;
     734           0 :                                         else if (at->type->localtype != TYPE_int)
     735             :                                                 return 0;
     736             :                                         break;
     737       28044 :                                 case TYPE_lng:
     738             : #if SIZEOF_OID == SIZEOF_LNG
     739             :                                 case TYPE_oid:
     740             : #endif
     741       28044 :                                         if (at->type->localtype == TYPE_bte)
     742       25246 :                                                 a->data.val.lval = a->data.val.btval;
     743        2798 :                                         else if (at->type->localtype == TYPE_sht)
     744        2524 :                                                 a->data.val.lval = a->data.val.shval;
     745         274 :                                         else if (at->type->localtype == TYPE_int)
     746         274 :                                                 a->data.val.lval = a->data.val.ival;
     747           0 :                                         else if (at->type->localtype != TYPE_lng)
     748             :                                                 return 0;
     749             :                                         break;
     750             : #ifdef HAVE_HGE
     751        4747 :                                 case TYPE_hge:
     752        4747 :                                         if (at->type->localtype == TYPE_bte)
     753        3896 :                                                 a->data.val.hval = a->data.val.btval;
     754         851 :                                         else if (at->type->localtype == TYPE_sht)
     755         809 :                                                 a->data.val.hval = a->data.val.shval;
     756          42 :                                         else if (at->type->localtype == TYPE_int)
     757          20 :                                                 a->data.val.hval = a->data.val.ival;
     758          22 :                                         else if (at->type->localtype == TYPE_lng)
     759          22 :                                                 a->data.val.hval = a->data.val.lval;
     760           0 :                                         else if (at->type->localtype != TYPE_hge)
     761             :                                                 return 0;
     762             :                                         break;
     763             : #endif
     764             :                                 default:
     765             :                                         return 0;
     766             :                                 }
     767             :                         } else { /* cast to a smaller numeric */
     768          84 :                                 switch (tp->type->localtype) {
     769             : #ifdef HAVE_HGE
     770           6 :                                 case TYPE_bte:
     771           6 :                                         if (a->data.val.hval > (hge) GDK_bte_max || a->data.val.hval <= (hge) GDK_bte_min)
     772             :                                                 return 0;
     773           3 :                                         a->data.val.btval = (bte) a->data.val.hval;
     774           3 :                                         break;
     775           4 :                                 case TYPE_sht:
     776           4 :                                         if (a->data.val.hval > (hge) GDK_sht_max || a->data.val.hval <= (hge) GDK_sht_min)
     777             :                                                 return 0;
     778           0 :                                         a->data.val.shval = (sht) a->data.val.hval;
     779           0 :                                         break;
     780          74 :                                 case TYPE_int:
     781             : #if SIZEOF_OID == SIZEOF_INT
     782             :                                 case TYPE_oid:
     783             : #endif
     784          74 :                                         if (a->data.val.hval > (hge) GDK_int_max || a->data.val.hval <= (hge) GDK_int_min)
     785             :                                                 return 0;
     786          71 :                                         a->data.val.ival = (int) a->data.val.hval;
     787          71 :                                         break;
     788           0 :                                 case TYPE_lng:
     789             : #if SIZEOF_OID == SIZEOF_LNG
     790             :                                 case TYPE_oid:
     791             : #endif
     792           0 :                                         if (a->data.val.hval > (hge) GDK_lng_max || a->data.val.hval <= (hge) GDK_lng_min)
     793             :                                                 return 0;
     794           0 :                                         a->data.val.lval = (lng) a->data.val.hval;
     795           0 :                                         break;
     796             : #else
     797             :                                 case TYPE_bte:
     798             :                                         if (a->data.val.lval > (lng) GDK_bte_max || a->data.val.lval <= (lng) GDK_bte_min)
     799             :                                                 return 0;
     800             :                                         a->data.val.btval = (bte) a->data.val.lval;
     801             :                                         break;
     802             :                                 case TYPE_sht:
     803             :                                         if (a->data.val.lval > (lng) GDK_sht_max || a->data.val.lval <= (lng) GDK_sht_min)
     804             :                                                 return 0;
     805             :                                         a->data.val.shval = (sht) a->data.val.lval;
     806             :                                         break;
     807             :                                 case TYPE_int:
     808             : #if SIZEOF_OID == SIZEOF_INT
     809             :                                 case TYPE_oid:
     810             : #endif
     811             :                                         if (a->data.val.lval > (lng) GDK_int_max || a->data.val.lval <= (lng) GDK_int_min)
     812             :                                                 return 0;
     813             :                                         a->data.val.ival = (int) a->data.val.lval;
     814             :                                         break;
     815             : #endif
     816             :                                 default:
     817             :                                         return 0;
     818             :                                 }
     819             :                         }
     820      694698 :                         a->tpe = *tp;
     821      694698 :                         a->data.vtype = tp->type->localtype;
     822      694698 :                         return 1;
     823             :                 }
     824       12018 :                 if (at->type->eclass == EC_DEC && tp->type->eclass == EC_DEC &&
     825          10 :                     at->type->localtype <= tp->type->localtype &&
     826          10 :                     at->digits <= tp->digits /* &&
     827             :                     at->scale <= tp->scale*/) {
     828             : #ifdef HAVE_HGE
     829             :                         hge mul = 1, div = 0, rnd = 0;
     830             : #else
     831             :                         lng mul = 1, div = 0, rnd = 0;
     832             : #endif
     833             :                         /* cast numerics */
     834           9 :                         switch (tp->type->localtype) {
     835           2 :                         case TYPE_bte:
     836           2 :                                 if (at->type->localtype != TYPE_bte)
     837             :                                         return 0;
     838             :                                 break;
     839           2 :                         case TYPE_sht:
     840           2 :                                 if (at->type->localtype == TYPE_bte)
     841           0 :                                         a->data.val.shval = a->data.val.btval;
     842           2 :                                 else if (at->type->localtype != TYPE_sht)
     843             :                                         return 0;
     844             :                                 break;
     845           0 :                         case TYPE_int:
     846             : #if SIZEOF_OID == SIZEOF_INT
     847             :                         case TYPE_oid:
     848             : #endif
     849           0 :                                 if (at->type->localtype == TYPE_bte)
     850           0 :                                         a->data.val.ival = a->data.val.btval;
     851           0 :                                 else if (at->type->localtype == TYPE_sht)
     852           0 :                                         a->data.val.ival = a->data.val.shval;
     853           0 :                                 else if (at->type->localtype != TYPE_int)
     854             :                                         return 0;
     855             :                                 break;
     856           5 :                         case TYPE_lng:
     857             : #if SIZEOF_OID == SIZEOF_LNG
     858             :                         case TYPE_oid:
     859             : #endif
     860           5 :                                 if (at->type->localtype == TYPE_bte)
     861           2 :                                         a->data.val.lval = a->data.val.btval;
     862           3 :                                 else if (at->type->localtype == TYPE_sht)
     863           2 :                                         a->data.val.lval = a->data.val.shval;
     864           1 :                                 else if (at->type->localtype == TYPE_int)
     865           1 :                                         a->data.val.lval = a->data.val.ival;
     866           0 :                                 else if (at->type->localtype != TYPE_lng)
     867             :                                         return 0;
     868             :                                 break;
     869             : #ifdef HAVE_HGE
     870           0 :                         case TYPE_hge:
     871           0 :                                 if (at->type->localtype == TYPE_bte)
     872           0 :                                         a->data.val.hval = a->data.val.btval;
     873           0 :                                 else if (at->type->localtype == TYPE_sht)
     874           0 :                                         a->data.val.hval = a->data.val.shval;
     875           0 :                                 else if (at->type->localtype == TYPE_int)
     876           0 :                                         a->data.val.hval = a->data.val.ival;
     877           0 :                                 else if (at->type->localtype == TYPE_lng)
     878           0 :                                         a->data.val.hval = a->data.val.lval;
     879           0 :                                 else if (at->type->localtype != TYPE_hge)
     880             :                                         return 0;
     881             :                                 break;
     882             : #endif
     883             :                         default:
     884             :                                 return 0;
     885             :                         }
     886             :                         /* fix scale */
     887           9 :                         if (tp->scale >= at->scale) {
     888           0 :                                 mul = scales[tp->scale-at->scale];
     889             :                         } else {
     890             :                                 /* only round when going to a lower scale */
     891           9 :                                 mul = scales[at->scale-tp->scale];
     892             : #ifndef TRUNCATE_NUMBERS
     893           9 :                                 rnd = mul>>1;
     894             : #endif
     895             :                                 div = 1;
     896             :                         }
     897           9 :                         a->tpe = *tp;
     898           9 :                         a->data.vtype = tp->type->localtype;
     899             : #ifdef HAVE_HGE
     900           9 :                         if (a->data.vtype == TYPE_hge) {
     901           0 :                                 if (div) {
     902           0 :                                         if (a->data.val.hval < 0)
     903           0 :                                                 a->data.val.hval -= rnd;
     904             :                                         else
     905           0 :                                                 a->data.val.hval += rnd;
     906           0 :                                         a->data.val.hval /= mul;
     907             :                                 } else
     908           0 :                                         a->data.val.hval *= mul;
     909           9 :                         } else if (a->data.vtype == TYPE_lng) {
     910           5 :                                 if (!div && ((hge) GDK_lng_min > (hge) a->data.val.lval * mul || (hge) a->data.val.lval * mul > (hge) GDK_lng_max))
     911             :                                         return 0;
     912           5 :                                 if (div) {
     913           5 :                                         if (a->data.val.lval < 0)
     914           0 :                                                 a->data.val.lval -= (lng)rnd;
     915             :                                         else
     916           5 :                                                 a->data.val.lval += (lng)rnd;
     917           5 :                                         a->data.val.lval /= (lng) mul;
     918             :                                 } else
     919           0 :                                         a->data.val.lval *= (lng) mul;
     920           4 :                         } else if (a->data.vtype == TYPE_int) {
     921           0 :                                 if (!div && ((hge) GDK_int_min > (hge) a->data.val.ival * mul || (hge) a->data.val.ival * mul > (hge) GDK_int_max))
     922             :                                         return 0;
     923           0 :                                 if (div) {
     924           0 :                                         if (a->data.val.ival < 0)
     925           0 :                                                 a->data.val.ival -= (int)rnd;
     926             :                                         else
     927           0 :                                                 a->data.val.ival += (int)rnd;
     928           0 :                                         a->data.val.ival /= (int) mul;
     929             :                                 } else
     930           0 :                                         a->data.val.ival *= (int) mul;
     931           4 :                         } else if (a->data.vtype == TYPE_sht) {
     932           2 :                                 if (!div && ((hge) GDK_sht_min > (hge) a->data.val.shval * mul || (hge) a->data.val.shval * mul > (hge) GDK_sht_max))
     933             :                                         return 0;
     934           2 :                                 if (div) {
     935           2 :                                         if (a->data.val.shval < 0)
     936           0 :                                                 a->data.val.shval -= (sht)rnd;
     937             :                                         else
     938           2 :                                                 a->data.val.shval += (sht)rnd;
     939           2 :                                         a->data.val.shval /= (sht) mul;
     940             :                                 } else
     941           0 :                                         a->data.val.shval *= (sht) mul;
     942           2 :                         } else if (a->data.vtype == TYPE_bte) {
     943           2 :                                 if (!div && ((hge) GDK_bte_min > (hge) a->data.val.btval * mul || (hge) a->data.val.btval * mul > (hge) GDK_bte_max))
     944             :                                         return 0;
     945           2 :                                 if (div) {
     946           2 :                                         if (a->data.val.btval < 0)
     947           0 :                                                 a->data.val.btval -= (bte)rnd;
     948             :                                         else
     949           2 :                                                 a->data.val.btval += (bte)rnd;
     950           2 :                                         a->data.val.btval /= (bte) mul;
     951             :                                 } else
     952           0 :                                         a->data.val.btval *= (bte) mul;
     953             :                         }
     954             : #else
     955             :                         if (a->data.vtype == TYPE_lng) {
     956             :                                 if (div) {
     957             :                                         if (a->data.val.lval < 0)
     958             :                                                 a->data.val.lval -= rnd;
     959             :                                         else
     960             :                                                 a->data.val.lval += rnd;
     961             :                                         a->data.val.lval /= mul;
     962             :                                 } else
     963             :                                         a->data.val.lval *= mul;
     964             :                         } else if (a->data.vtype == TYPE_int) {
     965             :                                 if (!div && ((lng) GDK_int_min > (lng) a->data.val.ival * mul || (lng) a->data.val.ival * mul > (lng) GDK_int_max))
     966             :                                         return 0;
     967             :                                 if (div) {
     968             :                                         if (a->data.val.ival < 0)
     969             :                                                 a->data.val.ival -= (int)rnd;
     970             :                                         else
     971             :                                                 a->data.val.ival += (int)rnd;
     972             :                                         a->data.val.ival /= (int) mul;
     973             :                                 } else
     974             :                                         a->data.val.ival *= (int) mul;
     975             :                         } else if (a->data.vtype == TYPE_sht) {
     976             :                                 if (!div && ((lng) GDK_sht_min > (lng) a->data.val.shval * mul || (lng) a->data.val.shval * mul > (lng) GDK_sht_max))
     977             :                                         return 0;
     978             :                                 if (div) {
     979             :                                         if (a->data.val.shval < 0)
     980             :                                                 a->data.val.shval -= (sht)rnd;
     981             :                                         else
     982             :                                                 a->data.val.shval += (sht)rnd;
     983             :                                         a->data.val.shval /= (sht) mul;
     984             :                                 } else
     985             :                                         a->data.val.shval *= (sht) mul;
     986             :                         } else if (a->data.vtype == TYPE_bte) {
     987             :                                 if (!div && ((lng) GDK_bte_min > (lng) a->data.val.btval * mul || (lng) a->data.val.btval * mul > (lng) GDK_bte_max))
     988             :                                         return 0;
     989             :                                 if (div) {
     990             :                                         if (a->data.val.btval < 0)
     991             :                                                 a->data.val.btval -= (bte)rnd;
     992             :                                         else
     993             :                                                 a->data.val.btval += (bte)rnd;
     994             :                                         a->data.val.btval /= (bte) mul;
     995             :                                 } else
     996             :                                         a->data.val.btval *= (bte) mul;
     997             :                         }
     998             : #endif
     999           9 :                         return 1;
    1000             :                 }
    1001             :                 /* truncating decimals */
    1002       12009 :                 if (at->type->eclass == EC_DEC && tp->type->eclass == EC_DEC &&
    1003           1 :                     at->type->localtype >= tp->type->localtype &&
    1004           1 :                     at->digits >= tp->digits &&
    1005           1 :                         (at->digits - tp->digits) == (at->scale - tp->scale)) {
    1006             : #ifdef HAVE_HGE
    1007             :                         hge mul = 1, rnd = 0, val = 0;
    1008             : #else
    1009             :                         lng mul = 1, rnd = 0, val = 0;
    1010             : #endif
    1011             : 
    1012             :                         /* fix scale */
    1013             : 
    1014             :                         /* only round when going to a lower scale */
    1015           1 :                         mul = scales[at->scale-tp->scale];
    1016             : #ifndef TRUNCATE_NUMBERS
    1017           1 :                         rnd = mul>>1;
    1018             : #endif
    1019             : 
    1020             : #ifdef HAVE_HGE
    1021           1 :                         if (a->data.vtype == TYPE_hge) {
    1022           0 :                                 val = a->data.val.hval;
    1023             :                         } else
    1024             : #endif
    1025           1 :                         if (a->data.vtype == TYPE_lng) {
    1026           1 :                                 val = a->data.val.lval;
    1027           0 :                         } else if (a->data.vtype == TYPE_int) {
    1028           0 :                                 val = a->data.val.ival;
    1029           0 :                         } else if (a->data.vtype == TYPE_sht) {
    1030           0 :                                 val = a->data.val.shval;
    1031           0 :                         } else if (a->data.vtype == TYPE_bte) {
    1032           0 :                                 val = a->data.val.btval;
    1033             :                         }
    1034             : 
    1035           1 :                         if (val < 0)
    1036           0 :                                 val -= rnd;
    1037             :                         else
    1038           1 :                                 val += rnd;
    1039           1 :                         val /= mul;
    1040             : 
    1041           1 :                         a->tpe = *tp;
    1042           1 :                         a->data.vtype = tp->type->localtype;
    1043             : #ifdef HAVE_HGE
    1044           1 :                         if (a->data.vtype == TYPE_hge) {
    1045           0 :                                 a->data.val.hval = val;
    1046           1 :                         } else if (a->data.vtype == TYPE_lng) {
    1047           1 :                                 if ( ((hge) GDK_lng_min > val || val > (hge) GDK_lng_max))
    1048             :                                         return 0;
    1049           1 :                                 a->data.val.lval = (lng) val;
    1050           0 :                         } else if (a->data.vtype == TYPE_int) {
    1051           0 :                                 if ( ((hge) GDK_int_min > val || val > (hge) GDK_int_max))
    1052             :                                         return 0;
    1053           0 :                                 a->data.val.ival = (int) val;
    1054           0 :                         } else if (a->data.vtype == TYPE_sht) {
    1055           0 :                                 if ( ((hge) GDK_sht_min > val || val > (hge) GDK_sht_max))
    1056             :                                         return 0;
    1057           0 :                                 a->data.val.shval = (sht) val;
    1058           0 :                         } else if (a->data.vtype == TYPE_bte) {
    1059           0 :                                 if ( ((hge) GDK_bte_min > val || val > (hge) GDK_bte_max))
    1060             :                                         return 0;
    1061           0 :                                 a->data.val.btval = (bte) val;
    1062             :                         }
    1063             : #else
    1064             :                         if (a->data.vtype == TYPE_lng) {
    1065             :                                 a->data.val.lval = (lng) val;
    1066             :                         } else if (a->data.vtype == TYPE_int) {
    1067             :                                 if ( ((lng) GDK_int_min > val || val > (lng) GDK_int_max))
    1068             :                                         return 0;
    1069             :                                 a->data.val.ival = (int) val;
    1070             :                         } else if (a->data.vtype == TYPE_sht) {
    1071             :                                 if ( ((lng) GDK_sht_min > val || val > (lng) GDK_sht_max))
    1072             :                                         return 0;
    1073             :                                 a->data.val.shval = (sht) val;
    1074             :                         } else if (a->data.vtype == TYPE_bte) {
    1075             :                                 if ( ((lng) GDK_bte_min > val || val > (lng) GDK_bte_max))
    1076             :                                         return 0;
    1077             :                                 a->data.val.btval = (bte) val;
    1078             :                         }
    1079             : #endif
    1080           1 :                         return 1;
    1081             :                 }
    1082       12008 :                 if (at->type->eclass == EC_NUM && tp->type->eclass == EC_DEC &&
    1083         183 :                     at->type->localtype <= tp->type->localtype &&
    1084         183 :                     (at->digits <= tp->digits || atom_num_digits(a) <= tp->digits) &&
    1085         183 :                     at->scale <= tp->scale) {
    1086             : #ifdef HAVE_HGE
    1087             :                         hge mul = 1;
    1088             : #else
    1089             :                         lng mul = 1;
    1090             : #endif
    1091             :                         /* cast numerics */
    1092         183 :                         switch (tp->type->localtype) {
    1093           8 :                         case TYPE_bte:
    1094           8 :                                 if (at->type->localtype != TYPE_bte)
    1095             :                                         return 0;
    1096             :                                 break;
    1097          16 :                         case TYPE_sht:
    1098          16 :                                 if (at->type->localtype == TYPE_bte)
    1099          16 :                                         a->data.val.shval = a->data.val.btval;
    1100           0 :                                 else if (at->type->localtype != TYPE_sht)
    1101             :                                         return 0;
    1102             :                                 break;
    1103          20 :                         case TYPE_int:
    1104             : #if SIZEOF_OID == SIZEOF_INT
    1105             :                         case TYPE_oid:
    1106             : #endif
    1107          20 :                                 if (at->type->localtype == TYPE_bte)
    1108          12 :                                         a->data.val.ival = a->data.val.btval;
    1109           8 :                                 else if (at->type->localtype == TYPE_sht)
    1110           0 :                                         a->data.val.ival = a->data.val.shval;
    1111           8 :                                 else if (at->type->localtype != TYPE_int)
    1112             :                                         return 0;
    1113             :                                 break;
    1114         110 :                         case TYPE_lng:
    1115             : #if SIZEOF_OID == SIZEOF_LNG
    1116             :                         case TYPE_oid:
    1117             : #endif
    1118         110 :                                 if (at->type->localtype == TYPE_bte)
    1119          95 :                                         a->data.val.lval = a->data.val.btval;
    1120          15 :                                 else if (at->type->localtype == TYPE_sht)
    1121          15 :                                         a->data.val.lval = a->data.val.shval;
    1122           0 :                                 else if (at->type->localtype == TYPE_int)
    1123           0 :                                         a->data.val.lval = a->data.val.ival;
    1124           0 :                                 else if (at->type->localtype != TYPE_lng)
    1125             :                                         return 0;
    1126             :                                 break;
    1127             : #ifdef HAVE_HGE
    1128          29 :                         case TYPE_hge:
    1129          29 :                                 if (at->type->localtype == TYPE_bte)
    1130           9 :                                         a->data.val.hval = a->data.val.btval;
    1131          20 :                                 else if (at->type->localtype == TYPE_sht)
    1132           0 :                                         a->data.val.hval = a->data.val.shval;
    1133          20 :                                 else if (at->type->localtype == TYPE_int)
    1134           0 :                                         a->data.val.hval = a->data.val.ival;
    1135          20 :                                 else if (at->type->localtype == TYPE_lng)
    1136          10 :                                         a->data.val.hval = a->data.val.lval;
    1137          10 :                                 else if (at->type->localtype != TYPE_hge)
    1138             :                                         return 0;
    1139             :                                 break;
    1140             : #endif
    1141             :                         default:
    1142             :                                 return 0;
    1143             :                         }
    1144             :                         /* fix scale */
    1145         183 :                         mul = scales[tp->scale-at->scale];
    1146         183 :                         a->tpe = *tp;
    1147         183 :                         a->data.vtype = tp->type->localtype;
    1148             : #ifdef HAVE_HGE
    1149         183 :                         if (a->data.vtype == TYPE_hge) {
    1150          29 :                                 a->data.val.hval *= mul;
    1151             :                         }
    1152         154 :                         else if (a->data.vtype == TYPE_lng) {
    1153         110 :                                 if ((hge) GDK_lng_min > (hge) a->data.val.lval * mul || (hge) a->data.val.lval * mul > (hge) GDK_lng_max)
    1154             :                                         return 0;
    1155         110 :                                 a->data.val.lval *= (lng) mul;
    1156             :                         }
    1157          44 :                         else if (a->data.vtype == TYPE_int) {
    1158          20 :                                 if ((hge) GDK_int_min > (hge) a->data.val.ival * mul || (hge) a->data.val.ival * mul > (hge) GDK_int_max)
    1159             :                                         return 0;
    1160          20 :                                 a->data.val.ival *= (int) mul;
    1161             :                         }
    1162          24 :                         else if (a->data.vtype == TYPE_sht) {
    1163          16 :                                 if ((hge) GDK_sht_min > (hge) a->data.val.shval * mul || (hge) a->data.val.shval * mul > (hge) GDK_sht_max)
    1164             :                                         return 0;
    1165          16 :                                 a->data.val.shval *= (sht) mul;
    1166             :                         }
    1167           8 :                         else if (a->data.vtype == TYPE_bte) {
    1168           8 :                                 if ((hge) GDK_bte_min > (hge) a->data.val.btval * mul || (hge) a->data.val.btval * mul > (hge) GDK_bte_max)
    1169             :                                         return 0;
    1170           8 :                                 a->data.val.btval *= (bte) mul;
    1171             :                         }
    1172             : #else
    1173             :                         if (a->data.vtype == TYPE_lng) {
    1174             :                                 a->data.val.lval *= mul;
    1175             :                         }
    1176             :                         else if (a->data.vtype == TYPE_int) {
    1177             :                                 if ((lng) GDK_int_min > (lng) a->data.val.ival * mul || (lng) a->data.val.ival * mul > (lng) GDK_int_max)
    1178             :                                         return 0;
    1179             :                                 a->data.val.ival *= (int) mul;
    1180             :                         }
    1181             :                         else if (a->data.vtype == TYPE_sht) {
    1182             :                                 if ((lng) GDK_sht_min > (lng) a->data.val.shval * mul || (lng) a->data.val.shval * mul > (lng) GDK_sht_max)
    1183             :                                         return 0;
    1184             :                                 a->data.val.shval *= (sht) mul;
    1185             :                         }
    1186             :                         else if (a->data.vtype == TYPE_bte) {
    1187             :                                 if ((lng) GDK_bte_min > (lng) a->data.val.btval * mul || (lng) a->data.val.btval * mul > (lng) GDK_bte_max)
    1188             :                                         return 0;
    1189             :                                 a->data.val.btval *= (bte) mul;
    1190             :                         }
    1191             : #endif
    1192         183 :                         return 1;
    1193             :                 }
    1194       11825 :                 if ((at->type->eclass == EC_DEC ||
    1195        6353 :                      at->type->eclass == EC_NUM) &&
    1196        6353 :                     tp->type->eclass == EC_FLT) {
    1197        5197 :                         if (!VALisnil(&a->data)) {
    1198             :                                 char *s;
    1199             : #ifdef HAVE_HGE
    1200             :                                 hge dec = 0;
    1201             : #else
    1202             :                                 lng dec = 0;
    1203             : #endif
    1204             :                                 /* cast decimals to doubles */
    1205        5197 :                                 switch (at->type->localtype) {
    1206        1773 :                                 case TYPE_bte:
    1207        1773 :                                         dec = a->data.val.btval;
    1208        1773 :                                         break;
    1209         714 :                                 case TYPE_sht:
    1210         714 :                                         dec = a->data.val.shval;
    1211         714 :                                         break;
    1212        2424 :                                 case TYPE_int:
    1213        2424 :                                         dec = a->data.val.ival;
    1214        2424 :                                         break;
    1215         283 :                                 case TYPE_lng:
    1216         283 :                                         dec = a->data.val.lval;
    1217         283 :                                         break;
    1218             : #ifdef HAVE_HGE
    1219           3 :                                 case TYPE_hge:
    1220           3 :                                         dec = a->data.val.hval;
    1221           3 :                                         break;
    1222             : #endif
    1223             :                                 default:
    1224             :                                         return 0;
    1225             :                                 }
    1226        5197 :                                 s = decimal_to_str(sa, dec, at);
    1227        5197 :                                 if (s) {
    1228        5197 :                                         int tpe = tp->type->localtype;
    1229        5197 :                                         size_t len = (tpe == TYPE_dbl) ? sizeof(dbl) : sizeof(flt);
    1230             :                                         ssize_t res;
    1231        5197 :                                         ptr p = &(a->data.val);
    1232        5197 :                                         if ((res = ATOMfromstr(tpe, &p, &len, s, false)) < 0) {
    1233           0 :                                                 GDKclrerr();
    1234           0 :                                                 return 0;
    1235             :                                         }
    1236             :                                 } else {
    1237             :                                         return 0;
    1238             :                                 }
    1239             :                         }
    1240        5197 :                         a->tpe = *tp;
    1241        5197 :                         a->data.vtype = tp->type->localtype;
    1242        5197 :                         return 1;
    1243             :                 }
    1244        6628 :                 if (EC_VARCHAR(at->type->eclass) && (tp->type->eclass == EC_DATE || EC_TEMP_NOFRAC(tp->type->eclass))){
    1245        2825 :                         int type = tp->type->localtype;
    1246             :                         ssize_t res = 0;
    1247        2825 :                         ptr p = NULL;
    1248             : 
    1249        2825 :                         a->data.len = 0;
    1250        2825 :                         res = ATOMfromstr(type, &p, &a->data.len, a->data.val.sval, false);
    1251             :                         /* no result or nil means error (SQL has NULL not nil) */
    1252        5564 :                         if (res < (ssize_t) strlen(a->data.val.sval) || !p ||
    1253        2739 :                             ATOMcmp(type, p, ATOMnilptr(type)) == 0) {
    1254          86 :                                 GDKfree(p);
    1255          86 :                                 a->data.len = strlen(a->data.val.sval);
    1256          86 :                                 GDKclrerr();
    1257          86 :                                 return 0;
    1258             :                         }
    1259        2739 :                         a->tpe = *tp;
    1260        2739 :                         a->data.vtype = type;
    1261        2739 :                         VALset(&a->data, a->data.vtype, p);
    1262        2739 :                         SA_VALcopy(sa, &a->data, &a->data);
    1263        2739 :                         GDKfree(p);
    1264        2739 :                         return 1;
    1265             :                 }
    1266             :         } else {
    1267       17500 :                 a->tpe = *tp;
    1268       17500 :                 a->data.vtype = tp->type->localtype;
    1269       17500 :                 return VALset(&a->data, a->data.vtype, (ptr) ATOMnilptr(a->data.vtype)) != NULL;
    1270             :         }
    1271             :         return 0;
    1272             : }
    1273             : 
    1274             : int
    1275           0 : atom_neg(atom *a)
    1276             : {
    1277             :         ValRecord dst;
    1278           0 :         if (a->isnull)
    1279             :                 return 0;
    1280           0 :         VALempty(&dst);
    1281           0 :         dst.vtype = a->data.vtype;
    1282           0 :         if (VARcalcnegate(&dst, &a->data) != GDK_SUCCEED) {
    1283           0 :                 GDKclrerr();
    1284           0 :                 return -1;
    1285             :         }
    1286           0 :         a->data = dst;
    1287           0 :         return 0;
    1288             : }
    1289             : 
    1290             : int
    1291      108678 : atom_cmp(atom *a1, atom *a2)
    1292             : {
    1293      108678 :         if ( a1->tpe.type->localtype != a2->tpe.type->localtype)
    1294             :                 return -1;
    1295       42700 :         if ( a1->isnull != a2->isnull)
    1296             :                 return -1;
    1297       42590 :         if ( a1->isnull)
    1298             :                 return 0;
    1299       42559 :         return VALcmp(&a1->data, &a2->data);
    1300             : }
    1301             : 
    1302             : atom *
    1303          18 : atom_add(atom *a1, atom *a2)
    1304             : {
    1305             :         ValRecord dst;
    1306             : 
    1307          18 :         if ((!EC_COMPUTE(a1->tpe.type->eclass) && (a1->tpe.type->eclass != EC_DEC || a1->tpe.digits != a2->tpe.digits || a1->tpe.scale != a2->tpe.scale)) || a1->tpe.digits < a2->tpe.digits || a1->tpe.type->localtype != a2->tpe.type->localtype)
    1308             :                 return NULL;
    1309             :         if (a1->tpe.type->localtype < a2->tpe.type->localtype ||
    1310             :             (a1->tpe.type->localtype == a2->tpe.type->localtype &&
    1311             :              a1->tpe.digits < a2->tpe.digits)) {
    1312             :                 atom *t = a1;
    1313             :                 a1 = a2;
    1314             :                 a2 = t;
    1315             :         }
    1316          17 :         dst.vtype = a1->tpe.type->localtype;
    1317          17 :         if (VARcalcadd(&dst, &a1->data, &a2->data, 1) != GDK_SUCCEED) {
    1318           0 :                 GDKclrerr();
    1319           0 :                 return NULL;
    1320             :         }
    1321          17 :         a1->data = dst;
    1322          17 :         if (a1->isnull || a2->isnull)
    1323           0 :                 a1->isnull = 1;
    1324             :         return a1;
    1325             : }
    1326             : 
    1327             : atom *
    1328          22 : atom_sub(atom *a1, atom *a2)
    1329             : {
    1330             :         ValRecord dst;
    1331             : 
    1332          22 :         if ((!EC_COMPUTE(a1->tpe.type->eclass) && (a1->tpe.type->eclass != EC_DEC || a1->tpe.digits != a2->tpe.digits || a1->tpe.scale != a2->tpe.scale)) || a1->tpe.digits < a2->tpe.digits || a1->tpe.type->localtype != a2->tpe.type->localtype)
    1333             :                 return NULL;
    1334             :         if (a1->tpe.type->localtype < a2->tpe.type->localtype ||
    1335             :             (a1->tpe.type->localtype == a2->tpe.type->localtype &&
    1336             :              a1->tpe.digits < a2->tpe.digits))
    1337             :                 dst.vtype = a2->tpe.type->localtype;
    1338             :         else
    1339          21 :                 dst.vtype = a1->tpe.type->localtype;
    1340          21 :         if (VARcalcsub(&dst, &a1->data, &a2->data, 1) != GDK_SUCCEED) {
    1341           0 :                 GDKclrerr();
    1342           0 :                 return NULL;
    1343             :         }
    1344          21 :         if (a1->tpe.type->localtype < a2->tpe.type->localtype ||
    1345          21 :             (a1->tpe.type->localtype == a2->tpe.type->localtype &&
    1346          21 :              a1->tpe.digits < a2->tpe.digits))
    1347             :                 a1 = a2;
    1348          21 :         a1->data = dst;
    1349          21 :         if (a1->isnull || a2->isnull)
    1350           0 :                 a1->isnull = 1;
    1351             :         return a1;
    1352             : }
    1353             : 
    1354             : atom *
    1355           3 : atom_mul(atom *a1, atom *a2)
    1356             : {
    1357             :         ValRecord dst;
    1358             : 
    1359           3 :         if (!EC_COMPUTE(a1->tpe.type->eclass))
    1360             :                 return NULL;
    1361           3 :         if (a1->tpe.type->localtype < a2->tpe.type->localtype ||
    1362           3 :             (a1->tpe.type->localtype == a2->tpe.type->localtype &&
    1363           3 :              a1->tpe.digits < a2->tpe.digits)) {
    1364             :                 atom *t = a1;
    1365             :                 a1 = a2;
    1366             :                 a2 = t;
    1367             :         }
    1368           3 :         if (a1->isnull || a2->isnull) {
    1369           0 :                 a1->isnull = 1;
    1370           0 :                 return a1;
    1371             :         }
    1372           3 :         dst.vtype = a1->tpe.type->localtype;
    1373           3 :         if (VARcalcmul(&dst, &a1->data, &a2->data, 1) != GDK_SUCCEED) {
    1374           0 :                 GDKclrerr();
    1375           0 :                 return NULL;
    1376             :         }
    1377           3 :         a1->data = dst;
    1378           3 :         a1->tpe.digits += a2->tpe.digits;
    1379           3 :         return a1;
    1380             : }
    1381             : 
    1382             : int
    1383           0 : atom_inc(atom *a)
    1384             : {
    1385             :         ValRecord dst;
    1386             : 
    1387           0 :         if (a->isnull)
    1388             :                 return -1;
    1389           0 :         dst.vtype = a->data.vtype;
    1390           0 :         if (VARcalcincr(&dst, &a->data, 1) != GDK_SUCCEED) {
    1391           0 :                 GDKclrerr();
    1392           0 :                 return -1;
    1393             :         }
    1394           0 :         a->data = dst;
    1395           0 :         return 0;
    1396             : }
    1397             : 
    1398             : int
    1399       16874 : atom_is_zero(atom *a)
    1400             : {
    1401       16874 :         if (a->isnull || !ATOMlinear(a->tpe.type->localtype))
    1402             :                 return 0;
    1403       16874 :         switch (ATOMstorage(a->tpe.type->localtype)) {
    1404        9571 :         case TYPE_bte:
    1405        9571 :                 return a->data.val.btval == 0;
    1406        1037 :         case TYPE_sht:
    1407        1037 :                 return a->data.val.shval == 0;
    1408        3566 :         case TYPE_int:
    1409        3566 :                 return a->data.val.ival == 0;
    1410        2611 :         case TYPE_lng:
    1411        2611 :                 return a->data.val.lval == 0;
    1412             : #ifdef HAVE_HGE
    1413          69 :         case TYPE_hge:
    1414          69 :                 return a->data.val.hval == 0;
    1415             : #endif
    1416           0 :         case TYPE_flt:
    1417           0 :                 return a->data.val.fval == 0;
    1418          20 :         case TYPE_dbl:
    1419          20 :                 return a->data.val.dval == 0;
    1420             :         default:
    1421             :                 return 0;
    1422             :         }
    1423             : }
    1424             : 
    1425             : int
    1426       11243 : atom_is_true(atom *a)
    1427             : {
    1428       11243 :         if (a->isnull)
    1429             :                 return 0;
    1430       10994 :         switch (ATOMstorage(a->tpe.type->localtype)) {
    1431       10967 :         case TYPE_bte:
    1432       10967 :                 return a->data.val.btval != 0;
    1433           0 :         case TYPE_sht:
    1434           0 :                 return a->data.val.shval != 0;
    1435           5 :         case TYPE_int:
    1436           5 :                 return a->data.val.ival != 0;
    1437          15 :         case TYPE_lng:
    1438          15 :                 return a->data.val.lval != 0;
    1439             : #ifdef HAVE_HGE
    1440           0 :         case TYPE_hge:
    1441           0 :                 return a->data.val.hval != 0;
    1442             : #endif
    1443           0 :         case TYPE_flt:
    1444           0 :                 return a->data.val.fval != 0;
    1445           0 :         case TYPE_dbl:
    1446           0 :                 return a->data.val.dval != 0;
    1447             :         default:
    1448             :                 return 0;
    1449             :         }
    1450             : }
    1451             : 
    1452             : int
    1453        8206 : atom_is_false(atom *a)
    1454             : {
    1455        8206 :         if (a->isnull)
    1456             :                 return 0;
    1457        7940 :         switch (ATOMstorage(a->tpe.type->localtype)) {
    1458        7940 :         case TYPE_bte:
    1459        7940 :                 return a->data.val.btval == 0;
    1460           0 :         case TYPE_sht:
    1461           0 :                 return a->data.val.shval == 0;
    1462           0 :         case TYPE_int:
    1463           0 :                 return a->data.val.ival == 0;
    1464           0 :         case TYPE_lng:
    1465           0 :                 return a->data.val.lval == 0;
    1466             : #ifdef HAVE_HGE
    1467           0 :         case TYPE_hge:
    1468           0 :                 return a->data.val.hval == 0;
    1469             : #endif
    1470           0 :         case TYPE_flt:
    1471           0 :                 return a->data.val.fval == 0;
    1472           0 :         case TYPE_dbl:
    1473           0 :                 return a->data.val.dval == 0;
    1474             :         default:
    1475             :                 return 0;
    1476             :         }
    1477             : }
    1478             : 
    1479             : atom *
    1480        6997 : atom_zero_value(sql_allocator *sa, sql_subtype* tpe)
    1481             : {
    1482             :         void *ret = NULL;
    1483             :         atom *res = NULL;
    1484        6997 :         int localtype = tpe->type->localtype;
    1485             : 
    1486        6997 :         bte bval = 0;
    1487        6997 :         sht sval = 0;
    1488        6997 :         int ival = 0;
    1489        6997 :         lng lval = 0;
    1490             : #ifdef HAVE_HGE
    1491        6997 :         hge hval = 0;
    1492             : #endif
    1493        6997 :         flt fval = 0;
    1494        6997 :         dbl dval = 0;
    1495             : 
    1496        6997 :         if (ATOMlinear(localtype)) {
    1497        6997 :                 switch (ATOMstorage(localtype)) {
    1498             :                 case TYPE_bte:
    1499             :                         ret = &bval;
    1500             :                         break;
    1501           2 :                 case TYPE_sht:
    1502             :                         ret = &sval;
    1503           2 :                         break;
    1504          47 :                 case TYPE_int:
    1505             :                         ret = &ival;
    1506          47 :                         break;
    1507        6946 :                 case TYPE_lng:
    1508             :                         ret = &lval;
    1509        6946 :                         break;
    1510             : #ifdef HAVE_HGE
    1511           2 :                 case TYPE_hge:
    1512             :                         ret = &hval;
    1513           2 :                         break;
    1514             : #endif
    1515           0 :                 case TYPE_flt:
    1516             :                         ret = &fval;
    1517           0 :                         break;
    1518           0 :                 case TYPE_dbl:
    1519             :                         ret = &dval;
    1520           0 :                         break;
    1521             :                 default: /* no support for strings and blobs zero value */
    1522             :                         break;
    1523             :                 }
    1524           0 :         }
    1525             : 
    1526             :         if (ret != NULL) {
    1527        6997 :                 res = atom_create(sa);
    1528        6997 :                 res->tpe = *tpe;
    1529        6997 :                 res->isnull = 0;
    1530        6997 :                 res->data.vtype = localtype;
    1531        6997 :                 VALset(&res->data, res->data.vtype, ret);
    1532             :         }
    1533             : 
    1534        6997 :         return res;
    1535             : }
    1536             : 
    1537             : atom *
    1538         206 : atom_max_value(sql_allocator *sa, sql_subtype *tpe)
    1539             : {
    1540             :         void *ret = NULL;
    1541             :         atom *res = NULL;
    1542         206 :         int localtype = tpe->type->localtype;
    1543             : 
    1544         206 :         bte bval = GDK_bte_max;
    1545         206 :         sht sval = GDK_sht_max;
    1546         206 :         int ival = GDK_int_max;
    1547         206 :         lng lval = GDK_lng_max;
    1548             : #ifdef HAVE_HGE
    1549         206 :         hge hval = GDK_hge_max;
    1550             : #endif
    1551         206 :         flt fval = GDK_flt_max;
    1552         206 :         dbl dval = GDK_dbl_max;
    1553             : 
    1554         206 :         if (ATOMlinear(localtype)) {
    1555         206 :                 switch (ATOMstorage(localtype)) {
    1556             :                 case TYPE_bte:
    1557             :                         ret = &bval;
    1558             :                         break;
    1559           0 :                 case TYPE_sht:
    1560             :                         ret = &sval;
    1561           0 :                         break;
    1562          69 :                 case TYPE_int:
    1563             :                         ret = &ival;
    1564          69 :                         break;
    1565         125 :                 case TYPE_lng:
    1566             :                         ret = &lval;
    1567         125 :                         break;
    1568             : #ifdef HAVE_HGE
    1569           2 :                 case TYPE_hge:
    1570             :                         ret = &hval;
    1571           2 :                         break;
    1572             : #endif
    1573           0 :                 case TYPE_flt:
    1574             :                         ret = &fval;
    1575           0 :                         break;
    1576           0 :                 case TYPE_dbl:
    1577             :                         ret = &dval;
    1578           0 :                         break;
    1579             :                 default: /* no support for strings and blobs zero value */
    1580             :                         break;
    1581             :                 }
    1582           0 :         }
    1583             : 
    1584             :         if (ret != NULL) {
    1585         206 :                 res = atom_create(sa);
    1586         206 :                 res->tpe = *tpe;
    1587         206 :                 res->isnull = 0;
    1588         206 :                 res->data.vtype = localtype;
    1589         206 :                 VALset(&res->data, res->data.vtype, ret);
    1590             :         }
    1591             : 
    1592         206 :         return res;
    1593             : }

Generated by: LCOV version 1.14