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 : /*
14 : * Martin Kersten
15 : * Multiple association tables
16 : * A MAT is a convenient way to deal represent horizontal fragmented
17 : * tables. It combines the definitions of several, type compatible
18 : * BATs under a single name.
19 : * It is produced by the mitosis optimizer and the operations
20 : * are the target of the mergetable optimizer.
21 : *
22 : * The MAT is materialized when the operations
23 : * can not deal with the components individually,
24 : * or the incremental operation is not supported.
25 : * Normally all mat.new() operations are removed by the
26 : * mergetable optimizer.
27 : * In case a mat.new() is retained in the code, then it will
28 : * behave as a mat.pack();
29 : *
30 : * The primitives below are chosen to accommodate the SQL
31 : * front-end to produce reasonable efficient code.
32 : */
33 : #include "monetdb_config.h"
34 : #include "mal_resolve.h"
35 : #include "mal_exception.h"
36 : #include "mal_interpreter.h"
37 :
38 : /*
39 : * The pack is an ordinary multi BAT insert. Oid synchronistion
40 : * between pieces should be ensured by the code generators.
41 : * The pack operation could be quite expensive, because it
42 : * may create a really large BAT.
43 : * The slice over a mat helps to avoid constructing intermediates
44 : * that are subsequently reduced.
45 : * Contrary to most operations, NIL arguments are skipped and
46 : * do not produce RUNTIME_OBJECT_MISSING.
47 : */
48 : static str
49 82268 : MATpackInternal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
50 : {
51 82268 : int i;
52 82268 : bat *ret = getArgReference_bat(stk, p, 0);
53 82268 : BAT *b, *bn = NULL;
54 82268 : BUN cap = 0;
55 82268 : int tt = TYPE_any;
56 82268 : int rt = getArgType(mb, p, 0), unmask = 0;
57 82268 : (void) cntxt;
58 :
59 411033 : for (i = 1; i < p->argc; i++) {
60 328795 : bat bid = stk->stk[getArg(p, i)].val.bval;
61 328795 : b = BBPquickdesc(bid);
62 328765 : if (b) {
63 328765 : if (tt == TYPE_any)
64 82257 : tt = b->ttype;
65 328765 : if ((tt != TYPE_void && b->ttype != TYPE_void
66 318397 : && b->ttype != TYPE_msk) && tt != b->ttype)
67 0 : throw(MAL, "mat.pack", "incompatible arguments");
68 328765 : cap += BATcount(b);
69 : }
70 : }
71 82238 : if (tt == TYPE_any) {
72 0 : *ret = bat_nil;
73 0 : return MAL_SUCCEED;
74 : }
75 :
76 82238 : if (tt == TYPE_msk && rt == newBatType(TYPE_oid)) {
77 0 : tt = TYPE_oid;
78 0 : unmask = 1;
79 : }
80 82238 : bn = COLnew(0, tt, cap, TRANSIENT);
81 82266 : if (bn == NULL)
82 0 : throw(MAL, "mat.pack", SQLSTATE(HY013) MAL_MALLOC_FAIL);
83 :
84 411202 : for (i = 1; i < p->argc; i++) {
85 328941 : if (!(b = BATdescriptor(stk->stk[getArg(p, i)].val.ival))) {
86 0 : BBPreclaim(bn);
87 0 : throw(MAL, "mat.pack", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
88 : }
89 328711 : if ((unmask && b->ttype == TYPE_msk) || mask_cand(b)) {
90 690 : BAT *ob = b;
91 690 : b = BATunmask(b);
92 690 : BBPunfix(ob->batCacheid);
93 690 : if (!b) {
94 0 : BBPreclaim(bn);
95 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
96 : }
97 : }
98 328711 : if (BATcount(bn) == 0) {
99 82972 : BAThseqbase(bn, b->hseqbase);
100 82981 : BATtseqbase(bn, b->tseqbase);
101 : }
102 328720 : if (BATappend(bn, b, NULL, false) != GDK_SUCCEED) {
103 0 : BBPreclaim(bn);
104 0 : BBPunfix(b->batCacheid);
105 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
106 : }
107 328946 : BBPunfix(b->batCacheid);
108 : }
109 82261 : if (bn->tnil && bn->tnonil) {
110 0 : BBPreclaim(bn);
111 0 : throw(MAL, "mat.pack",
112 : "INTERNAL ERROR" "bn->tnil or bn->tnonil fails ");
113 : }
114 82261 : *ret = bn->batCacheid;
115 82261 : BBPkeepref(bn);
116 82261 : return MAL_SUCCEED;
117 : }
118 :
119 : /*
120 : * Enable incremental packing. The SQL front-end requires
121 : * fixed oid sequences.
122 : */
123 : static str
124 745291 : MATpackIncrement(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
125 : {
126 745291 : bat *ret = getArgReference_bat(stk, p, 0);
127 745291 : int pieces;
128 745291 : BAT *b, *bb, *bn;
129 745291 : size_t newsize;
130 :
131 745291 : (void) cntxt;
132 745291 : b = BATdescriptor(stk->stk[getArg(p, 1)].val.ival);
133 745277 : if (b == NULL)
134 0 : throw(MAL, "mat.pack", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
135 :
136 745277 : if (getArgType(mb, p, 2) == TYPE_int) {
137 : /* first step, estimate with some slack */
138 191576 : pieces = stk->stk[getArg(p, 2)].val.ival;
139 191576 : int tt = ATOMtype(b->ttype);
140 191576 : if (b->ttype == TYPE_msk)
141 0 : tt = TYPE_oid;
142 191576 : bn = COLnew(b->hseqbase, tt, (BUN) (1.2 * BATcount(b) * pieces),
143 : TRANSIENT);
144 191575 : if (bn == NULL) {
145 0 : BBPunfix(b->batCacheid);
146 0 : throw(MAL, "mat.pack", SQLSTATE(HY013) MAL_MALLOC_FAIL);
147 : }
148 : /* allocate enough space for the vheap, but not for strings,
149 : * since BATappend does clever things for strings, and not for
150 : * vheap views since they may well get shared */
151 191575 : if (b->tvheap && b->tvheap->parentid == b->batCacheid && bn->tvheap
152 51688 : && ATOMstorage(b->ttype) != TYPE_str) {
153 46 : newsize = b->tvheap->size * pieces;
154 46 : if (HEAPextend(bn->tvheap, newsize, true) != GDK_SUCCEED) {
155 0 : BBPunfix(b->batCacheid);
156 0 : BBPreclaim(bn);
157 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
158 : }
159 : }
160 191575 : BATtseqbase(bn, b->tseqbase);
161 191577 : if (b->ttype == TYPE_msk || mask_cand(b)) {
162 0 : BAT *ob = b;
163 0 : b = BATunmask(b);
164 0 : BBPunfix(ob->batCacheid);
165 0 : if (!b) {
166 0 : BBPreclaim(bn);
167 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
168 : }
169 : }
170 191577 : if (BATappend(bn, b, NULL, false) != GDK_SUCCEED) {
171 0 : BBPreclaim(bn);
172 0 : BBPunfix(b->batCacheid);
173 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
174 : }
175 191571 : bn->tunique_est = b->tunique_est;
176 191571 : bn->unused = (pieces - 1); /* misuse "unused" field */
177 191571 : BBPunfix(b->batCacheid);
178 191561 : if (bn->tnil && bn->tnonil) {
179 0 : BBPreclaim(bn);
180 0 : throw(MAL, "mat.pack",
181 0 : "INTERNAL ERROR" " bn->tnil %d bn->tnonil %d", bn->tnil,
182 0 : bn->tnonil);
183 : }
184 191561 : *ret = bn->batCacheid;
185 191561 : BBPretain(bn->batCacheid);
186 191558 : BBPunfix(bn->batCacheid);
187 : } else {
188 : /* remaining steps */
189 553701 : if (!(bb = BATdescriptor(stk->stk[getArg(p, 2)].val.ival))) {
190 0 : BBPunfix(b->batCacheid);
191 0 : throw(MAL, "mat.pack", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
192 : }
193 553524 : if (bb->ttype == TYPE_msk || mask_cand(bb)) {
194 0 : BAT *obb = bb;
195 0 : bb = BATunmask(bb);
196 0 : BBPunfix(obb->batCacheid);
197 0 : if (!bb) {
198 0 : BBPunfix(b->batCacheid);
199 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
200 : }
201 : }
202 553524 : if (BATcount(b) == 0) {
203 303868 : BAThseqbase(b, bb->hseqbase);
204 303981 : BATtseqbase(b, bb->tseqbase);
205 : }
206 553576 : if (BATappend(b, bb, NULL, false) != GDK_SUCCEED) {
207 0 : BBPunfix(bb->batCacheid);
208 0 : BBPunfix(b->batCacheid);
209 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
210 : }
211 553678 : BBPunfix(bb->batCacheid);
212 553626 : b->tunique_est += bb->tunique_est;
213 553626 : b->unused--;
214 553626 : if (b->unused == 0 && (b = BATsetaccess(b, BAT_READ)) == NULL)
215 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
216 553630 : if (b->tnil && b->tnonil) {
217 0 : BBPunfix(b->batCacheid);
218 0 : throw(MAL, "mat.pack",
219 : "INTERNAL ERROR" " b->tnil or b->tnonil fails ");
220 : }
221 553630 : *ret = b->batCacheid;
222 553630 : BBPretain(b->batCacheid);
223 553669 : BBPunfix(b->batCacheid);
224 : }
225 : return MAL_SUCCEED;
226 : }
227 :
228 : static str
229 82268 : MATpack(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
230 : {
231 82268 : return MATpackInternal(cntxt, mb, stk, p);
232 : }
233 :
234 : static str
235 322809 : MATpackValues(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
236 : {
237 322809 : int i, type, first = 1;
238 322809 : bat *ret;
239 322809 : BAT *bn;
240 :
241 322809 : (void) cntxt;
242 322809 : type = getArgType(mb, p, first);
243 322809 : bn = COLnew(0, type, p->argc, TRANSIENT);
244 322759 : if (bn == NULL)
245 0 : throw(MAL, "mat.pack", SQLSTATE(HY013) MAL_MALLOC_FAIL);
246 :
247 322759 : if (ATOMextern(type)) {
248 1013779 : for (i = first; i < p->argc; i++)
249 821292 : if (BUNappend(bn, stk->stk[getArg(p, i)].val.pval, false) != GDK_SUCCEED)
250 0 : goto bailout;
251 : } else {
252 688739 : for (i = first; i < p->argc; i++)
253 558608 : if (BUNappend(bn, getArgReference(stk, p, i), false) != GDK_SUCCEED)
254 0 : goto bailout;
255 : }
256 322618 : ret = getArgReference_bat(stk, p, 0);
257 322618 : *ret = bn->batCacheid;
258 322618 : BBPkeepref(bn);
259 322618 : return MAL_SUCCEED;
260 0 : bailout:
261 0 : BBPreclaim(bn);
262 0 : throw(MAL, "mat.pack", GDK_EXCEPTION);
263 : }
264 :
265 : #include "mel.h"
266 : mel_func mat_init_funcs[] = {
267 : pattern("mat", "new", MATpack, false, "Define a Merge Association Table (MAT). Fall back to the pack operation\nwhen this is called ", args(1,2, batargany("",1),batvarargany("b",1))),
268 : pattern("bat", "pack", MATpackValues, false, "Materialize the values into a BAT. Avoiding a clash with mat.pack() in mergetable", args(1,2, batargany("",1),varargany("",1))),
269 : pattern("mat", "pack", MATpackValues, false, "Materialize the MAT (of values) into a BAT", args(1,2, batargany("",1),varargany("",1))),
270 : pattern("mat", "pack", MATpack, false, "Materialize the MAT into a BAT", args(1,2, batargany("",1),batvarargany("b",1))),
271 : pattern("mat", "packIncrement", MATpackIncrement, false, "Prepare incremental mat pack", args(1,3, batargany("",1),batargany("b",1),arg("pieces",int))),
272 : pattern("mat", "packIncrement", MATpackIncrement, false, "Prepare incremental mat pack", args(1,3, batargany("",1),batargany("b",1),batargany("c",1))),
273 : { .imp=NULL }
274 : };
275 : #include "mal_import.h"
276 : #ifdef _MSC_VER
277 : #undef read
278 : #pragma section(".CRT$XCU",read)
279 : #endif
280 323 : LIB_STARTUP_FUNC(init_mat_mal)
281 323 : { mal_module("mat", NULL, mat_init_funcs); }
|
