pub struct Select<'a> { /* private fields */ }
Expand description
A builder for a SELECT
statement.
Implementations§
Source§impl<'a> Select<'a>
impl<'a> Select<'a>
Sourcepub fn from_table<T>(table: T) -> Self
pub fn from_table<T>(table: T) -> Self
Creates a new SELECT
statement for the given table.
let query = Select::from_table("users");
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users""#, sql);
The table can be in multiple parts, defining the schema.
let query = Select::from_table(("crm", "users"));
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "crm"."users".* FROM "crm"."users""#, sql);
Selecting from a nested SELECT
.
let mut inner_select = Select::default();
inner_select.value(1);
let select = Table::from(inner_select).alias("num");
let query = Select::from_table(select.alias("num"));
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "num".* FROM (SELECT $1) AS "num""#, sql);
assert_eq!(vec![Value::from(1)], params);
Sourcepub fn and_from<T>(&mut self, table: T)
pub fn and_from<T>(&mut self, table: T)
Adds a table to be selected.
let mut query = Select::from_table("users");
let mut inner_select = Select::default();
inner_select.value(1);
query.and_from(Table::from(inner_select).alias("num"));
query.column(("users", "name"));
query.value(Table::from("num").asterisk());
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users"."name", "num".* FROM "users", (SELECT $1) AS "num""#, sql);
Sourcepub fn value<T>(&mut self, value: T)where
T: Into<Expression<'a>>,
pub fn value<T>(&mut self, value: T)where
T: Into<Expression<'a>>,
Selects a static value as the column.
let mut query = Select::default();
query.value(1);
let (sql, params) = renderer::Postgres::build(query);
assert_eq!("SELECT $1", sql);
assert_eq!(vec![Value::from(1)], params);
Sourcepub fn column<T>(&mut self, column: T)
pub fn column<T>(&mut self, column: T)
Adds a column to be selected.
let mut query = Select::from_table("users");
query.column("name");
query.column(("users", "id"));
query.column((("crm", "users"), "foo"));
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "name", "users"."id", "crm"."users"."foo" FROM "users""#, sql);
Sourcepub fn columns<T, C>(&mut self, columns: T)
pub fn columns<T, C>(&mut self, columns: T)
A bulk method to select multiple values.
let mut query = Select::from_table("users");
query.columns(["foo", "bar"]);
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "foo", "bar" FROM "users""#, sql);
Sourcepub fn distinct(&mut self)
pub fn distinct(&mut self)
Adds DISTINCT
to the select query.
let mut query = Select::from_table("users");
query.column("foo");
query.column("bar");
query.distinct();
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT DISTINCT "foo", "bar" FROM "users""#, sql);
Sourcepub fn so_that<T>(&mut self, conditions: T)where
T: Into<ConditionTree<'a>>,
pub fn so_that<T>(&mut self, conditions: T)where
T: Into<ConditionTree<'a>>,
Adds WHERE
conditions to the query, replacing the previous conditions.
See Comparable for more
examples.
let mut query = Select::from_table("users");
query.so_that("foo".equals("bar"));
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users" WHERE "foo" = $1"#, sql);
assert_eq!(vec![
Value::from("bar"),
], params);
Sourcepub fn and_where<T>(&mut self, conditions: T)where
T: Into<ConditionTree<'a>>,
pub fn and_where<T>(&mut self, conditions: T)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 mut query = Select::from_table("users");
query.so_that("foo".equals("bar"));
query.and_where("lol".equals("wtf"));
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users" WHERE ("foo" = $1 AND "lol" = $2)"#, sql);
assert_eq!(vec![
Value::from("bar"),
Value::from("wtf"),
], params);
Sourcepub fn or_where<T>(&mut self, conditions: T)where
T: Into<ConditionTree<'a>>,
pub fn or_where<T>(&mut self, conditions: T)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 mut query = Select::from_table("users");
query.so_that("foo".equals("bar"));
query.or_where("lol".equals("wtf"));
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users" WHERE ("foo" = $1 OR "lol" = $2)"#, sql);
assert_eq!(vec![
Value::from("bar"),
Value::from("wtf"),
], params);
Sourcepub fn inner_join<J>(&mut self, join: J)
pub fn inner_join<J>(&mut self, join: J)
Adds INNER JOIN
clause to the query.
let join = Table::from("posts")
.alias("p")
.on(("p", "user_id").equals(Column::from(("users", "id"))));
let mut query = Select::from_table("users");
query.inner_join(join);
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(
r#"SELECT "users".* FROM "users" INNER JOIN "posts" AS "p" ON "p"."user_id" = "users"."id""#,
sql
);
Sourcepub fn left_join<J>(&mut self, join: J)
pub fn left_join<J>(&mut self, join: J)
Adds LEFT JOIN
clause to the query.
let join = Table::from("posts")
.alias("p")
.on(("p", "visible").equals(true));
let mut query = Select::from_table("users");
query.left_join(join);
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(
r#"SELECT "users".* FROM "users" LEFT JOIN "posts" AS "p" ON "p"."visible" = $1"#,
sql
);
assert_eq!(
vec![
Value::from(true),
],
params
);
Sourcepub fn right_join<J>(&mut self, join: J)
pub fn right_join<J>(&mut self, join: J)
Adds RIGHT JOIN
clause to the query.
let join = Table::from("posts")
.alias("p")
.on(("p", "visible").equals(true));
let mut query = Select::from_table("users");
query.right_join(join);
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(
r#"SELECT "users".* FROM "users" RIGHT JOIN "posts" AS "p" ON "p"."visible" = $1"#,
sql
);
assert_eq!(
vec![
Value::from(true),
],
params
);
Sourcepub fn full_join<J>(&mut self, join: J)
pub fn full_join<J>(&mut self, join: J)
Adds FULL JOIN
clause to the query.
let join = Table::from("posts")
.alias("p")
.on(("p", "visible").equals(true));
let mut query = Select::from_table("users");
query.full_join(join);
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(
r#"SELECT "users".* FROM "users" FULL JOIN "posts" AS "p" ON "p"."visible" = $1"#,
sql
);
assert_eq!(
vec![
Value::from(true),
],
params
);
Sourcepub fn order_by<T>(&mut self, value: T)where
T: IntoOrderDefinition<'a>,
pub fn order_by<T>(&mut self, value: T)where
T: IntoOrderDefinition<'a>,
Adds an ordering to the ORDER BY
section.
let mut query = Select::from_table("users");
query.order_by("foo");
query.order_by("baz".ascend());
query.order_by("bar".descend());
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users" ORDER BY "foo", "baz" ASC, "bar" DESC"#, sql);
Sourcepub fn group_by<T>(&mut self, value: T)where
T: IntoGroupByDefinition<'a>,
pub fn group_by<T>(&mut self, value: T)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 mut query = Select::from_table("users");
query.column("foo");
query.column("bar");
query.group_by("foo");
query.group_by("bar");
let (sql, _) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "foo", "bar" FROM "users" GROUP BY "foo", "bar""#, sql);
Sourcepub fn having<T>(&mut self, conditions: T)where
T: Into<ConditionTree<'a>>,
pub fn having<T>(&mut self, conditions: T)where
T: Into<ConditionTree<'a>>,
Adds group conditions to a query. Should be combined together with a group_by statement.
let mut query = Select::from_table("users");
query.column("foo");
query.column("bar");
query.group_by("foo");
query.having("foo".greater_than(100));
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "foo", "bar" FROM "users" GROUP BY "foo" HAVING "foo" > $1"#, sql);
assert_eq!(vec![Value::from(100)], params);
Sourcepub fn limit(&mut self, limit: u32)
pub fn limit(&mut self, limit: u32)
Sets the LIMIT
value.
let mut query = Select::from_table("users");
query.limit(10);
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users" LIMIT $1"#, sql);
assert_eq!(vec![Value::from(10_i64)], params);
Sourcepub fn offset(&mut self, offset: u32)
pub fn offset(&mut self, offset: u32)
Sets the OFFSET
value.
let mut query = Select::from_table("users");
query.offset(10);
let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"SELECT "users".* FROM "users" OFFSET $1"#, sql);
assert_eq!(vec![Value::from(10_i64)], params);
Sourcepub fn with(&mut self, cte: CommonTableExpression<'a>)
pub fn with(&mut self, cte: CommonTableExpression<'a>)
Adds a common table expression to the select.
Trait Implementations§
Source§impl<'a> From<Select<'a>> for ConditionTree<'a>
impl<'a> From<Select<'a>> for ConditionTree<'a>
Source§impl<'a> From<Select<'a>> for Expression<'a>
impl<'a> From<Select<'a>> for Expression<'a>
Source§fn from(sel: Select<'a>) -> Expression<'a>
fn from(sel: Select<'a>) -> Expression<'a>
impl<'a> StructuralPartialEq for Select<'a>
Auto Trait Implementations§
impl<'a> Freeze for Select<'a>
impl<'a> RefUnwindSafe for Select<'a>
impl<'a> Send for Select<'a>
impl<'a> Sync for Select<'a>
impl<'a> Unpin for Select<'a>
impl<'a> UnwindSafe for Select<'a>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<'a, T> Conjunctive<'a> for Twhere
T: Into<Expression<'a>>,
impl<'a, T> Conjunctive<'a> for Twhere
T: Into<Expression<'a>>,
Source§fn and<E>(self, other: E) -> ConditionTree<'a>where
E: Into<Expression<'a>>,
fn and<E>(self, other: E) -> ConditionTree<'a>where
E: Into<Expression<'a>>,
AND
condition having self
as the left leaf and other
as the right.Source§fn or<E>(self, other: E) -> ConditionTree<'a>where
E: Into<Expression<'a>>,
fn or<E>(self, other: E) -> ConditionTree<'a>where
E: Into<Expression<'a>>,
OR
condition having self
as the left leaf and other
as the right.Source§fn not(self) -> ConditionTree<'a>
fn not(self) -> ConditionTree<'a>
NOT
condition having self
as the condition.