Use TempDB instead of context

Author: KyGost

Diff for: src/executor/alter_row/delete.rs

@@ -36,7 +36,7 @@ impl Glue {
 			.clone()
 			.map(|selection| {
 				PlannedRecipe::new(
-					MetaRecipe::new(selection)?.simplify_by_context(&*self.get_context()?)?,
+					MetaRecipe::new(selection)?.simplify_by_tempdb(&self.tempdb)?,
 					&columns,
 				)
 			})

Diff for: src/executor/alter_row/update.rs

@@ -49,7 +49,7 @@ impl Glue {
 			.clone()
 			.map(|selection| {
 				PlannedRecipe::new(
-					MetaRecipe::new(selection)?.simplify_by_context(&*self.get_context()?)?,
+					MetaRecipe::new(selection)?.simplify_by_tempdb(&self.tempdb)?,
 					&columns,
 				)
 			})
@@ -69,7 +69,7 @@ impl Glue {
 					.position(|column| column == &column_compare)
 					.ok_or(ExecuteError::ColumnNotFound)?;
 				let recipe = PlannedRecipe::new(
-					MetaRecipe::new(value.clone())?.simplify_by_context(&*self.get_context()?)?,
+					MetaRecipe::new(value.clone())?.simplify_by_tempdb(&self.tempdb)?,
 					&columns,
 				)?;
 				Ok((index, recipe))

Diff for: src/executor/query/get_columns.rs

@@ -12,11 +12,7 @@ use {
 
 impl Glue {
 	pub async fn get_columns(&self, table: ComplexTableName) -> Result<Vec<ColumnInfo>> {
-		let context_tables = {
-			let context = self.get_context().unwrap();
-			context.tables.clone()
-		};
-		if let Some((context_table_labels, ..)) = context_tables.get(&table.name) {
+		if let Some((context_table_labels, ..)) = self.tempdb.get_table(&table.name) {
 			Ok(context_table_labels
 				.iter()
 				.map(|name| ColumnInfo {

Diff for: src/executor/query/get_rows.rs

@@ -11,11 +11,7 @@ impl Glue {
 		database: &Option<String>,
 		index_filter: &Option<IndexFilter>,
 	) -> Result<Vec<Vec<Value>>> {
-		let context_tables = {
-			let context = self.get_context().unwrap();
-			context.tables.clone()
-		};
-		if let Some((.., context_table_rows)) = context_tables.get(table) {
+		if let Some((.., context_table_rows)) = self.tempdb.get_table(table) {
 			Ok(context_table_rows.clone())
 		} else {
 			let rows = self.get_view_rows(table, database).await?;

Diff for: src/executor/query/mod.rs

@@ -53,15 +53,15 @@ impl Glue {
 		let limit: Option<usize> = limit
 			.map(|expression| {
 				MetaRecipe::new(expression)?
-					.simplify_by_context(&*self.get_context()?)?
+					.simplify_by_tempdb(&self.tempdb)?
 					.confirm_or_err(QueryError::MissingComponentsForLimit.into())?
 					.cast()
 			})
 			.transpose()?;
 		let offset: Option<usize> = offset
 			.map(|offset| {
 				MetaRecipe::new(offset.value)?
-					.simplify_by_context(&*self.get_context()?)?
+					.simplify_by_tempdb(&self.tempdb)?
 					.confirm_or_err(QueryError::MissingComponentsForOffset.into())?
 					.cast()
 			})
@@ -84,7 +84,7 @@ impl Glue {
 				} = alias;
 				let name = name.value;
 				let data = self.query(query).await?;
-				self.get_mut_context()?.set_table(name, data);
+				self.tempdb.set_table(name, data);
 			}
 		}
 

Diff for: src/executor/query/select/join/manual.rs

@@ -2,7 +2,7 @@ use {
 	super::{JoinError, JoinType},
 	crate::{
 		executor::{types::ComplexTableName, MetaRecipe},
-		Context, Result,
+		Result, TempDB,
 	},
 	sqlparser::ast::{Join as AstJoin, JoinConstraint, JoinOperator, TableFactor},
 };
@@ -15,10 +15,10 @@ pub struct JoinManual {
 }
 
 impl JoinManual {
-	pub fn new(join: AstJoin, context: &Context) -> Result<Self> {
+	pub fn new(join: AstJoin, tempdb: &TempDB) -> Result<Self> {
 		let table = join.relation.try_into()?;
 		let (join_type, constraint) = Self::convert_join(join.join_operator)?;
-		let constraint = constraint.simplify_by_context(context)?;
+		let constraint = constraint.simplify_by_tempdb(tempdb)?;
 		Ok(Self {
 			table,
 			join_type,

Diff for: src/executor/query/select/manual/mod.rs

@@ -56,22 +56,16 @@ impl Manual {
 		} = select;
 
 		let constraint = selection
-			.map(|selection| {
-				MetaRecipe::new(selection)?.simplify_by_context(&glue.get_context().unwrap())
-			})
+			.map(|selection| MetaRecipe::new(selection)?.simplify_by_tempdb(&glue.tempdb))
 			.unwrap_or(Ok(MetaRecipe::TRUE))?;
 
 		let group_constraint = having
-			.map(|having| {
-				MetaRecipe::new(having)?.simplify_by_context(&glue.get_context().unwrap())
-			})
+			.map(|having| MetaRecipe::new(having)?.simplify_by_tempdb(&glue.tempdb))
 			.unwrap_or(Ok(MetaRecipe::TRUE))?;
 
 		let groups = group_by
 			.into_iter()
-			.map(|expression| {
-				MetaRecipe::new(expression)?.simplify_by_context(&glue.get_context().unwrap())
-			})
+			.map(|expression| MetaRecipe::new(expression)?.simplify_by_tempdb(&glue.tempdb))
 			.collect::<Result<Vec<MetaRecipe>>>()?;
 
 		let (select_items, _subqueries): (Vec<SelectItem>, Vec<Vec<JoinManual>>) = projection
@@ -88,7 +82,7 @@ impl Manual {
 				let mut joins = from
 					.joins
 					.into_iter()
-					.map(|join| JoinManual::new(join, &glue.get_context().unwrap()))
+					.map(|join| JoinManual::new(join, &glue.tempdb))
 					.collect::<Result<Vec<JoinManual>>>()?;
 				joins.push(main);
 				Ok(joins)
@@ -136,8 +130,7 @@ fn convert_select_item(
 				SelectItemAst::ExprWithAlias { expr, alias } => (expr, Some(alias.value)),
 				_ => unreachable!(),
 			};
-			let recipe =
-				MetaRecipe::new(expression)?.simplify_by_context(&glue.get_context().unwrap())?;
+			let recipe = MetaRecipe::new(expression)?.simplify_by_tempdb(&glue.tempdb)?;
 			let subqueries = recipe.meta.subqueries.clone();
 			(SelectItem::Recipe(recipe, alias), subqueries)
 		}

Diff for: src/executor/query/set_expr.rs

@@ -32,7 +32,7 @@ impl Glue {
 							.into_iter()
 							.map(|cell| {
 								MetaRecipe::new(cell)?
-									.simplify_by_context(&*self.get_context()?)?
+									.simplify_by_tempdb(&self.tempdb)?
 									.confirm_or_err(QueryError::MissingComponentsForValues.into())
 							})
 							.collect::<Result<Vec<Value>>>()

Diff for: src/executor/recipe/new.rs

@@ -2,7 +2,7 @@ use {
 	super::{Ingredient, Method, Recipe, RecipeError, TryIntoMethod},
 	crate::{
 		executor::{query::JoinManual, types::ObjectName},
-		Context, Resolve, Result, SimplifyBy, Value,
+		Resolve, Result, SimplifyBy, TempDB, Value,
 	},
 	sqlparser::ast::{Expr, FunctionArg, FunctionArgExpr, Ident},
 	std::convert::TryFrom,
@@ -19,7 +19,7 @@ impl MetaRecipe {
 		let (recipe, meta) = Recipe::new_with_meta(expression)?;
 		Ok(Self { recipe, meta })
 	}
-	pub fn simplify_by_context(self, context: &Context) -> Result<Self> {
+	pub fn simplify_by_tempdb(self, tempdb: &TempDB) -> Result<Self> {
 		let meta_objects = self.meta.objects.clone();
 		let (meta_objects, row) = meta_objects
 			.into_iter()
@@ -28,7 +28,7 @@ impl MetaRecipe {
 					.clone()
 					.and_then(|object_name| {
 						if object_name.len() == 1 {
-							context.variables.get(&object_name[0]).map(Clone::clone)
+							tempdb.get_variable(&object_name[0]).map(Clone::clone)
 						} else {
 							None
 						}

Diff for: src/executor/set_variable.rs

@@ -15,7 +15,7 @@ impl Glue {
 			SetVariableValue::Literal(literal) => literal.try_into()?,
 		};
 		let name = variable.value.clone();
-		self.get_mut_context()?.set_variable(name, value);
+		self.tempdb.set_variable(name, value);
 		Ok(())
 	}
 }

Diff for: src/glue/database.rs

@@ -1,5 +1,5 @@
 use {
-	crate::{Context, Database, DatabaseInner, Glue, InterfaceError, Result},
+	crate::{Database, DatabaseInner, Glue, InterfaceError, Result},
 	std::sync::MutexGuard,
 };
 
@@ -17,16 +17,6 @@ impl Glue {
 			.ok_or(InterfaceError::DatabaseNotFound.into())
 			.map(Database::get_mut)
 	}
-	pub fn get_context(&self) -> Result<MutexGuard<Context>> {
-		self.context
-			.try_lock()
-			.map_err(|_| InterfaceError::ContextUnavailable.into())
-	}
-	pub fn get_mut_context(&mut self) -> Result<&mut Context> {
-		self.context
-			.get_mut()
-			.map_err(|_| InterfaceError::ContextUnavailable.into())
-	}
 	pub fn get_database_list(&self) -> Vec<&String> {
 		self.databases.keys().collect()
 	}

Diff for: src/glue/mod.rs

@@ -1,40 +1,22 @@
-use std::sync::Mutex;
-
-use crate::ExecuteError;
 use {
 	crate::{
-		parse, parse_single, CSVSettings, Connection, Database, Payload, Query, Result, Value,
-		WIPError,
+		parse, parse_single, CSVSettings, Connection, Database, ExecuteError, Payload, Query,
+		Result, Value, WIPError,
 	},
 	futures::executor::block_on,
 	sqlparser::ast::{
 		Expr, Ident, ObjectName, Query as AstQuery, SetExpr, Statement, Value as AstValue, Values,
 	},
-	std::{collections::HashMap, fmt::Debug},
+	std::collections::HashMap,
 };
 
 mod database;
 mod error;
 mod payload;
 mod select;
+mod tempdb;
 
-pub use error::InterfaceError;
-
-pub(crate) type Variables = HashMap<String, Value>;
-
-#[derive(Default, Debug, Clone)]
-pub struct Context {
-	pub variables: Variables,
-	pub tables: HashMap<String, (Vec<String>, Vec<Vec<Value>>)>,
-}
-impl Context {
-	pub fn set_variable(&mut self, name: String, value: Value) {
-		self.variables.insert(name, value);
-	}
-	pub fn set_table(&mut self, name: String, data: (Vec<String>, Vec<Vec<Value>>)) {
-		self.tables.insert(name, data);
-	}
-}
+pub use {error::InterfaceError, tempdb::TempDB};
 
 /// # Glue
 /// Glue is *the* interface for interacting with MultiSQL; a Glue instance comprises any number of stores, each with their own identifier.
@@ -50,7 +32,7 @@ impl Context {
 pub struct Glue {
 	pub primary: String,
 	databases: HashMap<String, Database>,
-	context: Mutex<Context>,
+	pub tempdb: TempDB,
 }
 
 /// ## Creation of new interfaces
@@ -64,11 +46,10 @@ impl Glue {
 	/// Creates a [Glue] instance with access to all provided storages.
 	/// Argument is: [Vec]<(Identifier, [Database])>
 	pub fn new_multi(databases: HashMap<String, Database>) -> Self {
-		let context = Mutex::new(Context::default());
 		let primary = databases.keys().next().cloned().unwrap_or_default();
 		Self {
 			databases,
-			context,
+			tempdb: TempDB::default(),
 			primary,
 		}
 	}
@@ -167,22 +148,6 @@ impl Glue {
 	}
 }
 
-/// Internal: Modify
-impl Glue {
-	/*pub(crate) fn take_context(&mut self) -> Result<Context> {
-		self.context
-			.take()
-			.ok_or(InterfaceError::ContextUnavailable.into())
-	}
-	pub(crate) fn replace_context(&mut self, context: Context) {
-		self.context.replace(context);
-	}*/
-	#[allow(dead_code)]
-	fn set_context(&mut self, context: Context) {
-		self.context = Mutex::new(context);
-	}
-}
-
 impl Glue {
 	pub fn into_connections(self) -> Vec<(String, Connection)> {
 		self.databases

Diff for: src/glue/tempdb.rs

@@ -0,0 +1,35 @@
+use {crate::Value, std::collections::HashMap};
+
+#[derive(Clone)]
+pub struct TempDB {
+	variables: HashMap<String, Value>,
+	tables: HashMap<String, (Vec<String>, Vec<Vec<Value>>)>,
+}
+
+impl Default for TempDB {
+	fn default() -> Self {
+		TempDB {
+			variables: HashMap::new(),
+			tables: HashMap::new(),
+		}
+	}
+}
+
+impl TempDB {
+	pub fn get_variable(&self, name: &str) -> Option<&Value> {
+		self.variables.get(name)
+	}
+	pub fn set_variable(&mut self, name: String, value: Value) -> Option<Value> {
+		self.variables.insert(name, value)
+	}
+	pub fn get_table(&self, name: &str) -> Option<&(Vec<String>, Vec<Vec<Value>>)> {
+		self.tables.get(name)
+	}
+	pub fn set_table(
+		&mut self,
+		name: String,
+		data: (Vec<String>, Vec<Vec<Value>>),
+	) -> Option<(Vec<String>, Vec<Vec<Value>>)> {
+		self.tables.insert(name, data)
+	}
+}