pub use surrealdb_kvs::release::Release;
pub use surrealdb_stored_derive::Stored;
use super::{Encoder, Item};
use crate::val::Value;
mod describe;
mod error;
mod iam;
mod prim;
pub mod rt;
mod unrevisioned;
pub mod vm;
pub use describe::{Absent, Class, FieldSchema, Payload, Shape, TypeSchema, VariantSchema};
pub use error::SchemaError;
pub use unrevisioned::Unrevisioned;
pub const MAX_SCHEMA_DEPTH: u32 = 32;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Floor {
pub release: Release,
pub unparsable_text: bool,
}
impl Floor {
pub const fn first() -> Self {
Self {
release: Release::FIRST_STORED,
unparsable_text: false,
}
}
pub fn raise(&mut self, release: Release) {
if release > self.release {
self.release = release;
}
}
}
pub trait StoredField: Sized + PartialEq {
const NULLABLE: bool = false;
fn encode_item(&self, enc: &mut Encoder, prior: Option<Item<'_>>) -> Result<(), SchemaError>;
fn decode_item(item: Item<'_>, depth: u32) -> Result<Self, SchemaError>;
fn floor(&self, acc: &mut Floor) -> Result<(), SchemaError> {
let _ = acc;
Ok(())
}
fn unrevisioned_floor(&self) -> Option<Release> {
None
}
fn into_vm_value(self) -> Result<Value, SchemaError>;
fn to_vm_value(&self) -> Result<Value, SchemaError>
where
Self: Clone,
{
self.clone().into_vm_value()
}
fn from_vm_value(value: Value) -> Result<Self, SchemaError>;
fn write_type_name(out: &mut String);
fn write_list_type_name(out: &mut String) {
out.push_str("list<");
Self::write_type_name(out);
out.push('>');
}
fn collect_schemas(out: &mut Vec<&'static TypeSchema>) {
let _ = out;
}
fn encode_list(
items: &[Self],
enc: &mut Encoder,
prior: Option<Item<'_>>,
) -> Result<(), SchemaError> {
let prior = match prior {
Some(p) => p.list().ok().flatten(),
None => None,
};
let mut open = enc.open()?;
for (i, element) in items.iter().enumerate().rev() {
let carried = prior.and_then(|list| {
let item = list.get(i).ok()?;
(Self::decode_item(item, 0).ok()? == *element).then_some(item)
});
element.encode_item(enc, carried)?;
enc.end_item(&mut open)?;
}
enc.close_list(open)?;
Ok(())
}
fn decode_list(item: Item<'_>, depth: u32) -> Result<Vec<Self>, SchemaError> {
let list = item.list()?.ok_or(SchemaError::wrong_kind())?;
let mut out = Vec::with_capacity(list.len().min(item.bytes().len()));
for i in 0..list.len() {
out.push(Self::decode_item(list.get(i)?, depth)?);
}
Ok(out)
}
fn into_vm_list(items: Vec<Self>) -> Result<Value, SchemaError> {
vm::list_into(items)
}
fn from_vm_list(value: Value) -> Result<Vec<Self>, SchemaError> {
vm::list_from(value)
}
fn floor_of(&self) -> Result<Floor, SchemaError> {
let mut floor = Floor::first();
self.floor(&mut floor)?;
Ok(floor)
}
}
pub trait StoredType: StoredField {
const SCHEMA: TypeSchema;
}