Struct Glue

pub struct Glue {
    pub primary: String,
    pub tempdb: TempDB,
    /* private fields */
}

Glue

Glue is the interface for interacting with MultiSQL; a Glue instance comprises any number of stores, each with their own identifier. Once built, one will typically interact with Glue via queries.

There is a number of ways to deposit queries however, depending on the desired output:

• Glue::execute() – Might be considered the most generic. Replies with a Result<Payload> (payload being the response from any type of query).
• Glue::execute_many() – Same as execute() but will find any number of seperate queries in given text and provide a Vec in response.
• Glue::select_as_string() – Provides data, only for SELECT queries, as Strings (rather than Values).
• [Glue::select_as_json()] – Provides data, only for SELECT queries, as one big String; generally useful for webby interactions.

Fields

primary: String

tempdb: TempDB

Implementations

impl Glue

pub async fn auto_increment( &mut self, database: &Option<String>, table_name: &str, columns: &[Column], rows: &mut [Row], ) -> Result<()>

impl Glue

pub async fn ast_delete( &mut self, table_name: &ObjectName, selection: &Option<Expr>, ) -> Result<Payload>

impl Glue

pub async fn ast_insert( &mut self, table_name: &ObjectName, columns: &[Ident], source: &Query, expect_data: bool, ) -> Result<Payload>

pub async fn true_insert( &mut self, database: &Option<String>, table: &str, columns: &[&str], rows: Vec<Vec<Value>>, labels: Option<Vec<String>>, expect_data: bool, ) -> Result<Payload>

pub async fn insert_data( &mut self, database: &Option<String>, table_name: &str, rows: Vec<Row>, ) -> Result<()>

impl Glue

pub async fn ast_update( &mut self, table: &TableWithJoins, selection: &Option<Expr>, assignments: &[Assignment], ) -> Result<Payload>

impl Glue

pub async fn ast_alter_table( &mut self, name: &ObjectName, operation: &AlterTableOperation, ) -> Result<()>

impl Glue

pub async fn ast_drop( &mut self, object_type: &ObjectType, names: &[ObjectName], if_exists: bool, ) -> Result<()>

impl Glue

pub async fn ast_truncate(&mut self, table_name: &ObjectName) -> Result<()>

impl Glue

pub async fn ast_create_index( &mut self, table: &ObjectName, name: &ObjectName, columns: &[OrderByExpr], unique: bool, if_not_exists: bool, ) -> Result<()>

impl Glue

pub async fn ast_create_table( &mut self, name: &ObjectName, column_defs: &[ColumnDef], if_not_exists: bool, ) -> Result<()>

pub async fn add_table( &mut self, database: Option<String>, schema: Schema, if_not_exists: bool, ) -> Result<()>

impl Glue

pub async fn ast_create_view( &mut self, name: &ObjectName, query: &Box<Query>, or_replace: bool, ) -> Result<()>

impl Glue

pub async fn execute_query(&mut self, statement: &Query) -> Result<Payload>

impl Glue

pub async fn explain(&self, object: &ObjectName) -> Result<Payload>

impl Glue

pub async fn ast_procedure( &mut self, name: &Ident, parameters: &[Expr], ) -> Result<Payload>

impl Glue

pub async fn get_columns( &self, table: ComplexTableName, ) -> Result<Vec<ColumnInfo>>

pub fn get_view_columns<'life0, 'life1, 'life_self, 'async_recursion>( &'life_self self, view_name: &'life0 str, database: &'life1 Option<String>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<String>>>> + 'async_recursion>>

where 'life0: 'async_recursion, 'life1: 'async_recursion, 'life_self: 'async_recursion,

impl Glue

pub async fn get_view_data( &self, view_name: &str, database: &Option<String>, ) -> Result<Option<(Vec<String>, Vec<Vec<Value>>)>>

pub async fn get_view_query( &self, view_name: &str, database: &Option<String>, ) -> Result<Option<Select>>

impl Glue

pub fn get_rows<'life0, 'life1, 'life2, 'life_self, 'async_recursion>( &'life_self self, table: &'life0 str, database: &'life1 Option<String>, index_filter: &'life2 Option<IndexFilter>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<Value>>>> + 'async_recursion>>

where 'life0: 'async_recursion, 'life1: 'async_recursion, 'life2: 'async_recursion, 'life_self: 'async_recursion,

pub async fn get_view_rows( &self, view_name: &str, database: &Option<String>, ) -> Result<Option<Vec<Vec<Value>>>>

pub async fn get_table_rows( &self, table: &str, database: &Option<String>, index_filter: &Option<IndexFilter>, ) -> Result<Vec<Vec<Value>>>

impl Glue

pub async fn select(&self, plan: Plan) -> Result<(Vec<String>, Vec<Vec<Value>>)>

pub async fn select_query( &self, query: Select, order_by: Vec<OrderByExpr>, ) -> Result<(Vec<String>, Vec<Vec<Value>>)>

impl Glue

pub fn from_body<'life_self, 'async_recursion>( &'life_self mut self, body: SetExpr, order_by: Vec<OrderByExpr>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<String>, Vec<Vec<Value>>)>> + 'async_recursion>>

where 'life_self: 'async_recursion,

impl Glue

pub fn ast_query<'life_self, 'async_recursion>( &'life_self mut self, query: Query, ) -> Pin<Box<dyn Future<Output = Result<(Vec<String>, Vec<Vec<Value>>)>> + 'async_recursion>>

where 'life_self: 'async_recursion,

impl Glue

pub async fn set_variable( &mut self, variable: &Ident, value: &[SetVariableValue], ) -> Result<()>

impl Glue

pub fn get_database( &self, db_ref: &Option<String>, ) -> Result<MutexGuard<'_, Box<DatabaseInner>>>

pub fn get_mut_database( &mut self, db_ref: &Option<String>, ) -> Result<&mut Box<DatabaseInner>>

pub fn get_database_list(&self) -> Vec<&String>

impl Glue

Insert (INSERT)

pub fn insert( &mut self, database: Option<&str>, table: &str, columns: &[&str], recipes: Vec<Vec<Recipe>>, ) -> Result<Payload>

impl Glue

Select (SELECT)

pub fn select_json(&mut self, query: &str) -> Result<JSONValue>

Only for SELECT queries.

Output is one big serde_json::Value, wrapped in a Result.

Generally useful for webby interactions.

pub fn select_as_string(&mut self, query: &str) -> Result<Vec<Vec<String>>>

Only for SELECT queries.

pub fn select_as_csv(&mut self, query: &str) -> Result<String>

Only for SELECT queries.

impl Glue

Creation of new interfaces

pub fn new(name: String, database: Database) -> Self

Creates a Glue instance with just one Database.

pub fn new_multi(databases: HashMap<String, Database>) -> Self

Creates a Glue instance with access to all provided storages. Argument is: Vec<(Identifier, Database)>

pub fn new_multi_glue(glues: Vec<Glue>) -> Self

Merges existing Glue instances

pub fn extend_many_glues(&mut self, glues: Vec<Glue>)

Merge existing Glue with Vec of other Glues For example:

use multisql::{SledDatabase, Database, Glue};
let storage = SledDatabase::new("data/example_location/example")
  .map(Database::new_sled)
  .expect("Database Creation Failed");
let mut glue = Glue::new(String::from("main"), storage);

glue.execute_many("
  DROP TABLE IF EXISTS test;
  CREATE TABLE test (id INTEGER);
  INSERT INTO test VALUES (1),(2);
  SELECT * FROM test WHERE id > 1;
");

let other_storage = SledDatabase::new("data/example_location/example_other")
  .map(Database::new_sled)
  .expect("Database Creation Failed");
let mut other_glue = Glue::new(String::from("other"), other_storage);

glue.extend_many_glues(vec![other_glue]);

pub fn extend_glue(&mut self, glue: Glue)

pub fn try_extend_from_path( &mut self, database_name: String, database_path: String, ) -> Result<bool>

Extend using a [Path] String which represents a path Guesses the type of database based on the extension Returns bool of whether action was taken

pub fn extend(&mut self, database_name: String, database: Database) -> bool

Extend Glue by single database Returns bool of whether action was taken

pub fn reduce(&mut self, database_name: &String) -> bool

Opposite of Glue::extend, removes database Returns bool of whether action was taken

impl Glue

pub fn into_connections(self) -> Vec<(String, Connection)>

impl Glue

Execute (Generic)

pub fn execute(&mut self, query: &str) -> Result<Payload>

Will execute a single query.

pub fn execute_many(&mut self, query: &str) -> Result<Vec<Payload>>

Will execute a set of queries.

pub fn execute_parsed(&mut self, query: Query) -> Result<Payload>

Will execute a pre-parsed query (see Glue::pre_parse() for more).

pub fn pre_parse(query: &str) -> Result<Vec<Query>>

Provides a parsed query to execute later. Particularly useful if executing a small query many times as parsing is not (computationally) free.

impl Glue

Insert (INSERT)

pub fn insert_vec( &mut self, table_name: String, columns: Vec<String>, rows: Vec<Vec<Value>>, ) -> Result<Payload>