chore: use nullBool instead of pointer

core/stores/sqlx/sqlconn.go

@@ -57,8 +57,8 @@ type (
 	}
 
 	logOption struct {
-		EnableStatement *bool
-		EnableSlow      *bool
+		EnableStatement nullBool
+		EnableSlow      nullBool
 	}
 
 	// thread-safe
@@ -430,13 +430,19 @@ func WithAcceptable(acceptable func(err error) bool) SqlOption {
 // WithStatementLog returns a SqlOption to set whether to output SQL statements in the log.
 func WithStatementLog(enable bool) SqlOption {
 	return func(conn *commonSqlConn) {
-		conn.logOption.EnableStatement = &enable
+		conn.logOption.EnableStatement = nullBool{
+			value: enable,
+			valid: true,
+		}
 	}
 }
 
 // WithSlowLog returns a SqlOption to set whether to output slow SQL statements in the log.
 func WithSlowLog(enable bool) SqlOption {
 	return func(conn *commonSqlConn) {
-		conn.logOption.EnableSlow = &enable
+		conn.logOption.EnableSlow = nullBool{
+			value: enable,
+			valid: true,
+		}
 	}
 }

core/stores/sqlx/stmt.go

@@ -112,13 +112,13 @@ type (
 
 func newGuard(logOpt logOption, command string) sqlGuard {
 	logStmt := logStmtSql.True()
-	if logOpt.EnableStatement != nil {
-		logStmt = *logOpt.EnableStatement
+	if logOpt.EnableStatement.valid {
+		logStmt = logOpt.EnableStatement.value
 	}
 
 	logSlow := logSlowSql.True()
-	if logOpt.EnableSlow != nil {
-		logSlow = *logOpt.EnableSlow
+	if logOpt.EnableSlow.valid {
+		logSlow = logOpt.EnableSlow.value
 	}
 
 	if logSlow || logStmt {

core/stores/sqlx/stmt_test.go

@@ -205,33 +205,63 @@ func TestDisableStmtLog(t *testing.T) {
 }
 
 func TestDisableLogContext(t *testing.T) {
-	yes := true
-	no := false
 	t.Run("DisableLog", func(t *testing.T) {
 
+		assert.True(t, logStmtSql.True())
+		assert.True(t, logSlowSql.True())
+		defer func() {
+			logStmtSql.Set(true)
+			logSlowSql.Set(true)
+		}()
+
+		DisableLog()
+		assert.False(t, logStmtSql.True())
+		assert.False(t, logSlowSql.True())
+		guard := newGuard(logOption{}, "any")
+		assert.IsType(t, &nilGuard{}, guard)
+	})
+
+	t.Run("DisableStmtLog", func(t *testing.T) {
+		assert.True(t, logStmtSql.True())
+		assert.True(t, logSlowSql.True())
+		defer func() {
+			logStmtSql.Set(true)
+			logSlowSql.Set(true)
+		}()
+
+		DisableStmtLog()
+		assert.False(t, logStmtSql.True())
+		assert.True(t, logSlowSql.True())
+
+		guard := newGuard(logOption{}, "any")
+		assert.True(t, guard.(*realSqlGuard).slowLog(time.Hour))
+		assert.False(t, guard.(*realSqlGuard).statementLog())
+	})
+
+	t.Run("disable: Statement and Slow ", func(t *testing.T) {
 		guard := newGuard(logOption{
-			EnableStatement: &no,
-			EnableSlow:      &no,
+			EnableStatement: nullBool{valid: true, value: false},
+			EnableSlow:      nullBool{valid: true, value: false},
 		}, "any")
 		assert.IsType(t, &nilGuard{}, guard)
 	})
 
-	t.Run("DisableStatementLog", func(t *testing.T) {
+	t.Run("disable: Statement", func(t *testing.T) {
 		logStmtSql.Set(false)
 		defer logStmtSql.Set(true)
 
 		guard := newGuard(logOption{
-			EnableStatement: &yes,
-			EnableSlow:      &no,
+			EnableStatement: nullBool{valid: true, value: true},
+			EnableSlow:      nullBool{valid: true, value: false},
 		}, "any")
 		assert.False(t, guard.(*realSqlGuard).slowLog(time.Hour))
 		assert.True(t, guard.(*realSqlGuard).statementLog())
 	})
 
-	t.Run("DisableSlowLog", func(t *testing.T) {
+	t.Run("disable: Slow", func(t *testing.T) {
 		guard := newGuard(logOption{
-			EnableStatement: &no,
-			EnableSlow:      &yes,
+			EnableStatement: nullBool{valid: true, value: false},
+			EnableSlow:      nullBool{valid: true, value: true},
 		}, "any")
 		assert.True(t, guard.(*realSqlGuard).slowLog(time.Hour))
 		assert.False(t, guard.(*realSqlGuard).statementLog())

core/stores/sqlx/utils.go

@@ -186,3 +186,9 @@ func newAcceptableError(err error) error {
 func (e acceptableError) Error() string {
 	return e.err.Error()
 }
+
+// nullBool represents a bool that may be null.
+type nullBool struct {
+	value bool
+	valid bool // valid is true if Bool is not NULL
+}