reseek

boolean reseek(KeyValue key)
               throws IOException

Reseek the scanner at or after the specified KeyValue. This method is guaranteed to seek at or after the required key only if the key comes after the current position of the scanner. Should not be used to seek to a key which may come before the current position.

Parameters:

key - seek value (should be non-null)

Returns:

true if scanner has values left, false if end of scanner

Throws:

IOException

Rather than storing the ROOT region location in ZooKeeper, going to ROOT, and reading the META location, we should just store the META location directly in ZooKeeper.

The purpose of the root region from the bigtable paper was to support multiple meta regions. Currently, we explicitly only support a single meta region, so the translation from our current code of a single root location to a single meta location will be very simple. Long-term, it seems reasonable that we could store several meta region locations in ZK. There's been some discussion in HBASE-1755 about actually moving META into ZK, but I think this jira is a good step towards taking some of the complexity out of how we have to deal with catalog tables everywhere.

As-is, a new client already requires ZK to get the root location, so this would not change those requirements in any way.

The primary motivation for this is to simplify things like CatalogTracker. The way we can handle root in that class is really simple but the tracking of meta is difficulty and a bit hacky. This hack on tracking of the meta location is what caused one of the bugs over in HBASE-3159.

출처 :

http://hadoop-hbase.blogspot.kr/2012_02_01_archive.html

http://www.slideshare.net/cloudera/1-serving-apparel-catalog-from-h-base-suraj-varma-gap-inc-finalupdated-last-minute

The key observation is that all that is required for atomic operations are co-located cells.

관련 API

http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.html

http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/regionserver/DelimitedKeyPrefixRegionSplitPolicy.html

http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/regionserver/KeyPrefixRegionSplitPolicy.html

http://hadoop-hbase.blogspot.kr/2012_02_01_archive.html 의 구현 예제 내용을 그대로 배낌

An example can be setup as follows:

http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/client/RowMutations.html

Performs multiple mutations atomically on a single row. Currently Put and Delete are supported. The mutations are performed in the order in which they were added.

We compare and equate mutations based off their row so be careful putting RowMutations into Sets or using them as keys in Maps.

public void testColumnFamilyDeleteRM() throws Exception { 

        HTableInterface table = hTablePool.getTable(tableName); 

        try { 

            RowMutations rm =new RowMutations(row); 

            Delete delete = new Delete(row); 

            delete.deleteFamily(cf1); 

            rm.add(delete); 

            System.out.println("Added delete of cf1 column family to row mutation"); 

            Put put = new Put(row); 

            put.add(cf1, Bytes.toBytes("c1"), Bytes.toBytes("new_v1")); 

            put.add(cf1, Bytes.toBytes("c11"), Bytes.toBytes("new_v11")); 

            rm.add(put); 

            System.out.println("Added puts of cf1 column family to row mutation"); 

            table.mutateRow(rm); 

            System.out.println("Mutated row"); 

            Result result = table.get(new Get(row)); 

            NavigableMap<byte[], byte[]> familyMap = result.getFamilyMap(cf1); 

            Assert.assertNotNull(familyMap);

            Assert.assertEquals(2, familyMap.size()); 

        } finally { 

            table.close(); 

        } 

    } 

[-compactOnce] [-major] [-mapred] [-D<property=value>]* files...

public class CompactionTool extends Configured implements Tool {





 /**

     * Execute the actual compaction job.

     * If the compact once flag is not specified, execute the compaction until

     * no more compactions are needed. Uses the Configuration settings provided.

     */

    private void compactStoreFiles(final Path tableDir, final HTableDescriptor htd,

        final HRegionInfo hri, final String familyName, final boolean compactOnce,

        final boolean major) throws IOException {

      HStore store = getStore(conf, fs, tableDir, htd, hri, familyName, tmpDir);

      LOG.info("Compact table=" + htd.getNameAsString() +

        " region=" + hri.getRegionNameAsString() +

        " family=" + familyName);

      if (major) {

        store.triggerMajorCompaction();

      }

      do {

        CompactionContext compaction = store.requestCompaction(Store.PRIORITY_USER, null);

        if (compaction == null) break;

        List<StoreFile> storeFiles = store.compact(compaction);

        if (storeFiles != null && !storeFiles.isEmpty()) {

          if (keepCompactedFiles && deleteCompacted) {

            for (StoreFile storeFile: storeFiles) {

              fs.delete(storeFile.getPath(), false);

            }

          }

        }

      } while (store.needsCompaction() && !compactOnce);

    }

32public class DirectMemoryUtils {

Returns:

the setting of -XX:MaxDirectMemorySize as a long. Returns 0 if -XX:MaxDirectMemorySize is not set.

36

37

38  public static long getDirectMemorySize() {

39    RuntimeMXBean RuntimemxBean = ManagementFactory.getRuntimeMXBean();

40    List<String> arguments = RuntimemxBean.getInputArguments();

41    long multiplier = 1; //for the byte case.

42    for (String s : arguments) {

43      if (s.contains("-XX:MaxDirectMemorySize=")) {

44        String memSize = s.toLowerCase()

45            .replace("-xx:maxdirectmemorysize=", "").trim();

46

47        if (memSize.contains("k")) {

48          multiplier = 1024;

49        }

50

51        else if (memSize.contains("m")) {

52          multiplier = 1048576;

53        }

54

55        else if (memSize.contains("g")) {

56          multiplier = 1073741824;

57        }

58        memSize = memSize.replaceAll("[^\\d]", "");

59

60        long retValue = Long.parseLong(memSize);

61        return retValue * multiplier;

62      }

63

64    }

65    return 0;

66  }

DirectByteBuffers are garbage collected by using a phantom reference and a reference queue. Every once a while, the JVM checks the reference queue and cleans the DirectByteBuffers. However, as this doesn't happen immediately after discarding all references to a DirectByteBuffer, it's easy to OutOfMemoryError yourself using DirectByteBuffers. This function explicitly calls the Cleaner method of a DirectByteBuffer.

Parameters:

toBeDestroyed The DirectByteBuffer that will be "cleaned". Utilizes reflection.

79

80  public static void destroyDirectByteBuffer(ByteBuffer toBeDestroyed)

81      throws IllegalArgumentException, IllegalAccessException,

82      InvocationTargetException, SecurityException, NoSuchMethodException {

83

84    Preconditions.checkArgument(toBeDestroyed.isDirect(),

85        "toBeDestroyed isn't direct!");

86

87    Method cleanerMethod = toBeDestroyed.getClass().getMethod("cleaner");

88    cleanerMethod.setAccessible(true);

89    Object cleaner = cleanerMethod.invoke(toBeDestroyed);

90    Method cleanMethod = cleaner.getClass().getMethod("clean");

91    cleanMethod.setAccessible(true);

92    cleanMethod.invoke(cleaner);

93

94  }

95}