@sap/cds-compiler 3.1.0 → 3.3.2

package/lib/checks/checkForTypes.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { isPersistedOnDatabase } = require('../model/csnUtils.js');
+
+/**
+ * Check that `cds.hana` types are not used - we don't support them for postgres
+ *
+ * @param {object} parent Object with a type
+ * @param {string} name Name of the type property on parent
+ * @param {Array} type type to check
+ * @param {CSN.Path} path
+ */
+function checkForHanaTypes(parent, name, type, path) {
+  const artifact = this.csn.definitions[path[1]];
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && typeof parent.type === 'string' && parent.type.startsWith('cds.hana.'))
+    this.error('ref-unexpected-hana-type', [ ...path, 'type' ], {}, `Types in the ”cds.hana“ namespace can't be used with sqlDialect “postgres”`);
+}
+
+/**
+ * Check that `cds.UInt8`is not used - we don't have a clear idea how to represent it on postgres
+ *
+ * @param {object} parent Object with a type
+ * @param {string} name Name of the type property on parent
+ * @param {Array} type type to check
+ * @param {CSN.Path} path
+ */
+function checkForUInt8(parent, name, type, path) {
+  const artifact = this.csn.definitions[path[1]];
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && parent.type === 'cds.UInt8')
+    this.error('ref-unexpected-type', [ ...path, 'type' ], {}, `Type ”cds.UInt8“ can't be used with sqlDialect “postgres”`);
+}
+
+/**
+ * Check types - specifically for postgres
+ *
+ * @param {object} parent Object with a type
+ * @param {string} name Name of the type property on parent
+ * @param {Array} type type to check
+ * @param {CSN.Path} path
+ */
+function checkTypes(parent, name, type, path) {
+  checkForHanaTypes.bind(this)(parent, name, type, path);
+  checkForUInt8.bind(this)(parent, name, type, path);
+}
+
+module.exports = {
+  type: checkTypes,
+};

package/lib/checks/defaultValues.js

@@ -21,7 +21,7 @@ function validateDefaultValues(member, memberName, prop, path) {
       while (member.default.xpr[i] === '-' || member.default.xpr[i] === '+')
         i++;
       if (i > 1)
-        this.error(null, path, `Illegal number of unary '+/-' operators`);
+        this.error(null, path, {}, `Illegal number of unary '+/-' operators`);
     }
   }
 }
@@ -36,7 +36,7 @@ function validateDefaultValues(member, memberName, prop, path) {
  */
 function rejectParamDefaultsInHanaCds(member, memberName, prop, path) {
   if (member.default && prop === 'params' && this.options.transformation === 'hdbcds')
-    this.error(null, path, 'Parameter default values are not supported in SAP HANA CDS');
+    this.error(null, path, {}, 'Parameter default values are not supported in SAP HANA CDS');
 }
 
 /**

package/lib/checks/elements.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { forEachMember, forEachMemberRecursively } = require('../model/csnUtils');
+const { forEachMember, forEachMemberRecursively, isBuiltinType } = require('../model/csnUtils');
 const { isGeoTypeName } = require('../compiler/builtins');
-
+const { setProp } = require('../base/model');
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**
@@ -42,13 +42,15 @@ function checkPrimaryKey(art) {
                    { type: finalBaseType.type, name: elemFqName },
                    'Type $(TYPE) can\'t be used as primary key in element $(NAME)');
       }
-      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
+      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType) && !finalBaseType.$visited) {
+        setProp(finalBaseType, '$visited', true);
         forEachMemberRecursively(finalBaseType,
                                  (subMember, subMemberName) => checkIfPrimaryKeyIsOfGeoType
                                    .bind(this)(subMember,
                                                `${ elemFqName }/${ subMemberName }`,
                                                member.key || parentIsKey,
                                                member.$path));
+        delete finalBaseType.$visited;
       }
     }
   }
@@ -68,13 +70,15 @@ function checkPrimaryKey(art) {
         this.error(null, parentPath || member.$path, { name: elemFqName },
                    'Array-like type in element $(NAME) can\'t be used as primary key');
       }
-      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
+      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType) && !finalBaseType.$visited) {
+        setProp(finalBaseType, '$visited', true);
         forEachMemberRecursively(finalBaseType,
                                  (subMember, subMemberName) => checkIfPrimaryKeyIsArray
                                    .bind(this)(subMember,
                                                `${ elemFqName }/${ subMemberName }`,
                                                member.key || parentIsKey,
                                                member.$path));
+        delete finalBaseType.$visited;
       }
     }
   }
@@ -89,7 +93,7 @@ function checkPrimaryKey(art) {
 function checkVirtualElement(member) {
   if (member.virtual) {
     if (this.csnUtils.isAssociation(member.type)) { // or Composition ???
-      this.error(null, member.$path, `Element can't be virtual and an association`);
+      this.error(null, member.$path, {}, `Element can't be virtual and an association`);
     }
   }
 }
@@ -135,4 +139,75 @@ function checkManagedAssoc(art) {
   }
 }
 
-module.exports = { checkPrimaryKey, checkVirtualElement, checkManagedAssoc };
+/**
+ * All DB  & OData flat mode must reject recursive type usages in entities
+ * 'items' break recursion as 'items' will turn into an NCLOB and the path
+ * prefix to 'items' can be flattend in the DB.
+ * In OData flat mode the first appearance of 'items' breaks out into structured
+ * mode producing (legal) recursive complex types.
+ *
+ * @param {CSN.Artifact} art The artifact
+ */
+function checkRecursiveTypeUsage(art) {
+  const visit = (def) => {
+    const loc = def.$path;
+    // recursive types are allowed inside arrays
+    if (def.items)
+      return;
+    let { type } = def;
+    let prevType;
+    let isDeref = false;
+    if (type && !isBuiltinType(type) && !def.elements) {
+      do {
+        prevType = type;
+        // TODO: `type.ref.length > 1`, but OData backend must be tested first (#5144)
+        //  e.g. `{ ref: [ "MyType" ] }`
+        if (type.ref) {
+          def = this.artifactRef(type);
+          isDeref = true;
+        }
+        else {
+          def = this.csn.definitions[type];
+        }
+        type = def.type;
+      } while (type && !isBuiltinType(type) && !def.items && !def.elements && prevType !== type);
+    }
+    if (def.$visited || (type && prevType === type)) {
+      // Recursion via type is allowed in V4 struct, but not via dereferencing
+      if (!isDeref && this.options.odataVersion === 'v4' && this.options.odataFormat === 'structured')
+        return;
+      if (!def.$recErr) {
+        this.error(null, loc, {}, 'Unexpected recursive type definition');
+        setProp(def, '$recErr', true);
+      }
+    }
+    else if (def.elements) {
+      setProp(def, '$visited', true);
+      for (const n in def.elements)
+        visit(def.elements[n]);
+      delete def.$visited;
+    }
+  };
+  // elements & params are flattening candidates
+  // FUTURE:
+  // Once we have universal CSN for the runtimes
+  // Validate service members only for OData
+  if (art.kind === 'entity') {
+    for (const n in art.elements)
+      visit(art.elements[n]);
+    for (const n in art.params)
+      visit(art.params[n]);
+  }
+  if (this.options.odataVersion) {
+    // func/action params/returns don't allow recursive type derefs
+    if (art.kind === 'action' || art.kind === 'function') {
+      for (const n in art.params)
+        visit(art.params[n]);
+      if (art.returns)
+        visit(art.returns);
+    }
+  }
+}
+module.exports = {
+  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+};

package/lib/checks/foreignKeys.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { setProp } = require('../base/model');
+
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -41,10 +43,10 @@ function validateForeignKeys(member) {
   // Declared as arrow-function to keep scope the same (this value)
   const checkForItems = (mem) => {
     if (mem.items) {
-      this.error(null, member.$path, 'Array-like properties must not be foreign keys');
+      this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
     }
     else if (isUnmanagedAssoc(mem)) {
-      this.error(null, member.$path, 'Unmanaged association must not be a foreign key');
+      this.error(null, member.$path, {}, 'Unmanaged association must not be a foreign key');
     }
     else if (mem.keys) {
       handleAssociation(mem);
@@ -52,17 +54,14 @@ function validateForeignKeys(member) {
     else if (mem.elements) {
       handleStructured(mem);
     }
-    else if (mem.type && mem.type.ref) { // type of
-      checkForItems(this.artifactRef(mem.type));
-    }
-    else { // type T where T might contain items
-      const type = this.csn.definitions[mem.type];
-      if (type) {
-        if (type.keys)
-          handleAssociation(type);
-
-        else if (type.elements)
-          handleStructured(type);
+    else if (mem.type) {
+      const type = mem.type.ref
+        ? this.artifactRef(mem.type)
+        : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        checkForItems(type);
+        delete type.$visited;
       }
     }
   };

package/lib/checks/invalidTarget.js

@@ -3,6 +3,7 @@
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 const { ModelError } = require('../base/error');
+const { setProp } = require('../base/model');
 
 /**
  * Assert that targets of associations and compositions are entities.
@@ -38,18 +39,16 @@ function invalidTarget(member) {
         );
       }
     }
-    else if (mem.type && mem.type.ref) {
-      // type of
-      checkForInvalidTarget(this.artifactRef(mem.type));
+    // elements have precedence over type
+    else if (mem.elements) {
+      handleStructured(mem);
     }
-    else {
-      // type T
-      const type = this.csn.definitions[mem.type];
-      if (type) {
-        if (type.elements)
-          handleStructured(type);
-        else
-          checkForInvalidTarget(type);
+    else if (mem.type) {
+      const type = mem.type.ref ? this.artifactRef(mem.type) : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        checkForInvalidTarget(type);
+        delete type.$visited;
       }
     }
   };

package/lib/checks/managedInType.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { setProp } = require('../base/model');
+
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -35,18 +37,20 @@ function checkUsedTypesForAnonymousAspectComposition(member) {
     }
     else if (mem.type && (mem.type === 'cds.Composition') && !mem.on) {
       if (!mem.target && mem.targetAspect && typeof mem.targetAspect !== 'string')
-        this.error(null, member.$path, 'Types with anonymous aspect compositions can\'t be used');
+        this.error(null, member.$path, {}, 'Types with anonymous aspect compositions can\'t be used');
     }
     else if (mem.elements) {
       handleStructured(mem, assertNoAnonymousAspectComposition);
     }
-    else if (mem.type && mem.type.ref) { // type of
-      const type = this.artifactRef(mem.type);
-      assertNoAnonymousAspectComposition(type);
-    }
-    else if (mem.type && this.csn.definitions[mem.type]) { // type T
-      const type = this.csn.definitions[mem.type];
-      assertNoAnonymousAspectComposition(type);
+    else if (mem.type) {
+      const type = mem.type.ref
+        ? this.artifactRef(mem.type)
+        : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        assertNoAnonymousAspectComposition(type);
+        delete type.$visited;
+      }
     }
   };
 
@@ -62,13 +66,15 @@ function checkUsedTypesForAnonymousAspectComposition(member) {
     else if (mem.elements) {
       handleStructured(mem, checkTypeUsages);
     }
-    else if (mem.type && mem.type.ref) { // type of
-      const type = this.artifactRef(mem.type);
-      assertNoAnonymousAspectComposition(type);
-    }
-    else if (mem.type && this.csn.definitions[mem.type]) { // type T where T might contain items
-      const type = this.csn.definitions[mem.type];
-      assertNoAnonymousAspectComposition(type);
+    else if (mem.type) { // type of
+      const type = mem.type.ref
+        ? this.artifactRef(mem.type)
+        : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        assertNoAnonymousAspectComposition(type);
+        delete type.$visited;
+      }
     }
   };
 

package/lib/checks/nullableKeys.js

@@ -7,7 +7,7 @@
  */
 function checkExplicitlyNullableKeys(element) {
   if (element.key && element.notNull === false)
-    this.error(null, element.$path, 'Expecting primary key element to be not nullable');
+    this.error(null, element.$path, {}, 'Expecting primary key element to be not nullable');
 }
 
 module.exports = checkExplicitlyNullableKeys;

package/lib/checks/onConditions.js

@@ -61,7 +61,7 @@ function validateOnCondition(member, memberName, property, path) {
   if (member && member.on) {
     // complain about nullability constraint on managed composition
     if (member.targetAspect && {}.hasOwnProperty.call(member, 'notNull')) {
-      this.warning(null, path.concat([ 'on' ]),
+      this.warning(null, path.concat([ 'on' ]), {},
                    'Unexpected nullability constraint defined on managed composition');
     }
     for (let i = 0; i < member.on.length; i++) {
@@ -83,24 +83,24 @@ function validateOnCondition(member, memberName, property, path) {
           if (_links[j].art.target && !((_links[j].art === member) || ref[j] === '$self' || ref[j] === '$projection' || (validDollarSelf && j === _links.length - 1))) {
             if (_links[j].art.on) {
               // It's an unmanaged association - traversal is always forbidden
-              this.error(null, csnPath, { id, elemref }, 'ON-Conditions can\'t follow unmanaged associations, step $(ID) of path $(ELEMREF)');
+              this.error(null, csnPath, { id, elemref }, 'ON-conditions can\'t follow unmanaged associations, step $(ID) of path $(ELEMREF)');
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
               const nextRef = ref[j + 1].id || ref[j + 1];
               if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
-                this.error(null, csnPath, { id, elemref }, 'ON-Conditions can only follow managed associations to the foreign keys of the managed association, step $(ID) of path $(ELEMREF)');
+                this.error(null, csnPath, { id, elemref }, 'ON-conditions can only follow managed associations to the foreign keys of the managed association, step $(ID) of path $(ELEMREF)');
             }
           }
 
           if (_links[j].art.virtual)
-            this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-Conditions, step $(ID) of path $(ELEMREF)');
+            this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
 
           if (ref[j].where)
-            this.error(null, csnPath, { id, elemref }, 'ON-Conditions must not contain filters, step $(ID) of path $(ELEMREF)');
+            this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain filters, step $(ID) of path $(ELEMREF)');
 
           if (ref[j].args)
-            this.error(null, csnPath, { id, elemref }, 'ON-Conditions must not contain parameters, step $(ID) of path $(ELEMREF)');
+            this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)');
         }
         if (_art && $scope !== '$self') {
           _art = resolveArtifactType.call(this, _art);
@@ -117,15 +117,15 @@ function validateOnCondition(member, memberName, property, path) {
              /* 2) */ (_art.target && validDollarSelf)) &&
              !_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },
-                       'The last path of an on-condition must be a scalar value, path $(ELEMREF)');
+                       'The last path of an ON-condition must be a scalar value, path $(ELEMREF)');
           }
           else if (_art.items && !_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },
-                       'ON-Conditions can\'t use array-like elements, path $(ELEMREF)');
+                       'ON-conditions can\'t use array-like elements, path $(ELEMREF)');
           }
           else if (_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },
-                       'Virtual elements can\'t be used in ON-Conditions, path $(ELEMREF)');
+                       'Virtual elements can\'t be used in ON-conditions, path $(ELEMREF)');
           }
         }
       }

package/lib/checks/parameters.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const { isPersistedOnDatabase } = require('../model/csnUtils.js');
+
+/**
+ * Check that we don't have parameterized views - as we don't know yet how to represent them on postgres
+ *
+ * @param {object} parent Object with .params
+ * @param {string} name Name of the params property on parent
+ * @param {object} params params
+ * @param {CSN.Path} path
+ */
+function checkForParams(parent, name, params, path) {
+  const artifact = this.csn.definitions[path[1]];
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && !(parent.kind !== 'entity'))
+    this.error('ref-unexpected-params', [ ...path, 'params' ], `Parameterized views can't be used with sqlDialect “postgres”`);
+}
+
+module.exports = {
+  params: checkForParams,
+};

package/lib/checks/selectItems.js

@@ -106,7 +106,7 @@ function validateSelectItems(query) {
   if (this.options.transformation === 'hdbcds') {
     transformers.xpr = (parent) => {
       if (parent.func) {
-        this.error(null, parent.$path,
+        this.error(null, parent.$path, {},
                    'Window functions are not supported by SAP HANA CDS');
       }
     };

package/lib/checks/types.js

@@ -33,7 +33,7 @@ function checkDecimalScale(member, memberName, prop, path) {
  */
 function checkTypeIsScalar(member, memberName, prop, path) {
   if ( prop === 'params' && this.csnUtils.isStructured(member))
-    this.error(null, path, 'View parameter type must be scalar');
+    this.error(null, path, {}, 'View parameter type must be scalar');
 }
 
 /**
@@ -69,7 +69,7 @@ function checkElementTypeDefinitionHasType(member, memberName, prop, path) {
     }
     else if (member._type) {
       if ( this.isAspect(member._type) || member._type.kind === 'type' && member._type.$syntax === 'aspect')
-        this.error('ref-sloppy-type', path, 'A type or an element is expected here');
+        this.error('ref-sloppy-type', path, {}, 'A type or an element is expected here');
     }
     return;
   }

package/lib/checks/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../model/csnUtils');
-
+const { RelationalOperators } = require('../transform/transformUtilsNew');
 /**
  * Prepare the ref steps so that they are loggable
  *
@@ -17,17 +17,27 @@ function logReady(refStep) {
  * structured that can be used for tuple expansion. This can either be a
  * real 'elements' thing or a managed association/composition with foreign keys.
  *
+ * The RHS may be 'null' or any value
+ *
  * @param {Array} on the on condition which to check
  * @param {number} startIndex the index of the relational term in the on condition array
  * @returns {boolean} indicates whether the other side of a relational term is expandable
  */
 function otherSideIsExpandableStructure(on, startIndex) {
-  if (on[startIndex - 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex - 1]))
-    return isOk(resolveArtifactType.call(this, on[startIndex - 2]._art));
-
-  else if (on[startIndex + 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex + 1]))
-    return isOk(resolveArtifactType.call(this, on[startIndex + 2]._art));
-
+  if (on[startIndex - 1] && RelationalOperators.includes(on[startIndex - 1])) {
+    const lhs = on[startIndex - 2];
+    // if ever lhs is allowed to be a value uncomment this
+    return /* lhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, lhs?._art));
+  }
+  else if (on[startIndex + 1] && RelationalOperators.includes(on[startIndex + 1])) {
+    const op = on[startIndex + 1];
+    const rhs = on[startIndex + 2];
+    if (op === 'is')
+      // check for unary operator 'is [not] null' as token stream
+      return rhs === 'null' || (rhs === 'not' && on[startIndex + 3] === 'null');
+    // if ever rhs is allowed to be a value uncomment this
+    return /* rhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, rhs?._art));
+  }
   return false;
 
   /**

package/lib/checks/validator.js

@@ -6,12 +6,14 @@ const {
 } = require('../model/csnUtils');
 const enrich = require('./enricher');
 
-// forHana
+// forRelationalDB
 const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
+const checkForHanaTypes = require('./checkForTypes');
+const checkForParams = require('./parameters');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
 const { checkActionOrFunction } = require('./actionsFunctions');
@@ -26,7 +28,9 @@ const {
   checkTypeDefinitionHasType, checkElementTypeDefinitionHasType,
   checkTypeIsScalar, checkDecimalScale,
 } = require('./types');
-const { checkPrimaryKey, checkVirtualElement, checkManagedAssoc } = require('./elements');
+const {
+  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+} = require('./elements');
 const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
@@ -38,7 +42,7 @@ const {
   checkSqlAnnotationOnElement,
 } = require('./sql-snippets');
 
-const forHanaMemberValidators
+const forRelationalDBMemberValidators
 = [
   // For HANA CDS specifically, reject any default parameter values, as these are not supported.
   rejectParamDefaultsInHanaCds,
@@ -51,7 +55,7 @@ const forHanaMemberValidators
   checkSqlAnnotationOnElement,
 ];
 
-const forHanaArtifactValidators
+const forRelationalDBArtifactValidators
 = [
   // @cds.persistence has no impact on odata
   validateCdsPersistenceAnnotation,
@@ -61,12 +65,12 @@ const forHanaArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
+const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */
-const forHanaQueryValidators = [
-  // TODO reason why this is forHana exclusive
+const forRelationalDBQueryValidators = [
+  // TODO reason why this is forRelationalDB exclusive
   validateSelectItems,
   checkQueryForNoDBArtifacts,
 ];
@@ -103,7 +107,12 @@ const commonMemberValidators
   checkVirtualElement, checkElementTypeDefinitionHasType ];
 
 // TODO: checkManagedAssoc is a forEachMemberRecursively!
-const commonArtifactValidators = [ checkTypeDefinitionHasType, checkPrimaryKey, checkManagedAssoc ];
+const commonArtifactValidators = [
+  checkTypeDefinitionHasType,
+  checkPrimaryKey,
+  checkManagedAssoc,
+  checkRecursiveTypeUsage,
+];
 // TODO: Does it make sense to run the on-condition check as part of a CSN validator?
 const commonQueryValidators = [ validateMixinOnCondition ];
 
@@ -186,11 +195,14 @@ function mergeCsnValidators(csnValidators, that) {
  * @param {object} that Will be provided to the validators via "this"
  * @returns {Function} the validator function with the respective checks for the HANA backend
  */
-function forHana(csn, that) {
+function forRelationalDB(csn, that) {
   return _validate(csn, that,
-                   forHanaCsnValidators,
-                   forHanaMemberValidators.concat(commonMemberValidators),
-                   forHanaArtifactValidators.concat(commonArtifactValidators).concat(
+                   that.options.sqlDialect === 'postgres'
+                     ? [ ...forRelationalDBCsnValidators,
+                       checkForHanaTypes,
+                       checkForParams ] : forRelationalDBCsnValidators,
+                   forRelationalDBMemberValidators.concat(commonMemberValidators),
+                   forRelationalDBArtifactValidators.concat(commonArtifactValidators).concat(
                      // why is this hana exclusive
                      (artifact) => {
                        /*  the validation itself performs a recursive check on structured elements.
@@ -200,7 +212,7 @@ function forHana(csn, that) {
                        forEachMember(artifact, checkUsedTypesForAnonymousAspectComposition.bind(that));
                      }
                    ),
-                   forHanaQueryValidators.concat(commonQueryValidators),
+                   forRelationalDBQueryValidators.concat(commonQueryValidators),
                    {
                      skipArtifact: artifact => artifact.abstract ||
                                                 hasAnnotationValue(artifact, '@cds.persistence.skip') ||
@@ -235,4 +247,4 @@ function forOdata(csn, that) {
                    });
 }
 
-module.exports = { forHana, forOdata };
+module.exports = { forRelationalDB, forOdata };