How to use

ATypeTag

in

org.apache.asterix.om.types

public static int getStartSize(byte[] data, int start) {
  if (getIntervalTimeType(data, start) == ATypeTag.DATETIME.serialize()) {
    return Long.BYTES;
  } else {
    return Integer.BYTES;
  }
}

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}

public static IAType getDefaultOpenFieldType(ATypeTag tag) {
  if (tag.equals(ATypeTag.OBJECT))
    return NESTED_OPEN_RECORD_TYPE;
  if (tag.equals(ATypeTag.ARRAY))
    return NESTED_OPEN_AORDERED_LIST_TYPE;
  if (tag.equals(ATypeTag.MULTISET))
    return NESTED_OPEN_AUNORDERED_LIST_TYPE;
  else
    return null;
}

  aggType = typeTag;
} else if (typeTag != ATypeTag.SYSTEM_NULL && !ATypeHierarchy.isCompatible(typeTag, aggType)) {
  if (typeTag.ordinal() > aggType.ordinal()) {
    throw new IncompatibleTypeException(sourceLoc, BuiltinFunctions.AVG, data[offset], aggType.serialize());
  } else {
    throw new IncompatibleTypeException(sourceLoc, BuiltinFunctions.AVG, aggType.serialize(), data[offset]);

if (fieldValueType.getTypeTag().equals(ATypeTag.UNION)) {
  if (((AUnionType) fieldValueType).isUnknownableType()) {
    fieldValueTypeTag = ((AUnionType) fieldValueType).getActualType().getTypeTag();
    fieldValueLength = NonTaggedFormatUtil.getFieldValueLength(serRecord, fieldValueOffset,
        fieldValueTypeTag, false);
    out.writeByte(fieldValueTypeTag.serialize());
  } else {
  fieldValueLength = NonTaggedFormatUtil.getFieldValueLength(serRecord, fieldValueOffset,
      fieldValueTypeTag, false);
  out.writeByte(fieldValueTypeTag.serialize());

  return;
if (oldValueType.isDerivedType()) {
  throw new TypeMismatchException(sourceLoc, BuiltinFunctions.RECORD_REPLACE, 1, oldValueType.serialize(),
      "primitive");
if (newValueType.isDerivedType()) {
  newValueRecordCaster.evaluate(tuple, newValuePointable);

if (ATYPETAGDESERIALIZER.deserialize(valueBytes[valueOffset]).isDerivedType()) {
  throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLocation);
if (!ATYPETAGDESERIALIZER.deserialize(listBytes[listOffset]).isListType()) {
  PointableHelper.setNull(result);
  return;

if (typeTag == null)
  return flatValueAllocator.allocate(null);
else if (typeTag.equals(ATypeTag.OBJECT))
  return recordValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_RECORD_TYPE);
else if (typeTag.equals(ATypeTag.MULTISET)) {
  ATypeTag listItemType = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(b[offset]);
  if (listItemType == ATypeTag.ANY)
    return listValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_AUNORDERED_LIST_TYPE);
  else {
    if (listItemType.isDerivedType())
      return allocateFieldValue(listItemType, b, offset + 1);
    else
          unorederedListTypeAllocator.allocate(TypeTagUtil.getBuiltinTypeByTag(listItemType)));
} else if (typeTag.equals(ATypeTag.ARRAY)) {
  ATypeTag listItemType = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(b[offset]);
  if (listItemType == ATypeTag.ANY)
    return listValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_AORDERED_LIST_TYPE);
  else {
    if (listItemType.isDerivedType())
      return allocateFieldValue(listItemType, b, offset + 1);
    else

@Override
protected ATypeTag getNumericResultType(ATypeTag argTypeMax) {
  return argTypeMax.ordinal() < ATypeTag.FLOAT.ordinal() ? ATypeTag.DOUBLE : argTypeMax;
}

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

  @Override
  public String getConstructor() {
    return getTypeTag().toString().toLowerCase();
  }
}

@Override
public IScalarEvaluatorFactory[] next() {
  IScalarEvaluatorFactory[] scalarEvaluatorFactories = new IScalarEvaluatorFactory[argSize];
  for (int j = 0; j < argSize; ++j) {
    int base = (int) Math.pow(ATypeTag.values().length, j);
    // Enumerates through all possible type tags.
    byte serializedTypeTag = (byte) ((index / base) % ATypeTag.values().length);
    scalarEvaluatorFactories[j] = new ConstantEvalFactory(new byte[] { serializedTypeTag });
  }
  ++index;
  return scalarEvaluatorFactories;
}

@Override
public String toString() {
  return this.name().toLowerCase();
}

@Override
public int hashCode() {
  int result = indicator;
  result = 31 * result + fieldName.hashCode();
  result = 31 * result + fieldType.hashCode();
  return result;
}

  aggType = typeTag;
} else if (typeTag != ATypeTag.SYSTEM_NULL && !ATypeHierarchy.isCompatible(typeTag, aggType)) {
  if (typeTag.ordinal() > aggType.ordinal()) {
    throw new IncompatibleTypeException(sourceLoc, BuiltinFunctions.AVG, bytes[offset],
        aggType.serialize());
  } else {
    throw new IncompatibleTypeException(sourceLoc, BuiltinFunctions.AVG, aggType.serialize(),
        bytes[offset]);
state[start + AGG_TYPE_OFFSET] = aggType.serialize();

  if (subType.getTypeTag().equals(ATypeTag.UNION)) {
    byte serializedTypeTag = subType.getTypeTag().serialize();
    if (serializedTypeTag != ATypeTag.SERIALIZED_RECORD_TYPE_TAG) {
      throw new TypeMismatchException(sourceLoc, serializedTypeTag,
  if (subType.getTypeTag().equals(ATypeTag.UNION)) {
    subTypeTag = ((AUnionType) subType).getActualType().getTypeTag();
    subFieldLength = NonTaggedFormatUtil.getFieldValueLength(serRecord, subFieldOffset,
    subRecordTmpStream.write(subTypeTag.serialize());
    subRecordTmpStream.write(serRecord, subFieldOffset, subFieldLength);
    serRecord = subRecordTmpStream.getByteArray();
  result.set(serRecord, subFieldOffset, subFieldLength);
} else {
  out.writeByte(subTypeTag.serialize());
  out.write(serRecord, subFieldOffset, subFieldLength);
  result.set(resultStorage);

if (!listType.isListType() || Math.floor(maxDouble) < maxDouble || targetTag == ATypeTag.NULL
    || Double.isInfinite(maxDouble) || Double.isNaN(maxDouble)) {
  PointableHelper.setNull(result);
if (targetTag.isDerivedType()) {
  throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLoc);

public static boolean canPromote(ATypeTag type1, ATypeTag type2) {
  return typePromotionHierachyMap.get(type1.ordinal() * ATypeTag.TYPE_COUNT + type2.ordinal());
}

@Override
protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException {
  IAType argType = strippedInputTypes[0];
  IAType outputType = resultType;
  if (!argType.getTypeTag().isListType() || isUnknownable(((AbstractCollectionType) argType).getItemType())) {
    outputType = AUnionType.createUnknownableType(outputType);
  }
  return outputType;
}

@Override
public String toString() {
  return getTypeTag().toString();
}