clippy + docs

Author: amitayh

Cargo.lock

@@ -9,13 +9,80 @@ A simplified [Datomic](https://www.datomic.com/) clone built in Rust.
 ## What is this?
 
 This is a side project I've been working on, trying to mimic Datomic's functionality using Rust.
-I'm a complete novice with Rust, so I wanted to try learn it with something that feels real: dependencies, tests, etc.
+I'm a complete novice with Rust, so I wanted to try learn it with something that feels real:
+dependencies, tests, etc.
 
 ### Why Datomic?
 
  * Datomic has a well defined and documented API, which can guide me.
  * Datomic is closed source, so I don't know the implementatoin details of the real product.
- * Datomic is a database - meaning it has to deal with a lot of real-world complexity (I/O, concurrency).
- * Datomic (and datalog) introduced very different and interesting conpects compared to traditional databases.
- * This project can grow in complexity as much as I want to, depending on what I'll end up implementing.
- * Challenging myself to translate an API initially designed for a dynamic language (Clojure) to a staticly typed language.
+ * Datomic is a database - meaning it has to deal with a lot of real-world complexity (I/O,
+   concurrency).
+ * Datomic (and datalog) introduced very different and interesting conpects compared to traditional
+   databases.
+ * This project can grow in complexity as much as I want to, depending on what I'll end up
+   implementing.
+ * Challenging myself to translate an API initially designed for a dynamic language (Clojure) to a
+   staticly typed language.
+
+## Query Engine
+
+The project implements a Datalog-style query engine that supports:
+
+### Core Features
+
+* Pattern matching against the database using entity-attribute-value-transaction patterns
+* Variable binding and resolution across multiple clauses
+* Custom predicate filtering
+* Aggregation support (count, min, max, sum, average, count-distinct)
+* Attribute name resolution
+* Streaming result processing
+* Early filtering through predicate evaluation
+
+### Example Query
+
+```rust
+// Find all people born after 1980
+let query = Query::new()
+    .find(Find::variable("?person"))
+    .where(Clause::new()
+        .with_entity(Pattern::variable("?person"))
+        .with_attribute(Pattern::ident("person/born"))
+        .with_value(Pattern::variable("?born")))
+    .value_pred(
+        "?born",
+        |value| matches!(value, &Value::I64(born) if born > 1980),
+    );
+```
+
+## Transactor
+
+The transactor is a core component that handles all data modifications in the database. It
+implements Datomic's transactional model with ACID guarantees.
+
+### Features
+
+* **Entity Operations**
+  - Create new entities with auto-generated IDs
+  - Update existing entities by ID
+  - Support for temporary IDs within transactions
+  - Assert or retract attribute values
+
+* **Transaction Processing**
+  - Atomic execution of multiple operations
+  - Automatic timestamp recording for each transaction
+  - Value type validation against schema
+  - Uniqueness constraints enforcement
+  - Cardinality handling (one vs. many)
+
+### Example Transaction
+
+```rust
+let tx = Transaction::new()
+    .with(EntityOperation::on_new()
+        .assert("person/name", "John Doe")
+        .assert("person/age", 30))
+    .with(EntityOperation::on_temp_id("employee-1")
+        .assert("employee/role", "Developer")
+        .assert("employee/start-date", "2024-01-01"));
+```

README.md

@@ -8,6 +8,7 @@ pub mod tx;
 #[cfg(test)]
 mod tests {
     use googletest::prelude::*;
+    use std::result::Result;
     use std::time::SystemTime;
 
     use crate::clock::Instant;
@@ -79,7 +80,7 @@ mod tests {
                 .query(&self.storage, &self.resolver, query)
                 .await
                 .expect("Unable to query");
-            results.filter_map(|result| result.ok()).collect()
+            results.filter_map(Result::ok).collect()
         }
 
         async fn try_query(
@@ -909,10 +910,10 @@ mod tests {
                             .with_attribute(Pattern::ident("person/name"))
                             .with_value(Pattern::variable("?name")),
                     )
-                    .value_pred("?born", |value| match value {
-                        &Value::I64(born) => born > 1940,
-                        _ => false,
-                    }),
+                    .value_pred(
+                        "?born",
+                        |value| matches!(value, &Value::I64(born) if born > 1940),
+                    ),
             )
             .await;
 

src/lib.rs

@@ -2,7 +2,6 @@ use crate::datom::Value;
 use crate::query::*;
 use rust_decimal::Decimal;
 use std::collections::HashSet;
-use std::u64;
 
 #[derive(Clone)]
 pub enum AggregationState<'a> {

src/query/aggregation.rs

@@ -14,7 +14,6 @@ use crate::storage::attribute_resolver::ResolveError;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::sync::Arc;
-use std::u64;
 use thiserror::Error;
 
 /// An assignment is a mapping between variables and values such that the clauses are satisfied.
@@ -72,7 +71,7 @@ impl Query {
     ) -> Self {
         self.pred(move |assignment| {
             let value = assignment.get(variable);
-            value.map_or(true, &predicate)
+            value.is_none_or(&predicate)
         })
     }
 }

src/query/mod.rs

@@ -128,14 +128,14 @@ mod tests {
         }
     }
 
-    impl<'a> WriteStorage for CountingStorage {
+    impl WriteStorage for CountingStorage {
         type Error = <InMemoryStorage as WriteStorage>::Error;
         fn save(&mut self, datoms: &[Datom]) -> Result<(), Self::Error> {
             self.inner.save(datoms)
         }
     }
 
-    fn create_storage<'a>() -> CountingStorage {
+    fn create_storage() -> CountingStorage {
         let mut storage = CountingStorage::new();
         storage.save(&default_datoms()).unwrap();
         storage

src/storage/attribute_resolver.rs

@@ -1,6 +1,5 @@
 use std::marker::PhantomData;
 use std::path::Path;
-use std::u64;
 
 use rocksdb::*;
 use thiserror::Error;

src/storage/disk.rs

@@ -75,9 +75,9 @@ impl Restricts {
 
     pub fn test(&self, datom: &Datom) -> bool {
         datom.op == Op::Assert
-            && self.entity.map_or(true, |e| datom.entity == e)
-            && self.attribute.map_or(true, |a| datom.attribute == a)
-            && self.value.as_ref().map_or(true, |v| &datom.value == v)
+            && self.entity.is_none_or(|e| datom.entity == e)
+            && self.attribute.is_none_or(|a| datom.attribute == a)
+            && self.value.as_ref().is_none_or(|v| &datom.value == v)
             && self.tx.test(datom.tx)
     }
 }
@@ -91,8 +91,7 @@ pub enum TxRestrict {
 impl TxRestrict {
     pub fn value(&self) -> u64 {
         match *self {
-            TxRestrict::Exact(tx) => tx,
-            TxRestrict::AtMost(tx) => tx,
+            TxRestrict::Exact(tx) | TxRestrict::AtMost(tx) => tx,
         }
     }
 

src/storage/restricts.rs

@@ -3,7 +3,6 @@ use std::fmt::Debug;
 use std::io::Cursor;
 use std::io::Read;
 use std::mem::size_of;
-use std::u16;
 use thiserror::Error;
 
 use crate::datom::*;
@@ -383,10 +382,9 @@ mod value {
             match self {
                 Self::Nil => 0,
                 Self::Decimal(value) => value.size_hint(),
-                Self::U64(value) => value.size_hint(),
+                Self::U64(value) | Self::Ref(value) => value.size_hint(),
                 Self::I64(value) => value.size_hint(),
                 Self::Str(value) => value.size_hint(),
-                Self::Ref(value) => value.size_hint(),
             }
         }
 

src/storage/serde.rs

@@ -1,13 +1,12 @@
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::u64;
 
 use crate::clock::Instant;
 use crate::schema::attribute::*;
 use crate::schema::*;
 use crate::storage::attribute_resolver::*;
-use crate::storage::restricts::*;
-use crate::storage::*;
+use crate::storage::restricts::Restricts;
+use crate::storage::ReadStorage;
 use crate::tx::{
     AttributeValue, Datom, EntityOperation, OperatedEntity, Result, Transaction, TransactionError,
     TransctionResult, Value, ValueType,