Question

我想编写一个函数，将一个类型插入到数据库连接参数是通用的数据库中，以便它可以在多个后端上工作。

我想出了以下函数来使用通用连接插入对象：

pub fn create_label<C>(connection: &C, label: &model::Label)
where
    C: Connection,
    C::Backend: diesel::backend::Backend,
    C::Backend: diesel::backend::SupportsDefaultKeyword,
{
    diesel::insert(&label)
        .into(schema::label::table)
        .execute(connection);
}

如果我不包含SupportsDefaultKeyword约束，则该函数将无法编译。使用SqliteConnection作为连接参数进行调用时，出现以下错误：

database::create_label(&db_conn, &label); ^^^^^^^^^^^^^^^^^^^^^^ the trait 'diesel::backend::SupportsDefaultKeyword' is not implemented for 'diesel::sqlite::Sqlite'

这意味着使用SqliteConnection插入数据不起作用。显然情况并非如此，并且进一步改变create_label以使SqliteConnection直接正常工作。

pub fn create_label(connection: &SqliteConnection, label: &model::Label) {
    diesel::insert(&label)
        .into(schema::label::table)
        .execute(connection);
}

为什么泛型函数需要SupportsDefaultKeyword约束，而SqliteConnection的函数不需要？

这是一个说明问题的minimal example。根据评论，main.rs的第60行不会使用上面的错误进行编译，而第61行会编译：

#[macro_use]
extern crate diesel;
#[macro_use]
extern crate diesel_codegen;

mod schema {
    table! {
        labels {
            id -> Integer,
            name -> VarChar,
        }
    }
}

mod model {
    use schema::labels;

    #[derive(Debug, Identifiable, Insertable)]
    #[table_name = "labels"]
    pub struct Label {
        pub id: i32,
        pub name: String,
    }
}

use diesel::ExecuteDsl;
use diesel::Connection;
use diesel::prelude::*;
use diesel::sqlite::SqliteConnection;

pub fn create_label<C>(connection: &C, label: &model::Label)
where
    C: Connection,
    C::Backend: diesel::backend::Backend,
    C::Backend: diesel::backend::SupportsDefaultKeyword,
{
    diesel::insert(label)
        .into(schema::labels::table)
        .execute(connection)
        .expect("nope");
}

pub fn create_label_sqlite(connection: &SqliteConnection, label: &model::Label) {
    diesel::insert(label)
        .into(schema::labels::table)
        .execute(connection)
        .expect("nope");
}

pub fn establish_connection() -> SqliteConnection {
    let url = "test.db";
    SqliteConnection::establish(&url).expect(&format!("Error connecting to {}", url))
}

fn main() {
    let label = model::Label {
        id: 1,
        name: String::from("test"),
    };
    let conn = establish_connection();

    create_label(&conn, &label); /* Does not compile */
    create_label_sqlite(&conn, &label); /*Compiles */
}

[dependencies]
diesel = { version = "0.16.0", features = ["sqlite"] }
diesel_codegen = "0.16.0"

Answer 1

Diesel函数execute有多个具体实现。这里有两个相关的是：

impl<'a, T, U, Op, Ret, Conn, DB> ExecuteDsl<Conn, DB> for BatchInsertStatement<T, &'a [U], Op, Ret> 
where
    Conn: Connection<Backend = DB>,
    DB: Backend + SupportsDefaultKeyword,
    InsertStatement<T, &'a [U], Op, Ret>: ExecuteDsl<Conn>,

impl<'a, T, U, Op, Ret> ExecuteDsl<SqliteConnection> for BatchInsertStatement<T, &'a [U], Op, Ret> 
where
    InsertStatement<T, &'a U, Op, Ret>: ExecuteDsl<SqliteConnection>,
    T: Copy,
    Op: Copy,
    Ret: Copy,

从这两个中可以看出，SQLite的实现是特殊的。我不太了解Diesel的细节知道原因，但我猜想SQLite缺少默认关键字。

您可以重新制定与该特定声明一起使用的任何连接的要求：

use diesel::query_builder::insert_statement::InsertStatement;

pub fn create_label<C>(connection: &C, label: &model::Label)
where
    C: Connection,
    for<'a> InsertStatement<schema::labels::table, &'a model::Label>: ExecuteDsl<C>,
{
    diesel::insert(label)
        .into(schema::labels::table)
        .execute(connection)
        .expect("nope");
}

了解柴油中的特征约束误差

1 个答案: