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