// PRIVATE // READ INDEX //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static org.neo4j.storageengine.api.schema.StoreIndexDescriptor readIndexRule(long id, ByteBuffer source) throws org.neo4j.internal.kernel.api.exceptions.schema.MalformedSchemaRuleException private static StoreIndexDescriptor ReadIndexRule(long id, ByteBuffer source) { IndexProviderDescriptor indexProvider = ReadIndexProviderDescriptor(source); sbyte indexRuleType = source.get(); Optional <string> name; switch (indexRuleType) { case GENERAL_INDEX: { SchemaDescriptor schema = ReadSchema(source); name = ReadRuleName(source); return(IndexDescriptorFactory.forSchema(schema, name, indexProvider).withId(id)); } case UNIQUE_INDEX: { long owningConstraint = source.Long; SchemaDescriptor schema = ReadSchema(source); name = ReadRuleName(source); IndexDescriptor descriptor = IndexDescriptorFactory.uniqueForSchema(schema, name, indexProvider); return(owningConstraint == NO_OWNING_CONSTRAINT_YET?descriptor.WithId(id) : descriptor.WithIds(id, owningConstraint)); } default: throw new MalformedSchemaRuleException(format("Got unknown index rule type '%d'.", indexRuleType)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRecoverIndexCountsBySamplingThemOnStartup() public virtual void ShouldRecoverIndexCountsBySamplingThemOnStartup() { // given some aliens in a database CreateAliens(); // that have been indexed AwaitIndexOnline(IndexAliensBySpecimen()); // where ALIEN and SPECIMEN are both the first ids of their kind IndexDescriptor index = TestIndexDescriptorFactory.forLabel(LabelId(_alien), PkId(SPECIMEN)); SchemaStorage storage = new SchemaStorage(NeoStores().SchemaStore); long indexId = storage.IndexGetForSchema(index).Id; // for which we don't have index counts ResetIndexCounts(indexId); // when we shutdown the database and restart it Restart(); // then we should have re-sampled the index CountsTracker tracker = NeoStores().Counts; AssertEqualRegisters("Unexpected updates and size for the index", newDoubleLongRegister(0, 32), tracker.IndexUpdatesAndSize(indexId, newDoubleLongRegister())); AssertEqualRegisters("Unexpected sampling result", newDoubleLongRegister(16, 32), tracker.IndexSample(indexId, newDoubleLongRegister())); // and also AssertLogExistsForRecoveryOn(":Alien(specimen)"); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void detectUniqueIndexWithoutOwningConstraint() public virtual void DetectUniqueIndexWithoutOwningConstraint() { IndexDescriptor descriptor = UniqueForLabel(LABEL_ID, PROPERTY_ID_1); StoreIndexDescriptor indexRule = descriptor.WithId(RULE_ID); assertTrue(indexRule.IndexWithoutOwningConstraint); }
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] query, IndexOrder order, bool needsValues) { this.Descriptor = descriptor; this.Progressor = progressor; this.Query = query; this.Order = order; this.NeedsValuesConflict = needsValues; }
private void AssertEqualityByDescriptor(IndexDescriptor descriptor) { StoreIndexDescriptor rule1 = descriptor.WithId(RULE_ID); StoreIndexDescriptor rule2 = descriptor.WithId(RULE_ID_2); StoreIndexDescriptor rule3 = (descriptor.Type() == IndexDescriptor.Type.GENERAL ? forSchema(descriptor.Schema()) : uniqueForSchema(descriptor.Schema())).withId(RULE_ID); AssertEquality(rule1, rule2); AssertEquality(rule1, rule3); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTriggerResampling() throws org.neo4j.kernel.api.exceptions.schema.SchemaRuleNotFoundException, org.neo4j.internal.kernel.api.exceptions.ProcedureException, org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldTriggerResampling() { IndexDescriptor index = TestIndexDescriptorFactory.forLabel(123, 456); when(_schemaRead.index(anyInt(), any())).thenReturn(index); _procedure.resampleIndex(":Person(name)"); verify(_indexingService).triggerIndexSampling(index.Schema(), IndexSamplingMode.TRIGGER_REBUILD_ALL); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldLookUpTheIndexByLabelIdAndPropertyKeyId() throws org.neo4j.internal.kernel.api.exceptions.ProcedureException, org.neo4j.kernel.api.exceptions.schema.SchemaRuleNotFoundException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldLookUpTheIndexByLabelIdAndPropertyKeyId() { IndexDescriptor index = TestIndexDescriptorFactory.forLabel(0, 0); when(_tokenRead.nodeLabel(anyString())).thenReturn(123); when(_tokenRead.propertyKey(anyString())).thenReturn(456); when(_schemaRead.index(anyInt(), any())).thenReturn(index); _procedure.resampleIndex(":Person(name)"); verify(_schemaRead).index(123, 456); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private boolean indexIsOnline(org.neo4j.kernel.api.impl.index.storage.PartitionedIndexStorage indexStorage, org.neo4j.storageengine.api.schema.IndexDescriptor descriptor) throws java.io.IOException private bool IndexIsOnline(PartitionedIndexStorage indexStorage, IndexDescriptor descriptor) { using (SchemaIndex index = LuceneSchemaIndexBuilder.Create(descriptor, _config).withIndexStorage(indexStorage).build()) { if (index.exists()) { index.open(); return(index.Online); } return(false); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldLookUpTheCompositeIndexByLabelIdAndPropertyKeyId() throws org.neo4j.internal.kernel.api.exceptions.ProcedureException, org.neo4j.kernel.api.exceptions.schema.SchemaRuleNotFoundException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldLookUpTheCompositeIndexByLabelIdAndPropertyKeyId() { IndexDescriptor index = TestIndexDescriptorFactory.forLabel(0, 0, 1); when(_tokenRead.nodeLabel(anyString())).thenReturn(123); when(_tokenRead.propertyKey("name")).thenReturn(0); when(_tokenRead.propertyKey("lastName")).thenReturn(1); when(_schemaRead.index(123, 0, 1)).thenReturn(index); _procedure.resampleIndex(":Person(name, lastName)"); verify(_schemaRead).index(123, 0, 1); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCreateGeneralIndex() public virtual void ShouldCreateGeneralIndex() { // GIVEN IndexDescriptor descriptor = ForLabel(LABEL_ID, PROPERTY_ID_1); StoreIndexDescriptor indexRule = descriptor.WithId(RULE_ID); // THEN assertThat(indexRule.Id, equalTo(RULE_ID)); assertFalse(indexRule.CanSupportUniqueConstraint()); assertThat(indexRule.Schema(), equalTo(descriptor.Schema())); assertThat(indexRule, equalTo(descriptor)); assertThat(indexRule.ProviderDescriptor(), equalTo(ProviderDescriptor)); assertException(indexRule.getOwningConstraint, typeof(System.InvalidOperationException)); assertException(() => indexRule.WithOwningConstraint(RULE_ID_2), typeof(System.InvalidOperationException)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void visitsUniqueConstraintsAndIndices() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void VisitsUniqueConstraintsAndIndices() { DbStructureVisitor visitor = mock(typeof(DbStructureVisitor)); int labelId = CreateLabel("Person"); int pkId = CreatePropertyKey("name"); CommitAndReOpen(); ConstraintDescriptor constraint = CreateUniqueConstraint(labelId, pkId); IndexDescriptor descriptor = TestIndexDescriptorFactory.uniqueForLabel(labelId, pkId); // WHEN Accept(visitor); // THEN verify(visitor).visitIndex(descriptor, ":Person(name)", 1.0d, 0L); verify(visitor).visitUniqueConstraint(( UniquenessConstraintDescriptor )constraint, "CONSTRAINT ON ( person:Person ) ASSERT person.name IS " + "UNIQUE"); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCreateUniqueIndex() public virtual void ShouldCreateUniqueIndex() { // GIVEN IndexDescriptor descriptor = UniqueForLabel(LABEL_ID, PROPERTY_ID_1); StoreIndexDescriptor indexRule = descriptor.WithId(RULE_ID); // THEN assertThat(indexRule.Id, equalTo(RULE_ID)); assertTrue(indexRule.CanSupportUniqueConstraint()); assertThat(indexRule.Schema(), equalTo(descriptor.Schema())); assertThat(indexRule, equalTo(descriptor)); assertThat(indexRule.ProviderDescriptor(), equalTo(ProviderDescriptor)); assertThat(indexRule.OwningConstraint, equalTo(null)); StoreIndexDescriptor withConstraint = indexRule.WithOwningConstraint(RULE_ID_2); assertThat(withConstraint.OwningConstraint, equalTo(RULE_ID_2)); assertThat(indexRule.OwningConstraint, equalTo(null)); // this is unchanged }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldUpdateCountsOnClusterWhenCreatingANodeOnSlaveAndAnIndexOnMaster() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldUpdateCountsOnClusterWhenCreatingANodeOnSlaveAndAnIndexOnMaster() { // when creating a node on the master CreateANode(_slave1, _label, PROPERTY_VALUE, PROPERTY_NAME); IndexDescriptor schemaIndexDescriptor = CreateAnIndex(_master, _label, PROPERTY_NAME); AwaitOnline(_master); // and the updates are propagate in the cluster _cluster.sync(); AwaitOnline(_slave1); AwaitOnline(_slave2); // then the slaves has updated counts AssertOnIndexCounts(0, 1, 1, 1, schemaIndexDescriptor, _master); AssertOnIndexCounts(0, 1, 1, 1, schemaIndexDescriptor, _slave1); AssertOnIndexCounts(0, 1, 1, 1, schemaIndexDescriptor, _slave2); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertParseIndexRule(String serialized, String name) throws Exception private void AssertParseIndexRule(string serialized, string name) { // GIVEN long ruleId = 24; IndexDescriptor index = ForLabel(512, 4); IndexProviderDescriptor indexProvider = new IndexProviderDescriptor("index-provider", "25.0"); sbyte[] bytes = DecodeBase64(serialized); // WHEN StoreIndexDescriptor deserialized = AssertIndexRule(SchemaRuleSerialization.Deserialize(ruleId, ByteBuffer.wrap(bytes))); // THEN assertThat(deserialized.Id, equalTo(ruleId)); assertThat(deserialized, equalTo(index)); assertThat(deserialized.Schema(), equalTo(index.Schema())); assertThat(deserialized.ProviderDescriptor(), equalTo(indexProvider)); assertThat(deserialized.Name, @is(name)); assertException(deserialized.getOwningConstraint, typeof(System.InvalidOperationException)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertParseUniqueIndexRule(String serialized, String name) throws org.neo4j.internal.kernel.api.exceptions.schema.MalformedSchemaRuleException private void AssertParseUniqueIndexRule(string serialized, string name) { // GIVEN long ruleId = 33; long constraintId = 11; IndexDescriptor index = TestIndexDescriptorFactory.uniqueForLabel(61, 988); IndexProviderDescriptor indexProvider = new IndexProviderDescriptor("index-provider", "25.0"); sbyte[] bytes = DecodeBase64(serialized); // WHEN StoreIndexDescriptor deserialized = AssertIndexRule(SchemaRuleSerialization.Deserialize(ruleId, ByteBuffer.wrap(bytes))); // THEN assertThat(deserialized.Id, equalTo(ruleId)); assertThat(deserialized, equalTo(index)); assertThat(deserialized.Schema(), equalTo(index.Schema())); assertThat(deserialized.ProviderDescriptor(), equalTo(indexProvider)); assertThat(deserialized.OwningConstraint, equalTo(constraintId)); assertThat(deserialized.Name, @is(name)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void closeMustCloseAll() public virtual void CloseMustCloseAll() { IndexDescriptor index = TestIndexDescriptorFactory.forLabel(1, 2, 3); BridgingIndexProgressor progressor = new BridgingIndexProgressor(null, index.Schema().PropertyIds); IndexProgressor[] parts = new IndexProgressor[] { mock(typeof(IndexProgressor)), mock(typeof(IndexProgressor)) }; // Given foreach (IndexProgressor part in parts) { progressor.Initialize(index, part, null, IndexOrder.NONE, false); } // When progressor.Close(); // Then foreach (IndexProgressor part in parts) { verify(part, times(1)).close(); } }
internal StringIndexReader(GBPTree <StringIndexKey, NativeIndexValue> tree, IndexLayout <StringIndexKey, NativeIndexValue> layout, IndexDescriptor descriptor) : base(tree, layout, descriptor) { }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotAllowConcurrentViolationOfConstraint() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotAllowConcurrentViolationOfConstraint() { // Given GraphDatabaseAPI graphDb = Db.GraphDatabaseAPI; System.Func <KernelTransaction> ktxSupplier = () => graphDb.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true); Label label = label("Foo"); string propertyKey = "bar"; string conflictingValue = "baz"; // a constraint using (Transaction tx = graphDb.BeginTx()) { graphDb.Schema().constraintFor(label).assertPropertyIsUnique(propertyKey).create(); tx.Success(); } // When using (Transaction tx = graphDb.BeginTx()) { KernelTransaction ktx = ktxSupplier(); int labelId = ktx.TokenRead().nodeLabel(label.Name()); int propertyKeyId = ktx.TokenRead().propertyKey(propertyKey); IndexDescriptor index = TestIndexDescriptorFactory.uniqueForLabel(labelId, propertyKeyId); Read read = ktx.DataRead(); using (NodeValueIndexCursor cursor = ktx.Cursors().allocateNodeValueIndexCursor()) { read.NodeIndexSeek(ktx.SchemaRead().index(labelId, propertyKeyId), cursor, IndexOrder.NONE, false, IndexQuery.exact(index.Schema().PropertyId, "The value is irrelevant, we just want to perform some sort of lookup against this " + "index")); } // then let another thread come in and create a node Threads.execute(Db => { using (Transaction transaction = Db.beginTx()) { Db.createNode(label).setProperty(propertyKey, conflictingValue); transaction.success(); } return(null); }, graphDb).get(); // before we create a node with the same property ourselves - using the same statement that we have // already used for lookup against that very same index long node = ktx.DataWrite().nodeCreate(); ktx.DataWrite().nodeAddLabel(node, labelId); try { ktx.DataWrite().nodeSetProperty(node, propertyKeyId, Values.of(conflictingValue)); fail("exception expected"); } // Then catch (UniquePropertyValueValidationException e) { assertEquals(ConstraintDescriptorFactory.uniqueForLabel(labelId, propertyKeyId), e.Constraint()); IndexEntryConflictException conflict = Iterators.single(e.Conflicts().GetEnumerator()); assertEquals(Values.stringValue(conflictingValue), conflict.SinglePropertyValue); } tx.Success(); } }
public CompositeIndexPopulatorCompatibility(IndexProviderCompatibilityTestSuite testSuite, IndexDescriptor descriptor) : base(testSuite, descriptor) { }
internal TemporalIndexPartReader(GBPTree <KEY, NativeIndexValue> tree, IndexLayout <KEY, NativeIndexValue> layout, IndexDescriptor descriptor) : base(tree, layout, descriptor) { }
public LuceneIndexAccessor(SchemaIndex luceneIndex, IndexDescriptor descriptor) : base(luceneIndex, descriptor) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void assertOnIndexCounts(int expectedIndexUpdates, int expectedIndexSize, int expectedUniqueValues, int expectedSampleSize, org.neo4j.storageengine.api.schema.IndexDescriptor indexDescriptor, HighlyAvailableGraphDatabase db) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException, org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException private static void AssertOnIndexCounts(int expectedIndexUpdates, int expectedIndexSize, int expectedUniqueValues, int expectedSampleSize, IndexDescriptor indexDescriptor, HighlyAvailableGraphDatabase db) { using ([email protected] tx = Db.DependencyResolver.resolveDependency(typeof(Kernel)).beginTransaction(@explicit, AUTH_DISABLED)) { IndexReference indexReference = tx.SchemaRead().index(indexDescriptor.Schema()); AssertDoubleLongEquals(expectedIndexUpdates, expectedIndexSize, tx.SchemaRead().indexUpdatesAndSize(indexReference, newDoubleLongRegister())); AssertDoubleLongEquals(expectedUniqueValues, expectedSampleSize, tx.SchemaRead().indexSample(indexReference, newDoubleLongRegister())); } }
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] query, IndexOrder indexOrder, bool needsValues) { this._progressor = progressor; }
public UniqueLuceneIndexPopulator(SchemaIndex index, IndexDescriptor descriptor) : base(index) { this._propertyKeyIds = descriptor.Schema().PropertyIds; this._sampler = new UniqueIndexSampler(); }