Crate serde_json_borrow

Serde JSON Borrowed

Parses JSON into serde_json_borrow::Value<'ctx> from &'ctx str.

The default serde_json parses into an owned serde_json::Value. In cases where the DOM representation is just an intermediate struct, parsing into owned serde_json::Value can cause a lot of overhead. serde_json_borrow::Value<'ctx> borrows the Strings instead.

Additionally it pushes the (key,value) for JSON objects into a Vec instead of putting the values into a BTreeMap. Access works via ObjectAsVec, which provides the same API as BTreeMap.

The primary benefit of using serde_json_borrow is a higher JSON deserialization performance due to less allocations. By borrowing a DOM, the library ensures that no additional memory is allocated for Strings, that contain no JSON escape codes.

OwnedValue

You can take advantage of OwnedValue to parse a String containing unparsed JSON into a Value without having to worry about lifetimes, as OwnedValue will take ownership of the String and reference slices of it, rather than making copies.

Limitations

Keys in objects are not allowed to have any JSON escaping characters. So if your keys contain any control characters https://www.json.org/json-en.html, this crate will not work for you. List of unsupported characters in keys.

\" represents the quotation mark character (U+0022).
\\ represents the reverse solidus character (U+005C).
\/ represents the solidus character (U+002F).
\b represents the backspace character (U+0008).
\f represents the form feed character (U+000C).
\n represents the line feed character (U+000A).
\r represents the carriage return character (U+000D).
\t represents the character tabulation character (U+0009).

Usage

use std::io;
use serde_json_borrow::Value;
fn main() -> io::Result<()> {
    let data = r#"{"bool": true, "key": "123"}"#;
    let value: Value = serde_json::from_str(&data)?;
    assert_eq!(value.get("bool"), &Value::Bool(true));
    assert_eq!(value.get("key"), &Value::Str("123".into()));
    Ok(())
}

Performance

Performance gain depends on how many allocations can be avoided, and how many objects there are, as deserializing into a vec is significantly faster.

The benchmarks in the github repository show around 1.8x speedup, although they don’t account for that in practice it won’t be a simple consecutive alloc json, dealloc json. There will be other allocations in between.

On a hadoop file system log data set benchmark, I get 714Mb/s JSON deserialization throughput on my machine.

Structs

• ObjectAsVec
  For performance reasons we use a Vec instead of a Hashmap.
• OwnedValue
  Parses a String into Value, by taking ownership of String and reference slices from it in contrast to copying the contents.

Enums

• Value
  Represents any valid JSON value.