sqlglotc 30.14.0__tar.gz → 30.16.0__tar.gz

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

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

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/setup.py

@@ -43,6 +43,7 @@ def _subpkg_files(src_dir, subpkg, files=None):
 
 def _source_files(src_dir):
     return [
+        "anonymize.py",
         "errors.py",
         "generator.py",
         "helper.py",

sqlglotc-30.16.0/sqlglot/anonymize.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import string
+
+from sqlglot.dialects.dialect import Dialect, DialectType
+from sqlglot.errors import TokenError
+from sqlglot.tokens import Token, TokenType
+
+
+ALPHABET = string.ascii_lowercase
+ALPHABET_SIZE = len(ALPHABET)
+ANONYMIZED_TYPES = {
+    TokenType.BIT_STRING,
+    TokenType.BYTE_STRING,
+    TokenType.HEX_STRING,
+    TokenType.HEREDOC_STRING,
+    TokenType.IDENTIFIER,
+    TokenType.NATIONAL_STRING,
+    TokenType.NUMBER,
+    TokenType.RAW_STRING,
+    TokenType.STRING,
+    TokenType.UNICODE_STRING,
+    TokenType.VAR,
+}
+QUOTED_TYPES = ANONYMIZED_TYPES - {TokenType.NUMBER, TokenType.VAR}
+REWRITTEN_TYPES = {TokenType.HINT, TokenType.UNKNOWN}
+
+
+def anonymize(
+    sql_or_tokens: list[Token] | str,
+    dialect: DialectType = None,
+) -> list[Token]:
+    """Replaces sensitive tokens (identifiers, strings, numbers) with fixed-width,
+    length-preserving, consistent aliases, and blanks out comments and hint bodies. When a
+    SQL string is given, it is tokenized with `dialect` first; any un-tokenized remainder
+    (e.g. an unterminated literal) is appended as a blanked UNKNOWN token. Mutates and
+    returns `sql_or_tokens`.
+
+    Args:
+        sql_or_tokens: The SQL string to anonymize, or its token list.
+        dialect: The dialect used to tokenize a SQL string.
+    """
+    dialect = Dialect.get_or_raise(dialect)
+    tokenizer_class = dialect.tokenizer_class
+    parser_class = dialect.parser_class
+
+    errored = False
+    if isinstance(sql_or_tokens, str):
+        sql = sql_or_tokens
+        tokenizer = dialect.tokenizer()
+        try:
+            tokens = tokenizer.tokenize(sql)
+        except TokenError:
+            tokens = tokenizer.tokens
+            errored = True
+    else:
+        tokens = sql_or_tokens
+        sql = None
+
+    hint_start = tokenizer_class.HINT_START
+    hint_end = tokenizer_class._COMMENTS.get(hint_start)
+    nested = tokenizer_class.NESTED_COMMENTS
+
+    seen: dict[tuple[bool, str], str] = {}
+    counter = 0
+
+    for i, token in enumerate(tokens):
+        token.comments = [_blank(comment) for comment in token.comments]
+
+        if token.token_type == TokenType.HINT:
+            # A hint's text is the whole /*+ ... */ comment, so its body is blanked as well
+            text, stop = _blank_comment(token.text, 0, hint_start, hint_end, nested)
+            token.text = text + _blank(token.text[stop:])
+            continue
+
+        if (
+            token.token_type == TokenType.VAR
+            and i + 1 < len(tokens)
+            and tokens[i + 1].token_type == TokenType.L_PAREN
+        ):
+            # A function name can live in either registry, e.g. JSON_OBJECT is only in
+            # FUNCTION_PARSERS. They're consulted separately to avoid building their union
+            name = token.text.upper()
+            if name in parser_class.FUNCTIONS or name in parser_class.FUNCTION_PARSERS:
+                continue
+        if token.token_type not in ANONYMIZED_TYPES:
+            continue
+        if not token.text:
+            continue
+
+        is_number = token.token_type == TokenType.NUMBER
+        key = (is_number, token.text)
+        alias = seen.get(key)
+        if alias is None:
+            seen[key] = (
+                _number_alias(counter, token.text) if is_number else _alias(counter, token.text)
+            )
+            counter += 1
+        token.text = seen[key]
+
+    if sql is not None and errored:
+        start = tokens[-1].end + 1 if tokens else 0
+        length = len(sql)
+        while start < length and sql[start].isspace():
+            start += 1
+        if start < length:
+            # The first two characters are kept so that the delimiter the tokenizer choked
+            # on is still visible, e.g. 'u, /*, $$, `u
+            tokens.append(
+                Token(
+                    TokenType.UNKNOWN,
+                    sql[start : start + 2] + "." * (length - start - 2),
+                    start=start,
+                    end=length - 1,
+                    line=sql.count("\n", 0, start) + 1,
+                    col=start - sql.rfind("\n", 0, start),
+                )
+            )
+
+    return tokens
+
+
+def render(sql: str, tokens: list[Token], dialect: DialectType = None) -> str:
+    """Recreates the (anonymized) SQL string from the original `sql` and token positions.
+
+    Every token is rendered over its own source span, so the result is always as long as
+    `sql`: a token that wasn't anonymized is emitted verbatim, keeping the spelling the
+    tokenizer normalized away, and an anonymized one has its alias fitted between the
+    quotes of its span. The gaps between tokens hold only whitespace and comments, so
+    they're redacted rather than reconstructed: comment markers and whitespace survive,
+    everything else is blanked. That covers anything the tokenizer didn't reach as well,
+    which is a trailing gap whenever `anonymize` wasn't the one to tokenize `sql`.
+
+    Args:
+        sql: The original SQL string.
+        tokens: The anonymized tokens to render.
+        dialect: The dialect used to identify comments and quotes in `sql`.
+    """
+    tokenizer_class = Dialect.get_or_raise(dialect).tokenizer_class
+    comments = sorted(tokenizer_class._COMMENTS.items(), key=lambda c: len(c[0]), reverse=True)
+    nested = tokenizer_class.NESTED_COMMENTS
+    quotes = sorted(
+        {
+            **tokenizer_class._QUOTES,
+            **{start: end for start, (end, _) in tokenizer_class._FORMAT_STRINGS.items()},
+            **tokenizer_class._IDENTIFIERS,
+        }.items(),
+        key=lambda quote: (len(quote[0]), len(quote[1])),
+        reverse=True,
+    )
+
+    result = []
+    prev = 0
+
+    for token in tokens:
+        result.append(_redact(sql[prev : token.start], comments, nested))
+        prev = token.end + 1
+        span = sql[token.start : prev]
+        if token.token_type in REWRITTEN_TYPES:
+            # Blanked in place by `anonymize`, or synthesized by it, so already span-shaped
+            result.append(token.text)
+        elif token.token_type in ANONYMIZED_TYPES:
+            result.append(_fit(span, token.text, quotes, token.token_type))
+        else:
+            result.append(span)
+
+    result.append(_redact(sql[prev:], comments, nested))
+
+    return "".join(result)
+
+
+def _alias(counter: int, text: str) -> str:
+    digits = []
+    while counter:
+        counter, digit = divmod(counter, ALPHABET_SIZE)
+        digits.append(ALPHABET[digit])
+
+    letters = "".join(reversed(digits)).rjust(sum(not char.isspace() for char in text), "a")
+
+    alias = []
+    i = 0
+    for char in text:
+        if char.isspace():
+            alias.append(char)
+        else:
+            alias.append(letters[i])
+            i += 1
+
+    return "".join(alias)
+
+
+def _number_alias(counter: int, text: str) -> str:
+    if len(text) > 4000:
+        digits_seen = False
+        blanked = []
+        for char in text:
+            if char.isdigit():
+                blanked.append("0" if digits_seen else "1")
+                digits_seen = True
+            else:
+                blanked.append(char)
+        return "".join(blanked)
+
+    sep = "e" if "e" in text else ("E" if "E" in text else "")
+    mantissa, _, exponent = text.partition(sep) if sep else (text, "", "")
+    sign = ""
+    if exponent.startswith(("-", "+")):
+        sign, exponent = exponent[0], exponent[1:]
+    exponent_length = len(exponent)
+
+    integer, dot, fraction = mantissa.partition(".")
+    integer_length = len(integer)
+    digits = integer_length + len(fraction)
+    mantissa_value = 10 ** (digits - 1) + counter % (9 * 10 ** (digits - 1))
+    result = str(mantissa_value)
+    if dot:
+        result = result[:integer_length] + "." + result[integer_length:]
+    if sep:
+        # The exponent marker is kept even when there are no digits after it, e.g. 1e
+        result += sep + sign
+        if exponent_length:
+            exponent_value = 10 ** (exponent_length - 1) + (counter // (9 * 10 ** (digits - 1))) % (
+                9 * 10 ** (exponent_length - 1)
+            )
+            result += str(exponent_value)
+
+    return result
+
+
+def _fit(span: str, alias: str, quotes: list[tuple[str, str]], token_type: TokenType) -> str:
+    """Fits `alias` into the quoted region of `span`, so the two are always the same length."""
+    start = end = 0
+
+    if token_type in QUOTED_TYPES:
+        for open_quote, close_quote in quotes:
+            if (
+                len(span) >= len(open_quote) + len(close_quote)
+                and span.startswith(open_quote)
+                and span.endswith(close_quote)
+            ):
+                start, end = len(open_quote), len(close_quote)
+
+                if token_type == TokenType.HEREDOC_STRING:
+                    # A heredoc's tag is part of its delimiter, e.g. $tag$body$tag$
+                    open_end = span.find(close_quote, start)
+                    close_start = span.rfind(open_quote, 0, len(span) - end)
+                    if start <= open_end < close_start:
+                        start, end = open_end + len(close_quote), len(span) - close_start
+
+                break
+
+    width = len(span) - start - end
+    pad = "0" if token_type == TokenType.NUMBER else "a"
+
+    return span[:start] + alias[:width].rjust(width, pad) + span[len(span) - end :]
+
+
+def _blank(sql: str) -> str:
+    return "".join(char if char.isspace() else "." for char in sql)
+
+
+def _blank_comment(sql: str, i: int, start: str, end: str | None, nested: bool) -> tuple[str, int]:
+    """Blanks the body of the comment at `i`, returning its text and the index past it."""
+    body = i + len(start)
+
+    if not end:
+        stop = sql.find("\n", body)
+        stop = len(sql) if stop == -1 else stop
+        return start + _blank(sql[body:stop]), stop
+
+    depth = 1
+    j = body
+    while j < len(sql):
+        if nested and sql.startswith(start, j):
+            depth += 1
+            j += len(start)
+        elif sql.startswith(end, j):
+            j += len(end)
+            depth -= 1
+            if not depth:
+                return start + _blank(sql[body : j - len(end)]) + end, j
+        else:
+            j += 1
+
+    return start + _blank(sql[body:]), len(sql)
+
+
+def _redact(sql: str, comments: list[tuple[str, str | None]], nested: bool) -> str:
+    if not sql or sql.isspace():
+        return sql
+
+    result = []
+    i = 0
+    length = len(sql)
+
+    while i < length:
+        for start, end in comments:
+            if sql.startswith(start, i):
+                text, i = _blank_comment(sql, i, start, end, nested)
+                result.append(text)
+                break
+        else:
+            char = sql[i]
+            result.append(char if char.isspace() else ".")
+            i += 1
+
+    return "".join(result)

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/errors.py

@@ -72,7 +72,21 @@ class ParseError(SqlglotError):
 
 
 class TokenError(SqlglotError):
-    pass
+    """Error raised when tokenizing fails.
+
+    When available, `start` and `end` are the offsets in the source SQL of the context
+    snippet quoted in the message, i.e. the snippet is `sql[start:end]`.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        start: int | None = None,
+        end: int | None = None,
+    ):
+        super().__init__(message)
+        self.start = start
+        self.end = end
 
 
 class OptimizeError(SqlglotError):

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

@@ -8,6 +8,7 @@ from sqlglot.expressions.core import (
     Expr,
     Func,
     Binary,
+    Predicate,
     to_identifier,
 )
 from sqlglot.helper import trait
@@ -109,16 +110,16 @@ class ArrayAny(Expression, Func):
     arg_types = {"this": True, "expression": True}
 
 
-class ArrayContains(Expression, Binary, Func):
+class ArrayContains(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "ensure_variant": False, "check_null": False}
     _sql_names = ["ARRAY_CONTAINS", "ARRAY_HAS"]
 
 
-class ArrayContainsAll(Expression, Binary, Func):
+class ArrayContainsAll(Expression, Binary, Predicate, Func):
     _sql_names = ["ARRAY_CONTAINS_ALL", "ARRAY_HAS_ALL"]
 
 
-class ArrayContainedBy(Expression, Binary, Func):
+class ArrayContainedBy(Expression, Binary, Predicate, Func):
     pass
 
 
@@ -132,7 +133,7 @@ class ArrayIntersect(Expression, Func):
     _sql_names = ["ARRAY_INTERSECT", "ARRAY_INTERSECTION"]
 
 
-class ArrayOverlaps(Expression, Binary, Func):
+class ArrayOverlaps(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "null_safe": False}
 
 
@@ -343,6 +344,7 @@ class ToMap(Expression, Func):
 class VarMap(Expression, Func):
     arg_types = {"keys": True, "values": True}
     is_var_len_args = True
+    var_len_arg_key = "values"
 
     @property
     def keys(self) -> list[Expr]:

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

@@ -14,7 +14,7 @@ from builtins import type as Type
 from collections import deque
 from collections.abc import Collection, Iterator, Mapping, MutableMapping, Sequence
 from copy import deepcopy
-from decimal import Decimal
+from decimal import Decimal, InvalidOperation
 from functools import reduce
 
 from sqlglot._typing import E, GeneratorNoDialectArgs, ParserNoDialectArgs, T
@@ -85,6 +85,7 @@ class Expr:
     arg_types: t.ClassVar[dict[str, bool]] = {"this": True}
     required_args: t.ClassVar[set[str]] = {"this"}
     is_var_len_args: t.ClassVar[bool] = False
+    var_len_arg_key: t.ClassVar[str] = "expressions"
     _hash_raw_args: t.ClassVar[bool] = False
     is_subquery: t.ClassVar[bool] = False
     is_cast: t.ClassVar[bool] = False
@@ -1577,7 +1578,7 @@ class Condition(Expr):
 
 @trait
 class Predicate(Condition):
-    """Relationships like x = y, x > 1, x >= y."""
+    """Any condition that evaluates to a boolean, e.g. x = y, x LIKE 'a%', a @> b."""
 
 
 class Cache(Expression):
@@ -1643,8 +1644,11 @@ class Func(Condition):
     The base class for all function expressions.
 
     Attributes:
-        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
+        is_var_len_args (bool): if set to True the argument identified by var_len_arg_key will be
             treated as a variable length argument and the argument's value will be stored as a list.
+        var_len_arg_key (str): the arg_types key that collects the variable length arguments.
+            Arguments preceding it in arg_types are filled positionally; those following it (e.g.
+            dialect flags) are never populated by from_arg_list.
         _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
             function expression. These values are used to map this node to a name during parsing as
             well as to provide the function's name during SQL string generation. By default the SQL
@@ -1652,18 +1656,17 @@ class Func(Condition):
     """
 
     is_var_len_args: t.ClassVar[bool] = False
+    var_len_arg_key: t.ClassVar[str] = "expressions"
     _sql_names: t.ClassVar[list[str]] = []
 
     @classmethod
     def from_arg_list(cls, args: Sequence[object]) -> Self:
         if cls.is_var_len_args:
             all_arg_keys = tuple(cls.arg_types)
-            # If this function supports variable length argument treat the last argument as such.
-            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
-            num_non_var = len(non_var_len_arg_keys)
+            var_len_index = all_arg_keys.index(cls.var_len_arg_key)
 
-            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
-            args_dict[all_arg_keys[-1]] = args[num_non_var:]
+            args_dict = {arg_key: arg for arg, arg_key in zip(args, all_arg_keys[:var_len_index])}
+            args_dict[cls.var_len_arg_key] = args[var_len_index:]
         else:
             args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
 
@@ -1764,7 +1767,10 @@ class Literal(Expression, Condition):
             try:
                 return int(self.this)
             except ValueError:
-                return Decimal(self.this)
+                try:
+                    return Decimal(self.this)
+                except InvalidOperation as e:
+                    raise ValueError(f"Invalid numeric literal: {self.this!r}") from e
         return self.this
 
 
@@ -2119,15 +2125,15 @@ class Div(Expression, Binary):
     arg_types = {"this": True, "expression": True, "typed": False, "safe": False}
 
 
-class Overlaps(Expression, Binary):
+class Overlaps(Expression, Binary, Predicate):
     pass
 
 
-class ExtendsLeft(Expression, Binary):
+class ExtendsLeft(Expression, Binary, Predicate):
     pass
 
 
-class ExtendsRight(Expression, Binary):
+class ExtendsRight(Expression, Binary, Predicate):
     pass
 
 
@@ -2231,7 +2237,7 @@ class Sub(Expression, Binary):
     pass
 
 
-class Adjacent(Expression, Binary):
+class Adjacent(Expression, Binary, Predicate):
     pass
 
 
@@ -2317,7 +2323,7 @@ class Pow(Expression, Binary, Func):
     _sql_names = ["POWER", "POW"]
 
 
-class RegexpLike(Expression, Binary, Func):
+class RegexpLike(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "flag": False, "full_match": False}
 
 

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/expressions/datatypes.py

@@ -220,10 +220,22 @@ class DataType(Expression):
         DType.NCHAR,
         DType.NVARCHAR,
         DType.TEXT,
+        DType.TINYTEXT,
+        DType.MEDIUMTEXT,
+        DType.LONGTEXT,
         DType.VARCHAR,
         DType.NAME,
     }
 
+    BINARY_TYPES: t.ClassVar[set[DType]] = {
+        DType.BINARY,
+        DType.VARBINARY,
+        DType.TINYBLOB,
+        DType.BLOB,
+        DType.MEDIUMBLOB,
+        DType.LONGBLOB,
+    }
+
     SIGNED_INTEGER_TYPES: t.ClassVar[set[DType]] = {
         DType.BIGINT,
         DType.INT,

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/expressions/ddl.py

@@ -250,6 +250,7 @@ class AlterColumn(Expression):
         "allow_null": False,
         "visible": False,
         "rename_to": False,
+        "exists": False,
     }
 
 
@@ -358,6 +359,7 @@ class Drop(Expression):
         "concurrently": False,
         "sync": False,
         "iceberg": False,
+        "force": False,
     }
 
     @property

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/expressions/dml.py

@@ -212,6 +212,7 @@ class Insert(Expression, DDL, DML):
         "settings": False,
         "source": False,
         "default": False,
+        "using": False,
     }
 
     def with_(

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/expressions/json.py

@@ -46,15 +46,15 @@ class JSONArrayInsert(Expression, Func):
     _sql_names = ["JSON_ARRAY_INSERT"]
 
 
-class JSONBContains(Expression, Binary, Func):
+class JSONBContains(Expression, Binary, Predicate, Func):
     _sql_names = ["JSONB_CONTAINS"]
 
 
-class JSONBContainsAllTopKeys(Expression, Binary, Func):
+class JSONBContainsAllTopKeys(Expression, Binary, Predicate, Func):
     pass
 
 
-class JSONBContainsAnyTopKeys(Expression, Binary, Func):
+class JSONBContainsAnyTopKeys(Expression, Binary, Predicate, Func):
     pass
 
 
@@ -133,6 +133,7 @@ class JSONExtractScalar(Expression, Binary, Func):
         "expressions": False,
         "json_type": False,
         "scalar_only": False,
+        "json_subtype": False,
     }
     _sql_names = ["JSON_EXTRACT_SCALAR"]
     is_var_len_args = True

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

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

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/expressions/properties.py

@@ -42,7 +42,15 @@ class AutoIncrementProperty(Property):
 
 
 class AutoRefreshProperty(Property):
-    arg_types = {"this": True}
+    arg_types = {
+        "this": False,
+        "cadence": False,
+        "offset": False,
+        "randomize": False,
+        "expressions": False,
+        "settings": False,
+        "append": False,
+    }
 
 
 class BackupProperty(Property):

{sqlglotc-30.14.0 → sqlglotc-30.16.0}/sqlglot/expressions/query.py

@@ -444,7 +444,7 @@ class RecursiveWithSearch(Expression):
 
 
 class With(Expression):
-    arg_types = {"expressions": True, "recursive": False, "search": False}
+    arg_types = {"expressions": False, "recursive": False, "search": False, "udfs": False}
 
     @property
     def recursive(self) -> bool:
@@ -1761,6 +1761,7 @@ class Pivot(Expression):
         "identify_pivot_strings": False,
         "prefixed_pivot_columns": False,
         "pivot_column_naming": False,
+        "value_columns_first": False,
     }
 
     @property
@@ -1814,7 +1815,13 @@ class Pivot(Expression):
                 for ident in (e.expressions if isinstance(e, Tuple) else [e])
                 if isinstance(ident, Identifier)
             ]
-            outputs = [i.name for i in name_columns + value_columns]
+            # T-SQL emits the value column(s) ahead of the name column, everyone else emits them after it
+            ordered = (
+                value_columns + name_columns
+                if self.args.get("value_columns_first")
+                else name_columns + value_columns
+            )
+            outputs = [i.name for i in ordered]
         else:
             excluded = {c.output_name for c in self.find_all(Column)}
             outputs = [c.output_name for c in self.args.get("columns") or []]
@@ -2105,13 +2112,17 @@ class StoredProcedure(Expression):
 
 
 class Block(Expression):
-    arg_types = {"expressions": True}
+    arg_types = {"expressions": True, "begin": False}
 
 
 class IfBlock(Expression):
     arg_types = {"this": True, "true": True, "false": False}
 
 
+class CaseStatement(Expression):
+    arg_types = {"this": False, "ifs": True, "default": False}
+
+
 class WhileBlock(Expression):
     arg_types = {"this": True, "body": True}
 
@@ -2120,6 +2131,16 @@ class EndStatement(Expression):
     arg_types = {}
 
 
+# https://trino.io/docs/current/udf.html
+class FunctionSpecification(Expression):
+    arg_types = {
+        "this": True,
+        "characteristics": False,
+        "properties": False,
+        "expression": True,
+    }
+
+
 UNWRAPPED_QUERIES = (Select, SetOperation)