@Override public IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException { IAType inputType = strippedInputTypes[0]; return inputType.getTypeTag() == ATypeTag.DOUBLE ? inputType : BuiltinType.ANY; } }
@Override protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException { IAType strippedInputType = strippedInputTypes[0]; return strippedInputType.getTypeTag() == ATypeTag.OBJECT ? strippedInputType : RecordUtil.FULLY_OPEN_RECORD_TYPE; } }
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 protected void checkArgType(String funcName, int argIndex, IAType type, SourceLocation sourceLoc) throws AlgebricksException { if (argIndex == 1 && type.getTypeTag() != ATypeTag.BOOLEAN) { throw new TypeMismatchException(sourceLoc, funcName, argIndex, type.getTypeTag(), ATypeTag.BOOLEAN); } }
private static boolean isInteger(IAType type) { switch (type.getTypeTag()) { case TINYINT: case SMALLINT: case INTEGER: case BIGINT: return true; default: return false; } } }
private IAType getActualType(IAType definedType) { if (definedType.getTypeTag() == ATypeTag.UNION) { return ((AUnionType) definedType).getActualType(); } return definedType; }
@Override public void checkArgType(String funcName, int argIndex, IAType type, SourceLocation sourceLoc) throws AlgebricksException { ATypeTag tag = type.getTypeTag(); if (tag != ATypeTag.STRING) { throw new TypeMismatchException(sourceLoc, funcName, argIndex, tag, ATypeTag.STRING); } }
private boolean validate(IAType type, IAdmNode node) { if (type.getTypeTag().isDerivedType()) { return validateDerivedType(type, node); } else if (node == null) { result = ErrorType.MISSING_UNOPTIONAL_FIELD; return false; } else if (type.getTypeTag() != node.getType()) { setExpectedAndActualType(type.getTypeTag(), node.getType()); return false; } return true; }
@Override protected void checkArgType(String funcName, int argIndex, IAType type, SourceLocation sourceLoc) throws AlgebricksException { ATypeTag actualTypeTag = type.getTypeTag(); if (argIndex == 0 && actualTypeTag != ATypeTag.OBJECT) { throw new TypeMismatchException(sourceLoc, actualTypeTag, ATypeTag.OBJECT); } if (argIndex == 1 && actualTypeTag != ATypeTag.STRING) { throw new TypeMismatchException(sourceLoc, actualTypeTag, ATypeTag.STRING); } }
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); } }
private boolean exprIsRecord(IVariableTypeEnvironment typeEnvironment, ILogicalExpression recordExpr) throws AlgebricksException { if (recordExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) { IAType type = (IAType) typeEnvironment.getType(recordExpr); return type != null && type.getTypeTag() == ATypeTag.OBJECT; } return false; }
private void addField(ARecordType inputRecordType, String fieldName, List<String> resultFieldNames, List<IAType> resultFieldTypes) throws AlgebricksException { resultFieldNames.add(fieldName); if (inputRecordType.getFieldType(fieldName).getTypeTag() == ATypeTag.OBJECT) { ARecordType nestedType = (ARecordType) inputRecordType.getFieldType(fieldName); //Deep Copy prevents altering of input types resultFieldTypes.add(nestedType.deepCopy(nestedType)); } else { resultFieldTypes.add(inputRecordType.getFieldType(fieldName)); } }
public static void serializeTag(IAObject instance, DataOutput out) throws HyracksDataException { IAType t = instance.getType(); ATypeTag tag = t.getTypeTag(); try { out.writeByte(tag.serialize()); } catch (IOException e) { throw HyracksDataException.create(e); } }
private boolean isContainsFuncJoinOptimizable(Index index, IOptimizableFuncExpr optFuncExpr) { if (index.isEnforced()) { return isContainsFuncCompatible(index.getKeyFieldTypes().get(0).getTypeTag(), index.getIndexType()); } else { return isContainsFuncCompatible(optFuncExpr.getFieldType(0).getTypeTag(), index.getIndexType()); } }
public AUnorderedListSerializerDeserializer(AUnorderedListType unorderedlistType) { this.unorderedlistType = unorderedlistType; this.itemType = unorderedlistType.getItemType(); serializer = SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(itemType); deserializer = itemType.getTypeTag() == ATypeTag.ANY ? SerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(itemType) : SerializerDeserializerProvider.INSTANCE.getNonTaggedSerializerDeserializer(itemType); }
public int getClosedFieldSize(ARecordType recordType, int fieldId) throws HyracksDataException { if (isClosedFieldNull(recordType, fieldId)) { return 0; } return NonTaggedFormatUtil.getFieldValueLength(bytes, getClosedFieldOffset(recordType, fieldId), getClosedFieldType(recordType, fieldId).getTypeTag(), false); }
@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 init(PrintStream out, DataGeneratorContext ctx) throws Exception { super.init(out, ctx); if (act.getItemType().getTypeTag() == ATypeTag.STRING) { constructor = null; } else { constructor = getConstructor(act.getItemType()); } }
private void writeCollectionType(Datatype instance, AbstractComplexType type, DataOutput out) throws HyracksDataException { AbstractCollectionType listType = (AbstractCollectionType) type; IAType itemType = listType.getItemType(); if (itemType.getTypeTag().isDerivedType()) { handleNestedDerivedType(itemType.getTypeName(), (AbstractComplexType) itemType, instance, instance.getDataverseName(), instance.getDatatypeName()); } aString.setValue(listType.getItemType().getTypeName()); stringSerde.serialize(aString, out); }