From 6089e18a22a8eb9b26f2c785b0a93e0c015fc6d1 Mon Sep 17 00:00:00 2001 From: fickludd Date: Wed, 22 Feb 2017 17:06:52 +0100 Subject: [PATCH] ConstraintDescriptor subclasses for increased type safety - Pushed final boundary in ConstrainSemantics - Fixed some trailing TODOs --- .../constaints/ConstraintDescriptor.java | 95 +++---------------- .../ConstraintDescriptorFactory.java | 66 +++++++++---- .../NodeExistenceConstraintDescriptor.java | 51 ++++++++++ .../RelExistenceConstraintDescriptor.java | 51 ++++++++++ .../UniquenessConstraintDescriptor.java | 58 +++++++++++ .../kernel/api/txstate/TransactionState.java | 3 +- .../ConstraintEnforcingEntityOperations.java | 16 +++- .../api/StateHandlingStatementOperations.java | 3 +- .../api/operations/SchemaReadOperations.java | 2 +- .../neo4j/kernel/impl/api/state/TxState.java | 12 +-- .../kernel/impl/api/store/SchemaCache.java | 4 +- .../impl/constraints/ConstraintSemantics.java | 6 +- .../StandardConstraintSemantics.java | 29 +++--- .../TransactionToRecordStateVisitor.java | 8 +- .../impl/store/record/ConstraintRule.java | 3 +- .../ConstraintDescriptorFactoryTest.java | 10 -- .../StateHandlingStatementOperationsTest.java | 7 +- .../kernel/impl/api/state/TxStateTest.java | 11 ++- .../impl/api/store/SchemaCacheTest.java | 4 +- .../impl/store/record/ConstraintRuleTest.java | 15 ++- .../record/SchemaRuleSerializationTest.java | 4 - .../state/IntegrityValidatorTest.java | 4 +- .../EnterpriseConstraintSemantics.java | 6 +- 23 files changed, 300 insertions(+), 168 deletions(-) create mode 100644 community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/NodeExistenceConstraintDescriptor.java create mode 100644 community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/RelExistenceConstraintDescriptor.java create mode 100644 community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/UniquenessConstraintDescriptor.java diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptor.java b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptor.java index 8a3654c29a0ed..1826472fd8292 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptor.java @@ -20,21 +20,15 @@ package org.neo4j.kernel.api.schema_new.constaints; import org.neo4j.kernel.api.TokenNameLookup; -import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; -import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor; -import org.neo4j.kernel.api.schema_new.SchemaComputer; import org.neo4j.kernel.api.schema_new.SchemaDescriptor; -import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; -import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import static java.lang.String.format; -import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor.Type.UNIQUE; /** * Internal representation of a graph constraint, including the schema unit it targets (eg. label-property combination) * and the how that schema unit is constrained (eg. "has to exist", or "must be unique"). */ -public class ConstraintDescriptor implements SchemaDescriptor.Supplier +public abstract class ConstraintDescriptor implements SchemaDescriptor.Supplier { public enum Type { UNIQUE, EXISTS } @@ -43,31 +37,16 @@ public interface Supplier ConstraintDescriptor getConstraintDescriptor(); } - private final SchemaDescriptor schema; private final ConstraintDescriptor.Type type; - ConstraintDescriptor( SchemaDescriptor schema, Type type ) + ConstraintDescriptor( Type type ) { - this.schema = schema; this.type = type; } // METHODS - @Override - public SchemaDescriptor schema() - { - return schema; - } - - public NewIndexDescriptor ownedIndexDescriptor() - { - if ( type == UNIQUE && schema instanceof LabelSchemaDescriptor ) - { - return NewIndexDescriptorFactory.uniqueForSchema( (LabelSchemaDescriptor)schema ); - } - throw new IllegalStateException( "Only unique constraints on label-property combinations are allowed" ); - } + public abstract SchemaDescriptor schema(); public Type type() { @@ -80,7 +59,7 @@ public Type type() */ public String userDescription( TokenNameLookup tokenNameLookup ) { - return format( "Constraint( %s, %s )", type.name(), schema.userDescription( tokenNameLookup ) ); + return format( "Constraint( %s, %s )", type.name(), schema().userDescription( tokenNameLookup ) ); } /** @@ -88,13 +67,13 @@ public String userDescription( TokenNameLookup tokenNameLookup ) * @param supplier supplier to get a constraint descriptor from * @return true if the supplied constraint descriptor equals this constraint descriptor */ - public boolean isSame( Supplier supplier ) + public final boolean isSame( Supplier supplier ) { return this.equals( supplier.getConstraintDescriptor() ); } @Override - public boolean equals( Object o ) + public final boolean equals( Object o ) { if ( o != null && o instanceof ConstraintDescriptor ) { @@ -105,69 +84,23 @@ public boolean equals( Object o ) } @Override - public int hashCode() + public final int hashCode() { - return type.hashCode() & schema.hashCode(); + return type.hashCode() & schema().hashCode(); } // PRETTY PRINTING - public String prettyPrint( TokenNameLookup tokenNameLookup ) - { - return schema.computeWith( new ConstraintPrettyPrinter( tokenNameLookup ) ); - } + public abstract String prettyPrint( TokenNameLookup tokenNameLookup ); - private class ConstraintPrettyPrinter implements SchemaComputer + String escapeLabelOrRelTyp( String name ) { - private final TokenNameLookup tokenNameLookup; - - ConstraintPrettyPrinter( TokenNameLookup tokenNameLookup ) - { - this.tokenNameLookup = tokenNameLookup; - } - - @Override - public String computeSpecific( LabelSchemaDescriptor schema ) - { - assert schema.getPropertyIds().length == 1; - String labelName = labelName( schema.getLabelId(), tokenNameLookup ); - String nodeName = labelName.toLowerCase(); - String propertyName = tokenNameLookup.propertyKeyGetName( schema.getPropertyIds()[0] ); - if ( type == UNIQUE ) - { - return String.format( "CONSTRAINT ON ( %s:%s ) ASSERT %s.%s IS UNIQUE", - nodeName, labelName, nodeName, propertyName ); - } - else - { - return String.format( "CONSTRAINT ON ( %s:%s ) ASSERT exists(%s.%s)", - nodeName, labelName, nodeName, propertyName ); - } + if (name.contains( ":" )) { + return "`" + name + "`"; } - - @Override - public String computeSpecific( RelationTypeSchemaDescriptor schema ) - { - assert schema.getPropertyIds().length == 1; - String typeName = tokenNameLookup.relationshipTypeGetName( schema.getRelTypeId() ); - String relName = typeName.toLowerCase(); - String propertyName = tokenNameLookup.propertyKeyGetName( schema.getPropertyIds()[0] ); - return String.format( "CONSTRAINT ON ()-[ %s:%s ]-() ASSERT exists(%s.%s)", - relName, typeName, relName, propertyName ); - } - - private String labelName( int labelId, TokenNameLookup tokenNameLookup ) + else { - String labelName = tokenNameLookup.labelGetName( labelId ); - //if the labelName contains a `:` we must escape it to avoid disambiguation, - //e.g. CONSTRAINT on foo:bar:foo:bar - if (labelName.contains( ":" )) { - return "`" + labelName + "`"; - } - else - { - return labelName; - } + return name; } } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactory.java b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactory.java index d9e0214ed7e1c..96f1769553d5f 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactory.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactory.java @@ -19,41 +19,75 @@ */ package org.neo4j.kernel.api.schema_new.constaints; +import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; +import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor; +import org.neo4j.kernel.api.schema_new.SchemaComputer; import org.neo4j.kernel.api.schema_new.SchemaDescriptor; import org.neo4j.kernel.api.schema_new.SchemaDescriptorFactory; +import org.neo4j.kernel.api.schema_new.SchemaUtil; -import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor.Type.EXISTS; -import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor.Type.UNIQUE; +import static java.lang.String.format; public class ConstraintDescriptorFactory { - public static ConstraintDescriptor existsForLabel( int labelId, int... propertyIds ) + public static NodeExistenceConstraintDescriptor existsForLabel( int labelId, int... propertyIds ) { - return existsForSchema( SchemaDescriptorFactory.forLabel( labelId, propertyIds ) ); + return new NodeExistenceConstraintDescriptor( SchemaDescriptorFactory.forLabel( labelId, propertyIds ) ); } - public static ConstraintDescriptor existsForRelType( int relTypeId, int... propertyIds ) + public static RelExistenceConstraintDescriptor existsForRelType( int relTypeId, int... propertyIds ) { - return existsForSchema( SchemaDescriptorFactory.forRelType( relTypeId, propertyIds ) ); + return new RelExistenceConstraintDescriptor( SchemaDescriptorFactory.forRelType( relTypeId, propertyIds ) ); } - public static ConstraintDescriptor uniqueForLabel( int labelId, int... propertyIds ) + public static UniquenessConstraintDescriptor uniqueForLabel( int labelId, int... propertyIds ) { - return uniqueForSchema( SchemaDescriptorFactory.forLabel( labelId, propertyIds ) ); - } - - public static ConstraintDescriptor uniqueForRelType( int relTypeId, int... propertyIds ) - { - return uniqueForSchema( SchemaDescriptorFactory.forRelType( relTypeId, propertyIds ) ); + return new UniquenessConstraintDescriptor( SchemaDescriptorFactory.forLabel( labelId, propertyIds ) ); } public static ConstraintDescriptor existsForSchema( SchemaDescriptor schema ) { - return new ConstraintDescriptor( schema, EXISTS ); + return schema.computeWith( convertToExistenceConstraint ); } - public static ConstraintDescriptor uniqueForSchema( SchemaDescriptor schema ) + public static UniquenessConstraintDescriptor uniqueForSchema( SchemaDescriptor schema ) { - return new ConstraintDescriptor( schema, UNIQUE ); + return schema.computeWith( convertToUniquenessConstraint ); } + + private static SchemaComputer convertToExistenceConstraint = + new SchemaComputer() + { + @Override + public ConstraintDescriptor computeSpecific( LabelSchemaDescriptor schema ) + { + return new NodeExistenceConstraintDescriptor( schema ); + } + + @Override + public ConstraintDescriptor computeSpecific( RelationTypeSchemaDescriptor schema ) + { + return new RelExistenceConstraintDescriptor( schema ); + } + }; + + private static SchemaComputer convertToUniquenessConstraint = + new SchemaComputer() + { + @Override + public UniquenessConstraintDescriptor computeSpecific( LabelSchemaDescriptor schema ) + { + return new UniquenessConstraintDescriptor( schema ); + } + + @Override + public UniquenessConstraintDescriptor computeSpecific( RelationTypeSchemaDescriptor schema ) + { + throw new UnsupportedOperationException( + format( "Cannot create uniqueness constraint for schema '%s' of type %s", + schema.userDescription( SchemaUtil.idTokenNameLookup ), + schema.getClass().getSimpleName() + ) ); + } + }; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/NodeExistenceConstraintDescriptor.java b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/NodeExistenceConstraintDescriptor.java new file mode 100644 index 0000000000000..369452b313809 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/NodeExistenceConstraintDescriptor.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.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 . + */ +package org.neo4j.kernel.api.schema_new.constaints; + +import org.neo4j.kernel.api.TokenNameLookup; +import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; + +public class NodeExistenceConstraintDescriptor extends ConstraintDescriptor +{ + private LabelSchemaDescriptor schema; + + NodeExistenceConstraintDescriptor( LabelSchemaDescriptor schema ) + { + super( Type.EXISTS ); + this.schema = schema; + } + + @Override + public LabelSchemaDescriptor schema() + { + return schema; + } + + @Override + public String prettyPrint( TokenNameLookup tokenNameLookup ) + { + String labelName = escapeLabelOrRelTyp( tokenNameLookup.labelGetName( schema.getLabelId() ) ); + String nodeName = labelName.toLowerCase(); + String propertyName = tokenNameLookup.propertyKeyGetName( schema.getPropertyId() ); + + return String.format( "CONSTRAINT ON ( %s:%s ) ASSERT exists(%s.%s)", + nodeName, labelName, nodeName, propertyName ); + } +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/RelExistenceConstraintDescriptor.java b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/RelExistenceConstraintDescriptor.java new file mode 100644 index 0000000000000..a9ee0e1487178 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/RelExistenceConstraintDescriptor.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.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 . + */ +package org.neo4j.kernel.api.schema_new.constaints; + +import org.neo4j.kernel.api.TokenNameLookup; +import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor; + +public class RelExistenceConstraintDescriptor extends ConstraintDescriptor +{ + private final RelationTypeSchemaDescriptor schema; + + RelExistenceConstraintDescriptor( RelationTypeSchemaDescriptor schema ) + { + super( Type.EXISTS ); + this.schema = schema; + } + + @Override + public RelationTypeSchemaDescriptor schema() + { + return schema; + } + + @Override + public String prettyPrint( TokenNameLookup tokenNameLookup ) + { + String typeName = escapeLabelOrRelTyp( tokenNameLookup.relationshipTypeGetName( schema.getRelTypeId() ) ); + String relName = typeName.toLowerCase(); + String propertyName = tokenNameLookup.propertyKeyGetName( schema.getPropertyId() ); + + return String.format( "CONSTRAINT ON ()-[ %s:%s ]-() ASSERT exists(%s.%s)", + relName, typeName, relName, propertyName ); + } +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/UniquenessConstraintDescriptor.java b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/UniquenessConstraintDescriptor.java new file mode 100644 index 0000000000000..f0d39a36d7b2b --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/UniquenessConstraintDescriptor.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.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 . + */ +package org.neo4j.kernel.api.schema_new.constaints; + +import org.neo4j.kernel.api.TokenNameLookup; +import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; + +public class UniquenessConstraintDescriptor extends ConstraintDescriptor +{ + private final LabelSchemaDescriptor schema; + + UniquenessConstraintDescriptor( LabelSchemaDescriptor schema ) + { + super( Type.UNIQUE ); + this.schema = schema; + } + + @Override + public LabelSchemaDescriptor schema() + { + return schema; + } + + public NewIndexDescriptor ownedIndexDescriptor() + { + return NewIndexDescriptorFactory.uniqueForSchema( schema ); + } + + @Override + public String prettyPrint( TokenNameLookup tokenNameLookup ) + { + String labelName = escapeLabelOrRelTyp( tokenNameLookup.labelGetName( schema.getLabelId() ) ); + String nodeName = labelName.toLowerCase(); + String propertyName = tokenNameLookup.propertyKeyGetName( schema.getPropertyId() ); + + return String.format( "CONSTRAINT ON ( %s:%s ) ASSERT %s.%s IS UNIQUE", + nodeName, labelName, nodeName, propertyName ); + } +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionState.java b/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionState.java index 34dbbfb134b6f..6bcaabee0be16 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionState.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionState.java @@ -23,6 +23,7 @@ import org.neo4j.kernel.api.properties.Property; import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.storageengine.api.txstate.ReadableTransactionState; @@ -83,7 +84,7 @@ void relationshipDoReplaceProperty( long relationshipId, void constraintDoAdd( ConstraintDescriptor constraint ); - void constraintDoAdd( ConstraintDescriptor constraint, long indexId ); + void constraintDoAdd( UniquenessConstraintDescriptor constraint, long indexId ); void constraintDoDrop( ConstraintDescriptor constraint ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/ConstraintEnforcingEntityOperations.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/ConstraintEnforcingEntityOperations.java index 9eb4fa7db17ec..a30d1862343ac 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/ConstraintEnforcingEntityOperations.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/ConstraintEnforcingEntityOperations.java @@ -55,6 +55,7 @@ import org.neo4j.kernel.api.schema_new.SchemaBoundary; import org.neo4j.kernel.api.schema_new.SchemaDescriptorFactory; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.kernel.impl.api.operations.EntityOperations; import org.neo4j.kernel.impl.api.operations.EntityReadOperations; @@ -108,12 +109,13 @@ public boolean nodeAddLabel( KernelStatement state, long nodeId, int labelId ) ConstraintDescriptor constraint = constraints.next(); if ( constraint.type() == UNIQUE ) { + UniquenessConstraintDescriptor uniqueConstraint = (UniquenessConstraintDescriptor) constraint; // TODO: Support composite indexes - Object propertyValue = node.getProperty( constraint.schema().getPropertyIds()[0] ); + Object propertyValue = node.getProperty( uniqueConstraint.schema().getPropertyId() ); if ( propertyValue != null ) { // TODO: Support composite indexes - validateNoExistingNodeWithLabelAndProperty( state, constraint, propertyValue, node.id() ); + validateNoExistingNodeWithLabelAndProperty( state, uniqueConstraint, propertyValue, node.id() ); } } } @@ -136,10 +138,14 @@ public Property nodeSetProperty( KernelStatement state, long nodeId, DefinedProp Iterator constraints = schemaReadOperations.constraintsGetForSchema( state, SchemaDescriptorFactory.forLabel( labelId, propertyKeyId ) ); - if ( constraints.hasNext() ) + while ( constraints.hasNext() ) { ConstraintDescriptor constraint = constraints.next(); - validateNoExistingNodeWithLabelAndProperty( state, constraint, property.value(), node.id() ); + if ( constraint.type() == UNIQUE ) + { + validateNoExistingNodeWithLabelAndProperty( + state, (UniquenessConstraintDescriptor) constraint, property.value(), node.id() ); + } } return false; } ); @@ -150,7 +156,7 @@ public Property nodeSetProperty( KernelStatement state, long nodeId, DefinedProp private void validateNoExistingNodeWithLabelAndProperty( KernelStatement state, - ConstraintDescriptor constraint, + UniquenessConstraintDescriptor constraint, Object value, long modifiedNode ) throws ConstraintValidationException diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java index ebb5a64c93b08..7f2bd50b081db 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java @@ -74,6 +74,7 @@ import org.neo4j.kernel.api.schema_new.constaints.ConstraintBoundary; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.IndexBoundary; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.kernel.api.txstate.TransactionCountingStateVisitor; @@ -451,7 +452,7 @@ public UniquenessConstraint uniquePropertyConstraintCreate( KernelStatement stat throws CreateConstraintFailureException { LabelSchemaDescriptor schema = SchemaBoundary.map( descriptor ); - ConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForSchema( schema ); + UniquenessConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForSchema( schema ); try { if ( state.hasTxStateWithChanges() && diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/operations/SchemaReadOperations.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/operations/SchemaReadOperations.java index 32f5069b91fd6..7ce3b43b71ba1 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/operations/SchemaReadOperations.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/operations/SchemaReadOperations.java @@ -96,7 +96,7 @@ PopulationProgress indexGetPopulationProgress( KernelStatement state, NewIndexDe Iterator constraintsGetForSchema( KernelStatement state, SchemaDescriptor descriptor ); /** - * TODO: Write me. {@link ConstraintDescriptor} + * Returns true if a constraint exists that matches the given {@link ConstraintDescriptor}. */ boolean constraintExists( KernelStatement state, ConstraintDescriptor descriptor ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java index 985dfe4e769fc..6560a62ab163e 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java @@ -33,7 +33,6 @@ import org.neo4j.collection.primitive.PrimitiveLongSet; import org.neo4j.cursor.Cursor; import org.neo4j.helpers.collection.Iterables; -import org.neo4j.kernel.api.constraints.RelationshipPropertyConstraint; import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationException; import org.neo4j.kernel.api.exceptions.schema.CreateConstraintFailureException; import org.neo4j.kernel.api.properties.DefinedProperty; @@ -42,6 +41,7 @@ import org.neo4j.kernel.api.schema_new.SchemaDescriptor; import org.neo4j.kernel.api.schema_new.SchemaDescriptorPredicates; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.kernel.api.txstate.RelationshipChangeVisitorAdapter; import org.neo4j.kernel.api.txstate.TransactionState; @@ -158,7 +158,7 @@ void setMap( TxState state, Map map ) private PrimitiveLongSet nodesDeletedInTx; private PrimitiveLongSet relationshipsDeletedInTx; - private Map createdConstraintIndexesByConstraint; + private Map createdConstraintIndexesByConstraint; private PrimitiveIntObjectMap>> indexUpdates; @@ -911,7 +911,7 @@ private GraphState getOrCreateGraphState() } @Override - public void constraintDoAdd( ConstraintDescriptor constraint, long indexId ) + public void constraintDoAdd( UniquenessConstraintDescriptor constraint, long indexId ) { constraintsChangesDiffSets().add( constraint ); createdConstraintIndexesByConstraint().put( constraint, indexId ); @@ -964,7 +964,7 @@ public void constraintDoDrop( ConstraintDescriptor constraint ) constraintsChangesDiffSets().remove( constraint ); if ( constraint.type() == ConstraintDescriptor.Type.UNIQUE ) { - indexDoDrop( getIndexForUniqueConstraint( constraint ) ); + indexDoDrop( getIndexForUniqueConstraint( (UniquenessConstraintDescriptor)constraint ) ); } changed(); } @@ -1280,7 +1280,7 @@ private DiffSets getIndexUpdatesForScanOrSeek( int label, int propertyId ) return diffs; } - private Map createdConstraintIndexesByConstraint() + private Map createdConstraintIndexesByConstraint() { if ( createdConstraintIndexesByConstraint == null ) { @@ -1289,7 +1289,7 @@ private Map createdConstraintIndexesByConstraint() return createdConstraintIndexesByConstraint; } - private NewIndexDescriptor getIndexForUniqueConstraint( ConstraintDescriptor constraint ) + private NewIndexDescriptor getIndexForUniqueConstraint( UniquenessConstraintDescriptor constraint ) { return constraint.ownedIndexDescriptor(); } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/SchemaCache.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/SchemaCache.java index 56fe24c388e0d..d0667b7cc9e91 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/SchemaCache.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/SchemaCache.java @@ -134,7 +134,7 @@ public void addSchemaRule( SchemaRule rule ) { ConstraintRule constraintRule = (ConstraintRule) rule; constraintRuleById.put( constraintRule.getId(), constraintRule ); - constraints.add( ConstraintBoundary.map( constraintSemantics.readConstraint( constraintRule ) ) ); + constraints.add( constraintSemantics.readConstraint( constraintRule ) ); } else if ( rule instanceof IndexRule ) { @@ -166,7 +166,7 @@ public void removeSchemaRule( long id ) if ( constraintRuleById.containsKey( id ) ) { ConstraintRule rule = constraintRuleById.remove( id ); - constraints.remove( ConstraintBoundary.map( constraintSemantics.readConstraint( rule ) ) ); + constraints.remove( constraintSemantics.readConstraint( rule ) ); } else if ( indexRuleById.containsKey( id ) ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/ConstraintSemantics.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/ConstraintSemantics.java index 40988f587b4a1..5ac8bd63b118e 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/ConstraintSemantics.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/ConstraintSemantics.java @@ -22,11 +22,11 @@ import java.util.Iterator; import org.neo4j.cursor.Cursor; -import org.neo4j.kernel.api.constraints.PropertyConstraint; import org.neo4j.kernel.api.exceptions.schema.CreateConstraintFailureException; import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.impl.store.record.ConstraintRule; import org.neo4j.storageengine.api.NodeItem; import org.neo4j.storageengine.api.RelationshipItem; @@ -45,9 +45,9 @@ void validateExistenceConstraint( Iterator> allNodes, LabelSche void validateExistenceConstraint( Cursor allRels, RelationTypeSchemaDescriptor descriptor ) throws CreateConstraintFailureException; - PropertyConstraint readConstraint( ConstraintRule rule ); + ConstraintDescriptor readConstraint( ConstraintRule rule ); - ConstraintRule createUniquenessConstraintRule( long ruleId, ConstraintDescriptor descriptor, long indexId ); + ConstraintRule createUniquenessConstraintRule( long ruleId, UniquenessConstraintDescriptor descriptor, long indexId ); ConstraintRule createExistenceConstraint( long ruleId, ConstraintDescriptor descriptor ) throws CreateConstraintFailureException; diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/StandardConstraintSemantics.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/StandardConstraintSemantics.java index 6a8ec45d2fbc7..989100109e61f 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/StandardConstraintSemantics.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/constraints/StandardConstraintSemantics.java @@ -22,12 +22,13 @@ import java.util.Iterator; import org.neo4j.cursor.Cursor; -import org.neo4j.kernel.api.constraints.PropertyConstraint; import org.neo4j.kernel.api.exceptions.schema.CreateConstraintFailureException; import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor; -import org.neo4j.kernel.api.schema_new.constaints.ConstraintBoundary; +import org.neo4j.kernel.api.schema_new.SchemaDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.impl.store.record.ConstraintRule; import org.neo4j.storageengine.api.NodeItem; import org.neo4j.storageengine.api.RelationshipItem; @@ -45,44 +46,44 @@ public class StandardConstraintSemantics implements ConstraintSemantics public void validateExistenceConstraint( Iterator> allNodes, LabelSchemaDescriptor descriptor ) throws CreateConstraintFailureException { - // TODO: fix exceptions - throw propertyExistenceConstraintsNotAllowed( null ); + throw propertyExistenceConstraintsNotAllowed( descriptor ); } @Override public void validateExistenceConstraint( Cursor allRels, RelationTypeSchemaDescriptor descriptor ) throws CreateConstraintFailureException { - // TODO: fix exceptions - throw propertyExistenceConstraintsNotAllowed( null ); + throw propertyExistenceConstraintsNotAllowed( descriptor ); } @Override - public PropertyConstraint readConstraint( ConstraintRule rule ) + public ConstraintDescriptor readConstraint( ConstraintRule rule ) { ConstraintDescriptor desc = rule.getConstraintDescriptor(); if ( desc.type() == UNIQUE ) { - return ConstraintBoundary.map( desc ); + return desc; } return readNonStandardConstraint( rule ); } - protected PropertyConstraint readNonStandardConstraint( ConstraintRule rule ) + protected ConstraintDescriptor readNonStandardConstraint( ConstraintRule rule ) { // When opening a store in Community Edition that contains a Property Existence Constraint throw new IllegalStateException( ERROR_MESSAGE ); } - private CreateConstraintFailureException propertyExistenceConstraintsNotAllowed( ConstraintDescriptor constraint ) + private CreateConstraintFailureException propertyExistenceConstraintsNotAllowed( SchemaDescriptor descriptor ) { // When creating a Property Existence Constraint in Community Edition - return new CreateConstraintFailureException( constraint, new IllegalStateException( ERROR_MESSAGE ) ); + return new CreateConstraintFailureException( + ConstraintDescriptorFactory.existsForSchema( descriptor ), + new IllegalStateException( ERROR_MESSAGE ) ); } @Override - public ConstraintRule createUniquenessConstraintRule( long ruleId, ConstraintDescriptor descriptor, - long indexId ) + public ConstraintRule createUniquenessConstraintRule( + long ruleId, UniquenessConstraintDescriptor descriptor, long indexId ) { return ConstraintRule.constraintRule( ruleId, descriptor, indexId ); } @@ -91,7 +92,7 @@ public ConstraintRule createUniquenessConstraintRule( long ruleId, ConstraintDes public ConstraintRule createExistenceConstraint( long ruleId, ConstraintDescriptor descriptor ) throws CreateConstraintFailureException { - throw propertyExistenceConstraintsNotAllowed( descriptor ); + throw propertyExistenceConstraintsNotAllowed( descriptor.schema() ); } @Override diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/TransactionToRecordStateVisitor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/TransactionToRecordStateVisitor.java index 7eca16f627fec..c3aa0b3748680 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/TransactionToRecordStateVisitor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/TransactionToRecordStateVisitor.java @@ -29,6 +29,7 @@ import org.neo4j.kernel.api.index.SchemaIndexProvider; import org.neo4j.kernel.api.properties.DefinedProperty; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap; import org.neo4j.kernel.impl.constraints.ConstraintSemantics; @@ -201,9 +202,10 @@ public void visitAddedConstraint( ConstraintDescriptor constraint ) throws Creat switch ( constraint.type() ) { case UNIQUE: - IndexRule indexRule = schemaStorage.indexGetForSchema( constraint.ownedIndexDescriptor() ); + UniquenessConstraintDescriptor uniqueConstraint = (UniquenessConstraintDescriptor) constraint; + IndexRule indexRule = schemaStorage.indexGetForSchema( uniqueConstraint.ownedIndexDescriptor() ); recordState.createSchemaRule( constraintSemantics.createUniquenessConstraintRule( - constraintId, constraint, indexRule.getId() ) ); + constraintId, uniqueConstraint, indexRule.getId() ) ); recordState.setConstraintIndexOwner( indexRule, constraintId ); break; @@ -238,7 +240,7 @@ public void visitRemovedConstraint( ConstraintDescriptor constraint ) if ( constraint.type() == ConstraintDescriptor.Type.UNIQUE ) { // Remove the index for the constraint as well - visitRemovedIndex( constraint.ownedIndexDescriptor() ); + visitRemovedIndex( ((UniquenessConstraintDescriptor)constraint).ownedIndexDescriptor() ); } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/ConstraintRule.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/ConstraintRule.java index 29cc680a59978..862374b1325ee 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/ConstraintRule.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/ConstraintRule.java @@ -23,6 +23,7 @@ import org.neo4j.kernel.api.schema_new.SchemaDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.storageengine.api.schema.SchemaRule; import static org.neo4j.kernel.api.schema_new.SchemaUtil.idTokenNameLookup; @@ -46,7 +47,7 @@ public static ConstraintRule constraintRule( } public static ConstraintRule constraintRule( - long id, ConstraintDescriptor descriptor, long ownedIndexRule ) + long id, UniquenessConstraintDescriptor descriptor, long ownedIndexRule ) { return new ConstraintRule( id, descriptor, ownedIndexRule ); } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactoryTest.java b/community/kernel/src/test/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactoryTest.java index 200ce9bfea267..608a0f94b713f 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactoryTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptorFactoryTest.java @@ -55,10 +55,6 @@ public void shouldCreateUniqueConstraintDescriptors() desc = ConstraintDescriptorFactory.uniqueForLabel( LABEL_ID, 1 ); assertThat( desc.type(), equalTo( ConstraintDescriptor.Type.UNIQUE ) ); assertThat( desc.schema(), equalTo( SchemaDescriptorFactory.forLabel( LABEL_ID, 1 ) ) ); - - desc = ConstraintDescriptorFactory.uniqueForRelType( REL_TYPE_ID, 1 ); - assertThat( desc.type(), equalTo( ConstraintDescriptor.Type.UNIQUE ) ); - assertThat( desc.schema(), equalTo( SchemaDescriptorFactory.forRelType( REL_TYPE_ID, 1 ) ) ); } @Test @@ -89,10 +85,6 @@ public void shouldCreateEqualDescriptors() desc2 = ConstraintDescriptorFactory.existsForLabel( LABEL_ID, 1 ); assertEquality( desc1, desc2 ); - desc1 = ConstraintDescriptorFactory.uniqueForRelType( REL_TYPE_ID, 1 ); - desc2 = ConstraintDescriptorFactory.uniqueForRelType( REL_TYPE_ID, 1 ); - assertEquality( desc1, desc2 ); - desc1 = ConstraintDescriptorFactory.existsForRelType( LABEL_ID, 1 ); desc2 = ConstraintDescriptorFactory.existsForRelType( LABEL_ID, 1 ); assertEquality( desc1, desc2 ); @@ -107,7 +99,5 @@ public void shouldGiveNiceUserDescriptions() equalTo( "Constraint( EXISTS, -[:RelType1(property3)]- )" ) ); assertThat( ConstraintDescriptorFactory.uniqueForLabel( 2, 4 ).userDescription( simpleNameLookup ), equalTo( "Constraint( UNIQUE, :Label2(property4) )" ) ); - assertThat( ConstraintDescriptorFactory.uniqueForRelType( 2, 5 ).userDescription( simpleNameLookup ), - equalTo( "Constraint( UNIQUE, -[:RelType2(property5)]- )" ) ); } } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java index 7fe0b194b60de..9de1f379961b1 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java @@ -36,6 +36,7 @@ import org.neo4j.kernel.api.schema_new.SchemaBoundary; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.IndexBoundary; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; @@ -111,7 +112,7 @@ public void shouldNeverDelegateWrites() throws Exception public void shouldNotAddConstraintAlreadyExistsInTheStore() throws Exception { // given - ConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForLabel( descriptor1 + UniquenessConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForLabel( descriptor1 .getLabelId(), descriptor1.getPropertyKeyId() ); TransactionState txState = mock( TransactionState.class ); when( txState.nodesWithLabelChanged( anyInt() ) ).thenReturn( new DiffSets() ); @@ -152,8 +153,8 @@ public void shouldGetConstraintsByLabelAndProperty() throws Exception public void shouldGetConstraintsByLabel() throws Exception { // given - ConstraintDescriptor constraint1 = ConstraintDescriptorFactory.uniqueForLabel( 2, 3 ); - ConstraintDescriptor constraint2 = ConstraintDescriptorFactory.uniqueForLabel( 4, 5 ); + UniquenessConstraintDescriptor constraint1 = ConstraintDescriptorFactory.uniqueForLabel( 2, 3 ); + UniquenessConstraintDescriptor constraint2 = ConstraintDescriptorFactory.uniqueForLabel( 4, 5 ); TransactionState txState = new TxState(); KernelStatement state = mockedState( txState ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/TxStateTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/TxStateTest.java index 53b47470e0919..a5c678665e164 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/TxStateTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/TxStateTest.java @@ -47,6 +47,7 @@ import org.neo4j.kernel.api.schema.RelationshipPropertyDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.api.txstate.TransactionState; @@ -939,7 +940,7 @@ public void shouldListNodeAsDeletedIfItIsDeleted() throws Exception public void shouldAddUniquenessConstraint() throws Exception { // when - ConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); + UniquenessConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); state.constraintDoAdd( constraint, 7 ); // then @@ -953,11 +954,11 @@ public void shouldAddUniquenessConstraint() throws Exception public void addingUniquenessConstraintShouldBeIdempotent() throws Exception { // given - ConstraintDescriptor constraint1 = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); + UniquenessConstraintDescriptor constraint1 = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); state.constraintDoAdd( constraint1, 7 ); // when - ConstraintDescriptor constraint2 = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); + UniquenessConstraintDescriptor constraint2 = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); state.constraintDoAdd( constraint2, 19 ); // then @@ -969,9 +970,9 @@ public void addingUniquenessConstraintShouldBeIdempotent() throws Exception public void shouldDifferentiateBetweenUniquenessConstraintsForDifferentLabels() throws Exception { // when - ConstraintDescriptor constraint1 = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); + UniquenessConstraintDescriptor constraint1 = ConstraintDescriptorFactory.uniqueForLabel( 1, 17 ); state.constraintDoAdd( constraint1, 7 ); - ConstraintDescriptor constraint2 = ConstraintDescriptorFactory.uniqueForLabel( 2, 17 ); + UniquenessConstraintDescriptor constraint2 = ConstraintDescriptorFactory.uniqueForLabel( 2, 17 ); state.constraintDoAdd( constraint2, 19 ); // then diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/SchemaCacheTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/SchemaCacheTest.java index 398761e95ec54..0387807080898 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/SchemaCacheTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/SchemaCacheTest.java @@ -287,13 +287,13 @@ private static SchemaCache newSchemaCache( SchemaRule... rules ) private static class ConstraintSemantics extends StandardConstraintSemantics { @Override - protected PropertyConstraint readNonStandardConstraint( ConstraintRule rule ) + protected ConstraintDescriptor readNonStandardConstraint( ConstraintRule rule ) { if ( rule.getConstraintDescriptor().type() != EXISTS ) { throw new IllegalStateException( "Unsupported constraint type: " + rule ); } - return ConstraintBoundary.map( rule.getConstraintDescriptor() ); + return rule.getConstraintDescriptor(); } } } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/ConstraintRuleTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/ConstraintRuleTest.java index b84634f734276..521175e0f6555 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/ConstraintRuleTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/ConstraintRuleTest.java @@ -22,13 +22,13 @@ import org.junit.Test; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import static org.hamcrest.Matchers.equalTo; import static org.junit.Assert.assertThat; import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory.existsForLabel; import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory.existsForRelType; import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory.uniqueForLabel; -import static org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory.uniqueForRelType; import static org.neo4j.test.assertion.Assert.assertException; public class ConstraintRuleTest extends SchemaRuleTestBase @@ -51,7 +51,7 @@ public void shouldCreateUniquenessConstraint() throws Exception public void shouldCreateUniquenessConstraintWithOwnedIndex() throws Exception { // GIVEN - ConstraintDescriptor descriptor = uniqueForLabel( LABEL_ID, PROPERTY_ID_1 ); + UniquenessConstraintDescriptor descriptor = uniqueForLabel( LABEL_ID, PROPERTY_ID_1 ); ConstraintRule constraintRule = ConstraintRule.constraintRule( RULE_ID, descriptor, RULE_ID_2 ); // THEN @@ -79,16 +79,23 @@ public void indexRulesAreEqualBasedOnConstraintDescriptor() throws Exception assertEqualityByDescriptor( existsForLabel( LABEL_ID, PROPERTY_ID_1 ) ); assertEqualityByDescriptor( uniqueForLabel( LABEL_ID, PROPERTY_ID_1 ) ); assertEqualityByDescriptor( existsForRelType( REL_TYPE_ID, PROPERTY_ID_1 ) ); - assertEqualityByDescriptor( uniqueForRelType( REL_TYPE_ID, PROPERTY_ID_1 ) ); assertEqualityByDescriptor( existsForLabel( LABEL_ID, PROPERTY_ID_1, PROPERTY_ID_2 ) ); assertEqualityByDescriptor( uniqueForLabel( LABEL_ID, PROPERTY_ID_1, PROPERTY_ID_2 ) ); } - private void assertEqualityByDescriptor( ConstraintDescriptor descriptor ) + private void assertEqualityByDescriptor( UniquenessConstraintDescriptor descriptor ) { ConstraintRule rule1 = ConstraintRule.constraintRule( RULE_ID, descriptor, RULE_ID_2 ); ConstraintRule rule2 = ConstraintRule.constraintRule( RULE_ID_2, descriptor ); assertEquality( rule1, rule2 ); } + + private void assertEqualityByDescriptor( ConstraintDescriptor descriptor ) + { + ConstraintRule rule1 = ConstraintRule.constraintRule( RULE_ID, descriptor ); + ConstraintRule rule2 = ConstraintRule.constraintRule( RULE_ID_2, descriptor ); + + assertEquality( rule1, rule2 ); + } } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/SchemaRuleSerializationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/SchemaRuleSerializationTest.java index 0d598b38d9403..9fa585f1962eb 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/SchemaRuleSerializationTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/record/SchemaRuleSerializationTest.java @@ -67,9 +67,6 @@ public class SchemaRuleSerializationTest extends SchemaRuleTestBase ConstraintRule constraintExistsRelType = ConstraintRule.constraintRule( RULE_ID_2, ConstraintDescriptorFactory.existsForRelType( REL_TYPE_ID, PROPERTY_ID_1 ) ); - ConstraintRule constraintUniqueRelType = ConstraintRule.constraintRule( RULE_ID, - ConstraintDescriptorFactory.uniqueForRelType( REL_TYPE_ID, PROPERTY_ID_1 ), RULE_ID_2 ); - ConstraintRule constraintCompositeLabel = ConstraintRule.constraintRule( RULE_ID, ConstraintDescriptorFactory.existsForLabel( LABEL_ID, PROPERTY_ID_1, PROPERTY_ID_2 ) ); @@ -106,7 +103,6 @@ public void shouldSerializeAndDeserializeConstraintRules() throws MalformedSchem assertSerializeAndDeserializeConstraintRule( constraintExistsLabel ); assertSerializeAndDeserializeConstraintRule( constraintUniqueLabel ); assertSerializeAndDeserializeConstraintRule( constraintExistsRelType ); - assertSerializeAndDeserializeConstraintRule( constraintUniqueRelType ); } @Test diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/state/IntegrityValidatorTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/state/IntegrityValidatorTest.java index 3343f72eabc49..efb9af1558be8 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/state/IntegrityValidatorTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/state/IntegrityValidatorTest.java @@ -23,8 +23,8 @@ import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationException; import org.neo4j.kernel.api.exceptions.schema.UniquePropertyValueValidationException; -import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptorFactory; +import org.neo4j.kernel.api.schema_new.constaints.UniquenessConstraintDescriptor; import org.neo4j.kernel.impl.api.index.IndexingService; import org.neo4j.kernel.impl.store.MetaDataStore; import org.neo4j.kernel.impl.store.NeoStores; @@ -45,7 +45,7 @@ public void shouldValidateUniquenessIndexes() throws Exception NeoStores store = mock( NeoStores.class ); IndexingService indexes = mock(IndexingService.class); IntegrityValidator validator = new IntegrityValidator(store, indexes); - ConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForLabel( 1, 1 ); + UniquenessConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForLabel( 1, 1 ); doThrow( new UniquePropertyValueValidationException( constraint, ConstraintValidationException.Phase.VERIFICATION, new RuntimeException() ) ) diff --git a/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseConstraintSemantics.java b/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseConstraintSemantics.java index d46eaf25fba6c..e66c1d12df683 100644 --- a/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseConstraintSemantics.java +++ b/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseConstraintSemantics.java @@ -24,7 +24,6 @@ import java.util.List; import org.neo4j.cursor.Cursor; -import org.neo4j.kernel.api.constraints.PropertyConstraint; import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationException; import org.neo4j.kernel.api.exceptions.schema.CreateConstraintFailureException; import org.neo4j.kernel.api.exceptions.schema.NodePropertyExistenceException; @@ -32,7 +31,6 @@ import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor; import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor; import org.neo4j.kernel.api.schema_new.SchemaProcessor; -import org.neo4j.kernel.api.schema_new.constaints.ConstraintBoundary; import org.neo4j.kernel.api.schema_new.constaints.ConstraintDescriptor; import org.neo4j.kernel.impl.constraints.StandardConstraintSemantics; import org.neo4j.kernel.impl.store.record.ConstraintRule; @@ -48,13 +46,13 @@ public class EnterpriseConstraintSemantics extends StandardConstraintSemantics { @Override - protected PropertyConstraint readNonStandardConstraint( ConstraintRule rule ) + protected ConstraintDescriptor readNonStandardConstraint( ConstraintRule rule ) { if ( rule.getConstraintDescriptor().type() != EXISTS ) { throw new IllegalStateException( "Unsupported constraint type: " + rule ); } - return ConstraintBoundary.map( rule.getConstraintDescriptor() ); + return rule.getConstraintDescriptor(); } @Override