rawsql-ts/dist/esm/transformers/WildcardColumnInferenceCollector.d.ts

High-performance SQL parser and AST analyzer written in TypeScript. Provides fast parsing and advanced transformation capabilities.

import { SelectQuery } from "../models/SelectQuery";
import { ClauseScopedColumnReferenceClause } from "./ClauseScopedColumnReferenceCollector";
/** Kind of named query boundary whose wildcard output is being inferred. */
export type WildcardColumnInferenceTargetKind = "cte" | "derivedTable";
/** Syntax form of the wildcard SELECT item that may supply required columns. */
export type WildcardColumnInferenceWildcardKind = "qualified" | "unqualified";
/** Conservative reason why a downstream requirement could not be assigned to one wildcard supplier. */
export type WildcardColumnInferenceUnresolvedReason = "duplicateOutputOwnership" | "multipleWildcardSuppliers" | "unqualifiedWildcardMultipleSources" | "noWildcardSupplier" | "unsupportedQueryShape";
/** Clause-scoped downstream reference that requires an output column from the target. */
export interface WildcardColumnInferenceRequiredBy {
    /** Clause that owns the downstream reference. */
    clause: ClauseScopedColumnReferenceClause;
    /** SQL text form of the downstream column reference. */
    qualifiedName: string;
    /** Namespace or alias used by the downstream reference, if present. */
    namespace: string | null;
    /** Output column name required by the downstream reference. */
    column: string;
}
/** Metadata for a wildcard SELECT item inside the target query. */
export interface WildcardColumnInferenceWildcard {
    /** Whether the wildcard was written as `*` or as a qualified form such as `a.*`. */
    kind: WildcardColumnInferenceWildcardKind;
    /** SELECT-list position of the wildcard item. */
    outputIndex: number;
    /** Source alias that the wildcard can safely be associated with, when known. */
    sourceAlias: string | null;
    /** Physical source name for the wildcard source, when it is statically visible. */
    sourceName: string | null;
}
/** Explicit non-wildcard output preserved alongside inferred wildcard requirements. */
export interface WildcardColumnInferenceExplicitColumn {
    /** Output name exposed by the explicit SELECT item. */
    outputName: string;
    /** Source alias for a simple qualified column expression, when uniquely known. */
    sourceAlias: string | null;
    /** Physical source name for a simple qualified column expression, when uniquely known. */
    sourceName: string | null;
    /** Source column name for a simple qualified column expression, when uniquely known. */
    sourceColumnName: string | null;
}
/** Resolved required column supplied by a single unambiguous wildcard. */
export interface WildcardColumnInferenceResolvedColumn {
    /** Output column name required from the target. */
    outputName: string;
    /** Source alias selected as the wildcard supplier. */
    sourceAlias: string | null;
    /** Physical source name selected as the wildcard supplier, when known. */
    sourceName: string | null;
    /** Source column name inferred from the downstream output requirement. */
    sourceColumnName: string;
    /** Wildcard SELECT item that supplies this required column. */
    wildcard: WildcardColumnInferenceWildcard;
    /** Distinct downstream clauses that required this column. */
    requiredByClause: ClauseScopedColumnReferenceClause[];
    /** Clause-scoped downstream references that required this column. */
    requiredBy: WildcardColumnInferenceRequiredBy[];
}
/** Required output column that could not be assigned to a single wildcard supplier. */
export interface WildcardColumnInferenceUnresolvedColumn {
    /** Output column name required from the target. */
    outputName: string;
    /** Conservative reason why inference did not choose a supplier. */
    reason: WildcardColumnInferenceUnresolvedReason;
    /** Candidate wildcard suppliers visible for this requirement. */
    candidateWildcards: WildcardColumnInferenceWildcard[];
    /** Distinct downstream clauses that required this column. */
    requiredByClause: ClauseScopedColumnReferenceClause[];
    /** Clause-scoped downstream references that required this column. */
    requiredBy: WildcardColumnInferenceRequiredBy[];
}
/** Metadata-only wildcard inference result for one CTE or derived table target. */
export interface WildcardColumnInferenceResult {
    /** Kind of target whose wildcard output was inspected. */
    targetKind: WildcardColumnInferenceTargetKind;
    /** CTE name for CTE targets, otherwise null. */
    targetName: string | null;
    /** Alias used by the downstream consumer when available. */
    targetAlias: string | null;
    /** Wildcard SELECT items found inside the target query. */
    wildcards: WildcardColumnInferenceWildcard[];
    /** Explicit non-wildcard outputs found inside the target query. */
    explicitColumns: WildcardColumnInferenceExplicitColumn[];
    /** Downstream requirements assigned to exactly one wildcard supplier. */
    requiredColumns: WildcardColumnInferenceResolvedColumn[];
    /** Downstream requirements that were intentionally left unresolved. */
    unresolvedColumns: WildcardColumnInferenceUnresolvedColumn[];
}
/**
 * Infers the subset of wildcard columns required by downstream references.
 *
 * This collector only returns metadata. It does not rewrite SQL and does not attempt full
 * table-column discovery. When ownership is ambiguous, the requirement is reported as unresolved.
 */
export declare class WildcardColumnInferenceCollector {
    private readonly clauseCollector;
    private readonly requirements;
    private readonly visitedQueries;
    private nextObjectId;
    private objectIds;
    /**
     * Collect wildcard column inference metadata for CTEs and derived tables visible in a SELECT query.
     */
    collect(query: SelectQuery): WildcardColumnInferenceResult[];
    private collectFromSelectQuery;
    private collectCteQuery;
    private collectConsumerRequirements;
    private collectConsumerTargets;
    private createCteTarget;
    private createDerivedTableTarget;
    private collectNestedSources;
    private addRequirement;
    private inferTarget;
    private collectTargetOutputMetadata;
    private collectWildcardMetadata;
    private createUnresolved;
    private flattenReferences;
    private createRequiredBy;
    private collectRequiredByClauses;
    private getTargetMatchNames;
    private getUniqueTarget;
    private getUniqueSource;
    private getSourceMatchNames;
    private getSourceName;
    private collectLeadingCommonTables;
    private mergeCommonTables;
    private getObjectId;
    private isSelectQuery;
}