LCOV - code coverage report
Current view: top level - sql/backends/monet5 - sql_subquery.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 410 831 49.3 %
Date: 2021-10-13 02:24:04 Functions: 16 21 76.2 %

          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_subquery.h"
      11             : #include "gdk_subquery.h"
      12             : 
      13             : str
      14         377 : zero_or_one_error(ptr ret, const bat *bid, const bit *err)
      15             : {
      16             :         BAT *b;
      17             :         BUN c;
      18             :         size_t _s;
      19             :         const void *p = NULL;
      20             : 
      21         377 :         if ((b = BATdescriptor(*bid)) == NULL) {
      22           0 :                 throw(SQL, "sql.zero_or_one", SQLSTATE(HY005) "Cannot access column descriptor");
      23             :         }
      24         377 :         c = BATcount(b);
      25         377 :         if (c == 0) {
      26           5 :                 p = ATOMnilptr(b->ttype);
      27         728 :         } else if (c == 1 || (c > 1 && *err == false)) {
      28         356 :                 BATiter bi = bat_iterator(b);
      29         356 :                 p = BUNtail(bi, 0);
      30         356 :                 bat_iterator_end(&bi);
      31             :         } else {
      32             :                 p = NULL;
      33          16 :                 BBPunfix(b->batCacheid);
      34          16 :                 throw(SQL, "sql.zero_or_one", SQLSTATE(21000) "Cardinality violation, scalar value expected");
      35             :         }
      36         361 :         _s = ATOMsize(ATOMtype(b->ttype));
      37         361 :         if (b->ttype == TYPE_void)
      38             :                 p = &oid_nil;
      39         361 :         if (ATOMextern(b->ttype)) {
      40         254 :                 _s = ATOMlen(ATOMtype(b->ttype), p);
      41         254 :                 *(ptr *) ret = GDKmalloc(_s);
      42         254 :                 if (*(ptr *) ret == NULL) {
      43           0 :                         BBPunfix(b->batCacheid);
      44           0 :                         throw(SQL, "sql.zero_or_one", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      45             :                 }
      46         254 :                 memcpy(*(ptr *) ret, p, _s);
      47         107 :         } else if (b->ttype == TYPE_bat) {
      48           0 :                 bat bid = *(bat *) p;
      49           0 :                 if ((*(BAT **) ret = BATdescriptor(bid)) == NULL){
      50           0 :                         BBPunfix(b->batCacheid);
      51           0 :                         throw(SQL, "sql.zero_or_one", SQLSTATE(HY005) "Cannot access column descriptor");
      52             :                 }
      53         107 :         } else if (_s == 4) {
      54          44 :                 *(int *) ret = *(int *) p;
      55          63 :         } else if (_s == 1) {
      56           2 :                 *(bte *) ret = *(bte *) p;
      57          61 :         } else if (_s == 2) {
      58           0 :                 *(sht *) ret = *(sht *) p;
      59          61 :         } else if (_s == 8) {
      60          53 :                 *(lng *) ret = *(lng *) p;
      61             : #ifdef HAVE_HGE
      62           8 :         } else if (_s == 16) {
      63           8 :                 *(hge *) ret = *(hge *) p;
      64             : #endif
      65             :         } else {
      66           0 :                 memcpy(ret, p, _s);
      67             :         }
      68         361 :         BBPunfix(b->batCacheid);
      69         361 :         return MAL_SUCCEED;
      70             : }
      71             : 
      72             : str
      73           0 : zero_or_one_error_bat(ptr ret, const bat *bid, const bat *err)
      74             : {
      75           0 :         bit t = FALSE;
      76             :         (void)err;
      77           0 :         return zero_or_one_error(ret, bid, &t);
      78             : }
      79             : 
      80             : str
      81         377 : zero_or_one(ptr ret, const bat *bid)
      82             : {
      83         377 :         bit t = TRUE;
      84         377 :         return zero_or_one_error(ret, bid, &t);
      85             : }
      86             : 
      87             : str
      88           0 : SQLsubzero_or_one(bat *ret, const bat *bid, const bat *gid, const bat *eid, bit *no_nil)
      89             : {
      90             :         gdk_return r;
      91           0 :         BAT *ng = NULL, *h = NULL, *g = NULL;
      92           0 :         lng max = 0;
      93             : 
      94             :         (void)no_nil;
      95             :         (void)eid;
      96             : 
      97           0 :         if (!(g = BATdescriptor(*gid)))
      98           0 :                 throw(MAL, "sql.subzero_or_one", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
      99           0 :         r = BATgroup(&ng, NULL, &h, g, NULL, NULL, NULL, NULL);
     100           0 :         BBPunfix(g->batCacheid);
     101           0 :         if (r != GDK_SUCCEED)
     102           0 :                 throw(MAL, "sql.subzero_or_one", GDK_EXCEPTION);
     103             : 
     104           0 :         if (ng)
     105           0 :                 BBPunfix(ng->batCacheid);
     106           0 :         BATmax(h, &max);
     107           0 :         BBPunfix(h->batCacheid);
     108             : 
     109           0 :         if (max != lng_nil && max > 1)
     110           0 :                 throw(SQL, "sql.subzero_or_one", SQLSTATE(M0M29) "zero_or_one: cardinality violation, scalar expression expected");
     111           0 :         BBPretain(*ret = *bid);
     112           0 :         return MAL_SUCCEED;
     113             : }
     114             : 
     115             : #define SQLall_imp(TPE) \
     116             :         do {            \
     117             :                 TPE val = TPE##_nil;    \
     118             :                 if (c > 0) { \
     119             :                         TPE *restrict bp = (TPE*)bi.base; \
     120             :                         if (c == 1 || (b->tsorted && b->trevsorted)) { \
     121             :                                 val = bp[0]; \
     122             :                         } else { \
     123             :                                 for (; q < c; q++) { /* find first non nil */ \
     124             :                                         val = bp[q]; \
     125             :                                         if (!is_##TPE##_nil(val)) \
     126             :                                                 break; \
     127             :                                 } \
     128             :                                 for (; q < c; q++) { \
     129             :                                         TPE pp = bp[q]; \
     130             :                                         if (val != pp && !is_##TPE##_nil(pp)) { /* values != and not nil */ \
     131             :                                                 val = TPE##_nil; \
     132             :                                                 break; \
     133             :                                         } \
     134             :                                 } \
     135             :                         } \
     136             :                 } \
     137             :                 *(TPE *) ret = val; \
     138             :         } while (0)
     139             : 
     140             : str
     141          32 : SQLall(ptr ret, const bat *bid)
     142             : {
     143             :         BAT *b;
     144             :         BUN c, q = 0;
     145             : 
     146          32 :         if ((b = BATdescriptor(*bid)) == NULL)
     147           0 :                 throw(SQL, "sql.all", SQLSTATE(HY005) "Cannot access column descriptor");
     148             : 
     149          32 :         c = BATcount(b);
     150          32 :         if (b->ttype == TYPE_void) {
     151           0 :                 oid p = oid_nil;
     152           0 :                 memcpy(ret, &p, sizeof(oid));
     153             :         } else {
     154          32 :                 BATiter bi = bat_iterator(b);
     155          53 :                 switch (ATOMbasetype(b->ttype)) {
     156          11 :                 case TYPE_bte:
     157          11 :                         SQLall_imp(bte);
     158          11 :                         break;
     159           1 :                 case TYPE_sht:
     160           4 :                         SQLall_imp(sht);
     161           1 :                         break;
     162           5 :                 case TYPE_int:
     163          10 :                         SQLall_imp(int);
     164           5 :                         break;
     165           9 :                 case TYPE_lng:
     166           9 :                         SQLall_imp(lng);
     167           9 :                         break;
     168             : #ifdef HAVE_HGE
     169           0 :                 case TYPE_hge:
     170           0 :                         SQLall_imp(hge);
     171           0 :                         break;
     172             : #endif
     173           0 :                 case TYPE_flt:
     174           0 :                         SQLall_imp(flt);
     175           0 :                         break;
     176           0 :                 case TYPE_dbl:
     177           0 :                         SQLall_imp(dbl);
     178           0 :                         break;
     179           6 :                 default: {
     180           6 :                         int (*ocmp) (const void *, const void *) = ATOMcompare(b->ttype);
     181           6 :                         const void *n = ATOMnilptr(b->ttype), *p = n;
     182             :                         size_t s;
     183             : 
     184           6 :                         if (c > 0) {
     185           6 :                                 if (c == 1 || (b->tsorted && b->trevsorted)) {
     186           5 :                                         p = BUNtail(bi, 0);
     187             :                                 } else {
     188           1 :                                         for (; q < c; q++) { /* find first non nil */
     189           1 :                                                 p = BUNtail(bi, q);
     190           1 :                                                 if (ocmp(n, p) != 0)
     191             :                                                         break;
     192             :                                         }
     193           2 :                                         for (; q < c; q++) {
     194           2 :                                                 const void *pp = BUNtail(bi, q);
     195           2 :                                                 if (ocmp(p, pp) != 0 && ocmp(n, pp) != 0) { /* values != and not nil */
     196             :                                                         p = n;
     197             :                                                         break;
     198             :                                                 }
     199             :                                         }
     200             :                                 }
     201             :                         }
     202          12 :                         s = ATOMlen(ATOMtype(b->ttype), p);
     203           6 :                         if (ATOMextern(b->ttype)) {
     204           5 :                                 *(ptr *) ret = GDKmalloc(s);
     205           5 :                                 if (*(ptr *) ret == NULL) {
     206           0 :                                         BBPunfix(b->batCacheid);
     207           0 :                                         throw(SQL, "sql.all", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     208             :                                 }
     209           5 :                                 memcpy(*(ptr *)ret, p, s);
     210             :                         } else
     211           1 :                                 memcpy(ret, p, s);
     212             :                 }
     213             :                 }
     214          32 :                 bat_iterator_end(&bi);
     215             :         }
     216          32 :         BBPunfix(b->batCacheid);
     217          32 :         return MAL_SUCCEED;
     218             : }
     219             : 
     220             : str
     221          37 : SQLall_grp(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     222             : {
     223          37 :         bat *ret = getArgReference_bat(stk, pci, 0);
     224          37 :         bat *lp = getArgReference_bat(stk, pci, 1);
     225          37 :         bat *gp = getArgReference_bat(stk, pci, 2);
     226          37 :         bat *gpe = getArgReference_bat(stk, pci, 3);
     227          37 :         bat *sp = pci->argc == 6 ? getArgReference_bat(stk, pci, 4) : NULL;
     228             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 6 ? 5 : 4); no_nil argument is ignored
     229             :         BAT *l = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
     230             : 
     231             :         (void)cntxt;
     232             :         (void)mb;
     233          37 :         l = BATdescriptor(*lp);
     234          37 :         g = BATdescriptor(*gp);
     235          37 :         e = BATdescriptor(*gpe);
     236          37 :         if (sp)
     237           0 :                 s = BATdescriptor(*sp);
     238             : 
     239          37 :         if (!l || !g || !e || (sp && !s)) {
     240           0 :                 if (l)
     241           0 :                         BBPunfix(l->batCacheid);
     242           0 :                 if (g)
     243           0 :                         BBPunfix(g->batCacheid);
     244           0 :                 if (e)
     245           0 :                         BBPunfix(e->batCacheid);
     246           0 :                 if (s)
     247           0 :                         BBPunfix(s->batCacheid);
     248           0 :                 throw(MAL, "sql.all =", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     249             :         }
     250             : 
     251          37 :         res = BATall_grp(l, g, e, s);
     252             : 
     253          37 :         BBPunfix(l->batCacheid);
     254          37 :         BBPunfix(g->batCacheid);
     255          37 :         BBPunfix(e->batCacheid);
     256          37 :         if (s)
     257           0 :                 BBPunfix(s->batCacheid);
     258          37 :         if (res == NULL)
     259           0 :                 throw(MAL, "sql.all =", GDK_EXCEPTION);
     260          37 :         *ret = res->batCacheid;
     261          37 :         BBPkeepref(res->batCacheid);
     262          37 :         return MAL_SUCCEED;
     263             : }
     264             : 
     265             : #define SQLnil_imp(TPE) \
     266             :         do {            \
     267             :                 TPE *restrict bp = (TPE*)bi.base;       \
     268             :                 for (BUN q = 0; q < o; q++) {        \
     269             :                         if (is_##TPE##_nil(bp[q])) { \
     270             :                                 *ret = TRUE; \
     271             :                                 break; \
     272             :                         } \
     273             :                 } \
     274             :         } while (0)
     275             : 
     276             : str
     277          82 : SQLnil(bit *ret, const bat *bid)
     278             : {
     279             :         BAT *b;
     280             : 
     281          82 :         if ((b = BATdescriptor(*bid)) == NULL) {
     282           0 :                 throw(SQL, "sql.nil", SQLSTATE(HY005) "Cannot access column descriptor");
     283             :         }
     284          82 :         *ret = FALSE;
     285          82 :         if (BATcount(b) == 0)
     286          16 :                 *ret = bit_nil;
     287          82 :         if (BATcount(b) > 0) {
     288          66 :                 BUN o = BUNlast(b);
     289             : 
     290          66 :                 BATiter bi = bat_iterator(b);
     291         126 :                 switch (ATOMbasetype(b->ttype)) {
     292          12 :                 case TYPE_bte:
     293          31 :                         SQLnil_imp(bte);
     294             :                         break;
     295           1 :                 case TYPE_sht:
     296           2 :                         SQLnil_imp(sht);
     297             :                         break;
     298          39 :                 case TYPE_int:
     299        3211 :                         SQLnil_imp(int);
     300             :                         break;
     301           6 :                 case TYPE_lng:
     302          11 :                         SQLnil_imp(lng);
     303             :                         break;
     304             : #ifdef HAVE_HGE
     305           2 :                 case TYPE_hge:
     306           4 :                         SQLnil_imp(hge);
     307             :                         break;
     308             : #endif
     309           0 :                 case TYPE_flt:
     310           0 :                         SQLnil_imp(flt);
     311             :                         break;
     312           0 :                 case TYPE_dbl:
     313           0 :                         SQLnil_imp(dbl);
     314             :                         break;
     315           6 :                 default: {
     316           6 :                         int (*ocmp) (const void *, const void *) = ATOMcompare(b->ttype);
     317           6 :                         const void *restrict nilp = ATOMnilptr(b->ttype);
     318             : 
     319          13 :                         for (BUN q = 0; q < o; q++) {
     320           8 :                                 const void *restrict c = BUNtail(bi, q);
     321           8 :                                 if (ocmp(nilp, c) == 0) {
     322           1 :                                         *ret = TRUE;
     323           1 :                                         break;
     324             :                                 }
     325             :                         }
     326             :                 }
     327             :                 }
     328          66 :                 bat_iterator_end(&bi);
     329             :         }
     330          82 :         BBPunfix(b->batCacheid);
     331          82 :         return MAL_SUCCEED;
     332             : }
     333             : 
     334             : str
     335          61 : SQLnil_grp(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     336             : {
     337          61 :         bat *ret = getArgReference_bat(stk, pci, 0);
     338          61 :         bat *lp = getArgReference_bat(stk, pci, 1);
     339          61 :         bat *gp = getArgReference_bat(stk, pci, 2);
     340          61 :         bat *gpe = getArgReference_bat(stk, pci, 3);
     341          61 :         bat *sp = pci->argc == 6 ? getArgReference_bat(stk, pci, 4) : NULL;
     342             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 6 ? 5 : 4); no_nil argument is ignored
     343             :         BAT *l = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
     344             : 
     345             :         (void)cntxt;
     346             :         (void)mb;
     347          61 :         l = BATdescriptor(*lp);
     348          61 :         g = BATdescriptor(*gp);
     349          61 :         e = BATdescriptor(*gpe);
     350          61 :         if (sp)
     351           0 :                 s = BATdescriptor(*sp);
     352             : 
     353          61 :         if (!l || !g || !e || (sp && !s)) {
     354           0 :                 if (l)
     355           0 :                         BBPunfix(l->batCacheid);
     356           0 :                 if (g)
     357           0 :                         BBPunfix(g->batCacheid);
     358           0 :                 if (e)
     359           0 :                         BBPunfix(e->batCacheid);
     360           0 :                 if (s)
     361           0 :                         BBPunfix(s->batCacheid);
     362           0 :                 throw(MAL, "sql.nil", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     363             :         }
     364             : 
     365          61 :         res = BATnil_grp(l, g, e, s);
     366             : 
     367          61 :         BBPunfix(l->batCacheid);
     368          61 :         BBPunfix(g->batCacheid);
     369          61 :         BBPunfix(e->batCacheid);
     370          61 :         if (s)
     371           0 :                 BBPunfix(s->batCacheid);
     372          61 :         if (res == NULL)
     373           0 :                 throw(MAL, "sql.nil", GDK_EXCEPTION);
     374          61 :         *ret = res->batCacheid;
     375          61 :         BBPkeepref(res->batCacheid);
     376          61 :         return MAL_SUCCEED;
     377             : }
     378             : 
     379             : static inline bit
     380             : any_cmp(const bit cmp, const bit nl, const bit nr)
     381             : {
     382           1 :         if (nr == bit_nil) /* empty -> FALSE */
     383             :                 return FALSE;
     384         230 :         else if (cmp == TRUE)
     385             :                 return TRUE;
     386         137 :         else if (nl == TRUE || nr == TRUE)
     387          86 :                 return bit_nil;
     388             :         return FALSE;
     389             : }
     390             : 
     391             : #define ANY_ALL_CMP_BULK(FUNC, CMP, NL, NR) \
     392             :         do { \
     393             :                 for (BUN i = 0 ; i < q ; i++) { \
     394             :                         res_l[i] = FUNC(CMP, NL, NR); \
     395             :                         has_nil |= is_bit_nil(res_l[i]); \
     396             :                 } \
     397             :         } while (0);
     398             : 
     399             : str
     400          52 : SQLany_cmp(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     401             : {
     402          52 :         bat *ret = isaBatType(getArgType(mb, pci, 0)) ? getArgReference_bat(stk, pci, 0) : NULL;
     403          52 :         bat *cid = isaBatType(getArgType(mb, pci, 1)) ? getArgReference_bat(stk, pci, 1) : NULL;
     404          52 :         bat *nlid = isaBatType(getArgType(mb, pci, 2)) ? getArgReference_bat(stk, pci, 2) : NULL;
     405          52 :         bat *nrid = isaBatType(getArgType(mb, pci, 3)) ? getArgReference_bat(stk, pci, 3) : NULL;
     406             :         BAT *cmp = NULL, *nl = NULL, *nr = NULL, *res = NULL;
     407             :         str msg = MAL_SUCCEED;
     408             :         BUN q = 0;
     409             :         bit *restrict res_l = NULL, *cmp_l = NULL, *nl_l = NULL, *nr_l = NULL, cmp_at = FALSE, nl_at = FALSE, nr_at = FALSE, has_nil = 0;
     410             :         BATiter cmpi, nli, nri;
     411             : 
     412             :         (void) cntxt;
     413          52 :         if (cid && (cmp = BATdescriptor(*cid)) == NULL) {
     414           0 :                 msg = createException(SQL, "sql.any_cmp", SQLSTATE(HY005) "Cannot access column descriptor");
     415           0 :                 goto bailout;
     416             :         }
     417          52 :         if (nlid && (nl = BATdescriptor(*nlid)) == NULL) {
     418           0 :                 msg = createException(SQL, "sql.any_cmp", SQLSTATE(HY005) "Cannot access column descriptor");
     419           0 :                 goto bailout;
     420             :         }
     421          52 :         if (nrid && (nr = BATdescriptor(*nrid)) == NULL) {
     422           0 :                 msg = createException(SQL, "sql.any_cmp", SQLSTATE(HY005) "Cannot access column descriptor");
     423           0 :                 goto bailout;
     424             :         }
     425          52 :         cmpi = bat_iterator(cmp);
     426          52 :         nli = bat_iterator(nl);
     427          52 :         nri = bat_iterator(nr);
     428          52 :         if (cmp)
     429          51 :                 cmp_l = (bit *) cmpi.base;
     430             :         else
     431           1 :                 cmp_at = *getArgReference_bit(stk, pci, 1);
     432          52 :         if (nl)
     433          40 :                 nl_l = (bit *) nli.base;
     434             :         else
     435          12 :                 nl_at = *getArgReference_bit(stk, pci, 2);
     436          52 :         if (nr)
     437          51 :                 nr_l = (bit *) nri.base;
     438             :         else
     439           1 :                 nr_at = *getArgReference_bit(stk, pci, 3);
     440             : 
     441          52 :         if (cmp || nl || nr) {
     442          51 :                 q = cmp ? cmpi.count : nl ? nli.count : nri.count;
     443          51 :                 if (!(res = COLnew(cmp ? cmp->hseqbase : nl ? nl->hseqbase : nr->hseqbase, TYPE_bit, q, TRANSIENT))) {
     444           0 :                         msg = createException(SQL, "sql.any_cmp", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     445           0 :                         goto bailout1;
     446             :                 }
     447          51 :                 res_l = (bit *) Tloc(res, 0);
     448             :         }
     449             : 
     450          52 :         if (!cmp && !nl && !nr) {
     451           1 :                 bit *b = getArgReference_bit(stk, pci, 0);
     452           1 :                 *b = any_cmp(cmp_at, nl_at, nr_at);
     453          51 :         } else if (cmp && !nl && !nr) {
     454           0 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_l[i], nl_at, nr_at);
     455          51 :         } else if (!cmp && nl && !nr) {
     456           0 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_at, nl_l[i], nr_at);
     457          51 :         } else if (!cmp && !nl && nr) {
     458           0 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_at, nl_at, nr_l[i]);
     459          51 :         } else if (!cmp && nl && nr) {
     460           0 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_at, nl_l[i], nr_l[i]);
     461          51 :         } else if (cmp && !nl && nr) {
     462          27 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_l[i], nl_at, nr_l[i]);
     463          40 :         } else if (cmp && nl && !nr) {
     464           0 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_l[i], nl_l[i], nr_at);
     465             :         } else {
     466         310 :                 ANY_ALL_CMP_BULK(any_cmp, cmp_l[i], nl_l[i], nr_l[i]);
     467             :         }
     468             : 
     469          52 :         if (res) {
     470          51 :                 BATsetcount(res, q);
     471          51 :                 res->tkey = BATcount(res) <= 1;
     472          51 :                 res->tsorted = BATcount(res) <= 1;
     473          51 :                 res->trevsorted = BATcount(res) <= 1;
     474          51 :                 res->tnil = has_nil;
     475          51 :                 res->tnonil = !has_nil;
     476             :         }
     477           1 : bailout1:
     478          52 :         bat_iterator_end(&cmpi);
     479          52 :         bat_iterator_end(&nli);
     480          52 :         bat_iterator_end(&nri);
     481             : 
     482          52 : bailout:
     483          52 :         if (res && !msg)
     484          51 :                 BBPkeepref(*ret = res->batCacheid);
     485           1 :         else if (res)
     486           0 :                 BBPreclaim(res);
     487          52 :         if (cmp)
     488          51 :                 BBPunfix(cmp->batCacheid);
     489          52 :         if (nl)
     490          40 :                 BBPunfix(nl->batCacheid);
     491          52 :         if (nr)
     492          51 :                 BBPunfix(nr->batCacheid);
     493          52 :         return msg;
     494             : }
     495             : 
     496             : static inline bit
     497         863 : all_cmp(const bit cmp, const bit nl, const bit nr)
     498             : {
     499         863 :         if (nr == bit_nil) /* empty -> TRUE */
     500             :                 return TRUE;
     501         523 :         else if (cmp == FALSE || (cmp == bit_nil && !nl && !nr))
     502             :                 return FALSE;
     503         211 :         else if (nl == TRUE || nr == TRUE)
     504             :                 return bit_nil;
     505             :         else
     506          79 :                 return cmp;
     507             :         return TRUE;
     508             : }
     509             : 
     510             : str
     511         107 : SQLall_cmp(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     512             : {
     513         107 :         bat *ret = isaBatType(getArgType(mb, pci, 0)) ? getArgReference_bat(stk, pci, 0) : NULL;
     514         107 :         bat *cid = isaBatType(getArgType(mb, pci, 1)) ? getArgReference_bat(stk, pci, 1) : NULL;
     515         107 :         bat *nlid = isaBatType(getArgType(mb, pci, 2)) ? getArgReference_bat(stk, pci, 2) : NULL;
     516         107 :         bat *nrid = isaBatType(getArgType(mb, pci, 3)) ? getArgReference_bat(stk, pci, 3) : NULL;
     517             :         BAT *cmp = NULL, *nl = NULL, *nr = NULL, *res = NULL;
     518             :         str msg = MAL_SUCCEED;
     519             :         BUN q = 0;
     520             :         bit *restrict res_l = NULL, *cmp_l = NULL, *nl_l = NULL, *nr_l = NULL, cmp_at = FALSE, nl_at = FALSE, nr_at = FALSE, has_nil = 0;
     521             :         BATiter cmpi, nli, nri;
     522             : 
     523             :         (void) cntxt;
     524         107 :         if (cid && (cmp = BATdescriptor(*cid)) == NULL) {
     525           0 :                 msg = createException(SQL, "sql.all_cmp", SQLSTATE(HY005) "Cannot access column descriptor");
     526           0 :                 goto bailout;
     527             :         }
     528         107 :         if (nlid && (nl = BATdescriptor(*nlid)) == NULL) {
     529           0 :                 msg = createException(SQL, "sql.all_cmp", SQLSTATE(HY005) "Cannot access column descriptor");
     530           0 :                 goto bailout;
     531             :         }
     532         107 :         if (nrid && (nr = BATdescriptor(*nrid)) == NULL) {
     533           0 :                 msg = createException(SQL, "sql.all_cmp", SQLSTATE(HY005) "Cannot access column descriptor");
     534           0 :                 goto bailout;
     535             :         }
     536         107 :         cmpi = bat_iterator(cmp);
     537         107 :         nli = bat_iterator(nl);
     538         107 :         nri = bat_iterator(nr);
     539         107 :         if (cmp)
     540         102 :                 cmp_l = (bit *) cmpi.base;
     541             :         else
     542           5 :                 cmp_at = *getArgReference_bit(stk, pci, 1);
     543         107 :         if (nl)
     544          80 :                 nl_l = (bit *) nli.base;
     545             :         else
     546          27 :                 nl_at = *getArgReference_bit(stk, pci, 2);
     547         107 :         if (nr)
     548         105 :                 nr_l = (bit *) nri.base;
     549             :         else
     550           2 :                 nr_at = *getArgReference_bit(stk, pci, 3);
     551             : 
     552         107 :         if (cmp || nl || nr) {
     553         105 :                 q = cmp ? cmpi.count : nl ? nli.count : nri.count;
     554         105 :                 if (!(res = COLnew(cmp ? cmp->hseqbase : nl ? nl->hseqbase : nr->hseqbase, TYPE_bit, q, TRANSIENT))) {
     555           0 :                         msg = createException(SQL, "sql.all_cmp", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     556           0 :                         goto bailout1;
     557             :                 }
     558         105 :                 res_l = (bit *) Tloc(res, 0);
     559             :         }
     560             : 
     561         107 :         if (!cmp && !nl && !nr) {
     562           2 :                 bit *b = getArgReference_bit(stk, pci, 0);
     563           2 :                 *b = all_cmp(cmp_at, nl_at, nr_at);
     564         105 :         } else if (cmp && !nl && !nr) {
     565           0 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_l[i], nl_at, nr_at);
     566         105 :         } else if (!cmp && nl && !nr) {
     567           0 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_at, nl_l[i], nr_at);
     568         105 :         } else if (!cmp && !nl && nr) {
     569           0 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_at, nl_at, nr_l[i]);
     570         105 :         } else if (!cmp && nl && nr) {
     571          30 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_at, nl_l[i], nr_l[i]);
     572         102 :         } else if (cmp && !nl && nr) {
     573          66 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_l[i], nl_at, nr_l[i]);
     574          77 :         } else if (cmp && nl && !nr) {
     575           0 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_l[i], nl_l[i], nr_at);
     576             :         } else {
     577         870 :                 ANY_ALL_CMP_BULK(all_cmp, cmp_l[i], nl_l[i], nr_l[i]);
     578             :         }
     579             : 
     580         107 :         if (res) {
     581         105 :                 BATsetcount(res, q);
     582         105 :                 res->tkey = BATcount(res) <= 1;
     583         105 :                 res->tsorted = BATcount(res) <= 1;
     584         105 :                 res->trevsorted = BATcount(res) <= 1;
     585         105 :                 res->tnil = has_nil;
     586         105 :                 res->tnonil = !has_nil;
     587             :         }
     588           2 : bailout1:
     589         107 :         bat_iterator_end(&cmpi);
     590         107 :         bat_iterator_end(&nli);
     591         107 :         bat_iterator_end(&nri);
     592             : 
     593         107 : bailout:
     594         107 :         if (res && !msg)
     595         105 :                 BBPkeepref(*ret = res->batCacheid);
     596           2 :         else if (res)
     597           0 :                 BBPreclaim(res);
     598         107 :         if (cmp)
     599         102 :                 BBPunfix(cmp->batCacheid);
     600         107 :         if (nl)
     601          80 :                 BBPunfix(nl->batCacheid);
     602         107 :         if (nr)
     603         105 :                 BBPunfix(nr->batCacheid);
     604         107 :         return msg;
     605             : }
     606             : 
     607             : #define SQLanyequal_or_not_imp_single(TPE, OUTPUT) \
     608             :         do {                                                    \
     609             :                 TPE *rp = (TPE*)ri.base, *lp = (TPE*)li.base, p = lp[0];        \
     610             :                 for (BUN q = 0; q < o; q++) {        \
     611             :                         TPE c = rp[q]; \
     612             :                         if (is_##TPE##_nil(c)) { \
     613             :                                 *ret = bit_nil; \
     614             :                         } else if (p == c) { \
     615             :                                 *ret = OUTPUT; \
     616             :                                 break; \
     617             :                         } \
     618             :                 } \
     619             :         } while (0)
     620             : 
     621             : #define SQLanyequal_or_not_imp_multi(TPE, CMP) \
     622             :         do {                                                    \
     623             :                 TPE *rp = (TPE*)ri.base, *lp = (TPE*)li.base;   \
     624             :                 for (BUN q = 0; q < o; q++) {        \
     625             :                         TPE c = rp[q], d = lp[q]; \
     626             :                         res_l[q] = (is_##TPE##_nil(c) || is_##TPE##_nil(d)) ? bit_nil : c CMP d; \
     627             :                 } \
     628             :         } while (0)
     629             : 
     630             : str
     631           5 : SQLanyequal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     632             : {
     633           5 :         bat *bret = isaBatType(getArgType(mb, pci, 0)) ? getArgReference_bat(stk, pci, 0) : NULL;
     634           5 :         bat *bid1 = getArgReference_bat(stk, pci, 1);
     635           5 :         bat *bid2 = getArgReference_bat(stk, pci, 2);
     636             :         BAT *res = NULL, *l = NULL, *r = NULL;
     637             :         str msg = MAL_SUCCEED;
     638             :         BUN o = 0;
     639             :         BATiter li, ri;
     640             : 
     641             :         (void) cntxt;
     642           5 :         if ((l = BATdescriptor(*bid1)) == NULL) {
     643           0 :                 msg = createException(SQL, "sql.any =", SQLSTATE(HY005) "Cannot access column descriptor");
     644           0 :                 goto bailout;
     645             :         }
     646           5 :         if ((r = BATdescriptor(*bid2)) == NULL) {
     647           0 :                 msg = createException(SQL, "sql.any =", SQLSTATE(HY005) "Cannot access column descriptor");
     648           0 :                 goto bailout;
     649             :         }
     650           5 :         if (l->ttype != r->ttype) {
     651           0 :                 msg = createException(SQL, "sql.any =", SQLSTATE(42000) "sql.any = requires both arguments of the same type");
     652           0 :                 goto bailout;
     653             :         }
     654             : 
     655           5 :         o = BATcount(r);
     656           5 :         ri = bat_iterator(r);
     657           5 :         li = bat_iterator(l);
     658           5 :         if (bret) {
     659           5 :                 if (!(res = COLnew(r->hseqbase, TYPE_bit, o, TRANSIENT))) {
     660           0 :                         msg = createException(SQL, "sql.any =", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     661           0 :                         goto bailout1;
     662             :                 }
     663           5 :                 bit *restrict res_l = (bit*) Tloc(res, 0);
     664             : 
     665          10 :                 switch (ATOMbasetype(l->ttype)) {
     666           0 :                 case TYPE_bte:
     667           0 :                         SQLanyequal_or_not_imp_multi(bte, ==);
     668             :                         break;
     669           0 :                 case TYPE_sht:
     670           0 :                         SQLanyequal_or_not_imp_multi(sht, ==);
     671             :                         break;
     672           0 :                 case TYPE_int:
     673           0 :                         SQLanyequal_or_not_imp_multi(int, ==);
     674             :                         break;
     675           5 :                 case TYPE_lng:
     676         413 :                         SQLanyequal_or_not_imp_multi(lng, ==);
     677             :                         break;
     678             : #ifdef HAVE_HGE
     679           0 :                 case TYPE_hge:
     680           0 :                         SQLanyequal_or_not_imp_multi(hge, ==);
     681             :                         break;
     682             : #endif
     683           0 :                 case TYPE_flt:
     684           0 :                         SQLanyequal_or_not_imp_multi(flt, ==);
     685             :                         break;
     686           0 :                 case TYPE_dbl:
     687           0 :                         SQLanyequal_or_not_imp_multi(dbl, ==);
     688             :                         break;
     689           0 :                 default: {
     690           0 :                         int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
     691           0 :                         const void *nilp = ATOMnilptr(l->ttype);
     692             : 
     693           0 :                         for (BUN q = 0; q < o; q++) {
     694           0 :                                 const void *c = BUNtail(ri, q), *d = BUNtail(li, q);
     695           0 :                                 res_l[q] = ocmp(nilp, c) == 0 || ocmp(nilp, d) == 0 ? bit_nil : ocmp(c, d) == 0;
     696             :                         }
     697             :                 }
     698             :                 }
     699             : 
     700           5 :                 BATsetcount(res, o);
     701           5 :                 res->tkey = BATcount(res) <= 1;
     702           5 :                 res->tsorted = BATcount(res) <= 1;
     703           5 :                 res->trevsorted = BATcount(res) <= 1;
     704           5 :                 res->tnil = l->tnil || r->tnil;
     705          10 :                 res->tnonil = l->tnonil && r->tnonil;
     706             :         } else {
     707           0 :                 bit *ret = getArgReference_bit(stk, pci, 0);
     708             : 
     709           0 :                 *ret = FALSE;
     710           0 :                 if (o > 0) {
     711           0 :                         switch (ATOMbasetype(l->ttype)) {
     712           0 :                         case TYPE_bte:
     713           0 :                                 SQLanyequal_or_not_imp_single(bte, TRUE);
     714             :                                 break;
     715           0 :                         case TYPE_sht:
     716           0 :                                 SQLanyequal_or_not_imp_single(sht, TRUE);
     717             :                                 break;
     718           0 :                         case TYPE_int:
     719           0 :                                 SQLanyequal_or_not_imp_single(int, TRUE);
     720             :                                 break;
     721           0 :                         case TYPE_lng:
     722           0 :                                 SQLanyequal_or_not_imp_single(lng, TRUE);
     723             :                                 break;
     724             : #ifdef HAVE_HGE
     725           0 :                         case TYPE_hge:
     726           0 :                                 SQLanyequal_or_not_imp_single(hge, TRUE);
     727             :                                 break;
     728             : #endif
     729           0 :                         case TYPE_flt:
     730           0 :                                 SQLanyequal_or_not_imp_single(flt, TRUE);
     731             :                                 break;
     732           0 :                         case TYPE_dbl:
     733           0 :                                 SQLanyequal_or_not_imp_single(dbl, TRUE);
     734             :                                 break;
     735           0 :                         default: {
     736           0 :                                 int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
     737           0 :                                 const void *nilp = ATOMnilptr(l->ttype);
     738           0 :                                 const void *p = BUNtail(li, 0);
     739             : 
     740           0 :                                 for (BUN q = 0; q < o; q++) {
     741           0 :                                         const void *c = BUNtail(ri, q);
     742           0 :                                         if (ocmp(nilp, c) == 0)
     743           0 :                                                 *ret = bit_nil;
     744           0 :                                         else if (ocmp(p, c) == 0) {
     745           0 :                                                 *ret = TRUE;
     746           0 :                                                 break;
     747             :                                         }
     748             :                                 }
     749             :                         }
     750             :                         }
     751             :                 }
     752             :         }
     753           0 : bailout1:
     754           5 :         bat_iterator_end(&li);
     755           5 :         bat_iterator_end(&ri);
     756             : 
     757           5 : bailout:
     758           5 :         if (res && !msg)
     759           5 :                 BBPkeepref(*bret = res->batCacheid);
     760           0 :         else if (res)
     761           0 :                 BBPreclaim(res);
     762           5 :         if (l)
     763           5 :                 BBPunfix(l->batCacheid);
     764           5 :         if (r)
     765           5 :                 BBPunfix(r->batCacheid);
     766           5 :         return msg;
     767             : }
     768             : 
     769             : str
     770           0 : SQLanyequal_grp(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     771             : {
     772           0 :         bat *ret = getArgReference_bat(stk, pci, 0);
     773           0 :         bat *lp = getArgReference_bat(stk, pci, 1);
     774           0 :         bat *rp = getArgReference_bat(stk, pci, 2);
     775           0 :         bat *gp = getArgReference_bat(stk, pci, 3);
     776           0 :         bat *gpe = getArgReference_bat(stk, pci, 4);
     777           0 :         bat *sp = pci->argc == 7 ? getArgReference_bat(stk, pci, 5) : NULL;
     778             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 7 ? 6 : 5); no_nil argument is ignored
     779             :         BAT *l = NULL, *r = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
     780             : 
     781             :         (void)cntxt;
     782             :         (void)mb;
     783           0 :         l = BATdescriptor(*lp);
     784           0 :         r = BATdescriptor(*rp);
     785           0 :         g = BATdescriptor(*gp);
     786           0 :         e = BATdescriptor(*gpe);
     787           0 :         if (sp)
     788           0 :                 s = BATdescriptor(*sp);
     789             : 
     790           0 :         if (!l || !r || !g || !e || (sp && !s)) {
     791           0 :                 if (l)
     792           0 :                         BBPunfix(l->batCacheid);
     793           0 :                 if (r)
     794           0 :                         BBPunfix(r->batCacheid);
     795           0 :                 if (g)
     796           0 :                         BBPunfix(g->batCacheid);
     797           0 :                 if (e)
     798           0 :                         BBPunfix(e->batCacheid);
     799           0 :                 if (s)
     800           0 :                         BBPunfix(s->batCacheid);
     801           0 :                 throw(MAL, "sql.any =", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     802             :         }
     803           0 :         if (l->ttype != r->ttype) {
     804           0 :                 BBPunfix(l->batCacheid);
     805           0 :                 BBPunfix(r->batCacheid);
     806           0 :                 BBPunfix(g->batCacheid);
     807           0 :                 BBPunfix(e->batCacheid);
     808           0 :                 if (s)
     809           0 :                         BBPunfix(s->batCacheid);
     810           0 :                 throw(MAL, "sql.any =", SQLSTATE(42000) "sql.any = requires both arguments of the same type");
     811             :         }
     812             : 
     813           0 :         res = BATanyequal_grp(l, r, g, e, s);
     814             : 
     815           0 :         BBPunfix(l->batCacheid);
     816           0 :         BBPunfix(r->batCacheid);
     817           0 :         BBPunfix(g->batCacheid);
     818           0 :         BBPunfix(e->batCacheid);
     819           0 :         if (s)
     820           0 :                 BBPunfix(s->batCacheid);
     821           0 :         if (res == NULL)
     822           0 :                 throw(MAL, "sql.any =", GDK_EXCEPTION);
     823           0 :         *ret = res->batCacheid;
     824           0 :         BBPkeepref(res->batCacheid);
     825           0 :         return MAL_SUCCEED;
     826             : }
     827             : 
     828             : str
     829         130 : SQLanyequal_grp2(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     830             : {
     831         130 :         bat *ret = getArgReference_bat(stk, pci, 0);
     832         130 :         bat *lp = getArgReference_bat(stk, pci, 1);
     833         130 :         bat *rp = getArgReference_bat(stk, pci, 2);
     834         130 :         bat *ip = getArgReference_bat(stk, pci, 3);
     835         130 :         bat *gp = getArgReference_bat(stk, pci, 4);
     836         130 :         bat *gpe = getArgReference_bat(stk, pci, 5);
     837         130 :         bat *sp = pci->argc == 8 ? getArgReference_bat(stk, pci, 6) : NULL;
     838             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 8 ? 7 : 6); no_nil argument is ignored
     839             :         BAT *l = NULL, *r = NULL, *rid = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
     840             :         (void)cntxt;
     841             :         (void)mb;
     842             : 
     843         130 :         l = BATdescriptor(*lp);
     844         130 :         r = BATdescriptor(*rp);
     845         130 :         rid = BATdescriptor(*ip);
     846         130 :         g = BATdescriptor(*gp);
     847         130 :         e = BATdescriptor(*gpe);
     848         130 :         if (sp)
     849           0 :                 s = BATdescriptor(*sp);
     850             : 
     851         130 :         if (!l || !r || !rid || !g || !e || (sp && !s)) {
     852           0 :                 if (l)
     853           0 :                         BBPunfix(l->batCacheid);
     854           0 :                 if (r)
     855           0 :                         BBPunfix(r->batCacheid);
     856           0 :                 if (rid)
     857           0 :                         BBPunfix(rid->batCacheid);
     858           0 :                 if (g)
     859           0 :                         BBPunfix(g->batCacheid);
     860           0 :                 if (e)
     861           0 :                         BBPunfix(e->batCacheid);
     862           0 :                 if (s)
     863           0 :                         BBPunfix(s->batCacheid);
     864           0 :                 throw(MAL, "sql.any =", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     865             :         }
     866         130 :         if (l->ttype != r->ttype) {
     867           0 :                 BBPunfix(l->batCacheid);
     868           0 :                 BBPunfix(r->batCacheid);
     869           0 :                 BBPunfix(rid->batCacheid);
     870           0 :                 BBPunfix(g->batCacheid);
     871           0 :                 BBPunfix(e->batCacheid);
     872           0 :                 if (s)
     873           0 :                         BBPunfix(s->batCacheid);
     874           0 :                 throw(MAL, "sql.any =", SQLSTATE(42000) "sql.any = requires both arguments of the same type");
     875             :         }
     876             : 
     877         130 :         res = BATanyequal_grp2(l, r, rid, g, e, s);
     878             : 
     879         130 :         BBPunfix(l->batCacheid);
     880         130 :         BBPunfix(r->batCacheid);
     881         130 :         BBPunfix(rid->batCacheid);
     882         130 :         BBPunfix(g->batCacheid);
     883         130 :         BBPunfix(e->batCacheid);
     884         130 :         if (s)
     885           0 :                 BBPunfix(s->batCacheid);
     886         130 :         if (res == NULL)
     887           0 :                 throw(MAL, "sql.any =", GDK_EXCEPTION);
     888         130 :         *ret = res->batCacheid;
     889         130 :         BBPkeepref(res->batCacheid);
     890         130 :         return MAL_SUCCEED;
     891             : }
     892             : 
     893             : str
     894           0 : SQLallnotequal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     895             : {
     896           0 :         bat *bret = isaBatType(getArgType(mb, pci, 0)) ? getArgReference_bat(stk, pci, 0) : NULL;
     897           0 :         bat *bid1 = getArgReference_bat(stk, pci, 1);
     898           0 :         bat *bid2 = getArgReference_bat(stk, pci, 2);
     899             :         BAT *res = NULL, *l = NULL, *r = NULL;
     900             :         str msg = MAL_SUCCEED;
     901             :         BUN o = 0;
     902             :         BATiter li, ri;
     903             : 
     904             :         (void) cntxt;
     905           0 :         if ((l = BATdescriptor(*bid1)) == NULL) {
     906           0 :                 msg = createException(SQL, "sql.all <>", SQLSTATE(HY005) "Cannot access column descriptor");
     907           0 :                 goto bailout;
     908             :         }
     909           0 :         if ((r = BATdescriptor(*bid2)) == NULL) {
     910           0 :                 msg = createException(SQL, "sql.all <>", SQLSTATE(HY005) "Cannot access column descriptor");
     911           0 :                 goto bailout;
     912             :         }
     913           0 :         if (l->ttype != r->ttype) {
     914           0 :                 msg = createException(SQL, "sql.all <>", SQLSTATE(42000) "sql.all <> requires both arguments of the same type");
     915           0 :                 goto bailout;
     916             :         }
     917             : 
     918           0 :         o = BATcount(r);
     919           0 :         ri = bat_iterator(r);
     920           0 :         li = bat_iterator(l);
     921           0 :         if (bret) {
     922           0 :                 if (!(res = COLnew(r->hseqbase, TYPE_bit, o, TRANSIENT))) {
     923           0 :                         msg = createException(SQL, "sql.all <>", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     924           0 :                         goto bailout;
     925             :                 }
     926           0 :                 bit *restrict res_l = (bit*) Tloc(res, 0);
     927             : 
     928           0 :                 switch (ATOMbasetype(l->ttype)) {
     929           0 :                 case TYPE_bte:
     930           0 :                         SQLanyequal_or_not_imp_multi(bte, !=);
     931             :                         break;
     932           0 :                 case TYPE_sht:
     933           0 :                         SQLanyequal_or_not_imp_multi(sht, !=);
     934             :                         break;
     935           0 :                 case TYPE_int:
     936           0 :                         SQLanyequal_or_not_imp_multi(int, !=);
     937             :                         break;
     938           0 :                 case TYPE_lng:
     939           0 :                         SQLanyequal_or_not_imp_multi(lng, !=);
     940             :                         break;
     941             : #ifdef HAVE_HGE
     942           0 :                 case TYPE_hge:
     943           0 :                         SQLanyequal_or_not_imp_multi(hge, !=);
     944             :                         break;
     945             : #endif
     946           0 :                 case TYPE_flt:
     947           0 :                         SQLanyequal_or_not_imp_multi(flt, !=);
     948             :                         break;
     949           0 :                 case TYPE_dbl:
     950           0 :                         SQLanyequal_or_not_imp_multi(dbl, !=);
     951             :                         break;
     952           0 :                 default: {
     953           0 :                         int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
     954           0 :                         const void *nilp = ATOMnilptr(l->ttype);
     955           0 :                         BATiter li = bat_iterator(l), ri = bat_iterator(r);
     956             : 
     957           0 :                         for (BUN q = 0; q < o; q++) {
     958           0 :                                 const void *c = BUNtail(ri, q), *d = BUNtail(li, q);
     959           0 :                                 res_l[q] = ocmp(nilp, c) == 0 || ocmp(nilp, d) == 0 ? bit_nil : ocmp(c, d) != 0;
     960             :                         }
     961           0 :                         bat_iterator_end(&li);
     962           0 :                         bat_iterator_end(&ri);
     963             :                 }
     964             :                 }
     965             : 
     966           0 :                 BATsetcount(res, o);
     967           0 :                 res->tkey = BATcount(res) <= 1;
     968           0 :                 res->tsorted = BATcount(res) <= 1;
     969           0 :                 res->trevsorted = BATcount(res) <= 1;
     970           0 :                 res->tnil = l->tnil || r->tnil;
     971           0 :                 res->tnonil = l->tnonil && r->tnonil;
     972             :         } else {
     973           0 :                 bit *ret = getArgReference_bit(stk, pci, 0);
     974             : 
     975           0 :                 *ret = TRUE;
     976           0 :                 if (o > 0) {
     977           0 :                         switch (ATOMbasetype(l->ttype)) {
     978           0 :                         case TYPE_bte:
     979           0 :                                 SQLanyequal_or_not_imp_single(bte, FALSE);
     980             :                                 break;
     981           0 :                         case TYPE_sht:
     982           0 :                                 SQLanyequal_or_not_imp_single(sht, FALSE);
     983             :                                 break;
     984           0 :                         case TYPE_int:
     985           0 :                                 SQLanyequal_or_not_imp_single(int, FALSE);
     986             :                                 break;
     987           0 :                         case TYPE_lng:
     988           0 :                                 SQLanyequal_or_not_imp_single(lng, FALSE);
     989             :                                 break;
     990             : #ifdef HAVE_HGE
     991           0 :                         case TYPE_hge:
     992           0 :                                 SQLanyequal_or_not_imp_single(hge, FALSE);
     993             :                                 break;
     994             : #endif
     995           0 :                         case TYPE_flt:
     996           0 :                                 SQLanyequal_or_not_imp_single(flt, FALSE);
     997             :                                 break;
     998           0 :                         case TYPE_dbl:
     999           0 :                                 SQLanyequal_or_not_imp_single(dbl, FALSE);
    1000             :                                 break;
    1001           0 :                         default: {
    1002           0 :                                 int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
    1003           0 :                                 const void *nilp = ATOMnilptr(l->ttype);
    1004           0 :                                 const void *p = BUNtail(li, 0);
    1005             : 
    1006           0 :                                 for (BUN q = 0; q < o; q++) {
    1007           0 :                                         const void *c = BUNtail(ri, q);
    1008           0 :                                         if (ocmp(nilp, c) == 0)
    1009           0 :                                                 *ret = bit_nil;
    1010           0 :                                         else if (ocmp(p, c) == 0) {
    1011           0 :                                                 *ret = FALSE;
    1012           0 :                                                 break;
    1013             :                                         }
    1014             :                                 }
    1015             :                         }
    1016             :                         }
    1017             :                 }
    1018             :         }
    1019           0 :         bat_iterator_end(&li);
    1020           0 :         bat_iterator_end(&ri);
    1021             : 
    1022           0 : bailout:
    1023           0 :         if (res && !msg)
    1024           0 :                 BBPkeepref(*bret = res->batCacheid);
    1025           0 :         else if (res)
    1026           0 :                 BBPreclaim(res);
    1027           0 :         if (l)
    1028           0 :                 BBPunfix(l->batCacheid);
    1029           0 :         if (r)
    1030           0 :                 BBPunfix(r->batCacheid);
    1031           0 :         return msg;
    1032             : }
    1033             : 
    1034             : str
    1035           0 : SQLallnotequal_grp(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1036             : {
    1037           0 :         bat *ret = getArgReference_bat(stk, pci, 0);
    1038           0 :         bat *lp = getArgReference_bat(stk, pci, 1);
    1039           0 :         bat *rp = getArgReference_bat(stk, pci, 2);
    1040           0 :         bat *gp = getArgReference_bat(stk, pci, 3);
    1041           0 :         bat *gpe = getArgReference_bat(stk, pci, 4);
    1042           0 :         bat *sp = pci->argc == 7 ? getArgReference_bat(stk, pci, 5) : NULL;
    1043             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 7 ? 6 : 5); no_nil argument is ignored
    1044             :         BAT *l = NULL, *r = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
    1045             : 
    1046             :         (void)cntxt;
    1047             :         (void)mb;
    1048           0 :         l = BATdescriptor(*lp);
    1049           0 :         r = BATdescriptor(*rp);
    1050           0 :         g = BATdescriptor(*gp);
    1051           0 :         e = BATdescriptor(*gpe);
    1052           0 :         if (sp)
    1053           0 :                 s = BATdescriptor(*sp);
    1054             : 
    1055           0 :         if (!l || !r || !g || !e || (sp && !s)) {
    1056           0 :                 if (l)
    1057           0 :                         BBPunfix(l->batCacheid);
    1058           0 :                 if (r)
    1059           0 :                         BBPunfix(r->batCacheid);
    1060           0 :                 if (g)
    1061           0 :                         BBPunfix(g->batCacheid);
    1062           0 :                 if (e)
    1063           0 :                         BBPunfix(e->batCacheid);
    1064           0 :                 if (s)
    1065           0 :                         BBPunfix(s->batCacheid);
    1066           0 :                 throw(MAL, "sql.all <>", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    1067             :         }
    1068           0 :         if (l->ttype != r->ttype) {
    1069           0 :                 BBPunfix(l->batCacheid);
    1070           0 :                 BBPunfix(r->batCacheid);
    1071           0 :                 BBPunfix(g->batCacheid);
    1072           0 :                 BBPunfix(e->batCacheid);
    1073           0 :                 if (s)
    1074           0 :                         BBPunfix(s->batCacheid);
    1075           0 :                 throw(MAL, "sql.all <>", SQLSTATE(42000) "sql.all <> requires both arguments of the same type");
    1076             :         }
    1077             : 
    1078           0 :         res = BATallnotequal_grp(l, r, g, e, s);
    1079             : 
    1080           0 :         BBPunfix(l->batCacheid);
    1081           0 :         BBPunfix(r->batCacheid);
    1082           0 :         BBPunfix(g->batCacheid);
    1083           0 :         BBPunfix(e->batCacheid);
    1084           0 :         if (s)
    1085           0 :                 BBPunfix(s->batCacheid);
    1086           0 :         if (res == NULL)
    1087           0 :                 throw(MAL, "sql.all <>", GDK_EXCEPTION);
    1088           0 :         *ret = res->batCacheid;
    1089           0 :         BBPkeepref(res->batCacheid);
    1090           0 :         return MAL_SUCCEED;
    1091             : }
    1092             : 
    1093             : str
    1094          36 : SQLallnotequal_grp2(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1095             : {
    1096          36 :         bat *ret = getArgReference_bat(stk, pci, 0);
    1097          36 :         bat *lp = getArgReference_bat(stk, pci, 1);
    1098          36 :         bat *rp = getArgReference_bat(stk, pci, 2);
    1099          36 :         bat *ip = getArgReference_bat(stk, pci, 3);
    1100          36 :         bat *gp = getArgReference_bat(stk, pci, 4);
    1101          36 :         bat *gpe = getArgReference_bat(stk, pci, 5);
    1102          36 :         bat *sp = pci->argc == 8 ? getArgReference_bat(stk, pci, 6) : NULL;
    1103             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 8 ? 7 : 6); no_nil argument is ignored
    1104             :         BAT *l = NULL, *r = NULL, *rid = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
    1105             : 
    1106             :         (void)cntxt;
    1107             :         (void)mb;
    1108             : 
    1109          36 :         l = BATdescriptor(*lp);
    1110          36 :         r = BATdescriptor(*rp);
    1111          36 :         rid = BATdescriptor(*ip);
    1112          36 :         g = BATdescriptor(*gp);
    1113          36 :         e = BATdescriptor(*gpe);
    1114          36 :         if (sp)
    1115           0 :                 s = BATdescriptor(*sp);
    1116             : 
    1117          36 :         if (!l || !r || !rid || !g || !e || (sp && !s)) {
    1118           0 :                 if (l)
    1119           0 :                         BBPunfix(l->batCacheid);
    1120           0 :                 if (r)
    1121           0 :                         BBPunfix(r->batCacheid);
    1122           0 :                 if (rid)
    1123           0 :                         BBPunfix(rid->batCacheid);
    1124           0 :                 if (g)
    1125           0 :                         BBPunfix(g->batCacheid);
    1126           0 :                 if (e)
    1127           0 :                         BBPunfix(e->batCacheid);
    1128           0 :                 if (s)
    1129           0 :                         BBPunfix(s->batCacheid);
    1130           0 :                 throw(MAL, "sql.all <>", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    1131             :         }
    1132          36 :         if (l->ttype != r->ttype) {
    1133           0 :                 BBPunfix(l->batCacheid);
    1134           0 :                 BBPunfix(r->batCacheid);
    1135           0 :                 BBPunfix(rid->batCacheid);
    1136           0 :                 BBPunfix(g->batCacheid);
    1137           0 :                 BBPunfix(e->batCacheid);
    1138           0 :                 if (s)
    1139           0 :                         BBPunfix(s->batCacheid);
    1140           0 :                 throw(MAL, "sql.all <>", SQLSTATE(42000) "sql.all <> requires both arguments of the same type");
    1141             :         }
    1142             : 
    1143          36 :         res = BATallnotequal_grp2(l, r, rid, g, e, s);
    1144             : 
    1145          36 :         BBPunfix(l->batCacheid);
    1146          36 :         BBPunfix(r->batCacheid);
    1147          36 :         BBPunfix(rid->batCacheid);
    1148          36 :         BBPunfix(g->batCacheid);
    1149          36 :         BBPunfix(e->batCacheid);
    1150          36 :         if (s)
    1151           0 :                 BBPunfix(s->batCacheid);
    1152          36 :         if (res == NULL)
    1153           0 :                 throw(MAL, "sql.all <>", GDK_EXCEPTION);
    1154          36 :         *ret = res->batCacheid;
    1155          36 :         BBPkeepref(res->batCacheid);
    1156          36 :         return MAL_SUCCEED;
    1157             : }
    1158             : 
    1159             : str
    1160          45 : SQLexist(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1161             : {
    1162             :         BAT *b = NULL, *r = NULL;
    1163          45 :         bit count = TRUE;
    1164             : 
    1165             :         (void)cntxt;
    1166          45 :         if (isaBatType(getArgType(mb, pci, 1))) {
    1167          45 :                 bat *bid = getArgReference_bat(stk, pci, 1);
    1168          45 :                 if (!(b = BBPquickdesc(*bid)))
    1169           0 :                         throw(SQL, "aggr.exist", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    1170          45 :                 count = BATcount(b) != 0;
    1171             :         }
    1172          45 :         if (isaBatType(getArgType(mb, pci, 0))) {
    1173           0 :                 bat *res = getArgReference_bat(stk, pci, 0);
    1174           0 :                 if (!(r = BATconstant(b ? b->hseqbase : 0, TYPE_bit, &count, b ? BATcount(b) : 1, TRANSIENT)))
    1175           0 :                         throw(SQL, "aggr.exist", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    1176           0 :                 BBPkeepref(*res = r->batCacheid);
    1177             :         } else {
    1178          45 :                 bit *res = getArgReference_bit(stk, pci, 0);
    1179          45 :                 *res = count;
    1180             :         }
    1181             : 
    1182             :         return MAL_SUCCEED;
    1183             : }
    1184             : 
    1185             : str
    1186          62 : SQLsubexist(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1187             : {
    1188          62 :         bat *ret = getArgReference_bat(stk, pci, 0);
    1189          62 :         bat *bp = getArgReference_bat(stk, pci, 1);
    1190          62 :         bat *gp = getArgReference_bat(stk, pci, 2);
    1191          62 :         bat *gpe = getArgReference_bat(stk, pci, 3);
    1192          62 :         bat *sp = pci->argc == 6 ? getArgReference_bat(stk, pci, 4) : NULL;
    1193             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 6 ? 5 : 4); no_nil argument is ignored
    1194             :         BAT *b = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
    1195             : 
    1196             :         (void)cntxt;
    1197             :         (void)mb;
    1198          62 :         b = BATdescriptor(*bp);
    1199          62 :         g = BATdescriptor(*gp);
    1200          62 :         e = BATdescriptor(*gpe);
    1201          62 :         if (sp)
    1202           0 :                 s = BATdescriptor(*sp);
    1203             : 
    1204          62 :         if (!b || !g || !e || (sp && !s)) {
    1205           0 :                 if (b)
    1206           0 :                         BBPunfix(b->batCacheid);
    1207           0 :                 if (g)
    1208           0 :                         BBPunfix(g->batCacheid);
    1209           0 :                 if (e)
    1210           0 :                         BBPunfix(e->batCacheid);
    1211           0 :                 if (s)
    1212           0 :                         BBPunfix(s->batCacheid);
    1213           0 :                 throw(MAL, "sql.subexist", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    1214             :         }
    1215             : 
    1216          62 :         res = BATsubexist(b, g, e, s);
    1217             : 
    1218          62 :         BBPunfix(b->batCacheid);
    1219          62 :         BBPunfix(g->batCacheid);
    1220          62 :         BBPunfix(e->batCacheid);
    1221          62 :         if (s)
    1222           0 :                 BBPunfix(s->batCacheid);
    1223          62 :         if (res == NULL)
    1224           0 :                 throw(MAL, "sql.subexist", GDK_EXCEPTION);
    1225          62 :         *ret = res->batCacheid;
    1226          62 :         BBPkeepref(res->batCacheid);
    1227          62 :         return MAL_SUCCEED;
    1228             : }
    1229             : 
    1230             : str
    1231           4 : SQLnot_exist(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1232             : {
    1233             :         BAT *b = NULL, *r = NULL;
    1234           4 :         bit count = FALSE;
    1235             : 
    1236             :         (void)cntxt;
    1237           4 :         if (isaBatType(getArgType(mb, pci, 1))) {
    1238           4 :                 bat *bid = getArgReference_bat(stk, pci, 1);
    1239           4 :                 if (!(b = BBPquickdesc(*bid)))
    1240           0 :                         throw(SQL, "aggr.not_exist", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    1241           4 :                 count = BATcount(b) == 0;
    1242             :         }
    1243           4 :         if (isaBatType(getArgType(mb, pci, 0))) {
    1244           0 :                 bat *res = getArgReference_bat(stk, pci, 0);
    1245           0 :                 if (!(r = BATconstant(b ? b->hseqbase : 0, TYPE_bit, &count, b ? BATcount(b) : 1, TRANSIENT)))
    1246           0 :                         throw(SQL, "aggr.not_exist", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    1247           0 :                 BBPkeepref(*res = r->batCacheid);
    1248             :         } else {
    1249           4 :                 bit *res = getArgReference_bit(stk, pci, 0);
    1250           4 :                 *res = count;
    1251             :         }
    1252             : 
    1253             :         return MAL_SUCCEED;
    1254             : }
    1255             : 
    1256             : str
    1257          17 : SQLsubnot_exist(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1258             : {
    1259          17 :         bat *ret = getArgReference_bat(stk, pci, 0);
    1260          17 :         bat *bp = getArgReference_bat(stk, pci, 1);
    1261          17 :         bat *gp = getArgReference_bat(stk, pci, 2);
    1262          17 :         bat *gpe = getArgReference_bat(stk, pci, 3);
    1263          17 :         bat *sp = pci->argc == 6 ? getArgReference_bat(stk, pci, 4) : NULL;
    1264             :         //bit *no_nil = getArgReference_bit(stk, pci, pci->argc == 6 ? 5 : 4); no_nil argument is ignored
    1265             :         BAT *b = NULL, *g = NULL, *e = NULL, *s = NULL, *res = NULL;
    1266             : 
    1267             :         (void)cntxt;
    1268             :         (void)mb;
    1269          17 :         b = BATdescriptor(*bp);
    1270          17 :         g = BATdescriptor(*gp);
    1271          17 :         e = BATdescriptor(*gpe);
    1272          17 :         if (sp)
    1273           0 :                 s = BATdescriptor(*sp);
    1274             : 
    1275          17 :         if (!b || !g || !e || (sp && !s)) {
    1276           0 :                 if (b)
    1277           0 :                         BBPunfix(b->batCacheid);
    1278           0 :                 if (g)
    1279           0 :                         BBPunfix(g->batCacheid);
    1280           0 :                 if (e)
    1281           0 :                         BBPunfix(e->batCacheid);
    1282           0 :                 if (s)
    1283           0 :                         BBPunfix(s->batCacheid);
    1284           0 :                 throw(MAL, "sql.subnot_exist", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    1285             :         }
    1286             : 
    1287          17 :         res = BATsubnot_exist(b, g, e, s);
    1288             : 
    1289          17 :         BBPunfix(b->batCacheid);
    1290          17 :         BBPunfix(g->batCacheid);
    1291          17 :         BBPunfix(e->batCacheid);
    1292          17 :         if (s)
    1293           0 :                 BBPunfix(s->batCacheid);
    1294          17 :         if (res == NULL)
    1295           0 :                 throw(MAL, "sql.subnot_exist", GDK_EXCEPTION);
    1296          17 :         *ret = res->batCacheid;
    1297          17 :         BBPkeepref(res->batCacheid);
    1298          17 :         return MAL_SUCCEED;
    1299             : }

Generated by: LCOV version 1.14