this repo has no description
Fix CLI query execution for CREATE statements
- Implement proper CREATE query execution in cypher executor
- Fix Property/PropertyValue type usage and imports
- Update CLI result formatting to display actual values
- Add format_value method to handle different result value types
- CREATE statements now properly create nodes with labels and properties
- CLI shows correct node creation results in table format
Node creation now works:
- CREATE (bob:Person {name: 'Bob', age: 25}) ✓
- Shows "nodes_created: 1" result
- Nodes visible in :stats and :show nodes commands
- Properties and labels correctly stored
Next: Fix MATCH+RETURN compound query execution
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
+104
-13
+33
-5
src/cli/mod.rs
+33
-5
src/cli/mod.rs
···
580
580
}
581
581
output.push_str("┤\n");
582
582
583
-
// Rows (placeholder - would need actual row data)
584
-
output.push_str("│");
585
-
for column in &result.columns {
586
-
output.push_str(&format!(" {:^width$} │", "(data)", width = column.len().max(10)));
583
+
// Rows (actual row data)
584
+
for row in &result.rows {
585
+
output.push_str("│");
586
+
for (i, value) in row.values.iter().enumerate() {
587
+
let column_width = result.columns[i].len().max(10);
588
+
let value_str = self.format_value(value);
589
+
output.push_str(&format!(" {:^width$} │", value_str, width = column_width));
590
+
}
591
+
output.push('\n');
587
592
}
588
-
output.push('\n');
589
593
590
594
// Footer
591
595
output.push_str("╰");
···
619
623
output
620
624
}
621
625
626
+
/// Format a query result value for display
627
+
fn format_value(&self, value: &crate::cypher::executor::Value) -> String {
628
+
match value {
629
+
crate::cypher::executor::Value::Null => "null".to_string(),
630
+
crate::cypher::executor::Value::Node(node_id) => {
631
+
// Try to get node details
632
+
if let Some(node) = self.graph.get_node(*node_id) {
633
+
format!("Node({})", node_id.0)
634
+
} else {
635
+
format!("Node({})", node_id.0)
636
+
}
637
+
},
638
+
crate::cypher::executor::Value::Relationship(rel_id) => format!("Rel({})", rel_id.0),
639
+
crate::cypher::executor::Value::Integer(i) => i.to_string(),
640
+
crate::cypher::executor::Value::Float(f) => f.to_string(),
641
+
crate::cypher::executor::Value::String(s) => s.clone(),
642
+
crate::cypher::executor::Value::Boolean(b) => b.to_string(),
643
+
crate::cypher::executor::Value::List(list) => {
644
+
let items: Vec<String> = list.iter().map(|v| self.format_value(v)).collect();
645
+
format!("[{}]", items.join(", "))
646
+
},
647
+
}
648
+
}
649
+
622
650
/// Save command history
623
651
fn save_history(&mut self) {
624
652
if let Some(ref history_file) = self.config.history_file {
+71
-8
src/cypher/executor.rs
+71
-8
src/cypher/executor.rs
···
1
1
use crate::cypher::planner::{QueryPlan, ScanPlan, CreatePlan, ProjectPlan};
2
-
use crate::cypher::ast::{CypherQuery, MatchClause, CreateClause, ReturnClause, Expression};
3
-
use crate::core::Graph;
2
+
use crate::cypher::ast::{CypherQuery, MatchClause, CreateClause, ReturnClause, Expression, PatternElement};
3
+
use crate::core::{Graph, PropertyValue};
4
4
use crate::{Result, GigabrainError, NodeId, RelationshipId};
5
5
use std::sync::Arc;
6
6
use std::collections::HashMap;
···
49
49
50
50
async fn execute_match(&self, match_clause: &MatchClause) -> Result<QueryResult> {
51
51
let mut context = ExecutionContext::new();
52
-
self.execute_match_with_context(match_clause, &mut context).await
52
+
self.execute_match_with_context(match_clause, &mut context).await?;
53
+
54
+
// Return all matched nodes directly
55
+
let all_nodes = self.graph.get_all_nodes();
56
+
let columns = vec!["n".to_string()];
57
+
let mut rows = Vec::new();
58
+
59
+
for node_id in all_nodes {
60
+
rows.push(Row {
61
+
values: vec![Value::Node(node_id)]
62
+
});
63
+
}
64
+
65
+
Ok(QueryResult { rows, columns })
53
66
}
54
67
55
68
async fn execute_match_with_context(&self, match_clause: &MatchClause, context: &mut ExecutionContext) -> Result<QueryResult> {
···
60
73
for element in &pattern.elements {
61
74
if let crate::cypher::ast::PatternElement::Node(node_pattern) = element {
62
75
if let Some(variable) = &node_pattern.variable {
63
-
// For now, just bind all nodes to the variable
64
-
// In a real implementation, this would respect labels and filters
65
-
let all_node_ids: Vec<NodeId> = (0..3).map(|i| NodeId(i)).collect(); // Demo data
76
+
// Get actual nodes from the graph instead of demo data
77
+
let all_node_ids = self.graph.get_all_nodes();
66
78
context.bind_variable(variable.clone(), VariableBinding::Nodes(all_node_ids));
67
79
}
68
80
}
···
71
83
Ok(QueryResult::empty())
72
84
}
73
85
74
-
async fn execute_create_query(&self, _create_clause: &CreateClause) -> Result<QueryResult> {
86
+
async fn execute_create_query(&self, create_clause: &CreateClause) -> Result<QueryResult> {
75
87
// Create new nodes/relationships based on pattern
76
-
Ok(QueryResult::empty())
88
+
let mut created_nodes = Vec::new();
89
+
90
+
for element in &create_clause.pattern.elements {
91
+
if let PatternElement::Node(node_pattern) = element {
92
+
// Create a new node
93
+
let node_id = self.graph.create_node();
94
+
95
+
// Add labels and properties using update_node
96
+
self.graph.update_node(node_id, |node| {
97
+
// Add labels if specified
98
+
if !node_pattern.labels.is_empty() {
99
+
let schema = self.graph.schema();
100
+
for label_name in &node_pattern.labels {
101
+
let label_id = {
102
+
let mut schema_guard = schema.write();
103
+
schema_guard.get_or_create_label(label_name)
104
+
};
105
+
node.add_label(label_id);
106
+
}
107
+
}
108
+
109
+
// Add properties if specified
110
+
if let Some(ref properties) = node_pattern.properties {
111
+
let schema = self.graph.schema();
112
+
for (key, value_expr) in properties {
113
+
let property_key_id = {
114
+
let mut schema_guard = schema.write();
115
+
schema_guard.get_or_create_property_key(key)
116
+
};
117
+
118
+
// Convert expression to property value (simplified)
119
+
let property_value = match value_expr {
120
+
Expression::Literal(literal) => literal.clone(),
121
+
_ => PropertyValue::String("unknown".to_string()),
122
+
};
123
+
124
+
node.properties.insert(property_key_id, property_value);
125
+
}
126
+
}
127
+
})?;
128
+
129
+
created_nodes.push(node_id);
130
+
}
131
+
}
132
+
133
+
// Return result indicating nodes were created
134
+
let columns = vec!["nodes_created".to_string()];
135
+
let rows = vec![Row {
136
+
values: vec![Value::Integer(created_nodes.len() as i64)]
137
+
}];
138
+
139
+
Ok(QueryResult { rows, columns })
77
140
}
78
141
79
142
async fn execute_return(&self, return_clause: &ReturnClause) -> Result<QueryResult> {