[CALCITE-3429] AssertionError for user-defined table function with map argument

core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java

@@ -255,13 +255,19 @@ public static RelDataType toSql(final RelDataTypeFactory typeFactory,
       SqlTypeName sqlTypeName = type.getSqlTypeName();
       final RelDataType relDataType;
       if (SqlTypeUtil.isArray(type)) {
-        final RelDataType elementType = type.getComponentType() == null
-                // type.getJavaClass() is collection with erased generic type
-                ? typeFactory.createSqlType(SqlTypeName.ANY)
-                // elementType returned by JavaType is also of JavaType,
-                // and needs conversion using typeFactory
-                : toSql(typeFactory, type.getComponentType());
+        // Transform to sql type, take care for two cases:
+        // 1. type.getJavaClass() is collection with erased generic type
+        // 2. ElementType returned by JavaType is also of JavaType,
+        // and needs conversion using typeFactory
+        final RelDataType elementType = toSqlTypeWithNullToAny(
+            typeFactory, type.getComponentType());
         relDataType = typeFactory.createArrayType(elementType, -1);
+      } else if (SqlTypeUtil.isMap(type)) {
+        final RelDataType keyType = toSqlTypeWithNullToAny(
+            typeFactory, type.getKeyType());
+        final RelDataType valueType = toSqlTypeWithNullToAny(
+            typeFactory, type.getValueType());
+        relDataType = typeFactory.createMapType(keyType, valueType);
       } else {
         relDataType = typeFactory.createSqlType(sqlTypeName);
       }
@@ -270,6 +276,14 @@ public static RelDataType toSql(final RelDataTypeFactory typeFactory,
     return type;
   }
 
+  private static RelDataType toSqlTypeWithNullToAny(
+      final RelDataTypeFactory typeFactory, RelDataType type) {
+    if (type == null) {
+      return typeFactory.createSqlType(SqlTypeName.ANY);
+    }
+    return toSql(typeFactory, type);
+  }
+
   public Type createSyntheticType(List<Type> types) {
     if (types.isEmpty()) {
       // Unit is a pre-defined synthetic type to be used when there are 0

core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java

@@ -605,6 +605,32 @@ public RelDataType getComponentType() {
       }
     }
 
+    /**
+     * For {@link JavaType} created with {@link Map} class,
+     * cannot get the type of key and value.
+     * Using ANY type as key type.
+     */
+    @Override public RelDataType getKeyType() {
+      if (Map.class.isAssignableFrom(clazz)) {
+        return createSqlType(SqlTypeName.ANY);
+      } else {
+        return null;
+      }
+    }
+
+    /**
+     * For {@link JavaType} created with {@link Map} class,
+     * cannot get the type of key and value.
+     * Using ANY type as value type.
+     */
+    @Override public RelDataType getValueType() {
+      if (Map.class.isAssignableFrom(clazz)) {
+        return createSqlType(SqlTypeName.ANY);
+      } else {
+        return null;
+      }
+    }
+
     public Charset getCharset() {
       return this.charset;
     }

core/src/main/java/org/apache/calcite/sql/type/JavaToSqlTypeConversionRules.java

@@ -77,6 +77,7 @@ public class JavaToSqlTypeConversionRules {
           .put(ColumnList.class, SqlTypeName.COLUMN_LIST)
           .put(ArrayImpl.class, SqlTypeName.ARRAY)
           .put(List.class, SqlTypeName.ARRAY)
+          .put(Map.class, SqlTypeName.MAP)
           .put(Void.class, SqlTypeName.NULL)
           .build();
 

core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRules.java

@@ -193,6 +193,9 @@ private SqlTypeAssignmentRules(
     // ARRAY is assignable from ...
     rules.add(SqlTypeName.ARRAY, EnumSet.of(SqlTypeName.ARRAY));
 
+    // Map is assignable from ...
+    rules.add(SqlTypeName.MAP, EnumSet.of(SqlTypeName.MAP));
+
     // ANY is assignable from ...
     rule.clear();
     rule.add(SqlTypeName.TINYINT);

core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java

@@ -220,6 +220,8 @@ private void assertBasic(SqlTypeName typeName) {
         : "use createMultisetType() instead";
     assert typeName != SqlTypeName.ARRAY
         : "use createArrayType() instead";
+    assert typeName != SqlTypeName.MAP
+        : "use createMapType() instead";
     assert typeName != SqlTypeName.ROW
         : "use createStructType() instead";
     assert !SqlTypeName.INTERVAL_TYPES.contains(typeName)

core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java

@@ -29,6 +29,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertFalse;
@@ -153,6 +154,23 @@ public void createStructTypeWithNullability() {
     assertTrue(copyRecordType.isNullable());
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-3429">[CALCITE-3429]
+   * AssertionError thrown for user-defined table function with map argument</a>. */
+  @Test public void testCreateTypeWithJavaMapType() {
+    SqlTypeFixture f = new SqlTypeFixture();
+    RelDataType relDataType = f.typeFactory.createJavaType(Map.class);
+    assertThat(relDataType.getSqlTypeName(), is(SqlTypeName.MAP));
+    assertThat(relDataType.getKeyType().getSqlTypeName(), is(SqlTypeName.ANY));
+
+    try {
+      f.typeFactory.createSqlType(SqlTypeName.MAP);
+      fail();
+    } catch (AssertionError e) {
+      assertThat(e.getMessage(), is("use createMapType() instead"));
+    }
+  }
+
 }
 
 // End SqlTypeFactoryTest.java

core/src/test/java/org/apache/calcite/test/TableFunctionTest.java

@@ -123,6 +123,24 @@ private CalciteAssert.AssertThat with() {
     }
   }
 
+  @Test public void testTableFunctionWithMapParameter() throws SQLException {
+    try (Connection connection = DriverManager.getConnection("jdbc:calcite:")) {
+      CalciteConnection calciteConnection =
+          connection.unwrap(CalciteConnection.class);
+      SchemaPlus rootSchema = calciteConnection.getRootSchema();
+      SchemaPlus schema = rootSchema.add("s", new AbstractSchema());
+      final TableFunction table =
+          TableFunctionImpl.create(Smalls.GENERATE_STRINGS_OF_INPUT_MAP_SIZE_METHOD);
+      schema.add("GenerateStringsOfInputMapSize", table);
+      final String sql = "select *\n"
+          + "from table(\"s\".\"GenerateStringsOfInputMapSize\"(Map[5,4,3,1])) as t(n, c)\n"
+          + "where char_length(c) > 0";
+      ResultSet resultSet = connection.createStatement().executeQuery(sql);
+      assertThat(CalciteAssert.toString(resultSet),
+          equalTo("N=1; C=a\n"));
+    }
+  }
+
   /**
    * Tests a table function that implements {@link ScannableTable} and returns
    * a single column.

core/src/test/java/org/apache/calcite/util/Smalls.java

@@ -60,6 +60,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -74,6 +75,8 @@ public class Smalls {
       Types.lookupMethod(Smalls.class, "generateStrings", Integer.class);
   public static final Method GENERATE_STRINGS_OF_INPUT_SIZE_METHOD =
       Types.lookupMethod(Smalls.class, "generateStringsOfInputSize", List.class);
+  public static final Method GENERATE_STRINGS_OF_INPUT_MAP_SIZE_METHOD =
+      Types.lookupMethod(Smalls.class, "generateStringsOfInputMapSize", Map.class);
   public static final Method MAZE_METHOD =
       Types.lookupMethod(MazeTable.class, "generate", int.class, int.class,
           int.class);
@@ -187,6 +190,9 @@ public void close() {
   public static QueryableTable generateStringsOfInputSize(final List<Integer> list) {
     return generateStrings(list.size());
   }
+  public static QueryableTable generateStringsOfInputMapSize(final Map<Integer, Integer> map) {
+    return generateStrings(map.size());
+  }
 
   /** A function that generates multiplication table of {@code ncol} columns x
    * {@code nrow} rows. */

geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeTable.java

@@ -108,6 +108,9 @@ public Enumerable<Object> query(final GemFireCache clientCache,
         type = typeFactory.createMultisetType(
             typeFactory.createSqlType(SqlTypeName.ANY),
             -1);
+      } else if (typeName == SqlTypeName.MAP) {
+        RelDataType anyType = typeFactory.createSqlType(SqlTypeName.ANY);
+        type = typeFactory.createMapType(anyType, anyType);
       } else {
         type = typeFactory.createSqlType(typeName);
       }

geode/src/test/java/org/apache/calcite/adapter/geode/rel/GeodeBookstoreTest.java

@@ -22,14 +22,20 @@
 
 import org.apache.geode.cache.Cache;
 import org.apache.geode.cache.Region;
+import org.apache.geode.pdx.PdxInstance;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
+import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Arrays;
+import java.util.function.Consumer;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
 
 /**
  * Tests using {@code Bookshop} schema.
@@ -379,10 +385,37 @@ public void testSelectWithNestedPdx2() {
     calciteAssert()
         .query("select primaryAddress from geode.BookCustomer limit 2")
         .returnsCount(2)
-        .returns("primaryAddress=PDX[addressLine1,addressLine2,addressLine3,city,state,"
-            + "postalCode,country,phoneNumber,addressTag]\n"
-            + "primaryAddress=PDX[addressLine1,addressLine2,addressLine3,city,state,postalCode,"
-            + "country,phoneNumber,addressTag]\n")
+        .returns(new Consumer<ResultSet>() {
+          /**
+           * The result of {@link org.apache.geode.pdx.internal.PdxInstanceImpl}
+           * instance's toString method, has a prefix with random int value,
+           * removes the prefix before checking. The prefix may like this
+           * "PDX[10872742,org.apache.calcite.adapter.geode.primaryAddress]"
+           */
+          @Override public void accept(ResultSet resultSet) {
+            try {
+              StringBuilder builder = new StringBuilder();
+              final String prefix = "org.apache.calcite.adapter.geode.primaryAddress";
+              while (resultSet.next()) {
+                PdxInstance o = (PdxInstance) resultSet.getObject(1);
+                int index = o.toString().indexOf(prefix);
+                builder.append(
+                    o.toString().substring(index + prefix.length() + 1));
+                builder.append("\n");
+              }
+              assertThat(builder.toString(),
+                  is("{addressLine1=123 Main St., addressLine2=java.lang.NullPointerException,"
+                      + " addressLine3=java.lang.NullPointerException, addressTag=HOME, city=Topeka,"
+                      + " country=US, phoneNumber=423-555-3322, postalCode=50505, state=KS}\n"
+                      + "{addressLine1=123 Main St., addressLine2=java.lang.NullPointerException,"
+                      + " addressLine3=java.lang.NullPointerException, addressTag=HOME,"
+                      + " city=San Francisco, country=US," + " phoneNumber=423-555-3322,"
+                      + " postalCode=50505, state=CA}\n"));
+            } catch (Exception e) {
+              throw new RuntimeException(e);
+            }
+          }
+        })
         .explainContains("PLAN=GeodeToEnumerableConverter\n"
             + "  GeodeProject(primaryAddress=[$3])\n"
             + "    GeodeSort(fetch=[2])\n"