sqlglot 28.4.0__py3-none-any.whl → 28.8.0__py3-none-any.whl

sqlglot/dialects/exasol.py

@@ -16,6 +16,7 @@ from sqlglot.dialects.dialect import (
     build_date_delta,
     no_last_day_sql,
     DATE_ADD_OR_SUB,
+    build_timetostr_or_tochar,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
@@ -319,6 +320,7 @@ class Exasol(Dialect):
             "ENDIF": TokenType.END,
             "LONG VARCHAR": TokenType.TEXT,
             "SEPARATOR": TokenType.SEPARATOR,
+            "SYSTIMESTAMP": TokenType.SYSTIMESTAMP,
         }
         KEYWORDS.pop("DIV")
 
@@ -368,7 +370,7 @@ class Exasol(Dialect):
             "TRUNCATE": _build_trunc,
             "VAR_POP": exp.VariancePop.from_arg_list,
             "APPROXIMATE_COUNT_DISTINCT": exp.ApproxDistinct.from_arg_list,
-            "TO_CHAR": build_formatted_time(exp.ToChar, "exasol"),
+            "TO_CHAR": build_timetostr_or_tochar,
             "TO_DATE": build_formatted_time(exp.TsOrDsToDate, "exasol"),
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/convert_tz.htm
             "CONVERT_TZ": lambda args: exp.ConvertTimezone(
@@ -387,6 +389,17 @@ class Exasol(Dialect):
                 this=self._match(TokenType.IS) and self._parse_string(),
             ),
         }
+
+        FUNC_TOKENS = {
+            *parser.Parser.FUNC_TOKENS,
+            TokenType.SYSTIMESTAMP,
+        }
+
+        NO_PAREN_FUNCTIONS = {
+            **parser.Parser.NO_PAREN_FUNCTIONS,
+            TokenType.SYSTIMESTAMP: exp.Systimestamp,
+        }
+
         FUNCTION_PARSERS = {
             **parser.Parser.FUNCTION_PARSERS,
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/listagg.htm
@@ -438,6 +451,9 @@ class Exasol(Dialect):
             exp.DataType.Type.DECIMAL128: "DECIMAL",
             exp.DataType.Type.DECIMAL256: "DECIMAL",
             exp.DataType.Type.DATETIME: "TIMESTAMP",
+            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
+            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
+            exp.DataType.Type.TIMESTAMPNTZ: "TIMESTAMP",
         }
 
         def datatype_sql(self, expression: exp.DataType) -> str:

sqlglot/dialects/hive.py

@@ -30,6 +30,7 @@ from sqlglot.dialects.dialect import (
     struct_extract_sql,
     time_format,
     timestrtotime_sql,
+    trim_sql,
     unit_to_str,
     var_map_sql,
     sequence_sql,
@@ -48,6 +49,10 @@ from sqlglot.generator import unsupported_args
 from sqlglot.optimizer.annotate_types import TypeAnnotator
 from sqlglot.typing.hive import EXPRESSION_METADATA
 
+if t.TYPE_CHECKING:
+    from sqlglot._typing import F
+
+
 # (FuncType, Multiplier)
 DATE_DELTA_INTERVAL = {
     "YEAR": ("ADD_MONTHS", 12),
@@ -315,6 +320,12 @@ class Hive(Dialect):
         CHANGE_COLUMN_ALTER_SYNTAX = False
         # Whether the dialect supports using ALTER COLUMN syntax with CHANGE COLUMN.
 
+        FUNCTION_PARSERS = {
+            **parser.Parser.FUNCTION_PARSERS,
+            "PERCENTILE": lambda self: self._parse_quantile_function(exp.Quantile),
+            "PERCENTILE_APPROX": lambda self: self._parse_quantile_function(exp.ApproxQuantile),
+        }
+
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
             "BASE64": exp.ToBase64.from_arg_list,
@@ -345,8 +356,6 @@ class Hive(Dialect):
             "LAST_VALUE": _build_with_ignore_nulls(exp.LastValue),
             "MAP": parser.build_var_map,
             "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate.from_arg_list(args)),
-            "PERCENTILE": exp.Quantile.from_arg_list,
-            "PERCENTILE_APPROX": exp.ApproxQuantile.from_arg_list,
             "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
             "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
             "SEQUENCE": exp.GenerateSeries.from_arg_list,
@@ -423,6 +432,21 @@ class Hive(Dialect):
                 record_reader=record_reader,
             )
 
+        def _parse_quantile_function(self, func: t.Type[F]) -> F:
+            if self._match(TokenType.DISTINCT):
+                first_arg: t.Optional[exp.Expression] = self.expression(
+                    exp.Distinct, expressions=[self._parse_lambda()]
+                )
+            else:
+                self._match(TokenType.ALL)
+                first_arg = self._parse_lambda()
+
+            args = [first_arg]
+            if self._match(TokenType.COMMA):
+                args.extend(self._parse_function_args())
+
+            return func.from_arg_list(args)
+
         def _parse_types(
             self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
         ) -> t.Optional[exp.Expression]:
@@ -660,6 +684,7 @@ class Hive(Dialect):
             exp.TsOrDsDiff: _date_diff_sql,
             exp.TsOrDsToDate: _to_date_sql,
             exp.TryCast: no_trycast_sql,
+            exp.Trim: trim_sql,
             exp.Unicode: rename_func("ASCII"),
             exp.UnixToStr: lambda self, e: self.func(
                 "FROM_UNIXTIME", e.this, time_format("hive")(self, e)

sqlglot/dialects/mysql.py

@@ -30,6 +30,7 @@ from sqlglot.dialects.dialect import (
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
 from sqlglot.tokens import TokenType
+from sqlglot.typing.mysql import EXPRESSION_METADATA
 
 
 def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[MySQL.Parser], exp.Show]:
@@ -164,6 +165,9 @@ class MySQL(Dialect):
     SUPPORTS_SEMI_ANTI_JOIN = False
     SAFE_DIVISION = True
     SAFE_TO_ELIMINATE_DOUBLE_NEGATION = False
+    LEAST_GREATEST_IGNORES_NULLS = False
+
+    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 
     # https://prestodb.io/docs/current/functions/datetime.html#mysql-date-functions
     TIME_MAPPING = {
@@ -292,6 +296,7 @@ class MySQL(Dialect):
             TokenType.MOD,
             TokenType.SCHEMA,
             TokenType.VALUES,
+            TokenType.CHARACTER_SET,
         }
 
         CONJUNCTION = {
@@ -372,11 +377,6 @@ class MySQL(Dialect):
 
         FUNCTION_PARSERS = {
             **parser.Parser.FUNCTION_PARSERS,
-            "CHAR": lambda self: self.expression(
-                exp.Chr,
-                expressions=self._parse_csv(self._parse_assignment),
-                charset=self._match(TokenType.USING) and self._parse_var(),
-            ),
             "GROUP_CONCAT": lambda self: self._parse_group_concat(),
             # https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
             "VALUES": lambda self: self.expression(
@@ -449,6 +449,7 @@ class MySQL(Dialect):
         PROPERTY_PARSERS = {
             **parser.Parser.PROPERTY_PARSERS,
             "LOCK": lambda self: self._parse_property_assignment(exp.LockProperty),
+            "PARTITION BY": lambda self: self._parse_partition_property(),
         }
 
         SET_PARSERS = {
@@ -732,6 +733,63 @@ class MySQL(Dialect):
 
             return self.expression(exp.AlterIndex, this=index, visible=visible)
 
+        def _parse_partition_property(
+            self,
+        ) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
+            partition_cls: t.Optional[t.Type[exp.Expression]] = None
+            value_parser = None
+
+            if self._match_text_seq("RANGE"):
+                partition_cls = exp.PartitionByRangeProperty
+                value_parser = self._parse_partition_range_value
+            elif self._match_text_seq("LIST"):
+                partition_cls = exp.PartitionByListProperty
+                value_parser = self._parse_partition_list_value
+
+            if not partition_cls or not value_parser:
+                return None
+
+            partition_expressions = self._parse_wrapped_csv(self._parse_assignment)
+
+            # For Doris and Starrocks
+            if not self._match_text_seq("(", "PARTITION", advance=False):
+                return partition_expressions
+
+            create_expressions = self._parse_wrapped_csv(value_parser)
+
+            return self.expression(
+                partition_cls,
+                partition_expressions=partition_expressions,
+                create_expressions=create_expressions,
+            )
+
+        def _parse_partition_range_value(self) -> t.Optional[exp.Expression]:
+            self._match_text_seq("PARTITION")
+            name = self._parse_id_var()
+
+            if not self._match_text_seq("VALUES", "LESS", "THAN"):
+                return name
+
+            values = self._parse_wrapped_csv(self._parse_expression)
+
+            if (
+                len(values) == 1
+                and isinstance(values[0], exp.Column)
+                and values[0].name.upper() == "MAXVALUE"
+            ):
+                values = [exp.var("MAXVALUE")]
+
+            part_range = self.expression(exp.PartitionRange, this=name, expressions=values)
+            return self.expression(exp.Partition, expressions=[part_range])
+
+        def _parse_partition_list_value(self) -> exp.Partition:
+            self._match_text_seq("PARTITION")
+            name = self._parse_id_var()
+            self._match_text_seq("VALUES", "IN")
+            values = self._parse_wrapped_csv(self._parse_expression)
+            part_list = self.expression(exp.PartitionList, this=name, expressions=values)
+            return self.expression(exp.Partition, expressions=[part_list])
+
     class Generator(generator.Generator):
         INTERVAL_ALLOWS_PLURAL_FORM = False
         LOCKING_READS_SUPPORTED = True
@@ -752,6 +810,7 @@ class MySQL(Dialect):
         WRAP_DERIVED_VALUES = False
         VARCHAR_REQUIRES_SIZE = True
         SUPPORTS_MEDIAN = False
+        UPDATE_STATEMENT_SUPPORTS_FROM = False
 
         TRANSFORMS = {
             **generator.Generator.TRANSFORMS,
@@ -760,6 +819,7 @@ class MySQL(Dialect):
             exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXorAgg: rename_func("BIT_XOR"),
             exp.BitwiseCount: rename_func("BIT_COUNT"),
+            exp.Chr: lambda self, e: self.chr_sql(e, "CHAR"),
             exp.CurrentDate: no_paren_current_date_sql,
             exp.DateDiff: _remove_ts_or_ds_to_date(
                 lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
@@ -869,6 +929,9 @@ class MySQL(Dialect):
             **generator.Generator.PROPERTIES_LOCATION,
             exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
             exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
+            exp.PartitionedByProperty: exp.Properties.Location.UNSUPPORTED,
+            exp.PartitionByRangeProperty: exp.Properties.Location.POST_SCHEMA,
+            exp.PartitionByListProperty: exp.Properties.Location.POST_SCHEMA,
         }
 
         LIMIT_FETCH = "LIMIT"
@@ -1281,6 +1344,12 @@ class MySQL(Dialect):
 
             return f"SHOW{full}{global_}{this}{json}{target}{for_table}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}{for_group}{for_user}{for_role}{into_outfile}"
 
+        def alterrename_sql(self, expression: exp.AlterRename, include_to: bool = True) -> str:
+            """To avoid TO keyword in ALTER ... RENAME statements.
+            It's moved from Doris, because it's the same for all MySQL, Doris, and StarRocks.
+            """
+            return super().alterrename_sql(expression, include_to=False)
+
         def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
             dtype = self.sql(expression, "dtype")
             if not dtype:
@@ -1301,12 +1370,6 @@ class MySQL(Dialect):
                 return f" LIMIT {limit_offset}"
             return ""
 
-        def chr_sql(self, expression: exp.Chr) -> str:
-            this = self.expressions(sqls=[expression.this] + expression.expressions)
-            charset = expression.args.get("charset")
-            using = f" USING {self.sql(charset)}" if charset else ""
-            return f"CHAR({this}{using})"
-
         def timestamptrunc_sql(self, expression: exp.TimestampTrunc) -> str:
             unit = expression.args.get("unit")
 
@@ -1342,3 +1405,32 @@ class MySQL(Dialect):
         @unsupported_args("this")
         def currentschema_sql(self, expression: exp.CurrentSchema) -> str:
             return self.func("SCHEMA")
+
+        def partition_sql(self, expression: exp.Partition) -> str:
+            parent = expression.parent
+            if isinstance(parent, (exp.PartitionByRangeProperty, exp.PartitionByListProperty)):
+                return self.expressions(expression, flat=True)
+            return super().partition_sql(expression)
+
+        def _partition_by_sql(
+            self, expression: exp.PartitionByRangeProperty | exp.PartitionByListProperty, kind: str
+        ) -> str:
+            partitions = self.expressions(expression, key="partition_expressions", flat=True)
+            create = self.expressions(expression, key="create_expressions", flat=True)
+            return f"PARTITION BY {kind} ({partitions}) ({create})"
+
+        def partitionbyrangeproperty_sql(self, expression: exp.PartitionByRangeProperty) -> str:
+            return self._partition_by_sql(expression, "RANGE")
+
+        def partitionbylistproperty_sql(self, expression: exp.PartitionByListProperty) -> str:
+            return self._partition_by_sql(expression, "LIST")
+
+        def partitionlist_sql(self, expression: exp.PartitionList) -> str:
+            name = self.sql(expression, "this")
+            values = self.expressions(expression, flat=True)
+            return f"PARTITION {name} VALUES IN ({values})"
+
+        def partitionrange_sql(self, expression: exp.PartitionRange) -> str:
+            name = self.sql(expression, "this")
+            values = self.expressions(expression, flat=True)
+            return f"PARTITION {name} VALUES LESS THAN ({values})"

sqlglot/dialects/oracle.py

@@ -108,6 +108,7 @@ class Oracle(Dialect):
             "START": TokenType.BEGIN,
             "TOP": TokenType.TOP,
             "VARCHAR2": TokenType.VARCHAR,
+            "SYSTIMESTAMP": TokenType.SYSTIMESTAMP,
         }
 
     class Parser(parser.Parser):
@@ -139,6 +140,11 @@ class Oracle(Dialect):
             "DBMS_RANDOM": lambda self: self._parse_dbms_random(),
         }
 
+        NO_PAREN_FUNCTIONS = {
+            **parser.Parser.NO_PAREN_FUNCTIONS,
+            TokenType.SYSTIMESTAMP: exp.Systimestamp,
+        }
+
         FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
             **parser.Parser.FUNCTION_PARSERS,
             "JSON_ARRAY": lambda self: self._parse_json_array(
@@ -172,7 +178,11 @@ class Oracle(Dialect):
         TYPE_LITERAL_PARSERS = {
             exp.DataType.Type.DATE: lambda self, this, _: self.expression(
                 exp.DateStrToDate, this=this
-            )
+            ),
+            # https://docs.oracle.com/en/database/oracle/oracle-database/19/refrn/NLS_TIMESTAMP_FORMAT.html
+            exp.DataType.Type.TIMESTAMP: lambda self, this, _: _build_to_timestamp(
+                [this, '"%Y-%m-%d %H:%M:%S.%f"']
+            ),
         }
 
         # SELECT UNIQUE .. is old-style Oracle syntax for SELECT DISTINCT ..
@@ -275,6 +285,22 @@ class Oracle(Dialect):
         def _parse_connect_with_prior(self):
             return self._parse_assignment()
 
+        def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
+            this = super()._parse_column_ops(this)
+
+            if not this:
+                return this
+
+            index = self._index
+
+            # https://docs.oracle.com/en/database/oracle/oracle-database/26/sqlrf/Interval-Expressions.html
+            interval_span = self._parse_interval_span(this)
+            if isinstance(interval_span.args.get("unit"), exp.IntervalSpan):
+                return interval_span
+
+            self._retreat(index)
+            return this
+
         def _parse_insert_table(self) -> t.Optional[exp.Expression]:
             # Oracle does not use AS for INSERT INTO alias
             # https://docs.oracle.com/en/database/oracle/oracle-database/18/sqlrf/INSERT.html
@@ -368,6 +394,7 @@ class Oracle(Dialect):
             e: f"TO_DATE('1970-01-01', 'YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)",
             exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
             exp.UtcTime: rename_func("UTC_TIME"),
+            exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
         }
 
         PROPERTIES_LOCATION = {
@@ -420,3 +447,13 @@ class Oracle(Dialect):
 
         def isascii_sql(self, expression: exp.IsAscii) -> str:
             return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"
+
+        def interval_sql(self, expression: exp.Interval) -> str:
+            return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"
+
+        def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
+            param_constraint = expression.find(exp.InOutColumnConstraint)
+            if param_constraint:
+                sep = f" {self.sql(param_constraint)} "
+                param_constraint.pop()
+            return super().columndef_sql(expression, sep)