fix(dialect): support sqlite database version diagnostics

gqcn · gqcn · commit 768cf2770d4a · 2026-05-08T15:43:42.000+08:00
diff --git a/apps/lina-core/internal/service/sysinfo/sysinfo.go b/apps/lina-core/internal/service/sysinfo/sysinfo.go
@@ -13,6 +13,7 @@ import (
 
 	"lina-core/internal/service/cachecoord"
 	"lina-core/internal/service/config"
+	"lina-core/pkg/dialect"
 	"lina-core/pkg/logger"
 )
 
@@ -227,9 +228,5 @@ func (s *serviceImpl) loadComponents(metadata *config.MetadataConfig, sectionKey
 
 // getDbVersion retrieves the database version.
 func (s *serviceImpl) getDbVersion(ctx context.Context) (string, error) {
-	result, err := g.DB().GetValue(ctx, "SELECT VERSION()")
-	if err != nil {
-		return "", err
-	}
-	return result.String(), nil
+	return dialect.DatabaseVersion(ctx, g.DB())
 }
diff --git a/apps/lina-core/internal/service/sysinfo/sysinfo_test.go b/apps/lina-core/internal/service/sysinfo/sysinfo_test.go
@@ -5,15 +5,28 @@ package sysinfo
 import (
 	"context"
 	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
+	_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+
 	"lina-core/internal/service/cachecoord"
 )
 
 const (
 	// testRuntimeConfigDomain is the sysinfo test projection domain.
 	testRuntimeConfigDomain cachecoord.Domain = "runtime-config"
+	// sqliteSysInfoChildEnv marks the isolated child process that owns
+	// GoFrame's global SQLite database configuration.
+	sqliteSysInfoChildEnv = "LINA_SQLITE_SYSINFO_CHILD"
+	// sqliteSysInfoDBEnv stores the temporary SQLite path for the child test.
+	sqliteSysInfoDBEnv = "LINA_SQLITE_SYSINFO_DB"
 )
 
 // fakeCacheCoordService provides deterministic cachecoord snapshots for
@@ -119,3 +132,60 @@ func TestLoadCacheCoordinationToleratesSnapshotFailure(t *testing.T) {
 		t.Fatalf("expected empty diagnostics after snapshot failure, got %#v", items)
 	}
 }
+
+// TestGetDbVersionSupportsSQLite verifies sysinfo does not use MySQL-only
+// VERSION() diagnostics against SQLite databases.
+func TestGetDbVersionSupportsSQLite(t *testing.T) {
+	if os.Getenv(sqliteSysInfoChildEnv) == "1" {
+		t.Skip("parent test only launches the isolated SQLite child process")
+	}
+
+	dbPath := filepath.Join(t.TempDir(), "sysinfo.db")
+	cmd := exec.Command(os.Args[0], "-test.run=^TestGetDbVersionSupportsSQLiteChild$", "-test.count=1", "-test.v")
+	cmd.Env = append(os.Environ(),
+		sqliteSysInfoChildEnv+"=1",
+		sqliteSysInfoDBEnv+"="+dbPath,
+	)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("SQLite sysinfo child test failed: %v\n%s", err, string(output))
+	}
+}
+
+// TestGetDbVersionSupportsSQLiteChild runs the actual SQLite sysinfo
+// diagnostic check in an isolated process because GoFrame database config is
+// global.
+func TestGetDbVersionSupportsSQLiteChild(t *testing.T) {
+	if os.Getenv(sqliteSysInfoChildEnv) != "1" {
+		t.Skip("SQLite sysinfo child test is executed by TestGetDbVersionSupportsSQLite")
+	}
+
+	ctx := context.Background()
+	dbPath := os.Getenv(sqliteSysInfoDBEnv)
+	if dbPath == "" {
+		t.Fatalf("%s must be set", sqliteSysInfoDBEnv)
+	}
+	link := "sqlite::@file(" + dbPath + ")"
+	if err := gdb.SetConfig(gdb.Config{
+		gdb.DefaultGroupName: gdb.ConfigGroup{{Link: link}},
+	}); err != nil {
+		t.Fatalf("configure SQLite sysinfo database failed: %v", err)
+	}
+	t.Cleanup(func() {
+		if closeErr := g.DB().Close(ctx); closeErr != nil {
+			t.Errorf("close SQLite sysinfo database failed: %v", closeErr)
+		}
+	})
+
+	service := &serviceImpl{}
+	version, err := service.getDbVersion(ctx)
+	if err != nil {
+		t.Fatalf("get SQLite sysinfo database version failed: %v", err)
+	}
+	if !strings.HasPrefix(version, "SQLite ") {
+		t.Fatalf("expected SQLite version label, got %q", version)
+	}
+	if strings.TrimSpace(strings.TrimPrefix(version, "SQLite ")) == "" {
+		t.Fatalf("expected SQLite version number to be non-empty, got %q", version)
+	}
+}
diff --git a/apps/lina-core/pkg/dialect/dialect.go b/apps/lina-core/pkg/dialect/dialect.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"strings"
 
+	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/errors/gcode"
 
 	"lina-core/pkg/bizerr"
@@ -48,6 +49,8 @@ type Dialect interface {
 	// SupportsCluster reports whether this database can back multi-node
 	// coordination state.
 	SupportsCluster() bool
+	// DatabaseVersion returns a display-ready database engine and version label.
+	DatabaseVersion(ctx context.Context, db gdb.DB) (string, error)
 	// OnStartup applies dialect-specific runtime bootstrap behavior before
 	// cluster services start.
 	OnStartup(ctx context.Context, runtime RuntimeConfig) error
@@ -81,6 +84,30 @@ func From(link string) (Dialect, error) {
 	}
 }
 
+// FromDatabase resolves one database dialect from the active GoFrame database
+// configuration.
+func FromDatabase(db gdb.DB) (Dialect, error) {
+	link := ""
+	if db != nil && db.GetConfig() != nil {
+		configNode := db.GetConfig()
+		link = strings.TrimSpace(configNode.Link)
+		if link == "" && strings.TrimSpace(configNode.Type) != "" {
+			link = strings.TrimSpace(configNode.Type) + ":"
+		}
+	}
+	return From(link)
+}
+
+// DatabaseVersion returns a display-ready database engine and version label for
+// the active GoFrame database.
+func DatabaseVersion(ctx context.Context, db gdb.DB) (string, error) {
+	dbDialect, err := FromDatabase(db)
+	if err != nil {
+		return "", err
+	}
+	return dbDialect.DatabaseVersion(ctx, db)
+}
+
 // mysqlDialect is the public package wrapper for the internal MySQL dialect.
 type mysqlDialect struct{}
 
@@ -104,6 +131,11 @@ func (mysqlDialect) SupportsCluster() bool {
 	return internalmysql.SupportsCluster()
 }
 
+// DatabaseVersion returns the MySQL server version label.
+func (mysqlDialect) DatabaseVersion(ctx context.Context, db gdb.DB) (string, error) {
+	return internalmysql.DatabaseVersion(ctx, db)
+}
+
 // OnStartup has no MySQL-specific startup side effects.
 func (mysqlDialect) OnStartup(ctx context.Context, runtime RuntimeConfig) error {
 	return nil
@@ -134,6 +166,11 @@ func (sqliteDialect) SupportsCluster() bool {
 	return internalsqlite.SupportsCluster()
 }
 
+// DatabaseVersion returns the SQLite library version label.
+func (sqliteDialect) DatabaseVersion(ctx context.Context, db gdb.DB) (string, error) {
+	return internalsqlite.DatabaseVersion(ctx, db)
+}
+
 // OnStartup applies SQLite-specific startup behavior before cluster services start.
 func (d sqliteDialect) OnStartup(ctx context.Context, runtime RuntimeConfig) error {
 	return internalsqlite.OnStartup(ctx, d.link, runtime)
diff --git a/apps/lina-core/pkg/dialect/dialect_sqlite_test.go b/apps/lina-core/pkg/dialect/dialect_sqlite_test.go
@@ -4,9 +4,12 @@ package dialect
 
 import (
 	"context"
+	"path/filepath"
 	"strings"
 	"testing"
 
+	_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
+	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/os/glog"
 
 	"lina-core/pkg/logger"
@@ -80,6 +83,33 @@ func TestSQLiteOnStartupOverridesCluster(t *testing.T) {
 	}
 }
 
+// TestSQLiteDatabaseVersionUsesSQLiteFunction verifies version diagnostics do
+// not call the MySQL-only VERSION() function on SQLite connections.
+func TestSQLiteDatabaseVersionUsesSQLiteFunction(t *testing.T) {
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "version.db")
+	db, err := gdb.New(gdb.ConfigNode{Link: "sqlite::@file(" + dbPath + ")"})
+	if err != nil {
+		t.Fatalf("open SQLite database failed: %v", err)
+	}
+	t.Cleanup(func() {
+		if closeErr := db.Close(ctx); closeErr != nil {
+			t.Errorf("close SQLite database failed: %v", closeErr)
+		}
+	})
+
+	version, err := DatabaseVersion(ctx, db)
+	if err != nil {
+		t.Fatalf("query SQLite database version failed: %v", err)
+	}
+	if !strings.HasPrefix(version, "SQLite ") {
+		t.Fatalf("expected SQLite version label, got %q", version)
+	}
+	if strings.TrimSpace(strings.TrimPrefix(version, "SQLite ")) == "" {
+		t.Fatalf("expected SQLite version number to be non-empty, got %q", version)
+	}
+}
+
 // containsAnyMessage reports whether one captured message contains a substring.
 func containsAnyMessage(messages []string, needle string) bool {
 	for _, message := range messages {
diff --git a/apps/lina-core/pkg/dialect/internal/mysql/dialect.go b/apps/lina-core/pkg/dialect/internal/mysql/dialect.go
@@ -66,6 +66,18 @@ func SupportsCluster() bool {
 	return true
 }
 
+// DatabaseVersion returns the MySQL server version label.
+func DatabaseVersion(ctx context.Context, db gdb.DB) (string, error) {
+	if db == nil {
+		return "", gerror.New("database connection is required")
+	}
+	result, err := db.GetValue(ctx, "SELECT VERSION()")
+	if err != nil {
+		return "", err
+	}
+	return "MySQL " + strings.TrimSpace(result.String()), nil
+}
+
 // ConfigNodeFromLink returns the GoFrame-parsed MySQL configuration node.
 func ConfigNodeFromLink(link string) (*gdb.ConfigNode, error) {
 	db, err := gdb.New(gdb.ConfigNode{Link: link})
diff --git a/apps/lina-core/pkg/dialect/internal/sqlite/dialect.go b/apps/lina-core/pkg/dialect/internal/sqlite/dialect.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/os/gfile"
 
@@ -64,6 +65,18 @@ func SupportsCluster() bool {
 	return false
 }
 
+// DatabaseVersion returns the SQLite library version label.
+func DatabaseVersion(ctx context.Context, db gdb.DB) (string, error) {
+	if db == nil {
+		return "", gerror.New("database connection is required")
+	}
+	result, err := db.GetValue(ctx, "SELECT sqlite_version()")
+	if err != nil {
+		return "", err
+	}
+	return "SQLite " + strings.TrimSpace(result.String()), nil
+}
+
 // OnStartup locks cluster mode off and prints prominent warnings for SQLite.
 func OnStartup(ctx context.Context, link string, runtime StartupRuntime) error {
 	if runtime != nil {
diff --git a/apps/lina-plugins/monitor-server/backend/internal/service/monitor/monitor.go b/apps/lina-plugins/monitor-server/backend/internal/service/monitor/monitor.go
@@ -22,6 +22,7 @@ import (
 	netutil "github.com/shirou/gopsutil/v4/net"
 	"github.com/shirou/gopsutil/v4/process"
 
+	"lina-core/pkg/dialect"
 	"lina-core/pkg/logger"
 	"lina-plugin-monitor-server/backend/internal/dao"
 	"lina-plugin-monitor-server/backend/internal/model/do"
@@ -200,8 +201,12 @@ func (s *serviceImpl) Collect(ctx context.Context) *MonitorData {
 // GetDBInfo collects database metrics on demand.
 func (s *serviceImpl) GetDBInfo(ctx context.Context) *DBInfo {
 	info := &DBInfo{}
-	if value, err := g.DB().GetValue(ctx, "SELECT VERSION()"); err == nil {
-		info.Version = value.String()
+	dbVersion, err := dialect.DatabaseVersion(ctx, g.DB())
+	if err != nil {
+		logger.Warningf(ctx, "collect database version failed: %v", err)
+		info.Version = "unknown"
+	} else {
+		info.Version = dbVersion
 	}
 	statsItems := g.DB().GetCore().Stats(ctx)
 	if len(statsItems) > 0 {
diff --git a/apps/lina-plugins/monitor-server/backend/internal/service/monitor/monitor_upsert_test.go b/apps/lina-plugins/monitor-server/backend/internal/service/monitor/monitor_upsert_test.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
@@ -56,6 +57,25 @@ func TestUpsertMonitorSnapshotWorksOnSQLite(t *testing.T) {
 	}
 }
 
+// TestGetDBInfoReturnsSQLiteVersion verifies monitor-server database
+// diagnostics return a non-empty SQLite version label instead of silently
+// swallowing the MySQL-only VERSION() failure.
+func TestGetDBInfoReturnsSQLiteVersion(t *testing.T) {
+	ctx := context.Background()
+	setupSQLiteMonitorServerDB(t, ctx)
+
+	info := New().GetDBInfo(ctx)
+	if info == nil {
+		t.Fatal("expected SQLite DB info to be returned")
+	}
+	if !strings.HasPrefix(info.Version, "SQLite ") {
+		t.Fatalf("expected SQLite database version label, got %q", info.Version)
+	}
+	if strings.TrimSpace(strings.TrimPrefix(info.Version, "SQLite ")) == "" {
+		t.Fatalf("expected SQLite database version number to be non-empty, got %q", info.Version)
+	}
+}
+
 // setupSQLiteMonitorServerDB points the generated DAO at a temporary SQLite
 // database and creates the monitor-server table.
 func setupSQLiteMonitorServerDB(t *testing.T, ctx context.Context) {
diff --git a/hack/tests/e2e/dialect/TC0165-sqlite-mode-business-zero-impact.ts b/hack/tests/e2e/dialect/TC0165-sqlite-mode-business-zero-impact.ts
@@ -24,10 +24,16 @@ type UserCreateResult = {
   id: number;
 };
 
+type ServerMonitorResult = {
+  dbInfo?: {
+    version?: string;
+  };
+};
+
 test.describe("TC-165 SQLite mode business zero impact", () => {
   requireSQLiteE2E();
 
-  test("TC-165a~c: user CRUD, execution log list, and source plugin lifecycle work on SQLite", async () => {
+  test("TC-165a~d: user CRUD, execution log list, source plugin lifecycle, and monitor database version work on SQLite", async () => {
     const api = await createAdminApiContext();
     const username = `sqlite_e2e_${Date.now()}`;
     let createdUserId = 0;
@@ -99,6 +105,12 @@ test.describe("TC-165 SQLite mode business zero impact", () => {
       expect(plugin?.installed).toBe(1);
       expect(plugin?.enabled).toBe(1);
 
+      const monitor = await expectApiSuccess<ServerMonitorResult>(
+        await api.get("monitor/server"),
+        "query server monitor in SQLite mode",
+      );
+      expect(monitor.dbInfo?.version ?? "").toMatch(/^SQLite\s+\S+/);
+
       await updatePluginStatus(api, sqliteSourcePluginId, false);
       plugin = await findPlugin(api, sqliteSourcePluginId);
       expect(plugin?.enabled).toBe(0);
diff --git a/openspec/changes/sqlite-database-support/specs/database-dialect-abstraction/spec.md b/openspec/changes/sqlite-database-support/specs/database-dialect-abstraction/spec.md
@@ -2,15 +2,15 @@
 
 ### Requirement: 宿主必须通过统一的方言抽象层收敛数据库引擎差异
 
-系统 SHALL 在 `apps/lina-core/pkg/dialect/` 提供公共稳定的 `Dialect` 接口与方言辅助能力作为数据库引擎差异的唯一收敛点。所有数据库引擎相关的差异化行为（DDL 转译、数据库准备、集群能力查询、启动期钩子、驱动错误分类）必须通过该包暴露，业务模块（`controller` / `service` / `model` / `dao`）不得在自身代码路径中出现 `if isMySQL / if isSQLite` 等数据库引擎判断。`pkg/dialect` 的公开签名 SHALL 只依赖稳定窄接口，不得暴露宿主 `internal` 包中的具体服务类型，也不得导出 MySQL / SQLite 方言具体实现类型；具体方言实现应收敛在 `pkg/dialect/internal/mysql`、`pkg/dialect/internal/sqlite` 等内部子包中，由公共工厂与公共门面能力统一委托。
+系统 SHALL 在 `apps/lina-core/pkg/dialect/` 提供公共稳定的 `Dialect` 接口与方言辅助能力作为数据库引擎差异的唯一收敛点。所有数据库引擎相关的差异化行为（DDL 转译、数据库准备、集群能力查询、启动期钩子、驱动错误分类、数据库版本查询）必须通过该包暴露，业务模块（`controller` / `service` / `model` / `dao`）不得在自身代码路径中出现 `if isMySQL / if isSQLite` 等数据库引擎判断。`pkg/dialect` 的公开签名 SHALL 只依赖稳定窄接口，不得暴露宿主 `internal` 包中的具体服务类型，也不得导出 MySQL / SQLite 方言具体实现类型；具体方言实现应收敛在 `pkg/dialect/internal/mysql`、`pkg/dialect/internal/sqlite` 等内部子包中，由公共工厂与公共门面能力统一委托。
 
 #### Scenario: 业务模块不感知数据库引擎差异
 - **当** 业务模块（如 `user` / `role` / `dict` / `kvcache` / `locker`）通过 DAO 层执行查询、写入、更新、删除操作时
 - **则** 业务代码不包含针对数据库引擎的分支判断
 - **且** 同一份业务代码在 MySQL 和 SQLite 两种引擎下行为一致
 
 #### Scenario: 所有方言相关行为通过 Dialect 接口暴露
-- **当** 宿主需要执行"DDL 转译 / 数据库准备 / 集群能力查询 / 启动期钩子"中的任一行为时
+- **当** 宿主需要执行"DDL 转译 / 数据库准备 / 集群能力查询 / 启动期钩子 / 数据库版本查询"中的任一行为时
 - **则** 调用方通过 `dialect.From(link)` 获取当前方言实例
 - **且** 调用方仅依赖 `Dialect` 接口的方法签名，不依赖具体实现的内部细节
 
@@ -26,6 +26,14 @@
 - **且** 调用方不得硬编码 MySQL / SQLite 错误文案、错误码或具体驱动错误类型
 - **且** `pkg/dialect` 使用驱动暴露的结构化错误码进行分类，错误文案匹配最多只能作为方言包内部的显式兜底
 
+#### Scenario: 数据库版本查询由 dialect 公共包提供
+- **当** 宿主系统信息或 `monitor-server` 服务监控需要展示数据库版本时
+- **则** 调用方通过 `dialect.DatabaseVersion(ctx, db)` 或等价 `Dialect` 方法查询
+- **且** MySQL 方言使用 MySQL 可执行的版本查询语句
+- **且** SQLite 方言使用 SQLite 可执行的版本查询语句
+- **且** SQLite 模式下不得执行 `SELECT VERSION()` 或因为缺少 `VERSION()` 函数而返回空版本
+- **且** 返回给页面的版本文本必须包含数据库引擎名称与非空版本号
+
 #### Scenario: dialect 公共包不暴露宿主 internal 具体类型
 - **当** 插件生命周期、初始化命令或工具链代码导入 `apps/lina-core/pkg/dialect` 时
 - **则** 公开接口不要求调用方引用 `apps/lina-core/internal/...` 下的具体服务类型
diff --git a/openspec/changes/sqlite-database-support/tasks.md b/openspec/changes/sqlite-database-support/tasks.md
