polyglot-sql 0.13.2__tar.gz → 0.13.3__tar.gz

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.13.2"
+version = "0.13.3"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.13.2"
+version = "0.13.3"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.13.2
+Version: 0.13.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/crates/polyglot-sql/Cargo.toml

@@ -103,14 +103,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.2" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.3" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.2", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.3", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/crates/polyglot-sql/README.md

@@ -25,12 +25,12 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.13.2", default-features = false }
+polyglot-sql = { version = "0.13.3", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.13.2",
+    version = "0.13.3",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.13.2",
+    version = "0.13.3",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.13.2",
+    version = "0.13.3",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

polyglot_sql-0.13.3/crates/polyglot-sql/src/dialects/normalization/duckdb.rs

@@ -0,0 +1,272 @@
+//! Preserve DuckDB's type-dependent `//` semantics before target rewrites.
+
+use super::scalar::{expression_numeric_kind, NumericKind};
+use super::*;
+use crate::expressions::RoundFunc;
+
+fn combine(left: NumericKind, right: NumericKind) -> NumericKind {
+    use NumericKind::*;
+    match (left, right) {
+        (Unknown, _) | (_, Unknown) => Unknown,
+        (Float, _) | (_, Float) => Float,
+        (Decimal, _) | (_, Decimal) => Decimal,
+        (Integer, Integer) => Integer,
+    }
+}
+
+fn numeric_kind(expr: &Expression) -> NumericKind {
+    match expr {
+        Expression::Paren(p) => numeric_kind(&p.this),
+        Expression::Neg(n) => numeric_kind(&n.this),
+        Expression::Alias(a) => numeric_kind(&a.this),
+        Expression::Add(b) | Expression::Sub(b) | Expression::Mul(b) | Expression::Mod(b) => {
+            combine(numeric_kind(&b.left), numeric_kind(&b.right))
+        }
+        // The complete bottom-up source pass has already lowered fractional
+        // children to Div. Remaining IntDiv children have integer operands.
+        Expression::IntDiv(_) => NumericKind::Integer,
+        Expression::Div(_) => NumericKind::Float,
+        Expression::Function(f) if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 => {
+            numeric_kind(&f.args[0])
+        }
+        Expression::NullIf(f) => numeric_kind(&f.this),
+        _ => expression_numeric_kind(expr),
+    }
+}
+
+/// Classify the rewritten DataFusion expression. Source `/` nodes have already
+/// been made floating, and lowered `//` nodes retain their operands' types.
+/// Never infer provenance from SQL syntax such as a NULLIF divisor.
+fn datafusion_numeric_kind(expr: &Expression) -> NumericKind {
+    match expr {
+        Expression::Paren(p) => datafusion_numeric_kind(&p.this),
+        Expression::Annotated(a) => datafusion_numeric_kind(&a.this),
+        Expression::Neg(n) => datafusion_numeric_kind(&n.this),
+        Expression::Alias(a) => datafusion_numeric_kind(&a.this),
+        Expression::Abs(f) => datafusion_numeric_kind(&f.this),
+        Expression::Add(b) | Expression::Sub(b) | Expression::Mul(b) | Expression::Mod(b) => {
+            combine(
+                datafusion_numeric_kind(&b.left),
+                datafusion_numeric_kind(&b.right),
+            )
+        }
+        Expression::Div(b) => {
+            let left = datafusion_numeric_kind(&b.left);
+            // Div is already target SQL. Its generated NULLIF follows
+            // DataFusion's common-type coercion, including a floating divisor.
+            let right = match &b.right {
+                Expression::Function(f)
+                    if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 =>
+                {
+                    combine(
+                        datafusion_numeric_kind(&f.args[0]),
+                        datafusion_numeric_kind(&f.args[1]),
+                    )
+                }
+                other => datafusion_numeric_kind(other),
+            };
+            // A source `/` supplies a floating operand even when columns or
+            // function return types on the other side are unresolved.
+            if left == NumericKind::Float || right == NumericKind::Float {
+                NumericKind::Float
+            } else {
+                combine(left, right)
+            }
+        }
+        Expression::Coalesce(f) => datafusion_branch_kind(f.expressions.iter()),
+        Expression::Case(c) => datafusion_branch_kind(
+            c.whens
+                .iter()
+                .map(|(_, result)| result)
+                .chain(c.else_.iter()),
+        ),
+        Expression::IfFunc(f) => {
+            datafusion_branch_kind(std::iter::once(&f.true_value).chain(f.false_value.iter()))
+        }
+        Expression::Function(f) if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 => {
+            datafusion_nullif_kind(&f.args[0], &f.args[1])
+        }
+        Expression::NullIf(f) => datafusion_nullif_kind(&f.this, &f.expression),
+        // Do not assume functions such as ROUND preserve numeric types across
+        // dialects: DuckDB ROUND(integer) is integer, DataFusion's is floating.
+        _ => expression_numeric_kind(expr),
+    }
+}
+
+fn datafusion_branch_kind<'a>(branches: impl Iterator<Item = &'a Expression>) -> NumericKind {
+    branches
+        .filter(|expr| !matches!(expr, Expression::Null(_)))
+        .map(datafusion_numeric_kind)
+        .reduce(combine)
+        .unwrap_or(NumericKind::Unknown)
+}
+
+fn datafusion_nullif_kind(left: &Expression, right: &Expression) -> NumericKind {
+    let left_kind = datafusion_numeric_kind(left);
+    // DuckDB preserves the first argument's type, but DataFusion coerces both
+    // arguments to a common type. Mixed numeric types need an explicit cast.
+    if left_kind == datafusion_numeric_kind(right) || matches!(right, Expression::Null(_)) {
+        left_kind
+    } else {
+        NumericKind::Unknown
+    }
+}
+
+fn as_double(expr: Expression) -> Expression {
+    super::operators::cast_expr(
+        expr,
+        DataType::Double {
+            precision: None,
+            scale: None,
+        },
+    )
+}
+
+fn unresolved_division(target: DialectType) -> crate::error::Error {
+    crate::error::Error::unsupported(
+        "DuckDB // with unresolved operand types; use explicit numeric casts",
+        target.to_string(),
+    )
+}
+
+fn prepare_datafusion_division(expr: Expression) -> Result<Expression> {
+    // Stop the outer traversal at each outermost IntDiv. Rewrite that complete
+    // subtree once, bottom-up, including casts, functions, CASE and subqueries.
+    // Replacement nodes are not revisited, so a generated Div cannot be
+    // mistaken for a source `/`, even across nested integer divisions.
+    crate::traversal::transform_with_dispatch(
+        expr,
+        &Ok,
+        &|expr| !matches!(expr, Expression::IntDiv(_)),
+        &|expr, _| {
+            crate::traversal::transform_all(expr, &|mut expr| {
+                match &mut expr {
+                    Expression::Div(b) => {
+                        // Integer, decimal and unresolved source operands need
+                        // floating arithmetic. Preserve an existing FLOAT operand
+                        // rather than widening DuckDB's FLOAT/FLOAT division.
+                        if datafusion_numeric_kind(&b.left) != NumericKind::Float
+                            && datafusion_numeric_kind(&b.right) != NumericKind::Float
+                        {
+                            b.left =
+                                as_double(std::mem::replace(&mut b.left, Expression::number(0)));
+                        }
+                    }
+                    Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c)
+                        if super::scalar::data_type_numeric_kind(&c.to) == NumericKind::Integer
+                            && matches!(
+                                datafusion_numeric_kind(&c.this),
+                                NumericKind::Float | NumericKind::Decimal
+                            ) =>
+                    {
+                        // DuckDB rounds numeric casts to integers; DataFusion
+                        // truncates. This also matters after a nested source `/`.
+                        c.this = Expression::Round(Box::new(RoundFunc {
+                            this: std::mem::replace(&mut c.this, Expression::number(0)),
+                            decimals: Some(Expression::number(0)),
+                        }));
+                    }
+                    Expression::IntDiv(_) => {
+                        let Expression::IntDiv(mut division) = expr else {
+                            unreachable!()
+                        };
+                        let kind = combine(
+                            datafusion_numeric_kind(&division.this),
+                            datafusion_numeric_kind(&division.expression),
+                        );
+                        if kind == NumericKind::Unknown {
+                            return Err(unresolved_division(DialectType::DataFusion));
+                        }
+                        if kind == NumericKind::Decimal {
+                            division.this = as_double(division.this);
+                        }
+                        return Ok(Expression::Div(Box::new(BinaryOp::new(
+                            division.this,
+                            Expression::Function(Box::new(Function::new(
+                                "NULLIF".to_string(),
+                                vec![division.expression, Expression::number(0)],
+                            ))),
+                        ))));
+                    }
+                    _ => {}
+                }
+                Ok(expr)
+            })
+        },
+    )
+}
+
+pub(in crate::dialects) fn prepare_integer_division(
+    expr: Expression,
+    source: DialectType,
+    target: DialectType,
+) -> Result<Expression> {
+    if source != DialectType::DuckDB || target == DialectType::DuckDB {
+        return Ok(expr);
+    }
+
+    if target == DialectType::DataFusion {
+        return prepare_datafusion_division(expr);
+    }
+
+    // Visit every physical child, including typed function arguments and both
+    // operands of nested IntDiv nodes, before lowering the enclosing operator.
+    crate::traversal::transform_all(expr, &|expr| {
+        let Expression::IntDiv(mut division) = expr else {
+            return Ok(expr);
+        };
+        let left_kind = numeric_kind(&division.this);
+        let right_kind = numeric_kind(&division.expression);
+        let kind = combine(left_kind, right_kind);
+
+        if kind == NumericKind::Unknown {
+            return Err(unresolved_division(target));
+        }
+
+        // NULLIF evaluates the divisor once and preserves NULL on zero for
+        // literals, casts, computed expressions, and values only known at runtime.
+        division.expression = Expression::Function(Box::new(Function::new(
+            "NULLIF".to_string(),
+            vec![division.expression, Expression::number(0)],
+        )));
+
+        if kind != NumericKind::Integer {
+            // DuckDB decimal division produces DOUBLE, whereas some targets
+            // keep decimal arithmetic (and SQLite may treat DECIMAL as INTEGER).
+            // An explicitly floating operand already establishes float division.
+            if kind == NumericKind::Decimal {
+                division.this = super::operators::cast_expr(
+                    division.this,
+                    DataType::Double {
+                        precision: None,
+                        scale: None,
+                    },
+                );
+            }
+            return Ok(Expression::Div(Box::new(BinaryOp::new(
+                division.this,
+                division.expression,
+            ))));
+        }
+
+        // Only use IntDiv where generation has a native or exact lowering.
+        // A generic DIV(...) call is invalid in several other targets.
+        if !matches!(
+            target,
+            DialectType::PostgreSQL
+                | DialectType::BigQuery
+                | DialectType::ClickHouse
+                | DialectType::SQLite
+                | DialectType::Vertica
+                | DialectType::Hive
+                | DialectType::Spark
+                | DialectType::Databricks
+        ) {
+            return Err(crate::error::Error::unsupported(
+                "DuckDB integer // conversion",
+                target.to_string(),
+            ));
+        }
+        Ok(Expression::IntDiv(division))
+    })
+}

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/crates/polyglot-sql/src/dialects/normalization/scalar.rs

@@ -15738,7 +15738,8 @@ pub(super) fn normalize_bigquery_function(
                 | DialectType::Athena
                 | DialectType::Snowflake
                 | DialectType::TSQL
-                | DialectType::Fabric => {
+                | DialectType::Fabric
+                | DialectType::DataFusion => {
                     let x = args.remove(0);
                     let y = args.remove(0);
                     // Wrap complex expressions in parens to preserve precedence

{polyglot_sql-0.13.2 → polyglot_sql-0.13.3}/crates/polyglot-sql/src/generator.rs

@@ -3476,20 +3476,28 @@ impl Generator {
                     Ok(())
                 } else if is_native_slash_op {
                     // DuckDB and Vertica use // operator for integer division
-                    self.generate_expression(&f.this)?;
+                    self.generate_infix_operand(InfixOperator::Div, &f.this, OperandSide::Left)?;
                     self.write(" // ");
-                    self.generate_expression(&f.expression)?;
+                    self.generate_infix_operand(
+                        InfixOperator::Div,
+                        &f.expression,
+                        OperandSide::Right,
+                    )?;
                     Ok(())
                 } else if matches!(
                     self.config.dialect,
                     Some(DialectType::Hive | DialectType::Spark | DialectType::Databricks)
                 ) {
                     // Hive/Spark use DIV as an infix operator
-                    self.generate_expression(&f.this)?;
+                    self.generate_infix_operand(InfixOperator::Div, &f.this, OperandSide::Left)?;
                     self.write(" ");
                     self.write_keyword("DIV");
                     self.write(" ");
-                    self.generate_expression(&f.expression)?;
+                    self.generate_infix_operand(
+                        InfixOperator::Div,
+                        &f.expression,
+                        OperandSide::Right,
+                    )?;
                     Ok(())
                 } else {
                     // Other dialects use DIV function
@@ -19030,13 +19038,14 @@ impl Generator {
         matches!(self.config.dialect, Some(DialectType::ClickHouse))
     }
 
-    /// Generate MOD function - uses % operator for dialects that prefer or require it.
-    fn generate_mod_func(&mut self, f: &crate::expressions::BinaryFunc) -> Result<()> {
-        use crate::dialects::DialectType;
+    /// Whether `MOD(x, y)` is rendered as the infix `x % y` for this dialect.
+    fn mod_func_uses_percent_operator(&self) -> bool {
+        Self::mod_func_uses_percent_for(self.config.dialect)
+    }
 
-        // Several dialects prefer or require x % y instead of MOD(x, y).
-        let use_percent_operator = matches!(
-            self.config.dialect,
+    fn mod_func_uses_percent_for(dialect: Option<DialectType>) -> bool {
+        matches!(
+            dialect,
             Some(DialectType::Snowflake)
                 | Some(DialectType::MySQL)
                 | Some(DialectType::Presto)
@@ -19049,11 +19058,20 @@ impl Generator {
                 | Some(DialectType::Athena)
                 | Some(DialectType::TSQL)
                 | Some(DialectType::Fabric)
-        );
+                | Some(DialectType::DataFusion)
+        )
+    }
+
+    /// Generate MOD function - uses % operator for dialects that prefer or require it.
+    fn generate_mod_func(&mut self, f: &crate::expressions::BinaryFunc) -> Result<()> {
+        // Several dialects prefer or require x % y instead of MOD(x, y).
+        let use_percent_operator = self.mod_func_uses_percent_operator();
 
         if use_percent_operator {
             // MOD(a, b) treats both arguments as grouped expressions. When
-            // lowering to an infix operator, keep binary arguments grouped.
+            // lowering to an infix operator, keep binary arguments grouped,
+            // including operators introduced when rendering either argument.
+            let dialect = self.config.dialect;
             let needs_paren = |e: &Expression| {
                 matches!(
                     e,
@@ -19063,6 +19081,11 @@ impl Generator {
                         | Expression::Div(_)
                         | Expression::Mod(_)
                         | Expression::ModFunc(_)
+                ) || Self::infix_operand_needs_parentheses(
+                    dialect,
+                    InfixOperator::Mod,
+                    e,
+                    OperandSide::Right,
                 )
             };
             if needs_paren(&f.this) {
@@ -25720,7 +25743,12 @@ impl Generator {
         infix_operator: Option<InfixOperator>,
     ) -> Result<()> {
         let wrap_left = infix_operator.is_some_and(|parent| {
-            Self::infix_operand_needs_parentheses(parent, &op.left, OperandSide::Left)
+            Self::infix_operand_needs_parentheses(
+                self.config.dialect,
+                parent,
+                &op.left,
+                OperandSide::Left,
+            )
         });
         if wrap_left {
             self.write("(");
@@ -25798,7 +25826,12 @@ impl Generator {
         }
         self.write_space();
         let wrap_right = infix_operator.is_some_and(|parent| {
-            Self::infix_operand_needs_parentheses(parent, &op.right, OperandSide::Right)
+            Self::infix_operand_needs_parentheses(
+                self.config.dialect,
+                parent,
+                &op.right,
+                OperandSide::Right,
+            )
         });
         if wrap_right {
             self.write("(");
@@ -25823,8 +25856,12 @@ impl Generator {
 
         let generate_term =
             |generator: &mut Self, term: &Expression, side: OperandSide| -> Result<()> {
-                let should_wrap_for_precedence =
-                    Self::infix_operand_needs_parentheses(connector.infix_operator(), term, side);
+                let should_wrap_for_precedence = Self::infix_operand_needs_parentheses(
+                    generator.config.dialect,
+                    connector.infix_operator(),
+                    term,
+                    side,
+                );
                 let should_wrap_for_clickhouse = matches!(connector, ConnectorOperator::Or)
                     && matches!(generator.config.dialect, Some(DialectType::ClickHouse))
                     && matches!(
@@ -25903,8 +25940,32 @@ impl Generator {
         }
     }
 
-    fn infix_operator(expression: &Expression) -> Option<InfixOperator> {
+    fn infix_operator(
+        dialect: Option<DialectType>,
+        expression: &Expression,
+    ) -> Option<InfixOperator> {
         match expression {
+            // `MOD(x, y)` lowered to `x % y` binds like the infix operator, so as an
+            // operand it needs the same parentheses (`2 * MOD(5, 3)` -> `2 * (5 % 3)`).
+            Expression::ModFunc(_) if Self::mod_func_uses_percent_for(dialect) => {
+                Some(InfixOperator::Mod)
+            }
+            // IntDiv is atomic when rendered as a function or CAST, but // and
+            // DIV have the same precedence and associativity as division.
+            Expression::IntDiv(_)
+                if matches!(
+                    dialect,
+                    Some(
+                        DialectType::DuckDB
+                            | DialectType::Vertica
+                            | DialectType::Hive
+                            | DialectType::Spark
+                            | DialectType::Databricks
+                    )
+                ) =>
+            {
+                Some(InfixOperator::Div)
+            }
             Expression::Or(_) => Some(InfixOperator::Or),
             Expression::Xor(_) => Some(InfixOperator::Xor),
             Expression::And(_) => Some(InfixOperator::And),
@@ -25940,6 +26001,7 @@ impl Generator {
     }
 
     fn infix_operand_needs_parentheses(
+        dialect: Option<DialectType>,
         parent: InfixOperator,
         child: &Expression,
         side: OperandSide,
@@ -25948,7 +26010,22 @@ impl Generator {
             return false;
         }
 
-        let Some(child_operator) = Self::infix_operator(child) else {
+        // Bitwise precedence differs between dialects. Group these operands
+        // explicitly when emitting arithmetic, including a lowered MOD call.
+        if parent.is_arithmetic()
+            && matches!(
+                child,
+                Expression::BitwiseAnd(_)
+                    | Expression::BitwiseOr(_)
+                    | Expression::BitwiseXor(_)
+                    | Expression::BitwiseLeftShift(_)
+                    | Expression::BitwiseRightShift(_)
+            )
+        {
+            return true;
+        }
+
+        let Some(child_operator) = Self::infix_operator(dialect, child) else {
             return false;
         };
 
@@ -25974,7 +26051,8 @@ impl Generator {
         expression: &Expression,
         side: OperandSide,
     ) -> Result<()> {
-        let needs_parentheses = Self::infix_operand_needs_parentheses(parent, expression, side);
+        let needs_parentheses =
+            Self::infix_operand_needs_parentheses(self.config.dialect, parent, expression, side);
         if needs_parentheses {
             self.write("(");
         }
@@ -26155,7 +26233,12 @@ impl Generator {
         infix_operator: Option<InfixOperator>,
     ) -> Result<()> {
         let wrap_left = infix_operator.is_some_and(|parent| {
-            Self::infix_operand_needs_parentheses(parent, &op.left, OperandSide::Left)
+            Self::infix_operand_needs_parentheses(
+                self.config.dialect,
+                parent,
+                &op.left,
+                OperandSide::Left,
+            )
         });
         if wrap_left {
             self.write("(");
@@ -26212,7 +26295,12 @@ impl Generator {
         }
         self.write_space();
         let wrap_right = infix_operator.is_some_and(|parent| {
-            Self::infix_operand_needs_parentheses(parent, &op.right, OperandSide::Right)
+            Self::infix_operand_needs_parentheses(
+                self.config.dialect,
+                parent,
+                &op.right,
+                OperandSide::Right,
+            )
         });
         if wrap_right {
             self.write("(");
@@ -26253,7 +26341,18 @@ impl Generator {
                 self.write_space();
             }
         }
-        self.generate_expression(&op.this)
+        // Function-like AST nodes such as MOD and DIV can render as infix
+        // operators. Preserve their grouping under a symbolic unary operator.
+        let needs_parens = matches!(operator, "-" | "~")
+            && Self::infix_operator(self.config.dialect, &op.this).is_some();
+        if needs_parens {
+            self.write("(");
+        }
+        self.generate_expression(&op.this)?;
+        if needs_parens {
+            self.write(")");
+        }
+        Ok(())
     }
 
     fn generate_in(&mut self, in_expr: &In) -> Result<()> {