LCOV - code coverage report
Current view: top level - gdk - gdk_calc_compare.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 207 521 39.7 %
Date: 2021-10-13 02:24:04 Functions: 37 42 88.1 %

          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             : /* this file is included multiple times by gdk_calc.c */
      10             : 
      11             : static BUN
      12      627769 : op_typeswitchloop(const void *lft, int tp1, bool incr1, const char *hp1, int wd1,
      13             :                   const void *rgt, int tp2, bool incr2, const char *hp2, int wd2,
      14             :                   TPE *restrict dst,
      15             :                   struct canditer *restrict ci1, struct canditer *restrict ci2,
      16             :                   oid candoff1, oid candoff2,
      17             :                   bool nonil,
      18             : #ifdef NIL_MATCHES_FLAG
      19             :                   bool nil_matches,
      20             : #endif
      21             :                   const char *func)
      22             : {
      23             :         BUN nils = 0;
      24      627769 :         BUN i = 0, j = 0, k, ncand = ci1->ncand;
      25             :         const void *restrict nil;
      26             :         int (*atomcmp)(const void *, const void *);
      27             : 
      28             :         lng timeoffset = 0;
      29      627769 :         QryCtx *qry_ctx = MT_thread_get_qry_ctx();
      30      627770 :         if (qry_ctx != NULL) {
      31      627770 :                 timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0;
      32             :         }
      33             : 
      34      627770 :         switch (tp1) {
      35           8 :         case TYPE_void: {
      36           8 :                 assert(incr1);
      37           8 :                 assert(tp2 == TYPE_oid || incr2); /* if void, incr2==1 */
      38           8 :                 oid v = lft ? * (const oid *) lft : oid_nil;
      39          51 :                 TIMEOUT_LOOP_IDX(k, ncand, timeoffset) {
      40             :                         TPE res;
      41          27 :                         i = canditer_next(ci1) - candoff1;
      42          27 :                         if (incr2)
      43          27 :                                 j = canditer_next(ci2) - candoff2;
      44          27 :                         if (is_oid_nil(v) || tp2 == TYPE_void) {
      45           0 :                                 res = is_oid_nil(v) || is_oid_nil(* (const oid *) rgt) ?
      46             : #ifdef NIL_MATCHES_FLAG
      47           0 :                                         nil_matches ? OP(is_oid_nil(v), is_oid_nil(* (const oid *) rgt)) :
      48             : #endif
      49             :                                         TPE_nil :
      50           0 :                                         OP(v, * (const oid *) rgt);
      51           0 :                                 dst[k] = res;
      52           0 :                                 nils += is_TPE_nil(res);
      53             :                         } else {
      54          27 :                                 if (is_oid_nil(((const oid *) rgt)[j])) {
      55             : #ifdef NIL_MATCHES_FLAG
      56           0 :                                         if (nil_matches) {
      57           0 :                                                 dst[k] = OP(false, true);
      58             :                                         } else
      59             : #endif
      60             :                                         {
      61           0 :                                                 nils++;
      62           0 :                                                 dst[k] = TPE_nil;
      63             :                                         }
      64             :                                 } else {
      65          27 :                                         dst[k] = OP(v + i, ((const oid *) rgt)[j]);
      66             :                                 }
      67             :                         }
      68             :                 }
      69           8 :                 TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE));
      70             :                 break;
      71             :         }
      72           0 :         case TYPE_bit:
      73           0 :                 if (tp2 != TYPE_bit)
      74           0 :                         goto unsupported;
      75           0 :                 if (nonil)
      76           0 :                         BINARY_3TYPE_FUNC_nonil(bit, bit, TPE, OP);
      77             : #ifdef NIL_MATCHES_FLAG
      78           0 :                 else if (nil_matches)
      79           0 :                         BINARY_3TYPE_FUNC_nilmatch(bit, bit, TPE, OP);
      80             : #endif
      81             :                 else
      82           0 :                         BINARY_3TYPE_FUNC(bit, bit, TPE, OP);
      83             :                 break;
      84        1001 :         case TYPE_bte:
      85             :                 switch (tp2) {
      86             :                 case TYPE_bte:
      87        1001 :                 btebte:
      88        1001 :                         if (nonil)
      89        7425 :                                 BINARY_3TYPE_FUNC_nonil(bte, bte, TPE, OP);
      90             : #ifdef NIL_MATCHES_FLAG
      91         880 :                         else if (nil_matches)
      92         234 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, bte, TPE, OP);
      93             : #endif
      94             :                         else
      95      441229 :                                 BINARY_3TYPE_FUNC(bte, bte, TPE, OP);
      96             :                         break;
      97           0 :                 case TYPE_sht:
      98           0 :                         if (nonil)
      99           0 :                                 BINARY_3TYPE_FUNC_nonil(bte, sht, TPE, OP);
     100             : #ifdef NIL_MATCHES_FLAG
     101           0 :                         else if (nil_matches)
     102           0 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, sht, TPE, OP);
     103             : #endif
     104             :                         else
     105           0 :                                 BINARY_3TYPE_FUNC(bte, sht, TPE, OP);
     106             :                         break;
     107           0 :                 case TYPE_int:
     108           0 :                         if (nonil)
     109           0 :                                 BINARY_3TYPE_FUNC_nonil(bte, int, TPE, OP);
     110             : #ifdef NIL_MATCHES_FLAG
     111           0 :                         else if (nil_matches)
     112           0 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, int, TPE, OP);
     113             : #endif
     114             :                         else
     115           0 :                                 BINARY_3TYPE_FUNC(bte, int, TPE, OP);
     116             :                         break;
     117           0 :                 case TYPE_lng:
     118           0 :                         if (nonil)
     119           0 :                                 BINARY_3TYPE_FUNC_nonil(bte, lng, TPE, OP);
     120             : #ifdef NIL_MATCHES_FLAG
     121           0 :                         else if (nil_matches)
     122           0 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, lng, TPE, OP);
     123             : #endif
     124             :                         else
     125           0 :                                 BINARY_3TYPE_FUNC(bte, lng, TPE, OP);
     126             :                         break;
     127             : #ifdef HAVE_HGE
     128           0 :                 case TYPE_hge:
     129           0 :                         if (nonil)
     130           0 :                                 BINARY_3TYPE_FUNC_nonil(bte, hge, TPE, OP);
     131             : #ifdef NIL_MATCHES_FLAG
     132           0 :                         else if (nil_matches)
     133           0 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, hge, TPE, OP);
     134             : #endif
     135             :                         else
     136           0 :                                 BINARY_3TYPE_FUNC(bte, hge, TPE, OP);
     137             :                         break;
     138             : #endif
     139           0 :                 case TYPE_flt:
     140           0 :                         if (nonil)
     141           0 :                                 BINARY_3TYPE_FUNC_nonil(bte, flt, TPE, OP);
     142             : #ifdef NIL_MATCHES_FLAG
     143           0 :                         else if (nil_matches)
     144           0 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, flt, TPE, OP);
     145             : #endif
     146             :                         else
     147           0 :                                 BINARY_3TYPE_FUNC(bte, flt, TPE, OP);
     148             :                         break;
     149           0 :                 case TYPE_dbl:
     150           0 :                         if (nonil)
     151           0 :                                 BINARY_3TYPE_FUNC_nonil(bte, dbl, TPE, OP);
     152             : #ifdef NIL_MATCHES_FLAG
     153           0 :                         else if (nil_matches)
     154           0 :                                 BINARY_3TYPE_FUNC_nilmatch(bte, dbl, TPE, OP);
     155             : #endif
     156             :                         else
     157           0 :                                 BINARY_3TYPE_FUNC(bte, dbl, TPE, OP);
     158             :                         break;
     159           0 :                 default:
     160           0 :                         goto unsupported;
     161             :                 }
     162             :                 break;
     163        1333 :         case TYPE_sht:
     164             :                 switch (tp2) {
     165           0 :                 case TYPE_bte:
     166           0 :                         if (nonil)
     167           0 :                                 BINARY_3TYPE_FUNC_nonil(sht, bte, TPE, OP);
     168             : #ifdef NIL_MATCHES_FLAG
     169           0 :                         else if (nil_matches)
     170           0 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, bte, TPE, OP);
     171             : #endif
     172             :                         else
     173           0 :                                 BINARY_3TYPE_FUNC(sht, bte, TPE, OP);
     174             :                         break;
     175             :                 case TYPE_sht:
     176        1333 :                 shtsht:
     177        1333 :                         if (nonil)
     178         611 :                                 BINARY_3TYPE_FUNC_nonil(sht, sht, TPE, OP);
     179             : #ifdef NIL_MATCHES_FLAG
     180         570 :                         else if (nil_matches)
     181          24 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, sht, TPE, OP);
     182             : #endif
     183             :                         else
     184      188966 :                                 BINARY_3TYPE_FUNC(sht, sht, TPE, OP);
     185             :                         break;
     186           0 :                 case TYPE_int:
     187           0 :                         if (nonil)
     188           0 :                                 BINARY_3TYPE_FUNC_nonil(sht, int, TPE, OP);
     189             : #ifdef NIL_MATCHES_FLAG
     190           0 :                         else if (nil_matches)
     191           0 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, int, TPE, OP);
     192             : #endif
     193             :                         else
     194           0 :                                 BINARY_3TYPE_FUNC(sht, int, TPE, OP);
     195             :                         break;
     196           0 :                 case TYPE_lng:
     197           0 :                         if (nonil)
     198           0 :                                 BINARY_3TYPE_FUNC_nonil(sht, lng, TPE, OP);
     199             : #ifdef NIL_MATCHES_FLAG
     200           0 :                         else if (nil_matches)
     201           0 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, lng, TPE, OP);
     202             : #endif
     203             :                         else
     204           0 :                                 BINARY_3TYPE_FUNC(sht, lng, TPE, OP);
     205             :                         break;
     206             : #ifdef HAVE_HGE
     207           0 :                 case TYPE_hge:
     208           0 :                         if (nonil)
     209           0 :                                 BINARY_3TYPE_FUNC_nonil(sht, hge, TPE, OP);
     210             : #ifdef NIL_MATCHES_FLAG
     211           0 :                         else if (nil_matches)
     212           0 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, hge, TPE, OP);
     213             : #endif
     214             :                         else
     215           0 :                                 BINARY_3TYPE_FUNC(sht, hge, TPE, OP);
     216             :                         break;
     217             : #endif
     218           0 :                 case TYPE_flt:
     219           0 :                         if (nonil)
     220           0 :                                 BINARY_3TYPE_FUNC_nonil(sht, flt, TPE, OP);
     221             : #ifdef NIL_MATCHES_FLAG
     222           0 :                         else if (nil_matches)
     223           0 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, flt, TPE, OP);
     224             : #endif
     225             :                         else
     226           0 :                                 BINARY_3TYPE_FUNC(sht, flt, TPE, OP);
     227             :                         break;
     228           0 :                 case TYPE_dbl:
     229           0 :                         if (nonil)
     230           0 :                                 BINARY_3TYPE_FUNC_nonil(sht, dbl, TPE, OP);
     231             : #ifdef NIL_MATCHES_FLAG
     232           0 :                         else if (nil_matches)
     233           0 :                                 BINARY_3TYPE_FUNC_nilmatch(sht, dbl, TPE, OP);
     234             : #endif
     235             :                         else
     236           0 :                                 BINARY_3TYPE_FUNC(sht, dbl, TPE, OP);
     237             :                         break;
     238           0 :                 default:
     239           0 :                         goto unsupported;
     240             :                 }
     241             :                 break;
     242       63556 :         case TYPE_int:
     243             :                 switch (tp2) {
     244           0 :                 case TYPE_bte:
     245           0 :                         if (nonil)
     246           0 :                                 BINARY_3TYPE_FUNC_nonil(int, bte, TPE, OP);
     247             : #ifdef NIL_MATCHES_FLAG
     248           0 :                         else if (nil_matches)
     249           0 :                                 BINARY_3TYPE_FUNC_nilmatch(int, bte, TPE, OP);
     250             : #endif
     251             :                         else
     252           0 :                                 BINARY_3TYPE_FUNC(int, bte, TPE, OP);
     253             :                         break;
     254           0 :                 case TYPE_sht:
     255           0 :                         if (nonil)
     256           0 :                                 BINARY_3TYPE_FUNC_nonil(int, sht, TPE, OP);
     257             : #ifdef NIL_MATCHES_FLAG
     258           0 :                         else if (nil_matches)
     259           0 :                                 BINARY_3TYPE_FUNC_nilmatch(int, sht, TPE, OP);
     260             : #endif
     261             :                         else
     262           0 :                                 BINARY_3TYPE_FUNC(int, sht, TPE, OP);
     263             :                         break;
     264             :                 case TYPE_int:
     265       63556 :                 intint:
     266       63556 :                         if (nonil)
     267    89261322 :                                 BINARY_3TYPE_FUNC_nonil(int, int, TPE, OP);
     268             : #ifdef NIL_MATCHES_FLAG
     269       39209 :                         else if (nil_matches)
     270      123215 :                                 BINARY_3TYPE_FUNC_nilmatch(int, int, TPE, OP);
     271             : #endif
     272             :                         else
     273    35308954 :                                 BINARY_3TYPE_FUNC(int, int, TPE, OP);
     274             :                         break;
     275           0 :                 case TYPE_lng:
     276           0 :                         if (nonil)
     277           0 :                                 BINARY_3TYPE_FUNC_nonil(int, lng, TPE, OP);
     278             : #ifdef NIL_MATCHES_FLAG
     279           0 :                         else if (nil_matches)
     280           0 :                                 BINARY_3TYPE_FUNC_nilmatch(int, lng, TPE, OP);
     281             : #endif
     282             :                         else
     283           0 :                                 BINARY_3TYPE_FUNC(int, lng, TPE, OP);
     284             :                         break;
     285             : #ifdef HAVE_HGE
     286           0 :                 case TYPE_hge:
     287           0 :                         if (nonil)
     288           0 :                                 BINARY_3TYPE_FUNC_nonil(int, hge, TPE, OP);
     289             : #ifdef NIL_MATCHES_FLAG
     290           0 :                         else if (nil_matches)
     291           0 :                                 BINARY_3TYPE_FUNC_nilmatch(int, hge, TPE, OP);
     292             : #endif
     293             :                         else
     294           0 :                                 BINARY_3TYPE_FUNC(int, hge, TPE, OP);
     295             :                         break;
     296             : #endif
     297           0 :                 case TYPE_flt:
     298           0 :                         if (nonil)
     299           0 :                                 BINARY_3TYPE_FUNC_nonil(int, flt, TPE, OP);
     300             : #ifdef NIL_MATCHES_FLAG
     301           0 :                         else if (nil_matches)
     302           0 :                                 BINARY_3TYPE_FUNC_nilmatch(int, flt, TPE, OP);
     303             : #endif
     304             :                         else
     305           0 :                                 BINARY_3TYPE_FUNC(int, flt, TPE, OP);
     306             :                         break;
     307           0 :                 case TYPE_dbl:
     308           0 :                         if (nonil)
     309           0 :                                 BINARY_3TYPE_FUNC_nonil(int, dbl, TPE, OP);
     310             : #ifdef NIL_MATCHES_FLAG
     311           0 :                         else if (nil_matches)
     312           0 :                                 BINARY_3TYPE_FUNC_nilmatch(int, dbl, TPE, OP);
     313             : #endif
     314             :                         else
     315           0 :                                 BINARY_3TYPE_FUNC(int, dbl, TPE, OP);
     316             :                         break;
     317           0 :                 default:
     318           0 :                         goto unsupported;
     319             :                 }
     320             :                 break;
     321       32032 :         case TYPE_lng:
     322             :                 switch (tp2) {
     323           0 :                 case TYPE_bte:
     324           0 :                         if (nonil)
     325           0 :                                 BINARY_3TYPE_FUNC_nonil(lng, bte, TPE, OP);
     326             : #ifdef NIL_MATCHES_FLAG
     327           0 :                         else if (nil_matches)
     328           0 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, bte, TPE, OP);
     329             : #endif
     330             :                         else
     331           0 :                                 BINARY_3TYPE_FUNC(lng, bte, TPE, OP);
     332             :                         break;
     333           0 :                 case TYPE_sht:
     334           0 :                         if (nonil)
     335           0 :                                 BINARY_3TYPE_FUNC_nonil(lng, sht, TPE, OP);
     336             : #ifdef NIL_MATCHES_FLAG
     337           0 :                         else if (nil_matches)
     338           0 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, sht, TPE, OP);
     339             : #endif
     340             :                         else
     341           0 :                                 BINARY_3TYPE_FUNC(lng, sht, TPE, OP);
     342             :                         break;
     343           0 :                 case TYPE_int:
     344           0 :                         if (nonil)
     345           0 :                                 BINARY_3TYPE_FUNC_nonil(lng, int, TPE, OP);
     346             : #ifdef NIL_MATCHES_FLAG
     347           0 :                         else if (nil_matches)
     348           0 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, int, TPE, OP);
     349             : #endif
     350             :                         else
     351           0 :                                 BINARY_3TYPE_FUNC(lng, int, TPE, OP);
     352             :                         break;
     353             :                 case TYPE_lng:
     354       32032 :                 lnglng:
     355       32032 :                         if (nonil)
     356     9185309 :                                 BINARY_3TYPE_FUNC_nonil(lng, lng, TPE, OP);
     357             : #ifdef NIL_MATCHES_FLAG
     358       18021 :                         else if (nil_matches)
     359         109 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, lng, TPE, OP);
     360             : #endif
     361             :                         else
     362     8560615 :                                 BINARY_3TYPE_FUNC(lng, lng, TPE, OP);
     363             :                         break;
     364             : #ifdef HAVE_HGE
     365           0 :                 case TYPE_hge:
     366           0 :                         if (nonil)
     367           0 :                                 BINARY_3TYPE_FUNC_nonil(lng, hge, TPE, OP);
     368             : #ifdef NIL_MATCHES_FLAG
     369           0 :                         else if (nil_matches)
     370           0 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, hge, TPE, OP);
     371             : #endif
     372             :                         else
     373           0 :                                 BINARY_3TYPE_FUNC(lng, hge, TPE, OP);
     374             :                         break;
     375             : #endif
     376           0 :                 case TYPE_flt:
     377           0 :                         if (nonil)
     378           0 :                                 BINARY_3TYPE_FUNC_nonil(lng, flt, TPE, OP);
     379             : #ifdef NIL_MATCHES_FLAG
     380           0 :                         else if (nil_matches)
     381           0 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, flt, TPE, OP);
     382             : #endif
     383             :                         else
     384           0 :                                 BINARY_3TYPE_FUNC(lng, flt, TPE, OP);
     385             :                         break;
     386           0 :                 case TYPE_dbl:
     387           0 :                         if (nonil)
     388           0 :                                 BINARY_3TYPE_FUNC_nonil(lng, dbl, TPE, OP);
     389             : #ifdef NIL_MATCHES_FLAG
     390           0 :                         else if (nil_matches)
     391           0 :                                 BINARY_3TYPE_FUNC_nilmatch(lng, dbl, TPE, OP);
     392             : #endif
     393             :                         else
     394           0 :                                 BINARY_3TYPE_FUNC(lng, dbl, TPE, OP);
     395             :                         break;
     396           0 :                 default:
     397           0 :                         goto unsupported;
     398             :                 }
     399             :                 break;
     400             : #ifdef HAVE_HGE
     401         815 :         case TYPE_hge:
     402             :                 switch (tp2) {
     403           0 :                 case TYPE_bte:
     404           0 :                         if (nonil)
     405           0 :                                 BINARY_3TYPE_FUNC_nonil(hge, bte, TPE, OP);
     406             : #ifdef NIL_MATCHES_FLAG
     407           0 :                         else if (nil_matches)
     408           0 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, bte, TPE, OP);
     409             : #endif
     410             :                         else
     411           0 :                                 BINARY_3TYPE_FUNC(hge, bte, TPE, OP);
     412             :                         break;
     413           0 :                 case TYPE_sht:
     414           0 :                         if (nonil)
     415           0 :                                 BINARY_3TYPE_FUNC_nonil(hge, sht, TPE, OP);
     416             : #ifdef NIL_MATCHES_FLAG
     417           0 :                         else if (nil_matches)
     418           0 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, sht, TPE, OP);
     419             : #endif
     420             :                         else
     421           0 :                                 BINARY_3TYPE_FUNC(hge, sht, TPE, OP);
     422             :                         break;
     423           0 :                 case TYPE_int:
     424           0 :                         if (nonil)
     425           0 :                                 BINARY_3TYPE_FUNC_nonil(hge, int, TPE, OP);
     426             : #ifdef NIL_MATCHES_FLAG
     427           0 :                         else if (nil_matches)
     428           0 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, int, TPE, OP);
     429             : #endif
     430             :                         else
     431           0 :                                 BINARY_3TYPE_FUNC(hge, int, TPE, OP);
     432             :                         break;
     433           0 :                 case TYPE_lng:
     434           0 :                         if (nonil)
     435           0 :                                 BINARY_3TYPE_FUNC_nonil(hge, lng, TPE, OP);
     436             : #ifdef NIL_MATCHES_FLAG
     437           0 :                         else if (nil_matches)
     438           0 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, lng, TPE, OP);
     439             : #endif
     440             :                         else
     441           0 :                                 BINARY_3TYPE_FUNC(hge, lng, TPE, OP);
     442             :                         break;
     443             :                 case TYPE_hge:
     444         815 :                 hgehge:
     445         815 :                         if (nonil)
     446    35583736 :                                 BINARY_3TYPE_FUNC_nonil(hge, hge, TPE, OP);
     447             : #ifdef NIL_MATCHES_FLAG
     448         137 :                         else if (nil_matches)
     449         208 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, hge, TPE, OP);
     450             : #endif
     451             :                         else
     452     3401351 :                                 BINARY_3TYPE_FUNC(hge, hge, TPE, OP);
     453             :                         break;
     454           0 :                 case TYPE_flt:
     455           0 :                         if (nonil)
     456           0 :                                 BINARY_3TYPE_FUNC_nonil(hge, flt, TPE, OP);
     457             : #ifdef NIL_MATCHES_FLAG
     458           0 :                         else if (nil_matches)
     459           0 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, flt, TPE, OP);
     460             : #endif
     461             :                         else
     462           0 :                                 BINARY_3TYPE_FUNC(hge, flt, TPE, OP);
     463             :                         break;
     464           0 :                 case TYPE_dbl:
     465           0 :                         if (nonil)
     466           0 :                                 BINARY_3TYPE_FUNC_nonil(hge, dbl, TPE, OP);
     467             : #ifdef NIL_MATCHES_FLAG
     468           0 :                         else if (nil_matches)
     469           0 :                                 BINARY_3TYPE_FUNC_nilmatch(hge, dbl, TPE, OP);
     470             : #endif
     471             :                         else
     472           0 :                                 BINARY_3TYPE_FUNC(hge, dbl, TPE, OP);
     473             :                         break;
     474           0 :                 default:
     475           0 :                         goto unsupported;
     476             :                 }
     477             :                 break;
     478             : #endif
     479          50 :         case TYPE_flt:
     480             :                 switch (tp2) {
     481           0 :                 case TYPE_bte:
     482           0 :                         if (nonil)
     483           0 :                                 BINARY_3TYPE_FUNC_nonil(flt, bte, TPE, OP);
     484             : #ifdef NIL_MATCHES_FLAG
     485           0 :                         else if (nil_matches)
     486           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, bte, TPE, OP);
     487             : #endif
     488             :                         else
     489           0 :                                 BINARY_3TYPE_FUNC(flt, bte, TPE, OP);
     490             :                         break;
     491           0 :                 case TYPE_sht:
     492           0 :                         if (nonil)
     493           0 :                                 BINARY_3TYPE_FUNC_nonil(flt, sht, TPE, OP);
     494             : #ifdef NIL_MATCHES_FLAG
     495           0 :                         else if (nil_matches)
     496           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, sht, TPE, OP);
     497             : #endif
     498             :                         else
     499           0 :                                 BINARY_3TYPE_FUNC(flt, sht, TPE, OP);
     500             :                         break;
     501           0 :                 case TYPE_int:
     502           0 :                         if (nonil)
     503           0 :                                 BINARY_3TYPE_FUNC_nonil(flt, int, TPE, OP);
     504             : #ifdef NIL_MATCHES_FLAG
     505           0 :                         else if (nil_matches)
     506           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, int, TPE, OP);
     507             : #endif
     508             :                         else
     509           0 :                                 BINARY_3TYPE_FUNC(flt, int, TPE, OP);
     510             :                         break;
     511           0 :                 case TYPE_lng:
     512           0 :                         if (nonil)
     513           0 :                                 BINARY_3TYPE_FUNC_nonil(flt, lng, TPE, OP);
     514             : #ifdef NIL_MATCHES_FLAG
     515           0 :                         else if (nil_matches)
     516           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, lng, TPE, OP);
     517             : #endif
     518             :                         else
     519           0 :                                 BINARY_3TYPE_FUNC(flt, lng, TPE, OP);
     520             :                         break;
     521             : #ifdef HAVE_HGE
     522           0 :                 case TYPE_hge:
     523           0 :                         if (nonil)
     524           0 :                                 BINARY_3TYPE_FUNC_nonil(flt, hge, TPE, OP);
     525             : #ifdef NIL_MATCHES_FLAG
     526           0 :                         else if (nil_matches)
     527           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, hge, TPE, OP);
     528             : #endif
     529             :                         else
     530           0 :                                 BINARY_3TYPE_FUNC(flt, hge, TPE, OP);
     531             :                         break;
     532             : #endif
     533             :                 case TYPE_flt:
     534          50 :                 fltflt:
     535          50 :                         if (nonil)
     536         211 :                                 BINARY_3TYPE_FUNC_nonil(flt, flt, TPE, OP);
     537             : #ifdef NIL_MATCHES_FLAG
     538          45 :                         else if (nil_matches)
     539           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, flt, TPE, OP);
     540             : #endif
     541             :                         else
     542     1614934 :                                 BINARY_3TYPE_FUNC(flt, flt, TPE, OP);
     543             :                         break;
     544           0 :                 case TYPE_dbl:
     545           0 :                         if (nonil)
     546           0 :                                 BINARY_3TYPE_FUNC_nonil(flt, dbl, TPE, OP);
     547             : #ifdef NIL_MATCHES_FLAG
     548           0 :                         else if (nil_matches)
     549           0 :                                 BINARY_3TYPE_FUNC_nilmatch(flt, dbl, TPE, OP);
     550             : #endif
     551             :                         else
     552           0 :                                 BINARY_3TYPE_FUNC(flt, dbl, TPE, OP);
     553             :                         break;
     554           0 :                 default:
     555           0 :                         goto unsupported;
     556             :                 }
     557             :                 break;
     558        1281 :         case TYPE_dbl:
     559             :                 switch (tp2) {
     560           0 :                 case TYPE_bte:
     561           0 :                         if (nonil)
     562           0 :                                 BINARY_3TYPE_FUNC_nonil(dbl, bte, TPE, OP);
     563             : #ifdef NIL_MATCHES_FLAG
     564           0 :                         else if (nil_matches)
     565           0 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, bte, TPE, OP);
     566             : #endif
     567             :                         else
     568           0 :                                 BINARY_3TYPE_FUNC(dbl, bte, TPE, OP);
     569             :                         break;
     570           0 :                 case TYPE_sht:
     571           0 :                         if (nonil)
     572           0 :                                 BINARY_3TYPE_FUNC_nonil(dbl, sht, TPE, OP);
     573             : #ifdef NIL_MATCHES_FLAG
     574           0 :                         else if (nil_matches)
     575           0 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, sht, TPE, OP);
     576             : #endif
     577             :                         else
     578           0 :                                 BINARY_3TYPE_FUNC(dbl, sht, TPE, OP);
     579             :                         break;
     580           0 :                 case TYPE_int:
     581           0 :                         if (nonil)
     582           0 :                                 BINARY_3TYPE_FUNC_nonil(dbl, int, TPE, OP);
     583             : #ifdef NIL_MATCHES_FLAG
     584           0 :                         else if (nil_matches)
     585           0 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, int, TPE, OP);
     586             : #endif
     587             :                         else
     588           0 :                                 BINARY_3TYPE_FUNC(dbl, int, TPE, OP);
     589             :                         break;
     590           0 :                 case TYPE_lng:
     591           0 :                         if (nonil)
     592           0 :                                 BINARY_3TYPE_FUNC_nonil(dbl, lng, TPE, OP);
     593             : #ifdef NIL_MATCHES_FLAG
     594           0 :                         else if (nil_matches)
     595           0 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, lng, TPE, OP);
     596             : #endif
     597             :                         else
     598           0 :                                 BINARY_3TYPE_FUNC(dbl, lng, TPE, OP);
     599             :                         break;
     600             : #ifdef HAVE_HGE
     601           0 :                 case TYPE_hge:
     602           0 :                         if (nonil)
     603           0 :                                 BINARY_3TYPE_FUNC_nonil(dbl, hge, TPE, OP);
     604             : #ifdef NIL_MATCHES_FLAG
     605           0 :                         else if (nil_matches)
     606           0 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, hge, TPE, OP);
     607             : #endif
     608             :                         else
     609           0 :                                 BINARY_3TYPE_FUNC(dbl, hge, TPE, OP);
     610             :                         break;
     611             : #endif
     612           0 :                 case TYPE_flt:
     613           0 :                         if (nonil)
     614           0 :                                 BINARY_3TYPE_FUNC_nonil(dbl, flt, TPE, OP);
     615             : #ifdef NIL_MATCHES_FLAG
     616           0 :                         else if (nil_matches)
     617           0 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, flt, TPE, OP);
     618             : #endif
     619             :                         else
     620           0 :                                 BINARY_3TYPE_FUNC(dbl, flt, TPE, OP);
     621             :                         break;
     622             :                 case TYPE_dbl:
     623        1281 :                 dbldbl:
     624        1281 :                         if (nonil)
     625     7153962 :                                 BINARY_3TYPE_FUNC_nonil(dbl, dbl, TPE, OP);
     626             : #ifdef NIL_MATCHES_FLAG
     627         133 :                         else if (nil_matches)
     628          42 :                                 BINARY_3TYPE_FUNC_nilmatch(dbl, dbl, TPE, OP);
     629             : #endif
     630             :                         else
     631     1723137 :                                 BINARY_3TYPE_FUNC(dbl, dbl, TPE, OP);
     632             :                         break;
     633           0 :                 default:
     634           0 :                         goto unsupported;
     635             :                 }
     636             :                 break;
     637          11 :         case TYPE_oid:
     638          11 :                 if (tp2 == TYPE_void) {
     639           1 :                         oid v = * (const oid *) rgt;
     640           7 :                         TIMEOUT_LOOP_IDX(k, ncand, timeoffset) {
     641           4 :                                 if (incr1)
     642           4 :                                         i = canditer_next(ci1) - candoff1;
     643           4 :                                 j = canditer_next(ci2) - candoff2;
     644           4 :                                 if (is_oid_nil(v)) {
     645             : #ifdef NIL_MATCHES_FLAG
     646           0 :                                         if (nil_matches) {
     647           0 :                                                 dst[k] = OP(is_oid_nil(((const oid *) lft)[i]), true);
     648             :                                         } else
     649             : #endif
     650             :                                         {
     651           0 :                                                 dst[k] = TPE_nil;
     652           0 :                                                 nils++;
     653             :                                         }
     654             :                                 } else {
     655           4 :                                         if (is_oid_nil(((const oid *) lft)[i])) {
     656             : #ifdef NIL_MATCHES_FLAG
     657           0 :                                                 if (nil_matches) {
     658           0 :                                                         dst[k] = OP(true, false);
     659             :                                                 } else
     660             : #endif
     661             :                                                 {
     662           0 :                                                         nils++;
     663           0 :                                                         dst[k] = TPE_nil;
     664             :                                                 }
     665             :                                         } else {
     666           4 :                                                 dst[k] = OP(((const oid *) lft)[i], v + j);
     667             :                                         }
     668             :                                 }
     669             :                         }
     670           1 :                         TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE));
     671          10 :                 } else if (tp2 == TYPE_oid) {
     672          10 :                         if (nonil)
     673         174 :                                 BINARY_3TYPE_FUNC_nonil(oid, oid, TPE, OP);
     674             : #ifdef NIL_MATCHES_FLAG
     675           0 :                         else if (nil_matches)
     676           0 :                                 BINARY_3TYPE_FUNC_nilmatch(oid, oid, TPE, OP);
     677             : #endif
     678             :                         else
     679           0 :                                 BINARY_3TYPE_FUNC(oid, oid, TPE, OP);
     680             :                 } else {
     681           0 :                         goto unsupported;
     682             :                 }
     683             :                 break;
     684      527652 :         case TYPE_str:
     685      527652 :                 if (tp1 != tp2)
     686           0 :                         goto unsupported;
     687    30217939 :                 TIMEOUT_LOOP_IDX(k, ncand, timeoffset) {
     688    28632278 :                         if (incr1)
     689    27959294 :                                 i = canditer_next(ci1) - candoff1;
     690    28629805 :                         if (incr2)
     691     7560337 :                                 j = canditer_next(ci2) - candoff2;
     692             :                         const char *s1, *s2;
     693    28632277 :                         s1 = hp1 ? hp1 + VarHeapVal(lft, i, wd1) : (const char *) lft;
     694    28632277 :                         s2 = hp2 ? hp2 + VarHeapVal(rgt, j, wd2) : (const char *) rgt;
     695    57204216 :                         if (strNil(s1) || strNil(s2)) {
     696             : #ifdef NIL_MATCHES_FLAG
     697      185129 :                                 if (nil_matches) {
     698        1262 :                                         dst[k] = OP(strNil(s1), strNil(s2));
     699             :                                 } else
     700             : #endif
     701             :                                 {
     702      183940 :                                         nils++;
     703      183940 :                                         dst[k] = TPE_nil;
     704             :                                 }
     705             :                         } else {
     706    28447075 :                                 int x = strcmp(s1, s2);
     707    28447075 :                                 dst[k] = OP(x, 0);
     708             :                         }
     709             :                 }
     710      527651 :                 TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE));
     711             :                 break;
     712          31 :         default:
     713          31 :                 if (tp1 != tp2 ||
     714          31 :                     !ATOMlinear(tp1) ||
     715          31 :                     (atomcmp = ATOMcompare(tp1)) == NULL)
     716           0 :                         goto unsupported;
     717             :                 /* a bit of a hack: for inherited types, use
     718             :                  * type-expanded version if comparison function is
     719             :                  * equal to the inherited-from comparison function,
     720             :                  * and yes, we jump right into the middle of a switch,
     721             :                  * but that is legal (although not encouraged) C */
     722          31 :                 if (atomcmp == ATOMcompare(TYPE_bte))
     723           0 :                         goto btebte;
     724          31 :                 if (atomcmp == ATOMcompare(TYPE_sht))
     725           0 :                         goto shtsht;
     726          31 :                 if (atomcmp == ATOMcompare(TYPE_int))
     727           0 :                         goto intint;
     728          31 :                 if (atomcmp == ATOMcompare(TYPE_lng))
     729           0 :                         goto lnglng;
     730             : #ifdef HAVE_HGE
     731          31 :                 if (atomcmp == ATOMcompare(TYPE_hge))
     732           0 :                         goto hgehge;
     733             : #endif
     734          31 :                 if (atomcmp == ATOMcompare(TYPE_flt))
     735           0 :                         goto fltflt;
     736          31 :                 if (atomcmp == ATOMcompare(TYPE_dbl))
     737           0 :                         goto dbldbl;
     738          31 :                 nil = ATOMnilptr(tp1);
     739         208 :                 TIMEOUT_LOOP_IDX(k, ncand, timeoffset) {
     740         115 :                         if (incr1)
     741         105 :                                 i = canditer_next(ci1) - candoff1;
     742         115 :                         if (incr2)
     743         105 :                                 j = canditer_next(ci2) - candoff2;
     744             :                         const void *p1, *p2;
     745             :                         p1 = hp1
     746          40 :                                 ? (const void *) (hp1 + VarHeapVal(lft, i, wd1))
     747         115 :                                 : (const void *) ((const char *) lft + i * wd1);
     748             :                         p2 = hp2
     749          40 :                                 ? (const void *) (hp2 + VarHeapVal(rgt, j, wd2))
     750         115 :                                 : (const void *) ((const char *) rgt + j * wd2);
     751         230 :                         if (p1 == NULL || p2 == NULL ||
     752         226 :                             (*atomcmp)(p1, nil) == 0 ||
     753         111 :                             (*atomcmp)(p2, nil) == 0) {
     754             : #ifdef NIL_MATCHES_FLAG
     755          49 :                                 if (nil_matches) {
     756           2 :                                         dst[k] = OP(p1 == NULL || (*atomcmp)(p1, nil) == 0,
     757             :                                                     p2 == NULL || (*atomcmp)(p2, nil) == 0);
     758             :                                 } else
     759             : #endif
     760             :                                 {
     761          49 :                                         nils++;
     762          49 :                                         dst[k] = TPE_nil;
     763             :                                 }
     764             :                         } else {
     765          65 :                                 int x = (*atomcmp)(p1, p2);
     766          65 :                                 dst[k] = OP(x, 0);
     767             :                         }
     768             :                 }
     769          31 :                 TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE));
     770             :                 break;
     771             :         }
     772             : 
     773             :         return nils;
     774             : 
     775           0 :   unsupported:
     776           0 :         GDKerror("%s: bad input types %s,%s.\n", func,
     777             :                  ATOMname(tp1), ATOMname(tp2));
     778           0 :         return BUN_NONE;
     779             : }
     780             : 
     781             : static BAT *
     782       51210 : BATcalcop_intern(const void *lft, int tp1, bool incr1, const char *hp1, int wd1,
     783             :                  const void *rgt, int tp2, bool incr2, const char *hp2, int wd2,
     784             :                  struct canditer *restrict ci1, struct canditer *restrict ci2,
     785             :                  oid candoff1, oid candoff2, bool nonil, oid seqbase,
     786             : #ifdef NIL_MATCHES_FLAG
     787             :                  bool nil_matches,
     788             : #endif
     789             :                  const char *func)
     790             : {
     791             :         BAT *bn;
     792       51210 :         BUN nils = 0, ncand = ci1->ncand;
     793             :         TPE *restrict dst;
     794             : 
     795       51210 :         bn = COLnew(seqbase, TYPE_TPE, ncand, TRANSIENT);
     796       51210 :         if (bn == NULL)
     797             :                 return NULL;
     798             : 
     799       51210 :         dst = (TPE *) Tloc(bn, 0);
     800             : 
     801       51210 :         nils = op_typeswitchloop(lft, tp1, incr1, hp1, wd1,
     802             :                                  rgt, tp2, incr2, hp2, wd2,
     803             :                                  dst, ci1, ci2, candoff1, candoff2,
     804             :                                  nonil,
     805             : #ifdef NIL_MATCHES_FLAG
     806             :                                  nil_matches,
     807             : #endif
     808             :                                  func);
     809             : 
     810       51206 :         if (nils == BUN_NONE) {
     811           0 :                 BBPunfix(bn->batCacheid);
     812           0 :                 return NULL;
     813             :         }
     814             : 
     815       51206 :         BATsetcount(bn, ncand);
     816             : 
     817       51207 :         bn->tsorted = ncand <= 1 || nils == ncand;
     818       51207 :         bn->trevsorted = ncand <= 1 || nils == ncand;
     819       51207 :         bn->tkey = ncand <= 1;
     820       51207 :         bn->tnil = nils != 0;
     821       51207 :         bn->tnonil = nils == 0;
     822             : 
     823       51207 :         return bn;
     824             : }
     825             : 
     826             : BAT *
     827       75444 : BATcalcop(BAT *b1, BAT *b2, BAT *s1, BAT *s2
     828             : #ifdef NIL_MATCHES_FLAG
     829             :           , bool nil_matches
     830             : #endif
     831             :         )
     832             : {
     833             :         struct canditer ci1, ci2;
     834             :         BUN ncand;
     835             : 
     836       75444 :         BATcheck(b1, NULL);
     837       75444 :         BATcheck(b2, NULL);
     838             : 
     839       75444 :         ncand = canditer_init(&ci1, b1, s1);
     840       75445 :         if (canditer_init(&ci2, b2, s2) != ncand ||
     841       75440 :             ci1.hseq != ci2.hseq) {
     842           0 :                 GDKerror("inputs not the same size.\n");
     843           0 :                 return NULL;
     844             :         }
     845       75440 :         if (ncand == 0)
     846       27470 :                 return COLnew(ci1.hseq, TYPE_TPE, 0, TRANSIENT);
     847             : 
     848       47970 :         if (BATtvoid(b1) && BATtvoid(b2) && ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
     849             :                 TPE res;
     850             : 
     851          10 :                 if ((is_oid_nil(b1->tseqbase) || is_oid_nil(b2->tseqbase))
     852             : #ifdef NIL_MATCHES_FLAG
     853           2 :                         && !nil_matches
     854             : #endif
     855             :                    )
     856           0 :                         res = TPE_nil;
     857             :                 else
     858          10 :                         res = OP(b1->tseqbase + ci1.seq, b2->tseqbase + ci2.seq);
     859             : 
     860          10 :                 return BATconstant(b1->hseqbase, TYPE_TPE, &res, ncand, TRANSIENT);
     861             :         }
     862             : 
     863       47960 :         BATiter b1i = bat_iterator(b1);
     864       47962 :         BATiter b2i = bat_iterator(b2);
     865       97953 :         BAT *bn = BATcalcop_intern(b1i.type == TYPE_void ? (const void *) &b1->tseqbase : (const void *) b1i.base,
     866       47961 :                                 ATOMtype(b1i.type) == TYPE_oid ? b1i.type : ATOMbasetype(b1i.type),
     867             :                                 true,
     868       47961 :                                 b1->tvheap ? b1->tvheap->base : NULL,
     869       47961 :                                 b1i.width,
     870             :                                 b2i.type == TYPE_void ? (const void *) &b2->tseqbase : (const void *) b2i.base,
     871       47961 :                                 ATOMtype(b2i.type) == TYPE_oid ? b2i.type : ATOMbasetype(b2i.type),
     872             :                                 true,
     873       47961 :                                 b2->tvheap ? b2->tvheap->base : NULL,
     874       47961 :                                 b2i.width,
     875             :                                 &ci1, &ci2,
     876             :                                 b1->hseqbase, b2->hseqbase,
     877       47961 :                                 b1->tnonil && b2->tnonil,
     878             :                                 ci1.hseq,
     879             : #ifdef NIL_MATCHES_FLAG
     880             :                                 nil_matches,
     881             : #endif
     882             :                                 __func__);
     883       47960 :         bat_iterator_end(&b1i);
     884       47962 :         bat_iterator_end(&b2i);
     885       47962 :         return bn;
     886             : }
     887             : 
     888             : BAT *
     889       12547 : BATcalcopcst(BAT *b, const ValRecord *v, BAT *s
     890             : #ifdef NIL_MATCHES_FLAG
     891             :           , bool nil_matches
     892             : #endif
     893             :         )
     894             : {
     895             :         struct canditer ci;
     896             :         BUN ncand;
     897             : 
     898       12547 :         BATcheck(b, NULL);
     899             : 
     900       12547 :         ncand = canditer_init(&ci, b, s);
     901       12545 :         if (ncand == 0)
     902        9452 :                 return COLnew(ci.hseq, TYPE_TPE, 0, TRANSIENT);
     903             : 
     904        3093 :         BATiter bi = bat_iterator(b);
     905        3834 :         BAT *bn = BATcalcop_intern(bi.type == TYPE_void ? (const void *) &b->tseqbase : (const void *) bi.base,
     906        3094 :                                 ATOMtype(bi.type) == TYPE_oid ? bi.type : ATOMbasetype(bi.type),
     907             :                                 true,
     908        3094 :                                 bi.vh ? bi.vh->base : NULL,
     909        3094 :                                 bi.width,
     910             :                                 VALptr(v),
     911        3092 :                                 ATOMtype(v->vtype) == TYPE_oid ? v->vtype : ATOMbasetype(v->vtype),
     912             :                                 false,
     913             :                                 NULL,
     914             :                                 0,
     915             :                                 &ci,
     916        3094 :                                 &(struct canditer){.tpe=cand_dense, .ncand=ncand},
     917             :                                 b->hseqbase, 0,
     918        3094 :                                 b->tnonil && ATOMcmp(v->vtype, VALptr(v), ATOMnilptr(v->vtype)) != 0,
     919             :                                 ci.hseq,
     920             : #ifdef NIL_MATCHES_FLAG
     921             :                                 nil_matches,
     922             : #endif
     923             :                                 __func__);
     924        3093 :         bat_iterator_end(&bi);
     925        3094 :         return bn;
     926             : }
     927             : 
     928             : BAT *
     929         163 : BATcalccstop(const ValRecord *v, BAT *b, BAT *s
     930             : #ifdef NIL_MATCHES_FLAG
     931             :           , bool nil_matches
     932             : #endif
     933             :         )
     934             : {
     935             :         struct canditer ci;
     936             :         BUN ncand;
     937             : 
     938         163 :         BATcheck(b, NULL);
     939             : 
     940         163 :         ncand = canditer_init(&ci, b, s);
     941         163 :         if (ncand == 0)
     942           9 :                 return COLnew(ci.hseq, TYPE_TPE, 0, TRANSIENT);
     943             : 
     944         154 :         BATiter bi = bat_iterator(b);
     945         320 :         BAT *bn = BATcalcop_intern(VALptr(v),
     946         154 :                                 ATOMtype(v->vtype) == TYPE_oid ? v->vtype : ATOMbasetype(v->vtype),
     947             :                                 false,
     948             :                                 NULL,
     949             :                                 0,
     950             :                                 bi.type == TYPE_void ? (const void *) &b->tseqbase : (const void *) bi.base,
     951         154 :                                 ATOMtype(bi.type) == TYPE_oid ? bi.type : ATOMbasetype(bi.type),
     952             :                                 true,
     953         154 :                                 bi.vh ? bi.vh->base : NULL,
     954         154 :                                 bi.width,
     955         154 :                                 &(struct canditer){.tpe=cand_dense, .ncand=ncand},
     956             :                                 &ci,
     957             :                                 0, b->hseqbase,
     958         154 :                                 b->tnonil && ATOMcmp(v->vtype, VALptr(v), ATOMnilptr(v->vtype)) != 0,
     959             :                                 ci.hseq,
     960             : #ifdef NIL_MATCHES_FLAG
     961             :                                 nil_matches,
     962             : #endif
     963             :                                 __func__);
     964         154 :         bat_iterator_end(&bi);
     965         154 :         return bn;
     966             : }
     967             : 
     968             : gdk_return
     969      576560 : VARcalcop(ValPtr ret, const ValRecord *lft, const ValRecord *rgt
     970             : #ifdef NIL_MATCHES_FLAG
     971             :           , bool nil_matches
     972             : #endif
     973             :         )
     974             : {
     975      576560 :         ret->vtype = TYPE_TPE;
     976      576560 :         if (op_typeswitchloop(VALptr(lft),
     977      576560 :                               ATOMtype(lft->vtype) == TYPE_oid ? lft->vtype : ATOMbasetype(lft->vtype),
     978             :                               false,
     979             :                               NULL,
     980             :                               0,
     981             :                               VALptr(rgt),
     982      576560 :                               ATOMtype(rgt->vtype) == TYPE_oid ? rgt->vtype : ATOMbasetype(rgt->vtype),
     983             :                               false,
     984             :                               NULL,
     985             :                               0,
     986      576560 :                               VALget(ret),
     987      576560 :                               &(struct canditer){.tpe=cand_dense, .ncand=1},
     988      576560 :                               &(struct canditer){.tpe=cand_dense, .ncand=1},
     989             :                               0, 0,
     990             :                               false,
     991             : #ifdef NIL_MATCHES_FLAG
     992             :                               nil_matches,
     993             : #endif
     994             :                               __func__) == BUN_NONE)
     995           0 :                 return GDK_FAIL;
     996      576560 :         return GDK_SUCCEED;
     997             : }

Generated by: LCOV version 1.14