This is an automated email from the ASF dual-hosted git repository.
zhangduo pushed a commit to branch branch-3
in repository https://gitbox.apache.org/repos/asf/hbase.git
The following commit(s) were added to refs/heads/branch-3 by this push:
new 6a36d03912a HBASE-28398 Make sure we close all the scanners in
TestHRegion (#5701)
6a36d03912a is described below
commit 6a36d03912a330bfc142a4827207ceaec2056215
Author: Duo Zhang <zhang...@apache.org>
AuthorDate: Sat Feb 24 16:20:37 2024 +0800
HBASE-28398 Make sure we close all the scanners in TestHRegion (#5701)
Signed-off-by: Bryan Beaudreault <bbeaudrea...@apache.org>
Signed-off-by: Rajeshbabu Chintaguntla <rajeshb...@apache.org>
(cherry picked from commit 63e3a43041cf89ec7c18962380c769f9a253e8d0)
---
.../hadoop/hbase/regionserver/TestHRegion.java | 1080 ++++++++++----------
1 file changed, 539 insertions(+), 541 deletions(-)
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java
index 6a1c285bf8d..d244ca767be 100644
---
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java
@@ -287,21 +287,26 @@ public class TestHRegion {
HBaseTestingUtil.closeRegionAndWAL(this.region);
assertEquals(HConstants.NO_SEQNUM, region.getMaxFlushedSeqId());
assertEquals(0, (long) region.getMaxStoreSeqId().get(COLUMN_FAMILY_BYTES));
- // Open region again.
- region = initHRegion(tableName, method, CONF, COLUMN_FAMILY_BYTES);
- byte[] value = Bytes.toBytes(method);
- // Make a random put against our cf.
- Put put = new Put(value);
- put.addColumn(COLUMN_FAMILY_BYTES, null, value);
- region.put(put);
- // No flush yet so init numbers should still be in place.
- assertEquals(HConstants.NO_SEQNUM, region.getMaxFlushedSeqId());
- assertEquals(0, (long) region.getMaxStoreSeqId().get(COLUMN_FAMILY_BYTES));
- region.flush(true);
- long max = region.getMaxFlushedSeqId();
- HBaseTestingUtil.closeRegionAndWAL(this.region);
- assertEquals(max, region.getMaxFlushedSeqId());
- this.region = null;
+ HRegion oldRegion = region;
+ try {
+ // Open region again.
+ region = initHRegion(tableName, method, CONF, COLUMN_FAMILY_BYTES);
+ byte[] value = Bytes.toBytes(method);
+ // Make a random put against our cf.
+ Put put = new Put(value);
+ put.addColumn(COLUMN_FAMILY_BYTES, null, value);
+ region.put(put);
+ // No flush yet so init numbers should still be in place.
+ assertEquals(HConstants.NO_SEQNUM, region.getMaxFlushedSeqId());
+ assertEquals(0, (long)
region.getMaxStoreSeqId().get(COLUMN_FAMILY_BYTES));
+ region.flush(true);
+ long max = region.getMaxFlushedSeqId();
+ HBaseTestingUtil.closeRegionAndWAL(this.region);
+ assertEquals(max, region.getMaxFlushedSeqId());
+ this.region = null;
+ } finally {
+ HBaseTestingUtil.closeRegionAndWAL(oldRegion);
+ }
}
/**
@@ -615,39 +620,38 @@ public class TestHRegion {
Scan scan = new Scan();
scan.readVersions(3);
// open the first scanner
- RegionScanner scanner1 = region.getScanner(scan);
-
- Delete delete = new Delete(Bytes.toBytes("r1"));
- region.delete(delete);
- region.flush(true);
-
- // open the second scanner
- RegionScanner scanner2 = region.getScanner(scan);
-
- List<Cell> results = new ArrayList<>();
-
- System.out.println("Smallest read point:" + region.getSmallestReadPoint());
+ try (RegionScanner scanner1 = region.getScanner(scan)) {
+ Delete delete = new Delete(Bytes.toBytes("r1"));
+ region.delete(delete);
+ region.flush(true);
+ // open the second scanner
+ try (RegionScanner scanner2 = region.getScanner(scan)) {
+ List<Cell> results = new ArrayList<>();
- // make a major compaction
- region.compact(true);
+ LOG.info("Smallest read point:" + region.getSmallestReadPoint());
- // open the third scanner
- RegionScanner scanner3 = region.getScanner(scan);
+ // make a major compaction
+ region.compact(true);
- // get data from scanner 1, 2, 3 after major compaction
- scanner1.next(results);
- System.out.println(results);
- assertEquals(1, results.size());
+ // open the third scanner
+ try (RegionScanner scanner3 = region.getScanner(scan)) {
+ // get data from scanner 1, 2, 3 after major compaction
+ scanner1.next(results);
+ LOG.info(results.toString());
+ assertEquals(1, results.size());
- results.clear();
- scanner2.next(results);
- System.out.println(results);
- assertEquals(0, results.size());
+ results.clear();
+ scanner2.next(results);
+ LOG.info(results.toString());
+ assertEquals(0, results.size());
- results.clear();
- scanner3.next(results);
- System.out.println(results);
- assertEquals(0, results.size());
+ results.clear();
+ scanner3.next(results);
+ LOG.info(results.toString());
+ assertEquals(0, results.size());
+ }
+ }
+ }
}
@Test
@@ -666,18 +670,18 @@ public class TestHRegion {
Scan scan = new Scan();
scan.readVersions(3);
// open the first scanner
- RegionScanner scanner1 = region.getScanner(scan);
-
- System.out.println("Smallest read point:" + region.getSmallestReadPoint());
+ try (RegionScanner scanner1 = region.getScanner(scan)) {
+ LOG.info("Smallest read point:" + region.getSmallestReadPoint());
- region.compact(true);
+ region.compact(true);
- scanner1.reseek(Bytes.toBytes("r2"));
- List<Cell> results = new ArrayList<>();
- scanner1.next(results);
- Cell keyValue = results.get(0);
- Assert.assertTrue(Bytes.compareTo(CellUtil.cloneRow(keyValue),
Bytes.toBytes("r2")) == 0);
- scanner1.close();
+ scanner1.reseek(Bytes.toBytes("r2"));
+ List<Cell> results = new ArrayList<>();
+ scanner1.next(results);
+ Cell keyValue = results.get(0);
+ assertTrue(Bytes.compareTo(CellUtil.cloneRow(keyValue),
Bytes.toBytes("r2")) == 0);
+ scanner1.close();
+ }
}
@Test
@@ -1462,37 +1466,45 @@ public class TestHRegion {
}
private void deleteColumns(HRegion r, String value, String keyPrefix) throws
IOException {
- InternalScanner scanner = buildScanner(keyPrefix, value, r);
int count = 0;
- boolean more = false;
- List<Cell> results = new ArrayList<>();
- do {
- more = scanner.next(results);
- if (results != null && !results.isEmpty()) count++;
- else break;
- Delete delete = new Delete(CellUtil.cloneRow(results.get(0)));
- delete.addColumn(Bytes.toBytes("trans-tags"), Bytes.toBytes("qual2"));
- r.delete(delete);
- results.clear();
- } while (more);
+ try (InternalScanner scanner = buildScanner(keyPrefix, value, r)) {
+ boolean more = false;
+ List<Cell> results = new ArrayList<>();
+ do {
+ more = scanner.next(results);
+ if (results != null && !results.isEmpty()) {
+ count++;
+ } else {
+ break;
+ }
+ Delete delete = new Delete(CellUtil.cloneRow(results.get(0)));
+ delete.addColumn(Bytes.toBytes("trans-tags"), Bytes.toBytes("qual2"));
+ r.delete(delete);
+ results.clear();
+ } while (more);
+ }
assertEquals("Did not perform correct number of deletes", 3, count);
}
private int getNumberOfRows(String keyPrefix, String value, HRegion r)
throws Exception {
- InternalScanner resultScanner = buildScanner(keyPrefix, value, r);
- int numberOfResults = 0;
- List<Cell> results = new ArrayList<>();
- boolean more = false;
- do {
- more = resultScanner.next(results);
- if (results != null && !results.isEmpty()) numberOfResults++;
- else break;
- for (Cell kv : results) {
- System.out.println("kv=" + kv.toString() + ", " +
Bytes.toString(CellUtil.cloneValue(kv)));
- }
- results.clear();
- } while (more);
- return numberOfResults;
+ try (InternalScanner resultScanner = buildScanner(keyPrefix, value, r)) {
+ int numberOfResults = 0;
+ List<Cell> results = new ArrayList<>();
+ boolean more = false;
+ do {
+ more = resultScanner.next(results);
+ if (results != null && !results.isEmpty()) {
+ numberOfResults++;
+ } else {
+ break;
+ }
+ for (Cell kv : results) {
+ LOG.info("kv=" + kv.toString() + ", " +
Bytes.toString(CellUtil.cloneValue(kv)));
+ }
+ results.clear();
+ } while (more);
+ return numberOfResults;
+ }
}
private InternalScanner buildScanner(String keyPrefix, String value, HRegion
r)
@@ -3322,14 +3334,15 @@ public class TestHRegion {
Scan scan = new Scan();
scan.addFamily(fam1).addFamily(fam2);
- InternalScanner s = region.getScanner(scan);
- List<Cell> results = new ArrayList<>();
- s.next(results);
- assertTrue(CellUtil.matchingRows(results.get(0), rowA));
+ try (InternalScanner s = region.getScanner(scan)) {
+ List<Cell> results = new ArrayList<>();
+ s.next(results);
+ assertTrue(CellUtil.matchingRows(results.get(0), rowA));
- results.clear();
- s.next(results);
- assertTrue(CellUtil.matchingRows(results.get(0), rowB));
+ results.clear();
+ s.next(results);
+ assertTrue(CellUtil.matchingRows(results.get(0), rowB));
+ }
}
@Test
@@ -3453,17 +3466,17 @@ public class TestHRegion {
// next:
Scan scan = new Scan().withStartRow(row);
scan.addColumn(fam1, qual1);
- InternalScanner s = region.getScanner(scan);
-
- List<Cell> results = new ArrayList<>();
- assertEquals(false, s.next(results));
- assertEquals(1, results.size());
- Cell kv = results.get(0);
+ try (InternalScanner s = region.getScanner(scan)) {
+ List<Cell> results = new ArrayList<>();
+ assertEquals(false, s.next(results));
+ assertEquals(1, results.size());
+ Cell kv = results.get(0);
- assertArrayEquals(value2, CellUtil.cloneValue(kv));
- assertArrayEquals(fam1, CellUtil.cloneFamily(kv));
- assertArrayEquals(qual1, CellUtil.cloneQualifier(kv));
- assertArrayEquals(row, CellUtil.cloneRow(kv));
+ assertArrayEquals(value2, CellUtil.cloneValue(kv));
+ assertArrayEquals(fam1, CellUtil.cloneFamily(kv));
+ assertArrayEquals(qual1, CellUtil.cloneQualifier(kv));
+ assertArrayEquals(row, CellUtil.cloneRow(kv));
+ }
}
@Test
@@ -3657,11 +3670,7 @@ public class TestHRegion {
Scan scan = new Scan();
scan.addFamily(fam1);
scan.addFamily(fam2);
- try {
- region.getScanner(scan);
- } catch (Exception e) {
- assertTrue("Families could not be found in Region", false);
- }
+ region.getScanner(scan).close();
}
@Test
@@ -3675,13 +3684,7 @@ public class TestHRegion {
this.region = initHRegion(tableName, method, CONF, families);
Scan scan = new Scan();
scan.addFamily(fam2);
- boolean ok = false;
- try {
- region.getScanner(scan);
- } catch (Exception e) {
- ok = true;
- }
- assertTrue("Families could not be found in Region", ok);
+ assertThrows(NoSuchColumnFamilyException.class, () ->
region.getScanner(scan));
}
@Test
@@ -3705,20 +3708,20 @@ public class TestHRegion {
region.put(put);
Scan scan = null;
- RegionScannerImpl is = null;
- // Testing to see how many scanners that is produced by getScanner,
- // starting
- // with known number, 2 - current = 1
+ // Testing to see how many scanners that is produced by getScanner,
starting with known number,
+ // 2 - current = 1
scan = new Scan();
scan.addFamily(fam2);
scan.addFamily(fam4);
- is = region.getScanner(scan);
- assertEquals(1, is.storeHeap.getHeap().size());
+ try (RegionScannerImpl is = region.getScanner(scan)) {
+ assertEquals(1, is.storeHeap.getHeap().size());
+ }
scan = new Scan();
- is = region.getScanner(scan);
- assertEquals(families.length - 1, is.storeHeap.getHeap().size());
+ try (RegionScannerImpl is = region.getScanner(scan)) {
+ assertEquals(families.length - 1, is.storeHeap.getHeap().size());
+ }
}
/**
@@ -3739,15 +3742,7 @@ public class TestHRegion {
fail("Got IOException during initHRegion, " + e.getMessage());
}
region.closed.set(true);
- try {
- region.getScanner(null);
- fail("Expected to get an exception during getScanner on a region that is
closed");
- } catch (NotServingRegionException e) {
- // this is the correct exception that is expected
- } catch (IOException e) {
- fail("Got wrong type of exception - should be a
NotServingRegionException, "
- + "but was an IOException: " + e.getMessage());
- }
+ assertThrows(NotServingRegionException.class, () ->
region.getScanner(null));
}
@Test
@@ -3783,30 +3778,30 @@ public class TestHRegion {
Scan scan = new Scan();
scan.addFamily(fam2);
scan.addFamily(fam4);
- InternalScanner is = region.getScanner(scan);
-
- List<Cell> res = null;
-
- // Result 1
- List<Cell> expected1 = new ArrayList<>();
- expected1.add(new KeyValue(row1, fam2, null, ts, KeyValue.Type.Put, null));
- expected1.add(new KeyValue(row1, fam4, null, ts, KeyValue.Type.Put, null));
-
- res = new ArrayList<>();
- is.next(res);
- for (int i = 0; i < res.size(); i++) {
- assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected1.get(i),
res.get(i)));
- }
+ try (InternalScanner is = region.getScanner(scan)) {
+ List<Cell> res = null;
+
+ // Result 1
+ List<Cell> expected1 = new ArrayList<>();
+ expected1.add(new KeyValue(row1, fam2, null, ts, KeyValue.Type.Put,
null));
+ expected1.add(new KeyValue(row1, fam4, null, ts, KeyValue.Type.Put,
null));
+
+ res = new ArrayList<>();
+ is.next(res);
+ for (int i = 0; i < res.size(); i++) {
+ assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected1.get(i),
res.get(i)));
+ }
- // Result 2
- List<Cell> expected2 = new ArrayList<>();
- expected2.add(new KeyValue(row2, fam2, null, ts, KeyValue.Type.Put, null));
- expected2.add(new KeyValue(row2, fam4, null, ts, KeyValue.Type.Put, null));
+ // Result 2
+ List<Cell> expected2 = new ArrayList<>();
+ expected2.add(new KeyValue(row2, fam2, null, ts, KeyValue.Type.Put,
null));
+ expected2.add(new KeyValue(row2, fam4, null, ts, KeyValue.Type.Put,
null));
- res = new ArrayList<>();
- is.next(res);
- for (int i = 0; i < res.size(); i++) {
- assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected2.get(i),
res.get(i)));
+ res = new ArrayList<>();
+ is.next(res);
+ for (int i = 0; i < res.size(); i++) {
+ assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected2.get(i),
res.get(i)));
+ }
}
}
@@ -3852,14 +3847,14 @@ public class TestHRegion {
scan.addColumn(fam1, qf1);
scan.readVersions(MAX_VERSIONS);
List<Cell> actual = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(actual);
+ assertEquals(false, hasNext);
- boolean hasNext = scanner.next(actual);
- assertEquals(false, hasNext);
-
- // Verify result
- for (int i = 0; i < expected.size(); i++) {
- assertEquals(expected.get(i), actual.get(i));
+ // Verify result
+ for (int i = 0; i < expected.size(); i++) {
+ assertEquals(expected.get(i), actual.get(i));
+ }
}
}
@@ -3909,14 +3904,14 @@ public class TestHRegion {
scan.addColumn(fam1, qf2);
scan.readVersions(MAX_VERSIONS);
List<Cell> actual = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(actual);
+ assertEquals(false, hasNext);
- boolean hasNext = scanner.next(actual);
- assertEquals(false, hasNext);
-
- // Verify result
- for (int i = 0; i < expected.size(); i++) {
- assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ // Verify result
+ for (int i = 0; i < expected.size(); i++) {
+ assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ }
}
}
@@ -3986,14 +3981,14 @@ public class TestHRegion {
int versions = 3;
scan.readVersions(versions);
List<Cell> actual = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
-
- boolean hasNext = scanner.next(actual);
- assertEquals(false, hasNext);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(actual);
+ assertEquals(false, hasNext);
- // Verify result
- for (int i = 0; i < expected.size(); i++) {
- assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ // Verify result
+ for (int i = 0; i < expected.size(); i++) {
+ assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ }
}
}
@@ -4041,14 +4036,14 @@ public class TestHRegion {
scan.addFamily(fam1);
scan.readVersions(MAX_VERSIONS);
List<Cell> actual = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
-
- boolean hasNext = scanner.next(actual);
- assertEquals(false, hasNext);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(actual);
+ assertEquals(false, hasNext);
- // Verify result
- for (int i = 0; i < expected.size(); i++) {
- assertEquals(expected.get(i), actual.get(i));
+ // Verify result
+ for (int i = 0; i < expected.size(); i++) {
+ assertEquals(expected.get(i), actual.get(i));
+ }
}
}
@@ -4096,14 +4091,14 @@ public class TestHRegion {
scan.addFamily(fam1);
scan.readVersions(MAX_VERSIONS);
List<Cell> actual = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(actual);
+ assertEquals(false, hasNext);
- boolean hasNext = scanner.next(actual);
- assertEquals(false, hasNext);
-
- // Verify result
- for (int i = 0; i < expected.size(); i++) {
- assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ // Verify result
+ for (int i = 0; i < expected.size(); i++) {
+ assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ }
}
}
@@ -4143,11 +4138,11 @@ public class TestHRegion {
Scan scan = new Scan().withStartRow(row3).withStopRow(row4);
scan.readAllVersions();
scan.addColumn(family, col1);
- InternalScanner s = region.getScanner(scan);
-
- List<Cell> results = new ArrayList<>();
- assertEquals(false, s.next(results));
- assertEquals(0, results.size());
+ try (InternalScanner s = region.getScanner(scan)) {
+ List<Cell> results = new ArrayList<>();
+ assertEquals(false, s.next(results));
+ assertEquals(0, results.size());
+ }
}
@Test
@@ -4212,14 +4207,14 @@ public class TestHRegion {
int versions = 3;
scan.readVersions(versions);
List<Cell> actual = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
-
- boolean hasNext = scanner.next(actual);
- assertEquals(false, hasNext);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(actual);
+ assertEquals(false, hasNext);
- // Verify result
- for (int i = 0; i < expected.size(); i++) {
- assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ // Verify result
+ for (int i = 0; i < expected.size(); i++) {
+ assertTrue(PrivateCellUtil.equalsIgnoreMvccVersion(expected.get(i),
actual.get(i)));
+ }
}
}
@@ -4267,22 +4262,22 @@ public class TestHRegion {
CompareOperator.NOT_EQUAL, filtered_val);
scan.setFilter(filter);
scan.setLoadColumnFamiliesOnDemand(true);
- InternalScanner s = region.getScanner(scan);
-
- List<Cell> results = new ArrayList<>();
- assertTrue(s.next(results));
- assertEquals(1, results.size());
- results.clear();
+ try (InternalScanner s = region.getScanner(scan)) {
+ List<Cell> results = new ArrayList<>();
+ assertTrue(s.next(results));
+ assertEquals(1, results.size());
+ results.clear();
- assertTrue(s.next(results));
- assertEquals(3, results.size());
- assertTrue("orderCheck", CellUtil.matchingFamily(results.get(0),
cf_alpha));
- assertTrue("orderCheck", CellUtil.matchingFamily(results.get(1),
cf_essential));
- assertTrue("orderCheck", CellUtil.matchingFamily(results.get(2),
cf_joined));
- results.clear();
+ assertTrue(s.next(results));
+ assertEquals(3, results.size());
+ assertTrue("orderCheck", CellUtil.matchingFamily(results.get(0),
cf_alpha));
+ assertTrue("orderCheck", CellUtil.matchingFamily(results.get(1),
cf_essential));
+ assertTrue("orderCheck", CellUtil.matchingFamily(results.get(2),
cf_joined));
+ results.clear();
- assertFalse(s.next(results));
- assertEquals(0, results.size());
+ assertFalse(s.next(results));
+ assertEquals(0, results.size());
+ }
}
/**
@@ -4325,55 +4320,55 @@ public class TestHRegion {
};
scan.setFilter(bogusFilter);
- InternalScanner s = region.getScanner(scan);
-
- // Our data looks like this:
- // r0: first:a, first:b, second:a, second:b
- // r1: first:a, first:b, second:a, second:b
- // r2: first:a, first:b, second:a, second:b
- // r3: first:a, first:b, second:a, second:b
- // r4: first:a, first:b, second:a, second:b
- // r5: first:a
- // r6: first:a
- // r7: first:a
- // r8: first:a
- // r9: first:a
-
- // But due to next's limit set to 3, we should get this:
- // r0: first:a, first:b, second:a
- // r0: second:b
- // r1: first:a, first:b, second:a
- // r1: second:b
- // r2: first:a, first:b, second:a
- // r2: second:b
- // r3: first:a, first:b, second:a
- // r3: second:b
- // r4: first:a, first:b, second:a
- // r4: second:b
- // r5: first:a
- // r6: first:a
- // r7: first:a
- // r8: first:a
- // r9: first:a
-
- List<Cell> results = new ArrayList<>();
- int index = 0;
- ScannerContext scannerContext =
ScannerContext.newBuilder().setBatchLimit(3).build();
- while (true) {
- boolean more = s.next(results, scannerContext);
- if ((index >> 1) < 5) {
- if (index % 2 == 0) {
- assertEquals(3, results.size());
+ try (InternalScanner s = region.getScanner(scan)) {
+ // Our data looks like this:
+ // r0: first:a, first:b, second:a, second:b
+ // r1: first:a, first:b, second:a, second:b
+ // r2: first:a, first:b, second:a, second:b
+ // r3: first:a, first:b, second:a, second:b
+ // r4: first:a, first:b, second:a, second:b
+ // r5: first:a
+ // r6: first:a
+ // r7: first:a
+ // r8: first:a
+ // r9: first:a
+
+ // But due to next's limit set to 3, we should get this:
+ // r0: first:a, first:b, second:a
+ // r0: second:b
+ // r1: first:a, first:b, second:a
+ // r1: second:b
+ // r2: first:a, first:b, second:a
+ // r2: second:b
+ // r3: first:a, first:b, second:a
+ // r3: second:b
+ // r4: first:a, first:b, second:a
+ // r4: second:b
+ // r5: first:a
+ // r6: first:a
+ // r7: first:a
+ // r8: first:a
+ // r9: first:a
+
+ List<Cell> results = new ArrayList<>();
+ int index = 0;
+ ScannerContext scannerContext =
ScannerContext.newBuilder().setBatchLimit(3).build();
+ while (true) {
+ boolean more = s.next(results, scannerContext);
+ if ((index >> 1) < 5) {
+ if (index % 2 == 0) {
+ assertEquals(3, results.size());
+ } else {
+ assertEquals(1, results.size());
+ }
} else {
assertEquals(1, results.size());
}
- } else {
- assertEquals(1, results.size());
- }
- results.clear();
- index++;
- if (!more) {
- break;
+ results.clear();
+ index++;
+ if (!more) {
+ break;
+ }
}
}
}
@@ -4382,15 +4377,15 @@ public class TestHRegion {
public void testScannerOperationId() throws IOException {
region = initHRegion(tableName, method, CONF, COLUMN_FAMILY_BYTES);
Scan scan = new Scan();
- RegionScanner scanner = region.getScanner(scan);
- assertNull(scanner.getOperationId());
- scanner.close();
+ try (RegionScanner scanner = region.getScanner(scan)) {
+ assertNull(scanner.getOperationId());
+ }
String operationId = "test_operation_id_0101";
scan = new Scan().setId(operationId);
- scanner = region.getScanner(scan);
- assertEquals(operationId, scanner.getOperationId());
- scanner.close();
+ try (RegionScanner scanner = region.getScanner(scan)) {
+ assertEquals(operationId, scanner.getOperationId());
+ }
HBaseTestingUtil.closeRegionAndWAL(this.region);
}
@@ -4458,12 +4453,14 @@ public class TestHRegion {
if (i != 0 && i % flushAndScanInterval == 0) {
res.clear();
- InternalScanner scanner = region.getScanner(scan);
- if (toggle) {
- flushThread.flush();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ if (toggle) {
+ flushThread.flush();
+ }
+ while (scanner.next(res)) {
+ // ignore
+ }
}
- while (scanner.next(res))
- ;
if (!toggle) {
flushThread.flush();
}
@@ -4883,13 +4880,14 @@ public class TestHRegion {
new BinaryComparator(Bytes.toBytes(0L))),
new SingleColumnValueFilter(family, qual1,
CompareOperator.LESS_OR_EQUAL,
new BinaryComparator(Bytes.toBytes(3L))))));
- InternalScanner scanner = region.getScanner(idxScan);
- List<Cell> res = new ArrayList<>();
+ try (InternalScanner scanner = region.getScanner(idxScan)) {
+ List<Cell> res = new ArrayList<>();
- while (scanner.next(res)) {
- // Ignore res value.
+ while (scanner.next(res)) {
+ // Ignore res value.
+ }
+ assertEquals(1L, res.size());
}
- assertEquals(1L, res.size());
}
//
////////////////////////////////////////////////////////////////////////////
@@ -5751,8 +5749,7 @@ public class TestHRegion {
Scan scan = new Scan();
for (int i = 0; i < families.length; i++)
scan.addFamily(families[i]);
- InternalScanner s = r.getScanner(scan);
- try {
+ try (InternalScanner s = r.getScanner(scan)) {
List<Cell> curVals = new ArrayList<>();
boolean first = true;
OUTER_LOOP: while (s.next(curVals)) {
@@ -5768,8 +5765,6 @@ public class TestHRegion {
}
}
}
- } finally {
- s.close();
}
}
@@ -5908,26 +5903,26 @@ public class TestHRegion {
Scan scan = new Scan().withStartRow(rowC);
scan.readVersions(5);
scan.setReversed(true);
- InternalScanner scanner = region.getScanner(scan);
- List<Cell> currRow = new ArrayList<>();
- boolean hasNext = scanner.next(currRow);
- assertEquals(2, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowC, 0, rowC.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowB, 0, rowB.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowA, 0, rowA.length));
- assertFalse(hasNext);
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ List<Cell> currRow = new ArrayList<>();
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(2, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowC, 0, rowC.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowB, 0, rowB.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowA, 0, rowA.length));
+ assertFalse(hasNext);
+ }
}
@Test
@@ -5961,25 +5956,25 @@ public class TestHRegion {
List<Cell> currRow = new ArrayList<>();
scan.setReversed(true);
scan.readVersions(5);
- InternalScanner scanner = region.getScanner(scan);
- boolean hasNext = scanner.next(currRow);
- assertEquals(2, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowC, 0, rowC.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowB, 0, rowB.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowA, 0, rowA.length));
- assertFalse(hasNext);
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(2, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowC, 0, rowC.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowB, 0, rowB.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowA, 0, rowA.length));
+ assertFalse(hasNext);
+ }
}
@Test
@@ -6010,25 +6005,25 @@ public class TestHRegion {
Scan scan = new Scan();
List<Cell> currRow = new ArrayList<>();
scan.setReversed(true);
- InternalScanner scanner = region.getScanner(scan);
- boolean hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowC, 0, rowC.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowB, 0, rowB.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowA, 0, rowA.length));
- assertFalse(hasNext);
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowC, 0, rowC.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowB, 0, rowB.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowA, 0, rowA.length));
+ assertFalse(hasNext);
+ }
}
@Test
@@ -6075,36 +6070,37 @@ public class TestHRegion {
scan.addColumn(families[0], col1);
scan.setReversed(true);
List<Cell> currRow = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
- boolean hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowD, 0, rowD.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowC, 0, rowC.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowB, 0, rowB.length));
- assertFalse(hasNext);
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowD, 0, rowD.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowC, 0, rowC.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowB, 0, rowB.length));
+ assertFalse(hasNext);
+ }
scan = new Scan().withStartRow(rowD).withStopRow(rowA);
scan.addColumn(families[0], col2);
scan.setReversed(true);
currRow.clear();
- scanner = region.getScanner(scan);
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowD, 0, rowD.length));
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowD, 0, rowD.length));
+ assertTrue(hasNext);
+ }
}
@Test
@@ -6153,36 +6149,37 @@ public class TestHRegion {
scan.addColumn(families[0], col1);
scan.setReversed(true);
List<Cell> currRow = new ArrayList<>();
- InternalScanner scanner = region.getScanner(scan);
- boolean hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowD, 0, rowD.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowC, 0, rowC.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowB, 0, rowB.length));
- assertFalse(hasNext);
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowD, 0, rowD.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowC, 0, rowC.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowB, 0, rowB.length));
+ assertFalse(hasNext);
+ }
scan = new Scan().withStartRow(rowD).withStopRow(rowA);
scan.addColumn(families[0], col2);
scan.setReversed(true);
currRow.clear();
- scanner = region.getScanner(scan);
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), rowD, 0, rowD.length));
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), rowD, 0, rowD.length));
+ assertTrue(hasNext);
+ }
}
@Test
@@ -6274,60 +6271,59 @@ public class TestHRegion {
scan.readVersions(5);
scan.setBatch(3);
scan.setReversed(true);
- InternalScanner scanner = region.getScanner(scan);
- List<Cell> currRow = new ArrayList<>();
- boolean hasNext = false;
- // 1. scan out "row4" (5 kvs), "row5" can't be scanned out since not
- // included in scan range
- // "row4" takes 2 next() calls since batch=3
- hasNext = scanner.next(currRow);
- assertEquals(3, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row4, 0, row4.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(2, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row4, 0, row4.length));
- assertTrue(hasNext);
- // 2. scan out "row3" (2 kv)
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(2, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row3, 0, row3.length));
- assertTrue(hasNext);
- // 3. scan out "row2" (4 kvs)
- // "row2" takes 2 next() calls since batch=3
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(3, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row2, 0, row2.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row2, 0, row2.length));
- assertTrue(hasNext);
- // 4. scan out "row1" (2 kv)
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(2, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row1, 0, row1.length));
- assertTrue(hasNext);
- // 5. scan out "row0" (1 kv)
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row0, 0, row0.length));
- assertFalse(hasNext);
-
- scanner.close();
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ List<Cell> currRow = new ArrayList<>();
+ boolean hasNext = false;
+ // 1. scan out "row4" (5 kvs), "row5" can't be scanned out since not
+ // included in scan range
+ // "row4" takes 2 next() calls since batch=3
+ hasNext = scanner.next(currRow);
+ assertEquals(3, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row4, 0, row4.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(2, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row4, 0, row4.length));
+ assertTrue(hasNext);
+ // 2. scan out "row3" (2 kv)
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(2, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row3, 0, row3.length));
+ assertTrue(hasNext);
+ // 3. scan out "row2" (4 kvs)
+ // "row2" takes 2 next() calls since batch=3
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(3, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row2, 0, row2.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row2, 0, row2.length));
+ assertTrue(hasNext);
+ // 4. scan out "row1" (2 kv)
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(2, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row1, 0, row1.length));
+ assertTrue(hasNext);
+ // 5. scan out "row0" (1 kv)
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row0, 0, row0.length));
+ assertFalse(hasNext);
+ }
}
@Test
@@ -6374,31 +6370,32 @@ public class TestHRegion {
Scan scan = new Scan().withStartRow(row4);
scan.setReversed(true);
scan.setBatch(10);
- InternalScanner scanner = region.getScanner(scan);
- List<Cell> currRow = new ArrayList<>();
- boolean hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row4, 0, row4.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row3, 0, row3.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row2, 0, row2.length));
- assertTrue(hasNext);
- currRow.clear();
- hasNext = scanner.next(currRow);
- assertEquals(1, currRow.size());
- assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
- currRow.get(0).getRowLength(), row1, 0, row1.length));
- assertFalse(hasNext);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ List<Cell> currRow = new ArrayList<>();
+ boolean hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row4, 0, row4.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row3, 0, row3.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row2, 0, row2.length));
+ assertTrue(hasNext);
+ currRow.clear();
+ hasNext = scanner.next(currRow);
+ assertEquals(1, currRow.size());
+ assertTrue(Bytes.equals(currRow.get(0).getRowArray(),
currRow.get(0).getRowOffset(),
+ currRow.get(0).getRowLength(), row1, 0, row1.length));
+ assertFalse(hasNext);
+ }
}
/**
@@ -6422,35 +6419,35 @@ public class TestHRegion {
Scan scan = new Scan().withStartRow(Bytes.toBytes("19998"));
scan.setReversed(true);
- InternalScanner scanner = region.getScanner(scan);
-
- // create one storefile contains many rows will be skipped
- // to check StoreFileScanner.seekToPreviousRow
- for (int i = 10000; i < 20000; i++) {
- Put p = new Put(Bytes.toBytes("" + i));
- p.addColumn(cf1, col, Bytes.toBytes("" + i));
- region.put(p);
- }
- region.flushcache(true, true, FlushLifeCycleTracker.DUMMY);
+ try (InternalScanner scanner = region.getScanner(scan)) {
+ // create one storefile contains many rows will be skipped
+ // to check StoreFileScanner.seekToPreviousRow
+ for (int i = 10000; i < 20000; i++) {
+ Put p = new Put(Bytes.toBytes("" + i));
+ p.addColumn(cf1, col, Bytes.toBytes("" + i));
+ region.put(p);
+ }
+ region.flushcache(true, true, FlushLifeCycleTracker.DUMMY);
+
+ // create one memstore contains many rows will be skipped
+ // to check MemStoreScanner.seekToPreviousRow
+ for (int i = 10000; i < 20000; i++) {
+ Put p = new Put(Bytes.toBytes("" + i));
+ p.addColumn(cf1, col, Bytes.toBytes("" + i));
+ region.put(p);
+ }
- // create one memstore contains many rows will be skipped
- // to check MemStoreScanner.seekToPreviousRow
- for (int i = 10000; i < 20000; i++) {
- Put p = new Put(Bytes.toBytes("" + i));
- p.addColumn(cf1, col, Bytes.toBytes("" + i));
- region.put(p);
+ List<Cell> currRow = new ArrayList<>();
+ boolean hasNext;
+ do {
+ hasNext = scanner.next(currRow);
+ } while (hasNext);
+ assertEquals(2, currRow.size());
+ assertEquals("19998", Bytes.toString(currRow.get(0).getRowArray(),
+ currRow.get(0).getRowOffset(), currRow.get(0).getRowLength()));
+ assertEquals("19997", Bytes.toString(currRow.get(1).getRowArray(),
+ currRow.get(1).getRowOffset(), currRow.get(1).getRowLength()));
}
-
- List<Cell> currRow = new ArrayList<>();
- boolean hasNext;
- do {
- hasNext = scanner.next(currRow);
- } while (hasNext);
- assertEquals(2, currRow.size());
- assertEquals("19998", Bytes.toString(currRow.get(0).getRowArray(),
- currRow.get(0).getRowOffset(), currRow.get(0).getRowLength()));
- assertEquals("19997", Bytes.toString(currRow.get(1).getRowArray(),
- currRow.get(1).getRowOffset(), currRow.get(1).getRowLength()));
}
@Test
@@ -6469,37 +6466,38 @@ public class TestHRegion {
// create a reverse scan
Scan scan = new Scan().withStartRow(Bytes.toBytes("19996"));
scan.setReversed(true);
- RegionScannerImpl scanner = region.getScanner(scan);
-
- // flush the cache. This will reset the store scanner
- region.flushcache(true, true, FlushLifeCycleTracker.DUMMY);
-
- // create one memstore contains many rows will be skipped
- // to check MemStoreScanner.seekToPreviousRow
- for (int i = 10000; i < 20000; i++) {
- Put p = new Put(Bytes.toBytes("" + i));
- p.addColumn(cf1, col, Bytes.toBytes("" + i));
- region.put(p);
- }
- List<Cell> currRow = new ArrayList<>();
- boolean hasNext;
- boolean assertDone = false;
- do {
- hasNext = scanner.next(currRow);
- // With HBASE-15871, after the scanner is reset the memstore scanner
should not be
- // added here
- if (!assertDone) {
- StoreScanner current = (StoreScanner)
(scanner.storeHeap).getCurrentForTesting();
- List<KeyValueScanner> scanners = current.getAllScannersForTesting();
- assertEquals("There should be only one scanner the store file
scanner", 1, scanners.size());
- assertDone = true;
+ try (RegionScannerImpl scanner = region.getScanner(scan)) {
+ // flush the cache. This will reset the store scanner
+ region.flushcache(true, true, FlushLifeCycleTracker.DUMMY);
+
+ // create one memstore contains many rows will be skipped
+ // to check MemStoreScanner.seekToPreviousRow
+ for (int i = 10000; i < 20000; i++) {
+ Put p = new Put(Bytes.toBytes("" + i));
+ p.addColumn(cf1, col, Bytes.toBytes("" + i));
+ region.put(p);
}
- } while (hasNext);
- assertEquals(2, currRow.size());
- assertEquals("19996", Bytes.toString(currRow.get(0).getRowArray(),
- currRow.get(0).getRowOffset(), currRow.get(0).getRowLength()));
- assertEquals("19995", Bytes.toString(currRow.get(1).getRowArray(),
- currRow.get(1).getRowOffset(), currRow.get(1).getRowLength()));
+ List<Cell> currRow = new ArrayList<>();
+ boolean hasNext;
+ boolean assertDone = false;
+ do {
+ hasNext = scanner.next(currRow);
+ // With HBASE-15871, after the scanner is reset the memstore scanner
should not be
+ // added here
+ if (!assertDone) {
+ StoreScanner current = (StoreScanner)
(scanner.storeHeap).getCurrentForTesting();
+ List<KeyValueScanner> scanners = current.getAllScannersForTesting();
+ assertEquals("There should be only one scanner the store file
scanner", 1,
+ scanners.size());
+ assertDone = true;
+ }
+ } while (hasNext);
+ assertEquals(2, currRow.size());
+ assertEquals("19996", Bytes.toString(currRow.get(0).getRowArray(),
+ currRow.get(0).getRowOffset(), currRow.get(0).getRowLength()));
+ assertEquals("19995", Bytes.toString(currRow.get(1).getRowArray(),
+ currRow.get(1).getRowOffset(), currRow.get(1).getRowLength()));
+ }
}
@Test
@@ -6520,25 +6518,25 @@ public class TestHRegion {
// Create a reverse scan
Scan scan = new Scan().withStartRow(Bytes.toBytes("199996"));
scan.setReversed(true);
- RegionScannerImpl scanner = region.getScanner(scan);
+ try (RegionScannerImpl scanner = region.getScanner(scan)) {
+ // Put a lot of cells that have sequenceIDs grater than the readPt of
the reverse scan
+ for (int i = 100000; i < 200000; i++) {
+ Put p = new Put(Bytes.toBytes("" + i));
+ p.addColumn(cf1, col, Bytes.toBytes("" + i));
+ region.put(p);
+ }
+ List<Cell> currRow = new ArrayList<>();
+ boolean hasNext;
+ do {
+ hasNext = scanner.next(currRow);
+ } while (hasNext);
- // Put a lot of cells that have sequenceIDs grater than the readPt of the
reverse scan
- for (int i = 100000; i < 200000; i++) {
- Put p = new Put(Bytes.toBytes("" + i));
- p.addColumn(cf1, col, Bytes.toBytes("" + i));
- region.put(p);
+ assertEquals(2, currRow.size());
+ assertEquals("199996", Bytes.toString(currRow.get(0).getRowArray(),
+ currRow.get(0).getRowOffset(), currRow.get(0).getRowLength()));
+ assertEquals("199995", Bytes.toString(currRow.get(1).getRowArray(),
+ currRow.get(1).getRowOffset(), currRow.get(1).getRowLength()));
}
- List<Cell> currRow = new ArrayList<>();
- boolean hasNext;
- do {
- hasNext = scanner.next(currRow);
- } while (hasNext);
-
- assertEquals(2, currRow.size());
- assertEquals("199996", Bytes.toString(currRow.get(0).getRowArray(),
- currRow.get(0).getRowOffset(), currRow.get(0).getRowLength()));
- assertEquals("199995", Bytes.toString(currRow.get(1).getRowArray(),
- currRow.get(1).getRowOffset(), currRow.get(1).getRowLength()));
}
@Test
@@ -6987,11 +6985,11 @@ public class TestHRegion {
Scan s = new Scan().withStartRow(row);
ScannerContext.Builder contextBuilder = ScannerContext.newBuilder(true);
ScannerContext scannerContext = contextBuilder.build();
- RegionScanner scanner = region.getScanner(s);
- List<Cell> kvs = new ArrayList<>();
- scanner.next(kvs, scannerContext);
- assertEquals(expectCellSize, kvs.size());
- scanner.close();
+ try (RegionScanner scanner = region.getScanner(s)) {
+ List<Cell> kvs = new ArrayList<>();
+ scanner.next(kvs, scannerContext);
+ assertEquals(expectCellSize, kvs.size());
+ }
}
@Test
@@ -7615,7 +7613,7 @@ public class TestHRegion {
holder.start();
latch.await();
- region.close();
+ HBaseTestingUtil.closeRegionAndWAL(region);
region = null;
holder.join();
