[−][src]Struct sql_builder::SqlBuilder

pub struct SqlBuilder { /* fields omitted */ }

Main SQL builder

Methods

`impl SqlBuilder`[src]

`pub fn select_from(table: &str) -> Self`[src]

Create SELECT query. You may specify comma separted list of tables.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where("price > 100")
    .and_where_like("title", "Harry Potter%")
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE (price > 100) AND (title LIKE 'Harry Potter%');", &sql);
// add                               ^^^^^
// here                              table

`pub fn select_values(values: &[&str]) -> Self`[src]

Create SELECT query without a table.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_values(&["10", &quote("100")])
    .sql()?;

assert_eq!("SELECT 10, '100';", &sql);
// add             ^^^^^^^^^
// here             values

`pub fn insert_into(table: &str) -> Self`[src]

Create INSERT query.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::insert_into("books")
    .field("title")
    .field("price")
    .values(&[&quote("In Search of Lost Time"), "150"])
    .values(&["'Don Quixote', 200"])
    .sql()?;

assert_eq!("INSERT INTO books (title, price) VALUES ('In Search of Lost Time', 150), ('Don Quixote', 200);", &sql);
// add                  ^^^^^
// here                 table

`pub fn update_table(table: &str) -> Self`[src]

Create UPDATE query.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::update_table("books")
    .set("price", "price + 10")
    .sql()?;

assert_eq!("UPDATE books SET price = price + 10;", &sql);
// add             ^^^^^
// here            table

`pub fn delete_from(table: &str) -> Self`[src]

Create DELETE query.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::delete_from("books")
    .and_where("price > 100")
    .sql()?;

assert_eq!("DELETE FROM books WHERE price > 100;", &sql);
// add                  ^^^^^
// here                 table

`pub fn join( &mut self, table: &str, operator: Option<&str>, constraint: Option<&str> ) -> &mut Self`[src]

Join with table.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books AS b")
    .field("b.title")
    .field("s.total")
    .join("shops AS s", Some("LEFT OUTER"), Some("ON b.id = s.book"))
    .sql()?;

assert_eq!("SELECT b.title, s.total FROM books AS b LEFT OUTER JOIN shops AS s ON b.id = s.book;", &sql);
// add                                              ^^^^^^^^^^      ^^^^^^^^^^ ^^^^^^^^^^^^^^^^
// here                                              operator         table       constraint

`pub fn distinct(&mut self) -> &mut Self`[src]

Set DISTINCT for fields.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .distinct()
    .field("price")
    .sql()?;

assert_eq!("SELECT DISTINCT price FROM books;", &sql);
// add here        ^^^^^^^^

`pub fn fields(&mut self, fields: &[&str]) -> &mut Self`[src]

Add fields.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .fields(&["title", "price"])
    .sql()?;

assert_eq!("SELECT title, price FROM books;", &sql);
// add             ^^^^^^^^^^^^
// here               fields

`pub fn set_fields(&mut self, fields: &[&str]) -> &mut Self`[src]

Replace fields.

extern crate sql_builder;

use sql_builder::SqlBuilder;

// Prepare query for total count

let mut db = SqlBuilder::select_from("books");

db.field("COUNT(id)");

if let Some(filter) = &req_data.filter {
  let item = format!("LOWER(title) LIKE '%{}%'", filter.to_lowercase());
  db.and_where(&item);
}

if let Some(price_min) = &req_data.price_min {
  let item = format!("price >= {}", price_min);
  db.and_where(&item);
}

if let Some(price_max) = &req_data.price_max {
  let item = format!("price <= {}", price_max);
  db.and_where(&item);
}

let sql_count = db.sql()?;
println!("Database query: total_count: {}", &sql_count);

// Prepare query for results

db.set_fields(&["id", "title", "price"]);

if let (Some(limit), Some(offset)) = (req_data.limit, req_data.offset) {
  db.limit(limit).offset(offset);
}

let sql_results = db.sql()?;
println!("Database query: results: {}", &sql_results);

`pub fn field(&mut self, field: &str) -> &mut Self`[src]

Add field.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .sql()?;

assert_eq!("SELECT title, price FROM books;", &sql);
// add             ^^^^^  ^^^^^
// here            field  field

`pub fn set_field(&mut self, field: &str) -> &mut Self`[src]

Replace fields with choosed one.

extern crate sql_builder;

use sql_builder::SqlBuilder;

// Prepare query for total count

let mut db = SqlBuilder::select_from("books");

db.field("COUNT(id)");

if let Some(filter) = &req_data.filter {
  let item = format!("LOWER(title) LIKE '%{}%'", filter.to_lowercase());
  db.and_where(&item);
}

if let Some(price_min) = &req_data.price_min {
  let item = format!("price >= {}", price_min);
  db.and_where(&item);
}

if let Some(price_max) = &req_data.price_max {
  let item = format!("price <= {}", price_max);
  db.and_where(&item);
}

let sql_count = db.sql()?;
println!("Database query: total_count: {}", &sql_count);

// Prepare query for results

db.set_field("id");
db.field("title");
db.field("price");

if let (Some(limit), Some(offset)) = (req_data.limit, req_data.offset) {
  db.limit(limit).offset(offset);
}

let sql_results = db.sql()?;
println!("Database query: results: {}", &sql_results);

`pub fn set(&mut self, field: &str, value: &str) -> &mut Self`[src]

Add SET part (for UPDATE).

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::update_table("books")
    .set("price", "price + 10")
    .sql()?;

assert_eq!("UPDATE books SET price = price + 10;", &sql);
// add                       ^^^^^   ^^^^^^^^^^
// here                      field     value

`pub fn values(&mut self, values: &[&str]) -> &mut Self`[src]

Add VALUES part (for INSERT).

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::insert_into("books")
    .field("title")
    .field("price")
    .values(&[&quote("In Search of Lost Time"), "150"])
    .values(&["'Don Quixote', 200"])
    .sql()?;

assert_eq!("INSERT INTO books (title, price) VALUES ('In Search of Lost Time', 150), ('Don Quixote', 200);", &sql);
// add                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^
// here                                                         values                      values

`pub fn select(&mut self, query: &str) -> &mut Self`[src]

Add SELECT part (for INSERT).

extern crate sql_builder;

use sql_builder::SqlBuilder;

let query = SqlBuilder::select_from("warehouse")
    .field("title")
    .field("preliminary_price * 2")
    .query()?;

assert_eq!("SELECT title, preliminary_price * 2 FROM warehouse", &query);

let sql = SqlBuilder::insert_into("books")
    .field("title")
    .field("price")
    .select(&query)
    .sql()?;

assert_eq!("INSERT INTO books (title, price) SELECT title, preliminary_price * 2 FROM warehouse;", &sql);
// add                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                                            query

`pub fn group_by(&mut self, field: &str) -> &mut Self`[src]

Add GROUP BY part.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("price")
    .field("COUNT(price) AS cnt")
    .group_by("price")
    .order_desc("cnt")
    .sql()?;

assert_eq!("SELECT price, COUNT(price) AS cnt FROM books GROUP BY price ORDER BY cnt DESC;", &sql);
// add                                                            ^^^^^
// here                                                           field

`pub fn having(&mut self, cond: &str) -> &mut Self`[src]

Add HAVING condition.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("price")
    .field("COUNT(price) AS cnt")
    .group_by("price")
    .having("price > 100")
    .order_desc("cnt")
    .sql()?;

assert_eq!("SELECT price, COUNT(price) AS cnt FROM books GROUP BY price HAVING price > 100 ORDER BY cnt DESC;", &sql);
// add                                                                         ^^^^^^^^^^^
// here                                                                           cond

`pub fn and_where(&mut self, cond: &str) -> &mut Self`[src]

Add WHERE condition.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where("price > 100")
    .and_where("title LIKE 'Harry Potter%'")
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE (price > 100) AND (title LIKE 'Harry Potter%');", &sql);
// add                                            ^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                              cond                      cond

`pub fn and_where_eq(&mut self, field: &str, value: &str) -> &mut Self`[src]

Add WHERE condition for equal parts.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("price")
    .and_where_eq("title", &quote("Harry Potter and the Philosopher's Stone"))
    .sql()?;

assert_eq!("SELECT price FROM books WHERE title = 'Harry Potter and the Philosopher''s Stone';", &sql);
// add                                    ^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                   field                      value

`pub fn and_where_ne(&mut self, field: &str, value: &str) -> &mut Self`[src]

Add WHERE condition for non-equal parts.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("price")
    .and_where_ne("title", &quote("Harry Potter and the Philosopher's Stone"))
    .sql()?;

assert_eq!("SELECT price FROM books WHERE title <> 'Harry Potter and the Philosopher''s Stone';", &sql);
// add                                    ^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                   field                       value

`pub fn and_where_like(&mut self, field: &str, mask: &str) -> &mut Self`[src]

Add WHERE LIKE condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("price")
    .and_where_like("title", "%Philosopher's%")
    .sql()?;

assert_eq!("SELECT price FROM books WHERE title LIKE '%Philosopher''s%';", &sql);
// add                                    ^^^^^       ^^^^^^^^^^^^^^^^
// here                                   field             mask

`pub fn and_where_not_like(&mut self, field: &str, mask: &str) -> &mut Self`[src]

Add WHERE NOT LIKE condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .and_where_not_like("title", "%Alice's%")
    .sql()?;

assert_eq!("SELECT title FROM books WHERE title NOT LIKE '%Alice''s%';", &sql);
// add                                    ^^^^^           ^^^^^^^^^^
// here                                   field              mask

`pub fn and_where_is_null(&mut self, field: &str) -> &mut Self`[src]

Add WHERE IS NULL condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .and_where_is_null("price")
    .sql()?;

assert_eq!("SELECT title FROM books WHERE price IS NULL;", &sql);
// add                                    ^^^^^
// here                                   field

`pub fn and_where_is_not_null(&mut self, field: &str) -> &mut Self`[src]

Add WHERE IS NOT NULL condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .and_where_is_not_null("price")
    .sql()?;

assert_eq!("SELECT title FROM books WHERE price IS NOT NULL;", &sql);
// add                                    ^^^^^
// here                                   field

`pub fn or_where(&mut self, cond: &str) -> &mut Self`[src]

Add OR condition to the last WHERE condition.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where("price < 10")
    .or_where("price > 1000")
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE price < 10 OR price > 1000;", &sql);
// add                                                         ^^^^^^^^^^^^
// here                                                            cond

`pub fn or_where_eq(&mut self, field: &str, value: &str) -> &mut Self`[src]

Add OR condition of equal parts to the last WHERE condition.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("price")
    .and_where_eq("title", &quote("Harry Potter and the Philosopher's Stone"))
    .or_where_eq("title", &quote("Harry Potter and the Chamber of Secrets"))
    .sql()?;

assert_eq!("SELECT price FROM books WHERE title = 'Harry Potter and the Philosopher''s Stone' OR title = 'Harry Potter and the Chamber of Secrets';", &sql);
// add                                                                                           ^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                                                                          field                     value

`pub fn or_where_ne(&mut self, field: &str, value: &str) -> &mut Self`[src]

Add OR condition of non-equal parts to the last WHERE condition.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let sql = SqlBuilder::select_from("books")
    .field("price")
    .or_where_ne("title", &quote("Harry Potter and the Philosopher's Stone"))
    .or_where_ne("title", &quote("Harry Potter and the Chamber of Secrets"))
    .sql()?;

assert_eq!("SELECT price FROM books WHERE title <> 'Harry Potter and the Philosopher''s Stone' OR title <> 'Harry Potter and the Chamber of Secrets';", &sql);
// add                                    ^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                   field                       value                       field                      value

`pub fn or_where_like(&mut self, field: &str, mask: &str) -> &mut Self`[src]

Add OR LIKE condition to the last WHERE condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("price")
    .or_where_like("title", "%Alice's%")
    .or_where_like("title", "%Philosopher's%")
    .sql()?;

assert_eq!("SELECT price FROM books WHERE title LIKE '%Alice''s%' OR title LIKE '%Philosopher''s%';", &sql);
// add                                    ^^^^^      ^^^^^^^^^^^^    ^^^^^      ^^^^^^^^^^^^^^^^^^
// here                                   field          mask        field             mask

`pub fn or_where_not_like(&mut self, field: &str, mask: &str) -> &mut Self`[src]

Add OR NOT LIKE condition to the last WHERE condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .and_where_not_like("title", "%Alice's%")
    .or_where_not_like("title", "%Philosopher's%")
    .sql()?;

assert_eq!("SELECT title FROM books WHERE title NOT LIKE '%Alice''s%' OR title NOT LIKE '%Philosopher''s%';", &sql);
// add                                                                   ^^^^^          ^^^^^^^^^^^^^^^^^^
// here                                                                  field                 mask

`pub fn or_where_is_null(&mut self, field: &str) -> &mut Self`[src]

Add OR IS NULL condition to the last WHERE condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .and_where_eq("price", "0")
    .or_where_is_null("price")
    .sql()?;

assert_eq!("SELECT title FROM books WHERE price = 0 OR price IS NULL;", &sql);
// add                                                 ^^^^^
// here                                                field

`pub fn or_where_is_not_null(&mut self, field: &str) -> &mut Self`[src]

Add OR IS NOT NULL condition to the last WHERE condition.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .or_where_is_not_null("title")
    .or_where_is_not_null("price")
    .sql()?;

assert_eq!("SELECT title FROM books WHERE title IS NOT NULL OR price IS NOT NULL;", &sql);
// add                                    ^^^^^                ^^^^^
// here                                   field                field

`pub fn union(&mut self, query: &str) -> &mut Self`[src]

Union query with subquery. ORDER BY must be in the last subquery.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let append = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where("price < 100")
    .order_asc("title")
    .query()?;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_desc("price")
    .union(&append)
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' UNION SELECT title, price FROM books WHERE price < 100 ORDER BY title;", &sql);
// add                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                                                                                        query

`pub fn union_all(&mut self, query: &str) -> &mut Self`[src]

Union query with all subquery. ORDER BY must be in the last subquery.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let append = SqlBuilder::select_values(&["'The Great Gatsby'", "124"])
    .query_values()?;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_desc("price")
    .union_all(&append)
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' UNION ALL SELECT 'The Great Gatsby', 124;", &sql);
// add                                                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// here                                                                                           query

`pub fn order_by(&mut self, field: &str, desc: bool) -> &mut Self`[src]

Add ORDER BY.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_by("price", false)
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' ORDER BY price;", &sql);
// add                                                                               ^^^^^
// here                                                                              field

`pub fn order_asc(&mut self, field: &str) -> &mut Self`[src]

Add ORDER BY ASC.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_asc("title")
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' ORDER BY title;", &sql);
// add                                                                               ^^^^^
// here                                                                              field

`pub fn order_desc(&mut self, field: &str) -> &mut Self`[src]

Add ORDER BY DESC.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_desc("price")
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' ORDER BY price DESC;", &sql);
// add                                                                               ^^^^^
// here                                                                              field

`pub fn limit(&mut self, limit: usize) -> &mut Self`[src]

Set LIMIT.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_desc("price")
    .limit(10)
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' ORDER BY price DESC LIMIT 10;", &sql);
// add                                                                                                ^^
// here                                                                                              limit

`pub fn offset(&mut self, offset: usize) -> &mut Self`[src]

Set OFFSET.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .and_where_like("title", "Harry Potter%")
    .order_desc("price")
    .limit(10)
    .offset(100)
    .sql()?;

assert_eq!("SELECT title, price FROM books WHERE title LIKE 'Harry Potter%' ORDER BY price DESC LIMIT 10 OFFSET 100;", &sql);
// add                                                                                                          ^^^
// here                                                                                                        offset

`pub fn sql(&self) -> Result<String, Box<dyn Error>>`[src]

Build complete SQL command.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let sql = SqlBuilder::select_from("books").sql()?;

assert_eq!("SELECT * FROM books;", &sql);

`pub fn subquery(&self) -> Result<String, Box<dyn Error>>`[src]

Build subquery SQL command.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let cat = SqlBuilder::select_from("books")
    .field("CASE WHEN price < 100 THEN 'cheap' ELSE 'expensive' END AS category")
    .subquery()?;

assert_eq!("(SELECT CASE WHEN price < 100 THEN 'cheap' ELSE 'expensive' END AS category FROM books)", &cat);

let sql = SqlBuilder::select_from(&cat)
    .field("category")
    .field("COUNT(category) AS cnt")
    .group_by("category")
    .order_desc("cnt")
    .order_asc("category")
    .sql()?;

assert_eq!("SELECT category, COUNT(category) AS cnt FROM (SELECT CASE WHEN price < 100 THEN 'cheap' ELSE 'expensive' END AS category FROM books) GROUP BY category ORDER BY cnt DESC, category;", &sql);

`pub fn subquery_as(&self, name: &str) -> Result<String, Box<dyn Error>>`[src]

Build named subquery SQL command

extern crate sql_builder;

use sql_builder::SqlBuilder;

let cat = SqlBuilder::select_from("books")
    .field("CASE WHEN price < 100 THEN 'cheap' ELSE 'expensive' END")
    .subquery_as("category")?;

assert_eq!("(SELECT CASE WHEN price < 100 THEN 'cheap' ELSE 'expensive' END FROM books) AS category", &cat);
// add                                                                                     ^^^^^^^^
// here                                                                                      name

let sql = SqlBuilder::select_from("books")
    .field("title")
    .field("price")
    .field(&cat)
    .sql()?;

assert_eq!("SELECT title, price, (SELECT CASE WHEN price < 100 THEN 'cheap' ELSE 'expensive' END FROM books) AS category FROM books;", &sql);

`pub fn query(&self) -> Result<String, Box<dyn Error>>`[src]

SQL command generator for query or subquery.

extern crate sql_builder;

use sql_builder::SqlBuilder;

let query = SqlBuilder::select_from("warehouse")
    .field("title")
    .field("preliminary_price * 2")
    .query()?;

assert_eq!("SELECT title, preliminary_price * 2 FROM warehouse", &query);

let sql = SqlBuilder::insert_into("books")
    .field("title")
    .field("price")
    .select(&query)
    .sql()?;

assert_eq!("INSERT INTO books (title, price) SELECT title, preliminary_price * 2 FROM warehouse;", &sql);

`pub fn query_values(&self) -> Result<String, Box<dyn Error>>`[src]

SQL command generator for query or subquery without a table.

extern crate sql_builder;

use sql_builder::{SqlBuilder, quote};

let values = SqlBuilder::select_values(&["10", &quote("100")])
    .query_values()?;

assert_eq!("SELECT 10, '100'", &values);

Auto Trait Implementations

`impl RefUnwindSafe for SqlBuilder`

`impl Send for SqlBuilder`

`impl Sync for SqlBuilder`

`impl Unpin for SqlBuilder`

`impl UnwindSafe for SqlBuilder`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

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

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

[−][src]Struct sql_builder::SqlBuilder

Methods

impl SqlBuilder[src]

pub fn select_from(table: &str) -> Self[src]

pub fn select_values(values: &[&str]) -> Self[src]

pub fn insert_into(table: &str) -> Self[src]

pub fn update_table(table: &str) -> Self[src]

pub fn delete_from(table: &str) -> Self[src]

pub fn join( &mut self, table: &str, operator: Option<&str>, constraint: Option<&str>) -> &mut Self[src]

pub fn distinct(&mut self) -> &mut Self[src]

pub fn fields(&mut self, fields: &[&str]) -> &mut Self[src]

pub fn set_fields(&mut self, fields: &[&str]) -> &mut Self[src]

pub fn field(&mut self, field: &str) -> &mut Self[src]

pub fn set_field(&mut self, field: &str) -> &mut Self[src]

pub fn set(&mut self, field: &str, value: &str) -> &mut Self[src]

pub fn values(&mut self, values: &[&str]) -> &mut Self[src]

pub fn select(&mut self, query: &str) -> &mut Self[src]

pub fn group_by(&mut self, field: &str) -> &mut Self[src]

pub fn having(&mut self, cond: &str) -> &mut Self[src]

pub fn and_where(&mut self, cond: &str) -> &mut Self[src]

pub fn and_where_eq(&mut self, field: &str, value: &str) -> &mut Self[src]

pub fn and_where_ne(&mut self, field: &str, value: &str) -> &mut Self[src]

pub fn and_where_like(&mut self, field: &str, mask: &str) -> &mut Self[src]

pub fn and_where_not_like(&mut self, field: &str, mask: &str) -> &mut Self[src]

pub fn and_where_is_null(&mut self, field: &str) -> &mut Self[src]

pub fn and_where_is_not_null(&mut self, field: &str) -> &mut Self[src]

pub fn or_where(&mut self, cond: &str) -> &mut Self[src]

pub fn or_where_eq(&mut self, field: &str, value: &str) -> &mut Self[src]

pub fn or_where_ne(&mut self, field: &str, value: &str) -> &mut Self[src]

pub fn or_where_like(&mut self, field: &str, mask: &str) -> &mut Self[src]

pub fn or_where_not_like(&mut self, field: &str, mask: &str) -> &mut Self[src]

pub fn or_where_is_null(&mut self, field: &str) -> &mut Self[src]

pub fn or_where_is_not_null(&mut self, field: &str) -> &mut Self[src]

pub fn union(&mut self, query: &str) -> &mut Self[src]

pub fn union_all(&mut self, query: &str) -> &mut Self[src]

pub fn order_by(&mut self, field: &str, desc: bool) -> &mut Self[src]

pub fn order_asc(&mut self, field: &str) -> &mut Self[src]

pub fn order_desc(&mut self, field: &str) -> &mut Self[src]

pub fn limit(&mut self, limit: usize) -> &mut Self[src]

pub fn offset(&mut self, offset: usize) -> &mut Self[src]

pub fn sql(&self) -> Result<String, Box<dyn Error>>[src]

pub fn subquery(&self) -> Result<String, Box<dyn Error>>[src]

pub fn subquery_as(&self, name: &str) -> Result<String, Box<dyn Error>>[src]

pub fn query(&self) -> Result<String, Box<dyn Error>>[src]

pub fn query_values(&self) -> Result<String, Box<dyn Error>>[src]

Auto Trait Implementations

impl RefUnwindSafe for SqlBuilder

impl Send for SqlBuilder

impl Sync for SqlBuilder

impl Unpin for SqlBuilder

impl UnwindSafe for SqlBuilder