[PECOBLR-1746] Implementing support for listing procedures (#1238)

## Description

Implements `getProcedures` and `getProcedureColumns` in
`DatabricksDatabaseMetaData` by querying `information_schema.routines`
and `information_schema.parameters` via SQL.

Unlike other metadata operations that use `SHOW` commands or Thrift
RPCs, these use direct SQL SELECT queries against `information_schema`
views. This works for both Thrift and SEA transports.

**getProcedures:**
- Queries `information_schema.routines` filtered by `routine_type =
'PROCEDURE'`
- Returns 9-column JDBC-spec result set (PROCEDURE_CAT, PROCEDURE_SCHEM,
PROCEDURE_NAME, reserved x3, REMARKS, PROCEDURE_TYPE, SPECIFIC_NAME)
- PROCEDURE_TYPE is always `procedureNoResult` (1)

**getProcedureColumns:**
- Queries `information_schema.parameters` JOINed with
`information_schema.routines` to filter for procedures
- Returns 20-column JDBC-spec result set with parameter metadata
- Maps `parameter_mode` (IN/OUT/INOUT) to JDBC COLUMN_TYPE constants
(1/4/2)
- Maps Databricks type names to `java.sql.Types` codes via existing
`getCode()`

**Catalog resolution:**
- NULL catalog → queries `system.information_schema.routines`
(cross-catalog)
- Specific catalog → queries `<catalog>.information_schema.routines`
- Empty string → returns empty result set

**Shared SQL builders** in `CommandConstants` eliminate duplication
between SDK and Thrift clients.

## Testing

**Unit tests** (`DatabricksMetadataSdkClientTest`):
- 4 parameterized tests for `listProcedures` SQL generation
(catalog+schema+name, null schema, null name, null catalog)
- 3 parameterized tests for `listProcedureColumns` SQL generation (all
filters, partial filters, all nulls)

**Integration test**
(`MetadataIntegrationTests#testGetProceduresAndProcedureColumns`):
- Creates a procedure `jdbc_test_compute_area(x DOUBLE, y DOUBLE, OUT
area DOUBLE)` with COMMENT
- Verifies `getProcedures` returns correct name, schema, catalog,
remarks, type
- Verifies `getProcedureColumns` returns 3 params with correct
COLUMN_TYPE (IN=1, OUT=4), DATA_TYPE (DOUBLE=8), ordinal positions
- Tests column name filtering
- Cleans up procedure after test
- WireMock stubs recorded for REPLAY mode

**Existing tests:** All 248 `DatabricksDatabaseMetaDataTest` + 51
`DatabricksMetadataSdkClientTest` pass.

## Additional Notes to the Reviewer

- `information_schema.parameters` is used (not `routine_columns`)
because `routine_columns` contains table-valued function output columns,
not procedure parameters.
- NULLABLE is always `procedureNullableUnknown` (2) since the server
does not track parameter nullability.
- When catalog is NULL, `system.information_schema` is queried which
requires system table access permissions. If the user lacks this
permission, the driver returns an empty result set. This will be
addressed server-side in a future release.

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: msrathore-db

NEXT_CHANGELOG.md

@@ -3,6 +3,7 @@
 ## [Unreleased]
 
 ### Added
+- Added `DatabaseMetaData.getProcedures()` and `DatabaseMetaData.getProcedureColumns()` to discover stored procedures and their parameters. Queries `information_schema.routines` and `information_schema.parameters` using parameterized SQL for both SEA and Thrift transports.
 - Added connection property `OAuthWebServerTimeout` to configure the OAuth browser authentication timeout for U2M (user-to-machine) flows, and also updated hardcoded 1-hour timeout to default 120 seconds timeout.
 - Added connection property `UseQueryForMetadata` to use SQL SHOW commands instead of Thrift RPCs for metadata operations (getCatalogs, getSchemas, getTables, getColumns, getFunctions). This fixes incorrect wildcard matching where `_` was treated as a single-character wildcard in Thrift metadata pattern filters.
 - Added connection property `TreatMetadataCatalogNameAsPattern` to control whether catalog names are treated as patterns in Thrift metadata RPCs. When disabled (default), unescaped `_` in catalog names is escaped to prevent single-character wildcard matching. This aligns with JDBC spec which treats catalogName as identifier and not pattern.
@@ -11,6 +12,9 @@
 - Bumped `com.fasterxml.jackson.core:jackson-core` from 2.18.3 to 2.18.6.
 - Fat jar now routes SDK and Apache HTTP client logs through Java Util Logging (JUL), removing the need for external logging libraries.
 - PECOBLR-1121 Arrow patch to circumvent Arrow issues with JDK 16+.
+- Log timestamps now explicitly display timezone.
+- **[Breaking Change]** `PreparedStatement.setTimestamp(int, Timestamp, Calendar)` now properly applies Calendar timezone conversion using LocalDateTime pattern (inline with `getTimestamp`). Previously Calendar parameter was ineffective.
+- `DatabaseMetaData.getColumns()` with null catalog parameter now retrieves columns from all available catalogs when using SQL Execution API.
 
 ### Fixed
 - Fixed statement timeout when the server returns `TIMEDOUT_STATE` directly in the `ExecuteStatement` response (e.g. query queued under load), the driver now throws `SQLTimeoutException` instead of `DatabricksHttpException`.

src/main/java/com/databricks/jdbc/api/impl/DatabricksDatabaseMetaData.java

@@ -892,21 +892,6 @@ public boolean supportsSharding() throws SQLException {
     return false;
   }
 
-  /**
-   * Builds the result set for stored procedures metadata.
-   *
-   * <p>The result set structure is defined based on the JDBC driver specifications to ensure
-   * consistency. The following columns are included in the result set:
-   *
-   * <ul>
-   *   <li>PROCEDURE_CAT: The catalog of the procedure (String)
-   *   <li>PROCEDURE_SCHEM: The schema of the procedure (String)
-   *   <li>PROCEDURE_NAME: The name of the procedure (String)
-   *   <li>REMARKS: A description or remarks about the procedure (String)
-   *   <li>PROCEDURE_TYPE: The type of procedure (e.g., FUNCTION, PROCEDURE) (String)
-   *   <li>SPECIFIC_NAME: The specific name for the procedure (String)
-   * </ul>
-   */
   @Override
   public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
       throws SQLException {
@@ -916,44 +901,14 @@ public ResultSet getProcedures(String catalog, String schemaPattern, String proc
         schemaPattern,
         procedureNamePattern);
     throwExceptionIfConnectionIsClosed();
-    return new DatabricksResultSet(
-        new StatementStatus().setState(StatementState.SUCCEEDED),
-        new StatementId("getprocedures-metadata"),
-        Arrays.asList(
-            "PROCEDURE_CAT",
-            "PROCEDURE_SCHEM",
-            "PROCEDURE_NAME",
-            "NUM_INPUT_PARAMS",
-            "NUM_OUTPUT_PARAMS",
-            "NUM_RESULT_SETS",
-            "REMARKS",
-            "PROCEDURE_TYPE",
-            "SPECIFIC_NAME"),
-        Arrays.asList(
-            "VARCHAR",
-            "VARCHAR",
-            "VARCHAR",
-            "INTEGER",
-            "INTEGER",
-            "INTEGER",
-            "VARCHAR",
-            "SMALLINT",
-            "VARCHAR"),
-        new int[] {
-          Types.VARCHAR,
-          Types.VARCHAR,
-          Types.VARCHAR,
-          Types.INTEGER,
-          Types.INTEGER,
-          Types.INTEGER,
-          Types.VARCHAR,
-          Types.SMALLINT,
-          Types.VARCHAR
-        },
-        new int[] {128, 128, 128, 10, 10, 10, 254, 5, 128},
-        new int[] {1, 1, 0, 1, 1, 1, 1, 1, 0},
-        new Object[0][0],
-        StatementType.METADATA);
+    try {
+      return session
+          .getDatabricksMetadataClient()
+          .listProcedures(session, catalog, schemaPattern, procedureNamePattern);
+    } catch (Exception e) {
+      LOGGER.error(e, "Unable to fetch procedures, returning empty result set");
+      return metadataResultSetBuilder.getProceduresResult(new ArrayList<>());
+    }
   }
 
   @Override
@@ -967,12 +922,15 @@ public ResultSet getProcedureColumns(
         procedureNamePattern,
         columnNamePattern);
     throwExceptionIfConnectionIsClosed();
-
-    return metadataResultSetBuilder.getResultSetWithGivenRowsAndColumns(
-        PROCEDURE_COLUMNS_COLUMNS,
-        new ArrayList<>(),
-        METADATA_STATEMENT_ID,
-        CommandName.GET_PROCEDURES_COLUMNS);
+    try {
+      return session
+          .getDatabricksMetadataClient()
+          .listProcedureColumns(
+              session, catalog, schemaPattern, procedureNamePattern, columnNamePattern);
+    } catch (Exception e) {
+      LOGGER.error(e, "Unable to fetch procedure columns, returning empty result set");
+      return metadataResultSetBuilder.getProcedureColumnsResult(new ArrayList<>());
+    }
   }
 
   @Override

src/main/java/com/databricks/jdbc/common/CommandName.java

@@ -22,7 +22,8 @@ public enum CommandName {
   GET_TABLE_PRIVILEGES,
   GET_VERSION_COLUMNS,
   GET_SUPER_TYPES,
-  GET_PROCEDURES_COLUMNS,
+  LIST_PROCEDURES,
+  LIST_PROCEDURE_COLUMNS,
   GET_INDEX_INFO,
   GET_SUPER_TABLES,
   GET_FUNCTION_COLUMNS,

src/main/java/com/databricks/jdbc/common/MetadataOperationType.java

@@ -11,7 +11,9 @@ public enum MetadataOperationType {
   GET_COLUMNS("GetColumns"),
   GET_FUNCTIONS("GetFunctions"),
   GET_PRIMARY_KEYS("GetPrimaryKeys"),
-  GET_CROSS_REFERENCE("GetCrossReference");
+  GET_CROSS_REFERENCE("GetCrossReference"),
+  GET_PROCEDURES("GetProcedures"),
+  GET_PROCEDURE_COLUMNS("GetProcedureColumns");
 
   private final String headerValue;
 

src/main/java/com/databricks/jdbc/common/MetadataResultConstants.java

@@ -195,6 +195,14 @@ public class MetadataResultConstants {
   private static final ResultColumn RADIX = new ResultColumn("RADIX", "radix", Types.SMALLINT);
   private static final ResultColumn NULLABLE_SHORT =
       new ResultColumn("NULLABLE", "nullable", Types.SMALLINT);
+  private static final ResultColumn NUM_INPUT_PARAMS =
+      new ResultColumn("NUM_INPUT_PARAMS", "numInputParams", Types.INTEGER);
+  private static final ResultColumn NUM_OUTPUT_PARAMS =
+      new ResultColumn("NUM_OUTPUT_PARAMS", "numOutputParams", Types.INTEGER);
+  private static final ResultColumn NUM_RESULT_SETS =
+      new ResultColumn("NUM_RESULT_SETS", "numResultSets", Types.INTEGER);
+  private static final ResultColumn PROCEDURE_TYPE =
+      new ResultColumn("PROCEDURE_TYPE", "procedureType", Types.SMALLINT);
   private static final ResultColumn NON_UNIQUE =
       new ResultColumn("NON_UNIQUE", "nonUnique", Types.BOOLEAN);
   private static final ResultColumn INDEX_QUALIFIER =
@@ -225,6 +233,18 @@ public class MetadataResultConstants {
           FUNCTION_TYPE_COLUMN,
           SPECIFIC_NAME_COLUMN);
 
+  public static final List<ResultColumn> PROCEDURES_COLUMNS =
+      List.of(
+          PROCEDURE_CAT,
+          PROCEDURE_SCHEM,
+          PROCEDURE_NAME,
+          NUM_INPUT_PARAMS,
+          NUM_OUTPUT_PARAMS,
+          NUM_RESULT_SETS,
+          REMARKS_COLUMN,
+          PROCEDURE_TYPE,
+          SPECIFIC_NAME_COLUMN);
+
   public static List<ResultColumn> COLUMN_COLUMNS =
       List.of(
           CATALOG_COLUMN,
@@ -618,8 +638,9 @@ public class MetadataResultConstants {
               CommandName.GET_VERSION_COLUMNS,
               List.of(SCOPE, COL_NAME_COLUMN, DATA_TYPE_COLUMN, TYPE_NAME_COLUMN, PSEUDO_COLUMN));
           put(CommandName.GET_SUPER_TYPES, List.of(TYPE_NAME_COLUMN, SUPERTYPE_NAME));
+          put(CommandName.LIST_PROCEDURES, List.of(PROCEDURE_NAME, SPECIFIC_NAME_COLUMN));
           put(
-              CommandName.GET_PROCEDURES_COLUMNS,
+              CommandName.LIST_PROCEDURE_COLUMNS,
               List.of(
                   PROCEDURE_NAME,
                   COLUMN_NAME_COLUMN,

src/main/java/com/databricks/jdbc/dbclient/IDatabricksMetadataClient.java

@@ -132,6 +132,42 @@ DatabricksResultSet listImportedKeys(
   DatabricksResultSet listExportedKeys(
       IDatabricksSession session, String catalog, String schema, String table) throws SQLException;
 
+  /**
+   * Returns the list of stored procedures
+   *
+   * @param session underlying session
+   * @param catalog catalogName; null means use system catalog
+   * @param schemaNamePattern schema name pattern (can be a LIKE pattern)
+   * @param procedureNamePattern procedure name pattern (can be a LIKE pattern)
+   * @return a DatabricksResultSet representing list of procedures
+   */
+  @DatabricksMetricsTimed
+  DatabricksResultSet listProcedures(
+      IDatabricksSession session,
+      String catalog,
+      String schemaNamePattern,
+      String procedureNamePattern)
+      throws SQLException;
+
+  /**
+   * Returns the list of stored procedure columns/parameters
+   *
+   * @param session underlying session
+   * @param catalog catalogName; null means use system catalog
+   * @param schemaNamePattern schema name pattern (can be a LIKE pattern)
+   * @param procedureNamePattern procedure name pattern (can be a LIKE pattern)
+   * @param columnNamePattern column/parameter name pattern (can be a LIKE pattern)
+   * @return a DatabricksResultSet representing list of procedure columns
+   */
+  @DatabricksMetricsTimed
+  DatabricksResultSet listProcedureColumns(
+      IDatabricksSession session,
+      String catalog,
+      String schemaNamePattern,
+      String procedureNamePattern,
+      String columnNamePattern)
+      throws SQLException;
+
   /**
    * Returns the list of cross references between a parent table and a foreign table
    *

src/main/java/com/databricks/jdbc/dbclient/impl/common/CommandConstants.java

@@ -1,11 +1,17 @@
 package com.databricks.jdbc.dbclient.impl.common;
 
+import com.databricks.jdbc.api.impl.ImmutableSqlParameter;
+import com.databricks.jdbc.model.core.ColumnInfoTypeName;
+import java.util.Map;
+
 public class CommandConstants {
   public static final String METADATA_STATEMENT_ID = "metadata-statement";
   public static final String GET_TABLES_STATEMENT_ID = "gettables-metadata";
   public static final String GET_CATALOGS_STATEMENT_ID = "getcatalogs-metadata";
   public static final String GET_TABLE_TYPE_STATEMENT_ID = "gettabletype-metadata";
   public static final String GET_FUNCTIONS_STATEMENT_ID = "getfunctions-metadata";
+  public static final String GET_PROCEDURES_STATEMENT_ID = "getprocedures-metadata";
+  public static final String GET_PROCEDURE_COLUMNS_STATEMENT_ID = "getprocedurecolumns-metadata";
   public static final String SHOW_CATALOGS_SQL = "SHOW CATALOGS";
   public static final String SHOW_TABLE_TYPES_SQL = "SHOW TABLE_TYPES";
   public static final String IN_CATALOG_SQL = " IN CATALOG `%s`";
@@ -26,4 +32,107 @@ public class CommandConstants {
       "SHOW KEYS" + IN_CATALOG_SQL + IN_ABSOLUTE_SCHEMA_SQL + IN_ABSOLUTE_TABLE_SQL;
   public static final String SHOW_FOREIGN_KEYS_SQL =
       "SHOW FOREIGN KEYS" + IN_CATALOG_SQL + IN_ABSOLUTE_SCHEMA_SQL + IN_ABSOLUTE_TABLE_SQL;
+
+  private static final String INFORMATION_SCHEMA_ROUTINES = "information_schema.routines";
+  private static final String INFORMATION_SCHEMA_PARAMETERS = "information_schema.parameters";
+  private static final String PROCEDURE_TYPE_FILTER = "routine_type = 'PROCEDURE'";
+
+  private static final String ROUTINES_SELECT_COLUMNS =
+      "routine_catalog, routine_schema, routine_name, comment, specific_name";
+
+  private static final String PARAMETERS_SELECT_COLUMNS =
+      "p.specific_catalog, p.specific_schema, p.specific_name,"
+          + " p.parameter_name, p.parameter_mode, p.is_result,"
+          + " p.data_type,"
+          + " p.numeric_precision, p.numeric_precision_radix, p.numeric_scale,"
+          + " p.character_maximum_length, p.character_octet_length,"
+          + " p.ordinal_position, p.parameter_default, p.comment";
+
+  /**
+   * Builds a parameterized SQL query to fetch procedures from information_schema.routines. LIKE
+   * clause values use ? placeholders with parameters populated in the provided map for server-side
+   * binding.
+   */
+  public static String buildProceduresSQL(
+      String catalog,
+      String schemaPattern,
+      String procedureNamePattern,
+      Map<Integer, ImmutableSqlParameter> params) {
+    String catalogPrefix = getCatalogPrefix(catalog);
+    String routinesTable = catalogPrefix + "." + INFORMATION_SCHEMA_ROUTINES;
+    int paramIndex = 1;
+
+    StringBuilder sql = new StringBuilder();
+    sql.append("SELECT ").append(ROUTINES_SELECT_COLUMNS);
+    sql.append(" FROM ").append(routinesTable);
+    sql.append(" WHERE ").append(PROCEDURE_TYPE_FILTER);
+    if (schemaPattern != null) {
+      sql.append(" AND routine_schema LIKE ?");
+      params.put(paramIndex, buildStringParam(paramIndex, schemaPattern));
+      paramIndex++;
+    }
+    if (procedureNamePattern != null) {
+      sql.append(" AND routine_name LIKE ?");
+      params.put(paramIndex, buildStringParam(paramIndex, procedureNamePattern));
+      paramIndex++;
+    }
+    sql.append(" ORDER BY routine_catalog, routine_schema, routine_name");
+    return sql.toString();
+  }
+
+  /**
+   * Builds a parameterized SQL query to fetch procedure columns from information_schema.parameters.
+   * LIKE clause values use ? placeholders with parameters populated in the provided map for
+   * server-side binding.
+   */
+  public static String buildProcedureColumnsSQL(
+      String catalog,
+      String schemaPattern,
+      String procedureNamePattern,
+      String columnNamePattern,
+      Map<Integer, ImmutableSqlParameter> params) {
+    String catalogPrefix = getCatalogPrefix(catalog);
+    String parametersTable = catalogPrefix + "." + INFORMATION_SCHEMA_PARAMETERS + " p";
+    String routinesTable = catalogPrefix + "." + INFORMATION_SCHEMA_ROUTINES + " r";
+    int paramIndex = 1;
+
+    StringBuilder sql = new StringBuilder();
+    sql.append("SELECT ").append(PARAMETERS_SELECT_COLUMNS);
+    sql.append(" FROM ").append(parametersTable);
+    sql.append(" JOIN ").append(routinesTable);
+    sql.append(" ON p.specific_catalog = r.specific_catalog");
+    sql.append(" AND p.specific_schema = r.specific_schema");
+    sql.append(" AND p.specific_name = r.specific_name");
+    sql.append(" WHERE r.").append(PROCEDURE_TYPE_FILTER);
+    if (schemaPattern != null) {
+      sql.append(" AND p.specific_schema LIKE ?");
+      params.put(paramIndex, buildStringParam(paramIndex, schemaPattern));
+      paramIndex++;
+    }
+    if (procedureNamePattern != null) {
+      sql.append(" AND p.specific_name LIKE ?");
+      params.put(paramIndex, buildStringParam(paramIndex, procedureNamePattern));
+      paramIndex++;
+    }
+    if (columnNamePattern != null) {
+      sql.append(" AND p.parameter_name LIKE ?");
+      params.put(paramIndex, buildStringParam(paramIndex, columnNamePattern));
+      paramIndex++;
+    }
+    sql.append(
+        " ORDER BY p.specific_catalog, p.specific_schema, p.specific_name, p.ordinal_position");
+    return sql.toString();
+  }
+
+  private static ImmutableSqlParameter buildStringParam(int index, String value) {
+    return ImmutableSqlParameter.builder()
+        .type(ColumnInfoTypeName.STRING)
+        .value(value)
+        .cardinal(index)
+        .build();
+  }
+
+  private static String getCatalogPrefix(String catalog) {
+    return (catalog == null) ? "system" : "`" + catalog + "`";
+  }
 }