Allow binary arithmetic operation between string and numerics

Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>

Author: yuancu

core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java

@@ -14,11 +14,15 @@
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlIntervalQualifier;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.sql.validate.implicit.TypeCoercionImpl;
 import org.opensearch.sql.ast.expression.SpanUnit;
 import org.opensearch.sql.calcite.type.AbstractExprRelDataType;
 import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
@@ -185,4 +189,34 @@ else if ((SqlTypeUtil.isApproximateNumeric(sourceType) || SqlTypeUtil.isDecimal(
     }
     return super.makeCast(pos, type, exp, matchNullability, safe, format);
   }
+
+  /**
+   * Derives the return type of call to an operator.
+   *
+   * <p>In Calcite, coercion between STRING and NUMERIC operands takes place during converting SQL
+   * to RelNode. However, as we are building logical plans directly, the coercion is not yet
+   * implemented at this point. Hence, we duplicate {@link
+   * TypeCoercionImpl#binaryArithmeticWithStrings} here to infer the correct type, enabling
+   * operations like {@code "5" / 10}. The actual coercion will be inserted later when performing
+   * validation on SqlNode.
+   *
+   * @see TypeCoercionImpl#binaryArithmeticCoercion(SqlCallBinding)
+   * @param op the operator being called
+   * @param exprs actual operands
+   * @return derived type
+   */
+  @Override
+  public RelDataType deriveReturnType(SqlOperator op, List<? extends RexNode> exprs) {
+    if (op.getKind().belongsTo(SqlKind.BINARY_ARITHMETIC) && exprs.size() == 2) {
+      final RelDataType type1 = exprs.get(0).getType();
+      final RelDataType type2 = exprs.get(1).getType();
+      if (OpenSearchTypeFactory.isNumericType(type1) && OpenSearchTypeFactory.isCharacter(type2)) {
+        return type1;
+      } else if (OpenSearchTypeFactory.isCharacter(type1)
+          && OpenSearchTypeFactory.isNumericType(type2)) {
+        return type2;
+      }
+    }
+    return super.deriveReturnType(op, exprs);
+  }
 }

core/src/main/java/org/opensearch/sql/expression/function/CoercionUtils.java

@@ -925,7 +925,7 @@ void populate() {
       FunctionImp add =
           (builder, args) -> {
             SqlOperator op =
-                (Stream.of(args).map(RexNode::getType).anyMatch(OpenSearchTypeFactory::isCharacter))
+                (Stream.of(args).map(RexNode::getType).allMatch(OpenSearchTypeFactory::isCharacter))
                     ? SqlStdOperatorTable.CONCAT
                     : SqlStdOperatorTable.PLUS;
             return builder.makeCall(op, args);