@devrev/meerkat-core 0.0.84 → 0.0.85

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.
Files changed (34) hide show
  1. package/package.json +1 -1
  2. package/src/ast-serializer/ast-serializer.d.ts +1 -0
  3. package/src/ast-serializer/ast-serializer.js +12 -0
  4. package/src/ast-serializer/ast-serializer.js.map +1 -0
  5. package/src/ast-validator/dimension-validator.d.ts +10 -0
  6. package/src/ast-validator/dimension-validator.js +54 -0
  7. package/src/ast-validator/dimension-validator.js.map +1 -0
  8. package/src/ast-validator/index.d.ts +3 -0
  9. package/src/ast-validator/index.js +21 -0
  10. package/src/ast-validator/index.js.map +1 -0
  11. package/src/ast-validator/measure-validator.d.ts +11 -0
  12. package/src/ast-validator/measure-validator.js +162 -0
  13. package/src/ast-validator/measure-validator.js.map +1 -0
  14. package/src/ast-validator/tests/test-data.d.ts +2115 -0
  15. package/src/ast-validator/tests/test-data.js +2060 -0
  16. package/src/ast-validator/tests/test-data.js.map +1 -0
  17. package/src/ast-validator/types.d.ts +8 -0
  18. package/src/ast-validator/types.js +3 -0
  19. package/src/ast-validator/types.js.map +1 -0
  20. package/src/ast-validator/utils.d.ts +4 -0
  21. package/src/ast-validator/utils.js +35 -0
  22. package/src/ast-validator/utils.js.map +1 -0
  23. package/src/cube-filter-transformer/not/not.d.ts +2 -2
  24. package/src/cube-filter-transformer/not/not.js.map +1 -1
  25. package/src/index.d.ts +4 -1
  26. package/src/index.js +3 -0
  27. package/src/index.js.map +1 -1
  28. package/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.ts +17 -0
  29. package/src/types/duckdb-serialization-types/serialization/ParsedExpression.js.map +1 -1
  30. package/src/types/utils.d.ts +19 -0
  31. package/src/types/utils.js +108 -0
  32. package/src/types/utils.js.map +1 -0
  33. package/src/utils/base-ast.js +2 -3
  34. package/src/utils/base-ast.js.map +1 -1
package/src/ast-validator/tests/test-data.js ADDED
@@ -0,0 +1,2060 @@
1
+ "use strict";
2
+ function _export(target, all) {
3
+ for(var name in all)Object.defineProperty(target, name, {
4
+ enumerable: true,
5
+ get: all[name]
6
+ });
7
+ }
8
+ _export(exports, {
9
+ EMPTY_VALID_FUNCTIONS: function() {
10
+ return EMPTY_VALID_FUNCTIONS;
11
+ },
12
+ VALID_FUNCTIONS: function() {
13
+ return VALID_FUNCTIONS;
14
+ },
15
+ COLUMN_REF_NODE: function() {
16
+ return COLUMN_REF_NODE;
17
+ },
18
+ INVALID_NODE: function() {
19
+ return INVALID_NODE;
20
+ },
21
+ DIMENSION_TEST_CASES: function() {
22
+ return DIMENSION_TEST_CASES;
23
+ },
24
+ MEASURE_TEST_CASES: function() {
25
+ return MEASURE_TEST_CASES;
26
+ }
27
+ });
28
+ const _duckdbserializationtypes = require("../../types/duckdb-serialization-types");
29
+ const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
30
+ const EMPTY_VALID_FUNCTIONS = new Set();
31
+ const VALID_FUNCTIONS = new Set([
32
+ 'contains',
33
+ 'round',
34
+ 'power'
35
+ ]);
36
+ const COLUMN_REF_NODE = {
37
+ class: _Expression.ExpressionClass.COLUMN_REF,
38
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
39
+ alias: 'alias',
40
+ query_location: 0,
41
+ column_names: [
42
+ 'column_name'
43
+ ]
44
+ };
45
+ const INVALID_NODE = {
46
+ class: _Expression.ExpressionClass.INVALID,
47
+ type: _duckdbserializationtypes.ExpressionType.INVALID,
48
+ alias: '',
49
+ query_location: 0
50
+ };
51
+ const DIMENSION_TEST_CASES = [
52
+ {
53
+ description: 'node type COLUMN_REF',
54
+ node: {
55
+ class: _Expression.ExpressionClass.COLUMN_REF,
56
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
57
+ alias: '',
58
+ query_location: 0,
59
+ column_names: [
60
+ 'column_name'
61
+ ]
62
+ },
63
+ validFunctions: EMPTY_VALID_FUNCTIONS,
64
+ expected: true
65
+ },
66
+ {
67
+ description: 'node type COLUMN_REF with alias',
68
+ node: COLUMN_REF_NODE,
69
+ validFunctions: EMPTY_VALID_FUNCTIONS,
70
+ expected: true
71
+ },
72
+ {
73
+ description: 'node type VALUE_CONSTANT',
74
+ node: {
75
+ class: _Expression.ExpressionClass.CONSTANT,
76
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
77
+ alias: '',
78
+ query_location: 0,
79
+ value: '1'
80
+ },
81
+ validFunctions: EMPTY_VALID_FUNCTIONS,
82
+ expected: true
83
+ },
84
+ {
85
+ description: 'node type OPERATOR_CAST',
86
+ node: {
87
+ class: _Expression.ExpressionClass.CAST,
88
+ type: _duckdbserializationtypes.ExpressionType.OPERATOR_CAST,
89
+ alias: '',
90
+ query_location: 7,
91
+ child: {
92
+ class: _Expression.ExpressionClass.COLUMN_REF,
93
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
94
+ alias: '',
95
+ query_location: 12,
96
+ column_names: [
97
+ 'column_name'
98
+ ]
99
+ },
100
+ cast_type: {
101
+ id: 1
102
+ },
103
+ try_cast: false
104
+ },
105
+ validFunctions: EMPTY_VALID_FUNCTIONS,
106
+ expected: true
107
+ },
108
+ {
109
+ description: 'node type OPERATOR_COALESCE',
110
+ node: {
111
+ class: _Expression.ExpressionClass.OPERATOR,
112
+ type: _duckdbserializationtypes.ExpressionType.OPERATOR_COALESCE,
113
+ alias: '',
114
+ query_location: 18446744073709552000,
115
+ children: [
116
+ {
117
+ class: _Expression.ExpressionClass.COLUMN_REF,
118
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
119
+ alias: '',
120
+ query_location: 16,
121
+ column_names: [
122
+ 'column_name'
123
+ ]
124
+ },
125
+ {
126
+ class: _Expression.ExpressionClass.CONSTANT,
127
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
128
+ alias: '',
129
+ query_location: 38,
130
+ value: {
131
+ type: {
132
+ id: 'INTEGER',
133
+ type_info: null
134
+ },
135
+ is_null: false,
136
+ value: 0
137
+ }
138
+ }
139
+ ]
140
+ },
141
+ validFunctions: EMPTY_VALID_FUNCTIONS,
142
+ expected: true
143
+ },
144
+ {
145
+ description: 'node type FUNCTION with ROUND function and if it contains in validFunctions',
146
+ node: {
147
+ class: _Expression.ExpressionClass.FUNCTION,
148
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
149
+ alias: '',
150
+ query_location: 7,
151
+ function_name: 'round',
152
+ schema: '',
153
+ children: [
154
+ {
155
+ class: _Expression.ExpressionClass.COLUMN_REF,
156
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
157
+ alias: '',
158
+ query_location: 13,
159
+ column_names: [
160
+ 'column_name'
161
+ ]
162
+ },
163
+ {
164
+ class: _Expression.ExpressionClass.CONSTANT,
165
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
166
+ alias: '',
167
+ query_location: 41,
168
+ value: {
169
+ type: {
170
+ id: 'INTEGER',
171
+ type_info: null
172
+ },
173
+ is_null: false,
174
+ value: 1
175
+ }
176
+ }
177
+ ],
178
+ filter: null,
179
+ order_bys: {
180
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
181
+ orders: []
182
+ },
183
+ distinct: false,
184
+ is_operator: false,
185
+ export_state: false
186
+ },
187
+ validFunctions: VALID_FUNCTIONS,
188
+ expected: true
189
+ },
190
+ {
191
+ description: 'node type CASE',
192
+ node: {
193
+ class: _Expression.ExpressionClass.CASE,
194
+ type: _duckdbserializationtypes.ExpressionType.CASE_EXPR,
195
+ alias: '',
196
+ query_location: 7,
197
+ case_checks: [
198
+ {
199
+ when_expr: {
200
+ class: _Expression.ExpressionClass.COMPARISON,
201
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_GREATERTHAN,
202
+ alias: '',
203
+ query_location: 35,
204
+ left: {
205
+ class: _Expression.ExpressionClass.COLUMN_REF,
206
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
207
+ alias: '',
208
+ query_location: 17,
209
+ column_names: [
210
+ 'actual_close_date'
211
+ ]
212
+ },
213
+ right: {
214
+ class: _Expression.ExpressionClass.COLUMN_REF,
215
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
216
+ alias: '',
217
+ query_location: 37,
218
+ column_names: [
219
+ 'created_date'
220
+ ]
221
+ }
222
+ },
223
+ then_expr: {
224
+ class: _Expression.ExpressionClass.COLUMN_REF,
225
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
226
+ alias: '',
227
+ query_location: 55,
228
+ column_names: [
229
+ 'actual_close_date'
230
+ ]
231
+ }
232
+ }
233
+ ],
234
+ else_expr: {
235
+ class: _Expression.ExpressionClass.CONSTANT,
236
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
237
+ alias: '',
238
+ query_location: 18446744073709552000,
239
+ value: {
240
+ type: {
241
+ id: 'NULL',
242
+ type_info: null
243
+ },
244
+ is_null: true
245
+ }
246
+ }
247
+ },
248
+ validFunctions: EMPTY_VALID_FUNCTIONS,
249
+ expected: true
250
+ }
251
+ ];
252
+ const MEASURE_TEST_CASES = [
253
+ {
254
+ description: 'node type FUNCTION with count_star',
255
+ query: 'count_star()',
256
+ node: {
257
+ class: _Expression.ExpressionClass.FUNCTION,
258
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
259
+ alias: '',
260
+ query_location: 7,
261
+ function_name: 'count_star',
262
+ schema: '',
263
+ children: []
264
+ },
265
+ validFunctions: new Set([
266
+ 'count_star'
267
+ ]),
268
+ validScalarFunctions: EMPTY_VALID_FUNCTIONS,
269
+ expected: true
270
+ },
271
+ {
272
+ description: 'node type FUNCTION with SUM',
273
+ query: 'sum(column1)',
274
+ node: {
275
+ class: _Expression.ExpressionClass.FUNCTION,
276
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
277
+ alias: '',
278
+ query_location: 7,
279
+ function_name: 'sum',
280
+ schema: '',
281
+ children: [
282
+ {
283
+ class: _Expression.ExpressionClass.COLUMN_REF,
284
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
285
+ query_location: 11,
286
+ column_names: [
287
+ 'column1'
288
+ ]
289
+ }
290
+ ],
291
+ filter: null,
292
+ order_bys: {
293
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
294
+ orders: []
295
+ },
296
+ distinct: false,
297
+ is_operator: false,
298
+ export_state: false
299
+ },
300
+ validFunctions: new Set([
301
+ 'sum'
302
+ ]),
303
+ validScalarFunctions: EMPTY_VALID_FUNCTIONS,
304
+ expected: true
305
+ },
306
+ {
307
+ description: 'node type FUNCTION with SUM and invalid function type',
308
+ query: 'sum(column1)',
309
+ node: {
310
+ class: _Expression.ExpressionClass.FUNCTION,
311
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
312
+ alias: '',
313
+ query_location: 7,
314
+ function_name: 'sum',
315
+ schema: '',
316
+ children: [
317
+ {
318
+ class: _Expression.ExpressionClass.COLUMN_REF,
319
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
320
+ query_location: 11,
321
+ column_names: [
322
+ 'column1'
323
+ ]
324
+ }
325
+ ],
326
+ filter: null,
327
+ order_bys: {
328
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
329
+ orders: []
330
+ },
331
+ distinct: false,
332
+ is_operator: false,
333
+ export_state: false
334
+ },
335
+ validFunctions: new Set([
336
+ 'min'
337
+ ]),
338
+ validScalarFunctions: new Set([
339
+ '/'
340
+ ]),
341
+ error: 'Invalid function type: sum',
342
+ expected: 'error'
343
+ },
344
+ {
345
+ description: 'node type FUNCTION with MAX and operator',
346
+ query: 'max(column1) / 1000',
347
+ node: {
348
+ class: _Expression.ExpressionClass.FUNCTION,
349
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
350
+ alias: '',
351
+ query_location: 38,
352
+ function_name: '/',
353
+ schema: '',
354
+ children: [
355
+ {
356
+ class: _Expression.ExpressionClass.FUNCTION,
357
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
358
+ alias: '',
359
+ query_location: 7,
360
+ function_name: 'max',
361
+ schema: '',
362
+ children: [
363
+ {
364
+ class: _Expression.ExpressionClass.COLUMN_REF,
365
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
366
+ alias: '',
367
+ query_location: 11,
368
+ column_names: [
369
+ 'column1'
370
+ ]
371
+ }
372
+ ],
373
+ filter: null,
374
+ order_bys: {
375
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
376
+ orders: []
377
+ },
378
+ distinct: false,
379
+ is_operator: false,
380
+ export_state: false,
381
+ catalog: ''
382
+ },
383
+ {
384
+ class: _Expression.ExpressionClass.CONSTANT,
385
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
386
+ alias: '',
387
+ query_location: 40,
388
+ value: {
389
+ type: {
390
+ id: 'INTEGER',
391
+ type_info: null
392
+ },
393
+ is_null: false,
394
+ value: 1000
395
+ }
396
+ }
397
+ ],
398
+ filter: null,
399
+ order_bys: {
400
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
401
+ orders: []
402
+ },
403
+ distinct: false,
404
+ is_operator: true,
405
+ export_state: false,
406
+ catalog: ''
407
+ },
408
+ validFunctions: new Set([
409
+ 'max'
410
+ ]),
411
+ validScalarFunctions: new Set([
412
+ '/'
413
+ ]),
414
+ expected: true
415
+ },
416
+ {
417
+ description: 'node type CASE_EXPR',
418
+ query: 'CASE WHEN COUNT(id) > 1 THEN AVG(mtbf_hours) ELSE null END',
419
+ node: {
420
+ class: _Expression.ExpressionClass.CASE,
421
+ type: _duckdbserializationtypes.ExpressionType.CASE_EXPR,
422
+ alias: '',
423
+ query_location: 7,
424
+ case_checks: [
425
+ {
426
+ when_expr: {
427
+ class: _Expression.ExpressionClass.COMPARISON,
428
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_GREATERTHAN,
429
+ alias: '',
430
+ query_location: 27,
431
+ left: {
432
+ class: _Expression.ExpressionClass.FUNCTION,
433
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
434
+ alias: '',
435
+ query_location: 17,
436
+ function_name: 'count',
437
+ schema: '',
438
+ children: [
439
+ {
440
+ class: _Expression.ExpressionClass.COLUMN_REF,
441
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
442
+ alias: '',
443
+ query_location: 23,
444
+ column_names: [
445
+ 'id'
446
+ ]
447
+ }
448
+ ],
449
+ filter: null,
450
+ order_bys: {
451
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
452
+ orders: []
453
+ },
454
+ distinct: false,
455
+ is_operator: false,
456
+ export_state: false,
457
+ catalog: ''
458
+ },
459
+ right: {
460
+ class: _Expression.ExpressionClass.CONSTANT,
461
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
462
+ alias: '',
463
+ query_location: 29,
464
+ value: {
465
+ type: {
466
+ id: 'INTEGER',
467
+ type_info: null
468
+ },
469
+ is_null: false,
470
+ value: 1
471
+ }
472
+ }
473
+ },
474
+ then_expr: {
475
+ class: _Expression.ExpressionClass.FUNCTION,
476
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
477
+ alias: '',
478
+ query_location: 36,
479
+ function_name: 'avg',
480
+ schema: '',
481
+ children: [
482
+ {
483
+ class: _Expression.ExpressionClass.COLUMN_REF,
484
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
485
+ alias: '',
486
+ query_location: 40,
487
+ column_names: [
488
+ 'mtbf_hours'
489
+ ]
490
+ }
491
+ ],
492
+ filter: null,
493
+ order_bys: {
494
+ type: _duckdbserializationtypes.ResultModifierType.ORDER_MODIFIER,
495
+ orders: []
496
+ },
497
+ distinct: false,
498
+ is_operator: false,
499
+ export_state: false,
500
+ catalog: ''
501
+ }
502
+ }
503
+ ],
504
+ else_expr: {
505
+ class: _Expression.ExpressionClass.CONSTANT,
506
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
507
+ alias: '',
508
+ query_location: 57,
509
+ value: {
510
+ type: {
511
+ id: 'NULL',
512
+ type_info: null
513
+ },
514
+ is_null: true
515
+ }
516
+ }
517
+ },
518
+ validFunctions: new Set([
519
+ 'count',
520
+ 'avg'
521
+ ]),
522
+ validScalarFunctions: EMPTY_VALID_FUNCTIONS,
523
+ expected: true
524
+ },
525
+ {
526
+ description: 'node type FUNCTION with aggregation and case statement within',
527
+ node: {
528
+ class: _Expression.ExpressionClass.FUNCTION,
529
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
530
+ alias: '',
531
+ query_location: 7,
532
+ function_name: 'max',
533
+ schema: '',
534
+ children: [
535
+ {
536
+ class: 'CASE',
537
+ type: 'CASE_EXPR',
538
+ alias: '',
539
+ query_location: 11,
540
+ case_checks: [
541
+ {
542
+ when_expr: {
543
+ class: _Expression.ExpressionClass.COMPARISON,
544
+ type: 'COMPARE_EQUAL',
545
+ alias: '',
546
+ query_location: 43,
547
+ left: {
548
+ class: _Expression.ExpressionClass.FUNCTION,
549
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
550
+ alias: '',
551
+ query_location: 32,
552
+ function_name: '->>',
553
+ schema: '',
554
+ children: [
555
+ {
556
+ class: _Expression.ExpressionClass.COLUMN_REF,
557
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
558
+ alias: '',
559
+ query_location: 21,
560
+ column_names: [
561
+ 'stage_json'
562
+ ]
563
+ },
564
+ {
565
+ class: _Expression.ExpressionClass.CONSTANT,
566
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
567
+ alias: '',
568
+ query_location: 36,
569
+ value: {
570
+ type: {
571
+ id: 'VARCHAR',
572
+ type_info: null
573
+ },
574
+ is_null: false,
575
+ value: 'name'
576
+ }
577
+ }
578
+ ],
579
+ filter: null,
580
+ order_bys: {
581
+ type: 'ORDER_MODIFIER',
582
+ orders: []
583
+ },
584
+ distinct: false,
585
+ is_operator: true,
586
+ export_state: false,
587
+ catalog: ''
588
+ },
589
+ right: {
590
+ class: _Expression.ExpressionClass.CONSTANT,
591
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
592
+ alias: '',
593
+ query_location: 45,
594
+ value: {
595
+ type: {
596
+ id: 'VARCHAR',
597
+ type_info: null
598
+ },
599
+ is_null: false,
600
+ value: 'Tech Doc Inprogress'
601
+ }
602
+ }
603
+ },
604
+ then_expr: {
605
+ class: _Expression.ExpressionClass.COLUMN_REF,
606
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
607
+ alias: '',
608
+ query_location: 72,
609
+ column_names: [
610
+ 'modified_date'
611
+ ]
612
+ }
613
+ }
614
+ ],
615
+ else_expr: {
616
+ class: _Expression.ExpressionClass.CONSTANT,
617
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
618
+ alias: '',
619
+ query_location: 91,
620
+ value: {
621
+ type: {
622
+ id: 'NULL',
623
+ type_info: null
624
+ },
625
+ is_null: true
626
+ }
627
+ }
628
+ }
629
+ ],
630
+ filter: null,
631
+ order_bys: {
632
+ type: 'ORDER_MODIFIER',
633
+ orders: []
634
+ },
635
+ distinct: false,
636
+ is_operator: false,
637
+ export_state: false,
638
+ catalog: ''
639
+ },
640
+ validFunctions: new Set([
641
+ 'max'
642
+ ]),
643
+ validScalarFunctions: EMPTY_VALID_FUNCTIONS,
644
+ expected: true,
645
+ query: 'max(CASE WHEN stage_json->>name = "Tech" THEN modified_date ELSE NULL END)'
646
+ },
647
+ {
648
+ description: 'node type FUNCTION two children of aggregation and operator operation on them',
649
+ node: {
650
+ class: _Expression.ExpressionClass.FUNCTION,
651
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
652
+ alias: '',
653
+ query_location: 49,
654
+ function_name: '/',
655
+ schema: '',
656
+ children: [
657
+ {
658
+ class: _Expression.ExpressionClass.FUNCTION,
659
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
660
+ alias: '',
661
+ query_location: 7,
662
+ function_name: 'sum',
663
+ schema: '',
664
+ children: [
665
+ {
666
+ class: _Expression.ExpressionClass.FUNCTION,
667
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
668
+ alias: '',
669
+ query_location: 32,
670
+ function_name: '*',
671
+ schema: '',
672
+ children: [
673
+ {
674
+ class: _Expression.ExpressionClass.COLUMN_REF,
675
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
676
+ alias: '',
677
+ query_location: 11,
678
+ column_names: [
679
+ 'mean_reciprocal_rank'
680
+ ]
681
+ },
682
+ {
683
+ class: _Expression.ExpressionClass.COLUMN_REF,
684
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
685
+ alias: '',
686
+ query_location: 34,
687
+ column_names: [
688
+ 'total_queries'
689
+ ]
690
+ }
691
+ ],
692
+ filter: null,
693
+ order_bys: {
694
+ type: 'ORDER_MODIFIER',
695
+ orders: []
696
+ },
697
+ distinct: false,
698
+ is_operator: true,
699
+ export_state: false,
700
+ catalog: ''
701
+ }
702
+ ],
703
+ filter: null,
704
+ order_bys: {
705
+ type: 'ORDER_MODIFIER',
706
+ orders: []
707
+ },
708
+ distinct: false,
709
+ is_operator: false,
710
+ export_state: false,
711
+ catalog: ''
712
+ },
713
+ {
714
+ class: _Expression.ExpressionClass.FUNCTION,
715
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
716
+ alias: '',
717
+ query_location: 51,
718
+ function_name: 'sum',
719
+ schema: '',
720
+ children: [
721
+ {
722
+ class: _Expression.ExpressionClass.COLUMN_REF,
723
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
724
+ alias: '',
725
+ query_location: 55,
726
+ column_names: [
727
+ 'total_queries'
728
+ ]
729
+ }
730
+ ],
731
+ filter: null,
732
+ order_bys: {
733
+ type: 'ORDER_MODIFIER',
734
+ orders: []
735
+ },
736
+ distinct: false,
737
+ is_operator: false,
738
+ export_state: false,
739
+ catalog: ''
740
+ }
741
+ ],
742
+ filter: null,
743
+ order_bys: {
744
+ type: 'ORDER_MODIFIER',
745
+ orders: []
746
+ },
747
+ distinct: false,
748
+ is_operator: true,
749
+ export_state: false,
750
+ catalog: ''
751
+ },
752
+ validFunctions: new Set([
753
+ 'sum'
754
+ ]),
755
+ validScalarFunctions: new Set([
756
+ '/',
757
+ '*'
758
+ ]),
759
+ expected: true,
760
+ query: 'sum(mean_reciprocal_rank * total_queries) / sum(total_queries)'
761
+ },
762
+ {
763
+ description: 'node type CAST',
764
+ query: "CAST(COUNT(DISTINCT(id)) AS FLOAT) / NULLIF(DATEDIFF('day', MIN(created_date), MAX(created_date)) / 7 + 1, 0)",
765
+ node: {
766
+ class: _Expression.ExpressionClass.FUNCTION,
767
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
768
+ alias: '',
769
+ query_location: 42,
770
+ function_name: '/',
771
+ schema: '',
772
+ children: [
773
+ {
774
+ class: 'CAST',
775
+ type: 'OPERATOR_CAST',
776
+ alias: '',
777
+ query_location: 7,
778
+ child: {
779
+ class: _Expression.ExpressionClass.FUNCTION,
780
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
781
+ alias: '',
782
+ query_location: 12,
783
+ function_name: 'count',
784
+ schema: '',
785
+ children: [
786
+ {
787
+ class: _Expression.ExpressionClass.COLUMN_REF,
788
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
789
+ alias: '',
790
+ query_location: 27,
791
+ column_names: [
792
+ 'id'
793
+ ]
794
+ }
795
+ ],
796
+ filter: null,
797
+ order_bys: {
798
+ type: 'ORDER_MODIFIER',
799
+ orders: []
800
+ },
801
+ distinct: true,
802
+ is_operator: false,
803
+ export_state: false,
804
+ catalog: ''
805
+ },
806
+ cast_type: {
807
+ id: 'FLOAT',
808
+ type_info: null
809
+ },
810
+ try_cast: false
811
+ },
812
+ {
813
+ class: _Expression.ExpressionClass.FUNCTION,
814
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
815
+ alias: '',
816
+ query_location: 44,
817
+ function_name: 'nullif',
818
+ schema: '',
819
+ children: [
820
+ {
821
+ class: _Expression.ExpressionClass.FUNCTION,
822
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
823
+ alias: '',
824
+ query_location: 109,
825
+ function_name: '+',
826
+ schema: '',
827
+ children: [
828
+ {
829
+ class: _Expression.ExpressionClass.FUNCTION,
830
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
831
+ alias: '',
832
+ query_location: 105,
833
+ function_name: '/',
834
+ schema: '',
835
+ children: [
836
+ {
837
+ class: _Expression.ExpressionClass.FUNCTION,
838
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
839
+ alias: '',
840
+ query_location: 51,
841
+ function_name: 'datediff',
842
+ schema: '',
843
+ children: [
844
+ {
845
+ class: _Expression.ExpressionClass.CONSTANT,
846
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
847
+ alias: '',
848
+ query_location: 60,
849
+ value: {
850
+ type: {
851
+ id: 'VARCHAR',
852
+ type_info: null
853
+ },
854
+ is_null: false,
855
+ value: 'day'
856
+ }
857
+ },
858
+ {
859
+ class: _Expression.ExpressionClass.FUNCTION,
860
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
861
+ alias: '',
862
+ query_location: 67,
863
+ function_name: 'min',
864
+ schema: '',
865
+ children: [
866
+ {
867
+ class: _Expression.ExpressionClass.COLUMN_REF,
868
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
869
+ alias: '',
870
+ query_location: 71,
871
+ column_names: [
872
+ 'created_date'
873
+ ]
874
+ }
875
+ ],
876
+ filter: null,
877
+ order_bys: {
878
+ type: 'ORDER_MODIFIER',
879
+ orders: []
880
+ },
881
+ distinct: false,
882
+ is_operator: false,
883
+ export_state: false,
884
+ catalog: ''
885
+ },
886
+ {
887
+ class: _Expression.ExpressionClass.FUNCTION,
888
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
889
+ alias: '',
890
+ query_location: 86,
891
+ function_name: 'max',
892
+ schema: '',
893
+ children: [
894
+ {
895
+ class: _Expression.ExpressionClass.COLUMN_REF,
896
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
897
+ alias: '',
898
+ query_location: 90,
899
+ column_names: [
900
+ 'created_date'
901
+ ]
902
+ }
903
+ ],
904
+ filter: null,
905
+ order_bys: {
906
+ type: 'ORDER_MODIFIER',
907
+ orders: []
908
+ },
909
+ distinct: false,
910
+ is_operator: false,
911
+ export_state: false,
912
+ catalog: ''
913
+ }
914
+ ],
915
+ filter: null,
916
+ order_bys: {
917
+ type: 'ORDER_MODIFIER',
918
+ orders: []
919
+ },
920
+ distinct: false,
921
+ is_operator: false,
922
+ export_state: false,
923
+ catalog: ''
924
+ },
925
+ {
926
+ class: _Expression.ExpressionClass.CONSTANT,
927
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
928
+ alias: '',
929
+ query_location: 107,
930
+ value: {
931
+ type: {
932
+ id: 'INTEGER',
933
+ type_info: null
934
+ },
935
+ is_null: false,
936
+ value: 7
937
+ }
938
+ }
939
+ ],
940
+ filter: null,
941
+ order_bys: {
942
+ type: 'ORDER_MODIFIER',
943
+ orders: []
944
+ },
945
+ distinct: false,
946
+ is_operator: true,
947
+ export_state: false,
948
+ catalog: ''
949
+ },
950
+ {
951
+ class: _Expression.ExpressionClass.CONSTANT,
952
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
953
+ alias: '',
954
+ query_location: 111,
955
+ value: {
956
+ type: {
957
+ id: 'INTEGER',
958
+ type_info: null
959
+ },
960
+ is_null: false,
961
+ value: 1
962
+ }
963
+ }
964
+ ],
965
+ filter: null,
966
+ order_bys: {
967
+ type: 'ORDER_MODIFIER',
968
+ orders: []
969
+ },
970
+ distinct: false,
971
+ is_operator: true,
972
+ export_state: false,
973
+ catalog: ''
974
+ },
975
+ {
976
+ class: _Expression.ExpressionClass.CONSTANT,
977
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
978
+ alias: '',
979
+ query_location: 114,
980
+ value: {
981
+ type: {
982
+ id: 'INTEGER',
983
+ type_info: null
984
+ },
985
+ is_null: false,
986
+ value: 0
987
+ }
988
+ }
989
+ ],
990
+ filter: null,
991
+ order_bys: {
992
+ type: 'ORDER_MODIFIER',
993
+ orders: []
994
+ },
995
+ distinct: false,
996
+ is_operator: false,
997
+ export_state: false,
998
+ catalog: ''
999
+ }
1000
+ ],
1001
+ filter: null,
1002
+ order_bys: {
1003
+ type: 'ORDER_MODIFIER',
1004
+ orders: []
1005
+ },
1006
+ distinct: false,
1007
+ is_operator: true,
1008
+ export_state: false,
1009
+ catalog: ''
1010
+ },
1011
+ validFunctions: new Set([
1012
+ 'count',
1013
+ 'datediff',
1014
+ 'min',
1015
+ 'max'
1016
+ ]),
1017
+ validScalarFunctions: new Set([
1018
+ '/',
1019
+ '*'
1020
+ ]),
1021
+ expected: true
1022
+ },
1023
+ {
1024
+ description: 'node type COALESCE',
1025
+ query: 'COALESCE(SUM(amount) FILTER(direction = "Income"), 0)',
1026
+ node: {
1027
+ class: _Expression.ExpressionClass.OPERATOR,
1028
+ type: _duckdbserializationtypes.ExpressionType.OPERATOR_COALESCE,
1029
+ alias: '',
1030
+ query_location: 18446744073709552000,
1031
+ children: [
1032
+ {
1033
+ class: _Expression.ExpressionClass.FUNCTION,
1034
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1035
+ alias: '',
1036
+ query_location: 16,
1037
+ function_name: 'sum',
1038
+ schema: '',
1039
+ children: [
1040
+ {
1041
+ class: _Expression.ExpressionClass.COLUMN_REF,
1042
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1043
+ alias: '',
1044
+ query_location: 20,
1045
+ column_names: [
1046
+ 'amount'
1047
+ ]
1048
+ }
1049
+ ],
1050
+ filter: {
1051
+ class: _Expression.ExpressionClass.COMPARISON,
1052
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_EQUAL,
1053
+ alias: '',
1054
+ query_location: 45,
1055
+ left: {
1056
+ class: _Expression.ExpressionClass.COLUMN_REF,
1057
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1058
+ alias: '',
1059
+ query_location: 35,
1060
+ column_names: [
1061
+ 'direction'
1062
+ ]
1063
+ },
1064
+ right: {
1065
+ class: _Expression.ExpressionClass.COLUMN_REF,
1066
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1067
+ alias: '',
1068
+ query_location: 47,
1069
+ column_names: [
1070
+ 'Income'
1071
+ ]
1072
+ }
1073
+ },
1074
+ order_bys: {
1075
+ type: 'ORDER_MODIFIER',
1076
+ orders: []
1077
+ },
1078
+ distinct: false,
1079
+ is_operator: false,
1080
+ export_state: false,
1081
+ catalog: ''
1082
+ },
1083
+ {
1084
+ class: _Expression.ExpressionClass.CONSTANT,
1085
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1086
+ alias: '',
1087
+ query_location: 58,
1088
+ value: {
1089
+ type: {
1090
+ id: 'INTEGER',
1091
+ type_info: null
1092
+ },
1093
+ is_null: false,
1094
+ value: 0
1095
+ }
1096
+ }
1097
+ ]
1098
+ },
1099
+ validFunctions: new Set([
1100
+ 'sum'
1101
+ ]),
1102
+ validScalarFunctions: new Set([
1103
+ '/'
1104
+ ]),
1105
+ expected: true
1106
+ },
1107
+ {
1108
+ description: 'node type WINDOW_AGGREGATE',
1109
+ query: 'AVG(COUNT(column1)) OVER (ORDER BY (MEERKAT).record_date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW)',
1110
+ node: {
1111
+ class: _Expression.ExpressionClass.WINDOW,
1112
+ type: _duckdbserializationtypes.ExpressionType.WINDOW_AGGREGATE,
1113
+ alias: '',
1114
+ query_location: 7,
1115
+ function_name: 'avg',
1116
+ schema: '',
1117
+ catalog: '',
1118
+ children: [
1119
+ {
1120
+ class: _Expression.ExpressionClass.FUNCTION,
1121
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1122
+ alias: '',
1123
+ query_location: 11,
1124
+ function_name: 'count',
1125
+ schema: '',
1126
+ children: [
1127
+ {
1128
+ class: _Expression.ExpressionClass.COLUMN_REF,
1129
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1130
+ alias: '',
1131
+ query_location: 17,
1132
+ column_names: [
1133
+ 'number_deployments'
1134
+ ]
1135
+ }
1136
+ ],
1137
+ filter: null,
1138
+ order_bys: {
1139
+ type: 'ORDER_MODIFIER',
1140
+ orders: []
1141
+ },
1142
+ distinct: false,
1143
+ is_operator: false,
1144
+ export_state: false,
1145
+ catalog: ''
1146
+ }
1147
+ ],
1148
+ partitions: [],
1149
+ orders: [
1150
+ {
1151
+ type: 'ORDER_DEFAULT',
1152
+ null_order: 'ORDER_DEFAULT',
1153
+ expression: {
1154
+ class: 'OPERATOR',
1155
+ type: 'STRUCT_EXTRACT',
1156
+ alias: '',
1157
+ query_location: 18446744073709552000,
1158
+ children: [
1159
+ {
1160
+ class: _Expression.ExpressionClass.COLUMN_REF,
1161
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1162
+ alias: '',
1163
+ query_location: 54,
1164
+ column_names: [
1165
+ 'MEERKAT'
1166
+ ]
1167
+ },
1168
+ {
1169
+ class: _Expression.ExpressionClass.CONSTANT,
1170
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1171
+ alias: '',
1172
+ query_location: 18446744073709552000,
1173
+ value: {
1174
+ type: {
1175
+ id: 'VARCHAR',
1176
+ type_info: null
1177
+ },
1178
+ is_null: false,
1179
+ value: 'record_date'
1180
+ }
1181
+ }
1182
+ ]
1183
+ }
1184
+ }
1185
+ ],
1186
+ start: 'EXPR_PRECEDING_ROWS',
1187
+ end: 'CURRENT_ROW_ROWS',
1188
+ start_expr: {
1189
+ class: _Expression.ExpressionClass.CONSTANT,
1190
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1191
+ alias: '',
1192
+ query_location: 88,
1193
+ value: {
1194
+ type: {
1195
+ id: 'INTEGER',
1196
+ type_info: null
1197
+ },
1198
+ is_null: false,
1199
+ value: 6
1200
+ }
1201
+ },
1202
+ end_expr: null,
1203
+ offset_expr: null,
1204
+ default_expr: null,
1205
+ ignore_nulls: false,
1206
+ filter_expr: null,
1207
+ exclude_clause: 'NO_OTHER',
1208
+ distinct: false
1209
+ },
1210
+ validFunctions: new Set([
1211
+ 'avg',
1212
+ 'count'
1213
+ ]),
1214
+ validScalarFunctions: new Set([
1215
+ '/'
1216
+ ]),
1217
+ expected: true
1218
+ },
1219
+ {
1220
+ description: 'node type SUBQUERY',
1221
+ query: "(SELECT CASE WHEN COUNT(DISTINCT CASE WHEN sla_stage = ''breached'' THEN id END) + COUNT(DISTINCT CASE WHEN sla_stage = ''completed'' AND ARRAY_LENGTH(first_resp_time_arr) > 0 AND (total_first_resp_breaches_ever = 0 OR total_first_resp_breaches_ever IS NULL) THEN id END) > 0 THEN 100 - (COUNT(DISTINCT CASE WHEN sla_stage = ''breached'' THEN id END) * 100.0 / (COUNT(DISTINCT CASE WHEN sla_stage = ''breached'' THEN id END) + COUNT(DISTINCT CASE WHEN sla_stage = ''completed'' AND ARRAY_LENGTH(first_resp_time_arr) > 0 AND (total_first_resp_breaches_ever = 0 OR total_first_resp_breaches_ever IS NULL) THEN id END))) ELSE NULL END AS result)",
1222
+ node: {
1223
+ class: _Expression.ExpressionClass.SUBQUERY,
1224
+ type: _duckdbserializationtypes.ExpressionType.SUBQUERY,
1225
+ alias: '',
1226
+ query_location: 7,
1227
+ subquery: {
1228
+ node: {
1229
+ type: 'SELECT_NODE',
1230
+ modifiers: [],
1231
+ cte_map: {
1232
+ map: []
1233
+ },
1234
+ select_list: [
1235
+ {
1236
+ class: _Expression.ExpressionClass.CASE,
1237
+ type: _duckdbserializationtypes.ExpressionType.CASE_EXPR,
1238
+ alias: 'result',
1239
+ query_location: 15,
1240
+ case_checks: [
1241
+ {
1242
+ when_expr: {
1243
+ class: _Expression.ExpressionClass.COMPARISON,
1244
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_GREATERTHAN,
1245
+ alias: '',
1246
+ query_location: 275,
1247
+ left: {
1248
+ class: _Expression.ExpressionClass.FUNCTION,
1249
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1250
+ alias: '',
1251
+ query_location: 86,
1252
+ function_name: '+',
1253
+ schema: '',
1254
+ children: [
1255
+ {
1256
+ class: _Expression.ExpressionClass.FUNCTION,
1257
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1258
+ alias: '',
1259
+ query_location: 25,
1260
+ function_name: 'count',
1261
+ schema: '',
1262
+ children: [
1263
+ {
1264
+ class: _Expression.ExpressionClass.CASE,
1265
+ type: _duckdbserializationtypes.ExpressionType.CASE_EXPR,
1266
+ alias: '',
1267
+ query_location: 40,
1268
+ case_checks: [
1269
+ {
1270
+ when_expr: {
1271
+ class: _Expression.ExpressionClass.COMPARISON,
1272
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_EQUAL,
1273
+ alias: '',
1274
+ query_location: 60,
1275
+ left: {
1276
+ class: _Expression.ExpressionClass.COLUMN_REF,
1277
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1278
+ alias: '',
1279
+ query_location: 50,
1280
+ column_names: [
1281
+ 'sla_stage'
1282
+ ]
1283
+ },
1284
+ right: {
1285
+ class: _Expression.ExpressionClass.CONSTANT,
1286
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1287
+ alias: '',
1288
+ query_location: 62,
1289
+ value: {
1290
+ type: {
1291
+ id: 'VARCHAR',
1292
+ type_info: null
1293
+ },
1294
+ is_null: false,
1295
+ value: 'breached'
1296
+ }
1297
+ }
1298
+ },
1299
+ then_expr: {
1300
+ class: _Expression.ExpressionClass.COLUMN_REF,
1301
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1302
+ alias: '',
1303
+ query_location: 78,
1304
+ column_names: [
1305
+ 'id'
1306
+ ]
1307
+ }
1308
+ }
1309
+ ],
1310
+ else_expr: {
1311
+ class: _Expression.ExpressionClass.CONSTANT,
1312
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1313
+ alias: '',
1314
+ query_location: 18446744073709552000,
1315
+ value: {
1316
+ type: {
1317
+ id: 'NULL',
1318
+ type_info: null
1319
+ },
1320
+ is_null: true
1321
+ }
1322
+ }
1323
+ }
1324
+ ],
1325
+ filter: null,
1326
+ order_bys: {
1327
+ type: 'ORDER_MODIFIER',
1328
+ orders: []
1329
+ },
1330
+ distinct: true,
1331
+ is_operator: false,
1332
+ export_state: false,
1333
+ catalog: ''
1334
+ },
1335
+ {
1336
+ class: _Expression.ExpressionClass.FUNCTION,
1337
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1338
+ alias: '',
1339
+ query_location: 88,
1340
+ function_name: 'count',
1341
+ schema: '',
1342
+ children: [
1343
+ {
1344
+ class: _Expression.ExpressionClass.CASE,
1345
+ type: _duckdbserializationtypes.ExpressionType.CASE_EXPR,
1346
+ alias: '',
1347
+ query_location: 103,
1348
+ case_checks: [
1349
+ {
1350
+ when_expr: {
1351
+ class: _Expression.ExpressionClass.CONJUNCTION,
1352
+ type: _duckdbserializationtypes.ExpressionType.CONJUNCTION_AND,
1353
+ alias: '',
1354
+ query_location: 137,
1355
+ children: [
1356
+ {
1357
+ class: _Expression.ExpressionClass.COMPARISON,
1358
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_EQUAL,
1359
+ alias: '',
1360
+ query_location: 123,
1361
+ left: {
1362
+ class: _Expression.ExpressionClass.COLUMN_REF,
1363
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1364
+ alias: '',
1365
+ query_location: 113,
1366
+ column_names: [
1367
+ 'sla_stage'
1368
+ ]
1369
+ },
1370
+ right: {
1371
+ class: _Expression.ExpressionClass.CONSTANT,
1372
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1373
+ alias: '',
1374
+ query_location: 125,
1375
+ value: {
1376
+ type: {
1377
+ id: 'VARCHAR',
1378
+ type_info: null
1379
+ },
1380
+ is_null: false,
1381
+ value: 'completed'
1382
+ }
1383
+ }
1384
+ },
1385
+ {
1386
+ class: _Expression.ExpressionClass.COMPARISON,
1387
+ type: 'COMPARE_GREATERTHAN',
1388
+ alias: '',
1389
+ query_location: 175,
1390
+ left: {
1391
+ class: 'FUNCTION',
1392
+ type: 'FUNCTION',
1393
+ alias: '',
1394
+ query_location: 141,
1395
+ function_name: 'array_length',
1396
+ schema: '',
1397
+ children: [
1398
+ {
1399
+ class: _Expression.ExpressionClass.COLUMN_REF,
1400
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1401
+ alias: '',
1402
+ query_location: 154,
1403
+ column_names: [
1404
+ 'first_resp_time_arr'
1405
+ ]
1406
+ }
1407
+ ],
1408
+ filter: null,
1409
+ order_bys: {
1410
+ type: 'ORDER_MODIFIER',
1411
+ orders: []
1412
+ },
1413
+ distinct: false,
1414
+ is_operator: false,
1415
+ export_state: false,
1416
+ catalog: ''
1417
+ },
1418
+ right: {
1419
+ class: _Expression.ExpressionClass.CONSTANT,
1420
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1421
+ alias: '',
1422
+ query_location: 177,
1423
+ value: {
1424
+ type: {
1425
+ id: 'INTEGER',
1426
+ type_info: null
1427
+ },
1428
+ is_null: false,
1429
+ value: 0
1430
+ }
1431
+ }
1432
+ },
1433
+ {
1434
+ class: 'CONJUNCTION',
1435
+ type: 'CONJUNCTION_OR',
1436
+ alias: '',
1437
+ query_location: 219,
1438
+ children: [
1439
+ {
1440
+ class: _Expression.ExpressionClass.COMPARISON,
1441
+ type: 'COMPARE_EQUAL',
1442
+ alias: '',
1443
+ query_location: 215,
1444
+ left: {
1445
+ class: _Expression.ExpressionClass.COLUMN_REF,
1446
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1447
+ alias: '',
1448
+ query_location: 184,
1449
+ column_names: [
1450
+ 'total_first_resp_breaches_ever'
1451
+ ]
1452
+ },
1453
+ right: {
1454
+ class: _Expression.ExpressionClass.CONSTANT,
1455
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1456
+ alias: '',
1457
+ query_location: 217,
1458
+ value: {
1459
+ type: {
1460
+ id: 'INTEGER',
1461
+ type_info: null
1462
+ },
1463
+ is_null: false,
1464
+ value: 0
1465
+ }
1466
+ }
1467
+ },
1468
+ {
1469
+ class: 'OPERATOR',
1470
+ type: 'OPERATOR_IS_NULL',
1471
+ alias: '',
1472
+ query_location: 253,
1473
+ children: [
1474
+ {
1475
+ class: _Expression.ExpressionClass.COLUMN_REF,
1476
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1477
+ alias: '',
1478
+ query_location: 222,
1479
+ column_names: [
1480
+ 'total_first_resp_breaches_ever'
1481
+ ]
1482
+ }
1483
+ ]
1484
+ }
1485
+ ]
1486
+ }
1487
+ ]
1488
+ },
1489
+ then_expr: {
1490
+ class: _Expression.ExpressionClass.COLUMN_REF,
1491
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1492
+ alias: '',
1493
+ query_location: 267,
1494
+ column_names: [
1495
+ 'id'
1496
+ ]
1497
+ }
1498
+ }
1499
+ ],
1500
+ else_expr: {
1501
+ class: _Expression.ExpressionClass.CONSTANT,
1502
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1503
+ alias: '',
1504
+ query_location: 18446744073709552000,
1505
+ value: {
1506
+ type: {
1507
+ id: 'NULL',
1508
+ type_info: null
1509
+ },
1510
+ is_null: true
1511
+ }
1512
+ }
1513
+ }
1514
+ ],
1515
+ filter: null,
1516
+ order_bys: {
1517
+ type: 'ORDER_MODIFIER',
1518
+ orders: []
1519
+ },
1520
+ distinct: true,
1521
+ is_operator: false,
1522
+ export_state: false,
1523
+ catalog: ''
1524
+ }
1525
+ ],
1526
+ filter: null,
1527
+ order_bys: {
1528
+ type: 'ORDER_MODIFIER',
1529
+ orders: []
1530
+ },
1531
+ distinct: false,
1532
+ is_operator: true,
1533
+ export_state: false,
1534
+ catalog: ''
1535
+ },
1536
+ right: {
1537
+ class: _Expression.ExpressionClass.CONSTANT,
1538
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1539
+ alias: '',
1540
+ query_location: 277,
1541
+ value: {
1542
+ type: {
1543
+ id: 'INTEGER',
1544
+ type_info: null
1545
+ },
1546
+ is_null: false,
1547
+ value: 0
1548
+ }
1549
+ }
1550
+ },
1551
+ then_expr: {
1552
+ class: _Expression.ExpressionClass.FUNCTION,
1553
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1554
+ alias: '',
1555
+ query_location: 288,
1556
+ function_name: '-',
1557
+ schema: '',
1558
+ children: [
1559
+ {
1560
+ class: _Expression.ExpressionClass.CONSTANT,
1561
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1562
+ alias: '',
1563
+ query_location: 284,
1564
+ value: {
1565
+ type: {
1566
+ id: 'INTEGER',
1567
+ type_info: null
1568
+ },
1569
+ is_null: false,
1570
+ value: 100
1571
+ }
1572
+ },
1573
+ {
1574
+ class: _Expression.ExpressionClass.FUNCTION,
1575
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1576
+ alias: '',
1577
+ query_location: 360,
1578
+ function_name: '/',
1579
+ schema: '',
1580
+ children: [
1581
+ {
1582
+ class: _Expression.ExpressionClass.FUNCTION,
1583
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1584
+ alias: '',
1585
+ query_location: 352,
1586
+ function_name: '*',
1587
+ schema: '',
1588
+ children: [
1589
+ {
1590
+ class: _Expression.ExpressionClass.FUNCTION,
1591
+ type: _duckdbserializationtypes.ExpressionType.FUNCTION,
1592
+ alias: '',
1593
+ query_location: 291,
1594
+ function_name: 'count',
1595
+ schema: '',
1596
+ children: [
1597
+ {
1598
+ class: _Expression.ExpressionClass.CASE,
1599
+ type: _duckdbserializationtypes.ExpressionType.CASE_EXPR,
1600
+ alias: '',
1601
+ query_location: 306,
1602
+ case_checks: [
1603
+ {
1604
+ when_expr: {
1605
+ class: _Expression.ExpressionClass.COMPARISON,
1606
+ type: _duckdbserializationtypes.ExpressionType.COMPARE_EQUAL,
1607
+ alias: '',
1608
+ query_location: 326,
1609
+ left: {
1610
+ class: _Expression.ExpressionClass.COLUMN_REF,
1611
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1612
+ alias: '',
1613
+ query_location: 316,
1614
+ column_names: [
1615
+ 'sla_stage'
1616
+ ]
1617
+ },
1618
+ right: {
1619
+ class: _Expression.ExpressionClass.CONSTANT,
1620
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1621
+ alias: '',
1622
+ query_location: 328,
1623
+ value: {
1624
+ type: {
1625
+ id: 'VARCHAR',
1626
+ type_info: null
1627
+ },
1628
+ is_null: false,
1629
+ value: 'breached'
1630
+ }
1631
+ }
1632
+ },
1633
+ then_expr: {
1634
+ class: _Expression.ExpressionClass.COLUMN_REF,
1635
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1636
+ alias: '',
1637
+ query_location: 344,
1638
+ column_names: [
1639
+ 'id'
1640
+ ]
1641
+ }
1642
+ }
1643
+ ],
1644
+ else_expr: {
1645
+ class: _Expression.ExpressionClass.CONSTANT,
1646
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1647
+ alias: '',
1648
+ query_location: 18446744073709552000,
1649
+ value: {
1650
+ type: {
1651
+ id: 'NULL',
1652
+ type_info: null
1653
+ },
1654
+ is_null: true
1655
+ }
1656
+ }
1657
+ }
1658
+ ],
1659
+ filter: null,
1660
+ order_bys: {
1661
+ type: 'ORDER_MODIFIER',
1662
+ orders: []
1663
+ },
1664
+ distinct: true,
1665
+ is_operator: false,
1666
+ export_state: false,
1667
+ catalog: ''
1668
+ },
1669
+ {
1670
+ class: _Expression.ExpressionClass.CONSTANT,
1671
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1672
+ alias: '',
1673
+ query_location: 354,
1674
+ value: {
1675
+ type: {
1676
+ id: 'DECIMAL',
1677
+ type_info: {
1678
+ type: 'DECIMAL_TYPE_INFO',
1679
+ alias: '',
1680
+ modifiers: [],
1681
+ width: 4,
1682
+ scale: 1
1683
+ }
1684
+ },
1685
+ is_null: false,
1686
+ value: 1000
1687
+ }
1688
+ }
1689
+ ],
1690
+ filter: null,
1691
+ order_bys: {
1692
+ type: 'ORDER_MODIFIER',
1693
+ orders: []
1694
+ },
1695
+ distinct: false,
1696
+ is_operator: true,
1697
+ export_state: false,
1698
+ catalog: ''
1699
+ },
1700
+ {
1701
+ class: 'FUNCTION',
1702
+ type: 'FUNCTION',
1703
+ alias: '',
1704
+ query_location: 424,
1705
+ function_name: '+',
1706
+ schema: '',
1707
+ children: [
1708
+ {
1709
+ class: 'FUNCTION',
1710
+ type: 'FUNCTION',
1711
+ alias: '',
1712
+ query_location: 363,
1713
+ function_name: 'count',
1714
+ schema: '',
1715
+ children: [
1716
+ {
1717
+ class: 'CASE',
1718
+ type: 'CASE_EXPR',
1719
+ alias: '',
1720
+ query_location: 378,
1721
+ case_checks: [
1722
+ {
1723
+ when_expr: {
1724
+ class: _Expression.ExpressionClass.COMPARISON,
1725
+ type: 'COMPARE_EQUAL',
1726
+ alias: '',
1727
+ query_location: 398,
1728
+ left: {
1729
+ class: _Expression.ExpressionClass.COLUMN_REF,
1730
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1731
+ alias: '',
1732
+ query_location: 388,
1733
+ column_names: [
1734
+ 'sla_stage'
1735
+ ]
1736
+ },
1737
+ right: {
1738
+ class: _Expression.ExpressionClass.CONSTANT,
1739
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1740
+ alias: '',
1741
+ query_location: 400,
1742
+ value: {
1743
+ type: {
1744
+ id: 'VARCHAR',
1745
+ type_info: null
1746
+ },
1747
+ is_null: false,
1748
+ value: 'breached'
1749
+ }
1750
+ }
1751
+ },
1752
+ then_expr: {
1753
+ class: _Expression.ExpressionClass.COLUMN_REF,
1754
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1755
+ alias: '',
1756
+ query_location: 416,
1757
+ column_names: [
1758
+ 'id'
1759
+ ]
1760
+ }
1761
+ }
1762
+ ],
1763
+ else_expr: {
1764
+ class: _Expression.ExpressionClass.CONSTANT,
1765
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1766
+ alias: '',
1767
+ query_location: 18446744073709552000,
1768
+ value: {
1769
+ type: {
1770
+ id: 'NULL',
1771
+ type_info: null
1772
+ },
1773
+ is_null: true
1774
+ }
1775
+ }
1776
+ }
1777
+ ],
1778
+ filter: null,
1779
+ order_bys: {
1780
+ type: 'ORDER_MODIFIER',
1781
+ orders: []
1782
+ },
1783
+ distinct: true,
1784
+ is_operator: false,
1785
+ export_state: false,
1786
+ catalog: ''
1787
+ },
1788
+ {
1789
+ class: 'FUNCTION',
1790
+ type: 'FUNCTION',
1791
+ alias: '',
1792
+ query_location: 426,
1793
+ function_name: 'count',
1794
+ schema: '',
1795
+ children: [
1796
+ {
1797
+ class: 'CASE',
1798
+ type: 'CASE_EXPR',
1799
+ alias: '',
1800
+ query_location: 441,
1801
+ case_checks: [
1802
+ {
1803
+ when_expr: {
1804
+ class: 'CONJUNCTION',
1805
+ type: 'CONJUNCTION_AND',
1806
+ alias: '',
1807
+ query_location: 475,
1808
+ children: [
1809
+ {
1810
+ class: _Expression.ExpressionClass.COMPARISON,
1811
+ type: 'COMPARE_EQUAL',
1812
+ alias: '',
1813
+ query_location: 461,
1814
+ left: {
1815
+ class: _Expression.ExpressionClass.COLUMN_REF,
1816
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1817
+ alias: '',
1818
+ query_location: 451,
1819
+ column_names: [
1820
+ 'sla_stage'
1821
+ ]
1822
+ },
1823
+ right: {
1824
+ class: _Expression.ExpressionClass.CONSTANT,
1825
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1826
+ alias: '',
1827
+ query_location: 463,
1828
+ value: {
1829
+ type: {
1830
+ id: 'VARCHAR',
1831
+ type_info: null
1832
+ },
1833
+ is_null: false,
1834
+ value: 'completed'
1835
+ }
1836
+ }
1837
+ },
1838
+ {
1839
+ class: _Expression.ExpressionClass.COMPARISON,
1840
+ type: 'COMPARE_GREATERTHAN',
1841
+ alias: '',
1842
+ query_location: 513,
1843
+ left: {
1844
+ class: 'FUNCTION',
1845
+ type: 'FUNCTION',
1846
+ alias: '',
1847
+ query_location: 479,
1848
+ function_name: 'array_length',
1849
+ schema: '',
1850
+ children: [
1851
+ {
1852
+ class: _Expression.ExpressionClass.COLUMN_REF,
1853
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1854
+ alias: '',
1855
+ query_location: 492,
1856
+ column_names: [
1857
+ 'first_resp_time_arr'
1858
+ ]
1859
+ }
1860
+ ],
1861
+ filter: null,
1862
+ order_bys: {
1863
+ type: 'ORDER_MODIFIER',
1864
+ orders: []
1865
+ },
1866
+ distinct: false,
1867
+ is_operator: false,
1868
+ export_state: false,
1869
+ catalog: ''
1870
+ },
1871
+ right: {
1872
+ class: _Expression.ExpressionClass.CONSTANT,
1873
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1874
+ alias: '',
1875
+ query_location: 515,
1876
+ value: {
1877
+ type: {
1878
+ id: 'INTEGER',
1879
+ type_info: null
1880
+ },
1881
+ is_null: false,
1882
+ value: 0
1883
+ }
1884
+ }
1885
+ },
1886
+ {
1887
+ class: 'CONJUNCTION',
1888
+ type: 'CONJUNCTION_OR',
1889
+ alias: '',
1890
+ query_location: 557,
1891
+ children: [
1892
+ {
1893
+ class: _Expression.ExpressionClass.COMPARISON,
1894
+ type: 'COMPARE_EQUAL',
1895
+ alias: '',
1896
+ query_location: 553,
1897
+ left: {
1898
+ class: _Expression.ExpressionClass.COLUMN_REF,
1899
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1900
+ alias: '',
1901
+ query_location: 522,
1902
+ column_names: [
1903
+ 'total_first_resp_breaches_ever'
1904
+ ]
1905
+ },
1906
+ right: {
1907
+ class: _Expression.ExpressionClass.CONSTANT,
1908
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1909
+ alias: '',
1910
+ query_location: 555,
1911
+ value: {
1912
+ type: {
1913
+ id: 'INTEGER',
1914
+ type_info: null
1915
+ },
1916
+ is_null: false,
1917
+ value: 0
1918
+ }
1919
+ }
1920
+ },
1921
+ {
1922
+ class: 'OPERATOR',
1923
+ type: 'OPERATOR_IS_NULL',
1924
+ alias: '',
1925
+ query_location: 591,
1926
+ children: [
1927
+ {
1928
+ class: _Expression.ExpressionClass.COLUMN_REF,
1929
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1930
+ alias: '',
1931
+ query_location: 560,
1932
+ column_names: [
1933
+ 'total_first_resp_breaches_ever'
1934
+ ]
1935
+ }
1936
+ ]
1937
+ }
1938
+ ]
1939
+ }
1940
+ ]
1941
+ },
1942
+ then_expr: {
1943
+ class: _Expression.ExpressionClass.COLUMN_REF,
1944
+ type: _duckdbserializationtypes.ExpressionType.COLUMN_REF,
1945
+ alias: '',
1946
+ query_location: 605,
1947
+ column_names: [
1948
+ 'id'
1949
+ ]
1950
+ }
1951
+ }
1952
+ ],
1953
+ else_expr: {
1954
+ class: _Expression.ExpressionClass.CONSTANT,
1955
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
1956
+ alias: '',
1957
+ query_location: 18446744073709552000,
1958
+ value: {
1959
+ type: {
1960
+ id: 'NULL',
1961
+ type_info: null
1962
+ },
1963
+ is_null: true
1964
+ }
1965
+ }
1966
+ }
1967
+ ],
1968
+ filter: null,
1969
+ order_bys: {
1970
+ type: 'ORDER_MODIFIER',
1971
+ orders: []
1972
+ },
1973
+ distinct: true,
1974
+ is_operator: false,
1975
+ export_state: false,
1976
+ catalog: ''
1977
+ }
1978
+ ],
1979
+ filter: null,
1980
+ order_bys: {
1981
+ type: 'ORDER_MODIFIER',
1982
+ orders: []
1983
+ },
1984
+ distinct: false,
1985
+ is_operator: true,
1986
+ export_state: false,
1987
+ catalog: ''
1988
+ }
1989
+ ],
1990
+ filter: null,
1991
+ order_bys: {
1992
+ type: 'ORDER_MODIFIER',
1993
+ orders: []
1994
+ },
1995
+ distinct: false,
1996
+ is_operator: true,
1997
+ export_state: false,
1998
+ catalog: ''
1999
+ }
2000
+ ],
2001
+ filter: null,
2002
+ order_bys: {
2003
+ type: 'ORDER_MODIFIER',
2004
+ orders: []
2005
+ },
2006
+ distinct: false,
2007
+ is_operator: true,
2008
+ export_state: false,
2009
+ catalog: ''
2010
+ }
2011
+ }
2012
+ ],
2013
+ else_expr: {
2014
+ class: _Expression.ExpressionClass.CONSTANT,
2015
+ type: _duckdbserializationtypes.ExpressionType.VALUE_CONSTANT,
2016
+ alias: '',
2017
+ query_location: 620,
2018
+ value: {
2019
+ type: {
2020
+ id: 'NULL',
2021
+ type_info: null
2022
+ },
2023
+ is_null: true
2024
+ }
2025
+ }
2026
+ }
2027
+ ],
2028
+ from_table: {
2029
+ type: 'EMPTY',
2030
+ alias: '',
2031
+ sample: null,
2032
+ query_location: 18446744073709552000
2033
+ },
2034
+ where_clause: null,
2035
+ group_expressions: [],
2036
+ group_sets: [],
2037
+ aggregate_handling: 'STANDARD_HANDLING',
2038
+ having: null,
2039
+ sample: null,
2040
+ qualify: null
2041
+ }
2042
+ },
2043
+ child: null,
2044
+ comparison_type: 'INVALID'
2045
+ },
2046
+ validFunctions: new Set([
2047
+ 'count',
2048
+ 'count_star'
2049
+ ]),
2050
+ validScalarFunctions: new Set([
2051
+ '-',
2052
+ '/',
2053
+ '*',
2054
+ '+'
2055
+ ]),
2056
+ expected: true
2057
+ }
2058
+ ];
2059
+
2060
+ //# sourceMappingURL=test-data.js.map