sqlglot 27.6.0__py3-none-any.whl → 27.8.0__py3-none-any.whl

sqlglot/dialects/teradata.py

@@ -90,6 +90,7 @@ class Teradata(Dialect):
             "HELP": TokenType.COMMAND,
             "INS": TokenType.INSERT,
             "LE": TokenType.LTE,
+            "LOCKING": TokenType.LOCK,
             "LT": TokenType.LT,
             "MINUS": TokenType.EXCEPT,
             "MOD": TokenType.MOD,
@@ -155,6 +156,26 @@ class Teradata(Dialect):
                 exp.Use, this=self._parse_table(schema=False)
             ),
             TokenType.REPLACE: lambda self: self._parse_create(),
+            TokenType.LOCK: lambda self: self._parse_locking_statement(),
+        }
+
+        def _parse_locking_statement(self) -> exp.LockingStatement:
+            # Reuse exp.LockingProperty parsing for the lock kind, type etc
+            locking_property = self._parse_locking()
+            wrapped_query = self._parse_select()
+
+            if not wrapped_query:
+                self.raise_error("Expected SELECT statement after LOCKING clause")
+
+            return self.expression(
+                exp.LockingStatement,
+                this=locking_property,
+                expression=wrapped_query,
+            )
+
+        SET_PARSERS = {
+            **parser.Parser.SET_PARSERS,
+            "QUERY_BAND": lambda self: self._parse_query_band(),
         }
 
         FUNCTION_PARSERS = {
@@ -210,6 +231,36 @@ class Teradata(Dialect):
 
             return self.expression(exp.RangeN, this=this, expressions=expressions, each=each)
 
+        def _parse_query_band(self) -> exp.QueryBand:
+            # Parse: SET QUERY_BAND = 'key=value;key2=value2;' FOR SESSION|TRANSACTION
+            # Also supports: SET QUERY_BAND = 'key=value;' UPDATE FOR SESSION|TRANSACTION
+            # Also supports: SET QUERY_BAND = NONE FOR SESSION|TRANSACTION
+            self._match(TokenType.EQ)
+
+            # Handle both string literals and NONE keyword
+            if self._match_text_seq("NONE"):
+                query_band_string: t.Optional[exp.Expression] = exp.Var(this="NONE")
+            else:
+                query_band_string = self._parse_string()
+
+            update = self._match_text_seq("UPDATE")
+            self._match_text_seq("FOR")
+
+            # Handle scope - can be SESSION, TRANSACTION, VOLATILE, or SESSION VOLATILE
+            if self._match_text_seq("SESSION", "VOLATILE"):
+                scope = "SESSION VOLATILE"
+            elif self._match_texts(("SESSION", "TRANSACTION")):
+                scope = self._prev.text.upper()
+            else:
+                scope = None
+
+            return self.expression(
+                exp.QueryBand,
+                this=query_band_string,
+                scope=scope,
+                update=update,
+            )
+
         def _parse_index_params(self) -> exp.IndexParameters:
             this = super()._parse_index_params()
 
@@ -358,6 +409,13 @@ class Teradata(Dialect):
 
             return f"RANGE_N({this} BETWEEN {expressions_sql}{each_sql})"
 
+        def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
+            """Generate SQL for LOCKING statement"""
+            locking_clause = self.sql(expression, "this")
+            query_sql = self.sql(expression, "expression")
+
+            return f"{locking_clause} {query_sql}"
+
         def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
             kind = self.sql(expression, "kind").upper()
             if kind == "TABLE" and locations.get(exp.Properties.Location.POST_NAME):

sqlglot/dialects/trino.py

@@ -21,6 +21,7 @@ class Trino(Presto):
             **Presto.Parser.FUNCTION_PARSERS,
             "TRIM": lambda self: self._parse_trim(),
             "JSON_QUERY": lambda self: self._parse_json_query(),
+            "JSON_VALUE": lambda self: self._parse_json_value(),
             "LISTAGG": lambda self: self._parse_string_agg(),
         }
 

sqlglot/expressions.py

@@ -1458,6 +1458,11 @@ class DDL(Expression):
         return self.expression.named_selects if isinstance(self.expression, Query) else []
 
 
+# https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Manipulation-Language/Statement-Syntax/LOCKING-Request-Modifier/LOCKING-Request-Modifier-Syntax
+class LockingStatement(Expression):
+    arg_types = {"this": True, "expression": True}
+
+
 class DML(Expression):
     def returning(
         self,
@@ -1613,6 +1618,10 @@ class SetItem(Expression):
     }
 
 
+class QueryBand(Expression):
+    arg_types = {"this": True, "scope": False, "update": False}
+
+
 class Show(Expression):
     arg_types = {
         "this": True,
@@ -1680,7 +1689,7 @@ class ProjectionDef(Expression):
 
 
 class TableAlias(Expression):
-    arg_types = {"this": False, "columns": False, "column_only": False}
+    arg_types = {"this": False, "columns": False}
 
     @property
     def columns(self):
@@ -5292,7 +5301,7 @@ class TimeUnit(Expression):
 
     def __init__(self, **args):
         unit = args.get("unit")
-        if isinstance(unit, self.VAR_LIKE):
+        if type(unit) in self.VAR_LIKE:
             args["unit"] = Var(
                 this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
             )
@@ -5416,6 +5425,10 @@ class BitwiseCountAgg(AggFunc):
     _sql_names = ["BIT_COUNT"]
 
 
+class ByteLength(Func):
+    pass
+
+
 class ArrayRemove(Func):
     arg_types = {"this": True, "expression": True}
 
@@ -5451,6 +5464,15 @@ class Transform(Func):
     arg_types = {"this": True, "expression": True}
 
 
+class Translate(Func):
+    arg_types = {"this": True, "from": True, "to": True}
+
+
+class Grouping(AggFunc):
+    arg_types = {"expressions": True}
+    is_var_len_args = True
+
+
 class Anonymous(Func):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
@@ -5518,7 +5540,12 @@ class Pad(Func):
 # https://docs.snowflake.com/en/sql-reference/functions/to_char
 # https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/TO_CHAR-number.html
 class ToChar(Func):
-    arg_types = {"this": True, "format": False, "nlsparam": False}
+    arg_types = {
+        "this": True,
+        "format": False,
+        "nlsparam": False,
+        "is_numeric": False,
+    }
 
 
 # https://docs.snowflake.com/en/sql-reference/functions/to_decimal
@@ -5564,6 +5591,10 @@ class ConvertTimezone(Func):
     }
 
 
+class CodePointsToString(Func):
+    pass
+
+
 class GenerateSeries(Func):
     arg_types = {"start": True, "end": True, "step": False, "is_end_exclusive": False}
 
@@ -5791,6 +5822,18 @@ class JSONCast(Cast):
     pass
 
 
+class JustifyDays(Func):
+    pass
+
+
+class JustifyHours(Func):
+    pass
+
+
+class JustifyInterval(Func):
+    pass
+
+
 class Try(Func):
     pass
 
@@ -5947,6 +5990,10 @@ class DatetimeTrunc(Func, TimeUnit):
     arg_types = {"this": True, "unit": True, "zone": False}
 
 
+class DateFromUnixDate(Func):
+    pass
+
+
 class DayOfWeek(Func):
     _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]
 
@@ -6475,7 +6522,13 @@ class JSONExtractArray(Func):
 
 
 class JSONExtractScalar(Binary, Func):
-    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
+    arg_types = {
+        "this": True,
+        "expression": True,
+        "only_json_types": False,
+        "expressions": False,
+        "json_type": False,
+    }
     _sql_names = ["JSON_EXTRACT_SCALAR"]
     is_var_len_args = True
 
@@ -6489,6 +6542,7 @@ class JSONBExtract(Binary, Func):
 
 
 class JSONBExtractScalar(Binary, Func):
+    arg_types = {"this": True, "expression": True, "json_type": False}
     _sql_names = ["JSONB_EXTRACT_SCALAR"]
 
 
@@ -6509,6 +6563,14 @@ class ParseJSON(Func):
     arg_types = {"this": True, "expression": False, "safe": False}
 
 
+class ParseTime(Func):
+    arg_types = {"this": True, "format": True}
+
+
+class ParseDatetime(Func):
+    arg_types = {"this": True, "format": False, "zone": False}
+
+
 class Least(Func):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
@@ -6522,6 +6584,10 @@ class Right(Func):
     arg_types = {"this": True, "expression": True}
 
 
+class Reverse(Func):
+    pass
+
+
 class Length(Func):
     arg_types = {"this": True, "binary": False, "encoding": False}
     _sql_names = ["LENGTH", "LEN", "CHAR_LENGTH", "CHARACTER_LENGTH"]
@@ -6796,6 +6862,10 @@ class SortArray(Func):
     arg_types = {"this": True, "asc": False}
 
 
+class Soundex(Func):
+    pass
+
+
 class Split(Func):
     arg_types = {"this": True, "expression": True, "limit": False}
 
@@ -7047,6 +7117,14 @@ class UnixSeconds(Func):
     pass
 
 
+class UnixMicros(Func):
+    pass
+
+
+class UnixMillis(Func):
+    pass
+
+
 class Uuid(Func):
     _sql_names = ["UUID", "GEN_RANDOM_UUID", "GENERATE_UUID", "UUID_STRING"]
 
@@ -7096,6 +7174,10 @@ class Week(Func):
     arg_types = {"this": True, "mode": False}
 
 
+class WeekStart(Expression):
+    pass
+
+
 class XMLElement(Func):
     _sql_names = ["XMLELEMENT"]
     arg_types = {"this": True, "expressions": False}

sqlglot/generator.py

@@ -219,6 +219,7 @@ class Generator(metaclass=_Generator):
         exp.VarMap: lambda self, e: self.func("MAP", e.args["keys"], e.args["values"]),
         exp.ViewAttributeProperty: lambda self, e: f"WITH {self.sql(e, 'this')}",
         exp.VolatileProperty: lambda *_: "VOLATILE",
+        exp.WeekStart: lambda self, e: f"WEEK({self.sql(e, 'this')})",
         exp.WithJournalTableProperty: lambda self, e: f"WITH JOURNAL TABLE={self.sql(e, 'this')}",
         exp.WithProcedureOptions: lambda self, e: f"WITH {self.expressions(e, flat=True)}",
         exp.WithSchemaBindingProperty: lambda self, e: f"WITH SCHEMA {self.sql(e, 'this')}",
@@ -691,6 +692,8 @@ class Generator(metaclass=_Generator):
 
     RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS: t.Tuple[t.Type[exp.Expression], ...] = ()
 
+    SAFE_JSON_PATH_KEY_RE = exp.SAFE_IDENTIFIER_RE
+
     SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
 
     __slots__ = (
@@ -2405,6 +2408,14 @@ class Generator(metaclass=_Generator):
         tag = " TAG" if expression.args.get("tag") else ""
         return f"{'UNSET' if expression.args.get('unset') else 'SET'}{tag}{expressions}"
 
+    def queryband_sql(self, expression: exp.QueryBand) -> str:
+        this = self.sql(expression, "this")
+        update = " UPDATE" if expression.args.get("update") else ""
+        scope = self.sql(expression, "scope")
+        scope = f" FOR {scope}" if scope else ""
+
+        return f"QUERY_BAND = {this}{update}{scope}"
+
     def pragma_sql(self, expression: exp.Pragma) -> str:
         return f"PRAGMA {self.sql(expression, 'this')}"
 
@@ -3479,14 +3490,15 @@ class Generator(metaclass=_Generator):
         expressions = f"({expressions})" if expressions else ""
         return f"ALTER{compound} SORTKEY {this or expressions}"
 
-    def alterrename_sql(self, expression: exp.AlterRename) -> str:
+    def alterrename_sql(self, expression: exp.AlterRename, include_to: bool = True) -> str:
         if not self.RENAME_TABLE_WITH_DB:
             # Remove db from tables
             expression = expression.transform(
                 lambda n: exp.table_(n.this) if isinstance(n, exp.Table) else n
             ).assert_is(exp.AlterRename)
         this = self.sql(expression, "this")
-        return f"RENAME TO {this}"
+        to_kw = " TO" if include_to else ""
+        return f"RENAME{to_kw} {this}"
 
     def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
         exists = " IF EXISTS" if expression.args.get("exists") else ""
@@ -4352,7 +4364,7 @@ class Generator(metaclass=_Generator):
             this = self.json_path_part(this)
             return f".{this}" if this else ""
 
-        if exp.SAFE_IDENTIFIER_RE.match(this):
+        if self.SAFE_JSON_PATH_KEY_RE.match(this):
             return f".{this}"
 
         this = self.json_path_part(this)
@@ -5127,3 +5139,15 @@ class Generator(metaclass=_Generator):
             return self.sql(exp.Bracket(this=this, expressions=[expr]))
 
         return self.sql(exp.JSONExtract(this=this, expression=self.dialect.to_json_path(expr)))
+
+    def datefromunixdate_sql(self, expression: exp.DateFromUnixDate) -> str:
+        return self.sql(
+            exp.DateAdd(
+                this=exp.cast(exp.Literal.string("1970-01-01"), exp.DataType.Type.DATE),
+                expression=expression.this,
+                unit=exp.var("DAY"),
+            )
+        )
+
+    def space_sql(self: Generator, expression: exp.Space) -> str:
+        return self.sql(exp.Repeat(this=exp.Literal.string(" "), times=expression.this))

sqlglot/jsonpath.py

@@ -36,6 +36,10 @@ class JSONPathTokenizer(Tokenizer):
     IDENTIFIER_ESCAPES = ["\\"]
     STRING_ESCAPES = ["\\"]
 
+    VAR_TOKENS = {
+        TokenType.VAR,
+    }
+
 
 def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
     """Takes in a JSON path string and parses it into a JSONPath expression."""
@@ -76,6 +80,9 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
             raise ParseError(_error(f"Expected {token_type}"))
         return None
 
+    def _match_set(types: t.Collection[TokenType]) -> t.Optional[Token]:
+        return _advance() if _curr() in types else None
+
     def _parse_literal() -> t.Any:
         token = _match(TokenType.STRING) or _match(TokenType.IDENTIFIER)
         if token:
@@ -155,7 +162,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
         """
         prev_index = i - 2
 
-        while _match(TokenType.VAR):
+        while _match_set(jsonpath_tokenizer.VAR_TOKENS):
             pass
 
         start = 0 if prev_index < 0 else tokens[prev_index].end + 1
@@ -177,7 +184,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
         if _match(TokenType.DOT) or _match(TokenType.COLON):
             recursive = _prev().text == ".."
 
-            if _match(TokenType.VAR):
+            if _match_set(jsonpath_tokenizer.VAR_TOKENS):
                 value: t.Optional[str | exp.JSONPathWildcard] = _parse_var_text()
             elif _match(TokenType.IDENTIFIER):
                 value = _prev().text
@@ -194,7 +201,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
                 raise ParseError(_error("Expected key name or * after DOT"))
         elif _match(TokenType.L_BRACKET):
             expressions.append(_parse_bracket())
-        elif _match(TokenType.VAR):
+        elif _match_set(jsonpath_tokenizer.VAR_TOKENS):
             expressions.append(exp.JSONPathKey(this=_parse_var_text()))
         elif _match(TokenType.IDENTIFIER):
             expressions.append(exp.JSONPathKey(this=_prev().text))

sqlglot/optimizer/annotate_types.py

@@ -326,7 +326,10 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
             struct_type = exp.DataType(
                 this=exp.DataType.Type.STRUCT,
                 expressions=[
-                    exp.ColumnDef(this=exp.to_identifier(select.output_name), kind=select.type)
+                    exp.ColumnDef(
+                        this=exp.to_identifier(select.output_name),
+                        kind=select.type.copy() if select.type else None,
+                    )
                     for select in scope.expression.selects
                 ],
                 nested=True,

sqlglot/optimizer/merge_subqueries.py

@@ -330,6 +330,10 @@ def _merge_expressions(outer_scope: Scope, inner_scope: Scope, alias: str) -> No
             if isinstance(column.parent, (exp.Unary, exp.Binary)) and must_wrap_expression:
                 expression = exp.paren(expression, copy=False)
 
+            # make sure we do not accidentally change the name of the column
+            if isinstance(column.parent, exp.Select) and column.name != expression.name:
+                expression = exp.alias_(expression, column.name)
+
             column.replace(expression.copy())
 
 

sqlglot/optimizer/qualify_tables.py

@@ -128,14 +128,6 @@ def qualify_tables(
                 table_alias = udtf.args.get("alias") or exp.TableAlias(
                     this=exp.to_identifier(next_alias_name())
                 )
-                if (
-                    isinstance(udtf, exp.Unnest)
-                    and dialect.UNNEST_COLUMN_ONLY
-                    and not table_alias.columns
-                ):
-                    table_alias.set("columns", [table_alias.this.copy()])
-                    table_alias.set("column_only", True)
-
                 udtf.set("alias", table_alias)
 
                 if not table_alias.name:

sqlglot/parser.py

@@ -577,7 +577,6 @@ class Parser(metaclass=_Parser):
 
     TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
         TokenType.ANTI,
-        TokenType.APPLY,
         TokenType.ASOF,
         TokenType.FULL,
         TokenType.LEFT,
@@ -2084,7 +2083,24 @@ class Parser(metaclass=_Parser):
 
             if create_token.token_type == TokenType.SEQUENCE:
                 expression = self._parse_types()
-                extend_props(self._parse_properties())
+                props = self._parse_properties()
+                if props:
+                    sequence_props = exp.SequenceProperties()
+                    options = []
+                    for prop in props:
+                        if isinstance(prop, exp.SequenceProperties):
+                            for arg, value in prop.args.items():
+                                if arg == "options":
+                                    options.extend(value)
+                                else:
+                                    sequence_props.set(arg, value)
+                            prop.pop()
+
+                    if options:
+                        sequence_props.set("options", options)
+
+                    props.append("expressions", sequence_props)
+                    extend_props(props)
             else:
                 expression = self._parse_ddl_select()
 
@@ -2222,11 +2238,17 @@ class Parser(metaclass=_Parser):
             return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
 
         index = self._index
+
+        seq_props = self._parse_sequence_properties()
+        if seq_props:
+            return seq_props
+
+        self._retreat(index)
         key = self._parse_column()
 
         if not self._match(TokenType.EQ):
             self._retreat(index)
-            return self._parse_sequence_properties()
+            return None
 
         # Transform the key to exp.Dot if it's dotted identifiers wrapped in exp.Column or to exp.Var otherwise
         if isinstance(key, exp.Column):
@@ -3820,7 +3842,8 @@ class Parser(metaclass=_Parser):
         elif self._match(TokenType.USING):
             kwargs["using"] = self._parse_using_identifiers()
         elif (
-            not (outer_apply or cross_apply)
+            not method
+            and not (outer_apply or cross_apply)
             and not isinstance(kwargs["this"], exp.Unnest)
             and not (kind and kind.token_type in (TokenType.CROSS, TokenType.ARRAY))
         ):
@@ -5255,7 +5278,7 @@ class Parser(metaclass=_Parser):
         while self._match(TokenType.DOT):
             type_name = f"{type_name}.{self._advance_any() and self._prev.text}"
 
-        return exp.DataType.build(type_name, udt=True)
+        return exp.DataType.build(type_name, dialect=self.dialect, udt=True)
 
     def _parse_types(
         self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
@@ -6556,7 +6579,7 @@ class Parser(metaclass=_Parser):
         elif not to:
             self.raise_error("Expected TYPE after CAST")
         elif isinstance(to, exp.Identifier):
-            to = exp.DataType.build(to.name, udt=True)
+            to = exp.DataType.build(to.name, dialect=self.dialect, udt=True)
         elif to.this == exp.DataType.Type.CHAR:
             if self._match(TokenType.CHARACTER_SET):
                 to = self.expression(exp.CharacterSet, this=self._parse_var_or_string())
@@ -8684,3 +8707,18 @@ class Parser(metaclass=_Parser):
             kwargs["requires_string"] = self.dialect.TRY_CAST_REQUIRES_STRING
 
         return self.expression(exp_class, **kwargs)
+
+    def _parse_json_value(self) -> exp.JSONValue:
+        this = self._parse_bitwise()
+        self._match(TokenType.COMMA)
+        path = self._parse_bitwise()
+
+        returning = self._match(TokenType.RETURNING) and self._parse_type()
+
+        return self.expression(
+            exp.JSONValue,
+            this=this,
+            path=self.dialect.to_json_path(path),
+            returning=returning,
+            on_condition=self._parse_on_condition(),
+        )

{sqlglot-27.6.0.dist-info → sqlglot-27.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.6.0
+Version: 27.8.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 Project-URL: Homepage, https://sqlglot.com/
@@ -256,7 +256,7 @@ sqlglot.errors.ParseError: Expecting ). Line 1, Col: 34.
 Structured syntax errors are accessible for programmatic use:
 
 ```python
-import sqlglot
+import sqlglot.errors
 try:
     sqlglot.transpile("SELECT foo FROM (SELECT baz FROM t")
 except sqlglot.errors.ParseError as e: