@malloydata/malloy-tests 0.0.125 → 0.0.126-dev240305182920

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

@@ -36,6 +36,7 @@ afterAll(async () => {
 });
 
 runtimes.runtimeMap.forEach((runtime, databaseName) => {
+  const q = runtime.getQuoter();
   it(`sql expression with turducken - ${databaseName}`, async () => {
     await expect(`
       run: ${databaseName}.sql(
@@ -63,14 +64,14 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     await expect(`
       run: ${databaseName}.sql("""
         SELECT * from (%{
-          ${databaseName}.sql("""SELECT 1 as one""") -> { group_by: one }
+          ${databaseName}.sql("""SELECT 1 as ${q`one`} """) -> { group_by: one }
         }) as the_table
       """) -> { group_by: one }
     `).malloyResultMatches(runtime, {one: 1});
   });
   it(`run sql expression as query - ${databaseName}`, async () => {
     await expect(
-      `run: ${databaseName}.sql("""SELECT 1 as one""")`
+      `run: ${databaseName}.sql("""SELECT 1 as ${q`one`} """)`
     ).malloyResultMatches(runtime, {one: 1});
   });
 });

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

@@ -24,10 +24,15 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import '../../util/db-jest-matchers';
-import {mkSqlEqWith, runQuery, testIf} from '../../util';
+import {
+  databasesFromEnvironmentOr,
+  mkSqlEqWith,
+  runQuery,
+  testIf,
+} from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
 
-const runtimes = new RuntimeList(allDatabases);
+const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
 const timeSQL =
   "SELECT DATE '2021-02-24' as t_date, TIMESTAMP '2021-02-24 03:05:06' as t_timestamp";
@@ -620,12 +625,12 @@ describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
     const query = runtime.loadQuery(
       `
         run: ${dbName}.sql("SELECT 1") -> {
-          group_by: literalTime is @2020-02-20 00:00:00
+          group_by: literal_time is @2020-02-20 00:00:00
         }
 `
     );
     const result = await query.run();
-    const literal = result.data.path(0, 'literalTime').value as Date;
+    const literal = result.data.path(0, 'literal_time').value as Date;
     const have = LuxonDateTime.fromJSDate(literal);
     expect(have.valueOf()).toEqual(utc_2020.valueOf());
   });
@@ -634,12 +639,12 @@ describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
     const query = runtime.loadQuery(
       `
         run: ${dbName}.sql("SELECT 1") -> {
-          group_by: literalTime is @2020-02-20 00:00:00[America/Mexico_City]
+          group_by: literal_time is @2020-02-20 00:00:00[America/Mexico_City]
         }
 `
     );
     const result = await query.run();
-    const literal = result.data.path(0, 'literalTime').value as Date;
+    const literal = result.data.path(0, 'literal_time').value as Date;
     const have = LuxonDateTime.fromJSDate(literal);
     expect(have.valueOf()).toEqual(zone_2020.valueOf());
   });
@@ -651,12 +656,12 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
       `
         run: ${dbName}.sql("SELECT 1") -> {
           timezone: '${zone}'
-          group_by: literalTime is @2020-02-20 00:00:00
+          group_by: literal_time is @2020-02-20 00:00:00
         }
       `
     );
     const result = await query.run();
-    const literal = result.data.path(0, 'literalTime').value as Date;
+    const literal = result.data.path(0, 'literal_time').value as Date;
     const have = LuxonDateTime.fromJSDate(literal);
     expect(have.valueOf()).toEqual(zone_2020.valueOf());
   });

package/src/runtimes.ts

@@ -33,7 +33,24 @@ import {
 import {BigQueryConnection} from '@malloydata/db-bigquery';
 import {DuckDBConnection} from '@malloydata/db-duckdb';
 import {DuckDBWASMConnection} from '@malloydata/db-duckdb/wasm';
+import {SnowflakeConnection} from '@malloydata/db-snowflake';
 import {PooledPostgresConnection} from '@malloydata/db-postgres';
+import {SnowflakeExecutor} from '@malloydata/db-snowflake/src/snowflake_executor';
+
+export class SnowflakeTestConnection extends SnowflakeConnection {
+  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 BigQueryTestConnection extends BigQueryConnection {
   // we probably need a better way to do this.
@@ -119,34 +136,53 @@ export function rows(qr: Result): QueryDataRow[] {
 
 export function runtimeFor(dbName: string): SingleConnectionRuntime {
   let connection;
-  switch (dbName) {
-    case 'bigquery':
-      connection = new BigQueryTestConnection(
-        dbName,
-        {},
-        {projectId: 'malloy-data'}
-      );
-      break;
-    case 'postgres':
-      connection = new PostgresTestConnection(dbName);
-      break;
-    case 'duckdb':
-      connection = new DuckDBTestConnection(dbName);
-      break;
-    case 'duckdb_wasm':
-      connection = new DuckDBWASMTestConnection(dbName);
-      break;
-    default:
-      throw new Error(`Unknown runtime "${dbName}`);
+  try {
+    switch (dbName) {
+      case 'bigquery':
+        connection = new BigQueryTestConnection(
+          dbName,
+          {},
+          {projectId: 'malloy-data'}
+        );
+        break;
+      case 'postgres':
+        connection = new PostgresTestConnection(dbName);
+        break;
+      case 'duckdb':
+        connection = new DuckDBTestConnection(dbName);
+        break;
+      case 'duckdb_wasm':
+        connection = new DuckDBWASMTestConnection(dbName);
+        break;
+      case 'snowflake':
+        {
+          const connOptions = SnowflakeExecutor.getConnectionOptionsFromEnv();
+          connection = new SnowflakeTestConnection(dbName, {connOptions});
+        }
+        break;
+      default:
+        throw new Error(`Unknown runtime "${dbName}`);
+    }
+    return testRuntimeFor(connection);
+  } catch (error) {
+    throw new Error(
+      `Failed to create connection \`${dbName}\`: ${error.message}`
+    );
   }
-  return testRuntimeFor(connection);
 }
 
 export function testRuntimeFor(connection: Connection) {
   return new SingleConnectionRuntime(files, connection);
 }
 
-export const allDatabases = ['postgres', 'bigquery', 'duckdb', 'duckdb_wasm'];
+export const allDatabases = [
+  'postgres',
+  'bigquery',
+  'duckdb',
+  'duckdb_wasm',
+  'snowflake',
+];
+
 type RuntimeDatabaseNames = (typeof allDatabases)[number];
 
 export class RuntimeList {

package/src/util/db-jest-matchers.ts

@@ -139,9 +139,17 @@ expect.extend({
       return {pass: false, message: () => failMsg};
     }
 
+    const debug = querySrc.indexOf('--debug') >= 0;
     const allRows = Array.isArray(shouldEqual) ? shouldEqual : [shouldEqual];
     let i = 0;
     const fails: string[] = [];
+
+    if (debug) {
+      fails.push(
+        `Debug: Result Data: ${JSON.stringify(result.data.toObject())}`
+      );
+    }
+
     const gotRows = result.data.toObject().length;
     if (Array.isArray(shouldEqual)) {
       if (gotRows !== allRows.length) {

package/tsconfig.json

@@ -18,6 +18,9 @@
     {
       "path": "../packages/malloy-db-postgres"
     },
+    {
+      "path": "../packages/malloy-db-snowflake"
+    },
     {
       "path": "../packages/malloy-db-duckdb"
     },