Odtnhj

DB have some amount of OrderItemType which have relations between one to another like INCOMPATIBLE and REQUIRED

We combining an order by linking OrderItemType to it with CONTAINS relation

Is it possible to make constraint to fail with validation error when trying to add new OrderItemType which is incompatible with another in graph and if required items is not present yet?

Target is just trying to insert, and get reject if it violate some conditions

Another option - using transaction:
1. insert item
2. load graph and check rules manually
3. rollback if find some problems

UPDATE
Ok I will rephrase question with standard movies sample

lets establish some relations between actors

CREATE (Keanu)-[:HATE]->(JackN),
(Keanu)-[:REQUIRE]->(LillyW),
(JamesM)-[:HATE]->(LillyW)

now we starting new movie producing

CREATE (RaiseOfCrazyDev:Movie title:'RaiseOfCrazyDev', released:2020, tagline:'Crazy developer conquer the world')

and start casting. first we sign JackN, and JamesM

CREATE (JackN)-[:ACTED_IN roles:['Father'] ]->(RaiseOfCrazyDev),
(JamesM)-[:ACTED_IN roles:['BadGuy'] ]->(RaiseOfCrazyDev)

now we try to sign Keanu

CREATE (Keanu)-[:ACTED_IN roles:['Dev'] ]->(RaiseOfCrazyDev)

But it should fail, since Keanu hates JackN, and Keanu require LillyW

so we remove JackN and add Keanu and LillyW instead

MATCH (:JackN)-[r:ACTED_IN]-(:RaiseOfCrazyDev) DELETE r
CREATE (Keanu)-[:ACTED_IN roles:['Dev'] ]->(RaiseOfCrazyDev),
(LillyW)-[:ACTED_IN roles:['StepSister'] ]->(RaiseOfCrazyDev)

but now it fails again because JamesM hates LillyW

since Keanu is a main role in our movie, we fire JamesM

MATCH (:JamesM)-[r:ACTED_IN]-(:RaiseOfCrazyDev) DELETE r

So, if rephrase:

• It should be no HATE relationship between any two actors attached to one movie


• For all actors their REQUIRE relationship should be actors in this movie too.

Question: What is the best way and place to make such conditions checks?

I assume that problematic situations like the following do not exist in the DB: a requires b, and b requires c, but c hates a. (Even though such situations can exist in real life :-)). I also assume that actor nodes have the Actor label and a name property.

This query should get you started. It will tell you if it is OK to add an actor (I assume that actorName and title are passed as parameters). It will also return a list of the current cast members opposed by the "required" actors (including the main actor you want to add, and all the actors required by the required actors, etc.), and a list of the required actors opposed by the current cast members:

MATCH (a:Actor name: $actorName), (m:Movie title: $title)
OPTIONAL MATCH p=(a)-[:REQUIRE*]->(:Actor)
WITH a, m, NODES(p) AS reqs
UNWIND reqs AS req
WITH DISTINCT a, m, reqs, req
OPTIONAL MATCH (req)-[:HATE]->(h:Actor)
WITH a, m, reqs, COLLECT(DISTINCT h) AS hatedByReq
OPTIONAL MATCH (m)<-[:ACTED_IN]-(x:Actor)
OPTIONAL MATCH (x)-[:HATE]->(y:Actor)
WITH a, m, reqs, hatedByReq, COLLECT(x) AS cast, COLLECT(DISTINCT y) AS hatedByCast
WITH a, m, [c IN cast WHERE c IN hatedByReq] AS reqOpposes, [r IN reqs WHERE r IN hatedByCast] AS castOpposes
RETURN a, m, reqOpposes, castOpposes, (SIZE(reqOpposes) = 0 AND SIZE(castOpposes) = 0) AS okToAddActors

The result, using your sample data, is:

╒════════════════╤══════════════════════════════════════════════════════════════════════╤══════════════════╤═══════════════════╤═══════════════╕
│"a" │"m" │"reqOpposes" │"castOpposes" │"okToAddActors"│
╞════════════════╪══════════════════════════════════════════════════════════════════════╪══════════════════╪═══════════════════╪═══════════════╡
│"name":"Keanu"│"title":"RaiseOfCrazyDev","tagline":"Crazy developer conquer the wor│["name":"JackN"]│["name":"LillyW"]│false │
│ │ld","released":2020 │ │ │ │
└────────────────┴──────────────────────────────────────────────────────────────────────┴──────────────────┴───────────────────┴───────────────┘