qubl

Struct QueryBuilder

Source 
pub struct QueryBuilder<'a> {
    pub query: String,
    pub table: String,
    pub qtype: QueryType,
    pub list: Vec<KeywordList>,
    pub hq: Option<[&'a str; 26]>,
}
Expand description

Struct that benefits to build queries for interactions with rdbms’s.

Fields§

§query: String§table: String§qtype: QueryType§list: Vec<KeywordList>§hq: Option<[&'a str; 26]>

Implementations§

Source§

impl<'a> QueryBuilder<'a>

Implementations For QueryBuilder.

Source

pub fn select(fields: Vec<&str>) -> Result<Self, Error>

Select constructor. Use it if you want to build a Select Query.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap();
}
Source

pub fn delete() -> Result<Self, Error>

Delete constructor. Use it if you want to build a Delete Query.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::delete().unwrap();
}
Source

pub fn update() -> Result<Self, Error>

Update constructor. Use it if you want to build a Update Query.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::update().unwrap();
}
Source

pub fn insert(columns: Vec<&str>, values: Vec<ValueType>) -> Result<Self, Error>

Insert constructor. Use it if you want to build a Insert Query.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let fields = vec!["id", "age", "name"];
    let values = vec![ValueType::Int32(5), ValueType::Int64(25), ValueType::String("necdet".to_string())]
 
    let query = QueryBuilder::insert(fields, values).unwrap();
}
Source

pub fn table(&mut self, table: &str) -> &mut Self

define the table. It should came after the constructors.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users");
}
Source

pub fn count(condition: &str, _as: Option<&str>) -> Self

Count constructor. Use it if you want to learn to length of a table.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::count("*", Some("length")).table("users");
}
Source

pub fn where_( &mut self, column: &str, mark: &str, value: ValueType, ) -> &mut Self

add the “WHERE” keyword with it’s synthax.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_("id", "=", ValueType::Int32(5)).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id = 5;")
}
Source

pub fn where_in(&mut self, column: &str, ins: &Vec<ValueType>) -> &mut Self

It adds the “IN” keyword with it’s synthax. Don’t use “.where_cond()” method if you use it.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_in("id", &ins).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id IN (1, 5, 10);")
}
Source

pub fn where_not_in(&mut self, column: &str, ins: &Vec<ValueType>) -> &mut Self

It adds the “NOT IN” keyword with it’s synthax. Don’t use “.where_cond()” method if you use it.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_not_in("id", &ins).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id NOT IN (1, 5, 10);")
}
Source

pub fn where_in_custom(&mut self, column: &str, query: &str) -> &mut Self

It adds the “IN” keyword with it’s synthax and an empty condition, use it if you want to give more complex condition to “IN” keyword. Don’t use “.where_cond()” with it.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_in_custom("id", "1, 5, 10").finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id IN (1, 5, 10);")
}
Source

pub fn where_not_in_custom(&mut self, column: &str, query: &str) -> &mut Self

It adds the “NOT IN” keyword with it’s synthax and an empty condition, use it if you want to give more complex condition to “NOT IN” keyword. Don’t use “.where_cond()” with it.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_not_in_custom("id", "1, 5, 10").finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id NOT IN (1, 5, 10);")
}
Source

pub fn or(&mut self, column: &str, mark: &str, value: ValueType) -> &mut Self

It adds the “OR” keyword with it’s synthax. Warning: It’s not ready yet to chaining “AND” and “OR” keywords, for now, applying that kind of complex query use “.append_custom()” method instead.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_("id", "=", ValueType::Int32(10)).or("name", "=", ValueType::String("necdet".to_string())).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id = 10 OR name = 'necdet';")
}
Source

pub fn set(&mut self, column: &str, value: ValueType) -> &mut Self

It adds the “SET” keyword with it’s synthax.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::update().unwrap()
                             .table("users")
                             .set("name", ValueType::String("arda".to_string()))
                             .where_("id", "=", ValueType::Int32(1))
                             .finish();
 
    assert_eq!(query, "UPDATE users SET name = 'arda' WHERE id = 1;")
}
Source

pub fn and(&mut self, column: &str, mark: &str, value: ValueType) -> &mut Self

It adds the “AND” keyword with it’s synthax. Warning: It’s not ready yet to chaining “OR” and “AND” keywords, for now, applying that kind of complex query use “.append_custom()” method instead.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_("id", "=", ValueType::Int32(10)).and("name", "=", ValueType::String("necdet".to_string())).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id = 10 AND name = 'necdet';")
}
Source

pub fn offset(&mut self, offset: i32) -> &mut Self

It adds the “OFFSET” keyword with it’s synthax. Be careful about it’s alignment with “LIMIT” keyword.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_("id", "=", ValueType::Int32(10)).limit(5).offset(0).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id = 10 LIMIT 5 OFFSET 0;")
}
Source

pub fn limit(&mut self, limit: i32) -> &mut Self

It adds the “LIMIT” keyword with it’s synthax.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let ins = vec![ValueType::Int16(1), ValueType::Int64(5), ValueType::Int32(10)];
    let query = QueryBuilder::select(vec!["*"]).unwrap().table("users").where_("id", "=", ValueType::Int32(10)).limit(5).offset(0).finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE id = 10 LIMIT 5 OFFSET 0;")
}
Source

pub fn like(&mut self, columns: Vec<&str>, operand: &str) -> &mut Self

It adds the “LIKE” keyword with it’s synthax.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap()
                             .table("blogs")
                             .like(vec!["description", "title"], "qubl is awesome!")
                             .finish();
 
    assert_eq!(query, "SELECT * FROM blogs WHERE description LIKE '%qubl is awesome!%' OR title LIKE '%qubl is awesome!%';")
}
 
// it has more niche and different usages, for them check the tests.
Source

pub fn order_by(&mut self, column: &str, ordering: &str) -> &mut Self

It adds the “ORDER BY” keyword with it’s synthax. It only accepts “ASC”, “DESC”, “asc”, “desc” values.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap()
                             .table("users")
                             .where_("age", ">", ValueType::Int32(25))
                             .order_by("id", "ASC")
                             .limit(5)
                             .offset(0)
                             .finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE age > 25 ORDER BY id ASC LIMIT 5 OFFSET 0;")
}
Source

pub fn order_random(&mut self) -> &mut Self

A practical method that adds a query for shuffling the lines.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap()
                             .table("users")
                             .where_("age", ">", ValueType::Int32(25))
                             .order_random()
                             .limit(5)
                             .offset(0)
                             .finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE age > 25 ORDER BY RAND() LIMIT 5 OFFSET 0;")
}
Source

pub fn order_by_field(&mut self, column: &str, ordering: Vec<&str>) -> &mut Self

Adds “FIELD()” function with it’s synthax. It’s used on ordering depending on strings.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap()
                             .table("users")
                             .where_("age", ">", ValueType::Int32(25))
                             .order_by_field("role", vec!["admin", "member", "observer"])
                             .limit(5)
                             .offset(0)
                             .finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE age > 25 ORDER BY FIELD(role, 'admin', 'member', 'observer') LIMIT 5 OFFSET 0;")
}
Source

pub fn group_by(&mut self, column: &str) -> &mut Self

It adds the “GROUP BY” keyword with it’s Synthax.

Source

pub fn having( &mut self, column: &str, mark: &str, value: ValueType, ) -> &mut Self

Source

pub fn append_custom(&mut self, query: &str) -> &mut Self

A wildcard method that gives you the chance to write a part of your query. Warning, it does not add any keyword to builder, i’ll encourage to add proper keyword to it with .append_keyword() method for your custom query, otherwise you should continue building your query by yourself with that function, or you’ve to be prepared to encounter bugs.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap()
                             .table("users")
                             .append_custom("WHERE age > 25 ORDER BY FIELD(role, 'admin', 'member', 'observer') LIMIT 5 OFFSET 0")
                             .finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE age > 25 ORDER BY FIELD(role, 'admin', 'member', 'observer') LIMIT 5 OFFSET 0;")
}
Source

pub fn append_keyword(&mut self, keyword: KeywordList) -> &mut Self

A wildcard method that benefits you to append a keyword to the keyword list, so the QueryBuilder can build your queries properly, later than you appended your custom string to your query. It should be used with .append_custom() method.

 
use qubl::{QueryBuilder, ValueType, KeywordList};
 
fn main(){
    let query = QueryBuilder::select(vec!["*"]).unwrap()
                             .table("users")
                             .append_custom("WHERE age > 25 ORDER BY FIELD(role, 'admin', 'member', 'observer') LIMIT 5 OFFSET 0")
                             .append_keyword(KeywordList::Where)
                             .append_keyword(KeywordList::Field)
                             .append_keyword(KeywordList::Limit)
                             .append_keyword(KeywordList::Offset)
                             .finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE age > 25 ORDER BY FIELD(role, 'admin', 'member', 'observer') LIMIT 5 OFFSET 0;")
}
Source

pub fn json_extract( &mut self, haystack: &str, needle: &str, _as: Option<&str>, ) -> &mut Self

It applies “JSON_EXTRACT()” mysql function with it’s Synthax. If you encounter any syntactic bugs or deficiencies about that function, please report it via opening an issue.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(["*"].to_vec()).unwrap()
                             .json_extract("articles", "[0]", Some("blog1"))
                             .json_extract("articles", "[1]", Some("blog2"))
                             .json_extract("articles", "[2]", Some("blog3"))
                             .table("users")
                             .where_("published", "=", ValueType::Int32(1))
                             .finish();
 
    assert_eq!(query, "SELECT JSON_EXTRACT(articles, '$[0]') AS blog1, JSON_EXTRACT(articles, '$[1]') AS blog2, JSON_EXTRACT(articles, '$[2]') AS blog3 FROM users WHERE published = 1;")
}
Source

pub fn json_contains( &mut self, column: &str, needle: ValueType, path: Option<&str>, ) -> &mut Self

It applies “JSON_CONTAINS()” mysql function with it’s Synthax. If you encounter any syntactic bugs or deficiencies about that function, please report it via opening an issue.

 
use qubl::{QueryBuilder, ValueType};
 
fn main(){
    let query = QueryBuilder::select(["*"].to_vec()).unwrap()
                             .table("users")
                             .where_("pic", "=", ValueType::String("".to_string()))
                             .json_contains("pic", ValueType::String("{{ \"name\": \"blablabla.jpg\"}}".to_string()), Some(".name"))
                             .finish();
 
    assert_eq!(query, "SELECT * FROM users WHERE JSON_CONTAINS(pic, '{{ \"name\": \"blablabla.jpg\"}}', '$.name');")
}
Source

pub fn finish(&self) -> String

finishes the query and returns the result as string.

Source

pub fn copy(&mut self) -> Self

gives you an immutable copy of that instance, just for case if you need to share and potentially mutate it across threads.

Trait Implementations§

Source§

impl<'a> Clone for QueryBuilder<'a>

Source§

fn clone(&self) -> QueryBuilder<'a>

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<'a> Debug for QueryBuilder<'a>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<'a> Freeze for QueryBuilder<'a>

§

impl<'a> RefUnwindSafe for QueryBuilder<'a>

§

impl<'a> Send for QueryBuilder<'a>

§

impl<'a> Sync for QueryBuilder<'a>

§

impl<'a> Unpin for QueryBuilder<'a>

§

impl<'a> UnwindSafe for QueryBuilder<'a>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.