no ns for keyword

src/data/attr.rs

@@ -168,7 +168,7 @@ impl AttributeTyping {
             }
             AttributeTyping::Keyword => match val {
                 val @ Value::Keyword(_) => Ok(val),
-                Value::String(s) => Ok(Value::Keyword(Keyword::try_from(s.as_ref())?)),
+                Value::String(s) => Ok(Value::Keyword(Keyword::from(s.as_ref()))),
                 val => Err(self.type_err(val).into()),
             },
             AttributeTyping::Uuid => {
@@ -324,7 +324,7 @@ mod tests {
     fn show_sizes() {
         let attr = Attribute {
             id: AttrId(0),
-            keyword: Keyword::try_from("01234567890123456789012/01234567890123456789012").unwrap(),
+            keyword: Keyword::from("01234567890123456789012/01234567890123456789012"),
             cardinality: AttributeCardinality::One,
             val_type: AttributeTyping::Ref,
             indexing: AttributeIndex::None,

src/data/encode.rs

@@ -445,9 +445,7 @@ pub(crate) fn decode_sentinel_attr_by_id(src: &[u8]) -> Result<AttrId> {
 pub(crate) fn encode_sentinel_attr_by_kw(kw: &Keyword) -> EncodedVec<LARGE_VEC_SIZE> {
     let mut ret = SmallVec::<[u8; LARGE_VEC_SIZE]>::new();
     ret.push(StorageTag::SentinelAttrByKeyword as u8);
-    ret.extend_from_slice(kw.ns.as_bytes());
-    ret.push(b'/');
-    ret.extend_from_slice(kw.ident.as_bytes());
+    ret.extend_from_slice(kw.0.as_bytes());
     ret.into()
 }
 

src/data/json.rs

@@ -63,7 +63,7 @@ impl TryFrom<&'_ JsonValue> for Keyword {
         let s = value
             .as_str()
             .ok_or_else(|| JsonError::Conversion(value.clone(), "Keyword".to_string()))?;
-        Ok(Keyword::try_from(s)?)
+        Ok(Keyword::from(s))
     }
 }
 

src/data/keyword.rs

@@ -19,20 +19,11 @@ pub enum KeywordError {
 }
 
 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Deserialize, Serialize)]
-pub struct Keyword {
-    #[serde(rename = "n")]
-    pub(crate) ns: SmartString<LazyCompact>,
-    #[serde(rename = "i")]
-    pub(crate) ident: SmartString<LazyCompact>,
-}
+pub struct Keyword(pub(crate) SmartString<LazyCompact>);
 
 impl Display for Keyword {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if self.ns.is_empty() {
-            write!(f, ":{}", self.ident)
-        } else {
-            write!(f, ":{}/{}", self.ns, self.ident)
-        }
+        write!(f, ":{}", self.0)
     }
 }
 
@@ -42,49 +33,25 @@ impl Debug for Keyword {
     }
 }
 
-impl TryFrom<&str> for Keyword {
-    type Error = KeywordError;
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let make_err = || KeywordError::InvalidKeyword(value.to_string());
+impl From<&str> for Keyword {
+    fn from(value: &str) -> Self {
         let value = value.strip_prefix(':').unwrap_or(value);
-        let mut kw_iter = value.split('/');
-        let ns = kw_iter.next().ok_or_else(make_err)?;
-        let ident = match kw_iter.next() {
-            None => {
-                return Ok(Keyword {
-                    ns: "".into(),
-                    ident: ns.into(),
-                })
-            }
-            Some(ident) => ident,
-        };
-        if kw_iter.next().is_none() {
-            Ok(Keyword {
-                ns: ns.into(),
-                ident: ident.into(),
-            })
-        } else {
-            Err(make_err())
-        }
+        Self(value.into())
     }
 }
 
 impl TryFrom<&[u8]> for Keyword {
     type Error = KeywordError;
     fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
-        std::str::from_utf8(value)?.try_into()
+        Ok(std::str::from_utf8(value)?.into())
     }
 }
 
 impl Keyword {
     pub(crate) fn is_reserved(&self) -> bool {
-        self.ns.is_empty() && self.ident.starts_with('_')
+        self.0.starts_with('_')
     }
     pub(crate) fn to_string_no_prefix(&self) -> String {
-        if self.ns.is_empty() {
-            format!("{}", self.ident)
-        } else {
-            format!("{}/{}", self.ns, self.ident)
-        }
+        format!("{}", self.0)
     }
 }

src/data/tx_triple.rs

@@ -447,7 +447,7 @@ impl SessionTx {
         let mut has_identity_attr = false;
         for (k, v) in item {
             if k != PERM_ID_FIELD && k != TEMP_ID_FIELD {
-                let kw = (k as &str).try_into()?;
+                let kw = (k as &str).into();
                 let attr = self
                     .attr_by_kw(&kw)?
                     .ok_or_else(|| TxError::AttrNotFound(kw.clone()))?;

src/runtime/db.rs

@@ -218,7 +218,7 @@ impl Db {
             current.encoded_entity_amend_validity_to_inf_past();
             it.seek(&current);
         }
-        let collected = collected.into_iter().map(|(k, v)| v).collect_vec();
+        let collected = collected.into_iter().map(|(_, v)| v).collect_vec();
         Ok(json!(collected))
     }
 }