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()?; .try_collect()?;
let key = relation_store.encode_key_for_store(&extracted, *span)?; let key = relation_store.encode_key_for_store(&extracted, *span)?;
if has_triggers { 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 tup = extracted.clone();
if !existing.is_empty() { if !existing.is_empty() {
let mut remaining = &existing[ENCODED_KEY_MIN_LEN..]; let mut remaining = &existing[ENCODED_KEY_MIN_LEN..];
@ -130,7 +130,7 @@ impl<'a> SessionTx<'a> {
} }
new_tuples.push(DataValue::List(extracted.clone())); new_tuples.push(DataValue::List(extracted.clone()));
} }
self.tx.del(&key)?; self.store_tx.del(&key)?;
} }
if has_triggers && !new_tuples.is_empty() { 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 key = relation_store.encode_key_for_store(&extracted, *span)?;
let val = relation_store.encode_val_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 { match existing {
None => { None => {
bail!(TransactAssertionFailure { bail!(TransactAssertionFailure {
@ -244,7 +244,7 @@ impl<'a> SessionTx<'a> {
.map(|ex| ex.extract_data(&tuple)) .map(|ex| ex.extract_data(&tuple))
.try_collect()?; .try_collect()?;
let key = relation_store.encode_key_for_store(&extracted, *span)?; 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 { bail!(TransactAssertionFailure {
relation: relation_store.name.to_string(), relation: relation_store.name.to_string(),
key: extracted, key: extracted,
@ -291,7 +291,7 @@ impl<'a> SessionTx<'a> {
let val = relation_store.encode_val_for_store(&extracted, *span)?; let val = relation_store.encode_val_for_store(&extracted, *span)?;
if has_triggers { 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 tup = extracted.clone();
let mut remaining = &existing[ENCODED_KEY_MIN_LEN..]; let mut remaining = &existing[ENCODED_KEY_MIN_LEN..];
while !remaining.is_empty() { while !remaining.is_empty() {
@ -305,7 +305,7 @@ impl<'a> SessionTx<'a> {
new_tuples.push(DataValue::List(extracted)); new_tuples.push(DataValue::List(extracted));
} }
self.tx.put(&key, &val)?; self.store_tx.put(&key, &val)?;
} }
if has_triggers && !new_tuples.is_empty() { 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 end = Tuple::default().encode_as_key(handle.id.next());
let mut rows = vec![]; 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 (k, v) = data?;
let tuple = decode_tuple_from_kv(&k, &v); let tuple = decode_tuple_from_kv(&k, &v);
let row = tuple.into_iter().map(JsonValue::from).collect_vec(); let row = tuple.into_iter().map(JsonValue::from).collect_vec();
@ -282,7 +282,7 @@ impl<'s, S: Storage<'s>> Db<S> {
.try_collect()?; .try_collect()?;
let k_store = handle.encode_key_for_store(&keys, Default::default())?; let k_store = handle.encode_key_for_store(&keys, Default::default())?;
if is_delete { if is_delete {
tx.tx.del(&k_store)?; tx.store_tx.del(&k_store)?;
} else { } else {
let vals: Vec<_> = val_indices let vals: Vec<_> = val_indices
.iter() .iter()
@ -294,7 +294,7 @@ impl<'s, S: Storage<'s>> Db<S> {
}) })
.try_collect()?; .try_collect()?;
let v_store = handle.encode_val_only_for_store(&vals, Default::default())?; 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 s_tx = sqlite_db.transact_write()?;
let mut tx = self.transact()?; let mut tx = self.transact()?;
let iter = tx.tx.range_scan(&[], &[0xFF]); let iter = tx.store_tx.range_scan(&[], &[0xFF]);
s_tx.tx.batch_put(iter)?; s_tx.store_tx.batch_put(iter)?;
tx.commit_tx()?; tx.commit_tx()?;
s_tx.commit_tx()?; s_tx.commit_tx()?;
Ok(()) Ok(())
@ -337,8 +337,8 @@ impl<'s, S: Storage<'s>> Db<S> {
store_id store_id
); );
} }
let iter = s_tx.tx.range_scan(&[], &[1]); let iter = s_tx.store_tx.range_scan(&[], &[1]);
tx.tx.batch_put(iter)?; tx.store_tx.batch_put(iter)?;
s_tx.commit_tx()?; s_tx.commit_tx()?;
tx.commit_tx()?; tx.commit_tx()?;
Ok(()) 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_lower = Tuple::default().encode_as_key(src_handle.id);
let src_upper = Tuple::default().encode_as_key(src_handle.id.next()); 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>)> { |src_pair| -> Result<(Vec<u8>, Vec<u8>)> {
let (mut src_k, mut src_v) = src_pair?; let (mut src_k, mut src_v) = src_pair?;
dst_handle.amend_key_prefix(&mut src_k); dst_handle.amend_key_prefix(&mut src_k);
@ -385,7 +385,7 @@ impl<'s, S: Storage<'s>> Db<S> {
Ok((src_k, src_v)) 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()?; src_tx.commit_tx()?;
@ -409,14 +409,14 @@ impl<'s, S: Storage<'s>> Db<S> {
} }
fn transact(&'s self) -> Result<SessionTx<'_>> { fn transact(&'s self) -> Result<SessionTx<'_>> {
let ret = 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(), relation_store_id: self.relation_store_id.clone(),
}; };
Ok(ret) Ok(ret)
} }
fn transact_write(&'s self) -> Result<SessionTx<'_>> { fn transact_write(&'s self) -> Result<SessionTx<'_>> {
let ret = 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(), relation_store_id: self.relation_store_id.clone(),
}; };
Ok(ret) 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 { ) -> impl Iterator<Item = Result<Tuple>> + 'a {
let lower = Tuple::default().encode_as_key(self.id); let lower = Tuple::default().encode_as_key(self.id);
let upper = Tuple::default().encode_as_key(self.id.next()); 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>( pub(crate) fn get<'a>(
@ -233,14 +233,14 @@ impl RelationHandle {
) -> Result<Option<Tuple>> { ) -> Result<Option<Tuple>> {
let key_data = key.encode_as_key(self.id); let key_data = key.encode_as_key(self.id);
Ok(tx Ok(tx
.tx .store_tx
.get(&key_data, false)? .get(&key_data, false)?
.map(|val_data| decode_tuple_from_kv(&key_data, &val_data))) .map(|val_data| decode_tuple_from_kv(&key_data, &val_data)))
} }
pub(crate) fn exists<'a>(&self, tx: &'a SessionTx<'_>, key: &[DataValue]) -> Result<bool> { pub(crate) fn exists<'a>(&self, tx: &'a SessionTx<'_>, key: &[DataValue]) -> Result<bool> {
let key_data = key.encode_as_key(self.id); 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>( pub(crate) fn scan_prefix<'a>(
@ -255,7 +255,7 @@ impl RelationHandle {
let prefix_encoded = lower.encode_as_key(self.id); let prefix_encoded = lower.encode_as_key(self.id);
let upper_encoded = upper.encode_as_key(self.id); let upper_encoded = upper.encode_as_key(self.id);
// RelationIterator::new(tx, &prefix_encoded, &upper_encoded) // 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>( pub(crate) fn scan_bounded_prefix<'a>(
&self, &self,
@ -271,7 +271,7 @@ impl RelationHandle {
upper_t.push(DataValue::Bot); upper_t.push(DataValue::Bot);
let lower_encoded = lower_t.encode_as_key(self.id); let lower_encoded = lower_t.encode_as_key(self.id);
let upper_encoded = upper_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> { pub(crate) fn relation_exists(&self, name: &str) -> Result<bool> {
let key = DataValue::Str(SmartString::from(name)); let key = DataValue::Str(SmartString::from(name));
let encoded = vec![key].encode_as_key(RelationId::SYSTEM); 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( pub(crate) fn set_relation_triggers(
&mut self, &mut self,
@ -324,7 +324,7 @@ impl<'a> SessionTx<'a> {
original original
.serialize(&mut Serializer::new(&mut meta_val).with_struct_map()) .serialize(&mut Serializer::new(&mut meta_val).with_struct_map())
.unwrap(); .unwrap();
self.tx.put(&name_key, &meta_val)?; self.store_tx.put(&name_key, &meta_val)?;
Ok(()) Ok(())
} }
@ -335,7 +335,7 @@ impl<'a> SessionTx<'a> {
let key = DataValue::Str(input_meta.name.name.clone()); let key = DataValue::Str(input_meta.name.name.clone());
let encoded = vec![key].encode_as_key(RelationId::SYSTEM); 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())) bail!(RelNameConflictError(input_meta.name.to_string()))
}; };
@ -351,17 +351,17 @@ impl<'a> SessionTx<'a> {
access_level: AccessLevel::Normal, 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 name_key = vec![DataValue::Str(meta.name.clone())].encode_as_key(RelationId::SYSTEM);
let mut meta_val = vec![]; let mut meta_val = vec![];
meta.serialize(&mut Serializer::new(&mut meta_val).with_struct_map()) meta.serialize(&mut Serializer::new(&mut meta_val).with_struct_map())
.unwrap(); .unwrap();
self.tx.put(&name_key, &meta_val)?; self.store_tx.put(&name_key, &meta_val)?;
let tuple = vec![DataValue::Null]; let tuple = vec![DataValue::Null];
let t_encoded = tuple.encode_as_key(RelationId::SYSTEM); 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) Ok(meta)
} }
pub(crate) fn get_relation(&self, name: &str, lock: bool) -> Result<RelationHandle> { 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 encoded = vec![key].encode_as_key(RelationId::SYSTEM);
let found = self let found = self
.tx .store_tx
.get(&encoded, lock)? .get(&encoded, lock)?
.ok_or_else(|| StoredRelationNotFoundError(name.to_string()))?; .ok_or_else(|| StoredRelationNotFoundError(name.to_string()))?;
let metadata = RelationHandle::decode(&found)?; let metadata = RelationHandle::decode(&found)?;
@ -391,7 +391,7 @@ impl<'a> SessionTx<'a> {
} }
let key = DataValue::Str(SmartString::from(name as &str)); let key = DataValue::Str(SmartString::from(name as &str));
let encoded = vec![key].encode_as_key(RelationId::SYSTEM); 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 lower_bound = Tuple::default().encode_as_key(store.id);
let upper_bound = Tuple::default().encode_as_key(store.id.next()); let upper_bound = Tuple::default().encode_as_key(store.id.next());
Ok((lower_bound, upper_bound)) Ok((lower_bound, upper_bound))
@ -405,7 +405,7 @@ impl<'a> SessionTx<'a> {
let mut meta_val = vec![]; let mut meta_val = vec![];
meta.serialize(&mut Serializer::new(&mut meta_val).with_struct_map()) meta.serialize(&mut Serializer::new(&mut meta_val).with_struct_map())
.unwrap(); .unwrap();
self.tx.put(&name_key, &meta_val)?; self.store_tx.put(&name_key, &meta_val)?;
Ok(()) Ok(())
} }
@ -413,7 +413,7 @@ impl<'a> SessionTx<'a> {
let new_key = DataValue::Str(new.name.clone()); let new_key = DataValue::Str(new.name.clone());
let new_encoded = vec![new_key].encode_as_key(RelationId::SYSTEM); 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())) bail!(RelNameConflictError(new.name.to_string()))
}; };
@ -432,8 +432,8 @@ impl<'a> SessionTx<'a> {
let mut meta_val = vec![]; let mut meta_val = vec![];
rel.serialize(&mut Serializer::new(&mut meta_val)).unwrap(); rel.serialize(&mut Serializer::new(&mut meta_val)).unwrap();
self.tx.del(&old_encoded)?; self.store_tx.del(&old_encoded)?;
self.tx.put(&new_encoded, &meta_val)?; self.store_tx.put(&new_encoded, &meta_val)?;
Ok(()) 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; use crate::storage::StoreTx;
pub struct SessionTx<'a> { 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>, 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> { pub(crate) fn load_last_relation_store_id(&self) -> Result<RelationId> {
let tuple = vec![DataValue::Null]; let tuple = vec![DataValue::Null];
let t_encoded = tuple.encode_as_key(RelationId::SYSTEM); 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 { Ok(match found {
None => RelationId::SYSTEM, None => RelationId::SYSTEM,
Some(slice) => RelationId::raw_decode(&slice), Some(slice) => RelationId::raw_decode(&slice),
@ -33,7 +33,7 @@ impl<'a> SessionTx<'a> {
} }
pub fn commit_tx(&mut self) -> Result<()> { pub fn commit_tx(&mut self) -> Result<()> {
self.tx.commit()?; self.store_tx.commit()?;
Ok(()) Ok(())
} }
} }

Write Preview
Loading…
Cancel
Save