@malloydata/malloy-tests 0.0.202 → 0.0.203-dev241021171612

package/package.json

@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.202",
-    "@malloydata/db-duckdb": "^0.0.202",
-    "@malloydata/db-postgres": "^0.0.202",
-    "@malloydata/db-snowflake": "^0.0.202",
-    "@malloydata/db-trino": "^0.0.202",
-    "@malloydata/malloy": "^0.0.202",
-    "@malloydata/render": "^0.0.202",
+    "@malloydata/db-bigquery": "^0.0.203-dev241021171612",
+    "@malloydata/db-duckdb": "^0.0.203-dev241021171612",
+    "@malloydata/db-postgres": "^0.0.203-dev241021171612",
+    "@malloydata/db-snowflake": "^0.0.203-dev241021171612",
+    "@malloydata/db-trino": "^0.0.203-dev241021171612",
+    "@malloydata/malloy": "^0.0.203-dev241021171612",
+    "@malloydata/render": "^0.0.203-dev241021171612",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -37,5 +37,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.202"
+  "version": "0.0.203-dev241021171612"
 }

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

@@ -59,212 +59,247 @@ afterAll(async () => {
   await runtimes.closeAll();
 });
 
-describe('join expression tests', () => {
-  runtimes.runtimeMap.forEach((runtime, database) => {
-    const joinModelText = modelText(database);
-    const joinModel = runtime.loadModel(joinModelText);
-    it(`model source refine join - ${database}`, async () => {
-      await expect(`
-        source: a2 is aircraft extend {
-          join_one: aircraft_models with aircraft_model_code
-        }
-        run: a2 -> {
-          aggregate:
-            aircraft_count
-            aircraft_models.model_count
-        }
-      `).malloyResultMatches(joinModel, {model_count: 1416});
-    });
+describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
+  const joinModel = runtime.loadModel(modelText(databaseName));
 
-    it(`model source refine in query join - ${database}`, async () => {
-      await expect(`
-        run: aircraft extend {
-          join_one: aircraft_models with aircraft_model_code
-        } -> {
-          aggregate:
-            aircraft_count
-            aircraft_models.model_count
-        }
-      `).malloyResultMatches(joinModel, {model_count: 1416});
-    });
+  it('model source refine join', async () => {
+    await expect(`
+      source: a2 is aircraft extend {
+        join_one: aircraft_models with aircraft_model_code
+      }
+      run: a2 -> {
+        aggregate:
+          aircraft_count
+          aircraft_models.model_count
+      }
+    `).malloyResultMatches(joinModel, {model_count: 1416});
+  });
 
-    it(`model: join fact table query - ${database}`, async () => {
-      await expect(`
-        run: aircraft_models extend {
-          join_one: am_facts is
-            aircraft_models->{
-              group_by: m is manufacturer
-              aggregate: num_models is count()
-            } with manufacturer
-        } -> {
-          select:
-            manufacturer
-            am_facts.num_models
-          order_by: 2 desc
-          limit: 1
-        }
-      `).malloyResultMatches(joinModel, {num_models: 1147});
-    });
+  it('model source refine in query join', async () => {
+    await expect(`
+      run: aircraft extend {
+        join_one: aircraft_models with aircraft_model_code
+      } -> {
+        aggregate:
+          aircraft_count
+          aircraft_models.model_count
+      }
+    `).malloyResultMatches(joinModel, {model_count: 1416});
+  });
 
-    it(`model: source based on query - ${database}`, async () => {
-      await expect(`
-        run: aircraft_models
-          -> {
+  it('model: join fact table query', async () => {
+    await expect(`
+      run: aircraft_models extend {
+        join_one: am_facts is
+          aircraft_models->{
             group_by: m is manufacturer
             aggregate: num_models is count()
-          } -> {
-            select:
-            m
-            num_models
-            order_by: 2 desc
-            limit: 1
-          }
-      `).malloyResultMatches(joinModel, {num_models: 1147});
-    });
+          } with manufacturer
+      } -> {
+        select:
+          manufacturer
+          am_facts.num_models
+        order_by: 2 desc
+        limit: 1
+      }
+    `).malloyResultMatches(joinModel, {num_models: 1147});
+  });
 
-    it(`model: funnel - merge two queries - ${database}`, async () => {
-      await expect(`
-        run: aircraft_models->{
+  it('model: source based on query', async () => {
+    await expect(`
+      run: aircraft_models
+        -> {
           group_by: m is manufacturer
           aggregate: num_models is count()
-          } extend {
-            join_one: seats is
-              aircraft_models->{
-                group_by: m is manufacturer
-                aggregate: total_seats is seats.sum()
-              } with m
-          } -> {
-            select:
-              m
-              num_models
-              seats.total_seats
-            order_by: 2 desc
-            limit: 1
-          }
-      `).malloyResultMatches(joinModel, {
-        num_models: 1147,
-        total_seats: 252771,
-      });
-    });
-
-    it(`model: modeled funnel - ${database}`, async () => {
-      await expect(`
-        run: aircraft_models-> manufacturer_models extend {
-          join_one: seats is aircraft_models->manufacturer_seats with manufacturer
         } -> {
           select:
-            manufacturer,
-            num_models,
-            seats.total_seats
+          m
+          num_models
           order_by: 2 desc
           limit: 1
         }
-      `).malloyResultMatches(joinModel, {
-        num_models: 1147,
-        total_seats: 252771,
-      });
-    });
+    `).malloyResultMatches(joinModel, {num_models: 1147});
+  });
 
-    it(`model: modeled funnel2 - ${database}`, async () => {
-      await expect(`
-        run: funnel->{
+  it('model: funnel - merge two queries', async () => {
+    await expect(`
+      run: aircraft_models->{
+        group_by: m is manufacturer
+        aggregate: num_models is count()
+        } extend {
+          join_one: seats is
+            aircraft_models->{
+              group_by: m is manufacturer
+              aggregate: total_seats is seats.sum()
+            } with m
+        } -> {
           select:
-          manufacturer
+            m
             num_models
             seats.total_seats
           order_by: 2 desc
           limit: 1
         }
-      `).malloyResultMatches(joinModel, {
-        num_models: 1147,
-        total_seats: 252771,
-      });
+    `).malloyResultMatches(joinModel, {
+      num_models: 1147,
+      total_seats: 252771,
     });
+  });
 
-    it(`model: double_pipe - ${database}`, async () => {
-      await expect(`
-        run: aircraft_models->{
-          group_by: manufacturer
-          aggregate: f is count()
-        }->{
-          aggregate: f_sum is f.sum()
-        }->{
-          select: f_sum2 is f_sum+1
-        }
-    `).malloyResultMatches(joinModel, {f_sum2: 60462});
+  it('model: modeled funnel', async () => {
+    await expect(`
+      run: aircraft_models-> manufacturer_models extend {
+        join_one: seats is aircraft_models->manufacturer_seats with manufacturer
+      } -> {
+        select:
+          manufacturer,
+          num_models,
+          seats.total_seats
+        order_by: 2 desc
+        limit: 1
+      }
+    `).malloyResultMatches(joinModel, {
+      num_models: 1147,
+      total_seats: 252771,
     });
+  });
 
-    test.when(
-      runtime.supportsNesting && runtime.dialect.supportsLeftJoinUnnest
-    )(`model: unnest is left join - ${database}`, async () => {
-      await expect(`
-          // produce a table with 4 rows that has a nested element
-          query: a_states is ${database}.table('malloytest.state_facts')-> {
-          where: state ? ~ 'A%'
-            group_by: state
-            nest: somthing is {group_by: state}
-          }
-
-          // join the 4 rows and reference the
-          //  nested column. should return all the rows.
-          //  If the unnest is an inner join, we'll get back just 4 rows.
-          run: ${database}.table('malloytest.state_facts') extend {
-            join_one: a_states is a_states with state
-          }
-          -> {
-            group_by: state
-            aggregate: c is count()
-            nest: a is  {
-              group_by: a_states.somthing.state
-            }
-            limit: 5
-          }
-        `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
+  it('model: modeled funnel2', async () => {
+    await expect(`
+      run: funnel->{
+        select:
+        manufacturer
+          num_models
+          seats.total_seats
+        order_by: 2 desc
+        limit: 1
+      }
+    `).malloyResultMatches(joinModel, {
+      num_models: 1147,
+      total_seats: 252771,
     });
+  });
 
-    // not sure how to solve this one yet, just check for > 4 rows
-    it(`All joins at the same level - ${database}`, async () => {
+  it('model: double_pipe', async () => {
+    await expect(`
+      run: aircraft_models->{
+        group_by: manufacturer
+        aggregate: f is count()
+      }->{
+        aggregate: f_sum is f.sum()
+      }->{
+        select: f_sum2 is f_sum+1
+      }
+  `).malloyResultMatches(joinModel, {f_sum2: 60462});
+  });
+
+  test.when(runtime.supportsNesting && runtime.dialect.supportsLeftJoinUnnest)(
+    'model: unnest is left join',
+    async () => {
       await expect(`
-        source: flights is ${database}.table('malloytest.flights') extend {
-          join_one: aircraft is ${database}.table('malloytest.aircraft')
-            on tail_num = aircraft.tail_num
-          join_one: aircraft_models is ${database}.table('malloytest.aircraft_models')
-            on aircraft.aircraft_model_code = aircraft_models.aircraft_model_code
+        // produce a table with 4 rows that has a nested element
+        query: a_states is ${databaseName}.table('malloytest.state_facts')-> {
+        where: state ? ~ 'A%'
+          group_by: state
+          nest: somthing is {group_by: state}
         }
 
-        run: flights -> {
-          group_by: aircraft_models.seats
-          aggregate: flight_count is count()
+        // join the 4 rows and reference the
+        //  nested column. should return all the rows.
+        //  If the unnest is an inner join, we'll get back just 4 rows.
+        run: ${databaseName}.table('malloytest.state_facts') extend {
+          join_one: a_states is a_states with state
+        }
+        -> {
+          group_by: state
+          aggregate: c is count()
+          nest: a is  {
+            group_by: a_states.somthing.state
+          }
           limit: 5
         }
       `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
-    });
+    }
+  );
 
-    it(`join issue440 - ${database}`, async () => {
-      await expect(`
-        source: aircraft_models is ${database}.table('malloytest.aircraft_models')
+  // not sure how to solve this one yet, just check for > 4 rows
+  it('All joins at the same level', async () => {
+    await expect(`
+      source: flights is ${databaseName}.table('malloytest.flights') extend {
+        join_one: aircraft is ${databaseName}.table('malloytest.aircraft')
+          on tail_num = aircraft.tail_num
+        join_one: aircraft_models is ${databaseName}.table('malloytest.aircraft_models')
+          on aircraft.aircraft_model_code = aircraft_models.aircraft_model_code
+      }
 
-        source: aircraft is ${database}.table('malloytest.aircraft')
+      run: flights -> {
+        group_by: aircraft_models.seats
+        aggregate: flight_count is count()
+        limit: 5
+      }
+    `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
+  });
 
-        source: flights is ${database}.table('malloytest.flights') extend {
-          join_one: aircraft on aircraft.tail_num = tail_num
-          join_one: aircraft_models on aircraft_models.aircraft_model_code = aircraft.aircraft_model_code
-        }
+  it('join issue440', async () => {
+    await expect(`
+      source: aircraft_models is ${databaseName}.table('malloytest.aircraft_models')
 
-        run: flights-> {
-          group_by: testingtwo is aircraft_models.model
-          limit: 5
-        }
-      `).malloyResultMatches(runtime, [{}, {}, {}, {}, {}]);
-    });
+      source: aircraft is ${databaseName}.table('malloytest.aircraft')
 
-    it(`join issue1092 - ${database}`, async () => {
-      await expect(`
-        run: ${database}.table('malloytest.state_facts') -> {
-          extend: {join_one: sf is ${database}.table('malloytest.state_facts') on sf.state = state}
-          aggregate: x is sf.births.sum() { where:  state = 'CA' }
+      source: flights is ${databaseName}.table('malloytest.flights') extend {
+        join_one: aircraft on aircraft.tail_num = tail_num
+        join_one: aircraft_models on aircraft_models.aircraft_model_code = aircraft.aircraft_model_code
+      }
+
+      run: flights-> {
+        group_by: testingtwo is aircraft_models.model
+        limit: 5
+      }
+    `).malloyResultMatches(runtime, [{}, {}, {}, {}, {}]);
+  });
+
+  it('join issue1092', async () => {
+    await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        extend: {join_one: sf is ${databaseName}.table('malloytest.state_facts') on sf.state = state}
+        aggregate: x is sf.births.sum() { where:  state = 'CA' }
+      }
+    `).malloyResultMatches(runtime, [{}]);
+  });
+
+  it('always join in query', async () => {
+    await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        join_cross: x is ${databaseName}.table('malloytest.state_facts') on true
+        select: x is 1
+      } -> {
+        aggregate: c is count()
+      }
+    `).malloyResultMatches(joinModel, {c: 51 * 51});
+  });
+
+  it('not always join in extend', async () => {
+    await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        extend: {
+          join_cross: x is ${databaseName}.table('malloytest.state_facts') on true
         }
-      `).malloyResultMatches(runtime, [{}]);
-    });
+        select: x is 1
+      } -> {
+        aggregate: c is count()
+      }
+    `).malloyResultMatches(joinModel, {c: 51});
+  });
+
+  it('always inner join has side effects (in group_by)', async () => {
+    await expect(`
+      ##! experimental.join_types
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        join_cross: x is ${databaseName}.table('malloytest.state_facts') inner on false
+        group_by: x is 1
+      } -> {
+        aggregate: c is count()
+      }
+    `).malloyResultMatches(joinModel, {c: 0});
   });
 });