From e46178831af1107d3a167ff6ba94a57199b03919 Mon Sep 17 00:00:00 2001 From: wenshao Date: Thu, 3 May 2018 14:04:23 +0800 Subject: [PATCH] improved DruidDataSource executeStatistic. --- .../druid/pool/DruidAbstractDataSource.java | 212 +++++++++++------- .../alibaba/druid/pool/DruidDataSource.java | 87 +++---- .../pool/DruidPooledPreparedStatement.java | 6 +- .../druid/pool/DruidPooledStatement.java | 81 ++++++- .../ast/statement/SQLExplainStatement.java | 3 - .../ast/statement/MySqlExplainStatement.java | 6 +- .../stat/DruidDataSourceStatManager.java | 11 +- .../druid/stat/JdbcDataSourceStat.java | 3 +- .../support/http/resources/datasource.html | 17 +- .../support/http/resources/js/lang.js | 2 +- .../wall/mysql/MySqlWallTest151_update.java | 26 +++ .../oracle/select/OracleSelectTest124.java | 49 ++++ 12 files changed, 352 insertions(+), 151 deletions(-) create mode 100644 src/test/java/com/alibaba/druid/bvt/filter/wall/mysql/MySqlWallTest151_update.java create mode 100644 src/test/java/com/alibaba/druid/bvt/sql/oracle/select/OracleSelectTest124.java diff --git a/src/main/java/com/alibaba/druid/pool/DruidAbstractDataSource.java b/src/main/java/com/alibaba/druid/pool/DruidAbstractDataSource.java index 4a93369841..51314d1ad1 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidAbstractDataSource.java +++ b/src/main/java/com/alibaba/druid/pool/DruidAbstractDataSource.java @@ -68,10 +68,8 @@ import com.alibaba.druid.util.*; * @author ljw [ljw2083@alibaba-inc.com] */ public abstract class DruidAbstractDataSource extends WrapperAdapter implements DruidAbstractDataSourceMBean, DataSource, DataSourceProxy, Serializable { - - private final static Log LOG = LogFactory.getLog(DruidAbstractDataSource.class); - private static final long serialVersionUID = 1L; + private final static Log LOG = LogFactory.getLog(DruidAbstractDataSource.class); public final static int DEFAULT_INITIAL_SIZE = 0; public final static int DEFAULT_MAX_ACTIVE_SIZE = 8; @@ -86,12 +84,6 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements public static final long DEFAULT_TIME_BETWEEN_CONNECT_ERROR_MILLIS = 500; public static final int DEFAULT_NUM_TESTS_PER_EVICTION_RUN = 3; - /** - * The default value for {@link #getMinEvictableIdleTimeMillis}. - * - * @see #getMinEvictableIdleTimeMillis - * @see #setMinEvictableIdleTimeMillis - */ public static final long DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS = 1000L * 60L * 30L; public static final long DEFAULT_MAX_EVICTABLE_IDLE_TIME_MILLIS = 1000L * 60L * 60L * 7; public static final long DEFAULT_PHY_TIMEOUT_MILLIS = -1; @@ -131,8 +123,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements protected volatile boolean inited = false; - protected PrintWriter logWriter = new PrintWriter( - System.out); + protected PrintWriter logWriter = new PrintWriter(System.out); protected List filters = new CopyOnWriteArrayList(); private boolean clearFiltersEnable = true; @@ -143,27 +134,19 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements protected volatile int queryTimeout; protected volatile int transactionQueryTimeout; - protected AtomicLong createErrorCount = new AtomicLong(); - protected long createTimespan; protected volatile int maxWaitThreadCount = -1; - protected volatile boolean accessToUnderlyingConnectionAllowed = true; protected volatile long timeBetweenEvictionRunsMillis = DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS; - protected volatile int numTestsPerEvictionRun = DEFAULT_NUM_TESTS_PER_EVICTION_RUN; - protected volatile long minEvictableIdleTimeMillis = DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS; protected volatile long maxEvictableIdleTimeMillis = DEFAULT_MAX_EVICTABLE_IDLE_TIME_MILLIS; - protected volatile long phyTimeoutMillis = DEFAULT_PHY_TIMEOUT_MILLIS; protected volatile boolean removeAbandoned; - protected volatile long removeAbandonedTimeoutMillis = 300 * 1000; - protected volatile boolean logAbandoned; protected volatile int maxOpenPreparedStatements = -1; @@ -176,32 +159,41 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements protected volatile ValidConnectionChecker validConnectionChecker = null; - protected final AtomicLong errorCount = new AtomicLong(); - protected final AtomicLong dupCloseCount = new AtomicLong(); - protected final Map activeConnections = new IdentityHashMap(); protected final static Object PRESENT = new Object(); protected long id; - protected final Date createdTime = new Date(); - protected Date initedTime; - protected int connectionErrorRetryAttempts = 1; - protected boolean breakAfterAcquireFailure = false; - protected long transactionThresholdMillis = 0L; - protected final AtomicLong commitCount = new AtomicLong(); - protected final AtomicLong startTransactionCount = new AtomicLong(); - protected final AtomicLong rollbackCount = new AtomicLong(); - protected final AtomicLong cachedPreparedStatementHitCount = new AtomicLong(); - protected final AtomicLong preparedStatementCount = new AtomicLong(); - protected final AtomicLong closedPreparedStatementCount = new AtomicLong(); - protected final AtomicLong cachedPreparedStatementCount = new AtomicLong(); - protected final AtomicLong cachedPreparedStatementDeleteCount = new AtomicLong(); - protected final AtomicLong cachedPreparedStatementMissCount = new AtomicLong(); + protected final Date createdTime = new Date(); + protected Date initedTime; + protected volatile long errorCount = 0L; + protected volatile long dupCloseCount = 0L; + protected volatile long startTransactionCount = 0L; + protected volatile long commitCount = 0L; + protected volatile long rollbackCount = 0L; + protected volatile long cachedPreparedStatementHitCount = 0L; + protected volatile long preparedStatementCount = 0L; + protected volatile long closedPreparedStatementCount = 0L; + protected volatile long cachedPreparedStatementCount = 0L; + protected volatile long cachedPreparedStatementDeleteCount = 0L; + protected volatile long cachedPreparedStatementMissCount = 0L; + + final static AtomicLongFieldUpdater errorCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "errorCount"); + final static AtomicLongFieldUpdater dupCloseCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "dupCloseCount"); + final static AtomicLongFieldUpdater startTransactionCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "startTransactionCount"); + final static AtomicLongFieldUpdater commitCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "commitCount"); + final static AtomicLongFieldUpdater rollbackCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "rollbackCount"); + final static AtomicLongFieldUpdater cachedPreparedStatementHitCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "cachedPreparedStatementHitCount"); + final static AtomicLongFieldUpdater preparedStatementCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "preparedStatementCount"); + final static AtomicLongFieldUpdater closedPreparedStatementCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "closedPreparedStatementCount"); + final static AtomicLongFieldUpdater cachedPreparedStatementCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "cachedPreparedStatementCount"); + final static AtomicLongFieldUpdater cachedPreparedStatementDeleteCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "cachedPreparedStatementDeleteCount"); + final static AtomicLongFieldUpdater cachedPreparedStatementMissCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "cachedPreparedStatementMissCount"); + protected final Histogram transactionHistogram = new Histogram(1, 10, @@ -214,7 +206,15 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements private ObjectName objectName; - protected final AtomicLong executeCount = new AtomicLong(); + protected volatile long executeCount = 0L; + protected volatile long executeQueryCount = 0L; + protected volatile long executeUpdateCount = 0L; + protected volatile long executeBatchCount = 0L; + + final static AtomicLongFieldUpdater executeQueryCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "executeQueryCount"); + final static AtomicLongFieldUpdater executeUpdateCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "executeUpdateCount"); + final static AtomicLongFieldUpdater executeBatchCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "executeBatchCount"); + final static AtomicLongFieldUpdater executeCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "executeCount"); protected volatile Throwable createError; protected volatile Throwable lastError; @@ -233,13 +233,19 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements protected ReentrantLock activeConnectionLock = new ReentrantLock(); + protected volatile int createErrorCount = 0; protected volatile int creatingCount = 0; - protected AtomicLong createCount = new AtomicLong(); - protected AtomicLong destroyCount = new AtomicLong(); protected volatile int directCreateCount = 0; + protected volatile long createCount = 0L; + protected volatile long destroyCount = 0L; + + final static AtomicIntegerFieldUpdater createErrorCountUpdater = AtomicIntegerFieldUpdater.newUpdater(DruidAbstractDataSource.class, "createErrorCount"); + final static AtomicIntegerFieldUpdater creatingCountUpdater = AtomicIntegerFieldUpdater.newUpdater(DruidAbstractDataSource.class, "creatingCount"); + final static AtomicIntegerFieldUpdater directCreateCountUpdater = AtomicIntegerFieldUpdater.newUpdater(DruidAbstractDataSource.class, "directCreateCount"); + final static AtomicLongFieldUpdater createCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "createCount"); + final static AtomicLongFieldUpdater destroyCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "destroyCount"); private Boolean useUnfairLock = null; - private boolean useLocalSessionState = true; protected long timeBetweenLogStatsMillis; @@ -260,9 +266,6 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements protected volatile String lastFatalErrorSql = null; protected volatile Throwable lastFatalError = null; - protected static AtomicIntegerFieldUpdater directCreateCountUpdater = AtomicIntegerFieldUpdater.newUpdater(DruidAbstractDataSource.class, "directCreateCount"); - protected static AtomicIntegerFieldUpdater createCountUpdater = AtomicIntegerFieldUpdater.newUpdater(DruidAbstractDataSource.class, "creatingCount"); - public DruidAbstractDataSource(boolean lockFair){ lock = new ReentrantLock(lockFair); @@ -404,11 +407,46 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements } public long getExecuteCount() { - return executeCount.get(); + return executeCount + executeQueryCount + executeUpdateCount + executeBatchCount; + } + + public long getExecuteUpdateCount() { + return executeUpdateCount; + } + + public long getExecuteQueryCount() { + return executeQueryCount; + } + + public long getExecuteBatchCount() { + return executeBatchCount; + } + + public long getAndResetExecuteCount() { + return executeCountUpdater.getAndSet(this, 0) + + executeQueryCountUpdater.getAndSet(this, 0) + + executeUpdateCountUpdater.getAndSet(this, 0) + + executeBatchCountUpdater.getAndSet(this, 0); + } + + public long getExecuteCount2() { + return executeCount; } public void incrementExecuteCount() { - this.executeCount.incrementAndGet(); + this.executeCountUpdater.incrementAndGet(this); + } + + public void incrementExecuteUpdateCount() { + this.executeUpdateCount++; + } + + public void incrementExecuteQueryCount() { + this.executeQueryCount++; + } + + public void incrementExecuteBatchCount() { + this.executeBatchCount++; } public boolean isDupCloseLogEnable() { @@ -432,59 +470,59 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements } public void incrementCachedPreparedStatementCount() { - cachedPreparedStatementCount.incrementAndGet(); + cachedPreparedStatementCountUpdater.incrementAndGet(this); } public void decrementCachedPreparedStatementCount() { - cachedPreparedStatementCount.decrementAndGet(); + cachedPreparedStatementCountUpdater.decrementAndGet(this); } public void incrementCachedPreparedStatementDeleteCount() { - cachedPreparedStatementDeleteCount.incrementAndGet(); + cachedPreparedStatementDeleteCountUpdater.incrementAndGet(this); } public void incrementCachedPreparedStatementMissCount() { - cachedPreparedStatementMissCount.incrementAndGet(); + cachedPreparedStatementMissCountUpdater.incrementAndGet(this); } public long getCachedPreparedStatementMissCount() { - return cachedPreparedStatementMissCount.get(); + return cachedPreparedStatementMissCount; } public long getCachedPreparedStatementAccessCount() { - return cachedPreparedStatementMissCount.get() + cachedPreparedStatementHitCount.get(); + return cachedPreparedStatementMissCount + cachedPreparedStatementHitCount; } public long getCachedPreparedStatementDeleteCount() { - return cachedPreparedStatementDeleteCount.get(); + return cachedPreparedStatementDeleteCount; } public long getCachedPreparedStatementCount() { - return cachedPreparedStatementCount.get(); + return cachedPreparedStatementCount; } public void incrementClosedPreparedStatementCount() { - closedPreparedStatementCount.incrementAndGet(); + closedPreparedStatementCountUpdater.incrementAndGet(this); } public long getClosedPreparedStatementCount() { - return closedPreparedStatementCount.get(); + return closedPreparedStatementCount; } public void incrementPreparedStatementCount() { - preparedStatementCount.incrementAndGet(); + preparedStatementCountUpdater.incrementAndGet(this); } public long getPreparedStatementCount() { - return preparedStatementCount.get(); + return preparedStatementCount; } public void incrementCachedPreparedStatementHitCount() { - cachedPreparedStatementHitCount.incrementAndGet(); + cachedPreparedStatementHitCountUpdater.incrementAndGet(this); } public long getCachedPreparedStatementHitCount() { - return cachedPreparedStatementHitCount.get(); + return cachedPreparedStatementHitCount; } public long getTransactionThresholdMillis() { @@ -506,27 +544,27 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements } public long getCommitCount() { - return commitCount.get(); + return commitCount; } public void incrementCommitCount() { - commitCount.incrementAndGet(); + commitCountUpdater.incrementAndGet(this); } public long getRollbackCount() { - return rollbackCount.get(); + return rollbackCount; } public void incrementRollbackCount() { - rollbackCount.incrementAndGet(); + rollbackCountUpdater.incrementAndGet(this); } public long getStartTransactionCount() { - return startTransactionCount.get(); + return startTransactionCount; } public void incrementStartTransactionCount() { - startTransactionCount.incrementAndGet(); + startTransactionCountUpdater.incrementAndGet(this); } public boolean isBreakAfterAcquireFailure() { @@ -546,7 +584,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements } public long getDupCloseCount() { - return dupCloseCount.get(); + return dupCloseCount; } public int getMaxPoolPreparedStatementPerConnectionSize() { @@ -572,7 +610,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements } public void incrementDupCloseCount() { - dupCloseCount.incrementAndGet(); + dupCloseCountUpdater.incrementAndGet(this); } public ValidConnectionChecker getValidConnectionChecker() { @@ -1023,7 +1061,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements } public long getCreateErrorCount() { - return createErrorCount.get(); + return createErrorCount; } public int getMaxActive() { @@ -1463,31 +1501,37 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements this.clearFiltersEnable = clearFiltersEnable; } - protected final AtomicLong connectionIdSeed = new AtomicLong(10000); - protected final AtomicLong statementIdSeed = new AtomicLong(20000); - protected final AtomicLong resultSetIdSeed = new AtomicLong(50000); - protected final AtomicLong transactionIdSeed = new AtomicLong(60000); - protected final AtomicLong metaDataIdSeed = new AtomicLong(80000); + protected volatile long connectionIdSeed = 10000L; + protected volatile long statementIdSeed = 20000L; + protected volatile long resultSetIdSeed = 50000L; + protected volatile long transactionIdSeed = 60000L; + protected volatile long metaDataIdSeed = 80000L; + + final static AtomicLongFieldUpdater connectionIdSeedUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "connectionIdSeed"); + final static AtomicLongFieldUpdater statementIdSeedUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "statementIdSeed"); + final static AtomicLongFieldUpdater resultSetIdSeedUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "resultSetIdSeed"); + final static AtomicLongFieldUpdater transactionIdSeedUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "transactionIdSeed"); + final static AtomicLongFieldUpdater metaDataIdSeedUpdater = AtomicLongFieldUpdater.newUpdater(DruidAbstractDataSource.class, "metaDataIdSeed"); public long createConnectionId() { - return connectionIdSeed.incrementAndGet(); + return connectionIdSeedUpdater.incrementAndGet(this); } public long createStatementId() { - return statementIdSeed.getAndIncrement(); + return statementIdSeedUpdater.getAndIncrement(this); } public long createMetaDataId() { - return metaDataIdSeed.getAndIncrement(); + return metaDataIdSeedUpdater.getAndIncrement(this); } public long createResultSetId() { - return resultSetIdSeed.getAndIncrement(); + return resultSetIdSeedUpdater.getAndIncrement(this); } @Override public long createTransactionId() { - return transactionIdSeed.getAndIncrement(); + return transactionIdSeedUpdater.getAndIncrement(this); } void initStatement(DruidPooledConnection conn, Statement stmt) throws SQLException { @@ -1516,7 +1560,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements conn = new FilterChainImpl(this).connection_connect(info); } - createCount.incrementAndGet(); + createCountUpdater.incrementAndGet(this); return conn; } @@ -1574,7 +1618,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements ? new HashMap() : null; - createCountUpdater.incrementAndGet(this); + creatingCountUpdater.incrementAndGet(this); try { conn = createPhysicalConnection(url, physicalConnectProperties); connectedNanos = System.nanoTime(); @@ -1599,14 +1643,14 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements JdbcUtils.close(conn); throw ex; } catch (Error ex) { - createErrorCount.incrementAndGet(); + createErrorCountUpdater.incrementAndGet(this); setCreateError(ex); JdbcUtils.close(conn); throw ex; } finally { long nano = System.nanoTime() - connectStartNanos; createTimespan += nano; - createCountUpdater.decrementAndGet(this); + creatingCountUpdater.decrementAndGet(this); } return new PhysicalConnectionInfo(conn, connectStartNanos, connectedNanos, initedNanos, validatedNanos, variables, globalVariables); @@ -1625,7 +1669,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements return; } - createErrorCount.incrementAndGet(); + createErrorCountUpdater.incrementAndGet(this); long now = System.currentTimeMillis(); lock.lock(); try { @@ -1840,7 +1884,7 @@ public abstract class DruidAbstractDataSource extends WrapperAdapter implements if (stmtHolder == null) { return; } - closedPreparedStatementCount.incrementAndGet(); + closedPreparedStatementCountUpdater.incrementAndGet(this); decrementCachedPreparedStatementCount(); incrementCachedPreparedStatementDeleteCount(); diff --git a/src/main/java/com/alibaba/druid/pool/DruidDataSource.java b/src/main/java/com/alibaba/druid/pool/DruidDataSource.java index 24645e4de1..3d15d97bfd 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidDataSource.java +++ b/src/main/java/com/alibaba/druid/pool/DruidDataSource.java @@ -96,7 +96,6 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat private long connectCount = 0L; private long closeCount = 0L; private volatile long connectErrorCount = 0L; -// private final AtomicLong connectErrorCount = new AtomicLong(); private long recycleCount = 0L; private long removeAbandonedCount = 0L; private long notEmptyWaitCount = 0L; @@ -134,7 +133,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat private volatile boolean enable = true; private boolean resetStatEnable = true; - private final AtomicLong resetCount = new AtomicLong(); + private volatile long resetCount = 0L; private String initStackTrace; @@ -156,6 +155,8 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat = AtomicLongFieldUpdater.newUpdater(DruidDataSource.class, "recycleErrorCount"); protected static final AtomicLongFieldUpdater connectErrorCountUpdater = AtomicLongFieldUpdater.newUpdater(DruidDataSource.class, "connectErrorCount"); + protected static final AtomicLongFieldUpdater resetCountUpdater + = AtomicLongFieldUpdater.newUpdater(DruidDataSource.class, "resetCount"); public DruidDataSource(){ this(false); @@ -534,8 +535,9 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat closeCount = 0; discardCount = 0; recycleCount = 0; - createCount.set(0); - destroyCount.set(0); + createCount = 0L; + directCreateCount = 0; + destroyCount = 0L; removeAbandonedCount = 0; notEmptyWaitCount = 0; notEmptySignalCount = 0L; @@ -554,22 +556,22 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat } connectErrorCountUpdater.set(this, 0); - errorCount.set(0); - commitCount.set(0); - rollbackCount.set(0); - startTransactionCount.set(0); - cachedPreparedStatementHitCount.set(0); - closedPreparedStatementCount.set(0); - preparedStatementCount.set(0); + errorCountUpdater.set(this, 0); + commitCountUpdater.set(this, 0); + rollbackCountUpdater.set(this, 0); + startTransactionCountUpdater.set(this, 0); + cachedPreparedStatementHitCountUpdater.set(this, 0); + closedPreparedStatementCountUpdater.set(this, 0); + preparedStatementCountUpdater.set(this, 0); transactionHistogram.reset(); - cachedPreparedStatementDeleteCount.set(0); + cachedPreparedStatementDeleteCountUpdater.set(this, 0); recycleErrorCountUpdater.set(this, 0); - resetCount.incrementAndGet(); + resetCountUpdater.incrementAndGet(this); } public long getResetCount() { - return this.resetCount.get(); + return this.resetCount; } public boolean isEnable() { @@ -745,10 +747,10 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat this.id = DruidDriver.createDataSourceId(); if (this.id > 1) { long delta = (this.id - 1) * 100000; - this.connectionIdSeed.addAndGet(delta); - this.statementIdSeed.addAndGet(delta); - this.resultSetIdSeed.addAndGet(delta); - this.transactionIdSeed.addAndGet(delta); + this.connectionIdSeedUpdater.addAndGet(this, delta); + this.statementIdSeedUpdater.addAndGet(this, delta); + this.resultSetIdSeedUpdater.addAndGet(this, delta); + this.transactionIdSeedUpdater.addAndGet(this, delta); } if (this.jdbcUrl != null) { @@ -1368,12 +1370,12 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat for (boolean createDirect = false;;) { if (createDirect) { - if (createCountUpdater.compareAndSet(this, 0, 1)) { + if (creatingCountUpdater.compareAndSet(this, 0, 1)) { PhysicalConnectionInfo pyConnInfo = DruidDataSource.this.createPhysicalConnection(); holder = new DruidConnectionHolder(this, pyConnInfo); holder.lastActiveTimeMillis = System.currentTimeMillis(); - createCountUpdater.decrementAndGet(this); + creatingCountUpdater.decrementAndGet(this); directCreateCountUpdater.incrementAndGet(this); if (LOG.isDebugEnabled()) { @@ -1443,7 +1445,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat if (createScheduler != null && poolingCount == 0 && activeCount < maxActive - && createCountUpdater.get(this) == 0 + && creatingCountUpdater.get(this) == 0 && createScheduler instanceof ScheduledThreadPoolExecutor) { ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) createScheduler; if (executor.getQueue().size() > 0) { @@ -1520,7 +1522,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat public void handleConnectionException(DruidPooledConnection pooledConnection, Throwable t, String sql) throws SQLException { final DruidConnectionHolder holder = pooledConnection.getConnectionHolder(); - errorCount.incrementAndGet(); + errorCountUpdater.incrementAndGet(this); lastError = t; lastErrorTimeMillis = System.currentTimeMillis(); @@ -1682,7 +1684,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat if (!validate) { JdbcUtils.close(physicalConnection); - destroyCount.incrementAndGet(); + destroyCountUpdater.incrementAndGet(this); lock.lock(); try { @@ -1731,7 +1733,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat } public long getRecycleErrorCount() { - return recycleErrorCountUpdater.get(this); + return recycleErrorCount; } public void clearStatementCache() throws SQLException { @@ -1800,7 +1802,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat LOG.warn("close connection error", ex); } connections[i] = null; - destroyCount.incrementAndGet(); + destroyCountUpdater.incrementAndGet(this); } poolingCount = 0; unregisterMbean(); @@ -2012,11 +2014,11 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat } public long getCreateCount() { - return createCount.get(); + return createCount; } public long getDestroyCount() { - return destroyCount.get(); + return destroyCount; } public long getConnectCount() { @@ -2153,19 +2155,19 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat value.setLogicConnectErrorCount(connectErrorCountUpdater.getAndSet(this, 0)); - value.setPhysicalConnectCount(createCount.getAndSet(0)); - value.setPhysicalCloseCount(destroyCount.getAndSet(0)); - value.setPhysicalConnectErrorCount(createErrorCount.getAndSet(0)); + value.setPhysicalConnectCount(createCountUpdater.getAndSet(this, 0)); + value.setPhysicalCloseCount(destroyCountUpdater.getAndSet(this, 0)); + value.setPhysicalConnectErrorCount(createErrorCountUpdater.getAndSet(this, 0)); - value.setExecuteCount(this.executeCount.getAndSet(0)); - value.setErrorCount(errorCount.getAndSet(0)); - value.setCommitCount(commitCount.getAndSet(0)); - value.setRollbackCount(rollbackCount.getAndSet(0)); + value.setExecuteCount(this.getAndResetExecuteCount()); + value.setErrorCount(errorCountUpdater.getAndSet(this, 0)); + value.setCommitCount(commitCountUpdater.getAndSet(this, 0)); + value.setRollbackCount(rollbackCountUpdater.getAndSet(this, 0)); - value.setPstmtCacheHitCount(cachedPreparedStatementHitCount.getAndSet(0)); - value.setPstmtCacheMissCount(cachedPreparedStatementMissCount.getAndSet(0)); + value.setPstmtCacheHitCount(cachedPreparedStatementHitCountUpdater.getAndSet(this,0)); + value.setPstmtCacheMissCount(cachedPreparedStatementMissCountUpdater.getAndSet(this, 0)); - value.setStartTransactionCount(startTransactionCount.getAndSet(0)); + value.setStartTransactionCount(startTransactionCountUpdater.getAndSet(this, 0)); value.setTransactionHistogram(this.getTransactionHistogram().toArrayAndReset()); value.setConnectionHoldTimeHistogram(this.getDataSourceStat().getConnectionHoldHistogram().toArrayAndReset()); @@ -2430,7 +2432,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat } if (emptyWait - && asyncInit && createCount.get() < initialSize) { + && asyncInit && createCount < initialSize) { emptyWait = false; } @@ -2793,7 +2795,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat DruidConnectionHolder item = evictConnections[i]; Connection connection = item.getConnection(); JdbcUtils.close(connection); - destroyCount.incrementAndGet(); + destroyCountUpdater.incrementAndGet(this); } Arrays.fill(evictConnections, null); } @@ -2897,7 +2899,7 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat } public long getErrorCount() { - return this.errorCount.get(); + return this.errorCount; } public String toString() { @@ -3135,7 +3137,9 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat map.put("LastCreateErrorTime", this.getLastCreateErrorTime()); map.put("CreateErrorCount", this.getCreateErrorCount()); map.put("DiscardCount", this.getDiscardCount()); + map.put("ExecuteQueryCount", this.getExecuteQueryCount()); + map.put("ExecuteUpdateCount", this.getExecuteUpdateCount()); return map; } catch (JMException ex) { @@ -3220,6 +3224,9 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat dataMap.put("PhysicalConnectErrorCount", this.getCreateErrorCount()); dataMap.put("ExecuteCount", this.getExecuteCount()); + dataMap.put("ExecuteUpdateCount", this.getExecuteUpdateCount()); + dataMap.put("ExecuteQueryCount", this.getExecuteQueryCount()); + dataMap.put("ExecuteBatchCount", this.getExecuteBatchCount()); dataMap.put("ErrorCount", this.getErrorCount()); dataMap.put("CommitCount", this.getCommitCount()); dataMap.put("RollbackCount", this.getRollbackCount()); diff --git a/src/main/java/com/alibaba/druid/pool/DruidPooledPreparedStatement.java b/src/main/java/com/alibaba/druid/pool/DruidPooledPreparedStatement.java index 0bd558203f..55cf272c2a 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidPooledPreparedStatement.java +++ b/src/main/java/com/alibaba/druid/pool/DruidPooledPreparedStatement.java @@ -218,7 +218,7 @@ public class DruidPooledPreparedStatement extends DruidPooledStatement implement public ResultSet executeQuery() throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteQueryCount(); transactionRecord(sql); oracleSetRowPrefetch(); @@ -248,7 +248,7 @@ public class DruidPooledPreparedStatement extends DruidPooledStatement implement public int executeUpdate() throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteUpdateCount(); transactionRecord(sql); conn.beforeExecute(); @@ -558,7 +558,7 @@ public class DruidPooledPreparedStatement extends DruidPooledStatement implement public int[] executeBatch() throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteBatchCount(); transactionRecord(sql); conn.beforeExecute(); diff --git a/src/main/java/com/alibaba/druid/pool/DruidPooledStatement.java b/src/main/java/com/alibaba/druid/pool/DruidPooledStatement.java index 3edd151309..6db3b309a3 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidPooledStatement.java +++ b/src/main/java/com/alibaba/druid/pool/DruidPooledStatement.java @@ -196,13 +196,31 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { } public void incrementExecuteCount() { - DruidPooledConnection conn = this.getPoolableConnection(); - + final DruidPooledConnection conn = this.getPoolableConnection(); if (conn == null) { return; } - DruidConnectionHolder holder = conn.getConnectionHolder(); + final DruidConnectionHolder holder = conn.getConnectionHolder(); + if (holder == null) { + return; + } + + final DruidAbstractDataSource dataSource = holder.getDataSource(); + if (dataSource == null) { + return; + } + + dataSource.incrementExecuteCount(); + } + + public void incrementExecuteBatchCount() { + final DruidPooledConnection conn = this.getPoolableConnection(); + if (conn == null) { + return; + } + + final DruidConnectionHolder holder = conn.getConnectionHolder(); if (holder == null) { return; } @@ -211,7 +229,50 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { return; } - holder.getDataSource().incrementExecuteCount(); + final DruidAbstractDataSource dataSource = holder.getDataSource(); + if (dataSource == null) { + return; + } + + dataSource.incrementExecuteBatchCount(); + } + + public void incrementExecuteUpdateCount() { + final DruidPooledConnection conn = this.getPoolableConnection(); + if (conn == null) { + return; + } + + final DruidConnectionHolder holder = conn.getConnectionHolder(); + if (holder == null) { + return; + } + + final DruidAbstractDataSource dataSource = holder.getDataSource(); + if (dataSource == null) { + return; + } + + dataSource.incrementExecuteUpdateCount(); + } + + public void incrementExecuteQueryCount() { + final DruidPooledConnection conn = this.getPoolableConnection(); + if (conn == null) { + return; + } + + final DruidConnectionHolder holder = conn.getConnectionHolder(); + if (holder == null) { + return; + } + + final DruidAbstractDataSource dataSource = holder.getDataSource(); + if (dataSource == null) { + return; + } + + dataSource.incrementExecuteQueryCount(); } protected void transactionRecord(String sql) throws SQLException { @@ -222,7 +283,7 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { public final ResultSet executeQuery(String sql) throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteQueryCount(); transactionRecord(sql); conn.beforeExecute(); @@ -250,7 +311,7 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { public final int executeUpdate(String sql) throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteUpdateCount(); transactionRecord(sql); conn.beforeExecute(); @@ -301,7 +362,7 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { public final int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteUpdateCount(); transactionRecord(sql); conn.beforeExecute(); @@ -320,7 +381,7 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { public final int executeUpdate(String sql, int columnIndexes[]) throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteUpdateCount(); transactionRecord(sql); conn.beforeExecute(); @@ -339,7 +400,7 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { public final int executeUpdate(String sql, String columnNames[]) throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteUpdateCount(); transactionRecord(sql); conn.beforeExecute(); @@ -710,7 +771,7 @@ public class DruidPooledStatement extends PoolableWrapper implements Statement { public int[] executeBatch() throws SQLException { checkOpen(); - incrementExecuteCount(); + incrementExecuteBatchCount(); conn.beforeExecute(); try { diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExplainStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExplainStatement.java index d35914bf3b..97c65d9933 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExplainStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExplainStatement.java @@ -25,11 +25,8 @@ import com.alibaba.druid.sql.ast.SQLStatementImpl; import com.alibaba.druid.sql.visitor.SQLASTVisitor; public class SQLExplainStatement extends SQLStatementImpl { - private String type; - protected SQLStatement statement; - private List hints; public SQLExplainStatement() { diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlExplainStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlExplainStatement.java index 2fc6273313..7e5f7792df 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlExplainStatement.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlExplainStatement.java @@ -26,15 +26,11 @@ import com.alibaba.druid.sql.visitor.SQLASTVisitor; import com.alibaba.druid.util.JdbcConstants; public class MySqlExplainStatement extends SQLExplainStatement implements MySqlStatement { - private boolean describe; - private SQLName tableName; private SQLName columnName; private SQLExpr wild; - - private String format; - + private String format; private SQLExpr connectionId; public MySqlExplainStatement() { diff --git a/src/main/java/com/alibaba/druid/stat/DruidDataSourceStatManager.java b/src/main/java/com/alibaba/druid/stat/DruidDataSourceStatManager.java index c8bd1fb26c..3a8b7d6585 100644 --- a/src/main/java/com/alibaba/druid/stat/DruidDataSourceStatManager.java +++ b/src/main/java/com/alibaba/druid/stat/DruidDataSourceStatManager.java @@ -343,11 +343,15 @@ public class DruidDataSourceStatManager implements DruidDataSourceStatManagerMBe SimpleType.LONG, // SimpleType.STRING, // - // 40 - + // 40 - 44 SimpleType.DATE, // SimpleType.DATE, // SimpleType.LONG, // - SimpleType.LONG // + SimpleType.LONG, // + SimpleType.LONG, // + + // 45 + SimpleType.LONG, // // }; @@ -413,6 +417,9 @@ public class DruidDataSourceStatManager implements DruidDataSourceStatManagerMBe "LastCreateErrorTime", // "CreateErrorCount", // "DiscardCount", // + "ExecuteQueryCount", // + + "ExecuteUpdateCount", // // }; diff --git a/src/main/java/com/alibaba/druid/stat/JdbcDataSourceStat.java b/src/main/java/com/alibaba/druid/stat/JdbcDataSourceStat.java index aa552c5db0..7df8f23266 100644 --- a/src/main/java/com/alibaba/druid/stat/JdbcDataSourceStat.java +++ b/src/main/java/com/alibaba/druid/stat/JdbcDataSourceStat.java @@ -71,9 +71,8 @@ public class JdbcDataSourceStat implements JdbcDataSourceStatMBean { 1); private final AtomicLong clobOpenCount = new AtomicLong(); - private final AtomicLong blobOpenCount = new AtomicLong(); - private final AtomicLong keepAliveCheckCount = new AtomicLong(); + private final AtomicLong keepAliveCheckCount = new AtomicLong(); private boolean resetStatEnable = true; diff --git a/src/main/resources/support/http/resources/datasource.html b/src/main/resources/support/http/resources/datasource.html index 4b1e369221..a031f9df3d 100644 --- a/src/main/resources/support/http/resources/datasource.html +++ b/src/main/resources/support/http/resources/datasource.html @@ -286,7 +286,22 @@ ExecuteCount {{=datasourceNow.ExecuteCount}} - + Total Execute Count + + + ExecuteQueryCount + {{=datasourceNow.ExecuteQueryCount}} + + + + ExecuteUpdateCount + {{=datasourceNow.ExecuteUpdateCount}} + + + + ExecuteBatchCount + {{=datasourceNow.ExecuteBatchCount}} + ErrorCount diff --git a/src/main/resources/support/http/resources/js/lang.js b/src/main/resources/support/http/resources/js/lang.js index 14ec3ae6b6..5953ad54af 100644 --- a/src/main/resources/support/http/resources/js/lang.js +++ b/src/main/resources/support/http/resources/js/lang.js @@ -63,7 +63,7 @@ druid.lang = function() { 'PhysicalConnectCount' : ['PhysicalConnectCount', '物理连接打开次数'], 'PhysicalCloseCount' : ['PhysicalCloseCount', '物理关闭数量'], 'PhysicalConnectErrorCount' : ['PhysicalConnectErrorCount', '物理连接错误次数'], - 'ExecuteCount' : ['ExecuteCount', '执行数'], + 'ExecuteCount' : ['ExecuteCount (Total)', '执行数(总共)'], 'ErrorCount' : ['ErrorCount', '错误数'], 'CommitCount' : ['CommitCount', '提交数'], 'RollbackCount' : ['RollbackCount', '回滚数'], diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/mysql/MySqlWallTest151_update.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/mysql/MySqlWallTest151_update.java new file mode 100644 index 0000000000..285929b059 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/mysql/MySqlWallTest151_update.java @@ -0,0 +1,26 @@ +package com.alibaba.druid.bvt.filter.wall.mysql; + +import com.alibaba.druid.wall.WallCheckResult; +import com.alibaba.druid.wall.WallProvider; +import com.alibaba.druid.wall.spi.MySqlWallProvider; +import junit.framework.TestCase; + +public class MySqlWallTest151_update extends TestCase { + + public void test_false() throws Exception { + WallProvider provider = new MySqlWallProvider(); + + provider.getConfig().setSelectLimit(100); + + String sql = "update twogradeestate set layarea=layarea+97.0, selfarea=selfarea-97.0, sysmoddate='2016-12-21' where tgeid='0012002'"; + + WallCheckResult result = provider.check(sql); + assertEquals(0, result.getViolations().size()); + String wsql = result + .getStatementList().get(0).toString(); + + assertEquals("UPDATE twogradeestate\n" + + "SET layarea = layarea + 97.0, selfarea = selfarea - 97.0, sysmoddate = '2016-12-21'\n" + + "WHERE tgeid = '0012002'", wsql); + } +} diff --git a/src/test/java/com/alibaba/druid/bvt/sql/oracle/select/OracleSelectTest124.java b/src/test/java/com/alibaba/druid/bvt/sql/oracle/select/OracleSelectTest124.java new file mode 100644 index 0000000000..635cc336b6 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/sql/oracle/select/OracleSelectTest124.java @@ -0,0 +1,49 @@ +/* + * Copyright 1999-2017 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.bvt.sql.oracle.select; + +import com.alibaba.druid.sql.MysqlTest; +import com.alibaba.druid.sql.SQLUtils; +import com.alibaba.druid.sql.ast.SQLStatement; +import com.alibaba.druid.sql.ast.statement.SQLSelectStatement; +import com.alibaba.druid.util.JdbcConstants; +import junit.framework.TestCase; + +import java.util.List; + + +public class OracleSelectTest124 extends TestCase { + public void test_0() throws Exception { + String sql = "SELECT\n" + + "J01.COL_A,\n" + + "J01.COL_B,\n" + + "\"SUM\"(J01.COL_C) OVER (\n" + + "PARTITION BY J01.COL_A ORDER BY J01.COL_B NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n" + + ") AS COL_C\n" + + "FROM\n" + + "TAB_A J01"; + + List statementList = SQLUtils.parseStatements(sql, JdbcConstants.ORACLE); + + assertEquals(1, statementList.size()); + + SQLSelectStatement stmt = (SQLSelectStatement) statementList.get(0); + + assertEquals("SELECT J01.COL_A, J01.COL_B, SUM(J01.COL_C) OVER (PARTITION BY J01.COL_A ORDER BY J01.COL_B NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS COL_C\n" + + "FROM TAB_A J01", stmt.toString()); + } + +} \ No newline at end of file