MVStore: improved serialization (support arrays, java.util.Date)

h2/src/main/org/h2/mvstore/DataUtils.java

@@ -596,9 +596,9 @@ public class DataUtils {
     private static String formatMessage(String pattern, Object... arguments) {
         for (int i = 0, size = arguments.length; i < size; i++) {
             Object o = arguments[i];
-            String s = o == null ? "null" : o instanceof String ? StringUtils
-                    .quoteIdentifier(o.toString()) : o.toString();
-            arguments[i] = s;
+            if (o instanceof String) {
+                arguments[i] = StringUtils.quoteIdentifier(o.toString());
+            }
         }
         return MessageFormat.format(pattern, arguments) + getVersion();
     }

h2/src/main/org/h2/mvstore/MVStore.java

@@ -41,49 +41,43 @@ H:3,...
 
 TODO:
 
+- file system encryption: check standard
+
+- mvcc with multiple transactions
 - update checkstyle
 - automated 'kill process' and 'power failure' test
 - maybe split database into multiple files, to speed up compact
 - auto-compact from time to time and on close
 - test and possibly improve compact operation (for large dbs)
-- limited support for writing to old versions (branches)
-- on insert, if the child page is already full, don't load and modify it
--- split directly (for leaves with 1 entry)
 - performance test with encrypting file system
 - possibly split chunk data into immutable and mutable
 - compact: avoid processing pages using a counting bloom filter
 - defragment (re-creating maps, specially those with small pages)
-- write using ByteArrayOutputStream; remove DataType.getMaxLength
-- file header: check formatRead and format (is formatRead
--- needed if equal to format?)
+- remove DataType.getMaxLength (use ByteArrayOutputStream or getMemory)
 - chunk header: store changed chunk data as row; maybe after the root
 - chunk checksum (header, last page, 2 bytes per page?)
-- allow renaming maps
 - file locking: solve problem that locks are shared for a VM
-- online backup
-- data types: maybe support InputStream, Reader
-- data types: maybe support ResultSet, Date, Time, Timestamp
-- data types: maybe support boolean[], short[],...
 - store file "header" at the end of each chunk; at the end of the file
 - is there a better name for the file header,
 -- if it's no longer always at the beginning of a file?
+- on insert, if the child page is already full, don't load and modify it
+-- split directly (for leaves with 1 entry)
 - maybe let a chunk point to possible next chunks
 -- (so no fixed location header is needed)
 - support stores that span multiple files (chunks stored in other files)
 - triggers (can be implemented with a custom map)
-- store write operations per page (maybe defragment
+- store number of write operations per page (maybe defragment
 -- if much different than count)
 - r-tree: nearest neighbor search
 - use FileChannel by default (nio file system), but:
+-- an interrupt closes the FileChannel
 - auto-save temporary data if it uses too much memory,
 -- but revert it on startup if needed.
--- but revert it on startup if needed.
+- chunk metadata: do not store default values
 - support maps without values (just existence of the key)
 - support maps without keys (counted b-tree features)
 - use a small object cache (StringCache)
 - dump values
-- dump values
 - tool to import / manipulate CSV files (maybe concurrently)
 - map split / merge (fast if no overlap)
 - auto-save if there are too many changes (required for StreamStore)
@@ -97,10 +91,7 @@ TODO:
 - implement a shareded map (in one store, multiple stores)
 -- to support concurrent updates and writes, and very large maps
 - implement an off-heap file system
-- optimize API for Java 7 (diamond operator)
-- use new MVStore.Builder().open();
-- see Google Guice: Generic Type
-- JAXB (java xml binding) new TypeReference<String, String>(){}
+- remove change cursor, or add support for writing to branches
 
 */
 
@@ -120,6 +111,9 @@ public class MVStore {
      */
     static final int BLOCK_SIZE = 4 * 1024;
 
+    private static final int FORMAT_WRITE = 1;
+    private static final int FORMAT_READ = 1;
+
     private final String fileName;
 
     private int pageSize = 6 * 1024;
@@ -374,6 +368,23 @@ public class MVStore {
             return;
         }
         FileUtils.createDirectories(FileUtils.getParent(fileName));
+        if (readOnly) {
+            openFile();
+        } else if (!openFile()) {
+            readOnly = true;
+            openFile();
+        }
+    }
+
+    /**
+     * Try to open the file in read or write mode.
+     *
+     * @return if opening the file was successful, and false if the file could
+     *         not be opened in write mode because the write file format it too
+     *         high (in which case the file can be opened in read-only mode)
+     * @throw IllegalStateException if the file could not be opened at all
+     */
+    private boolean openFile() {
         try {
             log("file open");
             FilePath f = FilePath.get(fileName);
@@ -398,11 +409,24 @@ public class MVStore {
                 creationTime = getTime();
                 fileHeader.put("H", "3");
                 fileHeader.put("blockSize", "" + BLOCK_SIZE);
-                fileHeader.put("format", "1");
+                fileHeader.put("format", "" + FORMAT_WRITE);
                 fileHeader.put("creationTime", "" + creationTime);
                 writeFileHeader();
             } else {
                 readFileHeader();
+                int formatWrite = Integer.parseInt(fileHeader.get("format"));
+                String x = fileHeader.get("formatRead");
+                int formatRead = x == null ? formatWrite : Integer.parseInt(x);
+                if (formatRead > FORMAT_READ) {
+                    throw DataUtils.newIllegalStateException(
+                        "The file format {0} is larger than the supported format {1}",
+                        formatRead, FORMAT_READ);
+                }
+                if (formatWrite > FORMAT_WRITE) {
+                    readOnly = true;
+                    file.close();
+                    return false;
+                }
                 if (rootChunkStart > 0) {
                     readMeta();
                 }
@@ -416,6 +440,7 @@ public class MVStore {
             throw DataUtils.newIllegalStateException(
                     "Could not open file {0}", fileName, e);
         }
+        return true;
     }
 
     private void readMeta() {
@@ -1458,4 +1483,8 @@ public class MVStore {
 
     }
 
+    public boolean isReadOnly() {
+        return readOnly;
+    }
+
 }

h2/src/main/org/h2/mvstore/db/MVTableEngine.java

@@ -59,6 +59,9 @@ public class MVTableEngine implements TableEngine {
                 store = STORES.get(storeName);
                 if (store == null) {
                     builder.fileName(storeName + Constants.SUFFIX_MV_FILE);
+                    if (db.isReadOnly()) {
+                        builder.readOnly();
+                    }
                     store = new Store(db, builder.open());
                     STORES.put(storeName, store);
                 } else if (store.db != db) {

h2/src/main/org/h2/mvstore/type/ObjectDataType.java

@@ -6,11 +6,15 @@
  */
 package org.h2.mvstore.type;
 
+import java.lang.reflect.Array;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
+import java.util.Date;
+import java.util.HashMap;
 import java.util.UUID;
 import org.h2.mvstore.DataUtils;
+import org.h2.util.New;
 import org.h2.util.Utils;
 
 /**
@@ -22,23 +26,22 @@ public class ObjectDataType implements DataType {
     /**
      * The type constants are also used as tag values.
      */
+    static final int TYPE_NULL = 0;
     static final int TYPE_BOOLEAN = 1;
     static final int TYPE_BYTE = 2;
     static final int TYPE_SHORT = 3;
-    static final int TYPE_INTEGER = 4;
+    static final int TYPE_INT = 4;
     static final int TYPE_LONG = 5;
     static final int TYPE_BIG_INTEGER = 6;
     static final int TYPE_FLOAT = 7;
     static final int TYPE_DOUBLE = 8;
     static final int TYPE_BIG_DECIMAL = 9;
-    static final int TYPE_CHARACTER = 10;
+    static final int TYPE_CHAR = 10;
     static final int TYPE_STRING = 11;
     static final int TYPE_UUID = 12;
-    static final int TYPE_BYTE_ARRAY = 13;
-    static final int TYPE_INT_ARRAY = 14;
-    static final int TYPE_LONG_ARRAY = 15;
-    static final int TYPE_CHAR_ARRAY = 16;
-    static final int TYPE_SERIALIZED_OBJECT = 17;
+    static final int TYPE_DATE = 13;
+    static final int TYPE_ARRAY = 14;
+    static final int TYPE_SERIALIZED_OBJECT = 19;
 
     /**
      * For very common values (e.g. 0 and 1) we save space by encoding the value
@@ -80,6 +83,15 @@ public class ObjectDataType implements DataType {
     static final long DOUBLE_ZERO_BITS = Double.doubleToLongBits(0.0d);
     static final long DOUBLE_ONE_BITS = Double.doubleToLongBits(1.0d);
 
+    static final Class<?>[] COMMON_CLASSES = { boolean.class, byte.class,
+            short.class, char.class, int.class, long.class, float.class,
+            double.class, Object.class, Boolean.class, Byte.class, Short.class,
+            Character.class, Integer.class, Long.class, BigInteger.class,
+            Float.class, Double.class, BigDecimal.class, String.class,
+            UUID.class, Date.class };
+
+    private static final HashMap<Class<?>, Integer> COMMON_CLASSES_MAP = New.hashMap();
+
     private AutoDetectDataType last = new StringType(this);
 
     @Override
@@ -104,15 +116,17 @@ public class ObjectDataType implements DataType {
 
     private AutoDetectDataType newType(int typeId) {
         switch (typeId) {
+        case TYPE_NULL:
+            return new NullType(this);
         case TYPE_BOOLEAN:
             return new BooleanType(this);
         case TYPE_BYTE:
             return new ByteType(this);
         case TYPE_SHORT:
             return new ShortType(this);
-        case TYPE_CHARACTER:
+        case TYPE_CHAR:
             return new CharacterType(this);
-        case TYPE_INTEGER:
+        case TYPE_INT:
             return new IntegerType(this);
         case TYPE_LONG:
             return new LongType(this);
@@ -124,18 +138,14 @@ public class ObjectDataType implements DataType {
             return new BigIntegerType(this);
         case TYPE_BIG_DECIMAL:
             return new BigDecimalType(this);
-        case TYPE_BYTE_ARRAY:
-            return new ByteArrayType(this);
-        case TYPE_CHAR_ARRAY:
-            return new CharArrayType(this);
-        case TYPE_INT_ARRAY:
-            return new IntArrayType(this);
-        case TYPE_LONG_ARRAY:
-            return new LongArrayType(this);
         case TYPE_STRING:
             return new StringType(this);
         case TYPE_UUID:
             return new UUIDType(this);
+        case TYPE_DATE:
+            return new DateType(this);
+        case TYPE_ARRAY:
+            return new ObjectArrayType(this);
         case TYPE_SERIALIZED_OBJECT:
             return new SerializedObjectType(this);
         }
@@ -155,7 +165,7 @@ public class ObjectDataType implements DataType {
                 break;
             case TAG_INTEGER_NEGATIVE:
             case TAG_INTEGER_FIXED:
-                typeId = TYPE_INTEGER;
+                typeId = TYPE_INT;
                 break;
             case TAG_LONG_NEGATIVE:
             case TAG_LONG_FIXED:
@@ -184,13 +194,13 @@ public class ObjectDataType implements DataType {
                 break;
             default:
                 if (tag >= TAG_INTEGER_0_15 && tag <= TAG_INTEGER_0_15 + 15) {
-                    typeId = TYPE_INTEGER;
+                    typeId = TYPE_INT;
                 } else if (tag >= TAG_STRING_0_15 && tag <= TAG_STRING_0_15 + 15) {
                     typeId = TYPE_STRING;
                 } else if (tag >= TAG_LONG_0_7 && tag <= TAG_LONG_0_7 + 7) {
                     typeId = TYPE_LONG;
                 } else if (tag >= TAG_BYTE_ARRAY_0_15 && tag <= TAG_BYTE_ARRAY_0_15 + 15) {
-                    typeId = TYPE_BYTE_ARRAY;
+                    typeId = TYPE_ARRAY;
                 } else {
                     throw DataUtils.newIllegalStateException("Unknown tag {0}", tag);
                 }
@@ -204,17 +214,11 @@ public class ObjectDataType implements DataType {
 
     private static int getTypeId(Object obj) {
         if (obj instanceof Integer) {
-            return TYPE_INTEGER;
+            return TYPE_INT;
         } else if (obj instanceof String) {
             return TYPE_STRING;
         } else if (obj instanceof Long) {
             return TYPE_LONG;
-        } else if (obj instanceof BigDecimal) {
-            if (obj.getClass() == BigDecimal.class) {
-                return TYPE_BIG_DECIMAL;
-            }
-        } else if (obj instanceof byte[]) {
-            return TYPE_BYTE_ARRAY;
         } else if (obj instanceof Double) {
             return TYPE_DOUBLE;
         } else if (obj instanceof Float) {
@@ -225,24 +229,20 @@ public class ObjectDataType implements DataType {
             return TYPE_UUID;
         } else if (obj instanceof Byte) {
             return TYPE_BYTE;
-        } else if (obj instanceof int[]) {
-            return TYPE_INT_ARRAY;
-        } else if (obj instanceof long[]) {
-            return TYPE_LONG_ARRAY;
-        } else if (obj instanceof char[]) {
-            return TYPE_CHAR_ARRAY;
         } else if (obj instanceof Short) {
             return TYPE_SHORT;
-        } else if (obj instanceof BigInteger) {
-            if (obj.getClass() == BigInteger.class) {
-                return TYPE_BIG_INTEGER;
-            }
         } else if (obj instanceof Character) {
-            return TYPE_CHARACTER;
-        }
-        if (obj == null) {
-            throw DataUtils.newIllegalArgumentException(
-                    "Null is not supported");
+            return TYPE_CHAR;
+        } else if (obj == null) {
+            return TYPE_NULL;
+        } else if (isDate(obj)) {
+            return TYPE_DATE;
+        } else if (isBigInteger(obj)) {
+            return TYPE_BIG_INTEGER;
+        } else if (isBigDecimal(obj)) {
+            return TYPE_BIG_DECIMAL;
+        } else if (obj.getClass().isArray()) {
+            return TYPE_ARRAY;
         }
         return TYPE_SERIALIZED_OBJECT;
     }
@@ -262,70 +262,31 @@ public class ObjectDataType implements DataType {
         return l;
     }
 
-    /**
-     * Compare the contents of two arrays.
-     *
-     * @param data1 the first array (must not be null)
-     * @param data2 the second array (must not be null)
-     * @return the result of the comparison (-1, 1 or 0)
-     */
-    public static int compareNotNull(char[] data1, char[] data2) {
-        if (data1 == data2) {
-            return 0;
-        }
-        int len = Math.min(data1.length, data2.length);
-        for (int i = 0; i < len; i++) {
-            char x = data1[i];
-            char x2 = data2[i];
-            if (x != x2) {
-                return x > x2 ? 1 : -1;
-            }
-        }
-        return Integer.signum(data1.length - data2.length);
+    static boolean isBigInteger(Object obj) {
+        return obj instanceof BigInteger && obj.getClass() == BigInteger.class;
     }
 
-    /**
-     * Compare the contents of two arrays.
-     *
-     * @param data1 the first array (must not be null)
-     * @param data2 the second array (must not be null)
-     * @return the result of the comparison (-1, 1 or 0)
-     */
-    public static int compareNotNull(int[] data1, int[] data2) {
-        if (data1 == data2) {
-            return 0;
-        }
-        int len = Math.min(data1.length, data2.length);
-        for (int i = 0; i < len; i++) {
-            int x = data1[i];
-            int x2 = data2[i];
-            if (x != x2) {
-                return x > x2 ? 1 : -1;
-            }
-        }
-        return Integer.signum(data1.length - data2.length);
+    static boolean isBigDecimal(Object obj) {
+        return obj instanceof BigDecimal && obj.getClass() == BigDecimal.class;
     }
 
-    /**
-     * Compare the contents of two arrays.
-     *
-     * @param data1 the first array (must not be null)
-     * @param data2 the second array (must not be null)
-     * @return the result of the comparison (-1, 1 or 0)
-     */
-    public static int compareNotNull(long[] data1, long[] data2) {
-        if (data1 == data2) {
-            return 0;
-        }
-        int len = Math.min(data1.length, data2.length);
-        for (int i = 0; i < len; i++) {
-            long x = data1[i];
-            long x2 = data2[i];
-            if (x != x2) {
-                return x > x2 ? 1 : -1;
+    static boolean isDate(Object obj) {
+        return obj instanceof Date && obj.getClass() == Date.class;
+    }
+
+    static boolean isArray(Object obj) {
+        return obj != null && obj.getClass().isArray();
+    }
+
+    static Integer getCommonClassId(Class<?> clazz) {
+        HashMap<Class<?>, Integer> map = COMMON_CLASSES_MAP;
+        if (map.size() == 0) {
+            // lazy initialization
+            for (int i = 0, size = COMMON_CLASSES.length; i < size; i++) {
+                COMMON_CLASSES_MAP.put(COMMON_CLASSES[i], i);
             }
         }
-        return Integer.signum(data1.length - data2.length);
+        return map.get(clazz);
     }
 
     /**
@@ -393,6 +354,53 @@ public class ObjectDataType implements DataType {
 
     }
 
+    /**
+     * The type for the null value
+     */
+    class NullType extends AutoDetectDataType {
+
+        NullType(ObjectDataType base) {
+            super(base, TYPE_NULL);
+        }
+
+        @Override
+        public int compare(Object aObj, Object bObj) {
+            if (aObj == null && bObj == null) {
+                return 0;
+            } else if (aObj == null) {
+                return -1;
+            } else if (bObj == null) {
+                return 1;
+            }
+            return super.compare(aObj, bObj);
+        }
+
+        @Override
+        public int getMemory(Object obj) {
+            return obj == null ? 0 : super.getMemory(obj);
+        }
+
+        @Override
+        public int getMaxLength(Object obj) {
+            return obj == null ? 1 : super.getMaxLength(obj);
+        }
+
+        @Override
+        public void write(ByteBuffer buff, Object obj) {
+            if (obj == null) {
+                buff.put((byte) TYPE_NULL);
+            } else {
+                super.write(buff, obj);
+            }
+        }
+
+        @Override
+        public Object read(ByteBuffer buff, int tag) {
+            return null;
+        }
+
+    }
+
     /**
      * The type for boolean true and false.
      */
@@ -490,7 +498,7 @@ public class ObjectDataType implements DataType {
     class CharacterType extends AutoDetectDataType {
 
         CharacterType(ObjectDataType base) {
-            super(base, TYPE_CHARACTER);
+            super(base, TYPE_CHAR);
         }
 
         @Override
@@ -516,7 +524,7 @@ public class ObjectDataType implements DataType {
         @Override
         public void write(ByteBuffer buff, Object obj) {
             if (obj instanceof Character) {
-                buff.put((byte) TYPE_CHARACTER);
+                buff.put((byte) TYPE_CHAR);
                 buff.putChar(((Character) obj).charValue());
             } else {
                 super.write(buff, obj);
@@ -582,7 +590,7 @@ public class ObjectDataType implements DataType {
     class IntegerType extends AutoDetectDataType {
 
         IntegerType(ObjectDataType base) {
-            super(base, TYPE_INTEGER);
+            super(base, TYPE_INT);
         }
 
         @Override
@@ -623,7 +631,7 @@ public class ObjectDataType implements DataType {
                 } else if (x <= 15) {
                     buff.put((byte) (TAG_INTEGER_0_15 + x));
                 } else if (x <= DataUtils.COMPRESSED_VAR_INT_MAX) {
-                    buff.put((byte) TYPE_INTEGER);
+                    buff.put((byte) TYPE_INT);
                     DataUtils.writeVarInt(buff, x);
                 } else {
                     buff.put((byte) TAG_INTEGER_FIXED);
@@ -637,7 +645,7 @@ public class ObjectDataType implements DataType {
         @Override
         public Object read(ByteBuffer buff, int tag) {
             switch (tag) {
-            case TYPE_INTEGER:
+            case TYPE_INT:
                 return DataUtils.readVarInt(buff);
             case TAG_INTEGER_NEGATIVE:
                 return -DataUtils.readVarInt(buff);
@@ -652,7 +660,7 @@ public class ObjectDataType implements DataType {
     /**
      * The type for long objects.
      */
-    public class LongType extends AutoDetectDataType {
+    class LongType extends AutoDetectDataType {
 
         LongType(ObjectDataType base) {
             super(base, TYPE_LONG);
@@ -873,7 +881,7 @@ public class ObjectDataType implements DataType {
 
         @Override
         public int compare(Object aObj, Object bObj) {
-            if (aObj instanceof BigInteger && bObj instanceof BigInteger) {
+            if (isBigInteger(aObj) && isBigInteger(bObj)) {
                 BigInteger a = (BigInteger) aObj;
                 BigInteger b = (BigInteger) bObj;
                 return a.compareTo(b);
@@ -883,12 +891,12 @@ public class ObjectDataType implements DataType {
 
         @Override
         public int getMemory(Object obj) {
-            return obj instanceof BigInteger ? 100 : super.getMemory(obj);
+            return isBigInteger(obj) ? 100 : super.getMemory(obj);
         }
 
         @Override
         public int getMaxLength(Object obj) {
-            if (!(obj instanceof BigInteger)) {
+            if (!isBigInteger(obj)) {
                 return super.getMaxLength(obj);
             }
             BigInteger x = (BigInteger) obj;
@@ -905,7 +913,7 @@ public class ObjectDataType implements DataType {
 
         @Override
         public void write(ByteBuffer buff, Object obj) {
-            if (obj instanceof BigInteger) {
+            if (isBigInteger(obj)) {
                 BigInteger x = (BigInteger) obj;
                 if (BigInteger.ZERO.equals(x)) {
                     buff.put((byte) TAG_BIG_INTEGER_0);
@@ -957,7 +965,7 @@ public class ObjectDataType implements DataType {
 
         @Override
         public int compare(Object aObj, Object bObj) {
-            if (aObj instanceof BigDecimal && bObj instanceof BigDecimal) {
+            if (isBigDecimal(aObj) && isBigDecimal(bObj)) {
                 BigDecimal a = (BigDecimal) aObj;
                 BigDecimal b = (BigDecimal) bObj;
                 return a.compareTo(b);
@@ -967,12 +975,12 @@ public class ObjectDataType implements DataType {
 
         @Override
         public int getMemory(Object obj) {
-            return obj instanceof BigDecimal ? 150 : super.getMemory(obj);
+            return isBigDecimal(obj) ? 150 : super.getMemory(obj);
         }
 
         @Override
         public int getMaxLength(Object obj) {
-            if (!(obj instanceof BigDecimal)) {
+            if (!isBigDecimal(obj)) {
                 return super.getMaxLength(obj);
             }
             BigDecimal x = (BigDecimal) obj;
@@ -996,7 +1004,7 @@ public class ObjectDataType implements DataType {
 
         @Override
         public void write(ByteBuffer buff, Object obj) {
-            if (obj instanceof BigDecimal) {
+            if (isBigDecimal(obj)) {
                 BigDecimal x = (BigDecimal) obj;
                 if (BigDecimal.ZERO.equals(x)) {
                     buff.put((byte) TAG_BIG_DECIMAL_0);
@@ -1166,249 +1174,324 @@ public class ObjectDataType implements DataType {
     }
 
     /**
-     * The type for byte arrays.
+     * The type for java.util.Date objects.
      */
-    class ByteArrayType extends AutoDetectDataType {
+    class DateType extends AutoDetectDataType {
 
-        ByteArrayType(ObjectDataType base) {
-            super(base, TYPE_BYTE_ARRAY);
+        DateType(ObjectDataType base) {
+            super(base, TYPE_DATE);
         }
 
         @Override
         public int getMemory(Object obj) {
-            if (!(obj instanceof byte[])) {
-                return super.getMemory(obj);
-            }
-            return 24 + ((byte[]) obj).length;
+            return isDate(obj) ? 40 : super.getMemory(obj);
         }
 
         @Override
         public int compare(Object aObj, Object bObj) {
-            if (aObj instanceof byte[] && bObj instanceof byte[]) {
-                byte[] a = (byte[]) aObj;
-                byte[] b = (byte[]) bObj;
-                return Utils.compareNotNull(a, b);
+            if (isDate(aObj) && isDate(bObj)) {
+                Date a = (Date) aObj;
+                Date b = (Date) bObj;
+                return a.compareTo(b);
             }
             return super.compare(aObj, bObj);
         }
 
         @Override
         public int getMaxLength(Object obj) {
-            if (!(obj instanceof byte[])) {
+            if (!isDate(obj)) {
                 return super.getMaxLength(obj);
             }
-            return 1 + DataUtils.MAX_VAR_INT_LEN + ((byte[]) obj).length;
+            return 9;
         }
 
         @Override
         public void write(ByteBuffer buff, Object obj) {
-            if (obj instanceof byte[]) {
-                byte[] data = (byte[]) obj;
-                int len = data.length;
-                if (len <= 15) {
-                    buff.put((byte) (TAG_BYTE_ARRAY_0_15 + len));
-                } else {
-                    buff.put((byte) TYPE_BYTE_ARRAY);
-                    DataUtils.writeVarInt(buff,  data.length);
-                }
-                buff.put(data);
-            } else {
+            if (!isDate(obj)) {
                 super.write(buff, obj);
+                return;
             }
+            buff.put((byte) TYPE_DATE);
+            Date a = (Date) obj;
+            buff.putLong(a.getTime());
         }
 
         @Override
         public Object read(ByteBuffer buff, int tag) {
-            byte[] data;
-            if (tag == TYPE_BYTE_ARRAY) {
-                int len = DataUtils.readVarInt(buff);
-                data = Utils.newBytes(len);
-            } else {
-                int len = tag - TAG_BYTE_ARRAY_0_15;
-                data = Utils.newBytes(len);
-            }
-            buff.get(data);
-            return data;
+            long a = buff.getLong();
+            return new Date(a);
         }
 
     }
 
     /**
-     * The type for char arrays.
+     * The type for object arrays.
      */
-    class CharArrayType extends AutoDetectDataType {
+    class ObjectArrayType extends AutoDetectDataType {
+
+        private final ObjectDataType elementType = new ObjectDataType();
 
-        CharArrayType(ObjectDataType base) {
-            super(base, TYPE_CHAR_ARRAY);
+        ObjectArrayType(ObjectDataType base) {
+            super(base, TYPE_ARRAY);
         }
 
         @Override
         public int getMemory(Object obj) {
-            if (!(obj instanceof char[])) {
+            if (!isArray(obj)) {
                 return super.getMemory(obj);
             }
-            return 24 + 2 * ((char[]) obj).length;
-        }
-
-        @Override
-        public int compare(Object aObj, Object bObj) {
-            if (aObj instanceof char[] && bObj instanceof char[]) {
-                char[] a = (char[]) aObj;
-                char[] b = (char[]) bObj;
-                return compareNotNull(a, b);
-            }
-            return super.compare(aObj, bObj);
-        }
-
-        @Override
-        public int getMaxLength(Object obj) {
-            if (!(obj instanceof char[])) {
-                return super.getMaxLength(obj);
-            }
-            return 1 + DataUtils.MAX_VAR_INT_LEN + 2 * ((char[]) obj).length;
-        }
-
-        @Override
-        public void write(ByteBuffer buff, Object obj) {
-            if (obj instanceof char[]) {
-                buff.put((byte) TYPE_CHAR_ARRAY);
-                char[] data = (char[]) obj;
-                int len = data.length;
-                DataUtils.writeVarInt(buff,  len);
-                buff.asCharBuffer().put(data);
-                buff.position(buff.position() + len + len);
+            int size = 64;
+            Class<?> type = obj.getClass().getComponentType();
+            if (type.isPrimitive()) {
+                int len = Array.getLength(obj);
+                if (type == boolean.class) {
+                    size += len;
+                } else if (type == byte.class) {
+                    size += len;
+                } else if (type == char.class) {
+                    size += len * 2;
+                } else if (type == short.class) {
+                    size += len * 2;
+                } else if (type == int.class) {
+                    size += len * 4;
+                } else if (type == float.class) {
+                    size += len * 4;
+                } else if (type == double.class) {
+                    size += len * 8;
+                } else if (type == long.class) {
+                    size += len * 8;
+                }
             } else {
-                super.write(buff, obj);
-            }
-        }
-
-        @Override
-        public Object read(ByteBuffer buff, int tag) {
-            int len = DataUtils.readVarInt(buff);
-            char[] data = new char[len];
-            buff.asCharBuffer().get(data);
-            buff.position(buff.position() + len + len);
-            return data;
-        }
-
-    }
-
-    /**
-     * The type for char arrays.
-     */
-    class IntArrayType extends AutoDetectDataType {
-
-        IntArrayType(ObjectDataType base) {
-            super(base, TYPE_INT_ARRAY);
-        }
-
-        @Override
-        public int getMemory(Object obj) {
-            if (!(obj instanceof int[])) {
-                return super.getMemory(obj);
+                for (Object x : (Object[]) obj) {
+                    if (x != null) {
+                        size += elementType.getMemory(x);
+                    }
+                }
             }
-            return 24 + 4 * ((int[]) obj).length;
+            return size;
         }
 
         @Override
         public int compare(Object aObj, Object bObj) {
-            if (aObj instanceof int[] && bObj instanceof int[]) {
-                int[] a = (int[]) aObj;
-                int[] b = (int[]) bObj;
-                return compareNotNull(a, b);
+            if (!isArray(aObj) || !isArray(bObj)) {
+                return super.compare(aObj, bObj);
             }
-            return super.compare(aObj, bObj);
-        }
-
-        @Override
-        public int getMaxLength(Object obj) {
-            if (!(obj instanceof int[])) {
-                return super.getMaxLength(obj);
+            if (aObj == bObj) {
+                return 0;
             }
-            return 1 + DataUtils.MAX_VAR_INT_LEN + 4 * ((int[]) obj).length;
-        }
-
-        @Override
-        public void write(ByteBuffer buff, Object obj) {
-            if (obj instanceof int[]) {
-                buff.put((byte) TYPE_INT_ARRAY);
-                int[] data = (int[]) obj;
-                int len = data.length;
-                DataUtils.writeVarInt(buff,  len);
-                buff.asIntBuffer().put(data);
-                buff.position(buff.position() + 4 * len);
+            Class<?> type = aObj.getClass().getComponentType();
+            Class<?> bType = bObj.getClass().getComponentType();
+            if (type != bType) {
+                Integer classA = getCommonClassId(type);
+                Integer classB = getCommonClassId(bType);
+                if (classA != null) {
+                    if (classB != null) {
+                        return classA.compareTo(classB);
+                    }
+                    return -1;
+                } else if (classB != null) {
+                    return 1;
+                }
+                return type.getName().compareTo(bType.getName());
+            }
+            int aLen = Array.getLength(aObj);
+            int bLen = Array.getLength(bObj);
+            int len = Math.min(aLen, bLen);
+            if (type.isPrimitive()) {
+                if (type == byte.class) {
+                    byte[] a = (byte[]) aObj;
+                    byte[] b = (byte[]) bObj;
+                    return Utils.compareNotNull(a, b);
+                }
+                for (int i = 0; i < len; i++) {
+                    int x;
+                    if (type == boolean.class) {
+                        x = Integer.signum(
+                                (((boolean[]) aObj)[i] ? 1 : 0) -
+                                (((boolean[]) bObj)[i] ? 1 : 0));
+                    } else if (type == char.class) {
+                        x = Integer.signum(
+                                (((char[]) aObj)[i]) -
+                                (((char[]) bObj)[i]));
+                    } else if (type == short.class) {
+                        x = Integer.signum(
+                                (((short[]) aObj)[i]) -
+                                (((short[]) bObj)[i]));
+                    } else if (type == int.class) {
+                        int a = ((int[]) aObj)[i];
+                        int b = ((int[]) bObj)[i];
+                        x = a == b ? 0 : a < b ? -1 : 1;
+                    } else if (type == float.class) {
+                        x = Float.compare(
+                                ((float[]) aObj)[i],
+                                ((float[]) bObj)[i]);
+                    } else if (type == double.class) {
+                        x = Double.compare(
+                                ((double[]) aObj)[i],
+                                ((double[]) bObj)[i]);
+                    } else {
+                        long a = ((long[]) aObj)[i];
+                        long b = ((long[]) bObj)[i];
+                        x = a == b ? 0 : a < b ? -1 : 1;
+                    }
+                    if (x != 0) {
+                        return x;
+                    }
+                }
             } else {
-                super.write(buff, obj);
-            }
-        }
-
-        @Override
-        public Object read(ByteBuffer buff, int tag) {
-            int len = DataUtils.readVarInt(buff);
-            int[] data = new int[len];
-            buff.asIntBuffer().get(data);
-            buff.position(buff.position() + 4 * len);
-            return data;
-        }
-
-    }
-
-    /**
-     * The type for char arrays.
-     */
-    class LongArrayType extends AutoDetectDataType {
-
-        LongArrayType(ObjectDataType base) {
-            super(base, TYPE_LONG_ARRAY);
-        }
-
-        @Override
-        public int getMemory(Object obj) {
-            if (!(obj instanceof long[])) {
-                return super.getMemory(obj);
-            }
-            return 24 + 8 * ((long[]) obj).length;
-        }
-
-        @Override
-        public int compare(Object aObj, Object bObj) {
-            if (aObj instanceof long[] && bObj instanceof long[]) {
-                long[] a = (long[]) aObj;
-                long[] b = (long[]) bObj;
-                return compareNotNull(a, b);
+                Object[] a = (Object[]) aObj;
+                Object[] b = (Object[]) bObj;
+                for (int i = 0; i < len; i++) {
+                    int comp = elementType.compare(a[i], b[i]);
+                    if (comp != 0) {
+                        return comp;
+                    }
+                }
             }
-            return super.compare(aObj, bObj);
+            return aLen == bLen ? 0 : aLen < bLen ? -1 : 1;
         }
 
         @Override
         public int getMaxLength(Object obj) {
-            if (!(obj instanceof long[])) {
+            if (!isArray(obj)) {
                 return super.getMaxLength(obj);
             }
-            return 1 + DataUtils.MAX_VAR_INT_LEN + 8 * ((long[]) obj).length;
+            int size = 1 + DataUtils.MAX_VAR_INT_LEN;
+            Class<?> componentType = obj.getClass().getComponentType();
+            if (componentType.isPrimitive()) {
+                size += getMemory(obj);
+            } else {
+                Object[] array = (Object[]) obj;
+                String ct = array.getClass().getComponentType().getName();
+                size += StringDataType.INSTANCE.getMaxLength(ct);
+                for (Object x : array) {
+                    size += elementType.getMaxLength(x);
+                }
+            }
+            return size;
         }
 
         @Override
         public void write(ByteBuffer buff, Object obj) {
-            if (obj instanceof long[]) {
-                buff.put((byte) TYPE_LONG_ARRAY);
-                long[] data = (long[]) obj;
-                int len = data.length;
-                DataUtils.writeVarInt(buff,  len);
-                buff.asLongBuffer().put(data);
-                buff.position(buff.position() + 8 * len);
-            } else {
+            if (!isArray(obj)) {
                 super.write(buff, obj);
+            } else {
+                Class<?> type = obj.getClass().getComponentType();
+                Integer classId = getCommonClassId(type);
+                if (classId != null) {
+                    if (type.isPrimitive()) {
+                        if (type == byte.class) {
+                            byte[] data = (byte[]) obj;
+                            int len = data.length;
+                            if (len <= 15) {
+                                buff.put((byte) (TAG_BYTE_ARRAY_0_15 + len));
+                            } else {
+                                buff.put((byte) TYPE_ARRAY);
+                                buff.put((byte) classId.intValue());
+                                DataUtils.writeVarInt(buff,  len);
+                            }
+                            buff.put(data);
+                            return;
+                        }
+                        buff.put((byte) TYPE_ARRAY);
+                        buff.put((byte) classId.intValue());
+                        int len = Array.getLength(obj);
+                        DataUtils.writeVarInt(buff, len);
+                        for (int i = 0; i < len; i++) {
+                            if (type == boolean.class) {
+                                buff.put((byte) (((boolean[]) obj)[i] ? 1 : 0));
+                            } else if (type == char.class) {
+                                buff.putChar(((char[]) obj)[i]);
+                            } else if (type == short.class) {
+                                buff.putShort(((short[]) obj)[i]);
+                            } else if (type == int.class) {
+                                buff.putInt(((int[]) obj)[i]);
+                            } else if (type == float.class) {
+                                buff.putFloat(((float[]) obj)[i]);
+                            } else if (type == double.class) {
+                                buff.putDouble(((double[]) obj)[i]);
+                            } else {
+                                buff.putLong(((long[]) obj)[i]);
+                            }
+                        }
+                        return;
+                    }
+                    buff.put((byte) TYPE_ARRAY);
+                    buff.put((byte) classId.intValue());
+                } else {
+                    buff.put((byte) TYPE_ARRAY);
+                    buff.put((byte) -1);
+                    String c = type.getName();
+                    StringDataType.INSTANCE.write(buff, c);
+                }
+                Object[] array = (Object[]) obj;
+                int len = array.length;
+                DataUtils.writeVarInt(buff,  len);
+                for (Object x : array) {
+                    elementType.write(buff, x);
+                }
             }
         }
 
         @Override
         public Object read(ByteBuffer buff, int tag) {
+            if (tag != TYPE_ARRAY) {
+                byte[] data;
+                int len = tag - TAG_BYTE_ARRAY_0_15;
+                data = Utils.newBytes(len);
+                buff.get(data);
+                return data;
+            }
+            int ct = buff.get();
+            Class<?> clazz;
+            Object obj;
+            if (ct == -1) {
+                String componentType = StringDataType.INSTANCE.read(buff);
+                try {
+                    clazz = Class.forName(componentType);
+                } catch (Exception e) {
+                    throw DataUtils.newIllegalStateException(
+                            "Could not get class {0}",
+                            componentType, e);
+                }
+            } else {
+                clazz = COMMON_CLASSES[ct];
+            }
             int len = DataUtils.readVarInt(buff);
-            long[] data = new long[len];
-            buff.asLongBuffer().get(data);
-            buff.position(buff.position() + 8 * len);
-            return data;
+            try {
+                obj = Array.newInstance(clazz, len);
+            } catch (Exception e) {
+                throw DataUtils.newIllegalStateException(
+                        "Could not create array of type {0} length {1}",
+                        clazz, len, e);
+            }
+            if (clazz.isPrimitive()) {
+                for (int i = 0; i < len; i++) {
+                    if (clazz == boolean.class) {
+                        ((boolean[]) obj)[i] = buff.get() == 1;
+                    } else if (clazz == byte.class) {
+                        ((byte[]) obj)[i] = buff.get();
+                    } else if (clazz == char.class) {
+                        ((char[]) obj)[i] = buff.getChar();
+                    } else if (clazz == short.class) {
+                        ((short[]) obj)[i] = buff.getShort();
+                    } else if (clazz == int.class) {
+                        ((int[]) obj)[i] = buff.getInt();
+                    } else if (clazz == float.class) {
+                        ((float[]) obj)[i] = buff.getFloat();
+                    } else if (clazz == double.class) {
+                        ((double[]) obj)[i] = buff.getDouble();
+                    } else {
+                        ((long[]) obj)[i] = buff.getLong();
+                    }
+                }
+            } else {
+                Object[] array = (Object[]) obj;
+                for (int i = 0; i < len; i++) {
+                    array[i] = elementType.read(buff);
+                }
+            }
+            return obj;
         }
 
     }

h2/src/main/org/h2/security/CipherFactory.java

@@ -21,6 +21,7 @@ import java.security.PrivateKey;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateFactory;
 import java.security.spec.PKCS8EncodedKeySpec;
+import java.util.Arrays;
 import java.util.Properties;
 import javax.net.ServerSocketFactory;
 import javax.net.ssl.SSLServerSocket;
@@ -33,7 +34,6 @@ import org.h2.message.DbException;
 import org.h2.store.fs.FileUtils;
 import org.h2.util.IOUtils;
 import org.h2.util.StringUtils;
-import org.h2.util.Utils;
 
 /**
  * A factory to create new block cipher objects.
@@ -231,7 +231,7 @@ public class CipherFactory {
                 // don't need to overwrite the file if it did not change
                 InputStream fin = FileUtils.newInputStream(fileName);
                 byte[] now = IOUtils.readBytesAndClose(fin, 0);
-                if (now != null && Utils.compareNotNull(data, now) == 0) {
+                if (now != null && Arrays.equals(data, now)) {
                     needWrite = false;
                 }
             }

h2/src/main/org/h2/store/FileStore.java

@@ -10,6 +10,7 @@ import java.io.IOException;
 import java.lang.ref.Reference;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
+import java.util.Arrays;
 import org.h2.constant.ErrorCode;
 import org.h2.constant.SysProperties;
 import org.h2.engine.Constants;
@@ -17,7 +18,6 @@ import org.h2.message.DbException;
 import org.h2.security.SecureFileStore;
 import org.h2.store.fs.FileUtils;
 import org.h2.util.TempFileDeleter;
-import org.h2.util.Utils;
 
 /**
  * This class is an abstraction of a random access file.
@@ -193,7 +193,7 @@ public class FileStore {
             seek(0);
             byte[] buff = new byte[len];
             readFullyDirect(buff, 0, len);
-            if (Utils.compareNotNull(buff, magic) != 0) {
+            if (!Arrays.equals(buff, magic)) {
                 throw DbException.get(ErrorCode.FILE_VERSION_ERROR_1, name);
             }
             salt = new byte[len];
@@ -201,7 +201,7 @@ public class FileStore {
             initKey(salt);
             // read (maybe) encrypted
             readFully(buff, 0, Constants.FILE_BLOCK_SIZE);
-            if (Utils.compareNotNull(buff, magic) != 0) {
+            if (!Arrays.equals(buff, magic)) {
                 throw DbException.get(ErrorCode.FILE_ENCRYPTION_ERROR_1, name);
             }
         }

h2/src/main/org/h2/util/Utils.java

@@ -204,12 +204,14 @@ public class Utils {
      * first array is smaller than the second array, -1 is returned. If the
      * content or length of the second array is smaller than the first array, 1
      * is returned. If the contents and lengths are the same, 0 is returned.
+     * <p>
+     * This method interprets bytes as signed.
      *
      * @param data1 the first byte array (must not be null)
      * @param data2 the second byte array (must not be null)
      * @return the result of the comparison (-1, 1 or 0)
      */
-    public static int compareNotNull(byte[] data1, byte[] data2) {
+    public static int compareNotNullSigned(byte[] data1, byte[] data2) {
         if (data1 == data2) {
             return 0;
         }
@@ -224,6 +226,33 @@ public class Utils {
         return Integer.signum(data1.length - data2.length);
     }
 
+    /**
+     * Compare the contents of two byte arrays. If the content or length of the
+     * first array is smaller than the second array, -1 is returned. If the
+     * content or length of the second array is smaller than the first array, 1
+     * is returned. If the contents and lengths are the same, 0 is returned.
+     * <p>
+     * This method interprets bytes as unsigned.
+     *
+     * @param data1 the first byte array (must not be null)
+     * @param data2 the second byte array (must not be null)
+     * @return the result of the comparison (-1, 1 or 0)
+     */
+    public static int compareNotNull(byte[] data1, byte[] data2) {
+        if (data1 == data2) {
+            return 0;
+        }
+        int len = Math.min(data1.length, data2.length);
+        for (int i = 0; i < len; i++) {
+            int b = data1[i] & 255;
+            int b2 = data2[i] & 255;
+            if (b != b2) {
+                return b > b2 ? 1 : -1;
+            }
+        }
+        return Integer.signum(data1.length - data2.length);
+    }
+
     /**
      * Copy the contents of the source array to the target array. If the size if
      * the target array is too small, a larger array is created.

h2/src/main/org/h2/value/ValueBytes.java

@@ -8,6 +8,7 @@ package org.h2.value;
 
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
+import java.util.Arrays;
 import org.h2.constant.SysProperties;
 import org.h2.util.MathUtils;
 import org.h2.util.StringUtils;
@@ -86,7 +87,7 @@ public class ValueBytes extends Value {
 
     protected int compareSecure(Value v, CompareMode mode) {
         byte[] v2 = ((ValueBytes) v).value;
-        return Utils.compareNotNull(value, v2);
+        return Utils.compareNotNullSigned(value, v2);
     }
 
     public String getString() {
@@ -121,7 +122,7 @@ public class ValueBytes extends Value {
     }
 
     public boolean equals(Object other) {
-        return other instanceof ValueBytes && Utils.compareNotNull(value, ((ValueBytes) other).value) == 0;
+        return other instanceof ValueBytes && Arrays.equals(value, ((ValueBytes) other).value);
     }
 
     public Value convertPrecision(long precision, boolean force) {

h2/src/main/org/h2/value/ValueJavaObject.java

@@ -122,7 +122,7 @@ public class ValueJavaObject extends ValueBytes {
                     return 0;
                 }
 
-                return Utils.compareNotNull(getBytesNoCopy(), v.getBytesNoCopy());
+                return Utils.compareNotNullSigned(getBytesNoCopy(), v.getBytesNoCopy());
             }
 
             return h1 > h2 ? 1 : -1;

h2/src/main/org/h2/value/ValueLob.java

@@ -606,7 +606,7 @@ public class ValueLob extends Value {
             return Integer.signum(getString().compareTo(v.getString()));
         }
         byte[] v2 = v.getBytesNoCopy();
-        return Utils.compareNotNull(getBytes(), v2);
+        return Utils.compareNotNullSigned(getBytes(), v2);
     }
 
     public Object getObject() {

h2/src/main/org/h2/value/ValueLobDb.java

@@ -265,7 +265,7 @@ public class ValueLobDb extends Value implements Value.ValueClob, Value.ValueBlo
             return Integer.signum(getString().compareTo(v.getString()));
         }
         byte[] v2 = v.getBytesNoCopy();
-        return Utils.compareNotNull(getBytes(), v2);
+        return Utils.compareNotNullSigned(getBytes(), v2);
     }
 
     public Object getObject() {

h2/src/test/org/h2/test/jdbcx/SimpleXid.java

@@ -6,10 +6,10 @@
  */
 package org.h2.test.jdbcx;
 
+import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicInteger;
 import javax.transaction.xa.Xid;
 import org.h2.util.MathUtils;
-import org.h2.util.Utils;
 
 /**
  * A simple Xid implementation.
@@ -62,8 +62,8 @@ public class SimpleXid implements Xid {
         if (other instanceof Xid) {
             Xid xid = (Xid) other;
             if (xid.getFormatId() == formatId) {
-                if (Utils.compareNotNull(branchQualifier, xid.getBranchQualifier()) == 0) {
-                    if (Utils.compareNotNull(globalTransactionId, xid.getGlobalTransactionId()) == 0) {
+                if (Arrays.equals(branchQualifier, xid.getBranchQualifier())) {
+                    if (Arrays.equals(globalTransactionId, xid.getGlobalTransactionId())) {
                         return true;
                     }
                 }

h2/src/test/org/h2/test/store/TestMVStore.java

@@ -40,6 +40,7 @@ public class TestMVStore extends TestBase {
 
     public void test() throws Exception {
         FileUtils.deleteRecursive(getBaseDir(), true);
+        testFileFormatChange();
         testRecreateMap();
         testRenameMapRollback();
         testCustomMapType();
@@ -73,6 +74,29 @@ public class TestMVStore extends TestBase {
         testSimple();
     }
 
+    private void testFileFormatChange() {
+        String fileName = getBaseDir() + "/testFileFormatChange.h3";
+        FileUtils.delete(fileName);
+        MVStore s;
+        MVMap<Integer, Integer> m;
+        s = openStore(fileName);
+        m = s.openMap("test");
+        m.put(1, 1);
+        Map<String, String> header = s.getFileHeader();
+        int format = Integer.parseInt(header.get("format"));
+        assertEquals(1, format);
+        header.put("format", Integer.toString(format + 1));
+        s.store();
+        s.close();
+        try {
+            openStore(fileName).close();
+            fail();
+        } catch (IllegalStateException e) {
+            assertTrue(e.getCause() != null);
+        }
+        FileUtils.delete(fileName);
+    }
+
     private void testRecreateMap() {
         String fileName = getBaseDir() + "/testRecreateMap.h3";
         FileUtils.delete(fileName);
@@ -168,6 +192,10 @@ public class TestMVStore extends TestBase {
         } catch (IllegalStateException e) {
             // expected
         }
+        assertFalse(s.isReadOnly());
+        s.close();
+        s = new MVStore.Builder().fileName(fileName).readOnly().open();
+        assertTrue(s.isReadOnly());
         s.close();
     }
 

h2/src/test/org/h2/test/store/TestMVTableEngine.java

@@ -33,12 +33,32 @@ public class TestMVTableEngine extends TestBase {
     }
 
     public void test() throws Exception {
+        testReadOnly();
         testReuseDiskSpace();
         testDataTypes();
         testLocking();
         testSimple();
     }
 
+    private void testReadOnly() throws Exception {
+        FileUtils.deleteRecursive(getBaseDir(), true);
+        String dbName = "mvstore" +
+                ";DEFAULT_TABLE_ENGINE=org.h2.mvstore.db.MVTableEngine";
+        Connection conn;
+        Statement stat;
+        conn = getConnection(dbName);
+        stat = conn.createStatement();
+        stat.execute("create table test(id int)");
+        conn.close();
+        FileUtils.setReadOnly(getBaseDir() + "/mvstore.h2.db");
+        conn = getConnection(dbName);
+        for (MVTableEngine.Store s : MVTableEngine.getStores()) {
+            assertTrue(s.getStore().isReadOnly());
+        }
+        conn.close();
+        FileUtils.deleteRecursive(getBaseDir(), true);
+    }
+
     private void testReuseDiskSpace() throws Exception {
         FileUtils.deleteRecursive(getBaseDir(), true);
         String dbName = "mvstore" +

h2/src/test/org/h2/test/store/TestObjectDataType.java

@@ -69,19 +69,34 @@ public class TestObjectDataType extends TestBase {
                 new UUID(Long.MIN_VALUE, Long.MIN_VALUE),
                 new UUID(Long.MIN_VALUE, 0), new UUID(0, 0),
                 new UUID(Long.MAX_VALUE, Long.MAX_VALUE),
+                new java.util.Date(0), new java.util.Date(1000),
+                new java.util.Date(4000), new java.util.Date(5000),
+                new boolean[0], new boolean[] { false, false },
+                new boolean[] { true },
                 new byte[0], new byte[1], new byte[15], new byte[16],
                 new byte[10000], new byte[] { (byte) 1 },
+                new byte[] { (byte) 0xff },
+                new short[0], new short[] { -1 }, new short[] { 1 },
+                new char[0], new char[1], new char[10000],
+                new char[] { (char) 1 },
                 new int[0], new int[1], new int[15], new int[16],
                 new int[10000], new int[] { (byte) 1 },
                 new long[0], new long[1], new long[15], new long[16],
                 new long[10000], new long[] { (byte) 1 },
-                new char[0], new char[1], new char[10000], new char[] { (char) 1 },
-                new java.util.Date(0), new java.util.Date(1000),
-                new Timestamp(2000), new Timestamp(3000),
-                new java.util.Date(4000), new java.util.Date(5000),
-                new Object[0], new Object[] { 1 },
+                new float[0], new float[]{Float.NEGATIVE_INFINITY},
+                new float[1], new float[]{Float.POSITIVE_INFINITY},
+                new double[0], new double[]{Double.NEGATIVE_INFINITY},
+                new double[1], new double[]{Double.POSITIVE_INFINITY},
+                new Object[0],
+                new Object[100],
+                new Object[] { 1 },
                 new Object[] { 0.0, "Hello", null, Double.NaN },
-                new Object[100]
+                new String[] { "Hello", null },
+                new String[] { "World" },
+                new java.sql.Date[] { },
+                new Timestamp[] { },
+                new Timestamp[] { null },
+                new Timestamp(2000), new Timestamp(3000),
             };
         Object otherType = false;
         Object last = null;
@@ -91,7 +106,8 @@ public class TestObjectDataType extends TestBase {
                 int comp = ot.compare(x, last);
                 if (comp <= 0) {
                     ot.compare(x, last);
-                    fail(x.getClass().getName() + ": " + x.toString() + " " + comp);
+                    fail(x.getClass().getSimpleName() + ": " +
+                            x.toString() + " " + comp);
                 }
                 assertTrue(x.toString(), ot.compare(last, x) < 0);
             }
@@ -133,6 +149,14 @@ public class TestObjectDataType extends TestBase {
         if (x.getClass().isArray()) {
             if (x instanceof byte[]) {
                 assertTrue(Arrays.equals((byte[]) x, (byte[]) y));
+            } else if (x instanceof boolean[]) {
+                assertTrue(Arrays.equals((boolean[]) x, (boolean[]) y));
+            } else if (x instanceof short[]) {
+                assertTrue(Arrays.equals((short[]) x, (short[]) y));
+            } else if (x instanceof float[]) {
+                assertTrue(Arrays.equals((float[]) x, (float[]) y));
+            } else if (x instanceof double[]) {
+                assertTrue(Arrays.equals((double[]) x, (double[]) y));
             } else if (x instanceof char[]) {
                 assertTrue(Arrays.equals((char[]) x, (char[]) y));
             } else if (x instanceof int[]) {

h2/src/test/org/h2/test/unit/TestSecurity.java

@@ -9,12 +9,12 @@ package org.h2.test.unit;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
+import java.util.Arrays;
 import org.h2.security.BlockCipher;
 import org.h2.security.CipherFactory;
 import org.h2.security.SHA256;
 import org.h2.test.TestBase;
 import org.h2.util.StringUtils;
-import org.h2.util.Utils;
 
 /**
  * Tests various security primitives.
@@ -142,7 +142,7 @@ public class TestSecurity extends TestBase {
         byte[] enc = new byte[128];
         test.encrypt(enc, 0, 128);
         test.decrypt(enc, 0, 128);
-        if (Utils.compareNotNull(in, enc) != 0) {
+        if (!Arrays.equals(in, enc)) {
             throw new AssertionError();
         }
 

h2/src/tools/org/h2/build/code/CheckTextFiles.java

@@ -9,8 +9,7 @@ package org.h2.build.code;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.RandomAccessFile;
-
-import org.h2.util.Utils;
+import java.util.Arrays;
 
 /**
  * This tool checks that source code files only contain the allowed set of
@@ -239,7 +238,7 @@ public class CheckTextFiles {
         }
         if (fix) {
             byte[] changed = out.toByteArray();
-            if (Utils.compareNotNull(data, changed) != 0) {
+            if (!Arrays.equals(data, changed)) {
                 RandomAccessFile f = new RandomAccessFile(file, "rw");
                 f.write(changed);
                 f.setLength(changed.length);

h2/src/tools/org/h2/dev/fs/FilePathCrypt.java

@@ -124,7 +124,6 @@ class FileCrypt extends FileBase {
     static final int BLOCK_SIZE = Constants.FILE_BLOCK_SIZE;
 
     // TODO improve the header
-    // TODO store the number of empty blocks in the last block
     private static final byte[] HEADER = "-- H2 crypt --\n\0".getBytes();
     private static final int SALT_POS = HEADER.length;
     private static final int SALT_LENGTH = 16;