polyglot-sql-chio 0.13.2__tar.gz → 0.13.4__tar.gz

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.13.2"
+version = "0.13.4"
 dependencies = [
  "criterion",
  "once_cell",
@@ -624,7 +624,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.13.2"
+version = "0.13.4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -633,7 +633,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.13.2"
+version = "0.13.4"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -643,11 +643,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.13.2"
+version = "0.13.4"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.13.2"
+version = "0.13.4"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -658,7 +658,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.13.2"
+version = "0.13.4"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/Cargo.toml

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

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/PKG-INFO

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

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/Cargo.toml

@@ -101,14 +101,14 @@ function-catalog-all-dialects = [
 
 [dependencies]
 regex = { version = "1", optional = true }
-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.4" }
 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.4", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/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.4", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.13.2",
+    version = "0.13.4",
     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.4",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.13.2",
+    version = "0.13.4",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/ast_mutation.rs

@@ -77,6 +77,7 @@ pub(crate) fn binary(kind: BinaryKind, left: Expression, right: Expression) -> E
         BinaryKind::Div => Expression::Div(Box::new(operation)),
         BinaryKind::Mod => Expression::Mod(Box::new(operation)),
         BinaryKind::Like => Expression::Like(Box::new(LikeOp {
+            negated: false,
             left: operation.left,
             right: operation.right,
             escape: None,
@@ -84,6 +85,7 @@ pub(crate) fn binary(kind: BinaryKind, left: Expression, right: Expression) -> E
             inferred_type: None,
         })),
         BinaryKind::ILike => Expression::ILike(Box::new(LikeOp {
+            negated: false,
             left: operation.left,
             right: operation.right,
             escape: None,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/athena.rs

@@ -107,8 +107,10 @@ impl DialectImpl for AthenaDialect {
             // ILike -> LOWER() LIKE LOWER() (Trino doesn't support ILIKE)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left.clone())));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right.clone())));
+                let lower_right =
+                    super::lower_like_pattern(op.right.clone(), op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -172,8 +172,9 @@ impl DialectImpl for BigQueryDialect {
             // ILIKE -> LOWER() LIKE LOWER() in BigQuery (no ILIKE support)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left)));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right)));
+                let lower_right = super::lower_like_pattern(op.right, op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -119,8 +119,6 @@ impl DialectImpl for ClickHouseDialect {
                 | Expression::IsTrue(_)
                 | Expression::IsFalse(_)
                 | Expression::IsJson(_)
-                | Expression::Like(_)
-                | Expression::ILike(_)
                 | Expression::SimilarTo(_)
                 | Expression::Glob(_)
                 | Expression::RegexpLike(_)

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/hive.rs

@@ -120,8 +120,9 @@ impl DialectImpl for HiveDialect {
             // ILIKE -> LOWER() LIKE LOWER() in Hive (no ILIKE support)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left)));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right)));
+                let lower_right = super::lower_like_pattern(op.right, op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/mod.rs

@@ -631,6 +631,45 @@ fn is_default_presto_date_format(fmt: &str) -> bool {
     fmt == "%Y-%m-%d" || fmt == "%F"
 }
 
+/// Lower each literal quantified pattern, not its containing tuple/array.
+#[cfg(feature = "transpile")]
+pub(crate) fn lower_like_pattern(pattern: Expression, quantified: bool) -> Expression {
+    if quantified {
+        match pattern {
+            Expression::Paren(mut paren) => {
+                paren.this = lower_like_pattern(paren.this, true);
+                return Expression::Paren(paren);
+            }
+            Expression::Tuple(mut tuple) => {
+                tuple.expressions = tuple
+                    .expressions
+                    .into_iter()
+                    .map(|value| lower_like_pattern(value, false))
+                    .collect();
+                return Expression::Tuple(tuple);
+            }
+            Expression::Array(mut array) => {
+                array.expressions = array
+                    .expressions
+                    .into_iter()
+                    .map(|value| lower_like_pattern(value, false))
+                    .collect();
+                return Expression::Array(array);
+            }
+            Expression::ArrayFunc(mut array) => {
+                array.expressions = array
+                    .expressions
+                    .into_iter()
+                    .map(|value| lower_like_pattern(value, false))
+                    .collect();
+                return Expression::ArrayFunc(array);
+            }
+            other => return lower_like_pattern(other, false),
+        }
+    }
+    Expression::Lower(Box::new(crate::expressions::UnaryFunc::new(pattern)))
+}
+
 /// Applies a transform function bottom-up through an entire expression tree.
 ///
 /// The public entrypoint uses an explicit task stack for the recursion-heavy shapes

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/mysql.rs

@@ -162,8 +162,9 @@ impl DialectImpl for MySQLDialect {
             Expression::ILike(op) => {
                 // Transform ILIKE to: LOWER(left) LIKE LOWER(right)
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left)));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right)));
+                let lower_right = super::lower_like_pattern(op.right, op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -152,10 +152,18 @@ pub(super) fn normalize(
 
         if matches!(source, DialectType::Generic) && matches!(target, DialectType::Drill) {
             if let Expression::ILike(ref like) = e {
-                return Ok(Expression::Function(Box::new(Function::new(
+                if like.quantifier.is_some() {
+                    return Ok(e);
+                }
+                let function = Expression::Function(Box::new(Function::new(
                     "ILIKE".to_string(),
                     vec![like.left.clone(), like.right.clone()],
-                ))));
+                )));
+                return Ok(if like.negated {
+                    Expression::Not(Box::new(crate::expressions::UnaryOp::new(function)))
+                } else {
+                    function
+                });
             }
         }
 
@@ -3977,11 +3985,16 @@ pub(super) fn normalize(
                                 "LOWER".to_string(),
                                 vec![like.left],
                             )));
-                            let lower_right = Expression::Function(Box::new(Function::new(
-                                "LOWER".to_string(),
-                                vec![like.right],
-                            )));
+                            let lower_right = if like.quantifier.is_some() {
+                                super::lower_like_pattern(like.right, true)
+                            } else {
+                                Expression::Function(Box::new(Function::new(
+                                    "LOWER".to_string(),
+                                    vec![like.right],
+                                )))
+                            };
                             return Ok(Expression::Like(Box::new(crate::expressions::LikeOp {
+                                negated: like.negated,
                                 left: lower_left,
                                 right: lower_right,
                                 escape: like.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/normalization/operators.rs

@@ -335,6 +335,7 @@ pub(super) fn rewrite(
             Action::SimilarToToTsqlLike => match e {
                 Expression::SimilarTo(f) => {
                     let like = Expression::Like(Box::new(LikeOp {
+                        negated: false,
                         left: f.this,
                         right: f.pattern,
                         escape: f.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/normalization/scalar.rs

@@ -3080,6 +3080,7 @@ pub(super) fn rewrite(
                                 None
                             };
                             Ok(Expression::Like(Box::new(crate::expressions::LikeOp {
+                                negated: false,
                                 left: this,
                                 right: pattern,
                                 escape,
@@ -3097,6 +3098,7 @@ pub(super) fn rewrite(
                                 None
                             };
                             Ok(Expression::ILike(Box::new(crate::expressions::LikeOp {
+                                negated: false,
                                 left: this,
                                 right: pattern,
                                 escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/oracle.rs

@@ -92,8 +92,9 @@ impl DialectImpl for OracleDialect {
             // ILIKE -> LOWER() LIKE LOWER() in Oracle (no ILIKE support)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left)));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right)));
+                let lower_right = super::lower_like_pattern(op.right, op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/presto.rs

@@ -74,8 +74,10 @@ impl DialectImpl for PrestoDialect {
             // ILike -> LOWER() LIKE LOWER() (Presto doesn't support ILIKE)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left.clone())));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right.clone())));
+                let lower_right =
+                    super::lower_like_pattern(op.right.clone(), op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/snowflake.rs

@@ -2432,6 +2432,7 @@ impl SnowflakeDialect {
                 let right = args.next().unwrap();
                 let escape = args.next();
                 Ok(Expression::Like(Box::new(crate::expressions::LikeOp {
+                    negated: false,
                     left,
                     right,
                     escape,
@@ -2447,6 +2448,7 @@ impl SnowflakeDialect {
                 let right = args.next().unwrap();
                 let escape = args.next();
                 Ok(Expression::ILike(Box::new(crate::expressions::LikeOp {
+                    negated: false,
                     left,
                     right,
                     escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/sqlite.rs

@@ -82,8 +82,10 @@ impl DialectImpl for SQLiteDialect {
             // ILike -> LOWER() LIKE LOWER() (SQLite doesn't support ILIKE)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left.clone())));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right.clone())));
+                let lower_right =
+                    super::lower_like_pattern(op.right.clone(), op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,
@@ -375,6 +377,7 @@ impl SQLiteDialect {
                 let escape = args.remove(0);
                 Ok(Expression::Like(Box::new(LikeOp {
                     left: string,
+                    negated: false,
                     right: pattern,
                     escape: Some(escape),
                     quantifier: None,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/trino.rs

@@ -80,8 +80,10 @@ impl DialectImpl for TrinoDialect {
             // ILike -> LOWER() LIKE LOWER() (Trino doesn't support ILIKE)
             Expression::ILike(op) => {
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left.clone())));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right.clone())));
+                let lower_right =
+                    super::lower_like_pattern(op.right.clone(), op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -343,8 +343,9 @@ impl DialectImpl for TSQLDialect {
                 // SQL Server is case-insensitive by default based on collation
                 // But for explicit case-insensitive matching, use LOWER
                 let lower_left = Expression::Lower(Box::new(UnaryFunc::new(op.left)));
-                let lower_right = Expression::Lower(Box::new(UnaryFunc::new(op.right)));
+                let lower_right = super::lower_like_pattern(op.right, op.quantifier.is_some());
                 Ok(Expression::Like(Box::new(LikeOp {
+                    negated: op.negated,
                     left: lower_left,
                     right: lower_right,
                     escape: op.escape,

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/expressions.rs

@@ -4727,6 +4727,10 @@ impl BinaryOp {
 #[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]
 pub struct LikeOp {
+    /// Infix NOT LIKE negates each comparison, before ANY/ALL reduction.
+    /// Prefix NOT is represented separately as Expression::Not(Like(...)).
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub negated: bool,
     pub left: Expression,
     pub right: Expression,
     /// ESCAPE character/expression
@@ -4744,6 +4748,7 @@ pub struct LikeOp {
 impl LikeOp {
     pub fn new(left: Expression, right: Expression) -> Self {
         Self {
+            negated: false,
             left,
             right,
             escape: None,
@@ -4754,6 +4759,7 @@ impl LikeOp {
 
     pub fn with_escape(left: Expression, right: Expression, escape: Expression) -> Self {
         Self {
+            negated: false,
             left,
             right,
             escape: Some(escape),

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/function_registry.rs

@@ -40,7 +40,7 @@ pub(crate) const NO_PAREN_FUNCTION_NAME_LIST: &[&str] = &[
     "UTC_TIMESTAMP",
     "SESSION_USER",
     "SYSTEM_USER",
-    // Note: USER by itself is NOT a no-paren function in standard SQL - only CURRENT_USER is
+    // Bare USER is dialect-specific; see `bare_user_is_function`.
     "PI",
     // MySQL/Databricks CURDATE
     "CURDATE",
@@ -2224,6 +2224,21 @@ pub(crate) fn is_no_paren_function_name_upper(upper_name: &str) -> bool {
     NO_PAREN_FUNCTION_NAME_SET.contains(upper_name)
 }
 
+/// Whether an unquoted, unqualified `USER` is the niladic session-user function.
+/// Other dialects either require `USER()` or treat `user` as an ordinary name.
+pub(crate) fn bare_user_is_function(dialect: Option<DialectType>) -> bool {
+    matches!(
+        dialect,
+        Some(
+            DialectType::PostgreSQL
+                | DialectType::Redshift
+                | DialectType::DuckDB
+                | DialectType::TSQL
+                | DialectType::Oracle
+        )
+    )
+}
+
 /// Returns true if the given uppercased name should use aggregate parsing behavior.
 pub(crate) fn is_aggregate_function_name_upper(upper_name: &str) -> bool {
     AGGREGATE_FUNCTION_NAME_SET.contains(upper_name)

{polyglot_sql_chio-0.13.2 → polyglot_sql_chio-0.13.4}/crates/polyglot-sql/src/generator.rs

@@ -3382,11 +3382,7 @@ impl Generator {
             Expression::JSONBDeleteAtPath(op) => self.generate_binary_op(op, "#-"),
             Expression::ExtendsLeft(op) => self.generate_binary_op(op, "&<"),
             Expression::ExtendsRight(op) => self.generate_binary_op(op, "&>"),
-            Expression::Not(op) => match &op.this {
-                Expression::Like(like) => self.generate_like_op_negated(like, "LIKE"),
-                Expression::ILike(like) => self.generate_like_op_negated(like, "ILIKE"),
-                _ => self.generate_unary_op(op, "NOT"),
-            },
+            Expression::Not(op) => self.generate_unary_op(op, "NOT"),
             Expression::Neg(op) => self.generate_unary_op(op, "-"),
             Expression::BitwiseNot(op) => {
                 // Presto/Trino use BITWISE_NOT function
@@ -23869,7 +23865,8 @@ impl Generator {
     ) -> Result<()> {
         let wrap_left = infix_operator.is_some_and(|parent| {
             Self::infix_operand_needs_parentheses(parent, &op.left, OperandSide::Left)
-        });
+        }) || (matches!(&op.left, Expression::Not(_))
+            && !matches!(operator, "AND" | "OR" | "XOR"));
         if wrap_left {
             self.write("(");
         }
@@ -23947,7 +23944,8 @@ impl Generator {
         self.write_space();
         let wrap_right = infix_operator.is_some_and(|parent| {
             Self::infix_operand_needs_parentheses(parent, &op.right, OperandSide::Right)
-        });
+        }) || (matches!(&op.right, Expression::Not(_))
+            && !matches!(operator, "AND" | "OR" | "XOR"));
         if wrap_right {
             self.write("(");
         }
@@ -24165,28 +24163,41 @@ impl Generator {
 
     /// Generate LIKE/ILIKE operation with optional ESCAPE clause
     fn generate_like_op(&mut self, op: &LikeOp, operator: &str) -> Result<()> {
-        self.generate_like_op_inner(op, operator, false)
-    }
-
-    fn generate_like_op_negated(&mut self, op: &LikeOp, operator: &str) -> Result<()> {
-        self.generate_like_op_inner(op, operator, true)
+        self.generate_like_op_inner(op, operator, op.negated)
     }
 
     fn generate_like_op_inner(&mut self, op: &LikeOp, operator: &str, negated: bool) -> Result<()> {
+        // DataFusion's established unquantified spelling is prefix NOT. This
+        // equivalence must never be applied before an ANY/ALL reduction.
         if negated
-            && matches!(
-                self.config.dialect,
-                Some(DialectType::ClickHouse)
-                    | Some(DialectType::DataFusion)
-                    | Some(DialectType::TSQL)
-                    | Some(DialectType::Fabric)
-            )
+            && op.quantifier.is_none()
+            && self.config.dialect == Some(DialectType::DataFusion)
         {
             self.write_keyword("NOT");
             self.write_space();
             return self.generate_like_op_inner(op, operator, false);
         }
-
+        // Snowflake does not accept infix NOT LIKE ANY/ALL. Negating every
+        // comparison is equivalent to negating the dual positive quantifier.
+        if negated && self.config.dialect == Some(DialectType::Snowflake) {
+            let dual = match op.quantifier.as_deref() {
+                Some(q) if q.eq_ignore_ascii_case("ALL") => Some("ANY"),
+                Some(q) if q.eq_ignore_ascii_case("ANY") || q.eq_ignore_ascii_case("SOME") => {
+                    Some("ALL")
+                }
+                _ => None,
+            };
+            if let Some(dual) = dual {
+                let mut positive = op.clone();
+                positive.negated = false;
+                positive.quantifier = Some(dual.into());
+                self.write_keyword("NOT");
+                self.write(" (");
+                self.generate_like_op_inner(&positive, operator, false)?;
+                self.write(")");
+                return Ok(());
+            }
+        }
         if matches!(self.config.dialect, Some(DialectType::ClickHouse)) {
             if let Expression::Star(star) = &op.left {
                 if star
@@ -24304,7 +24315,8 @@ impl Generator {
     ) -> Result<()> {
         let wrap_left = infix_operator.is_some_and(|parent| {
             Self::infix_operand_needs_parentheses(parent, &op.left, OperandSide::Left)
-        });
+        }) || (matches!(&op.left, Expression::Not(_))
+            && !matches!(operator, "AND" | "OR" | "XOR"));
         if wrap_left {
             self.write("(");
         }
@@ -24361,7 +24373,8 @@ impl Generator {
         self.write_space();
         let wrap_right = infix_operator.is_some_and(|parent| {
             Self::infix_operand_needs_parentheses(parent, &op.right, OperandSide::Right)
-        });
+        }) || (matches!(&op.right, Expression::Not(_))
+            && !matches!(operator, "AND" | "OR" | "XOR"));
         if wrap_right {
             self.write("(");
         }
@@ -24401,7 +24414,20 @@ impl Generator {
                 self.write_space();
             }
         }
-        self.generate_expression(&op.this)
+        let wrap = operator == "NOT"
+            && (matches!(
+                &op.this,
+                Expression::And(_) | Expression::Or(_) | Expression::Xor(_)
+            ) || (self.config.dialect == Some(DialectType::ClickHouse)
+                && matches!(&op.this, Expression::Like(like) | Expression::ILike(like) if like.quantifier.is_some())));
+        if wrap {
+            self.write("(");
+        }
+        self.generate_expression(&op.this)?;
+        if wrap {
+            self.write(")");
+        }
+        Ok(())
     }
 
     fn generate_in(&mut self, in_expr: &In) -> Result<()> {