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; }
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; }
private boolean processOrderedList(List<IVisitablePointable> itemsLeft, List<IVisitablePointable> itemTagTypesLeft, List<IVisitablePointable> itemsRight, List<IVisitablePointable> itemTagTypesRight) throws HyracksDataException { for (int i = 0; i < itemsLeft.size(); i++) { ATypeTag fieldTypeLeft = PointableHelper.getTypeTag(itemTagTypesLeft.get(i)); if (fieldTypeLeft.isDerivedType() && fieldTypeLeft != PointableHelper.getTypeTag(itemTagTypesRight.get(i))) { return false; } itemVisitorArg.first = itemsRight.get(i); itemsLeft.get(i).accept(visitor, itemVisitorArg); if (itemVisitorArg.second == false) return false; } return true; }
public static Map<TypeSignature, IAType> computeTypes(MetadataTransactionContext mdTxnCtx, TypeExpression typeExpr, String typeName, String typeDataverse, Map<TypeSignature, IAType> typeMap) throws AlgebricksException { Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes = new HashMap<>(); Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes = new HashMap<>(); Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences = new HashMap<>(); firstPass(typeExpr, typeName, typeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences, typeDataverse); secondPass(mdTxnCtx, typeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences, typeDataverse); for (IAType type : typeMap.values()) { if (type.getTypeTag().isDerivedType()) { ((AbstractComplexType) type).generateNestedDerivedTypeNames(); } } return typeMap; }
@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 (itemType.getTypeTag().isDerivedType() && itemType.getTypeName() == null) { AbstractComplexType nestedType = ((AbstractComplexType) itemType); nestedType.setTypeName(getTypeName() + "_Item"); nestedType.generateNestedDerivedTypeNames(); } }
private boolean compareValues(List<IVisitablePointable> fieldTypesLeft, List<IVisitablePointable> fieldValuesLeft, List<IVisitablePointable> fieldNamesRight, List<IVisitablePointable> fieldTypesRight, List<IVisitablePointable> fieldValuesRight) throws HyracksDataException { // Probe phase: Probe items from second record for (int i = 0; i < fieldNamesRight.size(); i++) { IVisitablePointable fieldName = fieldNamesRight.get(i); keyEntry.set(fieldName.getByteArray(), fieldName.getStartOffset(), fieldName.getLength()); BinaryEntry entry = hashMap.get(keyEntry); if (entry == null) { return false; } int fieldIdLeft = AInt32SerializerDeserializer.getInt(entry.getBuf(), entry.getOffset()); ATypeTag fieldTypeLeft = PointableHelper.getTypeTag(fieldTypesLeft.get(fieldIdLeft)); if (fieldTypeLeft.isDerivedType() && fieldTypeLeft != PointableHelper.getTypeTag(fieldTypesRight.get(i))) { return false; } nestedVisitorArg.first = fieldValuesRight.get(i); fieldValuesLeft.get(fieldIdLeft).accept(visitor, nestedVisitorArg); if (nestedVisitorArg.second == false) { return false; } } return true; } }
if (fieldTypeLeft.isDerivedType() && fieldTypeLeft != PointableHelper.getTypeTag(itemTagTypesRight.get(indexRight))) { return false;
@Override protected void processList(ListAccessor listAccessor, IAsterixListBuilder listBuilder) throws IOException { sortedList.clear(); boolean itemInStorage; for (int i = 0; i < listAccessor.size(); i++) { itemInStorage = listAccessor.getOrWriteItem(i, item, storage); if (ATYPETAGDESERIALIZER.deserialize(item.getByteArray()[item.getStartOffset()]).isDerivedType()) { throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLoc); } sortedList.add(item); if (itemInStorage) { storage = (ArrayBackedValueStorage) storageAllocator.allocate(null); } item = pointableAllocator.allocateEmpty(); } while (!sortedList.isEmpty()) { listBuilder.addItem(sortedList.poll()); } } }
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 public void generateNestedDerivedTypeNames() { if (isUnknownableType()) { IAType nullableType = getActualType(); if (nullableType.getTypeTag().isDerivedType() && nullableType.getTypeName() == null) { AbstractComplexType derivedType = (AbstractComplexType) nullableType; derivedType.setTypeName(getTypeName()); derivedType.generateNestedDerivedTypeNames(); } } }
private ILogicalExpression translateConstantValue(IAObject value, SourceLocation sourceLoc) throws CompilationException { ConstantExpression constExpr = new ConstantExpression(new AsterixConstantValue(value)); constExpr.setSourceLocation(sourceLoc); IAType valueType = value.getType(); if (valueType.getTypeTag().isDerivedType()) { ScalarFunctionCallExpression castExpr = new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CAST_TYPE)); castExpr.setSourceLocation(sourceLoc); castExpr.getArguments().add(new MutableObject<>(constExpr)); TypeCastUtils.setRequiredAndInputTypes(castExpr, BuiltinType.ANY, valueType); return castExpr; } else { return constExpr; } }
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); }
return listValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_AUNORDERED_LIST_TYPE); else { if (listItemType.isDerivedType()) return allocateFieldValue(listItemType, b, offset + 1); else return listValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_AORDERED_LIST_TYPE); else { if (listItemType.isDerivedType()) return allocateFieldValue(listItemType, b, offset + 1); else
return; if (oldValueType.isDerivedType()) { throw new TypeMismatchException(sourceLoc, BuiltinFunctions.RECORD_REPLACE, 1, oldValueType.serialize(), "primitive"); if (newValueType.isDerivedType()) { newValueRecordCaster.evaluate(tuple, newValuePointable);
@Override public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException { resultStorage.reset(); eval0.evaluate(tuple, inputRecordPointable); eval1.evaluate(tuple, newFieldNamePointable); eval2.evaluate(tuple, newFieldValuePointable); if (containsMissing(inputRecordPointable, newFieldNamePointable)) { writeTypeTag(ATypeTag.SERIALIZED_MISSING_TYPE_TAG); result.set(resultStorage); return; } final ATypeTag inputObjectType = PointableHelper.getTypeTag(inputRecordPointable); final ATypeTag newFieldNameValueType = PointableHelper.getTypeTag(newFieldNamePointable); if (inputObjectType != ATypeTag.OBJECT || newFieldNameValueType != ATypeTag.STRING) { PointableHelper.setNull(result); return; } inputRecordCaster.evaluate(tuple, inputRecordPointable); final ATypeTag newFieldValueTag = PointableHelper.getTypeTag(newFieldValuePointable); if (newFieldValueTag.isDerivedType()) { argRecordCaster.evaluate(tuple, newFieldValuePointable); } newFieldValueIsMissing = newFieldValueTag == ATypeTag.MISSING; buildOutputRecord(); result.set(resultStorage); }
private void processLists(IPointable[] listsArgs, IAsterixListBuilder listBuilder) throws IOException { boolean itemInStorage; boolean isUsingItem; IPointable item = pointableAllocator.allocateEmpty(); ArrayBackedValueStorage storage = (ArrayBackedValueStorage) storageAllocator.allocate(null); storage.reset(); // process each list one by one for (int listIndex = 0; listIndex < listsArgs.length; listIndex++) { listAccessor.reset(listsArgs[listIndex].getByteArray(), listsArgs[listIndex].getStartOffset()); // process the items of the current list for (int j = 0; j < listAccessor.size(); j++) { itemInStorage = listAccessor.getOrWriteItem(j, item, storage); if (ATYPETAGDESERIALIZER.deserialize(item.getByteArray()[item.getStartOffset()]).isDerivedType() && isComparingElements) { throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLocation); } isUsingItem = processItem(item, listIndex, listBuilder); if (isUsingItem) { item = pointableAllocator.allocateEmpty(); if (itemInStorage) { storage = (ArrayBackedValueStorage) storageAllocator.allocate(null); storage.reset(); } } } } }
private void processList(ListAccessor listAccessor, int listIndex, IAsterixListBuilder listBuilder, boolean initIntersectList) throws IOException { int hash; List<ValueListIndex> sameHashes; boolean itemInStorage; IPointable item = pointableAllocator.allocateEmpty(); ArrayBackedValueStorage storage = (ArrayBackedValueStorage) storageAllocator.allocate(null); storage.reset(); for (int j = 0; j < listAccessor.size(); j++) { itemInStorage = listAccessor.getOrWriteItem(j, item, storage); if (ATYPETAGDESERIALIZER.deserialize(item.getByteArray()[item.getStartOffset()]).isDerivedType()) { throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLoc); } if (notNullAndMissing(item)) { // look up to see if item exists hash = binaryHashFunction.hash(item.getByteArray(), item.getStartOffset(), item.getLength()); sameHashes = hashes.get(hash); if (initIntersectList && initIntersectList(item, hash, sameHashes)) { // item is used item = pointableAllocator.allocateEmpty(); if (itemInStorage) { storage = (ArrayBackedValueStorage) storageAllocator.allocate(null); storage.reset(); } } else { incrementCommonValue(item, sameHashes, listIndex, listBuilder); } } } }