pg_examiner 0.1.0

data/spec/constraint_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should consider constraints when determining table equivalency" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        CONSTRAINT con CHECK (a > 0)
+      );
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT con CHECK (a     >     0);
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer CONSTRAINT con CHECK (a > 0)
+      );
+    SQL
+
+    d = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD CONSTRAINT con_two CHECK (a > 0);
+    SQL
+
+    e = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer CHECK (a > 0)
+      );
+    SQL
+
+    f = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+    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
+  end
+
+  it "should consider 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
+      );
+    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 child (
+        parent_id integer,
+        FOREIGN KEY (parent_id) REFERENCES parent ON DELETE CASCADE
+      );
+    SQL
+
+    a.should == b
+    a.should_not == c
+    b.should_not == c
+    b.should_not == d
+    b.should_not == e
+    d.should_not == e
+  end
+
+  it "should consider constraints when determining table equivalency" do
+    a = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        CONSTRAINT con CHECK (a > 0) NOT VALID
+      );
+    SQL
+
+    b = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        CONSTRAINT con CHECK (a > 0)
+      );
+    SQL
+
+    c = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        CONSTRAINT con CHECK (a > 0) NOT VALID
+      );
+
+      ALTER TABLE test_table VALIDATE CONSTRAINT con;
+    SQL
+
+    a.should_not == b
+    a.should_not == c
+    b.should == c
+  end
+end

data/spec/extension_spec.rb

@@ -0,0 +1,26 @@
+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']
+
+    result = examine <<-SQL
+      CREATE EXTENSION citext;
+    SQL
+
+    result.extensions.length.should == 2
+
+    citext, plpgsql = result.extensions # Ordered by name
+
+    citext.should be_an_instance_of PGExaminer::Result::Extension
+    citext.name.should == 'citext'
+    citext.schema.should be_an_instance_of PGExaminer::Result::Schema
+    citext.schema.name.should == 'public'
+
+    plpgsql.should be_an_instance_of PGExaminer::Result::Extension
+    plpgsql.name.should == 'plpgsql'
+    plpgsql.schema.should be nil
+  end
+end

data/spec/function_spec.rb

@@ -0,0 +1,452 @@
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should be able to differentiate between functions by their names" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    c = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add_numbers(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    a.should == b
+    a.should_not == c
+    b.should_not == c
+  end
+
+  it "should be able to differentiate between functions by their argument types" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer, three integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    c = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer, three integer[]) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    d = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer, VARIADIC three integer[]) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    a.should_not == b
+    a.should_not == c
+    a.should_not == d
+    b.should_not == c
+    b.should_not == d
+    c.should_not == d
+  end
+
+  it "should be able to differentiate between functions by their argument defaults" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer DEFAULT 42) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    a.should_not == b
+  end
+
+  it "should be able to differentiate between functions by their return types" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT (one + two)::integer
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS bigint
+      AS $$
+        SELECT (one + two)::bigint
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    c = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS smallint
+      AS $$
+        SELECT (one + two)::smallint
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    a.should_not == b
+    a.should_not == c
+    b.should_not == c
+  end
+
+  it "should be able to differentiate between functions by their languages" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        BEGIN
+          RETURN one + two;
+        END
+      $$
+      LANGUAGE PLPGSQL;
+    SQL_FUNCTION
+
+    a.should_not == b
+  end
+
+  it "should be able to differentiate between functions by their other flags" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL
+      COST 0.1;
+    SQL_FUNCTION
+
+    c = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL
+      RETURNS NULL ON NULL INPUT;
+    SQL_FUNCTION
+
+    d = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL
+      STRICT;
+    SQL_FUNCTION
+
+    a.should_not == b
+    a.should_not == c
+    a.should_not == d
+  end
+
+  it "should be able to differentiate between functions by their definitions" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT two + one
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    a.should_not == b
+  end
+
+  it "should be able to differentiate between functions by their volatility" do
+    a = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL;
+    SQL_FUNCTION
+
+    b = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL
+      VOLATILE;
+    SQL_FUNCTION
+
+    c = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL
+      STABLE;
+    SQL_FUNCTION
+
+    d = examine <<-SQL_FUNCTION
+      CREATE FUNCTION add(one integer, two integer) RETURNS integer
+      AS $$
+        SELECT one + two
+      $$
+      LANGUAGE SQL
+      IMMUTABLE;
+    SQL_FUNCTION
+
+    a.should == b
+    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
+  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
+  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
+  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
+  end
+end