xmysql2psql 0.2.0

data/lib/xmysql2psql/postgres_db_writer.rb

@@ -0,0 +1,183 @@
+require 'pg'
+
+require 'xmysql2psql/postgres_writer'
+
+class Xmysql2psql
+
+class PostgresDbWriter < PostgresWriter
+  attr_reader :conn, :hostname, :login, :password, :database, :schema, :port
+  
+  def db_writer?
+    true
+  end
+  
+  def initialize(options)
+    @hostname, @login, @password, @database, @port =  
+      options.pghostname('localhost'), options.pgusername, 
+      options.pgpassword, options.pgdatabase, options.pgport(5432).to_s
+    @database, @schema = database.split(":")
+    open
+  end
+
+  def open
+    @conn = PGconn.new(hostname, port, '', '', database, login, password)
+    @conn.exec("SET search_path TO #{PGconn.quote_ident(schema)}") if schema
+    @conn.exec("SET client_encoding = 'UTF8'")
+    @conn.exec("SET standard_conforming_strings = off") if @conn.server_version >= 80200
+    @conn.exec("SET check_function_bodies = false")
+    @conn.exec("SET client_min_messages = warning")    
+  end
+  
+  def close
+    @conn.close
+  end
+
+  def exists?(relname)
+    rc = @conn.exec("SELECT COUNT(*) FROM pg_class WHERE relname = '#{relname}'")
+    (!rc.nil?) && (rc.to_a.length==1) && (rc.first.count.to_i==1)
+  end
+  
+  def write_table(table)
+    puts "Creating table #{table.name}..."
+    primary_keys = []
+    serial_key = nil
+    maxval = nil
+    
+    columns = table.columns.map do |column|
+      if column[:auto_increment]
+        serial_key = column[:name]
+        maxval = column[:maxval].to_i < 1 ? 1 : column[:maxval] + 1
+      end
+      if column[:primary_key]
+        primary_keys << column[:name]
+      end
+      "  " + column_description(column)
+    end.join(",\n")
+    
+    if serial_key
+      if @conn.server_version < 80200
+        serial_key_seq = "#{table.name}_#{serial_key}_seq"
+        @conn.exec("DROP SEQUENCE #{serial_key_seq} CASCADE") if exists?(serial_key_seq)
+      else
+        @conn.exec("DROP SEQUENCE IF EXISTS #{table.name}_#{serial_key}_seq CASCADE")
+      end
+      @conn.exec <<-EOF
+        CREATE SEQUENCE #{table.name}_#{serial_key}_seq
+        INCREMENT BY 1
+        NO MAXVALUE
+        NO MINVALUE
+        CACHE 1
+      EOF
+    
+      @conn.exec "SELECT pg_catalog.setval('#{table.name}_#{serial_key}_seq', #{maxval}, true)"
+    end
+    
+    if @conn.server_version < 80200
+      @conn.exec "DROP TABLE #{PGconn.quote_ident(table.name)} CASCADE;" if exists?(table.name)
+    else
+      @conn.exec "DROP TABLE IF EXISTS #{PGconn.quote_ident(table.name)} CASCADE;"
+    end
+    create_sql = "CREATE TABLE #{PGconn.quote_ident(table.name)} (\n" + columns + "\n)\nWITHOUT OIDS;"
+    begin
+      @conn.exec(create_sql)
+    rescue Exception => e
+      puts "Error: \n#{create_sql}"
+      raise
+    end
+    puts "Created table #{table.name}"
+ 
+  end
+  
+  def write_indexes(table)
+    puts "Indexing table #{table.name}..."
+    if primary_index = table.indexes.find {|index| index[:primary]}
+      @conn.exec("ALTER TABLE #{PGconn.quote_ident(table.name)} ADD CONSTRAINT \"#{table.name}_pkey\" PRIMARY KEY(#{primary_index[:columns].map {|col| PGconn.quote_ident(col)}.join(", ")})")
+    end
+    
+    table.indexes.each do |index|
+      next if index[:primary]
+      unique = index[:unique] ? "UNIQUE " : nil
+      
+      #MySQL allows an index name which could be equal to a table name, Postgres doesn't
+      indexname = index[:name]
+      if indexname.eql?(table.name)
+        indexnamenew = "#{indexname}_index"
+        puts "WARNING: index \"#{indexname}\" equals table name. This is not allowed by postgres and will be renamed to \"#{indexnamenew}\""
+        indexname = indexnamenew
+      end
+      
+      if @conn.server_version < 80200
+        @conn.exec("DROP INDEX #{PGconn.quote_ident(indexname)} CASCADE;") if exists?(indexname)
+      else
+        @conn.exec("DROP INDEX IF EXISTS #{PGconn.quote_ident(indexname)} CASCADE;")
+      end
+      @conn.exec("CREATE #{unique}INDEX #{PGconn.quote_ident(indexname)} ON #{PGconn.quote_ident(table.name)} (#{index[:columns].map {|col| PGconn.quote_ident(col)}.join(", ")});")
+    end
+    
+    
+    #@conn.exec("VACUUM FULL ANALYZE #{PGconn.quote_ident(table.name)}")
+    puts "Indexed table #{table.name}"
+  rescue Exception => e
+    puts "Couldn't create indexes on #{table} (#{table.indexes.inspect})"
+    puts e
+    puts e.backtrace[0,3].join("\n")
+  end
+  
+  def write_constraints(table)
+    table.foreign_keys.each do |key|
+      key_sql = "ALTER TABLE #{PGconn.quote_ident(table.name)} ADD FOREIGN KEY (#{PGconn.quote_ident(key[:column])}) REFERENCES #{PGconn.quote_ident(key[:ref_table])}(#{PGconn.quote_ident(key[:ref_column])})"
+      begin
+        @conn.exec(key_sql)
+      rescue Exception => e
+        puts "Error: \n#{key_sql}\n#{e}"
+      end
+    end
+  end
+  
+  def format_eta (t)
+    t = t.to_i
+    sec = t % 60
+    min = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02dh:%02dm:%02ds", hour, min, sec)
+  end
+  
+  def write_contents(table, reader)
+    _time1 = Time.now
+    copy_line = "COPY #{PGconn.quote_ident(table.name)} (#{table.columns.map {|column| PGconn.quote_ident(column[:name])}.join(", ")}) FROM stdin;"
+    @conn.exec(copy_line)
+    puts "Counting rows of #{table.name}... "
+    STDOUT.flush
+    rowcount = table.count_rows
+    puts "Rows counted"
+    puts "Loading #{table.name}..."
+    STDOUT.flush
+    _counter = reader.paginated_read(table, 1000) do |row, counter|
+      line = []
+      process_row(table, row)
+      @conn.put_copy_data(row.join("\t") + "\n")
+       
+      if counter != 0 && counter % 20000 == 0
+        elapsedTime = Time.now - _time1
+        eta = elapsedTime * rowcount / counter - elapsedTime
+        etaf = self.format_eta(eta)
+        etatimef = (Time.now + eta).strftime("%Y/%m/%d %H:%M")
+        printf "\r#{counter} of #{rowcount} rows loaded. [ETA: #{etatimef} (#{etaf})]"
+        STDOUT.flush
+      end
+      
+      if counter % 5000 == 0
+        @conn.put_copy_end
+        @conn.exec(copy_line)
+      end
+       
+    end
+    _time2 = Time.now
+    puts "\n#{_counter} rows loaded in #{((_time2 - _time1) / 60).round}min #{((_time2 - _time1) % 60).round}s"
+#    @conn.putline(".\n")
+    @conn.put_copy_end
+  end
+  
+end
+
+end

data/lib/xmysql2psql/postgres_file_writer.rb

@@ -0,0 +1,146 @@
+require 'xmysql2psql/postgres_writer'
+
+class Xmysql2psql
+
+class PostgresFileWriter < PostgresWriter
+  def initialize(file)
+    @f = File.open(file, "w+")
+    @f << <<-EOF
+-- MySQL 2 PostgreSQL dump\n
+SET client_encoding = 'UTF8';
+SET standard_conforming_strings = off;
+SET check_function_bodies = false;
+SET client_min_messages = warning;
+ 
+EOF
+  end
+  
+  def db_writer?
+    false
+  end
+  
+  def truncate(table)
+    serial_key = nil
+    maxval = nil
+    
+    table.columns.map do |column|
+      if column[:auto_increment]
+        serial_key = column[:name]
+        maxval = column[:maxval].to_i < 1 ? 1 : column[:maxval] + 1
+      end
+    end
+
+    @f << <<-EOF
+-- TRUNCATE #{table.name};
+TRUNCATE #{PGconn.quote_ident(table.name)} CASCADE;
+
+EOF
+    if serial_key
+    @f << <<-EOF
+SELECT pg_catalog.setval(pg_get_serial_sequence('#{table.name}', '#{serial_key}'), #{maxval}, true);
+EOF
+    end
+  end
+  
+  def write_table(table)
+    primary_keys = []
+    serial_key = nil
+    maxval = nil
+    
+    columns = table.columns.map do |column|
+      if column[:auto_increment]
+        serial_key = column[:name]
+        maxval = column[:maxval].to_i < 1 ? 1 : column[:maxval] + 1
+      end
+      if column[:primary_key]
+        primary_keys << column[:name]
+      end
+      "  " + column_description(column)
+    end.join(",\n")
+    
+    if serial_key
+      
+      @f << <<-EOF
+--
+-- Name: #{table.name}_#{serial_key}_seq; Type: SEQUENCE; Schema: public
+--
+ 
+DROP SEQUENCE IF EXISTS #{table.name}_#{serial_key}_seq CASCADE;
+ 
+CREATE SEQUENCE #{table.name}_#{serial_key}_seq
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+    
+    
+SELECT pg_catalog.setval('#{table.name}_#{serial_key}_seq', #{maxval}, true);
+ 
+      EOF
+    end
+    
+    @f << <<-EOF
+-- Table: #{table.name}
+ 
+-- DROP TABLE #{table.name};
+DROP TABLE IF EXISTS #{PGconn.quote_ident(table.name)} CASCADE;
+ 
+CREATE TABLE #{PGconn.quote_ident(table.name)} (
+EOF
+  
+    @f << columns
+ 
+    if primary_index = table.indexes.find {|index| index[:primary]}
+      @f << ",\n  CONSTRAINT #{table.name}_pkey PRIMARY KEY(#{primary_index[:columns].map {|col| PGconn.quote_ident(col)}.join(", ")})"
+    end
+    
+    @f << <<-EOF
+\n)
+WITHOUT OIDS;
+EOF
+  
+    table.indexes.each do |index|
+      next if index[:primary]
+      unique = index[:unique] ? "UNIQUE " : nil
+      @f << <<-EOF
+DROP INDEX IF EXISTS #{PGconn.quote_ident(index[:name])} CASCADE;
+CREATE #{unique}INDEX #{PGconn.quote_ident(index[:name])} ON #{PGconn.quote_ident(table.name)} (#{index[:columns].map {|col| PGconn.quote_ident(col)}.join(", ")});
+EOF
+    end
+ 
+  end
+  
+  def write_indexes(table)
+  end
+  
+  def write_constraints(table)
+    table.foreign_keys.each do |key|
+      @f << "ALTER TABLE #{PGconn.quote_ident(table.name)} ADD FOREIGN KEY (#{PGconn.quote_ident(key[:column])}) REFERENCES #{PGconn.quote_ident(key[:ref_table])}(#{PGconn.quote_ident(key[:ref_column])});\n"
+    end
+  end
+  
+  
+  def write_contents(table, reader)
+    @f << <<-EOF
+--
+-- Data for Name: #{table.name}; Type: TABLE DATA; Schema: public
+--
+
+COPY "#{table.name}" (#{table.columns.map {|column| PGconn.quote_ident(column[:name])}.join(", ")}) FROM stdin;
+EOF
+    
+    reader.paginated_read(table, 1000) do |row, counter|
+      line = []
+      process_row(table, row)
+      @f << row.join("\t") + "\n"
+    end
+    @f << "\\.\n\n"
+    #@f << "VACUUM FULL ANALYZE #{PGconn.quote_ident(table.name)};\n\n"
+  end
+  
+  def close
+    @f.close
+  end
+end
+
+end

data/lib/xmysql2psql/postgres_writer.rb

@@ -0,0 +1,154 @@
+require 'pg'
+
+require 'xmysql2psql/writer'
+
+class Xmysql2psql
+
+  class PostgresWriter < Writer
+    def db_writer?
+      raise StandardError.new("not implemented")
+    end
+    
+    def escape_bytea(value)
+      if db_writer?
+        self.conn.escape_bytea(value)
+      else
+        PGConn.escape_bytea(value)
+      end
+    end
+
+    def column_description(column)
+      "#{PGconn.quote_ident(column[:name])} #{column_type_info(column)}"
+    end
+
+    def column_type(column)
+      column_type_info(column).split(" ").first
+    end
+  
+    def column_type_info(column)
+      if column[:auto_increment]
+        return "integer DEFAULT nextval('#{column[:table_name]}_#{column[:name]}_seq'::regclass) NOT NULL"
+      end
+    
+      default = column[:default] ? " DEFAULT #{column[:default] == nil ? 'NULL' : "'"+PGconn.escape(column[:default])+"'"}" : nil
+      null = column[:null] ? "" : " NOT NULL"
+      type = 
+      case column[:type]
+    
+      # String types
+      when "char"
+        default = default + "::char" if default
+        "character(#{column[:length]})"
+      when "varchar"
+        default = default + "::character varying" if default
+        "character varying(#{column[:length]})"
+      
+      # Integer and numeric types
+      when "integer"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_i}" if default
+        "integer"
+      when "bigint"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_i}" if default
+        "bigint"
+      when "tinyint"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_i}" if default
+        "smallint"
+    
+      when "boolean"
+        default = " DEFAULT #{column[:default].to_i == 1 ? 'true' : 'false'}" if default
+        "boolean"
+      when "float"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_f}" if default
+        "real"
+      when "float unsigned"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_f}" if default
+        "real"
+      when "decimal"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default]}" if default
+        "numeric(#{column[:length] || 10}, #{column[:decimals] || 0})"
+
+      when "double precision"
+        default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default]}" if default
+        "double precision"
+
+      # Mysql datetime fields
+      when "datetime"
+        default = nil
+        "timestamp without time zone"
+      when "date"
+        default = nil
+        "date"
+      when "timestamp"
+        default = " DEFAULT CURRENT_TIMESTAMP" if column[:default] == "CURRENT_TIMESTAMP"
+        default = " DEFAULT '1970-01-01 00:00'" if column[:default] == "0000-00-00 00:00"
+        default = " DEFAULT '1970-01-01 00:00:00'" if column[:default] == "0000-00-00 00:00:00"
+        "timestamp without time zone"
+      when "time"
+        default = " DEFAULT NOW()" if default
+        "time without time zone"
+
+      when "tinyblob"
+        "bytea"
+      when "mediumblob"
+        "bytea"
+      when "longblob"
+        "bytea"
+      when "blob"
+        "bytea"
+      when "varbinary"
+        "bytea"
+      when "tinytext"
+        "text"
+      when "mediumtext"
+        "text"
+      when "longtext"
+        "text"
+      when "text"
+        "text"
+      when /^enum/
+        default = default + "::character varying" if default
+        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}))"
+      else
+        puts "Unknown #{column.inspect}"
+        column[:type].inspect
+        return ""
+      end
+      "#{type}#{default}#{null}"
+    end
+  
+    def process_row(table, row)
+    	table.columns.each_with_index do |column, index|
+
+          if column[:type] == "time"
+            row[index] = "%02d:%02d:%02d" % [row[index].hour, row[index].minute, row[index].second]
+          end
+        
+          if 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')
+          end
+        
+          if column_type(column) == "boolean"
+            row[index] = row[index] == 1 ? 't' : row[index] == 0 ? 'f' : row[index]
+          end
+        
+          if row[index].is_a?(String)
+            if column_type(column) == "bytea"
+              row[index] = escape_bytea(row[index])
+            else
+              row[index] = row[index].gsub(/\\/, '\\\\\\').gsub(/\n/,'\n').gsub(/\t/,'\t').gsub(/\r/,'\r').gsub(/\0/, '')
+            end
+          end
+        
+          row[index] = '\N' if !row[index]
+        end
+    end
+  
+    def truncate(table)
+    end
+  
+  end
+
+end

data/lib/xmysql2psql/version.rb

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

data/lib/xmysql2psql/writer.rb

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

data/lib/xmysql2psql.rb

@@ -0,0 +1,41 @@
+require 'xmysql2psql/errors'
+require 'xmysql2psql/version'
+require 'xmysql2psql/config'
+require 'xmysql2psql/converter'
+require 'xmysql2psql/mysql_reader'
+require 'xmysql2psql/writer'
+require 'xmysql2psql/postgres_writer'
+require 'xmysql2psql/postgres_db_writer.rb'
+require 'xmysql2psql/postgres_file_writer.rb'
+
+
+class Xmysql2psql
+  
+  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('xmysql2psql.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/test/fixtures/config_all_options.yml

@@ -0,0 +1,38 @@
+mysql:
+ hostname: localhost
+ port: 3306
+ socket: /tmp/mysql.sock
+ 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 supress_data is true, only the schema definition will be exported/migrated, and not the data
+supress_data: true
+
+# if supress_ddl is true, only the data will be exported/imported, and not the schema
+supress_ddl: false
+
+# if force_truncate is true, forces a table truncate before table loading
+force_truncate: false

data/test/fixtures/seed_integration_tests.sql

@@ -0,0 +1,24 @@
+-- seed data for integration tests
+
+DROP TABLE IF EXISTS numeric_types_basics;
+CREATE TABLE numeric_types_basics (
+  id int,
+	f_tinyint TINYINT,
+	f_smallint SMALLINT,
+	f_mediumint MEDIUMINT,
+	f_int INT,
+	f_integer INTEGER,
+	f_bigint BIGINT,
+	f_real REAL,
+	f_double DOUBLE,
+	f_float FLOAT,
+	f_decimal DECIMAL,
+	f_numeric NUMERIC
+);
+
+INSERT INTO numeric_types_basics VALUES
+(1,1,1,1,1,1,1,1,1,1,1,1),
+(2,2,2,2,2,2,2,2,2,2,2,2),
+(23,23,23,23,23,23,23,23,23,23,23,23);
+
+

data/test/integration/convert_to_db_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+require 'xmysql2psql'
+
+class ConvertToDbTest < Test::Unit::TestCase
+
+  class << self
+    def startup
+      seed_test_database
+      @@options=get_test_config_by_label(:localmysql_to_db_convert_all)
+      @@xmysql2psql = Xmysql2psql.new([@@options.filepath])
+      @@xmysql2psql.convert
+      @@xmysql2psql.writer.open
+    end
+    def shutdown
+      @@xmysql2psql.writer.close
+      delete_files_for_test_config(@@options)
+    end
+  end
+  def setup
+  end
+  def teardown
+  end
+
+  def test_table_creation
+    assert_true @@xmysql2psql.writer.exists?('numeric_types_basics')
+  end
+
+end

data/test/integration/convert_to_file_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+require 'xmysql2psql'
+
+class ConvertToFileTest < Test::Unit::TestCase
+
+  class << self
+    def startup
+      seed_test_database
+      @@options=get_test_config_by_label(:localmysql_to_file_convert_all)
+      @@xmysql2psql = Xmysql2psql.new([@@options.filepath])
+      @@xmysql2psql.convert
+      @@content = IO.read(@@xmysql2psql.options.destfile)
+    end
+    def shutdown
+      delete_files_for_test_config(@@options)
+    end
+  end
+  def setup
+  end
+  def teardown
+  end
+  def content
+    @@content
+  end
+  
+  def test_table_creation
+    assert_not_nil content.match('DROP TABLE IF EXISTS "numeric_types_basics" CASCADE')
+    assert_not_nil content.match(/CREATE TABLE "numeric_types_basics"/)
+  end
+
+  def test_basic_numerics_tinyint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_tinyint" smallint,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_smallint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_smallint" integer,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_mediumint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_mediumint" integer,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_int
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_int" integer,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_integer
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_integer" integer,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_bigint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_bigint" bigint,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_real
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_real" double precision,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_double
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_double" double precision,.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_float
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_float" numeric\(20, 0\),.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_decimal
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_decimal" numeric\(10, 0\),.*\)', Regexp::MULTILINE).match( content )
+  end
+  def test_basic_numerics_numeric
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_numeric" numeric\(10, 0\)[\w\n]*\)', Regexp::MULTILINE).match( content )
+  end
+
+end