Why does sql.Open() return nil as error when it should not?

I am trying to connect to a mysql database.

I tried to see if I would get an error if I gave it wrong connection information but it still returns nil as error. Even If I shut down mysql completely it still does not return an error. What is the point of check for errors after this function if it does not return errors?

This is on Windows, I am using XAMPP and I don't have a password for the database. Username is "root".

import (
	"database/sql"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "root@tcp(127.0.0.1:3306)/dbname?charset=utf8")
	if err != nil {
		log.Fatal(err)
	}
    defer db.Close()
}

SQL.Open only creates the DB object, but does not open any connections to the database. If you want to test your connections you have to execute a query to force opening a connection. The common way for this is to call Ping() on your DB object.

See http://golang.org/pkg/database/sql/#Open and http://golang.org/pkg/database/sql/#DB.Ping

Quoting from the doc of sql.Open():

> Open may just validate its arguments without creating a connection to the database. To verify that the data source name is valid, call Ping.

As stated, Open() may not open any physical connection to the database server, but it will validate its arguments. That being said if arguments are valid, it may return nil error even if the database server is not reachable, or even if the host denoted by dataSourceName does not exist.

To answer your other question:

> What is the point of check for errors after this function if it does not return errors?

You have to check returned errors because it can return errors. For example if the specified driverName is invalid, a non-nil error will be returned (see below).

To test if the database server is reachable, use DB.Ping(). But you can only use this if the returned error is nil, else the returned DB might also be nil (and thus calling the Ping() method on it may result in run-time panic):

if db, err := sql.Open("nonexistingdriver", "somesource"); err != nil {
	fmt.Println("Error creating DB:", err)
	fmt.Println("To verify, db is:", db)
} else {
	err = db.Ping()
	if err != nil {
		fmt.Println("db.Ping failed:", err)
	}
}

Output (try it on the Go Playground):

Error creating DB: sql: unknown driver "nonexistingdriver" (forgotten import?)
To verify, db is: <nil>

It turns out that this does not actually connect to the database right away.

Source: http://go-database-sql.org/accessing.html

To check the validity of connection, we can do this:

db, err := sql.Open("mysql", "root@tcp(127.0.0.1:3306)/dbname?charset=utf8")
err = db.Ping() // Need to do this to check that the connection is valid
if err != nil {
	log.Fatal(err)
}