Merge pull request #189 from svladykin/batchJoin2

Batching support for index lookups and batched joins.

h2/src/main/org/h2/command/CommandContainer.java

@@ -17,7 +17,7 @@ import org.h2.value.ValueNull;
  * Represents a single SQL statements.
  * It wraps a prepared statement.
  */
-class CommandContainer extends Command {
+public class CommandContainer extends Command {
 
     private Prepared prepared;
     private boolean readOnlyKnown;

h2/src/main/org/h2/index/BaseIndex.java

@@ -427,13 +427,8 @@ public abstract class BaseIndex extends SchemaObjectBase implements Index {
     }
 
     @Override
-    public int getPreferedLookupBatchSize() {
-        // No batched lookups supported by default.
-        return 0;
-    }
-
-    @Override
-    public List<Future<Cursor>> findBatched(TableFilter filter, List<SearchRow> firstLastPairs) {
-        throw DbException.throwInternalError("Must not be called if getPreferedLookupBatchSize() is 0.");
+    public IndexLookupBatch createLookupBatch(TableFilter filter) {
+        // Lookup batching is not supported.
+        return null;
     }
 }

h2/src/main/org/h2/index/Index.java

@@ -259,27 +259,11 @@ public interface Index extends SchemaObject {
     void setSortedInsertMode(boolean sortedInsertMode);
 
     /**
-     * If this index can do batched lookups, it may return it's preferred batch size,
-     * otherwise it must return 0.
+     * Creates new lookup batch. Note that returned {@link IndexLookupBatch} instance 
+     * can be used multiple times.
      *
-     * @return preferred batch size or 0 if lookup batching is not supported
-     * @see #findBatched(TableFilter, Collection)
+     * @param filter Table filter.
+     * @return Created batch or {@code null} if batched lookup is not supported by this index.
      */
-    int getPreferedLookupBatchSize();
-
-    /**
-     * Do batched lookup over the given collection of {@link SearchRow} pairs as in
-     * {@link #find(TableFilter, SearchRow, SearchRow)}.
-     * <br/><br/>
-     * Correct implementation must always return number of future cursors equal to
-     * {@code firstLastPairs.size() / 2}. Instead of {@link Future} containing empty
-     * {@link Cursor} it is possible to put {@code null} in result list.
-     *
-     * @param filter the table filter
-     * @param firstLastPairs List of batched search row pairs as in
-     *          {@link #find(TableFilter, SearchRow, SearchRow)}, the collection will be reused by H2,
-     *          thus it makes sense to defensively copy contents if needed.
-     * @return batched cursors for respective search row pairs in the same order
-     */
-    List<Future<Cursor>> findBatched(TableFilter filter, List<SearchRow> firstLastPairs);
+    IndexLookupBatch createLookupBatch(TableFilter filter);
 }

h2/src/main/org/h2/index/IndexLookupBatch.java

+/*
+ * Copyright 2004-2014 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.index;
+
+import java.util.List;
+import java.util.concurrent.Future;
+import org.h2.result.SearchRow;
+
+/**
+ * Support for asynchronous batched lookups in indexes. The flow is the following:
+ * H2 engine will be calling {@link #addSearchRows(SearchRow, SearchRow)} until
+ * method {@link #isBatchFull()}} will return {@code true} or there are no more
+ * search rows to add. Then method {@link #find()} will be called to execute batched lookup.
+ * Note that a single instance of {@link IndexLookupBatch} can be reused for multiple 
+ * sequential batched lookups.
+ * 
+ * @see Index#createLookupBatch(TableFilter)
+ * @author Sergi Vladykin
+ */
+public interface IndexLookupBatch {
+    /**
+     * Add search row pair to the batch.
+     * 
+     * @param first the first row, or null for no limit
+     * @param last the last row, or null for no limit
+     * @see Index#find(TableFilter, SearchRow, SearchRow)
+     */
+    void addSearchRows(SearchRow first, SearchRow last);
+
+    /**
+     * Check if this batch is full.
+     * 
+     * @return {@code true} If batch is full, will not accept any 
+     *          more rows and {@link #find()} can be executed.
+     */
+    boolean isBatchFull();
+    
+    /**
+     * Execute batched lookup and return future cursor for each provided
+     * search row pair. Note that this method must return exactly the same number
+     * of future cursors in result list as number of {@link #addSearchRows(SearchRow, SearchRow)} 
+     * calls has been done before {@link #find()} call exactly in the same order.  
+     * 
+     * @return List of future cursors for collected search rows.
+     */
+    List<Future<Cursor>> find();
+}

h2/src/main/org/h2/index/MultiVersionIndex.java

@@ -389,12 +389,8 @@ public class MultiVersionIndex implements Index {
     }
 
     @Override
-    public int getPreferedLookupBatchSize() {
-        return 0;
-    }
-
-    @Override
-    public List<Future<Cursor>> findBatched(TableFilter filter, List<SearchRow> firstLastPairs) {
-        throw DbException.throwInternalError("Must never be called.");
+    public IndexLookupBatch createLookupBatch(TableFilter filter) {
+        // Lookup batching is not supported.
+        return null;
     }
 }

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

+/*
+ * Copyright 2004-2014 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.util;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Future which is already done.
+ * 
+ * @param <T> Result value.
+ * @author Sergi Vladykin
+ */
+public class DoneFuture<T> implements Future<T> {
+    final T x;
+    
+    public DoneFuture(T x) {
+        this.x = x;
+    }
+    
+    @Override
+    public T get() throws InterruptedException, ExecutionException {
+        return x;
+    }
+
+    @Override
+    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        return x;
+    }
+
+    @Override
+    public boolean isDone() {
+        return true;
+    }
+    
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        return false;
+    }
+    
+    @Override
+    public boolean isCancelled() {
+        return false;
+    }
+    
+    @Override
+    public String toString() {
+        return "DoneFuture->" + x;
+    }
+}