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!("Set({}.{})", sl.table_name, sl.column_name),
34        LogicalOperator::OptionalMatch(_) => "OptionalMatch".to_string(),
35        LogicalOperator::Unwind(uw) => format!("Unwind({})", uw.variable),
36        LogicalOperator::Foreach(fe) => format!("Foreach({})", fe.variable),
37        LogicalOperator::Merge(m) => format!("Merge({})", m.table_name),
38        LogicalOperator::SemiJoin(_) => "SemiJoin".to_string(),
39        LogicalOperator::AntiJoin(_) => "AntiJoin".to_string(),
40        LogicalOperator::VectorSimilarityScan(vs) => format!("VectorSimilarityScan(k={})", vs.top_k),
41        LogicalOperator::ArtIndexRangeScan(ars) => format!("ArtIndexRangeScan({})", ars.table_name),
42        LogicalOperator::Explain(_) => "Explain".to_string(),
43        LogicalOperator::Intersect(_) => "Intersect".to_string(),
44        LogicalOperator::RecursiveExtend(re) => {
45            format!("RecursiveExtend({}..{})", re.lower_bound, re.upper_bound)
46        }
47        LogicalOperator::Accumulate(ac) => format!("Accumulate({:?})", ac.accumulate_type),
48        LogicalOperator::ExpressionsScan(es) => format!("ExpressionsScan({} vars)", es.expressions.len()),
49        LogicalOperator::CountRelTable(crt) => format!("CountRelTable({})", crt.table_name),
50        LogicalOperator::CreateNodeTable(ct) => format!("CreateNodeTable({})", ct.name),
51        LogicalOperator::CreateRelTable(ct) => format!("CreateRelTable({})", ct.name),
52        LogicalOperator::DropTable(dt) => format!("DropTable({})", dt.name),
53        LogicalOperator::AlterTable(at) => format!("AlterTable({})", at.table_name),
54        LogicalOperator::CreateIndex(ci) => format!("CreateIndex({})", ci.index_name),
55        LogicalOperator::DropIndex(di) => format!("DropIndex({})", di.index_name),
56        LogicalOperator::CreateVectorIndex(vi) => format!("CreateVectorIndex({})", vi.index_name),
57        LogicalOperator::CreateSequence(cs) => format!("CreateSequence({})", cs.name),
58        LogicalOperator::DropSequence(ds) => format!("DropSequence({})", ds.name),
59        LogicalOperator::CreateDml(cd) => format!("CreateDml({})", cd.table_name),
60        LogicalOperator::CreateNode(cn) => format!("CreateNode({})", cn.table_name),
61        LogicalOperator::CreateRel(cr) => format!("CreateRel({})", cr.table_name),
62        LogicalOperator::Extend(ex) => format!(
63            "Extend({}->{} via {})",
64            ex.bound_node_var, ex.dst_node_var, ex.rel_table_name
65        ),
66        LogicalOperator::ExportDatabase(ed) => format!("ExportDatabase({})", ed.file_path),
67        LogicalOperator::ImportDatabase(id) => format!("ImportDatabase({})", id.file_path),
68        LogicalOperator::CreateFtsIndex(c) => format!("CreateFtsIndex({})", c.index_name),
69        LogicalOperator::FtsScan(s) => format!("FtsScan({})", s.index_name),
70        _ => format!("{:?}", op),
71    };
72
73    let card_str = format!("[cardinality={}]", op.cardinality());
74    let mut result = format!("{indent}{prefix}{op_name} {card_str}\n");
75
76    let children = op.children();
77    for (i, child) in children.iter().enumerate() {
78        let child_str = serialize_plan_tree(child, depth + 1);
79        if i == children.len() - 1 {
80            let adjusted = child_str.replacen("├─ ", "└─ ", 1);
81            result.push_str(&adjusted);
82        } else {
83            result.push_str(&child_str);
84        }
85    }
86
87    result
88}
akar_processor/processor/plan_serializer.rs

akar_processor/processor/
plan_serializer.rs
