Enable inspecting current keyspace

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All changes in this project will be noted in this file.
 
+## Unreleased
+
+### Additions
+
+- `INSPECT KEYSPACE` without arguments to inspect the current keyspace
+
+### Fixes
+
+- Added error code output for new error codes which otherwise printed "Unknown error"
+
 ## Version 0.7.4
 
 ### Additions

server/src/corestore/mod.rs

@@ -165,6 +165,13 @@ impl Corestore {
         }
         Ok(())
     }
+    /// Returns the current keyspace, if set
+    pub fn get_cks(&self) -> KeyspaceResult<&Keyspace> {
+        match self.estate.ks {
+            Some((_, ref cks)) => Ok(cks),
+            _ => Err(DdlError::DefaultNotFound),
+        }
+    }
     pub fn get_keyspace<Q>(&self, ksid: &Q) -> Option<Arc<Keyspace>>
     where
         ObjectID: Borrow<Q>,

server/src/queryengine/inspect.rs

@@ -69,9 +69,11 @@ action! {
 
     /// INSPECT a keyspace. This should only have the keyspace ID
     fn inspect_keyspace(handle: &Corestore, con: &'a mut T, mut act: ActionIter<'a>) {
-        ensure_length(act.len(), |len| len == 1)?;
+        ensure_length(act.len(), |len| len < 2)?;
+        let tbl_list: Vec<ObjectID>;
         match act.next() {
             Some(keyspace_name) => {
+                // inspect the provided keyspace
                 let ksid = if keyspace_name.len() > 64 {
                     return conwrite!(con, responses::groups::BAD_CONTAINER_NAME);
                 } else {
@@ -81,15 +83,19 @@ action! {
                     Some(kspace) => kspace,
                     None => return conwrite!(con, responses::groups::CONTAINER_NOT_FOUND),
                 };
-                let tbl_list: Vec<ObjectID> = ks.tables.iter().map(|kv| kv.key().clone()).collect();
-                let mut writer = unsafe {
-                    TypedArrayWriter::new(con, b'+', tbl_list.len())
-                }.await?;
-                for tbl in tbl_list {
-                    writer.write_element(tbl).await?;
-                }
+                tbl_list = ks.tables.iter().map(|kv| kv.key().clone()).collect();
             },
-            None => aerr!(con),
+            None => {
+                // inspect the current keyspace
+                let cks = handle.get_cks()?;
+                tbl_list = cks.tables.iter().map(|kv| kv.key().clone()).collect();
+            },
+        }
+        let mut writer = unsafe {
+            TypedArrayWriter::new(con, b'+', tbl_list.len())
+        }.await?;
+        for tbl in tbl_list {
+            writer.write_element(tbl).await?;
         }
         Ok(())
     }

server/src/tests/ddl_tests.rs

@@ -85,12 +85,11 @@ mod __private {
         );
     }
     async fn test_create_table_fully_qualified_entity() {
-        let mykeyspace: &str = __MYENTITY__.split(':').collect::<Vec<&str>>()[0];
         let mut rng = rand::thread_rng();
         let tblname = utils::rand_alphastring(10, &mut rng);
         query.push("create");
         query.push("table");
-        query.push(mykeyspace.to_owned() + ":" + &tblname);
+        query.push(__MYKS__.to_owned() + ":" + &tblname);
         query.push("keymap(str,str)");
         assert_eq!(
             con.run_query_raw(&query).await.unwrap(),
@@ -98,12 +97,11 @@ mod __private {
         );
     }
     async fn test_create_table_volatile_fully_qualified_entity() {
-        let mykeyspace: &str = __MYENTITY__.split(':').collect::<Vec<&str>>()[0];
         let mut rng = rand::thread_rng();
         let tblname = utils::rand_alphastring(10, &mut rng);
         query.push("create");
         query.push("table");
-        query.push(mykeyspace.to_owned() + ":" + &tblname);
+        query.push(__MYKS__.to_owned() + ":" + &tblname);
         query.push("keymap(str,str)");
         query.push("volatile");
         assert_eq!(
@@ -132,10 +130,9 @@ mod __private {
         );
     }
     async fn test_drop_table_fully_qualified_entity() {
-        let mykeyspace: &str = __MYENTITY__.split(':').collect::<Vec<&str>>()[0];
         let mut rng = rand::thread_rng();
         let tblname = utils::rand_alphastring(10, &mut rng);
-        let my_fqe = mykeyspace.to_owned() + ":" + &tblname;
+        let my_fqe = __MYKS__.to_owned() + ":" + &tblname;
         query.push("create");
         query.push("table");
         query.push(&my_fqe);
@@ -171,14 +168,10 @@ mod __private {
         )
     }
     async fn test_whereami() {
-        let mykeyspace: Vec<&str> = __MYENTITY__.split(':').collect::<Vec<&str>>();
         query.push("whereami");
         assert_eq!(
             con.run_query_raw(&query).await.unwrap(),
-            Element::Array(Array::NonNullStr(vec![
-                mykeyspace[0].to_owned(),
-                mykeyspace[1].to_owned()
-            ]))
+            Element::Array(Array::NonNullStr(vec![__MYKS__, __MYTABLE__]))
         );
         runeq!(
             con,

server/src/tests/inspect_tests.rs

@@ -36,20 +36,24 @@ mod __private {
         ))
     }
     async fn test_inspect_keyspace() {
-        let my_keyspace: &str = __MYENTITY__.split(':').collect::<Vec<&str>>()[0];
         query.push("INSPECT");
         query.push("KEYSPACE");
-        query.push(my_keyspace);
+        query.push(&__MYKS__);
         assert!(matches!(
             con.run_query_raw(&query).await.unwrap(),
             Element::Array(Array::Str(_))
         ))
     }
+    async fn test_inspect_current_keyspace() {
+        query.push("INSPECT");
+        query.push("KEYSPACE");
+        let ret: Vec<String> = con.run_query(&query).await.unwrap();
+        assert!(ret.contains(&__MYTABLE__));
+    }
     async fn test_inspect_table() {
-        let my_table: &str = __MYENTITY__.split(':').collect::<Vec<&str>>()[1];
         query.push("INSPECT");
         query.push("TABLE");
-        query.push(my_table);
+        query.push(__MYTABLE__);
         match con.run_query_raw(&query).await.unwrap() {
             Element::String(st) => {
                 assert_eq!(st, "Keymap { data:(str,str), volatile:true }".to_owned())

sky-macros/src/dbtest_fn.rs

@@ -282,6 +282,8 @@ fn generate_dbtest(
             let mut __concat_entity = std::string::String::new();
             __concat_entity.push_str("testsuite:");
             __concat_entity.push_str(&#rand_string);
+            let __MYTABLE__ : String = #rand_string.to_string();
+            let __MYKS__: String = "testsuite".to_owned();
             let __MYENTITY__: String = __concat_entity.clone();
         };
         // now switch to the temporary table we created