1 /** 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the 7 * "License"); you may not use this file except in compliance 8 * with the License. You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 package org.apache.hadoop.hbase.regionserver; 19 20 import java.util.List; 21 22 import org.apache.hadoop.hbase.classification.InterfaceAudience; 23 import org.apache.hadoop.hbase.Cell; 24 import org.apache.hadoop.hbase.io.HeapSize; 25 import org.apache.hadoop.hbase.util.Pair; 26 27 /** 28 * The MemStore holds in-memory modifications to the Store. Modifications are {@link Cell}s. 29 * <p> 30 * The MemStore functions should not be called in parallel. Callers should hold write and read 31 * locks. This is done in {@link HStore}. 32 * </p> 33 */ 34 @InterfaceAudience.Private 35 public interface MemStore extends HeapSize { 36 37 /** 38 * Creates a snapshot of the current memstore. Snapshot must be cleared by call to 39 * {@link #clearSnapshot(long)}. 40 * @return {@link MemStoreSnapshot} 41 */ 42 MemStoreSnapshot snapshot(); 43 44 /** 45 * Clears the current snapshot of the Memstore. 46 * @param id 47 * @throws UnexpectedStateException 48 * @see #snapshot() 49 */ 50 void clearSnapshot(long id) throws UnexpectedStateException; 51 52 /** 53 * On flush, how much memory we will clear. 54 * Flush will first clear out the data in snapshot if any (It will take a second flush 55 * invocation to clear the current Cell set). If snapshot is empty, current 56 * Cell set will be flushed. 57 * 58 * @return size of data that is going to be flushed 59 */ 60 long getFlushableSize(); 61 62 /** 63 * Return the size of the snapshot(s) if any 64 * @return size of the memstore snapshot 65 */ 66 long getSnapshotSize(); 67 68 /** 69 * Write an update 70 * @param cell 71 * @return approximate size of the passed KV and the newly added KV which maybe different from the 72 * passed in KV. 73 */ 74 Pair<Long, Cell> add(final Cell cell); 75 76 /** 77 * @return Oldest timestamp of all the Cells in the MemStore 78 */ 79 long timeOfOldestEdit(); 80 81 /** 82 * Remove n key from the memstore. Only kvs that have the same key and the same memstoreTS are 83 * removed. It is ok to not update timeRangeTracker in this call. 84 * @param cell 85 */ 86 void rollback(final Cell cell); 87 88 /** 89 * Write a delete 90 * @param deleteCell 91 * @return approximate size of the passed key and value. 92 */ 93 long delete(final Cell deleteCell); 94 95 /** 96 * Find the key that matches <i>row</i> exactly, or the one that immediately precedes it. The 97 * target row key is set in state. 98 * @param state column/delete tracking state 99 */ 100 void getRowKeyAtOrBefore(final GetClosestRowBeforeTracker state); 101 102 /** 103 * Given the specs of a column, update it, first by inserting a new record, 104 * then removing the old one. Since there is only 1 KeyValue involved, the memstoreTS 105 * will be set to 0, thus ensuring that they instantly appear to anyone. The underlying 106 * store will ensure that the insert/delete each are atomic. A scanner/reader will either 107 * get the new value, or the old value and all readers will eventually only see the new 108 * value after the old was removed. 109 * 110 * @param row 111 * @param family 112 * @param qualifier 113 * @param newValue 114 * @param now 115 * @return Timestamp 116 */ 117 long updateColumnValue(byte[] row, byte[] family, byte[] qualifier, long newValue, long now); 118 119 /** 120 * Update or insert the specified cells. 121 * <p> 122 * For each Cell, insert into MemStore. This will atomically upsert the value for that 123 * row/family/qualifier. If a Cell did already exist, it will then be removed. 124 * <p> 125 * Currently the memstoreTS is kept at 0 so as each insert happens, it will be immediately 126 * visible. May want to change this so it is atomic across all KeyValues. 127 * <p> 128 * This is called under row lock, so Get operations will still see updates atomically. Scans will 129 * only see each KeyValue update as atomic. 130 * @param cells 131 * @param readpoint readpoint below which we can safely remove duplicate Cells. 132 * @return change in memstore size 133 */ 134 long upsert(Iterable<Cell> cells, long readpoint); 135 136 /** 137 * @return scanner over the memstore. This might include scanner over the snapshot when one is 138 * present. 139 */ 140 List<KeyValueScanner> getScanners(long readPt); 141 142 /** 143 * @return Total memory occupied by this MemStore. 144 */ 145 long size(); 146 }