@sap/cds-compiler 3.4.0 → 3.4.4

package/lib/render/toHdbcds.js

@@ -7,9 +7,9 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
+  renderFunc, createExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
   hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
-  cdsToSqlTypes, cdsToHdbcdsTypes,
+  cdsToSqlTypes, cdsToHdbcdsTypes, withoutCast,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -70,37 +70,41 @@ function toHdbcdsSource(csn, options) {
     info, warning, error, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.hdbcds');
 
-  const renderExpr = getExpressionRenderer({
+  const exprRenderer = createExpressionRenderer({
     finalize: x => x,
-    explicitTypeCast(x, env) {
-      let typeRef = renderTypeReference(x.cast, env);
-
+    typeCast(x) {
+      let typeRef = renderTypeReference(x.cast, this.env);
       // inside a cast expression, the cds and hana cds types need to be mapped to hana sql types
       const hanaSqlType = cdsToSqlTypes.hana[x.cast.type] || cdsToSqlTypes.standard[x.cast.type];
       if (hanaSqlType) {
         const typeRefWithoutParams = typeRef.substring(0, typeRef.indexOf('(')) || typeRef;
         typeRef = typeRef.replace(typeRefWithoutParams, hanaSqlType);
       }
-      return `CAST(${renderExpr(x, env)} AS ${typeRef})`;
+      return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
     enum: x => `#${x['#']}`,
     ref: renderExpressionRef,
-    aliasOnly(x, _env) {
-      return x.as;
-    },
+    aliasOnly: x => x.as,
     windowFunction: renderExpressionFunc,
     func: renderExpressionFunc,
-    xpr(x, env) {
-      if (this.nestedExpr && !x.cast)
-        return `(${renderExpr(x.xpr, env, this.inline, true)})`;
-
-      return renderExpr(x.xpr, env, this.inline, true);
+    xpr(x) {
+      if (this.isNestedXpr && !x.cast)
+        return `(${this.renderSubExpr(x.xpr)})`;
+      return this.renderSubExpr(x.xpr);
+    },
+    SELECT(x) {
+      return `(${renderQuery(x, false, increaseIndent(this.env))})`;
+    },
+    SET(x) {
+      return `${renderQuery(x, false, increaseIndent(this.env))}`;
     },
-    SELECT: (x, env) => `(${renderQuery(x, false, increaseIndent(env))})`,
-    SET: (x, env) => `${renderQuery(x, false, increaseIndent(env))}`,
   });
 
+  function renderExpr(x, env) {
+    return exprRenderer.renderExpr(x, env);
+  }
+
   checkCSNVersion(csn, options);
 
   const hdbcdsResult = Object.create(null);
@@ -647,7 +651,7 @@ function toHdbcdsSource(csn, options) {
         result = `(${result} ${source.join} `;
         result += `join ${renderViewSource(source.args[i], env)}`;
         if (source.on)
-          result += ` on ${renderExpr(source.on, env, true, true)}`;
+          result += ` on ${renderExpr(source.on, env)}`;
 
         result += ')';
       }
@@ -688,7 +692,7 @@ function toHdbcdsSource(csn, options) {
       result += `(${renderArgs(path.ref[0], ':', env)})`;
 
     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)
@@ -761,7 +765,7 @@ function toHdbcdsSource(csn, options) {
         error(null, env.path, { tokensymbol: 'key', $reviewed: true }, 'Unexpected $(TOKENSYMBOL) in subquery');
 
       const key = (!env.skipKeys && (col.key || (element && element.key)) ? 'key ' : '');
-      result += key + renderExpr(col, env, true);
+      result += key + renderExpr(withoutCast(col), env);
       let alias = col.as || col.func;
       // HANA requires an alias for 'key' columns just for syntactical reasons
       // FIXME: This will not complain for non-refs (but that should be checked in forRelationalDB)
@@ -779,7 +783,7 @@ function toHdbcdsSource(csn, options) {
         // Redirections are never flattened (don't exist in HANA)
         result += ` : redirected to ${renderAbsoluteNameWithQuotes(col.cast.target, env)}`;
         if (col.cast.on)
-          result += ` on ${renderExpr(col.cast.on, env, true, true)}`;
+          result += ` on ${renderExpr(col.cast.on, env)}`;
       }
 
       return result;
@@ -910,13 +914,13 @@ function toHdbcdsSource(csn, options) {
    */
   function renderSelectProperties(select, alreadyRendered, env) {
     if (select.where)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env, true, true)}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env)}`;
 
     if (select.groupBy)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env, true, false, true)).join(', ')}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
 
     if (select.having)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env, true, true)}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env)}`;
 
     if (select.orderBy)
       alreadyRendered += `${continueIndent(alreadyRendered, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
@@ -970,7 +974,7 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Rendered order by
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderExpr(entry, env, true, false, true);
+    let result = renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1118,7 +1122,7 @@ function toHdbcdsSource(csn, options) {
 
     // ON-condition (if any)
     if (elm.on) {
-      result += ` on ${renderExpr(elm.on, env, true, true)}`;
+      result += ` on ${renderExpr(elm.on, env)}`;
     }
     else if (elm.targetAspect && elm.targetAspect.elements) { // anonymous aspect
       const childEnv = increaseIndent(env);
@@ -1159,7 +1163,7 @@ function toHdbcdsSource(csn, options) {
    * @param {number} idx Path position
    * @returns {string} Rendered path step
    */
-  function renderPathStep(s, idx, ref, env, inline) {
+  function renderPathStep(s, idx, ref, env) {
     // Simple id or absolute name
     if (typeof s === 'string') {
       // HANA-specific extra magic (should actually be in forRelationalDB)
@@ -1210,7 +1214,7 @@ function toHdbcdsSource(csn, options) {
       }
       if (s.where) {
         // Filter, possibly with cardinality
-        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
+        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env)}]`;
       }
       return result;
     }
@@ -1250,16 +1254,15 @@ function toHdbcdsSource(csn, options) {
    * Render the given expression x - which has a .func property
    *
    * @param {object} x
-   * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderExpressionFunc(x, env) {
+  function renderExpressionFunc(x) {
     const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
     const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
     // we can't quote functions with parens, issue warning if it is a reserved keyword
     if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
       warning(null, x.$location, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
-    return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
+    return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', this.env));
   }
 
   /**
@@ -1267,7 +1270,7 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Rendered expression
    * @todo no extra magic with x.param or x.global
    */
-  function renderExpressionRef(x, env) {
+  function renderExpressionRef(x) {
     if (!x.param && !x.global) {
       const magicReplacement = getVariableReplacement(x.ref, options);
       if (x.ref[0] === '$user') {
@@ -1294,7 +1297,7 @@ function toHdbcdsSource(csn, options) {
         return renderStringForHdbcds(magicReplacement);
       }
     }
-    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, env, this.inline)).join('.')}`;
+    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, this.env)).join('.')}`;
   }
 
   /**
@@ -1310,12 +1313,12 @@ function toHdbcdsSource(csn, options) {
     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 : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
+      return Object.keys(args).map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
 
 
     throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);

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');
@@ -80,11 +83,13 @@ function toSqlDdl(csn, options) {
     error, warning, info, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.sql');
   const { quoteSqlId, prepareIdentifier } = getIdentifierUtils(options);
-  const renderExpr = getExpressionRenderer({
+
+  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 [];
-      },
-    },
-    /*
-      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});`) : [];
-    },
-    /*
-      Render key addition as HANA SQL.
-     */
-    addKey(tableName, elementsObj) {
-      return [ `ALTER TABLE ${tableName} ADD ${render.primaryKey(elementsObj)}` ];
-    },
-    /*
-      Render column removals as HANA SQL.
-     */
-    dropColumns(tableName, sqlIds) {
-      return [ `ALTER TABLE ${tableName} DROP ${options.sqlDialect === 'hana' ? '(' : ''}${sqlIds.join(', ')}${options.sqlDialect === 'hana' ? ')' : ''};` ];
-    },
-    /*
-      Render association removals as HANA SQL.
-     */
-    dropAssociation(tableName, sqlId) {
-      return options.sqlDialect === 'hana' ? [ `ALTER TABLE ${tableName} DROP ASSOCIATION ${sqlId};` ] : [];
-    },
-    /*
-      Render primary-key removals as HANA SQL.
-     */
-    dropKey(tableName) {
-      return [ `ALTER TABLE ${tableName} DROP PRIMARY KEY;` ];
+    aliasOnly: x => x.as,
+    windowFunction( x) {
+      return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
     },
-    /*
-      Render column modifications as HANA SQL.
-     */
-    alterColumns(tableName, definitionsStr) {
-      return [ `ALTER TABLE ${tableName} ALTER (${definitionsStr});` ];
+    func(x) {
+      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, a => renderArgs(a, '=>', this.env, null));
     },
-    /*
-      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})`;
+    xpr(x) {
+      if (this.isNestedXpr && !x.cast)
+        return `(${this.renderSubExpr(x.xpr)})`;
+      return this.renderSubExpr(x.xpr);
     },
-    /*
-      Render entity-comment modifications as HANA SQL.
-     */
-    alterEntityComment(tableName, comment) {
-      return [ `COMMENT ON TABLE ${tableName} IS ${render.comment(comment)};` ];
+    SELECT( x) {
+      return `(${renderQuery('<subselect>', x, increaseIndent(this.env))})`;
     },
-    /*
-      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};` ];
+    SET( x) {
+      return `(${renderQuery('<union>', x, increaseIndent(this.env))})`;
     },
-    /*
-      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'))
@@ -435,10 +348,10 @@ function toSqlDdl(csn, options) {
       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) {
       const defNoProps = Object.assign({}, defVariant);
@@ -466,7 +379,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 +388,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 +406,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 +420,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 +448,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 +458,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));
         }
       }
     }
@@ -682,14 +595,14 @@ function toSqlDdl(csn, options) {
     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));
     }
   }
@@ -752,11 +665,12 @@ function toSqlDdl(csn, options) {
     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)}`;
@@ -811,7 +725,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;
   }
@@ -953,7 +867,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 += ')';
       }
@@ -1066,7 +980,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)
@@ -1091,12 +1005,12 @@ function toSqlDdl(csn, options) {
     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)}`);
@@ -1135,7 +1049,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)
@@ -1207,7 +1121,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);
       }
@@ -1262,19 +1176,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(', ')}`;
@@ -1322,7 +1236,7 @@ function toSqlDdl(csn, options) {
    * @returns {string} Rendered ORDER BY entry
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderExpr(entry, env, true, false, true);
+    let result = renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort.toUpperCase()}`;
 
@@ -1650,7 +1564,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;
       }
@@ -1660,9 +1574,8 @@ 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
+    let r = `${funcName}(${renderArgs(node, '=>', fctEnv, null)}) `;
+    r += renderExpr(node.xpr, fctEnv); // xpr[0] is 'over'
     return r;
   }
 
@@ -1679,10 +1592,11 @@ function toSqlDdl(csn, options) {
    * 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);
   }
 }