@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/render/toSql.js

@@ -8,8 +8,11 @@ const {
 } = require('../model/csnUtils');
 const {
   renderFunc, cdsToSqlTypes, getHanaComment, hasHanaComment,
-  getSqlSnippets, getExpressionRenderer,
+  getSqlSnippets, createExpressionRenderer, withoutCast,
 } = require('./utils/common');
+const {
+  getDeltaRenderer,
+} = require('./utils/delta');
 const {
   renderReferentialConstraint, getIdentifierUtils,
 } = require('./utils/sql');
@@ -74,17 +77,19 @@ const { ModelError } = require('../base/error');
  * @param {CSN.Options} options Transformation options
  * @returns {object} Dictionary of artifact-type:artifacts, where artifacts is a dictionary of name:content
  */
-function toSqlDdl(csn, options) {
+function toSqlDdl( csn, options ) {
   timetrace.start('SQL rendering');
   const {
     error, warning, info, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.sql');
-  const { quoteSqlId, prepareIdentifier } = getIdentifierUtils(options);
-  const renderExpr = getExpressionRenderer({
+  const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options);
+
+  const exprRenderer = createExpressionRenderer({
+    // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
     finalize: x => String(x).toUpperCase(),
-    explicitTypeCast: (x, env) => {
+    typeCast(x) {
       const typeRef = renderBuiltinType(x.cast.type) + renderTypeParameters(x.cast);
-      return `CAST(${renderExpr(x, env)} AS ${typeRef})`;
+      return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
     enum: (x) => {
@@ -94,131 +99,39 @@ function toSqlDdl(csn, options) {
       return '';
     },
     ref: renderExpressionRef,
-    aliasOnly(x, _env) {
-      return x.as;
-    },
-    windowFunction: (x, env) => renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, env),
-    func: (x, env) => renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, a => renderArgs(a, '=>', env, null)),
-    xpr(x, env) {
-      if (this.nestedExpr && !x.cast)
-        return `(${renderExpr(x.xpr, env, this.inline, true)})`;
-
-      return renderExpr(x.xpr, env, this.inline, true);
-    },
-    SELECT: (x, env) => `(${renderQuery('<subselect>', x, increaseIndent(env))})`,
-    SET: (x, env) => `(${renderQuery('<union>', x, increaseIndent(env))})`,
-  });
-
-  // Utils to render SQL statements.
-  const render = {
-    /*
-      Render column additions as HANA SQL. Checks for duplicate elements.
-      Only HANA SQL is currently supported.
-     */
-    addColumns: {
-      fromElementStrings(tableName, eltStrings) {
-        if (options.sqlDialect === 'sqlite') // SQLite can only alter one column at a time
-          return eltStrings.map(eltString => `ALTER TABLE ${tableName} ADD ${eltString};`);
-
-        const elts = options.sqlDialect === 'hana' ? `(${eltStrings.join(', ')})` : `${eltStrings.join(', ')}`;
-        return [ `ALTER TABLE ${tableName} ADD ${elts};` ];
-      },
-      fromElementsObj(artifactName, tableName, elementsObj, env, duplicateChecker) {
-        // Only extend with 'ADD' for elements/associations
-        // TODO: May also include 'RENAME' at a later stage
-        const alterEnv = activateAlterMode(env);
-        const elements = Object.entries(elementsObj)
-          .map(([ name, elt ]) => renderElement(artifactName, name, elt, duplicateChecker, null, alterEnv))
-          .filter(s => s !== '');
-
-        if (elements.length)
-          return render.addColumns.fromElementStrings(tableName, elements);
-
-        return [];
-      },
+    aliasOnly: x => x.as,
+    windowFunction( x) {
+      return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
     },
-    /*
-      Render association additions as HANA SQL.
-      TODO duplicity check
-     */
-    addAssociations(artifactName, tableName, elementsObj, env) {
-      return options.sqlDialect === 'hana' ? Object.entries(elementsObj)
-        .map(([ name, elt ]) => renderAssociationElement(name, elt, env))
-        .filter(s => s !== '')
-        .map(eltStr => `ALTER TABLE ${tableName} ADD ASSOCIATION (${eltStr});`) : [];
+    func(x) {
+      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, a => renderArgs(a, '=>', this.env, null));
     },
-    /*
-      Render key addition as HANA SQL.
-     */
-    addKey(tableName, elementsObj) {
-      return [ `ALTER TABLE ${tableName} ADD ${render.primaryKey(elementsObj)}` ];
+    xpr(x) {
+      if (this.isNestedXpr && !x.cast)
+        return `(${this.renderSubExpr(x.xpr)})`;
+      return this.renderSubExpr(x.xpr);
     },
-    /*
-      Render column removals as HANA SQL.
-     */
-    dropColumns(tableName, sqlIds) {
-      return [ `ALTER TABLE ${tableName} DROP ${options.sqlDialect === 'hana' ? '(' : ''}${sqlIds.join(', ')}${options.sqlDialect === 'hana' ? ')' : ''};` ];
+    SELECT( x) {
+      return `(${renderQuery('<subselect>', x, increaseIndent(this.env))})`;
     },
-    /*
-      Render association removals as HANA SQL.
-     */
-    dropAssociation(tableName, sqlId) {
-      return options.sqlDialect === 'hana' ? [ `ALTER TABLE ${tableName} DROP ASSOCIATION ${sqlId};` ] : [];
+    SET( x) {
+      return `(${renderQuery('<union>', x, increaseIndent(this.env))})`;
     },
-    /*
-      Render primary-key removals as HANA SQL.
-     */
-    dropKey(tableName) {
-      return [ `ALTER TABLE ${tableName} DROP PRIMARY KEY;` ];
-    },
-    /*
-      Render column modifications as HANA SQL.
-     */
-    alterColumns(tableName, definitionsStr) {
-      return [ `ALTER TABLE ${tableName} ALTER (${definitionsStr});` ];
-    },
-    /*
-      Render primary keys as HANA SQL.
-     */
-    primaryKey(elementsObj) {
-      const primaryKeys = Object.keys(elementsObj)
-        .filter(name => elementsObj[name].key)
-        .filter(name => !elementsObj[name].virtual)
-        .map(name => quoteSqlId(name))
-        .join(', ');
-      return primaryKeys && `PRIMARY KEY(${primaryKeys})`;
-    },
-    /*
-      Render entity-comment modifications as HANA SQL.
-     */
-    alterEntityComment(tableName, comment) {
-      return [ `COMMENT ON TABLE ${tableName} IS ${render.comment(comment)};` ];
-    },
-    /*
-      Render column-comment modifications as HANA SQL.
-     */
-    alterColumnComment(tableName, columnName, comment) {
-      return [ `COMMENT ON COLUMN ${tableName}.${columnName} IS ${render.comment(comment)};` ];
-    },
-    /*
-      Render comment string.
-     */
-    comment(comment) {
-      return comment && renderStringForSql(getHanaComment({ doc: comment }), options.sqlDialect) || 'NULL';
-    },
-    /*
-      Alter SQL snippet for entity.
-     */
-    alterEntitySqlSnippet(tableName, snippet) {
-      return [ `ALTER TABLE ${tableName} ${snippet};` ];
-    },
-    /*
-      Concatenate multiple statements which are to be treated as one by the API caller.
-     */
-    concat(...statements) {
-      return [ statements.join('\n') ];
-    },
-  };
+  });
+
+  function renderExpr( x, env ) {
+    return exprRenderer.renderExpr(x, env);
+  }
+
+  const render = getDeltaRenderer(options, {
+    renderElement,
+    renderArtifactName,
+    renderAssociationElement,
+    quoteSqlId,
+    renderStringForSql,
+    activateAlterMode,
+    getHanaComment,
+  });
 
   // FIXME: Currently requires 'options.forHana', because it can only render HANA-ish SQL dialect
   if (!options.forHana && !isBetaEnabled(options, 'sqlExtensions'))
@@ -339,8 +252,7 @@ function toSqlDdl(csn, options) {
   for (const name in deletions)
     deletions[name] = `${options.testMode ? '' : sqlVersionLine}${deletions[name]}`;
 
-
-  timetrace.stop();
+  timetrace.stop('SQL rendering');
   return mainResultObj;
 
   /**
@@ -351,7 +263,7 @@ function toSqlDdl(csn, options) {
    * @param {object} resultObj Result collector
    * @param {object} env Render environment
    */
-  function renderArtifactInto(artifactName, art, resultObj, env) {
+  function renderArtifactInto( artifactName, art, resultObj, env ) {
     // Ignore whole artifacts if forRelationalDB says so
     if (art.abstract || hasValidSkipOrExists(art))
       return;
@@ -393,7 +305,7 @@ function toSqlDdl(csn, options) {
    * @param {object} resultObj Result collector
    * @param {object} env Render environment
    */
-  function renderArtifactExtensionInto(artifactName, artifact, ext, resultObj, env) {
+  function renderArtifactExtensionInto( artifactName, artifact, ext, resultObj, env ) {
     // Property kind is always omitted for elements and can be omitted for
     // top-level type definitions, it does not exist for extensions.
     if (artifactName && !ext.query)
@@ -404,52 +316,36 @@ function toSqlDdl(csn, options) {
   }
 
   // Render an artifact deletion into the appropriate dictionary of 'resultObj'.
-  function renderArtifactDeletionInto(artifactName, art, resultObj) {
+  function renderArtifactDeletionInto( artifactName, art, resultObj ) {
     const tableName = renderArtifactName(artifactName);
     deletionsDuplicateChecker.addArtifact(tableName, art.$location, artifactName);
 
     addDeletion(resultObj, artifactName, `DROP TABLE ${tableName}`);
   }
 
-  /**
-   * Given the following artifact name: namespace.prefix.entity.with.dot, render the following,
-   * depending on the naming mode:
-   * - plain: NAMESPACE_PREFIX_ENTITY_WITH_DOT
-   * - quoted: namespace.prefix.entity_with_dot
-   * - hdbcds: namespace::prefix.entity_with_dot
-   *
-   *
-   * @param {string} artifactName Artifact name to render
-   *
-   * @returns {string} Artifact name
-   */
-  function renderArtifactName(artifactName) {
-    return quoteSqlId(getResultingName(csn, options.sqlMapping, artifactName));
-  }
-
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
   // Only HANA SQL is currently supported.
-  function renderArtifactMigrationInto(artifactName, migration, resultObj, env) {
-    function reducesTypeSize(def) {
+  function renderArtifactMigrationInto( artifactName, migration, resultObj, env ) {
+    function reducesTypeSize( def ) {
       // HANA does not allow decreasing the value of any of those type parameters.
       return def.old.type === def.new.type &&
         [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
     }
-    function getEltStr(defVariant, eltName) {
+    function getEltStr( defVariant, eltName, changeType = 'extension' ) {
       return defVariant.target
         ? renderAssociationElement(eltName, defVariant, env)
-        : renderElement(artifactName, eltName, defVariant, null, null, activateAlterMode(env));
+        : renderElement(artifactName, eltName, defVariant, null, null, activateAlterMode(env, changeType));
     }
-    function getEltStrNoProps(defVariant, eltName, ...props) {
+    function getEltStrNoProps( defVariant, eltName, ...props ) {
       const defNoProps = Object.assign({}, defVariant);
       for (const prop of props)
         delete defNoProps[prop];
       return getEltStr(defNoProps, eltName);
     }
-    function oldAnnoChangedIncompatibly(defOld, defNew) {
+    function oldAnnoChangedIncompatibly( defOld, defNew ) {
       return typeof defOld === 'string' && defOld.trim().length && !(typeof defNew === 'string' && defNew.trim().startsWith(`${defOld.trim()} `));
     }
-    function getUnknownSqlReason(anno, artName, defOld, defNew, eltName) {
+    function getUnknownSqlReason( anno, artName, defOld, defNew, eltName ) {
       const changeKind = defNew === undefined
         ? `removed (previous value: ${JSON.stringify(defOld)})`
         : `changed from ${JSON.stringify(defOld)} to ${JSON.stringify(defNew)}`;
@@ -466,7 +362,7 @@ function toSqlDdl(csn, options) {
     if (migration.properties) {
       for (const [ prop, def ] of Object.entries(migration.properties)) {
         if (prop === 'doc' && !options.disableHanaComments) { // def.new may be `null`
-          const alterComment = render.alterEntityComment(tableName, def.new);
+          const alterComment = render.alterEntityComment(artifactName, def.new);
           addMigration(resultObj, artifactName, false, alterComment);
         }
         else if (sqlSnippetAnnos.includes(prop)) { // NOTE: @sql.replace may be supported in the future
@@ -475,7 +371,7 @@ function toSqlDdl(csn, options) {
             addMigration(resultObj, artifactName, false, null, getUnknownSqlReason(prop, artifactName, def.old, def.new));
           }
           else {
-            addMigration(resultObj, artifactName, false, render.alterEntitySqlSnippet(tableName, def.new));
+            addMigration(resultObj, artifactName, false, render.alterEntitySqlSnippet(artifactName, def.new));
           }
         }
       }
@@ -493,10 +389,10 @@ function toSqlDdl(csn, options) {
 
         // Remove columns.
         if (removeCols.length)
-          addMigration(resultObj, artifactName, true, render.dropColumns(tableName, removeCols));
+          addMigration(resultObj, artifactName, true, render.dropColumns(artifactName, removeCols));
 
         // Remove associations.
-        removeAssocs.forEach(assoc => addMigration(resultObj, artifactName, true, render.dropAssociation(tableName, assoc)));
+        removeAssocs.forEach(assoc => addMigration(resultObj, artifactName, true, render.dropAssociation(artifactName, assoc)));
       }
     }
 
@@ -507,8 +403,8 @@ function toSqlDdl(csn, options) {
         const sqlId = quoteSqlId(eltName);
         changeElementsDuplicateChecker.addElement(sqlId, undefined, eltName);
 
-        const eltStrOld = getEltStr(def.old, eltName);
-        const eltStrNew = getEltStr(def.new, eltName);
+        const eltStrOld = getEltStr(def.old, eltName, 'migration');
+        const eltStrNew = getEltStr(def.new, eltName, 'migration');
         if (eltStrNew === eltStrOld)
           return; // Prevent spurious migrations, where the column DDL does not change.
 
@@ -535,7 +431,7 @@ function toSqlDdl(csn, options) {
           const eltStrOldNoDoc = getEltStrNoProps(def.old, eltName, 'doc');
           const eltStrNewNoDoc = getEltStrNoProps(def.new, eltName, 'doc');
           if (eltStrOldNoDoc === eltStrNewNoDoc) { // only `doc` changed
-            const alterComment = render.alterColumnComment(tableName, sqlId, def.new.doc);
+            const alterComment = render.alterColumnComment(artifactName, sqlId, def.new.doc);
             addMigration(resultObj, artifactName, false, alterComment);
             continue;
           }
@@ -545,16 +441,16 @@ function toSqlDdl(csn, options) {
           // Lossy change because either an association is removed and/or added, or the type size is reduced.
           // Drop old element and re-add it in its new shape.
           const drop = def.old.target
-            ? render.dropAssociation(tableName, sqlId)
-            : render.dropColumns(tableName, [ sqlId ]);
+            ? render.dropAssociation(artifactName, sqlId)
+            : render.dropColumns(artifactName, [ sqlId ]);
           const add = def.new.target
-            ? render.addAssociations(artifactName, tableName, { [eltName]: def.new }, env)
-            : render.addColumns.fromElementsObj(artifactName, tableName, { [eltName]: def.new }, env);
+            ? render.addAssociations(artifactName, { [eltName]: def.new }, env)
+            : render.addColumnsFromElementsObj(artifactName, { [eltName]: def.new }, env);
           addMigration(resultObj, artifactName, true, render.concat(...drop, ...add));
         }
         else {
           // Lossless change: no associations directly affected, no size reduction.
-          addMigration(resultObj, artifactName, false, render.alterColumns(tableName, eltStrNew));
+          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew));
         }
       }
     }
@@ -569,7 +465,7 @@ function toSqlDdl(csn, options) {
    * @param {object} resultObj Result collector
    * @param {object} env Render environment
    */
-  function renderEntityInto(artifactName, art, resultObj, env) {
+  function renderEntityInto( artifactName, art, resultObj, env ) {
     env._artifact = art;
     const childEnv = increaseIndent(env);
     const hanaTc = art.technicalConfig && art.technicalConfig.hana;
@@ -678,23 +574,23 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @param {DuplicateChecker} duplicateChecker
    */
-  function renderExtendInto(artifactName, artifactElements, extElements, resultObj, env, duplicateChecker) {
+  function renderExtendInto( artifactName, artifactElements, extElements, resultObj, env, duplicateChecker ) {
     const tableName = renderArtifactName(artifactName);
     if (duplicateChecker)
       duplicateChecker.addArtifact(tableName, undefined, artifactName);
-    const elements = render.addColumns.fromElementsObj(artifactName, tableName, extElements, env, duplicateChecker);
-    const associations = render.addAssociations(artifactName, tableName, extElements, env);
+    const elements = render.addColumnsFromElementsObj(artifactName, extElements, env, duplicateChecker);
+    const associations = render.addAssociations(artifactName, extElements, env);
     if (elements.length + associations.length > 0)
       addMigration(resultObj, artifactName, false, [ ...elements, ...associations ]);
 
     if (Object.values(extElements).some(elt => elt.key)) {
-      const drop = render.dropKey(tableName);
-      const add = render.addKey(tableName, artifactElements);
+      const drop = render.dropKey(artifactName);
+      const add = render.addKey(artifactName, artifactElements);
       addMigration(resultObj, artifactName, true, render.concat(...drop, ...add));
     }
   }
 
-  function addMigration(resultObj, artifactName, drop, sqlArray, description) {
+  function addMigration( resultObj, artifactName, drop, sqlArray, description ) {
     if (!(artifactName in resultObj.migrations))
       resultObj.migrations[artifactName] = [];
 
@@ -707,7 +603,7 @@ function toSqlDdl(csn, options) {
     resultObj.migrations[artifactName].push(...migrations);
   }
 
-  function addDeletion(resultObj, artifactName, deletionSql) {
+  function addDeletion( resultObj, artifactName, deletionSql ) {
     resultObj.deletions[artifactName] = deletionSql;
   }
 
@@ -718,7 +614,7 @@ function toSqlDdl(csn, options) {
    * @param {object} hanaTc Technical configuration object
    * @returns {object} fzindex for the element
    */
-  function getFzIndex(elemName, hanaTc) {
+  function getFzIndex( elemName, hanaTc ) {
     if (!hanaTc || !hanaTc.fzindexes || !hanaTc.fzindexes[elemName])
       return undefined;
 
@@ -748,15 +644,16 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered element
    */
-  function renderElement(artifactName, elementName, elm, duplicateChecker, fzindex, env) {
+  function renderElement( artifactName, elementName, elm, duplicateChecker, fzindex, env ) {
     if (elm.virtual || elm.target)
       return '';
 
+    const isPostgresAlterColumn = env.alterMode && env.changeType === 'migration' && options.sqlDialect === 'postgres';
     const quotedElementName = quoteSqlId(elementName);
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
-    let result = `${env.indent + quotedElementName} ${renderTypeReference(artifactName, elementName, elm)
+    let result = `${env.indent + quotedElementName}${isPostgresAlterColumn ? ' TYPE' : ''} ${renderTypeReference(artifactName, elementName, elm)
     }${renderNullability(elm, true, env.alterMode)}`;
     if (elm.default)
       result += ` DEFAULT ${renderExpr(elm.default, env)}`;
@@ -791,7 +688,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered association element
    */
-  function renderAssociationElement(elementName, elm, env) {
+  function renderAssociationElement( elementName, elm, env ) {
     let result = '';
     if (elm.target) {
       result += env.indent;
@@ -811,7 +708,7 @@ function toSqlDdl(csn, options) {
       }
       result += ' JOIN ';
       result += `${renderArtifactName(elm.target)} AS ${quoteSqlId(elementName)} ON (`;
-      result += `${renderExpr(elm.on, env, true, true)})`;
+      result += `${renderExpr(elm.on, env)})`;
     }
     return result;
   }
@@ -827,7 +724,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered technical configuration
    */
-  function renderTechnicalConfiguration(tc, env) {
+  function renderTechnicalConfiguration( tc, env ) {
     let result = '';
 
     if (!tc)
@@ -871,7 +768,7 @@ function toSqlDdl(csn, options) {
    * @param {object} resultObj Result collector
    * @param {object} env Render environment
    */
-  function renderIndexesInto(indexes, artifactName, resultObj, env) {
+  function renderIndexesInto( indexes, artifactName, resultObj, env ) {
     // Indices and full-text indices
     for (const idxName in indexes || {}) {
       let result = '';
@@ -903,7 +800,7 @@ function toSqlDdl(csn, options) {
      * @param {Array} index Index definition
      * @returns {Array} Index with artifact name inserted
      */
-    function insertTableName(index) {
+    function insertTableName( index ) {
       const i = index.indexOf('index');
       const j = index.indexOf('(');
       if (i > index.length - 2 || !index[i + 1].ref || j < i || j > index.length - 2)
@@ -934,7 +831,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered view source
    */
-  function renderViewSource(artifactName, source, env) {
+  function renderViewSource( artifactName, source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(artifactName, source, increaseIndent(env))})`;
@@ -953,7 +850,7 @@ function toSqlDdl(csn, options) {
           result += renderJoinCardinality(source.cardinality);
         result += `JOIN ${renderViewSource(artifactName, source.args[i], env)}`;
         if (source.on)
-          result += ` ON ${renderExpr(source.on, env, true, true)}`;
+          result += ` ON ${renderExpr(source.on, env)}`;
 
         result += ')';
       }
@@ -974,7 +871,7 @@ function toSqlDdl(csn, options) {
    * @param {object} card CSN cardinality representation
    * @returns {string} Rendered cardinality
    */
-  function renderJoinCardinality(card) {
+  function renderJoinCardinality( card ) {
     let result = '';
     if (card) {
       if (card.srcmin && card.srcmin === 1)
@@ -1002,7 +899,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered path
    */
-  function renderAbsolutePathWithAlias(artifactName, path, env) {
+  function renderAbsolutePathWithAlias( artifactName, path, env ) {
     // This actually can't happen anymore because assoc2joins should have taken care of it
     if (path.ref[0].where)
       throw new ModelError(`"${artifactName}": Filters in FROM are not supported for conversion to SQL`);
@@ -1040,7 +937,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered path
    */
-  function renderAbsolutePath(path, sep, env) {
+  function renderAbsolutePath( path, sep, env ) {
     // Sanity checks
     if (!path.ref)
       throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
@@ -1066,7 +963,7 @@ function toSqlDdl(csn, options) {
       result += '()';
     }
     if (path.ref[0].where)
-      result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env, true, true)}]`;
+      result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env)}]`;
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
@@ -1087,16 +984,16 @@ function toSqlDdl(csn, options) {
    * @returns {string} Rendered arguments
    * @throws Throws if args is not an array or object.
    */
-  function renderArgs(node, sep, env, syntax) {
+  function renderArgs( node, sep, env, syntax ) {
     const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env, true, false, true)).join(', ');
+      return args.map(arg => renderExpr(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
       // if this is a function param which is not a reference to the model, we must not quote it
-      return Object.keys(args).map(key => `${node.func ? key : decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
+      return Object.keys(args).map(key => `${node.func ? key : decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
 
 
     throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
@@ -1109,7 +1006,7 @@ function toSqlDdl(csn, options) {
      * @param {string|null} parameterSyntax Some magic A2J parameter - for calcview parameter rendering
      * @returns {string} Rendered argument
      */
-    function decorateParameter(arg, parameterSyntax) {
+    function decorateParameter( arg, parameterSyntax ) {
       if (parameterSyntax === 'calcview')
         return `PLACEHOLDER."$$${arg}$$"`;
 
@@ -1126,7 +1023,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered column
    */
-  function renderViewColumn(col, elements, env) {
+  function renderViewColumn( col, elements, env ) {
     let result = '';
     const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
     if (leaf && elements[leaf] && elements[leaf].virtual) {
@@ -1135,7 +1032,7 @@ function toSqlDdl(csn, options) {
         result += `${env.indent}NULL AS ${quoteSqlId(col.as || leaf)}`;
     }
     else {
-      result = env.indent + renderExpr(col, env, true);
+      result = env.indent + renderExpr(withoutCast(col), env);
       if (col.as)
         result += ` AS ${quoteSqlId(col.as)}`;
       else if (col.func)
@@ -1152,7 +1049,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered view
    */
-  function renderView(artifactName, art, env) {
+  function renderView( artifactName, art, env ) {
     env._artifact = art;
     const viewName = renderArtifactName(artifactName);
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
@@ -1189,7 +1086,7 @@ function toSqlDdl(csn, options) {
    * @param {Object} params Dictionary of parameters
    * @returns {string} Rendered parameters
    */
-  function renderParameterDefinitions(artifactName, params) {
+  function renderParameterDefinitions( artifactName, params ) {
     let result = '';
     if (params) {
       const parray = [];
@@ -1207,7 +1104,7 @@ function toSqlDdl(csn, options) {
           pIdentifier = quoteSqlId(pn);
         let pstr = `IN ${pIdentifier} ${renderTypeReference(artifactName, pn, p)}`;
         if (p.default)
-          pstr += ` DEFAULT ${renderExpr(p.default)}`;
+          pstr += ` DEFAULT ${renderExpr(p.default, { indent: '' })}`;
 
         parray.push(pstr);
       }
@@ -1225,7 +1122,7 @@ function toSqlDdl(csn, options) {
    * @param {CSN.Elements} [elements] to override direct query elements - e.g. leading union should win
    * @returns {string} Rendered query
    */
-  function renderQuery(artifactName, query, env, elements = null) {
+  function renderQuery( artifactName, query, env, elements = null ) {
     let result = '';
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
@@ -1262,19 +1159,19 @@ function toSqlDdl(csn, options) {
     result += `SELECT${select.distinct ? ' DISTINCT' : ''}`;
     // FIXME: We probably also need to consider `excluding` here ?
     result += `\n${(select.columns || [ '*' ])
-      .filter(col => !(select.mixin || Object.create(null))[firstPathStepId(col.ref)]) // No mixin columns
+      .filter(col => !select.mixin?.[firstPathStepId(col.ref)]) // No mixin columns
       .map(col => renderViewColumn(col, elements || select.elements, childEnv))
       .filter(s => s !== '')
       .join(',\n')}\n`;
     result += `${env.indent}FROM ${renderViewSource(artifactName, select.from, env)}`;
     if (select.where)
-      result += `\n${env.indent}WHERE ${renderExpr(select.where, env, true, true)}`;
+      result += `\n${env.indent}WHERE ${renderExpr(select.where, env)}`;
 
     if (select.groupBy)
-      result += `\n${env.indent}GROUP BY ${select.groupBy.map(expr => renderExpr(expr, env, true, false, true)).join(', ')}`;
+      result += `\n${env.indent}GROUP BY ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
 
     if (select.having)
-      result += `\n${env.indent}HAVING ${renderExpr(select.having, env, true, true)}`;
+      result += `\n${env.indent}HAVING ${renderExpr(select.having, env)}`;
 
     if (select.orderBy)
       result += `\n${env.indent}ORDER BY ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
@@ -1291,7 +1188,7 @@ function toSqlDdl(csn, options) {
    * @param {Array} ref Array of refs
    * @returns {string|undefined} Id of first path step
    */
-  function firstPathStepId(ref) {
+  function firstPathStepId( ref ) {
     return ref && ref[0] && (ref[0].id || ref[0]);
   }
 
@@ -1302,7 +1199,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Renderenvironment
    * @returns {string} Rendered LIMIT clause
    */
-  function renderLimit(limit, env) {
+  function renderLimit( limit, env ) {
     let result = '';
     if (limit.rows !== undefined)
       result += `LIMIT ${renderExpr(limit.rows, env)}`;
@@ -1321,8 +1218,8 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {string} Rendered ORDER BY entry
    */
-  function renderOrderByEntry(entry, env) {
-    let result = renderExpr(entry, env, true, false, true);
+  function renderOrderByEntry( entry, env ) {
+    let result = renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort.toUpperCase()}`;
 
@@ -1340,7 +1237,7 @@ function toSqlDdl(csn, options) {
    * @param {CSN.Element} elm CSN element
    * @returns {string} Rendered type reference
    */
-  function renderTypeReference(artifactName, elementName, elm) {
+  function renderTypeReference( artifactName, elementName, elm ) {
     let result = '';
 
     // Anonymous structured type: Not supported with SQL (but shouldn't happen anyway after forHana flattened them)
@@ -1382,7 +1279,7 @@ function toSqlDdl(csn, options) {
    * @param {string} typeName Name of the type
    * @returns {string} Rendered type
    */
-  function renderBuiltinType(typeName) {
+  function renderBuiltinType( typeName ) {
     const forHanaRenamesToEarly = {
       'cds.UTCDateTime': 'cds.DateTime',
       'cds.UTCTimestamp': 'cds.Timestamp',
@@ -1402,7 +1299,7 @@ function toSqlDdl(csn, options) {
    * @param {boolean} deltaMode Look for a $notNull and use that with precedence over notNull
    * @returns {string} NULL/NOT NULL or ''
    */
-  function renderNullability(obj, treatKeyAsNotNull = false, deltaMode = false) {
+  function renderNullability( obj, treatKeyAsNotNull = false, deltaMode = false ) {
     if (deltaMode && obj.$notNull !== undefined) { // can be set via compare.js if it goes from "not null" to implicit "null"
       return obj.$notNull ? ' NOT NULL' : ' NULL';
     }
@@ -1422,7 +1319,7 @@ function toSqlDdl(csn, options) {
    * @param {CSN.Element} elm CSN element
    * @returns {string} Rendered type parameters
    */
-  function renderTypeParameters(elm) {
+  function renderTypeParameters( elm ) {
     const params = [];
     // Length, precision and scale (even if incomplete)
     if (elm.length !== undefined)
@@ -1444,7 +1341,7 @@ function toSqlDdl(csn, options) {
     return params.length === 0 ? '' : `(${params.join(', ')})`;
   }
 
-  function renderExpressionLiteral(x) {
+  function renderExpressionLiteral( x ) {
     // Literal value, possibly with explicit 'literal' property
     switch (x.literal || typeof x.val) {
       case 'number':
@@ -1478,7 +1375,7 @@ function toSqlDdl(csn, options) {
     }
   }
 
-  function renderExpressionRef(x, env) {
+  function renderExpressionRef( x, env ) {
     if (!x.param && !x.global) {
       const magicReplacement = getVariableReplacement(x.ref, options);
 
@@ -1610,7 +1507,7 @@ function toSqlDdl(csn, options) {
      * @param {number} idx index of the path step in the overall path
      * @returns {string} Rendered path step
      */
-    function renderPathStep(s, idx) {
+    function renderPathStep( s, idx ) {
       // Simple id or absolute name
       if (typeof (s) === 'string') {
         // TODO: When is this actually executed and not handled already in renderExpr?
@@ -1650,7 +1547,7 @@ function toSqlDdl(csn, options) {
         if (s.where) {
           // Filter, possibly with cardinality
           // FIXME: Does SQL understand filter cardinalities?
-          result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, true, true)}]`;
+          result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env)}]`;
         }
         return result;
       }
@@ -1659,10 +1556,9 @@ function toSqlDdl(csn, options) {
     }
   }
 
-  function renderWindowFunction(funcName, node, fctEnv) {
-    const suffix = node.xpr[0]; // OVER
-    let r = `${funcName}(${renderArgs(node, '=>', fctEnv, null)})`;
-    r += ` ${suffix} (${renderExpr(node.xpr.slice(1), fctEnv)})`; // do not pass suffix in renderExpr
+  function renderWindowFunction( funcName, node, fctEnv ) {
+    let r = `${funcName}(${renderArgs(node, '=>', fctEnv, null)}) `;
+    r += renderExpr(node.xpr, fctEnv); // xpr[0] is 'over'
     return r;
   }
 
@@ -1672,17 +1568,18 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    * @returns {object} Render environment with increased indent
    */
-  function increaseIndent(env) {
+  function increaseIndent( env ) {
     return Object.assign({}, env, { indent: `${env.indent}  ` });
   }
   /**
    * Returns a copy of 'env' with alterMode set to true
    *
    * @param {object} env Render environment
+   * @param {string} changeType 'extension' or 'migration'
    * @returns {object} Render environment with alterMode
    */
-  function activateAlterMode(env) {
-    return Object.assign({ alterMode: true }, env);
+  function activateAlterMode( env, changeType ) {
+    return Object.assign({ alterMode: true, changeType }, env);
   }
 }
 
@@ -1693,8 +1590,8 @@ function toSqlDdl(csn, options) {
  * @param {string} sqlDialect
  * @return {string}
  */
-function renderStringForSql(str, sqlDialect) {
-  if (sqlDialect === 'hana' || sqlDialect === 'sqlite') {
+function renderStringForSql( str, sqlDialect ) {
+  if (sqlDialect === 'hana' || sqlDialect === 'sqlite' || sqlDialect === 'h2') {
     // SQLite
     // ======
     // SQLite's tokenizer available at
@@ -1704,6 +1601,13 @@ function renderStringForSql(str, sqlDialect) {
     // <https://sqlite.org/nulinstr.html>.
     //
     //
+    // H2
+    // ======
+    // H2's tokenizer available at
+    // <https://github.com/h2database/h2database/blob/master/h2/src/main/org/h2/command/Tokenizer.java>.
+    // For strings, see method "readCharacterString()".
+    //
+    //
     // HANA
     // ====
     // Respects the specification available at