@malloydata/malloy-tests 0.0.280 → 0.0.282

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.280",
-    "@malloydata/db-duckdb": "0.0.280",
-    "@malloydata/db-postgres": "0.0.280",
-    "@malloydata/db-snowflake": "0.0.280",
-    "@malloydata/db-trino": "0.0.280",
-    "@malloydata/malloy": "0.0.280",
-    "@malloydata/malloy-tag": "0.0.280",
-    "@malloydata/render": "0.0.280",
+    "@malloydata/db-bigquery": "0.0.282",
+    "@malloydata/db-duckdb": "0.0.282",
+    "@malloydata/db-postgres": "0.0.282",
+    "@malloydata/db-snowflake": "0.0.282",
+    "@malloydata/db-trino": "0.0.282",
+    "@malloydata/malloy": "0.0.282",
+    "@malloydata/malloy-tag": "0.0.282",
+    "@malloydata/render": "0.0.282",
     "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.280"
+  "version": "0.0.282"
 }

package/src/core/parameters.spec.ts

@@ -192,6 +192,32 @@ describe('parameters', () => {
       `
     ).malloyResultMatches(runtime, {param_value: 11});
   });
+  it('default value modified through extension propagates', async () => {
+    await expect(
+      `
+        ##! experimental.parameters
+        source: ab_new(param::number is 10) is duckdb.table('malloytest.state_facts') extend {
+          dimension: param_value is param
+        }
+        source: ab_new_new(param::number is 11) is ab_new(param is param + 1) extend {}
+        run: ab_new_new -> { group_by: param_value }
+      `
+    ).malloyResultMatches(runtime, {param_value: 12});
+  });
+  // Fix this with namespaces!
+  it.skip('default value modified through extension twice propagates', async () => {
+    await expect(
+      `
+        ##! experimental.parameters
+        source: ab_plus_0(param::number is 0) is duckdb.table('malloytest.state_facts') extend {
+          dimension: param_value is param
+        }
+        source: ab_plus_one(param::number is 0) is ab_plus_0(param is param + 1) extend {}
+        source: ab_plus_two(param::number is 0) is ab_plus_one(param is param + 1) extend {}
+        run: ab_plus_two -> { group_by: param_value }
+      `
+    ).malloyResultMatches(runtime, {param_value: 2});
+  });
   it('use parameter in nested view', async () => {
     await expect(
       `

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

@@ -321,8 +321,7 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
   });
 
-  // mysql doesn't have true booleans ...
-  const testBoolean = !db.dialect.booleanAsNumbers;
+  const testBoolean = db.dialect.booleanType === 'supported';
   describe('boolean filter expressions', () => {
     const facts = db.loadModel(`
       source: facts is ${dbName}.sql("""

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

@@ -24,11 +24,7 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import '../../util/db-jest-matchers';
-import {
-  booleanResult,
-  databasesFromEnvironmentOr,
-  mkSqlEqWith,
-} from '../../util';
+import {databasesFromEnvironmentOr, mkSqlEqWith} from '../../util';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
@@ -534,8 +530,8 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           group_by: boolean_2 is sql_boolean("\${engines} = 2")
         }
   `).malloyResultMatches(expressionModel, {
-        boolean_1: booleanResult(true, databaseName),
-        boolean_2: booleanResult(false, databaseName),
+        boolean_1: runtime.dialect.resultBoolean(true),
+        boolean_2: runtime.dialect.resultBoolean(false),
       });
     });
 
@@ -591,54 +587,60 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
       });
     });
 
-    describe('[not yet supported]', () => {
-      // See ${...} documentation for lookml here for guidance on remaining work:
-      // https://cloud.google.com/looker/docs/reference/param-field-sql#sql_for_dimensions
-      it('${view_name.dimension_name} - one path', async () => {
-        const query = await expressionModel.loadQuery(
-          `
-          ##! experimental { sql_functions }
-          source: a is ${databaseName}.table('malloytest.aircraft_models') extend { where: aircraft_model_code ? '0270202' }
+    it('${view_name.dimension_name} - one path', async () => {
+      await expect(`
+        ##! experimental { sql_functions }
+        source: a0 is ${databaseName}.table('malloytest.aircraft_models')
+        source: a is ${databaseName}.table('malloytest.aircraft_models') extend {
+          where: aircraft_model_code ? '0270202'
+          join_one: a0 on aircraft_model_code = a0.aircraft_model_code
+        }
 
-          run: a -> {
-              group_by: string_1 is sql_string("UPPER(\${a.manufacturer})")
-            }
-          `
-        );
-        await expect(query.run()).rejects.toThrow(
-          "'.' paths are not yet supported in sql interpolations, found ${a.manufacturer}"
-        );
+        run: a -> {
+          group_by: string_1 is sql_string("UPPER(\${a0.manufacturer})")
+        }
+      `).malloyResultMatches(expressionModel, {
+        string_1: 'AHRENS AIRCRAFT CORP.',
       });
+    });
 
-      it('${view_name.dimension_name} - multiple paths', async () => {
-        const query = await expressionModel.loadQuery(
-          `
-          ##! experimental { sql_functions }
-          source: a is ${databaseName}.table('malloytest.aircraft_models') extend { where: aircraft_model_code ? '0270202' }
+    it('${view_name.dimension_name} - multiple paths', async () => {
+      await expect(`
+        ##! experimental { sql_functions }
+        source: a0 is ${databaseName}.table('malloytest.aircraft_models')
+        source: a is ${databaseName}.table('malloytest.aircraft_models') extend {
+          where: aircraft_model_code ? '0270202'
+          join_one: a0 on aircraft_model_code = a0.aircraft_model_code
+        }
 
-          run: a -> {
-              group_by: number_1 is sql_number("\${a.seats} * \${a.seats} + \${a.total_seats}")
-            }
-          `
-        );
-        await expect(query.run()).rejects.toThrow(
-          "'.' paths are not yet supported in sql interpolations, found (${a.seats}, ${a.seats}, ${a.total_seats})"
-        );
+        run: a -> {
+          group_by: number_1 is sql_number("\${seats} + \${a0.seats}")
+        }
+      `).malloyResultMatches(expressionModel, {
+        number_1: 58,
       });
+    });
 
-      it('${view_name.SQL_TABLE_NAME}', async () => {
+    describe('[not yet supported]', () => {
+      // See ${...} documentation for lookml here for guidance on remaining work:
+      // https://cloud.google.com/looker/docs/reference/param-field-sql#sql_for_dimensions
+      it('${SQL_TABLE_NAME}', async () => {
         const query = await expressionModel.loadQuery(
           `
           ##! experimental { sql_functions }
-          source: a is ${databaseName}.table('malloytest.aircraft_models') extend { where: aircraft_model_code ? '0270202' }
+          source: a0 is ${databaseName}.table('malloytest.aircraft_models')
+          source: a is ${databaseName}.table('malloytest.aircraft_models') extend {
+            where: aircraft_model_code ? '0270202'
+            join_one: a0 on aircraft_model_code = a0.aircraft_model_code
+          }
 
           run: a -> {
-              group_by: number_1 is sql_number("\${a.SQL_TABLE_NAME}.seats")
-            }
+            group_by: number_1 is sql_number("\${a0.SQL_TABLE_NAME}.seats")
+          }
           `
         );
         await expect(query.run()).rejects.toThrow(
-          "'.' paths are not yet supported in sql interpolations, found ${a.SQL_TABLE_NAME}"
+          "Invalid interpolation: 'SQL_TABLE_NAME' is not defined"
         );
       });
     });
@@ -861,57 +863,59 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     });
   });
 
-  describe('null safe booleans', () => {
-    const nulls = `${databaseName}.sql("""
-      SELECT
-        0 as ${q`n`},
-        1 as ${q`x`}, 2 as ${q`y`},
-        'a' as ${q`a`}, 'b' as ${q`b`},
-        (1 = 1) as ${q`tf`}
-      UNION ALL SELECT
-        5,
-        null, null, null, null, null
-    """) extend { where: n > 0 }`;
-    const is_true = databaseName === 'mysql' ? 1 : true;
+  if (runtime.dialect.booleanType !== 'none') {
+    describe('null safe booleans', () => {
+      const nulls = `${databaseName}.sql("""
+        SELECT
+          0 as ${q`n`},
+          1 as ${q`x`}, 2 as ${q`y`},
+          'a' as ${q`a`}, 'b' as ${q`b`},
+          (1=1) as ${q`tf`}
+        UNION ALL SELECT
+          5,
+          null, null, null, null, null
+      """) extend { where: n > 0 }`;
+      const is_true = runtime.dialect.resultBoolean(true);
 
-    it('select boolean', async () => {
-      await expect(`run: ${nulls} -> {
-        select:
-          null_boolean is tf
-      }`).malloyResultMatches(runtime, {null_boolean: null});
-    });
-    it('not boolean', async () => {
-      await expect(`run: ${nulls} -> {
-        select:
-          not_null_boolean is not tf
-      }`).malloyResultMatches(runtime, {not_null_boolean: is_true});
-    });
-    it('numeric != non-null to null', async () => {
-      await expect(
-        `run: ${nulls} -> { select: val_ne_null is x != 9 }`
-      ).malloyResultMatches(runtime, {val_ne_null: is_true});
-    });
-    it('string !~ non-null to null', async () => {
-      await expect(
-        `run: ${nulls} -> { select: val_ne_null is a !~ 'z' }`
-      ).malloyResultMatches(runtime, {val_ne_null: is_true});
-    });
-    it('regex !~ non-null to null', async () => {
-      await expect(
-        `run: ${nulls} -> { select: val_ne_null is a !~ r'z' }`
-      ).malloyResultMatches(runtime, {val_ne_null: is_true});
-    });
-    it('numeric != null-to-null', async () => {
-      await expect(
-        `run: ${nulls} -> { select: null_ne_null is x != y }`
-      ).malloyResultMatches(runtime, {null_ne_null: is_true});
-    });
-    it('string !~ null-to-null', async () => {
-      await expect(
-        `run: ${nulls} -> { select: null_ne_null is a !~ b }`
-      ).malloyResultMatches(runtime, {null_ne_null: is_true});
+      it('select boolean', async () => {
+        await expect(`run: ${nulls} -> {
+          select:
+            null_boolean is tf
+        }`).malloyResultMatches(runtime, {null_boolean: null});
+      });
+      it('not boolean', async () => {
+        await expect(`run: ${nulls} -> {
+          select:
+            not_null_boolean is not tf
+        }`).malloyResultMatches(runtime, {not_null_boolean: is_true});
+      });
+      it('numeric != non-null to null', async () => {
+        await expect(
+          `run: ${nulls} -> { select: val_ne_null is x != 9 }`
+        ).malloyResultMatches(runtime, {val_ne_null: is_true});
+      });
+      it('string !~ non-null to null', async () => {
+        await expect(
+          `run: ${nulls} -> { select: val_ne_null is a !~ 'z' }`
+        ).malloyResultMatches(runtime, {val_ne_null: is_true});
+      });
+      it('regex !~ non-null to null', async () => {
+        await expect(
+          `run: ${nulls} -> { select: val_ne_null is a !~ r'z' }`
+        ).malloyResultMatches(runtime, {val_ne_null: is_true});
+      });
+      it('numeric != null-to-null', async () => {
+        await expect(
+          `run: ${nulls} -> { select: null_ne_null is x != y }`
+        ).malloyResultMatches(runtime, {null_ne_null: is_true});
+      });
+      it('string !~ null-to-null', async () => {
+        await expect(
+          `run: ${nulls} -> { select: null_ne_null is a !~ b }`
+        ).malloyResultMatches(runtime, {null_ne_null: is_true});
+      });
     });
-  });
+  }
 
   test('dimension expressions expanded with parens properly', async () => {
     await expect(
@@ -923,8 +927,8 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           paren is    false and (fot)
       }`
     ).malloyResultMatches(runtime, {
-      paren: booleanResult(false, databaseName),
-      no_paren: booleanResult(false, databaseName),
+      paren: runtime.dialect.resultBoolean(false),
+      no_paren: runtime.dialect.resultBoolean(false),
     });
   });
 });

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

@@ -23,7 +23,7 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {booleanResult, brokenIn, databasesFromEnvironmentOr} from '../../util';
+import {brokenIn, databasesFromEnvironmentOr} from '../../util';
 import '../../util/db-jest-matchers';
 import type * as malloy from '@malloydata/malloy';
 
@@ -68,6 +68,8 @@ runtimes.runtimeMap.forEach((runtime, databaseName) =>
 expressionModels.forEach((x, databaseName) => {
   const expressionModel = x.expressionModel;
   const runtime = x.runtime;
+  const dbTrue = runtime.dialect.resultBoolean(true);
+  const dbFalse = runtime.dialect.resultBoolean(false);
   const funcTestGeneral = async (
     expr: string,
     type: 'group_by' | 'aggregate',
@@ -85,8 +87,12 @@ expressionModels.forEach((x, databaseName) => {
     };
 
     if (expected.success !== undefined) {
+      const expectedSuccess =
+        typeof expected.success === 'boolean'
+          ? runtime.dialect.resultBoolean(expected.success)
+          : expected.success;
       const result = await run();
-      expect(result.data.path(0, 'f').value).toBe(expected.success);
+      expect(result.data.path(0, 'f').value).toBe(expectedSuccess);
     } else {
       expect(run).rejects.toThrowError(expected.error);
     }
@@ -623,6 +629,7 @@ expressionModels.forEach((x, databaseName) => {
       const result = await expressionModel
         .loadQuery(
           `
+          # test.debug
           run: state_facts -> {
             group_by: state
             calculate: lag_val is lag(@2011-11-11 11:11:11, 1, now).year = now.year
@@ -630,10 +637,10 @@ expressionModels.forEach((x, databaseName) => {
         )
         .run();
       expect(result.data.path(0, 'lag_val').value).toBe(
-        booleanResult(true, databaseName)
+        runtime.dialect.resultBoolean(true)
       );
       expect(result.data.path(1, 'lag_val').value).toBe(
-        booleanResult(false, databaseName)
+        runtime.dialect.resultBoolean(false)
       );
     });
   });
@@ -856,18 +863,18 @@ expressionModels.forEach((x, databaseName) => {
       : "'+inf'::number";
     it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        [`is_inf(${inf})`, true],
-        ['is_inf(100)', false],
-        ['is_inf(null)', false]
+        [`is_inf(${inf})`, dbTrue],
+        ['is_inf(100)', dbFalse],
+        ['is_inf(null)', dbFalse]
       );
     });
   });
   describe('is_nan', () => {
     it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ["is_nan('NaN'::number)", true],
-        ['is_nan(100)', false],
-        ['is_nan(null)', false]
+        ["is_nan('NaN'::number)", dbTrue],
+        ['is_nan(100)', dbFalse],
+        ['is_nan(null)', dbFalse]
       );
     });
   });
@@ -877,11 +884,11 @@ expressionModels.forEach((x, databaseName) => {
         ['greatest(1, 10, -100)', 10],
         [
           'greatest(@2003, @2004, @1994) = @2004',
-          booleanResult(true, databaseName),
+          runtime.dialect.resultBoolean(true),
         ],
         [
           'greatest(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:59:00',
-          booleanResult(true, databaseName),
+          runtime.dialect.resultBoolean(true),
         ],
         ["greatest('a', 'b')", 'b'],
         ['greatest(1, null, 0)', null],
@@ -895,11 +902,11 @@ expressionModels.forEach((x, databaseName) => {
         ['least(1, 10, -100)', -100],
         [
           'least(@2003, @2004, @1994) = @1994',
-          booleanResult(true, databaseName),
+          runtime.dialect.resultBoolean(true),
         ],
         [
           'least(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:58:00',
-          booleanResult(true, databaseName),
+          runtime.dialect.resultBoolean(true),
         ],
         ["least('a', 'b')", 'a'],
         ['least(1, null, 0)', null],
@@ -931,14 +938,17 @@ expressionModels.forEach((x, databaseName) => {
       await funcTestMultiple(
         [
           "starts_with('hello world', 'hello')",
-          booleanResult(true, databaseName),
+          runtime.dialect.resultBoolean(true),
         ],
         [
           "starts_with('hello world', 'world')",
-          booleanResult(false, databaseName),
+          runtime.dialect.resultBoolean(false),
         ],
-        ["starts_with(null, 'world')", booleanResult(false, databaseName)],
-        ["starts_with('hello world', null)", booleanResult(false, databaseName)]
+        ["starts_with(null, 'world')", runtime.dialect.resultBoolean(false)],
+        [
+          "starts_with('hello world', null)",
+          runtime.dialect.resultBoolean(false),
+        ]
       );
     });
   });
@@ -947,14 +957,14 @@ expressionModels.forEach((x, databaseName) => {
       await funcTestMultiple(
         [
           "ends_with('hello world', 'world')",
-          booleanResult(true, databaseName),
+          runtime.dialect.resultBoolean(true),
         ],
         [
           "ends_with('hello world', 'hello')",
-          booleanResult(false, databaseName),
+          runtime.dialect.resultBoolean(false),
         ],
-        ["ends_with(null, 'world')", booleanResult(false, databaseName)],
-        ["ends_with('hello world', null)", booleanResult(false, databaseName)]
+        ["ends_with(null, 'world')", runtime.dialect.resultBoolean(false)],
+        ["ends_with('hello world', null)", runtime.dialect.resultBoolean(false)]
       );
     });
   });
@@ -999,14 +1009,14 @@ expressionModels.forEach((x, databaseName) => {
       // There are around a billion values that rand() can be, so if this
       // test fails, most likely something is broken. Otherwise, you're the lucky
       // one in a billion!
-      await funcTest('rand() = rand()', booleanResult(false, databaseName));
+      await funcTest('rand() = rand()', runtime.dialect.resultBoolean(false));
     });
   });
   describe('pi', () => {
     it(`is pi - ${databaseName}`, async () => {
       await funcTest(
         'abs(pi() - 3.141592653589793) < 0.0000000000001',
-        booleanResult(true, databaseName)
+        runtime.dialect.resultBoolean(true)
       );
     });
   });
@@ -1169,8 +1179,8 @@ expressionModels.forEach((x, databaseName) => {
             aggregate: also_passes is abs(count_approx(airport_count)-count(airport_count))/count(airport_count) < 0.3
           }
           `).malloyResultMatches(runtime, {
-        'passes': booleanResult(true, databaseName),
-        'also_passes': booleanResult(true, databaseName),
+        'passes': runtime.dialect.resultBoolean(true),
+        'also_passes': runtime.dialect.resultBoolean(true),
       });
     });
     test.when(supported)('works with fanout', async () => {
@@ -1182,7 +1192,7 @@ expressionModels.forEach((x, databaseName) => {
         run: state_facts_fanout -> {
           aggregate: x is state_facts.state.count_approx() > 0
         }
-      `).malloyResultMatches(runtime, {x: booleanResult(true, databaseName)});
+      `).malloyResultMatches(runtime, {x: runtime.dialect.resultBoolean(true)});
     });
   });
   describe('last_value', () => {
@@ -1368,7 +1378,7 @@ expressionModels.forEach((x, databaseName) => {
       it.when(isDuckdb)('to_timestamp', async () => {
         await funcTest(
           'to_timestamp(1725555835) = @2024-09-05 17:03:55',
-          booleanResult(true, databaseName)
+          runtime.dialect.resultBoolean(true)
         );
       });
       it.when(isDuckdb)('list_extract', async () => {
@@ -1384,7 +1394,7 @@ expressionModels.forEach((x, databaseName) => {
       trino('from_unixtime', async () => {
         await funcTest(
           'from_unixtime(1725555835) = @2024-09-05 17:03:55',
-          booleanResult(true, databaseName)
+          runtime.dialect.resultBoolean(true)
         );
       });
     });
@@ -1796,6 +1806,42 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         },
       ]);
     });
+    // TODO remove the need for the `##! unsafe_complex_select_query` compiler flag
+    it('can be used in a select in a composite source', async () => {
+      await expect(`
+        ##! experimental { function_order_by partition_by composite_sources }
+        ##! unsafe_complex_select_query
+        source: state_facts_composite is compose(state_facts, state_facts)
+        run: state_facts_composite -> {
+          select: state, births, popular_name
+          calculate: prev_births_by_name is lag(births) {
+            partition_by: popular_name
+            order_by: births desc
+          }
+          order_by: births desc
+          limit: 3
+        }
+      `).malloyResultMatches(expressionModel, [
+        {
+          state: 'CA',
+          births: 28810563,
+          popular_name: 'Isabella',
+          prev_births_by_name: null,
+        },
+        {
+          state: 'NY',
+          births: 23694136,
+          popular_name: 'Isabella',
+          prev_births_by_name: 28810563,
+        },
+        {
+          state: 'TX',
+          births: 21467359,
+          popular_name: 'Isabella',
+          prev_births_by_name: 23694136,
+        },
+      ]);
+    });
   });
 });
 

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

@@ -23,7 +23,7 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {booleanResult, databasesFromEnvironmentOr} from '../../util';
+import {databasesFromEnvironmentOr} from '../../util';
 import '../../util/db-jest-matchers';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
@@ -45,7 +45,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         aggregate: model_count is count()
       }
     `).malloyResultMatches(orderByModel, {
-      big: booleanResult(false, databaseName),
+      big: runtime.dialect.resultBoolean(false),
       model_count: 58451,
     });
   });
@@ -62,7 +62,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         aggregate: model_count is model_count.sum()
       }
     `).malloyResultMatches(orderByModel, {
-      big: booleanResult(false, databaseName),
+      big: runtime.dialect.resultBoolean(false),
       model_count: 58500,
     });
   });

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import {RuntimeList} from '../../runtimes';
+import '../../util/db-jest-matchers';
+import {describeIfDatabaseAvailable} from '../../util';
+
+const [describe, databases] = describeIfDatabaseAvailable(['bigquery']);
+const runtimes = new RuntimeList(databases);
+
+afterAll(async () => {
+  await runtimes.closeAll();
+});
+
+describe('dialect specific function tests for standardsql', () => {
+  const runtime = runtimes.runtimeMap.get('bigquery');
+
+  it('runs the max_by function - bigquery', async () => {
+    await expect(`run: bigquery.sql("""
+              SELECT 1 as y, 55 as x
+    UNION ALL SELECT 50 as y, 22 as x
+    UNION ALL SELECT 100 as y, 1 as x
+    """) -> {
+    aggregate:
+      m1 is max_by(x, y)
+      m2 is max_by(y, x)
+    }`).malloyResultMatches(runtime!, {m1: 1, m2: 1});
+  });
+
+  it('runs the max_by function by grouping - bigquery', async () => {
+    await expect(`run: bigquery.sql("""
+              SELECT 1 as y, 55 as x, 10 as z
+    UNION ALL SELECT 50 as y, 22 as x, 10 as z
+    UNION ALL SELECT 1 as y, 10 as x, 20 as z
+    UNION ALL SELECT 100 as y, 15 as x, 20 as z
+    """) -> {
+    group_by:
+      z
+    aggregate:
+      m1 is max_by(x, y)
+      m2 is max_by(y, x)
+    }`).malloyResultMatches(runtime!, [
+      {z: 10, m1: 22, m2: 1},
+      {z: 20, m1: 15, m2: 100},
+    ]);
+  });
+
+  it('runs the min_by function - bigquery', async () => {
+    await expect(`run: bigquery.sql("""
+              SELECT 1 as y, 55 as x
+    UNION ALL SELECT 50 as y, 22 as x
+    UNION ALL SELECT 100 as y, 1 as x
+    """) -> {
+    aggregate:
+      m1 is min_by(x, y)
+      m2 is min_by(y, x)
+    }`).malloyResultMatches(runtime!, {m1: 55, m2: 100});
+  });
+});

package/src/databases/presto-trino/presto-trino.spec.ts

@@ -256,6 +256,24 @@ describe.each(runtimes.runtimeList)(
       }`).malloyResultMatches(runtime, {m1: 1, m2: 1});
     });
 
+    it(`runs the max_by function by grouping - ${databaseName}`, async () => {
+      await expect(`run: ${databaseName}.sql("""
+                SELECT 1 as y, 55 as x, 10 as z
+      UNION ALL SELECT 50 as y, 22 as x, 10 as z
+      UNION ALL SELECT 1 as y, 10 as x, 20 as z
+      UNION ALL SELECT 100 as y, 15 as x, 20 as z
+      """) -> {
+      group_by:
+        z
+      aggregate:
+        m1 is max_by(x, y)
+        m2 is max_by(y, x)
+      }`).malloyResultMatches(runtime, [
+        {z: 10, m1: 22, m2: 1},
+        {z: 20, m1: 15, m2: 100},
+      ]);
+    });
+
     it(`runs the min_by function - ${databaseName}`, async () => {
       await expect(`run: ${databaseName}.sql("""
                 SELECT 1 as y, 55 as x

package/src/render/drill.spec.ts

@@ -13,51 +13,103 @@ const duckdb = runtimeFor('duckdb');
 
 describe('drill query', () => {
   const model = `
-      source: carriers is duckdb.table('test/data/duckdb/carriers.parquet') extend {
-        primary_key: code
-        measure: carrier_count is count()
+    ##! experimental { drill parameters }
+    source: carriers is duckdb.table('test/data/duckdb/carriers.parquet') extend {
+      primary_key: code
+      measure: carrier_count is count()
+    }
+    source: flights is duckdb.table('test/data/duckdb/flights/part.*.parquet') extend {
+      primary_key: id2
+      // rename some fields as from their physical names
+      rename: \`Origin Code\` is origin
+      measure: flight_count is count()
+      join_one: carriers with carrier
+
+      view: top_carriers is {
+        group_by: carriers.nickname
+        aggregate:
+          flight_count
+        limit: 1
+      }
+
+      view: over_time is {
+        group_by: dep_month is month(dep_time)
+        aggregate: flight_count
+        limit: 1
       }
-      source: flights is duckdb.table('test/data/duckdb/flights/part.*.parquet') extend {
-        primary_key: id2
-        // rename some fields as from their physical names
-        rename: \`Origin Code\` is origin
-        measure: flight_count is count()
-        join_one: carriers with carrier
-
-        view: top_carriers is {
-          group_by: carriers.nickname
-          aggregate:
-            flight_count
-          limit: 1
-        }
-
-        view: over_time is {
-          group_by: dep_month is month(dep_time)
-          aggregate: flight_count
-          limit: 1
-        }
-
-        view: by_origin is {
-          group_by: \`Origin Code\`
-          aggregate: flight_count
-          limit: 1
-        }
-
-        view: no_filter is {
-          aggregate: flight_count
-        }
-
-        view: cool_carriers is {
-          where: carrier = 'AA' or carrier = 'WN'
-          group_by: \`Origin Code\`
-        }
+
+      view: by_origin is {
+        group_by: \`Origin Code\`
+        aggregate: flight_count
+        limit: 1
+      }
+
+      view: no_filter is {
+        aggregate: flight_count
       }
-      query: top_carriers is flights -> top_carriers
-      query: over_time is flights -> over_time
-      query: by_origin is flights -> by_origin
-      query: no_filter is flights -> no_filter
-      query: cool_carriers is flights -> cool_carriers
-    `;
+
+      view: cool_carriers is {
+        where: carrier = 'AA' or carrier = 'WN'
+        group_by: \`Origin Code\`
+      }
+
+      view: negative_value is {
+        group_by: negative_one is -1
+      }
+    }
+    source: flights_with_parameters(
+      number_param is 1,
+      string_param is 'foo',
+      boolean_param is true,
+      date_param is @2000,
+      timestamp_param is @2004-01-01 10:00,
+      filter_expression_param::filter<number> is f'> 3'
+    ) is flights
+    source: flights_with_timestamp_param(
+      timestamp_param is @2004-01-01 10:00
+    ) is flights
+    query: top_carriers is flights -> top_carriers
+    query: over_time is flights -> over_time
+    query: by_origin is flights -> by_origin
+    query: no_filter is flights -> no_filter
+    query: cool_carriers is flights -> cool_carriers
+    query: negative_value is flights -> negative_value
+    query: literal_with_nested_view_stable is flights -> {
+      where:
+        \`Origin Code\` ~ f'SFO, ORD',
+        destination = 'SJC'
+      group_by: carrier
+      nest: cool_carriers
+    }
+    query: literal_with_nested_view_unstable is flights -> {
+      where:
+        carriers.nickname ~ '%A%',
+        distance > 100,
+        month(dep_time) = 7
+      group_by: carrier
+      nest: cool_carriers
+      having: flight_count > 100
+    }
+    query: already_has_some_drills is flights -> {
+      drill:
+        \`Origin Code\` ~ f\`SFO, ORD\`,
+        destination = "SJC",
+        carrier = "AA",
+        cool_carriers.\`Origin Code\` = "ORD"
+    } + over_time
+    query: source_has_parameters is flights_with_parameters(
+      number_param is 1,
+      string_param is 'foo',
+      boolean_param is true,
+      date_param is @2000,
+      timestamp_param is @2004-01-01 10:00,
+      filter_expression_param is f'> 3'
+    ) -> top_carriers
+    query: source_has_timezone_param is flights_with_timestamp_param(
+      timestamp_param is @2004-01-01 10:00:00[America/Los_Angeles]
+    ) -> top_carriers
+    query: only_default_params is flights_with_parameters -> top_carriers
+  `;
 
   beforeEach(() => {
     jest.spyOn(console, 'warn').mockImplementation(() => {});
@@ -70,12 +122,9 @@ describe('drill query', () => {
       .run();
     const table = getDataTree(API.util.wrapResult(result));
     const expDrillQuery =
-      'run: flights -> {\n' +
-      '  where:\n' +
-      "    carriers.nickname = 'Southwest'\n" +
-      '} + { select: * }';
+      'run: flights -> { drill: top_carriers.nickname = "Southwest" } + { select: * }';
     const row = table.rows[0];
-    expect(row.getDrillQuery()).toEqual(expDrillQuery);
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
   });
 
   test('can handle expression fields', async () => {
@@ -85,10 +134,9 @@ describe('drill query', () => {
       .run();
     const table = getDataTree(API.util.wrapResult(result));
     const expDrillQuery =
-      'run: flights -> {\n  where:\n    ' +
-      'month(dep_time) = 8\n} + { select: * }';
+      'run: flights -> { drill: over_time.dep_month = 8 } + { select: * }';
     const row = table.rows[0];
-    expect(row.getDrillQuery()).toEqual(expDrillQuery);
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
   });
 
   test('can handle renamed and multi-word field names', async () => {
@@ -98,10 +146,9 @@ describe('drill query', () => {
       .run();
     const table = getDataTree(API.util.wrapResult(result));
     const expDrillQuery =
-      'run: flights -> {\n  where:\n    ' +
-      "`Origin Code` = 'ATL'\n} + { select: * }";
+      'run: flights -> { drill: by_origin.`Origin Code` = "ATL" } + { select: * }';
     const row = table.rows[0];
-    expect(row.getDrillQuery()).toEqual(expDrillQuery);
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
   });
 
   test('can handle queries with no filter', async () => {
@@ -112,7 +159,7 @@ describe('drill query', () => {
     const table = getDataTree(API.util.wrapResult(result));
     const expDrillQuery = 'run: flights -> { select: * }';
     const row = table.rows[0];
-    expect(row.getDrillQuery()).toEqual(expDrillQuery);
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
   });
 
   test('can handle view filters', async () => {
@@ -122,12 +169,170 @@ describe('drill query', () => {
       .run();
     const table = getDataTree(API.util.wrapResult(result));
     const expDrillQuery =
-      'run: flights -> {\n' +
-      '  where:\n' +
-      "    carrier = 'AA' or carrier = 'WN',\n" +
-      "    `Origin Code` = 'ABQ'\n" +
-      '} + { select: * }';
+      'run: flights -> { drill: cool_carriers.`Origin Code` = "ABQ" } + { select: * }';
     const row = table.rows[0];
-    expect(row.getDrillQuery()).toEqual(expDrillQuery);
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+  });
+
+  test('can handle filters that are not in a view (not stable compatible)', async () => {
+    const result = await duckdb
+      .loadModel(model)
+      .loadQueryByName('literal_with_nested_view_unstable')
+      .run();
+    const table = getDataTree(API.util.wrapResult(result));
+    const expDrillQuery = `run: flights -> {
+  drill:
+    carriers.nickname ~ '%A%',
+    distance > 100,
+    month(dep_time) = 7,
+    carrier = "AA"
+} + { select: * }`;
+    const row1 = table.rows[0];
+    expect(row1.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    const nest = row1.column('cool_carriers');
+    expect(nest.isRepeatedRecord()).toBe(true);
+    if (nest.isRepeatedRecord()) {
+      const expDrillQuery = `run: flights -> {
+  drill:
+    carriers.nickname ~ '%A%',
+    distance > 100,
+    month(dep_time) = 7,
+    carrier = "AA",
+    cool_carriers.\`Origin Code\` = "ABQ"
+} + { select: * }`;
+      const row = nest.rows[0];
+      expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    }
+  });
+
+  test('can handle filters that are not in a view (stable compatible)', async () => {
+    const result = await duckdb
+      .loadModel(model)
+      .loadQueryByName('literal_with_nested_view_stable')
+      .run();
+    const table = getDataTree(API.util.wrapResult(result));
+    const expDrillQuery = `run: flights -> {
+  drill:
+    \`Origin Code\` ~ f\`SFO, ORD\`,
+    destination = "SJC",
+    carrier = "AA"
+} + { select: * }`;
+    const row1 = table.rows[0];
+    expect(row1.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    const nest = row1.column('cool_carriers');
+    expect(nest.isRepeatedRecord()).toBe(true);
+    if (nest.isRepeatedRecord()) {
+      const expDrillQuery = `run: flights -> {
+  drill:
+    \`Origin Code\` ~ f\`SFO, ORD\`,
+    destination = "SJC",
+    carrier = "AA",
+    cool_carriers.\`Origin Code\` = "ORD"
+} + { select: * }`;
+      const row = nest.rows[0];
+      expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    }
+  });
+
+  test('can handle drills that are already there', async () => {
+    const result = await duckdb
+      .loadModel(model)
+      .loadQueryByName('already_has_some_drills')
+      .run();
+    const table = getDataTree(API.util.wrapResult(result));
+    const expDrillQuery = `run: flights -> {
+  drill:
+    \`Origin Code\` ~ f\`SFO, ORD\`,
+    destination = "SJC",
+    carrier = "AA",
+    cool_carriers.\`Origin Code\` = "ORD",
+    over_time.dep_month = 5
+} + { select: * }`;
+    const row = table.rows[0];
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+  });
+
+  test('negative number can be used in stable query filter', async () => {
+    const result = await duckdb
+      .loadModel(model)
+      .loadQueryByName('negative_value')
+      .run();
+    const table = getDataTree(API.util.wrapResult(result));
+    const expDrillQuery =
+      'run: flights -> { drill: negative_value.negative_one = -1 } + { select: * }';
+    const row = table.rows[0];
+    expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    expect(row.getStableDrillQuery()).toMatchObject({
+      definition: {
+        kind: 'arrow',
+        source: {
+          kind: 'source_reference',
+          name: 'flights',
+        },
+        view: {
+          kind: 'segment',
+          operations: [
+            {
+              filter: {
+                field_reference: {
+                  name: 'negative_one',
+                  path: ['negative_value'],
+                },
+                kind: 'literal_equality',
+                value: {
+                  kind: 'number_literal',
+                  number_value: -1,
+                },
+              },
+              kind: 'drill',
+            },
+          ],
+        },
+      },
+    });
+  });
+
+  describe('source parameters', () => {
+    test('can handle source parameters', async () => {
+      const result = await duckdb
+        .loadModel(model)
+        .loadQueryByName('source_has_parameters')
+        .run();
+      const table = getDataTree(API.util.wrapResult(result));
+      const expDrillQuery = `run: flights_with_parameters(
+  number_param is 1,
+  string_param is "foo",
+  boolean_param is true,
+  date_param is @2000,
+  timestamp_param is @2004-01-01 10:00,
+  filter_expression_param is f\`> 3\`
+) -> { drill: top_carriers.nickname = "Southwest" } + { select: * }`;
+      const row = table.rows[0];
+      expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    });
+
+    test('can handle timezone in source parameter', async () => {
+      const result = await duckdb
+        .loadModel(model)
+        .loadQueryByName('source_has_timezone_param')
+        .run();
+      const table = getDataTree(API.util.wrapResult(result));
+      const expDrillQuery =
+        'run: flights_with_timestamp_param(timestamp_param is @2004-01-01 10:00:00[America/Los_Angeles]) -> { drill: top_carriers.nickname = "Southwest" } + { select: * }';
+      const row = table.rows[0];
+      expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    });
+
+    test('default_params_are_not_included', async () => {
+      const result = await duckdb
+        .loadModel(model)
+        .loadQueryByName('only_default_params')
+        .run();
+      const table = getDataTree(API.util.wrapResult(result));
+      const expDrillQuery =
+        'run: flights_with_parameters -> { drill: top_carriers.nickname = "Southwest" } + { select: * }';
+      const row = table.rows[0];
+      expect(row.getDrillQueryMalloy()).toEqual(expDrillQuery);
+    });
   });
 });

package/src/util/index.ts

@@ -29,6 +29,7 @@ import type {
   Result,
   Runtime,
   Expr,
+  SingleConnectionRuntime,
 } from '@malloydata/malloy';
 import {composeSQLExpr} from '@malloydata/malloy';
 export * from '@malloydata/malloy/test';
@@ -102,7 +103,7 @@ function sqlSafe(str: string): string {
 }
 
 export function mkSqlEqWith(
-  runtime: Runtime,
+  runtime: SingleConnectionRuntime,
   cName: string,
   initV?: InitValues
 ) {
@@ -198,19 +199,3 @@ export async function runQuery(runtime: Runtime, querySrc: string) {
 
   return result;
 }
-
-export function booleanResult(value: boolean, dbName: string) {
-  if (dbName === 'mysql') {
-    return value ? 1 : 0;
-  } else {
-    return value;
-  }
-}
-
-export function booleanCode(value: boolean, dbName: string) {
-  if (dbName === 'mysql') {
-    return value ? '1' : '0';
-  } else {
-    return value ? 'true' : 'false';
-  }
-}