refactor(gdb): use driver dispatch for bool literal and shared-lock clause

Replace two anti-patterns from earlier commits in this PR with the
canonical driver-dispatch pattern already used by OrderRandomFunction:

- gdb_model_soft_time.go: delete boolFalseLiteral() method that branched
  on driver name via switch m.db.GetConfig().Type. Call
  m.db.GetBoolLiteral(false) directly at the two WHERE-builder sites.

- pgsql/gaussdb DoFilter: delete the gstr.Replace that rewrote
  "LOCK IN SHARE MODE" to "FOR SHARE" on every query. Instead, make
  Model.LockShared() call m.db.GetLockSharedClause() so each driver
  emits its own dialect directly — no string munging, no risk of
  corrupting SQL string literals that happen to contain the phrase.

New DB interface methods:
- GetBoolLiteral(v bool) string
- GetLockSharedClause() string

Core provides MySQL-legacy defaults ("0"/"1" and "LOCK IN SHARE MODE"),
so mysql/mariadb/mssql/oracle/dm/sqlite/oceanbase/tidb inherit without
change. pgsql/gaussdb/clickhouse override bool literal to "true"/"false";
pgsql/gaussdb override lock clause to "FOR SHARE".

No behavior change vs. the prior commits — all 560 pgsql tests still pass.

Author: lingcoder

contrib/drivers/clickhouse/clickhouse_dialect.go

@@ -0,0 +1,19 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package clickhouse
+
+// GetBoolLiteral returns the SQL literal for the given boolean value.
+// ClickHouse has a strict Bool type that requires 'true'/'false' literals.
+// GetLockSharedClause is not overridden because ClickHouse does not support
+// row-level locking — queries with lock clauses would fail at the server
+// regardless of which syntax is emitted.
+func (d *Driver) GetBoolLiteral(v bool) string {
+	if v {
+		return "true"
+	}
+	return "false"
+}

contrib/drivers/gaussdb/gaussdb_dialect.go

@@ -0,0 +1,26 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gaussdb
+
+import (
+	"github.com/gogf/gf/v2/database/gdb"
+)
+
+// GetBoolLiteral returns the SQL literal for the given boolean value.
+// GaussDB is PostgreSQL-compatible and uses strict boolean literals.
+func (d *Driver) GetBoolLiteral(v bool) string {
+	if v {
+		return "true"
+	}
+	return "false"
+}
+
+// GetLockSharedClause returns the SQL clause for shared row locks.
+// GaussDB uses "FOR SHARE" instead of MySQL's legacy "LOCK IN SHARE MODE".
+func (d *Driver) GetLockSharedClause() string {
+	return gdb.LockForShare
+}

contrib/drivers/gaussdb/gaussdb_do_filter.go

@@ -56,11 +56,6 @@ func (d *Driver) DoFilter(
 		newSql = "INSERT" + newSql[len(gdb.InsertOperationIgnore):]
 	}
 
-	// Translate MySQL shared lock syntax to GaussDB (PostgreSQL-compatible) syntax.
-	// LockShared() generates "LOCK IN SHARE MODE" which is MySQL-only;
-	// GaussDB uses "FOR SHARE" for the same semantics.
-	newSql = gstr.Replace(newSql, "LOCK IN SHARE MODE", "FOR SHARE")
-
 	newArgs = args
 
 	return d.Core.DoFilter(ctx, link, newSql, newArgs)

contrib/drivers/pgsql/pgsql_dialect.go

@@ -0,0 +1,27 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package pgsql
+
+import (
+	"github.com/gogf/gf/v2/database/gdb"
+)
+
+// GetBoolLiteral returns the SQL literal for the given boolean value.
+// PostgreSQL uses a strict boolean type that requires 'true'/'false' literals,
+// not MySQL's numeric 1/0.
+func (d *Driver) GetBoolLiteral(v bool) string {
+	if v {
+		return "true"
+	}
+	return "false"
+}
+
+// GetLockSharedClause returns the SQL clause for shared row locks.
+// PostgreSQL uses "FOR SHARE" instead of MySQL's legacy "LOCK IN SHARE MODE".
+func (d *Driver) GetLockSharedClause() string {
+	return gdb.LockForShare
+}

contrib/drivers/pgsql/pgsql_do_filter.go

@@ -52,11 +52,6 @@ func (d *Driver) DoFilter(
 		newSql = "INSERT" + newSql[len(gdb.InsertOperationIgnore):] + " ON CONFLICT DO NOTHING"
 	}
 
-	// Translate MySQL shared lock syntax to PostgreSQL syntax.
-	// LockShared() generates "LOCK IN SHARE MODE" which is MySQL-only;
-	// PostgreSQL uses "FOR SHARE" for the same semantics.
-	newSql = gstr.Replace(newSql, "LOCK IN SHARE MODE", "FOR SHARE")
-
 	newArgs = args
 
 	return d.Core.DoFilter(ctx, link, newSql, newArgs)

database/gdb/gdb.go

@@ -345,6 +345,17 @@ type DB interface {
 	// OrderRandomFunction returns the SQL function for random ordering.
 	// The implementation is database-specific (e.g., RAND() for MySQL).
 	OrderRandomFunction() string
+
+	// GetBoolLiteral returns the SQL literal for the given boolean value.
+	// Drivers with strict boolean types (e.g. pgsql, gaussdb, clickhouse)
+	// return "true"/"false"; others return "1"/"0" for bit/int-based
+	// boolean columns.
+	GetBoolLiteral(v bool) string
+
+	// GetLockSharedClause returns the SQL clause emitted by Model.LockShared().
+	// Drivers that don't support MySQL's legacy "LOCK IN SHARE MODE" override
+	// to return their dialect equivalent (e.g. "FOR SHARE" on PostgreSQL).
+	GetLockSharedClause() string
 }
 
 // TX defines the interfaces for ORM transaction operations.

database/gdb/gdb_core_underlying.go

@@ -514,6 +514,22 @@ func (c *Core) OrderRandomFunction() string {
 	return "RAND()"
 }
 
+// GetBoolLiteral returns the SQL literal for the given boolean value.
+// Default is "1"/"0" (MySQL bit/int convention); strict-bool drivers override.
+func (c *Core) GetBoolLiteral(v bool) string {
+	if v {
+		return "1"
+	}
+	return "0"
+}
+
+// GetLockSharedClause returns the SQL clause for Model.LockShared().
+// Default is MySQL's legacy "LOCK IN SHARE MODE"; drivers with other
+// dialect syntax (e.g. PostgreSQL's "FOR SHARE") override.
+func (c *Core) GetLockSharedClause() string {
+	return LockInShareMode
+}
+
 func (c *Core) columnValueToLocalValue(ctx context.Context, value any, columnType *sql.ColumnType) (any, error) {
 	var scanType = columnType.ScanType()
 	if scanType != nil {

database/gdb/gdb_model_lock.go

@@ -120,10 +120,11 @@ func (m *Model) LockUpdateSkipLocked() *Model {
 }
 
 // LockShared sets the lock in share mode for current operation.
-// This is equivalent to Lock("LOCK IN SHARE MODE") for MySQL or Lock("FOR SHARE") for PostgreSQL.
-// Note: For maximum compatibility, this uses MySQL's legacy syntax.
+// The actual clause is dialect-specific and supplied by the driver via
+// GetLockSharedClause() — MySQL emits "LOCK IN SHARE MODE", PostgreSQL/GaussDB
+// emit "FOR SHARE", etc.
 func (m *Model) LockShared() *Model {
 	model := m.getModel()
-	model.lockInfo = LockInShareMode
+	model.lockInfo = m.db.GetLockSharedClause()
 	return model
 }

database/gdb/gdb_model_soft_time.go

@@ -302,7 +302,7 @@ func (m *softTimeMaintainer) buildDeleteCondition(
 		case LocalTypeInt, LocalTypeUint, LocalTypeInt64, LocalTypeUint64:
 			return fmt.Sprintf(`%s=0`, quotedName)
 		case LocalTypeBool:
-			return fmt.Sprintf(`%s=%s`, quotedName, m.boolFalseLiteral())
+			return fmt.Sprintf(`%s=%s`, quotedName, m.db.GetBoolLiteral(false))
 		default:
 			intlog.Errorf(ctx, `invalid field type "%s" for soft delete condition: prefix=%s, field=%s`, fieldType, prefix, fieldName)
 			return ""
@@ -313,24 +313,12 @@ func (m *softTimeMaintainer) buildDeleteCondition(
 
 	default:
 		if fieldType == LocalTypeBool {
-			return fmt.Sprintf(`%s=%s`, quotedName, m.boolFalseLiteral())
+			return fmt.Sprintf(`%s=%s`, quotedName, m.db.GetBoolLiteral(false))
 		}
 		return fmt.Sprintf(`%s=0`, quotedName)
 	}
 }
 
-// boolFalseLiteral returns the SQL literal for boolean false appropriate for the current driver.
-// Drivers with strict boolean types (pgsql, gaussdb, clickhouse) require 'false',
-// while others (mysql, mssql, oracle, dm, etc.) use '0' for bit/int-based boolean columns.
-func (m *softTimeMaintainer) boolFalseLiteral() string {
-	switch m.db.GetConfig().Type {
-	case "pgsql", "gaussdb", "clickhouse":
-		return "false"
-	default:
-		return "0"
-	}
-}
-
 // GetFieldValue generates value for create/update/delete operations.
 func (m *softTimeMaintainer) GetFieldValue(
 	ctx context.Context, fieldType LocalType, isDeleted bool,