Oh, and plus I am using xtdb 1.

If you pass the result of xt/submit-tx to xt/await-tx and then get a new DB value, you should be guaranteed to have the transaction results in the DB. e.g.:

(let [tx-result (xt/submit-tx node ...)
      _ (xt/await-tx node tx-result)
      db (xt/db node)]
  ...)

Awesome. Thanks.

(xt/q
         (xt/db node) '{:find [tc p1 user d value dd]
                        :where [[tc :type :timecard]
                                [d1 :project p1]
                                [p1 :value value]
                                [tc :email user]
                                [tc :duration d]
                                [tc :date dd]
                                [(clj-time.core/within? interval dd)]
                                ]
                        :order-by [[dd :desc]]
                        :in [interval]}
         interval)

Is one of d1, p1 or value supposed to join onto something from tc?

It's possible it's timing out because it will be returning every combination of tc and p1, for example:

(xt/submit-tx xtdb-node
              [[::xt/put {:xt/id :a :type :one}]
               [::xt/put {:xt/id :b :type :one}]
               [::xt/put {:xt/id :c :type :two}]
               [::xt/put {:xt/id :d :type :two}]])

(xt/q (xt/db xtdb-node)
      '{:find [id1 id2]
        :where [[id1 :type :one]
                [id2 :type :two]]})
; => #{[:a :d] [:b :d] [:a :c] [:b :c]}

I’ve now rewritten this query like so, which is a lot quicker, but still not as fast as I’d like:

(xt/q
         (xt/db node) '{:find [tc p1 user d value dd]
                        :where [[tc :deliverable d1]
                                [d1 :project p1]
                                [p1 :value value]
                                [tc :email user]
                                [tc :duration d]
                                [tc :date dd]
                                (matches tc interval)
                                ]
                        :rules [[(matches [tc] i)
                                 [tc :type :timecard]
                                 [tc :date dd]
                                 [(clj-time.core/within? i dd)]
                                 ]]
                        :order-by [[dd :desc]]
                        :in [interval]}
         interval)

Yes, in the example I submitted I had missed [tc :deliverable d1]

It was timing out in both versions (with tc :deliverable ,,, and without)

I tried replicating your issue with some generated data:

(let [projects
      (for [id (range 10)]
        {:xt/id (str "p-" id)
         :value (str "value-" id)})
      deliverables
      (for [id (range 100)]
        {:xt/id (str "d-" id)
         :project (str "p-" (rand-int 10))})
      timecards
      (for [id (range 10000)]
        {:xt/id (str "tc-" id)
         :type :timecard
         :deliverable (str "d-" (rand-int 100))
         :date (t/date-time (+ 2019 (rand-int 3)))
         :email (str id "@email.com")
         :duration :something})]
  (xt/submit-tx xtdb-node
                (->> (concat projects deliverables timecards)
                     (map (fn [doc] [::xt/put doc])))))

(time
  (xt/q (xt/db xtdb-node)
        '{:find [tc p1 user d value dd]
          :where [[tc :deliverable d1]
                  [d1 :project p1]
                  [p1 :value value]
                  [tc :email user]
                  [tc :duration d]
                  [tc :date dd]
                  (matches tc interval)]

          :rules [[(matches [tc] i)
                   [tc :type :timecard]
                   [tc :date dd]
                   [(clj-time.core/within? i dd)]]]

          :order-by [[dd :desc]]
          :in [interval]}
     (t/interval (t/date-time 2019) (t/date-time 2021))))
; (out) "Elapsed time: 479.920167 msecs"

(time
  (xt/q (xt/db xtdb-node)
        '{:find [tc p1 user d value dd]
          :where [[tc :deliverable d1]
                  [d1 :project p1]
                  [p1 :value value]
                  [tc :email user]
                  [tc :duration d]
                  [tc :date dd]
                  (matches tc interval)]

          :rules [[(matches [tc] i)
                   ;[tc :type :timecard]
                   [tc :date dd]
                   [(clj-time.core/within? i dd)]]]

          :order-by [[dd :desc]]
          :in [interval]}
     (t/interval (t/date-time 2019) (t/date-time 2021))))
; (out) "Elapsed time: 301.287542 msecs"

Btw, this query is just as fast and more readable imo:

(xt/q (xt/db xtdb-node)
      '{:find [(pull tc [:email :duration :date 
                         {:deliverable [{:project [:value]}]}])
               dd]
        :where [[tc :date dd]
                [(clj-time.core/within? interval dd)]]
        :order-by [[dd :desc]]
        :in [interval]}
      (t/interval (t/date-time 2019) (t/date-time 2021)))

That’s so interesting

Because I’m still seeing it slow on my system

Ah no, on a fresh database it’s very quick

And I have way less than 10,000 timecards

Hmm, how is your node setup?