This is an automated email from the ASF dual-hosted git repository.
Apache9 pushed a commit to branch branch-2.6
in repository https://gitbox.apache.org/repos/asf/hbase.git
The following commit(s) were added to refs/heads/branch-2.6 by this push:
new 23d217c6727 HBASE-30243 Split TestMajorCompaction (#8390)
23d217c6727 is described below
commit 23d217c67276ca5f5ba4d041a4286dc2a21219ac
Author: Duo Zhang <[email protected]>
AuthorDate: Mon Jun 22 22:55:24 2026 +0800
HBASE-30243 Split TestMajorCompaction (#8390)
Signed-off-by: Xiao Liu <[email protected]>
(cherry picked from commit 249957e8312707189df9fb96637d92edb9463a70)
---
.../regionserver/MajorCompactionTestBase.java | 248 ++++++++++++
.../hbase/regionserver/TestMajorCompaction.java | 444 ++-------------------
.../TestMajorCompactionDataBlockEncoding.java | 68 ++++
.../regionserver/TestMajorCompactionRequest.java | 78 ++++
.../TestMajorCompactionWithDeletes.java | 102 +++++
.../regionserver/TestTimeBasedMajorCompaction.java | 90 +++++
6 files changed, 609 insertions(+), 421 deletions(-)
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/MajorCompactionTestBase.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/MajorCompactionTestBase.java
new file mode 100644
index 00000000000..e3ba95b5d31
--- /dev/null
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/MajorCompactionTestBase.java
@@ -0,0 +1,248 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.regionserver;
+
+import static org.apache.hadoop.hbase.HBaseTestingUtility.START_KEY;
+import static org.apache.hadoop.hbase.HBaseTestingUtility.START_KEY_BYTES;
+import static org.apache.hadoop.hbase.HBaseTestingUtility.fam1;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.util.stream.Stream;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.Cell;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.HBaseTestingUtility;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HTestConst;
+import org.apache.hadoop.hbase.KeyValue;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
+import org.apache.hadoop.hbase.client.Delete;
+import org.apache.hadoop.hbase.client.Get;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
+import org.apache.hadoop.hbase.wal.WAL;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.TestInfo;
+import org.junit.jupiter.params.provider.Arguments;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Base class for testing major compactions
+ */
+public abstract class MajorCompactionTestBase {
+
+ public static Stream<Arguments> parameters() {
+ return Stream.of("NONE", "BASIC", "EAGER").map(Arguments::of);
+ }
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(MajorCompactionTestBase.class.getName());
+ protected static final HBaseTestingUtility UTIL = new HBaseTestingUtility();
+ protected Configuration conf = UTIL.getConfiguration();
+
+ protected String name;
+ protected final String compType;
+
+ protected HRegion r = null;
+ protected TableDescriptor htd = null;
+ protected static final byte[] COLUMN_FAMILY = fam1;
+ protected final byte[] STARTROW = Bytes.toBytes(START_KEY);
+ protected static final byte[] COLUMN_FAMILY_TEXT = COLUMN_FAMILY;
+ protected int compactionThreshold;
+ protected byte[] secondRowBytes, thirdRowBytes;
+ protected static final long MAX_FILES_TO_COMPACT = 10;
+
+ /** constructor */
+ protected MajorCompactionTestBase(String compType) {
+ this.compType = compType;
+ }
+
+ @BeforeEach
+ public void setUp(TestInfo testInfo) throws Exception {
+ this.name = testInfo.getTestMethod().get().getName();
+ // Set cache flush size to 1MB
+ conf.setInt(HConstants.HREGION_MEMSTORE_FLUSH_SIZE, 1024 * 1024);
+ conf.setInt(HConstants.HREGION_MEMSTORE_BLOCK_MULTIPLIER, 100);
+ compactionThreshold = conf.getInt("hbase.hstore.compactionThreshold", 3);
+ conf.set(CompactingMemStore.COMPACTING_MEMSTORE_TYPE_KEY,
String.valueOf(compType));
+
+ secondRowBytes = START_KEY_BYTES.clone();
+ // Increment the least significant character so we get to next row.
+ secondRowBytes[START_KEY_BYTES.length - 1]++;
+ thirdRowBytes = START_KEY_BYTES.clone();
+ thirdRowBytes[START_KEY_BYTES.length - 1] =
+ (byte) (thirdRowBytes[START_KEY_BYTES.length - 1] + 2);
+ this.htd = UTIL.createTableDescriptor(
+ TableName.valueOf((name + "-" + compType).replace('[', 'i').replace(']',
'i')),
+ ColumnFamilyDescriptorBuilder.DEFAULT_MIN_VERSIONS, 3,
HConstants.FOREVER,
+ ColumnFamilyDescriptorBuilder.DEFAULT_KEEP_DELETED);
+ this.r = UTIL.createLocalHRegion(htd, null, null);
+ }
+
+ @AfterEach
+ public void tearDown() throws Exception {
+ WAL wal = ((HRegion) r).getWAL();
+ ((HRegion) r).close();
+ wal.close();
+ }
+
+ protected final void majorCompaction() throws Exception {
+ createStoreFile(r);
+ for (int i = 0; i < compactionThreshold; i++) {
+ createStoreFile(r);
+ }
+ // Add more content.
+ HTestConst.addContent(new RegionAsTable(r), Bytes.toString(COLUMN_FAMILY));
+
+ // Now there are about 5 versions of each column.
+ // Default is that there only 3 (MAXVERSIONS) versions allowed per column.
+ //
+ // Assert == 3 when we ask for versions.
+ Result result = r.get(new
Get(STARTROW).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
+ assertEquals(compactionThreshold, result.size());
+
+ r.flush(true);
+ r.compact(true);
+
+ // look at the second row
+ // Increment the least significant character so we get to next row.
+ byte[] secondRowBytes = START_KEY_BYTES.clone();
+ secondRowBytes[START_KEY_BYTES.length - 1]++;
+
+ // Always 3 versions if that is what max versions is.
+ result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
+ LOG.debug(
+ "Row " + Bytes.toStringBinary(secondRowBytes) + " after " + "initial
compaction: " + result);
+ assertEquals(compactionThreshold, result.size(),
+ "Invalid number of versions of row " +
Bytes.toStringBinary(secondRowBytes) + ".");
+
+ // Now add deletes to memstore and then flush it.
+ // That will put us over
+ // the compaction threshold of 3 store files. Compacting these store files
+ // should result in a compacted store file that has no references to the
+ // deleted row.
+ LOG.debug("Adding deletes to memstore and flushing");
+ Delete delete = new Delete(secondRowBytes,
EnvironmentEdgeManager.currentTime());
+ byte[][] famAndQf = { COLUMN_FAMILY, null };
+ delete.addFamily(famAndQf[0]);
+ r.delete(delete);
+
+ // Assert deleted.
+ result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
+ assertTrue(result.isEmpty(), "Second row should have been deleted");
+
+ r.flush(true);
+
+ result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
+ assertTrue(result.isEmpty(), "Second row should have been deleted");
+
+ // Add a bit of data and flush. Start adding at 'bbb'.
+ createSmallerStoreFile(this.r);
+ r.flush(true);
+ // Assert that the second row is still deleted.
+ result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
+ assertTrue(result.isEmpty(), "Second row should still be deleted");
+
+ // Force major compaction.
+ r.compact(true);
+ assertEquals(1, r.getStore(COLUMN_FAMILY_TEXT).getStorefiles().size());
+
+ result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
+ assertTrue(result.isEmpty(), "Second row should still be deleted");
+
+ // Make sure the store files do have some 'aaa' keys in them -- exactly 3.
+ // Also, that compacted store files do not have any secondRowBytes because
+ // they were deleted.
+ verifyCounts(3, 0);
+
+ // Multiple versions allowed for an entry, so the delete isn't enough
+ // Lower TTL and expire to ensure that all our entries have been wiped
+ final int ttl = 1000;
+ for (HStore store : r.getStores()) {
+ ScanInfo old = store.getScanInfo();
+ ScanInfo si = old.customize(old.getMaxVersions(), ttl,
old.getKeepDeletedCells());
+ store.setScanInfo(si);
+ }
+ Thread.sleep(1000);
+
+ r.compact(true);
+ int count = count();
+ assertEquals(0, count, "Should not see anything after TTL has expired");
+ }
+
+ private void verifyCounts(int countRow1, int countRow2) throws Exception {
+ int count1 = 0;
+ int count2 = 0;
+ for (HStoreFile f : r.getStore(COLUMN_FAMILY_TEXT).getStorefiles()) {
+ try (StoreFileScanner scanner = f.getPreadScanner(false, Long.MAX_VALUE,
0, false)) {
+ scanner.seek(KeyValue.LOWESTKEY);
+ for (Cell cell;;) {
+ cell = scanner.next();
+ if (cell == null) {
+ break;
+ }
+ byte[] row = CellUtil.cloneRow(cell);
+ if (Bytes.equals(row, STARTROW)) {
+ count1++;
+ } else if (Bytes.equals(row, secondRowBytes)) {
+ count2++;
+ }
+ }
+ }
+ }
+ assertEquals(countRow1, count1);
+ assertEquals(countRow2, count2);
+ }
+
+ private int count() throws IOException {
+ int count = 0;
+ for (HStoreFile f : r.getStore(COLUMN_FAMILY_TEXT).getStorefiles()) {
+ try (StoreFileScanner scanner = f.getPreadScanner(false, Long.MAX_VALUE,
0, false)) {
+ scanner.seek(KeyValue.LOWESTKEY);
+ while (scanner.next() != null) {
+ count++;
+ }
+ }
+ }
+ return count;
+ }
+
+ protected final void createStoreFile(final HRegion region) throws
IOException {
+ createStoreFile(region, Bytes.toString(COLUMN_FAMILY));
+ }
+
+ protected final void createStoreFile(final HRegion region, String family)
throws IOException {
+ Table loader = new RegionAsTable(region);
+ HTestConst.addContent(loader, family);
+ region.flush(true);
+ }
+
+ protected final void createSmallerStoreFile(final HRegion region) throws
IOException {
+ Table loader = new RegionAsTable(region);
+ HTestConst.addContent(loader, Bytes.toString(COLUMN_FAMILY),
Bytes.toBytes("" + "bbb"), null);
+ region.flush(true);
+ }
+}
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java
index 453146ced40..e72a81eef86 100644
---
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java
@@ -17,141 +17,29 @@
*/
package org.apache.hadoop.hbase.regionserver;
-import static org.apache.hadoop.hbase.HBaseTestingUtility.START_KEY;
-import static org.apache.hadoop.hbase.HBaseTestingUtility.START_KEY_BYTES;
-import static org.apache.hadoop.hbase.HBaseTestingUtility.fam1;
-import static org.apache.hadoop.hbase.regionserver.Store.PRIORITY_USER;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.stream.Stream;
-import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate;
-import org.apache.hadoop.hbase.HBaseTestingUtility;
-import org.apache.hadoop.hbase.HConstants;
-import org.apache.hadoop.hbase.HTableDescriptor;
-import org.apache.hadoop.hbase.HTestConst;
-import org.apache.hadoop.hbase.KeepDeletedCells;
-import org.apache.hadoop.hbase.TableName;
-import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
import org.apache.hadoop.hbase.client.Delete;
-import org.apache.hadoop.hbase.client.Get;
-import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Scan;
-import org.apache.hadoop.hbase.client.Table;
-import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;
-import org.apache.hadoop.hbase.io.hfile.HFileDataBlockEncoder;
-import org.apache.hadoop.hbase.io.hfile.HFileDataBlockEncoderImpl;
-import org.apache.hadoop.hbase.io.hfile.HFileScanner;
-import
org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker;
-import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequestImpl;
-import
org.apache.hadoop.hbase.regionserver.compactions.RatioBasedCompactionPolicy;
import org.apache.hadoop.hbase.testclassification.LargeTests;
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
-import org.apache.hadoop.hbase.util.Bytes;
-import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
-import org.apache.hadoop.hbase.wal.WAL;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Tag;
-import org.junit.jupiter.api.TestInfo;
import org.junit.jupiter.api.TestTemplate;
-import org.junit.jupiter.params.provider.Arguments;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-/**
- * Test major compactions
- */
@Tag(RegionServerTests.TAG)
@Tag(LargeTests.TAG)
@HBaseParameterizedTestTemplate(name = "{index}: compType={0}")
-public class TestMajorCompaction {
-
- public static Stream<Arguments> parameters() {
- return Stream.of("NONE", "BASIC", "EAGER").map(Arguments::of);
- }
-
- private static final Logger LOG =
LoggerFactory.getLogger(TestMajorCompaction.class.getName());
- private static final HBaseTestingUtility UTIL =
HBaseTestingUtility.createLocalHTU();
- protected Configuration conf = UTIL.getConfiguration();
-
- private String name;
- private final String compType;
+public class TestMajorCompaction extends MajorCompactionTestBase {
- private HRegion r = null;
- private HTableDescriptor htd = null;
- private static final byte[] COLUMN_FAMILY = fam1;
- private final byte[] STARTROW = Bytes.toBytes(START_KEY);
- private static final byte[] COLUMN_FAMILY_TEXT = COLUMN_FAMILY;
- private int compactionThreshold;
- private byte[] secondRowBytes, thirdRowBytes;
- private static final long MAX_FILES_TO_COMPACT = 10;
-
- /** constructor */
public TestMajorCompaction(String compType) {
- super();
- this.compType = compType;
- // Set cache flush size to 1MB
- conf.setInt(HConstants.HREGION_MEMSTORE_FLUSH_SIZE, 1024 * 1024);
- conf.setInt(HConstants.HREGION_MEMSTORE_BLOCK_MULTIPLIER, 100);
- compactionThreshold = conf.getInt("hbase.hstore.compactionThreshold", 3);
- conf.set(CompactingMemStore.COMPACTING_MEMSTORE_TYPE_KEY,
String.valueOf(compType));
-
- secondRowBytes = START_KEY_BYTES.clone();
- // Increment the least significant character so we get to next row.
- secondRowBytes[START_KEY_BYTES.length - 1]++;
- thirdRowBytes = START_KEY_BYTES.clone();
- thirdRowBytes[START_KEY_BYTES.length - 1] =
- (byte) (thirdRowBytes[START_KEY_BYTES.length - 1] + 2);
- }
-
- @BeforeEach
- public void setUp(TestInfo testInfo) throws Exception {
- this.name = testInfo.getTestMethod().get().getName();
- this.htd = UTIL.createTableDescriptor(
- TableName.valueOf((name + "-" + compType).replace('[', 'i').replace(']',
'i')),
- ColumnFamilyDescriptorBuilder.DEFAULT_MIN_VERSIONS, 3,
HConstants.FOREVER,
- ColumnFamilyDescriptorBuilder.DEFAULT_KEEP_DELETED);
- this.r = UTIL.createLocalHRegion(htd, null, null);
- }
-
- @AfterEach
- public void tearDown() throws Exception {
- WAL wal = ((HRegion) r).getWAL();
- ((HRegion) r).close();
- wal.close();
- }
-
- /**
- * Test that on a major compaction, if all cells are expired or deleted,
then we'll end up with no
- * product. Make sure scanner over region returns right answer in this case
- and that it just
- * basically works.
- * @throws IOException exception encountered
- */
- @TestTemplate
- public void testMajorCompactingToNoOutput() throws IOException {
- testMajorCompactingWithDeletes(KeepDeletedCells.FALSE);
- }
-
- /**
- * Test that on a major compaction,Deleted cells are retained if keep
deleted cells is set to true
- * @throws IOException exception encountered
- */
- @TestTemplate
- public void testMajorCompactingWithKeepDeletedCells() throws IOException {
- testMajorCompactingWithDeletes(KeepDeletedCells.TRUE);
+ super(compType);
}
/**
@@ -162,253 +50,6 @@ public class TestMajorCompaction {
majorCompaction();
}
- @TestTemplate
- public void testDataBlockEncodingInCacheOnly() throws Exception {
- majorCompactionWithDataBlockEncoding(true);
- }
-
- @TestTemplate
- public void testDataBlockEncodingEverywhere() throws Exception {
- majorCompactionWithDataBlockEncoding(false);
- }
-
- public void majorCompactionWithDataBlockEncoding(boolean inCacheOnly) throws
Exception {
- Map<HStore, HFileDataBlockEncoder> replaceBlockCache = new HashMap<>();
- for (HStore store : r.getStores()) {
- HFileDataBlockEncoder blockEncoder = store.getDataBlockEncoder();
- replaceBlockCache.put(store, blockEncoder);
- final DataBlockEncoding inCache = DataBlockEncoding.PREFIX;
- final DataBlockEncoding onDisk = inCacheOnly ? DataBlockEncoding.NONE :
inCache;
- ((HStore) store).setDataBlockEncoderInTest(new
HFileDataBlockEncoderImpl(onDisk));
- }
-
- majorCompaction();
-
- // restore settings
- for (Entry<HStore, HFileDataBlockEncoder> entry :
replaceBlockCache.entrySet()) {
- ((HStore) entry.getKey()).setDataBlockEncoderInTest(entry.getValue());
- }
- }
-
- private void majorCompaction() throws Exception {
- createStoreFile(r);
- for (int i = 0; i < compactionThreshold; i++) {
- createStoreFile(r);
- }
- // Add more content.
- HTestConst.addContent(new RegionAsTable(r), Bytes.toString(COLUMN_FAMILY));
-
- // Now there are about 5 versions of each column.
- // Default is that there only 3 (MAXVERSIONS) versions allowed per column.
- //
- // Assert == 3 when we ask for versions.
- Result result = r.get(new
Get(STARTROW).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
- assertEquals(compactionThreshold, result.size());
-
- r.flush(true);
- r.compact(true);
-
- // look at the second row
- // Increment the least significant character so we get to next row.
- byte[] secondRowBytes = START_KEY_BYTES.clone();
- secondRowBytes[START_KEY_BYTES.length - 1]++;
-
- // Always 3 versions if that is what max versions is.
- result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
- LOG.debug(
- "Row " + Bytes.toStringBinary(secondRowBytes) + " after " + "initial
compaction: " + result);
- assertEquals(compactionThreshold, result.size(),
- "Invalid number of versions of row " +
Bytes.toStringBinary(secondRowBytes) + ".");
-
- // Now add deletes to memstore and then flush it.
- // That will put us over
- // the compaction threshold of 3 store files. Compacting these store files
- // should result in a compacted store file that has no references to the
- // deleted row.
- LOG.debug("Adding deletes to memstore and flushing");
- Delete delete = new Delete(secondRowBytes,
EnvironmentEdgeManager.currentTime());
- byte[][] famAndQf = { COLUMN_FAMILY, null };
- delete.addFamily(famAndQf[0]);
- r.delete(delete);
-
- // Assert deleted.
- result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
- assertTrue(result.isEmpty(), "Second row should have been deleted");
-
- r.flush(true);
-
- result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
- assertTrue(result.isEmpty(), "Second row should have been deleted");
-
- // Add a bit of data and flush. Start adding at 'bbb'.
- createSmallerStoreFile(this.r);
- r.flush(true);
- // Assert that the second row is still deleted.
- result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
- assertTrue(result.isEmpty(), "Second row should still be deleted");
-
- // Force major compaction.
- r.compact(true);
- assertEquals(1, r.getStore(COLUMN_FAMILY_TEXT).getStorefiles().size());
-
- result = r.get(new
Get(secondRowBytes).addFamily(COLUMN_FAMILY_TEXT).readVersions(100));
- assertTrue(result.isEmpty(), "Second row should still be deleted");
-
- // Make sure the store files do have some 'aaa' keys in them -- exactly 3.
- // Also, that compacted store files do not have any secondRowBytes because
- // they were deleted.
- verifyCounts(3, 0);
-
- // Multiple versions allowed for an entry, so the delete isn't enough
- // Lower TTL and expire to ensure that all our entries have been wiped
- final int ttl = 1000;
- for (HStore store : r.getStores()) {
- ScanInfo old = store.getScanInfo();
- ScanInfo si = old.customize(old.getMaxVersions(), ttl,
old.getKeepDeletedCells());
- store.setScanInfo(si);
- }
- Thread.sleep(1000);
-
- r.compact(true);
- int count = count();
- assertEquals(0, count, "Should not see anything after TTL has expired");
- }
-
- @TestTemplate
- public void testTimeBasedMajorCompaction() throws Exception {
- // create 2 storefiles and force a major compaction to reset the time
- int delay = 10 * 1000; // 10 sec
- float jitterPct = 0.20f; // 20%
- conf.setLong(HConstants.MAJOR_COMPACTION_PERIOD, delay);
- conf.setFloat("hbase.hregion.majorcompaction.jitter", jitterPct);
-
- HStore s = ((HStore) r.getStore(COLUMN_FAMILY));
- s.storeEngine.getCompactionPolicy().setConf(conf);
- try {
- createStoreFile(r);
- createStoreFile(r);
- r.compact(true);
-
- // add one more file & verify that a regular compaction won't work
- createStoreFile(r);
- r.compact(false);
- assertEquals(2, s.getStorefilesCount());
-
- // ensure that major compaction time is deterministic
- RatioBasedCompactionPolicy c =
- (RatioBasedCompactionPolicy) s.storeEngine.getCompactionPolicy();
- Collection<HStoreFile> storeFiles = s.getStorefiles();
- long mcTime = c.getNextMajorCompactTime(storeFiles);
- for (int i = 0; i < 10; ++i) {
- assertEquals(mcTime, c.getNextMajorCompactTime(storeFiles));
- }
-
- // ensure that the major compaction time is within the variance
- long jitter = Math.round(delay * jitterPct);
- assertTrue(delay - jitter <= mcTime && mcTime <= delay + jitter);
-
- // wait until the time-based compaction interval
- Thread.sleep(mcTime);
-
- // trigger a compaction request and ensure that it's upgraded to major
- r.compact(false);
- assertEquals(1, s.getStorefilesCount());
- } finally {
- // reset the timed compaction settings
- conf.setLong(HConstants.MAJOR_COMPACTION_PERIOD, 1000 * 60 * 60 * 24);
- conf.setFloat("hbase.hregion.majorcompaction.jitter", 0.20F);
- // run a major to reset the cache
- createStoreFile(r);
- r.compact(true);
- assertEquals(1, s.getStorefilesCount());
- }
- }
-
- private void verifyCounts(int countRow1, int countRow2) throws Exception {
- int count1 = 0;
- int count2 = 0;
- for (HStoreFile f : r.getStore(COLUMN_FAMILY_TEXT).getStorefiles()) {
- HFileScanner scanner = f.getReader().getScanner(false, false);
- scanner.seekTo();
- do {
- byte[] row = CellUtil.cloneRow(scanner.getCell());
- if (Bytes.equals(row, STARTROW)) {
- count1++;
- } else if (Bytes.equals(row, secondRowBytes)) {
- count2++;
- }
- } while (scanner.next());
- }
- assertEquals(countRow1, count1);
- assertEquals(countRow2, count2);
- }
-
- private int count() throws IOException {
- int count = 0;
- for (HStoreFile f : r.getStore(COLUMN_FAMILY_TEXT).getStorefiles()) {
- HFileScanner scanner = f.getReader().getScanner(false, false);
- if (!scanner.seekTo()) {
- continue;
- }
- do {
- count++;
- } while (scanner.next());
- }
- return count;
- }
-
- private void createStoreFile(final HRegion region) throws IOException {
- createStoreFile(region, Bytes.toString(COLUMN_FAMILY));
- }
-
- private void createStoreFile(final HRegion region, String family) throws
IOException {
- Table loader = new RegionAsTable(region);
- HTestConst.addContent(loader, family);
- region.flush(true);
- }
-
- private void createSmallerStoreFile(final HRegion region) throws IOException
{
- Table loader = new RegionAsTable(region);
- HTestConst.addContent(loader, Bytes.toString(COLUMN_FAMILY),
Bytes.toBytes("" + "bbb"), null);
- region.flush(true);
- }
-
- /**
- * Test for HBASE-5920 - Test user requested major compactions always
occurring
- */
- @TestTemplate
- public void testNonUserMajorCompactionRequest() throws Exception {
- HStore store = r.getStore(COLUMN_FAMILY);
- createStoreFile(r);
- for (int i = 0; i < MAX_FILES_TO_COMPACT + 1; i++) {
- createStoreFile(r);
- }
- store.triggerMajorCompaction();
-
- CompactionRequestImpl request =
store.requestCompaction().get().getRequest();
- assertNotNull(request, "Expected to receive a compaction request");
- assertFalse(request.isMajor(),
- "System-requested major compaction should not occur if there are too
many store files");
- }
-
- /**
- * Test for HBASE-5920
- */
- @TestTemplate
- public void testUserMajorCompactionRequest() throws IOException {
- HStore store = r.getStore(COLUMN_FAMILY);
- createStoreFile(r);
- for (int i = 0; i < MAX_FILES_TO_COMPACT + 1; i++) {
- createStoreFile(r);
- }
- store.triggerMajorCompaction();
- CompactionRequestImpl request = store
- .requestCompaction(PRIORITY_USER, CompactionLifeCycleTracker.DUMMY,
null).get().getRequest();
- assertNotNull(request, "Expected to receive a compaction request");
- assertTrue(request.isMajor(), "User-requested major compaction should
always occur, "
- + "even if there are too many store files");
- }
-
/**
* Test that on a major compaction, if all cells are expired or deleted,
then we'll end up with no
* product. Make sure scanner over region returns right answer in this case
- and that it just
@@ -423,73 +64,34 @@ public class TestMajorCompaction {
// Now delete everything.
Scan scan = new Scan();
scan.setReversed(true);
- InternalScanner s = r.getScanner(scan);
- do {
- List<Cell> results = new ArrayList<>();
- boolean result = s.next(results);
- assertTrue(!results.isEmpty());
- r.delete(new Delete(CellUtil.cloneRow(results.get(0))));
- if (!result) {
- break;
- }
- } while (true);
- s.close();
+ try (InternalScanner s = r.getScanner(scan)) {
+ do {
+ List<Cell> results = new ArrayList<>();
+ boolean result = s.next(results);
+ assertTrue(!results.isEmpty());
+ r.delete(new Delete(CellUtil.cloneRow(results.get(0))));
+ if (!result) {
+ break;
+ }
+ } while (true);
+ }
// Flush
r.flush(true);
// Major compact.
r.compact(true);
scan = new Scan();
scan.setReversed(true);
- s = r.getScanner(scan);
int counter = 0;
- do {
- List<Cell> results = new ArrayList<>();
- boolean result = s.next(results);
- if (!result) {
- break;
- }
- counter++;
- } while (true);
- s.close();
- assertEquals(0, counter);
- }
-
- private void testMajorCompactingWithDeletes(KeepDeletedCells
keepDeletedCells)
- throws IOException {
- createStoreFile(r);
- for (int i = 0; i < compactionThreshold; i++) {
- createStoreFile(r);
- }
- // Now delete everything.
- InternalScanner s = r.getScanner(new Scan());
- int originalCount = 0;
- do {
- List<Cell> results = new ArrayList<>();
- boolean result = s.next(results);
- r.delete(new Delete(CellUtil.cloneRow(results.get(0))));
- if (!result) break;
- originalCount++;
- } while (true);
- s.close();
- // Flush
- r.flush(true);
-
- for (HStore store : this.r.stores.values()) {
- ScanInfo old = store.getScanInfo();
- ScanInfo si = old.customize(old.getMaxVersions(), old.getTtl(),
keepDeletedCells);
- store.setScanInfo(si);
+ try (InternalScanner s = r.getScanner(scan)) {
+ do {
+ List<Cell> results = new ArrayList<>();
+ boolean result = s.next(results);
+ if (!result) {
+ break;
+ }
+ counter++;
+ } while (true);
}
- // Major compact.
- r.compact(true);
- s = r.getScanner(new Scan().setRaw(true));
- int counter = 0;
- do {
- List<Cell> results = new ArrayList<>();
- boolean result = s.next(results);
- if (!result) break;
- counter++;
- } while (true);
- assertEquals(keepDeletedCells == KeepDeletedCells.TRUE ? originalCount :
0, counter);
-
+ assertEquals(0, counter);
}
}
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionDataBlockEncoding.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionDataBlockEncoding.java
new file mode 100644
index 00000000000..aafc00d44c3
--- /dev/null
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionDataBlockEncoding.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.regionserver;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate;
+import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;
+import org.apache.hadoop.hbase.io.hfile.HFileDataBlockEncoder;
+import org.apache.hadoop.hbase.io.hfile.HFileDataBlockEncoderImpl;
+import org.apache.hadoop.hbase.testclassification.LargeTests;
+import org.apache.hadoop.hbase.testclassification.RegionServerTests;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.TestTemplate;
+
+@Tag(RegionServerTests.TAG)
+@Tag(LargeTests.TAG)
+@HBaseParameterizedTestTemplate(name = "{index}: compType={0}")
+public class TestMajorCompactionDataBlockEncoding extends
MajorCompactionTestBase {
+
+ public TestMajorCompactionDataBlockEncoding(String compType) {
+ super(compType);
+ }
+
+ @TestTemplate
+ public void testDataBlockEncodingInCacheOnly() throws Exception {
+ majorCompactionWithDataBlockEncoding(true);
+ }
+
+ @TestTemplate
+ public void testDataBlockEncodingEverywhere() throws Exception {
+ majorCompactionWithDataBlockEncoding(false);
+ }
+
+ private void majorCompactionWithDataBlockEncoding(boolean inCacheOnly)
throws Exception {
+ Map<HStore, HFileDataBlockEncoder> replaceBlockCache = new HashMap<>();
+ for (HStore store : r.getStores()) {
+ HFileDataBlockEncoder blockEncoder = store.getDataBlockEncoder();
+ replaceBlockCache.put(store, blockEncoder);
+ final DataBlockEncoding inCache = DataBlockEncoding.PREFIX;
+ final DataBlockEncoding onDisk = inCacheOnly ? DataBlockEncoding.NONE :
inCache;
+ ((HStore) store).setDataBlockEncoderInTest(new
HFileDataBlockEncoderImpl(onDisk));
+ }
+
+ majorCompaction();
+
+ // restore settings
+ for (Entry<HStore, HFileDataBlockEncoder> entry :
replaceBlockCache.entrySet()) {
+ ((HStore) entry.getKey()).setDataBlockEncoderInTest(entry.getValue());
+ }
+ }
+}
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionRequest.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionRequest.java
new file mode 100644
index 00000000000..7762f46f9d2
--- /dev/null
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionRequest.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.regionserver;
+
+import static org.apache.hadoop.hbase.regionserver.Store.PRIORITY_USER;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate;
+import
org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker;
+import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequestImpl;
+import org.apache.hadoop.hbase.testclassification.LargeTests;
+import org.apache.hadoop.hbase.testclassification.RegionServerTests;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.TestTemplate;
+
+@Tag(RegionServerTests.TAG)
+@Tag(LargeTests.TAG)
+@HBaseParameterizedTestTemplate(name = "{index}: compType={0}")
+public class TestMajorCompactionRequest extends MajorCompactionTestBase {
+
+ public TestMajorCompactionRequest(String compType) {
+ super(compType);
+ }
+
+ /**
+ * Test for HBASE-5920 - Test user requested major compactions always
occurring
+ */
+ @TestTemplate
+ public void testNonUserMajorCompactionRequest() throws Exception {
+ HStore store = r.getStore(COLUMN_FAMILY);
+ createStoreFile(r);
+ for (int i = 0; i < MAX_FILES_TO_COMPACT + 1; i++) {
+ createStoreFile(r);
+ }
+ store.triggerMajorCompaction();
+
+ CompactionRequestImpl request =
store.requestCompaction().get().getRequest();
+ assertNotNull(request, "Expected to receive a compaction request");
+ assertEquals(false, request.isMajor(),
+ "System-requested major compaction should not occur if there are too
many store files");
+ }
+
+ /**
+ * Test for HBASE-5920
+ */
+ @TestTemplate
+ public void testUserMajorCompactionRequest() throws IOException {
+ HStore store = r.getStore(COLUMN_FAMILY);
+ createStoreFile(r);
+ for (int i = 0; i < MAX_FILES_TO_COMPACT + 1; i++) {
+ createStoreFile(r);
+ }
+ store.triggerMajorCompaction();
+ CompactionRequestImpl request = store
+ .requestCompaction(PRIORITY_USER, CompactionLifeCycleTracker.DUMMY,
null).get().getRequest();
+ assertNotNull(request, "Expected to receive a compaction request");
+ assertTrue(request.isMajor(), "User-requested major compaction should
always occur, "
+ + "even if there are too many store files");
+ }
+}
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionWithDeletes.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionWithDeletes.java
new file mode 100644
index 00000000000..2c4d43b5c64
--- /dev/null
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompactionWithDeletes.java
@@ -0,0 +1,102 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.regionserver;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.hadoop.hbase.Cell;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate;
+import org.apache.hadoop.hbase.KeepDeletedCells;
+import org.apache.hadoop.hbase.client.Delete;
+import org.apache.hadoop.hbase.client.Scan;
+import org.apache.hadoop.hbase.testclassification.LargeTests;
+import org.apache.hadoop.hbase.testclassification.RegionServerTests;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.TestTemplate;
+
+@Tag(RegionServerTests.TAG)
+@Tag(LargeTests.TAG)
+@HBaseParameterizedTestTemplate(name = "{index}: compType={0}")
+public class TestMajorCompactionWithDeletes extends MajorCompactionTestBase {
+
+ public TestMajorCompactionWithDeletes(String compType) {
+ super(compType);
+ }
+
+ /**
+ * Test that on a major compaction, if all cells are expired or deleted,
then we'll end up with no
+ * product. Make sure scanner over region returns right answer in this case
- and that it just
+ * basically works.
+ * @throws IOException exception encountered
+ */
+ @TestTemplate
+ public void testMajorCompactingToNoOutput() throws IOException {
+ testMajorCompactingWithDeletes(KeepDeletedCells.FALSE);
+ }
+
+ /**
+ * Test that on a major compaction,Deleted cells are retained if keep
deleted cells is set to true
+ * @throws IOException exception encountered
+ */
+ @TestTemplate
+ public void testMajorCompactingWithKeepDeletedCells() throws IOException {
+ testMajorCompactingWithDeletes(KeepDeletedCells.TRUE);
+ }
+
+ private void testMajorCompactingWithDeletes(KeepDeletedCells
keepDeletedCells)
+ throws IOException {
+ createStoreFile(r);
+ for (int i = 0; i < compactionThreshold; i++) {
+ createStoreFile(r);
+ }
+ // Now delete everything.
+ InternalScanner s = r.getScanner(new Scan());
+ int originalCount = 0;
+ do {
+ List<Cell> results = new ArrayList<>();
+ boolean result = s.next(results);
+ r.delete(new Delete(CellUtil.cloneRow(results.get(0))));
+ if (!result) break;
+ originalCount++;
+ } while (true);
+ s.close();
+ // Flush
+ r.flush(true);
+
+ for (HStore store : this.r.stores.values()) {
+ ScanInfo old = store.getScanInfo();
+ ScanInfo si = old.customize(old.getMaxVersions(), old.getTtl(),
keepDeletedCells);
+ store.setScanInfo(si);
+ }
+ // Major compact.
+ r.compact(true);
+ s = r.getScanner(new Scan().setRaw(true));
+ int counter = 0;
+ do {
+ List<Cell> results = new ArrayList<>();
+ boolean result = s.next(results);
+ if (!result) break;
+ counter++;
+ } while (true);
+ assertEquals(keepDeletedCells == KeepDeletedCells.TRUE ? originalCount :
0, counter);
+ }
+}
diff --git
a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTimeBasedMajorCompaction.java
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTimeBasedMajorCompaction.java
new file mode 100644
index 00000000000..31baa56c1b3
--- /dev/null
+++
b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTimeBasedMajorCompaction.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.regionserver;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Collection;
+import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate;
+import org.apache.hadoop.hbase.HConstants;
+import
org.apache.hadoop.hbase.regionserver.compactions.RatioBasedCompactionPolicy;
+import org.apache.hadoop.hbase.testclassification.LargeTests;
+import org.apache.hadoop.hbase.testclassification.RegionServerTests;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.TestTemplate;
+
+@Tag(RegionServerTests.TAG)
+@Tag(LargeTests.TAG)
+@HBaseParameterizedTestTemplate(name = "{index}: compType={0}")
+public class TestTimeBasedMajorCompaction extends MajorCompactionTestBase {
+
+ public TestTimeBasedMajorCompaction(String compType) {
+ super(compType);
+ }
+
+ @TestTemplate
+ public void testTimeBasedMajorCompaction() throws Exception {
+ // create 2 storefiles and force a major compaction to reset the time
+ int delay = 10 * 1000; // 10 sec
+ float jitterPct = 0.20f; // 20%
+ conf.setLong(HConstants.MAJOR_COMPACTION_PERIOD, delay);
+ conf.setFloat("hbase.hregion.majorcompaction.jitter", jitterPct);
+
+ HStore s = ((HStore) r.getStore(COLUMN_FAMILY));
+ s.storeEngine.getCompactionPolicy().setConf(conf);
+ try {
+ createStoreFile(r);
+ createStoreFile(r);
+ r.compact(true);
+
+ // add one more file & verify that a regular compaction won't work
+ createStoreFile(r);
+ r.compact(false);
+ assertEquals(2, s.getStorefilesCount());
+
+ // ensure that major compaction time is deterministic
+ RatioBasedCompactionPolicy c =
+ (RatioBasedCompactionPolicy) s.storeEngine.getCompactionPolicy();
+ Collection<HStoreFile> storeFiles = s.getStorefiles();
+ long mcTime = c.getNextMajorCompactTime(storeFiles);
+ for (int i = 0; i < 10; ++i) {
+ assertEquals(mcTime, c.getNextMajorCompactTime(storeFiles));
+ }
+
+ // ensure that the major compaction time is within the variance
+ long jitter = Math.round(delay * jitterPct);
+ assertTrue(delay - jitter <= mcTime && mcTime <= delay + jitter);
+
+ // wait until the time-based compaction interval
+ Thread.sleep(mcTime);
+
+ // trigger a compaction request and ensure that it's upgraded to major
+ r.compact(false);
+ assertEquals(1, s.getStorefilesCount());
+ } finally {
+ // reset the timed compaction settings
+ conf.setLong(HConstants.MAJOR_COMPACTION_PERIOD, 1000 * 60 * 60 * 24);
+ conf.setFloat("hbase.hregion.majorcompaction.jitter", 0.20F);
+ // run a major to reset the cache
+ createStoreFile(r);
+ r.compact(true);
+ assertEquals(1, s.getStorefilesCount());
+ }
+ }
+}
