@jaret - my formative years were in the Bay Area, so the Kings and Warriors would be the teams I root for, but I enjoy basketball too much to really care who wins.

but I am not a fan of the Knicks, that’s for sure 🙂

I have a question around bulk data entry. Is it better to transact one large transaction with temp-ids to associate refs or, transact entities which form references first and then transact the rest of the data?

The second option sounds tedious, the first one sounds bulky

Hi. I’m wondering how you would model “friendship” in Datomic (assuming “friendship” is mutual)

@alex-dixon one example of an approach: https://github.com/cognitect-labs/day-of-datomic-cloud/blob/master/tutorial/pull_recursion.clj

all references in datomic are bidirectional

@marshall Thanks. So an “add friendship” transaction would need to add two facts: “a is friends with b” and “b is friends with a”?

interesting - i see that the example does do that

It is done that way for the recursive pull

you can navigate the ‘friends’ relationship “backwards”

in a query you just reverse the clause

i.e. : if you have asserted:

{:user/name "a"
 :friend [:user/name "b"]}

you can navigate that relationship from a to b in a query with:

[[?e :user/name "a"]
 [?e :friend ?x]]

and you can do the “reverse” as well:

[[?e :user/name "b"]
 [?x :friend ?e]]

the first one says find friends of “a”

the second says “who are friends with b”

also, you can pull ref relationships in reverse: https://docs.datomic.com/cloud/query/query-pull.html#reverse-lookup

I think the problem to solve is deduping friendship relationships. You can transact a :friend b and b :friend a and have your read patterns understand that both are equivalent, but when you add/update/remove friend relationships, you want to make sure those updates are consistent and not vulnerable to transaction races

Agreed @favila ^ generally I would leverage the bidirectional ref so you don’t hit that issue

I think using a bidirectional ref may still be vulnerable to read skew unless there’s some canonicalization? I can’t think of a case offhand though

If the relationship is always considered bidirectional, it should be ok. I.e. i cant be friends with you if youre not friends with me

So the ref as a single relationship either exists or doesnt

I mean during updates, some ordering of friendship add or remove transactions may end up by failing to remove one of the directions

Not if you only model it from one side

but which side?

Does it matter?

Write the query to handle either

VAET makes it efficient either way

I sort of have a feature request in mind…which would the addition of tuple value types that are effectively sets…they don’t bring ordereding into their equality semantics. For things like this that aren’t really directional

I don’t think that would help @alex-dixon? where would that assertion live?

unless you mean a tuple of sets?

rather a set of sets

;; [0 :user/name "foo"]
;; [1 :user/name "bar"]
;; [2 :friendship/between [0 1]] ; I'd like [0 1] and [1 0] to be equal, but they're treated as different.
;; [2 :friendship/since 1949] ; :friendship exists as a fact independent of :user. There can be facts about it.

ok, I have wanted something like that

Something like that. Part of what I’m looking for also is a way to add information about the “friendship”

I’ve solved it by canonicalizing the A and B parts, or by serializing the relationship consistently

e.g. canonicalization: {:friendship/left (always the entity with the lower identity id) :friendship/right (always the other one)}

been a bit since i've done datomic but could a rule easily add the reflexive checking?

e.g. serializing {:friendship/id “lower-identity-id+higher-identity-id”}

(this was before tuples--I’d use tuples now)

the issue is still that you have an entity that you want to be unique by a value which is a set

with the right read patterns and using transaction fns or :db/ensure, you could keep the constraint that only one of these exists, but you can’t model it directly with a unique index without doing tricks like this

Ok. Thanks. I was thinking along those lines but didn’t know if I was missing something. I’m still curious about the possibility of something like a tuple type that would ignore ordering for its equality semantics. It seems that might open up a fact representation that doesn’t require encoding directedness, something like :friendship/between #{a b}, and annotate those with other facts

you could reify the “friendship”

as an entity

which then has a card-many :members attribute

presumably limited (in your app) to 2

but the indirection will have some performance considerations

it adds a step to each friend lookup

An alternative approach could be to model friendship as the hash of two hashes, then keep track of that as a identifier of "friendship" between two people.

Think Merkle Trees

I am trying to get websockets working with datomic ions. My connection function currently looks like:

clj
(defn add-connection! [id]
  (faraday/put-item nil sockets-table
    {:connection-id id}))

(defn connect [{:as req :keys [input context]}]
  (let [event (json/parse-string input true)
        id (-> event :requestContext :connectionId)]
    (add-connection! id)
    ;(str {:status 200})
    ))

js
exports.handler = function(event, context, callback) {
  var putParams = {
    TableName: process.env.TABLE_NAME,
    Item: {
      connectionId: { S: event.requestContext.connectionId }
    }
  };

  DDB.putItem(putParams, function(err, data) {
    callback(null, {
      statusCode: err ? 500 : 200,
      body: err ? "Failed to connect: " + JSON.stringify(err) : "Connected"
    });
  });
};

Maybe they are not using clojure for the connect function?

@mail524 I don't understand what problem you're having, could you describe what you expect to happen that isn't happening?

Hey all, question re: the Ions tutorial: once I’ve deployed my solo-topology, lambda-proxied ion and wired it up to an API gateway, why must I append “/datomic” to the invocation URL (or else get a 403 response)? https://docs.datomic.com/cloud/ions/ions-tutorial.html#deploy-apigw

@joe.lane when I call wscat -c wss://<api-key>. I get error: Unexpected server response: 502 which is describe here https://stackoverflow.com/questions/57438756/error-unexpected-server-response-502-on-trying-to-connect-to-a-lambda-function because I am not calling the callback function the connection does not stay alive. I do successfully get the connection id logged into dynamodb.

Is it possible to query maps with datomic? If so, does anyone know where I could find a simple example? (I see the nested vector example here: https://docs.datomic.com/on-prem/query.html)