sqlleaf 0.0.1__py3-none-any.whl

sqlleaf/processors/transformer/udf.py

@@ -0,0 +1,235 @@
+import logging
+import typing as t
+
+from sqlglot import exp
+
+from sqlleaf import mappings, util
+from sqlleaf.models.query import UserDefinedFunctionQuery
+from sqlleaf.processors.collector import substitute
+from sqlleaf.processors.transformer.expressions import normalize_values
+from sqlleaf.processors.transformer.expressions.row import transform_row_function_to_subquery
+
+logger = logging.getLogger("sqlleaf")
+
+
+
+
+
+def find_next_udf_call(
+    expression: exp.Expr, object_mapping: mappings.ObjectMapping
+) -> t.Tuple[t.Optional[exp.Anonymous], t.Optional[UserDefinedFunctionQuery]]:
+    """
+    Searches the AST for the next UDF call that matches any of the provided UDF definitions.
+    Returns the call node and the matched UDF definition.
+    """
+    for node in expression.find_all(exp.Anonymous):
+        best_match = object_mapping.lookup_udf_call(node)
+        if best_match:
+            return node, best_match
+
+    return None, None
+
+
+def _get_alias(node: exp.Expr) -> t.Optional[str]:
+    """Helper to extract an alias from a node or its parent."""
+    alias = node.alias
+    if not alias:
+        if isinstance(node.parent, exp.Table):
+            alias = node.parent.alias
+
+    if not alias and hasattr(node, "this"):
+        alias = node.this
+
+    return alias
+
+
+def create_subquery_with_alias(
+    replacement_expr: exp.Expr, query: UserDefinedFunctionQuery, alias: str = "t"
+) -> exp.Subquery:
+    """Creates a Subquery with a table alias and the UDF's return columns."""
+    return exp.Subquery(
+        this=replacement_expr,
+        alias=exp.TableAlias(
+            this=exp.Identifier(this=alias, quoted=False),
+            columns=[c.this if isinstance(c, exp.ColumnDef) else exp.to_identifier(c) for c in query.return_columns],
+        ),
+    )
+
+
+def transform_udf_to_subquery_if_table_reference(
+    node: exp.Anonymous, replacement_expr: exp.Expr, query: UserDefinedFunctionQuery
+) -> None:
+    """
+    Transforms a UDF call into a subquery when used in a FROM clause as a table.
+
+    Example:
+        SELECT FROM hello() -> SELECT FROM (SELECT ...) AS t(name, age)
+        where hello() returns (name, age)
+    """
+    if query.return_columns:
+        alias = _get_alias(node) or "t"
+        replacement_expr = create_subquery_with_alias(replacement_expr, query, alias=alias)
+
+    node.parent.replace(replacement_expr)
+
+
+def replace_scalar_call(target_node: exp.Expr, replacement_expr: exp.Expr) -> None:
+    """
+    Replaces a scalar UDF call, wrapping query-like expressions in a Subquery.
+
+    Example:
+        Given hello() as `SELECT 1`,
+        Before: `SELECT hello()`
+        After: `SELECT (SELECT 1)`
+    """
+    if isinstance(replacement_expr, (exp.Select, exp.Values)):
+        replacement_expr = exp.Subquery(this=replacement_expr)
+    copied = replacement_expr.copy()
+    target_node.replace(copied)
+
+
+def get_target_node(node: exp.Anonymous) -> exp.Expr:
+    """
+    Returns the node to be replaced.
+    """
+    parent = node.parent
+    # Qualified with a schema (e.g., myschema.myfunc())
+    if isinstance(parent, exp.Dot) and isinstance(parent.left, exp.Identifier):
+        return parent
+    return node
+
+
+def resolve_returning_to_select(
+    stmt: exp.Expr,
+    param_map: t.Dict[str, exp.Expr],
+    query: UserDefinedFunctionQuery,
+    positional_map: t.Dict[str, exp.Expr],
+) -> exp.Select:
+    """
+    Given a statement with a RETURNING clause (INSERT, UPDATE, DELETE, MERGE),
+    resolve each RETURNING expression and return a SELECT expression.
+
+    Notes on INSERT ... VALUES ... RETURNING:
+    - We intentionally resolve INSERT ... VALUES ... RETURNING by selecting the
+      requested columns from the target table rather than from the VALUES-derived
+      UNION. This preserves the semantics that RETURNING reflects the post-insert
+      target-row value.
+
+    Example:
+        INSERT INTO people (age) VALUES (5), (2) RETURNING age
+        → SELECT people.age FROM people
+    """
+    returning_node = stmt.args.get("returning")
+    if isinstance(stmt, exp.Insert) and isinstance(stmt.expression, exp.Values):
+        # TODO: this shouldn't be the select expr, but just direct lineage from the target column to the returning column
+        # For INSERT ... VALUES ... RETURNING, select the RETURNING columns from the target table.
+        table = stmt.find(exp.Table)
+        returning_select = exp.select(*[r.copy() for r in returning_node.expressions]).from_(table.copy())
+        return substitute.substitute_parameters(returning_select, query, param_map, positional_map)
+
+    col_to_val = {}
+    resolved = []
+    for ret_col in returning_node.expressions:
+        col_name = ret_col.name if isinstance(ret_col, exp.Column) else ret_col.alias_or_name
+        resolved_val = col_to_val.get(col_name, ret_col).copy()
+        # Apply parameter substitution on the resolved value
+        resolved_val = substitute.substitute_parameters(resolved_val, query, param_map, positional_map)
+        resolved.append(resolved_val)
+
+    return exp.select(*resolved)
+
+
+def transform_inner_query(
+    stmt: exp.Expr,
+    param_map: t.Dict[str, exp.Expr],
+    query: UserDefinedFunctionQuery,
+    positional_map: t.Dict[str, exp.Expr],
+) -> exp.Expr:
+    """
+    Performs replacement and transformations over a UDF's inner query.
+
+    Example:
+        Given a UDF body statement `SELECT $1 * 2 AS val` with param_map `{"$1": 5}`:
+            → SELECT 5 * 2 AS val
+
+        Given a UDF body statement `INSERT INTO people (age) VALUES (5) RETURNING age`:
+            → SELECT people.age FROM people
+    """
+    # handle INSERT/UPDATE/DELETE/MERGE ... RETURNING inside a UDF body
+    if isinstance(stmt, (exp.Insert, exp.Update, exp.Delete, exp.Merge)) and stmt.args.get("returning"):
+        return resolve_returning_to_select(stmt, param_map, query, positional_map)
+
+    if isinstance(stmt, exp.Values):
+        stmt = normalize_values(query, stmt)
+
+    logger.debug(f"Transforming inner query: {stmt.sql()}")
+    replacement_expr = substitute.substitute_parameters(stmt, query, param_map, positional_map)
+    logger.debug(f"Query after parameter substitution: {replacement_expr.sql()}")
+
+    # Handle ROW(...)::table_name replacement (composite/table type casting)
+    replacement_expr = transform_row_function_to_subquery(replacement_expr, query)
+
+    new_expr = replacement_expr
+    return new_expr
+
+
+def build_replacement_exprs(node: exp.Anonymous, query: UserDefinedFunctionQuery) -> t.List[exp.Expr]:
+    """
+    Builds the expressions that will replace a UDF call.
+
+    Example:
+        Given a UDF `hello()` defined as `SELECT 'Hello'` and a call site `hello()`:
+            → [SELECT 'Greetings!' AS greeting]
+
+        Given a UDF `hello()` with a RETURNING body `INSERT INTO people (age) VALUES (5) RETURNING age`:
+            → [SELECT people.age FROM people]
+    """
+    if query.return_type and query.return_type.this == exp.DataType.Type.NULL:
+        return [exp.select(exp.Null())]
+
+    param_map, positional_map = substitute.transform_arguments(node, query)
+
+    replacement_exprs = []
+    # Collect all child queries from the holder
+    for child in query.holder.downstream_holders:
+        stmt = child.original.statement
+        stmt = util.copy_expression(stmt)
+        replacement_exprs.append(transform_inner_query(stmt, param_map, query, positional_map))
+
+    return replacement_exprs
+
+
+def substitute_udf(
+    node: exp.Anonymous,
+    query: UserDefinedFunctionQuery,
+) -> t.List[exp.Expr]:
+    """
+    Returns the UDF's inner body with arguments substituted.
+    Does NOT modify the caller query.
+    Mirrors the contract of substitute_call / substitute_execute_with_plan.
+    """
+    return build_replacement_exprs(node, query)
+
+
+def apply_replacement(target_node: exp.Expr, replacement_expr: exp.Expr, query: UserDefinedFunctionQuery) -> None:
+    """
+    Applies the replacement of a UDF call node with its body logic.
+
+    Dispatches to the appropriate replacement strategy based on the call context:
+    - LATERAL context: wraps the replacement in a LATERAL subquery.
+    - Table reference context: wraps the replacement as a derived table.
+    - Field access (dot notation): replaces with a field-access subquery.
+    - Scalar call: replaces the call node inline.
+
+    Example:
+        Given `SELECT hello()` where `hello()` resolves to `SELECT 'Greetings!' AS greeting`:
+            → SELECT (SELECT 'Greetings!' AS greeting) AS hello
+    """
+    logger.debug(f"Applying replacement for UDF: {query.name}")
+
+    if isinstance(target_node.parent, exp.Table):
+        logger.debug("Applying Table reference replacement")
+        transform_udf_to_subquery_if_table_reference(target_node, replacement_expr, query)
+    else:
+        logger.debug("Applying Scalar call replacement")
+        replace_scalar_call(target_node, replacement_expr)

sqlleaf/processors/transformer/unload.py

@@ -0,0 +1,30 @@
+"""
+UnloadTransformer — handles UNLOAD statement transformations.
+"""
+
+from sqlglot import exp
+
+from sqlleaf.processors.transformer.base import BaseQueryTransformer
+
+
+class UnloadTransformer(BaseQueryTransformer):
+    """Transformer for UNLOAD statements."""
+
+    def transform(self, statement: exp.Insert) -> exp.Insert:
+        return self._convert_unload_to_insert(statement)
+
+    def _convert_unload_to_insert(self, statement: exp.Select) -> exp.Insert:
+        """
+        Convert the UNLOAD statement into an INSERT statement.
+
+        UNLOAD ('SELECT * FROM fruit.raw') TO 's3://object-path/name-prefix'
+            -> INSERT INTO 's3://object-path/name-prefix' SELECT * FROM fruit.raw
+        """
+        query = self.query
+        table = exp.table_(query.target_info.expression.name)
+        insert_expr = exp.insert(
+            expression=statement,
+            into=table,
+            dialect=query.dialect,
+        )
+        return insert_expr

sqlleaf/processors/transformer/update.py

@@ -0,0 +1,174 @@
+"""
+UpdateTransformer — handles UPDATE (and MERGE → UPDATE, ON CONFLICT) statement transformations.
+"""
+
+from sqlglot import exp
+
+from sqlleaf import exception
+from sqlleaf.processors.transformer.base import BaseQueryTransformer
+from sqlleaf.processors.transformer.expressions import normalize_values
+
+
+class UpdateTransformer(BaseQueryTransformer):
+    """Transformer for UPDATE statements."""
+
+    def transform(self, statement: exp.Insert) -> exp.Insert:
+        statement = self._convert_on_conflict_to_update(statement)
+        if isinstance(statement, (exp.Insert, exp.Update)):
+            statement = self._add_information_from_merge(statement)
+        if isinstance(statement, exp.Update):
+            statement = self._convert_update_defaults_to_values(statement)
+            statement = self._convert_update_to_insert(statement)
+        if isinstance(statement, (exp.Insert, exp.Merge, exp.Update, exp.Delete)):
+            statement = self._process_inner_ctes(statement)
+        return statement
+
+    def _convert_on_conflict_to_update(self, statement: exp.OnConflict | exp.Update) -> exp.Update:
+        """
+        Convert the 'DO UPDATE' in:
+            INSERT INTO <table> as t
+            ON CONFLICT
+            DO UPDATE SET name = EXCLUDED.name
+        to:
+            UPDATE <table> AS t
+            SET name = name
+        so that the expression has the correct columns/values.
+        """
+        if not isinstance(statement, exp.OnConflict):
+            return statement
+
+        # Note: this holder's `preprocess()`/`normalize_all_values()` only walks
+        # descendants of `statement` (the OnConflict node itself), so it never sees the
+        # sibling VALUES living under the ancestor Insert/Create's `.expression` in this
+        # holder's own copy of the tree. That conversion must still happen here.
+        parent_insert_expr = None
+        values_alias_name: str | None = None
+        parent = statement.parent
+        parent_expr = statement.parent.expression
+
+        update_expr = exp.update(table=self.query.get_target_as_table())
+        parent_table = parent_expr.args.get("from_", None)
+        if parent_table:
+            update_expr = update_expr.from_(parent_table.this)
+
+        if isinstance(parent_expr, exp.Values):
+            # Capture the VALUES alias (used in MySQL: VALUES (...) AS <alias>) before we rewrite it
+            alias_expr = parent_expr.args.get("alias")
+
+            if alias_expr is not None:
+                # exp.TableAlias typically exposes the alias via `.alias`; fallback to `.name` if needed
+                values_alias_name = alias_expr.alias_or_name
+
+            parent_insert_expr = normalize_values(self.query, parent)
+            statement = parent_insert_expr.args["conflict"]
+
+        elif isinstance(parent_expr, exp.Select):
+            parent_insert_expr = parent
+
+
+        # Rewrite the expressions in the UPDATE
+        for eq_expr in list(statement.expressions):
+            right_expr = eq_expr.right
+
+            if self.query.dialect == "mysql" and isinstance(right_expr, exp.Anonymous) and right_expr.name.upper() == "VALUES":
+                # Replace the VALUES() expression with its associated expression in the SELECT.
+                # The inner column is a reference to the SELECT expression in the INSERT list, not the column itself.
+                # e.g. INSERT INTO users (id, name) SELECT 'a', 'b' ... UPDATE SET name = VALUES(name)
+                # would replace VALUES(name) with 'b'
+                values_col = right_expr.expressions[0].name
+                column_names = self._extract_insert_columns(parent, self.query.target_info.expression, include_system=False)
+                if values_col not in column_names:
+                    raise exception.MappingError(f"Column '{values_col}' does not exist in the expression list or the columns for table '{str(parent.this.this)}'")
+
+                column_index = column_names.index(values_col)
+                select_expr = parent_insert_expr.selects[column_index]
+                right_expr.replace(select_expr.copy())
+
+            for col in right_expr.find_all(exp.Column):
+                # Transform any aliased columns into their correct expressions.
+                # Examples:
+                # - ON CONFLICT DO UPDATE ... EXCLUDED.col
+                # - ON DUPLICATE KEY UPDATE ... new_alias.col
+                table_name = (col.table or "").upper()
+                if table_name == "EXCLUDED" or (values_alias_name and col.table == values_alias_name):
+                    if col.name not in parent_insert_expr.named_selects:
+                        # The outer INSERT did not provide a value for this column; reference the existing column
+                        col.replace(exp.column(col.name))
+                    else:
+                        # Set it to the unaliased expression from the outer INSERT/SELECT
+                        select_expr = [
+                            alias_expr for alias_expr in parent_insert_expr.selects if alias_expr.alias == col.name
+                        ][0]
+                        new_expr = select_expr.unalias().copy()
+
+                        if isinstance(new_expr, exp.Column) and parent_table:
+                            new_expr.set("table", exp.to_identifier(parent_table.alias_or_name))
+
+                        col.replace(new_expr)
+
+        update_expr.set("expressions", statement.expressions)
+
+        return update_expr
+
+    def _convert_update_defaults_to_values(self, statement: exp.Update) -> exp.Update:
+        """
+        Transform the query:
+            UPDATE x SET a = DEFAULT
+        into:
+            UPDATE x SET a = 42
+        according to the table's default column values.
+        """
+        query = self.query
+        child_table = query.get_target_as_table()
+        table_query = query.object_mapping.lookup_table_query(table=child_table)
+        if not table_query:
+            return statement
+
+        table_columns = table_query.get_column_defs()
+
+        for expr in statement.expressions:
+            if isinstance(expr, exp.EQ) and isinstance(expr.left, exp.Column):
+                if (isinstance(expr.right, exp.Var) and expr.right.name.upper() == "DEFAULT") or (
+                    isinstance(expr.right, exp.Column) and expr.right.name.upper() == "DEFAULT"
+                ):
+                    # Replace 'DEFAULT' with the associated column's default expression
+                    self._replace_default_with_value(
+                        expression=expr.right,
+                        column_name=expr.left.name,
+                        table_columns=table_columns,
+                    )
+
+        return statement
+
+    def _add_information_from_merge(self, statement: exp.Insert | exp.Update) -> exp.Insert | exp.Update:
+        """
+        UPDATE branch of _add_information_from_merge.
+
+        Transform a nested UPDATE (from a MERGE WHEN MATCHED branch) into a
+        fully qualified UPDATE so it can be processed independently.
+        """
+        if not isinstance(statement, exp.Update):
+            return statement
+
+        ctx = self._extract_merge_context(statement)
+        if ctx is None:
+            return statement
+
+        using = ctx["using"]
+        on = ctx["on"]
+        returning = ctx["returning"]
+        new_ctes = [{"alias": cte.alias_or_name, "as_": cte.this} for cte in ctx["ctes"]]
+
+        # Add the missing information to the UPDATE statement
+        target = self.query.target_info.expression
+        if isinstance(target, exp.Table):
+            self.query.only = target.args.get("only", False)  # type: ignore
+
+        update_expr = statement.table(self.query.target_info.expression).from_(using).where(on)
+        update_expr.set("returning", returning)
+
+        for cte in new_ctes:
+            update_expr = update_expr.with_(alias=cte["alias"], as_=cte["as_"])
+
+        statement.replace(update_expr)
+        return update_expr

sqlleaf/processors/transformer/values.py

@@ -0,0 +1,10 @@
+from sqlglot import exp
+
+from sqlleaf.processors.transformer.base import BaseQueryTransformer
+from sqlleaf.processors.transformer.expressions import normalize_values
+
+
+class ValuesTransformer(BaseQueryTransformer):
+    def transform(self, statement: exp.Values) -> exp.Values:
+        statement = normalize_values(self.query, statement)
+        return statement

sqlleaf/settings/__init__.py

@@ -0,0 +1,19 @@
+import typing as t
+from functools import cache
+
+from sqlglot import exp
+
+from sqlleaf.settings.athena import AthenaSettings as AthenaSettings
+from sqlleaf.settings.base import BaseDialectSettings as BaseDialectSettings
+from sqlleaf.settings.postgres import PostgresSettings as PostgresSettings
+
+
+@cache
+def system_columns(dialect: str) -> t.List[exp.ColumnDef]:
+    return BaseDialectSettings.from_dialect(dialect).system_columns
+
+
+@cache
+def system_functions(dialect: str) -> t.Dict[str, t.List[str]]:
+    # TODO: refactor this into a set of objects that can be loaded into the mapping
+    return BaseDialectSettings.from_dialect(dialect).system_functions

sqlleaf/settings/athena.py

@@ -0,0 +1,23 @@
+import typing as t
+
+from sqlglot import exp
+
+from sqlleaf.settings.base import BaseDialectSettings
+
+
+class AthenaSettings(BaseDialectSettings):
+    DIALECT = "athena"
+    PSEUDOCOLUMNS = {
+        "$bucket": "BIGINT",
+        "$file_modified_time": "TIMESTAMP",
+        "$file_size": "BIGINT",
+        "$partition": "VARCHAR",
+        "$path": "VARCHAR",
+    }
+
+    @property
+    def system_columns(self) -> t.List[exp.ColumnDef]:
+        return [
+            exp.ColumnDef(this=exp.to_identifier(name), kind=exp.DataType.build(kind, self.DIALECT))
+            for name, kind in self.PSEUDOCOLUMNS.items()
+        ]

sqlleaf/settings/base.py

@@ -0,0 +1,37 @@
+import typing as t
+
+from sqlglot import exp
+
+
+class BaseDialectSettings:
+    # A registry to store subclasses
+    _dialects = {}
+    DIALECT = ""
+
+    def __init_subclass__(cls, **kwargs):
+        """Automatically registers subclasses when they are defined."""
+        super().__init_subclass__(**kwargs)
+        if cls.DIALECT:
+            BaseDialectSettings._dialects[cls.DIALECT] = cls
+
+    @classmethod
+    def from_dialect(cls, dialect: str) -> BaseDialectSettings:
+        """Instantiates a class from the registry by name."""
+        target_class = cls._dialects.get(dialect)
+        if not target_class:
+            return BaseDialectSettings()
+        return target_class()
+
+    @property
+    def system_columns(self) -> t.List[exp.ColumnDef]:
+        """
+        Represents system columns.
+        """
+        return []
+
+    @property
+    def system_functions(self) -> t.Dict[str, t.List[str]]:
+        """
+        Represents system functions.
+        """
+        return {}

sqlleaf/settings/postgres.py

@@ -0,0 +1,52 @@
+import typing as t
+
+from sqlglot import exp
+from sqlglot.dialects import postgres
+
+from sqlleaf.settings.base import BaseDialectSettings
+
+
+class PostgresSettings(BaseDialectSettings):
+    DIALECT = "postgres"
+    PSEUDOCOLUMNS = {
+        "cmax": "OID",
+        "cmin": "OID",
+        "ctid": "OID",
+        "oid": "OID",
+        "tableoid": "OID",
+        "xmax": "OID",
+        "xmin": "OID",
+    }
+
+    @property
+    def system_columns(self) -> t.List[exp.ColumnDef]:
+        return [
+            exp.ColumnDef(this=exp.to_identifier(name), kind=exp.DataType.build(kind, self.DIALECT))
+            for name, kind in self.PSEUDOCOLUMNS.items()
+        ]
+
+    @property
+    def system_functions(self) -> t.Dict[str, t.List[str]]:
+        """
+        Map function names to their returned column names.
+        """
+        return {
+            "aclexplode": ["grantor, grantee, privilege_type, is_grantable"],
+            "json_array_elements": ["value"],
+            "json_array_elements_text": ["value"],
+            "json_each": ["key", "value"],
+            "json_each_text": ["key", "value"],
+            "jsonb_array_elements": ["value"],
+            "jsonb_array_elements_text": ["value"],
+            "jsonb_each": ["key", "value"],
+            "jsonb_each_text": ["key", "value"],
+            "ts_debug": ["alias, description, token, dictionaries, dictionary, lexemes"],
+            "ts_parse": ["tokid", "token"],
+            "ts_stat": ["word", "ndoc", "nentry"],
+            "ts_token_type": ["tokid", "alias", "description"],
+        }
+
+
+# sqlglot is missing pseudocolumns for Postgres
+postgres.Postgres.PSEUDOCOLUMNS = {c.upper() for c in PostgresSettings.PSEUDOCOLUMNS.keys()}
+postgres.Postgres.EXCLUDES_PSEUDOCOLUMNS_FROM_STAR = True

sqlleaf/typing.py

@@ -0,0 +1,93 @@
+import typing as t
+from dataclasses import dataclass
+from enum import StrEnum, auto
+
+from sqlglot import exp
+from sqlglot.optimizer import Scope
+
+E = t.TypeVar("E", bound=exp.Expr)
+
+"""
+Represents a source and a target object of an SQL query.
+
+For example,
+    INSERT INTO <target> SELECT * FROM <source>
+    COPY <target> FROM <source>
+"""
+
+TargetExprType = exp.Table | exp.Literal | exp.Identifier | exp.Schema
+SourceExprType = exp.Table | exp.Literal | exp.Identifier | exp.Select | exp.Schema | exp.Values
+
+TableOrScopeType = exp.Table | Scope
+
+
+class SqlObjectType(StrEnum):
+    """
+    The types of models that represent a 'source' or 'target' in an SQL statement.
+    """
+
+    NONE = auto()
+
+    # Targets and sources
+    DATABASE = auto()
+    DYNAMODB = auto()
+    FILE = auto()
+    PREPARED_STATEMENT = auto()
+    PROCEDURE = auto()
+    PROGRAM = auto()
+    SCHEMA = auto()
+    STAGE = auto()
+    STREAM = auto()
+    TABLE = auto()
+    # Sources
+    DML = auto()
+    SELECT = auto()
+    SET = auto()  # Temporary
+    TUPLE = auto()  # Temporary
+    VALUES = auto()
+
+    @classmethod
+    def type_has_no_column_defs(cls, *clses: t.Iterable) -> bool:
+        """
+        Return all the types that do not define any columns of their own.
+        """
+        return not set(clses).isdisjoint({
+            cls.DYNAMODB,
+            cls.FILE,
+            cls.PROGRAM,
+            cls.STAGE,
+            cls.STREAM,
+            cls.PROCEDURE,
+            cls.PREPARED_STATEMENT,
+        })
+
+
+@dataclass(frozen=True)
+class SourceInfo:
+    expression: SourceExprType
+    type: SqlObjectType
+
+
+@dataclass(frozen=True)
+class TargetInfo:
+    expression: TargetExprType
+    type: SqlObjectType
+
+
+# TODO: merge this with SqlObjectType?
+class TableType(StrEnum):
+    TABLE = auto()
+    VIEW = auto()
+    CTE = auto()
+    DERIVED_TABLE = auto()
+    STAGE = auto()
+    FILE = auto()
+    UDTF = auto()  # LATERAL hello() as hello(col1, col2)
+    PROCEDURE = auto()
+
+
+class TableSubtype(StrEnum):
+    RECURSIVE = auto()
+    TEMPORARY = auto()
+    EXTERNAL = auto()
+    MATERIALIZED = auto()