@malloydata/malloy-query-builder 0.0.266 → 0.0.267-dev250421220633

package/src/query-ast.spec.ts

@@ -2621,4 +2621,308 @@ describe('query builder', () => {
       expect(query.isRunnable()).toBe(true);
     });
   });
+  describe('insertion order', () => {
+    const model: Malloy.ModelInfo = {
+      entries: [
+        {
+          kind: 'source',
+          name: 's',
+          schema: {
+            fields: [
+              {kind: 'dimension', name: 'd1', type: {kind: 'number_type'}},
+              {kind: 'dimension', name: 'd2', type: {kind: 'number_type'}},
+              {kind: 'dimension', name: 'd3', type: {kind: 'number_type'}},
+              {kind: 'measure', name: 'm1', type: {kind: 'number_type'}},
+              {kind: 'measure', name: 'm2', type: {kind: 'number_type'}},
+              {kind: 'measure', name: 'm3', type: {kind: 'number_type'}},
+              {kind: 'view', name: 'v1', schema: {fields: []}},
+              {kind: 'view', name: 'v2', schema: {fields: []}},
+              {kind: 'view', name: 'v3', schema: {fields: []}},
+            ],
+          },
+        },
+      ],
+      anonymous_queries: [],
+    };
+    function group_by(name: string): Malloy.ViewOperationWithGroupBy {
+      return {
+        kind: 'group_by',
+        field: {
+          expression: {
+            kind: 'field_reference',
+            name,
+          },
+        },
+      };
+    }
+    function aggregate(name: string): Malloy.ViewOperationWithAggregate {
+      return {
+        kind: 'aggregate',
+        field: {
+          expression: {
+            kind: 'field_reference',
+            name,
+          },
+        },
+      };
+    }
+    function nest(name: string): Malloy.ViewOperationWithNest {
+      return {
+        kind: 'nest',
+        view: {
+          definition: {
+            kind: 'view_reference',
+            name,
+          },
+        },
+      };
+    }
+    test('add an aggregate after adding some group bys', () => {
+      const from: Malloy.Query = {
+        definition: {
+          kind: 'arrow',
+          source: {
+            kind: 'source_reference',
+            name: 's',
+          },
+          view: {
+            kind: 'segment',
+            operations: [],
+          },
+        },
+      };
+      expect((q: ASTQuery) => {
+        const segment = q.getOrAddDefaultSegment();
+        segment.addGroupBy('d1');
+        segment.addGroupBy('d2');
+        segment.addAggregate('m1');
+      }).toModifyQuery({
+        model,
+        from,
+        to: {
+          definition: {
+            kind: 'arrow',
+            source: {
+              kind: 'source_reference',
+              name: 's',
+            },
+            view: {
+              kind: 'segment',
+              operations: [group_by('d1'), group_by('d2'), aggregate('m1')],
+            },
+          },
+        },
+        malloy: dedent`
+          run: s -> {
+            group_by:
+              d1
+              d2
+            aggregate: m1
+          }
+        `,
+      });
+    });
+    test('add GB, AGG, GB', () => {
+      const from: Malloy.Query = {
+        definition: {
+          kind: 'arrow',
+          source: {
+            kind: 'source_reference',
+            name: 's',
+          },
+          view: {
+            kind: 'segment',
+            operations: [],
+          },
+        },
+      };
+      expect((q: ASTQuery) => {
+        const segment = q.getOrAddDefaultSegment();
+        segment.addGroupBy('d1');
+        segment.addAggregate('m1');
+        segment.addGroupBy('d2');
+      }).toModifyQuery({
+        model,
+        from,
+        to: {
+          definition: {
+            kind: 'arrow',
+            source: {
+              kind: 'source_reference',
+              name: 's',
+            },
+            view: {
+              kind: 'segment',
+              operations: [group_by('d1'), group_by('d2'), aggregate('m1')],
+            },
+          },
+        },
+        malloy: dedent`
+          run: s -> {
+            group_by:
+              d1
+              d2
+            aggregate: m1
+          }
+        `,
+      });
+    });
+    test('add GB, NEST, AGG', () => {
+      const from: Malloy.Query = {
+        definition: {
+          kind: 'arrow',
+          source: {
+            kind: 'source_reference',
+            name: 's',
+          },
+          view: {
+            kind: 'segment',
+            operations: [],
+          },
+        },
+      };
+      expect((q: ASTQuery) => {
+        const segment = q.getOrAddDefaultSegment();
+        segment.addGroupBy('d1');
+        segment.addNest('v1');
+        segment.addAggregate('m1');
+      }).toModifyQuery({
+        model,
+        from,
+        to: {
+          definition: {
+            kind: 'arrow',
+            source: {
+              kind: 'source_reference',
+              name: 's',
+            },
+            view: {
+              kind: 'segment',
+              operations: [group_by('d1'), aggregate('m1'), nest('v1')],
+            },
+          },
+        },
+        malloy: dedent`
+          run: s -> {
+            group_by: d1
+            aggregate: m1
+            nest: v1
+          }
+        `,
+      });
+    });
+    test('add GB, LIMIT, AGG', () => {
+      const from: Malloy.Query = {
+        definition: {
+          kind: 'arrow',
+          source: {
+            kind: 'source_reference',
+            name: 's',
+          },
+          view: {
+            kind: 'segment',
+            operations: [],
+          },
+        },
+      };
+      expect((q: ASTQuery) => {
+        const segment = q.getOrAddDefaultSegment();
+        segment.addGroupBy('d1');
+        segment.setLimit(10);
+        segment.addAggregate('m1');
+      }).toModifyQuery({
+        model,
+        from,
+        to: {
+          definition: {
+            kind: 'arrow',
+            source: {
+              kind: 'source_reference',
+              name: 's',
+            },
+            view: {
+              kind: 'segment',
+              operations: [
+                group_by('d1'),
+                aggregate('m1'),
+                {kind: 'limit', limit: 10},
+              ],
+            },
+          },
+        },
+        malloy: dedent`
+          run: s -> {
+            group_by: d1
+            aggregate: m1
+            limit: 10
+          }
+        `,
+      });
+    });
+    test('add HAVING, WHERE, GROUP BY, LIMIT', () => {
+      const from: Malloy.Query = {
+        definition: {
+          kind: 'arrow',
+          source: {
+            kind: 'source_reference',
+            name: 's',
+          },
+          view: {
+            kind: 'segment',
+            operations: [],
+          },
+        },
+      };
+      expect((q: ASTQuery) => {
+        const segment = q.getOrAddDefaultSegment();
+        segment.addHaving('m1', '> 10');
+        segment.addWhere('d1', '> 10');
+        segment.addGroupBy('d2');
+        segment.setLimit(10);
+      }).toModifyQuery({
+        model,
+        from,
+        to: {
+          definition: {
+            kind: 'arrow',
+            source: {
+              kind: 'source_reference',
+              name: 's',
+            },
+            view: {
+              kind: 'segment',
+              operations: [
+                group_by('d2'),
+                {
+                  kind: 'where',
+                  filter: {
+                    kind: 'filter_string',
+                    filter: '> 10',
+                    field_reference: {name: 'd1'},
+                  },
+                },
+                {
+                  kind: 'having',
+                  filter: {
+                    kind: 'filter_string',
+                    filter: '> 10',
+                    field_reference: {name: 'm1'},
+                  },
+                },
+                {kind: 'limit', limit: 10},
+              ],
+            },
+          },
+        },
+        malloy: dedent`
+          run: s -> {
+            group_by: d2
+            where: d1 ~ f\`> 10\`
+            having: m1 ~ f\`> 10\`
+            limit: 10
+          }
+        `,
+      });
+    });
+  });
 });

package/src/query-ast.ts

@@ -2574,11 +2574,13 @@ export class ASTSegmentViewDefinition
   }
 
   private DEFAULT_INSERTION_ORDER: Malloy.ViewOperationType[] = [
-    'where',
     'group_by',
     'aggregate',
+    'where',
+    'having',
     'nest',
     'order_by',
+    'limit',
   ];
 
   private findInsertionPoint(kind: Malloy.ViewOperationType): number {
@@ -2600,7 +2602,7 @@ export class ASTSegmentViewDefinition
     );
     for (const laterType of laterOperations) {
       const firstOfType = this.firstIndexOfOperationType(laterType);
-      return firstOfType;
+      if (firstOfType > -1) return firstOfType;
     }
     return this.operations.length;
   }
@@ -4191,7 +4193,7 @@ export class ASTWhereViewOperation extends ASTObjectNode<
     filter: ASTFilter;
   }
 > {
-  readonly kind: Malloy.ViewOperationType = 'nest';
+  readonly kind: Malloy.ViewOperationType = 'where';
   constructor(public node: Malloy.ViewOperationWithWhere) {
     super(node, {
       kind: 'where',
@@ -4222,7 +4224,7 @@ export class ASTHavingViewOperation extends ASTObjectNode<
     filter: ASTFilter;
   }
 > {
-  readonly kind: Malloy.ViewOperationType = 'nest';
+  readonly kind: Malloy.ViewOperationType = 'having';
   constructor(public node: Malloy.ViewOperationWithHaving) {
     super(node, {
       kind: 'having',
@@ -4580,8 +4582,6 @@ export class ASTAnnotation extends ASTObjectNode<
     value: string;
   }
 > {
-  readonly kind: Malloy.ViewOperationType = 'limit';
-
   get value() {
     return this.children.value;
   }