Trait typed_sql::query::Query[−][src]

pub trait Query: Sized {

Show 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,
    { ... }

}

Provided methods

fn prepare<F, S>(name: &str, f: F) -> Prepare<'_, Self, S> where
    Self: Binding,
    F: FnOnce(Self::Bindings) -> S,
    S: ToSql, [src]

Examples

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

fn select(self) -> SelectStatement<Self, WildCard> where
    Self: Selectable, [src]

Examples

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

fn query<Q>(self, query: Q) -> SelectStatement<Self, Q> where
    Self: Selectable,
    Q: WriteQueryable, [src]

Examples

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

fn count<F, T>(self, f: F) -> SelectStatement<Self, Count<T>> where
    Self: Selectable,
    F: FnOnce(Self::Fields) -> T,
    Count<T>: WriteQueryable, [src]

Examples

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

Wildcard

use typed_sql::{Query, Table, ToSql};

#[derive(Table)]
struct Post {}

let stmt = Post::table().count(|_| {});

assert_eq!(stmt.to_sql(), "SELECT COUNT(*) FROM posts;");

fn insert<I>(self, value: I) -> InsertStatement<Self::Table, I> where
    Self: TableQueryable,
    I: Insertable, [src]

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

fn insert_values<I>(self, values: I) -> InsertStatement<Self::Table, Values<I>> where
    Self: TableQueryable,
    I: IntoIterator + Clone,
    I::Item: Insertable, [src]

fn insert_select<S, I>(
    self,
    select: S
) -> InsertStatement<Self::Table, InsertSelect<S, I>> where
    Self: TableQueryable,
    S: Select,
    I: Insertable, [src]

fn update<F, S>(self, f: F) -> Update<Self::Table, S> where
    Self: TableQueryable,
    F: FnOnce(<Self::Table as Table>::Fields) -> S,
    S: UpdateSet, [src]

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

fn delete(self) -> Delete<Self::Table> where
    Self: TableQueryable, [src]

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

fn filter<F, P>(self, f: F) -> Filter<Self, P> where
    Self: Filterable,
    F: FnOnce(Self::Fields) -> P, [src]

fn and<P>(self, predicate: P) -> And<Self, P> where
    Self: Predicate,
    P: Predicate, [src]

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

fn or<P>(self, predicate: P) -> Or<Self, P> where
    Self: Predicate,
    P: Predicate, [src]

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

fn group_by<F, O>(self, f: F) -> GroupBy<Self, O> where
    Self: Select,
    F: FnOnce(<Self::Selectable as Selectable>::Fields) -> O,
    O: GroupOrder, [src]

Examples

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

Multiple columns

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

fn order_by<F, O>(self, f: F) -> OrderBy<Self, O> where
    Self: Select,
    F: FnOnce(<Self::Selectable as Selectable>::Fields) -> O,
    O: Order, [src]

Examples

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

Direction

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

Multiple columns

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

fn limit(self, limit: usize) -> Limit<Self> where
    Self: Select, [src]

Implementors

impl<T> Query for T[src]