docs: clarify expr_arc_id scope for expression deduplication

Add documentation explaining that expr_arc_id is only valid for
deduplication within a single serialized plan from a single process.
Arc pointer addresses can collide across different processes or even
within the same process over time, so a fresh DefaultPhysicalProtoConverter
instance must be used for each plan deserialization.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: adriangb

datafusion/proto/proto/datafusion.proto

@@ -842,6 +842,14 @@ message PhysicalExprNode {
   // When serializing, this is set to Arc::as_ptr(expr) as u64.
   // When deserializing, if this ID has been seen before, the cached Arc is returned
   // instead of creating a new one, enabling expression sharing.
+  //
+  // IMPORTANT: This field is ONLY valid as a deduplication key within a single
+  // serialized plan from a single process. It MUST NOT be used to deduplicate
+  // across different plans or across different nodes/processes, as Arc pointer
+  // addresses can collide (the same address may be reused for different allocations
+  // in different processes, or even within the same process over time).
+  //
+  // The deserializer should use a fresh dedup cache for each plan it deserializes.
   optional uint64 expr_arc_id = 30;
 
   oneof ExprType {

datafusion/proto/src/generated/prost.rs

@@ -3673,10 +3673,25 @@ struct DataEncoderTuple {
 /// instead of creating a new one. This enables expression sharing and can
 /// significantly reduce memory usage for plans with duplicate expressions
 /// (e.g., large IN lists).
+///
+/// # Important: Scope of Deduplication
+///
+/// The `expr_arc_id` is only valid as a deduplication key **within a single
+/// serialized plan from a single process**. Arc pointer addresses can collide:
+/// - Different processes may allocate Arcs at the same address
+/// - The same process may reuse addresses after deallocation
+///
+/// Therefore, you **must create a fresh `DefaultPhysicalProtoConverter` instance
+/// for each plan you deserialize**. Do not reuse the same converter instance
+/// across multiple plans from different sources, as this could incorrectly
+/// deduplicate unrelated expressions that happen to share the same pointer address.
 #[derive(Default)]
 pub struct DefaultPhysicalProtoConverter {
     /// Cache for expression deduplication during deserialization.
     /// Maps expr_arc_id (the original Arc pointer address) to the deserialized expression.
+    ///
+    /// This cache should only be used for a single plan deserialization.
+    /// Create a new converter instance for each plan to avoid cross-plan collisions.
     dedup_cache: RwLock<HashMap<u64, Arc<dyn PhysicalExpr>>>,
 }