sqlglot 27.5.1__tar.gz → 27.6.0__tar.gz

{sqlglot-27.5.1 → sqlglot-27.6.0}/CHANGELOG.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+## [v27.5.1] - 2025-07-30
+### :bug: Bug Fixes
+- [`caf71d6`](https://github.com/tobymao/sqlglot/commit/caf71d687c0048d2346fddaee58b519e4f2e7945) - `between` builder should not set `symmetric` by default *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+
 ## [v27.5.0] - 2025-07-30
 ### :boom: BREAKING CHANGES
 - due to [`002286e`](https://github.com/tobymao/sqlglot/commit/002286ee05a608e303a2238a9a74ab963709b5da) - remove AM/PM entries from postgres, oracle `TIME_MAPPING` *(PR [#5491](https://github.com/tobymao/sqlglot/pull/5491) by [@georgesittas](https://github.com/georgesittas))*:
@@ -6373,3 +6378,4 @@ Changelog
 [v27.4.0]: https://github.com/tobymao/sqlglot/compare/v27.3.1...v27.4.0
 [v27.4.1]: https://github.com/tobymao/sqlglot/compare/v27.4.0...v27.4.1
 [v27.5.0]: https://github.com/tobymao/sqlglot/compare/v27.4.1...v27.5.0
+[v27.5.1]: https://github.com/tobymao/sqlglot/compare/v27.5.0...v27.5.1

{sqlglot-27.5.1 → sqlglot-27.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.5.1
+Version: 27.6.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 Project-URL: Homepage, https://sqlglot.com/

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '27.5.1'
-__version_tuple__ = version_tuple = (27, 5, 1)
+__version__ = version = '27.6.0'
+__version_tuple__ = version_tuple = (27, 6, 0)

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/dialects/bigquery.py

@@ -434,7 +434,9 @@ class BigQuery(Dialect):
 
     # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
     # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
-    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE"}
+    # https://cloud.google.com/bigquery/docs/querying-wildcard-tables#scanning_a_range_of_tables_using_table_suffix
+    # https://cloud.google.com/bigquery/docs/query-cloud-storage-data#query_the_file_name_pseudo-column
+    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE", "_TABLE_SUFFIX", "_FILE_NAME"}
 
     # All set operations require either a DISTINCT or ALL specifier
     SET_OP_DISTINCT_BY_DEFAULT = dict.fromkeys((exp.Except, exp.Intersect, exp.Union), None)

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/dialects/exasol.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import typing as t
 
 from sqlglot import exp, generator, parser, tokens
-from sqlglot.dialects.clickhouse import timestamptrunc_sql
 from sqlglot.dialects.dialect import (
     Dialect,
     binary_from_function,
@@ -12,6 +11,8 @@ from sqlglot.dialects.dialect import (
     strposition_sql,
     timestrtotime_sql,
     unit_to_str,
+    timestamptrunc_sql,
+    build_date_delta,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
@@ -46,6 +47,18 @@ def _build_trunc(args: t.List[exp.Expression], dialect: DialectType) -> exp.Expr
     return exp.Anonymous(this="TRUNC", expressions=args)
 
 
+# https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/zeroifnull.htm
+def _build_zeroifnull(args: t.List) -> exp.If:
+    cond = exp.Is(this=seq_get(args, 0), expression=exp.Null())
+    return exp.If(this=cond, true=exp.Literal.number(0), false=seq_get(args, 0))
+
+
+# https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/nullifzero.htm
+def _build_nullifzero(args: t.List) -> exp.If:
+    cond = exp.EQ(this=seq_get(args, 0), expression=exp.Literal.number(0))
+    return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0))
+
+
 class Exasol(Dialect):
     TIME_MAPPING = {
         "yyyy": "%Y",
@@ -79,11 +92,28 @@ class Exasol(Dialect):
         KEYWORDS = {
             **tokens.Tokenizer.KEYWORDS,
             "USER": TokenType.CURRENT_USER,
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/if.htm
+            "ENDIF": TokenType.END,
+            "LONG VARCHAR": TokenType.TEXT,
         }
 
     class Parser(parser.Parser):
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_days.htm
+            "ADD_DAYS": build_date_delta(exp.DateAdd, default_unit="DAY"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_years.htm
+            "ADD_YEARS": build_date_delta(exp.DateAdd, default_unit="YEAR"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_months.htm
+            "ADD_MONTHS": build_date_delta(exp.DateAdd, default_unit="MONTH"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_weeks.htm
+            "ADD_WEEKS": build_date_delta(exp.DateAdd, default_unit="WEEK"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_hour.htm
+            "ADD_HOURS": build_date_delta(exp.DateAdd, default_unit="HOUR"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_minutes.htm
+            "ADD_MINUTES": build_date_delta(exp.DateAdd, default_unit="MINUTE"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/add_seconds.htm
+            "ADD_SECONDS": build_date_delta(exp.DateAdd, default_unit="SECOND"),
             "BIT_AND": binary_from_function(exp.BitwiseAnd),
             "BIT_OR": binary_from_function(exp.BitwiseOr),
             "BIT_XOR": binary_from_function(exp.BitwiseXor),
@@ -127,6 +157,8 @@ class Exasol(Dialect):
                 timestamp=seq_get(args, 0),
                 options=seq_get(args, 3),
             ),
+            "NULLIFZERO": _build_nullifzero,
+            "ZEROIFNULL": _build_zeroifnull,
         }
         CONSTRAINT_PARSERS = {
             **parser.Parser.CONSTRAINT_PARSERS,
@@ -146,7 +178,8 @@ class Exasol(Dialect):
             exp.DataType.Type.MEDIUMTEXT: "VARCHAR",
             exp.DataType.Type.TINYBLOB: "VARCHAR",
             exp.DataType.Type.TINYTEXT: "VARCHAR",
-            exp.DataType.Type.TEXT: "VARCHAR",
+            # https://docs.exasol.com/db/latest/sql_references/data_types/datatypealiases.htm
+            exp.DataType.Type.TEXT: "LONG VARCHAR",
             exp.DataType.Type.VARBINARY: "VARCHAR",
         }
 
@@ -163,6 +196,16 @@ class Exasol(Dialect):
             exp.DataType.Type.DATETIME: "TIMESTAMP",
         }
 
+        DATE_ADD_FUNCTION_BY_UNIT = {
+            "DAY": "ADD_DAYS",
+            "WEEK": "ADD_WEEKS",
+            "MONTH": "ADD_MONTHS",
+            "YEAR": "ADD_YEARS",
+            "HOUR": "ADD_HOURS",
+            "MINUTE": "ADD_MINUTES",
+            "SECOND": "ADD_SECONDS",
+        }
+
         def datatype_sql(self, expression: exp.DataType) -> str:
             # Exasol supports a fixed default precision of 3 for TIMESTAMP WITH LOCAL TIME ZONE
             # and does not allow specifying a different custom precision
@@ -249,3 +292,18 @@ class Exasol(Dialect):
             options = expression.args.get("options")
 
             return self.func("CONVERT_TZ", datetime, from_tz, to_tz, options)
+
+        def if_sql(self, expression: exp.If) -> str:
+            this = self.sql(expression, "this")
+            true = self.sql(expression, "true")
+            false = self.sql(expression, "false")
+            return f"IF {this} THEN {true} ELSE {false} ENDIF"
+
+        def dateadd_sql(self, expression: exp.DateAdd) -> str:
+            unit = expression.text("unit").upper() or "DAY"
+            func_name = self.DATE_ADD_FUNCTION_BY_UNIT.get(unit)
+            if not func_name:
+                self.unsupported(f"'{unit}' is not supported in Exasol.")
+                return self.function_fallback_sql(expression)
+
+            return self.func(func_name, expression.this, expression.expression)

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/dialects/singlestore.py

@@ -4,6 +4,7 @@ import typing as t
 from sqlglot import exp
 from sqlglot.dialects.dialect import build_formatted_time
 from sqlglot.dialects.mysql import MySQL
+from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
 
 
@@ -65,6 +66,21 @@ class SingleStore(MySQL):
             ),
         }
 
+        CAST_COLUMN_OPERATORS = {TokenType.COLON_GT, TokenType.NCOLON_GT}
+
+        COLUMN_OPERATORS = {
+            TokenType.COLON_GT: lambda self, this, to: self.expression(
+                exp.Cast,
+                this=this,
+                to=to,
+            ),
+            TokenType.NCOLON_GT: lambda self, this, to: self.expression(
+                exp.TryCast,
+                this=this,
+                to=to,
+            ),
+        }
+
     class Generator(MySQL.Generator):
         TRANSFORMS = {
             **MySQL.Generator.TRANSFORMS,
@@ -89,6 +105,12 @@ class SingleStore(MySQL):
                     inverse_time_trie=MySQL.INVERSE_TIME_TRIE,
                 ),
             ),
+            exp.Cast: unsupported_args("format", "action", "default")(
+                lambda self, e: f"{self.sql(e, 'this')} :> {self.sql(e, 'to')}"
+            ),
+            exp.TryCast: unsupported_args("format", "action", "default")(
+                lambda self, e: f"{self.sql(e, 'this')} !:> {self.sql(e, 'to')}"
+            ),
         }
 
         # https://docs.singlestore.com/cloud/reference/sql-reference/restricted-keywords/list-of-restricted-keywords/

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/dialects/snowflake.py

@@ -591,6 +591,7 @@ class Snowflake(Dialect):
                 this=seq_get(args, 0), expression=seq_get(args, 1), max_dist=seq_get(args, 2)
             ),
             "FLATTEN": exp.Explode.from_arg_list,
+            "GET": exp.GetExtract.from_arg_list,
             "GET_PATH": lambda args, dialect: exp.JSONExtract(
                 this=seq_get(args, 0),
                 expression=dialect.to_json_path(seq_get(args, 1)),
@@ -1220,6 +1221,7 @@ class Snowflake(Dialect):
             exp.GenerateSeries: lambda self, e: self.func(
                 "ARRAY_GENERATE_RANGE", e.args["start"], e.args["end"] + 1, e.args.get("step")
             ),
+            exp.GetExtract: rename_func("GET"),
             exp.GroupConcat: lambda self, e: groupconcat_sql(self, e, sep=""),
             exp.If: if_sql(name="IFF", false_value="NULL"),
             exp.JSONExtractArray: _json_extract_value_array_sql,

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/expressions.py

@@ -6185,6 +6185,11 @@ class GenerateTimestampArray(Func):
     arg_types = {"start": True, "end": True, "step": True}
 
 
+# https://docs.snowflake.com/en/sql-reference/functions/get
+class GetExtract(Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class Greatest(Func):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/generator.py

@@ -5113,3 +5113,17 @@ class Generator(metaclass=_Generator):
         where = self.sql(expression, "where")
         where = self.seg(f"WHERE {where}") if where else ""
         return f"SEMANTIC_VIEW({self.indent(this + metrics + dimensions + where)}{self.seg(')', sep='')}"
+
+    def getextract_sql(self, expression: exp.GetExtract) -> str:
+        this = expression.this
+        expr = expression.expression
+
+        if not this.type or not expression.type:
+            from sqlglot.optimizer.annotate_types import annotate_types
+
+            this = annotate_types(this, dialect=self.dialect)
+
+        if this.is_type(*(exp.DataType.Type.ARRAY, exp.DataType.Type.MAP)):
+            return self.sql(exp.Bracket(this=this, expressions=[expr]))
+
+        return self.sql(exp.JSONExtract(this=this, expression=self.dialect.to_json_path(expr)))

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/optimizer/qualify_columns.py

@@ -972,6 +972,44 @@ class Resolver:
             }
         return self._all_columns
 
+    def get_source_columns_from_set_op(self, expression: exp.Expression) -> t.List[str]:
+        if isinstance(expression, exp.Select):
+            return expression.named_selects
+        if isinstance(expression, exp.Subquery) and isinstance(expression.this, exp.SetOperation):
+            # Different types of SET modifiers can be chained together if they're explicitly grouped by nesting
+            return self.get_source_columns_from_set_op(expression.this)
+        if not isinstance(expression, exp.SetOperation):
+            raise OptimizeError(f"Unknown set operation: {expression}")
+
+        set_op = expression
+
+        # BigQuery specific set operations modifiers, e.g INNER UNION ALL BY NAME
+        on_column_list = set_op.args.get("on")
+
+        if on_column_list:
+            # The resulting columns are the columns in the ON clause:
+            # {INNER | LEFT | FULL} UNION ALL BY NAME ON (col1, col2, ...)
+            columns = [col.name for col in on_column_list]
+        elif set_op.side or set_op.kind:
+            side = set_op.side
+            kind = set_op.kind
+
+            # Visit the children UNIONs (if any) in a post-order traversal
+            left = self.get_source_columns_from_set_op(set_op.left)
+            right = self.get_source_columns_from_set_op(set_op.right)
+
+            # We use dict.fromkeys to deduplicate keys and maintain insertion order
+            if side == "LEFT":
+                columns = left
+            elif side == "FULL":
+                columns = list(dict.fromkeys(left + right))
+            elif kind == "INNER":
+                columns = list(dict.fromkeys(left).keys() & dict.fromkeys(right).keys())
+        else:
+            columns = set_op.named_selects
+
+        return columns
+
     def get_source_columns(self, name: str, only_visible: bool = False) -> t.Sequence[str]:
         """Resolve the source columns for a given source `name`."""
         cache_key = (name, only_visible)
@@ -996,31 +1034,8 @@ class Resolver:
                         for k in source.expression.type.expressions:  # type: ignore
                             columns.append(k.name)
             elif isinstance(source, Scope) and isinstance(source.expression, exp.SetOperation):
-                set_op = source.expression
-
-                # BigQuery specific set operations modifiers, e.g INNER UNION ALL BY NAME
-                on_column_list = set_op.args.get("on")
-
-                if on_column_list:
-                    # The resulting columns are the columns in the ON clause:
-                    # {INNER | LEFT | FULL} UNION ALL BY NAME ON (col1, col2, ...)
-                    columns = [col.name for col in on_column_list]
-                elif set_op.side or set_op.kind:
-                    side = set_op.side
-                    kind = set_op.kind
-
-                    left = set_op.left.named_selects
-                    right = set_op.right.named_selects
-
-                    # We use dict.fromkeys to deduplicate keys and maintain insertion order
-                    if side == "LEFT":
-                        columns = left
-                    elif side == "FULL":
-                        columns = list(dict.fromkeys(left + right))
-                    elif kind == "INNER":
-                        columns = list(dict.fromkeys(left).keys() & dict.fromkeys(right).keys())
-                else:
-                    columns = set_op.named_selects
+                columns = self.get_source_columns_from_set_op(source.expression)
+
             else:
                 select = seq_get(source.expression.selects, 0)
 

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot/parser.py

@@ -792,6 +792,11 @@ class Parser(metaclass=_Parser):
         ),
     }
 
+    CAST_COLUMN_OPERATORS = {
+        TokenType.DOTCOLON,
+        TokenType.DCOLON,
+    }
+
     EXPRESSION_PARSERS = {
         exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
         exp.Column: lambda self: self._parse_column(),
@@ -5621,7 +5626,7 @@ class Parser(metaclass=_Parser):
             op_token = self._prev.token_type
             op = self.COLUMN_OPERATORS.get(op_token)
 
-            if op_token in (TokenType.DCOLON, TokenType.DOTCOLON):
+            if op_token in self.CAST_COLUMN_OPERATORS:
                 field = self._parse_dcolon()
                 if not field:
                     self.raise_error("Expected type")

{sqlglot-27.5.1 → sqlglot-27.6.0}/sqlglot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.5.1
+Version: 27.6.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 Project-URL: Homepage, https://sqlglot.com/

{sqlglot-27.5.1 → sqlglot-27.6.0}/tests/dialects/test_exasol.py

@@ -13,7 +13,10 @@ class TestExasol(Validator):
         self.validate_identity("CAST(x AS MEDIUMTEXT)", "CAST(x AS VARCHAR)")
         self.validate_identity("CAST(x AS TINYBLOB)", "CAST(x AS VARCHAR)")
         self.validate_identity("CAST(x AS TINYTEXT)", "CAST(x AS VARCHAR)")
-        self.validate_identity("CAST(x AS TEXT)", "CAST(x AS VARCHAR)")
+        self.validate_identity("CAST(x AS TEXT)", "CAST(x AS LONG VARCHAR)")
+        self.validate_identity(
+            "SELECT CAST((CAST(202305 AS INT) - 100) AS LONG VARCHAR) AS CAL_YEAR_WEEK_ADJUSTED"
+        )
         self.validate_identity("CAST(x AS VARBINARY)", "CAST(x AS VARCHAR)")
         self.validate_identity("CAST(x AS VARCHAR)", "CAST(x AS VARCHAR)")
         self.validate_identity("CAST(x AS CHAR)", "CAST(x AS CHAR)")
@@ -400,6 +403,32 @@ class TestExasol(Validator):
                 "databricks": "SELECT DATE_TRUNC('MINUTE', CAST('2006-12-31 23:59:59' AS TIMESTAMP)) AS DATE_TRUNC",
             },
         )
+        test_cases = {
+            "ADD_DAYS": ("DAY", "add_days"),
+            "ADD_WEEKS": ("WEEK", "add_weeks"),
+            "ADD_MONTHS": ("MONTH", "add_months"),
+            "ADD_YEARS": ("YEAR", "add_years"),
+            "ADD_HOURS": ("HOUR", "add_hours"),
+            "ADD_MINUTES": ("MINUTE", "add_minutes"),
+            "ADD_SECONDS": ("SECOND", "add_seconds"),
+        }
+
+        for func_name, (unit, alias) in test_cases.items():
+            with self.subTest(f"Testing {func_name}"):
+                write = {
+                    "exasol": f"SELECT {func_name}(CAST('2000-02-28' AS DATE), 1) AS {alias}",
+                    "bigquery": f"SELECT DATE_ADD(CAST('2000-02-28' AS DATE), INTERVAL 1 {unit}) AS {alias}",
+                    "duckdb": f"SELECT CAST('2000-02-28' AS DATE) + INTERVAL 1 {unit} AS {alias}",
+                    "presto": f"SELECT DATE_ADD('{unit}', 1, CAST('2000-02-28' AS DATE)) AS {alias}",
+                    "redshift": f"SELECT DATEADD({unit}, 1, CAST('2000-02-28' AS DATE)) AS {alias}",
+                    "snowflake": f"SELECT DATEADD({unit}, 1, CAST('2000-02-28' AS DATE)) AS {alias}",
+                    "tsql": f"SELECT DATEADD({unit}, 1, CAST('2000-02-28' AS DATE)) AS {alias}",
+                }
+
+                self.validate_all(
+                    f"SELECT {func_name}(DATE '2000-02-28', 1) AS {alias}",
+                    write=write,
+                )
 
     def test_number_functions(self):
         self.validate_identity("SELECT TRUNC(123.456, 2) AS TRUNC")
@@ -509,3 +538,30 @@ class TestExasol(Validator):
                 "trino": "SHA512(x)",
             },
         )
+        self.validate_all(
+            "SELECT NULLIFZERO(1) NIZ1",
+            write={
+                "exasol": "SELECT IF 1 = 0 THEN NULL ELSE 1 ENDIF AS NIZ1",
+                "snowflake": "SELECT IFF(1 = 0, NULL, 1) AS NIZ1",
+                "sqlite": "SELECT IIF(1 = 0, NULL, 1) AS NIZ1",
+                "presto": "SELECT IF(1 = 0, NULL, 1) AS NIZ1",
+                "spark": "SELECT IF(1 = 0, NULL, 1) AS NIZ1",
+                "hive": "SELECT IF(1 = 0, NULL, 1) AS NIZ1",
+                "duckdb": "SELECT CASE WHEN 1 = 0 THEN NULL ELSE 1 END AS NIZ1",
+            },
+        )
+        self.validate_all(
+            "SELECT ZEROIFNULL(NULL) NIZ1",
+            write={
+                "exasol": "SELECT IF NULL IS NULL THEN 0 ELSE NULL ENDIF AS NIZ1",
+                "snowflake": "SELECT IFF(NULL IS NULL, 0, NULL) AS NIZ1",
+                "sqlite": "SELECT IIF(NULL IS NULL, 0, NULL) AS NIZ1",
+                "presto": "SELECT IF(NULL IS NULL, 0, NULL) AS NIZ1",
+                "spark": "SELECT IF(NULL IS NULL, 0, NULL) AS NIZ1",
+                "hive": "SELECT IF(NULL IS NULL, 0, NULL) AS NIZ1",
+                "duckdb": "SELECT CASE WHEN NULL IS NULL THEN 0 ELSE NULL END AS NIZ1",
+            },
+        )
+        self.validate_identity(
+            "SELECT name, age, IF age < 18 THEN 'underaged' ELSE 'adult' ENDIF AS LEGALITY FROM persons"
+        )

{sqlglot-27.5.1 → sqlglot-27.6.0}/tests/dialects/test_singlestore.py

@@ -19,7 +19,6 @@ class TestSingleStore(Validator):
 
         self.validate_identity("SELECT 1")
         self.validate_identity("SELECT * FROM `users` ORDER BY ALL")
-        self.validate_identity("SELECT CAST(x AS GEOGRAPHYPOINT)")
 
     def test_byte_strings(self):
         self.validate_identity("SELECT e'text'")
@@ -47,5 +46,30 @@ class TestSingleStore(Validator):
         )
         self.validate_identity(
             "SELECT TIME_FORMAT('12:05:47', '%s, %i, %h')",
-            "SELECT DATE_FORMAT(CAST('12:05:47' AS TIME(6)), '%s, %i, %h')",
+            "SELECT DATE_FORMAT('12:05:47' :> TIME(6), '%s, %i, %h')",
         )
+
+    def test_cast(self):
+        self.validate_all(
+            "SELECT 1 :> INT",
+            read={
+                "": "SELECT CAST(1 AS INT)",
+            },
+            write={
+                "singlestore": "SELECT 1 :> INT",
+                "": "SELECT CAST(1 AS INT)",
+            },
+        )
+        self.validate_all(
+            "SELECT 1 !:> INT",
+            read={
+                "": "SELECT TRY_CAST(1 AS INT)",
+            },
+            write={
+                "singlestore": "SELECT 1 !:> INT",
+                "": "SELECT TRY_CAST(1 AS INT)",
+            },
+        )
+        self.validate_identity("SELECT '{\"a\" : 1}' :> JSON")
+        self.validate_identity("SELECT NOW() !:> TIMESTAMP(6)")
+        self.validate_identity("SELECT x :> GEOGRAPHYPOINT")

{sqlglot-27.5.1 → sqlglot-27.6.0}/tests/dialects/test_snowflake.py

@@ -2746,7 +2746,7 @@ SINGLE = TRUE""",
 
     def test_get_from_stage(self):
         self.validate_identity('GET @"my_DB"."schEMA1"."MYstage" \'file:///dir/tmp.csv\'')
-        self.validate_identity("GET @s1/test 'file:///dir/tmp.csv'")
+        self.validate_identity("GET @s1/test 'file:///dir/tmp.csv'").assert_is(exp.Get)
 
         # GET with file path and stage ref containing spaces (wrapped in single quotes)
         ast = parse_one("GET '@s1/my folder' 'file://my file.txt'", read="snowflake")
@@ -2950,3 +2950,30 @@ FROM SEMANTIC_VIEW(
 )""",
             pretty=True,
         )
+
+    def test_get_extract(self):
+        self.validate_all(
+            "SELECT GET([4, 5, 6], 1)",
+            write={
+                "snowflake": "SELECT GET([4, 5, 6], 1)",
+                "duckdb": "SELECT [4, 5, 6][2]",
+            },
+        )
+
+        self.validate_all(
+            "SELECT GET(col::MAP(INTEGER, VARCHAR), 1)",
+            write={
+                "snowflake": "SELECT GET(CAST(col AS MAP(INT, VARCHAR)), 1)",
+                "duckdb": "SELECT CAST(col AS MAP(INT, TEXT))[1]",
+            },
+        )
+
+        self.validate_all(
+            "SELECT GET(v, 'field')",
+            write={
+                "snowflake": "SELECT GET(v, 'field')",
+                "duckdb": "SELECT v -> '$.field'",
+            },
+        )
+
+        self.validate_identity("GET(foo, bar)").assert_is(exp.GetExtract)

{sqlglot-27.5.1 → sqlglot-27.6.0}/tests/fixtures/optimizer/qualify_columns.sql

@@ -389,6 +389,25 @@ SELECT _q_0.foo AS foo, _q_0.qux AS qux FROM ((SELECT 1 AS foo, 2 AS bar LEFT UN
 SELECT * FROM (((SELECT 1 AS foo, 2 AS bar LEFT UNION ALL BY NAME SELECT 3 AS bar, 4 AS baz) FULL UNION ALL BY NAME ON (foo, qux) SELECT 3 AS qux, 4 AS bar) INNER UNION ALL BY NAME ON (foo) SELECT 6 AS foo);
 SELECT _q_0.foo AS foo FROM (((SELECT 1 AS foo, 2 AS bar LEFT UNION ALL BY NAME SELECT 3 AS bar, 4 AS baz) FULL UNION ALL BY NAME ON (foo, qux) SELECT 3 AS qux, 4 AS bar) INNER UNION ALL BY NAME ON (foo) SELECT 6 AS foo) AS _q_0;
 
+# Title: Nested set operations with modifiers
+# dialect: bigquery
+# execute: false
+WITH t1 AS (SELECT 1 AS a, 2 AS b), t2 AS (SELECT 2 AS b, 3 AS c), t3 AS (SELECT 2 AS c, 3 AS d), t4 AS (SELECT 2 AS e, 3 AS f) SELECT * FROM ((SELECT * FROM t1 FULL OUTER UNION ALL BY NAME (SELECT * FROM t2 FULL OUTER UNION ALL BY NAME (SELECT * FROM t3 FULL OUTER UNION ALL BY NAME SELECT * FROM t4))));
+WITH t1 AS (SELECT 1 AS a, 2 AS b), t2 AS (SELECT 2 AS b, 3 AS c), t3 AS (SELECT 2 AS c, 3 AS d), t4 AS (SELECT 2 AS e, 3 AS f) SELECT _q_0.a AS a, _q_0.b AS b, _q_0.c AS c, _q_0.d AS d, _q_0.e AS e, _q_0.f AS f FROM ((SELECT t1.a AS a, t1.b AS b FROM t1 AS t1 FULL OUTER UNION ALL BY NAME (SELECT t2.b AS b, t2.c AS c FROM t2 AS t2 FULL OUTER UNION ALL BY NAME (SELECT t3.c AS c, t3.d AS d FROM t3 AS t3 FULL OUTER UNION ALL BY NAME SELECT t4.e AS e, t4.f AS f FROM t4 AS t4))) AS _q_0);
+
+
+# Title: Nested set operations with different modifiers (FULL + INNER)
+# dialect: bigquery
+# execute: false
+WITH t1 AS (SELECT 1 AS a, 2 AS b), t2 AS (SELECT 2 AS b, 3 AS c), t3 AS (SELECT 2 AS c, 3 AS d), t4 AS (SELECT 2 AS e, 3 AS f) SELECT * FROM ((SELECT * FROM t1 FULL OUTER UNION ALL BY NAME (SELECT * FROM t2 INNER UNION ALL BY NAME (SELECT * FROM t3 FULL OUTER UNION ALL BY NAME SELECT * FROM t4))));
+WITH t1 AS (SELECT 1 AS a, 2 AS b), t2 AS (SELECT 2 AS b, 3 AS c), t3 AS (SELECT 2 AS c, 3 AS d), t4 AS (SELECT 2 AS e, 3 AS f) SELECT _q_0.a AS a, _q_0.b AS b, _q_0.c AS c FROM ((SELECT t1.a AS a, t1.b AS b FROM t1 AS t1 FULL OUTER UNION ALL BY NAME (SELECT t2.b AS b, t2.c AS c FROM t2 AS t2 INNER UNION ALL BY NAME (SELECT t3.c AS c, t3.d AS d FROM t3 AS t3 FULL OUTER UNION ALL BY NAME SELECT t4.e AS e, t4.f AS f FROM t4 AS t4))) AS _q_0);
+
+# Title: Nested set operations with different modifiers (FULL + LEFT)
+# dialect: bigquery
+# execute: false
+WITH t1 AS (SELECT 1 AS a, 2 AS b, 3 AS c, 4 AS d), t2 AS (SELECT 2 AS b, 3 AS c), t3 AS (SELECT 2 AS c, 3 AS d), t4 AS (SELECT 2 AS d, 3 AS e) SELECT * FROM ((SELECT * FROM t1 FULL OUTER UNION ALL BY NAME (SELECT * FROM t2 FULL UNION ALL BY NAME (SELECT * FROM t3 LEFT UNION ALL BY NAME SELECT * FROM t4))));
+WITH t1 AS (SELECT 1 AS a, 2 AS b, 3 AS c, 4 AS d), t2 AS (SELECT 2 AS b, 3 AS c), t3 AS (SELECT 2 AS c, 3 AS d), t4 AS (SELECT 2 AS d, 3 AS e) SELECT _q_0.a AS a, _q_0.b AS b, _q_0.c AS c, _q_0.d AS d FROM ((SELECT t1.a AS a, t1.b AS b, t1.c AS c, t1.d AS d FROM t1 AS t1 FULL OUTER UNION ALL BY NAME (SELECT t2.b AS b, t2.c AS c FROM t2 AS t2 FULL UNION ALL BY NAME (SELECT t3.c AS c, t3.d AS d FROM t3 AS t3 LEFT UNION ALL BY NAME SELECT t4.d AS d, t4.e AS e FROM t4 AS t4))) AS _q_0);
+
 --------------------------------------
 -- Subqueries
 --------------------------------------