private Type coerceToSingleType(
        StackableAstVisitorContext<Context> context,
        String description,
        List<Expression> expressions) {
      // determine super type
      Type superType = UNKNOWN;

      // Use LinkedHashMultimap to preserve order in which expressions are analyzed within IN list
      Multimap<Type, NodeRef<Expression>> typeExpressions = LinkedHashMultimap.create();
      for (Expression expression : expressions) {
        // We need to wrap as NodeRef since LinkedHashMultimap does not allow duplicated values
        Type type = process(expression, context);
        typeExpressions.put(type, NodeRef.of(expression));
      }

      Set<Type> types = typeExpressions.keySet();

      for (Type type : types) {
        if (superType == UNKNOWN) {
          superType = type;
        } else {
          if (!isTwoTypeComparable(Arrays.asList(superType, type))) {
            throw new SemanticException(
                String.format(
                    "%s must be the same type or coercible to a common type. Cannot find common type between %s and %s, all types (without duplicates): %s",
                    description, superType, type, typeExpressions.keySet()));
          }
        }
        //        Optional<Type> newSuperType = typeCoercion.getCommonSuperType(superType, type);
        //        if (newSuperType.isEmpty()) {
        //          throw semanticException(TYPE_MISMATCH, Iterables.get(typeExpressions.get(type),
        // 0).getNode(),
        //              "%s must be the same type or coercible to a common type. Cannot find common
        // type between %s and %s, all types (without duplicates): %s",
        //              description,
        //              superType,
        //              type,
        //              typeExpressions.keySet());
        //        }
        //        superType = newSuperType.get();
      }

      // verify all expressions can be coerced to the superType
      //      for (Type type : types) {
      //        Collection<NodeRef<Expression>> coercionCandidates = typeExpressions.get(type);

      //        if (!type.equals(superType)) {
      //          if (!typeCoercion.canCoerce(type, superType)) {

      //          }
      //          addOrReplaceExpressionsCoercion(coercionCandidates, type, superType);
      //        }
      //      }

      return superType;
    }
@return the common supertype between the value type and subquery type
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/ExpressionAnalyzer.java