sqlglotc 30.13.0__tar.gz → 30.14.0__tar.gz

{sqlglotc-30.13.0/sqlglotc.egg-info → sqlglotc-30.14.0}/PKG-INFO

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

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/expressions/array.py

@@ -90,6 +90,10 @@ class ArraySort(Expression, Func):
     arg_types = {"this": True, "expression": False}
 
 
+class Shuffle(Expression, Func):
+    pass
+
+
 class SortArray(Expression, Func):
     arg_types = {"this": True, "asc": False, "nulls_first": False}
 

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/expressions/core.py

@@ -2184,7 +2184,7 @@ class IntDiv(Expression, Binary):
 
 
 class Is(Expression, Binary, Predicate):
-    pass
+    arg_types = {"this": True, "expression": True, "negate": False}
 
 
 class Like(Expression, Binary, Predicate):

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/expressions/math.py

@@ -164,6 +164,10 @@ class Log(Expression, Func):
     arg_types = {"this": True, "expression": False}
 
 
+class Nanvl(Expression, Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class Pi(Expression, Func):
     arg_types = {}
 

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/generator.py

@@ -4440,11 +4440,11 @@ class Generator:
         return self.binary(expression, ">=")
 
     def is_sql(self, expression: exp.Is) -> str:
+        negate = expression.args.get("negate")
         if not self.IS_BOOL_ALLOWED and isinstance(expression.expression, exp.Boolean):
-            return self.sql(
-                expression.this if expression.expression.this else exp.not_(expression.this)
-            )
-        return self.binary(expression, "IS")
+            positive = bool(expression.expression.this) != bool(negate)
+            return self.sql(expression.this if positive else exp.not_(expression.this))
+        return self.binary(expression, "IS NOT" if negate else "IS")
 
     def _like_sql(
         self,
@@ -5674,7 +5674,11 @@ class Generator:
 
     def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
         array_agg = self.function_fallback_sql(expression)
-        return self._add_arrayagg_null_filter(array_agg, expression, expression.this)
+        column_expr = expression.this
+        if isinstance(column_expr, exp.Order):
+            column_expr = column_expr.this
+
+        return self._add_arrayagg_null_filter(array_agg, expression, column_expr)
 
     def slice_sql(self, expression: exp.Slice) -> str:
         step = self.sql(expression, "step")

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/generators/duckdb.py

@@ -2204,6 +2204,25 @@ class DuckDBGenerator(generator.Generator):
         """
     )
 
+    # BigQuery's `x IN UNNEST(arr)` NULL semantics:
+    #   NULL IN UNNEST([1, 2])  -> NULL
+    #   3 IN UNNEST([1, NULL])  -> NULL
+    #   3 IN UNNEST([1, 2])     -> FALSE
+    #   1 IN UNNEST(NULL)       -> FALSE (not NULL)
+    #   1 IN UNNEST([])         -> FALSE
+    # The default `IN (SELECT UNNEST(...))` rewrite creates a correlated subquery
+    # that DuckDB rejects inside non-inner joins, so a CASE expression is used instead.
+    IN_UNNEST_TEMPLATE: exp.Expr = exp.maybe_parse(
+        """
+        CASE
+            WHEN :arr IS NULL OR ARRAY_LENGTH(:arr) = 0 THEN FALSE
+            WHEN ARRAY_CONTAINS(:arr, :value) THEN TRUE
+            WHEN :value IS NULL OR ARRAY_LENGTH(:arr) <> LIST_COUNT(:arr) THEN NULL
+            ELSE FALSE
+        END
+        """
+    )
+
     STRTOK_TO_ARRAY_TEMPLATE: exp.Expr = exp.maybe_parse(
         """
         CASE WHEN :delimiter IS NULL THEN NULL
@@ -3098,6 +3117,16 @@ class DuckDBGenerator(generator.Generator):
 
         return super().tablesample_sql(expression, tablesample_keyword=tablesample_keyword)
 
+    def in_sql(self, expression: exp.In) -> str:
+        unnest = expression.args.get("unnest")
+        if unnest:
+            return self.sql(
+                exp.replace_placeholders(
+                    self.IN_UNNEST_TEMPLATE, arr=unnest.expressions[0], value=expression.this
+                )
+            )
+        return super().in_sql(expression)
+
     def join_sql(self, expression: exp.Join) -> str:
         if (
             not expression.args.get("using")
@@ -3460,6 +3489,23 @@ class DuckDBGenerator(generator.Generator):
             )
         )
 
+    def arrayconcatagg_sql(self, expression: exp.ArrayConcatAgg) -> str:
+        this = expression.this
+
+        if isinstance(this, exp.Limit):
+            self.unsupported("LIMIT in ARRAY_CONCAT_AGG cannot be transpiled to DuckDB")
+            this = this.this
+
+        inner = this.this if isinstance(this, exp.Order) else this
+
+        return self.func(
+            "FLATTEN",
+            exp.Filter(
+                this=exp.ArrayAgg(this=this),
+                expression=exp.Where(this=inner.copy().is_(exp.null()).not_()),
+            ),
+        )
+
     def arrayunionagg_sql(self, expression: exp.ArrayUnionAgg) -> str:
         self.unsupported("ARRAY_UNION_AGG is not supported in DuckDB")
         return self.function_fallback_sql(expression)
@@ -3917,6 +3963,12 @@ class DuckDBGenerator(generator.Generator):
 
         return super().unnest_sql(expression)
 
+    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
+        if isinstance(expression.this, exp.Limit):
+            self.unsupported("LIMIT inside ARRAY_AGG is not supported in DuckDB")
+
+        return super().arrayagg_sql(expression)
+
     def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
         this = expression.this
 
@@ -3925,6 +3977,14 @@ class DuckDBGenerator(generator.Generator):
             # window functions that accept it e.g. FIRST_VALUE(... IGNORE NULLS) OVER (...)
             return super().ignorenulls_sql(expression)
 
+        # For ARRAY_AGG(expr IGNORE NULLS ...), convert IGNORE NULLS to a
+        # FILTER(WHERE expr IS NOT NULL) clause by setting nulls_excluded on
+        # the ArrayAgg.  The existing _add_arrayagg_null_filter method will
+        # emit the FILTER clause during arrayagg_sql / withingroup_sql.
+        if isinstance(this, exp.ArrayAgg):
+            this.set("nulls_excluded", True)
+            return self.sql(this)
+
         if isinstance(this, exp.First):
             this = exp.AnyValue(this=this.this)
 

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/generators/hive.py

@@ -45,27 +45,35 @@ HIVE_TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
 HIVE_DATE_FORMAT = "'yyyy-MM-dd'"
 HIVE_DATEINT_FORMAT = "'yyyyMMdd'"
 
-# The default formats above, as rendered by the lenient rewrite (non-padded month/day)
-HIVE_NON_PADDED_TIME_FORMATS = ("'yyyy-M-d HH:mm:ss'", "'yyyy-M-d'")
+# The default formats above, as rendered by the lenient rewrite (non-padded month/day/time)
+HIVE_NON_PADDED_TIME_FORMATS = ("'yyyy-M-d H:m:s'", "'yyyy-M-d'")
 
 # Expressions that parse a string with a format (vs. formatting one, like TimeToStr).
 PARSE_TIME_EXPRESSIONS = (exp.StrToTime, exp.StrToDate, exp.StrToUnix, exp.TsOrDsToDate)
 
-CANONICAL_TIME_FORMAT = re.compile(r"%(?:mstrict|dstrict|[-:].|.)")
+CANONICAL_TIME_FORMAT = re.compile(r"%(?:[mdHIMS]strict|[-:].|.)")
 
-LAX_TO_NON_PADDED_FORMATS = {"%m": "%-m", "%d": "%-d"}
+LAX_TO_NON_PADDED_FORMATS = {
+    "%m": "%-m",
+    "%d": "%-d",
+    "%H": "%-H",
+    "%I": "%-I",
+    "%M": "%-M",
+    "%S": "%-S",
+}
 
 
 def _lenient_parse_format(fmt: str) -> str:
     """
-    Changes the lax %m/%d in a canonical format to the non-padded %-m/%-d, which java.time
-    parses with or without a leading zero. This is only safe for delimited specifiers, because
-    adjacent fields parse greedily, so e.g. 'yyyyMd' (from '%Y%m%d') can't even parse '20200101'.
+    Changes a lax month/day/hour/minute/second in a canonical format to its non-padded form
+    (e.g. %m -> %-m), which java.time parses with or without a leading zero. This is only safe
+    for delimited specifiers, because adjacent fields parse greedily, so e.g. 'yyyyMd' (from
+    '%Y%m%d') can't even parse '20200101'.
 
     The format is decomposed into specifiers (`formats`) and the interleaved literal text (`parts`).
-    Specifier i sits between parts[i] and parts[i + 1]. A %m/%d is changed only when its neighbors
-    don't touch a digit run, i.e., neither side is another specifier or a literal digit. At the end,
-    the pieces are zipped back together to produce the rewritten canonical format.
+    Specifier i sits between parts[i] and parts[i + 1]. A specifier is changed only when its
+    neighbors don't touch a digit run, i.e., neither side is another specifier or a literal digit.
+    At the end, the pieces are zipped back together to produce the rewritten canonical format.
     """
     parts = CANONICAL_TIME_FORMAT.split(fmt)
     formats = CANONICAL_TIME_FORMAT.findall(fmt)
@@ -175,7 +183,8 @@ def _is_cast_time_format(self: HiveGenerator, expression: exp.Expr, time_format:
         return True
 
     if time_format in HIVE_NON_PADDED_TIME_FORMATS:
-        # The base render skips the lenient rewrite: a lax %m/%d pads back to MM/dd, an explicit %-m/%-d doesn't
+        # The base render skips the lenient rewrite: a lax specifier pads back (e.g. %m -> MM),
+        # an explicit non-padded specifier (e.g. %-m) doesn't
         padded_format = generator.Generator.format_time(self, expression)
         return padded_format in (HIVE_TIME_FORMAT, HIVE_DATE_FORMAT)
 

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/generators/python.py

@@ -93,7 +93,9 @@ class PythonGenerator(generator.Generator):
         exp.In: lambda self, e: f"{self.sql(e, 'this')} in {{{self.expressions(e, flat=True)}}}",
         exp.Interval: lambda self, e: f"INTERVAL({self.sql(e.this)}, '{self.sql(e.unit)}')",
         exp.Is: lambda self, e: (
-            self.binary(e, "==") if isinstance(e.this, exp.Literal) else self.binary(e, "is")
+            self.binary(e, "!=" if e.args.get("negate") else "==")
+            if isinstance(e.this, exp.Literal)
+            else self.binary(e, "is not" if e.args.get("negate") else "is")
         ),
         exp.JSONExtract: lambda self, e: self.func(e.key, e.this, e.expression, *e.expressions),
         exp.JSONPath: lambda self, e: f"[{','.join(self.sql(p) for p in e.expressions[1:])}]",

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/generators/tsql.py

@@ -378,9 +378,10 @@ class TSQLGenerator(generator.Generator):
         return "(1 = 1)" if expression.this else "(1 = 0)"
 
     def is_sql(self, expression: exp.Is) -> str:
+        negate = expression.args.get("negate")
         if isinstance(expression.expression, exp.Boolean):
-            return self.binary(expression, "=")
-        return self.binary(expression, "IS")
+            return self.binary(expression, "<>" if negate else "=")
+        return self.binary(expression, "IS NOT" if negate else "IS")
 
     def createable_sql(self, expression: exp.Create, locations: defaultdict) -> str:
         sql = self.sql(expression, "this")

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/optimizer/canonicalize_internal_names.py

@@ -245,7 +245,8 @@ def canonicalize_internal_names(expression: E) -> E:
         output_map: dict[str, str] = {}
         if isinstance(scope_expr, exp.Select):
             for sel in scope_expr.selects:
-                if isinstance(sel, exp.Alias):
+                # Sets default name for subquery projections, both aliased and unaliased
+                if isinstance(sel, (exp.Alias, exp.Subquery)) and sel.alias:
                     old_alias = sel.alias
                     if is_output_scope:
                         new_name = old_alias

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/optimizer/qualify.py

@@ -32,7 +32,7 @@ def qualify(
     quote_identifiers: bool = True,
     identify: bool = True,
     canonicalize_table_aliases: bool = False,
-    on_qualify: t.Callable[[exp.Expr], None] | None = None,
+    on_qualify: t.Callable[[exp.Table], None] | None = None,
     sql: str | None = None,
 ) -> E:
     """

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/optimizer/qualify_columns.py

@@ -819,18 +819,29 @@ def _expand_stars(
     for expression in scope_expression.selects:
         tables: list[str] = []
         if isinstance(expression, exp.Star):
+            # Only a string literal ILIKE pattern can filter the expansion at optimization time
+            ilike = expression.args.get("ilike")
+            if ilike and not ilike.is_string:
+                new_selections.append(expression)
+                continue
+
             tables.extend(scope.selected_sources)
             _add_except_columns(expression, tables, except_columns)
             _add_replace_columns(expression, tables, replace_columns)
             _add_rename_columns(expression, tables, rename_columns)
-            ilike_pattern = _add_ilike_columns(expression)
+            ilike_pattern = _add_ilike_columns(expression, dialect)
         elif expression.is_star:
             if isinstance(expression, exp.Column):
+                ilike = expression.this.args.get("ilike")
+                if ilike and not ilike.is_string:
+                    new_selections.append(expression)
+                    continue
+
                 tables.append(expression.table)
                 _add_except_columns(expression.this, tables, except_columns)
                 _add_replace_columns(expression.this, tables, replace_columns)
                 _add_rename_columns(expression.this, tables, rename_columns)
-                ilike_pattern = _add_ilike_columns(expression.this)
+                ilike_pattern = _add_ilike_columns(expression.this, dialect)
             elif isinstance(expression, exp.Dot):
                 if dialect.REQUIRES_PARENTHESIZED_STRUCT_ACCESS:
                     struct_fields = _expand_struct_stars_with_parens(expression)
@@ -861,7 +872,10 @@ def _expand_stars(
             if pseudocolumns and dialect.EXCLUDES_PSEUDOCOLUMNS_FROM_STAR:
                 columns = [name for name in columns if name.upper() not in pseudocolumns]
 
-            if not columns or "*" in columns:
+            # If a source exposes duplicate output names (e.g. a derived table re-exposing
+            # colliding star-expanded columns), expanding this star would produce ambiguous
+            # projections, so we leave it unexpanded.
+            if not columns or "*" in columns or len(columns) != len(set(columns)):
                 return
 
             table_id = id(table)
@@ -943,13 +957,33 @@ def _output_identifier_quoted(selection: exp.Expr) -> bool:
     return isinstance(identifier, exp.Identifier) and identifier.quoted
 
 
-def _add_ilike_columns(expression: exp.Expr) -> str | None:
+def _add_ilike_columns(expression: exp.Expr, dialect: Dialect) -> str | None:
     ilike = expression.args.get("ilike")
 
     if not ilike:
         return None
 
-    return "".join(".*" if c == "%" else "." if c == "_" else re.escape(c) for c in ilike.name)
+    i = 0
+    chars = []
+    pattern = ilike.name
+    len_pattern = len(pattern)
+
+    while i < len_pattern:
+        c = pattern[i]
+
+        if c == "\\" and dialect.STAR_ILIKE_BACKSLASH_ESCAPE and i + 1 < len_pattern:
+            i += 1
+            chars.append(re.escape(pattern[i]))
+        elif c == "%":
+            chars.append(".*")
+        elif c == "_":
+            chars.append(".")
+        else:
+            chars.append(re.escape(c))
+
+        i += 1
+
+    return "".join(chars)
 
 
 def _add_except_columns(expression: exp.Expr, tables, except_columns: dict[int, set[str]]) -> None:
@@ -1020,15 +1054,28 @@ def qualify_outputs(scope_or_expression: Scope | exp.Expr, dialect: Dialect) ->
                 dialect.normalize_identifier(alias_identifier)
                 selection.set("alias", exp.TableAlias(this=alias_identifier))
         elif not isinstance(selection, (exp.Alias, exp.Aliases)) and not selection.is_star:
-            source_quoted = isinstance(selection, exp.Column) and selection.this.quoted
+            unwrapped = selection.unnest()
+            if isinstance(unwrapped, exp.Column):
+                source_identifier = unwrapped.this
+            elif isinstance(unwrapped, exp.Dot):
+                source_identifier = unwrapped.expression
+            else:
+                source_identifier = None
+
             selection = alias(
                 selection,
                 alias=selection.output_name or f"_col_{i}",
                 copy=False,
             )
-            if source_quoted:
-                selection.args["alias"].set("quoted", True)
-            dialect.normalize_identifier(selection.args["alias"])
+            if isinstance(source_identifier, exp.Identifier):
+                # The alias copies the exact spelling of an existing identifier, so folding it
+                # here would desync it from other occurrences of that identifier; its casing
+                # is `normalize_identifiers`' concern, which has already run (or was skipped
+                # deliberately) by this point
+                if source_identifier.quoted:
+                    selection.args["alias"].set("quoted", True)
+            else:
+                dialect.normalize_identifier(selection.args["alias"])
         if aliased_column:
             selection.set("alias", exp.to_identifier(aliased_column))
 

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/optimizer/simplify.py

@@ -332,6 +332,8 @@ def eval_boolean(
     expression: object, a: SupportsComparison, b: SupportsComparison
 ) -> exp.Boolean | None:
     if isinstance(expression, (exp.EQ, exp.Is)):
+        if isinstance(expression, exp.Is) and expression.args.get("negate"):
+            return boolean_literal(a != b)
         return boolean_literal(a == b)
     if isinstance(expression, exp.NEQ):
         return boolean_literal(a != b)
@@ -892,8 +894,11 @@ class Simplifier:
         self, expression: exp.Expr, left: exp.Expr, right: exp.Expr, or_: bool = False
     ) -> exp.Expr | None:
         if isinstance(left, self.COMPARISONS) and isinstance(right, self.COMPARISONS):
-            ll, lr = left.args.values()
-            rl, rr = right.args.values()
+            if any(isinstance(e, exp.Is) and e.args.get("negate") for e in (left, right)):
+                return None
+
+            ll, lr = left.this, left.expression
+            rl, rr = right.this, right.expression
 
             largs = {ll, lr}
             rargs = {rl, rr}
@@ -1194,6 +1199,9 @@ class Simplifier:
                 c = b
                 not_ = False
 
+            if expression.args.get("negate"):
+                not_ = not not_
+
             if is_null(c):
                 if isinstance(a, exp.Literal):
                     return exp.true() if not_ else exp.false()
@@ -1699,7 +1707,7 @@ class Gen:
         self._binary(e, " DIV ")
 
     def is_sql(self, e: exp.Is) -> None:
-        self._binary(e, " IS ")
+        self._binary(e, " IS NOT " if e.args.get("negate") else " IS ")
 
     def like_sql(self, e: exp.Like) -> None:
         self._binary(e, " NOT Like " if e.args.get("negate") else " Like ")

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/parser.py

@@ -742,6 +742,7 @@ class Parser:
         TokenType.OFFSET,
         TokenType.OPERATOR,
         TokenType.ORDINALITY,
+        TokenType.OUT,
         TokenType.OVER,
         TokenType.OVERLAPS,
         TokenType.OVERWRITE,
@@ -1018,7 +1019,10 @@ class Parser:
             )
         ),
         TokenType.FARROW: lambda self, expressions: self.expression(
-            exp.Kwarg(this=exp.var(expressions[0].name), expression=self._parse_disjunction())
+            exp.Kwarg(
+                this=exp.var(expressions[0].name),
+                expression=self._parse_disjunction() or self._parse_select(),
+            )
         ),
     }
 
@@ -3542,6 +3546,38 @@ class Parser:
 
             this = self._parse_function() if is_function else self._parse_insert_table()
 
+        # MySQL's INSERT ... SET is normalized into the INSERT ... (cols) VALUES (vals) variant
+        set_values = None
+        if self._match(TokenType.SET):
+            columns = []
+            values = []
+
+            def _parse_set_assignment() -> exp.Expr | None:
+                target = self._parse_column()
+                if isinstance(target, exp.Column) and self._match(TokenType.EQ):
+                    if self.dialect.SUPPORTS_VALUES_DEFAULT and self._match(TokenType.DEFAULT):
+                        value: exp.Expr | None = exp.var(self._prev.text.upper())
+                    else:
+                        value = self._parse_disjunction()
+
+                    if value:
+                        columns.append(target.this)
+                        values.append(value)
+                        return value
+
+                self.raise_error("Expected column assignment in INSERT ... SET")
+                return None
+
+            self._parse_csv(_parse_set_assignment)
+
+            this = self.expression(exp.Schema(this=this, expressions=columns))
+            set_values = self.expression(
+                exp.Values(
+                    expressions=[exp.Tuple(expressions=values)],
+                    alias=self._parse_table_alias(),
+                )
+            )
+
         returning = self._parse_returning()  # TSQL allows RETURNING before source
 
         return self.expression(
@@ -3557,7 +3593,9 @@ class Parser:
                 partition=self._match(TokenType.PARTITION_BY) and self._parse_partitioned_by(),
                 settings=self._match_text_seq("SETTINGS") and self._parse_settings_property(),
                 default=self._match_text_seq("DEFAULT", "VALUES"),
-                expression=self._parse_derived_table_values() or self._parse_ddl_select(),
+                expression=set_values
+                or self._parse_derived_table_values()
+                or self._parse_ddl_select(),
                 conflict=self._parse_on_conflict(),
                 returning=returning or self._parse_returning(),
                 overwrite=overwrite,
@@ -5912,8 +5950,11 @@ class Parser:
             elif self._match(TokenType.NOTNULL):
                 # Postgres supports ISNULL and NOTNULL for conditions.
                 # https://blog.andreiavram.ro/postgresql-null-composite-type/
-                this = self.expression(exp.Is(this=this, expression=exp.Null()))
-                this = self.expression(exp.Not(this=this))
+                if self.dialect.NORMALIZE_NOT_NULL:
+                    this = self.expression(exp.Is(this=this, expression=exp.Null()))
+                    this = self.expression(exp.Not(this=this))
+                else:
+                    this = self.expression(exp.Is(this=this, expression=exp.Null(), negate=True))
             else:
                 if negate:
                     self._retreat(self._index - 1)
@@ -5969,8 +6010,12 @@ class Parser:
                 self._retreat(index)
                 return None
 
-        this = self.expression(exp.Is(this=this, expression=expression))
-        this = self.expression(exp.Not(this=this)) if negate else this
+        if negate and isinstance(expression, exp.Null) and not self.dialect.NORMALIZE_NOT_NULL:
+            this = self.expression(exp.Is(this=this, expression=expression, negate=True))
+        else:
+            this = self.expression(exp.Is(this=this, expression=expression))
+            this = self.expression(exp.Not(this=this)) if negate else this
+
         return self._parse_column_ops(this)
 
     def _parse_in(self, this: exp.Expr | None, alias: bool = False) -> exp.In:
@@ -9737,7 +9782,11 @@ class Parser:
                 this.set("unpack", True)
             return this
 
+        index = self._index
         ilike = self._parse_string() if self._match(TokenType.ILIKE) else None
+        if not ilike:
+            # ILIKE without a string pattern is not a star filter, e.g. `* ILIKE (foo)`
+            self._retreat(index)
 
         return self.expression(
             exp.Star(

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglot/parsers/duckdb.py

@@ -129,6 +129,7 @@ class DuckDBParser(parser.Parser):
         ),
         "EPOCH": exp.TimeToUnix.from_arg_list,
         "EPOCH_MS": lambda args: exp.UnixToTime(this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS),
+        "FROM_HEX": exp.Unhex.from_arg_list,
         "GENERATE_SERIES": _build_generate_series(),
         "GET_CURRENT_TIME": exp.CurrentTime.from_arg_list,
         "GET_BIT": lambda args: exp.Getbit(

{sqlglotc-30.13.0 → sqlglotc-30.14.0/sqlglotc.egg-info}/PKG-INFO

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

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglotc.egg-info/requires.txt

@@ -1,4 +1,4 @@
-sqlglot==30.13.0
+sqlglot==30.14.0
 
 [dev]
 setuptools>=61.0

{sqlglotc-30.13.0 → sqlglotc-30.14.0}/sqlglotc.egg-info/scm_file_list.json

@@ -1,7 +1,7 @@
 {
   "files": [
-    "pyproject.toml",
     "MANIFEST.in",
-    "setup.py"
+    "setup.py",
+    "pyproject.toml"
   ]
 }

sqlglotc-30.14.0/sqlglotc.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "30.14.0",
+  "distance": 0,
+  "node": "g29c651b85309693924b8c034501e6a2733d14588",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-27"
+}

sqlglotc-30.13.0/sqlglotc.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "30.13.0",
-  "distance": 0,
-  "node": "g98e2b3fa99d101ec57da18ebcbf3e147406dc966",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-07-20"
-}