Merge pull request #2242 from ClickHouse/add-jdbc-benchmarking

Paultagoras · web-flow · commit 892599e54c86 · 2025-03-25T05:19:05.000-04:00
Add JDBC Insert flow for Benchmarking
diff --git a/performance/src/test/com/clickhouse/benchmark/BenchmarkRunner.java b/performance/src/test/com/clickhouse/benchmark/BenchmarkRunner.java
@@ -5,6 +5,8 @@
 import com.clickhouse.benchmark.clients.ConcurrentQueryClient;
 import com.clickhouse.benchmark.clients.Deserializers;
 import com.clickhouse.benchmark.clients.InsertClient;
+import com.clickhouse.benchmark.clients.JDBCInsert;
+import com.clickhouse.benchmark.clients.JDBCQuery;
 import com.clickhouse.benchmark.clients.MixedWorkload;
 import com.clickhouse.benchmark.clients.QueryClient;
 import com.clickhouse.benchmark.clients.Serializers;
@@ -36,14 +38,16 @@ public static void main(String[] args) throws Exception {
         Map<String, String> argMap = parseArguments(args);
 
         Options opt = new OptionsBuilder()
-                .include(QueryClient.class.getSimpleName())
-                .include(InsertClient.class.getSimpleName())
-                .include(ConcurrentInsertClient.class.getSimpleName())
-                .include(ConcurrentQueryClient.class.getSimpleName())
-                .include(Compression.class.getSimpleName())
-                .include(Serializers.class.getSimpleName())
-                .include(Deserializers.class.getSimpleName())
-                .include(MixedWorkload.class.getSimpleName())
+                .include(QueryClient.class.getName())
+                .include(InsertClient.class.getName())
+                .include(ConcurrentInsertClient.class.getName())
+                .include(ConcurrentQueryClient.class.getName())
+                .include(Compression.class.getName())
+                .include(Serializers.class.getName())
+                .include(Deserializers.class.getName())
+                .include(MixedWorkload.class.getName())
+                .include(JDBCQuery.class.getName())
+                .include(JDBCInsert.class.getName())
                 .forks(1) // must be a fork. No fork only for debugging
                 .mode(Mode.SampleTime)
                 .timeUnit(TimeUnit.MILLISECONDS)
diff --git a/performance/src/test/com/clickhouse/benchmark/clients/BenchmarkBase.java b/performance/src/test/com/clickhouse/benchmark/clients/BenchmarkBase.java
@@ -11,6 +11,7 @@
 import com.clickhouse.client.ClickHouseNodeSelector;
 import com.clickhouse.client.ClickHouseProtocol;
 import com.clickhouse.client.ClickHouseResponse;
+import com.clickhouse.client.ClickHouseServerForTest;
 import com.clickhouse.client.api.Client;
 import com.clickhouse.client.api.ConnectionReuseStrategy;
 import com.clickhouse.client.api.enums.Protocol;
@@ -22,6 +23,7 @@
 import com.clickhouse.data.ClickHouseOutputStream;
 import com.clickhouse.data.ClickHouseRecord;
 import com.clickhouse.data.format.ClickHouseRowBinaryProcessor;
+import com.clickhouse.jdbc.ClickHouseDriver;
 import org.openjdk.jmh.annotations.Level;
 import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.Scope;
@@ -35,9 +37,12 @@
 import java.io.InputStream;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
+import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Properties;
 
 import static com.clickhouse.benchmark.BenchmarkRunner.getSelectCountQuery;
 import static com.clickhouse.benchmark.BenchmarkRunner.getSyncQuery;
@@ -52,14 +57,18 @@
 @State(Scope.Benchmark)
 public class BenchmarkBase {
     private static final Logger LOGGER = LoggerFactory.getLogger(BenchmarkBase.class);
-
     protected ClickHouseClient clientV1;
     protected Client clientV2;
+    protected static Connection jdbcV1;
+    protected static Connection jdbcV2;
+
     @Setup(Level.Iteration)
     public void setUpIteration() {
         LOGGER.info("BenchmarkBase::setUpIteration");
         clientV1 = getClientV1();
         clientV2 = getClientV2();
+        jdbcV1 = getJdbcV1();
+        jdbcV2 = getJdbcV2();
     }
 
     @TearDown(Level.Iteration)
@@ -73,6 +82,22 @@ public void tearDownIteration() {
             clientV2.close();
             clientV2 = null;
         }
+        if (jdbcV1 != null) {
+            try {
+                jdbcV1.close();
+            } catch (SQLException e) {
+                LOGGER.error(e.getMessage());
+            }
+            jdbcV1 = null;
+        }
+        if (jdbcV2 != null) {
+            try {
+                jdbcV2.close();
+            } catch (SQLException e) {
+                LOGGER.error(e.getMessage());
+            }
+            jdbcV2 = null;
+        }
     }
 
     @State(Scope.Benchmark)
@@ -240,6 +265,37 @@ protected static Client getClientV2(boolean includeDb) {
                 .setDefaultDatabase(includeDb ? DB_NAME : "default")
                 .build();
     }
+    
+    protected static Connection getJdbcV1() {
+        Properties properties = new Properties();
+        properties.put("user", getUsername());
+        properties.put("password", getPassword());
+        
+        ClickHouseNode node = getServer();
+        Connection jdbcV1 = null;
+        try {
+            jdbcV1 = new ClickHouseDriver().connect(String.format("jdbc:clickhouse://%s:%s?clickhouse.jdbc.v1=true", node.getHost(), node.getPort()), properties);
+        } catch (SQLException e) {
+            LOGGER.error(e.getMessage());
+        }
+        return jdbcV1;
+    }
+    
+    protected static Connection getJdbcV2() {
+        Properties properties = new Properties();
+        properties.put("user", getUsername());
+        properties.put("password", getPassword());
+
+        ClickHouseNode node = getServer();
+        Connection jdbcV2 = null;
+        try {
+            jdbcV2 = new ClickHouseDriver().connect(String.format("jdbc:clickhouse://%s:%s", node.getHost(), node.getPort()), properties);
+        } catch (SQLException e) {
+            LOGGER.error(e.getMessage());
+        }
+
+        return jdbcV2;
+    }
 
     public static void loadClickHouseRecords(DataState dataState) {
         syncQuery(dataState.tableNameFilled);
diff --git a/performance/src/test/com/clickhouse/benchmark/clients/JDBCInsert.java b/performance/src/test/com/clickhouse/benchmark/clients/JDBCInsert.java
@@ -0,0 +1,43 @@
+package com.clickhouse.benchmark.clients;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static com.clickhouse.benchmark.TestEnvironment.DB_NAME;
+
+public class JDBCInsert extends BenchmarkBase {
+    private static final Logger LOGGER = LoggerFactory.getLogger(JDBCInsert.class);
+    void insetData(Connection connection, DataState dataState) throws SQLException {
+        int size = dataState.dataSet.getSchema().getColumns().size();
+        String names = dataState.dataSet.getSchema().getColumns().stream().map(column -> column.getColumnName()).collect(Collectors.joining(","));
+        String values = dataState.dataSet.getSchema().getColumns().stream().map(column -> "?").collect(Collectors.joining(","));
+        String sql = String.format("INSERT INTO `%s`.`%s` (%s) VALUES (%s)", DB_NAME ,dataState.tableNameEmpty, names, values);
+        LOGGER.info("SQL: " + sql);
+        PreparedStatement preparedStatement = connection.prepareStatement(sql);
+        for (List<Object> data : dataState.dataSet.getRowsOrdered()) {
+            for (int j = 0; j < size; j++) {
+                preparedStatement.setObject(j + 1, data.get(j));
+            }
+            preparedStatement.addBatch();
+        }
+        preparedStatement.executeBatch();
+    }
+
+    @Benchmark
+    public void insertJDBCV1(DataState dataState) throws SQLException {
+        insetData(jdbcV1, dataState);
+    }
+
+    @Benchmark
+    public void insertJDBCV2(DataState dataState) throws SQLException {
+        insetData(jdbcV2, dataState);
+    }
+
+}
diff --git a/performance/src/test/com/clickhouse/benchmark/clients/JDBCQuery.java b/performance/src/test/com/clickhouse/benchmark/clients/JDBCQuery.java
@@ -0,0 +1,40 @@
+package com.clickhouse.benchmark.clients;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.infra.Blackhole;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static com.clickhouse.benchmark.BenchmarkRunner.getSelectQuery;
+
+public class JDBCQuery extends BenchmarkBase {
+    private static final Logger LOGGER = LoggerFactory.getLogger(JDBCQuery.class);
+    void selectData(Connection connection, DataState dataState, Blackhole blackhole) throws SQLException {
+        String sql = getSelectQuery(dataState.tableNameFilled);
+        try (Statement stmt = connection.createStatement()) {
+            try (ResultSet rs = stmt.executeQuery(sql)) {
+                while (rs.next()) {
+                    for (int i = 1; i <= dataState.dataSet.getSchema().getColumns().size(); i++) {
+                        blackhole.consume(rs.getObject(i));
+                    }
+                }
+            }
+        }
+    }
+
+    @Benchmark
+    public void selectJDBCV1(DataState dataState, Blackhole blackhole) throws SQLException {
+        selectData(jdbcV1, dataState, blackhole);
+    }
+
+    @Benchmark
+    public void selectJDBCV2(DataState dataState, Blackhole blackhole) throws SQLException {
+        selectData(jdbcV2, dataState, blackhole);
+    }
+
+}
