We are developing a new schema for a different application that is supposed to share data with our current application as well. We’ve started using the type system and we are trying to create different “views” of the same information as different nodes (per application).
For instance, we may have the type
Profile and the type
OtherProfile where there is an edge
OtherProfile. Most of our calls will deal with the
Profile and then based on the application, we would display a certain profile to the user.
Currently in our schema, we have a predicate called
id with an index on it. My question is, it appears then when trying to write concurrently to the same
id with a different type outside of a transaction, our transaction is aborted for one of the writes.
It is my general understanding that in dgraph that you can’t write to the same index with the same value without this occurring and it is up to the developer to retry the write.
So, I have two questions.
- Is my assumption about writing to the same index with the same value above correct?
- Am I correct in assuming the only ways around this are one of the following:
- Write a system to ensure writes are in the same transaction (if the same
idis being used)
- Write a system to ensure writes don’t happen concurrently to the same
- Write a system to retry the write using conditional blocks to ensure we don’t retry a write with old data (sort of like a document version like ElasticSearch uses)
- Use a different predicate per type:
profile.id, otherprofile.id, etc...
Just for an example, if I call this mutation in one transaction
_:y <id> "23" . _:y <dgraph.type> "Profile" .
And at the same time, try to call in a separate transaction:
_:x <id> "23" . _:x <dgraph.type> "OtherProfile" .
One of the transactions aborts because it is touching the same
id on the same index. However, these are two different
dgraph.types and ideally we would be able to write to dgraph as fast as possible instead of queuing up writes one type at a time.
EDIT: Is https://dgraph.io/docs/deploy/#ludicrous-mode another option? Is that a terrible idea?