Duplication of vertices in Amazon Neptune

I want to create some logic that does the following in Amazon Neptune using Gremlin:

1. Load a row of data that contains customer_id and postcode columns

2. Check if the postcode value from that row already exists in the database:

A. If it does, then create a new vertex for the row's customer_id value and then create a new edge that makes a connection from the customer_id vertex that has just been created to the pre-existing postcode vertex

B. Else, if it does not, then create a new vertex for the row's customer_id value, create a new vertex for the row's postcode value and then create a new edge that makes a connection from the customer_id vertex that has just been created to the postcode vertex that has just been created

• The purpose of this is to avoid creating duplicate vertices.
• I am open to different approaches if you can see flaws in my logic.
• I have tried a few methods but I've been unable to get a single piece of logic to perform all of the above.
• I am using Gremlin.

First, if you want to ensure uniqueness, each vertex and edge in a graph in Neptune must have a unique ID. So it is good practice to leverage that concept to the fullest. Deterministic IDs are also great for fast lookups, as a lookup by a vertex/edge ID is the fastest operation in Neptune. If you don't supply a value for the vertex/edge IDs, then Neptune creates an ID using a UUID.

After that you'll want to consider using a conditional write pattern. In Gremlin, you can follow the pattern documented in Practical Gremlin [1].

So the pattern, for your use case, would follow something like:

g.V().hasLabel('customer').has('customer_id',<id>).
    fold().coalesce(
        unfold(),
        addV('customer').property('customer_id',<id>)
    ).aggregate('c').
    V().hasLabel('postcode').has('postcode',<postcode>).
        fold().coalesce(
            unfold(),
            addV('postcode').property('postcode',<postcode>)
        ).
    addE('hasPostCode').from(select('c').unfold())

>Note: The aggregate() step is used above because we're wanting to label something in our query but then we need to cross a collapsing barrier step (fold()) later on in the query. If we were to use as(), the label will not persist beyond the collapsing barrier step.

If using deterministic IDs, this could be simplified. Say we use an ID nomenclature of "customer-id" for customer vertices and "postcode-code" for postcode vertices:

g.V(<customer_id>).
    fold().coalesce(
        unfold(),
        addV('customer').property(id,<customer_id>)
    ).
    V(<postcode_id>).
        fold().coalesce(
            unfold(),
            addV('postcode').property(id,<postcode_id>)
        ).
    addE('hasPostCode').from(V(<customer_id>)

[1] https://kelvinlawrence.net/book/Gremlin-Graph-Guide.html#upsert