Make TINYINT(1) bool

README.md

@@ -319,6 +319,18 @@ Default:        0
 > [!NOTE]
 > `time.Time` arguments are sent with up to nanosecond precision, so a value from `time.Now()` usually has more fractional-second digits than a `DATETIME(N)` or `TIMESTAMP(N)` column stores. On MariaDB, comparing such a value against an indexed column can prevent an index range scan, turning it into a full index scan. Truncating to the column's precision (`1us` for `DATETIME(6)`) avoids this. Only arguments sent to the server are truncated; values read from the server are not affected.
 
+##### `tinyInt1IsBool`
+
+```
+Type:           bool
+Valid Values:   true, false
+Default:        true
+```
+
+When `tinyInt1IsBool=true`, signed `TINYINT(1)` columns are treated as boolean values. Zero is returned as `false`, and non-zero values are returned as `true`. Their database type name is reported as `BOOLEAN`, and their scan type is `bool` for non-nullable columns or `sql.NullBool` for nullable columns.
+
+Unsigned and `ZEROFILL` columns are not converted. Set `tinyInt1IsBool=false` to preserve the numeric `TINYINT` behavior.
+
 ##### `maxAllowedPacket`
 ```
 Type:          decimal number

boolean_test.go

@@ -0,0 +1,151 @@
+// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
+//
+// Copyright 2026 The Go-MySQL-Driver Authors. All rights reserved.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package mysql
+
+import (
+	"database/sql"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestTinyInt1IsBoolConfig(t *testing.T) {
+	cfg := NewConfig()
+	if !cfg.tinyInt1IsBool {
+		t.Fatal("tinyInt1IsBool should be enabled by default")
+	}
+	if got := cfg.FormatDSN(); strings.Contains(got, "tinyInt1IsBool") {
+		t.Fatalf("FormatDSN() = %q; default option should be omitted", got)
+	}
+
+	if err := cfg.Apply(TinyInt1IsBool(false)); err != nil {
+		t.Fatal(err)
+	}
+	if cfg.tinyInt1IsBool {
+		t.Fatal("TinyInt1IsBool(false) did not disable the option")
+	}
+	if got := cfg.FormatDSN(); !strings.Contains(got, "tinyInt1IsBool=false") {
+		t.Fatalf("FormatDSN() = %q; want tinyInt1IsBool=false", got)
+	}
+
+	cfg, err := ParseDSN("/?tinyInt1IsBool=false")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cfg.tinyInt1IsBool {
+		t.Fatal("ParseDSN did not disable tinyInt1IsBool")
+	}
+
+	if _, err := ParseDSN("/?tinyInt1IsBool=invalid"); err == nil {
+		t.Fatal("ParseDSN accepted invalid tinyInt1IsBool value")
+	}
+}
+
+func TestTinyInt1IsBool(t *testing.T) {
+	runTestsParallel(t, dsn, func(dbt *DBTest, tbl string) {
+		dbt.mustExec("CREATE TABLE " + tbl + " (" +
+			"id INT PRIMARY KEY, " +
+			"b TINYINT(1) NOT NULL, " +
+			"bn TINYINT(1), " +
+			"n TINYINT(2) NOT NULL, " +
+			"u TINYINT(1) UNSIGNED NOT NULL)")
+		dbt.mustExec("INSERT INTO " + tbl + " VALUES " +
+			"(1, 0, NULL, 2, 1), " +
+			"(2, 1, 0, 2, 1), " +
+			"(3, 2, -1, 2, 1), " +
+			"(4, 0, 0, 2, 1)")
+
+		rows := dbt.mustQuery("SELECT b, bn, n, u FROM " + tbl + " ORDER BY id")
+		defer rows.Close()
+
+		columnTypes, err := rows.ColumnTypes()
+		if err != nil {
+			dbt.Fatal(err)
+		}
+		wantDatabaseTypes := []string{"BOOLEAN", "BOOLEAN", "TINYINT", "UNSIGNED TINYINT"}
+		wantScanTypes := []reflect.Type{
+			reflect.TypeFor[bool](),
+			reflect.TypeFor[sql.NullBool](),
+			scanTypeInt8,
+			scanTypeUint8,
+		}
+		for i, columnType := range columnTypes {
+			if got := columnType.DatabaseTypeName(); got != wantDatabaseTypes[i] {
+				dbt.Errorf("column %d DatabaseTypeName() = %q; want %q", i, got, wantDatabaseTypes[i])
+			}
+			if got := columnType.ScanType(); got != wantScanTypes[i] {
+				dbt.Errorf("column %d ScanType() = %v; want %v", i, got, wantScanTypes[i])
+			}
+		}
+
+		want := [][4]any{
+			{false, nil, int64(2), int64(1)},
+			{true, false, int64(2), int64(1)},
+			{true, true, int64(2), int64(1)},
+			{false, false, int64(2), int64(1)},
+		}
+		row := 0
+		for ; rows.Next(); row++ {
+			var got [4]any
+			if err := rows.Scan(&got[0], &got[1], &got[2], &got[3]); err != nil {
+				dbt.Fatal(err)
+			}
+			if row >= len(want) {
+				dbt.Errorf("unexpected row %d = %#v", row, got)
+				continue
+			}
+			if !reflect.DeepEqual(got, want[row]) {
+				dbt.Errorf("row %d = %#v; want %#v", row, got, want[row])
+			}
+		}
+		if err := rows.Err(); err != nil {
+			dbt.Fatal(err)
+		}
+		if row != len(want) {
+			dbt.Errorf("got %d rows; want %d", row, len(want))
+		}
+
+		stmt, err := dbt.db.Prepare("SELECT b, bn, n, u FROM " + tbl + " WHERE id = ?")
+		if err != nil {
+			dbt.Fatal(err)
+		}
+		defer stmt.Close()
+
+		for _, id := range []int{3, 4} {
+			var got [4]any
+			if err := stmt.QueryRow(id).Scan(&got[0], &got[1], &got[2], &got[3]); err != nil {
+				dbt.Fatal(err)
+			}
+			if !reflect.DeepEqual(got, want[id-1]) {
+				dbt.Errorf("prepared statement row %d = %#v; want %#v", id, got, want[id-1])
+			}
+		}
+	})
+}
+
+func TestTinyInt1IsBoolDisabled(t *testing.T) {
+	runTestsParallel(t, dsn+"&tinyInt1IsBool=false", func(dbt *DBTest, tbl string) {
+		dbt.mustExec("CREATE TABLE " + tbl + " (b TINYINT(1) NOT NULL)")
+		dbt.mustExec("INSERT INTO " + tbl + " VALUES (2)")
+
+		stmt, err := dbt.db.Prepare("SELECT b FROM " + tbl + " WHERE b = ?")
+		if err != nil {
+			dbt.Fatal(err)
+		}
+		defer stmt.Close()
+
+		var got any
+		if err := stmt.QueryRow(2).Scan(&got); err != nil {
+			dbt.Fatal(err)
+		}
+		if got != int64(2) {
+			dbt.Fatalf("Scan(&any) = %#v; want int64(2)", got)
+		}
+	})
+}

driver_test.go

@@ -421,8 +421,8 @@ func TestNumbersToAny(t *testing.T) {
 		if err != nil {
 			dbt.Fatal(err)
 		}
-		if b.(int64) != 1 {
-			dbt.Errorf("b != 1")
+		if b != true {
+			dbt.Errorf("b = %#v; want true", b)
 		}
 		if i8.(int64) != 127 {
 			dbt.Errorf("i8 != 127")
@@ -3053,6 +3053,9 @@ func TestRowsColumnTypes(t *testing.T) {
 	ni0 := sql.NullInt64{Int64: 0, Valid: true}
 	ni1 := sql.NullInt64{Int64: 1, Valid: true}
 	ni42 := sql.NullInt64{Int64: 42, Valid: true}
+	nbNULL := sql.NullBool{Bool: false, Valid: false}
+	nb0 := sql.NullBool{Bool: false, Valid: true}
+	nb1 := sql.NullBool{Bool: true, Valid: true}
 	nfNULL := sql.NullFloat64{Float64: 0.0, Valid: false}
 	nf0 := sql.NullFloat64{Float64: 0.0, Valid: true}
 	nf1337 := sql.NullFloat64{Float64: 13.37, Valid: true}
@@ -3088,8 +3091,8 @@ func TestRowsColumnTypes(t *testing.T) {
 		valuesOut        [3]any
 	}{
 		{"bit8null", "BIT(8)", "BIT", scanTypeBytes, true, 0, 0, [3]string{"0x0", "NULL", "0x42"}, [3]any{bx0, bNULL, bx42}},
-		{"boolnull", "BOOL", "TINYINT", scanTypeNullInt, true, 0, 0, [3]string{"NULL", "true", "0"}, [3]any{niNULL, ni1, ni0}},
-		{"bool", "BOOL NOT NULL", "TINYINT", scanTypeInt8, false, 0, 0, [3]string{"1", "0", "FALSE"}, [3]any{int8(1), int8(0), int8(0)}},
+		{"boolnull", "BOOL", "BOOLEAN", reflect.TypeFor[sql.NullBool](), true, 0, 0, [3]string{"NULL", "true", "0"}, [3]any{nbNULL, nb1, nb0}},
+		{"bool", "BOOL NOT NULL", "BOOLEAN", reflect.TypeFor[bool](), false, 0, 0, [3]string{"1", "0", "FALSE"}, [3]any{true, false, false}},
 		{"intnull", "INTEGER", "INT", scanTypeNullInt, true, 0, 0, [3]string{"0", "NULL", "42"}, [3]any{ni0, niNULL, ni42}},
 		{"smallint", "SMALLINT NOT NULL", "SMALLINT", scanTypeInt16, false, 0, 0, [3]string{"0", "-32768", "32767"}, [3]any{int16(0), int16(-32768), int16(32767)}},
 		{"smallintnull", "SMALLINT", "SMALLINT", scanTypeNullInt, true, 0, 0, [3]string{"0", "NULL", "42"}, [3]any{ni0, niNULL, ni42}},

dsn.go

@@ -76,7 +76,8 @@ type Config struct {
 	// unexported fields. new options should be come here.
 	// boolean first. alphabetical order.
 
-	compress bool // Enable zlib compression
+	compress       bool // Enable zlib compression
+	tinyInt1IsBool bool // Treat signed TINYINT(1) as boolean
 
 	beforeConnect func(context.Context, *Config) error // Invoked before a connection is established
 	pubKey        *rsa.PublicKey                       // Server public key
@@ -96,6 +97,7 @@ func NewConfig() *Config {
 		Logger:               defaultLogger,
 		AllowNativePasswords: true,
 		CheckConnLiveness:    true,
+		tinyInt1IsBool:       true,
 	}
 	return cfg
 }
@@ -136,6 +138,14 @@ func EnableCompression(yes bool) Option {
 	}
 }
 
+// TinyInt1IsBool controls whether signed TINYINT(1) columns are treated as boolean.
+func TinyInt1IsBool(yes bool) Option {
+	return func(cfg *Config) error {
+		cfg.tinyInt1IsBool = yes
+		return nil
+	}
+}
+
 // Charset sets the connection charset and collation.
 //
 // charset is the connection charset.
@@ -355,6 +365,10 @@ func (cfg *Config) FormatDSN() string {
 		writeDSNParam(&buf, &hasParam, "timeTruncate", cfg.timeTruncate.String())
 	}
 
+	if !cfg.tinyInt1IsBool {
+		writeDSNParam(&buf, &hasParam, "tinyInt1IsBool", "false")
+	}
+
 	if cfg.ReadTimeout > 0 {
 		writeDSNParam(&buf, &hasParam, "readTimeout", cfg.ReadTimeout.String())
 	}
@@ -603,13 +617,6 @@ func parseDSNParams(cfg *Config, params string) (err error) {
 				return errors.New("invalid bool value: " + value)
 			}
 
-		// time.Time truncation
-		case "timeTruncate":
-			cfg.timeTruncate, err = time.ParseDuration(value)
-			if err != nil {
-				return fmt.Errorf("invalid timeTruncate value: %v, error: %w", value, err)
-			}
-
 		// I/O read Timeout
 		case "readTimeout":
 			cfg.ReadTimeout, err = time.ParseDuration(value)
@@ -644,6 +651,21 @@ func parseDSNParams(cfg *Config, params string) (err error) {
 				return
 			}
 
+		// time.Time truncation
+		case "timeTruncate":
+			cfg.timeTruncate, err = time.ParseDuration(value)
+			if err != nil {
+				return fmt.Errorf("invalid timeTruncate value: %v, error: %w", value, err)
+			}
+
+		// Treat TINYINT(1) as boolean
+		case "tinyInt1IsBool":
+			var isBool bool
+			cfg.tinyInt1IsBool, isBool = readBool(value)
+			if !isBool {
+				return errors.New("invalid bool value: " + value)
+			}
+
 		// TLS-Encryption
 		case "tls":
 			boolValue, isBool := readBool(value)