@malloydata/malloy-tests 0.0.434 → 0.0.436

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

@@ -697,6 +697,13 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
         run: range + { where: t ~ f'2001' }
       `).toMatchRows(range, inRange);
     });
+    test('date in month, in a query time zone east of UTC', async () => {
+      // Midnight starting a month in Tokyo is still the previous day in UTC
+      const range = mkDateRange('2001-01-01', '2001-02-01');
+      await expect(`
+        run: range + { timezone: 'Asia/Tokyo'; where: t ~ f'2001-01' }
+      `).toMatchRows(range, inRange);
+    });
     test('2 days ago', async () => {
       nowIs('2001-01-15 12:00:00');
       const rangeQuery = mkRangeQuery(

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

@@ -79,11 +79,13 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     `).toMatchResult(testModel, {fieldName: 'one', weight: 51});
   });
 
-  // bigquery doesn't support row count based sampling.
+  // bigquery doesn't support row count based sampling; sqlserver's TABLESAMPLE
+  // returns whole pages, not the count asked for.
   test.when(
     databaseName !== 'bigquery' &&
       databaseName !== 'trino' &&
-      databaseName !== 'presto'
+      databaseName !== 'presto' &&
+      databaseName !== 'sqlserver'
   )(`index rows count - ${databaseName}`, async () => {
     await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {

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

@@ -527,12 +527,13 @@ 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: boolean_1 is sql_boolean("\${seats} > 20")
-          group_by: boolean_2 is sql_boolean("\${engines} = 2")
+          group_by:
+            boolean_1 is pick 'yes' when sql_boolean("\${seats} > 20") else 'no'
+            boolean_2 is pick 'yes' when sql_boolean("\${engines} = 2") else 'no'
         }
   `).toMatchResult(testModel, {
-        boolean_1: true,
-        boolean_2: false,
+        boolean_1: 'yes',
+        boolean_2: 'no',
       });
     });
 
@@ -1067,12 +1068,12 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         dimension: fot is (false) or (true)
       } -> {
         select:
-          no_paren is false and fot
-          paren is    false and (fot)
+          no_paren is pick 'yes' when false and fot else 'no'
+          paren is    pick 'yes' when false and (fot) else 'no'
       }`
     ).toMatchResult(testModel, {
-      paren: false,
-      no_paren: false,
+      paren: 'no',
+      no_paren: 'no',
     });
   });
 });

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

@@ -51,8 +51,6 @@ expressionModels.forEach((x, databaseName) => {
   const expressionModel = x.expressionModel;
   const runtime = x.runtime;
   const testModel = wrapTestModel(runtime, modelText(databaseName));
-  const dbTrue = runtime.dialect.resultBoolean(true);
-  const dbFalse = runtime.dialect.resultBoolean(false);
   const funcTestGeneral = async (
     expr: string,
     type: 'group_by' | 'aggregate',
@@ -124,14 +122,6 @@ expressionModels.forEach((x, databaseName) => {
       await funcTestMultiple(
         ["concat('foo', 'bar')", 'foobar'],
         ["concat(1, 'bar')", '1bar'],
-        [
-          "concat('cons', true)",
-          databaseName === 'postgres'
-            ? 'const'
-            : databaseName === 'mysql'
-              ? 'cons1'
-              : 'construe',
-        ],
         ["concat('foo', @2003)", 'foo2003-01-01'],
         [
           "concat('foo', @2003-01-01 12:00:00)",
@@ -142,6 +132,20 @@ expressionModels.forEach((x, databaseName) => {
         ['concat()', '']
       );
     });
+    it.when(
+      runtime.dialect.booleanType !== 'none' &&
+        !brokenIn('trino', databaseName) &&
+        !brokenIn('presto', databaseName)
+    )(`works with a boolean - ${databaseName}`, async () => {
+      await funcTest(
+        "concat('cons', true)",
+        databaseName === 'postgres'
+          ? 'const'
+          : databaseName === 'mysql'
+            ? 'cons1'
+            : 'construe'
+      );
+    });
   });
 
   describe('round', () => {
@@ -624,16 +628,13 @@ expressionModels.forEach((x, databaseName) => {
           # test.debug
           run: state_facts -> {
             group_by: state
-            calculate: lag_val is lag(@2011-11-11 11:11:11, 1, now).year = now.year
+            calculate: lag_val is
+              pick 'now' when lag(@2011-11-11 11:11:11, 1, now).year = now.year else 'then'
           }`
         )
         .run();
-      expect(result.data.path(0, 'lag_val').value).toBe(
-        runtime.dialect.resultBoolean(true)
-      );
-      expect(result.data.path(1, 'lag_val').value).toBe(
-        runtime.dialect.resultBoolean(false)
-      );
+      expect(result.data.path(0, 'lag_val').value).toBe('now');
+      expect(result.data.path(1, 'lag_val').value).toBe('then');
     });
   });
 
@@ -855,32 +856,45 @@ expressionModels.forEach((x, databaseName) => {
       : "'+inf'::number";
     it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        [`is_inf(${inf})`, dbTrue],
-        ['is_inf(100)', dbFalse],
-        ['is_inf(null)', dbFalse]
+        [`pick 'yes' when is_inf(${inf}) else 'no'`, 'yes'],
+        ["pick 'yes' when is_inf(100) else 'no'", 'no'],
+        ["pick 'yes' when is_inf(null) else 'no'", 'no']
       );
     });
+    // A null input is false, not null
+    it.when(databaseName !== 'mysql' && runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTest('is_inf(null)', runtime.dialect.resultBoolean(false));
+      }
+    );
   });
   describe('is_nan', () => {
     it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ["is_nan('NaN'::number)", dbTrue],
-        ['is_nan(100)', dbFalse],
-        ['is_nan(null)', dbFalse]
+        ["pick 'yes' when is_nan('NaN'::number) else 'no'", 'yes'],
+        ["pick 'yes' when is_nan(100) else 'no'", 'no'],
+        ["pick 'yes' when is_nan(null) else 'no'", 'no']
       );
     });
+    it.when(databaseName !== 'mysql' && runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTest('is_nan(null)', runtime.dialect.resultBoolean(false));
+      }
+    );
   });
   describe('greatest', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['greatest(1, 10, -100)', 10],
         [
-          'greatest(@2003, @2004, @1994) = @2004',
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when greatest(@2003, @2004, @1994) = @2004 else 'no'",
+          'yes',
         ],
         [
-          'greatest(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:59:00',
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when greatest(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:59:00 else 'no'",
+          'yes',
         ],
         ["greatest('a', 'b')", 'b'],
         ['greatest(1, null, 0)', null],
@@ -892,13 +906,10 @@ expressionModels.forEach((x, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['least(1, 10, -100)', -100],
+        ["pick 'yes' when least(@2003, @2004, @1994) = @1994 else 'no'", 'yes'],
         [
-          'least(@2003, @2004, @1994) = @1994',
-          runtime.dialect.resultBoolean(true),
-        ],
-        [
-          'least(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:58:00',
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when least(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:58:00 else 'no'",
+          'yes',
         ],
         ["least('a', 'b')", 'a'],
         ['least(1, null, 0)', null],
@@ -929,36 +940,48 @@ expressionModels.forEach((x, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         [
-          "starts_with('hello world', 'hello')",
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when starts_with('hello world', 'hello') else 'no'",
+          'yes',
         ],
-        [
-          "starts_with('hello world', 'world')",
-          runtime.dialect.resultBoolean(false),
-        ],
-        ["starts_with(null, 'world')", runtime.dialect.resultBoolean(false)],
-        [
-          "starts_with('hello world', null)",
-          runtime.dialect.resultBoolean(false),
-        ]
+        ["pick 'yes' when starts_with('hello world', 'world') else 'no'", 'no'],
+        ["pick 'yes' when starts_with(null, 'world') else 'no'", 'no'],
+        ["pick 'yes' when starts_with('hello world', null) else 'no'", 'no']
       );
     });
+    it.when(runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTestMultiple(
+          ["starts_with(null, 'world')", runtime.dialect.resultBoolean(false)],
+          [
+            "starts_with('hello world', null)",
+            runtime.dialect.resultBoolean(false),
+          ]
+        );
+      }
+    );
   });
   describe('ends_with', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        [
-          "ends_with('hello world', 'world')",
-          runtime.dialect.resultBoolean(true),
-        ],
-        [
-          "ends_with('hello world', 'hello')",
-          runtime.dialect.resultBoolean(false),
-        ],
-        ["ends_with(null, 'world')", runtime.dialect.resultBoolean(false)],
-        ["ends_with('hello world', null)", runtime.dialect.resultBoolean(false)]
+        ["pick 'yes' when ends_with('hello world', 'world') else 'no'", 'yes'],
+        ["pick 'yes' when ends_with('hello world', 'hello') else 'no'", 'no'],
+        ["pick 'yes' when ends_with(null, 'world') else 'no'", 'no'],
+        ["pick 'yes' when ends_with('hello world', null) else 'no'", 'no']
       );
     });
+    it.when(runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTestMultiple(
+          ["ends_with(null, 'world')", runtime.dialect.resultBoolean(false)],
+          [
+            "ends_with('hello world', null)",
+            runtime.dialect.resultBoolean(false),
+          ]
+        );
+      }
+    );
   });
   describe('trim', () => {
     it(`trim works - ${databaseName}`, async () => {
@@ -1001,14 +1024,17 @@ 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()', runtime.dialect.resultBoolean(false));
+      await funcTest(
+        "pick 'same' when rand() = rand() else 'differ'",
+        'differ'
+      );
     });
   });
   describe('pi', () => {
     it(`is pi - ${databaseName}`, async () => {
       await funcTest(
-        'abs(pi() - 3.141592653589793) < 0.0000000000001',
-        runtime.dialect.resultBoolean(true)
+        "pick 'yes' when abs(pi() - 3.141592653589793) < 0.0000000000001 else 'no'",
+        'yes'
       );
     });
   });

package/src/databases/all/new-matchers.spec.ts

@@ -11,8 +11,11 @@ import '@malloydata/malloy/test/matchers';
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
 describe.each(runtimes.runtimeList)('New matchers for %s', (db, runtime) => {
+  // A dialect without boolean values has no boolean column
+  const booleans = runtime.dialect.booleanType !== 'none';
+
   describe('mkTestModel and TV', () => {
-    test('basic types with type inference', async () => {
+    test.when(booleans)('basic types with type inference', async () => {
       const tm = mkTestModel(runtime, {
         data: [
           {t_int: 1, t_string: 'a', t_bool: true},
@@ -155,16 +158,19 @@ describe.each(runtimes.runtimeList)('New matchers for %s', (db, runtime) => {
       });
     });
 
-    test('plain booleans work with dialect boolean handling', async () => {
-      const tm = mkTestModel(runtime, {
-        data: [{a: true, b: false}],
-      });
-      // Booleans are handled by dialect.resultBoolean() in the matcher
-      await expect('run: data -> { select: * }').toMatchResult(tm, {
-        a: true,
-        b: false,
-      });
-    });
+    test.when(booleans)(
+      'plain booleans work with dialect boolean handling',
+      async () => {
+        const tm = mkTestModel(runtime, {
+          data: [{a: true, b: false}],
+        });
+        // Booleans are handled by dialect.resultBoolean() in the matcher
+        await expect('run: data -> { select: * }').toMatchResult(tm, {
+          a: true,
+          b: false,
+        });
+      }
+    );
   });
 
   describe('test.debug tag', () => {

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

@@ -24,20 +24,26 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     }`
   );
 
-  it(`boolean type - ${databaseName}`, async () => {
-    await expect(`
+  // A dialect without boolean values cannot group by one
+  it.when(runtime.dialect.booleanType !== 'none')(
+    `boolean type - ${databaseName}`,
+    async () => {
+      await expect(`
       run: models-> {
         group_by: big is seats >=20
         aggregate: model_count is count()
       }
     `).toMatchResult(orderByModel, {
-      big: false,
-      model_count: 58451,
-    });
-  });
+        big: false,
+        model_count: 58451,
+      });
+    }
+  );
 
-  it(`boolean in pipeline - ${databaseName}`, async () => {
-    await expect(`
+  it.when(runtime.dialect.booleanType !== 'none')(
+    `boolean in pipeline - ${databaseName}`,
+    async () => {
+      await expect(`
       run: models->{
         group_by:
           manufacturer,
@@ -48,10 +54,11 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         aggregate: model_count is model_count.sum()
       }
     `).toMatchResult(orderByModel, {
-      big: false,
-      model_count: 58500,
-    });
-  });
+        big: false,
+        model_count: 58500,
+      });
+    }
+  );
 
   it(`filtered measures in model are aggregates #352 - ${databaseName}`, async () => {
     await expect(`

package/src/databases/all/test-select.spec.ts

@@ -15,8 +15,11 @@ describe.each(runtimes.runtimeList)('TestSelect for %s', (db, runtime) => {
   const ts = new TestSelect(runtime.dialect);
   const testModel = wrapTestModel(runtime, '');
 
+  // A dialect without boolean values has no boolean column
+  const booleans = runtime.dialect.booleanType !== 'none';
+
   // Basic Type Tests
-  test(`${db} inferred basic types`, async () => {
+  test.when(booleans)(`${db} inferred basic types`, async () => {
     const sql = ts.generate(
       {t_int: 1, t_string: 'a', t_bool: true, t_float: 1.5},
       {t_int: 2, t_string: 'b', t_bool: false, t_float: 2.5}
@@ -27,7 +30,7 @@ describe.each(runtimes.runtimeList)('TestSelect for %s', (db, runtime) => {
     ]);
   });
 
-  test(`${db} explicit type hints`, async () => {
+  test.when(booleans)(`${db} explicit type hints`, async () => {
     const sql = ts.generate({
       t_int: ts.mk_int(1),
       t_float: ts.mk_float(1.5),