Struct quaint::ast::Select

pub struct Select<'a> { /* fields omitted */ }

A builder for a SELECT statement.

Methods

impl<'a> Select<'a>

pub fn from_table<T>(table: T) -> Self where
    T: Into<Table<'a>>, 

Creates a new SELECT statement for the given table.

let query = Select::from_table("users");
let (sql, _) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users`", sql);

The table can be in multiple parts, defining the database.

let query = Select::from_table(("crm", "users"));
let (sql, _) = Sqlite::build(query);

assert_eq!("SELECT `crm`.`users`.* FROM `crm`.`users`", sql);

It is also possible to use a nested SELECT.

let select = Table::from(Select::default().value(1)).alias("num");
let query = Select::from_table(select.alias("num"));
let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `num`.* FROM (SELECT ?) AS `num`", sql);
assert_eq!(vec![ParameterizedValue::from(1)], params);

pub fn value<T>(self, value: T) -> Self where
    T: Into<DatabaseValue<'a>>, 

Selects a static value as the column.

let query = Select::default().value(1);
let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT ?", sql);
assert_eq!(vec![ParameterizedValue::from(1)], params);

Creating a qualified asterisk to a joined table:

let join = "dogs".on(("dogs", "slave_id").equals(Column::from(("cats", "master_id"))));

let query = Select::from_table("cats")
    .value(Table::from("cats").asterisk())
    .value(col!("dogs", "age") - val!(4))
    .inner_join(join);

let (sql, params) = Sqlite::build(query);

assert_eq!(
    "SELECT `cats`.*, (`dogs`.`age` - ?) FROM `cats` INNER JOIN `dogs` ON `dogs`.`slave_id` = `cats`.`master_id`",
    sql
);

assert_eq!(vec![ParameterizedValue::from(4)], params);

pub fn column<T>(self, column: T) -> Self where
    T: Into<Column<'a>>, 

Adds a column to be selected.

let query = Select::from_table("users")
    .column("name")
    .column(("users", "id"))
    .column((("crm", "users"), "foo"));

let (sql, _) = Sqlite::build(query);

assert_eq!("SELECT `name`, `users`.`id`, `crm`.`users`.`foo` FROM `users`", sql);

pub fn columns<T, C>(self, columns: T) -> Self where
    T: IntoIterator<Item = C>,
    C: Into<Column<'a>>, 

A bulk method to select multiple values.

let query = Select::from_table("users").columns(vec!["foo", "bar"]);
let (sql, _) = Sqlite::build(query);

assert_eq!("SELECT `foo`, `bar` FROM `users`", sql);

pub fn so_that<T>(self, conditions: T) -> Self where
    T: Into<ConditionTree<'a>>, 

Adds WHERE conditions to the query, replacing the previous conditions. See Comparable for more examples.

let query = Select::from_table("users").so_that("foo".equals("bar"));
let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users` WHERE `foo` = ?", sql);

assert_eq!(vec![
   ParameterizedValue::from("bar"),
], params);

pub fn and_where<T>(self, conditions: T) -> Self where
    T: Into<ConditionTree<'a>>, 

Adds an additional WHERE condition to the query combining the possible previous condition with AND. See Comparable for more examples.

let query = Select::from_table("users")
    .so_that("foo".equals("bar"))
    .and_where("lol".equals("wtf"));

let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users` WHERE (`foo` = ? AND `lol` = ?)", sql);

assert_eq!(vec![
   ParameterizedValue::from("bar"),
   ParameterizedValue::from("wtf"),
], params);

pub fn or_where<T>(self, conditions: T) -> Self where
    T: Into<ConditionTree<'a>>, 

Adds an additional WHERE condition to the query combining the possible previous condition with OR. See Comparable for more examples.

let query = Select::from_table("users")
    .so_that("foo".equals("bar"))
    .or_where("lol".equals("wtf"));

let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users` WHERE (`foo` = ? OR `lol` = ?)", sql);

assert_eq!(vec![
   ParameterizedValue::from("bar"),
   ParameterizedValue::from("wtf"),
], params);

pub fn inner_join<J>(self, join: J) -> Self where
    J: Into<JoinData<'a>>, 

Adds INNER JOIN clause to the query.

let join = "posts".alias("p").on(("p", "user_id").equals(Column::from(("users", "id"))));
let query = Select::from_table("users").inner_join(join);
let (sql, _) = Sqlite::build(query);

assert_eq!(
    "SELECT `users`.* FROM `users` INNER JOIN `posts` AS `p` ON `p`.`user_id` = `users`.`id`",
    sql
);

pub fn left_join<J>(self, join: J) -> Self where
    J: Into<JoinData<'a>>, 

Adds LEFT JOIN clause to the query.

let join = "posts".alias("p").on(("p", "visible").equals(true));
let query = Select::from_table("users").left_join(join);
let (sql, params) = Sqlite::build(query);

assert_eq!(
    "SELECT `users`.* FROM `users` LEFT JOIN `posts` AS `p` ON `p`.`visible` = ?",
    sql
);

assert_eq!(
    vec![
        ParameterizedValue::from(true),
    ],
    params
);

pub fn right_join<J>(self, join: J) -> Self where
    J: Into<JoinData<'a>>, 

Adds RIGHT JOIN clause to the query.

let join = "posts".alias("p").on(("p", "visible").equals(true));
let query = Select::from_table("users").right_join(join);
let (sql, params) = Sqlite::build(query);

assert_eq!(
    "SELECT `users`.* FROM `users` RIGHT JOIN `posts` AS `p` ON `p`.`visible` = ?",
    sql
);

assert_eq!(
    vec![
        ParameterizedValue::from(true),
    ],
    params
);

pub fn full_join<J>(self, join: J) -> Self where
    J: Into<JoinData<'a>>, 

Adds FULL JOIN clause to the query.

let join = "posts".alias("p").on(("p", "visible").equals(true));
let query = Select::from_table("users").full_join(join);
let (sql, params) = Sqlite::build(query);

assert_eq!(
    "SELECT `users`.* FROM `users` FULL JOIN `posts` AS `p` ON `p`.`visible` = ?",
    sql
);

assert_eq!(
    vec![
        ParameterizedValue::from(true),
    ],
    params
);

pub fn order_by<T>(self, value: T) -> Self where
    T: IntoOrderDefinition<'a>, 

Adds an ordering to the ORDER BY section.

let query = Select::from_table("users")
    .order_by("foo")
    .order_by("baz".ascend())
    .order_by("bar".descend());

let (sql, _) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users` ORDER BY `foo`, `baz` ASC, `bar` DESC", sql);

pub fn group_by<T>(self, value: T) -> Self where
    T: IntoGroupByDefinition<'a>, 

Adds a grouping to the GROUP BY section.

This does not check if the grouping is actually valid in respect to aggregated columns.

let query = Select::from_table("users").column("foo").column("bar")
    .group_by("foo")
    .group_by("bar");

let (sql, _) = Sqlite::build(query);

assert_eq!("SELECT `foo`, `bar` FROM `users` GROUP BY `foo`, `bar`", sql);

pub fn having<T>(self, conditions: T) -> Self where
    T: Into<ConditionTree<'a>>, 

Adds group conditions to a query. Should be combined together with a group_by statement.

let query = Select::from_table("users").column("foo").column("bar")
    .group_by("foo")
    .having("foo".greater_than(100));

let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `foo`, `bar` FROM `users` GROUP BY `foo` HAVING `foo` > ?", sql);
assert_eq!(vec![ParameterizedValue::from(100)], params);

pub fn limit(self, limit: usize) -> Self

Sets the LIMIT value.

let query = Select::from_table("users").limit(10);
let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users` LIMIT ?", sql);
assert_eq!(vec![ParameterizedValue::from(10)], params);

pub fn offset(self, offset: usize) -> Self

Sets the OFFSET value.

let query = Select::from_table("users").offset(10);
let (sql, params) = Sqlite::build(query);

assert_eq!("SELECT `users`.* FROM `users` LIMIT ? OFFSET ?", sql);
assert_eq!(vec![ParameterizedValue::from(-1), ParameterizedValue::from(10)], params);

Trait Implementations

impl<'a> Clone for Select<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Select<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Select<'a>

fn default() -> Select<'a>

Returns the "default value" for a type.

impl<'a> From<Select<'a>> for ConditionTree<'a>

fn from(sel: Select<'a>) -> Self

Performs the conversion.

impl<'a> From<Select<'a>> for Expression<'a>

fn from(sel: Select<'a>) -> Expression<'a>

Performs the conversion.

impl<'a> From<Select<'a>> for DatabaseValue<'a>

fn from(sel: Select<'a>) -> DatabaseValue<'a>

Performs the conversion.

impl<'a> From<Select<'a>> for Query<'a>

fn from(sel: Select<'a>) -> Query<'a>

Performs the conversion.

impl<'a> From<Select<'a>> for Table<'a>

fn from(select: Select<'a>) -> Self

Performs the conversion.

impl<'a> PartialEq<Select<'a>> for Select<'a>

fn eq(&self, other: &Select<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Select<'a>) -> bool

This method tests for !=.

impl<'a> StructuralPartialEq for Select<'a>