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

Generated by: LCOV version 1.14