[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 <jenkins@fulliautomatix.ics.uci.edu>
Integration-Tests: Jenkins <jenkins@fulliautomatix.ics.uci.edu>
Contrib: Jenkins <jenkins@fulliautomatix.ics.uci.edu>
Reviewed-by: Till Westmann <tillw@apache.org>
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);
}
}
}