jdbc

pom.xml

@@ -2,13 +2,13 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <name>elasticsearch-sql2dsl</name>
+    <name>elasticsearch-query-toolkit</name>
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.elasticsearch</groupId>
-    <artifactId>elasticsearch-sql2dsl</artifactId>
+    <artifactId>elasticsearch-query-toolkit</artifactId>
     <version>${elasticsearch.version}</version>
     <packaging>jar</packaging>
-    <description>elasticsearch-sql2dsl</description>
+    <description>elasticsearch-query-toolkit</description>
     <inceptionYear>2016</inceptionYear>
     <licenses>
         <license>
@@ -84,8 +84,8 @@
 
         <dependency>
             <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-            <version>1.7.7</version>
+            <artifactId>slf4j-log4j12</artifactId>
+            <version>1.6.1</version>
         </dependency>
 
         <dependency>

src/main/java/org/elasticsearch/jdbc/AbstractConnection.java

@@ -67,7 +67,7 @@ public abstract class AbstractConnection extends AbstractFeatureNotSupportedConn
 
     @Override
     public boolean getAutoCommit() throws SQLException {
-        return true;
+        return false;
     }
 
 

src/main/java/org/elasticsearch/jdbc/AbstractDriverBasedDataSource.java

@@ -8,10 +8,6 @@ public abstract class AbstractDriverBasedDataSource extends AbstractDataSource {
 
     private String url;
 
-    private String username;
-
-    private String password;
-
     private Properties connectionProperties;
 
     public void setUrl(String url) {
@@ -22,26 +18,6 @@ public abstract class AbstractDriverBasedDataSource extends AbstractDataSource {
         return this.url;
     }
 
-
-    public void setUsername(String username) {
-        this.username = username;
-    }
-
-
-    public String getUsername() {
-        return this.username;
-    }
-
-
-    public void setPassword(String password) {
-        this.password = password;
-    }
-
-    public String getPassword() {
-        return this.password;
-    }
-
-
     public void setConnectionProperties(Properties connectionProperties) {
         this.connectionProperties = connectionProperties;
     }
@@ -51,25 +27,20 @@ public abstract class AbstractDriverBasedDataSource extends AbstractDataSource {
     }
 
     public Connection getConnection() throws SQLException {
-        return getConnectionFromDriver(getUsername(), getPassword());
+        return getConnectionFromDriver();
     }
 
+    @Override
     public Connection getConnection(String username, String password) throws SQLException {
-        return getConnectionFromDriver(username, password);
+        return getConnection();
     }
 
-    protected Connection getConnectionFromDriver(String username, String password) throws SQLException {
+    protected Connection getConnectionFromDriver() throws SQLException {
         Properties mergedProps = new Properties();
         Properties connProps = getConnectionProperties();
         if (connProps != null) {
             mergedProps.putAll(connProps);
         }
-        if (username != null) {
-            mergedProps.setProperty("user", username);
-        }
-        if (password != null) {
-            mergedProps.setProperty("password", password);
-        }
         return getConnectionFromDriver(mergedProps);
     }
 

src/main/java/org/elasticsearch/jdbc/DriverManagerDataSource.java

@@ -15,24 +15,15 @@ public class DriverManagerDataSource extends AbstractDriverBasedDataSource {
         setUrl(url);
     }
 
-
-    public DriverManagerDataSource(String url, String username, String password) {
-        setUrl(url);
-        setUsername(username);
-        setPassword(password);
-    }
-
     public DriverManagerDataSource(String url, Properties conProps) {
         setUrl(url);
         setConnectionProperties(conProps);
     }
 
     @Deprecated
-    public DriverManagerDataSource(String driverClassName, String url, String username, String password) {
+    public DriverManagerDataSource(String driverClassName, String url) {
         setDriverClassName(driverClassName);
         setUrl(url);
-        setUsername(username);
-        setPassword(password);
     }
 
 
@@ -73,8 +64,7 @@ public class DriverManagerDataSource extends AbstractDriverBasedDataSource {
 
     @Override
     protected Connection getConnectionFromDriver(Properties props) throws SQLException {
-        String url = getUrl();
-        return getConnectionFromDriverManager(url, props);
+        return getConnectionFromDriverManager(getUrl(), props);
     }
 
     protected Connection getConnectionFromDriverManager(String url, Properties props) throws SQLException {

src/main/java/org/elasticsearch/jdbc/ElasticDatabaseMetaData.java

@@ -4,6 +4,13 @@ import java.sql.*;
 
 public class ElasticDatabaseMetaData implements DatabaseMetaData {
 
+    private static final String ELASTIC_DRIVER_NAME = "org.elasticsearch.jdbc.ElasticDriver";
+    private static final String ELASTIC_DRIVER_PRODUCT_VERSION = "2.4.4";
+    private static final Integer ELASTIC_DRIVER_PRODUCT_MAJOR_VERSION = 2;
+    private static final Integer ELASTIC_DRIVER_PRODUCT_MINOR_VERSION = 4;
+    private static final String ELASTIC_DRIVER_PRODUCT_NAME = "elasticsearch-query-toolkit";
+
+
     private String url;
 
     public ElasticDatabaseMetaData(String url) {
@@ -57,32 +64,32 @@ public class ElasticDatabaseMetaData implements DatabaseMetaData {
 
     @Override
     public String getDatabaseProductName() throws SQLException {
-        return "elasticsearch_2.4.4";
+        return ELASTIC_DRIVER_PRODUCT_NAME;
     }
 
     @Override
     public String getDatabaseProductVersion() throws SQLException {
-        return "2.4.5";
+        return ELASTIC_DRIVER_PRODUCT_VERSION;
     }
 
     @Override
     public String getDriverName() throws SQLException {
-        return "org.elasticsearch.jdbc.ElasticDriver";
+        return ELASTIC_DRIVER_NAME;
     }
 
     @Override
     public String getDriverVersion() throws SQLException {
-        return "1.0";
+        return ELASTIC_DRIVER_PRODUCT_VERSION;
     }
 
     @Override
     public int getDriverMajorVersion() {
-        return 1;
+        return ELASTIC_DRIVER_PRODUCT_MAJOR_VERSION;
     }
 
     @Override
     public int getDriverMinorVersion() {
-        return 0;
+        return ELASTIC_DRIVER_PRODUCT_MINOR_VERSION;
     }
 
     @Override

src/main/java/org/elasticsearch/jdbc/ElasticDriver.java

@@ -1,9 +1,8 @@
 package org.elasticsearch.jdbc;
 
-import org.elasticsearch.client.transport.TransportClient;
-import org.elasticsearch.jdbc.search.TransportClientProvider;
-import org.elasticsearch.jdbc.search.TransportClientProviderImpl;
-import org.slf4j.LoggerFactory;
+import org.elasticsearch.jdbc.search.ElasticClientProvider;
+import org.elasticsearch.jdbc.search.ElasticClientProxy;
+import org.elasticsearch.jdbc.search.ElasticClientProxyProviderImpl;
 
 import java.sql.*;
 import java.util.Properties;
@@ -11,13 +10,11 @@ import java.util.logging.Logger;
 
 public class ElasticDriver implements Driver {
 
-    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(ElasticDriver.class);
-
     private static final String ELASTIC_SEARCH_DRIVER_PREFIX = "jdbc:elastic:";
 
-    private TransportClient transportClient = null;
+    private ElasticClientProxy elasticClientProxy = null;
 
-    private TransportClientProvider transportClientProvider;
+    private ElasticClientProvider elasticClientProvider;
 
     static {
         try {
@@ -35,15 +32,20 @@ public class ElasticDriver implements Driver {
     @Override
     public Connection connect(String url, Properties info) throws SQLException {
         synchronized (ElasticDriver.class) {
-            if (transportClientProvider == null) {
-                transportClientProvider = new TransportClientProviderImpl();
+            if (elasticClientProxy != null && Boolean.FALSE == elasticClientProxy.isClosed()) {
+                return new ElasticConnection(url, info, elasticClientProxy);
+            }
+
+            if (elasticClientProvider == null) {
+                elasticClientProvider = new ElasticClientProxyProviderImpl();
             }
-            transportClient = transportClientProvider.createTransportClientFromUrl(url);
-            if (transportClient == null) {
-                throw new SQLException(String.format("ElasticDriver.connect] Failed to build transport client for url[%s]", url));
+
+            elasticClientProxy = (ElasticClientProxy) elasticClientProvider.createElasticClientFromUrl(url);
+            if (elasticClientProxy == null || elasticClientProxy.isClosed()) {
+                throw new SQLException(String.format("ElasticDriver.connect] Failed to build elastic client for url[%s]", url));
             }
         }
-        return new ElasticConnection(url, info, transportClient);
+        return new ElasticConnection(url, info, elasticClientProxy);
     }
 
     @Override

src/main/java/org/elasticsearch/jdbc/ElasticSingleConnectionDataSource.java

@@ -2,9 +2,8 @@ package org.elasticsearch.jdbc;
 
 
 import org.elasticsearch.client.Client;
-import org.elasticsearch.jdbc.search.TransportClientProvider;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.elasticsearch.jdbc.search.ElasticClientProvider;
+import org.elasticsearch.utils.Logger;
 
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
@@ -14,9 +13,6 @@ import java.sql.Connection;
 import java.sql.SQLException;
 
 public class ElasticSingleConnectionDataSource extends DriverManagerDataSource implements SmartDataSource {
-
-    private static final Logger logger = LoggerFactory.getLogger(ElasticSingleConnectionDataSource.class);
-
     private boolean suppressClose;
 
     private Connection target;
@@ -25,7 +21,7 @@ public class ElasticSingleConnectionDataSource extends DriverManagerDataSource i
 
     private Client client;
 
-    private TransportClientProvider transportClientProvider;
+    private ElasticClientProvider elasticClientProvider;
 
     private final Object connectionMonitor = new Object();
 
@@ -38,8 +34,8 @@ public class ElasticSingleConnectionDataSource extends DriverManagerDataSource i
         this.suppressClose = suppressClose;
     }
 
-    public void setTransportClientProvider(TransportClientProvider transportClientProvider) {
-        this.transportClientProvider = transportClientProvider;
+    public void setElasticClientProvider(ElasticClientProvider elasticClientProvider) {
+        this.elasticClientProvider = elasticClientProvider;
     }
 
     public void setSuppressClose(boolean suppressClose) {
@@ -92,15 +88,15 @@ public class ElasticSingleConnectionDataSource extends DriverManagerDataSource i
             closeConnection();
 
             try {
-                if (transportClientProvider != null) {
-                    client = transportClientProvider.createTransportClientFromUrl(getUrl());
+                if (elasticClientProvider != null) {
+                    client = elasticClientProvider.createElasticClientFromUrl(getUrl());
                     if (client == null) {
-                        throw new SQLException(String.format("Failed to build transport client for url[%s]", getUrl()));
+                        throw new SQLException(String.format("Failed to build elastic client for url[%s]", getUrl()));
                     }
                     target = new ElasticConnection(getUrl(), null, client);
                 }
                 else {
-                    this.target = getConnectionFromDriver(getUsername(), getPassword());
+                    this.target = getConnectionFromDriver();
                 }
             }
             catch (Exception exp) {
@@ -136,7 +132,7 @@ public class ElasticSingleConnectionDataSource extends DriverManagerDataSource i
                 this.target.close();
             }
             catch (Throwable ex) {
-                logger.warn("Could not close shared JDBC Connection", ex);
+                Logger.warn(this, "Could not close shared JDBC Connection", ex);
             }
         }
 
@@ -145,7 +141,7 @@ public class ElasticSingleConnectionDataSource extends DriverManagerDataSource i
                 client.close();
             }
             catch (Exception ex) {
-                logger.error("Could not close elasticsearch client", ex);
+                Logger.error(this, "Could not close elasticsearch client", ex);
             }
         }
     }

src/main/java/org/elasticsearch/jdbc/exception/BuildElasticClientException.java

@@ -0,0 +1,23 @@
+package org.elasticsearch.jdbc.exception;
+
+
+public class BuildElasticClientException extends RuntimeException {
+    public BuildElasticClientException() {
+    }
+
+    public BuildElasticClientException(String message) {
+        super(message);
+    }
+
+    public BuildElasticClientException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public BuildElasticClientException(Throwable cause) {
+        super(cause);
+    }
+
+    public BuildElasticClientException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

src/main/java/org/elasticsearch/jdbc/search/ElasticClientProvider.java

@@ -0,0 +1,7 @@
+package org.elasticsearch.jdbc.search;
+
+import org.elasticsearch.client.Client;
+
+public interface ElasticClientProvider {
+    Client createElasticClientFromUrl(String url);
+}

src/main/java/org/elasticsearch/jdbc/search/ElasticClientProxy.java

@@ -0,0 +1,7 @@
+package org.elasticsearch.jdbc.search;
+
+import org.elasticsearch.client.Client;
+
+public interface ElasticClientProxy extends Client {
+    boolean isClosed();
+}

src/main/java/org/elasticsearch/jdbc/search/TransportClientProviderImpl.java

@@ -2,47 +2,48 @@ package org.elasticsearch.jdbc.search;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import org.elasticsearch.client.Client;
 import org.elasticsearch.client.transport.TransportClient;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.transport.InetSocketTransportAddress;
+import org.elasticsearch.jdbc.exception.BuildElasticClientException;
 import org.elasticsearch.utils.Constants;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
 import java.net.InetSocketAddress;
 import java.util.List;
 import java.util.Map;
 
-public class TransportClientProviderImpl implements TransportClientProvider {
+public class ElasticClientProxyProviderImpl implements ElasticClientProvider {
     private static final int DEFAULT_ES_PORT = 9300;
-
-    private static final Logger logger = LoggerFactory.getLogger(TransportClientProviderImpl.class);
-
     private static final String ELASTIC_SEARCH_DRIVER_PREFIX = "jdbc:elastic:";
 
-    private final Map<String, TransportClient> clientMap = Maps.newHashMap();
+    private final Map<String, ElasticClientProxy> clientMap = Maps.newHashMap();
 
-    public TransportClientProviderImpl() {
+    public ElasticClientProxyProviderImpl() {
 
     }
 
-    public TransportClient createTransportClientFromUrl(final String url) {
+    public Client createElasticClientFromUrl(final String url) {
         if (clientMap.containsKey(url)) {
             return clientMap.get(url);
         }
 
         try {
-            TransportClient transportClient = internalBuildTransportClient(url);
-            clientMap.put(url, transportClient);
+            ElasticClientProxy elasticClient = internalBuildElasticClient(url);
+            clientMap.put(url, elasticClient);
         }
         catch (Exception ex) {
-            logger.error(String.format("[TransportClientProviderImpl] Failed to build transport client for url[%s]", url), ex);
+            throw new BuildElasticClientException(String.format("Failed to build transport client for url[%s]", url), ex);
         }
 
         return clientMap.get(url);
     }
 
-    private TransportClient internalBuildTransportClient(String url) {
+    private ElasticClientProxy internalBuildElasticClient(String url) {
         String ipUrl = url.substring(ELASTIC_SEARCH_DRIVER_PREFIX.length());
 
         Settings.Builder settingBuilder = Settings.settingsBuilder();
@@ -59,7 +60,6 @@ public class TransportClientProviderImpl implements TransportClientProvider {
         }
 
         List<InetSocketTransportAddress> addressList = Lists.newLinkedList();
-
         String[] connStringList = hostListString.split(Constants.COMMA);
         for (String connStr : connStringList) {
             String[] connArr = connStr.split(Constants.COLON);
@@ -71,8 +71,39 @@ public class TransportClientProviderImpl implements TransportClientProvider {
             }
         }
 
-        return TransportClient.builder().settings(settingBuilder).build()
+        TransportClient transportClient = TransportClient.builder().settings(settingBuilder).build()
                 .addTransportAddresses(addressList.toArray(new InetSocketTransportAddress[addressList.size()]));
 
+        return (ElasticClientProxy) Proxy.newProxyInstance(ElasticClientProxy.class.getClassLoader(),
+                new Class[]{ElasticClientProxy.class}, new CloseClientProxyInvocationHandler(transportClient));
+
     }
+
+
+    private class CloseClientProxyInvocationHandler implements InvocationHandler {
+        private volatile boolean isClosed = false;
+        private Object target;
+
+        public CloseClientProxyInvocationHandler(Client client) {
+            this.target = client;
+        }
+
+        @Override
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            if ("close".equals(method.getName())) {
+                isClosed = true;
+            }
+            else if ("isClosed".equals(method.getName())) {
+                return isClosed;
+            }
+
+            try {
+                return method.invoke(target, args);
+            }
+            catch (InvocationTargetException ex) {
+                throw ex.getTargetException();
+            }
+        }
+    }
+
 }

src/main/java/org/elasticsearch/jdbc/search/JdbcSearchActionExecutor.java

@@ -1,13 +1,10 @@
 package org.elasticsearch.jdbc.search;
 
 import org.elasticsearch.action.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.elasticsearch.utils.Logger;
 
 public class JdbcSearchActionExecutor {
 
-    private static final Logger logger = LoggerFactory.getLogger(JdbcSearchActionExecutor.class);
-
     private static final JdbcSearchActionExecutor JDBC_SEARCH_ACTION_EXECUTOR = new JdbcSearchActionExecutor();
 
     private JdbcSearchActionExecutor() {
@@ -44,13 +41,13 @@ public class JdbcSearchActionExecutor {
         return new ActionListener<Response>() {
             @Override
             public void onResponse(Response response) {
-                logger.debug(String.format("[Search_Request] %s", requestBuilder.toString()));
-                logger.debug(String.format("[Search_Response] %s", response.toString()));
+                Logger.debug(this, String.format("[Search_Request] %s", requestBuilder.toString()));
+                Logger.debug(this, String.format("[Search_Response] %s", response.toString()));
             }
 
             @Override
             public void onFailure(Throwable throwable) {
-                logger.error("Execute search req error!", throwable);
+                Logger.error(this, "Execute search req error!", throwable);
             }
         };
     }

src/main/java/org/elasticsearch/jdbc/search/JdbcSearchResponseResolver.java

@@ -1,5 +1,6 @@
 package org.elasticsearch.jdbc.search;
 
+import com.google.common.base.Function;
 import com.google.common.collect.Lists;
 import com.google.common.reflect.TypeToken;
 import com.google.gson.Gson;
@@ -17,7 +18,7 @@ public class JdbcSearchResponseResolver {
 
     public JdbcSearchResponseResolver(String oriSearchResponseGson) {
         if (StringUtils.isBlank(oriSearchResponseGson)) {
-            throw new IllegalArgumentException("param[oriSearchResponseGson] can not be null");
+            throw new IllegalArgumentException("param[oriSearchResponseGson] can not be blank");
         }
         this.oriSearchResponseGson = oriSearchResponseGson;
     }
@@ -31,9 +32,19 @@ public class JdbcSearchResponseResolver {
         return resolveSearchResponse(clazz, defaultEsDateFormatGson);
     }
 
+    public <T> JdbcSearchResponse<T> resolveSearchResponse(TypeToken<T> typeToken) throws ResolveSearchResponseException {
+        Gson defaultEsDateFormatGson = new GsonBuilder().setDateFormat(Constants.DEFAULT_ES_DATE_FORMAT).create();
+        return resolveSearchResponse(typeToken, defaultEsDateFormatGson);
+    }
+
     public <T> JdbcSearchResponse<T> resolveSearchResponse(Class<T> clazz, String dataPattern) throws ResolveSearchResponseException {
-        Gson defaultEsDateFormatGson = new GsonBuilder().setDateFormat(dataPattern).create();
-        return resolveSearchResponse(clazz, defaultEsDateFormatGson);
+        Gson dateFormatGson = new GsonBuilder().setDateFormat(dataPattern).create();
+        return resolveSearchResponse(clazz, dateFormatGson);
+    }
+
+    public <T> JdbcSearchResponse<T> resolveSearchResponse(TypeToken<T> typeToken, String dataPattern) throws ResolveSearchResponseException {
+        Gson dateFormatGson = new GsonBuilder().setDateFormat(dataPattern).create();
+        return resolveSearchResponse(typeToken, dateFormatGson);
     }
 
     public <T> JdbcSearchResponse<T> resolveSearchResponse(Class<T> clazz, Gson gson) throws ResolveSearchResponseException {
@@ -45,7 +56,51 @@ public class JdbcSearchResponseResolver {
         });
     }
 
+    public <T> JdbcSearchResponse<T> resolveSearchResponse(TypeToken<T> typeToken, Gson gson) throws ResolveSearchResponseException {
+        return resolveSearchResponse(new ResolveStrategy<T>() {
+            @Override
+            public T resolve(String document) {
+                return gson.fromJson(document, typeToken.getType());
+            }
+        });
+    }
+
     public <T> JdbcSearchResponse<T> resolveSearchResponse(ResolveStrategy<T> resolveStrategy) throws ResolveSearchResponseException {
+        JdbcSearchResponse<String> searchRespStrGson = parseSearchResponseGson(oriSearchResponseGson);
+
+        JdbcSearchResponse<T> retJdbcSearchResponse = new JdbcSearchResponse<T>();
+        setBasicPropertyForResponse(retJdbcSearchResponse, searchRespStrGson);
+
+        // resolve query result set
+        List<T> docList = resolveDocumentList(searchRespStrGson.getDocList(), resolveStrategy);
+        retJdbcSearchResponse.setDocList(docList);
+
+        // todo resolve aggregation result set
+
+        return retJdbcSearchResponse;
+    }
+
+    protected <T> List<T> resolveDocumentList(List<String> documentList, ResolveStrategy<T> resolveStrategy) {
+        if (CollectionUtils.isEmpty(documentList)) {
+            return Collections.emptyList();
+        }
+
+        List<T> resolvedDocList = null;
+        try {
+            resolvedDocList = Lists.transform(documentList, new Function<String, T>() {
+                @Override
+                public T apply(String doc) {
+                    return resolveStrategy.resolve(doc);
+                }
+            });
+        }
+        catch (Exception ex) {
+            throw new ResolveSearchResponseException("Failed to resolve doc gson");
+        }
+        return resolvedDocList;
+    }
+
+    protected JdbcSearchResponse<String> parseSearchResponseGson(String searchRespGson) {
         JdbcSearchResponse<String> searchRespStrGson;
         try {
             searchRespStrGson = new Gson().fromJson(oriSearchResponseGson, new TypeToken<JdbcSearchResponse<String>>() {}.getType());
@@ -53,25 +108,15 @@ public class JdbcSearchResponseResolver {
         catch (Exception exp) {
             throw new ResolveSearchResponseException(String.format("Failed to parse responseGson[%s] to JdbcSearchResponse", oriSearchResponseGson));
         }
+        return searchRespStrGson;
+    }
 
-        JdbcSearchResponse<T> jdbcSearchResponse = new JdbcSearchResponse<T>();
-        jdbcSearchResponse.setTotalShards(searchRespStrGson.getTotalShards());
-        jdbcSearchResponse.setTotalHits(searchRespStrGson.getTotalHits());
-        jdbcSearchResponse.setTookInMillis(searchRespStrGson.getTookInMillis());
-        jdbcSearchResponse.setFailedShards(searchRespStrGson.getFailedShards());
-        jdbcSearchResponse.setSuccessfulShards(searchRespStrGson.getSuccessfulShards());
-
-        if (CollectionUtils.isEmpty(searchRespStrGson.getDocList())) {
-            jdbcSearchResponse.setDocList(Collections.emptyList());
-            return jdbcSearchResponse;
-        }
-
-        List<T> docList = Lists.newLinkedList();
-        for (String doc : searchRespStrGson.getDocList()) {
-            docList.add(resolveStrategy.resolve(doc));
-        }
-        jdbcSearchResponse.setDocList(docList);
-        return jdbcSearchResponse;
+    protected <T> void setBasicPropertyForResponse(JdbcSearchResponse<T> targetResponse, JdbcSearchResponse<String> sourceResponse) {
+        targetResponse.setTotalShards(sourceResponse.getTotalShards());
+        targetResponse.setTotalHits(sourceResponse.getTotalHits());
+        targetResponse.setTookInMillis(sourceResponse.getTookInMillis());
+        targetResponse.setFailedShards(sourceResponse.getFailedShards());
+        targetResponse.setSuccessfulShards(sourceResponse.getSuccessfulShards());
     }
 
     public interface ResolveStrategy<T> {

src/main/java/org/elasticsearch/jdbc/search/TransportClientProvider.java

@@ -1,7 +0,0 @@
-package org.elasticsearch.jdbc.search;
-
-import org.elasticsearch.client.transport.TransportClient;
-
-public interface TransportClientProvider {
-    TransportClient createTransportClientFromUrl(String url);
-}

src/main/java/org/elasticsearch/utils/Logger.java

@@ -0,0 +1,82 @@
+package org.elasticsearch.utils;
+
+
+import org.slf4j.LoggerFactory;
+
+public class Logger {
+    public static void warn(Object obj, String message, Throwable e) {
+
+        org.slf4j.Logger log = LoggerFactory.getLogger(obj.getClass().getName());
+        if (log.isWarnEnabled()) {
+            if (e == null) {
+                log.warn(message);
+            }
+            else {
+                log.warn(message, e);
+            }
+        }
+    }
+
+    public static void warn(Object obj, String message) {
+        warn(obj, message, null);
+    }
+
+    public static void error(Object obj, String message) {
+        error(obj.getClass(), message, null);
+    }
+
+    public static void error(Class clz, String message) {
+        error(clz, message, null);
+    }
+
+    public static void error(Object obj, String message, Throwable e) {
+        org.slf4j.Logger log = LoggerFactory.getLogger(obj instanceof Class ? ((Class) obj).getName() : obj.getClass().getName());
+        if (log.isErrorEnabled()) {
+            if (e == null) {
+                log.error(message);
+            }
+            else {
+                log.error(message, e);
+            }
+        }
+    }
+
+    public static void info(Object obj, String message) {
+        info(obj.getClass(), message);
+    }
+
+    public static void info(Class clz, String message) {
+        org.slf4j.Logger log = LoggerFactory.getLogger(clz.getName());
+        if (log.isInfoEnabled()) {
+            log.info(message);
+        }
+    }
+
+    public static void infoAndTrace(Object obj, String message) {
+        infoAndTrace(obj.getClass(), message);
+    }
+
+    public static void infoAndTrace(Class clz, String message) {
+        info(clz, message);
+
+        trace(clz, message);
+    }
+
+    private static void trace(Class clz, String message) {
+        org.slf4j.Logger log = LoggerFactory.getLogger(clz.getName());
+        if (log.isTraceEnabled()) {
+            log.trace(message);
+        }
+    }
+
+    public static void debug(Object obj, String message) {
+        debug(obj.getClass(), message);
+    }
+
+    public static void debug(Class clz, String message) {
+        org.slf4j.Logger log = LoggerFactory.getLogger(clz.getName());
+        if (log.isDebugEnabled()) {
+            log.debug(message);
+        }
+    }
+}