* db: removed mysql sslmode property, SSL mode will be detected by driver automatically

* db: actively inspect query plan once every 24 hours
    > via `explain`, support both MySQL and PostgreSQL, table scan more than 2000 rows is considered inefficient
    > removed Database.suppressSlowSQLWarning(false);
    > removed old error code `SLOW_SQL`, replaced with `INEFFICIENT_QUERY`
    > print query plan if SLOW_DB
* log: make ActionLogContext.track() return void

Signed-off-by: neo <1100909+neowu@users.noreply.github.com>

Author: neowu

CHANGELOG.md

@@ -1,8 +1,15 @@
 ## Change log
 
-### 9.3.2 ( - )
+### 9.4.0-b0 (1/26/26 - )
 
 * log: for rust version of log-processor/log-collector/log-exporter, refer to https://github.com/neowu/core_rs_workspace
+* db: removed mysql sslmode property, SSL mode will be detected by driver automatically
+* db: actively inspect query plan once every 24 hours
+  > via `explain`, support both MySQL and PostgreSQL, table scan more than 2000 rows is considered inefficient
+  > removed Database.suppressSlowSQLWarning(false);
+  > removed old error code `SLOW_SQL`, replaced with `INEFFICIENT_QUERY`
+  > print query plan if SLOW_DB
+* log: make ActionLogContext.track() return void
 
 ### 9.3.1 (10/8/2025 - 11/7/2025)
 

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 
 subprojects {
     group = "core.framework"
-    version = "9.3.1"
+    version = "9.4.0-b0"
     repositories {
         maven {
             url = uri("https://neowu.github.io/maven-repo/")

core-ng/src/main/java/core/framework/db/Database.java

@@ -1,35 +1,12 @@
 package core.framework.db;
 
-import core.framework.internal.log.ActionLog;
-import core.framework.internal.log.LogManager;
-
 import java.util.List;
 import java.util.Optional;
 
 /**
  * @author neo
  */
 public interface Database {
-    /**
-     * for expected slow sql, such as query with small table or db chooses different query plan,
-     * disable warning then enable after<p>
-     * e.g.
-     * <blockquote><pre>
-     * Database.suppressSlowSQLWarning(false);
-     * database.select(...);
-     * Database.suppressSlowSQLWarning(true);
-     * </pre></blockquote>
-     *
-     * @param suppress whether suppress slow sql warning
-     */
-    static void suppressSlowSQLWarning(boolean suppress) {
-        // pass flag thru thread local to MySQLQueryInterceptor, and put in action log to reset for every action
-        ActionLog actionLog = LogManager.currentActionLog();
-        if (actionLog != null) {
-            actionLog.warningContext.suppressSlowSQLWarning = suppress;
-        }
-    }
-
     <T> List<T> select(String sql, Class<T> viewClass, Object... params);
 
     <T> Optional<T> selectOne(String sql, Class<T> viewClass, Object... params);

core-ng/src/main/java/core/framework/db/QueryDiagnostic.java

@@ -7,10 +7,13 @@
 import core.framework.db.Repository;
 import core.framework.db.Transaction;
 import core.framework.db.UncheckedSQLException;
+import core.framework.internal.db.inspector.MySQLQueryAnalyzer;
+import core.framework.internal.db.inspector.PostgreSQLQueryAnalyzer;
+import core.framework.internal.db.inspector.QueryInspector;
 import core.framework.internal.log.ActionLog;
 import core.framework.internal.log.LogManager;
+import core.framework.internal.log.TrackResult;
 import core.framework.internal.resource.Pool;
-import core.framework.util.ASCII;
 import core.framework.util.StopWatch;
 import org.jspecify.annotations.Nullable;
 import org.slf4j.Logger;
@@ -57,6 +60,7 @@ public final class DatabaseImpl implements Database {
     private @Nullable Properties driverProperties;
     private Duration timeout;
     private Driver driver;
+    private QueryInspector inspector;
 
     public DatabaseImpl(String name) {
         initializeRowMappers();
@@ -130,17 +134,12 @@ Properties driverProperties(String url) {
             properties.setProperty("logger", "Slf4JLogger");
             properties.setProperty("cachePrepStmts", "true");
 
-            int index = url.indexOf('?');
-            // mysql with ssl has overhead, usually we ensure security on arch level, e.g. gcloud sql proxy or firewall rule
-            // with gcloud/azure iam / clear_text_password plugin, ssl is required
-            // refer to https://cloud.google.com/sql/docs/mysql/authentication
+            // with gcloud/azure iam / clear_text_password plugin, ssl is required, refer to https://cloud.google.com/sql/docs/mysql/authentication
             if (authProvider != null) {
-                properties.setProperty("sslMode", "PREFERRED");
                 properties.setProperty(CloudAuthProvider.Provider.CLOUD_AUTH, "true");
-            } else if (index == -1 || url.indexOf("sslMode=", index + 1) == -1) {
-                properties.setProperty("sslMode", "DISABLED");
             }
             // refer to https://dev.mysql.com/doc/connector-j/en/connector-j-reference-charsets.html
+            int index = url.indexOf('?');
             if (index == -1 || url.indexOf("characterEncoding=", index + 1) == -1)
                 properties.setProperty("characterEncoding", "utf-8");
         } else if (url.startsWith("jdbc:postgresql:")) {
@@ -175,12 +174,15 @@ public void url(String url) {
     private Driver driver(String url) {
         if (url.startsWith("jdbc:mysql:")) {
             operation.dialect = Dialect.MYSQL;
+            inspector = new QueryInspector(new MySQLQueryAnalyzer(operation));
             return createDriver("com.mysql.cj.jdbc.Driver");
         } else if (url.startsWith("jdbc:postgresql:")) {
             operation.dialect = Dialect.POSTGRESQL;
+            inspector = new QueryInspector(new PostgreSQLQueryAnalyzer(operation));
             return createDriver("org.postgresql.Driver");
         } else if (url.startsWith("jdbc:hsqldb:")) {
             operation.dialect = Dialect.MYSQL;    // unit test use mysql dialect
+            inspector = new QueryInspector(null);
             return createDriver("org.hsqldb.jdbc.JDBCDriver");
         } else {
             throw new Error("not supported database, url=" + url);
@@ -224,7 +226,8 @@ public Transaction beginTransaction() {
     @Override
     public <T> List<T> select(String sql, Class<T> viewClass, Object... params) {
         var watch = new StopWatch();
-        validateSQL(sql);
+        inspector.inspect(sql, params);
+
         int returnedRows = 0;
         try {
             List<T> results = operation.select(sql, rowMapper(viewClass), params);
@@ -233,14 +236,19 @@ public <T> List<T> select(String sql, Class<T> viewClass, Object... params) {
         } finally {
             long elapsed = watch.elapsed();
             logger.debug("select, sql={}, params={}, returnedRows={}, elapsed={}", sql, new SQLParams(operation.enumMapper, params), returnedRows, elapsed);
-            track(elapsed, returnedRows, 0, 1);   // check after sql debug log, to make log easier to read
+            boolean slow = track(elapsed, returnedRows, 0, 1);   // check after sql debug log, to make log easier to read
+            if (slow) {
+                String plan = inspector.explain(sql, params);
+                logger.debug("plan=\n{}", plan);
+            }
         }
     }
 
     @Override
     public <T> Optional<T> selectOne(String sql, Class<T> viewClass, Object... params) {
         var watch = new StopWatch();
-        validateSQL(sql);
+        inspector.inspect(sql, params);
+
         int returnedRows = 0;
         try {
             Optional<T> result = operation.selectOne(sql, rowMapper(viewClass), params);
@@ -249,14 +257,19 @@ public <T> Optional<T> selectOne(String sql, Class<T> viewClass, Object... param
         } finally {
             long elapsed = watch.elapsed();
             logger.debug("selectOne, sql={}, params={}, returnedRows={}, elapsed={}", sql, new SQLParams(operation.enumMapper, params), returnedRows, elapsed);
-            track(elapsed, returnedRows, 0, 1);
+            boolean slow = track(elapsed, returnedRows, 0, 1);
+            if (slow) {
+                String plan = inspector.explain(sql, params);
+                logger.debug("plan=\n{}", plan);
+            }
         }
     }
 
     @Override
     public int execute(String sql, Object... params) {
         var watch = new StopWatch();
-        validateSQL(sql);
+        inspector.inspect(sql, params);
+
         int affectedRows = 0;
         try {
             affectedRows = operation.update(sql, params);
@@ -271,8 +284,9 @@ public int execute(String sql, Object... params) {
     @Override
     public int[] batchExecute(String sql, List<Object[]> params) {
         var watch = new StopWatch();
-        validateSQL(sql);
         if (params.isEmpty()) throw new Error("params must not be empty");
+        inspector.inspect(sql, params.getFirst());
+
         int affectedRows = 0;
         try {
             int[] results = operation.batchUpdate(sql, params);
@@ -307,39 +321,14 @@ private <T> void registerViewClass(Class<T> viewClass) {
         rowMappers.put(viewClass, mapper);
     }
 
-    void track(long elapsed, int readRows, int writeRows, int queries) {
+    // return if slow
+    boolean track(long elapsed, int readRows, int writeRows, int queries) {
         ActionLog actionLog = LogManager.currentActionLog();
         if (actionLog != null) {
             actionLog.stats.compute("db_queries", (k, oldValue) -> (oldValue == null) ? queries : oldValue + queries);
-            actionLog.track("db", elapsed, readRows, writeRows, 0, 0);
-        }
-    }
-
-    void validateSQL(String sql) {
-        if (sql.startsWith("CREATE ")) return;  // ignore DDL
-
-        // validate asterisk
-        // execute() could have select part, e.g. insert into select
-        int index = sql.indexOf('*');
-        while (index > -1) {   // check whether it's wildcard or multiply operator
-            int length = sql.length();
-            char ch = 0;
-            index++;
-            for (; index < length; index++) {
-                ch = sql.charAt(index);
-                if (ch != ' ') break;   // seek to next non-whitespace
-            }
-            if (ch == ','
-                || index == length  // sql ends with *
-                || index + 4 <= length && ASCII.toUpperCase(ch) == 'F' && "FROM".equals(ASCII.toUpperCase(sql.substring(index, index + 4))))
-                throw new Error("sql must not contain wildcard(*), please only select columns needed, sql=" + sql);
-            index = sql.indexOf('*', index + 1);
+            TrackResult result = actionLog.track("db", elapsed, readRows, writeRows, 0, 0);
+            return result.slow();
         }
-
-        // validate string value
-        // by this way, it also disallows functions with string values, e.g. IFNULL(column, 'value'), but it usually can be prevented by different design,
-        // and we prefer to simplify db usage if possible, and shift complexity to application layer
-        if (sql.indexOf('\'') != -1)
-            throw new Error("sql must not contain single quote('), please use prepared statement and question mark(?), sql=" + sql);
+        return false;
     }
 }

core-ng/src/main/java/core/framework/internal/db/DatabaseImpl.java

@@ -1,15 +1,10 @@
 package core.framework.internal.db;
 
 import core.framework.db.Dialect;
-import core.framework.db.QueryDiagnostic;
 import core.framework.db.UncheckedSQLException;
-import core.framework.internal.log.ActionLog;
-import core.framework.internal.log.LogManager;
 import core.framework.internal.resource.PoolItem;
 import core.framework.util.Lists;
 import org.jspecify.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.math.BigDecimal;
 import java.sql.Connection;
@@ -26,15 +21,13 @@
 import java.util.OptionalLong;
 import java.util.UUID;
 
-import static core.framework.log.Markers.errorCode;
 import static core.framework.util.Strings.format;
 
 /**
  * @author neo
  */
 public class DatabaseOperation {
     final EnumDBMapper enumMapper = new EnumDBMapper();
-    private final Logger logger = LoggerFactory.getLogger(DatabaseOperation.class);
     private final TransactionManager transactionManager;
     Dialect dialect;
     int queryTimeoutInSeconds;
@@ -50,9 +43,7 @@ int update(String sql, Object... params) {
         try (PreparedStatement statement = connection.resource.prepareStatement(sql)) {
             statement.setQueryTimeout(queryTimeoutInSeconds);
             setParams(statement, params);
-            int result = statement.executeUpdate();
-            logSlowQuery(statement);
-            return result;
+            return statement.executeUpdate();
         } catch (SQLException e) {
             Connections.checkConnectionState(connection, e);
             throw new UncheckedSQLException(e);
@@ -71,9 +62,7 @@ int[] batchUpdate(String sql, List<Object[]> params) {
                 setParams(statement, batchParams);
                 statement.addBatch();
             }
-            int[] results = statement.executeBatch();
-            logSlowQuery(statement);
-            return results;
+            return statement.executeBatch();
         } catch (SQLException e) {
             Connections.checkConnectionState(connection, e);
             throw new UncheckedSQLException(e);
@@ -96,7 +85,7 @@ <T> Optional<T> selectOne(String sql, RowMapper<T> mapper, Object... params) {
         }
     }
 
-    <T> List<T> select(String sql, RowMapper<T> mapper, Object... params) {
+    public <T> List<T> select(String sql, RowMapper<T> mapper, Object... params) {
         PoolItem<Connection> connection = transactionManager.getConnection();
         try (PreparedStatement statement = connection.resource.prepareStatement(sql)) {
             statement.setQueryTimeout(queryTimeoutInSeconds);
@@ -155,8 +144,6 @@ private PreparedStatement insertStatement(Connection connection, String sql, @Nu
 
     private <T> Optional<T> fetchOne(PreparedStatement statement, RowMapper<T> mapper) throws SQLException {
         try (ResultSet resultSet = statement.executeQuery()) {
-            logSlowQuery(statement);
-
             T result = null;
             if (resultSet.next()) {
                 result = mapper.map(new ResultSetWrapper(resultSet, dialect));
@@ -169,8 +156,6 @@ private <T> Optional<T> fetchOne(PreparedStatement statement, RowMapper<T> mappe
 
     private <T> List<T> fetch(PreparedStatement statement, RowMapper<T> mapper) throws SQLException {
         try (ResultSet resultSet = statement.executeQuery()) {
-            logSlowQuery(statement);
-
             var wrapper = new ResultSetWrapper(resultSet, dialect);
             List<T> results = Lists.newArrayList();
             while (resultSet.next()) {
@@ -266,22 +251,4 @@ private void setParam(PreparedStatement statement, int index, @Nullable Object p
             default -> throw new Error(format("unsupported param type, type={}, value={}", param.getClass().getCanonicalName(), param));
         }
     }
-
-    void logSlowQuery(PreparedStatement statement) {
-        if (statement instanceof QueryDiagnostic diagnostic) {
-            boolean noIndexUsed = diagnostic.noIndexUsed();
-            boolean badIndexUsed = diagnostic.noGoodIndexUsed();
-            if (!noIndexUsed && !badIndexUsed) return;
-
-            ActionLog actionLog = LogManager.currentActionLog();
-            boolean warning = actionLog == null || !actionLog.warningContext.suppressSlowSQLWarning;
-            String message = noIndexUsed ? "no index used" : "bad index used";
-            String sqlValue = diagnostic.sql();
-            if (warning) {
-                logger.warn(errorCode("SLOW_SQL"), "{}, sql={}", message, sqlValue);
-            } else {
-                logger.debug("{}, sql={}", message, sqlValue);
-            }
-        }
-    }
 }