View Javadoc

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