content: /*
   * Copyright 1999-2018 Alibaba Group Holding Ltd.
   *
   * Licensed under the Apache License, Version 2.0 (the "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
   *
   * 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 com.alibaba.druid.mock;
  
  import com.alibaba.druid.util.jdbc.ConnectionBase;
  
  import java.sql.*;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.concurrent.Executor;
  
  public class MockConnection extends ConnectionBase implements Connection {
      // private static final Log LOG = LogFactory.getLog(MockConnection.class);
  
      private boolean closed;
  
      private MockDriver driver;
      private int savepointIdSeed;
      private List<Savepoint> savepoints = new ArrayList<Savepoint>();
  
      private long id;
  
      private final long createdTimeMillis = System.currentTimeMillis();
      private long lastActiveTimeMillis = System.currentTimeMillis();
      private int networkTimeout;
  
      private SQLException error;
  
      private String lastSql;
  
      public MockConnection() {
          this(null, null, null);
      }
  
      public MockConnection(MockDriver driver, String url, Properties connectProperties) {
          super(url, connectProperties);
  
          this.driver = driver;
  
          if (driver != null) {
              this.id = driver.generateConnectionId();
          }
      }
  
      public String getLastSql() {
          return lastSql;
      }
  
      public void setLastSql(String lastSql) {
          this.lastSql = lastSql;
      }
  
      public SQLException getError() {
          return error;
      }
  
      public void setError(SQLException error) {
          this.error = error;
      }
  
      public List<Savepoint> getSavepoints() {
          return savepoints;
      }
  
      public long getLastActiveTimeMillis() {
          return lastActiveTimeMillis;
      }
  
      public void setLastActiveTimeMillis(long lastActiveTimeMillis) {
          this.lastActiveTimeMillis = lastActiveTimeMillis;
      }
  
      public long getCreatedTimeMillis() {
          return createdTimeMillis;
      }
  
      public long getId() {
          return id;
      }
  
      public MockDriver getDriver() {
          return driver;
      }
  
      public void setDriver(MockDriver driver) {
          this.driver = driver;
      }
  
      @SuppressWarnings("unchecked")
      @Override
      public <T> T unwrap(Class<T> iface) throws SQLException {
          if (iface.isInstance(this)) {
              return (T) this;
          }
  
          return null;
      }
  
      @Override
      public boolean isWrapperFor(Class<?> iface) throws SQLException {
          return iface.isInstance(this);
      }
  
      @Override
      public Statement createStatement() throws SQLException {
          checkState();
  
          return createMockStatement();
      }
  
      private MockStatement createMockStatement() {
          if (driver != null) {
              return driver.createMockStatement(this);
          }
          return new MockStatement(this);
      }
  
      @Override
      public PreparedStatement prepareStatement(String sql) throws SQLException {
          checkState();
  
          return createMockPreparedStatement(sql);
      }
  
      @Override
      public CallableStatement prepareCall(String sql) throws SQLException {
          checkState();
  
          return createMockCallableStatement(sql);
      }
  
      @Override
      public String nativeSQL(String sql) throws SQLException {
          checkState();
  
          return sql;
      }
  
      @Override
      public void setAutoCommit(boolean autoCommit) throws SQLException {
          checkState();
  
          super.setAutoCommit(autoCommit);
      }
  
      @Override
      public void commit() throws SQLException {
          checkState();
      }
  
      @Override
      public void rollback() throws SQLException {
          checkState();
  
          this.savepoints.clear();
      }
  
      @Override
      public void close() throws SQLException {
          if (!closed) {
              closed = true;
              if (driver != null) {
                  driver.afterConnectionClose(this);
              }
          }
      }
  
      @Override
      public boolean isClosed() throws SQLException {
          return closed;
      }
  
      @Override
      public DatabaseMetaData getMetaData() throws SQLException {
          return null;
      }
  
      @Override
      public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
          checkState();
  
          MockStatement stmt = createMockStatement();
  
          stmt.setResultSetType(resultSetType);
          stmt.setResultSetConcurrency(resultSetConcurrency);
  
          return stmt;
      }
  
      @Override
      public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
              throws SQLException {
          checkState();
  
          MockPreparedStatement stmt = createMockPreparedStatement(sql);
  
          stmt.setResultSetType(resultSetType);
          stmt.setResultSetConcurrency(resultSetConcurrency);
  
          return stmt;
      }
  
      @Override
      public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
          checkState();
  
          MockCallableStatement stmt = createMockCallableStatement(sql);
  
          stmt.setResultSetType(resultSetType);
          stmt.setResultSetConcurrency(resultSetConcurrency);
  
          return stmt;
      }
  
      @Override
      public Map<String, Class<?>> getTypeMap() throws SQLException {
          return null;
      }
  
      @Override
      public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
      }
  
      @Override
      public Savepoint setSavepoint() throws SQLException {
          checkState();
  
          MockSavepoint savepoint = new MockSavepoint();
          savepoint.setSavepointId(this.savepointIdSeed++);
          this.savepoints.add(savepoint);
  
          return savepoint;
      }
  
      @Override
      public Savepoint setSavepoint(String name) throws SQLException {
          checkState();
  
          MockSavepoint savepoint = new MockSavepoint();
          savepoint.setSavepointId(this.savepointIdSeed++);
          savepoint.setSavepointName(name);
          this.savepoints.add(savepoint);
  
          return savepoint;
      }
  
      public void checkState() throws SQLException {
          if (error != null) {
              throw error;
          }
  
          if (closed) {
              throw new MockConnectionClosedException();
          }
      }
  
      @Override
      public void rollback(Savepoint savepoint) throws SQLException {
          checkState();
  
          int index = this.savepoints.indexOf(savepoint);
          if (index == -1) {
              throw new SQLException("savepoint not contained");
          }
          for (int i = savepoints.size() - 1; i >= index; --i) {
              savepoints.remove(i);
          }
      }
  
      @Override
      public void releaseSavepoint(Savepoint savepoint) throws SQLException {
          checkState();
  
          if (savepoint == null) {
              throw new SQLException("argument is null");
          }
  
          int index = this.savepoints.indexOf(savepoint);
          if (index == -1) {
              throw new SQLException("savepoint not contained");
          }
          savepoints.remove(savepoint);
      }
  
      @Override
      public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
              throws SQLException {
          checkState();
  
          MockStatement stmt = createMockStatement();
  
          stmt.setResultSetType(resultSetType);
          stmt.setResultSetConcurrency(resultSetConcurrency);
          stmt.setResultSetHoldability(resultSetHoldability);
  
          return stmt;
      }
  
      @Override
      public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
                                                int resultSetHoldability) throws SQLException {
          checkState();
  
          MockPreparedStatement stmt = createMockPreparedStatement(sql);
  
          stmt.setResultSetType(resultSetType);
          stmt.setResultSetConcurrency(resultSetConcurrency);
          stmt.setResultSetHoldability(resultSetHoldability);
  
          return stmt;
      }
  
      private MockPreparedStatement createMockPreparedStatement(String sql) {
          if (driver != null) {
              return driver.createMockPreparedStatement(this, sql);
          }
          return new MockPreparedStatement(this, sql);
      }
  
      @Override
      public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
                                           int resultSetHoldability) throws SQLException {
          checkState();
  
          MockCallableStatement stmt = createMockCallableStatement(sql);
  
          stmt.setResultSetType(resultSetType);
          stmt.setResultSetConcurrency(resultSetConcurrency);
          stmt.setResultSetHoldability(resultSetHoldability);
  
          return stmt;
      }
  
      private MockCallableStatement createMockCallableStatement(String sql) {
          if (driver != null) {
              return driver.createMockCallableStatement(this, sql);
          }
          return new MockCallableStatement(this, sql);
      }
  
      @Override
      public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
          checkState();
  
          return createMockPreparedStatement(sql);
      }
  
      @Override
      public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
          checkState();
  
          return createMockPreparedStatement(sql);
      }
  
      @Override
      public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
          checkState();
  
          return createMockPreparedStatement(sql);
      }
  
      @Override
      public Clob createClob() throws SQLException {
          if (driver != null) {
              return driver.createClob(this);
          }
  
          return new MockClob();
      }
  
      @Override
      public Blob createBlob() throws SQLException {
          if (driver != null) {
              return driver.createBlob(this);
          }
  
          return new MockBlob();
      }
  
      @Override
      public NClob createNClob() throws SQLException {
          if (driver != null) {
              return driver.createNClob(this);
          }
  
          return new MockNClob();
      }
  
      @Override
      public SQLXML createSQLXML() throws SQLException {
          if (driver != null) {
              return driver.createSQLXML(this);
          }
  
          return new MockSQLXML();
      }
  
      @Override
      public boolean isValid(int timeout) throws SQLException {
          return false;
      }
  
      @Override
      public void setClientInfo(String name, String value) throws SQLClientInfoException {
      }
  
      @Override
      public void setClientInfo(Properties properties) throws SQLClientInfoException {
      }
  
      @Override
      public String getClientInfo(String name) throws SQLException {
          return null;
      }
  
      @Override
      public Properties getClientInfo() throws SQLException {
          return new Properties();
      }
  
      @Override
      public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
          return new MockArray();
      }
  
      @Override
      public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
          return new MockStruct();
      }
  
      public void setSchema(String schema) throws SQLException {
          throw new SQLFeatureNotSupportedException();
      }
  
      public String getSchema() throws SQLException {
          throw new SQLFeatureNotSupportedException();
      }
  
      public void abort(Executor executor) throws SQLException {
          throw new SQLFeatureNotSupportedException();
      }
  
      public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
          this.networkTimeout = milliseconds;
      }
  
      public int getNetworkTimeout() throws SQLException {
          return networkTimeout;
      }
  
      @Override
      public void setReadOnly(boolean readOnly) throws SQLException {
          checkState();
          super.setReadOnly(readOnly);
      }
  
      public void handleSleep() {
          if (getConnectProperties() != null) {
              Object propertyValue = getConnectProperties().get("executeSleep");
  
              if (propertyValue != null) {
                  long millis = Long.parseLong(propertyValue.toString());
                  try {
                      Thread.sleep(millis);
                  } catch (InterruptedException e) {
                      // skip
                  }
              }
          }
      }
  }
  