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 * Write an update 64 * @param cell 65 * @return approximate size of the passed KV and the newly added KV which maybe different from the 66 * passed in KV. 67 */ 68 Pair<Long, Cell> add(final Cell cell); 69 70 /** 71 * @return Oldest timestamp of all the Cells in the MemStore 72 */ 73 long timeOfOldestEdit(); 74 75 /** 76 * Remove n key from the memstore. Only kvs that have the same key and the same memstoreTS are 77 * removed. It is ok to not update timeRangeTracker in this call. 78 * @param cell 79 */ 80 void rollback(final Cell cell); 81 82 /** 83 * Write a delete 84 * @param deleteCell 85 * @return approximate size of the passed key and value. 86 */ 87 long delete(final Cell deleteCell); 88 89 /** 90 * Find the key that matches <i>row</i> exactly, or the one that immediately precedes it. The 91 * target row key is set in state. 92 * @param state column/delete tracking state 93 */ 94 void getRowKeyAtOrBefore(final GetClosestRowBeforeTracker state); 95 96 /** 97 * Given the specs of a column, update it, first by inserting a new record, 98 * then removing the old one. Since there is only 1 KeyValue involved, the memstoreTS 99 * will be set to 0, thus ensuring that they instantly appear to anyone. The underlying 100 * store will ensure that the insert/delete each are atomic. A scanner/reader will either 101 * get the new value, or the old value and all readers will eventually only see the new 102 * value after the old was removed. 103 * 104 * @param row 105 * @param family 106 * @param qualifier 107 * @param newValue 108 * @param now 109 * @return Timestamp 110 */ 111 long updateColumnValue(byte[] row, byte[] family, byte[] qualifier, long newValue, long now); 112 113 /** 114 * Update or insert the specified cells. 115 * <p> 116 * For each Cell, insert into MemStore. This will atomically upsert the value for that 117 * row/family/qualifier. If a Cell did already exist, it will then be removed. 118 * <p> 119 * Currently the memstoreTS is kept at 0 so as each insert happens, it will be immediately 120 * visible. May want to change this so it is atomic across all KeyValues. 121 * <p> 122 * This is called under row lock, so Get operations will still see updates atomically. Scans will 123 * only see each KeyValue update as atomic. 124 * @param cells 125 * @param readpoint readpoint below which we can safely remove duplicate Cells. 126 * @return change in memstore size 127 */ 128 long upsert(Iterable<Cell> cells, long readpoint); 129 130 /** 131 * @return scanner over the memstore. This might include scanner over the snapshot when one is 132 * present. 133 */ 134 List<KeyValueScanner> getScanners(long readPt); 135 136 /** 137 * @return Total memory occupied by this MemStore. 138 */ 139 long size(); 140 }