pg_examiner 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52b286b1541c6b5c4bae49271dbb37a1f75273bf
-  data.tar.gz: 8fe536e9f6af7a96a2a0780abb42db432cc33f4d
+  metadata.gz: a2625b44e3b5e213a77252e0e4f75c8e1c3cba77
+  data.tar.gz: 131e5074c7e82abe966e780788039a7cca9a9c1e
 SHA512:
-  metadata.gz: c7599ff717e5d701631fa20608daaa36c36c6122f1279b2faf11e0dacdc9a479f62f45cec2ce98faa539e292267ccaff035bfbfa7d8074da6cfcc1bd6962f50a
-  data.tar.gz: 5ac072b2cee56fe350785c53b4fc33fbc8d9e3d2ef795934d86a79e2ff597f1e90bbdca1b4d8d82942eef75525f3073d71ab46f2f89f94e02e08af6c8f861236
+  metadata.gz: 7fe244030e4b2facf9f7dce11dcf322594f26a046ce4d3833d68b9f0d3a46e09d5514c87aaf03cd15e95a59550a4f5f7fc8ecae80eaa13006a6587ae0b291348
+  data.tar.gz: 5ea6584418fe201c4fd06f7c2aff2811036998e933467267ad7f8f212356236c5d269894d31d8f98fc7e13d8faf0ae82746e1277b73b195fea93d50fad7bfb24

data/lib/pg_examiner/base.rb

@@ -70,5 +70,14 @@ module PGExaminer
     def ==(other)
       self.class == other.class && diff(other) == {}
     end
+
+    private
+
+    ARRAY_REGEX = /\A\{(.*)\}\z/
+    def extract_array(value)
+      without_brackets = value[ARRAY_REGEX, 1]
+      raise "Invalid array value: #{value.inspect}" unless without_brackets
+      without_brackets.split(',')
+    end
   end
 end

data/lib/pg_examiner/result/constraint.rb

@@ -5,10 +5,97 @@ module PGExaminer
     class Constraint < Item
       def diffable_attrs
         {
-          "name"       => "name",
-          "definition" => "constraint definition",
+          "name"          => "name",
+          "contype"       => "constraint type",
+          "condeferrable" => "constraint is deferrable",
+          "condeferred"   => "constraint is initially deferred",
+          "convalidated"  => "constraint is validated",
+          "connoinherit"  => "constraint is not inheritable",
+          "check_def"     => "check constraint definition",
         }
       end
+
+      def diffable_methods
+        {
+          "type"                        => "type",
+          "index"                       => "index",
+          "foreign_table_name"          => "table referenced by foreign key",
+          "constrained_columns"         => "local constrained columns",
+          "foreign_constrained_columns" => "foreign constrained columns",
+          "foreign_key_update_action"   => "foreign key on update action",
+          "foreign_key_delete_action"   => "foreign key on delete action",
+          "foreign_key_match_type"      => "foreign key match type",
+        }
+      end
+
+      def type
+        @type ||= result.pg_type.find{|t| t['oid'] == row['contypid']}['name'] if row['contypid'] != '0'
+      end
+
+      def index
+        @index ||= result.pg_index.find{|i| i['indexrelid'] == row['conindid']}['name'] if row['conindid'] != '0'
+      end
+
+      def foreign_table_name
+        if ft = foreign_table
+          this_schema_name = parent.parent.name
+          that_schema_name = ft.parent.name
+
+          relative_schema =
+            if this_schema_name == that_schema_name
+              "(same schema)"
+            else
+              "#{that_schema_name} schema"
+            end
+
+          [relative_schema, ft.name]
+        end
+      end
+
+      def foreign_table
+        if row['confrelid'] != '0'
+          @foreign_table ||= begin
+            # Look up the table, which may be outside our own schema.
+            table_row = result.pg_class.find { |c| c['relkind'] == 'r' && c['oid'] == row['confrelid'] }
+            schema = result.schemas.find { |s| s.oid == table_row['relnamespace'] }
+            schema.tables.find { |t| t.name == table_row['name'] }
+          end
+        end
+      end
+
+      def constrained_columns
+        @constrained_columns ||= extract_array(row['conkey']).map{|n| parent.columns.find{|c| c.row['attnum'] == n}.name} if row['conkey']
+      end
+
+      def foreign_constrained_columns
+        @foreign_constrained_columns ||= extract_array(row['confkey']).map{|n| foreign_table.columns.find{|c| c.row['attnum'] == n}.name} if row['confkey']
+      end
+
+      FOREIGN_KEY_ACTIONS = {
+        "a" => "no action",
+        "r" => "restrict",
+        "c" => "cascade",
+        "n" => "set null",
+        "d" => "set default",
+      }.freeze
+
+      def foreign_key_update_action
+        FOREIGN_KEY_ACTIONS.fetch(row['confupdtype']) if row['confupdtype'] != ' '
+      end
+
+      def foreign_key_delete_action
+        FOREIGN_KEY_ACTIONS.fetch(row['confdeltype']) if row['confdeltype'] != ' '
+      end
+
+      FOREIGN_KEY_MATCH_TYPES = {
+        "f" => "full",
+        "p" => "partial",
+        "s" => "simple",
+      }.freeze
+
+      def foreign_key_match_type
+        FOREIGN_KEY_MATCH_TYPES.fetch(row['confmatchtype']) if row['confmatchtype'] != ' '
+      end
     end
   end
 end

data/lib/pg_examiner/result.rb

@@ -83,7 +83,7 @@ module PGExaminer
       SQL
 
       @pg_index = load_table @pg_class.map{|ns| ns['oid']}, <<-SQL
-        SELECT c.relname AS name, i.indrelid, i.indkey, indisunique, indisprimary,
+        SELECT i.indexrelid, c.relname AS name, i.indrelid, i.indkey, indisunique, indisprimary,
           pg_get_expr(i.indpred, i.indrelid) AS filter,
           pg_get_expr(i.indexprs, i.indrelid) AS expression
         FROM pg_index i
@@ -92,8 +92,10 @@ module PGExaminer
       SQL
 
       @pg_constraint = load_table @pg_class.map{|ns| ns['oid']}, <<-SQL
-        SELECT oid, conname AS name, conrelid,
-          pg_get_constraintdef(oid) AS definition
+        SELECT oid, conname AS name, conrelid, contype,
+          condeferrable, condeferred, convalidated,
+          contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype,
+          connoinherit, conkey, confkey, pg_get_expr(conbin, conrelid) AS check_def
         FROM pg_constraint c
         WHERE conrelid IN (?)
       SQL

data/lib/pg_examiner/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PGExaminer
-  VERSION = '0.4.3'
+  VERSION = '0.4.4'
 end

data/spec/constraint_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe PGExaminer do
-  it "should consider constraints when determining table equivalency" do
+  it "should consider check constraints when determining table equivalency" do
     a = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
@@ -45,95 +45,52 @@ describe PGExaminer do
       );
     SQL
 
-    a.should == b
-    a.should == c
-    b.should == c
-    a.should_not == d
-    a.should_not == e
-    a.should_not == f
-    e.should_not == f
+    g = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        CONSTRAINT con CHECK (a < 0)
+      );
+    SQL
+
+    a.diff(b).should be_empty
+    a.diff(c).should be_empty
+    b.diff(c).should be_empty
 
     a.diff(d).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"added"=>["con_two"], "removed"=>["con"]}}}}}}
     a.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"added"=>["test_table_a_check"], "removed"=>["con"]}}}}}}
     a.diff(f).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"removed"=>["con"]}}}}}}
+    a.diff(g).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"con"=>{"check constraint definition"=>{"(a > 0)"=>"(a < 0)"}}}}}}}}
     e.diff(f).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"removed"=>["test_table_a_check"]}}}}}}
   end
 
-  it "should consider foreign keys when differentiating between schemas" do
+  it "should consider the tables each constraint is on" do
     a = examine <<-SQL
-      CREATE TABLE parent (
-        int1 integer PRIMARY KEY,
-        int2 integer UNIQUE
+      CREATE TABLE test_table_1 (
+        a integer,
+        CONSTRAINT con CHECK (a > 0)
       );
 
-      CREATE TABLE child (
-        parent_id integer REFERENCES parent
+      CREATE TABLE test_table_2 (
+        a integer
       );
     SQL
 
     b = examine <<-SQL
-      CREATE TABLE parent (
-        int1 integer PRIMARY KEY,
-        int2 integer UNIQUE
-      );
-
-      CREATE TABLE child (
-        parent_id integer,
-        FOREIGN KEY (parent_id) REFERENCES parent
-      );
-    SQL
-
-    c = examine <<-SQL
-      CREATE TABLE parent (
-        int1 integer PRIMARY KEY,
-        int2 integer UNIQUE
-      );
-
-      CREATE TABLE child (
-        parent_id integer,
-        FOREIGN KEY (parent_id) REFERENCES parent (int2)
-      );
-    SQL
-
-    d = examine <<-SQL
-      CREATE TABLE parent (
-        int1 integer PRIMARY KEY,
-        int2 integer UNIQUE
-      );
-
-      CREATE TABLE child (
-        parent_id integer,
-        FOREIGN KEY (parent_id) REFERENCES parent ON UPDATE CASCADE
-      );
-    SQL
-
-    e = examine <<-SQL
-      CREATE TABLE parent (
-        int1 integer PRIMARY KEY,
-        int2 integer UNIQUE
+      CREATE TABLE test_table_1 (
+        a integer
       );
 
-      CREATE TABLE child (
-        parent_id integer,
-        FOREIGN KEY (parent_id) REFERENCES parent ON DELETE CASCADE
+      CREATE TABLE test_table_2 (
+        a integer,
+        CONSTRAINT con CHECK (a > 0)
       );
     SQL
 
-    a.should == b
-    a.should_not == c
-    b.should_not == c
-    b.should_not == d
-    b.should_not == e
-    d.should_not == e
-
-    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"constraint definition"=>{"FOREIGN KEY (parent_id) REFERENCES parent(int1)"=>"FOREIGN KEY (parent_id) REFERENCES parent(int2)"}}}}}}}}
-    b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"constraint definition"=>{"FOREIGN KEY (parent_id) REFERENCES parent(int1)"=>"FOREIGN KEY (parent_id) REFERENCES parent(int2)"}}}}}}}}
-    b.diff(d).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"constraint definition"=>{"FOREIGN KEY (parent_id) REFERENCES parent(int1)"=>"FOREIGN KEY (parent_id) REFERENCES parent(int1) ON UPDATE CASCADE"}}}}}}}}
-    b.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"constraint definition"=>{"FOREIGN KEY (parent_id) REFERENCES parent(int1)"=>"FOREIGN KEY (parent_id) REFERENCES parent(int1) ON DELETE CASCADE"}}}}}}}}
-    d.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"constraint definition"=>{"FOREIGN KEY (parent_id) REFERENCES parent(int1) ON UPDATE CASCADE"=>"FOREIGN KEY (parent_id) REFERENCES parent(int1) ON DELETE CASCADE"}}}}}}}}
+    a.should_not == b
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table_1"=>{"constraints"=>{"removed"=>["con"]}}, "test_table_2"=>{"constraints"=>{"added"=>["con"]}}}}}}
   end
 
-  it "should consider constraints when determining table equivalency" do
+  it "should consider constraint validation when determining table equivalency" do
     a = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
@@ -161,34 +118,235 @@ describe PGExaminer do
     a.should_not == c
     b.should == c
 
-    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"con"=>{"constraint definition"=>{"CHECK ((a > 0)) NOT VALID"=>"CHECK ((a > 0))"}}}}}}}}
-    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"con"=>{"constraint definition"=>{"CHECK ((a > 0)) NOT VALID"=>"CHECK ((a > 0))"}}}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"con"=>{"constraint is validated"=>{"f"=>"t"}}}}}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"con"=>{"constraint is validated"=>{"f"=>"t"}}}}}}}}
   end
 
-  it "should consider the tables each constraint is on" do
-    a = examine <<-SQL
-      CREATE TABLE test_table_1 (
-        a integer,
-        CONSTRAINT con CHECK (a > 0)
-      );
-
-      CREATE TABLE test_table_2 (
-        a integer
-      );
-    SQL
-
-    b = examine <<-SQL
-      CREATE TABLE test_table_1 (
-        a integer
-      );
-
-      CREATE TABLE test_table_2 (
-        a integer,
-        CONSTRAINT con CHECK (a > 0)
-      );
-    SQL
-
-    a.should_not == b
-    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table_1"=>{"constraints"=>{"removed"=>["con"]}}, "test_table_2"=>{"constraints"=>{"added"=>["con"]}}}}}}
+  describe "when considering foreign keys" do
+    it "should consider their presence" do
+      a = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer
+        );
+      SQL
+
+      b = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer REFERENCES parent
+        );
+      SQL
+
+      a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"added"=>["child_parent_id_fkey"]}}}}}}
+    end
+
+    it "should consider the remote columns of foreign keys when differentiating between schemas" do
+      a = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY,
+          int2 integer UNIQUE
+        );
+
+        CREATE TABLE child (
+          parent_id integer REFERENCES parent
+        );
+      SQL
+
+      b = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY,
+          int2 integer UNIQUE
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent (int1)
+        );
+      SQL
+
+      c = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY,
+          int2 integer UNIQUE
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent (int2)
+        );
+      SQL
+
+      a.should == b
+      a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"index"=>{"parent_pkey"=>"parent_int2_key"}, "foreign constrained columns"=>{["int1"]=>["int2"]}}}}}}}}
+      b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"index"=>{"parent_pkey"=>"parent_int2_key"}, "foreign constrained columns"=>{["int1"]=>["int2"]}}}}}}}}
+    end
+
+    it "should consider the local columns of the foreign keys" do
+      a = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id1 integer,
+          parent_id2 integer,
+          CONSTRAINT fkey FOREIGN KEY (parent_id1) REFERENCES parent
+        );
+      SQL
+
+      b = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id1 integer,
+          parent_id2 integer,
+          CONSTRAINT fkey FOREIGN KEY (parent_id2) REFERENCES parent
+        );
+      SQL
+
+      a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"fkey"=>{"local constrained columns"=>{["parent_id1"]=>["parent_id2"]}}}}}}}}
+    end
+
+    it "should consider on update/delete actions" do
+      a = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent
+        );
+      SQL
+
+      b = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent ON UPDATE CASCADE
+        );
+      SQL
+
+      c = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent ON DELETE CASCADE
+        );
+      SQL
+
+      a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"foreign key on update action"=>{"no action"=>"cascade"}}}}}}}}
+      a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"foreign key on delete action"=>{"no action"=>"cascade"}}}}}}}}
+      b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"foreign key on update action"=>{"cascade"=>"no action"}, "foreign key on delete action"=>{"no action"=>"cascade"}}}}}}}}
+    end
+
+    it "should consider match simple/full" do
+      a = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent
+        );
+      SQL
+
+      b = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent MATCH SIMPLE
+        );
+      SQL
+
+      c = examine <<-SQL
+        CREATE TABLE parent (
+          int1 integer PRIMARY KEY
+        );
+
+        CREATE TABLE child (
+          parent_id integer,
+          FOREIGN KEY (parent_id) REFERENCES parent MATCH FULL
+        );
+      SQL
+
+      a.diff(b).should == {}
+      a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"foreign key match type"=>{"simple"=>"full"}}}}}}}}
+      b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"foreign key match type"=>{"simple"=>"full"}}}}}}}}
+    end
+
+    describe "when comparing two schemas" do
+      it "should understand that tables will point to tables in their own schema" do
+        a = examine <<-SQL, "schema1"
+          CREATE SCHEMA schema1;
+          CREATE TABLE schema1.parent (int1 integer PRIMARY KEY);
+          CREATE TABLE schema1.child (parent_id integer REFERENCES schema1.parent);
+        SQL
+
+        b = examine <<-SQL, "schema2"
+          CREATE SCHEMA schema2;
+          CREATE TABLE schema2.parent (int1 integer PRIMARY KEY);
+          CREATE TABLE schema2.child (parent_id integer REFERENCES schema2.parent);
+        SQL
+
+        c = examine <<-SQL, "schema2"
+          CREATE SCHEMA schema1;
+          CREATE TABLE schema1.parent (int1 integer PRIMARY KEY);
+
+          CREATE SCHEMA schema2;
+          CREATE TABLE schema2.parent (int1 integer PRIMARY KEY);
+          CREATE TABLE schema2.child (parent_id integer REFERENCES schema1.parent);
+        SQL
+
+        a.should == b
+        b.diff(c).should == {"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"table referenced by foreign key"=>{["(same schema)", "parent"]=>["schema1 schema", "parent"]}}}}}}
+      end
+
+      it "should understand when tables point to a table in public" do
+        a = examine <<-SQL, "schema1"
+          CREATE TABLE parent (int1 integer PRIMARY KEY);
+          CREATE SCHEMA schema1;
+          CREATE TABLE schema1.parent (int1 integer PRIMARY KEY);
+          CREATE TABLE schema1.child (parent_id integer REFERENCES parent);
+        SQL
+
+        b = examine <<-SQL, "schema2"
+          CREATE TABLE parent (int1 integer PRIMARY KEY);
+          CREATE SCHEMA schema2;
+          CREATE TABLE schema2.parent (int1 integer PRIMARY KEY);
+          CREATE TABLE schema2.child (parent_id integer REFERENCES parent);
+        SQL
+
+        c = examine <<-SQL, "schema1"
+          CREATE TABLE parent (int1 integer PRIMARY KEY);
+
+          CREATE SCHEMA schema1;
+          CREATE TABLE schema1.parent (int1 integer PRIMARY KEY);
+          CREATE TABLE schema1.child (parent_id integer REFERENCES schema1.parent);
+        SQL
+
+        a.should == b
+        b.diff(c).should == {"tables"=>{"child"=>{"constraints"=>{"child_parent_id_fkey"=>{"table referenced by foreign key"=>{["public schema", "parent"]=>["(same schema)", "parent"]}}}}}}
+      end
+    end
   end
 end

data/spec/index_spec.rb

@@ -297,9 +297,9 @@ describe PGExaminer do
     d.should == d2
     e.should == e2
 
-    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint definition"=>{"UNIQUE (a)"=>"UNIQUE (a) DEFERRABLE"}}}}}}}}
-    a.diff(d).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint definition"=>{"UNIQUE (a)"=>"UNIQUE (a) DEFERRABLE"}}}}}}}}
-    c.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint definition"=>{"UNIQUE (a) DEFERRABLE"=>"UNIQUE (a) DEFERRABLE INITIALLY DEFERRED"}}}}}}}}
-    d.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint definition"=>{"UNIQUE (a) DEFERRABLE"=>"UNIQUE (a) DEFERRABLE INITIALLY DEFERRED"}}}}}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint is deferrable"=>{"f"=>"t"}}}}}}}}
+    a.diff(d).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint is deferrable"=>{"f"=>"t"}}}}}}}}
+    c.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint is initially deferred"=>{"f"=>"t"}}}}}}}}
+    d.diff(e).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"test_table_a_key"=>{"constraint is initially deferred"=>{"f"=>"t"}}}}}}}}
   end
 end

data/spec/trigger_spec.rb

@@ -303,8 +303,8 @@ describe PGExaminer do
       CREATE CONSTRAINT TRIGGER trig AFTER INSERT ON test_table DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE func();
     SQL
 
-    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"trig"=>{"constraint definition"=>{"TRIGGER"=>"TRIGGER DEFERRABLE"}}}}}}}}
-    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"trig"=>{"constraint definition"=>{"TRIGGER"=>"TRIGGER DEFERRABLE INITIALLY DEFERRED"}}}}}}}}
-    b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"trig"=>{"constraint definition"=>{"TRIGGER DEFERRABLE"=>"TRIGGER DEFERRABLE INITIALLY DEFERRED"}}}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"trig"=>{"constraint is deferrable"=>{"f"=>"t"}}}}}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"trig"=>{"constraint is deferrable"=>{"f"=>"t"}, "constraint is initially deferred"=>{"f"=>"t"}}}}}}}}
+    b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"trig"=>{"constraint is initially deferred"=>{"f"=>"t"}}}}}}}}
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_examiner
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-29 00:00:00.000000000 Z
+date: 2016-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg