pg_examiner 0.1.0

data/spec/index_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should consider indexes when determining equivalency" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        id integer
+      );
+
+      CREATE INDEX int_idx ON test_table(id);
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        id integer
+      );
+
+      CREATE INDEX int_idx ON test_table(id);
+    SQL
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        id integer
+      );
+
+      CREATE INDEX int_idx2 ON test_table(id);
+    SQL
+
+    one.should == two
+    one.should_not == three
+    two.should_not == three
+  end
+
+  it "should consider the columns indexes are on when determining equivalency" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        b integer
+      );
+
+      CREATE INDEX int_idx ON test_table(a);
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        b integer
+      );
+
+      CREATE INDEX int_idx ON test_table(b);
+    SQL
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        b integer
+      );
+
+      CREATE INDEX int_idx ON test_table(a, b);
+    SQL
+
+    one.should_not == two
+    one.should_not == three
+    two.should_not == three
+  end
+
+  it "should consider the filters indexes have when determining equivalency" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE INDEX int_idx ON test_table(a) WHERE a > 0;
+    SQL
+
+    one.schemas.first.tables.first.indexes.first.row['filter'].should == '(a > 0)'
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE INDEX int_idx ON test_table(a) WHERE a > 0;
+    SQL
+
+    two.schemas.first.tables.first.indexes.first.row['filter'].should == '(a > 0)'
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE INDEX int_idx ON test_table(a);
+    SQL
+
+    one.should == two
+    one.should_not == three
+    two.should_not == three
+  end
+
+  it "should consider the expressions indexes are on, if any" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a text
+      );
+
+      CREATE INDEX text_idx ON test_table(lower(a));
+    SQL
+
+    one.schemas.first.tables.first.indexes.first.expression.should == 'lower(a)'
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a text
+      );
+
+      CREATE INDEX text_idx ON test_table(LOWER(a));
+    SQL
+
+    two.schemas.first.tables.first.indexes.first.expression.should == 'lower(a)'
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a text
+      );
+
+      CREATE INDEX text_idx ON test_table(a);
+    SQL
+
+    one.should == two
+    one.should_not == three
+    two.should_not == three
+  end
+
+  it "should consider the uniqueness and primary key status of an index, if any" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE INDEX int_idx ON test_table(a);
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      CREATE UNIQUE INDEX int_idx ON test_table(a);
+    SQL
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD PRIMARY KEY (a);
+    SQL
+
+    one.should_not == two
+    one.should_not == three
+    two.should_not == three
+  end
+end

data/spec/language_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should be able to examine the languages loaded into the db" do
+    result = examine("SELECT 1")
+    result.should be_an_instance_of PGExaminer::Result
+    result.languages.map(&:name).should == %w(c internal plpgsql sql) # Different for other installations?
+  end
+end

data/spec/schema_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should be able to examine the public schema" do
+    result = examine("SELECT 1")
+    result.should be_an_instance_of PGExaminer::Result
+
+    result.schemas.length.should == 1
+    schema = result.schemas.first
+    schema.should be_an_instance_of PGExaminer::Result::Schema
+    schema.name.should == 'public'
+    schema.tables.should == []
+  end
+
+  it "should detect other user-added schemas" do
+    result = examine <<-SQL
+      CREATE SCHEMA my_schema;
+    SQL
+
+    result.schemas.length.should == 2
+    result.schemas.map(&:name).should == %w(my_schema public)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'uri'
+require 'pg'
+require 'pry'
+require 'pg_examiner'
+
+uri = URI.parse(ENV['DATABASE_URL'] || 'postgres://postgres:@localhost/pg_examiner_test')
+CONNECTION = PG::Connection.open :host     => uri.host,
+                                 :user     => uri.user,
+                                 :password => uri.password,
+                                 :port     => uri.port || 5432,
+                                 :dbname   => uri.path[1..-1]
+
+RSpec.configure do |config|
+  def examine(sql)
+    execute "BEGIN"
+    execute(sql)
+    PGExaminer.examine(CONNECTION)
+  ensure
+    execute "ROLLBACK"
+  end
+
+  def execute(*args)
+    CONNECTION.async_exec(*args).to_a
+  end
+end

data/spec/table_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+describe PGExaminer do
+  it "should be able to tell when a table exists" do
+    result = examine <<-SQL
+      CREATE TABLE test_table (
+        id serial,
+        body text
+      )
+    SQL
+
+    result.should be_an_instance_of PGExaminer::Result
+    result.schemas.length.should == 1
+
+    schema = result.schemas.first
+    schema.should be_an_instance_of PGExaminer::Result::Schema
+    schema.name.should == 'public'
+    schema.tables.length.should == 1
+
+    table = schema.tables.first
+    table.should be_an_instance_of PGExaminer::Result::Table
+    table.columns.length.should == 2
+
+    id, body = table.columns # Returned in proper ordering
+
+    id.should be_an_instance_of PGExaminer::Result::Column
+    id.name.should == 'id'
+    id.type.should == 'int4'
+    id.default.should == "nextval('test_table_id_seq'::regclass)"
+
+    body.should be_an_instance_of PGExaminer::Result::Column
+    body.name.should == 'body'
+    body.type.should == 'text'
+    body.default.should == nil
+  end
+
+  it "should order tables by name" do
+    result = examine <<-SQL
+      CREATE TABLE table_a ();
+      CREATE TABLE table_b ();
+    SQL
+
+    result.should be_an_instance_of PGExaminer::Result
+    result.schemas.length.should == 1
+
+    schema = result.schemas.first
+    schema.should be_an_instance_of PGExaminer::Result::Schema
+    schema.name.should == 'public'
+    schema.tables.length.should == 2
+    schema.tables.map(&:name).should == %w(table_a table_b)
+  end
+
+  it "should consider equivalent tables equivalent" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        id serial,
+        body text
+      )
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        id serial,
+        body text
+      )
+    SQL
+
+    one.should == two
+  end
+
+  it "should consider differently-named tables non-equivalent" do
+    one = examine <<-SQL
+      CREATE TABLE test_table_a (
+        id serial,
+        body text
+      )
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table_b (
+        id serial,
+        body text
+      )
+    SQL
+
+    one.should_not == two
+  end
+
+  it "should consider tables with current columns in the same order equivalent" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        b integer,
+        c integer
+      );
+
+      ALTER TABLE test_table DROP COLUMN b;
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        c integer
+      );
+    SQL
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+
+      ALTER TABLE test_table ADD COLUMN c integer;
+    SQL
+
+    one.should == two
+    one.should == three
+    two.should == three
+  end
+
+  it "should consider tables with columns in differing orders not equivalent" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        b integer,
+        c integer
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer,
+        c integer,
+        b integer
+      )
+    SQL
+
+    one.should_not == two
+  end
+
+  it "should consider tables with columns of differing types not equivalent" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a text
+      )
+    SQL
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer default 5
+      );
+    SQL
+
+    one.should_not == two
+    one.should_not == three
+  end
+
+  it "should consider array types as different from scalar types" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer[]
+      )
+    SQL
+
+    one.should_not == two
+  end
+
+  it "should consider the presence of not-null constraints" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer not null
+      )
+    SQL
+
+    one.should_not == two
+  end
+
+  it "should consider the presence of type-specific data" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a varchar(49)
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a varchar(50)
+      )
+    SQL
+
+    one.should_not == two
+  end
+
+  it "should consider unlogged and temporary tables as different from permanent tables" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE UNLOGGED TABLE test_table (
+        a integer
+      )
+    SQL
+
+    three = examine <<-SQL
+      CREATE TEMPORARY TABLE test_table (
+        a integer
+      )
+    SQL
+
+    one.should_not == two
+    one.should_not == three
+    two.should_not == three
+  end
+
+  it "should consider additional specified options when comparing tables" do
+    one = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      );
+    SQL
+
+    two = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      )
+      WITH (fillfactor=90);
+    SQL
+
+    three = examine <<-SQL
+      CREATE TABLE test_table (
+        a integer
+      )
+      WITH (fillfactor=70);
+    SQL
+
+    four = 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
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: pg_examiner
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Chris Hanks
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-06-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !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"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  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: 
+- christopher.m.hanks@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.txt
+- lib/pg_examiner.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/language.rb
+- lib/pg_examiner/result/schema.rb
+- lib/pg_examiner/result/table.rb
+- lib/pg_examiner/result/trigger.rb
+- lib/pg_examiner/version.rb
+- pg_examiner.gemspec
+- spec/constraint_spec.rb
+- spec/extension_spec.rb
+- spec/function_spec.rb
+- spec/index_spec.rb
+- spec/language_spec.rb
+- spec/schema_spec.rb
+- spec/spec_helper.rb
+- spec/table_spec.rb
+homepage: https://github.com/chanks/pg_examiner
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Parse the schemas of Postgres databases in detail
+test_files: 
+- spec/constraint_spec.rb
+- spec/extension_spec.rb
+- spec/function_spec.rb
+- spec/index_spec.rb
+- spec/language_spec.rb
+- spec/schema_spec.rb
+- spec/spec_helper.rb
+- spec/table_spec.rb