HCK-16096: add support of hybrid tables on PP and for FE logic

forward_engineering/configs/templates.js

@@ -6,7 +6,7 @@ module.exports = {
 	dropSchema: 'DROP SCHEMA IF EXISTS ${name};\n',
 
 	createTable:
-		'CREATE${orReplace}${temporary}${transient} TABLE${tableIfNotExists}\n' +
+		'CREATE${orReplace}${temporary}${transient}${hybrid} TABLE${tableIfNotExists}\n' +
 		'\t${name} (\n' +
 		'\t\t${column_definitions}' +
 		'${out_of_line_constraints}\n' +
@@ -52,6 +52,12 @@ module.exports = {
 		'\t\t${column_definitions}${out_of_line_constraints}\n' +
 		'\t)${tableOptions};\n',
 
+	createIndex:
+		'CREATE${orReplace} INDEX${ifNotExists} ${name}\n' +
+		'\tON ${tableName} (\n' +
+		'\t\t${keys}\n' +
+		'\t)${includeKeys};',
+
 	columnDefinition:
 		'${name} ${type}${collation}${default}${identity}${autoincrement}${not_nul}${inline_constraint}${comment}${tag}',
 

forward_engineering/ddlProvider.js

@@ -58,12 +58,14 @@ const {
 } = require('./helpers/tagHelper');
 const { createView, hydrateView, hydrateViewColumn } = require('./helpers/viewHelper');
 const { hydrateJsonSchemaColumn } = require('./helpers/hydrateJsonSchema');
+const { prepareIndexKeys } = require('./helpers/indexHelper');
 
 const DEFAULT_SNOWFLAKE_SEQUENCE_START = 1;
 const DEFAULT_SNOWFLAKE_SEQUENCE_INCREMENT = 1;
 
 module.exports = (baseProvider, options, app) => {
-	const { tab, hasType, clean } = app.require('@hackolade/ddl-fe-utils').general;
+	const { tab, hasType, clean, divideIntoActivatedAndDeactivated, checkAllKeysDeactivated } =
+		app.require('@hackolade/ddl-fe-utils').general;
 	const scriptFormat = options?.targetScriptOptions?.keyword || FORMATS.SNOWSIGHT;
 
 	const keyHelper = require('./helpers/keyHelper')(app);
@@ -314,13 +316,15 @@ module.exports = (baseProvider, options, app) => {
 
 		createTable(tableData, isActivated) {
 			const schemaName = get(tableData, 'schemaData.schemaName');
+			const hybrid = preSpace(tableData.hybrid && 'HYBRID');
 			const temporary = preSpace(tableData.temporary && 'TEMPORARY');
 			const transient = preSpace(tableData.transient && !tableData.temporary && 'TRANSIENT');
 			const orReplace = preSpace(tableData.orReplace && 'OR REPLACE');
 			const tableIfNotExists = preSpace(tableData.tableIfNotExists && 'IF NOT EXISTS');
 
 			const clusterKeys = preSpace(
 				!isEmpty(tableData.clusteringKey) &&
+					!hybrid &&
 					'CLUSTER BY (' +
 						(isActivated
 							? foreignKeysToString(tableData.isCaseSensitive, tableData.clusteringKey)
@@ -469,6 +473,7 @@ module.exports = (baseProvider, options, app) => {
 
 			return assignTemplates(templates.createTable, {
 				name: tableData.fullName,
+				hybrid,
 				temporary,
 				transient,
 				tableIfNotExists,
@@ -579,6 +584,73 @@ module.exports = (baseProvider, options, app) => {
 			};
 		},
 
+		hydrateIndex(indexData, tableData, schemaData) {
+			const firstTab = head(tableData) ?? {};
+
+			if (!firstTab.hybrid) {
+				return;
+			}
+
+			const schemaName = getName(firstTab.isCaseSensitive, get(schemaData, 'schemaName'));
+			const databaseName = getName(firstTab.isCaseSensitive, get(schemaData, 'databaseName'));
+			const tableName = getName(firstTab.isCaseSensitive, firstTab.code || firstTab.collectionName);
+			const fullTableName = getFullName(databaseName, getFullName(schemaName, tableName));
+
+			return {
+				indxName: getName(firstTab.isCaseSensitive, indexData.indxName),
+				isTableCaseSensitive: firstTab.isCaseSensitive,
+				fullTableName,
+				indxKey: indexData?.indxKey?.map(key => ({
+					name: key.name,
+					isActivated: key.isActivated,
+				})),
+				indxIncludeKey: indexData?.indxIncludeKey?.map(key => ({
+					name: key.name,
+					isActivated: key.isActivated,
+				})),
+				isActivated: indexData?.isActivated,
+				ifNotExists: indexData?.ifNotExist,
+				orReplace: indexData?.orReplace,
+			};
+		},
+
+		createIndex(_tableName, index, dbData, isParentActivated = true) {
+			if (isEmpty(index.indxKey) || !index.indxName) {
+				return '';
+			}
+
+			const allDeactivated = checkAllKeysDeactivated(index.indxKey || []);
+			const wholeStatementCommented = index.isActivated === false || !isParentActivated || allDeactivated;
+
+			const includeKeys = prepareIndexKeys({
+				indexKeys: index.indxIncludeKey,
+				wholeStatementCommented,
+				isCaseSensitive: index.isTableCaseSensitive,
+				divideIntoActivatedAndDeactivated,
+			});
+			const includeKeysStatement = !includeKeys ? '' : preSpace(`INCLUDE ( ${includeKeys} )`);
+
+			const indexStatement = assignTemplates(templates.createIndex, {
+				name: index.indxName,
+				tableName: index.fullTableName,
+				orReplace: preSpace(index.orReplace && 'OR REPLACE'),
+				ifNotExists: preSpace(index.ifNotExists && 'IF NOT EXISTS'),
+				keys: prepareIndexKeys({
+					indexKeys: index.indxKey,
+					wholeStatementCommented,
+					isCaseSensitive: index.isTableCaseSensitive,
+					divideIntoActivatedAndDeactivated,
+				}),
+				includeKeys: includeKeysStatement,
+			});
+
+			if (wholeStatementCommented) {
+				return commentIfDeactivated(indexStatement, { isActivated: false });
+			} else {
+				return indexStatement;
+			}
+		},
+
 		createView(viewData, dbData, isActivated) {
 			return createView({
 				viewData,
@@ -840,6 +912,7 @@ module.exports = (baseProvider, options, app) => {
 				...tableData,
 				fullName,
 				name: tableName,
+				hybrid: firstTab.hybrid,
 				temporary: firstTab.temporary,
 				transient: firstTab.transient,
 				external: firstTab.external,

forward_engineering/helpers/commentHelpers/commentDeactivatedHelper.js

@@ -3,7 +3,7 @@ const STARTS_QUERY = ['//'];
 const commentIfDeactivated = (statement, data, isPartOfLine) => {
 	if (data.isActivated === false) {
 		if (isPartOfLine) {
-			return '// ' + statement;
+			return '/* ' + statement + ' */';
 		} else if (statement.includes('\n')) {
 			return statement
 				.split('\n')

forward_engineering/helpers/indexHelper.js

@@ -0,0 +1,33 @@
+const { commentIfDeactivated } = require('./commentHelpers/commentDeactivatedHelper');
+const { preSpace } = require('../utils/preSpace');
+const { getName } = require('./general');
+
+const prepareIndexKeys = ({
+	indexKeys,
+	wholeStatementCommented,
+	isCaseSensitive,
+	divideIntoActivatedAndDeactivated,
+}) => {
+	const dividedKeys = divideIntoActivatedAndDeactivated(indexKeys || [], key => getName(isCaseSensitive, key.name));
+	const commentedKeys = dividedKeys.deactivatedItems.length
+		? commentIfDeactivated(
+				dividedKeys.deactivatedItems.join(', '),
+				{
+					isActivated: wholeStatementCommented,
+					isPartOfLine: true,
+				},
+				true,
+			)
+		: '';
+
+	return (
+		dividedKeys.activatedItems.join(', ') +
+		(wholeStatementCommented && commentedKeys && dividedKeys.activatedItems.length
+			? ', ' + commentedKeys
+			: preSpace(commentedKeys))
+	);
+};
+
+module.exports = {
+	prepareIndexKeys,
+};