sqlglotc 30.1.0__tar.gz → 30.2.0__tar.gz

{sqlglotc-30.1.0/sqlglotc.egg-info → sqlglotc-30.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.1.0
+Version: 30.2.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglotc-30.1.0 → sqlglotc-30.2.0}/setup.py

@@ -65,6 +65,8 @@ def _source_files(src_dir):
                 "qualify.py",
                 "qualify_tables.py",
                 "qualify_columns.py",
+                "simplify.py",
+                "annotate_types.py",
             ],
         ),
         *_subpkg_files(src_dir, "parsers"),

{sqlglotc-30.1.0 → sqlglotc-30.2.0}/sqlglot/expressions/builders.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import re
 import typing as t
 
-from sqlglot._typing import E
 from sqlglot.helper import seq_get, ensure_collection, split_num_words
 from sqlglot.errors import ParseError, TokenError
 from sqlglot.expressions.core import (
@@ -43,21 +42,32 @@ from sqlglot.expressions.query import (
     Values,
     Where,
     With,
+    Query,
 )
 from sqlglot.expressions.ddl import Alter, AlterRename, RenameColumn
 from sqlglot.expressions.dml import Delete, Insert, Merge, Update, When, Whens
 from sqlglot.expressions.functions import Case, Cast
 from sqlglot.expressions.array import Array
 
+
 if t.TYPE_CHECKING:
-    from collections.abc import Sequence, Iterable
+    from collections.abc import Sequence, Iterable, Iterator
     from sqlglot.dialects.dialect import DialectType
     from sqlglot.expressions.core import ExpOrStr, Func
     from sqlglot.expressions.datatypes import DATA_TYPE
-    from sqlglot.expressions.query import Query
+    from sqlglot._typing import ParserArgs, ParserNoDialectArgs, E
+    from typing_extensions import Unpack, ParamSpec, Concatenate
+    from sqlglot.expressions.core import Dot
+
+    P = ParamSpec("P")
 
 
-def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts: t.Any) -> Select:
+def select(
+    *expressions: ExpOrStr,
+    dialect: DialectType = None,
+    copy: bool = True,
+    **opts: Unpack[ParserNoDialectArgs],
+) -> Select:
     """
     Initializes a syntax tree from one or multiple SELECT expressions.
 
@@ -76,10 +86,15 @@ def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts: t.Any) -
     Returns:
         Select: the syntax tree for the SELECT statement.
     """
-    return Select().select(*expressions, dialect=dialect, **opts)
+    return Select().select(*expressions, dialect=dialect, copy=copy, **opts)
 
 
-def from_(expression: ExpOrStr, dialect: DialectType = None, **opts: t.Any) -> Select:
+def from_(
+    expression: ExpOrStr,
+    dialect: DialectType = None,
+    copy: bool = True,
+    **opts: Unpack[ParserNoDialectArgs],
+) -> Select:
     """
     Initializes a syntax tree from a FROM expression.
 
@@ -98,17 +113,18 @@ def from_(expression: ExpOrStr, dialect: DialectType = None, **opts: t.Any) -> S
     Returns:
         Select: the syntax tree for the SELECT statement.
     """
-    return Select().from_(expression, dialect=dialect, **opts)
+    return Select().from_(expression, dialect=dialect, copy=copy, **opts)
 
 
 def update(
     table: str | Table,
-    properties: t.Optional[dict] = None,
+    properties: t.Optional[dict[str, object]] = None,
     where: t.Optional[ExpOrStr] = None,
     from_: t.Optional[ExpOrStr] = None,
     with_: t.Optional[dict[str, ExpOrStr]] = None,
     dialect: DialectType = None,
-    **opts: t.Any,
+    copy: bool = True,
+    **opts: Unpack[ParserNoDialectArgs],
 ) -> Update:
     """
     Creates an update statement.
@@ -124,35 +140,38 @@ def update(
         from_: sql statement parsed into a FROM statement
         with_: dictionary of CTE aliases / select statements to include in a WITH clause.
         dialect: the dialect used to parse the input expressions.
+        copy: whether to copy the input expressions.
         **opts: other options to use to parse the input expressions.
 
     Returns:
         Update: the syntax tree for the UPDATE statement.
     """
-    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
+    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect, copy=copy))
     if properties:
         update_expr.set(
             "expressions",
             [
-                EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
+                EQ(this=maybe_parse(k, dialect=dialect, copy=copy, **opts), expression=convert(v))
                 for k, v in properties.items()
             ],
         )
     if from_:
         update_expr.set(
             "from_",
-            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
+            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", copy=copy, **opts),
         )
     if isinstance(where, Condition):
         where = Where(this=where)
     if where:
         update_expr.set(
             "where",
-            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
+            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", copy=copy, **opts),
         )
     if with_:
         cte_list = [
-            alias_(CTE(this=maybe_parse(qry, dialect=dialect, **opts)), alias, table=True)
+            alias_(
+                CTE(this=maybe_parse(qry, dialect=dialect, copy=copy, **opts)), alias, table=True
+            )
             for alias, qry in with_.items()
         ]
         update_expr.set(
@@ -167,7 +186,7 @@ def delete(
     where: t.Optional[ExpOrStr] = None,
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
-    **opts: t.Any,
+    **opts: Unpack[ParserNoDialectArgs],
 ) -> Delete:
     """
     Builds a delete statement.
@@ -195,13 +214,13 @@ def delete(
 
 def insert(
     expression: ExpOrStr,
-    into: ExpOrStr,
+    into: str | Table,
     columns: t.Optional[Sequence[str | Identifier]] = None,
     overwrite: t.Optional[bool] = None,
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
     copy: bool = True,
-    **opts: t.Any,
+    **opts: Unpack[ParserNoDialectArgs],
 ) -> Insert:
     """
     Builds an INSERT statement.
@@ -245,7 +264,7 @@ def merge(
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
     copy: bool = True,
-    **opts: t.Any,
+    **opts: Unpack[ParserNoDialectArgs],
 ) -> Merge:
     """
     Builds a MERGE statement.
@@ -271,7 +290,7 @@ def merge(
     Returns:
         Merge: The syntax tree for the MERGE statement.
     """
-    expressions: t.List[Expr] = []
+    expressions: list[Expr] = []
     for when_expr in when_exprs:
         expression = maybe_parse(when_expr, dialect=dialect, copy=copy, into=Whens, **opts)
         expressions.extend([expression] if isinstance(expression, When) else expression.expressions)
@@ -332,7 +351,7 @@ def to_interval(interval: str | Expr) -> Interval:
 
 
 def to_table(
-    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs
+    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs: object
 ) -> Table:
     """
     Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
@@ -360,10 +379,7 @@ def to_table(
 
         table = table_(this, db=db, catalog=catalog)
 
-    for k, v in kwargs.items():
-        table.set(k, v)
-
-    return table
+    return table.set_kwargs(kwargs)
 
 
 def to_column(
@@ -371,8 +387,8 @@ def to_column(
     quoted: t.Optional[bool] = None,
     dialect: DialectType = None,
     copy: bool = True,
-    **kwargs,
-) -> Column:
+    **kwargs: t.Any,
+) -> t.Union[Column, Dot]:
     """
     Create a column from a `[table].[column]` sql path. Table is optional.
     If a column is passed in then that column is returned.
@@ -409,7 +425,8 @@ def subquery(
     expression: ExpOrStr,
     alias: t.Optional[Identifier | str] = None,
     dialect: DialectType = None,
-    **opts: t.Any,
+    copy: bool = True,
+    **opts: Unpack[ParserNoDialectArgs],
 ) -> Select:
     """
     Build a subquery expression that's selected from.
@@ -428,9 +445,10 @@ def subquery(
     Returns:
         A new Select instance with the subquery expression included.
     """
-
-    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias, **opts)
-    return Select().from_(expression, dialect=dialect, **opts)
+    expr = (
+        maybe_parse(expression, dialect=dialect, **opts).assert_is(Query).subquery(alias, copy=copy)
+    )
+    return Select().from_(expr, dialect=dialect, **opts)
 
 
 def cast(
@@ -438,7 +456,7 @@ def cast(
     to: DATA_TYPE,
     copy: bool = True,
     dialect: DialectType = None,
-    **opts: t.Any,
+    **opts: Unpack[ParserNoDialectArgs],
 ) -> Cast:
     """Cast an expression to a data type.
 
@@ -630,7 +648,12 @@ def rename_column(
     )
 
 
-def replace_children(expression: Expr, fun: t.Callable, *args, **kwargs) -> None:
+def replace_children(
+    expression: Expr,
+    fun: t.Callable[Concatenate[Expr, P], object],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> None:
     """
     Replace children of an expression with the result of a lambda fun(child) -> exp.
     """
@@ -655,7 +678,7 @@ def replace_children(expression: Expr, fun: t.Callable, *args, **kwargs) -> None
 
 def replace_tree(
     expression: Expr,
-    fun: t.Callable,
+    fun: t.Callable[[Expr], Expr],
     prune: t.Optional[t.Callable[[Expr], bool]] = None,
 ) -> Expr:
     """
@@ -679,7 +702,7 @@ def replace_tree(
     return new_node
 
 
-def find_tables(expression: Expr) -> t.Set[Table]:
+def find_tables(expression: Expr) -> set[Table]:
     """
     Find all tables referenced in a query.
 
@@ -699,7 +722,7 @@ def find_tables(expression: Expr) -> t.Set[Table]:
     }
 
 
-def column_table_names(expression: Expr, exclude: str = "") -> t.Set[str]:
+def column_table_names(expression: Expr, exclude: str = "") -> set[str]:
     """
     Return all table names referenced through columns in an expression.
 
@@ -779,7 +802,7 @@ def normalize_table_name(table: str | Table, dialect: DialectType = None, copy:
 
 
 def replace_tables(
-    expression: E, mapping: t.Dict[str, str], dialect: DialectType = None, copy: bool = True
+    expression: E, mapping: dict[str, str], dialect: DialectType = None, copy: bool = True
 ) -> E:
     """Replace all tables in expression according to the mapping.
 
@@ -818,7 +841,7 @@ def replace_tables(
     return expression.transform(_replace_tables, copy=copy)  # type: ignore
 
 
-def replace_placeholders(expression: Expr, *args, **kwargs) -> Expr:
+def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Expr:
     """Replace placeholders in an expression.
 
     Args:
@@ -838,7 +861,7 @@ def replace_placeholders(expression: Expr, *args, **kwargs) -> Expr:
         The mapped expression.
     """
 
-    def _replace_placeholders(node: Expr, args, **kwargs) -> Expr:
+    def _replace_placeholders(node: Expr, args: Iterator[object], **kwargs: object) -> Expr:
         if isinstance(node, Placeholder):
             if node.this:
                 new_name = kwargs.get(node.this)
@@ -856,7 +879,7 @@ def replace_placeholders(expression: Expr, *args, **kwargs) -> Expr:
 
 def expand(
     expression: Expr,
-    sources: t.Dict[str, Query | t.Callable[[], Query]],
+    sources: dict[str, Query | t.Callable[[], Query]],
     dialect: DialectType = None,
     copy: bool = True,
 ) -> Expr:
@@ -900,7 +923,9 @@ def expand(
     return expression.transform(_expand, copy=copy)
 
 
-def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwargs) -> Func:
+def func(
+    name: str, *args: t.Any, copy: bool = True, dialect: DialectType = None, **kwargs: t.Any
+) -> Func:
     """
     Returns a Func expression.
 
@@ -932,7 +957,7 @@ def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwa
 
     dialect = Dialect.get_or_raise(dialect)
 
-    converted: t.List[Expr] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
+    converted: list[Expr] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
     kwargs = {key: maybe_parse(value, dialect=dialect, copy=copy) for key, value in kwargs.items()}
 
     constructor = dialect.parser_class.FUNCTIONS.get(name.upper())
@@ -967,7 +992,8 @@ def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwa
 
 def case(
     expression: t.Optional[ExpOrStr] = None,
-    **opts: t.Any,
+    copy: bool = True,
+    **opts: Unpack[ParserArgs],
 ) -> Case:
     """
     Initialize a CASE statement.
@@ -977,17 +1003,21 @@ def case(
 
     Args:
         expression: Optionally, the input expression (not all dialects support this)
+        copy: whether to copy the argument expressions.
         **opts: Extra keyword arguments for parsing `expression`
     """
     if expression is not None:
-        this = maybe_parse(expression, **opts)
+        this = maybe_parse(expression, copy=copy, **opts)
     else:
         this = None
     return Case(this=this, ifs=[])
 
 
 def array(
-    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
+    *expressions: ExpOrStr,
+    copy: bool = True,
+    dialect: DialectType = None,
+    **kwargs: Unpack[ParserNoDialectArgs],
 ) -> Array:
     """
     Returns an array.
@@ -1014,7 +1044,10 @@ def array(
 
 
 def tuple_(
-    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
+    *expressions: ExpOrStr,
+    copy: bool = True,
+    dialect: DialectType = None,
+    **kwargs: Unpack[ParserNoDialectArgs],
 ) -> Tuple:
     """
     Returns an tuple.
@@ -1063,10 +1096,10 @@ def null() -> Null:
 
 def apply_index_offset(
     this: Expr,
-    expressions: t.List[E],
+    expressions: list[E],
     offset: int,
     dialect: DialectType = None,
-) -> t.List[E]:
+) -> list[E]:
     if not offset or len(expressions) != 1:
         return expressions