@malloydata/malloy-tests 0.0.196-dev241007190115 → 0.0.196-dev241007230836

package/mysql/mysql_start.sh

@@ -0,0 +1,32 @@
+#! /bin/bash
+rm -rf .tmp
+mkdir .tmp
+
+#
+
+# run docker
+docker run -p 3306:3306 -d -v $PWD/../data/mysql:/init_data   --name mysql-malloy -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -d mysql:8.4.2
+
+# wait for server to start
+counter=0
+while ! docker logs mysql-malloy 2>&1 | grep -q "mysqld: ready for connections"
+do
+  sleep 10
+  counter=$((counter+1))
+  # if doesn't start after 2 minutes, output logs and kill process
+  if [ $counter -eq 120 ]
+  then
+    docker logs mysql-malloy >& ./.tmp/mysql-malloy.logs
+    docker rm -f mysql-malloy
+    echo "MySQL did not start successfully, check .tmp/mysql-malloy.logs"
+    exit 1
+    break
+  fi
+done
+
+# load the test data.
+docker exec mysql-malloy cp /init_data/malloytest.mysql.gz /tmp
+docker exec mysql-malloy gunzip /tmp/malloytest.mysql.gz
+docker exec mysql-malloy mysql -uroot -e 'drop database if exists malloytest; create database malloytest; use malloytest; source /tmp/malloytest.mysql'
+
+echo "MySQL running on port 3306"

package/mysql/mysql_stop.sh

@@ -0,0 +1,7 @@
+#! /bin/bash
+
+# clear tmp files
+rm -rf .tmp
+
+# stop container
+docker rm -f mysql-malloy

package/package.json

@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.196-dev241007190115",
-    "@malloydata/db-duckdb": "^0.0.196-dev241007190115",
-    "@malloydata/db-postgres": "^0.0.196-dev241007190115",
-    "@malloydata/db-snowflake": "^0.0.196-dev241007190115",
-    "@malloydata/db-trino": "^0.0.196-dev241007190115",
-    "@malloydata/malloy": "^0.0.196-dev241007190115",
-    "@malloydata/render": "^0.0.196-dev241007190115",
+    "@malloydata/db-bigquery": "^0.0.196-dev241007230836",
+    "@malloydata/db-duckdb": "^0.0.196-dev241007230836",
+    "@malloydata/db-postgres": "^0.0.196-dev241007230836",
+    "@malloydata/db-snowflake": "^0.0.196-dev241007230836",
+    "@malloydata/db-trino": "^0.0.196-dev241007230836",
+    "@malloydata/malloy": "^0.0.196-dev241007230836",
+    "@malloydata/render": "^0.0.196-dev241007230836",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -37,5 +37,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.196-dev241007190115"
+  "version": "0.0.196-dev241007230836"
 }

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

@@ -24,7 +24,11 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import '../../util/db-jest-matchers';
-import {databasesFromEnvironmentOr, mkSqlEqWith} from '../../util';
+import {
+  booleanResult,
+  databasesFromEnvironmentOr,
+  mkSqlEqWith,
+} from '../../util';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
@@ -129,6 +133,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
   // simple turtle expressions
   it('simple turtle', async () => {
     await expect(`
+      // # test.debug
       run:  ${databaseName}.table('malloytest.state_facts') -> {
         group_by: popular_name
         aggregate: airport_count.sum()
@@ -396,30 +401,28 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(expressionModel, {m_count: 63});
   });
 
+  const nativeInt = databaseName === 'mysql' ? 'signed' : 'integer';
   it('sql cast', async () => {
     await expect(`
       run: aircraft -> {
-        group_by: a is "312"::"integer"
+        group_by: a is "312"::"${nativeInt}"
       }
     `).malloyResultMatches(expressionModel, {a: 312});
   });
 
-  test.when(!['postgres'].includes(runtime.connection.name))(
-    'sql safe cast',
-    async () => {
-      await expect(`
+  test.when(runtime.dialect.supportsSafeCast)('sql safe cast', async () => {
+    await expect(`
       run: ${databaseName}.sql('SELECT 1 as one') -> { select:
         bad_date is '12a':::date
         bad_number is 'abc':::number
-        good_number is "312":::"integer"
+        good_number is "312":::"${nativeInt}"
       }
     `).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(`
@@ -494,8 +497,8 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           group_by: boolean_2 is sql_boolean("\${engines} = 2")
         }
   `).malloyResultMatches(expressionModel, {
-        boolean_1: true,
-        boolean_2: false,
+        boolean_1: booleanResult(true, databaseName),
+        boolean_2: booleanResult(false, databaseName),
       });
     });
 
@@ -817,7 +820,10 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           no_paren is false and fot
           paren is    false and (fot)
       }`
-    ).malloyResultMatches(runtime, {paren: false, no_paren: false});
+    ).malloyResultMatches(runtime, {
+      paren: booleanResult(false, databaseName),
+      no_paren: booleanResult(false, databaseName),
+    });
   });
 });
 

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

@@ -23,7 +23,7 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {brokenIn, databasesFromEnvironmentOr} from '../../util';
+import {booleanResult, brokenIn, databasesFromEnvironmentOr} from '../../util';
 import '../../util/db-jest-matchers';
 import * as malloy from '@malloydata/malloy';
 
@@ -107,7 +107,7 @@ expressionModels.forEach((x, databaseName) => {
       return await expressionModel
         .loadQuery(
           `
-      run: aircraft -> { ${testCases.map(
+      run: state_facts -> { ${testCases.map(
         (testCase, i) => `group_by: f${i} is ${testCase[0]}`
       )} }`
         )
@@ -137,7 +137,11 @@ expressionModels.forEach((x, databaseName) => {
         ["concat(1, 'bar')", '1bar'],
         [
           "concat('cons', true)",
-          databaseName === 'postgres' ? 'const' : 'construe',
+          databaseName === 'postgres'
+            ? 'const'
+            : databaseName === 'mysql'
+            ? 'cons1'
+            : 'construe',
         ],
         ["concat('foo', @2003)", 'foo2003-01-01'],
         [
@@ -216,7 +220,7 @@ expressionModels.forEach((x, databaseName) => {
         ["regexp_extract('I have a dog', r'd[aeiou]g')", 'dog'],
         ["regexp_extract(null, r'd[aeiou]g')", null],
         ["regexp_extract('foo', null)", null],
-        ["regexp_extract('I have a d0g', r'd\\dg')", 'd0g']
+        ["regexp_extract('I have a d0g', r'd.g')", 'd0g']
       );
     });
   });
@@ -230,7 +234,9 @@ expressionModels.forEach((x, databaseName) => {
           "replace('axbxc', r'(a).(b).(c)', '\\\\0 - \\\\1 - \\\\2 - \\\\3')",
           databaseName === 'postgres'
             ? '\\0 - a - b - c'
-            : databaseName === 'trino' || databaseName === 'presto'
+            : databaseName === 'trino' ||
+              databaseName === 'presto' ||
+              databaseName === 'mysql'
             ? '0 - 1 - 2 - 3'
             : 'axbxc - a - b - c',
         ],
@@ -263,8 +269,8 @@ expressionModels.forEach((x, databaseName) => {
   describe('raw function call', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ['floor(cbrt!(27)::number)', 3],
-        ['floor(cbrt!number(27))', 3],
+        ['floor(sqrt!(25)::number)', 5],
+        ['floor(sqrt!number(25))', 5],
         ["substr('foo bar baz', -3)", 'baz'],
         ["substr(nullif('x','x'), 1, 2)", null], // nullMatchesFunctionSignature
         ["substr('aaaa', null, 1)", null],
@@ -275,7 +281,11 @@ expressionModels.forEach((x, databaseName) => {
 
   describe('stddev', () => {
     // TODO symmetric aggregates don't work with custom aggregate functions in BQ currently
-    if (['bigquery', 'snowflake', 'trino', 'presto'].includes(databaseName))
+    if (
+      ['bigquery', 'snowflake', 'trino', 'presto', 'mysql'].includes(
+        databaseName
+      )
+    )
       return;
     it(`works - ${databaseName}`, async () => {
       await funcTestAgg('round(stddev(aircraft_models.seats))', 29);
@@ -357,16 +367,35 @@ expressionModels.forEach((x, databaseName) => {
       expect(result.data.path(0, 'row_num').value).toBe(1);
     });
 
+    // should rework the tests to this form....
+    // it(`boolean type - ${databaseName}`, async () => {
+    //   await expect(`
+    //     # test.debug
+    //       run: state_facts extend { join_one: airports on airports.state = state } -> {
+    //         group_by: state
+    //         nest: q is {
+    //           group_by: airports.county
+    //           calculate: row_num is row_number()
+    //         }
+    //       }
+    //   `).malloyResultMatches(expressionModel, {
+    //     big: 1,
+    //     model_count: 58451,
+    //   });
+    // });
+
     it(`works inside nest - ${databaseName}`, async () => {
       const result = await expressionModel
         .loadQuery(
-          `run: state_facts extend { join_one: airports on airports.state = state } -> {
+          `
+          run: state_facts extend { join_one: airports on airports.state = state } -> {
             group_by: state
             nest: q is {
               group_by: airports.county
               calculate: row_num is row_number()
             }
-          }`
+          }
+            `
         )
         .run();
       expect(result.data.path(0, 'q', 0, 'row_num').value).toBe(1);
@@ -582,8 +611,12 @@ expressionModels.forEach((x, databaseName) => {
           }`
         )
         .run();
-      expect(result.data.path(0, 'lag_val').value).toBe(true);
-      expect(result.data.path(1, 'lag_val').value).toBe(false);
+      expect(result.data.path(0, 'lag_val').value).toBe(
+        booleanResult(true, databaseName)
+      );
+      expect(result.data.path(1, 'lag_val').value).toBe(
+        booleanResult(false, databaseName)
+      );
     });
   });
 
@@ -803,7 +836,7 @@ expressionModels.forEach((x, databaseName) => {
     const inf = ['trino', 'presto'].includes(databaseName)
       ? 'infinity!()'
       : "'+inf'::number";
-    it(`works - ${databaseName}`, async () => {
+    it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         [`is_inf(${inf})`, true],
         ['is_inf(100)', false],
@@ -812,7 +845,7 @@ expressionModels.forEach((x, databaseName) => {
     });
   });
   describe('is_nan', () => {
-    it(`works - ${databaseName}`, async () => {
+    it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ["is_nan('NaN'::number)", true],
         ['is_nan(100)', false],
@@ -824,10 +857,13 @@ expressionModels.forEach((x, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['greatest(1, 10, -100)', 10],
-        ['greatest(@2003, @2004, @1994) = @2004', true],
+        [
+          'greatest(@2003, @2004, @1994) = @2004',
+          booleanResult(true, databaseName),
+        ],
         [
           'greatest(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:59:00',
-          true,
+          booleanResult(true, databaseName),
         ],
         ["greatest('a', 'b')", 'b'],
         ['greatest(1, null, 0)', null],
@@ -839,10 +875,13 @@ expressionModels.forEach((x, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['least(1, 10, -100)', -100],
-        ['least(@2003, @2004, @1994) = @1994', true],
+        [
+          'least(@2003, @2004, @1994) = @1994',
+          booleanResult(true, databaseName),
+        ],
         [
           'least(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:58:00',
-          true,
+          booleanResult(true, databaseName),
         ],
         ["least('a', 'b')", 'a'],
         ['least(1, null, 0)', null],
@@ -872,25 +911,37 @@ expressionModels.forEach((x, databaseName) => {
   describe('starts_with', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ["starts_with('hello world', 'hello')", true],
-        ["starts_with('hello world', 'world')", false],
-        ["starts_with(null, 'world')", false],
-        ["starts_with('hello world', null)", false]
+        [
+          "starts_with('hello world', 'hello')",
+          booleanResult(true, databaseName),
+        ],
+        [
+          "starts_with('hello world', 'world')",
+          booleanResult(false, databaseName),
+        ],
+        ["starts_with(null, 'world')", booleanResult(false, databaseName)],
+        ["starts_with('hello world', null)", booleanResult(false, databaseName)]
       );
     });
   });
   describe('ends_with', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ["ends_with('hello world', 'world')", true],
-        ["ends_with('hello world', 'hello')", false],
-        ["ends_with(null, 'world')", false],
-        ["ends_with('hello world', null)", false]
+        [
+          "ends_with('hello world', 'world')",
+          booleanResult(true, databaseName),
+        ],
+        [
+          "ends_with('hello world', 'hello')",
+          booleanResult(false, databaseName),
+        ],
+        ["ends_with(null, 'world')", booleanResult(false, databaseName)],
+        ["ends_with('hello world', null)", booleanResult(false, databaseName)]
       );
     });
   });
   describe('trim', () => {
-    it(`works - ${databaseName}`, async () => {
+    it(`trim works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ["trim('  keep this  ')", 'keep this'],
         ["trim('_ _keep_this_ _', '_ ')", 'keep_this'],
@@ -902,7 +953,7 @@ expressionModels.forEach((x, databaseName) => {
     });
   });
   describe('ltrim', () => {
-    it(`works - ${databaseName}`, async () => {
+    it(`ltrim works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ["ltrim('  keep this ->  ')", 'keep this ->  '],
         ["ltrim('_ _keep_this -> _ _', '_ ')", 'keep_this -> _ _'],
@@ -914,7 +965,7 @@ expressionModels.forEach((x, databaseName) => {
     });
   });
   describe('rtrim', () => {
-    it(`works - ${databaseName}`, async () => {
+    it(`rtrim works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ["rtrim('  <- keep this  ')", '  <- keep this'],
         ["rtrim('_ _ <- keep_this_ _', '_ ')", '_ _ <- keep_this'],
@@ -930,12 +981,15 @@ 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()', false);
+      await funcTest('rand() = rand()', booleanResult(false, databaseName));
     });
   });
   describe('pi', () => {
     it(`is pi - ${databaseName}`, async () => {
-      await funcTest('abs(pi() - 3.141592653589793) < 0.0000000000001', true);
+      await funcTest(
+        'abs(pi() - 3.141592653589793) < 0.0000000000001',
+        booleanResult(true, databaseName)
+      );
     });
   });
 
@@ -1098,8 +1152,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': true,
-        'also_passes': true,
+        'passes': booleanResult(true, databaseName),
+        'also_passes': booleanResult(true, databaseName),
       });
     });
     test.when(supported)('works with fanout', async () => {
@@ -1111,7 +1165,7 @@ expressionModels.forEach((x, databaseName) => {
         run: state_facts_fanout -> {
           aggregate: x is state_facts.state.count_approx() > 0
         }
-      `).malloyResultMatches(runtime, {x: true});
+      `).malloyResultMatches(runtime, {x: booleanResult(true, databaseName)});
     });
   });
   describe('last_value', () => {
@@ -1262,7 +1316,10 @@ expressionModels.forEach((x, databaseName) => {
     describe('duckdb', () => {
       const duckdb = it.when(databaseName === 'duckdb');
       duckdb('to_timestamp', async () => {
-        await funcTest('to_timestamp(1725555835) = @2024-09-05 17:03:55', true);
+        await funcTest(
+          'to_timestamp(1725555835) = @2024-09-05 17:03:55',
+          booleanResult(true, databaseName)
+        );
       });
     });
 
@@ -1271,7 +1328,7 @@ expressionModels.forEach((x, databaseName) => {
       trino('from_unixtime', async () => {
         await funcTest(
           'from_unixtime(1725555835) = @2024-09-05 17:03:55',
-          true
+          booleanResult(true, databaseName)
         );
       });
     });

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

@@ -64,8 +64,10 @@ afterAll(async () => {
 runtimes.runtimeMap.forEach((runtime, databaseName) => {
   const q = runtime.getQuoter();
   // Issue #1824
-  it(`not boolean field with null - ${databaseName}`, async () => {
-    await expect(`
+  it.when(runtime.dialect.nativeBoolean)(
+    `not boolean field with null - ${databaseName}`,
+    async () => {
+      await expect(`
       run: ${databaseName}.sql("""
           SELECT
             CASE WHEN 1=1 THEN NULL ELSE false END as ${q`n`}
@@ -73,14 +75,17 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
         select:
           is_true is not n
       }
-    `).malloyResultMatches(runtime, {is_true: true});
-  });
+    `).malloyResultMatches(runtime, {
+        is_true: true,
+      });
+    }
+  );
 
   // Issue: #1284
   it(`parenthesize output field values - ${databaseName}`, async () => {
     await expect(`
       run: ${databaseName}.table('malloytest.aircraft') -> {
-        group_by: r is 1
+        group_by: r is 1.0
 
         calculate:
           zero is 1 - rank()
@@ -413,11 +418,13 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     });
   });
 
-  it(`join full - ${databaseName}`, async () => {
-    // a cross join produces a Many to Many result.
-    // symmetric aggregate are needed on both sides of the join
-    // Check the row count and that sums on each side work properly.
-    await expect(`
+  it.when(runtime.dialect.supportsFullJoin)(
+    `join full - ${databaseName}`,
+    async () => {
+      // a cross join produces a Many to Many result.
+      // symmetric aggregate are needed on both sides of the join
+      // Check the row count and that sums on each side work properly.
+      await expect(`
       ${matrixModel}
       run: ac_states -> {
         extend: {
@@ -431,12 +438,13 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
 
       }
       `).malloyResultMatches(runtime, {
-      ac_count: 49,
-      ac_sum: 21336,
-      am_count: 12,
-      am_sum: 4139,
-    });
-  });
+        ac_count: 49,
+        ac_sum: 21336,
+        am_count: 12,
+        am_sum: 4139,
+      });
+    }
+  );
 
   it(`leafy count - ${databaseName}`, async () => {
     // in a joined table when the joined is leafiest
@@ -948,12 +956,13 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     ).malloyResultMatches(runtime, {a: 1});
   });
 
+  // weirdly '*' must be the first thing in the select list in MySQL
   it(`sql with turducken- ${databaseName}`, async () => {
     const turduckenQuery = `
       run: ${databaseName}.sql("""
         SELECT
-          'something' as SOMETHING,
           *
+          , 'something' as SOMETHING
         FROM %{
           ${databaseName}.table('malloytest.state_facts') -> {
             group_by: popular_name

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

@@ -23,7 +23,7 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {databasesFromEnvironmentOr} from '../../util';
+import {booleanResult, 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: false,
+      big: booleanResult(false, databaseName),
       model_count: 58451,
     });
   });
@@ -62,7 +62,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         aggregate: model_count is model_count.sum()
       }
     `).malloyResultMatches(orderByModel, {
-      big: false,
+      big: booleanResult(false, databaseName),
       model_count: 58500,
     });
   });
@@ -91,9 +91,9 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `reserved words are quoted in turtles - ${databaseName}`,
     async () => {
       await expect(`
-      run: models->{
+      run: ${databaseName}.table('malloytest.state_facts')->{
         nest: withx is {
-          group_by: select is UPPER(manufacturer)
+          group_by: select is upper(popular_name)
           aggregate: fetch is count()
         }
       } -> {

package/src/runtimes.ts

@@ -38,6 +38,10 @@ import {PooledPostgresConnection} from '@malloydata/db-postgres';
 import {TrinoConnection, TrinoExecutor} from '@malloydata/db-trino';
 import {SnowflakeExecutor} from '@malloydata/db-snowflake/src/snowflake_executor';
 import {PrestoConnection} from '@malloydata/db-trino/src/trino_connection';
+import {
+  MySQLConnection,
+  MySQLExecutor,
+} from '@malloydata/db-mysql/src/mysql_connection';
 import {EventEmitter} from 'events';
 
 export class SnowflakeTestConnection extends SnowflakeConnection {
@@ -72,6 +76,23 @@ export class BigQueryTestConnection extends BigQueryConnection {
   }
 }
 
+export class MySQLTestConnection extends MySQLConnection {
+  // we probably need a better way to do this.
+
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
 export class PostgresTestConnection extends PooledPostgresConnection {
   // we probably need a better way to do this.
 
@@ -175,6 +196,13 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
           TrinoExecutor.getConnectionOptionsFromEnv(dbName)
         );
         break;
+      case 'mysql':
+        connection = new MySQLConnection(
+          dbName,
+          MySQLExecutor.getConnectionOptionsFromEnv(),
+          {}
+        );
+        break;
       case 'presto':
         connection = new PrestoConnection(
           dbName,
@@ -208,6 +236,7 @@ export const allDatabases = [
   'duckdb_wasm',
   'snowflake',
   'trino',
+  'mysql',
 ];
 
 type RuntimeDatabaseNames = (typeof allDatabases)[number];

package/src/util/index.ts

@@ -198,3 +198,19 @@ 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';
+  }
+}

package/tsconfig.json

@@ -24,6 +24,9 @@
     {
       "path": "../packages/malloy-db-trino"
     },
+    {
+      "path": "../packages/malloy-db-mysql"
+    },
     {
       "path": "../packages/malloy-db-duckdb"
     },