1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.filter;
21
22 import static org.junit.Assert.assertTrue;
23
24 import java.util.ArrayList;
25 import java.util.LinkedList;
26 import java.util.List;
27 import java.util.TreeSet;
28
29 import org.apache.hadoop.hbase.testclassification.SmallTests;
30 import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
31 import org.apache.hadoop.hbase.filter.MultiRowRangeFilter.RowRange;
32 import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
33 import org.apache.hadoop.hbase.util.Bytes;
34 import org.apache.hadoop.hbase.util.Pair;
35 import org.junit.Test;
36 import org.junit.experimental.categories.Category;
37
38 @Category(SmallTests.class)
39 public class TestFilterSerialization {
40
41 @Test
42 public void testColumnCountGetFilter() throws Exception {
43 ColumnCountGetFilter columnCountGetFilter = new ColumnCountGetFilter(1);
44 assertTrue(columnCountGetFilter.areSerializedFieldsEqual(
45 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnCountGetFilter))));
46 }
47
48 @Test
49 public void testColumnPaginationFilter() throws Exception {
50 ColumnPaginationFilter columnPaginationFilter = new ColumnPaginationFilter(1,7);
51 assertTrue(columnPaginationFilter.areSerializedFieldsEqual(
52 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPaginationFilter))));
53 }
54
55 @Test
56 public void testColumnPrefixFilter() throws Exception {
57
58 ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
59 assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
60 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
61
62
63 columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
64 assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
65 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
66 }
67
68 @Test
69 public void testColumnRangeFilter() throws Exception {
70
71 ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(null, true, null, false);
72 assertTrue(columnRangeFilter.areSerializedFieldsEqual(
73 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
74
75
76 columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("a"), false, Bytes.toBytes("b"), true);
77 assertTrue(columnRangeFilter.areSerializedFieldsEqual(
78 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
79 }
80
81 @Test
82 public void testDependentColumnFilter() throws Exception {
83
84 DependentColumnFilter dependentColumnFilter = new DependentColumnFilter(null, null);
85 assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
86 ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
87
88
89 dependentColumnFilter = new DependentColumnFilter(Bytes.toBytes("family"),
90 Bytes.toBytes("qual"), true, CompareOp.GREATER_OR_EQUAL,
91 new BitComparator(Bytes.toBytes("bitComparator"), BitComparator.BitwiseOp.OR));
92 assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
93 ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
94 }
95
96 @Test
97 public void testFamilyFilter() throws Exception {
98 FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL,
99 new BinaryPrefixComparator(Bytes.toBytes("testValueOne")));
100 assertTrue(familyFilter.areSerializedFieldsEqual(
101 ProtobufUtil.toFilter(ProtobufUtil.toFilter(familyFilter))));
102 }
103
104 @Test
105 public void testFilterList() throws Exception {
106
107 FilterList filterList = new FilterList(new LinkedList<Filter>());
108 assertTrue(filterList.areSerializedFieldsEqual(
109 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
110
111
112 LinkedList<Filter> list = new LinkedList<Filter>();
113 list.add(new ColumnCountGetFilter(1));
114 list.add(new RowFilter(CompareFilter.CompareOp.EQUAL,
115 new SubstringComparator("testFilterList")));
116 assertTrue(filterList.areSerializedFieldsEqual(
117 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
118 }
119
120 @Test
121 public void testFilterWrapper() throws Exception {
122 FilterWrapper filterWrapper =
123 new FilterWrapper(
124 new ColumnRangeFilter(Bytes.toBytes("e"), false, Bytes.toBytes("f"), true));
125 assertTrue(filterWrapper.areSerializedFieldsEqual(
126 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterWrapper))));
127 }
128
129 @Test
130 public void testFirstKeyValueMatchingQualifiersFilter() throws Exception {
131
132 TreeSet<byte []> set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
133 FirstKeyValueMatchingQualifiersFilter firstKeyValueMatchingQualifiersFilter =
134 new FirstKeyValueMatchingQualifiersFilter(set);
135 assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
136 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
137
138
139 set.add(Bytes.toBytes("col0"));
140 set.add(Bytes.toBytes("col1"));
141 firstKeyValueMatchingQualifiersFilter =
142 new FirstKeyValueMatchingQualifiersFilter(set);
143 assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
144 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
145 }
146
147 @Test
148 public void testFirstKeyOnlyFilter() throws Exception {
149 FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
150 assertTrue(firstKeyOnlyFilter.areSerializedFieldsEqual(
151 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyOnlyFilter))));
152 }
153
154 @Test
155 public void testFuzzyRowFilter() throws Exception {
156 LinkedList<Pair<byte[], byte[]>> fuzzyList = new LinkedList<Pair<byte[], byte[]>>();
157 fuzzyList.add(new Pair<byte[], byte[]>(Bytes.toBytes("999"),new byte[] {0, 0, 1}));
158 fuzzyList.add(new Pair<byte[], byte[]>(Bytes.toBytes("abcd"),new byte[] {1, 0, 1, 1}));
159 FuzzyRowFilter fuzzyRowFilter = new FuzzyRowFilter(fuzzyList);
160 assertTrue(fuzzyRowFilter.areSerializedFieldsEqual(
161 ProtobufUtil.toFilter(ProtobufUtil.toFilter(fuzzyRowFilter))));
162 }
163
164 @Test
165 public void testInclusiveStopFilter() throws Exception {
166
167 InclusiveStopFilter inclusiveStopFilter = new InclusiveStopFilter(null);
168 assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
169 ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
170
171
172 inclusiveStopFilter = new InclusiveStopFilter(Bytes.toBytes("inclusiveStopFilter"));
173 assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
174 ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
175 }
176
177 @Test
178 public void testKeyOnlyFilter() throws Exception {
179
180 KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true);
181 assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
182 ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
183
184
185 keyOnlyFilter = new KeyOnlyFilter();
186 assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
187 ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
188 }
189
190 @Test
191 public void testMultipleColumnPrefixFilter() throws Exception {
192
193 byte [][] prefixes = null;
194 MultipleColumnPrefixFilter multipleColumnPrefixFilter =
195 new MultipleColumnPrefixFilter(prefixes);
196 assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
197 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
198
199
200 prefixes = new byte[2][];
201 prefixes[0] = Bytes.toBytes("a");
202 prefixes[1] = Bytes.toBytes("");
203 multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(prefixes);
204 assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
205 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
206 }
207
208 @Test
209 public void testPageFilter() throws Exception {
210 PageFilter pageFilter = new PageFilter(6);
211 assertTrue(pageFilter.areSerializedFieldsEqual(
212 ProtobufUtil.toFilter(ProtobufUtil.toFilter(pageFilter))));
213 }
214
215 @Test
216 public void testPrefixFilter() throws Exception {
217
218 PrefixFilter prefixFilter = new PrefixFilter(null);
219 assertTrue(prefixFilter.areSerializedFieldsEqual(
220 ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
221
222
223 prefixFilter = new PrefixFilter(Bytes.toBytes("abc"));
224 assertTrue(prefixFilter.areSerializedFieldsEqual(
225 ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
226 }
227
228 @Test
229 public void testQualifierFilter() throws Exception {
230 QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL,
231 new NullComparator());
232 assertTrue(qualifierFilter.areSerializedFieldsEqual(
233 ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter))));
234 }
235
236 @Test
237 public void testRandomRowFilter() throws Exception {
238 RandomRowFilter randomRowFilter = new RandomRowFilter((float)0.1);
239 assertTrue(randomRowFilter.areSerializedFieldsEqual(
240 ProtobufUtil.toFilter(ProtobufUtil.toFilter(randomRowFilter))));
241 }
242
243 @Test
244 public void testRowFilter() throws Exception {
245 RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,
246 new SubstringComparator("testRowFilter"));
247 assertTrue(rowFilter.areSerializedFieldsEqual(
248 ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter))));
249 }
250
251 @Test
252 public void testSingleColumnValueExcludeFilter() throws Exception {
253
254 SingleColumnValueExcludeFilter singleColumnValueExcludeFilter =
255 new SingleColumnValueExcludeFilter(null, null,
256 CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes("value"));
257 assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
258 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
259
260
261 singleColumnValueExcludeFilter =
262 new SingleColumnValueExcludeFilter(Bytes.toBytes("fam"), Bytes.toBytes("qual"),
263 CompareFilter.CompareOp.LESS_OR_EQUAL, new NullComparator(), false, false);
264 assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
265 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
266 }
267
268 @Test
269 public void testSingleColumnValueFilter() throws Exception {
270
271 SingleColumnValueFilter singleColumnValueFilter =
272 new SingleColumnValueFilter(null, null,
273 CompareFilter.CompareOp.LESS, Bytes.toBytes("value"));
274 assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
275 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
276
277
278 singleColumnValueFilter =
279 new SingleColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"),
280 CompareFilter.CompareOp.NOT_EQUAL, new NullComparator(), true, true);
281 assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
282 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
283 }
284
285 @Test
286 public void testSkipFilter() throws Exception {
287 SkipFilter skipFilter = new SkipFilter(new PageFilter(6));
288 assertTrue(skipFilter.areSerializedFieldsEqual(
289 ProtobufUtil.toFilter(ProtobufUtil.toFilter(skipFilter))));
290 }
291
292 @Test
293 public void testTimestampsFilter() throws Exception {
294
295 TimestampsFilter timestampsFilter = new TimestampsFilter(new LinkedList<Long>());
296 assertTrue(timestampsFilter.areSerializedFieldsEqual(
297 ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
298
299
300 LinkedList<Long> list = new LinkedList<Long>();
301 list.add(new Long(System.currentTimeMillis()));
302 list.add(new Long(System.currentTimeMillis()));
303 timestampsFilter = new TimestampsFilter(list);
304 assertTrue(timestampsFilter.areSerializedFieldsEqual(
305 ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
306 }
307
308 @Test
309 public void testValueFilter() throws Exception {
310 ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.NO_OP,
311 new BinaryComparator(Bytes.toBytes("testValueOne")));
312 assertTrue(valueFilter.areSerializedFieldsEqual(
313 ProtobufUtil.toFilter(ProtobufUtil.toFilter(valueFilter))));
314 }
315
316 @Test
317 public void testWhileMatchFilter() throws Exception {
318 WhileMatchFilter whileMatchFilter =
319 new WhileMatchFilter(
320 new ColumnRangeFilter(Bytes.toBytes("c"), false, Bytes.toBytes("d"), true));
321 assertTrue(whileMatchFilter.areSerializedFieldsEqual(
322 ProtobufUtil.toFilter(ProtobufUtil.toFilter(whileMatchFilter))));
323 }
324
325 @Test
326 public void testMultiRowRangeFilter() throws Exception {
327 List<RowRange> ranges = new ArrayList<RowRange>();
328 ranges.add(new RowRange(Bytes.toBytes(30), true, Bytes.toBytes(40), false));
329 ranges.add(new RowRange(Bytes.toBytes(10), true, Bytes.toBytes(20), false));
330 ranges.add(new RowRange(Bytes.toBytes(60), true, Bytes.toBytes(70), false));
331
332 MultiRowRangeFilter multiRowRangeFilter =
333 new MultiRowRangeFilter(ranges);
334 assertTrue(multiRowRangeFilter.areSerializedFieldsEqual(
335 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multiRowRangeFilter))));
336 }
337 }