Skip to content

Commit

Permalink
HBASE-18769 Make CompareFilter use generic CompareOperator instead of
Browse files Browse the repository at this point in the history 
internal enum
  • Loading branch information
@saintstack
saintstack committed Sep 8, 2017
1 parent 3319101 commit b8e0a83
Show file tree
Hide file tree
Showing 39 changed files with 678 additions and 338 deletions.
3 changes: 1 addition & 2 deletions hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java
View file
Expand Up @@ -134,8 +134,7 @@ void batch(final List<? extends Row> actions, final Object[] results) throws IOE
*/ */
<R> void batchCallback( <R> void batchCallback(
final List<? extends Row> actions, final Object[] results, final Batch.Callback<R> callback final List<? extends Row> actions, final Object[] results, final Batch.Callback<R> callback
) ) throws IOException, InterruptedException;
throws IOException, InterruptedException;


/** /**
* Extracts certain cells from a given row. * Extracts certain cells from a given row.
Expand Down
128 changes: 112 additions & 16 deletions hbase-client/src/main/java/org/apache/hadoop/hbase/filter/CompareFilter.java
View file
Expand Up @@ -54,8 +54,9 @@ public abstract class CompareFilter extends FilterBase {
* Comparison operators. For filters only! * Comparison operators. For filters only!
* Use {@link CompareOperator} otherwise. * Use {@link CompareOperator} otherwise.
* It (intentionally) has at least the below enums with same names. * It (intentionally) has at least the below enums with same names.
* TODO: Replace with generic {@link CompareOperator} * @deprecated since 2.0.0. Will be removed in 3.0.0. Use {@link CompareOperator} instead.
*/ */
@Deprecated
@InterfaceAudience.Public @InterfaceAudience.Public
public enum CompareOp { public enum CompareOp {
/** less than */ /** less than */
Expand All @@ -74,25 +75,43 @@ public enum CompareOp {
NO_OP, NO_OP,
} }


protected CompareOp compareOp; protected CompareOperator op;
protected ByteArrayComparable comparator; protected ByteArrayComparable comparator;


/** /**
* Constructor. * Constructor.
* @param compareOp the compare op for row matching * @param compareOp the compare op for row matching
* @param comparator the comparator for row matching * @param comparator the comparator for row matching
* @deprecated Since 2.0.0. Will be removed in 3.0.0. Use other constructor.
*/ */
@Deprecated
public CompareFilter(final CompareOp compareOp, public CompareFilter(final CompareOp compareOp,
final ByteArrayComparable comparator) { final ByteArrayComparable comparator) {
this.compareOp = compareOp; this(CompareOperator.valueOf(compareOp.name()), comparator);
}

/**
* Constructor.
* @param op the compare op for row matching
* @param comparator the comparator for row matching
*/
public CompareFilter(final CompareOperator op,
final ByteArrayComparable comparator) {
this.op = op;
this.comparator = comparator; this.comparator = comparator;
} }


/** /**
* @return operator * @return operator
* @deprecated since 2.0.0. Will be removed in 3.0.0. Use {@link #getCompareOperator()} instead.
*/ */
@Deprecated
public CompareOp getOperator() { public CompareOp getOperator() {
return compareOp; return CompareOp.valueOf(op.name());
}

public CompareOperator getCompareOperator() {
return op;
} }


/** /**
Expand All @@ -108,6 +127,11 @@ public boolean filterRowKey(Cell cell) throws IOException {
return false; return false;
} }


/**
* @deprecated Since 2.0.0. Will be removed in 3.0.0.
* Use {@link #compareRow(CompareOperator, ByteArrayComparable, Cell)}
*/
@Deprecated
protected boolean compareRow(final CompareOp compareOp, final ByteArrayComparable comparator, protected boolean compareRow(final CompareOp compareOp, final ByteArrayComparable comparator,
final Cell cell) { final Cell cell) {
if (compareOp == CompareOp.NO_OP) { if (compareOp == CompareOp.NO_OP) {
Expand All @@ -117,6 +141,20 @@ protected boolean compareRow(final CompareOp compareOp, final ByteArrayComparabl
return compare(compareOp, compareResult); return compare(compareOp, compareResult);
} }


protected boolean compareRow(final CompareOperator op, final ByteArrayComparable comparator,
final Cell cell) {
if (op == CompareOperator.NO_OP) {
return true;
}
int compareResult = CellComparator.compareRow(cell, comparator);
return compare(op, compareResult);
}

/**
* @deprecated Since 2.0.0. Will be removed in 3.0.0.
* Use {@link #compareFamily(CompareOperator, ByteArrayComparable, Cell)}
*/
@Deprecated
protected boolean compareFamily(final CompareOp compareOp, final ByteArrayComparable comparator, protected boolean compareFamily(final CompareOp compareOp, final ByteArrayComparable comparator,
final Cell cell) { final Cell cell) {
if (compareOp == CompareOp.NO_OP) { if (compareOp == CompareOp.NO_OP) {
Expand All @@ -126,26 +164,66 @@ protected boolean compareFamily(final CompareOp compareOp, final ByteArrayCompar
return compare(compareOp, compareResult); return compare(compareOp, compareResult);
} }


protected boolean compareFamily(final CompareOperator op, final ByteArrayComparable comparator,
final Cell cell) {
if (op == CompareOperator.NO_OP) {
return true;
}
int compareResult = CellComparator.compareFamily(cell, comparator);
return compare(op, compareResult);
}

/**
* @deprecated Since 2.0.0. Will be removed in 3.0.0.
* Use {@link #compareQualifier(CompareOperator, ByteArrayComparable, Cell)}
*/
@Deprecated
protected boolean compareQualifier(final CompareOp compareOp, protected boolean compareQualifier(final CompareOp compareOp,
final ByteArrayComparable comparator, final Cell cell) { final ByteArrayComparable comparator, final Cell cell) {
// We do not call through to the non-deprecated method for perf reasons.
if (compareOp == CompareOp.NO_OP) { if (compareOp == CompareOp.NO_OP) {
return true; return true;
} }
int compareResult = CellComparator.compareQualifier(cell, comparator); int compareResult = CellComparator.compareQualifier(cell, comparator);
return compare(compareOp, compareResult); return compare(compareOp, compareResult);
} }


protected boolean compareQualifier(final CompareOperator op,
final ByteArrayComparable comparator, final Cell cell) {
// We do not call through to the non-deprecated method for perf reasons.
if (op == CompareOperator.NO_OP) {
return true;
}
int compareResult = CellComparator.compareQualifier(cell, comparator);
return compare(op, compareResult);
}

/**
* @deprecated Since 2.0.0. Will be removed in 3.0.0.
* Use {@link #compareValue(CompareOperator, ByteArrayComparable, Cell)}
*/
@Deprecated
protected boolean compareValue(final CompareOp compareOp, final ByteArrayComparable comparator, protected boolean compareValue(final CompareOp compareOp, final ByteArrayComparable comparator,
final Cell cell) { final Cell cell) {
// We do not call through to the non-deprecated method for perf reasons.
if (compareOp == CompareOp.NO_OP) { if (compareOp == CompareOp.NO_OP) {
return true; return true;
} }
int compareResult = CellComparator.compareValue(cell, comparator); int compareResult = CellComparator.compareValue(cell, comparator);
return compare(compareOp, compareResult); return compare(compareOp, compareResult);
} }


private boolean compare(final CompareOp compareOp, int compareResult) { protected boolean compareValue(final CompareOperator op, final ByteArrayComparable comparator,
switch (compareOp) { final Cell cell) {
if (op == CompareOperator.NO_OP) {
return true;
}
int compareResult = CellComparator.compareValue(cell, comparator);
return compare(op, compareResult);
}

static boolean compare(final CompareOp op, int compareResult) {
switch (op) {
case LESS: case LESS:
return compareResult <= 0; return compareResult <= 0;
case LESS_OR_EQUAL: case LESS_OR_EQUAL:
Expand All @@ -159,28 +237,47 @@ private boolean compare(final CompareOp compareOp, int compareResult) {
case GREATER: case GREATER:
return compareResult >= 0; return compareResult >= 0;
default: default:
throw new RuntimeException("Unknown Compare op " + compareOp.name()); throw new RuntimeException("Unknown Compare op " + op.name());
}
}

static boolean compare(final CompareOperator op, int compareResult) {
switch (op) {
case LESS:
return compareResult <= 0;
case LESS_OR_EQUAL:
return compareResult < 0;
case EQUAL:
return compareResult != 0;
case NOT_EQUAL:
return compareResult == 0;
case GREATER_OR_EQUAL:
return compareResult > 0;
case GREATER:
return compareResult >= 0;
default:
throw new RuntimeException("Unknown Compare op " + op.name());
} }
} }


// returns an array of heterogeneous objects // returns an array of heterogeneous objects
public static ArrayList<Object> extractArguments(ArrayList<byte []> filterArguments) { public static ArrayList<Object> extractArguments(ArrayList<byte []> filterArguments) {
Preconditions.checkArgument(filterArguments.size() == 2, Preconditions.checkArgument(filterArguments.size() == 2,
"Expected 2 but got: %s", filterArguments.size()); "Expected 2 but got: %s", filterArguments.size());
CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(0)); CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(0));
ByteArrayComparable comparator = ParseFilter.createComparator( ByteArrayComparable comparator = ParseFilter.createComparator(
ParseFilter.removeQuotesFromByteArray(filterArguments.get(1))); ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)));


if (comparator instanceof RegexStringComparator || if (comparator instanceof RegexStringComparator ||
comparator instanceof SubstringComparator) { comparator instanceof SubstringComparator) {
if (compareOp != CompareOp.EQUAL && if (op != CompareOperator.EQUAL &&
compareOp != CompareOp.NOT_EQUAL) { op != CompareOperator.NOT_EQUAL) {
throw new IllegalArgumentException ("A regexstring comparator and substring comparator" + throw new IllegalArgumentException ("A regexstring comparator and substring comparator" +
" can only be used with EQUAL and NOT_EQUAL"); " can only be used with EQUAL and NOT_EQUAL");
} }
} }
ArrayList<Object> arguments = new ArrayList<>(2); ArrayList<Object> arguments = new ArrayList<>(2);
arguments.add(compareOp); arguments.add(op);
arguments.add(comparator); arguments.add(comparator);
return arguments; return arguments;
} }
Expand All @@ -191,7 +288,7 @@ public static ArrayList<Object> extractArguments(ArrayList<byte []> filterArgume
FilterProtos.CompareFilter convert() { FilterProtos.CompareFilter convert() {
FilterProtos.CompareFilter.Builder builder = FilterProtos.CompareFilter.Builder builder =
FilterProtos.CompareFilter.newBuilder(); FilterProtos.CompareFilter.newBuilder();
HBaseProtos.CompareType compareOp = CompareType.valueOf(this.compareOp.name()); HBaseProtos.CompareType compareOp = CompareType.valueOf(this.op.name());
builder.setCompareOp(compareOp); builder.setCompareOp(compareOp);
if (this.comparator != null) builder.setComparator(ProtobufUtil.toComparator(this.comparator)); if (this.comparator != null) builder.setComparator(ProtobufUtil.toComparator(this.comparator));
return builder.build(); return builder.build();
Expand All @@ -206,9 +303,8 @@ FilterProtos.CompareFilter convert() {
boolean areSerializedFieldsEqual(Filter o) { boolean areSerializedFieldsEqual(Filter o) {
if (o == this) return true; if (o == this) return true;
if (!(o instanceof CompareFilter)) return false; if (!(o instanceof CompareFilter)) return false;

CompareFilter other = (CompareFilter)o; CompareFilter other = (CompareFilter)o;
return this.getOperator().equals(other.getOperator()) && return this.getCompareOperator().equals(other.getCompareOperator()) &&
(this.getComparator() == other.getComparator() (this.getComparator() == other.getComparator()
|| this.getComparator().areSerializedFieldsEqual(other.getComparator())); || this.getComparator().areSerializedFieldsEqual(other.getComparator()));
} }
Expand All @@ -217,7 +313,7 @@ boolean areSerializedFieldsEqual(Filter o) {
public String toString() { public String toString() {
return String.format("%s (%s, %s)", return String.format("%s (%s, %s)",
this.getClass().getSimpleName(), this.getClass().getSimpleName(),
this.compareOp.name(), this.op.name(),
Bytes.toStringBinary(this.comparator.getValue())); Bytes.toStringBinary(this.comparator.getValue()));
} }
} }
40 changes: 32 additions & 8 deletions hbase-client/src/main/java/org/apache/hadoop/hbase/filter/DependentColumnFilter.java
View file
Expand Up @@ -26,6 +26,7 @@


import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil; import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.exceptions.DeserializationException; import org.apache.hadoop.hbase.exceptions.DeserializationException;
import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil;
Expand Down Expand Up @@ -64,12 +65,35 @@ public class DependentColumnFilter extends CompareFilter {
* @param dropDependentColumn whether the column should be discarded after * @param dropDependentColumn whether the column should be discarded after
* @param valueCompareOp comparison op * @param valueCompareOp comparison op
* @param valueComparator comparator * @param valueComparator comparator
* @deprecated Since 2.0.0. Will be removed in 3.0.0. Use
* {@link #DependentColumnFilter(byte[], byte[], boolean, CompareOperator, ByteArrayComparable)}
* instead.
*/ */
@Deprecated
public DependentColumnFilter(final byte [] family, final byte[] qualifier, public DependentColumnFilter(final byte [] family, final byte[] qualifier,
final boolean dropDependentColumn, final CompareOp valueCompareOp, final boolean dropDependentColumn, final CompareOp valueCompareOp,
final ByteArrayComparable valueComparator) { final ByteArrayComparable valueComparator) {
// set up the comparator this(family, qualifier, dropDependentColumn, CompareOperator.valueOf(valueCompareOp.name()),
super(valueCompareOp, valueComparator); valueComparator);
}

/**
* Build a dependent column filter with value checking
* dependent column varies will be compared using the supplied
* compareOp and comparator, for usage of which
* refer to {@link CompareFilter}
*
* @param family dependent column family
* @param qualifier dependent column qualifier
* @param dropDependentColumn whether the column should be discarded after
* @param op Value comparison op
* @param valueComparator comparator
*/
public DependentColumnFilter(final byte [] family, final byte[] qualifier,
final boolean dropDependentColumn, final CompareOperator op,
final ByteArrayComparable valueComparator) {
// set up the comparator
super(op, valueComparator);
this.columnFamily = family; this.columnFamily = family;
this.columnQualifier = qualifier; this.columnQualifier = qualifier;
this.dropDependentColumn = dropDependentColumn; this.dropDependentColumn = dropDependentColumn;
Expand Down Expand Up @@ -140,7 +164,7 @@ public ReturnCode filterKeyValue(Cell c) {
} }
// If it doesn't pass the op, skip it // If it doesn't pass the op, skip it
if (comparator != null if (comparator != null
&& compareValue(compareOp, comparator, c)) && compareValue(getCompareOperator(), comparator, c))
return ReturnCode.SKIP; return ReturnCode.SKIP;


stampSet.add(c.getTimestamp()); stampSet.add(c.getTimestamp());
Expand Down Expand Up @@ -194,11 +218,11 @@ public static Filter createFilterFromArguments(ArrayList<byte []> filterArgument
byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2));
CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(3)); CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(3));
ByteArrayComparable comparator = ParseFilter.createComparator( ByteArrayComparable comparator = ParseFilter.createComparator(
ParseFilter.removeQuotesFromByteArray(filterArguments.get(4))); ParseFilter.removeQuotesFromByteArray(filterArguments.get(4)));
return new DependentColumnFilter(family, qualifier, dropDependentColumn, return new DependentColumnFilter(family, qualifier, dropDependentColumn,
compareOp, comparator); op, comparator);
} else { } else {
throw new IllegalArgumentException("Expected 2, 3 or 5 but got: " + filterArguments.size()); throw new IllegalArgumentException("Expected 2, 3 or 5 but got: " + filterArguments.size());
} }
Expand Down Expand Up @@ -235,8 +259,8 @@ public static DependentColumnFilter parseFrom(final byte [] pbBytes)
} catch (InvalidProtocolBufferException e) { } catch (InvalidProtocolBufferException e) {
throw new DeserializationException(e); throw new DeserializationException(e);
} }
final CompareOp valueCompareOp = final CompareOperator valueCompareOp =
CompareOp.valueOf(proto.getCompareFilter().getCompareOp().name()); CompareOperator.valueOf(proto.getCompareFilter().getCompareOp().name());
ByteArrayComparable valueComparator = null; ByteArrayComparable valueComparator = null;
try { try {
if (proto.getCompareFilter().hasComparator()) { if (proto.getCompareFilter().hasComparator()) {
Expand Down Expand Up @@ -276,7 +300,7 @@ public String toString() {
Bytes.toStringBinary(this.columnFamily), Bytes.toStringBinary(this.columnFamily),
Bytes.toStringBinary(this.columnQualifier), Bytes.toStringBinary(this.columnQualifier),
this.dropDependentColumn, this.dropDependentColumn,
this.compareOp.name(), this.op.name(),
this.comparator != null ? Bytes.toStringBinary(this.comparator.getValue()) : "null"); this.comparator != null ? Bytes.toStringBinary(this.comparator.getValue()) : "null");
} }
} }

0 comments on commit b8e0a83

Please sign in to comment.