@sap/cds-compiler 5.9.2 → 6.0.10

package/lib/render/toSql.js

@@ -38,13 +38,15 @@ class SqlRenderEnvironment {
   path = null;
   alterMode = false;
   changeType = null;
+  /** Whether we're rendering a default value */
+  isInDefault = false;
 
   constructor(values) {
     Object.assign(this, values);
   }
 
   withIncreasedIndent() {
-    return new SqlRenderEnvironment({ ...this, indent: `  ${this.indent}` });
+    return new SqlRenderEnvironment({ ...this, indent: `  ${ this.indent }` });
   }
   withSubPath(path) {
     return new SqlRenderEnvironment({ ...this, path: [ ...this.path, ...path ] });
@@ -121,7 +123,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     finalize: x => String(x).toUpperCase(),
     typeCast(x) {
       const typeRef = renderBuiltinType(x.cast.type) + renderTypeParameters(x.cast);
-      return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
+      return `CAST(${ this.renderExpr(withoutCast(x)) } AS ${ typeRef })`;
     },
     val: renderExpressionLiteral,
     enum(x) {
@@ -134,7 +136,6 @@ function toSqlDdl( csn, options, messageFunctions ) {
     ref(x) {
       return renderExpressionRef(x, this.env);
     },
-    aliasOnly: x => x.as,
     windowFunction( x) {
       return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
     },
@@ -144,14 +145,14 @@ function toSqlDdl( csn, options, messageFunctions ) {
     xpr(x) {
       const env = this.env.withSubPath([ 'xpr' ]);
       if (this.isNestedXpr && !x.cast)
-        return `(${this.renderSubExpr(x.xpr, env)})`;
+        return `(${ this.renderSubExpr(x.xpr, env) })`;
       return this.renderSubExpr(x.xpr, env);
     },
     SELECT( x) {
-      return `(${renderQuery(x, this.env.withIncreasedIndent())})`;
+      return `(${ renderQuery(x, this.env.withIncreasedIndent()) })`;
     },
     SET( x) {
-      return `(${renderQuery(x, this.env.withIncreasedIndent())})`;
+      return `(${ renderQuery(x, this.env.withIncreasedIndent()) })`;
     },
   });
 
@@ -273,7 +274,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   Object.keys(sqlServiceEntities).forEach((sqlServiceName) => {
     const accessRole = {
       role: {
-        name: renderArtifactNameWithoutQuotes(`${sqlServiceName }.access`),
+        name: renderArtifactNameWithoutQuotes(`${ sqlServiceName }.access`),
         object_privileges: Object.entries(sqlServiceEntities[sqlServiceName]).map(([ name, entity ]) => ({
           name: renderArtifactNameWithoutQuotes(name),
           type: entity.query || entity.projection ? 'VIEW' : 'TABLE',
@@ -284,7 +285,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     };
 
     if (accessRole.role.object_privileges.length > 0)
-      mainResultObj.hdbrole[`${sqlServiceName }_access`] = JSON.stringify(accessRole, null, 2);
+      mainResultObj.hdbrole[`${ sqlServiceName }_access`] = JSON.stringify(accessRole, null, 2);
   });
 
   // Can only happen for HDI based deployment
@@ -292,7 +293,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const synonym = Object.create(null);
     Object.entries(dummySqlServiceEntities[sqlServiceName]).forEach(([ name ]) => {
       const artName = renderArtifactNameWithoutQuotes(name);
-      const dummyArtName = renderArtifactNameWithoutQuotes(`dummy.${ name}`);
+      const dummyArtName = renderArtifactNameWithoutQuotes(`dummy.${ name }`);
       synonym[artName] = {
         target: {
           object: dummyArtName,
@@ -300,7 +301,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       };
     });
 
-    mainResultObj.hdbsynonym[`${sqlServiceName}`] = JSON.stringify(synonym, null, 2);
+    mainResultObj.hdbsynonym[`${ sqlServiceName }`] = JSON.stringify(synonym, null, 2);
   });
 
   // trigger artifact and element name checks
@@ -328,7 +329,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
         // Hack: Other than in 'hdbtable' files, in HANA SQL COLUMN is not mandatory but default.
         if (options.sqlDialect === 'hana' && hdbKind === 'hdbtable' && sourceString.startsWith('COLUMN '))
           sourceString = sourceString.slice('COLUMN '.length);
-        sql[name] = `CREATE ${sourceString};`;
+        sql[name] = `CREATE ${ sourceString };`;
       }
     }
     if (options.src === 'sql')
@@ -342,7 +343,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
     forEachKey(alterStmts, (constraintName) => {
       if (!csn.unchangedConstraints?.has(constraintName))
-        constraints[constraintName] = `${alterStmts[constraintName]}`;
+        constraints[constraintName] = `${ alterStmts[constraintName] }`;
     });
     mainResultObj.constraints = constraints;
   }
@@ -351,7 +352,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     mainResultObj.sql = sql;
 
   for (const name in deletions)
-    deletions[name] = `${deletions[name]}`;
+    deletions[name] = `${ deletions[name] }`;
 
   timetrace.stop('SQL rendering');
   return mainResultObj;
@@ -404,7 +405,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
         // Ignore: not SQL-relevant
         return;
       default:
-        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${ art.kind }`);
     }
   }
 
@@ -443,7 +444,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
 
     if (!artifactName)
-      throw new ModelError(`Undefined artifact name: ${artifactName}`);
+      throw new ModelError(`Undefined artifact name: ${ artifactName }`);
   }
 
   // Render an artifact deletion into the appropriate dictionary of 'resultObj'.
@@ -451,7 +452,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const tableName = renderArtifactName(artifactName);
     deletionsDuplicateChecker.addArtifact(tableName, art.$location, artifactName);
 
-    addDeletion(resultObj, artifactName, `-- [WARNING] this statement is lossy\nDROP TABLE ${tableName}`);
+    addDeletion(resultObj, artifactName, `-- [WARNING] this statement is lossy\nDROP TABLE ${ tableName }`);
   }
 
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
@@ -474,15 +475,15 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return getEltStr(defNoProps, eltName);
     }
     function oldAnnoChangedIncompatibly( defOld, defNew ) {
-      return typeof defOld === 'string' && defOld.trim().length && !(typeof defNew === 'string' && defNew.trim().startsWith(`${defOld.trim()} `));
+      return typeof defOld === 'string' && defOld.trim().length && !(typeof defNew === 'string' && defNew.trim().startsWith(`${ defOld.trim() } `));
     }
     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)}`;
+        ? `removed (previous value: ${ JSON.stringify(defOld) })`
+        : `changed from ${ JSON.stringify(defOld) } to ${ JSON.stringify(defNew) }`;
       return eltName
-        ? `annotation ${anno} of element ${artName}:${eltName} has been ${changeKind}`
-        : `annotation ${anno} of artifact ${artName} has been ${changeKind}`;
+        ? `annotation ${ anno } of element ${ artName }:${ eltName } has been ${ changeKind }`
+        : `annotation ${ anno } of artifact ${ artName } has been ${ changeKind }`;
     }
 
     const sqlSnippetAnnos = [ '@sql.prepend', '@sql.append' ];
@@ -520,7 +521,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
         // Remove columns.
         if (removeCols.length)
-          addMigration(resultObj, artifactName, true, render.dropColumns(artifactName, removeCols).map(s => (options.src !== 'hdi' ? `-- [WARNING] this statement is lossy\n${s}` : s)));
+          addMigration(resultObj, artifactName, true, render.dropColumns(artifactName, removeCols).map(s => (options.src !== 'hdi' ? `-- [WARNING] this statement is lossy\n${ s }` : s)));
 
         // Remove associations.
         removeAssocs.forEach(assoc => addMigration(resultObj, artifactName, true, render.dropAssociation(artifactName, assoc)));
@@ -537,7 +538,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
           if (constraintType === 'referential')
             renderer = constraint => manageConstraint(constraint, csn, optionsWithDrop, '', quoteSqlId);
           else
-            renderer = (constraint, constraintName) => renderUniqueConstraintDrop(constraint, renderArtifactName(`${artifactName}_${constraintName}`), tableName, quoteSqlId);
+            renderer = (constraint, constraintName) => renderUniqueConstraintDrop(constraint, renderArtifactName(`${ artifactName }_${ constraintName }`), tableName, quoteSqlId);
           entries.forEach(( [ constraintName, constraint ]) => {
             addConstraintDeletion(resultObj, constraint.parentTable, renderer(constraint, constraintName));
           });
@@ -595,10 +596,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
           const add = def.new.target
             ? render.addAssociations(artifactName, { [eltName]: def.new }, env)
             : render.addColumnsFromElementsObj(artifactName, { [eltName]: def.new }, env);
-          addMigration(resultObj, artifactName, true, render.concat(...drop, ...add).map(s => (def.lossy !== undefined && options.src !== 'hdi' ? `-- [WARNING] this statement could ${def.lossy ? 'be lossy' : 'fail'}: ${def.details}\n${s}` : s)));
+          addMigration(resultObj, artifactName, true, render.concat(...drop, ...add).map(s => (def.lossy !== undefined && options.src !== 'hdi' ? `-- [WARNING] this statement could ${ def.lossy ? 'be lossy' : 'fail' }: ${ def.details }\n${ s }` : s)));
         }
         else { // Lossless change: no associations directly affected, no size reduction.
-          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')).map(s => (def.lossy !== undefined ? `-- [WARNING] this statement could ${def.lossy ? 'be lossy' : 'fail'}: ${def.details}\n${s}` : s)));
+          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')).map(s => (def.lossy !== undefined ? `-- [WARNING] this statement could ${ def.lossy ? 'be lossy' : 'fail' }: ${ def.details }\n${ s }` : s)));
         }
       }
     }
@@ -628,7 +629,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (options.sqlDialect === 'hana') {
       if (art.technicalConfig?.hana?.storeType) {
         // Explicitly specified
-        result += `${art.technicalConfig.hana.storeType.toUpperCase()} `;
+        result += `${ art.technicalConfig.hana.storeType.toUpperCase() } `;
       }
       else if (!front) {
         // in 'hdbtable' files, COLUMN or ROW is mandatory, and COLUMN is the default
@@ -637,7 +638,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
     const tableName = renderArtifactName(artifactName);
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art.$location, artifactName);
-    result += `TABLE ${tableName}`;
+    result += `TABLE ${ tableName }`;
     result += ' (\n';
     result += Object.keys(art.elements)
       .map(eltName => renderElement(eltName, art.elements[eltName], definitionsDuplicateChecker, getFzIndex(eltName, art.technicalConfig?.hana), childEnv))
@@ -648,11 +649,11 @@ function toSqlDdl( csn, options, messageFunctions ) {
       .map(name => quoteSqlId(name))
       .join(', ');
     if (uniqueFields !== '')
-      result += `,\n${childEnv.indent}UNIQUE(${uniqueFields})`;
+      result += `,\n${ childEnv.indent }UNIQUE(${ uniqueFields })`;
 
     const primaryKeys = render.primaryKey(art.elements);
     if (primaryKeys !== '')
-      result += `,\n${childEnv.indent}${primaryKeys}`;
+      result += `,\n${ childEnv.indent }${ primaryKeys }`;
 
     // for `to.sql` w/ dialect `hana` the constraints will be part of the alter statement
     const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres');
@@ -669,7 +670,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       }
       else {
         forEachValue(referentialConstraints, (constraint) => {
-          result += `,\n${constraint}`;
+          result += `,\n${ constraint }`;
         });
       }
     }
@@ -678,13 +679,13 @@ function toSqlDdl( csn, options, messageFunctions ) {
     // OR create a unique index for HDI
     const uniqueConstraints = art.$tableConstraints?.unique;
     for (const cn in uniqueConstraints) {
-      const constraint = renderUniqueConstraintString(uniqueConstraints[cn], renderArtifactName(`${artifactName}_${cn}`), tableName, quoteSqlId, options);
+      const constraint = renderUniqueConstraintString(uniqueConstraints[cn], renderArtifactName(`${ artifactName }_${ cn }`), tableName, quoteSqlId, options);
       if (options.src === 'hdi')
-        resultObj.hdbindex[`${artifactName}.${cn}`] = constraint;
+        resultObj.hdbindex[`${ artifactName }.${ cn }`] = constraint;
       else
-        result += `,\n${childEnv.indent}${constraint}`;
+        result += `,\n${ childEnv.indent }${ constraint }`;
     }
-    result += `${env.indent}\n)`;
+    result += `${ env.indent }\n)`;
 
     if (options.sqlDialect === 'hana')
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
@@ -696,8 +697,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
         .filter(s => s !== '')
         .join(',\n');
       if (associations !== '') {
-        result += `${env.indent} WITH ASSOCIATIONS (\n${associations}\n`;
-        result += `${env.indent})`;
+        result += `${ env.indent } WITH ASSOCIATIONS (\n${ associations }\n`;
+        result += `${ env.indent })`;
       }
     }
     // Only HANA has indices
@@ -706,7 +707,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       renderIndexesInto(art.technicalConfig?.hana?.indexes, artifactName, resultObj, env);
 
     if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
-      result += ` COMMENT ${renderStringForSql(getHanaComment(art), options.sqlDialect)}`;
+      result += ` COMMENT ${ renderStringForSql(getHanaComment(art), options.sqlDialect) }`;
 
     if (back)
       result += back;
@@ -723,7 +724,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
    * @param {object} resultObj Result collector
    */
   function renderConstraintExtendInto( artifactName, { constraint, constraintName, constraintType }, resultObj ) {
-    const result = constraintType === 'unique' ? renderUniqueConstraintAdd(constraint, renderArtifactName(`${artifactName}_${constraintName}`), renderArtifactName(constraint.parentTable), quoteSqlId, options)
+    const result = constraintType === 'unique' ? renderUniqueConstraintAdd(constraint, renderArtifactName(`${ artifactName }_${ constraintName }`), renderArtifactName(constraint.parentTable), quoteSqlId, options)
       : manageConstraint(constraint, csn, options, '', quoteSqlId);
 
     addMigration(resultObj, artifactName, false, [ result ]);
@@ -815,24 +816,26 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
-    let result = `${env.indent + quotedElementName}${isPostgresAlterColumn ? ' TYPE' : ''} ${renderTypeReference(elm, env)
-    }${renderNullability(elm, true, env.alterMode)}`;
+    let result = `${ env.indent + quotedElementName }${ isPostgresAlterColumn ? ' TYPE' : '' } ${ renderTypeReference(elm, env)
+    }${ renderNullability(elm, true, env.alterMode) }`;
     // calculated elements (on write) can't have a default; ignore it
+    env.isInDefault = true;
     if (elm.$default && env.alterMode && !elm.value && options.sqlDialect !== 'postgres')
-      result += ` DEFAULT ${renderExpr(elm.$default, env.withSubPath([ '$default' ]))}`;
+      result += ` DEFAULT ${ renderExpr(elm.$default, env.withSubPath([ '$default' ])) }`;
     else if (elm.default && !elm.value)
-      result += ` DEFAULT ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
+      result += ` DEFAULT ${ renderExpr(elm.default, env.withSubPath([ 'default' ])) }`;
+    env.isInDefault = false;
 
     // Only SAP HANA has fuzzy indices
     if (fzindex && options.sqlDialect === 'hana')
-      result += ` ${renderExpr(fzindex, env)}`;
+      result += ` ${ renderExpr(fzindex, env) }`;
 
     // (table) elements can only have a @sql.append
     const { back } = getSqlSnippets(options, elm);
     result += back; // Needs to be rendered before the COMMENT
 
     if (options.sqlDialect === 'hana' && hasHanaComment(elm, options))
-      result += ` COMMENT ${renderStringForSql(getHanaComment(elm), options.sqlDialect)}`;
+      result += ` COMMENT ${ renderStringForSql(getHanaComment(elm), options.sqlDialect) }`;
 
     return result;
   }
@@ -870,8 +873,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
         result += 'MANY TO ONE';
       }
       result += ' JOIN ';
-      result += `${renderArtifactName(elm.target)} AS ${quoteSqlId(elementName)} ON (`;
-      result += `${renderExpr(elm.on, env.withSubPath([ 'on' ]))})`;
+      result += `${ renderArtifactName(elm.target) } AS ${ quoteSqlId(elementName) } ON (`;
+      result += `${ renderExpr(elm.on, env.withSubPath([ 'on' ])) })`;
     }
     return result;
   }
@@ -917,7 +920,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       for (const xpr of tc.tableSuffix) {
         const clause = renderExpr(xpr, env);
         if (!ignore.includes(clause.toUpperCase()))
-          result += `\n${env.indent}${clause}`;
+          result += `\n${ env.indent }${ clause }`;
       }
     }
     return result;
@@ -945,10 +948,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
       }
       // FIXME: Full text index should already be different in compact CSN
       if (result.startsWith('FULLTEXT'))
-        resultObj.hdbfulltextindex[`${artifactName}.${idxName}`] = result;
+        resultObj.hdbfulltextindex[`${ artifactName }.${ idxName }`] = result;
 
       else
-        resultObj.hdbindex[`${artifactName}.${idxName}`] = result;
+        resultObj.hdbindex[`${ artifactName }.${ idxName }`] = result;
     }
 
 
@@ -967,9 +970,9 @@ function toSqlDdl( csn, options, messageFunctions ) {
       const i = index.indexOf('index');
       const j = index.indexOf('(');
       if (i > index.length - 2 || !index[i + 1].ref || j < i || j > index.length - 2)
-        throw new ModelError(`Unexpected form of index: "${index}"`);
+        throw new ModelError(`Unexpected form of index: "${ index }"`);
 
-      let indexName = renderArtifactName(`${artifactName}.${index[i + 1].ref}`);
+      let indexName = renderArtifactName(`${ artifactName }.${ index[i + 1].ref }`);
       if (options.sqlMapping === 'plain')
         indexName = indexName.replace(/(\.|::)/g, '_');
 
@@ -995,23 +998,23 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderQuerySource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      let result = `(${renderQuery(source, env.withIncreasedIndent())})`;
+      let result = `(${ renderQuery(source, env.withIncreasedIndent()) })`;
       if (source.as)
-        result += ` AS ${quoteSqlId(source.as)}`;
+        result += ` AS ${ quoteSqlId(source.as) }`;
 
       return result;
     }
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderQuerySource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
+      let result = `${ renderQuerySource(source.args[0], env.withSubPath([ 'args', 0 ])) }`;
       for (let i = 1; i < source.args.length; i++) {
-        result = `(${result} ${source.join.toUpperCase()} `;
+        result = `(${ result } ${ source.join.toUpperCase() } `;
         if (options.sqlDialect === 'hana')
           result += renderJoinCardinality(source.cardinality);
-        result += `JOIN ${renderQuerySource(source.args[i], env.withSubPath([ 'args', i ]))}`;
+        result += `JOIN ${ renderQuerySource(source.args[i], env.withSubPath([ 'args', i ])) }`;
         if (source.on)
-          result += ` ON ${renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
+          result += ` ON ${ renderExpr(source.on, env.withSubPath([ 'on' ])) }`;
 
         result += ')';
       }
@@ -1021,7 +1024,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
     // Sanity check
     if (!source.ref)
-      throw new ModelError(`Expecting ref in ${JSON.stringify(source)}`);
+      throw new ModelError(`Expecting ref in ${ JSON.stringify(source) }`);
 
     return renderAbsolutePathWithAlias(source, env);
   }
@@ -1062,7 +1065,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderAbsolutePathWithAlias( path, env ) {
     // This actually can't happen anymore because assoc2joins should have taken care of it
     if (path.ref[0].where)
-      throw new ModelError(`"At ${JSON.stringify(env.path)}": Filters in FROM are not supported for conversion to SQL (path: ${JSON.stringify(path)})`);
+      throw new ModelError(`"At ${ JSON.stringify(env.path) }": Filters in FROM are not supported for conversion to SQL (path: ${ JSON.stringify(path) })`);
 
     // SQL needs a ':' after path.ref[0] to separate associations
     let result = renderAbsolutePath(path, ':', env);
@@ -1071,13 +1074,13 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.sqlMapping, path.ref[0])) : getLastPartOfRef(path.ref);
     if (path.as) {
       // Source had an alias - render it
-      result += ` AS ${quoteSqlId(path.as)}`;
+      result += ` AS ${ quoteSqlId(path.as) }`;
     }
     else {
       const quotedAlias = quoteSqlId(implicitAlias);
       if (getLastPartOf(result) !== quotedAlias) {
         // Render an artificial alias if the result would produce a different one
-        result += ` AS ${quotedAlias}`;
+        result += ` AS ${ quotedAlias }`;
       }
     }
     return result;
@@ -1099,7 +1102,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderAbsolutePath( path, sep, env ) {
     // Sanity checks
     if (!path.ref)
-      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${ JSON.stringify(path) }`);
 
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
     const firstArtifactName = path.ref[0].id || path.ref[0];
@@ -1115,7 +1118,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const ref = csn.definitions[path.ref[0].id] || csn.definitions[path.ref[0]];
     if (ref?.params) {
       result += path.ref[0]?.args
-        ? `(${renderArgs(path.ref[0], '=>', env.withSubPath([ 'ref', 0 ]), syntax)})`
+        ? `(${ renderArgs(path.ref[0], '=>', env.withSubPath([ 'ref', 0 ]), syntax) })`
         : '()';
     }
     else if (syntax === 'udf') {
@@ -1124,13 +1127,13 @@ function toSqlDdl( csn, options, messageFunctions ) {
       result += '()';
     }
     if (path.ref[0].where) {
-      const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
-      result += `[${cardinality}${renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ]))}]`;
+      const cardinality = path.ref[0].cardinality ? (`${ path.ref[0].cardinality.max }: `) : '';
+      result += `[${ cardinality }${ renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ])) }]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `${sep}${renderTypeRef({ ref: path.ref.slice(1) }, env)}`;
+      result += `${ sep }${ renderTypeRef({ ref: path.ref.slice(1) }, env) }`;
 
     return result;
   }
@@ -1157,10 +1160,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
     // Named arguments (object/dict)
     else if (typeof node.args === 'object')
       // if this is a function param which is not a reference to the model, we must not quote it
-      return Object.keys(node.args).map(key => `${node.func ? key : decorateParameter(key, syntax)} ${sep} ${renderExpr(node.args[key], env.withSubPath([ 'args', key ]))}`).join(', ');
+      return Object.keys(node.args).map(key => `${ node.func ? key : decorateParameter(key, syntax) } ${ sep } ${ renderExpr(node.args[key], env.withSubPath([ 'args', key ])) }`).join(', ');
 
 
-    throw new ModelError(`Unknown args: ${JSON.stringify(node.args)}`);
+    throw new ModelError(`Unknown args: ${ JSON.stringify(node.args) }`);
 
 
     /**
@@ -1172,7 +1175,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
      */
     function decorateParameter( arg, parameterSyntax ) {
       if (parameterSyntax === 'calcview')
-        return `PLACEHOLDER."$$${arg}$$"`;
+        return `PLACEHOLDER."$$${ arg }$$"`;
 
       return quoteSqlId(arg);
     }
@@ -1193,14 +1196,14 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (leaf && elements[leaf]?.virtual) {
       if (isDeprecatedEnabled(options, '_renderVirtualElements'))
         // render a virtual column 'null as <alias>'
-        result += `${env.indent}NULL AS ${quoteSqlId(col.as || leaf)}`;
+        result += `${ env.indent }NULL AS ${ quoteSqlId(col.as || leaf) }`;
     }
     else {
       result = env.indent + renderExpr(withoutCast(col), env);
       if (col.as)
-        result += ` AS ${quoteSqlId(col.as)}`;
+        result += ` AS ${ quoteSqlId(col.as) }`;
       else if (col.func && !col.args) // e.g. CURRENT_TIMESTAMP
-        result += ` AS ${quoteSqlId(col.func)}`;
+        result += ` AS ${ quoteSqlId(col.func) }`;
     }
     return result;
   }
@@ -1216,15 +1219,15 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderView( artifactName, art, env ) {
     const viewName = renderArtifactName(artifactName);
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art?.$location, artifactName);
-    let result = `VIEW ${viewName}`;
+    let result = `VIEW ${ viewName }`;
 
     if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
-      result += ` COMMENT ${renderStringForSql(getHanaComment(art), options.sqlDialect)}`;
+      result += ` COMMENT ${ renderStringForSql(getHanaComment(art), options.sqlDialect) }`;
 
     result += renderParameterDefinitions(art.params, env);
-    result += ` AS ${renderQuery(getNormalizedQuery(art).query,
-                                 env.withSubPath([ art.projection ? 'projection' : 'query' ]),
-                                 art.elements, !!art.projection)}`;
+    result += ` AS ${ renderQuery(getNormalizedQuery(art).query,
+                                  env.withSubPath([ art.projection ? 'projection' : 'query' ]),
+                                  art.elements, !!art.projection) }`;
 
     const childEnv = env.withIncreasedIndent();
     const associations = Object.keys(art.elements)
@@ -1233,8 +1236,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
       .filter(s => s !== '')
       .join(',\n');
     if (associations !== '' && withHanaAssociations) {
-      result += `${env.indent}\nWITH ASSOCIATIONS (\n${associations}\n`;
-      result += `${env.indent})`;
+      result += `${ env.indent }\nWITH ASSOCIATIONS (\n${ associations }\n`;
+      result += `${ env.indent })`;
     }
 
     // views can only have a @sql.append
@@ -1269,13 +1272,13 @@ function toSqlDdl( csn, options, messageFunctions ) {
           pIdentifier = prepareIdentifier(pn);
         else
           pIdentifier = quoteSqlId(pn);
-        let pstr = `IN ${pIdentifier} ${renderTypeReference(p, paramEnv)}`;
+        let pstr = `IN ${ pIdentifier } ${ renderTypeReference(p, paramEnv) }`;
         if (p.default)
-          pstr += ` DEFAULT ${renderExpr(p.default, new SqlRenderEnvironment({ ...env, indent: '' }))}`;
+          pstr += ` DEFAULT ${ renderExpr(p.default, new SqlRenderEnvironment({ ...env, indent: '', isInDefault: true })) }`;
 
         parray.push(pstr);
       }
-      result = `(${parray.join(', ')})`;
+      result = `(${ parray.join(', ') })`;
     }
     return result;
   }
@@ -1301,9 +1304,9 @@ function toSqlDdl( csn, options, messageFunctions ) {
           // - has an ORDER BY/LIMIT (because UNION etc. can't stand directly behind an ORDER BY)
           const argEnv = env.withSubPath([ 'args', index ]);
           const queryString = renderQuery( arg, argEnv, elements || query.SET.elements, false);
-          return (arg.SET || arg.SELECT?.orderBy || arg.SELECT?.limit) ? `(${queryString})` : queryString;
+          return (arg.SET || arg.SELECT?.orderBy || arg.SELECT?.limit) ? `(${ queryString })` : queryString;
         })
-        .join(`\n${env.indent}${query.SET.op?.toUpperCase()}${query.SET.all ? ' ALL ' : ' '}`);
+        .join(`\n${ env.indent }${ query.SET.op?.toUpperCase() }${ query.SET.all ? ' ALL ' : ' ' }`);
 
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
@@ -1311,14 +1314,14 @@ function toSqlDdl( csn, options, messageFunctions ) {
       // (otherwise some SQL implementations (e.g. sqlite) would interpret the ORDER BY/LIMIT as belonging
       // to the last SET argument, not to the whole SET)
       if (query.SET.orderBy || query.SET.limit) {
-        result = `(${result})`;
+        result = `(${ result })`;
         if (query.SET.orderBy) {
           const orderBy = query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ');
-          result += `\n${env.indent}ORDER BY ${orderBy}`;
+          result += `\n${ env.indent }ORDER BY ${ orderBy }`;
         }
         if (query.SET.limit) {
           const limit = renderLimit(query.SET.limit, env.withSubPath([ 'limit' ]));
-          result += `\n${env.indent}${limit}`;
+          result += `\n${ env.indent }${ limit }`;
         }
       }
 
@@ -1326,15 +1329,15 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${ JSON.stringify(query) }`);
     }
     if (!isProjection)
       env = env.withSubPath([ 'SELECT' ]);
     const select = query.SELECT;
     const childEnv = env.withIncreasedIndent();
-    result += `SELECT${select.distinct ? ' DISTINCT' : ''}`;
+    result += `SELECT${ select.distinct ? ' DISTINCT' : '' }`;
     // FIXME: We probably also need to consider `excluding` here ?
-    result += `\n${(select.columns || [ '*' ])
+    result += `\n${ (select.columns || [ '*' ])
       .map((col, index) => {
         if (!select.mixin?.[firstPathStepId(col.ref)]) {
           const colEnv = select.columns ? childEnv.withSubPath([ 'columns', index ]) : childEnv;
@@ -1343,22 +1346,22 @@ function toSqlDdl( csn, options, messageFunctions ) {
         return ''; // No mixin columns
       })
       .filter(s => s !== '')
-      .join(',\n')}\n`;
-    result += `${env.indent}FROM ${renderQuerySource( select.from, env.withSubPath([ 'from' ]))}`;
+      .join(',\n') }\n`;
+    result += `${ env.indent }FROM ${ renderQuerySource( select.from, env.withSubPath([ 'from' ])) }`;
     if (select.where)
-      result += `\n${env.indent}WHERE ${renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
+      result += `\n${ env.indent }WHERE ${ renderExpr(select.where, env.withSubPath([ 'where' ])) }`;
 
     if (select.groupBy)
-      result += `\n${env.indent}GROUP BY ${select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
+      result += `\n${ env.indent }GROUP BY ${ select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ') }`;
 
     if (select.having)
-      result += `\n${env.indent}HAVING ${renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
+      result += `\n${ env.indent }HAVING ${ renderExpr(select.having, env.withSubPath([ 'having' ])) }`;
 
     if (select.orderBy)
-      result += `\n${env.indent}ORDER BY ${select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
+      result += `\n${ env.indent }ORDER BY ${ select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ') }`;
 
     if (select.limit)
-      result += `\n${env.indent}${renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
+      result += `\n${ env.indent }${ renderLimit(select.limit, env.withSubPath([ 'limit' ])) }`;
 
     return result;
   }
@@ -1383,11 +1386,11 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderLimit( limit, env ) {
     let result = '';
     if (limit.rows !== undefined)
-      result += `LIMIT ${renderExpr(limit.rows, env.withSubPath([ 'rows' ]))}`;
+      result += `LIMIT ${ renderExpr(limit.rows, env.withSubPath([ 'rows' ])) }`;
 
     if (limit.offset !== undefined) {
-      const indent = result !== '' ? `\n${env.indent}` : '';
-      result += `${indent}OFFSET ${renderExpr(limit.offset, env.withSubPath([ 'offset' ]))}`;
+      const indent = result !== '' ? `\n${ env.indent }` : '';
+      result += `${ indent }OFFSET ${ renderExpr(limit.offset, env.withSubPath([ 'offset' ])) }`;
     }
 
     return result;
@@ -1404,10 +1407,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderOrderByEntry( entry, env ) {
     let result = renderExpr(entry, env);
     if (entry.sort)
-      result += ` ${entry.sort.toUpperCase()}`;
+      result += ` ${ entry.sort.toUpperCase() }`;
 
     if (entry.nulls)
-      result += ` NULLS ${entry.nulls.toUpperCase()}`;
+      result += ` NULLS ${ entry.nulls.toUpperCase() }`;
 
     return result;
   }
@@ -1425,12 +1428,12 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (!elm.type && !elm.value) {
       // Anonymous structured type: Not supported with SQL, but doesn't happen anyway after flattening.
       if (options.testMode)
-        throw new ModelError(`to.sql(): Missing type of: ${JSON.stringify(env.path)}`);
+        throw new ModelError(`to.sql(): Missing type of: ${ JSON.stringify(env.path) }`);
       return result;
     }
     else if (elm.target) {
       if (options.testMode)
-        throw new ModelError(`to.sql(): Unexpected association in: ${JSON.stringify(env.path)}`);
+        throw new ModelError(`to.sql(): Unexpected association in: ${ JSON.stringify(env.path) }`);
       return result;
     }
 
@@ -1442,7 +1445,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
         result += renderTypeParameters(elm);
       }
       else {
-        throw new ModelError(`Unexpected non-primitive type of: ${JSON.stringify(env.path)}`);
+        throw new ModelError(`Unexpected non-primitive type of: ${ JSON.stringify(env.path) }`);
       }
     }
 
@@ -1452,7 +1455,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       // The SQL standard 2016 describes the syntax in section 11.3 - 11.4
       // of the SQL Foundation spec (for 2003 in 5WD-02-Foundation-2003-09.pdf). Summarized:
       //   <generation clause> ::= GENERATED ALWAYS AS '(' <value expression> ')'
-      result += ` GENERATED ALWAYS AS (${renderExpr(elm.value, env.withSubPath([ 'value' ]))})`;
+      result += ` GENERATED ALWAYS AS (${ renderExpr(elm.value, env.withSubPath([ 'value' ])) })`;
       // However, it appears many databases require a trailing "STORED".
       if (options.sqlDialect === 'sqlite' || options.sqlDialect === 'postgres')
         result += ' STORED';
@@ -1471,7 +1474,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const types = cdsToSqlTypes[options.sqlDialect];
     const result = types?.[typeName] || cdsToSqlTypes.standard[typeName];
     if (!result && options.testMode)
-      throw new CompilerAssertion(`Expected to find a type mapping for ${typeName}`);
+      throw new CompilerAssertion(`Expected to find a type mapping for ${ typeName }`);
     return result || 'CHAR';
   }
 
@@ -1521,7 +1524,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       else
         params.push(elm.srid);
     }
-    return params.length === 0 ? '' : `(${params.join(', ')})`;
+    return params.length === 0 ? '' : `(${ params.join(', ') })`;
   }
 
   function renderExpressionLiteral( x ) {
@@ -1534,16 +1537,16 @@ function toSqlDdl( csn, options, messageFunctions ) {
         return String(x.val).toUpperCase();
       case 'x':
         // x'f000'
-        return `${x.literal}'${x.val}'`;
+        return `${ x.literal }'${ x.val }'`;
       case 'date':
       case 'time':
       case 'timestamp':
         if (options.sqlDialect === 'sqlite') {
           // simple string literal '2017-11-02'
-          return `'${x.val}'`;
+          return `'${ x.val }'`;
         }
         // date'2017-11-02'
-        return `${x.literal}'${x.val}'`;
+        return `${ x.literal }'${ x.val }'`;
 
       case 'string':
         // 'foo', with proper escaping
@@ -1554,7 +1557,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
       // otherwise fall through to
       default:
-        throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+        throw new ModelError(`Unknown literal or type: ${ JSON.stringify(x) }`);
     }
   }
 
@@ -1575,7 +1578,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return renderStringForSql(magicReplacement, options.sqlDialect);
 
     const name = pathName(ref);
-    const result = variableForDialect(options, name);
+    const result = variableForDialect(options, name, env.isInDefault ? 'default' : null);
     if (result)
       return result;
 
@@ -1608,10 +1611,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
     //        assume that it was not if the path has length 2
     if (firstPathStepId(x.ref) === '$parameters' && x.ref.length === 2) {
       // Parameters must be uppercased and unquoted in SQL
-      return `:${x.ref[1].toUpperCase()}`;
+      return `:${ x.ref[1].toUpperCase() }`;
     }
     if (x.param)
-      return `:${x.ref[0].toUpperCase()}`;
+      return `:${ x.ref[0].toUpperCase() }`;
 
     return x.ref.map((step, i) => renderPathStep(step, i, env.withSubPath([ 'ref', i ])))
       .filter(s => s !== '')
@@ -1621,7 +1624,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderTypeRef( x, env ) {
     const prefix = x.param ? ':' : '';
     const ref = x.ref.map((step, index) => renderPathStep(step, index, env.withSubPath([ 'ref', index ]))).join('.');
-    return `${prefix}${ref}`;
+    return `${ prefix }${ ref }`;
   }
 
   /**
@@ -1645,33 +1648,33 @@ function toSqlDdl( csn, options, messageFunctions ) {
     else if (typeof s === 'object') {
       // Sanity check
       if (!s.func && !s.id)
-        throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
+        throw new ModelError(`Unknown path step object: ${ JSON.stringify(s) }`);
 
       // Not really a path step but an object-like function call
       if (s.func)
-        return `${s.func}(${renderArgs(s, '=>', env, null)})`;
+        return `${ s.func }(${ renderArgs(s, '=>', env, null) })`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${quoteSqlId(s.id)}`;
+      let result = `${ quoteSqlId(s.id) }`;
       if (s.args) {
         // View parameters
-        result += `(${renderArgs(s, '=>', env, null)})`;
+        result += `(${ renderArgs(s, '=>', env, null) })`;
       }
       if (s.where) {
         // Filter, possibly with cardinality
         // FIXME: Does SQL understand filter cardinalities?
-        const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
-        result += `[${cardinality}${renderExpr(s.where, env.withSubPath([ 'where' ]))}]`;
+        const cardinality = s.cardinality ? (`${ s.cardinality.max }: `) : '';
+        result += `[${ cardinality }${ renderExpr(s.where, env.withSubPath([ 'where' ])) }]`;
       }
       return result;
     }
 
-    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+    throw new ModelError(`Unknown path step: ${ JSON.stringify(s) }`);
   }
 
 
   function renderWindowFunction( funcName, node, fctEnv ) {
-    let r = `${funcName}(${renderArgs(node, '=>', fctEnv, null)}) `;
+    let r = `${ funcName }(${ renderArgs(node, '=>', fctEnv, null) }) `;
     r += renderExpr(node.xpr, fctEnv.withSubPath([ 'xpr' ])); // xpr[0] is 'over'
     return r;
   }
@@ -1742,7 +1745,7 @@ function renderStringForSql( str, sqlDialect ) {
     // - <https://www.postgresql.org/docs/9.1/functions-string.html>
     str = str.replace(/'/g, '\'\'');
   }
-  return `'${str}'`;
+  return `'${ str }'`;
 }
 
 module.exports = {