• Home
  • History
  • Annotate
Name Date Size #Lines LOC

..03-May-2022-

.github/H07-Jan-2020-5636

.travis/H07-Jan-2020-2316

.gitignoreH A D07-Jan-202084 109

.travis.ymlH A D07-Jan-20204.6 KiB130121

AUTHORSH A D07-Jan-20203.6 KiB10698

CHANGELOG.mdH A D07-Jan-20208.9 KiB207162

LICENSEH A D07-Jan-202016.3 KiB374293

README.mdH A D07-Jan-202021.2 KiB502351

auth.goH A D07-Jan-202010 KiB423279

auth_test.goH A D07-Jan-202038.8 KiB1,331979

benchmark_test.goH A D07-Jan-20207.8 KiB374325

buffer.goH A D07-Jan-20204.8 KiB183112

collations.goH A D07-Jan-20208.5 KiB266162

conncheck.goH A D07-Jan-20201.1 KiB5538

conncheck_dummy.goH A D07-Jan-2020505 185

conncheck_test.goH A D07-Jan-2020872 3921

connection.goH A D07-Jan-202013.8 KiB652525

connection_test.goH A D07-Jan-20204.1 KiB176136

connector.goH A D07-Jan-20203.5 KiB147101

connector_test.goH A D07-Jan-2020578 3126

const.goH A D07-Jan-20203.3 KiB175148

driver.goH A D07-Jan-20203.2 KiB10857

driver_test.goH A D07-Jan-202084.7 KiB3,1662,580

dsn.goH A D07-Jan-202014.1 KiB561428

dsn_test.goH A D07-Jan-202014.6 KiB416342

errors.goH A D07-Jan-20202.6 KiB6640

errors_test.goH A D07-Jan-2020989 4325

fields.goH A D07-Jan-20204.6 KiB195171

go.modH A D07-Jan-202047 42

infile.goH A D07-Jan-20204.5 KiB183124

nulltime.goH A D07-Jan-20201.2 KiB5133

nulltime_go113.goH A D07-Jan-2020814 325

nulltime_legacy.goH A D07-Jan-2020871 358

nulltime_test.goH A D07-Jan-20201.6 KiB6348

packets.goH A D07-Jan-202032.3 KiB1,343908

packets_test.goH A D07-Jan-20208 KiB337260

result.goH A D07-Jan-2020600 2311

rows.goH A D07-Jan-20204.7 KiB224168

statement.goH A D07-Jan-20204.8 KiB205141

statement_test.goH A D07-Jan-20202.8 KiB12795

transaction.goH A D07-Jan-2020729 3220

utils.goH A D07-Jan-202017.1 KiB702514

utils_test.goH A D07-Jan-20207.8 KiB294252

README.md

1# Go-MySQL-Driver
2
3A MySQL-Driver for Go's [database/sql](https://golang.org/pkg/database/sql/) package
4
5![Go-MySQL-Driver logo](https://raw.github.com/wiki/go-sql-driver/mysql/gomysql_m.png "Golang Gopher holding the MySQL Dolphin")
6
7---------------------------------------
8  * [Features](#features)
9  * [Requirements](#requirements)
10  * [Installation](#installation)
11  * [Usage](#usage)
12    * [DSN (Data Source Name)](#dsn-data-source-name)
13      * [Password](#password)
14      * [Protocol](#protocol)
15      * [Address](#address)
16      * [Parameters](#parameters)
17      * [Examples](#examples)
18    * [Connection pool and timeouts](#connection-pool-and-timeouts)
19    * [context.Context Support](#contextcontext-support)
20    * [ColumnType Support](#columntype-support)
21    * [LOAD DATA LOCAL INFILE support](#load-data-local-infile-support)
22    * [time.Time support](#timetime-support)
23    * [Unicode support](#unicode-support)
24  * [Testing / Development](#testing--development)
25  * [License](#license)
26
27---------------------------------------
28
29## Features
30  * Lightweight and [fast](https://github.com/go-sql-driver/sql-benchmark "golang MySQL-Driver performance")
31  * Native Go implementation. No C-bindings, just pure Go
32  * Connections over TCP/IPv4, TCP/IPv6, Unix domain sockets or [custom protocols](https://godoc.org/github.com/go-sql-driver/mysql#DialFunc)
33  * Automatic handling of broken connections
34  * Automatic Connection Pooling *(by database/sql package)*
35  * Supports queries larger than 16MB
36  * Full [`sql.RawBytes`](https://golang.org/pkg/database/sql/#RawBytes) support.
37  * Intelligent `LONG DATA` handling in prepared statements
38  * Secure `LOAD DATA LOCAL INFILE` support with file Whitelisting and `io.Reader` support
39  * Optional `time.Time` parsing
40  * Optional placeholder interpolation
41
42## Requirements
43  * Go 1.10 or higher. We aim to support the 3 latest versions of Go.
44  * MySQL (4.1+), MariaDB, Percona Server, Google CloudSQL or Sphinx (2.2.3+)
45
46---------------------------------------
47
48## Installation
49Simple install the package to your [$GOPATH](https://github.com/golang/go/wiki/GOPATH "GOPATH") with the [go tool](https://golang.org/cmd/go/ "go command") from shell:
50```bash
51$ go get -u github.com/go-sql-driver/mysql
52```
53Make sure [Git is installed](https://git-scm.com/downloads) on your machine and in your system's `PATH`.
54
55## Usage
56_Go MySQL Driver_ is an implementation of Go's `database/sql/driver` interface. You only need to import the driver and can use the full [`database/sql`](https://golang.org/pkg/database/sql/) API then.
57
58Use `mysql` as `driverName` and a valid [DSN](#dsn-data-source-name)  as `dataSourceName`:
59```go
60import "database/sql"
61import _ "github.com/go-sql-driver/mysql"
62
63db, err := sql.Open("mysql", "user:password@/dbname")
64```
65
66[Examples are available in our Wiki](https://github.com/go-sql-driver/mysql/wiki/Examples "Go-MySQL-Driver Examples").
67
68
69### DSN (Data Source Name)
70
71The Data Source Name has a common format, like e.g. [PEAR DB](http://pear.php.net/manual/en/package.database.db.intro-dsn.php) uses it, but without type-prefix (optional parts marked by squared brackets):
72```
73[username[:password]@][protocol[(address)]]/dbname[?param1=value1&...&paramN=valueN]
74```
75
76A DSN in its fullest form:
77```
78username:password@protocol(address)/dbname?param=value
79```
80
81Except for the databasename, all values are optional. So the minimal DSN is:
82```
83/dbname
84```
85
86If you do not want to preselect a database, leave `dbname` empty:
87```
88/
89```
90This has the same effect as an empty DSN string:
91```
92
93```
94
95Alternatively, [Config.FormatDSN](https://godoc.org/github.com/go-sql-driver/mysql#Config.FormatDSN) can be used to create a DSN string by filling a struct.
96
97#### Password
98Passwords can consist of any character. Escaping is **not** necessary.
99
100#### Protocol
101See [net.Dial](https://golang.org/pkg/net/#Dial) for more information which networks are available.
102In general you should use an Unix domain socket if available and TCP otherwise for best performance.
103
104#### Address
105For TCP and UDP networks, addresses have the form `host[:port]`.
106If `port` is omitted, the default port will be used.
107If `host` is a literal IPv6 address, it must be enclosed in square brackets.
108The functions [net.JoinHostPort](https://golang.org/pkg/net/#JoinHostPort) and [net.SplitHostPort](https://golang.org/pkg/net/#SplitHostPort) manipulate addresses in this form.
109
110For Unix domain sockets the address is the absolute path to the MySQL-Server-socket, e.g. `/var/run/mysqld/mysqld.sock` or `/tmp/mysql.sock`.
111
112#### Parameters
113*Parameters are case-sensitive!*
114
115Notice that any of `true`, `TRUE`, `True` or `1` is accepted to stand for a true boolean value. Not surprisingly, false can be specified as any of: `false`, `FALSE`, `False` or `0`.
116
117##### `allowAllFiles`
118
119```
120Type:           bool
121Valid Values:   true, false
122Default:        false
123```
124
125`allowAllFiles=true` disables the file Whitelist for `LOAD DATA LOCAL INFILE` and allows *all* files.
126[*Might be insecure!*](http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html)
127
128##### `allowCleartextPasswords`
129
130```
131Type:           bool
132Valid Values:   true, false
133Default:        false
134```
135
136`allowCleartextPasswords=true` allows using the [cleartext client side plugin](http://dev.mysql.com/doc/en/cleartext-authentication-plugin.html) if required by an account, such as one defined with the [PAM authentication plugin](http://dev.mysql.com/doc/en/pam-authentication-plugin.html). Sending passwords in clear text may be a security problem in some configurations. To avoid problems if there is any possibility that the password would be intercepted, clients should connect to MySQL Server using a method that protects the password. Possibilities include [TLS / SSL](#tls), IPsec, or a private network.
137
138##### `allowNativePasswords`
139
140```
141Type:           bool
142Valid Values:   true, false
143Default:        true
144```
145`allowNativePasswords=false` disallows the usage of MySQL native password method.
146
147##### `allowOldPasswords`
148
149```
150Type:           bool
151Valid Values:   true, false
152Default:        false
153```
154`allowOldPasswords=true` allows the usage of the insecure old password method. This should be avoided, but is necessary in some cases. See also [the old_passwords wiki page](https://github.com/go-sql-driver/mysql/wiki/old_passwords).
155
156##### `charset`
157
158```
159Type:           string
160Valid Values:   <name>
161Default:        none
162```
163
164Sets the charset used for client-server interaction (`"SET NAMES <value>"`). If multiple charsets are set (separated by a comma), the following charset is used if setting the charset failes. This enables for example support for `utf8mb4` ([introduced in MySQL 5.5.3](http://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html)) with fallback to `utf8` for older servers (`charset=utf8mb4,utf8`).
165
166Usage of the `charset` parameter is discouraged because it issues additional queries to the server.
167Unless you need the fallback behavior, please use `collation` instead.
168
169##### `checkConnLiveness`
170
171```
172Type:           bool
173Valid Values:   true, false
174Default:        true
175```
176
177On supported platforms connections retrieved from the connection pool are checked for liveness before using them. If the check fails, the respective connection is marked as bad and the query retried with another connection.
178`checkConnLiveness=false` disables this liveness check of connections.
179
180##### `collation`
181
182```
183Type:           string
184Valid Values:   <name>
185Default:        utf8mb4_general_ci
186```
187
188Sets the collation used for client-server interaction on connection. In contrast to `charset`, `collation` does not issue additional queries. If the specified collation is unavailable on the target server, the connection will fail.
189
190A list of valid charsets for a server is retrievable with `SHOW COLLATION`.
191
192The default collation (`utf8mb4_general_ci`) is supported from MySQL 5.5.  You should use an older collation (e.g. `utf8_general_ci`) for older MySQL.
193
194Collations for charset "ucs2", "utf16", "utf16le", and "utf32" can not be used ([ref](https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html#charset-connection-impermissible-client-charset)).
195
196
197##### `clientFoundRows`
198
199```
200Type:           bool
201Valid Values:   true, false
202Default:        false
203```
204
205`clientFoundRows=true` causes an UPDATE to return the number of matching rows instead of the number of rows changed.
206
207##### `columnsWithAlias`
208
209```
210Type:           bool
211Valid Values:   true, false
212Default:        false
213```
214
215When `columnsWithAlias` is true, calls to `sql.Rows.Columns()` will return the table alias and the column name separated by a dot. For example:
216
217```
218SELECT u.id FROM users as u
219```
220
221will return `u.id` instead of just `id` if `columnsWithAlias=true`.
222
223##### `interpolateParams`
224
225```
226Type:           bool
227Valid Values:   true, false
228Default:        false
229```
230
231If `interpolateParams` is true, placeholders (`?`) in calls to `db.Query()` and `db.Exec()` are interpolated into a single query string with given parameters. This reduces the number of roundtrips, since the driver has to prepare a statement, execute it with given parameters and close the statement again with `interpolateParams=false`.
232
233*This can not be used together with the multibyte encodings BIG5, CP932, GB2312, GBK or SJIS. These are blacklisted as they may [introduce a SQL injection vulnerability](http://stackoverflow.com/a/12118602/3430118)!*
234
235##### `loc`
236
237```
238Type:           string
239Valid Values:   <escaped name>
240Default:        UTC
241```
242
243Sets the location for time.Time values (when using `parseTime=true`). *"Local"* sets the system's location. See [time.LoadLocation](https://golang.org/pkg/time/#LoadLocation) for details.
244
245Note that this sets the location for time.Time values but does not change MySQL's [time_zone setting](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html). For that see the [time_zone system variable](#system-variables), which can also be set as a DSN parameter.
246
247Please keep in mind, that param values must be [url.QueryEscape](https://golang.org/pkg/net/url/#QueryEscape)'ed. Alternatively you can manually replace the `/` with `%2F`. For example `US/Pacific` would be `loc=US%2FPacific`.
248
249##### `maxAllowedPacket`
250```
251Type:          decimal number
252Default:       4194304
253```
254
255Max packet size allowed in bytes. The default value is 4 MiB and should be adjusted to match the server settings. `maxAllowedPacket=0` can be used to automatically fetch the `max_allowed_packet` variable from server *on every connection*.
256
257##### `multiStatements`
258
259```
260Type:           bool
261Valid Values:   true, false
262Default:        false
263```
264
265Allow multiple statements in one query. While this allows batch queries, it also greatly increases the risk of SQL injections. Only the result of the first query is returned, all other results are silently discarded.
266
267When `multiStatements` is used, `?` parameters must only be used in the first statement.
268
269##### `parseTime`
270
271```
272Type:           bool
273Valid Values:   true, false
274Default:        false
275```
276
277`parseTime=true` changes the output type of `DATE` and `DATETIME` values to `time.Time` instead of `[]byte` / `string`
278The date or datetime like `0000-00-00 00:00:00` is converted into zero value of `time.Time`.
279
280
281##### `readTimeout`
282
283```
284Type:           duration
285Default:        0
286```
287
288I/O read timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
289
290##### `rejectReadOnly`
291
292```
293Type:           bool
294Valid Values:   true, false
295Default:        false
296```
297
298
299`rejectReadOnly=true` causes the driver to reject read-only connections. This
300is for a possible race condition during an automatic failover, where the mysql
301client gets connected to a read-only replica after the failover.
302
303Note that this should be a fairly rare case, as an automatic failover normally
304happens when the primary is down, and the race condition shouldn't happen
305unless it comes back up online as soon as the failover is kicked off. On the
306other hand, when this happens, a MySQL application can get stuck on a
307read-only connection until restarted. It is however fairly easy to reproduce,
308for example, using a manual failover on AWS Aurora's MySQL-compatible cluster.
309
310If you are not relying on read-only transactions to reject writes that aren't
311supposed to happen, setting this on some MySQL providers (such as AWS Aurora)
312is safer for failovers.
313
314Note that ERROR 1290 can be returned for a `read-only` server and this option will
315cause a retry for that error. However the same error number is used for some
316other cases. You should ensure your application will never cause an ERROR 1290
317except for `read-only` mode when enabling this option.
318
319
320##### `serverPubKey`
321
322```
323Type:           string
324Valid Values:   <name>
325Default:        none
326```
327
328Server public keys can be registered with [`mysql.RegisterServerPubKey`](https://godoc.org/github.com/go-sql-driver/mysql#RegisterServerPubKey), which can then be used by the assigned name in the DSN.
329Public keys are used to transmit encrypted data, e.g. for authentication.
330If the server's public key is known, it should be set manually to avoid expensive and potentially insecure transmissions of the public key from the server to the client each time it is required.
331
332
333##### `timeout`
334
335```
336Type:           duration
337Default:        OS default
338```
339
340Timeout for establishing connections, aka dial timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
341
342
343##### `tls`
344
345```
346Type:           bool / string
347Valid Values:   true, false, skip-verify, preferred, <name>
348Default:        false
349```
350
351`tls=true` enables TLS / SSL encrypted connection to the server. Use `skip-verify` if you want to use a self-signed or invalid certificate (server side) or use `preferred` to use TLS only when advertised by the server. This is similar to `skip-verify`, but additionally allows a fallback to a connection which is not encrypted. Neither `skip-verify` nor `preferred` add any reliable security. You can use a custom TLS config after registering it with [`mysql.RegisterTLSConfig`](https://godoc.org/github.com/go-sql-driver/mysql#RegisterTLSConfig).
352
353
354##### `writeTimeout`
355
356```
357Type:           duration
358Default:        0
359```
360
361I/O write timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
362
363
364##### System Variables
365
366Any other parameters are interpreted as system variables:
367  * `<boolean_var>=<value>`: `SET <boolean_var>=<value>`
368  * `<enum_var>=<value>`: `SET <enum_var>=<value>`
369  * `<string_var>=%27<value>%27`: `SET <string_var>='<value>'`
370
371Rules:
372* The values for string variables must be quoted with `'`.
373* The values must also be [url.QueryEscape](http://golang.org/pkg/net/url/#QueryEscape)'ed!
374 (which implies values of string variables must be wrapped with `%27`).
375
376Examples:
377  * `autocommit=1`: `SET autocommit=1`
378  * [`time_zone=%27Europe%2FParis%27`](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html): `SET time_zone='Europe/Paris'`
379  * [`tx_isolation=%27REPEATABLE-READ%27`](https://dev.mysql.com/doc/refman/5.5/en/server-system-variables.html#sysvar_tx_isolation): `SET tx_isolation='REPEATABLE-READ'`
380
381
382#### Examples
383```
384user@unix(/path/to/socket)/dbname
385```
386
387```
388root:pw@unix(/tmp/mysql.sock)/myDatabase?loc=Local
389```
390
391```
392user:password@tcp(localhost:5555)/dbname?tls=skip-verify&autocommit=true
393```
394
395Treat warnings as errors by setting the system variable [`sql_mode`](https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html):
396```
397user:password@/dbname?sql_mode=TRADITIONAL
398```
399
400TCP via IPv6:
401```
402user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?timeout=90s&collation=utf8mb4_unicode_ci
403```
404
405TCP on a remote host, e.g. Amazon RDS:
406```
407id:password@tcp(your-amazonaws-uri.com:3306)/dbname
408```
409
410Google Cloud SQL on App Engine:
411```
412user:password@unix(/cloudsql/project-id:region-name:instance-name)/dbname
413```
414
415TCP using default port (3306) on localhost:
416```
417user:password@tcp/dbname?charset=utf8mb4,utf8&sys_var=esc%40ped
418```
419
420Use the default protocol (tcp) and host (localhost:3306):
421```
422user:password@/dbname
423```
424
425No Database preselected:
426```
427user:password@/
428```
429
430
431### Connection pool and timeouts
432The connection pool is managed by Go's database/sql package. For details on how to configure the size of the pool and how long connections stay in the pool see `*DB.SetMaxOpenConns`, `*DB.SetMaxIdleConns`, and `*DB.SetConnMaxLifetime` in the [database/sql documentation](https://golang.org/pkg/database/sql/). The read, write, and dial timeouts for each individual connection are configured with the DSN parameters [`readTimeout`](#readtimeout), [`writeTimeout`](#writetimeout), and [`timeout`](#timeout), respectively.
433
434## `ColumnType` Support
435This driver supports the [`ColumnType` interface](https://golang.org/pkg/database/sql/#ColumnType) introduced in Go 1.8, with the exception of [`ColumnType.Length()`](https://golang.org/pkg/database/sql/#ColumnType.Length), which is currently not supported.
436
437## `context.Context` Support
438Go 1.8 added `database/sql` support for `context.Context`. This driver supports query timeouts and cancellation via contexts.
439See [context support in the database/sql package](https://golang.org/doc/go1.8#database_sql) for more details.
440
441
442### `LOAD DATA LOCAL INFILE` support
443For this feature you need direct access to the package. Therefore you must change the import path (no `_`):
444```go
445import "github.com/go-sql-driver/mysql"
446```
447
448Files must be whitelisted by registering them with `mysql.RegisterLocalFile(filepath)` (recommended) or the Whitelist check must be deactivated by using the DSN parameter `allowAllFiles=true` ([*Might be insecure!*](http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html)).
449
450To use a `io.Reader` a handler function must be registered with `mysql.RegisterReaderHandler(name, handler)` which returns a `io.Reader` or `io.ReadCloser`. The Reader is available with the filepath `Reader::<name>` then. Choose different names for different handlers and `DeregisterReaderHandler` when you don't need it anymore.
451
452See the [godoc of Go-MySQL-Driver](https://godoc.org/github.com/go-sql-driver/mysql "golang mysql driver documentation") for details.
453
454
455### `time.Time` support
456The default internal output type of MySQL `DATE` and `DATETIME` values is `[]byte` which allows you to scan the value into a `[]byte`, `string` or `sql.RawBytes` variable in your program.
457
458However, many want to scan MySQL `DATE` and `DATETIME` values into `time.Time` variables, which is the logical equivalent in Go to `DATE` and `DATETIME` in MySQL. You can do that by changing the internal output type from `[]byte` to `time.Time` with the DSN parameter `parseTime=true`. You can set the default [`time.Time` location](https://golang.org/pkg/time/#Location) with the `loc` DSN parameter.
459
460**Caution:** As of Go 1.1, this makes `time.Time` the only variable type you can scan `DATE` and `DATETIME` values into. This breaks for example [`sql.RawBytes` support](https://github.com/go-sql-driver/mysql/wiki/Examples#rawbytes).
461
462Alternatively you can use the [`NullTime`](https://godoc.org/github.com/go-sql-driver/mysql#NullTime) type as the scan destination, which works with both `time.Time` and `string` / `[]byte`.
463
464
465### Unicode support
466Since version 1.5 Go-MySQL-Driver automatically uses the collation ` utf8mb4_general_ci` by default.
467
468Other collations / charsets can be set using the [`collation`](#collation) DSN parameter.
469
470Version 1.0 of the driver recommended adding `&charset=utf8` (alias for `SET NAMES utf8`) to the DSN to enable proper UTF-8 support. This is not necessary anymore. The [`collation`](#collation) parameter should be preferred to set another collation / charset than the default.
471
472See http://dev.mysql.com/doc/refman/8.0/en/charset-unicode.html for more details on MySQL's Unicode support.
473
474## Testing / Development
475To run the driver tests you may need to adjust the configuration. See the [Testing Wiki-Page](https://github.com/go-sql-driver/mysql/wiki/Testing "Testing") for details.
476
477Go-MySQL-Driver is not feature-complete yet. Your help is very appreciated.
478If you want to contribute, you can work on an [open issue](https://github.com/go-sql-driver/mysql/issues?state=open) or review a [pull request](https://github.com/go-sql-driver/mysql/pulls).
479
480See the [Contribution Guidelines](https://github.com/go-sql-driver/mysql/blob/master/CONTRIBUTING.md) for details.
481
482---------------------------------------
483
484## License
485Go-MySQL-Driver is licensed under the [Mozilla Public License Version 2.0](https://raw.github.com/go-sql-driver/mysql/master/LICENSE)
486
487Mozilla summarizes the license scope as follows:
488> MPL: The copyleft applies to any files containing MPLed code.
489
490
491That means:
492  * You can **use** the **unchanged** source code both in private and commercially.
493  * When distributing, you **must publish** the source code of any **changed files** licensed under the MPL 2.0 under a) the MPL 2.0 itself or b) a compatible license (e.g. GPL 3.0 or Apache License 2.0).
494  * You **needn't publish** the source code of your library as long as the files licensed under the MPL 2.0 are **unchanged**.
495
496Please read the [MPL 2.0 FAQ](https://www.mozilla.org/en-US/MPL/2.0/FAQ/) if you have further questions regarding the license.
497
498You can read the full terms here: [LICENSE](https://raw.github.com/go-sql-driver/mysql/master/LICENSE).
499
500![Go Gopher and MySQL Dolphin](https://raw.github.com/wiki/go-sql-driver/mysql/go-mysql-driver_m.jpg "Golang Gopher transporting the MySQL Dolphin in a wheelbarrow")
501
502