I tried

(or 
  (and [?known :core/entity ?entity] 
       [?known :user/id]]) 
  [(identity nil) ?known]
)

but that is obviously not the way to do it 🙂

?entity is bound in the where query before that clause

Heh, one way that I found out kind of works is [(identity true) ?known] in the other leg of that or predicate that returns N+1 matches for ones that have something and 1 for the ones that did not have anything...

so (dec (count ?known)) gives the result I expected.

Hey, I don't have time to think about this properly right now (I'll try to circle back sometime later), but this might give some ideas: https://github.com/xtdb/xtdb/blob/065f41945daed67c6742a5c480864eaa24f6e48d/test/test/xtdb/query_test.clj#L1812

On the surface it looks like that or-join it returns N+1 as well if I adapt this to my query, adding the restriction to the other leg with (not [?known :user/id])

You might want to check get-attr as well

Thanks! It was mentioned in the docs but https://github.com/xtdb/xtdb/blob/e2f51ed99fc2716faa8ad254c0b18166c937b134/test/test/xtdb/query_test.clj#L1054 this did not open so didn't bother looking into it 😄

user> (xt/submit-tx node [[::xt/put {:xt/id "test1" :foo 1 :have-it 42}] [::xt/put {:xt/id "test2" :foo 2}] [::xt/put {:xt/id "test3" :foo 3 :have-it 666}]])

user> (xt/q (xt/db node) '[:find ?e ?foo ?it :where [?e :foo ?foo] [(get-attr ?e :have-it) [?it]]])
#{["test3" 3 666] ["test1" 1 42] ["test2" 2 nil]}

Sounds like this does not fit my current use case. I'm essentially trying to find related documents that has a link to another entity through a key. My query above "works", if it is efficient or idiomatic – that is up for debate 😄 Thanks for your input – another new shining thing in my toolbelt 🙂

> so (dec (count ?known)) gives the result I expected. If you can share the full query (that gives the expected result) we'll be able to help more easily on the "efficient or idiomatic" front

Sure! 🙂

{
            :find [?role ?group-name ?type ?name ?skill (dec (count ?knows))],
            :where [[?dept :core/role ?role]
                    [?dept :core/type ?type]
                    [?group :core/parent ?dept]
                    [?group :core/name ?group-name]
                    [?group :core/type :core/group]
                    [?skill :core/parent ?group]
                    [?skill :core/name ?name]
                    (or (and [?knows :core/skill ?skill]
                             [?knows :user/id])
                        [(identity true) ?knows])]
          }

Thanks! That doesn't seem too bad, actually, though I might change the or to an or-join to make it slightly more explicit (and potentially speed it up):

(or-join [?knows ?skill]
         (and [?knows :core/skill ?skill]
              [?knows :user/id])
         [(identity true) ?knows])

Thank you again for your help. Changed my impl to or-join according to your suggestion 🙂