//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void mustSelectSpatialForExactPredicateWithSpatialValue() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void MustSelectSpatialForExactPredicateWithSpatialValue() { // given assumeTrue(HasSpatialSupport()); foreach (object value in FusionIndexTestHelp.ValuesSupportedBySpatial()) { IndexQuery indexQuery = IndexQuery.exact(PROP_KEY, value); // then VerifyQueryWithCorrectReader(_readers[SPATIAL], indexQuery); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void mustSelectTemporalForExactPredicateWithTemporalValue() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void MustSelectTemporalForExactPredicateWithTemporalValue() { // given assumeTrue(HasTemporalSupport()); foreach (object temporalValue in FusionIndexTestHelp.ValuesSupportedByTemporal()) { IndexQuery indexQuery = IndexQuery.exact(PROP_KEY, temporalValue); // then VerifyQueryWithCorrectReader(_readers[TEMPORAL], indexQuery); } }
private void AssertMatch(BlockBasedIndexPopulator <GenericKey, NativeIndexValue> populator, Value value, long id) { using (NativeIndexReader <GenericKey, NativeIndexValue> reader = populator.newReader()) { SimpleNodeValueClient cursor = new SimpleNodeValueClient(); reader.Query(cursor, IndexOrder.NONE, true, IndexQuery.exact(_indexDescriptor.properties()[0], value)); assertTrue(cursor.Next()); assertEquals(id, cursor.Reference); assertEquals(value, cursor.Values[0]); assertFalse(cursor.Next()); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void seekOverAllPartitions() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void SeekOverAllPartitions() { PartitionedIndexReader indexReader = CreatePartitionedReaderFromReaders(); IndexQuery.ExactPredicate query = IndexQuery.exact(1, "Test"); when(_indexReader1.query(query)).thenReturn(PrimitiveLongResourceCollections.iterator(null, 1)); when(_indexReader2.query(query)).thenReturn(PrimitiveLongResourceCollections.iterator(null, 2)); when(_indexReader3.query(query)).thenReturn(PrimitiveLongResourceCollections.iterator(null, 3)); LongSet results = PrimitiveLongCollections.asSet(indexReader.Query(query)); VerifyResult(results); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertIndexData(org.neo4j.internal.kernel.api.Transaction transaction, int[] propertyKeyIds, org.neo4j.values.storable.TextValue value, long node, org.neo4j.internal.kernel.api.IndexReference index) throws org.neo4j.internal.kernel.api.exceptions.KernelException private void AssertIndexData(Transaction transaction, int[] propertyKeyIds, TextValue value, long node, IndexReference index) { using (NodeValueIndexCursor indexCursor = transaction.Cursors().allocateNodeValueIndexCursor()) { IndexQuery[] query = new IndexQuery[propertyKeyIds.Length]; for (int i = 0; i < propertyKeyIds.Length; i++) { query[i] = IndexQuery.exact(propertyKeyIds[i], value); } transaction.DataRead().nodeIndexSeek(index, indexCursor, IndexOrder.NONE, false, query); assertTrue(indexCursor.Next()); assertEquals(node, indexCursor.NodeReference()); assertFalse(indexCursor.Next()); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertHasAllValues(java.util.List<NodeAndValue> values) throws java.io.IOException, org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException private void AssertHasAllValues(IList <NodeAndValue> values) { using (IndexAccessor accessor = IndexProvider.getOnlineAccessor(Descriptor, IndexSamplingConfig)) { using (IndexReader reader = new QueryResultComparingIndexReader(accessor.NewReader())) { int propertyKeyId = Descriptor.schema().PropertyId; foreach (NodeAndValue entry in values) { NodeValueIterator nodes = new NodeValueIterator(); reader.Query(nodes, IndexOrder.NONE, false, IndexQuery.exact(propertyKeyId, entry.Value)); assertEquals(entry.NodeId, nodes.Next()); assertFalse(nodes.HasNext()); } } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void exactMatchOnAllValues(java.util.List<org.neo4j.values.storable.Value> values) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException private void ExactMatchOnAllValues(IList <Value> values) { using (IndexReader indexReader = _accessor.newReader()) { SimpleNodeValueClient client = new SimpleNodeValueClient(); foreach (Value value in values) { IndexQuery.ExactPredicate exact = IndexQuery.exact(_descriptor.schema().PropertyId, value); indexReader.Query(client, IndexOrder.NONE, true, exact); // then assertTrue(client.Next()); assertEquals(value, client.Values[0]); assertFalse(client.Next()); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void verifyIndex(org.neo4j.kernel.impl.api.TransactionToApply tx) throws Exception internal virtual void VerifyIndex(TransactionToApply tx) { using (IndexReader reader = Index.newReader()) { NodeVisitor visitor = new NodeVisitor(); for (int i = 0; tx != null; i++) { tx.TransactionRepresentation().accept(visitor.Clear()); Value propertyValue = propertyValue(Id, Base + i); IndexQuery.ExactPredicate query = IndexQuery.exact(outerInstance.descriptor.PropertyId, propertyValue); LongIterator hits = reader.Query(query); assertEquals("Index doesn't contain " + visitor.NodeId + " " + propertyValue, visitor.NodeId, hits.next()); assertFalse(hits.hasNext()); tx = tx.Next(); } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldQueryAboutAddedAndChangedValueTuples() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldQueryAboutAddedAndChangedValueTuples() { // given IndexUpdater actual = mock(typeof(IndexUpdater)); IndexReader reader = mock(typeof(IndexReader)); when(reader.Query(anyVararg())).thenAnswer(invocation => iterator(0)); long nodeId = 0; IList <IndexEntryUpdate <IndexDescriptor> > updates = new List <IndexEntryUpdate <IndexDescriptor> >(); updates.Add(add(nodeId++, _descriptor, Tuple(10, 11))); updates.Add(change(nodeId++, _descriptor, Tuple("abc", "def"), Tuple("ghi", "klm"))); updates.Add(remove(nodeId++, _descriptor, Tuple(1001L, 1002L))); updates.Add(change(nodeId++, _descriptor, Tuple(( sbyte )2, ( sbyte )3), Tuple(( sbyte )4, ( sbyte )5))); updates.Add(add(nodeId++, _descriptor, Tuple(5, "5"))); using (DeferredConflictCheckingIndexUpdater updater = new DeferredConflictCheckingIndexUpdater(actual, () => reader, _descriptor)) { // when foreach (IndexEntryUpdate <IndexDescriptor> update in updates) { updater.Process(update); verify(actual).process(update); } } // then foreach (IndexEntryUpdate <IndexDescriptor> update in updates) { if (update.UpdateMode() == UpdateMode.ADDED || update.UpdateMode() == UpdateMode.CHANGED) { Value[] tuple = update.Values(); IndexQuery[] query = new IndexQuery[tuple.Length]; for (int i = 0; i < tuple.Length; i++) { query[i] = IndexQuery.exact(_propertyKeyIds[i], tuple[i]); } verify(reader).query(query); } } verify(reader).close(); verifyNoMoreInteractions(reader); }
private void ShouldConsultProvidedFilters(System.Func <Value[], Value[]> filterValues, bool filterAcceptsValue) { // given long nodeReference = 123; int labelId = 10; int slots = Random.Next(3, 8); IndexQuery[] filters = new IndexQuery[slots]; Value[] actualValues = new Value[slots]; Value[] values = new Value[slots]; IDictionary <int, Value> properties = new Dictionary <int, Value>(); int[] propertyKeyIds = new int[slots]; int filterCount = 0; for (int i = 0; i < slots; i++) { actualValues[i] = Random.nextValue(); int propertyKeyId = i; propertyKeyIds[i] = propertyKeyId; // we want at least one filter , randomly add filter or not if ((filterCount == 0 && i == slots - 1) || Random.nextBoolean()) { object filterValue = (filterAcceptsValue ? actualValues[i] : AnyOtherValueThan(actualValues[i])).asObjectCopy(); filters[i] = IndexQuery.exact(propertyKeyId, filterValue); filterCount++; } values[i] = Random.nextBoolean() ? NO_VALUE : actualValues[i]; properties[propertyKeyId] = actualValues[i]; } _node.withNode(nodeReference, new long[] { labelId }, properties); // when NodeValueClientFilter filter = new NodeValueClientFilter(this, _node, _property, _read, filters); filter.Initialize(TestIndexDescriptorFactory.forLabel(labelId, propertyKeyIds), this, null, IndexOrder.NONE, true); bool accepted = filter.AcceptNode(nodeReference, filterValues(values)); // then assertEquals(filterAcceptsValue, accepted); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testExactMatchOnRandomValues() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TestExactMatchOnRandomValues() { // given ValueType[] types = RandomSetOfSupportedTypes(); IList <Value> values = GenerateValuesFromType(types, new HashSet <Value>(), 30_000); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<IndexEntryUpdate<?>> updates = generateUpdatesFromValues(values, new org.apache.commons.lang3.mutable.MutableLong()); IList <IndexEntryUpdate <object> > updates = GenerateUpdatesFromValues(values, new MutableLong()); UpdateAndCommit(updates); // when //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (IndexEntryUpdate<?> update : updates) foreach (IndexEntryUpdate <object> update in updates) { // then IList <long> hits = Query(IndexQuery.exact(0, update.Values()[0])); assertEquals(hits.ToString(), 1, hits.Count); assertThat(single(hits), equalTo(update.EntityId)); } }
/// <summary> /// This test target a bug around minimal splitter in gbpTree and unique index populator. It goes like this: /// Given a set of updates (value,entityId): /// - ("A01",1), ("A90",3), ("A9",2) /// If ("A01",1) and ("A90",3) would cause a split to occur they would produce a minimal splitter ("A9",3). /// Note that the value in this minimal splitter is equal to our last update ("A9",2). /// When making insertions with the unique populator we don't compare entityId which would means ("A9",2) /// ends up to the right of ("A9",3), even though it belongs to the left because of entityId being smaller. /// At this point the tree is in an inconsistent (key on wrong side of splitter). /// /// To work around this problem the entityId is only kept in minimal splitter if strictly necessary to divide /// left from right. This means the minimal splitter between ("A01",1) and ("A90",3) is ("A9",-1) and ("A9",2) /// will correctly be placed on the right side of this splitter. /// /// To trigger this scenario this test first insert a bunch of values that are all unique and that will cause a /// split to happen. This is the firstBatch. /// The second batch are constructed so that at least one of them will have a value equal to the splitter key /// constructed during the firstBatch. /// It's important that the secondBatch has ids that are lower than the first batch to align with example described above. /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldPopulateAndRemoveEntriesWithSimilarMinimalSplitter() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldPopulateAndRemoveEntriesWithSimilarMinimalSplitter() { string prefix = "Work out your own salvation. Do not depend on others. "; int nbrOfNodes = 200; long nodeId = 0; // Second batch has lower ids IList <NodeAndValue> secondBatch = new List <NodeAndValue>(); for (int i = 0; i < nbrOfNodes; i++) { secondBatch.Add(new NodeAndValue(nodeId++, stringValue(prefix + i))); } // First batch has higher ids and minimal splitter among values in first batch will be found among second batch IList <NodeAndValue> firstBatch = new List <NodeAndValue>(); for (int i = 0; i < nbrOfNodes; i++) { firstBatch.Add(new NodeAndValue(nodeId++, stringValue(prefix + i + " " + i))); } WithPopulator(IndexProvider.getPopulator(Descriptor, IndexSamplingConfig, heapBufferFactory(1024)), p => { p.add(Updates(firstBatch)); p.add(Updates(secondBatch)); // Index should be consistent }); IList <NodeAndValue> toRemove = new List <NodeAndValue>(); ((IList <NodeAndValue>)toRemove).AddRange(firstBatch); ((IList <NodeAndValue>)toRemove).AddRange(secondBatch); Collections.shuffle(toRemove); // And we should be able to remove the entries in any order using (IndexAccessor accessor = IndexProvider.getOnlineAccessor(Descriptor, IndexSamplingConfig)) { // WHEN using (IndexUpdater updater = accessor.NewUpdater(IndexUpdateMode.ONLINE)) { foreach (NodeAndValue nodeAndValue in toRemove) { updater.Process(IndexEntryUpdate.Remove(nodeAndValue.NodeId, Descriptor, nodeAndValue.Value)); } } // THEN using (IndexReader reader = new QueryResultComparingIndexReader(accessor.NewReader())) { int propertyKeyId = Descriptor.schema().PropertyId; foreach (NodeAndValue nodeAndValue in toRemove) { NodeValueIterator nodes = new NodeValueIterator(); reader.Query(nodes, IndexOrder.NONE, false, IndexQuery.exact(propertyKeyId, nodeAndValue.Value)); bool anyHits = false; StringJoiner nodesStillLeft = new StringJoiner(", ", "[", "]"); while (nodes.HasNext()) { anyHits = true; nodesStillLeft.add(Convert.ToString(nodes.Next())); } assertFalse("Expected this query to have zero hits but found " + nodesStillLeft.ToString(), anyHits); } } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void concurrentIndexPopulationAndInsertsShouldNotProduceDuplicates() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ConcurrentIndexPopulationAndInsertsShouldNotProduceDuplicates() { // Given Config config = Config.defaults(); GraphDatabaseService db = NewEmbeddedGraphDatabaseWithSlowJobScheduler(config); try { // When using (Transaction tx = Db.beginTx()) { Db.schema().indexFor(label(LABEL)).on(KEY).create(); tx.Success(); } Node node; using (Transaction tx = Db.beginTx()) { node = Db.createNode(label(LABEL)); node.SetProperty(KEY, VALUE); tx.Success(); } using (Transaction tx = Db.beginTx()) { Db.schema().awaitIndexesOnline(1, MINUTES); tx.Success(); } // Then using (Transaction tx = Db.beginTx()) { KernelTransaction ktx = (( GraphDatabaseAPI )db).DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true); IndexReference index = ktx.SchemaRead().index(ktx.TokenRead().nodeLabel(LABEL), ktx.TokenRead().propertyKey(KEY)); NodeValueIndexCursor cursor = ktx.Cursors().allocateNodeValueIndexCursor(); ktx.DataRead().nodeIndexSeek(index, cursor, IndexOrder.NONE, false, IndexQuery.exact(1, VALUE)); assertTrue(cursor.Next()); assertEquals(node.Id, cursor.NodeReference()); assertFalse(cursor.Next()); tx.Success(); } } finally { Db.shutdown(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHandleCompositeSizesCloseToTheLimit() throws org.neo4j.internal.kernel.api.exceptions.KernelException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHandleCompositeSizesCloseToTheLimit() { // given CreateIndex(KEY, KEY2); // when a string longer than native string limit, but within lucene limit int length = 20_000; string string1 = Random.nextAlphaNumericString(length, length); string string2 = Random.nextAlphaNumericString(length, length); Node node; using (Transaction tx = Db.beginTx()) { node = Db.createNode(LABEL); node.SetProperty(KEY, string1); node.SetProperty(KEY2, string2); tx.Success(); } using (Transaction tx = Db.beginTx()) { KernelTransaction ktx = Db.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true); int labelId = ktx.TokenRead().nodeLabel(LABEL.Name()); int propertyKeyId1 = ktx.TokenRead().propertyKey(KEY); int propertyKeyId2 = ktx.TokenRead().propertyKey(KEY2); using (NodeValueIndexCursor cursor = ktx.Cursors().allocateNodeValueIndexCursor()) { ktx.DataRead().nodeIndexSeek(TestIndexDescriptorFactory.forLabel(labelId, propertyKeyId1, propertyKeyId2), cursor, IndexOrder.NONE, false, IndexQuery.exact(propertyKeyId1, string1), IndexQuery.exact(propertyKeyId2, string2)); assertTrue(cursor.Next()); assertEquals(node.Id, cursor.NodeReference()); assertFalse(cursor.Next()); } tx.Success(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertIndexedNodesMatchesStoreNodes() throws Exception private void AssertIndexedNodesMatchesStoreNodes() { int nodesInStore = 0; Label label = Label.label(PERSON_LABEL); using (Transaction tx = _db.beginTx()) { KernelTransaction ktx = (( GraphDatabaseAPI )_db).DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true); IList <string> mismatches = new List <string>(); int labelId = ktx.TokenRead().nodeLabel(PERSON_LABEL); int propertyKeyId = ktx.TokenRead().propertyKey(NAME_PROPERTY); IndexReference index = ktx.SchemaRead().index(labelId, propertyKeyId); using (NodeValueIndexCursor cursor = ktx.Cursors().allocateNodeValueIndexCursor()) { // Node --> Index foreach (Node node in filter(n => n.hasLabel(label) && n.hasProperty(NAME_PROPERTY), _db.AllNodes)) { nodesInStore++; string name = ( string )node.GetProperty(NAME_PROPERTY); ktx.DataRead().nodeIndexSeek(index, cursor, IndexOrder.NONE, false, IndexQuery.exact(propertyKeyId, name)); bool found = false; while (cursor.Next()) { long indexedNode = cursor.NodeReference(); if (indexedNode == node.Id) { if (found) { mismatches.Add("Index has multiple entries for " + name + " and " + indexedNode); } found = true; } } if (!found) { mismatches.Add("Index is missing entry for " + name + " " + node); } } if (mismatches.Count > 0) { fail(join(mismatches.ToArray(), format("%n"))); } // Node count == indexed node count ktx.DataRead().nodeIndexSeek(index, cursor, IndexOrder.NONE, false, IndexQuery.exists(propertyKeyId)); int nodesInIndex = 0; while (cursor.Next()) { nodesInIndex++; } assertEquals(nodesInStore, nodesInIndex); } } }