Unit test functions under validate folder

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

Author: yuancu

core/src/test/java/org/opensearch/sql/calcite/validate/OpenSearchSparkSqlDialectTest.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.validate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.TYPE_FACTORY;
+
+import java.util.List;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlBasicCall;
+import org.apache.calcite.sql.SqlDataTypeSpec;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.SqlWriterConfig;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.pretty.SqlPrettyWriter;
+import org.apache.calcite.sql.validate.SqlConformance;
+import org.junit.jupiter.api.Test;
+import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.ExprUDT;
+
+public class OpenSearchSparkSqlDialectTest {
+  @Test
+  public void testGetCastSpecForIpType() {
+    RelDataType ipType = TYPE_FACTORY.createUDT(ExprUDT.EXPR_IP);
+
+    SqlNode castSpec = OpenSearchSparkSqlDialect.DEFAULT.getCastSpec(ipType);
+
+    assertNotNull(castSpec);
+    assertInstanceOf(SqlDataTypeSpec.class, castSpec);
+    SqlDataTypeSpec typeSpec = (SqlDataTypeSpec) castSpec;
+    assertEquals("OTHER", typeSpec.getTypeName().toString());
+    assertEquals("IP", typeSpec.toString());
+  }
+
+  private SqlWriter createWriter(StringBuilder sb) {
+    SqlWriterConfig config =
+        SqlPrettyWriter.config().withDialect(OpenSearchSparkSqlDialect.DEFAULT);
+    return new SqlPrettyWriter(config, sb);
+  }
+
+  @Test
+  public void testUnparseCallArgMin() {
+    StringBuilder sb = new StringBuilder();
+    SqlWriter writer = createWriter(sb);
+
+    SqlIdentifier col1 = new SqlIdentifier("value_col", SqlParserPos.ZERO);
+    SqlIdentifier col2 = new SqlIdentifier("key_col", SqlParserPos.ZERO);
+
+    // Create a call that mimics ARG_MIN
+    SqlBasicCall argMinCall =
+        new SqlBasicCall(SqlStdOperatorTable.ARG_MIN, List.of(col1, col2), SqlParserPos.ZERO);
+
+    OpenSearchSparkSqlDialect.DEFAULT.unparseCall(writer, argMinCall, 0, 0);
+    String result = sb.toString();
+
+    // Should be translated to MIN_BY
+    assertTrue(result.contains("MIN_BY"));
+  }
+
+  @Test
+  public void testUnparseCallArgMax() {
+    StringBuilder sb = new StringBuilder();
+    SqlWriter writer = createWriter(sb);
+
+    SqlIdentifier col1 = new SqlIdentifier("value_col", SqlParserPos.ZERO);
+    SqlIdentifier col2 = new SqlIdentifier("key_col", SqlParserPos.ZERO);
+
+    SqlBasicCall argMaxCall =
+        new SqlBasicCall(SqlStdOperatorTable.ARG_MAX, List.of(col1, col2), SqlParserPos.ZERO);
+
+    OpenSearchSparkSqlDialect.DEFAULT.unparseCall(writer, argMaxCall, 0, 0);
+    String result = sb.toString();
+
+    // Should be translated to MAX_BY
+    assertTrue(result.contains("MAX_BY"));
+  }
+
+  @Test
+  public void testUnparseCallRegularOperator() {
+    StringBuilder sb = new StringBuilder();
+    SqlWriter writer = createWriter(sb);
+
+    SqlIdentifier col1 = new SqlIdentifier("col1", SqlParserPos.ZERO);
+    SqlIdentifier col2 = new SqlIdentifier("col2", SqlParserPos.ZERO);
+
+    SqlBasicCall plusCall =
+        new SqlBasicCall(SqlStdOperatorTable.PLUS, List.of(col1, col2), SqlParserPos.ZERO);
+
+    OpenSearchSparkSqlDialect.DEFAULT.unparseCall(writer, plusCall, 0, 0);
+    String result = sb.toString();
+
+    // Should contain the + operator, not translated
+    assertTrue(result.contains("+"));
+  }
+
+  @Test
+  public void testGetConformanceIsLiberal() {
+    SqlConformance conformance = OpenSearchSparkSqlDialect.DEFAULT.getConformance();
+
+    assertNotNull(conformance);
+    assertTrue(conformance.isLiberal());
+  }
+}

core/src/test/java/org/opensearch/sql/calcite/validate/PplTypeCoercionRuleTest.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.validate;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Map;
+import org.apache.calcite.sql.type.SqlTypeCoercionRule;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.junit.jupiter.api.Test;
+
+public class PplTypeCoercionRuleTest {
+  @Test
+  public void testOtherToVarcharCoercion() {
+    SqlTypeCoercionRule rule = PplTypeCoercionRule.instance();
+    Map<SqlTypeName, ImmutableSet<SqlTypeName>> mapping = rule.getTypeMapping();
+
+    // OTHER should be coercible to VARCHAR (IP type support)
+    ImmutableSet<SqlTypeName> varcharCoercions = mapping.get(SqlTypeName.VARCHAR);
+    assertNotNull(varcharCoercions);
+    assertTrue(varcharCoercions.contains(SqlTypeName.OTHER));
+  }
+
+  @Test
+  public void testOtherToCharCoercion() {
+    SqlTypeCoercionRule rule = PplTypeCoercionRule.instance();
+    Map<SqlTypeName, ImmutableSet<SqlTypeName>> mapping = rule.getTypeMapping();
+
+    // OTHER should be coercible to CHAR (IP type support)
+    ImmutableSet<SqlTypeName> charCoercions = mapping.get(SqlTypeName.CHAR);
+    assertNotNull(charCoercions);
+    assertTrue(charCoercions.contains(SqlTypeName.OTHER));
+  }
+
+  @Test
+  public void testVarcharToOtherCoercion() {
+    SqlTypeCoercionRule rule = PplTypeCoercionRule.instance();
+    Map<SqlTypeName, ImmutableSet<SqlTypeName>> mapping = rule.getTypeMapping();
+
+    // VARCHAR should be coercible from OTHER
+    ImmutableSet<SqlTypeName> otherCoercions = mapping.get(SqlTypeName.OTHER);
+    assertNotNull(otherCoercions);
+    assertTrue(otherCoercions.contains(SqlTypeName.VARCHAR));
+    assertTrue(otherCoercions.contains(SqlTypeName.CHAR));
+  }
+
+  @Test
+  public void testNumericToVarcharCoercion() {
+    SqlTypeCoercionRule rule = PplTypeCoercionRule.instance();
+    Map<SqlTypeName, ImmutableSet<SqlTypeName>> mapping = rule.getTypeMapping();
+
+    // VARCHAR should be coercible from numeric types
+    ImmutableSet<SqlTypeName> varcharCoercions = mapping.get(SqlTypeName.VARCHAR);
+    assertNotNull(varcharCoercions);
+
+    // Check some numeric types are included
+    assertTrue(varcharCoercions.contains(SqlTypeName.INTEGER));
+    assertTrue(varcharCoercions.contains(SqlTypeName.BIGINT));
+    assertTrue(varcharCoercions.contains(SqlTypeName.DOUBLE));
+    assertTrue(varcharCoercions.contains(SqlTypeName.DECIMAL));
+  }
+}