Proper way to create MySql interface in Go - mysql

Question

I am working on connecting my application to MySql. The code is structured the following way, which works, but looks a little odd to me. Is this the right pattern to follow?
I have saved my Db related things in a separate file, which looks like this:
var DatabaseObject MySqlDatabase
type IMySqlDatabase interface {
ConnectToDb() MySqlDatabase
GetDb() MySqlDatabase
}
type MySqlDatabase struct{
Db *sql.DB
}
func (MySqlDatabase) ConnectToDb(connectionString string){
db, _ := sql.Open("mysql", connectionString)
_ = db.Ping()
DatabaseObject = MySqlDatabase{Db: db}
}
func (MySqlDatabase) GetDb() *sql.DB{
return DatabaseObject.Db
}
As such I can connect to the database the following way:
infrastructureMySql.DatabaseObject.ConnectToDb(connectionString)
Which I find odd. Is there any sense of having an interface in the first place? If I didn't have it I could simply use the *sql.DB as a global variable. Thank you for your feedback.

Answer 1

I generally like to follow this guide by Ben Johnson when creating db:
See 3. Wrap types for application-specific context
This article mentions that we can provide an abstract layer here by interacting with the interface and so you don't need to leak these details in the application layer.
You mentioned that you would like to perform queries and other commands so you can draw up an interface regarding those commands like so:
type Mysql struct {
db *sql.DB
}
// Wrap a new connection into the MySql struct
func NewMysql() (*Mysql, error) {
db, err := sql.Open(...)
return &Mysql{ db }, err
}
func (m *Mysql) GetUsers(...) ([]User, error) {}
func (m *Mysql) CreateUsers(...) (User, error) {}
type UserStore interface {
GetUsers func(...) []User, error)
CreateUsers func(...) (User, error)
}

Answer 2

This is definitely incorrect:
MySqlDatabase does not implement IMySqlDatabase, so it would not work if you actually tried to use the interface
You're not actually using the interface
And has style issues:
The interface returns concrete types, which defeats the purpose
The interface appears to be a factory of itself? Or something? It's unclear what the interface or the concrete type are really supposed to be/do
Interfaces in Go should not be named IThing, that's C#
You appear to have type methods which modify globals which is going to be extremely unexpected to anyone using them