fix(proto): preserve case_insensitive of SimilarTo across a round trip

datafusion/proto-models/proto/datafusion.proto

@@ -760,6 +760,7 @@ message SimilarToNode {
   LogicalExprNode expr = 2;
   LogicalExprNode pattern = 3;
   string escape_char = 4;
+  bool case_insensitive = 5;
 }
 
 message CaseNode {

datafusion/proto-models/src/generated/pbjson.rs

@@ -27128,6 +27128,9 @@ impl serde::Serialize for SimilarToNode {
         if !self.escape_char.is_empty() {
             len += 1;
         }
+        if self.case_insensitive {
+            len += 1;
+        }
         let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?;
         if self.negated {
             struct_ser.serialize_field("negated", &self.negated)?;
@@ -27141,6 +27144,9 @@ impl serde::Serialize for SimilarToNode {
         if !self.escape_char.is_empty() {
             struct_ser.serialize_field("escapeChar", &self.escape_char)?;
         }
+        if self.case_insensitive {
+            struct_ser.serialize_field("caseInsensitive", &self.case_insensitive)?;
+        }
         struct_ser.end()
     }
 }
@@ -27156,6 +27162,8 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
             "pattern",
             "escape_char",
             "escapeChar",
+            "case_insensitive",
+            "caseInsensitive",
         ];
 
         #[allow(clippy::enum_variant_names)]
@@ -27164,6 +27172,7 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
             Expr,
             Pattern,
             EscapeChar,
+            CaseInsensitive,
         }
         impl<'de> serde::Deserialize<'de> for GeneratedField {
             fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
@@ -27189,6 +27198,7 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
                             "expr" => Ok(GeneratedField::Expr),
                             "pattern" => Ok(GeneratedField::Pattern),
                             "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
+                            "caseInsensitive" | "case_insensitive" => Ok(GeneratedField::CaseInsensitive),
                             _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                         }
                     }
@@ -27212,6 +27222,7 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
                 let mut expr__ = None;
                 let mut pattern__ = None;
                 let mut escape_char__ = None;
+                let mut case_insensitive__ = None;
                 while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Negated => {
@@ -27238,13 +27249,20 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
                             }
                             escape_char__ = Some(map_.next_value()?);
                         }
+                        GeneratedField::CaseInsensitive => {
+                            if case_insensitive__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("caseInsensitive"));
+                            }
+                            case_insensitive__ = Some(map_.next_value()?);
+                        }
                     }
                 }
                 Ok(SimilarToNode {
                     negated: negated__.unwrap_or_default(),
                     expr: expr__,
                     pattern: pattern__,
                     escape_char: escape_char__.unwrap_or_default(),
+                    case_insensitive: case_insensitive__.unwrap_or_default(),
                 })
             }
         }

datafusion/proto-models/src/generated/prost.rs

@@ -1202,6 +1202,8 @@ pub struct SimilarToNode {
     pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
     #[prost(string, tag = "4")]
     pub escape_char: ::prost::alloc::string::String,
+    #[prost(bool, tag = "5")]
+    pub case_insensitive: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CaseNode {

datafusion/proto/src/logical_plan/from_proto.rs

@@ -404,7 +404,7 @@ pub fn parse_expr(
                 codec,
             )?),
             parse_escape_char(&like.escape_char)?,
-            false,
+            like.case_insensitive,
         ))),
         ExprType::Case(case) => {
             let when_then_expr = case

datafusion/proto/src/logical_plan/to_proto.rs

@@ -156,13 +156,14 @@ pub fn serialize_expr(
             expr,
             pattern,
             escape_char,
-            case_insensitive: _,
+            case_insensitive,
         }) => {
             let pb = Box::new(protobuf::SimilarToNode {
                 negated: *negated,
                 expr: Some(Box::new(serialize_expr(expr.as_ref(), codec)?)),
                 pattern: Some(Box::new(serialize_expr(pattern.as_ref(), codec)?)),
                 escape_char: escape_char.map(|ch| ch.to_string()).unwrap_or_default(),
+                case_insensitive: *case_insensitive,
             });
             protobuf::LogicalExprNode {
                 expr_type: Some(ExprType::SimilarTo(pb)),

datafusion/proto/tests/cases/roundtrip_logical_plan.rs

@@ -2921,21 +2921,23 @@ fn roundtrip_ilike() {
 
 #[test]
 fn roundtrip_similar_to() {
-    fn similar_to(negated: bool, escape_char: Option<char>) {
+    fn similar_to(negated: bool, escape_char: Option<char>, case_insensitive: bool) {
         let test_expr = Expr::SimilarTo(Like::new(
             negated,
             Box::new(col("col")),
             Box::new(lit("[0-9]+")),
             escape_char,
-            false,
+            case_insensitive,
         ));
         let ctx = SessionContext::new();
         roundtrip_expr_test(test_expr, ctx);
     }
-    similar_to(true, Some('X'));
-    similar_to(false, Some('\\'));
-    similar_to(true, None);
-    similar_to(false, None);
+    similar_to(true, Some('X'), false);
+    similar_to(false, Some('\\'), false);
+    similar_to(true, None, false);
+    similar_to(false, None, false);
+    similar_to(false, None, true);
+    similar_to(true, Some('X'), true);
 }
 
 #[test]

docs/source/library-user-guide/upgrading/56.0.0.md

@@ -614,6 +614,25 @@ The protobuf wire format remains backward compatible.
 
 See [PR #25058](https://github.com/apache/datafusion/pull/25058) for details.
 
+### Generated protobuf `SimilarToNode` gained a `case_insensitive` field
+
+The generated `SimilarToNode` now carries `case_insensitive`, so an
+`Expr::SimilarTo` with `case_insensitive: true` keeps the flag across
+serialization. Earlier versions encoded and decoded it as `false`.
+
+Code constructing `SimilarToNode` with a struct literal must set the field:
+
+```rust,ignore
+// Before
+SimilarToNode { negated, expr, pattern, escape_char }
+
+// After
+SimilarToNode { negated, expr, pattern, escape_char, case_insensitive: false }
+```
+
+The protobuf wire format remains backward compatible: a payload without the
+field decodes as `case_insensitive: false`.
+
 ### `DefaultStatisticsProvider` is deprecated
 
 `datafusion_physical_plan::operator_statistics::DefaultStatisticsProvider` is