mysql_common

此crate是MySql基本协议原语的实现。

此crate

• 定义了基本MySql常量；
• 实现了对MySql cached_sha2_password，mysql_native_password 和旧版认证插件的必要功能；
• 实现了MySql协议IO的辅助特质；
• 实现了支持预处理语句的命名参数；
• 实现了对MySql协议数据包子集的解析器（包括binlog数据包）；
• 定义了MySql协议值和行的rust表示；
• 实现了MySql值和rust类型之间的转换，以及MySql行和rust类型元组之间的转换。
• 实现了 FromRow 和 FromValue derive宏

支持的rust类型

Crate提供了以下类型与MySql值的转换（请参阅MySql文档以了解数字类型的支持范围）。以下表格引用的是MySql协议类型（请参阅Value结构），而不是MySql列类型。请参阅MySql文档以了解列和协议类型的对应关系

此外，该crate还为以下类型的列表提供了从行转换（参见FromRow特质）

Crate特性

推导宏

FromValue推导

支持的推导

• 对于枚举 – 应仔细阅读MySQL文档中相应的部分。
• 对于新类型（参见新类型习语） – 假定包装的类型本身满足FromValue。

枚举

容器属性

• #[mysql(crate_name = "some_name")] – 覆盖了猜测提供所需特质的crate的尝试
• #[mysql(rename_all = ...)] – 根据给定的命名约定重命名所有变体。可能的值有 "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE"
• #[mysql(is_integer)] – 告诉 derive 宏该值是整数而不是 MySql 枚举。如果变体稀疏或大于 u16，宏不会警告，并且不会尝试解析文本表示形式。
• #[mysql(is_string)] – 告诉 derive 宏该值是字符串而不是 MySql 枚举。如果变体稀疏或大于 u16，宏不会警告，并且不会尝试解析整数表示形式。

示例

给定在 MySql 端的 ENUM('x-small', 'small', 'medium', 'large', 'x-large')

fn main() {

/// Note: the `crate_name` attribute should not be necessary.
#[derive(FromValue)]
#[mysql(rename_all = "kebab-case", crate_name = "mysql_common")]
#[repr(u8)]
enum Size {
    XSmall = 1,
    Small,
    Medium,
    Large,
    XLarge,
}

fn assert_from_row_works(x: Row) -> Size {
    from_row(x)
}

}

Newtypes

预期包装值满足 FromValue 或提供了 deserialize_with。注意，为了支持 FromRow，包装值必须满足 Into<Value> 或必须提供 serialize_with。

容器属性

• #[mysql(crate_name = "some_name")] – 覆盖了猜测导入类型所在包的尝试
• #[mysql(bound = "Foo: Bar, Baz: Quux")] – 使用以下额外的界限
• #[mysql(deserialize_with = "some::path")] – 使用以下函数来反序列化包装值。预期签名是 fn (Value) -> Result<Wrapped, FromValueError>。
• #[mysql(serialize_with = "some::path")] – 使用以下函数来序列化包装的值。期望的签名是 fn (Wrapped) -> Value。

示例

/// Trivial example
#[derive(FromValue)]
struct Inch(i32);

/// Example of a {serialize|deserialize}_with.
#[derive(FromValue)]
#[mysql(deserialize_with = "neg_de", serialize_with = "neg_ser")]
struct Neg(i64);

/// Wrapped generic. Bounds are inferred.
#[derive(FromValue)]
struct Foo<T>(Option<T>);

/// Example of additional bounds.
#[derive(FromValue)]
#[mysql(bound = "'b: 'a, T: 'a, U: From<String>, V: From<u64>")]
struct Bar<'a, 'b, const N: usize, T, U, V>(ComplexTypeToWrap<'a, 'b, N, T, U, V>);

fn assert_from_row_works<'a, 'b, const N: usize, T, U, V>(x: Row) -> (Inch, Neg, Foo<u8>, Bar<'a, 'b, N, T, U, V>)
where 'b: 'a, T: 'a, U: From<String>, V: From<u64>,
{
    from_row(x)
}


// test boilerplate..


/// Dummy complex type with additional bounds on FromValue impl.
struct ComplexTypeToWrap<'a, 'b, const N: usize, T, U, V>([(&'a T, &'b U, V); N]);

struct FakeIr;

impl TryFrom<Value> for FakeIr {
    // ...
}

impl<'a, 'b: 'a, const N: usize, T: 'a, U: From<String>, V: From<u64>> From<FakeIr> for ComplexTypeToWrap<'a, 'b, N, T, U, V> {
    // ...
}

impl From<FakeIr> for Value {
    // ...
}

impl<'a, 'b: 'a, const N: usize, T: 'a, U: From<String>, V: From<u64>> FromValue for ComplexTypeToWrap<'a, 'b, N, T, U, V> {
    type Intermediate = FakeIr;
}

fn neg_de(v: Value) -> Result<i64, FromValueError> {
    match v {
        Value::Int(x) => Ok(-x),
        Value::UInt(x) => Ok(-(x as i64)),
        x => Err(FromValueError(x)),
    }
}

fn neg_ser(x: i64) -> Value {
    Value::Int(-x)
}

FromRow 继承

也在结构体上定义了一些常量

• const TABLE_NAME: &str – 如果提供了 table_name
• const {}_FIELD: &str – 对于每个结构体字段（{} 是结构体字段名（不是列名）的 SCREAMING_SNAKE_CASE 表示形式）

/// Note: the `crate_name` attribute should not be necessary.
#[derive(Debug, PartialEq, Eq, FromRow)]
#[mysql(table_name = "Foos", crate_name = "mysql_common")]
struct Foo {
    id: u64,
    #[mysql(json, rename = "def")]
    definition: Bar,
    child: Option<u64>,
}

#[derive(Debug, serde::Deserialize, PartialEq, Eq)]
enum Bar {
    Left,
    Right,
}

/// Returns the following row:
///
/// ```
/// +----+-----------+-------+
/// | id | def       | child |
/// +----+-----------+-------+
/// | 42 | '"Right"' | NULL  |
/// +----+-----------+-------+
/// ```
fn get_row() -> Row {
    // ...
}

assert_eq!(Foo::TABLE_NAME, "Foos");
assert_eq!(Foo::ID_FIELD, "id");
assert_eq!(Foo::DEFINITION_FIELD, "def");
assert_eq!(Foo::CHILD_FIELD, "child");

let foo = from_row::<Foo>(get_row());
assert_eq!(foo, Foo { id: 42, definition: Bar::Right, child: None });