Struct multisql::Glue

pub struct Glue {
    pub primary: String,
    /* 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

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 delete(
    &mut self,
    table_name: &ObjectName,
    selection: &Option<Expr>
) -> Result<Payload>

impl Glue

pub async fn insert(
    &mut self,
    table_name: &ObjectName,
    columns: &[Ident],
    source: &Query,
    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 update(
    &mut self,
    table: &TableWithJoins,
    selection: &Option<Expr>,
    assignments: &[Assignment]
) -> Result<Payload>

impl Glue

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

impl Glue

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

impl Glue

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

impl Glue

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

impl Glue

pub async fn 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 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 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 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_context(&self) -> Result<MutexGuard<'_, Context>>

pub fn get_mut_context(&mut self) -> Result<&mut Context>

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

impl Glue

Select (SELECT)

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

Only for SELECT queries.

Output is one big String of JSON, wrapped in a Result in case it fails.

Generally useful for webby interactions.

pub fn select_as_json_with_headers(&mut self, query: &str) -> String

Only for SELECT queries.

Output is one big String of JSON, failures will be converted to json of {error: [error]}.

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>