common: Add new parameter to diff function for specifying merge strategy

This adds a new parameter to the diff function to specify the merge
strategy. This is mostly intended for later use and at the moment does
not do much except for toggling on or off the output of SQL statements
in the generated changeset object.

The way this is meant to be used (without guarantees that this is going
to work) is to use the NoMerge strategy when no merging is intended in
order to save some CPU cycles.

The PreservePkMerge strategy is intended for generating the SQL
statements needed to create database B out of database A in this
scenario:
A --> B
It can also be used when the user needs the primary key of their tables
to be preserved, i.e. when it carries some meaning.

The NewPkMerge strategy generates the same SQL statements except for the
INSERT statements which create new primary keys instead of keeping the
original ones. This is intended for merging databases B and C into
database D in this scenario:
A --> B --> D
\           ^
 \--> C ---/
Here the diff between A and C using the NewPkMerge strategy can be
applied on B to create D - at least when conflicting UPDATEs are
handled.

As soon as we implement actual merging we might want to add a function
to guess the merge strategy depending on whether or not the table has a
primary key, it is AUTOINCREMENTing, and it is of type INTEGER or some
similar algorithm and add a "guess" merge strategy here.

This commit also adds support for the new parameter to the API handler.
If no value is provided we default to the "none" merge strategy.

Author: MKleusberg

api/handlers.go

@@ -84,13 +84,26 @@ func columnsHandler(w http.ResponseWriter, r *http.Request) {
 //   * "dbname_b" is the name of the second database being diffed (optional, if not provided same as first name)
 //   * "commit_a" is the first commit for diffing
 //   * "commit_b" is the second commit for diffing
+//   * "merge" specifies the merge strategy (possible values: "none", "preserve_pk", "new_pk"; optional, defaults to "none")
 func diffHandler(w http.ResponseWriter, r *http.Request) {
 	loggedInUser, err := checkAuth(w, r)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusUnauthorized)
 		return
 	}
 
+	// Get merge strategy and parse value. Default to "none"
+	merge := r.PostFormValue("merge")
+	merge_strategy := com.NoMerge
+	if merge == "preserve_pk" {
+		merge_strategy = com.PreservePkMerge
+	} else if merge == "new_pk" {
+		merge_strategy = com.NewPkMerge
+	} else if merge != "" && merge != "none" {
+		jsonErr(w, "Invalid merge strategy", http.StatusBadRequest)
+		return
+	}
+
 	// Retrieve owner, name, and commit ids
 	oa := r.PostFormValue("dbowner_a")
 	na := r.PostFormValue("dbname_a")
@@ -164,7 +177,7 @@ func diffHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Perform diff
-	diffs, err := com.Diff(dbOwnerA, "/", dbNameA, ca, dbOwnerB, "/", dbNameB, cb, loggedInUser)
+	diffs, err := com.Diff(dbOwnerA, "/", dbNameA, ca, dbOwnerB, "/", dbNameB, cb, loggedInUser, merge_strategy)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return

common/diff.go

@@ -17,6 +17,14 @@ const (
 	ACTION_MODIFY          = "modify"
 )
 
+type MergeStrategy int
+
+const (
+	NoMerge         MergeStrategy = iota
+	PreservePkMerge
+	NewPkMerge
+)
+
 type SchemaDiff struct {
 	ActionType DiffType `json:"action_type"`
 	Sql        string   `json:"sql"`
@@ -41,7 +49,7 @@ type Diffs struct {
 }
 
 // Diff generates the differences between the two commits commitA and commitB of the two databases specified in the other parameters
-func Diff(ownerA string, folderA string, nameA string, commitA string, ownerB string, folderB string, nameB string, commitB string, loggedInUser string) (Diffs, error) {
+func Diff(ownerA string, folderA string, nameA string, commitA string, ownerB string, folderB string, nameB string, commitB string, loggedInUser string, merge MergeStrategy) (Diffs, error) {
 	// Check if the user has access to the requested databases
 	bucketA, idA, _, err := MinioLocation(ownerA, folderA, nameA, commitA, loggedInUser)
 	if err != nil {
@@ -77,11 +85,11 @@ func Diff(ownerA string, folderA string, nameA string, commitA string, ownerB st
 	}
 
 	// Call dbDiff which does the actual diffing of the database files
-	return dbDiff(dbA, dbB)
+	return dbDiff(dbA, dbB, merge)
 }
 
 // dbDiff generates the differences between the two database files in dbA and dbD
-func dbDiff(dbA string, dbB string) (Diffs, error) {
+func dbDiff(dbA string, dbB string, merge MergeStrategy) (Diffs, error) {
 	var diff Diffs
 
 	// Check if this is the same database and exit early
@@ -122,7 +130,7 @@ func dbDiff(dbA string, dbB string) (Diffs, error) {
 	err = stmt.Select(func(s *sqlite.Stmt) error {
 		objectName, _ := s.ScanText(0)
 		objectType, _ := s.ScanText(1)
-		changed, objectDiff, err := diffSingleObject(sdb, objectName, objectType)
+		changed, objectDiff, err := diffSingleObject(sdb, objectName, objectType, merge)
 		if err != nil {
 			return err
 		}
@@ -144,7 +152,7 @@ func dbDiff(dbA string, dbB string) (Diffs, error) {
 
 // diffSingleObject compares the object with name objectName and of type objectType in the main and aux schemata of the connection sdb
 // and returns three values: a boolean to indicate whether there are differences, a DiffObjectChangeset object containing all the differences, and an optional error object
-func diffSingleObject(sdb *sqlite.Conn, objectName string, objectType string) (bool, DiffObjectChangeset, error) {
+func diffSingleObject(sdb *sqlite.Conn, objectName string, objectType string, merge MergeStrategy) (bool, DiffObjectChangeset, error) {
 	// Prepare diff object to return
 	var diff DiffObjectChangeset
 	diff.ObjectName = objectName
@@ -164,7 +172,9 @@ func diffSingleObject(sdb *sqlite.Conn, objectName string, objectType string) (b
 	// Check for dropped object
 	if sqlInMain != "" && sqlInAux == "" {
 		diff.Schema.ActionType = ACTION_DELETE
-		diff.Schema.Sql = "DROP " + strings.ToUpper(objectType) + " " + EscapeId(objectName) + ";"
+		if merge != NoMerge {
+			diff.Schema.Sql = "DROP " + strings.ToUpper(objectType) + " " + EscapeId(objectName) + ";"
+		}
 
 		// If this is a table, also add all the deleted data to the diff
 		if objectType == "table" {
@@ -182,11 +192,13 @@ func diffSingleObject(sdb *sqlite.Conn, objectName string, objectType string) (b
 	// Check for added object
 	if sqlInMain == "" && sqlInAux != "" {
 		diff.Schema.ActionType = ACTION_ADD
-		diff.Schema.Sql = sqlInAux + ";"
+		if merge != NoMerge {
+			diff.Schema.Sql = sqlInAux + ";"
+		}
 
 		// If this is a table, also add all the added data to the diff
 		if objectType == "table" {
-			diff.Data, err = dataDiffForAllTableRows(sdb, "aux", objectName, ACTION_ADD, true)
+			diff.Data, err = dataDiffForAllTableRows(sdb, "aux", objectName, ACTION_ADD, merge != NoMerge)
 			if err != nil {
 				return false, DiffObjectChangeset{}, err
 			}
@@ -199,7 +211,9 @@ func diffSingleObject(sdb *sqlite.Conn, objectName string, objectType string) (b
 	// Check for modified object
 	if sqlInMain != "" && sqlInAux != "" && sqlInMain != sqlInAux {
 		diff.Schema.ActionType = ACTION_MODIFY
-		diff.Schema.Sql = "DROP " + strings.ToUpper(objectType) + " " + EscapeId(objectName) + ";" + sqlInAux + ";"
+		if merge != NoMerge {
+			diff.Schema.Sql = "DROP " + strings.ToUpper(objectType) + " " + EscapeId(objectName) + ";" + sqlInAux + ";"
+		}
 
 		// TODO If this is a table, be more clever and try to get away with ALTER TABLE instead of DROP and CREATE
 
@@ -209,7 +223,7 @@ func diffSingleObject(sdb *sqlite.Conn, objectName string, objectType string) (b
 			if err != nil {
 				return false, DiffObjectChangeset{}, err
 			}
-			add_data, err := dataDiffForAllTableRows(sdb, "aux", objectName, ACTION_ADD, true)
+			add_data, err := dataDiffForAllTableRows(sdb, "aux", objectName, ACTION_ADD, merge != NoMerge)
 			if err != nil {
 				return false, DiffObjectChangeset{}, err
 			}