When a global property is used and the index is global, and the property has its own unique index in each label, the query is abnormal.

Open

#4,511 opened on Jun 12, 2024 1 comment 0 reactions 0 assignees View on GitHub

Nobody has claimed this yet.

kind/bug/possible

Dominant language: Java
Stars: 5.8k
Forks: 1.2k
Avg merge: 13h 53m
Merged PRs (30d): 6

Description

this is a demo about schema.
```
m = graph.openManagement()

v1 = m.makeVertexLabel('v1').make()
v2 = m.makeVertexLabel('v2').make()
v3 = m.makeVertexLabel('v3').make()

cp0 = m.makePropertyKey('cp0').dataType(String.class).make()
cp1 = m.makePropertyKey('cp1').dataType(String.class).make()
cp2 = m.makePropertyKey('cp2').dataType(String.class).make()

cp0_c = m.buildIndex('cp0_c', Vertex.class).addKey(cp0).buildCompositeIndex()
cp1_c = m.buildIndex('cp1_c', Vertex.class).addKey(cp1).unique().buildCompositeIndex()
cp2_c = m.buildIndex('cp2_c', Vertex.class).addKey(cp2).buildCompositeIndex()
cp2_c_v3 = m.buildIndex('cp2_c_v3', Vertex.class).addKey(cp2).indexOnly(v3).unique().buildCompositeIndex()

m.setConsistency(cp0, ConsistencyModifier.LOCK)
m.setConsistency(cp1, ConsistencyModifier.LOCK)
m.setConsistency(cp2, ConsistencyModifier.LOCK)
m.setConsistency(cp0_c, ConsistencyModifier.LOCK)
m.setConsistency(cp1_c, ConsistencyModifier.LOCK)
m.setConsistency(cp2_c, ConsistencyModifier.LOCK)
m.setConsistency(cp2_c_v3, ConsistencyModifier.LOCK)

m.commit()

```

This is data and gremlin query
```
gremlin> g.V().elementMap()
==>{cp0=v1, cp1=2, cp2=cp2, id=81924096, label=v1}
==>{cp0=v2, cp1=6, cp2=cp2, id=81928192, label=v2}
==>{cp0=v2, cp1=4, cp2=cp2, id=12440, label=v2}
==>{cp0=v3, cp1=9, cp2=v3_cp2_3, id=16536, label=v3}
==>{cp0=v3, cp1=8, cp2=v3_cp2_2, id=40972488, label=v3}
==>{cp0=v1, cp1=1, cp2=cp2, id=40964304, label=v1}
==>{cp0=v1, cp1=3, cp2=cp2, id=12504, label=v1}
==>{cp0=v3, cp1=7, cp2=v3_cp2_1, id=16600, label=v3}
==>{cp0=v2, cp1=5, cp2=cp2, id=40964328, label=v2}
gremlin> g.E().elementMap()
==>{id=2pkjcw-1crx1c-8v85-1cs074, label=v1_rt1_v2, IN={id=81928192, label=v2}, OUT={id=81924096, label=v1}}

gremlin> g.V().has('cp1','2').out('v1_rt1_v2').has('cp2','cp2').elementMap()
gremlin> g.V().has('cp1','2').out('v1_rt1_v2').elementMap()
==>{cp0=v2, cp1=6, cp2=cp2, id=81928192, label=v2}

gremlin> g.V().has('cp1','2').out('v1_rt1_v2').has('cp2','cp2').explain()
==>Traversal Explanation
============================================================================================================================================================================================================
Original Traversal [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]

ConnectiveStrategy [D] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
IdentityRemovalStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
MatchPredicateStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
FilterRankingStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
ByModulatorOptimizationStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
InlineFilterStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
IncidentToAdjacentStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
RepeatUnrollStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
PathRetractionStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
AdjacentToIncidentStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
CountStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
EarlyLimitStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
LazyBarrierStrategy [O] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
AdjacentVertexHasIdOptimizerStrategy [P] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
AdjacentVertexIsOptimizerStrategy [P] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],vertex), HasStep([cp2.eq(cp2)])]
AdjacentVertexHasUniquePropertyOptimizerStrategy [P] [GraphStep(vertex,[]), HasStep([cp1.eq(2)]), VertexStep(OUT,[v1_rt1_v2],edge), HasStep([~adjacent.eq(40964304)]), EdgeVertexStep(IN)]

```

The problem is `~adjacent.eq(40964304)`, it will be returned a random vertex when has step matched

- Version: 1.0.0
- Storage Backend: hbase
- Mixed Index Backend: elasticsearch
- Expected Behavior: Each label has its own unique configuration in effect
- Current Behavior: gremlin will return random result when has("") step matched in global index

Contributor guide

Open the contributing guide

First steps

Read the whole issue, then the project's contributing guide.
Comment on the issue to say you are picking it up — it saves two people doing the same work.
Fork the repository and make your change on a branch.
Open a pull request that references the issue number.

Research direction

Start by reproducing the schema and traversal shown in the issue, then inspect the AdjacentVertexHasUniquePropertyOptimizerStrategy step from the explain output. Trace how the global index and label-specific unique index produce ~adjacent.eq(40964304); done means the has('cp2','cp2') filter returns only matching vertices rather than a random vertex.

Written by the indexing model from the issue text.

Assessment

Tech stack: elasticsearch, java
Domain: databases
Issue type: Bug
Difficulty: 4/5
Estimated time: 3-5 days
Activity status: Stale
Clarity: Mostly clear
Newbie friendliness: 35/100