sqlglotc 30.22.0__tar.gz → 30.23.0__tar.gz

{sqlglotc-30.22.0/sqlglotc.egg-info → sqlglotc-30.23.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.22.0
+Version: 30.23.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.22.0
+Requires-Dist: sqlglot==30.23.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/anonymize.py

@@ -15,6 +15,7 @@ ANONYMIZED_TYPES = {
     TokenType.HEX_STRING,
     TokenType.HEREDOC_STRING,
     TokenType.IDENTIFIER,
+    TokenType.NATIONAL_RAW_STRING,
     TokenType.NATIONAL_STRING,
     TokenType.NUMBER,
     TokenType.RAW_STRING,

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/builders.py

@@ -10,14 +10,25 @@ from sqlglot.errors import ParseError, TokenError
 from sqlglot.expressions.core import (
     Alias,
     Anonymous,
+    AtTimeZone,
+    Between,
+    Binary,
+    BitwiseNot,
     Boolean,
+    Bracket,
     Column,
     Condition,
+    Dot,
     EQ,
     Expr,
+    Func,
     Identifier,
+    In,
     Literal,
+    Neg,
+    Not,
     Null,
+    Paren,
     Placeholder,
     TABLE_PARTS,
     Var,
@@ -36,6 +47,8 @@ from sqlglot.expressions.query import (
     From,
     Schema,
     Select,
+    SetOperation,
+    Subquery,
     Table,
     TableAlias,
     Tuple,
@@ -44,7 +57,7 @@ from sqlglot.expressions.query import (
     With,
     Query,
 )
-from sqlglot.expressions.ddl import Alter, AlterRename, RenameColumn
+from sqlglot.expressions.ddl import Alter, AlterRename, Create, RenameColumn
 from sqlglot.expressions.dml import Delete, Insert, Merge, Update, When, Whens
 from sqlglot.expressions.functions import Case, Cast
 from sqlglot.expressions.array import Array
@@ -53,11 +66,10 @@ from sqlglot.expressions.array import Array
 if t.TYPE_CHECKING:
     from collections.abc import Sequence, Iterable, Iterator
     from sqlglot.dialects.dialect import DialectType
-    from sqlglot.expressions.core import ExpOrStr, Func
+    from sqlglot.expressions.core import ExpOrStr
     from sqlglot.expressions.datatypes import DATA_TYPE
     from sqlglot._typing import ParserArgs, ParserNoDialectArgs, E, P
     from typing_extensions import Unpack, Concatenate
-    from sqlglot.expressions.core import Dot
 
 
 def select(
@@ -849,6 +861,43 @@ def replace_tables(
     return expression.transform(_replace_tables, copy=copy)  # type: ignore
 
 
+OPERATORS = (AtTimeZone, Between, Binary, BitwiseNot, In, Neg, Not)
+
+
+def _is_operand(placeholder: Placeholder) -> bool:
+    parent = placeholder.parent
+    if isinstance(parent, (Bracket, In)):
+        return placeholder.arg_key == "this"
+    return isinstance(parent, OPERATORS)
+
+
+def _takes_query(placeholder: Placeholder) -> bool:
+    parent = placeholder.parent
+    if isinstance(parent, In):
+        return placeholder.arg_key == "expressions" and len(parent.expressions) == 1
+    if isinstance(parent, Func):
+        return len(list(parent.iter_expressions())) == 1
+    if isinstance(parent, Table):
+        return isinstance(parent.parent, (Create, Subquery))
+    return not parent or isinstance(parent, (CTE, Paren, SetOperation))
+
+
+def _replace_placeholder(placeholder: Placeholder, expression: Expr) -> Expr:
+    if (
+        isinstance(expression, Query)
+        and not isinstance(expression, Subquery)
+        and not _takes_query(placeholder)
+    ):
+        return expression.subquery(copy=False)
+    if (
+        _is_operand(placeholder)
+        and isinstance(expression, OPERATORS)
+        and not isinstance(expression, Dot)
+    ):
+        return Paren(this=expression)
+    return expression
+
+
 def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Expr:
     """Replace placeholders in an expression.
 
@@ -874,10 +923,10 @@ def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Ex
             if node.this:
                 new_name = kwargs.get(node.this)
                 if new_name is not None:
-                    return convert(new_name)
+                    return _replace_placeholder(node, convert(new_name))
             else:
                 try:
-                    return convert(next(args))
+                    return _replace_placeholder(node, convert(next(args)))
                 except StopIteration:
                     pass
         return node

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/constraints.py

@@ -208,6 +208,7 @@ class Constraint(Expression):
 
 class ForeignKey(Expression):
     arg_types = {
+        "this": False,
         "expressions": False,
         "reference": False,
         "delete": False,

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/core.py

@@ -867,7 +867,7 @@ class Expression(Expr):
                     for k in sorted(node.args):
                         v = node.args[k]
                         if v:
-                            hash_ = hash((hash_, k, v))
+                            hash_ = hash((hash_, k, tuple(v) if type(v) is list else v))
                 else:
                     for k in sorted(node.args):
                         v = node.args[k]
@@ -1595,7 +1595,14 @@ class Uncache(Expression):
 
 
 class Refresh(Expression):
-    arg_types = {"this": True, "kind": True}
+    arg_types = {
+        "this": True,
+        "kind": True,
+        "partition_start": False,
+        "partition_end": False,
+        "force": False,
+        "mode": False,
+    }
 
 
 class LockingStatement(Expression):
@@ -1859,6 +1866,7 @@ class SessionParameter(Expression, Condition):
 
 class Placeholder(Expression, Condition):
     arg_types = {"this": False, "kind": False, "widget": False, "jdbc": False}
+    _hash_raw_args = True
 
     @property
     def name(self) -> str:
@@ -1994,6 +2002,7 @@ class Typeof(Expression, Func):
 
 class ParameterizedAgg(Expression, AggFunc):
     arg_types = {"this": True, "expressions": True, "params": True}
+    _hash_raw_args = True
 
 
 class Anonymous(Expression, Func):
@@ -2008,6 +2017,7 @@ class Anonymous(Expression, Func):
 class AnonymousAggFunc(Expression, AggFunc):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
+    _hash_raw_args = True
 
 
 class CombinedAggFunc(AnonymousAggFunc):
@@ -2211,7 +2221,7 @@ class Like(Expression, Binary, Predicate):
 
 
 class Match(Expression, Binary, Predicate):
-    pass
+    arg_types = {"this": True, "expression": True, "kind": False, "analyzer": False}
 
 
 class LT(Expression, Binary, Predicate):

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/ddl.py

@@ -176,6 +176,7 @@ class Set(Expression):
 
 class Heredoc(Expression):
     arg_types = {"this": True, "tag": False}
+    _hash_raw_args = True
 
 
 class SetItem(Expression):
@@ -382,6 +383,7 @@ class Undrop(Expression):
 
 class Command(Expression):
     arg_types = {"this": True, "expression": False}
+    _hash_raw_args = True
 
 
 class Transaction(Expression):

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/json.py

@@ -100,6 +100,7 @@ class JSONExists(Expression, Func):
         "on_condition": False,
         "from_dcolonqmark": False,
     }
+    _hash_raw_args = True
 
 
 class JSONExtract(Expression, Binary, Func):

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/properties.py

@@ -25,6 +25,10 @@ class AllowedValuesProperty(Expression):
     arg_types = {"expressions": True}
 
 
+class AggregateKeyProperty(Property):
+    arg_types = {"expressions": True}
+
+
 class AlgorithmProperty(Property):
     arg_types = {"this": True}
 
@@ -123,6 +127,7 @@ class DatabaseProperty(Property):
 
 class DefinerProperty(Property):
     arg_types = {"this": True}
+    _hash_raw_args = True
 
 
 class DistKeyProperty(Property):
@@ -390,6 +395,10 @@ class PartitionedOfProperty(Property):
     arg_types = {"this": True, "expression": True}
 
 
+class PhysicalProperty(Property):
+    arg_types = {"this": True, "value": False}
+
+
 class StreamingTableProperty(Property):
     arg_types = {}
 
@@ -497,6 +506,10 @@ class StorageHandlerProperty(Property):
     arg_types = {"this": True}
 
 
+class StorageProperty(Property):
+    arg_types = {"expressions": True}
+
+
 class UsingProperty(Property):
     # kind: JAR, FILE, or ARCHIVE; this: the resource path (string literal)
     arg_types = {"this": True, "kind": True}
@@ -522,6 +535,10 @@ class Tags(Property, ColumnConstraintKind):
     arg_types = {"expressions": True}
 
 
+class TableSpaceProperty(Property):
+    arg_types = {"this": True}
+
+
 class PropertiesLocation(AutoName):
     POST_CREATE = auto()
     POST_NAME = auto()

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/expressions/query.py

@@ -500,14 +500,17 @@ class HexString(Expression, Condition):
 class ByteString(Expression, Condition):
     arg_types = {"this": True, "is_bytes": False}
     is_primitive = True
+    _hash_raw_args = True
 
 
 class RawString(Expression, Condition):
     is_primitive = True
+    _hash_raw_args = True
 
 
 class UnicodeString(Expression, Condition):
     arg_types = {"this": True, "escape": False}
+    _hash_raw_args = True
 
 
 class ColumnPosition(Expression):
@@ -599,6 +602,7 @@ class Introducer(Expression):
 
 class National(Expression):
     is_primitive = True
+    _hash_raw_args = True
 
 
 class Partition(Expression):
@@ -2047,14 +2051,17 @@ class JSONPathPart(Expression):
 
 class JSONPathFilter(JSONPathPart):
     arg_types = {"this": True}
+    _hash_raw_args = True
 
 
 class JSONPathKey(JSONPathPart):
     arg_types = {"this": True, "quoted": False}
+    _hash_raw_args = True
 
 
 class JSONPathRecursive(JSONPathPart):
     arg_types = {"this": False}
+    _hash_raw_args = True
 
 
 class JSONPathRoot(JSONPathPart):
@@ -2063,6 +2070,7 @@ class JSONPathRoot(JSONPathPart):
 
 class JSONPathScript(JSONPathPart):
     arg_types = {"this": True}
+    _hash_raw_args = True
 
 
 class JSONPathSlice(JSONPathPart):
@@ -2079,6 +2087,7 @@ class JSONPathSubscript(JSONPathPart):
 
 class JSONPathUnion(JSONPathPart):
     arg_types = {"expressions": True}
+    _hash_raw_args = True
 
 
 class JSONPathWildcard(JSONPathPart):

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generator.py

@@ -706,6 +706,7 @@ class Generator:
     EXPRESSION_PRECEDES_PROPERTIES_CREATABLES: t.ClassVar[set[str]] = set()
 
     PROPERTIES_LOCATION: t.ClassVar = {
+        exp.AggregateKeyProperty: exp.Properties.Location.POST_SCHEMA,
         exp.AllowedValuesProperty: exp.Properties.Location.POST_SCHEMA,
         exp.AlgorithmProperty: exp.Properties.Location.POST_CREATE,
         exp.ApiProperty: exp.Properties.Location.POST_CREATE,
@@ -773,6 +774,7 @@ class Generator:
         exp.OutputModelProperty: exp.Properties.Location.POST_SCHEMA,
         exp.PartitionedByProperty: exp.Properties.Location.POST_WITH,
         exp.PartitionedOfProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.PhysicalProperty: exp.Properties.Location.UNSUPPORTED,
         exp.PrimaryKey: exp.Properties.Location.POST_SCHEMA,
         exp.Property: exp.Properties.Location.POST_WITH,
         exp.RefreshTriggerProperty: exp.Properties.Location.POST_SCHEMA,
@@ -800,9 +802,11 @@ class Generator:
         exp.SqlSecurityProperty: exp.Properties.Location.POST_SCHEMA,
         exp.StabilityProperty: exp.Properties.Location.POST_SCHEMA,
         exp.StorageHandlerProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.StorageProperty: exp.Properties.Location.UNSUPPORTED,
         exp.StreamingTableProperty: exp.Properties.Location.POST_CREATE,
         exp.StrictProperty: exp.Properties.Location.POST_SCHEMA,
         exp.Tags: exp.Properties.Location.POST_WITH,
+        exp.TableSpaceProperty: exp.Properties.Location.UNSUPPORTED,
         exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
         exp.ToTableProperty: exp.Properties.Location.POST_SCHEMA,
         exp.TransientProperty: exp.Properties.Location.POST_CREATE,
@@ -3840,6 +3844,8 @@ class Generator:
         return f"CHECK ({this})"
 
     def foreignkey_sql(self, expression: exp.ForeignKey) -> str:
+        this = self.sql(expression, "this")
+        this = f" {this}" if this else ""
         expressions = self.expressions(expression, flat=True)
         expressions = f" ({expressions})" if expressions else ""
         reference = self.sql(expression, "reference")
@@ -3850,7 +3856,7 @@ class Generator:
         update = f" ON UPDATE {update}" if update else ""
         options = self.expressions(expression, key="options", flat=True, sep=" ")
         options = f" {options}" if options else ""
-        return f"FOREIGN KEY{expressions}{reference}{delete}{update}{options}"
+        return f"FOREIGN KEY{this}{expressions}{reference}{delete}{update}{options}"
 
     def primarykey_sql(self, expression: exp.PrimaryKey) -> str:
         this = self.sql(expression, "this")
@@ -4688,6 +4694,8 @@ class Generator:
         return self._like_sql(expression)
 
     def match_sql(self, expression: exp.Match) -> str:
+        if expression.args.get("kind") or expression.args.get("analyzer"):
+            self.unsupported("MATCH variants and USING ANALYZER are not supported in this dialect")
         return self.binary(expression, "MATCH")
 
     def similarto_sql(self, expression: exp.SimilarTo) -> str:
@@ -5043,6 +5051,9 @@ class Generator:
     def dictsubproperty_sql(self, expression: exp.DictSubProperty) -> str:
         return f"{self.sql(expression, 'this')} {self.sql(expression, 'value')}"
 
+    def aggregatekeyproperty_sql(self, expression: exp.AggregateKeyProperty) -> str:
+        return f"AGGREGATE KEY ({self.expressions(expression, flat=True)})"
+
     def duplicatekeyproperty_sql(self, expression: exp.DuplicateKeyProperty) -> str:
         return f"DUPLICATE KEY ({self.expressions(expression, flat=True)})"
 
@@ -5281,6 +5292,7 @@ class Generator:
         expression_sql = self.sql(expression, "expression")
         return f"FOR {this} DO {expression_sql}"
 
+    @unsupported_args("partition_start", "partition_end", "force", "mode")
     def refresh_sql(self, expression: exp.Refresh) -> str:
         this = self.sql(expression, "this")
         kind = "" if isinstance(expression.this, exp.Literal) else f"{expression.text('kind')} "

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/athena.py

@@ -54,7 +54,11 @@ def _generate_as_hive(expression: exp.Expr) -> bool:
 
             # Any CREATE TABLE other than CREATE TABLE ... As <query> is Hive
             if not isinstance(expression.expression, exp.Query):
-                return True
+                # CTAS with a leading USING EXTERNAL FUNCTION clause is Trino
+                return not (
+                    isinstance(expression.expression, exp.Command)
+                    and expression.expression.text("this").upper() == "USING"
+                )
         else:
             # CREATE VIEW is Trino, but CREATE SCHEMA, CREATE DATABASE, etc, is Hive
             return expression.kind != "VIEW"

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/clickhouse.py

@@ -326,7 +326,7 @@ class ClickHouseGenerator(generator.Generator):
         exp.IsNan: rename_func("isNaN"),
         exp.JarowinklerSimilarity: jarowinkler_similarity("jaroWinklerSimilarity"),
         exp.JSONCast: _json_cast_sql,
-        exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
+        exp.JSONExtract: json_extract_segments("JSONExtractRaw", quoted_index=False),
         exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
         exp.JSONPathKey: json_path_key_only_name,
         exp.JSONPathRoot: lambda *_: "",
@@ -503,6 +503,14 @@ class ClickHouseGenerator(generator.Generator):
         if isinstance(this, exp.StrToDate) and expression.to == exp.DType.DATETIME.into_expr():
             return self.sql(this)
 
+        this = this.unnest()
+        if (
+            isinstance(this, exp.JSONExtract)
+            and this.args.get("requires_json")
+            and expression.to.is_type(*exp.DataType.TEXT_TYPES)
+        ):
+            return self.func("JSONExtract", this, exp.Literal.string("Nullable(String)"))
+
         return super().cast_sql(expression, safe_prefix=safe_prefix)
 
     def trycast_sql(self, expression: exp.TryCast) -> str:
@@ -543,6 +551,30 @@ class ClickHouseGenerator(generator.Generator):
     def neq_sql(self, expression: exp.NEQ) -> str:
         return self._any_to_has(expression, super().neq_sql, "NOT ")
 
+    def regexpcount_sql(self, expression: exp.RegexpCount) -> str:
+        this = expression.this
+        pattern = expression.expression
+        position = expression.args.get("position")
+        parameters = expression.args.get("parameters")
+
+        if position:
+            # SUBSTRING counts bytes in ClickHouse, the position counts characters
+            this = self.func("substringUTF8", this, position)
+
+        if parameters:
+            flags = parameters.name if parameters.is_string else ""
+            if not parameters.is_string or set(flags) - set("cims"):
+                self.unsupported("Only literal 'c', 'i', 'm' and 's' regexp flags are supported")
+            # "c" (case-sensitive) is the default, and the last of "c" and "i" wins
+            if flags.rfind("c") > flags.rfind("i"):
+                flags = flags.replace("i", "")
+            flags = "".join(f for f in flags if f in "ims")
+            if flags:
+                # countMatches has no flags argument, so they are embedded in the pattern
+                pattern = self.func("CONCAT", exp.Literal.string(f"(?{flags})"), pattern)
+
+        return self.func("countMatches", this, pattern)
+
     def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
         # Manually add a flag to make the search case-insensitive
         regex = self.func("CONCAT", "'(?i)'", expression.expression)

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/doris.py

@@ -23,6 +23,12 @@ def _lag_lead_sql(self, expression: exp.Lag | exp.Lead) -> str:
 
 
 class DorisGenerator(MySQLGenerator):
+    def match_sql(self, expression: exp.Match) -> str:
+        kind = expression.text("kind")
+        sql = self.binary(expression, f"MATCH_{kind}" if kind else "MATCH")
+        analyzer = self.sql(expression, "analyzer")
+        return f"{sql} USING ANALYZER {analyzer}" if analyzer else sql
+
     LAST_DAY_SUPPORTS_DATE_PART = False
     SUPPORTS_ALTER_COLUMN_NULLABILITY = False
     VARCHAR_REQUIRES_SIZE = False

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/duckdb.py

@@ -388,6 +388,10 @@ def _array_insert_sql(self: DuckDBGenerator, expression: exp.ArrayInsert) -> str
 
     pos_value = position.to_py()
 
+    # 1-based -1 appends (Spark/Databricks); the 0-based normalization below
+    # would otherwise map it onto the prepend branch.
+    append = index_offset == 1 and pos_value == -1
+
     # Normalize one-based indexing to zero-based for slice calculations
     # Spark (1-based) -> Snowflake (0-based):
     #   Positive: pos=1 -> pos=0 (subtract 1)
@@ -399,7 +403,10 @@ def _array_insert_sql(self: DuckDBGenerator, expression: exp.ArrayInsert) -> str
         pos_value = pos_value + index_offset
 
     # Build the appropriate list_concat expression based on position
-    if pos_value == 0:
+    if append:
+        # append at end
+        concat_exprs = [this, element_array]
+    elif pos_value == 0:
         # insert at beginning
         concat_exprs = [element_array, this]
     elif pos_value > 0:
@@ -4164,7 +4171,7 @@ class DuckDBGenerator(generator.Generator):
                     this=exp.Transform(
                         this=expression.this,
                         expression=exp.Lambda(
-                            this=exp.Coalesce(this=x, expressions=[null]),
+                            this=exp.Coalesce(this=exp.cast(x, "TEXT"), expressions=[null]),
                             expressions=[x],
                         ),
                     ),

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/oracle.py

@@ -106,13 +106,24 @@ class OracleGenerator(generator.Generator):
         exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
         exp.UtcTime: rename_func("UTC_TIME"),
         exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
+        exp.TableSpaceProperty: lambda self, e: f"TABLESPACE {self.sql(e, 'this')}",
     }
 
     PROPERTIES_LOCATION = {
         **generator.Generator.PROPERTIES_LOCATION,
         exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
+        exp.TableSpaceProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.PhysicalProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.StorageProperty: exp.Properties.Location.POST_SCHEMA,
     }
 
+    def physicalproperty_sql(self, expression: exp.PhysicalProperty) -> str:
+        value = self.sql(expression, "value")
+        return f"{expression.name}{f' {value}' if value else ''}"
+
+    def storageproperty_sql(self, expression: exp.StorageProperty) -> str:
+        return f"STORAGE ({self.expressions(expression, sep=' ', flat=True)})"
+
     def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
         if expression.args.get("sysdate"):
             return "SYSDATE"
@@ -120,6 +131,17 @@ class OracleGenerator(generator.Generator):
         this = expression.this
         return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"
 
+    def version_sql(self, expression: exp.Version) -> str:
+        if expression.text("kind") == "AS OF":
+            value = expression.expression
+            value_sql = (
+                self.func("TO_TIMESTAMP", value, exp.Literal.string("YYYY-MM-DD HH24:MI:SS.FF6"))
+                if expression.name == "TIMESTAMP" and value.is_string
+                else self.sql(value)
+            )
+            return f"AS OF {expression.name} {value_sql}"
+        return super().version_sql(expression)
+
     def offset_sql(self, expression: exp.Offset) -> str:
         return f"{super().offset_sql(expression)} ROWS"
 

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/presto.py

@@ -4,6 +4,7 @@ import typing as t
 
 from sqlglot import exp, generator, transforms
 from sqlglot.dialects.dialect import (
+    array_slice_to_slice_sql,
     bool_xor_sql,
     bracket_to_element_at_sql,
     datestrtodate_sql,
@@ -324,7 +325,7 @@ class PrestoGenerator(generator.Generator):
         exp.ArrayContains: rename_func("CONTAINS"),
         exp.ArrayToString: rename_func("ARRAY_JOIN"),
         exp.ArrayUniqueAgg: rename_func("SET_AGG"),
-        exp.ArraySlice: rename_func("SLICE"),
+        exp.ArraySlice: array_slice_to_slice_sql,
         exp.AtTimeZone: rename_func("AT_TIMEZONE"),
         exp.BitwiseAnd: lambda self, e: self.func("BITWISE_AND", e.this, e.expression),
         exp.BitwiseLeftShift: rename_func("BITWISE_LEFT_SHIFT"),

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/spark2.py

@@ -4,6 +4,7 @@ import typing as t
 
 from sqlglot import exp, transforms
 from sqlglot.dialects.dialect import (
+    array_slice_to_slice_sql,
     bracket_to_element_at_sql,
     is_parse_json,
     rename_func,
@@ -139,7 +140,7 @@ class Spark2Generator(HiveGenerator):
                 f"AGGREGATE({self.sql(e, 'this')}, 0, (acc, x) -> acc + x, acc -> acc)"
             ),
             exp.ArrayToString: rename_func("ARRAY_JOIN"),
-            exp.ArraySlice: rename_func("SLICE"),
+            exp.ArraySlice: array_slice_to_slice_sql,
             exp.AtTimeZone: lambda self, e: self.func(
                 "FROM_UTC_TIMESTAMP", e.this, e.args.get("zone")
             ),

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/starrocks.py

@@ -79,6 +79,7 @@ class StarRocksGenerator(MySQLGenerator):
 
     TYPE_MAPPING = {
         **MySQLGenerator.TYPE_MAPPING,
+        exp.DType.HLLSKETCH: "HLL",
         exp.DType.INT128: "LARGEINT",
         exp.DType.TEXT: "STRING",
         exp.DType.TIMESTAMP: "DATETIME",
@@ -379,3 +380,23 @@ class StarRocksGenerator(MySQLGenerator):
         every = f" EVERY (INTERVAL {every} {unit})" if every and unit else ""
 
         return f"REFRESH{method}{kind}{starts}{every}"
+
+    def refresh_sql(self, expression: exp.Refresh) -> str:
+        this = self.sql(expression, "this")
+        kind = "" if isinstance(expression.this, exp.Literal) else f"{expression.text('kind')} "
+        partition_start = self.sql(expression, "partition_start")
+        partition_end = self.sql(expression, "partition_end")
+        partition = (
+            f" PARTITION START ({partition_start}) END ({partition_end})" if partition_start else ""
+        )
+        force = " FORCE" if expression.args.get("force") else ""
+        mode = self.sql(expression, "mode")
+        mode = f" WITH {mode} MODE" if mode else ""
+
+        return f"REFRESH {kind}{this}{partition}{force}{mode}"
+
+    def timeslice_sql(self, expression: exp.TimeSlice) -> str:
+        interval = exp.Interval(this=expression.expression, unit=expression.unit)
+        kind = expression.text("kind").upper()
+        boundary = exp.var("CEIL" if kind == "END" else "FLOOR") if kind else None
+        return self.func("TIME_SLICE", expression.this, interval, boundary)

{sqlglotc-30.22.0 → sqlglotc-30.23.0}/sqlglot/generators/teradata.py

@@ -10,6 +10,7 @@ from sqlglot.dialects.dialect import (
     strposition_sql,
     to_number_with_nls_param,
 )
+from sqlglot.parsers.teradata import is_window_aggregate
 from collections import defaultdict
 
 
@@ -117,6 +118,24 @@ class TeradataGenerator(generator.Generator):
     ) -> str:
         return f"{self.sql(expression, 'this')} SAMPLE {self.expressions(expression)}"
 
+    def window_sql(self, expression: exp.Window) -> str:
+        spec = expression.args.get("spec")
+
+        if (
+            spec
+            and expression.args.get("order")
+            and is_window_aggregate(expression)
+            and spec.text("kind").upper() == "ROWS"
+            and spec.text("start").upper() == "UNBOUNDED"
+            and spec.text("start_side").upper() == "PRECEDING"
+            and spec.text("end").upper() == "UNBOUNDED"
+            and spec.text("end_side").upper() == "FOLLOWING"
+        ):
+            # This is the default frame of window aggregates with ORDER BY in Teradata
+            expression.set("spec", None)
+
+        return super().window_sql(expression)
+
     def partitionedbyproperty_sql(self, expression: exp.PartitionedByProperty) -> str:
         return f"PARTITION BY {self.sql(expression, 'this')}"