1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
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
172 byte[] buffer = filter.toByteArray();
173
174
175 Filter newFilter = SingleColumnValueFilter.parseFrom(buffer);
176 return newFilter;
177 }
178
179
180
181
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
194
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