1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
66
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
121
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
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
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
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
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 }