Monster commit. Sorry.

Ripped out Property classes and replaced with Value equivalents. Not
completely optimized everywhere, but might give decent performance. In
particular haven't worked with cursors, because those will be touched by
separate work.

community/consistency-check/src/main/java/org/neo4j/consistency/checking/PropertyRecordCheck.java

@@ -82,7 +82,7 @@ public static void checkDataBlock( PropertyBlock block,
             default:
                 try
                 {
-                    type.getValue( block, null );
+                    type.getValueNow( block, null );
                 }
                 catch ( Exception e )
                 {

community/consistency-check/src/main/java/org/neo4j/consistency/checking/full/PropertyAndNodeIndexedCheck.java

@@ -45,6 +45,7 @@
 import org.neo4j.kernel.impl.store.record.PropertyRecord;
 import org.neo4j.kernel.impl.store.record.Record;
 import org.neo4j.storageengine.api.schema.IndexReader;
+import org.neo4j.values.Value;
 import org.neo4j.values.Values;
 
 import static java.lang.String.format;
@@ -105,7 +106,7 @@ private void matchIndexesToNode(
                 int[] indexPropertyIds = indexRule.schema().getPropertyIds();
                 if ( nodeHasSchemaProperties( nodePropertyMap, indexPropertyIds ) )
                 {
-                    Object[] values = getPropertyValues( nodePropertyMap, indexPropertyIds );
+                    Value[] values = getPropertyValues( nodePropertyMap, indexPropertyIds );
                     try ( IndexReader reader = indexes.accessorFor( indexRule ).newReader() )
                     {
                         long nodeId = record.getId();
@@ -197,13 +198,13 @@ private void checkProperty( NodeRecord record,
         }
     }
 
-    private Object[] getPropertyValues( PrimitiveIntObjectMap<PropertyBlock> propertyMap, int[] indexPropertyIds )
+    private Value[] getPropertyValues( PrimitiveIntObjectMap<PropertyBlock> propertyMap, int[] indexPropertyIds )
     {
-        Object[] values = new Object[indexPropertyIds.length];
+        Value[] values = new Value[indexPropertyIds.length];
         for ( int i = 0; i < indexPropertyIds.length; i++ )
         {
             PropertyBlock propertyBlock = propertyMap.get( indexPropertyIds[i] );
-            values[i] = propertyReader.propertyValue( propertyBlock ).value();
+            values[i] = propertyReader.propertyValue( propertyBlock );
         }
         return values;
     }

community/consistency-check/src/main/java/org/neo4j/consistency/checking/full/PropertyReader.java

@@ -26,15 +26,18 @@
 
 import org.neo4j.function.Suppliers;
 import org.neo4j.kernel.api.index.PropertyAccessor;
-import org.neo4j.kernel.api.properties.DefinedProperty;
-import org.neo4j.kernel.api.properties.Property;
+import org.neo4j.kernel.api.properties.PropertyKeyValue;
 import org.neo4j.kernel.impl.store.NodeStore;
 import org.neo4j.kernel.impl.store.PropertyStore;
 import org.neo4j.kernel.impl.store.StoreAccess;
 import org.neo4j.kernel.impl.store.record.NodeRecord;
 import org.neo4j.kernel.impl.store.record.PropertyBlock;
 import org.neo4j.kernel.impl.store.record.PropertyRecord;
 import org.neo4j.kernel.impl.store.record.Record;
+import org.neo4j.storageengine.api.StorageProperty;
+import org.neo4j.values.Value;
+import org.neo4j.values.Values;
+
 import static org.neo4j.kernel.impl.store.record.RecordLoad.FORCE;
 
 public class PropertyReader implements PropertyAccessor
@@ -93,13 +96,13 @@ public List<PropertyBlock> propertyBlocks( NodeRecord nodeRecord )
         return propertyBlocks;
     }
 
-    public DefinedProperty propertyValue( PropertyBlock block )
+    public Value propertyValue( PropertyBlock block )
     {
-        return block.getType().readProperty( block.getKeyIndexId(), block, Suppliers.singleton( propertyStore ) );
+        return block.getType().getValue( block, propertyStore );
     }
 
     @Override
-    public Property getProperty( long nodeId, int propertyKeyId )
+    public Value getPropertyValue( long nodeId, int propertyKeyId )
     {
         NodeRecord nodeRecord = nodeStore.newRecord();
         if ( nodeStore.getRecord( nodeId, nodeRecord, FORCE ).inUse() )
@@ -112,6 +115,6 @@ public Property getProperty( long nodeId, int propertyKeyId )
                 }
             }
         }
-        return Property.noNodeProperty( nodeId, propertyKeyId );
+        return Values.NO_VALUE;
     }
 }

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

@@ -107,6 +107,8 @@
 import org.neo4j.storageengine.api.schema.SchemaRule;
 import org.neo4j.string.UTF8;
 import org.neo4j.test.rule.SuppressOutput;
+import org.neo4j.values.Value;
+import org.neo4j.values.Values;
 
 import static java.lang.String.format;
 import static java.util.Arrays.asList;
@@ -598,12 +600,12 @@ public void shouldReportNodesWithDuplicatePropertyValueInUniqueIndex() throws Ex
                    .andThatsAllFolks();
     }
 
-    private Object[] values( IndexRule indexRule )
+    private Value[] values( IndexRule indexRule )
     {
         switch ( indexRule.schema().getPropertyIds().length )
         {
-        case 1: return Iterators.array( VALUE1 );
-        case 2: return Iterators.array( VALUE1, VALUE2 );
+        case 1: return Iterators.array( Values.of( VALUE1 ) );
+        case 2: return Iterators.array( Values.of( VALUE1 ), Values.of( VALUE2 ) );
         default: throw new UnsupportedOperationException();
         }
     }

community/kernel/src/main/java/org/neo4j/kernel/api/ReadOperations.java

@@ -158,7 +158,7 @@ RelationshipIterator nodeGetRelationships( long nodeId, Direction direction, int
     long nodeGetFromUniqueIndexSeek( IndexDescriptor index, IndexQuery.ExactPredicate... predicates ) throws IndexNotFoundKernelException,
             IndexBrokenKernelException, IndexNotApplicableKernelException;
 
-    long nodesCountIndexed( IndexDescriptor index, long nodeId, Object value )
+    long nodesCountIndexed( IndexDescriptor index, long nodeId, Value value )
             throws IndexNotFoundKernelException, IndexBrokenKernelException;
 
     boolean nodeExists( long nodeId );

community/kernel/src/main/java/org/neo4j/kernel/api/exceptions/index/IndexEntryConflictException.java

@@ -19,31 +19,35 @@
  */
 package org.neo4j.kernel.api.exceptions.index;
 
+import java.util.Arrays;
+
 import org.neo4j.kernel.api.TokenNameLookup;
 import org.neo4j.kernel.api.exceptions.KernelException;
 import org.neo4j.kernel.api.schema.LabelSchemaDescriptor;
-import org.neo4j.kernel.api.schema.OrderedPropertyValues;
 import org.neo4j.kernel.api.schema.SchemaUtil;
 import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.values.Value;
+import org.neo4j.values.ValueTuple;
 
 import static java.lang.String.format;
+import static java.lang.String.valueOf;
 import static org.neo4j.kernel.api.StatementConstants.NO_SUCH_NODE;
 
 /**
  * TODO why isn't this a {@link KernelException}?
  */
 public class IndexEntryConflictException extends Exception
 {
-    private final OrderedPropertyValues propertyValues;
+    private final ValueTuple propertyValues;
     private final long addedNodeId;
     private final long existingNodeId;
 
-    public IndexEntryConflictException( long existingNodeId, long addedNodeId, Object propertyValue )
+    public IndexEntryConflictException( long existingNodeId, long addedNodeId, Value propertyValue )
     {
-        this( existingNodeId, addedNodeId, OrderedPropertyValues.ofUndefined( propertyValue ) );
+        this( existingNodeId, addedNodeId, ValueTuple.of( propertyValue ) );
     }
 
-    public IndexEntryConflictException( long existingNodeId, long addedNodeId, OrderedPropertyValues propertyValues )
+    public IndexEntryConflictException( long existingNodeId, long addedNodeId, ValueTuple propertyValues )
     {
         super( format( "Both node %d and node %d share the property value %s",
                 existingNodeId, addedNodeId, propertyValues ) );
@@ -81,14 +85,14 @@ public String evidenceMessage( TokenNameLookup tokenNameLookup, LabelSchemaDescr
         }
     }
 
-    public OrderedPropertyValues getPropertyValues()
+    public ValueTuple getPropertyValues()
     {
         return propertyValues;
     }
 
-    public Object getSinglePropertyValue()
+    public Value getSinglePropertyValue()
     {
-        return propertyValues.getSinglePropertyValue();
+        return propertyValues.getOnlyValue();
     }
 
     public long getAddedNodeId()
@@ -150,8 +154,55 @@ private String propertyString( TokenNameLookup tokenNameLookup, int[] propertyId
             sb.append( '`' );
             sb.append( tokenNameLookup.propertyKeyGetName( propertyIds[i] ) );
             sb.append( "` = " );
-            sb.append( OrderedPropertyValues.quote( propertyValues.valueAt( i ) ) );
+            sb.append( quote( propertyValues.valueAt( i ).asPublic() ) );
         }
         return sb.toString();
     }
+
+    private static String quote( Object propertyValue )
+    {
+        if ( propertyValue instanceof String )
+        {
+            return format( "'%s'", propertyValue );
+        }
+        else if ( propertyValue.getClass().isArray() )
+        {
+            Class<?> type = propertyValue.getClass().getComponentType();
+            if ( type == Boolean.TYPE )
+            {
+                return Arrays.toString( (boolean[]) propertyValue );
+            }
+            else if ( type == Byte.TYPE )
+            {
+                return Arrays.toString( (byte[]) propertyValue );
+            }
+            else if ( type == Short.TYPE )
+            {
+                return Arrays.toString( (short[]) propertyValue );
+            }
+            else if ( type == Character.TYPE )
+            {
+                return Arrays.toString( (char[]) propertyValue );
+            }
+            else if ( type == Integer.TYPE )
+            {
+                return Arrays.toString( (int[]) propertyValue );
+            }
+            else if ( type == Long.TYPE )
+            {
+                return Arrays.toString( (long[]) propertyValue );
+            }
+            else if ( type == Float.TYPE )
+            {
+                return Arrays.toString( (float[]) propertyValue );
+            }
+            else if ( type == Double.TYPE )
+            {
+                return Arrays.toString( (double[]) propertyValue );
+            }
+            return Arrays.toString( (Object[]) propertyValue );
+        }
+        return valueOf( propertyValue );
+    }
+
 }

community/kernel/src/main/java/org/neo4j/kernel/api/index/DelegatingIndexReader.java

@@ -24,6 +24,7 @@
 import org.neo4j.kernel.api.schema.IndexQuery;
 import org.neo4j.storageengine.api.schema.IndexReader;
 import org.neo4j.storageengine.api.schema.IndexSampler;
+import org.neo4j.values.Value;
 
 public class DelegatingIndexReader implements IndexReader
 {
@@ -35,7 +36,7 @@ public DelegatingIndexReader( IndexReader delegate )
     }
 
     @Override
-    public long countIndexedNodes( long nodeId, Object... propertyValues )
+    public long countIndexedNodes( long nodeId, Value... propertyValues )
     {
         return delegate.countIndexedNodes( nodeId, propertyValues );
     }

community/kernel/src/main/java/org/neo4j/kernel/api/index/IndexEntryUpdate.java

@@ -24,6 +24,7 @@
 import org.neo4j.kernel.api.schema.LabelSchemaSupplier;
 import org.neo4j.kernel.api.schema.SchemaUtil;
 import org.neo4j.kernel.impl.api.index.UpdateMode;
+import org.neo4j.values.Value;
 
 import static java.lang.String.format;
 
@@ -36,17 +37,17 @@ public class IndexEntryUpdate<INDEX_KEY extends LabelSchemaSupplier>
 {
     private final long entityId;
     private final UpdateMode updateMode;
-    private final Object[] before;
-    private final Object[] values;
+    private final Value[] before;
+    private final Value[] values;
     private final INDEX_KEY indexKey;
 
-    private IndexEntryUpdate( long entityId, INDEX_KEY indexKey, UpdateMode updateMode, Object... values )
+    private IndexEntryUpdate( long entityId, INDEX_KEY indexKey, UpdateMode updateMode, Value... values )
     {
         this( entityId, indexKey, updateMode, null, values );
     }
 
-    private IndexEntryUpdate( long entityId, INDEX_KEY indexKey, UpdateMode updateMode, Object[] before,
-            Object[] values )
+    private IndexEntryUpdate( long entityId, INDEX_KEY indexKey, UpdateMode updateMode, Value[] before,
+            Value[] values )
     {
         // we do not support partial index entries
         assert indexKey.schema().getPropertyIds().length == values.length :
@@ -76,7 +77,7 @@ public INDEX_KEY indexKey()
         return indexKey;
     }
 
-    public Object[] values()
+    public Value[] values()
     {
         return values;
     }
@@ -103,11 +104,11 @@ public boolean equals( Object o )
         {
             return false;
         }
-        if ( !Arrays.deepEquals( before, that.before ) )
+        if ( !Arrays.equals( before, that.before ) )
         {
             return false;
         }
-        if ( !Arrays.deepEquals( values, that.values ) )
+        if ( !Arrays.equals( values, that.values ) )
         {
             return false;
         }
@@ -119,8 +120,8 @@ public int hashCode()
     {
         int result = (int) (entityId ^ (entityId >>> 32));
         result = 31 * result + (updateMode != null ? updateMode.hashCode() : 0);
-        result = 31 * result + Arrays.deepHashCode( before );
-        result = 31 * result + Arrays.deepHashCode( values );
+        result = 31 * result + Arrays.hashCode( before );
+        result = 31 * result + Arrays.hashCode( values );
         result = 31 * result + (indexKey != null ? indexKey.schema().hashCode() : 0);
         return result;
     }
@@ -133,31 +134,31 @@ public String toString()
     }
 
     public static <INDEX_KEY extends LabelSchemaSupplier> IndexEntryUpdate<INDEX_KEY> add(
-            long nodeId, INDEX_KEY indexKey, Object... values )
+            long nodeId, INDEX_KEY indexKey, Value... values )
     {
         return new IndexEntryUpdate<>( nodeId, indexKey, UpdateMode.ADDED, values );
     }
 
     public static <INDEX_KEY extends LabelSchemaSupplier> IndexEntryUpdate<INDEX_KEY> remove(
-            long nodeId, INDEX_KEY indexKey, Object... values )
+            long nodeId, INDEX_KEY indexKey, Value... values )
     {
         return new IndexEntryUpdate<>( nodeId, indexKey, UpdateMode.REMOVED, values );
     }
 
     public static <INDEX_KEY extends LabelSchemaSupplier> IndexEntryUpdate<INDEX_KEY> change(
-            long nodeId, INDEX_KEY indexKey, Object before, Object after )
+            long nodeId, INDEX_KEY indexKey, Value before, Value after )
     {
         return new IndexEntryUpdate<>( nodeId, indexKey, UpdateMode.CHANGED,
-                new Object[]{before}, new Object[]{after} );
+                new Value[]{before}, new Value[]{after} );
     }
 
     public static <INDEX_KEY extends LabelSchemaSupplier> IndexEntryUpdate<INDEX_KEY> change(
-            long nodeId, INDEX_KEY indexKey, Object[] before, Object[] after )
+            long nodeId, INDEX_KEY indexKey, Value[] before, Value[] after )
     {
         return new IndexEntryUpdate<>( nodeId, indexKey, UpdateMode.CHANGED, before, after );
     }
 
-    public Object[] beforeValues()
+    public Value[] beforeValues()
     {
         if ( before == null )
         {

community/kernel/src/main/java/org/neo4j/kernel/api/index/PropertyAccessor.java

@@ -20,12 +20,12 @@
 package org.neo4j.kernel.api.index;
 
 import org.neo4j.kernel.api.exceptions.EntityNotFoundException;
-import org.neo4j.kernel.api.properties.Property;
+import org.neo4j.values.Value;
 
 /**
  * Used by the {@link IndexPopulator} for verifying constraints, if need be.
  */
 public interface PropertyAccessor
 {
-    Property getProperty( long nodeId, int propertyKeyId ) throws EntityNotFoundException;
+    Value getPropertyValue( long nodeId, int propertyKeyId ) throws EntityNotFoundException;
 }