pg_examiner 0.3.0 → 0.4.0

data/spec/schema_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe PGExaminer do
@@ -49,18 +51,18 @@ describe PGExaminer do
     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']}}
+    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']}}
+    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
+    a = examine <<-SQL, "schema1"
       CREATE SCHEMA schema1;
       CREATE TABLE schema1.test_table (
         a integer,
@@ -68,7 +70,7 @@ describe PGExaminer do
       );
     SQL
 
-    b = examine <<-SQL, :schema2
+    b = examine <<-SQL, "schema2"
       CREATE SCHEMA schema2;
       CREATE TABLE schema2.test_table (
         a integer,
@@ -76,7 +78,7 @@ describe PGExaminer do
       );
     SQL
 
-    c = examine <<-SQL, :schema2
+    c = examine <<-SQL, "schema2"
       CREATE SCHEMA schema2;
       CREATE TABLE schema2.test_table_2 (
         a integer,
@@ -84,7 +86,7 @@ describe PGExaminer do
       );
     SQL
 
-    d = examine <<-SQL, :schema2
+    d = examine <<-SQL, "schema2"
       CREATE SCHEMA schema2;
     SQL
 
@@ -93,7 +95,7 @@ describe PGExaminer do
     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']}}
+    a.diff(c).should == {"tables" => {"added" => ['test_table_2'], "removed" => ['test_table']}}
+    a.diff(d).should == {"tables" => {"removed" => ['test_table']}}
   end
 end

data/spec/sequence_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should be able to tell when a sequence exists" do
+    a = examine ""
+
+    b = examine <<-SQL
+      CREATE SEQUENCE my_sequence;
+    SQL
+
+    c = examine <<-SQL
+      CREATE SEQUENCE my_other_sequence;
+    SQL
+
+    a.diff(b).should == {"schemas"=>{"public"=>{"sequences"=>{"added"=>["my_sequence"]}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"sequences"=>{"added"=>["my_other_sequence"]}}}}
+    b.diff(c).should == {"schemas"=>{"public"=>{"sequences"=>{"added"=>["my_other_sequence"], "removed"=>["my_sequence"]}}}}
+  end
+
+  it "should be able to tell when a table is associated with an index" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        id serial
+      )
+    SQL
+
+    b = examine <<-SQL
+      CREATE SEQUENCE test_table_id_seq;
+
+      CREATE TABLE test_table (
+        id integer NOT NULL default nextval('test_table_id_seq')
+      )
+    SQL
+
+    a.diff(b).should == {}
+
+    # TODO: Add concept of the column owning the sequence?
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'uri'
 require 'pg'
 require 'pry'

data/spec/table_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe PGExaminer do
@@ -21,7 +23,7 @@ describe PGExaminer do
     table.should be_an_instance_of PGExaminer::Result::Table
     table.columns.length.should == 2
 
-    id, body = table.columns # Returned in proper ordering
+    body, id = table.columns # Returned in alphabetical ordering
 
     id.should be_an_instance_of PGExaminer::Result::Column
     id.name.should == 'id'
@@ -85,7 +87,7 @@ describe PGExaminer do
 
     a.should_not == b
 
-    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{:added=>["test_table_b"], :removed=>["test_table_a"]}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"added"=>["test_table_b"], "removed"=>["test_table_a"]}, "sequences"=>{"added"=>["test_table_b_id_seq"], "removed"=>["test_table_a_id_seq"]}}}}
   end
 
   it "should consider tables with current columns in the same order equivalent" do
@@ -136,9 +138,7 @@ describe PGExaminer do
       )
     SQL
 
-    a.should_not == b
-
-    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{}}}}}}
+    a.should == b
   end
 
   it "should consider tables with columns of differing types not equivalent" do
@@ -163,8 +163,8 @@ describe PGExaminer do
     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"}}}}}}}}
+    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
@@ -182,7 +182,7 @@ describe PGExaminer do
 
     a.should_not == b
 
-    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:attndims=>{"0"=>"1"}, :type=>{"int4"=>"_int4"}}}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"columns"=>{"a"=>{"array dimensionality"=>{"0"=>"1"}, "type"=>{"int4"=>"_int4"}}}}}}}}
   end
 
   it "should consider the presence of not-null constraints" do
@@ -200,7 +200,7 @@ describe PGExaminer do
 
     a.should_not == b
 
-    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:attnotnull=>{"f"=>"t"}}}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"columns"=>{"a"=>{"column is marked not-null"=>{"f"=>"t"}}}}}}}}
   end
 
   it "should consider the presence of type-specific data" do
@@ -218,7 +218,7 @@ describe PGExaminer do
 
     a.should_not == b
 
-    a.diff(b).should == {:schemas=>{"public"=>{:tables=>{"test_table"=>{:columns=>{"a"=>{:atttypmod=>{"53"=>"54"}}}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"columns"=>{"a"=>{"datatype information (atttypmod)"=>{"53"=>"54"}}}}}}}}
   end
 
   it "should consider unlogged and temporary tables as different from permanent tables" do
@@ -244,9 +244,9 @@ describe PGExaminer do
     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"]}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"table type (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
@@ -282,8 +282,8 @@ describe PGExaminer do
     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}"}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"table options"=>{nil=>"{fillfactor=90}"}}}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"table options"=>{nil=>"{fillfactor=70}"}}}}}}
+    b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"table options"=>{"{fillfactor=90}"=>"{fillfactor=70}"}}}}}}
   end
 end

data/spec/trigger_spec.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should be able to differentiate between triggers by their names" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig2 BEFORE INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    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
+    a = examine <<-SQL
+      CREATE TABLE test_table_a (
+        a integer
+      );
+
+      CREATE TABLE test_table_b (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table_a FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table_a (
+        a integer
+      );
+
+      CREATE TABLE test_table_b (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table_b FOR EACH ROW EXECUTE PROCEDURE func();
+    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
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func1() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE FUNCTION func2() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func1();
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func1() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE FUNCTION func2() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func2();
+    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
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE UPDATE ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig BEFORE DELETE ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    a.should_not == b
+    a.should_not == c
+    b.should_not == c
+
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"triggers"=>{"trig"=>{"trigger firing conditions (tgtype)"=>{"7"=>"19"}}}}}}}}
+  end
+
+  it "should be able to differentiate between normal triggers and constraint triggers" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE TRIGGER trig AFTER INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE CONSTRAINT TRIGGER trig AFTER INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    a.should_not == b
+
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"added"=>["trig"]}}}}}}
+  end
+
+  it "should be able to differentiate between deferrable and non-deferrable constraint triggers" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE CONSTRAINT TRIGGER trig AFTER INSERT ON test_table FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      CREATE CONSTRAINT TRIGGER trig AFTER INSERT ON test_table DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE func();
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE FUNCTION func() RETURNS trigger AS $$
+        BEGIN
+          NEW.a = 56;
+          RETURN NEW;
+        END;
+      $$
+      LANGUAGE plpgsql;
+
+      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"}}}}}}}}
+  end
+end