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