omedusyo/minisql
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplify select_all and delete_all

Browse source
This commit is contained in:
Yuriy Dupyn 2023-12-29 06:33:30 +01:00
parent 6b58c3cb9b
commit f9b874f302
2 changed files with 86 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

2
minisql/src/interpreter.rs
View file

@ -86,7 +86,7 @@ impl State {
Delete(table_name, maybe_condition) => {
let table: &mut Table = self.table_from_name_mut(&table_name)?;
let rows_affected = table.delete_where(maybe_condition)?;
let rows_affected = table.delete_rows_where(maybe_condition)?;
Ok(Response::Deleted(rows_affected))
},
CreateTable(table_name, table_schema) => {

146
minisql/src/table.rs
View file

@ -17,16 +17,13 @@ pub struct Table {
}
// Use `ColumnPosition` as index
pub type Row = Vec<DbValue>;
pub type Rows =
// TODO: This should be some sort of an interface to a dictionary
// s.t. in the background it may modify stuff in memory or talk to the disk
BTreeMap<UUID, Row>;
// interface
// insert(id, value)
// Use `ColumnPosition` as index
pub type Row = Vec<DbValue>;
fn restrict_columns(row: &Row, columns: &Vec<ColumnPosition>) -> Row {
// If the index from `columns` is non-existant in `row`, it will just ignore it.
@ -51,10 +48,7 @@ impl Table {
}
}
pub fn attach_index(&mut self, column_position: ColumnPosition, column_index: ColumnIndex) {
self.indexes.insert(column_position, column_index);
}
// ======Selection======
fn get_row_by_id(&self, id: UUID) -> Option<Row> {
self.rows.get(&id).cloned()
}
@ -72,6 +66,61 @@ impl Table {
.collect()
}
fn select_all_rows(&self, selected_column_positions: &Vec<ColumnPosition>) -> Vec<Row> {
self.rows.values().map(|row| restrict_columns(row, &selected_column_positions)).collect()
}
fn select_rows_where_eq(&self, selected_column_positions: &Vec<ColumnPosition>, column_position: ColumnPosition, value: DbValue) -> DbResult<Vec<Row>> {
match value {
DbValue::Indexable(value) => {
match self.fetch_ids_from_index(column_position, &value)? {
Some(ids) =>
Ok(self.get_rows_by_ids(ids).iter().map(|row| restrict_columns(row, &selected_column_positions)).collect()),
None =>
Ok(self.get_rows_by_value(column_position, &DbValue::Indexable(value)).iter().map(|row| restrict_columns(row, &selected_column_positions)).collect())
}
},
_ => {
Ok(self.get_rows_by_value(column_position, &value).iter().map(|row| restrict_columns(row, &selected_column_positions)).collect())
}
}
}
pub fn select_where(&self, column_selection: ColumnSelection, condition: Option<Condition>) -> DbResult<Vec<Row>> {
let selected_column_positions: Vec<ColumnPosition> = self.schema.column_positions_from_column_selection(&column_selection)?;
match condition {
None => Ok(self.select_all_rows(&selected_column_positions)),
Some(Condition::Eq(eq_column_name, value)) => {
let eq_column_position = self.schema.column_position_from_column_name(&eq_column_name)?;
self.select_rows_where_eq(&selected_column_positions, eq_column_position, value)
}
}
}
// ======Insertion======
pub fn insert(&mut self, values: InsertionValues) -> DbResult<()> {
let (id, row) = self.schema.row_from_insertion_values(values)?;
if self.rows.get(&id).is_some() {
return Err(Error::AttemptingToInsertAlreadyPresentId(self.schema.table_name.clone(), id))
}
for (column_position, column_index) in &mut self.indexes {
match row.get(*column_position) {
Some(DbValue::Indexable(val)) => {
column_index.add(val.clone(), id)
},
Some(_) => {},
None => return Err(Error::ColumnPositionDoesNotExist(self.schema.table_name.clone(), *column_position))
}
}
let _ = self.rows.insert(id, row);
Ok(())
}
// ======Deletion======
fn delete_row_by_id(&mut self, id: UUID) -> usize {
match self.rows.remove(&id) {
Some(row) => {
@ -101,80 +150,41 @@ impl Table {
self.delete_rows_by_ids(matched_ids)
}
pub fn select_where(&self, column_selection: ColumnSelection, condition: Option<Condition>) -> DbResult<Vec<Row>> {
let selected_column_positions = self.schema.column_positions_from_column_selection(&column_selection)?;
match condition {
None =>
// select all
Ok(self.rows.values().map(|row| restrict_columns(row, &selected_column_positions)).collect()),
Some(Condition::Eq(eq_column_name, value)) => {
let eq_column_position = self.schema.column_position_from_column_name(&eq_column_name)?;
match value {
DbValue::Indexable(value) => {
match self.fetch_ids_from_index(eq_column_position, &value)? {
Some(ids) =>
Ok(self.get_rows_by_ids(ids).iter().map(|row| restrict_columns(row, &selected_column_positions)).collect()),
None =>
Ok(self.get_rows_by_value(eq_column_position, &DbValue::Indexable(value)).iter().map(|row| restrict_columns(row, &selected_column_positions)).collect())
}
},
_ => {
Ok(self.get_rows_by_value(eq_column_position, &value).iter().map(|row| restrict_columns(row, &selected_column_positions)).collect())
}
}
}
}
}
pub fn insert(&mut self, values: InsertionValues) -> DbResult<()> {
let (id, row) = self.schema.row_from_insertion_values(values)?;
if self.rows.get(&id).is_some() {
return Err(Error::AttemptingToInsertAlreadyPresentId(self.schema.table_name.clone(), id))
}
for (column_position, column_index) in &mut self.indexes {
match row.get(*column_position) {
Some(DbValue::Indexable(val)) => {
column_index.add(val.clone(), id)
},
Some(_) => {},
None => return Err(Error::ColumnPositionDoesNotExist(self.schema.table_name.clone(), *column_position))
}
}
let _ = self.rows.insert(id, row);
Ok(())
}
// TODO: Split into delete all and delete_where(condition)
pub fn delete_where(&mut self, maybe_condition: Option<Condition>) -> DbResult<usize> {
match maybe_condition {
None => {
// delete all
fn delete_all_rows(&mut self) -> usize {
let number_of_rows = self.rows.len();
self.rows = BTreeMap::new();
self.indexes = HashMap::new();
Ok(number_of_rows)
},
number_of_rows
}
Some(Condition::Eq(eq_column_name, value)) => {
let eq_column_position = self.schema.column_position_from_column_name(&eq_column_name)?;
fn delete_rows_where_eq(&mut self, column_position: ColumnPosition, value: DbValue) -> DbResult<usize> {
match value {
DbValue::Indexable(value) => {
match self.fetch_ids_from_index(eq_column_position, &value)? {
match self.fetch_ids_from_index(column_position, &value)? {
Some(ids) =>
Ok(self.delete_rows_by_ids(ids)),
None =>
Ok(self.delete_rows_by_value(eq_column_position, &DbValue::Indexable(value)))
Ok(self.delete_rows_by_value(column_position, &DbValue::Indexable(value)))
}
},
_ =>
Ok(self.delete_rows_by_value(eq_column_position, &value))
Ok(self.delete_rows_by_value(column_position, &value))
}
}
pub fn delete_rows_where(&mut self, maybe_condition: Option<Condition>) -> DbResult<usize> {
match maybe_condition {
None => Ok(self.delete_all_rows()),
Some(Condition::Eq(eq_column_name, value)) => {
let eq_column_position = self.schema.column_position_from_column_name(&eq_column_name)?;
self.delete_rows_where_eq(eq_column_position, value)
}
}
}
// ======Indexing======
pub fn attach_index(&mut self, column_position: ColumnPosition, column_index: ColumnIndex) {
self.indexes.insert(column_position, column_index);
}
fn fetch_ids_from_index(&self, column_position: ColumnPosition, value: &IndexableDbValue) -> DbResult<Option<HashSet<UUID>>> {