How do I enforce uniqueness on an attribute that isn't the document ID? In order to enforce this properly, the read to check uniqueness has to happen in the same transaction scope as the write, and it looks like match is the only way to read in a write transaction scope. But match requires knowing the document ID of the conflicting document upfront? How does this work?

Hi Jenny. I think you need to create a transaction function.

You will be able to read the database to check that no documents exist with a conflicting attribute value.

The alternative, using a transaction function, would be fine, but I'm having trouble understanding how a Clojure JVM instance would bootstrap and load the transaction functions at startup. I happen to be using Mount. Would I just add a hook to mount/start to load all transaction functions? I'm paranoid about append-only versioning of code; when loading a transaction function, how can I ensure that it's either created new or is unchanged? Are there best practices for transaction function versioning?

Another way of asking this is what are best practices for using temporal versioning of transaction functions? Since the version of the transaction function being called in a write transaction will necessarily match the document being written, the logging is already there. Are there patterns that already leverage this?

Just think typing: given the reality of rolling restarts for version migrations of the Clojure client, would it make sense to add the Clojure client code version to the name of the transaction function to ensure the function being called actually corresponds to the client code calling it? I guess a more paranoid approach is actually maintaining a node ID, let's say on the Docker container, and using that node ID in the transaction function name. There aren't that many nodes relative to data size.

I was playing around with a tiny subset of the data from the "Learn XTDB Datalog Today" page (see https://nextjournal.com/try/learn-xtdb-datalog-today/learn-xtdb-datalog-today) trying to convert from XTDB 1.x to XTDB 2 EA. Here's the XTDB 1.x code:

(ns rlws.xtdb-datalog
  (:require [xtdb.api :as xt])
  (:gen-class))

(comment

  (def my-node (xt/start-node {}))

  (def my-docs
    [{:person/name "George Miller", :xt/id -142}
     {:person/name "George Ogilvie", :xt/id -147}
     {:movie/title "Mad Max Beyond Thunderdome", :movie/director [-142 -147], :xt/id -218}])

  (xt/submit-tx my-node (for [doc my-docs]
                          [:xtdb.api/put doc]))
  (xt/sync my-node)

  (defn q [query & args]
    (apply xt/q (xt/db my-node) query args))

  (q '{:find [title]
       :where [[_ :movie/title title]]})

  (q '{:find [director-eid]
       :where [[movie-eid :movie/title "Mad Max Beyond Thunderdome"]
               [movie-eid :movie/director director-eid]]})

  (q '{:find [director-name]
       :where [[movie-eid :movie/title "Mad Max Beyond Thunderdome"]
               [movie-eid :movie/director director-eid]
               [director-eid :person/name director-name]]})

;
  )

(ns rlws.xtdb2
  (:require [xtdb.client :as xt.client]
            [xtdb.api :as xt]))

(comment

  (def xtdb-node (xt.client/start-client ""))
  (xt/status xtdb-node)

  (def people
    [{:name "George Miller", :id -142}
     {:name "George Ogilvie", :id -147}])

  (defn person->put-person [{:keys [id name] :as person}]
    [:put :person {:xt/id id, :name name}])

  (doseq [person people]
    (xt/submit-tx xtdb-node [(person->put-person person)]))

  (def movies
    [{:title "Mad Max Beyond Thunderdome", :director [-142 -147], :id -218}])

  (defn movie->put-movie [{:keys [id title director] :as movie}]
    [:put :movie {:xt/id id, :title title, :director director}])

  (doseq [movie movies]
    (xt/submit-tx xtdb-node [(movie->put-movie movie)]))

  (xt/q xtdb-node '{:find [title]
                    :where [($ :movie [title])]})

  (xt/q xtdb-node '{:find [director-eid]
                    :where [($ :movie {:title "Mad Max Beyond Thunderdome", :director director-eid})]})

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; THIS DOES NOT WORK
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  (xt/q xtdb-node '{:find [director-name]
                    :where [($ :movie {:title "Mad Max Beyond Thunderdome", :director director-eid})
                            ($ :person {:xt/id director-eid, :name director-name})]})

  ;
  )

(ns rlws.xtdb2
  (:require [xtdb.client :as xt.client]
            [xtdb.api :as xt]))

(comment

  (def xtdb-node (xt.client/start-client ""))
  (xt/status xtdb-node)

  (def people
    [{:name "George Miller", :id -142}
     {:name "George Ogilvie", :id -147}])

  (defn person->put-person [{:keys [id name] :as person}]
    [:put :person {:xt/id id, :name name}])

  (doseq [person people]
    (xt/submit-tx xtdb-node [(person->put-person person)]))

  (def movies
    [{:title "Mad Max Beyond Thunderdome", :id -218}])

  (defn movie->put-movie [{:keys [id title] :as movie}]
    [:put :movie {:xt/id id, :title title}])

  (doseq [movie movies]
    (xt/submit-tx xtdb-node [(movie->put-movie movie)]))

  (def movie-directors
    [{:movie-id -218, :person-id -142, :id -300}
     {:movie-id -218, :person-id -147, :id -301}])

  (defn movie-director->put-movie-director [{:keys [id movie-id person-id] :as movie-director}]
    [:put :movie-director {:xt/id id, :movie-id movie-id, :person-id person-id}])

  (doseq [movie-director movie-directors]
    (xt/submit-tx xtdb-node [(movie-director->put-movie-director movie-director)]))

  (xt/q xtdb-node '{:find [person-name]
                    :where [($ :movie {:xt/id movie-id, :title "Mad Max Beyond Thunderdome"})
                            ($ :movie-director {:movie-id movie-id, :person-id person-id})
                            ($ :person {:xt/id person-id, :name person-name})]})

;
  )

@me1408 that's a good question. One suggestion I have is that you write your transaction function as a SCI script you can store in the database. That way, you only ever need a single transaction function that knows how to call sci.core/eval-string. I've spoken about this in a talk here: https://youtu.be/Cq4S7nO1KOo

The code for doing this can be found in this namespace: https://github.com/juxt-site/site/blob/master/server/src/juxt/site/operations.clj