Better support for in-memory sqlite databases by allowing a db connection to remain open after deploying or updating schema. Clean up some logging.

Previously, deploying or updating a db schema closed the connection after deploy or update completed successfully.  However, this didn't work for in-memory sqlite db since each connection using a new db.  Therefore, when a connection was reestablished after deploy, this new connection didn't see a deployed db, it saw an empty db.  To fix this, deploying or updating a db can now leave the connection open for reuse in running queries.

Author: c9845 (AA-Desktop)

changlog.txt

@@ -1,3 +1,17 @@
+v1.3.0
+----------
+- Clean up logging.
+    - Previously logging was done with `if c.Debug{}` blocks encapsulating a `.log.Println()` call.
+    - Now, c.debugPrintln can be used.
+    - This removes a lot of `if` blocks to make code cleaner.
+- Allow keeping a database connection open after deploying or updating schema.
+    - This was necessary for supporting SQLite when using an in-memory database.  
+    - When an deploying a db the connection was closed after deploy was completed.
+    - However, for an in-memory db this doesn't work since each connection gets a "new" db. 
+    - When the connection was reopened to run queries none of the deployed schema existed.
+    - To alleviate this, deploying (or updating) a db now can take an options struct that allows for keeping the connection open after deploy/update.
+    - This allows connection to be reused and in-memory db to function as expected.
+
 v1.2.0
 ----------
 - Allow choosing between mattn and modernc libraries for SQLite.

sqldb-deploySchema.go

@@ -10,20 +10,32 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
-//DeploySchema deploys the database schema by running the list of DeployQueries defined
-//on a database config. This will create the database if needed. Typically this is used
-//to deploy an empty, or near empty, database. A database connection must not already
-//be established; this func will establish the connection the leave it open for further
-//use.
+//DeploySchemaOptions provides options when deploying a schema.
+type DeploySchemaOptions struct {
+	SkipInsert      bool
+	CloseConnection bool
+}
+
+//DeploySchemaWithOps deploys the database schema by running the list of DeployQueries
+//and DeployFuncs defined in config. This will create the database if needed. This is
+//typically used to deploy an empty, or near empty, database. A database connection
+//must not already be established; this func will establish the connection.
 //
-//Typically this func would be called when your app is passed a flag, such as --deploy-db,
-//so that your database is only deployed when needed, not as part of every start of
-//your app.
+//Although each DeployQuery and DeployFunc should be indempotent (ex.: using CREATE
+//TABLE IF NOT EXISTS), you should still not call this func each time your app starts
+//or otherwise. Typically you would check if the database already exists or use a
+//flag, such as --deploy-db, to run this func.
 //
-//The dontInsert parameter is used prevent any DeployQueries with "INSERT INTO" statements
-//from running. This is used to deploy a completely empty database.
-func (c *Config) DeploySchema(dontInsert bool) (err error) {
-	//Make sure the connection isn't already established to prevent overwriting anything.
+//skipInsert is used prevent any DeployQueries with "INSERT INTO" statements from
+//running. This is used to deploy a completely empty database and is useful for
+//migrating data or backups.
+//
+//closeConnection determines if the database connection should be closed after  this
+//func successfully completes. This was added to support SQLite in-memory databases
+//since each connection to an im-memory db uses a new database, so if we deploy with
+//a connection we need to reuse it to run queries.
+func (c *Config) DeploySchemaWithOps(ops DeploySchemaOptions) (err error) {
+	//Make sure a connection isn't already established to prevent overwriting anything.
 	//This forces users to call Close() first to prevent any incorrect db usage.
 	if c.Connected() {
 		return ErrConnected
@@ -55,9 +67,9 @@ func (c *Config) DeploySchema(dontInsert bool) (err error) {
 	}
 	defer conn.Close()
 
-	//Handle any database-type specific stuff.
-	//For non-sqlite dbs, we need to create the actual database on the server.
-	//For sqlite dbs, we need to Ping() the connection so the db file is created on disk.
+	//Create the database.
+	//For mariadb/mysql, we need to create the actual database on the server.
+	//For SQLite , we need to Ping() the connection so the file is created on disk.
 	switch c.Type {
 	case DBTypeMySQL, DBTypeMariaDB:
 		q := `CREATE DATABASE IF NOT EXISTS ` + c.Name
@@ -75,95 +87,105 @@ func (c *Config) DeploySchema(dontInsert bool) (err error) {
 
 	//Reconnect to the database since the previously used connection didn't include
 	//the database name in the connection string. This will connect us to the specific
-	//database, not the database server. This connects using Connect(), the same func
-	//that would be used to connect to the db for normal usage.
-	//
-	//This is not necessary for SQLite since SQLite always connects to the filepath
-	//that was provided, not a server.
-	if !c.IsSQLite() {
-		err = conn.Close()
-		if err != nil {
-			return
-		}
+	//database, not just the database server. This connects using Connect(), the same
+	//func that would be used to connect to the db for normal usage.
+	err = conn.Close()
+	if err != nil {
+		return
+	}
 
-		//Note, no `defer Close()` since we want to leave the connection to the db
-		//open upon successfully deploying the db so that db can be used without
-		//calling `Connect()` after this func.
-		err = c.Connect()
-		if err != nil {
-			return
-		}
+	err = c.Connect()
+	if err != nil {
+		return
+	}
+
+	if ops.CloseConnection {
+		defer c.Close()
 	}
 
 	//Run each deploy query.
-	c.log("sqldb.DeploySchema (DeployQueries)...")
+	c.debugPrintln("sqldb.DeploySchema (DeployQueries)...")
+	connection := c.Connection()
 	for _, q := range c.DeployQueries {
 		//Translate the query if needed. This will only translate queries with
 		//CREATE TABLE in the text.
 		q = c.translateCreateTable(q)
 
-		//skip queries that insert data if needed. This will skip any query with
-		//INSERT INTO in the text.
-		if strings.Contains(strings.ToUpper(q), "INSERT INTO") && dontInsert {
+		//Skip queries that insert data if needed.
+		if strings.Contains(strings.ToUpper(q), "INSERT INTO") && ops.SkipInsert {
 			continue
 		}
 
-		if c.Debug {
-			if strings.Contains(q, "CREATE TABLE") {
-				idx := strings.Index(q, "(")
-				log.Println(strings.TrimSpace(q[:idx]) + "...")
-			} else {
-				log.Println(q)
-			}
-
+		//Log out some info about the query being run for diagnostics.
+		if strings.Contains(q, "CREATE TABLE") {
+			idx := strings.Index(q, "(")
+			c.debugPrintln(strings.TrimSpace(q[:idx]) + "...")
+		} else {
+			c.debugPrintln(q)
 		}
 
-		//Execute the query.
-		//Logging on error so users can identify query in question.
-		connection := c.Connection()
+		//Execute the query. Always log on error so users can identify query that has
+		//an error.
 		_, innerErr := connection.Exec(q)
 		if innerErr != nil {
 			err = innerErr
 			log.Println("sqldb.DeploySchema() error with query", q)
+			c.Close()
 			return
 		}
 	}
-	if c.Debug {
-		log.Println("sqldb.DeploySchema (DeployQueries)...done")
-	}
+	c.debugPrintln("sqldb.DeploySchema (DeployQueries)...done")
 
 	//Run each deploy func.
-	if c.Debug {
-		log.Println("sqldb.DeploySchema (DeployFuncs)...")
-	}
+	c.debugPrintln("sqldb.DeploySchema (DeployFuncs)...")
 	for _, f := range c.DeployFuncs {
-		//get function name for diagnostics
+		//Get function name for diagnostics.
 		rawNameWithPath := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
 		funcName := path.Base(rawNameWithPath)
 
-		if c.Debug {
-			log.Println(funcName)
-		}
+		//Log out some infor about the func being run for diagnostics.
+		c.debugPrintln(funcName)
 
+		//Execute the func. Always log on error so users can identify query that has
+		//an error.
 		innerErr := f()
 		if innerErr != nil {
-			log.Println("Error with deploy func", funcName)
+			log.Println("sqldb.DeploySchema() error with deploy func", funcName)
+			c.Close()
 			return innerErr
 		}
 
 	}
-	if c.Debug {
-		log.Println("sqldb.DeploySchema (DeployFuncs)...done")
-	}
+	c.debugPrintln("sqldb.DeploySchema (DeployFuncs)...done")
 
-	//Not closing the connection upon success since user may want to start interacting
-	//with the db right away and this removes the need to call Connect() right after
-	//this func.
+	if ops.CloseConnection {
+		//close is handled by defer above.
+		c.debugPrintln("Connection closed upon successful deploy.")
+	} else {
+		c.debugPrintln("Connection left open after successful deploy.")
+	}
 
 	return
 }
 
-//DeploySchema deploys the database for the default package level config.
-func DeploySchema(dontInsert bool) (err error) {
-	return config.DeploySchema(dontInsert)
+//DeploySchemaWithOps deploys the database for the default package level config.
+func DeploySchemaWithOps(ops DeploySchemaOptions) (err error) {
+	return config.DeploySchemaWithOps(ops)
+}
+
+//DeploySchema runs DeploySchemaWithOps with some defaults set. This was implemented
+//to support legacy compatibility while expanding the feature set with deploy options.
+func (c *Config) DeploySchema(skipInsert bool) (err error) {
+	ops := DeploySchemaOptions{
+		SkipInsert:      skipInsert,
+		CloseConnection: true, //legacy
+	}
+	return c.DeploySchemaWithOps(ops)
+}
+
+//DeploySchema runs DeploySchemaWithOps with some defaults set for the default package
+//level config. This was implemented to support legacy compatibility while expanding
+//the feature set with deploy options.
+func DeploySchema(skipInsert bool) (err error) {
+	return config.DeploySchema(skipInsert)
 }