@expressive/sql 0.1.0 → 0.2.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/dist/index.d.mts +46 -37
- package/dist/index.d.ts +46 -37
- package/dist/index.js +26 -15
- package/dist/index.mjs +25 -12
- package/package.json +5 -2
- package/.turbo/turbo-build.log +0 -21
- package/src/columns/Bool.ts +0 -64
- package/src/columns/Num.ts +0 -54
- package/src/columns/One.test.ts +0 -131
- package/src/columns/One.ts +0 -49
- package/src/columns/Str.ts +0 -75
- package/src/columns/Time.ts +0 -29
- package/src/connection/Connection.ts +0 -117
- package/src/connection/Generator.ts +0 -303
- package/src/index.ts +0 -14
- package/src/query/Builder.ts +0 -466
- package/src/query/Computed.ts +0 -76
- package/src/query/Query.test.ts +0 -8
- package/src/query/Query.ts +0 -241
- package/src/tests/delete.test.ts +0 -48
- package/src/tests/insert.test.ts +0 -47
- package/src/tests/join.test.ts +0 -242
- package/src/tests/math.test.ts +0 -69
- package/src/tests/select.test.ts +0 -115
- package/src/tests/template.test.ts +0 -16
- package/src/tests/update.test.ts +0 -85
- package/src/tests/where.test.ts +0 -347
- package/src/type/Field.ts +0 -186
- package/src/type/Table.test.ts +0 -24
- package/src/type/Table.ts +0 -31
- package/src/type/Type.test.ts +0 -67
- package/src/type/Type.ts +0 -144
- package/src/utils.ts +0 -59
package/src/query/Builder.ts
DELETED
|
@@ -1,466 +0,0 @@
|
|
|
1
|
-
import { Field } from '../type/Field';
|
|
2
|
-
import { Type } from '../type/Type';
|
|
3
|
-
import { create, defineProperty, freeze, getOwnPropertyNames, values } from '../utils';
|
|
4
|
-
import { Query } from './Query';
|
|
5
|
-
|
|
6
|
-
declare namespace Builder {
|
|
7
|
-
interface Table<T extends Type = any> {
|
|
8
|
-
toString(): string;
|
|
9
|
-
name: string;
|
|
10
|
-
proxy: Query.From<T>;
|
|
11
|
-
fields: Map<string, Field>;
|
|
12
|
-
alias?: string;
|
|
13
|
-
optional?: boolean;
|
|
14
|
-
joins: Cond[];
|
|
15
|
-
}
|
|
16
|
-
|
|
17
|
-
type Using<T extends Type> = (self: Query.From<T>, where: Query.Where) => void;
|
|
18
|
-
|
|
19
|
-
type Insert = Map<Field, unknown>;
|
|
20
|
-
}
|
|
21
|
-
|
|
22
|
-
class Builder {
|
|
23
|
-
/**
|
|
24
|
-
* Parameters which will be sent with query.
|
|
25
|
-
* May either be placeholders for a template, or values
|
|
26
|
-
* which the query deems unsafe to interpolate directly.
|
|
27
|
-
*/
|
|
28
|
-
params = [] as Parameter[];
|
|
29
|
-
|
|
30
|
-
filters = new Group();
|
|
31
|
-
pending = new Set<() => void>();
|
|
32
|
-
order = new Map<Field, "asc" | "desc">();
|
|
33
|
-
tables = new Map<{}, Query.Table>();
|
|
34
|
-
|
|
35
|
-
deletes = new Set<Query.Table>();
|
|
36
|
-
updates = new Map<Query.Table, Builder.Insert>();
|
|
37
|
-
inserts = new Map<Query.Table, Builder.Insert>();
|
|
38
|
-
|
|
39
|
-
returns?: Map<string, Field | Value> | Field | Value;
|
|
40
|
-
limit?: number;
|
|
41
|
-
|
|
42
|
-
commit(returns: unknown){
|
|
43
|
-
if(this.returns)
|
|
44
|
-
throw new Error('This query has already been committed.');
|
|
45
|
-
|
|
46
|
-
this.pending.forEach(fn => fn());
|
|
47
|
-
this.pending.clear();
|
|
48
|
-
|
|
49
|
-
if(typeof returns === 'function')
|
|
50
|
-
returns = returns();
|
|
51
|
-
|
|
52
|
-
if(returns instanceof Field || returns instanceof Value){
|
|
53
|
-
this.returns = returns;
|
|
54
|
-
}
|
|
55
|
-
else if(returns) {
|
|
56
|
-
const columns = new Map<string, string | Field | Value>();
|
|
57
|
-
|
|
58
|
-
function scan(obj: any, path?: string) {
|
|
59
|
-
getOwnPropertyNames(obj).forEach(key => {
|
|
60
|
-
const use = path ? `${path}.${key}` : key;
|
|
61
|
-
let selects = obj[key];
|
|
62
|
-
|
|
63
|
-
if(typeof selects == 'function')
|
|
64
|
-
selects = selects();
|
|
65
|
-
|
|
66
|
-
if (selects instanceof Field || selects instanceof Value || typeof selects != 'object')
|
|
67
|
-
columns.set(use, selects);
|
|
68
|
-
else
|
|
69
|
-
scan(selects, use);
|
|
70
|
-
})
|
|
71
|
-
}
|
|
72
|
-
|
|
73
|
-
scan(returns);
|
|
74
|
-
|
|
75
|
-
this.returns = columns;
|
|
76
|
-
}
|
|
77
|
-
}
|
|
78
|
-
|
|
79
|
-
inject(args: number){
|
|
80
|
-
return Array.from({ length: args }, (_, i) => {
|
|
81
|
-
const p = new Parameter(i);
|
|
82
|
-
|
|
83
|
-
return () => {
|
|
84
|
-
if(this.params.includes(p))
|
|
85
|
-
throw new Error(`Parameter ${i} is already defined.`);
|
|
86
|
-
else
|
|
87
|
-
this.params.push(p);
|
|
88
|
-
|
|
89
|
-
return p;
|
|
90
|
-
}
|
|
91
|
-
})
|
|
92
|
-
}
|
|
93
|
-
|
|
94
|
-
table(table: Query.From){
|
|
95
|
-
const target = this.tables.get(table)!;
|
|
96
|
-
|
|
97
|
-
return <Query.Verbs<Type>> {
|
|
98
|
-
delete: () => {
|
|
99
|
-
this.deletes.add(target);
|
|
100
|
-
},
|
|
101
|
-
update: (data: Query.Update<any>) => {
|
|
102
|
-
const inserts = new Map<Field, unknown>();
|
|
103
|
-
|
|
104
|
-
Object.entries(data).forEach(([key, value]) => {
|
|
105
|
-
const field = target.fields.get(key)!;
|
|
106
|
-
|
|
107
|
-
if(value instanceof DataField)
|
|
108
|
-
value.field = field;
|
|
109
|
-
|
|
110
|
-
inserts.set(field, value);
|
|
111
|
-
})
|
|
112
|
-
|
|
113
|
-
this.updates.set(target, inserts);
|
|
114
|
-
}
|
|
115
|
-
}
|
|
116
|
-
}
|
|
117
|
-
|
|
118
|
-
field<T extends Field>(field: T){
|
|
119
|
-
return {
|
|
120
|
-
...field.where(),
|
|
121
|
-
asc: () => { this.order.set(field, "asc") },
|
|
122
|
-
desc: () => { this.order.set(field, "desc") }
|
|
123
|
-
}
|
|
124
|
-
}
|
|
125
|
-
|
|
126
|
-
andOr(...args: (Cond | Group)[]){
|
|
127
|
-
const local = new Group();
|
|
128
|
-
|
|
129
|
-
this.filters.add(local);
|
|
130
|
-
|
|
131
|
-
for(const eq of args){
|
|
132
|
-
if(eq instanceof Cond && eq.restricted)
|
|
133
|
-
throw new Error(
|
|
134
|
-
`Cannot use ${eq.left} ${eq.op} ${eq.right} in a group.`
|
|
135
|
-
);
|
|
136
|
-
|
|
137
|
-
this.filters.delete(eq)
|
|
138
|
-
local.add(eq);
|
|
139
|
-
}
|
|
140
|
-
|
|
141
|
-
return local;
|
|
142
|
-
}
|
|
143
|
-
|
|
144
|
-
use<T extends Type>(type: Type.EntityType<T>, optional?: false): Query.From<T>;
|
|
145
|
-
use<T extends Type>(type: Type.EntityType<T>, optional: boolean): Query.Join<T>;
|
|
146
|
-
use<T extends Type>(type: Type.EntityType<T>, ...inserts: Type.Insert<T>[]): Query.From<T>;
|
|
147
|
-
use<T extends Type>(type: Type.EntityType<T>, arg2?: boolean | Type.Insert<T>, ...rest: Type.Insert<T>[]){
|
|
148
|
-
const { fields, schema } = type;
|
|
149
|
-
const { tables } = this;
|
|
150
|
-
|
|
151
|
-
const proxy = {} as Query.From<T>;
|
|
152
|
-
const table: Builder.Table = {
|
|
153
|
-
name: type.table,
|
|
154
|
-
fields: new Map(),
|
|
155
|
-
joins: [],
|
|
156
|
-
proxy,
|
|
157
|
-
optional: arg2 === true,
|
|
158
|
-
toString(){
|
|
159
|
-
return this.alias
|
|
160
|
-
? this.name + " " + this.alias
|
|
161
|
-
: this.name;
|
|
162
|
-
}
|
|
163
|
-
};
|
|
164
|
-
|
|
165
|
-
if(rest.length)
|
|
166
|
-
arg2 = this.with<any>([arg2, ...rest]) as any;
|
|
167
|
-
|
|
168
|
-
// TODO: also support self-joins
|
|
169
|
-
if(schema){
|
|
170
|
-
table.alias = 'T' + tables.size;
|
|
171
|
-
table.name = schema + '.' + table.name;
|
|
172
|
-
}
|
|
173
|
-
|
|
174
|
-
tables.set(proxy, table);
|
|
175
|
-
fields.forEach((field, key) => {
|
|
176
|
-
field = create(field);
|
|
177
|
-
field.query = this;
|
|
178
|
-
field.table = table;
|
|
179
|
-
field.toString = () => `${table.alias || table.name}.${field.column}`;
|
|
180
|
-
|
|
181
|
-
table.fields.set(key, field);
|
|
182
|
-
|
|
183
|
-
let value: any;
|
|
184
|
-
|
|
185
|
-
defineProperty(proxy, key, {
|
|
186
|
-
get: () => value || (
|
|
187
|
-
value = field.use ? field.use(this) : field
|
|
188
|
-
)
|
|
189
|
-
});
|
|
190
|
-
});
|
|
191
|
-
|
|
192
|
-
if(typeof arg2 == "object")
|
|
193
|
-
this.insert(table, arg2);
|
|
194
|
-
|
|
195
|
-
freeze(proxy);
|
|
196
|
-
|
|
197
|
-
return table.proxy;
|
|
198
|
-
}
|
|
199
|
-
|
|
200
|
-
insert<T extends Type>(
|
|
201
|
-
table: Builder.Table<T>,
|
|
202
|
-
input: Type.Insert<T>){
|
|
203
|
-
|
|
204
|
-
const inserts = new Map<Field, unknown>();
|
|
205
|
-
|
|
206
|
-
for(const [key, field] of table.fields){
|
|
207
|
-
let value = (input as any)[key];
|
|
208
|
-
|
|
209
|
-
if(value instanceof DataField)
|
|
210
|
-
value.field = field;
|
|
211
|
-
else
|
|
212
|
-
value = this.digest(value, field);
|
|
213
|
-
|
|
214
|
-
if(value !== undefined)
|
|
215
|
-
inserts.set(field, value);
|
|
216
|
-
}
|
|
217
|
-
|
|
218
|
-
this.inserts.set(table, inserts);
|
|
219
|
-
}
|
|
220
|
-
|
|
221
|
-
digest(value: any, field: Field){
|
|
222
|
-
if (value != null)
|
|
223
|
-
try {
|
|
224
|
-
return field.set(value);
|
|
225
|
-
}
|
|
226
|
-
catch(err: unknown){
|
|
227
|
-
let message = `Provided value for ${field.parent}.${field.column} but not acceptable for type ${field.datatype}.`;
|
|
228
|
-
|
|
229
|
-
if(err instanceof Error){
|
|
230
|
-
err.message = message + "\n" + err.message;
|
|
231
|
-
throw err;
|
|
232
|
-
}
|
|
233
|
-
|
|
234
|
-
if(typeof err == "string")
|
|
235
|
-
message += "\n" + err;
|
|
236
|
-
|
|
237
|
-
throw new Error(message);
|
|
238
|
-
}
|
|
239
|
-
else if (!field.nullable && !field.optional && !field.increment)
|
|
240
|
-
throw new Error(
|
|
241
|
-
`Can't assign to \`${field.parent}.${field.property}\`. A value is required but got ${value}.`
|
|
242
|
-
);
|
|
243
|
-
}
|
|
244
|
-
|
|
245
|
-
where(left: Field, op: string, right: unknown){
|
|
246
|
-
if(typeof right == "function")
|
|
247
|
-
right = right();
|
|
248
|
-
|
|
249
|
-
if(right === null && !left.nullable)
|
|
250
|
-
throw new Error(`Column ${left} is not nullable.`);
|
|
251
|
-
|
|
252
|
-
if(right instanceof Field || right instanceof DataField){
|
|
253
|
-
const where = new Cond(left, op, right, true);
|
|
254
|
-
|
|
255
|
-
if(right instanceof DataField){
|
|
256
|
-
// TODO: should generator handle this?
|
|
257
|
-
right.field = left;
|
|
258
|
-
right.table.joins.push(where);
|
|
259
|
-
}
|
|
260
|
-
else
|
|
261
|
-
left.table!.joins.push(where);
|
|
262
|
-
|
|
263
|
-
return where;
|
|
264
|
-
}
|
|
265
|
-
|
|
266
|
-
if(right instanceof Parameter){
|
|
267
|
-
right.digest = left.set.bind(this);
|
|
268
|
-
}
|
|
269
|
-
|
|
270
|
-
return this.filters.add(left, op, right);
|
|
271
|
-
}
|
|
272
|
-
|
|
273
|
-
with<T extends Record<string, any>>(data: Iterable<T>){
|
|
274
|
-
return new DataTable(this, data).proxy;
|
|
275
|
-
}
|
|
276
|
-
|
|
277
|
-
accept(args: unknown[]){
|
|
278
|
-
return Array.from(this.params || [], p => p.toParam(args));
|
|
279
|
-
}
|
|
280
|
-
|
|
281
|
-
parse(raw: Record<string, any>){
|
|
282
|
-
const { returns: selects } = this;
|
|
283
|
-
|
|
284
|
-
if(selects instanceof Map){
|
|
285
|
-
const values = {} as any;
|
|
286
|
-
|
|
287
|
-
selects.forEach((field, column) => {
|
|
288
|
-
const path = column.split('.');
|
|
289
|
-
const property = path.pop()!;
|
|
290
|
-
let target = values;
|
|
291
|
-
|
|
292
|
-
for (const step of path)
|
|
293
|
-
target = target[step] || (target[step] = {});
|
|
294
|
-
|
|
295
|
-
const value = raw[column];
|
|
296
|
-
|
|
297
|
-
target[property] =
|
|
298
|
-
field instanceof Field ? field.get(value) :
|
|
299
|
-
selects instanceof Parameter ? selects.digest(value) :
|
|
300
|
-
value;
|
|
301
|
-
});
|
|
302
|
-
|
|
303
|
-
return values;
|
|
304
|
-
}
|
|
305
|
-
|
|
306
|
-
const value = values(raw)[0];
|
|
307
|
-
|
|
308
|
-
if(selects instanceof Parameter)
|
|
309
|
-
return selects.digest(value);
|
|
310
|
-
|
|
311
|
-
if(selects instanceof Field)
|
|
312
|
-
return selects.get(value);
|
|
313
|
-
|
|
314
|
-
return raw;
|
|
315
|
-
}
|
|
316
|
-
}
|
|
317
|
-
|
|
318
|
-
class Value {}
|
|
319
|
-
|
|
320
|
-
class Parameter extends Value {
|
|
321
|
-
index = -1;
|
|
322
|
-
|
|
323
|
-
constructor(index?: number);
|
|
324
|
-
constructor(data?: () => unknown);
|
|
325
|
-
constructor(arg?: number | (() => unknown)){
|
|
326
|
-
super();
|
|
327
|
-
|
|
328
|
-
if(typeof arg == "number")
|
|
329
|
-
this.index = arg;
|
|
330
|
-
else if(typeof arg == "function")
|
|
331
|
-
this.toParam = arg;
|
|
332
|
-
}
|
|
333
|
-
|
|
334
|
-
digest(value: unknown){
|
|
335
|
-
return value;
|
|
336
|
-
}
|
|
337
|
-
|
|
338
|
-
toParam(from: Record<string, any>){
|
|
339
|
-
return this.digest(from[this.index]);
|
|
340
|
-
}
|
|
341
|
-
}
|
|
342
|
-
|
|
343
|
-
export class DataField extends Value {
|
|
344
|
-
field?: Field;
|
|
345
|
-
|
|
346
|
-
constructor(
|
|
347
|
-
public column: string,
|
|
348
|
-
public table: DataTable){
|
|
349
|
-
super();
|
|
350
|
-
}
|
|
351
|
-
|
|
352
|
-
get datatype(){
|
|
353
|
-
return this.field?.datatype || "";
|
|
354
|
-
}
|
|
355
|
-
}
|
|
356
|
-
|
|
357
|
-
class DataTable<T extends Record<string, unknown> = any>
|
|
358
|
-
extends Parameter implements Builder.Table {
|
|
359
|
-
|
|
360
|
-
proxy: { [K in keyof T]: Field<T[K]> };
|
|
361
|
-
output: { [K in keyof T]: unknown }[] = [];
|
|
362
|
-
|
|
363
|
-
used = new Set<DataField>();
|
|
364
|
-
joins: Cond[] = [];
|
|
365
|
-
optional = false;
|
|
366
|
-
fields = new Map<string, Field>();
|
|
367
|
-
name = "input";
|
|
368
|
-
|
|
369
|
-
constructor(
|
|
370
|
-
public parent: Builder,
|
|
371
|
-
input: Iterable<T>){
|
|
372
|
-
|
|
373
|
-
super();
|
|
374
|
-
|
|
375
|
-
const proxy: any = {};
|
|
376
|
-
const keys = new Set<string>();
|
|
377
|
-
|
|
378
|
-
for(const item of input)
|
|
379
|
-
Object.keys(item).forEach(keys.add, keys);
|
|
380
|
-
|
|
381
|
-
for(const key of keys){
|
|
382
|
-
const value = new DataField(key, this);
|
|
383
|
-
|
|
384
|
-
defineProperty(proxy, key, {
|
|
385
|
-
enumerable: true,
|
|
386
|
-
get: () => {
|
|
387
|
-
this.used.add(value);
|
|
388
|
-
return value;
|
|
389
|
-
}
|
|
390
|
-
});
|
|
391
|
-
}
|
|
392
|
-
|
|
393
|
-
this.proxy = proxy;
|
|
394
|
-
this.index = parent.params.length;
|
|
395
|
-
|
|
396
|
-
parent.params.push(this);
|
|
397
|
-
parent.tables.set(proxy, this);
|
|
398
|
-
parent.pending.add(() => {
|
|
399
|
-
Array.from(input, (entry, index) => {
|
|
400
|
-
const emit = {} as any;
|
|
401
|
-
|
|
402
|
-
for(const { column, field } of this.used){
|
|
403
|
-
if(!field)
|
|
404
|
-
throw new Error(`Field for input ${column} is not defined.`);
|
|
405
|
-
|
|
406
|
-
try {
|
|
407
|
-
emit[column] = this.parent.digest(entry[column], field);
|
|
408
|
-
}
|
|
409
|
-
catch(err: unknown){
|
|
410
|
-
let message = `A provided value at \`${column}\` at index [${index}] is not acceptable.`;
|
|
411
|
-
|
|
412
|
-
if(err instanceof Error){
|
|
413
|
-
err.message = message + "\n" + err.message;
|
|
414
|
-
throw err;
|
|
415
|
-
}
|
|
416
|
-
|
|
417
|
-
if(typeof err == "string")
|
|
418
|
-
message += "\n" + err;
|
|
419
|
-
|
|
420
|
-
throw new Error(message);
|
|
421
|
-
}
|
|
422
|
-
}
|
|
423
|
-
|
|
424
|
-
this.output.push(emit);
|
|
425
|
-
});
|
|
426
|
-
});
|
|
427
|
-
}
|
|
428
|
-
|
|
429
|
-
toParam(): any {
|
|
430
|
-
return Array.from(this.output, row => (
|
|
431
|
-
Array.from(this.used, field => row[field.column])
|
|
432
|
-
))
|
|
433
|
-
}
|
|
434
|
-
}
|
|
435
|
-
|
|
436
|
-
export class Cond {
|
|
437
|
-
constructor(
|
|
438
|
-
public readonly left: Field,
|
|
439
|
-
public readonly op: string,
|
|
440
|
-
public readonly right: unknown,
|
|
441
|
-
public readonly restricted = false
|
|
442
|
-
){}
|
|
443
|
-
}
|
|
444
|
-
|
|
445
|
-
class Group {
|
|
446
|
-
children = new Set<Cond | Group>();
|
|
447
|
-
|
|
448
|
-
add(left: Field | Group | Cond, op?: string, right?: unknown){
|
|
449
|
-
if(left instanceof Field)
|
|
450
|
-
left = new Cond(left, op!, right!);
|
|
451
|
-
|
|
452
|
-
this.children.add(left);
|
|
453
|
-
|
|
454
|
-
return left;
|
|
455
|
-
}
|
|
456
|
-
|
|
457
|
-
delete(child: Cond | Group){
|
|
458
|
-
this.children.delete(child);
|
|
459
|
-
}
|
|
460
|
-
|
|
461
|
-
get size(){
|
|
462
|
-
return this.children.size;
|
|
463
|
-
}
|
|
464
|
-
}
|
|
465
|
-
|
|
466
|
-
export { Builder, Parameter, Group, Value, DataTable };
|
package/src/query/Computed.ts
DELETED
|
@@ -1,76 +0,0 @@
|
|
|
1
|
-
import { Query, Field } from "..";
|
|
2
|
-
import { Value } from "./Builder";
|
|
3
|
-
|
|
4
|
-
type ANumeric = Query.Value<string | number>;
|
|
5
|
-
type Numeric = Query.Value<number>;
|
|
6
|
-
|
|
7
|
-
export interface Bitwise {
|
|
8
|
-
not(value: Numeric): Numeric;
|
|
9
|
-
and(left: Numeric, right: Numeric): Numeric;
|
|
10
|
-
or(left: Numeric, right: Numeric): Numeric;
|
|
11
|
-
xor(left: Numeric, right: Numeric): Numeric;
|
|
12
|
-
left(value: Numeric, shift: Numeric): Numeric;
|
|
13
|
-
right(value: Numeric, shift: Numeric): Numeric;
|
|
14
|
-
}
|
|
15
|
-
|
|
16
|
-
export interface MathOps {
|
|
17
|
-
add(left: Numeric, right: Numeric): Numeric;
|
|
18
|
-
add(left: ANumeric, right: ANumeric): ANumeric;
|
|
19
|
-
sub(left: Numeric, right: Numeric): Numeric;
|
|
20
|
-
mul(left: Numeric, right: Numeric): Numeric;
|
|
21
|
-
div(left: Numeric, right: Numeric): Numeric;
|
|
22
|
-
mod(left: Numeric, right: Numeric): Numeric;
|
|
23
|
-
neg(value: Numeric): Numeric;
|
|
24
|
-
pos(value: Numeric): Numeric;
|
|
25
|
-
}
|
|
26
|
-
|
|
27
|
-
function op(operator: string, rank: number, unary?: boolean) {
|
|
28
|
-
return (left: Value, right?: Value) => {
|
|
29
|
-
return new Computed(operator, left, unary ? undefined : right, rank);
|
|
30
|
-
};
|
|
31
|
-
}
|
|
32
|
-
|
|
33
|
-
export const math: MathOps = {
|
|
34
|
-
add: op('+', 4),
|
|
35
|
-
sub: op('-', 4),
|
|
36
|
-
mul: op('*', 5),
|
|
37
|
-
div: op('/', 5),
|
|
38
|
-
mod: op('%', 5),
|
|
39
|
-
neg: op('-', 7, true),
|
|
40
|
-
pos: op('+', 7, true),
|
|
41
|
-
}
|
|
42
|
-
|
|
43
|
-
export const bit: Bitwise = {
|
|
44
|
-
not: op('~', 6, true),
|
|
45
|
-
left: op('<<', 3),
|
|
46
|
-
right: op('>>', 3),
|
|
47
|
-
and: op('&', 2),
|
|
48
|
-
or: op('|', 0),
|
|
49
|
-
xor: op('^', 1),
|
|
50
|
-
}
|
|
51
|
-
|
|
52
|
-
export class Computed<T> extends Value {
|
|
53
|
-
readonly left?: Query.Value | Field<T> | Computed<T>;
|
|
54
|
-
readonly right: Query.Value | Field<T> | Computed<T>;
|
|
55
|
-
|
|
56
|
-
readonly operator: string;
|
|
57
|
-
readonly rank: number;
|
|
58
|
-
|
|
59
|
-
constructor(
|
|
60
|
-
operator: string,
|
|
61
|
-
value: Value | Field<T> | Computed<T>,
|
|
62
|
-
right?: Value | Field<T> | Computed<T>,
|
|
63
|
-
rank: number = 0
|
|
64
|
-
) {
|
|
65
|
-
super();
|
|
66
|
-
this.operator = operator;
|
|
67
|
-
this.rank = rank;
|
|
68
|
-
|
|
69
|
-
if (right === undefined)
|
|
70
|
-
this.right = value;
|
|
71
|
-
else {
|
|
72
|
-
this.left = value;
|
|
73
|
-
this.right = right;
|
|
74
|
-
}
|
|
75
|
-
}
|
|
76
|
-
}
|