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