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