Exemple #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCheckAllCollisionsFromPopulatorAdd() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldCheckAllCollisionsFromPopulatorAdd()
        {
            // given
            _populator = NewPopulator();

            int          iterations = 228;      // This value has to be high enough to stress the EntrySet implementation
            IndexUpdater updater    = _populator.newPopulatingUpdater(_nodePropertyAccessor);

            for (int nodeId = 0; nodeId < iterations; nodeId++)
            {
                updater.Process(add(nodeId, _schemaDescriptor, 1));
                when(_nodePropertyAccessor.getNodePropertyValue(nodeId, PROPERTY_KEY_ID)).thenReturn(Values.of(nodeId));
            }

            // ... and the actual conflicting property:
            updater.Process(add(iterations, _schemaDescriptor, 1));
            when(_nodePropertyAccessor.getNodePropertyValue(iterations, PROPERTY_KEY_ID)).thenReturn(Values.of(1));                       // This collision is real!!!

            // when
            try
            {
                updater.Close();
                fail("should have thrown exception");
            }
            // then
            catch (IndexEntryConflictException conflict)
            {
                assertEquals(1, conflict.ExistingNodeId);
                assertEquals(Values.of(1), conflict.SinglePropertyValue);
                assertEquals(iterations, conflict.AddedNodeId);
            }
        }
            public override void Process <T1>(IndexEntryUpdate <T1> update)
            {
                Pair <IndexPopulation, IndexUpdater> pair = PopulationsWithUpdaters[update.IndexKey().schema()];

                if (pair != null)
                {
                    IndexPopulation population = pair.First();
                    IndexUpdater    updater    = pair.Other();

                    try
                    {
                        population.Populator.includeSample(update);
                        updater.Process(update);
                    }
                    catch (Exception t)
                    {
                        try
                        {
                            updater.Close();
                        }
                        catch (Exception ce)
                        {
                            Log.error(format("Failed to close index updater: [%s]", updater), ce);
                        }
                        PopulationsWithUpdaters.Remove(update.IndexKey().schema());
                        MultipleIndexPopulator.fail(population, t);
                    }
                }
            }
Exemple #3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRejectDuplicateEntryWhenUsingPopulatingUpdater() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldRejectDuplicateEntryWhenUsingPopulatingUpdater()
        {
            // given
            _populator = NewPopulator();

            AddUpdate(_populator, 1, "value1");
            AddUpdate(_populator, 2, "value2");

            Value value = Values.of("value1");

            when(_nodePropertyAccessor.getNodePropertyValue(1, PROPERTY_KEY_ID)).thenReturn(value);
            when(_nodePropertyAccessor.getNodePropertyValue(3, PROPERTY_KEY_ID)).thenReturn(value);

            // when
            try
            {
                IndexUpdater updater = _populator.newPopulatingUpdater(_nodePropertyAccessor);
                updater.Process(add(3, _schemaDescriptor, "value1"));
                updater.Close();

                fail("should have thrown exception");
            }
            // then
            catch (IndexEntryConflictException conflict)
            {
                assertEquals(1, conflict.ExistingNodeId);
                assertEquals(value, conflict.SinglePropertyValue);
                assertEquals(3, conflict.AddedNodeId);
            }
        }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void updaterShouldThrowOnDuplicateValues() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
            public virtual void UpdaterShouldThrowOnDuplicateValues()
            {
                // given
                outerInstance.populator.create();
                IndexEntryUpdate <IndexDescriptor>[] updates = valueCreatorUtil.someUpdatesWithDuplicateValues(random);
                IndexUpdater updater = outerInstance.populator.newPopulatingUpdater(NullPropertyAccessor);

                // when
                foreach (IndexEntryUpdate <IndexDescriptor> update in updates)
                {
                    updater.Process(update);
                }
                try
                {
                    updater.Close();
                    outerInstance.populator.scanCompleted(nullInstance);
                    fail("Updates should have conflicted");
                }
                catch (Exception e)
                {
                    // then
                    assertTrue(e.Message, Exceptions.contains(e, typeof(IndexEntryConflictException)));
                }
                finally
                {
                    outerInstance.populator.close(true);
                }
            }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void applyInterleaved(org.neo4j.kernel.api.index.IndexEntryUpdate<org.neo4j.storageengine.api.schema.IndexDescriptor>[] updates, NativeIndexPopulator<KEY,VALUE> populator) throws org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException
        private void ApplyInterleaved(IndexEntryUpdate <IndexDescriptor>[] updates, NativeIndexPopulator <KEY, VALUE> populator)
        {
            bool useUpdater = true;
            ICollection <IndexEntryUpdate <IndexDescriptor> > populatorBatch = new List <IndexEntryUpdate <IndexDescriptor> >();
            IndexUpdater updater = populator.NewPopulatingUpdater(NullPropertyAccessor);

            foreach (IndexEntryUpdate <IndexDescriptor> update in updates)
            {
                if (random.Next(100) < 20)
                {
                    if (useUpdater)
                    {
                        updater.Close();
                        populatorBatch = new List <IndexEntryUpdate <IndexDescriptor> >();
                    }
                    else
                    {
                        populator.Add(populatorBatch);
                        updater = populator.NewPopulatingUpdater(NullPropertyAccessor);
                    }
                    useUpdater = !useUpdater;
                }
                if (useUpdater)
                {
                    updater.Process(update);
                }
                else
                {
                    populatorBatch.Add(update);
                }
            }
            if (useUpdater)
            {
                updater.Close();
            }
            else
            {
                populator.Add(populatorBatch);
            }
        }
Exemple #6
0
 public virtual void CloseUpdater <T1>(DatabaseIndex <T1> index, IndexUpdater indexUpdater) where T1 : Org.Neo4j.Storageengine.Api.schema.IndexReader
 {
     _scheduler.schedule(Group.INDEX_UPDATING, () =>
     {
         try
         {
             indexUpdater.Close();
         }
         catch (IndexEntryConflictException e)
         {
             MarkAsFailed(index, e);
         }
     });
 }
            public override void Close()
            {
                foreach (Pair <IndexPopulation, IndexUpdater> pair in PopulationsWithUpdaters.Values)
                {
                    IndexPopulation population = pair.First();
                    IndexUpdater    updater    = pair.Other();

                    try
                    {
                        updater.Close();
                    }
                    catch (Exception t)
                    {
                        MultipleIndexPopulator.fail(population, t);
                    }
                }
                PopulationsWithUpdaters.Clear();
            }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void updaterMustThrowIfProcessAfterClose() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void UpdaterMustThrowIfProcessAfterClose()
        {
            // given
            Populator.create();
            IndexUpdater updater = Populator.newPopulatingUpdater(NullPropertyAccessor);

            // when
            updater.Close();

            // then
            try
            {
                updater.Process(valueCreatorUtil.add(1, Values.of(long.MaxValue)));
                fail("Expected process to throw on closed updater");
            }
            catch (System.InvalidOperationException)
            {
                // good
            }
            Populator.close(true);
        }
Exemple #9
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotRejectDuplicateEntryOnSameNodeIdAfterUsingPopulatingUpdater() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldNotRejectDuplicateEntryOnSameNodeIdAfterUsingPopulatingUpdater()
        {
            // given
            _populator = NewPopulator();

            when(_nodePropertyAccessor.getNodePropertyValue(1, PROPERTY_KEY_ID)).thenReturn(Values.of("value1"));

            IndexUpdater updater = _populator.newPopulatingUpdater(_nodePropertyAccessor);

            updater.Process(add(1, _schemaDescriptor, "value1"));
            updater.Process(change(1, _schemaDescriptor, "value1", "value1"));
            updater.Close();
            AddUpdate(_populator, 2, "value2");
            AddUpdate(_populator, 3, "value3");

            // when
            _populator.verifyDeferredConstraints(_nodePropertyAccessor);
            _populator.close(true);

            // then
            assertEquals(asList(1L), GetAllNodes(Directory, "value1"));
            assertEquals(asList(2L), GetAllNodes(Directory, "value2"));
            assertEquals(asList(3L), GetAllNodes(Directory, "value3"));
        }