use super::trait_def::PlanVisitor;
use crate::types::SqlPlan;
pub fn dispatch<V: PlanVisitor>(visitor: &mut V, plan: &SqlPlan) -> Result<V::Output, V::Error> {
match plan {
SqlPlan::ConstantResult { columns, values } => visitor.constant_result(columns, values),
SqlPlan::Scan {
collection,
alias,
engine,
filters,
projection,
sort_keys,
limit,
offset,
distinct,
window_functions,
temporal,
} => visitor.scan(
collection,
alias.as_deref(),
*engine,
filters,
projection,
sort_keys,
*limit,
*offset,
*distinct,
window_functions,
temporal,
),
SqlPlan::PointGet {
collection,
alias,
engine,
key_column,
key_value,
} => visitor.point_get(collection, alias.as_deref(), *engine, key_column, key_value),
SqlPlan::DocumentIndexLookup {
collection,
alias,
engine,
field,
value,
filters,
projection,
sort_keys,
limit,
offset,
distinct,
window_functions,
case_insensitive,
temporal,
} => visitor.document_index_lookup(
collection,
alias.as_deref(),
*engine,
field,
value,
filters,
projection,
sort_keys,
*limit,
*offset,
*distinct,
window_functions,
*case_insensitive,
temporal,
),
SqlPlan::RangeScan {
collection,
field,
lower,
upper,
limit,
} => visitor.range_scan(collection, field, lower.as_ref(), upper.as_ref(), *limit),
SqlPlan::Insert {
collection,
engine,
rows,
column_defaults,
if_absent,
column_schema,
} => visitor.insert(
collection,
*engine,
rows,
column_defaults,
*if_absent,
column_schema,
),
SqlPlan::KvInsert {
collection,
entries,
ttl_secs,
intent,
on_conflict_updates,
} => visitor.kv_insert(collection, entries, *ttl_secs, *intent, on_conflict_updates),
SqlPlan::Upsert {
collection,
engine,
rows,
column_defaults,
on_conflict_updates,
column_schema,
} => visitor.upsert(
collection,
*engine,
rows,
column_defaults,
on_conflict_updates,
column_schema,
),
SqlPlan::InsertSelect {
target,
source,
limit,
} => visitor.insert_select(target, source, *limit),
SqlPlan::Update {
collection,
engine,
assignments,
filters,
target_keys,
returning,
} => visitor.update(
collection,
*engine,
assignments,
filters,
target_keys,
*returning,
),
SqlPlan::UpdateFrom {
collection,
engine,
source,
target_join_col,
source_join_col,
assignments,
target_filters,
returning,
} => visitor.update_from(
collection,
*engine,
source,
target_join_col,
source_join_col,
assignments,
target_filters,
*returning,
),
SqlPlan::Delete {
collection,
engine,
filters,
target_keys,
} => visitor.delete(collection, *engine, filters, target_keys),
SqlPlan::Truncate {
collection,
restart_identity,
} => visitor.truncate(collection, *restart_identity),
SqlPlan::Join {
left,
right,
on,
join_type,
condition,
limit,
projection,
filters,
} => visitor.join(
left,
right,
on,
*join_type,
condition.as_ref(),
*limit,
projection,
filters,
),
SqlPlan::Aggregate {
input,
group_by,
aggregates,
having,
limit,
grouping_sets,
sort_keys,
} => visitor.aggregate(
input,
group_by,
aggregates,
having,
*limit,
grouping_sets.as_deref(),
sort_keys,
),
SqlPlan::TimeseriesScan {
collection,
time_range,
bucket_interval_ms,
group_by,
aggregates,
filters,
projection,
gap_fill,
limit,
tiered,
temporal,
} => visitor.timeseries_scan(
collection,
*time_range,
*bucket_interval_ms,
group_by,
aggregates,
filters,
projection,
gap_fill,
*limit,
*tiered,
temporal,
),
SqlPlan::TimeseriesIngest { collection, rows } => {
visitor.timeseries_ingest(collection, rows)
}
SqlPlan::VectorSearch {
collection,
field,
query_vector,
top_k,
ef_search,
metric,
filters,
array_prefilter,
ann_options,
skip_payload_fetch,
payload_filters,
} => visitor.vector_search(
collection,
field,
query_vector,
*top_k,
*ef_search,
*metric,
filters,
array_prefilter.as_ref(),
ann_options,
*skip_payload_fetch,
payload_filters,
),
SqlPlan::MultiVectorSearch {
collection,
query_vector,
top_k,
ef_search,
} => visitor.multi_vector_search(collection, query_vector, *top_k, *ef_search),
SqlPlan::TextSearch {
collection,
query,
top_k,
filters,
score_alias,
} => visitor.text_search(collection, query, *top_k, filters, score_alias.as_deref()),
SqlPlan::HybridSearch {
collection,
query_vector,
query_text,
top_k,
ef_search,
vector_weight,
fuzzy,
score_alias,
} => visitor.hybrid_search(
collection,
query_vector,
query_text,
*top_k,
*ef_search,
*vector_weight,
*fuzzy,
score_alias.as_deref(),
),
SqlPlan::HybridSearchTriple {
collection,
query_vector,
query_text,
graph_seed_id,
graph_depth,
graph_edge_label,
top_k,
ef_search,
fuzzy,
rrf_k,
score_alias,
} => visitor.hybrid_search_triple(
collection,
query_vector,
query_text,
graph_seed_id,
*graph_depth,
graph_edge_label.as_deref(),
*top_k,
*ef_search,
*fuzzy,
*rrf_k,
score_alias.as_deref(),
),
SqlPlan::SpatialScan {
collection,
field,
predicate,
query_geometry,
distance_meters,
attribute_filters,
limit,
projection,
} => visitor.spatial_scan(
collection,
field,
predicate,
query_geometry,
*distance_meters,
attribute_filters,
*limit,
projection,
),
SqlPlan::Union { inputs, distinct } => visitor.union(inputs, *distinct),
SqlPlan::Intersect { left, right, all } => visitor.intersect(left, right, *all),
SqlPlan::Except { left, right, all } => visitor.except(left, right, *all),
SqlPlan::RecursiveScan {
collection,
base_filters,
recursive_filters,
join_link,
max_iterations,
distinct,
limit,
} => visitor.recursive_scan(
collection,
base_filters,
recursive_filters,
join_link.as_ref(),
*max_iterations,
*distinct,
*limit,
),
SqlPlan::RecursiveValue {
cte_name,
columns,
init_exprs,
step_exprs,
condition,
max_depth,
distinct,
} => visitor.recursive_value(
cte_name,
columns,
init_exprs,
step_exprs,
condition.as_deref(),
*max_depth,
*distinct,
),
SqlPlan::Cte { definitions, outer } => visitor.cte(definitions, outer),
SqlPlan::CreateArray {
name,
dims,
attrs,
tile_extents,
cell_order,
tile_order,
prefix_bits,
audit_retain_ms,
minimum_audit_retain_ms,
} => visitor.create_array(
name,
dims,
attrs,
tile_extents,
*cell_order,
*tile_order,
*prefix_bits,
*audit_retain_ms,
*minimum_audit_retain_ms,
),
SqlPlan::DropArray { name, if_exists } => visitor.drop_array(name, *if_exists),
SqlPlan::AlterArray {
name,
audit_retain_ms,
minimum_audit_retain_ms,
} => visitor.alter_array(name, *audit_retain_ms, *minimum_audit_retain_ms),
SqlPlan::InsertArray { name, rows } => visitor.insert_array(name, rows),
SqlPlan::DeleteArray { name, coords } => visitor.delete_array(name, coords),
SqlPlan::ArraySlice {
name,
slice,
attr_projection,
limit,
temporal,
} => visitor.array_slice(name, slice, attr_projection, *limit, temporal),
SqlPlan::ArrayProject {
name,
attr_projection,
} => visitor.array_project(name, attr_projection),
SqlPlan::ArrayAgg {
name,
attr,
reducer,
group_by_dim,
temporal,
} => visitor.array_agg(name, attr, reducer, group_by_dim.as_deref(), temporal),
SqlPlan::ArrayElementwise {
left,
right,
op,
attr,
} => visitor.array_elementwise(left, right, *op, attr),
SqlPlan::ArrayFlush { name } => visitor.array_flush(name),
SqlPlan::ArrayCompact { name } => visitor.array_compact(name),
SqlPlan::Merge {
target,
engine,
source,
target_join_col,
source_join_col,
source_alias,
clauses,
returning,
} => visitor.merge(
target,
*engine,
source,
target_join_col,
source_join_col,
source_alias,
clauses,
*returning,
),
SqlPlan::LateralTopK {
outer,
outer_alias,
inner_collection,
inner_filters,
inner_order_by,
inner_limit,
correlation_keys,
lateral_alias,
projection,
left_join,
} => visitor.lateral_top_k(
outer,
outer_alias.as_deref(),
inner_collection,
inner_filters,
inner_order_by,
*inner_limit,
correlation_keys,
lateral_alias,
projection,
*left_join,
),
SqlPlan::LateralLoop {
outer,
outer_alias,
inner,
correlation_predicates,
lateral_alias,
projection,
outer_row_cap,
left_join,
} => visitor.lateral_loop(
outer,
outer_alias.as_deref(),
inner,
correlation_predicates,
lateral_alias,
projection,
*outer_row_cap,
*left_join,
),
SqlPlan::VectorPrimaryInsert {
collection,
field,
quantization,
storage_dtype,
payload_indexes,
rows,
} => visitor.vector_primary_insert(
collection,
field,
quantization,
storage_dtype,
payload_indexes,
rows,
),
SqlPlan::CreateIndex {
index_name,
collection,
field,
unique,
if_not_exists,
case_insensitive,
} => visitor.create_index(
index_name.as_deref(),
collection,
field,
*unique,
*if_not_exists,
*case_insensitive,
),
SqlPlan::DropIndex {
index_name,
collection,
if_exists,
} => visitor.drop_index(index_name, collection.as_deref(), *if_exists),
}
}