Struct sql_query_builder::SelectBuilder

pub struct SelectBuilder<'a> { /* private fields */ }

Builder to contruct a select command

Implementations

impl<'a> SelectBuilder<'a>

pub fn and(self, condition: &'a str) -> Self

The same as where_clause method, useful to write more idiomatic SQL query

use sql_query_builder::SelectBuilder;

let select = SelectBuilder::new()
  .where_clause("login = foo")
  .and("active = true");

pub fn as_string(&self) -> String

Gets the current state of the SelectBuilder returns it as string

pub fn debug(self) -> Self

Prints the current state of the SelectBuilder into console output in a more ease to read version. This method is useful to debug complex queries or just to print the generated SQL while you type

use sql_query_builder::SelectBuilder;

let select = SelectBuilder::new()
  .select("*")
  .from("users")
  .where_clause("login = foo")
  .and("active = true")
  .debug();

Output

SELECT *
FROM users
WHERE login = foo AND active = true

You can debug different parts of the select putting it in another position

use sql_query_builder::SelectBuilder;

let select_query = SelectBuilder::new()
  .select("*")
  .from("users")
  .debug()
  .where_clause("login = foo")
  .and("active = true")
  .as_string();

Output

SELECT *
FROM users

pub fn except(self, select: Self) -> Self

The except clause, this method can be used enabling the feature flag postgresql

pub fn from(self, tables: &'a str) -> Self

The from clause

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

The group by clause

pub fn having(self, condition: &'a str) -> Self

The having clause

pub fn cross_join(self, table: &'a str) -> Self

The cross join clause

pub fn inner_join(self, table: &'a str) -> Self

The inner join clause

pub fn left_join(self, table: &'a str) -> Self

The left join clause

pub fn right_join(self, table: &'a str) -> Self

The right join clause

pub fn intersect(self, select: Self) -> Self

The intersect clause, this method can be used enabling the feature flag postgresql

pub fn limit(self, num: &'a str) -> Self

The limit clause. This method overrides the previous value

use sql_query_builder::SelectBuilder;

let select = SelectBuilder::new()
  .limit("123");

let select = SelectBuilder::new()
  .limit("1000")
  .limit("123");

pub fn new() -> Self

Create SelectBuilder’s instance

pub fn offset(self, num: &'a str) -> Self

The offset clause. This method overrides the previous value

use sql_query_builder::SelectBuilder;

let select = SelectBuilder::new()
  .offset("1500");

let select = SelectBuilder::new()
  .offset("1000")
  .offset("1500");

pub fn order_by(self, column: &'a str) -> Self

The order by clause

pub fn print(self) -> Self

Prints the current state of the SelectBuilder into console output similar to debug method, the difference is that this method prints in one line.

pub fn raw(self, raw_sql: &'a str) -> Self

Adds at the beginning a raw SQL query.

use sql_query_builder::SelectBuilder;

let raw_query = "select * from users u inner join address addr on u.login = addr.owner_login";
let select_query = SelectBuilder::new()
  .raw(raw_query)
  .where_clause("u.login = foo")
  .as_string();

Output

select * from users u inner join address addr on u.login = addr.owner_login
WHERE u.login = foo

pub fn raw_after(self, clause: SelectClause, raw_sql: &'a str) -> Self

Adds a raw SQL query after a specified clause.

use sql_query_builder::{SelectClause, SelectBuilder};

let raw_join = "inner join address addr on u.login = addr.owner_login";
let select_query = SelectBuilder::new()
  .select("*")
  .from("users u")
  .raw_after(SelectClause::From, raw_join)
  .where_clause("u.login = foo")
  .as_string();

Output

SELECT *
FROM users u
inner join address addr on u.login = addr.owner_login
WHERE u.login = foo

pub fn raw_before(self, clause: SelectClause, raw_sql: &'a str) -> Self

Adds a raw SQL query before a specified clause.

use sql_query_builder::{SelectClause, SelectBuilder};

let raw_query = "from users u inner join address addr on u.login = addr.owner_login";
let select_query = SelectBuilder::new()
  .select("*")
  .raw_before(SelectClause::Where, raw_query)
  .where_clause("u.login = foo")
  .as_string();

Output

SELECT *
from users u inner join address addr on u.login = addr.owner_login
WHERE u.login = foo

pub fn select(self, column: &'a str) -> Self

The select clause

pub fn union(self, select: Self) -> Self

The union clause, this method can be used enabling the feature flag postgresql

pub fn where_clause(self, condition: &'a str) -> Self

The where clause

use sql_query_builder::SelectBuilder;

let select = SelectBuilder::new()
  .from("users")
  .where_clause("login = $1");

pub fn with(self, name: &'a str, query: impl WithQuery + 'static) -> Self

The with clause, this method can be used enabling the feature flag postgresql

use sql_query_builder::{InsertBuilder, SelectBuilder};

let logins = SelectBuilder::new().select("login").from("users").where_clause("id in ($1)");
let select = SelectBuilder::new()
  .with("logins", logins)
  .select("name, price")
  .from("orders")
  .where_clause("owner_login in (select * from logins)")
  .debug();

Output

WITH logins AS (
  SELECT login
  FROM users
  WHERE id in ($1)
)
SELECT name, price
FROM orders
WHERE owner_login in (select * from active_users)

Trait Implementations

impl<'a> Clone for SelectBuilder<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SelectBuilder<'_>

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

Formats the value using the given formatter.

impl<'a> Default for SelectBuilder<'a>

fn default() -> SelectBuilder<'a>

Returns the “default value” for a type.

impl Display for SelectBuilder<'_>

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

Formats the value using the given formatter.