documentation/licenses/github.com/go-sql-driver/mysql/conncheck.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2019 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/.
-
-//go:build linux || darwin || dragonfly || freebsd || netbsd || openbsd || solaris || illumos
-// +build linux darwin dragonfly freebsd netbsd openbsd solaris illumos
-
-package mysql
-
-import (
-	"errors"
-	"io"
-	"net"
-	"syscall"
-)
-
-var errUnexpectedRead = errors.New("unexpected read from socket")
-
-func connCheck(conn net.Conn) error {
-	var sysErr error
-
-	sysConn, ok := conn.(syscall.Conn)
-	if !ok {
-		return nil
-	}
-	rawConn, err := sysConn.SyscallConn()
-	if err != nil {
-		return err
-	}
-
-	err = rawConn.Read(func(fd uintptr) bool {
-		var buf [1]byte
-		n, err := syscall.Read(int(fd), buf[:])
-		switch {
-		case n == 0 && err == nil:
-			sysErr = io.EOF
-		case n > 0:
-			sysErr = errUnexpectedRead
-		case err == syscall.EAGAIN || err == syscall.EWOULDBLOCK:
-			sysErr = nil
-		default:
-			sysErr = err
-		}
-		return true
-	})
-	if err != nil {
-		return err
-	}
-
-	return sysErr
-}

documentation/licenses/github.com/go-sql-driver/mysql/conncheck_dummy.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2019 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/.
-
-//go:build !linux && !darwin && !dragonfly && !freebsd && !netbsd && !openbsd && !solaris && !illumos
-// +build !linux,!darwin,!dragonfly,!freebsd,!netbsd,!openbsd,!solaris,!illumos
-
-package mysql
-
-import "net"
-
-func connCheck(conn net.Conn) error {
-	return nil
-}

documentation/licenses/github.com/go-sql-driver/mysql/connection.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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 (
-	"context"
-	"database/sql"
-	"database/sql/driver"
-	"encoding/json"
-	"io"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type mysqlConn struct {
-	buf              buffer
-	netConn          net.Conn
-	rawConn          net.Conn    // underlying connection when netConn is TLS connection.
-	result           mysqlResult // managed by clearResult() and handleOkPacket().
-	cfg              *Config
-	connector        *connector
-	maxAllowedPacket int
-	maxWriteSize     int
-	writeTimeout     time.Duration
-	flags            clientFlag
-	status           statusFlag
-	sequence         uint8
-	parseTime        bool
-
-	// for context support (Go 1.8+)
-	watching bool
-	watcher  chan<- context.Context
-	closech  chan struct{}
-	finished chan<- struct{}
-	canceled atomicError // set non-nil if conn is canceled
-	closed   atomicBool  // set when conn is closed, before closech is closed
-}
-
-// Helper function to call per-connection logger.
-func (mc *mysqlConn) log(v ...any) {
-	mc.cfg.Logger.Print(v...)
-}
-
-// Handles parameters set in DSN after the connection is established
-func (mc *mysqlConn) handleParams() (err error) {
-	var cmdSet strings.Builder
-
-	for param, val := range mc.cfg.Params {
-		switch param {
-		// Charset: character_set_connection, character_set_client, character_set_results
-		case "charset":
-			charsets := strings.Split(val, ",")
-			for _, cs := range charsets {
-				// ignore errors here - a charset may not exist
-				if mc.cfg.Collation != "" {
-					err = mc.exec("SET NAMES " + cs + " COLLATE " + mc.cfg.Collation)
-				} else {
-					err = mc.exec("SET NAMES " + cs)
-				}
-				if err == nil {
-					break
-				}
-			}
-			if err != nil {
-				return
-			}
-
-		// Other system vars accumulated in a single SET command
-		default:
-			if cmdSet.Len() == 0 {
-				// Heuristic: 29 chars for each other key=value to reduce reallocations
-				cmdSet.Grow(4 + len(param) + 3 + len(val) + 30*(len(mc.cfg.Params)-1))
-				cmdSet.WriteString("SET ")
-			} else {
-				cmdSet.WriteString(", ")
-			}
-			cmdSet.WriteString(param)
-			cmdSet.WriteString(" = ")
-			cmdSet.WriteString(val)
-		}
-	}
-
-	if cmdSet.Len() > 0 {
-		err = mc.exec(cmdSet.String())
-		if err != nil {
-			return
-		}
-	}
-
-	return
-}
-
-func (mc *mysqlConn) markBadConn(err error) error {
-	if mc == nil {
-		return err
-	}
-	if err != errBadConnNoWrite {
-		return err
-	}
-	return driver.ErrBadConn
-}
-
-func (mc *mysqlConn) Begin() (driver.Tx, error) {
-	return mc.begin(false)
-}
-
-func (mc *mysqlConn) begin(readOnly bool) (driver.Tx, error) {
-	if mc.closed.Load() {
-		mc.log(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	var q string
-	if readOnly {
-		q = "START TRANSACTION READ ONLY"
-	} else {
-		q = "START TRANSACTION"
-	}
-	err := mc.exec(q)
-	if err == nil {
-		return &mysqlTx{mc}, err
-	}
-	return nil, mc.markBadConn(err)
-}
-
-func (mc *mysqlConn) Close() (err error) {
-	// Makes Close idempotent
-	if !mc.closed.Load() {
-		err = mc.writeCommandPacket(comQuit)
-	}
-
-	mc.cleanup()
-	mc.clearResult()
-	return
-}
-
-// Closes the network connection and unsets internal variables. Do not call this
-// function after successfully authentication, call Close instead. This function
-// is called before auth or on auth failure because MySQL will have already
-// closed the network connection.
-func (mc *mysqlConn) cleanup() {
-	if mc.closed.Swap(true) {
-		return
-	}
-
-	// Makes cleanup idempotent
-	close(mc.closech)
-	conn := mc.rawConn
-	if conn == nil {
-		return
-	}
-	if err := conn.Close(); err != nil {
-		mc.log(err)
-	}
-	// This function can be called from multiple goroutines.
-	// So we can not mc.clearResult() here.
-	// Caller should do it if they are in safe goroutine.
-}
-
-func (mc *mysqlConn) error() error {
-	if mc.closed.Load() {
-		if err := mc.canceled.Value(); err != nil {
-			return err
-		}
-		return ErrInvalidConn
-	}
-	return nil
-}
-
-func (mc *mysqlConn) Prepare(query string) (driver.Stmt, error) {
-	if mc.closed.Load() {
-		mc.log(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	// Send command
-	err := mc.writeCommandPacketStr(comStmtPrepare, query)
-	if err != nil {
-		// STMT_PREPARE is safe to retry.  So we can return ErrBadConn here.
-		mc.log(err)
-		return nil, driver.ErrBadConn
-	}
-
-	stmt := &mysqlStmt{
-		mc: mc,
-	}
-
-	// Read Result
-	columnCount, err := stmt.readPrepareResultPacket()
-	if err == nil {
-		if stmt.paramCount > 0 {
-			if err = mc.readUntilEOF(); err != nil {
-				return nil, err
-			}
-		}
-
-		if columnCount > 0 {
-			err = mc.readUntilEOF()
-		}
-	}
-
-	return stmt, err
-}
-
-func (mc *mysqlConn) interpolateParams(query string, args []driver.Value) (string, error) {
-	// Number of ? should be same to len(args)
-	if strings.Count(query, "?") != len(args) {
-		return "", driver.ErrSkip
-	}
-
-	buf, err := mc.buf.takeCompleteBuffer()
-	if err != nil {
-		// can not take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return "", ErrInvalidConn
-	}
-	buf = buf[:0]
-	argPos := 0
-
-	for i := 0; i < len(query); i++ {
-		q := strings.IndexByte(query[i:], '?')
-		if q == -1 {
-			buf = append(buf, query[i:]...)
-			break
-		}
-		buf = append(buf, query[i:i+q]...)
-		i += q
-
-		arg := args[argPos]
-		argPos++
-
-		if arg == nil {
-			buf = append(buf, "NULL"...)
-			continue
-		}
-
-		switch v := arg.(type) {
-		case int64:
-			buf = strconv.AppendInt(buf, v, 10)
-		case uint64:
-			// Handle uint64 explicitly because our custom ConvertValue emits unsigned values
-			buf = strconv.AppendUint(buf, v, 10)
-		case float64:
-			buf = strconv.AppendFloat(buf, v, 'g', -1, 64)
-		case bool:
-			if v {
-				buf = append(buf, '1')
-			} else {
-				buf = append(buf, '0')
-			}
-		case time.Time:
-			if v.IsZero() {
-				buf = append(buf, "'0000-00-00'"...)
-			} else {
-				buf = append(buf, '\'')
-				buf, err = appendDateTime(buf, v.In(mc.cfg.Loc), mc.cfg.timeTruncate)
-				if err != nil {
-					return "", err
-				}
-				buf = append(buf, '\'')
-			}
-		case json.RawMessage:
-			buf = append(buf, '\'')
-			if mc.status&statusNoBackslashEscapes == 0 {
-				buf = escapeBytesBackslash(buf, v)
-			} else {
-				buf = escapeBytesQuotes(buf, v)
-			}
-			buf = append(buf, '\'')
-		case []byte:
-			if v == nil {
-				buf = append(buf, "NULL"...)
-			} else {
-				buf = append(buf, "_binary'"...)
-				if mc.status&statusNoBackslashEscapes == 0 {
-					buf = escapeBytesBackslash(buf, v)
-				} else {
-					buf = escapeBytesQuotes(buf, v)
-				}
-				buf = append(buf, '\'')
-			}
-		case string:
-			buf = append(buf, '\'')
-			if mc.status&statusNoBackslashEscapes == 0 {
-				buf = escapeStringBackslash(buf, v)
-			} else {
-				buf = escapeStringQuotes(buf, v)
-			}
-			buf = append(buf, '\'')
-		default:
-			return "", driver.ErrSkip
-		}
-
-		if len(buf)+4 > mc.maxAllowedPacket {
-			return "", driver.ErrSkip
-		}
-	}
-	if argPos != len(args) {
-		return "", driver.ErrSkip
-	}
-	return string(buf), nil
-}
-
-func (mc *mysqlConn) Exec(query string, args []driver.Value) (driver.Result, error) {
-	if mc.closed.Load() {
-		mc.log(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	if len(args) != 0 {
-		if !mc.cfg.InterpolateParams {
-			return nil, driver.ErrSkip
-		}
-		// try to interpolate the parameters to save extra roundtrips for preparing and closing a statement
-		prepared, err := mc.interpolateParams(query, args)
-		if err != nil {
-			return nil, err
-		}
-		query = prepared
-	}
-
-	err := mc.exec(query)
-	if err == nil {
-		copied := mc.result
-		return &copied, err
-	}
-	return nil, mc.markBadConn(err)
-}
-
-// Internal function to execute commands
-func (mc *mysqlConn) exec(query string) error {
-	handleOk := mc.clearResult()
-	// Send command
-	if err := mc.writeCommandPacketStr(comQuery, query); err != nil {
-		return mc.markBadConn(err)
-	}
-
-	// Read Result
-	resLen, err := handleOk.readResultSetHeaderPacket()
-	if err != nil {
-		return err
-	}
-
-	if resLen > 0 {
-		// columns
-		if err := mc.readUntilEOF(); err != nil {
-			return err
-		}
-
-		// rows
-		if err := mc.readUntilEOF(); err != nil {
-			return err
-		}
-	}
-
-	return handleOk.discardResults()
-}
-
-func (mc *mysqlConn) Query(query string, args []driver.Value) (driver.Rows, error) {
-	return mc.query(query, args)
-}
-
-func (mc *mysqlConn) query(query string, args []driver.Value) (*textRows, error) {
-	handleOk := mc.clearResult()
-
-	if mc.closed.Load() {
-		mc.log(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	if len(args) != 0 {
-		if !mc.cfg.InterpolateParams {
-			return nil, driver.ErrSkip
-		}
-		// try client-side prepare to reduce roundtrip
-		prepared, err := mc.interpolateParams(query, args)
-		if err != nil {
-			return nil, err
-		}
-		query = prepared
-	}
-	// Send command
-	err := mc.writeCommandPacketStr(comQuery, query)
-	if err == nil {
-		// Read Result
-		var resLen int
-		resLen, err = handleOk.readResultSetHeaderPacket()
-		if err == nil {
-			rows := new(textRows)
-			rows.mc = mc
-
-			if resLen == 0 {
-				rows.rs.done = true
-
-				switch err := rows.NextResultSet(); err {
-				case nil, io.EOF:
-					return rows, nil
-				default:
-					return nil, err
-				}
-			}
-
-			// Columns
-			rows.rs.columns, err = mc.readColumns(resLen)
-			return rows, err
-		}
-	}
-	return nil, mc.markBadConn(err)
-}
-
-// Gets the value of the given MySQL System Variable
-// The returned byte slice is only valid until the next read
-func (mc *mysqlConn) getSystemVar(name string) ([]byte, error) {
-	// Send command
-	handleOk := mc.clearResult()
-	if err := mc.writeCommandPacketStr(comQuery, "SELECT @@"+name); err != nil {
-		return nil, err
-	}
-
-	// Read Result
-	resLen, err := handleOk.readResultSetHeaderPacket()
-	if err == nil {
-		rows := new(textRows)
-		rows.mc = mc
-		rows.rs.columns = []mysqlField{{fieldType: fieldTypeVarChar}}
-
-		if resLen > 0 {
-			// Columns
-			if err := mc.readUntilEOF(); err != nil {
-				return nil, err
-			}
-		}
-
-		dest := make([]driver.Value, resLen)
-		if err = rows.readRow(dest); err == nil {
-			return dest[0].([]byte), mc.readUntilEOF()
-		}
-	}
-	return nil, err
-}
-
-// finish is called when the query has canceled.
-func (mc *mysqlConn) cancel(err error) {
-	mc.canceled.Set(err)
-	mc.cleanup()
-}
-
-// finish is called when the query has succeeded.
-func (mc *mysqlConn) finish() {
-	if !mc.watching || mc.finished == nil {
-		return
-	}
-	select {
-	case mc.finished <- struct{}{}:
-		mc.watching = false
-	case <-mc.closech:
-	}
-}
-
-// Ping implements driver.Pinger interface
-func (mc *mysqlConn) Ping(ctx context.Context) (err error) {
-	if mc.closed.Load() {
-		mc.log(ErrInvalidConn)
-		return driver.ErrBadConn
-	}
-
-	if err = mc.watchCancel(ctx); err != nil {
-		return
-	}
-	defer mc.finish()
-
-	handleOk := mc.clearResult()
-	if err = mc.writeCommandPacket(comPing); err != nil {
-		return mc.markBadConn(err)
-	}
-
-	return handleOk.readResultOK()
-}
-
-// BeginTx implements driver.ConnBeginTx interface
-func (mc *mysqlConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
-	if mc.closed.Load() {
-		return nil, driver.ErrBadConn
-	}
-
-	if err := mc.watchCancel(ctx); err != nil {
-		return nil, err
-	}
-	defer mc.finish()
-
-	if sql.IsolationLevel(opts.Isolation) != sql.LevelDefault {
-		level, err := mapIsolationLevel(opts.Isolation)
-		if err != nil {
-			return nil, err
-		}
-		err = mc.exec("SET TRANSACTION ISOLATION LEVEL " + level)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return mc.begin(opts.ReadOnly)
-}
-
-func (mc *mysqlConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
-	dargs, err := namedValueToValue(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := mc.watchCancel(ctx); err != nil {
-		return nil, err
-	}
-
-	rows, err := mc.query(query, dargs)
-	if err != nil {
-		mc.finish()
-		return nil, err
-	}
-	rows.finish = mc.finish
-	return rows, err
-}
-
-func (mc *mysqlConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
-	dargs, err := namedValueToValue(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := mc.watchCancel(ctx); err != nil {
-		return nil, err
-	}
-	defer mc.finish()
-
-	return mc.Exec(query, dargs)
-}
-
-func (mc *mysqlConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
-	if err := mc.watchCancel(ctx); err != nil {
-		return nil, err
-	}
-
-	stmt, err := mc.Prepare(query)
-	mc.finish()
-	if err != nil {
-		return nil, err
-	}
-
-	select {
-	default:
-	case <-ctx.Done():
-		stmt.Close()
-		return nil, ctx.Err()
-	}
-	return stmt, nil
-}
-
-func (stmt *mysqlStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
-	dargs, err := namedValueToValue(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := stmt.mc.watchCancel(ctx); err != nil {
-		return nil, err
-	}
-
-	rows, err := stmt.query(dargs)
-	if err != nil {
-		stmt.mc.finish()
-		return nil, err
-	}
-	rows.finish = stmt.mc.finish
-	return rows, err
-}
-
-func (stmt *mysqlStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
-	dargs, err := namedValueToValue(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := stmt.mc.watchCancel(ctx); err != nil {
-		return nil, err
-	}
-	defer stmt.mc.finish()
-
-	return stmt.Exec(dargs)
-}
-
-func (mc *mysqlConn) watchCancel(ctx context.Context) error {
-	if mc.watching {
-		// Reach here if canceled,
-		// so the connection is already invalid
-		mc.cleanup()
-		return nil
-	}
-	// When ctx is already cancelled, don't watch it.
-	if err := ctx.Err(); err != nil {
-		return err
-	}
-	// When ctx is not cancellable, don't watch it.
-	if ctx.Done() == nil {
-		return nil
-	}
-	// When watcher is not alive, can't watch it.
-	if mc.watcher == nil {
-		return nil
-	}
-
-	mc.watching = true
-	mc.watcher <- ctx
-	return nil
-}
-
-func (mc *mysqlConn) startWatcher() {
-	watcher := make(chan context.Context, 1)
-	mc.watcher = watcher
-	finished := make(chan struct{})
-	mc.finished = finished
-	go func() {
-		for {
-			var ctx context.Context
-			select {
-			case ctx = <-watcher:
-			case <-mc.closech:
-				return
-			}
-
-			select {
-			case <-ctx.Done():
-				mc.cancel(ctx.Err())
-			case <-finished:
-			case <-mc.closech:
-				return
-			}
-		}
-	}()
-}
-
-func (mc *mysqlConn) CheckNamedValue(nv *driver.NamedValue) (err error) {
-	nv.Value, err = converter{}.ConvertValue(nv.Value)
-	return
-}
-
-// ResetSession implements driver.SessionResetter.
-// (From Go 1.10)
-func (mc *mysqlConn) ResetSession(ctx context.Context) error {
-	if mc.closed.Load() {
-		return driver.ErrBadConn
-	}
-
-	// Perform a stale connection check. We only perform this check for
-	// the first query on a connection that has been checked out of the
-	// connection pool: a fresh connection from the pool is more likely
-	// to be stale, and it has not performed any previous writes that
-	// could cause data corruption, so it's safe to return ErrBadConn
-	// if the check fails.
-	if mc.cfg.CheckConnLiveness {
-		conn := mc.netConn
-		if mc.rawConn != nil {
-			conn = mc.rawConn
-		}
-		var err error
-		if mc.cfg.ReadTimeout != 0 {
-			err = conn.SetReadDeadline(time.Now().Add(mc.cfg.ReadTimeout))
-		}
-		if err == nil {
-			err = connCheck(conn)
-		}
-		if err != nil {
-			mc.log("closing bad idle connection: ", err)
-			return driver.ErrBadConn
-		}
-	}
-
-	return nil
-}
-
-// IsValid implements driver.Validator interface
-// (From Go 1.15)
-func (mc *mysqlConn) IsValid() bool {
-	return !mc.closed.Load()
-}

documentation/licenses/github.com/go-sql-driver/mysql/connector.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2018 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 (
-	"context"
-	"database/sql/driver"
-	"net"
-	"os"
-	"strconv"
-	"strings"
-)
-
-type connector struct {
-	cfg               *Config // immutable private copy.
-	encodedAttributes string  // Encoded connection attributes.
-}
-
-func encodeConnectionAttributes(cfg *Config) string {
-	connAttrsBuf := make([]byte, 0)
-
-	// default connection attributes
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrClientName)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrClientNameValue)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrOS)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrOSValue)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrPlatform)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrPlatformValue)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrPid)
-	connAttrsBuf = appendLengthEncodedString(connAttrsBuf, strconv.Itoa(os.Getpid()))
-	serverHost, _, _ := net.SplitHostPort(cfg.Addr)
-	if serverHost != "" {
-		connAttrsBuf = appendLengthEncodedString(connAttrsBuf, connAttrServerHost)
-		connAttrsBuf = appendLengthEncodedString(connAttrsBuf, serverHost)
-	}
-
-	// user-defined connection attributes
-	for _, connAttr := range strings.Split(cfg.ConnectionAttributes, ",") {
-		k, v, found := strings.Cut(connAttr, ":")
-		if !found {
-			continue
-		}
-		connAttrsBuf = appendLengthEncodedString(connAttrsBuf, k)
-		connAttrsBuf = appendLengthEncodedString(connAttrsBuf, v)
-	}
-
-	return string(connAttrsBuf)
-}
-
-func newConnector(cfg *Config) *connector {
-	encodedAttributes := encodeConnectionAttributes(cfg)
-	return &connector{
-		cfg:               cfg,
-		encodedAttributes: encodedAttributes,
-	}
-}
-
-// Connect implements driver.Connector interface.
-// Connect returns a connection to the database.
-func (c *connector) Connect(ctx context.Context) (driver.Conn, error) {
-	var err error
-
-	// Invoke beforeConnect if present, with a copy of the configuration
-	cfg := c.cfg
-	if c.cfg.beforeConnect != nil {
-		cfg = c.cfg.Clone()
-		err = c.cfg.beforeConnect(ctx, cfg)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// New mysqlConn
-	mc := &mysqlConn{
-		maxAllowedPacket: maxPacketSize,
-		maxWriteSize:     maxPacketSize - 1,
-		closech:          make(chan struct{}),
-		cfg:              cfg,
-		connector:        c,
-	}
-	mc.parseTime = mc.cfg.ParseTime
-
-	// Connect to Server
-	dialsLock.RLock()
-	dial, ok := dials[mc.cfg.Net]
-	dialsLock.RUnlock()
-	if ok {
-		dctx := ctx
-		if mc.cfg.Timeout > 0 {
-			var cancel context.CancelFunc
-			dctx, cancel = context.WithTimeout(ctx, c.cfg.Timeout)
-			defer cancel()
-		}
-		mc.netConn, err = dial(dctx, mc.cfg.Addr)
-	} else {
-		nd := net.Dialer{Timeout: mc.cfg.Timeout}
-		mc.netConn, err = nd.DialContext(ctx, mc.cfg.Net, mc.cfg.Addr)
-	}
-	if err != nil {
-		return nil, err
-	}
-	mc.rawConn = mc.netConn
-
-	// Enable TCP Keepalives on TCP connections
-	if tc, ok := mc.netConn.(*net.TCPConn); ok {
-		if err := tc.SetKeepAlive(true); err != nil {
-			c.cfg.Logger.Print(err)
-		}
-	}
-
-	// Call startWatcher for context support (From Go 1.8)
-	mc.startWatcher()
-	if err := mc.watchCancel(ctx); err != nil {
-		mc.cleanup()
-		return nil, err
-	}
-	defer mc.finish()
-
-	mc.buf = newBuffer(mc.netConn)
-
-	// Set I/O timeouts
-	mc.buf.timeout = mc.cfg.ReadTimeout
-	mc.writeTimeout = mc.cfg.WriteTimeout
-
-	// Reading Handshake Initialization Packet
-	authData, plugin, err := mc.readHandshakePacket()
-	if err != nil {
-		mc.cleanup()
-		return nil, err
-	}
-
-	if plugin == "" {
-		plugin = defaultAuthPlugin
-	}
-
-	// Send Client Authentication Packet
-	authResp, err := mc.auth(authData, plugin)
-	if err != nil {
-		// try the default auth plugin, if using the requested plugin failed
-		c.cfg.Logger.Print("could not use requested auth plugin '"+plugin+"': ", err.Error())
-		plugin = defaultAuthPlugin
-		authResp, err = mc.auth(authData, plugin)
-		if err != nil {
-			mc.cleanup()
-			return nil, err
-		}
-	}
-	if err = mc.writeHandshakeResponsePacket(authResp, plugin); err != nil {
-		mc.cleanup()
-		return nil, err
-	}
-
-	// Handle response to auth packet, switch methods if possible
-	if err = mc.handleAuthResult(authData, plugin); err != nil {
-		// Authentication failed and MySQL has already closed the connection
-		// (https://dev.mysql.com/doc/internals/en/authentication-fails.html).
-		// Do not send COM_QUIT, just cleanup and return the error.
-		mc.cleanup()
-		return nil, err
-	}
-
-	if mc.cfg.MaxAllowedPacket > 0 {
-		mc.maxAllowedPacket = mc.cfg.MaxAllowedPacket
-	} else {
-		// Get max allowed packet size
-		maxap, err := mc.getSystemVar("max_allowed_packet")
-		if err != nil {
-			mc.Close()
-			return nil, err
-		}
-		mc.maxAllowedPacket = stringToInt(maxap) - 1
-	}
-	if mc.maxAllowedPacket < maxPacketSize {
-		mc.maxWriteSize = mc.maxAllowedPacket
-	}
-
-	// Handle DSN Params
-	err = mc.handleParams()
-	if err != nil {
-		mc.Close()
-		return nil, err
-	}
-
-	return mc, nil
-}
-
-// Driver implements driver.Connector interface.
-// Driver returns &MySQLDriver{}.
-func (c *connector) Driver() driver.Driver {
-	return &MySQLDriver{}
-}

documentation/licenses/github.com/go-sql-driver/mysql/const.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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 "runtime"
-
-const (
-	defaultAuthPlugin       = "mysql_native_password"
-	defaultMaxAllowedPacket = 64 << 20 // 64 MiB. See https://github.com/go-sql-driver/mysql/issues/1355
-	minProtocolVersion      = 10
-	maxPacketSize           = 1<<24 - 1
-	timeFormat              = "2006-01-02 15:04:05.999999"
-
-	// Connection attributes
-	// See https://dev.mysql.com/doc/refman/8.0/en/performance-schema-connection-attribute-tables.html#performance-schema-connection-attributes-available
-	connAttrClientName      = "_client_name"
-	connAttrClientNameValue = "Go-MySQL-Driver"
-	connAttrOS              = "_os"
-	connAttrOSValue         = runtime.GOOS
-	connAttrPlatform        = "_platform"
-	connAttrPlatformValue   = runtime.GOARCH
-	connAttrPid             = "_pid"
-	connAttrServerHost      = "_server_host"
-)
-
-// MySQL constants documentation:
-// http://dev.mysql.com/doc/internals/en/client-server-protocol.html
-
-const (
-	iOK           byte = 0x00
-	iAuthMoreData byte = 0x01
-	iLocalInFile  byte = 0xfb
-	iEOF          byte = 0xfe
-	iERR          byte = 0xff
-)
-
-// https://dev.mysql.com/doc/internals/en/capability-flags.html#packet-Protocol::CapabilityFlags
-type clientFlag uint32
-
-const (
-	clientLongPassword clientFlag = 1 << iota
-	clientFoundRows
-	clientLongFlag
-	clientConnectWithDB
-	clientNoSchema
-	clientCompress
-	clientODBC
-	clientLocalFiles
-	clientIgnoreSpace
-	clientProtocol41
-	clientInteractive
-	clientSSL
-	clientIgnoreSIGPIPE
-	clientTransactions
-	clientReserved
-	clientSecureConn
-	clientMultiStatements
-	clientMultiResults
-	clientPSMultiResults
-	clientPluginAuth
-	clientConnectAttrs
-	clientPluginAuthLenEncClientData
-	clientCanHandleExpiredPasswords
-	clientSessionTrack
-	clientDeprecateEOF
-)
-
-const (
-	comQuit byte = iota + 1
-	comInitDB
-	comQuery
-	comFieldList
-	comCreateDB
-	comDropDB
-	comRefresh
-	comShutdown
-	comStatistics
-	comProcessInfo
-	comConnect
-	comProcessKill
-	comDebug
-	comPing
-	comTime
-	comDelayedInsert
-	comChangeUser
-	comBinlogDump
-	comTableDump
-	comConnectOut
-	comRegisterSlave
-	comStmtPrepare
-	comStmtExecute
-	comStmtSendLongData
-	comStmtClose
-	comStmtReset
-	comSetOption
-	comStmtFetch
-)
-
-// https://dev.mysql.com/doc/internals/en/com-query-response.html#packet-Protocol::ColumnType
-type fieldType byte
-
-const (
-	fieldTypeDecimal fieldType = iota
-	fieldTypeTiny
-	fieldTypeShort
-	fieldTypeLong
-	fieldTypeFloat
-	fieldTypeDouble
-	fieldTypeNULL
-	fieldTypeTimestamp
-	fieldTypeLongLong
-	fieldTypeInt24
-	fieldTypeDate
-	fieldTypeTime
-	fieldTypeDateTime
-	fieldTypeYear
-	fieldTypeNewDate
-	fieldTypeVarChar
-	fieldTypeBit
-)
-const (
-	fieldTypeJSON fieldType = iota + 0xf5
-	fieldTypeNewDecimal
-	fieldTypeEnum
-	fieldTypeSet
-	fieldTypeTinyBLOB
-	fieldTypeMediumBLOB
-	fieldTypeLongBLOB
-	fieldTypeBLOB
-	fieldTypeVarString
-	fieldTypeString
-	fieldTypeGeometry
-)
-
-type fieldFlag uint16
-
-const (
-	flagNotNULL fieldFlag = 1 << iota
-	flagPriKey
-	flagUniqueKey
-	flagMultipleKey
-	flagBLOB
-	flagUnsigned
-	flagZeroFill
-	flagBinary
-	flagEnum
-	flagAutoIncrement
-	flagTimestamp
-	flagSet
-	flagUnknown1
-	flagUnknown2
-	flagUnknown3
-	flagUnknown4
-)
-
-// http://dev.mysql.com/doc/internals/en/status-flags.html
-type statusFlag uint16
-
-const (
-	statusInTrans statusFlag = 1 << iota
-	statusInAutocommit
-	statusReserved // Not in documentation
-	statusMoreResultsExists
-	statusNoGoodIndexUsed
-	statusNoIndexUsed
-	statusCursorExists
-	statusLastRowSent
-	statusDbDropped
-	statusNoBackslashEscapes
-	statusMetadataChanged
-	statusQueryWasSlow
-	statusPsOutParams
-	statusInTransReadonly
-	statusSessionStateChanged
-)
-
-const (
-	cachingSha2PasswordRequestPublicKey          = 2
-	cachingSha2PasswordFastAuthSuccess           = 3
-	cachingSha2PasswordPerformFullAuthentication = 4
-)

documentation/licenses/github.com/go-sql-driver/mysql/driver.go

-// Copyright 2012 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 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
-package mysql
-
-import (
-	"context"
-	"database/sql"
-	"database/sql/driver"
-	"net"
-	"sync"
-)
-
-// MySQLDriver is exported to make the driver directly accessible.
-// In general the driver is used via the database/sql package.
-type MySQLDriver struct{}
-
-// 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
-type DialFunc func(addr string) (net.Conn, error)
-
-// DialContextFunc is a function which can be used to establish the network connection.
-// Custom dial functions must be registered with RegisterDialContext
-type DialContextFunc func(ctx context.Context, addr string) (net.Conn, error)
-
-var (
-	dialsLock sync.RWMutex
-	dials     map[string]DialContextFunc
-)
-
-// 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.
-func RegisterDialContext(net string, dial DialContextFunc) {
-	dialsLock.Lock()
-	defer dialsLock.Unlock()
-	if dials == nil {
-		dials = make(map[string]DialContextFunc)
-	}
-	dials[net] = dial
-}
-
-// DeregisterDialContext removes the custom dial function registered with the given net.
-func DeregisterDialContext(net string) {
-	dialsLock.Lock()
-	defer dialsLock.Unlock()
-	if dials != nil {
-		delete(dials, net)
-	}
-}
-
-// 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
-func RegisterDial(network string, dial DialFunc) {
-	RegisterDialContext(network, func(_ context.Context, addr string) (net.Conn, error) {
-		return dial(addr)
-	})
-}
-
-// Open new Connection.
-// See https://github.com/go-sql-driver/mysql#dsn-data-source-name for how
-// the DSN string is formatted
-func (d MySQLDriver) Open(dsn string) (driver.Conn, error) {
-	cfg, err := ParseDSN(dsn)
-	if err != nil {
-		return nil, err
-	}
-	c := newConnector(cfg)
-	return c.Connect(context.Background())
-}
-
-// This variable can be replaced with -ldflags like below:
-// go build "-ldflags=-X github.com/go-sql-driver/mysql.driverName=custom"
-var driverName = "mysql"
-
-func init() {
-	if driverName != "" {
-		sql.Register(driverName, &MySQLDriver{})
-	}
-}
-
-// NewConnector returns new driver.Connector.
-func NewConnector(cfg *Config) (driver.Connector, error) {
-	cfg = cfg.Clone()
-	// normalize the contents of cfg so calls to NewConnector have the same
-	// behavior as MySQLDriver.OpenConnector
-	if err := cfg.normalize(); err != nil {
-		return nil, err
-	}
-	return newConnector(cfg), nil
-}
-
-// OpenConnector implements driver.DriverContext.
-func (d MySQLDriver) OpenConnector(dsn string) (driver.Connector, error) {
-	cfg, err := ParseDSN(dsn)
-	if err != nil {
-		return nil, err
-	}
-	return newConnector(cfg), nil
-}

documentation/licenses/github.com/go-sql-driver/mysql/dsn.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2016 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 (
-	"bytes"
-	"context"
-	"crypto/rsa"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"math/big"
-	"net"
-	"net/url"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var (
-	errInvalidDSNUnescaped       = errors.New("invalid DSN: did you forget to escape a param value?")
-	errInvalidDSNAddr            = errors.New("invalid DSN: network address not terminated (missing closing brace)")
-	errInvalidDSNNoSlash         = errors.New("invalid DSN: missing the slash separating the database name")
-	errInvalidDSNUnsafeCollation = errors.New("invalid DSN: interpolateParams can not be used with unsafe collations")
-)
-
-// 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.
-type Config struct {
-	// non boolean fields
-
-	User                 string            // Username
-	Passwd               string            // Password (requires User)
-	Net                  string            // Network (e.g. "tcp", "tcp6", "unix". default: "tcp")
-	Addr                 string            // Address (default: "127.0.0.1:3306" for "tcp" and "/tmp/mysql.sock" for "unix")
-	DBName               string            // Database name
-	Params               map[string]string // Connection parameters
-	ConnectionAttributes string            // Connection Attributes, comma-delimited string of user-defined "key:value" pairs
-	Collation            string            // Connection collation
-	Loc                  *time.Location    // Location for time.Time values
-	MaxAllowedPacket     int               // Max packet size allowed
-	ServerPubKey         string            // Server public key name
-	TLSConfig            string            // TLS configuration name
-	TLS                  *tls.Config       // TLS configuration, its priority is higher than TLSConfig
-	Timeout              time.Duration     // Dial timeout
-	ReadTimeout          time.Duration     // I/O read timeout
-	WriteTimeout         time.Duration     // I/O write timeout
-	Logger               Logger            // Logger
-
-	// boolean fields
-
-	AllowAllFiles            bool // Allow all files to be used with LOAD DATA LOCAL INFILE
-	AllowCleartextPasswords  bool // Allows the cleartext client side plugin
-	AllowFallbackToPlaintext bool // Allows fallback to unencrypted connection if server does not support TLS
-	AllowNativePasswords     bool // Allows the native password authentication method
-	AllowOldPasswords        bool // Allows the old insecure password method
-	CheckConnLiveness        bool // Check connections for liveness before using them
-	ClientFoundRows          bool // Return number of matching rows instead of rows changed
-	ColumnsWithAlias         bool // Prepend table alias to column names
-	InterpolateParams        bool // Interpolate placeholders into query string
-	MultiStatements          bool // Allow multiple statements in one query
-	ParseTime                bool // Parse time values to time.Time
-	RejectReadOnly           bool // Reject read-only connections
-
-	// unexported fields. new options should be come here
-
-	beforeConnect func(context.Context, *Config) error // Invoked before a connection is established
-	pubKey        *rsa.PublicKey                       // Server public key
-	timeTruncate  time.Duration                        // Truncate time.Time values to the specified duration
-}
-
-// Functional Options Pattern
-// https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis
-type Option func(*Config) error
-
-// NewConfig creates a new Config and sets default values.
-func NewConfig() *Config {
-	cfg := &Config{
-		Loc:                  time.UTC,
-		MaxAllowedPacket:     defaultMaxAllowedPacket,
-		Logger:               defaultLogger,
-		AllowNativePasswords: true,
-		CheckConnLiveness:    true,
-	}
-
-	return cfg
-}
-
-// Apply applies the given options to the Config object.
-func (c *Config) Apply(opts ...Option) error {
-	for _, opt := range opts {
-		err := opt(c)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// TimeTruncate sets the time duration to truncate time.Time values in
-// query parameters.
-func TimeTruncate(d time.Duration) Option {
-	return func(cfg *Config) error {
-		cfg.timeTruncate = d
-		return nil
-	}
-}
-
-// BeforeConnect sets the function to be invoked before a connection is established.
-func BeforeConnect(fn func(context.Context, *Config) error) Option {
-	return func(cfg *Config) error {
-		cfg.beforeConnect = fn
-		return nil
-	}
-}
-
-func (cfg *Config) Clone() *Config {
-	cp := *cfg
-	if cp.TLS != nil {
-		cp.TLS = cfg.TLS.Clone()
-	}
-	if len(cp.Params) > 0 {
-		cp.Params = make(map[string]string, len(cfg.Params))
-		for k, v := range cfg.Params {
-			cp.Params[k] = v
-		}
-	}
-	if cfg.pubKey != nil {
-		cp.pubKey = &rsa.PublicKey{
-			N: new(big.Int).Set(cfg.pubKey.N),
-			E: cfg.pubKey.E,
-		}
-	}
-	return &cp
-}
-
-func (cfg *Config) normalize() error {
-	if cfg.InterpolateParams && cfg.Collation != "" && unsafeCollations[cfg.Collation] {
-		return errInvalidDSNUnsafeCollation
-	}
-
-	// Set default network if empty
-	if cfg.Net == "" {
-		cfg.Net = "tcp"
-	}
-
-	// Set default address if empty
-	if cfg.Addr == "" {
-		switch cfg.Net {
-		case "tcp":
-			cfg.Addr = "127.0.0.1:3306"
-		case "unix":
-			cfg.Addr = "/tmp/mysql.sock"
-		default:
-			return errors.New("default addr for network '" + cfg.Net + "' unknown")
-		}
-	} else if cfg.Net == "tcp" {
-		cfg.Addr = ensureHavePort(cfg.Addr)
-	}
-
-	if cfg.TLS == nil {
-		switch cfg.TLSConfig {
-		case "false", "":
-			// don't set anything
-		case "true":
-			cfg.TLS = &tls.Config{}
-		case "skip-verify":
-			cfg.TLS = &tls.Config{InsecureSkipVerify: true}
-		case "preferred":
-			cfg.TLS = &tls.Config{InsecureSkipVerify: true}
-			cfg.AllowFallbackToPlaintext = true
-		default:
-			cfg.TLS = getTLSConfigClone(cfg.TLSConfig)
-			if cfg.TLS == nil {
-				return errors.New("invalid value / unknown config name: " + cfg.TLSConfig)
-			}
-		}
-	}
-
-	if cfg.TLS != nil && cfg.TLS.ServerName == "" && !cfg.TLS.InsecureSkipVerify {
-		host, _, err := net.SplitHostPort(cfg.Addr)
-		if err == nil {
-			cfg.TLS.ServerName = host
-		}
-	}
-
-	if cfg.ServerPubKey != "" {
-		cfg.pubKey = getServerPubKey(cfg.ServerPubKey)
-		if cfg.pubKey == nil {
-			return errors.New("invalid value / unknown server pub key name: " + cfg.ServerPubKey)
-		}
-	}
-
-	if cfg.Logger == nil {
-		cfg.Logger = defaultLogger
-	}
-
-	return nil
-}
-
-func writeDSNParam(buf *bytes.Buffer, hasParam *bool, name, value string) {
-	buf.Grow(1 + len(name) + 1 + len(value))
-	if !*hasParam {
-		*hasParam = true
-		buf.WriteByte('?')
-	} else {
-		buf.WriteByte('&')
-	}
-	buf.WriteString(name)
-	buf.WriteByte('=')
-	buf.WriteString(value)
-}
-
-// 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 (cfg *Config) FormatDSN() string {
-	var buf bytes.Buffer
-
-	// [username[:password]@]
-	if len(cfg.User) > 0 {
-		buf.WriteString(cfg.User)
-		if len(cfg.Passwd) > 0 {
-			buf.WriteByte(':')
-			buf.WriteString(cfg.Passwd)
-		}
-		buf.WriteByte('@')
-	}
-
-	// [protocol[(address)]]
-	if len(cfg.Net) > 0 {
-		buf.WriteString(cfg.Net)
-		if len(cfg.Addr) > 0 {
-			buf.WriteByte('(')
-			buf.WriteString(cfg.Addr)
-			buf.WriteByte(')')
-		}
-	}
-
-	// /dbname
-	buf.WriteByte('/')
-	buf.WriteString(url.PathEscape(cfg.DBName))
-
-	// [?param1=value1&...&paramN=valueN]
-	hasParam := false
-
-	if cfg.AllowAllFiles {
-		hasParam = true
-		buf.WriteString("?allowAllFiles=true")
-	}
-
-	if cfg.AllowCleartextPasswords {
-		writeDSNParam(&buf, &hasParam, "allowCleartextPasswords", "true")
-	}
-
-	if cfg.AllowFallbackToPlaintext {
-		writeDSNParam(&buf, &hasParam, "allowFallbackToPlaintext", "true")
-	}
-
-	if !cfg.AllowNativePasswords {
-		writeDSNParam(&buf, &hasParam, "allowNativePasswords", "false")
-	}
-
-	if cfg.AllowOldPasswords {
-		writeDSNParam(&buf, &hasParam, "allowOldPasswords", "true")
-	}
-
-	if !cfg.CheckConnLiveness {
-		writeDSNParam(&buf, &hasParam, "checkConnLiveness", "false")
-	}
-
-	if cfg.ClientFoundRows {
-		writeDSNParam(&buf, &hasParam, "clientFoundRows", "true")
-	}
-
-	if col := cfg.Collation; col != "" {
-		writeDSNParam(&buf, &hasParam, "collation", col)
-	}
-
-	if cfg.ColumnsWithAlias {
-		writeDSNParam(&buf, &hasParam, "columnsWithAlias", "true")
-	}
-
-	if cfg.InterpolateParams {
-		writeDSNParam(&buf, &hasParam, "interpolateParams", "true")
-	}
-
-	if cfg.Loc != time.UTC && cfg.Loc != nil {
-		writeDSNParam(&buf, &hasParam, "loc", url.QueryEscape(cfg.Loc.String()))
-	}
-
-	if cfg.MultiStatements {
-		writeDSNParam(&buf, &hasParam, "multiStatements", "true")
-	}
-
-	if cfg.ParseTime {
-		writeDSNParam(&buf, &hasParam, "parseTime", "true")
-	}
-
-	if cfg.timeTruncate > 0 {
-		writeDSNParam(&buf, &hasParam, "timeTruncate", cfg.timeTruncate.String())
-	}
-
-	if cfg.ReadTimeout > 0 {
-		writeDSNParam(&buf, &hasParam, "readTimeout", cfg.ReadTimeout.String())
-	}
-
-	if cfg.RejectReadOnly {
-		writeDSNParam(&buf, &hasParam, "rejectReadOnly", "true")
-	}
-
-	if len(cfg.ServerPubKey) > 0 {
-		writeDSNParam(&buf, &hasParam, "serverPubKey", url.QueryEscape(cfg.ServerPubKey))
-	}
-
-	if cfg.Timeout > 0 {
-		writeDSNParam(&buf, &hasParam, "timeout", cfg.Timeout.String())
-	}
-
-	if len(cfg.TLSConfig) > 0 {
-		writeDSNParam(&buf, &hasParam, "tls", url.QueryEscape(cfg.TLSConfig))
-	}
-
-	if cfg.WriteTimeout > 0 {
-		writeDSNParam(&buf, &hasParam, "writeTimeout", cfg.WriteTimeout.String())
-	}
-
-	if cfg.MaxAllowedPacket != defaultMaxAllowedPacket {
-		writeDSNParam(&buf, &hasParam, "maxAllowedPacket", strconv.Itoa(cfg.MaxAllowedPacket))
-	}
-
-	// other params
-	if cfg.Params != nil {
-		var params []string
-		for param := range cfg.Params {
-			params = append(params, param)
-		}
-		sort.Strings(params)
-		for _, param := range params {
-			writeDSNParam(&buf, &hasParam, param, url.QueryEscape(cfg.Params[param]))
-		}
-	}
-
-	return buf.String()
-}
-
-// ParseDSN parses the DSN string to a Config
-func ParseDSN(dsn string) (cfg *Config, err error) {
-	// New config with some default values
-	cfg = NewConfig()
-
-	// [user[:password]@][net[(addr)]]/dbname[?param1=value1&paramN=valueN]
-	// Find the last '/' (since the password or the net addr might contain a '/')
-	foundSlash := false
-	for i := len(dsn) - 1; i >= 0; i-- {
-		if dsn[i] == '/' {
-			foundSlash = true
-			var j, k int
-
-			// left part is empty if i <= 0
-			if i > 0 {
-				// [username[:password]@][protocol[(address)]]
-				// Find the last '@' in dsn[:i]
-				for j = i; j >= 0; j-- {
-					if dsn[j] == '@' {
-						// username[:password]
-						// Find the first ':' in dsn[:j]
-						for k = 0; k < j; k++ {
-							if dsn[k] == ':' {
-								cfg.Passwd = dsn[k+1 : j]
-								break
-							}
-						}
-						cfg.User = dsn[:k]
-
-						break
-					}
-				}
-
-				// [protocol[(address)]]
-				// Find the first '(' in dsn[j+1:i]
-				for k = j + 1; k < i; k++ {
-					if dsn[k] == '(' {
-						// dsn[i-1] must be == ')' if an address is specified
-						if dsn[i-1] != ')' {
-							if strings.ContainsRune(dsn[k+1:i], ')') {
-								return nil, errInvalidDSNUnescaped
-							}
-							return nil, errInvalidDSNAddr
-						}
-						cfg.Addr = dsn[k+1 : i-1]
-						break
-					}
-				}
-				cfg.Net = dsn[j+1 : k]
-			}
-
-			// dbname[?param1=value1&...&paramN=valueN]
-			// Find the first '?' in dsn[i+1:]
-			for j = i + 1; j < len(dsn); j++ {
-				if dsn[j] == '?' {
-					if err = parseDSNParams(cfg, dsn[j+1:]); err != nil {
-						return
-					}
-					break
-				}
-			}
-
-			dbname := dsn[i+1 : j]
-			if cfg.DBName, err = url.PathUnescape(dbname); err != nil {
-				return nil, fmt.Errorf("invalid dbname %q: %w", dbname, err)
-			}
-
-			break
-		}
-	}
-
-	if !foundSlash && len(dsn) > 0 {
-		return nil, errInvalidDSNNoSlash
-	}
-
-	if err = cfg.normalize(); err != nil {
-		return nil, err
-	}
-	return
-}
-
-// parseDSNParams parses the DSN "query string"
-// Values must be url.QueryEscape'ed
-func parseDSNParams(cfg *Config, params string) (err error) {
-	for _, v := range strings.Split(params, "&") {
-		key, value, found := strings.Cut(v, "=")
-		if !found {
-			continue
-		}
-
-		// cfg params
-		switch key {
-		// Disable INFILE allowlist / enable all files
-		case "allowAllFiles":
-			var isBool bool
-			cfg.AllowAllFiles, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Use cleartext authentication mode (MySQL 5.5.10+)
-		case "allowCleartextPasswords":
-			var isBool bool
-			cfg.AllowCleartextPasswords, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Allow fallback to unencrypted connection if server does not support TLS
-		case "allowFallbackToPlaintext":
-			var isBool bool
-			cfg.AllowFallbackToPlaintext, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Use native password authentication
-		case "allowNativePasswords":
-			var isBool bool
-			cfg.AllowNativePasswords, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Use old authentication mode (pre MySQL 4.1)
-		case "allowOldPasswords":
-			var isBool bool
-			cfg.AllowOldPasswords, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Check connections for Liveness before using them
-		case "checkConnLiveness":
-			var isBool bool
-			cfg.CheckConnLiveness, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Switch "rowsAffected" mode
-		case "clientFoundRows":
-			var isBool bool
-			cfg.ClientFoundRows, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Collation
-		case "collation":
-			cfg.Collation = value
-
-		case "columnsWithAlias":
-			var isBool bool
-			cfg.ColumnsWithAlias, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Compression
-		case "compress":
-			return errors.New("compression not implemented yet")
-
-		// Enable client side placeholder substitution
-		case "interpolateParams":
-			var isBool bool
-			cfg.InterpolateParams, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Time Location
-		case "loc":
-			if value, err = url.QueryUnescape(value); err != nil {
-				return
-			}
-			cfg.Loc, err = time.LoadLocation(value)
-			if err != nil {
-				return
-			}
-
-		// multiple statements in one query
-		case "multiStatements":
-			var isBool bool
-			cfg.MultiStatements, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// time.Time parsing
-		case "parseTime":
-			var isBool bool
-			cfg.ParseTime, isBool = readBool(value)
-			if !isBool {
-				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)
-			if err != nil {
-				return
-			}
-
-		// Reject read-only connections
-		case "rejectReadOnly":
-			var isBool bool
-			cfg.RejectReadOnly, isBool = readBool(value)
-			if !isBool {
-				return errors.New("invalid bool value: " + value)
-			}
-
-		// Server public key
-		case "serverPubKey":
-			name, err := url.QueryUnescape(value)
-			if err != nil {
-				return fmt.Errorf("invalid value for server pub key name: %v", err)
-			}
-			cfg.ServerPubKey = name
-
-		// Strict mode
-		case "strict":
-			panic("strict mode has been removed. See https://github.com/go-sql-driver/mysql/wiki/strict-mode")
-
-		// Dial Timeout
-		case "timeout":
-			cfg.Timeout, err = time.ParseDuration(value)
-			if err != nil {
-				return
-			}
-
-		// TLS-Encryption
-		case "tls":
-			boolValue, isBool := readBool(value)
-			if isBool {
-				if boolValue {
-					cfg.TLSConfig = "true"
-				} else {
-					cfg.TLSConfig = "false"
-				}
-			} else if vl := strings.ToLower(value); vl == "skip-verify" || vl == "preferred" {
-				cfg.TLSConfig = vl
-			} else {
-				name, err := url.QueryUnescape(value)
-				if err != nil {
-					return fmt.Errorf("invalid value for TLS config name: %v", err)
-				}
-				cfg.TLSConfig = name
-			}
-
-		// I/O write Timeout
-		case "writeTimeout":
-			cfg.WriteTimeout, err = time.ParseDuration(value)
-			if err != nil {
-				return
-			}
-		case "maxAllowedPacket":
-			cfg.MaxAllowedPacket, err = strconv.Atoi(value)
-			if err != nil {
-				return
-			}
-
-		// Connection attributes
-		case "connectionAttributes":
-			connectionAttributes, err := url.QueryUnescape(value)
-			if err != nil {
-				return fmt.Errorf("invalid connectionAttributes value: %v", err)
-			}
-			cfg.ConnectionAttributes = connectionAttributes
-
-		default:
-			// lazy init
-			if cfg.Params == nil {
-				cfg.Params = make(map[string]string)
-			}
-
-			if cfg.Params[key], err = url.QueryUnescape(value); err != nil {
-				return
-			}
-		}
-	}
-
-	return
-}
-
-func ensureHavePort(addr string) string {
-	if _, _, err := net.SplitHostPort(addr); err != nil {
-		return net.JoinHostPort(addr, "3306")
-	}
-	return addr
-}

documentation/licenses/github.com/go-sql-driver/mysql/errors.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2013 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 (
-	"errors"
-	"fmt"
-	"log"
-	"os"
-)
-
-// Various errors the driver might return. Can change between driver versions.
-var (
-	ErrInvalidConn       = errors.New("invalid connection")
-	ErrMalformPkt        = errors.New("malformed packet")
-	ErrNoTLS             = errors.New("TLS requested but server does not support TLS")
-	ErrCleartextPassword = errors.New("this user requires clear text authentication. If you still want to use it, please add 'allowCleartextPasswords=1' to your DSN")
-	ErrNativePassword    = errors.New("this user requires mysql native password authentication")
-	ErrOldPassword       = errors.New("this user requires old password authentication. If you still want to use it, please add 'allowOldPasswords=1' to your DSN. See also https://github.com/go-sql-driver/mysql/wiki/old_passwords")
-	ErrUnknownPlugin     = errors.New("this authentication plugin is not supported")
-	ErrOldProtocol       = errors.New("MySQL server does not support required protocol 41+")
-	ErrPktSync           = errors.New("commands out of sync. You can't run this command now")
-	ErrPktSyncMul        = errors.New("commands out of sync. Did you run multiple statements at once?")
-	ErrPktTooLarge       = errors.New("packet for query is too large. Try adjusting the `Config.MaxAllowedPacket`")
-	ErrBusyBuffer        = errors.New("busy buffer")
-
-	// errBadConnNoWrite is used for connection errors where nothing was sent to the database yet.
-	// If this happens first in a function starting a database interaction, it should be replaced by driver.ErrBadConn
-	// to trigger a resend.
-	// See https://github.com/go-sql-driver/mysql/pull/302
-	errBadConnNoWrite = errors.New("bad connection")
-)
-
-var defaultLogger = Logger(log.New(os.Stderr, "[mysql] ", log.Ldate|log.Ltime|log.Lshortfile))
-
-// Logger is used to log critical error messages.
-type Logger interface {
-	Print(v ...any)
-}
-
-// NopLogger is a nop implementation of the Logger interface.
-type NopLogger struct{}
-
-// Print implements Logger interface.
-func (nl *NopLogger) Print(_ ...any) {}
-
-// SetLogger is used to set the default logger for critical errors.
-// The initial logger is os.Stderr.
-func SetLogger(logger Logger) error {
-	if logger == nil {
-		return errors.New("logger is nil")
-	}
-	defaultLogger = logger
-	return nil
-}
-
-// MySQLError is an error type which represents a single MySQL error
-type MySQLError struct {
-	Number   uint16
-	SQLState [5]byte
-	Message  string
-}
-
-func (me *MySQLError) Error() string {
-	if me.SQLState != [5]byte{} {
-		return fmt.Sprintf("Error %d (%s): %s", me.Number, me.SQLState, me.Message)
-	}
-
-	return fmt.Sprintf("Error %d: %s", me.Number, me.Message)
-}
-
-func (me *MySQLError) Is(err error) bool {
-	if merr, ok := err.(*MySQLError); ok {
-		return merr.Number == me.Number
-	}
-	return false
-}

documentation/licenses/github.com/go-sql-driver/mysql/fields.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2017 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"
-)
-
-func (mf *mysqlField) typeDatabaseName() string {
-	switch mf.fieldType {
-	case fieldTypeBit:
-		return "BIT"
-	case fieldTypeBLOB:
-		if mf.charSet != binaryCollationID {
-			return "TEXT"
-		}
-		return "BLOB"
-	case fieldTypeDate:
-		return "DATE"
-	case fieldTypeDateTime:
-		return "DATETIME"
-	case fieldTypeDecimal:
-		return "DECIMAL"
-	case fieldTypeDouble:
-		return "DOUBLE"
-	case fieldTypeEnum:
-		return "ENUM"
-	case fieldTypeFloat:
-		return "FLOAT"
-	case fieldTypeGeometry:
-		return "GEOMETRY"
-	case fieldTypeInt24:
-		if mf.flags&flagUnsigned != 0 {
-			return "UNSIGNED MEDIUMINT"
-		}
-		return "MEDIUMINT"
-	case fieldTypeJSON:
-		return "JSON"
-	case fieldTypeLong:
-		if mf.flags&flagUnsigned != 0 {
-			return "UNSIGNED INT"
-		}
-		return "INT"
-	case fieldTypeLongBLOB:
-		if mf.charSet != binaryCollationID {
-			return "LONGTEXT"
-		}
-		return "LONGBLOB"
-	case fieldTypeLongLong:
-		if mf.flags&flagUnsigned != 0 {
-			return "UNSIGNED BIGINT"
-		}
-		return "BIGINT"
-	case fieldTypeMediumBLOB:
-		if mf.charSet != binaryCollationID {
-			return "MEDIUMTEXT"
-		}
-		return "MEDIUMBLOB"
-	case fieldTypeNewDate:
-		return "DATE"
-	case fieldTypeNewDecimal:
-		return "DECIMAL"
-	case fieldTypeNULL:
-		return "NULL"
-	case fieldTypeSet:
-		return "SET"
-	case fieldTypeShort:
-		if mf.flags&flagUnsigned != 0 {
-			return "UNSIGNED SMALLINT"
-		}
-		return "SMALLINT"
-	case fieldTypeString:
-		if mf.flags&flagEnum != 0 {
-			return "ENUM"
-		} else if mf.flags&flagSet != 0 {
-			return "SET"
-		}
-		if mf.charSet == binaryCollationID {
-			return "BINARY"
-		}
-		return "CHAR"
-	case fieldTypeTime:
-		return "TIME"
-	case fieldTypeTimestamp:
-		return "TIMESTAMP"
-	case fieldTypeTiny:
-		if mf.flags&flagUnsigned != 0 {
-			return "UNSIGNED TINYINT"
-		}
-		return "TINYINT"
-	case fieldTypeTinyBLOB:
-		if mf.charSet != binaryCollationID {
-			return "TINYTEXT"
-		}
-		return "TINYBLOB"
-	case fieldTypeVarChar:
-		if mf.charSet == binaryCollationID {
-			return "VARBINARY"
-		}
-		return "VARCHAR"
-	case fieldTypeVarString:
-		if mf.charSet == binaryCollationID {
-			return "VARBINARY"
-		}
-		return "VARCHAR"
-	case fieldTypeYear:
-		return "YEAR"
-	default:
-		return ""
-	}
-}
-
-var (
-	scanTypeFloat32    = reflect.TypeOf(float32(0))
-	scanTypeFloat64    = reflect.TypeOf(float64(0))
-	scanTypeInt8       = reflect.TypeOf(int8(0))
-	scanTypeInt16      = reflect.TypeOf(int16(0))
-	scanTypeInt32      = reflect.TypeOf(int32(0))
-	scanTypeInt64      = reflect.TypeOf(int64(0))
-	scanTypeNullFloat  = reflect.TypeOf(sql.NullFloat64{})
-	scanTypeNullInt    = reflect.TypeOf(sql.NullInt64{})
-	scanTypeNullTime   = reflect.TypeOf(sql.NullTime{})
-	scanTypeUint8      = reflect.TypeOf(uint8(0))
-	scanTypeUint16     = reflect.TypeOf(uint16(0))
-	scanTypeUint32     = reflect.TypeOf(uint32(0))
-	scanTypeUint64     = reflect.TypeOf(uint64(0))
-	scanTypeString     = reflect.TypeOf("")
-	scanTypeNullString = reflect.TypeOf(sql.NullString{})
-	scanTypeBytes      = reflect.TypeOf([]byte{})
-	scanTypeUnknown    = reflect.TypeOf(new(any))
-)
-
-type mysqlField struct {
-	tableName string
-	name      string
-	length    uint32
-	flags     fieldFlag
-	fieldType fieldType
-	decimals  byte
-	charSet   uint8
-}
-
-func (mf *mysqlField) scanType() reflect.Type {
-	switch mf.fieldType {
-	case fieldTypeTiny:
-		if mf.flags&flagNotNULL != 0 {
-			if mf.flags&flagUnsigned != 0 {
-				return scanTypeUint8
-			}
-			return scanTypeInt8
-		}
-		return scanTypeNullInt
-
-	case fieldTypeShort, fieldTypeYear:
-		if mf.flags&flagNotNULL != 0 {
-			if mf.flags&flagUnsigned != 0 {
-				return scanTypeUint16
-			}
-			return scanTypeInt16
-		}
-		return scanTypeNullInt
-
-	case fieldTypeInt24, fieldTypeLong:
-		if mf.flags&flagNotNULL != 0 {
-			if mf.flags&flagUnsigned != 0 {
-				return scanTypeUint32
-			}
-			return scanTypeInt32
-		}
-		return scanTypeNullInt
-
-	case fieldTypeLongLong:
-		if mf.flags&flagNotNULL != 0 {
-			if mf.flags&flagUnsigned != 0 {
-				return scanTypeUint64
-			}
-			return scanTypeInt64
-		}
-		return scanTypeNullInt
-
-	case fieldTypeFloat:
-		if mf.flags&flagNotNULL != 0 {
-			return scanTypeFloat32
-		}
-		return scanTypeNullFloat
-
-	case fieldTypeDouble:
-		if mf.flags&flagNotNULL != 0 {
-			return scanTypeFloat64
-		}
-		return scanTypeNullFloat
-
-	case fieldTypeBit, fieldTypeTinyBLOB, fieldTypeMediumBLOB, fieldTypeLongBLOB,
-		fieldTypeBLOB, fieldTypeVarString, fieldTypeString, fieldTypeGeometry:
-		if mf.charSet == binaryCollationID {
-			return scanTypeBytes
-		}
-		fallthrough
-	case fieldTypeDecimal, fieldTypeNewDecimal, fieldTypeVarChar,
-		fieldTypeEnum, fieldTypeSet, fieldTypeJSON, fieldTypeTime:
-		if mf.flags&flagNotNULL != 0 {
-			return scanTypeString
-		}
-		return scanTypeNullString
-
-	case fieldTypeDate, fieldTypeNewDate,
-		fieldTypeTimestamp, fieldTypeDateTime:
-		// NullTime is always returned for more consistent behavior as it can
-		// handle both cases of parseTime regardless if the field is nullable.
-		return scanTypeNullTime
-
-	default:
-		return scanTypeUnknown
-	}
-}

documentation/licenses/github.com/go-sql-driver/mysql/infile.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2013 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 (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"sync"
-)
-
-var (
-	fileRegister       map[string]bool
-	fileRegisterLock   sync.RWMutex
-	readerRegister     map[string]func() io.Reader
-	readerRegisterLock sync.RWMutex
-)
-
-// 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 {
-//	...
-func RegisterLocalFile(filePath string) {
-	fileRegisterLock.Lock()
-	// lazy map init
-	if fileRegister == nil {
-		fileRegister = make(map[string]bool)
-	}
-
-	fileRegister[strings.Trim(filePath, `"`)] = true
-	fileRegisterLock.Unlock()
-}
-
-// DeregisterLocalFile removes the given filepath from the allowlist.
-func DeregisterLocalFile(filePath string) {
-	fileRegisterLock.Lock()
-	delete(fileRegister, strings.Trim(filePath, `"`))
-	fileRegisterLock.Unlock()
-}
-
-// 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 {
-//	...
-func RegisterReaderHandler(name string, handler func() io.Reader) {
-	readerRegisterLock.Lock()
-	// lazy map init
-	if readerRegister == nil {
-		readerRegister = make(map[string]func() io.Reader)
-	}
-
-	readerRegister[name] = handler
-	readerRegisterLock.Unlock()
-}
-
-// DeregisterReaderHandler removes the ReaderHandler function with
-// the given name from the registry.
-func DeregisterReaderHandler(name string) {
-	readerRegisterLock.Lock()
-	delete(readerRegister, name)
-	readerRegisterLock.Unlock()
-}
-
-func deferredClose(err *error, closer io.Closer) {
-	closeErr := closer.Close()
-	if *err == nil {
-		*err = closeErr
-	}
-}
-
-const defaultPacketSize = 16 * 1024 // 16KB is small enough for disk readahead and large enough for TCP
-
-func (mc *okHandler) handleInFileRequest(name string) (err error) {
-	var rdr io.Reader
-	var data []byte
-	packetSize := defaultPacketSize
-	if mc.maxWriteSize < packetSize {
-		packetSize = mc.maxWriteSize
-	}
-
-	if idx := strings.Index(name, "Reader::"); idx == 0 || (idx > 0 && name[idx-1] == '/') { // io.Reader
-		// The server might return an an absolute path. See issue #355.
-		name = name[idx+8:]
-
-		readerRegisterLock.RLock()
-		handler, inMap := readerRegister[name]
-		readerRegisterLock.RUnlock()
-
-		if inMap {
-			rdr = handler()
-			if rdr != nil {
-				if cl, ok := rdr.(io.Closer); ok {
-					defer deferredClose(&err, cl)
-				}
-			} else {
-				err = fmt.Errorf("reader '%s' is <nil>", name)
-			}
-		} else {
-			err = fmt.Errorf("reader '%s' is not registered", name)
-		}
-	} else { // File
-		name = strings.Trim(name, `"`)
-		fileRegisterLock.RLock()
-		fr := fileRegister[name]
-		fileRegisterLock.RUnlock()
-		if mc.cfg.AllowAllFiles || fr {
-			var file *os.File
-			var fi os.FileInfo
-
-			if file, err = os.Open(name); err == nil {
-				defer deferredClose(&err, file)
-
-				// get file size
-				if fi, err = file.Stat(); err == nil {
-					rdr = file
-					if fileSize := int(fi.Size()); fileSize < packetSize {
-						packetSize = fileSize
-					}
-				}
-			}
-		} else {
-			err = fmt.Errorf("local file '%s' is not registered", name)
-		}
-	}
-
-	// send content packets
-	// if packetSize == 0, the Reader contains no data
-	if err == nil && packetSize > 0 {
-		data := make([]byte, 4+packetSize)
-		var n int
-		for err == nil {
-			n, err = rdr.Read(data[4:])
-			if n > 0 {
-				if ioErr := mc.conn().writePacket(data[:4+n]); ioErr != nil {
-					return ioErr
-				}
-			}
-		}
-		if err == io.EOF {
-			err = nil
-		}
-	}
-
-	// send empty packet (termination)
-	if data == nil {
-		data = make([]byte, 4)
-	}
-	if ioErr := mc.conn().writePacket(data[:4]); ioErr != nil {
-		return ioErr
-	}
-
-	// read OK packet
-	if err == nil {
-		return mc.readResultOK()
-	}
-
-	mc.conn().readPacket()
-	return err
-}

documentation/licenses/github.com/go-sql-driver/mysql/nulltime.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2013 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"
-	"database/sql/driver"
-	"fmt"
-	"time"
-)
-
-// 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.
-type NullTime sql.NullTime
-
-// Scan implements the Scanner interface.
-// The value type must be time.Time or string / []byte (formatted time-string),
-// otherwise Scan fails.
-func (nt *NullTime) Scan(value any) (err error) {
-	if value == nil {
-		nt.Time, nt.Valid = time.Time{}, false
-		return
-	}
-
-	switch v := value.(type) {
-	case time.Time:
-		nt.Time, nt.Valid = v, true
-		return
-	case []byte:
-		nt.Time, err = parseDateTime(v, time.UTC)
-		nt.Valid = (err == nil)
-		return
-	case string:
-		nt.Time, err = parseDateTime([]byte(v), time.UTC)
-		nt.Valid = (err == nil)
-		return
-	}
-
-	nt.Valid = false
-	return fmt.Errorf("can't convert %T to time.Time", value)
-}
-
-// Value implements the driver Valuer interface.
-func (nt NullTime) Value() (driver.Value, error) {
-	if !nt.Valid {
-		return nil, nil
-	}
-	return nt.Time, nil
-}

documentation/licenses/github.com/go-sql-driver/mysql/packets.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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 (
-	"bytes"
-	"crypto/tls"
-	"database/sql/driver"
-	"encoding/binary"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"time"
-)
-
-// Packets documentation:
-// http://dev.mysql.com/doc/internals/en/client-server-protocol.html
-
-// Read packet to buffer 'data'
-func (mc *mysqlConn) readPacket() ([]byte, error) {
-	var prevData []byte
-	for {
-		// read packet header
-		data, err := mc.buf.readNext(4)
-		if err != nil {
-			if cerr := mc.canceled.Value(); cerr != nil {
-				return nil, cerr
-			}
-			mc.log(err)
-			mc.Close()
-			return nil, ErrInvalidConn
-		}
-
-		// packet length [24 bit]
-		pktLen := int(uint32(data[0]) | uint32(data[1])<<8 | uint32(data[2])<<16)
-
-		// check packet sync [8 bit]
-		if data[3] != mc.sequence {
-			mc.Close()
-			if data[3] > mc.sequence {
-				return nil, ErrPktSyncMul
-			}
-			return nil, ErrPktSync
-		}
-		mc.sequence++
-
-		// packets with length 0 terminate a previous packet which is a
-		// multiple of (2^24)-1 bytes long
-		if pktLen == 0 {
-			// there was no previous packet
-			if prevData == nil {
-				mc.log(ErrMalformPkt)
-				mc.Close()
-				return nil, ErrInvalidConn
-			}
-
-			return prevData, nil
-		}
-
-		// read packet body [pktLen bytes]
-		data, err = mc.buf.readNext(pktLen)
-		if err != nil {
-			if cerr := mc.canceled.Value(); cerr != nil {
-				return nil, cerr
-			}
-			mc.log(err)
-			mc.Close()
-			return nil, ErrInvalidConn
-		}
-
-		// return data if this was the last packet
-		if pktLen < maxPacketSize {
-			// zero allocations for non-split packets
-			if prevData == nil {
-				return data, nil
-			}
-
-			return append(prevData, data...), nil
-		}
-
-		prevData = append(prevData, data...)
-	}
-}
-
-// Write packet buffer 'data'
-func (mc *mysqlConn) writePacket(data []byte) error {
-	pktLen := len(data) - 4
-
-	if pktLen > mc.maxAllowedPacket {
-		return ErrPktTooLarge
-	}
-
-	for {
-		var size int
-		if pktLen >= maxPacketSize {
-			data[0] = 0xff
-			data[1] = 0xff
-			data[2] = 0xff
-			size = maxPacketSize
-		} else {
-			data[0] = byte(pktLen)
-			data[1] = byte(pktLen >> 8)
-			data[2] = byte(pktLen >> 16)
-			size = pktLen
-		}
-		data[3] = mc.sequence
-
-		// Write packet
-		if mc.writeTimeout > 0 {
-			if err := mc.netConn.SetWriteDeadline(time.Now().Add(mc.writeTimeout)); err != nil {
-				return err
-			}
-		}
-
-		n, err := mc.netConn.Write(data[:4+size])
-		if err == nil && n == 4+size {
-			mc.sequence++
-			if size != maxPacketSize {
-				return nil
-			}
-			pktLen -= size
-			data = data[size:]
-			continue
-		}
-
-		// Handle error
-		if err == nil { // n != len(data)
-			mc.cleanup()
-			mc.log(ErrMalformPkt)
-		} else {
-			if cerr := mc.canceled.Value(); cerr != nil {
-				return cerr
-			}
-			if n == 0 && pktLen == len(data)-4 {
-				// only for the first loop iteration when nothing was written yet
-				return errBadConnNoWrite
-			}
-			mc.cleanup()
-			mc.log(err)
-		}
-		return ErrInvalidConn
-	}
-}
-
-/******************************************************************************
-*                           Initialization Process                            *
-******************************************************************************/
-
-// Handshake Initialization Packet
-// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake
-func (mc *mysqlConn) readHandshakePacket() (data []byte, plugin string, err error) {
-	data, err = mc.readPacket()
-	if err != nil {
-		// for init we can rewrite this to ErrBadConn for sql.Driver to retry, since
-		// in connection initialization we don't risk retrying non-idempotent actions.
-		if err == ErrInvalidConn {
-			return nil, "", driver.ErrBadConn
-		}
-		return
-	}
-
-	if data[0] == iERR {
-		return nil, "", mc.handleErrorPacket(data)
-	}
-
-	// protocol version [1 byte]
-	if data[0] < minProtocolVersion {
-		return nil, "", fmt.Errorf(
-			"unsupported protocol version %d. Version %d or higher is required",
-			data[0],
-			minProtocolVersion,
-		)
-	}
-
-	// server version [null terminated string]
-	// connection id [4 bytes]
-	pos := 1 + bytes.IndexByte(data[1:], 0x00) + 1 + 4
-
-	// first part of the password cipher [8 bytes]
-	authData := data[pos : pos+8]
-
-	// (filler) always 0x00 [1 byte]
-	pos += 8 + 1
-
-	// capability flags (lower 2 bytes) [2 bytes]
-	mc.flags = clientFlag(binary.LittleEndian.Uint16(data[pos : pos+2]))
-	if mc.flags&clientProtocol41 == 0 {
-		return nil, "", ErrOldProtocol
-	}
-	if mc.flags&clientSSL == 0 && mc.cfg.TLS != nil {
-		if mc.cfg.AllowFallbackToPlaintext {
-			mc.cfg.TLS = nil
-		} else {
-			return nil, "", ErrNoTLS
-		}
-	}
-	pos += 2
-
-	if len(data) > pos {
-		// character set [1 byte]
-		// status flags [2 bytes]
-		// capability flags (upper 2 bytes) [2 bytes]
-		// length of auth-plugin-data [1 byte]
-		// reserved (all [00]) [10 bytes]
-		pos += 1 + 2 + 2 + 1 + 10
-
-		// second part of the password cipher [minimum 13 bytes],
-		// where len=MAX(13, length of auth-plugin-data - 8)
-		//
-		// The web documentation is ambiguous about the length. However,
-		// according to mysql-5.7/sql/auth/sql_authentication.cc line 538,
-		// the 13th byte is "\0 byte, terminating the second part of
-		// a scramble". So the second part of the password cipher is
-		// a NULL terminated string that's at least 13 bytes with the
-		// last byte being NULL.
-		//
-		// The official Python library uses the fixed length 12
-		// which seems to work but technically could have a hidden bug.
-		authData = append(authData, data[pos:pos+12]...)
-		pos += 13
-
-		// EOF if version (>= 5.5.7 and < 5.5.10) or (>= 5.6.0 and < 5.6.2)
-		// \NUL otherwise
-		if end := bytes.IndexByte(data[pos:], 0x00); end != -1 {
-			plugin = string(data[pos : pos+end])
-		} else {
-			plugin = string(data[pos:])
-		}
-
-		// make a memory safe copy of the cipher slice
-		var b [20]byte
-		copy(b[:], authData)
-		return b[:], plugin, nil
-	}
-
-	// make a memory safe copy of the cipher slice
-	var b [8]byte
-	copy(b[:], authData)
-	return b[:], plugin, nil
-}
-
-// Client Authentication Packet
-// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::HandshakeResponse
-func (mc *mysqlConn) writeHandshakeResponsePacket(authResp []byte, plugin string) error {
-	// Adjust client flags based on server support
-	clientFlags := clientProtocol41 |
-		clientSecureConn |
-		clientLongPassword |
-		clientTransactions |
-		clientLocalFiles |
-		clientPluginAuth |
-		clientMultiResults |
-		clientConnectAttrs |
-		mc.flags&clientLongFlag
-
-	if mc.cfg.ClientFoundRows {
-		clientFlags |= clientFoundRows
-	}
-
-	// To enable TLS / SSL
-	if mc.cfg.TLS != nil {
-		clientFlags |= clientSSL
-	}
-
-	if mc.cfg.MultiStatements {
-		clientFlags |= clientMultiStatements
-	}
-
-	// encode length of the auth plugin data
-	var authRespLEIBuf [9]byte
-	authRespLen := len(authResp)
-	authRespLEI := appendLengthEncodedInteger(authRespLEIBuf[:0], uint64(authRespLen))
-	if len(authRespLEI) > 1 {
-		// if the length can not be written in 1 byte, it must be written as a
-		// length encoded integer
-		clientFlags |= clientPluginAuthLenEncClientData
-	}
-
-	pktLen := 4 + 4 + 1 + 23 + len(mc.cfg.User) + 1 + len(authRespLEI) + len(authResp) + 21 + 1
-
-	// To specify a db name
-	if n := len(mc.cfg.DBName); n > 0 {
-		clientFlags |= clientConnectWithDB
-		pktLen += n + 1
-	}
-
-	// encode length of the connection attributes
-	var connAttrsLEIBuf [9]byte
-	connAttrsLen := len(mc.connector.encodedAttributes)
-	connAttrsLEI := appendLengthEncodedInteger(connAttrsLEIBuf[:0], uint64(connAttrsLen))
-	pktLen += len(connAttrsLEI) + len(mc.connector.encodedAttributes)
-
-	// Calculate packet length and get buffer with that size
-	data, err := mc.buf.takeBuffer(pktLen + 4)
-	if err != nil {
-		// cannot take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return errBadConnNoWrite
-	}
-
-	// ClientFlags [32 bit]
-	data[4] = byte(clientFlags)
-	data[5] = byte(clientFlags >> 8)
-	data[6] = byte(clientFlags >> 16)
-	data[7] = byte(clientFlags >> 24)
-
-	// MaxPacketSize [32 bit] (none)
-	data[8] = 0x00
-	data[9] = 0x00
-	data[10] = 0x00
-	data[11] = 0x00
-
-	// Collation ID [1 byte]
-	cname := mc.cfg.Collation
-	if cname == "" {
-		cname = defaultCollation
-	}
-	var found bool
-	data[12], found = collations[cname]
-	if !found {
-		// Note possibility for false negatives:
-		// could be triggered  although the collation is valid if the
-		// collations map does not contain entries the server supports.
-		return fmt.Errorf("unknown collation: %q", cname)
-	}
-
-	// Filler [23 bytes] (all 0x00)
-	pos := 13
-	for ; pos < 13+23; pos++ {
-		data[pos] = 0
-	}
-
-	// SSL Connection Request Packet
-	// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::SSLRequest
-	if mc.cfg.TLS != nil {
-		// Send TLS / SSL request packet
-		if err := mc.writePacket(data[:(4+4+1+23)+4]); err != nil {
-			return err
-		}
-
-		// Switch to TLS
-		tlsConn := tls.Client(mc.netConn, mc.cfg.TLS)
-		if err := tlsConn.Handshake(); err != nil {
-			return err
-		}
-		mc.netConn = tlsConn
-		mc.buf.nc = tlsConn
-	}
-
-	// User [null terminated string]
-	if len(mc.cfg.User) > 0 {
-		pos += copy(data[pos:], mc.cfg.User)
-	}
-	data[pos] = 0x00
-	pos++
-
-	// Auth Data [length encoded integer]
-	pos += copy(data[pos:], authRespLEI)
-	pos += copy(data[pos:], authResp)
-
-	// Databasename [null terminated string]
-	if len(mc.cfg.DBName) > 0 {
-		pos += copy(data[pos:], mc.cfg.DBName)
-		data[pos] = 0x00
-		pos++
-	}
-
-	pos += copy(data[pos:], plugin)
-	data[pos] = 0x00
-	pos++
-
-	// Connection Attributes
-	pos += copy(data[pos:], connAttrsLEI)
-	pos += copy(data[pos:], []byte(mc.connector.encodedAttributes))
-
-	// Send Auth packet
-	return mc.writePacket(data[:pos])
-}
-
-// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::AuthSwitchResponse
-func (mc *mysqlConn) writeAuthSwitchPacket(authData []byte) error {
-	pktLen := 4 + len(authData)
-	data, err := mc.buf.takeSmallBuffer(pktLen)
-	if err != nil {
-		// cannot take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return errBadConnNoWrite
-	}
-
-	// Add the auth data [EOF]
-	copy(data[4:], authData)
-	return mc.writePacket(data)
-}
-
-/******************************************************************************
-*                             Command Packets                                 *
-******************************************************************************/
-
-func (mc *mysqlConn) writeCommandPacket(command byte) error {
-	// Reset Packet Sequence
-	mc.sequence = 0
-
-	data, err := mc.buf.takeSmallBuffer(4 + 1)
-	if err != nil {
-		// cannot take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return errBadConnNoWrite
-	}
-
-	// Add command byte
-	data[4] = command
-
-	// Send CMD packet
-	return mc.writePacket(data)
-}
-
-func (mc *mysqlConn) writeCommandPacketStr(command byte, arg string) error {
-	// Reset Packet Sequence
-	mc.sequence = 0
-
-	pktLen := 1 + len(arg)
-	data, err := mc.buf.takeBuffer(pktLen + 4)
-	if err != nil {
-		// cannot take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return errBadConnNoWrite
-	}
-
-	// Add command byte
-	data[4] = command
-
-	// Add arg
-	copy(data[5:], arg)
-
-	// Send CMD packet
-	return mc.writePacket(data)
-}
-
-func (mc *mysqlConn) writeCommandPacketUint32(command byte, arg uint32) error {
-	// Reset Packet Sequence
-	mc.sequence = 0
-
-	data, err := mc.buf.takeSmallBuffer(4 + 1 + 4)
-	if err != nil {
-		// cannot take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return errBadConnNoWrite
-	}
-
-	// Add command byte
-	data[4] = command
-
-	// Add arg [32 bit]
-	data[5] = byte(arg)
-	data[6] = byte(arg >> 8)
-	data[7] = byte(arg >> 16)
-	data[8] = byte(arg >> 24)
-
-	// Send CMD packet
-	return mc.writePacket(data)
-}
-
-/******************************************************************************
-*                              Result Packets                                 *
-******************************************************************************/
-
-func (mc *mysqlConn) readAuthResult() ([]byte, string, error) {
-	data, err := mc.readPacket()
-	if err != nil {
-		return nil, "", err
-	}
-
-	// packet indicator
-	switch data[0] {
-
-	case iOK:
-		// resultUnchanged, since auth happens before any queries or
-		// commands have been executed.
-		return nil, "", mc.resultUnchanged().handleOkPacket(data)
-
-	case iAuthMoreData:
-		return data[1:], "", err
-
-	case iEOF:
-		if len(data) == 1 {
-			// https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::OldAuthSwitchRequest
-			return nil, "mysql_old_password", nil
-		}
-		pluginEndIndex := bytes.IndexByte(data, 0x00)
-		if pluginEndIndex < 0 {
-			return nil, "", ErrMalformPkt
-		}
-		plugin := string(data[1:pluginEndIndex])
-		authData := data[pluginEndIndex+1:]
-		return authData, plugin, nil
-
-	default: // Error otherwise
-		return nil, "", mc.handleErrorPacket(data)
-	}
-}
-
-// Returns error if Packet is not a 'Result OK'-Packet
-func (mc *okHandler) readResultOK() error {
-	data, err := mc.conn().readPacket()
-	if err != nil {
-		return err
-	}
-
-	if data[0] == iOK {
-		return mc.handleOkPacket(data)
-	}
-	return mc.conn().handleErrorPacket(data)
-}
-
-// Result Set Header Packet
-// http://dev.mysql.com/doc/internals/en/com-query-response.html#packet-ProtocolText::Resultset
-func (mc *okHandler) readResultSetHeaderPacket() (int, error) {
-	// handleOkPacket replaces both values; other cases leave the values unchanged.
-	mc.result.affectedRows = append(mc.result.affectedRows, 0)
-	mc.result.insertIds = append(mc.result.insertIds, 0)
-
-	data, err := mc.conn().readPacket()
-	if err == nil {
-		switch data[0] {
-
-		case iOK:
-			return 0, mc.handleOkPacket(data)
-
-		case iERR:
-			return 0, mc.conn().handleErrorPacket(data)
-
-		case iLocalInFile:
-			return 0, mc.handleInFileRequest(string(data[1:]))
-		}
-
-		// column count
-		num, _, _ := readLengthEncodedInteger(data)
-		// ignore remaining data in the packet. see #1478.
-		return int(num), nil
-	}
-	return 0, err
-}
-
-// Error Packet
-// http://dev.mysql.com/doc/internals/en/generic-response-packets.html#packet-ERR_Packet
-func (mc *mysqlConn) handleErrorPacket(data []byte) error {
-	if data[0] != iERR {
-		return ErrMalformPkt
-	}
-
-	// 0xff [1 byte]
-
-	// Error Number [16 bit uint]
-	errno := binary.LittleEndian.Uint16(data[1:3])
-
-	// 1792: ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION
-	// 1290: ER_OPTION_PREVENTS_STATEMENT (returned by Aurora during failover)
-	if (errno == 1792 || errno == 1290) && mc.cfg.RejectReadOnly {
-		// Oops; we are connected to a read-only connection, and won't be able
-		// to issue any write statements. Since RejectReadOnly is configured,
-		// we throw away this connection hoping this one would have write
-		// permission. This is specifically for a possible race condition
-		// during failover (e.g. on AWS Aurora). See README.md for more.
-		//
-		// We explicitly close the connection before returning
-		// driver.ErrBadConn to ensure that `database/sql` purges this
-		// connection and initiates a new one for next statement next time.
-		mc.Close()
-		return driver.ErrBadConn
-	}
-
-	me := &MySQLError{Number: errno}
-
-	pos := 3
-
-	// SQL State [optional: # + 5bytes string]
-	if data[3] == 0x23 {
-		copy(me.SQLState[:], data[4:4+5])
-		pos = 9
-	}
-
-	// Error Message [string]
-	me.Message = string(data[pos:])
-
-	return me
-}
-
-func readStatus(b []byte) statusFlag {
-	return statusFlag(b[0]) | statusFlag(b[1])<<8
-}
-
-// Returns an instance of okHandler for codepaths where mysqlConn.result doesn't
-// need to be cleared first (e.g. during authentication, or while additional
-// resultsets are being fetched.)
-func (mc *mysqlConn) resultUnchanged() *okHandler {
-	return (*okHandler)(mc)
-}
-
-// okHandler represents the state of the connection when mysqlConn.result has
-// been prepared for processing of OK packets.
-//
-// To correctly populate mysqlConn.result (updated by handleOkPacket()), all
-// callpaths must either:
-//
-// 1. first clear it using clearResult(), or
-// 2. confirm that they don't need to (by calling resultUnchanged()).
-//
-// Both return an instance of type *okHandler.
-type okHandler mysqlConn
-
-// Exposes the underlying type's methods.
-func (mc *okHandler) conn() *mysqlConn {
-	return (*mysqlConn)(mc)
-}
-
-// clearResult clears the connection's stored affectedRows and insertIds
-// fields.
-//
-// It returns a handler that can process OK responses.
-func (mc *mysqlConn) clearResult() *okHandler {
-	mc.result = mysqlResult{}
-	return (*okHandler)(mc)
-}
-
-// Ok Packet
-// http://dev.mysql.com/doc/internals/en/generic-response-packets.html#packet-OK_Packet
-func (mc *okHandler) handleOkPacket(data []byte) error {
-	var n, m int
-	var affectedRows, insertId uint64
-
-	// 0x00 [1 byte]
-
-	// Affected rows [Length Coded Binary]
-	affectedRows, _, n = readLengthEncodedInteger(data[1:])
-
-	// Insert id [Length Coded Binary]
-	insertId, _, m = readLengthEncodedInteger(data[1+n:])
-
-	// Update for the current statement result (only used by
-	// readResultSetHeaderPacket).
-	if len(mc.result.affectedRows) > 0 {
-		mc.result.affectedRows[len(mc.result.affectedRows)-1] = int64(affectedRows)
-	}
-	if len(mc.result.insertIds) > 0 {
-		mc.result.insertIds[len(mc.result.insertIds)-1] = int64(insertId)
-	}
-
-	// server_status [2 bytes]
-	mc.status = readStatus(data[1+n+m : 1+n+m+2])
-	if mc.status&statusMoreResultsExists != 0 {
-		return nil
-	}
-
-	// warning count [2 bytes]
-
-	return nil
-}
-
-// Read Packets as Field Packets until EOF-Packet or an Error appears
-// http://dev.mysql.com/doc/internals/en/com-query-response.html#packet-Protocol::ColumnDefinition41
-func (mc *mysqlConn) readColumns(count int) ([]mysqlField, error) {
-	columns := make([]mysqlField, count)
-
-	for i := 0; ; i++ {
-		data, err := mc.readPacket()
-		if err != nil {
-			return nil, err
-		}
-
-		// EOF Packet
-		if data[0] == iEOF && (len(data) == 5 || len(data) == 1) {
-			if i == count {
-				return columns, nil
-			}
-			return nil, fmt.Errorf("column count mismatch n:%d len:%d", count, len(columns))
-		}
-
-		// Catalog
-		pos, err := skipLengthEncodedString(data)
-		if err != nil {
-			return nil, err
-		}
-
-		// Database [len coded string]
-		n, err := skipLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		pos += n
-
-		// Table [len coded string]
-		if mc.cfg.ColumnsWithAlias {
-			tableName, _, n, err := readLengthEncodedString(data[pos:])
-			if err != nil {
-				return nil, err
-			}
-			pos += n
-			columns[i].tableName = string(tableName)
-		} else {
-			n, err = skipLengthEncodedString(data[pos:])
-			if err != nil {
-				return nil, err
-			}
-			pos += n
-		}
-
-		// Original table [len coded string]
-		n, err = skipLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		pos += n
-
-		// Name [len coded string]
-		name, _, n, err := readLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		columns[i].name = string(name)
-		pos += n
-
-		// Original name [len coded string]
-		n, err = skipLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		pos += n
-
-		// Filler [uint8]
-		pos++
-
-		// Charset [charset, collation uint8]
-		columns[i].charSet = data[pos]
-		pos += 2
-
-		// Length [uint32]
-		columns[i].length = binary.LittleEndian.Uint32(data[pos : pos+4])
-		pos += 4
-
-		// Field type [uint8]
-		columns[i].fieldType = fieldType(data[pos])
-		pos++
-
-		// Flags [uint16]
-		columns[i].flags = fieldFlag(binary.LittleEndian.Uint16(data[pos : pos+2]))
-		pos += 2
-
-		// Decimals [uint8]
-		columns[i].decimals = data[pos]
-		//pos++
-
-		// Default value [len coded binary]
-		//if pos < len(data) {
-		//	defaultVal, _, err = bytesToLengthCodedBinary(data[pos:])
-		//}
-	}
-}
-
-// Read Packets as Field Packets until EOF-Packet or an Error appears
-// http://dev.mysql.com/doc/internals/en/com-query-response.html#packet-ProtocolText::ResultsetRow
-func (rows *textRows) readRow(dest []driver.Value) error {
-	mc := rows.mc
-
-	if rows.rs.done {
-		return io.EOF
-	}
-
-	data, err := mc.readPacket()
-	if err != nil {
-		return err
-	}
-
-	// EOF Packet
-	if data[0] == iEOF && len(data) == 5 {
-		// server_status [2 bytes]
-		rows.mc.status = readStatus(data[3:])
-		rows.rs.done = true
-		if !rows.HasNextResultSet() {
-			rows.mc = nil
-		}
-		return io.EOF
-	}
-	if data[0] == iERR {
-		rows.mc = nil
-		return mc.handleErrorPacket(data)
-	}
-
-	// RowSet Packet
-	var (
-		n      int
-		isNull bool
-		pos    int = 0
-	)
-
-	for i := range dest {
-		// Read bytes and convert to string
-		var buf []byte
-		buf, isNull, n, err = readLengthEncodedString(data[pos:])
-		pos += n
-
-		if err != nil {
-			return err
-		}
-
-		if isNull {
-			dest[i] = nil
-			continue
-		}
-
-		switch rows.rs.columns[i].fieldType {
-		case fieldTypeTimestamp,
-			fieldTypeDateTime,
-			fieldTypeDate,
-			fieldTypeNewDate:
-			if mc.parseTime {
-				dest[i], err = parseDateTime(buf, mc.cfg.Loc)
-			} else {
-				dest[i] = buf
-			}
-
-		case fieldTypeTiny, fieldTypeShort, fieldTypeInt24, fieldTypeYear, fieldTypeLong:
-			dest[i], err = strconv.ParseInt(string(buf), 10, 64)
-
-		case fieldTypeLongLong:
-			if rows.rs.columns[i].flags&flagUnsigned != 0 {
-				dest[i], err = strconv.ParseUint(string(buf), 10, 64)
-			} else {
-				dest[i], err = strconv.ParseInt(string(buf), 10, 64)
-			}
-
-		case fieldTypeFloat:
-			var d float64
-			d, err = strconv.ParseFloat(string(buf), 32)
-			dest[i] = float32(d)
-
-		case fieldTypeDouble:
-			dest[i], err = strconv.ParseFloat(string(buf), 64)
-
-		default:
-			dest[i] = buf
-		}
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Reads Packets until EOF-Packet or an Error appears. Returns count of Packets read
-func (mc *mysqlConn) readUntilEOF() error {
-	for {
-		data, err := mc.readPacket()
-		if err != nil {
-			return err
-		}
-
-		switch data[0] {
-		case iERR:
-			return mc.handleErrorPacket(data)
-		case iEOF:
-			if len(data) == 5 {
-				mc.status = readStatus(data[3:])
-			}
-			return nil
-		}
-	}
-}
-
-/******************************************************************************
-*                           Prepared Statements                               *
-******************************************************************************/
-
-// Prepare Result Packets
-// http://dev.mysql.com/doc/internals/en/com-stmt-prepare-response.html
-func (stmt *mysqlStmt) readPrepareResultPacket() (uint16, error) {
-	data, err := stmt.mc.readPacket()
-	if err == nil {
-		// packet indicator [1 byte]
-		if data[0] != iOK {
-			return 0, stmt.mc.handleErrorPacket(data)
-		}
-
-		// statement id [4 bytes]
-		stmt.id = binary.LittleEndian.Uint32(data[1:5])
-
-		// Column count [16 bit uint]
-		columnCount := binary.LittleEndian.Uint16(data[5:7])
-
-		// Param count [16 bit uint]
-		stmt.paramCount = int(binary.LittleEndian.Uint16(data[7:9]))
-
-		// Reserved [8 bit]
-
-		// Warning count [16 bit uint]
-
-		return columnCount, nil
-	}
-	return 0, err
-}
-
-// http://dev.mysql.com/doc/internals/en/com-stmt-send-long-data.html
-func (stmt *mysqlStmt) writeCommandLongData(paramID int, arg []byte) error {
-	maxLen := stmt.mc.maxAllowedPacket - 1
-	pktLen := maxLen
-
-	// After the header (bytes 0-3) follows before the data:
-	// 1 byte command
-	// 4 bytes stmtID
-	// 2 bytes paramID
-	const dataOffset = 1 + 4 + 2
-
-	// Cannot use the write buffer since
-	// a) the buffer is too small
-	// b) it is in use
-	data := make([]byte, 4+1+4+2+len(arg))
-
-	copy(data[4+dataOffset:], arg)
-
-	for argLen := len(arg); argLen > 0; argLen -= pktLen - dataOffset {
-		if dataOffset+argLen < maxLen {
-			pktLen = dataOffset + argLen
-		}
-
-		stmt.mc.sequence = 0
-		// Add command byte [1 byte]
-		data[4] = comStmtSendLongData
-
-		// Add stmtID [32 bit]
-		data[5] = byte(stmt.id)
-		data[6] = byte(stmt.id >> 8)
-		data[7] = byte(stmt.id >> 16)
-		data[8] = byte(stmt.id >> 24)
-
-		// Add paramID [16 bit]
-		data[9] = byte(paramID)
-		data[10] = byte(paramID >> 8)
-
-		// Send CMD packet
-		err := stmt.mc.writePacket(data[:4+pktLen])
-		if err == nil {
-			data = data[pktLen-dataOffset:]
-			continue
-		}
-		return err
-
-	}
-
-	// Reset Packet Sequence
-	stmt.mc.sequence = 0
-	return nil
-}
-
-// Execute Prepared Statement
-// http://dev.mysql.com/doc/internals/en/com-stmt-execute.html
-func (stmt *mysqlStmt) writeExecutePacket(args []driver.Value) error {
-	if len(args) != stmt.paramCount {
-		return fmt.Errorf(
-			"argument count mismatch (got: %d; has: %d)",
-			len(args),
-			stmt.paramCount,
-		)
-	}
-
-	const minPktLen = 4 + 1 + 4 + 1 + 4
-	mc := stmt.mc
-
-	// Determine threshold dynamically to avoid packet size shortage.
-	longDataSize := mc.maxAllowedPacket / (stmt.paramCount + 1)
-	if longDataSize < 64 {
-		longDataSize = 64
-	}
-
-	// Reset packet-sequence
-	mc.sequence = 0
-
-	var data []byte
-	var err error
-
-	if len(args) == 0 {
-		data, err = mc.buf.takeBuffer(minPktLen)
-	} else {
-		data, err = mc.buf.takeCompleteBuffer()
-		// In this case the len(data) == cap(data) which is used to optimise the flow below.
-	}
-	if err != nil {
-		// cannot take the buffer. Something must be wrong with the connection
-		mc.log(err)
-		return errBadConnNoWrite
-	}
-
-	// command [1 byte]
-	data[4] = comStmtExecute
-
-	// statement_id [4 bytes]
-	data[5] = byte(stmt.id)
-	data[6] = byte(stmt.id >> 8)
-	data[7] = byte(stmt.id >> 16)
-	data[8] = byte(stmt.id >> 24)
-
-	// flags (0: CURSOR_TYPE_NO_CURSOR) [1 byte]
-	data[9] = 0x00
-
-	// iteration_count (uint32(1)) [4 bytes]
-	data[10] = 0x01
-	data[11] = 0x00
-	data[12] = 0x00
-	data[13] = 0x00
-
-	if len(args) > 0 {
-		pos := minPktLen
-
-		var nullMask []byte
-		if maskLen, typesLen := (len(args)+7)/8, 1+2*len(args); pos+maskLen+typesLen >= cap(data) {
-			// buffer has to be extended but we don't know by how much so
-			// we depend on append after all data with known sizes fit.
-			// We stop at that because we deal with a lot of columns here
-			// which makes the required allocation size hard to guess.
-			tmp := make([]byte, pos+maskLen+typesLen)
-			copy(tmp[:pos], data[:pos])
-			data = tmp
-			nullMask = data[pos : pos+maskLen]
-			// No need to clean nullMask as make ensures that.
-			pos += maskLen
-		} else {
-			nullMask = data[pos : pos+maskLen]
-			for i := range nullMask {
-				nullMask[i] = 0
-			}
-			pos += maskLen
-		}
-
-		// newParameterBoundFlag 1 [1 byte]
-		data[pos] = 0x01
-		pos++
-
-		// type of each parameter [len(args)*2 bytes]
-		paramTypes := data[pos:]
-		pos += len(args) * 2
-
-		// value of each parameter [n bytes]
-		paramValues := data[pos:pos]
-		valuesCap := cap(paramValues)
-
-		for i, arg := range args {
-			// build NULL-bitmap
-			if arg == nil {
-				nullMask[i/8] |= 1 << (uint(i) & 7)
-				paramTypes[i+i] = byte(fieldTypeNULL)
-				paramTypes[i+i+1] = 0x00
-				continue
-			}
-
-			if v, ok := arg.(json.RawMessage); ok {
-				arg = []byte(v)
-			}
-			// cache types and values
-			switch v := arg.(type) {
-			case int64:
-				paramTypes[i+i] = byte(fieldTypeLongLong)
-				paramTypes[i+i+1] = 0x00
-
-				if cap(paramValues)-len(paramValues)-8 >= 0 {
-					paramValues = paramValues[:len(paramValues)+8]
-					binary.LittleEndian.PutUint64(
-						paramValues[len(paramValues)-8:],
-						uint64(v),
-					)
-				} else {
-					paramValues = append(paramValues,
-						uint64ToBytes(uint64(v))...,
-					)
-				}
-
-			case uint64:
-				paramTypes[i+i] = byte(fieldTypeLongLong)
-				paramTypes[i+i+1] = 0x80 // type is unsigned
-
-				if cap(paramValues)-len(paramValues)-8 >= 0 {
-					paramValues = paramValues[:len(paramValues)+8]
-					binary.LittleEndian.PutUint64(
-						paramValues[len(paramValues)-8:],
-						uint64(v),
-					)
-				} else {
-					paramValues = append(paramValues,
-						uint64ToBytes(uint64(v))...,
-					)
-				}
-
-			case float64:
-				paramTypes[i+i] = byte(fieldTypeDouble)
-				paramTypes[i+i+1] = 0x00
-
-				if cap(paramValues)-len(paramValues)-8 >= 0 {
-					paramValues = paramValues[:len(paramValues)+8]
-					binary.LittleEndian.PutUint64(
-						paramValues[len(paramValues)-8:],
-						math.Float64bits(v),
-					)
-				} else {
-					paramValues = append(paramValues,
-						uint64ToBytes(math.Float64bits(v))...,
-					)
-				}
-
-			case bool:
-				paramTypes[i+i] = byte(fieldTypeTiny)
-				paramTypes[i+i+1] = 0x00
-
-				if v {
-					paramValues = append(paramValues, 0x01)
-				} else {
-					paramValues = append(paramValues, 0x00)
-				}
-
-			case []byte:
-				// Common case (non-nil value) first
-				if v != nil {
-					paramTypes[i+i] = byte(fieldTypeString)
-					paramTypes[i+i+1] = 0x00
-
-					if len(v) < longDataSize {
-						paramValues = appendLengthEncodedInteger(paramValues,
-							uint64(len(v)),
-						)
-						paramValues = append(paramValues, v...)
-					} else {
-						if err := stmt.writeCommandLongData(i, v); err != nil {
-							return err
-						}
-					}
-					continue
-				}
-
-				// Handle []byte(nil) as a NULL value
-				nullMask[i/8] |= 1 << (uint(i) & 7)
-				paramTypes[i+i] = byte(fieldTypeNULL)
-				paramTypes[i+i+1] = 0x00
-
-			case string:
-				paramTypes[i+i] = byte(fieldTypeString)
-				paramTypes[i+i+1] = 0x00
-
-				if len(v) < longDataSize {
-					paramValues = appendLengthEncodedInteger(paramValues,
-						uint64(len(v)),
-					)
-					paramValues = append(paramValues, v...)
-				} else {
-					if err := stmt.writeCommandLongData(i, []byte(v)); err != nil {
-						return err
-					}
-				}
-
-			case time.Time:
-				paramTypes[i+i] = byte(fieldTypeString)
-				paramTypes[i+i+1] = 0x00
-
-				var a [64]byte
-				var b = a[:0]
-
-				if v.IsZero() {
-					b = append(b, "0000-00-00"...)
-				} else {
-					b, err = appendDateTime(b, v.In(mc.cfg.Loc), mc.cfg.timeTruncate)
-					if err != nil {
-						return err
-					}
-				}
-
-				paramValues = appendLengthEncodedInteger(paramValues,
-					uint64(len(b)),
-				)
-				paramValues = append(paramValues, b...)
-
-			default:
-				return fmt.Errorf("cannot convert type: %T", arg)
-			}
-		}
-
-		// Check if param values exceeded the available buffer
-		// In that case we must build the data packet with the new values buffer
-		if valuesCap != cap(paramValues) {
-			data = append(data[:pos], paramValues...)
-			if err = mc.buf.store(data); err != nil {
-				mc.log(err)
-				return errBadConnNoWrite
-			}
-		}
-
-		pos += len(paramValues)
-		data = data[:pos]
-	}
-
-	return mc.writePacket(data)
-}
-
-// For each remaining resultset in the stream, discards its rows and updates
-// mc.affectedRows and mc.insertIds.
-func (mc *okHandler) discardResults() error {
-	for mc.status&statusMoreResultsExists != 0 {
-		resLen, err := mc.readResultSetHeaderPacket()
-		if err != nil {
-			return err
-		}
-		if resLen > 0 {
-			// columns
-			if err := mc.conn().readUntilEOF(); err != nil {
-				return err
-			}
-			// rows
-			if err := mc.conn().readUntilEOF(); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// http://dev.mysql.com/doc/internals/en/binary-protocol-resultset-row.html
-func (rows *binaryRows) readRow(dest []driver.Value) error {
-	data, err := rows.mc.readPacket()
-	if err != nil {
-		return err
-	}
-
-	// packet indicator [1 byte]
-	if data[0] != iOK {
-		// EOF Packet
-		if data[0] == iEOF && len(data) == 5 {
-			rows.mc.status = readStatus(data[3:])
-			rows.rs.done = true
-			if !rows.HasNextResultSet() {
-				rows.mc = nil
-			}
-			return io.EOF
-		}
-		mc := rows.mc
-		rows.mc = nil
-
-		// Error otherwise
-		return mc.handleErrorPacket(data)
-	}
-
-	// NULL-bitmap,  [(column-count + 7 + 2) / 8 bytes]
-	pos := 1 + (len(dest)+7+2)>>3
-	nullMask := data[1:pos]
-
-	for i := range dest {
-		// Field is NULL
-		// (byte >> bit-pos) % 2 == 1
-		if ((nullMask[(i+2)>>3] >> uint((i+2)&7)) & 1) == 1 {
-			dest[i] = nil
-			continue
-		}
-
-		// Convert to byte-coded string
-		switch rows.rs.columns[i].fieldType {
-		case fieldTypeNULL:
-			dest[i] = nil
-			continue
-
-		// Numeric Types
-		case fieldTypeTiny:
-			if rows.rs.columns[i].flags&flagUnsigned != 0 {
-				dest[i] = int64(data[pos])
-			} else {
-				dest[i] = int64(int8(data[pos]))
-			}
-			pos++
-			continue
-
-		case fieldTypeShort, fieldTypeYear:
-			if rows.rs.columns[i].flags&flagUnsigned != 0 {
-				dest[i] = int64(binary.LittleEndian.Uint16(data[pos : pos+2]))
-			} else {
-				dest[i] = int64(int16(binary.LittleEndian.Uint16(data[pos : pos+2])))
-			}
-			pos += 2
-			continue
-
-		case fieldTypeInt24, fieldTypeLong:
-			if rows.rs.columns[i].flags&flagUnsigned != 0 {
-				dest[i] = int64(binary.LittleEndian.Uint32(data[pos : pos+4]))
-			} else {
-				dest[i] = int64(int32(binary.LittleEndian.Uint32(data[pos : pos+4])))
-			}
-			pos += 4
-			continue
-
-		case fieldTypeLongLong:
-			if rows.rs.columns[i].flags&flagUnsigned != 0 {
-				val := binary.LittleEndian.Uint64(data[pos : pos+8])
-				if val > math.MaxInt64 {
-					dest[i] = uint64ToString(val)
-				} else {
-					dest[i] = int64(val)
-				}
-			} else {
-				dest[i] = int64(binary.LittleEndian.Uint64(data[pos : pos+8]))
-			}
-			pos += 8
-			continue
-
-		case fieldTypeFloat:
-			dest[i] = math.Float32frombits(binary.LittleEndian.Uint32(data[pos : pos+4]))
-			pos += 4
-			continue
-
-		case fieldTypeDouble:
-			dest[i] = math.Float64frombits(binary.LittleEndian.Uint64(data[pos : pos+8]))
-			pos += 8
-			continue
-
-		// Length coded Binary Strings
-		case fieldTypeDecimal, fieldTypeNewDecimal, fieldTypeVarChar,
-			fieldTypeBit, fieldTypeEnum, fieldTypeSet, fieldTypeTinyBLOB,
-			fieldTypeMediumBLOB, fieldTypeLongBLOB, fieldTypeBLOB,
-			fieldTypeVarString, fieldTypeString, fieldTypeGeometry, fieldTypeJSON:
-			var isNull bool
-			var n int
-			dest[i], isNull, n, err = readLengthEncodedString(data[pos:])
-			pos += n
-			if err == nil {
-				if !isNull {
-					continue
-				} else {
-					dest[i] = nil
-					continue
-				}
-			}
-			return err
-
-		case
-			fieldTypeDate, fieldTypeNewDate, // Date YYYY-MM-DD
-			fieldTypeTime,                         // Time [-][H]HH:MM:SS[.fractal]
-			fieldTypeTimestamp, fieldTypeDateTime: // Timestamp YYYY-MM-DD HH:MM:SS[.fractal]
-
-			num, isNull, n := readLengthEncodedInteger(data[pos:])
-			pos += n
-
-			switch {
-			case isNull:
-				dest[i] = nil
-				continue
-			case rows.rs.columns[i].fieldType == fieldTypeTime:
-				// database/sql does not support an equivalent to TIME, return a string
-				var dstlen uint8
-				switch decimals := rows.rs.columns[i].decimals; decimals {
-				case 0x00, 0x1f:
-					dstlen = 8
-				case 1, 2, 3, 4, 5, 6:
-					dstlen = 8 + 1 + decimals
-				default:
-					return fmt.Errorf(
-						"protocol error, illegal decimals value %d",
-						rows.rs.columns[i].decimals,
-					)
-				}
-				dest[i], err = formatBinaryTime(data[pos:pos+int(num)], dstlen)
-			case rows.mc.parseTime:
-				dest[i], err = parseBinaryDateTime(num, data[pos:], rows.mc.cfg.Loc)
-			default:
-				var dstlen uint8
-				if rows.rs.columns[i].fieldType == fieldTypeDate {
-					dstlen = 10
-				} else {
-					switch decimals := rows.rs.columns[i].decimals; decimals {
-					case 0x00, 0x1f:
-						dstlen = 19
-					case 1, 2, 3, 4, 5, 6:
-						dstlen = 19 + 1 + decimals
-					default:
-						return fmt.Errorf(
-							"protocol error, illegal decimals value %d",
-							rows.rs.columns[i].decimals,
-						)
-					}
-				}
-				dest[i], err = formatBinaryDateTime(data[pos:pos+int(num)], dstlen)
-			}
-
-			if err == nil {
-				pos += int(num)
-				continue
-			} else {
-				return err
-			}
-
-		// Please report if this happens!
-		default:
-			return fmt.Errorf("unknown field type %d", rows.rs.columns[i].fieldType)
-		}
-	}
-
-	return nil
-}

documentation/licenses/github.com/go-sql-driver/mysql/result.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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/driver"
-
-// 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()
-type Result interface {
-	driver.Result
-	// AllRowsAffected returns a slice containing the affected rows for each
-	// executed statement.
-	AllRowsAffected() []int64
-	// AllLastInsertIds returns a slice containing the last inserted ID for each
-	// executed statement.
-	AllLastInsertIds() []int64
-}
-
-type mysqlResult struct {
-	// One entry in both slices is created for every executed statement result.
-	affectedRows []int64
-	insertIds    []int64
-}
-
-func (res *mysqlResult) LastInsertId() (int64, error) {
-	return res.insertIds[len(res.insertIds)-1], nil
-}
-
-func (res *mysqlResult) RowsAffected() (int64, error) {
-	return res.affectedRows[len(res.affectedRows)-1], nil
-}
-
-func (res *mysqlResult) AllLastInsertIds() []int64 {
-	return append([]int64{}, res.insertIds...) // defensive copy
-}
-
-func (res *mysqlResult) AllRowsAffected() []int64 {
-	return append([]int64{}, res.affectedRows...) // defensive copy
-}

documentation/licenses/github.com/go-sql-driver/mysql/rows.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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/driver"
-	"io"
-	"math"
-	"reflect"
-)
-
-type resultSet struct {
-	columns     []mysqlField
-	columnNames []string
-	done        bool
-}
-
-type mysqlRows struct {
-	mc     *mysqlConn
-	rs     resultSet
-	finish func()
-}
-
-type binaryRows struct {
-	mysqlRows
-}
-
-type textRows struct {
-	mysqlRows
-}
-
-func (rows *mysqlRows) Columns() []string {
-	if rows.rs.columnNames != nil {
-		return rows.rs.columnNames
-	}
-
-	columns := make([]string, len(rows.rs.columns))
-	if rows.mc != nil && rows.mc.cfg.ColumnsWithAlias {
-		for i := range columns {
-			if tableName := rows.rs.columns[i].tableName; len(tableName) > 0 {
-				columns[i] = tableName + "." + rows.rs.columns[i].name
-			} else {
-				columns[i] = rows.rs.columns[i].name
-			}
-		}
-	} else {
-		for i := range columns {
-			columns[i] = rows.rs.columns[i].name
-		}
-	}
-
-	rows.rs.columnNames = columns
-	return columns
-}
-
-func (rows *mysqlRows) ColumnTypeDatabaseTypeName(i int) string {
-	return rows.rs.columns[i].typeDatabaseName()
-}
-
-// func (rows *mysqlRows) ColumnTypeLength(i int) (length int64, ok bool) {
-// 	return int64(rows.rs.columns[i].length), true
-// }
-
-func (rows *mysqlRows) ColumnTypeNullable(i int) (nullable, ok bool) {
-	return rows.rs.columns[i].flags&flagNotNULL == 0, true
-}
-
-func (rows *mysqlRows) ColumnTypePrecisionScale(i int) (int64, int64, bool) {
-	column := rows.rs.columns[i]
-	decimals := int64(column.decimals)
-
-	switch column.fieldType {
-	case fieldTypeDecimal, fieldTypeNewDecimal:
-		if decimals > 0 {
-			return int64(column.length) - 2, decimals, true
-		}
-		return int64(column.length) - 1, decimals, true
-	case fieldTypeTimestamp, fieldTypeDateTime, fieldTypeTime:
-		return decimals, decimals, true
-	case fieldTypeFloat, fieldTypeDouble:
-		if decimals == 0x1f {
-			return math.MaxInt64, math.MaxInt64, true
-		}
-		return math.MaxInt64, decimals, true
-	}
-
-	return 0, 0, false
-}
-
-func (rows *mysqlRows) ColumnTypeScanType(i int) reflect.Type {
-	return rows.rs.columns[i].scanType()
-}
-
-func (rows *mysqlRows) Close() (err error) {
-	if f := rows.finish; f != nil {
-		f()
-		rows.finish = nil
-	}
-
-	mc := rows.mc
-	if mc == nil {
-		return nil
-	}
-	if err := mc.error(); err != nil {
-		return err
-	}
-
-	// flip the buffer for this connection if we need to drain it.
-	// note that for a successful query (i.e. one where rows.next()
-	// has been called until it returns false), `rows.mc` will be nil
-	// by the time the user calls `(*Rows).Close`, so we won't reach this
-	// see: https://github.com/golang/go/commit/651ddbdb5056ded455f47f9c494c67b389622a47
-	mc.buf.flip()
-
-	// Remove unread packets from stream
-	if !rows.rs.done {
-		err = mc.readUntilEOF()
-	}
-	if err == nil {
-		handleOk := mc.clearResult()
-		if err = handleOk.discardResults(); err != nil {
-			return err
-		}
-	}
-
-	rows.mc = nil
-	return err
-}
-
-func (rows *mysqlRows) HasNextResultSet() (b bool) {
-	if rows.mc == nil {
-		return false
-	}
-	return rows.mc.status&statusMoreResultsExists != 0
-}
-
-func (rows *mysqlRows) nextResultSet() (int, error) {
-	if rows.mc == nil {
-		return 0, io.EOF
-	}
-	if err := rows.mc.error(); err != nil {
-		return 0, err
-	}
-
-	// Remove unread packets from stream
-	if !rows.rs.done {
-		if err := rows.mc.readUntilEOF(); err != nil {
-			return 0, err
-		}
-		rows.rs.done = true
-	}
-
-	if !rows.HasNextResultSet() {
-		rows.mc = nil
-		return 0, io.EOF
-	}
-	rows.rs = resultSet{}
-	// rows.mc.affectedRows and rows.mc.insertIds accumulate on each call to
-	// nextResultSet.
-	resLen, err := rows.mc.resultUnchanged().readResultSetHeaderPacket()
-	if err != nil {
-		// Clean up about multi-results flag
-		rows.rs.done = true
-		rows.mc.status = rows.mc.status & (^statusMoreResultsExists)
-	}
-	return resLen, err
-}
-
-func (rows *mysqlRows) nextNotEmptyResultSet() (int, error) {
-	for {
-		resLen, err := rows.nextResultSet()
-		if err != nil {
-			return 0, err
-		}
-
-		if resLen > 0 {
-			return resLen, nil
-		}
-
-		rows.rs.done = true
-	}
-}
-
-func (rows *binaryRows) NextResultSet() error {
-	resLen, err := rows.nextNotEmptyResultSet()
-	if err != nil {
-		return err
-	}
-
-	rows.rs.columns, err = rows.mc.readColumns(resLen)
-	return err
-}
-
-func (rows *binaryRows) Next(dest []driver.Value) error {
-	if mc := rows.mc; mc != nil {
-		if err := mc.error(); err != nil {
-			return err
-		}
-
-		// Fetch next row from stream
-		return rows.readRow(dest)
-	}
-	return io.EOF
-}
-
-func (rows *textRows) NextResultSet() (err error) {
-	resLen, err := rows.nextNotEmptyResultSet()
-	if err != nil {
-		return err
-	}
-
-	rows.rs.columns, err = rows.mc.readColumns(resLen)
-	return err
-}
-
-func (rows *textRows) Next(dest []driver.Value) error {
-	if mc := rows.mc; mc != nil {
-		if err := mc.error(); err != nil {
-			return err
-		}
-
-		// Fetch next row from stream
-		return rows.readRow(dest)
-	}
-	return io.EOF
-}

documentation/licenses/github.com/go-sql-driver/mysql/statement.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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/driver"
-	"encoding/json"
-	"fmt"
-	"io"
-	"reflect"
-)
-
-type mysqlStmt struct {
-	mc         *mysqlConn
-	id         uint32
-	paramCount int
-}
-
-func (stmt *mysqlStmt) Close() error {
-	if stmt.mc == nil || stmt.mc.closed.Load() {
-		// driver.Stmt.Close can be called more than once, thus this function
-		// has to be idempotent.
-		// See also Issue #450 and golang/go#16019.
-		//errLog.Print(ErrInvalidConn)
-		return driver.ErrBadConn
-	}
-
-	err := stmt.mc.writeCommandPacketUint32(comStmtClose, stmt.id)
-	stmt.mc = nil
-	return err
-}
-
-func (stmt *mysqlStmt) NumInput() int {
-	return stmt.paramCount
-}
-
-func (stmt *mysqlStmt) ColumnConverter(idx int) driver.ValueConverter {
-	return converter{}
-}
-
-func (stmt *mysqlStmt) CheckNamedValue(nv *driver.NamedValue) (err error) {
-	nv.Value, err = converter{}.ConvertValue(nv.Value)
-	return
-}
-
-func (stmt *mysqlStmt) Exec(args []driver.Value) (driver.Result, error) {
-	if stmt.mc.closed.Load() {
-		stmt.mc.log(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	// Send command
-	err := stmt.writeExecutePacket(args)
-	if err != nil {
-		return nil, stmt.mc.markBadConn(err)
-	}
-
-	mc := stmt.mc
-	handleOk := stmt.mc.clearResult()
-
-	// Read Result
-	resLen, err := handleOk.readResultSetHeaderPacket()
-	if err != nil {
-		return nil, err
-	}
-
-	if resLen > 0 {
-		// Columns
-		if err = mc.readUntilEOF(); err != nil {
-			return nil, err
-		}
-
-		// Rows
-		if err := mc.readUntilEOF(); err != nil {
-			return nil, err
-		}
-	}
-
-	if err := handleOk.discardResults(); err != nil {
-		return nil, err
-	}
-
-	copied := mc.result
-	return &copied, nil
-}
-
-func (stmt *mysqlStmt) Query(args []driver.Value) (driver.Rows, error) {
-	return stmt.query(args)
-}
-
-func (stmt *mysqlStmt) query(args []driver.Value) (*binaryRows, error) {
-	if stmt.mc.closed.Load() {
-		stmt.mc.log(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	// Send command
-	err := stmt.writeExecutePacket(args)
-	if err != nil {
-		return nil, stmt.mc.markBadConn(err)
-	}
-
-	mc := stmt.mc
-
-	// Read Result
-	handleOk := stmt.mc.clearResult()
-	resLen, err := handleOk.readResultSetHeaderPacket()
-	if err != nil {
-		return nil, err
-	}
-
-	rows := new(binaryRows)
-
-	if resLen > 0 {
-		rows.mc = mc
-		rows.rs.columns, err = mc.readColumns(resLen)
-	} else {
-		rows.rs.done = true
-
-		switch err := rows.NextResultSet(); err {
-		case nil, io.EOF:
-			return rows, nil
-		default:
-			return nil, err
-		}
-	}
-
-	return rows, err
-}
-
-var jsonType = reflect.TypeOf(json.RawMessage{})
-
-type converter struct{}
-
-// ConvertValue mirrors the reference/default converter in database/sql/driver
-// with _one_ exception.  We support uint64 with their high bit and the default
-// implementation does not.  This function should be kept in sync with
-// database/sql/driver defaultConverter.ConvertValue() except for that
-// deliberate difference.
-func (c converter) ConvertValue(v any) (driver.Value, error) {
-	if driver.IsValue(v) {
-		return v, nil
-	}
-
-	if vr, ok := v.(driver.Valuer); ok {
-		sv, err := callValuerValue(vr)
-		if err != nil {
-			return nil, err
-		}
-		if driver.IsValue(sv) {
-			return sv, nil
-		}
-		// A value returned from the Valuer interface can be "a type handled by
-		// a database driver's NamedValueChecker interface" so we should accept
-		// uint64 here as well.
-		if u, ok := sv.(uint64); ok {
-			return u, nil
-		}
-		return nil, fmt.Errorf("non-Value type %T returned from Value", sv)
-	}
-	rv := reflect.ValueOf(v)
-	switch rv.Kind() {
-	case reflect.Ptr:
-		// indirect pointers
-		if rv.IsNil() {
-			return nil, nil
-		} else {
-			return c.ConvertValue(rv.Elem().Interface())
-		}
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return rv.Int(), nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return rv.Uint(), nil
-	case reflect.Float32, reflect.Float64:
-		return rv.Float(), nil
-	case reflect.Bool:
-		return rv.Bool(), nil
-	case reflect.Slice:
-		switch t := rv.Type(); {
-		case t == jsonType:
-			return v, nil
-		case t.Elem().Kind() == reflect.Uint8:
-			return rv.Bytes(), nil
-		default:
-			return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, t.Elem().Kind())
-		}
-	case reflect.String:
-		return rv.String(), nil
-	}
-	return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
-}
-
-var valuerReflectType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
-
-// callValuerValue returns vr.Value(), with one exception:
-// If vr.Value is an auto-generated method on a pointer type and the
-// pointer is nil, it would panic at runtime in the panicwrap
-// method. Treat it like nil instead.
-//
-// This is so people can implement driver.Value on value types and
-// still use nil pointers to those types to mean nil/NULL, just like
-// string/*string.
-//
-// This is an exact copy of the same-named unexported function from the
-// database/sql package.
-func callValuerValue(vr driver.Valuer) (v driver.Value, err error) {
-	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
-		rv.IsNil() &&
-		rv.Type().Elem().Implements(valuerReflectType) {
-		return nil, nil
-	}
-	return vr.Value()
-}

documentation/licenses/github.com/go-sql-driver/mysql/transaction.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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
-
-type mysqlTx struct {
-	mc *mysqlConn
-}
-
-func (tx *mysqlTx) Commit() (err error) {
-	if tx.mc == nil || tx.mc.closed.Load() {
-		return ErrInvalidConn
-	}
-	err = tx.mc.exec("COMMIT")
-	tx.mc = nil
-	return
-}
-
-func (tx *mysqlTx) Rollback() (err error) {
-	if tx.mc == nil || tx.mc.closed.Load() {
-		return ErrInvalidConn
-	}
-	err = tx.mc.exec("ROLLBACK")
-	tx.mc = nil
-	return
-}

documentation/licenses/github.com/go-sql-driver/mysql/utils.go

-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2012 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 (
-	"crypto/tls"
-	"database/sql"
-	"database/sql/driver"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// Registry for custom tls.Configs
-var (
-	tlsConfigLock     sync.RWMutex
-	tlsConfigRegistry map[string]*tls.Config
-)
-
-// 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")
-func RegisterTLSConfig(key string, config *tls.Config) error {
-	if _, isBool := readBool(key); isBool || strings.ToLower(key) == "skip-verify" || strings.ToLower(key) == "preferred" {
-		return fmt.Errorf("key '%s' is reserved", key)
-	}
-
-	tlsConfigLock.Lock()
-	if tlsConfigRegistry == nil {
-		tlsConfigRegistry = make(map[string]*tls.Config)
-	}
-
-	tlsConfigRegistry[key] = config
-	tlsConfigLock.Unlock()
-	return nil
-}
-
-// DeregisterTLSConfig removes the tls.Config associated with key.
-func DeregisterTLSConfig(key string) {
-	tlsConfigLock.Lock()
-	if tlsConfigRegistry != nil {
-		delete(tlsConfigRegistry, key)
-	}
-	tlsConfigLock.Unlock()
-}
-
-func getTLSConfigClone(key string) (config *tls.Config) {
-	tlsConfigLock.RLock()
-	if v, ok := tlsConfigRegistry[key]; ok {
-		config = v.Clone()
-	}
-	tlsConfigLock.RUnlock()
-	return
-}
-
-// Returns the bool value of the input.
-// The 2nd return value indicates if the input was a valid bool value
-func readBool(input string) (value bool, valid bool) {
-	switch input {
-	case "1", "true", "TRUE", "True":
-		return true, true
-	case "0", "false", "FALSE", "False":
-		return false, true
-	}
-
-	// Not a valid bool value
-	return
-}
-
-/******************************************************************************
-*                           Time related utils                                *
-******************************************************************************/
-
-func parseDateTime(b []byte, loc *time.Location) (time.Time, error) {
-	const base = "0000-00-00 00:00:00.000000"
-	switch len(b) {
-	case 10, 19, 21, 22, 23, 24, 25, 26: // up to "YYYY-MM-DD HH:MM:SS.MMMMMM"
-		if string(b) == base[:len(b)] {
-			return time.Time{}, nil
-		}
-
-		year, err := parseByteYear(b)
-		if err != nil {
-			return time.Time{}, err
-		}
-		if b[4] != '-' {
-			return time.Time{}, fmt.Errorf("bad value for field: `%c`", b[4])
-		}
-
-		m, err := parseByte2Digits(b[5], b[6])
-		if err != nil {
-			return time.Time{}, err
-		}
-		month := time.Month(m)
-
-		if b[7] != '-' {
-			return time.Time{}, fmt.Errorf("bad value for field: `%c`", b[7])
-		}
-
-		day, err := parseByte2Digits(b[8], b[9])
-		if err != nil {
-			return time.Time{}, err
-		}
-		if len(b) == 10 {
-			return time.Date(year, month, day, 0, 0, 0, 0, loc), nil
-		}
-
-		if b[10] != ' ' {
-			return time.Time{}, fmt.Errorf("bad value for field: `%c`", b[10])
-		}
-
-		hour, err := parseByte2Digits(b[11], b[12])
-		if err != nil {
-			return time.Time{}, err
-		}
-		if b[13] != ':' {
-			return time.Time{}, fmt.Errorf("bad value for field: `%c`", b[13])
-		}
-
-		min, err := parseByte2Digits(b[14], b[15])
-		if err != nil {
-			return time.Time{}, err
-		}
-		if b[16] != ':' {
-			return time.Time{}, fmt.Errorf("bad value for field: `%c`", b[16])
-		}
-
-		sec, err := parseByte2Digits(b[17], b[18])
-		if err != nil {
-			return time.Time{}, err
-		}
-		if len(b) == 19 {
-			return time.Date(year, month, day, hour, min, sec, 0, loc), nil
-		}
-
-		if b[19] != '.' {
-			return time.Time{}, fmt.Errorf("bad value for field: `%c`", b[19])
-		}
-		nsec, err := parseByteNanoSec(b[20:])
-		if err != nil {
-			return time.Time{}, err
-		}
-		return time.Date(year, month, day, hour, min, sec, nsec, loc), nil
-	default:
-		return time.Time{}, fmt.Errorf("invalid time bytes: %s", b)
-	}
-}
-
-func parseByteYear(b []byte) (int, error) {
-	year, n := 0, 1000
-	for i := 0; i < 4; i++ {
-		v, err := bToi(b[i])
-		if err != nil {
-			return 0, err
-		}
-		year += v * n
-		n /= 10
-	}
-	return year, nil
-}
-
-func parseByte2Digits(b1, b2 byte) (int, error) {
-	d1, err := bToi(b1)
-	if err != nil {
-		return 0, err
-	}
-	d2, err := bToi(b2)
-	if err != nil {
-		return 0, err
-	}
-	return d1*10 + d2, nil
-}
-
-func parseByteNanoSec(b []byte) (int, error) {
-	ns, digit := 0, 100000 // max is 6-digits
-	for i := 0; i < len(b); i++ {
-		v, err := bToi(b[i])
-		if err != nil {
-			return 0, err
-		}
-		ns += v * digit
-		digit /= 10
-	}
-	// nanoseconds has 10-digits. (needs to scale digits)
-	// 10 - 6 = 4, so we have to multiple 1000.
-	return ns * 1000, nil
-}
-
-func bToi(b byte) (int, error) {
-	if b < '0' || b > '9' {
-		return 0, errors.New("not [0-9]")
-	}
-	return int(b - '0'), nil
-}
-
-func parseBinaryDateTime(num uint64, data []byte, loc *time.Location) (driver.Value, error) {
-	switch num {
-	case 0:
-		return time.Time{}, nil
-	case 4:
-		return time.Date(
-			int(binary.LittleEndian.Uint16(data[:2])), // year
-			time.Month(data[2]),                       // month
-			int(data[3]),                              // day
-			0, 0, 0, 0,
-			loc,
-		), nil
-	case 7:
-		return time.Date(
-			int(binary.LittleEndian.Uint16(data[:2])), // year
-			time.Month(data[2]),                       // month
-			int(data[3]),                              // day
-			int(data[4]),                              // hour
-			int(data[5]),                              // minutes
-			int(data[6]),                              // seconds
-			0,
-			loc,
-		), nil
-	case 11:
-		return time.Date(
-			int(binary.LittleEndian.Uint16(data[:2])), // year
-			time.Month(data[2]),                       // month
-			int(data[3]),                              // day
-			int(data[4]),                              // hour
-			int(data[5]),                              // minutes
-			int(data[6]),                              // seconds
-			int(binary.LittleEndian.Uint32(data[7:11]))*1000, // nanoseconds
-			loc,
-		), nil
-	}
-	return nil, fmt.Errorf("invalid DATETIME packet length %d", num)
-}
-
-func appendDateTime(buf []byte, t time.Time, timeTruncate time.Duration) ([]byte, error) {
-	if timeTruncate > 0 {
-		t = t.Truncate(timeTruncate)
-	}
-
-	year, month, day := t.Date()
-	hour, min, sec := t.Clock()
-	nsec := t.Nanosecond()
-
-	if year < 1 || year > 9999 {
-		return buf, errors.New("year is not in the range [1, 9999]: " + strconv.Itoa(year)) // use errors.New instead of fmt.Errorf to avoid year escape to heap
-	}
-	year100 := year / 100
-	year1 := year % 100
-
-	var localBuf [len("2006-01-02T15:04:05.999999999")]byte // does not escape
-	localBuf[0], localBuf[1], localBuf[2], localBuf[3] = digits10[year100], digits01[year100], digits10[year1], digits01[year1]
-	localBuf[4] = '-'
-	localBuf[5], localBuf[6] = digits10[month], digits01[month]
-	localBuf[7] = '-'
-	localBuf[8], localBuf[9] = digits10[day], digits01[day]
-
-	if hour == 0 && min == 0 && sec == 0 && nsec == 0 {
-		return append(buf, localBuf[:10]...), nil
-	}
-
-	localBuf[10] = ' '
-	localBuf[11], localBuf[12] = digits10[hour], digits01[hour]
-	localBuf[13] = ':'
-	localBuf[14], localBuf[15] = digits10[min], digits01[min]
-	localBuf[16] = ':'
-	localBuf[17], localBuf[18] = digits10[sec], digits01[sec]
-
-	if nsec == 0 {
-		return append(buf, localBuf[:19]...), nil
-	}
-	nsec100000000 := nsec / 100000000
-	nsec1000000 := (nsec / 1000000) % 100
-	nsec10000 := (nsec / 10000) % 100
-	nsec100 := (nsec / 100) % 100
-	nsec1 := nsec % 100
-	localBuf[19] = '.'
-
-	// milli second
-	localBuf[20], localBuf[21], localBuf[22] =
-		digits01[nsec100000000], digits10[nsec1000000], digits01[nsec1000000]
-	// micro second
-	localBuf[23], localBuf[24], localBuf[25] =
-		digits10[nsec10000], digits01[nsec10000], digits10[nsec100]
-	// nano second
-	localBuf[26], localBuf[27], localBuf[28] =
-		digits01[nsec100], digits10[nsec1], digits01[nsec1]
-
-	// trim trailing zeros
-	n := len(localBuf)
-	for n > 0 && localBuf[n-1] == '0' {
-		n--
-	}
-
-	return append(buf, localBuf[:n]...), nil
-}
-
-// zeroDateTime is used in formatBinaryDateTime to avoid an allocation
-// if the DATE or DATETIME has the zero value.
-// It must never be changed.
-// The current behavior depends on database/sql copying the result.
-var zeroDateTime = []byte("0000-00-00 00:00:00.000000")
-
-const digits01 = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
-const digits10 = "0000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999"
-
-func appendMicrosecs(dst, src []byte, decimals int) []byte {
-	if decimals <= 0 {
-		return dst
-	}
-	if len(src) == 0 {
-		return append(dst, ".000000"[:decimals+1]...)
-	}
-
-	microsecs := binary.LittleEndian.Uint32(src[:4])
-	p1 := byte(microsecs / 10000)
-	microsecs -= 10000 * uint32(p1)
-	p2 := byte(microsecs / 100)
-	microsecs -= 100 * uint32(p2)
-	p3 := byte(microsecs)
-
-	switch decimals {
-	default:
-		return append(dst, '.',
-			digits10[p1], digits01[p1],
-			digits10[p2], digits01[p2],
-			digits10[p3], digits01[p3],
-		)
-	case 1:
-		return append(dst, '.',
-			digits10[p1],
-		)
-	case 2:
-		return append(dst, '.',
-			digits10[p1], digits01[p1],
-		)
-	case 3:
-		return append(dst, '.',
-			digits10[p1], digits01[p1],
-			digits10[p2],
-		)
-	case 4:
-		return append(dst, '.',
-			digits10[p1], digits01[p1],
-			digits10[p2], digits01[p2],
-		)
-	case 5:
-		return append(dst, '.',
-			digits10[p1], digits01[p1],
-			digits10[p2], digits01[p2],
-			digits10[p3],
-		)
-	}
-}
-
-func formatBinaryDateTime(src []byte, length uint8) (driver.Value, error) {
-	// length expects the deterministic length of the zero value,
-	// negative time and 100+ hours are automatically added if needed
-	if len(src) == 0 {
-		return zeroDateTime[:length], nil
-	}
-	var dst []byte      // return value
-	var p1, p2, p3 byte // current digit pair
-
-	switch length {
-	case 10, 19, 21, 22, 23, 24, 25, 26:
-	default:
-		t := "DATE"
-		if length > 10 {
-			t += "TIME"
-		}
-		return nil, fmt.Errorf("illegal %s length %d", t, length)
-	}
-	switch len(src) {
-	case 4, 7, 11:
-	default:
-		t := "DATE"
-		if length > 10 {
-			t += "TIME"
-		}
-		return nil, fmt.Errorf("illegal %s packet length %d", t, len(src))
-	}
-	dst = make([]byte, 0, length)
-	// start with the date
-	year := binary.LittleEndian.Uint16(src[:2])
-	pt := year / 100
-	p1 = byte(year - 100*uint16(pt))
-	p2, p3 = src[2], src[3]
-	dst = append(dst,
-		digits10[pt], digits01[pt],
-		digits10[p1], digits01[p1], '-',
-		digits10[p2], digits01[p2], '-',
-		digits10[p3], digits01[p3],
-	)
-	if length == 10 {
-		return dst, nil
-	}
-	if len(src) == 4 {
-		return append(dst, zeroDateTime[10:length]...), nil
-	}
-	dst = append(dst, ' ')
-	p1 = src[4] // hour
-	src = src[5:]
-
-	// p1 is 2-digit hour, src is after hour
-	p2, p3 = src[0], src[1]
-	dst = append(dst,
-		digits10[p1], digits01[p1], ':',
-		digits10[p2], digits01[p2], ':',
-		digits10[p3], digits01[p3],
-	)
-	return appendMicrosecs(dst, src[2:], int(length)-20), nil
-}
-
-func formatBinaryTime(src []byte, length uint8) (driver.Value, error) {
-	// length expects the deterministic length of the zero value,
-	// negative time and 100+ hours are automatically added if needed
-	if len(src) == 0 {
-		return zeroDateTime[11 : 11+length], nil
-	}
-	var dst []byte // return value
-
-	switch length {
-	case
-		8,                      // time (can be up to 10 when negative and 100+ hours)
-		10, 11, 12, 13, 14, 15: // time with fractional seconds
-	default:
-		return nil, fmt.Errorf("illegal TIME length %d", length)
-	}
-	switch len(src) {
-	case 8, 12:
-	default:
-		return nil, fmt.Errorf("invalid TIME packet length %d", len(src))
-	}
-	// +2 to enable negative time and 100+ hours
-	dst = make([]byte, 0, length+2)
-	if src[0] == 1 {
-		dst = append(dst, '-')
-	}
-	days := binary.LittleEndian.Uint32(src[1:5])
-	hours := int64(days)*24 + int64(src[5])
-
-	if hours >= 100 {
-		dst = strconv.AppendInt(dst, hours, 10)
-	} else {
-		dst = append(dst, digits10[hours], digits01[hours])
-	}
-
-	min, sec := src[6], src[7]
-	dst = append(dst, ':',
-		digits10[min], digits01[min], ':',
-		digits10[sec], digits01[sec],
-	)
-	return appendMicrosecs(dst, src[8:], int(length)-9), nil
-}
-
-/******************************************************************************
-*                       Convert from and to bytes                             *
-******************************************************************************/
-
-func uint64ToBytes(n uint64) []byte {
-	return []byte{
-		byte(n),
-		byte(n >> 8),
-		byte(n >> 16),
-		byte(n >> 24),
-		byte(n >> 32),
-		byte(n >> 40),
-		byte(n >> 48),
-		byte(n >> 56),
-	}
-}
-
-func uint64ToString(n uint64) []byte {
-	var a [20]byte
-	i := 20
-
-	// U+0030 = 0
-	// ...
-	// U+0039 = 9
-
-	var q uint64
-	for n >= 10 {
-		i--
-		q = n / 10
-		a[i] = uint8(n-q*10) + 0x30
-		n = q
-	}
-
-	i--
-	a[i] = uint8(n) + 0x30
-
-	return a[i:]
-}
-
-// treats string value as unsigned integer representation
-func stringToInt(b []byte) int {
-	val := 0
-	for i := range b {
-		val *= 10
-		val += int(b[i] - 0x30)
-	}
-	return val
-}
-
-// returns the string read as a bytes slice, whether the value is NULL,
-// the number of bytes read and an error, in case the string is longer than
-// the input slice
-func readLengthEncodedString(b []byte) ([]byte, bool, int, error) {
-	// Get length
-	num, isNull, n := readLengthEncodedInteger(b)
-	if num < 1 {
-		return b[n:n], isNull, n, nil
-	}
-
-	n += int(num)
-
-	// Check data length
-	if len(b) >= n {
-		return b[n-int(num) : n : n], false, n, nil
-	}
-	return nil, false, n, io.EOF
-}
-
-// returns the number of bytes skipped and an error, in case the string is
-// longer than the input slice
-func skipLengthEncodedString(b []byte) (int, error) {
-	// Get length
-	num, _, n := readLengthEncodedInteger(b)
-	if num < 1 {
-		return n, nil
-	}
-
-	n += int(num)
-
-	// Check data length
-	if len(b) >= n {
-		return n, nil
-	}
-	return n, io.EOF
-}
-
-// returns the number read, whether the value is NULL and the number of bytes read
-func readLengthEncodedInteger(b []byte) (uint64, bool, int) {
-	// See issue #349
-	if len(b) == 0 {
-		return 0, true, 1
-	}
-
-	switch b[0] {
-	// 251: NULL
-	case 0xfb:
-		return 0, true, 1
-
-	// 252: value of following 2
-	case 0xfc:
-		return uint64(b[1]) | uint64(b[2])<<8, false, 3
-
-	// 253: value of following 3
-	case 0xfd:
-		return uint64(b[1]) | uint64(b[2])<<8 | uint64(b[3])<<16, false, 4
-
-	// 254: value of following 8
-	case 0xfe:
-		return uint64(b[1]) | uint64(b[2])<<8 | uint64(b[3])<<16 |
-				uint64(b[4])<<24 | uint64(b[5])<<32 | uint64(b[6])<<40 |
-				uint64(b[7])<<48 | uint64(b[8])<<56,
-			false, 9
-	}
-
-	// 0-250: value of first byte
-	return uint64(b[0]), false, 1
-}
-
-// encodes a uint64 value and appends it to the given bytes slice
-func appendLengthEncodedInteger(b []byte, n uint64) []byte {
-	switch {
-	case n <= 250:
-		return append(b, byte(n))
-
-	case n <= 0xffff:
-		return append(b, 0xfc, byte(n), byte(n>>8))
-
-	case n <= 0xffffff:
-		return append(b, 0xfd, byte(n), byte(n>>8), byte(n>>16))
-	}
-	return append(b, 0xfe, byte(n), byte(n>>8), byte(n>>16), byte(n>>24),
-		byte(n>>32), byte(n>>40), byte(n>>48), byte(n>>56))
-}
-
-func appendLengthEncodedString(b []byte, s string) []byte {
-	b = appendLengthEncodedInteger(b, uint64(len(s)))
-	return append(b, s...)
-}
-
-// reserveBuffer checks cap(buf) and expand buffer to len(buf) + appendSize.
-// If cap(buf) is not enough, reallocate new buffer.
-func reserveBuffer(buf []byte, appendSize int) []byte {
-	newSize := len(buf) + appendSize
-	if cap(buf) < newSize {
-		// Grow buffer exponentially
-		newBuf := make([]byte, len(buf)*2+appendSize)
-		copy(newBuf, buf)
-		buf = newBuf
-	}
-	return buf[:newSize]
-}
-
-// escapeBytesBackslash escapes []byte with backslashes (\)
-// This escapes the contents of a string (provided as []byte) by adding backslashes before special
-// characters, and turning others into specific escape sequences, such as
-// turning newlines into \n and null bytes into \0.
-// https://github.com/mysql/mysql-server/blob/mysql-5.7.5/mysys/charset.c#L823-L932
-func escapeBytesBackslash(buf, v []byte) []byte {
-	pos := len(buf)
-	buf = reserveBuffer(buf, len(v)*2)
-
-	for _, c := range v {
-		switch c {
-		case '\x00':
-			buf[pos+1] = '0'
-			buf[pos] = '\\'
-			pos += 2
-		case '\n':
-			buf[pos+1] = 'n'
-			buf[pos] = '\\'
-			pos += 2
-		case '\r':
-			buf[pos+1] = 'r'
-			buf[pos] = '\\'
-			pos += 2
-		case '\x1a':
-			buf[pos+1] = 'Z'
-			buf[pos] = '\\'
-			pos += 2
-		case '\'':
-			buf[pos+1] = '\''
-			buf[pos] = '\\'
-			pos += 2
-		case '"':
-			buf[pos+1] = '"'
-			buf[pos] = '\\'
-			pos += 2
-		case '\\':
-			buf[pos+1] = '\\'
-			buf[pos] = '\\'
-			pos += 2
-		default:
-			buf[pos] = c
-			pos++
-		}
-	}
-
-	return buf[:pos]
-}
-
-// escapeStringBackslash is similar to escapeBytesBackslash but for string.
-func escapeStringBackslash(buf []byte, v string) []byte {
-	pos := len(buf)
-	buf = reserveBuffer(buf, len(v)*2)
-
-	for i := 0; i < len(v); i++ {
-		c := v[i]
-		switch c {
-		case '\x00':
-			buf[pos+1] = '0'
-			buf[pos] = '\\'
-			pos += 2
-		case '\n':
-			buf[pos+1] = 'n'
-			buf[pos] = '\\'
-			pos += 2
-		case '\r':
-			buf[pos+1] = 'r'
-			buf[pos] = '\\'
-			pos += 2
-		case '\x1a':
-			buf[pos+1] = 'Z'
-			buf[pos] = '\\'
-			pos += 2
-		case '\'':
-			buf[pos+1] = '\''
-			buf[pos] = '\\'
-			pos += 2
-		case '"':
-			buf[pos+1] = '"'
-			buf[pos] = '\\'
-			pos += 2
-		case '\\':
-			buf[pos+1] = '\\'
-			buf[pos] = '\\'
-			pos += 2
-		default:
-			buf[pos] = c
-			pos++
-		}
-	}
-
-	return buf[:pos]
-}
-
-// escapeBytesQuotes escapes apostrophes in []byte by doubling them up.
-// This escapes the contents of a string by doubling up any apostrophes that
-// it contains. This is used when the NO_BACKSLASH_ESCAPES SQL_MODE is in
-// effect on the server.
-// https://github.com/mysql/mysql-server/blob/mysql-5.7.5/mysys/charset.c#L963-L1038
-func escapeBytesQuotes(buf, v []byte) []byte {
-	pos := len(buf)
-	buf = reserveBuffer(buf, len(v)*2)
-
-	for _, c := range v {
-		if c == '\'' {
-			buf[pos+1] = '\''
-			buf[pos] = '\''
-			pos += 2
-		} else {
-			buf[pos] = c
-			pos++
-		}
-	}
-
-	return buf[:pos]
-}
-
-// escapeStringQuotes is similar to escapeBytesQuotes but for string.
-func escapeStringQuotes(buf []byte, v string) []byte {
-	pos := len(buf)
-	buf = reserveBuffer(buf, len(v)*2)
-
-	for i := 0; i < len(v); i++ {
-		c := v[i]
-		if c == '\'' {
-			buf[pos+1] = '\''
-			buf[pos] = '\''
-			pos += 2
-		} else {
-			buf[pos] = c
-			pos++
-		}
-	}
-
-	return buf[:pos]
-}
-
-/******************************************************************************
-*                               Sync utils                                    *
-******************************************************************************/
-
-// noCopy may be embedded into structs which must not be copied
-// after the first use.
-//
-// See https://github.com/golang/go/issues/8005#issuecomment-190753527
-// for details.
-type noCopy struct{}
-
-// Lock is a no-op used by -copylocks checker from `go vet`.
-func (*noCopy) Lock() {}
-
-// Unlock is a no-op used by -copylocks checker from `go vet`.
-// noCopy should implement sync.Locker from Go 1.11
-// https://github.com/golang/go/commit/c2eba53e7f80df21d51285879d51ab81bcfbf6bc
-// https://github.com/golang/go/issues/26165
-func (*noCopy) Unlock() {}
-
-// atomicError is a wrapper for atomically accessed error values
-type atomicError struct {
-	_     noCopy
-	value atomic.Value
-}
-
-// Set sets the error value regardless of the previous value.
-// The value must not be nil
-func (ae *atomicError) Set(value error) {
-	ae.value.Store(value)
-}
-
-// Value returns the current error value
-func (ae *atomicError) Value() error {
-	if v := ae.value.Load(); v != nil {
-		// this will panic if the value doesn't implement the error interface
-		return v.(error)
-	}
-	return nil
-}
-
-func namedValueToValue(named []driver.NamedValue) ([]driver.Value, error) {
-	dargs := make([]driver.Value, len(named))
-	for n, param := range named {
-		if len(param.Name) > 0 {
-			// TODO: support the use of Named Parameters #561
-			return nil, errors.New("mysql: driver does not support the use of Named Parameters")
-		}
-		dargs[n] = param.Value
-	}
-	return dargs, nil
-}
-
-func mapIsolationLevel(level driver.IsolationLevel) (string, error) {
-	switch sql.IsolationLevel(level) {
-	case sql.LevelRepeatableRead:
-		return "REPEATABLE READ", nil
-	case sql.LevelReadCommitted:
-		return "READ COMMITTED", nil
-	case sql.LevelReadUncommitted:
-		return "READ UNCOMMITTED", nil
-	case sql.LevelSerializable:
-		return "SERIALIZABLE", nil
-	default:
-		return "", fmt.Errorf("mysql: unsupported isolation level: %v", level)
-	}
-}

documentation/licenses/github.com/google/uuid/LICENSE

-Copyright (c) 2009,2014 Google Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

documentation/licenses/github.com/jinzhu/inflection/LICENSE

-The MIT License (MIT)
-
-Copyright (c) 2015 - Jinzhu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

documentation/licenses/github.com/jinzhu/now/License

-The MIT License (MIT)
-
-Copyright (c) 2013-NOW  Jinzhu <wosmvp@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.