@@ -42,7 +42,7 @@ public static JdbcTypeHandler create(String tableType, String... sensitiveValues
                 return new MySQLTypeHandler(tableType);
             case "ORACLE":
             case "OCEANBASE_ORACLE":
-                return new OracleTypeHandler(sensitiveValues);
+                return new OracleTypeHandler(tableType, sensitiveValues);
             case "POSTGRESQL":
                 return new PostgreSQLTypeHandler();
             case "CLICKHOUSE":
 
@@ -60,11 +60,16 @@ public class OracleTypeHandler extends DefaultTypeHandler {
 
     private final String[] sensitiveValues;
 
+    // Whether the catalog connects through Oracle's driver. An Oracle-mode OceanBase catalog shares this handler but
+    // connects through OceanBase's driver, which has no oracle.jdbc classes.
+    private final boolean oracleDriver;
+
     public OracleTypeHandler() {
-        this(new String[0]);
+        this("ORACLE");
     }
 
-    public OracleTypeHandler(String... sensitiveValues) {
+    public OracleTypeHandler(String tableType, String... sensitiveValues) {
+        this.oracleDriver = "ORACLE".equalsIgnoreCase(tableType);
         this.sensitiveValues = sensitiveValues.clone();
     }
 
@@ -123,14 +128,17 @@ public PreparedStatement initializeStatement(Connection conn, String sql,
                                                  int fetchSize) throws SQLException {
         // Detect driver version when creating the statement (first time we have access to connection)
         detectDriverVersion(conn);
-        // ALTER SESSION alone leaves the driver's TSLTZ zone unset. Initialize every borrowed connection.
-        try {
-            Connection physical = conn.unwrap(Connection.class);
-            Class<?> oracleConnection = Class.forName("oracle.jdbc.OracleConnection", true,
-                    physical.getClass().getClassLoader());
-            oracleConnection.getMethod("setSessionTimeZone", String.class).invoke(conn.unwrap(oracleConnection), "UTC");
-        } catch (ReflectiveOperationException e) {
-            throw new SQLException("Failed to initialize Oracle session time zone", e);
+        // ALTER SESSION alone leaves the Oracle driver's TSLTZ zone unset. Initialize every borrowed connection.
+        if (oracleDriver) {
+            try {
+                Connection physical = conn.unwrap(Connection.class);
+                Class<?> oracleConnection = Class.forName("oracle.jdbc.OracleConnection", true,
+                        physical.getClass().getClassLoader());
+                oracleConnection.getMethod("setSessionTimeZone", String.class)
+                        .invoke(conn.unwrap(oracleConnection), "UTC");
+            } catch (ReflectiveOperationException e) {
+                throw new SQLException("Failed to initialize Oracle session time zone", e);
+            }
         }
         PreparedStatement stmt = conn.prepareStatement(sql,
                 ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
 
@@ -24,6 +24,7 @@
 import org.mockito.InOrder;
 import org.mockito.Mockito;
 
+import java.lang.reflect.Proxy;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -68,4 +69,43 @@ void failedSessionInitializationAbortsBeforeQuery() throws Exception {
         Mockito.verify(pooled, Mockito.never()).prepareStatement(
                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt());
     }
+
+    @Test
+    void oracleCatalogSetsTheSessionTimeZone() throws Exception {
+        Connection pooled = Mockito.mock(Connection.class);
+        OracleConnection physical = Mockito.mock(OracleConnection.class);
+        DatabaseMetaData metadata = Mockito.mock(DatabaseMetaData.class);
+        Mockito.when(metadata.getDriverVersion()).thenReturn("23.26.2");
+        Mockito.when(pooled.getMetaData()).thenReturn(metadata);
+        Mockito.when(pooled.unwrap(Connection.class)).thenReturn(physical);
+        Mockito.when(pooled.unwrap(OracleConnection.class)).thenReturn(physical);
+        Mockito.when(pooled.prepareStatement(Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt()))
+                .thenReturn(Mockito.mock(PreparedStatement.class));
+        JdbcTypeHandlerFactory.create("ORACLE").initializeStatement(pooled, "SELECT ts FROM t", 100);
+        Mockito.verify(physical).setSessionTimeZone("UTC");
+    }
+
+    @Test
+    void oceanBaseOracleModeScansWithoutTheOracleDriver() throws Exception {
+        // An Oracle-mode OceanBase catalog shares this handler but connects through OceanBase's driver, whose class
+        // loader has no oracle.jdbc classes, so its scans must not need them. The connection below is defined by
+        // the platform class loader, which cannot see the Oracle driver on the test class path either.
+        // MUTATION: setting the Oracle session time zone for OCEANBASE_ORACLE too -> red.
+        Connection physical = (Connection) Proxy.newProxyInstance(ClassLoader.getPlatformClassLoader(),
+                new Class<?>[] {Connection.class}, (proxy, method, args) -> {
+                    throw new UnsupportedOperationException(method.getName());
+                });
+        Connection pooled = Mockito.mock(Connection.class);
+        DatabaseMetaData metadata = Mockito.mock(DatabaseMetaData.class);
+        PreparedStatement statement = Mockito.mock(PreparedStatement.class);
+        Mockito.when(metadata.getDriverVersion()).thenReturn("2.4.9");
+        Mockito.when(pooled.getMetaData()).thenReturn(metadata);
+        Mockito.when(pooled.unwrap(Connection.class)).thenReturn(physical);
+        Mockito.when(pooled.prepareStatement(Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt()))
+                .thenReturn(statement);
+
+        Assertions.assertSame(statement, JdbcTypeHandlerFactory.create("OCEANBASE_ORACLE")
+                .initializeStatement(pooled, "SELECT 1 FROM dual", 100));
+        Mockito.verify(statement).setFetchSize(100);
+    }
 }