improvements:

 - PreparedStatementImpl: getMetaData returns result set metadata using describe query - StatementImpl: maxRows handling - Driver: unload method fixed (DriverManager search driver for unregister by reference equality) - HttpAPIClientHelper: added sslmode option (presents in v1), support to skip ssl validation fixes: - PreparedStatementImpl: ignores question mark (?) in comments, string literals and quoted identifiers - StatementImpl: multiline block comments trim - HttpAPIClientHelper: null pointer exception with unpooled connection (poolControl is null)

Author: oleg-zinovev

client-v2/src/main/java/com/clickhouse/client/api/ClientConfigProperties.java

@@ -92,6 +92,8 @@ public enum ClientConfigProperties {
 
  SSL_KEY_STORE_PASSWORD("key_store_password"),
 
+ SSL_MODE("sslmode", "strict", Arrays.asList("strict", "none")),
+
  SSL_KEY("ssl_key"),
 
  CA_CERTIFICATE("sslrootcert"),

client-v2/src/main/java/com/clickhouse/client/api/internal/HttpAPIClientHelper.java

@@ -58,8 +58,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.net.ssl.KeyManager;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLException;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -74,7 +77,10 @@
 import java.net.URL;
 import java.net.UnknownHostException;
 import java.nio.charset.StandardCharsets;
+import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
 import java.util.Base64;
 import java.util.Collection;
 import java.util.Collections;
@@ -169,6 +175,13 @@ public SSLContext createSSLContext() {
  } catch (SSLException e) {
  throw new ClientMisconfigurationException("Failed to create SSL context from certificates", e);
  }
+ } else if ("none".equals(chConfiguration.get(ClientConfigProperties.SSL_MODE.getKey()))) {
+ try {
+ sslContext = SSLContext.getInstance("TLS");
+ sslContext.init(new KeyManager[0], new TrustManager[]{new TrustAllManager()}, new SecureRandom());
+ } catch (NoSuchAlgorithmException | KeyManagementException e) {
+ throw new ClientException("Failed to create none validating SSL context", e);
+ }
  }
  return sslContext;
  }
@@ -380,7 +393,7 @@ public Exception readError(ClassicHttpResponse httpResponse) {
 
  public ClassicHttpResponse executeRequest(ClickHouseNode server, Map<String, Object> requestConfig, LZ4Factory lz4Factory,
  IOCallback<OutputStream> writeCallback) throws IOException {
- if (timeToPoolVent.get() < System.currentTimeMillis()) {
+ if (poolControl != null && timeToPoolVent.get() < System.currentTimeMillis()) {
  timeToPoolVent.set(System.currentTimeMillis() + POOL_VENT_TIMEOUT);
  poolControl.closeExpired();
  }
@@ -828,4 +841,22 @@ public long getTime() {
  return count > 0 ? runningAverage / count : 0;
  }
  }
+
+ private static final class TrustAllManager implements X509TrustManager {
+
+ @Override
+ public void checkClientTrusted(X509Certificate[] chain, String authType) {
+ // ignore
+ }
+
+ @Override
+ public void checkServerTrusted(X509Certificate[] chain, String authType) {
+ // ignore
+ }
+
+ @Override
+ public X509Certificate[] getAcceptedIssuers() {
+ return new X509Certificate[0];
+ }
+ }
 }

client-v2/src/test/java/com/clickhouse/client/ClientTests.java

@@ -1,6 +1,7 @@
 package com.clickhouse.client;
 
 import com.clickhouse.client.api.Client;
+import com.clickhouse.client.api.ClientConfigProperties;
 import com.clickhouse.client.api.ClientException;
 import com.clickhouse.client.api.enums.Protocol;
 import com.clickhouse.client.api.query.GenericRecord;
@@ -64,6 +65,12 @@ private static Client[] secureClientProvider() throws Exception {
  .setPassword("")
  .setRootCertificate("containers/clickhouse-server/certs/localhost.crt")
  .build(),
+ new Client.Builder()
+ .addEndpoint("https://" + node.getHost() + ":" + node.getPort())
+ .setUsername("default")
+ .setPassword("")
+ .setOption(ClientConfigProperties.SSL_MODE.getKey(), "none")
+ .build(),
  new Client.Builder()
  .addEndpoint(Protocol.HTTP, node.getHost(), node.getPort(), true)
  .setUsername("default")
@@ -108,6 +115,13 @@ public void testPing() {
  }
  }
 
+ @Test
+ public void testPingUnpooled() {
+ try (Client client = newClient().enableConnectionPool(false).build()) {
+ Assert.assertTrue(client.ping());
+ }
+ }
+
  @Test
  public void testPingFailure() {
  try (Client client = new Client.Builder()

jdbc-v2/src/main/java/com/clickhouse/jdbc/Driver.java

@@ -98,15 +98,15 @@ public Driver(DataSourceImpl dataSourceImpl) {
 
  public static void load() {
  try {
- DriverManager.registerDriver(new Driver());
+ DriverManager.registerDriver(DriverHolder.INSTANCE);
  } catch (SQLException e) {
  log.error("Failed to register ClickHouse JDBC driver", e);
  }
  }
 
  public static void unload() {
  try {
- DriverManager.deregisterDriver(new Driver());
+ DriverManager.deregisterDriver(DriverHolder.INSTANCE);
  } catch (SQLException e) {
  log.error("Failed to deregister ClickHouse JDBC driver", e);
  }
@@ -163,4 +163,8 @@ public static String chSettingKey(String key) {
  public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
  throw new SQLFeatureNotSupportedException("Method not supported", ExceptionUtils.SQL_STATE_FEATURE_NOT_SUPPORTED);
  }
+
+ private static final class DriverHolder {
+ private static final Driver INSTANCE = new Driver();
+ }
 }

jdbc-v2/src/main/java/com/clickhouse/jdbc/PreparedStatementImpl.java

@@ -1,5 +1,7 @@
 package com.clickhouse.jdbc;
 
+import com.clickhouse.client.api.metadata.TableSchema;
+import com.clickhouse.data.ClickHouseColumn;
 import com.clickhouse.data.Tuple;
 import com.clickhouse.jdbc.internal.ExceptionUtils;
 import org.slf4j.Logger;
@@ -26,6 +28,7 @@
 import java.sql.SQLFeatureNotSupportedException;
 import java.sql.SQLType;
 import java.sql.SQLXML;
+import java.sql.Statement;
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.sql.Types;
@@ -42,7 +45,6 @@
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collection;
-import java.util.GregorianCalendar;
 import java.util.List;
 import java.util.Map;
 
@@ -58,17 +60,18 @@ public class PreparedStatementImpl extends StatementImpl implements PreparedStat
  private final Calendar defaultCalendar;
 
  String originalSql;
- String [] sqlSegments;
- String [] valueSegments;
- Object [] parameters;
+ String[] sqlSegments;
+ String[] valueSegments;
+ Object[] parameters;
  String insertIntoSQL;
 
  StatementType statementType;
+
  public PreparedStatementImpl(ConnectionImpl connection, String sql) throws SQLException {
  super(connection);
  this.originalSql = sql.trim();
  //Split the sql string into an array of strings around question mark tokens
- this.sqlSegments = originalSql.split("\\?");
+ this.sqlSegments = splitStatement(originalSql);
  this.statementType = parseStatementType(originalSql);
 
  if (statementType == StatementType.INSERT) {
@@ -77,17 +80,11 @@ public PreparedStatementImpl(ConnectionImpl connection, String sql) throws SQLEx
  }
 
  //Create an array of objects to store the parameters
- if (originalSql.contains("?")) {
- int count = originalSql.length() - originalSql.replace("?", "").length();
- this.parameters = new Object[count];
- } else {
- this.parameters = new Object[0];
- }
-
+ this.parameters = new Object[sqlSegments.length - 1];
  this.defaultCalendar = connection.defaultCalendar;
  }
 
- private String compileSql(String []segments) {
+ private String compileSql(String[] segments) {
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < segments.length; i++) {
  sb.append(segments[i]);
@@ -98,6 +95,7 @@ private String compileSql(String []segments) {
  LOG.trace("Compiled SQL: {}", sb);
  return sb.toString();
  }
+
  @Override
  public ResultSet executeQuery() throws SQLException {
  checkClosed();
@@ -305,7 +303,26 @@ public void setArray(int parameterIndex, Array x) throws SQLException {
  @Override
  public ResultSetMetaData getMetaData() throws SQLException {
  checkClosed();
- return null;
+ if (this.currentResultSet != null) {
+ return currentResultSet.getMetaData();
+ } else if (statementType != StatementType.SELECT) {
+ return null;
+ }
+
+ String sql = compileSql(sqlSegments);
+ String describe = String.format("describe (\n%s\n)", sql);
+
+ List<ClickHouseColumn> columns = new ArrayList<>();
+ try (Statement stmt = connection.createStatement()) {
+ try (ResultSet rs = stmt.executeQuery(describe)) {
+ while (rs.next()) {
+ ClickHouseColumn column = ClickHouseColumn.of(rs.getString(1), rs.getString(2));
+ columns.add(column);
+ }
+ }
+ }
+ TableSchema schema = new TableSchema(columns);
+ return new com.clickhouse.jdbc.metadata.ResultSetMetaData(schema);
  }
 
  @Override
@@ -517,14 +534,14 @@ private static String encodeObject(Object x) throws SQLException {
  } else if (x instanceof ZonedDateTime) {
  return encodeObject(((ZonedDateTime) x).toInstant());
  } else if (x instanceof Instant) {
- return "fromUnixTimestamp64Nano(" + (((Instant) x).getEpochSecond() * 1_000_000_000L + ((Instant) x).getNano())+ ")";
+ return "fromUnixTimestamp64Nano(" + (((Instant) x).getEpochSecond() * 1_000_000_000L + ((Instant) x).getNano()) + ")";
  } else if (x instanceof InetAddress) {
  return "'" + ((InetAddress) x).getHostAddress() + "'";
  } else if (x instanceof Array) {
  StringBuilder listString = new StringBuilder();
  listString.append("[");
  int i = 0;
- for (Object item : (Object[])((Array) x).getArray()) {
+ for (Object item : (Object[]) ((Array) x).getArray()) {
  if (i > 0) {
  listString.append(", ");
  }
@@ -592,7 +609,7 @@ private static String encodeObject(Object x) throws SQLException {
  StringBuilder tupleString = new StringBuilder();
  tupleString.append("(");
  Tuple t = (Tuple) x;
- Object [] values = t.getValues();
+ Object[] values = t.getValues();
  int i = 0;
  for (Object item : values) {
  if (i > 0) {
@@ -616,4 +633,70 @@ private static String encodeObject(Object x) throws SQLException {
  private static String escapeString(String x) {
  return x.replace("\\", "\\\\").replace("'", "\\'");//Escape single quotes
  }
+
+ private static String[] splitStatement(String sql) {
+ List<String> segments = new ArrayList<>();
+ char[] chars = sql.toCharArray();
+ int segmentStart = 0;
+ for (int i = 0; i < chars.length; i++) {
+ char c = chars[i];
+ if (c == '\'' || c == '"' || c == '`') {
+ // string literal or identifier
+ i = skip(chars, i + 1, c, true);
+ } else if (c == '/' && lookahead(chars, i) == '*') {
+ // block comment
+ int end = sql.indexOf("*/", i);
+ if (end == -1) {
+ // missing comment end
+ break;
+ }
+ i = end + 1;
+ } else if (c == '#' || (c == '-' && lookahead(chars, i) == '-')) {
+ // line comment
+ i = skip(chars, i + 1, '\n', false);
+ } else if (c == '?') {
+ // question mark
+ segments.add(sql.substring(segmentStart, i));
+ segmentStart = i + 1;
+ }
+ }
+ if (segmentStart < chars.length) {
+ segments.add(sql.substring(segmentStart));
+ } else {
+ // add empty segment in case question mark was last char of sql
+ segments.add("");
+ }
+ return segments.toArray(new String[0]);
+ }
+
+ private static int skip(char[] chars, int from, char until, boolean escape) {
+ for (int i = from; i < chars.length; i++) {
+ char curr = chars[i];
+ if (escape) {
+ char next = lookahead(chars, i);
+ if ((curr == '\\' && (next == '\\' || next == until)) || (curr == until && next == until)) {
+ // should skip:
+ // 1) double \\ (backslash escaped with backslash)
+ // 2) \[until] ([until] char, escaped with backslash)
+ // 3) [until][until] ([until] char, escaped with [until])
+ i++;
+ continue;
+ }
+ }
+
+ if (curr == until) {
+ return i;
+ }
+ }
+ return chars.length;
+ }
+
+ private static char lookahead(char[] chars, int pos) {
+ pos = pos + 1;
+ if (pos >= chars.length) {
+ return '\0';
+ }
+ return chars[pos];
+ }
+
 }

jdbc-v2/src/main/java/com/clickhouse/jdbc/StatementImpl.java

@@ -24,14 +24,15 @@
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
 
 public class StatementImpl implements Statement, JdbcV2Wrapper {
  private static final Logger LOG = LoggerFactory.getLogger(StatementImpl.class);
 
  ConnectionImpl connection;
  private int queryTimeout;
  protected boolean closed;
- private ResultSetImpl currentResultSet;
+ protected ResultSetImpl currentResultSet;
  private OperationMetrics metrics;
  protected List<String> batch;
  private String lastSql;
@@ -70,7 +71,7 @@ protected static StatementType parseStatementType(String sql) {
  return StatementType.OTHER;
  }
 
- trimmedSql = trimmedSql.replaceAll("/\\*.*?\\*/", "").trim(); // remove comments
+ trimmedSql = BLOCK_COMMENT.matcher(trimmedSql).replaceAll("").trim(); // remove comments
  String[] lines = trimmedSql.split("\n");
  for (String line : lines) {
  String trimmedLine = line.trim();
@@ -172,7 +173,10 @@ public ResultSetImpl executeQuery(String sql, QuerySettings settings) throws SQL
  closePreviousResultSet();
 
  QuerySettings mergedSettings = QuerySettings.merge(connection.getDefaultQuerySettings(), settings);
-
+ if (maxRows > 0) {
+ mergedSettings.setOption(ClientConfigProperties.serverSetting(ServerSettings.MAX_RESULT_ROWS), maxRows);
+ mergedSettings.setOption(ClientConfigProperties.serverSetting(ServerSettings.RESULT_OVERFLOW_MODE), "break");
+ }
 
  if (mergedSettings.getQueryId() != null) {
  lastQueryId = mergedSettings.getQueryId();
@@ -627,4 +631,6 @@ public String enquoteNCharLiteral(String val) throws SQLException {
  public String getLastQueryId() {
  return lastQueryId;
  }
+
+ private static final Pattern BLOCK_COMMENT = Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL);
 }