private IAType getOutputPrimeType(AUnionType type) { return type.getActualType(); }
private IAType getActualType(IAType definedType) { if (definedType.getTypeTag() == ATypeTag.UNION) { return ((AUnionType) definedType).getActualType(); } return definedType; }
public static IAType getActualType(IAType inputType) { return inputType.getTypeTag() == ATypeTag.UNION ? ((AUnionType) inputType).getActualType() : inputType; }
public static Pair<IAType, Boolean> getNonNullableType(IAType keyType) { boolean nullable = false; IAType actualKeyType = keyType; if (NonTaggedFormatUtil.isOptional(keyType)) { actualKeyType = ((AUnionType) keyType).getActualType(); nullable = true; } return new Pair<>(actualKeyType, nullable); }
public IAType getClosedFieldType(ARecordType recordType, int fieldId) { IAType aType = recordType.getFieldTypes()[fieldId]; if (NonTaggedFormatUtil.isOptional(aType)) { // optional field: add the embedded non-null type tag aType = ((AUnionType) aType).getActualType(); } return aType; }
private boolean validateUnionType(IAType type, IAdmNode node) { if (node == null || node.getType() == ATypeTag.NULL) { return true; } return validate(((AUnionType) type).getActualType(), node); }
public static boolean isClosed(IAType t) { switch (t.getTypeTag()) { case MISSING: case ANY: return false; case UNION: return isClosed(((AUnionType) t).getActualType()); default: return true; } }
private IAType getActualType(IAType t) throws AlgebricksException { switch (t.getTypeTag()) { case ANY: case OBJECT: return t; case UNION: return ((AUnionType) t).getActualType(); default: throw new AlgebricksException("Cannot call field-access on data of type " + t); } }
public static AOrderedListType extractOrderedListType(IAType t) { if (t.getTypeTag() == ATypeTag.ARRAY) { return (AOrderedListType) t; } if (t.getTypeTag() == ATypeTag.UNION) { IAType innerType = ((AUnionType) t).getActualType(); if (innerType.getTypeTag() == ATypeTag.ARRAY) { return (AOrderedListType) innerType; } } return null; }
@Override public IAType computeType(ILogicalExpression expression, IVariableTypeEnvironment env, IMetadataProvider<?, ?> metadataProvider) throws AlgebricksException { AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) expression; IAType type = (IAType) env.getType(f.getArguments().get(0).getValue()); if (type.getTypeTag() != ATypeTag.UNION) { // directly return the input type if it is not a union return type; } AUnionType unionType = (AUnionType) type; return unionType.getActualType(); } }
private IAType getComplexType(IAType aObjectType, ATypeTag tag) { if (aObjectType == null) { return null; } if (aObjectType.getTypeTag() == tag) { return aObjectType; } if (aObjectType.getTypeTag() == ATypeTag.UNION) { AUnionType unionType = (AUnionType) aObjectType; IAType type = unionType.getActualType(); if (type.getTypeTag() == tag) { return type; } } return null; // wont get here }
/** * Check if the type is optional boolean or not * * @param type * @return true if it is; false otherwise. */ private boolean isPossibleBoolean(IAType type) { IAType checkingType = type; while (NonTaggedFormatUtil.isOptional(checkingType)) { IAType actualType = ((AUnionType) checkingType).getActualType(); if (actualType.getTypeTag() == ATypeTag.BOOLEAN || actualType.getTypeTag() == ATypeTag.ANY) { return true; } checkingType = actualType; } return false; }
@Override public void init() throws HyracksDataException { nullPrinter = (ADMPrinterFactoryProvider.INSTANCE.getPrinterFactory(BuiltinType.ANULL)).createPrinter(); fieldPrinter = (ADMPrinterFactoryProvider.INSTANCE.getPrinterFactory(unionType.getActualType())) .createPrinter(); }
@Override public void init() throws HyracksDataException { nullPrinter = (CleanJSONPrinterFactoryProvider.INSTANCE.getPrinterFactory(BuiltinType.AMISSING)) .createPrinter(); fieldPrinter = (CleanJSONPrinterFactoryProvider.INSTANCE.getPrinterFactory(unionType.getActualType())) .createPrinter(); }
@Override public void init() throws HyracksDataException { nullPrinter = (CSVPrinterFactoryProvider.INSTANCE.getPrinterFactory(BuiltinType.AMISSING)).createPrinter(); fieldPrinter = (CSVPrinterFactoryProvider.INSTANCE.getPrinterFactory(unionType.getActualType())) .createPrinter(); }
@Override public void init() throws HyracksDataException { nullPrinter = (LosslessJSONPrinterFactoryProvider.INSTANCE.getPrinterFactory(BuiltinType.AMISSING)) .createPrinter(); fieldPrinter = (LosslessJSONPrinterFactoryProvider.INSTANCE.getPrinterFactory(unionType.getActualType())) .createPrinter(); }
public static final boolean isFixedSizedCollection(IAType type) { switch (type.getTypeTag()) { case UNION: if (!((AUnionType) type).isUnknownableType()) { return false; } else { return isFixedSizedCollection(((AUnionType) type).getActualType()); } default: return isFixedSizedCollection(type.getTypeTag()); } }
public ARecordSerializerDeserializer(ARecordType recordType) { if (recordType != null) { this.recordType = recordType; this.numberOfSchemaFields = recordType.getFieldNames().length; serializers = new ISerializerDeserializer[numberOfSchemaFields]; deserializers = new ISerializerDeserializer[numberOfSchemaFields]; for (int i = 0; i < numberOfSchemaFields; i++) { IAType t = recordType.getFieldTypes()[i]; IAType t2 = (t.getTypeTag() == ATypeTag.UNION) ? ((AUnionType) t).getActualType() : t; serializers[i] = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(t2); deserializers[i] = SerializerDeserializerProvider.INSTANCE.getNonTaggedSerializerDeserializer(t2); } } else { this.recordType = null; this.numberOfSchemaFields = 0; this.serializers = null; this.deserializers = null; } }
private void checkTypeCompatibility(IAType type) throws AsterixException { if (UNSUPPORTED_TYPES.contains(type.getTypeTag())) { throw new AsterixException(ErrorCode.TYPE_UNSUPPORTED, JSONDataParserFactory.class.getName(), type.getTypeTag().toString()); } else if (type.getTypeTag() == ATypeTag.ARRAY) { checkTypeCompatibility(((AOrderedListType) type).getItemType()); } else if (type.getTypeTag() == ATypeTag.OBJECT) { checkRecordTypeCompatibility((ARecordType) type); } else if (type.getTypeTag() == ATypeTag.UNION) { checkTypeCompatibility(((AUnionType) type).getActualType()); } //Compatible type }
@Override public void generateNestedDerivedTypeNames() { if (isUnknownableType()) { IAType nullableType = getActualType(); if (nullableType.getTypeTag().isDerivedType() && nullableType.getTypeName() == null) { AbstractComplexType derivedType = (AbstractComplexType) nullableType; derivedType.setTypeName(getTypeName()); derivedType.generateNestedDerivedTypeNames(); } } }