Added handling unknown properties in configuration for JDBC. Added filtering out JDBC properties from client ones

Author: chernser

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

@@ -343,6 +343,7 @@ public static Map<String, Object> parseConfigMap(Map<String, String> configMap)
         }
 
         if (!tmpMap.isEmpty()) {
+            tmpMap.remove(ClientConfigProperties.NO_THROW_ON_UNKNOWN_CONFIG);
             String msg = "Unknown and unmapped config properties: " + tmpMap.keySet();
             if (configMap.containsKey(NO_THROW_ON_UNKNOWN_CONFIG)) {
                 LOG.warn(msg);

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

@@ -1,5 +1,6 @@
 package com.clickhouse.jdbc;
 
+import com.clickhouse.client.api.ClientConfigProperties;
 import com.clickhouse.client.api.internal.ServerSettings;
 
 import java.util.Arrays;
@@ -98,4 +99,12 @@ public String getDefaultValue() {
     public List<String> getChoices() {
         return choices;
     }
+
+    public static String serverSetting(String key) {
+        return ClientConfigProperties.serverSetting(key);
+    }
+
+    public static String httpHeader(String key) {
+        return ClientConfigProperties.httpHeader(key);
+    }
 }

jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/JdbcConfiguration.java

@@ -7,6 +7,7 @@
 import com.clickhouse.jdbc.Driver;
 import com.clickhouse.jdbc.DriverProperties;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -22,6 +23,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -57,6 +59,17 @@ public boolean isIgnoreUnsupportedRequests() {
         return isIgnoreUnsupportedRequests;
     }
 
+    private static final Set<String> DRIVER_PROP_KEYS;
+    static {
+
+        ImmutableSet.Builder<String> driverPropertiesMapBuidler = ImmutableSet.builder();
+        for (DriverProperties prop : DriverProperties.values()) {
+            driverPropertiesMapBuidler.add(prop.getKey());
+        }
+
+        DRIVER_PROP_KEYS = driverPropertiesMapBuidler.build();
+    }
+
     /**
      * Parses URL to get property and target host.
      * Properties that are passed in the {@code info} parameter will override that are set in the {@code url}.
@@ -251,7 +264,10 @@ private void initProperties(Map<String, String> urlProperties, Properties provid
             DriverPropertyInfo propertyInfo = new DriverPropertyInfo(prop.getKey(), prop.getValue());
             propertyInfo.description = "(User Defined)";
             propertyInfos.put(prop.getKey(), propertyInfo);
-            clientProperties.put(prop.getKey(), prop.getValue());
+            if (!DRIVER_PROP_KEYS.contains(prop.getKey())) {
+                // filter out driver properties
+                clientProperties.put(prop.getKey(), prop.getValue());
+            }
         }
 
         // Fill list of client properties information, add not specified properties (doesn't affect client properties)

jdbc-v2/src/test/java/com/clickhouse/jdbc/DriverTest.java

@@ -1,17 +1,22 @@
 package com.clickhouse.jdbc;
 
 import com.clickhouse.client.api.ClientConfigProperties;
+import com.clickhouse.client.api.ClientMisconfigurationException;
+import com.clickhouse.client.api.ServerException;
 import org.testng.Assert;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
+import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.DriverPropertyInfo;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
 
+import static org.testng.Assert.assertEquals;
 import static org.testng.AssertJUnit.assertTrue;
 
 
@@ -62,16 +67,16 @@ public void testGetPropertyInfo(String url, Properties props, Map<String, String
             for (DriverPropertyInfo property : properties) {
                 Object expectedValue = checkPropertiesCopy.remove(property.name);
                 if (expectedValue != null) {
-                    Assert.assertEquals(property.value, expectedValue);
+                    assertEquals(property.value, expectedValue);
                 } else {
                     for (DriverProperties driverProp : DriverProperties.values()) {
                         if (driverProp.getKey().equalsIgnoreCase(property.name)) {
-                            Assert.assertEquals(property.value, driverProp.getDefaultValue());
+                            assertEquals(property.value, driverProp.getDefaultValue());
                         }
                     }
                     for (ClientConfigProperties clientProp : ClientConfigProperties.values()) {
                         if (clientProp.getKey().equalsIgnoreCase(property.name)) {
-                            Assert.assertEquals(property.value, clientProp.getDefaultValue());
+                            assertEquals(property.value, clientProp.getDefaultValue());
                         }
                     }
                 }
@@ -107,7 +112,7 @@ public void testGetDriverVersion() {
     @Test(groups = {"integration"}, dataProvider = "testParsingDriverVersionDP")
     public void testParsingDriverVersion(String version, int expectedMajor, int expectedMinor) {
         int[] versions = Driver.parseVersion(version);
-        Assert.assertEquals(versions, new int[] { expectedMajor, expectedMinor });
+        assertEquals(versions, new int[] { expectedMajor, expectedMinor });
     }
 
     @DataProvider(name = "testParsingDriverVersionDP")
@@ -139,7 +144,55 @@ public void testGetParentLogger() {
             driver.getParentLogger();
             Assert.fail("Should not reach here");
         } catch (SQLException e) {
-            Assert.assertEquals(e.getMessage(), "Method not supported");
+            assertEquals(e.getMessage(), "Method not supported");
         }
     }
+
+    @Test(groups = { "integration" })
+    public void testUnknownSettings() throws Exception {
+        Driver driver = new Driver();
+        try {
+            driver.connect(getEndpointString() + "?unknown_setting=1", new Properties());
+            Assert.fail("Exception expected");
+        } catch (SQLException e) {
+            Assert.assertTrue(e.getCause() instanceof ClientMisconfigurationException);
+            Assert.assertTrue(e.getCause().getMessage().contains("unknown_setting"));
+        }
+
+        try {
+            Properties properties = new Properties();
+            properties.put("unknown_setting1", "1");
+            driver.connect(getEndpointString(), properties).close();
+            Assert.fail("Exception expected");
+        } catch (SQLException e) {
+            Assert.assertTrue(e.getCause() instanceof ClientMisconfigurationException);
+            Assert.assertTrue(e.getCause().getMessage().contains("unknown_setting1"));
+        }
+
+        {
+            Properties properties = new Properties();
+            properties.put(DriverProperties.serverSetting("unknown_setting2"), "1");
+            try (Connection connection = getJdbcConnection(properties)) {
+                try {
+                    connection.createStatement().execute("SELECT 1");
+                    Assert.fail("Exception expected");
+                } catch (SQLException e) {
+                    Assert.assertTrue(e.getCause() instanceof ServerException);
+                    assertEquals(((ServerException) e.getCause()).getCode(), ServerException.UNKNOWN_SETTING);
+                }
+            }
+        }
+
+        {
+            Properties properties = new Properties();
+            properties.put(DriverProperties.SECURE_CONNECTION.getKey(), "true");
+            properties.put(DriverProperties.SCHEMA_TERM.getKey(), "catalog");
+            try (Connection connection = getJdbcConnection(properties);
+                 Statement stmt = connection.createStatement()) {
+                //
+            }
+        }
+
+        driver.connect(getEndpointString() + "?unknown_setting=1&" + ClientConfigProperties.NO_THROW_ON_UNKNOWN_CONFIG + "=1", new Properties()).close();
+    }
 }