@malloydata/malloy-tests 0.0.125 → 0.0.126-dev240305182920

package/snowflake/uploaddata.sql

@@ -0,0 +1,267 @@
+-- to run
+
+-- cd test/snowflake
+-- snowsql -f uploadddate.sql
+
+
+drop database malloytestdb;
+create database malloytestdb;
+
+use malloytestdb;
+create schema malloytest;
+
+CREATE OR REPLACE FILE FORMAT PARQUET_SCHEMA_DETECTION
+  TYPE = PARQUET
+  BINARY_AS_TEXT = FALSE;
+
+PUT file://../data/duckdb/aircraft.parquet @~/staged;
+
+CREATE OR REPLACE TABLE aircraft
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/aircraft.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.aircraft
+FROM '@~/staged/aircraft.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/aircraft_models.parquet @~/staged;
+
+CREATE OR REPLACE TABLE aircraft_models
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/aircraft_models.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.aircraft_models
+FROM '@~/staged/aircraft_models.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/airports.parquet @~/staged;
+
+CREATE OR REPLACE TABLE airports
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/airports.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.airports
+FROM '@~/staged/airports.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/alltypes.parquet @~/staged;
+
+CREATE OR REPLACE TABLE alltypes
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/alltypes.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.alltypes
+FROM '@~/staged/alltypes.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/alltypes2.parquet @~/staged;
+
+CREATE OR REPLACE TABLE alltypes2
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/alltypes2.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.alltypes2
+FROM '@~/staged/alltypes2.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/bq_medicare_test.parquet @~/staged;
+
+CREATE OR REPLACE TABLE bq_medicare_test
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/bq_medicare_test.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.bq_medicare_test
+FROM '@~/staged/bq_medicare_test.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/carriers.parquet @~/staged;
+
+CREATE OR REPLACE TABLE carriers
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/carriers.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.carriers
+FROM '@~/staged/carriers.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/flights.parquet @~/staged;
+
+CREATE OR REPLACE TABLE flights
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/flights.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.flights
+FROM '@~/staged/flights.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/flights_partitioned.parquet @~/staged;
+
+CREATE OR REPLACE TABLE flights_partitioned
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/flights_partitioned.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.flights_partitioned
+FROM '@~/staged/flights_partitioned.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/ga_sample.parquet @~/staged;
+
+CREATE OR REPLACE TABLE ga_sample
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/ga_sample.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.ga_sample
+FROM '@~/staged/ga_sample.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/numbers.parquet @~/staged;
+
+CREATE OR REPLACE TABLE numbers
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/numbers.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.numbers
+FROM '@~/staged/numbers.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/state_facts.parquet @~/staged;
+
+CREATE OR REPLACE TABLE state_facts
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/state_facts.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.state_facts
+FROM '@~/staged/state_facts.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/words.parquet @~/staged;
+
+CREATE OR REPLACE TABLE words
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/words.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.words
+FROM '@~/staged/words.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;
+
+PUT file://../data/duckdb/words_bigger.parquet @~/staged;
+
+CREATE OR REPLACE TABLE words_bigger
+    USING TEMPLATE (
+        SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
+        FROM TABLE(
+            INFER_SCHEMA(
+            LOCATION=>'@~/staged/words_bigger.parquet',
+            FILE_FORMAT => 'PARQUET_SCHEMA_DETECTION')
+        )
+    );
+
+COPY INTO malloytest.words_bigger
+FROM '@~/staged/words_bigger.parquet'
+FILE_FORMAT = 'PARQUET_SCHEMA_DETECTION'
+MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE
+ON_ERROR = CONTINUE;

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

@@ -58,6 +58,9 @@ source: aircraft is ${databaseName}.table('malloytest.aircraft') extend {
 describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
   const expressionModel = runtime.loadModel(modelText(databaseName));
   // basic calculations for sum, filtered sum, without a join.
+
+  const q = runtime.getQuoter();
+
   it('basic calculations', async () => {
     await expect(`
       run: aircraft_models->{
@@ -228,8 +231,11 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
   });
 
   // TODO not sure why this test needs to be skipped on postgres, feels like an oversight
-  testIf(databaseName !== 'postgres')('model: dates named', async () => {
-    await expect(`
+  // NOTE: unless underlying type is stored as a timestamp snowflake does not support extraction
+  testIf(!['postgres', 'snowflake'].includes(databaseName))(
+    'model: dates named',
+    async () => {
+      await expect(`
       run: ${databaseName}.table('malloytest.alltypes')->{
         group_by:
           t_date,
@@ -244,18 +250,19 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           t_timestamp_year is t_timestamp.year,
       }
     `).malloyResultMatches(runtime, {
-      t_date: new Date('2020-03-02'),
-      t_date_month: new Date('2020-03-01'),
-      t_date_year: new Date('2020-01-01'),
-      t_timestamp: new Date('2020-03-02T12:35:56.000Z'),
-      t_timestamp_second: new Date('2020-03-02T12:35:56.000Z'),
-      t_timestamp_minute: new Date('2020-03-02T12:35:00.000Z'),
-      t_timestamp_hour: new Date('2020-03-02T12:00:00.000Z'),
-      t_timestamp_date: new Date('2020-03-02'),
-      t_timestamp_month: new Date('2020-03-01'),
-      t_timestamp_year: new Date('2020-01-01'),
-    });
-  });
+        t_date: new Date('2020-03-02'),
+        t_date_month: new Date('2020-03-01'),
+        t_date_year: new Date('2020-01-01'),
+        t_timestamp: new Date('2020-03-02T12:35:56.000Z'),
+        t_timestamp_second: new Date('2020-03-02T12:35:56.000Z'),
+        t_timestamp_minute: new Date('2020-03-02T12:35:00.000Z'),
+        t_timestamp_hour: new Date('2020-03-02T12:00:00.000Z'),
+        t_timestamp_date: new Date('2020-03-02'),
+        t_timestamp_month: new Date('2020-03-01'),
+        t_timestamp_year: new Date('2020-01-01'),
+      });
+    }
+  );
 
   it('named query metadata undefined', async () => {
     const result = await expressionModel
@@ -309,19 +316,22 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(expressionModel, {a: 312});
   });
 
-  testIf(runtime.connection.name !== 'postgres')('sql safe cast', async () => {
-    await expect(`
+  testIf(!['postgres', 'snowflake'].includes(runtime.connection.name))(
+    'sql safe cast',
+    async () => {
+      await expect(`
       run: ${databaseName}.sql('SELECT 1') -> { select:
         bad_date is '123':::date
         bad_number is 'abc':::number
         good_number is "312":::"integer"
       }
     `).malloyResultMatches(expressionModel, {
-      bad_date: null,
-      bad_number: null,
-      good_number: 312,
-    });
-  });
+        bad_date: null,
+        bad_number: null,
+        good_number: 312,
+      });
+    }
+  );
 
   it('many_field.sum() has correct locality', async () => {
     await expect(`
@@ -433,7 +443,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
       source: a is ${databaseName}.table('malloytest.aircraft_models') extend { where: aircraft_model_code ? '0270202' }
 
       run: a -> {
-          group_by: string_1 is sql_string("UPPER(\${TABLE}.manufacturer)")
+          group_by: string_1 is sql_string('UPPER(\${TABLE}.${q`manufacturer`})')
         }
       `).malloyResultMatches(expressionModel, {
         string_1: 'AHRENS AIRCRAFT CORP.',
@@ -579,7 +589,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     });
   });
 
-  it('joined filtered explores with dependancies', async () => {
+  it('joined filtered explores with dependencies', async () => {
     await expect(`
       source: bo_models is
         ${databaseName}.table('malloytest.aircraft_models') extend { where: manufacturer ? ~ 'BO%' }
@@ -613,6 +623,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
 });
 
 describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
+  const q = runtime.getQuoter();
   const sqlEq = mkSqlEqWith(runtime, databaseName, {
     malloy: `extend {
       dimension: friName is 'friday'
@@ -687,7 +698,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
   test('nullish ?? operator', async () => {
     await expect(
       `run: ${databaseName}.sql("""
-          SELECT '' as null_value, '' as string_value
+          SELECT '' as ${q`null_value`}, '' as ${q`string_value`}
           UNION ALL SELECT null, 'correct'
       """) -> {
         where: null_value = null

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

@@ -111,6 +111,11 @@ expressionModels.forEach((expressionModel, databaseName) => {
 
   describe('concat', () => {
     it(`works - ${databaseName}`, async () => {
+      const expected = {
+        'bigquery': 'foo2003-01-01 12:00:00+00',
+        'snowflake': 'foo2003-01-01 12:00:00.000',
+      };
+
       await funcTestMultiple(
         ["concat('foo', 'bar')", 'foobar'],
         ["concat(1, 'bar')", '1bar'],
@@ -121,9 +126,7 @@ expressionModels.forEach((expressionModel, databaseName) => {
         ["concat('foo', @2003)", 'foo2003-01-01'],
         [
           "concat('foo', @2003-01-01 12:00:00)",
-          databaseName === 'bigquery'
-            ? 'foo2003-01-01 12:00:00+00'
-            : 'foo2003-01-01 12:00:00',
+          expected[databaseName] ?? 'foo2003-01-01 12:00:00',
         ],
         // TODO Maybe implement consistent null behavior
         // ["concat('foo', null)", null],
@@ -251,7 +254,7 @@ expressionModels.forEach((expressionModel, databaseName) => {
 
   describe('stddev', () => {
     // TODO symmetric aggregates don't work with custom aggregate functions in BQ currently
-    if (databaseName === 'bigquery') return;
+    if (['bigquery', 'snowflake'].includes(databaseName)) return;
     it(`works - ${databaseName}`, async () => {
       await funcTestAgg('round(stddev(aircraft_models.seats))', 29);
     });
@@ -906,13 +909,13 @@ expressionModels.forEach((expressionModel, databaseName) => {
   describe('coalesce', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ["coalesce('a')", 'a'],
+        // ["coalesce('a')", 'a'],
         ["coalesce('a', 'b')", 'a'],
         ["coalesce(null, 'a', 'b')", 'a'],
         ["coalesce(null, 'b')", 'b'],
         ["coalesce('a', null)", 'a'],
-        ['coalesce(null, null)', null],
-        ['coalesce(null)', null]
+        ['coalesce(null, null)', null]
+        // ['coalesce(null)', null]
       );
     });
   });
@@ -931,11 +934,11 @@ expressionModels.forEach((expressionModel, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['chr(65)', 'A'],
-        ['chr(255)', 'ÿ'],
-        ['chr(null)', null],
+        ['chr(255)', 'ÿ']
         // BigQuery's documentation says that `chr(0)` returns the empty string, but it doesn't,
         // it actually returns the null character. We generate code so that it does this.
-        ['chr(0)', '']
+        // ['chr(0)', '']
+        // ['chr(null)', null]
       );
     });
   });

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

@@ -46,6 +46,8 @@ function getSplitFunction(db: string) {
       `string_to_array(${column}, '${splitChar}')`,
     'duckdb_wasm': (column: string, splitChar: string) =>
       `string_to_array(${column}, '${splitChar}')`,
+    'snowflake': (column: string, splitChar: string) =>
+      `split(${column}, '${splitChar}')`,
   }[db];
 }
 
@@ -54,6 +56,8 @@ afterAll(async () => {
 });
 
 runtimes.runtimeMap.forEach((runtime, databaseName) => {
+  const q = runtime.getQuoter();
+
   // Issue: #1284
   it(`parenthesize output field values - ${databaseName}`, async () => {
     await expect(`
@@ -436,6 +440,29 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     });
   });
 
+  it(`nest/unnest -basic - ${databaseName}`, async () => {
+    // in a joined table when the joined is leafiest
+    //  we need to make sure we don't count rows that
+    //  don't match the join.
+    await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        group_by: state
+        aggregate: c is airport_count.sum()
+        nest: p is {
+          group_by: popular_name
+          aggregate: d is airport_count.sum()
+        }
+      } -> {
+        group_by: state, c
+        aggregate: p.d.sum()
+      }
+      `).malloyResultMatches(runtime, {
+      state: 'TX',
+      c: 1845,
+      d: 1845,
+    });
+  });
+
   it(`count at root should not use distinct key - ${databaseName}`, async () => {
     const q = await runtime
       .loadQuery(
@@ -521,7 +548,7 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
   it(`avg ignore null- ${databaseName}`, async () => {
     await expect(`
       source: one is ${databaseName}.sql("""
-        SELECT 2 as a
+        SELECT 2 as ${q`a`}
         UNION ALL SELECT 4
         UNION ALL SELECT null
       """)
@@ -729,21 +756,21 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
 
   it(`run simple sql - ${databaseName}`, async () => {
     const result = await runtime
-      .loadQuery('run: conn.sql("select 1 as one")')
+      .loadQuery(`run: conn.sql('select 1 as ${q`one`}')`)
       .run();
     expect(result.data.value[0]['one']).toBe(1);
   });
 
   it(`simple sql is exactly as written - ${databaseName}`, async () => {
     const result = await runtime
-      .loadQuery('run: conn.sql("select 1 as one")')
+      .loadQuery(`run: conn.sql('select 1 as ${q`one`}')`)
       .run();
     if (databaseName === 'postgres') {
       expect(result.sql).toBe(`WITH __stage0 AS (
-  select 1 as one)
+  select 1 as ${q`one`})
 SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     } else {
-      expect(result.sql).toBe('select 1 as one');
+      expect(result.sql).toBe(`select 1 as ${q`one`}`);
     }
     expect(result.resultExplore).not.toBeUndefined();
   });
@@ -752,7 +779,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     const result = await runtime
       .loadQuery(
         `
-        query: q is conn.sql("select 1 as one")
+        query: q is conn.sql('select 1 as ${q`one`}')
         source: s is q
         run: s -> { select: * }
       `
@@ -861,7 +888,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     }
   );
 
-  const sql1234 = `${databaseName}.sql("SELECT 1 as a, 2 as b UNION ALL SELECT 3, 4")`;
+  const sql1234 = `${databaseName}.sql('SELECT 1 as ${q`a`}, 2 as ${q`b`} UNION ALL SELECT 3, 4')`;
 
   it(`sql as source - ${databaseName}`, async () => {
     await expect(`
@@ -877,7 +904,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     const turduckenQuery = `
       run: ${databaseName}.sql("""
         SELECT
-          'something' as something,
+          'something' as SOMETHING,
           *
         FROM %{
           ${databaseName}.table('malloytest.state_facts') -> {
@@ -930,7 +957,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
   it(`regexp match- ${databaseName}`, async () => {
     await expect(`
       run: ${databaseName}.sql("""
-        SELECT 'hello mom' as a, 'cheese tastes good' as b
+        SELECT 'hello mom' as ${q`a`}, 'cheese tastes good' as ${q`b`}
         UNION ALL SELECT 'lloyd is a bozo', 'michael likes poetry'
       """) -> {
         aggregate: llo is count() {where: a ~ r'llo'}
@@ -942,21 +969,24 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
   it(`substitution precedence- ${databaseName}`, async () => {
     await expect(`
       run: ${databaseName}.sql("""
-        SELECT 5 as a, 2 as b
+        SELECT 5 as ${q`a`}, 2 as ${q`b`}
         UNION ALL SELECT 3, 4
       """) -> {
         extend: {dimension:  c is b + 4}
-        select: x is a * c
+        select: x is  a * c
       }
       `).malloyResultMatches(runtime, {x: 30});
   });
 
-  it(`array unnest - ${databaseName}`, async () => {
-    await expect(`
+  testIf(runtime.supportsNesting)(
+    `array unnest - ${databaseName}`,
+    async () => {
+      const splitFN = getSplitFunction(databaseName);
+      await expect(`
       run: ${databaseName}.sql("""
         SELECT
-          city,
-          ${getSplitFunction(databaseName)!('city', ' ')} as words
+          ${q`city`},
+          ${splitFN!(q`city`, ' ')} as ${q`words`}
         FROM ${rootDbPath(databaseName)}malloytest.aircraft
       """) -> {
         where: words.value != null
@@ -964,16 +994,20 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
         aggregate: c is count()
       }
       `).malloyResultMatches(runtime, {c: 145});
-  });
+    }
+  );
 
   // make sure we can count the total number of elements when fanning out.
-  it(`array unnest x 2 - ${databaseName}`, async () => {
-    await expect(`
+  testIf(runtime.supportsNesting)(
+    `array unnest x 2 - ${databaseName}`,
+    async () => {
+      const splitFN = getSplitFunction(databaseName);
+      await expect(`
       run: ${databaseName}.sql("""
         SELECT
-          city,
-          ${getSplitFunction(databaseName)!('city', ' ')} as words,
-          ${getSplitFunction(databaseName)!('city', 'A')} as abreak
+          ${q`city`},
+          ${splitFN!(q`city`, ' ')} as ${q`words`},
+          ${splitFN!(q`city`, 'A')} as ${q`abreak`}
         FROM ${rootDbPath(databaseName)}malloytest.aircraft
         WHERE city IS NOT null
       """) -> {
@@ -982,7 +1016,8 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
           c is words.count()
           a is abreak.count()
       }`).malloyResultMatches(runtime, {b: 3552, c: 4586, a: 6601});
-  });
+    }
+  );
 
   testIf(runtime.supportsNesting)(`nest null - ${databaseName}`, async () => {
     const result = await runtime
@@ -1120,7 +1155,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     const back = '\\';
     test('backslash quote', async () => {
       await expect(`
-        run: ${databaseName}.sql("SELECT 1") -> {
+        run: ${databaseName}.sql('SELECT 1') -> {
           select: tick is '${back}${tick}'
         }
       `).malloyResultMatches(runtime, {tick});

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

@@ -87,8 +87,10 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(orderByModel, {});
   });
 
-  it(`reserved words are quoted in turtles - ${databaseName}`, async () => {
-    await expect(`
+  testIf(runtime.supportsNesting)(
+    `reserved words are quoted in turtles - ${databaseName}`,
+    async () => {
+      await expect(`
       run: models->{
         nest: withx is {
           group_by: select is UPPER(manufacturer)
@@ -100,7 +102,8 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           fetch is withx.fetch
       }
     `).malloyResultMatches(orderByModel, {});
-  });
+    }
+  );
 
   it.skip('reserved words in structure definitions', async () => {
     await expect(`