Rust 反序列化 JSON 成自定义 HashMap<string, google_firestore1::value></string,>

Question

I just started with Rust and I have some trouble with deserialization.

I'm actually trying to use the function ProjectDatabaseDocumentCreateDocumentCall from the following crate google_firestore1 . I want to populate the field fields of the struct Document . The documentation of the struct is clear, it's expecting a HashMap<String, google_firestore1::Value> as a value.

The question is, how can I deserialize a JSON string to a HashMap<String, google_firestore1::Value> ?

Here is the code I wrote for the moment:

extern crate google_firestore1 as firestore1;

use google_firestore1::Document;
use std::collections::HashMap;
use serde_json;

pub fn go() {

  let _my_doc = Document::default();

  let test = "{\"test\":\"test\", \"myarray\": [1]}";

  // Working perfectly fine
  let _working: HashMap<String, serde_json::Value> = serde_json::from_str(test).unwrap();

  // Not working
  let _not_working: HashMap<String, firestore1::Value> = serde_json::from_str(test).unwrap();

  // Later I want to do the following
  // _my_doc.fields = _not_working
}

Obvsiouly this is not working, and it crashes with the following error.

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error("invalid type: string \"test\", expected struct Value", line: 1, column: 14)', src/firestore.rs:17:85
stack backtrace:

Of course, I noticed that serde_json::Value and firestore1::Value are not the same Struct. But I gave a look at the source code and it seems that firestore1::Value is implementing the Deserialize trait.

So why is it not working? In this case, do I need to iterate over the first HashMap and deserialize serde_json::Value to firestore1::Value again? Is there a cleaner way to do what I want?

Thanks for your answer !

Answer 1

The definition of the firestore1::Value is:

/// A message that can hold any of the supported value types.
/// 
/// This type is not used in any activity, and only used as *part* of another schema.
/// 
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Value {
    /// A bytes value.
    /// 
    /// Must not exceed 1 MiB - 89 bytes.
    /// Only the first 1,500 bytes are considered by queries.
    #[serde(rename="bytesValue")]
    pub bytes_value: Option<String>,
    /// A timestamp value.
    /// 
    /// Precise only to microseconds. When stored, any additional precision is
    /// rounded down.
    #[serde(rename="timestampValue")]
    pub timestamp_value: Option<String>,

    ...

}

This means each entry for a firestore1::Value must be an object. I suspect that only one of the fields would actually be set, corresponding to the actual type of the value (as they're all optional).

So your json would need to be something like:

let test = r#"{
  "test":{"stringValue":"test"},
  "myarray": {
     "arrayValue":{"values":[{"integerValue":1}]}
  }
}"#;

This is pretty ugly, so if you're doing a lot of your own JSON to firestore conversations, I'd probably write some helpers to convert from the serde_json::Value to firestore1::Value .

It would probably look something like this:

fn my_firestore_from_json(v:serde_json::Value) -> firestore1::Value {
  match v {
    serde_json::Value::Null => firestore::Value {
      // I don't know why this is a Option<String>
      null_value: Some("".to_string),
      ..Default::default(),
    },
    serde_json::Value::Bool(b) => firestore::Value {
      bool_value: Some(b),
      ..Default::default(),
    },
    // Implement this
    serde_json::Value::Number(n) => my_firestore_number(n),
    serde_json::Value::String(s) => firestore::Value {
      string_value: Some(s),
      ..Default::default(),
    },
    serde_json::Value::Array(v) => firestore::Value {
      array_value:
        Some(firestore1::ArrayValue{
            values:v.into_iter().map(my_firestore_from_json)
        }),
      ..Default::default(),
    },
    // Implement this
    serde_json::Value::Object(d) => my_firststore_object(/* something */) 
  }
}

This would be a bit neater if there were various implementations of From<T> for the firestore1::Value , but using the implementation of Default makes this not too ugly.

It is also worth noting that not all firebase types are created here, since the types expressed in serde_json are different from those supported by firebase.

Anyway this allows you to use your JSON as written by doing something like:

let test = "{\"test\":\"test\", \"myarray\": [1]}";
let working: HashMap<String, serde_json::Value> = serde_json::from_str(test).unwrap();
let value_map: HashMap<String, firestore1::Value> = working.iter().map(|(k,v)| (k, my_firestore_from_json(v)).collect();