Intermediate

Database db = conn.db();

// Pull with bounded recursion
Map result = (Map) Peer.pull(
    db,
    "[:person/name {:person/manager 2}]",
    Util.list(":person/email", "grace@example.com")
);
// => {:person/name "Grace Kim"
//     :person/manager {:person/name "Frank Lee"
//                      :person/manager {:person/name "Eve Johnson"}}}
// => {:person/manager N} recursively follows manager references N levels deep

// Pull with unbounded recursion
Map result2 = (Map) Peer.pull(
    db,
    "[:person/name {:person/manager ...}]",
    Util.list(":person/email", "grace@example.com")
);
// => Follows manager references until no more managers
// => ... means "recurse indefinitely"
// => Returns nested maps up the management chain

// Pull reverse references recursively
Map result3 = (Map) Peer.pull(
    db,
    "[{:person/_manager ...}]",
    Util.list(":person/email", "eve@example.com")
);
// => {:person/_manager
//     [{:person/name "Frank Lee"
//       :person/_manager [{:person/name "Grace Kim"}]}]}
// => Recursively pulls all reports (direct and indirect)

(def db (d/db conn))

;; Pull with bounded recursion
(d/pull db
  '[:person/name
    {:person/manager 2}]
  [:person/email "grace@example.com"])
;; => {:person/name "Grace Kim"
;;     :person/manager {:person/name "Frank Lee"
;;                      :person/manager {:person/name "Eve Johnson"}}}
;; => {:person/manager N} recursively follows manager references N levels deep

;; Pull with unbounded recursion
(d/pull db
  '[:person/name
    {:person/manager ...}]
  [:person/email "grace@example.com"])
;; => Follows manager references until no more managers
;; => ... means "recurse indefinitely"
;; => Returns nested maps up the management chain

;; Pull reverse references recursively
(d/pull db
  '[{:person/_manager ...}]
  [:person/email "eve@example.com"])
;; => {:person/_manager
;;     [{:person/name "Frank Lee"
;;       :person/_manager [{:person/name "Grace Kim"}]}]}
;; => Recursively pulls all reports (direct and indirect)

// Pull with attribute aliases
Map result = (Map) Peer.pull(
    db,
    "[(:person/name :as :fullName) " +
    " (:person/email :as :emailAddress) " +
    " (:person/age :as :yearsOld)]",
    Util.list(":person/email", "alice@example.com")
);
// => {:fullName "Alice Johnson"
//     :emailAddress "alice@example.com"
//     :yearsOld 33}
// => (:attribute :as :new-key) renames attribute in result

// Pull with default and limit
Map result2 = (Map) Peer.pull(
    db,
    "[(default :person/phone \"No phone\") " +
    " (limit :person/favorite-colors 2)]",
    Util.list(":person/email", "alice@example.com")
);
// => {:person/phone "No phone"
//     :person/favorite-colors #{"blue" "green"}}
// => (default :attr value) provides fallback when attribute absent
// => (limit :attr n) returns max n values from cardinality-many attribute

;; Pull with attribute aliases
(d/pull db
  '[(:person/name :as :fullName)
    (:person/email :as :emailAddress)
    (:person/age :as :yearsOld)]
  [:person/email "alice@example.com"])
;; => {:fullName "Alice Johnson"
;;     :emailAddress "alice@example.com"
;;     :yearsOld 33}
;; => (:attribute :as :new-key) renames attribute in result

;; Pull with default and limit
(d/pull db
  '[(default :person/phone "No phone")
    (limit :person/favorite-colors 2)]
  [:person/email "alice@example.com"])
;; => {:person/phone "No phone"
;;     :person/favorite-colors #{"blue" "green"}}
;; => (default :attr value) provides fallback when attribute absent
;; => (limit :attr n) returns max n values from cardinality-many attribute

// Custom aggregate: standard deviation
// Define as Java function implementing clojure.lang.IFn
public static class StdDev implements clojure.lang.IFn {
    public Object invoke(Object vals) {
        Collection<Number> numbers = (Collection<Number>) vals;
        double sum = 0;
        for (Number n : numbers) sum += n.doubleValue();
        double mean = sum / numbers.size();
        double variance = 0;
        for (Number n : numbers) {
            variance += Math.pow(n.doubleValue() - mean, 2);
        }
        variance /= numbers.size();
        return Math.sqrt(variance);
    }
}

// Register and use aggregate in query
Collection results = Peer.q(
    "[:find (my.ns.StdDev/invoke ?age) " +
    " :where [?e :person/age ?age]]",
    db
);
// => [[2.449...]]
// => Custom Java function called as aggregate
// => Function receives collection of all ?age values

// Note: For production, define Java classes as static methods
// and reference them in queries via namespace/method syntax

;; Custom aggregate: standard deviation
(defn std-dev
  [vals]
  (let [n (count vals)
        mean (/ (reduce + vals) n)
        variance (/ (reduce + (map #(Math/pow (- % mean) 2) vals)) n)]
    (Math/sqrt variance)))

;; Register as aggregate in query
(d/q '[:find (my-ns/std-dev ?age)
       :where [?e :person/age ?age]]
     db)
;; => [[2.449...]]
;; => (namespace/function ?var) calls custom aggregate
;; => Function receives collection of all ?age values

;; Custom aggregate: concatenate strings
(defn concat-names
  [names]
  (clojure.string/join ", " (sort names)))

(d/q '[:find (my-ns/concat-names ?name)
       :where [?e :person/name ?name]]
     db)
;; => [["Alice Johnson, Bob Smith, Dave Lee, ..."]]
;; => Aggregates can return any type

// EAVT: Entity-Attribute-Value-Transaction (primary index)
Iterable eavtDatoms = db.datoms(
    Peer.EAVT,
    Util.list(":person/email", "alice@example.com")
);
// => Iterable of datoms for specific entity
// => Datom: [entity-id attribute value tx-id added?]

// Take first 3 datoms
Iterator it = eavtDatoms.iterator();
for (int i = 0; i < 3 && it.hasNext(); i++) {
    datomic.Datom datom = (datomic.Datom) it.next();
    // datom.e() => entity ID
    // datom.a() => attribute
    // datom.v() => value
    // datom.tx() => transaction ID
}
// => Shows all attributes for Alice

// AVET: Attribute-Value-Entity-Transaction (value lookup)
Iterable avetDatoms = db.datoms(
    Peer.AVET,
    ":person/age",
    28
);
// => Finds all entities with age = 28
// => Efficient for value-based lookups

// Convert datoms to entities
for (Object obj : avetDatoms) {
    datomic.Datom datom = (datomic.Datom) obj;
    Entity entity = db.entity(datom.e());
    // Work with entity
}

// AEVT: Attribute-Entity-Value-Transaction (attribute scan)
Iterable aevtDatoms = db.datoms(
    Peer.AEVT,
    ":person/name"
);
// => All entities with :person/name attribute
// => Useful for "find all entities of type X" queries

;; EAVT: Entity-Attribute-Value-Transaction (primary index)
(def eavt-datoms
  (d/datoms db :eavt [:person/email "alice@example.com"]))
;; => Lazy sequence of datoms for specific entity
;; => Datom: [entity-id attribute value tx-id added?]

(take 3 eavt-datoms)
;; => (#datom[17592186045418 :person/name "Alice Johnson" 13194139534313 true]
;;     #datom[17592186045418 :person/email "alice@example.com" 13194139534313 true]
;;     #datom[17592186045418 :person/age 33 13194139534320 true])
;; => Shows all attributes for Alice

;; AVET: Attribute-Value-Entity-Transaction (value lookup)
(def avet-datoms
  (d/datoms db :avet :person/age 28))
;; => Finds all entities with age = 28
;; => Efficient for value-based lookups

(map #(d/entity db (:e %)) avet-datoms)
;; => (entity-for-bob ...)
;; => Convert datoms to entities

;; AEVT: Attribute-Entity-Value-Transaction (attribute scan)
(def aevt-datoms
  (d/datoms db :aevt :person/name))
;; => All entities with :person/name attribute
;; => Useful for "find all entities of type X" queries

// Find people with ages between 28 and 32 (inclusive)
Iterable rangeDatoms = db.indexRange(":person/age", 28, 32);
// => Iterable of datoms with age in [28, 32]
// => More efficient than query with predicate for large datasets

// Extract entities from range
for (Object obj : rangeDatoms) {
    datomic.Datom datom = (datomic.Datom) obj;
    Object value = datom.v();
    Object entityId = datom.e();
    // value => age (28, 29, 30, etc.)
    // entityId => entity ID
}

// String prefix search
Iterable nameDatoms = db.indexRange(":person/name", "A", "B");
// => Finds all names starting with "A" (up to but not including "B")
// => String ranges useful for prefix searches

;; Find people with ages between 28 and 32 (inclusive)
(d/index-range db :person/age 28 32)
;; => Lazy sequence of datoms with age in [28, 32]
;; => More efficient than query with predicate for large datasets

;; Extract entities from range
(map (fn [datom] [(:v datom) (:e datom)])
     (d/index-range db :person/age 28 32))
;; => ([28 entity-id-bob] [33 entity-id-alice])
;; => (:v datom) gets value, (:e datom) gets entity ID

;; String prefix search
(d/index-range db :person/name "A" "B")
;; => Finds all names starting with "A" (up to but not including "B")
;; => String ranges useful for prefix searches

// Initial transaction (creates new entity)
conn.transact(
    Util.list(
        Util.map(":person/email", "igor@example.com",
                 ":person/name", "Igor Volkov",
                 ":person/age", 40)
    )
).get();

Database db = conn.db();
Object age = Peer.q(
    "[:find ?age . :where [?e :person/email \"igor@example.com\"] [?e :person/age ?age]]",
    db
);
// => 40

// Upsert (updates existing entity)
conn.transact(
    Util.list(
        Util.map(":person/email", "igor@example.com",
                 ":person/age", 41)
    )
).get();
// => Matches existing entity by :person/email (unique identity)
// => Updates age from 40 to 41 (doesn't create duplicate)

db = conn.db();
age = Peer.q(
    "[:find ?age . :where [?e :person/email \"igor@example.com\"] [?e :person/age ?age]]",
    db
);
// => 41

// Upsert creates if not exists
conn.transact(
    Util.list(
        Util.map(":person/email", "judy@example.com",
                 ":person/name", "Judy Chen",
                 ":person/age", 29)
    )
).get();
// => No existing entity with judy@example.com
// => Creates new entity

;; Initial transaction (creates new entity)
@(d/transact conn
   [{:person/email "igor@example.com"
     :person/name "Igor Volkov"
     :person/age 40}])

(def db (d/db conn))
(d/q '[:find ?age . :where [?e :person/email "igor@example.com"] [?e :person/age ?age]] db)
;; => 40

;; Upsert (updates existing entity)
@(d/transact conn
   [{:person/email "igor@example.com"
     :person/age 41}])
;; => Matches existing entity by :person/email (unique identity)
;; => Updates age from 40 to 41 (doesn't create duplicate)

(def db (d/db conn))
(d/q '[:find ?age . :where [?e :person/email "igor@example.com"] [?e :person/age ?age]] db)
;; => 41

;; Upsert creates if not exists
@(d/transact conn
   [{:person/email "judy@example.com"
     :person/name "Judy Chen"
     :person/age 29}])
;; => No existing entity with judy@example.com
;; => Creates new entity

// Generate batch data
List batchPeople = new ArrayList();
for (int i = 0; i < 1000; i++) {
    batchPeople.add(
        Util.map(":person/email", "user" + i + "@example.com",
                 ":person/name", "User " + i,
                 ":person/age", 20 + (int)(Math.random() * 40))
    );
}

// Single transaction with 1000 entities
long start = System.currentTimeMillis();
conn.transact(batchPeople).get();
long elapsed = System.currentTimeMillis() - start;
// => "Elapsed time: 120 msecs" (example)
// => Much faster than 1000 individual transactions
// => All 1000 entities created atomically

// Verify batch insert
Database db = conn.db();
Object count = Peer.q(
    "[:find (count ?e) . :where [?e :person/email]]",
    db
);
// => 1008 (original people + 1000 batch)

;; Generate batch data
(def batch-people
  (for [i (range 1000)]
    {:person/email (str "user" i "@example.com")
     :person/name (str "User " i)
     :person/age (+ 20 (rand-int 40))}))

;; Single transaction with 1000 entities
(time
  @(d/transact conn batch-people))
;; => "Elapsed time: 120 msecs" (example)
;; => Much faster than 1000 individual transactions
;; => All 1000 entities created atomically

;; Verify batch insert
(def db (d/db conn))
(d/q '[:find (count ?e) . :where [?e :person/email]] db)
;; => 1008 (original people + 1000 batch)

// Alice has favorite colors: blue, green, purple
Database db = conn.db();
Entity alice = db.entity(Util.list(":person/email", "alice@example.com"));
alice.get(":person/favorite-colors");
// => #{"blue" "green" "purple"}

// Retract only "blue"
conn.transact(
    Util.list(
        Util.list(":db/retract",
                  Util.list(":person/email", "alice@example.com"),
                  ":person/favorite-colors",
                  "blue")
    )
).get();

// Verify selective retraction
db = conn.db();
alice = db.entity(Util.list(":person/email", "alice@example.com"));
alice.get(":person/favorite-colors");
// => #{"green" "purple"}
// => "blue" removed, others remain

// Add new color
conn.transact(
    Util.list(
        Util.list(":db/add",
                  Util.list(":person/email", "alice@example.com"),
                  ":person/favorite-colors",
                  "red")
    )
).get();

alice = conn.db().entity(Util.list(":person/email", "alice@example.com"));
alice.get(":person/favorite-colors");
// => #{"green" "purple" "red"}

;; Alice has favorite colors: blue, green, purple
(def db (d/db conn))
(:person/favorite-colors (d/entity db [:person/email "alice@example.com"]))
;; => #{"blue" "green" "purple"}

;; Retract only "blue"
@(d/transact conn
   [[:db/retract [:person/email "alice@example.com"] :person/favorite-colors "blue"]])

;; Verify selective retraction
(def db (d/db conn))
(:person/favorite-colors (d/entity db [:person/email "alice@example.com"]))
;; => #{"green" "purple"}
;; => "blue" removed, others remain

;; Add new color
@(d/transact conn
   [[:db/add [:person/email "alice@example.com"] :person/favorite-colors "red"]])

(:person/favorite-colors (d/entity (d/db conn) [:person/email "alice@example.com"]))
;; => #{"green" "purple" "red"}

// Note: Transaction functions are typically written in Clojure
// For Java, implement logic in application layer before transaction

// Alternative: Call application logic then transact
Database db = conn.db();
Entity alice = db.entity(Util.list(":person/email", "alice@example.com"));
int currentAge = (Integer) alice.get(":person/age");
// => 33

// Compute new value
int newAge = currentAge + 1;

// Execute conditional transaction
conn.transact(
    Util.list(
        Util.map(":db/id", Util.list(":person/email", "alice@example.com"),
                 ":person/age", newAge)
    )
).get();

alice = conn.db().entity(Util.list(":person/email", "alice@example.com"));
alice.get(":person/age");
// => 34

// For complex conditional logic, use :db/cas (compare-and-swap)
// or implement logic in Java before calling transact()

;; Define transaction function in database
(def increment-age-fn
  {:db/ident :my/increment-age
   :db/fn (d/function
            '{:lang :clojure
              :params [db email]
              :code (let [person (d/entity db [:person/email email])
                          current-age (:person/age person)]
                      [[:db/add [:person/email email]
                                :person/age
                                (inc current-age)]])})})

@(d/transact conn [increment-age-fn])
;; => Stores function in database
;; => :db/fn attribute holds function definition

;; Call transaction function
(def db (d/db conn))
(:person/age (d/entity db [:person/email "alice@example.com"]))
;; => 33

@(d/transact conn [[:my/increment-age "alice@example.com"]])
;; => Invokes function inside transaction
;; => Function reads current age, generates transaction data

(:person/age (d/entity (d/db conn) [:person/email "alice@example.com"]))
;; => 34

Database db = conn.db();

// Speculative transaction
Map withResult = db.with(
    Util.list(
        Util.map(":person/email", "test@example.com",
                 ":person/name", "Test User",
                 ":person/age", 25)
    )
);
Database speculativeDb = (Database) withResult.get(Keyword.intern("db-after"));
// => with returns same structure as transact but doesn't commit
// => :db-after is hypothetical database value

// Query speculative database
Object name = Peer.q(
    "[:find ?name . :where [?e :person/email \"test@example.com\"] [?e :person/name ?name]]",
    speculativeDb
);
// => "Test User"
// => Data exists in speculative database

// Original database unchanged
Object name2 = Peer.q(
    "[:find ?name . :where [?e :person/email \"test@example.com\"] [?e :person/name ?name]]",
    db
);
// => null
// => Original database has no test user

// Use with for validation
try {
    Map result = db.with(
        Util.list(
            Util.map(":person/email", "duplicate@example.com",
                     ":person/name", "Duplicate")
        )
    );
    // Transaction valid, can proceed
} catch (Exception e) {
    // Transaction would fail, handle error
}

(def db (d/db conn))

;; Speculative transaction
(def speculative-db
  (:db-after (d/with db
               [{:person/email "test@example.com"
                 :person/name "Test User"
                 :person/age 25}])))
;; => with returns same structure as transact but doesn't commit
;; => (:db-after ...) is hypothetical database value

;; Query speculative database
(d/q '[:find ?name . :where [?e :person/email "test@example.com"] [?e :person/name ?name]]
     speculative-db)
;; => "Test User"
;; => Data exists in speculative database

;; Original database unchanged
(d/q '[:find ?name . :where [?e :person/email "test@example.com"] [?e :person/name ?name]]
     db)
;; => nil
;; => Original database has no test user

;; Use with for validation
(defn validate-transaction [tx-data]
  (try
    (let [result (d/with (d/db conn) tx-data)]
      {:valid true :db-after (:db-after result)})
    (catch Exception e
      {:valid false :error (.getMessage e)})))

(validate-transaction [{:person/email "duplicate@example.com"
                        :person/name "Duplicate"}])
;; => {:valid true :db-after ...}
;; => Transaction would succeed

// Get transaction log
datomic.Log log = conn.log();
// => Log is append-only structure of all transactions

// Read recent transactions
Iterable recentTxs = log.txRange(null, null);
// => Iterable of transaction maps
// => null null means "from beginning to end"

// Examine first transaction
Iterator it = recentTxs.iterator();
if (it.hasNext()) {
    Map firstTx = (Map) it.next();
    Object t = firstTx.get(Keyword.intern("t"));
    // => Transaction's basis-t value

    Collection data = (Collection) firstTx.get(Keyword.intern("data"));
    // => Collection of datoms added in this transaction
    // => [datom[entity attr value tx added?] ...]
}

// Filter transactions by time range
long txIdStart = Peer.toTx(1000);
long txIdEnd = Peer.toTx(2000);
Iterable timeRangeTxs = log.txRange(txIdStart, txIdEnd);
// => Transactions between basis-t 1000 and 2000

;; Get transaction log
(def log (d/log conn))
;; => Log is append-only structure of all transactions

;; Read recent transactions
(def recent-txs (d/tx-range log nil nil))
;; => Lazy sequence of transaction maps
;; => nil nil means "from beginning to end"

;; Examine first transaction
(def first-tx (first recent-txs))
(:t first-tx)
;; => Transaction's basis-t value

(:data first-tx)
;; => Vector of datoms added in this transaction
;; => [#datom[entity attr value tx added?] ...]

;; Filter transactions by time range
(def tx-id-start (d/t->tx 1000))
(def tx-id-end (d/t->tx 2000))
(def time-range-txs (d/tx-range log tx-id-start tx-id-end))
;; => Transactions between basis-t 1000 and 2000

// Find people with any age (don't need age value)
Collection results = Peer.q(
    "[:find ?name " +
    " :where [?e :person/name ?name] " +
    "        [?e :person/age _]]",
    db
);
// => Returns names of people who have age attribute
// => _ matches any value but doesn't bind it
// => More efficient than binding unused variable

// Find entities with at least 3 attributes
Collection results2 = Peer.q(
    "[:find ?e " +
    " :where [?e :person/name _] " +
    "        [?e :person/email _] " +
    "        [?e :person/age _]]",
    db
);
// => Finds entities with all three attributes
// => Doesn't bind attribute values (not needed)

;; Find people with any age (don't need age value)
(d/q '[:find ?name
       :where [?e :person/name ?name]
              [?e :person/age _]]
     db)
;; => Returns names of people who have age attribute
;; => _ matches any value but doesn't bind it
;; => More efficient than binding unused variable

;; Find entities with at least 3 attributes
(d/q '[:find ?e
       :where [?e :person/name _]
              [?e :person/email _]
              [?e :person/age _]]
     db)
;; => Finds entities with all three attributes
;; => Doesn't bind attribute values (not needed)

// Note: :offset and :limit require Datomic Pro or Cloud
// For Datomic Free, implement pagination in application code

// Get all people
Collection allPeople = Peer.q(
    "[:find ?name ?email " +
    " :where [?e :person/name ?name] " +
    "        [?e :person/email ?email]]",
    db
);

// Application-level pagination - Page 1 (first 10 results)
int pageSize = 10;
int pageNum = 1;
List results = new ArrayList();
Iterator it = allPeople.iterator();
int skip = pageSize * (pageNum - 1);
int take = pageSize;
int index = 0;
while (it.hasNext()) {
    Object item = it.next();
    if (index >= skip && index < skip + take) {
        results.add(item);
    }
    index++;
    if (index >= skip + take) break;
}
// => First 10 people

// Page 2 (next 10 results) - adjust skip and take values

;; Note: :offset and :limit require Datomic Pro or Cloud
;; For Datomic Free, implement pagination in application code

;; Application-level pagination
(defn paginate-results [query-results page-size page-num]
  (->> query-results
       (drop (* page-size (dec page-num)))
       (take page-size)))

;; Get all people
(def all-people
  (d/q '[:find ?name ?email
         :where [?e :person/name ?name]
                [?e :person/email ?email]]
       db))

;; Page 1 (first 10 results)
(paginate-results all-people 10 1)
;; => First 10 people

;; Page 2 (next 10 results)
(paginate-results all-people 10 2)
;; => Results 11-20

// Add fulltext attribute
conn.transact(
    Util.list(
        Util.map(":db/ident", ":person/bio",
                 ":db/valueType", ":db.type/string",
                 ":db/cardinality", ":db.cardinality/one",
                 ":db/fulltext", true,
                 ":db/doc", "Person biography (fulltext searchable)")
    )
).get();

// Add bios
conn.transact(
    Util.list(
        Util.map(":person/email", "alice@example.com",
                 ":person/bio", "Software engineer passionate about functional programming and databases"),
        Util.map(":person/email", "bob@example.com",
                 ":person/bio", "Product manager with experience in e-commerce and retail")
    )
).get();

// Fulltext search
Database db = conn.db();
Collection results = Peer.q(
    "[:find ?name ?bio " +
    " :in $ ?search " +
    " :where [(fulltext $ :person/bio ?search) [[?e ?bio]]] " +
    "        [?e :person/name ?name]]",
    db,
    "functional programming"
);
// => #{["Alice Johnson" "Software engineer passionate about functional programming and databases"]}
// => (fulltext $ attr search-term) finds matches
// => Returns [entity text-value] tuples

;; Add fulltext attribute
@(d/transact conn
   [{:db/ident       :person/bio
     :db/valueType   :db.type/string
     :db/cardinality :db.cardinality/one
     :db/fulltext    true
     :db/doc         "Person biography (fulltext searchable)"}])

;; Add bios
@(d/transact conn
   [{:person/email "alice@example.com"
     :person/bio "Software engineer passionate about functional programming and databases"}
    {:person/email "bob@example.com"
     :person/bio "Product manager with experience in e-commerce and retail"}])

;; Fulltext search
(def db (d/db conn))
(d/q '[:find ?name ?bio
       :in $ ?search
       :where [(fulltext $ :person/bio ?search) [[?e ?bio]]]
              [?e :person/name ?name]]
     db
     "functional programming")
;; => #{["Alice Johnson" "Software engineer passionate about functional programming and databases"]}
;; => (fulltext $ attr search-term) finds matches
;; => Returns [entity text-value] tuples

// Query when Alice's age was last updated
Collection results = Peer.q(
    "[:find ?tx ?instant " +
    " :where [?e :person/email \"alice@example.com\"] " +
    "        [?e :person/age _ ?tx] " +
    "        [?tx :db/txInstant ?instant]]",
    db
);
// => [[tx-id #inst "2026-01-29T12:34:56.789-00:00"]]
// => ?tx is transaction entity ID
// => :db/txInstant is transaction timestamp

// Find all changes to Alice in last hour
Date oneHourAgo = new Date(new Date().getTime() - (60 * 60 * 1000));

Collection results2 = Peer.q(
    "[:find ?attr ?value ?instant " +
    " :in $ ?email ?since " +
    " :where [?e :person/email ?email] " +
    "        [?e ?a ?value ?tx] " +
    "        [?tx :db/txInstant ?instant] " +
    "        [(> ?instant ?since)] " +
    "        [?a :db/ident ?attr]]",
    db,
    "alice@example.com",
    oneHourAgo
);
// => Returns all attribute changes in last hour with timestamps

;; Query when Alice's age was last updated
(d/q '[:find ?tx ?instant
       :where [?e :person/email "alice@example.com"]
              [?e :person/age _ ?tx]
              [?tx :db/txInstant ?instant]]
     db)
;; => [[tx-id #inst "2026-01-29T12:34:56.789-00:00"]]
;; => ?tx is transaction entity ID
;; => :db/txInstant is transaction timestamp

;; Find all changes to Alice in last hour
(def one-hour-ago
  (java.util.Date. (- (.getTime (java.util.Date.)) (* 60 60 1000))))

(d/q '[:find ?attr ?value ?instant
       :in $ ?email ?since
       :where [?e :person/email ?email]
              [?e ?a ?value ?tx]
              [?tx :db/txInstant ?instant]
              [(> ?instant ?since)]
              [?a :db/ident ?attr]]
     db
     "alice@example.com"
     one-hour-ago)
;; => Returns all attribute changes in last hour with timestamps

// Define project schema
conn.transact(
    Util.list(
        Util.map(":db/ident", ":project/name",
                 ":db/valueType", ":db.type/string",
                 ":db/cardinality", ":db.cardinality/one",
                 ":db/unique", ":db.unique/identity"),
        Util.map(":db/ident", ":project/members",
                 ":db/valueType", ":db.type/ref",
                 ":db/cardinality", ":db.cardinality/many",
                 ":db/doc", "Project members (many-to-many with persons)")
    )
).get();

// Create projects with members
conn.transact(
    Util.list(
        Util.map(":project/name", "Project Alpha",
                 ":project/members", Util.list(
                     Util.list(":person/email", "alice@example.com"),
                     Util.list(":person/email", "bob@example.com"))),
        Util.map(":project/name", "Project Beta",
                 ":project/members", Util.list(
                     Util.list(":person/email", "alice@example.com"),
                     Util.list(":person/email", "dave@example.com")))
    )
).get();

// Query: Find all projects for Alice
Database db = conn.db();
Collection results = Peer.q(
    "[:find ?project-name " +
    " :where [?p :person/email \"alice@example.com\"] " +
    "        [?proj :project/members ?p] " +
    "        [?proj :project/name ?project-name]]",
    db
);
// => #{["Project Alpha"] ["Project Beta"]}
// => Alice is in both projects

// Query: Find all members of Project Alpha
Collection results2 = Peer.q(
    "[:find ?member-name " +
    " :where [?proj :project/name \"Project Alpha\"] " +
    "        [?proj :project/members ?member] " +
    "        [?member :person/name ?member-name]]",
    db
);
// => #{["Alice Johnson"] ["Bob Smith"]}

;; Define project schema
@(d/transact conn
   [{:db/ident       :project/name
     :db/valueType   :db.type/string
     :db/cardinality :db.cardinality/one
     :db/unique      :db.unique/identity}
    {:db/ident       :project/members
     :db/valueType   :db.type/ref
     :db/cardinality :db.cardinality/many
     :db/doc         "Project members (many-to-many with persons)"}])

;; Create projects with members
@(d/transact conn
   [{:project/name "Project Alpha"
     :project/members [[:person/email "alice@example.com"]
                       [:person/email "bob@example.com"]]}
    {:project/name "Project Beta"
     :project/members [[:person/email "alice@example.com"]
                       [:person/email "dave@example.com"]]}])

;; Query: Find all projects for Alice
(def db (d/db conn))
(d/q '[:find ?project-name
       :where [?p :person/email "alice@example.com"]
              [?proj :project/members ?p]
              [?proj :project/name ?project-name]]
     db)
;; => #{["Project Alpha"] ["Project Beta"]}
;; => Alice is in both projects

;; Query: Find all members of Project Alpha
(d/q '[:find ?member-name
       :where [?proj :project/name "Project Alpha"]
              [?proj :project/members ?member]
              [?member :person/name ?member-name]]
     db)
;; => #{["Alice Johnson"] ["Bob Smith"]}

// Find all "person" entities (have :person/name)
Collection results = Peer.q(
    "[:find ?e " +
    " :where [?e :person/name]]",
    db
);
// => Returns all person entity IDs
// => Attribute presence implies type

// Find all "project" entities
Collection results2 = Peer.q(
    "[:find ?e " +
    " :where [?e :project/name]]",
    db
);
// => Returns all project entity IDs

// Polymorphic query: entities with name (person OR project)
Collection results3 = Peer.q(
    "[:find ?name " +
    " :where (or [?e :person/name ?name] " +
    "            [?e :project/name ?name])]",
    db
);
// => Returns names from both persons and projects
// => Datomic uses attribute namespaces to organize, not enforce types

;; Find all "person" entities (have :person/name)
(d/q '[:find ?e
       :where [?e :person/name]]
     db)
;; => Returns all person entity IDs
;; => Attribute presence implies type

;; Find all "project" entities
(d/q '[:find ?e
       :where [?e :project/name]]
     db)
;; => Returns all project entity IDs

;; Polymorphic query: entities with name (person OR project)
(d/q '[:find ?name
       :where (or [?e :person/name ?name]
                  [?e :project/name ?name])]
     db)
;; => Returns names from both persons and projects
;; => Datomic uses attribute namespaces to organize, not enforce types

// Inefficient: starts with unbound variable
long start = System.currentTimeMillis();
Collection results = Peer.q(
    "[:find ?name " +
    " :where [?e :person/age ?age] " +
    "        [(> ?age 30)] " +
    "        [?e :person/name ?name]]",
    db
);
long elapsed = System.currentTimeMillis() - start;
// => Scans all ages, then filters, then joins to names
// => Slower on large datasets

// Efficient: start with most selective pattern
start = System.currentTimeMillis();
Collection results2 = Peer.q(
    "[:find ?name " +
    " :where [?e :person/name ?name] " +
    "        [?e :person/age ?age] " +
    "        [(> ?age 30)]]",
    db
);
elapsed = System.currentTimeMillis() - start;
// => Scans names first (uses AEVT index), then filters by age
// => Generally faster due to better index usage

// Most efficient: use indexed value if available
start = System.currentTimeMillis();
Collection results3 = Peer.q(
    "[:find ?name " +
    " :where [?e :person/email \"alice@example.com\"] " +
    "        [?e :person/name ?name]]",
    db
);
elapsed = System.currentTimeMillis() - start;
// => Uses AVET index on unique :person/email
// => Near-instant lookup

;; Inefficient: starts with unbound variable
(time
  (d/q '[:find ?name
         :where [?e :person/age ?age]
                [(> ?age 30)]
                [?e :person/name ?name]]
       db))
;; => Scans all ages, then filters, then joins to names
;; => Slower on large datasets

;; Efficient: start with most selective pattern
(time
  (d/q '[:find ?name
         :where [?e :person/name ?name]
                [?e :person/age ?age]
                [(> ?age 30)]]
       db))
;; => Scans names first (uses AEVT index), then filters by age
;; => Generally faster due to better index usage

;; Most efficient: use indexed value if available
(time
  (d/q '[:find ?name
         :where [?e :person/email "alice@example.com"]
                [?e :person/name ?name]]
       db))
;; => Uses AVET index on unique :person/email
;; => Near-instant lookup

// Entity map syntax (convenient for create/update)
conn.transact(
    Util.list(
        Util.map(":person/email", "kyle@example.com",
                 ":person/name", "Kyle Brown",
                 ":person/age", 31)
    )
).get();
// => Concise, readable
// => Automatically generates :db/add operations

// Explicit datom syntax (precise control)
Object kyleId = Util.list(":person/email", "kyle@example.com");
conn.transact(
    Util.list(
        Util.list(":db/add", kyleId, ":person/age", 32),
        Util.list(":db/retract", kyleId, ":person/age", 31)
    )
).get();
// => Explicit operations: add new value, retract old value
// => More verbose but complete control

// Mix both styles
conn.transact(
    Util.list(
        Util.map(":person/email", "lisa@example.com",
                 ":person/name", "Lisa Wong"),
        Util.list(":db/add",
                  Util.list(":person/email", "lisa@example.com"),
                  ":person/age",
                  27)
    )
).get();
// => Entity map creates/updates
// => Explicit datom adds additional attribute