version check on startup

cozo-core/src/runtime/db.rs

@@ -588,9 +588,9 @@ impl<'s, S: Storage<'s>> Db<S> {
     }
 
     fn load_last_ids(&'s self) -> Result<()> {
-        let mut tx = self.transact()?;
+        let mut tx = self.transact_write()?;
         self.relation_store_id
-            .store(tx.load_last_relation_store_id()?.0, Ordering::Release);
+            .store(tx.init_storage()?.0, Ordering::Release);
         tx.commit_tx()?;
         Ok(())
     }

cozo-core/src/runtime/transact.rs

@@ -9,7 +9,7 @@
 use std::sync::atomic::{AtomicU32, AtomicU64};
 use std::sync::Arc;
 
-use miette::Result;
+use miette::{bail, Result};
 
 use crate::data::tuple::TupleT;
 use crate::data::value::DataValue;
@@ -24,15 +24,47 @@ pub struct SessionTx<'a> {
     pub(crate) temp_store_id: AtomicU32,
 }
 
+pub const CURRENT_STORAGE_VERSION: [u8; 1] = [0x00];
+
+fn storage_version_key() -> Vec<u8> {
+    let storage_version_tuple = vec![DataValue::Null, DataValue::from("STORAGE_VERSION")];
+    storage_version_tuple.encode_as_key(RelationId::SYSTEM)
+}
+
 impl<'a> SessionTx<'a> {
-    pub(crate) fn load_last_relation_store_id(&self) -> Result<RelationId> {
+    pub(crate) fn init_storage(&mut self) -> Result<RelationId> {
         let tuple = vec![DataValue::Null];
         let t_encoded = tuple.encode_as_key(RelationId::SYSTEM);
         let found = self.store_tx.get(&t_encoded, false)?;
-        Ok(match found {
-            None => RelationId::SYSTEM,
-            Some(slice) => RelationId::raw_decode(&slice),
-        })
+        let storage_version_key = storage_version_key();
+        let ret = match found {
+            None => {
+                self.store_tx
+                    .put(&storage_version_key, &CURRENT_STORAGE_VERSION)?;
+                self.store_tx
+                    .put(&t_encoded, &RelationId::new(0).raw_encode())?;
+                RelationId::SYSTEM
+            }
+            Some(slice) => {
+                let version_found = self.store_tx.get(&storage_version_key, false)?;
+                match version_found {
+                    None => {
+                        bail!("Storage is used but un-versioned, probably created by an ancient version of Cozo.")
+                    }
+                    Some(v) => {
+                        if &v != &CURRENT_STORAGE_VERSION {
+                            bail!(
+                                "Version mismatch: expect storage version {:?}, got {:?}",
+                                CURRENT_STORAGE_VERSION,
+                                v
+                            )
+                        }
+                    }
+                }
+                RelationId::raw_decode(&slice)
+            }
+        };
+        Ok(ret)
     }
 
     pub fn commit_tx(&mut self) -> Result<()> {