001/** 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.filter; 019 020import static org.junit.Assert.assertTrue; 021 022import java.util.ArrayList; 023import java.util.LinkedList; 024import java.util.List; 025import java.util.TreeSet; 026import org.apache.hadoop.hbase.CompareOperator; 027import org.apache.hadoop.hbase.HBaseClassTestRule; 028import org.apache.hadoop.hbase.filter.MultiRowRangeFilter.RowRange; 029import org.apache.hadoop.hbase.testclassification.FilterTests; 030import org.apache.hadoop.hbase.testclassification.MediumTests; 031import org.apache.hadoop.hbase.util.Bytes; 032import org.apache.hadoop.hbase.util.Pair; 033import org.junit.ClassRule; 034import org.junit.Test; 035import org.junit.experimental.categories.Category; 036 037import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; 038 039@Category({FilterTests.class, MediumTests.class}) 040public class TestFilterSerialization { 041 042 @ClassRule 043 public static final HBaseClassTestRule CLASS_RULE = 044 HBaseClassTestRule.forClass(TestFilterSerialization.class); 045 046 @Test 047 public void testColumnCountGetFilter() throws Exception { 048 ColumnCountGetFilter columnCountGetFilter = new ColumnCountGetFilter(1); 049 assertTrue(columnCountGetFilter.areSerializedFieldsEqual( 050 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnCountGetFilter)))); 051 } 052 053 @Test 054 public void testColumnPaginationFilter() throws Exception { 055 ColumnPaginationFilter columnPaginationFilter = new ColumnPaginationFilter(1,7); 056 assertTrue(columnPaginationFilter.areSerializedFieldsEqual( 057 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPaginationFilter)))); 058 } 059 060 @Test 061 public void testColumnPrefixFilter() throws Exception { 062 // empty string 063 ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("")); 064 assertTrue(columnPrefixFilter.areSerializedFieldsEqual( 065 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter)))); 066 067 // non-empty string 068 columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("")); 069 assertTrue(columnPrefixFilter.areSerializedFieldsEqual( 070 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter)))); 071 } 072 073 @Test 074 public void testColumnRangeFilter() throws Exception { 075 // null columns 076 ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(null, true, null, false); 077 assertTrue(columnRangeFilter.areSerializedFieldsEqual( 078 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter)))); 079 080 // non-null columns 081 columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("a"), false, Bytes.toBytes("b"), true); 082 assertTrue(columnRangeFilter.areSerializedFieldsEqual( 083 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter)))); 084 } 085 086 @Test 087 public void testDependentColumnFilter() throws Exception { 088 // null column qualifier/family 089 DependentColumnFilter dependentColumnFilter = new DependentColumnFilter(null, null); 090 assertTrue(dependentColumnFilter.areSerializedFieldsEqual( 091 ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter)))); 092 093 // non-null column qualifier/family 094 dependentColumnFilter = new DependentColumnFilter(Bytes.toBytes("family"), 095 Bytes.toBytes("qual"), true, CompareOperator.GREATER_OR_EQUAL, 096 new BitComparator(Bytes.toBytes("bitComparator"), BitComparator.BitwiseOp.OR)); 097 assertTrue(dependentColumnFilter.areSerializedFieldsEqual( 098 ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter)))); 099 } 100 101 @Test 102 public void testFamilyFilter() throws Exception { 103 FamilyFilter familyFilter = new FamilyFilter(CompareOperator.EQUAL, 104 new BinaryPrefixComparator(Bytes.toBytes("testValueOne"))); 105 assertTrue(familyFilter.areSerializedFieldsEqual( 106 ProtobufUtil.toFilter(ProtobufUtil.toFilter(familyFilter)))); 107 } 108 109 @Test 110 public void testFilterList() throws Exception { 111 // empty filter list 112 FilterList filterList = new FilterList(new LinkedList<>()); 113 assertTrue(filterList.areSerializedFieldsEqual( 114 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList)))); 115 116 // non-empty filter list 117 LinkedList<Filter> list = new LinkedList<>(); 118 list.add(new ColumnCountGetFilter(1)); 119 list.add(new RowFilter(CompareOperator.EQUAL, 120 new SubstringComparator("testFilterList"))); 121 assertTrue(filterList.areSerializedFieldsEqual( 122 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList)))); 123 } 124 125 @Test 126 public void testFilterWrapper() throws Exception { 127 FilterWrapper filterWrapper = 128 new FilterWrapper( 129 new ColumnRangeFilter(Bytes.toBytes("e"), false, Bytes.toBytes("f"), true)); 130 assertTrue(filterWrapper.areSerializedFieldsEqual( 131 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterWrapper)))); 132 } 133 134 @SuppressWarnings("deprecation") 135 @Test 136 public void testFirstKeyValueMatchingQualifiersFilter() throws Exception { 137 // empty qualifiers set 138 TreeSet<byte []> set = new TreeSet<>(Bytes.BYTES_COMPARATOR); 139 FirstKeyValueMatchingQualifiersFilter firstKeyValueMatchingQualifiersFilter = 140 new FirstKeyValueMatchingQualifiersFilter(set); 141 assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual( 142 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter)))); 143 144 // non-empty qualifiers set 145 set.add(Bytes.toBytes("col0")); 146 set.add(Bytes.toBytes("col1")); 147 firstKeyValueMatchingQualifiersFilter = 148 new FirstKeyValueMatchingQualifiersFilter(set); 149 assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual( 150 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter)))); 151 } 152 153 @Test 154 public void testFirstKeyOnlyFilter() throws Exception { 155 FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter(); 156 assertTrue(firstKeyOnlyFilter.areSerializedFieldsEqual( 157 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyOnlyFilter)))); 158 } 159 160 @Test 161 public void testFuzzyRowFilter() throws Exception { 162 LinkedList<Pair<byte[], byte[]>> fuzzyList = new LinkedList<>(); 163 fuzzyList.add(new Pair<>(Bytes.toBytes("999"),new byte[] {0, 0, 1})); 164 fuzzyList.add(new Pair<>(Bytes.toBytes("abcd"),new byte[] {1, 0, 1, 1})); 165 FuzzyRowFilter fuzzyRowFilter = new FuzzyRowFilter(fuzzyList); 166 assertTrue(fuzzyRowFilter.areSerializedFieldsEqual( 167 ProtobufUtil.toFilter(ProtobufUtil.toFilter(fuzzyRowFilter)))); 168 } 169 170 @Test 171 public void testInclusiveStopFilter() throws Exception { 172 // InclusveStopFilter with null stopRowKey 173 InclusiveStopFilter inclusiveStopFilter = new InclusiveStopFilter(null); 174 assertTrue(inclusiveStopFilter.areSerializedFieldsEqual( 175 ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter)))); 176 177 // InclusveStopFilter with non-null stopRowKey 178 inclusiveStopFilter = new InclusiveStopFilter(Bytes.toBytes("inclusiveStopFilter")); 179 assertTrue(inclusiveStopFilter.areSerializedFieldsEqual( 180 ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter)))); 181 } 182 183 @Test 184 public void testKeyOnlyFilter() throws Exception { 185 // KeyOnlyFilter with lenAsVal 186 KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true); 187 assertTrue(keyOnlyFilter.areSerializedFieldsEqual( 188 ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter)))); 189 190 // KeyOnlyFilter without lenAsVal 191 keyOnlyFilter = new KeyOnlyFilter(); 192 assertTrue(keyOnlyFilter.areSerializedFieldsEqual( 193 ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter)))); 194 } 195 196 @Test 197 public void testMultipleColumnPrefixFilter() throws Exception { 198 // empty array 199 byte [][] prefixes = null; 200 MultipleColumnPrefixFilter multipleColumnPrefixFilter = 201 new MultipleColumnPrefixFilter(prefixes); 202 assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual( 203 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter)))); 204 205 // non-empty array 206 prefixes = new byte[2][]; 207 prefixes[0] = Bytes.toBytes("a"); 208 prefixes[1] = Bytes.toBytes(""); 209 multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(prefixes); 210 assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual( 211 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter)))); 212 } 213 214 @Test 215 public void testPageFilter() throws Exception { 216 PageFilter pageFilter = new PageFilter(6); 217 assertTrue(pageFilter.areSerializedFieldsEqual( 218 ProtobufUtil.toFilter(ProtobufUtil.toFilter(pageFilter)))); 219 } 220 221 @Test 222 public void testPrefixFilter() throws Exception { 223 // null prefix 224 PrefixFilter prefixFilter = new PrefixFilter(null); 225 assertTrue(prefixFilter.areSerializedFieldsEqual( 226 ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter)))); 227 228 // non-null prefix 229 prefixFilter = new PrefixFilter(Bytes.toBytes("abc")); 230 assertTrue(prefixFilter.areSerializedFieldsEqual( 231 ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter)))); 232 } 233 234 @Test 235 public void testQualifierFilter() throws Exception { 236 QualifierFilter qualifierFilter = new QualifierFilter(CompareOperator.EQUAL, 237 new NullComparator()); 238 assertTrue(qualifierFilter.areSerializedFieldsEqual( 239 ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter)))); 240 } 241 242 @Test 243 public void testRandomRowFilter() throws Exception { 244 RandomRowFilter randomRowFilter = new RandomRowFilter((float)0.1); 245 assertTrue(randomRowFilter.areSerializedFieldsEqual( 246 ProtobufUtil.toFilter(ProtobufUtil.toFilter(randomRowFilter)))); 247 } 248 249 @Test 250 public void testRowFilter() throws Exception { 251 RowFilter rowFilter = new RowFilter(CompareOperator.EQUAL, 252 new SubstringComparator("testRowFilter")); 253 assertTrue(rowFilter.areSerializedFieldsEqual( 254 ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter)))); 255 } 256 257 @Test 258 public void testSingleColumnValueExcludeFilter() throws Exception { 259 // null family/column SingleColumnValueExcludeFilter 260 SingleColumnValueExcludeFilter singleColumnValueExcludeFilter = 261 new SingleColumnValueExcludeFilter(null, null, 262 CompareOperator.GREATER_OR_EQUAL, Bytes.toBytes("value")); 263 assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual( 264 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter)))); 265 266 // non-null family/column SingleColumnValueFilter 267 singleColumnValueExcludeFilter = 268 new SingleColumnValueExcludeFilter(Bytes.toBytes("fam"), Bytes.toBytes("qual"), 269 CompareOperator.LESS_OR_EQUAL, new NullComparator(), false, false); 270 assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual( 271 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter)))); 272 } 273 274 @Test 275 public void testSingleColumnValueFilter() throws Exception { 276 // null family/column SingleColumnValueFilter 277 SingleColumnValueFilter singleColumnValueFilter = 278 new SingleColumnValueFilter(null, null, 279 CompareOperator.LESS, Bytes.toBytes("value")); 280 assertTrue(singleColumnValueFilter.areSerializedFieldsEqual( 281 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter)))); 282 283 // non-null family/column SingleColumnValueFilter 284 singleColumnValueFilter = 285 new SingleColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"), 286 CompareOperator.NOT_EQUAL, new NullComparator(), true, true); 287 assertTrue(singleColumnValueFilter.areSerializedFieldsEqual( 288 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter)))); 289 } 290 291 @Test 292 public void testSkipFilter() throws Exception { 293 SkipFilter skipFilter = new SkipFilter(new PageFilter(6)); 294 assertTrue(skipFilter.areSerializedFieldsEqual( 295 ProtobufUtil.toFilter(ProtobufUtil.toFilter(skipFilter)))); 296 } 297 298 @Test 299 public void testTimestampsFilter() throws Exception { 300 // Empty timestamp list 301 TimestampsFilter timestampsFilter = new TimestampsFilter(new LinkedList<>()); 302 assertTrue(timestampsFilter.areSerializedFieldsEqual( 303 ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter)))); 304 305 // Non-empty timestamp list 306 LinkedList<Long> list = new LinkedList<>(); 307 list.add(System.currentTimeMillis()); 308 list.add(System.currentTimeMillis()); 309 timestampsFilter = new TimestampsFilter(list); 310 assertTrue(timestampsFilter.areSerializedFieldsEqual( 311 ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter)))); 312 } 313 314 @Test 315 public void testValueFilter() throws Exception { 316 ValueFilter valueFilter = new ValueFilter(CompareOperator.NO_OP, 317 new BinaryComparator(Bytes.toBytes("testValueOne"))); 318 assertTrue(valueFilter.areSerializedFieldsEqual( 319 ProtobufUtil.toFilter(ProtobufUtil.toFilter(valueFilter)))); 320 } 321 322 @Test 323 public void testWhileMatchFilter() throws Exception { 324 WhileMatchFilter whileMatchFilter = 325 new WhileMatchFilter( 326 new ColumnRangeFilter(Bytes.toBytes("c"), false, Bytes.toBytes("d"), true)); 327 assertTrue(whileMatchFilter.areSerializedFieldsEqual( 328 ProtobufUtil.toFilter(ProtobufUtil.toFilter(whileMatchFilter)))); 329 } 330 331 @Test 332 public void testMultiRowRangeFilter() throws Exception { 333 List<RowRange> ranges = new ArrayList<>(); 334 ranges.add(new RowRange(Bytes.toBytes(30), true, Bytes.toBytes(40), false)); 335 ranges.add(new RowRange(Bytes.toBytes(10), true, Bytes.toBytes(20), false)); 336 ranges.add(new RowRange(Bytes.toBytes(60), true, Bytes.toBytes(70), false)); 337 338 MultiRowRangeFilter multiRowRangeFilter = 339 new MultiRowRangeFilter(ranges); 340 assertTrue(multiRowRangeFilter.areSerializedFieldsEqual( 341 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multiRowRangeFilter)))); 342 } 343 344 @Test 345 public void testColumnValueFilter() throws Exception { 346 ColumnValueFilter columnValueFilter = 347 new ColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"), 348 CompareOperator.EQUAL, Bytes.toBytes("value")); 349 assertTrue(columnValueFilter.areSerializedFieldsEqual( 350 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnValueFilter)))); 351 } 352}