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