@sap/cds-compiler 3.1.0 → 3.3.2

package/lib/transform/db/flattening.js

@@ -124,7 +124,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
       }
     },
   }, [ (definitions, artifactName, artifact) => {
-    // Replace events, actions and functions with simple dummies - they don't have effect on forHanaNew stuff
+    // Replace events, actions and functions with simple dummies - they don't have effect on forRelationalDB stuff
     // and that way they contain no references and don't hurt.
 
     // Do not do for OData

package/lib/transform/db/temporal.js

@@ -81,7 +81,7 @@ function getViewDecorator(csn, messageFunctions) {
           }
         }
         else {
-          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${from[0].error_parent}"."${from[0].name}" and "${to[0].error_parent}"."${to[0].name}" are not of same origin`);
+          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${from[0].errorParent}"."${from[0].name}" and "${to[0].errorParent}"."${to[0].name}" are not of same origin`);
         }
       }
       else if (from.length > 0 || to.length > 0) {

package/lib/transform/db/transformExists.js

@@ -799,7 +799,7 @@ function handleExists(csn, options, error) {
           where.push({ ref: [ base, ...part.ref.slice(1) ] });
         }
         else if (part.$scope === '$self') { // source side - "absolute" scope
-          // Same message as in forHanaNew/transformDollarSelfComparisonWithUnmanagedAssoc
+          // Same message as in forRelationalDB/transformDollarSelfComparisonWithUnmanagedAssoc
           error(null, part.$path, 'An association that uses "$self" in its ON-condition can\'t be compared to "$self"');
         }
         else if (partInspect.art) { // source side - with local scope

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' && 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;
       }
     }
@@ -983,7 +983,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')
@@ -1124,5 +1124,5 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
 
 module.exports = {
-  transformForHanaWithCsn,
+  transformForRelationalDBWithCsn,
 };

package/lib/transform/localized.js

@@ -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,7 @@ 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, `Can't create artificial type "${fullQualifiedNewTypeName}" for "${memberName}" because the name is already used`);
           return;
         }
       }

package/lib/transform/transformUtilsNew.js

@@ -13,13 +13,15 @@ const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError } = require("../base/error");
 const { forEach } = require('../utils/objectUtils');
 
+const RestrictedOperators = ['<', '>', '>=', '<='];
+const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
 // 'model' is compacted new style CSN
 // TODO: Error and warnings handling with compacted CSN? - currently just throw new ModelError for everything
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
 function getTransformers(model, options, pathDelimiter = '_') {
-  const { error, warning, info } = makeMessageFunction(model, options);
+  const { message, error, warning, info } = makeMessageFunction(model, options);
   const csnUtils = getUtils(model);
   const {
     getCsnDef,
@@ -500,7 +502,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * Create a 'DraftAdministrativeData' projection on entity 'DRAFT.DraftAdministrativeData'
    * in service 'service' and add it to the model.
    *
-   * For forHanaNew, use String(36) instead of UUID and UTCTimestamp instead of Timestamp
+   * For forRelationalDB, use String(36) instead of UUID and UTCTimestamp instead of Timestamp
    *
    * @param {string} service
    * @param {boolean} [hanaMode=false] Turn UUID into String(36)
@@ -1113,51 +1115,64 @@ function getTransformers(model, options, pathDelimiter = '_') {
       for(let i = 0; i < expr.length; i++)
       {
         if(Array.isArray(expr[i]))
-          rc.push(expr[i].map(expand, location));
+          rc.push(expr[i].map(e => expand(e, location)));
 
         if(i < expr.length-2)
         {
-          const [lhs, op, rhs] = expr.slice(i);
+          let [lhs, op, not, rhs] = expr.slice(i);
+          if(not !== 'not') {
+            rhs = not;
+            not = false;
+          }
+          if(lhs === undefined || op === undefined || rhs === undefined)
+            return expr;
 
           // we might have to ad-hoc resolve a ref, since handleExists is run before hand and generates new refs.
           const lhsArt = lhs._art || lhs.ref && !lhs.$scope && inspectRef(location.concat(i)).art;
           const rhsArt = rhs._art || rhs.ref && !rhs.$scope && inspectRef(location.concat(i+2)).art;
-          // lhs & rhs must be expandable types (structures or managed associations)
-          if(lhsArt && rhsArt &&
-             lhs.ref && rhs.ref &&
-             isExpandable(lhsArt) && isExpandable(rhsArt) &&
-             ['=', '<', '>', '>=', '<=', '!=', '<>'].includes(op) &&
-             !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs))) {
+          const lhsIsVal = (lhs.val !== undefined);
+          // if ever rhs should be alowed to be a value uncomment this
+          const rhsIsVal = (rhs === 'null' /*|| rhs.val !== undefined*/);
 
+          // lhs & rhs must be expandable types (structures or managed associations)
+          // if ever lhs should be alowed to be a value uncomment this
+          if(!(lhsIsVal /*&& rhsIsVal*/) &&
+             !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs)) &&
+             RelationalOperators.includes(op) &&
+             (lhsIsVal || (lhsArt && lhs.ref && isExpandable(lhsArt))) &&
+             (rhsIsVal || (rhsArt && rhs.ref && isExpandable(rhsArt)))
+            ) {
+
+            if(RestrictedOperators.includes(op)) {
+              message('expr-unexpected-operator', location, { op }, 'Unexpected operator $(OP) in structural comparison');
+            }
             // if path is scalar and no assoc or has no type (@Core.Computed) use original expression
             // only do the expansion on (managed) assocs and (items.)elements, array of check in ON cond is done elsewhere
-            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
-            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
+            const lhspaths = lhsIsVal ? [] : flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
+            const rhspaths = rhsIsVal ? [] : flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
 
             // mapping dict for lhs/rhs for mismatch check
             // strip lhs/rhs prefix from flattened paths to check remaining common trailing path
             // if path is idempotent, it doesn't produce new flattened paths (ends on scalar type)
             // key is then empty string on both sides '' (=> equality)
             // Path matches if lhs/rhs are available
-            const xref = lhspaths.reduce((a, v) => {
-              a[v.ref.slice(lhs.ref.length).join('.')] = { lhs: v };
-              return a;
-            }, Object.create(null));
-
-            rhspaths.forEach(v => {
-              const k = v.ref.slice(rhs.ref.length).join('.');
-              if(xref[k])
-                xref[k].rhs = v;
-              else
-                xref[k] = { rhs: v };
-            });
-
+            const xref = createXRef(lhspaths, rhspaths, lhs, rhs, lhsIsVal, rhsIsVal);
+            const xrefkeys = Object.keys(xref);
+            const xrefvalues = Object.values(xref);
             let cont = true;
-            for(const xn in xref) {
-              const x = xref[xn];
 
+            if(op === 'like' && xrefvalues.reduce((a, v) => { 
+              return (v.lhs && v.rhs) ? a + 1: a;
+            }, 0) === 0) {
+              // error if intersection of paths is zero
+              error(null, location, `Expected compatible types for '${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}'`);
+              cont = false;
+            }
+
+            cont && xrefkeys.forEach(xn => {
+              const x = xref[xn];
               // do the paths match?
-              if(!(x.lhs && x.rhs)) {
+              if(op !== 'like' && !(x.lhs && x.rhs)) {
                 if(xn.length)
                   error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Sub path '${xn}' not found in ${((x.lhs ? rhs : lhs).ref.join('.'))}`)
                 else
@@ -1167,17 +1182,17 @@ function getTransformers(model, options, pathDelimiter = '_') {
               // lhs && rhs are present, consistency checks that affect both ends
               else {
                 // is lhs scalar?
-                if(!isScalarOrNoType(x.lhs._art)) {
+                if(!lhsIsVal && x.lhs && !isScalarOrNoType(x.lhs._art)) {
                   error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${x.lhs.ref.join('.')}${(xn.length ? '.' + xn : '')}' must end on a scalar type`)
                   cont = false;
                 }
                 // is rhs scalar?
-                if(!isScalarOrNoType(x.rhs._art)) {
+                if(!rhsIsVal && x.rhs && !isScalarOrNoType(x.rhs._art)) {
                   error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${x.rhs.ref.join('.')}${(xn.length ? '.' + xn : '')}' must end on a scalar type`)
                   cont = false;
                 }
                 // info about type incompatibility if no other errors occured
-                if(xn && cont) {
+                if(!(lhsIsVal || rhsIsVal) && x.lhs && x.rhs && xn && cont) {
                   const lhst = getType(x.lhs._art);
                   const rhst = getType(x.rhs._art);
                   if(lhst !== rhst) {
@@ -1185,20 +1200,29 @@ function getTransformers(model, options, pathDelimiter = '_') {
                   }
                 }
               }
-            }
+            });
             // don't continue if there are path errors
             if(!cont)
               return expr;
 
-            Object.keys(xref).forEach((k, i) => {
-              const x = xref[k];
+            // if lhs and rhs are refs set operator from 'like' to '='
+            if(op === 'like' && !(lhsIsVal || rhsIsVal)) {
+              op = '=';
+            }
+            // t_0 OR ... OR t_n with t = (a <not equal> b)
+            const bop = (op === 'is' && not) || op === '!=' || op === '<>' ? 'or' : 'and';
+            rc.push('(');
+            xrefvalues.filter(x => x.lhs && x.rhs).forEach((x,i) => {
               if(i>0)
-                rc.push('and');
+                rc.push(bop);
               rc.push(x.lhs);
               rc.push(op);
+              if(not)
+                rc.push('not')
               rc.push(x.rhs);
             });
-            i += 2;
+            rc.push(')');
+            i += not ? 3 : 2;
           }
           else
             rc.push(expr[i]);
@@ -1208,6 +1232,44 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
       return rc;
 
+      function createXRef(lhspaths, rhspaths, lhs, rhs, lhsIsVal, rhsIsVal) {
+        // mapping dict for lhs/rhs for mismatch check
+        // strip lhs/rhs prefix from flattened paths to check remaining common trailing path
+        // if path is idempotent, it doesn't produce new flattened paths (ends on scalar type)
+        // key is then empty string on both sides '' (=> equality)
+        // Path matches if lhs/rhs are available
+        let xref;
+        if(!lhsIsVal) {
+          xref = lhspaths.reduce((a, v) => {
+            a[v.ref.slice(lhs.ref.length).join('.')] = rhsIsVal ? { lhs: v, rhs } : { lhs: v };
+            return a;
+          }, Object.create(null));
+
+          rhspaths.forEach(v => {
+            const k = v.ref.slice(rhs.ref.length).join('.');
+            if(xref[k])
+              xref[k].rhs = v;
+            else
+                xref[k] = { rhs: v };
+          });
+        }
+        else if(!rhsIsVal) {
+          xref = rhspaths.reduce((a, v) => {
+            a[v.ref.slice(rhs.ref.length).join('.')] = lhsIsVal ? { lhs, rhs: v } : { rhs: v };
+            return a;
+          }, Object.create(null));
+
+          lhspaths.forEach(v => {
+            const k = v.ref.slice(lhs.ref.length).join('.');
+            if(xref[k])
+              xref[k].lhs = v;
+            else
+                xref[k] = { lhs: v };
+          });
+        }
+        return xref;
+      }
+
       function getType(art) {
         const effart = effectiveType(art);
         return Object.keys(effart).length ? effart : art.type;
@@ -1218,7 +1280,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         if(art) {
           // items in ON conds are illegal but this should be checked elsewhere
           const elements = art.elements || (art.items && art.items.elements);
-          return (elements || art.target && art.keys)
+          return !!(elements || art.target && art.keys)
         }
         return false;
       }
@@ -1241,7 +1303,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
 }
 
-
 /**
  * Modify the given CSN/artifact in-place, applying the given customTransformations.
  * Dictionaries are correctly handled - a "type" transformer will not be called on an entity called "type".
@@ -1333,5 +1394,6 @@ function transformModel(csn, customTransformations, transformNonEnumerableElemen
 module.exports = {
   // This function retrieves the actual exports
   getTransformers,
-  transformModel
+  transformModel,
+  RelationalOperators
 };

package/lib/transform/translateAssocsToJoins.js

@@ -9,7 +9,7 @@ const { deduplicateMessages } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 // Paths that start with an artifact of protected kind are special
 // either ignore them in QAT building or in path rewriting
-const internalArtifactKinds = ['builtin'/*, '$parameters'*/, 'param'];
+const internalArtifactKinds = ['builtin', '$parameters', 'param'];
 
 function translateAssocsToJoinsCSN(csn, options){
   timetrace.start('Recompiling model');
@@ -444,7 +444,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         }
         else if(art.target) { // it's not an artifact, so it should be an assoc step
           if(joinTree === undefined)
-            throw Error('Cannot follow Associations without starting Entity');
+            throw Error('Can\'t follow Associations without starting Entity');
 
           if(!childQat.$QA)
             childQat.$QA = createQA(env, art.target._artifact, art.name.id, childQat._namedArgs);
@@ -762,7 +762,8 @@ function translateAssocsToJoins(model, inputOptions = {})
 
         let [head, ...tail] = path;
 
-        if(internalArtifactKinds.includes(head._artifact.kind)) // don't rewrite path
+        // don't rewrite path
+        if(internalArtifactKinds.includes(head._artifact.kind))
           return pathNode;
 
         // strip the absolute path indicators
@@ -1536,7 +1537,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             (  // not leaf
               i < tail.length-1 &&
               // path terminates on a scalar type
-              // _effectiveType.elements can be removed if forHanaNew can expand fk paths correctly
+              // _effectiveType.elements can be removed if forRelationalDB can expand fk paths correctly
               !(tail[tail.length-1]._artifact._effectiveType.elements || tail[tail.length-1]._artifact._effectiveType.target) &&
               // association is managed
               art.foreignKeys &&

package/lib/utils/moduleResolve.js

@@ -173,13 +173,13 @@ function _errorFileNotFound(dep, options, { error }) {
       resolved = resolved.replace( /\\/g, '/' );
     for (const from of dep.usingFroms) {
       error( 'file-not-readable', from.location, { file: resolved },
-             'Cannot read file $(FILE)' );
+             'Can\'t read file $(FILE)' );
     }
   }
   else if (isLocalFile( dep.module ) ) {
     for (const from of dep.usingFroms) {
       error( 'file-unknown-local', from.location, { file: dep.module },
-             'Cannot find local module $(FILE)' );
+             'Can\'t find local module $(FILE)' );
     }
   }
   else {
@@ -187,8 +187,8 @@ function _errorFileNotFound(dep, options, { error }) {
     for (const from of dep.usingFroms) {
       error( 'file-unknown-package', from.location,
              { file: dep.module, '#': internal }, {
-               std: 'Cannot find package $(FILE)',
-               internal: 'Cannot find package module $(FILE)',
+               std: 'Can\'t find package $(FILE)',
+               internal: 'Can\'t find package module $(FILE)',
              } );
     }
   }
@@ -417,7 +417,7 @@ function resolveCDS(moduleName, options, callback) {
    * @returns {Error}
    */
   function makeNotFoundError() {
-    const moduleError = new Error(`Cannot find module '${ moduleName }' from '${ options.basedir }'`);
+    const moduleError = new Error(`Can't find module '${ moduleName }' from '${ options.basedir }'`);
     // eslint-disable-next-line
     moduleError['code'] = 'MODULE_NOT_FOUND';
     return moduleError;

package/lib/utils/objectUtils.js

@@ -37,7 +37,7 @@ function createDict(obj) {
  */
 function forEach(obj, callback) {
   for (const key in obj) {
-    if (Object.hasOwnProperty.call(obj, key))
+    if (Object.prototype.hasOwnProperty.call(obj, key))
       callback(key, obj[key]);
   }
 }
@@ -51,7 +51,7 @@ function forEach(obj, callback) {
  */
 function forEachValue(o, callback) {
   for (const key in o) {
-    if (Object.hasOwnProperty.call(o, key))
+    if (Object.prototype.hasOwnProperty.call(o, key))
       callback(o[key]);
   }
 }
@@ -65,7 +65,7 @@ function forEachValue(o, callback) {
  */
 function forEachKey(o, callback) {
   for (const key in o) {
-    if (Object.hasOwnProperty.call(o, key))
+    if (Object.prototype.hasOwnProperty.call(o, key))
       callback(key);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "3.1.0",
+  "version": "3.3.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -16,7 +16,7 @@
   "scripts": {
     "download": "node scripts/downloadANTLR.js",
     "gen": "node ./scripts/build.js && node scripts/genGrammarChecksum.js",
-    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.0.11 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.0.11",
+    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.1.1 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.1.1",
     "xmakeAfterInstall": "npm run gen",
     "xmakePrepareRelease": "echo \"$(node scripts/stripReadme.js README.md)\" > README.md && node scripts/assertSnapshotVersioning.js && node scripts/assertChangelog.js && node scripts/cleanup.js --remove-dev",
     "test": "node scripts/verifyGrammarChecksum.js && mocha --reporter min --reporter-option maxDiffSize=0 scripts/testLazyLoading.js && mocha --parallel --reporter min --reporter-option maxDiffSize=0 test/ test3/",