ddnet-account-sql 0.4.0

Helpers for SQL databases.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use async_trait::async_trait;

use crate::any::{AnyConnection, AnyQuery, AnyRow, AnyStatement};

/// An interface for queries to allow converting them to various database implementations
#[async_trait]
pub trait Query<A> {
    /// MySQL version of [`Query::prepare`].
    #[cfg(feature = "mysql")]
    async fn prepare_mysql(
        connection: &mut sqlx::mysql::MySqlConnection,
    ) -> anyhow::Result<sqlx::mysql::MySqlStatement>;

    /// Sqlite version of [`Query::prepare`].
    #[cfg(feature = "sqlite")]
    async fn prepare_sqlite(
        connection: &mut sqlx::sqlite::SqliteConnection,
    ) -> anyhow::Result<sqlx::sqlite::SqliteStatement>;

    /// Prepare a statement to be later used by [`Query::query`].
    async fn prepare(connection: &mut AnyConnection) -> anyhow::Result<AnyStatement> {
        Ok(match connection {
            #[cfg(feature = "mysql")]
            AnyConnection::MySql(connection) => {
                AnyStatement::MySql(Self::prepare_mysql(connection).await?)
            }
            #[cfg(feature = "sqlite")]
            AnyConnection::Sqlite(connection) => {
                AnyStatement::Sqlite(Self::prepare_sqlite(connection).await?)
            }
        })
    }

    /// MySQL version of [`Query::query`].
    #[cfg(feature = "mysql")]
    fn query_mysql<'a>(
        &'a self,
        statement: &'a sqlx::mysql::MySqlStatement,
    ) -> sqlx::query::Query<'a, sqlx::MySql, sqlx::mysql::MySqlArguments>;

    /// Sqlite version of [`Query::query`].
    #[cfg(feature = "sqlite")]
    fn query_sqlite<'a>(
        &'a self,
        statement: &'a sqlx::sqlite::SqliteStatement,
    ) -> sqlx::query::Query<'a, sqlx::Sqlite, sqlx::sqlite::SqliteArguments>;

    /// Get a query with all arguments bound already, ready to be fetched.
    fn query<'a>(&'a self, statement: &'a AnyStatement) -> AnyQuery<'a> {
        match statement {
            #[cfg(feature = "mysql")]
            AnyStatement::MySql(statement) => AnyQuery::MySql(self.query_mysql(statement)),
            #[cfg(feature = "sqlite")]
            AnyStatement::Sqlite(statement) => AnyQuery::Sqlite(self.query_sqlite(statement)),
        }
    }

    /// MySQL version of [`Query::row_data`].
    #[cfg(feature = "mysql")]
    fn row_data_mysql(row: &sqlx::mysql::MySqlRow) -> anyhow::Result<A>;

    /// Sqlite version of [`Query::row_data`].
    #[cfg(feature = "sqlite")]
    fn row_data_sqlite(row: &sqlx::sqlite::SqliteRow) -> anyhow::Result<A>;

    /// Gets the row data for a result row of this query
    fn row_data(row: &AnyRow) -> anyhow::Result<A> {
        match row {
            #[cfg(feature = "mysql")]
            AnyRow::MySql(row) => Self::row_data_mysql(row),
            #[cfg(feature = "sqlite")]
            AnyRow::Sqlite(row) => Self::row_data_sqlite(row),
        }
    }
}