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 : * M.L.Kersten
15 : * BAT Algebra Extensions
16 : * The kernel libraries are unaware of the MAL runtime semantics.
17 : * This calls for declaring some operations in the MAL module section
18 : * and register them in the kernel modules explicitly.
19 : *
20 : * A good example of this borderline case are BAT creation operations,
21 : * which require a mapping of the type identifier to the underlying
22 : * implementation type.
23 : *
24 : * Another example concerns the (un)pack operations, which direct
25 : * access the runtime stack to (push)pull the values needed.
26 : */
27 : #include "monetdb_config.h"
28 : #include "mal_client.h"
29 : #include "mal_interpreter.h"
30 : #include "bat5.h"
31 : #include "gdk_time.h"
32 : #include "mal_instruction.h"
33 : #include "mal_exception.h"
34 :
35 : /*
36 : * BAT enhancements
37 : * The code to enhance the kernel.
38 : */
39 :
40 : static str
41 194504 : CMDBATnew(Client cntxt, MalBlkPtr m, MalStkPtr s, InstrPtr p)
42 : {
43 194504 : int tt;
44 194504 : role_t kind = TRANSIENT;
45 194504 : BUN cap = 0;
46 194504 : bat *res;
47 :
48 194504 : (void) cntxt;
49 194504 : res = getArgReference_bat(s, p, 0);
50 194504 : tt = getArgType(m, p, 1);
51 194504 : if (p->argc > 2) {
52 2 : lng lcap;
53 :
54 2 : if (getArgType(m, p, 2) == TYPE_lng)
55 0 : lcap = *getArgReference_lng(s, p, 2);
56 2 : else if (getArgType(m, p, 2) == TYPE_int)
57 2 : lcap = (lng) *getArgReference_int(s, p, 2);
58 : else
59 0 : throw(MAL, "bat.new", ILLEGAL_ARGUMENT " Incorrect type for size");
60 2 : if (lcap < 0)
61 0 : throw(MAL, "bat.new", POSITIVE_EXPECTED);
62 2 : if (lcap > (lng) BUN_MAX)
63 0 : throw(MAL, "bat.new", ILLEGAL_ARGUMENT " Capacity too large");
64 2 : cap = (BUN) lcap;
65 2 : if (p->argc == 4 && getVarConstant(m, getArg(p, 3)).val.ival)
66 194504 : kind = PERSISTENT;
67 : }
68 :
69 194504 : if (tt == TYPE_any || isaBatType(tt))
70 0 : throw(MAL, "bat.new", SEMANTIC_TYPE_ERROR);
71 197188 : return (str) BKCnewBAT(res, &tt, &cap, kind);
72 : }
73 :
74 : static str
75 4264 : CMDBATdup(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
76 : {
77 4264 : BAT *b, *i;
78 4264 : bat *ret = getArgReference_bat(stk, pci, 0);
79 4264 : int tt = getArgType(mb, pci, 1);
80 4264 : bat input = *getArgReference_bat(stk, pci, 2);
81 :
82 4264 : (void) cntxt;
83 4264 : if ((i = BBPquickdesc(input)) == NULL)
84 0 : throw(MAL, "bat.new", INTERNAL_BAT_ACCESS);
85 4264 : b = COLnew(i->hseqbase, tt, BATcount(i), TRANSIENT);
86 4264 : if (b == 0)
87 0 : throw(MAL, "bat.new", SQLSTATE(HY013) MAL_MALLOC_FAIL);
88 4264 : *ret = b->batCacheid;
89 4264 : BBPretain(b->batCacheid);
90 4264 : BBPunfix(b->batCacheid);
91 4264 : return MAL_SUCCEED;
92 : }
93 :
94 : static str
95 16787 : CMDBATsingle(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
96 : {
97 16787 : BAT *b;
98 16787 : int *ret = getArgReference_bat(stk, pci, 0);
99 16787 : void *u = (void *) getArgReference(stk, pci, 1);
100 :
101 17000 : (void) cntxt;
102 :
103 17000 : b = COLnew(0, getArgType(mb, pci, 1), 0, TRANSIENT);
104 17990 : if (b == 0)
105 0 : throw(MAL, "bat.single", SQLSTATE(HY013) MAL_MALLOC_FAIL);
106 17990 : if (ATOMextern(b->ttype))
107 6116 : u = (ptr) *(ptr *) u;
108 17990 : if (BUNappend(b, u, false) != GDK_SUCCEED) {
109 0 : BBPreclaim(b);
110 0 : throw(MAL, "bat.single", SQLSTATE(HY013) MAL_MALLOC_FAIL);
111 : }
112 17748 : *ret = b->batCacheid;
113 17748 : BBPkeepref(b);
114 17748 : return MAL_SUCCEED;
115 : }
116 :
117 : /* If the optimizer has not determined the partition bounds we derive one here. */
118 : static str
119 2 : CMDBATpartition(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
120 : {
121 2 : BAT *b, *bn;
122 2 : bat *ret;
123 2 : int i;
124 2 : bat bid;
125 2 : oid lval, hval = 0, step;
126 :
127 2 : (void) mb;
128 2 : (void) cntxt;
129 2 : bid = *getArgReference_bat(stk, pci, pci->retc);
130 :
131 2 : if ((b = BATdescriptor(bid)) == NULL) {
132 0 : throw(MAL, "bat.partition", INTERNAL_BAT_ACCESS);
133 : }
134 2 : step = BATcount(b) / pci->retc + 1;
135 :
136 : /* create the slices slightly overshoot to make sure it all is taken */
137 5 : for (i = 0; i < pci->retc; i++) {
138 3 : lval = i * step;
139 3 : hval = lval + step;
140 3 : if (i == pci->retc - 1)
141 2 : hval = BATcount(b);
142 3 : bn = BATslice(b, lval, hval);
143 3 : if (bn == NULL) {
144 0 : BBPunfix(b->batCacheid);
145 0 : throw(MAL, "bat.partition", SQLSTATE(HY013) MAL_MALLOC_FAIL);
146 : }
147 3 : BAThseqbase(bn, lval);
148 3 : stk->stk[getArg(pci, i)].val.bval = bn->batCacheid;
149 3 : ret = getArgReference_bat(stk, pci, i);
150 3 : *ret = bn->batCacheid;
151 3 : BBPkeepref(bn);
152 : }
153 2 : BBPunfix(b->batCacheid);
154 2 : return MAL_SUCCEED;
155 : }
156 :
157 : static str
158 9 : CMDBATpartition2(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
159 : {
160 9 : BAT *b, *bn;
161 9 : bat *ret, bid;
162 9 : int pieces = *getArgReference_int(stk, pci, 2);
163 9 : int idx = *getArgReference_int(stk, pci, 3);
164 9 : oid lval, hval = 0, step;
165 :
166 9 : (void) mb;
167 9 : (void) cntxt;
168 9 : if (pieces <= 0)
169 0 : throw(MAL, "bat.partition", POSITIVE_EXPECTED);
170 9 : if (idx >= pieces || idx < 0)
171 1 : throw(MAL, "bat.partition", ILLEGAL_ARGUMENT " Illegal piece index");
172 :
173 8 : bid = *getArgReference_bat(stk, pci, pci->retc);
174 :
175 8 : if ((b = BATdescriptor(bid)) == NULL) {
176 0 : throw(MAL, "bat.partition", INTERNAL_BAT_ACCESS);
177 : }
178 8 : step = BATcount(b) / pieces;
179 :
180 8 : lval = idx * step;
181 8 : if (idx == pieces - 1)
182 : hval = BATcount(b);
183 : else
184 4 : hval = lval + step;
185 8 : bn = BATslice(b, lval, hval);
186 8 : BAThseqbase(bn, lval + b->hseqbase);
187 8 : BBPunfix(b->batCacheid);
188 8 : if (bn == NULL) {
189 0 : throw(MAL, "bat.partition", INTERNAL_OBJ_CREATE);
190 : }
191 8 : ret = getArgReference_bat(stk, pci, 0);
192 8 : *ret = bn->batCacheid;
193 8 : BBPkeepref(bn);
194 8 : return MAL_SUCCEED;
195 : }
196 :
197 : static str
198 137528 : CMDBATappend_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
199 : {
200 137528 : bat *r = getArgReference_bat(stk, pci, 0),
201 137528 : *bid = getArgReference_bat(stk, pci, 1);
202 137528 : bit force = *getArgReference_bit(stk, pci, 2);
203 137528 : bit ms = false;
204 137528 : int argc = 3;
205 137528 : if (pci->argc > (argc+1) && getArgType(mb, pci, argc) == TYPE_bit && getArgType(mb, pci, argc + 1) != TYPE_bit) {
206 15 : ms = *getArgReference_bit(stk, pci, argc);
207 15 : argc++;
208 : }
209 137528 : BAT *b;
210 137528 : BUN inputs = (BUN) (pci->argc - argc), number_existing = 0, total = 0;
211 :
212 137528 : (void) cntxt;
213 137528 : if ((b = BATdescriptor(*bid)) == NULL)
214 0 : throw(MAL, "bat.append_bulk", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
215 :
216 137836 : if (inputs > 0) {
217 137836 : number_existing = BATcount(b);
218 :
219 137836 : if (isaBatType(getArgType(mb, pci, argc))) { /* use BATappend for the bulk case */
220 38 : gdk_return rt;
221 38 : if (ms) {
222 16 : int nr = -1;
223 52 : for (int i = argc, args = pci->argc; i < args; i++) {
224 36 : BAT *d = BATdescriptor(*getArgReference_bat(stk, pci, i));
225 36 : if (!d) {
226 0 : BBPunfix(b->batCacheid);
227 0 : throw(MAL, "bat.append_bulk",
228 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
229 : }
230 36 : if (i > argc) {
231 20 : int *t = Tloc(d, 0);
232 57 : for(BUN n = 0; n < BATcount(d); n++)
233 37 : t[n] += nr;
234 : }
235 36 : rt = BATappend(b, d, NULL, force);
236 35 : nr = *(int*)Tloc(b, BATcount(b)-1) + 1;
237 35 : BBPunfix(d->batCacheid);
238 36 : if (rt != GDK_SUCCEED) {
239 0 : BBPunfix(b->batCacheid);
240 0 : throw(MAL, "bat.append_bulk", GDK_EXCEPTION);
241 : }
242 : }
243 : } else
244 70 : for (int i = argc, args = pci->argc; i < args; i++) {
245 49 : BAT *d = BATdescriptor(*getArgReference_bat(stk, pci, i));
246 48 : if (!d) {
247 0 : BBPunfix(b->batCacheid);
248 0 : throw(MAL, "bat.append_bulk",
249 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
250 : }
251 48 : if (mask_cand(d)) {
252 0 : BAT *du = d;
253 0 : d = BATunmask(d);
254 0 : BBPunfix(du->batCacheid);
255 0 : if (!d) {
256 0 : BBPunfix(b->batCacheid);
257 0 : throw(MAL, "bat.append_bulk", GDK_EXCEPTION);
258 : }
259 : }
260 48 : rt = BATappend(b, d, NULL, force);
261 48 : BBPunfix(d->batCacheid);
262 48 : if (rt != GDK_SUCCEED) {
263 0 : BBPunfix(b->batCacheid);
264 0 : throw(MAL, "bat.append_bulk", GDK_EXCEPTION);
265 : }
266 : }
267 : } else {
268 137798 : bool external = ATOMextern(b->ttype);
269 137798 : total = number_existing + inputs;
270 137798 : if (BATextend(b, total) != GDK_SUCCEED) {
271 0 : BBPunfix(b->batCacheid);
272 0 : throw(MAL, "bat.append_bulk", GDK_EXCEPTION);
273 : }
274 882406 : for (int i = argc, args = pci->argc; i < args; i++) {
275 744428 : ptr u = getArgReference(stk, pci, i);
276 743516 : if (external)
277 144841 : u = (ptr) *(ptr *) u;
278 743516 : if (BUNappend(b, u, force) != GDK_SUCCEED) {
279 0 : BBPunfix(b->batCacheid);
280 0 : throw(MAL, "bat.append_bulk", GDK_EXCEPTION);
281 : }
282 : }
283 : }
284 : }
285 :
286 138015 : *r = b->batCacheid;
287 138015 : BBPretain(b->batCacheid);
288 138005 : BBPunfix(b->batCacheid);
289 138005 : return MAL_SUCCEED;
290 : }
291 :
292 : static str
293 1 : CMDBATvacuum(bat *r, const bat *bid)
294 : {
295 1 : BAT *b, *bn;
296 :
297 1 : if ((b = BATdescriptor(*bid)) == NULL)
298 0 : throw(MAL, "bat.vacuum", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
299 1 : if ((bn = COLcopy(b, b->ttype, true, b->batRole)) == NULL) {
300 0 : BBPunfix(b->batCacheid);
301 0 : throw(MAL, "bat.vacuum", GDK_EXCEPTION);
302 : }
303 :
304 1 : *r = bn->batCacheid;
305 1 : BBPkeepref(bn);
306 1 : BBPunfix(b->batCacheid);
307 1 : return MAL_SUCCEED;
308 : }
309 :
310 : #include "mel.h"
311 : mel_func batExtensions_init_funcs[] = {
312 : pattern("bat", "new", CMDBATnew, false, "", args(1,2, batargany("",1),argany("tt",1))),
313 : pattern("bat", "new", CMDBATnew, false, "", args(1,3, batargany("",1),argany("tt",1),arg("size",int))),
314 : pattern("bat", "new", CMDBATnew, false, "", args(1,4, batargany("",1),argany("tt",1),arg("size",lng),arg("persist",bit))),
315 : pattern("bat", "new", CMDBATnew, false, "", args(1,4, batargany("",1),argany("tt",1),arg("size",int),arg("persist",bit))),
316 : pattern("bat", "new", CMDBATnew, false, "Creates a new empty transient BAT, with tail-types as indicated.", args(1,3, batargany("",1),argany("tt",1),arg("size",lng))),
317 : pattern("bat", "new", CMDBATdup, false, "Creates a new empty transient BAT, with tail-type tt and hseqbase and size from the input bat argument.", args(1,3, batargany("",1), argany("tt",1),batargany("i",2))),
318 : pattern("bat", "single", CMDBATsingle, false, "Create a BAT with a single element", args(1,2, batargany("",1),argany("val",1))),
319 : pattern("bat", "partition", CMDBATpartition, false, "Create a series of slices over the BAT argument. The BUNs are distributed evenly.", args(1,2, batvarargany("",1),batargany("b",1))),
320 : pattern("bat", "partition", CMDBATpartition2, false, "Create the n-th slice over the BAT broken into several pieces.", args(1,4, batargany("",1),batargany("b",1),arg("pieces",int),arg("n",int))),
321 : pattern("bat", "appendBulk", CMDBATappend_bulk, false, "append the arguments ins to i", args(1,4, batargany("",1), batargany("i",1),arg("force",bit),varargany("ins",1))),
322 : pattern("bat", "appendBulk", CMDBATappend_bulk, false, "append the arguments ins to i", args(1,4, batargany("",1), batargany("i",1),arg("force",bit),batvarargany("ins",1))),
323 : pattern("bat", "appendBulk", CMDBATappend_bulk, false, "append the arguments ins to i", args(1,5, batargany("",1), batargany("i",1),arg("force",bit),arg("inc",bit), batvarargany("ins",1))),
324 : command("bat", "vacuum", CMDBATvacuum, false, "", args(1,2, batarg("",str),batarg("b",str))),
325 : { .imp=NULL }
326 : };
327 : #include "mal_import.h"
328 : #ifdef _MSC_VER
329 : #undef read
330 : #pragma section(".CRT$XCU",read)
331 : #endif
332 351 : LIB_STARTUP_FUNC(init_batExtensions_mal)
333 351 : { mal_module("batExtensions", NULL, batExtensions_init_funcs); }
|
