firebird 0.10.0

data/test/DatabaseTestCases.rb

@@ -0,0 +1,183 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class DatabaseTestCases < FbTestCase
+  def setup
+    super
+    @parms = get_db_conn_params
+    @reader = @parms.merge(:username => 'rubytest', :password => 'rubytest', :role => 'READER')
+    @writer = @parms.merge(:username => 'rubytest', :password => 'rubytest', :role => 'WRITER')
+    @database = @reader[:database]
+    @db_file = @database.split(":", 2).last
+  end
+
+  def test_new
+    db = Database.new
+    assert_instance_of Database, db
+  end
+
+  def test_properties_read
+    db = Database.new
+    assert_nil db.database
+    assert_nil db.username
+    assert_nil db.password
+    assert_nil db.charset
+    assert_nil db.role
+  end
+
+  def test_properties_write
+    db = Database.new
+    db.database = @database
+    assert_equal @database, db.database
+    db.username = 'sysdba'
+    assert_equal 'sysdba', db.username
+    db.password = 'masterkey'
+    assert_equal 'masterkey', db.password
+    db.charset = 'NONE'
+    assert_equal 'NONE', db.charset
+    db.role = 'READER'
+    assert_equal 'READER', db.role
+  end
+
+  def test_initialize_hash
+    db = Database.new(@parms)
+    assert_equal @database, db.database
+    assert_equal @parms[:username], db.username
+    assert_equal @parms[:password], db.password
+    assert_equal 'NONE', db.charset
+    assert_equal 'READER', db.role
+  end
+
+  def test_initialize_string
+    params = @parms
+    params_s = get_db_conn_string(params)
+    db = Database.new params_s
+    assert_equal @database, db.database
+    assert_equal params[:username], db.username
+    assert_equal params[:password], db.password
+    assert_equal 'NONE', db.charset
+    assert_equal 'READER', db.role
+  end
+
+  def test_create_instance
+    db = Database.new(@parms)
+    db.create
+    assert File.exist?(@db_file)
+  end
+
+  def test_create_instance_block
+    db = Database.new(@parms)
+    db.create do |connection|
+      connection.execute("select * from RDB$DATABASE") do |cursor|
+        row = cursor.fetch
+        assert_instance_of Array, row
+      end
+      assert_equal 3, connection.dialect
+      assert_equal 3, connection.db_dialect
+    end
+    assert File.exist?(@db_file)
+  end
+
+  def test_create_singleton
+    Database.create(@parms);
+    assert File.exist?(@db_file)
+  end
+
+  def test_create_singleton_with_defaults
+    Database.create(:database => @parms[:database]);
+    assert File.exist?(@db_file)
+  end
+
+  def test_create_singleton_block
+    db = Database.create(@parms) do |connection|
+      connection.execute("select * from RDB$DATABASE") do |cursor|
+        row = cursor.fetch
+        assert_instance_of Array, row
+      end
+    end
+    assert_instance_of Database, db
+    assert File.exist?(@db_file)
+  end
+
+  def test_create_bad_param
+    assert_raises TypeError do
+      Database.create(1)
+    end
+  end
+
+  def test_create_bad_page_size
+    assert_raises Error do
+      Database.create(@parms.merge(:page_size => 1000))
+    end
+  end
+
+  def test_connect_instance
+    db = Database.create(@parms)
+    connection = db.connect
+    assert_instance_of Connection, connection
+    connection.close
+  end
+
+  def test_connect_singleton
+    Database.create(@parms)
+    connection = Database.connect(@parms)
+    assert_instance_of Connection, connection
+    connection.close
+  end
+
+  def test_drop_instance
+    assert !File.exist?(@db_file)
+    db = Database.create(@parms)
+    assert File.exist?(@db_file)
+    db.drop
+    assert !File.exist?(@db_file)
+  end
+
+  def test_drop_singleton
+    assert !File.exist?(@db_file)
+    Database.create(@parms)
+    assert File.exist?(@db_file)
+    Database.drop(@parms)
+    assert !File.exist?(@db_file)
+  end
+
+  def test_role_support
+    Database.create(@parms) do |connection|
+      connection.execute("create table test (id int, test varchar(10))")
+      connection.execute("create role writer")
+      connection.execute("grant all on test to writer")
+      connection.execute("insert into test values (1, 'test role')")
+    end
+
+    connection = Database.connect(@parms)
+    begin
+      connection.execute("drop user rubytest")
+      connection.commit
+    rescue Error
+    ensure
+      connection.close rescue nil
+    end
+
+    Database.connect(@parms) do |connection|
+      connection.execute("CREATE USER rubytest password 'rubytest'")
+      connection.execute("GRANT WRITER TO rubytest")
+      connection.commit
+    end
+
+    Database.connect(@reader) do |connection|
+      assert_raises Error do
+        connection.execute("select * from test") do |cursor|
+          flunk "Should not reach here."
+        end
+      end
+    end
+
+    Database.connect(@writer) do |connection|
+      connection.execute("select * from test") do |cursor|
+        row = cursor.fetch :hash
+        assert_equal 1, row["ID"]
+        assert_equal 'test role', row["TEST"]
+      end
+    end
+  end
+end
+

data/test/EncodingTestCases.rb

@@ -0,0 +1,39 @@
+#coding:utf-8
+require File.expand_path("../test_helper", __FILE__)
+
+if RUBY_VERSION =~ /^1.9/
+  class EncodingTestCases < FbTestCase
+    def test_encoding
+      sql_schema = <<-END
+        create table TEST (
+          ID INTEGER,
+          C10 CHAR(10),
+          VC10 VARCHAR(10),
+          MEMO BLOB SUB_TYPE TEXT)
+        END
+      sql_insert = <<-END
+        insert into test
+          (ID, C10, VC10, MEMO)
+          values
+          (?, ?, ?, ?);
+        END
+      sql_select = "select * from TEST order by ID"
+      lorem = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+
+      params = @parms.merge(:encoding => "UTF-8")
+      Database.create(params) do |connection|
+        connection.execute(sql_schema)
+        connection.execute(sql_insert, 1, "abcdef", "한글", lorem)
+        row = connection.query(sql_select).first
+
+        assert_equal 1, row[0]
+        assert_equal  Encoding::UTF_8, row[1].encoding
+        assert_equal "abcdef    ", row[1]
+        assert_equal  Encoding::UTF_8, row[2].encoding
+        assert_equal "한글", row[2]
+        assert_equal  Encoding::UTF_8, row[3].encoding
+        assert_equal lorem, row[3]
+      end
+    end
+  end
+end

data/test/NumericDataTypesTestCases.rb

@@ -0,0 +1,588 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class NumericDataTypesTestCases < FbTestCase
+  def setup
+    super
+    @connection = Database.create(@parms).connect
+  end
+
+  def teardown
+    @connection.drop
+  end
+
+  def prepare_test_table(datatype)
+    @table = "test#{@id ||= 0 + 1}"
+    @connection.execute("create table #{@table} (val #{datatype})")
+  end
+
+  def write_and_read_value(insert_value)
+    @connection.execute("insert into #{@table} (val) values (?)", insert_value)
+    read_value = @connection.query("select * from #{@table}")[0][0]
+    @connection.execute("delete from #{@table}")
+    read_value
+  end
+
+  def test_smallint_max
+    prepare_test_table("smallint")
+    assert_equal 32767, write_and_read_value(32767)
+    assert_equal 32767, write_and_read_value("32767")
+    assert_equal 32767, write_and_read_value(32767.0)
+    assert_equal 32767, write_and_read_value(BigDecimal("32767"))
+    assert write_and_read_value(32767).is_a?(Integer)
+    assert write_and_read_value("32767").is_a?(Integer)
+    assert write_and_read_value(32767.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("32767")).is_a?(Integer)
+  end
+
+  def test_smallint_min
+    prepare_test_table("smallint")
+    assert_equal -32768, write_and_read_value(-32768)
+    assert_equal -32768, write_and_read_value("-32768")
+    assert_equal -32768, write_and_read_value(-32768.0)
+    assert_equal -32768, write_and_read_value(BigDecimal("-32768"))
+    assert write_and_read_value(-32768).is_a?(Integer)
+    assert write_and_read_value("-32768").is_a?(Integer)
+    assert write_and_read_value(-32768.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("-32768")).is_a?(Integer)
+  end
+
+  def test_smallint_rounding
+    prepare_test_table("smallint")
+    assert_equal 0, write_and_read_value(0.4)
+    assert_equal 0, write_and_read_value("0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("0.4"))
+    assert_equal 0, write_and_read_value(-0.4)
+    assert_equal 0, write_and_read_value("-0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.4"))
+    assert_equal 1, write_and_read_value(0.5)
+    assert_equal 1, write_and_read_value("0.5")
+    assert_equal 1, write_and_read_value(BigDecimal("0.5"))
+    assert_equal -1, write_and_read_value(-0.5)
+    assert_equal -1, write_and_read_value("-0.5")
+    assert_equal -1, write_and_read_value(BigDecimal("-0.5"))
+  end
+
+  def test_smallint_input_type
+    prepare_test_table("smallint")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_smallint_input_range
+    prepare_test_table("smallint")
+    assert_raises(RangeError) { write_and_read_value(32768) }
+    assert_raises(RangeError) { write_and_read_value("32768") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("32768")) }
+    assert_raises(RangeError) { write_and_read_value(-32769) }
+    assert_raises(RangeError) { write_and_read_value("-32769") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-32769")) }
+  end
+
+  def test_integer_max
+    prepare_test_table("integer")
+    assert_equal 2147483647, write_and_read_value(2147483647)
+    assert_equal 2147483647, write_and_read_value("2147483647")
+    assert_equal 2147483647, write_and_read_value(2147483647.0)
+    assert_equal 2147483647, write_and_read_value(BigDecimal("2147483647"))
+    assert write_and_read_value(2147483647).is_a?(Integer)
+    assert write_and_read_value("2147483647").is_a?(Integer)
+    assert write_and_read_value(2147483647.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("2147483647")).is_a?(Integer)
+  end
+
+  def test_integer_min
+    prepare_test_table("integer")
+    assert_equal -2147483648, write_and_read_value(-2147483648)
+    assert_equal -2147483648, write_and_read_value("-2147483648")
+    assert_equal -2147483648, write_and_read_value(-2147483648.0)
+    assert_equal -2147483648, write_and_read_value(BigDecimal("-2147483648"))
+    assert write_and_read_value(-2147483648).is_a?(Integer)
+    assert write_and_read_value("-2147483648").is_a?(Integer)
+    assert write_and_read_value(-2147483648.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("-2147483648")).is_a?(Integer)
+  end
+
+  def test_integer_rounding
+    prepare_test_table("integer")
+    assert_equal 0, write_and_read_value(0.4)
+    assert_equal 0, write_and_read_value("0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("0.4"))
+    assert_equal 0, write_and_read_value(-0.4)
+    assert_equal 0, write_and_read_value("-0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.4"))
+    assert_equal 1, write_and_read_value(0.5)
+    assert_equal 1, write_and_read_value("0.5")
+    assert_equal 1, write_and_read_value(BigDecimal("0.5"))
+    assert_equal -1, write_and_read_value(-0.5)
+    assert_equal -1, write_and_read_value("-0.5")
+    assert_equal -1, write_and_read_value(BigDecimal("-0.5"))
+  end
+
+  def test_integer_input_type
+    prepare_test_table("integer")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_integer_input_range
+    prepare_test_table("integer")
+    assert_raises(RangeError) { write_and_read_value(2147483648) }
+    assert_raises(RangeError) { write_and_read_value("2147483648") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("2147483648")) }
+    assert_raises(RangeError) { write_and_read_value(-2147483649) }
+    assert_raises(RangeError) { write_and_read_value("-2147483649") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-2147483649")) }
+  end
+
+  def test_bigint_max
+    prepare_test_table("bigint")
+    assert_equal 9223372036854775807, write_and_read_value(9223372036854775807)
+    assert_equal 9223372036854775807, write_and_read_value("9223372036854775807")
+    #assert_equal 9223372036854775807, write_and_read_value(9223372036854775807.0)
+    assert_equal 9223372036854775807, write_and_read_value(BigDecimal("9223372036854775807"))
+    assert write_and_read_value(9223372036854775807).is_a?(Integer)
+    assert write_and_read_value("9223372036854775807").is_a?(Integer)
+    #assert write_and_read_value(9223372036854775807.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("9223372036854775807")).is_a?(Integer)
+  end
+
+  def test_bigint_min
+    prepare_test_table("bigint")
+    assert_equal(-9223372036854775808, write_and_read_value(-9223372036854775808))
+    assert_equal(-9223372036854775808, write_and_read_value("-9223372036854775808"))
+    #assert_equal -9223372036854775808, write_and_read_value(-9223372036854775808.0)
+    assert_equal -9223372036854775808, write_and_read_value(BigDecimal("-9223372036854775808"))
+    assert write_and_read_value(-9223372036854775808).is_a?(Integer)
+    assert write_and_read_value("-9223372036854775808").is_a?(Integer)
+    #assert write_and_read_value(-9223372036854775808.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("-9223372036854775808")).is_a?(Integer)
+  end
+
+  def test_bigint_rounding
+    prepare_test_table("bigint")
+    assert_equal 0, write_and_read_value(0.4)
+    assert_equal 0, write_and_read_value("0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("0.4"))
+    assert_equal 0, write_and_read_value(-0.4)
+    assert_equal 0, write_and_read_value("-0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.4"))
+    assert_equal 1, write_and_read_value(0.5)
+    assert_equal 1, write_and_read_value("0.5")
+    assert_equal 1, write_and_read_value(BigDecimal("0.5"))
+    assert_equal -1, write_and_read_value(-0.5)
+    assert_equal -1, write_and_read_value("-0.5")
+    assert_equal -1, write_and_read_value(BigDecimal("-0.5"))
+  end
+
+  def test_bigint_input_type
+    prepare_test_table("bigint")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_bigint_input_range
+    prepare_test_table("bigint")
+    assert_raises(RangeError) { write_and_read_value(9223372036854775808) }
+    assert_raises(RangeError) { write_and_read_value("9223372036854775808") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("9223372036854775808")) }
+    assert_raises(RangeError) { write_and_read_value(-9223372036854775809) }
+    assert_raises(RangeError) { write_and_read_value("-9223372036854775809") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-9223372036854775809")) }
+  end
+
+  def test_decimal_4_0_max
+    prepare_test_table("decimal(4, 0)")
+    assert_equal 32767, write_and_read_value(32767)
+    assert_equal 32767, write_and_read_value("32767")
+    assert_equal 32767, write_and_read_value(32767.0)
+    assert_equal 32767, write_and_read_value(BigDecimal("32767"))
+    assert write_and_read_value(32767).is_a?(Integer)
+    assert write_and_read_value("32767").is_a?(Integer)
+    assert write_and_read_value(32767.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("32767")).is_a?(Integer)
+  end
+
+  def test_decimal_4_0_min
+    prepare_test_table("decimal(4, 0)")
+    assert_equal -32768, write_and_read_value(-32768)
+    assert_equal -32768, write_and_read_value("-32768")
+    assert_equal -32768, write_and_read_value(-32768.0)
+    assert_equal -32768, write_and_read_value(BigDecimal("-32768"))
+    assert write_and_read_value(-32768).is_a?(Integer)
+    assert write_and_read_value("-32768").is_a?(Integer)
+    assert write_and_read_value(-32768.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("-32768")).is_a?(Integer)
+  end
+
+  def test_decimal_4_0_rounding
+    prepare_test_table("decimal(4, 0)")
+    assert_equal 0, write_and_read_value(0.4)
+    assert_equal 0, write_and_read_value("0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("0.4"))
+    assert_equal 0, write_and_read_value(-0.4)
+    assert_equal 0, write_and_read_value("-0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.4"))
+    assert_equal 1, write_and_read_value(0.5)
+    assert_equal 1, write_and_read_value("0.5")
+    assert_equal 1, write_and_read_value(BigDecimal("0.5"))
+    assert_equal -1, write_and_read_value(-0.5)
+    assert_equal -1, write_and_read_value("-0.5")
+    assert_equal -1, write_and_read_value(BigDecimal("-0.5"))
+  end
+
+  def test_decimal_4_0_input_type
+    prepare_test_table("decimal(4, 0)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_4_0_input_range
+    prepare_test_table("decimal(4, 0)")
+    assert_raises(RangeError) { write_and_read_value(2147483648) }
+    assert_raises(RangeError) { write_and_read_value("2147483648") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("2147483648")) }
+    assert_raises(RangeError) { write_and_read_value(-2147483649) }
+    assert_raises(RangeError) { write_and_read_value("-2147483649") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-2147483649")) }
+  end
+
+  def test_decimal_9_0_max
+    prepare_test_table("decimal(9, 0)")
+    assert_equal 2147483647, write_and_read_value(2147483647)
+    assert_equal 2147483647, write_and_read_value("2147483647")
+    assert_equal 2147483647, write_and_read_value(2147483647.0)
+    assert_equal 2147483647, write_and_read_value(BigDecimal("2147483647"))
+    assert write_and_read_value(2147483647).is_a?(Integer)
+    assert write_and_read_value("2147483647").is_a?(Integer)
+    assert write_and_read_value(2147483647.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("2147483647")).is_a?(Integer)
+  end
+
+  def test_decimal_9_0_min
+    prepare_test_table("decimal(9, 0)")
+    assert_equal 2147483647, write_and_read_value(2147483647)
+    assert_equal 2147483647, write_and_read_value("2147483647")
+    assert_equal 2147483647, write_and_read_value(2147483647.0)
+    assert_equal 2147483647, write_and_read_value(BigDecimal("2147483647"))
+    assert write_and_read_value(2147483647).is_a?(Integer)
+    assert write_and_read_value("2147483647").is_a?(Integer)
+    assert write_and_read_value(2147483647.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("2147483647")).is_a?(Integer)
+  end
+
+  def test_decimal_9_0_rounding
+    prepare_test_table("decimal(9, 0)")
+    assert_equal 0, write_and_read_value(0.4)
+    assert_equal 0, write_and_read_value("0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("0.4"))
+    assert_equal 0, write_and_read_value(-0.4)
+    assert_equal 0, write_and_read_value("-0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.4"))
+    assert_equal 1, write_and_read_value(0.5)
+    assert_equal 1, write_and_read_value("0.5")
+    assert_equal 1, write_and_read_value(BigDecimal("0.5"))
+    assert_equal -1, write_and_read_value(-0.5)
+    assert_equal -1, write_and_read_value("-0.5")
+    assert_equal -1, write_and_read_value(BigDecimal("-0.5"))
+  end
+
+  def test_decimal_9_0_input_type
+    prepare_test_table("decimal(9, 0)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_9_0_input_range
+    prepare_test_table("decimal(9, 0)")
+    assert_raises(RangeError) { write_and_read_value(2147483648) }
+    assert_raises(RangeError) { write_and_read_value("2147483648") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("2147483648")) }
+    assert_raises(RangeError) { write_and_read_value(-2147483649) }
+    assert_raises(RangeError) { write_and_read_value("-2147483649") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-2147483649")) }
+  end
+
+  def test_decimal_9_4_max
+    prepare_test_table("decimal(9, 4)")
+    assert_equal BigDecimal("214748.3647"), write_and_read_value("214748.3647")
+    assert_equal BigDecimal("214748.3647"), write_and_read_value(214748.3647)
+    assert_equal BigDecimal("214748.3647"), write_and_read_value(BigDecimal("214748.3647"))
+    assert write_and_read_value("214748.3647").is_a?(BigDecimal)
+    assert write_and_read_value(214748.3647).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("214748.3647")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_9_4_min
+    prepare_test_table("decimal(9, 4)")
+    assert_equal BigDecimal("-214748.3648"), write_and_read_value("-214748.3648")
+    assert_equal BigDecimal("-214748.3648"), write_and_read_value(-214748.3648)
+    assert_equal BigDecimal("-214748.3648"), write_and_read_value(BigDecimal("-214748.3648"))
+    assert write_and_read_value("-214748.3648").is_a?(BigDecimal)
+    assert write_and_read_value(-214748.3648).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("-214748.3648")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_9_4_rounding
+    prepare_test_table("decimal(9, 4)")
+    assert_equal 0, write_and_read_value(0.00004)
+    assert_equal 0, write_and_read_value("0.00004")
+    assert_equal 0, write_and_read_value(BigDecimal("0.00004"))
+    assert_equal 0, write_and_read_value(-0.00004)
+    assert_equal 0, write_and_read_value("-0.00004")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.00004"))
+    assert_equal BigDecimal('0.0001'), write_and_read_value(0.00005)
+    assert_equal BigDecimal('0.0001'), write_and_read_value("0.00005")
+    assert_equal BigDecimal('0.0001'), write_and_read_value(BigDecimal("0.00005"))
+    assert_equal BigDecimal('-0.0001'), write_and_read_value(-0.00005)
+    assert_equal BigDecimal('-0.0001'), write_and_read_value("-0.00005")
+    assert_equal BigDecimal('-0.0001'), write_and_read_value(BigDecimal("-0.00005"))
+  end
+
+  def test_decimal_9_4_input_type
+    prepare_test_table("decimal(9, 4)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_9_4_input_range
+    prepare_test_table("decimal(9, 4)")
+    assert_raises(RangeError) { write_and_read_value(214748.3648) }
+    assert_raises(RangeError) { write_and_read_value("214748.3648") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("214748.3648")) }
+    assert_raises(RangeError) { write_and_read_value(-214748.3649) }
+    assert_raises(RangeError) { write_and_read_value("-214748.3649") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-214748.3649")) }
+  end
+
+  def test_decimal_9_9_max
+    prepare_test_table("decimal(9, 9)")
+    assert_equal BigDecimal("2.147483647"), write_and_read_value("2.147483647")
+    assert_equal BigDecimal("2.147483647"), write_and_read_value(2.147483647)
+    assert_equal BigDecimal("2.147483647"), write_and_read_value(BigDecimal("2.147483647"))
+    assert write_and_read_value("2.147483647").is_a?(BigDecimal)
+    assert write_and_read_value(2.147483647).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("2.147483647")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_9_9_min
+    prepare_test_table("decimal(9, 9)")
+    assert_equal BigDecimal("-2.147483648"), write_and_read_value("-2.147483648")
+    assert_equal BigDecimal("-2.147483648"), write_and_read_value(-2.147483648)
+    assert_equal BigDecimal("-2.147483648"), write_and_read_value(BigDecimal("-2.147483648"))
+    assert write_and_read_value("-2.147483648").is_a?(BigDecimal)
+    assert write_and_read_value(-2.147483648).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("-2.147483648")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_9_9_rounding
+    prepare_test_table("decimal(9, 9)")
+    assert_equal 0, write_and_read_value(0.0000000004)
+    assert_equal 0, write_and_read_value("0.0000000004")
+    assert_equal 0, write_and_read_value(BigDecimal("0.0000000004"))
+    assert_equal 0, write_and_read_value(-0.0000000004)
+    assert_equal 0, write_and_read_value("-0.0000000004")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.0000000004"))
+    assert_equal BigDecimal("0.000000001"), write_and_read_value(0.0000000005)
+    assert_equal BigDecimal("0.000000001"), write_and_read_value("0.0000000005")
+    assert_equal BigDecimal("0.000000001"), write_and_read_value(BigDecimal("0.0000000005"))
+    assert_equal BigDecimal("-0.000000001"), write_and_read_value(-0.0000000005)
+    assert_equal BigDecimal("-0.000000001"), write_and_read_value("-0.0000000005")
+    assert_equal BigDecimal("-0.000000001"), write_and_read_value(BigDecimal("-0.0000000005"))
+  end
+
+  def test_decimal_9_9_input_type
+    prepare_test_table("decimal(9, 9)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_9_9_input_range
+    prepare_test_table("decimal(9, 9)")
+    assert_raises(RangeError) { write_and_read_value(2.147483648) }
+    assert_raises(RangeError) { write_and_read_value("2.147483648") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("2.147483648")) }
+    assert_raises(RangeError) { write_and_read_value(-2.147483649) }
+    assert_raises(RangeError) { write_and_read_value("-2.147483649") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-2.147483649")) }
+  end
+
+  def test_decimal_18_0_max
+    prepare_test_table("decimal(18, 0)")
+    assert_equal 9223372036854775807, write_and_read_value(9223372036854775807)
+    assert_equal 9223372036854775807, write_and_read_value("9223372036854775807")
+    #assert_equal 9223372036854775807, write_and_read_value(9223372036854775807.0)
+    assert_equal 9223372036854775807, write_and_read_value(BigDecimal("9223372036854775807"))
+    assert write_and_read_value(9223372036854775807).is_a?(Integer)
+    assert write_and_read_value("9223372036854775807").is_a?(Integer)
+    #assert write_and_read_value(9223372036854775807.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("9223372036854775807")).is_a?(Integer)
+  end
+
+  def test_decimal_18_0_min
+    prepare_test_table("decimal(18, 0)")
+    assert_equal(-9223372036854775808, write_and_read_value(-9223372036854775808))
+    assert_equal(-9223372036854775808, write_and_read_value("-9223372036854775808"))
+    #assert_equal -9223372036854775808, write_and_read_value(-9223372036854775808.0)
+    assert_equal -9223372036854775808, write_and_read_value(BigDecimal("-9223372036854775808"))
+    assert write_and_read_value(-9223372036854775808).is_a?(Integer)
+    assert write_and_read_value("-9223372036854775808").is_a?(Integer)
+    #assert write_and_read_value(-9223372036854775808.0).is_a?(Integer)
+    assert write_and_read_value(BigDecimal("-9223372036854775808")).is_a?(Integer)
+  end
+
+  def test_decimal_18_0_rounding
+    prepare_test_table("decimal(18, 0)")
+    assert_equal 0, write_and_read_value(0.4)
+    assert_equal 0, write_and_read_value("0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("0.4"))
+    assert_equal 0, write_and_read_value(-0.4)
+    assert_equal 0, write_and_read_value("-0.4")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.4"))
+    assert_equal 1, write_and_read_value(0.5)
+    assert_equal 1, write_and_read_value("0.5")
+    assert_equal 1, write_and_read_value(BigDecimal("0.5"))
+    assert_equal -1, write_and_read_value(-0.5)
+    assert_equal -1, write_and_read_value("-0.5")
+    assert_equal -1, write_and_read_value(BigDecimal("-0.5"))
+  end
+
+  def test_decimal_18_0_input_types
+    prepare_test_table("decimal(18, 0)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_18_0_input_range
+    prepare_test_table("decimal(18, 0)")
+    assert_raises(RangeError) { write_and_read_value(9223372036854775808) }
+    assert_raises(RangeError) { write_and_read_value("9223372036854775808") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("9223372036854775808")) }
+    assert_raises(RangeError) { write_and_read_value(-9223372036854775809) }
+    assert_raises(RangeError) { write_and_read_value("-9223372036854775809") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-9223372036854775809")) }
+  end
+
+  def test_decimal_18_9_max
+    prepare_test_table("decimal(18, 9)")
+    assert_equal BigDecimal("9223372036.854775807"), write_and_read_value("9223372036.854775807")
+    #assert_equal BigDecimal("9223372036.854775807"), write_and_read_value(9223372036.854775807)
+    assert_equal BigDecimal("9223372036.854775807"), write_and_read_value(BigDecimal("9223372036.854775807"))
+    assert write_and_read_value("9223372036.854775807").is_a?(BigDecimal)
+    #assert write_and_read_value(9223372036.854775807).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("9223372036.854775807")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_18_9_min
+    prepare_test_table("decimal(18, 9)")
+    assert_equal BigDecimal("-9223372036.854775808"), write_and_read_value("-9223372036.854775808")
+    #assert_equal BigDecimal("-9223372036.854775808"), write_and_read_value(-9223372036.854775808)
+    assert_equal BigDecimal("-9223372036.854775808"), write_and_read_value(BigDecimal("-9223372036.854775808"))
+    assert write_and_read_value("-9223372036.854775808").is_a?(BigDecimal)
+    #assert write_and_read_value(-9223372036.854775808).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("-9223372036.854775808")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_18_9_rounding
+    prepare_test_table("decimal(18, 9)")
+    assert_equal 0, write_and_read_value(0.0000000004)
+    assert_equal 0, write_and_read_value("0.0000000004")
+    assert_equal 0, write_and_read_value(BigDecimal("0.0000000004"))
+    assert_equal 0, write_and_read_value(-0.0000000004)
+    assert_equal 0, write_and_read_value("-0.0000000004")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.0000000004"))
+    assert_equal BigDecimal('0.000000001'), write_and_read_value(0.0000000005)
+    assert_equal BigDecimal('0.000000001'), write_and_read_value("0.0000000005")
+    assert_equal BigDecimal('0.000000001'), write_and_read_value(BigDecimal("0.0000000005"))
+    assert_equal BigDecimal('-0.000000001'), write_and_read_value(-0.0000000005)
+    assert_equal BigDecimal('-0.000000001'), write_and_read_value("-0.0000000005")
+    assert_equal BigDecimal('-0.000000001'), write_and_read_value(BigDecimal("-0.0000000005"))
+  end
+
+  def test_decimal_18_9_input_type
+    prepare_test_table("decimal(18, 9)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_18_9_input_range
+    prepare_test_table("decimal(18, 9)")
+    assert_raises(RangeError) { write_and_read_value(9223372036.854775808) }
+    assert_raises(RangeError) { write_and_read_value("9223372036.854775808") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("9223372036.854775808")) }
+    assert_raises(RangeError) { write_and_read_value(-9223372036.854775809) }
+    assert_raises(RangeError) { write_and_read_value("-9223372036.854775809") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-9223372036.854775809")) }
+  end
+
+  def test_decimal_18_18_max
+    prepare_test_table("decimal(18, 18)")
+    assert_equal BigDecimal("9.223372036854775807"), write_and_read_value(BigDecimal("9.223372036854775807"))
+    #assert_equal BigDecimal("9.223372036854775807"), write_and_read_value(9.223372036854775807)
+    assert_equal BigDecimal("9.223372036854775807"), write_and_read_value("9.223372036854775807")
+    assert write_and_read_value("9.223372036854775807").is_a?(BigDecimal)
+    #assert write_and_read_value(9.223372036854775807).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("9.223372036854775807")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_18_18_min
+    prepare_test_table("decimal(18, 18)")
+    assert_equal BigDecimal("-9.223372036854775808"), write_and_read_value("-9.223372036854775808")
+    #assert_equal BigDecimal("-9.223372036854775808"), write_and_read_value(-9.223372036854775808)
+    assert_equal BigDecimal("-9.223372036854775808"), write_and_read_value(BigDecimal("-9.223372036854775808"))
+    assert write_and_read_value("-9.223372036854775808").is_a?(BigDecimal)
+    #assert write_and_read_value(-9.223372036854775808).is_a?(BigDecimal)
+    assert write_and_read_value(BigDecimal("-9.223372036854775808")).is_a?(BigDecimal)
+  end
+
+  def test_decimal_18_18_rounding
+    prepare_test_table("decimal(18, 18)")
+    assert_equal 0, write_and_read_value(0.0000000000000000004)
+    assert_equal 0, write_and_read_value("0.0000000000000000004")
+    assert_equal 0, write_and_read_value(BigDecimal("0.0000000000000000004"))
+    assert_equal 0, write_and_read_value(-0.0000000000000000004)
+    assert_equal 0, write_and_read_value("-0.0000000000000000004")
+    assert_equal 0, write_and_read_value(BigDecimal("-0.0000000000000000004"))
+    assert_equal BigDecimal("0.000000000000000001"), write_and_read_value(0.0000000000000000005)
+    assert_equal BigDecimal("0.000000000000000001"), write_and_read_value("0.0000000000000000005")
+    assert_equal BigDecimal("0.000000000000000001"), write_and_read_value(BigDecimal("0.0000000000000000005"))
+    assert_equal BigDecimal("-0.000000000000000001"), write_and_read_value(-0.0000000000000000005)
+    assert_equal BigDecimal("-0.000000000000000001"), write_and_read_value("-0.0000000000000000005")
+    assert_equal BigDecimal("-0.000000000000000001"), write_and_read_value(BigDecimal("-0.0000000000000000005"))
+  end
+
+  def test_decimal_18_18_input_type
+    prepare_test_table("decimal(18, 18)")
+    #assert_raises(TypeError) { write_and_read_value('abcde') }
+    assert_raises(TypeError) { write_and_read_value(Date.new) }
+    assert_raises(TypeError) { write_and_read_value(Time.new) }
+    assert_raises(TypeError) { write_and_read_value(Object.new) }
+  end
+
+  def test_decimal_18_18_input_range
+    prepare_test_table("decimal(18, 18)")
+    assert_raises(RangeError) { write_and_read_value(9.223372036854775808) }
+    assert_raises(RangeError) { write_and_read_value("9.223372036854775808") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("9.223372036854775808")) }
+    assert_raises(RangeError) { write_and_read_value(-9.223372036854775809) }
+    assert_raises(RangeError) { write_and_read_value("-9.223372036854775809") }
+    assert_raises(RangeError) { write_and_read_value(BigDecimal("-9.223372036854775809")) }
+  end
+end