public override SchemaDescriptor SchemaFor(EntityType type, string[] entityTokens, Properties indexConfiguration, params string[] properties)
{
if (entityTokens.Length == 0)
{
throw new BadSchemaException("At least one " + (type == EntityType.NODE ? "label" : "relationship type") + " must be specified when creating a fulltext index.");
}
if (properties.Length == 0)
{
throw new BadSchemaException("At least one property name must be specified when creating a fulltext index.");
}
if (Arrays.asList(properties).contains(LuceneFulltextDocumentStructure.FIELD_ENTITY_ID))
{
throw new BadSchemaException("Unable to index the property, the name is reserved for internal use " + LuceneFulltextDocumentStructure.FIELD_ENTITY_ID);
}
int[] entityTokenIds = new int[entityTokens.Length];
if (type == EntityType.NODE)
{
_tokenHolders.labelTokens().getOrCreateIds(entityTokens, entityTokenIds);
}
else
{
_tokenHolders.relationshipTypeTokens().getOrCreateIds(entityTokens, entityTokenIds);
}
int[] propertyIds = java.util.properties.Select(_tokenHolders.propertyKeyTokens().getOrCreateId).ToArray();
SchemaDescriptor schema = SchemaDescriptorFactory.multiToken(entityTokenIds, type, propertyIds);
indexConfiguration.putIfAbsent(FulltextIndexSettings.INDEX_CONFIG_ANALYZER, _defaultAnalyzerName);
indexConfiguration.putIfAbsent(FulltextIndexSettings.INDEX_CONFIG_EVENTUALLY_CONSISTENT, _defaultEventuallyConsistentSetting);
return(new FulltextSchemaDescriptor(schema, indexConfiguration));
}
private SchemaDescriptor RandomSchemaDescriptor(int highEntityKeyId, int highPropertyKeyId, int maxNumberOfEntityKeys, int maxNumberOfPropertyKeys)
{
int numberOfEntityKeys = _random.Next(1, maxNumberOfEntityKeys);
int[] entityKeys = RandomUniqueUnsortedIntArray(highEntityKeyId, numberOfEntityKeys);
int numberOfPropertyKeys = _random.Next(1, maxNumberOfPropertyKeys);
int[] propertyKeys = RandomUniqueUnsortedIntArray(highPropertyKeyId, numberOfPropertyKeys);
return(entityKeys.Length > 1 ? SchemaDescriptorFactory.multiToken(entityKeys, EntityType.NODE, propertyKeys) : SchemaDescriptorFactory.forLabel(entityKeys[0], propertyKeys));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldListMultiTokenIndexesInTheCoreAPI() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldListMultiTokenIndexesInTheCoreAPI()
{
Transaction transaction = NewTransaction(AUTH_DISABLED);
MultiTokenSchemaDescriptor descriptor = SchemaDescriptorFactory.multiToken(new int[] { _labelId, _labelId2 }, EntityType.NODE, _propertyKeyId);
transaction.SchemaWrite().indexCreate(descriptor);
Commit();
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: try (@SuppressWarnings("unused") org.neo4j.graphdb.Transaction tx = db.beginTx())
using (Org.Neo4j.Graphdb.Transaction tx = Db.beginTx())
{
ISet <IndexDefinition> indexes = Iterables.asSet(Db.schema().Indexes);
// then
assertEquals(1, indexes.Count);
IndexDefinition index = indexes.GetEnumerator().next();
try
{
index.Label;
fail("index.getLabel() should have thrown. ");
}
catch (System.InvalidOperationException)
{
}
try
{
index.RelationshipType;
fail("index.getRelationshipType() should have thrown. ");
}
catch (System.InvalidOperationException)
{
}
try
{
index.RelationshipTypes;
fail("index.getRelationshipTypes() should have thrown. ");
}
catch (System.InvalidOperationException)
{
}
assertThat(index.Labels, containsInAnyOrder(label(LABEL), label(LABEL2)));
assertFalse("should not be a constraint index", index.ConstraintIndex);
assertTrue("should be a multi-token index", index.MultiTokenIndex);
assertFalse("should not be a composite index", index.CompositeIndex);
assertTrue("should be a node index", index.NodeIndex);
assertFalse("should not be a relationship index", index.RelationshipIndex);
assertEquals(asSet(PROPERTY_KEY), Iterables.asSet(index.PropertyKeys));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldListCompositeMultiTokenRelationshipIndexesInTheCoreAPI() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldListCompositeMultiTokenRelationshipIndexesInTheCoreAPI()
{
Transaction transaction = NewTransaction(AUTH_DISABLED);
SchemaDescriptor descriptor = SchemaDescriptorFactory.multiToken(new int[] { _relType, _relType2 }, EntityType.RELATIONSHIP, _propertyKeyId, _propertyKeyId2);
transaction.SchemaWrite().indexCreate(descriptor);
Commit();
using (Org.Neo4j.Graphdb.Transaction tx = Db.beginTx())
{
ISet <IndexDefinition> indexes = Iterables.asSet(Db.schema().Indexes);
// then
assertEquals(1, indexes.Count);
IndexDefinition index = indexes.GetEnumerator().next();
try
{
index.Label;
fail("index.getLabel() should have thrown. ");
}
catch (System.InvalidOperationException)
{
}
try
{
index.Labels;
fail("index.getLabels() should have thrown. ");
}
catch (System.InvalidOperationException)
{
}
try
{
index.RelationshipType;
fail("index.getRelationshipType() should have thrown. ");
}
catch (System.InvalidOperationException)
{
}
assertThat(index.RelationshipTypes, containsInAnyOrder(withName(REL_TYPE), withName(REL_TYPE2)));
assertFalse("should not be a constraint index", index.ConstraintIndex);
assertTrue("should be a multi-token index", index.MultiTokenIndex);
assertTrue("should be a composite index", index.CompositeIndex);
assertFalse("should not be a node index", index.NodeIndex);
assertTrue("should be a relationship index", index.RelationshipIndex);
assertEquals(asSet(PROPERTY_KEY, PROPERTY_KEY2), Iterables.asSet(index.PropertyKeys));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ParameterizedTest @MethodSource("nodeAndRelationshipEntityTypes") void shouldMatchOnAnyEntityAndPropertyTokenForPartialPropertySchemaType(org.neo4j.storageengine.api.EntityType entityType)
internal virtual void ShouldMatchOnAnyEntityAndPropertyTokenForPartialPropertySchemaType(EntityType entityType)
{
// given
SchemaDescriptorLookupSet <SchemaDescriptor> set = new SchemaDescriptorLookupSet <SchemaDescriptor>();
MultiTokenSchemaDescriptor descriptor1 = SchemaDescriptorFactory.multiToken(Ints(0, 1, 2), entityType, 3, 4, 5);
MultiTokenSchemaDescriptor descriptor2 = SchemaDescriptorFactory.multiToken(Ints(0, 1), entityType, 3, 4);
MultiTokenSchemaDescriptor descriptor3 = SchemaDescriptorFactory.multiToken(Ints(0, 2), entityType, 4, 5);
set.Add(descriptor1);
set.Add(descriptor2);
set.Add(descriptor3);
// given that this test revolves around entity tokens 0,1,2 and property tokens 3,4,5 these 3 descriptors below matches either
// only those tokens for entity or property or neither. I.e. these should never be included in matching results
set.Add(SchemaDescriptorFactory.multiToken(Ints(3, 4), entityType, 4, 5));
set.Add(SchemaDescriptorFactory.multiToken(Ints(0, 1), entityType, 6, 7));
set.Add(SchemaDescriptorFactory.multiToken(Ints(3, 4), entityType, 6, 7));
// when matching these descriptors (in this case partial/complete list doesn't quite matter because the descriptors
// themselves are partially matched anyway.
ISet <SchemaDescriptor> descriptors1 = new HashSet <SchemaDescriptor>();
ISet <SchemaDescriptor> descriptors1Partial = new HashSet <SchemaDescriptor>();
ISet <SchemaDescriptor> descriptors2 = new HashSet <SchemaDescriptor>();
ISet <SchemaDescriptor> descriptors2Partial = new HashSet <SchemaDescriptor>();
ISet <SchemaDescriptor> descriptors3 = new HashSet <SchemaDescriptor>();
ISet <SchemaDescriptor> descriptors3Partial = new HashSet <SchemaDescriptor>();
set.MatchingDescriptorsForCompleteListOfProperties(descriptors1, Longs(0, 1), Ints(4, 5));
set.MatchingDescriptorsForPartialListOfProperties(descriptors1Partial, Longs(0, 1), Ints(4, 5));
set.MatchingDescriptorsForCompleteListOfProperties(descriptors2, Longs(0), Ints(3));
set.MatchingDescriptorsForPartialListOfProperties(descriptors2Partial, Longs(0), Ints(3));
set.MatchingDescriptorsForCompleteListOfProperties(descriptors3, Longs(1), Ints(5));
set.MatchingDescriptorsForPartialListOfProperties(descriptors3Partial, Longs(1), Ints(5));
// then
assertEquals(asSet(descriptor1, descriptor2, descriptor3), descriptors1);
assertEquals(asSet(descriptor1, descriptor2, descriptor3), descriptors1Partial);
assertEquals(asSet(descriptor1, descriptor2), descriptors2);
assertEquals(asSet(descriptor1, descriptor2), descriptors2Partial);
assertEquals(asSet(descriptor1), descriptors3);
assertEquals(asSet(descriptor1), descriptors3Partial);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void removeSchemaWithRepeatedRelType()
public virtual void RemoveSchemaWithRepeatedRelType()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final SchemaCache cache = newSchemaCache();
SchemaCache cache = NewSchemaCache();
const int id = 1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int[] repeatedRelTypes = {0, 1, 0};
int[] repeatedRelTypes = new int[] { 0, 1, 0 };
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.api.schema.MultiTokenSchemaDescriptor schema = org.neo4j.kernel.api.schema.SchemaDescriptorFactory.multiToken(repeatedRelTypes, org.neo4j.storageengine.api.EntityType.RELATIONSHIP, 1);
MultiTokenSchemaDescriptor schema = SchemaDescriptorFactory.multiToken(repeatedRelTypes, EntityType.RELATIONSHIP, 1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.storageengine.api.schema.StoreIndexDescriptor storeIndexDescriptor = org.neo4j.storageengine.api.schema.IndexDescriptorFactory.forSchema(schema).withId(id);
StoreIndexDescriptor storeIndexDescriptor = IndexDescriptorFactory.forSchema(schema).withId(id);
cache.AddSchemaRule(storeIndexDescriptor);
cache.RemoveSchemaRule(id);
}