spark-sql-language-server 0.0.1-beta.6 → 0.2.0-beta.0

package/out-tsc/formatter/strategies/ddl/create-table.strategy.js

@@ -0,0 +1,659 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyListStrategy = exports.CreateTableStrategy = void 0;
+/**
+ * CREATE TABLE Strategy
+ *
+ * Handles formatting for CREATE TABLE, CREATE TABLE LIKE, and REPLACE TABLE statements.
+ */
+const SparkSQLParser_1 = require("../../../lib/SparkSQLParser");
+const core_1 = require("../../core");
+class CreateTableStrategy extends core_1.BaseFormattingStrategy {
+    constructor() {
+        super(...arguments);
+        this.id = 'ddl.createTable';
+    }
+    canHandle(ctx) {
+        // Don't handle TableElementListContext if it's part of a Pipeline statement
+        if (ctx instanceof SparkSQLParser_1.TableElementListContext) {
+            const parent = ctx.parent;
+            if (parent && parent.constructor.name === 'CreatePipelineDatasetContext') {
+                return false; // Let PipelineStrategy handle this
+            }
+        }
+        return (ctx instanceof SparkSQLParser_1.CreateTableContext ||
+            ctx instanceof SparkSQLParser_1.CreateTableLikeContext ||
+            ctx instanceof SparkSQLParser_1.CreateTableHeaderContext ||
+            ctx instanceof SparkSQLParser_1.CreateTableClausesContext ||
+            ctx instanceof SparkSQLParser_1.PartitionFieldListContext ||
+            ctx instanceof SparkSQLParser_1.TableProviderContext ||
+            ctx instanceof SparkSQLParser_1.TableElementListContext ||
+            ctx instanceof SparkSQLParser_1.ColDefinitionContext ||
+            ctx instanceof SparkSQLParser_1.ReplaceTableContext ||
+            ctx instanceof SparkSQLParser_1.ReplaceTableHeaderContext);
+    }
+    format(ctx, bridge) {
+        if (ctx instanceof SparkSQLParser_1.CreateTableContext) {
+            this.formatCreateTable(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.CreateTableLikeContext) {
+            this.formatCreateTableLike(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.CreateTableHeaderContext) {
+            this.formatCreateTableHeader(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.CreateTableClausesContext) {
+            this.formatCreateTableClauses(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.PartitionFieldListContext) {
+            this.formatPartitionFieldList(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.TableProviderContext) {
+            this.formatTableProvider(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.TableElementListContext) {
+            this.formatTableElementList(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.ColDefinitionContext) {
+            this.formatColDefinition(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.ReplaceTableContext) {
+            this.formatReplaceTable(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.ReplaceTableHeaderContext) {
+            this.formatReplaceTableHeader(ctx, bridge);
+        }
+    }
+    /**
+     * Format CREATE TABLE statement
+     * Hanging indent style:
+     * CREATE TABLE student (
+     *     id INT,
+     *     name STRING
+     *   )
+     *   USING CSV
+     *   PARTITIONED BY (...)
+     *   TBLPROPERTIES (...);
+     *
+     * Without columns:
+     * CREATE TABLE t
+     *   USING PARQUET
+     *   LOCATION '/path';
+     */
+    formatCreateTable(ctx, bridge) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen) {
+            // Space before left parenthesis (stays on same line as table name)
+            bridge.updateAfterPreviousTokenByNode(leftParen, ' ');
+        }
+        // Process tableElementList first (it will handle its own double indent)
+        const tableElementList = ctx.tableElementList();
+        const tableProvider = ctx.tableProvider();
+        const createTableClauses = ctx.createTableClauses();
+        const hasSubsequentClauses = tableProvider || createTableClauses;
+        if (tableElementList) {
+            // Add single indent base for right paren and subsequent clauses
+            bridge.addIndent();
+            bridge.visit(tableElementList);
+        }
+        else if (hasSubsequentClauses) {
+            // No columns but has USING/PARTITIONED BY etc., add indent for subsequent clauses
+            bridge.addIndent();
+        }
+        // After tableElementList, we're back to single indent
+        // Right parenthesis on new line with single indent
+        if (rightParen) {
+            bridge.updateAfterPreviousTokenByNode(rightParen, bridge.newlineIndent);
+        }
+        // Process subsequent clauses (USING, PARTITIONED BY, etc.) with same single indent
+        if (tableProvider) {
+            bridge.updateAfterPreviousTokenByContext(tableProvider, bridge.newlineIndent);
+            bridge.visit(tableProvider);
+        }
+        // Process createTableClauses (PARTITIONED BY, TBLPROPERTIES, etc.)
+        if (createTableClauses) {
+            bridge.visit(createTableClauses);
+        }
+        // Handle AS keyword for CTAS
+        const asNode = ctx.AS();
+        const query = ctx.query();
+        if (asNode && query) {
+            // Minus indent BEFORE visiting query so SELECT is at baseline
+            if (tableElementList || hasSubsequentClauses) {
+                bridge.minusIndent();
+            }
+            bridge.updateAfterPreviousTokenByNode(asNode, ' ');
+            bridge.updateBeforeNextTokenByNode(asNode, '\n');
+            bridge.visit(query);
+        }
+        else if (tableElementList || hasSubsequentClauses) {
+            // No AS query, just minus indent
+            bridge.minusIndent();
+        }
+    }
+    /**
+     * Format CREATE TABLE ... LIKE statement
+     * Target format:
+     * CREATE TABLE target_table
+     *   LIKE source_table
+     *   USING CSV
+     *   LOCATION '/path/to/data';
+     */
+    formatCreateTableLike(ctx, bridge) {
+        const createNode = ctx.CREATE();
+        const tableNode = ctx.TABLE();
+        // Single space between CREATE and TABLE
+        bridge.updateBeforeNextTokenByNode(createNode, ' ');
+        // Handle IF NOT EXISTS
+        const ifNode = ctx.IF();
+        const existsNode = ctx.EXISTS();
+        const errorCapturingNot = ctx.errorCapturingNot();
+        if (ifNode && existsNode && errorCapturingNot) {
+            bridge.updateAfterPreviousTokenByNode(ifNode, ' ');
+            bridge.updateBeforeNextTokenByNode(ifNode, ' ');
+            bridge.updateAfterPreviousTokenByContext(errorCapturingNot, ' ');
+            bridge.updateBeforeNextTokenByContext(errorCapturingNot, ' ');
+            bridge.updateAfterPreviousTokenByNode(existsNode, ' ');
+            bridge.updateBeforeNextTokenByNode(existsNode, ' ');
+        }
+        else {
+            bridge.updateBeforeNextTokenByNode(tableNode, ' ');
+        }
+        // LIKE keyword on same line as table name
+        const likeNode = ctx.LIKE();
+        if (likeNode) {
+            bridge.updateAfterPreviousTokenByNode(likeNode, ' ');
+            bridge.updateBeforeNextTokenByNode(likeNode, ' ');
+        }
+        // Add indent for subsequent clauses (USING, LOCATION, etc.)
+        bridge.addIndent();
+        // Format optional clauses on separate lines with 2-space indent
+        const tableProviders = ctx.tableProvider();
+        for (const provider of tableProviders) {
+            bridge.updateAfterPreviousTokenByContext(provider, bridge.newlineIndent);
+        }
+        const rowFormats = ctx.rowFormat();
+        for (const rf of rowFormats) {
+            bridge.updateAfterPreviousTokenByContext(rf, bridge.newlineIndent);
+        }
+        const fileFormats = ctx.createFileFormat();
+        for (const ff of fileFormats) {
+            bridge.updateAfterPreviousTokenByContext(ff, bridge.newlineIndent);
+        }
+        const locations = ctx.locationSpec();
+        for (const loc of locations) {
+            bridge.updateAfterPreviousTokenByContext(loc, bridge.newlineIndent);
+        }
+        const tblPropsNodes = ctx.TBLPROPERTIES();
+        for (let i = 0; i < tblPropsNodes.length; i++) {
+            bridge.updateAfterPreviousTokenByNode(tblPropsNodes[i], bridge.newlineIndent);
+            bridge.updateBeforeNextTokenByNode(tblPropsNodes[i], ' ');
+        }
+        bridge.visitChildren(ctx);
+        // Minus indent after processing
+        bridge.minusIndent();
+    }
+    /**
+     * Format CREATE TABLE header
+     * Format: CREATE TABLE IF NOT EXISTS table_name
+     */
+    formatCreateTableHeader(ctx, bridge) {
+        if (ctx.TEMPORARY()) {
+            bridge.updateAfterPreviousTokenByNode(ctx.TEMPORARY(), ' ');
+            bridge.updateBeforeNextTokenByNode(ctx.TEMPORARY(), ' ');
+        }
+        if (ctx.EXTERNAL()) {
+            bridge.updateAfterPreviousTokenByNode(ctx.EXTERNAL(), ' ');
+            bridge.updateBeforeNextTokenByNode(ctx.EXTERNAL(), ' ');
+        }
+        bridge.updateAfterPreviousTokenByNode(ctx.TABLE(), ' ');
+        bridge.updateBeforeNextTokenByNode(ctx.TABLE(), ' ');
+        if (ctx.IF()) {
+            bridge.updateAfterPreviousTokenByNode(ctx.IF(), ' ');
+            bridge.updateBeforeNextTokenByNode(ctx.IF(), ' ');
+        }
+        const errorCapturingNot = ctx.errorCapturingNot();
+        if (errorCapturingNot) {
+            bridge.updateAfterPreviousTokenByContext(errorCapturingNot, ' ');
+            bridge.updateBeforeNextTokenByContext(errorCapturingNot, ' ');
+        }
+        if (ctx.EXISTS()) {
+            bridge.updateAfterPreviousTokenByNode(ctx.EXISTS(), ' ');
+            bridge.updateBeforeNextTokenByNode(ctx.EXISTS(), ' ');
+        }
+        bridge.visitChildren(ctx);
+    }
+    /**
+     * Format CREATE TABLE clauses (OPTIONS, PARTITIONED BY, etc.)
+     */
+    formatCreateTableClauses(ctx, bridge) {
+        // IMPORTANT: First visit children (including partitionFieldList) to set right paren formatting
+        // Then set subsequent clause formatting (CLUSTERED BY, etc.) to avoid edit conflicts
+        bridge.visitChildren(ctx);
+        // Now set newline for subsequent clauses AFTER right paren
+        // OPTIONS clause
+        const optionsTokens = ctx.OPTIONS();
+        if (optionsTokens.length > 0) {
+            bridge.updateAfterPreviousTokenByNode(optionsTokens[0], bridge.newlineIndent);
+        }
+        // PARTITIONED BY clause
+        const partitionedTokens = ctx.PARTITIONED();
+        const byTokens = ctx.BY();
+        if (partitionedTokens.length > 0) {
+            bridge.updateAfterPreviousTokenByNode(partitionedTokens[0], bridge.newlineIndent);
+            if (byTokens.length > 0) {
+                bridge.updateBeforeNextTokenByNode(partitionedTokens[0], ' ');
+            }
+        }
+        // COMMENT clause
+        const comment = ctx.commentSpec();
+        if (comment.length > 0) {
+            bridge.updateAfterPreviousTokenByContext(comment[0], bridge.newlineIndent);
+        }
+        // CLUSTERED BY clause - set newline before CLUSTERED keyword
+        const clusteredBy = ctx.bucketSpec();
+        for (const bucket of clusteredBy) {
+            const clusteredNode = bucket.CLUSTERED();
+            if (clusteredNode) {
+                bridge.updateAfterPreviousTokenByNode(clusteredNode, bridge.newlineIndent);
+            }
+        }
+        // ROW FORMAT clause
+        const rowFormat = ctx.rowFormat();
+        if (rowFormat.length > 0) {
+            bridge.updateAfterPreviousTokenByContext(rowFormat[0], bridge.newlineIndent);
+        }
+        // STORED AS/BY clause
+        const createFileFormat = ctx.createFileFormat();
+        if (createFileFormat.length > 0) {
+            bridge.updateAfterPreviousTokenByContext(createFileFormat[0], bridge.newlineIndent);
+        }
+        // LOCATION clause
+        const location = ctx.locationSpec();
+        if (location.length > 0) {
+            bridge.updateAfterPreviousTokenByContext(location[0], bridge.newlineIndent);
+        }
+        // TBLPROPERTIES clause
+        const tblPropertiesTokens = ctx.TBLPROPERTIES();
+        if (tblPropertiesTokens.length > 0) {
+            bridge.updateAfterPreviousTokenByNode(tblPropertiesTokens[0], bridge.newlineIndent);
+        }
+    }
+    /**
+     * Format tableProvider: USING provider_name
+     */
+    formatTableProvider(ctx, bridge) {
+        const usingNode = ctx.USING();
+        if (usingNode) {
+            bridge.updateBeforeNextTokenByNode(usingNode, ' ');
+        }
+        bridge.visitChildren(ctx);
+    }
+    /**
+     * Format table element list (column definitions)
+     * Hanging indent style:
+     * CREATE TABLE t (
+     *     id INT,
+     *     name STRING
+     *   )
+     *   USING ...
+     *
+     * Note: Caller (formatCreateTable) already added single indent for right paren
+     * This method adds one more indent for content (total 4 spaces)
+     */
+    formatTableElementList(ctx, bridge) {
+        // Add one more indent for content (caller already has single indent)
+        // Total: 2 spaces from caller + 2 spaces from here = 4 spaces for content
+        bridge.addIndent();
+        // First column on new line with double indent
+        const elements = ctx.tableElement();
+        if (elements.length > 0) {
+            bridge.updateAfterPreviousTokenByContext(elements[0], bridge.newlineIndent);
+        }
+        // Format commas: each subsequent column on separate line
+        const commas = ctx.COMMA();
+        for (let i = 0; i < commas.length; i++) {
+            bridge.updateAfterPreviousTokenByNode(commas[i], '');
+            bridge.updateBeforeNextTokenByNode(commas[i], bridge.newlineIndent);
+        }
+        bridge.visitChildren(ctx);
+        // Minus indent for right parenthesis (back to single indent = 2 spaces)
+        // Right paren is handled by formatCreateTable
+        bridge.minusIndent();
+    }
+    /**
+     * Format partition field list (PARTITIONED BY columns)
+     * Hanging indent style:
+     * PARTITIONED BY (
+     *     dt STRING,
+     *     region STRING
+     *   )
+     */
+    formatPartitionFieldList(ctx, bridge) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        const fields = ctx.partitionField();
+        // Space before left parenthesis (on same line as PARTITIONED BY)
+        if (leftParen) {
+            bridge.updateAfterPreviousTokenByNode(leftParen, ' ');
+        }
+        // Add one more indent for fields (caller already has single indent)
+        bridge.addIndent();
+        // First field on new line with double indent
+        if (fields.length > 0) {
+            bridge.updateAfterPreviousTokenByContext(fields[0], bridge.newlineIndent);
+        }
+        // Format commas: each subsequent field on separate line
+        const commas = ctx.COMMA();
+        for (let i = 0; i < commas.length; i++) {
+            bridge.updateAfterPreviousTokenByNode(commas[i], '');
+            bridge.updateBeforeNextTokenByNode(commas[i], bridge.newlineIndent);
+        }
+        bridge.visitChildren(ctx);
+        // Minus indent for right parenthesis (back to single indent)
+        bridge.minusIndent();
+        // Right parenthesis on new line with single indent
+        // Set newline BEFORE right paren
+        // Note: Don't set content AFTER right paren here - let CLUSTERED BY handling do it
+        if (rightParen) {
+            bridge.updateAfterPreviousTokenByNode(rightParen, bridge.newlineIndent);
+        }
+    }
+    /**
+     * Format column definition
+     */
+    formatColDefinition(ctx, bridge) {
+        const colName = ctx.errorCapturingIdentifier();
+        if (colName) {
+            bridge.updateBeforeNextTokenByContext(colName, ' ');
+        }
+        bridge.visitChildren(ctx);
+    }
+    /**
+     * Format REPLACE TABLE statement
+     * Same format as CREATE TABLE:
+     * REPLACE TABLE table_name (
+     *   col1 INT,
+     *   col2 STRING
+     * )
+     * USING parquet
+     * AS SELECT ...;
+     */
+    formatReplaceTable(ctx, bridge) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen) {
+            // Space before left parenthesis (stays on same line as table name)
+            bridge.updateAfterPreviousTokenByNode(leftParen, ' ');
+        }
+        // Process tableElementList first (it will handle its own double indent)
+        const tableElementList = ctx.tableElementList();
+        if (tableElementList) {
+            // Add single indent base for right paren and subsequent clauses
+            bridge.addIndent();
+            bridge.visit(tableElementList);
+        }
+        // After tableElementList, we're back to single indent
+        // Right parenthesis on new line with single indent
+        if (rightParen) {
+            bridge.updateAfterPreviousTokenByNode(rightParen, bridge.newlineIndent);
+        }
+        // Process subsequent clauses (USING, etc.) with same single indent
+        const tableProvider = ctx.tableProvider();
+        if (tableProvider) {
+            bridge.updateAfterPreviousTokenByContext(tableProvider, bridge.newlineIndent);
+            bridge.visit(tableProvider);
+        }
+        // Handle AS keyword
+        const asNode = ctx.AS();
+        const query = ctx.query();
+        if (asNode && query) {
+            // Minus indent BEFORE visiting query so SELECT is at baseline
+            if (tableElementList) {
+                bridge.minusIndent();
+            }
+            bridge.updateAfterPreviousTokenByNode(asNode, ' ');
+            bridge.updateBeforeNextTokenByNode(asNode, '\n');
+            bridge.visit(query);
+        }
+        else if (tableElementList) {
+            // No AS query, just minus indent
+            bridge.minusIndent();
+        }
+    }
+    /**
+     * Format REPLACE TABLE header
+     * Format: CREATE OR REPLACE TABLE table_name
+     * Or: REPLACE TABLE table_name
+     */
+    formatReplaceTableHeader(ctx, bridge) {
+        const createNode = ctx.CREATE();
+        const orNode = ctx.OR();
+        const replaceNode = ctx.REPLACE();
+        const tableNode = ctx.TABLE();
+        // Format CREATE
+        if (createNode) {
+            bridge.updateBeforeNextTokenByNode(createNode, ' ');
+        }
+        // Format OR REPLACE
+        if (orNode) {
+            bridge.updateAfterPreviousTokenByNode(orNode, ' ');
+            bridge.updateBeforeNextTokenByNode(orNode, ' ');
+        }
+        // Format REPLACE TABLE
+        if (replaceNode) {
+            bridge.updateAfterPreviousTokenByNode(replaceNode, ' ');
+            bridge.updateBeforeNextTokenByNode(replaceNode, ' ');
+        }
+        if (tableNode) {
+            bridge.updateAfterPreviousTokenByNode(tableNode, ' ');
+        }
+        bridge.visitChildren(ctx);
+    }
+}
+exports.CreateTableStrategy = CreateTableStrategy;
+/**
+ * Property List Strategy
+ * Handles formatting for property lists in TBLPROPERTIES, OPTIONS, etc.
+ */
+class PropertyListStrategy extends core_1.BaseFormattingStrategy {
+    constructor() {
+        super(...arguments);
+        this.id = 'ddl.propertyList';
+    }
+    canHandle(ctx) {
+        // Don't handle PropertyList if it's part of a Pipeline statement
+        if (ctx instanceof SparkSQLParser_1.PropertyListContext || ctx instanceof SparkSQLParser_1.ExpressionPropertyListContext) {
+            const parent = ctx.parent;
+            // If parent is CreateTableClausesContext, check if its parent is CreatePipelineDatasetContext
+            if (parent && parent.constructor.name === 'CreateTableClausesContext') {
+                const grandParent = parent.parent;
+                if (grandParent && grandParent.constructor.name === 'CreatePipelineDatasetContext') {
+                    return false; // Let PipelineStrategy handle this
+                }
+            }
+            // Don't handle PropertyList if it's part of a CREATE INDEX statement
+            if (parent && parent.constructor.name === 'CreateIndexContext') {
+                return false; // Let DropStatementStrategy handle this
+            }
+        }
+        return (ctx instanceof SparkSQLParser_1.PropertyListContext ||
+            ctx instanceof SparkSQLParser_1.ExpressionPropertyListContext ||
+            ctx instanceof SparkSQLParser_1.PropertyWithKeyAndEqualsContext ||
+            ctx instanceof SparkSQLParser_1.ExpressionPropertyWithKeyAndEqualsContext);
+    }
+    format(ctx, bridge) {
+        if (ctx instanceof SparkSQLParser_1.PropertyListContext) {
+            this.formatPropertyList(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.ExpressionPropertyListContext) {
+            this.formatExpressionPropertyList(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.PropertyWithKeyAndEqualsContext) {
+            this.formatPropertyWithKeyAndEquals(ctx, bridge);
+        }
+        else if (ctx instanceof SparkSQLParser_1.ExpressionPropertyWithKeyAndEqualsContext) {
+            this.formatExpressionPropertyWithKeyAndEquals(ctx, bridge);
+        }
+    }
+    formatPropertyList(ctx, bridge) {
+        // Compact format for ALTER TABLE/NAMESPACE contexts
+        const parent = ctx.parent;
+        const useCompactFormat = this.shouldUseCompactFormat(parent);
+        const properties = ctx.property();
+        const isSingleProperty = properties.length === 1;
+        // Check if this is SET TBLPROPERTIES context
+        const isSetTableProperties = parent?.constructor?.name === 'SetTablePropertiesContext';
+        if (useCompactFormat) {
+            const leftParen = ctx.LEFT_PAREN();
+            const rightParen = ctx.RIGHT_PAREN();
+            if (leftParen) {
+                bridge.updateBeforeNextTokenByNode(leftParen, '');
+            }
+            if (rightParen) {
+                bridge.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                bridge.updateAfterPreviousTokenByNode(comma, '');
+                bridge.updateBeforeNextTokenByNode(comma, ' ');
+            }
+            bridge.visitChildren(ctx);
+            return;
+        }
+        // Hanging indent format for CREATE TABLE / SET TBLPROPERTIES contexts
+        // Single property: compact format
+        // Multi property: content 4 spaces indent, right paren 2 spaces indent
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (isSingleProperty) {
+            // Single property: compact format on same line
+            if (isSetTableProperties) {
+                // SET TBLPROPERTIES single: left paren on new line, compact content
+                if (leftParen) {
+                    bridge.updateAfterPreviousTokenByNode(leftParen, bridge.newlineIndent);
+                }
+                if (rightParen) {
+                    bridge.updateAfterPreviousTokenByNode(rightParen, '');
+                }
+            }
+            else {
+                // CREATE TABLE / other contexts
+                if (leftParen) {
+                    bridge.updateAfterPreviousTokenByNode(leftParen, ' ');
+                }
+                if (rightParen) {
+                    bridge.updateAfterPreviousTokenByNode(rightParen, '');
+                }
+            }
+        }
+        else {
+            // Multi property: hanging indent
+            if (isSetTableProperties) {
+                // SET TBLPROPERTIES multi: left paren on new line (caller already set indent)
+                if (leftParen) {
+                    bridge.updateAfterPreviousTokenByNode(leftParen, bridge.newlineIndent);
+                }
+                // Add one indent for content (total 4 spaces)
+                bridge.addIndent();
+                // First property on new line
+                if (properties.length > 0) {
+                    bridge.updateAfterPreviousTokenByContext(properties[0], bridge.newlineIndent);
+                }
+                const commas = ctx.COMMA();
+                for (const comma of commas) {
+                    bridge.updateAfterPreviousTokenByNode(comma, '');
+                    bridge.updateBeforeNextTokenByNode(comma, bridge.newlineIndent);
+                }
+                bridge.minusIndent();
+                // Right paren on new line with 2 spaces indent
+                if (rightParen) {
+                    bridge.updateAfterPreviousTokenByNode(rightParen, bridge.newlineIndent);
+                }
+            }
+            else {
+                // CREATE TABLE / other contexts
+                if (leftParen) {
+                    bridge.updateAfterPreviousTokenByNode(leftParen, ' ');
+                }
+                // Caller already has base indent (2 spaces)
+                // Add one indent for content (total 4 spaces)
+                bridge.addIndent();
+                if (properties.length > 0) {
+                    bridge.updateAfterPreviousTokenByContext(properties[0], bridge.newlineIndent);
+                }
+                const commas = ctx.COMMA();
+                for (const comma of commas) {
+                    bridge.updateAfterPreviousTokenByNode(comma, '');
+                    bridge.updateBeforeNextTokenByNode(comma, bridge.newlineIndent);
+                }
+                bridge.minusIndent();
+                // Right paren on new line with 2 spaces indent
+                if (rightParen) {
+                    bridge.updateAfterPreviousTokenByNode(rightParen, bridge.newlineIndent);
+                }
+            }
+        }
+        bridge.visitChildren(ctx);
+    }
+    formatExpressionPropertyList(ctx, bridge) {
+        const properties = ctx.expressionProperty();
+        const isSingleProperty = properties.length === 1;
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen) {
+            bridge.updateAfterPreviousTokenByNode(leftParen, ' ');
+        }
+        if (isSingleProperty) {
+            // Single property: compact format on same line
+            if (rightParen) {
+                bridge.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+        }
+        else {
+            // Multi property: hanging indent
+            bridge.addIndent();
+            if (properties.length > 0) {
+                bridge.updateAfterPreviousTokenByContext(properties[0], bridge.newlineIndent);
+            }
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                bridge.updateAfterPreviousTokenByNode(comma, '');
+                bridge.updateBeforeNextTokenByNode(comma, bridge.newlineIndent);
+            }
+            bridge.minusIndent();
+            if (rightParen) {
+                bridge.updateAfterPreviousTokenByNode(rightParen, bridge.newlineIndent);
+            }
+        }
+        bridge.visitChildren(ctx);
+    }
+    formatPropertyWithKeyAndEquals(ctx, bridge) {
+        const eqNode = ctx.EQ();
+        if (eqNode) {
+            bridge.updateAfterPreviousTokenByNode(eqNode, ' ');
+            bridge.updateBeforeNextTokenByNode(eqNode, ' ');
+        }
+        bridge.visitChildren(ctx);
+    }
+    formatExpressionPropertyWithKeyAndEquals(ctx, bridge) {
+        const eqNode = ctx.EQ();
+        if (eqNode) {
+            bridge.updateAfterPreviousTokenByNode(eqNode, ' ');
+            bridge.updateBeforeNextTokenByNode(eqNode, ' ');
+        }
+        bridge.visitChildren(ctx);
+    }
+    shouldUseCompactFormat(parent) {
+        // Check if parent is an ALTER TABLE/NAMESPACE context that uses compact format
+        // Note: SetTablePropertiesContext is NOT in this list - it uses hanging indent for multi-property
+        const className = parent?.constructor?.name;
+        return (className === 'SetTableSerDeContext' ||
+            className === 'UnsetTablePropertiesContext' ||
+            className === 'SetNamespacePropertiesContext' ||
+            className === 'UnsetNamespacePropertiesContext');
+    }
+}
+exports.PropertyListStrategy = PropertyListStrategy;
+//# sourceMappingURL=create-table.strategy.js.map