Modelagem e serialização de dados

Exemplo de estrutura personalizada

O código a seguir define uma estrutura Vegetable de amostra que implementa as características de serialização serde :

#[derive(Serialize, Deserialize)]
struct Vegetable {
    name: String,
    category: String,
    tropical: bool,
}

O seguinte código acessa a collection vegetables com Vegetable como seu parâmetro de tipo genérico:

let my_coll: Collection<Vegetable> = client
    .database("db")
    .collection("vegetables");

Como a instância Collection é parametrizada com a estrutura Vegetable , você pode executar operações CRUD com esse tipo. O seguinte código insere uma instância do Vegetable na coleção:

let calabash = Vegetable {
    name: "calabash".to_string(),
    category: "gourd".to_string(),
    tropical: true,
};
my_coll.insert_one(calabash).await?;

Várias parametrizações

Se a sua collection contiver múltiplos esquemas, você poderá definir um tipo personalizado para modelar cada tipo de dados e criar clones da instância original do Collection para cada tipo. Você pode criar clones de uma instância Collection usando o método clone_with_type() .

Suponha que você parametrizou originalmente uma coleção com uma estrutura chamada Square, mas depois entende que deseja inserir um tipo diferente de dados, modelado pela estrutura Circle , na coleção. O código a seguir parametriza uma collection com o tipo Square e, em seguida, cria um clone da collection que é parametrizado com o tipo Circle :

let shapes_coll: Collection<Square> = client
    .database("db")
    .collection("shapes");
// ... perform some operations with Square
let shapes_coll: Collection<Circle> = shapes_coll.clone_with_type();
// ... perform some operations with Circle

Serializar uma string como um ObjectId

Talvez você queira representar o campo _id em um documento como uma cadeia hexadecimal em sua estrutura. Para converter a cadeia hexadecimal para o tipo ObjectId BSON, utilize a função auxiliar do serialize_hex_string_as_object_id como o valor do atributo serialize_with . O exemplo a seguir anexa o atributo serialize_with ao campo _id para que o driver serialize a string hexadecimal como um tipo ObjectId :

#[derive(Serialize, Deserialize)]
struct Order {
    #[serde(serialize_with = "serialize_hex_string_as_object_id")]
    _id: String,
    item: String,
}

Para ver como o driver serializa uma estrutura de exemplo Order para BSON, selecione a partir das seguintes guias Struct e BSON :

let order = Order {
    _id: "6348acd2e1a47ca32e79f46f".to_string(),
    item: "lima beans".to_string(),
};

{
  "_id": { "$oid": "6348acd2e1a47ca32e79f46f" },
  "item": "lima beans"
}

Serializar um DateTime como uma string

Talvez você queira representar um valor de campo DateTime em um documento como uma string formatada em ISO no BSON. Para especificar essa conversão, use a função auxiliar serialize_bson_datetime_as_rfc3339_string como valor do atributo serialize_with anexado ao campo com um valor DateTime . O exemplo seguinte anexa o atributo serialize_with ao campo delivery_date para que o driver serialize o valor DateTime para uma string:

#[derive(Serialize, Deserialize)]
struct Order {
    item: String,
    #[serde(serialize_with = "serialize_bson_datetime_as_rfc3339_string")]
    delivery_date: DateTime,
}

Para ver como o driver serializa uma estrutura de exemplo Order para BSON, selecione entre as seguintes guias Struct e BSON :

let order = Order {
    item: "lima beans".to_string(),
    delivery_date: DateTime::now(),
};

{
  "_id": { ... },
  "item": "lima beans",
  "delivery_date": "2023-09-26T17:30:18.181Z"
}

Serialize um u32 como um f64

Você pode querer representar um valor de campo u32 em um documento como um f64 ou Double tipo em BSON. Para especificar essa conversão, use a função auxiliar serialize_u32_as_f64 como valor do atributo serialize_with anexado ao campo com um valor u32 . O exemplo seguinte anexa o atributo serialize_with ao campo quantity para que o driver serialize o valor u32 para um tipo Double :

#[derive(Serialize, Deserialize)]
struct Order {
    item: String,
    #[serde(serialize_with = "serialize_u32_as_f64")]
    quantity: u32,
}

Outros atributos e módulos

Além das funções auxiliares, a biblioteca bson fornece módulos que lidam com a serialização e a desserialização. Para selecionar um módulo para usar em um campo ou variante específica, defina o valor do atributo with para o nome do módulo:

#[derive(Serialize, Deserialize)]
struct MyStruct {
    #[serde(with = "<module>")]
    field1: u32,
    // ... other fields
}

Para obter uma lista completa desses módulos, consulte a documentação da API serde_helpers.

O crate serde fornece muitos outros atributos para personalizar a serialização. A lista a seguir descreve alguns atributos comuns e sua funcionalidade:

• rename: serializar e desserializar um campo com um nome especificado em vez do nome da struct ou variante de Rust

• skip: não serialize ou deserialize o campo especificado

• default: se nenhum valor estiver presente durante a desserialização, use o valor padrão de Default::default()

Para obter uma lista completa dos serde atributos , consulte a documentação da API de atributos do serde .

Documentação da API

Para saber mais sobre os métodos e tipos mencionados neste guia, consulte a documentação da API abaixo:

• collection()

• clone_with_type()

• serialize_with Atributo Serde

• deserialize_with Atributo Serde

• com Atributo Serde