@Override public void generateNestedDerivedTypeNames() { if (itemType.getTypeTag().isDerivedType() && itemType.getTypeName() == null) { AbstractComplexType nestedType = ((AbstractComplexType) itemType); nestedType.setTypeName(getTypeName() + "_Item"); nestedType.generateNestedDerivedTypeNames(); } }
@Override public void generateNestedDerivedTypeNames() { for (int i = 0; i < fieldTypes.length; i++) { IAType fieldType = fieldTypes[i]; if (fieldType.getTypeTag().isDerivedType() && (fieldType.getTypeName() == null)) { AbstractComplexType nestedType = (AbstractComplexType) fieldType; nestedType.setTypeName(getTypeName() + "_" + fieldNames[i]); nestedType.generateNestedDerivedTypeNames(); } } }
@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(); } } }
@Override protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException { IAType argType = strippedInputTypes[0]; switch (argType.getTypeTag()) { case ARRAY: return argType; case MULTISET: return new AOrderedListType(((AUnorderedListType) argType).getItemType(), null); default: return new AOrderedListType(argType, null); } } }
private boolean hasDerivedType(IAType[] types) { for (IAType type : types) { if (type.getTypeTag().isDerivedType()) { return true; } } return false; }
@Override protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException { IAType type = strippedInputTypes[0]; if (type.getTypeTag().isListType()) { return AUnionType.createNullableType(((AbstractCollectionType) type).getItemType()); } return BuiltinType.ANY; } }
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; } }
@Override protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException { IAType type = strippedInputTypes[0]; if (type.getTypeTag() == ATypeTag.ANY) { return BuiltinType.ANY; } IAType itemType = ((AbstractCollectionType) type).getItemType(); if (itemType.getTypeTag() == ATypeTag.ANY) { return itemType; } // Could have out-of-bound access or null elements. return AUnionType.createUnknownableType(itemType); }
private IAType getActualType(IAType definedType) { if (definedType.getTypeTag() == ATypeTag.UNION) { return ((AUnionType) definedType).getActualType(); } return definedType; }
/** * Maintains the {@code updatedRecordType} as nullable/missable (?) in case it was originally nullable/missable * @param originalRecordType the original record type * @param updatedRecordType the original record type being enforced/modified with new non-declared fields included * @return {@code updatedRecordType} */ private static IAType keepUnknown(IAType originalRecordType, ARecordType updatedRecordType) { if (originalRecordType.getTypeTag() == ATypeTag.UNION) { return AUnionType.createUnknownableType(updatedRecordType, updatedRecordType.getTypeName()); } return updatedRecordType; }
public static IAType createMissableType(IAType t) { if (t != null && t.getTypeTag() == ATypeTag.MISSING) { return t; } String s = t != null ? t.getTypeName() : null; return createMissableType(t, s == null ? null : s + "?"); }
/** * Decide whether a type is an optional type * * @param type * @return true if it is optional; false otherwise */ public static boolean isOptional(IAType type) { return type.getTypeTag() == ATypeTag.UNION && ((AUnionType) type).isUnknownableType(); }
public UnorderedListConstructorEvaluatorFactory(IScalarEvaluatorFactory[] args, AUnorderedListType type) { this.args = args; this.unorderedlistType = type; if (type == null || type.getItemType() == null || type.getItemType().getTypeTag() == ATypeTag.ANY) { this.selfDescList = true; } else { this.homoList = true; } }
@Override public IAType computeType(ILogicalExpression expression, IVariableTypeEnvironment env, IMetadataProvider<?, ?> metadataProvider) throws AlgebricksException { return new AUnorderedListType(((AUnorderedListType) type).getItemType(), type.getTypeName()); }
protected boolean isNullableType(IAType definedType) { if (definedType.getTypeTag() != ATypeTag.UNION) { return false; } return ((AUnionType) definedType).isNullableType(); }
@Override public boolean deepEqual(IAObject obj) { if (obj == this) { return true; } if (!(obj instanceof BuiltinType)) { return false; } return ((BuiltinType) obj).getTypeTag().equals(getTypeTag()); }
private boolean hasDerivedType(IAType[] types) { for (IAType type : types) { if (type.getTypeTag().isDerivedType()) { return true; } } return false; }
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; }
private boolean hasDerivedType(IAType[] types) { for (IAType type : types) { if (type.getTypeTag().isDerivedType()) { return true; } } return false; }
private boolean hasDerivedType(IAType[] types) { for (IAType type : types) { if (type.getTypeTag().isDerivedType()) { return true; } } return false; }