From ded7faf505316a613698bd33dab9efbdf7b49e0e Mon Sep 17 00:00:00 2001
From: Yuriy Dupyn <2153100+omedusyo@users.noreply.github.com>
Date: Mon, 23 Oct 2023 23:27:09 +0200
Subject: [PATCH] Refine design

---
 .gitignore  |   1 +
 Cargo.lock  |   7 +++
 Cargo.toml  |   8 ++++
 DESIGN.md   | 121 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 src/main.rs |   6 +++
 5 files changed, 139 insertions(+), 4 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 Cargo.lock
 create mode 100644 Cargo.toml
 create mode 100644 src/main.rs

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ea8c4bf
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/target
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..e87788c
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "minisql"
+version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..df68143
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "minisql"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/DESIGN.md b/DESIGN.md
index 78c71a7..bf20c93 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -69,11 +69,45 @@ which will store the database as a file `path/to/db/my-db.db` and open a TCP ser
   how will the parsing output look like?
   Consider something like
 ```
+// TODO: Parser has access to all table metadata
+
 // Could also be called `SQLAbstractSyntaxTree`
-enum Operations {
-  Select(Vector<FieldName>, TableName),
-  Update(...)
+enum Operation {
+  Select(TableName, ColumnSelection, Option<Condition>),
+  Insert(TableName, Vec<(ColumnName, DbValue)>), // String because we don't yet know which type of value this is for sure
+  Delete(TableName, Option<Condition>),
+  // Update(...),
 }
+
+enum ColumnSelection {
+    All,
+    Columns(Vec<ColumnName>),
+}
+
+enum Condition = {
+    // And(Condition, Condition),
+    // Or(Condition, Condition),
+    // Not(Condition),
+
+    Eq(ColumnName, DbValue)
+    // LessOrEqual(ColumnName, DbValue)
+    // Less(ColumnName, DbValue)
+
+    // StringCondition(StringCondition)
+}
+
+enum StringCondition {
+    Prefix(ColumnName, String)
+    Substring(ColumnName, String)
+}
+
+
+enum Condition 
+    ColumnName, DbValue
+
+
+
+INSERT 123
 ```
 * We also have to write an interpreter for these operations. How will the db-state be represented in memory?
   For example how can we implement a table?
@@ -82,11 +116,46 @@ enum Operations {
 enum DbValue {
   DbString(String),
   DbNumber(Float),
-  DbByte(u8),
   DbUUID(u32)
 }
 
+// We also need a type of db-types
+enum DbType {
+    TString,
+    TNumber,
+    TId,
+}
+
+value_to_type(db_val: DbValue) -> DbType
+
+
+// table-metadata and data
+
+type TableName = String
+
+// Note that it is nice to split metadata from the data because
+// then you can give the metadata to the parser without giving it the data.
+struct TableMetaData {
+    name: TableName, // TODO: Is this really necessary? probably not
+    columns: Vec<(ColumnName, DbType, ColumnPosition)>
+}
+
+fn column_position(TableMetaData, ColumnName) -> ColumnPosition
+
+struct Table {
+    meta: TableMetaData,
+    rows: Rows // defined below
+    indexes:
+        BTree<ColumnName, Index> // TODO: Consider generalizing ColumnName to semething that would also apply to a pair of ColumnNames etc
+}
+
+type Tables = HashMap<TableName, Table>
+
+// We also need a function that for a given value computes its type (for validation)
+
+
 type ColumnName = String
+type ColumnPosition = u32
 
 // The below type is a type of a table row
 type Row = HashMap<ColumnName, DbValue>
@@ -94,6 +163,9 @@ type Row = HashMap<ColumnName, DbValue>
 // Or you know... some appropriate Dictionary Type
 HashMap::make![("id", 1), ("name", "Alice"), ("salary", 20.0)] : Row
 
+type Rows =
+    BTree<Id, Row>
+
 // possible optimization: have a mapping
 // column names ~> indexes
 // so that we could represent rows as
@@ -112,6 +184,47 @@ e.g. Row ~> vec![DbUUID 1, DbSTring "Alice"]
 Vec<Vec<DbValue>>
 
 ```
+* Interpreter
+```
+trait SqlConsumer {
+    // TODO: 
+    ???
+}
+
+fn interpret<T: SqlConsumer>(operation: Operation, tables: &mut Tables, consumer: T) -> ()  {
+    // TODO: lock stuff
+    match operation {
+          Select(table_name, column_selection, maybe_condition) => {
+            let table: Table = ...
+            // TODO: Wrap this into a response
+            select(table, column_selection, maybe_condition, consumer)
+          },
+          Insert(table_name, Vec<(ColumnName, DbValue)>) => {
+             insert(table, ???)
+          }
+          Delete(table_name, maybe_condition) => {
+
+          }
+    }
+}
+
+  response = interpret(...)
+  knows_how_to_respond(response, client)
+
+
+enum Response {
+    Selected(impl Iter<???>) // TODO: How to do this? Some reference to an iterator somehow... slice..?
+    Inserted(???),
+    Deleted(usize), // how many were deleted
+} 
+
+fn select(table: Table, ColumnName
+
+
+
+```
+
+
 * TODO: Consider streaming the response to the client and not just dumping 10K rows at once.
 
 
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..7217ece
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,6 @@
+
+
+
+fn main() {
+    println!("Hello, world!");
+}