chore: upgrade sqlglot (#1692)

Co-authored-by: anandgupta42 <[email protected]>

Author: mdesmet

altimate_packages/sqlglot/__init__.py

@@ -1,3 +1,4 @@
+# ruff: noqa: F401
 """
 .. include:: ../README.md
 
@@ -22,14 +23,18 @@
     Expression as Expression,
     alias_ as alias,
     and_ as and_,
+    case as case,
     cast as cast,
     column as column,
     condition as condition,
+    delete as delete,
     except_ as except_,
     from_ as from_,
     func as func,
+    insert as insert,
     intersect as intersect,
     maybe_parse as maybe_parse,
+    merge as merge,
     not_ as not_,
     or_ as or_,
     select as select,
@@ -43,7 +48,7 @@
 from sqlglot.generator import Generator as Generator
 from sqlglot.parser import Parser as Parser
 from sqlglot.schema import MappingSchema as MappingSchema, Schema as Schema
-from sqlglot.tokens import Tokenizer as Tokenizer, TokenType as TokenType
+from sqlglot.tokens import Token as Token, Tokenizer as Tokenizer, TokenType as TokenType
 
 if t.TYPE_CHECKING:
     from sqlglot._typing import E
@@ -63,8 +68,20 @@
 pretty = False
 """Whether to format generated SQL by default."""
 
-schema = MappingSchema()
-"""The default schema used by SQLGlot (e.g. in the optimizer)."""
+
+def tokenize(sql: str, read: DialectType = None, dialect: DialectType = None) -> t.List[Token]:
+    """
+    Tokenizes the given SQL string.
+
+    Args:
+        sql: the SQL code string to tokenize.
+        read: the SQL dialect to apply during tokenizing (eg. "spark", "hive", "presto", "mysql").
+        dialect: the SQL dialect (alias for read).
+
+    Returns:
+        The resulting list of tokens.
+    """
+    return Dialect.get_or_raise(read or dialect).tokenize(sql)
 
 
 def parse(
@@ -82,18 +99,15 @@ def parse(
     Returns:
         The resulting syntax tree collection.
     """
-    dialect = Dialect.get_or_raise(read or dialect)()
-    return dialect.parse(sql, **opts)
+    return Dialect.get_or_raise(read or dialect).parse(sql, **opts)
 
 
 @t.overload
-def parse_one(sql: str, *, into: t.Type[E], **opts) -> E:
-    ...
+def parse_one(sql: str, *, into: t.Type[E], **opts) -> E: ...
 
 
 @t.overload
-def parse_one(sql: str, **opts) -> Expression:
-    ...
+def parse_one(sql: str, **opts) -> Expression: ...
 
 
 def parse_one(
@@ -117,7 +131,7 @@ def parse_one(
         The syntax tree for the first parsed statement.
     """
 
-    dialect = Dialect.get_or_raise(read or dialect)()
+    dialect = Dialect.get_or_raise(read or dialect)
 
     if into:
         result = dialect.parse_into(into, sql, **opts)
@@ -157,7 +171,8 @@ def transpile(
         The list of transpiled SQL statements.
     """
     write = (read if write is None else write) if identity else write
+    write = Dialect.get_or_raise(write)
     return [
-        Dialect.get_or_raise(write)().generate(expression, **opts)
+        write.generate(expression, copy=False, **opts) if expression else ""
         for expression in parse(sql, read, error_level=error_level)
     ]

altimate_packages/sqlglot/__main__.py

@@ -1,90 +1,96 @@
-# from __future__ import annotations
-#
-# import argparse
-# import sys
-# import typing as t
-#
-# import sqlglot as sqlglot
-#
-# parser = argparse.ArgumentParser(description="Transpile SQL")
-# parser.add_argument(
-#     "sql",
-#     metavar="sql",
-#     type=str,
-#     help="SQL statement(s) to transpile, or - to parse stdin.",
-# )
-# parser.add_argument(
-#     "--read",
-#     dest="read",
-#     type=str,
-#     default=None,
-#     help="Dialect to read default is generic",
-# )
-# parser.add_argument(
-#     "--write",
-#     dest="write",
-#     type=str,
-#     default=None,
-#     help="Dialect to write default is generic",
-# )
-# parser.add_argument(
-#     "--no-identify",
-#     dest="identify",
-#     action="store_false",
-#     help="Don't auto identify fields",
-# )
-# parser.add_argument(
-#     "--no-pretty",
-#     dest="pretty",
-#     action="store_false",
-#     help="Compress sql",
-# )
-# parser.add_argument(
-#     "--parse",
-#     dest="parse",
-#     action="store_true",
-#     help="Parse and return the expression tree",
-# )
-# parser.add_argument(
-#     "--tokenize",
-#     dest="tokenize",
-#     action="store_true",
-#     help="Tokenize and return the tokens list",
-# )
-# parser.add_argument(
-#     "--error-level",
-#     dest="error_level",
-#     type=str,
-#     default="IMMEDIATE",
-#     help="IGNORE, WARN, RAISE, IMMEDIATE (default)",
-# )
-#
-#
-# args = parser.parse_args()
-# error_level = sqlglot.ErrorLevel[args.error_level.upper()]
-#
-# sql = sys.stdin.read() if args.sql == "-" else args.sql
-#
-# if args.parse:
-#     objs: t.Union[t.List[str], t.List[sqlglot.tokens.Token]] = [
-#         repr(expression)
-#         for expression in sqlglot.parse(
-#             sql,
-#             read=args.read,
-#             error_level=error_level,
-#         )
-#     ]
-# elif args.tokenize:
-#     objs = sqlglot.Dialect.get_or_raise(args.read)().tokenize(sql)
-# else:
-#     objs = sqlglot.transpile(
-#         sql,
-#         read=args.read,
-#         write=args.write,
-#         identify=args.identify,
-#         pretty=args.pretty,
-#         error_level=error_level,
-#     )
-#
-# for obj in objs:
-#     print(obj)
+from __future__ import annotations
+
+import argparse
+import sys
+import typing as t
+
+import sqlglot
+
+parser = argparse.ArgumentParser(description="Transpile SQL")
+parser.add_argument(
+    "sql",
+    metavar="sql",
+    type=str,
+    help="SQL statement(s) to transpile, or - to parse stdin.",
+)
+parser.add_argument(
+    "--read",
+    dest="read",
+    type=str,
+    default=None,
+    help="Dialect to read default is generic",
+)
+parser.add_argument(
+    "--write",
+    dest="write",
+    type=str,
+    default=None,
+    help="Dialect to write default is generic",
+)
+parser.add_argument(
+    "--no-identify",
+    dest="identify",
+    action="store_false",
+    help="Don't auto identify fields",
+)
+parser.add_argument(
+    "--no-pretty",
+    dest="pretty",
+    action="store_false",
+    help="Compress sql",
+)
+parser.add_argument(
+    "--parse",
+    dest="parse",
+    action="store_true",
+    help="Parse and return the expression tree",
+)
+parser.add_argument(
+    "--tokenize",
+    dest="tokenize",
+    action="store_true",
+    help="Tokenize and return the tokens list",
+)
+parser.add_argument(
+    "--error-level",
+    dest="error_level",
+    type=str,
+    default="IMMEDIATE",
+    help="IGNORE, WARN, RAISE, IMMEDIATE (default)",
+)
+parser.add_argument(
+    "--version",
+    action="version",
+    version=sqlglot.__version__,
+    help="Display the SQLGlot version",
+)
+
+
+args = parser.parse_args()
+error_level = sqlglot.ErrorLevel[args.error_level.upper()]
+
+sql = sys.stdin.read() if args.sql == "-" else args.sql
+
+if args.parse:
+    objs: t.Union[t.List[str], t.List[sqlglot.tokens.Token]] = [
+        repr(expression)
+        for expression in sqlglot.parse(
+            sql,
+            read=args.read,
+            error_level=error_level,
+        )
+    ]
+elif args.tokenize:
+    objs = sqlglot.Dialect.get_or_raise(args.read).tokenize(sql)
+else:
+    objs = sqlglot.transpile(
+        sql,
+        read=args.read,
+        write=args.write,
+        identify=args.identify,
+        pretty=args.pretty,
+        error_level=error_level,
+    )
+
+for obj in objs:
+    print(obj)

altimate_packages/sqlglot/_typing.py

@@ -2,7 +2,16 @@
 
 import typing as t
 
-import sqlglot as sqlglot
+import sqlglot
 
+if t.TYPE_CHECKING:
+    from typing_extensions import Literal as Lit  # noqa
+
+# A little hack for backwards compatibility with Python 3.7.
+# For example, we might want a TypeVar for objects that support comparison e.g. SupportsRichComparisonT from typeshed.
+# But Python 3.7 doesn't support Protocols, so we'd also need typing_extensions, which we don't want as a dependency.
+A = t.TypeVar("A", bound=t.Any)
+B = t.TypeVar("B", bound="sqlglot.exp.Binary")
 E = t.TypeVar("E", bound="sqlglot.exp.Expression")
+F = t.TypeVar("F", bound="sqlglot.exp.Func")
 T = t.TypeVar("T")