@cap-js/change-tracking 2.0.0-beta.4 → 2.0.0-beta.6

package/lib/hana/restoreProcedure.js

@@ -0,0 +1,342 @@
+const utils = require('../utils/change-tracking.js');
+const { getCompositionParentInfo, getGrandParentCompositionInfo } = require('../utils/composition-helpers.js');
+const { compositeKeyExpr } = require('./sql-expressions.js');
+
+/**
+ * Generates a HANA stored procedure that restores parent backlinks for composition changes.
+ *
+ * The procedure:
+ * 1. Finds all change entries for composition child entities that have no parent_ID set
+ * 2. Uses the child data table to resolve the parent entity key via FK lookup
+ * 3. Creates a parent composition entry (valueDataType='cds.Composition') if one doesn't exist
+ * 4. Updates child entries to set parent_ID pointing to the parent composition entry
+ * 5. Links composition entries to their grandparent composition entries (for deep hierarchies)
+ *
+ */
+function generateRestoreBacklinksProcedure(runtimeCSN, hierarchy, entities) {
+	const compositions = _collectCompositionInfo(runtimeCSN, hierarchy, entities);
+	if (compositions.length === 0) return null;
+
+	const blocks = compositions.map((comp) => _generateCompositionBlock(comp));
+
+	const procedureSQL = `PROCEDURE "SAP_CHANGELOG_RESTORE_BACKLINKS" ()
+	LANGUAGE SQLSCRIPT
+	SQL SECURITY INVOKER
+AS
+BEGIN
+${blocks.join('\n')}
+END`;
+
+	return {
+		name: 'SAP_CHANGELOG_RESTORE_BACKLINKS',
+		sql: procedureSQL,
+		suffix: '.hdbprocedure'
+	};
+}
+
+function _collectCompositionInfo(runtimeCSN, hierarchy, entities) {
+	const result = [];
+
+	for (const [childEntityName, hierarchyInfo] of hierarchy) {
+		const { parent: parentEntityName, compositionField } = hierarchyInfo;
+		if (!parentEntityName || !compositionField) continue;
+
+		const childEntity = runtimeCSN.definitions[childEntityName];
+		const parentEntity = runtimeCSN.definitions[parentEntityName];
+		if (!childEntity || !parentEntity) continue;
+
+		// Check if this entity is actually tracked (in our entities list)
+		const isTracked = entities.some((e) => e.dbEntityName === childEntityName);
+		if (!isTracked) continue;
+
+		// Get the FK binding from child to parent
+		const parentMergedAnnotations = entities.find((e) => e.dbEntityName === parentEntityName)?.mergedAnnotations;
+		const compositionParentInfo = getCompositionParentInfo(childEntity, parentEntity, parentMergedAnnotations);
+		if (!compositionParentInfo) continue;
+
+		const { parentKeyBinding } = compositionParentInfo;
+
+		// Skip composition of one - they have reverse FK direction and different handling
+		if (parentKeyBinding.type === 'compositionOfOne') continue;
+
+		const childKeys = utils.extractKeys(childEntity.keys);
+		const parentKeys = utils.extractKeys(parentEntity.keys);
+		const rootObjectIDs = utils.getObjectIDs(parentEntity, runtimeCSN, parentMergedAnnotations?.entityAnnotation);
+
+		// Collect child entity's objectIDs for restoring objectID on orphaned child entries
+		const childMergedAnnotations = entities.find((e) => e.dbEntityName === childEntityName)?.mergedAnnotations;
+		const childObjectIDs = utils.getObjectIDs(childEntity, runtimeCSN, childMergedAnnotations?.entityAnnotation);
+
+		// Collect grandparent info for deep hierarchies (e.g., Level2 -> Level1 -> Root)
+		const grandParentEntityName = hierarchyInfo?.grandParent ?? null;
+		const grandParentEntity = grandParentEntityName ? runtimeCSN.definitions[grandParentEntityName] : null;
+		const grandParentMergedAnnotations = grandParentEntityName ? entities.find((e) => e.dbEntityName === grandParentEntityName)?.mergedAnnotations : null;
+		const grandParentCompositionField = hierarchyInfo?.grandParentCompositionField ?? null;
+		const grandParentCompositionInfo = getGrandParentCompositionInfo(parentEntity, grandParentEntity, grandParentMergedAnnotations, grandParentCompositionField);
+
+		// If there's a grandparent, collect its keys, table name, and objectIDs for entry creation
+		let grandParentKeys, grandParentTableName, grandParentObjectIDs;
+		if (grandParentCompositionInfo && grandParentEntity) {
+			grandParentKeys = utils.extractKeys(grandParentEntity.keys);
+			grandParentTableName = utils.transformName(grandParentEntityName);
+			grandParentObjectIDs = utils.getObjectIDs(grandParentEntity, runtimeCSN, grandParentMergedAnnotations?.entityAnnotation);
+		}
+
+		result.push({
+			childEntityName,
+			parentEntityName,
+			compositionField,
+			childTableName: utils.transformName(childEntityName),
+			parentTableName: utils.transformName(parentEntityName),
+			fkFields: parentKeyBinding,
+			childKeys,
+			parentKeys,
+			rootObjectIDs,
+			childObjectIDs,
+			grandParentCompositionInfo,
+			grandParentKeys,
+			grandParentTableName,
+			grandParentObjectIDs
+		});
+	}
+
+	return result;
+}
+
+/**
+ * Builds the JOIN condition between Changes.entityKey and the child data table.
+ * Handles both v2 format (HIERARCHY_COMPOSITE_ID for multi-key) and v1 migrated format (single key only).
+ */
+function _buildChildKeyJoinCondition(childKeys, alias, changesAlias) {
+	const compositeExpr = compositeKeyExpr(childKeys.map((k) => `${alias}.${k}`));
+
+	// Single key: straightforward join
+	if (childKeys.length <= 1) {
+		return `${changesAlias}.ENTITYKEY = ${compositeExpr}`;
+	}
+
+	// Composite keys: support both v2 format (HIERARCHY_COMPOSITE_ID) and v1 migrated format (single ID only)
+	// v1 migrated data may have stored only the last key segment as entityKey
+	const lastKey = childKeys[childKeys.length - 1];
+	return `(${changesAlias}.ENTITYKEY = ${compositeExpr} OR ${changesAlias}.ENTITYKEY = TO_NVARCHAR(${alias}.${lastKey}))`;
+}
+
+/**
+ * Generates the SQL block for a single composition relationship.
+ */
+function _generateCompositionBlock(comp) {
+	const {
+		childEntityName,
+		parentEntityName,
+		compositionField,
+		childTableName,
+		parentTableName,
+		fkFields,
+		childKeys,
+		parentKeys,
+		rootObjectIDs,
+		childObjectIDs,
+		grandParentCompositionInfo,
+		grandParentKeys,
+		grandParentTableName,
+		grandParentObjectIDs
+	} = comp;
+
+	// Build JOIN condition handling both v2 composite keys and v1 migrated simple keys
+	const childKeyJoinStep1 = _buildChildKeyJoinCondition(childKeys, 'child_data', 'c');
+	const childKeyJoinStep2 = _buildChildKeyJoinCondition(childKeys, 'child_data', 'c2');
+
+	// Expression to compute the parent's entity key from the child data table's FK columns
+	const parentKeyFromChild = compositeKeyExpr(fkFields.map((fk) => `child_data.${fk}`));
+
+	// ObjectID expression for the parent composition entry
+	// Only use objectIDs that are direct columns on the parent table (not association paths requiring JOINs)
+	const simpleObjectIDs = rootObjectIDs?.filter((oid) => !oid.name.includes('.')) ?? [];
+	let objectIDExpr;
+	if (simpleObjectIDs.length > 0) {
+		const parts = simpleObjectIDs.map((oid) => `COALESCE(TO_NVARCHAR((SELECT ${oid.name} FROM ${parentTableName} WHERE ${parentKeys.map((pk) => `${pk} = grp.PARENT_ENTITYKEY`).join(' AND ')})), '')`);
+		const concatExpr = parts.length > 1 ? parts.join(" || ', ' || ") : parts[0];
+		objectIDExpr = `COALESCE(NULLIF(${concatExpr}, ''), grp.PARENT_ENTITYKEY)`;
+	} else {
+		objectIDExpr = 'grp.PARENT_ENTITYKEY';
+	}
+
+	// Child objectID expression for restoring objectID on orphaned child entries
+	// Uses @changelog fields if available, otherwise falls back to the child's entity key
+	const simpleChildObjectIDs = childObjectIDs?.filter((oid) => !oid.name.includes('.')) ?? [];
+	const childEntityKeyExpr = compositeKeyExpr(childKeys.map((k) => `child_data.${k}`));
+	let childObjectIDExpr;
+	if (simpleChildObjectIDs.length > 0) {
+		const childParts = simpleChildObjectIDs.map((oid) => `COALESCE(TO_NVARCHAR(child_data.${oid.name}), '<empty>')`);
+		const childConcatExpr = childParts.length > 1 ? childParts.join(" || ', ' || ") : childParts[0];
+		childObjectIDExpr = `COALESCE(NULLIF(${childConcatExpr}, ''), ${childEntityKeyExpr})`;
+	} else {
+		childObjectIDExpr = childEntityKeyExpr;
+	}
+
+	// Modification: 'create' if the parent entity was created in the same tx, 'update' otherwise
+	const modificationExpr = `CASE WHEN EXISTS (
+				SELECT 1 FROM SAP_CHANGELOG_CHANGES
+				WHERE entity = '${parentEntityName}'
+				AND entityKey = grp.PARENT_ENTITYKEY
+				AND modification = 'create'
+				AND transactionID = grp.TRANSACTIONID
+			) THEN 'create' ELSE 'update' END`;
+
+	let block = `
+	-- ============================================================================
+	-- Restore backlinks: ${childEntityName} -> ${parentEntityName}.${compositionField}
+	-- ============================================================================
+
+	-- Step 1: Create parent composition entries where missing
+	INSERT INTO SAP_CHANGELOG_CHANGES
+		(ID, parent_ID, attribute, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+	SELECT
+		SYSUUID,
+		NULL,
+		'${compositionField}',
+		'${parentEntityName}',
+		grp.PARENT_ENTITYKEY,
+		${objectIDExpr},
+		grp.MIN_CREATEDAT,
+		grp.CREATEDBY,
+		'cds.Composition',
+		${modificationExpr},
+		grp.TRANSACTIONID
+	FROM (
+		SELECT
+			${parentKeyFromChild} AS PARENT_ENTITYKEY,
+			c.TRANSACTIONID,
+			MIN(c.CREATEDAT) AS MIN_CREATEDAT,
+			MIN(c.CREATEDBY) AS CREATEDBY
+		FROM SAP_CHANGELOG_CHANGES c
+		INNER JOIN ${childTableName} child_data
+			ON ${childKeyJoinStep1}
+		WHERE c.entity = '${childEntityName}'
+		AND c.parent_ID IS NULL
+		AND c.valueDataType != 'cds.Composition'
+		AND NOT EXISTS (
+			SELECT 1 FROM SAP_CHANGELOG_CHANGES p
+			WHERE p.entity = '${parentEntityName}'
+			AND p.attribute = '${compositionField}'
+			AND p.valueDataType = 'cds.Composition'
+			AND p.transactionID = c.transactionID
+			AND p.entityKey = ${parentKeyFromChild}
+		)
+		GROUP BY ${parentKeyFromChild}, c.TRANSACTIONID, c.CREATEDBY
+	) grp;
+
+	-- Step 2: Link orphaned child entries to their parent composition entry and restore objectID
+	MERGE INTO SAP_CHANGELOG_CHANGES AS c
+	USING (
+		SELECT c2.ID AS CHILD_ID, p.ID AS PARENT_ID, ${childObjectIDExpr} AS CHILD_OBJECTID
+		FROM SAP_CHANGELOG_CHANGES c2
+		INNER JOIN ${childTableName} child_data
+			ON ${childKeyJoinStep2}
+		INNER JOIN SAP_CHANGELOG_CHANGES p
+			ON p.entity = '${parentEntityName}'
+			AND p.attribute = '${compositionField}'
+			AND p.valueDataType = 'cds.Composition'
+			AND p.transactionID = c2.transactionID
+			AND p.entityKey = ${parentKeyFromChild}
+		WHERE c2.entity = '${childEntityName}'
+		AND c2.parent_ID IS NULL
+		AND c2.valueDataType != 'cds.Composition'
+	) AS matched
+	ON c.ID = matched.CHILD_ID
+	WHEN MATCHED THEN UPDATE SET c.parent_ID = matched.PARENT_ID, c.objectID = matched.CHILD_OBJECTID;`;
+
+	// Create grandparent composition entries and link to them (for deep hierarchies)
+	if (grandParentCompositionInfo) {
+		const { grandParentEntityName, grandParentCompositionFieldName, grandParentKeyBinding } = grandParentCompositionInfo;
+
+		// Build expression to resolve the grandparent entity key from the parent data table's FK columns
+		const grandParentKeyFromParent = compositeKeyExpr(grandParentKeyBinding.map((fk) => `parent_data.${fk}`));
+
+		// Build grandparent objectID expression
+		const simpleGPObjectIDs = grandParentObjectIDs?.filter((oid) => !oid.name.includes('.')) ?? [];
+		let gpObjectIDExpr;
+		if (simpleGPObjectIDs.length > 0) {
+			const gpParts = simpleGPObjectIDs.map((oid) => `COALESCE(TO_NVARCHAR((SELECT ${oid.name} FROM ${grandParentTableName} WHERE ${grandParentKeys.map((pk) => `${pk} = grp2.GP_ENTITYKEY`).join(' AND ')})), '')`);
+			const gpConcatExpr = gpParts.length > 1 ? gpParts.join(" || ', ' || ") : gpParts[0];
+			gpObjectIDExpr = `COALESCE(NULLIF(${gpConcatExpr}, ''), grp2.GP_ENTITYKEY)`;
+		} else {
+			gpObjectIDExpr = 'grp2.GP_ENTITYKEY';
+		}
+
+		// Modification for grandparent: 'create' if grandparent was created in same tx, 'update' otherwise
+		const gpModificationExpr = `CASE WHEN EXISTS (
+					SELECT 1 FROM SAP_CHANGELOG_CHANGES
+					WHERE entity = '${grandParentEntityName}'
+					AND entityKey = grp2.GP_ENTITYKEY
+					AND modification = 'create'
+					AND transactionID = grp2.TRANSACTIONID
+				) THEN 'create' ELSE 'update' END`;
+
+		block += `
+
+	-- Step 3a: Create grandparent composition entries where missing
+	INSERT INTO SAP_CHANGELOG_CHANGES
+		(ID, parent_ID, attribute, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+	SELECT
+		SYSUUID,
+		NULL,
+		'${grandParentCompositionFieldName}',
+		'${grandParentEntityName}',
+		grp2.GP_ENTITYKEY,
+		${gpObjectIDExpr},
+		grp2.MIN_CREATEDAT,
+		grp2.CREATEDBY,
+		'cds.Composition',
+		${gpModificationExpr},
+		grp2.TRANSACTIONID
+	FROM (
+		SELECT
+			${grandParentKeyFromParent} AS GP_ENTITYKEY,
+			comp2.TRANSACTIONID,
+			MIN(comp2.CREATEDAT) AS MIN_CREATEDAT,
+			MIN(comp2.CREATEDBY) AS CREATEDBY
+		FROM SAP_CHANGELOG_CHANGES comp2
+		INNER JOIN ${parentTableName} parent_data
+			ON comp2.ENTITYKEY = ${compositeKeyExpr(parentKeys.map((pk) => `parent_data.${pk}`))}
+		WHERE comp2.entity = '${parentEntityName}'
+		AND comp2.attribute = '${compositionField}'
+		AND comp2.valueDataType = 'cds.Composition'
+		AND comp2.parent_ID IS NULL
+		AND NOT EXISTS (
+			SELECT 1 FROM SAP_CHANGELOG_CHANGES gp
+			WHERE gp.entity = '${grandParentEntityName}'
+			AND gp.attribute = '${grandParentCompositionFieldName}'
+			AND gp.valueDataType = 'cds.Composition'
+			AND gp.transactionID = comp2.transactionID
+			AND gp.entityKey = ${grandParentKeyFromParent}
+		)
+		GROUP BY ${grandParentKeyFromParent}, comp2.TRANSACTIONID, comp2.CREATEDBY
+	) grp2;
+
+	-- Step 3b: Link composition entries to their grandparent composition entries
+	MERGE INTO SAP_CHANGELOG_CHANGES AS comp
+	USING (
+		SELECT comp2.ID AS COMP_ID, gp.ID AS GRANDPARENT_ID
+		FROM SAP_CHANGELOG_CHANGES comp2
+		INNER JOIN ${parentTableName} parent_data
+			ON comp2.ENTITYKEY = ${compositeKeyExpr(parentKeys.map((pk) => `parent_data.${pk}`))}
+		INNER JOIN SAP_CHANGELOG_CHANGES gp
+			ON gp.entity = '${grandParentEntityName}'
+			AND gp.attribute = '${grandParentCompositionFieldName}'
+			AND gp.valueDataType = 'cds.Composition'
+			AND gp.transactionID = comp2.transactionID
+			AND gp.entityKey = ${grandParentKeyFromParent}
+		WHERE comp2.entity = '${parentEntityName}'
+		AND comp2.attribute = '${compositionField}'
+		AND comp2.valueDataType = 'cds.Composition'
+		AND comp2.parent_ID IS NULL
+	) AS matched
+	ON comp.ID = matched.COMP_ID
+	WHEN MATCHED THEN UPDATE SET comp.parent_ID = matched.GRANDPARENT_ID;`;
+	}
+
+	return block;
+}
+
+module.exports = { generateRestoreBacklinksProcedure };

package/lib/hana/sql-expressions.js

@@ -1,15 +1,14 @@
 const utils = require('../utils/change-tracking.js');
 const { CT_SKIP_VAR, getEntitySkipVarName, getElementSkipVarName } = require('../utils/session-variables.js');
-
-const HANAService = require('@cap-js/hana');
-const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 const { createTriggerCQN2SQL } = require('../TriggerCQN2SQL.js');
 
-const TriggerCQN2SQL = createTriggerCQN2SQL(HANAService.CQN2SQL);
 let HANACQN2SQL;
 
 function toSQL(query, model) {
+	const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 	if (!HANACQN2SQL) {
+		const { CQN2SQL } = require('@cap-js/hana');
+		const TriggerCQN2SQL = createTriggerCQN2SQL(CQN2SQL);
 		HANACQN2SQL = new TriggerCQN2SQL();
 	}
 	const sqlCQN = cqn4sql(query, model);
@@ -27,7 +26,7 @@ function getElementSkipCondition(entityName, elementName) {
 }
 
 function compositeKeyExpr(parts) {
-	if (parts.length <= 1) return parts[0];
+	if (parts.length <= 1) return `TO_NVARCHAR(${parts[0]})`;
 	return `HIERARCHY_COMPOSITE_ID(${parts.join(', ')})`;
 }
 
@@ -100,14 +99,9 @@ function getWhereCondition(col, modification) {
 }
 
 /**
- * Returns SQL expression for a column's label (looked-up value for associations)
+ * Builds scalar subselect for association label lookup with locale awareness
  */
-function getLabelExpr(col, refRow, model) {
-	if (!(col.target && col.alt)) {
-		return `NULL`;
-	}
-
-	// Builds inline SELECT expression for association label lookup with locale support
+function buildAssocLookup(col, assocPaths, refRow, model) {
 	let where = {};
 	if (col.foreignKeys) {
 		where = col.foreignKeys.reduce((acc, k) => {
@@ -121,11 +115,11 @@ function getLabelExpr(col, refRow, model) {
 		}, {});
 	}
 
-	const alt = col.alt.map((s) => s.split('.').slice(1).join('.'));
+	const alt = assocPaths.map((s) => s.split('.').slice(1).join('.'));
 	const columns = alt.length === 1 ? alt[0] : utils.buildConcatXpr(alt);
 
 	// Check for localization
-	const localizedInfo = utils.getLocalizedLookupInfo(col.target, col.alt, model);
+	const localizedInfo = utils.getLocalizedLookupInfo(col.target, assocPaths, model);
 	if (localizedInfo) {
 		const textsWhere = { ...where, locale: { func: 'SESSION_CONTEXT', args: [{ val: 'LOCALE' }] } };
 		const textsQuery = SELECT.one.from(localizedInfo.textsEntity).columns(columns).where(textsWhere);
@@ -137,6 +131,35 @@ function getLabelExpr(col, refRow, model) {
 	return `(${toSQL(query, model)})`;
 }
 
+/**
+ * Returns SQL expression for a column's label (looked-up value for associations)
+ */
+function getLabelExpr(col, refRow, model) {
+	if (!col.alt || col.alt.length === 0) return `NULL`;
+
+	const parts = [];
+	let assocBatch = [];
+
+	const flushAssocBatch = () => {
+		if (assocBatch.length > 0) {
+			parts.push(buildAssocLookup(col, assocBatch, refRow, model));
+			assocBatch = [];
+		}
+	};
+
+	for (const entry of col.alt) {
+		if (entry.source === 'assoc') {
+			assocBatch.push(entry.path);
+		} else {
+			flushAssocBatch();
+			parts.push(`TO_NVARCHAR(:${refRow}.${entry.path})`);
+		}
+	}
+	flushAssocBatch();
+
+	return parts.length === 0 ? `NULL` : parts.join(" || ', ' || ");
+}
+
 /**
  * Builds SQL expression for objectID (entity display name)
  * Uses @changelog annotation fields, falling back to entity name

package/lib/postgres/register.js

@@ -26,18 +26,6 @@ function registerPostgresCompilerHook() {
 
 		return ddl;
 	});
-
-	// REVISIT: Remove once time casting is fixed in cds-dbs
-	cds.on('serving', async () => {
-		if (cds.env.requires?.db.kind !== 'postgres') return;
-		const db = await cds.connect.to('db');
-		db.before('*', () => {
-			db.class.CQN2SQL.OutputConverters.Date = (e) => `to_date(${e}::text, 'YYYY-MM-DD')`;
-			db.class.CQN2SQL.OutputConverters.Time = (e) => `to_timestamp(${e}::text, 'HH24:MI:SS')::TIME`;
-			db.class.CQN2SQL.OutputConverters.DateTime = (e) => `to_timestamp(${e}::text, 'YYYY-MM-DD"T"HH24:MI:SS"Z"')::timestamp`;
-			db.class.CQN2SQL.OutputConverters.Timestamp = (e) => `to_timestamp(${e}::text, 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')::timestamp`;
-		});
-	});
 }
 
 async function deployPostgresLabels() {

package/lib/postgres/sql-expressions.js

@@ -1,13 +1,13 @@
 const cds = require('@sap/cds');
 const utils = require('../utils/change-tracking.js');
 const config = cds.env.requires['change-tracking'];
-const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 const { CT_SKIP_VAR, getEntitySkipVarName, getElementSkipVarName } = require('../utils/session-variables.js');
 const { createTriggerCQN2SQL } = require('../TriggerCQN2SQL.js');
 
 const _cqn2sqlCache = new WeakMap();
 
 function toSQL(query, model) {
+	const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 	let cqn2sql = _cqn2sqlCache.get(model);
 	if (!cqn2sql) {
 		const Service = require('@cap-js/postgres');
@@ -84,9 +84,13 @@ function getWhereCondition(col, modification) {
 }
 
 /**
- * Builds scalar subselect for association label lookup with locale support
+ * Builds scalar subselect for association label lookup with locale support.
+ * @param {Object} column Column entry with target, foreignKeys/on, etc.
+ * @param {string[]} assocPaths Array of association paths (format: "assocName.field")
+ * @param {string} refRow Trigger row reference ('NEW' or 'OLD')
+ * @param {*} model CSN model
  */
-function buildAssocLookup(column, refRow, model) {
+function buildAssocLookup(column, assocPaths, refRow, model) {
 	let where = {};
 	if (column.foreignKeys) {
 		where = column.foreignKeys.reduce((acc, k) => {
@@ -100,11 +104,11 @@ function buildAssocLookup(column, refRow, model) {
 		}, {});
 	}
 
-	const alt = column.alt.map((s) => s.split('.').slice(1).join('.'));
+	const alt = assocPaths.map((s) => s.split('.').slice(1).join('.'));
 	const columns = alt.length === 1 ? alt[0] : utils.buildConcatXpr(alt);
 
 	// Check for localization
-	const localizedInfo = utils.getLocalizedLookupInfo(column.target, column.alt, model);
+	const localizedInfo = utils.getLocalizedLookupInfo(column.target, assocPaths, model);
 	if (localizedInfo) {
 		const textsWhere = { ...where, locale: { func: 'current_setting', args: [{ val: 'cap.locale' }, { val: true }] } };
 		const textsQuery = SELECT.one.from(localizedInfo.textsEntity).columns(columns).where(textsWhere);
@@ -117,13 +121,34 @@ function buildAssocLookup(column, refRow, model) {
 }
 
 /**
- * Returns SQL expression for a column's label (looked-up value for associations)
+ * Returns SQL expression for a column's label (looked-up value for associations).
+ * Iterates over col.alt entries in order, grouping consecutive association paths
+ * into a single subquery and emitting local references inline from the trigger row.
  */
 function getLabelExpr(col, refRow, model) {
-	if (col.target && col.alt) {
-		return buildAssocLookup(col, refRow, model);
+	if (!col.alt || col.alt.length === 0) return 'NULL';
+
+	const parts = [];
+	let assocBatch = [];
+
+	const flushAssocBatch = () => {
+		if (assocBatch.length > 0) {
+			parts.push(buildAssocLookup(col, assocBatch, refRow, model));
+			assocBatch = [];
+		}
+	};
+
+	for (const entry of col.alt) {
+		if (entry.source === 'assoc') {
+			assocBatch.push(entry.path);
+		} else {
+			flushAssocBatch();
+			parts.push(`${refRow}.${entry.path}::TEXT`);
+		}
 	}
-	return 'NULL';
+	flushAssocBatch();
+
+	return parts.length === 0 ? 'NULL' : parts.join(" || ', ' || ");
 }
 
 /**

package/lib/postgres/triggers.js

@@ -1,7 +1,9 @@
+const cds = require('@sap/cds');
 const utils = require('../utils/change-tracking.js');
 const { getCompositionParentInfo, getGrandParentCompositionInfo } = require('../utils/composition-helpers.js');
 const { getSkipCheckCondition, compositeKeyExpr, buildObjectIDAssignment, buildInsertBlock, extractTrackedDbColumns } = require('./sql-expressions.js');
 const { buildCompositionParentBlock } = require('./composition.js');
+const config = cds.env.requires['change-tracking'];
 
 /**
  * Generates the PL/pgSQL function body for the main change tracking trigger
@@ -18,9 +20,9 @@ function buildFunctionBody(entity, columns, objectIDs, rootEntity, rootObjectIDs
 	const deleteBlock = columns.length > 0 ? buildInsertBlock(columns, 'delete', entity, model, hasCompositionParent) : '';
 
 	// Build composition parent blocks if needed
-	const createParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'create', model, grandParentCompositionInfo) : '';
-	const updateParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'update', model, grandParentCompositionInfo) : '';
-	const deleteParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'delete', model, grandParentCompositionInfo) : '';
+	const createParentBlock = compositionParentInfo && !config?.disableCreateTracking ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'create', model, grandParentCompositionInfo) : '';
+	const updateParentBlock = compositionParentInfo && !config?.disableUpdateTracking ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'update', model, grandParentCompositionInfo) : '';
+	const deleteParentBlock = compositionParentInfo && !config?.disableDeleteTracking ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'delete', model, grandParentCompositionInfo) : '';
 
 	return `
         DECLARE

package/lib/skipHandlers.js

@@ -7,7 +7,7 @@ const { setSkipSessionVariables, resetSkipSessionVariables, resetAutoSkipForServ
  * Register db handlers for setting/resetting session variables on INSERT/UPDATE/DELETE.
  */
 function registerSessionVariableHandlers() {
-	cds.db.before(['INSERT', 'UPDATE', 'DELETE'], async (req) => {
+	cds.db?.before(['INSERT', 'UPDATE', 'DELETE'], async (req) => {
 		const model = cds.context?.model ?? cds.model;
 		const collectedEntities = model.collectEntities || (model.collectEntities = collectEntities(model).collectedEntities);
 		if (!req.target || req.target.name.endsWith('.drafts')) return;
@@ -16,7 +16,7 @@ function registerSessionVariableHandlers() {
 		setSkipSessionVariables(req, srv, collectedEntities);
 	});
 
-	cds.db.after(['INSERT', 'UPDATE', 'DELETE'], async (_, req) => {
+	cds.db?.after(['INSERT', 'UPDATE', 'DELETE'], async (_, req) => {
 		if (!req.target || req.target.name.endsWith('.drafts')) return;
 
 		// Reset auto-skip variable if it was set

package/lib/sqlite/sql-expressions.js

@@ -2,10 +2,10 @@ const utils = require('../utils/change-tracking.js');
 const { CT_SKIP_VAR, getEntitySkipVarName, getElementSkipVarName } = require('../utils/session-variables.js');
 const { createTriggerCQN2SQL } = require('../TriggerCQN2SQL.js');
 
-const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 const _cqn2sqlCache = new WeakMap();
 
 function toSQL(query, model) {
+	const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 	let cqn2sql = _cqn2sqlCache.get(model);
 	if (!cqn2sql) {
 		const SQLiteService = require('@cap-js/sqlite');
@@ -95,7 +95,7 @@ function getWhereCondition(col, modification) {
 /**
  * Builds scalar subselect for association label lookup with locale awareness
  */
-function buildAssocLookup(column, refRow, entityKey, model) {
+function buildAssocLookup(column, assocPaths, refRow, entityKey, model) {
 	const where = column.foreignKeys
 		? column.foreignKeys.reduce((acc, k) => {
 				acc[k] = { val: `${refRow}.${column.name}_${k}` };
@@ -107,12 +107,12 @@ function buildAssocLookup(column, refRow, entityKey, model) {
 				return acc;
 			}, {});
 
-	// Drop the first part of column.alt (association name)
-	const alt = column.alt.map((s) => s.split('.').slice(1).join('.'));
+	// Drop the first part of each path (association name)
+	const alt = assocPaths.map((s) => s.split('.').slice(1).join('.'));
 	const columns = alt.length === 1 ? alt[0] : utils.buildConcatXpr(alt);
 
 	// Check for localization
-	const localizedInfo = utils.getLocalizedLookupInfo(column.target, column.alt, model);
+	const localizedInfo = utils.getLocalizedLookupInfo(column.target, assocPaths, model);
 	if (localizedInfo) {
 		const textsWhere = { ...where, locale: { func: 'session_context', args: [{ val: '$user.locale' }] } };
 		const textsQuery = SELECT.one.from(localizedInfo.textsEntity).columns(columns).where(textsWhere);
@@ -128,10 +128,30 @@ function buildAssocLookup(column, refRow, entityKey, model) {
  * Returns SQL expression for a column's label (looked-up value for associations)
  */
 function getLabelExpr(col, refRow, entityKey, model) {
-	if (col.target && col.alt) {
-		return buildAssocLookup(col, refRow, entityKey, model);
+	if (!col.alt || col.alt.length === 0) return 'NULL';
+
+	const parts = [];
+	let assocBatch = [];
+
+	const flushAssocBatch = () => {
+		if (assocBatch.length > 0) {
+			parts.push(buildAssocLookup(col, assocBatch, refRow, entityKey, model));
+			assocBatch = [];
+		}
+	};
+
+	for (const entry of col.alt) {
+		if (entry.source === 'assoc') {
+			assocBatch.push(entry.path);
+		} else {
+			// local field: flush any pending association batch first, then emit local ref
+			flushAssocBatch();
+			parts.push(`${refRow}.${entry.path}`);
+		}
 	}
-	return 'NULL';
+	flushAssocBatch();
+
+	return parts.length === 0 ? 'NULL' : parts.join(" || ', ' || ");
 }
 
 /**