@devrev/meerkat-core 0.0.84 → 0.0.86

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