I don’t know if this is supported but I have used the peer on jdk 11 without problems. (or maybe there were problems getting it to work but I’ve forgotten them and they are non-issues now)

I’ve never successfully used a transactor on java 11

(I probably encountered minor opposition and decided it was safer not to even try to work through it, but honestly I don’t remember clearly)

The latest release should run on jdk 11

If you have any issues or problems doing so, please let us know

The peer or the transactor can run on jdk 11, or both?

both

Great, thank you

I did and I'm failing to pull it back in with lein. I've asked Github for support

Haven't tried on github but we've got it published on a private S3 repo via mvn deploy-file without too much trouble

@U08QZ7Y5S yeah I did that with other libraries too. This did result in AWS credentials in the project files as something else got too involved. I could probably do better here. Now I was hoping Github would be a nice alternative. Maybe it needs some time

[(get-else ?e :ref-attr ?not-found) ?v] -> ?v is your “:db/id” (if I understand your question correctly?)

The reverse form of an attr isn’t recognized in query clauses; reverse the clause order instead: [?v :attr ?e] instead of [?e :_attr ?v]

Thanks, but reversing order makes me disappointed how to use get-else. I'l try you first suggestion

get-else only works on cardinality-one attributes; the reverse would be cardinality-many

so it wouldn’t work anyway

you could do an explicit d/datoms and check it for emptiness

(d/q '[:find [(count-distinct ?item)]
         :in $
         :where
         [?o :order/pickup-items ?item]
         [?r :recycle/items ?item]]
       db)
=> [541]

(d/q '[:find [(count-distinct ?item)]
         :in $
         :where
         [?o :order/pickup-items ?item]
        ;  [?r :recycle/items ?item]
         ]
       db)
=> [1561]

I want all 1561 rows but with ?r when it present. What should I do?

use pull?

Mmmm, maybe I have to read more about it

I’m not 100 % sure what you want the output to be

something like [[?item (?r1 ?r2 ,,,)],,,]?

i.e. all the ?r reachable from an item?

No. I want all 1561 items as a separate rows, but if item choosen also in recycle, I want its id, otherwise false by get-else or something similar

how is that different from what I said?

I do not want any aggregations

if you don’t aggregate, you may get [item1 r1] [item1 r2] etc

i.e. item repeats

it is not bad, I can process them in clojure

and if item doesn’t join to an r, what would you treat that as? having a single r?

with some sentinel?

something default

maybe false

get-else works good, but not with db/id , only with values

what do you ultimately want? {:item item-eid :recycles #{recycle1 recycle2,,,}}?

but if item doesn’t have a recycle, what would it be? {:item item-eid :recycles #{:default}}?

^^ this is what I don’t get

[item1 order1 rec1] [item1 order2 rec2] [item2 order2 false] ....

you mean [item2 order3 false] for that last one?

what you wrote isn’t possible

it can be the same order

nm I missed that item1->2

if your query is simple, consider two queries and cat them together

`’[:find ?item ?o ?r :where [?o :order/pickup-items ?item] [?r :recycle/items ?item]]` if they have an item

unfortunately my query sufficiently complex, I typed a simple example above for only to show the problem

ok, then you can use d/datoms directly

e.g a rule like this:

Yes, code above extracts ONLY if item has recycle

Simply speaking I want get-else for db/id

it’s not that simple because of cardinality

ok, thanks again, I'l think about another way

nm you don’t need datoms, a rule can do it

(d/q
  '[:find ?i ?o ?r
    :where
    [?o :order/pickup-items ?i]
    (or-join [?i ?r]
      (and
        (not [_ :recycle/items ?i])
        [(ground false) ?r])
      [?r :recycle/items ?i])
    ]
  '[[o1 :order/pickup-items i1]
    [o2 :order/pickup-items i1]
    [o2 :order/pickup-items i2]
    [r1 :recycle/items i1]
    [r2 :recycle/items i1]]
  )
=> #{[i2 o2 false] [i1 o1 r2] [i1 o2 r2] [i1 o1 r1] [i1 o2 r1]}

my other approach was call (d/datoms), perform a bounded count, and either destructure if nonzero or bind to your sentinel if zero

I’m still not convinced this is advisable, but there you go

Thanks, I'l try you suggestion in a some minutes

First impression that it is great and what I need!

I have not discovered or-join magic with ground yet )

the map form of a transaction is purely syntactic sugar for a bunch of [:db/add ...] clauses (which is what everything ultimately expands to. There’s no syntactic sugar for :db/retract

when you say {:db/id e :attr v} in a tx, you are only adding assertions to the entity, you are not making the entity look like your map.

that said there are some transaction functions floating around which can make your entity “look like” the argument, i.e. do whatever adds/retracts are necessary atomically

here’s some I wrote a long time ago, I’m sure there are better ones now: https://gist.github.com/favila/8ce31de4b2cb04cf202687c6a8fa4c94

Okay copy copy. With that, let me give you a little more context. So I have a vector of vectors with 3 values in them. I was very easily able to zipmap keys into those vectors and turn them into a vector of maps, then boom I could add them to the database. Now I have that same vector of vectors and I want to instead retract that information from the database. Should I just put all that information through a function which returns [:db/retract ...] until I have a bunch of those?

Looking at that code now. Would that solve the problem given the context I just shared? If so, I'll run with that. Otherwise, it's a bit complicated for me to off-the-bat understand what it's doing. I'm a bit new to Clojure I must admit

yes, just generate retractions

{:db/id id :attr v} => [:db/add id :attr v]