use of org.apache.asterix.om.base.AMutableFloat in project asterixdb by apache.
the class RangeMapBuilder method parseLiteralToBytes.
@SuppressWarnings("unchecked")
private static void parseLiteralToBytes(Expression item, DataOutput out) throws CompilationException {
AMutableDouble aDouble = new AMutableDouble(0);
AMutableFloat aFloat = new AMutableFloat(0);
AMutableInt64 aInt64 = new AMutableInt64(0);
AMutableInt32 aInt32 = new AMutableInt32(0);
AMutableString aString = new AMutableString("");
@SuppressWarnings("rawtypes") ISerializerDeserializer serde;
Literal l = ((LiteralExpr) item).getValue();
try {
switch(l.getLiteralType()) {
case DOUBLE:
DoubleLiteral dl = (DoubleLiteral) l;
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADOUBLE);
aDouble.setValue(dl.getValue());
serde.serialize(aDouble, out);
break;
case FLOAT:
FloatLiteral fl = (FloatLiteral) l;
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AFLOAT);
aFloat.setValue(fl.getValue());
serde.serialize(aFloat, out);
break;
case INTEGER:
IntegerLiteral il = (IntegerLiteral) l;
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT32);
aInt32.setValue(il.getValue());
serde.serialize(aInt32, out);
break;
case LONG:
LongIntegerLiteral lil = (LongIntegerLiteral) l;
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT64);
aInt64.setValue(lil.getValue());
serde.serialize(aInt64, out);
break;
case STRING:
StringLiteral sl = (StringLiteral) l;
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ASTRING);
aString.setValue(sl.getValue());
serde.serialize(aString, out);
break;
default:
throw new NotImplementedException("The range map builder has not been implemented for " + item.getKind() + " type of expressions.");
}
} catch (HyracksDataException e) {
throw new CompilationException(e.getMessage());
}
}
use of org.apache.asterix.om.base.AMutableFloat in project asterixdb by apache.
the class AbstractNumericArithmeticEval method createEvaluatorFactory.
@Override
public IScalarEvaluatorFactory createEvaluatorFactory(final IScalarEvaluatorFactory[] args) throws AlgebricksException {
return new IScalarEvaluatorFactory() {
private static final long serialVersionUID = 1L;
@Override
public IScalarEvaluator createScalarEvaluator(IHyracksTaskContext ctx) throws HyracksDataException {
return new IScalarEvaluator() {
private ArrayBackedValueStorage resultStorage = new ArrayBackedValueStorage();
private DataOutput out = resultStorage.getDataOutput();
private IPointable argPtr0 = new VoidPointable();
private IPointable argPtr1 = new VoidPointable();
private IScalarEvaluator evalLeft = args[0].createScalarEvaluator(ctx);
private IScalarEvaluator evalRight = args[1].createScalarEvaluator(ctx);
private double[] operandsFloating = new double[args.length];
private long[] operandsInteger = new long[args.length];
private int resultType;
protected static final int typeInt8 = 1;
protected static final int typeInt16 = 2;
protected static final int typeInt32 = 3;
protected static final int typeInt64 = 4;
protected static final int typeFloat = 5;
protected static final int typeDouble = 6;
protected AMutableFloat aFloat = new AMutableFloat(0);
protected AMutableDouble aDouble = new AMutableDouble(0);
protected AMutableInt64 aInt64 = new AMutableInt64(0);
protected AMutableInt32 aInt32 = new AMutableInt32(0);
protected AMutableInt16 aInt16 = new AMutableInt16((short) 0);
protected AMutableInt8 aInt8 = new AMutableInt8((byte) 0);
protected AMutableDuration aDuration = new AMutableDuration(0, 0);
protected AMutableDate aDate = new AMutableDate(0);
protected AMutableTime aTime = new AMutableTime(0);
protected AMutableDateTime aDatetime = new AMutableDateTime(0);
private ATypeTag typeTag;
@SuppressWarnings("rawtypes")
private ISerializerDeserializer serde;
@SuppressWarnings("unchecked")
@Override
public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
resultStorage.reset();
resultType = 0;
int currentType;
evalLeft.evaluate(tuple, argPtr0);
evalRight.evaluate(tuple, argPtr1);
for (int i = 0; i < args.length; i++) {
IPointable argPtr = i == 0 ? argPtr0 : argPtr1;
byte[] bytes = argPtr.getByteArray();
int offset = argPtr.getStartOffset();
typeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(bytes[offset]);
switch(typeTag) {
case TINYINT:
currentType = typeInt8;
operandsInteger[i] = AInt8SerializerDeserializer.getByte(bytes, offset + 1);
operandsFloating[i] = operandsInteger[i];
break;
case SMALLINT:
currentType = typeInt16;
operandsInteger[i] = AInt16SerializerDeserializer.getShort(bytes, offset + 1);
operandsFloating[i] = operandsInteger[i];
break;
case INTEGER:
currentType = typeInt32;
operandsInteger[i] = AInt32SerializerDeserializer.getInt(bytes, offset + 1);
operandsFloating[i] = operandsInteger[i];
break;
case BIGINT:
currentType = typeInt64;
operandsInteger[i] = AInt64SerializerDeserializer.getLong(bytes, offset + 1);
operandsFloating[i] = operandsInteger[i];
break;
case FLOAT:
currentType = typeFloat;
operandsFloating[i] = AFloatSerializerDeserializer.getFloat(bytes, offset + 1);
break;
case DOUBLE:
currentType = typeDouble;
operandsFloating[i] = ADoubleSerializerDeserializer.getDouble(bytes, offset + 1);
break;
case DATE:
case TIME:
case DATETIME:
case DURATION:
case YEARMONTHDURATION:
case DAYTIMEDURATION:
evaluateTemporalArthmeticOperation(typeTag);
result.set(resultStorage);
return;
default:
throw new TypeMismatchException(getIdentifier(), i, bytes[offset], ATypeTag.SERIALIZED_INT8_TYPE_TAG, ATypeTag.SERIALIZED_INT16_TYPE_TAG, ATypeTag.SERIALIZED_INT32_TYPE_TAG, ATypeTag.SERIALIZED_INT64_TYPE_TAG, ATypeTag.SERIALIZED_FLOAT_TYPE_TAG, ATypeTag.SERIALIZED_DOUBLE_TYPE_TAG, ATypeTag.SERIALIZED_DATE_TYPE_TAG, ATypeTag.SERIALIZED_TIME_TYPE_TAG, ATypeTag.SERIALIZED_DATETIME_TYPE_TAG, ATypeTag.SERIALIZED_DURATION_TYPE_TAG, ATypeTag.SERIALIZED_YEAR_MONTH_DURATION_TYPE_TAG, ATypeTag.SERIALIZED_DAY_TIME_DURATION_TYPE_TAG);
}
if (resultType < currentType) {
resultType = currentType;
}
}
long lres;
double dres;
switch(resultType) {
case typeInt8:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT8);
lres = evaluateInteger(operandsInteger[0], operandsInteger[1]);
if (lres > Byte.MAX_VALUE) {
throw new OverflowException(getIdentifier());
}
if (lres < Byte.MIN_VALUE) {
throw new UnderflowException(getIdentifier());
}
aInt8.setValue((byte) lres);
serde.serialize(aInt8, out);
break;
case typeInt16:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT16);
lres = evaluateInteger(operandsInteger[0], operandsInteger[1]);
if (lres > Short.MAX_VALUE) {
throw new OverflowException(getIdentifier());
}
if (lres < Short.MIN_VALUE) {
throw new UnderflowException(getIdentifier());
}
aInt16.setValue((short) lres);
serde.serialize(aInt16, out);
break;
case typeInt32:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT32);
lres = evaluateInteger(operandsInteger[0], operandsInteger[1]);
if (lres > Integer.MAX_VALUE) {
throw new OverflowException(getIdentifier());
}
if (lres < Integer.MIN_VALUE) {
throw new UnderflowException(getIdentifier());
}
aInt32.setValue((int) lres);
serde.serialize(aInt32, out);
break;
case typeInt64:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT64);
lres = evaluateInteger(operandsInteger[0], operandsInteger[1]);
aInt64.setValue(lres);
serde.serialize(aInt64, out);
break;
case typeFloat:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AFLOAT);
dres = evaluateDouble(operandsFloating[0], operandsFloating[1]);
if (dres > Float.MAX_VALUE) {
throw new OverflowException(getIdentifier());
}
if (dres < -Float.MAX_VALUE) {
throw new UnderflowException(getIdentifier());
}
aFloat.setValue((float) dres);
serde.serialize(aFloat, out);
break;
case typeDouble:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADOUBLE);
aDouble.setValue(evaluateDouble(operandsFloating[0], operandsFloating[1]));
serde.serialize(aDouble, out);
break;
}
result.set(resultStorage);
}
@SuppressWarnings("unchecked")
private void evaluateTemporalArthmeticOperation(ATypeTag leftType) throws HyracksDataException {
byte[] bytes1 = argPtr1.getByteArray();
int offset1 = argPtr1.getStartOffset();
ATypeTag rightType = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(bytes1[offset1]);
byte[] bytes0 = argPtr0.getByteArray();
int offset0 = argPtr0.getStartOffset();
if (rightType == leftType) {
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADURATION);
long leftChronon = 0, rightChronon = 0, dayTime = 0;
int yearMonth = 0;
switch(leftType) {
case DATE:
leftChronon = ADateSerializerDeserializer.getChronon(bytes0, offset0 + 1) * GregorianCalendarSystem.CHRONON_OF_DAY;
rightChronon = ADateSerializerDeserializer.getChronon(bytes1, offset1 + 1) * GregorianCalendarSystem.CHRONON_OF_DAY;
break;
case TIME:
leftChronon = ATimeSerializerDeserializer.getChronon(bytes0, offset0 + 1);
rightChronon = ATimeSerializerDeserializer.getChronon(bytes1, offset1 + 1);
break;
case DATETIME:
leftChronon = ADateTimeSerializerDeserializer.getChronon(bytes0, offset0 + 1);
rightChronon = ADateTimeSerializerDeserializer.getChronon(bytes1, offset1 + 1);
break;
case YEARMONTHDURATION:
yearMonth = (int) evaluateTimeInstanceArithmetic(AYearMonthDurationSerializerDeserializer.getYearMonth(bytes0, offset0 + 1), AYearMonthDurationSerializerDeserializer.getYearMonth(bytes1, offset1 + 1));
break;
case DAYTIMEDURATION:
leftChronon = ADayTimeDurationSerializerDeserializer.getDayTime(bytes0, offset0 + 1);
rightChronon = ADayTimeDurationSerializerDeserializer.getDayTime(bytes1, offset1 + 1);
break;
default:
throw new UnsupportedTypeException(getIdentifier(), bytes1[offset1]);
}
dayTime = evaluateTimeInstanceArithmetic(leftChronon, rightChronon);
aDuration.setValue(yearMonth, dayTime);
serde.serialize(aDuration, out);
} else {
long chronon = 0, dayTime = 0;
int yearMonth = 0;
ATypeTag resultType = null;
boolean isTimeOnly = false;
switch(leftType) {
case TIME:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ATIME);
chronon = ATimeSerializerDeserializer.getChronon(bytes0, offset0 + 1);
isTimeOnly = true;
resultType = ATypeTag.TIME;
switch(rightType) {
case DAYTIMEDURATION:
dayTime = ADayTimeDurationSerializerDeserializer.getDayTime(bytes1, offset1 + 1);
break;
case DURATION:
dayTime = ADurationSerializerDeserializer.getDayTime(bytes1, offset1 + 1);
yearMonth = ADurationSerializerDeserializer.getYearMonth(bytes1, offset1 + 1);
break;
default:
throw new IncompatibleTypeException(getIdentifier(), bytes0[offset0], bytes1[offset1]);
}
break;
case DATE:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADATE);
resultType = ATypeTag.DATE;
chronon = ADateSerializerDeserializer.getChronon(bytes0, offset0 + 1) * GregorianCalendarSystem.CHRONON_OF_DAY;
case DATETIME:
if (leftType == ATypeTag.DATETIME) {
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADATETIME);
resultType = ATypeTag.DATETIME;
chronon = ADateTimeSerializerDeserializer.getChronon(bytes0, offset0 + 1);
}
switch(rightType) {
case DURATION:
yearMonth = ADurationSerializerDeserializer.getYearMonth(bytes1, offset1 + 1);
dayTime = ADurationSerializerDeserializer.getDayTime(bytes1, offset1 + 1);
break;
case YEARMONTHDURATION:
yearMonth = AYearMonthDurationSerializerDeserializer.getYearMonth(bytes1, offset1 + 1);
break;
case DAYTIMEDURATION:
dayTime = ADayTimeDurationSerializerDeserializer.getDayTime(bytes1, offset1 + 1);
break;
default:
throw new IncompatibleTypeException(getIdentifier(), bytes0[offset0], bytes1[offset1]);
}
break;
case YEARMONTHDURATION:
yearMonth = AYearMonthDurationSerializerDeserializer.getYearMonth(bytes0, offset0 + 1);
switch(rightType) {
case DATETIME:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADATETIME);
resultType = ATypeTag.DATETIME;
chronon = ADateTimeSerializerDeserializer.getChronon(bytes1, offset1 + 1);
break;
case DATE:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADATE);
resultType = ATypeTag.DATE;
chronon = ADateSerializerDeserializer.getChronon(bytes1, offset1 + 1) * GregorianCalendarSystem.CHRONON_OF_DAY;
break;
default:
throw new IncompatibleTypeException(getIdentifier(), bytes0[offset0], bytes1[offset1]);
}
break;
case DURATION:
yearMonth = ADurationSerializerDeserializer.getYearMonth(bytes0, offset0 + 1);
dayTime = ADurationSerializerDeserializer.getDayTime(bytes0, offset0 + 1);
case DAYTIMEDURATION:
if (leftType == ATypeTag.DAYTIMEDURATION) {
dayTime = ADayTimeDurationSerializerDeserializer.getDayTime(bytes0, offset0 + 1);
}
switch(rightType) {
case DATETIME:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADATETIME);
resultType = ATypeTag.DATETIME;
chronon = ADateTimeSerializerDeserializer.getChronon(bytes1, offset1 + 1);
break;
case DATE:
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADATE);
resultType = ATypeTag.DATE;
chronon = ADateSerializerDeserializer.getChronon(bytes1, offset1 + 1) * GregorianCalendarSystem.CHRONON_OF_DAY;
break;
case TIME:
if (yearMonth == 0) {
serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ATIME);
resultType = ATypeTag.TIME;
chronon = ATimeSerializerDeserializer.getChronon(bytes1, offset1 + 1);
isTimeOnly = true;
break;
}
default:
throw new IncompatibleTypeException(getIdentifier(), bytes0[offset0], bytes1[offset1]);
}
break;
default:
throw new IncompatibleTypeException(getIdentifier(), bytes0[offset0], bytes1[offset1]);
}
chronon = evaluateTimeDurationArithmetic(chronon, yearMonth, dayTime, isTimeOnly);
switch(resultType) {
case DATE:
if (chronon < 0 && chronon % GregorianCalendarSystem.CHRONON_OF_DAY != 0) {
chronon = chronon / GregorianCalendarSystem.CHRONON_OF_DAY - 1;
} else {
chronon = chronon / GregorianCalendarSystem.CHRONON_OF_DAY;
}
aDate.setValue((int) chronon);
serde.serialize(aDate, out);
break;
case TIME:
aTime.setValue((int) chronon);
serde.serialize(aTime, out);
break;
case DATETIME:
aDatetime.setValue(chronon);
serde.serialize(aDatetime, out);
break;
default:
throw new IncompatibleTypeException(getIdentifier(), bytes0[offset0], bytes1[offset1]);
}
}
}
};
}
};
}
Aggregations