datalevin-node 1.0.2 → 1.1.0
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/README.md +293 -31
- package/jars/{datalevin-runtime-1.0.2.jar → datalevin-runtime-1.1.0.jar} +0 -0
- package/package.json +1 -1
- package/src/client.js +5 -3
- package/src/connection.js +23 -9
- package/src/convert.js +73 -0
- package/src/form.js +408 -0
- package/src/index.js +26 -1
- package/src/interop.js +16 -0
- package/src/query.js +1352 -0
- package/src/transaction.js +312 -0
- package/src/udf-value.js +252 -0
- package/src/udf.js +56 -65
package/src/udf.js
CHANGED
|
@@ -1,14 +1,16 @@
|
|
|
1
1
|
import { toJava, toJs } from "./convert.js";
|
|
2
|
+
import { Database } from "./database.js";
|
|
2
3
|
import { _BINDINGS } from "./interop.js";
|
|
3
4
|
import { javaBridgeModule } from "./jvm.js";
|
|
5
|
+
import { UdfDescriptor, descriptorData } from "./udf-value.js";
|
|
4
6
|
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
7
|
+
const DATABASE_CLASSES = new Set([
|
|
8
|
+
"datalevin.db.DB",
|
|
9
|
+
"datalevin.DatabaseValue"
|
|
10
|
+
]);
|
|
9
11
|
|
|
10
12
|
function descriptorKey(descriptor) {
|
|
11
|
-
const normalized =
|
|
13
|
+
const normalized = descriptorData(descriptor);
|
|
12
14
|
return [
|
|
13
15
|
normalized[":udf/lang"],
|
|
14
16
|
normalized[":udf/kind"],
|
|
@@ -38,50 +40,56 @@ function materializeJavaArgs(args) {
|
|
|
38
40
|
return items;
|
|
39
41
|
}
|
|
40
42
|
|
|
41
|
-
|
|
43
|
+
function materializeUdfArgs(args) {
|
|
42
44
|
if (Array.isArray(args)) {
|
|
43
|
-
|
|
44
|
-
return args;
|
|
45
|
-
}
|
|
46
|
-
const convertedTail = await Promise.all(args.slice(1).map((value) => toJs(value)));
|
|
47
|
-
return [args[0], ...convertedTail];
|
|
45
|
+
return args;
|
|
48
46
|
}
|
|
49
|
-
|
|
50
47
|
if (typeof args?.sizeSync === "function" && typeof args?.getSync === "function") {
|
|
48
|
+
const values = [];
|
|
51
49
|
const size = Number(args.sizeSync());
|
|
52
|
-
|
|
53
|
-
|
|
50
|
+
for (let index = 0; index < size; index += 1) {
|
|
51
|
+
try {
|
|
52
|
+
values.push(args.getSync(index));
|
|
53
|
+
} catch (error) {
|
|
54
|
+
const message = String(error?.message ?? error);
|
|
55
|
+
if (index === 0 && message.includes("ClassNotFoundException: datalevin.db.DB")) {
|
|
56
|
+
// Runtime jars before the DatabaseValue UDF bridge could not expose
|
|
57
|
+
// the generated Clojure DB class to Node. Preserve their historical
|
|
58
|
+
// null argument while newer runtimes provide an idiomatic Database.
|
|
59
|
+
values.push(null);
|
|
60
|
+
continue;
|
|
61
|
+
}
|
|
62
|
+
throw error;
|
|
63
|
+
}
|
|
54
64
|
}
|
|
55
|
-
|
|
56
|
-
const values = [null];
|
|
57
|
-
for (let index = 1; index < size; index += 1) {
|
|
58
|
-
values.push(await toJs(args.getSync(index)));
|
|
59
|
-
}
|
|
60
|
-
return values;
|
|
61
|
-
}
|
|
62
|
-
|
|
63
|
-
const values = materializeJavaArgs(args);
|
|
64
|
-
if (values.length === 0) {
|
|
65
65
|
return values;
|
|
66
66
|
}
|
|
67
|
-
|
|
68
|
-
return [values[0], ...convertedTail];
|
|
67
|
+
return materializeJavaArgs(args);
|
|
69
68
|
}
|
|
70
69
|
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
70
|
+
function javaClassName(value) {
|
|
71
|
+
try {
|
|
72
|
+
return value.getClassSync().getNameSync();
|
|
73
|
+
} catch {
|
|
74
|
+
return null;
|
|
75
75
|
}
|
|
76
|
+
}
|
|
76
77
|
|
|
77
|
-
|
|
78
|
+
async function udfArgsToJs(args) {
|
|
79
|
+
const values = materializeUdfArgs(args);
|
|
80
|
+
return Promise.all(values.map(async (value) => {
|
|
81
|
+
if (DATABASE_CLASSES.has(javaClassName(value))) {
|
|
82
|
+
return new Database(value);
|
|
83
|
+
}
|
|
84
|
+
return toJs(value);
|
|
85
|
+
}));
|
|
78
86
|
}
|
|
79
87
|
|
|
80
|
-
async function createProxy(fn
|
|
88
|
+
async function createProxy(fn) {
|
|
81
89
|
const { newProxy } = await javaBridgeModule();
|
|
82
90
|
return newProxy("datalevin.UdfFunction", {
|
|
83
91
|
invoke: async (args) => {
|
|
84
|
-
const values = await udfArgsToJs(args
|
|
92
|
+
const values = await udfArgsToJs(args);
|
|
85
93
|
const result = await fn(...values);
|
|
86
94
|
return toJava(result === undefined ? null : result);
|
|
87
95
|
}
|
|
@@ -93,29 +101,7 @@ export function udfDescriptor(idOrDescriptor, {
|
|
|
93
101
|
lang = ":java",
|
|
94
102
|
version = null
|
|
95
103
|
} = {}) {
|
|
96
|
-
|
|
97
|
-
const descriptor = idOrDescriptor;
|
|
98
|
-
const id = descriptor[":udf/id"] ?? descriptor.id ?? descriptor.udfId;
|
|
99
|
-
return udfDescriptor(id, {
|
|
100
|
-
kind: descriptor[":udf/kind"] ?? descriptor.kind ?? kind,
|
|
101
|
-
lang: descriptor[":udf/lang"] ?? descriptor.lang ?? lang,
|
|
102
|
-
version: descriptor[":udf/version"] ?? descriptor.version ?? version
|
|
103
|
-
});
|
|
104
|
-
}
|
|
105
|
-
|
|
106
|
-
if (idOrDescriptor === null || idOrDescriptor === undefined) {
|
|
107
|
-
throw new TypeError("udf id is required");
|
|
108
|
-
}
|
|
109
|
-
|
|
110
|
-
const descriptor = {
|
|
111
|
-
":udf/lang": keywordString(lang),
|
|
112
|
-
":udf/kind": keywordString(kind),
|
|
113
|
-
":udf/id": keywordString(idOrDescriptor)
|
|
114
|
-
};
|
|
115
|
-
if (version !== null && version !== undefined) {
|
|
116
|
-
descriptor[":udf/version"] = version;
|
|
117
|
-
}
|
|
118
|
-
return descriptor;
|
|
104
|
+
return descriptorData(idOrDescriptor, { kind, lang, version });
|
|
119
105
|
}
|
|
120
106
|
|
|
121
107
|
export class UdfRegistry {
|
|
@@ -133,15 +119,15 @@ export class UdfRegistry {
|
|
|
133
119
|
throw new TypeError("fn must be a function");
|
|
134
120
|
}
|
|
135
121
|
|
|
136
|
-
const normalized =
|
|
137
|
-
const proxy = await createProxy(fn
|
|
122
|
+
const normalized = UdfDescriptor.from(descriptor, { defaultLang: "javascript" });
|
|
123
|
+
const proxy = await createProxy(fn);
|
|
138
124
|
await _BINDINGS.registerUdf(this._handle, normalized, proxy);
|
|
139
125
|
this._proxies.set(descriptorKey(normalized), proxy);
|
|
140
126
|
return fn;
|
|
141
127
|
}
|
|
142
128
|
|
|
143
129
|
async unregister(descriptor) {
|
|
144
|
-
const normalized =
|
|
130
|
+
const normalized = UdfDescriptor.from(descriptor, { defaultLang: "javascript" });
|
|
145
131
|
await _BINDINGS.unregisterUdf(this._handle, normalized);
|
|
146
132
|
const key = descriptorKey(normalized);
|
|
147
133
|
const proxy = this._proxies.get(key);
|
|
@@ -152,30 +138,35 @@ export class UdfRegistry {
|
|
|
152
138
|
}
|
|
153
139
|
|
|
154
140
|
async registered(descriptor) {
|
|
155
|
-
return _BINDINGS.registeredUdf(
|
|
141
|
+
return _BINDINGS.registeredUdf(
|
|
142
|
+
this._handle,
|
|
143
|
+
UdfDescriptor.from(descriptor, { defaultLang: "javascript" })
|
|
144
|
+
);
|
|
156
145
|
}
|
|
157
146
|
|
|
158
147
|
async queryUdf(id, fn, options = {}) {
|
|
159
|
-
return this.register(
|
|
148
|
+
return this.register(UdfDescriptor.queryFn(id, options), fn);
|
|
160
149
|
}
|
|
161
150
|
|
|
162
151
|
async predicateUdf(id, fn, options = {}) {
|
|
163
|
-
return this.register(
|
|
152
|
+
return this.register(UdfDescriptor.predicate(id, options), fn);
|
|
164
153
|
}
|
|
165
154
|
|
|
166
155
|
async txUdf(id, fn, options = {}) {
|
|
167
|
-
return this.register(
|
|
156
|
+
return this.register(UdfDescriptor.txFn(id, options), fn);
|
|
168
157
|
}
|
|
169
158
|
|
|
170
159
|
async analyzerUdf(id, fn, options = {}) {
|
|
171
|
-
return this.register(
|
|
160
|
+
return this.register(UdfDescriptor.analyzer(id, options), fn);
|
|
172
161
|
}
|
|
173
162
|
|
|
174
163
|
async queryAnalyzerUdf(id, fn, options = {}) {
|
|
175
|
-
return this.register(
|
|
164
|
+
return this.register(UdfDescriptor.queryAnalyzer(id, options), fn);
|
|
176
165
|
}
|
|
177
166
|
}
|
|
178
167
|
|
|
179
168
|
export async function createUdfRegistry() {
|
|
180
169
|
return new UdfRegistry(await _BINDINGS.createUdfRegistry());
|
|
181
170
|
}
|
|
171
|
+
|
|
172
|
+
export { UdfDescriptor };
|