From commits-return-64755-archive-asf-public=cust-asf.ponee.io@hbase.apache.org Mon Jan 8 16:31:21 2018 Return-Path: X-Original-To: archive-asf-public@eu.ponee.io Delivered-To: archive-asf-public@eu.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by mx-eu-01.ponee.io (Postfix) with ESMTP id 7A2AB18072F for ; Mon, 8 Jan 2018 16:31:21 +0100 (CET) Received: by cust-asf.ponee.io (Postfix) id 69855160C1E; Mon, 8 Jan 2018 15:31:21 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id DDEFB160C2C for ; Mon, 8 Jan 2018 16:31:18 +0100 (CET) Received: (qmail 12190 invoked by uid 500); 8 Jan 2018 15:31:18 -0000 Mailing-List: contact commits-help@hbase.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@hbase.apache.org Delivered-To: mailing list commits@hbase.apache.org Received: (qmail 12177 invoked by uid 99); 8 Jan 2018 15:31:18 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 08 Jan 2018 15:31:18 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id B9B77DFFDA; Mon, 8 Jan 2018 15:31:16 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: git-site-role@apache.org To: commits@hbase.apache.org Date: Mon, 08 Jan 2018 15:31:17 -0000 Message-Id: <005a0d4086c0476e8a7ad43adbfa8921@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [02/11] hbase-site git commit: Published site at . http://git-wip-us.apache.org/repos/asf/hbase-site/blob/123d826c/testdevapidocs/src-html/org/apache/hadoop/hbase/filter/TestFilter.html ---------------------------------------------------------------------- diff --git a/testdevapidocs/src-html/org/apache/hadoop/hbase/filter/TestFilter.html b/testdevapidocs/src-html/org/apache/hadoop/hbase/filter/TestFilter.html index a6c7150..e93a01d 100644 --- a/testdevapidocs/src-html/org/apache/hadoop/hbase/filter/TestFilter.html +++ b/testdevapidocs/src-html/org/apache/hadoop/hbase/filter/TestFilter.html @@ -150,2012 +150,2072 @@ 142 @Before 143 public void setUp() throws Exception { 144 HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("TestFilter")); -145 htd.addFamily(new HColumnDescriptor(FAMILIES[0])); -146 htd.addFamily(new HColumnDescriptor(FAMILIES[1])); -147 htd.addFamily(new HColumnDescriptor(FAMILIES_1[0])); -148 htd.addFamily(new HColumnDescriptor(FAMILIES_1[1])); -149 htd.addFamily(new HColumnDescriptor(NEW_FAMILIES[0])); -150 htd.addFamily(new HColumnDescriptor(NEW_FAMILIES[1])); -151 HRegionInfo info = new HRegionInfo(htd.getTableName(), null, null, false); -152 this.region = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), -153 TEST_UTIL.getConfiguration(), htd); -154 -155 // Insert first half -156 for(byte [] ROW : ROWS_ONE) { -157 Put p = new Put(ROW); -158 p.setDurability(Durability.SKIP_WAL); -159 for(byte [] QUALIFIER : QUALIFIERS_ONE) { -160 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[0]); -161 } -162 this.region.put(p); -163 } -164 for(byte [] ROW : ROWS_TWO) { -165 Put p = new Put(ROW); -166 p.setDurability(Durability.SKIP_WAL); -167 for(byte [] QUALIFIER : QUALIFIERS_TWO) { -168 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[1]); -169 } -170 this.region.put(p); -171 } -172 -173 // Flush -174 this.region.flush(true); -175 -176 // Insert second half (reverse families) -177 for(byte [] ROW : ROWS_ONE) { -178 Put p = new Put(ROW); -179 p.setDurability(Durability.SKIP_WAL); -180 for(byte [] QUALIFIER : QUALIFIERS_ONE) { -181 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[0]); -182 } -183 this.region.put(p); -184 } -185 for(byte [] ROW : ROWS_TWO) { -186 Put p = new Put(ROW); -187 p.setDurability(Durability.SKIP_WAL); -188 for(byte [] QUALIFIER : QUALIFIERS_TWO) { -189 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[1]); -190 } -191 this.region.put(p); -192 } -193 -194 // Delete the second qualifier from all rows and families -195 for(byte [] ROW : ROWS_ONE) { -196 Delete d = new Delete(ROW); -197 d.addColumns(FAMILIES[0], QUALIFIERS_ONE[1]); -198 d.addColumns(FAMILIES[1], QUALIFIERS_ONE[1]); -199 this.region.delete(d); -200 } -201 for(byte [] ROW : ROWS_TWO) { -202 Delete d = new Delete(ROW); -203 d.addColumns(FAMILIES[0], QUALIFIERS_TWO[1]); -204 d.addColumns(FAMILIES[1], QUALIFIERS_TWO[1]); -205 this.region.delete(d); -206 } -207 colsPerRow -= 2; -208 -209 // Delete the second rows from both groups, one column at a time -210 for(byte [] QUALIFIER : QUALIFIERS_ONE) { -211 Delete d = new Delete(ROWS_ONE[1]); -212 d.addColumns(FAMILIES[0], QUALIFIER); -213 d.addColumns(FAMILIES[1], QUALIFIER); -214 this.region.delete(d); -215 } -216 for(byte [] QUALIFIER : QUALIFIERS_TWO) { -217 Delete d = new Delete(ROWS_TWO[1]); -218 d.addColumns(FAMILIES[0], QUALIFIER); -219 d.addColumns(FAMILIES[1], QUALIFIER); -220 this.region.delete(d); -221 } -222 numRows -= 2; -223 } -224 -225 @After -226 public void tearDown() throws Exception { -227 HBaseTestingUtility.closeRegionAndWAL(region); -228 } -229 -230 @Test -231 public void testRegionScannerReseek() throws Exception { -232 // create new rows and column family to show how reseek works.. -233 for (byte[] ROW : ROWS_THREE) { -234 Put p = new Put(ROW); -235 p.setDurability(Durability.SKIP_WAL); -236 for (byte[] QUALIFIER : QUALIFIERS_THREE) { -237 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[0]); -238 -239 } -240 this.region.put(p); -241 } -242 for (byte[] ROW : ROWS_FOUR) { -243 Put p = new Put(ROW); -244 p.setDurability(Durability.SKIP_WAL); -245 for (byte[] QUALIFIER : QUALIFIERS_FOUR) { -246 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[1]); -247 } -248 this.region.put(p); -249 } -250 // Flush -251 this.region.flush(true); -252 -253 // Insert second half (reverse families) -254 for (byte[] ROW : ROWS_THREE) { -255 Put p = new Put(ROW); -256 p.setDurability(Durability.SKIP_WAL); -257 for (byte[] QUALIFIER : QUALIFIERS_THREE) { -258 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[0]); -259 } -260 this.region.put(p); -261 } -262 for (byte[] ROW : ROWS_FOUR) { -263 Put p = new Put(ROW); -264 p.setDurability(Durability.SKIP_WAL); -265 for (byte[] QUALIFIER : QUALIFIERS_FOUR) { -266 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[1]); -267 } -268 this.region.put(p); -269 } -270 -271 Scan s = new Scan(); -272 // set a start row -273 s.setStartRow(ROWS_FOUR[1]); -274 RegionScanner scanner = region.getScanner(s); -275 -276 // reseek to row three. -277 scanner.reseek(ROWS_THREE[1]); -278 List<Cell> results = new ArrayList<>(); -279 -280 // the results should belong to ROWS_THREE[1] -281 scanner.next(results); -282 for (Cell keyValue : results) { -283 assertTrue("The rows with ROWS_TWO as row key should be appearing.", -284 CellUtil.matchingRows(keyValue, ROWS_THREE[1])); -285 } -286 // again try to reseek to a value before ROWS_THREE[1] -287 scanner.reseek(ROWS_ONE[1]); -288 results = new ArrayList<>(); -289 // This time no seek would have been done to ROWS_ONE[1] -290 scanner.next(results); -291 for (Cell keyValue : results) { -292 assertFalse("Cannot rewind back to a value less than previous reseek.", -293 Bytes.toString(CellUtil.cloneRow(keyValue)).contains("testRowOne")); -294 } -295 } -296 -297 @Test -298 public void testNoFilter() throws Exception { -299 // No filter -300 long expectedRows = this.numRows; -301 long expectedKeys = this.colsPerRow; -302 -303 // Both families -304 Scan s = new Scan(); -305 verifyScan(s, expectedRows, expectedKeys); -306 -307 // One family -308 s = new Scan(); -309 s.addFamily(FAMILIES[0]); -310 verifyScan(s, expectedRows, expectedKeys/2); -311 } -312 -313 @Test -314 public void testPrefixFilter() throws Exception { -315 // Grab rows from group one (half of total) -316 long expectedRows = this.numRows / 2; -317 long expectedKeys = this.colsPerRow; -318 Scan s = new Scan(); -319 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne"))); -320 verifyScan(s, expectedRows, expectedKeys); -321 } -322 -323 @Test -324 public void testPrefixFilterWithReverseScan() throws Exception { -325 // Grab rows from group one (half of total) -326 long expectedRows = this.numRows / 2; -327 long expectedKeys = this.colsPerRow; -328 Scan s = new Scan(); -329 s.setReversed(true); -330 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne"))); -331 verifyScan(s, expectedRows, expectedKeys); -332 } -333 -334 @Test -335 public void testPageFilter() throws Exception { -336 -337 // KVs in first 6 rows -338 KeyValue [] expectedKVs = { -339 // testRowOne-0 -340 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), -341 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), -342 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), -343 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), -344 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), -345 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), -346 // testRowOne-2 -347 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), -348 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), -349 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), -350 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), -351 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), -352 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), -353 // testRowOne-3 -354 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), -355 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), -356 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), -357 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), -358 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), -359 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), -360 // testRowTwo-0 -361 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), -362 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), -363 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), -364 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), -365 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), -366 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), -367 // testRowTwo-2 -368 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), -369 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), -370 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), -371 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), -372 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), -373 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), -374 // testRowTwo-3 -375 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), -376 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), -377 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), -378 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), -379 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), -380 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]) -381 }; -382 -383 // Grab all 6 rows -384 long expectedRows = 6; -385 long expectedKeys = this.colsPerRow; -386 Scan s = new Scan(); -387 s.setFilter(new PageFilter(expectedRows)); -388 verifyScan(s, expectedRows, expectedKeys); -389 s.setFilter(new PageFilter(expectedRows)); -390 verifyScanFull(s, expectedKVs); -391 -392 // Grab first 4 rows (6 cols per row) -393 expectedRows = 4; -394 expectedKeys = this.colsPerRow; -395 s = new Scan(); -396 s.setFilter(new PageFilter(expectedRows)); -397 verifyScan(s, expectedRows, expectedKeys); -398 s.setFilter(new PageFilter(expectedRows)); -399 verifyScanFull(s, Arrays.copyOf(expectedKVs, 24)); -400 -401 // Grab first 2 rows -402 expectedRows = 2; -403 expectedKeys = this.colsPerRow; -404 s = new Scan(); -405 s.setFilter(new PageFilter(expectedRows)); -406 verifyScan(s, expectedRows, expectedKeys); -407 s.setFilter(new PageFilter(expectedRows)); -408 verifyScanFull(s, Arrays.copyOf(expectedKVs, 12)); -409 -410 // Grab first row -411 expectedRows = 1; -412 expectedKeys = this.colsPerRow; -413 s = new Scan(); -414 s.setFilter(new PageFilter(expectedRows)); -415 verifyScan(s, expectedRows, expectedKeys); -416 s.setFilter(new PageFilter(expectedRows)); -417 verifyScanFull(s, Arrays.copyOf(expectedKVs, 6)); -418 -419 } -420 -421 @Test -422 public void testPageFilterWithReverseScan() throws Exception { -423 // KVs in first 6 rows -424 KeyValue[] expectedKVs = { -425 // testRowOne-0 -426 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), -427 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), -428 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), -429 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), -430 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), -431 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), -432 // testRowOne-2 -433 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), -434 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), -435 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), -436 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), -437 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), -438 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), -439 // testRowOne-3 -440 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), -441 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), -442 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), -443 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), -444 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), -445 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), -446 // testRowTwo-0 -447 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), -448 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), -449 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), -450 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), -451 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), -452 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), -453 // testRowTwo-2 -454 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), -455 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), -456 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), -457 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), -458 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), -459 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), -460 // testRowTwo-3 -461 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), -462 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), -463 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), -464 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), -465 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), -466 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]) }; -467 -468 // Grab all 6 rows -469 long expectedRows = 6; -470 long expectedKeys = this.colsPerRow; -471 Scan s = new Scan(); -472 s.setReversed(true); -473 s.setFilter(new PageFilter(expectedRows)); -474 verifyScan(s, expectedRows, expectedKeys); -475 -476 // Grab first 4 rows (6 cols per row) -477 expectedRows = 4; -478 expectedKeys = this.colsPerRow; -479 s = new Scan(); -480 s.setReversed(true); -481 s.setFilter(new PageFilter(expectedRows)); -482 verifyScan(s, expectedRows, expectedKeys); -483 -484 // Grab first 2 rows -485 expectedRows = 2; -486 expectedKeys = this.colsPerRow; -487 s = new Scan(); -488 s.setReversed(true); -489 s.setFilter(new PageFilter(expectedRows)); -490 verifyScan(s, expectedRows, expectedKeys); -491 -492 // Grab first row -493 expectedRows = 1; -494 expectedKeys = this.colsPerRow; -495 s = new Scan(); -496 s.setReversed(true); -497 s.setFilter(new PageFilter(expectedRows)); -498 verifyScan(s, expectedRows, expectedKeys); -499 } -500 -501 @Test -502 public void testWhileMatchFilterWithFilterRowWithReverseScan() -503 throws Exception { -504 final int pageSize = 4; -505 -506 Scan s = new Scan(); -507 s.setReversed(true); -508 WhileMatchFilter filter = new WhileMatchFilter(new PageFilter(pageSize)); -509 s.setFilter(filter); -510 -511 InternalScanner scanner = this.region.getScanner(s); -512 int scannerCounter = 0; -513 while (true) { -514 boolean isMoreResults = scanner.next(new ArrayList<>()); -515 scannerCounter++; -516 -517 if (scannerCounter >= pageSize) { -518 Assert.assertTrue( -519 "The WhileMatchFilter should now filter all remaining", -520 filter.filterAllRemaining()); -521 } -522 if (!isMoreResults) { -523 break; -524 } -525 } -526 scanner.close(); -527 Assert.assertEquals("The page filter returned more rows than expected", -528 pageSize, scannerCounter); -529 } -530 -531 @Test -532 public void testWhileMatchFilterWithFilterRowKeyWithReverseScan() -533 throws Exception { -534 Scan s = new Scan(); -535 String prefix = "testRowOne"; -536 WhileMatchFilter filter = new WhileMatchFilter(new PrefixFilter( -537 Bytes.toBytes(prefix))); -538 s.setFilter(filter); -539 s.setReversed(true); -540 -541 InternalScanner scanner = this.region.getScanner(s); -542 while (true) { -543 ArrayList<Cell> values = new ArrayList<>(); -544 boolean isMoreResults = scanner.next(values); -545 if (!isMoreResults -546 || !Bytes.toString(CellUtil.cloneRow(values.get(0))).startsWith(prefix)) { -547 Assert.assertTrue( -548 "The WhileMatchFilter should now filter all remaining", -549 filter.filterAllRemaining()); -550 } -551 if (!isMoreResults) { -552 break; -553 } -554 } -555 scanner.close(); -556 } -557 -558 /** -559 * Tests the the {@link WhileMatchFilter} works in combination with a -560 * {@link Filter} that uses the -561 * {@link Filter#filterRow()} method. -562 * -563 * See HBASE-2258. -564 * -565 * @throws Exception -566 */ -567 @Test -568 public void testWhileMatchFilterWithFilterRow() throws Exception { -569 final int pageSize = 4; -570 -571 Scan s = new Scan(); -572 WhileMatchFilter filter = new WhileMatchFilter(new PageFilter(pageSize)); -573 s.setFilter(filter); -574 -575 InternalScanner scanner = this.region.getScanner(s); -576 int scannerCounter = 0; -577 while (true) { -578 boolean isMoreResults = scanner.next(new ArrayList<>()); -579 scannerCounter++; -580 -581 if (scannerCounter >= pageSize) { -582 assertTrue("The WhileMatchFilter should now filter all remaining", filter.filterAllRemaining()); -583 } -584 if (!isMoreResults) { -585 break; -586 } -587 } -588 assertEquals("The page filter returned more rows than expected", pageSize, scannerCounter); -589 } -590 +145 HColumnDescriptor family0 = new HColumnDescriptor(FAMILIES[0]).setVersions(100, 100); +146 htd.addFamily(family0); +147 htd.addFamily(new HColumnDescriptor(FAMILIES[1])); +148 htd.addFamily(new HColumnDescriptor(FAMILIES_1[0])); +149 htd.addFamily(new HColumnDescriptor(FAMILIES_1[1])); +150 htd.addFamily(new HColumnDescriptor(NEW_FAMILIES[0])); +151 htd.addFamily(new HColumnDescriptor(NEW_FAMILIES[1])); +152 HRegionInfo info = new HRegionInfo(htd.getTableName(), null, null, false); +153 this.region = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), +154 TEST_UTIL.getConfiguration(), htd); +155 +156 // Insert first half +157 for(byte [] ROW : ROWS_ONE) { +158 Put p = new Put(ROW); +159 p.setDurability(Durability.SKIP_WAL); +160 for(byte [] QUALIFIER : QUALIFIERS_ONE) { +161 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[0]); +162 } +163 this.region.put(p); +164 } +165 for(byte [] ROW : ROWS_TWO) { +166 Put p = new Put(ROW); +167 p.setDurability(Durability.SKIP_WAL); +168 for(byte [] QUALIFIER : QUALIFIERS_TWO) { +169 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[1]); +170 } +171 this.region.put(p); +172 } +173 +174 // Flush +175 this.region.flush(true); +176 +177 // Insert second half (reverse families) +178 for(byte [] ROW : ROWS_ONE) { +179 Put p = new Put(ROW); +180 p.setDurability(Durability.SKIP_WAL); +181 for(byte [] QUALIFIER : QUALIFIERS_ONE) { +182 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[0]); +183 } +184 this.region.put(p); +185 } +186 for(byte [] ROW : ROWS_TWO) { +187 Put p = new Put(ROW); +188 p.setDurability(Durability.SKIP_WAL); +189 for(byte [] QUALIFIER : QUALIFIERS_TWO) { +190 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[1]); +191 } +192 this.region.put(p); +193 } +194 +195 // Delete the second qualifier from all rows and families +196 for(byte [] ROW : ROWS_ONE) { +197 Delete d = new Delete(ROW); +198 d.addColumns(FAMILIES[0], QUALIFIERS_ONE[1]); +199 d.addColumns(FAMILIES[1], QUALIFIERS_ONE[1]); +200 this.region.delete(d); +201 } +202 for(byte [] ROW : ROWS_TWO) { +203 Delete d = new Delete(ROW); +204 d.addColumns(FAMILIES[0], QUALIFIERS_TWO[1]); +205 d.addColumns(FAMILIES[1], QUALIFIERS_TWO[1]); +206 this.region.delete(d); +207 } +208 colsPerRow -= 2; +209 +210 // Delete the second rows from both groups, one column at a time +211 for(byte [] QUALIFIER : QUALIFIERS_ONE) { +212 Delete d = new Delete(ROWS_ONE[1]); +213 d.addColumns(FAMILIES[0], QUALIFIER); +214 d.addColumns(FAMILIES[1], QUALIFIER); +215 this.region.delete(d); +216 } +217 for(byte [] QUALIFIER : QUALIFIERS_TWO) { +218 Delete d = new Delete(ROWS_TWO[1]); +219 d.addColumns(FAMILIES[0], QUALIFIER); +220 d.addColumns(FAMILIES[1], QUALIFIER); +221 this.region.delete(d); +222 } +223 numRows -= 2; +224 } +225 +226 @After +227 public void tearDown() throws Exception { +228 HBaseTestingUtility.closeRegionAndWAL(region); +229 } +230 +231 @Test +232 public void testRegionScannerReseek() throws Exception { +233 // create new rows and column family to show how reseek works.. +234 for (byte[] ROW : ROWS_THREE) { +235 Put p = new Put(ROW); +236 p.setDurability(Durability.SKIP_WAL); +237 for (byte[] QUALIFIER : QUALIFIERS_THREE) { +238 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[0]); +239 +240 } +241 this.region.put(p); +242 } +243 for (byte[] ROW : ROWS_FOUR) { +244 Put p = new Put(ROW); +245 p.setDurability(Durability.SKIP_WAL); +246 for (byte[] QUALIFIER : QUALIFIERS_FOUR) { +247 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[1]); +248 } +249 this.region.put(p); +250 } +251 // Flush +252 this.region.flush(true); +253 +254 // Insert second half (reverse families) +255 for (byte[] ROW : ROWS_THREE) { +256 Put p = new Put(ROW); +257 p.setDurability(Durability.SKIP_WAL); +258 for (byte[] QUALIFIER : QUALIFIERS_THREE) { +259 p.addColumn(FAMILIES[1], QUALIFIER, VALUES[0]); +260 } +261 this.region.put(p); +262 } +263 for (byte[] ROW : ROWS_FOUR) { +264 Put p = new Put(ROW); +265 p.setDurability(Durability.SKIP_WAL); +266 for (byte[] QUALIFIER : QUALIFIERS_FOUR) { +267 p.addColumn(FAMILIES[0], QUALIFIER, VALUES[1]); +268 } +269 this.region.put(p); +270 } +271 +272 Scan s = new Scan(); +273 // set a start row +274 s.setStartRow(ROWS_FOUR[1]); +275 RegionScanner scanner = region.getScanner(s); +276 +277 // reseek to row three. +278 scanner.reseek(ROWS_THREE[1]); +279 List<Cell> results = new ArrayList<>(); +280 +281 // the results should belong to ROWS_THREE[1] +282 scanner.next(results); +283 for (Cell keyValue : results) { +284 assertTrue("The rows with ROWS_TWO as row key should be appearing.", +285 CellUtil.matchingRows(keyValue, ROWS_THREE[1])); +286 } +287 // again try to reseek to a value before ROWS_THREE[1] +288 scanner.reseek(ROWS_ONE[1]); +289 results = new ArrayList<>(); +290 // This time no seek would have been done to ROWS_ONE[1] +291 scanner.next(results); +292 for (Cell keyValue : results) { +293 assertFalse("Cannot rewind back to a value less than previous reseek.", +294 Bytes.toString(CellUtil.cloneRow(keyValue)).contains("testRowOne")); +295 } +296 } +297 +298 @Test +299 public void testNoFilter() throws Exception { +300 // No filter +301 long expectedRows = this.numRows; +302 long expectedKeys = this.colsPerRow; +303 +304 // Both families +305 Scan s = new Scan(); +306 verifyScan(s, expectedRows, expectedKeys); +307 +308 // One family +309 s = new Scan(); +310 s.addFamily(FAMILIES[0]); +311 verifyScan(s, expectedRows, expectedKeys/2); +312 } +313 +314 @Test +315 public void testPrefixFilter() throws Exception { +316 // Grab rows from group one (half of total) +317 long expectedRows = this.numRows / 2; +318 long expectedKeys = this.colsPerRow; +319 Scan s = new Scan(); +320 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne"))); +321 verifyScan(s, expectedRows, expectedKeys); +322 } +323 +324 @Test +325 public void testPrefixFilterWithReverseScan() throws Exception { +326 // Grab rows from group one (half of total) +327 long expectedRows = this.numRows / 2; +328 long expectedKeys = this.colsPerRow; +329 Scan s = new Scan(); +330 s.setReversed(true); +331 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne"))); +332 verifyScan(s, expectedRows, expectedKeys); +333 } +334 +335 @Test +336 public void testPageFilter() throws Exception { +337 +338 // KVs in first 6 rows +339 KeyValue [] expectedKVs = { +340 // testRowOne-0 +341 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), +342 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), +343 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), +344 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), +345 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), +346 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), +347 // testRowOne-2 +348 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), +349 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), +350 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), +351 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), +352 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), +353 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), +354 // testRowOne-3 +355 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), +356 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), +357 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), +358 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), +359 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), +360 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), +361 // testRowTwo-0 +362 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), +363 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), +364 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), +365 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), +366 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), +367 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), +368 // testRowTwo-2 +369 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), +370 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), +371 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), +372 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), +373 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), +374 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), +375 // testRowTwo-3 +376 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), +377 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), +378 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), +379 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), +380 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), +381 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]) +382 }; +383 +384 // Grab all 6 rows +385 long expectedRows = 6; +386 long expectedKeys = this.colsPerRow; +387 Scan s = new Scan(); +388 s.setFilter(new PageFilter(expectedRows)); +389 verifyScan(s, expectedRows, expectedKeys); +390 s.setFilter(new PageFilter(expectedRows)); +391 verifyScanFull(s, expectedKVs); +392 +393 // Grab first 4 rows (6 cols per row) +394 expectedRows = 4; +395 expectedKeys = this.colsPerRow; +396 s = new Scan(); +397 s.setFilter(new PageFilter(expectedRows)); +398 verifyScan(s, expectedRows, expectedKeys); +399 s.setFilter(new PageFilter(expectedRows)); +400 verifyScanFull(s, Arrays.copyOf(expectedKVs, 24)); +401 +402 // Grab first 2 rows +403 expectedRows = 2; +404 expectedKeys = this.colsPerRow; +405 s = new Scan(); +406 s.setFilter(new PageFilter(expectedRows)); +407 verifyScan(s, expectedRows, expectedKeys); +408 s.setFilter(new PageFilter(expectedRows)); +409 verifyScanFull(s, Arrays.copyOf(expectedKVs, 12)); +410 +411 // Grab first row +412 expectedRows = 1; +413 expectedKeys = this.colsPerRow; +414 s = new Scan(); +415 s.setFilter(new PageFilter(expectedRows)); +416 verifyScan(s, expectedRows, expectedKeys); +417 s.setFilter(new PageFilter(expectedRows)); +418 verifyScanFull(s, Arrays.copyOf(expectedKVs, 6)); +419 +420 } +421 +422 @Test +423 public void testPageFilterWithReverseScan() throws Exception { +424 // KVs in first 6 rows +425 KeyValue[] expectedKVs = { +426 // testRowOne-0 +427 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), +428 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), +429 new KeyValue(ROWS_ONE[0], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), +430 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), +431 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), +432 new KeyValue(ROWS_ONE[0], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), +433 // testRowOne-2 +434 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), +435 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), +436 new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), +437 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), +438 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), +439 new KeyValue(ROWS_ONE[2], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), +440 // testRowOne-3 +441 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[0], VALUES[0]), +442 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]), +443 new KeyValue(ROWS_ONE[3], FAMILIES[0], QUALIFIERS_ONE[3], VALUES[0]), +444 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[0], VALUES[0]), +445 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[2], VALUES[0]), +446 new KeyValue(ROWS_ONE[3], FAMILIES[1], QUALIFIERS_ONE[3], VALUES[0]), +447 // testRowTwo-0 +448 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), +449 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), +450 new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), +451 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), +452 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), +453 new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), +454 // testRowTwo-2 +455 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), +456 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), +457 new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), +458 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), +459 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), +460 new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]), +461 // testRowTwo-3 +462 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]), +463 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]), +464 new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]), +465 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]), +466 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]), +467 new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]) }; +468 +469 // Grab all 6 rows +470 long expectedRows = 6; +471 long expectedKeys = this.colsPerRow; +472 Scan s = new Scan(); +473 s.setReversed(true); +474 s.setFilter(new PageFilter(expectedRows)); +475 verifyScan(s, expectedRows, expectedKeys); +476 +477 // Grab first 4 rows (6 cols per row) +478 expectedRows = 4; +479 expectedKeys = this.colsPerRow; +480 s = new Scan(); +481 s.setReversed(true); +482 s.setFilter(new PageFilter(expectedRows)); +483 verifyScan(s, expectedRows, expectedKeys); +484 +485 // Grab first 2 rows +486 expectedRows = 2; +487 expectedKeys = this.colsPerRow; +488 s = new Scan(); +489 s.setReversed(true); +490 s.setFilter(new PageFilter(expectedRows)); +491 verifyScan(s, expectedRows, expectedKeys); +492 +493 // Grab first row +494 expectedRows = 1; +495 expectedKeys = this.colsPerRow; +496 s = new Scan(); +497 s.setReversed(true); +498 s.setFilter(new PageFilter(expectedRows)); +499 verifyScan(s, expectedRows, expectedKeys); +500 } +501 +502 @Test +503 public void testWhileMatchFilterWithFilterRowWithReverseScan() +504 throws Exception { +505 final int pageSize = 4; +506 +507 Scan s = new Scan(); +508 s.setReversed(true); +509 WhileMatchFilter filter = new WhileMatchFilter(new PageFilter(pageSize)); +510 s.setFilter(filter); +511 +512 InternalScanner scanner = this.region.getScanner(s); +513 int scannerCounter = 0; +514 while (true) { +515 boolean isMoreResults = scanner.next(new ArrayList<>()); +516 scannerCounter++; +517 +518 if (scannerCounter >= pageSize) { +519 Assert.assertTrue( +520 "The WhileMatchFilter should now filter all remaining", +521 filter.filterAllRemaining()); +522 } +523 if (!isMoreResults) { +524 break; +525 } +526 } +527 scanner.close(); +528 Assert.assertEquals("The page filter returned more rows than expected", +529 pageSize, scannerCounter); +530 } +531 +532 @Test +533 public void testWhileMatchFilterWithFilterRowKeyWithReverseScan() +534 throws Exception { +535 Scan s = new Scan(); +536 String prefix = "testRowOne"; +537 WhileMatchFilter filter = new WhileMatchFilter(new PrefixFilter( +538 Bytes.toBytes(prefix))); +539 s.setFilter(filter); +540 s.setReversed(true); +541 +542 InternalScanner scanner = this.region.getScanner(s); +543 while (true) { +544 ArrayList<Cell> values = new ArrayList<>(); +545 boolean isMoreResults = scanner.next(values); +546 if (!isMoreResults +547 || !Bytes.toString(CellUtil.cloneRow(values.get(0))).startsWith(prefix)) { +548 Assert.assertTrue( +549 "The WhileMatchFilter should now filter all remaining", +550 filter.filterAllRemaining()); +551 } +552 if (!isMoreResults) { +553 break; +554 } +555 } +556 scanner.close(); +557 } +558 +559 /** +560 * Tests the the {@link WhileMatchFilter} works in combination with a +561 * {@link Filter} that uses the +562 * {@link Filter#filterRow()} method. +563 * +564 * See HBASE-2258. +565 * +566 * @throws Exception +567 */ +568 @Test +569 public void testWhileMatchFilterWithFilterRow() throws Exception { +570 final int pageSize = 4; +571 +572 Scan s = new Scan(); +573 WhileMatchFilter filter = new WhileMatchFilter(new PageFilter(pageSize)); +574 s.setFilter(filter); +575 +576 InternalScanner scanner = this.region.getScanner(s); +577 int scannerCounter = 0; +578 while (true) { +579 boolean isMoreResults = scanner.next(new ArrayList<>()); +580 scannerCounter++; +581 +582 if (scannerCounter >= pageSize) { +583 assertTrue("The WhileMatchFilter should now filter all remaining", filter.filterAllRemaining()); +584 } +585 if (!isMoreResults) { +586 break; +587 } +588 } +589 assertEquals("The page filter returned more rows than expected", pageSize, scannerCounter); +590 } 591 -592 /** -593 * The following filter simulates a pre-0.96 filter where filterRow() is defined while -594