Simplified and improved the constraints queries (primary key, unique constraint, foreign key)

Author: joncrlsn

column.go

@@ -2,6 +2,7 @@ package main
 
 import "fmt"
 import "strconv"
+import "strings"
 import "database/sql"
 import "github.com/joncrlsn/pgutil"
 
@@ -45,10 +46,9 @@ func (c ColumnSchema) Compare(obj interface{}) int {
 // Add returns SQL to add the column
 func (c ColumnSchema) Add() {
 	if c.row["data_type"] == "character varying" {
-		maxLength := c.row["character_maximum_length"]
-		if maxLength == "null" {
-			fmt.Println("-- WARNING: varchar column has no maximum length.  Setting to 1024")
-			maxLength = "1024"
+		maxLength, valid := getMaxLength(c.row["character_maximum_length"])
+		if !valid {
+			fmt.Println("-- WARNING: varchar column has no maximum length.  Set to 1024")
 		}
 		fmt.Printf("ALTER TABLE %s ADD COLUMN %s %s(%s)", c.row["table_name"], c.row["column_name"], c.row["data_type"], maxLength)
 	} else {
@@ -80,32 +80,36 @@ func (c ColumnSchema) Change(obj interface{}) {
 	// Detect column type change (mostly varchar length, or number size increase)  (integer to/from bigint is OK)
 	if c.row["data_type"] == c2.row["data_type"] {
 		if c.row["data_type"] == "character varying" {
-			if c.row["character_maximum_length"] != c2.row["character_maximum_length"] {
-				max1 := c.row["character_maximum_length"]
-				max2 := c2.row["character_maximum_length"]
-				if max1 != "null" && max2 != "null" {
-					cMax, err1 := strconv.Atoi(max1)
-					check("converting string to int", err1)
-					c2Max, err2 := strconv.Atoi(max2)
-					check("converting string to int", err2)
-					if cMax < c2Max {
-						fmt.Println("-- WARNING: The next statement will shorten a character varying column.")
-					}
-				}
-				maxLength := c.row["character_maximum_length"]
-				if maxLength == "null" {
+			max1, max1Valid := getMaxLength(c.row["character_maximum_length"])
+			max2, max2Valid := getMaxLength(c2.row["character_maximum_length"])
+			if (max1Valid || !max2Valid) && (max1 != c2.row["character_maximum_length"]) {
+				if !max1Valid {
 					fmt.Println("-- WARNING: varchar column has no maximum length.  Setting to 1024")
-					maxLength = "1024"
 				}
-				fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE character varying(%s);\n", c.row["table_name"], c.row["column_name"], maxLength)
+				max1Int, err1 := strconv.Atoi(max1)
+				check("converting string to int", err1)
+				max2Int, err2 := strconv.Atoi(max2)
+				check("converting string to int", err2)
+				if max1Int < max2Int {
+					fmt.Println("-- WARNING: The next statement will shorten a character varying column.")
+				}
+				fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE character varying(%s);\n", c.row["table_name"], c.row["column_name"], max1)
 			}
 		}
 	}
 
 	// TODO: Code and test a column change from integer to bigint
 	if c.row["data_type"] != c2.row["data_type"] {
 		fmt.Printf("-- WARNING: This type change may not work well: (%s to %s).\n", c2.row["data_type"], c.row["data_type"])
-		fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE %s;\n", c.row["table_name"], c.row["column_name"], c.row["data_type"])
+		if strings.HasPrefix(c.row["data_type"], "character") {
+			max1, max1Valid := getMaxLength(c.row["character_maximum_length"])
+			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.row["table_name"], c.row["column_name"], c.row["data_type"], max1)
+		} else {
+			fmt.Printf("ALTER TABLE %s ALTER COLUMN %s TYPE %s;\n", c.row["table_name"], c.row["column_name"], c.row["data_type"])
+		}
 	}
 
 	// Detect column default change (or added, dropped)
@@ -153,3 +157,12 @@ ORDER by table_name, column_name COLLATE "C" ASC;`
 	// Compare the columns
 	doDiff(schema1, schema2)
 }
+
+// getMaxLength returns the maximum length and whether or not it is valie
+func getMaxLength(maxLength string) (string, bool) {
+
+	if maxLength == "null" {
+		return "1024", false
+	}
+	return maxLength, true
+}

foreignkey.go

@@ -37,18 +37,18 @@ func (c *ForeignKeySchema) Compare(obj interface{}) int {
 		return val
 	}
 
-	val = _compareString(c.row["constraint_name"], c2.row["constraint_name"])
+	val = _compareString(c.row["constraint_def"], c2.row["constraint_def"])
 	return val
 }
 
 // Add returns SQL to add the foreign key
 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"])
+	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s %s;\n", c.row["table_name"], c.row["constraint_name"], c.row["constraint_def"])
 }
 
 // Drop returns SQL to drop the foreign key
 func (c ForeignKeySchema) Drop() {
-	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT IF EXISTS %s;\n", c.row["table_name"], c.row["constraint_name"])
+	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s; -- %s\n", c.row["table_name"], c.row["constraint_name"], c.row["constraint_def"])
 }
 
 // Change handles the case where the table and foreign key name, but the details do not
@@ -57,59 +57,22 @@ func (c ForeignKeySchema) Change(obj interface{}) {
 	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"])
+	// There is no "changing" a foreign key.  It either gets created or dropped (or left as-is).
 }
 
 /*
- * Compare the columns in the two databases
+ * Compare the foreign keys in the two databases.  We do not recreate foreign keys if just the name is different.
  */
 func compareForeignKeys(conn1 *sql.DB, conn2 *sql.DB) {
 	sql := `
-SELECT tc.constraint_name
-    , tc.table_name
-    , kcu.column_name
-    , ccu.table_name AS foreign_table_name
-    , ccu.column_name AS foreign_column_name
-	, rc.delete_rule AS on_delete
-	, rc.update_rule AS on_update
-FROM information_schema.table_constraints AS tc
-     JOIN information_schema.key_column_usage AS kcu
-       ON (tc.constraint_name = kcu.constraint_name)
-     JOIN information_schema.constraint_column_usage AS ccu
-       ON (ccu.constraint_name = tc.constraint_name)
-     JOIN information_schema.referential_constraints rc
-       ON (tc.constraint_catalog = rc.constraint_catalog
-      AND tc.constraint_schema = rc.constraint_schema
-      AND tc.constraint_name = rc.constraint_name)
-WHERE tc.constraint_type = 'FOREIGN KEY' 
-ORDER BY tc.table_name, tc.constraint_name COLLATE "C" ASC; 
-
-
--- Foreign Keys
---SELECT
---    con.relname AS child_table,
---    att2.attname AS child_column, 
---    cl.relname AS parent_table, 
---    att.attname AS parent_column
---FROM
---   (SELECT 
---        unnest(con1.conkey) AS parent, 
---        unnest(con1.confkey) AS child, 
---        cl.relname,
---        con1.confrelid, 
---        con1.conrelid
---    FROM pg_class AS cl
---    JOIN pg_namespace AS ns ON (cl.relnamespace = ns.oid)
---    JOIN pg_constraint AS con1 ON (con1.conrelid = cl.oid)
---    WHERE con1.contype = 'f'
---    --AND cl.relname = 't_org'
---    --AND ns.nspname = 'child_schema'
---   ) con
---JOIN pg_attribute AS att ON (att.attrelid = con.confrelid AND att.attnum = con.child)
---JOIN pg_class AS cl ON (cl.oid = con.confrelid)
---JOIN pg_attribute AS att2 ON (att2.attrelid = con.conrelid AND att2.attnum = con.parent)
---ORDER BY con.relname, att2.attname;
-
+SELECT c.conname AS constraint_name
+	, c.contype AS constraint_type
+	, cl.relname AS table_name
+	, pg_catalog.pg_get_constraintdef(c.oid, true) as constraint_def
+FROM pg_catalog.pg_constraint c
+INNER JOIN pg_class AS cl ON (c.conrelid = cl.oid)
+WHERE c.contype = 'f'
+ORDER BY cl.relname::varchar, pg_catalog.pg_get_constraintdef(c.oid, true) COLLATE "C" ASC;
 `
 
 	rowChan1, _ := pgutil.QueryStrings(conn1, sql)

index.go

@@ -52,7 +52,7 @@ func (c IndexSchema) Add() {
 
 // Drop generates SQL to drop the index
 func (c IndexSchema) Drop() {
-	fmt.Printf("DROP INDEX %s;\n", c.row["index_name"])
+	fmt.Printf("DROP INDEX %s; -- %s ON (%s)\n", c.row["index_name"], c.row["table_name"], c.row["column_names"])
 }
 
 // Change handles the case where the table and index name match, but the details do not

primarykey.go

@@ -35,19 +35,17 @@ func (c *PrimaryKeySchema) Compare(obj interface{}) int {
 		return val
 	}
 
-	return _compareString(c.row["constraint_name"], c2.row["constraint_name"])
+	return _compareString(c.row["constraint_def"], c2.row["constraint_def"])
 }
 
 // Add returns SQL to add the primary key
 func (c PrimaryKeySchema) Add() {
-	// ALTER TABLE ONLY t_product ADD CONSTRAINT t_product_pkey PRIMARY KEY (product_id, seq_no);
-	// ALTER TABLE ONLY t_product ADD CONSTRAINT t_product_pkey UNIQUE (product_id);
-	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s PRIMARY KEY (%s);\n", c.row["table_name"], c.row["constraint_name"], c.primaryKeyString())
+	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s %s;\n", c.row["table_name"], c.row["constraint_name"], c.row["constraint_def"])
 }
 
 // Drop returns SQL to drop the foreign key
 func (c PrimaryKeySchema) Drop() {
-	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT IF EXISTS %s;\n", c.row["table_name"], c.row["constraint_name"])
+	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s; -- %s\n", c.row["table_name"], c.row["constraint_name"], c.row["constraint_def"])
 }
 
 // Change handles the case where the table name matches, but the details do not
@@ -56,54 +54,23 @@ func (c PrimaryKeySchema) Change(obj interface{}) {
 	if !ok {
 		fmt.Println("Error!!!, change needs a PrimaryKeySchema instance", c2)
 	}
-	pk1 := c.primaryKeyString()
-	pk2 := c.primaryKeyString()
-	if pk1 != pk2 {
-		fmt.Printf("-- Warning, primary key is different for table %s  pk1:%s  pk2:%s\n", c.row["table_name"], pk1, pk2)
-		fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s;\n", c.row["table_name"], c2.row["constraint_name"])
-		fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s PRIMARY KEY (%s);\n", c.row["table_name"], c.row["constraint_name"], c.primaryKeyString())
-	}
-}
-
-// primaryKeyString concatenates the primary key column names into one string.
-// It's possible this could be done with SQL, I just haven't figured it out yet
-func (c PrimaryKeySchema) primaryKeyString() string {
-	pkey := ""
-	for i := 1; i <= 5; i++ {
-		colName := fmt.Sprintf("col%d", i)
-		col := c.row[colName]
-		//fmt.Printf("-- colName: %s  val:'%s'\n", colName, col)
-		if len(col) > 0 {
-			if len(pkey) > 0 {
-				pkey = pkey + ","
-			}
-			pkey = pkey + col
-		}
-	}
-	return pkey
+	// There is no "changing" a primary key.  It either gets created or dropped (or left as-is).
 }
 
 /*
- * Compare the primary keys in the two databases.  This SQL can handle up to 5 columns
- * as part of the primary key
+ * Compare the primary keys in the two databases.  We do not recreate primary keys if just the name is different.
  */
 func comparePrimaryKeys(conn1 *sql.DB, conn2 *sql.DB) {
 	sql := `
-SELECT tc.table_name
-	, kcu.constraint_name
-	, MAX(CASE WHEN kcu.ordinal_position = 1 THEN kcu.column_name ELSE '' END) AS col1
-	, MAX(CASE WHEN kcu.ordinal_position = 2 THEN kcu.column_name ELSE '' END) AS col2
-	, MAX(CASE WHEN kcu.ordinal_position = 3 THEN kcu.column_name ELSE '' END) AS col3
-	, MAX(CASE WHEN kcu.ordinal_position = 4 THEN kcu.column_name ELSE '' END) AS col4
-	, MAX(CASE WHEN kcu.ordinal_position = 5 THEN kcu.column_name ELSE '' END) AS col5
-FROM information_schema.table_constraints AS tc 
-LEFT JOIN information_schema.key_column_usage kcu
-       ON tc.constraint_catalog = kcu.constraint_catalog
-      AND tc.constraint_schema = kcu.constraint_schema
-      AND tc.constraint_name = kcu.constraint_name
-WHERE tc.constraint_type = 'PRIMARY KEY'
-GROUP BY tc.table_name, kcu.constraint_name
-ORDER BY tc.table_name, kcu.constraint_name COLLATE "C" ASC;`
+SELECT c.conname AS constraint_name
+	, c.contype AS constraint_type
+	, cl.relname AS table_name
+	, pg_catalog.pg_get_constraintdef(c.oid, true) as constraint_def
+FROM pg_catalog.pg_constraint c
+INNER JOIN pg_class AS cl ON (c.conrelid = cl.oid)
+WHERE c.contype = 'p'
+ORDER BY cl.relname::varchar, pg_catalog.pg_get_constraintdef(c.oid, true) COLLATE "C" ASC;
+`
 
 	rowChan1, _ := pgutil.QueryStrings(conn1, sql)
 	rowChan2, _ := pgutil.QueryStrings(conn2, sql)

unique.go

@@ -34,20 +34,18 @@ func (c *UniqueSchema) Compare(obj interface{}) int {
 	if val != 0 {
 		return val
 	}
-	val = _compareString(c.row["constraint_name"], c2.row["constraint_name"])
+	val = _compareString(c.row["constraint_def"], c2.row["constraint_def"])
 	return val
 }
 
-// Add returns SQL to add the primary key
+// Add returns SQL to add the unique constraint
 func (c UniqueSchema) Add() {
-	// ALTER TABLE ONLY t_product ADD CONSTRAINT t_product_pkey PRIMARY KEY (product_id, seq_no);
-	// ALTER TABLE ONLY t_product ADD CONSTRAINT t_product_pkey UNIQUE (product_id);
-	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s UNIQUE (%s);\n", c.row["table_name"], c.row["constraint_name"], c.uniqueColumnString())
+	fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s %s;\n", c.row["table_name"], c.row["constraint_name"], c.row["constraint_def"])
 }
 
-// Drop returns SQL to drop the foreign key
+// Drop returns SQL to drop the unique constraint
 func (c UniqueSchema) Drop() {
-	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT IF EXISTS %s;\n", c.row["table_name"], c.row["constraint_name"])
+	fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s; -- %s\n", c.row["table_name"], c.row["constraint_name"], c.row["constraint_def"])
 }
 
 // Change handles the case where the table name matches, but the details do not
@@ -56,54 +54,23 @@ func (c UniqueSchema) Change(obj interface{}) {
 	if !ok {
 		fmt.Println("Error!!!, change needs a UniqueSchema instance", c2)
 	}
-	pk1 := c.uniqueColumnString()
-	pk2 := c.uniqueColumnString()
-	if pk1 != pk2 {
-		fmt.Printf("-- Warning, primary key is different for table %s  pk1:%s  pk2:%s\n", c.row["table_name"], pk1, pk2)
-		fmt.Printf("ALTER TABLE %s DROP CONSTRAINT %s;\n", c.row["table_name"], c2.row["constraint_name"])
-		fmt.Printf("ALTER TABLE %s ADD CONSTRAINT %s UNIQUE (%s);\n", c.row["table_name"], c.row["constraint_name"], c.uniqueColumnString())
-	}
-}
-
-// uniqueColumnString concatenates the primary key column names into one string.
-// It's possible this could be done with SQL, I just haven't figured it out yet
-func (c UniqueSchema) uniqueColumnString() string {
-	pkey := ""
-	for i := 1; i <= 5; i++ {
-		colName := fmt.Sprintf("col%d", i)
-		col := c.row[colName]
-		//fmt.Printf("-- colName: %s  val:'%s'\n", colName, col)
-		if len(col) > 0 {
-			if len(pkey) > 0 {
-				pkey = pkey + ","
-			}
-			pkey = pkey + col
-		}
-	}
-	return pkey
+	// There is no "changing" a unique constraint.  It either gets created or dropped (or left as-is).
 }
 
 /*
- * Compare the primary keys in the two databases.  This SQL can handle up to 5 columns
- * as part of the primary key
+ * Compare the primary keys in the two databases.  We do not recreate unique if just the name is different.
  */
 func compareUniqueConstraints(conn1 *sql.DB, conn2 *sql.DB) {
 	sql := `
-SELECT tc.table_name
-	, kcu.constraint_name
-	, MAX(CASE WHEN kcu.ordinal_position = 1 THEN kcu.column_name ELSE '' END) AS col1
-	, MAX(CASE WHEN kcu.ordinal_position = 2 THEN kcu.column_name ELSE '' END) AS col2
-	, MAX(CASE WHEN kcu.ordinal_position = 3 THEN kcu.column_name ELSE '' END) AS col3
-	, MAX(CASE WHEN kcu.ordinal_position = 4 THEN kcu.column_name ELSE '' END) AS col4
-	, MAX(CASE WHEN kcu.ordinal_position = 5 THEN kcu.column_name ELSE '' END) AS col5
-FROM information_schema.table_constraints AS tc 
-LEFT JOIN information_schema.key_column_usage kcu
-       ON tc.constraint_catalog = kcu.constraint_catalog
-      AND tc.constraint_schema = kcu.constraint_schema
-      AND tc.constraint_name = kcu.constraint_name
-WHERE tc.constraint_type = 'UNIQUE'
-GROUP BY tc.table_name, kcu.constraint_name
-ORDER BY tc.table_name, kcu.constraint_name COLLATE "C" ASC;`
+SELECT c.conname AS constraint_name
+	, c.contype AS constraint_type
+	, cl.relname AS table_name
+	, pg_catalog.pg_get_constraintdef(c.oid, true) as constraint_def
+FROM pg_catalog.pg_constraint c
+INNER JOIN pg_class AS cl ON (c.conrelid = cl.oid)
+WHERE c.contype = 'u'
+ORDER BY cl.relname::varchar, pg_catalog.pg_get_constraintdef(c.oid, true) COLLATE "C" ASC;
+`
 
 	rowChan1, _ := pgutil.QueryStrings(conn1, sql)
 	rowChan2, _ := pgutil.QueryStrings(conn2, sql)