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 java.io.IOException;
23 import java.util.ArrayList;
24
25 import org.apache.hadoop.hbase.util.ByteStringer;
26 import org.apache.commons.logging.Log;
27 import org.apache.commons.logging.LogFactory;
28 import org.apache.hadoop.hbase.classification.InterfaceAudience;
29 import org.apache.hadoop.hbase.classification.InterfaceStability;
30 import org.apache.hadoop.hbase.Cell;
31 import org.apache.hadoop.hbase.CellUtil;
32 import org.apache.hadoop.hbase.exceptions.DeserializationException;
33 import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
34 import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
35 import org.apache.hadoop.hbase.protobuf.generated.FilterProtos;
36 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos;
37 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.CompareType;
38 import org.apache.hadoop.hbase.util.Bytes;
39
40 import com.google.common.base.Preconditions;
41 import com.google.protobuf.InvalidProtocolBufferException;
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71 @InterfaceAudience.Public
72 @InterfaceStability.Stable
73 public class SingleColumnValueFilter extends FilterBase {
74 static final Log LOG = LogFactory.getLog(SingleColumnValueFilter.class);
75
76 protected byte [] columnFamily;
77 protected byte [] columnQualifier;
78 protected CompareOp compareOp;
79 protected ByteArrayComparable comparator;
80 protected boolean foundColumn = false;
81 protected boolean matchedColumn = false;
82 protected boolean filterIfMissing = false;
83 protected boolean latestVersionOnly = true;
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99 public SingleColumnValueFilter(final byte [] family, final byte [] qualifier,
100 final CompareOp compareOp, final byte[] value) {
101 this(family, qualifier, compareOp, new BinaryComparator(value));
102 }
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118 public SingleColumnValueFilter(final byte [] family, final byte [] qualifier,
119 final CompareOp compareOp, final ByteArrayComparable comparator) {
120 this.columnFamily = family;
121 this.columnQualifier = qualifier;
122 this.compareOp = compareOp;
123 this.comparator = comparator;
124 }
125
126
127
128
129
130
131
132
133
134
135 protected SingleColumnValueFilter(final byte[] family, final byte[] qualifier,
136 final CompareOp compareOp, ByteArrayComparable comparator, final boolean filterIfMissing,
137 final boolean latestVersionOnly) {
138 this(family, qualifier, compareOp, comparator);
139 this.filterIfMissing = filterIfMissing;
140 this.latestVersionOnly = latestVersionOnly;
141 }
142
143
144
145
146 public CompareOp getOperator() {
147 return compareOp;
148 }
149
150
151
152
153 public ByteArrayComparable getComparator() {
154 return comparator;
155 }
156
157
158
159
160 public byte[] getFamily() {
161 return columnFamily;
162 }
163
164
165
166
167 public byte[] getQualifier() {
168 return columnQualifier;
169 }
170
171 @Override
172 public ReturnCode filterKeyValue(Cell c) {
173 if (this.matchedColumn) {
174
175 return ReturnCode.INCLUDE;
176 } else if (this.latestVersionOnly && this.foundColumn) {
177
178 return ReturnCode.NEXT_ROW;
179 }
180 if (!CellUtil.matchingColumn(c, this.columnFamily, this.columnQualifier)) {
181 return ReturnCode.INCLUDE;
182 }
183 foundColumn = true;
184 if (filterColumnValue(c.getValueArray(), c.getValueOffset(), c.getValueLength())) {
185 return this.latestVersionOnly? ReturnCode.NEXT_ROW: ReturnCode.INCLUDE;
186 }
187 this.matchedColumn = true;
188 return ReturnCode.INCLUDE;
189 }
190
191
192
193 @Override
194 public Cell transformCell(Cell v) {
195 return v;
196 }
197
198 private boolean filterColumnValue(final byte [] data, final int offset,
199 final int length) {
200 int compareResult = this.comparator.compareTo(data, offset, length);
201 switch (this.compareOp) {
202 case LESS:
203 return compareResult <= 0;
204 case LESS_OR_EQUAL:
205 return compareResult < 0;
206 case EQUAL:
207 return compareResult != 0;
208 case NOT_EQUAL:
209 return compareResult == 0;
210 case GREATER_OR_EQUAL:
211 return compareResult > 0;
212 case GREATER:
213 return compareResult >= 0;
214 default:
215 throw new RuntimeException("Unknown Compare op " + compareOp.name());
216 }
217 }
218
219 public boolean filterRow() {
220
221
222 return this.foundColumn? !this.matchedColumn: this.filterIfMissing;
223 }
224
225 public boolean hasFilterRow() {
226 return true;
227 }
228
229 public void reset() {
230 foundColumn = false;
231 matchedColumn = false;
232 }
233
234
235
236
237
238
239 public boolean getFilterIfMissing() {
240 return filterIfMissing;
241 }
242
243
244
245
246
247
248
249
250
251 public void setFilterIfMissing(boolean filterIfMissing) {
252 this.filterIfMissing = filterIfMissing;
253 }
254
255
256
257
258
259
260
261
262 public boolean getLatestVersionOnly() {
263 return latestVersionOnly;
264 }
265
266
267
268
269
270
271
272
273 public void setLatestVersionOnly(boolean latestVersionOnly) {
274 this.latestVersionOnly = latestVersionOnly;
275 }
276
277 public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
278 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
279 "Expected 4 or 6 but got: %s", filterArguments.size());
280 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
281 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
282 CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(2));
283 ByteArrayComparable comparator = ParseFilter.createComparator(
284 ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
285
286 if (comparator instanceof RegexStringComparator ||
287 comparator instanceof SubstringComparator) {
288 if (compareOp != CompareOp.EQUAL &&
289 compareOp != CompareOp.NOT_EQUAL) {
290 throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
291 "can only be used with EQUAL and NOT_EQUAL");
292 }
293 }
294
295 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
296 compareOp, comparator);
297
298 if (filterArguments.size() == 6) {
299 boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
300 boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
301 filter.setFilterIfMissing(filterIfMissing);
302 filter.setLatestVersionOnly(latestVersionOnly);
303 }
304 return filter;
305 }
306
307 FilterProtos.SingleColumnValueFilter convert() {
308 FilterProtos.SingleColumnValueFilter.Builder builder =
309 FilterProtos.SingleColumnValueFilter.newBuilder();
310 if (this.columnFamily != null) {
311 builder.setColumnFamily(ByteStringer.wrap(this.columnFamily));
312 }
313 if (this.columnQualifier != null) {
314 builder.setColumnQualifier(ByteStringer.wrap(this.columnQualifier));
315 }
316 HBaseProtos.CompareType compareOp = CompareType.valueOf(this.compareOp.name());
317 builder.setCompareOp(compareOp);
318 builder.setComparator(ProtobufUtil.toComparator(this.comparator));
319 builder.setFilterIfMissing(this.filterIfMissing);
320 builder.setLatestVersionOnly(this.latestVersionOnly);
321
322 return builder.build();
323 }
324
325
326
327
328 public byte [] toByteArray() {
329 return convert().toByteArray();
330 }
331
332
333
334
335
336
337
338 public static SingleColumnValueFilter parseFrom(final byte [] pbBytes)
339 throws DeserializationException {
340 FilterProtos.SingleColumnValueFilter proto;
341 try {
342 proto = FilterProtos.SingleColumnValueFilter.parseFrom(pbBytes);
343 } catch (InvalidProtocolBufferException e) {
344 throw new DeserializationException(e);
345 }
346
347 final CompareOp compareOp =
348 CompareOp.valueOf(proto.getCompareOp().name());
349 final ByteArrayComparable comparator;
350 try {
351 comparator = ProtobufUtil.toComparator(proto.getComparator());
352 } catch (IOException ioe) {
353 throw new DeserializationException(ioe);
354 }
355
356 return new SingleColumnValueFilter(proto.hasColumnFamily() ? proto.getColumnFamily()
357 .toByteArray() : null, proto.hasColumnQualifier() ? proto.getColumnQualifier()
358 .toByteArray() : null, compareOp, comparator, proto.getFilterIfMissing(), proto
359 .getLatestVersionOnly());
360 }
361
362
363
364
365
366
367 boolean areSerializedFieldsEqual(Filter o) {
368 if (o == this) return true;
369 if (!(o instanceof SingleColumnValueFilter)) return false;
370
371 SingleColumnValueFilter other = (SingleColumnValueFilter)o;
372 return Bytes.equals(this.getFamily(), other.getFamily())
373 && Bytes.equals(this.getQualifier(), other.getQualifier())
374 && this.compareOp.equals(other.compareOp)
375 && this.getComparator().areSerializedFieldsEqual(other.getComparator())
376 && this.getFilterIfMissing() == other.getFilterIfMissing()
377 && this.getLatestVersionOnly() == other.getLatestVersionOnly();
378 }
379
380
381
382
383
384
385 public boolean isFamilyEssential(byte[] name) {
386 return !this.filterIfMissing || Bytes.equals(name, this.columnFamily);
387 }
388
389 @Override
390 public String toString() {
391 return String.format("%s (%s, %s, %s, %s)",
392 this.getClass().getSimpleName(), Bytes.toStringBinary(this.columnFamily),
393 Bytes.toStringBinary(this.columnQualifier), this.compareOp.name(),
394 Bytes.toStringBinary(this.comparator.getValue()));
395 }
396 }