fb 0.7.4 → 0.7.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/fb.c +58 -270
- data/test/CursorTestCases.rb +12 -0
- data/test/DataTypesTestCases.rb +11 -9
- data/test/FbTestSuite.rb +1 -0
- data/test/NumericDataTypesTestCases.rb +591 -0
- metadata +4 -3
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 8d355708819fa90d7b6d797ea6a66d4df6bc724c
|
4
|
+
data.tar.gz: 6ec6b2d0ec8ca6725a69378ad511712cb68b2841
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: c6438765aa02be661b1ca49b21459b200329dc4466d925509be5967ea3bc9658b239b55a6206a4100ee0c0f69a6a56f25fd34eb0a6304be06303cfb288f069d1
|
7
|
+
data.tar.gz: 642f27e3b5d0d5adbe28ed6692453278a9b6beb2c5e1f9f715679e72a699655a4d494f13356e37e4664f658fa71ca55303832a75d03ba1f81f5a6a59fd7ebee7
|
data/fb.c
CHANGED
@@ -141,10 +141,6 @@ typedef struct trans_opts
|
|
141
141
|
struct trans_opts *sub_opts;
|
142
142
|
} trans_opts;
|
143
143
|
|
144
|
-
/* global data */
|
145
|
-
/* static isc_tr_handle global_transact = 0; */ /* transaction handle */
|
146
|
-
/* static int connection_count = 0; */
|
147
|
-
|
148
144
|
/* global utilities */
|
149
145
|
|
150
146
|
#define FB_ALIGN(n, b) ((n + b - 1) & ~(b - 1))
|
@@ -325,24 +321,22 @@ static void tm_from_timestamp(struct tm *tm, VALUE obj)
|
|
325
321
|
#endif
|
326
322
|
}
|
327
323
|
|
328
|
-
static VALUE
|
329
|
-
{
|
330
|
-
ID id_to_str = rb_intern("to_str");
|
331
|
-
if (TYPE(obj) != T_FIXNUM && rb_respond_to(obj, id_to_str))
|
332
|
-
{
|
333
|
-
VALUE s = rb_funcall(obj, id_to_str, 0);
|
334
|
-
obj = rb_funcall(s, rb_intern("to_i"), 0);
|
335
|
-
}
|
336
|
-
return obj;
|
337
|
-
}
|
338
|
-
|
339
|
-
static VALUE ll_from_obj(VALUE obj)
|
324
|
+
static VALUE object_to_fixnum(VALUE object)
|
340
325
|
{
|
341
|
-
if (TYPE(
|
326
|
+
if (TYPE(object) != T_FIXNUM && TYPE(object) != T_BIGNUM)
|
342
327
|
{
|
343
|
-
|
328
|
+
if (TYPE(object) == T_FLOAT || !strcmp(rb_class2name(CLASS_OF(object)), "BigDecimal"))
|
329
|
+
object = rb_funcall(object, rb_intern("round"), 0);
|
330
|
+
else if (TYPE(object) == T_STRING)
|
331
|
+
object = rb_funcall(rb_funcall(rb_mKernel, rb_intern("BigDecimal"), 1, object), rb_intern("round"), 0);
|
332
|
+
else if (!strcmp(rb_class2name(CLASS_OF(object)), "Time"))
|
333
|
+
rb_raise(rb_eTypeError, "Time value not allowed as Integer");
|
334
|
+
else if (rb_respond_to(object, rb_intern("to_i")))
|
335
|
+
object = rb_funcall(object, rb_intern("to_i"), 0);
|
336
|
+
else
|
337
|
+
rb_raise(rb_eTypeError, "Value doesn't respond to 'to_i' for conversion");
|
344
338
|
}
|
345
|
-
return
|
339
|
+
return (object);
|
346
340
|
}
|
347
341
|
|
348
342
|
static VALUE double_from_obj(VALUE obj)
|
@@ -507,21 +501,6 @@ static void fb_connection_check(struct FbConnection *fb_connection)
|
|
507
501
|
}
|
508
502
|
}
|
509
503
|
|
510
|
-
/*
|
511
|
-
static void global_close_cursors()
|
512
|
-
{
|
513
|
-
struct FbConnection *list = fb_connection_list;
|
514
|
-
int i;
|
515
|
-
|
516
|
-
while (list) {
|
517
|
-
for (i = 0; i < RARRAY(list->cursor)->len; i++) {
|
518
|
-
cursor_close(RARRAY(list->cursor)->ptr[i]);
|
519
|
-
}
|
520
|
-
list = list->next;
|
521
|
-
}
|
522
|
-
}
|
523
|
-
*/
|
524
|
-
|
525
504
|
static void fb_connection_close_cursors(struct FbConnection *fb_connection)
|
526
505
|
{
|
527
506
|
int i;
|
@@ -541,28 +520,6 @@ static void fb_connection_drop_cursors(struct FbConnection *fb_connection)
|
|
541
520
|
rb_ary_clear(fb_connection->cursor);
|
542
521
|
}
|
543
522
|
|
544
|
-
/*
|
545
|
-
static void fb_connection_remove(struct FbConnection *fb_connection)
|
546
|
-
{
|
547
|
-
if (fb_connection_list != NULL) {
|
548
|
-
if (fb_connection_list == fb_connection) {
|
549
|
-
fb_connection_list = fb_connection_list->next;
|
550
|
-
} else {
|
551
|
-
struct FbConnection *list = fb_connection_list;
|
552
|
-
while (list->next) {
|
553
|
-
if (list->next == fb_connection) {
|
554
|
-
list->next = fb_connection->next;
|
555
|
-
break;
|
556
|
-
}
|
557
|
-
list = list->next;
|
558
|
-
}
|
559
|
-
}
|
560
|
-
fb_connection->db = 0;
|
561
|
-
connection_count--;
|
562
|
-
}
|
563
|
-
}
|
564
|
-
*/
|
565
|
-
|
566
523
|
static void fb_connection_disconnect(struct FbConnection *fb_connection)
|
567
524
|
{
|
568
525
|
if (fb_connection->transact) {
|
@@ -575,7 +532,6 @@ static void fb_connection_disconnect(struct FbConnection *fb_connection)
|
|
575
532
|
isc_detach_database(fb_connection->isc_status, &fb_connection->db);
|
576
533
|
}
|
577
534
|
fb_error_check(fb_connection->isc_status);
|
578
|
-
/* fb_connection_remove(fb_connection); */
|
579
535
|
}
|
580
536
|
|
581
537
|
static void fb_connection_disconnect_warn(struct FbConnection *fb_connection)
|
@@ -586,7 +542,6 @@ static void fb_connection_disconnect_warn(struct FbConnection *fb_connection)
|
|
586
542
|
}
|
587
543
|
isc_detach_database(fb_connection->isc_status, &fb_connection->db);
|
588
544
|
fb_error_check_warn(fb_connection->isc_status);
|
589
|
-
/* fb_connection_remove(fb_connection); */
|
590
545
|
}
|
591
546
|
|
592
547
|
static void fb_connection_mark(struct FbConnection *fb_connection)
|
@@ -957,145 +912,6 @@ error:
|
|
957
912
|
rb_raise(rb_eFbError, "%s", desc);
|
958
913
|
}
|
959
914
|
|
960
|
-
/*
|
961
|
-
static void set_teb_vec(ISC_TEB *vec, struct FbConnection *fb_connection, char *tpb, int len)
|
962
|
-
{
|
963
|
-
vec->dbb_ptr = &fb_connection->db;
|
964
|
-
if (tpb) {
|
965
|
-
vec->tpb_ptr = tpb;
|
966
|
-
vec->tpb_len = len;
|
967
|
-
} else {
|
968
|
-
vec->tpb_ptr = 0;
|
969
|
-
vec->tpb_len = 0;
|
970
|
-
}
|
971
|
-
}
|
972
|
-
*/
|
973
|
-
|
974
|
-
/*
|
975
|
-
static void global_transaction_start(VALUE opt, int argc, VALUE *argv)
|
976
|
-
{
|
977
|
-
ISC_STATUS isc_status[20];
|
978
|
-
struct FbConnection *fb_connection;
|
979
|
-
ISC_TEB *teb_vec = ALLOCA_N(ISC_TEB, connection_count);
|
980
|
-
ISC_TEB *vec = teb_vec;
|
981
|
-
char *tpb = 0;
|
982
|
-
short n;
|
983
|
-
int tpb_len;
|
984
|
-
|
985
|
-
if (global_transact) {
|
986
|
-
rb_raise(rb_eFbError, "The transaction has been already started");
|
987
|
-
}
|
988
|
-
|
989
|
-
if (!NIL_P(opt)) {
|
990
|
-
tpb = trans_parseopts(opt, &tpb_len);
|
991
|
-
}
|
992
|
-
|
993
|
-
if (argc > connection_count) {
|
994
|
-
rb_raise(rb_eFbError, "Too many databases specified for the transaction");
|
995
|
-
}
|
996
|
-
if (argc == 0) {
|
997
|
-
n = connection_count;
|
998
|
-
for (fb_connection = fb_connection_list; fb_connection; fb_connection = fb_connection->next) {
|
999
|
-
set_teb_vec(vec, fb_connection, tpb, tpb_len);
|
1000
|
-
vec++;
|
1001
|
-
}
|
1002
|
-
} else {
|
1003
|
-
for (n = 0; n < argc; n++) {
|
1004
|
-
fb_connection = fb_connection_check_retrieve(argv[n]);
|
1005
|
-
set_teb_vec(vec, fb_connection, tpb, tpb_len);
|
1006
|
-
vec++;
|
1007
|
-
}
|
1008
|
-
}
|
1009
|
-
|
1010
|
-
isc_start_multiple(isc_status, &global_transact, n, teb_vec);
|
1011
|
-
xfree(tpb);
|
1012
|
-
fb_error_check(isc_status);
|
1013
|
-
}
|
1014
|
-
*/
|
1015
|
-
|
1016
|
-
/* call-seq:
|
1017
|
-
* commit() -> nil
|
1018
|
-
*
|
1019
|
-
* Commit the current (global) transaction.
|
1020
|
-
*/
|
1021
|
-
/*
|
1022
|
-
static VALUE global_commit()
|
1023
|
-
{
|
1024
|
-
ISC_STATUS isc_status[20];
|
1025
|
-
|
1026
|
-
if (global_transact) {
|
1027
|
-
global_close_cursors();
|
1028
|
-
isc_commit_transaction(isc_status, &global_transact);
|
1029
|
-
fb_error_check(isc_status);
|
1030
|
-
}
|
1031
|
-
return Qnil;
|
1032
|
-
}
|
1033
|
-
*/
|
1034
|
-
|
1035
|
-
/* call-seq:
|
1036
|
-
* rollback() -> nil
|
1037
|
-
*
|
1038
|
-
* Rollback the current (global) transaction.
|
1039
|
-
*/
|
1040
|
-
/*
|
1041
|
-
static VALUE global_rollback()
|
1042
|
-
{
|
1043
|
-
ISC_STATUS isc_status[20];
|
1044
|
-
|
1045
|
-
if (global_transact) {
|
1046
|
-
global_close_cursors();
|
1047
|
-
isc_rollback_transaction(isc_status, &global_transact);
|
1048
|
-
fb_error_check(isc_status);
|
1049
|
-
}
|
1050
|
-
return Qnil;
|
1051
|
-
}
|
1052
|
-
*/
|
1053
|
-
|
1054
|
-
/* call-seq:
|
1055
|
-
* transaction(options, *connections) -> true
|
1056
|
-
* transaction(options, *connections) { } -> block result
|
1057
|
-
*
|
1058
|
-
* Start a (global) transaction.
|
1059
|
-
*/
|
1060
|
-
/*
|
1061
|
-
static VALUE global_transaction(int argc, VALUE *argv, VALUE self)
|
1062
|
-
{
|
1063
|
-
VALUE opt = Qnil;
|
1064
|
-
|
1065
|
-
if (argc > 0) {
|
1066
|
-
opt = *argv++;
|
1067
|
-
argc--;
|
1068
|
-
}
|
1069
|
-
global_transaction_start(opt, argc, argv);
|
1070
|
-
|
1071
|
-
if (rb_block_given_p()) {
|
1072
|
-
int state;
|
1073
|
-
VALUE result = rb_protect(rb_yield, 0, &state);
|
1074
|
-
if (state) {
|
1075
|
-
global_rollback();
|
1076
|
-
return rb_funcall(rb_mKernel, rb_intern("raise"), 0);
|
1077
|
-
} else {
|
1078
|
-
global_commit();
|
1079
|
-
return result;
|
1080
|
-
}
|
1081
|
-
} else {
|
1082
|
-
return Qtrue;
|
1083
|
-
}
|
1084
|
-
}
|
1085
|
-
*/
|
1086
|
-
|
1087
|
-
/* call-seq:
|
1088
|
-
* transaction_started()? -> true or false
|
1089
|
-
*
|
1090
|
-
* Returns true if a transaction is currently active.
|
1091
|
-
*/
|
1092
|
-
/*
|
1093
|
-
static VALUE global_transaction_started()
|
1094
|
-
{
|
1095
|
-
return global_transact ? Qtrue : Qfalse;
|
1096
|
-
}
|
1097
|
-
*/
|
1098
|
-
|
1099
915
|
static void fb_connection_transaction_start(struct FbConnection *fb_connection, VALUE opt)
|
1100
916
|
{
|
1101
917
|
char *tpb = 0;
|
@@ -1467,6 +1283,32 @@ static void fb_cursor_free(struct FbCursor *fb_cursor)
|
|
1467
1283
|
xfree(fb_cursor);
|
1468
1284
|
}
|
1469
1285
|
|
1286
|
+
static VALUE sql_decimal_to_bigdecimal(long long sql_data, int scale)
|
1287
|
+
{
|
1288
|
+
int i;
|
1289
|
+
char bigdecimal_buffer[23];
|
1290
|
+
int bigdecimal_dot;
|
1291
|
+
sprintf(bigdecimal_buffer, "%022lld", sql_data);
|
1292
|
+
bigdecimal_dot = strlen(bigdecimal_buffer) + scale;
|
1293
|
+
for (i = strlen(bigdecimal_buffer); i > bigdecimal_dot; i--)
|
1294
|
+
bigdecimal_buffer[i] = bigdecimal_buffer[i-1];
|
1295
|
+
bigdecimal_buffer[bigdecimal_dot] = '.';
|
1296
|
+
return rb_funcall(rb_path2class("BigDecimal"), rb_intern("new"), 1, rb_str_new2(bigdecimal_buffer));
|
1297
|
+
}
|
1298
|
+
|
1299
|
+
static VALUE object_to_unscaled_bigdecimal(VALUE object, int scale)
|
1300
|
+
{
|
1301
|
+
int i;
|
1302
|
+
long ratio = 1;
|
1303
|
+
for (i = 0; i > scale; i--)
|
1304
|
+
ratio *= 10;
|
1305
|
+
if (TYPE(object) == T_FLOAT)
|
1306
|
+
object = rb_funcall(object, rb_intern("to_s"), 0);
|
1307
|
+
object = rb_funcall(rb_path2class("BigDecimal"), rb_intern("new"), 1, object);
|
1308
|
+
object = rb_funcall(object, rb_intern("*"), 1, LONG2NUM(ratio));
|
1309
|
+
return rb_funcall(object, rb_intern("round"), 0);
|
1310
|
+
}
|
1311
|
+
|
1470
1312
|
static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VALUE *argv)
|
1471
1313
|
{
|
1472
1314
|
struct FbConnection *fb_connection;
|
@@ -1478,9 +1320,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
|
|
1478
1320
|
long lvalue;
|
1479
1321
|
ISC_INT64 llvalue;
|
1480
1322
|
long alignment;
|
1481
|
-
double ratio;
|
1482
1323
|
double dvalue;
|
1483
|
-
long scnt;
|
1484
1324
|
double dcheck;
|
1485
1325
|
VARY *vary;
|
1486
1326
|
XSQLVAR *var;
|
@@ -1547,21 +1387,11 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
|
|
1547
1387
|
offset = FB_ALIGN(offset, alignment);
|
1548
1388
|
var->sqldata = (char *)(fb_cursor->i_buffer + offset);
|
1549
1389
|
if (var->sqlscale < 0) {
|
1550
|
-
|
1551
|
-
for (scnt = 0; scnt > var->sqlscale; scnt--)
|
1552
|
-
ratio *= 10;
|
1553
|
-
obj = double_from_obj(obj);
|
1554
|
-
dvalue = NUM2DBL(obj) * ratio;
|
1555
|
-
if (dvalue >= 0.0) {
|
1556
|
-
lvalue = (ISC_LONG)(dvalue + 0.5);
|
1557
|
-
} else {
|
1558
|
-
lvalue = (ISC_LONG)(dvalue - 0.5);
|
1559
|
-
}
|
1390
|
+
lvalue = NUM2LONG(object_to_unscaled_bigdecimal(obj, var->sqlscale));
|
1560
1391
|
} else {
|
1561
|
-
|
1562
|
-
lvalue = NUM2LONG(obj);
|
1392
|
+
lvalue = NUM2LONG(object_to_fixnum(obj));
|
1563
1393
|
}
|
1564
|
-
if (lvalue <
|
1394
|
+
if (lvalue < -32768 || lvalue > 32767) {
|
1565
1395
|
rb_raise(rb_eRangeError, "short integer overflow");
|
1566
1396
|
}
|
1567
1397
|
*(short *)var->sqldata = lvalue;
|
@@ -1572,22 +1402,12 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
|
|
1572
1402
|
offset = FB_ALIGN(offset, alignment);
|
1573
1403
|
var->sqldata = (char *)(fb_cursor->i_buffer + offset);
|
1574
1404
|
if (var->sqlscale < 0) {
|
1575
|
-
|
1576
|
-
for (scnt = 0; scnt > var->sqlscale; scnt--)
|
1577
|
-
ratio *= 10;
|
1578
|
-
obj = double_from_obj(obj);
|
1579
|
-
dvalue = NUM2DBL(obj) * ratio;
|
1580
|
-
if (dvalue >= 0.0) {
|
1581
|
-
lvalue = (ISC_LONG)(dvalue + 0.5);
|
1582
|
-
} else {
|
1583
|
-
lvalue = (ISC_LONG)(dvalue - 0.5);
|
1584
|
-
}
|
1405
|
+
lvalue = NUM2LONG(object_to_unscaled_bigdecimal(obj, var->sqlscale));
|
1585
1406
|
} else {
|
1586
|
-
|
1587
|
-
lvalue = NUM2LONG(obj);
|
1407
|
+
lvalue = NUM2LONG(object_to_fixnum(obj));
|
1588
1408
|
}
|
1589
|
-
if (lvalue < -
|
1590
|
-
|
1409
|
+
if (lvalue < -2147483648 || lvalue > 2147483647) {
|
1410
|
+
rb_raise(rb_eRangeError, "integer overflow");
|
1591
1411
|
}
|
1592
1412
|
*(ISC_LONG *)var->sqldata = (ISC_LONG)lvalue;
|
1593
1413
|
offset += alignment;
|
@@ -1624,19 +1444,9 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
|
|
1624
1444
|
var->sqldata = (char *)(fb_cursor->i_buffer + offset);
|
1625
1445
|
|
1626
1446
|
if (var->sqlscale < 0) {
|
1627
|
-
|
1628
|
-
for (scnt = 0; scnt > var->sqlscale; scnt--)
|
1629
|
-
ratio *= 10;
|
1630
|
-
obj = double_from_obj(obj);
|
1631
|
-
dvalue = NUM2DBL(obj) * ratio;
|
1632
|
-
if (dvalue >= 0.0) {
|
1633
|
-
llvalue = (ISC_INT64)(dvalue + 0.5);
|
1634
|
-
} else {
|
1635
|
-
llvalue = (ISC_INT64)(dvalue - 0.5);
|
1636
|
-
}
|
1447
|
+
llvalue = NUM2LL(object_to_unscaled_bigdecimal(obj, var->sqlscale));
|
1637
1448
|
} else {
|
1638
|
-
|
1639
|
-
llvalue = NUM2LL(obj);
|
1449
|
+
llvalue = NUM2LL(object_to_fixnum(obj));
|
1640
1450
|
}
|
1641
1451
|
|
1642
1452
|
*(ISC_INT64 *)var->sqldata = llvalue;
|
@@ -1941,9 +1751,6 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
|
|
1941
1751
|
long dtp;
|
1942
1752
|
VALUE val;
|
1943
1753
|
VARY *vary;
|
1944
|
-
double ratio;
|
1945
|
-
double dval;
|
1946
|
-
long scnt;
|
1947
1754
|
struct tm tms;
|
1948
1755
|
|
1949
1756
|
isc_blob_handle blob_handle;
|
@@ -2008,10 +1815,7 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
|
|
2008
1815
|
|
2009
1816
|
case SQL_SHORT:
|
2010
1817
|
if (var->sqlscale < 0) {
|
2011
|
-
|
2012
|
-
for (scnt = 0; scnt > var->sqlscale; scnt--) ratio *= 10;
|
2013
|
-
dval = (double)*(short*)var->sqldata/ratio;
|
2014
|
-
val = rb_float_new(dval);
|
1818
|
+
val = sql_decimal_to_bigdecimal((long long)*(ISC_SHORT*)var->sqldata, var->sqlscale);
|
2015
1819
|
} else {
|
2016
1820
|
val = INT2NUM((long)*(short*)var->sqldata);
|
2017
1821
|
}
|
@@ -2019,10 +1823,7 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
|
|
2019
1823
|
|
2020
1824
|
case SQL_LONG:
|
2021
1825
|
if (var->sqlscale < 0) {
|
2022
|
-
|
2023
|
-
for (scnt = 0; scnt > var->sqlscale; scnt--) ratio *= 10;
|
2024
|
-
dval = (double)*(ISC_LONG*)var->sqldata/ratio;
|
2025
|
-
val = rb_float_new(dval);
|
1826
|
+
val = sql_decimal_to_bigdecimal((long long)*(ISC_LONG*)var->sqldata, var->sqlscale);
|
2026
1827
|
} else {
|
2027
1828
|
val = INT2NUM(*(ISC_LONG*)var->sqldata);
|
2028
1829
|
}
|
@@ -2037,14 +1838,11 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
|
|
2037
1838
|
break;
|
2038
1839
|
|
2039
1840
|
case SQL_INT64:
|
2040
|
-
|
2041
|
-
|
2042
|
-
|
2043
|
-
|
2044
|
-
|
2045
|
-
} else {
|
2046
|
-
val = LL2NUM(*(ISC_INT64*)var->sqldata);
|
2047
|
-
}
|
1841
|
+
if (var->sqlscale < 0) {
|
1842
|
+
val = sql_decimal_to_bigdecimal(*(ISC_INT64*)var->sqldata, var->sqlscale);
|
1843
|
+
} else {
|
1844
|
+
val = LL2NUM(*(ISC_INT64*)var->sqldata);
|
1845
|
+
}
|
2048
1846
|
break;
|
2049
1847
|
|
2050
1848
|
case SQL_TIMESTAMP:
|
@@ -2375,6 +2173,7 @@ static VALUE cursor_fetch(int argc, VALUE* argv, VALUE self)
|
|
2375
2173
|
fb_cursor_fetch_prep(fb_cursor);
|
2376
2174
|
|
2377
2175
|
ary = fb_cursor_fetch(fb_cursor);
|
2176
|
+
if (NIL_P(ary)) return Qnil;
|
2378
2177
|
return hash_row ? fb_hash_from_ary(fb_cursor->fields_ary, ary) : ary;
|
2379
2178
|
}
|
2380
2179
|
|
@@ -2609,11 +2408,6 @@ static VALUE connection_create(isc_db_handle handle, VALUE db)
|
|
2609
2408
|
fb_connection->db = handle;
|
2610
2409
|
fb_connection->transact = 0;
|
2611
2410
|
fb_connection->cursor = rb_ary_new();
|
2612
|
-
/*
|
2613
|
-
connection_count++;
|
2614
|
-
fb_connection->next = fb_connection_list;
|
2615
|
-
fb_connection_list = fb_connection;
|
2616
|
-
*/
|
2617
2411
|
dialect = SQL_DIALECT_CURRENT;
|
2618
2412
|
db_dialect = fb_connection_db_SQL_Dialect(fb_connection);
|
2619
2413
|
|
@@ -3120,6 +2914,8 @@ static VALUE database_s_drop(int argc, VALUE *argv, VALUE klass)
|
|
3120
2914
|
|
3121
2915
|
void Init_fb()
|
3122
2916
|
{
|
2917
|
+
rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("bigdecimal"));
|
2918
|
+
|
3123
2919
|
rb_mFb = rb_define_module("Fb");
|
3124
2920
|
|
3125
2921
|
rb_cFbDatabase = rb_define_class_under(rb_mFb, "Database", rb_cData);
|
@@ -3182,14 +2978,6 @@ void Init_fb()
|
|
3182
2978
|
rb_cFbSqlType = rb_define_class_under(rb_mFb, "SqlType", rb_cData);
|
3183
2979
|
rb_define_singleton_method(rb_cFbSqlType, "from_code", sql_type_from_code, 2);
|
3184
2980
|
|
3185
|
-
/*
|
3186
|
-
rb_cFbGlobal = rb_define_class_under(rb_mFb, "Global", rb_cData);
|
3187
|
-
rb_define_singleton_method(rb_cFbGlobal, "transaction", global_transaction, -1);
|
3188
|
-
rb_define_singleton_method(rb_cFbGlobal, "transaction_started", global_transaction_started, 0);
|
3189
|
-
rb_define_singleton_method(rb_cFbGlobal, "commit", global_commit, 0);
|
3190
|
-
rb_define_singleton_method(rb_cFbGlobal, "rollback", global_rollback, 0);
|
3191
|
-
*/
|
3192
|
-
|
3193
2981
|
rb_eFbError = rb_define_class_under(rb_mFb, "Error", rb_eStandardError);
|
3194
2982
|
rb_define_method(rb_eFbError, "error_code", error_error_code, 0);
|
3195
2983
|
|
data/test/CursorTestCases.rb
CHANGED
@@ -11,6 +11,12 @@ class CursorTestCases < FbTestCase
|
|
11
11
|
assert_instance_of Array, row
|
12
12
|
assert_equal 4, row.size
|
13
13
|
end
|
14
|
+
connection.execute("select * from rdb$database where rdb$description = 'bogus'") do |cursor|
|
15
|
+
assert_instance_of Cursor, cursor
|
16
|
+
row = cursor.fetch :array
|
17
|
+
assert_instance_of NilClass, row
|
18
|
+
assert_equal nil, row
|
19
|
+
end
|
14
20
|
connection.drop
|
15
21
|
end
|
16
22
|
end
|
@@ -23,6 +29,12 @@ class CursorTestCases < FbTestCase
|
|
23
29
|
assert_instance_of Hash, row
|
24
30
|
assert_equal 4, row.size
|
25
31
|
end
|
32
|
+
connection.execute("select * from rdb$database where rdb$description = 'bogus'") do |cursor|
|
33
|
+
assert_instance_of Cursor, cursor
|
34
|
+
row = cursor.fetch :hash
|
35
|
+
assert_instance_of NilClass, row
|
36
|
+
assert_equal nil, row
|
37
|
+
end
|
26
38
|
connection.drop
|
27
39
|
end
|
28
40
|
end
|
data/test/DataTypesTestCases.rb
CHANGED
@@ -1,3 +1,4 @@
|
|
1
|
+
require 'bigdecimal'
|
1
2
|
require 'test/FbTestCases'
|
2
3
|
|
3
4
|
class DataTypesTestCases < FbTestCase
|
@@ -482,7 +483,7 @@ class DataTypesTestCases < FbTestCase
|
|
482
483
|
connection.execute(sql_insert, "12345.12")
|
483
484
|
connection.execute(sql_insert, -12345.12)
|
484
485
|
vals = connection.query(sql_select)
|
485
|
-
|
486
|
+
assert vals[0][0].is_a?(BigDecimal), "Numeric(9, 2) must return BigDecimal"
|
486
487
|
assert_equal 12345.12, vals[0][0], "NUMERIC (decimal)"
|
487
488
|
assert_equal 12345.12, vals[1][0], "NUMERIC (string)"
|
488
489
|
assert_equal -12345.12, vals[2][0], "NUMERIC (string)"
|
@@ -491,19 +492,20 @@ class DataTypesTestCases < FbTestCase
|
|
491
492
|
connection.execute(sql_insert, "12345.12")
|
492
493
|
connection.execute(sql_insert, -12345.12)
|
493
494
|
vals = connection.query(sql_select)
|
494
|
-
|
495
|
+
assert vals[0][0].is_a?(BigDecimal), "Decimal(9,2) must return BigDecimal"
|
495
496
|
assert_equal 12345.12, vals[0][0], "DECIMAL (decimal)"
|
496
497
|
assert_equal 12345.12, vals[1][0], "DECIMAL (string)"
|
497
498
|
assert_equal -12345.12, vals[2][0], "DECIMAL (string)"
|
498
499
|
elsif cols[i] == 'N154'
|
499
|
-
connection.execute(sql_insert,
|
500
|
-
connection.execute(sql_insert, "
|
501
|
-
connection.execute(sql_insert, -
|
500
|
+
connection.execute(sql_insert, 91520.65)
|
501
|
+
connection.execute(sql_insert, "91520.65")
|
502
|
+
connection.execute(sql_insert, -91520.65)
|
502
503
|
vals = connection.query(sql_select)
|
503
|
-
|
504
|
-
|
505
|
-
assert_equal
|
506
|
-
assert_equal
|
504
|
+
assert vals[0][0].is_a?(BigDecimal), "Numeric(15,4) must return BigDecimal"
|
505
|
+
assert Float(91520.65) != vals[0][0]
|
506
|
+
assert_equal BigDecimal('91520.65'), vals[0][0]
|
507
|
+
assert_equal BigDecimal('91520.65'), vals[1][0]
|
508
|
+
assert_equal BigDecimal('-91520.65'), vals[2][0]
|
507
509
|
end
|
508
510
|
end
|
509
511
|
connection.drop
|
data/test/FbTestSuite.rb
CHANGED
@@ -0,0 +1,591 @@
|
|
1
|
+
require 'bigdecimal'
|
2
|
+
require 'test/FbTestCases'
|
3
|
+
|
4
|
+
class NumericDataTypesTestCases < FbTestCase
|
5
|
+
include FbTestCases
|
6
|
+
|
7
|
+
def setup
|
8
|
+
super
|
9
|
+
@connection = Database.create(@parms).connect
|
10
|
+
end
|
11
|
+
|
12
|
+
def teardown
|
13
|
+
@connection.drop
|
14
|
+
end
|
15
|
+
|
16
|
+
def prepare_test_table(datatype)
|
17
|
+
@table = "test#{@id ||= 0 + 1}"
|
18
|
+
@connection.execute("create table #{@table} (val #{datatype})")
|
19
|
+
end
|
20
|
+
|
21
|
+
def write_and_read_value(insert_value)
|
22
|
+
@connection.execute("insert into #{@table} (val) values (?)", insert_value)
|
23
|
+
read_value = @connection.query("select * from #{@table}")[0][0]
|
24
|
+
@connection.execute("delete from #{@table}")
|
25
|
+
read_value
|
26
|
+
end
|
27
|
+
|
28
|
+
def test_smallint_max
|
29
|
+
prepare_test_table("smallint")
|
30
|
+
assert_equal 32767, write_and_read_value(32767)
|
31
|
+
assert_equal 32767, write_and_read_value("32767")
|
32
|
+
assert_equal 32767, write_and_read_value(32767.0)
|
33
|
+
assert_equal 32767, write_and_read_value(BigDecimal("32767"))
|
34
|
+
assert write_and_read_value(32767).is_a?(Fixnum)
|
35
|
+
assert write_and_read_value("32767").is_a?(Fixnum)
|
36
|
+
assert write_and_read_value(32767.0).is_a?(Fixnum)
|
37
|
+
assert write_and_read_value(BigDecimal("32767")).is_a?(Fixnum)
|
38
|
+
end
|
39
|
+
|
40
|
+
def test_smallint_min
|
41
|
+
prepare_test_table("smallint")
|
42
|
+
assert_equal -32768, write_and_read_value(-32768)
|
43
|
+
assert_equal -32768, write_and_read_value("-32768")
|
44
|
+
assert_equal -32768, write_and_read_value(-32768.0)
|
45
|
+
assert_equal -32768, write_and_read_value(BigDecimal("-32768"))
|
46
|
+
assert write_and_read_value(-32768).is_a?(Fixnum)
|
47
|
+
assert write_and_read_value("-32768").is_a?(Fixnum)
|
48
|
+
assert write_and_read_value(-32768.0).is_a?(Fixnum)
|
49
|
+
assert write_and_read_value(BigDecimal("-32768")).is_a?(Fixnum)
|
50
|
+
end
|
51
|
+
|
52
|
+
def test_smallint_rounding
|
53
|
+
prepare_test_table("smallint")
|
54
|
+
assert_equal 0, write_and_read_value(0.4)
|
55
|
+
assert_equal 0, write_and_read_value("0.4")
|
56
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.4"))
|
57
|
+
assert_equal 0, write_and_read_value(-0.4)
|
58
|
+
assert_equal 0, write_and_read_value("-0.4")
|
59
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.4"))
|
60
|
+
assert_equal 1, write_and_read_value(0.5)
|
61
|
+
assert_equal 1, write_and_read_value("0.5")
|
62
|
+
assert_equal 1, write_and_read_value(BigDecimal.new("0.5"))
|
63
|
+
assert_equal -1, write_and_read_value(-0.5)
|
64
|
+
assert_equal -1, write_and_read_value("-0.5")
|
65
|
+
assert_equal -1, write_and_read_value(BigDecimal.new("-0.5"))
|
66
|
+
end
|
67
|
+
|
68
|
+
def test_smallint_input_type
|
69
|
+
prepare_test_table("smallint")
|
70
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
71
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
72
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
73
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
74
|
+
end
|
75
|
+
|
76
|
+
def test_smallint_input_range
|
77
|
+
prepare_test_table("smallint")
|
78
|
+
assert_raises(RangeError) { write_and_read_value(32768) }
|
79
|
+
assert_raises(RangeError) { write_and_read_value("32768") }
|
80
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("32768")) }
|
81
|
+
assert_raises(RangeError) { write_and_read_value(-32769) }
|
82
|
+
assert_raises(RangeError) { write_and_read_value("-32769") }
|
83
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-32769")) }
|
84
|
+
end
|
85
|
+
|
86
|
+
def test_integer_max
|
87
|
+
prepare_test_table("integer")
|
88
|
+
assert_equal 2147483647, write_and_read_value(2147483647)
|
89
|
+
assert_equal 2147483647, write_and_read_value("2147483647")
|
90
|
+
assert_equal 2147483647, write_and_read_value(2147483647.0)
|
91
|
+
assert_equal 2147483647, write_and_read_value(BigDecimal("2147483647"))
|
92
|
+
assert write_and_read_value(2147483647).is_a?(Fixnum)
|
93
|
+
assert write_and_read_value("2147483647").is_a?(Fixnum)
|
94
|
+
assert write_and_read_value(2147483647.0).is_a?(Fixnum)
|
95
|
+
assert write_and_read_value(BigDecimal("2147483647")).is_a?(Fixnum)
|
96
|
+
end
|
97
|
+
|
98
|
+
def test_integer_min
|
99
|
+
prepare_test_table("integer")
|
100
|
+
assert_equal -2147483648, write_and_read_value(-2147483648)
|
101
|
+
assert_equal -2147483648, write_and_read_value("-2147483648")
|
102
|
+
assert_equal -2147483648, write_and_read_value(-2147483648.0)
|
103
|
+
assert_equal -2147483648, write_and_read_value(BigDecimal("-2147483648"))
|
104
|
+
assert write_and_read_value(-2147483648).is_a?(Fixnum)
|
105
|
+
assert write_and_read_value("-2147483648").is_a?(Fixnum)
|
106
|
+
assert write_and_read_value(-2147483648.0).is_a?(Fixnum)
|
107
|
+
assert write_and_read_value(BigDecimal("-2147483648")).is_a?(Fixnum)
|
108
|
+
end
|
109
|
+
|
110
|
+
def test_integer_rounding
|
111
|
+
prepare_test_table("integer")
|
112
|
+
assert_equal 0, write_and_read_value(0.4)
|
113
|
+
assert_equal 0, write_and_read_value("0.4")
|
114
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.4"))
|
115
|
+
assert_equal 0, write_and_read_value(-0.4)
|
116
|
+
assert_equal 0, write_and_read_value("-0.4")
|
117
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.4"))
|
118
|
+
assert_equal 1, write_and_read_value(0.5)
|
119
|
+
assert_equal 1, write_and_read_value("0.5")
|
120
|
+
assert_equal 1, write_and_read_value(BigDecimal.new("0.5"))
|
121
|
+
assert_equal -1, write_and_read_value(-0.5)
|
122
|
+
assert_equal -1, write_and_read_value("-0.5")
|
123
|
+
assert_equal -1, write_and_read_value(BigDecimal.new("-0.5"))
|
124
|
+
end
|
125
|
+
|
126
|
+
def test_integer_input_type
|
127
|
+
prepare_test_table("integer")
|
128
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
129
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
130
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
131
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
132
|
+
end
|
133
|
+
|
134
|
+
def test_integer_input_range
|
135
|
+
prepare_test_table("integer")
|
136
|
+
assert_raises(RangeError) { write_and_read_value(2147483648) }
|
137
|
+
assert_raises(RangeError) { write_and_read_value("2147483648") }
|
138
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("2147483648")) }
|
139
|
+
assert_raises(RangeError) { write_and_read_value(-2147483649) }
|
140
|
+
assert_raises(RangeError) { write_and_read_value("-2147483649") }
|
141
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-2147483649")) }
|
142
|
+
end
|
143
|
+
|
144
|
+
def test_bigint_max
|
145
|
+
prepare_test_table("bigint")
|
146
|
+
assert_equal 9223372036854775807, write_and_read_value(9223372036854775807)
|
147
|
+
assert_equal 9223372036854775807, write_and_read_value("9223372036854775807")
|
148
|
+
#assert_equal 9223372036854775807, write_and_read_value(9223372036854775807.0)
|
149
|
+
assert_equal 9223372036854775807, write_and_read_value(BigDecimal("9223372036854775807"))
|
150
|
+
assert write_and_read_value(9223372036854775807).is_a?(Bignum)
|
151
|
+
assert write_and_read_value("9223372036854775807").is_a?(Bignum)
|
152
|
+
#assert write_and_read_value(9223372036854775807.0).is_a?(Bignum)
|
153
|
+
assert write_and_read_value(BigDecimal("9223372036854775807")).is_a?(Bignum)
|
154
|
+
end
|
155
|
+
|
156
|
+
def test_bigint_min
|
157
|
+
prepare_test_table("bigint")
|
158
|
+
assert_equal -9223372036854775808, write_and_read_value(-9223372036854775808)
|
159
|
+
assert_equal -9223372036854775808, write_and_read_value("-9223372036854775808")
|
160
|
+
#assert_equal -9223372036854775808, write_and_read_value(-9223372036854775808.0)
|
161
|
+
assert_equal -9223372036854775808, write_and_read_value(BigDecimal("-9223372036854775808"))
|
162
|
+
assert write_and_read_value(-9223372036854775808).is_a?(Bignum)
|
163
|
+
assert write_and_read_value("-9223372036854775808").is_a?(Bignum)
|
164
|
+
#assert write_and_read_value(-9223372036854775808.0).is_a?(Bignum)
|
165
|
+
assert write_and_read_value(BigDecimal("-9223372036854775808")).is_a?(Bignum)
|
166
|
+
end
|
167
|
+
|
168
|
+
def test_bigint_rounding
|
169
|
+
prepare_test_table("bigint")
|
170
|
+
assert_equal 0, write_and_read_value(0.4)
|
171
|
+
assert_equal 0, write_and_read_value("0.4")
|
172
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.4"))
|
173
|
+
assert_equal 0, write_and_read_value(-0.4)
|
174
|
+
assert_equal 0, write_and_read_value("-0.4")
|
175
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.4"))
|
176
|
+
assert_equal 1, write_and_read_value(0.5)
|
177
|
+
assert_equal 1, write_and_read_value("0.5")
|
178
|
+
assert_equal 1, write_and_read_value(BigDecimal.new("0.5"))
|
179
|
+
assert_equal -1, write_and_read_value(-0.5)
|
180
|
+
assert_equal -1, write_and_read_value("-0.5")
|
181
|
+
assert_equal -1, write_and_read_value(BigDecimal.new("-0.5"))
|
182
|
+
end
|
183
|
+
|
184
|
+
def test_bigint_input_type
|
185
|
+
prepare_test_table("bigint")
|
186
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
187
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
188
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
189
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
190
|
+
end
|
191
|
+
|
192
|
+
def test_bigint_input_range
|
193
|
+
prepare_test_table("bigint")
|
194
|
+
assert_raises(RangeError) { write_and_read_value(9223372036854775808) }
|
195
|
+
assert_raises(RangeError) { write_and_read_value("9223372036854775808") }
|
196
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("9223372036854775808")) }
|
197
|
+
assert_raises(RangeError) { write_and_read_value(-9223372036854775809) }
|
198
|
+
assert_raises(RangeError) { write_and_read_value("-9223372036854775809") }
|
199
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-9223372036854775809")) }
|
200
|
+
end
|
201
|
+
|
202
|
+
def test_decimal_4_0_max
|
203
|
+
prepare_test_table("decimal(4, 0)")
|
204
|
+
assert_equal 32767, write_and_read_value(32767)
|
205
|
+
assert_equal 32767, write_and_read_value("32767")
|
206
|
+
assert_equal 32767, write_and_read_value(32767.0)
|
207
|
+
assert_equal 32767, write_and_read_value(BigDecimal("32767"))
|
208
|
+
assert write_and_read_value(32767).is_a?(Fixnum)
|
209
|
+
assert write_and_read_value("32767").is_a?(Fixnum)
|
210
|
+
assert write_and_read_value(32767.0).is_a?(Fixnum)
|
211
|
+
assert write_and_read_value(BigDecimal("32767")).is_a?(Fixnum)
|
212
|
+
end
|
213
|
+
|
214
|
+
def test_decimal_4_0_min
|
215
|
+
prepare_test_table("decimal(4, 0)")
|
216
|
+
assert_equal -32768, write_and_read_value(-32768)
|
217
|
+
assert_equal -32768, write_and_read_value("-32768")
|
218
|
+
assert_equal -32768, write_and_read_value(-32768.0)
|
219
|
+
assert_equal -32768, write_and_read_value(BigDecimal("-32768"))
|
220
|
+
assert write_and_read_value(-32768).is_a?(Fixnum)
|
221
|
+
assert write_and_read_value("-32768").is_a?(Fixnum)
|
222
|
+
assert write_and_read_value(-32768.0).is_a?(Fixnum)
|
223
|
+
assert write_and_read_value(BigDecimal("-32768")).is_a?(Fixnum)
|
224
|
+
end
|
225
|
+
|
226
|
+
def test_decimal_4_0_rounding
|
227
|
+
prepare_test_table("decimal(4, 0)")
|
228
|
+
assert_equal 0, write_and_read_value(0.4)
|
229
|
+
assert_equal 0, write_and_read_value("0.4")
|
230
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.4"))
|
231
|
+
assert_equal 0, write_and_read_value(-0.4)
|
232
|
+
assert_equal 0, write_and_read_value("-0.4")
|
233
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.4"))
|
234
|
+
assert_equal 1, write_and_read_value(0.5)
|
235
|
+
assert_equal 1, write_and_read_value("0.5")
|
236
|
+
assert_equal 1, write_and_read_value(BigDecimal.new("0.5"))
|
237
|
+
assert_equal -1, write_and_read_value(-0.5)
|
238
|
+
assert_equal -1, write_and_read_value("-0.5")
|
239
|
+
assert_equal -1, write_and_read_value(BigDecimal.new("-0.5"))
|
240
|
+
end
|
241
|
+
|
242
|
+
def test_decimal_4_0_input_type
|
243
|
+
prepare_test_table("decimal(4, 0)")
|
244
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
245
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
246
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
247
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
248
|
+
end
|
249
|
+
|
250
|
+
def test_decimal_4_0_input_range
|
251
|
+
prepare_test_table("decimal(4, 0)")
|
252
|
+
assert_raises(RangeError) { write_and_read_value(2147483648) }
|
253
|
+
assert_raises(RangeError) { write_and_read_value("2147483648") }
|
254
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("2147483648")) }
|
255
|
+
assert_raises(RangeError) { write_and_read_value(-2147483649) }
|
256
|
+
assert_raises(RangeError) { write_and_read_value("-2147483649") }
|
257
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-2147483649")) }
|
258
|
+
end
|
259
|
+
|
260
|
+
def test_decimal_9_0_max
|
261
|
+
prepare_test_table("decimal(9, 0)")
|
262
|
+
assert_equal 2147483647, write_and_read_value(2147483647)
|
263
|
+
assert_equal 2147483647, write_and_read_value("2147483647")
|
264
|
+
assert_equal 2147483647, write_and_read_value(2147483647.0)
|
265
|
+
assert_equal 2147483647, write_and_read_value(BigDecimal("2147483647"))
|
266
|
+
assert write_and_read_value(2147483647).is_a?(Fixnum)
|
267
|
+
assert write_and_read_value("2147483647").is_a?(Fixnum)
|
268
|
+
assert write_and_read_value(2147483647.0).is_a?(Fixnum)
|
269
|
+
assert write_and_read_value(BigDecimal("2147483647")).is_a?(Fixnum)
|
270
|
+
end
|
271
|
+
|
272
|
+
def test_decimal_9_0_min
|
273
|
+
prepare_test_table("decimal(9, 0)")
|
274
|
+
assert_equal 2147483647, write_and_read_value(2147483647)
|
275
|
+
assert_equal 2147483647, write_and_read_value("2147483647")
|
276
|
+
assert_equal 2147483647, write_and_read_value(2147483647.0)
|
277
|
+
assert_equal 2147483647, write_and_read_value(BigDecimal("2147483647"))
|
278
|
+
assert write_and_read_value(2147483647).is_a?(Fixnum)
|
279
|
+
assert write_and_read_value("2147483647").is_a?(Fixnum)
|
280
|
+
assert write_and_read_value(2147483647.0).is_a?(Fixnum)
|
281
|
+
assert write_and_read_value(BigDecimal("2147483647")).is_a?(Fixnum)
|
282
|
+
end
|
283
|
+
|
284
|
+
def test_decimal_9_0_rounding
|
285
|
+
prepare_test_table("decimal(9, 0)")
|
286
|
+
assert_equal 0, write_and_read_value(0.4)
|
287
|
+
assert_equal 0, write_and_read_value("0.4")
|
288
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.4"))
|
289
|
+
assert_equal 0, write_and_read_value(-0.4)
|
290
|
+
assert_equal 0, write_and_read_value("-0.4")
|
291
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.4"))
|
292
|
+
assert_equal 1, write_and_read_value(0.5)
|
293
|
+
assert_equal 1, write_and_read_value("0.5")
|
294
|
+
assert_equal 1, write_and_read_value(BigDecimal.new("0.5"))
|
295
|
+
assert_equal -1, write_and_read_value(-0.5)
|
296
|
+
assert_equal -1, write_and_read_value("-0.5")
|
297
|
+
assert_equal -1, write_and_read_value(BigDecimal.new("-0.5"))
|
298
|
+
end
|
299
|
+
|
300
|
+
def test_decimal_9_0_input_type
|
301
|
+
prepare_test_table("decimal(9, 0)")
|
302
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
303
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
304
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
305
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
306
|
+
end
|
307
|
+
|
308
|
+
def test_decimal_9_0_input_range
|
309
|
+
prepare_test_table("decimal(9, 0)")
|
310
|
+
assert_raises(RangeError) { write_and_read_value(2147483648) }
|
311
|
+
assert_raises(RangeError) { write_and_read_value("2147483648") }
|
312
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("2147483648")) }
|
313
|
+
assert_raises(RangeError) { write_and_read_value(-2147483649) }
|
314
|
+
assert_raises(RangeError) { write_and_read_value("-2147483649") }
|
315
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-2147483649")) }
|
316
|
+
end
|
317
|
+
|
318
|
+
def test_decimal_9_4_max
|
319
|
+
prepare_test_table("decimal(9, 4)")
|
320
|
+
assert_equal BigDecimal("214748.3647"), write_and_read_value("214748.3647")
|
321
|
+
assert_equal BigDecimal("214748.3647"), write_and_read_value(214748.3647)
|
322
|
+
assert_equal BigDecimal("214748.3647"), write_and_read_value(BigDecimal("214748.3647"))
|
323
|
+
assert write_and_read_value("214748.3647").is_a?(BigDecimal)
|
324
|
+
assert write_and_read_value(214748.3647).is_a?(BigDecimal)
|
325
|
+
assert write_and_read_value(BigDecimal("214748.3647")).is_a?(BigDecimal)
|
326
|
+
end
|
327
|
+
|
328
|
+
def test_decimal_9_4_min
|
329
|
+
prepare_test_table("decimal(9, 4)")
|
330
|
+
assert_equal BigDecimal("-214748.3648"), write_and_read_value("-214748.3648")
|
331
|
+
assert_equal BigDecimal("-214748.3648"), write_and_read_value(-214748.3648)
|
332
|
+
assert_equal BigDecimal("-214748.3648"), write_and_read_value(BigDecimal("-214748.3648"))
|
333
|
+
assert write_and_read_value("-214748.3648").is_a?(BigDecimal)
|
334
|
+
assert write_and_read_value(-214748.3648).is_a?(BigDecimal)
|
335
|
+
assert write_and_read_value(BigDecimal("-214748.3648")).is_a?(BigDecimal)
|
336
|
+
end
|
337
|
+
|
338
|
+
def test_decimal_9_4_rounding
|
339
|
+
prepare_test_table("decimal(9, 4)")
|
340
|
+
assert_equal 0, write_and_read_value(0.00004)
|
341
|
+
assert_equal 0, write_and_read_value("0.00004")
|
342
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.00004"))
|
343
|
+
assert_equal 0, write_and_read_value(-0.00004)
|
344
|
+
assert_equal 0, write_and_read_value("-0.00004")
|
345
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.00004"))
|
346
|
+
assert_equal BigDecimal('0.0001'), write_and_read_value(0.00005)
|
347
|
+
assert_equal BigDecimal('0.0001'), write_and_read_value("0.00005")
|
348
|
+
assert_equal BigDecimal('0.0001'), write_and_read_value(BigDecimal.new("0.00005"))
|
349
|
+
assert_equal BigDecimal('-0.0001'), write_and_read_value(-0.00005)
|
350
|
+
assert_equal BigDecimal('-0.0001'), write_and_read_value("-0.00005")
|
351
|
+
assert_equal BigDecimal('-0.0001'), write_and_read_value(BigDecimal.new("-0.00005"))
|
352
|
+
end
|
353
|
+
|
354
|
+
def test_decimal_9_4_input_type
|
355
|
+
prepare_test_table("decimal(9, 4)")
|
356
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
357
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
358
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
359
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
360
|
+
end
|
361
|
+
|
362
|
+
def test_decimal_9_4_input_range
|
363
|
+
prepare_test_table("decimal(9, 4)")
|
364
|
+
assert_raises(RangeError) { write_and_read_value(214748.3648) }
|
365
|
+
assert_raises(RangeError) { write_and_read_value("214748.3648") }
|
366
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("214748.3648")) }
|
367
|
+
assert_raises(RangeError) { write_and_read_value(-214748.3649) }
|
368
|
+
assert_raises(RangeError) { write_and_read_value("-214748.3649") }
|
369
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-214748.3649")) }
|
370
|
+
end
|
371
|
+
|
372
|
+
def test_decimal_9_9_max
|
373
|
+
prepare_test_table("decimal(9, 9)")
|
374
|
+
assert_equal BigDecimal("2.147483647"), write_and_read_value("2.147483647")
|
375
|
+
assert_equal BigDecimal("2.147483647"), write_and_read_value(2.147483647)
|
376
|
+
assert_equal BigDecimal("2.147483647"), write_and_read_value(BigDecimal("2.147483647"))
|
377
|
+
assert write_and_read_value("2.147483647").is_a?(BigDecimal)
|
378
|
+
assert write_and_read_value(2.147483647).is_a?(BigDecimal)
|
379
|
+
assert write_and_read_value(BigDecimal("2.147483647")).is_a?(BigDecimal)
|
380
|
+
end
|
381
|
+
|
382
|
+
def test_decimal_9_9_min
|
383
|
+
prepare_test_table("decimal(9, 9)")
|
384
|
+
assert_equal BigDecimal("-2.147483648"), write_and_read_value("-2.147483648")
|
385
|
+
assert_equal BigDecimal("-2.147483648"), write_and_read_value(-2.147483648)
|
386
|
+
assert_equal BigDecimal("-2.147483648"), write_and_read_value(BigDecimal("-2.147483648"))
|
387
|
+
assert write_and_read_value("-2.147483648").is_a?(BigDecimal)
|
388
|
+
assert write_and_read_value(-2.147483648).is_a?(BigDecimal)
|
389
|
+
assert write_and_read_value(BigDecimal("-2.147483648")).is_a?(BigDecimal)
|
390
|
+
end
|
391
|
+
|
392
|
+
def test_decimal_9_9_rounding
|
393
|
+
prepare_test_table("decimal(9, 9)")
|
394
|
+
assert_equal 0, write_and_read_value(0.0000000004)
|
395
|
+
assert_equal 0, write_and_read_value("0.0000000004")
|
396
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.0000000004"))
|
397
|
+
assert_equal 0, write_and_read_value(-0.0000000004)
|
398
|
+
assert_equal 0, write_and_read_value("-0.0000000004")
|
399
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.0000000004"))
|
400
|
+
assert_equal BigDecimal("0.000000001"), write_and_read_value(0.0000000005)
|
401
|
+
assert_equal BigDecimal("0.000000001"), write_and_read_value("0.0000000005")
|
402
|
+
assert_equal BigDecimal("0.000000001"), write_and_read_value(BigDecimal.new("0.0000000005"))
|
403
|
+
assert_equal BigDecimal("-0.000000001"), write_and_read_value(-0.0000000005)
|
404
|
+
assert_equal BigDecimal("-0.000000001"), write_and_read_value("-0.0000000005")
|
405
|
+
assert_equal BigDecimal("-0.000000001"), write_and_read_value(BigDecimal.new("-0.0000000005"))
|
406
|
+
end
|
407
|
+
|
408
|
+
def test_decimal_9_9_input_type
|
409
|
+
prepare_test_table("decimal(9, 9)")
|
410
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
411
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
412
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
413
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
414
|
+
end
|
415
|
+
|
416
|
+
def test_decimal_9_9_input_range
|
417
|
+
prepare_test_table("decimal(9, 9)")
|
418
|
+
assert_raises(RangeError) { write_and_read_value(2.147483648) }
|
419
|
+
assert_raises(RangeError) { write_and_read_value("2.147483648") }
|
420
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("2.147483648")) }
|
421
|
+
assert_raises(RangeError) { write_and_read_value(-2.147483649) }
|
422
|
+
assert_raises(RangeError) { write_and_read_value("-2.147483649") }
|
423
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-2.147483649")) }
|
424
|
+
end
|
425
|
+
|
426
|
+
def test_decimal_18_0_max
|
427
|
+
prepare_test_table("decimal(18, 0)")
|
428
|
+
assert_equal 9223372036854775807, write_and_read_value(9223372036854775807)
|
429
|
+
assert_equal 9223372036854775807, write_and_read_value("9223372036854775807")
|
430
|
+
#assert_equal 9223372036854775807, write_and_read_value(9223372036854775807.0)
|
431
|
+
assert_equal 9223372036854775807, write_and_read_value(BigDecimal("9223372036854775807"))
|
432
|
+
assert write_and_read_value(9223372036854775807).is_a?(Bignum)
|
433
|
+
assert write_and_read_value("9223372036854775807").is_a?(Bignum)
|
434
|
+
#assert write_and_read_value(9223372036854775807.0).is_a?(Bignum)
|
435
|
+
assert write_and_read_value(BigDecimal("9223372036854775807")).is_a?(Bignum)
|
436
|
+
end
|
437
|
+
|
438
|
+
def test_decimal_18_0_min
|
439
|
+
prepare_test_table("decimal(18, 0)")
|
440
|
+
assert_equal -9223372036854775808, write_and_read_value(-9223372036854775808)
|
441
|
+
assert_equal -9223372036854775808, write_and_read_value("-9223372036854775808")
|
442
|
+
#assert_equal -9223372036854775808, write_and_read_value(-9223372036854775808.0)
|
443
|
+
assert_equal -9223372036854775808, write_and_read_value(BigDecimal("-9223372036854775808"))
|
444
|
+
assert write_and_read_value(-9223372036854775808).is_a?(Bignum)
|
445
|
+
assert write_and_read_value("-9223372036854775808").is_a?(Bignum)
|
446
|
+
#assert write_and_read_value(-9223372036854775808.0).is_a?(Bignum)
|
447
|
+
assert write_and_read_value(BigDecimal("-9223372036854775808")).is_a?(Bignum)
|
448
|
+
end
|
449
|
+
|
450
|
+
def test_decimal_18_0_rounding
|
451
|
+
prepare_test_table("decimal(18, 0)")
|
452
|
+
assert_equal 0, write_and_read_value(0.4)
|
453
|
+
assert_equal 0, write_and_read_value("0.4")
|
454
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.4"))
|
455
|
+
assert_equal 0, write_and_read_value(-0.4)
|
456
|
+
assert_equal 0, write_and_read_value("-0.4")
|
457
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.4"))
|
458
|
+
assert_equal 1, write_and_read_value(0.5)
|
459
|
+
assert_equal 1, write_and_read_value("0.5")
|
460
|
+
assert_equal 1, write_and_read_value(BigDecimal.new("0.5"))
|
461
|
+
assert_equal -1, write_and_read_value(-0.5)
|
462
|
+
assert_equal -1, write_and_read_value("-0.5")
|
463
|
+
assert_equal -1, write_and_read_value(BigDecimal.new("-0.5"))
|
464
|
+
end
|
465
|
+
|
466
|
+
def test_decimal_18_0_input_types
|
467
|
+
prepare_test_table("decimal(18, 0)")
|
468
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
469
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
470
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
471
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
472
|
+
end
|
473
|
+
|
474
|
+
def test_decimal_18_0_input_range
|
475
|
+
prepare_test_table("decimal(18, 0)")
|
476
|
+
assert_raises(RangeError) { write_and_read_value(9223372036854775808) }
|
477
|
+
assert_raises(RangeError) { write_and_read_value("9223372036854775808") }
|
478
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("9223372036854775808")) }
|
479
|
+
assert_raises(RangeError) { write_and_read_value(-9223372036854775809) }
|
480
|
+
assert_raises(RangeError) { write_and_read_value("-9223372036854775809") }
|
481
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-9223372036854775809")) }
|
482
|
+
end
|
483
|
+
|
484
|
+
def test_decimal_18_9_max
|
485
|
+
prepare_test_table("decimal(18, 9)")
|
486
|
+
assert_equal BigDecimal("9223372036.854775807"), write_and_read_value("9223372036.854775807")
|
487
|
+
#assert_equal BigDecimal("9223372036.854775807"), write_and_read_value(9223372036.854775807)
|
488
|
+
assert_equal BigDecimal("9223372036.854775807"), write_and_read_value(BigDecimal("9223372036.854775807"))
|
489
|
+
assert write_and_read_value("9223372036.854775807").is_a?(BigDecimal)
|
490
|
+
#assert write_and_read_value(9223372036.854775807).is_a?(BigDecimal)
|
491
|
+
assert write_and_read_value(BigDecimal("9223372036.854775807")).is_a?(BigDecimal)
|
492
|
+
end
|
493
|
+
|
494
|
+
def test_decimal_18_9_min
|
495
|
+
prepare_test_table("decimal(18, 9)")
|
496
|
+
assert_equal BigDecimal("-9223372036.854775808"), write_and_read_value("-9223372036.854775808")
|
497
|
+
#assert_equal BigDecimal("-9223372036.854775808"), write_and_read_value(-9223372036.854775808)
|
498
|
+
assert_equal BigDecimal("-9223372036.854775808"), write_and_read_value(BigDecimal("-9223372036.854775808"))
|
499
|
+
assert write_and_read_value("-9223372036.854775808").is_a?(BigDecimal)
|
500
|
+
#assert write_and_read_value(-9223372036.854775808).is_a?(BigDecimal)
|
501
|
+
assert write_and_read_value(BigDecimal("-9223372036.854775808")).is_a?(BigDecimal)
|
502
|
+
end
|
503
|
+
|
504
|
+
def test_decimal_18_9_rounding
|
505
|
+
prepare_test_table("decimal(18, 9)")
|
506
|
+
assert_equal 0, write_and_read_value(0.0000000004)
|
507
|
+
assert_equal 0, write_and_read_value("0.0000000004")
|
508
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.0000000004"))
|
509
|
+
assert_equal 0, write_and_read_value(-0.0000000004)
|
510
|
+
assert_equal 0, write_and_read_value("-0.0000000004")
|
511
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.0000000004"))
|
512
|
+
assert_equal BigDecimal('0.000000001'), write_and_read_value(0.0000000005)
|
513
|
+
assert_equal BigDecimal('0.000000001'), write_and_read_value("0.0000000005")
|
514
|
+
assert_equal BigDecimal('0.000000001'), write_and_read_value(BigDecimal.new("0.0000000005"))
|
515
|
+
assert_equal BigDecimal('-0.000000001'), write_and_read_value(-0.0000000005)
|
516
|
+
assert_equal BigDecimal('-0.000000001'), write_and_read_value("-0.0000000005")
|
517
|
+
assert_equal BigDecimal('-0.000000001'), write_and_read_value(BigDecimal.new("-0.0000000005"))
|
518
|
+
end
|
519
|
+
|
520
|
+
def test_decimal_18_9_input_type
|
521
|
+
prepare_test_table("decimal(18, 9)")
|
522
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
523
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
524
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
525
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
526
|
+
end
|
527
|
+
|
528
|
+
def test_decimal_18_9_input_range
|
529
|
+
prepare_test_table("decimal(18, 9)")
|
530
|
+
assert_raises(RangeError) { write_and_read_value(9223372036.854775808) }
|
531
|
+
assert_raises(RangeError) { write_and_read_value("9223372036.854775808") }
|
532
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("9223372036.854775808")) }
|
533
|
+
assert_raises(RangeError) { write_and_read_value(-9223372036.854775809) }
|
534
|
+
assert_raises(RangeError) { write_and_read_value("-9223372036.854775809") }
|
535
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-9223372036.854775809")) }
|
536
|
+
end
|
537
|
+
|
538
|
+
def test_decimal_18_18_max
|
539
|
+
prepare_test_table("decimal(18, 18)")
|
540
|
+
assert_equal BigDecimal("9.223372036854775807"), write_and_read_value(BigDecimal("9.223372036854775807"))
|
541
|
+
#assert_equal BigDecimal("9.223372036854775807"), write_and_read_value(9.223372036854775807)
|
542
|
+
assert_equal BigDecimal("9.223372036854775807"), write_and_read_value("9.223372036854775807")
|
543
|
+
assert write_and_read_value("9.223372036854775807").is_a?(BigDecimal)
|
544
|
+
#assert write_and_read_value(9.223372036854775807).is_a?(BigDecimal)
|
545
|
+
assert write_and_read_value(BigDecimal("9.223372036854775807")).is_a?(BigDecimal)
|
546
|
+
end
|
547
|
+
|
548
|
+
def test_decimal_18_18_min
|
549
|
+
prepare_test_table("decimal(18, 18)")
|
550
|
+
assert_equal BigDecimal("-9.223372036854775808"), write_and_read_value("-9.223372036854775808")
|
551
|
+
#assert_equal BigDecimal("-9.223372036854775808"), write_and_read_value(-9.223372036854775808)
|
552
|
+
assert_equal BigDecimal("-9.223372036854775808"), write_and_read_value(BigDecimal("-9.223372036854775808"))
|
553
|
+
assert write_and_read_value("-9.223372036854775808").is_a?(BigDecimal)
|
554
|
+
#assert write_and_read_value(-9.223372036854775808).is_a?(BigDecimal)
|
555
|
+
assert write_and_read_value(BigDecimal("-9.223372036854775808")).is_a?(BigDecimal)
|
556
|
+
end
|
557
|
+
|
558
|
+
def test_decimal_18_18_rounding
|
559
|
+
prepare_test_table("decimal(18, 18)")
|
560
|
+
assert_equal 0, write_and_read_value(0.0000000000000000004)
|
561
|
+
assert_equal 0, write_and_read_value("0.0000000000000000004")
|
562
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("0.0000000000000000004"))
|
563
|
+
assert_equal 0, write_and_read_value(-0.0000000000000000004)
|
564
|
+
assert_equal 0, write_and_read_value("-0.0000000000000000004")
|
565
|
+
assert_equal 0, write_and_read_value(BigDecimal.new("-0.0000000000000000004"))
|
566
|
+
assert_equal BigDecimal("0.000000000000000001"), write_and_read_value(0.0000000000000000005)
|
567
|
+
assert_equal BigDecimal("0.000000000000000001"), write_and_read_value("0.0000000000000000005")
|
568
|
+
assert_equal BigDecimal("0.000000000000000001"), write_and_read_value(BigDecimal.new("0.0000000000000000005"))
|
569
|
+
assert_equal BigDecimal("-0.000000000000000001"), write_and_read_value(-0.0000000000000000005)
|
570
|
+
assert_equal BigDecimal("-0.000000000000000001"), write_and_read_value("-0.0000000000000000005")
|
571
|
+
assert_equal BigDecimal("-0.000000000000000001"), write_and_read_value(BigDecimal.new("-0.0000000000000000005"))
|
572
|
+
end
|
573
|
+
|
574
|
+
def test_decimal_18_18_input_type
|
575
|
+
prepare_test_table("decimal(18, 18)")
|
576
|
+
#assert_raises(TypeError) { write_and_read_value('abcde') }
|
577
|
+
assert_raises(TypeError) { write_and_read_value(Date.new) }
|
578
|
+
assert_raises(TypeError) { write_and_read_value(Time.new) }
|
579
|
+
assert_raises(TypeError) { write_and_read_value(Object.new) }
|
580
|
+
end
|
581
|
+
|
582
|
+
def test_decimal_18_18_input_range
|
583
|
+
prepare_test_table("decimal(18, 18)")
|
584
|
+
assert_raises(RangeError) { write_and_read_value(9.223372036854775808) }
|
585
|
+
assert_raises(RangeError) { write_and_read_value("9.223372036854775808") }
|
586
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("9.223372036854775808")) }
|
587
|
+
assert_raises(RangeError) { write_and_read_value(-9.223372036854775809) }
|
588
|
+
assert_raises(RangeError) { write_and_read_value("-9.223372036854775809") }
|
589
|
+
assert_raises(RangeError) { write_and_read_value(BigDecimal("-9.223372036854775809")) }
|
590
|
+
end
|
591
|
+
end
|
metadata
CHANGED
@@ -1,14 +1,14 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: fb
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 0.7.
|
4
|
+
version: 0.7.5
|
5
5
|
platform: ruby
|
6
6
|
authors:
|
7
7
|
- Brent Rowland
|
8
8
|
autorequire:
|
9
9
|
bindir: bin
|
10
10
|
cert_chain: []
|
11
|
-
date:
|
11
|
+
date: 2016-04-14 00:00:00.000000000 Z
|
12
12
|
dependencies: []
|
13
13
|
description: Ruby Firebird Extension Library
|
14
14
|
email: rowland@rowlandresearch.com
|
@@ -29,6 +29,7 @@ files:
|
|
29
29
|
- test/EncodingTestCases.rb
|
30
30
|
- test/FbTestCases.rb
|
31
31
|
- test/FbTestSuite.rb
|
32
|
+
- test/NumericDataTypesTestCases.rb
|
32
33
|
- test/TransactionTestCases.rb
|
33
34
|
homepage: http://github.com/rowland/fb
|
34
35
|
licenses:
|
@@ -57,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
57
58
|
requirements:
|
58
59
|
- Firebird client library fbclient.dll, libfbclient.so or Firebird.framework.
|
59
60
|
rubyforge_project:
|
60
|
-
rubygems_version: 2.2.
|
61
|
+
rubygems_version: 2.2.5
|
61
62
|
signing_key:
|
62
63
|
specification_version: 4
|
63
64
|
summary: Firebird database driver
|