Work In Progress: Adding the ability to compare two different schemas in the same database

Former-commit-id: 07d956e

Author: joncrlsn

.gitignore

@@ -0,0 +1,4 @@
+bin-linux
+bin-win
+bin-osx
+pgdiff

README.md

@@ -58,12 +58,14 @@ options           | explanation
   -u, --user2     | second postgres user
   -W, --password1 | first db password
   -w, --password2 | second db password
-  -H, --host1     | first db host. default is localhost
+  -H, --host1     | first db host.  default is localhost
   -h, --host2     | second db host. default is localhost
-  -P, --port1     | first db port number. default is 5432
+  -P, --port1     | first db port number.  default is 5432
   -p, --port2     | second db port number. default is 5432
   -D, --dbname1   | first db name
   -d, --dbname2   | second db name
+  -S, --schema1   | first schema name.  default is public
+  -s, --schema2   | second schema name. default is public
   -O, --option1   | first db options. example: sslmode=disable
   -o, --option2   | second db options. example: sslmode=disable
 
@@ -92,8 +94,7 @@ linux and osx binaries are packaged with an extra, optional bash script and pgru
 1. 0.9.0 - Implemented ROLE, SEQUENCE, TABLE, COLUMN, INDEX, FOREIGN\_KEY, OWNER, GRANT\_RELATIONSHIP, GRANT\_ATTRIBUTE
 1. 0.9.1 - Added VIEW, FUNCTION, and TRIGGER (Thank you, Shawn Carroll AKA SparkeyG)
 1. 0.9.2 - Fixed bug when using the non-default port
-1. 0.9.3 - Added support for schemas other than public. Fixed VARCHAR bug when no max length
-   specified
+1. 0.9.3 - Added support for schemas other than public. Fixed VARCHAR bug when no max length specified
 
 
 ### todo

column.go

@@ -6,13 +6,48 @@
 
 package main
 
-import "sort"
-import "fmt"
-import "strconv"
-import "strings"
-import "database/sql"
-import "github.com/joncrlsn/pgutil"
-import "github.com/joncrlsn/misc"
+import (
+"sort"
+"fmt"
+"strconv"
+"strings"
+"database/sql"
+"github.com/joncrlsn/pgutil"
+"github.com/joncrlsn/misc"
+"text/template"
+"bytes"
+)
+
+var (
+	columnSqlTemplate = initColumnSqlTemplate()
+)
+
+// Initializes the Sql template
+func initColumnSqlTemplate() *template.Template {
+	sql := `
+SELECT table_schema
+    , {{if eq $.DbSchema "*" }}table_schema || '.' || {{end}}table_name AS compare_name
+	, table_name
+    , column_name
+    , data_type
+    , is_nullable
+    , column_default
+    , character_maximum_length
+FROM information_schema.columns 
+WHERE is_updatable = 'YES'
+{{if eq $.DbSchema "*" }}
+AND table_schema NOT LIKE 'pg_%' 
+AND table_schema <> 'information_schema' 
+{{else}}
+AND table_schema = '{{$.DbSchema}}'
+{{end}}
+ORDER BY compare_name, column_name;
+`
+	t := template.New("ColumnSqlTmpl")
+	template.Must(t.Parse(sql))
+	return t
+}
+
 
 // ==================================
 // Column Rows definition
@@ -26,8 +61,8 @@ func (slice ColumnRows) Len() int {
 }
 
 func (slice ColumnRows) Less(i, j int) bool {
-	if slice[i]["table_name"] != slice[j]["table_name"] {
-		return slice[i]["table_name"] < slice[j]["table_name"]
+	if slice[i]["compare_name"] != slice[j]["compare_name"] {
+		return slice[i]["column_name"] < slice[j]["compare_name"]
 	}
 	return slice[i]["column_name"] < slice[j]["column_name"]
 }
@@ -73,7 +108,7 @@ func (c *ColumnSchema) Compare(obj interface{}) int {
 		fmt.Println("Error!!!, Compare needs a ColumnSchema instance", c2)
 	}
 
-	val := misc.CompareStrings(c.get("table_name"), c2.get("table_name"))
+	val := misc.CompareStrings(c.get("compare_name"), c2.get("compare_name"))
 	if val != 0 {
 		// Table name differed so return that value
 		return val
@@ -85,19 +120,24 @@ func (c *ColumnSchema) Compare(obj interface{}) int {
 }
 
 // Add prints SQL to add the column
-func (c *ColumnSchema) Add() {
+func (c *ColumnSchema) Add(obj interface{}) {
+	c2, ok := obj.(*ColumnSchema)
+	if !ok {
+		fmt.Println("Error!!!, ColumnSchema.Add(obj) needs a ColumnSchema instance", c2)
+	}
+
 	if c.get("data_type") == "character varying" {
 		maxLength, valid := getMaxLength(c.get("character_maximum_length"))
 		if !valid {
-		    fmt.Printf("ALTER TABLE %s ADD COLUMN %s character varying", c.get("table_name"), c.get("column_name"))
+			fmt.Printf("ALTER TABLE %s.%s ADD COLUMN %s character varying", c2.get("table_schema"), c.get("table_name"), c.get("column_name"))
 		} else {
-			fmt.Printf("ALTER TABLE %s ADD COLUMN %s character varying(%s)", c.get("table_name"), c.get("column_name"), maxLength)
+			fmt.Printf("ALTER TABLE %s.%s ADD COLUMN %s character varying(%s)", c2.get("table_schema"), c.get("table_name"), c.get("column_name"), maxLength)
 		}
 	} else {
 		if c.get("data_type") == "ARRAY" {
 			fmt.Println("-- Note that adding of array data types are not yet generated properly.")
 		}
-		fmt.Printf("ALTER TABLE %s ADD COLUMN %s %s", c.get("table_name"), c.get("column_name"), c.get("data_type"))
+		fmt.Printf("ALTER TABLE %s.%s ADD COLUMN %s %s", c2.get("table_schema"), c.get("table_name"), c.get("column_name"), c.get("data_type"))
 	}
 
 	if c.get("is_nullable") == "NO" {
@@ -110,9 +150,13 @@ func (c *ColumnSchema) Add() {
 }
 
 // Drop prints SQL to drop the column
-func (c *ColumnSchema) Drop() {
+func (c *ColumnSchema) Drop(obj interface{}) {
+	c2, ok := obj.(*ColumnSchema)
+	if !ok {
+		fmt.Println("Error!!!, ColumnSchema.Drop(obj) needs a ColumnSchema instance", c2)
+	}
 	// if dropping column
-	fmt.Printf("ALTER TABLE %s DROP COLUMN IF EXISTS %s;\n", c.get("table_name"), c.get("column_name"))
+	fmt.Printf("ALTER TABLE %s.%s DROP COLUMN IF EXISTS %s;\n", c2.get("table_schema"), c2.get("table_name"), c2.get("column_name"))
 }
 
 // Change handles the case where the table and column match, but the details do not
@@ -122,7 +166,7 @@ func (c *ColumnSchema) Change(obj interface{}) {
 		fmt.Println("Error!!!, ColumnSchema.Change(obj) needs a ColumnSchema instance", c2)
 	}
 
-	// Detect column type change (mostly varchar length, or number size increase) 
+	// Detect column type change (mostly varchar length, or number size increase)
 	// (integer to/from bigint is OK)
 	if c.get("data_type") == c2.get("data_type") {
 		if c.get("data_type") == "character varying" {
@@ -141,8 +185,8 @@ func (c *ColumnSchema) Change(obj interface{}) {
 				if max1Int < max2Int {
 					fmt.Println("-- WARNING: The next statement will shorten a character varying column, which may result in data loss.")
 				}
-				fmt.Printf("-- max1Valid: %v  max2Valid: %v ", max1Valid, max2Valid)
-				fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE character varying(%s);\n", c.get("table_name"), c.get("column_name"), max1)
+				fmt.Printf("-- max1Valid: %v  max2Valid: %v \n", max1Valid, max2Valid)
+				fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s TYPE character varying(%s);\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"), max1)
 			}
 		}
 	}
@@ -155,27 +199,27 @@ func (c *ColumnSchema) Change(obj interface{}) {
 			if !max1Valid {
 				fmt.Println("-- WARNING: varchar column has no maximum length.  Setting to 1024")
 			}
-			fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE %s(%s);\n", c.get("table_name"), c.get("column_name"), c.get("data_type"), max1)
+			fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s TYPE %s(%s);\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"), c.get("data_type"), max1)
 		} else {
-			fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE %s;\n", c.get("table_name"), c.get("column_name"), c.get("data_type"))
+			fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s TYPE %s;\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"), c.get("data_type"))
 		}
 	}
 
 	// Detect column default change (or added, dropped)
 	if c.get("column_default") == "null" {
 		if c.get("column_default") != "null" {
-			fmt.Printf("ALTER TABLE %s ALTER COLUMN %s DROP DEFAULT;\n", c.get("table_name"), c.get("column_name"))
+			fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s DROP DEFAULT;\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"))
 		}
 	} else if c.get("column_default") != c2.get("column_default") {
-		fmt.Printf("ALTER TABLE %s ALTER COLUMN %s SET DEFAULT %s;\n", c.get("table_name"), c.get("column_name"), c.get("column_default"))
+		fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s SET DEFAULT %s;\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"), c.get("column_default"))
 	}
 
 	// Detect not-null and nullable change
 	if c.get("is_nullable") != c2.get("is_nullable") {
 		if c.get("is_nullable") == "YES" {
-			fmt.Printf("ALTER TABLE %s ALTER COLUMN %s DROP NOT NULL;\n", c.get("table_name"), c.get("column_name"))
+			fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s DROP NOT NULL;\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"))
 		} else {
-			fmt.Printf("ALTER TABLE %s ALTER COLUMN %s SET NOT NULL;\n", c.get("table_name"), c.get("column_name"))
+			fmt.Printf("ALTER TABLE %s.%s ALTER COLUMN %s SET NOT NULL;\n", c2.get("table_schema"), c.get("table_name"), c.get("column_name"))
 		}
 	}
 }
@@ -188,21 +232,15 @@ func (c *ColumnSchema) Change(obj interface{}) {
  * Compare the columns in the two databases
  */
 func compareColumns(conn1 *sql.DB, conn2 *sql.DB) {
-	sql := `
-SELECT table_schema || '.' || table_name AS table_name
-    , column_name
-    , data_type
-    , is_nullable
-    , column_default
-    , character_maximum_length
-FROM information_schema.columns 
-WHERE table_schema NOT LIKE 'pg_%'
-  AND table_schema <> 'information_schema'
-  AND is_updatable = 'YES'
-ORDER BY table_name, column_name;`
+	
+	buf1 := new(bytes.Buffer)
+	columnSqlTemplate.Execute(buf1, dbInfo1)
 
-	rowChan1, _ := pgutil.QueryStrings(conn1, sql)
-	rowChan2, _ := pgutil.QueryStrings(conn2, sql)
+	buf2 := new(bytes.Buffer)
+	columnSqlTemplate.Execute(buf2, dbInfo2)
+
+	rowChan1, _ := pgutil.QueryStrings(conn1, buf1.String())
+	rowChan2, _ := pgutil.QueryStrings(conn2, buf2.String())
 
 	//rows1 := make([]map[string]string, 500)
 	rows1 := make(ColumnRows, 0)
@@ -218,6 +256,15 @@ ORDER BY table_name, column_name;`
 	}
 	sort.Sort(&rows2)
 
+    //for _, val := range rows1 {
+		//fmt.Println("list1: ", val["table_schema"], val["compare_name"], val["column_name"], val["character_maximum_length"] )
+	//}
+	//fmt.Println()
+
+    //for _, val := range rows2 {
+		//fmt.Println("list2: ", val["table_schema"], val["compare_name"], val["column_name"], val["character_maximum_length"])
+	//}
+
 	// We have to explicitly type this as Schema here for some unknown reason
 	var schema1 Schema = &ColumnSchema{rows: rows1, rowNum: -1}
 	var schema2 Schema = &ColumnSchema{rows: rows2, rowNum: -1}

flags.go

@@ -18,20 +18,22 @@ func parseFlags() (pgutil.DbInfo, pgutil.DbInfo) {
 	var dbHost1 = flag.StringP("host1", "H", "localhost", "db host")
 	var dbPort1 = flag.IntP("port1", "P", 5432, "db port")
 	var dbName1 = flag.StringP("dbname1", "D", "", "db name")
+	var dbSchema1 = flag.StringP("schema1", "S", "public", "schema name or * for all schemas")
 	var dbOptions1 = flag.StringP("options1", "O", "", "db options (eg. sslmode=disable)")
 
 	var dbUser2 = flag.StringP("user2", "u", "", "db user")
 	var dbPass2 = flag.StringP("password2", "w", "", "db password")
 	var dbHost2 = flag.StringP("host2", "h", "localhost", "db host")
 	var dbPort2 = flag.IntP("port2", "p", 5432, "db port")
 	var dbName2 = flag.StringP("dbname2", "d", "", "db name")
+	var dbSchema2 = flag.StringP("schema2", "s", "public", "schema name or * for all schemas")
 	var dbOptions2 = flag.StringP("options2", "o", "", "db options (eg. sslmode=disable)")
 
 	flag.Parse()
 
-	dbInfo1 := pgutil.DbInfo{DbName: *dbName1, DbHost: *dbHost1, DbPort: int32(*dbPort1), DbUser: *dbUser1, DbPass: *dbPass1, DbOptions: *dbOptions1}
+	dbInfo1 := pgutil.DbInfo{DbName: *dbName1, DbHost: *dbHost1, DbPort: int32(*dbPort1), DbUser: *dbUser1, DbPass: *dbPass1, DbSchema: *dbSchema1, DbOptions: *dbOptions1}
 
-	dbInfo2 := pgutil.DbInfo{DbName: *dbName2, DbHost: *dbHost2, DbPort: int32(*dbPort2), DbUser: *dbUser2, DbPass: *dbPass2, DbOptions: *dbOptions2}
+	dbInfo2 := pgutil.DbInfo{DbName: *dbName2, DbHost: *dbHost2, DbPort: int32(*dbPort2), DbUser: *dbUser2, DbPass: *dbPass2, DbSchema: *dbSchema2, DbOptions: *dbOptions2}
 
 	return dbInfo1, dbInfo2
 }

foreignkey.go

@@ -90,20 +90,28 @@ func (c *ForeignKeySchema) Compare(obj interface{}) int {
 }
 
 // Add returns SQL to add the foreign key
-func (c *ForeignKeySchema) Add() {
+func (c *ForeignKeySchema) Add(obj interface{}) {
+	c2, ok := obj.(*ForeignKeySchema)
+	if !ok {
+		fmt.Println("Error!!!, ForeignKeySchema.Add(obj) needs a ForeignKeySchema instance", c2)
+	}
 	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s %s;\n", c.get("table_name"), c.get("fk_name"), c.get("constraint_def"))
 }
 
 // Drop returns SQL to drop the foreign key
-func (c ForeignKeySchema) Drop() {
+func (c ForeignKeySchema) Drop(obj interface{}) {
+	c2, ok := obj.(*ForeignKeySchema)
+	if !ok {
+		fmt.Println("Error!!!, ForeignKeySchema.Drop(obj) needs a ForeignKeySchema instance", c2)
+	}
 	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s; -- %s\n", c.get("table_name"), c.get("fk_name"), c.get("constraint_def"))
 }
 
 // Change handles the case where the table and foreign key name, but the details do not
 func (c *ForeignKeySchema) Change(obj interface{}) {
 	c2, ok := obj.(*ForeignKeySchema)
 	if !ok {
-		fmt.Println("Error!!!, Change(obj) needs a ForeignKeySchema instance", c2)
+		fmt.Println("Error!!!, ForeignKeySchema.Change(obj) needs a ForeignKeySchema instance", c2)
 	}
 	// There is no "changing" a foreign key.  It either gets created or dropped (or left as-is).
 }

function.go

@@ -72,14 +72,22 @@ func (c *FunctionSchema) Compare(obj interface{}) int {
 }
 
 // Add returns SQL to create the function
-func (c FunctionSchema) Add() {
+func (c FunctionSchema) Add(obj interface{}) {
+	c2, ok := obj.(*FunctionSchema)
+	if !ok {
+		fmt.Println("Error!!!, FunctionSchema.Add needs a FunctionSchema instance", c2)
+	}
 	fmt.Println("-- STATEMENT-BEGIN")
 	fmt.Println(c.get("definition"))
 	fmt.Println("-- STATEMENT-END")
 }
 
 // Drop returns SQL to drop the function
-func (c FunctionSchema) Drop() {
+func (c FunctionSchema) Drop(obj interface{}) {
+	c2, ok := obj.(*FunctionSchema)
+	if !ok {
+		fmt.Println("Error!!!, FunctionSchema.Drop needs a FunctionSchema instance", c2)
+	}
 	fmt.Println("-- Note that CASCADE in the statement below will also drop any triggers depending on this function.")
 	fmt.Println("-- Also, if there are two functions with this name, you will need to add arguments to identify the correct one to drop.")
 	fmt.Println("-- (See http://www.postgresql.org/docs/9.4/interactive/sql-dropfunction.html) ")

grant-attribute.go

@@ -119,13 +119,23 @@ func (c *GrantAttributeSchema) Compare(obj interface{}) int {
 }
 
 // Add prints SQL to add the column
-func (c *GrantAttributeSchema) Add() {
+func (c *GrantAttributeSchema) Add(obj interface{}) {
+	c2, ok := obj.(*GrantAttributeSchema)
+	if !ok {
+		fmt.Println("-- Error!!!, Add needs a GrantAttributeSchema instance", c2)
+	}
+
 	role, grants := parseGrants(c.get("attribute_acl"))
 	fmt.Printf("GRANT %s (%s) ON %s TO %s; -- Add\n", strings.Join(grants, ", "), c.get("attribute_name"), c.get("relationship_name"), role)
 }
 
 // Drop prints SQL to drop the column
-func (c *GrantAttributeSchema) Drop() {
+func (c *GrantAttributeSchema) Drop(obj interface{}) {
+	c2, ok := obj.(*GrantAttributeSchema)
+	if !ok {
+		fmt.Println("-- Error!!!, Drop needs a GrantAttributeSchema instance", c2)
+	}
+
 	role, grants := parseGrants(c.get("attribute_acl"))
 	fmt.Printf("REVOKE %s (%s) ON %s FROM %s; -- Drop\n", strings.Join(grants, ", "), c.get("attribute_name"), c.get("relationship_name"), role)
 }

grant-relationship.go

@@ -112,13 +112,23 @@ func (c *GrantRelationshipSchema) Compare(obj interface{}) int {
 }
 
 // Add prints SQL to add the column
-func (c *GrantRelationshipSchema) Add() {
+func (c *GrantRelationshipSchema) Add(obj interface{}) {
+	c2, ok := obj.(*GrantRelationshipSchema)
+	if !ok {
+		fmt.Println("-- Error!!!, Add needs a GrantRelationshipSchema instance", c2)
+	}
+
 	role, grants := parseGrants(c.get("relationship_acl"))
 	fmt.Printf("GRANT %s ON %s TO %s; -- Add\n", strings.Join(grants, ", "), c.get("relationship_name"), role)
 }
 
 // Drop prints SQL to drop the column
-func (c *GrantRelationshipSchema) Drop() {
+func (c *GrantRelationshipSchema) Drop(obj interface{}) {
+	c2, ok := obj.(*GrantRelationshipSchema)
+	if !ok {
+		fmt.Println("-- Error!!!, Drop needs a GrantRelationshipSchema instance", c2)
+	}
+
 	role, grants := parseGrants(c.get("relationship_acl"))
 	fmt.Printf("REVOKE %s ON %s FROM %s; -- Drop\n", strings.Join(grants, ", "), c.get("relationship_name"), role)
 }
@@ -127,7 +137,7 @@ func (c *GrantRelationshipSchema) Drop() {
 func (c *GrantRelationshipSchema) Change(obj interface{}) {
 	c2, ok := obj.(*GrantRelationshipSchema)
 	if !ok {
-		fmt.Println("-- Error!!!, change needs a GrantRelationshipSchema instance", c2)
+		fmt.Println("-- Error!!!, Change needs a GrantRelationshipSchema instance", c2)
 	}
 
 	role, grants1 := parseGrants(c.get("relationship_acl"))