= remaining) {
+ currentPos += remaining;
+ break;
+ } else {
+ remaining -= (buf.length - currentPos);
+ current++;
+ currentPos = 0;
+ }
+ }
+ pos += k;
+ return k;
+ }
+
+ /**
+ * Returns the number of remaining bytes that can be read (or skipped over)
+ * from this input stream.
+ *
+ * The value returned is count - pos,
+ * which is the number of bytes remaining to be read from the input buffer.
+ *
+ * @return the number of remaining bytes that can be read (or skipped
+ * over) from this input stream without blocking.
+ */
+ public synchronized int available() {
+ return count - pos;
+ }
+
+ public boolean markSupported() {
+ return true;
+ }
+
+ /**
+ * Mark the pos and you can reset to it.
+ */
+ public synchronized void mark(int readAheadLimit) {
+ mark = pos;
+ }
+
+ /**
+ * Resets the buffer to the marked position. The marked position
+ * is 0 unless another position was marked or an offset was specified
+ * in the constructor.
+ */
+ public synchronized void reset() {
+ int remaining = mark;
+ for (int i=0; i= remaining) {
+ currentPos = remaining;
+ current = i;
+ break;
+ } else {
+ remaining -= buf.length;
+ }
+ }
+ pos = mark;
+ }
+
+ public void close() throws IOException {
+ // do nothing.
+ }
+}
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
index a3c18ec5b..57cae8722 100644
--- a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
+++ b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
@@ -5,11 +5,24 @@
import com.clickhouse.client.ClickHouseNode;
import com.clickhouse.client.ClickHouseRequest;
+import com.clickhouse.client.http.config.ClickHouseHttpOption;
+import com.clickhouse.client.http.config.HttpConnectionProvider;
public final class ClickHouseHttpConnectionFactory {
public static ClickHouseHttpConnection createConnection(ClickHouseNode server, ClickHouseRequest request,
ExecutorService executor) throws IOException {
- return new HttpUrlConnectionImpl(server, request, executor);
+ HttpConnectionProvider provider = request.getConfig().getOption(ClickHouseHttpOption.CONNECTION_PROVIDER,
+ HttpConnectionProvider.class);
+
+ try {
+ return provider == null || provider == HttpConnectionProvider.HTTP_URL_CONNECTION
+ ? new HttpUrlConnectionImpl(server, request, executor)
+ : new ApacheHttpConnectionImpl(server, request, executor);
+ } catch (IOException e) {
+ throw e;
+ } catch (Throwable t) {
+ return new HttpUrlConnectionImpl(server, request, executor);
+ }
}
private ClickHouseHttpConnectionFactory() {
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpEntity.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpEntity.java
new file mode 100644
index 000000000..1fd01860f
--- /dev/null
+++ b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpEntity.java
@@ -0,0 +1,90 @@
+package com.clickhouse.client.http;
+
+import com.clickhouse.client.ClickHouseClient;
+import com.clickhouse.client.ClickHouseConfig;
+import com.clickhouse.client.ClickHouseInputStream;
+import com.clickhouse.client.ClickHouseOutputStream;
+import org.apache.hc.core5.http.io.entity.AbstractHttpEntity;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Objects;
+
+/**
+ * Used to encapsulate post request.
+ */
+public class ClickHouseHttpEntity extends AbstractHttpEntity {
+
+ /**
+ * Data to send
+ */
+ private final ClickHouseInputStream in;
+ private final ClickHouseConfig config;
+ /**
+ * Indicate that there is extra data which comes from file.
+ */
+ private final boolean hasFile;
+ /**
+ * Indicate that there is extra data which comes from external tables.
+ */
+ private final boolean hasInput;
+
+ public ClickHouseHttpEntity(ClickHouseInputStream in, ClickHouseConfig config, String contentType,
+ String contentEncoding,
+ boolean hasFile, boolean hasInput) {
+ super(contentType, contentEncoding, hasInput);
+ this.in = in;
+ this.config = config;
+ this.hasFile = hasFile;
+ this.hasInput = hasInput;
+ }
+
+ @Override
+ public boolean isRepeatable() {
+ return false;
+ }
+
+ @Override
+ public long getContentLength() {
+ return -1;
+ }
+
+ @Override
+ public InputStream getContent() throws IOException, UnsupportedOperationException {
+ return in;
+ }
+
+ @Override
+ public void writeTo(OutputStream outStream) throws IOException {
+ Objects.requireNonNull(outStream, "outStream");
+ try {
+ OutputStream wrappedOut = hasFile
+ ? ClickHouseOutputStream.of(outStream, config.getWriteBufferSize())
+ : (hasInput
+ ? ClickHouseClient.getAsyncRequestOutputStream(config, outStream, null)
+ : ClickHouseClient.getRequestOutputStream(config, outStream, null)
+ );
+ final byte[] buffer = new byte[config.getBufferSize()];
+ int readLen;
+ while ((readLen = in.read(buffer)) != -1) {
+ wrappedOut.write(buffer, 0, readLen);
+ }
+ wrappedOut.flush();
+ } finally {
+ in.close();
+ }
+ }
+
+ @Override
+ public boolean isStreaming() {
+ return false;
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (in != null) {
+ in.close();
+ }
+ }
+}
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/ClickHouseHttpOption.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/ClickHouseHttpOption.java
index 4d91a0649..5818ec41d 100644
--- a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/ClickHouseHttpOption.java
+++ b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/ClickHouseHttpOption.java
@@ -1,10 +1,10 @@
package com.clickhouse.client.http.config;
-import java.io.Serializable;
-
import com.clickhouse.client.ClickHouseChecker;
import com.clickhouse.client.config.ClickHouseOption;
+import java.io.Serializable;
+
/**
* Http client options.
*/
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/HttpConnectionProvider.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/HttpConnectionProvider.java
index 2eba73bdf..76218d147 100644
--- a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/HttpConnectionProvider.java
+++ b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/HttpConnectionProvider.java
@@ -2,5 +2,6 @@
public enum HttpConnectionProvider {
HTTP_CLIENT,
- HTTP_URL_CONNECTION
+ HTTP_URL_CONNECTION,
+ APACHE_HTTP_CLIENT
}
diff --git a/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java b/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
index 9bd6d54b0..5396f11c6 100644
--- a/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
+++ b/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
@@ -17,7 +17,9 @@ public static ClickHouseHttpConnection createConnection(ClickHouseNode server, C
try {
return provider == null || provider == HttpConnectionProvider.HTTP_URL_CONNECTION
? new HttpUrlConnectionImpl(server, request, executor)
- : new HttpClientConnectionImpl(server, request, executor);
+ : provider == HttpConnectionProvider.HTTP_CLIENT
+ ? new HttpClientConnectionImpl(server, request, executor)
+ : new ApacheHttpConnectionImpl(server, request, executor);
} catch (IOException e) {
throw e;
} catch (Throwable t) {
diff --git a/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ApacheHttpConnectionImplTest.java b/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ApacheHttpConnectionImplTest.java
new file mode 100644
index 000000000..7ed1c24ca
--- /dev/null
+++ b/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ApacheHttpConnectionImplTest.java
@@ -0,0 +1,38 @@
+package com.clickhouse.client.http;
+
+import com.clickhouse.client.BaseIntegrationTest;
+import com.clickhouse.client.ClickHouseClient;
+import com.clickhouse.client.ClickHouseNode;
+import com.clickhouse.client.ClickHouseProtocol;
+import com.clickhouse.client.ClickHouseRequest;
+import com.clickhouse.client.ClickHouseResponse;
+import com.clickhouse.client.http.config.ClickHouseHttpOption;
+import com.clickhouse.client.http.config.HttpConnectionProvider;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class ApacheHttpConnectionImplTest extends BaseIntegrationTest {
+ @Test(groups = { "integration" })
+ public void testConnection() throws Exception {
+ ClickHouseNode server = getServer(ClickHouseProtocol.HTTP);
+
+ try (ClickHouseClient client = ClickHouseClient.newInstance()) {
+
+ ClickHouseRequest req1 = client.connect(server);
+ try (ClickHouseResponse resp = req1
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, HttpConnectionProvider.APACHE_HTTP_CLIENT)
+ .query("select 1").executeAndWait()) {
+ Assert.assertEquals(resp.firstRecord().getValue(0).asString(), "1");
+ }
+
+ // req2 will use same connection with req1
+ ClickHouseRequest req2 = client.connect(server);
+ try (ClickHouseResponse resp = req2
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, HttpConnectionProvider.APACHE_HTTP_CLIENT)
+ .query("select 1").executeAndWait()) {
+ Assert.assertEquals(resp.firstRecord().getValue(0).asString(), "1");
+ }
+
+ }
+ }
+}
diff --git a/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ByteArraysInputStreamTest.java b/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ByteArraysInputStreamTest.java
new file mode 100644
index 000000000..14a018694
--- /dev/null
+++ b/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ByteArraysInputStreamTest.java
@@ -0,0 +1,177 @@
+package com.clickhouse.client.http;
+
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class ByteArraysInputStreamTest {
+
+ @Test(groups = { "unit" })
+ public void testInvalidValue() {
+ Assert.assertThrows(NullPointerException.class,
+ () -> ByteArraysInputStream.of((List) null));
+ Assert.assertThrows(NullPointerException.class,
+ () -> ByteArraysInputStream.of(new byte[] {1}, null));
+ }
+
+ @Test(groups = { "unit" })
+ public void testNewInstance() {
+ ByteArraysInputStream in1 = ByteArraysInputStream.of(new byte[] {1,2,3});
+ Assert.assertEquals(in1.pos, 0);
+ Assert.assertEquals(in1.count, 3);
+ Assert.assertEquals(in1.mark, 0);
+ Assert.assertEquals(in1.current, 0);
+ Assert.assertEquals(in1.currentPos, 0);
+
+ ByteArraysInputStream in2 = ByteArraysInputStream.of(new byte[] {1,2,3}, new byte[] {4,5,6});
+ Assert.assertEquals(in2.pos, 0);
+ Assert.assertEquals(in2.count, 6);
+ Assert.assertEquals(in2.mark, 0);
+ Assert.assertEquals(in2.current, 0);
+ Assert.assertEquals(in2.currentPos, 0);
+ }
+
+ @DataProvider(name = "getIn")
+ protected Object[][] getIn() {
+ return new Object[][] {
+ { ByteArraysInputStream.of(new byte[] {}) },
+ { ByteArraysInputStream.of(new byte[] {1,2,3}) },
+ { ByteArraysInputStream.of(new byte[] {1,2,3}, new byte[] {4,5,6}) },
+ { ByteArraysInputStream.of(new byte[] {1,2,3}, new byte[0], new byte[] {4,5,6}) },
+ };
+ }
+
+ @Test(dataProvider = "getIn", groups = { "unit" })
+ public void testRead(ByteArraysInputStream in) {
+ for (int i=0; i getClientClass() {
return ClickHouseHttpClient.class;
}
- @Test(groups = "integration")
- public void testAuthentication() throws ClickHouseException {
+ @DataProvider(name = "connectionProvider")
+ protected Object[][] getConnectionProvider() {
+ return new Object[][] {
+ { HttpConnectionProvider.HTTP_URL_CONNECTION },
+ { HttpConnectionProvider.APACHE_HTTP_CLIENT }
+ };
+ }
+
+ @Test(dataProvider = "connectionProvider", groups = "integration")
+ public void testAuthentication(HttpConnectionProvider connProvider) throws ClickHouseException {
String sql = "select currentUser()";
try (ClickHouseClient client = getClient(
new ClickHouseConfig(null, ClickHouseCredentials.fromUserAndPassword("dba", "dba"), null, null));
ClickHouseResponse response = client
.connect(getServer())
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
// .option(ClickHouseHttpOption.CUSTOM_PARAMS, "user=dba,password=incorrect")
.query(sql).executeAndWait()) {
Assert.assertEquals(response.firstRecord().getValue(0).asString(), "dba");
@@ -54,6 +68,7 @@ public void testAuthentication() throws ClickHouseException {
try (ClickHouseClient client = getClient();
ClickHouseResponse response = client
.connect(getServer())
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.option(ClickHouseHttpOption.CUSTOM_HEADERS, "Authorization=Basic ZGJhOmRiYQ==")
// .option(ClickHouseHttpOption.CUSTOM_PARAMS, "user=dba,password=incorrect")
.query(sql).executeAndWait()) {
@@ -64,21 +79,23 @@ public void testAuthentication() throws ClickHouseException {
ClickHouseResponse response = client
.connect(getServer(ClickHouseNode
.of("http://localhost?custom_http_headers=aUthorization%3DBasic%20ZGJhOmRiYQ%3D%3D")))
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.query(sql).executeAndWait()) {
Assert.assertEquals(response.firstRecord().getValue(0).asString(), "dba");
}
}
- @Test(groups = "integration")
- @Override
- public void testSession() throws ClickHouseException {
+ @Test(dataProvider = "connectionProvider", groups = "integration")
+ public void testSession(HttpConnectionProvider connProvider) throws ClickHouseException {
super.testSession();
ClickHouseNode server = getServer();
String sessionId = ClickHouseRequestManager.getInstance().createSessionId();
try (ClickHouseClient client = getClient()) {
ClickHouseRequest req = client.connect(server).session(sessionId, true)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.option(ClickHouseHttpOption.CUSTOM_PARAMS, "session_check=0,max_query_size=1000")
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, HttpConnectionProvider.APACHE_HTTP_CLIENT)
.transaction(null)
.format(ClickHouseFormat.RowBinaryWithNamesAndTypes);
try (ClickHouseResponse resp = req.copy()
@@ -92,20 +109,24 @@ public void testSession() throws ClickHouseException {
}
}
- @Test(groups = { "integration" })
- public void testPing() {
- try (ClickHouseClient client = ClickHouseClient.newInstance(ClickHouseProtocol.HTTP)) {
+ @Test(dataProvider = "connectionProvider", groups = "integration")
+ public void testPing(HttpConnectionProvider connProvider) {
+ try (ClickHouseClient client = ClickHouseClient.builder()
+ .nodeSelector(ClickHouseNodeSelector.of(ClickHouseProtocol.HTTP))
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider).build()) {
Assert.assertTrue(client.ping(getServer(), 3000));
}
try (ClickHouseClient client = ClickHouseClient.builder()
.nodeSelector(ClickHouseNodeSelector.of(ClickHouseProtocol.HTTP))
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.option(ClickHouseHttpOption.WEB_CONTEXT, "a/b").build()) {
Assert.assertTrue(client.ping(getServer(), 3000));
}
try (ClickHouseClient client = ClickHouseClient.builder()
.nodeSelector(ClickHouseNodeSelector.of(ClickHouseProtocol.HTTP))
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.option(ClickHouseHttpOption.WEB_CONTEXT, "a/b")
.option(ClickHouseClientOption.HEALTH_CHECK_METHOD, ClickHouseHealthCheckMethod.PING).build()) {
Assert.assertFalse(client.ping(getServer(), 3000));
@@ -113,6 +134,7 @@ public void testPing() {
try (ClickHouseClient client = ClickHouseClient.builder()
.nodeSelector(ClickHouseNodeSelector.of(ClickHouseProtocol.HTTP))
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.option(ClickHouseHttpOption.WEB_CONTEXT, "/")
.option(ClickHouseClientOption.HEALTH_CHECK_METHOD, ClickHouseHealthCheckMethod.PING).build()) {
Assert.assertTrue(client.ping(getServer(), 3000));
@@ -120,6 +142,7 @@ public void testPing() {
try (ClickHouseClient client = ClickHouseClient.builder()
.nodeSelector(ClickHouseNodeSelector.of(ClickHouseProtocol.HTTP))
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.option(ClickHouseClientOption.HEALTH_CHECK_METHOD, ClickHouseHealthCheckMethod.PING)
.removeOption(ClickHouseHttpOption.WEB_CONTEXT).build()) {
Assert.assertTrue(client.ping(getServer(), 3000));
@@ -138,8 +161,8 @@ public void testTransaction() throws ClickHouseException {
testImplicitTransaction();
}
- @Test // (groups = "integration")
- public void testSslClientAuth() throws ClickHouseException {
+ @Test(dataProvider = "connectionProvider")// (groups = "integration")
+ public void testSslClientAuth(HttpConnectionProvider connProvider) throws ClickHouseException {
// NPE on JDK 8:
// java.lang.NullPointerException
// at sun.security.provider.JavaKeyStore.convertToBytes(JavaKeyStore.java:822)
@@ -156,17 +179,20 @@ public void testSslClientAuth() throws ClickHouseException {
// com.clickhouse.client.config.ClickHouseDefaultSslContextProvider.getKeyStore(ClickHouseDefaultSslContextProvider.java:105)
ClickHouseNode server = getSecureServer(ClickHouseProtocol.HTTP);
try (ClickHouseClient client = getSecureClient();
- ClickHouseResponse response = client.connect(server).query("select 123").executeAndWait()) {
+ ClickHouseResponse response = client.connect(server)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
+ .query("select 123").executeAndWait()) {
Assert.assertEquals(response.firstRecord().getValue(0).asInteger(), 123);
}
}
- @Test(groups = { "integration" })
- public void testCreateTableAsSelect() throws ClickHouseException {
+ @Test(dataProvider = "connectionProvider", groups = { "integration" })
+ public void testCreateTableAsSelect(HttpConnectionProvider connProvider) throws ClickHouseException {
ClickHouseNode server = getServer();
sendAndWait(server, "drop table if exists test_create_table_as_select");
try (ClickHouseClient client = getClient()) {
- ClickHouseRequest request = client.connect(server);
+ ClickHouseRequest request = client.connect(server)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider);
try (ClickHouseResponse resp = request.write()
.external(ClickHouseExternalTable.builder().name("myExtTable").addColumn("s", "String")
.addColumn("i", "Int32").content(ClickHouseInputStream.of("one,1\ntwo,2"))
@@ -190,16 +216,17 @@ public void testCreateTableAsSelect() throws ClickHouseException {
}
}
- @Test(groups = { "integration" })
- @Override
- public void testMutation() throws ClickHouseException {
+ @Test(dataProvider = "connectionProvider", groups = { "integration" })
+ public void testMutation(HttpConnectionProvider connProvider) throws ClickHouseException {
super.testMutation();
ClickHouseNode server = getServer();
sendAndWait(server, "drop table if exists test_http_mutation",
"create table test_http_mutation(a String, b Nullable(Int64))engine=Memory");
try (ClickHouseClient client = getClient();
- ClickHouseResponse response = client.connect(server).set("send_progress_in_http_headers", 1)
+ ClickHouseResponse response = client.connect(server)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
+ .set("send_progress_in_http_headers", 1)
.query("insert into test_http_mutation select toString(number), number from numbers(1)")
.executeAndWait()) {
ClickHouseResponseSummary summary = response.getSummary();
@@ -207,12 +234,14 @@ public void testMutation() throws ClickHouseException {
}
}
- @Test(groups = { "integration" })
- public void testLogComment() throws ClickHouseException {
+ @Test(dataProvider = "connectionProvider", groups = { "integration" })
+ public void testLogComment(HttpConnectionProvider connProvider) throws ClickHouseException, IOException {
ClickHouseNode server = getServer(ClickHouseProtocol.HTTP);
String uuid = UUID.randomUUID().toString();
try (ClickHouseClient client = ClickHouseClient.newInstance()) {
- ClickHouseRequest request = client.connect(server).format(ClickHouseFormat.RowBinaryWithNamesAndTypes);
+ ClickHouseRequest request = client.connect(server)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
+ .format(ClickHouseFormat.RowBinaryWithNamesAndTypes);
try (ClickHouseResponse resp = request
.query("select version()").executeAndWait()) {
if (!ClickHouseVersion.of(resp.firstRecord().getValue(0).asString()).check("[21.2,)")) {
@@ -244,14 +273,15 @@ public void testLogComment() throws ClickHouseException {
}
}
- @Test(groups = { "integration" })
- public void testPost() throws ClickHouseException {
+ @Test(dataProvider = "connectionProvider", groups = { "integration" })
+ public void testPost(HttpConnectionProvider connProvider) throws ClickHouseException {
ClickHouseNode server = getServer(ClickHouseProtocol.HTTP);
try (ClickHouseClient client = ClickHouseClient.builder()
.defaultCredentials(ClickHouseCredentials.fromUserAndPassword("foo", "bar")).build()) {
// why no detailed error message for this: "select 1，2"
try (ClickHouseResponse resp = client.connect(server).compressServerResponse(false)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
.format(ClickHouseFormat.RowBinaryWithNamesAndTypes)
.query("select 1,2").executeAndWait()) {
int count = 0;
@@ -265,7 +295,9 @@ public void testPost() throws ClickHouseException {
}
// reuse connection
- try (ClickHouseResponse resp = client.connect(server).format(ClickHouseFormat.RowBinaryWithNamesAndTypes)
+ try (ClickHouseResponse resp = client.connect(server)
+ .option(ClickHouseHttpOption.CONNECTION_PROVIDER, connProvider)
+ .format(ClickHouseFormat.RowBinaryWithNamesAndTypes)
.query("select 3,4").executeAndWait()) {
int count = 0;
for (ClickHouseRecord r : resp.records()) {
diff --git a/pom.xml b/pom.xml
index 24c1da1e2..2ee80b6c9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -99,6 +99,7 @@
1.17.5
7.5
+ 5.2
3.0.9
8.0.31
@@ -264,6 +265,11 @@
testng
${testng.version}