fluidB
/
fluidb
1
0
Fork 0
Code Pull Requests Activity

rename confusing field

Browse Source
main
Ziyang Hu 2 years ago
parent 1e5cf1e053
commit 17f52713a1
4 changed files with 37 additions and 37 deletions
Show Stats Download Patch File Download Diff File

12
cozo-core/src/query/stored.rs
Unescape Escape View File

@ -116,7 +116,7 @@ impl<'a> SessionTx<'a> {
.try_collect()?;
let key = relation_store.encode_key_for_store(&extracted, *span)?;
if has_triggers {
if let Some(existing) = self.tx.get(&key, false)? {
if let Some(existing) = self.store_tx.get(&key, false)? {
let mut tup = extracted.clone();
if !existing.is_empty() {
let mut remaining = &existing[ENCODED_KEY_MIN_LEN..];
@ -130,7 +130,7 @@ impl<'a> SessionTx<'a> {
}
new_tuples.push(DataValue::List(extracted.clone()));
}
self.tx.del(&key)?;
self.store_tx.del(&key)?;
}
if has_triggers && !new_tuples.is_empty() {
@ -200,7 +200,7 @@ impl<'a> SessionTx<'a> {
let key = relation_store.encode_key_for_store(&extracted, *span)?;
let val = relation_store.encode_val_for_store(&extracted, *span)?;
let existing = self.tx.get(&key, true)?;
let existing = self.store_tx.get(&key, true)?;
match existing {
None => {
bail!(TransactAssertionFailure {
@ -244,7 +244,7 @@ impl<'a> SessionTx<'a> {
.map(|ex| ex.extract_data(&tuple))
.try_collect()?;
let key = relation_store.encode_key_for_store(&extracted, *span)?;
if self.tx.exists(&key, true)? {
if self.store_tx.exists(&key, true)? {
bail!(TransactAssertionFailure {
relation: relation_store.name.to_string(),
key: extracted,
@ -291,7 +291,7 @@ impl<'a> SessionTx<'a> {
let val = relation_store.encode_val_for_store(&extracted, *span)?;
if has_triggers {
if let Some(existing) = self.tx.get(&key, false)? {
if let Some(existing) = self.store_tx.get(&key, false)? {
let mut tup = extracted.clone();
let mut remaining = &existing[ENCODED_KEY_MIN_LEN..];
while !remaining.is_empty() {
@ -305,7 +305,7 @@ impl<'a> SessionTx<'a> {
new_tuples.push(DataValue::List(extracted));
}
self.tx.put(&key, &val)?;
self.store_tx.put(&key, &val)?;
}
if has_triggers && !new_tuples.is_empty() {

22
cozo-core/src/runtime/db.rs
Unescape Escape View File

@ -180,7 +180,7 @@ impl<'s, S: Storage<'s>> Db<S> {
let end = Tuple::default().encode_as_key(handle.id.next());
let mut rows = vec![];
for data in tx.tx.range_scan(&start, &end) {
for data in tx.store_tx.range_scan(&start, &end) {
let (k, v) = data?;
let tuple = decode_tuple_from_kv(&k, &v);
let row = tuple.into_iter().map(JsonValue::from).collect_vec();
@ -282,7 +282,7 @@ impl<'s, S: Storage<'s>> Db<S> {
.try_collect()?;
let k_store = handle.encode_key_for_store(&keys, Default::default())?;
if is_delete {
tx.tx.del(&k_store)?;
tx.store_tx.del(&k_store)?;
} else {
let vals: Vec<_> = val_indices
.iter()
@ -294,7 +294,7 @@ impl<'s, S: Storage<'s>> Db<S> {
})
.try_collect()?;
let v_store = handle.encode_val_only_for_store(&vals, Default::default())?;
tx.tx.put(&k_store, &v_store)?;
tx.store_tx.put(&k_store, &v_store)?;
}
}
}
@ -312,8 +312,8 @@ impl<'s, S: Storage<'s>> Db<S> {
}
let mut s_tx = sqlite_db.transact_write()?;
let mut tx = self.transact()?;
let iter = tx.tx.range_scan(&[], &[0xFF]);
s_tx.tx.batch_put(iter)?;
let iter = tx.store_tx.range_scan(&[], &[0xFF]);
s_tx.store_tx.batch_put(iter)?;
tx.commit_tx()?;
s_tx.commit_tx()?;
Ok(())
@ -337,8 +337,8 @@ impl<'s, S: Storage<'s>> Db<S> {
store_id
);
}
let iter = s_tx.tx.range_scan(&[], &[1]);
tx.tx.batch_put(iter)?;
let iter = s_tx.store_tx.range_scan(&[], &[1]);
tx.store_tx.batch_put(iter)?;
s_tx.commit_tx()?;
tx.commit_tx()?;
Ok(())
@ -377,7 +377,7 @@ impl<'s, S: Storage<'s>> Db<S> {
let src_lower = Tuple::default().encode_as_key(src_handle.id);
let src_upper = Tuple::default().encode_as_key(src_handle.id.next());
let data_it = src_tx.tx.range_scan(&src_lower, &src_upper).map(
let data_it = src_tx.store_tx.range_scan(&src_lower, &src_upper).map(
|src_pair| -> Result<(Vec<u8>, Vec<u8>)> {
let (mut src_k, mut src_v) = src_pair?;
dst_handle.amend_key_prefix(&mut src_k);
@ -385,7 +385,7 @@ impl<'s, S: Storage<'s>> Db<S> {
Ok((src_k, src_v))
},
);
dst_tx.tx.batch_put(Box::new(data_it))?;
dst_tx.store_tx.batch_put(Box::new(data_it))?;
}
src_tx.commit_tx()?;
@ -409,14 +409,14 @@ impl<'s, S: Storage<'s>> Db<S> {
}
fn transact(&'s self) -> Result<SessionTx<'_>> {
let ret = SessionTx {
tx: Box::new(self.db.transact(false)?),
store_tx: Box::new(self.db.transact(false)?),
relation_store_id: self.relation_store_id.clone(),
};
Ok(ret)
}
fn transact_write(&'s self) -> Result<SessionTx<'_>> {
let ret = SessionTx {
tx: Box::new(self.db.transact(true)?),
store_tx: Box::new(self.db.transact(true)?),
relation_store_id: self.relation_store_id.clone(),
};
Ok(ret)

34
cozo-core/src/runtime/relation.rs
Unescape Escape View File

@ -223,7 +223,7 @@ impl RelationHandle {
) -> impl Iterator<Item = Result<Tuple>> + 'a {
let lower = Tuple::default().encode_as_key(self.id);
let upper = Tuple::default().encode_as_key(self.id.next());
tx.tx.range_scan_tuple(&lower, &upper)
tx.store_tx.range_scan_tuple(&lower, &upper)
}
pub(crate) fn get<'a>(
@ -233,14 +233,14 @@ impl RelationHandle {
) -> Result<Option<Tuple>> {
let key_data = key.encode_as_key(self.id);
Ok(tx
.tx
.store_tx
.get(&key_data, false)?
.map(|val_data| decode_tuple_from_kv(&key_data, &val_data)))
}
pub(crate) fn exists<'a>(&self, tx: &'a SessionTx<'_>, key: &[DataValue]) -> Result<bool> {
let key_data = key.encode_as_key(self.id);
tx.tx.exists(&key_data, false)
tx.store_tx.exists(&key_data, false)
}
pub(crate) fn scan_prefix<'a>(
@ -255,7 +255,7 @@ impl RelationHandle {
let prefix_encoded = lower.encode_as_key(self.id);
let upper_encoded = upper.encode_as_key(self.id);
// RelationIterator::new(tx, &prefix_encoded, &upper_encoded)
tx.tx.range_scan_tuple(&prefix_encoded, &upper_encoded)
tx.store_tx.range_scan_tuple(&prefix_encoded, &upper_encoded)
}
pub(crate) fn scan_bounded_prefix<'a>(
&self,
@ -271,7 +271,7 @@ impl RelationHandle {
upper_t.push(DataValue::Bot);
let lower_encoded = lower_t.encode_as_key(self.id);
let upper_encoded = upper_t.encode_as_key(self.id);
tx.tx.range_scan_tuple(&lower_encoded, &upper_encoded)
tx.store_tx.range_scan_tuple(&lower_encoded, &upper_encoded)
}
}
@ -296,7 +296,7 @@ impl<'a> SessionTx<'a> {
pub(crate) fn relation_exists(&self, name: &str) -> Result<bool> {
let key = DataValue::Str(SmartString::from(name));
let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
self.tx.exists(&encoded, false)
self.store_tx.exists(&encoded, false)
}
pub(crate) fn set_relation_triggers(
&mut self,
@ -324,7 +324,7 @@ impl<'a> SessionTx<'a> {
original
.serialize(&mut Serializer::new(&mut meta_val).with_struct_map())
.unwrap();
self.tx.put(&name_key, &meta_val)?;
self.store_tx.put(&name_key, &meta_val)?;
Ok(())
}
@ -335,7 +335,7 @@ impl<'a> SessionTx<'a> {
let key = DataValue::Str(input_meta.name.name.clone());
let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
if self.tx.exists(&encoded, true)? {
if self.store_tx.exists(&encoded, true)? {
bail!(RelNameConflictError(input_meta.name.to_string()))
};
@ -351,17 +351,17 @@ impl<'a> SessionTx<'a> {
access_level: AccessLevel::Normal,
};
self.tx.put(&encoded, &meta.id.raw_encode())?;
self.store_tx.put(&encoded, &meta.id.raw_encode())?;
let name_key = vec![DataValue::Str(meta.name.clone())].encode_as_key(RelationId::SYSTEM);
let mut meta_val = vec![];
meta.serialize(&mut Serializer::new(&mut meta_val).with_struct_map())
.unwrap();
self.tx.put(&name_key, &meta_val)?;
self.store_tx.put(&name_key, &meta_val)?;
let tuple = vec![DataValue::Null];
let t_encoded = tuple.encode_as_key(RelationId::SYSTEM);
self.tx.put(&t_encoded, &meta.id.raw_encode())?;
self.store_tx.put(&t_encoded, &meta.id.raw_encode())?;
Ok(meta)
}
pub(crate) fn get_relation(&self, name: &str, lock: bool) -> Result<RelationHandle> {
@ -374,7 +374,7 @@ impl<'a> SessionTx<'a> {
let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
let found = self
.tx
.store_tx
.get(&encoded, lock)?
.ok_or_else(|| StoredRelationNotFoundError(name.to_string()))?;
let metadata = RelationHandle::decode(&found)?;
@ -391,7 +391,7 @@ impl<'a> SessionTx<'a> {
}
let key = DataValue::Str(SmartString::from(name as &str));
let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
self.tx.del(&encoded)?;
self.store_tx.del(&encoded)?;
let lower_bound = Tuple::default().encode_as_key(store.id);
let upper_bound = Tuple::default().encode_as_key(store.id.next());
Ok((lower_bound, upper_bound))
@ -405,7 +405,7 @@ impl<'a> SessionTx<'a> {
let mut meta_val = vec![];
meta.serialize(&mut Serializer::new(&mut meta_val).with_struct_map())
.unwrap();
self.tx.put(&name_key, &meta_val)?;
self.store_tx.put(&name_key, &meta_val)?;
Ok(())
}
@ -413,7 +413,7 @@ impl<'a> SessionTx<'a> {
let new_key = DataValue::Str(new.name.clone());
let new_encoded = vec![new_key].encode_as_key(RelationId::SYSTEM);
if self.tx.exists(&new_encoded, true)? {
if self.store_tx.exists(&new_encoded, true)? {
bail!(RelNameConflictError(new.name.to_string()))
};
@ -432,8 +432,8 @@ impl<'a> SessionTx<'a> {
let mut meta_val = vec![];
rel.serialize(&mut Serializer::new(&mut meta_val)).unwrap();
self.tx.del(&old_encoded)?;
self.tx.put(&new_encoded, &meta_val)?;
self.store_tx.del(&old_encoded)?;
self.store_tx.put(&new_encoded, &meta_val)?;
Ok(())
}

6
cozo-core/src/runtime/transact.rs
Unescape Escape View File

@ -17,7 +17,7 @@ use crate::runtime::relation::RelationId;
use crate::storage::StoreTx;
pub struct SessionTx<'a> {
pub(crate) tx: Box<dyn StoreTx<'a> + 'a>,
pub(crate) store_tx: Box<dyn StoreTx<'a> + 'a>,
pub(crate) relation_store_id: Arc<AtomicU64>,
}
@ -25,7 +25,7 @@ impl<'a> SessionTx<'a> {
pub(crate) fn load_last_relation_store_id(&self) -> Result<RelationId> {
let tuple = vec![DataValue::Null];
let t_encoded = tuple.encode_as_key(RelationId::SYSTEM);
let found = self.tx.get(&t_encoded, false)?;
let found = self.store_tx.get(&t_encoded, false)?;
Ok(match found {
None => RelationId::SYSTEM,
Some(slice) => RelationId::raw_decode(&slice),
@ -33,7 +33,7 @@ impl<'a> SessionTx<'a> {
}
pub fn commit_tx(&mut self) -> Result<()> {
self.tx.commit()?;
self.store_tx.commit()?;
Ok(())
}
}

Write Preview
Loading…
Cancel
Save