org.neo4j.internal.schema.SchemaDescriptorImplementation Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-schema Show documentation
Show all versions of neo4j-schema Show documentation
Schema descriptors and interfaces in Neo4j.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see boolean isSchemaDescriptorType(Class type) {
Preconditions.requireNonNull(type, "type argument cannot be null.");
// TODO: make use of switch with pattern matching of JDK 21 when we do
// not support 17 anymore.
return switch (type.getSimpleName()) {
case "SchemaDescriptor" -> true;
case "LabelSchemaDescriptor" -> schemaArchetype == SchemaArchetype.LABEL_PROPERTY;
case "RelationTypeSchemaDescriptor" -> schemaArchetype == SchemaArchetype.RELATIONSHIP_PROPERTY;
case "FulltextSchemaDescriptor" -> schemaArchetype == SchemaArchetype.MULTI_TOKEN;
case "AnyTokenSchemaDescriptor" -> schemaArchetype == SchemaArchetype.ANY_TOKEN;
case "RelationshipEndpointSchemaDescriptor" -> schemaArchetype == SchemaArchetype.SINGLE_RELATIONSHIP;
case "LabelCoexistenceSchemaDescriptor" -> schemaArchetype == SchemaArchetype.SINGLE_LABEL;
default -> false;
};
}
@Override
public T asSchemaDescriptorType(Class type) {
if (isSchemaDescriptorType(type)) {
return (T) this;
}
throw cannotCastException(type.getSimpleName());
}
private IllegalStateException cannotCastException(String descriptorType) {
return new IllegalStateException("Cannot cast this schema to a " + descriptorType
+ " because it does not match that structure: " + this + ".");
}
@Override
public boolean isAffected(int[] entityTokenIds) {
for (int id : entityTokens) {
if (ArrayUtils.contains(entityTokenIds, id)) {
return true;
}
}
return false;
}
@Override
public String userDescription(TokenNameLookup tokenNameLookup) {
return SchemaUserDescription.forSchema(tokenNameLookup, entityType, entityTokens, propertyKeyIds);
}
@Override
public int[] getPropertyIds() {
return propertyKeyIds;
}
@Override
public int[] getEntityTokenIds() {
return entityTokens;
}
@Override
public ResourceType keyType() {
return entityType == EntityType.NODE ? ResourceType.LABEL : ResourceType.RELATIONSHIP_TYPE;
}
@Override
public EntityType entityType() {
return entityType;
}
@Override
public SchemaPatternMatchingType schemaPatternMatchingType() {
return schemaPatternMatchingType;
}
@Override
public long[] lockingKeys() {
// for AnyToken schema which doesn't have specific token ids lock on max long
if (schemaArchetype == SchemaArchetype.ANY_TOKEN) {
return TOKEN_INDEX_LOCKING_IDS;
}
int[] tokenIds = getEntityTokenIds();
int tokenCount = tokenIds.length;
long[] lockingIds = new long[tokenCount];
for (int i = 0; i < tokenCount; i++) {
lockingIds[i] = tokenIds[i];
}
Arrays.sort(lockingIds); // Sort to ensure labels are locked and assigned in order.
return lockingIds;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof SchemaDescriptor that)) {
return false;
}
return entityType == that.entityType()
&& schemaPatternMatchingType == that.schemaPatternMatchingType()
&& Arrays.equals(entityTokens, that.getEntityTokenIds())
&& Arrays.equals(propertyKeyIds, that.getPropertyIds());
}
@Override
public int hashCode() {
int result = entityType.hashCode();
result = 31 * result + schemaPatternMatchingType.hashCode();
result = 31 * result + Arrays.hashCode(entityTokens);
result = 31 * result + Arrays.hashCode(propertyKeyIds);
return result;
}
@Override
public String toString() {
return userDescription(TOKEN_ID_NAME_LOOKUP);
}
/**
* Currently there are 4 schema archetypes:
* 1. LABEL_PROPERTY - schema that describes exactly one label, and one or more properties.
* This schema matches nodes that are labeled with specified label, and have all specified properties.
* 2. RELATIONSHIP_PROPERTY - schema that describes exactly one relationship type, and one or more properties.
* This schema matches relationship of specified type that have all specified properties.
* 3. MULTI_TOKEN - schema that describes at least one label or type, and one or more properties.
* This schema matches node/relationship if at least one of it's label/type is specified by the schema,
* and if node/relationship has at least one property specified by the schema.
* I.e. fulltext indexes are described by this kind of schema
* 4. ANY_TOKEN - schema that describes any labels or any relationship types, not specifying any properties.
* Any labeled node or any relationship type is matched by this schema.
* 5. SINGLE_RELATIONSHIP - schema that describes exactly one relationship type and no properties.
* This schema matches relationships of specified type.
* 6. SINGLE_LABEL - schema that describes exactly one label and no properties.
* This schema matches nodes that are labeled with specified label.
*/
private enum SchemaArchetype {
LABEL_PROPERTY,
RELATIONSHIP_PROPERTY,
MULTI_TOKEN,
ANY_TOKEN,
SINGLE_RELATIONSHIP,
SINGLE_LABEL
}
}