assertions are "closed", whereas retractions are "open".

cozo-core/src/data/functions.rs

@@ -1272,7 +1272,7 @@ pub(crate) fn op_to_bool(args: &[DataValue]) -> Result<DataValue> {
         DataValue::Regex(r) => !r.0.as_str().is_empty(),
         DataValue::List(l) => !l.is_empty(),
         DataValue::Set(s) => !s.is_empty(),
-        DataValue::Validity(vld) => vld.is_assert,
+        DataValue::Validity(vld) => vld.is_assert.0,
         DataValue::Bot => false,
     }))
 }
@@ -1289,7 +1289,7 @@ pub(crate) fn op_to_unity(args: &[DataValue]) -> Result<DataValue> {
         DataValue::Regex(r) => i64::from(!r.0.as_str().is_empty()),
         DataValue::List(l) => i64::from(!l.is_empty()),
         DataValue::Set(s) => i64::from(!s.is_empty()),
-        DataValue::Validity(vld) => i64::from(vld.is_assert),
+        DataValue::Validity(vld) => i64::from(vld.is_assert.0),
         DataValue::Bot => 0,
     }))
 }
@@ -1492,7 +1492,7 @@ pub(crate) fn current_validity() -> ValidityTs {
 pub(crate) const MAX_VALIDITY_TS: ValidityTs = ValidityTs(Reverse(i64::MAX));
 pub(crate) const TERMINAL_VALIDITY: Validity = Validity {
     timestamp: ValidityTs(Reverse(i64::MIN)),
-    is_assert: true,
+    is_assert: Reverse(false),
 };
 
 define_op!(OP_FORMAT_TIMESTAMP, 1, true);

cozo-core/src/data/memcmp.rs

@@ -86,7 +86,7 @@ pub(crate) trait MemCmpEncoder: Write {
                 let ts_flipped = !ts_u64;
                 self.write_u8(VLD_TAG).unwrap();
                 self.write_u64::<BigEndian>(ts_flipped).unwrap();
-                self.write_u8(vld.is_assert as u8).unwrap();
+                self.write_u8(!vld.is_assert.0 as u8).unwrap();
             }
             DataValue::Bot => self.write_u8(BOT_TAG).unwrap(),
         }
@@ -285,11 +285,11 @@ impl DataValue {
                 let ts_u64 = !ts_flipped;
                 let ts = order_decode_i64(ts_u64);
                 let (is_assert_byte, rest) = rest.split_first().unwrap();
-                let is_assert = *is_assert_byte != 0;
+                let is_assert = *is_assert_byte == 0;
                 (
                     DataValue::Validity(Validity {
                         timestamp: ValidityTs(Reverse(ts)),
-                        is_assert,
+                        is_assert: Reverse(is_assert),
                     }),
                     rest,
                 )

cozo-core/src/data/relation.rs

@@ -232,11 +232,11 @@ impl NullableColType {
                     DataValue::Str(s) => match &s as &str {
                         "ASSERT" => DataValue::Validity(Validity {
                             timestamp: cur_vld,
-                            is_assert: true,
+                            is_assert: Reverse(true),
                         }),
                         "RETRACT" => DataValue::Validity(Validity {
                             timestamp: cur_vld,
-                            is_assert: false,
+                            is_assert: Reverse(false),
                         }),
                         s => {
                             let (is_assert, ts_str) = match s.strip_prefix('~') {
@@ -255,7 +255,7 @@ impl NullableColType {
 
                             DataValue::Validity(Validity {
                                 timestamp: ValidityTs(Reverse(microseconds)),
-                                is_assert,
+                                is_assert: Reverse(is_assert),
                             })
                         }
                     },
@@ -269,7 +269,7 @@ impl NullableColType {
                                 }
                                 return Ok(DataValue::Validity(Validity {
                                     timestamp: ValidityTs(Reverse(ts)),
-                                    is_assert,
+                                    is_assert: Reverse(is_assert),
                                 }));
                             }
                         }

cozo-core/src/data/tuple.rs

@@ -6,6 +6,7 @@
  * You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+use std::cmp::Reverse;
 use crate::data::functions::TERMINAL_VALIDITY;
 use miette::Result;
 
@@ -64,11 +65,11 @@ pub fn check_key_for_validity(key: &[u8], valid_at: ValidityTs) -> (Option<Tuple
     if vld.timestamp < valid_at {
         *decoded.last_mut().unwrap() = DataValue::Validity(Validity {
             timestamp: valid_at,
-            is_assert: false,
+            is_assert: Reverse(true),
         });
         let nxt_seek = decoded.encode_as_key(rel_id);
         (None, nxt_seek)
-    } else if !vld.is_assert {
+    } else if !vld.is_assert.0 {
         *decoded.last_mut().unwrap() = DataValue::Validity(TERMINAL_VALIDITY);
         let nxt_seek = decoded.encode_as_key(rel_id);
         (None, nxt_seek)

cozo-core/src/data/value.rs

@@ -111,7 +111,7 @@ pub struct ValidityTs(pub Reverse<i64>);
 )]
 pub struct Validity {
     pub(crate) timestamp: ValidityTs,
-    pub(crate) is_assert: bool,
+    pub(crate) is_assert: Reverse<bool>,
 }
 
 #[derive(