Made SchemaRule an interface

community/consistency-check/src/test/java/org/neo4j/consistency/checking/full/FullCheckIntegrationTest.java

@@ -103,6 +103,7 @@
 import org.neo4j.kernel.impl.store.record.RelationshipGroupRecord;
 import org.neo4j.kernel.impl.store.record.RelationshipRecord;
 import org.neo4j.kernel.impl.store.record.RelationshipTypeTokenRecord;
+import org.neo4j.kernel.impl.store.record.SchemaRuleSerialization;
 import org.neo4j.kernel.impl.transaction.state.storeview.NeoStoreIndexStoreView;
 import org.neo4j.kernel.impl.util.Bits;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
@@ -1017,7 +1018,7 @@ protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
 
                 schema.setNextBlock( next.schema() ); // Point to a record that isn't in use.
                 IndexRule rule = indexRule( schema.getId(), label1, key1, DESCRIPTOR );
-                schema.setData( rule.serialize() );
+                schema.setData( SchemaRuleSerialization.serialize( rule ) );
 
                 tx.createSchema( asList( schemaBefore ), asList( schema ), rule );
             }
@@ -2379,7 +2380,7 @@ public void andThatsAllFolks()
 
     private static Collection<DynamicRecord> serializeRule( SchemaRule rule, DynamicRecord... records )
     {
-        byte[] data = rule.serialize();
+        byte[] data = SchemaRuleSerialization.serialize( rule );
         DynamicRecordAllocator dynamicRecordAllocator =
                 new ReusableRecordsCompositeAllocator( asList( records ), schemaAllocator );
         Collection<DynamicRecord> result = new ArrayList<>();

community/consistency-check/src/test/java/org/neo4j/consistency/report/ConsistencyReporterTest.java

@@ -413,12 +413,18 @@ private Object parameter( Class<?> type )
 
         private SchemaRule simpleSchemaRule()
         {
-            return new SchemaRule( 0 )
+            return new SchemaRule()
             {
                 @Override
-                public byte[] serialize()
+                public long getId()
                 {
-                    return new byte[0];
+                    return 0;
+                }
+
+                @Override
+                public String getName()
+                {
+                    return null;
                 }
 
                 @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/store/SchemaStore.java

@@ -73,7 +73,7 @@ public List<DynamicRecord> allocateFrom( SchemaRule rule )
         List<DynamicRecord> records = new ArrayList<>();
         DynamicRecord record = getRecord( rule.getId(), nextRecord(), CHECK );
         DynamicRecordAllocator recordAllocator = new ReusableRecordsCompositeAllocator( singleton( record ), this );
-        allocateRecordsFromBytes( records, rule.serialize(), recordAllocator );
+        allocateRecordsFromBytes( records, SchemaRuleSerialization.serialize( rule ), recordAllocator );
         return records;
     }
 

community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/ConstraintRule.java

@@ -26,9 +26,11 @@
 
 import static org.neo4j.internal.kernel.api.schema.SchemaUtil.idTokenNameLookup;
 
-public class ConstraintRule extends SchemaRule implements ConstraintDescriptor.Supplier
+public class ConstraintRule implements SchemaRule, ConstraintDescriptor.Supplier
 {
     private final Long ownedIndexRule;
+    private final String name;
+    private final long id;
     private final ConstraintDescriptor descriptor;
 
     public static ConstraintRule constraintRule(
@@ -62,9 +64,10 @@ public static ConstraintRule constraintRule(
 
     ConstraintRule( long id, ConstraintDescriptor descriptor, Long ownedIndexRule, String name )
     {
-        super( id, name );
+        this.id = id;
         this.descriptor = descriptor;
         this.ownedIndexRule = ownedIndexRule;
+        this.name = SchemaRule.nameOrDefault( name, "constraint_" + id );
     }
 
     @Override
@@ -96,12 +99,6 @@ public long getOwnedIndex()
         return ownedIndexRule;
     }
 
-    @Override
-    public byte[] serialize()
-    {
-        return SchemaRuleSerialization.serialize( this );
-    }
-
     @Override
     public boolean equals( Object o )
     {
@@ -118,4 +115,16 @@ public int hashCode()
     {
         return descriptor.hashCode();
     }
+
+    @Override
+    public long getId()
+    {
+        return id;
+    }
+
+    @Override
+    public String getName()
+    {
+        return name;
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/IndexRule.java

@@ -30,11 +30,13 @@
 /**
  * A {@link Label} can have zero or more index rules which will have data specified in the rules indexed.
  */
-public class IndexRule extends SchemaRule implements SchemaIndexDescriptor.Supplier
+public class IndexRule implements SchemaRule, SchemaIndexDescriptor.Supplier
 {
     private final IndexProvider.Descriptor providerDescriptor;
     private final SchemaIndexDescriptor descriptor;
     private final Long owningConstraint;
+    private final long id;
+    private final String name;
 
     public static IndexRule indexRule( long id, SchemaIndexDescriptor descriptor,
                                        IndexProvider.Descriptor providerDescriptor )
@@ -71,7 +73,8 @@ public static IndexRule constraintIndexRule( long id, SchemaIndexDescriptor desc
     IndexRule( long id, IndexProvider.Descriptor providerDescriptor,
                SchemaIndexDescriptor descriptor, Long owningConstraint, String name )
     {
-        super( id, name );
+        this.id = id;
+        this.name = SchemaRule.nameOrDefault( name, "index_" + id );
         if ( providerDescriptor == null )
         {
             throw new IllegalArgumentException( "null provider descriptor prohibited" );
@@ -128,12 +131,6 @@ public IndexRule withOwningConstraint( long constraintId )
         return constraintIndexRule( id, descriptor, providerDescriptor, constraintId );
     }
 
-    @Override
-    public byte[] serialize()
-    {
-        return SchemaRuleSerialization.serialize( this );
-    }
-
     @Override
     public String toString()
     {
@@ -175,4 +172,16 @@ public int hashCode()
     {
         return this.descriptor.hashCode();
     }
+
+    @Override
+    public long getId()
+    {
+        return id;
+    }
+
+    @Override
+    public String getName()
+    {
+        return name;
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/SchemaRuleSerialization.java

@@ -70,8 +70,27 @@ private SchemaRuleSerialization()
 
     // PUBLIC
 
+    /**
+     * Serialize the provided SchemaRule onto the target buffer
+     *
+     * @param schemaRule the SchemaRule to serialize
+     */
+    public static byte[] serialize( SchemaRule schemaRule )
+    {
+        if ( schemaRule instanceof IndexRule )
+        {
+            return serialize( (IndexRule)schemaRule );
+        }
+        else if ( schemaRule instanceof ConstraintRule )
+        {
+            return serialize( (ConstraintRule)schemaRule );
+        }
+        throw new IllegalStateException( "Unknown schema rule type: "+schemaRule.getClass() );
+    }
+
     /**
      * Parse a SchemaRule from the provided buffer.
+     *
      * @param id the id to give the returned Schema Rule
      * @param source the buffer to parse from
      * @return a SchemaRule
@@ -99,6 +118,7 @@ public static SchemaRule deserialize( long id, ByteBuffer source ) throws Malfor
 
     /**
      * Serialize the provided IndexRule onto the target buffer
+     *
      * @param indexRule the IndexRule to serialize
      * @throws IllegalStateException if the IndexRule is of type unique, but the owning constrain has not been set
      */
@@ -237,14 +257,14 @@ private static IndexRule readIndexRule( long id, ByteBuffer source ) throws Malf
         {
         case GENERAL_INDEX:
             schema = readLabelSchema( source );
-            name = readRuleName( id, IndexRule.class, source );
+            name = readRuleName( source );
             return IndexRule.indexRule( id, SchemaIndexDescriptorFactory.forSchema( schema ), indexProvider, name );
 
         case UNIQUE_INDEX:
             long owningConstraint = source.getLong();
             schema = readLabelSchema( source );
             SchemaIndexDescriptor descriptor = SchemaIndexDescriptorFactory.uniqueForSchema( schema );
-            name = readRuleName( id, IndexRule.class, source );
+            name = readRuleName( source );
             return IndexRule.constraintIndexRule( id, descriptor, indexProvider,
                     owningConstraint == NO_OWNING_CONSTRAINT_YET ? null : owningConstraint, name );
 
@@ -282,38 +302,38 @@ private static ConstraintRule readConstraintRule( long id, ByteBuffer source ) t
         {
         case EXISTS_CONSTRAINT:
             schema = readSchema( source );
-            name = readRuleName( id, ConstraintRule.class, source );
+            name = readRuleName( source );
             return ConstraintRule.constraintRule( id, ConstraintDescriptorFactory.existsForSchema( schema ), name );
 
         case UNIQUE_CONSTRAINT:
             long ownedUniqueIndex = source.getLong();
             schema = readSchema( source );
             UniquenessConstraintDescriptor descriptor = ConstraintDescriptorFactory.uniqueForSchema( schema );
-            name = readRuleName( id, ConstraintRule.class, source );
+            name = readRuleName( source );
             return ConstraintRule.constraintRule( id, descriptor, ownedUniqueIndex, name );
 
         case UNIQUE_EXISTS_CONSTRAINT:
             long ownedNodeKeyIndex = source.getLong();
             schema = readSchema( source );
             NodeKeyConstraintDescriptor nodeKeyConstraintDescriptor = ConstraintDescriptorFactory.nodeKeyForSchema( schema );
-            name = readRuleName( id, ConstraintRule.class, source );
+            name = readRuleName( source );
             return ConstraintRule.constraintRule( id, nodeKeyConstraintDescriptor, ownedNodeKeyIndex, name );
 
         default:
             throw new MalformedSchemaRuleException( format( "Got unknown constraint rule type '%d'.", constraintRuleType ) );
         }
     }
 
-    private static String readRuleName( long id, Class<? extends SchemaRule> type, ByteBuffer source )
+    private static String readRuleName( ByteBuffer source )
     {
         String ruleName = null;
         if ( source.remaining() >= UTF8.MINIMUM_SERIALISED_LENGTH_BYTES )
         {
             ruleName = UTF8.getDecodedStringFrom( source );
-        }
-        if ( ruleName == null || ruleName.isEmpty() )
-        {
-            ruleName = SchemaRule.generateName( id, type );
+            if ( ruleName.isEmpty() )
+            {
+                ruleName = null;
+            }
         }
         return ruleName;
     }

community/kernel/src/main/java/org/neo4j/storageengine/api/schema/SchemaRule.java

@@ -26,41 +26,32 @@
 import org.neo4j.internal.kernel.api.schema.constraints.ConstraintDescriptor;
 import org.neo4j.kernel.api.exceptions.schema.MalformedSchemaRuleException;
 import org.neo4j.kernel.api.schema.index.SchemaIndexDescriptor;
-import org.neo4j.kernel.impl.store.record.ConstraintRule;
-import org.neo4j.kernel.impl.store.record.IndexRule;
 
 /**
  * Represents a stored schema rule.
  */
-public abstract class SchemaRule implements SchemaDescriptorSupplier
+public interface SchemaRule extends SchemaDescriptorSupplier
 {
-    protected final long id;
-    protected final String name;
-
-    protected SchemaRule( long id )
-    {
-        this( id, null );
-    }
-
-    protected SchemaRule( long id, String name )
+    static String nameOrDefault( String name, String defaultName )
     {
-        this.id = id;
-        this.name = name == null ? generateName( id, getClass() ) : checkName( name );
-    }
-
-    private String checkName( String name )
-    {
-        int length = name.length();
-        if ( length == 0 )
+        if ( name == null )
+        {
+            return defaultName;
+        }
+        else if ( name.isEmpty() )
         {
             throw new IllegalArgumentException( "Schema rule name cannot be the empty string" );
         }
-        for ( int i = 0; i < length; i++ )
+        else
         {
-            char ch = name.charAt( i );
-            if ( ch == '\0' )
+            int length = name.length();
+            for ( int i = 0; i < length; i++ )
             {
-                throw new IllegalArgumentException( "Illegal schema rule name: '" + name + "'" );
+                char ch = name.charAt( i );
+                if ( ch == '\0' )
+                {
+                    throw new IllegalArgumentException( "Illegal schema rule name: '" + name + "'" );
+                }
             }
         }
         return name;
@@ -69,33 +60,12 @@ private String checkName( String name )
     /**
      * The persistence id for this rule.
      */
-    public final long getId()
-    {
-        return this.id;
-    }
+    long getId();
 
     /**
      * @return The (possibly user supplied) name of this schema rule.
      */
-    public final String getName()
-    {
-        return name;
-    }
-
-    public abstract byte[] serialize();
-
-    public static String generateName( long id, Class<? extends SchemaRule> type )
-    {
-        if ( type == IndexRule.class )
-        {
-            return "index_" + id;
-        }
-        if ( type == ConstraintRule.class )
-        {
-            return "constraint_" + id;
-        }
-        return "schema_" + id;
-    }
+    String getName();
 
     /**
      * This enum is used for the legacy schema store, and should not be extended.

community/kernel/src/test/java/org/neo4j/kernel/impl/store/SchemaStoreTest.java

@@ -91,7 +91,7 @@ public void storeAndLoadSchemaRule() throws Exception
 
         // WHEN
         IndexRule readIndexRule = (IndexRule) SchemaRuleSerialization.deserialize(
-                indexRule.getId(), wrap( indexRule.serialize() ) );
+                indexRule.getId(), wrap( SchemaRuleSerialization.serialize( indexRule ) ) );
 
         // THEN
         assertEquals( indexRule.getId(), readIndexRule.getId() );
@@ -110,7 +110,7 @@ public void storeAndLoadCompositeSchemaRule() throws Exception
 
         // WHEN
         IndexRule readIndexRule = (IndexRule) SchemaRuleSerialization.deserialize(
-                indexRule.getId(), wrap( indexRule.serialize() ) );
+                indexRule.getId(), wrap( SchemaRuleSerialization.serialize( indexRule ) ) );
 
         // THEN
         assertEquals( indexRule.getId(), readIndexRule.getId() );
@@ -128,7 +128,7 @@ public void storeAndLoad_Big_CompositeSchemaRule() throws Exception
 
         // WHEN
         IndexRule readIndexRule = (IndexRule) SchemaRuleSerialization.deserialize(
-                indexRule.getId(), wrap( indexRule.serialize() ) );
+                indexRule.getId(), wrap( SchemaRuleSerialization.serialize( indexRule ) ) );
 
         // THEN
         assertEquals( indexRule.getId(), readIndexRule.getId() );