pub trait Query: Sized {
Show 15 methods
// Provided methods
fn prepare<F, S>(name: &str, f: F) -> Prepare<'_, Self, S>
where Self: Binding,
F: FnOnce(Self::Bindings) -> S,
S: ToSql { ... }
fn select(self) -> SelectStatement<Self, WildCard>
where Self: Selectable { ... }
fn query<Q>(self, query: Q) -> SelectStatement<Self, Q>
where Self: Selectable,
Q: WriteQueryable { ... }
fn count<F, T>(self, f: F) -> SelectStatement<Self, Count<T>>
where Self: Selectable,
F: FnOnce(Self::Fields) -> T,
Count<T>: WriteQueryable { ... }
fn insert<I>(self, value: I) -> InsertStatement<Self::Table, I>
where Self: TableQueryable,
I: Insertable { ... }
fn insert_values<I>(
self,
values: I
) -> InsertStatement<Self::Table, Values<I>>
where Self: TableQueryable,
I: IntoIterator + Clone,
I::Item: Insertable { ... }
fn insert_select<S, I>(
self,
select: S
) -> InsertStatement<Self::Table, InsertSelect<S, I>>
where Self: TableQueryable,
S: Select,
I: Insertable { ... }
fn update<F, S>(self, f: F) -> Update<Self::Table, S>
where Self: TableQueryable,
F: FnOnce(<Self::Table as Table>::Fields) -> S,
S: UpdateSet { ... }
fn delete(self) -> Delete<Self::Table>
where Self: TableQueryable { ... }
fn filter<F, P>(self, f: F) -> Filter<Self, P>
where Self: Filterable,
F: FnOnce(Self::Fields) -> P { ... }
fn and<P>(self, predicate: P) -> And<Self, P>
where Self: Predicate,
P: Predicate { ... }
fn or<P>(self, predicate: P) -> Or<Self, P>
where Self: Predicate,
P: Predicate { ... }
fn group_by<F, O>(self, f: F) -> GroupBy<Self, O>
where Self: Select,
F: FnOnce(<Self::Selectable as Selectable>::Fields) -> O,
O: GroupOrder { ... }
fn order_by<F, O>(self, f: F) -> OrderBy<Self, O>
where Self: Select,
F: FnOnce(<Self::Selectable as Selectable>::Fields) -> O,
O: Order { ... }
fn limit(self, limit: usize) -> Limit<Self>
where Self: Select { ... }
use typed_sql::{Binding, Query, Table, ToSql};
#[derive(Table)]
struct Post {
id: i64,
content: String
}
#[derive(Binding)]
struct PostBinding {
id: i64
}
let stmt = PostBinding::prepare("postplan", |binds| {
Post::table()
.select()
.filter(|post| post.id.eq(binds.id))
});
assert_eq!(
stmt.to_sql(),
"PREPARE postplan AS SELECT * FROM posts WHERE posts.id = $1;"
);
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct Post {
content: String
}
let stmt = Post::table().select().filter(|p| p.content.eq("foo"));
assert_eq!(
stmt.to_sql_unchecked(),
"SELECT * FROM posts WHERE posts.content = 'foo';"
);
use typed_sql::{Query, Queryable, Table, ToSql};
#[derive(Table)]
struct Post {
id: i64,
content: String
}
#[derive(Queryable)]
struct PostQuery {
content: String
}
let stmt = Post::table().query(PostQuery::queryable());
assert_eq!(
stmt.to_sql_unchecked(),
"SELECT content FROM posts;"
);
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct Post {
content: Option<String>
}
let stmt = Post::table().count(|post| post.content);
assert_eq!(stmt.to_sql(), "SELECT COUNT(posts.content) FROM posts;");
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct Post {}
let stmt = Post::table().count(|_| {});
assert_eq!(stmt.to_sql(), "SELECT COUNT(*) FROM posts;");
use typed_sql::{Insertable, Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64,
name: String
}
#[derive(Insertable)]
struct UserInsert {
name: &'static str
}
let stmt = User::table().insert(UserInsert { name: "Matt" });
assert_eq!(
stmt.to_sql_unchecked(),
"INSERT INTO users(name) VALUES ('Matt');"
);
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct Post {
id: i64,
name: String
}
let stmt = Post::table()
.update(|p| p.id.eq(2).and(p.name.eq("foo")))
.filter(|p| p.id.eq(1));
assert_eq!(
stmt.to_sql_unchecked(),
"UPDATE posts \
SET posts.id = 2,posts.name = 'foo' \
WHERE posts.id = 1;"
);
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct Post {
id: i64
}
let stmt = Post::table().delete().filter(|p| p.id.eq(2));
assert_eq!(stmt.to_sql_unchecked(), "DELETE FROM posts WHERE posts.id = 2;");
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64
}
let stmt = User::table().select().filter(|user| user.id.neq(2).and(user.id.lt(5)));
assert_eq!(
stmt.to_sql_unchecked(),
"SELECT * FROM users WHERE users.id != 2 AND users.id < 5;"
);
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64
}
let stmt = User::table()
.select()
.filter(|user| user.id.eq(1).or(user.id.eq(3)));
assert_eq!(
stmt.to_sql_unchecked(),
"SELECT * FROM users WHERE users.id = 1 OR users.id = 3;"
);
use typed_sql::{Table, ToSql, Query};
#[derive(Table)]
struct User {
id: i64
}
let stmt = User::table().select().group_by(|user| user.id);
assert_eq!(stmt.to_sql(), "SELECT * FROM users GROUP BY users.id;");
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64,
name: String
}
let stmt = User::table().select().group_by(|user| user.id.then(user.name));
assert_eq!(stmt.to_sql(), "SELECT * FROM users GROUP BY users.id,users.name;");
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64,
name: String
}
let stmt = User::table().select().order_by(|user| user.id);
assert_eq!(stmt.to_sql(), "SELECT * FROM users ORDER BY users.id;");
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64
}
let stmt = User::table().select().order_by(|user| user.id.ascending());
assert_eq!(stmt.to_sql(), "SELECT * FROM users ORDER BY users.id ASC;");
use typed_sql::{Query, Table, ToSql};
#[derive(Table)]
struct User {
id: i64,
name: String
}
let stmt = User::table().select()
.order_by(|user| user.id.ascending().then(user.name.descending()));
assert_eq!(stmt.to_sql(), "SELECT * FROM users ORDER BY users.id ASC,users.name DESC;");