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.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  // Can't be small as it plays with EnvironmentEdgeManager
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     * Test utility for building a NavigableSet for scanners.
63     * @param strCols
64     * @return
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      // returns only 1 of these 2 even though same timestamp
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      // Scan limited TimeRange
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     // Another range.
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     // See how TimeRange and Versions interact.
117     // Another range.
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     // returns only 1 of these 2 even though same timestamp
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     // this only uses maxVersions (default=1) and TimeRange (default=all)
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    * Test test shows exactly how the matcher's return codes confuses the StoreScanner
152    * and prevent it from doing the right thing.  Seeking once, then nexting twice
153    * should return R1, then R2, but in this case it doesnt.
154    * TODO this comment makes no sense above. Appears to do the right thing.
155    * @throws IOException
156    */
157   public void testWontNextToNext() throws IOException {
158     // build the scan file:
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     // this only uses maxVersions (default=1) and TimeRange (default=all)
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     // should be ok...
176     // now scan _next_ again.
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    * Test the case where there is a delete row 'in front of' the next row, the scanner
206    * will move to the next row.
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     // the two put at ts=now will be masked by the 1 delete, and
247     // since the scan default returns 1 version we'll return the newest
248     // key, which is kvs[2], now-100.
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"), // inc
296         // orphaned delete column.
297         KeyValueTestUtil.create("R1", "cf", "a", 1, KeyValue.Type.DeleteColumn, "dont-care"),
298         // column b
299         KeyValueTestUtil.create("R1", "cf", "b", 2, KeyValue.Type.Put, "dont-care"), // inc
300         KeyValueTestUtil.create("R1", "cf", "b", 1, KeyValue.Type.Put, "dont-care"), // inc
301         // column c
302         KeyValueTestUtil.create("R1", "cf", "c", 10, KeyValue.Type.Delete, "dont-care"),
303         KeyValueTestUtil.create("R1", "cf", "c", 10, KeyValue.Type.Put, "dont-care"), // no
304         KeyValueTestUtil.create("R1", "cf", "c", 9, KeyValue.Type.Put, "dont-care"),  // inc
305         // column d
306         KeyValueTestUtil.create("R1", "cf", "d", 11, KeyValue.Type.Put, "dont-care"), // inc
307         KeyValueTestUtil.create("R1", "cf", "d", 10, KeyValue.Type.DeleteColumn, "dont-care"),
308         KeyValueTestUtil.create("R1", "cf", "d", 9, KeyValue.Type.Put, "dont-care"),  // no
309         KeyValueTestUtil.create("R1", "cf", "d", 8, KeyValue.Type.Put, "dont-care"),  // no
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    * Test expiration of KeyValues in combination with a configured TTL for
405    * a column family (as should be triggered in a major compaction).
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     // Previously a updateReaders twice in a row would cause an NPE.  In test this would also
452     // normally cause an NPE because scan.store is null.  So as long as we get through these
453     // two calls we are good and the bug was quashed.
454 
455     scan.updateReaders();
456 
457     scan.updateReaders();
458 
459     scan.peek();
460   }
461 
462 
463   /**
464    * TODO this fails, since we don't handle deletions, etc, in peek
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    * Ensure that expired delete family markers don't override valid puts
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     // scanner with ttl equal to 500
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         /*0*/ new KeyValue(Bytes.toBytes("R1"), Bytes.toBytes("cf"), null,
518         now - 100, KeyValue.Type.DeleteFamily), // live
519         /*1*/ new KeyValue(Bytes.toBytes("R1"), Bytes.toBytes("cf"), null,
520         now - 1000, KeyValue.Type.DeleteFamily), // expired
521         /*2*/ KeyValueTestUtil.create("R1", "cf", "a", now - 50,
522         KeyValue.Type.Put, "v3"), // live
523         /*3*/ KeyValueTestUtil.create("R1", "cf", "a", now - 55,
524         KeyValue.Type.Delete, "dontcare"), // live
525         /*4*/ KeyValueTestUtil.create("R1", "cf", "a", now - 55,
526         KeyValue.Type.Put, "deleted-version v2"), // deleted
527         /*5*/ KeyValueTestUtil.create("R1", "cf", "a", now - 60,
528         KeyValue.Type.Put, "v1"), // live
529         /*6*/ KeyValueTestUtil.create("R1", "cf", "a", now - 65,
530         KeyValue.Type.Put, "v0"), // max-version reached
531         /*7*/ KeyValueTestUtil.create("R1", "cf", "a",
532         now - 100, KeyValue.Type.DeleteColumn, "dont-care"), // max-version
533         /*8*/ KeyValueTestUtil.create("R1", "cf", "b", now - 600,
534         KeyValue.Type.DeleteColumn, "dont-care"), //expired
535         /*9*/ KeyValueTestUtil.create("R1", "cf", "b", now - 70,
536         KeyValue.Type.Put, "v2"), //live
537         /*10*/ KeyValueTestUtil.create("R1", "cf", "b", now - 750,
538         KeyValue.Type.Put, "v1"), //expired
539         /*11*/ KeyValueTestUtil.create("R1", "cf", "c", now - 500,
540         KeyValue.Type.Delete, "dontcare"), //expired
541         /*12*/ KeyValueTestUtil.create("R1", "cf", "c", now - 600,
542         KeyValue.Type.Put, "v1"), //expired
543         /*13*/ KeyValueTestUtil.create("R1", "cf", "c", now - 1000,
544         KeyValue.Type.Delete, "dontcare"), //expired
545         /*14*/ KeyValueTestUtil.create("R1", "cf", "d", now - 60,
546         KeyValue.Type.Put, "expired put"), //live
547         /*15*/ KeyValueTestUtil.create("R1", "cf", "d", now - 100,
548         KeyValue.Type.Delete, "not-expired delete"), //live
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 /* minVersions */,
555         2 /* maxVersions */, 500 /* ttl */,
556         KeepDeletedCells.FALSE /* keepDeletedCells */,
557         200, /* timeToPurgeDeletes */
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