Add AsynchronousFileChannel-based experimental FilePathAsync

h2/src/docsrc/html/advanced.html

@@ -1550,6 +1550,7 @@ The following file systems are included:
 </li><li><code>nioMapped:</code> file system that uses memory mapped files (faster in some operating systems).
     Please note that there currently is a file size limitation of 2 GB when using this file system.
     To work around this limitation, combine it with the split file system: <code>split:nioMapped:test</code>.
+</li><li><code>async:</code> experimental file system that uses <code>AsynchronousFileChannel</code> instead of <code>RandomAccessFile</code> (faster in some operating systems).
 </li><li><code>memFS:</code> in-memory file system (slower than mem; experimental; mainly used for testing the database engine itself).
 </li><li><code>memLZF:</code> compressing in-memory file system (slower than memFS but uses less memory; experimental; mainly used for testing the database engine itself).
 </li><li><code>nioMemFS:</code> stores data outside of the VM's heap - useful for large memory DBs without incurring GC costs.

h2/src/main/org/h2/store/fs/FilePath.java

@@ -74,6 +74,7 @@ public abstract class FilePath {
                     "org.h2.store.fs.FilePathSplit",
                     "org.h2.store.fs.FilePathNio",
                     "org.h2.store.fs.FilePathNioMapped",
+                    "org.h2.store.fs.FilePathAsync",
                     "org.h2.store.fs.FilePathZip",
                     "org.h2.store.fs.FilePathRetryOnInterrupt"
             }) {

h2/src/main/org/h2/store/fs/FilePathAsync.java

+/*
+ * Copyright 2004-2018 H2 Group. Multiple-Licensed under the MPL 2.0,
+ * and the EPL 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.store.fs;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousFileChannel;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.channels.NonWritableChannelException;
+import java.nio.file.OpenOption;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * This file system stores files on disk and uses
+ * java.nio.channels.AsynchronousFileChannel to access the files.
+ */
+public class FilePathAsync extends FilePathWrapper {
+
+    private static final boolean AVAILABLE;
+
+    /*
+     * Android has NIO2 only since API 26.
+     */
+    static {
+        boolean a = false;
+        try {
+            AsynchronousFileChannel.class.getName();
+            a = true;
+        } catch (Throwable e) {
+            // Nothing to do
+        }
+        AVAILABLE = a;
+    }
+
+    /**
+     * Creates new instance of FilePathAsync.
+     */
+    public FilePathAsync() {
+        if (!AVAILABLE) {
+            throw new UnsupportedOperationException("NIO2 is not available");
+        }
+    }
+
+    @Override
+    public FileChannel open(String mode) throws IOException {
+        return new FileAsync(name.substring(getScheme().length() + 1), mode);
+    }
+
+    @Override
+    public String getScheme() {
+        return "async";
+    }
+
+}
+
+/**
+ * File which uses NIO2 AsynchronousFileChannel.
+ */
+class FileAsync extends FileBase {
+
+    private static final OpenOption[] R = { StandardOpenOption.READ };
+
+    private static final OpenOption[] W = { StandardOpenOption.READ, StandardOpenOption.WRITE,
+            StandardOpenOption.CREATE };
+
+    private static final OpenOption[] RWS = { StandardOpenOption.READ, StandardOpenOption.WRITE,
+            StandardOpenOption.CREATE, StandardOpenOption.SYNC };
+
+    private static final OpenOption[] RWD = { StandardOpenOption.READ, StandardOpenOption.WRITE,
+            StandardOpenOption.CREATE, StandardOpenOption.DSYNC };
+
+    private final String name;
+
+    private final AsynchronousFileChannel channel;
+
+    private long position;
+
+    FileAsync(String fileName, String mode) throws IOException {
+        this.name = fileName;
+        OpenOption[] options;
+        switch (mode) {
+        case "r":
+            options = R;
+            break;
+        case "rw":
+            options = W;
+            break;
+        case "rws":
+            options = RWS;
+            break;
+        case "rwd":
+            options = RWD;
+            break;
+        default:
+            throw new IllegalArgumentException(mode);
+        }
+        channel = AsynchronousFileChannel.open(Paths.get(fileName), options);
+    }
+
+    @Override
+    public void implCloseChannel() throws IOException {
+        channel.close();
+    }
+
+    @Override
+    public long position() throws IOException {
+        return position;
+    }
+
+    @Override
+    public long size() throws IOException {
+        return channel.size();
+    }
+
+    @Override
+    public int read(ByteBuffer dst) throws IOException {
+        int read;
+        try {
+            read = channel.read(dst, position).get();
+            if (read > 0) {
+                position += read;
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            throw new IOException(e);
+        }
+        return read;
+    }
+
+    @Override
+    public FileChannel position(long pos) throws IOException {
+        position = pos;
+        return this;
+    }
+
+    @Override
+    public int read(ByteBuffer dst, long position) throws IOException {
+        try {
+            return channel.read(dst, position).get();
+        } catch (InterruptedException | ExecutionException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public int write(ByteBuffer src, long position) throws IOException {
+        try {
+            return channel.write(src, position).get();
+        } catch (NonWritableChannelException e) {
+            throw new IOException("read only");
+        } catch (InterruptedException | ExecutionException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public FileChannel truncate(long newLength) throws IOException {
+        channel.truncate(newLength);
+        if (position < newLength) {
+            position = newLength;
+        }
+        return this;
+    }
+
+    @Override
+    public void force(boolean metaData) throws IOException {
+        channel.force(metaData);
+    }
+
+    @Override
+    public int write(ByteBuffer src) throws IOException {
+        int read;
+        try {
+            read = channel.write(src, position).get();
+            position += read;
+        } catch (NonWritableChannelException e) {
+            throw new IOException("read only");
+        } catch (InterruptedException | ExecutionException e) {
+            throw new IOException(e);
+        }
+        return read;
+    }
+
+    @Override
+    public synchronized FileLock tryLock(long position, long size, boolean shared) throws IOException {
+        return channel.tryLock(position, size, shared);
+    }
+
+    @Override
+    public String toString() {
+        return "async:" + name;
+    }
+
+}