gvsafronov
/
skytable
1
0
Fork 0
Code Pull Requests Activity

Simplify wrapper based access

Browse Source
next
Sayan Nandan 2 years ago
parent f98478b274
commit 798871bdd6
No known key found for this signature in database
GPG Key ID: 42EEDF4AE9D96B54
10 changed files with 109 additions and 95 deletions
Show Stats Download Patch File Download Diff File

2
server/src/engine/ql/ast/mod.rs
Unescape Escape View File

@ -516,7 +516,7 @@ impl<'a> Entity<'a> {
}
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Debug, PartialEq)]
/// A [`Statement`] is a fully BlueQL statement that can be executed by the query engine
// TODO(@ohsayan): Determine whether we actually need this
pub enum Statement<'a> {

3
server/src/engine/ql/ddl/alt.rs
Unescape Escape View File

@ -78,8 +78,7 @@ impl<'a> AlterSpace<'a> {
}
}
#[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))]
#[derive(Debug, PartialEq)]
pub struct AlterModel<'a> {
model: Slice<'a>,
kind: AlterKind<'a>,

3
server/src/engine/ql/ddl/drop.rs
Unescape Escape View File

@ -116,7 +116,8 @@ mod impls {
Self::parse(state)
}
}
pub struct DropStatementAST<'a>(pub Statement<'a>);
#[derive(sky_macros::Wrapper, Debug)]
pub struct DropStatementAST<'a>(Statement<'a>);
impl<'a> ASTNode<'a> for DropStatementAST<'a> {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
super::parse_drop(state).map(Self)

3
server/src/engine/ql/ddl/ins.rs
Unescape Escape View File

@ -69,7 +69,8 @@ pub fn parse_inspect<'a, Qd: QueryData<'a>>(
pub use impls::InspectStatementAST;
mod impls {
use crate::engine::ql::ast::{traits::ASTNode, QueryData, State, Statement};
pub struct InspectStatementAST<'a>(pub Statement<'a>);
#[derive(sky_macros::Wrapper, Debug)]
pub struct InspectStatementAST<'a>(Statement<'a>);
impl<'a> ASTNode<'a> for InspectStatementAST<'a> {
fn from_state<Qd: QueryData<'a>>(
state: &mut State<'a, Qd>,

43
server/src/engine/ql/ddl/syn.rs
Unescape Escape View File

@ -507,7 +507,6 @@ mod impls {
ast::{traits::ASTNode, QueryData, State},
LangError, LangResult,
};
use std::ops::{Deref, DerefMut};
impl<'a> ASTNode<'a> for ExpandedField<'a> {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
Self::parse(state)
@ -537,7 +536,8 @@ mod impls {
}
}
}
pub struct DictBasic(pub Dict);
#[derive(sky_macros::Wrapper, Debug)]
pub struct DictBasic(Dict);
impl<'a> ASTNode<'a> for DictBasic {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
let mut dict = Dict::new();
@ -549,18 +549,8 @@ mod impls {
}
}
}
impl Deref for DictBasic {
type Target = Dict;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for DictBasic {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
pub struct DictTypeMetaSplit(pub Dict);
#[derive(sky_macros::Wrapper, Debug)]
pub struct DictTypeMetaSplit(Dict);
impl<'a> ASTNode<'a> for DictTypeMetaSplit {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
let mut dict = Dict::new();
@ -572,18 +562,8 @@ mod impls {
}
}
}
impl Deref for DictTypeMetaSplit {
type Target = Dict;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for DictTypeMetaSplit {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
pub struct DictTypeMeta(pub Dict);
#[derive(sky_macros::Wrapper, Debug)]
pub struct DictTypeMeta(Dict);
impl<'a> ASTNode<'a> for DictTypeMeta {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
let mut dict = Dict::new();
@ -595,17 +575,6 @@ mod impls {
}
}
}
impl Deref for DictTypeMeta {
type Target = Dict;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for DictTypeMeta {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<'a> ASTNode<'a> for Field<'a> {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
Self::parse(state)

9
server/src/engine/ql/dml/ins.rs
Unescape Escape View File

@ -208,7 +208,8 @@ unsafe fn handle_func_sub<'a, Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> O
}
#[cfg(test)]
pub struct List(pub Vec<DataType>);
#[derive(sky_macros::Wrapper, Debug)]
pub struct List(Vec<DataType>);
#[cfg(test)]
impl<'a> ASTNode<'a> for List {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
@ -270,7 +271,8 @@ pub(super) fn parse_data_tuple_syntax<'a, Qd: QueryData<'a>>(
}
#[cfg(test)]
pub struct DataTuple(pub Vec<Option<DataType>>);
#[derive(sky_macros::Wrapper, Debug)]
pub struct DataTuple(Vec<Option<DataType>>);
#[cfg(test)]
impl<'a> ASTNode<'a> for DataTuple {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {
@ -340,7 +342,8 @@ pub(super) fn parse_data_map_syntax<'a, Qd: QueryData<'a>>(
}
#[cfg(test)]
pub struct DataMap(pub HashMap<Box<str>, Option<DataType>>);
#[derive(sky_macros::Wrapper, Debug)]
pub struct DataMap(HashMap<Box<str>, Option<DataType>>);
#[cfg(test)]
impl<'a> ASTNode<'a> for DataMap {
fn from_state<Qd: QueryData<'a>>(state: &mut State<'a, Qd>) -> LangResult<Self> {

36
server/src/engine/ql/tests/dml_tests.rs
Unescape Escape View File

@ -41,7 +41,7 @@ mod list_parse {
",
)
.unwrap();
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap();
assert_eq!(r, vec![])
}
#[test]
@ -52,7 +52,7 @@ mod list_parse {
",
)
.unwrap();
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap();
assert_eq!(r.as_slice(), into_array![1, 2, 3, 4])
}
#[test]
@ -71,7 +71,9 @@ mod list_parse {
];
let mut state = State::new(&tok[1..], SubstitutedData::new(&data));
assert_eq!(
<List as ASTNode>::from_state(&mut state).unwrap().0,
<List as ASTNode>::from_state(&mut state)
.unwrap()
.into_inner(),
into_array![1, 2, 3, 4]
)
}
@ -88,7 +90,7 @@ mod list_parse {
",
)
.unwrap();
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap();
assert_eq!(
r.as_slice(),
into_array![
@ -122,7 +124,9 @@ mod list_parse {
];
let mut state = State::new(&tok[1..], SubstitutedData::new(&data));
assert_eq!(
<List as ASTNode>::from_state(&mut state).unwrap().0,
<List as ASTNode>::from_state(&mut state)
.unwrap()
.into_inner(),
into_array![
into_array![1, 2],
into_array![3, 4],
@ -144,7 +148,7 @@ mod list_parse {
",
)
.unwrap();
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<List>(&tok[1..]).unwrap();
assert_eq!(
r.as_slice(),
into_array![
@ -184,7 +188,9 @@ mod list_parse {
];
let mut state = State::new(&tok[1..], SubstitutedData::new(&data));
assert_eq!(
<List as ASTNode>::from_state(&mut state).unwrap().0,
<List as ASTNode>::from_state(&mut state)
.unwrap()
.into_inner(),
into_array![
into_array![into_array![1, 1], into_array![2, 2]],
into_array![into_array![], into_array![4, 4]],
@ -202,7 +208,7 @@ mod tuple_syntax {
#[test]
fn tuple_mini() {
let tok = lex_insecure(b"()").unwrap();
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap();
assert_eq!(r, vec![]);
}
@ -214,7 +220,7 @@ mod tuple_syntax {
"#,
)
.unwrap();
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap();
assert_eq!(
r.as_slice(),
into_array_nullable![1234, "email@example.com", true]
@ -234,7 +240,7 @@ mod tuple_syntax {
"#,
)
.unwrap();
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap();
assert_eq!(
r.as_slice(),
into_array_nullable![
@ -266,7 +272,7 @@ mod tuple_syntax {
"#,
)
.unwrap();
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataTuple>(&tok[1..]).unwrap();
assert_eq!(
r.as_slice(),
into_array_nullable![
@ -292,7 +298,7 @@ mod map_syntax {
#[test]
fn map_mini() {
let tok = lex_insecure(b"{}").unwrap();
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap();
assert_eq!(r, null_dict! {})
}
@ -309,7 +315,7 @@ mod map_syntax {
"#,
)
.unwrap();
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap();
assert_eq!(
r,
dict_nullable! {
@ -335,7 +341,7 @@ mod map_syntax {
"#,
)
.unwrap();
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap();
assert_eq!(
r,
dict_nullable! {
@ -364,7 +370,7 @@ mod map_syntax {
}
"#)
.unwrap();
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap().0;
let r = parse_ast_node_full::<DataMap>(&tok[1..]).unwrap();
assert_eq!(
r,
dict_nullable! {

48
server/src/engine/ql/tests/schema_tests.rs
Unescape Escape View File

@ -40,9 +40,7 @@ mod inspect {
fn inspect_space() {
let tok = lex_insecure(b"inspect space myspace").unwrap();
assert_eq!(
parse_ast_node_full::<InspectStatementAST>(&tok[1..])
.unwrap()
.0,
parse_ast_node_full::<InspectStatementAST>(&tok[1..]).unwrap(),
Statement::InspectSpace(b"myspace")
);
}
@ -50,16 +48,12 @@ mod inspect {
fn inspect_model() {
let tok = lex_insecure(b"inspect model users").unwrap();
assert_eq!(
parse_ast_node_full::<InspectStatementAST>(&tok[1..])
.unwrap()
.0,
parse_ast_node_full::<InspectStatementAST>(&tok[1..]).unwrap(),
Statement::InspectModel(Entity::Single(b"users"))
);
let tok = lex_insecure(b"inspect model tweeter.users").unwrap();
assert_eq!(
parse_ast_node_full::<InspectStatementAST>(&tok[1..])
.unwrap()
.0,
parse_ast_node_full::<InspectStatementAST>(&tok[1..]).unwrap(),
Statement::InspectModel(Entity::Full(b"tweeter", b"users"))
);
}
@ -67,9 +61,7 @@ mod inspect {
fn inspect_spaces() {
let tok = lex_insecure(b"inspect spaces").unwrap();
assert_eq!(
parse_ast_node_full::<InspectStatementAST>(&tok[1..])
.unwrap()
.0,
parse_ast_node_full::<InspectStatementAST>(&tok[1..]).unwrap(),
Statement::InspectSpaces
);
}
@ -120,7 +112,7 @@ mod tymeta {
fn tymeta_mini() {
let tok = lex_insecure(b"{}").unwrap();
let tymeta = parse_ast_node_full::<DictTypeMeta>(&tok).unwrap();
assert_eq!(tymeta.0, null_dict!());
assert_eq!(tymeta, null_dict!());
}
#[test]
#[should_panic]
@ -133,7 +125,7 @@ mod tymeta {
let tok = lex_insecure(br#"{hello: "world", loading: true, size: 100 }"#).unwrap();
let tymeta = parse_ast_node_full::<DictTypeMeta>(&tok).unwrap();
assert_eq!(
tymeta.0,
tymeta,
null_dict! {
"hello" => Lit::Str("world".into()),
"loading" => Lit::Bool(true),
@ -154,10 +146,10 @@ mod tymeta {
assert!(Token![,].eq(state.fw_read()));
let tymeta2: DictTypeMetaSplit = ASTNode::from_state(&mut state).unwrap();
assert!(state.exhausted());
let mut final_ret = tymeta;
final_ret.0.extend(tymeta2.0);
let mut final_ret = tymeta.into_inner();
final_ret.extend(tymeta2.into_inner());
assert_eq!(
final_ret.0,
final_ret,
null_dict! {
"maxlen" => Lit::UnsignedInt(100),
"unique" => Lit::Bool(true)
@ -179,10 +171,10 @@ mod tymeta {
assert!(Token![,].eq(state.fw_read()));
let tymeta2: DictTypeMetaSplit = ASTNode::from_state(&mut state).unwrap();
assert!(state.exhausted());
let mut final_ret = tymeta;
final_ret.0.extend(tymeta2.0);
let mut final_ret = tymeta.into_inner();
final_ret.extend(tymeta2.into_inner());
assert_eq!(
final_ret.0,
final_ret,
null_dict! {
"maxlen" => Lit::UnsignedInt(100),
"unique" => Lit::Bool(true),
@ -1151,9 +1143,7 @@ mod ddl_other_query_tests {
fn drop_space() {
let src = lex_insecure(br"drop space myspace").unwrap();
assert_eq!(
parse_ast_node_full::<DropStatementAST>(&src[1..])
.unwrap()
.0,
parse_ast_node_full::<DropStatementAST>(&src[1..]).unwrap(),
Statement::DropSpace(DropSpace::new(b"myspace", false))
);
}
@ -1161,9 +1151,7 @@ mod ddl_other_query_tests {
fn drop_space_force() {
let src = lex_insecure(br"drop space myspace force").unwrap();
assert_eq!(
parse_ast_node_full::<DropStatementAST>(&src[1..])
.unwrap()
.0,
parse_ast_node_full::<DropStatementAST>(&src[1..]).unwrap(),
Statement::DropSpace(DropSpace::new(b"myspace", true))
);
}
@ -1171,9 +1159,7 @@ mod ddl_other_query_tests {
fn drop_model() {
let src = lex_insecure(br"drop model mymodel").unwrap();
assert_eq!(
parse_ast_node_full::<DropStatementAST>(&src[1..])
.unwrap()
.0,
parse_ast_node_full::<DropStatementAST>(&src[1..]).unwrap(),
Statement::DropModel(DropModel::new(Entity::Single(b"mymodel"), false))
);
}
@ -1181,9 +1167,7 @@ mod ddl_other_query_tests {
fn drop_model_force() {
let src = lex_insecure(br"drop model mymodel force").unwrap();
assert_eq!(
parse_ast_node_full::<DropStatementAST>(&src[1..])
.unwrap()
.0,
parse_ast_node_full::<DropStatementAST>(&src[1..]).unwrap(),
Statement::DropModel(DropModel::new(Entity::Single(b"mymodel"), true))
);
}

6
server/src/engine/ql/tests/structure_syn.rs
Unescape Escape View File

@ -43,7 +43,9 @@ macro_rules! fold_dict {
fn fold_dict(raw: &[u8]) -> Option<Dict> {
let lexed = lex_insecure(raw).unwrap();
parse_ast_node_full::<DictBasic>(&lexed).map(|v| v.0).ok()
parse_ast_node_full::<DictBasic>(&lexed)
.map(|v| v.into_inner())
.ok()
}
mod dict {
@ -222,7 +224,7 @@ mod dict {
let r = parse_ast_node_full::<DictBasic>(new_src);
let okay = r.is_ok();
if should_pass {
assert_eq!(r.unwrap().0, ret_dict)
assert_eq!(r.unwrap(), ret_dict)
}
okay
});

51
sky-macros/src/lib.rs
Unescape Escape View File

@ -43,7 +43,12 @@
//! - `__MYENTITY__` - `String` with entity
//!
use {proc_macro::TokenStream, quote::quote, syn::Lit};
use {
proc_macro::TokenStream,
proc_macro2::TokenStream as TokenStream2,
quote::quote,
syn::{Data, DataStruct, DeriveInput, Fields, Lit},
};
mod dbtest_fn;
mod dbtest_mod;
@ -177,3 +182,47 @@ pub fn compiled_eresp_bytes_v1(tokens: TokenStream) -> TokenStream {
}
.into()
}
#[proc_macro_derive(Wrapper)]
/// Implements necessary traits for some type `T` to make it identify as a different type but mimic the functionality
/// as the inner type it wraps around
pub fn derive_wrapper(t: TokenStream) -> TokenStream {
let item = syn::parse_macro_input!(t as DeriveInput);
let r = wrapper(item);
r.into()
}
fn wrapper(item: DeriveInput) -> TokenStream2 {
let st_name = &item.ident;
let fields = match item.data {
Data::Struct(DataStruct {
fields: Fields::Unnamed(ref f),
..
}) if f.unnamed.len() == 1 => f,
_ => panic!("only works on tuple structs with one field"),
};
let field = &fields.unnamed[0];
let ty = &field.ty;
let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_generics #st_name #ty_generics #where_clause { pub fn into_inner(self) -> #ty { self.0 } }
#[automatically_derived]
impl #impl_generics ::core::ops::Deref for #st_name #ty_generics #where_clause {
type Target = #ty;
fn deref(&self) -> &Self::Target { &self.0 }
}
#[automatically_derived]
impl #impl_generics ::core::ops::DerefMut for #st_name #ty_generics #where_clause {
fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
}
#[automatically_derived]
impl #impl_generics ::core::cmp::PartialEq<#ty> for #st_name #ty_generics #where_clause {
fn eq(&self, other: &#ty) -> bool { ::core::cmp::PartialEq::eq(&self.0, other) }
}
#[automatically_derived]
impl #impl_generics ::core::cmp::PartialEq<#st_name #ty_generics> for #ty #where_clause {
fn eq(&self, other: &#st_name #ty_generics) -> bool { ::core::cmp::PartialEq::eq(self, &other.0) }
}
}
}

Write Preview
Loading…
Cancel
Save