TestDefaultMemStore (Hortonworks Data Platform Apache HBase Java API Reference)

java.lang.Object
- TestCase
- - org.apache.hadoop.hbase.regionserver.TestDefaultMemStore

public class TestDefaultMemStore
extends TestCase

memstore test case

Constructor Summary

Constructors
Constructor and Description

TestDefaultMemStore()

Constructors
Constructor and Description
`TestDefaultMemStore()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`main(java.lang.String[] args)`
`void`	`setUp()`
`void`	`testGet_memstoreAndSnapShot()`
`void`	`testGetNextRow()` Test getNextRow from memstore
`void`	`testGetWithDelete()`
`void`	`testGetWithDeleteColumn()`
`void`	`testGetWithDeleteFamily()`
`void`	`testKeepDeleteInmemstore()`
`void`	`testMemstoreConcurrentControl()`
`void`	`testMemstoreDeletesVisibilityWithSameKey()` When we insert a higher-memstoreTS deletion of a cell but with the same timestamp, we still need to provide consistent reads for the same scanner.
`void`	`testMemstoreEditsVisibilityWithSameKey()` Regression test for HBASE-2616, HBASE-2670.
`void`	`testMultipleTimestamps()` Test to ensure correctness when using Memstore with multiple timestamps
`void`	`testMultipleVersionsSimple()`
`void`	`testPutSameKey()`
`void`	`testReadOwnWritesUnderConcurrency()`
`void`	`testRetainsDeleteColumn()`
`void`	`testRetainsDeleteFamily()`
`void`	`testRetainsDeleteVersion()`
`void`	`testScanAcrossSnapshot()` Test memstore snapshot happening while scanning.
`void`	`testScanAcrossSnapshot2()` A simple test which verifies the 3 possible states when scanning across snapshot.
`void`	`testShouldFlush()` Tests the HRegion.shouldFlush method - adds an edit in the memstore and checks that shouldFlush returns true, and another where it disables the periodic flush functionality and tests whether shouldFlush returns false.
`void`	`testShouldFlushMeta()`
`void`	`testSnapshotting()` Test memstore snapshots
`void`	`testUpdateToTimeOfOldestEdit()` Tests that the timeOfOldestEdit is updated correctly for the various edit operations in memstore.
`void`	`testUpsertMemstoreSize()` Add keyvalues with a fixed memstoreTs, and checks that memstore size is decreased as older keyvalues are deleted from the memstore.
`void`	`testUpsertMSLAB()` Test a pathological pattern that shows why we can't currently use the MSLAB for upsert workloads.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - TestDefaultMemStore
```
public TestDefaultMemStore()
```
- Method Detail
  - setUp
```
public void setUp()
           throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testPutSameKey
```
public void testPutSameKey()
```
  - testScanAcrossSnapshot
```
public void testScanAcrossSnapshot()
                            throws java.io.IOException
```
    Test memstore snapshot happening while scanning.
    
    Throws:
    
    java.io.IOException
  - testScanAcrossSnapshot2
```
public void testScanAcrossSnapshot2()
                             throws java.io.IOException,
                                    java.lang.CloneNotSupportedException
```
    A simple test which verifies the 3 possible states when scanning across snapshot.
    
    Throws:
    
    java.io.IOException
    
    java.lang.CloneNotSupportedException
  - testMemstoreConcurrentControl
```
public void testMemstoreConcurrentControl()
                                   throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testMemstoreEditsVisibilityWithSameKey
```
public void testMemstoreEditsVisibilityWithSameKey()
                                            throws java.io.IOException
```
    Regression test for HBASE-2616, HBASE-2670. When we insert a higher-memstoreTS version of a cell but with the same timestamp, we still need to provide consistent reads for the same scanner.
    
    Throws:
    
    java.io.IOException
  - testMemstoreDeletesVisibilityWithSameKey
```
public void testMemstoreDeletesVisibilityWithSameKey()
                                              throws java.io.IOException
```
    When we insert a higher-memstoreTS deletion of a cell but with the same timestamp, we still need to provide consistent reads for the same scanner.
    
    Throws:
    
    java.io.IOException
  - testReadOwnWritesUnderConcurrency
```
public void testReadOwnWritesUnderConcurrency()
                                       throws java.lang.Throwable
```
    Throws:
    
    java.lang.Throwable
  - testSnapshotting
```
public void testSnapshotting()
                      throws java.io.IOException
```
    Test memstore snapshots
    
    Throws:
    
    java.io.IOException
  - testMultipleVersionsSimple
```
public void testMultipleVersionsSimple()
                                throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testGetNextRow
```
public void testGetNextRow()
                    throws java.lang.Exception
```
    Test getNextRow from memstore
    
    Throws:
    
    java.lang.InterruptedException
    
    java.lang.Exception
  - testGet_memstoreAndSnapShot
```
public void testGet_memstoreAndSnapShot()
                                 throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testGetWithDelete
```
public void testGetWithDelete()
                       throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testGetWithDeleteColumn
```
public void testGetWithDeleteColumn()
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testGetWithDeleteFamily
```
public void testGetWithDeleteFamily()
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testKeepDeleteInmemstore
```
public void testKeepDeleteInmemstore()
```
  - testRetainsDeleteVersion
```
public void testRetainsDeleteVersion()
                              throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testRetainsDeleteColumn
```
public void testRetainsDeleteColumn()
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testRetainsDeleteFamily
```
public void testRetainsDeleteFamily()
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testMultipleTimestamps
```
public void testMultipleTimestamps()
                            throws java.io.IOException
```
    Test to ensure correctness when using Memstore with multiple timestamps
    
    Throws:
    
    java.io.IOException
  - testUpsertMSLAB
```
public void testUpsertMSLAB()
                     throws java.lang.Exception
```
    Test a pathological pattern that shows why we can't currently use the MSLAB for upsert workloads. This test inserts data in the following pattern: - row0001 through row1000 (fills up one 2M Chunk) - row0002 through row1001 (fills up another 2M chunk, leaves one reference to the first chunk - row0003 through row1002 (another chunk, another dangling reference) This causes OOME pretty quickly if we use MSLAB for upsert since each 2M chunk is held onto by a single reference.
    
    Throws:
    
    java.lang.Exception
  - testUpsertMemstoreSize
```
public void testUpsertMemstoreSize()
                            throws java.lang.Exception
```
    Add keyvalues with a fixed memstoreTs, and checks that memstore size is decreased as older keyvalues are deleted from the memstore.
    
    Throws:
    
    java.lang.Exception
  - testUpdateToTimeOfOldestEdit
```
public void testUpdateToTimeOfOldestEdit()
                                  throws java.lang.Exception
```
    Tests that the timeOfOldestEdit is updated correctly for the various edit operations in memstore.
    
    Throws:
    
    java.lang.Exception
  - testShouldFlush
```
public void testShouldFlush()
                     throws java.lang.Exception
```
    Tests the HRegion.shouldFlush method - adds an edit in the memstore and checks that shouldFlush returns true, and another where it disables the periodic flush functionality and tests whether shouldFlush returns false.
    
    Throws:
    
    java.lang.Exception
  - testShouldFlushMeta
```
public void testShouldFlushMeta()
                         throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - main
```
public static void main(java.lang.String[] args)
                 throws java.io.IOException
```
    Throws:
    
    java.io.IOException

Class TestDefaultMemStore

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TestDefaultMemStore

Method Detail

setUp

testPutSameKey

testScanAcrossSnapshot

testScanAcrossSnapshot2

testMemstoreConcurrentControl

testMemstoreEditsVisibilityWithSameKey

testMemstoreDeletesVisibilityWithSameKey

testReadOwnWritesUnderConcurrency

testSnapshotting

testMultipleVersionsSimple

testGetNextRow

testGet_memstoreAndSnapShot

testGetWithDelete

testGetWithDeleteColumn

testGetWithDeleteFamily

testKeepDeleteInmemstore

testRetainsDeleteVersion

testRetainsDeleteColumn

testRetainsDeleteFamily

testMultipleTimestamps

testUpsertMSLAB

testUpsertMemstoreSize

testUpdateToTimeOfOldestEdit

testShouldFlush

testShouldFlushMeta

main