benhutton-mysql2psql 0.2.0

data/lib/mysql2psql/postgres_writer.rb

@@ -0,0 +1,168 @@
+require 'pg'
+
+require 'mysql2psql/writer'
+
+class Mysql2psql
+
+  class PostgresWriter < Writer
+    def column_description(column, options)
+      "#{PGconn.quote_ident(column[:name])} #{column_type_info(column, options)}"
+    end
+
+    def column_type(column, options={})
+      if column[:auto_increment]
+        'integer'
+      else
+        case column[:type]
+        when 'char'
+          "character(#{column[:length]})"
+        when 'varchar'
+          "character varying(#{column[:length]})"
+        when /tinyint|smallint/
+          'smallint'
+        when 'real', /float/, 'double precision'
+          'double precision'
+        when 'decimal'
+          # TODO: seven1m thinks "real" instead?
+          "numeric(#{column[:length] || 10}, #{column[:decimals] || 5})"
+        when 'datetime', 'timestamp'
+          "timestamp with#{options[:use_timezones] ? '' : 'out'} time zone"
+        when 'time'
+          "time with#{options[:use_timezones] ? '' : 'out'} time zone"
+        when 'tinyblob', 'mediumblob', 'longblob', 'blob', 'varbinary'
+          'bytea'
+        when 'tinytext', 'mediumtext', 'longtext', 'text'
+          'text'
+        when /^enum/
+          enum = column[:type].gsub(/enum|\(|\)/, '')
+          max_enum_size = enum.split(',').map{ |check| check.size() -2}.sort[-1]
+          "character varying(#{max_enum_size}) check( #{column[:name]} in (#{enum}))"
+        when 'integer', 'bigint', 'boolean', 'date'
+          column[:type]
+        else
+          puts "Unknown #{column.inspect}"
+          ''
+        end
+      end
+    end
+    
+    def column_default(column)
+      if column[:auto_increment]
+        "nextval('#{column[:table_name]}_#{column[:name]}_seq'::regclass)"
+      elsif column[:default]
+        case column[:type]
+        when 'char'
+          "'#{PGconn.escape(column[:default])}'::char"
+        when 'varchar', /^enum/
+          "'#{PGconn.escape(column[:default])}'::character varying"
+        when 'integer', 'bigint', /tinyint|smallint/
+          column[:default].to_i
+        when 'real', /float/
+          column[:default].to_f
+        when 'decimal', 'double precision'
+          column[:default]
+        when 'boolean'
+          case column[:default]
+          when nil
+            'NULL'
+          when 0, '0', "b'0'"
+            'false'
+          else
+            # Case for 1, '1', "b'1'" (for BIT(1) the data type), or anything non-nil and non-zero (for the TINYINT(1) type)
+            'true'
+          end
+        when 'timestamp', 'datetime', 'date'
+          case column[:default]
+          when 'CURRENT_TIMESTAMP'
+            'CURRENT_TIMESTAMP'
+          when '0000-00-00'
+            "'1970-01-01'"
+          when '0000-00-00 00:00'
+            "'1970-01-01 00:00'"
+          when '0000-00-00 00:00:00'
+            "'1970-01-01 00:00:00'"
+          else
+            "'#{PGconn.escape(column[:default])}'"
+          end
+        when 'time'
+          "'#{PGconn.escape(column[:default])}'"
+        else
+          # TODO: column[:default] will never be nil here.
+          #       Perhaps we should also issue a warning if this case is encountered.
+          "#{column[:default] == nil ? 'NULL' : "'"+PGconn.escape(column[:default])+"'"}"
+        end
+      end
+    end
+
+    def column_type_info(column, options)
+      type = column_type(column, options)
+      if type
+        not_null = !column[:null] || column[:auto_increment] ? ' NOT NULL' : ''
+        default = column[:default] || column[:auto_increment] ? " DEFAULT #{column_default(column)}" : ''
+        "#{type}#{default}#{not_null}"
+      else
+        ''
+      end
+    end
+
+    def process_row(table, row)
+      table.columns.each_with_index do |column, index|
+        if column[:type] == 'time'
+          begin
+            row[index] = "%02d:%02d:%02d" % [row[index].hour, row[index].minute, row[index].second]
+          rescue
+            # Don't fail on nil date/time.
+          end
+        elsif row[index].is_a?(Mysql::Time)
+          row[index] = row[index].to_s.gsub('0000-00-00 00:00', '1970-01-01 00:00')
+          row[index] = row[index].to_s.gsub('0000-00-00 00:00:00', '1970-01-01 00:00:00')
+        elsif column[:type] == 'boolean'
+          row[index] = (
+            case row[index]
+            when nil
+              '\N' # See note below about null values.
+            when 0, "\0"
+              'f'
+            else
+              # Case for 1, "\1" (for the BIT(1) data type), or anything non-nil and non-zero (to handle the TINYINT(1) type)
+              't'
+            end
+          )
+        elsif row[index].is_a?(String)
+          if column_type(column) == "bytea"
+            row[index] = PGconn.escape_bytea(row[index])
+          else
+            if row[index] == '\N' || row[index] == '\.'
+              row[index] = '\\' + row[index] # Escape our two PostgreSQL-text-mode-special strings.
+            else
+              # Awesome side-effect producing conditional. Don't do this at home.
+              unless row[index].gsub!(/\0/, '').nil?
+                puts "Removed null bytes from string since PostgreSQL TEXT types don't allow the storage of null bytes."
+              end
+              
+              row[index] = row[index].dump
+              row[index] = row[index].slice(1, row[index].size-2)
+            end
+          end
+        elsif row[index].nil?
+          # Note: '\N' not "\N" is correct here:
+          #       The string containing the literal backslash followed by 'N'
+          #       represents database NULL value in PostgreSQL's text mode.
+          row[index] = '\N'
+        end
+      end
+    end
+
+    def truncate(table)
+    end
+
+    def sqlfor_set_serial_sequence(table, serial_key_seq, max_value)
+      "SELECT pg_catalog.setval('#{serial_key_seq}', #{max_value}, true);"
+    end
+    def sqlfor_reset_serial_sequence(table, serial_key, max_value)
+      "SELECT pg_catalog.setval(pg_get_serial_sequence('#{table.name}', '#{serial_key}'), #{max_value}, true);"
+    end
+
+  end
+
+end

data/lib/mysql2psql/version.rb

@@ -0,0 +1,9 @@
+class Mysql2psql
+  module Version
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end

data/lib/mysql2psql/writer.rb

@@ -0,0 +1,6 @@
+class Mysql2psql
+
+  class Writer
+  end
+
+end

data/lib/mysql2psql.rb

@@ -0,0 +1,41 @@
+require 'mysql2psql/errors'
+require 'mysql2psql/version'
+require 'mysql2psql/config'
+require 'mysql2psql/converter'
+require 'mysql2psql/mysql_reader'
+require 'mysql2psql/writer'
+require 'mysql2psql/postgres_writer'
+require 'mysql2psql/postgres_db_writer.rb'
+require 'mysql2psql/postgres_file_writer.rb'
+
+
+class Mysql2psql
+  
+  attr_reader :options, :reader, :writer
+  
+  def initialize(args)
+    help if args.length==1 && args[0] =~ /^-.?|^-*he?l?p?$/i 
+    configfile = args[0] || File.expand_path('mysql2psql.yml')
+    @options = Config.new( configfile, true )
+  end
+  
+  def convert
+    @reader = MysqlReader.new( options )
+
+    if options.destfile(nil)
+      @writer = PostgresFileWriter.new(options.destfile)
+    else
+      @writer = PostgresDbWriter.new(options)
+    end
+
+    Converter.new(reader, writer, options).convert
+  end
+
+  def help
+    puts <<EOS
+MySQL to PostgreSQL Conversion
+
+EOS
+    exit -2
+  end
+end

data/mysql2psql.gemspec

@@ -0,0 +1,106 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mysql2psql}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Max Lapshin <max@maxidoors.ru>", "Anton Ageev <anton@ageev.name>", "Samuel Tribehou <cracoucax@gmail.com>", "Marco Nenciarini <marco.nenciarini@devise.it>", "James Nobis <jnobis@jnobis.controldocs.com>", "quel <github@quelrod.net>", "Holger Amann <keeney@fehu.org>", "Maxim Dobriakov <closer.main@gmail.com>", "Michael Kimsal <mgkimsal@gmail.com>", "Jacob Coby <jcoby@portallabs.com>", "Neszt Tibor <neszt@tvnetwork.hu>", "Miroslav Kratochvil <exa.exa@gmail.com>", "Paul Gallagher <gallagher.paul@gmail.com>", "James Coleman <jtc331@gmail.com>", "Aaron Peckham", "James Tippett", "Tim Morgan", "dakhota", "Matthew Soldo"]
+  s.date = %q{2012-02-13}
+  s.default_executable = %q{mysql2psql}
+  s.description = %q{It can create postgresql dump from mysql database or directly load data from mysql to
+    postgresql (at about 100 000 records per minute). Translates most data types and indexes.}
+  s.email = %q{gallagher.paul@gmail.com}
+  s.executables = ["mysql2psql"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "CHANGELOG",
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "bin/mysql2psql",
+    "lib/mysql2psql.rb",
+    "lib/mysql2psql/config.rb",
+    "lib/mysql2psql/config_base.rb",
+    "lib/mysql2psql/converter.rb",
+    "lib/mysql2psql/errors.rb",
+    "lib/mysql2psql/mysql_reader.rb",
+    "lib/mysql2psql/postgres_db_writer.rb",
+    "lib/mysql2psql/postgres_file_writer.rb",
+    "lib/mysql2psql/postgres_writer.rb",
+    "lib/mysql2psql/version.rb",
+    "lib/mysql2psql/writer.rb",
+    "mysql2psql.gemspec",
+    "test/fixtures/config_all_options.yml",
+    "test/fixtures/seed_integration_tests.sql",
+    "test/integration/convert_to_db_test.rb",
+    "test/integration/convert_to_file_test.rb",
+    "test/integration/converter_test.rb",
+    "test/integration/mysql_reader_base_test.rb",
+    "test/integration/mysql_reader_test.rb",
+    "test/integration/postgres_db_writer_base_test.rb",
+    "test/lib/ext_test_unit.rb",
+    "test/lib/test_helper.rb",
+    "test/units/config_base_test.rb",
+    "test/units/config_test.rb",
+    "test/units/postgres_file_writer_test.rb"
+  ]
+  s.homepage = %q{https://github.com/tardate/mysql2postgres}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Tool for converting mysql database to postgresql}
+  s.test_files = [
+    "test/integration/convert_to_db_test.rb",
+    "test/integration/convert_to_file_test.rb",
+    "test/integration/converter_test.rb",
+    "test/integration/mysql_reader_base_test.rb",
+    "test/integration/mysql_reader_test.rb",
+    "test/integration/postgres_db_writer_base_test.rb",
+    "test/lib/ext_test_unit.rb",
+    "test/lib/test_helper.rb",
+    "test/units/config_base_test.rb",
+    "test/units/config_test.rb",
+    "test/units/postgres_file_writer_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mysql2psql>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.21"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<test-unit>, [">= 2.1.1"])
+      s.add_development_dependency(%q<rake>, ["~> 0.9.2.2"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_runtime_dependency(%q<mysql>, ["= 2.8.1"])
+      s.add_runtime_dependency(%q<pg>)
+    else
+      s.add_dependency(%q<mysql2psql>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.21"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<test-unit>, [">= 2.1.1"])
+      s.add_dependency(%q<rake>, ["~> 0.9.2.2"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<mysql>, ["= 2.8.1"])
+      s.add_dependency(%q<pg>)
+    end
+  else
+    s.add_dependency(%q<mysql2psql>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.21"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<test-unit>, [">= 2.1.1"])
+    s.add_dependency(%q<rake>, ["~> 0.9.2.2"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<mysql>, ["= 2.8.1"])
+    s.add_dependency(%q<pg>)
+  end
+end
+

data/test/fixtures/config_all_options.yml

@@ -0,0 +1,50 @@
+mysql:
+ hostname: localhost
+ port: 3306
+ socket:
+ username: somename
+ password: secretpassword
+ database: somename
+
+destination:
+ # if file is given, output goes to file, else postgres
+ file: somefile
+ postgres:
+  hostname: localhost
+  port: 5432
+  username: somename
+  password: secretpassword
+  database: somename
+
+# if tables is given, only the listed tables will be converted.  leave empty to convert all tables.
+tables:
+- table1
+- table2
+- table3
+- table4
+
+# if exclude_tables is given, exclude the listed tables from the conversion.
+exclude_tables:
+- table5
+- table6
+
+# if suppress_data is true, only the schema definition will be exported/migrated, and not the data
+suppress_data: true
+
+# if suppress_ddl is true, only the data will be exported/imported, and not the schema
+suppress_ddl: false
+
+# if suppress_sequence_update is true, the sequences for serial (auto-incrementing) columns
+# will not be update to the current maximum value of that column in the database
+# if suppress_ddl is not set to true, then this option is implied to be false as well (unless overridden here)
+suppress_sequence_update: false
+
+# if suppress_indexes is true, indexes will not be exported/migrated.
+suppress_indexes: false
+
+# if force_truncate is true, forces a table truncate before table loading
+force_truncate: false
+
+# if use_timezones is true, timestamp/time columns will be created in postgres as "with time zone"
+# rather than "without time zone"
+use_timezones: false

data/test/fixtures/seed_integration_tests.sql

@@ -0,0 +1,119 @@
+-- seed data for integration tests
+
+DROP TABLE IF EXISTS numeric_types_basics;
+CREATE TABLE numeric_types_basics (
+  id int,
+	f_tinyint TINYINT,
+	f_tinyint_u TINYINT UNSIGNED,
+	f_smallint SMALLINT,
+	f_smallint_u SMALLINT UNSIGNED,
+	f_mediumint MEDIUMINT,
+	f_mediumint_u MEDIUMINT UNSIGNED,
+	f_int INT,
+	f_int_u INT UNSIGNED,
+	f_integer INTEGER,
+	f_integer_u INTEGER UNSIGNED,
+	f_bigint BIGINT,
+	f_bigint_u BIGINT UNSIGNED,
+	f_real REAL,
+	f_double DOUBLE,
+	f_float FLOAT,
+	f_float_u FLOAT UNSIGNED,
+	f_decimal DECIMAL,
+	f_numeric NUMERIC
+);
+
+INSERT INTO numeric_types_basics VALUES
+( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19),
+( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
+( 3,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23),
+( 4, -128,   0,-32768,     0,-8388608,        0,-2147483648,          0,-2147483648,          0,-9223372036854775808,                    0, 1, 1, 1, 1, 1, 1),
+( 5,  127, 255, 32767, 65535, 8388607, 16777215, 2147483647, 4294967295, 2147483647, 4294967295, 9223372036854775807, 18446744073709551615, 1, 1, 1, 1, 1, 1);
+
+
+
+DROP TABLE IF EXISTS basic_autoincrement;
+CREATE TABLE basic_autoincrement (
+  auto_id INT(11) NOT NULL AUTO_INCREMENT,
+	auto_dummy INT,
+	PRIMARY KEY (auto_id)
+);
+
+INSERT INTO basic_autoincrement(auto_dummy) VALUES
+(1),(2),(23);
+
+-- see GH#22 float conversion error
+DROP TABLE IF EXISTS numeric_type_floats;
+CREATE TABLE numeric_type_floats (
+ latitude FLOAT,
+ longitude FLOAT
+);
+
+INSERT INTO numeric_type_floats(latitude,longitude) VALUES
+(1.1,2.2);
+
+-- see GH#18 smallint error
+DROP TABLE IF EXISTS gh18_smallint;
+CREATE TABLE gh18_smallint (
+ s_smallint SMALLINT,
+ u_smallint SMALLINT UNSIGNED
+);
+
+INSERT INTO gh18_smallint(s_smallint,u_smallint) VALUES
+(-32768,32767),
+(-1,0),
+(32767,65535);
+
+-- see https://github.com/maxlapshin/mysql2postgres/issues/27
+DROP TABLE IF EXISTS test_boolean_conversion;
+CREATE TABLE test_boolean_conversion (
+  test_name VARCHAR(25),
+  bit_1 BIT(1),
+  tinyint_1 TINYINT(1),
+  bit_1_default_0 BIT(1) DEFAULT 0,
+  bit_1_default_1 BIT(1) DEFAULT 1,
+  tinyint_1_default_0 TINYINT(1) DEFAULT 0,
+  tinyint_1_default_1 TINYINT(1) DEFAULT 1,
+  tinyint_1_default_2 TINYINT(1) DEFAULT 2 -- Test the fact that 1 byte isn't limited to [0,1]
+);
+
+INSERT INTO test_boolean_conversion (test_name, bit_1, tinyint_1)
+VALUES ('test-null', NULL, NULL),
+       ('test-false', 0, 0),
+       ('test-true', 1, 1);
+INSERT INTO test_boolean_conversion (test_name, tinyint_1) VALUES ('test-true-nonzero', 2);
+
+CREATE OR REPLACE VIEW test_view AS
+SELECT b.test_name
+FROM test_boolean_conversion b;
+
+DROP TABLE IF EXISTS test_null_conversion;
+CREATE TABLE test_null_conversion (column_a VARCHAR(10));
+INSERT INTO test_null_conversion (column_a) VALUES (NULL);
+
+DROP TABLE IF EXISTS test_datetime_conversion;
+CREATE TABLE test_datetime_conversion (
+	column_a DATETIME,
+	column_b TIMESTAMP,
+	column_c DATETIME DEFAULT '0000-00-00',
+	column_d DATETIME DEFAULT '0000-00-00 00:00',
+	column_e DATETIME DEFAULT '0000-00-00 00:00:00',
+	column_f TIME
+);
+INSERT INTO test_datetime_conversion (column_a, column_f) VALUES ('0000-00-00 00:00', '08:15:30');
+
+DROP TABLE IF EXISTS test_index_conversion;
+CREATE TABLE test_index_conversion (column_a VARCHAR(10));
+CREATE UNIQUE INDEX index_test_index_conversion_on_column_a ON test_index_conversion (column_a);
+
+DROP TABLE IF EXISTS test_foreign_keys_child;
+DROP TABLE IF EXISTS test_foreign_keys_parent;
+CREATE TABLE test_foreign_keys_parent (id INT NOT NULL, PRIMARY KEY (id)) ENGINE=INNODB;
+CREATE TABLE test_foreign_keys_child (id INT, test_foreign_keys_parent_id INT,
+	INDEX par_ind (test_foreign_keys_parent_id),
+	FOREIGN KEY (test_foreign_keys_parent_id) REFERENCES test_foreign_keys_parent(id) ON DELETE CASCADE
+) ENGINE=INNODB;
+
+DROP TABLE IF EXISTS test_enum;
+CREATE TABLE test_enum (name ENUM('small', 'medium', 'large'));
+INSERT INTO test_enum (name) VALUES ('medium');

data/test/integration/convert_to_db_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+require 'mysql2psql'
+
+class ConvertToDbTest < Test::Unit::TestCase
+
+  def setup
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    seed_test_database
+    @options=get_test_config_by_label(:localmysql_to_db_convert_all)
+    @mysql2psql = Mysql2psql.new([@options.filepath])
+    @mysql2psql.convert
+    @mysql2psql.writer.open
+  end
+
+  def teardown
+    @mysql2psql.writer.close
+    delete_files_for_test_config(@options)
+    
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+
+  def exec_sql_on_psql(sql, parameters=nil)
+    @mysql2psql.writer.conn.exec(sql, parameters)
+  end
+
+  def get_boolean_test_record(name)
+    exec_sql_on_psql('SELECT * FROM test_boolean_conversion WHERE test_name = $1', [name]).first
+  end
+
+  def test_table_creation
+    assert_true @mysql2psql.writer.exists?('numeric_types_basics')
+    assert_true @mysql2psql.writer.exists?('basic_autoincrement')
+    assert_true @mysql2psql.writer.exists?('numeric_type_floats')
+  end
+
+  def test_boolean_conversion_to_true
+    true_record = get_boolean_test_record('test-true')
+    assert_equal 't', true_record['bit_1']
+    assert_equal 't', true_record['tinyint_1']
+    
+    true_nonzero_record = get_boolean_test_record('test-true-nonzero')
+    assert_equal 't', true_nonzero_record['tinyint_1']
+  end
+
+  def test_boolean_conversion_to_false
+    false_record = get_boolean_test_record('test-false')
+    assert_equal 'f', false_record['bit_1']
+    assert_equal 'f', false_record['tinyint_1']
+  end
+
+  def test_boolean_conversion_of_null
+    null_record = get_boolean_test_record('test-null')
+    assert_nil null_record['bit_1']
+    assert_nil null_record['tinyint_1']
+  end
+  
+  def test_null_conversion
+    result = exec_sql_on_psql('SELECT column_a FROM test_null_conversion').first
+    assert_nil result['column_a']
+  end
+  
+  def test_datetime_conversion
+    result = exec_sql_on_psql('SELECT column_a, column_f FROM test_datetime_conversion').first
+    assert_equal '1970-01-01 00:00:00', result['column_a']
+    assert_equal '08:15:30', result['column_f']
+  end
+  
+  def test_datetime_defaults
+    result = exec_sql_on_psql(<<-SQL)
+      SELECT a.attname,
+        pg_catalog.format_type(a.atttypid, a.atttypmod),
+        (SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid) for 128)
+         FROM pg_catalog.pg_attrdef d
+         WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef) AS default
+      FROM pg_catalog.pg_attribute a
+      WHERE a.attrelid = 'test_datetime_conversion'::regclass AND a.attnum > 0
+    SQL
+    
+    assert_equal 6, result.count
+    
+    result.each do |row|
+      if row["attname"] == "column_f"
+        assert_equal "time without time zone", row["format_type"]
+      else
+        assert_equal "timestamp without time zone", row["format_type"]
+      end
+      
+      case row["attname"]
+      when "column_a"
+        assert_nil row["default"]
+      when "column_b"
+        assert_equal "now()", row["default"]
+      when "column_c", "column_d", "column_e"
+        assert_equal "'1970-01-01 00:00:00'::timestamp without time zone", row["default"]
+      end
+    end
+  end
+  
+  def test_index_conversion
+    result = exec_sql_on_psql(%(
+       SELECT pg_get_indexdef(indexrelid)
+       FROM pg_index
+       join pg_class on pg_class.oid=pg_index.indrelid
+       where pg_class.relname='test_index_conversion'
+    )).first
+    assert_equal "CREATE UNIQUE INDEX index_test_index_conversion_on_column_a ON test_index_conversion USING btree (column_a)", result["pg_get_indexdef"]
+  end
+  
+  def test_foreign_keys
+    result = exec_sql_on_psql("SELECT conname, pg_catalog.pg_get_constraintdef(r.oid, true) as condef FROM pg_catalog.pg_constraint r WHERE r.conrelid = 'test_foreign_keys_child'::regclass")
+    expected = {"condef" => "FOREIGN KEY (test_foreign_keys_parent_id) REFERENCES test_foreign_keys_parent(id) ON UPDATE RESTRICT ON DELETE CASCADE", "conname" => "test_foreign_keys_child_test_foreign_keys_parent_id_fkey"}
+    assert_equal expected, result.first
+  end
+  
+  def test_output
+    $stdout.rewind
+    actual = $stdout.read
+    
+    assert_match /Counting rows of test_foreign_keys_child/, actual
+  end
+  
+  def test_enum
+    result = exec_sql_on_psql(<<-SQL)
+      SELECT r.conname, pg_catalog.pg_get_constraintdef(r.oid, true)
+      FROM pg_catalog.pg_constraint r
+      WHERE r.conrelid = 'test_enum'::regclass AND r.contype = 'c'
+      ORDER BY 1
+    SQL
+    
+    assert_equal 1, result.count
+    assert_equal "CHECK (name::text = ANY (ARRAY['small'::character varying, 'medium'::character varying, 'large'::character varying]::text[]))", result.first["pg_get_constraintdef"]
+  end
+end