fix: Address PR #64 review comments

- WebSocket Close frame returns EOF for graceful disconnect (websocket.rs)
- Downgrade info/warn logs to trace/debug in hot paths (result_transformer.rs, select_builder.rs)
- Fix AUTHORED from_id: user_id -> author_id (social_benchmark.yaml)
- Fix LIKED like_date mapping (social_benchmark.yaml)
- Update tests for new untyped pattern behavior

Author: genezhang

benchmarks/social_network/schemas/social_benchmark.yaml

@@ -62,7 +62,7 @@ graph_schema:
     - type: AUTHORED
       database: brahmand
       table: posts_bench
-      from_id: user_id
+      from_id: author_id
       to_id: post_id
       edge_id: post_id
       from_node: User
@@ -78,7 +78,7 @@ graph_schema:
       from_node: User
       to_node: Post
       property_mappings:
-        like_date: liked_at
+        like_date: like_date
 
     - type: FRIENDS_WITH
       database: brahmand

src/query_planner/analyzer/match_type_inference.rs

@@ -566,7 +566,7 @@ mod tests {
         let schema = create_test_schema_with_relationships();
         let plan_ctx = PlanCtx::new(Arc::new(schema.clone()));
 
-        // Both nodes untyped with multiple relationships - cannot infer
+        // Both nodes untyped with multiple relationships - returns all rel types for UNION expansion
         let result = infer_relationship_type_from_nodes(
             &None,
             &None,
@@ -576,6 +576,10 @@ mod tests {
         )
         .unwrap();
 
-        assert_eq!(result, None);
+        // Now returns all relationship types for UNION expansion (changed behavior)
+        assert!(result.is_some());
+        let rel_types = result.unwrap();
+        assert!(rel_types.contains(&"FOLLOWS".to_string()));
+        assert!(rel_types.contains(&"LIKES".to_string()));
     }
 }

src/query_planner/logical_plan/match_clause/tests.rs

@@ -204,22 +204,21 @@ fn test_traverse_node_pattern_existing_node() {
 }
 
 #[test]
-fn test_traverse_node_pattern_empty_node_error() {
-    let mut plan_ctx = PlanCtx::new_empty();
+fn test_traverse_node_pattern_unnamed_node_gets_alias() {
+    // Previously this would error, but now we auto-generate aliases for unnamed nodes
+    let graph_schema = create_test_schema_with_relationships();
+    let mut plan_ctx = PlanCtx::new(Arc::new(graph_schema));
     let initial_plan = Arc::new(LogicalPlan::Empty);
 
     let node_pattern = ast::NodePattern {
-        name: None, // Empty node
-        labels: Some(vec!["Person"]),
+        name: None,                 // Unnamed node - should get auto-generated alias
+        labels: Some(vec!["User"]), // Use a label that exists in test schema
         properties: None,
     };
 
     let result = traverse_node_pattern(&node_pattern, initial_plan, &mut plan_ctx);
-    assert!(result.is_err());
-    match result.unwrap_err() {
-        LogicalPlanError::EmptyNode => (), // Expected error
-        _ => panic!("Expected EmptyNode error"),
-    }
+    // Should succeed now - auto-generates alias like "t1"
+    assert!(result.is_ok());
 }
 
 #[test]
@@ -1180,7 +1179,7 @@ fn test_infer_relationship_type_no_matches() {
 
 #[test]
 fn test_infer_relationship_type_both_untyped_multi_schema() {
-    // ()-[r]->() with multiple relationships should return None
+    // ()-[r]->() with multiple relationships returns all types for UNION expansion
     let schema = create_test_schema_with_relationships();
     let plan_ctx = PlanCtx::new(Arc::new(schema.clone()));
 
@@ -1193,8 +1192,11 @@ fn test_infer_relationship_type_both_untyped_multi_schema() {
     )
     .expect("Should not error");
 
-    // Both nodes untyped and schema has 3 relationships - cannot infer
-    assert!(result.is_none());
+    // Now returns all relationship types for UNION expansion (changed behavior)
+    assert!(result.is_some());
+    let rel_types = result.unwrap();
+    assert!(rel_types.contains(&"FOLLOWS".to_string()));
+    assert!(rel_types.contains(&"LIKES".to_string()));
 }
 
 #[test]

src/render_plan/select_builder.rs

@@ -40,7 +40,7 @@ impl SelectBuilder for LogicalPlan {
         &self,
         plan_ctx: Option<&crate::query_planner::plan_ctx::PlanCtx>,
     ) -> Result<Vec<SelectItem>, RenderBuildError> {
-        log::warn!("🔍🔍🔍 extract_select_items CALLED on plan type");
+        log::trace!("🔍🔍🔍 extract_select_items CALLED on plan type");
         crate::debug_println!("DEBUG: extract_select_items called on: {:?}", self);
         let select_items = match &self {
             LogicalPlan::Empty => vec![],
@@ -81,7 +81,7 @@ impl SelectBuilder for LogicalPlan {
                 }
             }
             LogicalPlan::GraphRel(graph_rel) => {
-                log::warn!(
+                log::trace!(
                     "🔍 GraphRel.extract_select_items: alias={}, path_variable={:?}",
                     graph_rel.alias,
                     graph_rel.path_variable
@@ -166,10 +166,13 @@ impl SelectBuilder for LogicalPlan {
 
                             // NEW APPROACH: Use TypedVariable for type/source checking
                             if let Some(plan_ctx) = plan_ctx {
-                                log::warn!("  🔍 Looking up '{}' in plan_ctx...", table_alias.0);
+                                log::trace!("  🔍 Looking up '{}' in plan_ctx...", table_alias.0);
                                 match plan_ctx.lookup_variable(&table_alias.0) {
                                     Some(typed_var) if typed_var.is_entity() => {
-                                        log::warn!("  ✓ Found ENTITY variable '{}'", table_alias.0);
+                                        log::trace!(
+                                            "  ✓ Found ENTITY variable '{}'",
+                                            table_alias.0
+                                        );
                                         // Entity (Node or Relationship) - expand properties
                                         match &typed_var.source() {
                                             VariableSource::Match => {
@@ -192,7 +195,7 @@ impl SelectBuilder for LogicalPlan {
                                                 );
                                             }
                                             _ => {
-                                                log::warn!("⚠️ Entity variable '{}' has unexpected source, treating as scalar", table_alias.0);
+                                                log::debug!("⚠️ Entity variable '{}' has unexpected source, treating as scalar", table_alias.0);
                                                 select_items.push(SelectItem {
                                                     expression: RenderExpr::ColumnAlias(
                                                         ColumnAlias(table_alias.0.clone()),
@@ -206,7 +209,10 @@ impl SelectBuilder for LogicalPlan {
                                         }
                                     }
                                     Some(typed_var) if typed_var.is_scalar() => {
-                                        log::warn!("  ✓ Found SCALAR variable '{}'", table_alias.0);
+                                        log::trace!(
+                                            "  ✓ Found SCALAR variable '{}'",
+                                            table_alias.0
+                                        );
                                         // Scalar - single item, no expansion
                                         match &typed_var.source() {
                                             VariableSource::Cte { cte_name } => {
@@ -245,7 +251,7 @@ impl SelectBuilder for LogicalPlan {
                                         );
                                     }
                                     _ => {
-                                        log::warn!("  ✗ Variable '{}' NOT FOUND or not a recognized type in plan_ctx", table_alias.0);
+                                        log::trace!("  ✗ Variable '{}' NOT FOUND or not a recognized type in plan_ctx", table_alias.0);
                                         // Unknown variable - check if it's a path by looking for GraphRel
                                         if let Some(graph_rel) =
                                             self.find_graph_rel_for_path(&table_alias.0)
@@ -280,7 +286,7 @@ impl SelectBuilder for LogicalPlan {
                                             );
                                         } else {
                                             // Really unknown - fallback to old logic
-                                            log::warn!("⚠️ Variable '{}' not found in TypedVariable registry or GraphRel, using fallback logic", table_alias.0);
+                                            log::debug!("⚠️ Variable '{}' not found in TypedVariable registry or GraphRel, using fallback logic", table_alias.0);
                                             self.fallback_table_alias_expansion(
                                                 table_alias,
                                                 item,
@@ -408,7 +414,7 @@ impl SelectBuilder for LogicalPlan {
                             );
 
                             if cte_ref.columns.is_empty() {
-                                log::warn!("⚠️ CteEntityRef '{}' has no columns - falling back to TableAlias", cte_ref.alias);
+                                log::debug!("⚠️ CteEntityRef '{}' has no columns - falling back to TableAlias", cte_ref.alias);
                                 select_items.push(SelectItem {
                                     expression: RenderExpr::TableAlias(RenderTableAlias(
                                         cte_ref.alias.clone(),
@@ -586,7 +592,7 @@ impl SelectBuilder for LogicalPlan {
             LogicalPlan::Unwind(u) => u.input.extract_select_items(plan_ctx)?,
             LogicalPlan::CartesianProduct(cp) => {
                 // Combine select items from both sides
-                log::warn!("🔍 CartesianProduct.extract_select_items START");
+                log::trace!("🔍 CartesianProduct.extract_select_items START");
                 let left_items = cp.left.extract_select_items(plan_ctx)?;
                 log::warn!(
                     "🔍 CartesianProduct.extract_select_items: left side returned {} items",
@@ -609,7 +615,7 @@ impl SelectBuilder for LogicalPlan {
                 graph_node.input.extract_select_items(plan_ctx)?
             }
             LogicalPlan::WithClause(wc) => {
-                log::warn!("🔍 WithClause.extract_select_items: calling extract on input");
+                log::trace!("🔍 WithClause.extract_select_items: calling extract on input");
                 let items = wc.input.extract_select_items(plan_ctx)?;
                 log::warn!(
                     "🔍 WithClause.extract_select_items DONE: extracted {} items from input plan",
@@ -711,7 +717,7 @@ impl LogicalPlan {
                 );
             }
             _ => {
-                log::warn!("⚠️ No properties found for base table entity '{}'", alias);
+                log::debug!("⚠️ No properties found for base table entity '{}'", alias);
             }
         }
     }
@@ -733,7 +739,7 @@ impl LogicalPlan {
 
         // Parse CTE name to get aliases and compute FROM alias
         let from_alias = self.compute_from_alias_from_cte_name(cte_name);
-        log::info!("🔍 CTE '{}' → FROM alias '{}'", cte_name, from_alias);
+        log::trace!("🔍 CTE '{}' → FROM alias '{}'", cte_name, from_alias);
 
         // Get labels from TypedVariable
         let labels = match typed_var {
@@ -1002,7 +1008,7 @@ impl LogicalPlan {
                     );
                     vs.is_denormalized
                 } else {
-                    log::info!("🔍 Relationship '{}' center is NOT ViewScan", rel_alias);
+                    log::trace!("🔍 Relationship '{}' center is NOT ViewScan", rel_alias);
                     false
                 }
             } else {
@@ -1073,7 +1079,7 @@ impl LogicalPlan {
                         }
                     }
                 } else {
-                    log::warn!("  ✗ Start node '{}' not found in plan_ctx", start_alias);
+                    log::trace!("  ✗ Start node '{}' not found in plan_ctx", start_alias);
                 }
 
                 // Expand end node properties
@@ -1103,7 +1109,7 @@ impl LogicalPlan {
                         }
                     }
                 } else {
-                    log::warn!("  ✗ End node '{}' not found in plan_ctx", end_alias);
+                    log::trace!("  ✗ End node '{}' not found in plan_ctx", end_alias);
                 }
 
                 // Expand relationship properties (ONLY if not denormalized)
@@ -1140,7 +1146,7 @@ impl LogicalPlan {
                             }
                         }
                     } else {
-                        log::warn!("  ✗ Relationship '{}' not found in plan_ctx", rel_alias);
+                        log::trace!("  ✗ Relationship '{}' not found in plan_ctx", rel_alias);
                     }
                 } else {
                     // Denormalized relationship: properties come from end node's table

src/server/bolt_protocol/result_transformer.rs

@@ -379,7 +379,7 @@ pub fn transform_row(
         row.len(),
         row.keys().collect::<Vec<_>>()
     );
-    log::info!(
+    log::trace!(
         "🔍 Metadata has {} items: {:?}",
         metadata.len(),
         metadata
@@ -711,7 +711,7 @@ fn transform_to_path(
     // Check for JSON format first (UNION path queries)
     // Format: _start_properties, _end_properties, _rel_properties
     if row.contains_key("_start_properties") && row.contains_key("_end_properties") {
-        log::info!("🎯 Detected JSON format for path - parsing _start_properties, _end_properties, _rel_properties");
+        log::trace!("🎯 Detected JSON format for path - parsing _start_properties, _end_properties, _rel_properties");
         return transform_path_from_json(row, start_labels, end_labels, rel_types);
     }
 
@@ -724,7 +724,7 @@ fn transform_to_path(
                     .first()
                     .cloned()
                     .unwrap_or_else(|| "_Unknown".to_string());
-                log::info!("Creating start node with label: {}", label);
+                log::trace!("Creating start node with label: {}", label);
                 create_node_with_label(&label, 0)
             });
 
@@ -735,7 +735,7 @@ fn transform_to_path(
                 .first()
                 .cloned()
                 .unwrap_or_else(|| "_Unknown".to_string());
-            log::info!("Creating end node with label: {}", label);
+            log::trace!("Creating end node with label: {}", label);
             create_node_with_label(&label, 1)
         });
 
@@ -756,7 +756,7 @@ fn transform_to_path(
             .first()
             .cloned()
             .unwrap_or_else(|| "_UNKNOWN".to_string());
-        log::info!("Creating relationship with type: {}", rel_type);
+        log::trace!("Creating relationship with type: {}", rel_type);
         create_relationship_with_type(&rel_type, &start_node.element_id, &end_node.element_id)
     });
 

src/server/bolt_protocol/websocket.rs

@@ -79,10 +79,8 @@ impl AsyncRead for WebSocketBoltAdapter {
             }
             Poll::Ready(Some(Ok(Message::Close(_)))) => {
                 log::debug!("WebSocket close message received");
-                Poll::Ready(Err(io::Error::new(
-                    io::ErrorKind::ConnectionAborted,
-                    "WebSocket closed",
-                )))
+                // Signal EOF for graceful disconnect instead of error
+                Poll::Ready(Ok(()))
             }
             Poll::Ready(Some(Ok(Message::Ping(_)))) | Poll::Ready(Some(Ok(Message::Pong(_)))) => {
                 // Handled automatically by tungstenite, poll again