Ali Alsuliman has submitted this change and it was merged. Change subject: [ASTERIXDB-2516][COMP] Change logical comparator interface ......................................................................
[ASTERIXDB-2516][COMP] Change logical comparator interface - user model changes: no - storage format changes: no - interface changes: yes Details: Use IPointable instead of bytes, offset, and length. Change-Id: I8150ccb4b18550fd8fba10ffca9c88d45ebc625b Reviewed-on: https://asterix-gerrit.ics.uci.edu/3263 Tested-by: Jenkins <[email protected]> Integration-Tests: Jenkins <[email protected]> Contrib: Jenkins <[email protected]> Reviewed-by: Till Westmann <[email protected]> --- M asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/common/ILogicalBinaryComparator.java M asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComparatorUtil.java M asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComplexBinaryComparator.java M asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalGenericBinaryComparator.java M asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalScalarBinaryComparator.java M asterixdb/asterix-runtime/src/main/java/org/apache/asterix/runtime/evaluators/comparisons/AbstractComparisonEvaluator.java 6 files changed, 105 insertions(+), 119 deletions(-) Approvals: Anon. E. Moose #1000171: Till Westmann: Looks good to me, approved Jenkins: Verified; ; Verified Objections: Jenkins: Violations found diff --git a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/common/ILogicalBinaryComparator.java b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/common/ILogicalBinaryComparator.java index 8b4348c..eb99918 100644 --- a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/common/ILogicalBinaryComparator.java +++ b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/common/ILogicalBinaryComparator.java @@ -20,6 +20,7 @@ import org.apache.asterix.om.base.IAObject; import org.apache.hyracks.api.exceptions.HyracksDataException; +import org.apache.hyracks.data.std.api.IPointable; public interface ILogicalBinaryComparator { @@ -36,12 +37,11 @@ return result < 0 ? Result.LT : (result == 0 ? Result.EQ : Result.GT); } - Result compare(byte[] leftBytes, int leftStart, int leftLen, byte[] rightBytes, int rightStart, int rightLen) - throws HyracksDataException; + Result compare(IPointable left, IPointable right) throws HyracksDataException; - Result compare(byte[] leftBytes, int leftStart, int leftLen, IAObject rightConstant); + Result compare(IPointable left, IAObject rightConstant); - Result compare(IAObject leftConstant, byte[] rightBytes, int rightStart, int rightLen); + Result compare(IAObject leftConstant, IPointable right); Result compare(IAObject leftConstant, IAObject rightConstant); } diff --git a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComparatorUtil.java b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComparatorUtil.java index 7b8b11d..d074010 100644 --- a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComparatorUtil.java +++ b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComparatorUtil.java @@ -28,6 +28,7 @@ import static org.apache.asterix.om.types.ATypeTag.TINYINT; import org.apache.asterix.dataflow.data.common.ILogicalBinaryComparator; +import org.apache.asterix.dataflow.data.common.ILogicalBinaryComparator.Result; import org.apache.asterix.dataflow.data.nontagged.serde.ADoubleSerializerDeserializer; import org.apache.asterix.dataflow.data.nontagged.serde.AFloatSerializerDeserializer; import org.apache.asterix.dataflow.data.nontagged.serde.AInt16SerializerDeserializer; @@ -45,6 +46,7 @@ import org.apache.asterix.om.types.ATypeTag; import org.apache.asterix.om.types.IAType; import org.apache.asterix.om.types.hierachy.ATypeHierarchy; +import org.apache.hyracks.data.std.api.IPointable; public class LogicalComparatorUtil { @@ -65,31 +67,30 @@ } } - static ILogicalBinaryComparator.Result returnMissingOrNullOrMismatch(ATypeTag leftTag, ATypeTag rightTag) { + static Result returnMissingOrNullOrMismatch(ATypeTag leftTag, ATypeTag rightTag) { if (leftTag == MISSING || rightTag == MISSING) { - return ILogicalBinaryComparator.Result.MISSING; + return Result.MISSING; } if (leftTag == NULL || rightTag == NULL) { - return ILogicalBinaryComparator.Result.NULL; + return Result.NULL; } if (!ATypeHierarchy.isCompatible(leftTag, rightTag)) { - return ILogicalBinaryComparator.Result.INCOMPARABLE; + return Result.INCOMPARABLE; } return null; } // checking that left and right are compatible has to be done before calling this - static ILogicalBinaryComparator.Result compareNumbers(ATypeTag leftTag, byte[] b1, int s1, ATypeTag rightTag, - byte[] b2, int s2) { + static Result compareNumbers(ATypeTag leftTag, IPointable left, ATypeTag rightTag, IPointable right) { int result; if (leftTag == DOUBLE || rightTag == DOUBLE) { - result = Double.compare(getDoubleValue(leftTag, b1, s1), getDoubleValue(rightTag, b2, s2)); + result = Double.compare(getDoubleValue(leftTag, left), getDoubleValue(rightTag, right)); } else if (leftTag == FLOAT || rightTag == FLOAT) { - result = Float.compare((float) getDoubleValue(leftTag, b1, s1), (float) getDoubleValue(rightTag, b2, s2)); + result = Float.compare((float) getDoubleValue(leftTag, left), (float) getDoubleValue(rightTag, right)); } else if (leftTag == BIGINT || rightTag == BIGINT) { - result = Long.compare(getLongValue(leftTag, b1, s1), getLongValue(rightTag, b2, s2)); + result = Long.compare(getLongValue(leftTag, left), getLongValue(rightTag, right)); } else if (leftTag == INTEGER || leftTag == SMALLINT || leftTag == TINYINT) { - result = Integer.compare((int) getLongValue(leftTag, b1, s1), (int) getLongValue(rightTag, b2, s2)); + result = Integer.compare((int) getLongValue(leftTag, left), (int) getLongValue(rightTag, right)); } else { return null; } @@ -97,18 +98,17 @@ } // checking that left and right are compatible has to be done before calling this - static ILogicalBinaryComparator.Result compareNumWithConstant(ATypeTag leftTag, byte[] b1, int s1, - IAObject rightConstant) { + static Result compareNumWithConstant(ATypeTag leftTag, IPointable left, IAObject rightConstant) { int result; ATypeTag rightTag = rightConstant.getType().getTypeTag(); if (leftTag == DOUBLE || rightTag == DOUBLE) { - result = Double.compare(getDoubleValue(leftTag, b1, s1), getConstantDouble(rightConstant)); + result = Double.compare(getDoubleValue(leftTag, left), getConstantDouble(rightConstant)); } else if (leftTag == FLOAT || rightTag == FLOAT) { - result = Float.compare((float) getDoubleValue(leftTag, b1, s1), (float) getConstantDouble(rightConstant)); + result = Float.compare((float) getDoubleValue(leftTag, left), (float) getConstantDouble(rightConstant)); } else if (leftTag == BIGINT || rightTag == BIGINT) { - result = Long.compare(getLongValue(leftTag, b1, s1), getConstantLong(rightConstant)); + result = Long.compare(getLongValue(leftTag, left), getConstantLong(rightConstant)); } else if (leftTag == INTEGER || leftTag == SMALLINT || leftTag == TINYINT) { - result = Integer.compare((int) getLongValue(leftTag, b1, s1), (int) getConstantLong(rightConstant)); + result = Integer.compare((int) getLongValue(leftTag, left), (int) getConstantLong(rightConstant)); } else { return null; } @@ -116,7 +116,7 @@ } // checking that left and right are compatible has to be done before calling this - static ILogicalBinaryComparator.Result compareConstants(IAObject leftConstant, IAObject rightConstant) { + static Result compareConstants(IAObject leftConstant, IAObject rightConstant) { int result; ATypeTag leftTag = leftConstant.getType().getTypeTag(); ATypeTag rightTag = rightConstant.getType().getTypeTag(); @@ -134,40 +134,38 @@ return ILogicalBinaryComparator.asResult(result); } - @SuppressWarnings("squid:S1226") // asking for introducing a new variable for s - private static double getDoubleValue(ATypeTag numericTag, byte[] b, int s) { - s++; + private static double getDoubleValue(ATypeTag numericTag, IPointable value) { + int start = value.getStartOffset() + 1; switch (numericTag) { case TINYINT: - return AInt8SerializerDeserializer.getByte(b, s); + return AInt8SerializerDeserializer.getByte(value.getByteArray(), start); case SMALLINT: - return AInt16SerializerDeserializer.getShort(b, s); + return AInt16SerializerDeserializer.getShort(value.getByteArray(), start); case INTEGER: - return AInt32SerializerDeserializer.getInt(b, s); + return AInt32SerializerDeserializer.getInt(value.getByteArray(), start); case BIGINT: - return AInt64SerializerDeserializer.getLong(b, s); + return AInt64SerializerDeserializer.getLong(value.getByteArray(), start); case FLOAT: - return AFloatSerializerDeserializer.getFloat(b, s); + return AFloatSerializerDeserializer.getFloat(value.getByteArray(), start); case DOUBLE: - return ADoubleSerializerDeserializer.getDouble(b, s); + return ADoubleSerializerDeserializer.getDouble(value.getByteArray(), start); default: // TODO(ali): use unsupported type throw new UnsupportedOperationException(); } } - @SuppressWarnings("squid:S1226") // asking for introducing a new variable for s - private static long getLongValue(ATypeTag numericTag, byte[] b, int s) { - s++; + private static long getLongValue(ATypeTag numericTag, IPointable value) { + int start = value.getStartOffset() + 1; switch (numericTag) { case TINYINT: - return AInt8SerializerDeserializer.getByte(b, s); + return AInt8SerializerDeserializer.getByte(value.getByteArray(), start); case SMALLINT: - return AInt16SerializerDeserializer.getShort(b, s); + return AInt16SerializerDeserializer.getShort(value.getByteArray(), start); case INTEGER: - return AInt32SerializerDeserializer.getInt(b, s); + return AInt32SerializerDeserializer.getInt(value.getByteArray(), start); case BIGINT: - return AInt64SerializerDeserializer.getLong(b, s); + return AInt64SerializerDeserializer.getLong(value.getByteArray(), start); default: // TODO(ali): use unsupported type throw new UnsupportedOperationException(); diff --git a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComplexBinaryComparator.java b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComplexBinaryComparator.java index a5924b9..e792e23 100644 --- a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComplexBinaryComparator.java +++ b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalComplexBinaryComparator.java @@ -76,10 +76,9 @@ } @Override - public Result compare(byte[] leftBytes, int leftStart, int leftLen, byte[] rightBytes, int rightStart, int rightLen) - throws HyracksDataException { - ATypeTag leftRuntimeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftBytes[leftStart]); - ATypeTag rightRuntimeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(rightBytes[rightStart]); + public Result compare(IPointable left, IPointable right) throws HyracksDataException { + ATypeTag leftRuntimeTag = VALUE_TYPE_MAPPING[left.getByteArray()[left.getStartOffset()]]; + ATypeTag rightRuntimeTag = VALUE_TYPE_MAPPING[right.getByteArray()[right.getStartOffset()]]; Result comparisonResult = LogicalComparatorUtil.returnMissingOrNullOrMismatch(leftRuntimeTag, rightRuntimeTag); if (comparisonResult != null) { return comparisonResult; @@ -88,14 +87,13 @@ if (!leftRuntimeTag.isDerivedType() || !rightRuntimeTag.isDerivedType()) { throw new IllegalStateException("Input data is not complex type"); } - return compareComplex(leftType, leftRuntimeTag, leftBytes, leftStart, leftLen, rightType, rightRuntimeTag, - rightBytes, rightStart, rightLen); + return compareComplex(leftType, leftRuntimeTag, left, rightType, rightRuntimeTag, right); } @Override - public Result compare(byte[] leftBytes, int leftStart, int leftLen, IAObject rightConstant) { + public Result compare(IPointable left, IAObject rightConstant) { // TODO(ali): not defined currently for constant complex types - ATypeTag leftTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftBytes[leftStart]); + ATypeTag leftTag = VALUE_TYPE_MAPPING[left.getByteArray()[left.getStartOffset()]]; ATypeTag rightTag = rightConstant.getType().getTypeTag(); Result comparisonResult = LogicalComparatorUtil.returnMissingOrNullOrMismatch(leftTag, rightTag); if (comparisonResult != null) { @@ -106,9 +104,9 @@ } @Override - public Result compare(IAObject leftConstant, byte[] rightBytes, int rightStart, int rightLen) { + public Result compare(IAObject leftConstant, IPointable right) { // TODO(ali): not defined currently for constant complex types - Result result = compare(rightBytes, rightStart, rightLen, leftConstant); + Result result = compare(right, leftConstant); switch (result) { case LT: return Result.GT; @@ -132,32 +130,32 @@ return Result.NULL; } - private Result compareComplex(IAType leftType, ATypeTag leftRuntimeTag, byte[] leftBytes, int leftStart, - int leftLen, IAType rightType, ATypeTag rightRuntimeTag, byte[] rightBytes, int rightStart, int rightLen) - throws HyracksDataException { - if (leftRuntimeTag != rightRuntimeTag) { + private Result compareComplex(IAType leftType, ATypeTag leftTag, IPointable left, IAType rightType, + ATypeTag rightTag, IPointable right) throws HyracksDataException { + if (leftTag != rightTag) { return Result.INCOMPARABLE; } - IAType leftCompileType = TypeComputeUtils.getActualTypeOrOpen(leftType, leftRuntimeTag); - IAType rightCompileType = TypeComputeUtils.getActualTypeOrOpen(rightType, rightRuntimeTag); - switch (leftRuntimeTag) { + IAType leftCompileType = TypeComputeUtils.getActualTypeOrOpen(leftType, leftTag); + IAType rightCompileType = TypeComputeUtils.getActualTypeOrOpen(rightType, rightTag); + switch (leftTag) { case MULTISET: - return compareMultisets(leftCompileType, leftRuntimeTag, leftBytes, leftStart, rightCompileType, - rightRuntimeTag, rightBytes, rightStart); + return compareMultisets(leftCompileType, leftTag, left, rightCompileType, rightTag, right); case ARRAY: - return compareArrays(leftCompileType, leftRuntimeTag, leftBytes, leftStart, rightCompileType, - rightRuntimeTag, rightBytes, rightStart); + return compareArrays(leftCompileType, leftTag, left, rightCompileType, rightTag, right); case OBJECT: - return compareRecords(leftCompileType, leftBytes, leftStart, leftLen, rightCompileType, rightBytes, - rightStart, rightLen); + return compareRecords(leftCompileType, left, rightCompileType, right); default: return Result.NULL; } } - private Result compareArrays(IAType leftType, ATypeTag leftListTag, byte[] leftBytes, int leftStart, - IAType rightType, ATypeTag rightListTag, byte[] rightBytes, int rightStart) throws HyracksDataException { + private Result compareArrays(IAType leftType, ATypeTag leftListTag, IPointable left, IAType rightType, + ATypeTag rightListTag, IPointable right) throws HyracksDataException { // reaching here, both left and right have to be arrays (should be enforced) + byte[] leftBytes = left.getByteArray(); + byte[] rightBytes = right.getByteArray(); + int leftStart = left.getStartOffset(); + int rightStart = right.getStartOffset(); int leftNumItems = ListAccessorUtil.numberOfItems(leftBytes, leftStart); int rightNumItems = ListAccessorUtil.numberOfItems(rightBytes, rightStart); IAType leftItemCompileType = ((AbstractCollectionType) leftType).getItemType(); @@ -187,13 +185,10 @@ leftItemRuntimeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftItemTagByte); rightItemRuntimeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(rightItemTagByte); if (leftItemRuntimeTag.isDerivedType() && rightItemRuntimeTag.isDerivedType()) { - tempResult = compareComplex(leftItemCompileType, leftItemRuntimeTag, leftItem.getByteArray(), - leftItem.getStartOffset(), leftItem.getLength(), rightItemCompileType, rightItemRuntimeTag, - rightItem.getByteArray(), rightItem.getStartOffset(), rightItem.getLength()); + tempResult = compareComplex(leftItemCompileType, leftItemRuntimeTag, leftItem, rightItemCompileType, + rightItemRuntimeTag, rightItem); } else { - tempResult = scalarComparator.compare(leftItem.getByteArray(), leftItem.getStartOffset(), - leftItem.getLength(), rightItem.getByteArray(), rightItem.getStartOffset(), - rightItem.getLength()); + tempResult = scalarComparator.compare(leftItem, rightItem); } if (tempResult == Result.INCOMPARABLE || tempResult == Result.MISSING || tempResult == Result.NULL) { @@ -220,8 +215,8 @@ } } - private Result compareMultisets(IAType leftType, ATypeTag leftListTag, byte[] leftBytes, int leftStart, - IAType rightType, ATypeTag rightListTag, byte[] rightBytes, int rightStart) throws HyracksDataException { + private Result compareMultisets(IAType leftType, ATypeTag leftListTag, IPointable left, IAType rightType, + ATypeTag rightListTag, IPointable right) throws HyracksDataException { // TODO(ali): multiset comparison logic here // equality is the only operation defined for multiset if (!isEquality) { @@ -230,8 +225,8 @@ return Result.NULL; } - private Result compareRecords(IAType leftType, byte[] leftBytes, int leftStart, int leftLen, IAType rightType, - byte[] rightBytes, int rightStart, int rightLen) throws HyracksDataException { + private Result compareRecords(IAType leftType, IPointable left, IAType rightType, IPointable right) + throws HyracksDataException { // equality is the only operation defined for records if (!isEquality) { return Result.INCOMPARABLE; @@ -243,8 +238,8 @@ // keeps track of the fields in the right record that have not been matched BitSet notMatched = bitSetAllocator.allocate(null); try { - leftRecord.set(leftBytes, leftStart, leftLen); - rightRecord.set(rightBytes, rightStart, rightLen); + leftRecord.set(left); + rightRecord.set(right); List<IVisitablePointable> leftFieldValues = leftRecord.getFieldValues(); List<IVisitablePointable> leftFieldNames = leftRecord.getFieldNames(); List<IVisitablePointable> rightFieldValues = rightRecord.getFieldValues(); @@ -282,16 +277,10 @@ } else if (leftFTag.isDerivedType() && rightFTag.isDerivedType()) { leftFieldType = CompareHashUtil.getType(leftRecordType, i, leftFTag); rightFieldType = CompareHashUtil.getType(rightRecordType, k, rightFTag); - tempCompResult = - compareComplex(leftFieldType, leftFTag, leftFieldValue.getByteArray(), - leftFieldValue.getStartOffset(), leftFieldValue.getLength(), - rightFieldType, rightFTag, rightFieldValue.getByteArray(), - rightFieldValue.getStartOffset(), rightFieldValue.getLength()); + tempCompResult = compareComplex(leftFieldType, leftFTag, leftFieldValue, + rightFieldType, rightFTag, rightFieldValue); } else { - tempCompResult = scalarComparator.compare(leftFieldValue.getByteArray(), - leftFieldValue.getStartOffset(), leftFieldValue.getLength(), - rightFieldValue.getByteArray(), rightFieldValue.getStartOffset(), - rightFieldValue.getLength()); + tempCompResult = scalarComparator.compare(leftFieldValue, rightFieldValue); } if (tempCompResult == Result.INCOMPARABLE || tempCompResult == Result.MISSING diff --git a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalGenericBinaryComparator.java b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalGenericBinaryComparator.java index 99c4151..51a782d 100644 --- a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalGenericBinaryComparator.java +++ b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalGenericBinaryComparator.java @@ -18,47 +18,48 @@ */ package org.apache.asterix.dataflow.data.nontagged.comparators; +import static org.apache.asterix.om.types.ATypeTag.VALUE_TYPE_MAPPING; + import org.apache.asterix.dataflow.data.common.ILogicalBinaryComparator; import org.apache.asterix.om.base.IAObject; import org.apache.asterix.om.types.ATypeTag; -import org.apache.asterix.om.types.EnumDeserializer; import org.apache.asterix.om.types.IAType; import org.apache.hyracks.api.exceptions.HyracksDataException; +import org.apache.hyracks.data.std.api.IPointable; public class LogicalGenericBinaryComparator implements ILogicalBinaryComparator { private final LogicalComplexBinaryComparator complexComparator; private final LogicalScalarBinaryComparator scalarComparator; - public LogicalGenericBinaryComparator(IAType leftType, IAType rightType, boolean isEquality) { + LogicalGenericBinaryComparator(IAType leftType, IAType rightType, boolean isEquality) { complexComparator = new LogicalComplexBinaryComparator(leftType, rightType, isEquality); scalarComparator = new LogicalScalarBinaryComparator(isEquality); } @Override - public Result compare(byte[] leftBytes, int leftStart, int leftLen, byte[] rightBytes, int rightStart, int rightLen) - throws HyracksDataException { - ATypeTag leftTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftBytes[leftStart]); - ATypeTag rightTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(rightBytes[rightStart]); + public Result compare(IPointable left, IPointable right) throws HyracksDataException { + ATypeTag leftTag = VALUE_TYPE_MAPPING[left.getByteArray()[left.getStartOffset()]]; + ATypeTag rightTag = VALUE_TYPE_MAPPING[right.getByteArray()[right.getStartOffset()]]; if (leftTag.isDerivedType() && rightTag.isDerivedType()) { - return complexComparator.compare(leftBytes, leftStart, leftLen, rightBytes, rightStart, rightLen); + return complexComparator.compare(left, right); } - return scalarComparator.compare(leftBytes, leftStart, leftLen, rightBytes, rightStart, rightLen); + return scalarComparator.compare(left, right); } @Override - public Result compare(byte[] leftBytes, int leftStart, int leftLen, IAObject rightConstant) { - ATypeTag leftTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftBytes[leftStart]); + public Result compare(IPointable left, IAObject rightConstant) { + ATypeTag leftTag = VALUE_TYPE_MAPPING[left.getByteArray()[left.getStartOffset()]]; ATypeTag rightTag = rightConstant.getType().getTypeTag(); if (leftTag.isDerivedType() && rightTag.isDerivedType()) { - return complexComparator.compare(leftBytes, leftStart, leftLen, rightConstant); + return complexComparator.compare(left, rightConstant); } - return scalarComparator.compare(leftBytes, leftStart, leftLen, rightConstant); + return scalarComparator.compare(left, rightConstant); } @Override - public Result compare(IAObject leftConstant, byte[] rightBytes, int rightStart, int rightLen) { - Result result = compare(rightBytes, rightStart, rightLen, leftConstant); + public Result compare(IAObject leftConstant, IPointable right) { + Result result = compare(right, leftConstant); if (result == Result.LT) { return Result.GT; } else if (result == Result.GT) { diff --git a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalScalarBinaryComparator.java b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalScalarBinaryComparator.java index a25c90e..f293193 100644 --- a/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalScalarBinaryComparator.java +++ b/asterixdb/asterix-om/src/main/java/org/apache/asterix/dataflow/data/nontagged/comparators/LogicalScalarBinaryComparator.java @@ -26,6 +26,7 @@ import static org.apache.asterix.om.types.ATypeTag.POINT3D; import static org.apache.asterix.om.types.ATypeTag.POLYGON; import static org.apache.asterix.om.types.ATypeTag.RECTANGLE; +import static org.apache.asterix.om.types.ATypeTag.VALUE_TYPE_MAPPING; import java.util.EnumSet; @@ -38,10 +39,10 @@ import org.apache.asterix.formats.nontagged.BinaryComparatorFactoryProvider; import org.apache.asterix.om.base.IAObject; import org.apache.asterix.om.types.ATypeTag; -import org.apache.asterix.om.types.EnumDeserializer; import org.apache.hyracks.api.dataflow.value.IBinaryComparator; import org.apache.hyracks.api.exceptions.HyracksDataException; import org.apache.hyracks.data.std.accessors.PointableBinaryComparatorFactory; +import org.apache.hyracks.data.std.api.IPointable; import org.apache.hyracks.data.std.primitive.ByteArrayPointable; public class LogicalScalarBinaryComparator implements ILogicalBinaryComparator { @@ -80,10 +81,9 @@ @SuppressWarnings("squid:S1226") // asking for introducing a new variable for incremented local variables @Override - public Result compare(byte[] leftBytes, int leftStart, int leftLen, byte[] rightBytes, int rightStart, int rightLen) - throws HyracksDataException { - ATypeTag leftTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftBytes[leftStart]); - ATypeTag rightTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(rightBytes[rightStart]); + public Result compare(IPointable left, IPointable right) throws HyracksDataException { + ATypeTag leftTag = VALUE_TYPE_MAPPING[left.getByteArray()[left.getStartOffset()]]; + ATypeTag rightTag = VALUE_TYPE_MAPPING[right.getByteArray()[right.getStartOffset()]]; Result comparisonResult = LogicalComparatorUtil.returnMissingOrNullOrMismatch(leftTag, rightTag); if (comparisonResult != null) { return comparisonResult; @@ -92,8 +92,7 @@ return Result.INCOMPARABLE; } // compare number if one of args is number - comparisonResult = - LogicalComparatorUtil.compareNumbers(leftTag, leftBytes, leftStart, rightTag, rightBytes, rightStart); + comparisonResult = LogicalComparatorUtil.compareNumbers(leftTag, left, rightTag, right); if (comparisonResult != null) { return comparisonResult; } @@ -104,10 +103,12 @@ throw new IllegalStateException("Two different non-numeric tags but they are compatible"); } - leftStart++; - leftLen--; - rightStart++; - rightLen--; + byte[] leftBytes = left.getByteArray(); + byte[] rightBytes = right.getByteArray(); + int leftStart = left.getStartOffset() + 1; + int rightStart = right.getStartOffset() + 1; + int leftLen = left.getLength() - 1; + int rightLen = right.getLength() - 1; int result; switch (leftTag) { @@ -177,9 +178,9 @@ } @Override - public Result compare(byte[] leftBytes, int leftStart, int leftLen, IAObject rightConstant) { + public Result compare(IPointable left, IAObject rightConstant) { // TODO(ali): currently defined for numbers only - ATypeTag leftTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(leftBytes[leftStart]); + ATypeTag leftTag = VALUE_TYPE_MAPPING[left.getByteArray()[left.getStartOffset()]]; ATypeTag rightTag = rightConstant.getType().getTypeTag(); Result comparisonResult = LogicalComparatorUtil.returnMissingOrNullOrMismatch(leftTag, rightTag); if (comparisonResult != null) { @@ -188,7 +189,7 @@ if (comparisonUndefined(leftTag, rightTag, isEquality)) { return Result.NULL; } - comparisonResult = LogicalComparatorUtil.compareNumWithConstant(leftTag, leftBytes, leftStart, rightConstant); + comparisonResult = LogicalComparatorUtil.compareNumWithConstant(leftTag, left, rightConstant); if (comparisonResult != null) { return comparisonResult; } @@ -196,9 +197,9 @@ } @Override - public Result compare(IAObject leftConstant, byte[] rightBytes, int rightStart, int rightLen) { + public Result compare(IAObject leftConstant, IPointable right) { // TODO(ali): currently defined for numbers only - Result result = compare(rightBytes, rightStart, rightLen, leftConstant); + Result result = compare(right, leftConstant); if (result == Result.LT) { return Result.GT; } else if (result == Result.GT) { diff --git a/asterixdb/asterix-runtime/src/main/java/org/apache/asterix/runtime/evaluators/comparisons/AbstractComparisonEvaluator.java b/asterixdb/asterix-runtime/src/main/java/org/apache/asterix/runtime/evaluators/comparisons/AbstractComparisonEvaluator.java index b7ed05d..1d1b3e1 100644 --- a/asterixdb/asterix-runtime/src/main/java/org/apache/asterix/runtime/evaluators/comparisons/AbstractComparisonEvaluator.java +++ b/asterixdb/asterix-runtime/src/main/java/org/apache/asterix/runtime/evaluators/comparisons/AbstractComparisonEvaluator.java @@ -109,17 +109,14 @@ return logicalComparator.compare(leftConstant, rightConstant); } else { // left is constant, right isn't - return logicalComparator.compare(leftConstant, argRight.getByteArray(), argRight.getStartOffset(), - argRight.getLength()); + return logicalComparator.compare(leftConstant, argRight); } } else { if (rightConstant != null) { // right is constant, left isn't - return logicalComparator.compare(argLeft.getByteArray(), argLeft.getStartOffset(), argLeft.getLength(), - rightConstant); + return logicalComparator.compare(argLeft, rightConstant); } else { - return logicalComparator.compare(argLeft.getByteArray(), argLeft.getStartOffset(), argLeft.getLength(), - argRight.getByteArray(), argRight.getStartOffset(), argRight.getLength()); + return logicalComparator.compare(argLeft, argRight); } } } -- To view, visit https://asterix-gerrit.ics.uci.edu/3263 To unsubscribe, visit https://asterix-gerrit.ics.uci.edu/settings Gerrit-MessageType: merged Gerrit-Change-Id: I8150ccb4b18550fd8fba10ffca9c88d45ebc625b Gerrit-PatchSet: 4 Gerrit-Project: asterixdb Gerrit-Branch: master Gerrit-Owner: Ali Alsuliman <[email protected]> Gerrit-Reviewer: Ali Alsuliman <[email protected]> Gerrit-Reviewer: Anon. E. Moose #1000171 Gerrit-Reviewer: Dmitry Lychagin <[email protected]> Gerrit-Reviewer: Jenkins <[email protected]> Gerrit-Reviewer: Till Westmann <[email protected]>
