polyglot-sql 0.13.4__cp315-cp315-win_amd64.whl

polyglot_sql/__init__.pyi

@@ -0,0 +1,2042 @@
+from typing import Any as TypingAny, TypedDict, overload
+from .analysis_types import (
+    AnalyzeQueryOptions as AnalyzeQueryOptions,
+    ValidationSchema as ValidationSchema,
+    SchemaTable as SchemaTable,
+    SchemaColumn as SchemaColumn,
+    SchemaColumnReference as SchemaColumnReference,
+    SchemaTableReference as SchemaTableReference,
+    SchemaForeignKey as SchemaForeignKey,
+    QueryAnalysis as QueryAnalysis,
+    QuerySourceSpan as QuerySourceSpan,
+    ProjectionFact as ProjectionFact,
+    TransformFunctionFact as TransformFunctionFact,
+    CteFact as CteFact,
+    RelationFact as RelationFact,
+    StarProjectionFact as StarProjectionFact,
+    SetOperationFact as SetOperationFact,
+    SetOperationBranchFact as SetOperationBranchFact,
+    ColumnUseFact as ColumnUseFact,
+    ColumnUseReferenceFact as ColumnUseReferenceFact,
+    ColumnReferenceFact as ColumnReferenceFact,
+    ReferenceConfidence as ReferenceConfidence,
+    ProjectionNullability as ProjectionNullability,
+    TransformKind as TransformKind,
+    ColumnUseContext as ColumnUseContext,
+    FunctionNameCase as FunctionNameCase,
+    FunctionSignature as FunctionSignature,
+    FunctionCatalogEntry as FunctionCatalogEntry,
+    FunctionCatalogSpec as FunctionCatalogSpec,
+)
+
+
+class ComplexityGuardOptions(TypedDict, total=False):
+    maxParserDepth: int | None
+    maxInputBytes: int | None
+    maxTokens: int | None
+    maxAstNodes: int | None
+    maxAstDepth: int | None
+    maxParenthesisDepth: int | None
+    maxFunctionCallDepth: int | None
+
+
+class PolyglotError(Exception):
+    """Base exception for all polyglot-sql errors."""
+    ...
+
+class ParseError(PolyglotError):
+    """Raised when SQL parsing fails."""
+    ...
+
+class GenerateError(PolyglotError):
+    """Raised when SQL generation from an AST fails."""
+    ...
+
+class TranspileError(PolyglotError):
+    """Raised when SQL transpilation fails."""
+    ...
+
+class ValidationError(PolyglotError):
+    """Raised when SQL validation encounters a fatal error."""
+    ...
+
+class ColumnResolutionError(TranspileError):
+    """Raised when a requested output name or zero-based ordinal cannot be resolved."""
+
+    reason: str
+    column: str | None
+    ordinal: int | None
+
+
+class ValidationErrorInfo:
+    """Details about a single validation finding."""
+
+    @property
+    def message(self) -> str:
+        """Human-readable description of the issue."""
+        ...
+
+    @property
+    def line(self) -> int:
+        """1-based line number where the issue was found."""
+        ...
+
+    @property
+    def col(self) -> int:
+        """1-based column number where the issue was found."""
+        ...
+
+    @property
+    def start(self) -> int | None:
+        """Zero-based Unicode character offset, or None when unavailable."""
+        ...
+
+    @property
+    def end(self) -> int | None:
+        """Exclusive Unicode character offset, or None when unavailable."""
+        ...
+
+    @property
+    def code(self) -> str:
+        """Machine-readable error code (e.g. ``"E001"``)."""
+        ...
+
+    @property
+    def severity(self) -> str:
+        """Severity level: ``"error"`` or ``"warning"``."""
+        ...
+
+
+class ValidationResult:
+    """Result returned by validate and validate_with_schema."""
+
+    @property
+    def valid(self) -> bool:
+        """True when no errors were found; warnings do not invalidate SQL."""
+        ...
+
+    @property
+    def errors(self) -> list[ValidationErrorInfo]:
+        """List of validation findings (may be empty when valid)."""
+        ...
+
+    def __bool__(self) -> bool:
+        """Allows ``if validate(...):`` usage."""
+        ...
+
+
+class Expression:
+    """Base class for all AST nodes.
+
+    Every parsed SQL expression is represented as an ``Expression`` subclass
+    (e.g. ``Select``, ``Column``, ``Literal``).  All subclasses share the
+    properties and methods defined here.
+
+    The API mirrors `sqlglot <https://github.com/tobymao/sqlglot>`_ so that
+    porting code between the two libraries is straightforward.
+
+    Example::
+
+        import polyglot_sql
+
+        ast = polyglot_sql.parse_one("SELECT a AS x, b FROM t WHERE c > 1")
+
+        # Property access
+        ast.expressions          # [Column(a), Column(b)]  (AS x is an Alias wrapping Column)
+        ast.find(polyglot_sql.Column).name   # "a"
+
+        # Type dispatch
+        isinstance(ast, polyglot_sql.Select)  # True
+
+        # Traversal
+        for node in ast.walk():
+            print(node.kind, node.name)
+    """
+
+    # ── Core identifiers ─────────────────────────────────────────────
+
+    @property
+    def kind(self) -> str:
+        """Snake-case variant name, e.g. ``"select"``, ``"column"``, ``"add"``.
+
+        Matches the key in :meth:`to_dict` output and corresponds to the
+        serde tag of the underlying Rust enum variant.
+        """
+        ...
+
+    @property
+    def key(self) -> str:
+        """Alias for :attr:`kind` (sqlglot compatibility)."""
+        ...
+
+    @property
+    def tree_depth(self) -> int:
+        """Maximum depth of the sub-tree rooted at this node (0 for leaves)."""
+        ...
+
+    # ── SQL generation ───────────────────────────────────────────────
+
+    def sql(self, dialect: str | None = None, *, pretty: bool = False) -> str:
+        """Generate a SQL string for this expression.
+
+        Args:
+            dialect: Target dialect (e.g. ``"postgres"``, ``"mysql"``).
+                     Defaults to ``"generic"`` (dialect-agnostic SQL).
+            pretty: When ``True``, emit formatted SQL with indentation.
+
+        Returns:
+            The SQL string.
+
+        Raises:
+            GenerateError: If generation fails.
+            ValueError: If the dialect name is unknown.
+        """
+        ...
+
+    # ── SQLGlot-compatible builder subset ───────────────────────────
+
+    def eq(self, other: TypingAny) -> Expression: ...
+    def neq(self, other: TypingAny) -> Expression: ...
+    def lt(self, other: TypingAny) -> Expression: ...
+    def lte(self, other: TypingAny) -> Expression: ...
+    def gt(self, other: TypingAny) -> Expression: ...
+    def gte(self, other: TypingAny) -> Expression: ...
+    def and_(self, other: TypingAny) -> Expression: ...
+    def or_(self, other: TypingAny) -> Expression: ...
+    def xor(self, other: TypingAny) -> Expression: ...
+    def not_(self) -> Expression: ...
+    def is_(self, other: TypingAny) -> Expression: ...
+    def is_null(self) -> Expression: ...
+    def is_not_null(self) -> Expression: ...
+    def like(self, pattern: TypingAny) -> Expression: ...
+    def ilike(self, pattern: TypingAny) -> Expression: ...
+    def rlike(self, pattern: TypingAny) -> Expression: ...
+    def between(self, low: TypingAny, high: TypingAny) -> Expression: ...
+    def isin(self, *expressions: TypingAny) -> Expression: ...
+    def not_in(self, *expressions: TypingAny) -> Expression: ...
+    def as_(self, alias: str) -> Expression: ...
+    def cast(self, to: str) -> Expression: ...
+    def asc(self) -> Expression: ...
+    def desc(self) -> Expression: ...
+    def select(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def from_(self, expression: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def join(self, expression: TypingAny, on: TypingAny = None, join_type: str = "", dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def where(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def group_by(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def having(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def order_by(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def sort_by(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def limit(self, expression: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def offset(self, expression: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def distinct(self, distinct: bool = True, copy: bool = True) -> Expression: ...
+    def qualify(self, *expressions: TypingAny, append: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def lateral_view(self, expression: TypingAny, table_alias: str | None = None, column_aliases: list[str] | None = None, outer: bool = False, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def window(self, name: str, partition_by: tuple[TypingAny, ...] | None = None, order_by: tuple[TypingAny, ...] | None = None, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def for_update(self, copy: bool = True) -> Expression: ...
+    def for_share(self, copy: bool = True) -> Expression: ...
+    def hint(self, text: str, copy: bool = True) -> Expression: ...
+    def ctas(self, table: str, replace: bool = False, temporary: bool = False, copy: bool = True) -> Expression: ...
+    def subquery(self, alias: str | None = None, copy: bool = True) -> Expression: ...
+    def union(self, expression: TypingAny, distinct: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def intersect(self, expression: TypingAny, distinct: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def except_(self, expression: TypingAny, distinct: bool = True, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def when(self, condition: TypingAny, result: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def else_(self, result: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def set_(self, assignments: dict[str, TypingAny], copy: bool = True) -> Expression: ...
+    def columns(self, columns: list[str], copy: bool = True) -> Expression: ...
+    def values(self, *values: TypingAny, copy: bool = True) -> Expression: ...
+    def query(self, query: TypingAny, copy: bool = True) -> Expression: ...
+    def merge_using(self, source: TypingAny, on: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def when_matched_update(self, assignments: dict[str, TypingAny], condition: TypingAny = None, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def when_matched_delete(self, condition: TypingAny = None, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def when_not_matched_insert(self, columns: list[str], values: tuple[TypingAny, ...], condition: TypingAny = None, dialect: str | None = None, copy: bool = True) -> Expression: ...
+    def __add__(self, other: TypingAny) -> Expression: ...
+    def __sub__(self, other: TypingAny) -> Expression: ...
+    def __mul__(self, other: TypingAny) -> Expression: ...
+    def __truediv__(self, other: TypingAny) -> Expression: ...
+    def __mod__(self, other: TypingAny) -> Expression: ...
+    def __and__(self, other: TypingAny) -> Expression: ...
+    def __or__(self, other: TypingAny) -> Expression: ...
+    def __xor__(self, other: TypingAny) -> Expression: ...
+    def __invert__(self) -> Expression: ...
+    def __neg__(self) -> Expression: ...
+
+    # ── Serialization ────────────────────────────────────────────────
+
+    def to_dict(self) -> dict[str, TypingAny]:
+        """Serialize this node to a nested Python dict (JSON-like).
+
+        The top-level key is the :attr:`kind` string and the value is a dict
+        of the node's fields.
+
+        Example::
+
+            polyglot_sql.parse_one("SELECT 1").to_dict()
+            # {"select": {"expressions": [{"literal": {"value": "1", ...}}], ...}}
+        """
+        ...
+
+    def arg(self, name: str) -> TypingAny:
+        """Look up a single field by name from the serialized payload.
+
+        Returns a Python object: child ``Expression`` objects are wrapped
+        automatically; scalars are returned as ``str`` / ``int`` / ``bool``;
+        missing keys return ``None``.
+        """
+        ...
+
+    # ── Child accessors (no serialization, fast) ─────────────────────
+
+    @property
+    def this(self) -> Expression | None:
+        """Primary child expression.
+
+        For unary operators and functions this is the operand.
+        For binary operators this is the *left* operand.
+        For ``Alias`` this is the aliased expression.
+        For clauses (``Where``, ``Having``, ...) this is the predicate.
+
+        Returns ``None`` for leaf nodes and types without a primary child
+        (e.g. ``Select``, ``Identifier``, ``Literal``).
+        """
+        ...
+
+    @property
+    def expression(self) -> Expression | None:
+        """Secondary child expression.
+
+        For binary operators this is the *right* operand.
+        For ``BinaryFunc`` types (``Power``, ``NullIf``, ...) this is the
+        second argument.
+
+        Returns ``None`` for most other node types.
+        """
+        ...
+
+    @property
+    def expressions(self) -> list[Expression]:
+        """List of child expressions.
+
+        - ``Select.expressions`` — the selected columns
+        - ``Function.expressions`` / ``AggregateFunction.expressions`` — arguments
+        - ``From.expressions`` — tables in the FROM clause
+        - ``In.expressions`` — values in an IN list
+        - ``Array`` / ``Tuple`` / ``Coalesce`` / ``Greatest`` / ``Least`` — elements
+
+        Returns an empty list for node types without a list child.
+        """
+        ...
+
+    @property
+    def args(self) -> dict[str, TypingAny]:
+        """All fields as a dict (uses serialization, not on the hot path).
+
+        Keys are field names, values are Python objects.
+        """
+        ...
+
+    @property
+    def name(self) -> str:
+        """Short name of this expression.
+
+        - ``Column`` → column name (e.g. ``"id"``)
+        - ``Table`` → table name (e.g. ``"users"``)
+        - ``Identifier`` → identifier text
+        - ``Literal`` → literal value as string (e.g. ``"42"``)
+        - ``Function`` / ``AggregateFunction`` → function name
+        - ``Star`` → ``"*"``
+        - ``Alias`` → delegates to the aliased expression's name
+        - ``Boolean`` → ``"TRUE"`` / ``"FALSE"``
+        - ``Null`` → ``"NULL"``
+
+        Returns ``""`` for types without a meaningful name.
+        """
+        ...
+
+    @property
+    def alias(self) -> str:
+        """Alias name, if this expression has one.
+
+        - ``Alias`` → the alias identifier (e.g. ``"x"`` in ``a AS x``)
+        - ``Table`` → table alias if present
+        - ``Subquery`` → subquery alias if present
+
+        Returns ``""`` otherwise.
+        """
+        ...
+
+    @property
+    def alias_or_name(self) -> str:
+        """Returns :attr:`alias` if non-empty, else :attr:`name`."""
+        ...
+
+    @property
+    def output_name(self) -> str:
+        """The name this expression produces in a result set.
+
+        - ``Alias`` → the alias identifier
+        - ``Column`` → the column name
+        - ``Literal`` → the literal value
+        - ``Star`` → ``"*"``
+
+        Returns ``""`` for types without an output name.
+        """
+        ...
+
+    @property
+    def comments(self) -> list[str]:
+        """SQL comments attached to this node (trailing or leading)."""
+        ...
+
+    @property
+    def type_(self) -> Expression | None:
+        """Inferred data type (a ``DataType`` expression), or ``None``."""
+        ...
+
+    # ── Type predicates ──────────────────────────────────────────────
+
+    @property
+    def is_string(self) -> bool:
+        """``True`` if this is a string literal."""
+        ...
+
+    @property
+    def is_number(self) -> bool:
+        """``True`` if this is a numeric literal (or negated numeric literal)."""
+        ...
+
+    @property
+    def is_int(self) -> bool:
+        """``True`` if this is an integer literal (or negated integer literal)."""
+        ...
+
+    @property
+    def is_star(self) -> bool:
+        """``True`` if this is a ``*`` (star / wildcard) expression."""
+        ...
+
+    def is_leaf(self) -> bool:
+        """``True`` if this node has no children."""
+        ...
+
+    # ── Parent tracking ──────────────────────────────────────────────
+
+    @property
+    def parent(self) -> Expression | None:
+        """The parent node, or ``None`` for root nodes.
+
+        Parent references are set lazily when accessing children via
+        :attr:`this`, :attr:`expression`, :attr:`expressions`,
+        or :meth:`children`.
+        """
+        ...
+
+    @property
+    def depth(self) -> int:
+        """Number of parent hops to the root (0 for root nodes)."""
+        ...
+
+    def root(self) -> Expression:
+        """Walk the parent chain and return the root node."""
+        ...
+
+    def find_ancestor(self, *types: type[Expression] | str) -> Expression | None:
+        """Walk the parent chain and return the first ancestor matching any of *types*.
+
+        Args:
+            *types: One or more ``Expression`` subclasses or snake-case kind strings.
+
+        Returns:
+            The matching ancestor, or ``None``.
+        """
+        ...
+
+    @property
+    def parent_select(self) -> Expression | None:
+        """Shorthand for ``find_ancestor(Select)``."""
+        ...
+
+    # ── Traversal ────────────────────────────────────────────────────
+
+    def children(self) -> list[Expression]:
+        """Immediate child expressions (with parent references set)."""
+        ...
+
+    def walk(self, order: str = "dfs") -> list[Expression]:
+        """Traverse the entire sub-tree.
+
+        Args:
+            order: ``"dfs"`` (depth-first, default) or ``"bfs"`` (breadth-first).
+
+        Returns:
+            All nodes including ``self``.
+
+        Raises:
+            ValueError: If *order* is not ``"dfs"`` or ``"bfs"``.
+        """
+        ...
+
+    def find(self, *types: type[Expression] | str) -> Expression | None:
+        """Find the first descendant matching any of *types* (DFS, skips self).
+
+        Args:
+            *types: One or more ``Expression`` subclasses (e.g. ``Column``)
+                    or snake-case kind strings (e.g. ``"column"``).
+
+        Returns:
+            The first matching descendant, or ``None``.
+
+        Example::
+
+            ast = polyglot_sql.parse_one("SELECT a, 1 FROM t")
+            ast.find(polyglot_sql.Column)          # Column(a)
+            ast.find("literal")                    # Literal(1)
+            ast.find(polyglot_sql.Column, polyglot_sql.Literal)  # Column(a) — first match
+        """
+        ...
+
+    def find_all(self, *types: type[Expression] | str) -> list[Expression]:
+        """Find all descendants matching any of *types* (DFS, skips self).
+
+        Same argument format as :meth:`find`.
+        """
+        ...
+
+    def unnest(self) -> Expression:
+        """Recursively unwrap ``Paren`` wrappers. Returns self if not a ``Paren``."""
+        ...
+
+    def unalias(self) -> Expression:
+        """Unwrap one ``Alias`` layer. Returns self if not an ``Alias``."""
+        ...
+
+    def flatten(self) -> list[Expression]:
+        """Flatten same-variant chains into a list.
+
+        For example, ``And(And(a, b), c)`` flattens to ``[a, b, c]``.
+        Useful for normalizing chained ``AND`` / ``OR`` predicates.
+        """
+        ...
+
+    def iter_expressions(self) -> list[Expression]:
+        """Alias for :meth:`children` (sqlglot compatibility)."""
+        ...
+
+    def text(self, key: str) -> str:
+        """Extract a field as a plain string.
+
+        Looks up *key* in the serialized payload and returns:
+        - Strings and numbers directly
+        - Nested expressions via their :attr:`name`
+        - Nested structs (e.g. ``Identifier``) via their ``name`` field
+        - ``""`` for missing keys
+        """
+        ...
+
+
+# Expression subclasses — one per AST variant.
+# All inherit from Expression and share its methods.
+class Abs(Expression): ...
+class Add(Expression): ...
+class AddMonths(Expression): ...
+class AddPartition(Expression): ...
+class Adjacent(Expression): ...
+class AggregateFunction(Expression): ...
+class AIAgg(Expression): ...
+class AIClassify(Expression): ...
+class AlgorithmProperty(Expression): ...
+class Alias(Expression): ...
+class Aliases(Expression): ...
+class All(Expression): ...
+class AllowedValuesProperty(Expression): ...
+class AlterColumn(Expression): ...
+class AlterIndex(Expression): ...
+class AlterSequence(Expression): ...
+class AlterSession(Expression): ...
+class AlterSet(Expression): ...
+class AlterSortKey(Expression): ...
+class AlterTable(Expression): ...
+class AlterView(Expression): ...
+class Analyze(Expression): ...
+class AnalyzeDelete(Expression): ...
+class AnalyzeHistogram(Expression): ...
+class AnalyzeListChainedRows(Expression): ...
+class AnalyzeSample(Expression): ...
+class AnalyzeStatistics(Expression): ...
+class AnalyzeValidate(Expression): ...
+class AnalyzeWith(Expression): ...
+class And(Expression): ...
+class Annotated(Expression): ...
+class Anonymous(Expression): ...
+class AnonymousAggFunc(Expression): ...
+class Any(Expression): ...
+class AnyValue(Expression): ...
+class Apply(Expression): ...
+class ApproxCountDistinct(Expression): ...
+class ApproxDistinct(Expression): ...
+class ApproxPercentile(Expression): ...
+class ApproxPercentileEstimate(Expression): ...
+class ApproxQuantile(Expression): ...
+class ApproxQuantiles(Expression): ...
+class ApproxTopK(Expression): ...
+class ApproxTopKAccumulate(Expression): ...
+class ApproxTopKCombine(Expression): ...
+class ApproxTopKEstimate(Expression): ...
+class ApproxTopSum(Expression): ...
+class ArgMax(Expression): ...
+class ArgMin(Expression): ...
+class Array(Expression): ...
+class ArrayAgg(Expression): ...
+class ArrayAll(Expression): ...
+class ArrayAny(Expression): ...
+class ArrayAppend(Expression): ...
+class ArrayCompact(Expression): ...
+class ArrayConcat(Expression): ...
+class ArrayConcatAgg(Expression): ...
+class ArrayConstructCompact(Expression): ...
+class ArrayContainedBy(Expression): ...
+class ArrayContains(Expression): ...
+class ArrayContainsAll(Expression): ...
+class ArrayDistinct(Expression): ...
+class ArrayExcept(Expression): ...
+class ArrayFilter(Expression): ...
+class ArrayFlatten(Expression): ...
+class ArrayFunc(Expression): ...
+class ArrayIntersect(Expression): ...
+class ArrayJoin(Expression): ...
+class ArrayLength(Expression): ...
+class ArrayOverlaps(Expression): ...
+class ArrayPosition(Expression): ...
+class ArrayPrepend(Expression): ...
+class ArrayRemove(Expression): ...
+class ArrayReverse(Expression): ...
+class ArraySize(Expression): ...
+class ArraySlice(Expression): ...
+class ArraySort(Expression): ...
+class ArraySum(Expression): ...
+class ArrayToString(Expression): ...
+class ArrayTransform(Expression): ...
+class ArrayUnion(Expression): ...
+class ArrayUniqueAgg(Expression): ...
+class ArrayZip(Expression): ...
+class Ascii(Expression): ...
+class Asin(Expression): ...
+class Acos(Expression): ...
+class AssumeColumnConstraint(Expression): ...
+class Atan(Expression): ...
+class Atan2(Expression): ...
+class AtIndex(Expression): ...
+class AtTimeZone(Expression): ...
+class Attach(Expression): ...
+class AttachOption(Expression): ...
+class AutoIncrementColumnConstraint(Expression): ...
+class AutoIncrementProperty(Expression): ...
+class AutoRefreshProperty(Expression): ...
+class Avg(Expression): ...
+class BackupProperty(Expression): ...
+class Base64DecodeBinary(Expression): ...
+class Base64DecodeString(Expression): ...
+class Base64Encode(Expression): ...
+class Between(Expression): ...
+class BitwiseAnd(Expression): ...
+class BitwiseAndAgg(Expression): ...
+class BitwiseCount(Expression): ...
+class BitwiseLeftShift(Expression): ...
+class BitwiseNot(Expression): ...
+class BitwiseOr(Expression): ...
+class BitwiseOrAgg(Expression): ...
+class BitwiseRightShift(Expression): ...
+class BitwiseXor(Expression): ...
+class BitwiseXorAgg(Expression): ...
+class BlockCompressionProperty(Expression): ...
+class BoolXorAgg(Expression): ...
+class Boolean(Expression): ...
+class Booland(Expression): ...
+class Boolor(Expression): ...
+class BracedWildcard(Expression): ...
+class BuildProperty(Expression): ...
+class ByteLength(Expression): ...
+class ByteString(Expression): ...
+class Cache(Expression): ...
+class Cardinality(Expression): ...
+class Case(Expression): ...
+class CaseSpecificColumnConstraint(Expression): ...
+class Cast(Expression): ...
+class CastToStrType(Expression): ...
+class Cbrt(Expression): ...
+class Ceil(Expression): ...
+class Changes(Expression): ...
+class CharFunc(Expression): ...
+class CharacterSetColumnConstraint(Expression): ...
+class CharacterSetProperty(Expression): ...
+class CheckColumnConstraint(Expression): ...
+class CheckJson(Expression): ...
+class CheckXml(Expression): ...
+class ChecksumProperty(Expression): ...
+class Chr(Expression): ...
+class Clone(Expression): ...
+class ClusterBy(Expression): ...
+class ClusterByColumnsProperty(Expression): ...
+class ClusteredByProperty(Expression): ...
+class Coalesce(Expression): ...
+class Collation(Expression): ...
+class CollateProperty(Expression): ...
+class Column(Expression): ...
+class ColumnConstraint(Expression): ...
+class ColumnDef(Expression): ...
+class ColumnPosition(Expression): ...
+class ColumnPrefix(Expression): ...
+class Columns(Expression): ...
+class CombinedAggFunc(Expression): ...
+class CombinedParameterizedAgg(Expression): ...
+class Command(Expression): ...
+class Comment(Expression): ...
+class CommentColumnConstraint(Expression): ...
+class Commit(Expression): ...
+class Comprehension(Expression): ...
+class Compress(Expression): ...
+class CompressColumnConstraint(Expression): ...
+class ComputedColumnConstraint(Expression): ...
+class Concat(Expression): ...
+class ConcatWs(Expression): ...
+class ConditionalInsert(Expression): ...
+class Connect(Expression): ...
+class ConnectByRoot(Expression): ...
+class Constraint(Expression): ...
+class Contains(Expression): ...
+class Convert(Expression): ...
+class ConvertTimezone(Expression): ...
+class ConvertToCharset(Expression): ...
+class Copy(Expression): ...
+class CopyParameter(Expression): ...
+class Corr(Expression): ...
+class Cos(Expression): ...
+class CosineDistance(Expression): ...
+class Count(Expression): ...
+class CountIf(Expression): ...
+class CovarPop(Expression): ...
+class CovarSamp(Expression): ...
+class CreateDatabase(Expression): ...
+class CreateFunction(Expression): ...
+class CreateIndex(Expression): ...
+class CreateProcedure(Expression): ...
+class CreateSchema(Expression): ...
+class CreateSequence(Expression): ...
+class CreateTable(Expression): ...
+class CreateTrigger(Expression): ...
+class CreateType(Expression): ...
+class CreateView(Expression): ...
+class FlashbackTable(Expression): ...
+class Credentials(Expression): ...
+class CredentialsProperty(Expression): ...
+class Cte(Expression): ...
+class Cube(Expression): ...
+class CumeDist(Expression): ...
+class CurrentDate(Expression): ...
+class CurrentDatetime(Expression): ...
+class CurrentSchema(Expression): ...
+class CurrentSchemas(Expression): ...
+class CurrentTime(Expression): ...
+class CurrentTimestamp(Expression): ...
+class CurrentTimestampLTZ(Expression): ...
+class CurrentUser(Expression): ...
+class DPipe(Expression): ...
+class DataBlocksizeProperty(Expression): ...
+class DataDeletionProperty(Expression): ...
+class DataType(Expression): ...
+class Date(Expression): ...
+class DateAdd(Expression): ...
+class DateBin(Expression): ...
+class DateDiff(Expression): ...
+class DateFormat(Expression): ...
+class DateFormatColumnConstraint(Expression): ...
+class DateFromParts(Expression): ...
+class DateFromUnixDate(Expression): ...
+class DateStrToDate(Expression): ...
+class DateSub(Expression): ...
+class DateToDateStr(Expression): ...
+class DateToDi(Expression): ...
+class DateTrunc(Expression): ...
+class Datetime(Expression): ...
+class DatetimeAdd(Expression): ...
+class DatetimeDiff(Expression): ...
+class DatetimeSub(Expression): ...
+class DatetimeTrunc(Expression): ...
+class Day(Expression): ...
+class DayOfMonth(Expression): ...
+class DayOfWeek(Expression): ...
+class DayOfWeekIso(Expression): ...
+class DayOfYear(Expression): ...
+class Dayname(Expression): ...
+class Declare(Expression): ...
+class DeclareItem(Expression): ...
+class Decode(Expression): ...
+class DecodeCase(Expression): ...
+class DecompressBinary(Expression): ...
+class DecompressString(Expression): ...
+class Decrypt(Expression): ...
+class DecryptRaw(Expression): ...
+class DefaultColumnConstraint(Expression): ...
+class DefinerProperty(Expression): ...
+class Degrees(Expression): ...
+class Delete(Expression): ...
+class DenseRank(Expression): ...
+class Describe(Expression): ...
+class Detach(Expression): ...
+class DictProperty(Expression): ...
+class DictRange(Expression): ...
+class DiToDate(Expression): ...
+class Directory(Expression): ...
+class DistKeyProperty(Expression): ...
+class DistStyleProperty(Expression): ...
+class DistributeBy(Expression): ...
+class DistributedByProperty(Expression): ...
+class Div(Expression): ...
+class Dot(Expression): ...
+class DotProduct(Expression): ...
+class DropDatabase(Expression): ...
+class DropFunction(Expression): ...
+class DropIndex(Expression): ...
+class DropNamespace(Expression): ...
+class DropPartition(Expression): ...
+class DropProcedure(Expression): ...
+class DropSchema(Expression): ...
+class DropSequence(Expression): ...
+class DropTable(Expression): ...
+class DropTrigger(Expression): ...
+class DropType(Expression): ...
+class DropView(Expression): ...
+class DuplicateKeyProperty(Expression): ...
+class ElementAt(Expression): ...
+class Elt(Expression): ...
+class Encode(Expression): ...
+class EncodeProperty(Expression): ...
+class Encrypt(Expression): ...
+class EncryptRaw(Expression): ...
+class EndsWith(Expression): ...
+class EngineProperty(Expression): ...
+class EnviromentProperty(Expression): ...
+class Epoch(Expression): ...
+class EpochMs(Expression): ...
+class Eq(Expression): ...
+class EqualNull(Expression): ...
+class EuclideanDistance(Expression): ...
+class Except(Expression): ...
+class Execute(Expression): ...
+class ExecuteAsProperty(Expression): ...
+class Exists(Expression): ...
+class Exp(Expression): ...
+class Explode(Expression): ...
+class ExplodeOuter(Expression): ...
+class ExplodingGenerateSeries(Expression): ...
+class Export(Expression): ...
+class ExtendsLeft(Expression): ...
+class ExtendsRight(Expression): ...
+class ExternalProperty(Expression): ...
+class Extract(Expression): ...
+class FallbackProperty(Expression): ...
+class FarmFingerprint(Expression): ...
+class FeaturesAtTime(Expression): ...
+class Fetch(Expression): ...
+class FileFormatProperty(Expression): ...
+class Filter(Expression): ...
+class First(Expression): ...
+class FirstValue(Expression): ...
+class Float64(Expression): ...
+class Floor(Expression): ...
+class ForIn(Expression): ...
+class ForeignKey(Expression): ...
+class Format(Expression): ...
+class FormatDate(Expression): ...
+class FormatPhrase(Expression): ...
+class FreespaceProperty(Expression): ...
+class From(Expression): ...
+class FromBase(Expression): ...
+class FromTimeZone(Expression): ...
+class FromUnixtime(Expression): ...
+class Function(Expression): ...
+class Upsert(Expression): ...
+class StorageProperty(Expression): ...
+class Hierarchy(Expression): ...
+class ViewParameter(Expression): ...
+class Call(Expression): ...
+class FunctionEmits(Expression): ...
+class GapFill(Expression): ...
+class Generate(Expression): ...
+class GenerateDateArray(Expression): ...
+class GenerateEmbedding(Expression): ...
+class GenerateSeries(Expression): ...
+class GenerateTimestampArray(Expression): ...
+class GeneratedAsIdentityColumnConstraint(Expression): ...
+class GeneratedAsRowColumnConstraint(Expression): ...
+class Get(Expression): ...
+class Getbit(Expression): ...
+class GetExtract(Expression): ...
+class Glob(Expression): ...
+class Grant(Expression): ...
+class GrantPrincipal(Expression): ...
+class GrantPrivilege(Expression): ...
+class Greatest(Expression): ...
+class Group(Expression): ...
+class GroupBy(Expression): ...
+class GroupConcat(Expression): ...
+class Grouping(Expression): ...
+class GroupingId(Expression): ...
+class GroupingSets(Expression): ...
+class Gt(Expression): ...
+class Gte(Expression): ...
+class HashAgg(Expression): ...
+class Having(Expression): ...
+class HavingMax(Expression): ...
+class Heredoc(Expression): ...
+class Hex(Expression): ...
+class HexEncode(Expression): ...
+class HexStringExpr(Expression): ...
+class Hint(Expression): ...
+class HistoricalData(Expression): ...
+class Hll(Expression): ...
+class Hour(Expression): ...
+class ILike(Expression): ...
+class IfFunc(Expression): ...
+class IfNull(Expression): ...
+class Identifier(Expression): ...
+class In(Expression): ...
+class IncludeProperty(Expression): ...
+class Index(Expression): ...
+class IndexColumnConstraint(Expression): ...
+class IndexConstraintOption(Expression): ...
+class IndexParameters(Expression): ...
+class IndexTableHint(Expression): ...
+class Initcap(Expression): ...
+class InOutColumnConstraint(Expression): ...
+class InputModelProperty(Expression): ...
+class InputOutputFormat(Expression): ...
+class InheritsProperty(Expression): ...
+class Insert(Expression): ...
+class Install(Expression): ...
+class Int64(Expression): ...
+class IntDiv(Expression): ...
+class Intersect(Expression): ...
+class Interval(Expression): ...
+class IntervalOp(Expression): ...
+class IntervalSpan(Expression): ...
+class IntoClause(Expression): ...
+class Introducer(Expression): ...
+class Is(Expression): ...
+class IsFalse(Expression): ...
+class IsInf(Expression): ...
+class IsJson(Expression): ...
+class IsNan(Expression): ...
+class IsNull(Expression): ...
+class IsTrue(Expression): ...
+class IsolatedLoadingProperty(Expression): ...
+class JSON(Expression): ...
+class JSONArray(Expression): ...
+class JSONArrayAgg(Expression): ...
+class JSONArrayAppend(Expression): ...
+class JSONArrayContains(Expression): ...
+class JSONArrayInsert(Expression): ...
+class JSONBContains(Expression): ...
+class JSONBContainsAllTopKeys(Expression): ...
+class JSONBContainsAnyTopKeys(Expression): ...
+class JSONBDeleteAtPath(Expression): ...
+class JSONBExists(Expression): ...
+class JSONBExtract(Expression): ...
+class JSONBExtractScalar(Expression): ...
+class JSONBObjectAgg(Expression): ...
+class JSONBool(Expression): ...
+class JSONCast(Expression): ...
+class JSONColumnDef(Expression): ...
+class JSONExists(Expression): ...
+class JSONExtract(Expression): ...
+class JSONExtractArray(Expression): ...
+class JSONExtractQuote(Expression): ...
+class JSONExtractScalar(Expression): ...
+class JSONFormat(Expression): ...
+class JSONKeyValue(Expression): ...
+class JSONKeys(Expression): ...
+class JSONKeysAtDepth(Expression): ...
+class JSONObject(Expression): ...
+class JSONObjectAgg(Expression): ...
+class JSONPath(Expression): ...
+class JSONPathFilter(Expression): ...
+class JSONPathKey(Expression): ...
+class JSONPathRecursive(Expression): ...
+class JSONPathRoot(Expression): ...
+class JSONPathScript(Expression): ...
+class JSONPathSelector(Expression): ...
+class JSONPathSlice(Expression): ...
+class JSONPathSubscript(Expression): ...
+class JSONPathUnion(Expression): ...
+class JSONRemove(Expression): ...
+class JSONSchema(Expression): ...
+class JSONSet(Expression): ...
+class JSONStripNulls(Expression): ...
+class JSONTable(Expression): ...
+class JSONType(Expression): ...
+class JSONValue(Expression): ...
+class JSONValueArray(Expression): ...
+class JarowinklerSimilarity(Expression): ...
+class Join(Expression): ...
+class JoinHint(Expression): ...
+class JoinedTable(Expression): ...
+class JournalProperty(Expression): ...
+class JsonArray(Expression): ...
+class JsonArrayAgg(Expression): ...
+class JsonArrayLength(Expression): ...
+class JsonExtract(Expression): ...
+class JsonExtractPath(Expression): ...
+class JsonExtractScalar(Expression): ...
+class JsonInsert(Expression): ...
+class JsonKeys(Expression): ...
+class JsonMergePatch(Expression): ...
+class JsonObject(Expression): ...
+class JsonObjectAgg(Expression): ...
+class JsonQuery(Expression): ...
+class JsonRemove(Expression): ...
+class JsonSet(Expression): ...
+class JsonType(Expression): ...
+class JsonValue(Expression): ...
+class Kill(Expression): ...
+class Lag(Expression): ...
+class Lambda(Expression): ...
+class LanguageProperty(Expression): ...
+class Last(Expression): ...
+class LastDay(Expression): ...
+class LastValue(Expression): ...
+class Lateral(Expression): ...
+class LateralView(Expression): ...
+class Lead(Expression): ...
+class Least(Expression): ...
+class Left(Expression): ...
+class Length(Expression): ...
+class Levenshtein(Expression): ...
+class Like(Expression): ...
+class LikeProperty(Expression): ...
+class Limit(Expression): ...
+class LimitOptions(Expression): ...
+class List(Expression): ...
+class ListAgg(Expression): ...
+class Literal(Expression): ...
+class Ln(Expression): ...
+class LoadData(Expression): ...
+class Localtime(Expression): ...
+class Localtimestamp(Expression): ...
+class LocationProperty(Expression): ...
+class Lock(Expression): ...
+class LockProperty(Expression): ...
+class LockingProperty(Expression): ...
+class LockingStatement(Expression): ...
+class Log(Expression): ...
+class LogProperty(Expression): ...
+class LogicalAnd(Expression): ...
+class LogicalOr(Expression): ...
+class Lower(Expression): ...
+class LowerHex(Expression): ...
+class Lpad(Expression): ...
+class LTrim(Expression): ...
+class MLForecast(Expression): ...
+class MLTranslate(Expression): ...
+class MD5Digest(Expression): ...
+class MD5NumberLower64(Expression): ...
+class MD5NumberUpper64(Expression): ...
+class MakeDate(Expression): ...
+class MakeInterval(Expression): ...
+class MakeTimestamp(Expression): ...
+class ManhattanDistance(Expression): ...
+class Map(Expression): ...
+class MapCat(Expression): ...
+class MapConcat(Expression): ...
+class MapContainsKey(Expression): ...
+class MapDelete(Expression): ...
+class MapFromArrays(Expression): ...
+class MapFromEntries(Expression): ...
+class MapFunc(Expression): ...
+class MapInsert(Expression): ...
+class MapKeys(Expression): ...
+class MapPick(Expression): ...
+class MapValues(Expression): ...
+class MaskingPolicyColumnConstraint(Expression): ...
+class Match(Expression): ...
+class MatchAgainst(Expression): ...
+class MatchRecognize(Expression): ...
+class MatchRecognizeMeasure(Expression): ...
+class MaterializedProperty(Expression): ...
+class Max(Expression): ...
+class Median(Expression): ...
+class MemberOf(Expression): ...
+class Merge(Expression): ...
+class MergeBlockRatioProperty(Expression): ...
+class MergeTreeTTL(Expression): ...
+class MergeTreeTTLAction(Expression): ...
+class MethodCall(Expression): ...
+class Min(Expression): ...
+class Minhash(Expression): ...
+class Minute(Expression): ...
+class Mod(Expression): ...
+class ModFunc(Expression): ...
+class Mode(Expression): ...
+class ModelAttribute(Expression): ...
+class Month(Expression): ...
+class MonthsBetween(Expression): ...
+class Monthname(Expression): ...
+class Mul(Expression): ...
+class MultitableInserts(Expression): ...
+class NTile(Expression): ...
+class NamedArgument(Expression): ...
+class NamedStruct(Expression): ...
+class Neg(Expression): ...
+class Neq(Expression): ...
+class NextDay(Expression): ...
+class NextValueFor(Expression): ...
+class Normal(Expression): ...
+class Normalize(Expression): ...
+class Not(Expression): ...
+class NotNullColumnConstraint(Expression): ...
+class Ntile(Expression): ...
+class Null(Expression): ...
+class NullIf(Expression): ...
+class Nullif(Expression): ...
+class NullSafeEq(Expression): ...
+class NullSafeNeq(Expression): ...
+class NumberToStr(Expression): ...
+class Nvl(Expression): ...
+class Nvl2(Expression): ...
+class NthValue(Expression): ...
+class ObjectAgg(Expression): ...
+class ObjectIdentifier(Expression): ...
+class ObjectInsert(Expression): ...
+class Offset(Expression): ...
+class OnCluster(Expression): ...
+class OnCommitProperty(Expression): ...
+class OnCondition(Expression): ...
+class OnConflict(Expression): ...
+class OnProperty(Expression): ...
+class Opclass(Expression): ...
+class OpenJSON(Expression): ...
+class OpenJSONColumnDef(Expression): ...
+class Operator(Expression): ...
+class OptionsProperty(Expression): ...
+class Or(Expression): ...
+class Ordered(Expression): ...
+class OrderBy(Expression): ...
+class OutputModelProperty(Expression): ...
+class Over(Expression): ...
+class OverflowTruncateBehavior(Expression): ...
+class Overlaps(Expression): ...
+class Overlay(Expression): ...
+class Pad(Expression): ...
+class Parameter(Expression): ...
+class ParameterizedAgg(Expression): ...
+class Paren(Expression): ...
+class ParseDatetime(Expression): ...
+class ParseIp(Expression): ...
+class ParseJSON(Expression): ...
+class ParseJson(Expression): ...
+class ParseTime(Expression): ...
+class ParseUrl(Expression): ...
+class Partition(Expression): ...
+class PartitionBoundSpec(Expression): ...
+class PartitionByListProperty(Expression): ...
+class PartitionByProperty(Expression): ...
+class PartitionByRangeProperty(Expression): ...
+class PartitionByRangePropertyDynamic(Expression): ...
+class PartitionByTruncate(Expression): ...
+class PartitionList(Expression): ...
+class PartitionRange(Expression): ...
+class PartitionedByBucket(Expression): ...
+class PartitionedByProperty(Expression): ...
+class PartitionedOfProperty(Expression): ...
+class PathColumnConstraint(Expression): ...
+class Percentile(Expression): ...
+class PercentileCont(Expression): ...
+class PercentileDisc(Expression): ...
+class PercentRank(Expression): ...
+class PeriodForSystemTimeConstraint(Expression): ...
+class Pi(Expression): ...
+class PipeOperator(Expression): ...
+class Pivot(Expression): ...
+class PivotAlias(Expression): ...
+class PivotAny(Expression): ...
+class Placeholder(Expression): ...
+class Position(Expression): ...
+class Power(Expression): ...
+class Pragma(Expression): ...
+class Prepare(Expression): ...
+class PreWhere(Expression): ...
+class Predict(Expression): ...
+class PreviousDay(Expression): ...
+class PrimaryKey(Expression): ...
+class PrimaryKeyColumnConstraint(Expression): ...
+class Prior(Expression): ...
+class ProjectionDef(Expression): ...
+class Properties(Expression): ...
+class Property(Expression): ...
+class PropertyEQ(Expression): ...
+class Pseudocolumn(Expression): ...
+class PseudoType(Expression): ...
+class Put(Expression): ...
+class Qualify(Expression): ...
+class Quantile(Expression): ...
+class Quarter(Expression): ...
+class QueryBand(Expression): ...
+class QueryOption(Expression): ...
+class QueryTransform(Expression): ...
+class RTrim(Expression): ...
+class Radians(Expression): ...
+class Rand(Expression): ...
+class Random(Expression): ...
+class Randn(Expression): ...
+class Randstr(Expression): ...
+class RangeBucket(Expression): ...
+class RangeN(Expression): ...
+class Rank(Expression): ...
+class Raw(Expression): ...
+class ReadCSV(Expression): ...
+class ReadParquet(Expression): ...
+class RecursiveWithSearch(Expression): ...
+class Reduce(Expression): ...
+class Reference(Expression): ...
+class Refresh(Expression): ...
+class RefreshTriggerProperty(Expression): ...
+class RegexpCount(Expression): ...
+class RegexpExtract(Expression): ...
+class RegexpExtractAll(Expression): ...
+class RegexpFullMatch(Expression): ...
+class RegexpILike(Expression): ...
+class RegexpInstr(Expression): ...
+class RegexpLike(Expression): ...
+class RegexpReplace(Expression): ...
+class RegexpSplit(Expression): ...
+class RegrAvgx(Expression): ...
+class RegrAvgy(Expression): ...
+class RegrCount(Expression): ...
+class RegrIntercept(Expression): ...
+class RegrR2(Expression): ...
+class RegrSlope(Expression): ...
+class RegrSxx(Expression): ...
+class RegrSxy(Expression): ...
+class RegrSyy(Expression): ...
+class RegrValx(Expression): ...
+class RegrValy(Expression): ...
+class RemoteWithConnectionModelProperty(Expression): ...
+class RenameColumn(Expression): ...
+class Repeat(Expression): ...
+class Replace(Expression): ...
+class ReplacePartition(Expression): ...
+class ReturnStmt(Expression): ...
+class Returning(Expression): ...
+class ReturnsProperty(Expression): ...
+class Reverse(Expression): ...
+class Revoke(Expression): ...
+class Right(Expression): ...
+class Rollback(Expression): ...
+class Rollup(Expression): ...
+class RollupProperty(Expression): ...
+class Round(Expression): ...
+class RowFormatDelimitedProperty(Expression): ...
+class RowFormatProperty(Expression): ...
+class RowFormatSerdeProperty(Expression): ...
+class RowNumber(Expression): ...
+class RowsFrom(Expression): ...
+class Rpad(Expression): ...
+class SHA(Expression): ...
+class SHA1Digest(Expression): ...
+class SHA2(Expression): ...
+class SHA2Digest(Expression): ...
+class SafeAdd(Expression): ...
+class SafeCast(Expression): ...
+class SafeDivide(Expression): ...
+class SafeMultiply(Expression): ...
+class SafeSubtract(Expression): ...
+class SampleProperty(Expression): ...
+class Schema(Expression): ...
+class SchemaCommentProperty(Expression): ...
+class ScopeResolution(Expression): ...
+class Search(Expression): ...
+class SearchIp(Expression): ...
+class Second(Expression): ...
+class SecurityProperty(Expression): ...
+class Select(Expression): ...
+class SemanticView(Expression): ...
+class Sequence(Expression): ...
+class SequenceProperties(Expression): ...
+class SerdeProperties(Expression): ...
+class SessionParameter(Expression): ...
+class SessionUser(Expression): ...
+class Set(Expression): ...
+class SetConfigProperty(Expression): ...
+class SetItem(Expression): ...
+class SetOperation(Expression): ...
+class SetProperty(Expression): ...
+class SetStatement(Expression): ...
+class SettingsProperty(Expression): ...
+class SharingProperty(Expression): ...
+class Show(Expression): ...
+class Sign(Expression): ...
+class SimilarTo(Expression): ...
+class Sin(Expression): ...
+class Skewness(Expression): ...
+class Slice(Expression): ...
+class SortArray(Expression): ...
+class SortBy(Expression): ...
+class SortKeyProperty(Expression): ...
+class Soundex(Expression): ...
+class Split(Expression): ...
+class SplitPart(Expression): ...
+class SplitTable(Expression): ...
+class SqlComment(Expression): ...
+class SqlReadWriteProperty(Expression): ...
+class SqlSecurityProperty(Expression): ...
+class Sqrt(Expression): ...
+class StDistance(Expression): ...
+class StPoint(Expression): ...
+class StabilityProperty(Expression): ...
+class StageReference(Expression): ...
+class StandardHash(Expression): ...
+class Star(Expression): ...
+class StarMap(Expression): ...
+class StartsWith(Expression): ...
+class Stddev(Expression): ...
+class StddevPop(Expression): ...
+class StddevSamp(Expression): ...
+class StorageHandlerProperty(Expression): ...
+class StrPosition(Expression): ...
+class StrToDate(Expression): ...
+class StrToMap(Expression): ...
+class StrToTime(Expression): ...
+class StrToUnix(Expression): ...
+class Stream(Expression): ...
+class StringAgg(Expression): ...
+class StringFunc(Expression): ...
+class StringToArray(Expression): ...
+class Struct(Expression): ...
+class StructExtract(Expression): ...
+class StructFunc(Expression): ...
+class Stuff(Expression): ...
+class Sub(Expression): ...
+class Subquery(Expression): ...
+class Subscript(Expression): ...
+class Substring(Expression): ...
+class SubstringIndex(Expression): ...
+class Sum(Expression): ...
+class SumIf(Expression): ...
+class Summarize(Expression): ...
+class Systimestamp(Expression): ...
+class Table(Expression): ...
+class TableAlias(Expression): ...
+class TableArgument(Expression): ...
+class TableFromRows(Expression): ...
+class TableSample(Expression): ...
+class Tag(Expression): ...
+class Tags(Expression): ...
+class Tan(Expression): ...
+class TemporaryProperty(Expression): ...
+class Time(Expression): ...
+class TimeAdd(Expression): ...
+class TimeDiff(Expression): ...
+class TimeFromParts(Expression): ...
+class TimeSlice(Expression): ...
+class TimeStrToDate(Expression): ...
+class TimeStrToTime(Expression): ...
+class TimeStrToUnix(Expression): ...
+class TimeSub(Expression): ...
+class TimeToStr(Expression): ...
+class TimeToUnix(Expression): ...
+class TimeTrunc(Expression): ...
+class TimeUnit(Expression): ...
+class Timestamp(Expression): ...
+class TimestampAdd(Expression): ...
+class TimestampDiff(Expression): ...
+class TimestampFromParts(Expression): ...
+class TimestampSub(Expression): ...
+class TimestampTrunc(Expression): ...
+class TimestampTzFromParts(Expression): ...
+class ToArray(Expression): ...
+class ToBoolean(Expression): ...
+class ToBinary(Expression): ...
+class ToChar(Expression): ...
+class ToDate(Expression): ...
+class ToDecfloat(Expression): ...
+class ToDouble(Expression): ...
+class ToFile(Expression): ...
+class ToJson(Expression): ...
+class ToMap(Expression): ...
+class ToNumber(Expression): ...
+class ToTableProperty(Expression): ...
+class ToTimestamp(Expression): ...
+class Transaction(Expression): ...
+class Transform(Expression): ...
+class TransformKeys(Expression): ...
+class TransformModelProperty(Expression): ...
+class TransformValues(Expression): ...
+class TransientProperty(Expression): ...
+class Translate(Expression): ...
+class TranslateCharacters(Expression): ...
+class Trim(Expression): ...
+class Truncate(Expression): ...
+class TruncFunc(Expression): ...
+class TruncateTable(Expression): ...
+class TryCast(Expression): ...
+class TryCatch(Expression): ...
+class TryBase64DecodeBinary(Expression): ...
+class TryBase64DecodeString(Expression): ...
+class TryToDecfloat(Expression): ...
+class TsMatch(Expression): ...
+class TsOrDiToDi(Expression): ...
+class TsOrDsAdd(Expression): ...
+class TsOrDsDiff(Expression): ...
+class TsOrDsToDate(Expression): ...
+class TsOrDsToDatetime(Expression): ...
+class TsOrDsToTime(Expression): ...
+class TsOrDsToTimestamp(Expression): ...
+class Tuple(Expression): ...
+class Typeof(Expression): ...
+class Uncache(Expression): ...
+class Unhex(Expression): ...
+class Unicode(Expression): ...
+class UnicodeString(Expression): ...
+class Uniform(Expression): ...
+class Union(Expression): ...
+class UniqueColumnConstraint(Expression): ...
+class UniqueKeyProperty(Expression): ...
+class UnixDate(Expression): ...
+class UnixMicros(Expression): ...
+class UnixMillis(Expression): ...
+class UnixSeconds(Expression): ...
+class UnixTimestamp(Expression): ...
+class UnixToStr(Expression): ...
+class UnixToTime(Expression): ...
+class UnixToTimeStr(Expression): ...
+class Unnest(Expression): ...
+class Unpivot(Expression): ...
+class UnpivotColumns(Expression): ...
+class Update(Expression): ...
+class Upper(Expression): ...
+class Use(Expression): ...
+class UserDefinedFunction(Expression): ...
+class UsingData(Expression): ...
+class UsingTemplateProperty(Expression): ...
+class UtcTime(Expression): ...
+class UtcTimestamp(Expression): ...
+class Uuid(Expression): ...
+class Values(Expression): ...
+class Var(Expression): ...
+class VarMap(Expression): ...
+class VarPop(Expression): ...
+class VarSamp(Expression): ...
+class Variadic(Expression): ...
+class Variance(Expression): ...
+class VectorSearch(Expression): ...
+class Version(Expression): ...
+class Vertica(Expression): ...
+class ViewAttributeProperty(Expression): ...
+class VolatileProperty(Expression): ...
+class WatermarkColumnConstraint(Expression): ...
+class Week(Expression): ...
+class When(Expression): ...
+class Whens(Expression): ...
+class Where(Expression): ...
+class WidthBucket(Expression): ...
+class Window(Expression): ...
+class WindowFunction(Expression): ...
+class WindowSpec(Expression): ...
+class With(Expression): ...
+class WithDataProperty(Expression): ...
+class WithFill(Expression): ...
+class WithJournalTableProperty(Expression): ...
+class WithOperator(Expression): ...
+class WithProcedureOptions(Expression): ...
+class WithSchemaBindingProperty(Expression): ...
+class WithSystemVersioningProperty(Expression): ...
+class WithTableHint(Expression): ...
+class WithinGroup(Expression): ...
+class XMLElement(Expression): ...
+class XMLGet(Expression): ...
+class XMLKeyValueOption(Expression): ...
+class XMLTable(Expression): ...
+class XmlNamespace(Expression): ...
+class Xor(Expression): ...
+class Year(Expression): ...
+class YearOfWeek(Expression): ...
+class YearOfWeekIso(Expression): ...
+class Zipf(Expression): ...
+
+
+def transpile(
+    sql: str,
+    read: str | None = None,
+    write: str | None = None,
+    *,
+    identity: bool = True,
+    error_level: str | None = None,
+    unsupported_level: str | None = None,
+    pretty: bool = False,
+    max_unsupported: int | None = None,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> list[str]:
+    """Transpile SQL from one dialect to another.
+
+    Args:
+        sql: One or more SQL statements separated by semicolons.
+        read: Source dialect (e.g. ``"mysql"``). Defaults to ``"generic"``.
+        write: Target dialect (e.g. ``"postgres"``). Defaults to ``"generic"``.
+        identity: Keep SQL unchanged when read == write. Defaults to ``True``.
+        error_level: Error handling: ``"raise"`` (default), ``"warn"``, or ``"ignore"``.
+        pretty: Emit formatted SQL with indentation.
+
+    Returns:
+        A list of transpiled SQL strings (one per statement).
+
+    Raises:
+        TranspileError: If transpilation fails.
+        ValueError: If a dialect name is unknown.
+    """
+    ...
+
+
+def parse(
+    sql: str,
+    read: str | None = None,
+    dialect: str | None = None,
+    *,
+    error_level: str | None = None,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> list[Expression]:
+    """Parse SQL into a list of ``Expression`` AST nodes.
+
+    Args:
+        sql: One or more SQL statements separated by semicolons.
+        read: Source dialect. Alias for *dialect*.
+        dialect: Source dialect (e.g. ``"postgres"``). Defaults to ``"generic"``.
+        error_level: ``"raise"`` (default), ``"warn"``, or ``"ignore"``.
+
+    Returns:
+        A list of typed ``Expression`` objects (e.g. ``Select``, ``Insert``).
+
+    Raises:
+        ParseError: If parsing fails and *error_level* is ``"raise"``.
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+@overload
+def parse_one(
+    sql: str,
+    read: str | None = None,
+    dialect: str | None = None,
+    *,
+    into: type[DataType],
+    error_level: str | None = None,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> DataType:
+    ...
+
+@overload
+def parse_one(
+    sql: str,
+    read: str | None = None,
+    dialect: str | None = None,
+    *,
+    into: None = None,
+    error_level: str | None = None,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> Expression:
+    ...
+
+def parse_one(
+    sql: str,
+    read: str | None = None,
+    dialect: str | None = None,
+    *,
+    into: type[DataType] | None = None,
+    error_level: str | None = None,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> Expression | DataType:
+    """Parse a single SQL statement into an ``Expression`` AST node.
+
+    Args:
+        sql: Exactly one SQL statement.
+        read: Source dialect. Alias for *dialect*.
+        dialect: Source dialect (e.g. ``"postgres"``). Defaults to ``"generic"``.
+        into: Set to ``polyglot_sql.DataType`` to parse a standalone data type.
+        error_level: ``"raise"`` (default), ``"warn"``, or ``"ignore"``.
+
+    Returns:
+        A typed ``Expression`` object (e.g. ``Select``) or ``DataType`` when
+        ``into=polyglot_sql.DataType`` is used.
+
+    Raises:
+        ParseError: If the input contains zero or multiple statements.
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+def parse_data_type(
+    sql: str,
+    read: str | None = None,
+    dialect: str | None = None,
+    *,
+    error_level: str | None = None,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> DataType:
+    """Parse a standalone SQL data type string.
+
+    Args:
+        sql: A data type string such as ``"DECIMAL(10, 2)"``.
+        read: Source dialect. Alias for *dialect*.
+        dialect: Source dialect (e.g. ``"duckdb"``). Defaults to ``"generic"``.
+        error_level: ``"raise"`` (default), ``"warn"``, or ``"ignore"``.
+
+    Returns:
+        A typed ``DataType`` expression that can be rendered with ``.sql()``.
+    """
+    ...
+
+
+def generate(
+    ast: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+    dialect: str = "generic",
+    *,
+    pretty: bool = False,
+) -> list[str]:
+    """Generate SQL strings from AST nodes.
+
+    Accepts a single ``Expression``, a list of ``Expression`` objects, or
+    their ``dict`` equivalents (as returned by :meth:`Expression.to_dict`).
+
+    Args:
+        ast: One or more AST nodes.
+        dialect: Target dialect. Defaults to ``"generic"``.
+        pretty: Emit formatted SQL with indentation.
+
+    Returns:
+        A list of SQL strings (one per input AST).
+
+    Raises:
+        GenerateError: If generation fails.
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+def qualify_tables(
+    ast: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+    *,
+    db: str | None = None,
+    catalog: str | None = None,
+    dialect: str | None = None,
+    canonicalize_table_aliases: bool = False,
+    alias_unaliased_tables: bool = True,
+    alias_unaliased_subqueries: bool = True,
+    alias_prefix: str = "_",
+    normalize_set_operation_subqueries: bool = True,
+) -> Expression | list[Expression]:
+    """Qualify table references in an AST.
+
+    The returned shape matches the input shape: a single AST returns a single
+    ``Expression`` and a list input returns a list.
+    """
+    ...
+
+
+def set_limit(
+    ast: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+    limit: int,
+) -> Expression | list[Expression]:
+    """Set LIMIT on a SELECT or set operation AST.
+
+    The returned shape matches the input shape: a single AST returns a single
+    ``Expression`` and a list input returns a list.
+    """
+    ...
+
+
+def set_offset(
+    ast: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+    offset: int,
+) -> Expression | list[Expression]:
+    """Set OFFSET on a SELECT or set operation AST.
+
+    The returned shape matches the input shape: a single AST returns a single
+    ``Expression`` and a list input returns a list.
+    """
+    ...
+
+
+def set_order_by(
+    ast: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+    order_by: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+) -> Expression | list[Expression]:
+    """Set ORDER BY on a SELECT or set operation AST.
+
+    Bare expressions are normalized to ascending order entries. The returned
+    shape matches the input shape.
+    """
+    ...
+
+
+def rename_tables(
+    ast: Expression | dict[str, TypingAny] | list[Expression] | list[dict[str, TypingAny]],
+    mapping: dict[str, str],
+    *,
+    alias_renamed_tables: bool = False,
+    preserve_existing_aliases: bool = True,
+) -> Expression | list[Expression]:
+    """Rename table references in an AST.
+
+    The returned shape matches the input shape: a single AST returns a single
+    ``Expression`` and a list input returns a list.
+    """
+    ...
+
+
+def format_sql(
+    sql: str,
+    dialect: str = "generic",
+    *,
+    max_input_bytes: int | None = None,
+    max_tokens: int | None = None,
+    max_ast_nodes: int | None = None,
+    max_set_op_chain: int | None = None,
+) -> str:
+    """Parse and pretty-print SQL (identity transpile with formatting).
+
+    Args:
+        sql: A single SQL statement.
+        dialect: Dialect for parsing and generation. Defaults to ``"generic"``.
+        max_input_bytes: Override the input size limit (bytes).
+        max_tokens: Override the token count limit.
+        max_ast_nodes: Override the AST node count limit.
+        max_set_op_chain: Override the ``UNION``/``INTERSECT``/``EXCEPT`` chain limit.
+
+    Returns:
+        Formatted SQL string.
+
+    Raises:
+        ParseError: If parsing fails or a guard limit is exceeded.
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+def validate(
+    sql: str,
+    dialect: str = "generic",
+    *,
+    strict_syntax: bool = False,
+    semantic: bool = False,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> ValidationResult:
+    """Validate SQL syntax and optional semantic correctness/quality checks.
+
+    Does **not** raise on invalid SQL — check ``result.valid`` or
+    ``bool(result)`` instead.
+
+    Args:
+        sql: SQL to validate.
+        dialect: Dialect for parsing. Defaults to ``"generic"``.
+        strict_syntax: Reject permissive forms such as trailing commas.
+        semantic: Report correctness errors E230-E232 and quality warnings W001-W004.
+
+    Raises:
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+def validate_with_schema(
+    sql: str,
+    schema: ValidationSchema | dict[str, TypingAny],
+    dialect: str = "generic",
+    *,
+    check_types: bool = False,
+    check_references: bool = False,
+    strict: bool | None = None,
+    semantic: bool = False,
+    strict_syntax: bool = False,
+    complexity_guard: ComplexityGuardOptions | None = None,
+    function_catalog: FunctionCatalogSpec | dict[str, TypingAny] | None = None,
+) -> ValidationResult:
+    """Validate SQL against a shared ValidationSchema dictionary using Rust.
+
+    Unknown tables, columns and aliases are checked by default. check_types
+    enables type checks; check_references enables ambiguity and foreign-key
+    checks. strict overrides schema['strict'], which otherwise defaults to
+    True. Non-strict reference/type findings are warnings. Empty column lists
+    and '*' columns represent open schemas, not known-empty tables.
+
+    semantic and strict_syntax behave as in validate. Syntax errors take
+    precedence. Invalid SQL returns findings; invalid schemas or dialect names
+    raise ValueError. Options are snake_case keyword arguments, not a dictionary.
+
+    function_catalog replaces the embedded name/arity catalog for check_types;
+    it does not enable checks by itself. Unknown nested input keys are rejected.
+    Proven semantic errors remain errors even with strict=False.
+    """
+    ...
+
+
+def optimize(sql: str, dialect: str | None = None, *, read: str | None = None) -> str:
+    """Apply basic SQL optimizations (predicate simplification, etc.).
+
+    Args:
+        sql: SQL to optimize.
+        dialect: Dialect for parsing and generation. Defaults to ``"generic"``.
+        read: Alias for *dialect*.
+
+    Returns:
+        Optimized SQL string.
+
+    Raises:
+        ParseError: If parsing fails.
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+def lineage(column: str, sql: str, dialect: str = "generic") -> dict[str, TypingAny]:
+    """Trace column lineage through a SQL query.
+
+    Args:
+        column: Target column name to trace.
+        sql: SQL query.
+        dialect: Dialect for parsing. Defaults to ``"generic"``.
+
+    Returns:
+        A dict describing the lineage graph.
+    """
+    ...
+
+def lineage_with_schema(
+    column: str,
+    sql: str,
+    schema: dict[str, TypingAny],
+    dialect: str = "generic",
+) -> dict[str, TypingAny]:
+    """Trace column lineage with an explicit schema for disambiguation.
+
+    Args:
+        column: Target column name to trace.
+        sql: SQL query.
+        schema: Schema dict mapping ``table_name`` to ``{column: type}`` dicts.
+        dialect: Dialect for parsing. Defaults to ``"generic"``.
+
+    Returns:
+        A dict describing the lineage graph.
+    """
+    ...
+
+def lineage_at(
+    ordinal: int,
+    sql: str,
+    dialect: str = "generic",
+) -> dict[str, TypingAny]:
+    """Trace lineage for a zero-based output ordinal."""
+    ...
+
+def lineage_at_with_schema(
+    ordinal: int,
+    sql: str,
+    schema: dict[str, TypingAny],
+    dialect: str = "generic",
+) -> dict[str, TypingAny]:
+    """Trace schema-aware lineage for a zero-based output ordinal."""
+    ...
+
+def output_columns(
+    sql: str,
+    dialect: str = "generic",
+) -> dict[str, TypingAny]:
+    """Return the ordered query output description."""
+    ...
+
+def output_columns_with_schema(
+    sql: str,
+    schema: dict[str, TypingAny],
+    dialect: str = "generic",
+) -> dict[str, TypingAny]:
+    """Return the ordered output description after schema-aware wildcard expansion."""
+    ...
+
+
+def source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]:
+    """Return source table names that contribute to a column.
+
+    Args:
+        column: Target column name.
+        sql: SQL query.
+        dialect: Dialect for parsing. Defaults to ``"generic"``.
+
+    Returns:
+        A list of table name strings.
+    """
+    ...
+
+
+def analyze_query(
+    sql: str,
+    options: AnalyzeQueryOptions | dict[str, TypingAny] | None = None,
+    dialect: str = "generic",
+    *,
+    complexity_guard: ComplexityGuardOptions | None = None,
+) -> QueryAnalysis:
+    """Return compact query analysis facts for a SELECT or set operation.
+
+    Options use camelCase keys and support ``dialect``, ``complexityGuard`` and optional
+    ``schema`` in the same ValidationSchema shape accepted by schema-aware
+    validation and lineage APIs. Schema columns use the ``type`` key for type
+    strings; ``dataType`` and ``data_type`` are not accepted aliases.
+
+    Supply guard limits using either ``complexity_guard`` or the options entry,
+    not both. Omitted limits use defaults; a field-level None disables one check.
+
+    The returned dict includes ``relations``, transitive ``baseTables``,
+    top-level ``cteFacts``, original ``starProjections``, and projection
+    ``nullability`` values of ``"non_null"``, ``"nullable"``, or ``"unknown"``.
+    ``columnUses`` groups non-projection references by clause, with ``context``,
+    ``scopePath``, ``expressionPath``, dialect-rendered ``expressionSql`` and
+    ``references``. Optional ``span`` objects use half-open Unicode-character
+    offsets into the original SQL. Reference spans locate uses, not definitions.
+    """
+    ...
+
+
+def openlineage_column_lineage(
+    sql: str,
+    options: dict[str, TypingAny],
+) -> dict[str, TypingAny]:
+    """Build an OpenLineage columnLineage facet and dataset payload.
+
+    The options dict uses the same camelCase keys as the JSON API, including
+    ``producer``, ``datasetNamespace``, ``outputDataset``, and optional
+    ``schema``. This function does not send events.
+    """
+    ...
+
+
+def openlineage_job_event(
+    sql: str,
+    options: dict[str, TypingAny],
+) -> dict[str, TypingAny]:
+    """Build an OpenLineage JobEvent payload without sending it."""
+    ...
+
+
+def openlineage_run_event(
+    sql: str,
+    options: dict[str, TypingAny],
+) -> dict[str, TypingAny]:
+    """Build an OpenLineage RunEvent payload without sending it."""
+    ...
+
+
+def diff(sql1: str, sql2: str, dialect: str = "generic") -> list[dict[str, TypingAny]]:
+    """Compute a structural diff between two SQL statements.
+
+    Args:
+        sql1: First SQL statement.
+        sql2: Second SQL statement.
+        dialect: Dialect for parsing. Defaults to ``"generic"``.
+
+    Returns:
+        A list of diff entries (insertions, deletions, moves).
+
+    Raises:
+        ValueError: If the dialect name is unknown.
+    """
+    ...
+
+
+def dialects() -> list[str]:
+    """Return the list of supported dialect names.
+
+    Example::
+
+        polyglot_sql.dialects()
+        # ["athena", "bigquery", "clickhouse", "databricks", "doris", ...]
+    """
+    ...
+
+
+def format(
+    sql: str,
+    dialect: str = "generic",
+    *,
+    max_input_bytes: int | None = None,
+    max_tokens: int | None = None,
+    max_ast_nodes: int | None = None,
+    max_set_op_chain: int | None = None,
+) -> str:
+    """Alias for :func:`format_sql`."""
+    ...
+
+
+# SQLGlot-compatible builder subset
+def select(*expressions: TypingAny, dialect: str | None = None, copy: bool = True) -> Select: ...
+def from_(expression: TypingAny, dialect: str | None = None, copy: bool = True) -> Select: ...
+def column(name: str, table: str | None = None) -> Column: ...
+def col(name: str, table: str | None = None) -> Column: ...
+def table_(name: str) -> Table: ...
+def convert(value: TypingAny, copy: bool = False) -> Expression: ...
+def lit(value: TypingAny) -> Expression: ...
+def condition(expression: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+def and_(*expressions: TypingAny, dialect: str | None = None, copy: bool = True, wrap: bool = True) -> Expression: ...
+def or_(*expressions: TypingAny, dialect: str | None = None, copy: bool = True, wrap: bool = True) -> Expression: ...
+def not_(expression: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+def alias_(expression: TypingAny, alias: str, dialect: str | None = None, copy: bool = True) -> Expression: ...
+def func(name: str, *args: TypingAny, dialect: str | None = None, copy: bool = True) -> Expression: ...
+def count(expression: TypingAny) -> Expression: ...
+def count_star() -> Expression: ...
+def count_distinct(expression: TypingAny) -> Expression: ...
+def sum_(expression: TypingAny) -> Expression: ...
+def avg(expression: TypingAny) -> Expression: ...
+def min_(expression: TypingAny) -> Expression: ...
+def max_(expression: TypingAny) -> Expression: ...
+def approx_distinct(expression: TypingAny) -> Expression: ...
+def upper(expression: TypingAny) -> Expression: ...
+def lower(expression: TypingAny) -> Expression: ...
+def length(expression: TypingAny) -> Expression: ...
+def trim(expression: TypingAny) -> Expression: ...
+def ltrim(expression: TypingAny) -> Expression: ...
+def rtrim(expression: TypingAny) -> Expression: ...
+def reverse(expression: TypingAny) -> Expression: ...
+def initcap(expression: TypingAny) -> Expression: ...
+def substring(expression: TypingAny, start: TypingAny, length: TypingAny = None) -> Expression: ...
+def replace_(expression: TypingAny, old: TypingAny, new: TypingAny) -> Expression: ...
+def concat_ws(separator: TypingAny, *expressions: TypingAny) -> Expression: ...
+def coalesce(*expressions: TypingAny) -> Expression: ...
+def null_if(left: TypingAny, right: TypingAny) -> Expression: ...
+def if_null(expression: TypingAny, fallback: TypingAny) -> Expression: ...
+def abs_(expression: TypingAny) -> Expression: ...
+def round_(expression: TypingAny, decimals: TypingAny = None) -> Expression: ...
+def floor(expression: TypingAny) -> Expression: ...
+def ceil(expression: TypingAny) -> Expression: ...
+def power(base: TypingAny, exponent: TypingAny) -> Expression: ...
+def sqrt(expression: TypingAny) -> Expression: ...
+def ln(expression: TypingAny) -> Expression: ...
+def exp(expression: TypingAny) -> Expression: ...
+def sign(expression: TypingAny) -> Expression: ...
+def greatest(*expressions: TypingAny) -> Expression: ...
+def least(*expressions: TypingAny) -> Expression: ...
+def current_date() -> Expression: ...
+def current_time() -> Expression: ...
+def current_timestamp() -> Expression: ...
+def extract(field: str, expression: TypingAny) -> Expression: ...
+def row_number() -> Expression: ...
+def rank() -> Expression: ...
+def dense_rank() -> Expression: ...
+def case(expression: TypingAny = None, dialect: str | None = None, copy: bool = True) -> Case: ...
+def update(table: str, properties: dict[str, TypingAny] | None = None, where: TypingAny = None, from_: str | None = None, dialect: str | None = None, copy: bool = True) -> Update: ...
+def delete(table: str, where: TypingAny = None, dialect: str | None = None, copy: bool = True) -> Delete: ...
+def insert(expression: TypingAny, into: str, columns: list[str] | None = None, dialect: str | None = None, copy: bool = True) -> Insert: ...
+def merge_into(target: str, dialect: str | None = None, copy: bool = True) -> Merge: ...
+def union(left: TypingAny, right: TypingAny, distinct: bool = True, dialect: str | None = None, copy: bool = True) -> Union: ...
+def intersect(left: TypingAny, right: TypingAny, distinct: bool = True, dialect: str | None = None, copy: bool = True) -> Intersect: ...
+def except_(left: TypingAny, right: TypingAny, distinct: bool = True, dialect: str | None = None, copy: bool = True) -> Except: ...
+
+
+__version__: str
+"""Package version string (e.g. ``"0.1.15"``)."""