noth/surrealpatch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Always use simplified serialization unless specified explicitly

Browse source
This commit is contained in:
Tobie Morgan Hitchcock 2022-05-21 01:35:59 +01:00
parent 64ddd407ca
commit 61b1e547b6
19 changed files with 119 additions and 79 deletions

22
Cargo.lock generated
View file

@ -1817,11 +1817,11 @@ checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
[[package]]
name = "proc-macro2"
version = "1.0.38"
version = "1.0.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9027b48e9d4c9175fa2218adf3557f91c1137021739951d4932f5f8268ac48aa"
checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
dependencies = [
"unicode-xid",
"unicode-ident",
]
[[package]]
@ -2624,9 +2624,9 @@ dependencies = [
[[package]]
name = "surrealdb-derive"
version = "0.1.2"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6045ae5b030a2485f0862dd735eff304b72a7cef3d4d541b3a46a45565737548"
checksum = "22a396ad39ed9eb61259fd5c0c9c9a9d9bdfcafa927c686b7cc3aa56ee5ff073"
dependencies = [
"quote",
"syn",
@ -2634,13 +2634,13 @@ dependencies = [
[[package]]
name = "syn"
version = "1.0.92"
version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ff7c592601f11445996a06f8ad0c27f094a58857c2f89e97974ab9235b92c52"
checksum = "fbaf6116ab8924f39d52792136fb74fd60a80194cf1b1c6ffa6453eef1c3f942"
dependencies = [
"proc-macro2",
"quote",
"unicode-xid",
"unicode-ident",
]
[[package]]
@ -3063,6 +3063,12 @@ version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1218098468b8085b19a2824104c70d976491d247ce194bbd9dc77181150cdfd6"
[[package]]
name = "unicode-ident"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"
[[package]]
name = "unicode-normalization"
version = "0.1.19"

2
lib/Cargo.toml
View file

@ -21,7 +21,7 @@ bigdecimal = { version = "0.3.0", features = ["serde", "string-only"] }
boa = { version = "0.14.0", package = "boa_engine", optional = true }
channel = { version = "1.6.1", package = "async-channel" }
chrono = { version = "0.4.19", features = ["serde"] }
derive = { version = "0.1.2", package = "surrealdb-derive" }
derive = { version = "0.2.0", package = "surrealdb-derive" }
dmp = "0.1.1"
echodb = { version = "0.3.0", optional = true }
executor = { version = "1.4.1", package = "async-executor", optional = true }

2
lib/src/doc/document.rs
View file

@ -18,7 +18,7 @@ pub struct Document<'a> {
impl<'a> From<&Document<'a>> for Vec<u8> {
fn from(val: &Document<'a>) -> Vec<u8> {
msgpack::to_vec(&val.current).unwrap()
val.current.as_ref().into()
}
}

5
lib/src/key/graph.rs
View file

@ -78,7 +78,10 @@ impl Graph {
}
}
pub fn encode(&self) -> Result<Vec<u8>, Error> {
Ok(serialize(self)?)
crate::sql::serde::beg_internal_serialization();
let v = serialize(self);
crate::sql::serde::end_internal_serialization();
Ok(v?)
}
pub fn decode(v: &[u8]) -> Result<Graph, Error> {
Ok(deserialize(v)?)

5
lib/src/key/index.rs
View file

@ -67,7 +67,10 @@ impl Index {
}
}
pub fn encode(&self) -> Result<Vec<u8>, Error> {
Ok(serialize(self)?)
crate::sql::serde::beg_internal_serialization();
let v = serialize(self);
crate::sql::serde::end_internal_serialization();
Ok(v?)
}
pub fn decode(v: &[u8]) -> Result<Index, Error> {
Ok(deserialize(v)?)

5
lib/src/key/point.rs
View file

@ -70,7 +70,10 @@ impl Point {
}
}
pub fn encode(&self) -> Result<Vec<u8>, Error> {
Ok(serialize(self)?)
crate::sql::serde::beg_internal_serialization();
let v = serialize(self);
crate::sql::serde::end_internal_serialization();
Ok(v?)
}
pub fn decode(v: &[u8]) -> Result<Point, Error> {
Ok(deserialize(v)?)

7
lib/src/sql/array.rs
View file

@ -7,6 +7,7 @@ use crate::sql::common::commas;
use crate::sql::error::IResult;
use crate::sql::number::Number;
use crate::sql::operation::Operation;
use crate::sql::serde::is_internal_serialization;
use crate::sql::strand::Strand;
use crate::sql::value::{value, Value};
use nom::character::complete::char;
@ -159,10 +160,10 @@ impl Serialize for Array {
where
S: serde::Serializer,
{
if serializer.is_human_readable() {
serializer.serialize_some(&self.0)
} else {
if is_internal_serialization() {
serializer.serialize_newtype_struct("Array", &self.0)
} else {
serializer.serialize_some(&self.0)
}
}
}

7
lib/src/sql/datetime.rs
View file

@ -1,5 +1,6 @@
use crate::sql::common::{take_digits, take_digits_range, take_u32};
use crate::sql::error::IResult;
use crate::sql::serde::is_internal_serialization;
use chrono::{DateTime, FixedOffset, TimeZone, Utc};
use nom::branch::alt;
use nom::character::complete::char;
@ -58,10 +59,10 @@ impl Serialize for Datetime {
where
S: serde::Serializer,
{
if serializer.is_human_readable() {
serializer.serialize_some(&self.0)
} else {
if is_internal_serialization() {
serializer.serialize_newtype_struct("Datetime", &self.0)
} else {
serializer.serialize_some(&self.0)
}
}
}

7
lib/src/sql/duration.rs
View file

@ -1,6 +1,7 @@
use crate::sql::common::take_u64;
use crate::sql::datetime::Datetime;
use crate::sql::error::IResult;
use crate::sql::serde::is_internal_serialization;
use chrono::DurationRound;
use nom::branch::alt;
use nom::bytes::complete::tag;
@ -110,10 +111,10 @@ impl Serialize for Duration {
where
S: serde::Serializer,
{
if serializer.is_human_readable() {
serializer.serialize_some(&self.0)
} else {
if is_internal_serialization() {
serializer.serialize_newtype_struct("Duration", &self.0)
} else {
serializer.serialize_some(&self.0)
}
}
}

31
lib/src/sql/geometry.rs
View file

@ -1,6 +1,7 @@
use crate::sql::comment::mightbespace;
use crate::sql::common::commas;
use crate::sql::error::IResult;
use crate::sql::serde::is_internal_serialization;
use geo::algorithm::contains::Contains;
use geo::algorithm::intersects::Intersects;
use geo::{LineString, Point, Polygon};
@ -367,7 +368,21 @@ impl Serialize for Geometry {
where
S: serde::Serializer,
{
if s.is_human_readable() {
if is_internal_serialization() {
match self {
Geometry::Point(v) => s.serialize_newtype_variant("Geometry", 0, "Point", v),
Geometry::Line(v) => s.serialize_newtype_variant("Geometry", 1, "Line", v),
Geometry::Polygon(v) => s.serialize_newtype_variant("Geometry", 2, "Polygon", v),
Geometry::MultiPoint(v) => s.serialize_newtype_variant("Geometry", 3, "Points", v),
Geometry::MultiLine(v) => s.serialize_newtype_variant("Geometry", 4, "Lines", v),
Geometry::MultiPolygon(v) => {
s.serialize_newtype_variant("Geometry", 5, "Polygons", v)
}
Geometry::Collection(v) => {
s.serialize_newtype_variant("Geometry", 6, "Collection", v)
}
}
} else {
match self {
Geometry::Point(v) => {
let mut map = s.serialize_map(Some(2))?;
@ -450,20 +465,6 @@ impl Serialize for Geometry {
map.end()
}
}
} else {
match self {
Geometry::Point(v) => s.serialize_newtype_variant("Geometry", 0, "Point", v),
Geometry::Line(v) => s.serialize_newtype_variant("Geometry", 1, "Line", v),
Geometry::Polygon(v) => s.serialize_newtype_variant("Geometry", 2, "Polygon", v),
Geometry::MultiPoint(v) => s.serialize_newtype_variant("Geometry", 3, "Points", v),
Geometry::MultiLine(v) => s.serialize_newtype_variant("Geometry", 4, "Lines", v),
Geometry::MultiPolygon(v) => {
s.serialize_newtype_variant("Geometry", 5, "Polygons", v)
}
Geometry::Collection(v) => {
s.serialize_newtype_variant("Geometry", 6, "Collection", v)
}
}
}
}
}

1
lib/src/sql/mod.rs
View file

@ -35,6 +35,7 @@ pub(crate) mod permission;
pub(crate) mod query;
pub(crate) mod regex;
pub(crate) mod script;
pub(crate) mod serde;
pub(crate) mod split;
pub(crate) mod start;
pub(crate) mod statement;

15
lib/src/sql/number.rs
View file

@ -1,6 +1,7 @@
use crate::sql::comment::comment;
use crate::sql::error::IResult;
use crate::sql::operator::{assigner, operator};
use crate::sql::serde::is_internal_serialization;
use bigdecimal::BigDecimal;
use bigdecimal::FromPrimitive;
use bigdecimal::ToPrimitive;
@ -138,18 +139,18 @@ impl Serialize for Number {
where
S: serde::Serializer,
{
if s.is_human_readable() {
match self {
Number::Int(v) => s.serialize_i64(*v),
Number::Float(v) => s.serialize_f64(*v),
Number::Decimal(v) => s.serialize_some(v),
}
} else {
if is_internal_serialization() {
match self {
Number::Int(v) => s.serialize_newtype_variant("Number", 0, "Int", v),
Number::Float(v) => s.serialize_newtype_variant("Number", 1, "Float", v),
Number::Decimal(v) => s.serialize_newtype_variant("Number", 2, "Decimal", v),
}
} else {
match self {
Number::Int(v) => s.serialize_i64(*v),
Number::Float(v) => s.serialize_f64(*v),
Number::Decimal(v) => s.serialize_some(v),
}
}
}
}

7
lib/src/sql/object.rs
View file

@ -7,6 +7,7 @@ use crate::sql::common::{commas, val_char};
use crate::sql::error::IResult;
use crate::sql::escape::escape_key;
use crate::sql::operation::{Op, Operation};
use crate::sql::serde::is_internal_serialization;
use crate::sql::value::{value, Value};
use nom::branch::alt;
use nom::bytes::complete::is_not;
@ -135,15 +136,15 @@ impl Serialize for Object {
where
S: serde::Serializer,
{
if serializer.is_human_readable() {
if is_internal_serialization() {
serializer.serialize_newtype_struct("Object", &self.0)
} else {
let mut map = serializer.serialize_map(Some(self.len()))?;
for (ref k, ref v) in &self.0 {
map.serialize_key(k)?;
map.serialize_value(v)?;
}
map.end()
} else {
serializer.serialize_newtype_struct("Object", &self.0)
}
}
}

4
lib/src/sql/parser.rs
View file

@ -159,8 +159,8 @@ mod tests {
assert!(res.is_ok());
let tmp = res.unwrap();
let enc = msgpack::to_vec(&tmp).unwrap();
let dec = msgpack::from_slice::<Query>(&enc).unwrap();
let enc: Vec<u8> = Vec::from(&tmp);
let dec: Query = Query::from(enc);
assert_eq!(tmp, dec);
}
}

3
lib/src/sql/query.rs
View file

@ -1,12 +1,13 @@
use crate::sql::error::IResult;
use crate::sql::statement::{statements, Statement, Statements};
use derive::Store;
use nom::combinator::all_consuming;
use serde::{Deserialize, Serialize};
use std::fmt;
use std::ops::Deref;
use std::str;
#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
pub struct Query(pub Statements);
impl Deref for Query {

18
lib/src/sql/serde.rs Normal file
View file

@ -0,0 +1,18 @@
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
thread_local! {
static INTERNAL_SERIALIZATION: AtomicBool = AtomicBool::new(false);
}
pub(crate) fn is_internal_serialization() -> bool {
INTERNAL_SERIALIZATION.with(|v| v.load(Ordering::Relaxed))
}
pub(crate) fn beg_internal_serialization() {
INTERNAL_SERIALIZATION.with(|v| v.store(true, Ordering::Relaxed))
}
pub(crate) fn end_internal_serialization() {
INTERNAL_SERIALIZATION.with(|v| v.store(false, Ordering::Relaxed))
}

7
lib/src/sql/strand.rs
View file

@ -1,5 +1,6 @@
use crate::sql::error::IResult;
use crate::sql::escape::escape_strand;
use crate::sql::serde::is_internal_serialization;
use nom::branch::alt;
use nom::bytes::complete::escaped;
use nom::bytes::complete::is_not;
@ -59,10 +60,10 @@ impl Serialize for Strand {
where
S: serde::Serializer,
{
if serializer.is_human_readable() {
serializer.serialize_some(&self.0)
} else {
if is_internal_serialization() {
serializer.serialize_newtype_struct("Strand", &self.0)
} else {
serializer.serialize_some(&self.0)
}
}
}

9
lib/src/sql/thing.rs
View file

@ -3,6 +3,7 @@ use crate::sql::escape::escape_ident;
use crate::sql::id::{id, Id};
use crate::sql::ident::ident_raw;
use crate::sql::number::Number;
use crate::sql::serde::is_internal_serialization;
use derive::Store;
use nom::character::complete::char;
use serde::ser::SerializeStruct;
@ -53,14 +54,14 @@ impl Serialize for Thing {
where
S: serde::Serializer,
{
if serializer.is_human_readable() {
let output = format!("{}:{}", self.tb, self.id);
serializer.serialize_some(&output)
} else {
if is_internal_serialization() {
let mut val = serializer.serialize_struct("Thing", 2)?;
val.serialize_field("tb", &self.tb)?;
val.serialize_field("id", &self.id)?;
val.end()
} else {
let output = format!("{}:{}", self.tb, self.id);
serializer.serialize_some(&output)
}
}
}

41
lib/src/sql/value/value.rs
View file

@ -22,6 +22,7 @@ use crate::sql::operation::Operation;
use crate::sql::param::{param, Param};
use crate::sql::part::Part;
use crate::sql::regex::{regex, Regex};
use crate::sql::serde::is_internal_serialization;
use crate::sql::strand::{strand, Strand};
use crate::sql::subquery::{subquery, Subquery};
use crate::sql::table::{table, Table};
@ -659,10 +660,6 @@ impl Value {
.into()
}
pub fn to_vec(&self) -> Result<Vec<u8>, Error> {
msgpack::to_vec(&self).map_err(|e| e.into())
}
// -----------------------------------
// Simple conversion of value
// -----------------------------------
@ -1010,24 +1007,7 @@ impl Serialize for Value {
where
S: serde::Serializer,
{
if s.is_human_readable() {
match self {
Value::None => s.serialize_none(),
Value::Void => s.serialize_none(),
Value::Null => s.serialize_none(),
Value::True => s.serialize_bool(true),
Value::False => s.serialize_bool(false),
Value::Thing(v) => s.serialize_some(v),
Value::Array(v) => s.serialize_some(v),
Value::Object(v) => s.serialize_some(v),
Value::Number(v) => s.serialize_some(v),
Value::Strand(v) => s.serialize_some(v),
Value::Geometry(v) => s.serialize_some(v),
Value::Duration(v) => s.serialize_some(v),
Value::Datetime(v) => s.serialize_some(v),
_ => s.serialize_none(),
}
} else {
if is_internal_serialization() {
match self {
Value::None => s.serialize_unit_variant("Value", 0, "None"),
Value::Void => s.serialize_unit_variant("Value", 1, "Void"),
@ -1051,6 +1031,23 @@ impl Serialize for Value {
Value::Subquery(v) => s.serialize_newtype_variant("Value", 19, "Subquery", v),
Value::Expression(v) => s.serialize_newtype_variant("Value", 20, "Expression", v),
}
} else {
match self {
Value::None => s.serialize_none(),
Value::Void => s.serialize_none(),
Value::Null => s.serialize_none(),
Value::True => s.serialize_bool(true),
Value::False => s.serialize_bool(false),
Value::Thing(v) => s.serialize_some(v),
Value::Array(v) => s.serialize_some(v),
Value::Object(v) => s.serialize_some(v),
Value::Number(v) => s.serialize_some(v),
Value::Strand(v) => s.serialize_some(v),
Value::Geometry(v) => s.serialize_some(v),
Value::Duration(v) => s.serialize_some(v),
Value::Datetime(v) => s.serialize_some(v),
_ => s.serialize_none(),
}
}
}
}