mirror of
https://github.com/aljazceru/turso.git
synced 2026-01-07 18:24:20 +01:00
7c07c09300
Currently our "table id"/"table no"/"table idx" references always
use the direct index of the `TableReference` in the plan, e.g. in
`SelectPlan::table_references`. For example:
```rust
Expr::Column { table: 0, column: 3, .. }
```
refers to the 0'th table in the `table_references` list.
This is a fragile approach because it assumes the table_references
list is stable for the lifetime of the query processing. This has so
far been the case, but there exist certain query transformations,
e.g. subquery unnesting, that may fold new table references from
a subquery (which has its own table ref list) into the table reference
list of the parent.
If such a transformation is made, then potentially all of the Expr::Column
references to tables will become invalid. Consider this example:
```sql
-- Assume tables: users(id, age), orders(user_id, amount)
-- Get total amount spent per user on orders over $100
SELECT u.id, sub.total
FROM users u JOIN
(SELECT user_id, SUM(amount) as total
FROM orders o
WHERE o.amount > 100
GROUP BY o.user_id) sub
WHERE u.id = sub.user_id
-- Before subquery unnesting:
-- Main query table_references: [users, sub]
-- u.id refers to table 0, column 0
-- sub.total refers to table 1, column 1
--
-- Subquery table_references: [orders]
-- o.user_id refers to table 0, column 0
-- o.amount refers to table 0, column 1
--
-- After unnesting and folding subquery tables into main query,
-- the query might look like this:
SELECT u.id, SUM(o.amount) as total
FROM users u JOIN orders o ON u.id = o.user_id
WHERE o.amount > 100
GROUP BY u.id;
-- Main query table_references: [users, orders]
-- u.id refers to table index 0 (correct)
-- o.amount refers to table index 0 (incorrect, should be 1)
-- o.user_id refers to table index 0 (incorrect, should be 1)
```
We could ofc traverse every expression in the subquery and rewrite
the table indexes to be correct, but if we instead use stable identifiers
for each table reference, then all the column references will continue
to be correct.
Hence, this PR introduces a `TableInternalId` used in `TableReference`
as well as `Expr::Column` and `Expr::Rowid` so that this kind of query
transformations can happen with less pain.
111 lines
3.3 KiB
Rust
111 lines
3.3 KiB
Rust
use crate::schema::Table;
|
|
use crate::translate::emitter::emit_program;
|
|
use crate::translate::optimizer::optimize_plan;
|
|
use crate::translate::plan::{DeletePlan, Operation, Plan};
|
|
use crate::translate::planner::{parse_limit, parse_where};
|
|
use crate::vdbe::builder::{ProgramBuilder, ProgramBuilderOpts, QueryMode, TableRefIdCounter};
|
|
use crate::{schema::Schema, Result, SymbolTable};
|
|
use limbo_sqlite3_parser::ast::{Expr, Limit, QualifiedName};
|
|
|
|
use super::plan::{ColumnUsedMask, IterationDirection, TableReference};
|
|
|
|
pub fn translate_delete(
|
|
query_mode: QueryMode,
|
|
schema: &Schema,
|
|
tbl_name: &QualifiedName,
|
|
where_clause: Option<Box<Expr>>,
|
|
limit: Option<Box<Limit>>,
|
|
syms: &SymbolTable,
|
|
mut program: ProgramBuilder,
|
|
) -> Result<ProgramBuilder> {
|
|
let mut delete_plan = prepare_delete_plan(
|
|
schema,
|
|
tbl_name,
|
|
where_clause,
|
|
limit,
|
|
&mut program.table_reference_counter,
|
|
)?;
|
|
optimize_plan(&mut delete_plan, schema)?;
|
|
let Plan::Delete(ref delete) = delete_plan else {
|
|
panic!("delete_plan is not a DeletePlan");
|
|
};
|
|
let opts = ProgramBuilderOpts {
|
|
query_mode,
|
|
num_cursors: 1,
|
|
approx_num_insns: estimate_num_instructions(delete),
|
|
approx_num_labels: 0,
|
|
};
|
|
program.extend(&opts);
|
|
emit_program(&mut program, delete_plan, syms)?;
|
|
Ok(program)
|
|
}
|
|
|
|
pub fn prepare_delete_plan(
|
|
schema: &Schema,
|
|
tbl_name: &QualifiedName,
|
|
where_clause: Option<Box<Expr>>,
|
|
limit: Option<Box<Limit>>,
|
|
table_ref_counter: &mut TableRefIdCounter,
|
|
) -> Result<Plan> {
|
|
let table = match schema.get_table(tbl_name.name.0.as_str()) {
|
|
Some(table) => table,
|
|
None => crate::bail_corrupt_error!("Parse error: no such table: {}", tbl_name),
|
|
};
|
|
let table = if let Some(table) = table.virtual_table() {
|
|
Table::Virtual(table.clone())
|
|
} else if let Some(table) = table.btree() {
|
|
Table::BTree(table.clone())
|
|
} else {
|
|
crate::bail_corrupt_error!("Table is neither a virtual table nor a btree table");
|
|
};
|
|
let name = tbl_name.name.0.as_str().to_string();
|
|
let indexes = schema
|
|
.get_indices(table.get_name())
|
|
.iter()
|
|
.cloned()
|
|
.collect();
|
|
let mut table_references = vec![TableReference {
|
|
table,
|
|
identifier: name,
|
|
internal_id: table_ref_counter.next(),
|
|
op: Operation::Scan {
|
|
iter_dir: IterationDirection::Forwards,
|
|
index: None,
|
|
},
|
|
join_info: None,
|
|
col_used_mask: ColumnUsedMask::new(),
|
|
}];
|
|
|
|
let mut where_predicates = vec![];
|
|
|
|
// Parse the WHERE clause
|
|
parse_where(
|
|
where_clause.map(|e| *e),
|
|
&mut table_references,
|
|
None,
|
|
&mut where_predicates,
|
|
)?;
|
|
|
|
// Parse the LIMIT/OFFSET clause
|
|
let (resolved_limit, resolved_offset) = limit.map_or(Ok((None, None)), |l| parse_limit(&l))?;
|
|
|
|
let plan = DeletePlan {
|
|
table_references,
|
|
result_columns: vec![],
|
|
where_clause: where_predicates,
|
|
order_by: None,
|
|
limit: resolved_limit,
|
|
offset: resolved_offset,
|
|
contains_constant_false_condition: false,
|
|
indexes,
|
|
};
|
|
|
|
Ok(Plan::Delete(plan))
|
|
}
|
|
|
|
fn estimate_num_instructions(plan: &DeletePlan) -> usize {
|
|
let base = 20;
|
|
|
|
base + plan.table_references.len() * 10
|
|
}
|