@mlimotte That talk describes a solution done for an internal company application. This open ended /query endpoint shouldn't be public. There's another talk about "datomic superpowers" where they sanitize the query and add constraints (can't remember if in a database function or by appending :where clauses) according to user roles: https://www.youtube.com/watch?v=7lm3K8zVOdY

Should lookup refs in transactions work fine? - I thought they would, but I do get :db.error/not-an-entity Unable to resolve entity: ....

[...
  {:db/id #db/id[:db.part/user]
   :some/tag "whatever"}
  {:db/id #db/id[:db.part/user]
   :ref-to-some [:some/tag "whatever"]}
 ...
]

in map txes, you must wrap with {:db/id lr}

so {:db/id [:some/tag "whatever"]}? What if I want to put it in a different partition?

:ref-to-some {:db/id [:some/tag "whatever"]}

aah, sorry.

at this point, it's already in a partition

yeah, right. get it, thx.

... or not. It doesn't seem to work: still same error.

java.lang.IllegalArgumentException: :db.error/not-an-entity Unable to resolve entity: [:some/tag "whatever"] in datom [#db/id[:db.part/user -1] :ref-to-some [:some/tag "whatever"]]

So, no lookup refs in transactions. Switching back to #db/id[db.part/user -1] and stuff. Too bad.

@kurt-yagram lookup refs can only find entities that are already in storage. you need to use temp ids to refer to temp ids

allright, thanks!

If I query a db, can I return a default value if a many-cardinality attribute doesn't contain any value? (something like get-else, but for many-cardinality)

@kurt-yagram You could probably write something using missing? and ground to do so,

aha, missing seems to be something...

this does the trick, there may be no attrs in :some/attr :

[(missing? $ ?t :some/attr) ?no-attr]
            (or-join [?no-tag]
                     [?t :some/attr ?attrs]
                     [(when ?no-attr []) ?attrs])]
       

or not... it's not right.

I figured out a way to do this in the past at one point. I think it was a missing and a ground clause both inside an or

@kenny thanks for the feedback. That is in-line with what I was planning. Was hoping there was already some published example, but not sure how generic vs. application-specific the result will be.

Datomic 0.9.5404 is now available https://groups.google.com/d/topic/datomic/JKbyd8VFYm8/discussion

@yonatanel I'm not sure that's true. The speaker at one point refers to the web service layer handle edge concerns to protect from the "Scary internet". In any case if you support authentication and authorization, and sufficiently sanitize the input, I could see doing the same thing for an internet facing application.

Curious about the switch away from HornetQ.

Purely performance?

@potetm The HornetQ codebase was donated to Apache and became part of Artemis

Ah. So basically just a HornetQ update.

http://hornetq.blogspot.com/2015/06/hornetq-apache-donation-and-apache.html

hihi. can I ask maybe a stupid question, however I am new to data structures and algorithms

so I was trying to google that out, but still: is datomic um.. indexes sort of persistent data structures, right?

if so, what are in the leaves?

and what is stored in the upper level of the tree

(the guide says that datomic stores segments, not individual datoms in the tree. so this means those have to be periodically rebuilt and written anew somewhere on the disk)

@leov yes and no. It does store segments, and the indexes are periodically rewritten (see http://docs.datomic.com/capacity.html#indexing for the performance impact), but the segments themselves are immutable.

@leov persistent datastructures means “when I ‘update’ the structure, the old one is untouched, and I have a new structure representing the change’. kind of like a git fork

if you’re interested in implementation details, etc. Rich’s Writing Datomic in Clojure talk is probably the best resource: https://www.infoq.com/presentations/Datomic (though note that some details may have changed since then of course).

How can I get a pull pattern to be recursive at an arbitrary depth? For example:

[:db/id
 :some-value
 :nested {:foo '...}]

{:db/id 1, :some-value 6, :nested #:db{:id 2}}

thank you