clojure.lang.ExceptionInfo: Unable to resolve symbol: tx-data in this context
         cognitect.anomalies/category: :cognitect.anomalies/fault
          cognitect.anomalies/message: "Unable to resolve symbol: tx-data in this context"
         datomic.client-spi/exception: com.google.common.util.concurrent.UncheckedExecutionException
        datomic.client-spi/request-id: "38a341e3-784a-440e-a698-b22a985cc2a5"
    datomic.client-spi/root-exception: java.lang.RuntimeException
                                  dbs: [{:database-id "bc6549ca-5e23-47d0-bb13-b185f5c8d9f5",
                                         :t 9034,
                                         :next-t 9035,
                                         :history false}]

I’ve added clojure.core/compare to the :allow list in ion-config

Is this a known problem?

I’ll try to workaround using some other fn for now

false alarm. it was not the compare fn. it was another invalid rule

odd error message for a bad rule but at least I’m not blocked

Can I see the query?

Thanks but no need. It was an invalid rule that I needed to delete. The only mystery is why it didn't fail in tests but did on cloud

Are you using dev-local in your tests?

I think this is the same issue: https://clojurians.slack.com/archives/C03RZMDSH/p1683025237165599, fix should be in the works

Wow. That was quick and very helpful. Thanks!

Yep! We'll have this fixed in the next release. Discovered too late to get it into 6733.

> [[:three-args 1 2 3] ?result]]

this is not an invocation

of your db fn

it’s invoking the keyword (clojure keywords are functions)

you need to get that :db/fn object, or you can use the peer api d/invoke

e.g. [(datomic.api/invoke $ :three-args 1 2 3) ?result]

I think this might work too, but I’m not sure if the datalog parser is ok with it

[:three-args :db/fn ?three-args-fn][(?three-args-fn 1 2 3) ?result]

are you using database functions as a deployment method? otherwise you can just call arbitrary functions from within the query in on-prem

[(my-ns/three-args 1 2 3) ?result]

Thank you favila! Your first code sample worked, so I have proof of concept, at least. It sounds like calling namespaced functions directly within the query would work for me. I'll be filtering results based on the truthiness of my date checking function, that will work?

yes, you can call anything, even java interop, even type hints

predicate forms you can omit the return binding, and truthiness will determine if it unifies

[(my-pred ?x)] for e.g.

Wow, that's neat. I will try that. Looks like I started out by overengineering 😁 Thank you for your help.

the only caveat I have is that only the first level of the form is inspected for datalog variables

[(f (vector ?x))] won’t work for e.g.

Okay, got it I think. I don't think that will be an issue, but I will see.

the workaround is to adjust the signature of f to what you need, or to use multiple clauses binding an intermediate

the query runs in the same process and clojure environment as the rest of the peer, so def-ing a new thing and using it from a query requires no ceremony

Yes that works! Thank you so much, this is much, much easier to manage.

Just for completeness sake, comparing dates of entities with today is something you could already do pretty easily. If my memory serves me well; comparison is even implemented more efficiently than using clojure.core/> :

(d/q '{:find  [?e]
       :in    [$ ?now]
       :where [[?e :my-entity/date ?date]]
               [(> ?date ?now)]}
     db
     (Date.))

(although visually, it looks like you are invoking the > function)

Good call out, I read over that part of the OP

datomic datalog comparison operators work on any datomic attribute type except bytes. They’re not clojure.core/>, which don’t support those (e.g. (< (Date.) (Date.)) throws)

documented here: https://docs.datomic.com/pro/query/query.html#built-in-expressions

That's a neat idea, too. I will experiment with the simple built-in comparison operators. Thanks Lennart 🙂

Be sure to also check out ‘rules’, which is a way to reuse multiple clauses across queries.

Imo, using the built in stuff, together with rules, should already be powerful enough for the majority of queries you write ^^. Database functions are just a way for you to unlock even more superpowers ;)

Oh rules are cool! I was just thinking, man, wouldn't it be nice if I could build the :where up programatically...

You can! But I would strongly advice to try to get used to writing datomic queries statically (with rules to reuse!).

There are cases to think of to build queries programmatically, to use datomic functions, to do all sorts of magic stuff. But there is nothing as clear as a literal map with datalog clauses and the occasional rule.

(I don’t know how contentious this point is, haha)

Good point. I'm not getting too fancy just yet.