@malloydata/malloy-tests 0.0.434 → 0.0.436

package/src/databases/sqlserver/sqlserver.spec.ts

@@ -0,0 +1,509 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+import {RuntimeList} from '../../runtimes';
+import {describeIfDatabaseAvailable} from '../../util';
+import '@malloydata/malloy/test/matchers';
+import {wrapTestModel} from '@malloydata/malloy/test';
+
+const [describe] = describeIfDatabaseAvailable(['sqlserver']);
+
+/*
+ * The dialect is built up here in the order a query grows: a literal, a
+ * table, a filter, an ordering, a grouping, a join. Each block is what the
+ * next one stands on, and what the cross-dialect suite in ../all assumes.
+ */
+describe('SQL Server', () => {
+  const runtimes = new RuntimeList(['sqlserver']);
+  const runtime = runtimes.runtimeMap.get('sqlserver');
+  if (runtime === undefined) {
+    throw new Error("Couldn't build runtime");
+  }
+  // A test runtime enables experimental dialects; no compiler flag is needed
+  const tm = wrapTestModel(runtime, '');
+
+  afterAll(async () => {
+    await runtimes.closeAll();
+  });
+
+  describe('a SQL block', () => {
+    test('selects a literal', async () => {
+      await expect(
+        'run: sqlserver.sql("SELECT 1 AS n") -> { select: n }'
+      ).toMatchResult(tm, {n: 1});
+    });
+
+    test('carries string, date and timestamp values', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT N'héllo' AS s,
+                 CAST('2021-02-24' AS DATE) AS d,
+                 CAST('2021-02-24 03:05:06' AS DATETIME2) AS t
+        """) -> { select: s, d, t }
+      `).toMatchResult(tm, {
+        s: 'héllo',
+        d: new Date('2021-02-24T00:00:00Z'),
+        t: new Date('2021-02-24T03:05:06Z'),
+      });
+    });
+
+    test('carries a newline in a string literal', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> { select: s is 'a\\nb' }
+      `).toMatchResult(tm, {s: 'a\nb'});
+    });
+
+    test('quotes a field named like a keyword', async () => {
+      await expect(`
+        run: sqlserver.sql('SELECT 1 AS "select"') -> {
+          select: \`select\`, \`create\` is \`select\` + 1
+        }
+      `).toMatchResult(tm, {select: 1, create: 2});
+    });
+  });
+
+  describe('a table', () => {
+    test('a boolean literal is a condition', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          where: true
+          aggregate: n is count(), none is count() { where: false }
+        }
+      `).toEqualResult(tm, [{n: 51, none: 0}]);
+    });
+
+    test('a bit column is an integer', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.alltypes') -> {
+          select: t_bool_true, t_bool_false, t_bool_null
+        }
+      `).toEqualResult(tm, [
+        {t_bool_true: 1, t_bool_false: 0, t_bool_null: null},
+      ]);
+    });
+
+    test('a limit of zero is no limit', async () => {
+      // FETCH NEXT 0 ROWS is a parse error; the compiler writes no limit at all
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          limit: 0
+        } -> { aggregate: n is count() }
+      `).toEqualResult(tm, [{n: 51}]);
+    });
+
+    test('a declared boolean in a result column is refused, naming the value to write', async () => {
+      await expect(
+        runtime
+          .loadQuery(
+            `run: sqlserver.table('malloytest.state_facts') extend {
+              dimension: big is airport_count > 500
+            } -> { group_by: big; aggregate: n is count() }`
+          )
+          .run()
+      ).rejects.toThrow(
+        "'sqlserver' does not support a boolean as a result column; write the value, pick 'yes' when big else 'no'"
+      );
+    });
+
+    test('a declared boolean is a condition in where: and having:', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') extend {
+          dimension: big is airport_count > 500
+          measure: n is count()
+        } -> {
+          where: big
+          aggregate: n
+          having: n > 1
+        }
+      `).toEqualResult(tm, [{n: 12}]);
+    });
+
+    test('not, and a comparison true on NULL, follow Malloy rather than SQL', async () => {
+      await expect(`
+        run: sqlserver.sql('SELECT CAST(NULL AS INT) AS n, 1 AS one') -> {
+          select:
+            not_null is pick 'yes' when not (n = 1) else 'no'
+            ne_null is pick 'yes' when n != 1 else 'no'
+            not_one is pick 'yes' when not (one = 1) else 'no'
+            ne_one is pick 'yes' when one != 1 else 'no'
+        }
+      `).toEqualResult(tm, [
+        {not_null: 'yes', ne_null: 'yes', not_one: 'no', ne_one: 'no'},
+      ]);
+    });
+
+    test('a comparison picks', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: size is pick 'big' when airport_count > 500 else 'small'
+          aggregate: n is count()
+          order_by: size
+        }
+      `).toEqualResult(tm, [
+        {size: 'big', n: 12},
+        {size: 'small', n: 39},
+      ]);
+    });
+
+    test('a boolean function is a condition', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          where: starts_with(state, 'C') and not ends_with(state, 'A')
+          select: state
+          order_by: state
+        }
+      `).toEqualResult(tm, [{state: 'CO'}, {state: 'CT'}]);
+    });
+
+    test('sql_boolean is a condition', async () => {
+      await expect(`
+        ##! experimental { sql_functions }
+        run: sqlserver.table('malloytest.state_facts') extend {
+          dimension: big is sql_boolean("\${airport_count} > 500")
+        } -> {
+          where: big
+          aggregate: n is count()
+        }
+      `).toEqualResult(tm, [{n: 12}]);
+    });
+
+    test('a cast to boolean is refused', async () => {
+      await expect(
+        runtime
+          .loadQuery(
+            `run: sqlserver.table('malloytest.state_facts') -> {
+              select: b is airport_count::boolean
+            }`
+          )
+          .run()
+      ).rejects.toThrow(/boolean/);
+    });
+
+    test('starts_with, ends_with and is_nan filter an aggregate', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate:
+            c_states is count() { where: starts_with(state, 'C') }
+            a_states is count() { where: ends_with(state, 'A') }
+            nan_counts is count() { where: is_nan(airport_count) }
+        }
+      `).toEqualResult(tm, [{c_states: 3, a_states: 8, nan_counts: 0}]);
+    });
+
+    test('reads a column', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          where: state = 'CA'
+        }
+      `).toEqualResult(tm, [{state: 'CA'}]);
+    });
+
+    test('reads a bracket-quoted path', async () => {
+      await expect(`
+        run: sqlserver.table('[malloytest].[state_facts]') -> {
+          select: state
+          where: state = 'CA'
+        }
+      `).toEqualResult(tm, [{state: 'CA'}]);
+    });
+
+    test('reads a database-qualified path', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.malloytest.state_facts') -> {
+          aggregate: n is count()
+        }
+      `).toMatchResult(tm, {n: 51});
+    });
+
+    test('orders and limits', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          order_by: state desc
+          limit: 2
+        }
+      `).toEqualResult(tm, [{state: 'WY'}, {state: 'WV'}]);
+    });
+
+    test('limits a stage that feeds another', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          order_by: state desc
+          limit: 3
+        } -> {
+          select: state
+          order_by: state asc
+        }
+      `).toEqualResult(tm, [{state: 'WI'}, {state: 'WV'}, {state: 'WY'}]);
+    });
+
+    test('filters on a comparison', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate: n is count()
+          where: airport_count > 500
+        }
+      `).toMatchResult(tm, {n: 12});
+    });
+
+    test('escapes a bracket in a LIKE pattern', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT s FROM (VALUES (N'a[b'), (N'ab'), (N'axb')) v(s)
+        """) -> { select: s; where: s ~ 'a[%' }
+      `).toEqualResult(tm, [{s: 'a[b'}]);
+    });
+  });
+
+  describe('aggregation', () => {
+    test('a group of only constants is one row', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> { group_by: x is 1, y is 'a' }
+      `).toEqualResult(tm, [{x: 1, y: 'a'}]);
+    });
+
+    test('a constant dimension groups with the others', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: tag is 'facts', size is pick 'big' when airport_count > 500 else 'small'
+          aggregate: n is count()
+          order_by: size
+        }
+      `).toEqualResult(tm, [
+        {tag: 'facts', size: 'big', n: 12},
+        {tag: 'facts', size: 'small', n: 39},
+      ]);
+    });
+
+    test('counts without a group', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate: state_count is count()
+        }
+      `).toMatchResult(tm, {state_count: 51});
+    });
+
+    test('groups by a column', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc
+        }
+      `).toMatchResult(tm, {popular_name: 'Isabella'});
+    });
+
+    test('groups by an expression', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: first is substr(state, 1, 1)
+          aggregate: state_count is count()
+          order_by: state_count desc, first
+        }
+      `).toMatchResult(tm, {first: 'M', state_count: 8});
+    });
+
+    test('orders and limits a grouped result', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc, popular_name
+          limit: 2
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Isabella', state_count: 24},
+        {popular_name: 'Sophia', state_count: 11},
+      ]);
+    });
+
+    test('orders a query used as a source', async () => {
+      await expect(`
+        source: by_name is sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc
+        }
+        run: by_name -> {
+          select: popular_name
+          where: state_count > 10
+          order_by: popular_name
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Isabella'},
+        {popular_name: 'Sophia'},
+      ]);
+    });
+
+    test('orders the last stage of a pipeline', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+        } -> {
+          select: popular_name, state_count
+          order_by: state_count asc, popular_name desc
+          limit: 2
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Madison', state_count: 3},
+        {popular_name: 'Ava', state_count: 3},
+      ]);
+    });
+
+    test('divides as a float', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 7 AS a, 2 AS b") -> {
+          select: q is a / b
+        }
+      `).toMatchResult(tm, {q: 3.5});
+    });
+  });
+
+  describe('functions', () => {
+    test('pow computes in floating point', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select: root is round(pow(2, 0.5), 6), hundredth is pow(10, -2)
+        }
+      `).toEqualResult(tm, [{root: 1.414214, hundredth: 0.01}]);
+    });
+
+    test('length counts trailing spaces', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select:
+            padded is length('abc  ')
+            back is substr('abc ', -2)
+        }
+      `).toEqualResult(tm, [{padded: 5, back: 'c '}]);
+    });
+  });
+
+  describe('time zones', () => {
+    test('converts a query time zone through its Windows name', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2020-02-20 00:00:00' AS DATETIME2) AS t") -> {
+          timezone: 'America/Mexico_City'
+          select: mex_day is t.day, mex_hour is hour(t)
+        }
+      `).toMatchResult(tm, {
+        mex_day: new Date('2020-02-19T06:00:00Z'),
+        mex_hour: 18,
+      });
+    });
+
+    test('a zone is known by its current IANA name as well as its old one', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2021-02-24 03:05:06' AS DATETIME2) AS t") -> {
+          timezone: 'Asia/Kolkata'
+          select: h is hour(t)
+        }
+      `).toEqualResult(tm, [{h: 8}]);
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2021-02-24 03:05:06' AS DATETIME2) AS t") -> {
+          timezone: 'Europe/Kyiv'
+          select: h is hour(t)
+        }
+      `).toEqualResult(tm, [{h: 5}]);
+    });
+
+    test('a literal written in a zone is that instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select: t is @2020-02-20 00:00:00[America/Mexico_City]
+        }
+      `).toMatchResult(tm, {t: new Date('2020-02-20T06:00:00Z')});
+    });
+  });
+
+  describe('a datetimeoffset', () => {
+    // 12:34:56 at -05:00 is 17:34:56 UTC; 22:34:56 at -05:00 is 03:34:56 UTC the next day
+    const noon = "CAST('2024-03-20 12:34:56 -05:00' AS DATETIMEOFFSET)";
+    const night = "CAST('2024-03-20 22:34:56 -05:00' AS DATETIMEOFFSET)";
+
+    test('is an instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT ${noon} AS t") -> {
+          select: t, utc is t::timestamp
+        }
+      `).toMatchResult(tm, {
+        t: new Date('2024-03-20T17:34:56Z'),
+        utc: new Date('2024-03-20T17:34:56Z'),
+      });
+    });
+
+    test('reads its clock at UTC without a query time zone', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT ${night} AS t") -> {
+          select: h is hour(t), d is t.day, dt is t::date
+        }
+      `).toMatchResult(tm, {
+        h: 3,
+        d: new Date('2024-03-21T00:00:00Z'),
+        dt: '2024-03-21',
+      });
+    });
+
+    test('compares as an instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT ${noon} AS t") -> {
+          where: t > @2024-03-20 15:00:00
+          aggregate: n is count()
+        }
+      `).toMatchResult(tm, {n: 1});
+    });
+
+    test('offsets by a calendar unit at UTC', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2024-01-30 22:34:56 -05:00' AS DATETIMEOFFSET) AS t") -> {
+          select: next is t + 1 month
+        }
+      `).toMatchResult(tm, {next: new Date('2024-02-29T03:34:56Z')});
+    });
+
+    test('measures between two offsets as instants', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT CAST('2024-03-20 12:00:00 +00:00' AS DATETIMEOFFSET) AS a,
+                 CAST('2024-03-20 12:00:00 -05:00' AS DATETIMEOFFSET) AS b
+        """) -> { select: h is hours(a to b) }
+      `).toMatchResult(tm, {h: 5});
+    });
+  });
+
+  describe('joins', () => {
+    test('sums each side of a fan-out once', async () => {
+      await expect(`
+        source: facts is sqlserver.table('malloytest.state_facts')
+        run: facts extend { join_cross: other is facts on other.state = 'CA' | 'NY' } -> {
+          aggregate:
+            row_count is count(concat(state, other.state))
+            left_sum is airport_count.sum()
+            right_sum is other.airport_count.sum()
+        }
+      `).toMatchResult(tm, {row_count: 102, left_sum: 19701, right_sum: 1560});
+    });
+
+    test('joins and aggregates symmetrically', async () => {
+      await expect(`
+        source: carriers is sqlserver.table('malloytest.carriers') extend {
+          primary_key: code
+        }
+        source: flights is sqlserver.table('malloytest.flights') extend {
+          join_one: carriers with carrier
+        }
+        run: flights -> {
+          group_by: carriers.nickname
+          aggregate: flight_count is count(), carrier_count is carriers.count()
+          order_by: flight_count desc
+        }
+      `).toMatchResult(tm, {nickname: 'Southwest', carrier_count: 1});
+    });
+  });
+});

package/src/runtimes.ts

@@ -16,6 +16,7 @@ import {
   InMemoryURLReader,
   InMemoryModelCache,
   CacheManager,
+  getDialect,
 } from '@malloydata/malloy';
 import {createTestRuntime} from '@malloydata/malloy/test';
 import {BigQueryConnection} from '@malloydata/db-bigquery';
@@ -31,6 +32,10 @@ import {
   MySQLExecutor,
 } from '@malloydata/db-mysql/src/mysql_connection';
 import {DatabricksConnection} from '@malloydata/db-databricks/src/databricks_connection';
+import {
+  SQLServerConnection,
+  SQLServerExecutor,
+} from '@malloydata/db-sqlserver/src/sqlserver_connection';
 import {EventEmitter} from 'events';
 
 export class SnowflakeTestConnection extends SnowflakeConnection {
@@ -144,6 +149,21 @@ export class DuckDBWASMTestConnection extends DuckDBWASMConnection {
   }
 }
 
+export class SQLServerTestConnection extends SQLServerConnection {
+  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 TestCacheManager extends CacheManager {
   constructor(readonly _modelCache: ModelCache) {
     super(_modelCache);
@@ -203,15 +223,26 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
         );
         break;
       case 'mssql_via_duckdb':
-        connection = new DuckDBTestConnection({
-          name: dbName,
-          additionalExtensions: ['mssql'],
-          setupSQL: [
-            // Must match test/mssql/connection_string.ts
-            "ATTACH 'Server=localhost;Port=1433;Database=malloytest;User Id=sa;Password=Malloy_Test_123;TrustServerCertificate=true' AS msdb (TYPE mssql)",
-            'USE msdb.malloytest',
-          ].join(';\n'),
-        });
+        {
+          const s = SQLServerExecutor.getConnectionOptionsFromEnv();
+          if (s.server === undefined) {
+            throw new Error(
+              'MSSQL_HOST is not set; see test/mssql/mssql_start.sh'
+            );
+          }
+          connection = new DuckDBTestConnection({
+            name: dbName,
+            additionalExtensions: ['mssql'],
+            setupSQL: [
+              // The same string test/mssql/connection_string.ts builds for the
+              // loader, written here because packages/malloy-render type-checks
+              // this file alone and admits no import beside it. `Server=host,port`:
+              // the extension reads no separate Port key.
+              `ATTACH 'Server=${s.server},${s.port ?? 1433};Database=${s.database};User Id=${s.user};Password=${s.password};TrustServerCertificate=${s.trustServerCertificate ?? false}' AS msdb (TYPE mssql)`,
+              `USE msdb.${s.database}`,
+            ].join(';\n'),
+          });
+        }
         break;
       case 'motherduck':
         connection = new DuckDBTestConnection({
@@ -247,6 +278,12 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
           TrinoExecutor.getConnectionOptionsFromEnv(dbName) // they share configs.
         );
         break;
+      case 'sqlserver':
+        connection = new SQLServerTestConnection(
+          dbName,
+          SQLServerExecutor.getConnectionOptionsFromEnv()
+        );
+        break;
       case 'databricks':
         {
           const warehouseId = process.env['DATABRICKS_WAREHOUSE_ID'];
@@ -265,6 +302,9 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
       default:
         throw new Error(`Unknown runtime "${dbName}`);
     }
+    // The shared suites carry no `##! experimental.dialect.NAME` lines. A
+    // dialect under test is accepted once, for the whole process, instead.
+    getDialect(connection.dialectName).acceptExperimental();
     return testRuntimeFor(connection);
   } catch (error) {
     throw new Error(
@@ -314,7 +354,6 @@ export class RuntimeList {
         database instanceof SingleConnectionRuntime
           ? database
           : runtimeFor(database);
-      rt.isTestRuntime = true;
       this.runtimeMap.set(rt.connection.name, rt);
       this.runtimeList.push([rt.connection.name, rt]);
     }

package/src/test-select.ts

@@ -521,21 +521,17 @@ export class TestSelect {
     const innerQuery = selects.join('\nUNION ALL ');
 
     // Generate ORDER BY based on dialect preference
-    let orderByClause: string;
-    if (this.dialect.orderByClause === 'ordinal') {
-      // ORDER BY position (column count + 1 since row_id is last)
-      orderByClause = `ORDER BY ${columnList.length + 1}`;
-    } else if (this.dialect.orderByClause === 'output_name') {
-      // ORDER BY column name
-      orderByClause = `ORDER BY ${rowIdColumn}`;
-    } else {
-      // ORDER BY expression - just use column name (qualified would be t_sorted.__ts_row_id__)
-      orderByClause = `ORDER BY ${rowIdColumn}`;
-    }
-    // Presto/Trino ignores ORDER BY on a subquery without LIMIT
-    orderByClause += ` LIMIT ${rows.length}`;
+    const orderTerm =
+      this.dialect.orderByClause === 'ordinal'
+        ? `${columnList.length + 1}`
+        : rowIdColumn;
+    // Presto/Trino ignores ORDER BY on a subquery without a row limit
+    const orderByClause = this.dialect.sqlOrderByLimit(
+      [orderTerm],
+      rows.length
+    );
 
-    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}\n) AS t_result\n`;
+    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}) AS t_result\n`;
 
     return sql;
   }

package/tsconfig.json

@@ -34,6 +34,9 @@
     {
       "path": "../packages/malloy-db-snowflake"
     },
+    {
+      "path": "../packages/malloy-db-sqlserver"
+    },
     {
       "path": "../packages/malloy-db-trino"
     },