use fourcc as object tags (bad idea); store type info within objects

4 files changed, 27 insertions, 62 deletions

diff --git a/database/src/kv/mod.rs b/database/src/kv/mod.rs
index 90b6686..f5dcc72 100644
--- a/database/src/kv/mod.rs
+++ b/database/src/kv/mod.rs
@@ -17,7 +17,7 @@ pub mod tests;
 use std::borrow::Cow;
 
 use crate::{
-    DEBUG_TAGREG, Database, Query, RowNum, Transaction,
+    Database, Query, RowNum, Transaction,
     kv::{
         helpers::{read_counter, write_counter},
         index::{iter_index, read_count_index, update_index},
@@ -27,7 +27,7 @@ use crate::{
     },
 };
 use anyhow::{Result, anyhow};
-use jellyobject::{ObjectBuffer, inspect::Inspector};
+use jellyobject::ObjectBuffer;
 use log::{debug, info};
 
 pub type SubtreeNum = u32;
@@ -47,9 +47,7 @@ impl<T: jellykv::Store> Database for T {
 
 impl Transaction for &mut dyn jellykv::Transaction {
     fn insert(&mut self, entry: ObjectBuffer) -> Result<RowNum> {
-        if let Some(tr) = DEBUG_TAGREG.get() {
-            debug!("insert {:?}", Inspector(tr, entry.as_object()))
-        }
+        debug!("insert {entry:?}");
         let mut id_counter = read_counter(*self, &T_ROW_COUNTER.to_be_bytes(), 0)?;
         let row = id_counter;
         id_counter += 1;
@@ -105,7 +103,7 @@ impl Transaction for &mut dyn jellykv::Transaction {
         &'a mut self,
         query: Query,
     ) -> Result<Box<dyn Iterator<Item = Result<(RowNum, Vec<u8>)>> + 'a>> {
-        debug!("query: {}", query.show_debug());
+        debug!("query: {}", query.show());
         let mut prefixes = Vec::new();
         for (binning, mut prefix) in query.filter.get_bins() {
             let ik = IndexKey(binning, query.sort.key());
diff --git a/database/src/lib.rs b/database/src/lib.rs
index 984502e..9b76c58 100644
--- a/database/src/lib.rs
+++ b/database/src/lib.rs
@@ -8,12 +8,8 @@ pub mod query_ser;
 #[cfg(test)]
 pub mod test_shared;
 
-use std::sync::OnceLock;
-
 use anyhow::Result;
-use jellyobject::{ObjectBuffer, Path, Registry};
-
-pub static DEBUG_TAGREG: OnceLock<Registry> = OnceLock::new();
+use jellyobject::{ObjectBuffer, Path};
 
 pub type RowNum = u64;
 pub type RowIter = Box<dyn Iterator<Item = Result<(RowNum, Vec<u8>)>>>;
diff --git a/database/src/query_ser.rs b/database/src/query_ser.rs
index 498f2ad..d76dea7 100644
--- a/database/src/query_ser.rs
+++ b/database/src/query_ser.rs
@@ -4,37 +4,30 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::{DEBUG_TAGREG, Filter, MultiBehaviour, Query, Sort, SortOrder};
-use jellyobject::{Path, Registry, Tag};
+use crate::{Filter, MultiBehaviour, Query, Sort, SortOrder};
+use jellyobject::{Path, Tag};
 
 impl Query {
-    pub fn show_debug(&self) -> String {
-        if let Some(r) = DEBUG_TAGREG.get() {
-            self.show(r)
-        } else {
-            "[debug tag registry disabled]".to_string()
-        }
-    }
-    pub fn show(&self, reg: &Registry) -> String {
+    pub fn show(&self) -> String {
         let mut o = String::new();
         if !matches!(self.filter, Filter::True) {
-            o += &format!("FILTER {} ", self.filter.show(reg))
+            o += &format!("FILTER {} ", self.filter.show())
         }
         if !matches!(self.sort, Sort::None) {
-            o += &format!("SORT {} ", self.sort.show(reg))
+            o += &format!("SORT {} ", self.sort.show())
         }
         o
     }
 }
 impl Filter {
-    pub fn show(&self, reg: &Registry) -> String {
+    pub fn show(&self) -> String {
         match self {
             Filter::True => "TRUE".to_string(),
             Filter::All(filters) => format!(
                 "({})",
                 filters
                     .iter()
-                    .map(|f| f.show(reg))
+                    .map(|f| f.show())
                     .collect::<Vec<_>>()
                     .join(" AND ")
             ),
@@ -42,23 +35,23 @@ impl Filter {
                 "({})",
                 filters
                     .iter()
-                    .map(|f| f.show(reg))
+                    .map(|f| f.show())
                     .collect::<Vec<_>>()
                     .join(" OR ")
             ),
             Filter::Match(path, value) => {
                 format!(
                     "{} = {}",
-                    show_path(reg, path),
-                    show_value(reg, *path.0.last().unwrap(), value)
+                    show_path(path),
+                    show_value(*path.0.last().unwrap(), value)
                 )
             }
-            Filter::Has(path) => show_path(reg, path),
+            Filter::Has(path) => show_path(path),
         }
     }
 }
 impl Sort {
-    pub fn show(&self, reg: &Registry) -> String {
+    pub fn show(&self) -> String {
         match self {
             Sort::None => "NONE".to_string(),
             Sort::Value(vs) => {
@@ -75,36 +68,23 @@ impl Sort {
                         MultiBehaviour::Max => "MAX",
                         MultiBehaviour::Min => "MIN",
                     },
-                    show_path(reg, &vs.path),
+                    show_path(&vs.path),
                 )
             }
             Sort::TextSearch(path, value) => {
-                format!("TEXT SEARCH {} = {value:?}", show_path(reg, path),)
+                format!("TEXT SEARCH {} = {value:?}", show_path(path),)
             }
         }
     }
 }
 
-fn show_path(reg: &Registry, path: &Path) -> String {
+fn show_path(path: &Path) -> String {
     path.0
         .iter()
-        .map(|s| reg.name(*s))
+        .map(|s| str::from_utf8(&s.0.to_be_bytes()).unwrap().to_string())
         .collect::<Vec<_>>()
         .join(".")
 }
-fn show_value(reg: &Registry, tag: Tag, value: &[u8]) -> String {
-    if let Some(info) = reg.info(tag)
-        && let Some(ty) = info.r#type
-    {
-        use jellyobject::types::*;
-        match () {
-            () if ty == STR => format!("{:?}", str::from_utf8(value).unwrap()),
-            () if ty == U32 => format!("{:?}", u32::from_be_bytes(value.try_into().unwrap())),
-            () if ty == U64 => format!("{:?}", u64::from_be_bytes(value.try_into().unwrap())),
-            () if ty == F64 => format!("{:?}", f64::from_be_bytes(value.try_into().unwrap())),
-            () => format!("{value:?}"),
-        }
-    } else {
-        format!("{value:?}")
-    }
+fn show_value(_tag: Tag, value: &[u8]) -> String {
+    format!("{value:?}") // TODO
 }
diff --git a/database/src/test_shared.rs b/database/src/test_shared.rs
index 8216113..81d2e60 100644
--- a/database/src/test_shared.rs
+++ b/database/src/test_shared.rs
@@ -4,21 +4,12 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use jellyobject::{ObjectBuffer, Registry, fields};
-use std::sync::LazyLock;
+use jellyobject::{ObjectBuffer, fields};
 
-use crate::DEBUG_TAGREG;
-
-pub static TAGREG: LazyLock<Registry> = LazyLock::new(|| {
-    let mut reg = Registry::default();
-    register_fields(&mut reg);
-    DEBUG_TAGREG.set(reg.clone()).ok().unwrap();
-    reg
-});
 fields! {
-    NAME: &str = 15 "name";
-    AGE: u32 = 13 "age";
-    FRIEND: &str = 54321 "friend";
+    NAME: &str = b"name";
+    AGE: u32 = b"age1";
+    FRIEND: &str = b"frnd";
 }
 
 pub(crate) fn new_bob() -> ObjectBuffer {