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

sqlglot/dialects/doris.py

@@ -68,11 +68,36 @@ class Doris(MySQL):
             "UNIQUE": lambda self: self._parse_composite_key_property(exp.UniqueKeyProperty),
             # Plain KEY without UNIQUE/DUPLICATE/AGGREGATE prefixes should be treated as UniqueKeyProperty with unique=False
             "KEY": lambda self: self._parse_composite_key_property(exp.UniqueKeyProperty),
-            "PARTITION BY": lambda self: self._parse_partition_by_opt_range(),
             "BUILD": lambda self: self._parse_build_property(),
             "REFRESH": lambda self: self._parse_refresh_property(),
         }
 
+        def _parse_partition_property(
+            self,
+        ) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
+            expr = super()._parse_partition_property()
+
+            if not expr:
+                return self._parse_partitioned_by()
+
+            if isinstance(expr, exp.Property):
+                return expr
+
+            self._match_l_paren()
+
+            if self._match_text_seq("FROM", advance=False):
+                create_expressions = self._parse_csv(self._parse_partitioning_granularity_dynamic)
+            else:
+                create_expressions = None
+
+            self._match_r_paren()
+
+            return self.expression(
+                exp.PartitionByRangeProperty,
+                partition_expressions=expr,
+                create_expressions=create_expressions,
+            )
+
         def _parse_partitioning_granularity_dynamic(self) -> exp.PartitionByRangePropertyDynamic:
             self._match_text_seq("FROM")
             start = self._parse_wrapped(self._parse_string)
@@ -86,20 +111,16 @@ class Doris(MySQL):
                 exp.PartitionByRangePropertyDynamic, start=start, end=end, every=every
             )
 
-        def _parse_partition_definition(self) -> exp.Partition:
-            self._match_text_seq("PARTITION")
+        def _parse_partition_range_value(self) -> exp.Partition:
+            expr = super()._parse_partition_range_value()
 
-            name = self._parse_id_var()
-            self._match_text_seq("VALUES")
-
-            if self._match_text_seq("LESS", "THAN"):
-                values = self._parse_wrapped_csv(self._parse_expression)
-                if len(values) == 1 and values[0].name.upper() == "MAXVALUE":
-                    values = [exp.var("MAXVALUE")]
+            if isinstance(expr, exp.Partition):
+                return expr
 
-                part_range = self.expression(exp.PartitionRange, this=name, expressions=values)
-                return self.expression(exp.Partition, expressions=[part_range])
+            self._match_text_seq("VALUES")
+            name = expr
 
+            # Doris-specific bracket syntax: VALUES [(...), (...))
             self._match(TokenType.L_BRACKET)
             values = self._parse_csv(lambda: self._parse_wrapped_csv(self._parse_expression))
 
@@ -109,48 +130,6 @@ class Doris(MySQL):
             part_range = self.expression(exp.PartitionRange, this=name, expressions=values)
             return self.expression(exp.Partition, expressions=[part_range])
 
-        def _parse_partition_definition_list(self) -> exp.Partition:
-            # PARTITION <name> VALUES IN (<value_csv>)
-            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])
-
-        def _parse_partition_by_opt_range(
-            self,
-        ) -> exp.PartitionedByProperty | exp.PartitionByRangeProperty | exp.PartitionByListProperty:
-            if self._match_text_seq("LIST"):
-                return self.expression(
-                    exp.PartitionByListProperty,
-                    partition_expressions=self._parse_wrapped_id_vars(),
-                    create_expressions=self._parse_wrapped_csv(
-                        self._parse_partition_definition_list
-                    ),
-                )
-
-            if not self._match_text_seq("RANGE"):
-                return super()._parse_partitioned_by()
-
-            partition_expressions = self._parse_wrapped_id_vars()
-            self._match_l_paren()
-
-            if self._match_text_seq("FROM", advance=False):
-                create_expressions = self._parse_csv(self._parse_partitioning_granularity_dynamic)
-            elif self._match_text_seq("PARTITION", advance=False):
-                create_expressions = self._parse_csv(self._parse_partition_definition)
-            else:
-                create_expressions = None
-
-            self._match_r_paren()
-
-            return self.expression(
-                exp.PartitionByRangeProperty,
-                partition_expressions=partition_expressions,
-                create_expressions=create_expressions,
-            )
-
         def _parse_build_property(self) -> exp.BuildProperty:
             return self.expression(exp.BuildProperty, this=self._parse_var(upper=True))
 
@@ -178,6 +157,7 @@ class Doris(MySQL):
         VARCHAR_REQUIRES_SIZE = False
         WITH_PROPERTIES_PREFIX = "PROPERTIES"
         RENAME_TABLE_WITH_DB = False
+        UPDATE_STATEMENT_SUPPORTS_FROM = True
 
         TYPE_MAPPING = {
             **MySQL.Generator.TYPE_MAPPING,
@@ -189,11 +169,8 @@ class Doris(MySQL):
         PROPERTIES_LOCATION = {
             **MySQL.Generator.PROPERTIES_LOCATION,
             exp.UniqueKeyProperty: exp.Properties.Location.POST_SCHEMA,
-            exp.PartitionByRangeProperty: exp.Properties.Location.POST_SCHEMA,
-            exp.PartitionByListProperty: exp.Properties.Location.POST_SCHEMA,
             exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
             exp.BuildProperty: exp.Properties.Location.POST_SCHEMA,
-            exp.RefreshTriggerProperty: exp.Properties.Location.POST_SCHEMA,
         }
 
         CAST_MAPPING = {}
@@ -720,12 +697,6 @@ class Doris(MySQL):
 
             return super().uniquekeyproperty_sql(expression)
 
-        def partition_sql(self, expression: exp.Partition) -> str:
-            parent = expression.parent
-            if isinstance(parent, (exp.PartitionByRangeProperty, exp.PartitionByListProperty)):
-                return ", ".join(self.sql(e) for e in expression.expressions)
-            return super().partition_sql(expression)
-
         def partitionrange_sql(self, expression: exp.PartitionRange) -> str:
             name = self.sql(expression, "this")
             values = expression.expressions
@@ -759,31 +730,11 @@ class Doris(MySQL):
 
             return f"FROM ({start}) TO ({end}) {interval}"
 
-        def partitionbyrangeproperty_sql(self, expression: exp.PartitionByRangeProperty) -> str:
-            partition_expressions = self.expressions(
-                expression, key="partition_expressions", indent=False
-            )
-            create_sql = self.expressions(expression, key="create_expressions", indent=False)
-            return f"PARTITION BY RANGE ({partition_expressions}) ({create_sql})"
-
-        def partitionbylistproperty_sql(self, expression: exp.PartitionByListProperty) -> str:
-            partition_expressions = self.expressions(
-                expression, key="partition_expressions", indent=False
-            )
-            create_sql = self.expressions(expression, key="create_expressions", indent=False)
-            return f"PARTITION BY LIST ({partition_expressions}) ({create_sql})"
-
-        def partitionlist_sql(self, expression: exp.PartitionList) -> str:
-            name = self.sql(expression, "this")
-            values = self.expressions(expression, indent=False)
-            return f"PARTITION {name} VALUES IN ({values})"
-
         def partitionedbyproperty_sql(self, expression: exp.PartitionedByProperty) -> str:
-            node = expression.this
-            if isinstance(node, exp.Schema):
-                parts = ", ".join(self.sql(e) for e in node.expressions)
-                return f"PARTITION BY ({parts})"
-            return f"PARTITION BY ({self.sql(node)})"
+            this = expression.this
+            if isinstance(this, exp.Schema):
+                return f"PARTITION BY ({self.expressions(this, flat=True)})"
+            return f"PARTITION BY ({self.sql(this)})"
 
         def table_sql(self, expression: exp.Table, sep: str = " AS ") -> str:
             """Override table_sql to avoid AS keyword in UPDATE and DELETE statements."""
@@ -791,6 +742,3 @@ class Doris(MySQL):
             if not isinstance(ancestor, exp.Select):
                 sep = " "
             return super().table_sql(expression, sep=sep)
-
-        def alterrename_sql(self, expression: exp.AlterRename, include_to: bool = True) -> str:
-            return super().alterrename_sql(expression, include_to=False)

sqlglot/dialects/druid.py

@@ -17,4 +17,5 @@ class Druid(Dialect):
             **generator.Generator.TRANSFORMS,
             exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
             exp.Mod: rename_func("MOD"),
+            exp.Array: lambda self, e: f"ARRAY[{self.expressions(e)}]",
         }