feat(cubejs-schema-compiler): Support FILTER_GROUP in YAML models (#8574)

Add arglist node handling in transpiler, allows to generate function calls with multiple arguments, like FILTER_GROUP

Remove disclaimer from the docs

---------

Co-authored-by: Igor Lukanin <[email protected]>

Author: mcheshkov

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-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', () => {