more

Author: trask

instrumentation/jdbc/library/src/main/java/io/opentelemetry/instrumentation/jdbc/internal/OpenTelemetryPreparedStatement.java

@@ -430,15 +430,6 @@ public void setObject(int parameterIndex, Object x, SQLType targetSqlType) throw
 
   @Override
   public long executeLargeUpdate() throws SQLException {
-    return wrapCall(
-        query,
-        () -> {
-          try {
-            return delegate.executeLargeUpdate();
-          } catch (UnsupportedOperationException ignored) {
-            // Fallback for drivers that only implement executeUpdate
-            return (long) delegate.executeUpdate();
-          }
-        });
+    return wrapCall(query, delegate::executeLargeUpdate);
   }
 }

instrumentation/jdbc/library/src/main/java/io/opentelemetry/instrumentation/jdbc/internal/OpenTelemetryStatement.java

@@ -28,7 +28,6 @@
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.sql.SQLFeatureNotSupportedException;
 import java.sql.SQLWarning;
 import java.sql.Statement;
 import java.util.ArrayList;
@@ -330,22 +329,7 @@ public long getLargeMaxRows() throws SQLException {
 
   @Override
   public long[] executeLargeBatch() throws SQLException {
-    return wrapBatchCall(
-        () -> {
-          try {
-            return delegate.executeLargeBatch();
-          } catch (UnsupportedOperationException
-              | SQLFeatureNotSupportedException
-              | AbstractMethodError ignored) {
-            // Older drivers rely on the default executeLargeBatch implementation, which throws.
-            int[] batchResult = delegate.executeBatch();
-            long[] converted = new long[batchResult.length];
-            for (int index = 0; index < batchResult.length; index++) {
-              converted[index] = batchResult[index];
-            }
-            return converted;
-          }
-        });
+    return wrapBatchCall(delegate::executeLargeBatch);
   }
 
   @Override

instrumentation/jdbc/testing/src/main/java/io/opentelemetry/instrumentation/jdbc/testing/AbstractJdbcInstrumentationTest.java

@@ -26,6 +26,7 @@
 import static io.opentelemetry.semconv.incubating.DbIncubatingAttributes.DB_SYSTEM;
 import static io.opentelemetry.semconv.incubating.DbIncubatingAttributes.DB_USER;
 import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import com.google.common.collect.ImmutableMap;
@@ -880,15 +881,27 @@ void testPreparedStatementLargeUpdate(
       String table)
       throws SQLException {
     Connection connection = wrap(conn);
-    testPreparedStatementUpdateImpl(
-        system,
-        connection,
-        username,
-        query,
-        spanName,
-        url,
-        table,
-        statement -> assertThat(statement.executeLargeUpdate()).isEqualTo(0));
+    
+    // executeLargeUpdate was added in JDBC 4.2
+    if (supportsJdbc42(connection)) {
+      testPreparedStatementUpdateImpl(
+          system,
+          connection,
+          username,
+          query,
+          spanName,
+          url,
+          table,
+          statement -> assertThat(statement.executeLargeUpdate()).isEqualTo(0));
+    } else {
+      // Driver doesn't support JDBC 4.2, expect UnsupportedOperationException
+      // This is the correct behavior - instrumentation should not change driver behavior
+      String sql = connection.nativeSQL(query);
+      PreparedStatement statement = connection.prepareStatement(sql);
+      cleanup.deferCleanup(statement);
+      assertThatThrownBy(statement::executeLargeUpdate)
+          .isInstanceOf(UnsupportedOperationException.class);
+    }
   }
 
   void testPreparedStatementUpdateImpl(
@@ -1440,13 +1453,28 @@ void testLargeBatch(String system, Connection connection, String username, Strin
     // derby and hsqldb used in this test don't support executeLargeBatch
     assumeTrue("h2".equals(system));
 
-    testBatchImpl(
-        system,
-        wrap(connection),
-        username,
-        url,
-        "simple_batch_test_large",
-        statement -> assertThat(statement.executeLargeBatch()).isEqualTo(new long[] {1, 1}));
+    Statement createTable = wrap(connection).createStatement();
+    createTable.execute(
+        "CREATE TABLE simple_batch_test_large (id INTEGER not NULL, PRIMARY KEY ( id ))");
+    Statement statement = wrap(connection).createStatement();
+    statement.addBatch("INSERT INTO simple_batch_test_large VALUES(1)");
+    statement.addBatch("INSERT INTO simple_batch_test_large VALUES(2)");
+
+    // executeLargeBatch was added in JDBC 4.2
+    if (supportsJdbc42(connection)) {
+      assertThat(statement.executeLargeBatch()).isEqualTo(new long[] {1, 1});
+    } else {
+      // Driver doesn't support JDBC 4.2, expect UnsupportedOperationException
+      // This is the correct behavior - instrumentation should not change driver behavior
+      assertThatThrownBy(statement::executeLargeBatch)
+          .isInstanceOf(UnsupportedOperationException.class);
+    }
+  }
+
+  private static boolean supportsJdbc42(Connection connection) throws SQLException {
+    return connection.getMetaData().getJDBCMajorVersion() > 4
+        || (connection.getMetaData().getJDBCMajorVersion() == 4
+            && connection.getMetaData().getJDBCMinorVersion() >= 2);
   }
 
   private void testBatchImpl(