[−][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("title LIKE 'Harry Potter%'")
    .sql()?;

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

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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
);

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
);

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
);

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("title LIKE 'Harry Potter%'")
    .order_by("price", false)
    .sql()?;

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

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("title LIKE 'Harry Potter%'")
    .order_asc("title")
    .sql()?;

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

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("title LIKE 'Harry Potter%'")
    .order_desc("price")
    .sql()?;

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

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("title LIKE '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
);

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("title LIKE '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
);

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);

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);

Auto Trait Implementations

Blanket Implementations

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

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

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

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

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

The type returned in the event of a conversion error.