Ali Alsuliman has uploaded a new change for review.
https://asterix-gerrit.ics.uci.edu/3263
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
---
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
5 files changed, 102 insertions(+), 112 deletions(-)
git pull ssh://asterix-gerrit.ics.uci.edu:29418/asterixdb
refs/changes/63/3263/1
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..ba3bf86 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();
@@ -283,15 +278,10 @@
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());
+ 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) {
--
To view, visit https://asterix-gerrit.ics.uci.edu/3263
To unsubscribe, visit https://asterix-gerrit.ics.uci.edu/settings
Gerrit-MessageType: newchange
Gerrit-Change-Id: I8150ccb4b18550fd8fba10ffca9c88d45ebc625b
Gerrit-PatchSet: 1
Gerrit-Project: asterixdb
Gerrit-Branch: master
Gerrit-Owner: Ali Alsuliman <[email protected]>
