@malloydata/malloy-tests 0.0.194-dev241001154534 → 0.0.194-dev241001231135

package/package.json

@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.194-dev241001154534",
-    "@malloydata/db-duckdb": "^0.0.194-dev241001154534",
-    "@malloydata/db-postgres": "^0.0.194-dev241001154534",
-    "@malloydata/db-snowflake": "^0.0.194-dev241001154534",
-    "@malloydata/db-trino": "^0.0.194-dev241001154534",
-    "@malloydata/malloy": "^0.0.194-dev241001154534",
-    "@malloydata/render": "^0.0.194-dev241001154534",
+    "@malloydata/db-bigquery": "^0.0.194-dev241001231135",
+    "@malloydata/db-duckdb": "^0.0.194-dev241001231135",
+    "@malloydata/db-postgres": "^0.0.194-dev241001231135",
+    "@malloydata/db-snowflake": "^0.0.194-dev241001231135",
+    "@malloydata/db-trino": "^0.0.194-dev241001231135",
+    "@malloydata/malloy": "^0.0.194-dev241001231135",
+    "@malloydata/render": "^0.0.194-dev241001231135",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
     "madge": "^6.0.0"
@@ -36,5 +36,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.194-dev241001154534"
+  "version": "0.0.194-dev241001231135"
 }

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

@@ -32,19 +32,23 @@ describe.each(allDucks.runtimeList)('duckdb:%s', (dbName, runtime) => {
     run: foo -> fooview;
     `;
 
-    const qm = runtime.loadQuery(query, {replaceMaterializedReferences: true});
+    const qm = runtime.loadQuery(query, {
+      replaceMaterializedReferences: true,
+      materializedTablePrefix: 'myPipelinePrefix',
+    });
     const preparedResult = await qm.getPreparedResult();
 
     expect(preparedResult.sql).toBe(
-      'SELECT \n   base."two"+1 as "three"\nFROM myMaterializedQuery-6037d4be-8b92-5ea7-95a0-27bd26c240ca as base\n'
+      'SELECT \n   base."two"+1 as "three"\nFROM myPipelinePrefix_myMaterializedQuery_6037d4be_8b92_5ea7_95a0_27bd26c240ca as base\n'
     );
     expect(preparedResult.dependenciesToMaterialize).toStrictEqual({
-      'myMaterializedQuery-6037d4be-8b92-5ea7-95a0-27bd26c240ca': {
-        'id': 'myMaterializedQuery-6037d4be-8b92-5ea7-95a0-27bd26c240ca',
-        'path': 'internal://internal.malloy',
-        'queryName': 'myMaterializedQuery',
-        'source': undefined,
-      },
+      'myPipelinePrefix_myMaterializedQuery_6037d4be_8b92_5ea7_95a0_27bd26c240ca':
+        {
+          'id': 'myPipelinePrefix_myMaterializedQuery_6037d4be_8b92_5ea7_95a0_27bd26c240ca',
+          'path': 'internal://internal.malloy',
+          'queryName': 'myMaterializedQuery',
+          'source': undefined,
+        },
     });
   });
 
@@ -76,11 +80,11 @@ describe.each(allDucks.runtimeList)('duckdb:%s', (dbName, runtime) => {
     const preparedResult = await qm.getPreparedResult();
 
     expect(preparedResult.sql).toBe(
-      'SELECT \n   base."three"+1 as "four"\nFROM secondLevelMaterializedQuery-bd80d526-f867-587e-933e-89353d26d022 as base\n'
+      'SELECT \n   base."three"+1 as "four"\nFROM secondLevelMaterializedQuery_bd80d526_f867_587e_933e_89353d26d022 as base\n'
     );
     expect(preparedResult.dependenciesToMaterialize).toStrictEqual({
-      'secondLevelMaterializedQuery-bd80d526-f867-587e-933e-89353d26d022': {
-        id: 'secondLevelMaterializedQuery-bd80d526-f867-587e-933e-89353d26d022',
+      'secondLevelMaterializedQuery_bd80d526_f867_587e_933e_89353d26d022': {
+        id: 'secondLevelMaterializedQuery_bd80d526_f867_587e_933e_89353d26d022',
         path: 'internal://internal.malloy',
         queryName: 'secondLevelMaterializedQuery',
         source: undefined,

package/src/databases/duckdb/reference-id.spec.ts

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+
+import {RuntimeList} from '../../runtimes';
+import '../../util/db-jest-matchers';
+import {describeIfDatabaseAvailable} from '../../util';
+import {Explore, Field} from '@malloydata/malloy';
+
+const [describe, databases] = describeIfDatabaseAvailable(['duckdb']);
+const dbs = new RuntimeList(databases);
+
+function referenceId(field: Field | Explore) {
+  if (field.isExplore() || field.isQueryField()) {
+    return undefined;
+  }
+  return field.referenceId;
+}
+
+describe.each(dbs.runtimeList)('%s', (dbName, runtime) => {
+  describe('reference id', () => {
+    it('is correct for field references in table', async () => {
+      const query = `
+        run: duckdb.sql("SELECT 1 as one") -> {
+          group_by: one
+          nest: a is {
+            group_by: one
+          }
+          nest: b is {
+            group_by: one is "fake"
+          }
+          nest: c is {
+            # this reference has an annotation
+            group_by: one
+          }
+        }
+      `;
+
+      const result = await runtime.loadQuery(query).run();
+      const actual = referenceId(result.data.path(0, 'one').field);
+      expect(actual).not.toBeUndefined();
+      expect(referenceId(result.data.path(0, 'a', 0, 'one').field)).toBe(
+        actual
+      );
+      const bOne = referenceId(result.data.path(0, 'b', 0, 'one').field);
+      expect(bOne).not.toBe(undefined);
+      expect(bOne).not.toBe(actual);
+      expect(referenceId(result.data.path(0, 'c', 0, 'one').field)).toBe(
+        actual
+      );
+    });
+
+    it('is correct for measures', async () => {
+      const query = `
+        run: duckdb.sql("SELECT 1 as one") extend {
+          measure: c is count()
+        } -> {
+          aggregate: c
+          nest: a is {
+            aggregate: c
+          }
+          nest: b is {
+            aggregate: c is count() * 2
+          }
+          nest: d is {
+            # this reference has an annotation
+            aggregate: c
+          }
+        }
+      `;
+
+      const result = await runtime.loadQuery(query).run();
+      const actual = referenceId(result.data.path(0, 'c').field);
+      expect(actual).not.toBeUndefined();
+      expect(referenceId(result.data.path(0, 'a', 'c').field)).toBe(actual);
+      const bC = referenceId(result.data.path(0, 'b', 'c').field);
+      expect(bC).not.toBe(undefined);
+      expect(bC).not.toBe(actual);
+      expect(referenceId(result.data.path(0, 'd', 'c').field)).toBe(actual);
+    });
+
+    it('is correct for field references from extend block', async () => {
+      const query = `
+        run: duckdb.sql("SELECT 1 as one") -> {
+          extend: {
+            dimension: two is 2
+          }
+          group_by: two
+          nest: a is {
+            group_by: two
+          }
+          nest: b is {
+            group_by: two is "fake"
+          }
+          nest: c is {
+            # this reference has an annotation
+            group_by: two
+          }
+        }
+      `;
+
+      const result = await runtime.loadQuery(query).run();
+      const actual = referenceId(result.data.path(0, 'two').field);
+      expect(actual).not.toBeUndefined();
+      expect(referenceId(result.data.path(0, 'a', 0, 'two').field)).toBe(
+        actual
+      );
+      const bTwo = referenceId(result.data.path(0, 'b', 0, 'two').field);
+      expect(bTwo).not.toBe(undefined);
+      expect(bTwo).not.toBe(actual);
+      expect(referenceId(result.data.path(0, 'c', 0, 'two').field)).toBe(
+        actual
+      );
+    });
+
+    it.skip('is unequal for different nest/extend blocks', async () => {
+      const query = `
+        run: duckdb.sql("SELECT 1 as one") -> {
+          nest: a is {
+            extend: {
+              dimension: three is 3
+            }
+            group_by: three
+          }
+          nest: b is {
+            extend: {
+              dimension: three is 4
+            }
+            group_by: three
+          }
+        }
+      `;
+
+      const result = await runtime.loadQuery(query).run();
+      const actual = referenceId(result.data.path(0, 'a', 0, 'three').field);
+      expect(actual).not.toBeUndefined();
+      expect(referenceId(result.data.path(0, 'b', 0, 'three').field)).toBe(
+        actual
+      );
+    });
+  });
+});
+
+afterAll(async () => {
+  await dbs.closeAll();
+});