akar_processor/processor/
plan_serializer.rs

1use akar_planner::logical_operator::LogicalOperator;
2
3#[allow(unreachable_patterns)]
4pub fn serialize_plan_tree(op: &LogicalOperator, depth: usize) -> String {
5    let indent = "  ".repeat(depth);
6    let prefix = if depth > 0 { "├─ " } else { "" };
7
8    let op_name = match op {
9        LogicalOperator::ScanNode(s) => format!("ScanNode({})", s.table_name),
10        LogicalOperator::ScanRel(s) => format!("ScanRel({})", s.table_name),
11        LogicalOperator::Filter(_) => "Filter".to_string(),
12        LogicalOperator::Projection(p) => format!("Projection({} cols)", p.expressions.len()),
13        LogicalOperator::HashJoin(hj) => format!("HashJoin({} keys)", hj.join_keys.len()),
14        LogicalOperator::CrossProduct(_) => "CrossProduct".to_string(),
15        LogicalOperator::OrderBy(ob) => format!("OrderBy({} keys)", ob.sort_keys.len()),
16        LogicalOperator::TopK(tk) => format!(
17            "TopK(limit={}, offset={}, {} keys)",
18            tk.limit,
19            tk.offset,
20            tk.sort_keys.len()
21        ),
22        LogicalOperator::Limit(l) => format!("Limit({})", l.limit),
23        LogicalOperator::Aggregate(a) => {
24            format!("Aggregate({} aggs, {} group_by)", a.aggregates.len(), a.group_by.len())
25        }
26        LogicalOperator::Union(u) => format!("Union({})", if u.all { "ALL" } else { "DISTINCT" }),
27        LogicalOperator::Flatten(_) => "Flatten".to_string(),
28        LogicalOperator::TableFunctionCall(tf) => format!("TableFunctionCall({})", tf.function_name),
29        LogicalOperator::CopyFrom(cf) => format!("CopyFrom({})", cf.table_name),
30        LogicalOperator::BatchInsert(bi) => format!("BatchInsert({}, {} rows)", bi.table_name, bi.rows.len()),
31        LogicalOperator::IndexLookup(il) => format!("IndexLookup({})", il.table_name),
32        LogicalOperator::Delete(dl) => format!("Delete({})", dl.table_name),
33        LogicalOperator::Set(sl) => format!(
34            "Set({}.{})",
35            sl.table_name,
36            sl.items.first().map(|i| i.column_name.as_str()).unwrap_or("?")
37        ),
38        LogicalOperator::OptionalMatch(_) => "OptionalMatch".to_string(),
39        LogicalOperator::OptionalExtend(oe) => {
40            format!("OptionalExtend({} via {})", oe.rel_var, oe.rel_table_name)
41        }
42        LogicalOperator::Unwind(uw) => format!("Unwind({})", uw.variable),
43        LogicalOperator::Foreach(fe) => format!("Foreach({})", fe.variable),
44        LogicalOperator::Merge(m) => format!("Merge({})", m.table_name),
45        LogicalOperator::MergeRel(mr) => format!("MergeRel({})", mr.rel_table_name),
46        LogicalOperator::SemiJoin(_) => "SemiJoin".to_string(),
47        LogicalOperator::AntiJoin(_) => "AntiJoin".to_string(),
48        LogicalOperator::VectorSimilarityScan(vs) => format!("VectorSimilarityScan(k={})", vs.top_k),
49        LogicalOperator::ArtIndexRangeScan(ars) => format!("ArtIndexRangeScan({})", ars.table_name),
50        LogicalOperator::Explain(_) => "Explain".to_string(),
51        LogicalOperator::Intersect(_) => "Intersect".to_string(),
52        LogicalOperator::RecursiveExtend(re) => {
53            format!("RecursiveExtend({}..{})", re.lower_bound, re.upper_bound)
54        }
55        LogicalOperator::Accumulate(ac) => format!("Accumulate({:?})", ac.accumulate_type),
56        LogicalOperator::ExpressionsScan(es) => format!("ExpressionsScan({} vars)", es.expressions.len()),
57        LogicalOperator::CountRelTable(crt) => format!("CountRelTable({})", crt.table_name),
58        LogicalOperator::CreateNodeTable(ct) => format!("CreateNodeTable({})", ct.name),
59        LogicalOperator::CreateRelTable(ct) => format!("CreateRelTable({})", ct.name),
60        LogicalOperator::DropTable(dt) => format!("DropTable({})", dt.name),
61        LogicalOperator::AlterTable(at) => format!("AlterTable({})", at.table_name),
62        LogicalOperator::CreateIndex(ci) => format!("CreateIndex({})", ci.index_name),
63        LogicalOperator::DropIndex(di) => format!("DropIndex({})", di.index_name),
64        LogicalOperator::CreateVectorIndex(vi) => format!("CreateVectorIndex({})", vi.index_name),
65        LogicalOperator::CreateSequence(cs) => format!("CreateSequence({})", cs.name),
66        LogicalOperator::DropSequence(ds) => format!("DropSequence({})", ds.name),
67        LogicalOperator::CreateDml(cd) => format!("CreateDml({})", cd.table_name),
68        LogicalOperator::CreateNode(cn) => format!("CreateNode({})", cn.table_name),
69        LogicalOperator::CreateRel(cr) => format!("CreateRel({})", cr.table_name),
70        LogicalOperator::Extend(ex) => format!(
71            "Extend({}->{} via {})",
72            ex.bound_node_var, ex.dst_node_var, ex.rel_table_name
73        ),
74        LogicalOperator::ExportDatabase(ed) => format!("ExportDatabase({})", ed.file_path),
75        LogicalOperator::ImportDatabase(id) => format!("ImportDatabase({})", id.file_path),
76        LogicalOperator::CreateFtsIndex(c) => format!("CreateFtsIndex({})", c.index_name),
77        LogicalOperator::FtsScan(s) => format!("FtsScan({})", s.index_name),
78        _ => format!("{:?}", op),
79    };
80
81    let card_str = format!("[cardinality={}]", op.cardinality());
82    let mut result = format!("{indent}{prefix}{op_name} {card_str}\n");
83
84    let children = op.children();
85    for (i, child) in children.iter().enumerate() {
86        let child_str = serialize_plan_tree(child, depth + 1);
87        if i == children.len() - 1 {
88            let adjusted = child_str.replacen("├─ ", "└─ ", 1);
89            result.push_str(&adjusted);
90        } else {
91            result.push_str(&child_str);
92        }
93    }
94
95    result
96}
akar_processor/processor/plan_serializer.rs

akar_processor/processor/
plan_serializer.rs
