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
26 /**
27 * The MemStore holds in-memory modifications to the Store. Modifications are {@link Cell}s.
28 * <p>
29 * The MemStore functions should not be called in parallel. Callers should hold write and read
30 * locks. This is done in {@link HStore}.
31 * </p>
32 */
33 @InterfaceAudience.Private
34 public interface MemStore extends HeapSize {
35
36 /**
37 * Creates a snapshot of the current memstore. Snapshot must be cleared by call to
38 * {@link #clearSnapshot(long)}.
39 * @return {@link MemStoreSnapshot}
40 */
41 MemStoreSnapshot snapshot();
42
43 /**
44 * Clears the current snapshot of the Memstore.
45 * @param id
46 * @throws UnexpectedStateException
47 * @see #snapshot()
48 */
49 void clearSnapshot(long id) throws UnexpectedStateException;
50
51 /**
52 * On flush, how much memory we will clear.
53 * Flush will first clear out the data in snapshot if any (It will take a second flush
54 * invocation to clear the current Cell set). If snapshot is empty, current
55 * Cell set will be flushed.
56 *
57 * @return size of data that is going to be flushed
58 */
59 long getFlushableSize();
60
61 /**
62 * Return the size of the snapshot(s) if any
63 * @return size of the memstore snapshot
64 */
65 long getSnapshotSize();
66
67 /**
68 * Write an update
69 * @param cell
70 * @return approximate size of the passed cell.
71 */
72 long add(final Cell cell);
73
74 /**
75 * @return Oldest timestamp of all the Cells in the MemStore
76 */
77 long timeOfOldestEdit();
78
79 /**
80 * Remove n key from the memstore. Only kvs that have the same key and the same memstoreTS are
81 * removed. It is ok to not update timeRangeTracker in this call.
82 * @param cell
83 */
84 void rollback(final Cell cell);
85
86 /**
87 * Write a delete
88 * @param deleteCell
89 * @return approximate size of the passed key and value.
90 */
91 long delete(final Cell deleteCell);
92
93 /**
94 * Find the key that matches <i>row</i> exactly, or the one that immediately precedes it. The
95 * target row key is set in state.
96 * @param state column/delete tracking state
97 */
98 void getRowKeyAtOrBefore(final GetClosestRowBeforeTracker state);
99
100 /**
101 * Given the specs of a column, update it, first by inserting a new record,
102 * then removing the old one. Since there is only 1 KeyValue involved, the memstoreTS
103 * will be set to 0, thus ensuring that they instantly appear to anyone. The underlying
104 * store will ensure that the insert/delete each are atomic. A scanner/reader will either
105 * get the new value, or the old value and all readers will eventually only see the new
106 * value after the old was removed.
107 *
108 * @param row
109 * @param family
110 * @param qualifier
111 * @param newValue
112 * @param now
113 * @return Timestamp
114 */
115 long updateColumnValue(byte[] row, byte[] family, byte[] qualifier, long newValue, long now);
116
117 /**
118 * Update or insert the specified cells.
119 * <p>
120 * For each Cell, insert into MemStore. This will atomically upsert the value for that
121 * row/family/qualifier. If a Cell did already exist, it will then be removed.
122 * <p>
123 * Currently the memstoreTS is kept at 0 so as each insert happens, it will be immediately
124 * visible. May want to change this so it is atomic across all KeyValues.
125 * <p>
126 * This is called under row lock, so Get operations will still see updates atomically. Scans will
127 * only see each KeyValue update as atomic.
128 * @param cells
129 * @param readpoint readpoint below which we can safely remove duplicate Cells.
130 * @return change in memstore size
131 */
132 long upsert(Iterable<Cell> cells, long readpoint);
133
134 /**
135 * @return scanner over the memstore. This might include scanner over the snapshot when one is
136 * present.
137 */
138 List<KeyValueScanner> getScanners(long readPt);
139
140 /**
141 * @return Total memory occupied by this MemStore.
142 */
143 long size();
144 }