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.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
62
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
109
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
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
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
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 }