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  package org.apache.hadoop.hbase.filter;
20  
21  import static org.junit.Assert.assertFalse;
22  import static org.junit.Assert.assertTrue;
23  
24  import java.util.regex.Pattern;
25  
26  import org.apache.hadoop.hbase.KeyValue;
27  import org.apache.hadoop.hbase.SmallTests;
28  import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
29  import org.apache.hadoop.hbase.util.Bytes;
30  import org.junit.Before;
31  import org.junit.Test;
32  import org.junit.experimental.categories.Category;
33  
34  /**
35   * Tests the value filter
36   */
37  @Category(SmallTests.class)
38  public class TestSingleColumnValueFilter {
39    private static final byte[] ROW = Bytes.toBytes("test");
40    private static final byte[] COLUMN_FAMILY = Bytes.toBytes("test");
41    private static final byte [] COLUMN_QUALIFIER = Bytes.toBytes("foo");
42    private static final byte[] VAL_1 = Bytes.toBytes("a");
43    private static final byte[] VAL_2 = Bytes.toBytes("ab");
44    private static final byte[] VAL_3 = Bytes.toBytes("abc");
45    private static final byte[] VAL_4 = Bytes.toBytes("abcd");
46    private static final byte[] FULLSTRING_1 =
47      Bytes.toBytes("The quick brown fox jumps over the lazy dog.");
48    private static final byte[] FULLSTRING_2 =
49      Bytes.toBytes("The slow grey fox trips over the lazy dog.");
50    private static final String QUICK_SUBSTR = "quick";
51    private static final String QUICK_REGEX = ".+quick.+";
52    private static final Pattern QUICK_PATTERN = Pattern.compile("QuIcK", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
53  
54    Filter basicFilter;
55    Filter nullFilter;
56    Filter substrFilter;
57    Filter regexFilter;
58    Filter regexPatternFilter;
59  
60    @Before
61    public void setUp() throws Exception {
62      basicFilter = basicFilterNew();
63      nullFilter = nullFilterNew();
64      substrFilter = substrFilterNew();
65      regexFilter = regexFilterNew();
66      regexPatternFilter = regexFilterNew(QUICK_PATTERN);
67    }
68  
69    private Filter basicFilterNew() {
70      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
71        CompareOp.GREATER_OR_EQUAL, VAL_2);
72    }
73  
74    private Filter nullFilterNew() {
75      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER, CompareOp.NOT_EQUAL,
76          new NullComparator());
77    }
78  
79    private Filter substrFilterNew() {
80      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
81        CompareOp.EQUAL,
82        new SubstringComparator(QUICK_SUBSTR));
83    }
84  
85    private Filter regexFilterNew() {
86      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
87        CompareOp.EQUAL,
88        new RegexStringComparator(QUICK_REGEX));
89    }
90  
91    private Filter regexFilterNew(Pattern pattern) {
92      return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
93          CompareOp.EQUAL,
94          new RegexStringComparator(pattern.pattern(), pattern.flags()));
95    }
96  
97    private void basicFilterTests(SingleColumnValueFilter filter)
98        throws Exception {
99      KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
100     assertTrue("basicFilter1", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
101     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_3);
102     assertTrue("basicFilter2", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
103     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_4);
104     assertTrue("basicFilter3", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
105     assertFalse("basicFilterNotNull", filter.filterRow());
106     filter.reset();
107     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
108     assertTrue("basicFilter4", filter.filterKeyValue(kv) == Filter.ReturnCode.NEXT_ROW);
109     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
110     assertTrue("basicFilter4", filter.filterKeyValue(kv) == Filter.ReturnCode.NEXT_ROW);
111     assertFalse("basicFilterAllRemaining", filter.filterAllRemaining());
112     assertTrue("basicFilterNotNull", filter.filterRow());
113     filter.reset();
114     filter.setLatestVersionOnly(false);
115     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
116     assertTrue("basicFilter5", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
117     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
118     assertTrue("basicFilter5", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
119     assertFalse("basicFilterNotNull", filter.filterRow());
120   }
121 
122   private void nullFilterTests(Filter filter) throws Exception {
123     ((SingleColumnValueFilter) filter).setFilterIfMissing(true);
124     KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, FULLSTRING_1);
125     assertTrue("null1", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
126     assertFalse("null1FilterRow", filter.filterRow());
127     filter.reset();
128     kv = new KeyValue(ROW, COLUMN_FAMILY, Bytes.toBytes("qual2"), FULLSTRING_2);
129     assertTrue("null2", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
130     assertTrue("null2FilterRow", filter.filterRow());
131   }
132 
133   private void substrFilterTests(Filter filter)
134       throws Exception {
135     KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
136       FULLSTRING_1);
137     assertTrue("substrTrue",
138       filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
139     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
140       FULLSTRING_2);
141     assertTrue("substrFalse", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
142     assertFalse("substrFilterAllRemaining", filter.filterAllRemaining());
143     assertFalse("substrFilterNotNull", filter.filterRow());
144   }
145 
146   private void regexFilterTests(Filter filter)
147       throws Exception {
148     KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
149       FULLSTRING_1);
150     assertTrue("regexTrue",
151       filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
152     kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
153       FULLSTRING_2);
154     assertTrue("regexFalse", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
155     assertFalse("regexFilterAllRemaining", filter.filterAllRemaining());
156     assertFalse("regexFilterNotNull", filter.filterRow());
157   }
158 
159   private void regexPatternFilterTests(Filter filter)
160       throws Exception {
161     KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
162       FULLSTRING_1);
163     assertTrue("regexTrue",
164       filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
165     assertFalse("regexFilterAllRemaining", filter.filterAllRemaining());
166     assertFalse("regexFilterNotNull", filter.filterRow());
167   }
168 
169   private Filter serializationTest(Filter filter)
170       throws Exception {
171     // Decompose filter to bytes.
172     byte[] buffer = filter.toByteArray();
173 
174     // Recompose filter.
175     Filter newFilter = SingleColumnValueFilter.parseFrom(buffer);
176     return newFilter;
177   }
178 
179   /**
180    * Tests identification of the stop row
181    * @throws Exception
182    */
183   @Test
184   public void testStop() throws Exception {
185     basicFilterTests((SingleColumnValueFilter) basicFilter);
186     nullFilterTests(nullFilter);
187     substrFilterTests(substrFilter);
188     regexFilterTests(regexFilter);
189     regexPatternFilterTests(regexPatternFilter);
190   }
191 
192   /**
193    * Tests serialization
194    * @throws Exception
195    */
196   @Test
197   public void testSerialization() throws Exception {
198     Filter newFilter = serializationTest(basicFilter);
199     basicFilterTests((SingleColumnValueFilter)newFilter);
200     newFilter = serializationTest(nullFilter);
201     nullFilterTests(newFilter);
202     newFilter = serializationTest(substrFilter);
203     substrFilterTests(newFilter);
204     newFilter = serializationTest(regexFilter);
205     regexFilterTests(newFilter);
206     newFilter = serializationTest(regexPatternFilter);
207     regexPatternFilterTests(newFilter);
208   }
209 
210 }
211