MoreThanText/morethantext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adjusted query to also accept a list of oids.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2025-11-07 12:08:08 -05:00
parent b665e63ad5
commit df4671761c
1 changed files with 114 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

286
src/message.rs
View File

@ -46,7 +46,7 @@ enum Action {
Create, Create,
Delete, Delete,
Error, Error,
On, OnAction,
Query, Query,
Records, Records,
Register, Register,
@ -62,7 +62,7 @@ impl From<MsgAction> for Action {
MsgAction::Create(_) => Action::Create, MsgAction::Create(_) => Action::Create,
MsgAction::Delete(_) => Action::Delete, MsgAction::Delete(_) => Action::Delete,
MsgAction::Error(_) => Action::Error, MsgAction::Error(_) => Action::Error,
MsgAction::On(_) => Action::On, MsgAction::OnAction(_) => Action::OnAction,
MsgAction::Query(_) => Action::Query, MsgAction::Query(_) => Action::Query,
MsgAction::Records(_) => Action::Records, MsgAction::Records(_) => Action::Records,
MsgAction::Register(_) => Action::Register, MsgAction::Register(_) => Action::Register,
@ -127,8 +127,8 @@ enum MsgAction {
// Alter // Alter
// Remove // Remove
Error(MTTError), Error(MTTError),
On(On), OnAction(OnAction),
Query(Query), Query(QueryType),
Records(RecordIter), Records(RecordIter),
Register(Register), Register(Register),
Reply(Reply), Reply(Reply),
@ -163,7 +163,7 @@ impl From<MTTError> for MsgAction {
impl From<Query> for MsgAction { impl From<Query> for MsgAction {
fn from(value: Query) -> Self { fn from(value: Query) -> Self {
MsgAction::Query(value) MsgAction::Query(QueryType::Query(value))
} }
} }
@ -329,7 +329,7 @@ mod messages {
#[test] #[test]
fn can_the_document_be_an_id() { fn can_the_document_be_an_id() {
let document = Uuid::new_v4(); let document = Uuid::new_v4();
let msg = Message::new(document.clone(), MsgAction::Query(Query::new())); let msg = Message::new(document.clone(), Query::new());
match msg.get_document_id() { match msg.get_document_id() {
NameType::ID(data) => assert_eq!(data, &document), NameType::ID(data) => assert_eq!(data, &document),
_ => unreachable!("should have been an id"), _ => unreachable!("should have been an id"),
@ -354,7 +354,7 @@ mod messages {
#[test] #[test]
fn Can_make_reply_message() { fn Can_make_reply_message() {
let name = Name::english("testing"); let name = Name::english("testing");
let msg = Message::new(name.clone(), MsgAction::Query(Query::new())); let msg = Message::new(name.clone(), Query::new());
let responce = Reply::new(); let responce = Reply::new();
let reply = msg.response(responce); let reply = msg.response(responce);
assert_eq!(reply.get_message_id(), msg.get_message_id()); assert_eq!(reply.get_message_id(), msg.get_message_id());
@ -371,7 +371,7 @@ mod messages {
#[test] #[test]
fn Can_make_error_message() { fn Can_make_error_message() {
let name = Name::english("testing"); let name = Name::english("testing");
let msg = Message::new(name.clone(), MsgAction::Query(Query::new())); let msg = Message::new(name.clone(), Query::new());
let err_msg = Uuid::new_v4().to_string(); let err_msg = Uuid::new_v4().to_string();
let result = msg.response(MTTError::DocumentNotFound(err_msg.clone())); let result = msg.response(MTTError::DocumentNotFound(err_msg.clone()));
@ -392,7 +392,7 @@ mod messages {
#[test] #[test]
fn can_make_a_response_message() { fn can_make_a_response_message() {
let doc_id = Uuid::new_v4(); let doc_id = Uuid::new_v4();
let msg = Message::new(doc_id.clone(), MsgAction::Query(Query::new())); let msg = Message::new(doc_id.clone(), Query::new());
let data = Uuid::new_v4().to_string(); let data = Uuid::new_v4().to_string();
let result1 = msg.response(MTTError::DocumentNotFound(data.clone())); let result1 = msg.response(MTTError::DocumentNotFound(data.clone()));
let result2 = msg.response(Reply::new()); let result2 = msg.response(Reply::new());
@ -2418,12 +2418,12 @@ enum OnType {
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct On { struct OnAction {
on_type: OnType, on_type: OnType,
oids: HashSet<Oid>, oids: HashSet<Oid>,
} }
impl On { impl OnAction {
fn new(on_type: OnType, oids: HashSet<Oid>) -> Self { fn new(on_type: OnType, oids: HashSet<Oid>) -> Self {
Self { Self {
on_type: on_type, on_type: on_type,
@ -2453,7 +2453,7 @@ mod ons {
while oids.len() < count { while oids.len() < count {
oids.insert(Oid::new()); oids.insert(Oid::new());
} }
let result = On::new(on_type.clone(), oids.clone()); let result = OnAction::new(on_type.clone(), oids.clone());
assert_eq!(result.get_type(), on_type); assert_eq!(result.get_type(), on_type);
assert_eq!(result.get_oids(), &oids); assert_eq!(result.get_oids(), &oids);
} }
@ -3205,6 +3205,24 @@ impl Operation {
} }
} }
#[derive(Clone, Debug)]
enum QueryType {
Query(Query),
Oids(HashSet<Oid>),
}
impl From<Query> for QueryType {
fn from(value: Query) -> Self {
QueryType::Query(value)
}
}
impl From<HashSet<Oid>> for QueryType {
fn from(value: HashSet<Oid>) -> Self {
QueryType::Oids(value)
}
}
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct Query { struct Query {
data: HashMap<NameType, Calculation>, data: HashMap<NameType, Calculation>,
@ -3710,12 +3728,6 @@ impl Document {
self.data.iter() self.data.iter()
} }
/*
fn iter(&self) -> DocIter {
DocIter::new(self)
}
*/
fn is_empty(&self) -> bool { fn is_empty(&self) -> bool {
self.data.is_empty() self.data.is_empty()
} }
@ -3779,47 +3791,45 @@ mod documents {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct Delete { struct Delete {
query: Query, query: QueryType,
} }
impl Delete { impl Delete {
fn new() -> Self { fn new<QT>(query: QT) -> Self
where
QT: Into<QueryType>,
{
Self { Self {
query: Query::new(), query: query.into(),
} }
} }
fn get_query(&self) -> &Query { fn get_query(&self) -> &QueryType {
&self.query &self.query
} }
fn get_query_mut(&mut self) -> &mut Query {
&mut self.query
}
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct Update { struct Update {
query: Query, query: QueryType,
values: Document, values: Document,
} }
impl Update { impl Update {
fn new() -> Self { fn new<QT>(query: QT) -> Self
where
QT: Into<QueryType>,
{
Self { Self {
query: Query::new(), query: query.into(),
values: Document::new(), values: Document::new(),
} }
} }
fn get_query(&self) -> &Query { fn get_query(&self) -> &QueryType {
&self.query &self.query
} }
fn get_query_mut(&mut self) -> &mut Query {
&mut self.query
}
fn get_values(&self) -> &Document { fn get_values(&self) -> &Document {
&self.values &self.values
} }
@ -4348,49 +4358,6 @@ impl DocumentFile {
records.insert(holder); records.insert(holder);
} }
records.into() records.into()
/*
for (field_id, value) in addition.iter() {
let id = match self.docdef.get_field_id(field_id) {
Ok(fid) => fid,
Err(err) => return MsgAction::Error(err),
};
}
let doc = addition.get_document();
for (field, value) in doc.iter() {
match self.validate(field, &value) {
Ok((id, data)) => {
holder.insert(id, data);
}
Err(err) => return MsgAction::Error(err),
}
}
let requested: HashSet<Uuid> = holder.keys().cloned().collect();
let all_fields = self.docdef.field_ids();
for field in all_fields.difference(&requested).cloned() {
match self.validate(field, &Field::None) {
Ok((id, data)) => {
holder.insert(id, data);
}
Err(err) => return MsgAction::Error(err),
}
}
let mut records = RecordIter::with_names(self.docdef.get_field_names().clone());
if !holder.is_empty() {
let mut oid = Oid::new();
while self.docs.contains_key(&oid) {
oid = Oid::new();
}
self.docs.insert(oid.clone(), holder.clone());
for (field_id, oids) in self.indexes.iter_mut() {
let value = holder.get(field_id).unwrap();
oids.internal_add(value, oid.clone());
}
records.insert(holder);
}
records.into()
*/
} }
fn delete(&mut self, delete: &Delete) -> MsgAction { fn delete(&mut self, delete: &Delete) -> MsgAction {
@ -4410,7 +4377,11 @@ impl DocumentFile {
records.into() records.into()
} }
fn run_query(&self, query: &Query) -> Result<HashSet<Oid>, MTTError> { fn run_query(&self, query_type: &QueryType) -> Result<HashSet<Oid>, MTTError> {
let query = match query_type {
QueryType::Query(qry) => qry,
QueryType::Oids(oids) => return Ok(oids.clone()),
};
let indexed_ids = self.indexes.index_ids(); let indexed_ids = self.indexes.index_ids();
let mut indexed: HashMap<Uuid, Calculation> = HashMap::new(); let mut indexed: HashMap<Uuid, Calculation> = HashMap::new();
let mut unindexed: HashMap<Uuid, Calculation> = HashMap::new(); let mut unindexed: HashMap<Uuid, Calculation> = HashMap::new();
@ -4451,7 +4422,7 @@ impl DocumentFile {
Ok(oids) Ok(oids)
} }
fn query(&self, query: &Query) -> MsgAction { fn query(&self, query: &QueryType) -> MsgAction {
let oids = match self.run_query(query) { let oids = match self.run_query(query) {
Ok(data) => data, Ok(data) => data,
Err(err) => return err.into(), Err(err) => return err.into(),
@ -4508,51 +4479,6 @@ impl DocumentFile {
output.insert(new_rec.clone()); output.insert(new_rec.clone());
} }
output.into() output.into()
/*
let mut changes: HashMap<Uuid, Field> = HashMap::new();
for (key, value) in update.get_values().iter() {
let (id, field) = match self.validate(key, &value) {
Ok(data) => data,
Err(err) => return err.into(),
};
changes.insert(id, field);
}
let oids = match self.run_query(update.get_query()) {
Ok(result) => result,
Err(err) => return err.into(),
};
let mut holder: HashMap<Oid, InternalRecord> = HashMap::new();
for oid in oids.iter() {
holder.insert(oid.clone(), self.docs.get(oid).unwrap().clone());
}
let mut removes: Vec<(Uuid, Field, Oid)> = Vec::new();
let mut indexes = self.docdef.create_indexes();
for (oid, rec) in holder.iter_mut() {
for (field_id, value) in changes.iter() {
removes.push((
field_id.clone(),
rec.get(field_id).unwrap().clone(),
oid.clone(),
));
match indexes.add_to_index(&field_id, value.clone(), oid.clone()) {
Ok(_) => {}
Err(err) => return err.into(),
}
rec.insert(field_id.clone(), value.clone());
}
}
let mut output = RecordIter::with_names(self.docdef.get_field_names().clone());
for (field_id, value, oid) in removes.iter() {
self.indexes.remove_from_index(field_id, value, oid);
}
self.indexes.append(&indexes);
for (oid, record) in holder.iter() {
self.docs.insert(oid.clone(), record.clone());
output.insert(record.clone());
}
output.into()
*/
} }
} }
@ -4704,10 +4630,10 @@ mod document_files {
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();
let msg_actions = [ let msg_actions = [
MsgAction::Addition(Addition::new()), MsgAction::Addition(Addition::new()),
MsgAction::Delete(Delete::new()), MsgAction::Delete(Delete::new(Query::new())),
MsgAction::Query(Query::new()), MsgAction::Query(Query::new().into()),
MsgAction::Show, MsgAction::Show,
MsgAction::Update(Update::new()), MsgAction::Update(Update::new(Query::new())),
]; ];
for msg_action in msg_actions.iter() { for msg_action in msg_actions.iter() {
let msg = Message::new(name.clone(), msg_action.clone()); let msg = Message::new(name.clone(), msg_action.clone());
@ -4753,10 +4679,10 @@ mod document_files {
let msg_actions = [ let msg_actions = [
MsgAction::Addition(Addition::new()), MsgAction::Addition(Addition::new()),
MsgAction::Create(DocDef::new(name.clone())), MsgAction::Create(DocDef::new(name.clone())),
MsgAction::Delete(Delete::new()), MsgAction::Delete(Delete::new(Query::new())),
MsgAction::Query(Query::new()), MsgAction::Query(Query::new().into()),
MsgAction::Show, MsgAction::Show,
MsgAction::Update(Update::new()), MsgAction::Update(Update::new(Query::new())),
]; ];
let mut msgs: HashMap<Uuid, MsgAction> = HashMap::new(); let mut msgs: HashMap<Uuid, MsgAction> = HashMap::new();
for msg_action in msg_actions.iter() { for msg_action in msg_actions.iter() {
@ -5306,10 +5232,13 @@ mod document_files {
for id in ids.iter() { for id in ids.iter() {
doc.populate([id.clone().into()].to_vec()); doc.populate([id.clone().into()].to_vec());
} }
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(id); calc.add_value(CalcValue::Existing(FieldType::Uuid))
update.get_query_mut().add(Name::english("field0"), calc); .unwrap();
calc.add_value(Uuid::nil()).unwrap();
let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update update
.get_values_mut() .get_values_mut()
.add_field(Name::english("field0"), Uuid::nil()); .add_field(Name::english("field0"), Uuid::nil());
@ -5331,12 +5260,13 @@ mod document_files {
let new = "new"; let new = "new";
let id = Uuid::new_v4(); let id = Uuid::new_v4();
doc.populate([id.into(), old.into()].to_vec()); doc.populate([id.into(), old.into()].to_vec());
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(CalcValue::Existing(FieldType::Uuid)) calc.add_value(CalcValue::Existing(FieldType::Uuid))
.unwrap(); .unwrap();
calc.add_value(id.clone()).unwrap(); calc.add_value(id.clone()).unwrap();
update.get_query_mut().add(Name::english("field0"), calc); let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update update
.get_values_mut() .get_values_mut()
.add_field(Name::english("field1"), new); .add_field(Name::english("field1"), new);
@ -5368,16 +5298,18 @@ mod document_files {
let old = "old"; let old = "old";
let new = "new"; let new = "new";
let count = 5; let count = 5;
let field_count = count.clone().try_into().unwrap();
let picked = 3; let picked = 3;
for i in 0..count { for i in 0..field_count {
doc.populate([i.into(), old.into()].to_vec()); doc.populate([i.into(), old.into()].to_vec());
} }
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(picked.clone()).unwrap();
calc.add_value(CalcValue::Existing(FieldType::Integer)) calc.add_value(CalcValue::Existing(FieldType::Integer))
.unwrap(); .unwrap();
update.get_query_mut().add(Name::english("field0"), calc); calc.add_value(picked.clone()).unwrap();
let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update update
.get_values_mut() .get_values_mut()
.add_field(Name::english("field1"), new); .add_field(Name::english("field1"), new);
@ -5403,7 +5335,7 @@ mod document_files {
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Records(docs) => { MsgAction::Records(docs) => {
assert_eq!(docs.len(), 5, "should have one entry"); assert_eq!(docs.len(), count, "should have one entry");
for doc in docs.clone() { for doc in docs.clone() {
if doc.get(Name::english("field0")).unwrap() == picked.into() { if doc.get(Name::english("field0")).unwrap() == picked.into() {
assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into()); assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into());
@ -5428,12 +5360,13 @@ mod document_files {
for i in 0..count { for i in 0..count {
doc.populate([picked.into(), old.into()].to_vec()); doc.populate([picked.into(), old.into()].to_vec());
} }
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(picked.clone()).unwrap();
calc.add_value(CalcValue::Existing(FieldType::Integer)) calc.add_value(CalcValue::Existing(FieldType::Integer))
.unwrap(); .unwrap();
update.get_query_mut().add(Name::english("field0"), calc); calc.add_value(picked.clone()).unwrap();
let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update update
.get_values_mut() .get_values_mut()
.add_field(Name::english("field1"), new); .add_field(Name::english("field1"), new);
@ -5443,7 +5376,7 @@ mod document_files {
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Records(docs) => { MsgAction::Records(docs) => {
assert_eq!(docs.len(), 5, "should have one entry"); assert_eq!(docs.len(), count, "should have one entry");
for doc in docs.clone() { for doc in docs.clone() {
assert_eq!(doc.get(Name::english("field0")).unwrap(), picked.into()); assert_eq!(doc.get(Name::english("field0")).unwrap(), picked.into());
assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into()); assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into());
@ -5465,10 +5398,7 @@ mod document_files {
let new = "new"; let new = "new";
let bad_name = Name::english("wrong"); let bad_name = Name::english("wrong");
doc.populate([id.into(), old.into()].to_vec()); doc.populate([id.into(), old.into()].to_vec());
let mut update = Update::new(); let mut update = Update::new(Query::new());
let mut calc = Calculation::new(Operand::Equal);
calc.add_value(id.clone());
update.get_query_mut().add(Name::english("field0"), calc);
update.get_values_mut().add_field(bad_name.clone(), new); update.get_values_mut().add_field(bad_name.clone(), new);
doc.send(update).unwrap(); doc.send(update).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@ -5490,11 +5420,14 @@ mod document_files {
let old = "old"; let old = "old";
let new = Uuid::nil(); let new = Uuid::nil();
doc.populate([id.into(), old.into()].to_vec()); doc.populate([id.into(), old.into()].to_vec());
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(id.clone()); calc.add_value(CalcValue::Existing(FieldType::Uuid))
calc.add_value(CalcValue::Existing(FieldType::Uuid)); .unwrap();
update.get_query_mut().add(Name::english("field0"), calc); calc.add_value(id.clone()).unwrap();
let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update update
.get_values_mut() .get_values_mut()
.add_field(Name::english("field1"), new); .add_field(Name::english("field1"), new);
@ -5524,11 +5457,14 @@ mod document_files {
let old = 3; let old = 3;
let new = 5; let new = 5;
test_doc.populate([old.into()].to_vec()); test_doc.populate([old.into()].to_vec());
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(old); calc.add_value(CalcValue::Existing(FieldType::Integer))
calc.add_value(CalcValue::Existing(FieldType::Integer)); .unwrap();
update.get_query_mut().add(fname.clone(), calc); calc.add_value(old.clone()).unwrap();
let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update.get_values_mut().add_field(&fname, new); update.get_values_mut().add_field(&fname, new);
test_doc.send(update).unwrap(); test_doc.send(update).unwrap();
test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@ -5606,11 +5542,14 @@ mod document_files {
let fold: Field = old.into(); let fold: Field = old.into();
let fnew: Field = new.into(); let fnew: Field = new.into();
doc.populate([old.into()].to_vec()); doc.populate([old.into()].to_vec());
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(old); calc.add_value(CalcValue::Existing(FieldType::StaticString))
calc.add_value(CalcValue::Existing(FieldType::StaticString)); .unwrap();
update.get_query_mut().add(fname.clone(), calc); calc.add_value(old.clone()).unwrap();
let mut query = Query::new();
query.add(Name::english("field0"), calc);
let mut update = Update::new(query);
update.get_values_mut().add_field(fname.clone(), new); update.get_values_mut().add_field(fname.clone(), new);
doc.send(update).unwrap(); doc.send(update).unwrap();
doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@ -5661,12 +5600,14 @@ mod document_files {
for id in ids.iter() { for id in ids.iter() {
doc.populate([id.clone().into(), data.into()].to_vec()); doc.populate([id.clone().into(), data.into()].to_vec());
} }
let mut update = Update::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(data).unwrap();
calc.add_value(CalcValue::Existing(FieldType::StaticString)) calc.add_value(CalcValue::Existing(FieldType::StaticString))
.unwrap(); .unwrap();
update.get_query_mut().add(&f1name, calc); calc.add_value(data).unwrap();
let mut query = Query::new();
query.add(&f1name, calc);
let mut update = Update::new(query);
update.get_values_mut().add_field(&f0name, holder.clone()); update.get_values_mut().add_field(&f0name, holder.clone());
doc.send(update).unwrap(); doc.send(update).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@ -5674,7 +5615,7 @@ mod document_files {
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err {
MTTError::FieldDuplicate => {} MTTError::FieldDuplicate => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err), _ => unreachable!("got {:?}: should have gotten field duplicate", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),
} }
@ -5741,8 +5682,7 @@ mod document_files {
calc.add_value(CalcValue::Existing(FieldType::Integer)); calc.add_value(CalcValue::Existing(FieldType::Integer));
let mut query = Query::new(); let mut query = Query::new();
query.add(&fname, calc); query.add(&fname, calc);
let mut delete = Delete::new(); let mut delete = Delete::new(query.clone());
*delete.get_query_mut() = query.clone();
doc.send(delete).unwrap(); doc.send(delete).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
@ -5772,11 +5712,12 @@ mod document_files {
let field_name = Name::english("wrong"); let field_name = Name::english("wrong");
let mut doc = TestDocument::new([FieldType::Integer].to_vec()); let mut doc = TestDocument::new([FieldType::Integer].to_vec());
doc.start(); doc.start();
let mut delete = Delete::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(CalcValue::Existing(FieldType::Integer));
calc.add_value(1); calc.add_value(1);
let query = delete.get_query_mut(); let mut query = Query::new();
query.add(field_name.clone(), calc); query.add(field_name.clone(), calc);
let delete = Delete::new(query);
doc.send(delete).unwrap(); doc.send(delete).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
@ -5797,7 +5738,7 @@ mod document_files {
doc.get_docdef_mut().add_index(&fname, IndexType::Unique); doc.get_docdef_mut().add_index(&fname, IndexType::Unique);
doc.start(); doc.start();
doc.populate([value.into()].to_vec()); doc.populate([value.into()].to_vec());
doc.send(Delete::new()); doc.send(Delete::new(Query::new()));
doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let mut addition = Addition::new(); let mut addition = Addition::new();
addition.add_field(&fname, value.clone()); addition.add_field(&fname, value.clone());
@ -5852,7 +5793,7 @@ mod createdocs {
MsgAction::Reply(_) => {} MsgAction::Reply(_) => {}
_ => unreachable!("got {:?}: should have been a reply.", result1.get_action()), _ => unreachable!("got {:?}: should have been a reply.", result1.get_action()),
} }
let msg2 = Message::new(name, MsgAction::Query(Query::new())); let msg2 = Message::new(name, Query::new());
queue.send(msg2.clone()).unwrap(); queue.send(msg2.clone()).unwrap();
let result2 = rx.recv_timeout(TIMEOUT).unwrap(); let result2 = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result2.get_message_id(), msg2.get_message_id()); assert_eq!(result2.get_message_id(), msg2.get_message_id());
@ -5925,6 +5866,7 @@ impl Clock {
#[cfg(test)] #[cfg(test)]
mod clocks { mod clocks {
use super::*; use super::*;
use chrono::TimeDelta;
static TIMEOUT: Duration = Duration::from_millis(1500); static TIMEOUT: Duration = Duration::from_millis(1500);
@ -5946,8 +5888,8 @@ mod clocks {
holder.push(rx.recv_timeout(TIMEOUT).unwrap()); holder.push(rx.recv_timeout(TIMEOUT).unwrap());
} }
let end = Utc::now(); let end = Utc::now();
assert!((end - start) > chrono::TimeDelta::seconds(1)); assert!((end - start) > TimeDelta::seconds(1));
assert!((end - start) < chrono::TimeDelta::seconds(2)); assert!((end - start) < TimeDelta::seconds(2));
for msg in holder.iter() { for msg in holder.iter() {
let name_id = msg.get_document_id(); let name_id = msg.get_document_id();
match name_id { match name_id {