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

sqlglot/generator.py

@@ -112,6 +112,7 @@ class Generator(metaclass=_Generator):
 
     TRANSFORMS: t.Dict[t.Type[exp.Expression], t.Callable[..., str]] = {
         **JSON_PATH_PART_TRANSFORMS,
+        exp.Adjacent: lambda self, e: self.binary(e, "-|-"),
         exp.AllowedValuesProperty: lambda self,
         e: f"ALLOWED_VALUES {self.expressions(e, flat=True)}",
         exp.AnalyzeColumns: lambda self, e: self.sql(e, "this"),
@@ -169,6 +170,7 @@ class Generator(metaclass=_Generator):
         exp.LocationProperty: lambda self, e: self.naked_property(e),
         exp.LogProperty: lambda _, e: f"{'NO ' if e.args.get('no') else ''}LOG",
         exp.MaterializedProperty: lambda *_: "MATERIALIZED",
+        exp.NetFunc: lambda self, e: f"NET.{self.sql(e, 'this')}",
         exp.NonClusteredColumnConstraint: lambda self,
         e: f"NONCLUSTERED ({self.expressions(e, 'this', indent=False)})",
         exp.NoPrimaryIndexProperty: lambda *_: "NO PRIMARY INDEX",
@@ -195,6 +197,7 @@ class Generator(metaclass=_Generator):
         exp.ReturnsProperty: lambda self, e: (
             "RETURNS NULL ON NULL INPUT" if e.args.get("null") else self.naked_property(e)
         ),
+        exp.SafeFunc: lambda self, e: f"SAFE.{self.sql(e, 'this')}",
         exp.SampleProperty: lambda self, e: f"SAMPLE BY {self.sql(e, 'this')}",
         exp.SecureProperty: lambda *_: "SECURE",
         exp.SecurityProperty: lambda self, e: f"SECURITY {self.sql(e, 'this')}",
@@ -227,6 +230,7 @@ class Generator(metaclass=_Generator):
         exp.UtcTimestamp: lambda self, e: self.sql(
             exp.CurrentTimestamp(this=exp.Literal.string("UTC"))
         ),
+        exp.Variadic: lambda self, e: f"VARIADIC {self.sql(e, 'this')}",
         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",
@@ -282,9 +286,15 @@ class Generator(metaclass=_Generator):
     # The string used for creating an index on a table
     INDEX_ON = "ON"
 
+    # Separator for IN/OUT parameter mode (Oracle uses " " for "IN OUT", PostgreSQL uses "" for "INOUT")
+    INOUT_SEPARATOR = " "
+
     # Whether join hints should be generated
     JOIN_HINTS = True
 
+    # Whether directed joins are supported
+    DIRECTED_JOINS = False
+
     # Whether table hints should be generated
     TABLE_HINTS = True
 
@@ -514,6 +524,11 @@ class Generator(metaclass=_Generator):
     # Whether to include the VARIABLE keyword for SET assignments
     SET_ASSIGNMENT_REQUIRES_VARIABLE_KEYWORD = False
 
+    # Whether FROM is supported in UPDATE statements or if joins must be generated instead, e.g:
+    # Supported (Postgres, Doris etc): UPDATE t1 SET t1.a = t2.b FROM t2
+    # Unsupported (MySQL, SingleStore): UPDATE t1 JOIN t2 ON TRUE SET t1.a = t2.b
+    UPDATE_STATEMENT_SUPPORTS_FROM = True
+
     TYPE_MAPPING = {
         exp.DataType.Type.DATETIME2: "TIMESTAMP",
         exp.DataType.Type.NCHAR: "CHAR",
@@ -622,8 +637,10 @@ class Generator(metaclass=_Generator):
         exp.PartitionedOfProperty: exp.Properties.Location.POST_SCHEMA,
         exp.PrimaryKey: exp.Properties.Location.POST_SCHEMA,
         exp.Property: exp.Properties.Location.POST_WITH,
+        exp.RefreshTriggerProperty: exp.Properties.Location.POST_SCHEMA,
         exp.RemoteWithConnectionModelProperty: exp.Properties.Location.POST_SCHEMA,
         exp.ReturnsProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.RollupProperty: exp.Properties.Location.UNSUPPORTED,
         exp.RowFormatProperty: exp.Properties.Location.POST_SCHEMA,
         exp.RowFormatDelimitedProperty: exp.Properties.Location.POST_SCHEMA,
         exp.RowFormatSerdeProperty: exp.Properties.Location.POST_SCHEMA,
@@ -1152,6 +1169,24 @@ class Generator(metaclass=_Generator):
         options = f" {options}" if options else ""
         return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{options}"
 
+    def inoutcolumnconstraint_sql(self, expression: exp.InOutColumnConstraint) -> str:
+        input_ = expression.args.get("input_")
+        output = expression.args.get("output")
+        variadic = expression.args.get("variadic")
+
+        # VARIADIC is mutually exclusive with IN/OUT/INOUT
+        if variadic:
+            return "VARIADIC"
+
+        if input_ and output:
+            return f"IN{self.INOUT_SEPARATOR}OUT"
+        if input_:
+            return "IN"
+        if output:
+            return "OUT"
+
+        return ""
+
     def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
         return self.sql(expression, "this")
 
@@ -1302,8 +1337,9 @@ class Generator(metaclass=_Generator):
         partition = f" {partition}" if partition else ""
         format = self.sql(expression, "format")
         format = f" {format}" if format else ""
+        as_json = " AS JSON" if expression.args.get("as_json") else ""
 
-        return f"DESCRIBE{style}{format} {self.sql(expression, 'this')}{partition}"
+        return f"DESCRIBE{style}{format} {self.sql(expression, 'this')}{partition}{as_json}"
 
     def heredoc_sql(self, expression: exp.Heredoc) -> str:
         tag = self.sql(expression, "tag")
@@ -1398,6 +1434,7 @@ class Generator(metaclass=_Generator):
                 escape_backslash=False,
                 delimiter=self.dialect.BYTE_END,
                 escaped_delimiter=self._escaped_byte_quote_end,
+                is_byte_string=True,
             )
             is_bytes = expression.args.get("is_bytes", False)
             delimited_byte_string = (
@@ -1455,7 +1492,15 @@ class Generator(metaclass=_Generator):
     def datatype_sql(self, expression: exp.DataType) -> str:
         nested = ""
         values = ""
-        interior = self.expressions(expression, flat=True)
+
+        expr_nested = expression.args.get("nested")
+        interior = (
+            self.expressions(
+                expression, dynamic=True, new_line=True, skip_first=True, skip_last=True
+            )
+            if expr_nested and self.pretty
+            else self.expressions(expression, flat=True)
+        )
 
         type_value = expression.this
         if type_value in self.UNSUPPORTED_TYPES:
@@ -1473,7 +1518,7 @@ class Generator(metaclass=_Generator):
             )
 
         if interior:
-            if expression.args.get("nested"):
+            if expr_nested:
                 nested = f"{self.STRUCT_DELIMITER[0]}{interior}{self.STRUCT_DELIMITER[1]}"
                 if expression.args.get("values") is not None:
                     delimiters = ("[", "]") if type_value == exp.DataType.Type.ARRAY else ("(", ")")
@@ -2019,7 +2064,12 @@ class Generator(metaclass=_Generator):
         constraint = f" ON CONSTRAINT {constraint}" if constraint else ""
 
         conflict_keys = self.expressions(expression, key="conflict_keys", flat=True)
-        conflict_keys = f"({conflict_keys}) " if conflict_keys else " "
+        if conflict_keys:
+            conflict_keys = f"({conflict_keys})"
+
+        index_predicate = self.sql(expression, "index_predicate")
+        conflict_keys = f"{conflict_keys}{index_predicate} "
+
         action = self.sql(expression, "action")
 
         expressions = self.expressions(expression, flat=True)
@@ -2222,10 +2272,42 @@ class Generator(metaclass=_Generator):
     def tuple_sql(self, expression: exp.Tuple) -> str:
         return f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
 
+    def _update_from_joins_sql(self, expression: exp.Update) -> t.Tuple[str, str]:
+        """
+        Returns (join_sql, from_sql) for UPDATE statements.
+        - join_sql: placed after UPDATE table, before SET
+        - from_sql: placed after SET clause (standard position)
+        Dialects like MySQL need to convert FROM to JOIN syntax.
+        """
+        if self.UPDATE_STATEMENT_SUPPORTS_FROM or not (from_expr := expression.args.get("from_")):
+            return ("", self.sql(expression, "from_"))
+
+        # Qualify unqualified columns in SET clause with the target table
+        # MySQL requires qualified column names in multi-table UPDATE to avoid ambiguity
+        target_table = expression.this
+        if isinstance(target_table, exp.Table):
+            target_name = exp.to_identifier(target_table.alias_or_name)
+            for eq in expression.expressions:
+                col = eq.this
+                if isinstance(col, exp.Column) and not col.table:
+                    col.set("table", target_name)
+
+        table = from_expr.this
+        if nested_joins := table.args.get("joins", []):
+            table.set("joins", None)
+
+        join_sql = self.sql(exp.Join(this=table, on=exp.true()))
+        for nested in nested_joins:
+            if not nested.args.get("on") and not nested.args.get("using"):
+                nested.set("on", exp.true())
+            join_sql += self.sql(nested)
+
+        return (join_sql, "")
+
     def update_sql(self, expression: exp.Update) -> str:
         this = self.sql(expression, "this")
+        join_sql, from_sql = self._update_from_joins_sql(expression)
         set_sql = self.expressions(expression, flat=True)
-        from_sql = self.sql(expression, "from_")
         where_sql = self.sql(expression, "where")
         returning = self.sql(expression, "returning")
         order = self.sql(expression, "order")
@@ -2236,7 +2318,7 @@ class Generator(metaclass=_Generator):
             expression_sql = f"{returning}{from_sql}{where_sql}"
         options = self.expressions(expression, key="options")
         options = f" OPTION({options})" if options else ""
-        sql = f"UPDATE {this} SET {set_sql}{expression_sql}{order}{limit}{options}"
+        sql = f"UPDATE {this}{join_sql} SET {set_sql}{expression_sql}{order}{limit}{options}"
         return self.prepend_ctes(expression, sql)
 
     def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
@@ -2303,6 +2385,24 @@ class Generator(metaclass=_Generator):
         expressions = self.expressions(expression, indent=False)
         return f"ROLLUP {self.wrap(expressions)}" if expressions else "WITH ROLLUP"
 
+    def rollupindex_sql(self, expression: exp.RollupIndex) -> str:
+        this = self.sql(expression, "this")
+
+        columns = self.expressions(expression, flat=True)
+
+        from_sql = self.sql(expression, "from_index")
+        from_sql = f" FROM {from_sql}" if from_sql else ""
+
+        properties = expression.args.get("properties")
+        properties_sql = (
+            f" {self.properties(properties, prefix='PROPERTIES')}" if properties else ""
+        )
+
+        return f"{this}({columns}){from_sql}{properties_sql}"
+
+    def rollupproperty_sql(self, expression: exp.RollupProperty) -> str:
+        return f"ROLLUP ({self.expressions(expression, flat=True)})"
+
     def cube_sql(self, expression: exp.Cube) -> str:
         expressions = self.expressions(expression, indent=False)
         return f"CUBE {self.wrap(expressions)}" if expressions else "WITH CUBE"
@@ -2368,6 +2468,7 @@ class Generator(metaclass=_Generator):
                 side,
                 expression.kind,
                 expression.hint if self.JOIN_HINTS else None,
+                "DIRECTED" if expression.args.get("directed") and self.DIRECTED_JOINS else None,
             )
             if op
         )
@@ -2533,11 +2634,17 @@ class Generator(metaclass=_Generator):
         escape_backslash: bool = True,
         delimiter: t.Optional[str] = None,
         escaped_delimiter: t.Optional[str] = None,
+        is_byte_string: bool = False,
     ) -> str:
-        if self.dialect.ESCAPED_SEQUENCES:
-            to_escaped = self.dialect.ESCAPED_SEQUENCES
+        if is_byte_string:
+            supports_escape_sequences = self.dialect.BYTE_STRINGS_SUPPORT_ESCAPED_SEQUENCES
+        else:
+            supports_escape_sequences = self.dialect.STRINGS_SUPPORT_ESCAPED_SEQUENCES
+
+        if supports_escape_sequences:
             text = "".join(
-                to_escaped.get(ch, ch) if escape_backslash or ch != "\\" else ch for ch in text
+                self.dialect.ESCAPED_SEQUENCES.get(ch, ch) if escape_backslash or ch != "\\" else ch
+                for ch in text
             )
 
         delimiter = delimiter or self.dialect.QUOTE_END
@@ -3509,6 +3616,10 @@ class Generator(metaclass=_Generator):
         default = f" DEFAULT {default} ON CONVERSION ERROR" if default else ""
         return f"{safe_prefix or ''}CAST({self.sql(expression, 'this')} AS{to_sql}{default}{format_sql}{action})"
 
+    # Base implementation that excludes safe, zone, and target_type metadata args
+    def strtotime_sql(self, expression: exp.StrToTime) -> str:
+        return self.func("STR_TO_TIME", expression.this, expression.args.get("format"))
+
     def currentdate_sql(self, expression: exp.CurrentDate) -> str:
         zone = self.sql(expression, "this")
         return f"CURRENT_DATE({zone})" if zone else "CURRENT_DATE"
@@ -4435,11 +4546,11 @@ class Generator(metaclass=_Generator):
     def tsordstodate_sql(self, expression: exp.TsOrDsToDate) -> str:
         this = expression.this
         time_format = self.format_time(expression)
-
+        safe = expression.args.get("safe")
         if time_format and time_format not in (self.dialect.TIME_FORMAT, self.dialect.DATE_FORMAT):
             return self.sql(
                 exp.cast(
-                    exp.StrToTime(this=this, format=expression.args["format"]),
+                    exp.StrToTime(this=this, format=expression.args["format"], safe=safe),
                     exp.DataType.Type.DATE,
                 )
             )
@@ -4447,6 +4558,9 @@ class Generator(metaclass=_Generator):
         if isinstance(this, exp.TsOrDsToDate) or this.is_type(exp.DataType.Type.DATE):
             return self.sql(this)
 
+        if safe:
+            return self.sql(exp.TryCast(this=this, to=exp.DataType(this=exp.DataType.Type.DATE)))
+
         return self.sql(exp.cast(this, exp.DataType.Type.DATE))
 
     def unixdate_sql(self, expression: exp.UnixDate) -> str:
@@ -4811,18 +4925,6 @@ class Generator(metaclass=_Generator):
 
         return self.sql(generate_series)
 
-    def arrayconcat_sql(self, expression: exp.ArrayConcat, name: str = "ARRAY_CONCAT") -> str:
-        exprs = expression.expressions
-        if not self.ARRAY_CONCAT_IS_VAR_LEN:
-            if len(exprs) == 0:
-                rhs: t.Union[str, exp.Expression] = exp.Array(expressions=[])
-            else:
-                rhs = reduce(lambda x, y: exp.ArrayConcat(this=x, expressions=[y]), exprs)
-        else:
-            rhs = self.expressions(expression)  # type: ignore
-
-        return self.func(name, expression.this, rhs or None)
-
     def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:
         if self.SUPPORTS_CONVERT_TIMEZONE:
             return self.function_fallback_sql(expression)
@@ -4929,30 +5031,49 @@ class Generator(metaclass=_Generator):
 
         return self.func("JSON_EXISTS", this, path)
 
-    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
-        array_agg = self.function_fallback_sql(expression)
+    def _add_arrayagg_null_filter(
+        self,
+        array_agg_sql: str,
+        array_agg_expr: exp.ArrayAgg,
+        column_expr: exp.Expression,
+    ) -> str:
+        """
+        Add NULL filter to ARRAY_AGG if dialect requires it.
+
+        Args:
+            array_agg_sql: The generated ARRAY_AGG SQL string
+            array_agg_expr: The ArrayAgg expression node
+            column_expr: The column/expression to filter (before ORDER BY wrapping)
 
+        Returns:
+            SQL string with FILTER clause added if needed
+        """
         # Add a NULL FILTER on the column to mimic the results going from a dialect that excludes nulls
         # on ARRAY_AGG (e.g Spark) to one that doesn't (e.g. DuckDB)
-        if self.dialect.ARRAY_AGG_INCLUDES_NULLS and expression.args.get("nulls_excluded"):
-            parent = expression.parent
-            if isinstance(parent, exp.Filter):
-                parent_cond = parent.expression.this
-                parent_cond.replace(parent_cond.and_(expression.this.is_(exp.null()).not_()))
-            else:
-                this = expression.this
-                # Do not add the filter if the input is not a column (e.g. literal, struct etc)
-                if this.find(exp.Column):
-                    # DISTINCT is already present in the agg function, do not propagate it to FILTER as well
-                    this_sql = (
-                        self.expressions(this)
-                        if isinstance(this, exp.Distinct)
-                        else self.sql(expression, "this")
-                    )
+        if not (
+            self.dialect.ARRAY_AGG_INCLUDES_NULLS and array_agg_expr.args.get("nulls_excluded")
+        ):
+            return array_agg_sql
+
+        parent = array_agg_expr.parent
+        if isinstance(parent, exp.Filter):
+            parent_cond = parent.expression.this
+            parent_cond.replace(parent_cond.and_(column_expr.is_(exp.null()).not_()))
+        elif column_expr.find(exp.Column):
+            # Do not add the filter if the input is not a column (e.g. literal, struct etc)
+            # DISTINCT is already present in the agg function, do not propagate it to FILTER as well
+            this_sql = (
+                self.expressions(column_expr)
+                if isinstance(column_expr, exp.Distinct)
+                else self.sql(column_expr)
+            )
+            array_agg_sql = f"{array_agg_sql} FILTER(WHERE {this_sql} IS NOT NULL)"
 
-                    array_agg = f"{array_agg} FILTER(WHERE {this_sql} IS NOT NULL)"
+        return array_agg_sql
 
-        return array_agg
+    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
+        array_agg = self.function_fallback_sql(expression)
+        return self._add_arrayagg_null_filter(array_agg, expression, expression.this)
 
     def slice_sql(self, expression: exp.Slice) -> str:
         step = self.sql(expression, "step")
@@ -5044,7 +5165,8 @@ class Generator(metaclass=_Generator):
 
     @unsupported_args("format")
     def todouble_sql(self, expression: exp.ToDouble) -> str:
-        return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
+        cast = exp.TryCast if expression.args.get("safe") else exp.Cast
+        return self.sql(cast(this=expression.this, to=exp.DataType.build(exp.DataType.Type.DOUBLE)))
 
     def string_sql(self, expression: exp.String) -> str:
         this = expression.this
@@ -5154,7 +5276,8 @@ class Generator(metaclass=_Generator):
         return include
 
     def xmlelement_sql(self, expression: exp.XMLElement) -> str:
-        name = f"NAME {self.sql(expression, 'this')}"
+        prefix = "EVALNAME" if expression.args.get("evalname") else "NAME"
+        name = f"{prefix} {self.sql(expression, 'this')}"
         return self.func("XMLELEMENT", name, *expression.expressions)
 
     def xmlkeyvalueoption_sql(self, expression: exp.XMLKeyValueOption) -> str:
@@ -5467,3 +5590,9 @@ class Generator(metaclass=_Generator):
             return "WEEK"
 
         return self.func("WEEK", expression.this)
+
+    def chr_sql(self, expression: exp.Chr, name: str = "CHR") -> str:
+        this = self.expressions(expression)
+        charset = self.sql(expression, "charset")
+        using = f" USING {charset}" if charset else ""
+        return self.func(name, this + using)