pg_examiner 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: d356dc864a178282a0215872ebada1d1632bde1f
-  data.tar.gz: dd10dd54b238c784dd2a64860fc4ea2bb603fd9b
-SHA512: 
-  metadata.gz: 86f551bd4b3f744071d176bc78bfe0b8a67468dacbed61af64fb10ec822f1ecd24357d960b609dd1936852e87f64802ef3da0c7c95573924260e12d1d96b7c6f
-  data.tar.gz: 027020de63882cdc3040dc84e7f48426503a0f6ca36a7071dd7322453087dce450d6f0eefe722ef838c289ee3bbfb4b885ec7b17870b50fc6d680e23f73f95ad
+---
+SHA1:
+  metadata.gz: 81a303d82801100e755a80fbf08ac0b6b9d0f254
+  data.tar.gz: 0dc95a111058c548e1281a1b0694d0d97d170537
+SHA512:
+  metadata.gz: bcace5f639bc93c559f2ae2ab802f741a858c0a79d5071a3ba94d88b06cd26cc9f2ce3f4816d2ab6a4c3450408a706ae2b11c64821ba5fe39543be26a247c8dd
+  data.tar.gz: 0606ea636a20e128179ec6ee679ec0b6e9445a2cf4e5ca620095f3fc52a9f3a57dd7d4c44bf69d949f87c57f67555f8e2b5a010cad532c8e83ca5cebce02a65f

data/lib/pg_examiner/base.rb

@@ -0,0 +1,72 @@
+module PGExaminer
+  class Base
+    def diffable_lists
+      []
+    end
+
+    def diffable_attrs
+      []
+    end
+
+    def diffable_methods
+      []
+    end
+
+    def diff(other)
+      raise "Can't diff a #{self.class} and a #{other.class}" unless self.class == other.class
+
+      r = {}
+
+      diffable_attrs.each do |attr|
+        this = @row.fetch(attr.to_s)
+        that = other.row.fetch(attr.to_s)
+
+        unless this == that
+          r[attr] = {this => that}
+        end
+      end
+
+      diffable_methods.each do |attr|
+        this = send(attr)
+        that = other.send(attr)
+
+        unless this == that
+          r[attr] = {this => that}
+        end
+      end
+
+      diffable_lists.each do |attr|
+        these = send(attr)
+        those = other.send(attr)
+        these_names = these.map(&:name)
+        those_names = those.map(&:name)
+
+        if these_names == those_names
+          result = these.zip(those).each_with_object({}) do |(this, that), hash|
+            if (result = this.diff(that)).any?
+              hash[this.name] = result
+            end
+          end
+
+          if result.any?
+            r[attr] = result
+          end
+        else
+          added   = those_names - these_names
+          removed = these_names - those_names
+
+          h = {}
+          h[:added]   = added   if added.any?
+          h[:removed] = removed if removed.any?
+          r[attr] = h
+        end
+      end
+
+      r
+    end
+
+    def ==(other)
+      self.class == other.class && diff(other) == {}
+    end
+  end
+end

data/lib/pg_examiner/result/column.rb

@@ -1,7 +1,13 @@
 module PGExaminer
   class Result
-    class Column < Base
-      COMPARISON_COLUMNS = %w(name attndims attnotnull atttypmod)
+    class Column < Item
+      def diffable_methods
+        [:type, :default]
+      end
+
+      def diffable_attrs
+        [:name, :attndims, :attnotnull, :atttypmod]
+      end
 
       def type
         @type ||= result.pg_type.find{|t| t['oid'] == row['atttypid']}['name']
@@ -16,12 +22,6 @@ module PGExaminer
           @default = result.pg_attrdef.find{|d| d['adrelid'] == row['attrelid']}['default'] if row['atthasdef'] == 't'
         end
       end
-
-      def ==(other)
-        super &&
-          type == other.type &&
-          default == other.default
-      end
     end
   end
 end

data/lib/pg_examiner/result/constraint.rb

@@ -1,7 +1,9 @@
 module PGExaminer
   class Result
-    class Constraint < Base
-      COMPARISON_COLUMNS = %w(name definition)
+    class Constraint < Item
+      def diffable_attrs
+        [:name, :definition]
+      end
     end
   end
 end

data/lib/pg_examiner/result/extension.rb

@@ -1,15 +1,28 @@
 module PGExaminer
   class Result
-    class Extension < Base
-      COMPARISON_COLUMNS = %w(name extversion)
+    class Extension < Item
+      def diffable_attrs
+        [:name, :extversion]
+      end
+
+      def diffable_methods
+        [:schema_name]
+      end
 
       def schema
-        @schema ||= result.schemas.find { |s| s.oid == row['extnamespace'] }
+        # Extensions installed in system schemas won't be returned, so @schema
+        # will be nil in that case.
+
+        if @schema_calculated
+          @schema
+        else
+          @schema_calculated = true
+          @schema = result.schemas.find{|s| s.oid == row['extnamespace']}
+        end
       end
 
-      def ==(other)
-        super &&
-          (schema && schema.name) == (other.schema && other.schema.name)
+      def schema_name
+        schema && schema.name
       end
     end
   end

data/lib/pg_examiner/result/function.rb

@@ -1,7 +1,13 @@
 module PGExaminer
   class Result
-    class Function < Base
-      COMPARISON_COLUMNS = %w(name proargmodes definition)
+    class Function < Item
+      def diffable_attrs
+        [:name, :proargmodes, :definition]
+      end
+
+      def diffable_methods
+        [:argument_types, :return_type, :language]
+      end
 
       def argument_types
         @argument_types ||= @row['proargtypes'].split.map do |oid|
@@ -16,13 +22,6 @@ module PGExaminer
       def language
         @language ||= result.pg_language.find{|l| l['oid'] == @row['prolang']}['name']
       end
-
-      def ==(other)
-        super &&
-          argument_types == other.argument_types &&
-          return_type    == other.return_type &&
-          language       == other.language
-      end
     end
   end
 end

data/lib/pg_examiner/result/index.rb

@@ -1,15 +1,16 @@
 module PGExaminer
   class Result
-    class Index < Base
-      COMPARISON_COLUMNS = %w(name filter indisunique indisprimary)
+    class Index < Item
+      def diffable_attrs
+        [:name, :filter, :indisunique, :indisprimary]
+      end
 
-      def expression
-        @row['expression'] || @row['indkey'].split.map{|i| parent.columns.find{|c| c.row['attnum'] == i}}.map(&:name)
+      def diffable_methods
+        [:expression]
       end
 
-      def ==(other)
-        super &&
-          expression == other.expression
+      def expression
+        @row['expression'] || @row['indkey'].split.map{|i| parent.columns.find{|c| c.row['attnum'] == i}}.map(&:name)
       end
     end
   end

data/lib/pg_examiner/result/{base.rb → item.rb}

@@ -1,6 +1,6 @@
 module PGExaminer
   class Result
-    class Base
+    class Item < Base
       attr_reader :result, :row, :parent
 
       def initialize(result, row, parent = nil)
@@ -15,11 +15,6 @@ module PGExaminer
         @row['name']
       end
 
-      def ==(other)
-        columns = self.class::COMPARISON_COLUMNS
-        self.class == other.class && row.values_at(*columns) == other.row.values_at(*columns)
-      end
-
       def inspect
         "#<#{self.class} @row=#{@row.inspect}>"
       end

data/lib/pg_examiner/result/language.rb

@@ -1,7 +1,9 @@
 module PGExaminer
   class Result
-    class Language < Base
-      COMPARISON_COLUMNS = %w(name)
+    class Language < Item
+      def diffable_attrs
+        [:name]
+      end
     end
   end
 end

data/lib/pg_examiner/result/schema.rb

@@ -1,7 +1,9 @@
 module PGExaminer
   class Result
-    class Schema < Base
-      COMPARISON_COLUMNS = %w()
+    class Schema < Item
+      def diffable_lists
+        [:tables, :functions]
+      end
 
       def tables
         @tables ||= result.pg_class.select do |c|
@@ -14,12 +16,6 @@ module PGExaminer
           c['pronamespace'] == oid
         end.map{|row| Function.new(result, row, self)}.sort_by(&:name)
       end
-
-      def ==(other)
-        super &&
-          tables    == other.tables &&
-          functions == other.functions
-      end
     end
   end
 end

data/lib/pg_examiner/result/table.rb

@@ -1,7 +1,13 @@
 module PGExaminer
   class Result
-    class Table < Base
-      COMPARISON_COLUMNS = %w(name relpersistence reloptions)
+    class Table < Item
+      def diffable_lists
+        [:columns, :indexes, :constraints, :triggers]
+      end
+
+      def diffable_attrs
+        [:name, :relpersistence, :reloptions]
+      end
 
       def columns
         @columns ||= result.pg_attribute.select do |c|
@@ -26,14 +32,6 @@ module PGExaminer
           t['tgrelid'] == oid
         end.map{|row| Trigger.new(result, row, self)}.sort_by(&:name)
       end
-
-      def ==(other)
-        super &&
-          columns     == other.columns &&
-          indexes     == other.indexes &&
-          constraints == other.constraints &&
-          triggers    == other.triggers
-      end
     end
   end
 end

data/lib/pg_examiner/result/trigger.rb

@@ -1,15 +1,16 @@
 module PGExaminer
   class Result
-    class Trigger < Base
-      COMPARISON_COLUMNS = %w(name tgtype)
+    class Trigger < Item
+      def diffable_attrs
+        [:name, :tgtype]
+      end
 
-      def function
-        @function ||= result.pg_proc.find{|f| f['oid'] == @row['tgfoid']}['name']
+      def diffable_methods
+        [:function]
       end
 
-      def ==(other)
-        super &&
-          function == other.function
+      def function
+        @function ||= result.pg_proc.find{|f| f['oid'] == @row['tgfoid']}['name']
       end
     end
   end

data/lib/pg_examiner/result.rb

@@ -1,16 +1,7 @@
-require 'pg_examiner/result/base'
-require 'pg_examiner/result/column'
-require 'pg_examiner/result/constraint'
-require 'pg_examiner/result/extension'
-require 'pg_examiner/result/function'
-require 'pg_examiner/result/index'
-require 'pg_examiner/result/language'
-require 'pg_examiner/result/schema'
-require 'pg_examiner/result/table'
-require 'pg_examiner/result/trigger'
+require 'pg_examiner/base'
 
 module PGExaminer
-  class Result
+  class Result < Base
     attr_reader :pg_namespace,
                 :pg_class,
                 :pg_type,
@@ -28,6 +19,10 @@ module PGExaminer
       load_schema
     end
 
+    def diffable_lists
+      [:schemas, :extensions, :languages]
+    end
+
     def schemas
       @schemas ||= @pg_namespace.map{|row| Schema.new(self, row)}.sort_by(&:name)
     end
@@ -40,17 +35,6 @@ module PGExaminer
       @languages ||= @pg_language.map{|row| Language.new(self, row)}.sort_by(&:name)
     end
 
-    def ==(other)
-      # We want to be able to compare the contents of two schemas to each
-      # other, so compare names at the top level instead of schema-to-schema.
-
-      other.is_a?(Result) &&
-        schemas.map(&:name) == other.schemas.map(&:name) &&
-        schemas             == other.schemas &&
-        extensions          == other.extensions &&
-        languages           == other.languages
-    end
-
     def inspect
       "#<#{self.class} @schemas=#{@schemas.inspect}, @extensions=#{@extensions.inspect}>"
     end
@@ -147,3 +131,14 @@ module PGExaminer
     end
   end
 end
+
+require 'pg_examiner/result/item'
+require 'pg_examiner/result/column'
+require 'pg_examiner/result/constraint'
+require 'pg_examiner/result/extension'
+require 'pg_examiner/result/function'
+require 'pg_examiner/result/index'
+require 'pg_examiner/result/language'
+require 'pg_examiner/result/schema'
+require 'pg_examiner/result/table'
+require 'pg_examiner/result/trigger'

data/lib/pg_examiner/version.rb

@@ -1,3 +1,3 @@
 module PGExaminer
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/spec/constraint_spec.rb

@@ -50,6 +50,11 @@ describe PGExaminer do
     a.should_not == e
     a.should_not == f
     e.should_not == f
+
+    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"]}}}}}}
+    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
@@ -118,6 +123,12 @@ describe PGExaminer do
     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"=>{: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"=>{: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"=>{: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"=>{: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"=>{:definition=>{"FOREIGN KEY (parent_id) REFERENCES parent(int1) ON UPDATE CASCADE"=>"FOREIGN KEY (parent_id) REFERENCES parent(int1) ON DELETE CASCADE"}}}}}}}}
   end
 
   it "should consider constraints when determining table equivalency" do
@@ -147,5 +158,35 @@ describe PGExaminer do
     a.should_not == b
     a.should_not == c
     b.should == c
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:constraints=>{"con"=>{:definition=>{"CHECK ((a > 0)) NOT VALID"=>"CHECK ((a > 0))"}}}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:constraints=>{"con"=>{:definition=>{"CHECK ((a > 0)) NOT VALID"=>"CHECK ((a > 0))"}}}}}}}}
+  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"]}}}}}}
   end
 end

data/spec/extension_spec.rb

@@ -2,17 +2,17 @@ require 'spec_helper'
 
 describe PGExaminer do
   it "should be able to examine the extensions in the db" do
-    result = examine "SELECT 1"
-    result.should be_an_instance_of PGExaminer::Result
-    result.extensions.map(&:name).should == ['plpgsql']
+    result1 = examine "SELECT 1"
+    result1.should be_an_instance_of PGExaminer::Result
+    result1.extensions.map(&:name).should == ['plpgsql']
 
-    result = examine <<-SQL
+    result2 = examine <<-SQL
       CREATE EXTENSION citext;
     SQL
 
-    result.extensions.length.should == 2
+    result2.extensions.length.should == 2
 
-    citext, plpgsql = result.extensions # Ordered by name
+    citext, plpgsql = result2.extensions # Ordered by name
 
     citext.should be_an_instance_of PGExaminer::Result::Extension
     citext.name.should == 'citext'
@@ -22,5 +22,8 @@ describe PGExaminer do
     plpgsql.should be_an_instance_of PGExaminer::Result::Extension
     plpgsql.name.should == 'plpgsql'
     plpgsql.schema.should be nil
+
+    result1.diff(result2)[:extensions].should == {added: ['citext']}
+    result2.diff(result1)[:extensions].should == {removed: ['citext']}
   end
 end

data/spec/function_spec.rb

@@ -29,6 +29,9 @@ describe PGExaminer do
     a.should == b
     a.should_not == c
     b.should_not == c
+
+    a.diff(c).should == {:schemas=>{"public"=>{:functions=>{:added=>["add_numbers"], :removed=>["add"]}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:functions=>{:added=>["add_numbers"], :removed=>["add"]}}}}
   end
 
   it "should be able to differentiate between functions by their argument types" do
@@ -70,6 +73,9 @@ describe PGExaminer do
     b.should_not == c
     b.should_not == d
     c.should_not == d
+
+    a.diff(b).should == {:schemas=>{"public"=>{:functions=>{"add"=>{:definition=>{"CREATE OR REPLACE FUNCTION public.add(one integer, two integer)\n RETURNS integer\n LANGUAGE sql\nAS $function$\n        SELECT one + two\n      $function$\n"=>"CREATE OR REPLACE FUNCTION public.add(one integer, two integer, three integer)\n RETURNS integer\n LANGUAGE sql\nAS $function$\n        SELECT one + two\n      $function$\n"}, :argument_types=>{["int4", "int4"]=>["int4", "int4", "int4"]}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:functions=>{"add"=>{:definition=>{"CREATE OR REPLACE FUNCTION public.add(one integer, two integer)\n RETURNS integer\n LANGUAGE sql\nAS $function$\n        SELECT one + two\n      $function$\n"=>"CREATE OR REPLACE FUNCTION public.add(one integer, two integer, three integer[])\n RETURNS integer\n LANGUAGE sql\nAS $function$\n        SELECT one + two\n      $function$\n"}, :argument_types=>{["int4", "int4"]=>["int4", "int4", "_int4"]}}}}}}
   end
 
   it "should be able to differentiate between functions by their argument defaults" do
@@ -142,6 +148,8 @@ describe PGExaminer do
     SQL_FUNCTION
 
     a.should_not == b
+
+    a.diff(b)[:schemas]['public'][:functions]['add'][:language].should == {'sql' => 'plpgsql'}
   end
 
   it "should be able to differentiate between functions by their other flags" do
@@ -298,6 +306,9 @@ describe PGExaminer do
     a.should == b
     a.should_not == c
     b.should_not == c
+
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:triggers=>{:added=>["trig2"], :removed=>["trig"]}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:triggers=>{:added=>["trig2"], :removed=>["trig"]}}}}}}
   end
 
   it "should be able to differentiate between triggers by their parent tables" do
@@ -342,6 +353,8 @@ describe PGExaminer do
     SQL
 
     a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table_a"=>{:triggers=>{:removed=>["trig"]}}, "test_table_b"=>{:triggers=>{:added=>["trig"]}}}}}}
   end
 
   it "should be able to differentiate between triggers by their associated functions" do
@@ -394,6 +407,8 @@ describe PGExaminer do
     SQL
 
     a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:triggers=>{"trig"=>{:function=>{"func1"=>"func2"}}}}}}}}
   end
 
   it "should be able to differentiate between triggers by their firing conditions" do
@@ -448,5 +463,7 @@ describe PGExaminer do
     a.should_not == b
     a.should_not == c
     b.should_not == c
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:triggers=>{"trig"=>{:tgtype=>{"7"=>"19"}}}}}}}}
   end
 end

data/spec/index_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe PGExaminer do
   it "should consider indexes when determining equivalency" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         id integer
       );
@@ -10,7 +10,7 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(id);
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         id integer
       );
@@ -18,7 +18,7 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(id);
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         id integer
       );
@@ -26,13 +26,16 @@ describe PGExaminer do
       CREATE INDEX int_idx2 ON test_table(id);
     SQL
 
-    one.should == two
-    one.should_not == three
-    two.should_not == three
+    a.should == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{:added=>["int_idx2"], :removed=>["int_idx"]}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{:added=>["int_idx2"], :removed=>["int_idx"]}}}}}}
   end
 
   it "should consider the columns indexes are on when determining equivalency" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         b integer
@@ -41,7 +44,7 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(a);
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         b integer
@@ -50,7 +53,7 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(b);
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         b integer
@@ -59,13 +62,17 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(a, b);
     SQL
 
-    one.should_not == two
-    one.should_not == three
-    two.should_not == three
+    a.should_not == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"int_idx"=>{:expression=>{["a"]=>["b"]}}}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"int_idx"=>{:expression=>{["a"]=>["a", "b"]}}}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"int_idx"=>{:expression=>{["b"]=>["a", "b"]}}}}}}}}
   end
 
   it "should consider the filters indexes have when determining equivalency" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -73,9 +80,9 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(a) WHERE a > 0;
     SQL
 
-    one.schemas.first.tables.first.indexes.first.row['filter'].should == '(a > 0)'
+    a.schemas.first.tables.first.indexes.first.row['filter'].should == '(a > 0)'
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -83,9 +90,9 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(a) WHERE a > 0;
     SQL
 
-    two.schemas.first.tables.first.indexes.first.row['filter'].should == '(a > 0)'
+    b.schemas.first.tables.first.indexes.first.row['filter'].should == '(a > 0)'
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -93,13 +100,16 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(a);
     SQL
 
-    one.should == two
-    one.should_not == three
-    two.should_not == three
+    a.should == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"int_idx"=>{:filter=>{"(a > 0)"=>nil}}}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"int_idx"=>{:filter=>{"(a > 0)"=>nil}}}}}}}}
   end
 
   it "should consider the expressions indexes are on, if any" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a text
       );
@@ -107,9 +117,9 @@ describe PGExaminer do
       CREATE INDEX text_idx ON test_table(lower(a));
     SQL
 
-    one.schemas.first.tables.first.indexes.first.expression.should == 'lower(a)'
+    a.schemas.first.tables.first.indexes.first.expression.should == 'lower(a)'
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a text
       );
@@ -117,9 +127,9 @@ describe PGExaminer do
       CREATE INDEX text_idx ON test_table(LOWER(a));
     SQL
 
-    two.schemas.first.tables.first.indexes.first.expression.should == 'lower(a)'
+    b.schemas.first.tables.first.indexes.first.expression.should == 'lower(a)'
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a text
       );
@@ -127,13 +137,16 @@ describe PGExaminer do
       CREATE INDEX text_idx ON test_table(a);
     SQL
 
-    one.should == two
-    one.should_not == three
-    two.should_not == three
+    a.should == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"text_idx"=>{:expression=>{"lower(a)"=>["a"]}}}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"text_idx"=>{:expression=>{"lower(a)"=>["a"]}}}}}}}}
   end
 
   it "should consider the uniqueness and primary key status of an index, if any" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -141,7 +154,7 @@ describe PGExaminer do
       CREATE INDEX int_idx ON test_table(a);
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -149,7 +162,7 @@ describe PGExaminer do
       CREATE UNIQUE INDEX int_idx ON test_table(a);
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -157,8 +170,12 @@ describe PGExaminer do
       ALTER TABLE test_table ADD PRIMARY KEY (a);
     SQL
 
-    one.should_not == two
-    one.should_not == three
-    two.should_not == three
+    a.should_not == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:indexes=>{"int_idx"=>{:indisunique=>{"f"=>"t"}}}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:attnotnull=>{"f"=>"t"}}}, :indexes=>{:added=>["test_table_pkey"], :removed=>["int_idx"]}, :constraints=>{:added=>["test_table_pkey"]}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:attnotnull=>{"f"=>"t"}}}, :indexes=>{:added=>["test_table_pkey"], :removed=>["int_idx"]}, :constraints=>{:added=>["test_table_pkey"]}}}}}}
   end
 end

data/spec/schema_spec.rb

@@ -10,6 +10,10 @@ describe PGExaminer do
     schema.should be_an_instance_of PGExaminer::Result::Schema
     schema.name.should == 'public'
     schema.tables.should == []
+
+    other_result = examine("SELECT 1")
+    result.should == other_result
+    result.diff(other_result).should == {}
   end
 
   it "should detect other user-added schemas" do
@@ -21,6 +25,40 @@ describe PGExaminer do
     result.schemas.map(&:name).should == %w(my_schema public)
   end
 
+  it "should consider differently-named schemas non-equivalent" do
+    a = examine <<-SQL
+      CREATE SCHEMA test_schema_a;
+    SQL
+
+    b = examine <<-SQL
+      CREATE SCHEMA test_schema_b;
+    SQL
+
+    c = examine <<-SQL
+      SELECT 1;
+    SQL
+
+    a.should == a
+    a.should_not == b
+    a.should_not == c
+    b.should_not == a
+    b.should == b
+    b.should_not == c
+    c.should_not == a
+    c.should_not == b
+    c.should == c
+
+    a.diff(a).should == {}
+    a.diff(b).should == {schemas: {added: ['test_schema_b'], removed: ['test_schema_a']}}
+    a.diff(c).should == {schemas: {removed: ['test_schema_a']}}
+    b.diff(a).should == {schemas: {added: ['test_schema_a'], removed: ['test_schema_b']}}
+    b.diff(b).should == {}
+    b.diff(c).should == {schemas: {removed: ['test_schema_b']}}
+    c.diff(a).should == {schemas: {added: ['test_schema_a']}}
+    c.diff(b).should == {schemas: {added: ['test_schema_b']}}
+    c.diff(c).should == {}
+  end
+
   it "should be able to compare the contents of different schemas" do
     a = examine <<-SQL, :schema1
       CREATE SCHEMA schema1;
@@ -38,6 +76,24 @@ describe PGExaminer do
       );
     SQL
 
+    c = examine <<-SQL, :schema2
+      CREATE SCHEMA schema2;
+      CREATE TABLE schema2.test_table_2 (
+        a integer,
+        b integer
+      );
+    SQL
+
+    d = examine <<-SQL, :schema2
+      CREATE SCHEMA schema2;
+    SQL
+
     a.should == b
+    a.diff(b).should == {}
+    b.diff(a).should == {}
+
+    a.should_not == c
+    a.diff(c).should == {tables: {added: ['test_table_2'], removed: ['test_table']}}
+    a.diff(d).should == {tables: {removed: ['test_table']}}
   end
 end

data/spec/spec_helper.rb

@@ -11,6 +11,8 @@ CONNECTION = PG::Connection.open :host     => uri.host,
                                  :dbname   => uri.path[1..-1]
 
 RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = [:expect, :should] }
+
   def examine(sql, schema = nil)
     execute "BEGIN"
     execute(sql)

data/spec/table_spec.rb

@@ -51,43 +51,45 @@ describe PGExaminer do
   end
 
   it "should consider equivalent tables equivalent" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         id serial,
         body text
       )
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         id serial,
         body text
       )
     SQL
 
-    one.should == two
+    a.should == b
   end
 
   it "should consider differently-named tables non-equivalent" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table_a (
         id serial,
         body text
       )
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table_b (
         id serial,
         body text
       )
     SQL
 
-    one.should_not == two
+    a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{:added=>["test_table_b"], :removed=>["test_table_a"]}}}}
   end
 
   it "should consider tables with current columns in the same order equivalent" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         b integer,
@@ -97,14 +99,14 @@ describe PGExaminer do
       ALTER TABLE test_table DROP COLUMN b;
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         c integer
       );
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
@@ -112,13 +114,13 @@ describe PGExaminer do
       ALTER TABLE test_table ADD COLUMN c integer;
     SQL
 
-    one.should == two
-    one.should == three
-    two.should == three
+    a.should == b
+    a.should == c
+    b.should == c
   end
 
   it "should consider tables with columns in differing orders not equivalent" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         b integer,
@@ -126,7 +128,7 @@ describe PGExaminer do
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer,
         c integer,
@@ -134,135 +136,154 @@ describe PGExaminer do
       )
     SQL
 
-    one.should_not == two
+    a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{}}}}}}
   end
 
   it "should consider tables with columns of differing types not equivalent" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a text
       )
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a integer default 5
       );
     SQL
 
-    one.should_not == two
-    one.should_not == three
+    a.should_not == b
+    a.should_not == c
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:type=>{"int4"=>"text"}}}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:default=>{nil=>"5"}}}}}}}}
   end
 
   it "should consider array types as different from scalar types" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer[]
       )
     SQL
 
-    one.should_not == two
+    a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:attndims=>{"0"=>"1"}, :type=>{"int4"=>"_int4"}}}}}}}}
   end
 
   it "should consider the presence of not-null constraints" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer not null
       )
     SQL
 
-    one.should_not == two
+    a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:attnotnull=>{"f"=>"t"}}}}}}}}
   end
 
   it "should consider the presence of type-specific data" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a varchar(49)
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a varchar(50)
       )
     SQL
 
-    one.should_not == two
+    a.should_not == b
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:atttypmod=>{"53"=>"54"}}}}}}}}
   end
 
   it "should consider unlogged and temporary tables as different from permanent tables" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE UNLOGGED TABLE test_table (
         a integer
       )
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TEMPORARY TABLE test_table (
         a integer
       )
     SQL
 
-    one.should_not == two
-    one.should_not == three
-    two.should_not == three
+    a.should_not == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:relpersistence=>{"p"=>"u"}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{:removed=>["test_table"]}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{:removed=>["test_table"]}}}}
   end
 
   it "should consider additional specified options when comparing tables" do
-    one = examine <<-SQL
+    a = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
     SQL
 
-    two = examine <<-SQL
+    b = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       )
       WITH (fillfactor=90);
     SQL
 
-    three = examine <<-SQL
+    c = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       )
       WITH (fillfactor=70);
     SQL
 
-    four = examine <<-SQL
+    d = examine <<-SQL
       CREATE TABLE test_table (
         a integer
       );
       ALTER TABLE test_table SET (fillfactor=70);
     SQL
 
-    one.should_not == two
-    one.should_not == three
-    two.should_not == three
-    three.should == four
+    a.should_not == b
+    a.should_not == c
+    b.should_not == c
+    c.should == d
+
+    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:reloptions=>{nil=>"{fillfactor=90}"}}}}}}
+    a.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:reloptions=>{nil=>"{fillfactor=70}"}}}}}}
+    b.diff(c).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:reloptions=>{"{fillfactor=90}"=>"{fillfactor=70}"}}}}}}
   end
 end

metadata

@@ -1,69 +1,80 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pg_examiner
-version: !ruby/object:Gem::Version 
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 0.3.0
 platform: ruby
-authors: 
+authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-06-13 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bundler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "1.6"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - &id003 
-      - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: pry
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    requirements: 
-    - *id003
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-description: Examine and compare the tables, columns, constraints and other information that makes up the schema of a PG database
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Examine and compare the tables, columns, constraints and other information
+  that makes up the schema of a PG database
+email:
 - christopher.m.hanks@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - TODO.txt
 - lib/pg_examiner.rb
+- lib/pg_examiner/base.rb
 - lib/pg_examiner/result.rb
-- lib/pg_examiner/result/base.rb
 - lib/pg_examiner/result/column.rb
 - lib/pg_examiner/result/constraint.rb
 - lib/pg_examiner/result/extension.rb
 - lib/pg_examiner/result/function.rb
 - lib/pg_examiner/result/index.rb
+- lib/pg_examiner/result/item.rb
 - lib/pg_examiner/result/language.rb
 - lib/pg_examiner/result/schema.rb
 - lib/pg_examiner/result/table.rb
@@ -79,29 +90,30 @@ files:
 - spec/spec_helper.rb
 - spec/table_spec.rb
 homepage: https://github.com/chanks/pg_examiner
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id003
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id003
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Parse the schemas of Postgres databases in detail
-test_files: 
+test_files:
 - spec/constraint_spec.rb
 - spec/extension_spec.rb
 - spec/function_spec.rb