Trait SqlGenericExecutor

pub trait SqlGenericExecutor {
    type DB: Database;
    type CountType: SelectedEntity<Self::DB>;

    // Required method
    fn get_affected_rows(
        query_result: &<Self::DB as Database>::QueryResult,
    ) -> u64;

    // Provided methods
    async fn generic_exists<'a, EX, A>(
        ex: EX,
        stmt: &'a str,
        args: A,
    ) -> Result<bool>
       where EX: Executor<'a, Database = Self::DB>,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_exists_plain<'a, EX, A>(
        ex: EX,
        stmt: &'a str,
        _args: PhantomData<A>,
    ) -> Result<bool>
       where EX: Executor<'a, Database = Self::DB>,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_count<'s, 'a, EX, A>(
        ex: EX,
        stmt: &'s str,
        args: A,
    ) -> Result<Self::CountType>
       where EX: Executor<'a, Database = Self::DB>,
             A: IntoArguments<'a, Self::DB> + 'a,
             's: 'a { ... }
    async fn generic_count_plain<'a, EX, A>(
        ex: EX,
        stmt: &'a str,
        _args: PhantomData<A>,
    ) -> Result<Self::CountType>
       where EX: Executor<'a, Database = Self::DB>,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_execute<'a, 'e, EX, A>(
        ex: EX,
        query: &'a str,
        args: A,
    ) -> Result<u64>
       where EX: Executor<'e, Database = Self::DB>,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_execute_plain<'a, EX, A>(
        ex: EX,
        query: &'a str,
        _args: PhantomData<A>,
    ) -> Result<u64>
       where EX: Executor<'a, Database = Self::DB>,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_all<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE::Selection,
        args: A,
    ) -> Result<Vec<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_all_<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE,
        args: A,
    ) -> Result<Vec<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_all_plain<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE::Selection,
        _: PhantomData<A>,
    ) -> Result<Vec<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_all_plain_<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE,
        _: PhantomData<A>,
    ) -> Result<Vec<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_one<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE::Selection,
        args: A,
    ) -> Result<SE>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_fetch_one_<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE,
        args: A,
    ) -> Result<SE>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_fetch_one_plain<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE::Selection,
        _: PhantomData<A>,
    ) -> Result<SE>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_one_plain_<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE,
        _: PhantomData<A>,
    ) -> Result<SE>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_option<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE::Selection,
        args: A,
    ) -> Result<Option<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_option_<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE,
        args: A,
    ) -> Result<Option<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_option_plain<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE::Selection,
        _: PhantomData<A>,
    ) -> Result<Option<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_option_plain_<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        selection: &SE,
        _: PhantomData<A>,
    ) -> Result<Option<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_all_full<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        args: A,
    ) -> Result<Vec<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_fetch_all_full_plain<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        _: PhantomData<A>,
    ) -> Result<Vec<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_one_full<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        args: A,
    ) -> Result<SE>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_fetch_one_full_plain<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        _: PhantomData<A>,
    ) -> Result<SE>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
    async fn generic_fetch_option_full<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        args: A,
    ) -> Result<Option<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a { ... }
    async fn generic_fetch_option_full_plain<'a, EX, SE, A>(
        ex: EX,
        stmt: &'a str,
        _: PhantomData<A>,
    ) -> Result<Option<SE>>
       where EX: Executor<'a, Database = Self::DB>,
             SE: SelectedEntity<Self::DB> + Send + Unpin,
             A: IntoArguments<'a, Self::DB> + 'a + Default { ... }
}

本模块提供2个维度的封装

1. 结果的转化，上层抽象不再感知Row和QueryResult的存在 QueryResult -> u64 Vec -> Vec Row -> SE Option -> Option Option -> bool
2. sqlx::query::Query结构体的封装，上层抽象不再感知这个结构体的存在

本模块提供以下泛型接口函数

generic_execute (ex, stmt, args) -> Result generic_execute_plain (ex, stmt, _ ) -> Result

generic_exists (ex, stmt, args) -> Result generic_exists_plain (ex, stmt, _ ) -> Result generic_count (ex, stmt, args) -> Result generic_count_plain (ex, stmt, _ ) -> Result

generic_fetch_all (ex, stmt, selection, args) -> Result<Vec> generic_fetch_all_plain (ex, stmt, selection, _ ) -> Result<Vec> generic_fetch_one (ex, stmt, selection, args) -> Result generic_fetch_one_plain (ex, stmt, selection, _ ) -> Result generic_fetch_option (ex, stmt, selection, args) -> Result<Option> generic_fetch_option_plain(ex, stmt, selection, _ ) -> Result<Option>

generic_fetch_all_ (ex, stmt, se, args) -> Result<Vec> generic_fetch_all_plain_ (ex, stmt, se, _ ) -> Result<Vec> generic_fetch_one_ (ex, stmt, se, args) -> Result generic_fetch_one_plain_ (ex, stmt, se, _ ) -> Result generic_fetch_option_ (ex, stmt, se, args) -> Result<Option> generic_fetch_option_plain_(ex, stmt, se, _ ) -> Result<Option>

generic_fetch_all_full (ex, stmt, args) -> Result<Vec> generic_fetch_all_full_plain (ex, stmt, _ ) -> Result<Vec> generic_fetch_one_full (ex, stmt, args) -> Result generic_fetch_one_full_plain (ex, stmt, _ ) -> Result generic_fetch_option_full (ex, stmt, args) -> Result<Option> generic_fetch_option_full_plain(ex, stmt, _ ) -> Result<Option>

Required Associated Types

type DB: Database

type CountType: SelectedEntity<Self::DB>

Required Methods

fn get_affected_rows(query_result: &<Self::DB as Database>::QueryResult) -> u64

Provided Methods

async fn generic_exists<'a, EX, A>( ex: EX, stmt: &'a str, args: A, ) -> Result<bool>

where EX: Executor<'a, Database = Self::DB>, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_exists_plain<'a, EX, A>( ex: EX, stmt: &'a str, _args: PhantomData<A>, ) -> Result<bool>

where EX: Executor<'a, Database = Self::DB>, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_count<'s, 'a, EX, A>( ex: EX, stmt: &'s str, args: A, ) -> Result<Self::CountType>

where EX: Executor<'a, Database = Self::DB>, A: IntoArguments<'a, Self::DB> + 'a, 's: 'a,

async fn generic_count_plain<'a, EX, A>( ex: EX, stmt: &'a str, _args: PhantomData<A>, ) -> Result<Self::CountType>

where EX: Executor<'a, Database = Self::DB>, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_execute<'a, 'e, EX, A>( ex: EX, query: &'a str, args: A, ) -> Result<u64>

where EX: Executor<'e, Database = Self::DB>, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_execute_plain<'a, EX, A>( ex: EX, query: &'a str, _args: PhantomData<A>, ) -> Result<u64>

where EX: Executor<'a, Database = Self::DB>, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_all<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE::Selection, args: A, ) -> Result<Vec<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_all_<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE, args: A, ) -> Result<Vec<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_all_plain<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE::Selection, _: PhantomData<A>, ) -> Result<Vec<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_all_plain_<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE, _: PhantomData<A>, ) -> Result<Vec<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_one<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE::Selection, args: A, ) -> Result<SE>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_fetch_one_<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE, args: A, ) -> Result<SE>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_fetch_one_plain<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE::Selection, _: PhantomData<A>, ) -> Result<SE>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_one_plain_<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE, _: PhantomData<A>, ) -> Result<SE>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_option<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE::Selection, args: A, ) -> Result<Option<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_option_<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE, args: A, ) -> Result<Option<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_option_plain<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE::Selection, _: PhantomData<A>, ) -> Result<Option<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_option_plain_<'a, EX, SE, A>( ex: EX, stmt: &'a str, selection: &SE, _: PhantomData<A>, ) -> Result<Option<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_all_full<'a, EX, SE, A>( ex: EX, stmt: &'a str, args: A, ) -> Result<Vec<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_fetch_all_full_plain<'a, EX, SE, A>( ex: EX, stmt: &'a str, _: PhantomData<A>, ) -> Result<Vec<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_one_full<'a, EX, SE, A>( ex: EX, stmt: &'a str, args: A, ) -> Result<SE>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_fetch_one_full_plain<'a, EX, SE, A>( ex: EX, stmt: &'a str, _: PhantomData<A>, ) -> Result<SE>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

async fn generic_fetch_option_full<'a, EX, SE, A>( ex: EX, stmt: &'a str, args: A, ) -> Result<Option<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a,

async fn generic_fetch_option_full_plain<'a, EX, SE, A>( ex: EX, stmt: &'a str, _: PhantomData<A>, ) -> Result<Option<SE>>

where EX: Executor<'a, Database = Self::DB>, SE: SelectedEntity<Self::DB> + Send + Unpin, A: IntoArguments<'a, Self::DB> + 'a + Default,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl SqlGenericExecutor for SqliteDatabase

type DB = Sqlite

type CountType = CountResult

impl<'t> SqlGenericExecutor for SqliteTransaction<'t>

type DB = Sqlite

type CountType = CountResult