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.regionserver;
21
22 import static org.apache.hadoop.hbase.regionserver.KeyValueScanFixture.scanFixture;
23
24 import java.io.IOException;
25 import java.util.ArrayList;
26 import java.util.Arrays;
27 import java.util.List;
28 import java.util.NavigableSet;
29 import java.util.TreeSet;
30
31 import junit.framework.TestCase;
32
33 import org.apache.hadoop.conf.Configuration;
34 import org.apache.hadoop.hbase.HBaseConfiguration;
35 import org.apache.hadoop.hbase.Cell;
36 import org.apache.hadoop.hbase.HConstants;
37 import org.apache.hadoop.hbase.KeepDeletedCells;
38 import org.apache.hadoop.hbase.KeyValue;
39 import org.apache.hadoop.hbase.KeyValueTestUtil;
40 import org.apache.hadoop.hbase.client.Scan;
41 import org.apache.hadoop.hbase.testclassification.MediumTests;
42 import org.apache.hadoop.hbase.util.Bytes;
43 import org.apache.hadoop.hbase.util.EnvironmentEdge;
44 import org.apache.hadoop.hbase.util.EnvironmentEdgeManagerTestHelper;
45 import org.junit.experimental.categories.Category;
46
47
48 @Category(MediumTests.class)
49 public class TestStoreScanner extends TestCase {
50 private static final String CF_STR = "cf";
51 final byte [] CF = Bytes.toBytes(CF_STR);
52 static Configuration CONF = HBaseConfiguration.create();
53 private ScanInfo scanInfo = new ScanInfo(CONF, CF, 0, Integer.MAX_VALUE,
54 Long.MAX_VALUE, KeepDeletedCells.FALSE, 0, KeyValue.COMPARATOR);
55 private ScanType scanType = ScanType.USER_SCAN;
56
57 public void setUp() throws Exception {
58 super.setUp();
59 }
60
61
62
63
64
65
66 NavigableSet<byte[]> getCols(String ...strCols) {
67 NavigableSet<byte[]> cols = new TreeSet<byte[]>(Bytes.BYTES_COMPARATOR);
68 for (String col : strCols) {
69 byte[] bytes = Bytes.toBytes(col);
70 cols.add(bytes);
71 }
72 return cols;
73 }
74
75 public void testScanTimeRange() throws IOException {
76 String r1 = "R1";
77
78 KeyValue [] kvs = new KeyValue[] {
79 KeyValueTestUtil.create(r1, CF_STR, "a", 1, KeyValue.Type.Put, "dont-care"),
80 KeyValueTestUtil.create(r1, CF_STR, "a", 2, KeyValue.Type.Put, "dont-care"),
81 KeyValueTestUtil.create(r1, CF_STR, "a", 3, KeyValue.Type.Put, "dont-care"),
82 KeyValueTestUtil.create(r1, CF_STR, "a", 4, KeyValue.Type.Put, "dont-care"),
83 KeyValueTestUtil.create(r1, CF_STR, "a", 5, KeyValue.Type.Put, "dont-care"),
84 };
85 List<KeyValueScanner> scanners = Arrays.<KeyValueScanner>asList(
86 new KeyValueScanner[] {
87 new KeyValueScanFixture(KeyValue.COMPARATOR, kvs)
88 });
89 Scan scanSpec = new Scan(Bytes.toBytes(r1));
90 scanSpec.setTimeRange(0, 6);
91 scanSpec.setMaxVersions();
92 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
93 getCols("a"), scanners);
94 List<Cell> results = new ArrayList<Cell>();
95 assertEquals(true, scan.next(results));
96 assertEquals(5, results.size());
97 assertEquals(kvs[kvs.length - 1], results.get(0));
98
99 scanSpec = new Scan(Bytes.toBytes(r1));
100 scanSpec.setTimeRange(1, 3);
101 scanSpec.setMaxVersions();
102 scan = new StoreScanner(scanSpec, scanInfo, scanType, getCols("a"),
103 scanners);
104 results = new ArrayList<Cell>();
105 assertEquals(true, scan.next(results));
106 assertEquals(2, results.size());
107
108 scanSpec = new Scan(Bytes.toBytes(r1));
109 scanSpec.setTimeRange(5, 10);
110 scanSpec.setMaxVersions();
111 scan = new StoreScanner(scanSpec, scanInfo, scanType, getCols("a"),
112 scanners);
113 results = new ArrayList<Cell>();
114 assertEquals(true, scan.next(results));
115 assertEquals(1, results.size());
116
117
118 scanSpec = new Scan(Bytes.toBytes(r1));
119 scanSpec.setTimeRange(0, 10);
120 scanSpec.setMaxVersions(3);
121 scan = new StoreScanner(scanSpec, scanInfo, scanType, getCols("a"),
122 scanners);
123 results = new ArrayList<Cell>();
124 assertEquals(true, scan.next(results));
125 assertEquals(3, results.size());
126 }
127
128 public void testScanSameTimestamp() throws IOException {
129
130 KeyValue [] kvs = new KeyValue[] {
131 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Put, "dont-care"),
132 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Put, "dont-care"),
133 };
134 List<KeyValueScanner> scanners = Arrays.asList(
135 new KeyValueScanner[] {
136 new KeyValueScanFixture(KeyValue.COMPARATOR, kvs)
137 });
138
139 Scan scanSpec = new Scan(Bytes.toBytes("R1"));
140
141 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
142 getCols("a"), scanners);
143
144 List<Cell> results = new ArrayList<Cell>();
145 assertEquals(true, scan.next(results));
146 assertEquals(1, results.size());
147 assertEquals(kvs[0], results.get(0));
148 }
149
150
151
152
153
154
155
156
157 public void testWontNextToNext() throws IOException {
158
159 KeyValue [] kvs = new KeyValue[] {
160 KeyValueTestUtil.create("R1", "cf", "a", 2, KeyValue.Type.Put, "dont-care"),
161 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Put, "dont-care"),
162 KeyValueTestUtil.create("R2", "cf", "a", 1, KeyValue.Type.Put, "dont-care")
163 };
164 List<KeyValueScanner> scanners = scanFixture(kvs);
165
166 Scan scanSpec = new Scan(Bytes.toBytes("R1"));
167
168 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
169 getCols("a"), scanners);
170
171 List<Cell> results = new ArrayList<Cell>();
172 scan.next(results);
173 assertEquals(1, results.size());
174 assertEquals(kvs[0], results.get(0));
175
176
177 results.clear();
178 scan.next(results);
179 assertEquals(1, results.size());
180 assertEquals(kvs[2], results.get(0));
181
182 results.clear();
183 scan.next(results);
184 assertEquals(0, results.size());
185
186 }
187
188
189 public void testDeleteVersionSameTimestamp() throws IOException {
190 KeyValue [] kvs = new KeyValue [] {
191 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Put, "dont-care"),
192 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Delete, "dont-care"),
193 };
194 List<KeyValueScanner> scanners = scanFixture(kvs);
195 Scan scanSpec = new Scan(Bytes.toBytes("R1"));
196 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
197 getCols("a"), scanners);
198
199 List<Cell> results = new ArrayList<Cell>();
200 assertFalse(scan.next(results));
201 assertEquals(0, results.size());
202 }
203
204
205
206
207
208 public void testDeletedRowThenGoodRow() throws IOException {
209 KeyValue [] kvs = new KeyValue [] {
210 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Put, "dont-care"),
211 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Delete, "dont-care"),
212 KeyValueTestUtil.create("R2", "cf", "a", 20, KeyValue.Type.Put, "dont-care")
213 };
214 List<KeyValueScanner> scanners = scanFixture(kvs);
215 Scan scanSpec = new Scan(Bytes.toBytes("R1"));
216 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
217 getCols("a"), scanners);
218
219 List<Cell> results = new ArrayList<Cell>();
220 assertEquals(true, scan.next(results));
221 assertEquals(0, results.size());
222
223 assertEquals(true, scan.next(results));
224 assertEquals(1, results.size());
225 assertEquals(kvs[2], results.get(0));
226
227 assertEquals(false, scan.next(results));
228 }
229
230 public void testDeleteVersionMaskingMultiplePuts() throws IOException {
231 long now = System.currentTimeMillis();
232 KeyValue [] kvs1 = new KeyValue[] {
233 KeyValueTestUtil.create("R1", "cf", "a", now, KeyValue.Type.Put, "dont-care"),
234 KeyValueTestUtil.create("R1", "cf", "a", now, KeyValue.Type.Delete, "dont-care")
235 };
236 KeyValue [] kvs2 = new KeyValue[] {
237 KeyValueTestUtil.create("R1", "cf", "a", now-500, KeyValue.Type.Put, "dont-care"),
238 KeyValueTestUtil.create("R1", "cf", "a", now-100, KeyValue.Type.Put, "dont-care"),
239 KeyValueTestUtil.create("R1", "cf", "a", now, KeyValue.Type.Put, "dont-care")
240 };
241 List<KeyValueScanner> scanners = scanFixture(kvs1, kvs2);
242
243 StoreScanner scan = new StoreScanner(new Scan(Bytes.toBytes("R1")),
244 scanInfo, scanType, getCols("a"), scanners);
245 List<Cell> results = new ArrayList<Cell>();
246
247
248
249 assertEquals(true, scan.next(results));
250 assertEquals(1, results.size());
251 assertEquals(kvs2[1], results.get(0));
252 }
253 public void testDeleteVersionsMixedAndMultipleVersionReturn() throws IOException {
254 long now = System.currentTimeMillis();
255 KeyValue [] kvs1 = new KeyValue[] {
256 KeyValueTestUtil.create("R1", "cf", "a", now, KeyValue.Type.Put, "dont-care"),
257 KeyValueTestUtil.create("R1", "cf", "a", now, KeyValue.Type.Delete, "dont-care")
258 };
259 KeyValue [] kvs2 = new KeyValue[] {
260 KeyValueTestUtil.create("R1", "cf", "a", now-500, KeyValue.Type.Put, "dont-care"),
261 KeyValueTestUtil.create("R1", "cf", "a", now+500, KeyValue.Type.Put, "dont-care"),
262 KeyValueTestUtil.create("R1", "cf", "a", now, KeyValue.Type.Put, "dont-care"),
263 KeyValueTestUtil.create("R2", "cf", "z", now, KeyValue.Type.Put, "dont-care")
264 };
265 List<KeyValueScanner> scanners = scanFixture(kvs1, kvs2);
266
267 Scan scanSpec = new Scan(Bytes.toBytes("R1")).setMaxVersions(2);
268 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
269 getCols("a"), scanners);
270 List<Cell> results = new ArrayList<Cell>();
271 assertEquals(true, scan.next(results));
272 assertEquals(2, results.size());
273 assertEquals(kvs2[1], results.get(0));
274 assertEquals(kvs2[0], results.get(1));
275 }
276
277 public void testWildCardOneVersionScan() throws IOException {
278 KeyValue [] kvs = new KeyValue [] {
279 KeyValueTestUtil.create("R1", "cf", "a", 2, KeyValue.Type.Put, "dont-care"),
280 KeyValueTestUtil.create("R1", "cf", "b", 1, KeyValue.Type.Put, "dont-care"),
281 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.DeleteColumn, "dont-care"),
282 };
283 List<KeyValueScanner> scanners = scanFixture(kvs);
284 StoreScanner scan = new StoreScanner(new Scan(Bytes.toBytes("R1")),
285 scanInfo, scanType, null, scanners);
286 List<Cell> results = new ArrayList<Cell>();
287 assertEquals(true, scan.next(results));
288 assertEquals(2, results.size());
289 assertEquals(kvs[0], results.get(0));
290 assertEquals(kvs[1], results.get(1));
291 }
292
293 public void testWildCardScannerUnderDeletes() throws IOException {
294 KeyValue [] kvs = new KeyValue [] {
295 KeyValueTestUtil.create("R1", "cf", "a", 2, KeyValue.Type.Put, "dont-care"),
296
297 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.DeleteColumn, "dont-care"),
298
299 KeyValueTestUtil.create("R1", "cf", "b", 2, KeyValue.Type.Put, "dont-care"),
300 KeyValueTestUtil.create("R1", "cf", "b", 1, KeyValue.Type.Put, "dont-care"),
301
302 KeyValueTestUtil.create("R1", "cf", "c", 10, KeyValue.Type.Delete, "dont-care"),
303 KeyValueTestUtil.create("R1", "cf", "c", 10, KeyValue.Type.Put, "dont-care"),
304 KeyValueTestUtil.create("R1", "cf", "c", 9, KeyValue.Type.Put, "dont-care"),
305
306 KeyValueTestUtil.create("R1", "cf", "d", 11, KeyValue.Type.Put, "dont-care"),
307 KeyValueTestUtil.create("R1", "cf", "d", 10, KeyValue.Type.DeleteColumn, "dont-care"),
308 KeyValueTestUtil.create("R1", "cf", "d", 9, KeyValue.Type.Put, "dont-care"),
309 KeyValueTestUtil.create("R1", "cf", "d", 8, KeyValue.Type.Put, "dont-care"),
310
311 };
312 List<KeyValueScanner> scanners = scanFixture(kvs);
313 StoreScanner scan = new StoreScanner(new Scan().setMaxVersions(2),
314 scanInfo, scanType, null, scanners);
315 List<Cell> results = new ArrayList<Cell>();
316 assertEquals(true, scan.next(results));
317 assertEquals(5, results.size());
318 assertEquals(kvs[0], results.get(0));
319 assertEquals(kvs[2], results.get(1));
320 assertEquals(kvs[3], results.get(2));
321 assertEquals(kvs[6], results.get(3));
322 assertEquals(kvs[7], results.get(4));
323 }
324
325 public void testDeleteFamily() throws IOException {
326 KeyValue [] kvs = new KeyValue[] {
327 KeyValueTestUtil.create("R1", "cf", "a", 100, KeyValue.Type.DeleteFamily, "dont-care"),
328 KeyValueTestUtil.create("R1", "cf", "b", 11, KeyValue.Type.Put, "dont-care"),
329 KeyValueTestUtil.create("R1", "cf", "c", 11, KeyValue.Type.Put, "dont-care"),
330 KeyValueTestUtil.create("R1", "cf", "d", 11, KeyValue.Type.Put, "dont-care"),
331 KeyValueTestUtil.create("R1", "cf", "e", 11, KeyValue.Type.Put, "dont-care"),
332 KeyValueTestUtil.create("R1", "cf", "e", 11, KeyValue.Type.DeleteColumn, "dont-care"),
333 KeyValueTestUtil.create("R1", "cf", "f", 11, KeyValue.Type.Put, "dont-care"),
334 KeyValueTestUtil.create("R1", "cf", "g", 11, KeyValue.Type.Put, "dont-care"),
335 KeyValueTestUtil.create("R1", "cf", "g", 11, KeyValue.Type.Delete, "dont-care"),
336 KeyValueTestUtil.create("R1", "cf", "h", 11, KeyValue.Type.Put, "dont-care"),
337 KeyValueTestUtil.create("R1", "cf", "i", 11, KeyValue.Type.Put, "dont-care"),
338 KeyValueTestUtil.create("R2", "cf", "a", 11, KeyValue.Type.Put, "dont-care"),
339 };
340 List<KeyValueScanner> scanners = scanFixture(kvs);
341 StoreScanner scan = new StoreScanner(
342 new Scan().setMaxVersions(Integer.MAX_VALUE), scanInfo, scanType, null,
343 scanners);
344 List<Cell> results = new ArrayList<Cell>();
345 assertEquals(true, scan.next(results));
346 assertEquals(0, results.size());
347 assertEquals(true, scan.next(results));
348 assertEquals(1, results.size());
349 assertEquals(kvs[kvs.length-1], results.get(0));
350
351 assertEquals(false, scan.next(results));
352 }
353
354 public void testDeleteColumn() throws IOException {
355 KeyValue [] kvs = new KeyValue[] {
356 KeyValueTestUtil.create("R1", "cf", "a", 10, KeyValue.Type.DeleteColumn, "dont-care"),
357 KeyValueTestUtil.create("R1", "cf", "a", 9, KeyValue.Type.Delete, "dont-care"),
358 KeyValueTestUtil.create("R1", "cf", "a", 8, KeyValue.Type.Put, "dont-care"),
359 KeyValueTestUtil.create("R1", "cf", "b", 5, KeyValue.Type.Put, "dont-care")
360 };
361 List<KeyValueScanner> scanners = scanFixture(kvs);
362 StoreScanner scan = new StoreScanner(new Scan(), scanInfo, scanType, null,
363 scanners);
364 List<Cell> results = new ArrayList<Cell>();
365 assertEquals(true, scan.next(results));
366 assertEquals(1, results.size());
367 assertEquals(kvs[3], results.get(0));
368 }
369
370 private static final KeyValue [] kvs = new KeyValue[] {
371 KeyValueTestUtil.create("R1", "cf", "a", 11, KeyValue.Type.Put, "dont-care"),
372 KeyValueTestUtil.create("R1", "cf", "b", 11, KeyValue.Type.Put, "dont-care"),
373 KeyValueTestUtil.create("R1", "cf", "c", 11, KeyValue.Type.Put, "dont-care"),
374 KeyValueTestUtil.create("R1", "cf", "d", 11, KeyValue.Type.Put, "dont-care"),
375 KeyValueTestUtil.create("R1", "cf", "e", 11, KeyValue.Type.Put, "dont-care"),
376 KeyValueTestUtil.create("R1", "cf", "f", 11, KeyValue.Type.Put, "dont-care"),
377 KeyValueTestUtil.create("R1", "cf", "g", 11, KeyValue.Type.Put, "dont-care"),
378 KeyValueTestUtil.create("R1", "cf", "h", 11, KeyValue.Type.Put, "dont-care"),
379 KeyValueTestUtil.create("R1", "cf", "i", 11, KeyValue.Type.Put, "dont-care"),
380 KeyValueTestUtil.create("R2", "cf", "a", 11, KeyValue.Type.Put, "dont-care"),
381 };
382
383 public void testSkipColumn() throws IOException {
384 List<KeyValueScanner> scanners = scanFixture(kvs);
385 StoreScanner scan = new StoreScanner(new Scan(), scanInfo, scanType,
386 getCols("a", "d"), scanners);
387
388 List<Cell> results = new ArrayList<Cell>();
389 assertEquals(true, scan.next(results));
390 assertEquals(2, results.size());
391 assertEquals(kvs[0], results.get(0));
392 assertEquals(kvs[3], results.get(1));
393 results.clear();
394
395 assertEquals(true, scan.next(results));
396 assertEquals(1, results.size());
397 assertEquals(kvs[kvs.length-1], results.get(0));
398
399 results.clear();
400 assertEquals(false, scan.next(results));
401 }
402
403
404
405
406
407 public void testWildCardTtlScan() throws IOException {
408 long now = System.currentTimeMillis();
409 KeyValue [] kvs = new KeyValue[] {
410 KeyValueTestUtil.create("R1", "cf", "a", now-1000, KeyValue.Type.Put, "dont-care"),
411 KeyValueTestUtil.create("R1", "cf", "b", now-10, KeyValue.Type.Put, "dont-care"),
412 KeyValueTestUtil.create("R1", "cf", "c", now-200, KeyValue.Type.Put, "dont-care"),
413 KeyValueTestUtil.create("R1", "cf", "d", now-10000, KeyValue.Type.Put, "dont-care"),
414 KeyValueTestUtil.create("R2", "cf", "a", now, KeyValue.Type.Put, "dont-care"),
415 KeyValueTestUtil.create("R2", "cf", "b", now-10, KeyValue.Type.Put, "dont-care"),
416 KeyValueTestUtil.create("R2", "cf", "c", now-200, KeyValue.Type.Put, "dont-care"),
417 KeyValueTestUtil.create("R2", "cf", "c", now-1000, KeyValue.Type.Put, "dont-care")
418 };
419 List<KeyValueScanner> scanners = scanFixture(kvs);
420 Scan scan = new Scan();
421 scan.setMaxVersions(1);
422 ScanInfo scanInfo = new ScanInfo(CONF, CF, 0, 1, 500, KeepDeletedCells.FALSE, 0,
423 KeyValue.COMPARATOR);
424 ScanType scanType = ScanType.USER_SCAN;
425 StoreScanner scanner =
426 new StoreScanner(scan, scanInfo, scanType,
427 null, scanners);
428
429 List<Cell> results = new ArrayList<Cell>();
430 assertEquals(true, scanner.next(results));
431 assertEquals(2, results.size());
432 assertEquals(kvs[1], results.get(0));
433 assertEquals(kvs[2], results.get(1));
434 results.clear();
435
436 assertEquals(true, scanner.next(results));
437 assertEquals(3, results.size());
438 assertEquals(kvs[4], results.get(0));
439 assertEquals(kvs[5], results.get(1));
440 assertEquals(kvs[6], results.get(2));
441 results.clear();
442
443 assertEquals(false, scanner.next(results));
444 }
445
446 public void testScannerReseekDoesntNPE() throws Exception {
447 List<KeyValueScanner> scanners = scanFixture(kvs);
448 StoreScanner scan = new StoreScanner(new Scan(), scanInfo, scanType,
449 getCols("a", "d"), scanners);
450
451
452
453
454
455 scan.updateReaders();
456
457 scan.updateReaders();
458
459 scan.peek();
460 }
461
462
463
464
465
466 public void SKIP_testPeek() throws Exception {
467 KeyValue [] kvs = new KeyValue [] {
468 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Put, "dont-care"),
469 KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.Delete, "dont-care"),
470 };
471 List<KeyValueScanner> scanners = scanFixture(kvs);
472 Scan scanSpec = new Scan(Bytes.toBytes("R1"));
473 StoreScanner scan = new StoreScanner(scanSpec, scanInfo, scanType,
474 getCols("a"), scanners);
475 assertNull(scan.peek());
476 }
477
478
479
480
481 public void testExpiredDeleteFamily() throws Exception {
482 long now = System.currentTimeMillis();
483 KeyValue [] kvs = new KeyValue[] {
484 new KeyValue(Bytes.toBytes("R1"), Bytes.toBytes("cf"), null, now-1000,
485 KeyValue.Type.DeleteFamily),
486 KeyValueTestUtil.create("R1", "cf", "a", now-10, KeyValue.Type.Put,
487 "dont-care"),
488 };
489 List<KeyValueScanner> scanners = scanFixture(kvs);
490 Scan scan = new Scan();
491 scan.setMaxVersions(1);
492
493 ScanInfo scanInfo = new ScanInfo(CONF, CF, 0, 1, 500, KeepDeletedCells.FALSE, 0,
494 KeyValue.COMPARATOR);
495 ScanType scanType = ScanType.USER_SCAN;
496 StoreScanner scanner =
497 new StoreScanner(scan, scanInfo, scanType, null, scanners);
498
499 List<Cell> results = new ArrayList<Cell>();
500 assertEquals(true, scanner.next(results));
501 assertEquals(1, results.size());
502 assertEquals(kvs[1], results.get(0));
503 results.clear();
504
505 assertEquals(false, scanner.next(results));
506 }
507
508 public void testDeleteMarkerLongevity() throws Exception {
509 try {
510 final long now = System.currentTimeMillis();
511 EnvironmentEdgeManagerTestHelper.injectEdge(new EnvironmentEdge() {
512 public long currentTime() {
513 return now;
514 }
515 });
516 KeyValue[] kvs = new KeyValue[]{
517
518 now - 100, KeyValue.Type.DeleteFamily),
519
520 now - 1000, KeyValue.Type.DeleteFamily),
521
522 KeyValue.Type.Put, "v3"),
523
524 KeyValue.Type.Delete, "dontcare"),
525
526 KeyValue.Type.Put, "deleted-version v2"),
527
528 KeyValue.Type.Put, "v1"),
529
530 KeyValue.Type.Put, "v0"),
531
532 now - 100, KeyValue.Type.DeleteColumn, "dont-care"),
533
534 KeyValue.Type.DeleteColumn, "dont-care"),
535
536 KeyValue.Type.Put, "v2"),
537
538 KeyValue.Type.Put, "v1"),
539
540 KeyValue.Type.Delete, "dontcare"),
541
542 KeyValue.Type.Put, "v1"),
543
544 KeyValue.Type.Delete, "dontcare"),
545
546 KeyValue.Type.Put, "expired put"),
547
548 KeyValue.Type.Delete, "not-expired delete"),
549 };
550 List<KeyValueScanner> scanners = scanFixture(kvs);
551 Scan scan = new Scan();
552 scan.setMaxVersions(2);
553 ScanInfo scanInfo = new ScanInfo(CONF, Bytes.toBytes("cf"),
554 0
555 2
556 KeepDeletedCells.FALSE
557 200,
558 KeyValue.COMPARATOR);
559 StoreScanner scanner =
560 new StoreScanner(scan, scanInfo,
561 ScanType.COMPACT_DROP_DELETES, null, scanners,
562 HConstants.OLDEST_TIMESTAMP);
563 List<Cell> results = new ArrayList<Cell>();
564 results = new ArrayList<Cell>();
565 assertEquals(true, scanner.next(results));
566 assertEquals(kvs[0], results.get(0));
567 assertEquals(kvs[2], results.get(1));
568 assertEquals(kvs[3], results.get(2));
569 assertEquals(kvs[5], results.get(3));
570 assertEquals(kvs[9], results.get(4));
571 assertEquals(kvs[14], results.get(5));
572 assertEquals(kvs[15], results.get(6));
573 assertEquals(7, results.size());
574 scanner.close();
575 }finally{
576 EnvironmentEdgeManagerTestHelper.reset();
577 }
578 }
579
580 }
581