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.io.IOException; 21 import java.util.Collection; 22 import java.util.List; 23 import java.util.NavigableSet; 24 25 import org.apache.hadoop.classification.InterfaceAudience; 26 import org.apache.hadoop.classification.InterfaceStability; 27 import org.apache.hadoop.fs.FileSystem; 28 import org.apache.hadoop.fs.Path; 29 import org.apache.hadoop.hbase.Cell; 30 import org.apache.hadoop.hbase.TableName; 31 import org.apache.hadoop.hbase.HColumnDescriptor; 32 import org.apache.hadoop.hbase.HRegionInfo; 33 import org.apache.hadoop.hbase.KeyValue; 34 import org.apache.hadoop.hbase.client.Scan; 35 import org.apache.hadoop.hbase.io.HeapSize; 36 import org.apache.hadoop.hbase.io.compress.Compression; 37 import org.apache.hadoop.hbase.io.hfile.CacheConfig; 38 import org.apache.hadoop.hbase.io.hfile.HFileDataBlockEncoder; 39 import org.apache.hadoop.hbase.protobuf.generated.WALProtos.CompactionDescriptor; 40 import org.apache.hadoop.hbase.regionserver.compactions.CompactionContext; 41 import org.apache.hadoop.hbase.regionserver.compactions.CompactionProgress; 42 import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequest; 43 44 /** 45 * Interface for objects that hold a column family in a Region. Its a memstore and a set of zero or 46 * more StoreFiles, which stretch backwards over time. 47 */ 48 @InterfaceAudience.Private 49 @InterfaceStability.Evolving 50 public interface Store extends HeapSize, StoreConfigInformation { 51 52 /* The default priority for user-specified compaction requests. 53 * The user gets top priority unless we have blocking compactions. (Pri <= 0) 54 */ int PRIORITY_USER = 1; 55 int NO_PRIORITY = Integer.MIN_VALUE; 56 57 // General Accessors 58 KeyValue.KVComparator getComparator(); 59 60 Collection<StoreFile> getStorefiles(); 61 62 /** 63 * Close all the readers We don't need to worry about subsequent requests because the HRegion 64 * holds a write lock that will prevent any more reads or writes. 65 * @return the {@link StoreFile StoreFiles} that were previously being used. 66 * @throws IOException on failure 67 */ 68 Collection<StoreFile> close() throws IOException; 69 70 /** 71 * Return a scanner for both the memstore and the HStore files. Assumes we are not in a 72 * compaction. 73 * @param scan Scan to apply when scanning the stores 74 * @param targetCols columns to scan 75 * @return a scanner over the current key values 76 * @throws IOException on failure 77 */ 78 KeyValueScanner getScanner(Scan scan, final NavigableSet<byte[]> targetCols, long readPt) 79 throws IOException; 80 81 /** 82 * Get all scanners with no filtering based on TTL (that happens further down 83 * the line). 84 * @param cacheBlocks 85 * @param isGet 86 * @param usePread 87 * @param isCompaction 88 * @param matcher 89 * @param startRow 90 * @param stopRow 91 * @param readPt 92 * @return all scanners for this store 93 */ 94 List<KeyValueScanner> getScanners( 95 boolean cacheBlocks, 96 boolean isGet, 97 boolean usePread, 98 boolean isCompaction, 99 ScanQueryMatcher matcher, 100 byte[] startRow, 101 byte[] stopRow, 102 long readPt 103 ) throws IOException; 104 105 ScanInfo getScanInfo(); 106 107 /** 108 * Adds or replaces the specified KeyValues. 109 * <p> 110 * For each KeyValue specified, if a cell with the same row, family, and qualifier exists in 111 * MemStore, it will be replaced. Otherwise, it will just be inserted to MemStore. 112 * <p> 113 * This operation is atomic on each KeyValue (row/family/qualifier) but not necessarily atomic 114 * across all of them. 115 * @param cells 116 * @param readpoint readpoint below which we can safely remove duplicate KVs 117 * @return memstore size delta 118 * @throws IOException 119 */ 120 long upsert(Iterable<Cell> cells, long readpoint) throws IOException; 121 122 /** 123 * Adds a value to the memstore 124 * @param kv 125 * @return memstore size delta 126 */ 127 long add(KeyValue kv); 128 129 /** 130 * When was the last edit done in the memstore 131 */ 132 long timeOfOldestEdit(); 133 134 /** 135 * Removes a kv from the memstore. The KeyValue is removed only if its key & memstoreTS match the 136 * key & memstoreTS value of the kv parameter. 137 * @param kv 138 */ 139 void rollback(final KeyValue kv); 140 141 /** 142 * Find the key that matches <i>row</i> exactly, or the one that immediately precedes it. WARNING: 143 * Only use this method on a table where writes occur with strictly increasing timestamps. This 144 * method assumes this pattern of writes in order to make it reasonably performant. Also our 145 * search is dependent on the axiom that deletes are for cells that are in the container that 146 * follows whether a memstore snapshot or a storefile, not for the current container: i.e. we'll 147 * see deletes before we come across cells we are to delete. Presumption is that the 148 * memstore#kvset is processed before memstore#snapshot and so on. 149 * @param row The row key of the targeted row. 150 * @return Found keyvalue or null if none found. 151 * @throws IOException 152 */ 153 KeyValue getRowKeyAtOrBefore(final byte[] row) throws IOException; 154 155 FileSystem getFileSystem(); 156 157 /* 158 * @param maxKeyCount 159 * @param compression Compression algorithm to use 160 * @param isCompaction whether we are creating a new file in a compaction 161 * @param includeMVCCReadpoint whether we should out the MVCC readpoint 162 * @return Writer for a new StoreFile in the tmp dir. 163 */ 164 StoreFile.Writer createWriterInTmp( 165 long maxKeyCount, 166 Compression.Algorithm compression, 167 boolean isCompaction, 168 boolean includeMVCCReadpoint, 169 boolean includesTags 170 ) throws IOException; 171 172 // Compaction oriented methods 173 174 boolean throttleCompaction(long compactionSize); 175 176 /** 177 * getter for CompactionProgress object 178 * @return CompactionProgress object; can be null 179 */ 180 CompactionProgress getCompactionProgress(); 181 182 CompactionContext requestCompaction() throws IOException; 183 184 CompactionContext requestCompaction(int priority, CompactionRequest baseRequest) 185 throws IOException; 186 187 void cancelRequestedCompaction(CompactionContext compaction); 188 189 List<StoreFile> compact(CompactionContext compaction) throws IOException; 190 191 /** 192 * @return true if we should run a major compaction. 193 */ 194 boolean isMajorCompaction() throws IOException; 195 196 void triggerMajorCompaction(); 197 198 /** 199 * See if there's too much store files in this store 200 * @return true if number of store files is greater than the number defined in minFilesToCompact 201 */ 202 boolean needsCompaction(); 203 204 int getCompactPriority(); 205 206 StoreFlushContext createFlushContext(long cacheFlushId); 207 208 /** 209 * Call to complete a compaction. Its for the case where we find in the WAL a compaction 210 * that was not finished. We could find one recovering a WAL after a regionserver crash. 211 * See HBASE-2331. 212 * @param compaction 213 */ 214 void completeCompactionMarker(CompactionDescriptor compaction) 215 throws IOException; 216 217 // Split oriented methods 218 219 boolean canSplit(); 220 221 /** 222 * Determines if Store should be split 223 * @return byte[] if store should be split, null otherwise. 224 */ 225 byte[] getSplitPoint(); 226 227 // Bulk Load methods 228 229 /** 230 * This throws a WrongRegionException if the HFile does not fit in this region, or an 231 * InvalidHFileException if the HFile is not valid. 232 */ 233 void assertBulkLoadHFileOk(Path srcPath) throws IOException; 234 235 /** 236 * This method should only be called from HRegion. It is assumed that the ranges of values in the 237 * HFile fit within the stores assigned region. (assertBulkLoadHFileOk checks this) 238 * 239 * @param srcPathStr 240 * @param sequenceId sequence Id associated with the HFile 241 */ 242 void bulkLoadHFile(String srcPathStr, long sequenceId) throws IOException; 243 244 // General accessors into the state of the store 245 // TODO abstract some of this out into a metrics class 246 247 /** 248 * @return <tt>true</tt> if the store has any underlying reference files to older HFiles 249 */ 250 boolean hasReferences(); 251 252 /** 253 * @return The size of this store's memstore, in bytes 254 */ 255 long getMemStoreSize(); 256 257 /** 258 * @return The amount of memory we could flush from this memstore; usually this is equal to 259 * {@link #getMemStoreSize()} unless we are carrying snapshots and then it will be the size of 260 * outstanding snapshots. 261 */ 262 long getFlushableSize(); 263 264 HColumnDescriptor getFamily(); 265 266 /** 267 * @return The maximum memstoreTS in all store files. 268 */ 269 long getMaxMemstoreTS(); 270 271 /** 272 * @return the data block encoder 273 */ 274 HFileDataBlockEncoder getDataBlockEncoder(); 275 276 /** @return aggregate size of all HStores used in the last compaction */ 277 long getLastCompactSize(); 278 279 /** @return aggregate size of HStore */ 280 long getSize(); 281 282 /** 283 * @return Count of store files 284 */ 285 int getStorefilesCount(); 286 287 /** 288 * @return The size of the store files, in bytes, uncompressed. 289 */ 290 long getStoreSizeUncompressed(); 291 292 /** 293 * @return The size of the store files, in bytes. 294 */ 295 long getStorefilesSize(); 296 297 /** 298 * @return The size of the store file indexes, in bytes. 299 */ 300 long getStorefilesIndexSize(); 301 302 /** 303 * Returns the total size of all index blocks in the data block indexes, including the root level, 304 * intermediate levels, and the leaf level for multi-level indexes, or just the root level for 305 * single-level indexes. 306 * @return the total size of block indexes in the store 307 */ 308 long getTotalStaticIndexSize(); 309 310 /** 311 * Returns the total byte size of all Bloom filter bit arrays. For compound Bloom filters even the 312 * Bloom blocks currently not loaded into the block cache are counted. 313 * @return the total size of all Bloom filters in the store 314 */ 315 long getTotalStaticBloomSize(); 316 317 // Test-helper methods 318 319 /** 320 * Used for tests. 321 * @return cache configuration for this Store. 322 */ 323 CacheConfig getCacheConfig(); 324 325 /** 326 * @return the parent region info hosting this store 327 */ 328 HRegionInfo getRegionInfo(); 329 330 RegionCoprocessorHost getCoprocessorHost(); 331 332 boolean areWritesEnabled(); 333 334 /** 335 * @return The smallest mvcc readPoint across all the scanners in this 336 * region. Writes older than this readPoint, are included in every 337 * read operation. 338 */ 339 long getSmallestReadPoint(); 340 341 String getColumnFamilyName(); 342 343 TableName getTableName(); 344 345 /* 346 * @param o Observer who wants to know about changes in set of Readers 347 */ 348 void addChangedReaderObserver(ChangedReadersObserver o); 349 350 /* 351 * @param o Observer no longer interested in changes in set of Readers. 352 */ 353 void deleteChangedReaderObserver(ChangedReadersObserver o); 354 355 /** 356 * @return Whether this store has too many store files. 357 */ 358 boolean hasTooManyStoreFiles(); 359 }