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 : /*
14 : * Peter Boncz, M.L. Kersten
15 : * Binary Association Tables
16 : * This module contains the commands and patterns to manage Binary
17 : * Association Tables (BATs). The relational operations you can execute
18 : * on BATs have the form of a neat algebra, described in algebra.c
19 : *
20 : * But a database system needs more that just this algebra, since often it
21 : * is crucial to do table-updates (this would not be permitted in a strict
22 : * algebra).
23 : *
24 : * All commands needed for BAT updates, property management, basic I/O,
25 : * persistence, and storage options can be found in this module.
26 : *
27 : * All parameters to the modules are passed by reference.
28 : * In particular, this means that string values are passed to the module
29 : * layer as (str *)
30 : * and we have to de-reference them before entering the gdk library.
31 : * (Actual a design error in gdk to differentiate passing int/str)
32 : * This calls for knowledge on the underlying BAT types`s
33 : */
34 :
35 : #include "monetdb_config.h"
36 : #include "bat5.h"
37 : #include "mal_exception.h"
38 :
39 : /*
40 : * The remainder contains the wrapper code over the mserver version 4
41 : * InformationFunctions
42 : * In most cases we pass a BAT identifier, which should be unified
43 : * with a BAT descriptor. Upon failure we can simply abort the function.
44 : *
45 : * The logical head type :oid is mapped to a TYPE_void
46 : * with sequenceBase. It represents the old fashioned :vid
47 : */
48 :
49 :
50 : #define derefStr(b, v) \
51 : do { \
52 : int _tpe= ATOMstorage((b)->ttype); \
53 : if (_tpe >= TYPE_str) { \
54 : if ((v) == 0 || *(str*) (v) == 0) \
55 : (v) = (str) str_nil; \
56 : else \
57 : (v) = *(str *) (v); \
58 : } \
59 : } while (0)
60 :
61 : str
62 193845 : BKCnewBAT(bat *res, const int *tt, const BUN *cap, role_t role)
63 : {
64 193845 : BAT *bn;
65 :
66 193845 : bn = COLnew(0, *tt, *cap, role);
67 199693 : if (bn == NULL)
68 0 : throw(MAL, "bat.new", GDK_EXCEPTION);
69 199693 : *res = bn->batCacheid;
70 199693 : BBPretain(bn->batCacheid);
71 199067 : BBPunfix(bn->batCacheid);
72 199067 : return MAL_SUCCEED;
73 : }
74 :
75 : static str
76 0 : BKCdensebat(bat *ret, const lng *size)
77 : {
78 0 : BAT *bn;
79 0 : lng sz = *size;
80 :
81 0 : if (sz < 0)
82 : sz = 0;
83 : if (sz > (lng) BUN_MAX)
84 : sz = (lng) BUN_MAX;
85 0 : bn = BATdense(0, 0, (BUN) sz);
86 0 : if (bn == NULL)
87 0 : throw(MAL, "bat.densebat", GDK_EXCEPTION);
88 0 : *ret = bn->batCacheid;
89 0 : BBPkeepref(bn);
90 0 : return MAL_SUCCEED;
91 : }
92 :
93 : str
94 121594 : BKCmirror(bat *ret, const bat *bid)
95 : {
96 121594 : BAT *b, *bn;
97 :
98 121594 : *ret = 0;
99 121594 : if (!(b = BBPquickdesc(*bid)))
100 0 : throw(MAL, "bat.mirror", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
101 121752 : if (!(bn = BATdense(b->hseqbase, b->hseqbase, BATcount(b))))
102 0 : throw(MAL, "bat.mirror", GDK_EXCEPTION);
103 121586 : *ret = bn->batCacheid;
104 121586 : BBPkeepref(bn);
105 121586 : return MAL_SUCCEED;
106 : }
107 :
108 : static str
109 4 : BKCdelete(bat *r, const bat *bid, const oid *h)
110 : {
111 4 : BAT *b;
112 :
113 4 : if ((b = BATdescriptor(*bid)) == NULL)
114 0 : throw(MAL, "bat.delete", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
115 4 : if (BUNdelete(b, *h) != GDK_SUCCEED) {
116 2 : BBPunfix(b->batCacheid);
117 2 : throw(MAL, "bat.delete", GDK_EXCEPTION);
118 : }
119 2 : *r = b->batCacheid;
120 2 : BBPretain(b->batCacheid);
121 2 : BBPunfix(b->batCacheid);
122 2 : return MAL_SUCCEED;
123 : }
124 :
125 : static str
126 4 : BKCdelete_multi(bat *r, const bat *bid, const bat *sid)
127 : {
128 4 : BAT *b, *s;
129 4 : gdk_return ret;
130 :
131 4 : if ((b = BATdescriptor(*bid)) == NULL)
132 0 : throw(MAL, "bat.delete", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
133 4 : if ((s = BATdescriptor(*sid)) == NULL) {
134 0 : BBPunfix(b->batCacheid);
135 0 : throw(MAL, "bat.delete", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
136 : }
137 4 : ret = BATdel(b, s);
138 4 : BBPunfix(s->batCacheid);
139 4 : if (ret != GDK_SUCCEED) {
140 0 : BBPunfix(b->batCacheid);
141 0 : throw(MAL, "bat.delete", GDK_EXCEPTION);
142 : }
143 4 : *r = b->batCacheid;
144 4 : BBPretain(b->batCacheid);
145 4 : BBPunfix(b->batCacheid);
146 4 : return MAL_SUCCEED;
147 : }
148 :
149 : static str
150 7 : BKCdelete_all(bat *r, const bat *bid)
151 : {
152 7 : BAT *b;
153 :
154 7 : if ((b = BATdescriptor(*bid)) == NULL)
155 0 : throw(MAL, "bat.delete", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
156 7 : if (BATclear(b, false) != GDK_SUCCEED) {
157 0 : BBPunfix(b->batCacheid);
158 0 : throw(MAL, "bat.delete", GDK_EXCEPTION);
159 : }
160 7 : *r = b->batCacheid;
161 7 : BBPretain(b->batCacheid);
162 7 : BBPunfix(b->batCacheid);
163 7 : return MAL_SUCCEED;
164 : }
165 :
166 : static str
167 104065 : BKCappend_cand_force_wrap(bat *r, const bat *bid, const bat *uid,
168 : const bat *sid, const bit *force)
169 : {
170 104065 : BAT *b, *u, *s = NULL;
171 104065 : gdk_return ret;
172 :
173 104065 : if ((b = BATdescriptor(*bid)) == NULL)
174 0 : throw(MAL, "bat.append", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
175 104529 : if (isVIEW(b)) {
176 9503 : BAT *bn = COLcopy(b, b->ttype, true, TRANSIENT);
177 9423 : MT_lock_set(&b->theaplock);
178 9473 : restrict_t mode = b->batRestricted;
179 9473 : MT_lock_unset(&b->theaplock);
180 9504 : BBPunfix(b->batCacheid);
181 9494 : if (bn == NULL || (b = BATsetaccess(bn, mode)) == NULL)
182 0 : throw(MAL, "bat.append", GDK_EXCEPTION);
183 : }
184 104530 : if ((u = BATdescriptor(*uid)) == NULL) {
185 0 : BBPunfix(b->batCacheid);
186 0 : throw(MAL, "bat.append", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
187 : }
188 104455 : if (mask_cand(u)) {
189 0 : BAT *ou = u;
190 0 : u = BATunmask(u);
191 0 : BBPunfix(ou->batCacheid);
192 0 : if (!u) {
193 0 : BBPunfix(b->batCacheid);
194 0 : throw(MAL, "bat.append", GDK_EXCEPTION);
195 : }
196 : }
197 104455 : if (sid && !is_bat_nil(*sid) && (s = BATdescriptor(*sid)) == NULL) {
198 0 : BBPunfix(b->batCacheid);
199 0 : BBPunfix(u->batCacheid);
200 0 : throw(MAL, "bat.append", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
201 : }
202 104676 : ret = BATappend(b, u, s, force ? *force : false);
203 103966 : BBPunfix(u->batCacheid);
204 104396 : BBPreclaim(s);
205 104289 : if (ret != GDK_SUCCEED) {
206 0 : BBPunfix(b->batCacheid);
207 0 : throw(MAL, "bat.append", GDK_EXCEPTION);
208 : }
209 104289 : *r = b->batCacheid;
210 104289 : BBPretain(b->batCacheid);
211 104353 : BBPunfix(b->batCacheid);
212 104353 : return MAL_SUCCEED;
213 : }
214 :
215 : static str
216 0 : BKCappend_cand_wrap(bat *r, const bat *bid, const bat *uid, const bat *sid)
217 : {
218 0 : return BKCappend_cand_force_wrap(r, bid, uid, sid, NULL);
219 : }
220 :
221 : static str
222 221 : BKCappend_wrap(bat *r, const bat *bid, const bat *uid)
223 : {
224 221 : return BKCappend_cand_force_wrap(r, bid, uid, NULL, NULL);
225 : }
226 :
227 : static str
228 103944 : BKCappend_force_wrap(bat *r, const bat *bid, const bat *uid, const bit *force)
229 : {
230 103944 : return BKCappend_cand_force_wrap(r, bid, uid, NULL, force);
231 : }
232 :
233 : static str
234 14304064 : BKCappend_val_force_wrap(bat *r, const bat *bid, const void *u,
235 : const bit *force)
236 : {
237 14304064 : BAT *b;
238 :
239 14304064 : if ((b = BATdescriptor(*bid)) == NULL)
240 0 : throw(MAL, "bat.append", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
241 14304064 : if (isVIEW(b)) {
242 12 : BAT *bn = COLcopy(b, b->ttype, true, TRANSIENT);
243 12 : MT_lock_set(&b->theaplock);
244 12 : restrict_t mode = b->batRestricted;
245 12 : MT_lock_unset(&b->theaplock);
246 12 : BBPunfix(b->batCacheid);
247 12 : if (bn == NULL || (b = BATsetaccess(bn, mode)) == NULL)
248 0 : throw(MAL, "bat.append", GDK_EXCEPTION);
249 : }
250 14304064 : derefStr(b, u);
251 28607773 : if (BUNappend(b, u, force ? *force : false) != GDK_SUCCEED) {
252 0 : BBPunfix(b->batCacheid);
253 0 : throw(MAL, "bat.append", GDK_EXCEPTION);
254 : }
255 14304064 : *r = b->batCacheid;
256 14304064 : BBPretain(b->batCacheid);
257 14304064 : BBPunfix(b->batCacheid);
258 14304064 : return MAL_SUCCEED;
259 : }
260 :
261 : static str
262 14303709 : BKCappend_val_wrap(bat *r, const bat *bid, const void *u)
263 : {
264 14303709 : return BKCappend_val_force_wrap(r, bid, u, NULL);
265 : }
266 :
267 : static str
268 103 : BKCbun_inplace(bat *r, const bat *bid, const oid *id, const void *t)
269 : {
270 103 : BAT *b;
271 :
272 103 : if ((b = BATdescriptor(*bid)) == NULL)
273 0 : throw(MAL, "bat.inplace", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
274 103 : derefStr(b, t);
275 103 : if (void_inplace(b, *id, t, false) != GDK_SUCCEED) {
276 0 : BBPunfix(b->batCacheid);
277 0 : throw(MAL, "bat.inplace", GDK_EXCEPTION);
278 : }
279 103 : *r = b->batCacheid;
280 103 : BBPretain(b->batCacheid);
281 103 : BBPunfix(b->batCacheid);
282 103 : return MAL_SUCCEED;
283 : }
284 :
285 : static str
286 0 : BKCbun_inplace_force(bat *r, const bat *bid, const oid *id, const void *t,
287 : const bit *force)
288 : {
289 0 : BAT *b;
290 :
291 0 : if ((b = BATdescriptor(*bid)) == NULL)
292 0 : throw(MAL, "bat.inplace", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
293 0 : derefStr(b, t);
294 0 : if (void_inplace(b, *id, t, *force) != GDK_SUCCEED) {
295 0 : BBPunfix(b->batCacheid);
296 0 : throw(MAL, "bat.inplace", GDK_EXCEPTION);
297 : }
298 0 : *r = b->batCacheid;
299 0 : BBPretain(b->batCacheid);
300 0 : BBPunfix(b->batCacheid);
301 0 : return MAL_SUCCEED;
302 : }
303 :
304 :
305 : static str
306 209469 : BKCbat_inplace_force(bat *r, const bat *bid, const bat *rid, const bat *uid,
307 : const bit *force)
308 : {
309 209469 : BAT *b, *p, *u;
310 :
311 209469 : if ((b = BATdescriptor(*bid)) == NULL)
312 0 : throw(MAL, "bat.inplace", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
313 210096 : if ((p = BATdescriptor(*rid)) == NULL) {
314 0 : BBPunfix(b->batCacheid);
315 0 : throw(MAL, "bat.inplace", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
316 : }
317 210050 : if ((u = BATdescriptor(*uid)) == NULL) {
318 0 : BBPunfix(b->batCacheid);
319 0 : BBPunfix(p->batCacheid);
320 0 : throw(MAL, "bat.inplace", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
321 : }
322 210106 : if (BATreplace(b, p, u, *force) != GDK_SUCCEED) {
323 0 : BBPunfix(b->batCacheid);
324 0 : BBPunfix(p->batCacheid);
325 0 : BBPunfix(u->batCacheid);
326 0 : throw(MAL, "bat.inplace", GDK_EXCEPTION);
327 : }
328 209308 : *r = b->batCacheid;
329 209308 : BBPretain(b->batCacheid);
330 210008 : BBPunfix(b->batCacheid);
331 209923 : BBPunfix(p->batCacheid);
332 210017 : BBPunfix(u->batCacheid);
333 210017 : return MAL_SUCCEED;
334 : }
335 :
336 : static str
337 2 : BKCbat_inplace(bat *r, const bat *bid, const bat *rid, const bat *uid)
338 : {
339 2 : bit F = FALSE;
340 :
341 2 : return BKCbat_inplace_force(r, bid, rid, uid, &F);
342 : }
343 :
344 : /*end of SQL enhancement */
345 :
346 : static str
347 0 : BKCgetCapacity(lng *res, const bat *bid)
348 : {
349 0 : *res = lng_nil;
350 0 : BAT *b = BBPquickdesc(*bid);
351 :
352 0 : if (b == NULL)
353 0 : throw(MAL, "bat.getCapacity", ILLEGAL_ARGUMENT);
354 0 : *res = (lng) BATcapacity(b);
355 0 : return MAL_SUCCEED;
356 : }
357 :
358 : static str
359 0 : BKCgetColumnType(str *res, const bat *bid)
360 : {
361 0 : const char *ret = str_nil;
362 0 : BAT *b = BBPquickdesc(*bid);
363 :
364 0 : if (b == NULL)
365 0 : throw(MAL, "bat.getColumnType", ILLEGAL_ARGUMENT);
366 0 : ret = *bid < 0 ? ATOMname(TYPE_void) : ATOMname(b->ttype);
367 0 : *res = GDKstrdup(ret);
368 0 : if (*res == NULL)
369 0 : throw(MAL, "bat.getColumnType", SQLSTATE(HY013) MAL_MALLOC_FAIL);
370 : return MAL_SUCCEED;
371 : }
372 :
373 : static str
374 0 : BKCisSorted(bit *res, const bat *bid)
375 : {
376 0 : BAT *b;
377 :
378 0 : if ((b = BATdescriptor(*bid)) == NULL) {
379 0 : throw(MAL, "bat.isSorted", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
380 : }
381 0 : *res = BATordered(b);
382 0 : BBPunfix(b->batCacheid);
383 0 : return MAL_SUCCEED;
384 : }
385 :
386 : static str
387 0 : BKCisSortedReverse(bit *res, const bat *bid)
388 : {
389 0 : BAT *b;
390 :
391 0 : if ((b = BATdescriptor(*bid)) == NULL) {
392 0 : throw(MAL, "bat.isSorted", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
393 : }
394 0 : *res = BATordered_rev(b);
395 0 : BBPunfix(b->batCacheid);
396 0 : return MAL_SUCCEED;
397 : }
398 :
399 : /*
400 : * We must take care of the special case of a nil column (TYPE_void,seqbase=nil)
401 : * such nil columns never set tkey
402 : * a nil column of a BAT with <= 1 entries does not contain doubles => return TRUE.
403 : */
404 :
405 : static str
406 0 : BKCgetKey(bit *ret, const bat *bid)
407 : {
408 0 : BAT *b;
409 :
410 0 : if ((b = BATdescriptor(*bid)) == NULL)
411 0 : throw(MAL, "bat.setPersistence",
412 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
413 0 : MT_lock_set(&b->theaplock);
414 0 : *ret = b->tkey;
415 0 : MT_lock_unset(&b->theaplock);
416 0 : BBPunfix(b->batCacheid);
417 0 : return MAL_SUCCEED;
418 : }
419 :
420 : static str
421 2 : BKCpersists(void *r, const bat *bid, const bit *flg)
422 : {
423 2 : BAT *b;
424 :
425 2 : (void) r;
426 2 : if ((b = BATdescriptor(*bid)) == NULL) {
427 0 : throw(MAL, "bat.setPersistence",
428 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
429 : }
430 2 : if (BATmode(b, (*flg != TRUE)) != GDK_SUCCEED) {
431 0 : BBPunfix(b->batCacheid);
432 0 : throw(MAL, "bat.setPersistence", ILLEGAL_ARGUMENT);
433 : }
434 2 : BBPunfix(b->batCacheid);
435 2 : return MAL_SUCCEED;
436 : }
437 :
438 : static str
439 1 : BKCsetPersistent(void *r, const bat *bid)
440 : {
441 1 : bit flag = TRUE;
442 1 : return BKCpersists(r, bid, &flag);
443 : }
444 :
445 : static str
446 2 : BKCisPersistent(bit *res, const bat *bid)
447 : {
448 2 : BAT *b;
449 :
450 2 : if ((b = BATdescriptor(*bid)) == NULL) {
451 0 : throw(MAL, "bat.setPersistence",
452 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
453 : }
454 2 : MT_lock_set(&b->theaplock);
455 2 : *res = !b->batTransient;
456 2 : MT_lock_unset(&b->theaplock);
457 2 : BBPunfix(b->batCacheid);
458 2 : return MAL_SUCCEED;
459 : }
460 :
461 : static str
462 1 : BKCsetTransient(void *r, const bat *bid)
463 : {
464 1 : bit flag = FALSE;
465 1 : return BKCpersists(r, bid, &flag);
466 : }
467 :
468 : static str
469 2 : BKCisTransient(bit *res, const bat *bid)
470 : {
471 2 : BAT *b;
472 :
473 2 : if ((b = BATdescriptor(*bid)) == NULL) {
474 0 : throw(MAL, "bat.setTransient", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
475 : }
476 2 : MT_lock_set(&b->theaplock);
477 2 : *res = b->batTransient;
478 2 : MT_lock_unset(&b->theaplock);
479 2 : BBPunfix(b->batCacheid);
480 2 : return MAL_SUCCEED;
481 : }
482 :
483 : static str
484 3 : BKCsetAccess(bat *res, const bat *bid, const char *const *param)
485 : {
486 3 : BAT *b;
487 3 : restrict_t m;
488 :
489 3 : if ((b = BATdescriptor(*bid)) == NULL)
490 0 : throw(MAL, "bat.setAccess", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
491 3 : switch (*param[0]) {
492 : case 'r':
493 : m = BAT_READ;
494 : break;
495 0 : case 'a':
496 0 : m = BAT_APPEND;
497 0 : break;
498 0 : case 'w':
499 0 : m = BAT_WRITE;
500 0 : break;
501 0 : default:
502 0 : *res = 0;
503 0 : BBPunfix(b->batCacheid);
504 0 : throw(MAL, "bat.setAccess",
505 : ILLEGAL_ARGUMENT " Got %c" " expected 'r','a', or 'w'",
506 0 : *param[0]);
507 : }
508 3 : if ((b = BATsetaccess(b, m)) == NULL)
509 0 : throw(MAL, "bat.setAccess", OPERATION_FAILED);
510 3 : *res = b->batCacheid;
511 3 : BBPretain(b->batCacheid);
512 3 : BBPunfix(b->batCacheid);
513 3 : return MAL_SUCCEED;
514 : }
515 :
516 : static str
517 0 : BKCgetAccess(str *res, const bat *bid)
518 : {
519 0 : BAT *b;
520 :
521 0 : if ((b = BATdescriptor(*bid)) == NULL)
522 0 : throw(MAL, "bat.getAccess", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
523 0 : switch (BATgetaccess(b)) {
524 0 : case BAT_READ:
525 0 : *res = GDKstrdup("read");
526 0 : break;
527 0 : case BAT_APPEND:
528 0 : *res = GDKstrdup("append");
529 0 : break;
530 0 : case BAT_WRITE:
531 0 : *res = GDKstrdup("write");
532 0 : break;
533 : default:
534 0 : MT_UNREACHABLE();
535 : }
536 0 : BBPunfix(b->batCacheid);
537 0 : if (*res == NULL)
538 0 : throw(MAL, "bat.getAccess", SQLSTATE(HY013) MAL_MALLOC_FAIL);
539 : return MAL_SUCCEED;
540 : }
541 :
542 : /*
543 : * Property management
544 : * All property operators should ensure exclusive access to the BAT
545 : * descriptor.
546 : * Where necessary use the primary view to access the properties
547 : */
548 : static inline char *
549 0 : pre(const char *s1, const char *s2, char *buf)
550 : {
551 0 : snprintf(buf, 64, "%s%s", s1, s2);
552 0 : return buf;
553 : }
554 :
555 : static inline char *
556 0 : local_itoa(ssize_t i, char *buf)
557 : {
558 0 : snprintf(buf, 32, "%zd", i);
559 0 : return buf;
560 : }
561 :
562 : static inline char *
563 0 : local_utoa(size_t i, char *buf)
564 : {
565 0 : snprintf(buf, 32, "%zu", i);
566 0 : return buf;
567 : }
568 :
569 : static inline char *
570 0 : oidtostr(oid i, char *p, size_t len)
571 : {
572 0 : if (OIDtoStr(&p, &len, &i, false) < 0)
573 : return NULL;
574 0 : return p;
575 : }
576 :
577 : static gdk_return
578 0 : infoHeap(BAT *bk, BAT *bv, Heap *hp, const char *nme)
579 : {
580 0 : char buf[1024], *p = buf;
581 :
582 0 : if (!hp)
583 : return GDK_SUCCEED;
584 0 : while (*nme)
585 0 : *p++ = *nme++;
586 0 : strcpy(p, "free");
587 0 : if (BUNappend(bk, buf, false) != GDK_SUCCEED ||
588 0 : BUNappend(bv, local_utoa(hp->free, buf), false) != GDK_SUCCEED)
589 0 : return GDK_FAIL;
590 0 : strcpy(p, "size");
591 0 : if (BUNappend(bk, buf, false) != GDK_SUCCEED ||
592 0 : BUNappend(bv, local_utoa(hp->size, buf), false) != GDK_SUCCEED)
593 0 : return GDK_FAIL;
594 0 : strcpy(p, "storage");
595 0 : if (BUNappend(bk, buf, false) != GDK_SUCCEED ||
596 0 : BUNappend(bv, (hp->base == NULL || hp->base == (char *) 1) ? "absent" : (hp->storage == STORE_MMAP) ? (hp-> filename [0] ? "memory mapped" : "anonymous vm") : (hp->storage == STORE_PRIV) ? "private map" : "malloced", false) != GDK_SUCCEED)
597 0 : return GDK_FAIL;
598 0 : strcpy(p, "newstorage");
599 0 : if (BUNappend(bk, buf, false) != GDK_SUCCEED ||
600 0 : BUNappend(bv, (hp->newstorage == STORE_MEM) ? "malloced" : (hp->newstorage == STORE_PRIV) ? "private map" : "memory mapped", false) != GDK_SUCCEED)
601 0 : return GDK_FAIL;
602 0 : strcpy(p, "filename");
603 0 : if (BUNappend(bk, buf, false) != GDK_SUCCEED ||
604 0 : BUNappend(bv, hp->filename[0] ? hp->filename : "no file",
605 : false) != GDK_SUCCEED)
606 0 : return GDK_FAIL;
607 : return GDK_SUCCEED;
608 : }
609 :
610 : #define COLLISION (8 * sizeof(size_t))
611 :
612 : static gdk_return
613 0 : HASHinfo(BAT *bk, BAT *bv, Hash *h, const char *s)
614 : {
615 0 : BUN i;
616 0 : BUN j;
617 0 : BUN k;
618 0 : BUN cnt[COLLISION + 1];
619 0 : char buf[32];
620 0 : char prebuf[64];
621 :
622 0 : if (BUNappend(bk, pre(s, "type", prebuf), false) != GDK_SUCCEED ||
623 0 : BUNappend(bv, ATOMname(h->type), false) != GDK_SUCCEED ||
624 0 : BUNappend(bk, pre(s, "mask", prebuf), false) != GDK_SUCCEED ||
625 0 : BUNappend(bv, local_utoa(h->nbucket, buf), false) != GDK_SUCCEED)
626 0 : return GDK_FAIL;
627 :
628 0 : for (i = 0; i < COLLISION + 1; i++) {
629 0 : cnt[i] = 0;
630 : }
631 0 : for (i = 0; i < h->nbucket; i++) {
632 0 : j = HASHlist(h, i);
633 0 : for (k = 0; j; k++)
634 0 : j >>= 1;
635 0 : cnt[k]++;
636 : }
637 :
638 0 : for (i = 0; i < COLLISION + 1; i++)
639 0 : if (cnt[i]) {
640 0 : if (BUNappend(bk,
641 0 : pre(s, local_utoa(i ? (((size_t) 1) << (i - 1)) : 0,
642 : buf),
643 : prebuf),
644 : false) != GDK_SUCCEED
645 0 : || BUNappend(bv, local_utoa((size_t) cnt[i], buf),
646 : false) != GDK_SUCCEED)
647 0 : return GDK_FAIL;
648 : }
649 : return GDK_SUCCEED;
650 : }
651 :
652 : static str
653 0 : BKCinfo(bat *ret1, bat *ret2, const bat *bid)
654 : {
655 0 : const char *mode, *accessmode;
656 0 : BAT *bk = NULL, *bv = NULL, *b;
657 0 : char bf[oidStrlen];
658 0 : char buf[32];
659 :
660 0 : if ((b = BATdescriptor(*bid)) == NULL) {
661 0 : throw(MAL, "bat.info", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
662 : }
663 :
664 0 : bk = COLnew(0, TYPE_str, 128, TRANSIENT);
665 0 : bv = COLnew(0, TYPE_str, 128, TRANSIENT);
666 0 : if (bk == NULL || bv == NULL) {
667 0 : BBPreclaim(bk);
668 0 : BBPreclaim(bv);
669 0 : BBPunfix(b->batCacheid);
670 0 : throw(MAL, "bat.info", SQLSTATE(HY013) MAL_MALLOC_FAIL);
671 : }
672 :
673 0 : BATiter bi = bat_iterator(b);
674 0 : if (bi.transient) {
675 : mode = "transient";
676 : } else {
677 0 : mode = "persistent";
678 : }
679 :
680 0 : switch (bi.restricted) {
681 : case BAT_READ:
682 : accessmode = "read-only";
683 : break;
684 0 : case BAT_WRITE:
685 0 : accessmode = "updatable";
686 0 : break;
687 0 : case BAT_APPEND:
688 0 : accessmode = "append-only";
689 0 : break;
690 0 : default:
691 0 : accessmode = "unknown";
692 : }
693 :
694 0 : if (BUNappend(bk, "batId", false) != GDK_SUCCEED
695 0 : || BUNappend(bv, BATgetId(b), false) != GDK_SUCCEED
696 0 : || BUNappend(bk, "batCacheid", false) != GDK_SUCCEED
697 0 : || BUNappend(bv, local_itoa((ssize_t) b->batCacheid, buf),
698 : false) != GDK_SUCCEED
699 0 : || BUNappend(bk, "tparentid", false) != GDK_SUCCEED
700 0 : || BUNappend(bv, local_itoa((ssize_t) bi.h->parentid, buf),
701 : false) != GDK_SUCCEED
702 0 : || BUNappend(bk, "batCount", false) != GDK_SUCCEED
703 0 : || BUNappend(bv, local_utoa((size_t) bi.count, buf),
704 : false) != GDK_SUCCEED
705 0 : || BUNappend(bk, "batCapacity", false) != GDK_SUCCEED
706 0 : || BUNappend(bv, local_utoa((size_t) b->batCapacity, buf),
707 : false) != GDK_SUCCEED
708 0 : || BUNappend(bk, "head", false) != GDK_SUCCEED
709 0 : || BUNappend(bv, ATOMname(TYPE_void), false) != GDK_SUCCEED
710 0 : || BUNappend(bk, "tail", false) != GDK_SUCCEED
711 0 : || BUNappend(bv, ATOMname(bi.type), false) != GDK_SUCCEED
712 0 : || BUNappend(bk, "batPersistence", false) != GDK_SUCCEED
713 0 : || BUNappend(bv, mode, false) != GDK_SUCCEED
714 0 : || BUNappend(bk, "batRestricted", false) != GDK_SUCCEED
715 0 : || BUNappend(bv, accessmode, false) != GDK_SUCCEED
716 0 : || BUNappend(bk, "batRefcnt", false) != GDK_SUCCEED
717 0 : || BUNappend(bv, local_itoa((ssize_t) BBP_refs(b->batCacheid), buf),
718 : false) != GDK_SUCCEED
719 0 : || BUNappend(bk, "batLRefcnt", false) != GDK_SUCCEED
720 0 : || BUNappend(bv, local_itoa((ssize_t) BBP_lrefs(b->batCacheid), buf),
721 : false) != GDK_SUCCEED
722 0 : || BUNappend(bk, "batDirty", false) != GDK_SUCCEED
723 0 : || BUNappend(bv, BATdirtybi(bi) ? "dirty" : "clean",
724 : false) != GDK_SUCCEED
725 0 : || BUNappend(bk, "hseqbase", false) != GDK_SUCCEED
726 0 : || BUNappend(bv, oidtostr(b->hseqbase, bf, sizeof(bf)),
727 : FALSE) != GDK_SUCCEED
728 0 : || BUNappend(bk, "tdense", false) != GDK_SUCCEED
729 0 : || BUNappend(bv, local_itoa((ssize_t) BATtdensebi(&bi), buf),
730 : false) != GDK_SUCCEED
731 0 : || BUNappend(bk, "tseqbase", false) != GDK_SUCCEED
732 0 : || BUNappend(bv, oidtostr(bi.tseq, bf, sizeof(bf)),
733 : FALSE) != GDK_SUCCEED
734 0 : || BUNappend(bk, "tsorted", false) != GDK_SUCCEED
735 0 : || BUNappend(bv, local_itoa((ssize_t) bi.sorted, buf),
736 : false) != GDK_SUCCEED
737 0 : || BUNappend(bk, "trevsorted", false) != GDK_SUCCEED
738 0 : || BUNappend(bv, local_itoa((ssize_t) bi.revsorted, buf),
739 : false) != GDK_SUCCEED
740 0 : || BUNappend(bk, "tkey", false) != GDK_SUCCEED
741 0 : || BUNappend(bv, local_itoa((ssize_t) bi.key, buf),
742 : false) != GDK_SUCCEED
743 0 : || BUNappend(bk, "tvarsized", false) != GDK_SUCCEED
744 0 : || BUNappend(bv,
745 0 : local_itoa((ssize_t)
746 : (bi.type == TYPE_void
747 0 : || bi.vh != NULL), buf), false) != GDK_SUCCEED
748 0 : || BUNappend(bk, "tnosorted", false) != GDK_SUCCEED
749 0 : || BUNappend(bv, local_utoa(bi.nosorted, buf), false) != GDK_SUCCEED
750 0 : || BUNappend(bk, "tnorevsorted", false) != GDK_SUCCEED
751 0 : || BUNappend(bv, local_utoa(bi.norevsorted, buf), false) != GDK_SUCCEED
752 0 : || BUNappend(bk, "tnokey[0]", false) != GDK_SUCCEED
753 0 : || BUNappend(bv, local_utoa(bi.nokey[0], buf), false) != GDK_SUCCEED
754 0 : || BUNappend(bk, "tnokey[1]", false) != GDK_SUCCEED
755 0 : || BUNappend(bv, local_utoa(bi.nokey[1], buf), false) != GDK_SUCCEED
756 0 : || BUNappend(bk, "tnonil", false) != GDK_SUCCEED
757 0 : || BUNappend(bv, local_utoa(bi.nonil, buf), false) != GDK_SUCCEED
758 0 : || BUNappend(bk, "tnil", false) != GDK_SUCCEED
759 0 : || BUNappend(bv, local_utoa(bi.nil, buf), false) != GDK_SUCCEED
760 0 : || BUNappend(bk, "batInserted", false) != GDK_SUCCEED
761 0 : || BUNappend(bv, local_utoa(b->batInserted, buf), false) != GDK_SUCCEED
762 0 : || BUNappend(bk, "ttop", false) != GDK_SUCCEED
763 0 : || BUNappend(bv, local_utoa(bi.hfree, buf), false) != GDK_SUCCEED
764 0 : || BUNappend(bk, "batCopiedtodisk", false) != GDK_SUCCEED
765 0 : || BUNappend(bv, local_itoa((ssize_t) bi.copiedtodisk, buf),
766 : false) != GDK_SUCCEED
767 0 : || BUNappend(bk, "theap.dirty", false) != GDK_SUCCEED
768 0 : || BUNappend(bv, bi.hdirty ? "dirty" : "clean", false) != GDK_SUCCEED
769 0 : || infoHeap(bk, bv, bi.h, "tail.") != GDK_SUCCEED
770 0 : || BUNappend(bk, "tvheap->dirty", false) != GDK_SUCCEED
771 0 : || BUNappend(bv, bi.vhdirty ? "dirty" : "clean", false) != GDK_SUCCEED
772 0 : || infoHeap(bk, bv, bi.vh, "theap.") != GDK_SUCCEED) {
773 0 : bat_iterator_end(&bi);
774 0 : BBPreclaim(bk);
775 0 : BBPreclaim(bv);
776 0 : BBPunfix(b->batCacheid);
777 0 : throw(MAL, "bat.info", SQLSTATE(HY013) MAL_MALLOC_FAIL);
778 : }
779 : /* dump index information */
780 0 : MT_rwlock_rdlock(&b->thashlock);
781 0 : if (b->thash && HASHinfo(bk, bv, b->thash, "thash->") != GDK_SUCCEED) {
782 0 : MT_rwlock_rdunlock(&b->thashlock);
783 0 : bat_iterator_end(&bi);
784 0 : BBPreclaim(bk);
785 0 : BBPreclaim(bv);
786 0 : BBPunfix(b->batCacheid);
787 0 : throw(MAL, "bat.info", SQLSTATE(HY013) MAL_MALLOC_FAIL);
788 : }
789 0 : MT_rwlock_rdunlock(&b->thashlock);
790 0 : bat_iterator_end(&bi);
791 0 : assert(BATcount(bk) == BATcount(bv));
792 0 : BBPunfix(b->batCacheid);
793 0 : *ret1 = bk->batCacheid;
794 0 : BBPkeepref(bk);
795 0 : *ret2 = bv->batCacheid;
796 0 : BBPkeepref(bv);
797 0 : return MAL_SUCCEED;
798 : }
799 :
800 : // get the actual size of all constituents, also for views
801 : #define ROUND_UP(x,y) ((y)*(((x)+(y)-1)/(y)))
802 :
803 : static str
804 0 : BKCgetSize(lng *tot, const bat *bid)
805 : {
806 0 : BAT *b;
807 0 : lng size = 0;
808 0 : lng blksize = (lng) MT_pagesize();
809 0 : if ((b = BATdescriptor(*bid)) == NULL) {
810 0 : throw(MAL, "bat.getDiskSize", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
811 : }
812 :
813 0 : size = sizeof(bat);
814 :
815 0 : MT_lock_set(&b->theaplock);
816 0 : if (!isVIEW(b)) {
817 0 : BUN cnt = BATcapacity(b);
818 0 : size += ROUND_UP(b->theap->free, blksize);
819 0 : if (b->tvheap)
820 0 : size += ROUND_UP(b->tvheap->free, blksize);
821 0 : MT_lock_unset(&b->theaplock);
822 :
823 0 : if (b->thash)
824 0 : size += ROUND_UP(sizeof(BUN) * cnt, blksize);
825 : } else {
826 0 : MT_lock_unset(&b->theaplock);
827 : }
828 0 : *tot = size;
829 0 : BBPunfix(*bid);
830 0 : return MAL_SUCCEED;
831 : }
832 :
833 : static str
834 3 : BKCgetVHeapSize(lng *tot, const bat *bid)
835 : {
836 3 : BAT *b;
837 3 : lng size = 0;
838 3 : if ((b = BATdescriptor(*bid)) == NULL) {
839 0 : throw(MAL, "bat.getVHeapSize", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
840 : }
841 3 : if (ATOMvarsized(b->ttype)) {
842 3 : MT_lock_set(&b->theaplock);
843 3 : if (b->tvheap)
844 3 : size += b->tvheap->size;
845 3 : MT_lock_unset(&b->theaplock);
846 : }
847 :
848 3 : *tot = size;
849 3 : BBPunfix(*bid);
850 3 : return MAL_SUCCEED;
851 : }
852 :
853 : /*
854 : * Synced BATs
855 : */
856 : static str
857 0 : BKCisSynced(bit *ret, const bat *bid1, const bat *bid2)
858 : {
859 0 : BAT *b1, *b2;
860 :
861 0 : if ((b1 = BATdescriptor(*bid1)) == NULL) {
862 0 : throw(MAL, "bat.isSynced", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
863 : }
864 0 : if ((b2 = BATdescriptor(*bid2)) == NULL) {
865 0 : BBPunfix(b1->batCacheid);
866 0 : throw(MAL, "bat.isSynced", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
867 : }
868 0 : *ret = ALIGNsynced(b1, b2) != 0;
869 0 : BBPunfix(b1->batCacheid);
870 0 : BBPunfix(b2->batCacheid);
871 0 : return MAL_SUCCEED;
872 : }
873 :
874 : /*
875 : * Role Management
876 : */
877 : static str
878 9 : BKCsetName(void *r, const bat *bid, const char *const *s)
879 : {
880 9 : BAT *b;
881 9 : int ret;
882 9 : int c;
883 9 : const char *t = *s;
884 :
885 9 : (void) r;
886 9 : if ((b = BATdescriptor(*bid)) == NULL)
887 0 : throw(MAL, "bat.setName", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
888 :
889 52 : for (; (c = *t) != 0; t++)
890 43 : if (c != '_' && !GDKisalnum(c)) {
891 0 : BBPunfix(b->batCacheid);
892 0 : throw(MAL, "bat.setName",
893 : ILLEGAL_ARGUMENT ": identifier expected: %s", *s);
894 : }
895 :
896 9 : t = *s;
897 9 : ret = BBPrename(b, t);
898 9 : BBPunfix(b->batCacheid);
899 9 : switch (ret) {
900 0 : case BBPRENAME_ILLEGAL:
901 0 : GDKclrerr();
902 0 : throw(MAL, "bat.setName",
903 : ILLEGAL_ARGUMENT ": illegal temporary name: '%s'", t);
904 0 : case BBPRENAME_LONG:
905 0 : GDKclrerr();
906 0 : throw(MAL, "bat.setName", ILLEGAL_ARGUMENT ": name too long: '%s'", t);
907 0 : case BBPRENAME_MEMORY:
908 0 : GDKclrerr();
909 0 : throw(MAL, "bat.setName", SQLSTATE(HY013) MAL_MALLOC_FAIL);
910 1 : case BBPRENAME_ALREADY:
911 1 : GDKclrerr();
912 : /* fall through */
913 : case 0:
914 : break;
915 : }
916 : return MAL_SUCCEED;
917 : }
918 :
919 : static str
920 0 : BKCgetBBPname(str *ret, const bat *bid)
921 : {
922 0 : BAT *b;
923 :
924 0 : if ((b = BATdescriptor(*bid)) == NULL) {
925 0 : throw(MAL, "bat.getName", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
926 : }
927 0 : *ret = GDKstrdup(BBP_logical(b->batCacheid));
928 0 : BBPunfix(b->batCacheid);
929 0 : return *ret ? MAL_SUCCEED : createException(MAL, "bat.getName",
930 : SQLSTATE(HY013)
931 : MAL_MALLOC_FAIL);
932 : }
933 :
934 : static str
935 0 : BKCsave(bit *res, const char *const *input)
936 : {
937 0 : bat bid = BBPindex(*input);
938 0 : BAT *b;
939 :
940 0 : *res = FALSE;
941 0 : if (!is_bat_nil(bid)) {
942 0 : if ((b = BATdescriptor(bid)) != NULL) {
943 0 : if (BATdirty(b)) {
944 0 : if (BBPsave(b) == GDK_SUCCEED)
945 0 : *res = TRUE;
946 : }
947 0 : BBPunfix(bid);
948 0 : return MAL_SUCCEED;
949 : }
950 0 : throw(MAL, "bat.save", "fix failed");
951 : }
952 : return MAL_SUCCEED;
953 : }
954 :
955 : static str
956 0 : BKCsave2(void *r, const bat *bid)
957 : {
958 0 : BAT *b;
959 :
960 0 : (void) r;
961 0 : if ((b = BATdescriptor(*bid)) == NULL) {
962 0 : throw(MAL, "bat.save", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
963 : }
964 0 : MT_lock_set(&b->theaplock);
965 0 : if (!b->batTransient) {
966 0 : MT_lock_unset(&b->theaplock);
967 0 : BBPunfix(b->batCacheid);
968 0 : throw(MAL, "bat.save", "Only save transient columns.");
969 : }
970 0 : MT_lock_unset(&b->theaplock);
971 :
972 0 : if (b && BATdirty(b))
973 0 : BBPsave(b);
974 0 : BBPunfix(b->batCacheid);
975 0 : return MAL_SUCCEED;
976 : }
977 :
978 : /*
979 : * Accelerator Control
980 : */
981 : static str
982 0 : BKCsetHash(bit *ret, const bat *bid)
983 : {
984 0 : BAT *b;
985 :
986 0 : (void) ret;
987 0 : if ((b = BATdescriptor(*bid)) == NULL) {
988 0 : throw(MAL, "bat.setHash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
989 : }
990 0 : *ret = BAThash(b) == GDK_SUCCEED;
991 0 : BBPunfix(b->batCacheid);
992 0 : return MAL_SUCCEED;
993 : }
994 :
995 : static str
996 0 : BKCgetSequenceBase(oid *r, const bat *bid)
997 : {
998 0 : BAT *b;
999 :
1000 0 : if ((b = BATdescriptor(*bid)) == NULL) {
1001 0 : throw(MAL, "bat.setSequenceBase",
1002 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1003 : }
1004 0 : *r = b->hseqbase;
1005 0 : BBPunfix(b->batCacheid);
1006 0 : return MAL_SUCCEED;
1007 : }
1008 :
1009 : static str
1010 113403 : BKCmergecand(bat *ret, const bat *aid, const bat *bid)
1011 : {
1012 113403 : BAT *a, *b, *bn;
1013 :
1014 113403 : if ((a = BATdescriptor(*aid)) == NULL) {
1015 0 : throw(MAL, "bat.mergecand", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1016 : }
1017 113684 : if ((b = BATdescriptor(*bid)) == NULL) {
1018 0 : BBPunfix(a->batCacheid);
1019 0 : throw(MAL, "bat.mergecand", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1020 : }
1021 113684 : bn = BATmergecand(a, b);
1022 113365 : BBPunfix(a->batCacheid);
1023 113554 : BBPunfix(b->batCacheid);
1024 113604 : if (bn == NULL)
1025 0 : throw(MAL, "bat.mergecand", GDK_EXCEPTION);
1026 113604 : *ret = bn->batCacheid;
1027 113604 : BBPkeepref(bn);
1028 113604 : return MAL_SUCCEED;
1029 : }
1030 :
1031 : static str
1032 0 : BKCintersectcand(bat *ret, const bat *aid, const bat *bid)
1033 : {
1034 0 : BAT *a, *b, *bn;
1035 :
1036 0 : if ((a = BATdescriptor(*aid)) == NULL) {
1037 0 : throw(MAL, "bat.intersectcand", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1038 : }
1039 0 : if ((b = BATdescriptor(*bid)) == NULL) {
1040 0 : BBPunfix(a->batCacheid);
1041 0 : throw(MAL, "bat.intersectcand", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1042 : }
1043 0 : bn = BATintersectcand(a, b);
1044 0 : BBPunfix(a->batCacheid);
1045 0 : BBPunfix(b->batCacheid);
1046 0 : if (bn == NULL)
1047 0 : throw(MAL, "bat.intersectcand", GDK_EXCEPTION);
1048 0 : *ret = bn->batCacheid;
1049 0 : BBPkeepref(bn);
1050 0 : return MAL_SUCCEED;
1051 : }
1052 :
1053 : static str
1054 0 : BKCdiffcand(bat *ret, const bat *aid, const bat *bid)
1055 : {
1056 0 : BAT *a, *b, *bn;
1057 :
1058 0 : if ((a = BATdescriptor(*aid)) == NULL) {
1059 0 : throw(MAL, "bat.diffcand", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1060 : }
1061 0 : if ((b = BATdescriptor(*bid)) == NULL) {
1062 0 : BBPunfix(a->batCacheid);
1063 0 : throw(MAL, "bat.diffcand", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1064 : }
1065 0 : bn = BATdiffcand(a, b);
1066 0 : BBPunfix(a->batCacheid);
1067 0 : BBPunfix(b->batCacheid);
1068 0 : if (bn == NULL)
1069 0 : throw(MAL, "bat.diffcand", GDK_EXCEPTION);
1070 0 : *ret = bn->batCacheid;
1071 0 : BBPkeepref(bn);
1072 0 : return MAL_SUCCEED;
1073 : }
1074 :
1075 : #include "mel.h"
1076 : mel_func bat5_init_funcs[] = {
1077 : command("bat", "mirror", BKCmirror, false, "Returns the head-mirror image of a BAT (two head columns).", args(1,2, batarg("",oid),batargany("b",1))),
1078 : command("bat", "delete", BKCdelete, false, "Delete BUN indicated by head value, exchanging with last BUN", args(1,3, batargany("",1),batargany("b",1),arg("h",oid))),
1079 : command("bat", "delete", BKCdelete_multi, false, "Delete multiple BUN, shifting BUNs up", args(1,3, batargany("",1),batargany("b",1),batarg("d",oid))),
1080 : command("bat", "delete", BKCdelete_all, false, "Delete all entries.", args(1,2, batargany("",1),batargany("b",1))),
1081 : command("bat", "replace", BKCbun_inplace, false, "Replace the tail value of one BUN that has some head value.", args(1,4, batargany("",1),batargany("b",1),arg("h",oid),argany("t",1))),
1082 : command("bat", "replace", BKCbun_inplace_force, false, "Replace the tail value of one BUN that has some head value.", args(1,5, batargany("",1),batargany("b",1),arg("h",oid),argany("t",1),arg("force",bit))),
1083 : command("bat", "replace", BKCbat_inplace, false, "Perform replace for all BUNs of the second BAT into the first.", args(1,4, batargany("",1),batargany("b",1),batarg("rid",oid),batargany("val",1))),
1084 : command("bat", "replace", BKCbat_inplace_force, false, "Perform replace for all BUNs of the second BAT into the first.", args(1,5, batargany("",1),batargany("b",1),batarg("rid",oid),batargany("val",1),arg("force",bit))),
1085 : command("bat", "append", BKCappend_wrap, false, "append the content of u to i", args(1,3, batargany("",1),batargany("i",1),batargany("u",1))),
1086 : command("bat", "append", BKCappend_force_wrap, false, "append the content of u to i", args(1,4, batargany("",1),batargany("i",1),batargany("u",1),arg("force",bit))),
1087 : command("bat", "append", BKCappend_cand_wrap, false, "append the content of u with candidate list s to i", args(1,4, batargany("",1),batargany("i",1),batargany("u",1),batarg("s",oid))),
1088 : command("bat", "append", BKCappend_cand_force_wrap, false, "append the content of u with candidate list s to i", args(1,5, batargany("",1),batargany("i",1),batargany("u",1),batarg("s",oid),arg("force",bit))),
1089 : command("bat", "append", BKCappend_val_force_wrap, false, "append the value u to i", args(1,4, batargany("",1),batargany("i",1),argany("u",1),arg("force",bit))),
1090 : command("bat", "densebat", BKCdensebat, false, "Creates a new [void,void] BAT of size 'sz'.", args(1,2, batarg("",oid),arg("sz",lng))),
1091 : command("bat", "info", BKCinfo, false, "Produce a table containing information about a BAT in [attribute,value] format. \nIt contains all properties of the BAT record. ", args(2,3, batarg("",str),batarg("",str),batargany("b",1))),
1092 : command("bat", "getSize", BKCgetSize, false, "Calculate the actual size of the BAT descriptor, heaps, hashes in bytes\nrounded to the memory page size (see bbp.getPageSize()).", args(1,2, arg("",lng),batargany("b",1))),
1093 : command("bat", "getVHeapSize", BKCgetVHeapSize, false, "Calculate the vheap size for varsized bats", args(1,2, arg("",lng),batargany("b",1))),
1094 : command("bat", "getCapacity", BKCgetCapacity, false, "Returns the current allocation size (in max number of elements) of a BAT.", args(1,2, arg("",lng),batargany("b",1))),
1095 : command("bat", "getColumnType", BKCgetColumnType, false, "Returns the type of the tail column of a BAT, as an integer type number.", args(1,2, arg("",str),batargany("b",1))),
1096 : command("bat", "isaKey", BKCgetKey, false, "Return whether the column tail values are unique (key).", args(1,2, arg("",bit),batargany("b",1))),
1097 : command("bat", "setAccess", BKCsetAccess, false, "Try to change the update access privileges \nto this BAT. Mode:\nr[ead-only] - allow only read access.\na[append-only] - allow reads and update.\nw[riteable] - allow all operations.\nBATs are updatable by default. On making a BAT read-only, \nall subsequent updates fail with an error message.\nReturns the BAT itself.", args(1,3, batargany("",1),batargany("b",1),arg("mode",str))),
1098 : command("bat", "getAccess", BKCgetAccess, false, "Return the access mode attached to this BAT as a character.", args(1,2, arg("",str),batargany("b",1))),
1099 : command("bat", "getSequenceBase", BKCgetSequenceBase, false, "Get the sequence base for the void column of a BAT.", args(1,2, arg("",oid),batargany("b",1))),
1100 : command("bat", "isSorted", BKCisSorted, false, "Returns true if BAT values are ordered.", args(1,2, arg("",bit),batargany("b",1))),
1101 : command("bat", "isSortedReverse", BKCisSortedReverse, false, "Returns true if BAT values are reversely ordered.", args(1,2, arg("",bit),batargany("b",1))),
1102 : command("bat", "append", BKCappend_val_wrap, false, "append the value u to i", args(1,3, batargany("",1),batargany("i",1),argany("u",1))),
1103 : command("bat", "setName", BKCsetName, false, "Give a logical name to a BAT. ", args(1,3, arg("",void),batargany("b",1),arg("s",str))),
1104 : command("bat", "getName", BKCgetBBPname, false, "Gives back the logical name of a BAT.", args(1,2, arg("",str),batargany("b",1))),
1105 : command("bat", "isTransient", BKCisTransient, false, "", args(1,2, arg("",bit),batargany("b",1))),
1106 : command("bat", "setTransient", BKCsetTransient, false, "Make the BAT transient. Returns \nboolean which indicates if the\nBAT administration has indeed changed.", args(1,2, arg("",void),batargany("b",1))),
1107 : command("bat", "isPersistent", BKCisPersistent, false, "", args(1,2, arg("",bit),batargany("b",1))),
1108 : command("bat", "setPersistent", BKCsetPersistent, false, "Make the BAT persistent.", args(1,2, arg("",void),batargany("b",1))),
1109 : command("bat", "save", BKCsave2, false, "", args(1,2, arg("",void),batargany("nme",1))),
1110 : command("bat", "save", BKCsave, false, "Save a BAT to storage, if it was loaded and dirty. \nReturns whether IO was necessary. Please realize that \ncalling this function violates the atomic commit protocol!!", args(1,2, arg("",bit),arg("nme",str))),
1111 : command("bat", "setHash", BKCsetHash, false, "Create a hash structure on the column", args(1,2, arg("",bit),batargany("b",1))),
1112 : command("bat", "isSynced", BKCisSynced, false, "Tests whether two BATs are synced or not. ", args(1,3, arg("",bit),batargany("b1",1),batargany("b2",2))),
1113 : command("bat", "mergecand", BKCmergecand, false, "Merge two candidate lists into one", args(1,3, batarg("",oid),batarg("a",oid),batarg("b",oid))),
1114 : command("bat", "intersectcand", BKCintersectcand, false, "Intersect two candidate lists into one", args(1,3, batarg("",oid),batarg("a",oid),batarg("b",oid))),
1115 : command("bat", "diffcand", BKCdiffcand, false, "Calculate difference of two candidate lists", args(1,3, batarg("",oid),batarg("a",oid),batarg("b",oid))),
1116 : { .imp=NULL }
1117 : };
1118 : #include "mal_import.h"
1119 : #ifdef _MSC_VER
1120 : #undef read
1121 : #pragma section(".CRT$XCU",read)
1122 : #endif
1123 350 : LIB_STARTUP_FUNC(init_bat5_mal)
1124 350 : { mal_module("bat5", NULL, bat5_init_funcs); }
|
