Merge pull request #11 from little-pan/0.3.29-server-status

forchid · web-flow · commit 5f7cb5bc75cd · 2019-12-21T23:06:24.000+08:00
Added SQL metric for "show status" statement
diff --git a/src/main/java/org/sqlite/server/SQLiteProcessor.java b/src/main/java/org/sqlite/server/SQLiteProcessor.java
@@ -37,6 +37,7 @@
 import org.sqlite.server.func.StringResultFunc;
 import org.sqlite.server.func.TimestampFunc;
 import org.sqlite.server.func.UserFunc;
+import org.sqlite.server.sql.SQLMetric;
 import org.sqlite.server.sql.meta.Catalog;
 import org.sqlite.server.sql.meta.CreateDatabaseStatement;
 import org.sqlite.server.sql.meta.DropDatabaseStatement;
@@ -98,6 +99,8 @@ public abstract class SQLiteProcessor extends SQLContext implements AutoCloseabl
     protected SQLiteLocalDb localDb;
     protected Stack<TransactionStatement> savepointStack;
     
+    protected long sqlStartNanoTime;
+    
     protected SQLiteProcessor(SQLiteServer server, SocketChannel channel, int id) 
             throws NetworkException {
         this.createTime = System.currentTimeMillis();
@@ -383,6 +386,49 @@ protected void prepareTransaction(TransactionStatement txSql) {
         trace(log, "{}, '{}' readOnly {}", tx, this, this.readOnly);
     }
     
+    @Override
+    protected void preExecute(SQLStatement s) {
+        final SQLMetric metric = this.worker.sqlMetric;
+        
+        switch(s.getCommand()) {
+        case "SELECT":
+            metric.selectStmts++;
+            break;
+        case "UPDATE":
+            metric.updateStmts++;
+            break;
+        case "INSERT":
+            metric.insertStmts++;
+            break;
+        case "DELETE":
+            metric.deleteStmts++;
+            break;
+        default:
+            break;
+        }
+        metric.totalStmts++;
+        
+        long longTime = this.server.getLongQueryNanoTime();
+        if (longTime > 0L) {
+            this.sqlStartNanoTime = System.nanoTime();
+        } else {
+            this.sqlStartNanoTime = 0L;
+        }
+    }
+    
+    @Override
+    protected void postExecute(SQLStatement s) {
+        long longTime = this.server.getLongQueryNanoTime();
+        final SQLMetric metric = this.worker.getSQLMetric();
+        
+        if (longTime > 0L && this.sqlStartNanoTime > 0L) {
+            if (System.nanoTime() - this.sqlStartNanoTime > longTime) {
+                metric.slowStmts++;
+            }
+        }
+        this.sqlStartNanoTime = 0L;
+    }
+    
     @Override
     protected void pushSavepoint(TransactionStatement txSql) {
         this.savepointStack.push(txSql);
diff --git a/src/main/java/org/sqlite/server/SQLiteServer.java b/src/main/java/org/sqlite/server/SQLiteServer.java
@@ -50,6 +50,7 @@
 import org.sqlite.server.func.TimestampFunc;
 import org.sqlite.server.func.VersionFunc;
 import org.sqlite.server.pg.PgServer;
+import org.sqlite.server.sql.SQLMetric;
 import org.sqlite.server.sql.meta.Catalog;
 import org.sqlite.server.sql.meta.User;
 import org.sqlite.server.util.IoUtils;
@@ -77,6 +78,7 @@ public abstract class SQLiteServer implements AutoCloseable {
     public static final String HOST_DEFAULT = "localhost";
     public static final int AUTH_TIMEOUT_DEFAULT = 15000;
     public static final int PORT_DEFAULT = 3272;
+    public static final int LONG_QUERY_TIME_DEFAULT = 2000;
     public static final int MAX_CONNS_DEFAULT = 50;
     public static final int MAX_WORKER_COUNT  = 128;
     public static final int OPEN_TIMEOUT_DEFAULT = 30000;
@@ -112,6 +114,8 @@ public abstract class SQLiteServer implements AutoCloseable {
     protected int authTimeout = AUTH_TIMEOUT_DEFAULT;
     protected int sleepTimeout = SLEEP_TIMEOUT_DEFAULT;
     protected int sleepInTxTimeout = SLEEP_IN_TX_TIMEOUT_DEFAULT;
+    protected long longQueryNanoTime = LONG_QUERY_TIME_DEFAULT * 1000000L;
+    
     protected JournalMode journalMode = JOURNAL_MODE_DEFAULT;
     protected SynchronousMode synchronous = SYNCHRONOUS_DEFAULT;
     private final ConcurrentMap<String, SQLContext> dbWriteLocks;
@@ -439,6 +443,8 @@ public void init(String... args) {
                 this.authMethod = toLowerEnglish(args[++i]);
             } else if ("--max-allowed-packet".equals(a)) {
                 this.maxAllowedPacket = Long.decode(args[++i]);
+            } else if("--long-query-time".equals(a)) {
+                this.longQueryNanoTime = Long.decode(args[++i]) * 1000000L;
             } else if ("--help".equals(a) || "-h".equals(a) || "-?".equals(a)) {
                 help = true;
             }
@@ -791,6 +797,10 @@ public File getDbFile(String dbName) {
         return new File(this.dataDir, dbName);
     }
     
+    public long getLongQueryNanoTime() {
+        return this.longQueryNanoTime;
+    }
+    
     protected SQLiteMetaDb getMetaDb() {
         return this.metaDb;
     }
@@ -840,6 +850,25 @@ public int getSleepInTxTimeout() {
         return this.sleepInTxTimeout;
     }
     
+    public SQLMetric getSQLMetric() {
+        final SQLiteWorker[] workers = this.workers;
+        final SQLMetric metric = new SQLMetric();
+        
+        for (final SQLiteWorker worker: workers) {
+            if (worker != null) {
+                SQLMetric m = worker.getSQLMetric();
+                metric.deleteStmts += m.deleteStmts;
+                metric.insertStmts += m.insertStmts;
+                metric.selectStmts += m.selectStmts;
+                metric.updateStmts += m.updateStmts;
+                metric.totalStmts  += m.totalStmts;
+                metric.slowStmts   += m.slowStmts;
+            }
+        }
+        
+        return metric;
+    }
+    
     public boolean inDataDir(String filename) {
         return inDataDir(filename, this.dataDir);
     }
@@ -1052,6 +1081,7 @@ protected String getBootHelp() {
                 "  --help|-h|-?                  \tShow this message\n" +
                 "  --host|-H       <host>        \tSQLite server listen host or IP, default "+HOST_DEFAULT+"\n"+
                 "  --journal-mode  <mode>        \tSQLite journal mode, default "+JOURNAL_MODE_DEFAULT+"\n"+
+                "  --long-query-time <millis>    \tLong SQL query time, default "+LONG_QUERY_TIME_DEFAULT+"ms\n"+
                 "  --max-allowed-packet <number> \tMax allowed packet size, default " + MAX_ALLOWED_PACKET_DEFAULT+"B\n"+
                 "  --max-conns     <number>      \tMax client connections limit, default "+MAX_CONNS_DEFAULT+"\n"+
                 "  --open-timeout  <millis>      \tOpen SQLite database timeout, default "+OPEN_TIMEOUT_DEFAULT+"ms\n"+
diff --git a/src/main/java/org/sqlite/server/SQLiteWorker.java b/src/main/java/org/sqlite/server/SQLiteWorker.java
@@ -28,6 +28,7 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.sqlite.server.sql.SQLMetric;
 import org.sqlite.server.sql.meta.User;
 import org.sqlite.server.util.IoUtils;
 import org.sqlite.server.util.SlotAllocator;
@@ -62,6 +63,8 @@ public class SQLiteWorker implements Runnable {
     private final SlotAllocator<SQLiteProcessor> processors;
     private final SlotAllocator<SQLiteProcessor> busyProcs;
     
+    protected final SQLMetric sqlMetric = new SQLMetric();
+    
     public SQLiteWorker(SQLiteServer server, int id) {
         this.server = server;
         this.id = id;
@@ -502,6 +505,10 @@ protected long minSelectTimeout(final long curr, final long idleCheckIntv) {
         
         return timeout;
     }
+    
+    public SQLMetric getSQLMetric() {
+        return this.sqlMetric;
+    }
 
     SQLiteProcessor getProcessor(int pid) {
         SlotAllocator<SQLiteProcessor> processors = this.processors;
diff --git a/src/main/java/org/sqlite/server/sql/SQLMetric.java b/src/main/java/org/sqlite/server/sql/SQLMetric.java
@@ -0,0 +1,39 @@
+/**
+ * Copyright 2019 little-pan. A SQLite server based on the C/S architecture.
+ * 
+ * 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 org.sqlite.server.sql;
+
+/** SQL statement metric.
+ * 
+ * @author little-pan
+ * @since 2019-12-21
+ *
+ */
+public class SQLMetric {
+    
+    // Imprecise is intentional for performance
+    public volatile long selectStmts;
+    public volatile long updateStmts;
+    public volatile long insertStmts;
+    public volatile long deleteStmts;
+    public volatile long totalStmts;
+    
+    public volatile long slowStmts;
+    
+    public SQLMetric() {
+        
+    }
+
+}
diff --git a/src/main/java/org/sqlite/server/sql/local/ShowStatusStatement.java b/src/main/java/org/sqlite/server/sql/local/ShowStatusStatement.java
@@ -28,8 +28,10 @@
 import java.util.Date;
 
 import org.sqlite.server.SQLiteProcessor;
+import org.sqlite.server.SQLiteServer;
+import org.sqlite.server.sql.SQLMetric;
 
-/** "SHOW STATUS" statement that shows server current status, includes memory, 
+/** "SHOW STATUS" statement that shows server current status, includes SQL, memory, 
  * thread, runtime and OS information.
  * 
  * @author little-pan
@@ -47,7 +49,8 @@ public ShowStatusStatement(String sql) {
     @Override
     protected String getSQL(String localSchema) throws SQLException {
         final String f = 
-                "select Mem_Committed, Mem_Max, Mem_Used, "
+                "select Select_Stmts, Update_Stmts, Insert_Stmts, Delete_Stmts, Total_Stmts, Slow_Stmts, "
+                + "Mem_Committed, Mem_Max, Mem_Used, "
                 + "OS_Arch, OS_Name, OS_Version, "
                 + "RT_Name, RT_Start_Time, RT_Uptime, RT_Vendor, RT_Version, "
                 + "Thread_Count, Thread_Daemon_Count, Thread_Peak_Count, Thread_Started_Count, "
@@ -64,9 +67,15 @@ protected void init() throws SQLException {
         String f, sql;
         // CREATE TABLE
         f = "create table if not exists '%s'.%s("
-                + "`Mem_Committed` bigint null,"
-                + "`Mem_Max` bigint not null,"
-                + "`Mem_Used` bigint not null,"
+                + "`Select_Stmts` bigint,"
+                + "`Update_Stmts` bigint,"
+                + "`Insert_Stmts` bigint,"
+                + "`Delete_Stmts` bigint,"
+                + "`Total_Stmts` bigint,"
+                + "`Slow_Stmts` bigint,"
+                + "`Mem_Committed` bigint,"
+                + "`Mem_Max` bigint,"
+                + "`Mem_Used` bigint,"
                 + "`OS_Arch` varchar(80),"
                 + "`OS_Name` varchar(64),"
                 + "`OS_Version` varchar(64),"
@@ -96,12 +105,15 @@ public void preExecute(int maxRows) throws SQLException, IllegalStateException {
         
         // Collect processor state
         SQLiteProcessor processor = super.getContext();
+        SQLiteServer server = processor.getServer();
         // INSERT new data for query
-        f = "insert into '%s'.%s(`Mem_Committed`, `Mem_Max`, `Mem_Used`, `OS_Arch`, `OS_Name`, `OS_Version`, "
+        f = "insert into '%s'.%s(`Select_Stmts`, `Update_Stmts`, `Insert_Stmts`, `Delete_Stmts`, "
+                + "`Total_Stmts`, `Slow_Stmts`,"
+                + "`Mem_Committed`, `Mem_Max`, `Mem_Used`, `OS_Arch`, `OS_Name`, `OS_Version`, "
                 + "`RT_Name`, `RT_Start_Time`, `RT_Uptime`, `RT_Vendor`, `RT_Version`, "
                 + "`Thread_Count`, `Thread_Daemon_Count`, `Thread_Peak_Count`, `Thread_Started_Count`, "
                 + "`Sys_Load_Average`)"
-                + "values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+                + "values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
         sql = format(f, localSchema, TBL_NAME);
         try (PreparedStatement ps = processor.getConnection().prepareStatement(sql)) {
             MemoryMXBean memMxBean = ManagementFactory.getMemoryMXBean();
@@ -114,6 +126,15 @@ public void preExecute(int maxRows) throws SQLException, IllegalStateException {
             int i = 0;
             long v = -1;
             
+            // SQL metric
+            SQLMetric sqlMetric = server.getSQLMetric();
+            ps.setLong(++i, sqlMetric.selectStmts);
+            ps.setLong(++i, sqlMetric.updateStmts);
+            ps.setLong(++i, sqlMetric.insertStmts);
+            ps.setLong(++i, sqlMetric.deleteStmts);
+            ps.setLong(++i, sqlMetric.totalStmts);
+            ps.setLong(++i, sqlMetric.slowStmts);
+            
             // Memory committed
             if (heapMemUsage.getCommitted() > 0) {
                 v  = heapMemUsage.getCommitted();
diff --git a/src/main/java/org/sqlite/sql/SQLContext.java b/src/main/java/org/sqlite/sql/SQLContext.java
@@ -112,5 +112,9 @@ public void setTransaction(Transaction transaction) throws IllegalStateException
     public abstract String getDbName();
     
     public abstract File getDataDir();
+
+    protected abstract void preExecute(SQLStatement s);
+    
+    protected abstract void postExecute(SQLStatement s);
     
 }
diff --git a/src/main/java/org/sqlite/sql/SQLStatement.java b/src/main/java/org/sqlite/sql/SQLStatement.java
@@ -220,19 +220,24 @@ protected boolean doExecute(int maxRows) throws SQLException {
         }
         
         context.trace(log, "execute sql \"{}\"", this);
-        if (this.prepared) {
-            // Execute batch prepared statement in an implicit transaction for ACID
-            if (shouldBeginImplicitTx(autoCommit, writable)) {
-                execute("begin immediate");
-                Transaction tx = new Transaction(context, true);
-                context.setTransaction(tx);
-                context.trace(log, "tx: begin an implicit {}", tx);
+        context.preExecute(this);
+        try {
+            if (this.prepared) {
+                // Execute batch prepared statement in an implicit transaction for ACID
+                if (shouldBeginImplicitTx(autoCommit, writable)) {
+                    execute("begin immediate");
+                    Transaction tx = new Transaction(context, true);
+                    context.setTransaction(tx);
+                    context.trace(log, "tx: begin an implicit {}", tx);
+                }
+                PreparedStatement ps = getPreparedStatement();
+                resultSet = ps.execute();
+            } else {
+                String sql = getExecutableSQL();
+                resultSet = this.jdbcStatement.execute(sql);
             }
-            PreparedStatement ps = getPreparedStatement();
-            resultSet = ps.execute();
-        } else {
-            String sql = getExecutableSQL();
-            resultSet = this.jdbcStatement.execute(sql);
+        } finally {
+            context.postExecute(this);
         }
         
         final Transaction tx = context.getTransaction();

Original file line number	Diff line number	Diff line change
`@@ -112,5 +112,9 @@ public void setTransaction(Transaction transaction) throws IllegalStateException`
`112`	`112`	`public abstract String getDbName();`
`113`	`113`
`114`	`114`	`public abstract File getDataDir();`
	`115`	`+`
	`116`	`+ protected abstract void preExecute(SQLStatement s);`
	`117`	`+`
	`118`	`+ protected abstract void postExecute(SQLStatement s);`
`115`	`119`
`116`	`120`	`}`