Examples with IAType org.apache.asterix.om.types.IAType used on opensource projects

Example 81 with IAType

use of org.apache.asterix.om.types.IAType in project asterixdb by apache.

the class ADMDataParser method parseRecord.

private void parseRecord(ARecordType recType, DataOutput out) throws IOException {
    ArrayBackedValueStorage fieldValueBuffer = getTempBuffer();
    ArrayBackedValueStorage fieldNameBuffer = getTempBuffer();
    IARecordBuilder recBuilder = getRecordBuilder();
    BitSet nulls = null;
    if (recType != null) {
        // TODO: use BitSet Pool
        nulls = new BitSet(recType.getFieldNames().length);
        recBuilder.reset(recType);
    } else {
        recBuilder.reset(null);
    }
    recBuilder.init();
    int token;
    boolean inRecord = true;
    boolean expectingRecordField = false;
    boolean first = true;
    Boolean openRecordField = false;
    int fieldId = 0;
    IAType fieldType = null;
    do {
        token = admLexer.next();
        switch(token) {
            case AdmLexer.TOKEN_END_RECORD:
                if (expectingRecordField) {
                    throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_RECORD_END_UNEXPECTED);
                }
                inRecord = false;
                break;
            case AdmLexer.TOKEN_STRING_LITERAL:
                // we've read the name of the field
                // now read the content
                fieldNameBuffer.reset();
                fieldValueBuffer.reset();
                expectingRecordField = false;
                if (recType != null) {
                    String fldName = admLexer.getLastTokenImage().substring(1, admLexer.getLastTokenImage().length() - 1);
                    fieldId = recBuilder.getFieldId(fldName);
                    if ((fieldId < 0) && !recType.isOpen()) {
                        throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_EXTRA_FIELD_IN_CLOSED_RECORD, fldName);
                    } else if ((fieldId < 0) && recType.isOpen()) {
                        aStringFieldName.setValue(admLexer.getLastTokenImage().substring(1, admLexer.getLastTokenImage().length() - 1));
                        stringSerde.serialize(aStringFieldName, fieldNameBuffer.getDataOutput());
                        openRecordField = true;
                        fieldType = null;
                    } else {
                        // a closed field
                        nulls.set(fieldId);
                        fieldType = recType.getFieldTypes()[fieldId];
                        openRecordField = false;
                    }
                } else {
                    aStringFieldName.setValue(admLexer.getLastTokenImage().substring(1, admLexer.getLastTokenImage().length() - 1));
                    stringSerde.serialize(aStringFieldName, fieldNameBuffer.getDataOutput());
                    openRecordField = true;
                    fieldType = null;
                }
                token = admLexer.next();
                if (token != AdmLexer.TOKEN_COLON) {
                    throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_UNEXPECTED_TOKEN_WHEN_EXPECT_COMMA, AdmLexer.tokenKindToString(token));
                }
                token = admLexer.next();
                this.admFromLexerStream(token, fieldType, fieldValueBuffer.getDataOutput());
                if (openRecordField) {
                    recBuilder.addField(fieldNameBuffer, fieldValueBuffer);
                } else {
                    recBuilder.addField(fieldId, fieldValueBuffer);
                }
                break;
            case AdmLexer.TOKEN_COMMA:
                if (first) {
                    throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_FOUND_COMMA_WHEN, "before any");
                }
                if (expectingRecordField) {
                    throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_FOUND_COMMA_WHEN, "expecting a");
                }
                expectingRecordField = true;
                break;
            default:
                throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_UNEXPECTED_TOKEN_KIND, AdmLexer.tokenKindToString(token));
        }
        first = false;
    } while (inRecord);
    if (recType != null) {
        final int nullableFieldId = checkOptionalConstraints(recType, nulls);
        if (nullableFieldId != -1) {
            throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_FIELD_NOT_NULL, recType.getFieldNames()[nullableFieldId]);
        }
    }
    recBuilder.write(out, true);
}

Example 82 with IAType

use of org.apache.asterix.om.types.IAType in project asterixdb by apache.

the class ADMDataParser method parseOrderedList.

private void parseOrderedList(AOrderedListType oltype, DataOutput out) throws IOException {
    ArrayBackedValueStorage itemBuffer = getTempBuffer();
    OrderedListBuilder orderedListBuilder = (OrderedListBuilder) getOrderedListBuilder();
    IAType itemType = null;
    if (oltype != null) {
        itemType = oltype.getItemType();
    }
    orderedListBuilder.reset(oltype);
    int token;
    boolean inList = true;
    boolean expectingListItem = false;
    boolean first = true;
    do {
        token = admLexer.next();
        if (token == AdmLexer.TOKEN_END_ORDERED_LIST) {
            if (expectingListItem) {
                throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_LIST_FOUND_END_COLLECTION);
            }
            inList = false;
        } else if (token == AdmLexer.TOKEN_COMMA) {
            if (first) {
                throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_LIST_FOUND_COMMA_BEFORE_LIST);
            }
            if (expectingListItem) {
                throw new ParseException(ErrorCode.PARSER_ADM_DATA_PARSER_LIST_FOUND_COMMA_EXPECTING_ITEM);
            }
            expectingListItem = true;
        } else {
            expectingListItem = false;
            itemBuffer.reset();
            admFromLexerStream(token, itemType, itemBuffer.getDataOutput());
            orderedListBuilder.addItem(itemBuffer);
        }
        first = false;
    } while (inList);
    orderedListBuilder.write(out, true);
}

Example 83 with IAType

use of org.apache.asterix.om.types.IAType in project asterixdb by apache.

the class JObjectUtil method mergeRecordTypes.

private static ARecordType mergeRecordTypes(ARecordType recType1, ARecordType recType2) {
    String[] fieldNames = new String[recType1.getFieldNames().length + recType2.getFieldNames().length];
    IAType[] fieldTypes = new IAType[recType1.getFieldTypes().length + recType2.getFieldTypes().length];
    int i = 0;
    for (; i < recType1.getFieldNames().length; i++) {
        fieldNames[i] = recType1.getFieldNames()[i];
        fieldTypes[i] = recType1.getFieldTypes()[i];
    }
    for (int j = 0; j < recType2.getFieldNames().length; i++, j++) {
        fieldNames[i] = recType2.getFieldNames()[j];
        fieldTypes[i] = recType2.getFieldTypes()[j];
    }
    return new ARecordType(null, fieldNames, fieldTypes, true);
}

Example 84 with IAType

use of org.apache.asterix.om.types.IAType in project asterixdb by apache.

the class JObjectUtil method getJType.

public static IJObject getJType(ATypeTag typeTag, IAType type, ByteArrayAccessibleDataInputStream dis, IObjectPool<IJObject, IAType> objectPool) throws IOException {
    IJObject jObject;
    switch(typeTag) {
        case INTEGER:
            {
                int v = dis.readInt();
                jObject = objectPool.allocate(BuiltinType.AINT32);
                ((JInt) jObject).setValue(v);
                break;
            }
        case FLOAT:
            {
                float v = dis.readFloat();
                jObject = objectPool.allocate(BuiltinType.AFLOAT);
                ((JFloat) jObject).setValue(v);
                break;
            }
        case DOUBLE:
            {
                double value = dis.readDouble();
                jObject = objectPool.allocate(BuiltinType.ADOUBLE);
                ((JDouble) jObject).setValue(value);
                break;
            }
        case STRING:
            {
                String v = dis.readUTF();
                jObject = objectPool.allocate(BuiltinType.ASTRING);
                ((JString) jObject).setValue(v);
                break;
            }
        case BOOLEAN:
            jObject = objectPool.allocate(BuiltinType.ABOOLEAN);
            ((JBoolean) jObject).setValue(dis.readBoolean());
            break;
        case DATE:
            {
                int d = dis.readInt();
                jObject = objectPool.allocate(BuiltinType.ADATE);
                ((JDate) jObject).setValue(d);
                break;
            }
        case DATETIME:
            {
                jObject = objectPool.allocate(BuiltinType.ADATETIME);
                long value = dis.readLong();
                ((JDateTime) jObject).setValue(value);
                break;
            }
        case DURATION:
            {
                jObject = objectPool.allocate(BuiltinType.ADURATION);
                int months = dis.readInt();
                long msecs = dis.readLong();
                ((JDuration) jObject).setValue(months, msecs);
                break;
            }
        case TIME:
            {
                jObject = objectPool.allocate(BuiltinType.ATIME);
                int time = dis.readInt();
                ((JTime) jObject).setValue(time);
                break;
            }
        case INTERVAL:
            {
                jObject = objectPool.allocate(BuiltinType.AINTERVAL);
                long start = dis.readLong();
                long end = dis.readLong();
                byte intervalType = dis.readByte();
                ((JInterval) jObject).setValue(start, end, intervalType);
                break;
            }
        case CIRCLE:
            {
                jObject = objectPool.allocate(BuiltinType.ACIRCLE);
                double x = dis.readDouble();
                double y = dis.readDouble();
                double radius = dis.readDouble();
                JPoint jpoint = (JPoint) objectPool.allocate(BuiltinType.APOINT);
                jpoint.setValue(x, y);
                ((JCircle) jObject).setValue(jpoint, radius);
                break;
            }
        case POINT:
            {
                jObject = objectPool.allocate(BuiltinType.APOINT);
                double x = dis.readDouble();
                double y = dis.readDouble();
                ((JPoint) jObject).setValue(x, y);
                break;
            }
        case POINT3D:
            {
                jObject = objectPool.allocate(BuiltinType.APOINT3D);
                double x = dis.readDouble();
                double y = dis.readDouble();
                double z = dis.readDouble();
                ((JPoint3D) jObject).setValue(x, y, z);
                break;
            }
        case LINE:
            {
                jObject = objectPool.allocate(BuiltinType.ALINE);
                double x1 = dis.readDouble();
                double y1 = dis.readDouble();
                double x2 = dis.readDouble();
                double y2 = dis.readDouble();
                JPoint jpoint1 = (JPoint) objectPool.allocate(BuiltinType.APOINT);
                jpoint1.setValue(x1, y1);
                JPoint jpoint2 = (JPoint) objectPool.allocate(BuiltinType.APOINT);
                jpoint2.setValue(x2, y2);
                ((JLine) jObject).setValue(jpoint1, jpoint2);
                break;
            }
        case POLYGON:
            {
                jObject = objectPool.allocate(BuiltinType.APOLYGON);
                short numberOfPoints = dis.readShort();
                List<JPoint> points = new ArrayList<JPoint>();
                for (int i = 0; i < numberOfPoints; i++) {
                    JPoint p1 = (JPoint) objectPool.allocate(BuiltinType.APOINT);
                    p1.setValue(dis.readDouble(), dis.readDouble());
                    points.add(p1);
                }
                ((JPolygon) jObject).setValue(points.toArray(new APoint[] {}));
                break;
            }
        case RECTANGLE:
            {
                jObject = objectPool.allocate(BuiltinType.ARECTANGLE);
                double x1 = dis.readDouble();
                double y1 = dis.readDouble();
                double x2 = dis.readDouble();
                double y2 = dis.readDouble();
                JPoint jpoint1 = (JPoint) objectPool.allocate(BuiltinType.APOINT);
                jpoint1.setValue(x1, y1);
                JPoint jpoint2 = (JPoint) objectPool.allocate(BuiltinType.APOINT);
                jpoint2.setValue(x2, y2);
                ((JRectangle) jObject).setValue(jpoint1, jpoint2);
                break;
            }
        case MULTISET:
            {
                AUnorderedListType listType = (AUnorderedListType) type;
                IAType elementType = listType.getItemType();
                jObject = objectPool.allocate(listType);
                boolean fixedSize = false;
                ATypeTag tag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(dis.readByte());
                switch(tag) {
                    case STRING:
                    case OBJECT:
                    case ARRAY:
                    case MULTISET:
                    case ANY:
                        fixedSize = false;
                        break;
                    default:
                        fixedSize = true;
                        break;
                }
                // list size
                dis.readInt();
                int numberOfitems;
                numberOfitems = dis.readInt();
                if (numberOfitems <= 0) {
                    break;
                }
                if (!fixedSize) {
                    for (int i = 0; i < numberOfitems; i++) {
                        dis.readInt();
                    }
                }
                for (int i = 0; i < numberOfitems; i++) {
                    IJObject v = getJType(elementType.getTypeTag(), elementType, dis, objectPool);
                    ((JUnorderedList) jObject).add(v);
                }
                break;
            }
        case ARRAY:
            {
                AOrderedListType listType = (AOrderedListType) type;
                IAType elementType = listType.getItemType();
                jObject = objectPool.allocate(listType);
                boolean fixedSize = false;
                ATypeTag tag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(dis.readByte());
                switch(tag) {
                    case STRING:
                    case OBJECT:
                    case ARRAY:
                    case MULTISET:
                    case ANY:
                        fixedSize = false;
                        break;
                    default:
                        fixedSize = true;
                        break;
                }
                // list size
                dis.readInt();
                int numberOfitems;
                numberOfitems = dis.readInt();
                if (numberOfitems <= 0) {
                    break;
                }
                if (!fixedSize) {
                    for (int i = 0; i < numberOfitems; i++) {
                        dis.readInt();
                    }
                }
                for (int i = 0; i < numberOfitems; i++) {
                    IJObject v = getJType(elementType.getTypeTag(), elementType, dis, objectPool);
                    ((JOrderedList) jObject).add(v);
                }
                break;
            }
        case OBJECT:
            ARecordType recordType = (ARecordType) type;
            int numberOfSchemaFields = recordType.getFieldTypes().length;
            byte[] recordBits = dis.getInputStream().getArray();
            boolean isExpanded = false;
            dis.getInputStream();
            int[] fieldOffsets = new int[numberOfSchemaFields];
            IJObject[] closedFields = new IJObject[numberOfSchemaFields];
            // reading length is not required.
            dis.skip(4);
            if (recordType.isOpen()) {
                isExpanded = dis.readBoolean();
                if (isExpanded) {
                    dis.readInt();
                } else {
                }
            } else {
            }
            if (numberOfSchemaFields > 0) {
                dis.readInt();
                int nullBitMapOffset = 0;
                boolean hasOptionalFields = NonTaggedFormatUtil.hasOptionalField(recordType);
                if (hasOptionalFields) {
                    nullBitMapOffset = dis.getInputStream().getPosition();
                    dis.getInputStream();
                } else {
                    dis.getInputStream();
                }
                for (int i = 0; i < numberOfSchemaFields; i++) {
                    fieldOffsets[i] = dis.readInt();
                }
                for (int fieldNumber = 0; fieldNumber < numberOfSchemaFields; fieldNumber++) {
                    if (hasOptionalFields) {
                        byte b1 = recordBits[nullBitMapOffset + fieldNumber / 8];
                        int p = 1 << (7 - (fieldNumber % 8));
                        if ((b1 & p) == 0) {
                            continue;
                        }
                    }
                    IAType[] fieldTypes = recordType.getFieldTypes();
                    ATypeTag fieldValueTypeTag = null;
                    IAType fieldType = fieldTypes[fieldNumber];
                    if (fieldTypes[fieldNumber].getTypeTag() == ATypeTag.UNION) {
                        if (((AUnionType) fieldTypes[fieldNumber]).isUnknownableType()) {
                            fieldType = ((AUnionType) fieldTypes[fieldNumber]).getActualType();
                            fieldValueTypeTag = fieldType.getTypeTag();
                        }
                    } else {
                        fieldValueTypeTag = fieldTypes[fieldNumber].getTypeTag();
                    }
                    closedFields[fieldNumber] = getJType(fieldValueTypeTag, fieldType, dis, objectPool);
                }
            }
            if (isExpanded) {
                int numberOfOpenFields = dis.readInt();
                String[] fieldNames = new String[numberOfOpenFields];
                IAType[] fieldTypes = new IAType[numberOfOpenFields];
                IJObject[] openFields = new IJObject[numberOfOpenFields];
                for (int i = 0; i < numberOfOpenFields; i++) {
                    dis.readInt();
                    dis.readInt();
                }
                for (int i = 0; i < numberOfOpenFields; i++) {
                    fieldNames[i] = AStringSerializerDeserializer.INSTANCE.deserialize(dis).getStringValue();
                    ATypeTag openFieldTypeTag = SerializerDeserializerUtil.deserializeTag(dis);
                    openFields[i] = getJType(openFieldTypeTag, null, dis, objectPool);
                    fieldTypes[i] = openFields[i].getIAObject().getType();
                }
                ARecordType openPartRecType = new ARecordType(null, fieldNames, fieldTypes, true);
                if (numberOfSchemaFields > 0) {
                    ARecordType mergedRecordType = mergeRecordTypes(recordType, openPartRecType);
                    IJObject[] mergedFields = mergeFields(closedFields, openFields);
                    jObject = objectPool.allocate(recordType);
                    return new JRecord(mergedRecordType, mergedFields);
                } else {
                    return new JRecord(recordType, openFields);
                }
            } else {
                return new JRecord(recordType, closedFields);
            }
        default:
            throw new RuntimeDataException(ErrorCode.LIBRARY_JOBJECT_UTIL_ILLEGAL_ARGU_TYPE, typeTag);
    }
    return jObject;
}

Example 85 with IAType

use of org.apache.asterix.om.types.IAType in project asterixdb by apache.

the class ADMDataParser method checkOptionalConstraints.

private int checkOptionalConstraints(ARecordType recType, BitSet nulls) {
    for (int i = 0; i < recType.getFieldTypes().length; i++) {
        if (nulls.get(i) == false) {
            IAType type = recType.getFieldTypes()[i];
            if ((type.getTypeTag() != ATypeTag.NULL) && (type.getTypeTag() != ATypeTag.UNION)) {
                return i;
            }
            if (type.getTypeTag() != ATypeTag.UNION) {
                continue;
            }
            // union
            AUnionType unionType = (AUnionType) type;
            if (!unionType.isUnknownableType()) {
                return i;
            }
        }
    }
    return -1;
}