WL#15133, BUG#29178528: narrow expression parser responsability

The X DevAPI expression parser is performing two different duties when
it should only have a single responsability. In this case, besides
parsing an expression string, it also creates the corresponding protobuf
message instance using the available protocol stubs.

From an architectural standpoint, the parser should be an isolated
component and should not have to know about the existence of an
underlying protocol. Additionally the parser output should not be tied
to a format defined by a 3rd-party library.

This patch narrows the job of the expression parser component to the
single responsability of parsing expression strings and returning a
basic structured output and moves, to the protocol stub adapters, the
responsability of actually encoding the resulting protobuf message
instances. As a result, it also decouples the parser from the protocol
itself and from the custom restricted format specified by the
google-protobuf library.

As a consequence of the structural changes in the expression parser,
some of its known limitations have also been addressed. In particular,
the one described by BUG#29178528.

Change-Id: I1550ac72ee288864eaada69e6630d2441274b3a0

Author: ruiquelhas

lib/ExprParser/index.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as

lib/ExprParser/lib/grammar/booleanExpressions/addSubExpr.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -30,22 +30,32 @@
 
 'use strict';
 
-const binaryOpMapper = require('../../mappers/binaryOperator');
+const binaryOperatorMapper = require('../../mappers/binaryOperator');
 const Pa = require('parsimmon');
 
-const parser = options => r => Pa
-    .seq(
-        r.mulDivExpr,
-        Pa
-            .seq(
-                Pa.optWhitespace,
-                Pa.alt(Pa.string('+'), Pa.string('-')),
-                Pa.optWhitespace,
-                r.mulDivExpr
-            )
-            .map(data => ({ operand: data[3], operator: data[1] }))
-            .many()
-    )
-    .map(binaryOpMapper);
+const PARSER_OPTIONS = {
+    ID: 'addSubExpr',
+    NAME: 'ADD_SUB_EXPR'
+};
 
-module.exports = { name: 'ADD_SUB_EXPR', parser };
+const arithmeticOperator = Pa.alt(
+    Pa.string('+'),
+    Pa.string('-')
+);
+
+/**
+ * Sub-parser that matches addition and subtraction operator expressions.
+ * addSubExpr ::= mulDivExpr ( ( '+' | '-' ) mulDivExpr )*
+ * @private
+ * @param {Object} [_] - Optional object containing parser options.
+ * @returns The generated grammar for the parser.
+ * @see https://dev.mysql.com/doc/x-devapi-userguide/en/mysql-x-expressions-ebnf-definitions.html#expression-ebnf-addsubexpr
+ * @example
+ * 1 + 1
+ * 3 - 2
+ */
+const parser = _ => r => Pa
+    .seq(r.mulDivExpr, Pa.seq(arithmeticOperator.trim(Pa.optWhitespace), r.mulDivExpr).map(([name, param]) => ({ name, params: [param] })).many())
+    .map(([one, more]) => !more.length ? one : binaryOperatorMapper({ type: PARSER_OPTIONS.ID, one, more }));
+
+module.exports = { name: PARSER_OPTIONS.NAME, parser };

lib/ExprParser/lib/grammar/booleanExpressions/andExpr.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -30,17 +30,26 @@
 
 'use strict';
 
-const binaryOpMapper = require('../../mappers/binaryOperator');
+const binaryOperatorMapper = require('../../mappers/binaryOperator');
 const Pa = require('parsimmon');
 
-const parser = options => r => Pa
-    .seq(
-        r.ilriExpr,
-        Pa
-            .seq(Pa.whitespace, r.AND, Pa.whitespace, r.ilriExpr)
-            .map(data => ({ operand: data[3], operator: data[1] }))
-            .many()
-    )
-    .map(binaryOpMapper);
+const PARSER_OPTIONS = {
+    ID: 'andExpr',
+    NAME: 'AND_EXPR'
+};
 
-module.exports = { name: 'AND_EXPR', parser };
+/**
+ * Sub-parser that matches composable expressions with the AND (or "&&") operator.
+ * andExpr ::= ilriExpr ( ( '&&' | 'AND' ) ilriExpr )*
+ * @private
+ * @param {Object} [_] - Optional object containing parser options.
+ * @returns The generated grammar for the parser.
+ * @see https://dev.mysql.com/doc/x-devapi-userguide/en/mysql-x-expressions-ebnf-definitions.html#expression-ebnf-andexpr
+ * @example
+ * x = :x AND y + y = 5
+ */
+const parser = _ => r => Pa
+    .seq(r.ilriExpr, Pa.seq(r.AND.trim(Pa.whitespace), r.ilriExpr).map(([name, param]) => ({ name, params: [param] })).many())
+    .map(([one, more]) => !more.length ? one : binaryOperatorMapper({ type: PARSER_OPTIONS.ID, one, more }));
+
+module.exports = { name: PARSER_OPTIONS.NAME, parser };

lib/ExprParser/lib/grammar/booleanExpressions/argsList.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -32,14 +32,25 @@
 
 const Pa = require('parsimmon');
 
-const parser = options => r => Pa
-    .seq(
-        r.expr.map(data => data.output),
-        Pa
-            .seq(Pa.optWhitespace, Pa.string(','), Pa.optWhitespace, r.expr.map(data => data.output))
-            .map(data => data[3])
-            .many()
-    )
-    .map(data => [data[0]].concat(data[1]));
+const PARSER_OPTIONS = {
+    ID: 'argsList',
+    NAME: 'ARGS_LIST'
+};
 
-module.exports = { name: 'ARG_LIST', parser };
+/**
+ * Sub-parser that matches a comma-separated list of expressions.
+ * argsList ::= expr ( ',' expr )*
+ * @private
+ * @param {Object} [_] - Optional object containing parser options.
+ * @returns The generated grammar for the parser.
+ * @see https://dev.mysql.com/doc/x-devapi-userguide/en/mysql-x-expressions-ebnf-definitions.html#expression-ebnf-argslist
+ * @example
+ * 'foo', TRUE, :x, 1.234
+ */
+const parser = _ => r => r.expr
+    .sepBy(Pa.seq(Pa.optWhitespace, Pa.string(','), Pa.optWhitespace))
+    // TODO(Rui): for now we will be extracting the value from the
+    // corresponding expressions but the parser output should be standardized.
+    .map(exprs => ({ type: PARSER_OPTIONS.ID, value: exprs.map(e => e.value) }));
+
+module.exports = { name: PARSER_OPTIONS.NAME, parser };

lib/ExprParser/lib/grammar/booleanExpressions/atomicExpr.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -30,28 +30,37 @@
 
 'use strict';
 
-const Expr = require('../../../../Protocol/Stubs/mysqlx_expr_pb').Expr;
 const Pa = require('parsimmon');
 
-const parser = options => r => Pa
-    .alt(
-        r.literal
-            .map(data => data.output)
-            .map(data => {
-                const expr = new Expr();
-                expr.setType(Expr.Type.LITERAL);
-                expr.setLiteral(data);
+const PARSER_OPTIONS = {
+    ID: 'atomicExpr',
+    NAME: 'ATOMIC_EXPR'
+};
 
-                return expr;
-            }),
-        r.jsonArray,
-        r.jsonDoc,
-        r.groupedExpr,
-        r.placeholder,
-        r.unaryOp,
-        r.castOp,
-        r.functionCall,
-        r.columnOrPath
-    );
+/**
+ * Sub-parser that matches an atomic expression.
+ * atomicExpr   ::= placeholder
+ *              | columnOrPath
+ *              | functionCall
+ *              | groupedExpr
+ *              | unaryOp
+ *              | castOp
+ * @private
+ * @param {Object} [_] - Optional object containing parser options.
+ * @returns The generated grammar for the parser.
+ * @see https://dev.mysql.com/doc/x-devapi-userguide/en/mysql-x-expressions-ebnf-definitions.html#expression-ebnf-atomicexpr
+ * @example
+ * literals: 'foo', 1, 1.234, TRUE, NULL
+ * jsonArray: ['foo', 1, 1.234, TRUE, NULL, { "bar": "baz" }, ["qux", "quux"]]
+ * jsonDoc: { 'foo': 1, 'baz': { 'baz': 1.234 }, 'qux': ['quux'] }
+ * groupedExpr: (x = :v1 OR y = :v2) AND z = :v3
+ * placeholder: :x
+ * unaryOp: !TRUE
+ * castOp: CAST(foo AS CHAR(3))
+ * functionCall: foo(bar("baz"))
+ * columnOrPath: foo.bar.*, foo.bar->>'$.baz.qux'
+ */
+const parser = _ => r => Pa
+    .alt(r.literal, r.jsonArray, r.jsonDoc, r.groupedExpr, r.placeholder, r.unaryOp, r.castOp, r.functionCall, r.columnOrPath);
 
-module.exports = { name: 'ATOMIC_EXPR', parser };
+module.exports = { name: PARSER_OPTIONS.NAME, parser };

lib/ExprParser/lib/grammar/booleanExpressions/bitExpr.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -30,22 +30,28 @@
 
 'use strict';
 
-const binaryOpMapper = require('../../mappers/binaryOperator');
+const binaryOperatorMapper = require('../../mappers/binaryOperator');
 const Pa = require('parsimmon');
 
-const parser = options => r => Pa
-    .seq(
-        r.shiftExpr,
-        Pa
-            .seq(
-                Pa.optWhitespace,
-                Pa.alt(Pa.string('&'), Pa.string('|'), Pa.string('^')),
-                Pa.optWhitespace,
-                r.shiftExpr
-            )
-            .map(data => ({ operand: data[3], operator: data[1] }))
-            .many()
-    )
-    .map(binaryOpMapper);
+const PARSER_OPTIONS = {
+    ID: 'bitExpr',
+    NAME: 'BIT_EXPR'
+};
 
-module.exports = { name: 'BIT_EXPR', parser };
+/**
+ * Sub-parser that matches a bitwise operator expression.
+ * bitExpr ::= shiftExpr ( ( '&' | '|' | '^' ) shiftExpr )*
+ * @private
+ * @param {Object} [_] - Optional object containing parser options.
+ * @returns The generated grammar for the parser.
+ * @see https://dev.mysql.com/doc/x-devapi-userguide/en/mysql-x-expressions-ebnf-definitions.html#expression-ebnf-bitexpr
+ * @example
+ * 1 & 1
+ * 1 | 0
+ * 0 ^ 1
+ */
+const parser = _ => r => Pa
+    .seq(r.xorBitExprPart, Pa.seq(Pa.string('|').trim(Pa.optWhitespace), r.xorBitExprPart).map(([name, param]) => ({ name, params: [param] })).many())
+    .map(([one, more]) => !more.length ? one : binaryOperatorMapper({ type: PARSER_OPTIONS.ID, one, more }));
+
+module.exports = { name: PARSER_OPTIONS.NAME, parser };

lib/ExprParser/lib/grammar/booleanExpressions/castOp.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -30,34 +30,25 @@
 
 'use strict';
 
-const Expr = require('../../../../Protocol/Stubs/mysqlx_expr_pb').Expr;
-const Operator = require('../../../../Protocol/Stubs/mysqlx_expr_pb').Operator;
 const Pa = require('parsimmon');
 
-const parser = options => r => Pa
-    .seq(
-        r.CAST,
-        Pa.string('('),
-        Pa.optWhitespace,
-        r.expr.map(data => data.output),
-        Pa.whitespace,
-        r.AS,
-        Pa.whitespace,
-        r.castType,
-        Pa.optWhitespace,
-        Pa.string(')')
-    )
-    .map(data => {
-        const operator = new Operator();
-        operator.setName(data[0]);
-        operator.addParam(data[3]);
-        operator.addParam(data[7]);
+const PARSER_OPTIONS = {
+    ID: 'castOp',
+    NAME: 'CAST_OP'
+};
 
-        const expr = new Expr();
-        expr.setType(Expr.Type.OPERATOR);
-        expr.setOperator(operator);
-
-        return expr;
-    });
+/**
+ * Sub-parser that matches a cast function.
+ * castOp ::= 'CAST' '(' expr 'AS' castType ')'
+ * @private
+ * @param {Object} [_] - Optional object containing parser options.
+ * @returns The generated grammar for the parser.
+ * @see https://dev.mysql.com/doc/x-devapi-userguide/en/mysql-x-expressions-ebnf-definitions.html#expression-ebnf-castop
+ * @example
+ * CAST(foo AS CHAR(3))
+ */
+const parser = _ => r => Pa.seqMap(r.CAST, Pa.seq(r.expr.map(({ value }) => value).skip(Pa.seq(Pa.whitespace, r.AS, Pa.whitespace)), r.castType).trim(Pa.optWhitespace).wrap(Pa.string('('), Pa.string(')')), (name, params) => {
+    return { type: PARSER_OPTIONS.ID, value: { name, params } };
+});
 
-module.exports = { name: 'CAST_OP', parser };
+module.exports = { name: PARSER_OPTIONS.NAME, parser };