Search in sources :

Example 1 with UnsupportedTypeException

use of org.apache.asterix.runtime.exceptions.UnsupportedTypeException in project asterixdb by apache.

the class CodePointToStringDescriptor 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 IScalarEvaluatorFactory listEvalFactory = args[0];

                private IPointable inputArgList = new VoidPointable();

                private IScalarEvaluator evalList = listEvalFactory.createScalarEvaluator(ctx);

                private final byte[] currentUTF8 = new byte[6];

                private final byte[] tempStoreForLength = new byte[5];

                private final byte stringTypeTag = ATypeTag.SERIALIZED_STRING_TYPE_TAG;

                @Override
                public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
                    try {
                        resultStorage.reset();
                        evalList.evaluate(tuple, inputArgList);
                        byte[] serOrderedList = inputArgList.getByteArray();
                        int offset = inputArgList.getStartOffset();
                        int size;
                        if (ATypeTag.VALUE_TYPE_MAPPING[serOrderedList[offset]] != ATypeTag.ARRAY) {
                            throw new TypeMismatchException(getIdentifier().getName(), 0, serOrderedList[offset]);
                        } else {
                            switch(ATypeTag.VALUE_TYPE_MAPPING[serOrderedList[offset + 1]]) {
                                case TINYINT:
                                case SMALLINT:
                                case INTEGER:
                                case BIGINT:
                                case FLOAT:
                                case DOUBLE:
                                case ANY:
                                    size = AOrderedListSerializerDeserializer.getNumberOfItems(serOrderedList, offset);
                                    break;
                                default:
                                    throw new UnsupportedTypeException(getIdentifier(), serOrderedList[offset]);
                            }
                        }
                        try {
                            // calculate length first
                            int utf_8_len = 0;
                            for (int i = 0; i < size; i++) {
                                int itemOffset = AOrderedListSerializerDeserializer.getItemOffset(serOrderedList, offset, i);
                                int codePoint = 0;
                                codePoint = ATypeHierarchy.getIntegerValueWithDifferentTypeTagPosition(getIdentifier().getName(), 0, serOrderedList, itemOffset, offset + 1);
                                utf_8_len += UTF8StringUtil.codePointToUTF8(codePoint, currentUTF8);
                            }
                            out.writeByte(stringTypeTag);
                            UTF8StringUtil.writeUTF8Length(utf_8_len, tempStoreForLength, out);
                            for (int i = 0; i < size; i++) {
                                int itemOffset = AOrderedListSerializerDeserializer.getItemOffset(serOrderedList, offset, i);
                                int codePoint = 0;
                                codePoint = ATypeHierarchy.getIntegerValueWithDifferentTypeTagPosition(getIdentifier().getName(), 0, serOrderedList, itemOffset, offset + 1);
                                utf_8_len = UTF8StringUtil.codePointToUTF8(codePoint, currentUTF8);
                                for (int j = 0; j < utf_8_len; j++) {
                                    out.writeByte(currentUTF8[j]);
                                }
                            }
                            result.set(resultStorage);
                        } catch (AsterixException ex) {
                            throw new HyracksDataException(ex);
                        }
                    } catch (IOException e1) {
                        throw new HyracksDataException(e1);
                    }
                }
            };
        }
    };
}
Also used : DataOutput(java.io.DataOutput) 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) HyracksDataException(org.apache.hyracks.api.exceptions.HyracksDataException) IScalarEvaluatorFactory(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory) ArrayBackedValueStorage(org.apache.hyracks.data.std.util.ArrayBackedValueStorage) AsterixException(org.apache.asterix.common.exceptions.AsterixException) IHyracksTaskContext(org.apache.hyracks.api.context.IHyracksTaskContext) VoidPointable(org.apache.hyracks.data.std.primitive.VoidPointable) IFrameTupleReference(org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference) UnsupportedTypeException(org.apache.asterix.runtime.exceptions.UnsupportedTypeException)

Example 2 with UnsupportedTypeException

use of org.apache.asterix.runtime.exceptions.UnsupportedTypeException in project asterixdb by apache.

the class FieldAccessNestedEvalFactory method createScalarEvaluator.

@Override
public IScalarEvaluator createScalarEvaluator(final IHyracksTaskContext ctx) throws HyracksDataException {
    return new IScalarEvaluator() {

        private ArrayBackedValueStorage resultStorage = new ArrayBackedValueStorage();

        private final DataOutput out = resultStorage.getDataOutput();

        private final ByteArrayAccessibleOutputStream subRecordTmpStream = new ByteArrayAccessibleOutputStream();

        private final IPointable inputArg0 = new VoidPointable();

        private final IScalarEvaluator eval0 = recordEvalFactory.createScalarEvaluator(ctx);

        private final IPointable[] fieldPointables = new VoidPointable[fieldPath.size()];

        private final RuntimeRecordTypeInfo[] recTypeInfos = new RuntimeRecordTypeInfo[fieldPath.size()];

        @SuppressWarnings("unchecked")
        private final ISerializerDeserializer<ANull> nullSerde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ANULL);

        @SuppressWarnings("unchecked")
        private final ISerializerDeserializer<AMissing> missingSerde = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AMISSING);

        {
            generateFieldsPointables();
            for (int index = 0; index < fieldPath.size(); ++index) {
                recTypeInfos[index] = new RuntimeRecordTypeInfo();
            }
        }

        @SuppressWarnings("unchecked")
        private void generateFieldsPointables() throws HyracksDataException {
            for (int i = 0; i < fieldPath.size(); i++) {
                ArrayBackedValueStorage storage = new ArrayBackedValueStorage();
                DataOutput out = storage.getDataOutput();
                AString as = new AString(fieldPath.get(i));
                SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(as.getType()).serialize(as, out);
                fieldPointables[i] = new VoidPointable();
                fieldPointables[i].set(storage);
            }
        }

        @Override
        public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
            try {
                resultStorage.reset();
                eval0.evaluate(tuple, inputArg0);
                byte[] serRecord = inputArg0.getByteArray();
                int offset = inputArg0.getStartOffset();
                int start = offset;
                int len = inputArg0.getLength();
                if (serRecord[start] != ATypeTag.SERIALIZED_RECORD_TYPE_TAG) {
                    throw new TypeMismatchException(BuiltinFunctions.FIELD_ACCESS_NESTED, 0, serRecord[start], ATypeTag.SERIALIZED_RECORD_TYPE_TAG);
                }
                int subFieldIndex = -1;
                int subFieldOffset = -1;
                int subFieldLength = -1;
                int nullBitmapSize = -1;
                IAType subType = recordType;
                recTypeInfos[0].reset(recordType);
                ATypeTag subTypeTag = ATypeTag.MISSING;
                boolean openField = false;
                int pathIndex = 0;
                // Moving through closed fields first.
                for (; pathIndex < fieldPointables.length; pathIndex++) {
                    if (subType.getTypeTag().equals(ATypeTag.UNION)) {
                        //enforced SubType
                        subType = ((AUnionType) subType).getActualType();
                        byte serializedTypeTag = subType.getTypeTag().serialize();
                        if (serializedTypeTag != ATypeTag.SERIALIZED_RECORD_TYPE_TAG) {
                            throw new UnsupportedTypeException(BuiltinFunctions.FIELD_ACCESS_NESTED.getName(), serializedTypeTag);
                        }
                        if (subType.getTypeTag() == ATypeTag.OBJECT) {
                            recTypeInfos[pathIndex].reset((ARecordType) subType);
                        }
                    }
                    subFieldIndex = recTypeInfos[pathIndex].getFieldIndex(fieldPointables[pathIndex].getByteArray(), fieldPointables[pathIndex].getStartOffset() + 1, fieldPointables[pathIndex].getLength() - 1);
                    if (subFieldIndex == -1) {
                        break;
                    }
                    nullBitmapSize = RecordUtil.computeNullBitmapSize((ARecordType) subType);
                    subFieldOffset = ARecordSerializerDeserializer.getFieldOffsetById(serRecord, start, subFieldIndex, nullBitmapSize, ((ARecordType) subType).isOpen());
                    if (subFieldOffset == 0) {
                        // the field is null, we checked the null bit map
                        // any path after null will return null.
                        nullSerde.serialize(ANull.NULL, out);
                        result.set(resultStorage);
                        return;
                    }
                    if (subFieldOffset < 0) {
                        // the field is missing, we checked the missing bit map
                        // any path after missing will return null.
                        missingSerde.serialize(AMissing.MISSING, out);
                        result.set(resultStorage);
                        return;
                    }
                    subType = ((ARecordType) subType).getFieldTypes()[subFieldIndex];
                    if (subType.getTypeTag() == ATypeTag.OBJECT && pathIndex + 1 < fieldPointables.length) {
                        // Move to the next Depth
                        recTypeInfos[pathIndex + 1].reset((ARecordType) subType);
                    }
                    if (subType.getTypeTag().equals(ATypeTag.UNION)) {
                        subTypeTag = ((AUnionType) subType).getActualType().getTypeTag();
                        subFieldLength = NonTaggedFormatUtil.getFieldValueLength(serRecord, subFieldOffset, subTypeTag, false);
                    } else {
                        subTypeTag = subType.getTypeTag();
                        subFieldLength = NonTaggedFormatUtil.getFieldValueLength(serRecord, subFieldOffset, subTypeTag, false);
                    }
                    if (pathIndex < fieldPointables.length - 1) {
                        //setup next iteration
                        subRecordTmpStream.reset();
                        subRecordTmpStream.write(subTypeTag.serialize());
                        subRecordTmpStream.write(serRecord, subFieldOffset, subFieldLength);
                        serRecord = subRecordTmpStream.getByteArray();
                        start = 0;
                    }
                    // type check
                    if (pathIndex < fieldPointables.length - 1 && serRecord[start] != ATypeTag.SERIALIZED_RECORD_TYPE_TAG) {
                        throw new UnsupportedTypeException(BuiltinFunctions.FIELD_ACCESS_NESTED, serRecord[start]);
                    }
                }
                // Moving through open fields after we hit the first open field.
                for (; pathIndex < fieldPointables.length; pathIndex++) {
                    openField = true;
                    subFieldOffset = ARecordSerializerDeserializer.getFieldOffsetByName(serRecord, start, len, fieldPointables[pathIndex].getByteArray(), fieldPointables[pathIndex].getStartOffset());
                    if (subFieldOffset < 0) {
                        out.writeByte(ATypeTag.SERIALIZED_MISSING_TYPE_TAG);
                        result.set(resultStorage);
                        return;
                    }
                    subTypeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(serRecord[subFieldOffset]);
                    subFieldLength = NonTaggedFormatUtil.getFieldValueLength(serRecord, subFieldOffset, subTypeTag, true) + 1;
                    if (pathIndex >= fieldPointables.length - 1) {
                        continue;
                    }
                    //setup next iteration
                    start = subFieldOffset;
                    len = subFieldLength;
                    // type check
                    if (serRecord[start] == ATypeTag.SERIALIZED_MISSING_TYPE_TAG) {
                        missingSerde.serialize(AMissing.MISSING, out);
                        result.set(resultStorage);
                        return;
                    }
                    if (serRecord[start] != ATypeTag.SERIALIZED_RECORD_TYPE_TAG) {
                        throw new UnsupportedTypeException(BuiltinFunctions.FIELD_ACCESS_NESTED.getName(), serRecord[start]);
                    }
                }
                // emit the final result.
                if (openField) {
                    result.set(serRecord, subFieldOffset, subFieldLength);
                } else {
                    out.writeByte(subTypeTag.serialize());
                    out.write(serRecord, subFieldOffset, subFieldLength);
                    result.set(resultStorage);
                }
            } catch (IOException | AsterixException e) {
                throw new HyracksDataException(e);
            }
        }
    };
}
Also used : DataOutput(java.io.DataOutput) AUnionType(org.apache.asterix.om.types.AUnionType) ByteArrayAccessibleOutputStream(org.apache.hyracks.data.std.util.ByteArrayAccessibleOutputStream) 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) HyracksDataException(org.apache.hyracks.api.exceptions.HyracksDataException) ArrayBackedValueStorage(org.apache.hyracks.data.std.util.ArrayBackedValueStorage) AsterixException(org.apache.asterix.common.exceptions.AsterixException) ATypeTag(org.apache.asterix.om.types.ATypeTag) VoidPointable(org.apache.hyracks.data.std.primitive.VoidPointable) IFrameTupleReference(org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference) UnsupportedTypeException(org.apache.asterix.runtime.exceptions.UnsupportedTypeException) RuntimeRecordTypeInfo(org.apache.asterix.om.types.runtime.RuntimeRecordTypeInfo) AString(org.apache.asterix.om.base.AString) ARecordType(org.apache.asterix.om.types.ARecordType) IAType(org.apache.asterix.om.types.IAType)

Example 3 with UnsupportedTypeException

use of org.apache.asterix.runtime.exceptions.UnsupportedTypeException 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 4 with UnsupportedTypeException

use of org.apache.asterix.runtime.exceptions.UnsupportedTypeException in project asterixdb by apache.

the class AStringConstructorDescriptor 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 UTF8StringBuilder builder = new UTF8StringBuilder();

                private GrowableArray baaos = new GrowableArray();

                @Override
                public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
                    try {
                        resultStorage.reset();
                        baaos.reset();
                        eval.evaluate(tuple, inputArg);
                        byte[] serString = inputArg.getByteArray();
                        int offset = inputArg.getStartOffset();
                        int len = inputArg.getLength();
                        ATypeTag tt = ATypeTag.VALUE_TYPE_MAPPING[serString[offset]];
                        if (tt == ATypeTag.STRING) {
                            result.set(inputArg);
                        } else {
                            builder.reset(baaos, len);
                            int startOffset = offset + 1;
                            switch(tt) {
                                case TINYINT:
                                    {
                                        int i = AInt8SerializerDeserializer.getByte(serString, startOffset);
                                        builder.appendString(String.valueOf(i));
                                        break;
                                    }
                                case SMALLINT:
                                    {
                                        int i = AInt16SerializerDeserializer.getShort(serString, startOffset);
                                        builder.appendString(String.valueOf(i));
                                        break;
                                    }
                                case INTEGER:
                                    {
                                        int i = AInt32SerializerDeserializer.getInt(serString, startOffset);
                                        builder.appendString(String.valueOf(i));
                                        break;
                                    }
                                case BIGINT:
                                    {
                                        long l = AInt64SerializerDeserializer.getLong(serString, startOffset);
                                        builder.appendString(String.valueOf(l));
                                        break;
                                    }
                                case DOUBLE:
                                    {
                                        double d = ADoubleSerializerDeserializer.getDouble(serString, startOffset);
                                        builder.appendString(String.valueOf(d));
                                        break;
                                    }
                                case FLOAT:
                                    {
                                        float f = AFloatSerializerDeserializer.getFloat(serString, startOffset);
                                        builder.appendString(String.valueOf(f));
                                        break;
                                    }
                                case BOOLEAN:
                                    {
                                        boolean b = ABooleanSerializerDeserializer.getBoolean(serString, startOffset);
                                        builder.appendString(String.valueOf(b));
                                        break;
                                    }
                                // NotYetImplemented
                                case CIRCLE:
                                case DATE:
                                case DATETIME:
                                case LINE:
                                case TIME:
                                case DURATION:
                                case YEARMONTHDURATION:
                                case DAYTIMEDURATION:
                                case INTERVAL:
                                case ARRAY:
                                case POINT:
                                case POINT3D:
                                case RECTANGLE:
                                case POLYGON:
                                case OBJECT:
                                case MULTISET:
                                case UUID:
                                default:
                                    throw new UnsupportedTypeException(getIdentifier(), serString[offset]);
                            }
                            builder.finish();
                            out.write(ATypeTag.SERIALIZED_STRING_TYPE_TAG);
                            out.write(baaos.getByteArray(), 0, baaos.getLength());
                            result.set(resultStorage);
                        }
                    } catch (IOException e) {
                        throw new InvalidDataFormatException(getIdentifier(), e, ATypeTag.SERIALIZED_STRING_TYPE_TAG);
                    }
                }
            };
        }
    };
}
Also used : DataOutput(java.io.DataOutput) GrowableArray(org.apache.hyracks.data.std.util.GrowableArray) IPointable(org.apache.hyracks.data.std.api.IPointable) IOException(java.io.IOException) IScalarEvaluator(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator) UTF8StringBuilder(org.apache.hyracks.data.std.util.UTF8StringBuilder) IScalarEvaluatorFactory(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory) InvalidDataFormatException(org.apache.asterix.runtime.exceptions.InvalidDataFormatException) ArrayBackedValueStorage(org.apache.hyracks.data.std.util.ArrayBackedValueStorage) ATypeTag(org.apache.asterix.om.types.ATypeTag) IHyracksTaskContext(org.apache.hyracks.api.context.IHyracksTaskContext) VoidPointable(org.apache.hyracks.data.std.primitive.VoidPointable) IFrameTupleReference(org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference) UnsupportedTypeException(org.apache.asterix.runtime.exceptions.UnsupportedTypeException)

Example 5 with UnsupportedTypeException

use of org.apache.asterix.runtime.exceptions.UnsupportedTypeException in project asterixdb by apache.

the class CheckUnknownDescriptor method createEvaluatorFactory.

@Override
public IScalarEvaluatorFactory createEvaluatorFactory(final IScalarEvaluatorFactory[] args) {
    return new IScalarEvaluatorFactory() {

        private static final long serialVersionUID = 1L;

        @Override
        public IScalarEvaluator createScalarEvaluator(final IHyracksTaskContext ctx) throws HyracksDataException {
            return new IScalarEvaluator() {

                private IPointable inputArg = new VoidPointable();

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

                @Override
                public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
                    eval.evaluate(tuple, inputArg);
                    byte[] data = inputArg.getByteArray();
                    int offset = inputArg.getStartOffset();
                    if (data[offset] == ATypeTag.SERIALIZED_MISSING_TYPE_TAG || data[offset] == ATypeTag.SERIALIZED_NULL_TYPE_TAG) {
                        throw new UnsupportedTypeException(getIdentifier(), data[offset]);
                    }
                    result.set(inputArg);
                }
            };
        }
    };
}
Also used : IHyracksTaskContext(org.apache.hyracks.api.context.IHyracksTaskContext) VoidPointable(org.apache.hyracks.data.std.primitive.VoidPointable) IFrameTupleReference(org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference) UnsupportedTypeException(org.apache.asterix.runtime.exceptions.UnsupportedTypeException) IPointable(org.apache.hyracks.data.std.api.IPointable) IScalarEvaluator(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator) IScalarEvaluatorFactory(org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory)

Aggregations

UnsupportedTypeException (org.apache.asterix.runtime.exceptions.UnsupportedTypeException)5 IScalarEvaluator (org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator)5 IPointable (org.apache.hyracks.data.std.api.IPointable)5 VoidPointable (org.apache.hyracks.data.std.primitive.VoidPointable)5 IFrameTupleReference (org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference)5 DataOutput (java.io.DataOutput)4 IScalarEvaluatorFactory (org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory)4 IHyracksTaskContext (org.apache.hyracks.api.context.IHyracksTaskContext)4 ArrayBackedValueStorage (org.apache.hyracks.data.std.util.ArrayBackedValueStorage)4 IOException (java.io.IOException)3 ATypeTag (org.apache.asterix.om.types.ATypeTag)3 TypeMismatchException (org.apache.asterix.runtime.exceptions.TypeMismatchException)3 AsterixException (org.apache.asterix.common.exceptions.AsterixException)2 ISerializerDeserializer (org.apache.hyracks.api.dataflow.value.ISerializerDeserializer)2 HyracksDataException (org.apache.hyracks.api.exceptions.HyracksDataException)2 AMutableDate (org.apache.asterix.om.base.AMutableDate)1 AMutableDateTime (org.apache.asterix.om.base.AMutableDateTime)1 AMutableDouble (org.apache.asterix.om.base.AMutableDouble)1 AMutableDuration (org.apache.asterix.om.base.AMutableDuration)1 AMutableFloat (org.apache.asterix.om.base.AMutableFloat)1