sqlglot 27.27.0__py3-none-any.whl → 27.28.1__py3-none-any.whl

sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '27.27.0'
-__version_tuple__ = version_tuple = (27, 27, 0)
+__version__ = version = '27.28.1'
+__version_tuple__ = version_tuple = (27, 28, 1)
 
 __commit_id__ = commit_id = None

sqlglot/dialects/bigquery.py

@@ -496,6 +496,115 @@ class BigQuery(Dialect):
     # BigQuery maps Type.TIMESTAMP to DATETIME, so we need to amend the inferred types
     TYPE_TO_EXPRESSIONS = {
         **Dialect.TYPE_TO_EXPRESSIONS,
+        exp.DataType.Type.BIGINT: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BIGINT],
+            exp.Ascii,
+            exp.BitwiseAndAgg,
+            exp.BitwiseOrAgg,
+            exp.BitwiseXorAgg,
+            exp.BitwiseCount,
+            exp.ByteLength,
+            exp.DenseRank,
+            exp.FarmFingerprint,
+            exp.Grouping,
+            exp.LaxInt64,
+            exp.Ntile,
+            exp.Rank,
+            exp.RangeBucket,
+            exp.RegexpInstr,
+            exp.RowNumber,
+            exp.Unicode,
+        },
+        exp.DataType.Type.BINARY: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BINARY],
+            exp.ByteString,
+            exp.CodePointsToBytes,
+            exp.MD5Digest,
+            exp.SHA,
+            exp.SHA2,
+            exp.Unhex,
+        },
+        exp.DataType.Type.BOOLEAN: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BOOLEAN],
+            exp.IsInf,
+            exp.IsNan,
+            exp.JSONBool,
+            exp.LaxBool,
+        },
+        exp.DataType.Type.DATE: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.DATE],
+            exp.DateFromUnixDate,
+        },
+        exp.DataType.Type.DATETIME: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.DATETIME],
+            exp.ParseDatetime,
+            exp.TimestampFromParts,
+        },
+        exp.DataType.Type.DECIMAL: {
+            exp.ParseNumeric,
+        },
+        exp.DataType.Type.BIGDECIMAL: {
+            exp.ParseBignumeric,
+        },
+        exp.DataType.Type.DOUBLE: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.DOUBLE],
+            exp.Acos,
+            exp.Acosh,
+            exp.Asin,
+            exp.Asinh,
+            exp.Atan,
+            exp.Atanh,
+            exp.Atan2,
+            exp.Cbrt,
+            exp.Corr,
+            exp.Cot,
+            exp.CosineDistance,
+            exp.Coth,
+            exp.CovarPop,
+            exp.CovarSamp,
+            exp.Csc,
+            exp.Csch,
+            exp.CumeDist,
+            exp.EuclideanDistance,
+            exp.Float64,
+            exp.LaxFloat64,
+            exp.PercentRank,
+            exp.Rand,
+            exp.Sec,
+            exp.Sech,
+            exp.Sin,
+            exp.Sinh,
+        },
+        exp.DataType.Type.JSON: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.JSON],
+            exp.JSONArray,
+            exp.JSONArrayAppend,
+            exp.JSONArrayInsert,
+            exp.JSONObject,
+            exp.JSONRemove,
+            exp.JSONSet,
+            exp.JSONStripNulls,
+        },
+        exp.DataType.Type.TIME: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.TIME],
+            exp.ParseTime,
+            exp.TimeFromParts,
+            exp.TimeTrunc,
+            exp.TsOrDsToTime,
+        },
+        exp.DataType.Type.VARCHAR: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.VARCHAR],
+            exp.CodePointsToString,
+            exp.Format,
+            exp.JSONExtractScalar,
+            exp.JSONType,
+            exp.LaxString,
+            exp.LowerHex,
+            exp.Normalize,
+            exp.SafeConvertBytesToString,
+            exp.Soundex,
+            exp.Uuid,
+        },
         exp.DataType.Type.TIMESTAMPTZ: Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.TIMESTAMP],
     }
     TYPE_TO_EXPRESSIONS.pop(exp.DataType.Type.TIMESTAMP)
@@ -545,64 +654,15 @@ class BigQuery(Dialect):
                 exp.Upper,
             )
         },
-        exp.Acos: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Acosh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Asin: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Asinh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Atan: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Atanh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Atan2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
         exp.ApproxTopSum: lambda self, e: _annotate_by_args_approx_top(self, e),
         exp.ApproxTopK: lambda self, e: _annotate_by_args_approx_top(self, e),
         exp.ApproxQuantiles: lambda self, e: self._annotate_by_args(e, "this", array=True),
         exp.Array: _annotate_array,
         exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
-        exp.Ascii: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.BitwiseAndAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.BitwiseOrAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.BitwiseXorAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.BitwiseCountAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.ByteLength: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.ByteString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
-        exp.Cbrt: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.CodePointsToBytes: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.BINARY
-        ),
-        exp.CodePointsToString: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.VARCHAR
-        ),
         exp.Concat: _annotate_concat,
-        exp.Corr: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Cot: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.CosineDistance: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Coth: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.CovarPop: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.CovarSamp: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Csc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Csch: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.CumeDist: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.DateFromUnixDate: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATE),
-        exp.DenseRank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.EuclideanDistance: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.DOUBLE
-        ),
-        exp.FarmFingerprint: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.Unhex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
-        exp.Float64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Format: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
         exp.GenerateTimestampArray: lambda self, e: self._annotate_with_type(
             e, exp.DataType.build("ARRAY<TIMESTAMP>", dialect="bigquery")
         ),
-        exp.Grouping: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.IsInf: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
-        exp.IsNan: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
-        exp.JSONArray: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONArrayAppend: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONArrayInsert: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONBool: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
-        exp.JSONExtractScalar: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.VARCHAR
-        ),
         exp.JSONExtractArray: lambda self, e: self._annotate_by_args(e, "this", array=True),
         exp.JSONFormat: lambda self, e: self._annotate_with_type(
             e, exp.DataType.Type.JSON if e.args.get("to_json") else exp.DataType.Type.VARCHAR
@@ -610,62 +670,19 @@ class BigQuery(Dialect):
         exp.JSONKeysAtDepth: lambda self, e: self._annotate_with_type(
             e, exp.DataType.build("ARRAY<VARCHAR>", dialect="bigquery")
         ),
-        exp.JSONObject: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONRemove: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONSet: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONStripNulls: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
-        exp.JSONType: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
         exp.JSONValueArray: lambda self, e: self._annotate_with_type(
             e, exp.DataType.build("ARRAY<VARCHAR>", dialect="bigquery")
         ),
         exp.Lag: lambda self, e: self._annotate_by_args(e, "this", "default"),
-        exp.LowerHex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
-        exp.LaxBool: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
-        exp.LaxFloat64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.LaxInt64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.LaxString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
-        exp.MD5Digest: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
-        exp.Normalize: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
-        exp.Ntile: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.ParseTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
-        exp.ParseDatetime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATETIME),
-        exp.ParseBignumeric: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.BIGDECIMAL
-        ),
-        exp.ParseNumeric: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DECIMAL),
         exp.PercentileCont: lambda self, e: _annotate_by_args_with_coerce(self, e),
-        exp.PercentRank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Rank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.RangeBucket: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
         exp.RegexpExtractAll: lambda self, e: self._annotate_by_args(e, "this", array=True),
-        exp.RegexpInstr: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.RowNumber: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.Rand: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.SafeConvertBytesToString: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.VARCHAR
-        ),
         exp.SafeAdd: lambda self, e: _annotate_by_args_with_coerce(self, e),
         exp.SafeMultiply: lambda self, e: _annotate_by_args_with_coerce(self, e),
         exp.SafeSubtract: lambda self, e: _annotate_by_args_with_coerce(self, e),
-        exp.Sec: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Sech: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Soundex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
-        exp.SHA: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
-        exp.SHA2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
-        exp.Sin: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
-        exp.Sinh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
         exp.Split: lambda self, e: self._annotate_by_args(e, "this", array=True),
-        exp.TimestampFromParts: lambda self, e: self._annotate_with_type(
-            e, exp.DataType.Type.DATETIME
-        ),
-        exp.TimeFromParts: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
-        exp.TimeTrunc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
         exp.ToCodePoints: lambda self, e: self._annotate_with_type(
             e, exp.DataType.build("ARRAY<BIGINT>", dialect="bigquery")
         ),
-        exp.TsOrDsToTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
-        exp.Unicode: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
-        exp.Uuid: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     }
 
     def normalize_identifier(self, expression: E) -> E:
@@ -786,7 +803,7 @@ class BigQuery(Dialect):
             "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
             "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
             "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
-            "BIT_COUNT": exp.BitwiseCountAgg.from_arg_list,
+            "BIT_COUNT": exp.BitwiseCount.from_arg_list,
             "BOOL": exp.JSONBool.from_arg_list,
             "CONTAINS_SUBSTR": _build_contains_substring,
             "DATE": _build_date,
@@ -1302,7 +1319,7 @@ class BigQuery(Dialect):
             exp.BitwiseAndAgg: rename_func("BIT_AND"),
             exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXorAgg: rename_func("BIT_XOR"),
-            exp.BitwiseCountAgg: rename_func("BIT_COUNT"),
+            exp.BitwiseCount: rename_func("BIT_COUNT"),
             exp.ByteLength: rename_func("BYTE_LENGTH"),
             exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
             exp.CollateProperty: lambda self, e: (

sqlglot/dialects/clickhouse.py

@@ -1418,9 +1418,12 @@ class ClickHouse(Dialect):
             return in_sql
 
         def not_sql(self, expression: exp.Not) -> str:
-            if isinstance(expression.this, exp.In) and expression.this.args.get("is_global"):
-                # let `GLOBAL IN` child interpose `NOT`
-                return self.sql(expression, "this")
+            if isinstance(expression.this, exp.In):
+                if expression.this.args.get("is_global"):
+                    # let `GLOBAL IN` child interpose `NOT`
+                    return self.sql(expression, "this")
+
+                expression.set("this", exp.paren(expression.this, copy=False))
 
             return super().not_sql(expression)
 

sqlglot/dialects/duckdb.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 import typing as t
 
 from sqlglot import exp, generator, parser, tokens, transforms
@@ -44,6 +45,10 @@ from sqlglot.helper import seq_get
 from sqlglot.tokens import TokenType
 from sqlglot.parser import binary_range_parser
 
+# Regex to detect time zones in timestamps of the form [+|-]TT[:tt]
+# The pattern matches timezone offsets that appear after the time portion
+TIMEZONE_PATTERN = re.compile(r":\d{2}.*?[+\-]\d{2}(?::\d{2})?")
+
 
 # BigQuery -> DuckDB conversion for the DATE function
 def _date_sql(self: DuckDB.Generator, expression: exp.Date) -> str:
@@ -211,7 +216,18 @@ def _arrow_json_extract_sql(self: DuckDB.Generator, expression: JSON_EXTRACT_TYP
 def _implicit_datetime_cast(
     arg: t.Optional[exp.Expression], type: exp.DataType.Type = exp.DataType.Type.DATE
 ) -> t.Optional[exp.Expression]:
-    return exp.cast(arg, type) if isinstance(arg, exp.Literal) else arg
+    if isinstance(arg, exp.Literal) and arg.is_string:
+        ts = arg.name
+        if type == exp.DataType.Type.DATE and ":" in ts:
+            type = (
+                exp.DataType.Type.TIMESTAMPTZ
+                if TIMEZONE_PATTERN.search(ts)
+                else exp.DataType.Type.TIMESTAMP
+            )
+
+        arg = exp.cast(arg, type)
+
+    return arg
 
 
 def _date_diff_sql(self: DuckDB.Generator, expression: exp.DateDiff) -> str:
@@ -694,6 +710,7 @@ class DuckDB(Dialect):
             exp.DateDiff: _date_diff_sql,
             exp.DateStrToDate: datestrtodate_sql,
             exp.Datetime: no_datetime_sql,
+            exp.DatetimeDiff: _date_diff_sql,
             exp.DatetimeSub: date_delta_to_binary_interval_op(),
             exp.DatetimeAdd: date_delta_to_binary_interval_op(),
             exp.DateToDi: lambda self,
@@ -758,6 +775,7 @@ class DuckDB(Dialect):
             exp.Struct: _struct_sql,
             exp.Transform: rename_func("LIST_TRANSFORM"),
             exp.TimeAdd: date_delta_to_binary_interval_op(),
+            exp.TimeSub: date_delta_to_binary_interval_op(),
             exp.Time: no_time_sql,
             exp.TimeDiff: _timediff_sql,
             exp.Timestamp: no_timestamp_sql,
@@ -781,6 +799,7 @@ class DuckDB(Dialect):
                 exp.cast(e.expression, exp.DataType.Type.TIMESTAMP),
                 exp.cast(e.this, exp.DataType.Type.TIMESTAMP),
             ),
+            exp.UnixMicros: rename_func("EPOCH_US"),
             exp.UnixToStr: lambda self, e: self.func(
                 "STRFTIME", self.func("TO_TIMESTAMP", e.this), self.format_time(e)
             ),

sqlglot/dialects/mysql.py

@@ -325,7 +325,7 @@ class MySQL(Dialect):
             "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
             "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
             "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
-            "BIT_COUNT": exp.BitwiseCountAgg.from_arg_list,
+            "BIT_COUNT": exp.BitwiseCount.from_arg_list,
             "CONVERT_TZ": lambda args: exp.ConvertTimezone(
                 source_tz=seq_get(args, 1), target_tz=seq_get(args, 2), timestamp=seq_get(args, 0)
             ),
@@ -755,7 +755,7 @@ class MySQL(Dialect):
             exp.BitwiseAndAgg: rename_func("BIT_AND"),
             exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXorAgg: rename_func("BIT_XOR"),
-            exp.BitwiseCountAgg: rename_func("BIT_COUNT"),
+            exp.BitwiseCount: rename_func("BIT_COUNT"),
             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")

sqlglot/dialects/snowflake.py

@@ -23,6 +23,7 @@ from sqlglot.dialects.dialect import (
     rename_func,
     timestamptrunc_sql,
     timestrtotime_sql,
+    unit_to_str,
     var_map_sql,
     map_date_part,
     no_timestamp_sql,
@@ -41,6 +42,9 @@ if t.TYPE_CHECKING:
     from sqlglot._typing import E, B
 
 
+DATE_PARTS = ["YEAR", "QUARTER", "MONTH", "WEEK", "DAY"]
+
+
 def _build_strtok(args: t.List) -> exp.SplitPart:
     # Add default delimiter (space) if missing - per Snowflake docs
     if len(args) == 1:
@@ -547,6 +551,19 @@ def _annotate_reverse(self: TypeAnnotator, expression: exp.Reverse) -> exp.Rever
     return expression
 
 
+def _annotate_date_or_time_add(self: TypeAnnotator, expression: E) -> E:
+    self._annotate_args(expression)
+
+    if (
+        expression.this.is_type(exp.DataType.Type.DATE)
+        and expression.text("unit").upper() not in DATE_PARTS
+    ):
+        self._set_type(expression, exp.DataType.Type.TIMESTAMPNTZ)
+    else:
+        self._annotate_by_args(expression, "this")
+    return expression
+
+
 class Snowflake(Dialect):
     # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
     NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
@@ -570,6 +587,7 @@ class Snowflake(Dialect):
             exp.Cot,
             exp.Degrees,
             exp.Exp,
+            exp.MonthsBetween,
             exp.Sin,
             exp.Sinh,
             exp.Tan,
@@ -588,10 +606,14 @@ class Snowflake(Dialect):
             exp.Length,
             exp.RtrimmedLength,
             exp.BitLength,
+            exp.Hour,
             exp.Levenshtein,
             exp.JarowinklerSimilarity,
+            exp.Minute,
+            exp.Second,
             exp.StrPosition,
             exp.Unicode,
+            exp.WidthBucket,
         },
         exp.DataType.Type.VARCHAR: {
             *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.VARCHAR],
@@ -610,6 +632,7 @@ class Snowflake(Dialect):
             exp.TryHexDecodeString,
             exp.HexEncode,
             exp.Initcap,
+            exp.Monthname,
             exp.RegexpExtract,
             exp.RegexpReplace,
             exp.Repeat,
@@ -640,6 +663,7 @@ class Snowflake(Dialect):
             exp.Factorial,
             exp.MD5NumberLower64,
             exp.MD5NumberUpper64,
+            exp.Rand,
         },
         exp.DataType.Type.ARRAY: {
             exp.Split,
@@ -655,8 +679,18 @@ class Snowflake(Dialect):
         },
         exp.DataType.Type.BOOLEAN: {
             *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BOOLEAN],
+            exp.Boolnot,
             exp.Search,
         },
+        exp.DataType.Type.DATE: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.DATE],
+            exp.NextDay,
+            exp.PreviousDay,
+        },
+        exp.DataType.Type.TIME: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.TIME],
+            exp.TimeFromParts,
+        },
     }
 
     ANNOTATORS = {
@@ -669,6 +703,7 @@ class Snowflake(Dialect):
         **{
             expr_type: lambda self, e: self._annotate_by_args(e, "this")
             for expr_type in (
+                exp.AddMonths,
                 exp.Floor,
                 exp.Left,
                 exp.Pad,
@@ -677,6 +712,9 @@ class Snowflake(Dialect):
                 exp.Substring,
                 exp.Round,
                 exp.Ceil,
+                exp.DateTrunc,
+                exp.TimeSlice,
+                exp.TimestampTrunc,
             )
         },
         **{
@@ -689,7 +727,15 @@ class Snowflake(Dialect):
             )
         },
         exp.ConcatWs: lambda self, e: self._annotate_by_args(e, "expressions"),
+        exp.ConvertTimezone: lambda self, e: self._annotate_with_type(
+            e,
+            exp.DataType.Type.TIMESTAMPNTZ
+            if e.args.get("source_tz")
+            else exp.DataType.Type.TIMESTAMPTZ,
+        ),
+        exp.DateAdd: _annotate_date_or_time_add,
         exp.Reverse: _annotate_reverse,
+        exp.TimeAdd: _annotate_date_or_time_add,
     }
 
     TIME_MAPPING = {
@@ -1078,8 +1124,11 @@ class Snowflake(Dialect):
             if not this:
                 return None
 
-            self._match(TokenType.COMMA)
-            expression = self._parse_bitwise()
+            # Handle both syntaxes: DATE_PART(part, expr) and DATE_PART(part FROM expr)
+            expression = (
+                self._match_set((TokenType.FROM, TokenType.COMMA)) and self._parse_bitwise()
+            )
+
             this = map_date_part(this)
             name = this.name.upper()
 
@@ -1545,6 +1594,13 @@ class Snowflake(Dialect):
             exp.Stuff: rename_func("INSERT"),
             exp.StPoint: rename_func("ST_MAKEPOINT"),
             exp.TimeAdd: date_delta_sql("TIMEADD"),
+            exp.TimeSlice: lambda self, e: self.func(
+                "TIME_SLICE",
+                e.this,
+                e.expression,
+                unit_to_str(e),
+                e.args.get("kind"),
+            ),
             exp.Timestamp: no_timestamp_sql,
             exp.TimestampAdd: date_delta_sql("TIMESTAMPADD"),
             exp.TimestampDiff: lambda self, e: self.func(

sqlglot/dialects/spark.py

@@ -128,7 +128,7 @@ class Spark(Spark2):
             "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
             "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
             "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
-            "BIT_COUNT": exp.BitwiseCountAgg.from_arg_list,
+            "BIT_COUNT": exp.BitwiseCount.from_arg_list,
             "DATE_ADD": _build_dateadd,
             "DATEADD": _build_dateadd,
             "TIMESTAMPADD": _build_dateadd,
@@ -196,7 +196,7 @@ class Spark(Spark2):
             exp.BitwiseAndAgg: rename_func("BIT_AND"),
             exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXorAgg: rename_func("BIT_XOR"),
-            exp.BitwiseCountAgg: rename_func("BIT_COUNT"),
+            exp.BitwiseCount: rename_func("BIT_COUNT"),
             exp.Create: preprocess(
                 [
                     remove_unique_constraints,
@@ -258,3 +258,11 @@ class Spark(Spark2):
                 return super().placeholder_sql(expression)
 
             return f"{{{expression.name}}}"
+
+        def readparquet_sql(self, expression: exp.ReadParquet) -> str:
+            if len(expression.expressions) != 1:
+                self.unsupported("READ_PARQUET with multiple arguments is not supported")
+                return ""
+
+            parquet_file = expression.expressions[0]
+            return f"parquet.`{parquet_file.name}`"

sqlglot/dialects/starrocks.py

@@ -127,6 +127,9 @@ class StarRocks(MySQL):
         PARSE_JSON_NAME: t.Optional[str] = "PARSE_JSON"
         WITH_PROPERTIES_PREFIX = "PROPERTIES"
 
+        # StarRocks doesn't support "IS TRUE/FALSE" syntax.
+        IS_BOOL_ALLOWED = False
+
         CAST_MAPPING = {}
 
         TYPE_MAPPING = {

sqlglot/dialects/tsql.py

@@ -200,7 +200,7 @@ def _build_hashbytes(args: t.List) -> exp.Expression:
     return exp.func("HASHBYTES", *args)
 
 
-DATEPART_ONLY_FORMATS = {"DW", "WK", "HOUR", "QUARTER"}
+DATEPART_ONLY_FORMATS = {"DW", "WK", "HOUR", "QUARTER", "ISO_WEEK"}
 
 
 def _format_sql(self: TSQL.Generator, expression: exp.NumberToStr | exp.TimeToStr) -> str:
@@ -426,6 +426,9 @@ class TSQL(Dialect):
         "week": "%W",
         "ww": "%W",
         "wk": "%W",
+        "isowk": "%IW",
+        "isoww": "%IW",
+        "iso_week": "%IW",
         "hour": "%h",
         "hh": "%I",
         "minute": "%M",

sqlglot/expressions.py

@@ -454,9 +454,8 @@ class Expression(metaclass=_Expression):
                 for v in reversed(vs) if reverse else vs:  # type: ignore
                     if hasattr(v, "parent"):
                         yield v
-            else:
-                if hasattr(vs, "parent"):
-                    yield vs
+            elif hasattr(vs, "parent"):
+                yield vs
 
     def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
         """
@@ -3834,8 +3833,15 @@ class Update(DML):
         )
 
 
+# DuckDB supports VALUES followed by https://duckdb.org/docs/stable/sql/query_syntax/limit
 class Values(UDTF):
-    arg_types = {"expressions": True, "alias": False}
+    arg_types = {
+        "expressions": True,
+        "alias": False,
+        "order": False,
+        "limit": False,
+        "offset": False,
+    }
 
 
 class Var(Expression):
@@ -5602,7 +5608,7 @@ class BitwiseXorAgg(AggFunc):
     pass
 
 
-class BitwiseCountAgg(AggFunc):
+class BitwiseCount(Func):
     pass
 
 
@@ -5610,6 +5616,10 @@ class ByteLength(Func):
     pass
 
 
+class Boolnot(Func):
+    pass
+
+
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#bool_for_json
 class JSONBool(Func):
     pass
@@ -6286,6 +6296,10 @@ class LastDay(Func, TimeUnit):
     arg_types = {"this": True, "unit": False}
 
 
+class PreviousDay(Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class LaxBool(Func):
     pass
 
@@ -6331,6 +6345,10 @@ class TimestampTrunc(Func, TimeUnit):
     arg_types = {"this": True, "unit": True, "zone": False}
 
 
+class TimeSlice(Func, TimeUnit):
+    arg_types = {"this": True, "expression": True, "unit": True, "kind": False}
+
+
 class TimeAdd(Func, TimeUnit):
     arg_types = {"this": True, "expression": True, "unit": False}
 
@@ -6576,6 +6594,18 @@ class HexEncode(Func):
     arg_types = {"this": True, "case": False}
 
 
+class Hour(Func):
+    pass
+
+
+class Minute(Func):
+    pass
+
+
+class Second(Func):
+    pass
+
+
 # T-SQL: https://learn.microsoft.com/en-us/sql/t-sql/functions/compress-transact-sql?view=sql-server-ver17
 # Snowflake: https://docs.snowflake.com/en/sql-reference/functions/compress
 class Compress(Func):
@@ -6701,7 +6731,7 @@ class FormatJson(Expression):
 
 
 class Format(Func):
-    arg_types = {"this": True, "expressions": True}
+    arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
 
 
@@ -7144,6 +7174,10 @@ class Month(Func):
     pass
 
 
+class Monthname(Func):
+    pass
+
+
 class AddMonths(Func):
     arg_types = {"this": True, "expression": True}
 
@@ -7276,6 +7310,11 @@ class ReadCSV(Func):
     arg_types = {"this": True, "expressions": False}
 
 
+class ReadParquet(Func):
+    is_var_len_args = True
+    arg_types = {"expressions": True}
+
+
 class Reduce(Func):
     arg_types = {"this": True, "initial": True, "merge": True, "finish": False}
 
@@ -7752,6 +7791,10 @@ class VariancePop(AggFunc):
     _sql_names = ["VARIANCE_POP", "VAR_POP"]
 
 
+class WidthBucket(Func):
+    arg_types = {"this": True, "min_value": True, "max_value": True, "num_buckets": True}
+
+
 class CovarSamp(Binary, AggFunc):
     pass
 
@@ -7768,6 +7811,10 @@ class WeekStart(Expression):
     pass
 
 
+class NextDay(Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class XMLElement(Func):
     _sql_names = ["XMLELEMENT"]
     arg_types = {"this": True, "expressions": False}

sqlglot/generator.py

@@ -2223,6 +2223,7 @@ class Generator(metaclass=_Generator):
                 and (alias or isinstance(expression.parent, (exp.From, exp.Table)))
                 else values
             )
+            values = self.query_modifiers(expression, values)
             return f"{values} AS {alias}" if alias else values
 
         # Converts `VALUES...` expression into a series of select unions.

sqlglot/lineage.py

@@ -73,6 +73,7 @@ def lineage(
     dialect: DialectType = None,
     scope: t.Optional[Scope] = None,
     trim_selects: bool = True,
+    copy: bool = True,
     **kwargs,
 ) -> Node:
     """Build the lineage graph for a column of a SQL query.
@@ -84,21 +85,26 @@ def lineage(
         sources: A mapping of queries which will be used to continue building lineage.
         dialect: The dialect of input SQL.
         scope: A pre-created scope to use instead.
-        trim_selects: Whether or not to clean up selects by trimming to only relevant columns.
+        trim_selects: Whether to clean up selects by trimming to only relevant columns.
+        copy: Whether to copy the Expression arguments.
         **kwargs: Qualification optimizer kwargs.
 
     Returns:
         A lineage node.
     """
 
-    expression = maybe_parse(sql, dialect=dialect)
+    expression = maybe_parse(sql, copy=copy, dialect=dialect)
     column = normalize_identifiers.normalize_identifiers(column, dialect=dialect).name
 
     if sources:
         expression = exp.expand(
             expression,
-            {k: t.cast(exp.Query, maybe_parse(v, dialect=dialect)) for k, v in sources.items()},
+            {
+                k: t.cast(exp.Query, maybe_parse(v, copy=copy, dialect=dialect))
+                for k, v in sources.items()
+            },
             dialect=dialect,
+            copy=copy,
         )
 
     if not scope:

sqlglot/optimizer/qualify_columns.py

@@ -280,10 +280,12 @@ def _expand_alias_refs(
     alias_to_expression: t.Dict[str, t.Tuple[exp.Expression, int]] = {}
     projections = {s.alias_or_name for s in expression.selects}
     is_bigquery = dialect == "bigquery"
+    replaced = False
 
     def replace_columns(
         node: t.Optional[exp.Expression], resolve_table: bool = False, literal_index: bool = False
     ) -> None:
+        nonlocal replaced
         is_group_by = isinstance(node, exp.Group)
         is_having = isinstance(node, exp.Having)
         if not node or (expand_only_groupby and not is_group_by):
@@ -329,6 +331,7 @@ def _expand_alias_refs(
                     # We should not qualify "id" with "custom_fields" in either clause, since the aggregation shadows the actual table
                     # and we'd get the error: "Column custom_fields contains an aggregation function, which is not allowed in GROUP BY clause"
                     column.replace(exp.to_identifier(column.name))
+                    replaced = True
                     return
 
             if table and (not alias_expr or skip_replace):
@@ -339,7 +342,9 @@ def _expand_alias_refs(
                 ):
                     if literal_index:
                         column.replace(exp.Literal.number(i))
+                        replaced = True
                 else:
+                    replaced = True
                     column = column.replace(exp.paren(alias_expr))
                     simplified = simplify_parens(column, dialect)
                     if simplified is not column:
@@ -376,7 +381,8 @@ def _expand_alias_refs(
         for join in expression.args.get("joins") or []:
             replace_columns(join)
 
-    scope.clear_cache()
+    if replaced:
+        scope.clear_cache()
 
 
 def _expand_group_by(scope: Scope, dialect: DialectType) -> None:

sqlglot/optimizer/simplify.py

@@ -270,7 +270,11 @@ def simplify_connectors(expression, root=True):
                 return exp.false()
             if is_zero(left) or is_zero(right):
                 return exp.false()
-            if is_null(left) or is_null(right):
+            if (
+                (is_null(left) and is_null(right))
+                or (is_null(left) and always_true(right))
+                or (always_true(left) and is_null(right))
+            ):
                 return exp.null()
             if always_true(left) and always_true(right):
                 return exp.true()
@@ -293,9 +297,6 @@ def simplify_connectors(expression, root=True):
             if is_false(right):
                 return left
             return _simplify_comparison(expression, left, right, or_=True)
-        elif isinstance(expression, exp.Xor):
-            if left == right:
-                return exp.false()
 
     if isinstance(expression, exp.Connector):
         return _flat_simplify(expression, _simplify_connectors, root)
@@ -1128,7 +1129,7 @@ def remove_where_true(expression):
 
 def always_true(expression):
     return (isinstance(expression, exp.Boolean) and expression.this) or (
-        isinstance(expression, exp.Literal) and not is_zero(expression)
+        isinstance(expression, exp.Literal) and expression.is_number and not is_zero(expression)
     )
 
 

sqlglot/parser.py

@@ -485,6 +485,7 @@ class Parser(metaclass=_Parser):
     # Tokens that can represent identifiers
     ID_VAR_TOKENS = {
         TokenType.ALL,
+        TokenType.ANALYZE,
         TokenType.ATTACH,
         TokenType.VAR,
         TokenType.ANTI,
@@ -1473,7 +1474,7 @@ class Parser(metaclass=_Parser):
 
     RECURSIVE_CTE_SEARCH_KIND = {"BREADTH", "DEPTH", "CYCLE"}
 
-    MODIFIABLES = (exp.Query, exp.Table, exp.TableFromRows)
+    MODIFIABLES = (exp.Query, exp.Table, exp.TableFromRows, exp.Values)
 
     STRICT_CAST = True
 
@@ -3225,6 +3226,7 @@ class Parser(metaclass=_Parser):
                 this = select
             else:
                 this = exp.select("*").from_(t.cast(exp.From, from_))
+                this = self._parse_query_modifiers(self._parse_set_operations(this))
         else:
             this = (
                 self._parse_table(consume_pipe=True)
@@ -4624,7 +4626,7 @@ class Parser(metaclass=_Parser):
             return None
 
         return self.expression(
-            kind, expressions=[] if with_prefix else self._parse_wrapped_csv(self._parse_column)
+            kind, expressions=[] if with_prefix else self._parse_wrapped_csv(self._parse_bitwise)
         )
 
     def _parse_grouping_sets(self) -> t.Optional[exp.GroupingSets]:
@@ -5814,7 +5816,7 @@ class Parser(metaclass=_Parser):
             this = self.expression(exp.Tuple)
         elif isinstance(this, exp.UNWRAPPED_QUERIES):
             this = self._parse_subquery(this=this, parse_alias=False)
-        elif isinstance(this, exp.Subquery):
+        elif isinstance(this, (exp.Subquery, exp.Values)):
             this = self._parse_subquery(
                 this=self._parse_query_modifiers(self._parse_set_operations(this)),
                 parse_alias=False,

{sqlglot-27.27.0.dist-info → sqlglot-27.28.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.27.0
+Version: 27.28.1
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglot-27.27.0.dist-info → sqlglot-27.28.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=DcL6qrG2tT7X1MpfROtPMQ08iOdQQhq3jUOUDiSxmm0,708
+sqlglot/_version.py,sha256=a2s3xivaD0dEK5-MT3OUAmpTCsjQgqde6-5KQyvtpi8,708
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=uon9D-UuY81594xYDRkxsCa5vUsLdzJhdNmxDEnMOwc,261799
-sqlglot/generator.py,sha256=aXMzVK4vDjlUQg8i55BtOEgIfGIIa2C4An7NAY-TVQ8,227272
+sqlglot/expressions.py,sha256=IzTuOpj16YU8hqkpa82JSfhcQ_05DR8ER9agQYexFT8,262590
+sqlglot/generator.py,sha256=R6AmMoZAOQZS5r1odOcMbulJHNGArSCEgFgE48AtaAo,227334
 sqlglot/helper.py,sha256=OOt5_Mbmnl4Uy6WO6v7DR1iLPcb3v6ITybpq6usf3jw,14471
 sqlglot/jsonpath.py,sha256=SQgaxzaEYBN7At9dkTK4N1Spk6xHxvHL6QtCIP6iM30,7905
-sqlglot/lineage.py,sha256=Qj5ykuDNcATppb9vOjoIKBqRVLbu3OMPiZk9f3iyv40,15312
-sqlglot/parser.py,sha256=fiY6bFbbU8fR4fu4oXcQwZWptTvRD30unXmDCZzs7DE,338623
+sqlglot/lineage.py,sha256=f3yT6sZzY2Plbo49Il8pfmGWuzRgKpSiORaEO4wUXsI,15475
+sqlglot/parser.py,sha256=RwvK9nX5vVU2nz8cFTBSvJ56kap8JzJ7aX7zqupfls4,338762
 sqlglot/planner.py,sha256=ql7Li-bWJRcyXzNaZy_n6bQ6B2ZfunEIB8Ztv2xaxq4,14634
 sqlglot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlglot/schema.py,sha256=13H2qKQs27EKdTpDLOvcNnSTDAUbYNKjWtJs4aQCSOA,20509
@@ -20,21 +20,21 @@ sqlglot/transforms.py,sha256=14RbNbPBL3O4vOQPEbQlBTizK8L-Y85Lj47iguW8ucc,40165
 sqlglot/trie.py,sha256=v27uXMrHfqrXlJ6GmeTSMovsB_3o0ctnlKhdNt7W6fI,2245
 sqlglot/dialects/__init__.py,sha256=g3HRtyb32r3LooiHKTzuUNB0_rBO_RauuOegp42gB48,3811
 sqlglot/dialects/athena.py,sha256=ofArmayYLev4qZQ15GM8mevG04qqR5WGFb2ZcuYm6x4,10966
-sqlglot/dialects/bigquery.py,sha256=l_t70png3A83zEDWUBBsCbiM40HfKIP03Wuq3Zt9CUI,72889
-sqlglot/dialects/clickhouse.py,sha256=CTmBJRGVPm4EEy4mhz4nLUfPcqyQWvkyBjWn6pxAVfo,58646
+sqlglot/dialects/bigquery.py,sha256=7RCx2S9NBBCREE6crIa_zHMHtf4QoVRxe2KjJf5FvZE,68631
+sqlglot/dialects/clickhouse.py,sha256=bV9wlcaKC020up7WYz2Me0eti_hYxHq4GzLbAdbyOYY,58750
 sqlglot/dialects/databricks.py,sha256=H4QTq7gg6tJylKc_YWsGp6049KydoI_wlQUHM7iCJtI,4753
 sqlglot/dialects/dialect.py,sha256=2ReSGrvsJvZF0SnpZp-NFkcHqaiEPsRQEK4IvAGLqCk,74022
 sqlglot/dialects/doris.py,sha256=CFnF955Oav3IjZWA80ickOI8tPpCjxk7BN5R4Z6pA1U,25263
 sqlglot/dialects/dremio.py,sha256=nOMxu_4xVKSOmMGNSwdxXSPc243cNbbpb-xXzYdgdeg,8460
 sqlglot/dialects/drill.py,sha256=FOh7_KjPx_77pv0DiHKZog0CcmzqeF9_PEmGnJ1ESSM,5825
 sqlglot/dialects/druid.py,sha256=kh3snZtneehNOWqs3XcPjsrhNaRbkCQ8E4hHbWJ1fHM,690
-sqlglot/dialects/duckdb.py,sha256=aOQ4gVhWIgC5mnoO-e-ibNvmpZfS3_S0_8FZye-j3aA,55157
+sqlglot/dialects/duckdb.py,sha256=Hg-j3_AXJQ9WgrDQGT0WDR31N7Yag2aDK3wtuG3wf44,55825
 sqlglot/dialects/dune.py,sha256=gALut-fFfN2qMsr8LvZ1NQK3F3W9z2f4PwMvTMXVVVg,375
 sqlglot/dialects/exasol.py,sha256=ay3g_VyT5WvHTgNyJuCQu0nBt4bpllLZ9IdMBizEgYM,15761
 sqlglot/dialects/fabric.py,sha256=BdkvzM8s-m5DIdBwdjEYskp32ub7aHCAex_xlhQn92I,10222
 sqlglot/dialects/hive.py,sha256=Uw-7Y1LnYOdcv71jCIZXhMvJAWwU5AVcFlIuM-YArnY,34530
 sqlglot/dialects/materialize.py,sha256=LD2q1kTRrCwkIu1BfoBvnjTGbupDtoQ8JQMDCIYAXHg,3533
-sqlglot/dialects/mysql.py,sha256=xxVAR-pXMljYCUioavP3nROtOqKmK4kfdp4WWXX7X9g,50049
+sqlglot/dialects/mysql.py,sha256=nDwO8xERj0FD33qZMZcesEot6hbaifYQCnCUEpo5T0w,50043
 sqlglot/dialects/oracle.py,sha256=qB6Ga0Si2-TpVNqU_2COvWESIUYNL32rYk_BC9aiujE,15898
 sqlglot/dialects/postgres.py,sha256=DBnVQKXs8ZEapDB_fcM9k73dZO01byOWmbcReAIPwAw,34851
 sqlglot/dialects/presto.py,sha256=5C6I_aDC-9CDrLfY97EFsUWymaS3B7aW_-h-mHleWIQ,33339
@@ -42,16 +42,16 @@ sqlglot/dialects/prql.py,sha256=fwN-SPEGx-drwf1K0U2MByN-PkW3C_rOgQ3xeJeychg,7908
 sqlglot/dialects/redshift.py,sha256=FIwtP3yEg-way9pa32kxCJc6IaFkHVIvgYKZA-Ilmi0,15919
 sqlglot/dialects/risingwave.py,sha256=Wd-I_Hbwl-6Rgf_NM0I_axliInY418k2kaAWRCmaqyE,3791
 sqlglot/dialects/singlestore.py,sha256=0QqNYOucNklPQuyeGcsisLI97qPGx_RfWKOFarJz2qw,61711
-sqlglot/dialects/snowflake.py,sha256=Ll13pf9n_P5b5ied2gDaci_g-dqoyoq9Po7T2hEKzZg,82277
+sqlglot/dialects/snowflake.py,sha256=Mag5lU0Rx4ffXkIMrcwgw3fh3HrXaKHOunRZ9x4dkU0,84070
 sqlglot/dialects/solr.py,sha256=pydnl4ml-3M1Fc4ALm6cMVO9h-5EtqZxPZH_91Nz1Ss,617
-sqlglot/dialects/spark.py,sha256=mt3Twh0_EJelYy_7HLinDEQ1Chj2EYMjeLCPLRzAJXY,10113
+sqlglot/dialects/spark.py,sha256=j83lEzkAWbw8LTkk1vxXrYA3d5pmcg8Ze8Xws001g7s,10450
 sqlglot/dialects/spark2.py,sha256=s4RTOGunYT1_HJt4KbhBWK_eOgmtzlpBCQCl60KEPAQ,15621
 sqlglot/dialects/sqlite.py,sha256=FuEDDyKZeeWVblknhFSMX7dNoS-ci5ktXpSXZeBK5xA,13592
-sqlglot/dialects/starrocks.py,sha256=-NWQa2gJbiMMfLauX-Jy9ciJ5DUzUOk2QkPbhglz5W4,11446
+sqlglot/dialects/starrocks.py,sha256=iTnVIKwjaInc_iOs21BFf7-5HEhjVodXBMmIOhMwVvo,11539
 sqlglot/dialects/tableau.py,sha256=oIawDzUITxGCWaEMB8OaNMPWhbC3U-2y09pYPm4eazc,2190
 sqlglot/dialects/teradata.py,sha256=7LxCcRwP0Idd_OnCzA57NCdheVjHcKC2aFAKG5N49IU,18202
 sqlglot/dialects/trino.py,sha256=Z7prRhCxIBh0KCxIQpWmVOIGHCJM9Xl5oRlqySxln4Y,4350
-sqlglot/dialects/tsql.py,sha256=oRyxKLpUzdb2dmoWtTkxrM1my2uEJGoxR89l_IFpzww,54948
+sqlglot/dialects/tsql.py,sha256=P3G2P6UY77x4xakwCoppO4MD-GZIaxsqu8RhMotNdn4,55035
 sqlglot/executor/__init__.py,sha256=FslewzYQtQdDNg_0Ju2UaiP4vo4IMUgkfkmFsYUhcN0,2958
 sqlglot/executor/context.py,sha256=WJHJdYQCOeVXwLw0uSSrWSc25eBMn5Ix108RCvdsKRQ,3386
 sqlglot/executor/env.py,sha256=tQhU5PpTBMcxgZIFddFqxWMNPtHN0vOOz72voncY3KY,8276
@@ -72,13 +72,13 @@ sqlglot/optimizer/optimizer.py,sha256=vXEXDWHvbO-vJmSI7UqJuydM2WrD1xko7rETq2EtVJ
 sqlglot/optimizer/pushdown_predicates.py,sha256=HGjs3Z4V3-X2d1VTfWhyByY3aL5SmKnVvt3aDXiiBM0,8414
 sqlglot/optimizer/pushdown_projections.py,sha256=7NoK5NAUVYVhs0YnYyo6WuXfaO-BShSwS6lA8Y-ATQ4,6668
 sqlglot/optimizer/qualify.py,sha256=oAPfwub7dEkrlCrsptcJWpLya4BgKhN6M5SwIs_86LY,4002
-sqlglot/optimizer/qualify_columns.py,sha256=JPVASnK4X0HOGtr6fEhUsd-94yFiJdCSO-H6zx1n4UA,45294
+sqlglot/optimizer/qualify_columns.py,sha256=yTEZ4_GBt0ml3g0xQNGu759m_gR3meF2geKEENCP1mc,45474
 sqlglot/optimizer/qualify_tables.py,sha256=asv18k_PXAett6xhCyjCBH4EycZk4WYSnNFLqoFfVQw,6687
 sqlglot/optimizer/scope.py,sha256=UOTrbwqcTc5iRQf0WStgYWXpE24w6riZy-tJYA18yTw,31229
-sqlglot/optimizer/simplify.py,sha256=27IYsqbz1kyMlURSfRkm_ADSQJg-4805AOMFOjKKytU,51049
+sqlglot/optimizer/simplify.py,sha256=TzbIh0XK0M92ZnCLtI4GI6UUX2eXqB-wQHizqGmX84E,51114
 sqlglot/optimizer/unnest_subqueries.py,sha256=zt5UFYGAfDBTDPbJCpzm4HbXDDia5GlyKZd3SdBXYEk,10906
-sqlglot-27.27.0.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
-sqlglot-27.27.0.dist-info/METADATA,sha256=nnaX1EICQuz87cROcK2_MHDB99y9dhtT--92vbUnrqQ,20825
-sqlglot-27.27.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-27.27.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-27.27.0.dist-info/RECORD,,
+sqlglot-27.28.1.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
+sqlglot-27.28.1.dist-info/METADATA,sha256=e2Z2QQhb-a4xkhBzGcaTVSd2CUIynP-OUv-UcazYFeg,20825
+sqlglot-27.28.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-27.28.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-27.28.1.dist-info/RECORD,,