From 0ec02eeef826864aea6acedc013b20389b90344d Mon Sep 17 00:00:00 2001 From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com> Date: Sun, 28 Jan 2024 18:29:22 +0100 Subject: [PATCH 1/4] ColumnName ~> Column --- minisql/src/internals/row.rs | 8 ++++---- minisql/src/internals/table.rs | 25 ++++++++++++------------- minisql/src/interpreter.rs | 18 +++++++++--------- minisql/src/operation.rs | 8 ++++---- minisql/src/restricted_row.rs | 12 ++++++------ minisql/src/schema.rs | 20 ++++++++++---------- 6 files changed, 45 insertions(+), 46 deletions(-) diff --git a/minisql/src/internals/row.rs b/minisql/src/internals/row.rs index 0e48867..4698ec0 100644 --- a/minisql/src/internals/row.rs +++ b/minisql/src/internals/row.rs @@ -5,7 +5,7 @@ use std::slice::SliceIndex; use serde::{Deserialize, Serialize}; use crate::restricted_row::RestrictedRow; -pub type ColumnPosition = usize; +pub type Column = usize; #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Row(Vec); @@ -61,13 +61,13 @@ impl Row { self.0.len() } - pub fn get(&self, column: ColumnPosition) -> Option<&Value> { + pub fn get(&self, column: Column) -> Option<&Value> { self.0.get(column) } - pub fn restrict_columns(&self, columns: &Vec) -> RestrictedRow { + pub fn restrict_columns(&self, columns: &Vec) -> RestrictedRow { // If the index from `columns` is non-existant in `row`, it will just ignore it. - let mut subrow: Vec<(ColumnPosition, Value)> = vec![]; + let mut subrow: Vec<(Column, Value)> = vec![]; for column in columns { if let Some(value) = self.get(*column) { subrow.push((*column, value.clone())); diff --git a/minisql/src/internals/table.rs b/minisql/src/internals/table.rs index dc83639..7609373 100644 --- a/minisql/src/internals/table.rs +++ b/minisql/src/internals/table.rs @@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize}; use crate::error::RuntimeError; use crate::internals::column_index::ColumnIndex; -use crate::internals::row::{ColumnPosition, Row}; +use crate::internals::row::{Column, Row}; use crate::restricted_row::RestrictedRow; use crate::schema::{ColumnName, TableSchema, TableName}; use crate::result::DbResult; @@ -14,7 +14,7 @@ pub struct Table { schema: TableSchema, rows: Rows, // TODO: Consider wrapping this in a lock. Also consider if we need to have the // same lock for both rows and indexes - indexes: HashMap, + indexes: HashMap, } pub type Rows = BTreeMap; @@ -36,7 +36,7 @@ impl Table { &self.rows } - pub fn indexes(&self) -> &HashMap { + pub fn indexes(&self) -> &HashMap { &self.indexes } @@ -55,7 +55,7 @@ impl Table { .collect() } - fn get_rows_by_value(&self, column: ColumnPosition, value: &Value) -> Vec { + fn get_rows_by_value(&self, column: Column, value: &Value) -> Vec { // brute-force search self.rows .values() @@ -69,7 +69,7 @@ impl Table { .collect() } - pub fn select_all_rows<'a>(&'a self, selected_columns: Vec) -> impl Iterator + 'a { + pub fn select_all_rows<'a>(&'a self, selected_columns: Vec) -> impl Iterator + 'a { self.rows .values() .map(move |row| row.restrict_columns(&selected_columns)) @@ -77,8 +77,8 @@ impl Table { pub fn select_rows_where_eq<'a>( &'a self, - selected_columns: Vec, - column: ColumnPosition, + selected_columns: Vec, + column: Column, value: Value, ) -> DbResult + 'a> { let restrict_columns_of_row = move |row: Row| row.restrict_columns(&selected_columns); @@ -149,7 +149,7 @@ impl Table { total_count } - fn delete_rows_by_value(&mut self, column: ColumnPosition, value: &Value) -> usize { + fn delete_rows_by_value(&mut self, column: Column, value: &Value) -> usize { let matched_ids: HashSet = self .rows .iter() @@ -173,7 +173,7 @@ impl Table { pub fn delete_rows_where_eq( &mut self, - column: ColumnPosition, + column: Column, value: Value, ) -> DbResult { match value { @@ -186,7 +186,7 @@ impl Table { } // ======Indexing====== - pub fn attach_index(&mut self, column: ColumnPosition) -> DbResult<()> { + pub fn attach_index(&mut self, column: Column) -> DbResult<()> { if self.indexes.get(&column).is_some() { let column_name = self.schema.column_name_from_column(column).clone(); let table_name = self.schema.table_name().clone(); @@ -200,7 +200,7 @@ impl Table { fn fetch_ids_from_index( &self, - column: ColumnPosition, + column: Column, value: &IndexableValue, ) -> DbResult>> { if self.schema.is_primary(column) { @@ -228,7 +228,7 @@ impl Table { fn update_index_from_table( column_index: &mut ColumnIndex, table: &Table, - column: ColumnPosition, + column: Column, ) -> DbResult<()> { for (id, row) in &table.rows { let value = match &row[column] { @@ -237,7 +237,6 @@ fn update_index_from_table( let column_name: ColumnName = table .schema .column_name_from_column(column); - // TODO: Perhaps this should be handled in validation? return Err(RuntimeError::AttemptToIndexNonIndexableColumn( table.table_name().to_string(), column_name, diff --git a/minisql/src/interpreter.rs b/minisql/src/interpreter.rs index 08602af..c1bec89 100644 --- a/minisql/src/interpreter.rs +++ b/minisql/src/interpreter.rs @@ -1,4 +1,4 @@ -use crate::internals::row::ColumnPosition; +use crate::internals::row::Column; use crate::schema::{TableName, TableSchema}; use crate::internals::table::Table; use crate::operation::{Operation, Condition}; @@ -145,7 +145,7 @@ impl State { #[cfg(test)] mod tests { use super::*; - use crate::internals::row::ColumnPosition; + use crate::internals::row::Column; use std::collections::HashSet; use crate::type_system::{DbType, IndexableValue, Value}; use crate::operation::Operation; @@ -259,8 +259,8 @@ mod tests { let users_schema = users_schema(); let users_position: TablePosition = 0; - let id_column: ColumnPosition = 0; - let name_column: ColumnPosition = 1; + let id_column: Column = 0; + let name_column: Column = 1; state .interpret(CreateTable(users_schema.clone())) @@ -377,7 +377,7 @@ mod tests { let users_schema = users_schema(); let users_position: TablePosition = 0; - let id_column: ColumnPosition = 0; + let id_column: Column = 0; state .interpret(CreateTable(users_schema.clone())) @@ -451,7 +451,7 @@ mod tests { let users_schema = users_schema(); let users_position: TablePosition = 0; - let name_column: ColumnPosition = 1; + let name_column: Column = 1; state .interpret(CreateTable(users_schema.clone())) @@ -497,7 +497,7 @@ mod tests { let table = &state.tables[0]; assert!(table.rows().len() == 2); - let user: ColumnPosition = 1; + let user: Column = 1; assert!(table.indexes().contains_key(&user)); let index = table.indexes().get(&user).unwrap(); @@ -519,8 +519,8 @@ pub fn example() { use Operation::*; use Value::*; - let id_column: ColumnPosition = 0; - let name_column: ColumnPosition = 1; + let id_column: Column = 0; + let name_column: Column = 1; // let age_column: ColumnPosition = 2; let users_schema: TableSchema = { diff --git a/minisql/src/operation.rs b/minisql/src/operation.rs index fa56b70..3b384bd 100644 --- a/minisql/src/operation.rs +++ b/minisql/src/operation.rs @@ -1,6 +1,6 @@ use crate::schema::TableSchema; use crate::type_system::Value; -use crate::internals::row::ColumnPosition; +use crate::internals::row::Column; use crate::interpreter::TablePosition; // Validated operation. Constructed by validation crate. @@ -10,15 +10,15 @@ pub enum Operation { Insert(TablePosition, InsertionValues), Delete(TablePosition, Option), CreateTable(TableSchema), - CreateIndex(TablePosition, ColumnPosition), + CreateIndex(TablePosition, Column), } // Assumes that these are sorted by column position. pub type InsertionValues = Vec; -pub type ColumnSelection = Vec; +pub type ColumnSelection = Vec; #[derive(Debug, PartialEq)] pub enum Condition { - Eq(ColumnPosition, Value), + Eq(Column, Value), } diff --git a/minisql/src/restricted_row.rs b/minisql/src/restricted_row.rs index 26be188..17f4b7a 100644 --- a/minisql/src/restricted_row.rs +++ b/minisql/src/restricted_row.rs @@ -1,14 +1,14 @@ use std::ops::Index; use std::slice::SliceIndex; -use crate::internals::row::ColumnPosition; +use crate::internals::row::Column; use crate::type_system::Value; #[derive(Debug, Clone)] -pub struct RestrictedRow(Vec<(ColumnPosition, Value)>); +pub struct RestrictedRow(Vec<(Column, Value)>); impl Index for RestrictedRow where - Idx: SliceIndex<[(ColumnPosition, Value)]>, + Idx: SliceIndex<[(Column, Value)]>, { type Output = Idx::Output; @@ -17,8 +17,8 @@ where } } -impl From> for RestrictedRow { - fn from(v: Vec<(ColumnPosition, Value)>) -> Self { +impl From> for RestrictedRow { + fn from(v: Vec<(Column, Value)>) -> Self { RestrictedRow(v) } } @@ -28,7 +28,7 @@ impl RestrictedRow { self.0.len() } - pub fn iter(&self) -> impl Iterator { + pub fn iter(&self) -> impl Iterator { self.0.iter() } } diff --git a/minisql/src/schema.rs b/minisql/src/schema.rs index 16a41bf..8e9423c 100644 --- a/minisql/src/schema.rs +++ b/minisql/src/schema.rs @@ -1,4 +1,4 @@ -use crate::internals::row::{ColumnPosition, Row}; +use crate::internals::row::{Column, Row}; use crate::operation::{InsertionValues, ColumnSelection}; use crate::result::DbResult; use crate::type_system::{DbType, IndexableValue, Uuid, Value}; @@ -10,8 +10,8 @@ use serde::{Deserialize, Serialize}; #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct TableSchema { table_name: TableName, // used for descriptive errors - primary_key: ColumnPosition, - column_name_position_mapping: BiMap, + primary_key: Column, + column_name_position_mapping: BiMap, types: Vec, } @@ -20,11 +20,11 @@ pub type ColumnName = String; impl TableSchema { pub fn new(table_name: TableName, primary_column_name: ColumnName, columns: Vec, types: Vec) -> Self { - let mut column_name_position_mapping: BiMap = BiMap::new(); + let mut column_name_position_mapping: BiMap = BiMap::new(); for (column, column_name) in columns.into_iter().enumerate() { column_name_position_mapping.insert(column_name, column); } - let primary_key: ColumnPosition = match column_name_position_mapping.get_by_left(&primary_column_name).copied() { + let primary_key: Column = match column_name_position_mapping.get_by_left(&primary_column_name).copied() { Some(primary_key) => primary_key, None => unreachable!() // SAFETY: Existence of unique primary key is ensured in validation. }; @@ -35,7 +35,7 @@ impl TableSchema { &self.table_name } - pub fn column_type(&self, column: ColumnPosition) -> DbType { + pub fn column_type(&self, column: Column) -> DbType { self.types[column] } @@ -47,7 +47,7 @@ impl TableSchema { self.column_name_position_mapping.contains_left(column_name) } - pub fn get_column_position(&self, column_name: &ColumnName) -> Option { + pub fn get_column_position(&self, column_name: &ColumnName) -> Option { self.column_name_position_mapping.get_by_left(column_name).copied() } @@ -57,7 +57,7 @@ impl TableSchema { selection } - pub fn get_column(&self, column_name: &ColumnName) -> Option<(ColumnPosition, DbType)> { + pub fn get_column(&self, column_name: &ColumnName) -> Option<(Column, DbType)> { let column = self.get_column_position(column_name)?; Some((column, self.column_type(column))) } @@ -67,12 +67,12 @@ impl TableSchema { self.types.get(position).copied() } - pub fn is_primary(&self, column: ColumnPosition) -> bool { + pub fn is_primary(&self, column: Column) -> bool { self.primary_key == column } // Assumes `column` comes from a validated source. - pub fn column_name_from_column(&self, column: ColumnPosition) -> ColumnName { + pub fn column_name_from_column(&self, column: Column) -> ColumnName { match self .column_name_position_mapping .get_by_right(&column) From a2180a3e3278d1e6acbdf280b483a49bd9174924 Mon Sep 17 00:00:00 2001 From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com> Date: Sun, 28 Jan 2024 18:40:34 +0100 Subject: [PATCH 2/4] Move Column into schema.rs --- DESIGN.md | 2 +- minisql/src/internals/row.rs | 3 +-- minisql/src/internals/table.rs | 4 ++-- minisql/src/interpreter.rs | 5 ++--- minisql/src/operation.rs | 3 +-- minisql/src/restricted_row.rs | 2 +- minisql/src/schema.rs | 12 +++++++----- parser/src/validation.rs | 8 ++++---- server/src/proto_wrapper.rs | 8 ++++---- 9 files changed, 23 insertions(+), 24 deletions(-) diff --git a/DESIGN.md b/DESIGN.md index 449f983..d94f87b 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -136,7 +136,7 @@ struct TableMetaData { columns: Vec<(ColumnName, DbType, ColumnPosition)> } -fn column_position(TableMetaData, ColumnName) -> ColumnPosition +fn column(TableMetaData, ColumnName) -> ColumnPosition struct Table { meta: TableMetaData, diff --git a/minisql/src/internals/row.rs b/minisql/src/internals/row.rs index 4698ec0..f8a0ea8 100644 --- a/minisql/src/internals/row.rs +++ b/minisql/src/internals/row.rs @@ -4,8 +4,7 @@ use std::ops::{Index, IndexMut}; use std::slice::SliceIndex; use serde::{Deserialize, Serialize}; use crate::restricted_row::RestrictedRow; - -pub type Column = usize; +use crate::schema::Column; #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Row(Vec); diff --git a/minisql/src/internals/table.rs b/minisql/src/internals/table.rs index 7609373..9dc05de 100644 --- a/minisql/src/internals/table.rs +++ b/minisql/src/internals/table.rs @@ -3,9 +3,9 @@ use serde::{Deserialize, Serialize}; use crate::error::RuntimeError; use crate::internals::column_index::ColumnIndex; -use crate::internals::row::{Column, Row}; +use crate::internals::row::Row; use crate::restricted_row::RestrictedRow; -use crate::schema::{ColumnName, TableSchema, TableName}; +use crate::schema::{Column, ColumnName, TableSchema, TableName}; use crate::result::DbResult; use crate::type_system::{IndexableValue, Uuid, Value}; diff --git a/minisql/src/interpreter.rs b/minisql/src/interpreter.rs index c1bec89..b019054 100644 --- a/minisql/src/interpreter.rs +++ b/minisql/src/interpreter.rs @@ -1,5 +1,4 @@ -use crate::internals::row::Column; -use crate::schema::{TableName, TableSchema}; +use crate::schema::{Column, TableName, TableSchema}; use crate::internals::table::Table; use crate::operation::{Operation, Condition}; use crate::result::DbResult; @@ -145,7 +144,7 @@ impl State { #[cfg(test)] mod tests { use super::*; - use crate::internals::row::Column; + use crate::schema::Column; use std::collections::HashSet; use crate::type_system::{DbType, IndexableValue, Value}; use crate::operation::Operation; diff --git a/minisql/src/operation.rs b/minisql/src/operation.rs index 3b384bd..6448385 100644 --- a/minisql/src/operation.rs +++ b/minisql/src/operation.rs @@ -1,6 +1,5 @@ -use crate::schema::TableSchema; +use crate::schema::{Column, TableSchema}; use crate::type_system::Value; -use crate::internals::row::Column; use crate::interpreter::TablePosition; // Validated operation. Constructed by validation crate. diff --git a/minisql/src/restricted_row.rs b/minisql/src/restricted_row.rs index 17f4b7a..8ea9aca 100644 --- a/minisql/src/restricted_row.rs +++ b/minisql/src/restricted_row.rs @@ -1,6 +1,6 @@ use std::ops::Index; use std::slice::SliceIndex; -use crate::internals::row::Column; +use crate::schema::Column; use crate::type_system::Value; #[derive(Debug, Clone)] diff --git a/minisql/src/schema.rs b/minisql/src/schema.rs index 8e9423c..7b16656 100644 --- a/minisql/src/schema.rs +++ b/minisql/src/schema.rs @@ -1,4 +1,4 @@ -use crate::internals::row::{Column, Row}; +use crate::internals::row::Row; use crate::operation::{InsertionValues, ColumnSelection}; use crate::result::DbResult; use crate::type_system::{DbType, IndexableValue, Uuid, Value}; @@ -17,6 +17,8 @@ pub struct TableSchema { pub type TableName = String; pub type ColumnName = String; +pub type Column = usize; + impl TableSchema { pub fn new(table_name: TableName, primary_column_name: ColumnName, columns: Vec, types: Vec) -> Self { @@ -47,7 +49,7 @@ impl TableSchema { self.column_name_position_mapping.contains_left(column_name) } - pub fn get_column_position(&self, column_name: &ColumnName) -> Option { + pub fn get_column(&self, column_name: &ColumnName) -> Option { self.column_name_position_mapping.get_by_left(column_name).copied() } @@ -57,13 +59,13 @@ impl TableSchema { selection } - pub fn get_column(&self, column_name: &ColumnName) -> Option<(Column, DbType)> { - let column = self.get_column_position(column_name)?; + pub fn get_typed_column(&self, column_name: &ColumnName) -> Option<(Column, DbType)> { + let column = self.get_column(column_name)?; Some((column, self.column_type(column))) } pub fn get_type_at(&self, column_name: &ColumnName) -> Option { - let position = self.get_column_position(column_name)?; + let position = self.get_column(column_name)?; self.types.get(position).copied() } diff --git a/parser/src/validation.rs b/parser/src/validation.rs index b818448..abeeb86 100644 --- a/parser/src/validation.rs +++ b/parser/src/validation.rs @@ -122,7 +122,7 @@ fn validate_select(table_name: TableName, column_selection: syntax::ColumnSelect Err(ValidationError::ColumnsDoNotExist(non_existant_columns)) } else { let selection: operation::ColumnSelection = - columns.iter().filter_map(|column_name| schema.get_column_position(column_name)).collect(); + columns.iter().filter_map(|column_name| schema.get_column(column_name)).collect(); let validated_condition = validate_condition(condition, schema)?; Ok(Operation::Select(table_position, selection, validated_condition)) } @@ -163,7 +163,7 @@ fn validate_insert(table_name: TableName, insertion_values: syntax::InsertionVal // to get the values in a vector // sorted by the key. for (column_name, value) in insertion_values { - let (column, expected_type) = schema.get_column(&column_name).ok_or(ValidationError::ColumnsDoNotExist(vec![column_name.to_string()]))?; // By the previous validation steps this is never gonna trigger an error. + let (column, expected_type) = schema.get_typed_column(&column_name).ok_or(ValidationError::ColumnsDoNotExist(vec![column_name.to_string()]))?; // By the previous validation steps this is never gonna trigger an error. let value_type = value.to_type(); if value_type != expected_type { return Err(ValidationError::TypeMismatch { column_name: column_name.to_string(), received_type: value_type, expected_type }); @@ -189,7 +189,7 @@ fn validate_condition(condition: Option, schema: &TableSchema Some(condition) => { match condition { syntax::Condition::Eq(column_name, value) => { - let (column, expected_type) = schema.get_column(&column_name).ok_or(ValidationError::ColumnsDoNotExist(vec![column_name.to_string()]))?; + let (column, expected_type) = schema.get_typed_column(&column_name).ok_or(ValidationError::ColumnsDoNotExist(vec![column_name.to_string()]))?; let value_type: DbType = value.to_type(); if expected_type.eq(&value_type) { Ok(Some(operation::Condition::Eq(column, value))) @@ -206,7 +206,7 @@ fn validate_condition(condition: Option, schema: &TableSchema fn validate_create_index(table_name: TableName, column_name: ColumnName, db_schema: &DbSchema) -> Result { let (table_position, schema) = validate_table_exists(db_schema, &table_name)?; schema - .get_column(&column_name) + .get_typed_column(&column_name) .map_or_else( || Err(ValidationError::ColumnsDoNotExist(vec![column_name.to_string()])), |(column, type_)| { diff --git a/server/src/proto_wrapper.rs b/server/src/proto_wrapper.rs index bd74ba6..79cedbd 100644 --- a/server/src/proto_wrapper.rs +++ b/server/src/proto_wrapper.rs @@ -1,7 +1,7 @@ use async_trait::async_trait; use minisql::restricted_row::RestrictedRow; -use minisql::schema::TableSchema; -use minisql::type_system::{Value}; +use minisql::schema::{Column, TableSchema}; +use minisql::type_system::Value; use proto::message::backend::{BackendMessage, ColumnDescription, CommandCompleteData, DataRowData, ErrorResponseData, ReadyForQueryData, RowDescriptionData}; use proto::message::primitive::pglist::PgList; use proto::writer::backend::BackendProtoWriter; @@ -58,7 +58,7 @@ impl ServerProto for W where W: BackendProtoWriter + Send { async fn write_table_header(&mut self, table_schema: &TableSchema, row: &RestrictedRow) -> anyhow::Result<()> { let columns = row.iter() - .map(|(index, value)| value_to_column_description(table_schema, value, *index)) + .map(|(column, value)| value_to_column_description(table_schema, value, *column)) .collect::>>()?; self.write_proto(RowDescriptionData { columns: columns.into() }.into()).await?; @@ -84,7 +84,7 @@ impl ServerProto for W where W: BackendProtoWriter + Send { } } -fn value_to_column_description(schema: &TableSchema, value: &Value, index: usize) -> anyhow::Result { +fn value_to_column_description(schema: &TableSchema, value: &Value, index: Column) -> anyhow::Result { let name = schema.column_name_from_column(index); let table_oid = schema.table_name().as_bytes().as_ptr() as i32; From ec0a4f25108a029f619e65ff50558687fb69d5bf Mon Sep 17 00:00:00 2001 From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com> Date: Sun, 28 Jan 2024 18:43:53 +0100 Subject: [PATCH 3/4] Move TablePosition into schema --- minisql/src/interpreter.rs | 3 +-- minisql/src/operation.rs | 3 +-- minisql/src/schema.rs | 1 + parser/src/validation.rs | 4 ++-- 4 files changed, 5 insertions(+), 6 deletions(-) diff --git a/minisql/src/interpreter.rs b/minisql/src/interpreter.rs index b019054..7e9b293 100644 --- a/minisql/src/interpreter.rs +++ b/minisql/src/interpreter.rs @@ -1,4 +1,4 @@ -use crate::schema::{Column, TableName, TableSchema}; +use crate::schema::{Column, TableName, TablePosition, TableSchema}; use crate::internals::table::Table; use crate::operation::{Operation, Condition}; use crate::result::DbResult; @@ -8,7 +8,6 @@ use crate::restricted_row::RestrictedRow; // Use `TablePosition` as index pub type Tables = Vec; -pub type TablePosition = usize; // ==============Interpreter================ #[derive(Debug, Serialize, Deserialize)] diff --git a/minisql/src/operation.rs b/minisql/src/operation.rs index 6448385..b774663 100644 --- a/minisql/src/operation.rs +++ b/minisql/src/operation.rs @@ -1,6 +1,5 @@ -use crate::schema::{Column, TableSchema}; +use crate::schema::{Column, TablePosition, TableSchema}; use crate::type_system::Value; -use crate::interpreter::TablePosition; // Validated operation. Constructed by validation crate. #[derive(Debug, PartialEq)] diff --git a/minisql/src/schema.rs b/minisql/src/schema.rs index 7b16656..314eae9 100644 --- a/minisql/src/schema.rs +++ b/minisql/src/schema.rs @@ -16,6 +16,7 @@ pub struct TableSchema { } pub type TableName = String; +pub type TablePosition = usize; pub type ColumnName = String; pub type Column = usize; diff --git a/parser/src/validation.rs b/parser/src/validation.rs index abeeb86..a52ff27 100644 --- a/parser/src/validation.rs +++ b/parser/src/validation.rs @@ -4,7 +4,7 @@ use thiserror::Error; use crate::syntax; use crate::syntax::{RawTableSchema, ColumnSchema, RawQuerySyntax}; use minisql::operation; -use minisql::{operation::Operation, type_system::Value, schema::{TableSchema, ColumnName, TableName}, type_system::DbType, interpreter::{TablePosition, DbSchema}}; +use minisql::{operation::Operation, type_system::Value, schema::{TableSchema, ColumnName, Column, TableName, TablePosition}, type_system::DbType, interpreter::DbSchema}; #[derive(Debug, Error)] pub enum ValidationError { @@ -158,7 +158,7 @@ fn validate_insert(table_name: TableName, insertion_values: syntax::InsertionVal } // Check types and prepare for creation of InsertionValues for the interpreter - let mut values_map: BTreeMap<_, Value> = BTreeMap::new(); // The reason for using BTreeMap + let mut values_map: BTreeMap = BTreeMap::new(); // The reason for using BTreeMap // instead of HashMap is that we need // to get the values in a vector // sorted by the key. From 8108b26af58564a044c9da8330a1f274a87e33cf Mon Sep 17 00:00:00 2001 From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com> Date: Sun, 28 Jan 2024 19:18:43 +0100 Subject: [PATCH 4/4] Renaming --- minisql/src/internals/row.rs | 6 +++--- server/src/proto_wrapper.rs | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/minisql/src/internals/row.rs b/minisql/src/internals/row.rs index f8a0ea8..504828a 100644 --- a/minisql/src/internals/row.rs +++ b/minisql/src/internals/row.rs @@ -41,15 +41,15 @@ impl FromIterator for Row { impl Row { pub fn new() -> Self { - Row(vec![]) + Self(vec![]) } pub fn new_from_insertion_values(insertion_values: InsertionValues) -> Self { - Row(insertion_values) + Self(insertion_values) } pub fn with_number_of_columns(number_of_columns: usize) -> Self { - Row(Vec::with_capacity(number_of_columns)) + Self(Vec::with_capacity(number_of_columns)) } pub fn push(&mut self, value: Value) { diff --git a/server/src/proto_wrapper.rs b/server/src/proto_wrapper.rs index 79cedbd..48ec749 100644 --- a/server/src/proto_wrapper.rs +++ b/server/src/proto_wrapper.rs @@ -84,11 +84,11 @@ impl ServerProto for W where W: BackendProtoWriter + Send { } } -fn value_to_column_description(schema: &TableSchema, value: &Value, index: Column) -> anyhow::Result { - let name = schema.column_name_from_column(index); +fn value_to_column_description(schema: &TableSchema, value: &Value, column: Column) -> anyhow::Result { + let name = schema.column_name_from_column(column); let table_oid = schema.table_name().as_bytes().as_ptr() as i32; - let column_index = index.try_into()?; + let column_index = column.try_into()?; let type_oid = value.type_oid(); let type_size = value.type_size();