Fix driver crash when using INTERVAL types (databricks#1085)

## Description

This PR fixes a driver crash that occurs when executing a query
returning an `INTERVAL` type mentioned in
databricks#1083 issue.
Previously, `PreparedStatement.getMetaData()` failed with:

```
IllegalArgumentException: No enum constant ColumnInfoTypeName.INTERVAL DAY TO SECOND
```

This happened because the driver attempted to map interval types to an
enum that did not support multi-word SQL type names such as `INTERVAL
DAY TO SECOND`.

### What has been done

* Added support for INTERVAL types in metadata handling.
* Ensured `DatabricksPreparedStatement.getMetaData()` and supporting
code paths correctly parse and map interval type names.
* Changed visibility of `SIGNED_TYPES` from private to public (just a
suggestion — it seems useful and potentially reusable).

This PR addresses the issue described in *Follow-up databricks#1064* and fixes the
metadata retrieval for interval expressions such as:

```sql
SELECT current_timestamp() - '2025-01-01 00:00:00.0'
SELECT INTERVAL '15' MINUTE
```

---

## Testing

~**Still planning to add automated tests — this is a DRAFT.**~

Manual testing performed so far:

* Used a small Java program (included below) that:

  * Prepares a statement returning an interval value.
  * Calls `getMetaData()` to verify that no exceptions are thrown.
  * Prints metadata fields (type, name, precision, scale, etc.).
* Executes the query and validates that values can be retrieved via both
`getObject()` and `getString()`.

Tested on driver version **3.0.4**.

Before this fix → driver crashes.
With this PR → metadata is returned successfully and the interval value
can be fetched.

### How to manually test the change

You can use the following standalone Java snippet to test the fix
end-to-end:

```java
public static void main(String[] args) {
  String url = "...";
  Properties props = new Properties();
  Driver driver = Driver.getInstance();

  try (Connection conn = driver.connect(url, props)) {
    try (PreparedStatement st = conn.prepareStatement("SELECT INTERVAL '15' MINUTE")) {
      ResultSetMetaData rsmd = st.getMetaData();

      System.out.println("=== ResultSetMetaData ===");
      System.out.println("Column count: " + rsmd.getColumnCount());

      for (int i = 1; i <= rsmd.getColumnCount(); i++) {
        System.out.println("\nColumn " + i + ":");
        System.out.println("  Name: " + rsmd.getColumnName(i));
        System.out.println("  Label: " + rsmd.getColumnLabel(i));
        System.out.println("  Type: " + rsmd.getColumnType(i));
        System.out.println("  Type Name: " + rsmd.getColumnTypeName(i));
        System.out.println("  Class Name: " + rsmd.getColumnClassName(i));
        System.out.println("  Display Size: " + rsmd.getColumnDisplaySize(i));
        System.out.println("  Precision: " + rsmd.getPrecision(i));
        System.out.println("  Scale: " + rsmd.getScale(i));
      }

      try (ResultSet rs = st.executeQuery()) {
        System.out.println("=== Query Results ===");

        while (rs.next()) {
          Object value = rs.getObject(1);
          String stringValue = rs.getString(1);

          System.out.println("Value (Object): " + value);
          System.out.println("Value (String): " + stringValue);
          System.out.println("Value class: " + (value != null ? value.getClass() : "null"));
        }
      }

    } catch (SQLException e) {
      System.err.println("SQL Error: " + e.getMessage());
      e.printStackTrace();
      throw new RuntimeException(e);
    }
  } catch (SQLException e) {
    System.err.println("Connection Error: " + e.getMessage());
    e.printStackTrace();
    throw new RuntimeException(e);
  }

  TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
  System.out.printf("\nThe driver {%s} has been initialized.%n", Driver.class);
}
```

---

## Additional Notes to the Reviewer

~* **This PR is a DRAFT** — unit tests will be added before marking it
ready.~

* Early feedback is welcome, especially regarding:

  * The chosen mapping strategy for interval types.
  * Whether exposing `SIGNED_TYPES` is acceptable.
  * Enum / type-parsing paths that may need to be refactored.
* If there are other interval forms worth testing (e.g., `INTERVAL DAY`,
`INTERVAL SECOND`, mixed units), please let me know.
* I’m open to suggestions on where interval-related tests should live in
the test suite.

---------

Signed-off-by: Roman Dryndik <dryndikroman@gmail.com>
Co-authored-by: Samikshya Chand <148681192+samikshya-db@users.noreply.github.com>

Author: MagnetonBora

NEXT_CHANGELOG.md

@@ -9,5 +9,7 @@
 
 ### Fixed
 
+- Fix driver crash when using `INTERVAL` types.
+
 ---
 *Note: When making changes, please add your change under the appropriate section with a brief description.*

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

@@ -456,6 +456,8 @@ public DatabricksResultSetMetaData(
       } else if (columnTypeText.equalsIgnoreCase(VARIANT)) {
         columnTypeName = ColumnInfoTypeName.STRING;
         columnTypeText = VARIANT;
+      } else if (columnTypeText.toUpperCase().startsWith(INTERVAL)) {
+        columnTypeName = ColumnInfoTypeName.INTERVAL;
       } else {
         columnTypeName =
             ColumnInfoTypeName.valueOf(metadataResultSetBuilder.stripBaseTypeName(columnTypeText));
@@ -492,7 +494,6 @@ public DatabricksResultSetMetaData(
     this.totalRows = -1;
     this.columns = columnsBuilder.build();
     this.columnNameIndex = CaseInsensitiveImmutableMap.copyOf(columnNameToIndexMap);
-    ;
   }
 
   @Override

src/main/java/com/databricks/jdbc/common/util/DatabricksTypeUtil.java

@@ -53,9 +53,9 @@ public class DatabricksTypeUtil {
   public static final String STRUCT = "STRUCT";
   public static final String VARIANT = "VARIANT";
   public static final String CHAR = "CHAR";
-  public static final String INTERVAL = "INTERVAL";
   public static final String GEOMETRY = "GEOMETRY";
   public static final String GEOGRAPHY = "GEOGRAPHY";
+  public static final String INTERVAL = "INTERVAL";
   public static final String GEOMETRY_CLASS_NAME = "com.databricks.jdbc.api.IGeometry";
   public static final String GEOGRAPHY_CLASS_NAME = "com.databricks.jdbc.api.IGeography";
   public static final String MEASURE = "measure";
@@ -114,6 +114,8 @@ public static ColumnInfoTypeName getColumnInfoType(String typeName) {
         return ColumnInfoTypeName.NULL;
       case DatabricksTypeUtil.MAP:
         return ColumnInfoTypeName.MAP;
+      case DatabricksTypeUtil.INTERVAL:
+        return ColumnInfoTypeName.INTERVAL;
     }
     return ColumnInfoTypeName.USER_DEFINED_TYPE;
   }

src/test/java/com/databricks/jdbc/api/impl/DatabricksResultSetMetaDataTest.java

@@ -199,7 +199,70 @@ public void testDatabricksResultSetMetaDataInitialization_DescribeQuery() throws
       {"col_struct", "struct<col_int:int,col_string:string>", "STRUCT", Types.STRUCT, 255, 0},
       {"col_array", "array<int>", "ARRAY", Types.ARRAY, 255, 0},
       {"col_map", "map<string,string>", "MAP", Types.VARCHAR, 255, 0},
-      {"col_variant", "variant", "VARIANT", Types.VARCHAR, 255, 0}
+      {"col_variant", "variant", "VARIANT", Types.VARCHAR, 255, 0},
+      {"col_interval", "interval", "INTERVAL", Types.VARCHAR, 255, 0},
+      {"col_interval_second", "interval second", "INTERVAL SECOND", Types.VARCHAR, 255, 0},
+      {"col_interval_minute", "interval minute", "INTERVAL MINUTE", Types.VARCHAR, 255, 0},
+      {"col_interval_hour", "interval hour", "INTERVAL HOUR", Types.VARCHAR, 255, 0},
+      {"col_interval_day", "interval day", "INTERVAL DAY", Types.VARCHAR, 255, 0},
+      {"col_interval_month", "interval month", "INTERVAL MONTH", Types.VARCHAR, 255, 0},
+      {"col_interval_year", "interval year", "INTERVAL YEAR", Types.VARCHAR, 255, 0},
+      {
+        "col_interval_year_to_month",
+        "interval year to month",
+        "INTERVAL YEAR TO MONTH",
+        Types.VARCHAR,
+        255,
+        0
+      },
+      {
+        "col_interval_day_to_hour",
+        "interval day to hour",
+        "INTERVAL DAY TO HOUR",
+        Types.VARCHAR,
+        255,
+        0
+      },
+      {
+        "col_interval_day_to_minute",
+        "interval day to minute",
+        "INTERVAL DAY TO MINUTE",
+        Types.VARCHAR,
+        255,
+        0
+      },
+      {
+        "col_interval_day_to_second",
+        "interval day to second",
+        "INTERVAL DAY TO SECOND",
+        Types.VARCHAR,
+        255,
+        0
+      },
+      {
+        "col_interval_hour_to_minute",
+        "interval hour to minute",
+        "INTERVAL HOUR TO MINUTE",
+        Types.VARCHAR,
+        255,
+        0
+      },
+      {
+        "col_interval_hour_to_second",
+        "interval hour to second",
+        "INTERVAL HOUR TO SECOND",
+        Types.VARCHAR,
+        255,
+        0
+      },
+      {
+        "col_interval_minute_to_second",
+        "interval minute to second",
+        "INTERVAL MINUTE TO SECOND",
+        Types.VARCHAR,
+        255,
+        0
+      }
     };
 
     List<String> columnNames =

src/test/java/com/databricks/jdbc/common/util/DatabricksTypeUtilTest.java

@@ -284,6 +284,7 @@ void testInferDatabricksType() {
     "NULL, NULL",
     "MAP, MAP",
     "CHAR, STRING",
+    "INTERVAL, INTERVAL",
     "UNKNOWN, USER_DEFINED_TYPE"
   })
   public void testGetColumnInfoType(String inputTypeName, String expectedTypeName) {