1.4.0 Scan to return SortedMap, Key now implements Comparable

Author: mark-jones-at-bettercloud

core/src/main/java/com/bettercloud/bigtable/orm/BigTableEntityDao.java

@@ -9,9 +9,15 @@
 import org.apache.hadoop.hbase.client.ResultScanner;
 import org.apache.hadoop.hbase.client.Scan;
 import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.filter.BinaryComparator;
+import org.apache.hadoop.hbase.filter.CompareFilter;
+import org.apache.hadoop.hbase.filter.Filter;
+import org.apache.hadoop.hbase.filter.FilterList;
 import org.apache.hadoop.hbase.filter.PageFilter;
+import org.apache.hadoop.hbase.filter.RowFilter;
 import org.apache.hadoop.hbase.util.Bytes;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.time.Instant;
 import java.util.ArrayList;
@@ -22,6 +28,8 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
@@ -137,8 +145,10 @@ public <K extends Key<T>> Map<K, T> getAll(final Set<K> keys) throws IOException
     }
 
     /**
+     * Utility method for running scan without a provided constant.
+     *
      * Runs a paging table scan from the provided starting key to the provided ending key,
-     * and returns a list of entities in the order returned from BigTable.
+     * and returns a list of paired Key/Value entities in the order returned from BigTable.
      *
      * Use the last returned entity to construct a new starting key for subsequent paging requests until no values are returned.
      *
@@ -151,31 +161,63 @@ public <K extends Key<T>> Map<K, T> getAll(final Set<K> keys) throws IOException
      * @throws IOException when an error occurs while communicating with BigTable
      */
     @Override
-    public <K extends Key<T>> List<T> scan(final K startKey,
-                                           final boolean startKeyInclusive,
-                                           final K endKey,
-                                           final boolean endKeyInclusive,
-                                           final int numRows) throws IOException {
+    public <K extends Key<T>> SortedMap<Key<T>, T> scan(final K startKey,
+                                                         final boolean startKeyInclusive,
+                                                         final K endKey,
+                                                         final boolean endKeyInclusive,
+                                                         final int numRows) throws IOException {
+        return scan(startKey, startKeyInclusive, endKey, endKeyInclusive, numRows, null);
+    }
+
+    /**
+     * Runs a paging table scan from the provided starting key to the provided ending key,
+     * and returns a list of paired Key/Value entities in the order returned from BigTable.
+     *
+     * Use the last returned entity to construct a new starting key for subsequent paging requests until no values are returned.
+     *
+     * @param startKey key to start scanning from (does not have to have an existing record at the location)
+     * @param startKeyInclusive whether to include result from startKey
+     * @param endKey key to end scanning on (does not have to have an existing record at the location)
+     * @param endKeyInclusive whether to include result from endKey
+     * @param numRows max number of entries to return
+     * @param constant optional field to be used to be included, should be the constant provided to KeyComponent if it exists
+     * @return A list of entities in the order that they are stored in BigTable
+     * @throws IOException when an error occurs while communicating with BigTable
+     */
+    @Override
+    public <K extends Key<T>> SortedMap<Key<T>, T> scan(final K startKey,
+                                                        final boolean startKeyInclusive,
+                                                        final K endKey,
+                                                        final boolean endKeyInclusive,
+                                                        final int numRows,
+                                                        @Nullable final String constant) throws IOException {
         Objects.requireNonNull(startKey);
         Objects.requireNonNull(endKey);
 
+        List<Filter> filters = new ArrayList<>();
+        filters.add(new PageFilter(numRows));
+        if (Objects.nonNull(constant) && !"".equals(constant)) {
+            filters.add(new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(constant.getBytes())));
+        }
+        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL, filters);
+
         final Scan scan = new Scan();
-        scan.setFilter(new PageFilter(numRows));
+        scan.setFilter(filterList);
         scan.withStartRow(startKey.toBytes(), startKeyInclusive);
         scan.withStopRow(endKey.toBytes(), endKeyInclusive);
 
         final ResultScanner scanner = table.getScanner(scan);
-        final List<T> results = new ArrayList<>();
+        final SortedMap<Key<T>, T> results = new TreeMap<>();
 
         Result result;
         while ((result = scanner.next()) != null) {
             if (!result.isEmpty()) {
                 final T entity = delegateToEntity(result);
-                results.add(entity);
+                results.put(new RawKey<T>(result.getRow()), entity);
             }
         }
 
-        return Collections.unmodifiableList(results);
+        return Collections.unmodifiableSortedMap(results);
     }
 
     /**

core/src/main/java/com/bettercloud/bigtable/orm/Dao.java

@@ -1,10 +1,10 @@
 package com.bettercloud.bigtable.orm;
 
 import java.io.IOException;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.SortedMap;
 
 public interface Dao<T extends Entity> {
 
@@ -13,11 +13,19 @@ public interface Dao<T extends Entity> {
 
     <K extends Key<T>> Map<K, T> getAll(final Set<K> keys) throws IOException;
 
-    <K extends Key<T>> List<T> scan(final K startKey,
-                                    final boolean startKeyInclusive,
-                                    final K endKey,
-                                    final boolean endKeyInclusive,
-                                    final int numRows) throws IOException;
+    <K extends Key<T>> SortedMap<Key<T>, T> scan(final K startKey,
+                                                 final boolean startKeyInclusive,
+                                                 final K endKey,
+                                                 final boolean endKeyInclusive,
+                                                 final int numRows) throws IOException;
+
+    <K extends Key<T>> SortedMap<Key<T>, T> scan(final K startKey,
+                                                 final boolean startKeyInclusive,
+                                                 final K endKey,
+                                                 final boolean endKeyInclusive,
+                                                 final int numRows,
+                                                 final String constant) throws IOException;
+
     @Deprecated
     <K extends Key<T>> T save(final K key, final T entity) throws IOException;
 

core/src/main/java/com/bettercloud/bigtable/orm/Key.java

@@ -1,6 +1,6 @@
 package com.bettercloud.bigtable.orm;
 
-public interface Key<T extends Entity> {
+public interface Key<T extends Entity> extends Comparable<Key> {
 
     byte[] toBytes();
 }

core/src/main/java/com/bettercloud/bigtable/orm/RawKey.java

@@ -0,0 +1,36 @@
+package com.bettercloud.bigtable.orm;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+public class RawKey<T extends Entity> implements Key<T> {
+
+    private final byte[] key;
+
+    public RawKey(byte[] key) {
+        this.key = Arrays.copyOf(key, key.length);
+    }
+
+    @Override
+    public byte[] toBytes() {
+        return key;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RawKey<?> rawKey = (RawKey<?>) o;
+        return Arrays.equals(key, rawKey.key);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(key);
+    }
+
+    @Override
+    public int compareTo(Key otherKey) {
+        return ByteBuffer.wrap(this.toBytes()).compareTo(ByteBuffer.wrap(otherKey.toBytes()));
+    }
+}

core/src/main/java/com/bettercloud/bigtable/orm/StringKey.java

@@ -2,6 +2,7 @@
 
 import org.apache.hadoop.hbase.util.Bytes;
 
+import java.nio.ByteBuffer;
 import java.util.Objects;
 
 public class StringKey<T extends Entity> implements Key<T> {
@@ -42,4 +43,9 @@ public int hashCode() {
     public String toString() {
         return keyString;
     }
+
+    @Override
+    public int compareTo(Key otherKey) {
+        return ByteBuffer.wrap(this.toBytes()).compareTo(ByteBuffer.wrap(otherKey.toBytes()));
+    }
 }