@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/optionProcessor.js

@@ -19,10 +19,7 @@ optionProcessor
   .option('    --color <mode>', ['auto', 'always', 'never'])
   .option('-o, --out <dir>')
   .option('    --cds-home <dir>')
-  .option('    --lint-mode')
   .option('    --fuzzy-csn-error')
-  .option('    --trace-parser')
-  .option('    --trace-parser-amb')
   .option('    --trace-fs')
   .option('    --error <id-list>')
   .option('    --warn <id-list>')
@@ -35,7 +32,6 @@ optionProcessor
   .option('    --beta <list>')
   .option('    --deprecated <list>')
   .option('    --direct-backend')
-  .option('    --parse-only')
   .option('    --fallback-parser <type>', ['cdl', 'csn', 'csn!'])
   .option('    --test-mode')
   .option('    --test-sort-csn')
@@ -78,7 +74,6 @@ optionProcessor
                               never:
    -o, --out <dir>          Place generated files in directory <dir>, default is "-" for <stdout>
        --cds-home <dir>     When set, modules starting with '@sap/cds/' are searched in <dir>
-       --lint-mode          Generate nothing, just produce messages if any (for use by editors)
        --fuzzy-csn-error    Report free-style CSN properties as errors
        --                   Indicate the end of options (helpful if source names start with "-")
 
@@ -87,8 +82,6 @@ optionProcessor
        --default-string-length <length> Default 'length' for 'cds.String'
 
   Diagnostic options
-       --trace-parser       Trace parser
-       --trace-parser-amb   Trace parser ambiguities
        --trace-fs           Trace file system access caused by "using from"
 
   Severity options
@@ -109,10 +102,12 @@ optionProcessor
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
                               ignoreAssocPublishingInUnion
+                              odataOpenType
+                              optionalActionFunctionParameters
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
+                              autoCorrectOrderBySourceRefs
                               eagerPersistenceForGeneratedEntities
-       --parse-only         Stop compilation after parsing and write result to <stdout>
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this
                                  parser as a fallback. Valid values are:
                                    cdl  : Use CDL parser
@@ -141,15 +136,18 @@ optionProcessor
        toCsn [options] <files...>               (default) Generate original model as CSN
        parseCdl [options] <file>                Generate a CSN that is close to the CDL source.
        explain <message-id>                     Explain a compiler message.
+       parseOnly [options] <files...>           (internal)  Stop compilation after parsing, write messages to <stderr>,
+                                                per default no output.
        toRename [options] <files...>            (internal) Generate SQL DDL rename statements
        manageConstraints [options] <files...>   (internal) Generate ALTER TABLE statements to
                                                            add / modify referential constraints.
+       inspect [options] <files...>             (internal) Inspect the given CDS files.
 `);
 
 // ----------- toHana -----------
 optionProcessor.command('H, toHana')
   .option('-h, --help')
-  .option('-n, --names <style>', ['plain', 'quoted', 'hdbcds'])
+  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: ['--names'] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
@@ -159,6 +157,7 @@ optionProcessor.command('H, toHana')
   .option('    --integrity-not-enforced')
   .option('    --assert-integrity <mode>', ['true', 'false', 'individual'])
   .option('    --assert-integrity-type <type>', ['RT', 'DB'], { ignoreCase: true })
+  .option('    --disable-hana-comments')
   .help(`
   Usage: cdsc toHana [options] <files...>
 
@@ -166,7 +165,7 @@ optionProcessor.command('H, toHana')
 
   Options
    -h, --help                 Show this help text
-   -n, --names <style>        Naming style for generated entity and element names:
+   -n, --sql-mapping <style>  Naming style for generated entity and element names:
                                 plain  : (default) Produce HANA entity and element names in
                                          uppercase and flattened with underscores. Do not generate
                                          structured types.
@@ -193,11 +192,12 @@ optionProcessor.command('H, toHana')
                                            RT : (default) No database constraint for an association
                                                if not explicitly demanded via annotation
                                            DB : Create database constraints for associations
+   --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
 `);
 
 optionProcessor.command('O, toOdata')
   .option('-h, --help')
-  .option('-v, --odata-version <version>', ['v2', 'v4', 'v4x'])
+  .option('-v, --odata-version <version>', ['v2', 'v4', 'v4x'], { aliases: ['--version'] })
   .option('-x, --xml')
   .option('-j, --json')
   .option('    --odata-containment')
@@ -207,7 +207,7 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-v2-partial-constr')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', ['flat', 'structured'])
-  .option('-n, --names <style>', ['plain', 'quoted', 'hdbcds'])
+  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
   .option('-s, --service-names <list>')
   .help(`
   Usage: cdsc toOdata [options] <files...>
@@ -232,13 +232,13 @@ optionProcessor.command('O, toOdata')
        --odata-foreign-keys        Render foreign keys in structured format (V4 only)
        --odata-v2-partial-constr   Render referential constraints also for partial principal key tuple
                                    (Not spec compliant and V2 only)
-   -n, --names <style>      Annotate artifacts and elements with "@cds.persistence.name", which is
-                            the corresponding database name (see "--names" for "toHana or "toSql")
-                              plain   : (default) Names in uppercase and flattened with underscores
-                              quoted  : Names in original case as in CDL. Entity names with dots,
-                                        but element names flattened with underscores
-                              hdbcds  : Names as HANA CDS would generate them from the same CDS
-                                        source (like "quoted", but using element names with dots)
+   -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
+                             the corresponding database name (see "--sql-mapping" for "toHana or "toSql")
+                               plain   : (default) Names in uppercase and flattened with underscores
+                               quoted  : Names in original case as in CDL. Entity names with dots,
+                                         but element names flattened with underscores
+                               hdbcds  : Names as HANA CDS would generate them from the same CDS
+                                         source (like "quoted", but using element names with dots)
     -s, --service-names <list>    List of comma-separated service names to be rendered
                                   (default) empty, all services are rendered
 `);
@@ -256,10 +256,10 @@ optionProcessor.command('C, toCdl')
 
 optionProcessor.command('Q, toSql')
   .option('-h, --help')
-  .option('-n, --names <style>', ['plain', 'quoted', 'hdbcds'])
+  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
+  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres'], { aliases: [ '--dialect' ] })
   .option('    --render-virtual')
   .option('    --joinfk')
-  .option('-d, --dialect <dialect>', ['hana', 'sqlite', 'plain', 'postgres'])
   .option('-u, --user <user>')
   .option('-l, --locale <locale>')
   .option('-s, --src <style>', ['sql', 'hdi'])
@@ -269,6 +269,7 @@ optionProcessor.command('Q, toSql')
   .option('    --assert-integrity <mode>', ['true', 'false', 'individual'])
   .option('    --assert-integrity-type <type>', ['RT', 'DB'], { ignoreCase: true })
   .option('    --constraints-in-create-table')
+  .option('    --disable-hana-comments')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -276,7 +277,7 @@ optionProcessor.command('Q, toSql')
 
   Options
    -h, --help                 Show this help text
-   -n, --names <style>        Naming style for generated entity and element names:
+   -n, --sql-mapping <style>  Naming style for generated entity and element names:
                                 plain  : (default) Produce SQL table and view names in
                                          flattened with underscores format (no quotes required)
                                 quoted : Produce SQL table and view names in original case as in
@@ -289,7 +290,7 @@ optionProcessor.command('Q, toSql')
                                          combination with "hana" dialect.
        --render-virtual       Render virtual elements in views and draft tables
        --joinfk               Create JOINs for foreign key accesses
-   -d, --dialect <dialect>    SQL dialect to be generated:
+   -d, --sql-dialect <dialect>  SQL dialect to be generated:
                                 plain    : (default) Common SQL - no assumptions about DB restrictions
                                 hana     : SQL with HANA specific language features
                                 sqlite   : Common SQL for sqlite
@@ -316,32 +317,34 @@ optionProcessor.command('Q, toSql')
    --constraints-in-create-table    If set, the foreign key constraints will be rendered as
                                     part of the "CREATE TABLE" statements rather than as separate
                                     "ALTER TABLE ADD CONSTRAINT" statements
+   --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
 `);
 
 optionProcessor.command('toRename')
   .option('-h, --help')
-  .option('-n, --names <style>', ['quoted', 'hdbcds'])
+  .option('-n, --sql-mapping <style>', ['quoted', 'hdbcds'], { aliases: ['--names'] })
   .help(`
   Usage: cdsc toRename [options] <files...>
 
   (internal, subject to change): Generate SQL stored procedure containing DDL statements to
   "storedProcedure.sql" that allows to rename existing tables and their columns so that they
-  match the result of "toHana" or "toSql" with the "--names plain" option.
+  match the result of "toHana" or "toSql" with the "--sql-mapping plain" option.
 
   Options
    -h, --help           Display this help text
-   -n, --names <style>  Assume existing tables were generated with "--names <style>":
+   -n, --sql-mapping <style>
+                        Assume existing tables were generated with "--sql-mapping <style>":
                           quoted   : Assume existing SQL tables and views were named in original
                                      case as in CDL (with dots), but column names were flattened
-                                     with underscores (e.g. resulting from "toHana --names quoted")
+                                     with underscores (e.g. resulting from "toHana --sql-mapping quoted")
                           hdbcds   : (default) Assume existing SQL tables, views and columns were
                                      generated by HANA CDS from the same CDS source (or resulting
-                                     from "toHana --names hdbcds")
+                                     from "toHana --sql-mapping hdbcds")
 `);
 
 optionProcessor.command('manageConstraints')
   .option('-h, --help')
-  .option('-n, --names <style>', ['plain', 'quoted', 'hdbcds'])
+  .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: ['--names'] })
   .option('-s, --src <style>', ['sql', 'hdi'])
   .option('    --drop')
   .option('    --alter')
@@ -357,7 +360,8 @@ optionProcessor.command('manageConstraints')
 
   Options
    -h, --help             Display this help text
-   -n, --names <style>    Assume existing tables were generated with "--names <style>":
+   -n, --sql-mapping <style>
+                          Assume existing tables were generated with "--sql-mapping <style>":
                             plain    : (default) Assume SQL tables were flattened and dots were
                                         replaced by underscores
                             quoted   : Assume existing SQL tables and views were named in original
@@ -379,8 +383,9 @@ optionProcessor.command('manageConstraints')
 
 optionProcessor.command('toCsn')
   .option('-h, --help')
-  .option('-f, --flavor <flavor>', ['client', 'gensrc', 'universal'])
+  .option('-f, --csn-flavor <flavor>', ['client', 'gensrc', 'universal'], { aliases: ['--flavor'] })
   .option('    --with-localized')
+  .option('    --with-locations')
   .help(`
   Usage: cdsc toCsn [options] <files...>
 
@@ -388,13 +393,15 @@ optionProcessor.command('toCsn')
 
   Options
    -h, --help             Show this help text
-   -f, --flavor <flavor>  Generate CSN in one of two flavors:
-                            client  : (default) Standard CSN consumable by clients and backends
-                            gensrc  : CSN specifically for use as a source, e.g. for
-                                      combination with additional "extend" or "annotate"
-                                      statements, but not suitable for consumption by clients or
-                                      backends
-                            universal: in development (BETA)
+   -f, --csn-flavor <flavor>  Generate CSN in one of two flavors:
+                                client  : (default) Standard CSN consumable by clients and backends
+                                gensrc  : CSN specifically for use as a source, e.g. for
+                                          combination with additional "extend" or "annotate"
+                                          statements, but not suitable for consumption by clients or
+                                          backends
+                                universal: in development (BETA)
+       --with-locations   Add $location to CSN artifacts. In contrast to \`--enrich-csn\`,
+                          $location is an object with 'file', 'line' and 'col' properties.
 
   Internal options (for testing only, may be changed/removed at any time)
        --with-localized   Add localized convenience views to the CSN output.
@@ -413,6 +420,26 @@ optionProcessor.command('parseCdl')
    -h, --help             Show this help text
 `);
 
+optionProcessor.command('parseOnly')
+  .option('-h, --help')
+  .option('    --trace-parser')
+  .option('    --trace-parser-amb')
+  .positionalArgument('<file>')
+  .help(`
+  Usage: cdsc parseOnly [options] <files...>
+
+  (internal): Stop compilation after parsing and write messages to <stderr>.
+  Per default, nothing is printed.  With \`--raw-output +\`, XSN is printed
+  to <stdout>.
+
+  Options
+   -h, --help               Show this help text
+
+  Diagnostic options
+       --trace-parser       Trace parser
+       --trace-parser-amb   Trace parser ambiguities
+`);
+
 optionProcessor.command('explain')
   .option('-h, --help')
   .positionalArgument('<message-id>')
@@ -428,6 +455,22 @@ optionProcessor.command('explain')
    -h, --help        Show this help text
 `);
 
+optionProcessor.command('inspect')
+  .option('-h, --help')
+  .option('    --statistics')
+  .option('    --propagation <art>')
+  .positionalArgument('<files...>')
+  .help(`
+  Usage: cdsc inspect [options] <files...>
+
+  (internal): Inspect the CSN model compiled from the provided CDS files.
+
+  Options
+   -h, --help                Show this help text
+       --statistics          Print model statistics
+       --propagation <art>   Show propagation sources for <art>
+`);
+
 module.exports = {
   optionProcessor
 };

package/lib/render/toCdl.js

@@ -142,11 +142,10 @@ function csnToCdl(csn, options) {
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
 
     if (ext.includes && ext.includes.length > 0) {
-      // Includes can't be combined with anything in braces {}.  Multiple includes
-      // are possible through CSN, but in CDL, only one include at once is possible.
+      // Includes can't be combined with anything in braces {}.
       const affix = isElementExtend ? 'element ' : '';
-      for (const id of ext.includes)
-        result += `${env.indent}extend ${affix}${extName} with ${quotePathIfRequired(id)};\n`;
+      const includes = ext.includes.map(inc => quotePathIfRequired(inc)).join(', ');
+      result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
       return result;
     }
 
@@ -358,17 +357,21 @@ function csnToCdl(csn, options) {
       case 'context':
       case 'service':
         return renderContextOrService(artifactName, art, env);
+
       case 'type':
       case 'aspect':
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
         return renderTypeOrAnnotation(artifactName, art, env);
+
       case 'action':
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
+
       case 'event':
         return renderEvent(artifactName, art, env);
+
       default:
-        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`to.cdl: Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -426,14 +429,16 @@ function csnToCdl(csn, options) {
    */
   function renderEntity(artifactName, art, env) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    const childEnv = increaseIndent(env);
-    const normalizedArtifactName = renderArtifactName(artifactName);
-    result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
-    const parameters = Object.keys(art.params || []).map(name => renderParameter(name, art.params[name], childEnv)).join(',\n');
-    result += (parameters === '') ? '' : ` (\n${parameters}\n${env.indent})`;
+    result += env.indent + (art.abstract ? 'abstract ' : '');
+    result += `entity ${renderArtifactName(artifactName)}`;
+
+    if (art.params)
+      result += renderParameters(art, env);
+
     if (art.includes)
       result += renderIncludes(art.includes);
     result += ' {\n';
+    const childEnv = increaseIndent(env);
     for (const name in art.elements) {
       const element = art.elements[name];
       result += renderElement(name, element, childEnv);
@@ -664,8 +669,11 @@ function csnToCdl(csn, options) {
     if (path.ref[0].args)
       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)}]`;
+    if (path.ref[0].where) {
+      const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
+      const expr = renderExpr(path.ref[0].where, env, true, true);
+      result += `[${cardinality}${expr}]`;
+    }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
@@ -841,14 +849,9 @@ function csnToCdl(csn, options) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent}${art.abstract ? 'abstract ' : ''}${syntax === 'projection' ? 'entity' : syntax} ${renderArtifactName(artifactName)}`;
-    if (art.params) {
-      const childEnv = increaseIndent(env);
-      const parameters = Object.keys(art.params).map(name => renderParameter(name, art.params[name], childEnv)).join(',\n');
-      result += `(\n${parameters}\n${env.indent}) as `;
-    }
-    else {
-      result += ' as ';
-    }
+    if (art.params)
+      result += renderParameters(art, env);
+    result += ' as ';
     result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
     result += ';\n';
     result += renderQueryElementAnnotations(artifactName, art, env);
@@ -959,9 +962,10 @@ function csnToCdl(csn, options) {
       if (limit.rows !== undefined)
         limitStr += `limit ${renderExpr(limit.rows, limitEnv)}`;
 
-      if (limit.offset !== undefined)
-        limitStr += `${limitStr !== '' ? `\n${increaseIndent(limitEnv).indent}` : ''}offset ${renderExpr(limit.offset, limitEnv)}`;
-
+      if (limit.offset !== undefined) {
+        const offsetIndent = (limitStr === '') ? '' : `\n${increaseIndent(limitEnv).indent}`;
+        limitStr += `${offsetIndent}offset ${renderExpr(limit.offset, limitEnv)}`;
+      }
       return limitStr;
     }
 
@@ -1040,10 +1044,9 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderActionOrFunction(actionName, act, env) {
-    let result = `${renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind} ${renderArtifactName(actionName)}`;
-    const childEnv = increaseIndent(env);
-    const parameters = Object.keys(act.params || []).map(name => renderParameter(name, act.params[name], childEnv)).join(',\n');
-    result += (parameters === '') ? '()' : `(\n${parameters}\n${env.indent})`;
+    let result = renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
+    result += ` ${renderArtifactName(actionName)}`;
+    result += renderParameters(act, env);
     if (act.returns) {
       const actEnv = envAddPath(env, [ 'returns' ]);
       result += ` returns ${renderTypeReferenceAndProps(act.returns, actEnv)}`;
@@ -1053,6 +1056,23 @@ function csnToCdl(csn, options) {
     return result;
   }
 
+  /**
+   * Render art.params, i.e. list of parameter in parentheses.  If there is only one
+   * parameter, a single line is used, otherwise an indented list is used.
+   * If there are no params, an empty list `()` is returned.
+   *
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderParameters(art, env) {
+    const childEnv = increaseIndent(env);
+    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv));
+    if (parameters.length === 0)
+      return '()';
+    return `(\n${parameters.join(',\n')}\n${env.indent})`;
+  }
+
   /**
    * Render an action or function parameter 'par' with name 'parName'. Return the resulting source string (no trailing LF).
    *
@@ -1075,7 +1095,7 @@ function csnToCdl(csn, options) {
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
-   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind. Only in toCdl mode
+   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind.
    * @return {string}
    */
   function renderTypeOrAnnotation(artifactName, art, env, artType) {
@@ -1085,9 +1105,11 @@ function csnToCdl(csn, options) {
       result += renderIncludes(art.includes);
 
     if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
-      result += ` ${renderTypeReferenceAndProps(art, env)};\n`;
+      result += ` ${renderTypeReferenceAndProps(art, env)}`;
     else
-      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
+      result += ` : ${renderTypeReferenceAndProps(art, env)}`;
+    // for aspects, but since types don't have `actions` this does not hurt
+    result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
   }
 
@@ -1373,7 +1395,9 @@ function csnToCdl(csn, options) {
       }
       if (s.where) {
         // Filter, possibly with cardinality
-        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
+        const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+        const expr = renderExpr(s.where, env, inline, true);
+        result += `[${cardinality}${expr}]`;
       }
 
       return result;
@@ -1516,7 +1540,8 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderForeignKey(fKey, env) {
-    return `${renderExpr(fKey, env)}${fKey.as ? (` as ${fKey.as}`) : ''}`;
+    const alias = fKey.as ? (` as ${fKey.as}`) : '';
+    return renderExpr(fKey, env) + alias;
   }
 
   /**

package/lib/render/toHdbcds.js

@@ -839,7 +839,7 @@ function toHdbcdsSource(csn, options) {
    * @param {object} [elements] For leading query, the elements of the artifact
    * @returns {string} The rendered query
    */
-  function renderQuery(query, isLeadingQuery, env, path = [], elements) {
+  function renderQuery(query, isLeadingQuery, env, path = [], elements = null) {
     let result = '';
     env.skipKeys = !isLeadingQuery;
     // Set operator, like UNION, INTERSECT, ...

package/lib/render/toSql.js

@@ -117,14 +117,18 @@ function toSqlDdl(csn, options) {
      */
     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, env))
+          .map(([ name, elt ]) => renderElement(artifactName, name, elt, duplicateChecker, null, alterEnv))
           .filter(s => s !== '');
 
         if (elements.length)
@@ -138,10 +142,10 @@ function toSqlDdl(csn, options) {
       TODO duplicity check
      */
     addAssociations(artifactName, tableName, elementsObj, env) {
-      return Object.entries(elementsObj)
+      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});`);
+        .map(eltStr => `ALTER TABLE ${tableName} ADD ASSOCIATION (${eltStr});`) : [];
     },
     /*
       Render key addition as HANA SQL.
@@ -159,7 +163,7 @@ function toSqlDdl(csn, options) {
       Render association removals as HANA SQL.
      */
     dropAssociation(tableName, sqlId) {
-      return [ `ALTER TABLE ${tableName} DROP ASSOCIATION ${sqlId};` ];
+      return options.sqlDialect === 'hana' ? [ `ALTER TABLE ${tableName} DROP ASSOCIATION ${sqlId};` ] : [];
     },
     /*
       Render primary-key removals as HANA SQL.
@@ -200,7 +204,7 @@ function toSqlDdl(csn, options) {
       Render comment string.
      */
     comment(comment) {
-      return comment && renderStringForSql(comment, options.sqlDialect) || 'NULL';
+      return comment && renderStringForSql(getHanaComment({ doc: comment }), options.sqlDialect) || 'NULL';
     },
     /*
       Alter SQL snippet for entity.
@@ -434,7 +438,7 @@ function toSqlDdl(csn, options) {
     function getEltStr(defVariant, eltName) {
       return defVariant.target
         ? renderAssociationElement(eltName, defVariant, env)
-        : renderElement(artifactName, eltName, defVariant, null, null, env);
+        : renderElement(artifactName, eltName, defVariant, null, null, activateAlterMode(env));
     }
     function getEltStrNoProps(defVariant, eltName, ...props) {
       const defNoProps = Object.assign({}, defVariant);
@@ -461,7 +465,7 @@ function toSqlDdl(csn, options) {
     // Change entity properties
     if (migration.properties) {
       for (const [ prop, def ] of Object.entries(migration.properties)) {
-        if (prop === 'doc') {
+        if (prop === 'doc' && !options.disableHanaComments) { // def.new may be `null`
           const alterComment = render.alterEntityComment(tableName, def.new);
           addMigration(resultObj, artifactName, false, alterComment);
         }
@@ -527,7 +531,7 @@ function toSqlDdl(csn, options) {
           }
         }
 
-        if (def.old.doc !== def.new.doc) {
+        if (!options.disableHanaComments && def.old.doc !== def.new.doc) {
           const eltStrOldNoDoc = getEltStrNoProps(def.old, eltName, 'doc');
           const eltStrNewNoDoc = getEltStrNoProps(def.new, eltName, 'doc');
           if (eltStrOldNoDoc === eltStrNewNoDoc) { // only `doc` changed
@@ -753,7 +757,7 @@ function toSqlDdl(csn, options) {
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
     let result = `${env.indent + quotedElementName} ${renderTypeReference(artifactName, elementName, elm)
-    }${renderNullability(elm, true)}`;
+    }${renderNullability(elm, true, env.alterMode)}`;
     if (elm.default)
       result += ` DEFAULT ${renderExpr(elm.default, env)}`;
 
@@ -1395,9 +1399,15 @@ function toSqlDdl(csn, options) {
    *
    * @param {object} obj Object to render for
    * @param {boolean} treatKeyAsNotNull Whether to render KEY as not null
+   * @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) {
+  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';
+    }
+
+
     if (obj.notNull === undefined && !(obj.key && treatKeyAsNotNull)) {
       // Attribute not set at all
       return '';
@@ -1492,6 +1502,7 @@ function toSqlDdl(csn, options) {
       }
       else if (x.ref[0] === '$now') { // TODO: Can there be cases where $now is followed by something?
         switch (options.sqlDialect) {
+          case 'plain':
           case 'sqlite':
           case 'hana':
             return 'CURRENT_TIMESTAMP';
@@ -1531,7 +1542,7 @@ function toSqlDdl(csn, options) {
           return 'SESSION_CONTEXT(\'LOCALE\')';
         return '\'en\''; // default language
       }
-      // Basically: Second path step was invalid, do nothing - should not happen, see 'unknownMagic.js'
+      // Basically: Second path step was invalid, do nothing - should not happen.
       return null;
     }
     /**
@@ -1654,6 +1665,15 @@ function toSqlDdl(csn, options) {
   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
+   * @returns {object} Render environment with alterMode
+   */
+  function activateAlterMode(env) {
+    return Object.assign({ alterMode: true }, env);
+  }
 }
 
 /**

package/lib/render/utils/common.js

@@ -286,8 +286,8 @@ const cdsToSqlTypes = {
     'cds.LargeString': 'text',
     'cds.hana.CLOB': 'text',
     'cds.LargeBinary': 'bytea',
-    'cds.Binary': 'VARCHAR',
-    'cds.hana.BINARY': 'VARCHAR',
+    'cds.Binary': 'bytea',
+    'cds.hana.BINARY': 'bytea',
     'cds.Double': 'double precision',
     'cds.hana.TINYINT': 'INTEGER',
   },
@@ -358,11 +358,10 @@ function hasHanaComment(obj, options) {
  * Return the comment of the given artifact or element.
  * Uses the first block (everything up to the first empty line (double \n)).
  * Remove leading/trailing whitespace.
- * Does not escape any characters.
+ * Does not escape any characters, use e.g. `getEscapedHanaComment()` for HDBCDS.
  *
  * @param {CSN.Artifact|CSN.Element} obj
  * @returns {string}
- * @todo Warning/info to user?
  */
 function getHanaComment(obj) {
   return obj.doc.split('\n\n')[0].trim();