Fix length checks

Also improve panic messages in `dbtest` tests.

server/src/actions/get.rs

@@ -34,7 +34,7 @@ use crate::util::compiler;
 action!(
     /// Run a `GET` query
     fn get(handle: &crate::corestore::Corestore, con: &mut T, mut act: ActionIter<'a>) {
-        ensure_length(act.len(), |len| len == 0)?;
+        ensure_length(act.len(), |len| len == 1)?;
         let kve = handle.get_table_with::<KVE>()?;
         unsafe {
             match kve.get_cloned_with_tsymbol(act.next_unchecked()) {

server/src/actions/lists/lget.rs

@@ -67,7 +67,7 @@ action! {
     /// - `LGET <mylist> LAST` will return the last item
     /// if it exists
     fn lget(handle: &Corestore, con: &mut T, mut act: ActionIter<'a>) {
-        ensure_length(act.len(), |len| len > 1)?;
+        ensure_length(act.len(), |len| len != 0)?;
         let listmap = handle.get_table_with::<KVEList>()?;
         // get the list name
         let listname = unsafe { act.next_unchecked() };

server/src/actions/lists/lmod.rs

@@ -46,7 +46,7 @@ action! {
     /// - `LMOD <mylist> remove <index>`
     /// - `LMOD <mylist> clear`
     fn lmod(handle: &Corestore, con: &mut T, mut act: ActionIter<'a>) {
-        ensure_length(act.len(), |len| len > 2)?;
+        ensure_length(act.len(), |len| len > 1)?;
         let listmap = handle.get_table_with::<KVEList>()?;
         // get the list name
         let listname = unsafe { act.next_unchecked() };

server/src/actions/lists/mod.rs

@@ -46,7 +46,7 @@ action! {
     /// Handle an `LSET` query for the list model
     /// Syntax: `LSET <listname> <values ...>`
     fn lset(handle: &Corestore, con: &mut T, mut act: ActionIter<'a>) {
-        ensure_length(act.len(), |len| len > 1)?;
+        ensure_length(act.len(), |len| len > 0)?;
         let listmap = handle.get_table_with::<KVEList>()?;
         let listname = unsafe { act.next_unchecked_bytes() };
         let list = listmap.kve_inner_ref();

server/src/corestore/mod.rs

@@ -41,6 +41,7 @@ use crate::storage::sengine::SnapshotEngine;
 use crate::util::Unwrappable;
 use crate::IoResult;
 use core::borrow::Borrow;
+use core::fmt;
 use core::hash::Hash;
 pub use htable::Data;
 use std::sync::Arc;
@@ -67,13 +68,29 @@ pub type OwnedEntityGroup = OptionTuple<ObjectID>;
 /// A raw borrowed entity (not the struct, but in a tuple form)
 type BorrowedEntityGroupRaw<'a> = OptionTuple<&'a [u8]>;
 
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq)]
 /// An entity group borrowed from a byte slice
 pub struct BorrowedEntityGroup<'a> {
     va: Option<&'a [u8]>,
     vb: Option<&'a [u8]>,
 }
 
+impl<'a> fmt::Debug for BorrowedEntityGroup<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn write_if_some(v: Option<&'_ [u8]>) -> String {
+            if let Some(v) = v {
+                format!("{:?}", String::from_utf8_lossy(&v))
+            } else {
+                "None".to_owned()
+            }
+        }
+        f.debug_struct("BorrowedEntityGroup")
+            .field("va", &write_if_some(self.va))
+            .field("vb", &write_if_some(self.vb))
+            .finish()
+    }
+}
+
 impl<'a> BorrowedEntityGroup<'a> {
     pub unsafe fn into_owned(self) -> OwnedEntityGroup {
         match self {

server/src/corestore/table.rs

@@ -48,7 +48,7 @@ pub trait DescribeTable {
                     None => util::err(groups::WRONG_MODEL),
                 }
             }
-            _ => util::err(groups::DEFAULT_UNSET),
+            None => util::err(groups::DEFAULT_UNSET),
         }
     }
 }

server/src/queryengine/ddl.rs

@@ -43,7 +43,7 @@ action! {
     /// like queries
     fn create(handle: &Corestore, con: &'a mut T, mut act: ActionIter<'a>) {
         // minlength is 2 (create has already been checked)
-        ensure_length(act.len(), |size| size > 2)?;
+        ensure_length(act.len(), |size| size > 1)?;
         let mut create_what = unsafe { act.next().unsafe_unwrap() }.to_vec();
         create_what.make_ascii_uppercase();
         match create_what.as_ref() {
@@ -61,7 +61,7 @@ action! {
     /// like queries
     fn ddl_drop(handle: &Corestore, con: &'a mut T, mut act: ActionIter<'a>) {
         // minlength is 2 (create has already been checked)
-        ensure_length(act.len(), |size| size > 2)?;
+        ensure_length(act.len(), |size| size > 1)?;
         let mut create_what = unsafe { act.next().unsafe_unwrap() }.to_vec();
         create_what.make_ascii_uppercase();
         match create_what.as_ref() {
@@ -75,9 +75,9 @@ action! {
         Ok(())
     }
 
-    /// We should have `<tableid> <model>(args)`
+    /// We should have `<tableid> <model>(args) properties`
     fn create_table(handle: &Corestore, con: &'a mut T, mut act: ActionIter<'a>) {
-        ensure_length(act.len(), |size| size > 2 && size < 3)?;
+        ensure_length(act.len(), |size| size > 1 && size < 4)?;
         let (table_entity, model_code) = parser::parse_table_args(&mut act)?;
         let is_volatile = match act.next() {
             Some(maybe_volatile) => {

server/src/queryengine/mod.rs

@@ -71,23 +71,20 @@ macro_rules! gen_constants_and_matches {
 
 macro_rules! swap_entity {
     ($con:expr, $handle:expr, $entity:expr) => {
-        match parser::get_query_entity(&$entity) {
-            Ok(e) => match $handle.swap_entity(e) {
-                Ok(()) => $con.write_response(responses::groups::OKAY).await?,
-                Err(DdlError::ObjectNotFound) => {
-                    $con.write_response(responses::groups::CONTAINER_NOT_FOUND)
-                        .await?
-                }
-                Err(DdlError::DefaultNotFound) => {
-                    $con.write_response(responses::groups::DEFAULT_UNSET)
-                        .await?
-                }
-                Err(_) => unsafe {
-                    // we know Corestore::swap_entity doesn't return anything else
-                    impossible!()
-                },
+        match $handle.swap_entity(parser::get_query_entity(&$entity)?) {
+            Ok(()) => $con.write_response(responses::groups::OKAY).await?,
+            Err(DdlError::ObjectNotFound) => {
+                $con.write_response(responses::groups::CONTAINER_NOT_FOUND)
+                    .await?
+            }
+            Err(DdlError::DefaultNotFound) => {
+                $con.write_response(responses::groups::DEFAULT_UNSET)
+                    .await?
+            }
+            Err(_) => unsafe {
+                // we know Corestore::swap_entity doesn't return anything else
+                impossible!()
             },
-            Err(e) => $con.write_response(e).await?,
         }
     };
 }

sky-macros/src/lib.rs

@@ -84,10 +84,23 @@ fn parse_dbtest(
             con.run_simple_query(
                 &skytable::query!("create", "keyspace", "testsuite")
             ).await.unwrap();
+        if !(
+            __create_ks == skytable::Element::RespCode(skytable::RespCode::Okay) ||
+            __create_ks == skytable::Element::RespCode(
+                skytable::RespCode::ErrorString(
+                    skytable::error::errorstring::ERR_ALREADY_EXISTS.to_owned()
+                )
+            )
+        ) {
+            panic!("Failed to create keyspace: {:?}", __create_ks);
+        }
         let __switch_ks =
             con.run_simple_query(
                 &skytable::query!("use", "testsuite")
             ).await.unwrap();
+        if (__switch_ks != skytable::Element::RespCode(skytable::RespCode::Okay)) {
+            panic!("Failed to switch keyspace: {:?}", __switch_ks);
+        }
         let __create_tbl =
             con.run_simple_query(
                 &skytable::query!(
@@ -98,6 +111,9 @@ fn parse_dbtest(
                     "volatile"
                 )
             ).await.unwrap();
+        assert_eq!(
+            __create_tbl, skytable::Element::RespCode(skytable::RespCode::Okay), "Failed to create table"
+        );
         let mut __concat_entity = std::string::String::new();
         __concat_entity.push_str("testsuite:");
         __concat_entity.push_str(&#rand_string);
@@ -106,6 +122,9 @@ fn parse_dbtest(
             con.run_simple_query(
                 &skytable::query!("use", __concat_entity)
             ).await.unwrap();
+        assert_eq!(
+            __switch_entity, skytable::Element::RespCode(skytable::RespCode::Okay), "Failed to switch"
+        );
         let mut query = skytable::Query::new();
         #body
         {