@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/modelCompare/compare.js

@@ -8,6 +8,8 @@ const {
   isPersistedAsView
 } = require('../model/csnUtils');
 const { isBetaEnabled } = require('../base/model');
+const { forEachKey } = require('../utils/objectUtils');
+
 // used to mark a view as changed so we know to drop-create it
 const isChanged = Symbol('Marks a view as changed');
 
@@ -25,19 +27,18 @@ function compareModels(beforeModel, afterModel, options) {
   if(!(options && options.testMode)) // no $version with testMode
     validateCsnVersions(beforeModel, afterModel, options);
 
-  const deletedEntities = Object.create(null);
-  const elementAdditions = [];
-  const migrations = []; // element changes/removals or changes of entity properties
+  const returnObj = Object.create(null);
+  returnObj.definitions = afterModel.definitions;
+  returnObj.deletions = Object.create(null);
+  returnObj.extensions = [];
+  returnObj.migrations = []; // element changes/removals or changes of entity properties
+  returnObj.unchangedConstraints = new Set();
 
   // There is currently no use in knowing the added entities only. If this changes, hand in `addedEntities` to `getArtifactComparator` below.
-  forEachDefinition(afterModel, getArtifactComparator(beforeModel, options, null, null, elementAdditions, migrations));
-  forEachDefinition(beforeModel, getArtifactComparator(afterModel, options, null, deletedEntities, null, null));
+  forEachDefinition(afterModel, getExtensionAndMigrations(beforeModel, options, returnObj));
+  forEachDefinition(beforeModel, getDeletions(afterModel, options, returnObj));
+
 
-  const returnObj = Object.create(null);
-  returnObj.definitions = afterModel.definitions;
-  returnObj.deletions = deletedEntities;
-  returnObj.extensions = elementAdditions;
-  returnObj.migrations = migrations;
   return returnObj;
 }
 
@@ -65,13 +66,21 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
 }
 
-function getArtifactComparator(otherModel, options, addedEntities, deletedEntities, elementAdditions, migrations) {
+/**
+ * Calculate extensions, migrations and unchangedConstraints
+ * 
+ * @param {CSN.Model} beforeModel 
+ * @param {CSN.Options} options 
+ * @param {object} returnObj 
+ * @returns {function}
+ */
+function getExtensionAndMigrations(beforeModel, options, { extensions, migrations, unchangedConstraints }) {
   return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
       forEachMember(artifact, getElementComparator(otherArtifact, elements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(elements).length > 0) {
-        elementAdditions.push(addedElements(name, elements));
+        extensions.push(addedElements(name, elements));
       }
     }
     function changePropsOrRemoveOrChangeElements() {
@@ -92,6 +101,54 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
           changedProperties[prop.name] = changedElement(artifact[prop.name], otherArtifact[prop.name] || null);
         }
       });
+
+      const removedConstraints = {};
+
+      // HDI (src === 'hdi) does handle table constraints via separate files and therefore no delta handling needed
+      if(options.src === 'sql' && (artifact.$tableConstraints  || otherArtifact.$tableConstraints)) {
+        const current = artifact.$tableConstraints || {};
+        const old = otherArtifact.$tableConstraints || {};
+        let changes = false;
+        const constraintTypes = ['unique', 'referential'];
+        constraintTypes.forEach(constraintType => {
+          // We only render/handle referential constraints for specific cases
+          if(hasReferentialConstraints(options) || constraintType !== 'referential')
+            if(current[constraintType] || old[constraintType]) {
+              removedConstraints[constraintType] = Object.create(null);
+
+              const cnew = current[constraintType] || Object.create(null);
+              const cold = old[constraintType] || Object.create(null);
+              forEachKey(cnew, (constraintName) => {
+                if(cold[constraintName]) {
+                  // constraint changed - add it to "removedConstraints" to drop-create it.
+                  // Quick-and-dirty compare with JSON.stringify - false-positive will just be a drop-create
+                  if(JSON.stringify(cold[constraintName]) !== JSON.stringify(cnew[constraintName])) {
+                    changes = true;
+                    removedConstraints[constraintType][constraintName] = cold[constraintName];
+                    if(options.constraintsInCreateTable || constraintType !== 'referential') // schedule an "ADD"
+                      extensions.push(addedConstraint(name, cnew[constraintName], constraintName,  constraintType));
+                  } else {
+                    unchangedConstraints.add(constraintName);
+                  }
+                } else if(options.constraintsInCreateTable || constraintType !== 'referential'){
+                  // Sometimes referential constraints are anyway added via ALTER - no need to add them as explicit extensions then
+                  extensions.push(addedConstraint(name, cnew[constraintName], constraintName,  constraintType));
+                }
+              });
+
+              forEachKey(cold, (constraintName) => {
+                if(!cnew[constraintName]) {
+                  changes = true;
+                  removedConstraints[constraintType][constraintName] = cold[constraintName];
+                }
+              })
+            }
+        });
+
+        if(changes)
+          migration.removeConstraints = removedConstraints;
+      }
+
       if (Object.keys(changedProperties).length > 0) {
         migration.properties = changedProperties;
       }
@@ -106,27 +163,15 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
         migration.change = changedElements;
       }
 
-      if (migration.properties || migration.remove || migration.change) {
+      if (migration.properties || migration.remove || migration.change || migration.removeConstraints) {
         migrations.push(migration);
       }
     }
 
-    const otherArtifact = otherModel.definitions[name];
+    const otherArtifact = beforeModel.definitions[name];
     const isPersisted = isPersistedAsTable(artifact);
     const isPersistedOther = otherArtifact && isPersistedAsTable(otherArtifact);
 
-    if (deletedEntities) {
-      // Looking for deleted entities only.
-      // Arguments are interchanged in this case: `artifact` from beforeModel and `otherArtifact` from afterModel.
-      if (isPersisted && !isPersistedOther) {
-        deletedEntities[name] = artifact;
-      // eslint-disable-next-line sonarjs/no-duplicated-branches
-      } else if(isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
-        deletedEntities[name] = artifact;
-      }
-      return;
-    }
-
     // to make it easier to know which views to drop-create
     if(isPersistedAsView(artifact) && isPersistedAsView(otherArtifact)) {
       // TODO: Check only on artifact.query/projection BUT: Need to manually check for sql-snippets then!
@@ -136,37 +181,52 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
     // Looking for added entities and added/deleted/changed elements.
     // Parameters: `artifact` from afterModel and `otherArtifact` from beforeModel.
 
-    if (!isPersisted) {
-      // Artifact not persisted in afterModel.
+    if (!isPersisted) // Artifact not persisted in afterModel.
       return;
-    }
 
     if (!isPersistedOther) {
-      if (addedEntities) {
-        addedEntities[name] = artifact;
-      }
+      extensions[name] = artifact;
       return;
     }
 
     // Artifact changed?
 
-    if (elementAdditions) {
-      addElements();
-    }
-    if (migrations) {
-      changePropsOrRemoveOrChangeElements();
+    addElements();
+    changePropsOrRemoveOrChangeElements();
+  };
+}
+/**
+ * Calculate all deleted entities.
+ * 
+ * @param {CSN.Model} afterModel 
+ * @param {CSN.Options} options 
+ * @param {object} returnObj 
+ * @returns {function}
+ */
+function getDeletions(afterModel, options, { deletions }) {
+  return function compareArtifacts(artifact, name) {
+    const otherArtifact = afterModel.definitions[name];
+    const isPersisted = isPersistedAsTable(artifact);
+    const isPersistedOther = otherArtifact && isPersistedAsTable(otherArtifact);
+
+    // Looking for deleted entities only.
+    if (isPersisted && !isPersistedOther) {
+      deletions[name] = artifact;
+      // eslint-disable-next-line sonarjs/no-duplicated-branches
+    } else if (isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
+      deletions[name] = artifact;
     }
   };
 }
 
 function getElementComparator(otherArtifact, addedElementsDict = null, changedElementsDict = null) {
   return function compareElements(element, name) {
-    if (element._ignore) {
+    if (element.$ignore) {
       return;
     }
 
     const otherElement = otherArtifact.elements[name];
-    if (otherElement && !otherElement._ignore) {
+    if (otherElement && !otherElement.$ignore) {
       // Element type changed?
       if (!changedElementsDict) {
         return;
@@ -189,7 +249,42 @@ function getElementComparator(otherArtifact, addedElementsDict = null, changedEl
 }
 
 function relevantTypeChange(type, otherType) {
-  return otherType !== type && ![type, otherType].every(t => ['cds.Association', 'cds.Composition'].includes(t));
+  return otherType !== type && !isSuperflousHanaTypeChange(otherType, type) && ![type, otherType].every(t => ['cds.Association', 'cds.Composition'].includes(t));
+}
+
+const superflousTypeChanges = {
+  // turn it into a real dict
+  __proto__: null,
+  // We used to put these types into the CSN, although they are just internal
+  // so we need to be robust against them now.
+  'cds.UTCDateTime': 'cds.DateTime',
+  'cds.UTCTimestamp': 'cds.Timestamp',
+  'cds.LocalDate': 'cds.Date',
+  'cds.LocalTime': 'cds.Time' ,
+};
+
+/**
+ * We removed some old SAP HANA types from the CSN and we now need to not
+ * detect them as changes.
+ *
+ * @param {string} before Type before
+ * @param {string} after Type after
+ * @returns {boolean}
+ */
+function isSuperflousHanaTypeChange( before, after ) {
+  return superflousTypeChanges[before] ? superflousTypeChanges[before] === after : false;
+}
+
+/**
+ * If the element has one of the superflous types, do the change so we don't accidentally
+ * pass such an old type into the SQL renderer.
+ * @param {CSN.Element} element 
+ * @returns {CSN.Element}
+ */
+function remapType( element ) {
+  if(element?.type && superflousTypeChanges[element.type])
+    element.type = superflousTypeChanges[element.type];
+  return element;
 }
 
 /**
@@ -239,13 +334,26 @@ function addedElements(entity, elements) {
   };
 }
 
+function addedConstraint(entity, constraint, constraintName, constraintType) {
+  return {
+    extend: entity,
+    constraint,
+    constraintName,
+    constraintType,
+  }
+}
+
 function changedElement(element, otherElement) {
   return {
-    old: otherElement,
+    old: remapType(otherElement),
     new: element
   };
 }
 
+function hasReferentialConstraints(options) {
+  return options.src === 'sql' && (options.sqlDialect === 'postgres' || options.sqlDialect === 'hana' || options.sqlDialect === 'sqlite')
+}
+
 module.exports = {
   compareModels,
   deepEqual,

package/lib/modelCompare/utils/filter.js

@@ -13,20 +13,31 @@ function isKey( element ) {
 module.exports = {
   sqlite: getFilterObject(
     'sqlite',
-    function forEachExtension(extend, name, element, error) {
-      if (isKey(element)) { // Key must not be extended
-        error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite' }, 'Added element $(ID) is a primary key change and will not work with dialect $(NAME)');
+    function forEachExtension(extend, name, elementOrConstraint, { error, warning }) {
+      if (isKey(elementOrConstraint)) { // Key must not be extended
+        error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite', '#': 'std' } );
+        return false;
       }
+      else if (elementOrConstraint.parentTable) { // constraints have a .parentTable
+        warning('def-unsupported-constraint-add', [ 'definitions', elementOrConstraint.parentTable, 'elements', elementOrConstraint.paths ? name : name.slice(elementOrConstraint.parentTable.length + 1) ], { id: elementOrConstraint.identifier || name, name: 'sqlite' },
+                'Ignoring add of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+        return false;
+      }
+
+      return true;
     },
     function forEachMigration(migrate, name, migration, change, error) {
       const newIsKey = isKey(migration.new);
       const oldIsKey = isKey(migration.old);
-      if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) { // Turned into key or key was removed
-        error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite' }, 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)');
-      }
-      else { // Ignore simple migrations
+      if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) // Turned into key or key was removed
+        error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite', '#': 'changed' } );
+      else
         delete change[name];
-      }
+    },
+    function forEachConstraintRemoval(constraintRemovals, name, constraint, warning) {
+      warning('def-unsupported-constraint-drop', [ 'definitions', constraint.parentTable, 'elements', constraint.paths ? name : name.slice(constraint.parentTable.length + 1) ], { id: constraint.identifier || name, name: 'sqlite' },
+              'Ignoring drop of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+      delete constraintRemovals[name];
     }
   ),
   postgres: getFilterObject('postgres'),
@@ -35,22 +46,32 @@ module.exports = {
   csn: filterCsn,
 };
 
-function getFilterObject( dialect, extensionCallback, migrationCallback ) {
+function getFilterObject( dialect, extensionCallback, migrationCallback, removeConstraintsCallback ) {
   return {
-    // will be called with a simple Array.forEach
-    extension: ({ elements, extend }, error) => {
-      if (extensionCallback) {
-        forEach(elements, (name, element) => {
-          extensionCallback(extend, name, element, error);
-        });
-      }
+    // will be called with a simple Array.filter, as we need to filter constraint `ADD` for SQLite
+    extension: ({
+      elements, constraint, constraintName, extend,
+    }, { error, message, warning }) => {
+      let returnValue = true;
+      forEach(elements, (name, element) => {
+        if (dialect !== 'sqlite' && isKey(element))
+          message('type-unsupported-key-change', [ 'definitions', extend, 'elements', name ], { id: name, '#': 'std' } );
+        else if (extensionCallback && !extensionCallback(extend, name, element, { error, warning }))
+          returnValue = false;
+      });
+
+      if (constraint && extensionCallback && !extensionCallback(extend, constraintName, constraint, { error, warning }))
+        returnValue = false;
+
+      return returnValue;
     },
-    // will be called with a Array.map, as we need to filter "change" for SQLite
-    migration: ({ change, migrate, remove }, error) => {
+    // will be called with a Array.forEach
+    migration: ({
+      change, migrate, remove, removeConstraints,
+    }, { error, warning, message }) => {
       forEach(remove, (name) => {
         error('def-unsupported-element-drop', [ 'definitions', migrate, 'elements', name ], {}, 'Dropping elements is not supported');
       });
-
       forEach(change, (name, migration) => {
         const loc = [ 'definitions', migrate, 'elements', name ];
         if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
@@ -61,11 +82,22 @@ function getFilterObject( dialect, extensionCallback, migrationCallback ) {
           error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported');
         else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
           error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported');
+        else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
+          message('type-unsupported-key-change', [ 'definitions', migrate, 'elements', name ], { id: name, '#': 'changed' } );
         else if (migrationCallback)
           migrationCallback(migrate, name, migration, change, error);
 
         // TODO: precision/scale growth
       });
+
+      if (removeConstraintsCallback) {
+        const constraintTypes = [ 'unique', 'referential' ];
+        constraintTypes.forEach((constraintType) => {
+          forEach(removeConstraints?.[constraintType], (name, constraint) => {
+            removeConstraintsCallback(removeConstraints[constraintType], name, constraint, warning);
+          });
+        });
+      }
     },
     deletion: ([ artifactName, artifact ], error) => {
       if (isPersistedAsTable(artifact))
@@ -110,10 +142,8 @@ function typeChangeIsNotCompatible( dialect, before, after ) {
  */
 function filterCsn( csn ) {
   const annosToKeep = {
-    '@cds.persistence.skip': true,
-    '@cds.persistence.exists': true,
-    '@cds.persistence.table': true,
-    '@cds.persistence.name': true,
+    // + @cds.persistence.*
+    '@assert.integrity': true,
     '@sql.append': true,
     '@sql.prepend': true,
   };
@@ -122,14 +152,14 @@ function filterCsn( csn ) {
     elements: (parent, prop, elements) => {
       forEachValue(elements, (element) => {
         forEachKey(element, (key) => {
-          if ((key.startsWith('@') && !annosToKeep[key]) || key === 'keys')
+          if ((key.startsWith('@') && !key.startsWith('@cds.persistence.') && !annosToKeep[key]) || key === 'keys')
             delete element[key];
         });
       });
     },
   }, [ (artifact) => {
     forEachKey(artifact, (key) => {
-      if (key.startsWith('@') && !annosToKeep[key])
+      if (key.startsWith('@') && !key.startsWith('@cds.persistence.') && !annosToKeep[key])
         delete artifact[key];
     });
   } ]);

package/lib/optionProcessor.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { createOptionProcessor } = require('./base/optionProcessorHelper');
+const { availableBetaFlags } = require('./base/model');
 
 // This option processor is used both by the command line parser (to translate cmd line options
 // into an options object) and by the API functions (to verify options)
@@ -20,7 +21,7 @@ optionProcessor
   .option('    --color <mode>', ['auto', 'always', 'never'])
   .option('-o, --out <dir>')
   .option('    --cds-home <dir>')
-  .option('    --fuzzy-csn-error')
+  .option('    --module-lookup-directories <list>')
   .option('    --trace-fs')
   .option('    --error <id-list>')
   .option('    --warn <id-list>')
@@ -77,7 +78,8 @@ 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>
-       --fuzzy-csn-error    Report free-style CSN properties as errors
+       --module-lookup-directories <list>  Comma separated list of directories to look
+                            for CDS modules. Default is 'node_modules/'.
        --                   Indicate the end of options (helpful if source names start with "-")
 
   Type options
@@ -102,12 +104,11 @@ optionProcessor
        --beta-mode          Enable all unsupported, incomplete (beta) features
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
-                              hanaAssocRealCardinality
-                              mapAssocToJoinCardinality
-                              enableUniversalCsn
-                              aspectWithoutElements
-                              odataTerms
-                              optionalActionFunctionParameters
+                              ${
+  Object.keys(availableBetaFlags).sort()
+    .filter(flag => availableBetaFlags[flag])
+    .join('\n' + ' '.repeat(30))
+}
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
                               eagerPersistenceForGeneratedEntities
@@ -228,6 +229,7 @@ optionProcessor.command('O, toOdata')
   .option('-f, --odata-format <format>', ['flat', 'structured'])
   .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
   .option('-s, --service-names <list>')
+  .option('    --fewer-localized-views')
   .help(`
   Usage: cdsc toOdata [options] <files...>
 
@@ -264,6 +266,8 @@ optionProcessor.command('O, toOdata')
                                          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
+   --fewer-localized-views   If set, the backends will not create localized convenience views for
+                             those views, that only have an association to a localized entity/view.
 `);
 
 optionProcessor.command('C, toCdl')
@@ -296,6 +300,7 @@ optionProcessor.command('Q, toSql')
   .option('    --disable-hana-comments')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables')
+  .option('    --fewer-localized-views')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -347,7 +352,10 @@ optionProcessor.command('Q, toSql')
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
    --generated-by-comment     Enable rendering of the initial SQL comment for HDI-based artifacts
-   --better-sqlite-session-variables    Enable better-sqlite compatible rendering of $user. Only active if sqlDialect is \`sqlite\`
+   --better-sqlite-session-variables    Enable better-sqlite compatible rendering of $user. Only
+                              active if sqlDialect is \`sqlite\`
+   --fewer-localized-views    If set, the backends will not create localized convenience views for
+                              those views, that only have an association to a localized entity/view.
 
 `);
 
@@ -425,6 +433,7 @@ optionProcessor.command('toCsn')
   .option('    --with-localized')
   .option('    --with-locations')
   .option('    --struct-xpr')
+  .option('    --fewer-localized-views')
   .help(`
   Usage: cdsc toCsn [options] <files...>
 
@@ -441,6 +450,9 @@ optionProcessor.command('toCsn')
                                 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.
+       --fewer-localized-views   If --with-locations and this option are set, the backends
+                          will not create localized convenience views for those views,
+                          that only have an association to a localized entity/view.
 
   Internal options (for testing only, may be changed/removed at any time)
        --with-localized   Add localized convenience views to the CSN output.

package/lib/render/manageConstraints.js

@@ -101,26 +101,28 @@ function manageConstraints( csn, options ) {
   forEachDefinition(csn, (artifact) => {
     if (artifact.$tableConstraints?.referential) {
       forEach(artifact.$tableConstraints.referential, (fileName, constraint) => {
-        const renderAlterConstraintStatement = options.alter && options.src !== 'hdi';
-        const renderedConstraint = renderReferentialConstraint(constraint, indent, false, csn, options, renderAlterConstraintStatement);
-        if (options.src === 'hdi' && !options.drop) {
-          resultArtifacts[fileName] = renderedConstraint;
-          return;
-        }
-        let alterTableStatement = '';
-        alterTableStatement += `${indent}ALTER TABLE ${quoteSqlId(getResultingName(csn, options.sqlMapping, constraint.dependentTable))}`;
-        if (renderAlterConstraintStatement)
-          alterTableStatement += `\n${indent}ALTER ${renderedConstraint};`;
-        else if (options.drop)
-          alterTableStatement += `${indent} DROP CONSTRAINT ${quoteSqlId(constraint.identifier)};`;
-        else
-          alterTableStatement += `\n${indent}ADD ${renderedConstraint};`;
-
-        resultArtifacts[fileName] = alterTableStatement;
+        resultArtifacts[fileName] = manageConstraint(constraint, csn, options, indent, quoteSqlId);
       });
     }
   });
-  return options.src === 'hdi' ? resultArtifacts : Object.values(resultArtifacts);
+  return resultArtifacts;
+}
+
+function manageConstraint( constraint, csn, options, indent, quoteSqlId ) {
+  const renderAlterConstraintStatement = options.alter && options.src !== 'hdi';
+  const renderedConstraint = renderReferentialConstraint(constraint, indent, false, csn, options, renderAlterConstraintStatement);
+  if (options.src === 'hdi' && !options.drop)
+    return renderedConstraint;
+  let alterTableStatement = '';
+  alterTableStatement += `${indent}ALTER TABLE ${quoteSqlId(getResultingName(csn, options.sqlMapping, constraint.dependentTable))}`;
+  if (renderAlterConstraintStatement)
+    alterTableStatement += `\n${indent}ALTER ${renderedConstraint};`;
+  else if (options.drop)
+    alterTableStatement += `${indent} DROP CONSTRAINT ${quoteSqlId(constraint.identifier)};`;
+  else
+    alterTableStatement += `\n${indent}ADD ${renderedConstraint};`;
+
+  return alterTableStatement;
 }
 
 /**
@@ -264,5 +266,6 @@ function getListOfAllConstraints( csn ) {
 module.exports = {
   alterConstraintsWithCsn,
   manageConstraints,
+  manageConstraint,
   listReferentialIntegrityViolations,
 };