@malloydata/malloy-tests 0.0.66-dev230807232724

package/src/databases/bigquery-postgres/multi_connection.spec.ts

@@ -0,0 +1,143 @@
+/* eslint-disable no-console */
+/*
+ * 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.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+import * as malloy from '@malloydata/malloy';
+import {EmptyURLReader} from '@malloydata/malloy';
+import {BigQueryTestConnection, PostgresTestConnection} from '../../runtimes';
+import {describeIfDatabaseAvailable} from '../../util';
+
+const res = describeIfDatabaseAvailable(['bigquery', 'postgres']);
+let [describe] = res;
+const [, databases] = res;
+
+// *** NOTE ***
+// this is a special case (for now): a test that REQUIRES two databases - bigquery AND postgres
+describe =
+  databases.filter(d => ['postgres', 'bigquery'].includes(d)).length >= 2
+    ? describe
+    : describe.skip;
+
+describe('Multi-connection', () => {
+  const bqConnection = new BigQueryTestConnection(
+    'bigquery',
+    {},
+    {defaultProject: 'malloy-data'}
+  );
+  const postgresConnection = new PostgresTestConnection('postgres');
+  const files = new EmptyURLReader();
+
+  const connectionMap = new malloy.FixedConnectionMap(
+    new Map(
+      Object.entries({
+        bigquery: bqConnection,
+        postgres: postgresConnection,
+      })
+    ),
+    'bigquery'
+  );
+
+  const runtime = new malloy.Runtime(files, connectionMap);
+
+  afterAll(async () => {
+    await postgresConnection.close();
+  });
+
+  const expressionModelText = `
+source: default_aircraft is table('malloytest.aircraft'){
+  measure: aircraft_count is count(DISTINCT tail_num)
+}
+
+source: bigquery_state_facts is table('malloytest.state_facts'){
+  measure: state_count is count(DISTINCT state)+2
+}
+
+source: postgres_aircraft is table('postgres:malloytest.aircraft'){
+  measure: aircraft_count is count(DISTINCT tail_num)+4
+}
+`;
+
+  const expressionModel = runtime.loadModel(expressionModelText);
+
+  it('default query', async () => {
+    const result = await expressionModel
+      .loadQuery(
+        `
+      query: default_aircraft-> {
+        aggregate: aircraft_count
+      }
+    `
+      )
+      .run();
+    // console.log(result.sql);
+    expect(result.data.path(0, 'aircraft_count').value).toBe(3599);
+  });
+
+  it('bigquery query', async () => {
+    const result = await expressionModel
+      .loadQuery(
+        `
+      query: bigquery_state_facts-> {
+        aggregate: state_count
+      }
+    `
+      )
+      .run();
+    // console.log(result.sql);
+    expect(result.data.path(0, 'state_count').value).toBe(53);
+  });
+
+  it('postgres query', async () => {
+    const result = await expressionModel
+      .loadQuery(
+        `
+      query: postgres_aircraft-> {
+        aggregate: aircraft_count
+      }
+    `
+      )
+      .run();
+    expect(result.data.path(0, 'aircraft_count').value).toBe(3603);
+  });
+
+  it('postgres raw query', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+      query: table('postgres:malloytest.airports')->{
+        group_by:
+          version is version!()
+        aggregate:
+          code_count is count(distinct code)
+          airport_count is count()
+      }
+    `
+      )
+      .run();
+    expect(result.data.path(0, 'airport_count').value).toBe(19793);
+    expect(result.data.path(0, 'version').value).toMatch(/Postgre/);
+    expect(result.data.path(0, 'code_count').value).toBe(19793);
+  });
+});

package/src/databases/bigquery-postgres/streaming.spec.ts

@@ -0,0 +1,100 @@
+/*
+ * 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 {
+  CSVWriter,
+  DataRecord,
+  JSONWriter,
+  WriteStream,
+} from '@malloydata/malloy';
+import {RuntimeList} from '../../runtimes';
+import {describeIfDatabaseAvailable} from '../../util';
+
+class StringAccumulator implements WriteStream {
+  public accumulatedValue = '';
+
+  write(text: string) {
+    this.accumulatedValue += text;
+  }
+
+  close() {
+    return;
+  }
+}
+
+const [describe, databases] = describeIfDatabaseAvailable([
+  'bigquery',
+  'postgres',
+]);
+
+describe('Streaming tests', () => {
+  const runtimes = new RuntimeList(databases);
+
+  afterAll(async () => {
+    await runtimes.closeAll();
+  });
+
+  runtimes.runtimeMap.forEach((runtime, databaseName) => {
+    it(`basic stream test  - ${databaseName}`, async () => {
+      const stream = runtime
+        .loadModel("source: airports is table('malloytest.airports') {}")
+        .loadQuery('query: airports -> { project: code }')
+        .runStream({rowLimit: 10});
+      const rows: DataRecord[] = [];
+      for await (const row of stream) {
+        rows.push(row);
+      }
+      expect(rows.length).toBe(10);
+      expect(rows[0].cell('code').string.value).toBe('1Q9');
+    });
+
+    it(`stream to JSON - ${databaseName}`, async () => {
+      const stream = runtime
+        .loadModel("source: airports is table('malloytest.airports') {}")
+        .loadQuery('query: airports -> { project: code }')
+        .runStream({rowLimit: 1});
+      const accummulator = new StringAccumulator();
+      const jsonWriter = new JSONWriter(accummulator);
+      await jsonWriter.process(stream);
+      expect(accummulator.accumulatedValue).toBe(
+        `[
+  {
+    "code": "1Q9"
+  }
+]
+`
+      );
+    });
+
+    it(`stream to CSV - ${databaseName}`, async () => {
+      const stream = runtime
+        .loadModel("source: airports is table('malloytest.airports') {}")
+        .loadQuery('query: airports -> { project: code }')
+        .runStream({rowLimit: 1});
+      const accummulator = new StringAccumulator();
+      const csvWriter = new CSVWriter(accummulator);
+      await csvWriter.process(stream);
+      expect(accummulator.accumulatedValue).toBe('code\n1Q9\n');
+    });
+  });
+});

package/src/databases/duckdb/duckdb.spec.ts

@@ -0,0 +1,131 @@
+/*
+ * 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 {DateTime} from 'luxon';
+import {RuntimeList} from '../../runtimes';
+import '../../util/db-jest-matchers';
+import {describeIfDatabaseAvailable} from '../../util';
+
+const runtimes = ['duckdb', 'duckdb_wasm'];
+
+const [_describe, databases] = describeIfDatabaseAvailable(runtimes);
+const allDucks = new RuntimeList(databases);
+
+describe.each(allDucks.runtimeList)('duckdb:%s', (dbName, runtime) => {
+  it('can open tables with wildcards', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+        query: table('duckdb:test/data/duckdb/flights/part.*.parquet') -> {
+          top: 1
+          group_by: carrier;
+        }
+      `
+      )
+      .run();
+    expect(result.data.path(0, 'carrier').value).toEqual('AA');
+  });
+
+  it('accepts all schema numbers', async () => {
+    const allInts = [
+      'BIGINT',
+      'INTEGER',
+      'TINYINT',
+      'SMALLINT',
+      'UBIGINT',
+      'UINTEGER',
+      'UTINYINT',
+      'USMALLINT',
+      'HUGEINT',
+    ];
+    const allFields = allInts.map(intType => `a${intType.toLowerCase()}`);
+    const query = `
+      sql: allInts is { connection: "${dbName}" select: """
+        SELECT
+        ${allInts
+          .map(intType => `1::${intType} as a${intType.toLowerCase()}`)
+          .join(',\n')}
+      """}
+      query: from_sql(allInts) -> {
+        aggregate:
+        ${allFields
+          .map(fieldType => `sum_${fieldType} is sum(${fieldType})`)
+          .join('\n')}
+      }
+    `;
+    const result = await runtime.loadQuery(query).run();
+    for (const fieldType of allFields) {
+      expect(result.data.path(0, `sum_${fieldType}`).value).toEqual(1);
+    }
+  });
+
+  it('can open json files', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+          query: table('duckdb:test/data/duckdb/test.json') -> {
+            project: *
+          }
+        `
+      )
+      .run();
+    expect(result.data.path(0, 'foo').value).toEqual('bar');
+  });
+
+  it('supports timezones', async () => {
+    await runtime.connection.runSQL("SET TimeZone='CET'");
+    const result = await runtime.connection.runSQL(
+      "SELECT current_setting('TimeZone')"
+    );
+    expect(result.rows[0]).toEqual({"current_setting('TimeZone')": 'CET'});
+  });
+
+  describe('time', () => {
+    const zone = 'America/Mexico_City'; // -06:00 no DST
+    const zone_2020 = DateTime.fromObject({
+      year: 2020,
+      month: 2,
+      day: 20,
+      hour: 0,
+      minute: 0,
+      second: 0,
+      zone,
+    });
+    // TODO: Investigate why its no working.
+    test.skip('can use unsupported types', async () => {
+      await expect(runtime).queryMatches(
+        `sql: timeData is { connection: "duckdb"  select: """
+          SELECT TIMESTAMPTZ '2020-02-20 00:00:00 ${zone}' as t_tstz
+        """}
+      query: from_sql(timeData) -> {
+        project: mex_220 is t_tstz::timestamp
+      }`,
+        {mex_220: zone_2020.toJSDate()}
+      );
+    });
+  });
+});
+
+afterAll(async () => {
+  await allDucks.closeAll();
+});

package/src/databases/postgres/postgres.spec.ts

@@ -0,0 +1,167 @@
+/*
+ * 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.
+ */
+
+/* eslint-disable no-console */
+
+import {RuntimeList} from '../../runtimes';
+import {describeIfDatabaseAvailable} from '../../util';
+import '../../util/db-jest-matchers';
+import {DateTime} from 'luxon';
+
+const [describe] = describeIfDatabaseAvailable(['postgres']);
+
+describe('Postgres tests', () => {
+  const runtimeList = new RuntimeList(['postgres']);
+  const runtime = runtimeList.runtimeMap.get('postgres');
+  if (runtime === undefined) {
+    throw new Error("Couldn't build runtime");
+  }
+
+  // Idempotently create schema and tables with capital letters to use in tests.
+  beforeAll(async () => {
+    await runtime.connection.runSQL(
+      'create schema if not exists "UpperSchema";'
+    );
+    await Promise.all([
+      runtime.connection.runSQL(
+        'create table if not exists "UpperSchema"."UpperSchemaUpperTable" as select 1 as one;'
+      ),
+      runtime.connection.runSQL(
+        'create table if not exists "UpperTablePublic" as select 1 as one;'
+      ),
+    ]);
+  });
+
+  afterAll(async () => {
+    await runtimeList.closeAll();
+  });
+
+  it('sql_block', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+      sql: one is {select:"""
+        SELECT 1 as n
+       """}
+
+      query: from_sql(one) -> { project: n }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['n']).toBe(1);
+  });
+
+  it('quote field name', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+      sql: one is {select:"""
+        SELECT 1 as "upperLower"
+       """}
+
+      query: from_sql(one) -> { project: upperLower }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['upperLower']).toBe(1);
+  });
+
+  it('quote keyword', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+      sql: one is {select:"""
+        SELECT 1 as "select"
+       """}
+
+      query: from_sql(one) -> {
+        project:
+          select
+          create is select + 1
+      }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['select']).toBe(1);
+    expect(result.data.value[0]['create']).toBe(2);
+  });
+
+  // these started failing and I'm not sure why (lloyd, skipping for now)
+  it.skip('quote table name', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+      query: table('public.UpperTablePublic') -> { project: one }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['one']).toBe(1);
+  });
+
+  it.skip('quote schema name', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+      query: table('UpperSchema.UpperSchemaUpperTable') -> { project: one }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['one']).toBe(1);
+  });
+
+  it('passes unsupported data', async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+        sql: badType is { select: """SELECT int4range(10, 20) as ranger""" }
+        query: from_sql(badType)->{ project: *}
+      `
+      )
+      .run();
+    expect(result.data.value[0]['ranger']).toBeDefined();
+  });
+  describe('time', () => {
+    const zone = 'America/Mexico_City'; // -06:00 no DST
+    const zone_2020 = DateTime.fromObject({
+      year: 2020,
+      month: 2,
+      day: 20,
+      hour: 0,
+      minute: 0,
+      second: 0,
+      zone,
+    });
+    // TODO: Investigate why this test is not working.
+    test.skip('can use unsupported types', async () => {
+      await expect(runtime).queryMatches(
+        `sql: timeData is { connection: "postgres"  select: """
+          SELECT TIMESTAMPTZ '2020-02-20 00:00:00 ${zone}' as t_tstz
+        """}
+      query: from_sql(timeData) -> {
+        project: mex_220 is t_tstz::timestamp
+      }`,
+        {mex_220: zone_2020.toJSDate()}
+      );
+    });
+  });
+});

package/src/databases/shared/test_list.ts

@@ -0,0 +1,24 @@
+import {RuntimeList} from '../../runtimes';
+import {exprSharedTests} from '../all/expr.spec';
+import {functionsSharedTests} from '../all/functions.spec';
+import {indexSharedTests} from '../all/index.spec';
+import {joinSharedTests} from '../all/join.spec';
+import {noModelSharedTests} from '../all/nomodel.spec';
+import {orderBySharedTests} from '../all/orderby.spec';
+import {problemsSharedTests} from '../all/problems.spec';
+import {sqlExpressionsSharedTests} from '../all/sql_expressions.spec';
+import {timeSharedTests} from '../all/time.spec';
+
+export type DatabaseTestSet = (runtimeList: RuntimeList) => void;
+
+export const allDatabaseTestSets: DatabaseTestSet[] = [
+  exprSharedTests,
+  functionsSharedTests,
+  indexSharedTests,
+  joinSharedTests,
+  noModelSharedTests,
+  orderBySharedTests,
+  problemsSharedTests,
+  sqlExpressionsSharedTests,
+  timeSharedTests,
+];

package/src/dependencies.spec.ts

@@ -0,0 +1,62 @@
+/*
+ * 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 madge from 'madge';
+
+describe('dependencies', () => {
+  function getMessage(circles: string[][]): string {
+    let message = 'Circular References:\n';
+    for (const circle of circles) {
+      message += '    ';
+      for (const dep of circle) {
+        message += `${dep} -> `;
+      }
+      message += `${circle[0]}\n`;
+    }
+    return message;
+  }
+
+  it('typescript references should not be circular', async () => {
+    const deps = await madge('packages', {
+      fileExtensions: ['ts'],
+      excludeRegExp: [/malloy\/src\/lang/, /\.d\.ts/],
+    });
+    expect(deps.circular().length, getMessage(deps.circular())).toBe(0);
+  });
+
+  it('javascript references should not be circular', async () => {
+    const deps = await madge('packages', {
+      fileExtensions: ['js'],
+    });
+    expect(deps.circular().length, getMessage(deps.circular())).toBe(0);
+  });
+
+  // Enable more strict circular checks if we refactor lang again.
+  it.skip('malloy/src/lang typescript should not be circular', async () => {
+    const deps = await madge('packages', {
+      fileExtensions: ['ts'],
+      excludeRegExp: [/malloy\/src\/lang\/lib/, /\.d\.ts/],
+    });
+    expect(deps.circular().length, getMessage(deps.circular())).toBe(0);
+  });
+});

package/src/index.ts

@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+
+export {RuntimeList, testRuntimeFor} from './runtimes';
+
+export {allDatabaseTestSets} from './databases/shared/test_list';
+
+export {exprSharedTests} from './databases/all/expr.spec';
+export {functionsSharedTests} from './databases/all/functions.spec';
+export {indexSharedTests} from './databases/all/index.spec';
+export {joinSharedTests} from './databases/all/join.spec';
+export {noModelSharedTests} from './databases/all/nomodel.spec';
+export {orderBySharedTests} from './databases/all/orderby.spec';
+export {problemsSharedTests} from './databases/all/problems.spec';
+export {sqlExpressionsSharedTests} from './databases/all/sql_expressions.spec';
+export {timeSharedTests} from './databases/all/time.spec';