package mysql

Import Path
	github.com/go-sql-driver/mysql (on go.dev)

Dependency Relation
	imports 33 packages, and imported by one package


Involved Source Files

	    atomic_bool.go
	    auth.go
	    buffer.go
	    collations.go
	    conncheck.go
	    connection.go
	    connector.go
	    const.go
	
		Package mysql provides a MySQL driver for Go's database/sql package.
		
		The driver should be used via the database/sql package:
		
			import "database/sql"
			import _ "github.com/go-sql-driver/mysql"
		
			db, err := sql.Open("mysql", "user:password@/dbname")
		
		See https://github.com/go-sql-driver/mysql#usage for details

	    dsn.go
	    errors.go
	    fields.go
	    infile.go
	    nulltime.go
	    packets.go
	    result.go
	    rows.go
	    statement.go
	    transaction.go
	    utils.go


Package-Level Type Names (total 10)


	/* sort by:  |  */
	
		Config is a configuration parsed from a DSN string.
		If a new Config is created instead of being parsed from a DSN string,
		the NewConfig function should be used, which sets default values.

		
			
				// Address (default: "127.0.0.1:3306" for "tcp" and "/tmp/mysql.sock" for "unix")

			
				// Allow all files to be used with LOAD DATA LOCAL INFILE

			
				// Allows the cleartext client side plugin

			
				// Allows fallback to unencrypted connection if server does not support TLS

			
				// Allows the native password authentication method

			
				// Allows the old insecure password method

			
				// Check connections for liveness before using them

			
				// Return number of matching rows instead of rows changed

			
				// Connection collation

			
				// Prepend table alias to column names

			
				// Connection Attributes, comma-delimited string of user-defined "key:value" pairs

			
				// Database name

			
				// Interpolate placeholders into query string

			
				// Location for time.Time values

			
				// Logger

			
				// Max packet size allowed

			
				// Allow multiple statements in one query

			
				// Network (e.g. "tcp", "tcp6", "unix". default: "tcp")

			
				// Connection parameters

			
				// Parse time values to time.Time

			
				// Password (requires User)

			
				// I/O read timeout

			
				// Reject read-only connections

			
				// Server public key name

			
				// TLS configuration, its priority is higher than TLSConfig

			
				// TLS configuration name

			
				// Dial timeout

			
				// Username

			
				// I/O write timeout

		
			
				Apply applies the given options to the Config object.

			(*Config) Clone() *Config
			
				FormatDSN formats the given Config into a DSN string which can be passed to
				the driver.
				
				Note: use [NewConnector] and [database/sql.OpenDB] to open a connection from a [*Config].

		
			func NewConfig() *Config
			func ParseDSN(dsn string) (cfg *Config, err error)
			func (*Config).Clone() *Config
		
			func NewConnector(cfg *Config) (driver.Connector, error)


	
		DialContextFunc is a function which can be used to establish the network connection.
		Custom dial functions must be registered with RegisterDialContext

		
			func RegisterDialContext(net string, dial DialContextFunc)


	
		DialFunc is a function which can be used to establish the network connection.
		Custom dial functions must be registered with RegisterDial
		
		Deprecated: users should register a DialContextFunc instead

		
			func RegisterDial(network string, dial DialFunc)


	
		Logger is used to log critical error messages.

		
			( Logger) Print(v ...any)
		
			*NopLogger
			*github.com/coreos/pkg/capnslog.PackageLogger
			 github.com/reeflective/console.Menu
			*github.com/spf13/cobra.Command
			 golang.org/x/xerrors.Printer (interface)
			 google.golang.org/grpc/grpclog.Logger (interface)
			 google.golang.org/grpc/grpclog/internal.Logger (interface)
			 google.golang.org/grpc/grpclog/internal.LoggerWrapper
			*log.Logger
		
			func SetLogger(logger Logger) error


	
		MySQLDriver is exported to make the driver directly accessible.
		In general the driver is used via the database/sql package.

		
			
				Open new Connection.
				See https://github.com/go-sql-driver/mysql#dsn-data-source-name for how
				the DSN string is formatted

			
				OpenConnector implements driver.DriverContext.

		
			 MySQLDriver : database/sql/driver.Driver
			 MySQLDriver : database/sql/driver.DriverContext


	
		MySQLError is an error type which represents a single MySQL error

		
			Message string
			Number uint16
			SQLState [5]byte
		
			(*MySQLError) Error() string
			(*MySQLError) Is(err error) bool
		
			*MySQLError : error


	
		NopLogger is a nop implementation of the Logger interface.

		
			
				Print implements Logger interface.

		
			*NopLogger : Logger


	
		NullTime represents a time.Time that may be NULL.
		NullTime implements the Scanner interface so
		it can be used as a scan destination:
		
			var nt NullTime
			err := db.QueryRow("SELECT time FROM foo WHERE id=?", id).Scan(&nt)
			...
			if nt.Valid {
			   // use nt.Time
			} else {
			   // NULL value
			}
		
		# This NullTime implementation is not driver-specific
		
		Deprecated: NullTime doesn't honor the loc DSN parameter.
		NullTime.Scan interprets a time as UTC, not the loc DSN parameter.
		Use sql.NullTime instead.

		
			Time time.Time
			
				// Valid is true if Time is not NULL

		
			
				Scan implements the Scanner interface.
				The value type must be time.Time or string / []byte (formatted time-string),
				otherwise Scan fails.

			
				Value implements the driver Valuer interface.

		
			*NullTime : database/sql.Scanner
			 NullTime : database/sql/driver.Valuer


	
		Functional Options Pattern
		https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis

		
			func BeforeConnect(fn func(context.Context, *Config) error) Option
			func TimeTruncate(d time.Duration) Option
		
			func (*Config).Apply(opts ...Option) error


	
		Result exposes data not available through *connection.Result.
		
		This is accessible by executing statements using sql.Conn.Raw() and
		downcasting the returned result:
		
			res, err := rawConn.Exec(...)
			res.(mysql.Result).AllRowsAffected()

		
			
				AllLastInsertIds returns a slice containing the last inserted ID for each
				executed statement.

			
				AllRowsAffected returns a slice containing the affected rows for each
				executed statement.

			
				LastInsertId returns the database's auto-generated ID
				after, for example, an INSERT into a table with primary
				key.

			
				RowsAffected returns the number of rows affected by the
				query.

		
			 Result : database/sql.Result
			 Result : database/sql/driver.Result




Package-Level Functions (total 17)


	
		BeforeConnect sets the function to be invoked before a connection is established.


	
		DeregisterDialContext removes the custom dial function registered with the given net.


	
		DeregisterLocalFile removes the given filepath from the allowlist.


	
		DeregisterReaderHandler removes the ReaderHandler function with
		the given name from the registry.


	
		DeregisterServerPubKey removes the public key registered with the given name.


	
		DeregisterTLSConfig removes the tls.Config associated with key.


	
		NewConfig creates a new Config and sets default values.


	
		NewConnector returns new driver.Connector.


	
		ParseDSN parses the DSN string to a Config


	
		RegisterDial registers a custom dial function. It can then be used by the
		network address mynet(addr), where mynet is the registered new network.
		addr is passed as a parameter to the dial function.
		
		Deprecated: users should call RegisterDialContext instead


	
		RegisterDialContext registers a custom dial function. It can then be used by the
		network address mynet(addr), where mynet is the registered new network.
		The current context for the connection and its address is passed to the dial function.


	
		RegisterLocalFile adds the given file to the file allowlist,
		so that it can be used by "LOAD DATA LOCAL INFILE <filepath>".
		Alternatively you can allow the use of all local files with
		the DSN parameter 'allowAllFiles=true'
		
			filePath := "/home/gopher/data.csv"
			mysql.RegisterLocalFile(filePath)
			err := db.Exec("LOAD DATA LOCAL INFILE '" + filePath + "' INTO TABLE foo")
			if err != nil {
			...


	
		RegisterReaderHandler registers a handler function which is used
		to receive a io.Reader.
		The Reader can be used by "LOAD DATA LOCAL INFILE Reader::<name>".
		If the handler returns a io.ReadCloser Close() is called when the
		request is finished.
		
			mysql.RegisterReaderHandler("data", func() io.Reader {
				var csvReader io.Reader // Some Reader that returns CSV data
				... // Open Reader here
				return csvReader
			})
			err := db.Exec("LOAD DATA LOCAL INFILE 'Reader::data' INTO TABLE foo")
			if err != nil {
			...


	
		RegisterServerPubKey registers a server RSA public key which can be used to
		send data in a secure manner to the server without receiving the public key
		in a potentially insecure way from the server first.
		Registered keys can afterwards be used adding serverPubKey=<name> to the DSN.
		
		Note: The provided rsa.PublicKey instance is exclusively owned by the driver
		after registering it and may not be modified.
		
			data, err := os.ReadFile("mykey.pem")
			if err != nil {
				log.Fatal(err)
			}
		
			block, _ := pem.Decode(data)
			if block == nil || block.Type != "PUBLIC KEY" {
				log.Fatal("failed to decode PEM block containing public key")
			}
		
			pub, err := x509.ParsePKIXPublicKey(block.Bytes)
			if err != nil {
				log.Fatal(err)
			}
		
			if rsaPubKey, ok := pub.(*rsa.PublicKey); ok {
				mysql.RegisterServerPubKey("mykey", rsaPubKey)
			} else {
				log.Fatal("not a RSA public key")
			}


	
		RegisterTLSConfig registers a custom tls.Config to be used with sql.Open.
		Use the key as a value in the DSN where tls=value.
		
		Note: The provided tls.Config is exclusively owned by the driver after
		registering it.
		
			rootCertPool := x509.NewCertPool()
			pem, err := os.ReadFile("/path/ca-cert.pem")
			if err != nil {
			    log.Fatal(err)
			}
			if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
			    log.Fatal("Failed to append PEM.")
			}
			clientCert := make([]tls.Certificate, 0, 1)
			certs, err := tls.LoadX509KeyPair("/path/client-cert.pem", "/path/client-key.pem")
			if err != nil {
			    log.Fatal(err)
			}
			clientCert = append(clientCert, certs)
			mysql.RegisterTLSConfig("custom", &tls.Config{
			    RootCAs: rootCertPool,
			    Certificates: clientCert,
			})
			db, err := sql.Open("mysql", "user@tcp(localhost:3306)/test?tls=custom")


	
		SetLogger is used to set the default logger for critical errors.
		The initial logger is os.Stderr.


	
		TimeTruncate sets the time duration to truncate time.Time values in
		query parameters.




Package-Level Variables (total 12)


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.


	
		Various errors the driver might return. Can change between driver versions.