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 }