How to use org.apache.calcite.sql.type

 ApproxCountDistinctSqlAggFunction()
 {
  super(
    NAME,
    null,
    SqlKind.OTHER_FUNCTION,
    ReturnTypes.explicit(SqlTypeName.BIGINT),
    InferTypes.VARCHAR_1024,
    OperandTypes.ANY,
    SqlFunctionCategory.STRING,
    false,
    false
  );
 }
}

 QuantileSqlAggFunction()
 {
  super(
    NAME,
    null,
    SqlKind.OTHER_FUNCTION,
    ReturnTypes.explicit(SqlTypeName.DOUBLE),
    null,
    OperandTypes.or(
      OperandTypes.and(
        OperandTypes.sequence(SIGNATURE1, OperandTypes.ANY, OperandTypes.LITERAL),
        OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC)
      ),
      OperandTypes.and(
        OperandTypes.sequence(SIGNATURE2, OperandTypes.ANY, OperandTypes.LITERAL, OperandTypes.LITERAL),
        OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.EXACT_NUMERIC)
      )
    ),
    SqlFunctionCategory.NUMERIC,
    false,
    false
  );
 }
}

private HiveFloorDate(String name) {
 super(name, SqlKind.FLOOR, ReturnTypes.ARG0_OR_EXACT_NO_SCALE, null,
   OperandTypes.sequence(
     "'" + SqlKind.FLOOR + "(<DATE> TO <TIME_UNIT>)'\n"
     + "'" + SqlKind.FLOOR + "(<TIME> TO <TIME_UNIT>)'\n"
     + "'" + SqlKind.FLOOR + "(<TIMESTAMP> TO <TIME_UNIT>)'",
     OperandTypes.DATETIME,
     OperandTypes.ANY),
   SqlFunctionCategory.NUMERIC);
}

private static CalciteUDFInfo getUDFInfo(String hiveUdfName,
  ImmutableList<RelDataType> calciteArgTypes, RelDataType calciteRetType) {
 CalciteUDFInfo udfInfo = new CalciteUDFInfo();
 udfInfo.udfName = hiveUdfName;
 udfInfo.returnTypeInference = ReturnTypes.explicit(calciteRetType);
 udfInfo.operandTypeInference = InferTypes.explicit(calciteArgTypes);
 ImmutableList.Builder<SqlTypeFamily> typeFamilyBuilder = new ImmutableList.Builder<SqlTypeFamily>();
 for (RelDataType at : calciteArgTypes) {
  typeFamilyBuilder.add(Util.first(at.getSqlTypeName().getFamily(), SqlTypeFamily.ANY));
 }
 udfInfo.operandTypeChecker = OperandTypes.family(typeFamilyBuilder.build());
 return udfInfo;
}

final public SqlIdentifier CollectionsTypeName() throws ParseException {
 jj_consume_token(MULTISET);
   {if (true) return new SqlIdentifier(
     SqlTypeName.MULTISET.name(), getPos());}
 throw new Error("Missing return statement in function");
}

  @Override
  public RelDataType toSql(RelDataType type) {
    if (type instanceof JavaType) {
      JavaType javaType = (JavaType) type;
      SqlTypeName sqlTypeName = JavaToSqlTypeConversionRules.instance().lookup(javaType.getJavaClass());
      if (sqlTypeName == null) {
        sqlTypeName = SqlTypeName.ANY;
      }
      return createTypeWithNullability(createSqlType(sqlTypeName), type.isNullable());
    }
    return super.toSql(type);
  }
}

 public SqlFunction build()
 {
  return new SqlFunction(
    name,
    kind,
    Preconditions.checkNotNull(returnTypeInference, "returnTypeInference"),
    null,
    OperandTypes.family(
      Preconditions.checkNotNull(operandTypes, "operandTypes"),
      i -> i + 1 > requiredOperands
    ),
    functionCategory
  );
 }
}

private List<RexNode> rewriteToDateChildren(List<RexNode> childRexNodeLst) {
 List<RexNode> newChildRexNodeLst = new ArrayList<RexNode>();
 assert childRexNodeLst.size() == 1;
 RexNode child = childRexNodeLst.get(0);
 if (SqlTypeUtil.isDatetime(child.getType()) || SqlTypeUtil.isInterval(child.getType())) {
  newChildRexNodeLst.add(child);
 } else {
  newChildRexNodeLst.add(makeCast(SqlTypeName.TIMESTAMP, child));
 }
 return newChildRexNodeLst;
}

private SqlKind getOp(RexCall call) {
 SqlKind op = call.getKind();
 if (call.getKind().equals(SqlKind.OTHER_FUNCTION)
   && SqlTypeUtil.inBooleanFamily(call.getType())) {
  SqlOperator sqlOp = call.getOperator();
  String opName = (sqlOp != null) ? sqlOp.getName() : "";
  if (opName.equalsIgnoreCase("in")) {
   op = SqlKind.IN;
  }
 }
 return op;
}

 private boolean areTypesCompatible(RelDataType type1, RelDataType type2) {
  if (type1.equals(type2)) {
   return true;
  }
  SqlTypeName sqlType1 = type1.getSqlTypeName();
  if (sqlType1 != null) {
   return sqlType1.equals(type2.getSqlTypeName());
  }
  return false;
 }
}

private SqlNode maybeCast(SqlNode node, RelDataType currentType,
  RelDataType desiredType) {
  return currentType.equals(desiredType)
    || (currentType.isNullable() != desiredType.isNullable()
        && typeFactory.createTypeWithNullability(currentType,
    desiredType.isNullable()).equals(desiredType))
    ? node
    : SqlStdOperatorTable.CAST.createCall(SqlParserPos.ZERO,
    node, SqlTypeUtil.convertTypeToSpec(desiredType));
}

private HiveExtractDate(String name) {
 super(name, SqlKind.EXTRACT,
   ReturnTypes.cascade(ReturnTypes.INTEGER, SqlTypeTransforms.FORCE_NULLABLE), null,
   OperandTypes.INTERVALINTERVAL_INTERVALDATETIME,
   SqlFunctionCategory.SYSTEM);
}

private static CalciteUDFInfo getUDFInfo(String hiveUdfName,
  ImmutableList<RelDataType> calciteArgTypes, RelDataType calciteRetType) {
 CalciteUDFInfo udfInfo = new CalciteUDFInfo();
 udfInfo.udfName = hiveUdfName;
 udfInfo.returnTypeInference = ReturnTypes.explicit(calciteRetType);
 udfInfo.operandTypeInference = InferTypes.explicit(calciteArgTypes);
 ImmutableList.Builder<SqlTypeFamily> typeFamilyBuilder = new ImmutableList.Builder<SqlTypeFamily>();
 for (RelDataType at : calciteArgTypes) {
  typeFamilyBuilder.add(Util.first(at.getSqlTypeName().getFamily(), SqlTypeFamily.ANY));
 }
 udfInfo.operandTypeChecker = OperandTypes.family(typeFamilyBuilder.build());
 return udfInfo;
}

public OperatorBuilder nullableReturnType(final SqlTypeName typeName)
{
 this.returnTypeInference = ReturnTypes.explicit(
   factory -> Calcites.createSqlTypeWithNullability(factory, typeName, true)
 );
 return this;
}

final public SqlIdentifier CollectionsTypeName() throws ParseException {
 jj_consume_token(MULTISET);
   {if (true) return new SqlIdentifier(
     SqlTypeName.MULTISET.name(), getPos());}
 throw new Error("Missing return statement in function");
}

private HiveFloorDate(String name) {
 super(name, SqlKind.FLOOR, ReturnTypes.ARG0_OR_EXACT_NO_SCALE, null,
   OperandTypes.sequence(
     "'" + SqlKind.FLOOR + "(<DATE> TO <TIME_UNIT>)'\n"
     + "'" + SqlKind.FLOOR + "(<TIME> TO <TIME_UNIT>)'\n"
     + "'" + SqlKind.FLOOR + "(<TIMESTAMP> TO <TIME_UNIT>)'",
     OperandTypes.DATETIME,
     OperandTypes.ANY),
   SqlFunctionCategory.NUMERIC);
}

protected void validateWhereOrOn(
  SqlValidatorScope scope,
  SqlNode condition,
  String clause) {
  validateNoAggs(aggOrOverOrGroupFinder, condition, clause);
  inferUnknownTypes(
    booleanType,
    scope,
    condition);
  condition.validate(this, scope);
  final RelDataType type = deriveType(scope, condition);
  if (!SqlTypeUtil.inBooleanFamily(type)) {
    throw newValidationError(condition, RESOURCE.condMustBeBoolean(clause));
  }
}

SqlAggFunction createCustomAggFunction(String funcName, RelDataType returnType, Class<?> customAggFuncClz) {
  RelDataTypeFactory typeFactory = getCluster().getTypeFactory();
  SqlIdentifier sqlIdentifier = new SqlIdentifier(funcName, new SqlParserPos(1, 1));
  AggregateFunction aggFunction = AggregateFunctionImpl.create(customAggFuncClz);
  List<RelDataType> argTypes = new ArrayList<RelDataType>();
  List<SqlTypeFamily> typeFamilies = new ArrayList<SqlTypeFamily>();
  for (FunctionParameter o : aggFunction.getParameters()) {
    final RelDataType type = o.getType(typeFactory);
    argTypes.add(type);
    typeFamilies.add(Util.first(type.getSqlTypeName().getFamily(), SqlTypeFamily.ANY));
  }
  return new SqlUserDefinedAggFunction(sqlIdentifier, ReturnTypes.explicit(returnType),
      InferTypes.explicit(argTypes), OperandTypes.family(typeFamilies), aggFunction, false, false,
      typeFactory);
}

public OperatorBuilder returnType(final SqlTypeName typeName)
{
 this.returnTypeInference = ReturnTypes.explicit(
   factory -> Calcites.createSqlType(factory, typeName)
 );
 return this;
}

@Override
public AggregateCall other(RelDataTypeFactory typeFactory, AggregateCall e) {
 RelDataType countRetType = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.BIGINT), true);
 return AggregateCall.create(
  new HiveSqlCountAggFunction(isDistinct, ReturnTypes.explicit(countRetType), operandTypeInference, operandTypeChecker),
  false, ImmutableIntList.of(), -1, countRetType, "count");
}