use std::cell::RefCell;
use std::ops::Bound;
use super::tag::*;
use super::{DEPTH_LIMIT, Error, geometry, int_width, uint_width, varint};
use crate::val::{Date, Interval, Number, Object, RecordId, RecordIdKey, Time, Timestamp, Value};
#[derive(Default)]
pub struct Encoder {
buf: Vec<u8>,
head: usize,
starts: Vec<u32>,
}
#[must_use = "an opened container must be closed"]
#[derive(Debug)]
pub struct Open {
end: usize,
mark: usize,
at: usize,
last: Option<u32>,
}
impl Open {
fn into_span(self) -> (usize, usize) {
(self.end, self.mark)
}
}
const RETAIN_LIMIT: usize = 1 << 20;
thread_local! {
static ENCODER: RefCell<Encoder> = RefCell::new(Encoder::default());
}
pub fn with_encoder<R>(f: impl FnOnce(&mut Encoder) -> R) -> R {
ENCODER.with(|cell| match cell.try_borrow_mut() {
Ok(mut enc) => {
enc.clear();
let r = f(&mut enc);
if enc.buf.len() > RETAIN_LIMIT {
*enc = Encoder::default();
}
r
}
Err(_) => f(&mut Encoder::default()),
})
}
pub fn encode(v: &Value) -> Result<Vec<u8>, Error> {
with_encoder(|enc| {
enc.value(v)?;
Ok(enc.as_bytes().to_vec())
})
}
#[inline]
fn decimal_parts(d: &rust_decimal::Decimal) -> (u8, [u8; 16], usize) {
let m = d.mantissa().unsigned_abs();
let len = (128 - m.leading_zeros() as usize).div_ceil(8);
(((d.is_sign_negative() as u8) << 7) | d.scale() as u8, m.to_le_bytes(), len)
}
pub fn put_decimal_payload(d: &rust_decimal::Decimal, out: &mut Vec<u8>) {
let (head, magnitude, len) = decimal_parts(d);
out.push(head);
out.extend_from_slice(&magnitude[..len]);
}
pub fn put_bigdecimal_payload(d: &surrealdb_types::BigDecimal, out: &mut Vec<u8>) {
out.push(u8::from(d.signum() < 0));
let mut buf = [0u8; varint::MAX_LEN];
out.extend_from_slice(varint::write_u64(d.scale() as u64, &mut buf));
out.extend_from_slice(&d.magnitude_le_bytes());
}
impl Encoder {
pub fn clear(&mut self) {
self.head = self.buf.len();
self.starts.clear();
}
#[inline(always)]
pub fn written(&self) -> usize {
self.buf.len() - self.head
}
#[inline(always)]
pub fn as_bytes(&self) -> &[u8] {
&self.buf[self.head..]
}
#[cold]
#[inline(never)]
fn grow(&mut self, need: usize) {
let used = self.written();
let len = (self.buf.len() * 2).max(used + need).max(256);
let mut buf = vec![0u8; len];
buf[len - used..].copy_from_slice(&self.buf[self.head..]);
self.head = len - used;
self.buf = buf;
}
#[inline(always)]
pub(super) fn front(&mut self, n: usize) -> &mut [u8] {
if self.head < n {
self.grow(n);
}
self.head -= n;
&mut self.buf[self.head..self.head + n]
}
#[inline(always)]
pub fn put(&mut self, b: &[u8]) {
self.front(b.len()).copy_from_slice(b);
}
#[inline(always)]
pub fn put_u8(&mut self, b: u8) {
self.front(1)[0] = b;
}
#[inline]
pub fn put_varint_u64(&mut self, v: u64) {
let mut buf = [0u8; varint::MAX_LEN];
self.put(varint::write_u64(v, &mut buf));
}
#[inline(always)]
pub fn put_clen(&mut self, n: usize) -> Result<(), Error> {
if n < 0xFF {
self.put_u8(n as u8);
} else {
let n =
u32::try_from(n).map_err(|_| Error::Unstorable("a string longer than 4 GiB"))?;
self.put(&n.to_le_bytes());
self.put_u8(0xFF);
}
Ok(())
}
#[inline(always)]
fn put_clen_bytes(&mut self, b: &[u8]) -> Result<(), Error> {
self.put(b);
self.put_clen(b.len())
}
#[inline(always)]
fn mark(&mut self) -> Result<(), Error> {
let at = u32::try_from(self.written())
.map_err(|_| Error::Unstorable("a value larger than 4 GiB"))?;
self.starts.push(at);
Ok(())
}
fn finish(&mut self, base: u8, end: usize, mark: usize) -> Result<(), Error> {
const MISORDERED: Error = Error::Unstorable("a container closed out of order");
let n = self.starts.len().checked_sub(mark).ok_or(MISORDERED)?;
let start = self.written();
let len = start.checked_sub(end).ok_or(MISORDERED)?;
let spans = self.starts.get(mark..).ok_or(MISORDERED)?;
if let (Some(&first), Some(&last)) = (spans.first(), spans.last())
&& ((first as usize) < end || (last as usize) > start)
{
return Err(MISORDERED);
}
let (w, tag) = if len <= 0xFF && n <= 0xFF {
(1, base)
} else if len <= 0xFFFF && n <= 0xFFFF {
(2, base + 1)
} else if u32::try_from(len).is_ok() && u32::try_from(n).is_ok() {
(4, base + 2)
} else {
return Err(Error::Unstorable("a value larger than 4 GiB"));
};
let total = n
.checked_mul(w)
.and_then(|t| t.checked_add(1 + w))
.ok_or(Error::Unstorable("a value larger than 4 GiB"))?;
if self.head < total {
self.grow(total);
}
self.head -= total;
let h = self.head;
let out = &mut self.buf[h..h + total];
let starts = &self.starts[mark..];
out[0] = tag;
match w {
1 => {
out[1] = n as u8;
for (slot, &s) in out[2..].iter_mut().zip(starts.iter().rev()) {
*slot = (start - s as usize) as u8;
}
}
2 => {
out[1..3].copy_from_slice(&(n as u16).to_le_bytes());
for (slot, &s) in
out[3..].as_chunks_mut::<2>().0.iter_mut().zip(starts.iter().rev())
{
*slot = ((start - s as usize) as u16).to_le_bytes();
}
}
_ => {
out[1..5].copy_from_slice(&(n as u32).to_le_bytes());
for (slot, &s) in
out[5..].as_chunks_mut::<4>().0.iter_mut().zip(starts.iter().rev())
{
*slot = ((start - s as usize) as u32).to_le_bytes();
}
}
}
self.starts.truncate(mark);
Ok(())
}
pub fn value(&mut self, v: &Value) -> Result<(), Error> {
self.value_at(v, 0)
}
pub fn value_nested(&mut self, v: &Value, depth: usize) -> Result<(), Error> {
self.value_at(v, depth)
}
pub fn record_key_nested(&mut self, k: &RecordIdKey, depth: usize) -> Result<(), Error> {
self.key(k, depth)
}
pub fn object_entries_nested<'v, I>(
&mut self,
rev: I,
n: usize,
depth: usize,
) -> Result<(), Error>
where
I: Iterator<Item = (&'v str, &'v Value)>,
{
self.object(rev, n, depth)
}
pub fn object_without(&mut self, obj: &Object, skip: &str) -> Result<(), Error> {
let n = obj.0.len() - usize::from(obj.0.contains_key(skip));
self.object(
obj.0.iter().rev().filter(|(k, _)| k.as_str() != skip).map(|(k, v)| (k.as_str(), v)),
n,
0,
)
}
pub fn object_entries<'v, I>(&mut self, rev: I, n: usize) -> Result<(), Error>
where
I: Iterator<Item = (&'v str, &'v Value)>,
{
self.object(rev, n, 0)
}
fn object<'v, I>(&mut self, rev: I, n: usize, depth: usize) -> Result<(), Error>
where
I: Iterator<Item = (&'v str, &'v Value)>,
{
let end = self.written();
let mark = self.starts.len();
for (k, v) in rev {
self.value_at(v, depth + 1)?;
self.put_clen_bytes(k.as_bytes())?;
self.mark()?;
}
self.expect_entries(mark, n)?;
self.finish(OBJECT, end, mark)
}
fn items<'v, I>(&mut self, base: u8, rev: I, n: usize, depth: usize) -> Result<(), Error>
where
I: Iterator<Item = &'v Value>,
{
let end = self.written();
let mark = self.starts.len();
for v in rev {
self.value_at(v, depth + 1)?;
self.mark()?;
}
self.expect_entries(mark, n)?;
self.finish(base, end, mark)
}
#[inline(always)]
fn expect_entries(&self, mark: usize, n: usize) -> Result<(), Error> {
match self.starts.len().checked_sub(mark) {
Some(got) if got == n => Ok(()),
_ => Err(Error::Unstorable("a container whose entry count is not the entries written")),
}
}
#[inline(always)]
pub fn none(&mut self) {
self.put_u8(NONE);
}
#[inline(always)]
pub fn bool(&mut self, b: bool) {
self.put_u8(if b {
TRUE
} else {
FALSE
});
}
#[inline]
pub fn int(&mut self, v: i64) {
if (0..=SMALL_INT_MAX).contains(&v) {
self.put_u8(SMALL_INT + v as u8);
} else {
self.put(&v.to_le_bytes()[..int_width(v)]);
self.put_u8(INT);
}
}
#[inline]
pub fn float(&mut self, f: f64) {
let g = f as f32;
if g as f64 == f && !f.is_nan() {
self.put(&g.to_le_bytes());
} else {
self.put(&f.to_le_bytes());
}
self.put_u8(FLOAT);
}
#[inline]
pub fn f32_bits(&mut self, f: f32) {
self.put(&f.to_le_bytes());
self.put_u8(FLOAT);
}
#[inline]
pub fn decimal(&mut self, d: &rust_decimal::Decimal) {
let (head, magnitude, len) = decimal_parts(d);
self.put(&magnitude[..len]);
self.put_u8(head);
self.put_u8(DECIMAL);
}
pub fn bigdecimal(&mut self, d: &surrealdb_types::BigDecimal) {
self.put(&d.magnitude_le_bytes());
let mut buf = [0u8; varint::MAX_LEN];
self.put(varint::write_u64(d.scale() as u64, &mut buf));
self.put_u8(u8::from(d.signum() < 0));
self.put_u8(BIGDECIMAL);
}
#[inline]
pub fn i8(&mut self, v: i8) {
self.put_u8(v as u8);
self.put_u8(I8);
}
#[inline]
pub fn u8(&mut self, v: u8) {
self.put_u8(v);
self.put_u8(U8);
}
#[inline]
pub fn i16(&mut self, v: i16) {
self.put(&v.to_le_bytes()[..int_width(v as i64)]);
self.put_u8(I16);
}
#[inline]
pub fn u16(&mut self, v: u16) {
self.put(&v.to_le_bytes()[..uint_width(v as u64)]);
self.put_u8(U16);
}
#[inline]
pub fn i32(&mut self, v: i32) {
self.put(&v.to_le_bytes()[..int_width(v as i64)]);
self.put_u8(I32);
}
#[inline]
pub fn u32(&mut self, v: u32) {
self.put(&v.to_le_bytes()[..uint_width(v as u64)]);
self.put_u8(U32);
}
#[inline]
pub fn u64(&mut self, v: u64) {
self.put(&v.to_le_bytes()[..uint_width(v)]);
self.put_u8(U64);
}
#[inline]
pub fn f16(&mut self, f: half::f16) {
self.put(&f.to_bits().to_le_bytes());
self.put_u8(F16);
}
#[inline]
pub fn f32(&mut self, f: f32) {
self.put(&f.to_bits().to_le_bytes());
self.put_u8(F32);
}
#[inline]
pub fn number(&mut self, n: &Number) -> Result<(), Error> {
match n {
Number::BigDecimal(b) => self.bigdecimal(b),
Number::Int(i) => self.int(*i),
Number::Float(f) => self.float(*f),
Number::Decimal(d) => self.decimal(d),
Number::I8(v) => self.i8(*v),
Number::U8(v) => self.u8(*v),
Number::I16(v) => self.i16(*v),
Number::U16(v) => self.u16(*v),
Number::I32(v) => self.i32(*v),
Number::U32(v) => self.u32(*v),
Number::U64(v) => self.u64(*v),
Number::F16(v) => self.f16(*v),
Number::F32(v) => self.f32(*v),
}
Ok(())
}
#[inline]
pub fn string(&mut self, s: &str) {
self.put(s.as_bytes());
self.put_u8(STRING);
}
#[inline]
pub fn bytes(&mut self, b: &[u8]) {
self.put(b);
self.put_u8(BYTES);
}
#[inline]
pub fn uuid(&mut self, u: &uuid::Uuid) {
self.put(u.as_bytes());
self.put_u8(UUID);
}
#[inline]
pub fn duration(&mut self, d: std::time::Duration) {
match u64::try_from(d.as_nanos()) {
Ok(ns) => self.put(&ns.to_le_bytes()),
Err(_) => {
self.put(&d.subsec_nanos().to_le_bytes());
self.put(&d.as_secs().to_le_bytes());
}
}
self.put_u8(DURATION);
}
#[inline]
pub fn datetime(&mut self, d: &chrono::DateTime<chrono::Utc>) {
let subsec = d.timestamp_subsec_nanos();
match d.timestamp_nanos_opt().filter(|_| subsec < 1_000_000_000) {
Some(ns) => self.put(&ns.to_le_bytes()),
None => {
self.put(&subsec.to_le_bytes());
self.put(&d.timestamp().to_le_bytes());
}
}
self.put_u8(DATETIME);
}
#[inline]
pub fn date(&mut self, d: &Date) {
self.put(&d.0.to_le_bytes()[..int_width(i64::from(d.0))]);
self.put_u8(DATE);
}
#[inline]
pub fn time(&mut self, t: &Time) {
self.put(&t.0.to_le_bytes()[..uint_width(t.0)]);
self.put_u8(TIME);
}
#[inline]
pub fn timestamp(&mut self, t: &Timestamp) {
let ns = t.secs.checked_mul(1_000_000_000).and_then(|s| s.checked_add(i64::from(t.nanos)));
match ns.filter(|_| t.nanos < 1_000_000_000) {
Some(ns) => self.put(&ns.to_le_bytes()),
None => {
self.put(&t.nanos.to_le_bytes());
self.put(&t.secs.to_le_bytes());
}
}
self.put_u8(TIMESTAMP);
}
#[inline]
pub fn interval(&mut self, i: &Interval) {
self.put(&i.micros.to_le_bytes());
self.put(&i.days.to_le_bytes());
self.put(&i.months.to_le_bytes());
self.put_u8(INTERVAL);
}
pub fn record_id(&mut self, r: &RecordId) -> Result<(), Error> {
self.record_id_at(r, 0)
}
fn record_id_at(&mut self, r: &RecordId, depth: usize) -> Result<(), Error> {
self.key(&r.key, depth + 1)?;
self.put_clen_bytes(r.table.as_str().as_bytes())?;
self.put_u8(RECORD_ID);
Ok(())
}
pub fn values(&mut self, v: &[Value]) -> Result<(), Error> {
self.values_at(v, 0)
}
pub fn open(&mut self) -> Result<Open, Error> {
let written = self.written();
u32::try_from(written).map_err(|_| Error::Unstorable("a value larger than 4 GiB"))?;
Ok(Open {
end: written,
mark: self.starts.len(),
at: written,
last: None,
})
}
pub fn end_entry(&mut self, open: &mut Open, number: u32) -> Result<(), Error> {
if number == 0 {
return Err(Error::Unstorable("a map entry number of zero"));
}
if open.last.is_some_and(|last| number >= last) {
return Err(Error::Unstorable("map entry numbers are not strictly ascending"));
}
if self.written() <= open.at {
return Err(Error::Unstorable("a map entry with no item"));
}
self.put_varint_u64(u64::from(number));
self.mark()?;
open.at = self.written();
open.last = Some(number);
Ok(())
}
pub fn raw_entry(&mut self, open: &mut Open, number: u32, item: &[u8]) -> Result<(), Error> {
if item.is_empty() {
return Err(Error::Unstorable("a map entry with no item"));
}
self.put(item);
self.end_entry(open, number)
}
pub fn end_item(&mut self, open: &mut Open) -> Result<(), Error> {
if self.written() <= open.at {
return Err(Error::Unstorable("a list element with no item"));
}
self.mark()?;
open.at = self.written();
Ok(())
}
pub fn close_map(&mut self, open: Open) -> Result<(), Error> {
let (end, mark) = open.into_span();
self.finish(MAP, end, mark)
}
pub fn close_list(&mut self, open: Open) -> Result<(), Error> {
let (end, mark) = open.into_span();
self.finish(ARRAY, end, mark)
}
fn value_at(&mut self, v: &Value, depth: usize) -> Result<(), Error> {
if depth > DEPTH_LIMIT {
return Err(Error::TooDeep(DEPTH_LIMIT));
}
match v {
Value::None => self.none(),
Value::Null => self.put_u8(NULL),
Value::Bool(b) => self.bool(*b),
Value::Number(n) => self.number(n)?,
Value::String(s) => self.string(s.as_str()),
Value::Duration(d) => self.duration(d.0),
Value::Datetime(d) => self.datetime(&d.0),
Value::Date(d) => self.date(d),
Value::Time(t) => self.time(t),
Value::Timestamp(t) => self.timestamp(t),
Value::Interval(i) => self.interval(i),
Value::Uuid(u) => self.uuid(&u.0),
Value::Array(a) => self.values_at(&a.0, depth)?,
Value::Set(s) => self.items(SET, s.0.iter().rev(), s.0.len(), depth)?,
Value::Object(o) => {
self.object(o.0.iter().rev().map(|(k, v)| (k.as_str(), v)), o.0.len(), depth)?
}
Value::Geometry(g) => {
geometry::encode(self, g, depth)?;
self.put_u8(GEOMETRY);
}
Value::Bytes(b) => self.bytes(&b.0),
Value::Table(t) => {
self.put(t.as_str().as_bytes());
self.put_u8(TABLE);
}
Value::RecordId(rid) => self.record_id_at(rid, depth)?,
Value::File(f) => {
self.put(f.key.as_bytes());
self.put_clen_bytes(f.bucket.as_bytes())?;
self.put_u8(FILE);
}
Value::Regex(r) => {
self.put(r.0.as_str().as_bytes());
self.put_u8(REGEX);
}
Value::Range(r) => {
self.end_bound(&r.end, |e, v| e.value_at(v, depth + 1))?;
self.start_bound(&r.start, |e, v| e.value_at(v, depth + 1))?;
self.put_u8(RANGE);
}
Value::Closure(_) => return Err(Error::Closure),
}
Ok(())
}
#[inline]
fn put_ints<const W: usize>(&mut self, v: &[Value]) {
let (out, _) = self.front(v.len() * W).as_chunks_mut::<W>();
debug_assert_eq!(out.len(), v.len());
for (slot, e) in out.iter_mut().zip(v) {
if let Value::Number(Number::Int(i)) = e
&& let Some(b) = i.to_le_bytes().first_chunk::<W>()
{
*slot = *b;
} else {
debug_assert!(false, "an element that is not an integer of the array's width");
}
}
}
fn values_at(&mut self, v: &[Value], depth: usize) -> Result<(), Error> {
if let Some(w) = narrowest_int_array_width(v) {
match w {
1 => self.put_ints::<1>(v),
2 => self.put_ints::<2>(v),
4 => self.put_ints::<4>(v),
_ => self.put_ints::<8>(v),
}
self.put_u8(I8_ARRAY + w.trailing_zeros() as u8);
return Ok(());
}
if !v.is_empty() && v.iter().all(|v| matches!(v, Value::Number(Number::Float(_)))) {
let floats = v.iter().map(|v| {
if let Value::Number(Number::Float(f)) = v {
*f
} else {
unreachable!("every element is a float")
}
});
if floats.clone().all(|f| (f as f32) as f64 == f && !f.is_nan()) {
let (out, _) = self.front(v.len() * 4).as_chunks_mut::<4>();
for (slot, f) in out.iter_mut().zip(floats) {
*slot = (f as f32).to_le_bytes();
}
self.put_u8(F32_ARRAY);
} else {
let (out, _) = self.front(v.len() * 8).as_chunks_mut::<8>();
for (slot, f) in out.iter_mut().zip(floats) {
*slot = f.to_le_bytes();
}
self.put_u8(F64_ARRAY);
}
return Ok(());
}
self.items(ARRAY, v.iter().rev(), v.len(), depth)
}
fn key(&mut self, k: &RecordIdKey, depth: usize) -> Result<(), Error> {
if depth > DEPTH_LIMIT {
return Err(Error::TooDeep(DEPTH_LIMIT));
}
match k {
RecordIdKey::Number(n) => self.int(*n),
RecordIdKey::String(s) => {
self.put(s.as_str().as_bytes());
self.put_u8(STRING);
}
RecordIdKey::Uuid(u) => {
self.put(u.0.as_bytes());
self.put_u8(UUID);
}
RecordIdKey::Array(a) => self.values_at(&a.0, depth)?,
RecordIdKey::Object(o) => {
self.object(o.0.iter().rev().map(|(k, v)| (k.as_str(), v)), o.0.len(), depth)?
}
RecordIdKey::Range(r) => {
self.end_bound(&r.end, |e, k| e.key(k, depth + 1))?;
self.start_bound(&r.start, |e, k| e.key(k, depth + 1))?;
self.put_u8(RANGE);
}
}
Ok(())
}
fn start_bound<T>(
&mut self,
b: &Bound<T>,
f: impl FnOnce(&mut Self, &T) -> Result<(), Error>,
) -> Result<(), Error> {
match b {
Bound::Unbounded => self.put_u8(UNBOUNDED),
Bound::Included(v) | Bound::Excluded(v) => {
let before = self.written();
f(self, v)?;
self.put_clen(self.written() - before)?;
self.put_u8(if matches!(b, Bound::Included(_)) {
INCLUDED
} else {
EXCLUDED
});
}
}
Ok(())
}
fn end_bound<T>(
&mut self,
b: &Bound<T>,
f: impl FnOnce(&mut Self, &T) -> Result<(), Error>,
) -> Result<(), Error> {
match b {
Bound::Unbounded => self.put_u8(UNBOUNDED),
Bound::Included(v) | Bound::Excluded(v) => {
f(self, v)?;
self.put_u8(if matches!(b, Bound::Included(_)) {
INCLUDED
} else {
EXCLUDED
});
}
}
Ok(())
}
}
#[inline]
fn narrowest_int_array_width(v: &[Value]) -> Option<usize> {
let mut w = 1;
for e in v {
if let Value::Number(Number::Int(i)) = e {
w = w.max(int_width(*i));
} else {
return None;
}
}
(!v.is_empty()).then(|| w.next_power_of_two())
}