How to use

ordinal

method

in

org.apache.asterix.om.types.ATypeTag

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

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

private static void addPromotionRule(ATypeTag type1, ATypeTag type2, ITypeConvertComputer promoteComputer) {
  int index = type1.ordinal() * ATypeTag.TYPE_COUNT + type2.ordinal();
  typePromotionHierachyMap.set(index);
  promoteComputerMap.put(index, promoteComputer);
}

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

private static void addDemotionRule(ATypeTag type1, ATypeTag type2, ITypeConvertComputer demoteStrictComputer,
    ITypeConvertComputer demoteLenientComputer) {
  int index = type1.ordinal() * ATypeTag.TYPE_COUNT + type2.ordinal();
  typeDemotionHierachyMap.set(index);
  demoteComputerMap.put(index, Pair.of(demoteStrictComputer, demoteLenientComputer));
}

public static ITypeConvertComputer getTypePromoteComputer(ATypeTag type1, ATypeTag type2) {
  if (canPromote(type1, type2)) {
    return promoteComputerMap.get(type1.ordinal() * ATypeTag.TYPE_COUNT + type2.ordinal());
  }
  return null;
}

public static ITypeConvertComputer getTypeDemoteComputer(ATypeTag type1, ATypeTag type2, boolean strict) {
  if (canDemote(type1, type2)) {
    Pair<ITypeConvertComputer, ITypeConvertComputer> pair =
        demoteComputerMap.get(type1.ordinal() * ATypeTag.TYPE_COUNT + type2.ordinal());
    return strict ? pair.getLeft() : pair.getRight();
  }
  return null;
}

@Override
public void writeToFuncArgs(List<Mutable<ILogicalExpression>> funcArgs) {
  super.writeToFuncArgs(funcArgs);
  // Write search modifier type.
  funcArgs.add(new MutableObject<ILogicalExpression>(
      AccessMethodUtils.createInt32Constant(searchModifierType.ordinal())));
  // Write similarity threshold.
  funcArgs.add(new MutableObject<ILogicalExpression>(new ConstantExpression(similarityThreshold)));
  // Write search key type.
  funcArgs.add(
      new MutableObject<ILogicalExpression>(AccessMethodUtils.createInt32Constant(searchKeyType.ordinal())));
  // Write full-text search information.
  funcArgs.add(
      new MutableObject<ILogicalExpression>(AccessMethodUtils.createBooleanConstant(isFullTextSearchQuery)));
  // Write key var list.
  writeVarList(keyVarList, funcArgs);
  // Write non-key var list.
  if (nonKeyVarList != null) {
    writeVarList(nonKeyVarList, funcArgs);
  }
}

  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 {

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

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

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

if (typeTag.ordinal() > aggType.ordinal()) {
  throw new IncompatibleTypeException(sourceLoc, "min/max", typeTag.serialize(), aggType.serialize());
} else {

private static void generateTests(List<Object[]> outTests, IAType inType, IAType targetType) {
  int value = inType.getTypeTag().ordinal();
  addTest(outTests, inType, createValue(inType, value), targetType, createValue(targetType, value));
  if (ATypeHierarchy.canDemote(inType.getTypeTag(), targetType.getTypeTag())) {
    IAObject inMax = createValue(inType, getMax(inType));
    IAObject inMin = createValue(inType, getMin(inType));
    IAObject targetMax = createValue(targetType, getMax(targetType));
    IAObject targetMin = createValue(targetType, getMin(targetType));
    addTest(outTests, inType, inMax, targetType, targetMax);
    addTest(outTests, inType, inMin, targetType, targetMin);
    if (!isInteger(inType) && isInteger(targetType)) {
      addTest(outTests, inType, createValue(inType, getPositiveInfinity(inType)), targetType, targetMax);
      addTest(outTests, inType, createValue(inType, getNegativeInfinity(inType)), targetType, targetMin);
      addTest(outTests, inType, createValue(inType, getNaN(inType)), targetType, createValue(targetType, 0));
    }
  }
}