zeppelin-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jongy...@apache.org
Subject [44/49] zeppelin git commit: [ZEPPELIN-3740] Adopt `google-java-format` and `fmt-maven-plugin`
Date Sun, 26 Aug 2018 04:44:27 GMT
http://git-wip-us.apache.org/repos/asf/zeppelin/blob/55f6c91c/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java
----------------------------------------------------------------------
diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java
index 93d2344..228215f 100644
--- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java
+++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java
@@ -5,12 +5,12 @@
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 package org.apache.zeppelin.jdbc;
 
@@ -19,22 +19,6 @@ import static org.apache.commons.lang.StringUtils.isEmpty;
 import static org.apache.commons.lang.StringUtils.isNotEmpty;
 import static org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod.KERBEROS;
 
-import org.apache.commons.dbcp2.ConnectionFactory;
-import org.apache.commons.dbcp2.DriverManagerConnectionFactory;
-import org.apache.commons.dbcp2.PoolableConnectionFactory;
-import org.apache.commons.dbcp2.PoolingDriver;
-import org.apache.commons.lang.StringUtils;
-import org.apache.commons.lang.exception.ExceptionUtils;
-import org.apache.commons.lang.mutable.MutableBoolean;
-import org.apache.commons.pool2.ObjectPool;
-import org.apache.commons.pool2.impl.GenericObjectPool;
-import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.security.UserGroupInformation;
-import org.apache.hadoop.security.alias.CredentialProvider;
-import org.apache.hadoop.security.alias.CredentialProviderFactory;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.IOException;
 import java.security.PrivilegedExceptionAction;
 import java.sql.Connection;
@@ -54,7 +38,19 @@ import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
-
+import org.apache.commons.dbcp2.ConnectionFactory;
+import org.apache.commons.dbcp2.DriverManagerConnectionFactory;
+import org.apache.commons.dbcp2.PoolableConnectionFactory;
+import org.apache.commons.dbcp2.PoolingDriver;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.exception.ExceptionUtils;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.apache.commons.pool2.ObjectPool;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hadoop.security.alias.CredentialProvider;
+import org.apache.hadoop.security.alias.CredentialProviderFactory;
 import org.apache.zeppelin.interpreter.InterpreterContext;
 import org.apache.zeppelin.interpreter.InterpreterException;
 import org.apache.zeppelin.interpreter.InterpreterResult;
@@ -67,28 +63,24 @@ import org.apache.zeppelin.scheduler.Scheduler;
 import org.apache.zeppelin.scheduler.SchedulerFactory;
 import org.apache.zeppelin.user.UserCredentials;
 import org.apache.zeppelin.user.UsernamePassword;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * JDBC interpreter for Zeppelin. This interpreter can also be used for accessing HAWQ,
- * GreenplumDB, MariaDB, MySQL, Postgres and Redshift.
+ * JDBC interpreter for Zeppelin. This interpreter can also be used for accessing HAWQ, GreenplumDB,
+ * MariaDB, MySQL, Postgres and Redshift.
  *
  * <ul>
- * <li>{@code default.url} - JDBC URL to connect to.</li>
- * <li>{@code default.user} - JDBC user name..</li>
- * <li>{@code default.password} - JDBC password..</li>
- * <li>{@code default.driver.name} - JDBC driver name.</li>
- * <li>{@code common.max.result} - Max number of SQL result to display.</li>
+ *   <li>{@code default.url} - JDBC URL to connect to.
+ *   <li>{@code default.user} - JDBC user name..
+ *   <li>{@code default.password} - JDBC password..
+ *   <li>{@code default.driver.name} - JDBC driver name.
+ *   <li>{@code common.max.result} - Max number of SQL result to display.
  * </ul>
  *
- * <p>
- * How to use: <br/>
- * {@code %jdbc.sql} <br/>
- * {@code
- * SELECT store_id, count(*)
- * FROM retail_demo.order_lineitems_pxf
- * GROUP BY store_id;
- * }
- * </p>
+ * <p>How to use: <br>
+ * {@code %jdbc.sql} <br>
+ * {@code SELECT store_id, count(*) FROM retail_demo.order_lineitems_pxf GROUP BY store_id; }
  */
 public class JDBCInterpreter extends KerberosInterpreter {
   private Logger logger = LoggerFactory.getLogger(JDBCInterpreter.class);
@@ -134,7 +126,7 @@ public class JDBCInterpreter extends KerberosInterpreter {
 
   private static final String CONCURRENT_EXECUTION_KEY = "zeppelin.jdbc.concurrent.use";
   private static final String CONCURRENT_EXECUTION_COUNT =
-          "zeppelin.jdbc.concurrent.max_connection";
+      "zeppelin.jdbc.concurrent.max_connection";
   private static final String DBCP_STRING = "jdbc:apache:commons:dbcp:";
 
   private final HashMap<String, Properties> basePropretiesMap;
@@ -196,8 +188,13 @@ public class JDBCInterpreter extends KerberosInterpreter {
       if (!COMMON_KEY.equals(key)) {
         Properties properties = basePropretiesMap.get(key);
         if (!properties.containsKey(DRIVER_KEY) || !properties.containsKey(URL_KEY)) {
-          logger.error("{} will be ignored. {}.{} and {}.{} is mandatory.",
-              key, DRIVER_KEY, key, key, URL_KEY);
+          logger.error(
+              "{} will be ignored. {}.{} and {}.{} is mandatory.",
+              key,
+              DRIVER_KEY,
+              key,
+              key,
+              URL_KEY);
           removeKeySet.add(key);
         }
       }
@@ -222,20 +219,24 @@ public class JDBCInterpreter extends KerberosInterpreter {
   }
 
   private void setMaxLineResults() {
-    if (basePropretiesMap.containsKey(COMMON_KEY) &&
-        basePropretiesMap.get(COMMON_KEY).containsKey(MAX_LINE_KEY)) {
+    if (basePropretiesMap.containsKey(COMMON_KEY)
+        && basePropretiesMap.get(COMMON_KEY).containsKey(MAX_LINE_KEY)) {
       maxLineResults = Integer.valueOf(basePropretiesMap.get(COMMON_KEY).getProperty(MAX_LINE_KEY));
     }
   }
 
-  private SqlCompleter createOrUpdateSqlCompleter(SqlCompleter sqlCompleter,
-      final Connection connection, String propertyKey, final String buf, final int cursor) {
+  private SqlCompleter createOrUpdateSqlCompleter(
+      SqlCompleter sqlCompleter,
+      final Connection connection,
+      String propertyKey,
+      final String buf,
+      final int cursor) {
     String schemaFiltersKey = String.format("%s.%s", propertyKey, COMPLETER_SCHEMA_FILTERS_KEY);
     String sqlCompleterTtlKey = String.format("%s.%s", propertyKey, COMPLETER_TTL_KEY);
     final String schemaFiltersString = getProperty(schemaFiltersKey);
-    int ttlInSeconds = Integer.valueOf(
-        StringUtils.defaultIfEmpty(getProperty(sqlCompleterTtlKey), DEFAULT_COMPLETER_TTL)
-    );
+    int ttlInSeconds =
+        Integer.valueOf(
+            StringUtils.defaultIfEmpty(getProperty(sqlCompleterTtlKey), DEFAULT_COMPLETER_TTL));
     final SqlCompleter completer;
     if (sqlCompleter == null) {
       completer = new SqlCompleter(ttlInSeconds);
@@ -243,12 +244,13 @@ public class JDBCInterpreter extends KerberosInterpreter {
       completer = sqlCompleter;
     }
     ExecutorService executorService = Executors.newFixedThreadPool(1);
-    executorService.execute(new Runnable() {
-      @Override
-      public void run() {
-        completer.createOrUpdateFromConnection(connection, schemaFiltersString, buf, cursor);
-      }
-    });
+    executorService.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            completer.createOrUpdateFromConnection(connection, schemaFiltersString, buf, cursor);
+          }
+        });
 
     executorService.shutdown();
 
@@ -322,13 +324,13 @@ public class JDBCInterpreter extends KerberosInterpreter {
   }
 
   private boolean existAccountInBaseProperty(String propertyKey) {
-    return basePropretiesMap.get(propertyKey).containsKey(USER_KEY) &&
-        !isEmpty((String) basePropretiesMap.get(propertyKey).get(USER_KEY)) &&
-        basePropretiesMap.get(propertyKey).containsKey(PASSWORD_KEY);
+    return basePropretiesMap.get(propertyKey).containsKey(USER_KEY)
+        && !isEmpty((String) basePropretiesMap.get(propertyKey).get(USER_KEY))
+        && basePropretiesMap.get(propertyKey).containsKey(PASSWORD_KEY);
   }
 
-  private UsernamePassword getUsernamePassword(InterpreterContext interpreterContext,
-                                               String replName) {
+  private UsernamePassword getUsernamePassword(
+      InterpreterContext interpreterContext, String replName) {
     UserCredentials uc = interpreterContext.getAuthenticationInfo().getUserCredentials();
     if (uc != null) {
       return uc.getUsernamePassword(replName);
@@ -360,8 +362,8 @@ public class JDBCInterpreter extends KerberosInterpreter {
     String user = interpreterContext.getAuthenticationInfo().getUser();
 
     JDBCUserConfigurations jdbcUserConfigurations = getJDBCConfiguration(user);
-    if (basePropretiesMap.get(propertyKey).containsKey(USER_KEY) &&
-        !basePropretiesMap.get(propertyKey).getProperty(USER_KEY).isEmpty()) {
+    if (basePropretiesMap.get(propertyKey).containsKey(USER_KEY)
+        && !basePropretiesMap.get(propertyKey).getProperty(USER_KEY).isEmpty()) {
       String password = getPassword(basePropretiesMap.get(propertyKey));
       if (!isEmpty(password)) {
         basePropretiesMap.get(propertyKey).setProperty(PASSWORD_KEY, password);
@@ -373,8 +375,8 @@ public class JDBCInterpreter extends KerberosInterpreter {
     }
     jdbcUserConfigurations.cleanUserProperty(propertyKey);
 
-    UsernamePassword usernamePassword = getUsernamePassword(interpreterContext,
-            getEntityName(interpreterContext.getReplName()));
+    UsernamePassword usernamePassword =
+        getUsernamePassword(interpreterContext, getEntityName(interpreterContext.getReplName()));
     if (usernamePassword != null) {
       jdbcUserConfigurations.setUserProperty(propertyKey, usernamePassword);
     } else {
@@ -382,13 +384,13 @@ public class JDBCInterpreter extends KerberosInterpreter {
     }
   }
 
-  private void createConnectionPool(String url, String user, String propertyKey,
-      Properties properties) throws SQLException, ClassNotFoundException {
-    ConnectionFactory connectionFactory =
-            new DriverManagerConnectionFactory(url, properties);
+  private void createConnectionPool(
+      String url, String user, String propertyKey, Properties properties)
+      throws SQLException, ClassNotFoundException {
+    ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url, properties);
 
-    PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(
-            connectionFactory, null);
+    PoolableConnectionFactory poolableConnectionFactory =
+        new PoolableConnectionFactory(connectionFactory, null);
     final String maxConnectionLifetime =
         StringUtils.defaultIfEmpty(getProperty("zeppelin.jdbc.maxConnLifetime"), "-1");
     poolableConnectionFactory.setMaxConnLifetimeMillis(Long.parseLong(maxConnectionLifetime));
@@ -402,8 +404,9 @@ public class JDBCInterpreter extends KerberosInterpreter {
     getJDBCConfiguration(user).saveDBDriverPool(propertyKey, driver);
   }
 
-  private Connection getConnectionFromPool(String url, String user, String propertyKey,
-      Properties properties) throws SQLException, ClassNotFoundException {
+  private Connection getConnectionFromPool(
+      String url, String user, String propertyKey, Properties properties)
+      throws SQLException, ClassNotFoundException {
     String jdbcDriver = getJDBCDriverName(user, propertyKey);
 
     if (!getJDBCConfiguration(user).isConnectionInDBDriverPool(propertyKey)) {
@@ -414,7 +417,7 @@ public class JDBCInterpreter extends KerberosInterpreter {
 
   public Connection getConnection(String propertyKey, InterpreterContext interpreterContext)
       throws ClassNotFoundException, SQLException, InterpreterException, IOException {
-    final String user =  interpreterContext.getAuthenticationInfo().getUser();
+    final String user = interpreterContext.getAuthenticationInfo().getUser();
     Connection connection;
     if (propertyKey == null || basePropretiesMap.get(propertyKey) == null) {
       return null;
@@ -437,8 +440,9 @@ public class JDBCInterpreter extends KerberosInterpreter {
       JDBCSecurityImpl.createSecureConfiguration(getProperties(), authType);
       switch (authType) {
         case KERBEROS:
-          if (user == null || "false".equalsIgnoreCase(
-              getProperty("zeppelin.jdbc.auth.kerberos.proxy.enable"))) {
+          if (user == null
+              || "false"
+                  .equalsIgnoreCase(getProperty("zeppelin.jdbc.auth.kerberos.proxy.enable"))) {
             connection = getConnectionFromPool(connectionUrl, user, propertyKey, properties);
           } else {
             if (basePropretiesMap.get(propertyKey).containsKey("proxy.user.property")) {
@@ -446,8 +450,9 @@ public class JDBCInterpreter extends KerberosInterpreter {
             } else {
               UserGroupInformation ugi = null;
               try {
-                ugi = UserGroupInformation.createProxyUser(
-                    user, UserGroupInformation.getCurrentUser());
+                ugi =
+                    UserGroupInformation.createProxyUser(
+                        user, UserGroupInformation.getCurrentUser());
               } catch (Exception e) {
                 logger.error("Error in getCurrentUser", e);
                 throw new InterpreterException("Error in getCurrentUser", e);
@@ -455,12 +460,14 @@ public class JDBCInterpreter extends KerberosInterpreter {
 
               final String poolKey = propertyKey;
               try {
-                connection = ugi.doAs(new PrivilegedExceptionAction<Connection>() {
-                  @Override
-                  public Connection run() throws Exception {
-                    return getConnectionFromPool(connectionUrl, user, poolKey, properties);
-                  }
-                });
+                connection =
+                    ugi.doAs(
+                        new PrivilegedExceptionAction<Connection>() {
+                          @Override
+                          public Connection run() throws Exception {
+                            return getConnectionFromPool(connectionUrl, user, poolKey, properties);
+                          }
+                        });
               } catch (Exception e) {
                 logger.error("Error in doAs", e);
                 throw new InterpreterException("Error in doAs", e);
@@ -480,21 +487,29 @@ public class JDBCInterpreter extends KerberosInterpreter {
   private String appendProxyUserToURL(String url, String user, String propertyKey) {
     StringBuilder connectionUrl = new StringBuilder(url);
 
-    if (user != null && !user.equals("anonymous") &&
-        basePropretiesMap.get(propertyKey).containsKey("proxy.user.property")) {
+    if (user != null
+        && !user.equals("anonymous")
+        && basePropretiesMap.get(propertyKey).containsKey("proxy.user.property")) {
 
       Integer lastIndexOfUrl = connectionUrl.indexOf("?");
       if (lastIndexOfUrl == -1) {
         lastIndexOfUrl = connectionUrl.length();
       }
       logger.info("Using proxy user as :" + user);
-      logger.info("Using proxy property for user as :" +
-          basePropretiesMap.get(propertyKey).getProperty("proxy.user.property"));
-      connectionUrl.insert(lastIndexOfUrl, ";" +
-          basePropretiesMap.get(propertyKey).getProperty("proxy.user.property") + "=" + user + ";");
+      logger.info(
+          "Using proxy property for user as :"
+              + basePropretiesMap.get(propertyKey).getProperty("proxy.user.property"));
+      connectionUrl.insert(
+          lastIndexOfUrl,
+          ";"
+              + basePropretiesMap.get(propertyKey).getProperty("proxy.user.property")
+              + "="
+              + user
+              + ";");
     } else if (user != null && !user.equals("anonymous") && url.contains("hive")) {
-      logger.warn("User impersonation for hive has changed please refer: http://zeppelin.apache" +
-          ".org/docs/latest/interpreter/jdbc.html#apache-hive");
+      logger.warn(
+          "User impersonation for hive has changed please refer: http://zeppelin.apache"
+              + ".org/docs/latest/interpreter/jdbc.html#apache-hive");
     }
 
     return connectionUrl.toString();
@@ -507,7 +522,8 @@ public class JDBCInterpreter extends KerberosInterpreter {
         && isNotEmpty(properties.getProperty(JDBC_JCEKS_CREDENTIAL_KEY))) {
       try {
         Configuration configuration = new Configuration();
-        configuration.set(CredentialProviderFactory.CREDENTIAL_PROVIDER_PATH,
+        configuration.set(
+            CredentialProviderFactory.CREDENTIAL_PROVIDER_PATH,
             properties.getProperty(JDBC_JCEKS_FILE));
         CredentialProvider provider = CredentialProviderFactory.getProviders(configuration).get(0);
         CredentialProvider.CredentialEntry credEntry =
@@ -515,13 +531,18 @@ public class JDBCInterpreter extends KerberosInterpreter {
         if (credEntry != null) {
           return new String(credEntry.getCredential());
         } else {
-          throw new InterpreterException("Failed to retrieve password from JCEKS from key: "
-              + properties.getProperty(JDBC_JCEKS_CREDENTIAL_KEY));
+          throw new InterpreterException(
+              "Failed to retrieve password from JCEKS from key: "
+                  + properties.getProperty(JDBC_JCEKS_CREDENTIAL_KEY));
         }
       } catch (Exception e) {
-        logger.error("Failed to retrieve password from JCEKS \n" +
-            "For file: " + properties.getProperty(JDBC_JCEKS_FILE) +
-            "\nFor key: " + properties.getProperty(JDBC_JCEKS_CREDENTIAL_KEY), e);
+        logger.error(
+            "Failed to retrieve password from JCEKS \n"
+                + "For file: "
+                + properties.getProperty(JDBC_JCEKS_FILE)
+                + "\nFor key: "
+                + properties.getProperty(JDBC_JCEKS_CREDENTIAL_KEY),
+            e);
         throw e;
       }
     }
@@ -617,7 +638,10 @@ public class JDBCInterpreter extends KerberosInterpreter {
         }
       }
 
-      if (!quoteString && !doubleQuoteString && !multiLineComment && !singleLineComment
+      if (!quoteString
+          && !doubleQuoteString
+          && !multiLineComment
+          && !singleLineComment
           && sql.length() > item + 1) {
         if (character == '-' && sql.charAt(item + 1) == '-') {
           singleLineComment = true;
@@ -626,7 +650,10 @@ public class JDBCInterpreter extends KerberosInterpreter {
         }
       }
 
-      if (character == ';' && !quoteString && !doubleQuoteString && !multiLineComment
+      if (character == ';'
+          && !quoteString
+          && !doubleQuoteString
+          && !multiLineComment
           && !singleLineComment) {
         queries.add(StringUtils.trim(query.toString()));
         query = new StringBuilder();
@@ -656,8 +683,8 @@ public class JDBCInterpreter extends KerberosInterpreter {
     return interpreterResult;
   }
 
-  private InterpreterResult executeSql(String propertyKey, String sql,
-      InterpreterContext interpreterContext) {
+  private InterpreterResult executeSql(
+      String propertyKey, String sql, InterpreterContext interpreterContext) {
     Connection connection = null;
     Statement statement;
     ResultSet resultSet = null;
@@ -712,7 +739,7 @@ public class JDBCInterpreter extends KerberosInterpreter {
 
           String statementPrecode =
               getProperty(String.format(STATEMENT_PRECODE_KEY_TEMPLATE, propertyKey));
-          
+
           if (StringUtils.isNotBlank(statementPrecode)) {
             statement.execute(statementPrecode);
           }
@@ -723,37 +750,42 @@ public class JDBCInterpreter extends KerberosInterpreter {
             resultSet = statement.getResultSet();
 
             // Regards that the command is DDL.
-            if (isDDLCommand(statement.getUpdateCount(),
-                resultSet.getMetaData().getColumnCount())) {
-              interpreterResult.add(InterpreterResult.Type.TEXT,
-                  "Query executed successfully.");
+            if (isDDLCommand(
+                statement.getUpdateCount(), resultSet.getMetaData().getColumnCount())) {
+              interpreterResult.add(InterpreterResult.Type.TEXT, "Query executed successfully.");
             } else {
               MutableBoolean isComplete = new MutableBoolean(true);
-              String results = getResults(resultSet,
-                  !containsIgnoreCase(sqlToExecute, EXPLAIN_PREDICATE), isComplete);
+              String results =
+                  getResults(
+                      resultSet, !containsIgnoreCase(sqlToExecute, EXPLAIN_PREDICATE), isComplete);
               interpreterResult.add(results);
               if (!isComplete.booleanValue()) {
-                interpreterResult.add(ResultMessages.getExceedsLimitRowsMessage(getMaxResult(),
-                    String.format("%s.%s", COMMON_KEY, MAX_LINE_KEY)));
+                interpreterResult.add(
+                    ResultMessages.getExceedsLimitRowsMessage(
+                        getMaxResult(), String.format("%s.%s", COMMON_KEY, MAX_LINE_KEY)));
               }
             }
           } else {
             // Response contains either an update count or there are no results.
             int updateCount = statement.getUpdateCount();
-            interpreterResult.add(InterpreterResult.Type.TEXT,
-                "Query executed successfully. Affected rows : " +
-                    updateCount);
+            interpreterResult.add(
+                InterpreterResult.Type.TEXT,
+                "Query executed successfully. Affected rows : " + updateCount);
           }
         } finally {
           if (resultSet != null) {
             try {
               resultSet.close();
-            } catch (SQLException e) { /*ignored*/ }
+            } catch (SQLException e) {
+              /*ignored*/
+            }
           }
           if (statement != null) {
             try {
               statement.close();
-            } catch (SQLException e) { /*ignored*/ }
+            } catch (SQLException e) {
+              /*ignored*/
+            }
           }
         }
       }
@@ -763,23 +795,23 @@ public class JDBCInterpreter extends KerberosInterpreter {
       interpreterResult.add(errorMsg);
       return new InterpreterResult(Code.ERROR, interpreterResult.message());
     } finally {
-      //In case user ran an insert/update/upsert statement
+      // In case user ran an insert/update/upsert statement
       if (connection != null) {
         try {
           if (!connection.getAutoCommit()) {
             connection.commit();
           }
           connection.close();
-        } catch (SQLException e) { /*ignored*/ }
+        } catch (SQLException e) {
+          /*ignored*/
+        }
       }
       getJDBCConfiguration(user).removeStatement(paragraphId);
     }
     return interpreterResult;
   }
 
-  /**
-   * For %table response replace Tab and Newline characters from the content.
-   */
+  /** For %table response replace Tab and Newline characters from the content. */
   private String replaceReservedChars(String str) {
     if (str == null) {
       return EMPTY_COLUMN_VALUE;
@@ -789,8 +821,10 @@ public class JDBCInterpreter extends KerberosInterpreter {
 
   @Override
   public InterpreterResult interpret(String originalCmd, InterpreterContext contextInterpreter) {
-    String cmd = Boolean.parseBoolean(getProperty("zeppelin.jdbc.interpolation")) ?
-            interpolate(originalCmd, contextInterpreter.getResourcePool()) : originalCmd;
+    String cmd =
+        Boolean.parseBoolean(getProperty("zeppelin.jdbc.interpolation"))
+            ? interpolate(originalCmd, contextInterpreter.getResourcePool())
+            : originalCmd;
     logger.debug("Run SQL command '{}'", cmd);
     String propertyKey = getPropertyKey(contextInterpreter);
     cmd = cmd.trim();
@@ -803,7 +837,7 @@ public class JDBCInterpreter extends KerberosInterpreter {
     logger.info("Cancel current query statement.");
     String paragraphId = context.getParagraphId();
     JDBCUserConfigurations jdbcUserConfigurations =
-            getJDBCConfiguration(context.getAuthenticationInfo().getUser());
+        getJDBCConfiguration(context.getAuthenticationInfo().getUser());
     try {
       jdbcUserConfigurations.cancelStatement(paragraphId);
     } catch (SQLException e) {
@@ -839,15 +873,15 @@ public class JDBCInterpreter extends KerberosInterpreter {
   @Override
   public Scheduler getScheduler() {
     String schedulerName = JDBCInterpreter.class.getName() + this.hashCode();
-    return isConcurrentExecution() ?
-            SchedulerFactory.singleton().createOrGetParallelScheduler(schedulerName,
-                getMaxConcurrentConnection())
-            : SchedulerFactory.singleton().createOrGetFIFOScheduler(schedulerName);
+    return isConcurrentExecution()
+        ? SchedulerFactory.singleton()
+            .createOrGetParallelScheduler(schedulerName, getMaxConcurrentConnection())
+        : SchedulerFactory.singleton().createOrGetFIFOScheduler(schedulerName);
   }
 
   @Override
-  public List<InterpreterCompletion> completion(String buf, int cursor,
-      InterpreterContext interpreterContext) throws InterpreterException {
+  public List<InterpreterCompletion> completion(
+      String buf, int cursor, InterpreterContext interpreterContext) throws InterpreterException {
     List<InterpreterCompletion> candidates = new ArrayList<>();
     String propertyKey = getPropertyKey(interpreterContext);
     String sqlCompleterKey =

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/55f6c91c/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCUserConfigurations.java
----------------------------------------------------------------------
diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCUserConfigurations.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCUserConfigurations.java
index 4eac9fc..e584c06 100644
--- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCUserConfigurations.java
+++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCUserConfigurations.java
@@ -5,28 +5,24 @@
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 package org.apache.zeppelin.jdbc;
 
-import org.apache.commons.dbcp2.PoolingDriver;
-
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
-
+import org.apache.commons.dbcp2.PoolingDriver;
 import org.apache.zeppelin.user.UsernamePassword;
 
-/**
- * UserConfigurations for JDBC impersonation.
- */
+/** UserConfigurations for JDBC impersonation. */
 public class JDBCUserConfigurations {
   private final Map<String, Statement> paragraphIdStatementMap;
   private final Map<String, PoolingDriver> poolingDriverMap;
@@ -87,6 +83,7 @@ public class JDBCUserConfigurations {
     poolingDriverMap.put(key, driver);
     isSuccessful.put(key, false);
   }
+
   public PoolingDriver removeDBDriverPool(String key) throws SQLException {
     isSuccessful.remove(key);
     return poolingDriverMap.remove(key);

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/55f6c91c/jdbc/src/main/java/org/apache/zeppelin/jdbc/SqlCompleter.java
----------------------------------------------------------------------
diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/SqlCompleter.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/SqlCompleter.java
index 9f52ecb..0f7f01e 100644
--- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/SqlCompleter.java
+++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/SqlCompleter.java
@@ -4,11 +4,6 @@ package org.apache.zeppelin.jdbc;
  * This source file is based on code taken from SQLLine 1.0.2 See SQLLine notice in LICENSE
  */
 
-import org.apache.commons.lang.StringUtils;
-import org.apache.commons.lang.math.NumberUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -26,54 +21,47 @@ import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.TreeSet;
 import java.util.regex.Pattern;
-
 import jline.console.completer.ArgumentCompleter.ArgumentList;
 import jline.console.completer.ArgumentCompleter.WhitespaceArgumentDelimiter;
-
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.math.NumberUtils;
 import org.apache.zeppelin.completer.CachedCompleter;
 import org.apache.zeppelin.completer.CompletionType;
 import org.apache.zeppelin.completer.StringsCompleter;
 import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-/**
- * SQL auto complete functionality for the JdbcInterpreter.
- */
+/** SQL auto complete functionality for the JdbcInterpreter. */
 public class SqlCompleter {
   private static Logger logger = LoggerFactory.getLogger(SqlCompleter.class);
 
-  /**
-   * Delimiter that can split SQL statement in keyword list.
-   */
-  private WhitespaceArgumentDelimiter sqlDelimiter = new WhitespaceArgumentDelimiter() {
+  /** Delimiter that can split SQL statement in keyword list. */
+  private WhitespaceArgumentDelimiter sqlDelimiter =
+      new WhitespaceArgumentDelimiter() {
 
-    private Pattern pattern = Pattern.compile(",");
+        private Pattern pattern = Pattern.compile(",");
 
-    @Override
-    public boolean isDelimiterChar(CharSequence buffer, int pos) {
-      return pattern.matcher("" + buffer.charAt(pos)).matches()
+        @Override
+        public boolean isDelimiterChar(CharSequence buffer, int pos) {
+          return pattern.matcher("" + buffer.charAt(pos)).matches()
               || super.isDelimiterChar(buffer, pos);
-    }
-  };
+        }
+      };
 
-  /**
-   * Schema completer.
-   */
+  /** Schema completer. */
   private CachedCompleter schemasCompleter;
 
-  /**
-   * Contain different completer with table list for every schema name.
-   */
+  /** Contain different completer with table list for every schema name. */
   private Map<String, CachedCompleter> tablesCompleters = new HashMap<>();
 
   /**
-   * Contains different completer with column list for every table name
-   * Table names store as schema_name.table_name.
+   * Contains different completer with column list for every table name Table names store as
+   * schema_name.table_name.
    */
   private Map<String, CachedCompleter> columnsCompleters = new HashMap<>();
 
-  /**
-   * Completer for sql keywords.
-   */
+  /** Completer for sql keywords. */
   private CachedCompleter keywordCompleter;
 
   private int ttlInSeconds;
@@ -99,7 +87,11 @@ public class SqlCompleter {
       argumentPosition = argumentList.getArgumentPosition();
     }
 
-    int complete = completeName(cursorArgument, argumentPosition, candidates,
+    int complete =
+        completeName(
+            cursorArgument,
+            argumentPosition,
+            candidates,
             findAliasesInSQL(argumentList.getArguments()));
 
     logger.debug("complete:" + complete + ", size:" + candidates.size());
@@ -110,10 +102,9 @@ public class SqlCompleter {
    * Return list of schema names within the database.
    *
    * @param meta metadata from connection to database
-   * @param schemaFilters a schema name patterns; must match the schema name
-   *        as it is stored in the database; "" retrieves those without a schema;
-   *        <code>null</code> means that the schema name should not be used to narrow
-   *        the search; supports '%'; for example "prod_v_%"
+   * @param schemaFilters a schema name patterns; must match the schema name as it is stored in the
+   *     database; "" retrieves those without a schema; <code>null</code> means that the schema name
+   *     should not be used to narrow the search; supports '%'; for example "prod_v_%"
    * @return set of all schema names in the database
    */
   private static Set<String> getSchemaNames(DatabaseMetaData meta, List<String> schemaFilters) {
@@ -146,10 +137,9 @@ public class SqlCompleter {
    * Return list of catalog names within the database.
    *
    * @param meta metadata from connection to database
-   * @param schemaFilters a catalog name patterns; must match the catalog name
-   *        as it is stored in the database; "" retrieves those without a catalog;
-   *        <code>null</code> means that the schema name should not be used to narrow
-   *        the search; supports '%'; for example "prod_v_%"
+   * @param schemaFilters a catalog name patterns; must match the catalog name as it is stored in
+   *     the database; "" retrieves those without a catalog; <code>null</code> means that the schema
+   *     name should not be used to narrow the search; supports '%'; for example "prod_v_%"
    * @return set of all catalog names in the database
    */
   private static Set<String> getCatalogNames(DatabaseMetaData meta, List<String> schemaFilters) {
@@ -175,8 +165,14 @@ public class SqlCompleter {
   }
 
   private static void fillTableNames(String schema, DatabaseMetaData meta, Set<String> tables) {
-    try (ResultSet tbls = meta.getTables(schema, schema, "%",
-        new String[]{"TABLE", "VIEW", "ALIAS", "SYNONYM", "GLOBAL TEMPORARY", "LOCAL TEMPORARY"})) {
+    try (ResultSet tbls =
+        meta.getTables(
+            schema,
+            schema,
+            "%",
+            new String[] {
+              "TABLE", "VIEW", "ALIAS", "SYNONYM", "GLOBAL TEMPORARY", "LOCAL TEMPORARY"
+            })) {
       while (tbls.next()) {
         String table = tbls.getString("TABLE_NAME");
         tables.add(table);
@@ -192,11 +188,11 @@ public class SqlCompleter {
    * @param schema name of a scheme
    * @param table name of a table
    * @param meta meta metadata from connection to database
-   * @param columns function fills this set, for every table name adds set
-   *        of columns within the table; table name is in format schema_name.table_name
+   * @param columns function fills this set, for every table name adds set of columns within the
+   *     table; table name is in format schema_name.table_name
    */
-  private static void fillColumnNames(String schema, String table, DatabaseMetaData meta,
-      Set<String> columns) {
+  private static void fillColumnNames(
+      String schema, String table, DatabaseMetaData meta, Set<String> columns) {
     try (ResultSet cols = meta.getColumns(schema, schema, table, "%")) {
       while (cols.next()) {
         String column = cols.getString("COLUMN_NAME");
@@ -207,31 +203,34 @@ public class SqlCompleter {
     }
   }
 
-  public static Set<String> getSqlKeywordsCompletions(DatabaseMetaData meta) throws IOException,
-          SQLException {
+  public static Set<String> getSqlKeywordsCompletions(DatabaseMetaData meta)
+      throws IOException, SQLException {
     // Add the default SQL completions
     String keywords =
-            new BufferedReader(new InputStreamReader(
-                    SqlCompleter.class.getResourceAsStream("/ansi.sql.keywords"))).readLine();
+        new BufferedReader(
+                new InputStreamReader(SqlCompleter.class.getResourceAsStream("/ansi.sql.keywords")))
+            .readLine();
 
     Set<String> completions = new TreeSet<>();
 
     if (null != meta) {
       // Add the driver specific SQL completions
       String driverSpecificKeywords =
-              "/" + meta.getDriverName().replace(" ", "-").toLowerCase() + "-sql.keywords";
+          "/" + meta.getDriverName().replace(" ", "-").toLowerCase() + "-sql.keywords";
       logger.info("JDBC DriverName:" + driverSpecificKeywords);
       try {
         if (SqlCompleter.class.getResource(driverSpecificKeywords) != null) {
           String driverKeywords =
-                  new BufferedReader(new InputStreamReader(
+              new BufferedReader(
+                      new InputStreamReader(
                           SqlCompleter.class.getResourceAsStream(driverSpecificKeywords)))
-                          .readLine();
+                  .readLine();
           keywords += "," + driverKeywords.toUpperCase();
         }
       } catch (Exception e) {
-        logger.debug("fail to get driver specific SQL completions for " +
-                driverSpecificKeywords + " : " + e, e);
+        logger.debug(
+            "fail to get driver specific SQL completions for " + driverSpecificKeywords + " : " + e,
+            e);
       }
 
       // Add the keywords from the current JDBC connection
@@ -277,11 +276,11 @@ public class SqlCompleter {
    * Initializes all local completers from database connection.
    *
    * @param connection database connection
-   * @param schemaFiltersString a comma separated schema name patterns, supports '%'  symbol;
-   *        for example "prod_v_%,prod_t_%"
+   * @param schemaFiltersString a comma separated schema name patterns, supports '%' symbol; for
+   *     example "prod_v_%,prod_t_%"
    */
-  public void createOrUpdateFromConnection(Connection connection, String schemaFiltersString,
-      String buffer, int cursor) {
+  public void createOrUpdateFromConnection(
+      Connection connection, String schemaFiltersString, String buffer, int cursor) {
     try (Connection c = connection) {
       if (schemaFiltersString == null) {
         schemaFiltersString = StringUtils.EMPTY;
@@ -297,14 +296,16 @@ public class SqlCompleter {
 
       if (c != null) {
         DatabaseMetaData databaseMetaData = c.getMetaData();
-        if (keywordCompleter == null || keywordCompleter.getCompleter() == null
+        if (keywordCompleter == null
+            || keywordCompleter.getCompleter() == null
             || keywordCompleter.isExpired()) {
           keywords = getSqlKeywordsCompletions(databaseMetaData);
           initKeywords(keywords);
         }
-        if (cursorArgument.needLoadSchemas() &&
-            (schemasCompleter == null || schemasCompleter.getCompleter() == null
-            || schemasCompleter.isExpired())) {
+        if (cursorArgument.needLoadSchemas()
+            && (schemasCompleter == null
+                || schemasCompleter.getCompleter() == null
+                || schemasCompleter.isExpired())) {
           schemas = getSchemaNames(databaseMetaData, schemaFilters);
           catalogs = getCatalogNames(databaseMetaData, schemaFilters);
 
@@ -316,8 +317,8 @@ public class SqlCompleter {
         }
 
         CachedCompleter tablesCompleter = tablesCompleters.get(cursorArgument.getSchema());
-        if (cursorArgument.needLoadTables() &&
-            (tablesCompleter == null || tablesCompleter.isExpired())) {
+        if (cursorArgument.needLoadTables()
+            && (tablesCompleter == null || tablesCompleter.isExpired())) {
           fillTableNames(cursorArgument.getSchema(), databaseMetaData, tables);
           initTables(cursorArgument.getSchema(), tables);
         }
@@ -326,15 +327,21 @@ public class SqlCompleter {
             String.format("%s.%s", cursorArgument.getSchema(), cursorArgument.getTable());
         CachedCompleter columnsCompleter = columnsCompleters.get(schemaTable);
 
-        if (cursorArgument.needLoadColumns() &&
-            (columnsCompleter == null || columnsCompleter.isExpired())) {
-          fillColumnNames(cursorArgument.getSchema(), cursorArgument.getTable(), databaseMetaData,
-              columns);
+        if (cursorArgument.needLoadColumns()
+            && (columnsCompleter == null || columnsCompleter.isExpired())) {
+          fillColumnNames(
+              cursorArgument.getSchema(), cursorArgument.getTable(), databaseMetaData, columns);
           initColumns(schemaTable, columns);
         }
 
-        logger.info("Completer initialized with " + schemas.size() + " schemas, " +
-            columns.size() + " tables and " + keywords.size() + " keywords");
+        logger.info(
+            "Completer initialized with "
+                + schemas.size()
+                + " schemas, "
+                + columns.size()
+                + " tables and "
+                + keywords.size()
+                + " keywords");
       }
 
     } catch (SQLException | IOException e) {
@@ -350,22 +357,22 @@ public class SqlCompleter {
 
   public void initSchemas(Set<String> schemas) {
     if (schemas != null && !schemas.isEmpty()) {
-      schemasCompleter = new CachedCompleter(
-          new StringsCompleter(new TreeSet<>(schemas)), ttlInSeconds);
+      schemasCompleter =
+          new CachedCompleter(new StringsCompleter(new TreeSet<>(schemas)), ttlInSeconds);
     }
   }
 
   public void initTables(String schema, Set<String> tables) {
     if (tables != null && !tables.isEmpty()) {
-      tablesCompleters.put(schema, new CachedCompleter(
-          new StringsCompleter(new TreeSet<>(tables)), ttlInSeconds));
+      tablesCompleters.put(
+          schema, new CachedCompleter(new StringsCompleter(new TreeSet<>(tables)), ttlInSeconds));
     }
   }
 
   public void initColumns(String schemaTable, Set<String> columns) {
     if (columns != null && !columns.isEmpty()) {
-      columnsCompleters.put(schemaTable,
-          new CachedCompleter(new StringsCompleter(columns), ttlInSeconds));
+      columnsCompleters.put(
+          schemaTable, new CachedCompleter(new StringsCompleter(columns), ttlInSeconds));
     }
   }
 
@@ -378,8 +385,8 @@ public class SqlCompleter {
   public Map<String, String> findAliasesInSQL(String[] sqlArguments) {
     Map<String, String> res = new HashMap<>();
     for (int i = 0; i < sqlArguments.length - 1; i++) {
-      if (columnsCompleters.keySet().contains(sqlArguments[i]) &&
-              sqlArguments[i + 1].matches("[a-zA-Z]+")) {
+      if (columnsCompleters.keySet().contains(sqlArguments[i])
+          && sqlArguments[i + 1].matches("[a-zA-Z]+")) {
         res.put(sqlArguments[i + 1], sqlArguments[i]);
       }
     }
@@ -409,8 +416,8 @@ public class SqlCompleter {
    *
    * @return -1 in case of no candidates found, 0 otherwise
    */
-  private int completeTable(String schema, String buffer, int cursor,
-                            List<CharSequence> candidates) {
+  private int completeTable(
+      String schema, String buffer, int cursor, List<CharSequence> candidates) {
     // Wrong schema
     if (schema == null || !tablesCompleters.containsKey(schema)) {
       return -1;
@@ -424,26 +431,31 @@ public class SqlCompleter {
    *
    * @return -1 in case of no candidates found, 0 otherwise
    */
-  private int completeColumn(String schema, String table, String buffer, int cursor,
-                             List<CharSequence> candidates) {
+  private int completeColumn(
+      String schema, String table, String buffer, int cursor, List<CharSequence> candidates) {
     // Wrong schema or wrong table
     if (schema == null || table == null || !columnsCompleters.containsKey(schema + "." + table)) {
       return -1;
     } else {
-      return columnsCompleters.get(schema + "." + table).getCompleter()
+      return columnsCompleters
+          .get(schema + "." + table)
+          .getCompleter()
           .complete(buffer, cursor, candidates);
     }
   }
 
   /**
-   * Complete buffer with a single name. Function will decide what it is:
-   * a schema, a table of a column or a keyword
+   * Complete buffer with a single name. Function will decide what it is: a schema, a table of a
+   * column or a keyword
    *
    * @param aliases for every alias contains table name in format schema_name.table_name
    * @return -1 in case of no candidates found, 0 otherwise
    */
-  public int completeName(String buffer, int cursor, List<InterpreterCompletion> candidates,
-                          Map<String, String> aliases) {
+  public int completeName(
+      String buffer,
+      int cursor,
+      List<InterpreterCompletion> candidates,
+      Map<String, String> aliases) {
     CursorArgument cursorArgument = parseCursorArgument(buffer, cursor);
 
     // find schema and table name if they are
@@ -451,40 +463,42 @@ public class SqlCompleter {
     String table;
     String column;
 
-    if (cursorArgument.getSchema() == null) {             // process all
+    if (cursorArgument.getSchema() == null) { // process all
       List<CharSequence> keywordsCandidates = new ArrayList();
       List<CharSequence> schemaCandidates = new ArrayList<>();
       int keywordsRes = completeKeyword(buffer, cursor, keywordsCandidates);
       int schemaRes = completeSchema(buffer, cursor, schemaCandidates);
       addCompletions(candidates, keywordsCandidates, CompletionType.keyword.name());
       addCompletions(candidates, schemaCandidates, CompletionType.schema.name());
-      return NumberUtils.max(new int[]{keywordsRes, schemaRes});
+      return NumberUtils.max(new int[] {keywordsRes, schemaRes});
     } else {
       schema = cursorArgument.getSchema();
-      if (aliases.containsKey(schema)) {  // process alias case
+      if (aliases.containsKey(schema)) { // process alias case
         String alias = aliases.get(schema);
         int pointPos = alias.indexOf('.');
         schema = alias.substring(0, pointPos);
         table = alias.substring(pointPos + 1);
         column = cursorArgument.getColumn();
         List<CharSequence> columnCandidates = new ArrayList();
-        int columnRes = completeColumn(schema, table, column, cursorArgument.getCursorPosition(),
-            columnCandidates);
+        int columnRes =
+            completeColumn(
+                schema, table, column, cursorArgument.getCursorPosition(), columnCandidates);
         addCompletions(candidates, columnCandidates, CompletionType.column.name());
         // process schema.table case
       } else if (cursorArgument.getTable() != null && cursorArgument.getColumn() == null) {
         List<CharSequence> tableCandidates = new ArrayList();
         table = cursorArgument.getTable();
-        int tableRes = completeTable(schema, table, cursorArgument.getCursorPosition(),
-            tableCandidates);
+        int tableRes =
+            completeTable(schema, table, cursorArgument.getCursorPosition(), tableCandidates);
         addCompletions(candidates, tableCandidates, CompletionType.table.name());
         return tableRes;
       } else {
         List<CharSequence> columnCandidates = new ArrayList();
         table = cursorArgument.getTable();
         column = cursorArgument.getColumn();
-        int columnRes = completeColumn(schema, table, column, cursorArgument.getCursorPosition(),
-            columnCandidates);
+        int columnRes =
+            completeColumn(
+                schema, table, column, cursorArgument.getCursorPosition(), columnCandidates);
         addCompletions(candidates, columnCandidates, CompletionType.column.name());
       }
     }
@@ -497,11 +511,13 @@ public class SqlCompleter {
     return this.sqlDelimiter;
   }
 
-  private void addCompletions(List<InterpreterCompletion> interpreterCompletions,
-      List<CharSequence> candidates, String meta) {
+  private void addCompletions(
+      List<InterpreterCompletion> interpreterCompletions,
+      List<CharSequence> candidates,
+      String meta) {
     for (CharSequence candidate : candidates) {
-      interpreterCompletions.add(new InterpreterCompletion(candidate.toString(),
-          candidate.toString(), meta));
+      interpreterCompletions.add(
+          new InterpreterCompletion(candidate.toString(), candidate.toString(), meta));
     }
   }
 

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/55f6c91c/jdbc/src/main/java/org/apache/zeppelin/jdbc/security/JDBCSecurityImpl.java
----------------------------------------------------------------------
diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/security/JDBCSecurityImpl.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/security/JDBCSecurityImpl.java
index b093ab2..22f4703 100644
--- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/security/JDBCSecurityImpl.java
+++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/security/JDBCSecurityImpl.java
@@ -19,31 +19,29 @@ package org.apache.zeppelin.jdbc.security;
 import static org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod.KERBEROS;
 import static org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod.SIMPLE;
 
+import java.io.IOException;
+import java.util.Properties;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.security.UserGroupInformation;
 import org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.util.Properties;
-
-/**
- * Created for org.apache.zeppelin.jdbc.security on 09/07/16.
- */
+/** Created for org.apache.zeppelin.jdbc.security on 09/07/16. */
 public class JDBCSecurityImpl {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(JDBCSecurityImpl.class);
 
-  /***
+  /**
+   * *
+   *
    * @param properties
    */
-  public static void createSecureConfiguration(Properties properties,
-      AuthenticationMethod authType) {
+  public static void createSecureConfiguration(
+      Properties properties, AuthenticationMethod authType) {
     switch (authType) {
       case KERBEROS:
-        Configuration conf = new
-            org.apache.hadoop.conf.Configuration();
+        Configuration conf = new org.apache.hadoop.conf.Configuration();
         conf.set("hadoop.security.authentication", KERBEROS.toString());
         UserGroupInformation.setConfiguration(conf);
         try {
@@ -57,12 +55,13 @@ public class JDBCSecurityImpl {
                 properties.getProperty("zeppelin.jdbc.principal"),
                 properties.getProperty("zeppelin.jdbc.keytab.location"));
           } else {
-            LOGGER.info("The user has already logged in using Keytab and principal, " +
-                "no action required");
+            LOGGER.info(
+                "The user has already logged in using Keytab and principal, "
+                    + "no action required");
           }
         } catch (IOException e) {
-          LOGGER.error("Failed to get either keytab location or principal name in the " +
-              "interpreter", e);
+          LOGGER.error(
+              "Failed to get either keytab location or principal name in the " + "interpreter", e);
         }
     }
   }
@@ -70,11 +69,14 @@ public class JDBCSecurityImpl {
   public static AuthenticationMethod getAuthtype(Properties properties) {
     AuthenticationMethod authType;
     try {
-      authType = AuthenticationMethod.valueOf(properties.getProperty("zeppelin.jdbc.auth.type")
-          .trim().toUpperCase());
+      authType =
+          AuthenticationMethod.valueOf(
+              properties.getProperty("zeppelin.jdbc.auth.type").trim().toUpperCase());
     } catch (Exception e) {
-      LOGGER.error(String.format("Invalid auth.type detected with value %s, defaulting " +
-          "auth.type to SIMPLE", properties.getProperty("zeppelin.jdbc.auth.type")));
+      LOGGER.error(
+          String.format(
+              "Invalid auth.type detected with value %s, defaulting " + "auth.type to SIMPLE",
+              properties.getProperty("zeppelin.jdbc.auth.type")));
       authType = SIMPLE;
     }
     return authType;

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/55f6c91c/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterInterpolationTest.java
----------------------------------------------------------------------
diff --git a/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterInterpolationTest.java b/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterInterpolationTest.java
index d55f9fe..d602f95 100644
--- a/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterInterpolationTest.java
+++ b/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterInterpolationTest.java
@@ -5,24 +5,19 @@
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 package org.apache.zeppelin.jdbc;
 
-import com.mockrunner.jdbc.BasicJDBCTestCaseAdapter;
-import org.apache.zeppelin.interpreter.InterpreterContext;
-import org.apache.zeppelin.interpreter.InterpreterResult;
-import org.apache.zeppelin.resource.LocalResourcePool;
-import org.apache.zeppelin.resource.ResourcePool;
-import org.apache.zeppelin.user.AuthenticationInfo;
-import org.junit.Before;
-import org.junit.Test;
+import static java.lang.String.format;
+import static org.junit.Assert.assertEquals;
 
+import com.mockrunner.jdbc.BasicJDBCTestCaseAdapter;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -30,13 +25,15 @@ import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.Statement;
 import java.util.Properties;
+import org.apache.zeppelin.interpreter.InterpreterContext;
+import org.apache.zeppelin.interpreter.InterpreterResult;
+import org.apache.zeppelin.resource.LocalResourcePool;
+import org.apache.zeppelin.resource.ResourcePool;
+import org.apache.zeppelin.user.AuthenticationInfo;
+import org.junit.Before;
+import org.junit.Test;
 
-import static java.lang.String.format;
-import static org.junit.Assert.assertEquals;
-
-/**
- * JDBC interpreter Z-variable interpolation unit tests.
- */
+/** JDBC interpreter Z-variable interpolation unit tests. */
 public class JDBCInterpreterInterpolationTest extends BasicJDBCTestCaseAdapter {
 
   private static String jdbcConnection;
@@ -58,22 +55,24 @@ public class JDBCInterpreterInterpolationTest extends BasicJDBCTestCaseAdapter {
     Connection connection = DriverManager.getConnection(getJdbcConnection());
     Statement statement = connection.createStatement();
     statement.execute(
-          "DROP TABLE IF EXISTS test_table; " +
-          "CREATE TABLE test_table(id varchar(255), name varchar(255));");
+        "DROP TABLE IF EXISTS test_table; "
+            + "CREATE TABLE test_table(id varchar(255), name varchar(255));");
 
     Statement insertStatement = connection.createStatement();
-    insertStatement.execute("insert into test_table(id, name) values " +
-                "('pro', 'processor')," +
-                "('mem', 'memory')," +
-                "('key', 'keyboard')," +
-                "('mou', 'mouse');");
+    insertStatement.execute(
+        "insert into test_table(id, name) values "
+            + "('pro', 'processor'),"
+            + "('mem', 'memory'),"
+            + "('key', 'keyboard'),"
+            + "('mou', 'mouse');");
     resourcePool = new LocalResourcePool("JdbcInterpolationTest");
 
-    interpreterContext = InterpreterContext.builder()
-        .setParagraphId("paragraph_1")
-        .setAuthenticationInfo(new AuthenticationInfo("testUser"))
-        .setResourcePool(resourcePool)
-        .build();
+    interpreterContext =
+        InterpreterContext.builder()
+            .setParagraphId("paragraph_1")
+            .setAuthenticationInfo(new AuthenticationInfo("testUser"))
+            .setResourcePool(resourcePool)
+            .build();
   }
 
   @Test
@@ -110,8 +109,7 @@ public class JDBCInterpreterInterpolationTest extends BasicJDBCTestCaseAdapter {
     assertEquals(InterpreterResult.Code.SUCCESS, interpreterResult.code());
     assertEquals(InterpreterResult.Type.TABLE, interpreterResult.message().get(0).getType());
     assertEquals(1, interpreterResult.message().size());
-    assertEquals("ID\tNAME\nmem\tmemory\n",
-            interpreterResult.message().get(0).getData());
+    assertEquals("ID\tNAME\nmem\tmemory\n", interpreterResult.message().get(0).getData());
   }
 
   @Test
@@ -149,8 +147,7 @@ public class JDBCInterpreterInterpolationTest extends BasicJDBCTestCaseAdapter {
     assertEquals(InterpreterResult.Code.SUCCESS, interpreterResult.code());
     assertEquals(InterpreterResult.Type.TABLE, interpreterResult.message().get(0).getType());
     assertEquals(1, interpreterResult.message().size());
-    assertEquals("ID\tNAME\nkey\tkeyboard\n",
-            interpreterResult.message().get(0).getData());
+    assertEquals("ID\tNAME\nkey\tkeyboard\n", interpreterResult.message().get(0).getData());
   }
 
   @Test
@@ -177,8 +174,7 @@ public class JDBCInterpreterInterpolationTest extends BasicJDBCTestCaseAdapter {
     assertEquals(InterpreterResult.Code.SUCCESS, interpreterResult.code());
     assertEquals(InterpreterResult.Type.TABLE, interpreterResult.message().get(0).getType());
     assertEquals(1, interpreterResult.message().size());
-    assertEquals("ID\tNAME\nkey\tkeyboard\nmou\tmouse\n", 
-                 interpreterResult.message().get(0).getData());
+    assertEquals(
+        "ID\tNAME\nkey\tkeyboard\nmou\tmouse\n", interpreterResult.message().get(0).getData());
   }
-
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/55f6c91c/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterTest.java
----------------------------------------------------------------------
diff --git a/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterTest.java b/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterTest.java
index 62f6550..f66e2dd 100644
--- a/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterTest.java
+++ b/jdbc/src/test/java/org/apache/zeppelin/jdbc/JDBCInterpreterTest.java
@@ -5,36 +5,31 @@
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 package org.apache.zeppelin.jdbc;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
 import static java.lang.String.format;
-
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.COMMON_MAX_LINE;
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_DRIVER;
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_PASSWORD;
+import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_PRECODE;
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_STATEMENT_PRECODE;
-import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_USER;
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_URL;
-import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_PRECODE;
+import static org.apache.zeppelin.jdbc.JDBCInterpreter.DEFAULT_USER;
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.PRECODE_KEY_TEMPLATE;
-
-import org.junit.Before;
-import org.junit.Test;
 import static org.apache.zeppelin.jdbc.JDBCInterpreter.STATEMENT_PRECODE_KEY_TEMPLATE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
-
+import com.mockrunner.jdbc.BasicJDBCTestCaseAdapter;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -47,9 +42,6 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
-
-import com.mockrunner.jdbc.BasicJDBCTestCaseAdapter;
-
 import org.apache.zeppelin.completer.CompletionType;
 import org.apache.zeppelin.interpreter.InterpreterContext;
 import org.apache.zeppelin.interpreter.InterpreterException;
@@ -61,10 +53,10 @@ import org.apache.zeppelin.scheduler.Scheduler;
 import org.apache.zeppelin.user.AuthenticationInfo;
 import org.apache.zeppelin.user.UserCredentials;
 import org.apache.zeppelin.user.UsernamePassword;
+import org.junit.Before;
+import org.junit.Test;
 
-/**
- * JDBC interpreter unit tests.
- */
+/** JDBC interpreter unit tests. */
 public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
   static String jdbcConnection;
   InterpreterContext interpreterContext;
@@ -95,40 +87,36 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     Connection connection = DriverManager.getConnection(getJdbcConnection());
     Statement statement = connection.createStatement();
     statement.execute(
-        "DROP TABLE IF EXISTS test_table; " +
-        "CREATE TABLE test_table(id varchar(255), name varchar(255));");
+        "DROP TABLE IF EXISTS test_table; "
+            + "CREATE TABLE test_table(id varchar(255), name varchar(255));");
 
-    PreparedStatement insertStatement = connection.prepareStatement(
+    PreparedStatement insertStatement =
+        connection.prepareStatement(
             "insert into test_table(id, name) values ('a', 'a_name'),('b', 'b_name'),('c', ?);");
     insertStatement.setString(1, null);
     insertStatement.execute();
-    interpreterContext = InterpreterContext.builder()
-        .setAuthenticationInfo(new AuthenticationInfo("testUser"))
-        .build();
+    interpreterContext =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(new AuthenticationInfo("testUser"))
+            .build();
   }
 
-
   @Test
   public void testForParsePropertyKey() {
     JDBCInterpreter t = new JDBCInterpreter(new Properties());
     Map<String, String> localProperties = new HashMap<>();
-    InterpreterContext interpreterContext = InterpreterContext.builder()
-        .setLocalProperties(localProperties)
-        .build();
+    InterpreterContext interpreterContext =
+        InterpreterContext.builder().setLocalProperties(localProperties).build();
     assertEquals(JDBCInterpreter.DEFAULT_KEY, t.getPropertyKey(interpreterContext));
 
     localProperties = new HashMap<>();
     localProperties.put("db", "mysql");
-    interpreterContext = InterpreterContext.builder()
-        .setLocalProperties(localProperties)
-        .build();
+    interpreterContext = InterpreterContext.builder().setLocalProperties(localProperties).build();
     assertEquals("mysql", t.getPropertyKey(interpreterContext));
 
     localProperties = new HashMap<>();
     localProperties.put("hive", "hive");
-    interpreterContext = InterpreterContext.builder()
-        .setLocalProperties(localProperties)
-        .build();
+    interpreterContext = InterpreterContext.builder().setLocalProperties(localProperties).build();
     assertEquals("hive", t.getPropertyKey(interpreterContext));
   }
 
@@ -147,10 +135,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     String sqlQuery = "select * from test_table";
     Map<String, String> localProperties = new HashMap<>();
     localProperties.put("db", "fake");
-    InterpreterContext context = InterpreterContext.builder()
-        .setAuthenticationInfo(new AuthenticationInfo("testUser"))
-        .setLocalProperties(localProperties)
-        .build();
+    InterpreterContext context =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(new AuthenticationInfo("testUser"))
+            .setLocalProperties(localProperties)
+            .build();
     InterpreterResult interpreterResult = t.interpret(sqlQuery, context);
 
     // if prefix not found return ERROR and Prefix not found.
@@ -192,17 +181,17 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
   @Test
   public void testSplitSqlQuery() throws SQLException, IOException {
-    String sqlQuery = "insert into test_table(id, name) values ('a', ';\"');" +
-        "select * from test_table;" +
-        "select * from test_table WHERE ID = \";'\";" +
-        "select * from test_table WHERE ID = ';';" +
-        "select '\n', ';';" +
-        "select replace('A\\;B', '\\', 'text');" +
-        "select '\\', ';';" +
-        "select '''', ';';" +
-        "select /*+ scan */ * from test_table;" +
-        "--singleLineComment\nselect * from test_table";
-
+    String sqlQuery =
+        "insert into test_table(id, name) values ('a', ';\"');"
+            + "select * from test_table;"
+            + "select * from test_table WHERE ID = \";'\";"
+            + "select * from test_table WHERE ID = ';';"
+            + "select '\n', ';';"
+            + "select replace('A\\;B', '\\', 'text');"
+            + "select '\\', ';';"
+            + "select '''', ';';"
+            + "select /*+ scan */ * from test_table;"
+            + "--singleLineComment\nselect * from test_table";
 
     Properties properties = new Properties();
     JDBCInterpreter t = new JDBCInterpreter(properties);
@@ -223,10 +212,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
   @Test
   public void testQueryWithEscapedCharacters() throws SQLException, IOException {
-    String sqlQuery = "select '\\n', ';';" +
-        "select replace('A\\;B', '\\', 'text');" +
-        "select '\\', ';';" +
-        "select '''', ';'";
+    String sqlQuery =
+        "select '\\n', ';';"
+            + "select replace('A\\;B', '\\', 'text');"
+            + "select '\\', ';';"
+            + "select '''', ';'";
 
     Properties properties = new Properties();
     properties.setProperty("common.max_count", "1000");
@@ -265,15 +255,14 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     JDBCInterpreter t = new JDBCInterpreter(properties);
     t.open();
 
-    String sqlQuery = "select * from test_table;" +
-        "select * from test_table WHERE ID = ';';";
+    String sqlQuery = "select * from test_table;" + "select * from test_table WHERE ID = ';';";
     InterpreterResult interpreterResult = t.interpret(sqlQuery, interpreterContext);
     assertEquals(InterpreterResult.Code.SUCCESS, interpreterResult.code());
     assertEquals(2, interpreterResult.message().size());
 
     assertEquals(InterpreterResult.Type.TABLE, interpreterResult.message().get(0).getType());
-    assertEquals("ID\tNAME\na\ta_name\nb\tb_name\nc\tnull\n",
-            interpreterResult.message().get(0).getData());
+    assertEquals(
+        "ID\tNAME\na\ta_name\nb\tb_name\nc\tnull\n", interpreterResult.message().get(0).getData());
 
     assertEquals(InterpreterResult.Type.TABLE, interpreterResult.message().get(1).getType());
     assertEquals("ID\tNAME\n", interpreterResult.message().get(1).getData());
@@ -291,15 +280,14 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     JDBCInterpreter t = new JDBCInterpreter(properties);
     t.open();
 
-    String sqlQuery = "select * from test_table;" +
-        "select * from test_table WHERE ID = ';';";
+    String sqlQuery = "select * from test_table;" + "select * from test_table WHERE ID = ';';";
     InterpreterResult interpreterResult = t.interpret(sqlQuery, interpreterContext);
     assertEquals(InterpreterResult.Code.SUCCESS, interpreterResult.code());
     assertEquals(1, interpreterResult.message().size());
 
     assertEquals(InterpreterResult.Type.TABLE, interpreterResult.message().get(0).getType());
-    assertEquals("ID\tNAME\na\ta_name\nb\tb_name\nc\tnull\n",
-            interpreterResult.message().get(0).getData());
+    assertEquals(
+        "ID\tNAME\na\ta_name\nb\tb_name\nc\tnull\n", interpreterResult.message().get(0).getData());
   }
 
   @Test
@@ -323,7 +311,6 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     assertEquals("ID\tNAME\nc\tnull\n", interpreterResult.message().get(0).getData());
   }
 
-
   @Test
   public void testSelectQueryMaxResult() throws SQLException, IOException {
     Properties properties = new Properties();
@@ -384,11 +371,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
     jdbcInterpreter.interpret("", interpreterContext);
 
-    List<InterpreterCompletion> completionList = jdbcInterpreter.completion("sel", 3,
-            interpreterContext);
+    List<InterpreterCompletion> completionList =
+        jdbcInterpreter.completion("sel", 3, interpreterContext);
 
-    InterpreterCompletion correctCompletionKeyword = new InterpreterCompletion("select", "select",
-            CompletionType.keyword.name());
+    InterpreterCompletion correctCompletionKeyword =
+        new InterpreterCompletion("select", "select", CompletionType.keyword.name());
 
     assertEquals(1, completionList.size());
     assertEquals(true, completionList.contains(correctCompletionKeyword));
@@ -409,8 +396,8 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     return properties;
   }
 
-  private AuthenticationInfo getUserAuth(String user, String entityName, String dbUser,
-      String dbPassword) {
+  private AuthenticationInfo getUserAuth(
+      String user, String entityName, String dbUser, String dbPassword) {
     UserCredentials userCredentials = new UserCredentials();
     if (entityName != null && dbUser != null && dbPassword != null) {
       UsernamePassword up = new UsernamePassword(dbUser, dbPassword);
@@ -440,10 +427,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
     // user1 runs jdbc1
     jdbc1.open();
-    InterpreterContext ctx1 = InterpreterContext.builder()
-        .setAuthenticationInfo(user1Credential)
-        .setReplName("jdbc1")
-        .build();
+    InterpreterContext ctx1 =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(user1Credential)
+            .setReplName("jdbc1")
+            .build();
     jdbc1.interpret("", ctx1);
 
     JDBCUserConfigurations user1JDBC1Conf = jdbc1.getJDBCConfiguration("user1");
@@ -453,10 +441,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
     // user1 runs jdbc2
     jdbc2.open();
-    InterpreterContext ctx2 = InterpreterContext.builder()
-        .setAuthenticationInfo(user1Credential)
-        .setReplName("jdbc2")
-        .build();
+    InterpreterContext ctx2 =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(user1Credential)
+            .setReplName("jdbc2")
+            .build();
     jdbc2.interpret("", ctx2);
 
     JDBCUserConfigurations user1JDBC2Conf = jdbc2.getJDBCConfiguration("user1");
@@ -466,10 +455,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
     // user2 runs jdbc1
     jdbc1.open();
-    InterpreterContext ctx3 = InterpreterContext.builder()
-        .setAuthenticationInfo(user2Credential)
-        .setReplName("jdbc1")
-        .build();
+    InterpreterContext ctx3 =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(user2Credential)
+            .setReplName("jdbc1")
+            .build();
     jdbc1.interpret("", ctx3);
 
     JDBCUserConfigurations user2JDBC1Conf = jdbc1.getJDBCConfiguration("user2");
@@ -479,10 +469,11 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
 
     // user2 runs jdbc2
     jdbc2.open();
-    InterpreterContext ctx4 = InterpreterContext.builder()
-        .setAuthenticationInfo(user2Credential)
-        .setReplName("jdbc2")
-        .build();
+    InterpreterContext ctx4 =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(user2Credential)
+            .setReplName("jdbc2")
+            .build();
     jdbc2.interpret("", ctx4);
 
     JDBCUserConfigurations user2JDBC2Conf = jdbc2.getJDBCConfiguration("user2");
@@ -498,8 +489,9 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     properties.setProperty("default.url", getJdbcConnection());
     properties.setProperty("default.user", "");
     properties.setProperty("default.password", "");
-    properties.setProperty(DEFAULT_PRECODE,
-            "create table test_precode (id int); insert into test_precode values (1);");
+    properties.setProperty(
+        DEFAULT_PRECODE,
+        "create table test_precode (id int); insert into test_precode values (1);");
     JDBCInterpreter jdbcInterpreter = new JDBCInterpreter(properties);
     jdbcInterpreter.open();
     jdbcInterpreter.executePrecode(interpreterContext);
@@ -541,17 +533,19 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     properties.setProperty("anotherPrefix.url", getJdbcConnection());
     properties.setProperty("anotherPrefix.user", "");
     properties.setProperty("anotherPrefix.password", "");
-    properties.setProperty(String.format(PRECODE_KEY_TEMPLATE, "anotherPrefix"),
-            "create table test_precode_2 (id int); insert into test_precode_2 values (2);");
+    properties.setProperty(
+        String.format(PRECODE_KEY_TEMPLATE, "anotherPrefix"),
+        "create table test_precode_2 (id int); insert into test_precode_2 values (2);");
     JDBCInterpreter jdbcInterpreter = new JDBCInterpreter(properties);
     jdbcInterpreter.open();
 
     Map<String, String> localProperties = new HashMap<>();
     localProperties.put("db", "anotherPrefix");
-    InterpreterContext context = InterpreterContext.builder()
-        .setAuthenticationInfo(new AuthenticationInfo("testUser"))
-        .setLocalProperties(localProperties)
-        .build();
+    InterpreterContext context =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(new AuthenticationInfo("testUser"))
+            .setLocalProperties(localProperties)
+            .build();
     jdbcInterpreter.executePrecode(context);
 
     String sqlQuery = "select * from test_precode_2";
@@ -609,17 +603,19 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     properties.setProperty("anotherPrefix.url", getJdbcConnection());
     properties.setProperty("anotherPrefix.user", "");
     properties.setProperty("anotherPrefix.password", "");
-    properties.setProperty(String.format(STATEMENT_PRECODE_KEY_TEMPLATE, "anotherPrefix"),
-            "set @v='statementAnotherPrefix'");
+    properties.setProperty(
+        String.format(STATEMENT_PRECODE_KEY_TEMPLATE, "anotherPrefix"),
+        "set @v='statementAnotherPrefix'");
     JDBCInterpreter jdbcInterpreter = new JDBCInterpreter(properties);
     jdbcInterpreter.open();
 
     Map<String, String> localProperties = new HashMap<>();
     localProperties.put("db", "anotherPrefix");
-    InterpreterContext context = InterpreterContext.builder()
-        .setAuthenticationInfo(new AuthenticationInfo("testUser"))
-        .setLocalProperties(localProperties)
-        .build();
+    InterpreterContext context =
+        InterpreterContext.builder()
+            .setAuthenticationInfo(new AuthenticationInfo("testUser"))
+            .setLocalProperties(localProperties)
+            .build();
 
     String sqlQuery = "select @v";
 
@@ -643,16 +639,17 @@ public class JDBCInterpreterTest extends BasicJDBCTestCaseAdapter {
     JDBCInterpreter t = new JDBCInterpreter(properties);
     t.open();
 
-    String sqlQuery = "/* ; */\n" +
-        "-- /* comment\n" +
-        "--select * from test_table\n" +
-        "select * from test_table; /* some comment ; */\n" +
-        "/*\n" +
-        "select * from test_table;\n" +
-        "*/\n" +
-        "-- a ; b\n" +
-        "select * from test_table WHERE ID = ';--';\n" +
-        "select * from test_table WHERE ID = '/*' -- test";
+    String sqlQuery =
+        "/* ; */\n"
+            + "-- /* comment\n"
+            + "--select * from test_table\n"
+            + "select * from test_table; /* some comment ; */\n"
+            + "/*\n"
+            + "select * from test_table;\n"
+            + "*/\n"
+            + "-- a ; b\n"
+            + "select * from test_table WHERE ID = ';--';\n"
+            + "select * from test_table WHERE ID = '/*' -- test";
 
     InterpreterResult interpreterResult = t.interpret(sqlQuery, interpreterContext);
     assertEquals(InterpreterResult.Code.SUCCESS, interpreterResult.code());


Mime
View raw message