Add TxState support for index range seeks by string

neo4j · Jul 20, 2015 · aa5360d · aa5360d
1 parent 5d3dea4
commit aa5360d
Show file tree

Hide file tree

Showing 5 changed files with 409 additions and 7 deletions.
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/ReadableTxState.java b/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/ReadableTxState.java
@@ -145,6 +145,10 @@ ReadableDiffSets<Long> indexUpdatesForRangeSeekByNumber( IndexDescriptor index,
                                                              Number lower, boolean includeLower,
                                                              Number upper, boolean includeUpper );
 
+    ReadableDiffSets<Long> indexUpdatesForRangeSeekByString( IndexDescriptor index,
+                                                             String lower, boolean includeLower,
+                                                             String upper, boolean includeUpper );
+
     ReadableDiffSets<Long> indexUpdatesForRangeSeekByPrefix( IndexDescriptor index, String prefix );
 
     NodeState getNodeState( long id );

diff --git a/...nity/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java b/...nity/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java
@@ -822,11 +822,7 @@ public PrimitiveLongIterator nodesGetFromIndexRangeSeekByString( KernelStatement
 
     {
         PrimitiveLongIterator committed = storeLayer.nodesGetFromIndexRangeSeekByString(state, index, lower, includeLower, upper, includeUpper);
-        if (state.txState().hasChanges()) {
+        return filterIndexStateChangesForRangeSeekByString(state, index, lower, includeLower, upper, includeUpper, committed);
-            throw new UnsupportedOperationException("TODO");
-
-        }
-        return committed;
     }
 
     @Override
@@ -873,12 +869,31 @@ private PrimitiveLongIterator filterIndexStateChangesForRangeSeekByNumber( Kerne
     {
         if ( state.hasTxStateWithChanges() )
         {
-            ReadableDiffSets<Long> labelPropertyChangesForPrefix =
+            ReadableDiffSets<Long> labelPropertyChangesForNumber =
                     state.txState().indexUpdatesForRangeSeekByNumber( index, lower, includeLower, upper, includeUpper );
             ReadableDiffSets<Long> nodes = state.txState().addedAndRemovedNodes();
 
             // Apply to actual index lookup
-            return nodes.augmentWithRemovals( labelPropertyChangesForPrefix.augment( nodeIds ) );
+            return nodes.augmentWithRemovals( labelPropertyChangesForNumber.augment( nodeIds ) );
+        }
+        return nodeIds;
+
+    }
+
+    private PrimitiveLongIterator filterIndexStateChangesForRangeSeekByString( KernelStatement state,
+                                                                               IndexDescriptor index,
+                                                                               String lower, boolean includeLower,
+                                                                               String upper, boolean includeUpper,
+                                                                               PrimitiveLongIterator nodeIds )
+    {
+        if ( state.hasTxStateWithChanges() )
+        {
+            ReadableDiffSets<Long> labelPropertyChangesForString =
+                    state.txState().indexUpdatesForRangeSeekByString( index, lower, includeLower, upper, includeUpper );
+            ReadableDiffSets<Long> nodes = state.txState().addedAndRemovedNodes();
+
+            // Apply to actual index lookup
+            return nodes.augmentWithRemovals( labelPropertyChangesForString.augment( nodeIds ) );
         }
         return nodeIds;
 

diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java
@@ -1267,6 +1267,66 @@ private ReadableDiffSets<Long> getIndexUpdatesForRangeSeekByNumber( IndexDescrip
         return diffs;
     }
 
+    @Override
+    public ReadableDiffSets<Long> indexUpdatesForRangeSeekByString( IndexDescriptor descriptor,
+                                                                    String lower, boolean includeLower,
+                                                                    String upper, boolean includeUpper )
+    {
+        return ReadableDiffSets.Empty.ifNull(
+                getIndexUpdatesForRangeSeekByString(descriptor, lower, includeLower, upper, includeUpper)
+        );
+    }
+
+    private ReadableDiffSets<Long> getIndexUpdatesForRangeSeekByString( IndexDescriptor descriptor,
+                                                                        String lower, boolean includeLower,
+                                                                        String upper, boolean includeUpper )
+    {
+        TreeMap<DefinedProperty, DiffSets<Long>> sortedUpdates = getSortedIndexUpdates( descriptor );
+        if ( sortedUpdates == null )
+        {
+            return null;
+        }
+
+        DefinedProperty selectedLower;
+        boolean selectedIncludeLower;
+
+        DefinedProperty selectedUpper;
+        boolean selectedIncludeUpper;
+
+        int propertyKeyId = descriptor.getPropertyKeyId();
+
+        if ( lower == null )
+        {
+            selectedLower = DefinedProperty.stringProperty(propertyKeyId, "");
+            selectedIncludeLower = true;
+        }
+        else
+        {
+            selectedLower = DefinedProperty.stringProperty(propertyKeyId, lower);
+            selectedIncludeLower = includeLower;
+        }
+
+        if ( upper == null )
+        {
+            selectedUpper = DefinedProperty.stringProperty(propertyKeyId, String.valueOf(Character.MAX_VALUE) );
+            selectedIncludeUpper = true;
+        }
+        else
+        {
+            selectedUpper = DefinedProperty.stringProperty(propertyKeyId, upper );
+            selectedIncludeUpper = includeUpper;
+        }
+
+        DiffSets<Long> diffs = new DiffSets<>();
+        for ( Map.Entry<DefinedProperty,DiffSets<Long>> entry : sortedUpdates.subMap( selectedLower, selectedIncludeLower, selectedUpper, selectedIncludeUpper ).entrySet() )
+        {
+            DiffSets<Long> diffSets = entry.getValue();
+            diffs.addAll( diffSets.getAdded().iterator() );
+            diffs.removeAll( diffSets.getRemoved().iterator() );
+        }
+        return diffs;
+    }
+
     @Override
     public ReadableDiffSets<Long> indexUpdatesForRangeSeekByPrefix( IndexDescriptor descriptor, String prefix )
     {

diff --git a/...l/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java b/...l/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java
@@ -314,6 +314,35 @@ public void shouldConsiderTransactionStateDuringIndexBetweenRangeSeekByNumber()
         assertEquals( asSet( 42L, 43L ), asSet( results ) );
     }
 
+    @Test
+    public void shouldConsiderTransactionStateDuringIndexBetweenRangeSeekByString() throws Exception
+    {
+        // Given
+        TransactionState txState = mock( TransactionState.class );
+        KernelStatement statement = mock( KernelStatement.class );
+        when( statement.hasTxStateWithChanges() ).thenReturn( true );
+        when( statement.txState() ).thenReturn( txState );
+        IndexDescriptor index = new IndexDescriptor( 1, 2 );
+        when( txState.indexUpdatesForRangeSeekByString( index, "Anne", true, "Bill", false ) ).thenReturn(
+                new DiffSets<>( Collections.singleton( 42L ), Collections.singleton( 44L ) )
+        );
+        when( txState.addedAndRemovedNodes() ).thenReturn(
+                new DiffSets<>( Collections.singleton( 45L ), Collections.singleton( 46L ) )
+        );
+
+        StoreReadLayer storeReadLayer = mock( StoreReadLayer.class );
+        when( storeReadLayer.nodesGetFromIndexRangeSeekByString( statement, index, "Anne", true, "Bill", false ) ).thenReturn(
+                IteratorUtil.resourceIterator( PrimitiveLongCollections.iterator( 43L, 44L, 46L ), null )
+        );
+
+        StateHandlingStatementOperations context = newTxStateOps( storeReadLayer );
+
+        // When
+        PrimitiveLongIterator results = context.nodesGetFromIndexRangeSeekByString( statement, index, "Anne", true, "Bill", false );
+
+        // Then
+        assertEquals( asSet( 42L, 43L ), asSet( results ) );
+    }
 
     @Test(expected = EntityNotFoundException.class)
     public void nodeDeletionShouldThrowExceptionWhenNodeWasAlreadyDeletedInSameTx() throws EntityNotFoundException