Merge branch 'main' into 'validation-tests'

# Conflicts:
#   minisql/src/schema.rs

minisql/Cargo.toml

@@ -6,5 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bimap = "0.6.3"
+bimap = { version = "0.6.3", features = ["serde"] }
+serde = { version = "1.0.196", features = ["derive"] }
 thiserror = "1.0.50"

minisql/src/internals/column_index.rs

@@ -1,7 +1,8 @@
 use crate::type_system::{IndexableValue, Uuid};
 use std::collections::{BTreeMap, HashSet};
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct ColumnIndex {
     index: BTreeMap<IndexableValue, HashSet<Uuid>>,
 }

minisql/src/internals/row.rs

@@ -2,11 +2,12 @@ use crate::type_system::Value;
 use crate::operation::InsertionValues;
 use std::ops::{Index, IndexMut};
 use std::slice::SliceIndex;
+use serde::{Deserialize, Serialize};
 use crate::restricted_row::RestrictedRow;
 
 pub type ColumnPosition = usize;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Row(Vec<Value>);
 
 impl<Idx> Index<Idx> for Row

minisql/src/internals/table.rs

@@ -1,4 +1,5 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
+use serde::{Deserialize, Serialize};
 
 use crate::error::RuntimeError;
 use crate::internals::column_index::ColumnIndex;
@@ -8,7 +9,7 @@ use crate::schema::{ColumnName, TableSchema, TableName};
 use crate::result::DbResult;
 use crate::type_system::{IndexableValue, Uuid, Value};
 
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Table {
     schema: TableSchema,
     rows: Rows, // TODO: Consider wrapping this in a lock. Also consider if we need to have the

minisql/src/interpreter.rs

@@ -4,6 +4,7 @@ use crate::internals::table::Table;
 use crate::operation::{Operation, Condition};
 use crate::result::DbResult;
 use bimap::BiMap;
+use serde::{Deserialize, Serialize};
 use crate::restricted_row::RestrictedRow;
 
 // Use `TablePosition` as index
@@ -11,7 +12,7 @@ pub type Tables = Vec<Table>;
 pub type TablePosition = usize;
 
 // ==============Interpreter================
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct State {
     table_name_position_mapping: BiMap<TableName, TablePosition>,
     tables: Tables,

minisql/src/schema.rs

@@ -3,10 +3,11 @@ use crate::operation::{InsertionValues, ColumnSelection};
 use crate::result::DbResult;
 use crate::type_system::{DbType, IndexableValue, Uuid, Value};
 use bimap::BiMap;
+use serde::{Deserialize, Serialize};
 
 // 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.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TableSchema {
     table_name: TableName, // used for descriptive errors
     primary_key: ColumnPosition,

minisql/src/type_system.rs

@@ -1,7 +1,8 @@
+use serde::{Deserialize, Serialize};
 use crate::error::TypeConversionError;
 
 // ==============Types================
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum DbType {
     String,
     Int,
@@ -15,14 +16,14 @@ pub type Uuid = u64;
 // TODO: What about nulls? I would rather not have that in SQL, it sucks.
 //       I would rather have non-nullable values by default,
 //       and something like an explicit Option type for nulls.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum Value {
     Number(f64), // TODO: Can't put floats as keys in maps, since they don't implement Eq. What to
     // do?
     Indexable(IndexableValue),
 }
 
-#[derive(Debug, Ord, Eq, Clone, PartialOrd, PartialEq)]
+#[derive(Debug, Ord, Eq, Clone, PartialOrd, PartialEq, Serialize, Deserialize)]
 pub enum IndexableValue {
     String(String),
     Int(u64),