pgdiff 1.0.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68b437ba9b29ffad626470871d071797eb01db9e0ef80e46036ac894cd389ee7
-  data.tar.gz: ab86aaa142d6e7f5f8f883c249edf46054524e820c589c10c5b9066a207bbb9c
+  metadata.gz: 633c03ef3f939faad6c41e2714fa2ed0913a8dcae53dffb55464dd589d1819a9
+  data.tar.gz: ec25fe04644ce6e75de45b6445f83962c97f64f63c4eb0f5adf2821d583c1579
 SHA512:
-  metadata.gz: dbf27f416b4aa28071de9754ad81d626ce3d3f1680b5db41bc4779042cf01fc1b51609b68be93dc0be29fc503e67d2a89b31fd96a0d26926595683795de222d5
-  data.tar.gz: 2e6ab376273507606fa28a70e8116d9522353524129d63b4d98137aead8c9855d772a0b09dda218049db16f64aa4fa490a5ed6e0ded28292a01a96cbf8e2968f
+  metadata.gz: 703cd30da3b358aef33b409d83022a371f89b8810a0305dce5be657acdff03758ab4dedc5687c1b9350583ffea1440d5396c673ba2c45dc545f172e3b8d05233
+  data.tar.gz: 64147cd571163edd3a6ba14ca9bee9a05d1d37a44796838ba5f41700973c183dceb3c131f4753a4fe1328f78ab55a4de02cd0e092c15a05a8708605474aed051

data/CHANGELOG.rdoc

@@ -1,7 +1,12 @@
 = Changelog
 
-=== 1.0.1 (May 16, 2018)
-* Stop using deprecated PGConn class
+=== 2.0.1 (June 2, 2023)
+* Fix incorrect quoting of system schemas
+
+=== 2.0.0 (June 1, 2023)
+* Add new command line arguments
+* Significantly improve performance
+* Rewrite to imporove modularity
 
 === 1.0.0 (January 31, 2015)
 * Improve constraint checking

data/README.rdoc

@@ -2,15 +2,14 @@
 
 == Overview
 
-This ruby gem provides a pgdiff script that compares two PostgreSQL databases and generates SQL statements to make
-their structures the same. The original version was posted at http://www.dzone.com/snippets/pgdiff-compare-two-postgresql.
+This pgdiff gem compares two PostgreSQL databases and generates SQL statements to update the source database to match the target datbase.
 
 The script detects differences in:
 
-  * Domains
   * Schemas
+  * Extensions
+  * Domains
   * Tables
-  * Table field order
   * Sequences
   * Views
   * Constraints
@@ -21,29 +20,45 @@ The script detects differences in:
 
 Two objects with the same name are considered equal if they have the same definitions.
 
-pgdiff does not currently compare ownership, user rights, object dependencies, table inheritance, type casts, aggregates
-or operators.  Patches are welcome to add this functionality.
+pgdiff does not currently compare ownership, user rights, object dependencies, table inheritance, type casts, aggregates or operators.  Patches are welcome to add this functionality.
 
 == Installation
 
-Install pgdiff using Ruby Gems:
+Install pgdiff:
 
-  gem install "pgdiff"
+  gem install pgdiff
 
 == Usage
 
 To use pgdiff open a command prompt and runn the following command:
 
-  pg_diff "source_connection_string" "destination_connection_string"
+  pg_diff --source "source_connection_string" --target "destination_connection_string"
+
+The format of the connection strings are  documented in the Ruby PG gem at https://www.rubydoc.info/gems/pg/PG/Connection.new.
+
+For eample:
+    "host=localhost dbname=a_database user=a_user password=a_password"
+
+== Ignore Schemas
+By default, pgdiff will not process the following system schemas:
 
-The format of the two connection strings is documented in the Ruby pg gem.  For more information
-see http://www.rubydoc.info/gems/pg/PG/Connection:initialize
+    * pg_catalog
+    * pg_toast
+    * information_schema
+
+You may specify additions schemas to ingore using the `--ingore-schemas` flag:
+
+    pgdiff --ignore_schemas=schema1,schema2
 
 == Output
+By default, pgdiff will output results to stdout. You may also specify a file path via the `--output` command line parameter:
+
+    pgdiff --ouput=/tmp/diff.sql
+
+You can then run this sql script against your database.
 
-pgdiff will output the necesssary sql statements to update the source database to have the same structure
-as the destination database.  PLEASE VERIFY the accuracy of the generated sql statements before running them,
-it is always possible the script has bugs.
+== Run The Script
+The sql script generated by pgdiff will change your database. It is YOUR responsibility to verify the script before running it. pgdiff may have bugs, which could result in catastrophic, unrecoverable changes to your database. DO NOT RUN THIS ON A PRODUCTION DATABASE WITHOUT BACKING UP AND TESTING FIRST.
 
 == Support
 

data/Rakefile

@@ -2,6 +2,7 @@
 
 require 'rubygems'
 require 'rubygems/package_task'
+require 'rake/testtask'
 
 GEM_NAME = 'pgdiff'
 
@@ -12,4 +13,13 @@ spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
 Gem::PackageTask.new(spec) do |pkg|
   pkg.package_dir = 'pkg'
   pkg.need_tar    = false
-end
+end
+
+Rake::TestTask.new do |task|
+  task.libs << "test"
+  task.test_files = FileList['test/test*.rb']
+  task.verbose = true
+end
+
+# Add task to create test database
+load 'test/fixtures/database.rake'

data/bin/pgdiff

@@ -13,16 +13,52 @@
 # ./pg_diff source_connection_string destination_connection_string
 #
 # The format of the connection strings is documented in the Ruby pg gem
-# at http://www.rubydoc.info/gems/pg/PG/Connection:initialize.
+# at https://www.rubydoc.info/gems/pg/PG/Connection.new
+
+lib_path = File.expand_path(File.join(__dir__, '..', 'lib'))
+$LOAD_PATH.unshift(File.expand_path(lib_path))
 
 require 'pg'
 require 'pgdiff'
+require 'optparse'
+require 'ostruct'
+
+options = OpenStruct.new
+options.source = nil
+options.target = nil
+options.ignore_schemas = []
+
+args = OptionParser.new do |parser|
+  parser.version = PgDiff::VERSION
+
+  parser.banner = "Usage: pgdiff --source --target"
+
+  parser.on("-s", "--source=connection_string", "Source connection string. See https://www.rubydoc.info/gems/pg/PG/Connection.new") do |source|
+    options.source = source
+  end
+
+  parser.on("-t", "--target=connection_string", "Target connection string. See see https://www.rubydoc.info/gems/pg/PG/Connection.new") do |target|
+    options.target = target
+  end
+
+  parser.on("--ignore_schemas=schema1,schema2", "Schemas to ignore. Comma separated string") do |ignore_schemas|
+    options.ignore_schemas = ignore_schemas.split(',').map {|schema_name| schema_name.strip}
+  end
+
+  parser.on("--output=file_path", "Save output to file. Otherwise printed to stdout") do |path|
+    options.path = path
+  end
 
-if ARGV.length != 2
-  raise(ArgumentError, "You must specify two arguments - a source and target db connection string.  For " +
-                       "more information about how to format connection strings see http://www.rubydoc.info/gems/pg/PG/Connection:initialize")
-end
+  parser.on("-h", "--help", "Prints this help") do
+    puts parser
+    exit
+  end
+end.parse!
 
-diff = PgDiff::Diff.new(ARGV[0], ARGV[1])
+output = if options.path.nil?
+           STDOUT
+         else
+           File.open(options.path)
+         end
+diff = PgDiff::Diff.new(output, options.source, options.target, ignore_schemas: options.ignore_schemas)
 diff.run_compare
-puts diff.output

data/lib/pgdiff.rb

@@ -1,9 +1,21 @@
-require 'database'
-require 'table'
-require 'attribute'
-require 'view'
-require 'sequence'
-require 'rule'
-require 'function'
-require 'trigger'
-require 'diff'
+require 'set'
+require 'pg'
+require 'pgdiff/attribute'
+require 'pgdiff/attributes'
+require 'pgdiff/collation'
+require 'pgdiff/constraint'
+require 'pgdiff/constraints'
+require 'pgdiff/database'
+require 'pgdiff/diff'
+require 'pgdiff/domain'
+require 'pgdiff/extension'
+require 'pgdiff/function'
+require 'pgdiff/index'
+require 'pgdiff/indexes'
+require 'pgdiff/rule'
+require 'pgdiff/schema'
+require 'pgdiff/sequence'
+require 'pgdiff/table'
+require 'pgdiff/trigger'
+require 'pgdiff/view'
+require 'pgdiff/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgdiff
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Charlie Savage
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-05-16 00:00:00.000000000 Z
+date: 2023-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -16,19 +16,75 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'Compares two PostgreSQL databases and generates the SQL statements needed
   to make their structure the same.
 
-'
-email: 
+  '
+email:
 executables:
 - pgdiff
 extensions: []
@@ -38,21 +94,12 @@ files:
 - README.rdoc
 - Rakefile
 - bin/pgdiff
-- lib/attribute.rb
-- lib/database.rb
-- lib/diff.rb
-- lib/function.rb
 - lib/pgdiff.rb
-- lib/rule.rb
-- lib/sequence.rb
-- lib/table.rb
-- lib/trigger.rb
-- lib/view.rb
 homepage: https://github.com/cfis/pgdiff.git
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,16 +107,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Provides a ruby script that compares two PostgreSQL databases and generates
   the SQL statements needed to make their structure the same.  The original version

data/lib/attribute.rb

@@ -1,23 +0,0 @@
-module PgDiff
-  class Attribute
-    attr_accessor :name, :type_def, :notnull, :default
-
-    def initialize(name, typedef, notnull, default)
-      @name = name
-      @type_def = typedef
-      @notnull = notnull
-      @default = default
-    end
-
-    def definition
-      out = ['    ', @name,  @type_def]
-      out << 'NOT NULL' if @notnull
-      out << 'DEFAULT ' + @default if @default
-      out.join(" ")
-    end
-
-    def == (other)
-      definition == other.definition
-    end
-  end
-end

data/lib/database.rb

@@ -1,112 +0,0 @@
-module PgDiff
-  class Database
-    attr_accessor :tables, :views, :sequences, :schemas, :domains, :rules, :functions, :triggers
-
-    def initialize(conn)
-      cls_query = <<-EOT
-        SELECT n.nspname, c.relname, c.relkind
-        FROM pg_catalog.pg_class c
-        LEFT JOIN pg_catalog.pg_user u ON u.usesysid = c.relowner
-        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-        WHERE c.relkind IN ('r','S','v')
-        AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema')
-        ORDER BY 1,2;
-      EOT
-      @views = {}
-      @tables = {}
-      @sequences = {}
-      @schemas = {}
-      @domains = {}
-      @functions = {}
-      @rules = {}
-      @triggers = {}
-
-      conn.query(cls_query).each do |tuple|
-        schema = tuple['nspname']
-        relname = tuple['relname']
-        relkind = tuple['relkind']
-        case relkind
-          when 'r'
-            @tables["#{schema}.#{relname}"] = Table.new(conn, schema, relname)
-          when 'v'
-            @views["#{schema}.#{relname}"] = View.new(conn, schema, relname)
-          when 'S'
-            @sequences["#{schema}.#{relname}"] = Sequence.new(conn, schema, relname)
-        end
-      end
-
-      domain_qry = <<-EOT
-      SELECT n.nspname, t.typname,  pg_catalog.format_type(t.typbasetype, t.typtypmod) || ' ' ||
-         CASE WHEN t.typnotnull AND t.typdefault IS NOT NULL THEN 'not null default '||t.typdefault
-              WHEN t.typnotnull AND t.typdefault IS NULL THEN 'not null'
-              WHEN NOT t.typnotnull AND t.typdefault IS NOT NULL THEN 'default '|| t.typdefault
-              ELSE ''
-         END AS def
-      FROM pg_catalog.pg_type t
-         LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-      WHERE t.typtype = 'd'
-      ORDER BY 1, 2
-      EOT
-      conn.query(domain_qry).each do |tuple|
-        schema = tuple['nspname']
-        typename = tuple['typname']
-        value = tuple['def']
-        @domains["#{schema}.#{typename}"] = value
-      end
-
-      schema_qry = <<-EOT
-        select nspname from pg_namespace
-      EOT
-      conn.query(schema_qry).each do |tuple|
-        schema = tuple['nspname']
-        @schemas[schema] = schema
-      end
-
-      func_query = <<-EOT
-       SELECT proname AS function_name
-       , nspname AS namespace
-       , lanname AS language_name
-       , pg_catalog.obj_description(pg_proc.oid, 'pg_proc') AS comment
-       , proargtypes AS function_args
-       , proargnames AS function_arg_names
-       , prosrc AS source_code
-       , proretset AS returns_set
-       , prorettype AS return_type,
-       provolatile, proisstrict, prosecdef
-       FROM pg_catalog.pg_proc
-       JOIN pg_catalog.pg_language ON (pg_language.oid = prolang)
-       JOIN pg_catalog.pg_namespace ON (pronamespace = pg_namespace.oid)
-       JOIN pg_catalog.pg_type ON (prorettype = pg_type.oid)
-       WHERE pg_namespace.nspname !~ 'pg_catalog|information_schema'
-       AND proname != 'plpgsql_call_handler'
-       AND proname != 'plpgsql_validator'
-      EOT
-
-      conn.exec(func_query).each_with_index do |tuple, i|
-        func = Function.new(conn, tuple)
-        @functions[func.signature] = func
-      end
-
-      rule_query = <<-EOT
-      select  schemaname || '.' ||  tablename || '.' || rulename as rule_name,
-              schemaname || '.' ||  tablename as tab_name,
-        rulename, definition
-      from pg_rules
-      where schemaname !~ 'pg_catalog|information_schema'
-      EOT
-      conn.exec(rule_query).each do |tuple|
-        @rules[tuple['rule_name']] = Rule.new(tuple['tab_name'], tuple['rulename'], tuple['definition'])
-      end
-
-      trigger_query =  <<-EOT
-      select nspname || '.' || relname as tgtable, tgname, pg_get_triggerdef(t.oid) as tg_def
-      from pg_trigger t join pg_class c ON (tgrelid = c.oid ) JOIN pg_namespace n ON (c.relnamespace = n.oid)
-      where not tgisinternal
-      and nspname !~ 'pg_catalog|information_schema'
-      EOT
-      conn.exec(trigger_query).each do |tuple|
-        @triggers[tuple['tgtable'] + "." + tuple['tgname']] = Trigger.new(tuple['tgtable'], tuple['tgname'], tuple['tg_def'])
-      end
-    end
-  end
-end

data/lib/diff.rb

@@ -1,345 +0,0 @@
-module PgDiff
-  class Diff
-    def initialize(old_db_spec, new_db_spec)
-      @old_conn = PG::Connection.new(old_db_spec)
-      @new_conn = PG::Connection.new(new_db_spec)
-      @sections = [
-        :domains_drop,
-        :domains_create,
-        :schemas_drop,
-        :schemas_create,
-        :tables_drop,
-        :tables_change,
-        :tables_create,
-        :sequences_drop,
-        :sequences_create,
-        :views_drop,
-        :views_create,
-        :constraints_drop,
-        :constraints_change,
-        :constraints_create,
-        :indices_drop,
-        :indices_create,
-        :functions_drop,
-        :functions_create ,
-        :triggers_drop,
-        :triggers_create ,
-        :rules_drop,
-        :rules_create
-      ]
-      @script = {}
-      @sections.each {|s| @script[s] = []}
-    end
-
-    def run_compare
-      @old_database = Database.new(@old_conn)
-      @new_database = Database.new(@new_conn)
-      compare_schemas
-      compare_domains
-      compare_sequences
-      compare_triggers_drop
-      compare_rules_drop
-      compare_views_drop
-      compare_table_attrs
-      compare_views_create
-      compare_functions
-      compare_rules_create
-      compare_triggers_create
-      compare_table_constraints
-    end
-
-    def add_script(section, statement)
-      @script[section] << statement
-    end
-
-    def compare_schemas
-      @old_database.schemas.keys.each do |name|
-        add_script(:schemas_drop ,  "DROP SCHEMA #{name};") unless @new_database.schemas.has_key?(name)
-      end
-      @new_database.schemas.keys.each do |name|
-        add_script(:schemas_create ,  "CREATE SCHEMA #{name};") unless @old_database.schemas.has_key?(name)
-      end
-    end
-
-    def compare_domains
-      @old_database.domains.keys.each do |name|
-        add_script(:domains_drop ,  "DROP DOMAIN #{name} CASCADE;") unless @new_database.domains.has_key?(name)
-      end
-      @new_database.domains.each do |name, df|
-        add_script(:domains_create ,  "CREATE DOMAIN #{name} AS #{df};") unless @old_database.domains.has_key?(name)
-        old_domain = @old_database.domains[name]
-        if old_domain && old_domain != df
-           add_script(:domains_drop, "DROP DOMAIN #{name} CASCADE;")
-           add_script(:domains_create,  "-- [changed domain] :")
-           add_script(:domains_create,  "-- OLD: #{old_domain}")
-           add_script(:domains_create,  "CREATE DOMAIN #{name} AS #{df};")
-        end
-      end
-    end
-
-    def compare_sequences
-      @old_database.sequences.keys.each do |name|
-        add_script(:sequences_drop ,  "DROP SEQUENCE #{name} CASCADE;") unless @new_database.sequences.has_key?(name)
-      end
-      @new_database.sequences.keys.each do |name|
-        add_script(:sequences_create ,  "CREATE SEQUENCE #{name};") unless @old_database.sequences.has_key?(name)
-      end
-    end
-
-    def compare_functions
-      @old_database.functions.keys.each do |name|
-        add_script(:functions_drop ,  "DROP FUNCTION #{name} CASCADE;") unless @new_database.functions.has_key?(name)
-      end
-      @new_database.functions.each do |name, func|
-        add_script(:functions_create ,   func.definition) unless @old_database.functions.has_key?(name)
-        old_function = @old_database.functions[name]
-        if old_function && old_function.definition != func.definition
-          add_script(:functions_create , '-- [changed function] :')
-          add_script(:functions_create , '-- OLD :')
-          add_script(:functions_create ,  old_function.definition.gsub(/^/, "-->  ") )
-          add_script(:functions_create ,   func.definition)
-        end
-      end
-    end
-
-    def compare_rules_drop
-      @old_database.rules.each do |name, rule|
-        add_script(:rules_drop ,  "DROP RULE #{rule.name} ON #{rule.table_name} CASCADE;") unless @new_database.rules.has_key?(name)
-      end
-    end
-
-    def compare_rules_create
-      @new_database.rules.each do |name, rule|
-        add_script(:rules_create ,   rule.definition) unless @old_database.rules.has_key?(name)
-        old_rule = @old_database.rules[name]
-        if old_rule && old_rule != rule
-          add_script(:rules_drop ,  "DROP RULE #{rule.name} ON #{rule.table_name} CASCADE;")
-          add_script(:rules_create ,  "-- [changed rule] :")
-          add_script(:rules_create ,  "-- OLD: #{old_rule.definition}")
-          add_script(:rules_create ,   rule.definition )
-        end
-      end
-    end
-
-    def compare_triggers_drop
-      @old_database.triggers.each do |name, trigger|
-        add_script(:triggers_drop ,  "DROP trigger #{trigger.name} ON #{trigger.table_name} CASCADE;") unless @new_database.triggers.has_key?(name)
-      end
-    end
-
-    def compare_triggers_create
-      @new_database.triggers.each do |name, trigger|
-        add_script(:triggers_create ,   trigger.definition) unless @old_database.triggers.has_key?(name)
-        old_trigger = @old_database.triggers[name]
-        if old_trigger && old_trigger != trigger
-          add_script(:triggers_drop ,  "DROP trigger #{trigger.name} ON #{trigger.table_name} CASCADE;")
-          add_script(:triggers_create ,  "-- [changed trigger] :")
-          add_script(:triggers_create ,  "-- OLD #{old_trigger.definition}")
-          add_script(:triggers_create ,   trigger.definition)
-        end
-      end
-    end
-
-    def compare_views_drop
-      @old_database.views.keys.each do |name|
-        add_script(:views_drop ,  "DROP VIEW #{name};") unless @new_database.views.has_key?(name)
-      end
-    end
-
-    def compare_views_create
-      @new_database.views.each do |name, df|
-        add_script(:views_create ,   df.definition) unless @old_database.views.has_key?(name)
-        old_view = @old_database.views[name]
-        if old_view && df.definition != old_view.definition
-          add_script(:views_drop ,  "DROP VIEW #{name};")
-          add_script(:views_create ,  "-- [changed view] :")
-          add_script(:views_create ,  "-- #{old_view.definition.gsub(/\n/, ' ')}")
-          add_script(:views_create ,  df.definition)
-        end
-      end
-    end
-
-    def compare_table_attrs
-      @old_database.tables.each do |name, table|
-        add_script(:tables_drop, "DROP TABLE #{name} CASCADE;") unless @new_database.tables.has_key?(name)
-      end
-      @to_compare = []
-      @new_database.tables.each do |name, table|
-        unless @old_database.tables.has_key?(name)
-          add_script(:tables_create ,  table.table_creation)
-          add_script(:indices_create ,  table.index_creation) unless table.indexes.empty?
-          @to_compare << name
-        else
-          diff_attributes(@old_database.tables[name], table)
-          diff_indexes(@old_database.tables[name], table)
-          @to_compare << name
-        end
-      end
-    end
-
-    def compare_table_constraints
-      @c_check = []
-      @c_primary = []
-      @c_unique = []
-      @c_foreign = []
-      @to_compare.each do |name|
-        if @old_database.tables[name]
-          diff_constraints(@old_database.tables[name], @new_database.tables[name])
-        else
-          @new_database.tables[name].constraints.each do |cname, cdef|
-            add_cnstr(name,  cname, cdef)
-          end
-        end
-      end
-      @script[:constraints_create] += @c_check
-      @script[:constraints_create] += @c_primary
-      @script[:constraints_create] += @c_unique
-      @script[:constraints_create] += @c_foreign
-    end
-
-    def output
-      out = []
-      @sections.each do |sect|
-        if @script[sect].empty?
-           out << "-- [SKIP SECTION : #{sect.to_s.upcase}] : no changes\n"
-        else
-           out << "-- [START SECTION : #{sect.to_s.upcase}]"
-           out += @script[sect]
-           out << "-- [END SECTION : #{sect.to_s.upcase}]\n"
-        end
-      end
-      out.join("\n")
-    end
-
-    def diff_attributes(old_table, new_table)
-      dropped = []
-      added   = []
-      changed = []
-
-      order = []
-      old_table.attributes.keys.each do |attname|
-        if new_table.has_attribute?(attname)
-          changed << attname if old_table.attributes[attname] != new_table.attributes[attname]
-        else
-          dropped << attname
-        end
-      end
-
-      old_table.attributes.keys.each do |attname|
-        if new_table.has_attribute?(attname)
-          old_index = old_table.attribute_index(attname)
-          new_index = new_table.attribute_index(attname)
-          order << attname if old_index != new_index
-        end
-      end
-      new_table.attributes.keys.each do |attname|
-        added << attname unless old_table.has_attribute?(attname)
-      end
-      add_script(:tables_change ,  "--  [#{old_table.name}] dropped attributes") unless dropped.empty?
-      dropped.each do |attname|
-        add_script(:tables_change ,  "ALTER TABLE #{old_table.name} DROP COLUMN #{attname} CASCADE;")
-      end
-      add_script(:tables_change ,  "--  [#{old_table.name}] added attributes") unless added.empty?
-      added.each do |attname|
-        add_script(:tables_change ,  "ALTER TABLE #{old_table.name} ADD COLUMN #{new_table.attributes[attname].definition};")
-      end
-      add_script(:tables_change ,  "--  [#{old_table.name}] changed attributes") unless changed.empty?
-      changed.each do |attname|
-        old_att = old_table.attributes[attname]
-        new_att = new_table.attributes[attname]
-        add_script(:tables_change ,  "-- attribute: #{attname}")
-        add_script(:tables_change ,  "-- OLD : #{old_att.definition}")
-        add_script(:tables_change ,  "-- NEW : #{new_att.definition}")
-        if old_att.type_def != new_att.type_def
-          add_script(:tables_change ,  "ALTER TABLE #{old_table.name} ALTER COLUMN #{attname} TYPE #{new_att.type_def};")
-        end
-        if old_att.default != new_att.default
-          if new_att.default.nil?
-            add_script(:tables_change ,  "ALTER TABLE #{old_table.name} ALTER COLUMN #{attname} DROP DEFAULT;")
-          else
-            add_script(:tables_change ,  "ALTER TABLE #{old_table.name} ALTER COLUMN #{attname} SET DEFAULT #{new_att.default};")
-          end
-        end
-        if old_att.notnull != new_att.notnull
-          add_script(:tables_change ,  "ALTER TABLE #{old_table.name} ALTER COLUMN #{attname} #{new_att.notnull ? 'SET' : 'DROP'} NOT NULL;")
-        end
-      end
-
-      add_script(:tables_change ,   "--  [#{old_table.name}] attribute order changed") unless order.empty?
-      order.each do |attname|
-        add_script(:tables_change , "     #{attname}.  Old index: #{old_table.attribute_index(attname)}, New index: #{new_table.attribute_index(attname)}")
-      end
-    end
-
-    def diff_constraints(old_table, new_table)
-      dropped = []
-      added   = []
-      changed = []
-
-      old_table.constraints.keys.each do |conname|
-        if new_table.has_constraint?(conname)
-          if old_table.constraints[conname] != new_table.constraints[conname]
-            changed << conname
-          end
-        else
-          dropped << conname
-        end
-      end
-
-      new_table.constraints.keys.each do |conname|
-        added << conname unless old_table.has_constraint?(conname)
-      end
-
-      dropped.each do |name|
-        add_script(:constraints_drop ,  "ALTER TABLE #{old_table.name} DROP CONSTRAINT #{name};")
-      end
-
-      added.each do |name|
-        add_cnstr(old_table.name,  name, new_table.constraints[name])
-      end
-
-      changed.each do |name|
-        add_script(:constraints_change,
-                   "-- Previous: #{old_table.constraints[name]}\n" +
-                   "ALTER TABLE #{old_table.name} DROP CONSTRAINT #{name};\n" +
-                   "ALTER TABLE #{new_table.name} ADD CONSTRAINT #{name} #{new_table.constraints[name]};\n")
-      end
-    end
-
-    def add_cnstr(tablename, cnstrname, cnstrdef)
-      c_string = "ALTER TABLE #{tablename} ADD CONSTRAINT #{cnstrname} #{cnstrdef} ;"
-      case cnstrdef
-        when /^CHECK /   then @c_check  << c_string
-        when /^PRIMARY / then @c_primary << c_string
-        when /^FOREIGN / then @c_foreign << c_string
-        when /^UNIQUE /  then @c_unique  << c_string
-      end
-    end
-
-    def diff_indexes(old_table, new_table)
-      dropped = []
-      added   = []
-
-      old_table.indexes.keys.each do |name|
-        if new_table.has_index?(name)
-          if old_table.indexes[name] != new_table.indexes[name]
-            dropped << name
-            added << name
-          end
-        else
-          dropped << name
-        end
-      end
-      new_table.indexes.keys.each do |name|
-        added << name unless old_table.has_index?(name)
-      end
-
-      dropped.each do |name|
-        add_script(:indices_drop ,  "DROP INDEX #{name};")
-      end
-      added.each do |name|
-        add_script(:indices_create ,  (new_table.indexes[name] + ";")) if new_table.indexes[name]
-      end
-    end
-  end
-end

data/lib/function.rb

@@ -1,56 +0,0 @@
-module PgDiff
-  class Function
-    def initialize(conn, tuple)
-      @name = tuple['namespace'] + "." + tuple['function_name']
-      @language = tuple['language_name']
-      @src = tuple['source_code']
-      @returns_set = tuple['returns_set']
-      @return_type = format_type(conn, tuple['return_type'])
-      @tipes = tuple['function_args'].split(" ")
-      if tuple['function_arg_names'] && tuple['function_arg_names'] =~ /^\{(.*)\}$/
-        @arnames = $1.split(',')
-      elsif tuple['function_arg_names'].is_a? Array # my version of ruby-postgres
-        @arnames = tuple['function_arg_names']
-      else
-        @arnames = [""] * @tipes.length
-      end
-      alist = []
-      @tipes.each_with_index do |typ,idx|
-        alist << (@arnames[idx] + " " + format_type(conn, typ))
-      end
-      @arglist = alist.join(" , ")
-      @strict = tuple['proisstrict'] ? ' STRICT' : ''
-      @secdef = tuple['prosecdef'] ? ' SECURITY DEFINER' : ''
-      @volatile = case tuple['provolatile']
-        when 'i' then ' IMMUTABLE'
-        when 's' then ' STABLE'
-        else ''
-      end
-    end
-
-    def signature
-      "#{@name}(#{@arglist})"
-    end
-
-    def definition
-      <<-EOT
-  CREATE OR REPLACE FUNCTION #{@name} (#{@arglist}) RETURNS #{@returns_set ? 'SETOF' : ''} #{@return_type} AS $_$#{@src}$_$ LANGUAGE '#{@language}' #{@volatile}#{@strict}#{@secdef};
-  EOT
-    end
-
-    def == (other)
-      definition == other.definition
-    end
-
-    def format_type(conn, oid)
-      t_query = <<-EOT
-      SELECT pg_catalog.format_type(pg_type.oid, typtypmod) AS type_name
-       FROM pg_catalog.pg_type
-       JOIN pg_catalog.pg_namespace ON (pg_namespace.oid = typnamespace)
-       WHERE pg_type.oid =
-      EOT
-      tuple = conn.query(t_query + oid.to_s).first
-      tuple['type_name']
-    end
-  end
-end

data/lib/rule.rb

@@ -1,15 +0,0 @@
-module PgDiff
-  class Rule
-    attr_reader :table_name, :name, :definition
-
-    def initialize(table_name, name, df)
-      @table_name = table_name
-      @name = name
-      @definition = df
-    end
-
-    def == (other)
-      other.definition == definition
-    end
-  end
-end

data/lib/sequence.rb

@@ -1,11 +0,0 @@
-module PgDiff
-  class Sequence
-    def initialize(conn, sch, relname)
-       @name = "#{sch}.#{relname}"
-    end
-
-    def definition
-      "CREATE SEQUENCE #{@name} ;"
-    end
-  end
-end

data/lib/table.rb

@@ -1,90 +0,0 @@
-module PgDiff
-  class Table
-    attr_accessor :table_name, :schema, :attributes, :constraints, :indexes
-
-    def initialize(conn, schema, table_name)
-      @schema = schema
-      @table_name = table_name
-      @attributes = {}
-      @constraints = {}
-      @indexes = {}
-      @atlist = []
-
-      att_query = <<-EOT
-        select attname, format_type(atttypid, atttypmod) as a_type, attnotnull,  pg_get_expr(adbin, attrelid) as a_default
-        from pg_attribute left join pg_attrdef  on (adrelid = attrelid and adnum = attnum)
-        where attrelid = '#{schema}.#{table_name}'::regclass and not attisdropped and attnum > 0
-        order by attnum
-      EOT
-      conn.query(att_query).each do |tuple|
-        attname = tuple['attname']
-        typedef = tuple['a_type']
-        notnull = tuple['attnotnull']
-        default = tuple['a_default']
-        @attributes[attname] = Attribute.new(attname, typedef, notnull, default)
-        @atlist << attname
-      end
-
-      ind_query = <<-EOT
-        select indexrelid::regclass as indname, pg_get_indexdef(indexrelid) as def
-        from pg_index where indrelid = '#{schema}.#{table_name}'::regclass and not indisprimary
-      EOT
-      conn.query(ind_query).each do |tuple|
-        name = tuple['indname']
-        value = tuple['def']
-        @indexes[name] = value
-      end
-
-      cons_query = <<-EOT
-        select conname, pg_get_constraintdef(oid) from pg_constraint where conrelid = '#{schema}.#{table_name}'::regclass
-      EOT
-      conn.query(cons_query).each do |tuple|
-        name = tuple['conname']
-        value = tuple['pg_get_constraintdef']
-        @constraints[name] = value
-      end
-      @constraints.keys.each do |cname|
-        @indexes.delete("#{schema}.#{cname}") if has_index?(cname)
-      end
-    end
-
-    def has_attribute?(name)
-      @attributes.has_key?(name)
-    end
-
-    def attribute_index(name)
-      @atlist.index(name)
-    end
-
-    def has_index?(name)
-      @indexes.has_key?(name) || @indexes.has_key?("#{schema}.#{name}")
-    end
-
-    def has_constraint?(name)
-      @constraints.has_key?(name)
-    end
-
-    def table_creation
-      out = ["CREATE TABLE #{name} ("]
-      stmt = []
-      @atlist.each do |attname|
-        stmt << @attributes[attname].definition
-      end
-      out << stmt.join(",\n")
-      out << ");"
-      out.join("\n")
-    end
-
-    def name
-      "#{schema}.#{table_name}"
-    end
-
-    def index_creation
-      out = []
-      @indexes.values.each do |c|
-        out << (c+";")
-      end
-      out.join("\n")
-    end
-  end
-end

data/lib/trigger.rb

@@ -1,15 +0,0 @@
-module PgDiff
-  class Trigger
-    attr_reader :table_name, :name, :definition
-
-    def initialize(table_name, name, df)
-      @table_name = table_name
-      @name = name
-      @definition = df + ";"
-    end
-
-    def == (other)
-      other.definition == definition
-    end
-  end
-end

data/lib/view.rb

@@ -1,18 +0,0 @@
-module PgDiff
-  class View
-    attr_reader :def, :name
-
-    def initialize(conn, sch, relname)
-      @name = "#{sch}.#{relname}"
-      view_qery = <<-EOT
-        SELECT pg_catalog.pg_get_viewdef('#{@name}'::regclass, true)
-      EOT
-      tuple = conn.query(view_qery).first
-      @def = tuple['pg_get_viewdef']
-    end
-
-    def definition
-      "CREATE VIEW #{@name} AS #{@def}"
-    end
-  end
-end