1   /**
2    * Copyright 2007 The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  package org.apache.hadoop.hbase.filter;
21  
22  import java.io.ByteArrayInputStream;
23  import java.io.ByteArrayOutputStream;
24  import java.io.DataInputStream;
25  import java.io.DataOutputStream;
26  
27  import org.apache.hadoop.hbase.KeyValue;
28  import org.apache.hadoop.hbase.SmallTests;
29  import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
30  import org.apache.hadoop.hbase.util.Bytes;
31  
32  import junit.framework.TestCase;
33  import org.junit.experimental.categories.Category;
34  
35  /**
36   * Tests the value filter
37   */
38  @Category(SmallTests.class)
39  public class TestSingleColumnValueFilter extends TestCase {
40    private static final byte[] ROW = Bytes.toBytes("test");
41    private static final byte[] COLUMN_FAMILY = Bytes.toBytes("test");
42    private static final byte [] COLUMN_QUALIFIER = Bytes.toBytes("foo");
43    private static final byte[] VAL_1 = Bytes.toBytes("a");
44    private static final byte[] VAL_2 = Bytes.toBytes("ab");
45    private static final byte[] VAL_3 = Bytes.toBytes("abc");
46    private static final byte[] VAL_4 = Bytes.toBytes("abcd");
47    private static final byte[] FULLSTRING_1 =
48      Bytes.toBytes("The quick brown fox jumps over the lazy dog.");
49    private static final byte[] FULLSTRING_2 =
50      Bytes.toBytes("The slow grey fox trips over the lazy dog.");
51    private static final String QUICK_SUBSTR = "quick";
52    private static final String QUICK_REGEX = ".+quick.+";
53  
54    Filter basicFilter;
55    Filter substrFilter;
56    Filter regexFilter;
57  
58    @Override
59    protected void setUp() throws Exception {
60      super.setUp();
61      basicFilter = basicFilterNew();
62      substrFilter = substrFilterNew();
63      regexFilter = regexFilterNew();
64    }
65  
66    private Filter basicFilterNew() {
67      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
68        CompareOp.GREATER_OR_EQUAL, VAL_2);
69    }
70  
71    private Filter substrFilterNew() {
72      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
73        CompareOp.EQUAL,
74        new SubstringComparator(QUICK_SUBSTR));
75    }
76  
77    private Filter regexFilterNew() {
78      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
79        CompareOp.EQUAL,
80        new RegexStringComparator(QUICK_REGEX));
81    }
82  
83    private void basicFilterTests(SingleColumnValueFilter filter)
84        throws Exception {
85      KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
86      assertTrue("basicFilter1", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
87      kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_3);
88      assertTrue("basicFilter2", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
89      kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_4);
90      assertTrue("basicFilter3", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
91      assertFalse("basicFilterNotNull", filter.filterRow());
92      filter.reset();
93      kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
94      assertTrue("basicFilter4", filter.filterKeyValue(kv) == Filter.ReturnCode.NEXT_ROW);
95      kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
96      assertTrue("basicFilter4", filter.filterKeyValue(kv) == Filter.ReturnCode.NEXT_ROW);
97      assertFalse("basicFilterAllRemaining", filter.filterAllRemaining());
98      assertTrue("basicFilterNotNull", filter.filterRow());
99      filter.reset();
100     filter.setLatestVersionOnly(false);
101     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
102     assertTrue("basicFilter5", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
103     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
104     assertTrue("basicFilter5", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
105     assertFalse("basicFilterNotNull", filter.filterRow());
106   }
107 
108   private void substrFilterTests(Filter filter)
109       throws Exception {
110     KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
111       FULLSTRING_1);
112     assertTrue("substrTrue",
113       filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
114     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
115       FULLSTRING_2);
116     assertTrue("substrFalse", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
117     assertFalse("substrFilterAllRemaining", filter.filterAllRemaining());
118     assertFalse("substrFilterNotNull", filter.filterRow());
119   }
120 
121   private void regexFilterTests(Filter filter)
122       throws Exception {
123     KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
124       FULLSTRING_1);
125     assertTrue("regexTrue",
126       filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
127     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
128       FULLSTRING_2);
129     assertTrue("regexFalse", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
130     assertFalse("regexFilterAllRemaining", filter.filterAllRemaining());
131     assertFalse("regexFilterNotNull", filter.filterRow());
132   }
133 
134   private Filter serializationTest(Filter filter)
135       throws Exception {
136     // Decompose filter to bytes.
137     ByteArrayOutputStream stream = new ByteArrayOutputStream();
138     DataOutputStream out = new DataOutputStream(stream);
139     filter.write(out);
140     out.close();
141     byte[] buffer = stream.toByteArray();
142 
143     // Recompose filter.
144     DataInputStream in =
145       new DataInputStream(new ByteArrayInputStream(buffer));
146     Filter newFilter = new SingleColumnValueFilter();
147     newFilter.readFields(in);
148 
149     return newFilter;
150   }
151 
152   /**
153    * Tests identification of the stop row
154    * @throws Exception
155    */
156   public void testStop() throws Exception {
157     basicFilterTests((SingleColumnValueFilter)basicFilter);
158     substrFilterTests(substrFilter);
159     regexFilterTests(regexFilter);
160   }
161 
162   /**
163    * Tests serialization
164    * @throws Exception
165    */
166   public void testSerialization() throws Exception {
167     Filter newFilter = serializationTest(basicFilter);
168     basicFilterTests((SingleColumnValueFilter)newFilter);
169     newFilter = serializationTest(substrFilter);
170     substrFilterTests(newFilter);
171     newFilter = serializationTest(regexFilter);
172     regexFilterTests(newFilter);
173   }
174 
175   @org.junit.Rule
176   public org.apache.hadoop.hbase.ResourceCheckerJUnitRule cu =
177     new org.apache.hadoop.hbase.ResourceCheckerJUnitRule();
178 }
179