sqlglotc 30.24.0__tar.gz → 30.25.0__tar.gz

{sqlglotc-30.24.0/sqlglotc.egg-info → sqlglotc-30.25.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.24.0
+Version: 30.25.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Repository, https://github.com/tobymao/sqlglot
 Requires-Python: >=3.10
-Requires-Dist: sqlglot==30.24.0
+Requires-Dist: sqlglot==30.25.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/pyproject.toml

@@ -28,6 +28,7 @@ include-package-data = false
 
 [tool.setuptools_scm]
 root = ".."
+write_to_source = true
 fallback_version = "0.0.0"
 local_scheme = "no-local-version"
 

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/array.py

@@ -254,6 +254,10 @@ class SplitToTable(Expression, Func, UDTF):
     arg_types = {"this": True, "expression": True}
 
 
+class StrtokSplitToTable(Expression, Func, UDTF):
+    arg_types = {"this": True, "expression": False}
+
+
 class Stack(Expression, Func, UDTF):
     arg_types = {"this": True, "expressions": True}
     is_var_len_args = True

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/builders.py

@@ -921,7 +921,7 @@ def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Ex
     def _replace_placeholders(node: Expr, args: Iterator[object], **kwargs: object) -> Expr:
         if isinstance(node, Placeholder):
             if node.this:
-                new_name = kwargs.get(node.this)
+                new_name = kwargs.get(node.name)
                 if new_name is not None:
                     return _replace_placeholder(node, convert(new_name))
             else:

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/constraints.py

@@ -161,7 +161,7 @@ class OnUpdateColumnConstraint(Expression, ColumnConstraintKind):
 
 
 class PrimaryKeyColumnConstraint(Expression, ColumnConstraintKind):
-    arg_types = {"desc": False, "options": False}
+    arg_types = {"desc": False, "options": False, "include": False}
 
 
 class TitleColumnConstraint(Expression, ColumnConstraintKind):
@@ -175,6 +175,7 @@ class UniqueColumnConstraint(Expression, ColumnConstraintKind):
         "on_conflict": False,
         "nulls": False,
         "options": False,
+        "include": False,
     }
 
 

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/core.py

@@ -1734,13 +1734,13 @@ class Column(Expression, Condition):
         return self.name
 
     @property
-    def parts(self) -> list[Identifier | Star]:
+    def parts(self) -> list[Expr]:
         """Return the parts of a column in order catalog, db, table, name."""
         return [
             self.args[part] for part in ("catalog", "db", "table", "this") if self.args.get(part)
         ]
 
-    def to_dot(self, include_dots: bool = True) -> Dot | Identifier | Star:
+    def to_dot(self, include_dots: bool = True) -> Expr:
         """Converts the column into a dot expression."""
         parts = self.parts
         parent = self.parent
@@ -3071,7 +3071,7 @@ def alias_(
 
 @t.overload
 def column(
-    col: str | Identifier,
+    col: str | Expr,
     table: str | Identifier | None = None,
     db: str | Identifier | None = None,
     catalog: str | Identifier | None = None,
@@ -3085,7 +3085,7 @@ def column(
 
 @t.overload
 def column(
-    col: str | Identifier | Star,
+    col: str | Expr,
     table: str | Identifier | None = None,
     db: str | Identifier | None = None,
     catalog: str | Identifier | None = None,
@@ -3111,19 +3111,18 @@ def column(
     Build a Column.
 
     Args:
-        col: Column name.
+        col: Column name or expression.
         table: Table name.
         db: Database name.
         catalog: Catalog name.
         fields: Additional fields using dots.
         quoted: Whether to force quotes on the column's identifiers.
-        copy: Whether to copy identifiers if passed in.
+        copy: Whether to copy expressions if passed in.
 
     Returns:
         The new Column instance.
     """
-    if not isinstance(col, Star):
-        col = to_identifier(col, quoted=quoted, copy=copy)
+    col = maybe_copy(col, copy) if isinstance(col, Expr) else to_identifier(col, quoted=quoted)
 
     this: Column | Dot = Column(
         this=col,

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/datatypes.py

@@ -461,7 +461,9 @@ class IntervalSpan(DataType):
 
 
 class Interval(_TimeUnit):
-    arg_types = {"this": False, "unit": False}
+    # fraction_in_string: a fractional amount was written with its unit in one string, e.g.
+    # INTERVAL '1.5 DAY', which differs from INTERVAL '1.5' DAY in e.g. DuckDB and Postgres
+    arg_types = {"this": False, "unit": False, "fraction_in_string": False}
 
 
 DATA_TYPE = t.Union[str, Identifier, Dot, DataType, DType]

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/ddl.py

@@ -131,6 +131,14 @@ class Describe(Expression):
     }
 
 
+class ConnectTo(Expression):
+    pass
+
+
+class Disconnect(Expression):
+    arg_types = {}
+
+
 class Attach(Expression):
     arg_types = {"this": True, "exists": False, "expressions": False}
 

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/expressions/query.py

@@ -663,7 +663,7 @@ class GroupingSets(Expression):
 
 
 class Lambda(Expression):
-    arg_types = {"this": True, "expressions": True, "colon": False}
+    arg_types = {"this": True, "expressions": True}
 
 
 class Limit(Expression):
@@ -699,8 +699,9 @@ class Join(Expression):
         "method": False,
         "global_": False,
         "hint": False,
-        "match_condition": False,  # Snowflake
-        "directed": False,  # Snowflake
+        "match_condition": False,
+        "nearest": False,
+        "directed": False,
         "expressions": False,
         "pivots": False,
     }
@@ -817,6 +818,10 @@ class Join(Expression):
         return join
 
 
+class Nearest(Expression):
+    arg_types = {"this": True, "count": True, "approximate": False, "similarity": False}
+
+
 class Lateral(Expression, UDTF):
     arg_types = {
         "this": True,

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generator.py

@@ -333,6 +333,9 @@ class Generator:
     # Whether MERGE ... WHEN MATCHED/NOT MATCHED THEN UPDATE/INSERT ... WHERE is supported
     SUPPORTS_MERGE_WHERE = False
 
+    # Whether MERGE uses ALL BY NAME instead of a star to update or insert all columns
+    MERGE_ALL_BY_NAME = False
+
     # Whether the INTERVAL expression works only with values like '1 day'
     SINGLE_STRING_INTERVAL = False
 
@@ -370,6 +373,9 @@ class Generator:
     # Whether directed joins are supported
     DIRECTED_JOINS = False
 
+    # Whether top-k distance/similarity joins are supported
+    SUPPORTS_NEAREST_JOIN = False
+
     # Whether table hints should be generated
     TABLE_HINTS = True
 
@@ -414,9 +420,12 @@ class Generator:
     # SELECT * VALUES into SELECT UNION
     VALUES_AS_TABLE = True
 
-    # Whether the word COLUMN is included when adding a column with ALTER TABLE
+    # Whether COLUMN/COLUMNS keywords are included when adding columns with ALTER TABLE.
     ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = True
 
+    # Whether ALTER TABLE mutli-column additions are wrapped in parentheses.
+    ALTER_TABLE_ADD_COLUMNS_WRAPPED = True
+
     # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
     UNNEST_WITH_ORDINALITY = True
 
@@ -1322,7 +1331,8 @@ class Generator:
             return f"PRIMARY KEY{' DESC' if desc else ' ASC'}"
         options = self.expressions(expression, key="options", flat=True, sep=" ")
         options = f" {options}" if options else ""
-        return f"PRIMARY KEY{options}"
+        include = self.sql(expression, "include")
+        return f"PRIMARY KEY{include}{options}"
 
     def uniquecolumnconstraint_sql(self, expression: exp.UniqueColumnConstraint) -> str:
         this = self.sql(expression, "this")
@@ -1334,7 +1344,8 @@ class Generator:
         nulls_sql = " NULLS NOT DISTINCT" if expression.args.get("nulls") else ""
         options = self.expressions(expression, key="options", flat=True, sep=" ")
         options = f" {options}" if options else ""
-        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{options}"
+        include = self.sql(expression, "include")
+        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{include}{options}"
 
     def inoutcolumnconstraint_sql(self, expression: exp.InOutColumnConstraint) -> str:
         input_ = expression.args.get("input_")
@@ -2024,7 +2035,9 @@ class Generator:
         with_storage = self.expressions(expression, key="with_storage", flat=True)
         with_storage = f" WITH ({with_storage})" if with_storage else ""
         tablespace = self.sql(expression, "tablespace")
-        tablespace = f" USING INDEX TABLESPACE {tablespace}" if tablespace else ""
+        if tablespace:
+            prefix = "" if isinstance(expression.parent, exp.Index) else " USING INDEX"
+            tablespace = f"{prefix} TABLESPACE {tablespace}"
         on = self.sql(expression, "on")
         on = f" ON {on}" if on else ""
 
@@ -2168,7 +2181,7 @@ class Generator:
     def property_name(self, expression: exp.Property, string_key: bool = False) -> str:
         if isinstance(expression.this, exp.Dot):
             return self.sql(expression, "this")
-        return f"'{expression.name}'" if string_key else expression.name
+        return self.sql(exp.Literal.string(expression.name)) if string_key else expression.name
 
     def property_sql(self, expression: exp.Property) -> str:
         property_cls = expression.__class__
@@ -2911,6 +2924,12 @@ class Generator:
         this = self.indent(self.sql(expression, "this"))
         return f"{self.seg('HAVING')}{self.sep()}{this}"
 
+    def connectto_sql(self, expression: exp.ConnectTo) -> str:
+        return f"CONNECT {self.sql(expression, 'this')}"
+
+    def disconnect_sql(self, expression: exp.Disconnect) -> str:
+        return "DISCONNECT"
+
     def connect_sql(self, expression: exp.Connect) -> str:
         start = self.sql(expression, "start")
         start = self.seg(f"START WITH {start}") if start else ""
@@ -2922,7 +2941,7 @@ class Generator:
     def prior_sql(self, expression: exp.Prior) -> str:
         return f"PRIOR {self.sql(expression, 'this')}"
 
-    def join_sql(self, expression: exp.Join) -> str:
+    def join_sql(self, expression: exp.Join, join_op: str | None = None) -> str:
         if not self.SEMI_ANTI_JOIN_WITH_SIDE and expression.kind in ("SEMI", "ANTI"):
             side = None
         else:
@@ -2942,6 +2961,8 @@ class Generator:
         )
         match_cond = self.sql(expression, "match_condition")
         match_cond = f" MATCH_CONDITION ({match_cond})" if match_cond else ""
+        nearest = self.sql(expression, "nearest")
+        nearest = f" {nearest}" if nearest else ""
         on_sql = self.sql(expression, "on")
         using = expression.args.get("using")
 
@@ -2962,17 +2983,27 @@ class Generator:
                 on_sql = f"{space}USING ({on_sql})"
             else:
                 on_sql = f"{space}ON {on_sql}"
-        elif not op_sql:
+        elif not op_sql and not nearest:
             if isinstance(this, exp.Lateral) and this.args.get("cross_apply") is not None:
                 return f" {this_sql}"
 
             return f", {this_sql}"
 
-        if op_sql != "STRAIGHT_JOIN":
+        if join_op:
+            op_sql = join_op
+        elif op_sql != "STRAIGHT_JOIN":
             op_sql = f"{op_sql} JOIN" if op_sql else "JOIN"
 
         pivots = self.expressions(expression, key="pivots", sep="", flat=True)
-        return f"{self.seg(op_sql)} {this_sql}{match_cond}{on_sql}{pivots}"
+        return f"{self.seg(op_sql)} {this_sql}{match_cond}{nearest}{on_sql}{pivots}"
+
+    def nearest_sql(self, expression: exp.Nearest) -> str:
+        if not self.SUPPORTS_NEAREST_JOIN:
+            self.unsupported("NEAREST joins are not supported")
+
+        approximate = "APPROX " if expression.args.get("approximate") else ""
+        metric = "SIMILARITY" if expression.args.get("similarity") else "DISTANCE"
+        return f"{approximate}NEAREST {self.sql(expression, 'count')} BY {metric} {self.sql(expression, 'this')}"
 
     def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->", wrap: bool = True) -> str:
         args = self.expressions(expression, flat=True)
@@ -3636,6 +3667,9 @@ class Generator:
             first = "FIRST" if first else "LAST"
 
         if not partition and not order and not spec and alias:
+            # WINDOW w2 AS w1 is unparseable in DuckDB/Postgres; parens are required.
+            if expression.arg_key == "windows":
+                return f"{this} ({alias})"
             return f"{this} {alias}"
 
         args = self.format_args(
@@ -4085,8 +4119,8 @@ class Generator:
             if this:
                 interval_keyword = f"{interval_keyword} " if interval_keyword else ""
                 if unit_expression and isinstance(unit_expression, exp.IntervalSpan):
-                    return f"{interval_keyword}'{this}'{unit}"
-                return f"{interval_keyword}'{this}{unit}'"
+                    return f"{interval_keyword}{self.sql(exp.Literal.string(this))}{unit}"
+                return f"{interval_keyword}{self.sql(exp.Literal.string(f'{this}{unit}'))}"
             return f"{interval_keyword}{unit}"
 
         this = self.sql(expression, "this")
@@ -4508,13 +4542,17 @@ class Generator:
         return f"{keyword} {items_sql}"
 
     def add_column_sql(self, expression: exp.Expr) -> str:
-        sql = self.sql(expression)
-        if isinstance(expression, exp.Schema):
-            column_text = " COLUMNS"
-        elif isinstance(expression, exp.ColumnDef) and self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
-            column_text = " COLUMN"
+        column_text = ""
+        if self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
+            if isinstance(expression, exp.ColumnDef):
+                column_text = " COLUMN"
+            elif isinstance(expression, exp.Schema):
+                column_text = " COLUMNS"
+
+        if isinstance(expression, exp.Schema) and not self.ALTER_TABLE_ADD_COLUMNS_WRAPPED:
+            sql = self.expressions(expression, flat=True)
         else:
-            column_text = ""
+            sql = self.sql(expression)
 
         return f"ADD{column_text} {sql}"
 
@@ -4980,13 +5018,27 @@ class Generator:
 
         then_expression = expression.args.get("then")
         if isinstance(then_expression, exp.Insert):
-            this = self.sql(then_expression, "this")
+            this = (
+                "ALL BY NAME"
+                if self.MERGE_ALL_BY_NAME and isinstance(then_expression.this, exp.Star)
+                else self.sql(then_expression, "this")
+            )
             this = f"INSERT {this}" if this else "INSERT"
             then = self.sql(then_expression, "expression")
             then = f"{this} VALUES {then}" if then else this
         elif isinstance(then_expression, exp.Update):
             if isinstance(then_expression.args.get("expressions"), exp.Star):
-                then = f"UPDATE {self.sql(then_expression, 'expressions')}"
+                then = (
+                    "UPDATE ALL BY NAME"
+                    if self.MERGE_ALL_BY_NAME
+                    else f"UPDATE {self.sql(then_expression, 'expressions')}"
+                )
+            elif (
+                self.MERGE_ALL_BY_NAME
+                and len(then_expression.expressions) == 1
+                and isinstance(then_expression.expressions[0], exp.Star)
+            ):
+                then = "UPDATE ALL BY NAME"
             else:
                 expressions_sql = self.expressions(then_expression)
                 then = f"UPDATE SET{self.sep()}{expressions_sql}" if expressions_sql else "UPDATE"
@@ -5947,7 +5999,8 @@ class Generator:
 
     def slice_sql(self, expression: exp.Slice) -> str:
         step = self.sql(expression, "step")
-        end = self.sql(expression.expression)
+        # An omitted end is written as `-` before a step, since `::` is the cast operator
+        end = self.sql(expression.expression) or ("-" if step else "")
         begin = self.sql(expression.this)
 
         sql = f"{end}:{step}" if step else end

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/bigquery.py

@@ -429,6 +429,7 @@ class BigQueryGenerator(generator.Generator):
         exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
         exp.Day: _extract_part("DAY"),
         exp.DayOfMonth: _extract_part("DAY"),
+        exp.DayOfWeek: _extract_part("DAYOFWEEK"),
         exp.DayOfWeekIso: _day_of_week_iso_sql,
         exp.DayOfYear: _extract_part("DAYOFYEAR"),
         exp.Filter: no_filter_sql,

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/clickhouse.py

@@ -24,6 +24,7 @@ from sqlglot.dialects.dialect import (
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import is_int
+from sqlglot.optimizer.simplify import simplify_parens
 from collections import defaultdict
 
 DATETIME_DELTA = t.Union[exp.DateAdd, exp.DateDiff, exp.DateSub, exp.TimestampSub, exp.TimestampAdd]
@@ -433,13 +434,12 @@ class ClickHouseGenerator(generator.Generator):
 
     @unsupported_args("json_scope")
     def contains_sql(self, expression: exp.Contains) -> str:
-        # ClickHouse has no CONTAINS; the comparison needs parentheses inside another operator
-        result = exp.StrPosition(this=expression.this, substr=expression.expression) > 0
-        if isinstance(expression.parent, exp.Binary) and not isinstance(
-            expression.parent, exp.Connector
-        ):
-            return self.sql(exp.paren(result, copy=False))
-        return self.sql(result)
+        # ClickHouse has no CONTAINS; keep the parentheses only where the parent needs them
+        result = exp.paren(
+            exp.StrPosition(this=expression.this, substr=expression.expression) > 0, copy=False
+        )
+        result.parent = expression.parent
+        return self.sql(simplify_parens(result, self.dialect))
 
     def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
         this = expression.this

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/databricks.py

@@ -19,6 +19,7 @@ class DatabricksGenerator(SparkGenerator):
     SAFE_JSON_PATH_KEY_RE = exp.SAFE_IDENTIFIER_RE
     QUOTE_JSON_PATH = False
     PARSE_JSON_NAME: str | None = "PARSE_JSON"
+    SUPPORTS_TEMPORAL_PRECISION = True
 
     TRANSFORMS = {
         k: v

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/duckdb.py

@@ -672,6 +672,15 @@ def _struct_sql(self: DuckDBGenerator, expression: exp.Struct) -> str:
     return f"ROW({csv_args})" if is_bq_inline_struct else f"{{{csv_args}}}"
 
 
+@unsupported_args("unique_keys", "return_type", "encoding", "strict")
+def _json_constructor_sql(self: DuckDBGenerator, expression: exp.JSONArray | exp.JSONObject) -> str:
+    if expression.args.get("null_handling") == "ABSENT ON NULL":
+        self.unsupported("ABSENT ON NULL is not supported in DuckDB")
+
+    name = "JSON_ARRAY" if isinstance(expression, exp.JSONArray) else "JSON_OBJECT"
+    return self.func(name, *expression.expressions)
+
+
 def _json_format_sql(self: DuckDBGenerator, expression: exp.JSONFormat) -> str:
     sql = self.func("TO_JSON", expression.this, expression.args.get("options"))
     return f"CAST({sql} AS TEXT)"
@@ -889,6 +898,19 @@ WRAPPED_JSON_EXTRACT_EXPRESSIONS = (exp.Binary, exp.Bracket, exp.In, exp.Not)
 
 
 def _arrow_json_extract_sql(self: DuckDBGenerator, expression: JSON_EXTRACT_TYPE) -> str:
+    paths = expression.expressions
+    if isinstance(expression, exp.JSONExtract) and paths:
+        # JSON_EXTRACT with several paths (SQLite, MySQL) returns a JSON array of the results,
+        # which DuckDB builds from a list of paths
+        return self.func(
+            "TO_JSON",
+            self.func(
+                "JSON_EXTRACT",
+                expression.this,
+                exp.Array(expressions=[expression.expression, *paths]),
+            ),
+        )
+
     arrow_sql = arrow_json_extract_sql(self, expression)
     if not expression.same_parent and isinstance(
         expression.parent, WRAPPED_JSON_EXTRACT_EXPRESSIONS
@@ -1567,6 +1589,7 @@ class DuckDBGenerator(generator.Generator):
     TABLE_HINTS = False
     QUERY_HINTS = False
     LIMIT_FETCH = "LIMIT"
+    SUPPORTS_NEAREST_JOIN = True
     STRUCT_DELIMITER = ("(", ")")
     RENAME_TABLE_WITH_DB = False
     NVL2_SUPPORTED = False
@@ -1794,7 +1817,7 @@ class DuckDBGenerator(generator.Generator):
         exp.TsOrDsAdd: _date_delta_to_binary_interval_op(),
         exp.TsOrDsDiff: lambda self, e: self.func(
             "DATE_DIFF",
-            f"'{e.args.get('unit') or 'DAY'}'",
+            exp.Literal.string(e.unit or "DAY"),
             exp.cast(e.expression, exp.DType.TIMESTAMP),
             exp.cast(e.this, exp.DType.TIMESTAMP),
         ),
@@ -1824,6 +1847,8 @@ class DuckDBGenerator(generator.Generator):
         ),
         exp.Xor: _xor_sql,
         exp.JSONObjectAgg: rename_func("JSON_GROUP_OBJECT"),
+        exp.JSONArray: _json_constructor_sql,
+        exp.JSONObject: _json_constructor_sql,
         exp.JSONBObjectAgg: rename_func("JSON_GROUP_OBJECT"),
         exp.DateBin: rename_func("TIME_BUCKET"),
         exp.LastDay: _last_day_sql,
@@ -1970,6 +1995,7 @@ class DuckDBGenerator(generator.Generator):
         exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
         exp.ReturnsProperty: exp.Properties.Location.POST_ALIAS,
         exp.SequenceProperties: exp.Properties.Location.POST_EXPRESSION,
+        exp.TriggerProperties: exp.Properties.Location.POST_EXPRESSION,
         exp.IcebergProperty: exp.Properties.Location.POST_CREATE,
     }
 
@@ -2387,6 +2413,27 @@ class DuckDBGenerator(generator.Generator):
 
         return self.sql(add_expr)
 
+    def unicodestring_sql(self, expression: exp.UnicodeString) -> str:
+        # DuckDB has no Unicode escape strings and doesn't read \u in a string, so the escapes
+        # are decoded into the characters, e.g. U&'d\0061t\0061' and U&'d!+000061ta' UESCAPE '!'
+        # are both 'data'
+        escape = expression.args.get("escape")
+        escape_char = re.escape(escape.name if isinstance(escape, exp.Expr) else "\\")
+        pattern = re.compile(
+            rf"{escape_char}(?:\+([0-9a-fA-F]{{6}})|([0-9a-fA-F]{{4}})|({escape_char}))"
+        )
+
+        def decode(match: re.Match[str]) -> str:
+            if match.group(3):
+                return match.group(3)
+            return chr(int(match.group(1) or match.group(2), 16))
+
+        # A character outside the BMP can be written as a UTF-16 surrogate pair
+        text = (
+            pattern.sub(decode, expression.name).encode("utf-16", "surrogatepass").decode("utf-16")
+        )
+        return self.sql(exp.Literal.string(text))
+
     def bytestring_sql(self, expression: exp.ByteString) -> str:
         if not expression.args.get("is_bytes"):
             return super().bytestring_sql(expression)
@@ -2551,9 +2598,6 @@ class DuckDBGenerator(generator.Generator):
         initial_value = expression.args.get("initial")
         merge_lambda = expression.args.get("merge")
 
-        if merge_lambda:
-            merge_lambda.set("colon", True)
-
         return self.func("list_reduce", array_arg, merge_lambda, initial_value)
 
     def zipf_sql(self, expression: exp.Zipf) -> str:
@@ -2678,7 +2722,7 @@ class DuckDBGenerator(generator.Generator):
         return self._greatest_least_sql(expression)
 
     def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->", wrap: bool = True) -> str:
-        if expression.args.get("colon"):
+        if self.dialect.version >= (1, 3):
             prefix = "LAMBDA "
             arrow_sep = ":"
             wrap = False
@@ -2697,6 +2741,11 @@ class DuckDBGenerator(generator.Generator):
         self.unsupported("SOUNDEX is not supported in DuckDB")
         return self.func("SOUNDEX", expression.this)
 
+    def placeholder_sql(self, expression: exp.Placeholder) -> str:
+        if isinstance(expression.this, exp.Identifier):
+            return f"${self.sql(expression, 'this')}"
+        return super().placeholder_sql(expression)
+
     def install_sql(self, expression: exp.Install) -> str:
         force = "FORCE " if expression.args.get("force") else ""
         this = self.sql(expression, "this")
@@ -3163,10 +3212,26 @@ class DuckDBGenerator(generator.Generator):
             )
         return super().in_sql(expression)
 
-    def join_sql(self, expression: exp.Join) -> str:
+    def interval_sql(self, expression: exp.Interval) -> str:
+        # DuckDB truncates INTERVAL '1.5' DAY to 1 day, but keeps the fraction in INTERVAL '1.5 DAY'
+        this = expression.this
+        unit = expression.unit
+        if expression.args.get("fraction_in_string") and this and isinstance(unit, exp.Var):
+            return f"INTERVAL '{this.name} {self.sql(unit)}'"
+
+        return super().interval_sql(expression)
+
+    def join_sql(self, expression: exp.Join, join_op: str | None = None) -> str:
+        if expression.kind in ("MARK", "SINGLE") or (
+            expression.side == "RIGHT" and expression.is_semi_or_anti_join
+        ):
+            kind = "_".join(part for part in (expression.side, expression.kind) if part)
+            return super().join_sql(expression, join_op=f"JOIN BY (TYPE {kind})")
+
         if (
             not expression.args.get("using")
             and not expression.args.get("on")
+            and not expression.args.get("nearest")
             and not expression.method
             and (expression.kind in ("", "INNER", "OUTER"))
         ):
@@ -3178,7 +3243,7 @@ class DuckDBGenerator(generator.Generator):
             expression.set("side", None)
             expression.set("kind", None)
 
-        return super().join_sql(expression)
+        return super().join_sql(expression, join_op=join_op)
 
     def countif_sql(self, expression: exp.CountIf) -> str:
         if self.dialect.version >= (1, 2):

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/exasol.py

@@ -100,12 +100,9 @@ def _trunc_sql(
     node = expression.this.this if isinstance(expression.this, exp.Cast) else expression.this
     expr_sql = self.sql(node)
     if isinstance(node, exp.Literal) and node.is_string:
-        expr_sql = (
-            f"{kind} '{node.this.replace('T', ' ')}'"
-            if kind == "TIMESTAMP"
-            else f"DATE '{node.this}'"
-        )
-    return f"DATE_TRUNC('{unit}', {expr_sql})"
+        text = node.this.replace("T", " ") if kind == "TIMESTAMP" else node.this
+        expr_sql = f"{kind} {self.sql(exp.Literal.string(text))}"
+    return f"DATE_TRUNC({self.sql(exp.Literal.string(unit))}, {expr_sql})"
 
 
 def _date_trunc_sql(self: ExasolGenerator, expression: exp.DateTrunc) -> str:

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/hive.py

@@ -246,6 +246,7 @@ class HiveGenerator(generator.Generator):
     PARSE_JSON_NAME: str | None = "PARSE_JSON"
     PAD_FILL_PATTERN_IS_REQUIRED = True
     SUPPORTS_MEDIAN = False
+    SUPPORTS_TEMPORAL_PRECISION = False
     ARRAY_SIZE_NAME = "SIZE"
     ALTER_SET_TYPE = ""
 
@@ -506,7 +507,9 @@ class HiveGenerator(generator.Generator):
             expression.set("expressions", None)
         elif expression.is_type(exp.DType.TEXT) and expression.expressions:
             expression.set("this", exp.DType.VARCHAR)
-        elif expression.this in exp.DataType.TEMPORAL_TYPES:
+        elif (
+            not self.SUPPORTS_TEMPORAL_PRECISION and expression.this in exp.DataType.TEMPORAL_TYPES
+        ):
             expression.set("expressions", None)
         elif expression.is_type("float"):
             size_expression = expression.find(exp.DataTypeParam)

{sqlglotc-30.24.0 → sqlglotc-30.25.0}/sqlglot/generators/oracle.py

@@ -145,9 +145,6 @@ class OracleGenerator(generator.Generator):
     def offset_sql(self, expression: exp.Offset) -> str:
         return f"{super().offset_sql(expression)} ROWS"
 
-    def add_column_sql(self, expression: exp.Expr) -> str:
-        return f"ADD {self.sql(expression)}"
-
     def queryoption_sql(self, expression: exp.QueryOption) -> str:
         option = self.sql(expression, "this")
         value = self.sql(expression, "expression")