@malloydata/malloy-tests 0.0.304 → 0.0.305

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.304",
-    "@malloydata/db-duckdb": "0.0.304",
-    "@malloydata/db-postgres": "0.0.304",
-    "@malloydata/db-snowflake": "0.0.304",
-    "@malloydata/db-trino": "0.0.304",
-    "@malloydata/malloy": "0.0.304",
-    "@malloydata/malloy-tag": "0.0.304",
-    "@malloydata/render": "0.0.304",
+    "@malloydata/db-bigquery": "0.0.305",
+    "@malloydata/db-duckdb": "0.0.305",
+    "@malloydata/db-postgres": "0.0.305",
+    "@malloydata/db-snowflake": "0.0.305",
+    "@malloydata/db-trino": "0.0.305",
+    "@malloydata/malloy": "0.0.305",
+    "@malloydata/malloy-tag": "0.0.305",
+    "@malloydata/render": "0.0.305",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -38,5 +38,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.304"
+  "version": "0.0.305"
 }

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

@@ -485,21 +485,20 @@ expressionModels.forEach((x, databaseName) => {
     });
 
     it(`works using unary minus in calculate block - ${databaseName}`, async () => {
-      const result = await expressionModel
-        .loadQuery(
-          `run: state_facts -> {
-            group_by: first_letter is substr(state, 1, 1)
-            aggregate: states_with_first_letter_ish is round(count() / 2) * 2
-            calculate:
-              r is rank()
-              neg_r is -r
-          }`
-        )
-        .run();
-      expect(result.data.path(0, 'neg_r').value).toBe(-1);
-      expect(result.data.path(1, 'neg_r').value).toBe(-1);
-      expect(result.data.path(2, 'neg_r').value).toBe(-3);
-      expect(result.data.path(3, 'neg_r').value).toBe(-3);
+      await expect(`
+        run: state_facts -> {
+          group_by: first_letter is substr(state, 1, 1)
+          aggregate: states_with_first_letter_ish is round(count() / 2) * 2
+          calculate:
+            r is rank()
+            neg_r is -r
+      }`).matchesRows(
+        expressionModel,
+        {neg_r: -1},
+        {neg_r: -1},
+        {neg_r: -3},
+        {neg_r: -3}
+      );
     });
 
     it(`properly isolated nested calculations - ${databaseName}`, async () => {

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

@@ -0,0 +1,201 @@
+/* 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 {RuntimeList, allDatabases} from '../../runtimes';
+import {databasesFromEnvironmentOr} from '../../util';
+import '../../util/db-jest-matchers';
+
+const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
+
+// // No prebuilt shared model, each test is complete.  Makes debugging easier.
+// function rootDbPath(databaseName: string) {
+//   return databaseName === 'bigquery' ? 'malloydata-org.' : '';
+// }
+
+afterAll(async () => {
+  await runtimes.closeAll();
+});
+
+runtimes.runtimeMap.forEach((runtime, databaseName) => {
+  // const q = runtime.getQuoter();
+
+  describe('limits', () => {
+    test('limit only', async () => {
+      await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        group_by: popular_name
+        aggregate: c is count()
+        limit: 3
+      }
+      `).malloyResultMatches(runtime, [{}, {}, {}]);
+    });
+
+    test('limit nest one', async () => {
+      await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        group_by: popular_name
+        aggregate: c is count()
+        limit: 3
+        nest: one is {
+          group_by: state
+          limit: 2
+        }
+      }
+      `).malloyResultMatches(runtime, [
+        {popular_name: 'Isabella', one: [{'state': 'AZ'}, {}]},
+        {},
+        {},
+      ]);
+    });
+
+    test('limit nest with having', async () => {
+      await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        group_by: popular_name
+        aggregate: c is count()
+        having: c % 2 = 1
+        limit: 3
+        nest: one is {
+          group_by: state
+          limit: 2
+        }
+      }
+      `).malloyResultMatches(runtime, [
+        {popular_name: 'Sophia', one: [{'state': 'AK'}, {}]},
+        {},
+        {},
+      ]);
+    });
+
+    test('limit two nests with having', async () => {
+      await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        nest: name is {
+          group_by: popular_name
+          aggregate: c is count()
+          having: c % 2 = 1
+          limit: 3
+        }
+        nest: by_state is {
+          group_by: state
+          limit: 2
+        }
+      }
+      `).malloyResultMatches(runtime, [
+        {
+          'name': [{popular_name: 'Sophia'}, {}, {}],
+          'by_state': [{'state': 'AK'}, {}],
+        },
+      ]);
+    });
+
+    test('limit 2 stage second with nest with having', async () => {
+      await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        select: *
+      } -> {
+        group_by: popular_name
+        aggregate: c is count()
+        having: c % 2 = 1
+        limit: 3
+        nest: one is {
+          group_by: state
+          limit: 2
+        }
+      }
+      `).malloyResultMatches(runtime, [
+        {popular_name: 'Sophia', one: [{'state': 'AK'}, {}]},
+        {},
+        {},
+      ]);
+    });
+
+    test('limit index 2 stage', async () => {
+      await expect(`
+      //# test.debug
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        index: *
+      } -> {
+        group_by: fieldName
+        aggregate: cardinality is count(fieldValue)
+        limit: 2
+        nest: values is {
+          group_by: fieldValue
+          aggregate: weight is weight.sum()
+          limit: 3
+        }
+      }
+      `).malloyResultMatches(runtime, [
+        {fieldName: 'state', values: [{}, {}, {}]},
+        {
+          fieldName: 'popular_name',
+          values: [{fieldValue: 'Isabella', weight: 24}, {}, {}],
+        },
+      ]);
+    });
+    test('limit select - in pipeline', async () => {
+      await expect(`
+      //# test.debug
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        group_by: popular_name
+        aggregate: c is count()
+        having: c % 2 = 1
+        limit: 100
+        nest: one is {
+          group_by: state
+          limit: 2
+        }
+      } -> {
+        select: popular_name
+        limit: 2
+      }
+      `).malloyResultMatches(runtime, [{}, {}]);
+    });
+
+    test.when(
+      runtime.supportsNesting &&
+        runtime.dialect.supportsPipelinesInViews &&
+        databaseName !== 'trino'
+    )('limit select - nested pipeline', async () => {
+      await expect(`
+      //# test.debug
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        group_by: popular_name
+        aggregate: c is count()
+        having: c % 2 = 1
+        limit: 1
+        nest: one is {
+          group_by: state
+          limit: 20
+        } -> {
+          select: state
+          limit: 2
+        }
+      }
+      `).malloyResultMatches(runtime, [{one: [{}, {}]}]);
+    });
+  });
+});

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

@@ -128,7 +128,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         group_by: m is manufacturer
         aggregate: num_models is count()
         } extend {
-          join_one: seats is
+          join_one: seats_join is
             aircraft_models->{
               group_by: m is manufacturer
               aggregate: total_seats is seats.sum()
@@ -137,7 +137,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           select:
             m
             num_models
-            seats.total_seats
+            seats_join.total_seats
           order_by: 2 desc
           limit: 1
         }
@@ -223,8 +223,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     }
   );
 
-  // not sure how to solve this one yet, just check for > 4 rows
-  it('All joins at the same level', async () => {
+  it('activates parent join when fields in leaf join are referenced', async () => {
     await expect(`
       source: flights is ${databaseName}.table('malloytest.flights') extend {
         join_one: aircraft is ${databaseName}.table('malloytest.aircraft')
@@ -238,14 +237,19 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         aggregate: flight_count is count()
         limit: 5
       }
-    `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
+    `).malloyResultMatches(runtime, [{}, {}, {}, {}, {}]);
   });
 
+  // I don't know what join issue 440 was, there was a change of repos and that
+  // is no longer recorded anywhere. I suspect it was the indirect reference to
+  // the leaf join field. In a world where the join tree is built from fieldUsage
+  // that automatically works, but what is a problem is inferring the join tree
+  // from the ordering of usages. Inverting the "on" comparison in this test
+  // caused it to fail when the previous one passed.
   it('join issue440', async () => {
     await expect(`
-      source: aircraft_models is ${databaseName}.table('malloytest.aircraft_models')
-
       source: aircraft is ${databaseName}.table('malloytest.aircraft')
+      source: aircraft_models is ${databaseName}.table('malloytest.aircraft_models')
 
       source: flights is ${databaseName}.table('malloytest.flights') extend {
         join_one: aircraft on aircraft.tail_num = tail_num
@@ -253,10 +257,10 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
       }
 
       run: flights-> {
-        group_by: testingtwo is aircraft_models.model
-        limit: 5
+        group_by: testtwo is aircraft_models.seats
+        limit: 1
       }
-    `).malloyResultMatches(runtime, [{}, {}, {}, {}, {}]);
+    `).malloyResultMatches(runtime, [{}]);
   });
 
   it('join issue1092', async () => {

package/src/databases/bigquery/malloy_query.spec.ts

@@ -529,7 +529,7 @@ describe('airport_tests', () => {
     run: airports -> {
       group_by: county
       nest: stuff is {
-        select: elevation
+        group_by: elevation
         order_by: 1 desc
         limit: 10
       }

package/src/runtimes.d.ts

@@ -1,53 +0,0 @@
-import type { Connection, MalloyQueryData, QueryDataRow, Result, RunSQLOptions, ModelCache } from '@malloydata/malloy';
-import { SingleConnectionRuntime, InMemoryURLReader, CacheManager } from '@malloydata/malloy';
-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 { MySQLConnection } from '@malloydata/db-mysql/src/mysql_connection';
-export declare class SnowflakeTestConnection extends SnowflakeConnection {
-    runSQL(sqlCommand: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-}
-export declare class BigQueryTestConnection extends BigQueryConnection {
-    runSQL(sqlCommand: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-}
-export declare class MySQLTestConnection extends MySQLConnection {
-    runSQL(sqlCommand: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-}
-export declare class PostgresTestConnection extends PooledPostgresConnection {
-    runSQL(sqlCommand: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-}
-export declare class DuckDBTestConnection extends DuckDBConnection {
-    runSQL(sqlCommand: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-}
-export declare class DuckDBWASMTestConnection extends DuckDBWASMConnection {
-    runSQL(sqlCommand: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-}
-export declare class TestCacheManager extends CacheManager {
-    readonly _modelCache: ModelCache;
-    constructor(_modelCache: ModelCache);
-}
-export declare class TestURLReader extends InMemoryURLReader {
-    constructor();
-    setFile(url: URL, contents: string): void;
-    deleteFile(url: URL): void;
-}
-export declare function rows(qr: Result): QueryDataRow[];
-export declare function runtimeFor(dbName: string): SingleConnectionRuntime;
-export declare function testRuntimeFor(connection: Connection): SingleConnectionRuntime<Connection>;
-/**
- * All databases which should be tested by default. Experimental dialects
- * should not be in this list. Use MALLOY_DATABASE=dialect_name to test those
- */
-export declare const allDatabases: string[];
-type RuntimeDatabaseNames = (typeof allDatabases)[number];
-export declare class RuntimeList {
-    runtimeMap: Map<string, SingleConnectionRuntime<Connection>>;
-    runtimeList: Array<[string, SingleConnectionRuntime]>;
-    constructor();
-    constructor(databaseList: RuntimeDatabaseNames[]);
-    constructor(externalConnections: SingleConnectionRuntime[]);
-    closeAll(): Promise<void>;
-}
-export {};