@malloydata/malloy-tests 0.0.248-dev250325154148 → 0.0.248-dev250325235002

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.248-dev250325154148",
-    "@malloydata/db-duckdb": "^0.0.248-dev250325154148",
-    "@malloydata/db-postgres": "^0.0.248-dev250325154148",
-    "@malloydata/db-snowflake": "^0.0.248-dev250325154148",
-    "@malloydata/db-trino": "^0.0.248-dev250325154148",
-    "@malloydata/malloy": "^0.0.248-dev250325154148",
-    "@malloydata/malloy-tag": "^0.0.248-dev250325154148",
-    "@malloydata/render": "^0.0.248-dev250325154148",
+    "@malloydata/db-bigquery": "^0.0.248-dev250325235002",
+    "@malloydata/db-duckdb": "^0.0.248-dev250325235002",
+    "@malloydata/db-postgres": "^0.0.248-dev250325235002",
+    "@malloydata/db-snowflake": "^0.0.248-dev250325235002",
+    "@malloydata/db-trino": "^0.0.248-dev250325235002",
+    "@malloydata/malloy": "^0.0.248-dev250325235002",
+    "@malloydata/malloy-tag": "^0.0.248-dev250325235002",
+    "@malloydata/render": "^0.0.248-dev250325235002",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -38,5 +38,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.248-dev250325154148"
+  "version": "0.0.248-dev250325235002"
 }

package/src/databases/all/db_filter_expressions.spec.ts

@@ -16,98 +16,94 @@ afterAll(async () => {
   await runtimes.closeAll();
 });
 
-// mtoy todo sit down with each parser and compiler and make sure there is a test for every case
-
 describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
   const q = db.getQuoter();
   describe('string filter expressions', () => {
-    const bq = db.dialect.sqlLiteralString('x\\');
+    function got(s: string) {
+      const zipMe = s.split(',');
+      return zipMe.map(s => ({nm: s}));
+    }
+    const xbq = db.dialect.sqlLiteralString('x\\');
     const abc = db.loadModel(`
       source: abc is ${dbName}.sql("""
-        SELECT 'abc' as ${q`s`}, '0 - abc' as ${q`nm`}
-        UNION ALL SELECT 'def', '1 - def'
-        UNION ALL SELECT null, '2 - null'
-        UNION ALL SELECT '', '3 - empty'
-        UNION ALL SELECT ${bq}, '4 - xback'
+        SELECT 'abc' as ${q`s`}, 'abc' as ${q`nm`}
+        UNION ALL SELECT 'def', 'def'
+        UNION ALL SELECT ${xbq}, 'xback'
+        UNION ALL SELECT '', 'z-empty'
+        UNION ALL SELECT null, 'z-null'
       """)
     `);
 
-    test('abc', async () => {
+    test('is abc', async () => {
       await expect(`
         run: abc -> {
           where: s ~ f'abc';
           select: s
         }`).malloyResultMatches(abc, [{s: 'abc'}]);
     });
+    test.skip('empty string filter expression', async () => {
+      /*
+        since the sql generated works when pasted into mysql
+        my next suggestion is that there is some funky re-ordering
+        happening in the result processing which will test tomorrow
+      */
+      await expect(`
+        # test.verbose
+        run: abc -> {
+          where: s ~ f'';
+          select: *; order_by: nm asc
+        }`).malloyResultMatches(abc, got('abc,def,xback,z-empty,z-null'));
+    });
     test('abc,def', async () => {
       await expect(`
         run: abc -> {
           where: s ~ f'abc,def';
-          select: nm; order_by: nm
-        }`).malloyResultMatches(abc, [{nm: '0 - abc'}, {nm: '1 - def'}]);
+          select: nm; order_by: nm asc
+        }`).malloyResultMatches(abc, got('abc,def'));
     });
     test('-abc', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-abc',
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '1 - def'},
-        {nm: '2 - null'},
-        {nm: '3 - empty'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('def,xback,z-empty,z-null'));
     });
     test('-starts', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-a%',
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '1 - def'},
-        {nm: '2 - null'},
-        {nm: '3 - empty'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('def,xback,z-empty,z-null'));
     });
     test('-contains', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-%b%',
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '1 - def'},
-        {nm: '2 - null'},
-        {nm: '3 - empty'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('def,xback,z-empty,z-null'));
     });
     test('-end', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-%c',
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '1 - def'},
-        {nm: '2 - null'},
-        {nm: '3 - empty'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('def,xback,z-empty,z-null'));
     });
     test('unlike', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-a%c',
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '1 - def'},
-        {nm: '2 - null'},
-        {nm: '3 - empty'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('def,xback,z-empty,z-null'));
     });
     test('simple but not ___,-abc', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'___,-abc';
           select: s
@@ -115,43 +111,39 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
     test('empty', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'empty'
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [{nm: '2 - null'}, {nm: '3 - empty'}]);
+        }`).malloyResultMatches(abc, got('z-empty,z-null'));
     });
     test('-empty', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-empty'
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '0 - abc'},
-        {nm: '1 - def'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('abc,def,xback'));
     });
     test('null', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'null'
           select: nm
-        }`).malloyResultMatches(abc, [{nm: '2 - null'}]);
+        }`).malloyResultMatches(abc, got('z-null'));
     });
     test('-null', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'-null'
           select: nm; order_by: nm asc
-        }`).malloyResultMatches(abc, [
-        {nm: '0 - abc'},
-        {nm: '1 - def'},
-        {nm: '3 - empty'},
-        {nm: '4 - xback'},
-      ]);
+        }`).malloyResultMatches(abc, got('abc,def,xback,z-empty'));
     });
     test('starts', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'a%';
           select: s
@@ -159,13 +151,15 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
     test('contains', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'%b%,%e%';
-          select: s; order_by: s asc
+          select: *; order_by: nm asc
         }`).malloyResultMatches(abc, [{s: 'abc'}, {s: 'def'}]);
     });
     test('simple ends', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'%c';
           select: s
@@ -173,17 +167,19 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
     test('ends in backslash', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'%\\\\'
           select: nm
-        }`).malloyResultMatches(abc, [{nm: '4 - xback'}]);
+        }`).malloyResultMatches(abc, got('xback'));
     });
     test('= x backslash', async () => {
       await expect(`
+        # test.verbose
         run: abc -> {
           where: s ~ f'x\\\\'
           select: nm
-        }`).malloyResultMatches(abc, [{nm: '4 - xback'}]);
+        }`).malloyResultMatches(abc, got('xback'));
     });
   });
 
@@ -198,6 +194,20 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
         UNION ALL SELECT NULL, 'null'
       """)
     `);
+    test.skip('empty numeric filter', async () => {
+      await expect(`
+        run: nums -> {
+          where: n ~ f''
+          select: t; order_by: t asc
+        }`).malloyResultMatches(nums, [
+        {t: '0'},
+        {t: '1'},
+        {t: '2'},
+        {t: '3'},
+        {t: '4'},
+        {t: 'null'},
+      ]);
+    });
     test('2', async () => {
       await expect(`
         run: nums -> {
@@ -227,7 +237,6 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
     test('not [1 to 3]', async () => {
       await expect(`
-        # test.verbose
         run: nums -> {
           where: n ~ f'not [1 to 3]'
           select: t; order_by: t asc
@@ -299,6 +308,7 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
   });
 
   // mysql doesn't have true booleans ...
+  const testBoolean = !db.dialect.booleanAsNumbers;
   describe('boolean filter expressions', () => {
     const facts = db.loadModel(`
       source: facts is ${dbName}.sql("""
@@ -307,48 +317,59 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
         UNION ALL SELECT NULL, 'null'
       """)
     `);
-    test.when(dbName !== 'mysql')('true', async () => {
+    test.when(testBoolean)('true', async () => {
       await expect(`
         run: facts -> {
           where: b ~ f'true'
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'true'}]);
     });
-    test.when(dbName !== 'mysql')('true', async () => {
+    test.when(testBoolean)('true', async () => {
       await expect(`
         run: facts -> {
           where: b ~ f'true'
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'true'}]);
     });
-    test.when(dbName !== 'mysql')('false', async () => {
+    test.when(testBoolean)('false', async () => {
       await expect(`
         run: facts -> {
           where: b ~ f'false'
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'false'}, {t: 'null'}]);
     });
-    test.when(dbName !== 'mysql')('=false', async () => {
+    test.when(testBoolean)('=false', async () => {
       await expect(`
         run: facts -> {
           where: b ~ f'=false'
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'false'}]);
     });
-    test.when(dbName !== 'mysql')('null', async () => {
+    test.when(testBoolean)('null', async () => {
       await expect(`
         run: facts -> {
           where: b ~ f'null'
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'null'}]);
     });
-    test.when(dbName !== 'mysql')('not null', async () => {
+    test.when(testBoolean)('not null', async () => {
       await expect(`
         run: facts -> {
           where: b ~ f'not null'
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'false'}, {t: 'true'}]);
     });
+    // test.when(testBoolean)('empty boolean filter', async () => {
+    //   await expect(`
+    //     run: facts -> {
+    //       where: b ~ f''
+    //       select: t; order_by: t asc
+    //     }`).malloyResultMatches(facts, [
+    //     {t: 'false'},
+    //     {t: 'null'},
+    //     {t: 'true'},
+    //   ]);
+    // });
   });
 
   type TL = 'timeLiteral';
@@ -373,12 +394,12 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
      * { t: 1 second before start, n: 'before' }
      * { t: start,                 n: 'first' }
      * { t: 1 second before end,   n: 'last' }
-     * { t: end,                   n: 'zend' }
-     * { t: NULL                   n: ' null ' }
+     * { t: end,                   n: 'post-range' }
+     * { t: NULL                   n: 'z-null' }
      * Use malloyResultMatches(range, inRange) or (range, notInRange)
      */
     const inRange = [{n: 'first'}, {n: 'last'}];
-    const notInRange = [{n: 'before'}, {n: 'zend'}];
+    const notInRange = [{n: 'before'}, {n: 'post-range'}];
     function mkRange(start: string, end: string) {
       const begin = LuxonDateTime.fromFormat(start, fTimestamp);
       const b4 = begin.minus({second: 1});
@@ -394,8 +415,8 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
           SELECT ${before} AS ${q`t`}, 'before' AS ${q`n`}
           UNION ALL SELECT ${lit(start, 'timestamp')}, 'first'
           UNION ALL SELECT ${last} , 'last'
-          UNION ALL SELECT ${lit(end, 'timestamp')}, 'zend'
-          UNION ALL SELECT NULL, ' null '
+          UNION ALL SELECT ${lit(end, 'timestamp')}, 'post-range'
+          UNION ALL SELECT NULL, 'z-null'
         """)
         -> {select: *; order_by: n}`;
       return db.loadModel(rangeModel);
@@ -412,10 +433,10 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
           )} AS ${q`t`}, 'before' AS ${q`n`}
           UNION ALL SELECT ${lit(start, 'date')}, 'first'
           UNION ALL SELECT ${lit(last.toFormat(fDate), 'date')} , 'last'
-          UNION ALL SELECT ${lit(end, 'date')}, 'zend'
-          UNION ALL SELECT NULL, ' null '
+          UNION ALL SELECT ${lit(end, 'date')}, 'post-range'
+          UNION ALL SELECT NULL, 'z-null'
         """)
-        -> {select: *; order_by: n}`;
+        -> {select: t,n; order_by: n}`;
       return db.loadModel(rangeModel);
     }
 
@@ -432,7 +453,7 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
       const range = mkDateRange('2001-01-01', '2001-04-01');
       await expect(`
         run: range + { where: t ~ f'after 2001-Q1' }
-      `).malloyResultMatches(range, {n: 'zend'});
+      `).malloyResultMatches(range, {n: 'post-range'});
     });
     test('date before month', async () => {
       const range = mkDateRange('2001-01-01', '2001-02-01');
@@ -497,7 +518,7 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
       const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
       await expect(`
         run: range + { where: t ~ f'after 2001' }
-      `).malloyResultMatches(range, [{n: 'zend'}]);
+      `).malloyResultMatches(range, [{n: 'post-range'}]);
     });
     test('y2k for 1 minute', async () => {
       const range = mkRange('2001-01-01 00:00:00', '2001-01-01 00:01:00');
@@ -545,17 +566,30 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
       const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
       await expect(`
         run: range + { where: t ~ f'null' }
-      `).malloyResultMatches(range, [{n: ' null '}]);
+      `).malloyResultMatches(range, [{n: 'z-null'}]);
     });
     test('not null', async () => {
       const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
       await expect(`
-        run: range + { where: t ~ f'not null' }
+        run: range + { where: t ~ f'not null'; order_by: n }
+      `).malloyResultMatches(range, [
+        {n: 'before'},
+        {n: 'first'},
+        {n: 'last'},
+        {n: 'post-range'},
+      ]);
+    });
+    test.skip('empty temporal filter', async () => {
+      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
+      await expect(`
+        # test.verbose
+        run: range + { where: t ~ f''; order_by: n }
       `).malloyResultMatches(range, [
         {n: 'before'},
         {n: 'first'},
         {n: 'last'},
-        {n: 'zend'},
+        {n: 'post-range'},
+        {n: 'z-null'},
       ]);
     });
     test('year literal', async () => {

package/src/databases/all/nomodel.spec.ts

@@ -550,6 +550,7 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
       // symmetric aggregate are needed on both sides of the join
       // Check the row count and that sums on each side work properly.
       await expect(`
+        # test.verbose
         run: ${databaseName}.table('malloytest.state_facts') -> {
           group_by: state
           nest: ugly is {

package/src/databases/all/orderby.spec.ts

@@ -184,4 +184,166 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
       } -> foo
     `).malloyResultMatches(orderByModel, {});
   });
+
+  // There's a problem with null ordering in MySQL which we are ignoring for now
+  const testNullOrdering = databaseName !== 'mysql';
+  const testTimes =
+    testNullOrdering && !['presto', 'trino'].includes(databaseName);
+  describe('null ordering', () => {
+    const q = runtime.getQuoter();
+    const a = runtime.dialect.sqlLiteralString('a');
+    const b = runtime.dialect.sqlLiteralString('b');
+    const c = runtime.dialect.sqlLiteralString('c');
+    const abc = `${databaseName}.sql("""
+      SELECT ${a} as ${q`l`}, 'a' as ${q`ln`}
+      UNION ALL SELECT ${c}, 'c'
+      UNION ALL SELECT ${b}, 'b'
+      UNION ALL SELECT NULL, 'null'
+    """)`;
+    test.when(testNullOrdering)(
+      'null last in select string with ascending order',
+      async () => {
+        await expect(
+          `run: ${abc} -> { select: *; order_by: l asc }`
+        ).malloyResultMatches(runtime, [
+          {ln: 'a'},
+          {ln: 'b'},
+          {ln: 'c'},
+          {ln: 'null'},
+        ]);
+      }
+    );
+    test.when(testNullOrdering)(
+      'null last in select string with descending order',
+      async () => {
+        await expect(
+          `run: ${abc} -> { select: *; order_by: l desc }`
+        ).malloyResultMatches(runtime, [
+          {ln: 'c'},
+          {ln: 'b'},
+          {ln: 'a'},
+          {ln: 'null'},
+        ]);
+      }
+    );
+    test.when(testNullOrdering)(
+      'null last in reduce string with default ascending order',
+      async () => {
+        await expect(`
+        #! test.verbose
+        run: ${abc} -> { group_by: l }`).malloyResultMatches(runtime, [
+          {l: 'a'},
+          {l: 'b'},
+          {l: 'c'},
+          {l: null},
+        ]);
+      }
+    );
+    const nums = `${databaseName}.sql("""
+      SELECT 1 as ${q`n`}
+      UNION ALL SELECT 9
+      UNION ALL SELECT 5
+      UNION ALL SELECT NULL
+      """)`;
+    test.when(testNullOrdering)(
+      'null last in numbers with ascending order',
+      async () => {
+        await expect(
+          `run: ${nums} -> { select: n; order_by: n asc }`
+        ).malloyResultMatches(runtime, [{n: 1}, {n: 5}, {n: 9}, {n: null}]);
+      }
+    );
+    test.when(testNullOrdering)(
+      'null last in numbers with descending order',
+      async () => {
+        await expect(
+          `run: ${nums} -> { select: n; order_by: n desc }`
+        ).malloyResultMatches(runtime, [{n: 9}, {n: 5}, {n: 1}, {n: null}]);
+      }
+    );
+    test.when(testNullOrdering)(
+      'null last in reduce measure with default descending order',
+      async () => {
+        await expect(`
+        # test.verbose
+        run: ${nums} -> {
+          group_by: nstr is n ? pick 'null' when is null else concat('number', n::string)
+          aggregate: nTotal is n.sum()
+        }`).malloyResultMatches(runtime, [
+          {nstr: 'number9'},
+          {nstr: 'number5'},
+          {nstr: 'number1'},
+          {nstr: 'null'},
+        ]);
+      }
+    );
+    const y2020 = runtime.dialect.sqlLiteralTime(
+      {},
+      {
+        node: 'timeLiteral',
+        literal: '2020-01-01 00:00:00',
+        typeDef: {type: 'timestamp'},
+      }
+    );
+    const d2020 = new Date('2020-01-01 00:00:00Z');
+    const d2022 = new Date('2022-01-01 00:00:00Z');
+    const d2025 = new Date('2025-01-01 00:00:00Z');
+    const y2025 = runtime.dialect.sqlLiteralTime(
+      {},
+      {
+        node: 'timeLiteral',
+        literal: '2025-01-01 00:00:00',
+        typeDef: {type: 'timestamp'},
+      }
+    );
+    const y2022 = runtime.dialect.sqlLiteralTime(
+      {},
+      {
+        node: 'timeLiteral',
+        literal: '2022-01-01 00:00:00',
+        typeDef: {type: 'timestamp'},
+      }
+    );
+    const times = `${databaseName}.sql("""
+      SELECT ${y2020} as ${q`t`}
+      UNION ALL SELECT ${y2025}
+      UNION ALL SELECT ${y2022}
+      UNION ALL SELECT NULL
+    """)`;
+    test.when(testTimes)(
+      'null last in timestamps with ascending order',
+      async () => {
+        await expect(
+          `run: ${times} -> { select: t; order_by: t asc }`
+        ).malloyResultMatches(runtime, [
+          {t: d2020},
+          {t: d2022},
+          {t: d2025},
+          {t: null},
+        ]);
+      }
+    );
+    test.when(testTimes)(
+      'null last in timestamps with descending order',
+      async () => {
+        await expect(
+          `run: ${times} -> { select: t; order_by: t desc }`
+        ).malloyResultMatches(runtime, [
+          {t: d2025},
+          {t: d2022},
+          {t: d2020},
+          {t: null},
+        ]);
+      }
+    );
+    test.when(testTimes)(
+      'null last in reduce timestamps with default descending order',
+      async () => {
+        await expect(`run: ${times} -> { group_by: t }`).malloyResultMatches(
+          runtime,
+          [{t: d2025}, {t: d2022}, {t: d2020}, {t: null}]
+        );
+      }
+    );
+  });
 });

package/src/databases/bigquery/wildcard_table_names.spec.ts

@@ -100,7 +100,6 @@ describe('Wildcard BigQuery Tables', () => {
         )
         .run();
       expect(result.data.value).toStrictEqual([
-        {state: null, aircraft_count: 43},
         {state: 'IA', aircraft_count: 1},
         {state: 'KS', aircraft_count: 1},
         {state: 'LA', aircraft_count: 1},
@@ -109,6 +108,7 @@ describe('Wildcard BigQuery Tables', () => {
         {state: 'OK', aircraft_count: 1},
         {state: 'OR', aircraft_count: 2},
         {state: 'TX', aircraft_count: 1},
+        {state: null, aircraft_count: 43},
       ]);
     }
   });
@@ -137,11 +137,11 @@ describe('Wildcard BigQuery Tables', () => {
         )
         .run();
       expect(result.data.value).toStrictEqual([
-        {state: null, aircraft_count: 47},
         {state: 'KS', aircraft_count: 1},
         {state: 'LA', aircraft_count: 1},
         {state: 'OK', aircraft_count: 1},
         {state: 'OR', aircraft_count: 1},
+        {state: null, aircraft_count: 47},
       ]);
     }
   });
@@ -197,8 +197,8 @@ describe('Wildcard BigQuery Tables', () => {
         )
         .run();
       expect(result.data.value).toStrictEqual([
-        {_TABLE_SUFFIX: null, aircraft_count: 47},
         {_TABLE_SUFFIX: '02', aircraft_count: 4},
+        {_TABLE_SUFFIX: null, aircraft_count: 47},
       ]);
     }
   });