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

package/out-tsc/visitors/space-replacer-format.visitor.d.ts

@@ -0,0 +1,1641 @@
+import { CommonTokenStream } from 'antlr4ts';
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree';
+import { TextEdit } from 'vscode-languageserver-textdocument';
+import { MultiInsertQueryContext, MultiInsertQueryBodyContext, QueryPrimaryContext, RelationPrimaryContext, AnalyzeContext, AnalyzeTablesContext, AddTableColumnsContext, AddTablePartitionContext, AggregationClauseContext, AliasedQueryContext, AlterColumnActionContext, AlterTableAlterColumnContext, AlterViewQueryContext, ArithmeticBinaryContext, BucketSpecContext, CacheTableContext, CallContext, CastContext, ClearCacheContext, ColDefinitionContext, CommentSpecContext, ColDefinitionDescriptorWithPositionContext, ColTypeContext, ColTypeListContext, ComparisonContext, ComplexColTypeContext, ComplexColTypeListContext, ComplexDataTypeContext, CreateTableClausesContext, CreateNamespaceContext, CreateFileFormatContext, CreateFunctionContext, CreateIndexContext, CreateTableContext, CreateTableLikeContext, CreateTableHeaderContext, CreateViewContext, CreateMetricViewContext, CreateTempViewUsingContext, CtesContext, DeleteFromTableContext, DereferenceContext, MergeIntoTableContext, MatchedClauseContext, NotMatchedClauseContext, NotMatchedBySourceClauseContext, DropFunctionContext, DropNamespaceContext, DropTableColumnsContext, DropTableContext, DropTablePartitionsContext, DropViewContext, ExistsContext, ExplainContext, ExpressionPropertyListContext, ExpressionPropertyWithKeyAndEqualsContext, FromClauseContext, FromStatementBodyContext, FrameBoundContext, FunctionCallContext, GroupingAnalyticsContext, GroupingSetContext, HavingClauseContext, HiveChangeColumnContext, HiveReplaceColumnsContext, IdentifierCommentContext, IdentifierCommentListContext, IdentifierListContext, IdentifierSeqContext, InlineTableContext, InsertIntoTableContext, InsertOverwriteTableContext, JoinCriteriaContext, JoinRelationContext, JoinTypeContext, LateralViewContext, LoadDataContext, LocationSpecContext, LogicalBinaryContext, LogicalNotContext, MultipartIdentifierListContext, NonTrivialPrimitiveTypeContext, NamedExpressionContext, OperatorPipeStatementContext, OperatorPipeRightSideContext, OperatorPipeSetAssignmentSeqContext, PrimitiveTypeContext, NamedExpressionSeqContext, NamedQueryContext, NamedWindowContext, OrderedIdentifierContext, OrderedIdentifierListContext, ParenthesizedExpressionContext, PartitionFieldListContext, PartitionSpecContext, PartitionValContext, PredicateContext, ProgramContext, PropertyListContext, PropertyWithKeyAndEqualsContext, QueryContext, QualifiedColTypeWithPositionContext, QualifiedColTypeWithPositionListContext, QueryOrganizationContext, RecoverPartitionsContext, RefreshFunctionContext, RefreshTableContext, RegularQuerySpecificationContext, RenameTableColumnContext, RenameTableContext, RenameTablePartitionContext, RepairTableContext, ResourceContext, RowConstructorContext, RowFormatSerdeContext, RowFormatDelimitedContext, SearchedCaseContext, SelectClauseContext, SetClauseContext, SetNamespaceCollationContext, SetNamespaceLocationContext, SetNamespacePropertiesContext, SetOperationContext, SetQuantifierContext, SetTableLocationContext, SetTablePropertiesContext, SetTableSerDeContext, SimpleCaseContext, SingleInsertQueryContext, SortItemContext, StarContext, StatementEndContext, StatementsContext, SubqueryContext, SubqueryExpressionContext, TableAliasContext, TableContext, TableElementListContext, TableFileFormatContext, TableNameContext, TableProviderContext, TrimContext, TruncateTableContext, UncacheTableContext, UnsetNamespacePropertiesContext, UnsetTablePropertiesContext, UpdateTableContext, WhenClauseContext, WhereClauseContext, WindowClauseContext, WindowDefContext, WindowFrameContext, ExecuteImmediateContext, ExceptClauseContext, CommentNamespaceContext, CommentTableContext, DescribeQueryContext, DescribeRelationContext, DescribeNamespaceContext, DescribeProcedureContext, DescribeFunctionContext, PivotClauseContext, UnpivotClauseContext, UnpivotNullClauseContext, UnpivotSingleValueColumnClauseContext, UnpivotMultiValueColumnClauseContext, UnpivotColumnSetContext, Any_valueContext, FirstContext, LastContext, TimestampaddContext, TimestampdiffContext, PositionContext, StructContext, SampleContext, SampleByPercentileContext, CollateContext, CollateClauseContext, IntervalValueContext, UseContext, UseNamespaceContext, SetCatalogContext, ShowNamespacesContext, ShowTablesContext, ShowTableExtendedContext, ShowTblPropertiesContext, ShowColumnsContext, ShowViewsContext, ShowPartitionsContext, ShowFunctionsContext, ShowProceduresContext, ShowCreateTableContext, ShowCurrentNamespaceContext, ShowCatalogsContext, SetTimeZoneContext, SetVariableContext, SetQuotedConfigurationContext, SetConfigurationContext, ResetQuotedConfigurationContext, ResetConfigurationContext, ReplaceTableContext, CreateUserDefinedFunctionContext, CreateVariableContext, DropVariableContext, AlterClusterByContext, AlterTableCollationContext, AddTableConstraintContext, DropTableConstraintContext, AlterViewSchemaBindingContext, CreatePipelineDatasetContext, CreatePipelineInsertIntoFlowContext, CreatePipelineDatasetHeaderContext, CreatePipelineFlowHeaderContext, DropIndexContext, RefreshResourceContext, ManageResourceContext } from '../lib/SparkSQLParser';
+import { SparkSQLParserVisitor } from '../lib/SparkSQLParserVisitor';
+import { SparkSQLFormattingOptions, FormattingError } from '../typings';
+/**
+ * Transverse parse tree and replace spaces between terminalNodes or contexts with
+ * formatted strings of whitespaces/newlines.
+ */
+export declare class SpaceReplacerFormatVisitor extends AbstractParseTreeVisitor<void> implements SparkSQLParserVisitor<void> {
+    private tokens;
+    private config;
+    textEdits: TextEdit[];
+    formattingErrors: FormattingError[];
+    private editKeys;
+    private indentNumber;
+    private indentString;
+    private readonly newline;
+    private readonly maxParenthesisLength;
+    private readonly newlineRegex;
+    private inPipeOperatorRightSide;
+    private inPipeSubquery;
+    private inWindowClause;
+    private readonly pipeStepClassifier;
+    private readonly pipeSelectStrategy;
+    private readonly pipeWhereStrategy;
+    private readonly pipeSetStrategy;
+    private readonly pipeDropStrategy;
+    private readonly pipeExtendStrategy;
+    private readonly blockStrategy;
+    private readonly listStrategy;
+    private readonly clauseHeadBodyStrategy;
+    private readonly joinStrategy;
+    private readonly pipeJoinStrategy;
+    private readonly pipeQueryOrganizationStrategy;
+    private readonly pipeAggregateStrategy;
+    private readonly pipeSetOperationStrategy;
+    private readonly pipeSampleStrategy;
+    private readonly pipePivotStrategy;
+    private readonly pipeUnpivotStrategy;
+    constructor(tokens: CommonTokenStream, config: SparkSQLFormattingOptions);
+    /**
+     * Add a text edit, allowing later edits to override earlier ones for the same range
+     */
+    private addTextEdit;
+    /**
+     * Get previous non-hidden token (skipping whitespace and comments)
+     * HIDDEN channel tokens (WS, comments) are in channel 1 or 2
+     * Note: Uses token's stopIndex to find position since tokenIndex may be -1 in browser
+     */
+    private getPreviousNonHiddenToken;
+    /**
+     * Get next non-hidden token (skipping whitespace and comments)
+     * Note: Uses token's startIndex to find position since tokenIndex may be -1 in browser
+     */
+    private getNextNonHiddenToken;
+    /**
+     * Find token index by matching startIndex
+     * This is used as a fallback when tokenIndex is -1
+     */
+    private findTokenIndexByStartIndex;
+    /**
+     * Get previous non-hidden token by symbol's startIndex
+     * Used when tokenIndex is not available (-1 in browser)
+     */
+    private getPreviousNonHiddenTokenByStartIndex;
+    /**
+     * Get next non-hidden token by symbol's stopIndex
+     * Used when tokenIndex is not available (-1 in browser)
+     */
+    private getNextNonHiddenTokenByStopIndex;
+    /**
+     * Check if a token is a comment (single-line or multi-line)
+     */
+    private isCommentToken;
+    /**
+     * Find the last comment token before a given start index
+     * Returns the comment token if found, undefined otherwise
+     */
+    private findLastCommentTokenBefore;
+    /**
+     * Find comment tokens between two positions (startIndex to endIndex exclusive)
+     * Returns array of comment tokens in order
+     */
+    private findCommentTokensBetween;
+    /**
+     * Find all tokens (including hidden) between two positions
+     * Returns array of tokens in order
+     */
+    private findTokensBetween;
+    /**
+     * Check if there is a newline in the whitespace before a comment
+     * @param startIndex - Start of the range to check
+     * @param commentStartIndex - Start index of the comment
+     * @returns true if there is a newline before the comment
+     */
+    private hasNewlineBeforeComment;
+    /**
+     * Build text that preserves comments within a range while respecting original positions
+     * Used to avoid deleting comments when updating whitespace between tokens
+     *
+     * Comment position rules:
+     * 1. If a comment was on the same line as the previous token (no newline before it),
+     *    keep it on the same line with a space separator
+     * 2. If a comment was on a new line, put it on a new line with proper indentation
+     * 3. Always add the requested newText after the last comment
+     *
+     * @param startIndex - Start index of the range (exclusive, typically end of previous token)
+     * @param endIndex - End index of the range (exclusive, typically start of next token)
+     * @param newText - The desired whitespace/newline text to use for line breaks
+     * @returns Text that includes preserved comments with proper spacing
+     */
+    private buildTextWithPreservedComments;
+    defaultResult(): void;
+    /**
+     * Check if the current context is inside a CASE WHEN expression
+     * by traversing the parent chain
+     */
+    private isInsideCaseWhen;
+    /**
+     * Check if the current context is inside a function call
+     * by traversing the parent chain
+     */
+    private isInsideFunctionCall;
+    /**
+     * Check if the expression contains a subquery that requires newline
+     * Only subquery expressions require newline, not simple parenthesized expressions
+     */
+    private containsSubquery;
+    private get indent();
+    private get newlineIndent();
+    private get writer();
+    private addIndent;
+    private minusIndent;
+    /**
+     * Update text before next token by context
+     * Replaces whitespace between context end and next non-hidden token
+     */
+    private updateBeforeNextTokenByContext;
+    /**
+     * Update text after previous token by context
+     * Replaces whitespace between previous non-hidden token and context start
+     * Preserves any comments that exist between the tokens
+     */
+    private updateAfterPreviousTokenByContext;
+    /**
+     * Update text before next token by node
+     * Replaces whitespace between current node and next non-hidden token
+     * Preserves any comments that exist between the tokens
+     */
+    private updateBeforeNextTokenByNode;
+    /**
+     * Calculate the end position of a token, handling multi-line tokens correctly
+     * For multi-line tokens (like strings with newlines), we need to count the lines
+     * and find the character position on the last line
+     */
+    private getTokenEndPosition;
+    private getFormattingBridgeHelpers;
+    private getListFormattingBridge;
+    private getClauseHeadBodyBridge;
+    private getJoinFormattingBridge;
+    private getBlockFormattingBridge;
+    /**
+     * Update text after previous token by node
+     * Replaces whitespace between previous non-hidden token and current node
+     * Preserves any comments that exist between the tokens
+     */
+    private updateAfterPreviousTokenByNode;
+    private normalizeKeywordSpacing;
+    /**
+     * Normalize spacing for multiple keywords at once
+     * Convenience method for consecutive keyword spacing
+     */
+    private normalizeKeywordsSpacing;
+    private normalizeKeywordSpacingAfterNewline;
+    /**
+     * Format IF EXISTS clause with proper spacing
+     * Handles: IF EXISTS - single space before and after each keyword
+     */
+    private formatIfExistsClause;
+    /**
+     * Format IF NOT EXISTS clause with proper spacing
+     * Handles: IF NOT EXISTS - single space before and after each keyword
+     */
+    private formatIfNotExistsClause;
+    private indentAfterNode;
+    /**
+     * Add indent and put context on new line with indent
+     * Pattern: this.addIndent() + updateBeforeNextTokenByContext(ctx, this.newlineIndent) + this.minusIndent()
+     */
+    private indentBeforeContext;
+    /**
+     * Format a parenthesized block with content on new lines
+     * Pattern: ( content ) -> (\n  content\n)
+     *
+     * @param leftParen - The left parenthesis node
+     * @param rightParen - The right parenthesis node
+     * @param options - Optional configuration
+     * @param options.spaceBeforeLeftParen - Whether to add space before left paren (default: true)
+     */
+    private formatParenthesizedBlock;
+    /**
+     * Format compact parentheses (no newlines inside)
+     * Used for: PARTITION (a=1, b=2), GROUPING SET (a, b), etc.
+     *
+     * @param leftParen - The left parenthesis node
+     * @param rightParen - The right parenthesis node
+     * @param options - Optional configuration
+     * @param options.spaceBeforeLeftParen - Whether to add space before left paren (default: false)
+     * @param options.commas - Comma nodes to format inline
+     */
+    private formatCompactParentheses;
+    /**
+     * Format equals sign with single space before and after
+     * Used for: key = value, pt = 'value', etc.
+     */
+    private formatEqualsSign;
+    private formatKeywordWithIndentedBody;
+    private formatIndentedContextList;
+    private addNewlineBeforeContexts;
+    /**
+     * Add newline before first TerminalNode in array
+     * Used for keyword lists like OPTIONS, PARTITIONED, TBLPROPERTIES
+     */
+    private addNewlineBeforeFirstNode;
+    /**
+     * Add newline before each TerminalNode and space after
+     * Pattern: keyword on new line, followed by space
+     */
+    private addNewlineAndSpaceBeforeNodes;
+    private formatIndentedTrailingCommaContextList;
+    private formatIndentedTrailingCommaNodes;
+    private formatInlineCommaNodes;
+    private addNewlineBeforeFirstContext;
+    /**
+     * Format a simple keyword statement
+     * Pattern: KEYWORD rest_of_statement
+     * Just adds a space after the keyword
+     */
+    private formatSimpleKeywordStatement;
+    /**
+     * Add space after a node (shorthand for common pattern)
+     * Pattern: this.updateBeforeNextTokenByNode(node, ' ')
+     */
+    private addSpaceAfterNode;
+    /**
+     * Add space after a context (shorthand for common pattern)
+     * Pattern: this.updateBeforeNextTokenByContext(ctx, ' ')
+     */
+    private addSpaceAfterContext;
+    /**
+     * Add space after multiple nodes (batch operation)
+     * Pattern: this.updateBeforeNextTokenByNode(node, ' ') for each node
+     */
+    private addSpaceAfterNodes;
+    /**
+     * Add newline before a node (shorthand for common pattern)
+     * Pattern: this.updateAfterPreviousTokenByNode(node, this.newline)
+     */
+    private addNewlineBeforeNode;
+    /**
+     * Add newline after a node
+     * Pattern: this.updateBeforeNextTokenByNode(node, this.newline)
+     */
+    private addNewlineAfterNode;
+    /**
+     * Add newline with indent before a node
+     * Pattern: this.updateAfterPreviousTokenByNode(node, this.newlineIndent)
+     */
+    private addNewlineIndentBeforeNode;
+    /**
+     * Add newline before a context (shorthand for common pattern)
+     * Pattern: this.updateAfterPreviousTokenByContext(ctx, this.newline)
+     */
+    private addNewlineBeforeContext;
+    /**
+     * Add newline with indent before a context
+     * Pattern: this.updateAfterPreviousTokenByContext(ctx, this.newlineIndent)
+     */
+    private addNewlineIndentBeforeContext;
+    /**
+     * Recursively clear newlines in a context and all its children (for compact mode)
+     * This ensures expressions like "any_value(a)" stay compact even if input has newlines
+     * @param ctx - The context to clear newlines from
+     */
+    private clearNewlinesRecursive;
+    /**
+     * Check if a token needs space before it based on its type
+     * Used by clearAllNewlines to preserve necessary spaces between tokens
+     */
+    private needsSpaceBefore;
+    /**
+     * Check if token is a keyword (reserved or non-reserved)
+     */
+    private isKeywordToken;
+    /**
+     * Check if token is a number or identifier
+     */
+    private isNumberOrIdentifierToken;
+    /**
+     * Check if token is opening punctuation
+     */
+    private isOpeningPunctuationToken;
+    /**
+     * Check if token is closing punctuation
+     */
+    private isClosingPunctuationToken;
+    /**
+     * Aggressively clear ALL newlines in a context, including between all tokens
+     * This is a stronger version of clearNewlinesRecursive for complete compact format
+     * Now intelligently preserves spaces between keywords, numbers, and identifiers
+     * @param ctx - The context to clear all newlines from
+     */
+    private clearAllNewlines;
+    /**
+     * Get the last terminal token from a context
+     */
+    private getLastToken;
+    /**
+     * Check if a range overlaps with any existing edit
+     * Used to avoid overwriting or conflicting with targeted formatting edits
+     */
+    private hasOverlappingEdit;
+    /**
+     * Compress consecutive spaces within a single line to a single space
+     * This is a post-processing step that catches any multi-space issues
+     * not handled by targeted visitor methods.
+     *
+     * Rules:
+     * 1. Only process tokens on HIDDEN channel (whitespace tokens)
+     * 2. Skip tokens that contain newlines (cross-line spaces)
+     * 3. Skip tokens that have already been processed by targeted methods
+     * 4. Compress multiple spaces to single space
+     *
+     * Note: String literals are not affected because they are parsed as
+     * separate tokens on the default channel, not as whitespace tokens.
+     */
+    private compressConsecutiveSpaces;
+    /**
+     * Format a sequence of keywords with optional line wrapping based on length
+     *
+     * This is a generic helper method for formatting keyword sequences that may need
+     * to wrap to new lines when the content exceeds maxParenthesisLength.
+     *
+     * @param ctx - The parser context to check length against
+     * @param rules - Array of keyword formatting rules
+     *
+     * Each rule specifies:
+     * - node: The TerminalNode to format (if undefined, rule is skipped)
+     * - beforeNormal: Separator before the keyword in normal mode (default: no change)
+     * - afterNormal: Separator after the keyword in normal mode (default: no change)
+     * - beforeWrap: Separator before the keyword when wrapping (used only if isWrapPoint=true)
+     * - afterWrap: Separator after the keyword when wrapping
+     * - isWrapPoint: If true, this keyword is where line wrapping occurs when content is long
+     *
+     * Example usage:
+     * ```typescript
+     * this.formatKeywordsWithLengthCheck(ctx, [
+     *   { node: ctx.INPUTFORMAT(), afterNormal: ' ', afterWrap: ' ' },
+     *   { node: ctx.OUTPUTFORMAT(), beforeNormal: ' ', afterNormal: ' ',
+     *     beforeWrap: this.newlineIndent, afterWrap: ' ', isWrapPoint: true }
+     * ]);
+     * ```
+     */
+    private formatKeywordsWithLengthCheck;
+    /**
+     * Format parenthesized content with commas (generic helper for all bracket scenarios)
+     *
+     * This is a reusable method for formatting any parenthesized content such as:
+     * - Column definitions: (id INT, name STRING)
+     * - Function arguments: func(arg1, arg2)
+     * - Property lists: TBLPROPERTIES ('key' = 'value')
+     * - Partition specs: PARTITION (pt = 'value')
+     * - Row constructors: VALUES (val1, val2)
+     * - Grouping analytics: ROLLUP(a, b), CUBE(a, b)
+     * - Identifier lists: alias(col1, col2)
+     *
+     * Handles two modes based on content length:
+     * - Compact mode (content <= maxParenthesisLength):
+     *   (elem1, elem2, elem3) - all on same line
+     * - Multiline mode (content > maxParenthesisLength):
+     *   (
+     *     elem1,
+     *     elem2,
+     *     elem3
+     *   )
+     *
+     * @param leftParen - Left parenthesis node
+     * @param rightParen - Right parenthesis node
+     * @param commas - Array of comma nodes
+     * @param contentLength - Total length of content inside parentheses
+     * @param options - Configuration options:
+     *   - spaceBeforeLeftParen: Add space before '(' (default: false)
+     *   - forceCompact: Always use compact format regardless of length
+     *   - forceMultiline: Always use multiline format regardless of length
+     *   - visitChildren: Callback to visit children (default: no-op)
+     *   - addIndentBeforeFormat: Add indent before formatting (for nested contexts)
+     */
+    private formatParenthesizedContent;
+    visitProgram(ctx: ProgramContext): void;
+    visitStatements(ctx: StatementsContext): void;
+    visitStatementEnd(ctx: StatementEndContext): void;
+    /**
+     * EXPLAIN [LOGICAL|FORMATTED|EXTENDED|CODEGEN|COST] statement
+     * Format: EXPLAIN FORMATTED
+     *         select
+     *           ...
+     * Note: EXPLAIN and mode stay on same line, statement on new line
+     */
+    visitExplain(ctx: ExplainContext): void;
+    visitCall(ctx: CallContext): void;
+    /**
+     * Format EXECUTE IMMEDIATE statement
+     *
+     * Short query (no INTO/USING):
+     *   EXECUTE IMMEDIATE 'SELECT * FROM users WHERE id = 1';
+     *
+     * With INTO and USING:
+     *   EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM t WHERE date >= ?'
+     *   INTO result_count
+     *   USING (start_date);
+     *
+     * Multi-param USING:
+     *   EXECUTE IMMEDIATE dynamic_query
+     *   INTO affected_rows
+     *   USING (
+     *     source_table => 'temp_data',
+     *     target_table => 'main_table',
+     *     batch_size => 1000
+     *   );
+     *
+     * Key rules:
+     * - EXECUTE IMMEDIATE expression stays on the same line
+     * - INTO clause starts on a new line
+     * - USING clause starts on a new line
+     * - String literal content is never modified (preserves highlighting)
+     */
+    visitExecuteImmediate(ctx: ExecuteImmediateContext): void;
+    visitCreateTable(ctx: CreateTableContext): void;
+    /**
+     * Format CREATE TABLE ... LIKE statement
+     * Target format:
+     * CREATE TABLE target_table
+     * LIKE source_table
+     * USING CSV
+     * LOCATION '/path/to/data';
+     */
+    visitCreateTableLike(ctx: CreateTableLikeContext): void;
+    /**
+     * Format tableProvider: USING provider_name
+     * Ensures single space between USING keyword and provider name
+     * Format: USING CSV (not: USING    CSV)
+     */
+    visitTableProvider(ctx: TableProviderContext): void;
+    visitCreateTableHeader(ctx: CreateTableHeaderContext): void;
+    visitCreateTableClauses(ctx: CreateTableClausesContext): void;
+    visitPropertyList(ctx: PropertyListContext): void;
+    /**
+     * Format expressionPropertyList (used by OPTIONS clause)
+     * Format: OPTIONS (
+     *   'key' = 'value',
+     *   'key2' = 'value2'
+     * )
+     * This ensures consistent formatting with TBLPROPERTIES
+     */
+    visitExpressionPropertyList(ctx: ExpressionPropertyListContext): void;
+    /**
+     * Format expressionProperty with key = value format (used by OPTIONS clause)
+     * Ensures exactly one space before and after the equals sign
+     * Format: 'key' = 'value'
+     * This ensures consistent formatting with property (used by TBLPROPERTIES)
+     */
+    visitExpressionPropertyWithKeyAndEquals(ctx: ExpressionPropertyWithKeyAndEqualsContext): void;
+    /**
+     * Property with key = value format
+     * Ensures exactly one space before and after the equals sign
+     * Format: 'key' = 'value'
+     */
+    visitPropertyWithKeyAndEquals(ctx: PropertyWithKeyAndEqualsContext): void;
+    visitTableElementList(ctx: TableElementListContext): void;
+    visitColDefinition(ctx: ColDefinitionContext): void;
+    /**
+     * Format CREATE VIEW statement
+     * Format:
+     *   CREATE VIEW view_name AS
+     *   SELECT ...
+     *
+     *   CREATE OR REPLACE GLOBAL TEMPORARY VIEW view_name (col1 COMMENT 'desc') AS
+     *   SELECT ...
+     *
+     *   CREATE VIEW IF NOT EXISTS view_name
+     *   COMMENT 'description'
+     *   TBLPROPERTIES ('key' = 'value') AS
+     *   SELECT ...
+     */
+    visitCreateView(ctx: CreateViewContext): void;
+    /**
+     * Format CREATE METRIC VIEW statement
+     * Format:
+     *   CREATE VIEW view_name
+     *   WITH METRICS
+     *   LANGUAGE SQL
+     *   COMMENT 'description'
+     *   TBLPROPERTIES ('key' = 'value') AS
+     *   '...'
+     */
+    visitCreateMetricView(ctx: CreateMetricViewContext): void;
+    /**
+     * Format CREATE TEMP VIEW ... USING statement
+     * Format:
+     *   CREATE TEMPORARY VIEW view_name (col1 STRING, col2 INT)
+     *   USING CSV
+     *   OPTIONS ('path' = '/data/path')
+     *
+     *   CREATE OR REPLACE GLOBAL TEMPORARY VIEW view_name
+     *   USING PARQUET
+     *   OPTIONS ('path' = '/data/path')
+     */
+    visitCreateTempViewUsing(ctx: CreateTempViewUsingContext): void;
+    /**
+     * Format CREATE FUNCTION statement
+     * Format:
+     *   CREATE FUNCTION simple_udf AS 'SimpleUdf'
+     *       USING JAR '/tmp/SimpleUdf.jar';
+     *   CREATE TEMPORARY FUNCTION simple_temp_udf AS 'SimpleUdf'
+     *       USING JAR '/tmp/SimpleUdf.jar';
+     *   CREATE OR REPLACE FUNCTION simple_udf AS 'SimpleUdfR'
+     *       USING JAR '/tmp/SimpleUdfR.jar';
+     */
+    visitCreateFunction(ctx: CreateFunctionContext): void;
+    /**
+     * Format resource in CREATE FUNCTION USING clause
+     * Ensures single space between resource type (JAR/FILE/ARCHIVE) and path
+     * Format: JAR '/path/to/jar' (not: JAR     '/path/to/jar')
+     */
+    visitResource(ctx: ResourceContext): void;
+    /**
+     * Format CREATE INDEX statement
+     * Format: CREATE INDEX [IF NOT EXISTS] index_name ON [TABLE] table_name
+     *         USING index_type
+     *         (columns)
+     *         OPTIONS (...)
+     */
+    visitCreateIndex(ctx: CreateIndexContext): void;
+    /**
+     * Helper method to format ALTER TABLE/VIEW common structure
+     * Format: ALTER TABLE
+     *           table_name
+     * SUB_COMMAND ...
+     */
+    private formatAlterTableHeader;
+    /**
+     * ALTER TABLE ... ADD COLUMN/COLUMNS
+     * Format: ALTER TABLE
+     *           table_name
+     *         ADD COLUMN
+     *           email STRING;
+     * Or with multiple columns:
+     *         ADD COLUMNS (
+     *           age INT, address STRING
+     *         );
+     */
+    visitAddTableColumns(ctx: AddTableColumnsContext): void;
+    /**
+     * ALTER TABLE ... RENAME COLUMN from TO to
+     * Format: ALTER TABLE
+     *           table_name
+     *         RENAME COLUMN
+     *           name
+     *         TO
+     *           full_name;
+     */
+    visitRenameTableColumn(ctx: RenameTableColumnContext): void;
+    /**
+     * ALTER TABLE ... DROP COLUMN/COLUMNS (IF EXISTS)
+     * Format: ALTER TABLE
+     *           table_name
+     *         DROP COLUMN
+     *           address;
+     */
+    visitDropTableColumns(ctx: DropTableColumnsContext): void;
+    /**
+     * ALTER TABLE/VIEW ... RENAME TO new_name
+     * Format: ALTER TABLE
+     *           table_name
+     *         RENAME TO
+     *           new_table_name;
+     */
+    visitRenameTable(ctx: RenameTableContext): void;
+    /**
+     * ALTER VIEW ... AS query
+     * Format: ALTER VIEW tempdb1.v2 AS
+     *         SELECT
+     *           *
+     *         FROM
+     *           tempdb1.v1;
+     */
+    visitAlterViewQuery(ctx: AlterViewQueryContext): void;
+    /**
+     * ALTER TABLE/VIEW ... SET TBLPROPERTIES (...)
+     * Format: ALTER TABLE
+     *           table_name
+     *         SET TBLPROPERTIES
+     *           ('description' = '...');
+     */
+    visitSetTableProperties(ctx: SetTablePropertiesContext): void;
+    /**
+     * ALTER TABLE/VIEW ... UNSET TBLPROPERTIES (IF EXISTS) (...)
+     * Format: ALTER TABLE
+     *           table_name
+     *         UNSET TBLPROPERTIES
+     *           ('key');
+     */
+    visitUnsetTableProperties(ctx: UnsetTablePropertiesContext): void;
+    /**
+     * ALTER TABLE ... ALTER/CHANGE COLUMN column_name action
+     * Format: ALTER TABLE
+     *           table_name
+     *         ALTER COLUMN
+     *           column_name ...
+     */
+    visitAlterTableAlterColumn(ctx: AlterTableAlterColumnContext): void;
+    /**
+     * Format alterColumnAction for ALTER TABLE ... ALTER COLUMN
+     * COMMENT should be on its own line with same indent as column name
+     * Format: ALTER TABLE
+     *           table_name
+     *         ALTER COLUMN
+     *           col_name
+     *           COMMENT 'comment'
+     */
+    visitAlterColumnAction(ctx: AlterColumnActionContext): void;
+    /**
+     * ALTER TABLE ... CHANGE COLUMN old_name new_type [COMMENT] [FIRST|AFTER]
+     * Format: ALTER TABLE
+     *           table_name
+     *         CHANGE COLUMN
+     *           name
+     *           name STRING;
+     *   Or with position:
+     *           email STRING
+     *           FIRST;
+     */
+    visitHiveChangeColumn(ctx: HiveChangeColumnContext): void;
+    /**
+     * ALTER TABLE ... REPLACE COLUMNS (col1 type1, col2 type2)
+     * Format: ALTER TABLE
+     *           table_name
+     *         REPLACE COLUMNS (
+     *           col1 type1, col2 type2
+     *         )
+     */
+    visitHiveReplaceColumns(ctx: HiveReplaceColumnsContext): void;
+    /**
+     * Format qualifiedColTypeWithPositionList for REPLACE COLUMNS / ADD COLUMNS
+     * Format: (
+     *   name string,
+     *   ID int
+     *     COMMENT 'new comment'
+     * )
+     * Each column definition on its own line with indent
+     */
+    visitQualifiedColTypeWithPositionList(ctx: QualifiedColTypeWithPositionListContext): void;
+    /**
+     * Format qualifiedColTypeWithPosition for ADD COLUMNS / REPLACE COLUMNS
+     * Ensures single space between field name and data type
+     * Format: LastName string (not: LastName     string)
+     */
+    visitQualifiedColTypeWithPosition(ctx: QualifiedColTypeWithPositionContext): void;
+    /**
+     * Format multipartIdentifierList for DROP COLUMNS
+     * Ensures proper comma formatting: no space before comma, one space after
+     * Format: LastName, DOB (not: LastName  ,    DOB)
+     */
+    visitMultipartIdentifierList(ctx: MultipartIdentifierListContext): void;
+    /**
+     * Format column definition descriptors (COMMENT, NOT NULL, DEFAULT, position)
+     * COMMENT should be on its own line with extra indent
+     * Format: ID int
+     *           COMMENT 'new comment'
+     */
+    visitColDefinitionDescriptorWithPosition(ctx: ColDefinitionDescriptorWithPositionContext): void;
+    /**
+     * ALTER TABLE ... SET SERDE/SERDEPROPERTIES
+     * Format 1: ALTER TABLE
+     *             table_name
+     *           SET SERDE
+     *             'serde_class'
+     *           WITH SERDEPROPERTIES
+     *             (key = 'value')
+     * Format 2: ALTER TABLE
+     *             table_name
+     *           SET SERDEPROPERTIES
+     *             (key = 'value')
+     */
+    visitSetTableSerDe(ctx: SetTableSerDeContext): void;
+    /**
+     * ALTER TABLE/VIEW ... ADD (IF NOT EXISTS) PARTITION
+     * Format: ALTER TABLE
+     *           table_name
+     *         ADD
+     *           PARTITION(pt = '2023-01-01');
+     */
+    visitAddTablePartition(ctx: AddTablePartitionContext): void;
+    /**
+     * ALTER TABLE ... PARTITION (...) RENAME TO PARTITION (...)
+     * Format: ALTER TABLE
+     *           table_name
+     *           PARTITION(pt = '2023-01-02')
+     *         RENAME TO
+     *           PARTITION(pt = '2023-01-03');
+     */
+    visitRenameTablePartition(ctx: RenameTablePartitionContext): void;
+    /**
+     * ALTER TABLE/VIEW ... DROP (IF EXISTS) PARTITION (...) PURGE?
+     * Format: ALTER TABLE
+     *           table_name
+     *         DROP
+     *           PARTITION(pt = '2023-01-01');
+     */
+    visitDropTablePartitions(ctx: DropTablePartitionsContext): void;
+    /**
+     * ALTER TABLE ... (PARTITION) SET LOCATION '...'
+     * Format: ALTER TABLE
+     *           table_name
+     *         SET
+     *           LOCATION '/path/to/location';
+     */
+    visitSetTableLocation(ctx: SetTableLocationContext): void;
+    /**
+     * Format locationSpec: LOCATION '/path/to/location'
+     * Ensures single space between LOCATION keyword and path value
+     * Format: LOCATION '/path' (not: LOCATION      '/path')
+     */
+    visitLocationSpec(ctx: LocationSpecContext): void;
+    /**
+     * Format commentSpec: COMMENT 'comment string'
+     * Ensures single space between COMMENT keyword and comment value
+     * Format: COMMENT 'comment' (not: COMMENT      'comment')
+     */
+    visitCommentSpec(ctx: CommentSpecContext): void;
+    /**
+     * Format identifierCommentList: (ID COMMENT 'desc', Name, ...)
+     * Used in CREATE VIEW column definitions
+     * Format: (
+     *   ID COMMENT 'desc',
+     *   Name
+     * ) - each column on new line with indent
+     */
+    visitIdentifierCommentList(ctx: IdentifierCommentListContext): void;
+    /**
+     * Format identifierComment: identifier COMMENT 'desc'
+     * Ensures single space between identifier and optional COMMENT clause
+     * Format: ID COMMENT 'desc' (not: ID    COMMENT 'desc')
+     */
+    visitIdentifierComment(ctx: IdentifierCommentContext): void;
+    /**
+     * ALTER TABLE ... RECOVER PARTITIONS
+     * Format: ALTER TABLE
+     *           table_name
+     *         RECOVER PARTITIONS
+     */
+    visitRecoverPartitions(ctx: RecoverPartitionsContext): void;
+    /**
+     * Format CREATE DATABASE/NAMESPACE statement
+     * Format:
+     *   CREATE DATABASE IF NOT EXISTS customer_db
+     *   COMMENT 'This is customer database'
+     *   LOCATION '/user'
+     *   WITH DBPROPERTIES (
+     *     ID = 001,
+     *     Name = 'John'
+     *   );
+     */
+    visitCreateNamespace(ctx: CreateNamespaceContext): void;
+    /**
+     * Helper method to format ALTER NAMESPACE common structure
+     * Format: ALTER NAMESPACE
+     *           namespace_name
+     * SUB_COMMAND ...
+     */
+    private formatAlterNamespaceHeader;
+    /**
+     * ALTER NAMESPACE ... SET (DBPROPERTIES | PROPERTIES) propertyList
+     * Format: ALTER NAMESPACE
+     *           namespace_name
+     *         SET DBPROPERTIES
+     *           ('key1' = 'value1', 'key2' = 'value2');
+     */
+    visitSetNamespaceProperties(ctx: SetNamespacePropertiesContext): void;
+    /**
+     * ALTER NAMESPACE ... UNSET (DBPROPERTIES | PROPERTIES) propertyList
+     * Format: ALTER NAMESPACE
+     *           namespace_name
+     *         UNSET DBPROPERTIES
+     *           ('key1', 'key2');
+     */
+    visitUnsetNamespaceProperties(ctx: UnsetNamespacePropertiesContext): void;
+    /**
+     * ALTER NAMESPACE ... collationSpec
+     * Format: ALTER NAMESPACE
+     *           namespace_name
+     *         COLLATION
+     *           collation_name;
+     */
+    visitSetNamespaceCollation(ctx: SetNamespaceCollationContext): void;
+    /**
+     * ALTER NAMESPACE ... SET locationSpec
+     * Format: ALTER NAMESPACE
+     *           namespace_name
+     *         SET
+     *           LOCATION '/path/to/location';
+     */
+    visitSetNamespaceLocation(ctx: SetNamespaceLocationContext): void;
+    /**
+     * Query primary: handles inlineTable, subquery, tableName, etc.
+     * For inlineTable with AS alias, ensure the alias stays on the same line as VALUES
+     */
+    visitQueryPrimary(ctx: QueryPrimaryContext): void;
+    /**
+     * Relation primary: handles tableName, inlineTable, subquery, etc.
+     * For inlineTable, we want to prevent unwanted line breaks
+     */
+    visitRelationPrimary(ctx: RelationPrimaryContext): void;
+    visitSingleInsertQuery(ctx: SingleInsertQueryContext): void;
+    visitInsertIntoTable(ctx: InsertIntoTableContext): void;
+    visitInsertOverwriteTable(ctx: InsertOverwriteTableContext): void;
+    visitPartitionSpec(ctx: PartitionSpecContext): void;
+    /**
+     * Format partition value: pt = 'value' or pt = DEFAULT
+     * Ensure space around equals sign
+     */
+    visitPartitionVal(ctx: PartitionValContext): void;
+    visitInlineTable(ctx: InlineTableContext): void;
+    /**
+     * Row constructor for VALUES clause: (expr1, expr2, ...)
+     * Ensures no extra spaces inside parentheses and proper comma spacing
+     * Format (short): ('value1', 'value2') not (  'value1',  'value2'  )
+     * Format (long): (
+     *     expr1,
+     *     expr2,
+     *     ...
+     *   )
+     */
+    visitRowConstructor(ctx: RowConstructorContext): void;
+    /**
+     * Table alias: t(k, v) or AS t(k, v)
+     * Ensures single space before alias identifier and no space between identifier and column list
+     * Format: ... t(k, v) not ...   t (k, v)
+     */
+    visitTableAlias(ctx: TableAliasContext): void;
+    /**
+     * Identifier list for table alias: t(k, v)
+     * Ensures no extra spaces inside parentheses and proper comma spacing
+     * Format (short): t(k, v) not t(k,v) or t( k , v )
+     * Format (long): t(
+     *     col1,
+     *     col2,
+     *     col3
+     *   )
+     */
+    visitIdentifierList(ctx: IdentifierListContext): void;
+    /**
+     * Identifier sequence: k, v, ...
+     * Note: Comma formatting is handled by parent (visitIdentifierList) when using formatParenthesizedContent
+     * This method only handles cases where identifierSeq is used outside of identifierList
+     */
+    visitIdentifierSeq(ctx: IdentifierSeqContext): void;
+    visitQuery(ctx: QueryContext): void;
+    visitSetOperation(ctx: SetOperationContext): void;
+    visitQueryOrganization(ctx: QueryOrganizationContext): void;
+    visitCtes(ctx: CtesContext): void;
+    visitNamedQuery(ctx: NamedQueryContext): void;
+    visitRegularQuerySpecification(ctx: RegularQuerySpecificationContext): void;
+    visitSelectClause(ctx: SelectClauseContext): void;
+    /**
+     * Format fromStatementBody - used in multiInsertQuery (FROM table SELECT ...)
+     * The SELECT clause should be on a new line, aligned with FROM
+     */
+    visitFromStatementBody(ctx: FromStatementBodyContext): void;
+    /**
+     * Format multi-insert query:
+     * FROM source_table
+     * INSERT INTO table1 SELECT col1, col2 WHERE condition1
+     * INSERT INTO table2 SELECT col3, col4 WHERE condition2
+     * INSERT OVERWRITE TABLE3 SELECT *;
+     *
+     * Formatting rules:
+     * - FROM clause as the starting point (no indent)
+     * - Each INSERT clause on a new line
+     * - SELECT parts are formatted according to query formatting rules
+     */
+    visitMultiInsertQuery(ctx: MultiInsertQueryContext): void;
+    /**
+     * Format each multi-insert query body:
+     * INSERT INTO table_name SELECT ... WHERE ...
+     *
+     * Each body starts with INSERT and contains the full query specification.
+     * Subsequent INSERT bodies should each be on their own line.
+     */
+    visitMultiInsertQueryBody(ctx: MultiInsertQueryBodyContext): void;
+    visitSetQuantifier(ctx: SetQuantifierContext): void;
+    visitNamedExpressionSeq(ctx: NamedExpressionSeqContext): void;
+    visitNamedExpression(ctx: NamedExpressionContext): void;
+    /**
+     * DELETE FROM table_name WHERE condition
+     * Format: DELETE FROM
+     *           table_name
+     *         WHERE
+     *           condition;
+     * Note: DELETE FROM stays on same line (unlike SELECT's FROM which is on its own line)
+     */
+    visitDeleteFromTable(ctx: DeleteFromTableContext): void;
+    /**
+     * UPDATE table_name SET col1 = val1, col2 = val2 WHERE condition
+     * Format: UPDATE
+     *           table_name
+     *         SET
+     *           column1 = value1,
+     *           column2 = value2
+     *         WHERE
+     *           condition;
+     */
+    visitUpdateTable(ctx: UpdateTableContext): void;
+    /**
+     * SET clause in UPDATE statement
+     * Format: SET
+     *           column1 = value1,
+     *           column2 = value2
+     */
+    visitSetClause(ctx: SetClauseContext): void;
+    /**
+     * MERGE INTO statement
+     * Format:
+     *   MERGE INTO
+     *     target_table t
+     *   USING
+     *     source_table s
+     *   ON
+     *     t.id = s.id
+     *   WHEN MATCHED THEN UPDATE SET t.name = s.name
+     *   WHEN NOT MATCHED THEN INSERT (id, name) VALUES (s.id, s.name)
+     *   WHEN NOT MATCHED BY SOURCE THEN DELETE;
+     *
+     * Or with SCHEMA EVOLUTION:
+     *   MERGE WITH SCHEMA EVOLUTION INTO
+     *     target_table t
+     *   USING
+     *     source_table s
+     *   ON
+     *     t.id = s.id
+     *   ...
+     */
+    visitMergeIntoTable(ctx: MergeIntoTableContext): void;
+    /**
+     * Format WHEN MATCHED clause
+     * Format: WHEN MATCHED [AND condition] THEN UPDATE SET ...
+     * All on same line
+     */
+    visitMatchedClause(ctx: MatchedClauseContext): void;
+    /**
+     * Format WHEN NOT MATCHED clause
+     * Format: WHEN NOT MATCHED [BY TARGET] [AND condition] THEN INSERT ...
+     * All on same line
+     */
+    visitNotMatchedClause(ctx: NotMatchedClauseContext): void;
+    /**
+     * Format WHEN NOT MATCHED BY SOURCE clause
+     * Format: WHEN NOT MATCHED BY SOURCE [AND condition] THEN DELETE/UPDATE ...
+     * All on same line
+     */
+    visitNotMatchedBySourceClause(ctx: NotMatchedBySourceClauseContext): void;
+    visitFromClause(ctx: FromClauseContext): void;
+    visitTable(ctx: TableContext): void;
+    visitTableName(ctx: TableNameContext): void;
+    visitJoinRelation(ctx: JoinRelationContext): void;
+    /**
+     * Format join type keywords: LEFT OUTER, RIGHT OUTER, FULL OUTER, etc.
+     * Ensures single space between keywords
+     */
+    visitJoinType(ctx: JoinTypeContext): void;
+    visitJoinCriteria(ctx: JoinCriteriaContext): void;
+    visitLateralView(ctx: LateralViewContext): void;
+    visitAliasedQuery(ctx: AliasedQueryContext): void;
+    /**
+     * Check if a context is inside a SELECT expression (e.g., select (subquery) as alias)
+     */
+    private isInsideSelectExpression;
+    visitWhereClause(ctx: WhereClauseContext): void;
+    visitAggregationClause(ctx: AggregationClauseContext): void;
+    visitGroupingAnalytics(ctx: GroupingAnalyticsContext): void;
+    /**
+     * Format grouping set: (expr1, expr2, ...) or single expression
+     * Ensures no extra spaces inside parentheses and proper comma spacing
+     * Format: (region, category, year) not ( region,   category,   year)
+     */
+    visitGroupingSet(ctx: GroupingSetContext): void;
+    visitHavingClause(ctx: HavingClauseContext): void;
+    visitPivotClause(ctx: PivotClauseContext): void;
+    visitUnpivotClause(ctx: UnpivotClauseContext): void;
+    visitUnpivotNullClause(ctx: UnpivotNullClauseContext): void;
+    visitSample(ctx: SampleContext): void;
+    visitSampleByPercentile(ctx: SampleByPercentileContext): void;
+    visitUnpivotMultiValueColumnClause(ctx: UnpivotMultiValueColumnClauseContext): void;
+    visitUnpivotSingleValueColumnClause(ctx: UnpivotSingleValueColumnClauseContext): void;
+    visitUnpivotColumnSet(ctx: UnpivotColumnSetContext): void;
+    visitWindowClause(ctx: WindowClauseContext): void;
+    visitNamedWindow(ctx: NamedWindowContext): void;
+    visitWindowDef(ctx: WindowDefContext): void;
+    /**
+     * Format window frame clause: ROWS/RANGE [BETWEEN ... AND ...]
+     * Ensures single space between keywords
+     * Format: ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+     */
+    visitWindowFrame(ctx: WindowFrameContext): void;
+    /**
+     * Format frame bound: UNBOUNDED PRECEDING/FOLLOWING or CURRENT ROW
+     * Ensures single space between keywords
+     */
+    visitFrameBound(ctx: FrameBoundContext): void;
+    visitSortItem(ctx: SortItemContext): void;
+    private hasLogicalBinary;
+    visitSearchedCase(ctx: SearchedCaseContext): void;
+    visitSimpleCase(ctx: SimpleCaseContext): void;
+    visitWhenClause(ctx: WhenClauseContext): void;
+    private formatOrderedAggregateFunctionCall;
+    private formatOuterWrapperFunctionCall;
+    visitFunctionCall(ctx: FunctionCallContext): void;
+    private isListAggFunctionCall;
+    private containsWithinGroupClause;
+    private isMultilineWithinGroupTarget;
+    private isIntervalValueContext;
+    private containsMultilineFunctionArgument;
+    private hasMultilineFunctionCallChild;
+    private classifyFunctionCallKind;
+    /**
+     * Format ANY_VALUE function: ANY_VALUE(expression [IGNORE NULLS])
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitAny_value(ctx: Any_valueContext): void;
+    /**
+     * Format FIRST function: FIRST(expression [IGNORE NULLS])
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitFirst(ctx: FirstContext): void;
+    /**
+     * Format LAST function: LAST(expression [IGNORE NULLS])
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitLast(ctx: LastContext): void;
+    /**
+     * Format TIMESTAMPADD function: TIMESTAMPADD(unit, amount, timestamp)
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitTimestampadd(ctx: TimestampaddContext): void;
+    /**
+     * Format TIMESTAMPDIFF function: TIMESTAMPDIFF(unit, startTimestamp, endTimestamp)
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitTimestampdiff(ctx: TimestampdiffContext): void;
+    /**
+     * Format POSITION function: POSITION(substr IN str)
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitPosition(ctx: PositionContext): void;
+    /**
+     * Format STRUCT function: STRUCT(expr1 [AS alias1], expr2 [AS alias2], ...)
+     * Ensures compact format - no newlines inside parentheses
+     */
+    visitStruct(ctx: StructContext): void;
+    /**
+     * Format TRIM function: TRIM([BOTH|LEADING|TRAILING] [trimStr] FROM srcStr)
+     * Ensures no space after left paren and no space before right paren
+     * Format: TRIM(BOTH ' ' FROM column) not TRIM( BOTH ' ' FROM column )
+     */
+    visitTrim(ctx: TrimContext): void;
+    /**
+     * Format CAST and TRY_CAST expressions
+     * Ensures proper spacing:
+     *   CAST(customer_id AS STRING) - no space after ( or before )
+     *   TRY_CAST(amount AS DECIMAL(10, 2)) - same formatting rules
+     */
+    visitCast(ctx: CastContext): void;
+    visitSubqueryExpression(ctx: SubqueryExpressionContext): void;
+    /**
+     * Format subquery: (query) - used in CTAS without AS keyword
+     * Format:
+     *   CLUSTERED BY (id) INTO 4 buckets (
+     *     WITH tmpTable AS (...)
+     *     SELECT ...
+     *   )
+     * Left parenthesis stays on same line, content indented, right parenthesis on new line
+     */
+    visitSubquery(ctx: SubqueryContext): void;
+    visitParenthesizedExpression(ctx: ParenthesizedExpressionContext): void;
+    visitLogicalBinary(ctx: LogicalBinaryContext): void;
+    visitLogicalNot(ctx: LogicalNotContext): void;
+    visitCollateClause(ctx: CollateClauseContext): void;
+    visitCollate(ctx: CollateContext): void;
+    visitComparison(ctx: ComparisonContext): void;
+    visitPredicate(ctx: PredicateContext): void;
+    visitExists(ctx: ExistsContext): void;
+    visitIntervalValue(ctx: IntervalValueContext): void;
+    visitArithmeticBinary(ctx: ArithmeticBinaryContext): void;
+    visitDereference(ctx: DereferenceContext): void;
+    visitStar(ctx: StarContext): void;
+    visitExceptClause(ctx: ExceptClauseContext): void;
+    /**
+     * Format partitionFieldList: (field1, field2, ...)
+     * Ensures space after BY keyword and proper parenthesis formatting
+     * Format: PARTITIONED BY (age INT) not: PARTITIONED BY(age INT) or PARTITIONED     BY   (age)
+     */
+    visitPartitionFieldList(ctx: PartitionFieldListContext): void;
+    /**
+     * Format bucketSpec: CLUSTERED BY (col1, col2) SORTED BY (col1) INTO n BUCKETS
+     * Ensures single space between all keywords
+     * Format: CLUSTERED BY (id) SORTED BY (id) INTO 4 BUCKETS
+     */
+    visitBucketSpec(ctx: BucketSpecContext): void;
+    /**
+     * Format orderedIdentifierList: (col1 ASC, col2 DESC)
+     * Used by SORTED BY clause in bucketSpec
+     * Ensures proper parenthesis and comma formatting
+     */
+    visitOrderedIdentifierList(ctx: OrderedIdentifierListContext): void;
+    /**
+     * Format orderedIdentifier: column ASC/DESC
+     * Ensures single space between identifier and ordering keyword (ASC/DESC)
+     * Format: ID ASC not: ID      ASC
+     */
+    visitOrderedIdentifier(ctx: OrderedIdentifierContext): void;
+    /**
+     * Format createFileFormat: STORED AS format or STORED BY handler
+     * Ensures single space between STORED and AS/BY keywords
+     * Format: STORED AS PARQUET not: STORED     AS    PARQUET
+     */
+    visitCreateFileFormat(ctx: CreateFileFormatContext): void;
+    /**
+     * Format tableFileFormat: INPUTFORMAT 'input_class' OUTPUTFORMAT 'output_class'
+     *
+     * Normal mode (short line):
+     *   STORED AS INPUTFORMAT 'input_class' OUTPUTFORMAT 'output_class'
+     *
+     * Wrap mode (long line > maxParenthesisLength):
+     *   STORED AS INPUTFORMAT 'input_class'
+     *   OUTPUTFORMAT 'output_class'
+     */
+    visitTableFileFormat(ctx: TableFileFormatContext): void;
+    /**
+     * Format rowFormatSerde: ROW FORMAT SERDE 'serde_class' WITH SERDEPROPERTIES (...)
+     * Ensures single space between ROW, FORMAT, SERDE keywords
+     * Format: ROW FORMAT SERDE 'class' not: ROW    FORMAT    SERDE    'class'
+     */
+    visitRowFormatSerde(ctx: RowFormatSerdeContext): void;
+    /**
+     * Format rowFormatDelimited: ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' ...
+     * Each parameter group should be on its own line for readability
+     * Format:
+     *   ROW FORMAT DELIMITED
+     *   FIELDS TERMINATED BY ','
+     *   ESCAPED BY '\\'
+     *   COLLECTION ITEMS TERMINATED BY '_'
+     *   MAP KEYS TERMINATED BY ':'
+     *   LINES TERMINATED BY '\n'
+     *   NULL DEFINED AS 'foonull'
+     */
+    visitRowFormatDelimited(ctx: RowFormatDelimitedContext): void;
+    /**
+     * Format complex data types: ARRAY<>, MAP<>, STRUCT<>
+     * Ensures proper spacing inside angle brackets
+     * Format:
+     *   ARRAY<STRING> (not: ARRAY <STRING> or ARRAY<  STRING  >)
+     *   MAP<STRING, INT> (not: MAP <STRING, INT> or MAP<STRING,   INT>)
+     *   STRUCT<field: type> (not: STRUCT <field: type> or STRUCT<field:   type>)
+     */
+    visitComplexDataType(ctx: ComplexDataTypeContext): void;
+    /**
+     * Format non-trivial primitive data types: DECIMAL(10, 2), VARCHAR(50), etc.
+     * Ensures proper spacing inside parentheses
+     * Format:
+     *   DECIMAL(10, 2) (not: DECIMAL( 10,2 ) or DECIMAL(10,2))
+     *   VARCHAR(50) (not: VARCHAR( 50 ) or VARCHAR(50 ))
+     */
+    visitNonTrivialPrimitiveType(ctx: NonTrivialPrimitiveTypeContext): void;
+    /**
+     * Format primitive types with parentheses (e.g., TIMESTAMP(6), unsupported types with params)
+     * Ensures proper spacing inside parentheses
+     * Format:
+     *   TIMESTAMP(6) (not: TIMESTAMP( 6 ) or TIMESTAMP(6 ))
+     *   custom_type(10, 2) (not: custom_type( 10,2 ) or custom_type(10,2 ))
+     */
+    visitPrimitiveType(ctx: PrimitiveTypeContext): void;
+    /**
+     * Format colTypeList: col1 TYPE, col2 TYPE, ...
+     * Used in CREATE TEMP VIEW ... (col1 TYPE, col2 TYPE) USING ...
+     * Ensures proper comma formatting: no space before, single space after
+     * Format: (id INT, name STRING) not: (id INT , name STRING)
+     */
+    visitColTypeList(ctx: ColTypeListContext): void;
+    /**
+     * Format colType: colName dataType [NOT NULL] [COMMENT '...']
+     * Ensures single space between column name and data type
+     * Format: id INT not: id   INT
+     */
+    visitColType(ctx: ColTypeContext): void;
+    /**
+     * Format complexColTypeList: field1: type1, field2: type2
+     * Used inside STRUCT<...>
+     * Ensures proper spacing between fields
+     */
+    visitComplexColTypeList(ctx: ComplexColTypeListContext): void;
+    /**
+     * Format complexColType: fieldName: dataType
+     * Used inside STRUCT<...>
+     * Ensures single space after colon (or no space based on preference)
+     * Format: field: TYPE (not: field:   TYPE)
+     */
+    visitComplexColType(ctx: ComplexColTypeContext): void;
+    /**
+     * Format DROP DATABASE/NAMESPACE/SCHEMA statement
+     * Format: DROP DATABASE [IF EXISTS] db_name [RESTRICT|CASCADE]
+     */
+    visitDropNamespace(ctx: DropNamespaceContext): void;
+    /**
+     * Format DROP TABLE statement
+     * Format: DROP TABLE [IF EXISTS] table_name [PURGE]
+     */
+    visitDropTable(ctx: DropTableContext): void;
+    /**
+     * Format DROP VIEW statement
+     * Format: DROP VIEW [IF EXISTS] view_name
+     */
+    visitDropView(ctx: DropViewContext): void;
+    /**
+     * Format DROP FUNCTION statement
+     * Format: DROP [TEMPORARY] FUNCTION [IF EXISTS] function_name
+     */
+    visitDropFunction(ctx: DropFunctionContext): void;
+    /**
+     * Format LOAD DATA statement
+     * Format: LOAD DATA [LOCAL] INPATH 'path' [OVERWRITE] INTO TABLE table_name [PARTITION (...)]
+     */
+    visitLoadData(ctx: LoadDataContext): void;
+    /**
+     * Format TRUNCATE TABLE statement
+     * Format: TRUNCATE TABLE table_name [PARTITION (...)]
+     */
+    visitTruncateTable(ctx: TruncateTableContext): void;
+    /**
+     * Format REPAIR TABLE statement
+     * Format: [MSCK] REPAIR TABLE table_name [ADD|DROP|SYNC PARTITIONS]
+     */
+    visitRepairTable(ctx: RepairTableContext): void;
+    /**
+     * Format ANALYZE TABLE statement
+     * Format: ANALYZE TABLE table_name [PARTITION (...)] COMPUTE STATISTICS [FOR COLUMNS ...]
+     */
+    visitAnalyze(ctx: AnalyzeContext): void;
+    /**
+     * Format ANALYZE TABLES statement
+     * Format: ANALYZE TABLES [FROM|IN db_name] COMPUTE STATISTICS [NOSCAN]
+     */
+    visitAnalyzeTables(ctx: AnalyzeTablesContext): void;
+    /**
+     * Format CACHE TABLE statement
+     * Format: CACHE [LAZY] TABLE table_name [OPTIONS (...)] [AS query]
+     */
+    visitCacheTable(ctx: CacheTableContext): void;
+    /**
+     * Format UNCACHE TABLE statement
+     * Format: UNCACHE TABLE [IF EXISTS] table_name
+     */
+    visitUncacheTable(ctx: UncacheTableContext): void;
+    /**
+     * Format CLEAR CACHE statement
+     * Format: CLEAR CACHE
+     */
+    visitClearCache(ctx: ClearCacheContext): void;
+    /**
+     * Format REFRESH TABLE statement
+     * Format: REFRESH TABLE table_name
+     */
+    visitRefreshTable(ctx: RefreshTableContext): void;
+    /**
+     * Format REFRESH FUNCTION statement
+     * Format: REFRESH FUNCTION function_name
+     */
+    visitRefreshFunction(ctx: RefreshFunctionContext): void;
+    /**
+     * Format DESCRIBE FUNCTION statement
+     * Format: DESC|DESCRIBE FUNCTION [EXTENDED] function_name
+     */
+    visitDescribeFunction(ctx: DescribeFunctionContext): void;
+    /**
+     * Format DESCRIBE PROCEDURE statement
+     * Format: DESC|DESCRIBE PROCEDURE procedure_name
+     */
+    visitDescribeProcedure(ctx: DescribeProcedureContext): void;
+    /**
+     * Format DESCRIBE NAMESPACE statement
+     * Format: DESC|DESCRIBE (DATABASE|SCHEMA|NAMESPACE) [EXTENDED] identifier_reference
+     */
+    visitDescribeNamespace(ctx: DescribeNamespaceContext): void;
+    /**
+     * Format DESCRIBE RELATION statement (for tables, views, etc.)
+     * Format: DESC|DESCRIBE [TABLE] [EXTENDED|FORMATTED] table_name [PARTITION (...)] [col_name] [AS JSON]
+     */
+    visitDescribeRelation(ctx: DescribeRelationContext): void;
+    /**
+     * Format DESCRIBE QUERY statement
+     * Format: DESC|DESCRIBE [QUERY] query
+     * Rules:
+     *   1. DESC/DESCRIBE without QUERY - DESCRIBE on own line, query on next line
+     *   2. DESC/DESCRIBE with QUERY - DESCRIBE QUERY on own line, query on next line
+     * Expected format:
+     *   DESCRIBE QUERY
+     *   SELECT ...
+     * Or:
+     *   DESCRIBE
+     *   SELECT ...
+     */
+    visitDescribeQuery(ctx: DescribeQueryContext): void;
+    /**
+     * Format COMMENT ON NAMESPACE statement
+     * Format: COMMENT ON NAMESPACE identifier IS 'comment text'
+     * Rules:
+     * - COMMENT ON 与对象类型间使用单个空格
+     * - IS 关键字前后添加空格
+     * - 注释文本内容保持原样不变
+     */
+    visitCommentNamespace(ctx: CommentNamespaceContext): void;
+    /**
+     * Format COMMENT ON TABLE statement
+     * Format: COMMENT ON TABLE identifier IS 'comment text'
+     * Rules:
+     * - COMMENT ON 与对象类型间使用单个空格
+     * - IS 关键字前后添加空格
+     * - 注释文本内容保持原样不变
+     */
+    visitCommentTable(ctx: CommentTableContext): void;
+    /**
+     * Format MERGE INTO statement
+     * Format:
+     * MERGE INTO target_table t
+     * USING source_table s
+     * ON t.id = s.id
+     * WHEN MATCHED THEN UPDATE SET t.name = s.name
+     */
+    /**
+     * Format pipe operator statement
+     * The pipe operator (|> or single |) passes the result of the left query to the right side operation.
+     *
+     * Format rules based on pipe.sql:
+     * - `|>` or `|` starts on a new line with proper indentation
+     * - Pipe operator is followed by the operation keyword on the same line (no newline before keyword)
+     * - Content after the operation keyword is indented (5 spaces from line start)
+     *
+     * Example:
+     * table t
+     * |> select
+     *      x,
+     *      y;
+     */
+    visitOperatorPipeStatement(ctx: OperatorPipeStatementContext): void;
+    private getPipeStepKind;
+    private restorePipeFormattingState;
+    private getPipeStepFormattingBridge;
+    private createPipeStepFormattingContext;
+    /**
+     * Format pipe operator right side
+     * Handles various operation types: SELECT, WHERE, EXTEND, SET, DROP, AS, AGGREGATE, JOIN,
+     * UNION/INTERSECT/EXCEPT, ORDER BY/LIMIT, PIVOT/UNPIVOT
+     *
+     * Format rules based on pipe.sql:
+     * - Operation keyword follows `|>` on the same line (handled by visitOperatorPipeStatement)
+     * - Content after keyword is indented on new lines (5 spaces from line start for top-level)
+     * - GROUP BY in AGGREGATE aligns with `|>` (3 spaces indent)
+     *
+     * Key design: Set dynamic indent base so all nested structures automatically get correct indentation
+     */
+    visitOperatorPipeRightSide(ctx: OperatorPipeRightSideContext): void;
+    /**
+     * Format pipe operator SET assignment sequence
+     * Format:
+     * |> SET
+     *      col1 = expr1,
+     *      col2 = expr2;
+     */
+    visitOperatorPipeSetAssignmentSeq(ctx: OperatorPipeSetAssignmentSeqContext): void;
+    /**
+     * Format USE statement
+     * Format: USE database_name
+     * Simple statement - keep formatting as-is
+     */
+    visitUse(ctx: UseContext): void;
+    /**
+     * Format USE NAMESPACE statement
+     * Format: USE NAMESPACE catalog.database
+     * Simple statement - keep formatting as-is
+     */
+    visitUseNamespace(ctx: UseNamespaceContext): void;
+    /**
+     * Format SET CATALOG statement
+     * Format: SET CATALOG catalog_name
+     * Simple statement - keep formatting as-is
+     */
+    visitSetCatalog(ctx: SetCatalogContext): void;
+    /**
+     * Format SHOW NAMESPACES statement
+     * Format: SHOW NAMESPACES [FROM catalog] [LIKE 'pattern']
+     */
+    visitShowNamespaces(ctx: ShowNamespacesContext): void;
+    /**
+     * Format SHOW TABLES statement
+     * Format: SHOW TABLES [FROM database] [LIKE 'pattern']
+     */
+    visitShowTables(ctx: ShowTablesContext): void;
+    /**
+     * Format SHOW TABLE EXTENDED statement
+     * Format: SHOW TABLE EXTENDED [FROM database] LIKE 'pattern' [PARTITION (...)]
+     */
+    visitShowTableExtended(ctx: ShowTableExtendedContext): void;
+    /**
+     * Format SHOW TBLPROPERTIES statement
+     * Format: SHOW TBLPROPERTIES table_name [('key')]
+     */
+    visitShowTblProperties(ctx: ShowTblPropertiesContext): void;
+    /**
+     * Format SHOW COLUMNS statement
+     * Format: SHOW COLUMNS FROM table_name [FROM database]
+     */
+    visitShowColumns(ctx: ShowColumnsContext): void;
+    /**
+     * Format SHOW VIEWS statement
+     * Format: SHOW VIEWS [FROM database] [LIKE 'pattern']
+     */
+    visitShowViews(ctx: ShowViewsContext): void;
+    /**
+     * Format SHOW PARTITIONS statement
+     * Format: SHOW PARTITIONS table_name [PARTITION (...)]
+     */
+    visitShowPartitions(ctx: ShowPartitionsContext): void;
+    /**
+     * Format SHOW FUNCTIONS statement
+     * Format: SHOW [USER|SYSTEM|ALL] FUNCTIONS [FROM database] [LIKE 'pattern']
+     */
+    visitShowFunctions(ctx: ShowFunctionsContext): void;
+    /**
+     * Format SHOW PROCEDURES statement
+     * Format: SHOW PROCEDURES [FROM database]
+     */
+    visitShowProcedures(ctx: ShowProceduresContext): void;
+    /**
+     * Format SHOW CREATE TABLE statement
+     * Format: SHOW CREATE TABLE table_name [AS SERDE]
+     */
+    visitShowCreateTable(ctx: ShowCreateTableContext): void;
+    /**
+     * Format SHOW CURRENT NAMESPACE statement
+     * Format: SHOW CURRENT NAMESPACE
+     */
+    visitShowCurrentNamespace(ctx: ShowCurrentNamespaceContext): void;
+    /**
+     * Format SHOW CATALOGS statement
+     * Format: SHOW CATALOGS [LIKE 'pattern']
+     */
+    visitShowCatalogs(ctx: ShowCatalogsContext): void;
+    /**
+     * Format SET TIME ZONE statement
+     * Format: SET TIME ZONE 'timezone' | INTERVAL ... | LOCAL
+     */
+    visitSetTimeZone(ctx: SetTimeZoneContext): void;
+    /**
+     * Format SET variable statement
+     * Format: SET var1 = value1, var2 = value2
+     * Or: SET (var1, var2) = (SELECT ...)
+     */
+    visitSetVariable(ctx: SetVariableContext): void;
+    /**
+     * Format SET configuration (quoted)
+     * Format: SET 'spark.sql.shuffle.partitions' = '200'
+     */
+    visitSetQuotedConfiguration(ctx: SetQuotedConfigurationContext): void;
+    /**
+     * Format SET configuration
+     * Format: SET spark.sql.shuffle.partitions = 200
+     * Or: SET spark.sql.shuffle.partitions
+     */
+    visitSetConfiguration(ctx: SetConfigurationContext): void;
+    /**
+     * Format RESET configuration (quoted)
+     * Format: RESET 'spark.sql.shuffle.partitions'
+     */
+    visitResetQuotedConfiguration(ctx: ResetQuotedConfigurationContext): void;
+    /**
+     * Format RESET configuration
+     * Format: RESET spark.sql.shuffle.partitions
+     * Or: RESET (reset all)
+     */
+    visitResetConfiguration(ctx: ResetConfigurationContext): void;
+    /**
+     * Format REPLACE TABLE statement
+     * Same formatting as CREATE TABLE
+     * Format:
+     * REPLACE TABLE table_name (
+     *   col1 INT,
+     *   col2 STRING
+     * )
+     * USING parquet
+     * PARTITIONED BY (col1)
+     * AS SELECT ...
+     */
+    visitReplaceTable(ctx: ReplaceTableContext): void;
+    /**
+     * Format CREATE FUNCTION statement with parameters and return type
+     * Format:
+     * CREATE OR REPLACE FUNCTION func_name(
+     *   param1 TYPE DEFAULT value COMMENT 'desc',
+     *   param2 TYPE
+     * )
+     * RETURNS type
+     * LANGUAGE SQL
+     * DETERMINISTIC
+     * CONTAINS SQL
+     * CALLED ON NULL INPUT
+     * COMMENT 'description'
+     * SQL SECURITY INVOKER
+     * RETURN expression;
+     */
+    visitCreateUserDefinedFunction(ctx: CreateUserDefinedFunctionContext): void;
+    /**
+     * Format DECLARE variable statement
+     * Format: DECLARE [OR REPLACE] VARIABLE var_name TYPE DEFAULT value
+     */
+    visitCreateVariable(ctx: CreateVariableContext): void;
+    /**
+     * Format DROP VARIABLE statement
+     * Format: DROP TEMPORARY VARIABLE [IF EXISTS] var_name
+     */
+    visitDropVariable(ctx: DropVariableContext): void;
+    /**
+     * Format ALTER TABLE CLUSTER BY statement
+     * Format:
+     * ALTER TABLE
+     *   table_name
+     * CLUSTER BY
+     *   (col1, col2);
+     * Or: CLUSTER BY NONE
+     */
+    visitAlterClusterBy(ctx: AlterClusterByContext): void;
+    /**
+     * Format ALTER TABLE COLLATION statement
+     * Format:
+     * ALTER TABLE
+     *   table_name
+     * COLLATE
+     *   collation_name;
+     */
+    visitAlterTableCollation(ctx: AlterTableCollationContext): void;
+    /**
+     * Format ALTER TABLE ADD CONSTRAINT statement
+     * Format:
+     * ALTER TABLE
+     *   table_name
+     * ADD
+     *   CONSTRAINT constraint_name
+     *   UNIQUE (col1, col2);
+     */
+    visitAddTableConstraint(ctx: AddTableConstraintContext): void;
+    /**
+     * Format ALTER TABLE DROP CONSTRAINT statement
+     * Format:
+     * ALTER TABLE
+     *   table_name
+     * DROP CONSTRAINT IF EXISTS
+     *   constraint_name
+     * [RESTRICT | CASCADE];
+     */
+    visitDropTableConstraint(ctx: DropTableConstraintContext): void;
+    /**
+     * Format ALTER VIEW SCHEMA BINDING statement
+     * Format:
+     * ALTER VIEW
+     *   view_name
+     * WITH SCHEMA
+     *   BINDING | COMPENSATION | EVOLUTION | TYPE EVOLUTION;
+     */
+    visitAlterViewSchemaBinding(ctx: AlterViewSchemaBindingContext): void;
+    /**
+     * Format CREATE MATERIALIZED VIEW / STREAMING TABLE header
+     * Format: CREATE MATERIALIZED VIEW [IF NOT EXISTS] table_name
+     * Or: CREATE STREAMING TABLE [IF NOT EXISTS] table_name
+     */
+    visitCreatePipelineDatasetHeader(ctx: CreatePipelineDatasetHeaderContext): void;
+    /**
+     * Format CREATE MATERIALIZED VIEW / STREAMING TABLE statement
+     * Format (same as CREATE TABLE):
+     * CREATE MATERIALIZED VIEW table_name (
+     *   col1 INT,
+     *   col2 STRING
+     * )
+     * USING parquet
+     * TBLPROPERTIES (...)
+     * AS SELECT ...;
+     */
+    visitCreatePipelineDataset(ctx: CreatePipelineDatasetContext): void;
+    /**
+     * Format CREATE FLOW header
+     * Format: CREATE FLOW flow_name [COMMENT 'desc'] AS
+     */
+    visitCreatePipelineFlowHeader(ctx: CreatePipelineFlowHeaderContext): void;
+    /**
+     * Format CREATE FLOW statement
+     * Format:
+     * CREATE FLOW flow_name
+     *   COMMENT 'description'
+     * AS
+     *   INSERT INTO target_table
+     *   SELECT ...;
+     */
+    visitCreatePipelineInsertIntoFlow(ctx: CreatePipelineInsertIntoFlowContext): void;
+    /**
+     * Format DROP INDEX statement
+     * Format: DROP INDEX [IF EXISTS] index_name ON [TABLE] table_name
+     */
+    visitDropIndex(ctx: DropIndexContext): void;
+    /**
+     * Format REFRESH resource statement
+     * Format: REFRESH 'resource_path'
+     * Simple statement - keep as-is
+     */
+    visitRefreshResource(ctx: RefreshResourceContext): void;
+    /**
+     * Format ADD/LIST resource statement
+     * Format: ADD JAR 'path' | LIST FILE 'path'
+     * Simple statement - keep as-is
+     */
+    visitManageResource(ctx: ManageResourceContext): void;
+}
+//# sourceMappingURL=space-replacer-format.visitor.d.ts.map