|
|
@ -4,7 +4,7 @@ use crate::data::encode::{
|
|
|
|
encode_aev_key, encode_ave_key, encode_ave_key_for_unique_v, encode_eav_key,
|
|
|
|
encode_aev_key, encode_ave_key, encode_ave_key_for_unique_v, encode_eav_key,
|
|
|
|
encode_unique_attr_val, encode_unique_entity, encode_vae_key, EncodedVec, LARGE_VEC_SIZE,
|
|
|
|
encode_unique_attr_val, encode_unique_entity, encode_vae_key, EncodedVec, LARGE_VEC_SIZE,
|
|
|
|
};
|
|
|
|
};
|
|
|
|
use crate::data::id::{AttrId, EntityId, TxId};
|
|
|
|
use crate::data::id::{AttrId, EntityId, Validity};
|
|
|
|
use crate::data::keyword::Keyword;
|
|
|
|
use crate::data::keyword::Keyword;
|
|
|
|
use crate::data::triple::StoreOp;
|
|
|
|
use crate::data::triple::StoreOp;
|
|
|
|
use crate::data::value::{StaticValue, Value, INLINE_VAL_SIZE_LIMIT};
|
|
|
|
use crate::data::value::{StaticValue, Value, INLINE_VAL_SIZE_LIMIT};
|
|
|
@ -23,7 +23,7 @@ enum TripleError {
|
|
|
|
#[error("unique constraint violated: {0} {1}")]
|
|
|
|
#[error("unique constraint violated: {0} {1}")]
|
|
|
|
UniqueConstraintViolated(Keyword, String),
|
|
|
|
UniqueConstraintViolated(Keyword, String),
|
|
|
|
#[error("triple not found for {0:?} {1:?} {2:?}")]
|
|
|
|
#[error("triple not found for {0:?} {1:?} {2:?}")]
|
|
|
|
TripleEANotFound(EntityId, AttrId, TxId),
|
|
|
|
TripleEANotFound(EntityId, AttrId, Validity),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl SessionTx {
|
|
|
|
impl SessionTx {
|
|
|
@ -32,13 +32,14 @@ impl SessionTx {
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
attr: &Attribute,
|
|
|
|
attr: &Attribute,
|
|
|
|
v: &Value,
|
|
|
|
v: &Value,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
op: StoreOp,
|
|
|
|
op: StoreOp,
|
|
|
|
) -> Result<()> {
|
|
|
|
) -> Result<()> {
|
|
|
|
let tx_id = self.get_write_tx_id()?;
|
|
|
|
let tx_id = self.get_write_tx_id()?;
|
|
|
|
let tx_id_in_key = if attr.with_history {
|
|
|
|
let vld_in_key = if attr.with_history {
|
|
|
|
tx_id
|
|
|
|
vld
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
TxId::NO_HISTORY
|
|
|
|
Validity::MIN
|
|
|
|
};
|
|
|
|
};
|
|
|
|
// elide value in key for eav and aev if cardinality is one
|
|
|
|
// elide value in key for eav and aev if cardinality is one
|
|
|
|
let (v_in_key, v_in_val) = if attr.cardinality.is_one() {
|
|
|
|
let (v_in_key, v_in_val) = if attr.cardinality.is_one() {
|
|
|
@ -49,8 +50,8 @@ impl SessionTx {
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
(v, &Value::Bottom)
|
|
|
|
(v, &Value::Bottom)
|
|
|
|
};
|
|
|
|
};
|
|
|
|
let eav_encoded = encode_eav_key(eid, attr.id, v_in_key, tx_id_in_key);
|
|
|
|
let eav_encoded = encode_eav_key(eid, attr.id, v_in_key, vld_in_key);
|
|
|
|
let val_encoded = v_in_val.encode_with_op(op);
|
|
|
|
let val_encoded = v_in_val.encode_with_op_and_tx(op, tx_id);
|
|
|
|
self.tx.put(&eav_encoded, &val_encoded)?;
|
|
|
|
self.tx.put(&eav_encoded, &val_encoded)?;
|
|
|
|
|
|
|
|
|
|
|
|
// elide value in data for aev if it is big
|
|
|
|
// elide value in data for aev if it is big
|
|
|
@ -60,12 +61,12 @@ impl SessionTx {
|
|
|
|
val_encoded
|
|
|
|
val_encoded
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
let aev_encoded = encode_aev_key(attr.id, eid, v_in_key, tx_id_in_key);
|
|
|
|
let aev_encoded = encode_aev_key(attr.id, eid, v_in_key, vld_in_key);
|
|
|
|
self.tx.put(&aev_encoded, &val_encoded)?;
|
|
|
|
self.tx.put(&aev_encoded, &val_encoded)?;
|
|
|
|
|
|
|
|
|
|
|
|
// vae for ref types
|
|
|
|
// vae for ref types
|
|
|
|
if attr.val_type.is_ref_type() {
|
|
|
|
if attr.val_type.is_ref_type() {
|
|
|
|
let vae_encoded = encode_vae_key(v.get_entity_id()?, attr.id, eid, tx_id_in_key);
|
|
|
|
let vae_encoded = encode_vae_key(v.get_entity_id()?, attr.id, eid, vld_in_key);
|
|
|
|
self.tx.put(&vae_encoded, &[op as u8])?;
|
|
|
|
self.tx.put(&vae_encoded, &[op as u8])?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
@ -77,16 +78,16 @@ impl SessionTx {
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
eid
|
|
|
|
eid
|
|
|
|
};
|
|
|
|
};
|
|
|
|
let ave_encoded = encode_ave_key(attr.id, v, e_in_key, tx_id_in_key);
|
|
|
|
let ave_encoded = encode_ave_key(attr.id, v, e_in_key, vld_in_key);
|
|
|
|
// checking of unique constraints
|
|
|
|
// checking of unique constraints
|
|
|
|
// TODO include future-pointing checking
|
|
|
|
// TODO include future-pointing checking
|
|
|
|
if attr.indexing.is_unique_index() {
|
|
|
|
if attr.indexing.is_unique_index() {
|
|
|
|
let starting = if attr.with_history {
|
|
|
|
let starting = if attr.with_history {
|
|
|
|
ave_encoded.clone()
|
|
|
|
ave_encoded.clone()
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
encode_ave_key(attr.id, v, e_in_key, tx_id)
|
|
|
|
encode_ave_key(attr.id, v, e_in_key, vld)
|
|
|
|
};
|
|
|
|
};
|
|
|
|
let ave_encoded_bound = encode_ave_key(attr.id, v, e_in_key, TxId::ZERO);
|
|
|
|
let ave_encoded_bound = encode_ave_key(attr.id, v, e_in_key, Validity::MIN);
|
|
|
|
if let Some((k_slice, v_slice)) = self
|
|
|
|
if let Some((k_slice, v_slice)) = self
|
|
|
|
.bounded_scan_first(&starting, &ave_encoded_bound)
|
|
|
|
.bounded_scan_first(&starting, &ave_encoded_bound)
|
|
|
|
.pair()?
|
|
|
|
.pair()?
|
|
|
@ -120,7 +121,13 @@ impl SessionTx {
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub(crate) fn new_triple(&mut self, eid: EntityId, attr: &Attribute, v: &Value) -> Result<()> {
|
|
|
|
pub(crate) fn new_triple(
|
|
|
|
|
|
|
|
&mut self,
|
|
|
|
|
|
|
|
eid: EntityId,
|
|
|
|
|
|
|
|
attr: &Attribute,
|
|
|
|
|
|
|
|
v: &Value,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
|
|
|
|
) -> Result<()> {
|
|
|
|
// invariant: in the preparation step, any identity attr should already be resolved to
|
|
|
|
// invariant: in the preparation step, any identity attr should already be resolved to
|
|
|
|
// an existing eid, if there is one
|
|
|
|
// an existing eid, if there is one
|
|
|
|
let eid = if eid.is_perm() {
|
|
|
|
let eid = if eid.is_perm() {
|
|
|
@ -135,7 +142,7 @@ impl SessionTx {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
};
|
|
|
|
self.put_triple(eid, attr, v, StoreOp::Assert)
|
|
|
|
self.put_triple(eid, attr, v, vld, StoreOp::Assert)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub(crate) fn amend_triple(
|
|
|
|
pub(crate) fn amend_triple(
|
|
|
@ -143,12 +150,13 @@ impl SessionTx {
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
attr: &Attribute,
|
|
|
|
attr: &Attribute,
|
|
|
|
v: &Value,
|
|
|
|
v: &Value,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
) -> Result<()> {
|
|
|
|
) -> Result<()> {
|
|
|
|
if !eid.is_perm() {
|
|
|
|
if !eid.is_perm() {
|
|
|
|
return Err(TripleError::TempEid(eid).into());
|
|
|
|
return Err(TripleError::TempEid(eid).into());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// checking that the eid actually exists should be done in the preprocessing step
|
|
|
|
// checking that the eid actually exists should be done in the preprocessing step
|
|
|
|
self.put_triple(eid, attr, v, StoreOp::Retract)
|
|
|
|
self.put_triple(eid, attr, v, vld, StoreOp::Retract)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub(crate) fn retract_triple(
|
|
|
|
pub(crate) fn retract_triple(
|
|
|
@ -156,11 +164,12 @@ impl SessionTx {
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
attr: &Attribute,
|
|
|
|
attr: &Attribute,
|
|
|
|
v: &Value,
|
|
|
|
v: &Value,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
) -> Result<()> {
|
|
|
|
) -> Result<()> {
|
|
|
|
self.put_triple(eid, attr, v, StoreOp::Retract)?;
|
|
|
|
self.put_triple(eid, attr, v, vld, StoreOp::Retract)?;
|
|
|
|
if attr.val_type == AttributeTyping::Component {
|
|
|
|
if attr.val_type == AttributeTyping::Component {
|
|
|
|
let eid_v = v.get_entity_id()?;
|
|
|
|
let eid_v = v.get_entity_id()?;
|
|
|
|
self.retract_entity(eid_v)?;
|
|
|
|
self.retract_entity(eid_v, vld)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -168,26 +177,30 @@ impl SessionTx {
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
attr: &Attribute,
|
|
|
|
attr: &Attribute,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
) -> Result<()> {
|
|
|
|
) -> Result<()> {
|
|
|
|
let lower_bound = encode_eav_key(eid, attr.id, &Value::Null, TxId::MAX_USER);
|
|
|
|
// TODO properly add retractions at the correct time
|
|
|
|
let upper_bound = encode_eav_key(eid, attr.id, &Value::Bottom, TxId::ZERO);
|
|
|
|
let lower_bound = encode_eav_key(eid, attr.id, &Value::Null, Validity::MAX);
|
|
|
|
self.batch_retract_triple(lower_bound, upper_bound)
|
|
|
|
let upper_bound = encode_eav_key(eid, attr.id, &Value::Bottom, Validity::MIN);
|
|
|
|
|
|
|
|
self.batch_retract_triple(lower_bound, upper_bound, vld)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn retract_entity(&mut self, eid: EntityId) -> Result<()> {
|
|
|
|
pub(crate) fn retract_entity(&mut self, eid: EntityId, vld: Validity) -> Result<()> {
|
|
|
|
match self.latest_entity_existence(eid, true)? {
|
|
|
|
match self.latest_entity_existence(eid, true)? {
|
|
|
|
LatestTripleExistence::Asserted => {}
|
|
|
|
LatestTripleExistence::Asserted => {}
|
|
|
|
LatestTripleExistence::Retracted => return Ok(()),
|
|
|
|
LatestTripleExistence::Retracted => return Ok(()),
|
|
|
|
LatestTripleExistence::NotFound => return Err(TripleError::EidNotFound(eid).into()),
|
|
|
|
LatestTripleExistence::NotFound => return Err(TripleError::EidNotFound(eid).into()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
let lower_bound = encode_eav_key(eid, AttrId::MIN_PERM, &Value::Null, TxId::MAX_USER);
|
|
|
|
let lower_bound = encode_eav_key(eid, AttrId::MIN_PERM, &Value::Null, Validity::MAX);
|
|
|
|
let upper_bound = encode_eav_key(eid, AttrId::MAX_PERM, &Value::Bottom, TxId::ZERO);
|
|
|
|
let upper_bound = encode_eav_key(eid, AttrId::MAX_PERM, &Value::Bottom, Validity::MAX);
|
|
|
|
self.batch_retract_triple(lower_bound, upper_bound)
|
|
|
|
self.batch_retract_triple(lower_bound, upper_bound, vld)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn batch_retract_triple(
|
|
|
|
fn batch_retract_triple(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
lower_bound: EncodedVec<LARGE_VEC_SIZE>,
|
|
|
|
lower_bound: EncodedVec<LARGE_VEC_SIZE>,
|
|
|
|
upper_bound: EncodedVec<LARGE_VEC_SIZE>,
|
|
|
|
upper_bound: EncodedVec<LARGE_VEC_SIZE>,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
) -> Result<()> {
|
|
|
|
) -> Result<()> {
|
|
|
|
|
|
|
|
// TODO properly retract attributes at the correct time only
|
|
|
|
let mut it = self.bounded_scan(&lower_bound, &upper_bound);
|
|
|
|
let mut it = self.bounded_scan(&lower_bound, &upper_bound);
|
|
|
|
let mut current = lower_bound.clone();
|
|
|
|
let mut current = lower_bound.clone();
|
|
|
|
loop {
|
|
|
|
loop {
|
|
|
@ -202,9 +215,9 @@ impl SessionTx {
|
|
|
|
let cur_attr = self
|
|
|
|
let cur_attr = self
|
|
|
|
.attr_by_id(cur_aid)?
|
|
|
|
.attr_by_id(cur_aid)?
|
|
|
|
.ok_or(TransactError::AttrNotFound(cur_aid))?;
|
|
|
|
.ok_or(TransactError::AttrNotFound(cur_aid))?;
|
|
|
|
self.retract_triple(cur_eid, &cur_attr, &cur_v)?;
|
|
|
|
self.retract_triple(cur_eid, &cur_attr, &cur_v, vld)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
current = encode_eav_key(cur_eid, cur_aid, &cur_v, TxId::ZERO);
|
|
|
|
current = encode_eav_key(cur_eid, cur_aid, &cur_v, Validity::MIN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -229,6 +242,7 @@ impl SessionTx {
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
attr: &Attribute,
|
|
|
|
attr: &Attribute,
|
|
|
|
v: &Value,
|
|
|
|
v: &Value,
|
|
|
|
|
|
|
|
vld: Validity,
|
|
|
|
) -> Result<Option<EntityId>> {
|
|
|
|
) -> Result<Option<EntityId>> {
|
|
|
|
if let Some(inner) = self.eid_by_attr_val_cache.get(v) {
|
|
|
|
if let Some(inner) = self.eid_by_attr_val_cache.get(v) {
|
|
|
|
if let Some(found) = inner.get(&attr.id) {
|
|
|
|
if let Some(found) = inner.get(&attr.id) {
|
|
|
@ -236,8 +250,8 @@ impl SessionTx {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let lower = encode_ave_key_for_unique_v(attr.id, v, self.r_tx_id);
|
|
|
|
let lower = encode_ave_key_for_unique_v(attr.id, v, vld);
|
|
|
|
let upper = encode_ave_key_for_unique_v(attr.id, v, TxId::ZERO);
|
|
|
|
let upper = encode_ave_key_for_unique_v(attr.id, v, Validity::MIN);
|
|
|
|
Ok(
|
|
|
|
Ok(
|
|
|
|
if let Some((k_slice, v_slice)) = self.bounded_scan_first(&lower, &upper).pair()? {
|
|
|
|
if let Some((k_slice, v_slice)) = self.bounded_scan_first(&lower, &upper).pair()? {
|
|
|
|
if StoreOp::try_from(v_slice[0])?.is_assert() {
|
|
|
|
if StoreOp::try_from(v_slice[0])?.is_assert() {
|
|
|
@ -264,83 +278,96 @@ impl SessionTx {
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
aid: AttrId,
|
|
|
|
aid: AttrId,
|
|
|
|
txid: TxId,
|
|
|
|
vld: Validity,
|
|
|
|
) -> Result<StaticValue> {
|
|
|
|
) -> Result<StaticValue> {
|
|
|
|
let encoded = encode_eav_key(eid, aid, &Value::Bottom, txid);
|
|
|
|
let encoded = encode_eav_key(eid, aid, &Value::Bottom, vld);
|
|
|
|
let res = self
|
|
|
|
let res = self
|
|
|
|
.tx
|
|
|
|
.tx
|
|
|
|
.get(&encoded, false)?
|
|
|
|
.get(&encoded, false)?
|
|
|
|
.ok_or(TripleError::TripleEANotFound(eid, aid, txid))?;
|
|
|
|
.ok_or(TripleError::TripleEANotFound(eid, aid, vld))?;
|
|
|
|
Ok(decode_value(&res.as_ref()[1..])?.to_static())
|
|
|
|
Ok(decode_value(&res.as_ref()[1..])?.to_static())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_ea_scan(
|
|
|
|
pub(crate) fn triple_ea_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
aid: AttrId,
|
|
|
|
aid: AttrId,
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, StaticValue, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, StaticValue, Validity)>> {
|
|
|
|
let lower = encode_eav_key(eid, aid, &Value::Null, TxId::MAX_USER);
|
|
|
|
let lower = encode_eav_key(eid, aid, &Value::Null, Validity::MAX);
|
|
|
|
let upper = encode_eav_key(eid, aid, &Value::Bottom, TxId::ZERO);
|
|
|
|
let upper = encode_eav_key(eid, aid, &Value::Bottom, Validity::MIN);
|
|
|
|
TripleEntityAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleEntityAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_ae_scan(
|
|
|
|
pub(crate) fn triple_ae_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
aid: AttrId,
|
|
|
|
aid: AttrId,
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, EntityId, StaticValue, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, EntityId, StaticValue, Validity)>> {
|
|
|
|
let lower = encode_aev_key(aid, eid, &Value::Null, TxId::MAX_USER);
|
|
|
|
let lower = encode_aev_key(aid, eid, &Value::Null, Validity::MAX);
|
|
|
|
let upper = encode_aev_key(aid, eid, &Value::Bottom, TxId::ZERO);
|
|
|
|
let upper = encode_aev_key(aid, eid, &Value::Bottom, Validity::MIN);
|
|
|
|
TripleAttrEntityIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleAttrEntityIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_av_scan(
|
|
|
|
pub(crate) fn triple_av_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
aid: AttrId,
|
|
|
|
aid: AttrId,
|
|
|
|
v: &Value,
|
|
|
|
v: &Value,
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, StaticValue, EntityId, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, StaticValue, EntityId, Validity)>> {
|
|
|
|
let lower = encode_ave_key(aid, v, EntityId::MIN_PERM, TxId::MAX_USER);
|
|
|
|
let lower = encode_ave_key(aid, v, EntityId::MIN_PERM, Validity::MAX);
|
|
|
|
let upper = encode_ave_key(aid, v, EntityId::MAX_PERM, TxId::ZERO);
|
|
|
|
let upper = encode_ave_key(aid, v, EntityId::MAX_PERM, Validity::MIN);
|
|
|
|
TripleAttrValueIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleAttrValueIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_vref_a_scan(
|
|
|
|
pub(crate) fn triple_vref_a_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
v_eid: EntityId,
|
|
|
|
v_eid: EntityId,
|
|
|
|
aid: AttrId,
|
|
|
|
aid: AttrId,
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, EntityId, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, EntityId, Validity)>> {
|
|
|
|
let lower = encode_vae_key(v_eid, aid, EntityId::MIN_PERM, TxId::MAX_USER);
|
|
|
|
let lower = encode_vae_key(v_eid, aid, EntityId::MIN_PERM, Validity::MAX);
|
|
|
|
let upper = encode_vae_key(v_eid, aid, EntityId::MAX_PERM, TxId::ZERO);
|
|
|
|
let upper = encode_vae_key(v_eid, aid, EntityId::MAX_PERM, Validity::MIN);
|
|
|
|
TripleValueRefAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleValueRefAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_e_scan(
|
|
|
|
pub(crate) fn triple_e_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
eid: EntityId,
|
|
|
|
eid: EntityId,
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, StaticValue, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, StaticValue, Validity)>> {
|
|
|
|
let lower = encode_eav_key(eid, AttrId::MIN_PERM, &Value::Null, TxId::MAX_USER);
|
|
|
|
let lower = encode_eav_key(eid, AttrId::MIN_PERM, &Value::Null, Validity::MAX);
|
|
|
|
let upper = encode_eav_key(eid, AttrId::MAX_PERM, &Value::Bottom, TxId::ZERO);
|
|
|
|
let upper = encode_eav_key(eid, AttrId::MAX_PERM, &Value::Bottom, Validity::MIN);
|
|
|
|
TripleEntityAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleEntityAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_a_scan(
|
|
|
|
pub(crate) fn triple_a_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
aid: AttrId,
|
|
|
|
aid: AttrId,
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, EntityId, StaticValue, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, EntityId, StaticValue, Validity)>> {
|
|
|
|
let lower = encode_aev_key(aid, EntityId::MIN_PERM, &Value::Null, TxId::MAX_USER);
|
|
|
|
let lower = encode_aev_key(aid, EntityId::MIN_PERM, &Value::Null, Validity::MAX);
|
|
|
|
let upper = encode_aev_key(aid, EntityId::MAX_PERM, &Value::Bottom, TxId::ZERO);
|
|
|
|
let upper = encode_aev_key(aid, EntityId::MAX_PERM, &Value::Bottom, Validity::MIN);
|
|
|
|
TripleAttrEntityIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleAttrEntityIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}pub(crate) fn triple_a_scan_all(
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn triple_a_scan_all(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, EntityId, StaticValue, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(AttrId, EntityId, StaticValue, Validity)>> {
|
|
|
|
let lower = encode_aev_key(AttrId::MIN_PERM, EntityId::MIN_PERM, &Value::Null, TxId::MAX_USER);
|
|
|
|
let lower = encode_aev_key(
|
|
|
|
let upper = encode_aev_key(AttrId::MAX_PERM, EntityId::MAX_PERM, &Value::Bottom, TxId::ZERO);
|
|
|
|
AttrId::MIN_PERM,
|
|
|
|
|
|
|
|
EntityId::MIN_PERM,
|
|
|
|
|
|
|
|
&Value::Null,
|
|
|
|
|
|
|
|
Validity::MAX,
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
let upper = encode_aev_key(
|
|
|
|
|
|
|
|
AttrId::MAX_PERM,
|
|
|
|
|
|
|
|
EntityId::MAX_PERM,
|
|
|
|
|
|
|
|
&Value::Bottom,
|
|
|
|
|
|
|
|
Validity::MIN,
|
|
|
|
|
|
|
|
);
|
|
|
|
TripleAttrEntityIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleAttrEntityIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) fn triple_vref_scan(
|
|
|
|
pub(crate) fn triple_vref_scan(
|
|
|
|
&mut self,
|
|
|
|
&mut self,
|
|
|
|
v_eid: EntityId,
|
|
|
|
v_eid: EntityId,
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, EntityId, TxId)>> {
|
|
|
|
) -> impl Iterator<Item = Result<(EntityId, AttrId, EntityId, Validity)>> {
|
|
|
|
let lower = encode_vae_key(v_eid, AttrId::MIN_PERM, EntityId::MIN_PERM, TxId::MAX_USER);
|
|
|
|
let lower = encode_vae_key(v_eid, AttrId::MIN_PERM, EntityId::MIN_PERM, Validity::MAX);
|
|
|
|
let upper = encode_vae_key(v_eid, AttrId::MAX_PERM, EntityId::MAX_PERM, TxId::ZERO);
|
|
|
|
let upper = encode_vae_key(v_eid, AttrId::MAX_PERM, EntityId::MAX_PERM, Validity::MIN);
|
|
|
|
TripleValueRefAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
TripleValueRefAttrIter::new(self.tx.iterator(), lower, upper)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// FIXME iterators should iterate on current validity
|
|
|
|
|
|
|
|
|
|
|
|
enum LatestTripleExistence {
|
|
|
|
enum LatestTripleExistence {
|
|
|
|
Asserted,
|
|
|
|
Asserted,
|
|
|
|
Retracted,
|
|
|
|
Retracted,
|
|
|
@ -364,7 +391,7 @@ impl TripleEntityAttrIter {
|
|
|
|
current: lower_bound,
|
|
|
|
current: lower_bound,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(EntityId, AttrId, StaticValue, TxId)>> {
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(EntityId, AttrId, StaticValue, Validity)>> {
|
|
|
|
loop {
|
|
|
|
loop {
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
match self.it.pair()? {
|
|
|
|
match self.it.pair()? {
|
|
|
@ -385,7 +412,7 @@ impl TripleEntityAttrIter {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl Iterator for TripleEntityAttrIter {
|
|
|
|
impl Iterator for TripleEntityAttrIter {
|
|
|
|
type Item = Result<(EntityId, AttrId, StaticValue, TxId)>;
|
|
|
|
type Item = Result<(EntityId, AttrId, StaticValue, Validity)>;
|
|
|
|
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
@ -409,7 +436,7 @@ impl TripleAttrEntityIter {
|
|
|
|
current: lower_bound,
|
|
|
|
current: lower_bound,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(AttrId, EntityId, StaticValue, TxId)>> {
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(AttrId, EntityId, StaticValue, Validity)>> {
|
|
|
|
loop {
|
|
|
|
loop {
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
match self.it.pair()? {
|
|
|
|
match self.it.pair()? {
|
|
|
@ -430,7 +457,7 @@ impl TripleAttrEntityIter {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl Iterator for TripleAttrEntityIter {
|
|
|
|
impl Iterator for TripleAttrEntityIter {
|
|
|
|
type Item = Result<(AttrId, EntityId, StaticValue, TxId)>;
|
|
|
|
type Item = Result<(AttrId, EntityId, StaticValue, Validity)>;
|
|
|
|
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
@ -454,7 +481,7 @@ impl TripleAttrValueIter {
|
|
|
|
current: lower_bound,
|
|
|
|
current: lower_bound,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(AttrId, StaticValue, EntityId, TxId)>> {
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(AttrId, StaticValue, EntityId, Validity)>> {
|
|
|
|
loop {
|
|
|
|
loop {
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
match self.it.pair()? {
|
|
|
|
match self.it.pair()? {
|
|
|
@ -475,7 +502,7 @@ impl TripleAttrValueIter {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl Iterator for TripleAttrValueIter {
|
|
|
|
impl Iterator for TripleAttrValueIter {
|
|
|
|
type Item = Result<(AttrId, StaticValue, EntityId, TxId)>;
|
|
|
|
type Item = Result<(AttrId, StaticValue, EntityId, Validity)>;
|
|
|
|
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
@ -499,7 +526,7 @@ impl TripleValueRefAttrIter {
|
|
|
|
current: lower_bound,
|
|
|
|
current: lower_bound,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(EntityId, AttrId, EntityId, TxId)>> {
|
|
|
|
fn next_inner(&mut self) -> Result<Option<(EntityId, AttrId, EntityId, Validity)>> {
|
|
|
|
loop {
|
|
|
|
loop {
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
self.it.seek(&self.current);
|
|
|
|
match self.it.pair()? {
|
|
|
|
match self.it.pair()? {
|
|
|
@ -519,7 +546,7 @@ impl TripleValueRefAttrIter {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl Iterator for TripleValueRefAttrIter {
|
|
|
|
impl Iterator for TripleValueRefAttrIter {
|
|
|
|
type Item = Result<(EntityId, AttrId, EntityId, TxId)>;
|
|
|
|
type Item = Result<(EntityId, AttrId, EntityId, Validity)>;
|
|
|
|
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
|
swap_option_result(self.next_inner())
|
|
|
|