Search in sources :

Example 16 with AMutableInt32

use of org.apache.asterix.om.base.AMutableInt32 in project asterixdb by apache.

the class Literal method createRelTime.

/* Creates a relative time literal, from the string timestr,
     *parsing it as [[[days+]hh:]mm:]ss
     * Ex - 1+00:02:00
     */
public static Literal createRelTime(AMutableCharArrayString timeStr, ClassAdObjectPool objectPool) throws HyracksDataException {
    Value val = objectPool.valuePool.get();
    ClassAdTime rsecs = objectPool.classAdTimePool.get();
    int len = timeStr.getLength();
    double secs = 0;
    int mins = 0;
    int hrs = 0;
    int days = 0;
    boolean negative = false;
    AMutableInt32 i = objectPool.int32Pool.get();
    i.setValue(len - 1);
    prevNonSpaceChar(timeStr, i);
    // checking for 'sec' parameter & collecting it if present (ss.sss)
    if ((i.getIntegerValue() >= 0) && ((timeStr.charAt(i.getIntegerValue()) == 's') || (timeStr.charAt(i.getIntegerValue()) == 'S') || (Character.isDigit(timeStr.charAt(i.getIntegerValue()))))) {
        if ((timeStr.charAt(i.getIntegerValue()) == 's') || (timeStr.charAt(i.getIntegerValue()) == 'S')) {
            i.setValue(i.getIntegerValue() - 1);
        }
        prevNonSpaceChar(timeStr, i);
        AMutableCharArrayString revSecStr = objectPool.strPool.get();
        while ((i.getIntegerValue() >= 0) && (Character.isDigit(timeStr.charAt(i.getIntegerValue())))) {
            revSecStr.appendChar(timeStr.charAt(i.getIntegerValue()));
            i.setValue(i.getIntegerValue() - 1);
        }
        if ((i.getIntegerValue() >= 0) && (timeStr.charAt(i.getIntegerValue()) == '.')) {
            revSecStr.appendChar(timeStr.charAt(i.getIntegerValue()));
            i.setValue(i.getIntegerValue() - 1);
            while ((i.getIntegerValue() >= 0) && (Character.isDigit(timeStr.charAt(i.getIntegerValue())))) {
                revSecStr.appendChar(timeStr.charAt(i.getIntegerValue()));
                i.setValue(i.getIntegerValue() - 1);
            }
        }
        secs = revDouble(revSecStr, objectPool);
    }
    prevNonSpaceChar(timeStr, i);
    // checking for 'min' parameter
    if ((i.getIntegerValue() >= 0) && ((timeStr.charAt(i.getIntegerValue()) == 'm') || (timeStr.charAt(i.getIntegerValue()) == 'M') || (timeStr.charAt(i.getIntegerValue()) == ':'))) {
        i.setValue(i.getIntegerValue() - 1);
        AMutableCharArrayString revMinStr = objectPool.strPool.get();
        prevNonSpaceChar(timeStr, i);
        while ((i.getIntegerValue() >= 0) && (Character.isDigit(timeStr.charAt(i.getIntegerValue())))) {
            revMinStr.appendChar(timeStr.charAt(i.getIntegerValue()));
            i.setValue(i.getIntegerValue() - 1);
        }
        mins = revInt(revMinStr, objectPool);
    }
    prevNonSpaceChar(timeStr, i);
    // checking for 'hrs' parameter
    if ((i.getIntegerValue() >= 0) && ((timeStr.charAt(i.getIntegerValue()) == 'h') || (timeStr.charAt(i.getIntegerValue()) == 'H') || (timeStr.charAt(i.getIntegerValue()) == ':'))) {
        i.setValue(i.getIntegerValue() - 1);
        AMutableCharArrayString revHrStr = objectPool.strPool.get();
        prevNonSpaceChar(timeStr, i);
        while ((i.getIntegerValue() >= 0) && (Character.isDigit(timeStr.charAt(i.getIntegerValue())))) {
            revHrStr.appendChar(timeStr.charAt(i.getIntegerValue()));
            i.setValue(i.getIntegerValue() - 1);
        }
        hrs = revInt(revHrStr, objectPool);
    }
    prevNonSpaceChar(timeStr, i);
    // checking for 'days' parameter
    if ((i.getIntegerValue() >= 0) && ((timeStr.charAt(i.getIntegerValue()) == 'd') || (timeStr.charAt(i.getIntegerValue()) == 'D') || (timeStr.charAt(i.getIntegerValue()) == '+'))) {
        i.setValue(i.getIntegerValue() - 1);
        AMutableCharArrayString revDayStr = objectPool.strPool.get();
        prevNonSpaceChar(timeStr, i);
        while ((i.getIntegerValue() >= 0) && (Character.isDigit(timeStr.charAt(i.getIntegerValue())))) {
            revDayStr.appendChar(timeStr.charAt(i.getIntegerValue()));
            i.setValue(i.getIntegerValue() - 1);
        }
        days = revInt(revDayStr, objectPool);
    }
    prevNonSpaceChar(timeStr, i);
    // checking for '-' operator
    if ((i.getIntegerValue() >= 0) && (timeStr.charAt(i.getIntegerValue()) == '-')) {
        negative = true;
        i.setValue(i.getIntegerValue() - 1);
    }
    prevNonSpaceChar(timeStr, i);
    if ((i.getIntegerValue() >= 0) && (!(Character.isWhitespace(timeStr.charAt(i.getIntegerValue()))))) {
        // should not conatin any non-space char beyond -,d,h,m,s
        val.setErrorValue();
        return (createLiteral(val, objectPool));
    }
    rsecs.setRelativeTime((long) ((negative ? -1 : +1) * (days * 86400000 + hrs * 3600000 + mins * 60000 + secs * 1000.0)));
    val.setRelativeTimeValue(rsecs);
    return (createLiteral(val, objectPool));
}
Also used : AMutableInt32(org.apache.asterix.om.base.AMutableInt32)

Example 17 with AMutableInt32

use of org.apache.asterix.om.base.AMutableInt32 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]);
                        }
                    }
                }
            };
        }
    };
}
Also used : DataOutput(java.io.DataOutput) AMutableInt8(org.apache.asterix.om.base.AMutableInt8) TypeMismatchException(org.apache.asterix.runtime.exceptions.TypeMismatchException) IPointable(org.apache.hyracks.data.std.api.IPointable) IScalarEvaluator(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator) AMutableDate(org.apache.asterix.om.base.AMutableDate) VoidPointable(org.apache.hyracks.data.std.primitive.VoidPointable) AMutableDouble(org.apache.asterix.om.base.AMutableDouble) IncompatibleTypeException(org.apache.asterix.runtime.exceptions.IncompatibleTypeException) AMutableInt64(org.apache.asterix.om.base.AMutableInt64) AMutableFloat(org.apache.asterix.om.base.AMutableFloat) AMutableDuration(org.apache.asterix.om.base.AMutableDuration) ISerializerDeserializer(org.apache.hyracks.api.dataflow.value.ISerializerDeserializer) IScalarEvaluatorFactory(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory) AMutableDateTime(org.apache.asterix.om.base.AMutableDateTime) ArrayBackedValueStorage(org.apache.hyracks.data.std.util.ArrayBackedValueStorage) ATypeTag(org.apache.asterix.om.types.ATypeTag) IHyracksTaskContext(org.apache.hyracks.api.context.IHyracksTaskContext) IFrameTupleReference(org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference) UnsupportedTypeException(org.apache.asterix.runtime.exceptions.UnsupportedTypeException) AMutableInt16(org.apache.asterix.om.base.AMutableInt16) UnderflowException(org.apache.asterix.runtime.exceptions.UnderflowException) AMutableTime(org.apache.asterix.om.base.AMutableTime) OverflowException(org.apache.asterix.runtime.exceptions.OverflowException) AMutableInt32(org.apache.asterix.om.base.AMutableInt32)

Example 18 with AMutableInt32

use of org.apache.asterix.om.base.AMutableInt32 in project asterixdb by apache.

the class AInt32ConstructorDescriptor method createEvaluatorFactory.

@Override
public IScalarEvaluatorFactory createEvaluatorFactory(final IScalarEvaluatorFactory[] args) {
    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 inputArg = new VoidPointable();

                private IScalarEvaluator eval = args[0].createScalarEvaluator(ctx);

                private int value, offset;

                private boolean positive;

                private AMutableInt32 aInt32 = new AMutableInt32(0);

                @SuppressWarnings("unchecked")
                private ISerializerDeserializer<AInt32> int32Serde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT32);

                private final UTF8StringPointable utf8Ptr = new UTF8StringPointable();

                @Override
                public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
                    try {
                        resultStorage.reset();
                        eval.evaluate(tuple, inputArg);
                        byte[] serString = inputArg.getByteArray();
                        int startOffset = inputArg.getStartOffset();
                        int len = inputArg.getLength();
                        if (serString[startOffset] == ATypeTag.SERIALIZED_STRING_TYPE_TAG) {
                            utf8Ptr.set(serString, startOffset + 1, len - 1);
                            offset = utf8Ptr.getCharStartOffset();
                            //accumulating value in negative domain
                            //otherwise Integer.MIN_VALUE = -(Integer.MAX_VALUE + 1) would have caused overflow
                            value = 0;
                            positive = true;
                            int limit = -Integer.MAX_VALUE;
                            if (serString[offset] == '+') {
                                offset++;
                            } else if (serString[offset] == '-') {
                                offset++;
                                positive = false;
                                limit = Integer.MIN_VALUE;
                            }
                            int end = startOffset + len;
                            for (; offset < end; offset++) {
                                int digit;
                                if (serString[offset] >= '0' && serString[offset] <= '9') {
                                    value *= 10;
                                    digit = serString[offset] - '0';
                                } else if (serString[offset] == 'i' && serString[offset + 1] == '3' && serString[offset + 2] == '2' && offset + 3 == end) {
                                    break;
                                } else {
                                    throw new InvalidDataFormatException(getIdentifier(), ATypeTag.SERIALIZED_INT32_TYPE_TAG);
                                }
                                if (value < limit + digit) {
                                    throw new InvalidDataFormatException(getIdentifier(), ATypeTag.SERIALIZED_INT32_TYPE_TAG);
                                }
                                value -= digit;
                            }
                            if (value > 0) {
                                throw new InvalidDataFormatException(getIdentifier(), ATypeTag.SERIALIZED_INT32_TYPE_TAG);
                            }
                            if (value < 0 && positive) {
                                value *= -1;
                            }
                            aInt32.setValue(value);
                            int32Serde.serialize(aInt32, out);
                        } else {
                            throw new TypeMismatchException(getIdentifier(), 0, serString[offset], ATypeTag.SERIALIZED_STRING_TYPE_TAG);
                        }
                        result.set(resultStorage);
                    } catch (IOException e) {
                        throw new InvalidDataFormatException(getIdentifier(), e, ATypeTag.SERIALIZED_INT32_TYPE_TAG);
                    }
                }
            };
        }
    };
}
Also used : DataOutput(java.io.DataOutput) UTF8StringPointable(org.apache.hyracks.data.std.primitive.UTF8StringPointable) TypeMismatchException(org.apache.asterix.runtime.exceptions.TypeMismatchException) IPointable(org.apache.hyracks.data.std.api.IPointable) IOException(java.io.IOException) IScalarEvaluator(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator) ISerializerDeserializer(org.apache.hyracks.api.dataflow.value.ISerializerDeserializer) IScalarEvaluatorFactory(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory) InvalidDataFormatException(org.apache.asterix.runtime.exceptions.InvalidDataFormatException) ArrayBackedValueStorage(org.apache.hyracks.data.std.util.ArrayBackedValueStorage) IHyracksTaskContext(org.apache.hyracks.api.context.IHyracksTaskContext) VoidPointable(org.apache.hyracks.data.std.primitive.VoidPointable) IFrameTupleReference(org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference) AMutableInt32(org.apache.asterix.om.base.AMutableInt32)

Aggregations

AMutableInt32 (org.apache.asterix.om.base.AMutableInt32)18 ISerializerDeserializer (org.apache.hyracks.api.dataflow.value.ISerializerDeserializer)9 DataOutput (java.io.DataOutput)8 TypeMismatchException (org.apache.asterix.runtime.exceptions.TypeMismatchException)8 IScalarEvaluator (org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator)8 IScalarEvaluatorFactory (org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory)8 IHyracksTaskContext (org.apache.hyracks.api.context.IHyracksTaskContext)8 IPointable (org.apache.hyracks.data.std.api.IPointable)8 VoidPointable (org.apache.hyracks.data.std.primitive.VoidPointable)8 ArrayBackedValueStorage (org.apache.hyracks.data.std.util.ArrayBackedValueStorage)8 IFrameTupleReference (org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference)8 AMutableDouble (org.apache.asterix.om.base.AMutableDouble)7 AMutableInt64 (org.apache.asterix.om.base.AMutableInt64)7 AMutableFloat (org.apache.asterix.om.base.AMutableFloat)6 AMutableInt16 (org.apache.asterix.om.base.AMutableInt16)5 AMutableInt8 (org.apache.asterix.om.base.AMutableInt8)5 HyracksDataException (org.apache.hyracks.api.exceptions.HyracksDataException)4 IOException (java.io.IOException)3 AMutableString (org.apache.asterix.om.base.AMutableString)2 ATypeTag (org.apache.asterix.om.types.ATypeTag)2