prettier-plugin-tsql 0.5.1 → 0.6.1

package/dist/printer/ddl.js

@@ -1,4 +1,4 @@
-import { keyword, hardline, join, indent, group, softline, line, ifExistsDoc, commentsBlock, parenList } from '@prettier-sql/core/printer/utils';
+import { keyword, hardline, join, indent, group, softline, line, ifExistsDoc, commentsBlock, parenList, } from '@prettier-sql/core/printer/utils';
 import { prop, propArr, propStr, propBool, schemaObjectName } from './helpers.js';
 // printNode / printBool / qexpr / printStatementWithComments are imported from statements.ts
 // — circular but safe in ESM (all imports are function references, never accessed during init)
@@ -6,6 +6,18 @@ import { printStatementWithComments, printNode, printBool, qexpr } from './state
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
+/**
+ * When ScriptDOM sees `AS BEGIN...END` it wraps the body in a single
+ * BeginEndBlockStatement. Unwrap that one outer block so that proc/function/
+ * trigger printers can emit their own BEGIN/END delimiters cleanly, while
+ * a *standalone* BEGIN...END statement still prints with its own delimiters.
+ */
+function unwrapBodyBlock(stmts) {
+    if (stmts.length === 1 && stmts[0]?.type === 'BeginEndBlock') {
+        return propArr(stmts[0], 'statements');
+    }
+    return stmts;
+}
 /** Render ` NULL` / ` NOT NULL` from a tristate `nullable` prop value. */
 function nullablePart(nullable, opts) {
     if (nullable === true)
@@ -33,22 +45,77 @@ function withOptionsClause(options, opts) {
 // ---------------------------------------------------------------------------
 // CREATE TABLE
 // ---------------------------------------------------------------------------
+/** Inline INDEX definition within CREATE TABLE body. */
+function printInlineIndex(node, opts) {
+    const indexName = propStr(node, 'indexName') ?? '';
+    const isUnique = node.props?.['unique'];
+    const kind = propStr(node, 'kind'); // 'clustered', 'nonclustered', etc.
+    const columns = propArr(node, 'columns');
+    const includeColumns = node.props?.['includeColumns'];
+    const filterPredicate = propStr(node, 'filterPredicate');
+    const indexOptions = node.props?.['indexOptions'];
+    const uniqueKw = isUnique ? [keyword('UNIQUE', opts), ' '] : '';
+    const kindKw = kind ? [keyword(kind.toUpperCase(), opts), ' '] : '';
+    const colDocs = columns.map((c) => {
+        const colName = propStr(c, 'name') ?? '';
+        const sort = propStr(c, 'sortOrder') ?? 'Ascending';
+        return sort === 'Descending' ? [colName, ' ', keyword('DESC', opts)] : [colName, ' ', keyword('ASC', opts)];
+    });
+    const includePart = includeColumns?.length
+        ? [' ', keyword('INCLUDE', opts), ' ', parenList(includeColumns)]
+        : '';
+    const filterPart = filterPredicate ? [' ', keyword('WHERE', opts), ' ', filterPredicate] : '';
+    const withPart = indexOptions?.length ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')'] : '';
+    return [
+        keyword('INDEX', opts),
+        ' ',
+        indexName,
+        ' ',
+        uniqueKw,
+        kindKw,
+        parenList(colDocs),
+        includePart,
+        filterPart,
+        withPart,
+    ];
+}
 export function printCreateTable(node, opts) {
     const columns = propArr(node, 'columns');
     const constraints = propArr(node, 'constraints');
     const options = node.props?.['options'];
+    const systemTimePeriod = node.props?.['systemTimePeriod'];
+    const indexes = propArr(node, 'indexes');
     const allDefs = [
         ...columns.map((col) => printColumnDef(col, opts)),
         ...constraints.map((c) => printConstraintDef(c, opts)),
+        ...indexes.map((idx) => printInlineIndex(idx, opts)),
     ];
-    const withPart = options && options.length > 0
-        ? [
-            hardline,
-            keyword('WITH', opts),
-            ' ',
-            parenList(options),
-        ]
-        : '';
+    // PERIOD FOR SYSTEM_TIME (ValidFrom, ValidTo) — always last in the table body
+    if (systemTimePeriod) {
+        allDefs.push([
+            keyword('PERIOD FOR SYSTEM_TIME', opts),
+            ' (',
+            systemTimePeriod.startColumn,
+            ', ',
+            systemTimePeriod.endColumn,
+            ')',
+        ]);
+    }
+    const withPart = options && options.length > 0 ? [hardline, keyword('WITH', opts), ' ', parenList(options)] : '';
+    const onFileGroup = propStr(node, 'onFileGroup');
+    const textimageOn = propStr(node, 'textimageOn');
+    const fileStreamOn = propStr(node, 'fileStreamOn');
+    const onPart = onFileGroup ? [hardline, keyword('ON', opts), ' ', onFileGroup] : '';
+    const textimagePart = textimageOn ? [hardline, keyword('TEXTIMAGE_ON', opts), ' ', textimageOn] : '';
+    const fileStreamPart = fileStreamOn ? [hardline, keyword('FILESTREAM_ON', opts), ' ', fileStreamOn] : '';
+    // Graph table types (AS NODE / AS EDGE)
+    const asNode = node.props?.['asNode'];
+    const asEdge = node.props?.['asEdge'];
+    const graphPart = asNode
+        ? [' ', keyword('AS NODE', opts)]
+        : asEdge
+            ? [' ', keyword('AS EDGE', opts)]
+            : '';
     return group([
         keyword('CREATE TABLE', opts),
         ' ',
@@ -57,16 +124,27 @@ export function printCreateTable(node, opts) {
         indent([hardline, join([',', hardline], allDefs)]),
         hardline,
         ')',
+        graphPart,
+        onPart,
+        fileStreamPart,
+        textimagePart,
         withPart,
         ';',
     ]);
 }
 export function printColumnDef(node, opts) {
+    // Raw leaf (e.g. ENCRYPTED WITH — property names vary across ScriptDOM versions).
+    // The C# AstBuilder emits `Leaf("ColumnDefinition", col, rawText)` which sets
+    // `node.text` to the original column fragment and leaves `node.props` undefined.
+    if (!node.props)
+        return node.text ?? '/* column */';
     const name = propStr(node, 'name') ?? 'col';
-    // Computed column: Name AS expression [PERSISTED]
+    // Computed column: Name AS expression [PERSISTED] [NOT NULL|NULL]
     const computedExpr = prop(node, 'computedExpression');
     if (computedExpr) {
         const isPersisted = node.props?.['isPersisted'];
+        // Computed PERSISTED columns may have an explicit nullability constraint
+        const computedNullPart = nullablePart(node.props?.['nullable'], opts);
         return [
             name,
             ' ',
@@ -74,28 +152,124 @@ export function printColumnDef(node, opts) {
             ' ',
             printNode(computedExpr, opts),
             isPersisted ? [' ', keyword('PERSISTED', opts)] : '',
+            computedNullPart,
         ];
     }
     const dataType = propStr(node, 'dataType') ?? 'INT';
     const params = node.props?.['dataTypeParams'];
+    const xmlSchemaCollection = propStr(node, 'xmlSchemaCollection');
+    const xmlTypeOption = propStr(node, 'xmlTypeOption');
     // Read nullable as a tristate (true/false/undefined) — propBool only returns true/false.
     const isNullable = node.props?.['nullable'];
     const isIdentity = propBool(node, 'identity');
     const identitySeed = propStr(node, 'identitySeed');
     const identityIncrement = propStr(node, 'identityIncrement');
     const defaultValue = prop(node, 'defaultValue');
-    const typeStr = Array.isArray(params) && params.length > 0
-        ? [keyword(dataType, opts), `(${params.join(', ')})`]
-        : keyword(dataType, opts);
+    const checkConstraint = prop(node, 'checkConstraint');
+    const collation = propStr(node, 'collation');
+    const typeStr = (() => {
+        const baseType = keyword(dataType, opts);
+        if (Array.isArray(params) && params.length > 0) {
+            return [baseType, `(${params.join(', ')})`];
+        }
+        if (xmlSchemaCollection) {
+            // xml(CONTENT|DOCUMENT schema_collection) — CONTENT/DOCUMENT are optional keywords
+            const prefix = xmlTypeOption ? `${keyword(xmlTypeOption, opts)} ` : '';
+            return [baseType, '(', prefix, xmlSchemaCollection, ')'];
+        }
+        return baseType;
+    })();
     const parts = [name, ' ', typeStr];
+    // COLLATE clause comes right after the data type
+    if (collation)
+        parts.push(' ', keyword('COLLATE', opts), ' ', collation);
     if (isIdentity) {
         const seed = identitySeed ?? '1';
         const inc = identityIncrement ?? '1';
         parts.push(' ', keyword('IDENTITY', opts), `(${seed}, ${inc})`);
+        if (node.props?.['identityNotForReplication'])
+            parts.push(' ', keyword('NOT FOR REPLICATION', opts));
+    }
+    if (node.props?.['isRowGuidCol'])
+        parts.push(' ', keyword('ROWGUIDCOL', opts));
+    // SPARSE / FILESTREAM / COLUMN_SET
+    if (node.props?.['isSparse'])
+        parts.push(' ', keyword('SPARSE', opts));
+    if (node.props?.['isFileStream'])
+        parts.push(' ', keyword('FILESTREAM', opts));
+    if (node.props?.['isColumnSet'])
+        parts.push(' ', keyword('COLUMN_SET FOR ALL_SPARSE_COLUMNS', opts));
+    // Temporal table: GENERATED ALWAYS AS ROW START / ROW END [HIDDEN]
+    const generatedAlways = propStr(node, 'generatedAlways');
+    if (generatedAlways) {
+        const gaMap = {
+            RowStart: 'ROW START',
+            RowEnd: 'ROW END',
+            UserIdStart: 'USER ID START',
+            UserIdEnd: 'USER ID END',
+            UserNameStart: 'USER NAME START',
+            UserNameEnd: 'USER NAME END',
+            TransactionIdStart: 'TRANSACTION ID START',
+            TransactionIdEnd: 'TRANSACTION ID END',
+            SequenceNumberStart: 'SEQUENCE NUMBER START',
+            SequenceNumberEnd: 'SEQUENCE NUMBER END',
+        };
+        const gaKw = gaMap[generatedAlways] ?? generatedAlways.toUpperCase();
+        parts.push(' ', keyword('GENERATED ALWAYS AS', opts), ' ', keyword(gaKw, opts));
+    }
+    if (node.props?.['isHidden'])
+        parts.push(' ', keyword('HIDDEN', opts));
+    // Dynamic data masking
+    if (node.props?.['isMasked']) {
+        const maskFn = propStr(node, 'maskingFunction') ?? 'default()';
+        parts.push(' ', keyword('MASKED WITH', opts), ' (', keyword('FUNCTION', opts), ` = '${maskFn}')`);
+    }
+    if (defaultValue) {
+        const defaultName = propStr(node, 'defaultConstraintName');
+        const defaultNamePrefix = defaultName ? [keyword('CONSTRAINT', opts), ' ', defaultName, ' '] : '';
+        parts.push(' ', defaultNamePrefix, keyword('DEFAULT', opts), ' ', printNode(defaultValue, opts));
     }
-    if (defaultValue)
-        parts.push(' ', keyword('DEFAULT', opts), ' ', printNode(defaultValue, opts));
     parts.push(nullablePart(isNullable, opts));
+    if (checkConstraint) {
+        const checkName = propStr(node, 'checkConstraintName');
+        const checkPrefix = checkName ? [keyword('CONSTRAINT', opts), ' ', checkName, ' '] : '';
+        parts.push(' ', checkPrefix, keyword('CHECK', opts), ' (', printBool(checkConstraint, opts), ')');
+    }
+    // Inline PRIMARY KEY / UNIQUE constraint (e.g. in table variable declarations)
+    const uniqueConstraint = node.props?.['uniqueConstraint'];
+    if (uniqueConstraint) {
+        const constraintNamePrefix = uniqueConstraint.constraintName
+            ? [keyword('CONSTRAINT', opts), ' ', uniqueConstraint.constraintName, ' ']
+            : '';
+        const uqKw = uniqueConstraint.isPrimaryKey ? keyword('PRIMARY KEY', opts) : keyword('UNIQUE', opts);
+        const clusteredKw = uniqueConstraint.clustered === true
+            ? [' ', keyword('CLUSTERED', opts)]
+            : uniqueConstraint.clustered === false
+                ? [' ', keyword('NONCLUSTERED', opts)]
+                : '';
+        parts.push(' ', constraintNamePrefix, uqKw, clusteredKw);
+    }
+    // Inline REFERENCES (column-level foreign key: col type [CONSTRAINT name] REFERENCES Table(col))
+    const foreignKey = node.props?.['foreignKey'];
+    if (foreignKey) {
+        if (foreignKey.constraintName) {
+            parts.push(' ', keyword('CONSTRAINT', opts), ' ', foreignKey.constraintName);
+        }
+        const refColsPart = foreignKey.refColumns?.length ? [' (', join(', ', foreignKey.refColumns), ')'] : '';
+        parts.push(' ', keyword('REFERENCES', opts), ' ', schemaObjectName(foreignKey.refTable), refColsPart);
+        if (foreignKey.deleteAction) {
+            parts.push(' ', keyword('ON DELETE', opts), ' ', keyword(foreignKey.deleteAction
+                .replace(/([A-Z])/g, ' $1')
+                .trim()
+                .toUpperCase(), opts));
+        }
+        if (foreignKey.updateAction) {
+            parts.push(' ', keyword('ON UPDATE', opts), ' ', keyword(foreignKey.updateAction
+                .replace(/([A-Z])/g, ' $1')
+                .trim()
+                .toUpperCase(), opts));
+        }
+    }
     return parts;
 }
 export function printConstraintDef(node, opts) {
@@ -104,14 +278,40 @@ export function printConstraintDef(node, opts) {
     switch (node.type) {
         case 'UniqueConstraint': {
             const isPK = propBool(node, 'isPrimaryKey');
-            const cols = Array.isArray(node.props?.['columns']) ? node.props?.['columns'] : [];
+            const clustered = node.props?.['clustered'];
+            // Only emit CLUSTERED/NONCLUSTERED when explicitly specified in DDL
+            const clusteredKw = clustered === true
+                ? [keyword('CLUSTERED', opts), ' ']
+                : clustered === false
+                    ? [keyword('NONCLUSTERED', opts), ' ']
+                    : '';
             const kw = isPK ? keyword('PRIMARY KEY', opts) : keyword('UNIQUE', opts);
-            const colsDoc = parenList(cols);
-            return group([namePrefix, indent([softline, kw, ' ', colsDoc])]);
+            // Columns are now {name, order} objects; fall back to plain strings for compat
+            const rawCols = Array.isArray(node.props?.['columns']) ? node.props['columns'] : [];
+            const colDocs = rawCols.map((c) => {
+                if (typeof c === 'string')
+                    return c;
+                const dir = c.order === 'Descending' ? [' ', keyword('DESC', opts)] : '';
+                return [c.name, dir];
+            });
+            const colsDoc = parenList(colDocs);
+            const indexOptions = node.props?.['indexOptions'];
+            const withPart = indexOptions?.length
+                ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
+                : '';
+            return group([namePrefix, indent([softline, kw, ' ', clusteredKw, colsDoc]), withPart]);
         }
         case 'CheckConstraint': {
             const expr = prop(node, 'expression');
-            return [namePrefix, keyword('CHECK', opts), ' (', expr ? printBool(expr, opts) : '', ')'];
+            const nfr = propBool(node, 'notForReplication');
+            return [
+                namePrefix,
+                keyword('CHECK', opts),
+                nfr ? [' ', keyword('NOT FOR REPLICATION', opts)] : '',
+                ' (',
+                expr ? printBool(expr, opts) : '',
+                ')',
+            ];
         }
         case 'ForeignKeyConstraint': {
             const cols = Array.isArray(node.props?.['columns']) ? node.props?.['columns'] : [];
@@ -120,6 +320,7 @@ export function printConstraintDef(node, opts) {
             const refName = refTable ? schemaObjectName(refTable) : '';
             const deleteAction = propStr(node, 'deleteAction');
             const updateAction = propStr(node, 'updateAction');
+            const nfr = propBool(node, 'notForReplication');
             const refActionKw = (action) => keyword(action
                 .replace(/([A-Z])/g, ' $1')
                 .trim()
@@ -139,6 +340,7 @@ export function printConstraintDef(node, opts) {
                         ]),
                         deleteAction ? [line, keyword('ON DELETE', opts), ' ', refActionKw(deleteAction)] : '',
                         updateAction ? [line, keyword('ON UPDATE', opts), ' ', refActionKw(updateAction)] : '',
+                        nfr ? [line, keyword('NOT FOR REPLICATION', opts)] : '',
                     ]),
                 ]),
             ];
@@ -179,6 +381,11 @@ export function printAlterTable(node, opts) {
                 join([',', line], elements.map((e) => e.name)),
             ]),
         ]);
+        // WITH (ONLINE = ON, WAIT_AT_LOW_PRIORITY ...) on DROP CLUSTERED CONSTRAINT
+        const allDropOptions = elements.flatMap((e) => e.dropOptions ?? []);
+        const withPart = allDropOptions.length
+            ? [' ', keyword('WITH', opts), ' (', join(', ', allDropOptions), ')']
+            : '';
         return [
             keyword('ALTER TABLE', opts),
             ' ',
@@ -188,6 +395,7 @@ export function printAlterTable(node, opts) {
             ifExists ? [' ', keyword('IF EXISTS', opts)] : '',
             ' ',
             nameList,
+            withPart,
             ';',
         ];
     }
@@ -213,7 +421,49 @@ export function printAlterTable(node, opts) {
     }
     if (alterType === 'AlterTableAlterColumnStatement') {
         const column = propStr(node, 'column') ?? '';
+        const alterColumnOption = propStr(node, 'alterColumnOption');
+        const maskingFunction = propStr(node, 'maskingFunction');
+        // ADD/DROP modifier variants (no data type change, just add/remove a column property)
+        if (alterColumnOption) {
+            let optDoc;
+            if (alterColumnOption === 'AddMaskingFunction') {
+                // ALTER COLUMN col ADD MASKED WITH (FUNCTION = 'fn()')
+                const fn = maskingFunction ?? 'default()';
+                optDoc = [keyword('ADD MASKED WITH', opts), ' (', keyword('FUNCTION', opts), ` = '${fn}')`];
+            }
+            else {
+                const optMap = {
+                    DropMaskingFunction: 'DROP MASKED',
+                    AddSparse: 'ADD SPARSE',
+                    DropSparse: 'DROP SPARSE',
+                    AddRowGuidCol: 'ADD ROWGUIDCOL',
+                    DropRowGuidCol: 'DROP ROWGUIDCOL',
+                    AddHidden: 'ADD HIDDEN',
+                    DropHidden: 'DROP HIDDEN',
+                    AddPersisted: 'ADD PERSISTED',
+                    DropPersisted: 'DROP PERSISTED',
+                };
+                optDoc = keyword(optMap[alterColumnOption] ?? alterColumnOption.toUpperCase(), opts);
+            }
+            return [
+                keyword('ALTER TABLE', opts),
+                ' ',
+                name,
+                hardline,
+                keyword('ALTER COLUMN', opts),
+                ' ',
+                column,
+                ' ',
+                optDoc,
+                ';',
+            ];
+        }
+        // Normal type-change: ALTER COLUMN col newtype [COLLATE ...] [NULL|NOT NULL]
         const dataType = propStr(node, 'dataType') ?? '';
+        const collationAC = propStr(node, 'collation');
+        const collatePart = collationAC
+            ? [' ', keyword('COLLATE', opts), ' ', collationAC]
+            : '';
         const nullPart = nullablePart(node.props?.['nullable'], opts);
         return [
             keyword('ALTER TABLE', opts),
@@ -225,18 +475,16 @@ export function printAlterTable(node, opts) {
             column,
             ' ',
             keyword(dataType, opts),
+            collatePart,
             nullPart,
             ';',
         ];
     }
     if (alterType === 'AlterTableSetStatement') {
-        // Convert camelCase enum names to SQL_KEYWORD style: LockEscalation → LOCK_ESCALATION
-        const toSqlKw = (s) => s
-            .replace(/([A-Z])/g, '_$1')
-            .replace(/^_/, '')
-            .toUpperCase();
+        // Options come pre-serialized from SerializeTableOption (e.g. "lock_escalation = table",
+        // "system_versioning = on (history_table = dbo.Tbl)"). Render them verbatim — applying
+        // keyword() casing would uppercase embedded schema/table names.
         const options = (node.props?.['options'] ?? []);
-        const optDocs = options.map((o) => [keyword(toSqlKw(o.kind), opts), ' = ', keyword(toSqlKw(o.value), opts)]);
         return [
             keyword('ALTER TABLE', opts),
             ' ',
@@ -244,7 +492,7 @@ export function printAlterTable(node, opts) {
             hardline,
             keyword('SET', opts),
             ' (',
-            join(', ', optDocs),
+            join(', ', options),
             ')',
             ';',
         ];
@@ -273,9 +521,13 @@ export function printAlterTable(node, opts) {
         const sourcePartition = propStr(node, 'sourcePartition');
         const targetTable = prop(node, 'targetTable');
         const targetPartition = propStr(node, 'targetPartition');
+        const switchOptions = node.props?.['switchOptions'];
         const sourceDoc = sourcePartition ? [' ', keyword('PARTITION', opts), ' ', sourcePartition] : '';
         const targetDoc = targetTable ? schemaObjectName(targetTable) : '';
         const targetPartDoc = targetPartition ? [' ', keyword('PARTITION', opts), ' ', targetPartition] : '';
+        const switchOptDoc = switchOptions?.length
+            ? [' ', keyword('WITH', opts), ' (', join(', ', switchOptions), ')']
+            : '';
         return [
             keyword('ALTER TABLE', opts),
             ' ',
@@ -288,9 +540,18 @@ export function printAlterTable(node, opts) {
             ' ',
             targetDoc,
             targetPartDoc,
+            switchOptDoc,
             ';',
         ];
     }
+    if (alterType === 'AlterTableTriggerModificationStatement') {
+        const enable = propBool(node, 'enable');
+        const triggerAll = node.props?.['triggerAll'];
+        const triggerNames = node.props?.['triggerNames'];
+        const verb = enable ? keyword('ENABLE TRIGGER', opts) : keyword('DISABLE TRIGGER', opts);
+        const targets = triggerAll ? keyword('ALL', opts) : join(', ', triggerNames ?? []);
+        return [keyword('ALTER TABLE', opts), ' ', name, hardline, verb, ' ', targets, ';'];
+    }
     return [keyword('ALTER TABLE', opts), ' ', name, ' /* ', alterType, ' */;'];
 }
 // ---------------------------------------------------------------------------
@@ -299,10 +560,10 @@ export function printAlterTable(node, opts) {
 export function printCreateIndex(node, opts) {
     const indexName = propStr(node, 'indexName') ?? 'idx';
     const isUnique = propBool(node, 'unique');
-    const isClustered = propBool(node, 'clustered');
     const table = prop(node, 'table');
     const columns = propArr(node, 'columns');
     const includeColumns = node.props?.['includeColumns'];
+    const filterPredicate = propStr(node, 'filterPredicate');
     const colDocs = columns.map((c) => {
         const colName = propStr(c, 'name') ?? c.text ?? '';
         const sort = propStr(c, 'sortOrder') ?? 'Ascending';
@@ -310,8 +571,14 @@ export function printCreateIndex(node, opts) {
             ? [colName, ' ', keyword('DESC', opts)]
             : [colName, ' ', keyword('ASC', opts)];
     });
-    const uniqueKw = isUnique ? keyword('UNIQUE ', opts) : '';
-    const clusteredKw = isClustered ? keyword('CLUSTERED ', opts) : keyword('NONCLUSTERED ', opts);
+    const uniqueKw = isUnique ? [keyword('UNIQUE', opts), ' '] : '';
+    // Preserve CLUSTERED / NONCLUSTERED exactly as written; omit when not specified.
+    const clusteredProp = node.props?.['clustered'];
+    const clusteredKw = clusteredProp === true
+        ? [keyword('CLUSTERED', opts), ' ']
+        : clusteredProp === false
+            ? [keyword('NONCLUSTERED', opts), ' ']
+            : '';
     const onClause = [
         keyword('ON', opts),
         ' ',
@@ -322,21 +589,26 @@ export function printCreateIndex(node, opts) {
         ')',
     ];
     const includePart = Array.isArray(includeColumns) && includeColumns.length > 0
-        ? [
-            hardline,
-            keyword('INCLUDE', opts),
-            ' ',
-            parenList(includeColumns),
-        ]
+        ? [hardline, keyword('INCLUDE', opts), ' ', parenList(includeColumns)]
         : '';
+    const filterPart = filterPredicate ? [hardline, keyword('WHERE', opts), ' ', filterPredicate] : '';
+    const indexOptions = node.props?.['indexOptions'];
+    const withPart = indexOptions && indexOptions.length > 0
+        ? [hardline, keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
+        : '';
+    const onFileGroup = propStr(node, 'onFileGroup');
+    const fileGroupPart = onFileGroup ? [hardline, keyword('ON', opts), ' ', onFileGroup] : '';
     return group([
-        keyword('CREATE ', opts),
+        keyword('CREATE', opts),
+        ' ',
         uniqueKw,
         clusteredKw,
         keyword('INDEX', opts),
         ' ',
         indexName,
-        indent([hardline, onClause, includePart]),
+        indent([hardline, onClause, includePart, filterPart]),
+        withPart,
+        fileGroupPart,
         ';',
     ]);
 }
@@ -354,6 +626,12 @@ export function printAlterIndex(node, opts) {
         Set: 'SET',
     };
     const typeKw = keyword(typeKwMap[alterType] ?? alterType.toUpperCase(), opts);
+    const indexOptions = node.props?.['indexOptions'];
+    const partition = propStr(node, 'partition');
+    const withPart = indexOptions && indexOptions.length > 0
+        ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
+        : '';
+    const partitionPart = partition ? [' ', keyword('PARTITION', opts), ' = ', partition] : '';
     return [
         keyword('ALTER INDEX', opts),
         ' ',
@@ -364,6 +642,8 @@ export function printAlterIndex(node, opts) {
         schemaObjectName(table),
         ' ',
         typeKw,
+        partitionPart,
+        withPart,
         ';',
     ];
 }
@@ -410,10 +690,13 @@ export function printCreateProcedure(node, opts) {
     const paramDocs = parameters.map((p) => {
         const pName = propStr(p, 'name') ?? '@p';
         const dt = propStr(p, 'dataType') ?? 'INT';
+        const isUdt = propBool(p, 'isUdt');
         const isOutput = propBool(p, 'output');
         const isReadonly = propBool(p, 'readonly');
         const defaultVal = prop(p, 'defaultValue');
-        const parts = [pName, ' ', keyword(dt, opts)];
+        // UDT names are identifiers, not SQL keywords — skip keyword-casing
+        const dtDoc = isUdt ? dt : keyword(dt, opts);
+        const parts = [pName, ' ', dtDoc];
         if (defaultVal)
             parts.push(' = ', printNode(defaultVal, opts));
         if (isOutput)
@@ -422,7 +705,11 @@ export function printCreateProcedure(node, opts) {
             parts.push(' ', keyword('READONLY', opts));
         return parts;
     });
-    const bodyDocs = body.map((s) => printStatementWithComments(s, opts));
+    // Natively compiled procs have a single BEGIN ATOMIC WITH (...) body statement.
+    const atomicBlock = body.length === 1 && body[0].type === 'BeginEndAtomicBlock' ? body[0] : null;
+    const atomicOptions = atomicBlock?.props?.['atomicOptions'];
+    const innerBody = atomicBlock ? propArr(atomicBlock, 'statements') : unwrapBodyBlock(body);
+    const bodyDocs = innerBody.map((s) => printStatementWithComments(s, opts));
     const preBody = commentsBlock(node.preBodyComments);
     const postParam = commentsBlock(node.postParamComments);
     const procKw = node.type === 'CreateOrAlterProcedureStatement'
@@ -430,6 +717,26 @@ export function printCreateProcedure(node, opts) {
         : node.type === 'AlterProcedureStatement'
             ? keyword('ALTER PROCEDURE', opts)
             : keyword('CREATE PROCEDURE', opts);
+    // CLR stored procedure: AS EXTERNAL NAME assembly.[class].method
+    const externalName = propStr(node, 'externalName');
+    if (externalName) {
+        return group([
+            procKw,
+            ' ',
+            schemaObjectName(prop(node, 'name')),
+            preBody,
+            parameters.length > 0 ? indent([hardline, join([',', hardline], paramDocs)]) : '',
+            postParam,
+            printModuleOptions(node, opts),
+            hardline,
+            keyword('AS', opts),
+            ' ',
+            keyword('EXTERNAL NAME', opts),
+            ' ',
+            externalName,
+            ';',
+        ]);
+    }
     return group([
         procKw,
         ' ',
@@ -441,7 +748,19 @@ export function printCreateProcedure(node, opts) {
         hardline,
         keyword('AS', opts),
         hardline,
-        keyword('BEGIN', opts),
+        ...(atomicOptions?.length
+            ? [
+                keyword('BEGIN', opts),
+                ' ',
+                keyword('ATOMIC', opts),
+                ' ',
+                keyword('WITH', opts),
+                ' (',
+                indent([hardline, join([',', hardline], atomicOptions)]),
+                hardline,
+                ')',
+            ]
+            : [keyword('BEGIN', opts)]),
         indent([hardline, join([hardline, hardline], bodyDocs)]),
         hardline,
         keyword('END', opts),
@@ -459,7 +778,9 @@ export function printCreateFunction(node, opts) {
     const paramDocs = parameters.map((p) => {
         const pName = propStr(p, 'name') ?? '@p';
         const dt = propStr(p, 'dataType') ?? 'INT';
-        return [pName, ' ', keyword(dt, opts)];
+        const isUdt = propBool(p, 'isUdt');
+        // UDT names are identifiers — skip keyword-casing
+        return [pName, ' ', isUdt ? dt : keyword(dt, opts)];
     });
     const preBody = commentsBlock(node.preBodyComments);
     const postParam = commentsBlock(node.postParamComments);
@@ -468,25 +789,43 @@ export function printCreateFunction(node, opts) {
         : node.type === 'AlterFunctionStatement'
             ? keyword('ALTER FUNCTION', opts)
             : keyword('CREATE FUNCTION', opts);
-    const nameAndParams = [
+    const nameAndParamsNoOpts = [
         fnKw,
         ' ',
         schemaObjectName(prop(node, 'name')),
         preBody,
         group(['(', parameters.length > 0 ? [indent([softline, join([',', line], paramDocs)]), softline] : '', ')']),
         postParam,
-        printModuleOptions(node, opts),
     ];
+    // CLR function: EXTERNAL NAME assembly.[class].method (no body)
+    const externalName = propStr(node, 'externalName');
+    if (externalName) {
+        return [
+            nameAndParamsNoOpts,
+            hardline,
+            keyword('RETURNS', opts),
+            ' ',
+            keyword(returnType, opts),
+            printModuleOptions(node, opts),
+            hardline,
+            keyword('AS', opts),
+            ' ',
+            keyword('EXTERNAL NAME', opts),
+            ' ',
+            externalName,
+            ';',
+        ];
+    }
     if (bodyType === 'table') {
-        // Inline TVF: RETURNS TABLE AS RETURN (query) — no BEGIN/END
-        // returnType raw text contains the SELECT, not the word TABLE — hardcode TABLE
+        // Inline TVF: RETURNS TABLE [WITH options] AS RETURN (query) — no BEGIN/END
         const queryDoc = body && !Array.isArray(body) ? qexpr(body, opts) : '/* query */';
         return [
-            nameAndParams,
-            ' ',
+            nameAndParamsNoOpts,
+            hardline,
             keyword('RETURNS', opts),
             ' ',
             keyword('TABLE', opts),
+            printModuleOptions(node, opts),
             hardline,
             keyword('AS', opts),
             hardline,
@@ -499,7 +838,7 @@ export function printCreateFunction(node, opts) {
         ];
     }
     // Scalar or multi-statement TVF — both use BEGIN...END
-    const stmts = Array.isArray(body) ? body.map((s) => printStatementWithComments(s, opts)) : [];
+    const stmts = Array.isArray(body) ? unwrapBodyBlock(body).map((s) => printStatementWithComments(s, opts)) : [];
     const bodyDoc = join([hardline, hardline], stmts);
     let retTypePart;
     if (bodyType === 'inline-table') {
@@ -519,12 +858,15 @@ export function printCreateFunction(node, opts) {
     else {
         retTypePart = keyword(returnType, opts);
     }
+    // WITH options come AFTER RETURNS (per T-SQL syntax):
+    // CREATE FUNCTION ... (params) RETURNS type WITH options AS BEGIN ... END
     return [
-        nameAndParams,
-        ' ',
+        nameAndParamsNoOpts,
+        hardline,
         keyword('RETURNS', opts),
         ' ',
         retTypePart,
+        printModuleOptions(node, opts),
         hardline,
         keyword('AS', opts),
         hardline,
@@ -547,9 +889,7 @@ export function printCreateView(node, opts) {
         : node.type === 'AlterViewStatement'
             ? keyword('ALTER VIEW', opts)
             : keyword('CREATE VIEW', opts);
-    const colsPart = columns?.length
-        ? [' ', parenList(columns)]
-        : '';
+    const colsPart = columns?.length ? [' ', parenList(columns)] : '';
     const withPart = withOptions?.length
         ? [
             hardline,
@@ -559,6 +899,8 @@ export function printCreateView(node, opts) {
         ]
         : '';
     const preBodyPart = commentsBlock(node.preBodyComments);
+    const withCheckOption = node.props?.['withCheckOption'];
+    const checkOptionPart = withCheckOption ? [hardline, keyword('WITH CHECK OPTION', opts)] : '';
     return group([
         kw,
         ' ',
@@ -570,6 +912,7 @@ export function printCreateView(node, opts) {
         keyword('AS', opts),
         hardline,
         body ? qexpr(body, opts) : '',
+        checkOptionPart,
         ';',
     ]);
 }
@@ -589,7 +932,15 @@ export function printCreateTrigger(node, opts) {
     const actionList = Array.isArray(actions)
         ? join(', ', actions.map((a) => keyword(a.toUpperCase(), opts)))
         : '';
-    const bodyDocs = propArr(node, 'body').map((s) => printStatementWithComments(s, opts));
+    const notForReplication = propBool(node, 'notForReplication');
+    const notForReplicationDoc = notForReplication ? [hardline, keyword('NOT FOR REPLICATION', opts)] : '';
+    const bodyDocs = unwrapBodyBlock(propArr(node, 'body')).map((s) => printStatementWithComments(s, opts));
+    const triggerScope = propStr(node, 'triggerScope'); // 'Database' or 'Server' for DDL triggers
+    const onTarget = triggerScope === 'Database'
+        ? keyword('DATABASE', opts)
+        : triggerScope === 'Server'
+            ? keyword('ALL SERVER', opts)
+            : schemaObjectName(prop(node, 'onName'));
     return [
         kw,
         ' ',
@@ -597,11 +948,12 @@ export function printCreateTrigger(node, opts) {
         hardline,
         keyword('ON', opts),
         ' ',
-        schemaObjectName(prop(node, 'onName')),
+        onTarget,
         hardline,
         typeKw,
         ' ',
         actionList,
+        notForReplicationDoc,
         hardline,
         keyword('AS', opts),
         hardline,
@@ -749,9 +1101,14 @@ export function printDropObjects(objType, node, opts) {
     ];
 }
 export function printDropIndex(node, opts) {
+    const ifExists = propBool(node, 'ifExists');
     const indices = propArr(node, 'indices');
     const indexDocs = indices.map((idx) => [propStr(idx, 'name') ?? '', ' ', keyword('ON', opts), ' ', schemaObjectName(prop(idx, 'table'))]);
-    return group([keyword('DROP INDEX', opts), ' ', join([',', hardline], indexDocs), ';']);
+    const ifExistsPart = ifExists ? [' ', keyword('IF EXISTS', opts)] : '';
+    if (indexDocs.length === 1) {
+        return [keyword('DROP INDEX', opts), ifExistsPart, ' ', indexDocs[0], ';'];
+    }
+    return [keyword('DROP INDEX', opts), ifExistsPart, indent([hardline, join([',', hardline], indexDocs)]), ';'];
 }
 // ---------------------------------------------------------------------------
 // CREATE / DROP SYNONYM
@@ -964,7 +1321,10 @@ export function printUpdateStatistics(node, opts) {
     const subElements = node.props?.['subElements'];
     const options = node.props?.['options'];
     const parts = [keyword('UPDATE STATISTICS', opts), ' ', table ? schemaObjectName(table) : ''];
-    if (subElements?.length)
+    // Single stat name: no parens needed. Multiple: wrap in parens.
+    if (subElements?.length === 1)
+        parts.push([' ', subElements[0]]);
+    else if (subElements?.length)
         parts.push([' ', parenList(subElements)]);
     if (options?.length)
         parts.push([hardline, withOptionsClause(options, opts)]);