fb 0.7.4 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56b9a209c188f5a267c3dda503f72226a467eaa2
-  data.tar.gz: e443a11b2c99d410856eabdc463cf8146e9fb261
+  metadata.gz: 8d355708819fa90d7b6d797ea6a66d4df6bc724c
+  data.tar.gz: 6ec6b2d0ec8ca6725a69378ad511712cb68b2841
 SHA512:
-  metadata.gz: 2b1d66d743e5649eb9fcf65406b8e1d78b747cac4e420867954b02b792875ddb2acf5b8c06a396d7c674869afdb2d0c24b4f903c940f062c8c622f1be24bbe1a
-  data.tar.gz: dda09a0abc589816ce41e88a13d40d335787ee9d9b6c3978f56f96b129fe1ca6b849e5e7d2955737c823cc40dac221b7197a6cd7e733b6e41c5f978f911af3a6
+  metadata.gz: c6438765aa02be661b1ca49b21459b200329dc4466d925509be5967ea3bc9658b239b55a6206a4100ee0c0f69a6a56f25fd34eb0a6304be06303cfb288f069d1
+  data.tar.gz: 642f27e3b5d0d5adbe28ed6692453278a9b6beb2c5e1f9f715679e72a699655a4d494f13356e37e4664f658fa71ca55303832a75d03ba1f81f5a6a59fd7ebee7

data/fb.c

@@ -141,10 +141,6 @@ typedef struct trans_opts
 	struct trans_opts *sub_opts;
 } trans_opts;
 
-/* global data */
-/* static isc_tr_handle global_transact = 0; */	/* transaction handle */
-/* static int connection_count = 0; */
-
 /* global utilities */
 
 #define	FB_ALIGN(n, b)	((n + b - 1) & ~(b - 1))
@@ -325,24 +321,22 @@ static void tm_from_timestamp(struct tm *tm, VALUE obj)
 #endif
 }
 
-static VALUE long_from_obj(VALUE obj)
-{
-	ID id_to_str = rb_intern("to_str");
-	if (TYPE(obj) != T_FIXNUM && rb_respond_to(obj, id_to_str))
-	{
-		VALUE s = rb_funcall(obj, id_to_str, 0);
-		obj = rb_funcall(s, rb_intern("to_i"), 0);
-	}
-	return obj;
-}
-
-static VALUE ll_from_obj(VALUE obj)
+static VALUE object_to_fixnum(VALUE object)
 {
-	if (TYPE(obj) == T_STRING)
+	if (TYPE(object) != T_FIXNUM && TYPE(object) != T_BIGNUM)
 	{
-		obj = rb_funcall(obj, rb_intern("to_i"), 0);
+		if (TYPE(object) == T_FLOAT || !strcmp(rb_class2name(CLASS_OF(object)), "BigDecimal"))
+			object = rb_funcall(object, rb_intern("round"), 0);
+		else if (TYPE(object) == T_STRING)
+			object = rb_funcall(rb_funcall(rb_mKernel, rb_intern("BigDecimal"), 1, object), rb_intern("round"), 0);
+		else if (!strcmp(rb_class2name(CLASS_OF(object)), "Time"))
+			rb_raise(rb_eTypeError, "Time value not allowed as Integer");
+		else if (rb_respond_to(object, rb_intern("to_i")))
+			object = rb_funcall(object, rb_intern("to_i"), 0);
+		else
+			rb_raise(rb_eTypeError, "Value doesn't respond to 'to_i' for conversion");
 	}
-	return obj;
+	return (object);
 }
 
 static VALUE double_from_obj(VALUE obj)
@@ -507,21 +501,6 @@ static void fb_connection_check(struct FbConnection *fb_connection)
 	}
 }
 
-/*
-static void global_close_cursors()
-{
-	struct FbConnection *list = fb_connection_list;
-	int i;
-
-	while (list) {
-		for (i = 0; i < RARRAY(list->cursor)->len; i++) {
-			cursor_close(RARRAY(list->cursor)->ptr[i]);
-		}
-		list = list->next;
-	}
-}
-*/
-
 static void fb_connection_close_cursors(struct FbConnection *fb_connection)
 {
 	int i;
@@ -541,28 +520,6 @@ static void fb_connection_drop_cursors(struct FbConnection *fb_connection)
   rb_ary_clear(fb_connection->cursor);
 }
 
-/*
-static void fb_connection_remove(struct FbConnection *fb_connection)
-{
-	if (fb_connection_list != NULL) {
-		if (fb_connection_list == fb_connection) {
-			fb_connection_list = fb_connection_list->next;
-		} else {
-			struct FbConnection *list = fb_connection_list;
-			while (list->next) {
-				if (list->next == fb_connection) {
-					list->next = fb_connection->next;
-					break;
-				}
-				list = list->next;
-			}
-		}
-		fb_connection->db = 0;
-		connection_count--;
-	}
-}
-*/
-
 static void fb_connection_disconnect(struct FbConnection *fb_connection)
 {
 	if (fb_connection->transact) {
@@ -575,7 +532,6 @@ static void fb_connection_disconnect(struct FbConnection *fb_connection)
 		isc_detach_database(fb_connection->isc_status, &fb_connection->db);
 	}
 	fb_error_check(fb_connection->isc_status);
-	/* fb_connection_remove(fb_connection); */
 }
 
 static void fb_connection_disconnect_warn(struct FbConnection *fb_connection)
@@ -586,7 +542,6 @@ static void fb_connection_disconnect_warn(struct FbConnection *fb_connection)
 	}
 	isc_detach_database(fb_connection->isc_status, &fb_connection->db);
 	fb_error_check_warn(fb_connection->isc_status);
-	/* fb_connection_remove(fb_connection); */
 }
 
 static void fb_connection_mark(struct FbConnection *fb_connection)
@@ -957,145 +912,6 @@ error:
 	rb_raise(rb_eFbError, "%s", desc);
 }
 
-/*
-static void set_teb_vec(ISC_TEB *vec, struct FbConnection *fb_connection, char *tpb, int len)
-{
-	vec->dbb_ptr = &fb_connection->db;
-	if (tpb) {
-		vec->tpb_ptr = tpb;
-		vec->tpb_len = len;
-	} else {
-		vec->tpb_ptr = 0;
-		vec->tpb_len = 0;
-	}
-}
-*/
-
-/*
-static void global_transaction_start(VALUE opt, int argc, VALUE *argv)
-{
-	ISC_STATUS isc_status[20];
-	struct FbConnection *fb_connection;
-	ISC_TEB *teb_vec = ALLOCA_N(ISC_TEB, connection_count);
-	ISC_TEB *vec = teb_vec;
-	char *tpb = 0;
-	short n;
-	int tpb_len;
-
-	if (global_transact) {
-		rb_raise(rb_eFbError, "The transaction has been already started");
-	}
-
-	if (!NIL_P(opt)) {
-		tpb = trans_parseopts(opt, &tpb_len);
-	}
-
-	if (argc > connection_count) {
-		rb_raise(rb_eFbError, "Too many databases specified for the transaction");
-	}
-	if (argc == 0) {
-		n = connection_count;
-		for (fb_connection = fb_connection_list; fb_connection; fb_connection = fb_connection->next) {
-			set_teb_vec(vec, fb_connection, tpb, tpb_len);
-			vec++;
-		}
-	} else {
-		for (n = 0; n < argc; n++) {
-			fb_connection = fb_connection_check_retrieve(argv[n]);
-			set_teb_vec(vec, fb_connection, tpb, tpb_len);
-			vec++;
-		}
-	}
-
-	isc_start_multiple(isc_status, &global_transact, n, teb_vec);
-	xfree(tpb);
-	fb_error_check(isc_status);
-}
-*/
-
-/* call-seq:
- *   commit() -> nil
- *
- * Commit the current (global) transaction.
- */
-/*
-static VALUE global_commit()
-{
-	ISC_STATUS isc_status[20];
-
-	if (global_transact) {
-		global_close_cursors();
-		isc_commit_transaction(isc_status, &global_transact);
-		fb_error_check(isc_status);
-	}
-	return Qnil;
-}
-*/
-
-/* call-seq:
- *   rollback() -> nil
- *
- * Rollback the current (global) transaction.
- */
-/*
-static VALUE global_rollback()
-{
-	ISC_STATUS isc_status[20];
-
-	if (global_transact) {
-		global_close_cursors();
-		isc_rollback_transaction(isc_status, &global_transact);
-		fb_error_check(isc_status);
-	}
-	return Qnil;
-}
-*/
-
-/* call-seq:
- *   transaction(options, *connections) -> true
- *   transaction(options, *connections) { } -> block result
- *
- * Start a (global) transaction.
- */
-/*
-static VALUE global_transaction(int argc, VALUE *argv, VALUE self)
-{
-	VALUE opt = Qnil;
-
-	if (argc > 0) {
-		opt = *argv++;
-		argc--;
-	}
-	global_transaction_start(opt, argc, argv);
-
-	if (rb_block_given_p()) {
-		int state;
-		VALUE result = rb_protect(rb_yield, 0, &state);
-		if (state) {
-			global_rollback();
-			return rb_funcall(rb_mKernel, rb_intern("raise"), 0);
-		} else {
-			global_commit();
-			return result;
-		}
-	} else {
-		return Qtrue;
-   	}
-}
-*/
-
-/* call-seq:
- *   transaction_started()? -> true or false
- *
- * Returns true if a transaction is currently active.
- */
-/*
-static VALUE global_transaction_started()
-{
-	return global_transact ? Qtrue : Qfalse;
-}
-*/
-
 static void fb_connection_transaction_start(struct FbConnection *fb_connection, VALUE opt)
 {
 	char *tpb = 0;
@@ -1467,6 +1283,32 @@ static void fb_cursor_free(struct FbCursor *fb_cursor)
 	xfree(fb_cursor);
 }
 
+static VALUE sql_decimal_to_bigdecimal(long long sql_data, int scale)
+{
+	int  i;
+	char bigdecimal_buffer[23];
+	int  bigdecimal_dot;
+	sprintf(bigdecimal_buffer, "%022lld", sql_data);
+	bigdecimal_dot = strlen(bigdecimal_buffer) + scale;
+	for (i = strlen(bigdecimal_buffer); i > bigdecimal_dot; i--)
+		bigdecimal_buffer[i] = bigdecimal_buffer[i-1];
+	bigdecimal_buffer[bigdecimal_dot] = '.';
+	return rb_funcall(rb_path2class("BigDecimal"), rb_intern("new"), 1, rb_str_new2(bigdecimal_buffer));
+}
+
+static VALUE object_to_unscaled_bigdecimal(VALUE object, int scale)
+{
+	int i;
+	long ratio = 1;
+	for (i = 0; i > scale; i--)
+		ratio *= 10;
+	if (TYPE(object) == T_FLOAT)
+		object = rb_funcall(object, rb_intern("to_s"), 0);
+	object = rb_funcall(rb_path2class("BigDecimal"), rb_intern("new"), 1, object);
+	object = rb_funcall(object, rb_intern("*"), 1, LONG2NUM(ratio));
+	return rb_funcall(object, rb_intern("round"), 0);
+}
+
 static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VALUE *argv)
 {
 	struct FbConnection *fb_connection;
@@ -1478,9 +1320,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 	long lvalue;
 	ISC_INT64 llvalue;
 	long alignment;
-	double ratio;
 	double dvalue;
-	long scnt;
 	double dcheck;
 	VARY *vary;
 	XSQLVAR *var;
@@ -1547,21 +1387,11 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (var->sqlscale < 0) {
-						ratio = 1;
-						for (scnt = 0; scnt > var->sqlscale; scnt--)
-							ratio *= 10;
-						obj = double_from_obj(obj);
-						dvalue = NUM2DBL(obj) * ratio;
-						if (dvalue >= 0.0) {
-							lvalue = (ISC_LONG)(dvalue + 0.5);
-						} else {
-							lvalue = (ISC_LONG)(dvalue - 0.5);
-						}
+						lvalue = NUM2LONG(object_to_unscaled_bigdecimal(obj, var->sqlscale));
 					} else {
-						obj = long_from_obj(obj);
-						lvalue = NUM2LONG(obj);
+						lvalue = NUM2LONG(object_to_fixnum(obj));
 					}
-					if (lvalue < SHRT_MIN || lvalue > SHRT_MAX) {
+					if (lvalue < -32768 || lvalue > 32767) {
 						rb_raise(rb_eRangeError, "short integer overflow");
 					}
 					*(short *)var->sqldata = lvalue;
@@ -1572,22 +1402,12 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (var->sqlscale < 0) {
-						ratio = 1;
-						for (scnt = 0; scnt > var->sqlscale; scnt--)
-							ratio *= 10;
-						obj = double_from_obj(obj);
-						dvalue = NUM2DBL(obj) * ratio;
-						if (dvalue >= 0.0) {
-							lvalue = (ISC_LONG)(dvalue + 0.5);
-						} else {
-							lvalue = (ISC_LONG)(dvalue - 0.5);
-						}
+						lvalue = NUM2LONG(object_to_unscaled_bigdecimal(obj, var->sqlscale));
 					} else {
-						obj = long_from_obj(obj);
-						lvalue = NUM2LONG(obj);
+						lvalue = NUM2LONG(object_to_fixnum(obj));
 					}
-					if (lvalue < -2147483647 || lvalue > 2147483647) {
-                        rb_raise(rb_eRangeError, "integer overflow");
+					if (lvalue < -2147483648 || lvalue > 2147483647) {
+						rb_raise(rb_eRangeError, "integer overflow");
 					}
 					*(ISC_LONG *)var->sqldata = (ISC_LONG)lvalue;
 					offset += alignment;
@@ -1624,19 +1444,9 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 
 					if (var->sqlscale < 0) {
-						ratio = 1;
-						for (scnt = 0; scnt > var->sqlscale; scnt--)
-							ratio *= 10;
-						obj = double_from_obj(obj);
-						dvalue = NUM2DBL(obj) * ratio;
-						if (dvalue >= 0.0) {
-							llvalue = (ISC_INT64)(dvalue + 0.5);
-						} else {
-							llvalue = (ISC_INT64)(dvalue - 0.5);
-						}
+						llvalue = NUM2LL(object_to_unscaled_bigdecimal(obj, var->sqlscale));
 					} else {
-						obj = ll_from_obj(obj);
-						llvalue = NUM2LL(obj);
+						llvalue = NUM2LL(object_to_fixnum(obj));
 					}
 
 					*(ISC_INT64 *)var->sqldata = llvalue;
@@ -1941,9 +1751,6 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 	long dtp;
 	VALUE val;
 	VARY *vary;
-	double ratio;
-	double dval;
-	long scnt;
 	struct tm tms;
 
 	isc_blob_handle blob_handle;
@@ -2008,10 +1815,7 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 
 				case SQL_SHORT:
 					if (var->sqlscale < 0) {
-						ratio = 1;
-						for (scnt = 0; scnt > var->sqlscale; scnt--) ratio *= 10;
-						dval = (double)*(short*)var->sqldata/ratio;
-						val = rb_float_new(dval);
+						val = sql_decimal_to_bigdecimal((long long)*(ISC_SHORT*)var->sqldata, var->sqlscale);
 					} else {
 						val = INT2NUM((long)*(short*)var->sqldata);
 					}
@@ -2019,10 +1823,7 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 
 				case SQL_LONG:
 					if (var->sqlscale < 0) {
-						ratio = 1;
-						for (scnt = 0; scnt > var->sqlscale; scnt--) ratio *= 10;
-						dval = (double)*(ISC_LONG*)var->sqldata/ratio;
-						val = rb_float_new(dval);
+						val = sql_decimal_to_bigdecimal((long long)*(ISC_LONG*)var->sqldata, var->sqlscale);
 					} else {
 						val = INT2NUM(*(ISC_LONG*)var->sqldata);
 					}
@@ -2037,14 +1838,11 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 					break;
 
 				case SQL_INT64:
-        				if (var->sqlscale < 0) {
-        					ratio = 1;
-        					for (scnt = 0; scnt > var->sqlscale; scnt--) ratio *= 10;
-        					dval = (double)*(ISC_INT64*)var->sqldata/ratio;
-        					val = rb_float_new(dval);
-        				} else {
-        					val = LL2NUM(*(ISC_INT64*)var->sqldata);
-        				}
+					if (var->sqlscale < 0) {
+						val = sql_decimal_to_bigdecimal(*(ISC_INT64*)var->sqldata, var->sqlscale);
+					} else {
+						val = LL2NUM(*(ISC_INT64*)var->sqldata);
+					}
 					break;
 
 				case SQL_TIMESTAMP:
@@ -2375,6 +2173,7 @@ static VALUE cursor_fetch(int argc, VALUE* argv, VALUE self)
 	fb_cursor_fetch_prep(fb_cursor);
 
 	ary = fb_cursor_fetch(fb_cursor);
+	if (NIL_P(ary)) return Qnil;
 	return hash_row ? fb_hash_from_ary(fb_cursor->fields_ary, ary) : ary;
 }
 
@@ -2609,11 +2408,6 @@ static VALUE connection_create(isc_db_handle handle, VALUE db)
 	fb_connection->db = handle;
 	fb_connection->transact = 0;
 	fb_connection->cursor = rb_ary_new();
-/*
-	connection_count++;
-	fb_connection->next = fb_connection_list;
-	fb_connection_list = fb_connection;
-*/
 	dialect = SQL_DIALECT_CURRENT;
 	db_dialect = fb_connection_db_SQL_Dialect(fb_connection);
 
@@ -3120,6 +2914,8 @@ static VALUE database_s_drop(int argc, VALUE *argv, VALUE klass)
 
 void Init_fb()
 {
+	rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("bigdecimal"));
+
 	rb_mFb = rb_define_module("Fb");
 
 	rb_cFbDatabase = rb_define_class_under(rb_mFb, "Database", rb_cData);
@@ -3182,14 +2978,6 @@ void Init_fb()
 	rb_cFbSqlType = rb_define_class_under(rb_mFb, "SqlType", rb_cData);
 	rb_define_singleton_method(rb_cFbSqlType, "from_code", sql_type_from_code, 2);
 
-/*
-	rb_cFbGlobal = rb_define_class_under(rb_mFb, "Global", rb_cData);
-	rb_define_singleton_method(rb_cFbGlobal, "transaction", global_transaction, -1);
-	rb_define_singleton_method(rb_cFbGlobal, "transaction_started", global_transaction_started, 0);
-	rb_define_singleton_method(rb_cFbGlobal, "commit", global_commit, 0);
-	rb_define_singleton_method(rb_cFbGlobal, "rollback", global_rollback, 0);
-*/
-
 	rb_eFbError = rb_define_class_under(rb_mFb, "Error", rb_eStandardError);
 	rb_define_method(rb_eFbError, "error_code", error_error_code, 0);
 

data/test/CursorTestCases.rb

@@ -11,6 +11,12 @@ class CursorTestCases < FbTestCase
         assert_instance_of Array, row
         assert_equal 4, row.size
       end
+      connection.execute("select * from rdb$database where rdb$description = 'bogus'") do |cursor|
+        assert_instance_of Cursor, cursor
+        row = cursor.fetch :array
+        assert_instance_of NilClass, row
+        assert_equal nil, row
+      end
       connection.drop
     end
   end
@@ -23,6 +29,12 @@ class CursorTestCases < FbTestCase
         assert_instance_of Hash, row
         assert_equal 4, row.size
       end
+      connection.execute("select * from rdb$database where rdb$description = 'bogus'") do |cursor|
+        assert_instance_of Cursor, cursor
+        row = cursor.fetch :hash
+        assert_instance_of NilClass, row
+        assert_equal nil, row
+      end
       connection.drop
     end
   end

data/test/DataTypesTestCases.rb

@@ -1,3 +1,4 @@
+require 'bigdecimal'
 require 'test/FbTestCases'
 
 class DataTypesTestCases < FbTestCase
@@ -482,7 +483,7 @@ class DataTypesTestCases < FbTestCase
           connection.execute(sql_insert, "12345.12")
           connection.execute(sql_insert, -12345.12)
           vals = connection.query(sql_select)
-          # puts vals.inspect
+          assert vals[0][0].is_a?(BigDecimal), "Numeric(9, 2) must return BigDecimal"
           assert_equal 12345.12, vals[0][0], "NUMERIC (decimal)"
           assert_equal 12345.12, vals[1][0], "NUMERIC (string)"
           assert_equal -12345.12, vals[2][0], "NUMERIC (string)"
@@ -491,19 +492,20 @@ class DataTypesTestCases < FbTestCase
           connection.execute(sql_insert, "12345.12")
           connection.execute(sql_insert, -12345.12)
           vals = connection.query(sql_select)
-          # puts vals.inspect
+          assert vals[0][0].is_a?(BigDecimal), "Decimal(9,2) must return BigDecimal"
           assert_equal 12345.12, vals[0][0], "DECIMAL (decimal)"
           assert_equal 12345.12, vals[1][0], "DECIMAL (string)"
           assert_equal -12345.12, vals[2][0], "DECIMAL (string)"
         elsif cols[i] == 'N154'
-          connection.execute(sql_insert, 12345.12)
-          connection.execute(sql_insert, "12345.12")
-          connection.execute(sql_insert, -12345.12)
+          connection.execute(sql_insert, 91520.65)
+          connection.execute(sql_insert, "91520.65")
+          connection.execute(sql_insert, -91520.65)
           vals = connection.query(sql_select)
-          # puts vals.inspect
-          assert_equal 12345.12, vals[0][0], "NUMERIC (decimal)"
-          assert_equal 12345.12, vals[1][0], "NUMERIC (string)"
-          assert_equal -12345.12, vals[2][0], "NUMERIC (string)"
+          assert vals[0][0].is_a?(BigDecimal), "Numeric(15,4) must return BigDecimal"
+          assert Float(91520.65) != vals[0][0]
+          assert_equal BigDecimal('91520.65'), vals[0][0]
+          assert_equal BigDecimal('91520.65'), vals[1][0]
+          assert_equal BigDecimal('-91520.65'), vals[2][0]
         end
       end
       connection.drop

data/test/FbTestSuite.rb

@@ -5,6 +5,7 @@ require 'DatabaseTestCases'
 require 'ConnectionTestCases'
 require 'CursorTestCases'
 require 'DataTypesTestCases'
+require 'NumericDataTypesTestCases'
 require 'TransactionTestCases'
 if RUBY_VERSION =~ /^1.9/
   require 'EncodingTestCases'

data/test/NumericDataTypesTestCases.rb

@@ -0,0 +1,591 @@
+require 'bigdecimal'
+require 'test/FbTestCases'
+
+class NumericDataTypesTestCases < FbTestCase
+  include FbTestCases
+
+  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?(Fixnum)
+    assert write_and_read_value("32767").is_a?(Fixnum)
+    assert write_and_read_value(32767.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("32767")).is_a?(Fixnum)
+  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?(Fixnum)
+    assert write_and_read_value("-32768").is_a?(Fixnum)
+    assert write_and_read_value(-32768.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("-32768")).is_a?(Fixnum)
+  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.new("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.new("-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.new("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.new("-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?(Fixnum)
+    assert write_and_read_value("2147483647").is_a?(Fixnum)
+    assert write_and_read_value(2147483647.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("2147483647")).is_a?(Fixnum)
+  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?(Fixnum)
+    assert write_and_read_value("-2147483648").is_a?(Fixnum)
+    assert write_and_read_value(-2147483648.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("-2147483648")).is_a?(Fixnum)
+  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.new("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.new("-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.new("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.new("-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?(Bignum)
+    assert write_and_read_value("9223372036854775807").is_a?(Bignum)
+    #assert write_and_read_value(9223372036854775807.0).is_a?(Bignum)
+    assert write_and_read_value(BigDecimal("9223372036854775807")).is_a?(Bignum)
+  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?(Bignum)
+    assert write_and_read_value("-9223372036854775808").is_a?(Bignum)
+    #assert write_and_read_value(-9223372036854775808.0).is_a?(Bignum)
+    assert write_and_read_value(BigDecimal("-9223372036854775808")).is_a?(Bignum)
+  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.new("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.new("-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.new("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.new("-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?(Fixnum)
+    assert write_and_read_value("32767").is_a?(Fixnum)
+    assert write_and_read_value(32767.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("32767")).is_a?(Fixnum)
+  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?(Fixnum)
+    assert write_and_read_value("-32768").is_a?(Fixnum)
+    assert write_and_read_value(-32768.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("-32768")).is_a?(Fixnum)
+  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.new("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.new("-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.new("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.new("-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?(Fixnum)
+    assert write_and_read_value("2147483647").is_a?(Fixnum)
+    assert write_and_read_value(2147483647.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("2147483647")).is_a?(Fixnum)
+  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?(Fixnum)
+    assert write_and_read_value("2147483647").is_a?(Fixnum)
+    assert write_and_read_value(2147483647.0).is_a?(Fixnum)
+    assert write_and_read_value(BigDecimal("2147483647")).is_a?(Fixnum)
+  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.new("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.new("-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.new("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.new("-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.new("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.new("-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.new("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.new("-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.new("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.new("-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.new("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.new("-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?(Bignum)
+    assert write_and_read_value("9223372036854775807").is_a?(Bignum)
+    #assert write_and_read_value(9223372036854775807.0).is_a?(Bignum)
+    assert write_and_read_value(BigDecimal("9223372036854775807")).is_a?(Bignum)
+  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?(Bignum)
+    assert write_and_read_value("-9223372036854775808").is_a?(Bignum)
+    #assert write_and_read_value(-9223372036854775808.0).is_a?(Bignum)
+    assert write_and_read_value(BigDecimal("-9223372036854775808")).is_a?(Bignum)
+  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.new("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.new("-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.new("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.new("-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.new("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.new("-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.new("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.new("-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.new("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.new("-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.new("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.new("-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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fb
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.7.5
 platform: ruby
 authors:
 - Brent Rowland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2016-04-14 00:00:00.000000000 Z
 dependencies: []
 description: Ruby Firebird Extension Library
 email: rowland@rowlandresearch.com
@@ -29,6 +29,7 @@ files:
 - test/EncodingTestCases.rb
 - test/FbTestCases.rb
 - test/FbTestSuite.rb
+- test/NumericDataTypesTestCases.rb
 - test/TransactionTestCases.rb
 homepage: http://github.com/rowland/fb
 licenses:
@@ -57,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Firebird client library fbclient.dll, libfbclient.so or Firebird.framework.
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Firebird database driver