Go-MySQL-Driver

Go-MySQL-Driver implements Go’s database/sql/driver interface entirely in Go, with no cgo or C bindings, so it cross-compiles cleanly and runs anywhere the Go toolchain does. Importing it for its side effect registers a mysql driver with database/sql, after which the standard library’s connection pooling, prepared statements, and query APIs work against MySQL, MariaDB, or TiDB without any driver-specific code in the caller.

Beyond the baseline driver contract, it handles the practical edges of talking to a real MySQL server: TLS negotiation, zlib compression, LOAD DATA LOCAL INFILE with an explicit file allowlist, automatic reconnection on broken connections, and full context.Context support for cancellation and timeouts. Configuration is driven by a DSN string or a typed Config struct, both parsed and validated the same way, so applications can choose whichever fits their setup.

What You Get

• A database/sql/driver implementation registered under the mysql driver name via a blank import
• DSN parsing and a typed Config/FormatDSN API for building connection strings programmatically
• TLS support, including custom tls.Config registration for verified or self-signed certificates
• Optional zlib connection compression and pluggable custom dial functions via RegisterDialContext
• Context-aware query cancellation and configurable read/write timeouts
• Secure LOAD DATA LOCAL INFILE support with explicit file and reader allowlisting

Common Use Cases

• Backing a Go web service’s database/sql connection pool with a MySQL or MariaDB database
• Connecting to TiDB, which speaks the MySQL wire protocol, for horizontally scaled workloads
• Streaming large result sets or bulk-loading data via LOAD DATA LOCAL INFILE from an io.Reader
• Using sql.RawBytes and prepared statements to move large payloads without excess allocation

Under The Hood

Architecture

The driver is a flat, single-package implementation of Go’s database/sql/driver interfaces (driver.go, connector.go, connection.go, statement.go, transaction.go, rows.go). MySQLDriver.Open/OpenConnector parse a DSN into a Config and hand it to an internal connector, whose Connect method performs the handshake and returns a mysqlConn that owns the network connection, protocol buffer, and per-connection state (capability flags, sequence numbers, compression). packets.go implements the wire protocol framing and packet types on top of a small buffer abstraction, and auth.go isolates the various MySQL authentication plugins (native password, caching_sha2, cleartext) behind a common negotiation path. This keeps protocol concerns, connection lifecycle, and the database/sql adapter surface in clearly separate files despite the single-package layout, so a change to authentication or packet framing doesn’t ripple into the sql.driver glue code.

Tech Stack

The module targets Go 1.24+ and declares exactly one external dependency, filippo.io/edwards25519, used for Ed25519 curve arithmetic in newer MySQL authentication plugins — everything else, including TCP/TLS handling, zlib compression, and DSN parsing, is implemented with the Go standard library (net, crypto/tls, compress/zlib, context). There is no ORM or query-builder layer; the driver operates purely at the database/sql/driver boundary, so any Go code using database/sql gets MySQL/MariaDB/TiDB connectivity by importing the package for its side effect and calling sql.Open("mysql", dsn).

Code Quality

The repository ships 14 _test.go files with roughly 167 test functions, including fuzz tests for DSN parsing (dsn_fuzz_test.go) and a benchmark suite, exercised in CI against a real matrix of MySQL (5.7 through 9.0) and MariaDB (10.5 through 12.3 LTS) versions across three Go releases and three operating systems. A dedicated lint job runs staticcheck on every push and pull request. Errors are exposed as typed sentinel values (ErrInvalidConn, ErrPktTooLarge, etc.) and a MySQLError type carrying the server’s numeric code and SQLSTATE, rather than opaque strings, and connection-layer failures are explicitly funneled through markBadConn so database/sql knows to retry on a fresh connection instead of silently reusing a broken one.

What Makes It Unique

Unlike drivers that wrap a C client library via cgo, this is a from-scratch reimplementation of the MySQL wire protocol in pure Go, which is what lets it cross-compile to any Go-supported platform without a C toolchain or shared library at runtime. It also treats operational safety as a first-class concern rather than an afterthought — LOAD DATA LOCAL INFILE, a feature that has been a source of real-world SQL injection and file-disclosure vulnerabilities in other drivers, requires callers to explicitly allowlist file paths or register an io.Reader, closing off the class of exploit where a malicious server or query could read arbitrary client-side files.