How to use

isDerivedType

method

in

org.apache.asterix.om.types.ATypeTag

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);
      }
    }
  }
}