select all

Cargo.lock

@@ -286,6 +286,7 @@ dependencies = [
  "anyhow",
  "async-trait",
  "bimap",
+ "bincode",
  "proto",
  "serde",
  "storage_engine",

minisql/Cargo.toml

@@ -10,6 +10,7 @@ rust-version = "1.74"
 anyhow = "1.0.79"
 async-trait = "0.1.77"
 bimap = { version = "0.6.3", features = ["serde"] }
+bincode = "2.0.0-rc.3"
 serde = { version = "1.0.196", features = ["derive"] }
 tokio = { version = "1.34.0", features = ["full"] }
 thiserror = "1.0.50"

minisql/src/error.rs

@@ -14,7 +14,9 @@ pub enum RuntimeError {
     #[error("table {0} already indexes column {1}")]
     AttemptToIndexAlreadyIndexedColumn(TableName, ColumnName),
     #[error("Storage Engine error for table {0}: {1}")]
-    StorageEngineError(TableName, storage_engine::error::Error)
+    StorageEngineError(TableName, storage_engine::error::Error),
+    #[error("runtime anyhow error: {0}")]
+    AnyhowError(anyhow::Error)
 }
 
 #[derive(Debug, Error)]
@@ -28,3 +30,10 @@ pub enum TypeConversionError {
     #[error("unknown type with oid {oid} and size {size}")]
     UnknownType { oid: PgOid, size: i16 },
 }
+
+
+impl From<anyhow::Error> for RuntimeError {
+    fn from(e: anyhow::Error) -> RuntimeError {
+        Self::AnyhowError(e)
+    }
+}

minisql/src/internals/row.rs

@@ -5,6 +5,7 @@ use crate::type_system::Value;
 use serde::{Deserialize, Serialize};
 use std::ops::{Index, IndexMut};
 use std::slice::SliceIndex;
+use storage_engine::segments::entry::EntryDetailed;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Row(Vec<Value>);
@@ -39,6 +40,12 @@ impl FromIterator<Value> for Row {
     }
 }
 
+impl From<EntryDetailed<Value>> for Row {
+    fn from(entry: EntryDetailed<Value>) -> Self {
+        Row(entry.data)
+    }
+}
+
 // To satisfy clippy.
 impl Default for Row {
     fn default() -> Self {

minisql/src/interpreter2.rs

@@ -5,11 +5,13 @@ use crate::schema::{Column, TableName, TablePosition, TableSchema};
 use crate::type_system::Value;
 use crate::error::RuntimeError;
 use crate::response_writer::ResponseWriter;
+use crate::internals::row::Row;
 
 use bimap::BiMap;
 
 use storage_engine::store::Store;
 use storage_engine::cursor::{ReadCursor, WriteCursor};
+use storage_engine::cursor_capabilities::traversal::CursorCanTraverse;
 
 // ==============Interpreter================
 #[derive(Debug)]
@@ -36,12 +38,12 @@ impl Default for State {
 
 impl Table {
     async fn read(&self) -> DbResult<ReadCursor<Value>> {
-        let cursor = self.store.read_cursor().await.map_err(|err| RuntimeError::StorageEngineError(self.schema.table_name().to_string(), err))?;
+        let cursor = self.store.read_cursor().await.map_err(|e| RuntimeError::StorageEngineError(self.schema.table_name().to_string(), e))?;
         Ok(cursor)
     }
 
     async fn write(&mut self) -> DbResult<WriteCursor<Value>> {
-        let cursor = self.store.write_cursor().await.map_err(|err| RuntimeError::StorageEngineError(self.schema.table_name().to_string(), err))?;
+        let cursor = self.store.write_cursor().await.map_err(|e| RuntimeError::StorageEngineError(self.schema.table_name().to_string(), e))?;
         Ok(cursor)
     }
 }
@@ -73,6 +75,15 @@ impl State {
         &mut self.tables[table_position]
     }
 
+    async fn select_all_rows<Writer: ResponseWriter>(table: &Table, mut cursor: ReadCursor<'_, Value>, response_writer: &mut Writer, column_selection: ColumnSelection) -> DbResult<()> {
+        while let Some(entry) = cursor.next_alive().await.map_err(|e| RuntimeError::StorageEngineError(table.schema.table_name().to_string(), e))? {
+            let row: Row = From::from(entry);
+            let restricted_row = row.restrict_columns(&column_selection);
+            response_writer.write_table_row(&restricted_row).await.map_err(|e| RuntimeError::AnyhowError(e))?;
+        }
+        Ok(())
+    }
+
     pub async fn interpret<Writer: ResponseWriter>(&mut self, response_writer: &mut Writer, operation: Operation) -> DbResult<()> {
         use Operation::*;
 
@@ -81,18 +92,16 @@ impl State {
                 let table: &Table = self.table_at(table_position);
                 let cursor = table.read().await?;
 
-                let selected_rows = match maybe_condition {
+                response_writer.write_table_header(&table.schema, &column_selection).await.map_err(|e| RuntimeError::AnyhowError(e))?;
+                match maybe_condition {
                     None => {
-                        // select all rows
+                        Self::select_all_rows(&table, cursor, response_writer, column_selection).await
-                        todo!()
                     }
 
                     Some(Condition::Eq(eq_column, value)) => {
                         todo!()
                     }
-                };
+                }
-
-                todo!()
             }
             Insert(table_position, values) => {
                 let table: &mut Table = self.table_at_mut(table_position);

minisql/src/restricted_row.rs

@@ -1,7 +1,9 @@
-use crate::schema::Column;
+use crate::schema::{Column, TableSchema};
 use crate::type_system::Value;
+use crate::operation::ColumnSelection;
 use std::ops::Index;
 use std::slice::SliceIndex;
+use storage_engine::segments::entry::EntryDetailed;
 
 #[derive(Debug, Clone)]
 pub struct RestrictedRow(Vec<(Column, Value)>);

minisql/src/type_system.rs

@@ -2,9 +2,12 @@ use crate::error::TypeConversionError;
 use proto::message::primitive::pgoid::PgOid;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
+// TODO: Private???
+// use bincode::{Encode, Encoder, EncodeError, Decode, Decoder, DecodeError};
+use bincode::{Encode, Decode};
 
 // ==============Types================
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)]
 pub enum DbType {
     String,
     Int,
@@ -15,7 +18,7 @@ pub enum DbType {
 
 // ==============Values================
 pub type Uuid = u64;
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode)]
 #[serde(try_from = "String", into = "String")]
 pub enum Value {
     Number(f64),
@@ -81,6 +84,18 @@ impl Ord for IndexableValue {
     }
 }
 
+// impl Encode for Value {
+//     fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+//         todo!()
+//     }
+// }
+
+// impl Decode for Value {
+//     fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
+//         todo!()
+//     }
+// }
+
 impl DbType {
     fn new_n_option(n: usize, inside: DbType) -> DbType {
         if n == 0 {

storage_engine/src/cursor_capabilities/mod.rs

@@ -1,4 +1,4 @@
 pub(crate) mod primitive;
-pub(crate) mod traversal;
+pub mod traversal;
-pub(crate) mod entry_modification;
+pub mod entry_modification;
-pub(crate) mod index_access;
+pub mod index_access;