go mysql dsn_dsn.go · 无~痕/mysql - Gitee.com

// 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"

"crypto/tls"

"errors"

"fmt"

"net"

"net/url"

"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

type Config struct {

User string // Username

Passwd string // Password (requires User)

Net string // Network type

Addr string // Network address (requires Net)

DBName string // Database name

Params map[string]string // Connection parameters

Collation string // Connection collation

Loc *time.Location // Location for time.Time values

MaxAllowedPacket int // Max packet size allowed

TLSConfig string // TLS configuration name

tls *tls.Config // TLS configuration

Timeout time.Duration // Dial timeout

ReadTimeout time.Duration // I/O read timeout

WriteTimeout time.Duration // I/O write timeout

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

AllowCleartextPasswords bool // Allows the cleartext client side plugin

AllowNativePasswords bool // Allows the native password authentication method

AllowOldPasswords bool // Allows the old insecure password method

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

Strict bool // Return warnings as errors

}

// FormatDSN formats the given Config into a DSN string which can be passed to

// the driver.

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(cfg.DBName)

// [?param1=value1&...&paramN=valueN]

hasParam := false

if cfg.AllowAllFiles {

hasParam = true

buf.WriteString("?allowAllFiles=true")

}

if cfg.AllowCleartextPasswords {

if hasParam {

buf.WriteString("&allowCleartextPasswords=true")

} else {

hasParam = true

buf.WriteString("?allowCleartextPasswords=true")

}

}

if cfg.AllowNativePasswords {

if hasParam {

buf.WriteString("&allowNativePasswords=true")

} else {

hasParam = true

buf.WriteString("?allowNativePasswords=true")

}

}

if cfg.AllowOldPasswords {

if hasParam {

buf.WriteString("&allowOldPasswords=true")

} else {

hasParam = true

buf.WriteString("?allowOldPasswords=true")

}

}

if cfg.ClientFoundRows {

if hasParam {

buf.WriteString("&clientFoundRows=true")

} else {

hasParam = true

buf.WriteString("?clientFoundRows=true")

}

}

if col := cfg.Collation; col != defaultCollation && len(col) > 0 {

if hasParam {

buf.WriteString("&collation=")

} else {

hasParam = true

buf.WriteString("?collation=")

}

buf.WriteString(col)

}

if cfg.ColumnsWithAlias {

if hasParam {

buf.WriteString("&columnsWithAlias=true")

} else {

hasParam = true

buf.WriteString("?columnsWithAlias=true")

}

}

if cfg.InterpolateParams {

if hasParam {

buf.WriteString("&interpolateParams=true")

} else {

hasParam = true

buf.WriteString("?interpolateParams=true")

}

}

if cfg.Loc != time.UTC && cfg.Loc != nil {

if hasParam {

buf.WriteString("&loc=")

} else {

hasParam = true

buf.WriteString("?loc=")

}

buf.WriteString(url.QueryEscape(cfg.Loc.String()))

}

if cfg.MultiStatements {

if hasParam {

buf.WriteString("&multiStatements=true")

} else {

hasParam = true

buf.WriteString("?multiStatements=true")

}

}

if cfg.ParseTime {

if hasParam {

buf.WriteString("&parseTime=true")

} else {

hasParam = true

buf.WriteString("?parseTime=true")

}

}

if cfg.ReadTimeout > 0 {

if hasParam {

buf.WriteString("&readTimeout=")

} else {

hasParam = true

buf.WriteString("?readTimeout=")

}

buf.WriteString(cfg.ReadTimeout.String())

}

if cfg.Strict {

if hasParam {

buf.WriteString("&strict=true")

} else {

hasParam = true

buf.WriteString("?strict=true")

}

}

if cfg.Timeout > 0 {

if hasParam {

buf.WriteString("&timeout=")

} else {

hasParam = true

buf.WriteString("?timeout=")

}

buf.WriteString(cfg.Timeout.String())

}

if len(cfg.TLSConfig) > 0 {

if hasParam {

buf.WriteString("&tls=")

} else {

hasParam = true

buf.WriteString("?tls=")

}

buf.WriteString(url.QueryEscape(cfg.TLSConfig))

}

if cfg.WriteTimeout > 0 {

if hasParam {

buf.WriteString("&writeTimeout=")

} else {

hasParam = true

buf.WriteString("?writeTimeout=")

}

buf.WriteString(cfg.WriteTimeout.String())

}

if cfg.MaxAllowedPacket > 0 {

if hasParam {

buf.WriteString("&maxAllowedPacket=")

} else {

hasParam = true

buf.WriteString("?maxAllowedPacket=")

}

buf.WriteString(strconv.Itoa(cfg.MaxAllowedPacket))

}

// other params

if cfg.Params != nil {

for param, value := range cfg.Params {

if hasParam {

buf.WriteByte('&')

} else {

hasParam = true

buf.WriteByte('?')

}

buf.WriteString(param)

buf.WriteByte('=')

buf.WriteString(url.QueryEscape(value))

}

}

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 = &Config{

Loc: time.UTC,

Collation: defaultCollation,

}

// [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

}

}

cfg.DBName = dsn[i+1 : j]

break

}

}

if !foundSlash && len(dsn) > 0 {

return nil, errInvalidDSNNoSlash

}

if cfg.InterpolateParams && unsafeCollations[cfg.Collation] {

return nil, 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 nil, errors.New("default addr for network '" + cfg.Net + "' unknown")

}

}

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, "&") {

param := strings.SplitN(v, "=", 2)

if len(param) != 2 {

continue

}

// cfg params

switch value := param[1]; param[0] {

// Disable INFILE whitelist / 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)

}

// 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)

}

// 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

break

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)

}

// I/O read Timeout

case "readTimeout":

cfg.ReadTimeout, err = time.ParseDuration(value)

if err != nil {

return

}

// Strict mode

case "strict":

var isBool bool

cfg.Strict, isBool = readBool(value)

if !isBool {

return errors.New("invalid bool value: " + value)

}

// 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"

cfg.tls = &tls.Config{}

} else {

cfg.TLSConfig = "false"

}

} else if vl := strings.ToLower(value); vl == "skip-verify" {

cfg.TLSConfig = vl

cfg.tls = &tls.Config{InsecureSkipVerify: true}

} else {

name, err := url.QueryUnescape(value)

if err != nil {

return fmt.Errorf("invalid value for TLS config name: %v", err)

}

if tlsConfig, ok := tlsConfigRegister[name]; ok {

if len(tlsConfig.ServerName) == 0 && !tlsConfig.InsecureSkipVerify {

host, _, err := net.SplitHostPort(cfg.Addr)

if err == nil {

tlsConfig.ServerName = host

}

}

cfg.TLSConfig = name

cfg.tls = tlsConfig

} else {

return errors.New("invalid value / unknown config name: " + 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

}

default:

// lazy init

if cfg.Params == nil {

cfg.Params = make(map[string]string)

}

if cfg.Params[param[0]], err = url.QueryUnescape(value); err != nil {

return

}

}

}

return

}

一键复制

编辑

Web IDE

原始数据

按行查看

历史