mirror of
https://github.com/neondatabase/neon.git
synced 2026-01-07 05:22:56 +00:00
55aef2993d
See #11992 and #11961 for some examples of usecases. This introduces a JSON serialization lib, designed for more flexibility than serde_json offers. ## Dynamic construction Sometimes you have dynamic values you want to serialize, that are not already in a serde-aware model like a struct or a Vec etc. To achieve this with serde, you need to implement a lot of different traits on a lot of different new-types. Because of this, it's often easier to give-in and pull all the data into a serde-aware model (serde_json::Value or some intermediate struct), but that is often not very efficient. This crate allows full control over the JSON encoding without needing to implement any extra traits. Just call the relevant functions, and it will guarantee a correctly encoded JSON value. ## Async construction Similar to the above, sometimes the values arrive asynchronously. Often collecting those values in memory is more expensive than writing them as JSON, since the overheads of `Vec` and `String` is much higher, however there are exceptions. Serializing to JSON all in one go is also more CPU intensive and can cause lag spikes, whereas serializing values incrementally spreads out the CPU load and reduces lag.
87 lines
2.5 KiB
Rust
87 lines
2.5 KiB
Rust
//! # Examples
|
|
//!
|
|
//! ```
|
|
//! use futures::{StreamExt, TryStream, TryStreamExt};
|
|
//!
|
|
//! async fn stream_to_json_list<S, T, E>(mut s: S) -> Result<String, E>
|
|
//! where
|
|
//! S: TryStream<Ok = T, Error = E> + Unpin,
|
|
//! T: json::ValueEncoder
|
|
//! {
|
|
//! Ok(json::value_to_string!(|val| json::value_as_list!(|val| {
|
|
//! // note how we can use `.await` and `?` in here.
|
|
//! while let Some(value) = s.try_next().await? {
|
|
//! val.push(value);
|
|
//! }
|
|
//! })))
|
|
//! }
|
|
//!
|
|
//! let stream = futures::stream::iter([1, 2, 3]).map(Ok::<i32, ()>);
|
|
//! let json_string = futures::executor::block_on(stream_to_json_list(stream)).unwrap();
|
|
//! assert_eq!(json_string, "[1,2,3]");
|
|
//! ```
|
|
|
|
/// A helper to create a new JSON vec.
|
|
///
|
|
/// Implemented as a macro to preserve all control flow.
|
|
#[macro_export]
|
|
macro_rules! value_to_vec {
|
|
(|$val:ident| $body:expr) => {{
|
|
let mut buf = vec![];
|
|
let $val = $crate::ValueSer::new(&mut buf);
|
|
let _: () = $body;
|
|
buf
|
|
}};
|
|
}
|
|
|
|
/// A helper to create a new JSON string.
|
|
///
|
|
/// Implemented as a macro to preserve all control flow.
|
|
#[macro_export]
|
|
macro_rules! value_to_string {
|
|
(|$val:ident| $body:expr) => {{
|
|
::std::string::String::from_utf8($crate::value_to_vec!(|$val| $body))
|
|
.expect("json should be valid utf8")
|
|
}};
|
|
}
|
|
|
|
/// A helper that ensures the [`ObjectSer::finish`](crate::ObjectSer::finish) method is called on completion.
|
|
///
|
|
/// Consumes `$val` and assigns it as an [`ObjectSer`](crate::ObjectSer) serializer.
|
|
/// The serializer is only 'finished' if the body completes.
|
|
/// The serializer is rolled back if `break`/`return` escapes the body.
|
|
///
|
|
/// Implemented as a macro to preserve all control flow.
|
|
#[macro_export]
|
|
macro_rules! value_as_object {
|
|
(|$val:ident| $body:expr) => {{
|
|
let mut obj = $crate::ObjectSer::new($val);
|
|
|
|
let $val = &mut obj;
|
|
let res = $body;
|
|
|
|
obj.finish();
|
|
res
|
|
}};
|
|
}
|
|
|
|
/// A helper that ensures the [`ListSer::finish`](crate::ListSer::finish) method is called on completion.
|
|
///
|
|
/// Consumes `$val` and assigns it as an [`ListSer`](crate::ListSer) serializer.
|
|
/// The serializer is only 'finished' if the body completes.
|
|
/// The serializer is rolled back if `break`/`return` escapes the body.
|
|
///
|
|
/// Implemented as a macro to preserve all control flow.
|
|
#[macro_export]
|
|
macro_rules! value_as_list {
|
|
(|$val:ident| $body:expr) => {{
|
|
let mut list = $crate::ListSer::new($val);
|
|
|
|
let $val = &mut list;
|
|
let res = $body;
|
|
|
|
list.finish();
|
|
res
|
|
}};
|
|
}
|