Implement CassandraDatabaseMetaData.getFunctionColumns()

Author: maximevw

CHANGELOG.md

@@ -16,8 +16,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - Implement the methods `isSigned()` and `isSearchable()` in the different `ResultSetMetaData` implementations.
 - Implement the method `isValid(int)` in `CassandraConnection`.
 - Implement the following methods of `CassandraDatabaseMetaData`: `getFunctions(String, String, String)`,
-  `getNumericFunctions()`, `getSQLKeywords()`, `getStringFunctions()`, `getSystemFunctions()`, `getTimeDateFunctions()`,
-  `getTypeInfo()` and `getUDTs(String, String, String, int[])`.
+  `getFunctionColumns(String, String, String, String)`, `getNumericFunctions()`, `getSQLKeywords()`, 
+  `getStringFunctions()`, `getSystemFunctions()`, `getTimeDateFunctions()`, `getTypeInfo()` and 
+  `getUDTs(String, String, String, int[])`.
 ### Changed
 - Harmonize the implementations of `Wrapper` interface.
 - Rewrite the tests using Testcontainers with Apache Cassandra(R) 4.1.0 image.

src/main/java/com/ing/data/cassandra/jdbc/CassandraDatabaseMetaData.java

@@ -328,8 +328,15 @@ public String getExtraNameCharacters() {
     public ResultSet getFunctionColumns(final String catalog, final String schemaPattern,
                                         final String functionNamePattern, final String columnNamePattern)
         throws SQLException {
-        // TODO: method to implement
         checkStatementClosed();
+        if (catalog == null || catalog.equals(this.connection.getCatalog())) {
+            String schemaName = schemaPattern;
+            if (schemaPattern == null) {
+                schemaName = this.connection.getSchema(); // limit to current schema if defined.
+            }
+            return MetadataResultSets.INSTANCE.makeFunctionColumns(this.statement, schemaName, functionNamePattern,
+                columnNamePattern);
+        }
         return CassandraResultSet.EMPTY_RESULT_SET;
     }
 

src/main/java/com/ing/data/cassandra/jdbc/MetadataResultSets.java

@@ -34,11 +34,14 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.List;
 import java.util.Map;
 
 import static com.ing.data.cassandra.jdbc.AbstractJdbcType.DEFAULT_PRECISION;
 import static com.ing.data.cassandra.jdbc.AbstractJdbcType.DEFAULT_SCALE;
 import static com.ing.data.cassandra.jdbc.TypesMap.getTypeForComparator;
+import static java.sql.DatabaseMetaData.functionColumnIn;
+import static java.sql.DatabaseMetaData.functionReturn;
 import static java.sql.DatabaseMetaData.typeNullable;
 import static java.sql.DatabaseMetaData.typePredBasic;
 import static java.sql.Types.JAVA_OBJECT;
@@ -64,6 +67,7 @@ public final class MetadataResultSets {
     static final String COLUMN_DEFAULT = "COLUMN_DEF";
     static final String COLUMN_NAME = "COLUMN_NAME";
     static final String COLUMN_SIZE = "COLUMN_SIZE";
+    static final String COLUMN_TYPE = "COLUMN_TYPE";
     static final String CREATE_PARAMS = "CREATE_PARAMS";
     static final String DATA_TYPE = "DATA_TYPE";
     static final String DECIMAL_DIGITS = "DECIMAL_DIGITS";
@@ -79,6 +83,7 @@ public final class MetadataResultSets {
     static final String IS_GENERATED_COLUMN = "IS_GENERATEDCOLUMN";
     static final String IS_NULLABLE = "IS_NULLABLE";
     static final String KEY_SEQ = "KEY_SEQ";
+    static final String LENGTH = "LENGTH";
     static final String LITERAL_PREFIX = "LITERAL_PREFIX";
     static final String LITERAL_SUFFIX = "LITERAL_SUFFIX";
     static final String LOCALIZED_TYPE_NAME = "LOCAL_TYPE_NAME";
@@ -92,8 +97,10 @@ public final class MetadataResultSets {
     static final String PAGES = "PAGES";
     static final String PRECISION = "PRECISION";
     static final String PRIMARY_KEY_NAME = "PK_NAME";
+    static final String RADIX = "RADIX";
     static final String REF_GENERATION = "REF_GENERATION";
     static final String REMARKS = "REMARKS";
+    static final String SCALE = "SCALE";
     static final String SCOPE_CATALOG = "SCOPE_CATALOG";
     static final String SCOPE_SCHEMA = "SCOPE_SCHEMA";
     static final String SCOPE_TABLE = "SCOPE_TABLE";
@@ -115,6 +122,7 @@ public final class MetadataResultSets {
     static final String TYPE_SCHEMA = "TYPE_SCHEM";
     static final String UNSIGNED_ATTRIBUTE = "UNSIGNED_ATTRIBUTE";
     static final String WILDCARD_CHAR = "%";
+    static final String YES_VALUE = "YES";
 
     private static final Logger LOG = LoggerFactory.getLogger(MetadataResultSets.class);
 
@@ -865,11 +873,174 @@ public CassandraMetadataResultSet makeFunctions(final CassandraStatement stateme
             }
         }
 
-        // Results should all have the same FUNCTION_CAT, so just sort them by FUNCTION_SCHEM, then FUNCTION_NAME and
-        // finally SPECIFIC_NAME.
+        // Results should all have the same FUNCTION_CAT, so just sort them by FUNCTION_SCHEM then FUNCTION_NAME (since
+        // here SPECIFIC_NAME is equal to FUNCTION_NAME).
         functionsRows.sort(Comparator.comparing(row -> ((MetadataRow) row).getString(FUNCTION_SCHEMA))
-            .thenComparing(row -> ((MetadataRow) row).getString(FUNCTION_NAME))
-            .thenComparing(row -> ((MetadataRow) row).getString(SPECIFIC_NAME)));
+            .thenComparing(row -> ((MetadataRow) row).getString(FUNCTION_NAME)));
         return new CassandraMetadataResultSet(statement, new MetadataResultSet().setRows(functionsRows));
     }
+
+    /**
+     * Builds a valid result set of the given catalog's system or user function parameters and return type.
+     * This method is used to implement the method
+     * {@link DatabaseMetaData#getFunctionColumns(String, String, String, String)}.
+     * <p>
+     * Only descriptions matching the schema, function and parameter name criteria are returned. They are ordered by
+     * {@code FUNCTION_CAT}, {@code FUNCTION_SCHEM}, {@code FUNCTION_NAME} and {@code SPECIFIC_NAME}. Within this, the
+     * return value, if any, is first. Next are the parameter descriptions in call order. The column descriptions
+     * follow in column number order.
+     * </p>
+     * <p>
+     * The columns of this result set are:
+     *     <ol>
+     *         <li><b>FUNCTION_CAT</b> String => function catalog, may be {@code null}: here is the Cassandra cluster
+     *         name (if available).</li>
+     *         <li><b>FUNCTION_SCHEM</b> String => function schema, may be {@code null}: here is the keyspace the table
+     *         is member of.</li>
+     *         <li><b>FUNCTION_NAME</b> String => function name. This is the name used to invoke the function.</li>
+     *         <li><b>COLUMN_NAME</b> String => column/parameter name.</li>
+     *         <li><b>COLUMN_TYPE</b> short => kind of column/parameter:
+     *             <ul>
+     *                 <li>{@link DatabaseMetaData#functionColumnUnknown} - unknown type</li>
+     *                 <li>{@link DatabaseMetaData#functionColumnIn} - {@code IN} parameter</li>
+     *                 <li>{@link DatabaseMetaData#functionColumnInOut} - {@code INOUT} parameter</li>
+     *                 <li>{@link DatabaseMetaData#functionColumnOut} - {@code OUT} parameter</li>
+     *                 <li>{@link DatabaseMetaData#functionReturn} - function return value</li>
+     *                 <li>{@link DatabaseMetaData#functionColumnResult} - indicates that the parameter or column is a
+     *                 column in the {@code ResultSet}</li>
+     *             </ul>
+     *         </li>
+     *         <li><b>DATA_TYPE</b> int => SQL data type from {@link Types}.</li>
+     *         <li><b>TYPE_NAME</b> String => SQL type name, for a UDT type the type name is fully qualified.</li>
+     *         <li><b>PRECISION</b> int => maximum precision.</li>
+     *         <li><b>LENGTH</b> int => length in bytes of data.</li>
+     *         <li><b>SCALE</b> int => scale, {@code null} is returned for data types where SCALE is not
+     *         applicable.</li>
+     *         <li><b>RADIX</b> short => precision radix.</li>
+     *         <li><b>NULLABLE</b> short => can you use {@code NULL} for this type:
+     *              <ul>
+     *                  <li>{@link DatabaseMetaData#typeNoNulls} - does not allow {@code NULL} values</li>
+     *                  <li>{@link DatabaseMetaData#typeNullable} - allows {@code NULL} values</li>
+     *                  <li>{@link DatabaseMetaData#typeNullableUnknown} - nullability unknown</li>
+     *              </ul>
+     *         </li>
+     *         <li><b>REMARKS</b> String => comment describing column/parameter (always empty, Cassandra does not
+     *         allow to describe columns with a comment).</li>
+     *         <li><b>CHAR_OCTET_LENGTH</b> int => the maximum length of binary and character based parameters or
+     *         columns. For any other datatype the returned value is a {@code NULL}.</li>
+     *         <li><b>ORDINAL_POSITION</b> int => the ordinal position, starting from 1, for the input and output
+     *         parameters. A value of 0 is returned if this row describes the function's return value. For result set
+     *         columns, it is the ordinal position of the column in the result set starting from 1.</li>
+     *         <li><b>IS_NULLABLE</b> String => "YES" if a parameter or column accepts {@code NULL} values, "NO"
+     *         if not and empty if the nullability is unknown.</li>
+     *         <li><b>SPECIFIC_NAME</b> String => the name which uniquely identifies this function within its schema.
+     *         This is a user specified, or DBMS generated, name that may be different then the {@code FUNCTION_NAME}
+     *         for example with overload functions.</li>
+     *     </ol>
+     * </p>
+     * <p>
+     * The {@code PRECISION} column represents the maximum column size that the server supports for the given datatype.
+     * For numeric data, this is the maximum precision. For character data, this is the length in characters. For
+     * datetime data types, this is the length in characters of the {@code String} representation (assuming the maximum
+     * allowed precision of the fractional seconds component). For binary data, this is the length in bytes.
+     * For the {@code ROWID} datatype (not supported by Cassandra), this is the length in bytes. The value {@code null}
+     * is returned for data types where the column size is not applicable.
+     * </p>
+     *
+     * @param statement             The statement.
+     * @param schemaPattern         A schema name pattern. It must match the schema name as it is stored in the
+     *                              database; {@code ""} retrieves those without a schema and {@code null} means that
+     *                              the schema name should not be used to narrow down the search.
+     * @param functionNamePattern   A function name pattern; must match the function name as it is stored in the
+     *                              database.
+     * @param columnNamePattern     A parameter name pattern; must match the parameter or column name as it is stored
+     *                              in the database.
+     * @return A valid result set for implementation of
+     * {@link DatabaseMetaData#getFunctionColumns(String, String, String, String)}.
+     * @throws SQLException when something went wrong during the creation of the result set.
+     */
+    public CassandraMetadataResultSet makeFunctionColumns(final CassandraStatement statement,
+                                                          final String schemaPattern,
+                                                          final String functionNamePattern,
+                                                          final String columnNamePattern) throws SQLException {
+        final ArrayList<MetadataRow> functionParamsRows = new ArrayList<>();
+        final Map<CqlIdentifier, KeyspaceMetadata> keyspaces = statement.connection.getClusterMetadata().getKeyspaces();
+
+        for (final Map.Entry<CqlIdentifier, KeyspaceMetadata> keyspace : keyspaces.entrySet()) {
+            final KeyspaceMetadata keyspaceMetadata = keyspace.getValue();
+            String schemaNamePattern = schemaPattern;
+            if (WILDCARD_CHAR.equals(schemaPattern)) {
+                schemaNamePattern = keyspaceMetadata.getName().asInternal();
+            }
+            if (schemaNamePattern == null || schemaNamePattern.equals(keyspaceMetadata.getName().asInternal())) {
+                final Map<FunctionSignature, FunctionMetadata> functions = keyspaceMetadata.getFunctions();
+
+                for (final Map.Entry<FunctionSignature, FunctionMetadata> function : functions.entrySet()) {
+                    final FunctionSignature functionSignature = function.getKey();
+                    final FunctionMetadata functionMetadata = function.getValue();
+                    if (WILDCARD_CHAR.equals(functionNamePattern) || functionNamePattern == null
+                        || functionNamePattern.equals(functionSignature.getName().asInternal())) {
+                        // Function return type.
+                        final AbstractJdbcType<?> returnJdbcType =
+                            getTypeForComparator(functionMetadata.getReturnType().asCql(false, true));
+                        final MetadataRow row = new MetadataRow()
+                            .addEntry(FUNCTION_CATALOG, statement.connection.getCatalog())
+                            .addEntry(FUNCTION_SCHEMA, keyspaceMetadata.getName().asInternal())
+                            .addEntry(FUNCTION_NAME, functionSignature.getName().asInternal())
+                            .addEntry(COLUMN_NAME, StringUtils.EMPTY)
+                            .addEntry(COLUMN_TYPE, String.valueOf(functionReturn))
+                            .addEntry(DATA_TYPE, String.valueOf(returnJdbcType.getJdbcType()))
+                            .addEntry(TYPE_NAME, functionMetadata.getReturnType().toString())
+                            .addEntry(PRECISION, String.valueOf(returnJdbcType.getPrecision(null)))
+                            .addEntry(LENGTH, String.valueOf(Integer.MAX_VALUE))
+                            .addEntry(SCALE, String.valueOf(returnJdbcType.getScale(null)))
+                            .addEntry(RADIX, String.valueOf(returnJdbcType.getPrecision(null)))
+                            .addEntry(NULLABLE, String.valueOf(typeNullable))
+                            .addEntry(REMARKS, StringUtils.EMPTY)
+                            .addEntry(CHAR_OCTET_LENGTH, null)
+                            .addEntry(ORDINAL_POSITION, "0")
+                            .addEntry(IS_NULLABLE, YES_VALUE)
+                            .addEntry(SPECIFIC_NAME, functionSignature.getName().asInternal());
+                        functionParamsRows.add(row);
+                        // Function input parameters.
+                        final List<CqlIdentifier> paramNames = functionMetadata.getParameterNames();
+                        for (int i = 0; i < paramNames.size(); i++) {
+                            if (WILDCARD_CHAR.equals(columnNamePattern) || columnNamePattern == null
+                                || columnNamePattern.equals(paramNames.get(i).asInternal())) {
+                                final AbstractJdbcType<?> paramJdbcType = getTypeForComparator(
+                                    functionSignature.getParameterTypes().get(i).asCql(false, true));
+                                final MetadataRow paramRow = new MetadataRow()
+                                    .addEntry(FUNCTION_CATALOG, statement.connection.getCatalog())
+                                    .addEntry(FUNCTION_SCHEMA, keyspaceMetadata.getName().asInternal())
+                                    .addEntry(FUNCTION_NAME, functionSignature.getName().asInternal())
+                                    .addEntry(COLUMN_NAME, paramNames.get(i).asInternal())
+                                    .addEntry(COLUMN_TYPE, String.valueOf(functionColumnIn))
+                                    .addEntry(DATA_TYPE, String.valueOf(paramJdbcType.getJdbcType()))
+                                    .addEntry(TYPE_NAME, functionSignature.getParameterTypes().get(i).toString())
+                                    .addEntry(PRECISION, String.valueOf(paramJdbcType.getPrecision(null)))
+                                    .addEntry(LENGTH, String.valueOf(Integer.MAX_VALUE))
+                                    .addEntry(SCALE, String.valueOf(paramJdbcType.getScale(null)))
+                                    .addEntry(RADIX, String.valueOf(paramJdbcType.getPrecision(null)))
+                                    .addEntry(NULLABLE, String.valueOf(typeNullable))
+                                    .addEntry(REMARKS, StringUtils.EMPTY)
+                                    .addEntry(CHAR_OCTET_LENGTH, null)
+                                    .addEntry(ORDINAL_POSITION, String.valueOf(i + 1))
+                                    .addEntry(IS_NULLABLE, YES_VALUE)
+                                    .addEntry(SPECIFIC_NAME, functionSignature.getName().asInternal());
+                                functionParamsRows.add(paramRow);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Results should all have the same FUNCTION_CAT, so just sort them by FUNCTION_SCHEM then FUNCTION_NAME (since
+        // here SPECIFIC_NAME is equal to FUNCTION_NAME), and finally by ORDINAL_POSITION.
+        functionParamsRows.sort(Comparator.comparing(row -> ((MetadataRow) row).getString(FUNCTION_SCHEMA))
+            .thenComparing(row -> ((MetadataRow) row).getString(FUNCTION_NAME))
+            .thenComparing(row -> ((MetadataRow) row).getString(SPECIFIC_NAME))
+            .thenComparing(row -> Integer.valueOf(((MetadataRow) row).getString(ORDINAL_POSITION))));
+        return new CassandraMetadataResultSet(statement, new MetadataResultSet().setRows(functionParamsRows));
+    }
 }