@malloydata/malloy 0.0.88-dev231002231014 → 0.0.88-dev231002235732

package/dist/lang/test/query.spec.js

@@ -27,53 +27,54 @@ require("./parse-expects");
 const model_1 = require("../../model");
 describe('query:', () => {
     describe('basic query syntax', () => {
-        test('anonymous query', () => {
-            expect((0, test_translator_1.markSource) `query: ${"table('aTable') -> { group_by: astr }"}`).toTranslate();
-        });
-        test('anonymous query', () => {
+        test('run:anonymous query', () => expect('run: a -> { group_by: astr }').toTranslate());
+        test('query:anonymous query m4 warning', () => {
             expect((0, test_translator_1.markSource) `##! m4warnings
-      query: ${"conn.table('aTable') -> { group_by: astr }"}`).toTranslateWithWarnings('Anonymous `query:` statements are deprecated, use `run:` instead');
+          query: ${'a  -> { group_by: astr }'}`).toTranslateWithWarnings('Anonymous `query:` statements are deprecated, use `run:` instead');
         });
-        test('run query', () => expect("run: table('aTable') -> { group_by: astr }").toTranslate());
+        test('named query:', () => expect('query: aq is a -> { group_by: astr }').toTranslate());
         test('run query ref', () => expect(`
-      query: foo is table('aTable') -> { group_by: astr }
-      run: foo
+        query: foo is a -> { group_by: astr }
+        run: foo
     `).toTranslate());
-        test('query', () => expect("query: name is table('aTable') -> { group_by: astr }").toTranslate());
-        test('query', () => {
-            expect("query: name is table('aTable') -> { group_by: astr }").toTranslate();
-        });
         test('query from query', () => {
             expect(`
         query: q1 is ab->{ group_by: astr limit: 10 }
-        query: q2 is ->q1
+        query: q2 is q1
       `).toTranslate();
         });
         test('query with refinements from query', () => {
             expect(`
         query: q1 is ab->{ group_by: astr limit: 10 }
-        query: q2 is ->q1 { aggregate: acount }
+        query: q2 is q1 + { aggregate: acount }
       `).toTranslate();
         });
         test('chained query operations', () => {
             expect(`
-      query: ab
+      run: ab
         -> { group_by: astr; aggregate: acount }
         -> { top: 5; where: astr ~ 'a%' group_by: astr }
     `).toTranslate();
         });
-        test('from(query) refined into query', () => {
-            expect('query: from(ab -> {group_by: astr}) { dimension: bigstr is upper(astr) } -> { group_by: bigstr }').toTranslate();
+        test('query output refined into another query pre-m4', () => {
+            expect(`
+          ##! -m4warnings
+          run: from(ab -> {group_by: astr}) extend { dimension: bigstr is upper(astr) } -> { group_by: bigstr }
+        `).toTranslate();
+        });
+        test('query output refined into another query', () => {
+            expect('run: ab -> {group_by: astr} extend { dimension: bigstr is upper(astr) } -> { group_by: bigstr }').toTranslate();
         });
         test('query with shortcut filtered turtle', () => {
-            expect("query: allA is ab -> aturtle {? astr ~ 'a%' }").toTranslate();
+            expect(`##! -m4warnings
+        query: allA is ab -> aturtle + {? astr ~ 'a%' }`).toTranslate();
         });
         test('query with filtered turtle', () => {
-            expect("query: allA is ab -> aturtle { where: astr ~ 'a%' }").toTranslate();
+            expect("query: allA is ab -> aturtle + { where: astr ~ 'a%' }").toTranslate();
         });
         test('nest: in group_by:', () => {
             expect(`
-      query: ab -> {
+      run: ab -> {
         group_by: astr;
         nest: nested_count is {
           aggregate: acount
@@ -83,19 +84,19 @@ describe('query:', () => {
         });
         test('reduce pipe project', () => {
             expect(`
-      query: a -> { aggregate: f is count() } -> { project: f2 is f + 1 }
+      run: a -> { aggregate: f is count() } -> { select: f2 is f + 1 }
     `).toTranslate();
         });
         test('refine and extend query', () => {
             expect(`
       query: a_by_str is a -> { group_by: astr }
-      query: -> a_by_str { aggregate: str_count is count() }
+      run: a_by_str + { aggregate: str_count is count() }
     `).toTranslate();
         });
         test('query refinement preserves original', () => {
             const x = new test_translator_1.TestTranslator(`
       query: q is a -> { aggregate: acount is count() }
-      query: nq is -> q + { group_by: astr }
+      query: nq is q + { group_by: astr }
     `);
             expect(x).toTranslate();
             const q = x.getQuery('q');
@@ -108,7 +109,7 @@ describe('query:', () => {
         test('query composition preserves original', () => {
             const x = new test_translator_1.TestTranslator(`
       query: q is ab -> { aggregate: acount }
-      query: nq is -> q -> { project: * }
+      query: nq is q -> { select: * }
     `);
             expect(x).toTranslate();
             const q = x.getQuery('q');
@@ -119,7 +120,7 @@ describe('query:', () => {
         });
         test('all ungroup with args', () => {
             expect(`
-      query: a -> {
+      run: a -> {
         group_by: astr
         nest: by_int is {
           group_by: ai
@@ -130,18 +131,17 @@ describe('query:', () => {
         });
         test('all ungroup checks args', () => {
             expect(`
-    query: a -> {
-      group_by: astr
-      nest: by_int is {
-        group_by: ai
-        aggregate: bi_count is all(count(), afloat)
-      }
-    }
-  `).translationToFailWith("all() 'afloat' is missing from query output");
+        run: a -> {
+        group_by: astr
+        nest: by_int is {
+          group_by: ai
+          aggregate: bi_count is all(count(), afloat)
+        }
+      }`).translationToFailWith("all() 'afloat' is missing from query output");
         });
         test('exclude ungroup with args', () => {
             expect(`
-      query: a -> {
+      run: a -> {
         group_by: aa is 'a'
         nest: by_b is {
           group_by: bb is 'b'
@@ -155,7 +155,7 @@ describe('query:', () => {
         });
         test('exclude ungroup checks args', () => {
             expect(`
-      query: a -> {
+      run: a -> {
         group_by: aa is 'a'
         nest: by_b is {
           group_by: bb is 'b'
@@ -169,14 +169,14 @@ describe('query:', () => {
         });
         test('exclude problem revealed by production models', () => {
             expect(`
-      source: carriers is table('malloytest.carriers') {
+      source: carriers is _db_.table('malloytest.carriers') extend {
         primary_key: code
       }
-      source: flights is table('malloytest.flights') {
+      source: flights is _db_.table('malloytest.flights') extend {
         primary_key: id2
         join_one: carriers with carrier
 
-        query: carrier_overview is {
+        view: carrier_overview is {
           group_by: carrier_name is carriers.nickname
           nest: top_destinations is {
             group_by: destination
@@ -191,93 +191,94 @@ describe('query:', () => {
     describe('query operation typechecking', () => {
         describe('field declarations', () => {
             test('cannot use aggregate in group_by', () => {
-                expect('query: a -> { group_by: s is count()}').translationToFailWith('Cannot use an aggregate field in a group_by operation, did you mean to use an aggregate operation instead?');
+                expect('run: a -> { group_by: s is count()}').translationToFailWith('Cannot use an aggregate field in a group_by operation, did you mean to use an aggregate operation instead?');
             });
             test('cannot use ungrouped_aggregate in group_by', () => {
-                expect('query: a -> { group_by: s is all(count())}').translationToFailWith('Cannot use an aggregate field in a group_by operation, did you mean to use an aggregate operation instead?');
+                expect('run: a -> { group_by: s is all(count())}').translationToFailWith('Cannot use an aggregate field in a group_by operation, did you mean to use an aggregate operation instead?');
             });
             test('cannot use analytic in group_by', () => {
-                expect('query: a -> { group_by: s is row_number()}').translationToFailWith('Cannot use an analytic field in a group_by operation, did you mean to use a calculate operation instead?');
+                expect('run: a -> { group_by: s is row_number()}').translationToFailWith('Cannot use an analytic field in a group_by operation, did you mean to use a calculate operation instead?');
             });
             test('cannot use aggregate in dimension', () => {
-                expect('source: a1 is a { dimension: s is count()}').translationToFailWith('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
+                expect('source: a1 is a extend { dimension: s is count()}').translationToFailWith('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
             });
             test('cannot use ungrouped_aggregate in dimension', () => {
-                expect('source: a1 is a { dimension: s is all(count())}').translationToFailWith('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
+                expect('source: a1 is a extend { dimension: s is all(count())}').translationToFailWith('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
             });
             test('cannot use analytic in dimension', () => {
-                expect('source: a1 is a { dimension: s is row_number()}').translationToFailWith('Cannot use an analytic field in a dimension declaration');
+                expect('source: a1 is a extend { dimension: s is row_number()}').translationToFailWith('Cannot use an analytic field in a dimension declaration');
             });
             test('cannot use scalar in measure', () => {
-                expect('source: a1 is a { measure: s is 1}').translationToFailWith('Cannot use a scalar field in a measure declaration, did you mean to use a dimension declaration instead?');
+                expect('source: a1 is a extend { measure: s is 1}').translationToFailWith('Cannot use a scalar field in a measure declaration, did you mean to use a dimension declaration instead?');
             });
             test('cannot use analytic in measure', () => {
-                expect('source: a1 is a { measure: s is lag(count())}').translationToFailWith('Cannot use an analytic field in a measure declaration');
+                expect('source: a1 is a extend { measure: s is lag(count())}').translationToFailWith('Cannot use an analytic field in a measure declaration');
             });
             test('cannot use scalar in aggregate', () => {
-                expect('query: a -> { aggregate: s is 1}').translationToFailWith('Cannot use a scalar field in an aggregate operation, did you mean to use a group_by or project operation instead?');
+                expect('run: a -> { aggregate: s is 1}').translationToFailWith('Cannot use a scalar field in an aggregate operation, did you mean to use a group_by or project operation instead?');
             });
             test('cannot use analytic in aggregate', () => {
-                expect('query: a -> { aggregate: s is lag(count())}').translationToFailWith('Cannot use an analytic field in an aggregate operation, did you mean to use a calculate operation instead?');
+                expect('run: a -> { aggregate: s is lag(count())}').translationToFailWith('Cannot use an analytic field in an aggregate operation, did you mean to use a calculate operation instead?');
             });
             test('cannot use scalar in calculate', () => {
-                expect('query: a -> { group_by: a is 1; calculate: s is 1 }').translationToFailWith('Cannot use a scalar field in a calculate operation, did you mean to use a group_by or project operation instead?');
+                expect('run: a -> { group_by: a is 1; calculate: s is 1 }').translationToFailWith('Cannot use a scalar field in a calculate operation, did you mean to use a group_by or project operation instead?');
             });
             test('cannot use aggregate in calculate', () => {
-                expect('query: a -> { group_by: a is 1; calculate: s is count() }').translationToFailWith('Cannot use an aggregate field in a calculate operation, did you mean to use an aggregate operation instead?');
+                expect('run: a -> { group_by: a is 1; calculate: s is count() }').translationToFailWith('Cannot use an aggregate field in a calculate operation, did you mean to use an aggregate operation instead?');
             });
             test('cannot use aggregate in project', () => {
-                expect('query: a -> { project: s is count() }').translationToFailWith('Cannot use an aggregate field in a project operation, did you mean to use an aggregate operation instead?');
+                expect('run: a -> { select: s is count() }').translationToFailWith('Cannot use an aggregate field in a project operation, did you mean to use an aggregate operation instead?');
             });
             test('cannot use analytic in project', () => {
-                expect('query: a -> { project: s is row_number() }').translationToFailWith('Cannot use an analytic field in a project operation, did you mean to use a calculate operation instead?');
+                expect('run: a -> { select: s is row_number() }').translationToFailWith('Cannot use an analytic field in a project operation, did you mean to use a calculate operation instead?');
             });
             test('cannot use analytic in declare', () => {
-                expect('query: a -> { group_by: a is 1; declare: s is row_number() }').translationToFailWith('Analytic expressions can not be used in a declare block');
+                expect(`##! -m4warnings
+          run: a -> { group_by: a is 1; declare: s is row_number() }`).translationToFailWith('Analytic expressions can not be used in a declare block');
             });
             test('cannot use aggregate in index', () => {
-                expect('query: a { measure: acount is count() } -> { index: acount }').translationToFailWith('Cannot use an aggregate field in an index operation');
+                expect('run: a extend { measure: acount is count() } -> { index: acount }').translationToFailWith('Cannot use an aggregate field in an index operation');
             });
             test('can use aggregate in except', () => {
                 expect(`
-          source: b1 is a { measure: acount is count() }
-          source: c1 is b1 { except: acount }
+          source: b1 is a extend { measure: acount is count() }
+          source: c1 is b1 extend { except: acount }
         `).toTranslate();
             });
         });
         describe('field references', () => {
             test('cannot use aggregate in group_by', () => {
-                expect('query: a -> { declare: acount is count(); group_by: acount }').translationToFailWith('Cannot use an aggregate field in a group_by operation, did you mean to use an aggregate operation instead?');
+                expect('run: a -> { extend: {measure: acount is count()} group_by: acount }').translationToFailWith('Cannot use an aggregate field in a group_by operation, did you mean to use an aggregate operation instead?');
             });
             test('cannot use query in group_by', () => {
-                expect('query: a { query: q is { group_by: x is 1 } } -> { group_by: q }').translationToFailWith('Cannot use a query field in a group_by operation, did you mean to use a nest operation instead?');
+                expect('run: a extend { view: q is { group_by: x is 1 } } -> { group_by: q }').translationToFailWith('Cannot use a view field in a group_by operation, did you mean to use a nest operation instead?');
             });
             test('cannot use scalar in aggregate', () => {
-                expect('query: a -> { declare: aconst is 1; aggregate: aconst }').translationToFailWith('Cannot use a scalar field in an aggregate operation, did you mean to use a group_by or project operation instead?');
+                expect('run: a -> { extend: {dimension: aconst is 1} aggregate: aconst }').translationToFailWith('Cannot use a scalar field in an aggregate operation, did you mean to use a group_by or project operation instead?');
             });
             test('cannot use scalar in calculate', () => {
-                expect('query: a -> { declare: aconst is 1; group_by: x is 1; calculate: aconst }').translationToFailWith('Cannot use a scalar field in a calculate operation, did you mean to use a group_by or project operation instead?');
+                expect('run: a -> { extend: {dimension: aconst is 1} group_by: x is 1; calculate: aconst }').translationToFailWith('Cannot use a scalar field in a calculate operation, did you mean to use a group_by or project operation instead?');
             });
             test('cannot use aggregate in calculate', () => {
-                expect('query: a -> { declare: acount is count(); group_by: x is 1; calculate: acount }').translationToFailWith('Cannot use an aggregate field in a calculate operation, did you mean to use an aggregate operation instead?');
+                expect('run: a -> { extend: {measure: acount is count()} group_by: x is 1; calculate: acount }').translationToFailWith('Cannot use an aggregate field in a calculate operation, did you mean to use an aggregate operation instead?');
             });
             test('cannot use query in project', () => {
-                expect('query: a { query: q is { group_by: x is 1 } } -> { project: q }').translationToFailWith('Cannot use a query field in a project operation, did you mean to use a nest operation instead?');
+                expect('run: a extend { view: q is { group_by: x is 1 } } -> { select: q }').translationToFailWith('Cannot use a view field in a project operation, did you mean to use a nest operation instead?');
             });
             test('cannot use query in index', () => {
-                expect('query: a { query: q is { group_by: x is 1 } } -> { index: q }').translationToFailWith('Cannot use a query field in an index operation');
+                expect('run: a extend { view: q is { group_by: x is 1 } } -> { index: q }').translationToFailWith('Cannot use a view field in an index operation');
             });
             test('cannot use query in calculate', () => {
-                expect('query: a { query: q is { group_by: x is 1 } } -> { group_by: x is 1; calculate: q }').translationToFailWith('Cannot use a query field in a calculate operation, did you mean to use a nest operation instead?');
+                expect('run: a extend { view: q is { group_by: x is 1 } } -> { group_by: x is 1; calculate: q }').translationToFailWith('Cannot use a view field in a calculate operation, did you mean to use a nest operation instead?');
             });
             test('cannot use query in aggregate', () => {
-                expect('query: a { query: q is { group_by: x is 1 } } -> { aggregate: q }').translationToFailWith('Cannot use a query field in an aggregate operation, did you mean to use a nest operation instead?');
+                expect('run: a extend { view: q is { group_by: x is 1 } } -> { aggregate: q }').translationToFailWith('Cannot use a view field in an aggregate operation, did you mean to use a nest operation instead?');
             });
             test('cannot use aggregate in calculate, preserved over refinement', () => {
                 expect(`query: a1 is a -> {
           aggregate: c is count()
         }
-        query: -> a1 {
+        run: a1 + {
           calculate: b is c
         }`).translationToFailWith('Cannot use an aggregate field in a calculate operation, did you mean to use an aggregate operation instead?');
             });
@@ -285,7 +286,7 @@ describe('query:', () => {
                 expect(`query: a1 is a -> {
           group_by: c is 1
         }
-        query: -> a1 {
+        run: a1 + {
           calculate: b is c
         }`).translationToFailWith('Cannot use a scalar field in a calculate operation, did you mean to use a group_by or project operation instead?');
             });
@@ -294,7 +295,7 @@ describe('query:', () => {
           group_by: c is 1
           calculate: c2 is lag(c)
         }
-        query: -> a1 {
+        run: a1 + {
           group_by: b is c2
         }`).translationToFailWith(
                 // c2 is not defined because group_by doesn't know to look in the output space
@@ -305,7 +306,7 @@ describe('query:', () => {
           group_by: c is 1
           calculate: c2 is lag(c)
         }
-        query: -> a1 {
+        run: a1 + {
           order_by: c2
         }`).translationToFailWith('Illegal order by of analytic field c2');
             });
@@ -331,7 +332,7 @@ describe('query:', () => {
                 expect(`query: a1 is a -> {
           group_by: c is 1
         }
-        query: -> a1 {
+        run: a1 + {
           order_by: c
         }`).toTranslate();
             });
@@ -339,7 +340,7 @@ describe('query:', () => {
                 expect(`query: a1 is a -> {
           group_by: c is astr
         }
-        query: -> a1 {
+        run: a1 + {
           order_by: c
         }`).toTranslate();
             });
@@ -347,30 +348,30 @@ describe('query:', () => {
     });
     describe('function typechecking', () => {
         test('use function correctly', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: s is concat('a', 'b')
       }`).toTranslate();
         });
         test('function incorrect case', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: s is CONCAT('a', 'b')
       }`).toTranslateWithWarnings("Case insensitivity for function names is deprecated, use 'concat' instead");
         });
         test('function no matching overload', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: s is floor('a', 'b')
       }`).translationToFailWith('No matching overload for function floor(string, string)');
         });
         test('unknown function', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: s is asdfasdf()
       }`).translationToFailWith("Unknown function 'asdfasdf'. Use 'asdfasdf!(...)' to call a SQL function directly.");
         });
         test('can select different overload', () => {
-            expect('query: a -> { group_by: s is concat() }').toTranslate();
+            expect('run: a -> { group_by: s is concat() }').toTranslate();
         });
         test('can pass different expression types', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: f1 is sqrt(1)
         aggregate: f2 is sqrt(count())
         aggregate: f3 is sqrt(all(count()))
@@ -379,29 +380,29 @@ describe('query:', () => {
       }`).toTranslate();
         });
         test('function return type correct', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: s is floor(1.2) + 1
       }`).toTranslate();
         });
         test('function return type incorrect', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
           group_by: s is floor(1.2) + 'a'
       }`).translationToFailWith("Non numeric('number,string') value with '+'");
         });
         test('can use output value in calculate', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is 1
         calculate: s is lag(x)
       }`).toTranslate();
         });
         test('cannot use output value in group_by', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is 1
         group_by: y is x
       }`).translationToFailWith("'x' is not defined");
         });
         test('lag can check that other args are constant', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is 1
         calculate: s is lag(x, 1, x)
       }`).translationToFailWith(
@@ -409,7 +410,7 @@ describe('query:', () => {
             "Parameter 3 ('default') of lag must be literal or constant, but received output");
         });
         test('lag can check that other args are literal', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is 1
         calculate: s is lag(x, 1 + 1)
       }`).translationToFailWith(
@@ -417,13 +418,13 @@ describe('query:', () => {
             "Parameter 2 ('offset') of lag must be literal, but received constant");
         });
         test('lag can check that other args are nonnull', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is 1
         calculate: s is lag(x, null)
       }`).translationToFailWith("Parameter 2 ('offset') of lag must not be a literal null");
         });
         test('lag can use constant values for other args', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is 1
         calculate: s is lag(x, 2)
       }`).toTranslate();
@@ -434,7 +435,7 @@ describe('query:', () => {
             "'concat' is already defined, cannot redefine");
         });
         test('`now` is considered constant`', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: n is now
         calculate: l is lag(n, 1, now)
       }`).toTranslate();
@@ -442,7 +443,7 @@ describe('query:', () => {
         // TODO it might be nice to reference a field which is a constant, and be able to
         // use that as a constant param. Same with a literal.
         test('cannot use a field which is a constant in a constant param', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
           group_by: ai, pi is pi()
           calculate: l is lag(ai, 1, pi)
         }`).translationToFailWith("Parameter 3 ('default') of lag must be literal or constant, but received output");
@@ -452,7 +453,7 @@ describe('query:', () => {
         // as a function argument.
         // We add <join_name>_id to the query, but it's not included in the output space
         test('cannot use struct in function arg', () => {
-            expect(`query: a {join_one: b with astr } -> {
+            expect(`run: a extend {join_one: b with astr } -> {
           group_by: b
           calculate: foo is lag(b)
         }`).translationToFailWith('No matching overload for function lag(struct)');
@@ -460,37 +461,37 @@ describe('query:', () => {
         // TODO this doesn't work today, we're not rigorous enough with integer
         // subtypes. But we should probably make this typecheck properly.
         test.skip('cannot use float in round precision', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: x is round(1.5, 1.6)
       }`).translationToFailWith(
             // TODO improve this error message
             "Parameter 2 ('precision') for round must be integer, received float");
         });
         test('cannot use stddev with no arguments', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         aggregate: x is stddev()
       }`).translationToFailWith('No matching overload for function stddev()');
         });
         test('can use stddev with postfix syntax', () => {
-            expect(`query: a -> {
-        declare: y is 1
+            expect(`run: a -> {
+        extend: { dimension: y is 1 }
         aggregate: x is y.stddev()
       }`).toTranslate();
         });
         test('can use stddev with postfix syntax on join', () => {
-            expect(`query: a -> {
-        join_one: b with astr
+            expect(`run: a -> {
+        extend: { join_one: b with astr }
         aggregate: x is b.ai.stddev()
       }`).toTranslate();
         });
         test('can use calculate with a measure', () => {
-            expect(`query: a { measure: c is count() } -> {
+            expect(`run: a extend { measure: c is count() } -> {
         group_by: y is 1
         calculate: x is lag(c)
       }`).toTranslate();
         });
         test('cannot use calculate with input fields', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: y is 1
         calculate: x is lag(ai)
       }`).translationToFailWith(
@@ -501,24 +502,24 @@ describe('query:', () => {
             "Parameter 1 ('value') of lag must be literal, constant or output, but received input");
         });
         test('can use calculate with aggregate field which is not in query', () => {
-            expect(`query: a { measure: acount is count() } -> {
+            expect(`run: a extend { measure: acount is count() } -> {
         group_by: astr
         calculate: pc is lag(acount)
       }`).toTranslate();
         });
         test('cannot use agregate as argument to agg function', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         aggregate: x is stddev(count())
       }`).translationToFailWith("Parameter 1 ('value') of stddev must be scalar, but received aggregate");
         });
         test('cannot use calculate with no other fields', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         calculate: x is row_number()
       }`).translationToFailWith("Can't determine query type (group_by/aggregate/nest,project,index)");
         });
         // TODO someday make it so we can order by an analytic function
         test('today: cannot order by analytic function', () => {
-            expect(`query: a -> {
+            expect(`run: a -> {
         group_by: astr
         calculate: row_num is row_number()
         order_by: row_num desc
@@ -529,45 +530,44 @@ describe('query:', () => {
         group_by: astr
         calculate: p is lag(astr)
       }
-      query: -> a1 {
+      run: a1 + {
         calculate: p1 is lag(p)
       }`).translationToFailWith("Parameter 1 ('value') of lag must be scalar or aggregate, but received scalar_analytic");
         });
         test('cannot use aggregate analytic in project', () => {
-            expect(`query: a -> {
-        project: astr
+            expect(`run: a -> {
+        select: astr
         calculate: p is lag(count())
       }`).translationToFailWith('Cannot add aggregate analyics to project');
         });
         test('reference field in join', () => {
-            expect(`query: a -> {
-        join_one: b with astr
+            expect(`run: a -> {
+        extend: { join_one: b with astr }
         group_by: b.ai
       }`).toTranslate();
         });
-        // TODO decide whether this syntax should be legal, really...
         test('reference join name in group_by', () => {
-            expect(`query: a -> {
-        join_one: b with astr
+            expect(`run: a -> {
+        extend: { join_one: b with astr }
         group_by: b
       }`).toTranslate();
         });
-        test('can reference project: inline join.* field in calculate', () => {
-            expect(`query: a -> {
-        join_one: b with astr
-        project: b.*
+        test('can reference select: inline join.* field in calculate', () => {
+            expect(`run: a -> {
+        extend: { join_one: b with astr }
+        select: b.*
         calculate: s is lag(ai)
       }`).toTranslate();
         });
-        test('can reference project: join.* field in calculate', () => {
-            expect(`query: a { join_one: b with astr } -> {
-        project: b.*
+        test('can reference select: join.* field in calculate', () => {
+            expect(`run: a extend { join_one: b with astr } -> {
+        select: b.*
         calculate: s is lag(ai)
       }`).toTranslate();
         });
         test('can reference implied output entries in calculate', () => {
             expect(`source: aaa is a extend { dimension: big_i is ai+10 }
-      query: a extend { join_one: aaa on astr=aaa.astr } -> {
+      run: a extend { join_one: aaa on astr=aaa.astr } -> {
         group_by: aaa.big_i
         aggregate: s is aaa.big_i.sum()
         calculate: a is lag(big_i)
@@ -576,26 +576,26 @@ describe('query:', () => {
     });
     describe('qops', () => {
         test('group by single', () => {
-            expect('query: a->{ group_by: astr }').toTranslate();
+            expect('run: a->{ group_by: astr }').toTranslate();
         });
         test("group_by x is x'", () => {
-            expect('query: a->{ group_by: ai is ai/2 }').toTranslate();
+            expect('run: a->{ group_by: ai is ai/2 }').toTranslate();
         });
         test('group by multiple', () => {
-            expect('query: a->{ group_by: astr,ai }').toTranslate();
+            expect('run: a->{ group_by: astr,ai }').toTranslate();
         });
         test('aggregate single', () => {
-            expect('query: a->{ aggregate: num is count() }').toTranslate();
+            expect('run: a->{ aggregate: num is count() }').toTranslate();
         });
         test('calculate in reduce', () => {
-            expect('query: a->{ group_by: astr, ai calculate: num is lag(ai) }').toTranslate();
+            expect('run: a->{ group_by: astr, ai calculate: num is lag(ai) }').toTranslate();
         });
         test('calculate in project', () => {
-            expect('query: a->{ project: astr, ai calculate: num is lag(ai) }').toTranslate();
+            expect('run: a->{ select: astr, ai calculate: num is lag(ai) }').toTranslate();
         });
         test('aggregate reference', () => {
             var _a;
-            const doc = (0, test_translator_1.model) `query: a->{ aggregate: ai.sum() }`;
+            const doc = (0, test_translator_1.model) `run: a->{ aggregate: ai.sum() }`;
             expect(doc).toTranslate();
             const q = doc.translator.getQuery(0);
             expect(q).toBeDefined();
@@ -608,7 +608,7 @@ describe('query:', () => {
         });
         test('timeunit reference', () => {
             var _a;
-            const doc = (0, test_translator_1.model) `query: a->{ group_by: ats.day }`;
+            const doc = (0, test_translator_1.model) `run: a->{ group_by: ats.day }`;
             expect(doc).toTranslate();
             const q = doc.translator.getQuery(0);
             expect(q).toBeDefined();
@@ -617,13 +617,13 @@ describe('query:', () => {
         });
         test('aggregate multiple', () => {
             expect(`
-        query: a->{
+        run: a->{
           aggregate: num is count(), total is sum(ai)
         }
       `).toTranslate();
         });
         test('project ref', () => {
-            expect('query:ab->{ project: b.astr }').toTranslate();
+            expect('run:ab->{ select: b.astr }').toTranslate();
         });
         const afields = test_translator_1.aTableDef.fields
             .filter(f => (0, model_1.isAtomicFieldType)(f.type))
@@ -678,14 +678,10 @@ describe('query:', () => {
             expect(fields.sort()).toEqual(afields.concat('x'));
         });
         test('project def', () => {
-            expect('query:ab->{ project: one is 1 }').toTranslate();
+            expect('run: ab->{ select: one is 1 }').toTranslate();
         });
         test('project multiple', () => {
-            expect(`
-        query: a->{
-          project: one is 1, astr
-        }
-      `).toTranslate();
+            expect('run: a->{ select: one is 1, astr }').toTranslate();
         });
         test('index single', () => { });
         test('regress check extend: and star', () => {
@@ -697,29 +693,29 @@ describe('query:', () => {
             expect(fields.sort()).toEqual(afields.concat('x'));
         });
         test('project def', () => {
-            expect('query:ab->{ project: one is 1 }').toTranslate();
+            expect('run:ab->{ select: one is 1 }').toTranslate();
         });
         test('project multiple', () => {
             expect(`
-        query: a->{
-          project: one is 1, astr
+        run: a->{
+          select: one is 1, astr
         }
       `).toTranslate();
         });
         test('index single', () => {
-            expect('query:a->{index: astr}').toTranslate();
+            expect('run:a->{index: astr}').toTranslate();
         });
         test('index path', () => {
-            expect('query:ab->{index: ab.astr}').toTranslate();
+            expect('run:ab->{index: ab.astr}').toTranslate();
         });
         test('index unique on path', () => {
-            expect('query:ab->{index: b.astr, ab.astr}').toTranslate();
+            expect('run:ab->{index: b.astr, ab.astr}').toTranslate();
         });
         test('index join.*', () => {
-            expect('query:ab->{index: ab.*}').toTranslate();
+            expect('run:ab->{index: ab.*}').toTranslate();
         });
         test('index multiple', () => {
-            const model = new test_translator_1.TestTranslator('query:a->{index: af, astr}');
+            const model = new test_translator_1.TestTranslator('run:a->{index: af, astr}');
             expect(model).toTranslate();
             const q = model.getQuery(0);
             expect(q).toBeDefined();
@@ -730,7 +726,7 @@ describe('query:', () => {
             }
         });
         test('index star', () => {
-            const model = new test_translator_1.TestTranslator('query:a->{index: *, astr}');
+            const model = new test_translator_1.TestTranslator('run:a->{index: *, astr}');
             expect(model).toTranslate();
             const q = model.getQuery(0);
             expect(q).toBeDefined();
@@ -741,16 +737,16 @@ describe('query:', () => {
             }
         });
         test('index by', () => {
-            expect('query:a->{index: * by ai}').toTranslate();
+            expect('run:a->{index: * by ai}').toTranslate();
         });
         test('index sampled', () => {
-            expect('query:a->{index: *; sample: true}').toTranslate();
+            expect('run:a->{index: *; sample: true}').toTranslate();
         });
         test('index unsampled', () => {
-            expect('query:a->{index: *; sample: false}').toTranslate();
+            expect('run:a->{index: *; sample: false}').toTranslate();
         });
         test('index sample-percent', () => {
-            const model = new test_translator_1.TestTranslator('query:a->{index: *; sample: 42%}');
+            const model = new test_translator_1.TestTranslator('run:a->{index: *; sample: 42%}');
             expect(model).toTranslate();
             const q = model.getQuery(0);
             expect(q).toBeDefined();
@@ -763,74 +759,75 @@ describe('query:', () => {
             }
         });
         test('index sample-rows', () => {
-            expect('query:a->{index: *; sample: 100000}').toTranslate();
+            expect('run:a->{index: *; sample: 100000}').toTranslate();
         });
         test('top N', () => {
-            expect('query: a->{ top: 5; group_by: astr }').toTranslate();
+            expect('run: a->{ top: 5; group_by: astr }').toTranslate();
         });
         test('top N by field', () => {
-            expect('query: a->{top: 5 by astr; group_by: astr}').toTranslate();
+            expect(`##! m4warnings
+        run: a->{top: 5 ${'by astr'}; group_by: astr}`).toTranslateWithWarnings('by clause of top statement unupported. Use order_by instead');
         });
         test('top N by expression', () => {
-            expect('query: ab->{top: 5 by ai + 1; group_by: ai}').toTranslate();
+            expect(`##! m4warnings
+        run: ab->{top: 5 by ai + 1; group_by: ai}`).toTranslateWithWarnings('by clause of top statement unupported. Use order_by instead');
         });
-        test('top N by field must be in the output space', () => expect('query: a->{top: 5 by af; group_by: astr}').translationToFailWith('Unknown field af in output space'));
         test('limit N', () => {
-            expect('query: a->{ limit: 5; group_by: astr }').toTranslate();
+            expect('run: a->{ limit: 5; group_by: astr }').toTranslate();
         });
         test('order by', () => {
-            expect('query: a->{ order_by: astr; group_by: astr }').toTranslate();
+            expect('run: a->{ order_by: astr; group_by: astr }').toTranslate();
         });
         test('order by preserved over refinement', () => {
             expect(`
         query: a1 is a -> { group_by: astr }
-        query: -> a1 { order_by: astr }
+        run: a1 + { order_by: astr }
       `).toTranslate();
         });
-        test('order by must be in the output space', () => expect('query: a -> { order_by: af; group_by: astr }').translationToFailWith('Unknown field af in output space'));
+        test('order by must be in the output space', () => expect('run: a -> { order_by: af; group_by: astr }').translationToFailWith('Unknown field af in output space'));
         test('order by asc', () => {
-            expect('query: a->{ order_by: astr asc; group_by: astr }').toTranslate();
+            expect('run: a->{ order_by: astr asc; group_by: astr }').toTranslate();
         });
         test('order by desc', () => {
-            expect('query: a->{ order_by: astr desc; group_by: astr }').toTranslate();
+            expect('run: a->{ order_by: astr desc; group_by: astr }').toTranslate();
         });
         test('order by N', () => {
-            expect('query: a->{ order_by: 1 asc; group_by: astr }').toTranslate();
+            expect('run: a->{ order_by: 1 asc; group_by: astr }').toTranslate();
         });
         test('order by multiple', () => {
             expect(`
-        query: a->{
+        run: a->{
           order_by: 1 asc, af desc
           group_by: astr, af
         }
       `).toTranslate();
         });
         test('agg cannot be used in where', () => {
-            expect('query:ab->{ aggregate: acount; group_by: astr; where: acount > 10 }').translationToFailWith('Aggregate expressions are not allowed in `where:`; use `having:`');
+            expect('run:ab->{ aggregate: acount; group_by: astr; where: acount > 10 }').translationToFailWith('Aggregate expressions are not allowed in `where:`; use `having:`');
         });
         test('analytic cannot be used in where', () => {
-            expect('query:ab->{ calculate: prevc is lag(count()); group_by: astr; where: prevc > 10 }').translationToFailWith("'prevc' is not defined");
+            expect('run:ab->{ calculate: prevc is lag(count()); group_by: astr; where: prevc > 10 }').translationToFailWith("'prevc' is not defined");
         });
         test('analytic cannot be used in having', () => {
-            expect('query:ab->{ calculate: prevc is lag(count()); group_by: astr; having: prevc > 10 }').translationToFailWith('Analytic expressions are not allowed in `having:`');
+            expect('run:ab->{ calculate: prevc is lag(count()); group_by: astr; having: prevc > 10 }').translationToFailWith('Analytic expressions are not allowed in `having:`');
         });
         test('where single', () => {
-            expect('query:a->{ group_by: astr; where: af > 10 }').toTranslate();
+            expect('run:a->{ group_by: astr; where: af > 10 }').toTranslate();
         });
         test('having single', () => {
-            expect('query:ab->{ aggregate: acount; group_by: astr; having: acount > 10 }').toTranslate();
+            expect('run:ab->{ aggregate: acount; group_by: astr; having: acount > 10 }').toTranslate();
         });
         test('compound having still works', () => {
-            expect('query:ab->{ aggregate: acount; having: acount > 10 and acount < 100 }').toTranslate();
+            expect('run:ab->{ aggregate: acount; having: acount > 10 and acount < 100 }').toTranslate();
         });
         test('compound aggregate still works', () => {
-            expect('query:ab->{ aggregate: thing is acount > 10 and acount < 100 }').toTranslate();
+            expect('run:ab->{ aggregate: thing is acount > 10 and acount < 100 }').toTranslate();
         });
         test('where multiple', () => {
-            expect("query:a->{ group_by: astr; where: af > 10,astr~'a%' }").toTranslate();
+            expect("run:a->{ group_by: astr; where: af > 10,astr~'a%' }").toTranslate();
         });
         test('filters preserve source formatting in code:', () => {
-            const model = new test_translator_1.TestTranslator("source: notb is a + { where: astr  !=  'b' }");
+            const model = new test_translator_1.TestTranslator("source: notb is a extend { where: astr  !=  'b' }");
             expect(model).toTranslate();
             const notb = model.getSourceDef('notb');
             expect(notb).toBeDefined();
@@ -843,7 +840,7 @@ describe('query:', () => {
             }
         });
         test('field expressions preserve source formatting in code:', () => {
-            const model = new test_translator_1.TestTranslator('source: notb is a + { dimension: d is 1 +   2 }');
+            const model = new test_translator_1.TestTranslator('source: notb is a extend { dimension: d is 1 +   2 }');
             expect(model).toTranslate();
             const notb = model.getSourceDef('notb');
             expect(notb).toBeDefined();
@@ -858,42 +855,42 @@ describe('query:', () => {
         });
         test('nest single', () => {
             expect(`
-        query: a->{
+        run: a->{
           group_by: ai
           nest: nestbystr is { group_by: astr; aggregate: N is count() }
         }
       `).toTranslate();
         });
         test('nest multiple', () => expect(`
-        query: a->{
+        run: a->{
           group_by: ai
           nest:
             nestbystr is { group_by: astr; aggregate: N is count() },
             renest is { group_by: astr; aggregate: N is count() }
         }
       `).toTranslate());
-        test('nest ref', () => expect('query: ab->{group_by: ai; nest: aturtle}').toTranslate());
+        test('nest ref', () => expect('run: ab->{group_by: ai; nest: aturtle}').toTranslate());
         describe('extend block', () => {
             test('works with dimension', () => {
-                expect('query: a -> { extend: { dimension: x is 1 }; group_by: x }').toTranslate();
+                expect('run: a -> { extend: { dimension: x is 1 }; group_by: x }').toTranslate();
             });
             test('works with measure', () => {
-                expect('query: a -> { extend: { measure: x is count() }; aggregate: x }').toTranslate();
+                expect('run: a -> { extend: { measure: x is count() }; aggregate: x }').toTranslate();
             });
             test('works with join_one', () => {
-                expect('query: a -> { extend: { join_one: bb is b on bb.astr = astr }; group_by: bb.astr }').toTranslate();
+                expect('run: a -> { extend: { join_one: bb is b on bb.astr = astr }; group_by: bb.astr }').toTranslate();
             });
             test('works with join_many', () => {
-                expect('query: a -> { extend: { join_many: b on astr = b.astr }; group_by: b.astr }').toTranslate();
+                expect('run: a -> { extend: { join_many: b on astr = b.astr }; group_by: b.astr }').toTranslate();
             });
             test('works with join_cross', () => {
-                expect('query: a -> { extend: { join_cross: b on true }; group_by: b.astr }').toTranslate();
+                expect('run: a -> { extend: { join_cross: b on true }; group_by: b.astr }').toTranslate();
             });
             test('works with multiple in one block', () => {
-                expect('query: a -> { extend: { dimension: x is 1, y is 2 }; group_by: x, y }').toTranslate();
+                expect('run: a -> { extend: { dimension: x is 1, y is 2 }; group_by: x, y }').toTranslate();
             });
             test('works with multiple blocks', () => {
-                expect('query: a -> { extend: { dimension: x is 1; dimension: y is 2; measure: c is count() }; group_by: x, y; aggregate: c }').toTranslate();
+                expect('run: a -> { extend: { dimension: x is 1; dimension: y is 2; measure: c is count() }; group_by: x, y; aggregate: c }').toTranslate();
             });
         });
         describe('declare/query join warnings', () => {
@@ -912,12 +909,11 @@ describe('query:', () => {
         });
         test('refine query with extended source', () => {
             const m = new test_translator_1.TestTranslator(`
-        source: nab is ab {
-          query: xturtle is aturtle + {
-            declare: aratio is ai / acount
+        run: ab extend {
+          view: xturtle is aturtle + {
+            extend: { measure: aratio is ai / acount }
           }
-        }
-        query: nab -> xturtle + { aggregate: aratio }
+        } -> xturtle + { aggregate: aratio }
       `);
             expect(m).toTranslate();
             const t = m.translate();
@@ -939,8 +935,8 @@ describe('query:', () => {
         });
         test('refine query source with field', () => {
             const m = new test_translator_1.TestTranslator(`
-        query: ab -> aturtle + {
-          declare: aratio is ai / acount
+        run: ab -> aturtle + {
+          extend: { measure:  aratio is ai / acount }
           aggregate: aratio
         }
       `);
@@ -963,8 +959,8 @@ describe('query:', () => {
         });
         test('refine query source with join', () => {
             const m = new test_translator_1.TestTranslator(`
-        query: ab -> aturtle + {
-          join_one: bb is b on bb.astr = astr
+        run: ab -> aturtle + {
+          extend: { join_one: bb is b on bb.astr = astr }
           group_by: foo is bb.astr
         }
       `);
@@ -985,8 +981,8 @@ describe('query:', () => {
     describe('refinement location rules', () => {
         test('where clauses go into the first segment', () => {
             const doc = (0, test_translator_1.model) `
-          query: refineme is a -> { project: stage is "stage1" } -> { project: stage is "stage2" }
-          query: checkme is refineme refine { where: astr = 'a' }`;
+          query: refineme is a -> { select: stage is "stage1" } -> { select: stage is "stage2" }
+          query: checkme is refineme + { where: astr = 'a' }`;
             expect(doc).toTranslate();
             const checkme = doc.translator.getQuery('checkme');
             expect(checkme).toBeDefined();
@@ -1001,7 +997,7 @@ describe('query:', () => {
         test('having clauses go into the last segment', () => {
             const doc = (0, test_translator_1.model) `
         query: refineme is a -> { group_by: ai,astr  } -> { group_by: ai, aggregate: ac is count() }
-        query: checkme is refineme refine { having: ac > 0 }`;
+        query: checkme is refineme + { having: ac > 0 }`;
             expect(doc).toTranslate();
             const checkme = doc.translator.getQuery('checkme');
             expect(checkme).toBeDefined();
@@ -1016,7 +1012,7 @@ describe('query:', () => {
         test('limit goes into the last segment', () => {
             const doc = (0, test_translator_1.model) `
         query: refineme is a -> { group_by: ai,astr  } -> { group_by: ai, aggregate: ac is count() }
-        query: checkme is refineme refine { limit: 1 }`;
+        query: checkme is refineme + { limit: 1 }`;
             expect(doc).toTranslate();
             const checkme = doc.translator.getQuery('checkme');
             expect(checkme).toBeDefined();
@@ -1027,7 +1023,7 @@ describe('query:', () => {
         test('order_by goes into the last segment', () => {
             const doc = (0, test_translator_1.model) `
         query: refineme is a -> { group_by: ai,astr  } -> { group_by: ai, aggregate: ac is count() }
-        query: checkme is refineme refine { order_by: 2 }`;
+        query: checkme is refineme + { order_by: 2 }`;
             expect(doc).toTranslate();
             const checkme = doc.translator.getQuery('checkme');
             expect(checkme).toBeDefined();
@@ -1037,28 +1033,28 @@ describe('query:', () => {
         });
         const stageErr = 'Illegal in refinement of a query with more than one stage';
         test('group_by illegal in long pipes', () => {
-            expect((0, test_translator_1.markSource) `query: refineme is a -> { project: stage is "stage1" } -> { project: stage is "stage2" }
-        query: checkme is refineme refine { ${'group_by: stage'} }`).translationToFailWith(stageErr);
+            expect((0, test_translator_1.markSource) `query: refineme is a -> { select: stage is "stage1" } -> { select: stage is "stage2" }
+        query: checkme is refineme + { ${'group_by: stage'} }`).translationToFailWith(stageErr);
         });
         test('aggregate illegal in long pipes', () => {
-            expect((0, test_translator_1.markSource) `query: refineme is a -> { project: stage is "stage1" } -> { project: stage is "stage2" }
-        query: checkme is refineme refine { ${'aggregate: c is count()'} }`).translationToFailWith(stageErr);
+            expect((0, test_translator_1.markSource) `query: refineme is a -> { select: stage is "stage1" } -> { select: stage is "stage2" }
+        query: checkme is refineme + { ${'aggregate: c is count()'} }`).translationToFailWith(stageErr);
         });
         test('calcluate illegal in long pipes', () => {
-            expect((0, test_translator_1.markSource) `query: refineme is a -> { project: stage is "stage1" } -> { project: stage is "stage2" }
-        query: checkme is refineme refine { ${'calculate: c is count()'} }`).translationToFailWith(stageErr);
+            expect((0, test_translator_1.markSource) `query: refineme is a -> { select: stage is "stage1" } -> { select: stage is "stage2" }
+        query: checkme is refineme + { ${'calculate: c is count()'} }`).translationToFailWith(stageErr);
         });
         test('extend illegal in long pipes', () => {
-            expect((0, test_translator_1.markSource) `query: refineme is a -> { project: stage is "stage1" } -> { project: stage is "stage2" }
-        query: checkme is refineme refine { ${'extend: {measure: c is count()}'} }`).translationToFailWith(stageErr);
+            expect((0, test_translator_1.markSource) `query: refineme is a -> { select: stage is "stage1" } -> { select: stage is "stage2" }
+        query: checkme is refineme + { ${'extend: {measure: c is count()}'} }`).translationToFailWith(stageErr);
         });
         test('nest illegal in long pipes', () => {
-            expect((0, test_translator_1.markSource) `query: refineme is a -> { project: stage is "stage1" } -> { project: stage is "stage2" }
-        query: checkme is refineme refine { ${'nest: b is {group_by: stage}'} }`).translationToFailWith(stageErr);
+            expect((0, test_translator_1.markSource) `query: refineme is a -> { select: stage is "stage1" } -> { select: stage is "stage2" }
+        query: checkme is refineme + { ${'nest: b is {group_by: stage}'} }`).translationToFailWith(stageErr);
         });
         test('all single stage refinements are accepted', () => {
             expect((0, test_translator_1.markSource) `query: refineme is a -> { group_by: stage is "stage1" }
-        query: checkme is refineme refine {
+        query: checkme is refineme + {
           extend: { dimension: red is 'red' }
           nest: nestRed is { group_by: red }
           group_by: ai