View Javadoc

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 }