pg_examiner 0.3.0 → 0.4.0

data/spec/extension_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe PGExaminer do
@@ -23,7 +25,7 @@ describe PGExaminer do
     plpgsql.name.should == 'plpgsql'
     plpgsql.schema.should be nil
 
-    result1.diff(result2)[:extensions].should == {added: ['citext']}
-    result2.diff(result1)[:extensions].should == {removed: ['citext']}
+    result1.diff(result2)["extensions"].should == {"added"   => ['citext']}
+    result2.diff(result1)["extensions"].should == {"removed" => ['citext']}
   end
 end

data/spec/function_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe PGExaminer do
@@ -30,8 +32,8 @@ describe PGExaminer do
     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"]}}}}
+    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
@@ -74,8 +76,8 @@ describe PGExaminer do
     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"]}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"functions"=>{"add"=>{"function 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"=>{"function 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
@@ -149,7 +151,7 @@ describe PGExaminer do
 
     a.should_not == b
 
-    a.diff(b)[:schemas]['public'][:functions]['add'][:language].should == {'sql' => 'plpgsql'}
+    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
@@ -253,217 +255,4 @@ describe PGExaminer do
     a.should_not == c
     a.should_not == d
   end
-
-  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"=>{:tgtype=>{"7"=>"19"}}}}}}}}
-  end
 end

data/spec/index_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe PGExaminer do
@@ -30,8 +32,8 @@ describe PGExaminer do
     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"]}}}}}}
+    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
@@ -66,9 +68,9 @@ describe PGExaminer do
     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"]}}}}}}}}
+    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
@@ -104,8 +106,8 @@ describe PGExaminer do
     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}}}}}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"indexes"=>{"int_idx"=>{"filter expression"=>{"(a > 0)"=>nil}}}}}}}}
+    b.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"indexes"=>{"int_idx"=>{"filter expression"=>{"(a > 0)"=>nil}}}}}}}}
   end
 
   it "should consider the expressions indexes are on, if any" do
@@ -141,8 +143,8 @@ describe PGExaminer do
     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"]}}}}}}}}
+    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
@@ -174,8 +176,127 @@ describe PGExaminer do
     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"]}}}}}}
+    a.diff(b).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"indexes"=>{"int_idx"=>{"index is unique"=>{"f"=>"t"}}}}}}}}
+    a.diff(c).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"columns"=>{"a"=>{"column is marked not-null"=>{"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"=>{"column is marked not-null"=>{"f"=>"t"}}}, "indexes"=>{"added"=>["test_table_pkey"], "removed"=>["int_idx"]}, "constraints"=>{"added"=>["test_table_pkey"]}}}}}}
+  end
+
+  it "should recognize the difference between a unique index and a unique constraint" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        UNIQUE (a)
+      );
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer UNIQUE
+      );
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a);
+    SQL
+
+    d = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE UNIQUE INDEX test_table_a_key ON test_table (a);
+    SQL
+
+    a.should == b
+    a.should == c
+    a.should_not == d
+
+    a.diff(d).should == {"schemas"=>{"public"=>{"tables"=>{"test_table"=>{"constraints"=>{"removed"=>["test_table_a_key"]}}}}}}
+  end
+
+  it "should recognize the difference between unique indices with different deferrable states" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a);
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) NOT DEFERRABLE;
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) DEFERRABLE;
+    SQL
+
+    d = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) DEFERRABLE INITIALLY IMMEDIATE;
+    SQL
+
+    e = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) DEFERRABLE INITIALLY DEFERRED;
+    SQL
+
+    c2 = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) DEFERRABLE;
+    SQL
+
+    d2 = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) DEFERRABLE INITIALLY IMMEDIATE;
+    SQL
+
+    e2 = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT test_table_a_key UNIQUE (a) DEFERRABLE INITIALLY DEFERRED;
+    SQL
+
+    a.should     == b
+    a.should_not == c
+    a.should_not == d
+    c.should     == d
+    c.should_not == e
+    d.should_not == e
+
+    c.should == c2
+    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"}}}}}}}}
   end
 end

data/spec/language_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe PGExaminer do