First commit... of many

Author: joncrlsn

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jon Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,4 +1,28 @@
-pgdiff
-======
+# pgdiff - PostgreSQL schema diff
 
-Compares the postgres schema between two databases and generates SQL.  This is still a work in progress. 
+Written in GoLang, this utility compares the schema between two PostgreSQL databases and generates alter statements to be run against the second database.  Not everything in the schema is compared, but the thinngs I considered important are: tables, columns (and their default values), foreign keys, and (soon) constraints and user roles. 
+
+It is written to be easy to add and improve the accuracy of the comparison.  Please let me know if you think this goal has not been met.  I'm very interested in suggestions and contributions to improve this program.  I'm not a GoLang expert yet, but each program I write gets me closer to that goal.
+
+I'm a big fan of GoLang because of how easy it is to deliver a single executable on almost any platform.  But, just as important I love the design choices and the concurrency features which I've only begun to delve into.  Streaming objects back (via a channel) from a method one by one is far better than returning a potentially massive list of objects.
+
+A couple of binaries to save you the effort:
+[Mac](https://github.com/joncrlsn/pgdiff/raw/master/bin-osx/pgdiff "OSX version")
+
+## usage
+
+	pgdiff [database flags] 
+
+
+ program flags | Explanation 
+-------------: | ------------------------------------
+  -U1          | first db postgres user
+  -pw1         | first db password
+  -h1          | first db host -- default is localhost
+  -p1          | first db port number.  defaults to 5432
+  -d1          | first db name
+  -U2          | second db postgres user
+  -pw2         | second db password
+  -h2          | second db host -- default is localhost
+  -p2          | second db port number.  defaults to 5432
+  -d2          | second db name

column.go

@@ -0,0 +1,87 @@
+package main
+
+import "fmt"
+
+type ColumnSchema struct {
+	channel chan map[string]string
+	row     map[string]string
+}
+
+// Reads from the channel and converts the end-of-channel value into a boolean
+func (c *ColumnSchema) NextRow(more bool) bool {
+	c.row = <-c.channel
+	if !more || len(c.row) == 0 {
+       return false
+	}
+	return true
+}
+
+// Compare
+func (c ColumnSchema) Compare(obj interface{}) int {
+	c2, ok := obj.(*ColumnSchema)
+	if !ok {
+		fmt.Println("Error!!!, change needs a ColumnSchema instance", c2)
+	}
+
+	val := _compareString(c.row["table_name"], c2.row["table_name"])
+	if val != 0 {
+		// Table name differed so return that value
+		return val
+	}
+
+	// Table name was the same so compare column name
+	val = _compareString(c.row["column_name"], c2.row["column_name"])
+	return val
+}
+
+// Return SQL to add the column
+func (c ColumnSchema) Add() {
+	if c.row["data_type"] == "character varying" {
+		fmt.Printf("ALTER TABLE %s ADD COLUMN %s %s(%s)", c.row["table_name"], c.row["column_name"], c.row["data_type"], c.row["character_maximum_length"])
+	} else {
+		fmt.Printf("ALTER TABLE %s ADD COLUMN %s %s", c.row["table_name"], c.row["column_name"], c.row["data_type"])
+	}
+
+	if c.row["is_nullable"] == "NO" {
+		fmt.Printf(" NOT NULL")
+	}
+	if c.row["column_default"] != "null" {
+		fmt.Printf(" DEFAULT %s", c.row["column_default"])
+	}
+	fmt.Printf(";\n")
+}
+
+// Return SQL to drop the column
+func (c ColumnSchema) Drop() {
+	// if dropping column
+    fmt.Printf("ALTER TABLE %s DROP COLUMN %s;\n", c.row["table_name"], c.row["column_name"])
+}
+
+// Handle the case where the table and column match, but the details do not
+func (c ColumnSchema) Change(obj interface{}) {
+	c2, ok := obj.(*ColumnSchema)
+	if !ok {
+		fmt.Println("Error!!!, change needs a ColumnSchema instance", c2)
+	}
+//    fmt.Printf("Changes? ")
+//	// if changing type
+//	if c.row["data_type"] == "character varying" {
+//		// varchar needs a length specified
+//		fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE %s(%s);\n", c.row["table_name"], c.row["column_name"], c.row["data_type"], c.row["character_maximum_length"])
+//	} else {
+//		fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE %s;\n", c.row["table_name"], c.row["column_name"], c.row["data_type"])
+//	}
+//
+//	// if changing/adding default value
+//	fmt.Printf("ALTER TABLE %s ALTER COLUMN %s SET DEFAULT %s;\n", c.row["table_name"], c.row["column_name"], c.row["column_default"])
+//
+//	// if dropping default value
+//	fmt.Printf("ALTER TABLE %s ALTER COLUMN %s DROP DEFAULT;\n", c.row["table_name"], c.row["column_name"])
+//
+//	// if adding not null
+//	fmt.Printf("ALTER TABLE %s ALTER COLUMN %s SET NOT NULL;\n", c.row["table_name"], c.row["column_name"])
+//
+//	// if dropping not null
+//	fmt.Printf("ALTER TABLE %s ALTER COLUMN %s DROP NOT NULL;\n", c.row["table_name"], c.row["column_name"])
+//	return "Change"
+}

flags.go

@@ -0,0 +1,30 @@
+package main
+
+import "flag"
+import "github.com/joncrlsn/pgutil"
+
+func ParseFlags() (pgutil.DbInfo, pgutil.DbInfo) {
+
+    var dbUser1 = flag.String("U1", "", "db user")
+    var dbPass1 = flag.String("pw1", "", "db password")
+    var dbHost1 = flag.String("h1", "localhost", "db host")
+    var dbPort1 = flag.Int("p1", 5432, "db port")
+    var dbName1 = flag.String("d1", "", "db name")
+    var dbOptions1 = flag.String("o1", "", "db options (eg. sslmode=disable)")
+   
+    var dbUser2 = flag.String("U2", "", "db user")
+    var dbPass2 = flag.String("pw2", "", "db password")
+    var dbHost2 = flag.String("h2", "localhost", "db host")
+    var dbPort2 = flag.Int("p2", 5432, "db port")
+    var dbName2 = flag.String("d2", "", "db name")
+    var dbOptions2 = flag.String("o2", "", "db options (eg. sslmode=disable)")
+
+    flag.Parse()
+
+    dbInfo1 := pgutil.DbInfo{DbName:*dbName1, DbHost:*dbHost1, DbPort:int32(*dbPort1), DbUser:*dbUser1, DbPass:*dbPass1, DbOptions:*dbOptions1}
+
+    dbInfo2 := pgutil.DbInfo{DbName:*dbName2, DbHost:*dbHost2, DbPort:int32(*dbPort2), DbUser:*dbUser2, DbPass:*dbPass2, DbOptions:*dbOptions2}
+
+    return dbInfo1, dbInfo2
+}
+

foreignkey.go

@@ -0,0 +1,56 @@
+package main
+
+import "fmt"
+
+type ForeignKeySchema struct {
+	channel chan map[string]string
+	row     map[string]string
+}
+
+// Reads from the channel and converts the end-of-channel value into a boolean
+func (c *ForeignKeySchema) NextRow(more bool) bool {
+	c.row = <-c.channel
+    //fmt.Println("Found ", c.row["table_name"])
+
+	if !more || len(c.row) == 0 {
+		return false
+	}
+	return true
+}
+
+// Compare
+func (c *ForeignKeySchema) Compare(obj interface{}) int {
+	c2, ok := obj.(*ForeignKeySchema)
+	if !ok {
+		fmt.Println("Error!!!, Change(...) needs a ForeignKeySchema instance", c2)
+        return +999
+	}
+
+	//fmt.Printf("Comparing %s with %s", c.row["table_name"], c2.row["table_name"])
+	val := _compareString(c.row["table_name"], c2.row["table_name"])
+    if val != 0 {
+        return val
+    }
+
+	val = _compareString(c.row["constraint_name"], c2.row["constraint_name"])
+	return val
+}
+
+// Return SQL to add the table
+func (c ForeignKeySchema) Add() {
+	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY(%s) REFERENCES %s(%s);\n", c.row["table_name"], c.row["constraint_name"], c.row["column_name"], c.row["foreign_table_name"], c.row["foreign_column_name"], )
+}
+
+// Return SQL to drop the table
+func (c ForeignKeySchema) Drop() {
+    fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s;\n", c.row["table_name"], c.row["constraint_name"])
+}
+
+// Handle the case where the table and column match, but the details do not
+func (c ForeignKeySchema) Change(obj interface{}) {
+	c2, ok := obj.(*ForeignKeySchema)
+	if !ok {
+		fmt.Println("Error!!!, change needs a ForeignKeySchema instance", c2)
+	}
+    //fmt.Printf("Change Table? %s - %s\n", c.row["table_name"], c2.row["table_name"])
+}