Merge branch 'master' into feat-suboptimal-which-do-not-use-all-dimensions

Author: RusovDmitriy

.github/workflows/master.yml

@@ -11,6 +11,9 @@ on:
       - 'package.json'
       - 'rollup.config.js'
       - 'yarn.lock'
+      - 'rust/cubesqlplanner/**'
+      - 'rust/cubenativeutils/**'
+      - 'rust/cubesql/**'
     branches:
       - master
 jobs:

.github/workflows/rust-cubesql.yml

@@ -40,13 +40,16 @@ jobs:
           key: cubesql-${{ runner.OS }}-x86_64-unknown-linux-gnu
           shared-key: cubesql-${{ runner.OS }}-x86_64-unknown-linux-gnu
       - name: Lint CubeSQL
-        run: cd rust/cubesql/cubesql && cargo fmt --all -- --check
+        run: cd rust/cubesql && cargo fmt --all -- --check
       - name: Lint Native
         run: cd packages/cubejs-backend-native && cargo fmt --all -- --check
+      # TODO replace with clippy once cubesql is ready
+      - name: Check CubeSQL
+        run: cd rust/cubesql && cargo check --locked --workspace --all-targets --keep-going
       - name: Clippy Native
-        run: cd packages/cubejs-backend-native && cargo clippy -- -D warnings
+        run: cd packages/cubejs-backend-native && cargo clippy --locked --workspace --all-targets --keep-going -- -D warnings
       - name: Clippy Native (with Python)
-        run: cd packages/cubejs-backend-native && cargo clippy --features python -- -D warnings
+        run: cd packages/cubejs-backend-native && cargo clippy --locked --workspace --all-targets --keep-going --features python -- -D warnings
       # CubeSQL is not ready for Clippy
       #- name: Clippy CubeSQL
       #  run: cd rust/cubesql && cargo clippy -- -D warnings

docs/pages/product/apis-integrations.mdx

@@ -38,6 +38,13 @@ queries][ref-graphql-syntax].
 
 For AI use cases, consider using the [AI API][ref-ai-api].
 
+<ReferenceBox>
+
+See this [GitHub issue](https://github.com/cube-js/cube/issues/1744#issuecomment-2291680777)
+for an unofficial, community-maintained [client library for Python](https://github.com/mharrisb1/cube-http-client).
+
+</ReferenceBox>
+
 ## Management APIs
 
 In case you'd like Cube to work with data orchestration tools and let them push

docs/pages/reference/data-model/context-variables.mdx

@@ -323,13 +323,6 @@ in your Cube queries, incorrect SQL might be generated.
 
 </WarningBox>
 
-<ReferenceBox>
-
-Currently, `FILTER_GROUP` is not supported in YAML-based data models.
-Please [track this issue](https://github.com/cube-js/cube/issues/8508).
-
-</ReferenceBox>
-
 `FILTER_GROUP` has to be a top-level expression in `WHERE` and it has the
 following syntax:
 

packages/cubejs-backend-native/src/utils.rs

@@ -27,7 +27,7 @@ pub fn bind_method<'a>(
 
 pub fn batch_to_rows(batch: RecordBatch) -> Result<(Value, Vec<Value>), CubeError> {
     let schema = batch.schema();
-    let data_frame = dataframe::batch_to_dataframe(&schema, &vec![batch])?;
+    let data_frame = dataframe::batches_to_dataframe(&schema, vec![batch])?;
 
     let columns = serde_json::to_value(data_frame.get_columns())?;
     let rows = data_frame

packages/cubejs-schema-compiler/src/parser/PythonParser.ts

@@ -18,6 +18,7 @@ import {
   VarargslistContext,
   LambdefContext,
   Single_string_template_atomContext,
+  ArglistContext,
 } from './Python3Parser';
 import { UserError } from '../compiler/UserError';
 import { Python3ParserVisitor } from './Python3ParserVisitor';
@@ -178,7 +179,9 @@ export class PythonParser {
           const name = node.NAME();
           const argsList = node.arglist();
           if (argsList) {
-            return { call: children };
+            // trailer with arglist have a single child: arguments _list_
+            const args = children[0];
+            return { call: args };
           } else if (name) {
             return { identifier: t.identifier(name.text) };
           } else {
@@ -195,6 +198,8 @@ export class PythonParser {
           return { args: children };
         } else if (node instanceof LambdefContext) {
           return t.arrowFunctionExpression(children[0].args, children[1]);
+        } else if (node instanceof ArglistContext) {
+          return children;
         } else {
           return singleNodeReturn();
         }

packages/cubejs-schema-compiler/test/unit/base-query.test.ts

@@ -858,6 +858,132 @@ describe('SQL Generation', () => {
       expect(cubeSQL).toMatch(/\(\s*\(.*type\s*=\s*\$\d\$.*OR.*type\s*=\s*\$\d\$.*\)\s*AND\s*\(.*type\s*=\s*\$\d\$.*OR.*type\s*=\s*\$\d\$.*\)\s*\)/);
     });
   });
+
+  describe('FILTER_GROUP', () => {
+    /** @type {Compilers} */
+    const compilers = prepareYamlCompiler(
+      createSchemaYaml({
+        cubes: [
+          {
+            name: 'Order',
+            sql: `select * from order where {FILTER_GROUP(
+              FILTER_PARAMS.Order.dim0.filter('dim0'),
+              FILTER_PARAMS.Order.dim1.filter('dim1')
+            )}`,
+            measures: [{
+              name: 'count',
+              type: 'count',
+            }],
+            dimensions: [
+              {
+                name: 'dim0',
+                sql: 'dim0',
+                type: 'string'
+              },
+              {
+                name: 'dim1',
+                sql: 'dim1',
+                type: 'string'
+              }
+            ]
+          },
+        ]
+      })
+    );
+
+    it('inserts "or" filter', async () => {
+      await compilers.compiler.compile();
+      const query = new BaseQuery(compilers, {
+        measures: ['Order.count'],
+        filters: [
+          {
+            or: [
+              {
+                member: 'Order.dim0',
+                operator: 'equals',
+                values: ['val0'],
+              },
+              {
+                member: 'Order.dim1',
+                operator: 'equals',
+                values: ['val1'],
+              },
+            ]
+          }
+        ],
+      });
+      const cubeSQL = query.cubeSql('Order');
+      expect(cubeSQL).toContain('where (((dim0 = $0$) OR (dim1 = $1$)))');
+    });
+
+    it('inserts "and" filter', async () => {
+      await compilers.compiler.compile();
+      const query = new BaseQuery(compilers, {
+        measures: ['Order.count'],
+        filters: [
+          {
+            and: [
+              {
+                member: 'Order.dim0',
+                operator: 'equals',
+                values: ['val0'],
+              },
+              {
+                member: 'Order.dim1',
+                operator: 'equals',
+                values: ['val1'],
+              },
+            ]
+          }
+        ],
+      });
+      const cubeSQL = query.cubeSql('Order');
+      expect(cubeSQL).toContain('where (((dim0 = $0$) AND (dim1 = $1$)))');
+    });
+
+    it('inserts "or + and" filter', async () => {
+      await compilers.compiler.compile();
+      const query = new BaseQuery(compilers, {
+        measures: ['Order.count'],
+        filters: [
+          {
+            or: [
+              {
+                and: [
+                  {
+                    member: 'Order.dim0',
+                    operator: 'equals',
+                    values: ['val0'],
+                  },
+                  {
+                    member: 'Order.dim1',
+                    operator: 'equals',
+                    values: ['val1'],
+                  }
+                ]
+              },
+              {
+                and: [
+                  {
+                    member: 'Order.dim0',
+                    operator: 'equals',
+                    values: ['another_val0'],
+                  },
+                  {
+                    member: 'Order.dim1',
+                    operator: 'equals',
+                    values: ['another_val1'],
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      });
+      const cubeSQL = query.cubeSql('Order');
+      expect(cubeSQL).toContain('where ((((dim0 = $0$) AND (dim1 = $1$)) OR ((dim0 = $2$) AND (dim1 = $3$))))');
+    });
+  });
 });
 
 describe('Class unit tests', () => {

rust/cubesql/cubesql/benches/large_model.rs

@@ -20,8 +20,8 @@ use uuid::Uuid;
 macro_rules! bench_large_model {
     ($DIMS:expr, $NAME:expr, $QUERY_FN:expr, $CRITERION:expr) => {{
         let context = Arc::new(
-            futures::executor::block_on(create_test_cube_context(
-                create_test_postgresql_cube_context($DIMS),
+            futures::executor::block_on(create_test_postgresql_cube_context(
+                get_large_model_test_tenant_ctx($DIMS),
             ))
             .unwrap(),
         );