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, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : #include "monetdb_config.h"
14 : #include "gdk.h"
15 : #include "gdk_subquery.h"
16 : #include "gdk_private.h"
17 : #include "gdk_calc_private.h"
18 :
19 : #define SQLall_grp_imp(TYPE) \
20 : do { \
21 : const TYPE *restrict vals = (const TYPE *) li.base; \
22 : TYPE *restrict rp = (TYPE *) Tloc(res, 0); \
23 : for (BUN n = 0; n < ci.ncand; n++) { \
24 : i = canditer_next(&ci) - l->hseqbase; \
25 : if (gids == NULL || \
26 : (gids[i] >= min && gids[i] <= max)) { \
27 : if (gids) \
28 : gid = gids[i] - min; \
29 : else \
30 : gid = (oid) i; \
31 : if (oids[gid] != (BUN_NONE - 1)) { \
32 : if (oids[gid] == BUN_NONE) { \
33 : if (!is_##TYPE##_nil(vals[i])) \
34 : oids[gid] = i; \
35 : } else { \
36 : if (vals[oids[gid]] != vals[i] && !is_##TYPE##_nil(vals[i])) \
37 : oids[gid] = BUN_NONE - 1; \
38 : } \
39 : } \
40 : } \
41 : } \
42 : for (i = 0; i < ngrp; i++) { /* convert the found oids in values */ \
43 : BUN noid = oids[i]; \
44 : if (noid > (BUN_NONE - 2)) { \
45 : rp[i] = TYPE##_nil; \
46 : hasnil = 1; \
47 : } else { \
48 : rp[i] = vals[noid]; \
49 : } \
50 : } \
51 : } while (0)
52 :
53 : BAT *
54 38 : BATall_grp(BAT *l, BAT *g, BAT *e, BAT *s)
55 : {
56 38 : BAT *res = NULL;
57 38 : const oid *restrict gids;
58 38 : oid gid, min, max, *restrict oids = NULL; /* The oids variable controls if we have found a nil in the group so far */
59 38 : BUN i, ngrp;
60 38 : bit hasnil = 0;
61 38 : struct canditer ci;
62 38 : const char *err;
63 38 : lng t0 = 0;
64 :
65 38 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
66 :
67 38 : if ((err = BATgroupaggrinit(l, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
68 0 : GDKerror("%s\n", err);
69 0 : return NULL;
70 : }
71 38 : if (g == NULL) {
72 0 : GDKerror("l and g must be aligned\n");
73 0 : return NULL;
74 : }
75 :
76 38 : if (BATcount(l) == 0 || ngrp == 0) {
77 13 : const void *nilp = ATOMnilptr(l->ttype);
78 13 : if ((res = BATconstant(ngrp == 0 ? 0 : min, l->ttype, nilp, ngrp, TRANSIENT)) == NULL)
79 0 : goto alloc_fail;
80 : } else {
81 25 : BATiter li;
82 :
83 25 : if ((res = COLnew(min, l->ttype, ngrp, TRANSIENT)) == NULL)
84 0 : goto alloc_fail;
85 25 : if ((oids = GDKmalloc(ngrp * sizeof(oid))) == NULL)
86 0 : goto alloc_fail;
87 :
88 104 : for (i = 0; i < ngrp; i++)
89 79 : oids[i] = BUN_NONE;
90 :
91 25 : if (!g || BATtdense(g))
92 : gids = NULL;
93 : else
94 12 : gids = (const oid *) Tloc(g, 0);
95 :
96 25 : li = bat_iterator(l);
97 50 : switch (ATOMbasetype(l->ttype)) {
98 4 : case TYPE_bte:
99 32 : SQLall_grp_imp(bte);
100 : break;
101 0 : case TYPE_sht:
102 0 : SQLall_grp_imp(sht);
103 : break;
104 16 : case TYPE_int:
105 134 : SQLall_grp_imp(int);
106 : break;
107 0 : case TYPE_lng:
108 0 : SQLall_grp_imp(lng);
109 : break;
110 : #ifdef HAVE_HGE
111 3 : case TYPE_hge:
112 31 : SQLall_grp_imp(hge);
113 : break;
114 : #endif
115 0 : case TYPE_flt:
116 0 : SQLall_grp_imp(flt);
117 : break;
118 1 : case TYPE_dbl:
119 9 : SQLall_grp_imp(dbl);
120 : break;
121 1 : default: {
122 1 : int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
123 1 : const void *restrict nilp = ATOMnilptr(l->ttype);
124 :
125 3 : for (BUN n = 0; n < ci.ncand; n++) {
126 2 : i = canditer_next(&ci) - l->hseqbase;
127 2 : if (gids == NULL ||
128 2 : (gids[i] >= min && gids[i] <= max)) {
129 2 : if (gids)
130 2 : gid = gids[i] - min;
131 : else
132 : gid = (oid) i;
133 2 : if (oids[gid] != (BUN_NONE - 1)) {
134 2 : if (oids[gid] == BUN_NONE) {
135 1 : if (ocmp(BUNtail(li, i), nilp) != 0)
136 1 : oids[gid] = i;
137 : } else {
138 1 : const void *pi = BUNtail(li, oids[gid]);
139 1 : const void *pp = BUNtail(li, i);
140 1 : if (ocmp(pi, pp) != 0 && ocmp(pp, nilp) != 0)
141 1 : oids[gid] = BUN_NONE - 1;
142 : }
143 : }
144 : }
145 : }
146 :
147 1 : if (ATOMvarsized(l->ttype)) {
148 2 : for (i = 0; i < ngrp; i++) { /* convert the found oids in values */
149 1 : BUN noid = oids[i];
150 1 : const void *next;
151 1 : if (noid > (BUN_NONE - 2)) {
152 : next = nilp;
153 : hasnil = 1;
154 : } else {
155 0 : next = BUNtvar(li, noid);
156 : }
157 1 : if (tfastins_nocheckVAR(res, i, next) != GDK_SUCCEED) {
158 0 : bat_iterator_end(&li);
159 0 : goto alloc_fail;
160 : }
161 : }
162 : } else {
163 0 : uint8_t *restrict rcast = (uint8_t *) Tloc(res, 0);
164 0 : uint16_t width = res->twidth;
165 0 : for (i = 0; i < ngrp; i++) { /* convert the found oids in values */
166 0 : BUN noid = oids[i];
167 0 : const void *next;
168 0 : if (noid > (BUN_NONE - 2)) {
169 : next = nilp;
170 : hasnil = 1;
171 : } else {
172 0 : next = BUNtloc(li, noid);
173 : }
174 0 : memcpy(rcast, next, width);
175 0 : rcast += width;
176 : }
177 : }
178 : }
179 : }
180 25 : bat_iterator_end(&li);
181 25 : BATsetcount(res, ngrp);
182 25 : res->tnil = hasnil != 0;
183 25 : res->tnonil = hasnil == 0;
184 25 : res->tkey = BATcount(res) <= 1;
185 25 : res->tsorted = BATcount(res) <= 1;
186 25 : res->trevsorted = BATcount(res) <= 1;
187 : }
188 :
189 63 : GDKfree(oids);
190 :
191 38 : TRC_DEBUG(ALGO, "l=" ALGOBATFMT ",g=" ALGOBATFMT
192 : ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
193 : " -> " ALGOOPTBATFMT
194 : " (%s -- " LLFMT " usec)\n",
195 : ALGOBATPAR(l), ALGOBATPAR(g),
196 : ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
197 : ALGOOPTBATPAR(res),
198 : __func__, GDKusec() - t0);
199 : return res;
200 0 : alloc_fail:
201 0 : BBPreclaim(res);
202 0 : GDKfree(oids);
203 0 : return NULL;
204 : }
205 :
206 : #define SQLnil_grp_imp(TYPE) \
207 : do { \
208 : const TYPE *restrict vals = (const TYPE *) li.base; \
209 : for (BUN n = 0; n < ci.ncand; n++) { \
210 : i = canditer_next(&ci) - l->hseqbase; \
211 : if (gids == NULL || \
212 : (gids[i] >= min && gids[i] <= max)) { \
213 : if (gids) \
214 : gid = gids[i] - min; \
215 : else \
216 : gid = (oid) i; \
217 : if (ret[gid] != TRUE && is_##TYPE##_nil(vals[i])) \
218 : ret[gid] = TRUE; \
219 : } \
220 : } \
221 : } while (0)
222 :
223 : BAT *
224 75 : BATnil_grp(BAT *l, BAT *g, BAT *e, BAT *s)
225 : {
226 75 : BAT *res = NULL;
227 75 : const oid *restrict gids;
228 75 : oid gid, min, max;
229 75 : BUN i, ngrp;
230 75 : struct canditer ci;
231 75 : const char *err;
232 75 : lng t0 = 0;
233 :
234 75 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
235 :
236 75 : if ((err = BATgroupaggrinit(l, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
237 0 : GDKerror("%s\n", err);
238 0 : return NULL;
239 : }
240 75 : if (g == NULL) {
241 0 : GDKerror("l and g must be aligned\n");
242 0 : return NULL;
243 : }
244 :
245 96 : if (BATcount(l) == 0 || ngrp == 0) {
246 21 : bit F = FALSE;
247 21 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &F, ngrp, TRANSIENT)) == NULL)
248 0 : goto alloc_fail;
249 :
250 : } else {
251 54 : bit *restrict ret;
252 54 : BATiter li;
253 :
254 54 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
255 0 : goto alloc_fail;
256 54 : ret = (bit *) Tloc(res, 0);
257 54 : memset(ret, FALSE, ngrp * sizeof(bit));
258 :
259 54 : if (!g || BATtdense(g))
260 : gids = NULL;
261 : else
262 36 : gids = (const oid *) Tloc(g, 0);
263 :
264 54 : li = bat_iterator(l);
265 108 : switch (ATOMbasetype(l->ttype)) {
266 8 : case TYPE_bte:
267 54 : SQLnil_grp_imp(bte);
268 : break;
269 0 : case TYPE_sht:
270 0 : SQLnil_grp_imp(sht);
271 : break;
272 41 : case TYPE_int:
273 263 : SQLnil_grp_imp(int);
274 : break;
275 0 : case TYPE_lng:
276 0 : SQLnil_grp_imp(lng);
277 : break;
278 : #ifdef HAVE_HGE
279 3 : case TYPE_hge:
280 17 : SQLnil_grp_imp(hge);
281 : break;
282 : #endif
283 0 : case TYPE_flt:
284 0 : SQLnil_grp_imp(flt);
285 : break;
286 1 : case TYPE_dbl:
287 5 : SQLnil_grp_imp(dbl);
288 : break;
289 1 : default: {
290 1 : int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
291 1 : const void *restrict nilp = ATOMnilptr(l->ttype);
292 :
293 3 : for (BUN n = 0; n < ci.ncand; n++) {
294 2 : i = canditer_next(&ci) - l->hseqbase;
295 2 : if (gids == NULL ||
296 2 : (gids[i] >= min && gids[i] <= max)) {
297 2 : if (gids)
298 2 : gid = gids[i] - min;
299 : else
300 : gid = (oid) i;
301 2 : const void *restrict lv = BUNtail(li, i);
302 2 : if (ret[gid] != TRUE && ocmp(lv, nilp) == 0)
303 0 : ret[gid] = TRUE;
304 : }
305 : }
306 : }
307 : }
308 54 : bat_iterator_end(&li);
309 54 : BATsetcount(res, ngrp);
310 54 : res->tkey = BATcount(res) <= 1;
311 54 : res->tsorted = BATcount(res) <= 1;
312 54 : res->trevsorted = BATcount(res) <= 1;
313 54 : res->tnil = false;
314 54 : res->tnonil = true;
315 : }
316 :
317 75 : TRC_DEBUG(ALGO, "l=" ALGOBATFMT ",g=" ALGOBATFMT
318 : ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
319 : " -> " ALGOOPTBATFMT
320 : " (%s -- " LLFMT " usec)\n",
321 : ALGOBATPAR(l), ALGOBATPAR(g),
322 : ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
323 : ALGOOPTBATPAR(res),
324 : __func__, GDKusec() - t0);
325 : return res;
326 : alloc_fail:
327 0 : BBPreclaim(res);
328 : return NULL;
329 : }
330 :
331 : #define SQLanyequal_or_not_grp_imp(TYPE, TEST) \
332 : do { \
333 : const TYPE *vals1 = (const TYPE *) li.base; \
334 : const TYPE *vals2 = (const TYPE *) ri.base; \
335 : for (BUN n = 0; n < ci.ncand; n++) { \
336 : i = canditer_next(&ci) - l->hseqbase; \
337 : if (gids == NULL || \
338 : (gids[i] >= min && gids[i] <= max)) { \
339 : if (gids) \
340 : gid = gids[i] - min; \
341 : else \
342 : gid = (oid) i; \
343 : if (ret[gid] != TEST) { \
344 : if (is_##TYPE##_nil(vals1[i]) || is_##TYPE##_nil(vals2[i])) { \
345 : ret[gid] = bit_nil; \
346 : hasnil = 1; \
347 : } else if (vals1[i] == vals2[i]) { \
348 : ret[gid] = TEST; \
349 : } \
350 : } \
351 : } \
352 : } \
353 : } while (0)
354 :
355 : BAT *
356 0 : BATanyequal_grp(BAT *l, BAT *r, BAT *g, BAT *e, BAT *s)
357 : {
358 0 : BAT *res = NULL;
359 0 : const oid *restrict gids;
360 0 : oid gid, min, max;
361 0 : BUN i, ngrp;
362 0 : bit hasnil = 0;
363 0 : struct canditer ci;
364 0 : const char *err;
365 0 : lng t0 = 0;
366 :
367 0 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
368 :
369 0 : if ((err = BATgroupaggrinit(l, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
370 0 : GDKerror("%s\n", err);
371 0 : return NULL;
372 : }
373 0 : if (g == NULL) {
374 0 : GDKerror("l, r and g must be aligned\n");
375 0 : return NULL;
376 : }
377 :
378 0 : if (BATcount(l) == 0 || ngrp == 0) {
379 0 : bit F = FALSE;
380 0 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &F, ngrp, TRANSIENT)) == NULL)
381 0 : goto alloc_fail;
382 : } else {
383 0 : bit *restrict ret;
384 0 : BATiter li, ri;
385 :
386 0 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
387 0 : goto alloc_fail;
388 0 : ret = (bit *) Tloc(res, 0);
389 0 : memset(ret, FALSE, ngrp * sizeof(bit));
390 :
391 0 : if (!g || BATtdense(g))
392 : gids = NULL;
393 : else
394 0 : gids = (const oid *) Tloc(g, 0);
395 :
396 0 : li = bat_iterator(l);
397 0 : ri = bat_iterator(r);
398 0 : switch (ATOMbasetype(l->ttype)) {
399 0 : case TYPE_bte:
400 0 : SQLanyequal_or_not_grp_imp(bte, TRUE);
401 : break;
402 0 : case TYPE_sht:
403 0 : SQLanyequal_or_not_grp_imp(sht, TRUE);
404 : break;
405 0 : case TYPE_int:
406 0 : SQLanyequal_or_not_grp_imp(int, TRUE);
407 : break;
408 0 : case TYPE_lng:
409 0 : SQLanyequal_or_not_grp_imp(lng, TRUE);
410 : break;
411 : #ifdef HAVE_HGE
412 0 : case TYPE_hge:
413 0 : SQLanyequal_or_not_grp_imp(hge, TRUE);
414 : break;
415 : #endif
416 0 : case TYPE_flt:
417 0 : SQLanyequal_or_not_grp_imp(flt, TRUE);
418 : break;
419 0 : case TYPE_dbl:
420 0 : SQLanyequal_or_not_grp_imp(dbl, TRUE);
421 : break;
422 0 : default: {
423 0 : int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
424 0 : const void *nilp = ATOMnilptr(l->ttype);
425 :
426 0 : for (BUN n = 0; n < ci.ncand; n++) {
427 0 : i = canditer_next(&ci) - l->hseqbase;
428 0 : if (gids == NULL ||
429 0 : (gids[i] >= min && gids[i] <= max)) {
430 0 : if (gids)
431 0 : gid = gids[i] - min;
432 : else
433 : gid = (oid) i;
434 0 : if (ret[gid] != TRUE) {
435 0 : const void *lv = BUNtail(li, i);
436 0 : const void *rv = BUNtail(ri, i);
437 0 : if (ocmp(lv, nilp) == 0 || ocmp(rv, nilp) == 0) {
438 0 : ret[gid] = bit_nil;
439 0 : hasnil = 1;
440 0 : } else if (ocmp(lv, rv) == 0)
441 0 : ret[gid] = TRUE;
442 : }
443 : }
444 : }
445 : }
446 : }
447 0 : bat_iterator_end(&li);
448 0 : bat_iterator_end(&ri);
449 0 : BATsetcount(res, ngrp);
450 0 : res->tkey = BATcount(res) <= 1;
451 0 : res->tsorted = BATcount(res) <= 1;
452 0 : res->trevsorted = BATcount(res) <= 1;
453 0 : (void)hasnil;
454 0 : res->tnil = false ;//hasnil != 0;
455 0 : res->tnonil = false ;//hasnil == 0;
456 : }
457 :
458 0 : TRC_DEBUG(ALGO, "l=" ALGOBATFMT ",r=" ALGOBATFMT ",g=" ALGOBATFMT
459 : ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
460 : " -> " ALGOOPTBATFMT
461 : " (%s -- " LLFMT " usec)\n",
462 : ALGOBATPAR(l), ALGOBATPAR(r), ALGOBATPAR(g),
463 : ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
464 : ALGOOPTBATPAR(res),
465 : __func__, GDKusec() - t0);
466 : return res;
467 : alloc_fail:
468 0 : BBPreclaim(res);
469 : return NULL;
470 : }
471 :
472 : BAT *
473 0 : BATallnotequal_grp(BAT *l, BAT *r, BAT *g, BAT *e, BAT *s)
474 : {
475 0 : BAT *res = NULL;
476 0 : const oid *restrict gids;
477 0 : oid gid, min, max;
478 0 : BUN i, ngrp;
479 0 : bit hasnil = 0;
480 0 : struct canditer ci;
481 0 : const char *err;
482 0 : lng t0 = 0;
483 :
484 0 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
485 :
486 0 : if ((err = BATgroupaggrinit(l, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
487 0 : GDKerror("%s\n", err);
488 0 : return NULL;
489 : }
490 0 : if (g == NULL) {
491 0 : GDKerror("l, r and g must be aligned\n");
492 0 : return NULL;
493 : }
494 :
495 0 : if (BATcount(l) == 0 || ngrp == 0) {
496 0 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &(bit){TRUE}, ngrp, TRANSIENT)) == NULL)
497 0 : goto alloc_fail;
498 : } else {
499 0 : bit *restrict ret;
500 0 : BATiter li, ri;
501 :
502 0 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
503 0 : goto alloc_fail;
504 0 : ret = (bit *) Tloc(res, 0);
505 0 : memset(ret, TRUE, ngrp * sizeof(bit));
506 :
507 0 : if (!g || BATtdense(g))
508 : gids = NULL;
509 : else
510 0 : gids = (const oid *) Tloc(g, 0);
511 :
512 0 : li = bat_iterator(l);
513 0 : ri = bat_iterator(r);
514 0 : switch (ATOMbasetype(l->ttype)) {
515 0 : case TYPE_bte:
516 0 : SQLanyequal_or_not_grp_imp(bte, FALSE);
517 : break;
518 0 : case TYPE_sht:
519 0 : SQLanyequal_or_not_grp_imp(sht, FALSE);
520 : break;
521 0 : case TYPE_int:
522 0 : SQLanyequal_or_not_grp_imp(int, FALSE);
523 : break;
524 0 : case TYPE_lng:
525 0 : SQLanyequal_or_not_grp_imp(lng, FALSE);
526 : break;
527 : #ifdef HAVE_HGE
528 0 : case TYPE_hge:
529 0 : SQLanyequal_or_not_grp_imp(hge, FALSE);
530 : break;
531 : #endif
532 0 : case TYPE_flt:
533 0 : SQLanyequal_or_not_grp_imp(flt, FALSE);
534 : break;
535 0 : case TYPE_dbl:
536 0 : SQLanyequal_or_not_grp_imp(dbl, FALSE);
537 : break;
538 0 : default: {
539 0 : int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
540 0 : const void *nilp = ATOMnilptr(l->ttype);
541 :
542 0 : for (BUN n = 0; n < ci.ncand; n++) {
543 0 : i = canditer_next(&ci) - l->hseqbase;
544 0 : if (gids == NULL ||
545 0 : (gids[i] >= min && gids[i] <= max)) {
546 0 : if (gids)
547 0 : gid = gids[i] - min;
548 : else
549 : gid = (oid) i;
550 0 : if (ret[gid] != FALSE) {
551 0 : const void *lv = BUNtail(li, i);
552 0 : const void *rv = BUNtail(ri, i);
553 0 : if (ocmp(lv, nilp) == 0 || ocmp(rv, nilp) == 0) {
554 0 : ret[gid] = bit_nil;
555 0 : hasnil = 1;
556 0 : } else if (ocmp(lv, rv) == 0)
557 0 : ret[gid] = FALSE;
558 : }
559 : }
560 : }
561 : }
562 : }
563 0 : bat_iterator_end(&li);
564 0 : bat_iterator_end(&ri);
565 0 : BATsetcount(res, ngrp);
566 0 : res->tkey = BATcount(res) <= 1;
567 0 : res->tsorted = BATcount(res) <= 1;
568 0 : res->trevsorted = BATcount(res) <= 1;
569 0 : res->tnil = hasnil != 0;
570 0 : res->tnonil = hasnil == 0;
571 : }
572 :
573 0 : TRC_DEBUG(ALGO, "l=" ALGOBATFMT ",r=" ALGOBATFMT ",g=" ALGOBATFMT
574 : ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
575 : " -> " ALGOOPTBATFMT
576 : " (%s -- " LLFMT " usec)\n",
577 : ALGOBATPAR(l), ALGOBATPAR(r), ALGOBATPAR(g),
578 : ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
579 : ALGOOPTBATPAR(res),
580 : __func__, GDKusec() - t0);
581 : return res;
582 : alloc_fail:
583 0 : BBPreclaim(res);
584 : return NULL;
585 : }
586 :
587 : #define SQLanyequal_or_not_grp2_imp(TYPE, VAL1, VAL2) \
588 : do { \
589 : const TYPE *vals1 = (const TYPE *) li.base; \
590 : const TYPE *vals2 = (const TYPE *) ri.base; \
591 : for (BUN n = 0; n < ci.ncand; n++) { \
592 : i = canditer_next(&ci) - l->hseqbase; \
593 : if (gids == NULL || \
594 : (gids[i] >= min && gids[i] <= max)) { \
595 : if (gids) \
596 : gid = gids[i] - min; \
597 : else \
598 : gid = (oid) i; \
599 : if (ret[gid] != VAL1) { \
600 : const oid id = *(oid*)BUNtail(ii, i); \
601 : if (is_oid_nil(id)) { \
602 : ret[gid] = VAL2; \
603 : } else if (is_##TYPE##_nil(vals1[i]) || is_##TYPE##_nil(vals2[i])) { \
604 : ret[gid] = bit_nil; \
605 : } else if (vals1[i] == vals2[i]) { \
606 : ret[gid] = VAL1; \
607 : } \
608 : } \
609 : } \
610 : } \
611 : } while (0)
612 :
613 : BAT *
614 0 : BATanyequal_grp2(BAT *l, BAT *r, BAT *rid, BAT *g, BAT *e, BAT *s)
615 : {
616 0 : BAT *res = NULL;
617 0 : const oid *restrict gids;
618 0 : oid gid, min, max;
619 0 : BUN i, ngrp;
620 0 : bit hasnil = 0;
621 0 : struct canditer ci;
622 0 : const char *err;
623 0 : lng t0 = 0;
624 :
625 0 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
626 :
627 0 : if ((err = BATgroupaggrinit(l, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
628 0 : GDKerror("%s\n", err);
629 0 : return NULL;
630 : }
631 0 : if (g == NULL) {
632 0 : GDKerror("l, r, rid and g must be aligned\n");
633 0 : return NULL;
634 : }
635 :
636 0 : if (BATcount(l) == 0 || ngrp == 0) {
637 0 : bit F = FALSE;
638 0 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &F, ngrp, TRANSIENT)) == NULL)
639 0 : goto alloc_fail;
640 : } else {
641 0 : bit *restrict ret;
642 0 : BATiter ii, li, ri;
643 :
644 0 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
645 0 : goto alloc_fail;
646 0 : ret = (bit *) Tloc(res, 0);
647 0 : memset(ret, FALSE, ngrp * sizeof(bit));
648 :
649 0 : if (!g || BATtdense(g))
650 : gids = NULL;
651 : else
652 0 : gids = (const oid *) Tloc(g, 0);
653 :
654 0 : ii = bat_iterator(rid);
655 0 : li = bat_iterator(l);
656 0 : ri = bat_iterator(r);
657 0 : switch (ATOMbasetype(l->ttype)) {
658 0 : case TYPE_bte:
659 0 : SQLanyequal_or_not_grp2_imp(bte, TRUE, FALSE);
660 : break;
661 0 : case TYPE_sht:
662 0 : SQLanyequal_or_not_grp2_imp(sht, TRUE, FALSE);
663 : break;
664 0 : case TYPE_int:
665 0 : SQLanyequal_or_not_grp2_imp(int, TRUE, FALSE);
666 : break;
667 0 : case TYPE_lng:
668 0 : SQLanyequal_or_not_grp2_imp(lng, TRUE, FALSE);
669 : break;
670 : #ifdef HAVE_HGE
671 0 : case TYPE_hge:
672 0 : SQLanyequal_or_not_grp2_imp(hge, TRUE, FALSE);
673 : break;
674 : #endif
675 0 : case TYPE_flt:
676 0 : SQLanyequal_or_not_grp2_imp(flt, TRUE, FALSE);
677 : break;
678 0 : case TYPE_dbl:
679 0 : SQLanyequal_or_not_grp2_imp(dbl, TRUE, FALSE);
680 : break;
681 0 : default: {
682 0 : int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
683 0 : const void *nilp = ATOMnilptr(l->ttype);
684 :
685 0 : for (BUN n = 0; n < ci.ncand; n++) {
686 0 : i = canditer_next(&ci) - l->hseqbase;
687 0 : if (gids == NULL ||
688 0 : (gids[i] >= min && gids[i] <= max)) {
689 0 : if (gids)
690 0 : gid = gids[i] - min;
691 : else
692 : gid = (oid) i;
693 0 : if (ret[gid] != TRUE) {
694 0 : const oid id = *(oid*)BUNtail(ii, i);
695 0 : if (is_oid_nil(id)) {
696 0 : ret[gid] = FALSE;
697 : } else {
698 0 : const void *lv = BUNtail(li, i);
699 0 : const void *rv = BUNtail(ri, i);
700 0 : if (ocmp(lv, nilp) == 0 || ocmp(rv, nilp) == 0) {
701 0 : ret[gid] = bit_nil;
702 0 : } else if (ocmp(lv, rv) == 0)
703 0 : ret[gid] = TRUE;
704 : }
705 : }
706 : }
707 : }
708 : }
709 : }
710 0 : bat_iterator_end(&li);
711 0 : bat_iterator_end(&ri);
712 0 : bat_iterator_end(&ii);
713 0 : for (BUN i = 0 ; i < ngrp ; i++)
714 0 : hasnil |= ret[i] == bit_nil;
715 0 : BATsetcount(res, ngrp);
716 0 : res->tkey = BATcount(res) <= 1;
717 0 : res->tsorted = BATcount(res) <= 1;
718 0 : res->trevsorted = BATcount(res) <= 1;
719 0 : res->tnil = hasnil != 0;
720 0 : res->tnonil = hasnil == 0;
721 : }
722 :
723 0 : TRC_DEBUG(ALGO, "l=" ALGOBATFMT ",r=" ALGOBATFMT ",rid=" ALGOBATFMT
724 : ",g=" ALGOBATFMT ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
725 : " -> " ALGOOPTBATFMT
726 : " (%s -- " LLFMT " usec)\n",
727 : ALGOBATPAR(l), ALGOBATPAR(r), ALGOBATPAR(rid),
728 : ALGOBATPAR(g), ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
729 : ALGOOPTBATPAR(res),
730 : __func__, GDKusec() - t0);
731 : return res;
732 : alloc_fail:
733 0 : BBPreclaim(res);
734 : return NULL;
735 : }
736 :
737 : BAT *
738 0 : BATallnotequal_grp2(BAT *l, BAT *r, BAT *rid, BAT *g, BAT *e, BAT *s)
739 : {
740 0 : BAT *res = NULL;
741 0 : const oid *restrict gids;
742 0 : oid gid, min, max;
743 0 : BUN i, ngrp;
744 0 : bit hasnil = 0;
745 0 : struct canditer ci;
746 0 : const char *err;
747 0 : lng t0 = 0;
748 :
749 0 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
750 :
751 0 : if ((err = BATgroupaggrinit(l, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
752 0 : GDKerror("%s\n", err);
753 0 : return NULL;
754 : }
755 0 : if (g == NULL) {
756 0 : GDKerror("l, r, rid and g must be aligned\n");
757 0 : return NULL;
758 : }
759 :
760 0 : if (BATcount(l) == 0 || ngrp == 0) {
761 0 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &(bit){TRUE}, ngrp, TRANSIENT)) == NULL)
762 0 : goto alloc_fail;
763 : } else {
764 0 : bit *restrict ret;
765 0 : BATiter ii, li, ri;
766 :
767 0 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
768 0 : goto alloc_fail;
769 0 : ret = (bit *) Tloc(res, 0);
770 0 : memset(ret, TRUE, ngrp * sizeof(bit));
771 :
772 0 : if (!g || BATtdense(g))
773 : gids = NULL;
774 : else
775 0 : gids = (const oid *) Tloc(g, 0);
776 :
777 0 : ii = bat_iterator(rid);
778 0 : li = bat_iterator(l);
779 0 : ri = bat_iterator(r);
780 0 : switch (ATOMbasetype(l->ttype)) {
781 0 : case TYPE_bte:
782 0 : SQLanyequal_or_not_grp2_imp(bte, FALSE, TRUE);
783 : break;
784 0 : case TYPE_sht:
785 0 : SQLanyequal_or_not_grp2_imp(sht, FALSE, TRUE);
786 : break;
787 0 : case TYPE_int:
788 0 : SQLanyequal_or_not_grp2_imp(int, FALSE, TRUE);
789 : break;
790 0 : case TYPE_lng:
791 0 : SQLanyequal_or_not_grp2_imp(lng, FALSE, TRUE);
792 : break;
793 : #ifdef HAVE_HGE
794 0 : case TYPE_hge:
795 0 : SQLanyequal_or_not_grp2_imp(hge, FALSE, TRUE);
796 : break;
797 : #endif
798 0 : case TYPE_flt:
799 0 : SQLanyequal_or_not_grp2_imp(flt, FALSE, TRUE);
800 : break;
801 0 : case TYPE_dbl:
802 0 : SQLanyequal_or_not_grp2_imp(dbl, FALSE, TRUE);
803 : break;
804 0 : default: {
805 0 : int (*ocmp) (const void *, const void *) = ATOMcompare(l->ttype);
806 0 : const void *nilp = ATOMnilptr(l->ttype);
807 :
808 0 : for (BUN n = 0; n < ci.ncand; n++) {
809 0 : i = canditer_next(&ci) - l->hseqbase;
810 0 : if (gids == NULL ||
811 0 : (gids[i] >= min && gids[i] <= max)) {
812 0 : if (gids)
813 0 : gid = gids[i] - min;
814 : else
815 : gid = (oid) i;
816 0 : if (ret[gid] != FALSE) {
817 0 : const oid id = *(oid*)BUNtail(ii, i);
818 0 : if (is_oid_nil(id)) {
819 0 : ret[gid] = TRUE;
820 : } else {
821 0 : const void *lv = BUNtail(li, i);
822 0 : const void *rv = BUNtail(ri, i);
823 0 : if (ocmp(lv, nilp) == 0 || ocmp(rv, nilp) == 0) {
824 0 : ret[gid] = bit_nil;
825 0 : } else if (ocmp(lv, rv) == 0)
826 0 : ret[gid] = FALSE;
827 : }
828 : }
829 : }
830 : }
831 : }
832 : }
833 0 : bat_iterator_end(&ii);
834 0 : bat_iterator_end(&li);
835 0 : bat_iterator_end(&ri);
836 0 : for (BUN i = 0 ; i < ngrp ; i++)
837 0 : hasnil |= ret[i] == bit_nil;
838 0 : BATsetcount(res, ngrp);
839 0 : res->tkey = BATcount(res) <= 1;
840 0 : res->tsorted = BATcount(res) <= 1;
841 0 : res->trevsorted = BATcount(res) <= 1;
842 0 : res->tnil = hasnil != 0;
843 0 : res->tnonil = hasnil == 0;
844 : }
845 :
846 0 : TRC_DEBUG(ALGO, "l=" ALGOBATFMT ",r=" ALGOBATFMT ",rid=" ALGOBATFMT
847 : ",g=" ALGOBATFMT ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
848 : " -> " ALGOOPTBATFMT
849 : " (%s -- " LLFMT " usec)\n",
850 : ALGOBATPAR(l), ALGOBATPAR(r), ALGOBATPAR(rid),
851 : ALGOBATPAR(g), ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
852 : ALGOOPTBATPAR(res),
853 : __func__, GDKusec() - t0);
854 : return res;
855 : alloc_fail:
856 0 : BBPreclaim(res);
857 : return NULL;
858 : }
859 :
860 : BAT *
861 0 : BATsubexist(BAT *b, BAT *g, BAT *e, BAT *s)
862 : {
863 0 : BAT *res = NULL;
864 0 : const oid *restrict gids;
865 0 : oid min, max;
866 0 : BUN i, ngrp;
867 0 : struct canditer ci;
868 0 : const char *err;
869 0 : lng t0 = 0;
870 :
871 0 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
872 :
873 0 : if ((err = BATgroupaggrinit(b, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
874 0 : GDKerror("%s\n", err);
875 0 : return NULL;
876 : }
877 0 : if (g == NULL) {
878 0 : GDKerror("b and g must be aligned\n");
879 0 : return NULL;
880 : }
881 :
882 0 : if (BATcount(b) == 0 || ngrp == 0) {
883 0 : bit F = FALSE;
884 0 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &F, ngrp, TRANSIENT)) == NULL)
885 0 : goto alloc_fail;
886 : } else {
887 0 : bit *restrict exists;
888 :
889 0 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
890 0 : goto alloc_fail;
891 0 : exists = (bit *) Tloc(res, 0);
892 0 : memset(exists, FALSE, ngrp * sizeof(bit));
893 :
894 0 : if (!g || BATtdense(g))
895 : gids = NULL;
896 : else
897 0 : gids = (const oid *) Tloc(g, 0);
898 :
899 0 : if (gids) {
900 0 : for (BUN n = 0; n < ci.ncand; n++) {
901 0 : i = canditer_next(&ci) - b->hseqbase;
902 0 : if (gids[i] >= min && gids[i] <= max)
903 0 : exists[gids[i] - min] = TRUE;
904 : }
905 : } else {
906 0 : for (BUN n = 0; n < ci.ncand; n++) {
907 0 : i = canditer_next(&ci) - b->hseqbase;
908 0 : exists[i] = TRUE;
909 : }
910 : }
911 0 : BATsetcount(res, ngrp);
912 0 : res->tkey = BATcount(res) <= 1;
913 0 : res->tsorted = BATcount(res) <= 1;
914 0 : res->trevsorted = BATcount(res) <= 1;
915 0 : res->tnil = false;
916 0 : res->tnonil = true;
917 : }
918 :
919 0 : TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",g=" ALGOBATFMT
920 : ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
921 : " -> " ALGOOPTBATFMT
922 : " (%s -- " LLFMT " usec)\n",
923 : ALGOBATPAR(b), ALGOBATPAR(g),
924 : ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
925 : ALGOOPTBATPAR(res),
926 : __func__, GDKusec() - t0);
927 : return res;
928 : alloc_fail:
929 0 : BBPreclaim(res);
930 : return NULL;
931 : }
932 :
933 : BAT *
934 0 : BATsubnot_exist(BAT *b, BAT *g, BAT *e, BAT *s)
935 : {
936 0 : BAT *res = NULL;
937 0 : const oid *restrict gids;
938 0 : oid min, max;
939 0 : BUN i, ngrp;
940 0 : struct canditer ci;
941 0 : const char *err;
942 0 : lng t0 = 0;
943 :
944 0 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
945 :
946 0 : if ((err = BATgroupaggrinit(b, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
947 0 : GDKerror("%s\n", err);
948 0 : return NULL;
949 : }
950 0 : if (g == NULL) {
951 0 : GDKerror("b and g must be aligned\n");
952 0 : return NULL;
953 : }
954 :
955 0 : if (BATcount(b) == 0 || ngrp == 0) {
956 0 : if ((res = BATconstant(ngrp == 0 ? 0 : min, TYPE_bit, &(bit){TRUE}, ngrp, TRANSIENT)) == NULL)
957 0 : goto alloc_fail;
958 : } else {
959 0 : bit *restrict exists;
960 :
961 0 : if ((res = COLnew(min, TYPE_bit, ngrp, TRANSIENT)) == NULL)
962 0 : goto alloc_fail;
963 0 : exists = (bit *) Tloc(res, 0);
964 0 : memset(exists, TRUE, ngrp * sizeof(bit));
965 :
966 0 : if (!g || BATtdense(g))
967 : gids = NULL;
968 : else
969 0 : gids = (const oid *) Tloc(g, 0);
970 :
971 0 : if (gids) {
972 0 : for (BUN n = 0; n < ci.ncand; n++) {
973 0 : i = canditer_next(&ci) - b->hseqbase;
974 0 : if (gids[i] >= min && gids[i] <= max)
975 0 : exists[gids[i] - min] = FALSE;
976 : }
977 : } else {
978 0 : for (BUN n = 0; n < ci.ncand; n++) {
979 0 : i = canditer_next(&ci) - b->hseqbase;
980 0 : exists[i] = FALSE;
981 : }
982 : }
983 0 : BATsetcount(res, ngrp);
984 0 : res->tkey = BATcount(res) <= 1;
985 0 : res->tsorted = BATcount(res) <= 1;
986 0 : res->trevsorted = BATcount(res) <= 1;
987 0 : res->tnil = false;
988 0 : res->tnonil = true;
989 : }
990 :
991 0 : TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",g=" ALGOBATFMT
992 : ",e=" ALGOOPTBATFMT ",s=" ALGOOPTBATFMT
993 : " -> " ALGOOPTBATFMT
994 : " (%s -- " LLFMT " usec)\n",
995 : ALGOBATPAR(b), ALGOBATPAR(g),
996 : ALGOOPTBATPAR(e), ALGOOPTBATPAR(s),
997 : ALGOOPTBATPAR(res),
998 : __func__, GDKusec() - t0);
999 : return res;
1000 : alloc_fail:
1001 0 : BBPreclaim(res);
1002 : return NULL;
1003 : }
|
