View Javadoc

1   /**
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  
20  package org.apache.hadoop.hbase.coprocessor;
21  
22  import static org.junit.Assert.assertArrayEquals;
23  import static org.junit.Assert.assertEquals;
24  import static org.junit.Assert.assertNotNull;
25  import static org.junit.Assert.assertTrue;
26  
27  import java.io.IOException;
28  import java.util.List;
29  import java.util.Map;
30  import java.util.NavigableSet;
31  import java.util.concurrent.atomic.AtomicBoolean;
32  import java.util.concurrent.atomic.AtomicInteger;
33  
34  import com.google.common.collect.ImmutableList;
35  import org.apache.commons.logging.Log;
36  import org.apache.commons.logging.LogFactory;
37  import org.apache.hadoop.hbase.Cell;
38  import org.apache.hadoop.hbase.CellUtil;
39  import org.apache.hadoop.hbase.CoprocessorEnvironment;
40  import org.apache.hadoop.hbase.HRegionInfo;
41  import org.apache.hadoop.hbase.KeyValue;
42  import org.apache.hadoop.hbase.client.Get;
43  import org.apache.hadoop.hbase.client.Mutation;
44  import org.apache.hadoop.hbase.client.Put;
45  import org.apache.hadoop.hbase.client.Delete;
46  import org.apache.hadoop.hbase.client.Increment;
47  import org.apache.hadoop.hbase.client.Result;
48  import org.apache.hadoop.hbase.client.Scan;
49  import org.apache.hadoop.hbase.client.Durability;
50  import org.apache.hadoop.hbase.regionserver.HRegion;
51  import org.apache.hadoop.hbase.regionserver.InternalScanner;
52  import org.apache.hadoop.hbase.regionserver.KeyValueScanner;
53  import org.apache.hadoop.hbase.regionserver.Leases;
54  import org.apache.hadoop.hbase.regionserver.MiniBatchOperationInProgress;
55  import org.apache.hadoop.hbase.regionserver.RegionScanner;
56  import org.apache.hadoop.hbase.regionserver.ScanType;
57  import org.apache.hadoop.hbase.regionserver.Store;
58  import org.apache.hadoop.hbase.regionserver.StoreFile;
59  import org.apache.hadoop.hbase.regionserver.wal.HLogKey;
60  import org.apache.hadoop.hbase.regionserver.wal.WALEdit;
61  import org.apache.hadoop.hbase.util.Bytes;
62  import org.apache.hadoop.hbase.util.Pair;
63  
64  /**
65   * A sample region observer that tests the RegionObserver interface.
66   * It works with TestRegionObserverInterface to provide the test case.
67   */
68  public class SimpleRegionObserver extends BaseRegionObserver {
69    static final Log LOG = LogFactory.getLog(TestRegionObserverInterface.class);
70  
71    final AtomicInteger ctBeforeDelete = new AtomicInteger(1);
72    final AtomicInteger ctPreOpen = new AtomicInteger(0);
73    final AtomicInteger ctPostOpen = new AtomicInteger(0);
74    final AtomicInteger ctPreClose = new AtomicInteger(0);
75    final AtomicInteger ctPostClose = new AtomicInteger(0);
76    final AtomicInteger ctPreFlush = new AtomicInteger(0);
77    final AtomicInteger ctPreFlushScannerOpen = new AtomicInteger(0);
78    final AtomicInteger ctPostFlush = new AtomicInteger(0);
79    final AtomicInteger ctPreSplit = new AtomicInteger(0);
80    final AtomicInteger ctPostSplit = new AtomicInteger(0);
81    final AtomicInteger ctPreCompactSelect = new AtomicInteger(0);
82    final AtomicInteger ctPostCompactSelect = new AtomicInteger(0);
83    final AtomicInteger ctPreCompactScanner = new AtomicInteger(0);
84    final AtomicInteger ctPreCompact = new AtomicInteger(0);
85    final AtomicInteger ctPostCompact = new AtomicInteger(0);
86    final AtomicInteger ctPreGet = new AtomicInteger(0);
87    final AtomicInteger ctPostGet = new AtomicInteger(0);
88    final AtomicInteger ctPrePut = new AtomicInteger(0);
89    final AtomicInteger ctPostPut = new AtomicInteger(0);
90    final AtomicInteger ctPreDeleted = new AtomicInteger(0);
91    final AtomicInteger ctPostDeleted = new AtomicInteger(0);
92    final AtomicInteger ctPreGetClosestRowBefore = new AtomicInteger(0);
93    final AtomicInteger ctPostGetClosestRowBefore = new AtomicInteger(0);
94    final AtomicInteger ctPreIncrement = new AtomicInteger(0);
95    final AtomicInteger ctPostIncrement = new AtomicInteger(0);
96    final AtomicInteger ctPreWALRestored = new AtomicInteger(0);
97    final AtomicInteger ctPostWALRestored = new AtomicInteger(0);
98    final AtomicInteger ctPreScannerNext = new AtomicInteger(0);
99    final AtomicInteger ctPostScannerNext = new AtomicInteger(0);
100   final AtomicInteger ctPreScannerClose = new AtomicInteger(0);
101   final AtomicInteger ctPostScannerClose = new AtomicInteger(0);
102   final AtomicInteger ctPreScannerOpen = new AtomicInteger(0);
103   final AtomicInteger ctPreStoreScannerOpen = new AtomicInteger(0);
104   final AtomicInteger ctPostScannerOpen = new AtomicInteger(0);
105   final AtomicInteger ctPreBulkLoadHFile = new AtomicInteger(0);
106   final AtomicInteger ctPostBulkLoadHFile = new AtomicInteger(0);
107   final AtomicInteger ctPreBatchMutate = new AtomicInteger(0);
108   final AtomicInteger ctPostBatchMutate = new AtomicInteger(0);
109   final AtomicInteger ctPreWALRestore = new AtomicInteger(0);
110   final AtomicInteger ctPostWALRestore = new AtomicInteger(0);
111   final AtomicBoolean throwOnPostFlush = new AtomicBoolean(false);
112   static final String TABLE_SKIPPED = "SKIPPED_BY_PREWALRESTORE";
113 
114   public void setThrowOnPostFlush(Boolean val){
115     throwOnPostFlush.set(val);
116   }
117 
118   @Override
119   public void start(CoprocessorEnvironment e) throws IOException {
120     // this only makes sure that leases and locks are available to coprocessors
121     // from external packages
122     RegionCoprocessorEnvironment re = (RegionCoprocessorEnvironment)e;
123     Leases leases = re.getRegionServerServices().getLeases();
124     leases.createLease("x", 2000, null);
125     leases.cancelLease("x");
126   }
127 
128   @Override
129   public void preOpen(ObserverContext<RegionCoprocessorEnvironment> c) {
130     ctPreOpen.incrementAndGet();
131   }
132 
133   @Override
134   public void postOpen(ObserverContext<RegionCoprocessorEnvironment> c) {
135     ctPostOpen.incrementAndGet();
136   }
137 
138   public boolean wasOpened() {
139     return ctPreOpen.get() > 0 && ctPostOpen.get() > 0;
140   }
141 
142   @Override
143   public void preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested) {
144     ctPreClose.incrementAndGet();
145   }
146 
147   @Override
148   public void postClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested) {
149     ctPostClose.incrementAndGet();
150   }
151 
152   public boolean wasClosed() {
153     return ctPreClose.get() > 0 && ctPostClose.get() > 0;
154   }
155 
156   @Override
157   public InternalScanner preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
158       Store store, InternalScanner scanner) throws IOException {
159     ctPreFlush.incrementAndGet();
160     return scanner;
161   }
162 
163   @Override
164   public InternalScanner preFlushScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
165       Store store, KeyValueScanner memstoreScanner, InternalScanner s) throws IOException {
166     ctPreFlushScannerOpen.incrementAndGet();
167     return null;
168   }
169 
170   @Override
171   public void postFlush(ObserverContext<RegionCoprocessorEnvironment> c,
172       Store store, StoreFile resultFile) throws IOException {
173     ctPostFlush.incrementAndGet();
174     if (throwOnPostFlush.get()){
175       throw new IOException("throwOnPostFlush is true in postFlush");
176     }
177   }
178 
179   public boolean wasFlushed() {
180     return ctPreFlush.get() > 0 && ctPostFlush.get() > 0;
181   }
182 
183   @Override
184   public void preSplit(ObserverContext<RegionCoprocessorEnvironment> c) {
185     ctPreSplit.incrementAndGet();
186   }
187 
188   @Override
189   public void postSplit(ObserverContext<RegionCoprocessorEnvironment> c, HRegion l, HRegion r) {
190     ctPostSplit.incrementAndGet();
191   }
192 
193   public boolean wasSplit() {
194     return ctPreSplit.get() > 0 && ctPostSplit.get() > 0;
195   }
196 
197   @Override
198   public void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
199       Store store, List<StoreFile> candidates) {
200     ctPreCompactSelect.incrementAndGet();
201   }
202 
203   @Override
204   public void postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
205       Store store, ImmutableList<StoreFile> selected) {
206     ctPostCompactSelect.incrementAndGet();
207   }
208 
209   @Override
210   public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
211       Store store, InternalScanner scanner, ScanType scanType) {
212     ctPreCompact.incrementAndGet();
213     return scanner;
214   }
215 
216   @Override
217   public InternalScanner preCompactScannerOpen(
218       final ObserverContext<RegionCoprocessorEnvironment> c,
219       Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs,
220       InternalScanner s) throws IOException {
221     ctPreCompactScanner.incrementAndGet();
222     return null;
223   }
224 
225   @Override
226   public void postCompact(ObserverContext<RegionCoprocessorEnvironment> e,
227       Store store, StoreFile resultFile) {
228     ctPostCompact.incrementAndGet();
229   }
230 
231   public boolean wasCompacted() {
232     return ctPreCompact.get() > 0 && ctPostCompact.get() > 0;
233   }
234 
235   @Override
236   public RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
237       final Scan scan,
238       final RegionScanner s) throws IOException {
239     ctPreScannerOpen.incrementAndGet();
240     return null;
241   }
242 
243   @Override
244   public KeyValueScanner preStoreScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
245       final Store store, final Scan scan, final NavigableSet<byte[]> targetCols,
246       final KeyValueScanner s) throws IOException {
247     ctPreStoreScannerOpen.incrementAndGet();
248     return null;
249   }
250 
251   @Override
252   public RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
253       final Scan scan, final RegionScanner s)
254       throws IOException {
255     ctPostScannerOpen.incrementAndGet();
256     return s;
257   }
258 
259   @Override
260   public boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
261       final InternalScanner s, final List<Result> results,
262       final int limit, final boolean hasMore) throws IOException {
263     ctPreScannerNext.incrementAndGet();
264     return hasMore;
265   }
266 
267   @Override
268   public boolean postScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
269       final InternalScanner s, final List<Result> results, final int limit,
270       final boolean hasMore) throws IOException {
271     ctPostScannerNext.incrementAndGet();
272     return hasMore;
273   }
274 
275   @Override
276   public void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
277       final InternalScanner s) throws IOException {
278     ctPreScannerClose.incrementAndGet();
279   }
280 
281   @Override
282   public void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
283       final InternalScanner s) throws IOException {
284     ctPostScannerClose.incrementAndGet();
285   }
286 
287   @Override
288   public void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c, final Get get,
289       final List<Cell> results) throws IOException {
290     RegionCoprocessorEnvironment e = c.getEnvironment();
291     assertNotNull(e);
292     assertNotNull(e.getRegion());
293     assertNotNull(get);
294     assertNotNull(results);
295     ctPreGet.incrementAndGet();
296   }
297 
298   @Override
299   public void postGetOp(final ObserverContext<RegionCoprocessorEnvironment> c, final Get get,
300       final List<Cell> results) {
301     RegionCoprocessorEnvironment e = c.getEnvironment();
302     assertNotNull(e);
303     assertNotNull(e.getRegion());
304     assertNotNull(get);
305     assertNotNull(results);
306     if (e.getRegion().getTableDesc().getTableName().equals(
307         TestRegionObserverInterface.TEST_TABLE)) {
308       boolean foundA = false;
309       boolean foundB = false;
310       boolean foundC = false;
311       for (Cell kv: results) {
312         if (CellUtil.matchingFamily(kv, TestRegionObserverInterface.A)) {
313           foundA = true;
314         }
315         if (CellUtil.matchingFamily(kv, TestRegionObserverInterface.B)) {
316           foundB = true;
317         }
318         if (CellUtil.matchingFamily(kv, TestRegionObserverInterface.C)) {
319           foundC = true;
320         }
321       }
322       assertTrue(foundA);
323       assertTrue(foundB);
324       assertTrue(foundC);
325     }
326     ctPostGet.incrementAndGet();
327   }
328 
329   @Override
330   public void prePut(final ObserverContext<RegionCoprocessorEnvironment> c, 
331       final Put put, final WALEdit edit,
332       final Durability durability) throws IOException {
333     Map<byte[], List<Cell>> familyMap  = put.getFamilyCellMap();
334     RegionCoprocessorEnvironment e = c.getEnvironment();
335     assertNotNull(e);
336     assertNotNull(e.getRegion());
337     assertNotNull(familyMap);
338     if (e.getRegion().getTableDesc().getTableName().equals(
339         TestRegionObserverInterface.TEST_TABLE)) {
340       List<Cell> cells = familyMap.get(TestRegionObserverInterface.A);
341       assertNotNull(cells);
342       assertNotNull(cells.get(0));
343       KeyValue kv = (KeyValue)cells.get(0);
344       assertTrue(Bytes.equals(kv.getQualifier(),
345           TestRegionObserverInterface.A));
346       cells = familyMap.get(TestRegionObserverInterface.B);
347       assertNotNull(cells);
348       assertNotNull(cells.get(0));
349       kv = (KeyValue)cells.get(0);
350       assertTrue(Bytes.equals(kv.getQualifier(),
351           TestRegionObserverInterface.B));
352       cells = familyMap.get(TestRegionObserverInterface.C);
353       assertNotNull(cells);
354       assertNotNull(cells.get(0));
355       kv = (KeyValue)cells.get(0);
356       assertTrue(Bytes.equals(kv.getQualifier(),
357           TestRegionObserverInterface.C));
358     }
359     ctPrePut.incrementAndGet();
360   }
361 
362   @Override
363   public void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
364       final Put put, final WALEdit edit,
365       final Durability durability) throws IOException {
366     Map<byte[], List<Cell>> familyMap  = put.getFamilyCellMap();
367     RegionCoprocessorEnvironment e = c.getEnvironment();
368     assertNotNull(e);
369     assertNotNull(e.getRegion());
370     assertNotNull(familyMap);
371     List<Cell> cells = familyMap.get(TestRegionObserverInterface.A);
372     if (e.getRegion().getTableDesc().getTableName().equals(
373         TestRegionObserverInterface.TEST_TABLE)) {
374       assertNotNull(cells);
375       assertNotNull(cells.get(0));
376       // KeyValue v1 expectation.  Cast for now until we go all Cell all the time. TODO
377       KeyValue kv = (KeyValue)cells.get(0);
378       assertTrue(Bytes.equals(kv.getQualifier(), TestRegionObserverInterface.A));
379       cells = familyMap.get(TestRegionObserverInterface.B);
380       assertNotNull(cells);
381       assertNotNull(cells.get(0));
382       // KeyValue v1 expectation.  Cast for now until we go all Cell all the time. TODO
383       kv = (KeyValue)cells.get(0);
384       assertTrue(Bytes.equals(kv.getQualifier(), TestRegionObserverInterface.B));
385       cells = familyMap.get(TestRegionObserverInterface.C);
386       assertNotNull(cells);
387       assertNotNull(cells.get(0));
388       // KeyValue v1 expectation.  Cast for now until we go all Cell all the time. TODO
389       kv = (KeyValue)cells.get(0);
390       assertTrue(Bytes.equals(kv.getQualifier(), TestRegionObserverInterface.C));
391     }
392     ctPostPut.incrementAndGet();
393   }
394 
395   @Override
396   public void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c, 
397       final Delete delete, final WALEdit edit,
398       final Durability durability) throws IOException {
399     Map<byte[], List<Cell>> familyMap  = delete.getFamilyCellMap();
400     RegionCoprocessorEnvironment e = c.getEnvironment();
401     assertNotNull(e);
402     assertNotNull(e.getRegion());
403     assertNotNull(familyMap);
404     if (ctBeforeDelete.get() > 0) {
405       ctPreDeleted.incrementAndGet();
406     }
407   }
408 
409   @Override
410   public void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c, 
411       final Delete delete, final WALEdit edit,
412       final Durability durability) throws IOException {
413     Map<byte[], List<Cell>> familyMap  = delete.getFamilyCellMap();
414     RegionCoprocessorEnvironment e = c.getEnvironment();
415     assertNotNull(e);
416     assertNotNull(e.getRegion());
417     assertNotNull(familyMap);
418     ctBeforeDelete.set(0);
419     ctPostDeleted.incrementAndGet();
420   }
421   
422   @Override
423   public void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
424       MiniBatchOperationInProgress<Mutation> miniBatchOp) throws IOException {
425     RegionCoprocessorEnvironment e = c.getEnvironment();
426     assertNotNull(e);
427     assertNotNull(e.getRegion());
428     assertNotNull(miniBatchOp);
429     ctPreBatchMutate.incrementAndGet();
430   }
431 
432   @Override
433   public void postBatchMutate(final ObserverContext<RegionCoprocessorEnvironment> c,
434       final MiniBatchOperationInProgress<Mutation> miniBatchOp) throws IOException {
435     RegionCoprocessorEnvironment e = c.getEnvironment();
436     assertNotNull(e);
437     assertNotNull(e.getRegion());
438     assertNotNull(miniBatchOp);
439     ctPostBatchMutate.incrementAndGet();
440   }
441 
442   @Override
443   public void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
444       final byte[] row, final byte[] family, final Result result)
445       throws IOException {
446     RegionCoprocessorEnvironment e = c.getEnvironment();
447     assertNotNull(e);
448     assertNotNull(e.getRegion());
449     assertNotNull(row);
450     assertNotNull(result);
451     if (ctBeforeDelete.get() > 0) {
452       ctPreGetClosestRowBefore.incrementAndGet();
453     }
454   }
455 
456   @Override
457   public void postGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
458       final byte[] row, final byte[] family, final Result result)
459       throws IOException {
460     RegionCoprocessorEnvironment e = c.getEnvironment();
461     assertNotNull(e);
462     assertNotNull(e.getRegion());
463     assertNotNull(row);
464     assertNotNull(result);
465     ctPostGetClosestRowBefore.incrementAndGet();
466   }
467 
468   @Override
469   public Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
470       final Increment increment) throws IOException {
471     ctPreIncrement.incrementAndGet();
472     return null;
473   }
474 
475   @Override
476   public Result postIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
477       final Increment increment, final Result result) throws IOException {
478     ctPostIncrement.incrementAndGet();
479     return result;
480   }
481 
482   @Override
483   public void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
484                                List<Pair<byte[], String>> familyPaths) throws IOException {
485     RegionCoprocessorEnvironment e = ctx.getEnvironment();
486     assertNotNull(e);
487     assertNotNull(e.getRegion());
488     if (e.getRegion().getTableDesc().getTableName().equals(
489         TestRegionObserverInterface.TEST_TABLE)) {
490       assertNotNull(familyPaths);
491       assertEquals(1,familyPaths.size());
492       assertArrayEquals(familyPaths.get(0).getFirst(), TestRegionObserverInterface.A);
493       String familyPath = familyPaths.get(0).getSecond();
494       String familyName = Bytes.toString(TestRegionObserverInterface.A);
495       assertEquals(familyPath.substring(familyPath.length()-familyName.length()-1),"/"+familyName);
496     }
497     ctPreBulkLoadHFile.incrementAndGet();
498   }
499 
500   @Override
501   public boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
502       List<Pair<byte[], String>> familyPaths, boolean hasLoaded) throws IOException {
503     RegionCoprocessorEnvironment e = ctx.getEnvironment();
504     assertNotNull(e);
505     assertNotNull(e.getRegion());
506     if (e.getRegion().getTableDesc().getTableName().equals(
507         TestRegionObserverInterface.TEST_TABLE)) {
508       assertNotNull(familyPaths);
509       assertEquals(1,familyPaths.size());
510       assertArrayEquals(familyPaths.get(0).getFirst(), TestRegionObserverInterface.A);
511       String familyPath = familyPaths.get(0).getSecond();
512       String familyName = Bytes.toString(TestRegionObserverInterface.A);
513       assertEquals(familyPath.substring(familyPath.length()-familyName.length()-1),"/"+familyName);
514     }
515     ctPostBulkLoadHFile.incrementAndGet();
516     return hasLoaded;
517   }
518 
519   @Override
520   public void preWALRestore(ObserverContext<RegionCoprocessorEnvironment> env, HRegionInfo info,
521                             HLogKey logKey, WALEdit logEdit) throws IOException {
522     String tableName = logKey.getTablename().getNameAsString();
523     if (tableName.equals(TABLE_SKIPPED)) {
524       // skip recovery of TABLE_SKIPPED for testing purpose
525       env.bypass();
526       return;
527     }
528     ctPreWALRestore.incrementAndGet();
529   }
530 
531   @Override
532   public void postWALRestore(ObserverContext<RegionCoprocessorEnvironment> env,
533                              HRegionInfo info, HLogKey logKey, WALEdit logEdit) throws IOException {
534     ctPostWALRestore.incrementAndGet();
535   }
536 
537 
538   public boolean hadPreGet() {
539     return ctPreGet.get() > 0;
540   }
541 
542   public boolean hadPostGet() {
543     return ctPostGet.get() > 0;
544   }
545 
546   public boolean hadPrePut() {
547     return ctPrePut.get() > 0;
548   }
549 
550   public boolean hadPostPut() {
551     return ctPostPut.get() > 0;
552   }
553   
554   public boolean hadPreBatchMutate() {
555     return ctPreBatchMutate.get() > 0;
556   }
557 
558   public boolean hadPostBatchMutate() {
559     return ctPostBatchMutate.get() > 0;
560   }
561   
562   public boolean hadDelete() {
563     return !(ctBeforeDelete.get() > 0);
564   }
565 
566   public boolean hadPreIncrement() {
567     return ctPreIncrement.get() > 0;
568   }
569 
570   public boolean hadPostIncrement() {
571     return ctPostIncrement.get() > 0;
572   }
573 
574   public boolean hadPreWALRestored() {
575     return ctPreWALRestored.get() > 0;
576   }
577 
578   public boolean hadPostWALRestored() {
579     return ctPostWALRestored.get() > 0;
580   }
581   public boolean wasScannerNextCalled() {
582     return ctPreScannerNext.get() > 0 && ctPostScannerNext.get() > 0;
583   }
584   public boolean wasScannerCloseCalled() {
585     return ctPreScannerClose.get() > 0 && ctPostScannerClose.get() > 0;
586   }
587   public boolean wasScannerOpenCalled() {
588     return ctPreScannerOpen.get() > 0 && ctPostScannerOpen.get() > 0;
589   }
590   public boolean hadDeleted() {
591     return ctPreDeleted.get() > 0 && ctPostDeleted.get() > 0;
592   }
593 
594   public boolean hadPostBulkLoadHFile() {
595     return ctPostBulkLoadHFile.get() > 0;
596   }
597 
598   public boolean hadPreBulkLoadHFile() {
599     return ctPreBulkLoadHFile.get() > 0;
600   }
601 
602 
603   public int getCtBeforeDelete() {
604     return ctBeforeDelete.get();
605   }
606 
607   public int getCtPreOpen() {
608     return ctPreOpen.get();
609   }
610 
611   public int getCtPostOpen() {
612     return ctPostOpen.get();
613   }
614 
615   public int getCtPreClose() {
616     return ctPreClose.get();
617   }
618 
619   public int getCtPostClose() {
620     return ctPostClose.get();
621   }
622 
623   public int getCtPreFlush() {
624     return ctPreFlush.get();
625   }
626 
627   public int getCtPreFlushScannerOpen() {
628     return ctPreFlushScannerOpen.get();
629   }
630 
631   public int getCtPostFlush() {
632     return ctPostFlush.get();
633   }
634 
635   public int getCtPreSplit() {
636     return ctPreSplit.get();
637   }
638 
639   public int getCtPostSplit() {
640     return ctPostSplit.get();
641   }
642 
643   public int getCtPreCompactSelect() {
644     return ctPreCompactSelect.get();
645   }
646 
647   public int getCtPostCompactSelect() {
648     return ctPostCompactSelect.get();
649   }
650 
651   public int getCtPreCompactScanner() {
652     return ctPreCompactScanner.get();
653   }
654 
655   public int getCtPreCompact() {
656     return ctPreCompact.get();
657   }
658 
659   public int getCtPostCompact() {
660     return ctPostCompact.get();
661   }
662 
663   public int getCtPreGet() {
664     return ctPreGet.get();
665   }
666 
667   public int getCtPostGet() {
668     return ctPostGet.get();
669   }
670 
671   public int getCtPrePut() {
672     return ctPrePut.get();
673   }
674 
675   public int getCtPostPut() {
676     return ctPostPut.get();
677   }
678 
679   public int getCtPreDeleted() {
680     return ctPreDeleted.get();
681   }
682 
683   public int getCtPostDeleted() {
684     return ctPostDeleted.get();
685   }
686 
687   public int getCtPreGetClosestRowBefore() {
688     return ctPreGetClosestRowBefore.get();
689   }
690 
691   public int getCtPostGetClosestRowBefore() {
692     return ctPostGetClosestRowBefore.get();
693   }
694 
695   public int getCtPreIncrement() {
696     return ctPreIncrement.get();
697   }
698 
699   public int getCtPostIncrement() {
700     return ctPostIncrement.get();
701   }
702 
703   public int getCtPreWALRestore() {
704     return ctPreWALRestore.get();
705   }
706 
707   public int getCtPostWALRestore() {
708     return ctPostWALRestore.get();
709   }
710 }