data.go

package main

import (
	"fmt"
	"log"
	"strings"
	"time"
)

func findInSet(opt string, options []string) bool {
	for _, it := range options {
		if opt == strings.TrimSpace(it) {
			return true
		}
	}
	return false
}

func containsInSet(opt string, options []string) bool {
	for _, it := range options {
		if strings.Contains(opt, strings.TrimSpace(it)) {
			return true
		}
	}
	return false
}

func generateSQL(opt string, mapList map[string][]*DiffRow, out *Output) {
	if len(mapList) > 0 {
		out.Printf("\n# ********************************* %s SQL ********************************* #\n", strings.ToUpper(opt))
	}

	for table := range mapList {
		out.Printf("\n-- ------------------------------- %s ------------------------------- --\n", table)
		for _, d := range mapList[table] {
			out.Println(d.GenerateSQL(d.table))
		}
	}
}

// DataDiff ...
func DataDiff(srcDB, dstDB *DB, conf *Config) bool {
	var isUpdate bool

	out := &Output{}
	if err := out.Init(conf.Output); err != nil {
		log.Fatal(err, conf.Output)
	}
	defer func() {
		out.Close(isUpdate)
	}()

	out.Printf("-- Create Date : %s\n", time.Now())
	out.Printf("\nSET FOREIGN_KEY_CHECKS = 0;\n")

	// diff data
	// get table list.
	tableList, err := srcDB.GetObjectList(TABLE, conf.Include, conf.Exclude)
	if err != nil {
		log.Fatal(err)
	}

	// check target db.
	updateList := make(map[string][]*DiffRow)
	insertList := make(map[string][]*DiffRow)
	deleteList := make(map[string][]*DiffRow)

	for _, t := range tableList {
		log.Printf("start compare table %s ...", t)
		// check target db.
		srcTable := srcDB.GetTableInfo(t)
		if srcTable == nil {
			log.Fatal("load table info error", err)
		}
		// check primary key.
		if _, ok := srcTable.Indexs["PRIMARY"]; !ok {
			log.Println("not exist primary key", t)
			continue
		}

		dstTable := dstDB.GetTableInfo(t)
		if srcTable == nil {
			log.Fatal("load table info error", err)
		}

		if dd := srcTable.compare(dstTable); dd != "" {
			log.Fatal("table desc is different!", t, dd)
		}

		query := fmt.Sprintf("SELECT * FROM %s", t)
		// load src db rows
		srcData, err := srcDB.GetData(t, query, srcTable.Cols)
		if err != nil {
			log.Fatal(err)
		}

		// load dst db rows
		dstData, err := dstDB.GetData(t, query, dstTable.Cols)
		if err != nil {
			log.Fatal(err)
		}

		// Compare data...
		result := CompareRows(t, srcData, dstData, srcTable.GetPrimaryKey(), strings.Split(conf.IgnoreColumn, ","))
		if len(result) > 0 {
			for _, d := range result {
				switch d.Compare {
				case INSERT:
					insertList[t] = append(insertList[t], d)
					break
				case UPDATE:
					updateList[t] = append(updateList[t], d)
					break
				case DELETE:
					deleteList[t] = append(deleteList[t], d)
					break
				}
				// out.Println(d.GenerateSQL(t))
				isUpdate = true
			}
		}

		log.Printf("finish compare table %s ... count=%d\n", t, len(result))
	}

	options := strings.Split(conf.Options, ",")
	// group by update/insert/delete
	if findInSet("update", options) {
		generateSQL("update", updateList, out)
	}

	if findInSet("insert", options) {
		generateSQL("insert", insertList, out)
	}

	if findInSet("delete", options) {
		generateSQL("delete", deleteList, out)
	}

	out.Printf("\nSET FOREIGN_KEY_CHECKS = 1;\n")
	return isUpdate
}