@loaders.gl/sql 5.0.0-alpha.1 → 5.0.0-alpha.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +14 -3
- package/README.md +107 -0
- package/dist/arrow-query.cjs +1404 -0
- package/dist/arrow-query.cjs.map +6 -0
- package/dist/arrow-query.d.ts +5 -0
- package/dist/arrow-query.d.ts.map +1 -0
- package/dist/arrow-query.js +6 -0
- package/dist/arrow-query.js.map +1 -0
- package/dist/arrow-table-source.d.ts +27 -0
- package/dist/arrow-table-source.d.ts.map +1 -0
- package/dist/arrow-table-source.js +79 -0
- package/dist/arrow-table-source.js.map +1 -0
- package/dist/bind-sql-predicate.d.ts +4 -0
- package/dist/bind-sql-predicate.d.ts.map +1 -0
- package/dist/bind-sql-predicate.js +11 -0
- package/dist/bind-sql-predicate.js.map +1 -0
- package/dist/compile-table-query.d.ts +55 -0
- package/dist/compile-table-query.d.ts.map +1 -0
- package/dist/compile-table-query.js +255 -0
- package/dist/compile-table-query.js.map +1 -0
- package/dist/duckdb-sql-source.d.ts +51 -3
- package/dist/duckdb-sql-source.d.ts.map +1 -1
- package/dist/duckdb-sql-source.js +21 -7
- package/dist/duckdb-sql-source.js.map +1 -1
- package/dist/index.cjs +3352 -37
- package/dist/index.cjs.map +3 -4
- package/dist/index.d.ts +16 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +9 -0
- package/dist/index.js.map +1 -1
- package/dist/parse-sql-predicate.d.ts +10 -0
- package/dist/parse-sql-predicate.d.ts.map +1 -0
- package/dist/parse-sql-predicate.js +322 -0
- package/dist/parse-sql-predicate.js.map +1 -0
- package/dist/query-arrow-table.d.ts +83 -0
- package/dist/query-arrow-table.d.ts.map +1 -0
- package/dist/query-arrow-table.js +663 -0
- package/dist/query-arrow-table.js.map +1 -0
- package/dist/snowflake-sql-source.d.ts +51 -3
- package/dist/snowflake-sql-source.d.ts.map +1 -1
- package/dist/snowflake-sql-source.js +9 -6
- package/dist/snowflake-sql-source.js.map +1 -1
- package/dist/sql-predicate-schema.d.ts +156 -0
- package/dist/sql-predicate-schema.d.ts.map +1 -0
- package/dist/sql-predicate-schema.js +226 -0
- package/dist/sql-predicate-schema.js.map +1 -0
- package/dist/sql-predicate-types.d.ts +45 -0
- package/dist/sql-predicate-types.d.ts.map +1 -0
- package/dist/sql-predicate-types.js +9 -0
- package/dist/sql-predicate-types.js.map +1 -0
- package/dist/sql-predicate-zod.cjs +54 -0
- package/dist/sql-predicate-zod.cjs.map +6 -0
- package/dist/sql-predicate-zod.d.ts +11 -0
- package/dist/sql-predicate-zod.d.ts.map +1 -0
- package/dist/sql-predicate-zod.js +45 -0
- package/dist/sql-predicate-zod.js.map +1 -0
- package/dist/sql-predicate.cjs +607 -0
- package/dist/sql-predicate.cjs.map +6 -0
- package/dist/sql-predicate.d.ts +6 -0
- package/dist/sql-predicate.d.ts.map +1 -0
- package/dist/sql-predicate.js +8 -0
- package/dist/sql-predicate.js.map +1 -0
- package/dist/sql-source.d.ts +16 -3
- package/dist/sql-source.d.ts.map +1 -1
- package/dist/sql-source.js +34 -5
- package/dist/sql-source.js.map +1 -1
- package/dist/sql-types.d.ts +3 -0
- package/dist/sql-types.d.ts.map +1 -1
- package/dist/table-query-capabilities.d.ts +6 -0
- package/dist/table-query-capabilities.d.ts.map +1 -0
- package/dist/table-query-capabilities.js +26 -0
- package/dist/table-query-capabilities.js.map +1 -0
- package/dist/table-query.cjs +286 -0
- package/dist/table-query.cjs.map +6 -0
- package/dist/table-query.d.ts +29 -0
- package/dist/table-query.d.ts.map +1 -0
- package/dist/table-query.js +30 -0
- package/dist/table-query.js.map +1 -0
- package/package.json +45 -8
- package/src/arrow-query.ts +17 -0
- package/src/arrow-table-source.ts +111 -0
- package/src/bind-sql-predicate.ts +21 -0
- package/src/compile-table-query.ts +354 -0
- package/src/duckdb-sql-source.ts +30 -6
- package/src/index.ts +57 -0
- package/src/parse-sql-predicate.ts +381 -0
- package/src/query-arrow-table.ts +846 -0
- package/src/snowflake-sql-source.ts +8 -5
- package/src/sql-predicate-schema.ts +251 -0
- package/src/sql-predicate-types.ts +87 -0
- package/src/sql-predicate-zod.ts +52 -0
- package/src/sql-predicate.ts +28 -0
- package/src/sql-source.ts +40 -5
- package/src/sql-types.ts +4 -0
- package/src/table-query-capabilities.ts +29 -0
- package/src/table-query.ts +78 -0
|
@@ -0,0 +1,1404 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __create = Object.create;
|
|
3
|
+
var __defProp = Object.defineProperty;
|
|
4
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
7
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
+
var __export = (target, all) => {
|
|
9
|
+
for (var name in all)
|
|
10
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
11
|
+
};
|
|
12
|
+
var __copyProps = (to, from, except, desc) => {
|
|
13
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
14
|
+
for (let key of __getOwnPropNames(from))
|
|
15
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
16
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
17
|
+
}
|
|
18
|
+
return to;
|
|
19
|
+
};
|
|
20
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
21
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
22
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
23
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
24
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
25
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
26
|
+
mod
|
|
27
|
+
));
|
|
28
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
29
|
+
|
|
30
|
+
// dist/arrow-query.js
|
|
31
|
+
var arrow_query_exports = {};
|
|
32
|
+
__export(arrow_query_exports, {
|
|
33
|
+
ARROW_TABLE_QUERY_CAPABILITIES: () => ARROW_TABLE_QUERY_CAPABILITIES,
|
|
34
|
+
getSQLPredicateColumnNames: () => getSQLPredicateColumnNames,
|
|
35
|
+
planTableQuery: () => planTableQuery2,
|
|
36
|
+
queryArrowTable: () => queryArrowTable
|
|
37
|
+
});
|
|
38
|
+
module.exports = __toCommonJS(arrow_query_exports);
|
|
39
|
+
|
|
40
|
+
// dist/query-arrow-table.js
|
|
41
|
+
var arrow4 = __toESM(require("apache-arrow"), 1);
|
|
42
|
+
|
|
43
|
+
// ../schema-utils/src/lib/schema/data-type.ts
|
|
44
|
+
var import_types = require("@math.gl/types");
|
|
45
|
+
function getDataTypeFromValue(value, defaultNumberType = "float32") {
|
|
46
|
+
if (value instanceof Date) {
|
|
47
|
+
return "date-millisecond";
|
|
48
|
+
}
|
|
49
|
+
if (typeof value === "number") {
|
|
50
|
+
return defaultNumberType;
|
|
51
|
+
}
|
|
52
|
+
if (typeof value === "boolean") {
|
|
53
|
+
return "bool";
|
|
54
|
+
}
|
|
55
|
+
if (typeof value === "string") {
|
|
56
|
+
return "utf8";
|
|
57
|
+
}
|
|
58
|
+
if (value === null || value === "undefined") {
|
|
59
|
+
return "null";
|
|
60
|
+
}
|
|
61
|
+
return "null";
|
|
62
|
+
}
|
|
63
|
+
function getDataTypeFromArray(array) {
|
|
64
|
+
let type = getDataTypeFromTypedArray(array);
|
|
65
|
+
if (type !== "null") {
|
|
66
|
+
return { type, nullable: false };
|
|
67
|
+
}
|
|
68
|
+
if (array.length > 0) {
|
|
69
|
+
type = getDataTypeFromValue(array[0]);
|
|
70
|
+
return { type, nullable: true };
|
|
71
|
+
}
|
|
72
|
+
return { type: "null", nullable: true };
|
|
73
|
+
}
|
|
74
|
+
function getDataTypeFromTypedArray(array) {
|
|
75
|
+
if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
|
|
76
|
+
return "float16";
|
|
77
|
+
}
|
|
78
|
+
switch (array.constructor) {
|
|
79
|
+
case Int8Array:
|
|
80
|
+
return "int8";
|
|
81
|
+
case Uint8Array:
|
|
82
|
+
case Uint8ClampedArray:
|
|
83
|
+
return "uint8";
|
|
84
|
+
case Int16Array:
|
|
85
|
+
return "int16";
|
|
86
|
+
case Uint16Array:
|
|
87
|
+
return "uint16";
|
|
88
|
+
case Int32Array:
|
|
89
|
+
return "int32";
|
|
90
|
+
case Uint32Array:
|
|
91
|
+
return "uint32";
|
|
92
|
+
case BigInt64Array:
|
|
93
|
+
return "int64";
|
|
94
|
+
case BigUint64Array:
|
|
95
|
+
return "uint64";
|
|
96
|
+
case Float32Array:
|
|
97
|
+
return "float32";
|
|
98
|
+
case Float64Array:
|
|
99
|
+
return "float64";
|
|
100
|
+
default:
|
|
101
|
+
return "null";
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
// ../schema-utils/src/lib/schema/convert-arrow-schema.ts
|
|
106
|
+
var arrow = __toESM(require("apache-arrow"), 1);
|
|
107
|
+
function convertArrowToSchema(arrowSchema) {
|
|
108
|
+
return serializeArrowSchema(arrowSchema);
|
|
109
|
+
}
|
|
110
|
+
function serializeArrowSchema(arrowSchema) {
|
|
111
|
+
return {
|
|
112
|
+
fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
|
|
113
|
+
metadata: serializeArrowMetadata(arrowSchema.metadata)
|
|
114
|
+
};
|
|
115
|
+
}
|
|
116
|
+
function serializeArrowMetadata(arrowMetadata) {
|
|
117
|
+
return Object.fromEntries(arrowMetadata);
|
|
118
|
+
}
|
|
119
|
+
function serializeArrowField(field) {
|
|
120
|
+
return {
|
|
121
|
+
name: field.name,
|
|
122
|
+
type: serializeArrowType(field.type),
|
|
123
|
+
nullable: field.nullable,
|
|
124
|
+
metadata: serializeArrowMetadata(field.metadata)
|
|
125
|
+
};
|
|
126
|
+
}
|
|
127
|
+
function serializeArrowType(arrowType) {
|
|
128
|
+
if (isArrowViewType(arrowType, "BinaryView")) {
|
|
129
|
+
return "binary-view";
|
|
130
|
+
}
|
|
131
|
+
if (isArrowViewType(arrowType, "Utf8View")) {
|
|
132
|
+
return "utf8-view";
|
|
133
|
+
}
|
|
134
|
+
if (isOptionalArrowType(arrowType, "LargeList")) {
|
|
135
|
+
const largeListType = arrowType;
|
|
136
|
+
return {
|
|
137
|
+
type: "large-list",
|
|
138
|
+
children: [serializeArrowField(largeListType.valueField)]
|
|
139
|
+
};
|
|
140
|
+
}
|
|
141
|
+
switch (arrowType.constructor) {
|
|
142
|
+
case arrow.Null:
|
|
143
|
+
return "null";
|
|
144
|
+
case arrow.Binary:
|
|
145
|
+
return "binary";
|
|
146
|
+
case arrow.FixedSizeBinary:
|
|
147
|
+
return {
|
|
148
|
+
type: "fixed-size-binary",
|
|
149
|
+
byteWidth: arrowType.byteWidth
|
|
150
|
+
};
|
|
151
|
+
case arrow.Bool:
|
|
152
|
+
return "bool";
|
|
153
|
+
case arrow.Int:
|
|
154
|
+
const intType = arrowType;
|
|
155
|
+
return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
|
|
156
|
+
case arrow.Int8:
|
|
157
|
+
return "int8";
|
|
158
|
+
case arrow.Int16:
|
|
159
|
+
return "int16";
|
|
160
|
+
case arrow.Int32:
|
|
161
|
+
return "int32";
|
|
162
|
+
case arrow.Int64:
|
|
163
|
+
return "int64";
|
|
164
|
+
case arrow.Uint8:
|
|
165
|
+
return "uint8";
|
|
166
|
+
case arrow.Uint16:
|
|
167
|
+
return "uint16";
|
|
168
|
+
case arrow.Uint32:
|
|
169
|
+
return "uint32";
|
|
170
|
+
case arrow.Uint64:
|
|
171
|
+
return "uint64";
|
|
172
|
+
case arrow.Float:
|
|
173
|
+
const precision = arrowType.precision;
|
|
174
|
+
switch (precision) {
|
|
175
|
+
case arrow.Precision.HALF:
|
|
176
|
+
return "float16";
|
|
177
|
+
case arrow.Precision.SINGLE:
|
|
178
|
+
return "float32";
|
|
179
|
+
case arrow.Precision.DOUBLE:
|
|
180
|
+
return "float64";
|
|
181
|
+
default:
|
|
182
|
+
return "float16";
|
|
183
|
+
}
|
|
184
|
+
case arrow.Float16:
|
|
185
|
+
return "float16";
|
|
186
|
+
case arrow.Float32:
|
|
187
|
+
return "float32";
|
|
188
|
+
case arrow.Float64:
|
|
189
|
+
return "float64";
|
|
190
|
+
case arrow.Utf8:
|
|
191
|
+
return "utf8";
|
|
192
|
+
case arrow.Decimal:
|
|
193
|
+
const decimal = arrowType;
|
|
194
|
+
return {
|
|
195
|
+
type: "decimal",
|
|
196
|
+
bitWidth: decimal.bitWidth,
|
|
197
|
+
precision: decimal.precision,
|
|
198
|
+
scale: decimal.scale
|
|
199
|
+
};
|
|
200
|
+
case arrow.Date_:
|
|
201
|
+
const dateUnit = arrowType.unit;
|
|
202
|
+
return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
|
|
203
|
+
case arrow.DateDay:
|
|
204
|
+
return "date-day";
|
|
205
|
+
case arrow.DateMillisecond:
|
|
206
|
+
return "date-millisecond";
|
|
207
|
+
case arrow.Time:
|
|
208
|
+
const timeUnit = arrowType.unit;
|
|
209
|
+
switch (timeUnit) {
|
|
210
|
+
case arrow.TimeUnit.SECOND:
|
|
211
|
+
return "time-second";
|
|
212
|
+
case arrow.TimeUnit.MILLISECOND:
|
|
213
|
+
return "time-millisecond";
|
|
214
|
+
case arrow.TimeUnit.MICROSECOND:
|
|
215
|
+
return "time-microsecond";
|
|
216
|
+
case arrow.TimeUnit.NANOSECOND:
|
|
217
|
+
return "time-nanosecond";
|
|
218
|
+
default:
|
|
219
|
+
return "time-second";
|
|
220
|
+
}
|
|
221
|
+
case arrow.TimeMillisecond:
|
|
222
|
+
return "time-millisecond";
|
|
223
|
+
case arrow.TimeSecond:
|
|
224
|
+
return "time-second";
|
|
225
|
+
case arrow.TimeMicrosecond:
|
|
226
|
+
return "time-microsecond";
|
|
227
|
+
case arrow.TimeNanosecond:
|
|
228
|
+
return "time-nanosecond";
|
|
229
|
+
case arrow.Timestamp:
|
|
230
|
+
const timeStampUnit = arrowType.unit;
|
|
231
|
+
switch (timeStampUnit) {
|
|
232
|
+
case arrow.TimeUnit.SECOND:
|
|
233
|
+
return "timestamp-second";
|
|
234
|
+
case arrow.TimeUnit.MILLISECOND:
|
|
235
|
+
return "timestamp-millisecond";
|
|
236
|
+
case arrow.TimeUnit.MICROSECOND:
|
|
237
|
+
return "timestamp-microsecond";
|
|
238
|
+
case arrow.TimeUnit.NANOSECOND:
|
|
239
|
+
return "timestamp-nanosecond";
|
|
240
|
+
default:
|
|
241
|
+
return "timestamp-second";
|
|
242
|
+
}
|
|
243
|
+
case arrow.TimestampSecond:
|
|
244
|
+
return "timestamp-second";
|
|
245
|
+
case arrow.TimestampMillisecond:
|
|
246
|
+
return "timestamp-millisecond";
|
|
247
|
+
case arrow.TimestampMicrosecond:
|
|
248
|
+
return "timestamp-microsecond";
|
|
249
|
+
case arrow.TimestampNanosecond:
|
|
250
|
+
return "timestamp-nanosecond";
|
|
251
|
+
case arrow.Interval:
|
|
252
|
+
const intervalUnit = arrowType.unit;
|
|
253
|
+
switch (intervalUnit) {
|
|
254
|
+
case arrow.IntervalUnit.DAY_TIME:
|
|
255
|
+
return "interval-daytime";
|
|
256
|
+
case arrow.IntervalUnit.YEAR_MONTH:
|
|
257
|
+
return "interval-yearmonth";
|
|
258
|
+
default:
|
|
259
|
+
return "interval-daytime";
|
|
260
|
+
}
|
|
261
|
+
case arrow.IntervalDayTime:
|
|
262
|
+
return "interval-daytime";
|
|
263
|
+
case arrow.IntervalYearMonth:
|
|
264
|
+
return "interval-yearmonth";
|
|
265
|
+
case arrow.Map_:
|
|
266
|
+
const mapType = arrowType;
|
|
267
|
+
return {
|
|
268
|
+
type: "map",
|
|
269
|
+
keysSorted: mapType.keysSorted,
|
|
270
|
+
children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
|
|
271
|
+
};
|
|
272
|
+
case arrow.List:
|
|
273
|
+
const listType = arrowType;
|
|
274
|
+
const listField = listType.valueField;
|
|
275
|
+
return {
|
|
276
|
+
type: "list",
|
|
277
|
+
children: [serializeArrowField(listField)]
|
|
278
|
+
};
|
|
279
|
+
case arrow.FixedSizeList:
|
|
280
|
+
const fixedSizeList = arrowType;
|
|
281
|
+
return {
|
|
282
|
+
type: "fixed-size-list",
|
|
283
|
+
listSize: fixedSizeList.listSize,
|
|
284
|
+
children: [serializeArrowField(fixedSizeList.children[0])]
|
|
285
|
+
};
|
|
286
|
+
case arrow.Struct:
|
|
287
|
+
const structType = arrowType;
|
|
288
|
+
return {
|
|
289
|
+
type: "struct",
|
|
290
|
+
children: structType.children.map((arrowField) => serializeArrowField(arrowField))
|
|
291
|
+
};
|
|
292
|
+
case arrow.SparseUnion:
|
|
293
|
+
case arrow.DenseUnion:
|
|
294
|
+
const unionType = arrowType;
|
|
295
|
+
return {
|
|
296
|
+
type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
|
|
297
|
+
typeIds: unionType.typeIds,
|
|
298
|
+
children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
|
|
299
|
+
typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
|
|
300
|
+
};
|
|
301
|
+
case arrow.Dictionary:
|
|
302
|
+
const dictionaryType = arrowType;
|
|
303
|
+
return {
|
|
304
|
+
type: "dictionary",
|
|
305
|
+
id: dictionaryType.id,
|
|
306
|
+
indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
|
|
307
|
+
dictionary: serializeArrowType(dictionaryType.dictionary),
|
|
308
|
+
isOrdered: dictionaryType.isOrdered
|
|
309
|
+
};
|
|
310
|
+
default:
|
|
311
|
+
throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
|
|
312
|
+
}
|
|
313
|
+
}
|
|
314
|
+
function getOptionalArrowConstructor(typeName) {
|
|
315
|
+
return arrow[typeName];
|
|
316
|
+
}
|
|
317
|
+
function isArrowViewType(arrowType, viewTypeName) {
|
|
318
|
+
const constructor = getOptionalArrowConstructor(viewTypeName);
|
|
319
|
+
if (constructor && arrowType instanceof constructor) {
|
|
320
|
+
return true;
|
|
321
|
+
}
|
|
322
|
+
const guards = arrow.DataType;
|
|
323
|
+
const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
|
|
324
|
+
return Boolean(guard == null ? void 0 : guard(arrowType));
|
|
325
|
+
}
|
|
326
|
+
function isOptionalArrowType(arrowType, typeName) {
|
|
327
|
+
const constructor = getOptionalArrowConstructor(typeName);
|
|
328
|
+
return Boolean(constructor && arrowType instanceof constructor);
|
|
329
|
+
}
|
|
330
|
+
function serializeArrowDictionaryKeyType(arrowType) {
|
|
331
|
+
if (arrowType instanceof arrow.Int) {
|
|
332
|
+
const prefix = arrowType.isSigned ? "int" : "uint";
|
|
333
|
+
const keyType = `${prefix}${arrowType.bitWidth}`;
|
|
334
|
+
if (isSchemaDictionaryKeyType(keyType)) {
|
|
335
|
+
return keyType;
|
|
336
|
+
}
|
|
337
|
+
}
|
|
338
|
+
switch (arrowType.constructor) {
|
|
339
|
+
case arrow.Int8:
|
|
340
|
+
return "int8";
|
|
341
|
+
case arrow.Int16:
|
|
342
|
+
return "int16";
|
|
343
|
+
case arrow.Int32:
|
|
344
|
+
return "int32";
|
|
345
|
+
case arrow.Uint8:
|
|
346
|
+
return "uint8";
|
|
347
|
+
case arrow.Uint16:
|
|
348
|
+
return "uint16";
|
|
349
|
+
case arrow.Uint32:
|
|
350
|
+
return "uint32";
|
|
351
|
+
default:
|
|
352
|
+
throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
|
|
353
|
+
}
|
|
354
|
+
}
|
|
355
|
+
function isSchemaDictionaryKeyType(keyType) {
|
|
356
|
+
return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
// ../schema-utils/src/lib/schema/deduce-table-schema.ts
|
|
360
|
+
function deduceTableSchema(table) {
|
|
361
|
+
switch (table.shape) {
|
|
362
|
+
case "array-row-table":
|
|
363
|
+
case "object-row-table":
|
|
364
|
+
return deduceSchemaFromRows(table.data);
|
|
365
|
+
case "geojson-table":
|
|
366
|
+
return deduceSchemaFromGeoJSON(table.features);
|
|
367
|
+
case "columnar-table":
|
|
368
|
+
return deduceSchemaFromColumns(table.data);
|
|
369
|
+
case "arrow-table":
|
|
370
|
+
default:
|
|
371
|
+
throw new Error("Deduce schema");
|
|
372
|
+
}
|
|
373
|
+
}
|
|
374
|
+
function deduceSchemaFromColumns(columnarTable) {
|
|
375
|
+
const fields = [];
|
|
376
|
+
for (const [columnName, column] of Object.entries(columnarTable)) {
|
|
377
|
+
const field = deduceFieldFromColumn(column, columnName);
|
|
378
|
+
fields.push(field);
|
|
379
|
+
}
|
|
380
|
+
return { fields, metadata: {} };
|
|
381
|
+
}
|
|
382
|
+
function deduceSchemaFromRows(rowTable) {
|
|
383
|
+
if (!rowTable.length) {
|
|
384
|
+
throw new Error("deduce from empty table");
|
|
385
|
+
}
|
|
386
|
+
const fields = [];
|
|
387
|
+
const row0 = rowTable[0];
|
|
388
|
+
for (const [columnName, value] of Object.entries(row0)) {
|
|
389
|
+
fields.push(deduceFieldFromValue(value, columnName));
|
|
390
|
+
}
|
|
391
|
+
return { fields, metadata: {} };
|
|
392
|
+
}
|
|
393
|
+
function deduceSchemaFromGeoJSON(features) {
|
|
394
|
+
if (!features.length) {
|
|
395
|
+
throw new Error("deduce from empty table");
|
|
396
|
+
}
|
|
397
|
+
const fields = [];
|
|
398
|
+
const row0 = features[0].properties || {};
|
|
399
|
+
for (const [columnName, value] of Object.entries(row0)) {
|
|
400
|
+
fields.push(deduceFieldFromValue(value, columnName));
|
|
401
|
+
}
|
|
402
|
+
return { fields, metadata: {} };
|
|
403
|
+
}
|
|
404
|
+
function deduceFieldFromColumn(column, name) {
|
|
405
|
+
if (ArrayBuffer.isView(column)) {
|
|
406
|
+
const type = getDataTypeFromArray(column);
|
|
407
|
+
return {
|
|
408
|
+
name,
|
|
409
|
+
type: type.type || "null",
|
|
410
|
+
nullable: type.nullable
|
|
411
|
+
// metadata: {}
|
|
412
|
+
};
|
|
413
|
+
}
|
|
414
|
+
if (Array.isArray(column) && column.length > 0) {
|
|
415
|
+
const value = column[0];
|
|
416
|
+
const type = getDataTypeFromValue(value);
|
|
417
|
+
return {
|
|
418
|
+
name,
|
|
419
|
+
type,
|
|
420
|
+
nullable: true
|
|
421
|
+
// metadata: {},
|
|
422
|
+
};
|
|
423
|
+
}
|
|
424
|
+
throw new Error("empty table");
|
|
425
|
+
}
|
|
426
|
+
function deduceFieldFromValue(value, name) {
|
|
427
|
+
const type = getDataTypeFromValue(value);
|
|
428
|
+
return {
|
|
429
|
+
name,
|
|
430
|
+
type,
|
|
431
|
+
nullable: true
|
|
432
|
+
// metadata: {}
|
|
433
|
+
};
|
|
434
|
+
}
|
|
435
|
+
|
|
436
|
+
// ../schema-utils/src/lib/table/tables/make-table.ts
|
|
437
|
+
var arrow2 = __toESM(require("apache-arrow"), 1);
|
|
438
|
+
function makeTableFromData(data) {
|
|
439
|
+
let table;
|
|
440
|
+
switch (getTableShapeFromData(data)) {
|
|
441
|
+
case "array-row-table":
|
|
442
|
+
table = { shape: "array-row-table", data };
|
|
443
|
+
break;
|
|
444
|
+
case "object-row-table":
|
|
445
|
+
table = { shape: "object-row-table", data };
|
|
446
|
+
break;
|
|
447
|
+
case "columnar-table":
|
|
448
|
+
table = { shape: "columnar-table", data };
|
|
449
|
+
break;
|
|
450
|
+
case "arrow-table":
|
|
451
|
+
table = { shape: "arrow-table", data };
|
|
452
|
+
break;
|
|
453
|
+
default:
|
|
454
|
+
throw new Error("table");
|
|
455
|
+
}
|
|
456
|
+
const schema = deduceTableSchema(table);
|
|
457
|
+
return { ...table, schema };
|
|
458
|
+
}
|
|
459
|
+
function getTableShapeFromData(data) {
|
|
460
|
+
if (data instanceof arrow2.Table) {
|
|
461
|
+
return "arrow-table";
|
|
462
|
+
}
|
|
463
|
+
if (Array.isArray(data)) {
|
|
464
|
+
if (data.length === 0) {
|
|
465
|
+
throw new Error("cannot deduce type of empty table");
|
|
466
|
+
}
|
|
467
|
+
const firstRow = data[0];
|
|
468
|
+
if (Array.isArray(firstRow)) {
|
|
469
|
+
return "array-row-table";
|
|
470
|
+
}
|
|
471
|
+
if (firstRow && typeof firstRow === "object") {
|
|
472
|
+
return "object-row-table";
|
|
473
|
+
}
|
|
474
|
+
}
|
|
475
|
+
if (data && typeof data === "object") {
|
|
476
|
+
return "columnar-table";
|
|
477
|
+
}
|
|
478
|
+
throw new Error("invalid table");
|
|
479
|
+
}
|
|
480
|
+
|
|
481
|
+
// dist/sql-utils.js
|
|
482
|
+
var arrow3 = __toESM(require("apache-arrow"), 1);
|
|
483
|
+
function convertRowsToArrowTable(rows) {
|
|
484
|
+
const table = rows.length > 0 ? makeTableFromData(rows) : { shape: "object-row-table", schema: { fields: [], metadata: {} }, data: rows };
|
|
485
|
+
const schema = deducePrimitiveAwareSchema(table);
|
|
486
|
+
if (table.data.length === 0 || schema.fields.length === 0) {
|
|
487
|
+
return {
|
|
488
|
+
shape: "arrow-table",
|
|
489
|
+
schema,
|
|
490
|
+
data: new arrow3.Table(new arrow3.Schema([]))
|
|
491
|
+
};
|
|
492
|
+
}
|
|
493
|
+
return {
|
|
494
|
+
shape: "arrow-table",
|
|
495
|
+
schema,
|
|
496
|
+
data: arrow3.tableFromJSON(table.data)
|
|
497
|
+
};
|
|
498
|
+
}
|
|
499
|
+
function deducePrimitiveAwareSchema(table) {
|
|
500
|
+
return {
|
|
501
|
+
...table.schema,
|
|
502
|
+
fields: table.schema.fields.map((field) => {
|
|
503
|
+
if (field.type !== "null") {
|
|
504
|
+
return field;
|
|
505
|
+
}
|
|
506
|
+
const columnValues = table.data.map((row) => row[field.name]);
|
|
507
|
+
const inferredType = getDataTypeFromArray(columnValues);
|
|
508
|
+
return { ...field, type: inferredType.type, nullable: inferredType.nullable };
|
|
509
|
+
})
|
|
510
|
+
};
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
// ../loader-utils/src/lib/scan-utils/columnar-predicate.ts
|
|
514
|
+
function getColumnarPredicateColumns(predicate) {
|
|
515
|
+
return [...new Set(getColumnarPredicatePaths(predicate).map((path) => path[0]))];
|
|
516
|
+
}
|
|
517
|
+
function getColumnarPredicatePath(property) {
|
|
518
|
+
return typeof property.property === "string" ? [property.property] : [...property.property];
|
|
519
|
+
}
|
|
520
|
+
function getColumnarPredicatePaths(predicate) {
|
|
521
|
+
const paths = /* @__PURE__ */ new Map();
|
|
522
|
+
visitColumnarPredicate(predicate, (child) => {
|
|
523
|
+
if ("property" in child.args[0]) {
|
|
524
|
+
const path = getColumnarPredicatePath(child.args[0]);
|
|
525
|
+
paths.set(path.join("\0"), path);
|
|
526
|
+
}
|
|
527
|
+
});
|
|
528
|
+
return [...paths.values()];
|
|
529
|
+
}
|
|
530
|
+
function validateColumnarPredicate(predicate, availableColumns) {
|
|
531
|
+
visitColumnarPredicate(predicate, (child) => {
|
|
532
|
+
if (child.op === "and" || child.op === "or") {
|
|
533
|
+
if (child.args.length < 2)
|
|
534
|
+
throw new Error(`Columnar predicate ${child.op} requires at least two child predicates`);
|
|
535
|
+
return;
|
|
536
|
+
}
|
|
537
|
+
if (child.op === "not") return;
|
|
538
|
+
const leaf = child;
|
|
539
|
+
const path = getColumnarPredicatePath(leaf.args[0]);
|
|
540
|
+
if (!path.length || path.some((component) => !component)) {
|
|
541
|
+
throw new Error("Columnar predicate property path must contain non-empty strings");
|
|
542
|
+
}
|
|
543
|
+
if (!availableColumns.has(path[0]))
|
|
544
|
+
throw new Error(`Columnar predicate column not found: ${path.join(".")}`);
|
|
545
|
+
if (leaf.op === "in" && leaf.args[1].length === 0) {
|
|
546
|
+
throw new Error("Columnar predicate in requires at least one value");
|
|
547
|
+
}
|
|
548
|
+
});
|
|
549
|
+
}
|
|
550
|
+
function isColumnarPredicateParameter(value) {
|
|
551
|
+
const parameterValue = value;
|
|
552
|
+
return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "parameter") && typeof parameterValue.parameter === "string" && parameterValue.parameter.length > 0;
|
|
553
|
+
}
|
|
554
|
+
function visitColumnarPredicate(predicate, visitor) {
|
|
555
|
+
visitor(predicate);
|
|
556
|
+
if (predicate.op === "and" || predicate.op === "or")
|
|
557
|
+
predicate.args.forEach((child) => visitColumnarPredicate(child, visitor));
|
|
558
|
+
else if (predicate.op === "not") visitColumnarPredicate(predicate.args[0], visitor);
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
// ../loader-utils/src/lib/scan-utils/table-query.ts
|
|
562
|
+
function planTableQuery(sourceColumnNames, options = {}) {
|
|
563
|
+
validateTableQueryOptions(sourceColumnNames, options);
|
|
564
|
+
const outputColumnNames = options.columns ? [...options.columns] : [...sourceColumnNames];
|
|
565
|
+
const predicateColumnNames = options.predicate ? getColumnarPredicateColumns(options.predicate) : [];
|
|
566
|
+
const requiredColumnNames = /* @__PURE__ */ new Set([...outputColumnNames, ...predicateColumnNames]);
|
|
567
|
+
const scanColumnNames = sourceColumnNames.filter(
|
|
568
|
+
(columnName) => requiredColumnNames.has(columnName)
|
|
569
|
+
);
|
|
570
|
+
const steps = [
|
|
571
|
+
Object.freeze({ kind: "scan", columns: Object.freeze(scanColumnNames) })
|
|
572
|
+
];
|
|
573
|
+
if (options.predicate) {
|
|
574
|
+
steps.push(Object.freeze({ kind: "filter", predicate: options.predicate }));
|
|
575
|
+
}
|
|
576
|
+
steps.push(Object.freeze({ kind: "project", columns: Object.freeze(outputColumnNames) }));
|
|
577
|
+
if (options.limit !== void 0) {
|
|
578
|
+
steps.push(Object.freeze({ kind: "limit", limit: options.limit }));
|
|
579
|
+
}
|
|
580
|
+
return Object.freeze(steps);
|
|
581
|
+
}
|
|
582
|
+
function validateTableQueryOptions(sourceColumnNames, options) {
|
|
583
|
+
const availableColumnNames = new Set(sourceColumnNames);
|
|
584
|
+
const outputColumnNames = options.columns ?? sourceColumnNames;
|
|
585
|
+
const seenColumnNames = /* @__PURE__ */ new Set();
|
|
586
|
+
for (const columnName of outputColumnNames) {
|
|
587
|
+
if (!availableColumnNames.has(columnName)) {
|
|
588
|
+
throw new Error(`Table query column not found: ${columnName}`);
|
|
589
|
+
}
|
|
590
|
+
if (seenColumnNames.has(columnName)) {
|
|
591
|
+
throw new Error(`Table query column was selected more than once: ${columnName}`);
|
|
592
|
+
}
|
|
593
|
+
seenColumnNames.add(columnName);
|
|
594
|
+
}
|
|
595
|
+
validateTableQueryLimit(options.limit);
|
|
596
|
+
if (options.predicate) {
|
|
597
|
+
validateColumnarPredicate(options.predicate, availableColumnNames);
|
|
598
|
+
}
|
|
599
|
+
}
|
|
600
|
+
function validateTableQueryLimit(limit) {
|
|
601
|
+
if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 0)) {
|
|
602
|
+
throw new Error("Table query limit must be a non-negative safe integer.");
|
|
603
|
+
}
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
// ../loader-utils/src/lib/scan-utils/relational-query.ts
|
|
607
|
+
function planRelationalQuery(sourceColumnNames, options = {}) {
|
|
608
|
+
var _a, _b, _c, _d, _e, _f;
|
|
609
|
+
const available = new Set(sourceColumnNames);
|
|
610
|
+
const expressionNames = /* @__PURE__ */ new Set();
|
|
611
|
+
for (const expression of options.expressions || []) {
|
|
612
|
+
if (!expression.name) throw new Error("Relational expression names must be non-empty.");
|
|
613
|
+
if (available.has(expression.name) || expressionNames.has(expression.name)) {
|
|
614
|
+
throw new Error(`Relational expression duplicates column: ${expression.name}`);
|
|
615
|
+
}
|
|
616
|
+
expressionNames.add(expression.name);
|
|
617
|
+
}
|
|
618
|
+
const aggregateNames = new Set((options.aggregates || []).map((aggregate) => aggregate.name));
|
|
619
|
+
const requiredColumns = /* @__PURE__ */ new Set();
|
|
620
|
+
const availableColumns = new Set(sourceColumnNames);
|
|
621
|
+
for (const expression of options.expressions || []) {
|
|
622
|
+
const definition = expression.expression;
|
|
623
|
+
if (definition.op === "column") {
|
|
624
|
+
validateRelationalColumnReference(definition.column, availableColumns);
|
|
625
|
+
if (available.has(definition.column)) requiredColumns.add(definition.column);
|
|
626
|
+
}
|
|
627
|
+
if ("left" in definition) {
|
|
628
|
+
validateRelationalColumnReference(definition.left, availableColumns);
|
|
629
|
+
validateRelationalColumnReference(definition.right, availableColumns);
|
|
630
|
+
if (available.has(definition.left)) requiredColumns.add(definition.left);
|
|
631
|
+
if (available.has(definition.right)) requiredColumns.add(definition.right);
|
|
632
|
+
}
|
|
633
|
+
availableColumns.add(expression.name);
|
|
634
|
+
}
|
|
635
|
+
for (const key of options.orderBy || []) requiredColumns.add(key.column);
|
|
636
|
+
for (const key of options.groupBy || []) requiredColumns.add(key);
|
|
637
|
+
for (const aggregate of options.aggregates || []) {
|
|
638
|
+
if (aggregate.column) requiredColumns.add(aggregate.column);
|
|
639
|
+
}
|
|
640
|
+
const outputColumns = (_a = options.columns) == null ? void 0 : _a.filter(
|
|
641
|
+
(column) => !expressionNames.has(column) && !aggregateNames.has(column)
|
|
642
|
+
);
|
|
643
|
+
const tablePlan = [
|
|
644
|
+
...planTableQuery(sourceColumnNames, {
|
|
645
|
+
...options,
|
|
646
|
+
columns: outputColumns,
|
|
647
|
+
predicate: options.predicate
|
|
648
|
+
})
|
|
649
|
+
];
|
|
650
|
+
const scanStep = tablePlan[0];
|
|
651
|
+
if ((scanStep == null ? void 0 : scanStep.kind) === "scan") {
|
|
652
|
+
const scanColumns = new Set(scanStep.columns);
|
|
653
|
+
for (const column of requiredColumns) {
|
|
654
|
+
if (available.has(column)) scanColumns.add(column);
|
|
655
|
+
}
|
|
656
|
+
tablePlan[0] = Object.freeze({ kind: "scan", columns: Object.freeze([...scanColumns]) });
|
|
657
|
+
}
|
|
658
|
+
for (const expression of expressionNames) available.add(expression);
|
|
659
|
+
for (const aggregate of aggregateNames) available.add(aggregate);
|
|
660
|
+
for (const key of options.orderBy || []) {
|
|
661
|
+
if (!available.has(key.column))
|
|
662
|
+
throw new Error(`Relational order column not found: ${key.column}`);
|
|
663
|
+
}
|
|
664
|
+
for (const key of options.groupBy || []) {
|
|
665
|
+
if (!available.has(key)) throw new Error(`Relational group column not found: ${key}`);
|
|
666
|
+
}
|
|
667
|
+
for (const aggregate of options.aggregates || []) {
|
|
668
|
+
if (!aggregate.name) throw new Error("Relational aggregate names must be non-empty.");
|
|
669
|
+
if (aggregate.function !== "count" && !aggregate.column) {
|
|
670
|
+
throw new Error(`Relational aggregate ${aggregate.function} requires a column.`);
|
|
671
|
+
}
|
|
672
|
+
if (aggregate.column && !available.has(aggregate.column)) {
|
|
673
|
+
throw new Error(`Relational aggregate column not found: ${aggregate.column}`);
|
|
674
|
+
}
|
|
675
|
+
}
|
|
676
|
+
const relationalSteps = [];
|
|
677
|
+
if ((_b = options.expressions) == null ? void 0 : _b.length)
|
|
678
|
+
relationalSteps.push({ kind: "expression", detail: options.expressions });
|
|
679
|
+
if ((_c = options.orderBy) == null ? void 0 : _c.length) relationalSteps.push({ kind: "order", detail: options.orderBy });
|
|
680
|
+
if (((_d = options.aggregates) == null ? void 0 : _d.length) || ((_e = options.groupBy) == null ? void 0 : _e.length)) {
|
|
681
|
+
relationalSteps.push({
|
|
682
|
+
kind: "aggregate",
|
|
683
|
+
detail: { groupBy: options.groupBy, aggregates: options.aggregates }
|
|
684
|
+
});
|
|
685
|
+
}
|
|
686
|
+
if ((_f = options.union) == null ? void 0 : _f.length) relationalSteps.push({ kind: "union", detail: options.union });
|
|
687
|
+
if (options.join) relationalSteps.push({ kind: "join", detail: options.join });
|
|
688
|
+
return { tablePlan, relationalSteps: Object.freeze(relationalSteps) };
|
|
689
|
+
}
|
|
690
|
+
function validateRelationalColumnReference(columnName, availableColumns) {
|
|
691
|
+
if (!availableColumns.has(columnName)) {
|
|
692
|
+
throw new Error(`Relational expression column not found: ${columnName}`);
|
|
693
|
+
}
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
// dist/sql-predicate-types.js
|
|
697
|
+
function isSQLPredicateParameter(value) {
|
|
698
|
+
return isColumnarPredicateParameter(value);
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
// dist/sql-predicate-schema.js
|
|
702
|
+
var MAXIMUM_PREDICATE_DEPTH = 64;
|
|
703
|
+
var MAXIMUM_PREDICATE_NODES = 4096;
|
|
704
|
+
function validateSQLPredicate(value) {
|
|
705
|
+
const state = { nodes: 0 };
|
|
706
|
+
validatePredicateNode(value, "$", 0, state);
|
|
707
|
+
}
|
|
708
|
+
function validatePredicateNode(value, path, depth, state) {
|
|
709
|
+
if (depth > MAXIMUM_PREDICATE_DEPTH) {
|
|
710
|
+
throw new Error(`SQL predicate ${path} exceeds the maximum nesting depth`);
|
|
711
|
+
}
|
|
712
|
+
state.nodes++;
|
|
713
|
+
if (state.nodes > MAXIMUM_PREDICATE_NODES) {
|
|
714
|
+
throw new Error("SQL predicate exceeds the maximum node count");
|
|
715
|
+
}
|
|
716
|
+
if (!isRecord(value) || !hasExactKeys(value, ["op", "args"])) {
|
|
717
|
+
throw new Error(`SQL predicate ${path} must contain only op and args`);
|
|
718
|
+
}
|
|
719
|
+
if (typeof value.op !== "string" || !Array.isArray(value.args)) {
|
|
720
|
+
throw new Error(`SQL predicate ${path} requires string op and array args`);
|
|
721
|
+
}
|
|
722
|
+
switch (value.op) {
|
|
723
|
+
case "and":
|
|
724
|
+
case "or":
|
|
725
|
+
if (value.args.length < 2) {
|
|
726
|
+
throw new Error(`SQL predicate ${path}.${value.op} requires at least two arguments`);
|
|
727
|
+
}
|
|
728
|
+
for (let index = 0; index < value.args.length; index++) {
|
|
729
|
+
validatePredicateNode(value.args[index], `${path}.args[${index}]`, depth + 1, state);
|
|
730
|
+
}
|
|
731
|
+
return;
|
|
732
|
+
case "not":
|
|
733
|
+
if (value.args.length !== 1) {
|
|
734
|
+
throw new Error(`SQL predicate ${path}.not requires exactly one argument`);
|
|
735
|
+
}
|
|
736
|
+
validatePredicateNode(value.args[0], `${path}.args[0]`, depth + 1, state);
|
|
737
|
+
return;
|
|
738
|
+
case "isNull":
|
|
739
|
+
if (value.args.length !== 1) {
|
|
740
|
+
throw new Error(`SQL predicate ${path}.isNull requires exactly one argument`);
|
|
741
|
+
}
|
|
742
|
+
validatePredicateProperty(value.args[0], `${path}.args[0]`);
|
|
743
|
+
return;
|
|
744
|
+
case "in":
|
|
745
|
+
if (value.args.length !== 2 || !Array.isArray(value.args[1]) || value.args[1].length === 0) {
|
|
746
|
+
throw new Error(`SQL predicate ${path}.in requires a property and non-empty value list`);
|
|
747
|
+
}
|
|
748
|
+
validatePredicateProperty(value.args[0], `${path}.args[0]`);
|
|
749
|
+
value.args[1].forEach((item, index) => validatePredicateValue(item, `${path}.args[1][${index}]`));
|
|
750
|
+
return;
|
|
751
|
+
case "=":
|
|
752
|
+
case "<>":
|
|
753
|
+
case "<":
|
|
754
|
+
case "<=":
|
|
755
|
+
case ">":
|
|
756
|
+
case ">=":
|
|
757
|
+
if (value.args.length !== 2) {
|
|
758
|
+
throw new Error(`SQL predicate ${path}.${value.op} requires exactly two arguments`);
|
|
759
|
+
}
|
|
760
|
+
validatePredicateProperty(value.args[0], `${path}.args[0]`);
|
|
761
|
+
validatePredicateValue(value.args[1], `${path}.args[1]`);
|
|
762
|
+
return;
|
|
763
|
+
default:
|
|
764
|
+
throw new Error(`SQL predicate ${path} has unsupported operator ${JSON.stringify(value.op)}`);
|
|
765
|
+
}
|
|
766
|
+
}
|
|
767
|
+
function validatePredicateProperty(value, path) {
|
|
768
|
+
if (!isRecord(value) || !hasAllowedKeys(value, ["property", "quoted"]) || typeof value.property !== "string" || value.property.length === 0 || value.quoted !== void 0 && typeof value.quoted !== "boolean") {
|
|
769
|
+
throw new Error(`SQL predicate ${path} requires a non-empty property reference`);
|
|
770
|
+
}
|
|
771
|
+
}
|
|
772
|
+
function validatePredicateValue(value, path) {
|
|
773
|
+
if (isSQLPredicateParameter(value)) {
|
|
774
|
+
return;
|
|
775
|
+
}
|
|
776
|
+
if (typeof value === "boolean" || typeof value === "bigint" || typeof value === "string" || value instanceof Uint8Array) {
|
|
777
|
+
return;
|
|
778
|
+
}
|
|
779
|
+
if (typeof value === "number" && Number.isFinite(value)) {
|
|
780
|
+
return;
|
|
781
|
+
}
|
|
782
|
+
if (value instanceof Date && Number.isFinite(value.getTime())) {
|
|
783
|
+
return;
|
|
784
|
+
}
|
|
785
|
+
throw new Error(`SQL predicate ${path} contains an unsupported scalar value`);
|
|
786
|
+
}
|
|
787
|
+
function isRecord(value) {
|
|
788
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
789
|
+
}
|
|
790
|
+
function hasExactKeys(value, expectedKeys) {
|
|
791
|
+
const keys = Object.keys(value);
|
|
792
|
+
return keys.length === expectedKeys.length && expectedKeys.every((key) => keys.includes(key));
|
|
793
|
+
}
|
|
794
|
+
function hasAllowedKeys(value, allowedKeys) {
|
|
795
|
+
return Object.keys(value).every((key) => allowedKeys.includes(key));
|
|
796
|
+
}
|
|
797
|
+
|
|
798
|
+
// dist/table-query-capabilities.js
|
|
799
|
+
var ARROW_TABLE_QUERY_CAPABILITIES = Object.freeze({
|
|
800
|
+
projection: "residual",
|
|
801
|
+
predicate: "residual",
|
|
802
|
+
limit: "residual",
|
|
803
|
+
streaming: false,
|
|
804
|
+
cancellation: true,
|
|
805
|
+
expressions: "residual",
|
|
806
|
+
orderBy: "residual",
|
|
807
|
+
aggregates: "residual"
|
|
808
|
+
});
|
|
809
|
+
var SQL_DATA_SOURCE_TABLE_QUERY_CAPABILITIES = Object.freeze({
|
|
810
|
+
projection: "pushdown",
|
|
811
|
+
predicate: "pushdown",
|
|
812
|
+
limit: "pushdown",
|
|
813
|
+
streaming: false,
|
|
814
|
+
cancellation: false,
|
|
815
|
+
expressions: "pushdown",
|
|
816
|
+
orderBy: "pushdown",
|
|
817
|
+
aggregates: "pushdown"
|
|
818
|
+
});
|
|
819
|
+
|
|
820
|
+
// dist/table-query.js
|
|
821
|
+
function planTableQuery2(sourceColumnNames, options = {}) {
|
|
822
|
+
if (options.predicate) {
|
|
823
|
+
validateSQLPredicate(options.predicate);
|
|
824
|
+
}
|
|
825
|
+
return planTableQuery(sourceColumnNames, options);
|
|
826
|
+
}
|
|
827
|
+
function getSQLPredicateColumnNames(predicate) {
|
|
828
|
+
return getColumnarPredicateColumns(predicate);
|
|
829
|
+
}
|
|
830
|
+
|
|
831
|
+
// dist/query-arrow-table.js
|
|
832
|
+
function queryArrowTable(sourceTable, options = {}) {
|
|
833
|
+
var _a, _b;
|
|
834
|
+
throwIfAborted(options.signal);
|
|
835
|
+
if (options.join) {
|
|
836
|
+
validateArrowJoinQuery(sourceTable, options);
|
|
837
|
+
}
|
|
838
|
+
if (options.join && hasRelationalOperatorsExceptJoin(options)) {
|
|
839
|
+
throw new Error("Arrow joins cannot yet be combined with other relational operators.");
|
|
840
|
+
}
|
|
841
|
+
if (options.join && !hasRelationalOperatorsExceptJoin(options)) {
|
|
842
|
+
return queryArrowJoin(sourceTable, options);
|
|
843
|
+
}
|
|
844
|
+
if (hasRelationalOperators(options)) {
|
|
845
|
+
return queryArrowTableRelational(sourceTable, options);
|
|
846
|
+
}
|
|
847
|
+
const sourceData = sourceTable.data;
|
|
848
|
+
const plan = planTableQuery2(sourceData.schema.fields.map((field) => field.name), options);
|
|
849
|
+
const scannedData = sourceData.select([...getScanStep(plan).columns]);
|
|
850
|
+
const projectedData = scannedData.select([...getProjectStep(plan).columns]);
|
|
851
|
+
const predicate = (_a = getFilterStep(plan)) == null ? void 0 : _a.predicate;
|
|
852
|
+
const limit = ((_b = getLimitStep(plan)) == null ? void 0 : _b.limit) ?? Number.POSITIVE_INFINITY;
|
|
853
|
+
if (!predicate) {
|
|
854
|
+
return wrapArrowTable(projectedData.slice(0, limit));
|
|
855
|
+
}
|
|
856
|
+
const predicateColumns = getPredicateColumns(scannedData, getSQLPredicateColumnNames(predicate));
|
|
857
|
+
const matchingRowIndices = [];
|
|
858
|
+
for (let rowIndex = 0; rowIndex < scannedData.numRows && matchingRowIndices.length < limit; rowIndex++) {
|
|
859
|
+
throwIfAborted(options.signal);
|
|
860
|
+
if (evaluatePredicate(predicate, predicateColumns, rowIndex) === true) {
|
|
861
|
+
matchingRowIndices.push(rowIndex);
|
|
862
|
+
}
|
|
863
|
+
}
|
|
864
|
+
if (matchingRowIndices.length === 0) {
|
|
865
|
+
return wrapArrowTable(projectedData.slice(0, 0));
|
|
866
|
+
}
|
|
867
|
+
const outputColumns = {};
|
|
868
|
+
for (const field of projectedData.schema.fields) {
|
|
869
|
+
const sourceColumn = projectedData.getChild(field.name);
|
|
870
|
+
if (!sourceColumn) {
|
|
871
|
+
throw new Error(`Arrow query could not read column "${field.name}".`);
|
|
872
|
+
}
|
|
873
|
+
const values = matchingRowIndices.map((rowIndex) => sourceColumn.get(rowIndex));
|
|
874
|
+
outputColumns[field.name] = arrow4.vectorFromArray(values, sourceColumn.type);
|
|
875
|
+
}
|
|
876
|
+
return wrapArrowTable(new arrow4.Table(projectedData.schema, outputColumns));
|
|
877
|
+
}
|
|
878
|
+
function queryArrowTableRelational(sourceTable, options) {
|
|
879
|
+
var _a, _b, _c, _d, _e, _f;
|
|
880
|
+
const sourceData = sourceTable.data;
|
|
881
|
+
const sourceColumnNames = sourceData.schema.fields.map((field) => field.name);
|
|
882
|
+
const relationalPlan = planRelationalQuery(sourceColumnNames, options);
|
|
883
|
+
const scanStep = relationalPlan.tablePlan.find((step) => step.kind === "scan");
|
|
884
|
+
if (!scanStep || scanStep.kind !== "scan") {
|
|
885
|
+
throw new Error("Arrow relational query plan is missing a scan step.");
|
|
886
|
+
}
|
|
887
|
+
const scannedTable = wrapArrowTable(sourceData.select([...scanStep.columns]));
|
|
888
|
+
const filteredTable = queryArrowTable(scannedTable, {
|
|
889
|
+
predicate: options.predicate,
|
|
890
|
+
columns: scanStep.columns,
|
|
891
|
+
signal: options.signal
|
|
892
|
+
});
|
|
893
|
+
let rows = arrowTableToRows(filteredTable.data);
|
|
894
|
+
for (const child of options.union || []) {
|
|
895
|
+
const childTable = (_a = options.tables) == null ? void 0 : _a[child.source];
|
|
896
|
+
if (!childTable)
|
|
897
|
+
throw new Error(`Arrow union source not found: ${child.source}`);
|
|
898
|
+
const childResult = queryArrowTable(childTable, {
|
|
899
|
+
...child.query || {},
|
|
900
|
+
columns: getUnionChildColumns(sourceColumnNames, options),
|
|
901
|
+
signal: options.signal
|
|
902
|
+
});
|
|
903
|
+
rows = rows.concat(arrowTableToRows(childResult.data));
|
|
904
|
+
}
|
|
905
|
+
for (const expression of options.expressions || []) {
|
|
906
|
+
for (const row of rows) {
|
|
907
|
+
row[expression.name] = evaluateRelationalExpression(expression, row);
|
|
908
|
+
}
|
|
909
|
+
}
|
|
910
|
+
if (((_b = options.groupBy) == null ? void 0 : _b.length) || ((_c = options.aggregates) == null ? void 0 : _c.length)) {
|
|
911
|
+
rows = aggregateRows(rows, options.groupBy || [], options.aggregates || []);
|
|
912
|
+
}
|
|
913
|
+
if ((_d = options.orderBy) == null ? void 0 : _d.length) {
|
|
914
|
+
const orderBy = options.orderBy;
|
|
915
|
+
rows = rows.map((row, index) => ({ row, index })).sort((left, right) => compareRows(left.row, right.row, orderBy) || left.index - right.index).map((entry) => entry.row);
|
|
916
|
+
}
|
|
917
|
+
const outputColumns = options.columns || (((_e = options.groupBy) == null ? void 0 : _e.length) || ((_f = options.aggregates) == null ? void 0 : _f.length) ? [...options.groupBy || [], ...(options.aggregates || []).map((aggregate) => aggregate.name)] : sourceColumnNames);
|
|
918
|
+
const outputRows = rows.map((row) => {
|
|
919
|
+
const output = {};
|
|
920
|
+
for (const columnName of outputColumns) {
|
|
921
|
+
if (!(columnName in row)) {
|
|
922
|
+
throw new Error(`Arrow relational query column not found: ${columnName}`);
|
|
923
|
+
}
|
|
924
|
+
output[columnName] = row[columnName];
|
|
925
|
+
}
|
|
926
|
+
return output;
|
|
927
|
+
});
|
|
928
|
+
const limit = options.limit === void 0 ? outputRows.length : options.limit;
|
|
929
|
+
const limitedRows = outputRows.slice(0, limit);
|
|
930
|
+
return limitedRows.length ? convertRowsToArrowTable(limitedRows) : createEmptyRelationalResult(sourceData, outputColumns, options);
|
|
931
|
+
}
|
|
932
|
+
function getUnionChildColumns(sourceColumnNames, options) {
|
|
933
|
+
var _a, _b;
|
|
934
|
+
const expressionNames = new Set((options.expressions || []).map((expression) => expression.name));
|
|
935
|
+
const aggregateNames = new Set((options.aggregates || []).map((aggregate) => aggregate.name));
|
|
936
|
+
const outputColumns = options.columns || (((_a = options.groupBy) == null ? void 0 : _a.length) || ((_b = options.aggregates) == null ? void 0 : _b.length) ? [...options.groupBy || [], ...(options.aggregates || []).map((aggregate) => aggregate.name)] : sourceColumnNames);
|
|
937
|
+
const requiredColumns = new Set(outputColumns.filter((column) => !expressionNames.has(column) && !aggregateNames.has(column)));
|
|
938
|
+
for (const expression of options.expressions || []) {
|
|
939
|
+
const definition = expression.expression;
|
|
940
|
+
if (definition.op === "column")
|
|
941
|
+
requiredColumns.add(definition.column);
|
|
942
|
+
if ("left" in definition) {
|
|
943
|
+
requiredColumns.add(definition.left);
|
|
944
|
+
requiredColumns.add(definition.right);
|
|
945
|
+
}
|
|
946
|
+
}
|
|
947
|
+
for (const key of options.orderBy || []) {
|
|
948
|
+
if (!expressionNames.has(key.column) && !aggregateNames.has(key.column)) {
|
|
949
|
+
requiredColumns.add(key.column);
|
|
950
|
+
}
|
|
951
|
+
}
|
|
952
|
+
for (const column of options.groupBy || [])
|
|
953
|
+
requiredColumns.add(column);
|
|
954
|
+
for (const aggregate of options.aggregates || []) {
|
|
955
|
+
if (aggregate.column)
|
|
956
|
+
requiredColumns.add(aggregate.column);
|
|
957
|
+
}
|
|
958
|
+
return sourceColumnNames.filter((column) => requiredColumns.has(column));
|
|
959
|
+
}
|
|
960
|
+
function hasRelationalOperators(options) {
|
|
961
|
+
var _a, _b, _c, _d, _e;
|
|
962
|
+
return Boolean(((_a = options.expressions) == null ? void 0 : _a.length) || ((_b = options.orderBy) == null ? void 0 : _b.length) || ((_c = options.groupBy) == null ? void 0 : _c.length) || ((_d = options.aggregates) == null ? void 0 : _d.length) || ((_e = options.union) == null ? void 0 : _e.length) || options.join);
|
|
963
|
+
}
|
|
964
|
+
function hasRelationalOperatorsExceptJoin(options) {
|
|
965
|
+
var _a, _b, _c, _d, _e;
|
|
966
|
+
return Boolean(((_a = options.expressions) == null ? void 0 : _a.length) || ((_b = options.orderBy) == null ? void 0 : _b.length) || ((_c = options.groupBy) == null ? void 0 : _c.length) || ((_d = options.aggregates) == null ? void 0 : _d.length) || ((_e = options.union) == null ? void 0 : _e.length));
|
|
967
|
+
}
|
|
968
|
+
function queryArrowJoin(sourceTable, options) {
|
|
969
|
+
var _a;
|
|
970
|
+
const join = options.join;
|
|
971
|
+
if (!join)
|
|
972
|
+
throw new Error("Arrow join query is missing a join definition.");
|
|
973
|
+
const childTable = (_a = options.tables) == null ? void 0 : _a[join.child.source];
|
|
974
|
+
if (!childTable)
|
|
975
|
+
throw new Error(`Arrow join source not found: ${join.child.source}`);
|
|
976
|
+
const leftResult = queryArrowTable(sourceTable, {
|
|
977
|
+
predicate: options.predicate,
|
|
978
|
+
columns: void 0,
|
|
979
|
+
signal: options.signal
|
|
980
|
+
});
|
|
981
|
+
const rightResult = queryArrowTable(childTable, {
|
|
982
|
+
...join.child.query || {},
|
|
983
|
+
signal: options.signal
|
|
984
|
+
});
|
|
985
|
+
const leftRows = arrowTableToRows(leftResult.data);
|
|
986
|
+
const rightRows = arrowTableToRows(rightResult.data);
|
|
987
|
+
const rightPrefix = `${join.child.source}.`;
|
|
988
|
+
const defaultOutputColumns = [
|
|
989
|
+
...sourceTable.data.schema.fields.map((field) => field.name),
|
|
990
|
+
...rightResult.data.schema.fields.map((field) => `${rightPrefix}${field.name}`)
|
|
991
|
+
];
|
|
992
|
+
const rows = [];
|
|
993
|
+
for (const leftRow of leftRows) {
|
|
994
|
+
for (const rightRow of rightRows) {
|
|
995
|
+
if (leftRow[join.left] !== null && leftRow[join.left] !== void 0 && rightRow[join.right] !== null && rightRow[join.right] !== void 0 && compareSortValues(leftRow[join.left], rightRow[join.right]) === 0) {
|
|
996
|
+
rows.push({
|
|
997
|
+
...leftRow,
|
|
998
|
+
...Object.fromEntries(Object.entries(rightRow).map(([key, value]) => [`${rightPrefix}${key}`, value]))
|
|
999
|
+
});
|
|
1000
|
+
}
|
|
1001
|
+
}
|
|
1002
|
+
}
|
|
1003
|
+
const outputColumns = options.columns || defaultOutputColumns;
|
|
1004
|
+
const outputRows = rows.map((row) => Object.fromEntries(outputColumns.map((column) => [column, row[column]])));
|
|
1005
|
+
const limitedRows = outputRows.slice(0, options.limit);
|
|
1006
|
+
return limitedRows.length ? convertRowsToArrowTable(limitedRows) : createEmptyRelationalResult(sourceTable.data, outputColumns, options, new Map(rightResult.data.schema.fields.map((field) => [
|
|
1007
|
+
`${rightPrefix}${field.name}`,
|
|
1008
|
+
new arrow4.Field(`${rightPrefix}${field.name}`, field.type, field.nullable, field.metadata)
|
|
1009
|
+
])));
|
|
1010
|
+
}
|
|
1011
|
+
function validateArrowJoinQuery(sourceTable, options) {
|
|
1012
|
+
var _a, _b, _c;
|
|
1013
|
+
const join = options.join;
|
|
1014
|
+
if (!join)
|
|
1015
|
+
return;
|
|
1016
|
+
const sourceColumnNames = sourceTable.data.schema.fields.map((field) => field.name);
|
|
1017
|
+
const childTable = (_a = options.tables) == null ? void 0 : _a[join.child.source];
|
|
1018
|
+
if (!childTable)
|
|
1019
|
+
throw new Error(`Arrow join source not found: ${join.child.source}`);
|
|
1020
|
+
const childColumnNames = childTable.data.schema.fields.map((field) => field.name);
|
|
1021
|
+
if (!sourceColumnNames.includes(join.left)) {
|
|
1022
|
+
throw new Error(`Arrow join column not found: ${join.left}`);
|
|
1023
|
+
}
|
|
1024
|
+
if (!childColumnNames.includes(join.right)) {
|
|
1025
|
+
throw new Error(`Arrow join column not found: ${join.right}`);
|
|
1026
|
+
}
|
|
1027
|
+
const childPrefix = `${join.child.source}.`;
|
|
1028
|
+
const rootColumns = (_b = options.columns) == null ? void 0 : _b.filter((column) => !column.startsWith(childPrefix));
|
|
1029
|
+
planTableQuery2(sourceColumnNames, {
|
|
1030
|
+
predicate: options.predicate,
|
|
1031
|
+
columns: (rootColumns == null ? void 0 : rootColumns.length) ? rootColumns : void 0,
|
|
1032
|
+
limit: options.limit,
|
|
1033
|
+
signal: options.signal
|
|
1034
|
+
});
|
|
1035
|
+
const childQuery = join.child.query || {};
|
|
1036
|
+
planTableQuery2(childColumnNames, childQuery);
|
|
1037
|
+
const childOutputColumns = childQuery.columns || childColumnNames;
|
|
1038
|
+
if (!childOutputColumns.includes(join.right)) {
|
|
1039
|
+
throw new Error(`Arrow join child projection must include: ${join.right}`);
|
|
1040
|
+
}
|
|
1041
|
+
const projectedChildColumns = ((_c = options.columns) == null ? void 0 : _c.filter((column) => column.startsWith(childPrefix))) || [];
|
|
1042
|
+
const seenChildColumns = /* @__PURE__ */ new Set();
|
|
1043
|
+
for (const projectedColumn of projectedChildColumns) {
|
|
1044
|
+
const childColumn = projectedColumn.slice(childPrefix.length);
|
|
1045
|
+
if (!childColumnNames.includes(childColumn)) {
|
|
1046
|
+
throw new Error(`Arrow join column not found: ${projectedColumn}`);
|
|
1047
|
+
}
|
|
1048
|
+
if (seenChildColumns.has(childColumn)) {
|
|
1049
|
+
throw new Error(`Arrow query column was selected more than once: ${projectedColumn}`);
|
|
1050
|
+
}
|
|
1051
|
+
seenChildColumns.add(childColumn);
|
|
1052
|
+
if (!childOutputColumns.includes(childColumn)) {
|
|
1053
|
+
throw new Error(`Arrow join child projection does not include: ${childColumn}`);
|
|
1054
|
+
}
|
|
1055
|
+
}
|
|
1056
|
+
}
|
|
1057
|
+
function arrowTableToRows(data) {
|
|
1058
|
+
const columns = data.schema.fields.map((field) => ({
|
|
1059
|
+
name: field.name,
|
|
1060
|
+
vector: data.getChild(field.name)
|
|
1061
|
+
}));
|
|
1062
|
+
return Array.from({ length: data.numRows }, (_, rowIndex) => {
|
|
1063
|
+
const row = {};
|
|
1064
|
+
for (const column of columns) {
|
|
1065
|
+
if (!column.vector)
|
|
1066
|
+
throw new Error(`Arrow relational query could not read ${column.name}`);
|
|
1067
|
+
row[column.name] = column.vector.get(rowIndex);
|
|
1068
|
+
}
|
|
1069
|
+
return row;
|
|
1070
|
+
});
|
|
1071
|
+
}
|
|
1072
|
+
function evaluateRelationalExpression(expression, row) {
|
|
1073
|
+
const definition = expression.expression;
|
|
1074
|
+
if (definition.op === "literal")
|
|
1075
|
+
return definition.value;
|
|
1076
|
+
if (definition.op === "column")
|
|
1077
|
+
return row[definition.column];
|
|
1078
|
+
const left = row[definition.left];
|
|
1079
|
+
const right = row[definition.right];
|
|
1080
|
+
if (left === null || left === void 0 || right === null || right === void 0)
|
|
1081
|
+
return null;
|
|
1082
|
+
if (typeof left !== "number" || typeof right !== "number") {
|
|
1083
|
+
throw new Error(`Arrow relational expression ${expression.name} requires numeric operands.`);
|
|
1084
|
+
}
|
|
1085
|
+
switch (definition.op) {
|
|
1086
|
+
case "add":
|
|
1087
|
+
return left + right;
|
|
1088
|
+
case "subtract":
|
|
1089
|
+
return left - right;
|
|
1090
|
+
case "multiply":
|
|
1091
|
+
return left * right;
|
|
1092
|
+
case "divide":
|
|
1093
|
+
return right === 0 ? null : left / right;
|
|
1094
|
+
}
|
|
1095
|
+
}
|
|
1096
|
+
function compareRows(left, right, orderBy) {
|
|
1097
|
+
for (const key of orderBy) {
|
|
1098
|
+
const leftValue = left[key.column];
|
|
1099
|
+
const rightValue = right[key.column];
|
|
1100
|
+
const nulls = key.nulls || "last";
|
|
1101
|
+
if (leftValue === null || leftValue === void 0 || rightValue === null || rightValue === void 0) {
|
|
1102
|
+
if (leftValue === rightValue)
|
|
1103
|
+
continue;
|
|
1104
|
+
const nullResult = leftValue === null || leftValue === void 0 ? -1 : 1;
|
|
1105
|
+
return nulls === "first" ? nullResult : -nullResult;
|
|
1106
|
+
}
|
|
1107
|
+
const result = compareSortValues(leftValue, rightValue);
|
|
1108
|
+
if (result)
|
|
1109
|
+
return (key.direction === "desc" ? -1 : 1) * result;
|
|
1110
|
+
}
|
|
1111
|
+
return 0;
|
|
1112
|
+
}
|
|
1113
|
+
function compareSortValues(left, right) {
|
|
1114
|
+
if (left instanceof Date && right instanceof Date)
|
|
1115
|
+
return compareNumbers(left.getTime(), right.getTime());
|
|
1116
|
+
if (typeof left === "bigint" && typeof right === "bigint")
|
|
1117
|
+
return left === right ? 0 : left < right ? -1 : 1;
|
|
1118
|
+
if (typeof left === "number" && typeof right === "number")
|
|
1119
|
+
return compareNumbers(left, right);
|
|
1120
|
+
if (typeof left === "string" && typeof right === "string")
|
|
1121
|
+
return left === right ? 0 : left < right ? -1 : 1;
|
|
1122
|
+
if (typeof left === "boolean" && typeof right === "boolean")
|
|
1123
|
+
return Number(left) - Number(right);
|
|
1124
|
+
throw new Error(`Arrow relational order cannot compare ${getValueType(left)} with ${getValueType(right)}.`);
|
|
1125
|
+
}
|
|
1126
|
+
function aggregateRows(rows, groupBy, aggregates) {
|
|
1127
|
+
const groups = /* @__PURE__ */ new Map();
|
|
1128
|
+
for (const row of rows) {
|
|
1129
|
+
const key = serializeGroupKey(groupBy.map((column) => row[column]));
|
|
1130
|
+
const group = groups.get(key) || [];
|
|
1131
|
+
group.push(row);
|
|
1132
|
+
groups.set(key, group);
|
|
1133
|
+
}
|
|
1134
|
+
if (!groupBy.length && !rows.length)
|
|
1135
|
+
groups.set("[]", []);
|
|
1136
|
+
return [...groups.values()].map((group) => {
|
|
1137
|
+
var _a;
|
|
1138
|
+
const output = {};
|
|
1139
|
+
for (const column of groupBy)
|
|
1140
|
+
output[column] = ((_a = group[0]) == null ? void 0 : _a[column]) ?? null;
|
|
1141
|
+
for (const aggregate of aggregates)
|
|
1142
|
+
output[aggregate.name] = evaluateAggregate(aggregate, group);
|
|
1143
|
+
return output;
|
|
1144
|
+
});
|
|
1145
|
+
}
|
|
1146
|
+
function serializeGroupKey(values) {
|
|
1147
|
+
return values.map((value) => {
|
|
1148
|
+
if (value === null || value === void 0)
|
|
1149
|
+
return "null:";
|
|
1150
|
+
if (value instanceof Date)
|
|
1151
|
+
return `date:${value.getTime()}`;
|
|
1152
|
+
if (value instanceof Uint8Array)
|
|
1153
|
+
return `bytes:${Array.from(value).join(".")}`;
|
|
1154
|
+
return `${typeof value}:${String(value)}`;
|
|
1155
|
+
}).join("");
|
|
1156
|
+
}
|
|
1157
|
+
function createEmptyRelationalResult(sourceData, outputColumns, options, additionalFields) {
|
|
1158
|
+
const sourceFields = new Map(sourceData.schema.fields.map((field) => [field.name, field]));
|
|
1159
|
+
const expressions = new Map((options.expressions || []).map((expression) => [expression.name, expression]));
|
|
1160
|
+
const aggregates = new Map((options.aggregates || []).map((aggregate) => [aggregate.name, aggregate]));
|
|
1161
|
+
const fields = outputColumns.map((columnName) => {
|
|
1162
|
+
const sourceField = sourceFields.get(columnName);
|
|
1163
|
+
if (sourceField)
|
|
1164
|
+
return sourceField;
|
|
1165
|
+
const additionalField = additionalFields == null ? void 0 : additionalFields.get(columnName);
|
|
1166
|
+
if (additionalField)
|
|
1167
|
+
return additionalField;
|
|
1168
|
+
const expression = expressions.get(columnName);
|
|
1169
|
+
if (expression)
|
|
1170
|
+
return new arrow4.Field(columnName, getExpressionType(expression, sourceFields), true);
|
|
1171
|
+
const aggregate = aggregates.get(columnName);
|
|
1172
|
+
if (aggregate)
|
|
1173
|
+
return new arrow4.Field(columnName, getAggregateType(aggregate, sourceFields), true);
|
|
1174
|
+
return new arrow4.Field(columnName, new arrow4.Utf8(), true);
|
|
1175
|
+
});
|
|
1176
|
+
const columns = {};
|
|
1177
|
+
for (const field of fields)
|
|
1178
|
+
columns[field.name] = arrow4.vectorFromArray([], field.type);
|
|
1179
|
+
return wrapArrowTable(new arrow4.Table(new arrow4.Schema(fields), columns));
|
|
1180
|
+
}
|
|
1181
|
+
function getExpressionType(expression, sourceFields) {
|
|
1182
|
+
var _a;
|
|
1183
|
+
if (expression.expression.op === "literal") {
|
|
1184
|
+
const value = expression.expression.value;
|
|
1185
|
+
if (typeof value === "boolean")
|
|
1186
|
+
return new arrow4.Bool();
|
|
1187
|
+
if (typeof value === "number")
|
|
1188
|
+
return new arrow4.Float64();
|
|
1189
|
+
return new arrow4.Utf8();
|
|
1190
|
+
}
|
|
1191
|
+
if (expression.expression.op === "column") {
|
|
1192
|
+
return ((_a = sourceFields.get(expression.expression.column)) == null ? void 0 : _a.type) || new arrow4.Utf8();
|
|
1193
|
+
}
|
|
1194
|
+
return new arrow4.Float64();
|
|
1195
|
+
}
|
|
1196
|
+
function getAggregateType(aggregate, sourceFields) {
|
|
1197
|
+
var _a;
|
|
1198
|
+
if (aggregate.function === "count")
|
|
1199
|
+
return new arrow4.Int32();
|
|
1200
|
+
return aggregate.column ? ((_a = sourceFields.get(aggregate.column)) == null ? void 0 : _a.type) || new arrow4.Float64() : new arrow4.Float64();
|
|
1201
|
+
}
|
|
1202
|
+
function evaluateAggregate(aggregate, rows) {
|
|
1203
|
+
if (aggregate.function === "count")
|
|
1204
|
+
return aggregate.column ? rows.filter((row) => row[aggregate.column] != null).length : rows.length;
|
|
1205
|
+
const values = rows.map((row) => row[aggregate.column]).filter((value) => value != null);
|
|
1206
|
+
if (!values.length)
|
|
1207
|
+
return null;
|
|
1208
|
+
if (!values.every((value) => typeof value === "number"))
|
|
1209
|
+
throw new Error(`Arrow aggregate ${aggregate.function} requires numeric values.`);
|
|
1210
|
+
const numericValues = values;
|
|
1211
|
+
switch (aggregate.function) {
|
|
1212
|
+
case "sum":
|
|
1213
|
+
return numericValues.reduce((sum, value) => sum + value, 0);
|
|
1214
|
+
case "avg":
|
|
1215
|
+
return numericValues.reduce((sum, value) => sum + value, 0) / numericValues.length;
|
|
1216
|
+
case "min":
|
|
1217
|
+
return Math.min(...numericValues);
|
|
1218
|
+
case "max":
|
|
1219
|
+
return Math.max(...numericValues);
|
|
1220
|
+
}
|
|
1221
|
+
}
|
|
1222
|
+
function getPredicateColumns(sourceTable, columnNames) {
|
|
1223
|
+
const columns = {};
|
|
1224
|
+
for (const columnName of columnNames) {
|
|
1225
|
+
const column = sourceTable.getChild(columnName);
|
|
1226
|
+
if (!column) {
|
|
1227
|
+
throw new Error(`Arrow query column not found: ${columnName}`);
|
|
1228
|
+
}
|
|
1229
|
+
columns[columnName] = column;
|
|
1230
|
+
}
|
|
1231
|
+
return columns;
|
|
1232
|
+
}
|
|
1233
|
+
function evaluatePredicate(predicate, columns, rowIndex) {
|
|
1234
|
+
if (isLogicalPredicate(predicate)) {
|
|
1235
|
+
const values = predicate.args.map((child) => evaluatePredicate(child, columns, rowIndex));
|
|
1236
|
+
return predicate.op === "and" ? evaluateAnd(values) : evaluateOr(values);
|
|
1237
|
+
}
|
|
1238
|
+
if (isNotPredicate(predicate)) {
|
|
1239
|
+
const value2 = evaluatePredicate(predicate.args[0], columns, rowIndex);
|
|
1240
|
+
return value2 === null ? null : !value2;
|
|
1241
|
+
}
|
|
1242
|
+
const value = getColumnValue(columns, predicate.args[0].property, rowIndex);
|
|
1243
|
+
if (isNullPredicate(predicate)) {
|
|
1244
|
+
return value === null;
|
|
1245
|
+
}
|
|
1246
|
+
if (isInPredicate(predicate)) {
|
|
1247
|
+
return evaluateIn(value, predicate.args[1]);
|
|
1248
|
+
}
|
|
1249
|
+
return evaluateComparison(value, predicate);
|
|
1250
|
+
}
|
|
1251
|
+
function getColumnValue(columns, columnName, rowIndex) {
|
|
1252
|
+
const column = columns[columnName];
|
|
1253
|
+
if (!column) {
|
|
1254
|
+
throw new Error(`Arrow query could not read predicate column "${columnName}".`);
|
|
1255
|
+
}
|
|
1256
|
+
return column.get(rowIndex);
|
|
1257
|
+
}
|
|
1258
|
+
function evaluateAnd(values) {
|
|
1259
|
+
if (values.includes(false)) {
|
|
1260
|
+
return false;
|
|
1261
|
+
}
|
|
1262
|
+
return values.includes(null) ? null : true;
|
|
1263
|
+
}
|
|
1264
|
+
function evaluateOr(values) {
|
|
1265
|
+
if (values.includes(true)) {
|
|
1266
|
+
return true;
|
|
1267
|
+
}
|
|
1268
|
+
return values.includes(null) ? null : false;
|
|
1269
|
+
}
|
|
1270
|
+
function evaluateIn(value, candidates) {
|
|
1271
|
+
if (value === null || value === void 0) {
|
|
1272
|
+
return null;
|
|
1273
|
+
}
|
|
1274
|
+
for (const candidate of candidates) {
|
|
1275
|
+
if (compareValues(value, candidate) === 0) {
|
|
1276
|
+
return true;
|
|
1277
|
+
}
|
|
1278
|
+
}
|
|
1279
|
+
return false;
|
|
1280
|
+
}
|
|
1281
|
+
function evaluateComparison(value, predicate) {
|
|
1282
|
+
if (value === null || value === void 0) {
|
|
1283
|
+
return null;
|
|
1284
|
+
}
|
|
1285
|
+
const comparison = compareValues(value, predicate.args[1]);
|
|
1286
|
+
switch (predicate.op) {
|
|
1287
|
+
case "=":
|
|
1288
|
+
return comparison === 0;
|
|
1289
|
+
case "<>":
|
|
1290
|
+
return comparison !== 0;
|
|
1291
|
+
case "<":
|
|
1292
|
+
return comparison < 0;
|
|
1293
|
+
case "<=":
|
|
1294
|
+
return comparison <= 0;
|
|
1295
|
+
case ">":
|
|
1296
|
+
return comparison > 0;
|
|
1297
|
+
case ">=":
|
|
1298
|
+
return comparison >= 0;
|
|
1299
|
+
}
|
|
1300
|
+
}
|
|
1301
|
+
function compareValues(left, right) {
|
|
1302
|
+
if (isSQLPredicateParameter(right)) {
|
|
1303
|
+
throw new Error(`Arrow query parameter ":${right.parameter}" must be bound before query execution.`);
|
|
1304
|
+
}
|
|
1305
|
+
if (left instanceof Date && right instanceof Date) {
|
|
1306
|
+
return compareNumbers(left.getTime(), right.getTime());
|
|
1307
|
+
}
|
|
1308
|
+
if (typeof left === "number" && right instanceof Date) {
|
|
1309
|
+
return compareNumbers(left, right.getTime());
|
|
1310
|
+
}
|
|
1311
|
+
if (left instanceof Uint8Array && right instanceof Uint8Array) {
|
|
1312
|
+
return compareBinary(left, right);
|
|
1313
|
+
}
|
|
1314
|
+
if (typeof left === "bigint" && typeof right === "bigint") {
|
|
1315
|
+
return left === right ? 0 : left < right ? -1 : 1;
|
|
1316
|
+
}
|
|
1317
|
+
if (typeof left === "bigint" && typeof right === "number" && Number.isSafeInteger(right)) {
|
|
1318
|
+
return compareValues(left, BigInt(right));
|
|
1319
|
+
}
|
|
1320
|
+
if (typeof left === "number" && typeof right === "bigint" && Number.isSafeInteger(left)) {
|
|
1321
|
+
return compareValues(BigInt(left), right);
|
|
1322
|
+
}
|
|
1323
|
+
if (typeof left === "number" && typeof right === "number") {
|
|
1324
|
+
return compareNumbers(left, right);
|
|
1325
|
+
}
|
|
1326
|
+
if (typeof left === "string" && typeof right === "string") {
|
|
1327
|
+
return left === right ? 0 : left < right ? -1 : 1;
|
|
1328
|
+
}
|
|
1329
|
+
if (typeof left === "boolean" && typeof right === "boolean") {
|
|
1330
|
+
return Number(left) - Number(right);
|
|
1331
|
+
}
|
|
1332
|
+
throw new Error(`Arrow query cannot compare ${getValueType(left)} with ${getValueType(right)} values.`);
|
|
1333
|
+
}
|
|
1334
|
+
function compareNumbers(left, right) {
|
|
1335
|
+
if (!Number.isFinite(left) || !Number.isFinite(right)) {
|
|
1336
|
+
throw new Error("Arrow query cannot compare non-finite numbers.");
|
|
1337
|
+
}
|
|
1338
|
+
return left === right ? 0 : left < right ? -1 : 1;
|
|
1339
|
+
}
|
|
1340
|
+
function compareBinary(left, right) {
|
|
1341
|
+
const commonLength = Math.min(left.length, right.length);
|
|
1342
|
+
for (let index = 0; index < commonLength; index++) {
|
|
1343
|
+
if (left[index] !== right[index]) {
|
|
1344
|
+
return left[index] < right[index] ? -1 : 1;
|
|
1345
|
+
}
|
|
1346
|
+
}
|
|
1347
|
+
return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
|
|
1348
|
+
}
|
|
1349
|
+
function getValueType(value) {
|
|
1350
|
+
if (value instanceof Date) {
|
|
1351
|
+
return "Date";
|
|
1352
|
+
}
|
|
1353
|
+
if (value instanceof Uint8Array) {
|
|
1354
|
+
return "Uint8Array";
|
|
1355
|
+
}
|
|
1356
|
+
return typeof value;
|
|
1357
|
+
}
|
|
1358
|
+
function isLogicalPredicate(predicate) {
|
|
1359
|
+
return predicate.op === "and" || predicate.op === "or";
|
|
1360
|
+
}
|
|
1361
|
+
function isNotPredicate(predicate) {
|
|
1362
|
+
return predicate.op === "not";
|
|
1363
|
+
}
|
|
1364
|
+
function isNullPredicate(predicate) {
|
|
1365
|
+
return predicate.op === "isNull";
|
|
1366
|
+
}
|
|
1367
|
+
function isInPredicate(predicate) {
|
|
1368
|
+
return predicate.op === "in";
|
|
1369
|
+
}
|
|
1370
|
+
function getScanStep(plan) {
|
|
1371
|
+
const step = plan.find((candidate) => candidate.kind === "scan");
|
|
1372
|
+
if (!step) {
|
|
1373
|
+
throw new Error("Arrow query plan is missing a scan step.");
|
|
1374
|
+
}
|
|
1375
|
+
return step;
|
|
1376
|
+
}
|
|
1377
|
+
function getFilterStep(plan) {
|
|
1378
|
+
return plan.find((candidate) => candidate.kind === "filter");
|
|
1379
|
+
}
|
|
1380
|
+
function getProjectStep(plan) {
|
|
1381
|
+
const step = plan.find((candidate) => candidate.kind === "project");
|
|
1382
|
+
if (!step) {
|
|
1383
|
+
throw new Error("Arrow query plan is missing a project step.");
|
|
1384
|
+
}
|
|
1385
|
+
return step;
|
|
1386
|
+
}
|
|
1387
|
+
function getLimitStep(plan) {
|
|
1388
|
+
return plan.find((candidate) => candidate.kind === "limit");
|
|
1389
|
+
}
|
|
1390
|
+
function throwIfAborted(signal) {
|
|
1391
|
+
if (signal == null ? void 0 : signal.aborted) {
|
|
1392
|
+
const error = new Error("Arrow query was aborted.");
|
|
1393
|
+
error.name = "AbortError";
|
|
1394
|
+
throw error;
|
|
1395
|
+
}
|
|
1396
|
+
}
|
|
1397
|
+
function wrapArrowTable(data) {
|
|
1398
|
+
return {
|
|
1399
|
+
shape: "arrow-table",
|
|
1400
|
+
schema: convertArrowToSchema(data.schema),
|
|
1401
|
+
data
|
|
1402
|
+
};
|
|
1403
|
+
}
|
|
1404
|
+
//# sourceMappingURL=arrow-query.cjs.map
|