Starting to transaction wrap

Author: BrandonRoehl

dump.go

@@ -14,17 +14,21 @@ import (
 /*
 Data struct to configure dump behavior
 
-    Out:          Stream to wite to
-    Connection:   Database connection to dump
-    IgnoreTables: Mark sensitive tables to ignore
+    Out:               Stream to wite to
+    Connection:        Database connection to dump
+    IgnoreTables:      Mark sensitive tables to ignore
+    LockTables:        Lock all tables for the duration of the dump
+    SingleTransaction: Do the entire dump in one transaction
 */
 type Data struct {
-	Out              io.Writer
-	Connection       *sql.DB
-	IgnoreTables     []string
-	MaxAllowedPacket int
-	LockTables       bool
-
+	Out               io.Writer
+	Connection        *sql.DB
+	IgnoreTables      []string
+	MaxAllowedPacket  int
+	LockTables        bool
+	SingleTransaction bool
+
+	tx         *sql.Tx
 	headerTmpl *template.Template
 	tableTmpl  *template.Template
 	footerTmpl *template.Template
@@ -49,7 +53,7 @@ type metaData struct {
 
 const (
 	// Version of this plugin for easy reference
-	Version = "0.5.0"
+	Version = "0.6.0"
 
 	defaultMaxAllowedPacket = 4194304
 )
@@ -123,15 +127,20 @@ func (data *Data) Dump() error {
 		data.MaxAllowedPacket = defaultMaxAllowedPacket
 	}
 
-	if err := meta.updateServerVersion(data.Connection); err != nil {
+	if err := data.getTemplates(); err != nil {
 		return err
 	}
 
-	if err := data.getTemplates(); err != nil {
+	if err := data.headerTmpl.Execute(data.Out, meta); err != nil {
 		return err
 	}
 
-	if err := data.headerTmpl.Execute(data.Out, meta); err != nil {
+	if err := data.begin(); err != nil {
+		return err
+	}
+	defer data.rollback()
+
+	if err := meta.updateServerVersion(data); err != nil {
 		return err
 	}
 
@@ -173,6 +182,18 @@ func (data *Data) Dump() error {
 
 // MARK: - Private methods
 
+func (data *Data) begin() (err error) {
+	data.tx, err = data.Connection.BeginTx(nil, &sql.TxOptions{
+		Isolation: sql.LevelRepeatableRead,
+		ReadOnly:  true,
+	})
+	return
+}
+
+func (data *Data) rollback() error {
+	return data.tx.Rollback()
+}
+
 // MARK: writter methods
 
 func (data *Data) dumpTable(name string) error {
@@ -214,7 +235,7 @@ func (data *Data) getTemplates() (err error) {
 func (data *Data) getTables() ([]string, error) {
 	tables := make([]string, 0)
 
-	rows, err := data.Connection.Query("SHOW TABLES")
+	rows, err := data.tx.Query("SHOW TABLES")
 	if err != nil {
 		return tables, err
 	}
@@ -241,10 +262,10 @@ func (data *Data) isIgnoredTable(name string) bool {
 	return false
 }
 
-func (data *metaData) updateServerVersion(db *sql.DB) (err error) {
+func (meta *metaData) updateServerVersion(data *Data) (err error) {
 	var serverVersion sql.NullString
-	err = db.QueryRow("SELECT version()").Scan(&serverVersion)
-	data.ServerVersion = serverVersion.String
+	err = data.tx.QueryRow("SELECT version()").Scan(&serverVersion)
+	meta.ServerVersion = serverVersion.String
 	return
 }
 
@@ -263,7 +284,7 @@ func (table *table) NameEsc() string {
 
 func (table *table) CreateSQL() (string, error) {
 	var tableReturn, tableSQL sql.NullString
-	if err := table.data.Connection.QueryRow("SHOW CREATE TABLE "+table.NameEsc()).Scan(&tableReturn, &tableSQL); err != nil {
+	if err := table.data.tx.QueryRow("SHOW CREATE TABLE "+table.NameEsc()).Scan(&tableReturn, &tableSQL); err != nil {
 		return "", err
 	}
 
@@ -280,7 +301,7 @@ func (table *table) Init() (err error) {
 		return errors.New("can't init twice")
 	}
 
-	table.rows, err = table.data.Connection.Query("SELECT * FROM " + table.NameEsc())
+	table.rows, err = table.data.tx.Query("SELECT * FROM " + table.NameEsc())
 	if err != nil {
 		return err
 	}

dump_test.go

@@ -10,21 +10,31 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestGetTablesOk(t *testing.T) {
+func GetMockData() (data *Data, mock sqlmock.Sqlmock, err error) {
 	db, mock, err := sqlmock.New()
+	if err != nil {
+		return
+	}
+	mock.ExpectBegin()
+
+	data = &Data{
+		Connection: db,
+	}
+	err = data.begin()
+	return
+}
+
+func TestGetTablesOk(t *testing.T) {
+	data, mock, err := GetMockData()
 	assert.NoError(t, err, "an error was not expected when opening a stub database connection")
-	defer db.Close()
+	defer data.Close()
 
 	rows := sqlmock.NewRows([]string{"Tables_in_Testdb"}).
 		AddRow("Test_Table_1").
 		AddRow("Test_Table_2")
 
 	mock.ExpectQuery("^SHOW TABLES$").WillReturnRows(rows)
 
-	data := Data{
-		Connection: db,
-	}
-
 	result, err := data.getTables()
 	assert.NoError(t, err)
 
@@ -94,11 +104,15 @@ func TestGetServerVersionOk(t *testing.T) {
 	rows := sqlmock.NewRows([]string{"Version()"}).
 		AddRow("test_version")
 
+	mock.ExpectBegin()
 	mock.ExpectQuery("^SELECT version()").WillReturnRows(rows)
 
 	meta := metaData{}
 
-	assert.NoError(t, meta.updateServerVersion(db), "error was not expected while updating stats")
+	tx, _ := db.Begin()
+	assert.NoError(t, meta.updateServerVersion(&Data{
+		tx: tx,
+	}), "error was not expected while updating stats")
 
 	// we make sure that all expectations were met
 	assert.NoError(t, mock.ExpectationsWereMet(), "there were unfulfilled expections")

mysqldump_test.go

@@ -76,11 +76,13 @@ func RunDump(t testing.TB, data *Data) {
 		AddRow(1, nil, "Test Name 1").
 		AddRow(2, "[email protected]", "Test Name 2")
 
+	mock.ExpectBegin()
 	mock.ExpectQuery(`^SELECT version\(\)$`).WillReturnRows(serverVersionRows)
-	mock.ExpectQuery("^SHOW TABLES$").WillReturnRows(showTablesRows)
+	mock.ExpectQuery(`^SHOW TABLES$`).WillReturnRows(showTablesRows)
 	mock.ExpectExec("^LOCK TABLES `Test_Table` READ /\\*!32311 LOCAL \\*/$").WillReturnResult(sqlmock.NewResult(1, 1))
 	mock.ExpectQuery("^SHOW CREATE TABLE `Test_Table`$").WillReturnRows(createTableRows)
 	mock.ExpectQuery("^SELECT (.+) FROM `Test_Table`$").WillReturnRows(createTableValueRows)
+	mock.ExpectRollback()
 
 	assert.NoError(t, data.Dump(), "an error was not expected when dumping a stub database connection")
 }
@@ -124,10 +126,12 @@ func TestNoLockOk(t *testing.T) {
 		AddRow(1, nil, "Test Name 1").
 		AddRow(2, "[email protected]", "Test Name 2")
 
+	mock.ExpectBegin()
 	mock.ExpectQuery(`^SELECT version\(\)$`).WillReturnRows(serverVersionRows)
-	mock.ExpectQuery("^SHOW TABLES$").WillReturnRows(showTablesRows)
+	mock.ExpectQuery(`^SHOW TABLES$`).WillReturnRows(showTablesRows)
 	mock.ExpectQuery("^SHOW CREATE TABLE `Test_Table`$").WillReturnRows(createTableRows)
 	mock.ExpectQuery("^SELECT (.+) FROM `Test_Table`$").WillReturnRows(createTableValueRows)
+	mock.ExpectRollback()
 
 	assert.NoError(t, data.Dump(), "an error was not expected when dumping a stub database connection")