@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/transform/db/views.js

@@ -247,14 +247,14 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
     if (isUnion(queryPath) && options.transformation === 'hdbcds') {
       if (isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J) {
         if (elem.keys)
-          info(null, queryPath, `Managed association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, { name: elemName }, 'Managed association $(NAME), published in a UNION, will be ignored');
         else
-          info(null, queryPath, `Association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, { name: elemName }, 'Association $(NAME), published in a UNION, will be ignored');
 
         elem._ignore = true;
       }
       else {
-        error(null, queryPath, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
+        error(null, queryPath, { name: elemName }, 'Association $(NAME) can\'t be published in a SAP HANA CDS UNION');
       }
     }
     else if (queryPath.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
@@ -325,17 +325,40 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
    * due to an issue with HANA - only for hdbcds-hdbcds, I assume flattening
    * takes care of this for the other cases already
    *
-   * @param {CSN.Query} query
+   * @param {CSN.Column} col
    * @param {CSN.Path} path
    */
-  function addImplicitAliasWithAssoc(query, path) {
-    for (let i = 0; i < query.SELECT.columns.length; i++) {
-      const col = query.SELECT.columns[i];
-      if (!col.as && col.ref && col.ref.length > 1) {
-        const { links } = inspectRef(path.concat([ 'columns', i ]));
-        if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
-          col.as = getLastRefStepString(col.ref);
-      }
+  function addImplicitAliasWithAssoc(col, path) {
+    if (!col.as && col.ref && col.ref.length > 1) {
+      const { links } = inspectRef(path);
+      if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
+        col.as = getLastRefStepString(col.ref);
+    }
+  }
+
+  /**
+   * If simply selecting from a param like `:param`, we need to add an implicit alias like `:param as param`
+   * due to an issue with HANA
+   *
+   * @param {CSN.Column} col
+   */
+  function addImplicitAliasWithLonelyParam(col) {
+    if (!col.as && col.param)
+      col.as = getLastRefStepString(col.ref);
+  }
+
+
+  /**
+   * Loop over the columns and call all of the given functions with the column and the path
+   *
+   * @param {Function[]} functions
+   * @param {CSN.Column[]} columns
+   * @param {CSN.Path} path
+   */
+  function processColumns(functions, columns, path) {
+    for (let i = 0; i < columns.length; i++) {
+      const col = columns[i];
+      functions.forEach(fn => fn(col, path.concat(i)));
     }
   }
 
@@ -401,8 +424,14 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
       query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem]._ignore).map(key => stripLeadingSelf(columnMap[key]));
       // If following an association, explicitly set the implicit alias
       // due to an issue with HANA - this seems to only have an effect on ref files with hdbcds-hdbcds, so only run then
+      const columnProcessors = [];
+      if (options.transformation === 'hdbcds' || options.transformation === 'sql' && options.sqlDialect === 'hana')
+        columnProcessors.push(addImplicitAliasWithLonelyParam);
       if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')
-        addImplicitAliasWithAssoc(query, path);
+        columnProcessors.push(addImplicitAliasWithAssoc);
+
+      if (columnProcessors.length > 0)
+        processColumns(columnProcessors, query.SELECT.columns, path.concat('columns'));
 
       delete query.SELECT.excluding;  // just to make the output of the new transformer the same as the old
 

package/lib/transform/draft/db.js

@@ -165,8 +165,8 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
       }
 
       else {
-        error(null, [ 'definitions', draftRootName ], { name: persistenceName },
-              `Entity $(NAME) already generated by draft root "${definingDraftRoot}"`);
+        error(null, [ 'definitions', draftRootName ], { name: persistenceName, alias: definingDraftRoot },
+              'Entity $(NAME) already generated by draft root $(ALIAS)');
       }
 
       return;

package/lib/transform/forOdataNew.js

@@ -97,6 +97,7 @@ function transform4odataWithCsn(inputModel, options) {
     inspectRef,
     artifactRef,
     effectiveType,
+    getFinalBaseTypeWithProps
   } = csnUtils;
 
   // are we working with structured OData or not
@@ -123,7 +124,7 @@ function transform4odataWithCsn(inputModel, options) {
   addLocalizationViews(csn, options, { acceptLocalizedView, ignoreUnknownExtensions: true });
 
   const cleanup = validate.forOdata(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
+    message, error, warning, info, inspectRef, effectiveType, getFinalBaseTypeWithProps, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
   });
 
 
@@ -307,11 +308,13 @@ function transform4odataWithCsn(inputModel, options) {
       '@Capabilities.Readable': '@Capabilities.ReadRestrictions.Readable',
     }
 
+    const shortCuts = Object.keys(mappings);
     Object.keys(node).forEach( name => {
       // Rename according to map above
-      if (mappings[name] != undefined)
-        renameAnnotation(node, name, mappings[name]);
-
+      const prefix = shortCuts.find(p => name.startsWith(p + '.') || name === p);
+      if(prefix) {
+        renameAnnotation(node, name, name.replace(prefix, mappings[prefix]));
+      }
       // Special case: '@important: [true|false]' becomes '@UI.Importance: [#High|#Low]'
       if (name === '@important') {
         renameAnnotation(node, name, '@UI.Importance');
@@ -323,7 +326,7 @@ function transform4odataWithCsn(inputModel, options) {
       // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
       // but '@Core.Immutable' for everything else.
       if (!(node['@readonly'] && node['@insertonly'])) {
-        if (name === '@readonly' && node[name] !== null) {
+        if (name === '@readonly' && node[name]) {
           if (node.kind === 'entity' || node.kind === 'aspect') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
@@ -333,7 +336,7 @@ function transform4odataWithCsn(inputModel, options) {
           }
         }
         // @insertonly is effective on entities/queries only
-        else if (name === '@insertonly' && node[name] !== null) {
+        else if (name === '@insertonly' && node[name]) {
           if (node.kind === 'entity' || node.kind === 'aspect') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
@@ -342,7 +345,7 @@ function transform4odataWithCsn(inputModel, options) {
         }
       }
       // Only on element level: translate @mandatory
-      if (name === '@mandatory' && node[name] !== null &&
+      if (name === '@mandatory' && node[name] &&
         node.kind === undefined && node['@Common.FieldControl'] === undefined) {
         setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
       }

package/lib/transform/{forHanaNew.js → forRelationalDB.js}

@@ -93,14 +93,14 @@ function forEachDefinition(csn, cb) {
  * - (240) All artifacts (a), elements, foreign keys, parameters (b) that have a DB representation are annotated
  *         with their database name (as '@cds.persistence.name') according to the naming convention chosen
  *         in 'options.sqlMapping'.
- * - (250) Remove name space definitions again (only in forHanaNew). Maybe we can omit inserting namespace definitions
+ * - (250) Remove name space definitions again (only in forRelationalDB). Maybe we can omit inserting namespace definitions
  *         completely (TODO)
  *
  * @param {CSN.Model}   inputModel
  * @param {CSN.Options} options
  * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
  */
-function transformForHanaWithCsn(inputModel, options, moduleName) {
+function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
   /** @type {CSN.Model} */
@@ -131,7 +131,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     forEachDefinition(csn, handleMixinOnConditions);
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
-  const cleanup = validate.forHana(csn, {
+  const cleanup = validate.forRelationalDB(csn, {
     message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, isAspect
   });
 
@@ -310,7 +310,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
    * hence we do not generate the referential constraints for them.
    */
-  if((options.sqlDialect === 'hana' || options.sqlDialect === 'sqlite') && doA2J)
+  if(options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2' && doA2J)
     createReferentialConstraints(csn, options);
 
   // no constraints for drafts
@@ -398,7 +398,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   if(options.sqlDialect === 'postgres') {
     killers.length = (parent) => {
-      if (parent.type === 'cds.Binary' || parent.type === 'cds.hana.BINARY') {
+      if (parent.type === 'cds.Binary') {
         delete parent.length;
       }
     }
@@ -625,12 +625,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       }
       else if (options.sqlDialect === 'sqlite') { // view with params
         // Allow with plain
-        error(null, [ 'definitions', artifactName ], `SQLite does not support entities with parameters`);
+        error(null, [ 'definitions', artifactName ], 'SQLite does not support entities with parameters');
       }
       else {
         for (const pname in artifact.params) {
           if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be regular SQL identifier
-            warning(null, [ 'definitions', artifactName, 'params', pname ], `Expecting regular SQL-Identifier`);
+            warning(null, [ 'definitions', artifactName, 'params', pname ], 'Expecting regular SQL-Identifier');
           }
           else if (options.sqlMapping !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
             warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.sqlMapping },
@@ -704,6 +704,11 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       node.length = 36;
       setProp(node, '$renamed', 'cds.UUID');
     }
+
+    if(options.sqlDialect === 'h2' && val === 'cds.Decimal' && !node.scale) {
+      node[key] = 'cds.DecimalFloat'; // cds.Decimal and cds.Decimal(p) should map do DECFLOAT for h2
+    }
+
     // Length/Precision/Scale is done in addDefaultTypeFacets
   }
 
@@ -860,7 +865,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       // not to the view).
       // FIXME: This also means that corresponding key fields should be in the select list etc ...
       if (!art.query && !art.projection && assoc.target && assoc.target != artifactName)
-        error(null, path, `Only an association that points back to this artifact can be compared to "$self"`);
+        error(null, path, { name: '$self' }, 'Only an association that points back to this artifact can be compared to $(NAME)');
 
 
       // Check: The forward link <assocOp> must not contain '$self' in its own ON-condition
@@ -868,7 +873,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         const containsDollarSelf = assoc.on.some(isDollarSelfOrProjectionOperand);
 
         if (containsDollarSelf)
-          error(null, path, `An association that uses "$self" in its ON-condition can't be compared to "$self"`);
+          error(null, path, { name: '$self' },
+            'An association that uses $(NAME) in its ON-condition can\'t be compared to $(NAME)');
       }
 
       // Transform comparison of $self to managed association into AND-combined foreign key comparisons
@@ -983,7 +989,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         const absolute = node.type;
         const parameters = node.parameters || [];
         // :FIXME: Is this dead code? node.parameters is always undefined...
-        // forHana tested against the parameters of the type definition which is not available in CSN
+        // forRelationalDB tested against the parameters of the type definition which is not available in CSN
         for (const name in parameters) {
           const param = parameters[name];
           if (!node[param] && absolute !== 'cds.hana.ST_POINT' && absolute !== 'cds.hana.ST_GEOMETRY')
@@ -1086,7 +1092,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
                 else if (art.elements) {
                   // The reference is structured
                   if (isFulltextIndex)
-                    error(null, path, `"${ artName }": A fulltext index can't be defined on a structured element`);
+                    error(null, path, { name: artName }, 'A fulltext index can\'t be defined on a structured element $(NAME)');
                   // First, compute the name from the path, e.g ['s', 's1', 's2' ] will result in 'S_s1_s2' ...
                   const refPath = flattenStructStepsInRef(val.ref, path);
                   // ... and take this as the prefix for all elements
@@ -1124,5 +1130,5 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
 
 module.exports = {
-  transformForHanaWithCsn,
+  transformForRelationalDBWithCsn,
 };

package/lib/transform/localized.js

@@ -73,7 +73,7 @@ const _targetFor = Symbol('_targetFor');
  */
 function _addLocalizationViews(csn, options, useJoins, config) {
   // Don't try to create convenience views with errors.
-  if (hasErrors(options.messages))
+  if (hasErrors(options.messages)) // TODO: this is actually wrong, consider --test-mode
     return csn;
 
   const messageFunctions = makeMessageFunction(csn, options);
@@ -86,19 +86,8 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
-
-  forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
-
-  // In case that the user tried to annotate `localized.*` artifacts, apply them.
-  applyAnnotationsFromExtensions(csn, {
-    override: true,
-    filter: (name) => name.startsWith('localized.'),
-    notFound(name, index) {
-      if (!ignoreUnknownExtensions)
-        messageFunctions.message('anno-undefined-art', [ 'extensions', index ], { name })
-    },
-  });
-
+  cleanDefinitionSymbols();
+  applyAnnotationsForLocalizedViews();
   sortCsnDefinitionsForTests(csn, options);
   return csn;
 
@@ -196,7 +185,7 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
     for (const originalElement of textElements) {
       const elem = entity.elements[originalElement];
-      // Note: $key is used by forHanaNew.js to indicate that this element was a key in the original,
+      // Note: $key is used by forRelationalDB.js to indicate that this element was a key in the original,
       //      user's entity.  Keys may have been changed by the backends (e.g. by `@cds.valid.key`)
       if (!elem.key && !elem.$key)
         columns.push( createColumnLocalizedElement( originalElement, shouldUseJoin ) );
@@ -605,6 +594,27 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     // We can assume, that the element exists.  This is checked in isEntityPreprocessed()
     return csn.definitions[artName].elements.texts.target;
   }
+
+  function cleanDefinitionSymbols() {
+    forEachDefinition(csn, function cleanDefinition(definition) {
+      cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor);
+    });
+  }
+
+  /**
+   * In case that the user tried to annotate `localized.*` artifacts, apply them.
+   */
+  function applyAnnotationsForLocalizedViews() {
+    applyAnnotationsFromExtensions(csn, {
+      override: true,
+      filter: (name) => name.startsWith('localized.'),
+      notFound(name, index) {
+        if (!ignoreUnknownExtensions)
+          messageFunctions.message('anno-undefined-art', [ 'extensions', index ], { name })
+      },
+    });
+  }
+
 }
 
 /**
@@ -636,7 +646,7 @@ function addLocalizationViewsWithJoins(csn, options, config = {}) {
  * @param {string} [as] Alias for path.
  * @return {CSN.Column}
  */
-function createColumnRef(ref, as = null) {
+function createColumnRef(ref, as) {
   const column = { ref };
   if (as)
     column.as = as;
@@ -708,10 +718,9 @@ function hasExistingLocalizationViews(csn, options, messageFunctions) {
   let hasExistingViews = false;
   let hasNonViews = false;
 
-  for (const name in csn.definitions) {
-    const art = csn.definitions[name];
+  forEachDefinition(csn, (def, name) => {
     if (isInLocalizedNamespace(name) || name === 'localized') {
-      if (!art.query && !art.projection) {
+      if (!def.query && !def.projection) {
         if (!name.endsWith('.texts')) {
           hasNonViews = true;
           messageFunctions.error('reserved-namespace-localized', ['definitions', name], {},
@@ -723,7 +732,7 @@ function hasExistingLocalizationViews(csn, options, messageFunctions) {
           'Input CSN already contains localization views, no further ones will be created' );
       }
     }
-  }
+  });
   return hasExistingViews || hasNonViews;
 }
 

package/lib/transform/odata/toFinalBaseType.js

@@ -68,9 +68,9 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   // type Foo: array of { qux: Integer };
   function expandFirstLevelOfArrayed(def) {
     if (def.items.type && !isBuiltinType(def.items.type)) {
-      let finalType = csnUtils.getFinalTypeDef(def.items.type);
-      if (csnUtils.isStructured(finalType)) {
-        def.items.elements = cloneCsnDictionary(finalType.elements, options);
+      let finalBaseType = csnUtils.getFinalBaseTypeWithProps(def.items.type);
+      if (finalBaseType?.elements) {
+        def.items.elements = cloneCsnDictionary(finalBaseType.elements, options);
         delete def.items.type;
       }
     }
@@ -147,14 +147,11 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
         // handle array of defined via a named type
         // example in actions: 'action act() return Primitive; type Primitive: array of String;'
       const currService = csnUtils.getServiceName(defName);
-      const finalType = csnUtils.getFinalTypeDef(node.type);
-      if (finalType.items &&
-        (isBuiltinType(finalType.items.type) || isBuiltinType(csnUtils.getFinalBaseTypeWithProps(finalType.items.type)?.type)))
-      {
-        if (!isArtifactInService(node.type, currService) || !isV4) {
-          node.items = finalType.items;
-          delete node.type;
-        }
+      const finalType = csnUtils.getFinalBaseTypeWithProps(node.type);
+      const isArrayOfBuiltin = finalType?.items && isBuiltinType(csnUtils.getFinalBaseTypeWithProps(finalType.items.type)?.type)
+      if (isArrayOfBuiltin && (!isArtifactInService(node.type, currService) || !isV4)) {
+        node.items = finalType.items;
+        delete node.type;
       }
     }
 

package/lib/transform/odata/typesExposure.js

@@ -108,7 +108,8 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       if (newType) {
         // error, if it was not exposed by us
         if (!exposedTypes[fullQualifiedNewTypeName]) {
-          error(null, path, `Cannot create artificial type "${fullQualifiedNewTypeName}" for "${memberName}" because the name is already used`);
+          error(null, path, { type: fullQualifiedNewTypeName, name: memberName },
+            'Can\'t create artificial type $(TYPE) for $(NAME) because the name is already used');
           return;
         }
       }

package/lib/transform/parseExpr.js

@@ -0,0 +1,245 @@
+'use strict'
+
+/**
+ * parseExpr accepts any JSON object and tries to convert a token stream expression
+ * array into an AST like expression with CDL operator precedence.
+ *
+ * The following operators are supported:
+ *
+ * Multiplication/Division:    '*', '/'
+ * Addition/Subtraction:       '+', '-'
+ * Concatenation:              '||'
+ * Relational:                 '=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in', 'exists', 'between and'
+ * Unary:                      'is [not] null', 'not'
+ * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
+ *
+ * Not yet implmemented:       'new'
+ *
+ * This is not an optimized LL(1) parser but a token 'sniffer'. A stream is
+ * cracked up in sub streams and passed down to the next higher function.
+ *
+ * Complex aggregates like case/when/else/end and between are parsed first to pass down the
+ * resulting sub expressions and avoiding 'and' ambiguities.
+ *
+ * Sub expressions are grouped as arrays, the final AST is an array of nested arrays.
+ * Alternatively, an object like AST can be produced by setting argument 'array' to false.
+ *
+ * This parser intentionally does no error handling. If a clause is malformed, it is accepted as is.
+ *
+ * @param {any} xpr A JSON object.
+ * @param {Boolean} array Bias AST representation.
+ */
+
+function parseExpr(xpr, array=true) {
+  return parseExprInt(xpr);
+
+  function parseExprInt(xpr) {
+    return conditionOR(...CaseWhen(xpr));
+  }
+
+  function CaseWhen(xpr) {
+    if(Array.isArray(xpr))
+      inner(xpr);
+    return [xpr, 0, Array.isArray(xpr) ? xpr.length : 1];
+
+    // replace case/end from inner to outer
+    function inner(pxpr, lvl=0) {
+      const s = pxpr.findIndex(t => t === 'case');
+      if(s >= 0) {
+        let e = findLastIndex(pxpr, 'end');
+        pxpr = pxpr.slice(s+1, e);
+        const dist = inner(pxpr, lvl+1);
+        e -= dist;
+        if(dist > 0)
+          pxpr = xpr.slice(s+1, e+1);
+        const caseTree = array ? [ 'case' ] : { 'case': [] };
+        let i = pxpr.findIndex(t => t === 'else');
+        let elseCond = undefined;
+        if(i >= 0) {
+          elseCond = pxpr.slice(i+1);
+          pxpr = pxpr.slice(0, i);
+        }
+        i = pxpr.findIndex(t => t === 'when');
+        while(i >= 0) {
+          pxpr = pxpr.slice(i+1);
+          const when = { 'when': [] };
+          if(array)
+            caseTree.push('when');
+          else
+            caseTree.case.push(when);
+          i = pxpr.findIndex(t => t === 'then');
+          if(i >= 0) {
+            const arg = pxpr.slice(0, i);
+            if(array)
+              caseTree.push(arg);
+            else
+              when.when.push(arg.length === 1 ? arg[0] : arg);
+          }
+          pxpr = pxpr.slice(i+1);
+          i = pxpr.findIndex(t => t === 'when');
+          const arg = ((i >= 0) ? pxpr.slice(0, i) : pxpr);
+          if(array)
+            caseTree.push('then', arg);
+          else
+            when.when.push(arg.length === 1 ? arg[0] : arg);
+        }
+        if(elseCond) {
+          if(array)
+            caseTree.push('else', elseCond);
+          else
+            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+        }
+        if(array)
+          caseTree.push('end');
+        if(lvl > 0)
+          xpr.splice(s+1, e-s+1, caseTree);
+        else {
+          xpr = caseTree;
+        }
+        return e-s+1;
+      }
+      else
+        return 0;
+    }
+
+    function findLastIndex(expr, token, l=expr.length-1) {
+      while(l >= 0 && expr[l] !== token) l--;
+      return l;
+    }
+  }
+
+  function conditionOR(xpr, s, e) {
+    return binaryExpr(xpr, ['or'], conditionAnd, s, e);
+  }
+  function conditionAnd(xpr, s, e) {
+    return binaryExpr(xpr, (xpr, s, e) => {
+      let a = s-1;
+      let b;
+      // scan for 'and', skip 'between/and'
+      do {
+        b = false;
+        for(a++; xpr[a] !== 'and' && a < e; a++) {
+          if(xpr[a] === 'between')
+            b = true;
+        }
+      } while(b && a < e)
+
+      if(!b && a < e)
+        return [1, a]
+      else
+        return [1, -1];
+    }, conditionTerm, s, e);
+  }
+
+  function conditionTerm(xpr, s, e) {
+    if(Array.isArray(xpr)) {
+      if(xpr.length >= 3 && xpr[s+1] === 'is') {
+        if(xpr[s+2] === 'null')
+          return array ? [ conditionOR(xpr[s]), 'is', 'null' ] :  { 'isNull': conditionOR(xpr[s]) };
+        else if(xpr[s+2] === 'not' && xpr[s+3] === 'null')
+          return array ? [ conditionOR(xpr[s]), 'is', 'not', 'null' ] : { 'isNotNull': conditionOR(xpr[s]) };
+      }
+      if(xpr[s] === 'not')
+        return array ? [ 'not', conditionTerm(xpr, s+1, e) ] : { 'not': conditionTerm(xpr, s+1, e) };
+      if(xpr[s] === 'exists')
+        return array ? [ 'exists', conditionOR(xpr[s+1]) ] : { 'exists': conditionOR(xpr[s+1]) };
+    }
+    return compareTerm(xpr, s, e);
+  }
+
+  function compareTerm(xpr, s, e) {
+    if(Array.isArray(xpr)) {
+      let i = s;
+      while(i < e && xpr[i] !== 'between') i++;
+      const b = i < e ? i : -1;
+      while(i < e && xpr[i] !== 'and') i++;
+      const a = i < e ? i : -1;
+      if(b >= 0) {
+        const expr = expression(xpr, s, b);
+        const between = array ? [ expr, 'between' ] : { 'between': [ expr ] };
+        if(a >= 0) {
+          const lower = expression(xpr, b+1, a);
+          const upper = expression(xpr, a+1, e);
+          if(array)
+            between.push(lower, 'and', upper);
+          else {
+            between.between.push(lower, upper);
+          }
+        }
+        else {
+          const unspec = expression(xpr, b+1, e);
+          if(array)
+            between.push(unspec);
+          else
+            between.between.push(unspec);
+        }
+        return between;
+      }
+    }
+    return binaryExpr(xpr, ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'], expression, s, e);
+  }
+
+  function expression(xpr, s, e) {
+    return binaryExpr(xpr, ['||'], exprAddSub, s, e);
+  }
+
+  function exprAddSub(xpr, s, e) {
+    return binaryExpr(xpr, ['+', '-'], exprMulDiv, s, e);
+  }
+
+  function exprMulDiv(xpr, s, e) {
+    return binaryExpr(xpr, ['*', '/'], terminal, s, e);
+  }
+
+  function terminal(xpr, s, e) {
+    if(Array.isArray(xpr) && xpr.length > 0) {
+      if(e-s <= 1)
+        return parseExprInt(xpr[e-1]);
+      else
+        return xpr.slice(s, e).map(parseExprInt);
+    }
+    if (typeof xpr === 'object') {
+      for(let n in xpr) {
+        xpr[n] = parseExprInt(xpr[n]);
+      }
+    }
+    return xpr;
+  }
+
+  function binaryExpr(xpr, token, next, s, e) {
+    if (Array.isArray(xpr)) {
+      let [tl, p] = findToken(s, e);
+      if (p >= 0) {
+        let lhs = next(xpr, s, p);
+        let op = xpr[p];
+        s = p+tl;
+        [tl, p] = findToken(s, e);
+        while(p >= 0) {
+          let rhs = next(xpr, s, p);
+          lhs = array ? [ lhs, op, rhs ] : { [op]: [lhs, rhs] };
+          op = xpr[p];
+          s = p+tl;
+          [tl, p] = findToken(s, e);
+        }
+        return array ? [ lhs, op, next(xpr, s, e) ] : { [op]: [lhs, next(xpr, s, e)] };
+      }
+    }
+    return next(xpr, s, e);
+
+    function findToken(s, e) {
+      if(typeof token === 'function')
+        return token(xpr, s, e);
+      else {
+        while(s < e && !token.includes(xpr[s])) s++;
+        if(s < e)
+          return [1, s];
+      }
+      return [1, -1];
+    }
+  }
+
+}
+
+module.exports = {
+  parseExpr,
+};