Heavy rewrite of existing basic functionality, remove older func to create configs, clean up old code.

Author: c9845

sqldb-mariadb.go

@@ -28,3 +28,16 @@ func (cfg *Config) IsMariaDB() bool {
 func IsMariaDB() bool {
 	return config.IsMariaDB()
 }
+
+// IsMySQLOrMariaDB returns if the database is a MySQL or MariaDB. This is useful
+// since MariaDB is a fork of MySQL and most things are compatible; this way you
+// don't need to check IsMySQL() and IsMariaDB().
+func (cfg *Config) IsMySQLOrMariaDB() bool {
+	return cfg.Type == DBTypeMySQL || cfg.Type == DBTypeMariaDB
+}
+
+// IsMySQLOrMariaDB returns if the database is a MySQL or MariaDB for the package
+// level config.
+func IsMySQLOrMariaDB() bool {
+	return config.IsMySQLOrMariaDB()
+}

sqldb-sqlite-mattn.go

@@ -1,9 +1,14 @@
-//!modernc causes this file to be included by default if no -tags are provided to
-//go build or go run. AKA, default to using mattn if no build tag is provided.
+//go:build !modernc
 
-//mattn requires CGO. modernc does not which allows for easier cross compiled builds.
+/*
+This file handles the [github.com/mattn/go-sqlite3] SQLite library.
 
-//go:build !modernc
+This library is the default SQLite library if no build tags are provided. Note the
+"go:build !modernc" line.
+
+This library requires CGO, and therefore requires a bit more work to get cross-
+compiling to work properly.
+*/
 
 package sqldb
 
@@ -12,9 +17,14 @@ import (
 )
 
 const (
-	sqliteLibrary    = "github.com/mattn/go-sqlite3"
+	//sqliteLibrary is used in logging.
+	sqliteLibrary = "github.com/mattn/go-sqlite3"
+
+	//sqliteDriverName is used in Connect() when calling [database/sql.Open].
 	sqliteDriverName = "sqlite3"
 )
 
-// Placeholder so that this variable is defined for this SQLite library.
+// Placeholder so that this variable is defined for this SQLite library. The mattn
+// library defines some default PRAGMAs already so we do not need to define them here.
+// However, we need this variable defined since it is checked for in Connect().
 var sqliteDefaultPragmas = []string{}

sqldb-sqlite-modernc.go

@@ -1,19 +1,35 @@
 //go:build modernc
 
+/*
+This file handles the [modernc.org/sqlite] SQLite library.
+
+This library is not the default since it doesn't use the SQLite source C code and
+isn't as widely used.
+
+However, this library is straight golang and does not require CGO which makes cross-
+compiling much easier.
+*/
+
 package sqldb
 
 import (
 	_ "modernc.org/sqlite"
 )
 
 const (
-	sqliteLibrary    = "modernc.org/sqlite"
+	//sqliteLibrary is used in logging.
+	sqliteLibrary = "modernc.org/sqlite"
+
+	//sqliteDriverName is used in Connect() when calling [database/sql.Open].
 	sqliteDriverName = "sqlite"
 )
 
+// The [github.com/mattn/go-sqlite3] library sets some PRAGMAs by default. The
+// [modernc.org/sqlite]library does not define any default PRAGMAs. However, to
+// make switching between the two database libraries/drivers easier, we define
+// some PRAGMAs here to make using a SQLite database more consistent.
+//
+// https://github.com/mattn/go-sqlite3/blob/ae2a61f847e10e6dd771ecd4e1c55e0421cdc7f9/sqlite3.go#L1086
 var sqliteDefaultPragmas = []string{
-	//The mattn/go-sqlite3 sets this value by default. Use this for modernc/sqlite as
-	//well.
-	//https://github.com/mattn/go-sqlite3/blob/ae2a61f847e10e6dd771ecd4e1c55e0421cdc7f9/sqlite3.go#L1086
 	"PRAGMA busy_timeout = 5000",
 }

sqldb-sqlite.go

@@ -7,73 +7,51 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
-// defaults
 const (
-	//Possible libraries. Used in comparisons, such as when building connection string
-	//pragmas.
+	//Possible SQLite libraries. These are used in comparisons, such as when building
+	//the connection string PRAGMAs.
 	sqliteLibraryMattn   = "github.com/mattn/go-sqlite3"
 	sqliteLibraryModernc = "modernc.org/sqlite"
 
-	//InMemoryFilePathRacy is the "path" to provide for the SQLite file when you want
-	//to use an in-memory database instead of a filesystem file database. This is racy
-	//because each "Connect" call to :memory: will open a brand new database.
+	//InMemoryFilePathRacy is the path to provide for SQLitePath when you want to use
+	//an in-memory database instead of a file on disk. This is racy because each call
+	//to Connect() will open a brand new database. If you only call Connect() once
+	//then this is safe to use.
 	//
 	//This is good for running tests since then each test runs with a separate
 	//in-memory db.
 	InMemoryFilePathRacy = ":memory:"
 
-	//InMemoryFilePathRaceSafe is the "path" to provide for the SQLite file when you
-	//want to use an in-memory database between multiple "Connect" calls. This is race
-	//safe since multiple calls of "Connect" will connect to the same in-memory db,
-	//although connecting more than once to the same db would be very odd.
+	//InMemoryFilePathRaceSafe is the path to provide for SQLitePath when you want to
+	//use an in-memory database instead of a file on disk. This is race safe since
+	//multiple calls of Connect() will connect to the same in-memory database,
+	//although connecting more than once to the same database would be very odd.
 	InMemoryFilePathRaceSafe = "file::memory:?cache=shared"
 )
 
-// NewSQLiteConfig returns a config for connecting to a SQLite database.
-func NewSQLiteConfig(pathToFile string) (cfg *Config) {
-	//The returned error can be ignored since it only returns if a bad db type is
-	//provided but we are providing a known-good db type.
-	cfg, _ = NewConfig(DBTypeSQLite)
-
-	cfg.SQLitePath = pathToFile
-	cfg.SQLitePragmas = sqliteDefaultPragmas
-	cfg.UseDefaultTranslateFuncs()
-
-	return
-}
-
-// DefaultSQLiteConfig initializes the globally accessible package level config with
-// some defaults set.
-func DefaultSQLiteConfig(pathToFile string) {
-	cfg := NewSQLiteConfig(pathToFile)
-	config = *cfg
-}
-
-// IsSQLite returns true if the database is a SQLite database. This is easier
-// than checking for equality against the Type field in the config.
-func (cfg *Config) IsSQLite() bool {
-	return cfg.Type == DBTypeSQLite
+// IsSQLite returns true if the database is a SQLite database.
+func (c *Config) IsSQLite() bool {
+	return c.Type == DBTypeSQLite
 }
 
-// IsSQLite returns true if the database is a SQLite database. This is easier
-// than checking for equality against the Type field in the config.
+// IsSQLite returns true if the database is a SQLite database.
 func IsSQLite() bool {
-	return config.IsSQLite()
+	return cfg.IsSQLite()
 }
 
-// GetSQLiteVersion returns the version of SQLite that is embedded into the app. This
-// works by creating a temporary in-memory SQLite database to run a query against. We
-// don't use the config or an already established connection because we may want to
-// get the SQLiter version before a database is connected to!
+// GetSQLiteVersion returns the version of SQLite that is embedded into your app.
+// This works by creating a temporary in-memory SQLite database to run a query
+// against.
+//
+// A separate database connection is established because you might want to get the
+// SQLite version before you call Connect(). This also just keeps things separate
+// from your own connection.
 func GetSQLiteVersion() (version string, err error) {
 	//Get driver name based on SQLite library in use.
-	driver, err := getDriver(DBTypeSQLite)
-	if err != nil {
-		return
-	}
+	driver := getDriver(DBTypeSQLite)
 
 	//Connect.
-	conn, err := sqlx.Open(driver, ":memory:")
+	conn, err := sqlx.Open(driver, InMemoryFilePathRacy)
 	if err != nil {
 		return
 	}
@@ -89,66 +67,62 @@ func GetSQLiteVersion() (version string, err error) {
 }
 
 // GetSQLiteLibrary returns the SQLite library that was used to build the binary. The
-// library is set at build/run with -tags {mattn || modernc}.
+// library is set at build/run with go build tags.
 func GetSQLiteLibrary() string {
 	return sqliteLibrary
 }
 
-// SQLitePragmasAsString builds the string of pragmas that should be appended to the
-// filename when connecting to a SQLite database. This is needed to set pragmas reliably
-// since pragmas must be set upon initially connecting to the database. The difficulty
-// in setting pragmas is that each SQLite library (mattn vs modernc) has a slighly
-// different format for setting pragmas. This takes the list of pragmas in SQLite query
-// format (PRAGMA busy_timeout = 5000) and translates them to the correct format for
-// the SQLite library in use.
-func (cfg *Config) SQLitePragmasAsString() (filenamePragmaString string) {
+// pragmsQueriesToString takes SQLite PRAGMAs in query format and retuns them in the
+// format needed to be appended to a SQLite database filepath per the in-use SQLite
+// driver.
+//
+// SQLite PRAGMAs need to be set upon initially connecting to the database. The
+// PRAGMAs are added to the database file's path as query parameter (?...&...).
+// However, the format of these appended query parameters differs between SQLite
+// libraries. This translates PRAGMA statements into the format required by the
+// library the binary is built with.
+//
+// "PRAGMA busy_timeout = 5000" becomes "_pragma=busy_timeout=5000" when using the
+// modernc library.
+func pragmsQueriesToString(pragmas []string) (filenamePragmaString string) {
 	v := url.Values{}
 
-	for _, p := range cfg.SQLitePragmas {
+	for _, p := range pragmas {
 		//Sanitize, to make replace/stripping of "PRAGMA" keyword easier.
 		p = strings.ToLower(p)
 
 		//Strip out the PRAGMA keyword.
-		p = strings.Replace(p, "pragma", "", 1)
+		p = strings.TrimPrefix(p, "pragma")
 
-		//Build filename pragma as expected by SQLite library is use.
+		//Build pragma as expected by library in use.
 		switch GetSQLiteLibrary() {
 		case sqliteLibraryMattn:
-			//ex: _busy_timeout=5000
+			//Library's format:  _busy_timeout=5000
 			key, value, found := strings.Cut(p, "=")
 			if !found {
 				continue
 			}
 
-			//trim
 			key = strings.TrimSpace(key)
 			value = strings.TrimSpace(value)
 
-			//add
 			key = "_" + key
 			v.Add(key, value)
+
 		case sqliteLibraryModernc:
-			//ex: _pragma=busy_timeout=5000
+			//Library's format: _pragma=busy_timeout=5000
 			key := "_pragma"
 			value := p
 
-			//trim
 			value = strings.TrimSpace(value)
 			value = strings.Replace(value, " ", "", -1)
 
-			//add
 			v.Add(key, value)
+
 		default:
-			//this can never happen since we hardcode the supported sqlite libraries.
+			//This can never happen since we hardcode the supported SQLite libraries.
 		}
 	}
 
 	return "?" + v.Encode()
 }
-
-// GetDefaultSQLitePragmas returns the default PRAGMAs this package defines for use with
-// either SQLite library. This can be helpful for debugging. We don't just export the
-// sqliteDefaultPragmas slice so that it cannot be modified.
-func GetDefaultSQLitePragmas() []string {
-	return sqliteDefaultPragmas
-}