ibm_db 2.5.26-x86-mingw32 → 2.5.27-x86-mingw32

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.
Files changed (11) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGES +5 -1
  3. data/README +1 -1
  4. data/ext/ibm_db.c +437 -351
  5. data/ext/ruby_ibm_db.h +241 -240
  6. data/ext/ruby_ibm_db_cli.c +32 -26
  7. data/ext/ruby_ibm_db_cli.h +15 -4
  8. data/lib/active_record/connection_adapters/ibm_db_adapter.rb +1 -0
  9. data/lib/mswin32/ibm_db.rb +2 -2
  10. data/lib/mswin32/rb22x/i386/ibm_db.so +0 -0
  11. metadata +2 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 4f203d36d906884d58b39af4a01eaf769d1e9acd
4
- data.tar.gz: 88c9dd7109d993f25a3e4f22a7d783eefa72b4ca
3
+ metadata.gz: bfecc36c3cb45e37334de64860c57a31a9c3930a
4
+ data.tar.gz: 7b5e68da345fcf8fdc39584c6b0cc13b5762ff74
5
5
  SHA512:
6
- metadata.gz: 78c60ed4b5a50ad8db067bb879b44cda690ac4385207b7d66f02687c95b8b03dff9182e6650d62fc20efaf00eb8fabfab8928842432f0968d36f5cc06d2da12a
7
- data.tar.gz: 3987168631560807316e56fea1e0213ae74499d815729be65bb291e281d76147721129d0071c87886c622f4b085168d081b01372187e8ea335e3151cbdd91bed
6
+ metadata.gz: 71b5b2a685bf8de7f6c7544d0fbb49045bd2782ded7652c9493386db1ba2725a60b8c9161acd1cd6597427472ec74b3d8a299e16282367f19053bd476d48719a
7
+ data.tar.gz: 836a6a17093660ad3c19ba8a9a090e9b25d96cb1eb606f041e71b197843017aa198036ae714d2962b80065a40bfa873527e2038e1493b03b8991b759721e5397
data/CHANGES CHANGED
@@ -1,11 +1,15 @@
1
1
  Change Log
2
2
  ==============
3
+ 2015/06/08 (IBM_DB adapter 2.5.27, driver 2.5.27)
4
+ - Support for Ruby 2.2.x on Windows and Linux platform
5
+ - Fixed bug#28 Create table fails on db:migrate task in ActiveRecord 4.2.1 if database adapter not support foreign_keys.
6
+
3
7
  2015/04/08 (IBM_DB adapter 2.5.26, driver 2.5.26)
4
8
  - Fixed bug#22 - Error 'undefined method lookup_cast_type encountered' with rails version lesser than 4.2
5
9
 
6
10
  2015/03/24 (IBM_DB adapter 2.5.25, driver 2.5.25)
7
11
  - Support for Rails 4.2.x
8
- - Support for Ruby 2.2.x on Windows and Linus platform
12
+ - Support for Ruby 2.2.x on Windows and Linux platform
9
13
 
10
14
  2014/08/03 (IBM_DB adapter 2.5.18, driver 2.5.14) :
11
15
  - Support for Rails 4.1.x
data/README CHANGED
@@ -1,5 +1,5 @@
1
1
  =====================================================================
2
- README for the IBM_DB Adapter (2.5.26) and Driver (2.5.26) (2015/04/08)
2
+ README for the IBM_DB Adapter (2.5.27) and Driver (2.5.27) (2015/04/08)
3
3
  For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
4
4
  =====================================================================
5
5
 
data/ext/ibm_db.c CHANGED
@@ -12,7 +12,7 @@
12
12
  +----------------------------------------------------------------------+
13
13
  */
14
14
 
15
- #define MODULE_RELEASE "2.5.26"
15
+ #define MODULE_RELEASE "2.5.27"
16
16
 
17
17
  #ifdef HAVE_CONFIG_H
18
18
  #include "config.h"
@@ -57,6 +57,7 @@ typedef struct _stmt_bind_data_array {
57
57
  SQLSMALLINT num;
58
58
  int bind_params;
59
59
  VALUE *error;
60
+ VALUE return_value;
60
61
  }stmt_bind_array;
61
62
 
62
63
  /*
@@ -69,7 +70,9 @@ typedef struct _ibm_db_connect_helper_args_struct {
69
70
  VALUE *options;
70
71
  VALUE *error;
71
72
  int literal_replacement;
72
- VALUE hKey;
73
+ VALUE hKey;
74
+ conn_handle *conn_res;
75
+ VALUE entry;
73
76
  } connect_helper_args;
74
77
 
75
78
  /*
@@ -79,6 +82,7 @@ typedef struct _ibm_db_result_args_struct {
79
82
  stmt_handle *stmt_res;
80
83
  VALUE column;
81
84
  VALUE *error;
85
+ VALUE return_value;
82
86
  } ibm_db_result_args;
83
87
 
84
88
  /*
@@ -90,6 +94,7 @@ typedef struct _ibm_db_fetch_helper_struct {
90
94
  int arg_count;
91
95
  int funcType;
92
96
  VALUE *error;
97
+ VALUE return_value;
93
98
  } ibm_db_fetch_helper_args;
94
99
 
95
100
  void ruby_init_ibm_db();
@@ -159,7 +164,6 @@ static VALUE id_id2name;
159
164
 
160
165
  utf8_enc = rb_enc_find("UTF-8");
161
166
  rbString = rb_external_str_new(str, strlen(str));
162
-
163
167
  return rb_str_export_to_enc(rbString, utf8_enc);
164
168
  }
165
169
 
@@ -171,7 +175,6 @@ static VALUE id_id2name;
171
175
  } else {
172
176
  utf16_enc = rb_enc_find("UTF-16LE");
173
177
  }
174
-
175
178
  return rb_external_str_new_with_enc((char *)str, len, utf16_enc);
176
179
  }
177
180
 
@@ -179,7 +182,7 @@ static VALUE id_id2name;
179
182
  VALUE rbString;
180
183
 
181
184
  rbString = _ruby_ibm_db_export_sqlwchar_to_utf16_rstr( str, len ); /*Construct the Ruby string from SQLWCHAR(which is in utf16)*/
182
-
185
+
183
186
  return _ruby_ibm_db_export_str_to_utf8(rbString); /*Convert the string to utf8 encoding*/
184
187
  }
185
188
 
@@ -187,7 +190,7 @@ static VALUE id_id2name;
187
190
  rb_encoding *utf8_enc;
188
191
 
189
192
  utf8_enc = rb_enc_find("UTF-8");
190
-
193
+
191
194
  return rb_external_str_new_with_enc((char *)str, len, utf8_enc);
192
195
  }
193
196
  #endif
@@ -195,6 +198,7 @@ static VALUE id_id2name;
195
198
  /* Every user visible function must have an entry in Init_ibm_db
196
199
  */
197
200
  void Init_ibm_db(void) {
201
+
198
202
  mDB = rb_define_module("IBM_DB");
199
203
 
200
204
  rb_define_module_function(mDB, "connect", ibm_db_connect, -1);
@@ -260,7 +264,7 @@ void Init_ibm_db(void) {
260
264
  rb_define_module_function(mDB, "server_info", ibm_db_server_info, -1);
261
265
  rb_define_module_function(mDB, "client_info", ibm_db_client_info, -1);
262
266
  rb_define_module_function(mDB, "active", ibm_db_active, -1);
263
-
267
+
264
268
  RUBY_FE(connect)
265
269
  RUBY_FE(commit)
266
270
  RUBY_FE(pconnect)
@@ -326,7 +330,7 @@ void Init_ibm_db(void) {
326
330
  id_keys = rb_intern("keys");
327
331
  id_new = rb_intern("new");
328
332
  id_id2name = rb_intern("id2name");
329
-
333
+
330
334
  };
331
335
  /* */
332
336
 
@@ -341,7 +345,7 @@ static void ruby_ibm_db_load_necessary_libs() {
341
345
  }
342
346
 
343
347
  #ifdef _WIN32
344
- static void ruby_ibm_db_check_sqlcreatedb(HINSTANCE cliLib) {
348
+ static void ruby_ibm_db_check_sqlcreatedb(HINSTANCE cliLib) {
345
349
  FARPROC sqlcreatedb;
346
350
  sqlcreatedb = DLSYM( cliLib, "SQLCreateDbW" );
347
351
  #else
@@ -397,6 +401,7 @@ static void ruby_ibm_db_init_globals(struct _ibm_db_globals *ibm_db_globals)
397
401
  memset(ibm_db_globals->__ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN);
398
402
  memset(ibm_db_globals->__ruby_conn_err_state, '\0', SQL_SQLSTATE_SIZE + 1);
399
403
  memset(ibm_db_globals->__ruby_stmt_err_state, '\0', SQL_SQLSTATE_SIZE + 1);
404
+
400
405
  }
401
406
  /* */
402
407
 
@@ -481,11 +486,12 @@ static void _ruby_ibm_db_mark_conn_struct(conn_handle *handle)
481
486
  /* static void _ruby_ibm_db_free_conn_struct */
482
487
  static void _ruby_ibm_db_free_conn_struct(conn_handle *handle)
483
488
  {
489
+
484
490
  int rc;
485
491
  end_tran_args *end_X_args;
486
492
 
487
493
  if ( handle != NULL ) {
488
- /* Disconnect from DB. If stmt is allocated, it is freed automatically*/
494
+ //Disconnect from DB. If stmt is allocated, it is freed automatically
489
495
  if ( handle->handle_active ) {
490
496
  if( handle->transaction_active == 1 && handle->auto_commit == 0 ) {
491
497
  handle->transaction_active = 0;
@@ -494,14 +500,14 @@ static void _ruby_ibm_db_free_conn_struct(conn_handle *handle)
494
500
 
495
501
  end_X_args->hdbc = &(handle->hdbc);
496
502
  end_X_args->handleType = SQL_HANDLE_DBC;
497
- end_X_args->completionType = SQL_ROLLBACK; /*Note we are rolling back the transaction*/
503
+ end_X_args->completionType = SQL_ROLLBACK; //Note we are rolling back the transaction
498
504
 
499
505
  _ruby_ibm_db_SQLEndTran( end_X_args );
500
506
 
501
507
  ruby_xfree( end_X_args );
502
508
 
503
509
  }
504
- rc = _ruby_ibm_db_SQLDisconnect_helper( &(handle->hdbc) );
510
+ rc = _ruby_ibm_db_SQLDisconnect_helper( &(handle->hdbc) );
505
511
  rc = SQLFreeHandle(SQL_HANDLE_DBC, handle->hdbc );
506
512
  rc = SQLFreeHandle(SQL_HANDLE_ENV, handle->henv );
507
513
  }
@@ -516,14 +522,15 @@ static void _ruby_ibm_db_free_conn_struct(conn_handle *handle)
516
522
  handle->ruby_error_state = NULL;
517
523
  }
518
524
 
519
- /*if ( handle->flag_pconnect ) {
520
- ruby_xfree( handle );
521
- } else {
522
- ruby_xfree( handle );
523
- }*/
525
+ //if ( handle->flag_pconnect ) {
526
+ // ruby_xfree( handle );
527
+ //} else {
528
+ // ruby_xfree( handle );
529
+ //}
524
530
  ruby_xfree( handle );
525
531
  handle = NULL;
526
532
  }
533
+
527
534
  }
528
535
  /* */
529
536
 
@@ -563,20 +570,18 @@ static void _ruby_ibm_db_free_result_struct(stmt_handle* handle)
563
570
  {
564
571
  int i;
565
572
  param_node *curr_ptr = NULL, *prev_ptr = NULL;
573
+
566
574
 
567
575
  if ( handle != NULL ) {
568
576
  /* Free param cache list */
569
577
  curr_ptr = handle->head_cache_list;
570
578
  prev_ptr = handle->head_cache_list;
571
-
572
579
  while ( curr_ptr != NULL ) {
573
580
  curr_ptr = curr_ptr->next;
574
-
575
581
  if ( prev_ptr->varname != NULL ) {
576
582
  ruby_xfree( prev_ptr->varname );
577
583
  prev_ptr->varname = NULL;
578
584
  }
579
-
580
585
  if ( prev_ptr->svalue != NULL ) {
581
586
  ruby_xfree( prev_ptr->svalue );
582
587
  prev_ptr->svalue = NULL;
@@ -588,7 +593,6 @@ static void _ruby_ibm_db_free_result_struct(stmt_handle* handle)
588
593
  handle->head_cache_list = NULL;
589
594
  handle->num_params = 0;
590
595
  handle->current_node = NULL;
591
-
592
596
  /* free row data cache */
593
597
  if ( handle->row_data ) {
594
598
  for (i=0; i<handle->num_columns;i++) {
@@ -620,7 +624,6 @@ static void _ruby_ibm_db_free_result_struct(stmt_handle* handle)
620
624
  ruby_xfree( handle->row_data );
621
625
  handle->row_data = NULL;
622
626
  }
623
-
624
627
  /* free column info cache */
625
628
  if ( handle->column_info ) {
626
629
  for (i=0; i<handle->num_columns; i++) {
@@ -682,26 +685,28 @@ static void _ruby_ibm_db_mark_stmt_struct(stmt_handle *handle)
682
685
  }
683
686
 
684
687
 
685
- //VALUE ibm_Ruby_Thread_Call(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2)
686
688
  VALUE ibm_Ruby_Thread_Call(rb_blocking_function_t *func, void *data1, rb_unblock_function_t *ubf, void *data2)
687
- {
688
- #ifdef RUBY_API_VERSION_MAJOR
689
- if( RUBY_API_VERSION_MAJOR >=2 && RUBY_API_VERSION_MINOR >=2)
690
- {
691
- #ifdef _WIN32
692
- void *(*f)(void*) = (void *(*)(void*))func;
693
- return (VALUE)rb_thread_call_without_gvl(f, data1, ubf, data2);
694
- #else
689
+ {
690
+ #ifdef RUBY_API_VERSION_MAJOR
691
+ if( RUBY_API_VERSION_MAJOR >=2 && RUBY_API_VERSION_MINOR >=2)
692
+ {
693
+
694
+ #ifdef _WIN32
695
+ void *(*f)(void*) = (void *(*)(void*))func;
696
+ return (VALUE)rb_thread_call_without_gvl(f, data1, ubf, data2);
697
+ #elif __APPLE__
698
+ return rb_thread_call_without_gvl(func, data1, ubf, data2);
699
+ #else
700
+ rb_thread_call_without_gvl(func, data1, ubf, data2);
701
+ #endif
702
+ }
703
+ else
704
+ {
705
+ rb_thread_call_without_gvl(func, data1, ubf, data2);
706
+ }
707
+ #else
695
708
  rb_thread_call_without_gvl(func, data1, ubf, data2);
696
- #endif
697
- }
698
- else
699
- {
700
- return rb_thread_blocking_region(func, data1, ubf, data2);
701
- }
702
- #else
703
- return rb_thread_blocking_region(func, data1, ubf, data2);
704
- #endif
709
+ #endif
705
710
  }
706
711
 
707
712
 
@@ -712,7 +717,6 @@ static void _ruby_ibm_db_free_stmt_handle_and_resources(stmt_handle *handle)
712
717
  {
713
718
  int rc;
714
719
  if ( handle != NULL ) {
715
-
716
720
  if( !handle->is_freed ) {
717
721
  rc = SQLFreeHandle( SQL_HANDLE_STMT, handle->hstmt );
718
722
 
@@ -722,7 +726,6 @@ static void _ruby_ibm_db_free_stmt_handle_and_resources(stmt_handle *handle)
722
726
  ruby_xfree( handle->ruby_stmt_err_msg );
723
727
  handle->ruby_stmt_err_msg = NULL;
724
728
  }
725
-
726
729
  if( handle->ruby_stmt_err_state != NULL ) {
727
730
  ruby_xfree( handle->ruby_stmt_err_state );
728
731
  handle->ruby_stmt_err_state = NULL;
@@ -736,12 +739,12 @@ static void _ruby_ibm_db_free_stmt_handle_and_resources(stmt_handle *handle)
736
739
 
737
740
  /* static _ruby_ibm_db_free_stmt_struct */
738
741
  static void _ruby_ibm_db_free_stmt_struct(stmt_handle *handle)
739
- {
742
+ {
740
743
  if ( handle != NULL ) {
741
744
  _ruby_ibm_db_free_stmt_handle_and_resources( handle );
742
745
  ruby_xfree( handle );
743
- handle = NULL;
744
- }
746
+ handle = NULL;
747
+ }
745
748
  }
746
749
 
747
750
  /* */
@@ -770,6 +773,7 @@ VALUE ibm_db_row_object(int argc, VALUE *argv, VALUE self)
770
773
  */
771
774
  void ruby_init_ibm_db()
772
775
  {
776
+
773
777
  #ifndef _WIN32
774
778
  /* Declare variables for DB2 instance settings */
775
779
  char * tmp_name = NULL;
@@ -778,9 +782,9 @@ void ruby_init_ibm_db()
778
782
 
779
783
  ibm_db_globals = ALLOC(struct _ibm_db_globals);
780
784
  memset(ibm_db_globals, '\0', sizeof(struct _ibm_db_globals));
781
-
785
+
782
786
  ruby_ibm_db_init_globals(ibm_db_globals);
783
-
787
+
784
788
  /* Specifies that binary data shall be converted to a hexadecimal encoding and returned as an ASCII string */
785
789
  rb_define_const(mDB, "BINARY", INT2NUM(1));
786
790
  /* Specifies that binary data shall be converted to a hexadecimal encoding and returned as an ASCII string */
@@ -891,7 +895,7 @@ void ruby_init_ibm_db()
891
895
  #endif
892
896
 
893
897
  persistent_list = rb_hash_new();
894
-
898
+
895
899
  le_conn_struct = rb_define_class_under(mDB, "Connection", rb_cObject);
896
900
  le_pconn_struct = rb_define_class_under(mDB, "PConnection", rb_cObject);
897
901
  le_stmt_struct = rb_define_class_under(mDB, "Statement", rb_cObject);
@@ -936,6 +940,7 @@ void ruby_init_ibm_db()
936
940
  ruby_ibm_db_load_necessary_libs();
937
941
 
938
942
  ruby_ibm_db_check_if_cli_func_supported();
943
+
939
944
  }
940
945
  /* */
941
946
 
@@ -1020,10 +1025,10 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1020
1025
 
1021
1026
  if( release_gil == 1 ){
1022
1027
 
1023
- #ifdef UNICODE_SUPPORT_VERSION
1024
- //return_code = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLGetDiagRec_helper, get_DiagRec_args,
1025
- return_code = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLGetDiagRec_helper, get_DiagRec_args,
1028
+ #ifdef UNICODE_SUPPORT_VERSION
1029
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLGetDiagRec_helper, get_DiagRec_args,
1026
1030
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
1031
+ return_code =get_DiagRec_args->return_code;
1027
1032
  #else
1028
1033
  return_code = _ruby_ibm_db_SQLGetDiagRec_helper( get_DiagRec_args );
1029
1034
  #endif
@@ -1291,6 +1296,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1291
1296
  if( sqlstate != NULL ) {
1292
1297
  ruby_xfree( sqlstate );
1293
1298
  }
1299
+
1294
1300
  }
1295
1301
  /* */
1296
1302
 
@@ -1594,6 +1600,7 @@ static int _ruby_ibm_db_parse_options ( VALUE options, int type, void *handle, V
1594
1600
  if( ret_val == Qfalse ){
1595
1601
  return SQL_ERROR;
1596
1602
  }
1603
+
1597
1604
  return SQL_SUCCESS;
1598
1605
  }
1599
1606
  /* */
@@ -1626,6 +1633,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1626
1633
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
1627
1634
  ruby_xfree( result_cols_args );
1628
1635
  result_cols_args = NULL;
1636
+ stmt_res->rc = -1;
1629
1637
  return -1;
1630
1638
  }
1631
1639
  stmt_res->num_columns = result_cols_args->count;
@@ -1666,6 +1674,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1666
1674
  result_cols_args = NULL;
1667
1675
  describecolargs = NULL;
1668
1676
  stmt_res->column_info = NULL;
1677
+ stmt_res->rc = -1;
1669
1678
  return -1;
1670
1679
  }
1671
1680
  if ( describecolargs->name_length <= 0 ) {
@@ -1698,6 +1707,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1698
1707
  result_cols_args = NULL;
1699
1708
  describecolargs = NULL;
1700
1709
  stmt_res->column_info = NULL;
1710
+ stmt_res->rc = -1;
1701
1711
  return -1;
1702
1712
  }
1703
1713
  } else {
@@ -1720,6 +1730,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1720
1730
  ruby_xfree( result_cols_args );
1721
1731
  result_cols_args = NULL;
1722
1732
  }
1733
+ stmt_res->rc = 0;
1723
1734
  return 0;
1724
1735
  }
1725
1736
  /* */
@@ -1742,7 +1753,7 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
1742
1753
  memset(bindCol_args,'\0',sizeof(struct _ibm_db_bind_col_struct));
1743
1754
 
1744
1755
  bindCol_args->stmt_res = stmt_res;
1745
-
1756
+
1746
1757
  for (i=0; i<stmt_res->num_columns; i++) {
1747
1758
  column_type = stmt_res->column_info[i].type;
1748
1759
  row_data = &stmt_res->row_data[i].data;
@@ -1788,7 +1799,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
1788
1799
  bindCol_args->out_length = (SQLLEN *) (&stmt_res->row_data[i].out_length);
1789
1800
 
1790
1801
  rc = _ruby_ibm_db_SQLBindCol_helper( bindCol_args );
1791
-
1792
1802
  if ( rc == SQL_ERROR ) {
1793
1803
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT,
1794
1804
  rc, 1, NULL, NULL, -1, 1, 0 );
@@ -1949,7 +1959,7 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
1949
1959
  bindCol_args->buff_length = 4;
1950
1960
  bindCol_args->TargetValuePtr = &stmt_res->column_info[i].lob_loc;
1951
1961
  bindCol_args->out_length = &stmt_res->column_info[i].loc_ind;
1952
-
1962
+
1953
1963
  rc = _ruby_ibm_db_SQLBindCol_helper( bindCol_args );
1954
1964
 
1955
1965
  if ( rc == SQL_ERROR ) {
@@ -1971,12 +1981,12 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
1971
1981
  bindCol_args->TargetValuePtr = NULL;
1972
1982
  bindCol_args->out_length = NULL;
1973
1983
  }
1974
-
1975
1984
  /*Free Any Memory Allocated*/
1976
1985
  if ( bindCol_args != NULL ) {
1977
1986
  ruby_xfree( bindCol_args );
1978
1987
  bindCol_args = NULL;
1979
1988
  }
1989
+
1980
1990
  return rc;
1981
1991
  }
1982
1992
  /* */
@@ -2021,6 +2031,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2021
2031
  get_handle_attr_args *get_handleAttr_args = NULL;
2022
2032
 
2023
2033
  conn_alive = 1;
2034
+
2024
2035
 
2025
2036
  handleAttr_args = ALLOC( set_handle_attr_args );
2026
2037
  memset(handleAttr_args,'\0',sizeof(struct _ibm_db_set_handle_attr_struct));
@@ -2028,8 +2039,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2028
2039
  do {
2029
2040
  /* Check if we already have a connection for this userID & database combination */
2030
2041
  if ( isPersistent ) {
2031
-
2032
- if ( !NIL_P(entry = rb_hash_aref(persistent_list, data->hKey)) ) {
2042
+ if ( !NIL_P(entry = rb_hash_aref(persistent_list, data->hKey)) ) {
2033
2043
  Data_Get_Struct(entry, conn_handle, conn_res);
2034
2044
  #ifndef PASE /* i5/OS server mode is persistant */
2035
2045
  /* Need to reinitialize connection? */
@@ -2041,9 +2051,9 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2041
2051
  get_handleAttr_args->valuePtr = (SQLPOINTER)&conn_alive;
2042
2052
  get_handleAttr_args->buff_length = 0;
2043
2053
  get_handleAttr_args->out_length = NULL;
2044
-
2054
+
2045
2055
  rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
2046
-
2056
+
2047
2057
  ruby_xfree( get_handleAttr_args );
2048
2058
  get_handleAttr_args = NULL;
2049
2059
 
@@ -2057,12 +2067,10 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2057
2067
  } else {
2058
2068
  /* Need to check for max pconnections? */
2059
2069
  }
2060
-
2061
2070
  if ( conn_res == NULL ) {
2062
2071
  conn_res = ALLOC(conn_handle);
2063
2072
  memset(conn_res, '\0', sizeof(conn_handle));
2064
2073
  }
2065
-
2066
2074
  /* handle not active as of yet */
2067
2075
  conn_res->handle_active = 0;
2068
2076
 
@@ -2098,10 +2106,8 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2098
2106
  return Qnil;
2099
2107
  break;
2100
2108
  }
2101
-
2102
2109
  handleAttr_args->handle = &( conn_res->henv );
2103
2110
  handleAttr_args->strLength = 0;
2104
-
2105
2111
  #ifndef PASE /* i5/OS server mode */
2106
2112
  handleAttr_args->attribute = SQL_ATTR_ODBC_VERSION;
2107
2113
  handleAttr_args->valuePtr = (void *) SQL_OV_ODBC3;
@@ -2110,7 +2116,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2110
2116
  handleAttr_args->attribute = SQL_ATTR_SERVER_MODE;
2111
2117
  handleAttr_args->valuePtr = &attr;
2112
2118
  #endif /* PASE */
2113
-
2114
2119
  rc = _ruby_ibm_db_SQLSetEnvAttr_helper( handleAttr_args );
2115
2120
 
2116
2121
  if (rc != SQL_SUCCESS) {
@@ -2138,7 +2143,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2138
2143
  break;
2139
2144
  }
2140
2145
  }
2141
-
2142
2146
  if (! reused) {
2143
2147
  /* Alloc CONNECT Handle */
2144
2148
  rc = SQLAllocHandle( SQL_HANDLE_DBC, conn_res->henv, &(conn_res->hdbc) );
@@ -2166,7 +2170,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2166
2170
  break;
2167
2171
  }
2168
2172
  }
2169
-
2170
2173
  handleAttr_args->handle = &(conn_res->hdbc);
2171
2174
  handleAttr_args->strLength = SQL_NTS;
2172
2175
  handleAttr_args->attribute = SQL_ATTR_AUTOCOMMIT;
@@ -2178,13 +2181,11 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2178
2181
  handleAttr_args->valuePtr = (SQLPOINTER)(conn_res->auto_commit);
2179
2182
 
2180
2183
  rc = _ruby_ibm_db_SQLSetConnectAttr_helper( handleAttr_args );
2181
-
2182
2184
  #else
2183
2185
  conn_res->auto_commit = SQL_AUTOCOMMIT_ON;
2184
2186
  handleAttr_args->valuePtr = (SQLPOINTER)(&conn_res->auto_commit);
2185
2187
 
2186
2188
  rc = _ruby_ibm_db_SQLSetConnectAttr_helper( handleAttr_args );
2187
-
2188
2189
  if (!IBM_DB_G(i5_allow_commit)) {
2189
2190
  if (!rc) {
2190
2191
  SQLINTEGER nocommitpase = SQL_TXN_NO_COMMIT;
@@ -2197,7 +2198,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2197
2198
  }
2198
2199
  }
2199
2200
  #endif
2200
-
2201
2201
  conn_res->c_bin_mode = IBM_DB_G(bin_mode);
2202
2202
  conn_res->c_case_mode = CASE_NATURAL;
2203
2203
  conn_res->c_cursor_type = SQL_SCROLL_FORWARD_ONLY;
@@ -2211,7 +2211,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2211
2211
  conn_res->errorType = 1;
2212
2212
 
2213
2213
  conn_res->transaction_active = 0; /*No transaction is active*/
2214
-
2215
2214
  /* Set Options */
2216
2215
  if ( !NIL_P(*options) ) {
2217
2216
  rc = _ruby_ibm_db_parse_options( *options, SQL_HANDLE_DBC, conn_res, error );
@@ -2224,12 +2223,10 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2224
2223
  return Qnil;
2225
2224
  }
2226
2225
  }
2227
-
2228
2226
  if (! reused) {
2229
2227
  conn_args->hdbc = &(conn_res->hdbc);
2230
2228
 
2231
2229
  rc = _ruby_ibm_db_SQLConnect_helper( conn_args );
2232
-
2233
2230
  if ( rc == SQL_ERROR ) {
2234
2231
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
2235
2232
  SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc );
@@ -2244,38 +2241,33 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2244
2241
  } else {
2245
2242
  #ifdef UNICODE_SUPPORT_VERSION
2246
2243
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Connection failed: <error message could not be retrieved>");
2247
- #else
2244
+ #else
2248
2245
  *error = rb_str_new2("Connection failed: <error message could not be retrieved>");
2249
2246
  #endif
2250
2247
  }
2251
2248
  ruby_xfree( handleAttr_args );
2252
- handleAttr_args = NULL;
2253
- _ruby_ibm_db_free_conn_struct( conn_res );
2249
+ handleAttr_args = NULL;
2250
+ _ruby_ibm_db_free_conn_struct( conn_res );
2254
2251
  return Qnil;
2255
- }
2256
-
2252
+ }
2257
2253
  /* Get the AUTOCOMMIT state from the CLI driver as cli driver could have changed autocommit status based on it's precedence */
2258
2254
  get_handleAttr_args = ALLOC( get_handle_attr_args );
2259
2255
  memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
2260
-
2256
+
2261
2257
  get_handleAttr_args->handle = &( conn_res->hdbc );
2262
2258
  get_handleAttr_args->attribute = SQL_ATTR_AUTOCOMMIT;
2263
- get_handleAttr_args->valuePtr = (SQLPOINTER)(&conn_res->auto_commit);
2259
+ get_handleAttr_args->valuePtr = (SQLPOINTER)(&conn_res->auto_commit);
2264
2260
  get_handleAttr_args->buff_length = 0;
2265
- get_handleAttr_args->out_length = NULL;
2266
-
2267
- rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
2268
-
2261
+ get_handleAttr_args->out_length = NULL;
2262
+ rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
2269
2263
  ruby_xfree( get_handleAttr_args );
2270
2264
  get_handleAttr_args = NULL;
2271
-
2272
2265
  if ( rc == SQL_ERROR ) {
2273
2266
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
2274
- rc = _ruby_ibm_db_SQLDisconnect_helper( &(conn_res->hdbc) );
2267
+ rc = _ruby_ibm_db_SQLDisconnect_helper( &(conn_res->hdbc) );
2275
2268
  SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc );
2276
- SQLFreeHandle( SQL_HANDLE_ENV, conn_res->henv );
2277
- if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2278
-
2269
+ SQLFreeHandle( SQL_HANDLE_ENV, conn_res->henv );
2270
+ if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2279
2271
  #ifdef UNICODE_SUPPORT_VERSION
2280
2272
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Failed to retrieve autocommit status during connection: "),
2281
2273
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(conn_res->ruby_error_msg, conn_res->ruby_error_msg_len));
@@ -2295,7 +2287,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2295
2287
  return Qnil;
2296
2288
 
2297
2289
  }
2298
-
2299
2290
  #ifdef CLI_DBC_SERVER_TYPE_DB2LUW
2300
2291
  #ifdef SQL_ATTR_DECFLOAT_ROUNDING_MODE
2301
2292
 
@@ -2307,7 +2298,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2307
2298
 
2308
2299
  #endif
2309
2300
  #endif
2310
-
2311
2301
  /* Get the server name */
2312
2302
  #ifdef UNICODE_SUPPORT_VERSION
2313
2303
  server = ALLOC_N(SQLWCHAR, 2048);
@@ -2318,20 +2308,18 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2318
2308
  server = ALLOC_N(SQLCHAR, 2048);
2319
2309
  memset(server, 0, sizeof(server));
2320
2310
  #endif
2321
-
2322
2311
  getInfo_args = ALLOC( get_info_args );
2323
2312
  memset(getInfo_args,'\0',sizeof(struct _ibm_db_get_info_struct));
2324
-
2325
2313
  getInfo_args->conn_res = conn_res;
2326
2314
  getInfo_args->out_length = &out_length;
2327
2315
  getInfo_args->infoType = SQL_DBMS_NAME;
2328
2316
  getInfo_args->infoValue = (SQLPOINTER)server;
2317
+
2329
2318
  #ifdef UNICODE_SUPPORT_VERSION
2330
2319
  getInfo_args->buff_length = 2048 * sizeof(SQLWCHAR);
2331
2320
  #else
2332
2321
  getInfo_args->buff_length = 2048;
2333
2322
  #endif
2334
-
2335
2323
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
2336
2324
 
2337
2325
  #ifndef UNICODE_SUPPORT_VERSION
@@ -2350,12 +2338,10 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2350
2338
  is_informix = 1;
2351
2339
  }
2352
2340
  #endif
2353
-
2354
2341
  ruby_xfree( getInfo_args );
2355
2342
  ruby_xfree( server );
2356
2343
  getInfo_args = NULL;
2357
2344
  server = NULL;
2358
-
2359
2345
  rc = SQL_SUCCESS; /*Setting rc to SQL_SUCCESS, because the below block may or may not be executed*/
2360
2346
 
2361
2347
  /* Set SQL_ATTR_REPLACE_QUOTED_LITERALS connection attribute to
@@ -2372,7 +2358,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2372
2358
  handleAttr_args->strLength = SQL_IS_INTEGER;
2373
2359
  handleAttr_args->attribute = SQL_ATTR_REPLACE_QUOTED_LITERALS;
2374
2360
  handleAttr_args->valuePtr = (SQLPOINTER)(enable_numeric_literals);
2375
-
2376
2361
  rc = _ruby_ibm_db_SQLSetConnectAttr_helper( handleAttr_args );
2377
2362
  if (rc != SQL_SUCCESS) {
2378
2363
  handleAttr_args->attribute = SQL_ATTR_REPLACE_QUOTED_LITERALS_OLDVALUE;
@@ -2386,7 +2371,6 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2386
2371
  handleAttr_args->strLength = SQL_IS_INTEGER;
2387
2372
  handleAttr_args->attribute = SQL_ATTR_REPLACE_QUOTED_LITERALS;
2388
2373
  handleAttr_args->valuePtr = (SQLPOINTER)(&enable_numeric_literals);
2389
-
2390
2374
  rc = _ruby_ibm_db_SQLSetConnectAttr_helper( handleAttr_args );
2391
2375
  if (rc != SQL_SUCCESS) {
2392
2376
  handleAttr_args->attribute = SQL_ATTR_REPLACE_QUOTED_LITERALS_OLDVALUE;
@@ -2400,46 +2384,52 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2400
2384
  }
2401
2385
  conn_res->handle_active = 1;
2402
2386
  } while (0);
2403
-
2404
2387
  if( handleAttr_args != NULL ) {
2405
2388
  ruby_xfree( handleAttr_args );
2406
2389
  handleAttr_args = NULL;
2407
2390
  }
2408
-
2409
- if (data->hKey != Qnil) {
2410
- if (! reused && rc == SQL_SUCCESS) {
2391
+ if (data->hKey != Qnil)
2392
+ {
2393
+ //data->conn_res = conn_res;
2394
+ if (! reused && rc == SQL_SUCCESS)
2395
+ {
2411
2396
  /* If we created a new persistent connection, add it to the persistent_list */
2412
2397
  entry = Data_Wrap_Struct(le_pconn_struct,
2413
- _ruby_ibm_db_mark_pconn_struct, _ruby_ibm_db_free_pconn_struct,
2398
+ _ruby_ibm_db_mark_pconn_struct, _ruby_ibm_db_free_pconn_struct,
2414
2399
  conn_res);
2400
+ //data->entry = entry;
2415
2401
  rb_hash_aset(persistent_list, data->hKey, entry);
2416
2402
  }
2403
+ data->entry = entry;
2417
2404
  }
2418
-
2419
2405
  if ( rc < SQL_SUCCESS ) {
2420
2406
  if (conn_res != NULL && conn_res->handle_active) {
2421
2407
  rc = SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc);
2422
2408
  rc = SQLFreeHandle(SQL_HANDLE_ENV, conn_res->henv );
2423
2409
  }
2424
-
2425
2410
  /* free memory */
2426
2411
  if (conn_res != NULL) {
2427
2412
  conn_res->handle_active = 0;
2428
2413
  _ruby_ibm_db_free_conn_struct(conn_res);
2429
2414
  }
2430
-
2431
2415
  return Qfalse;
2432
2416
  } else if (!NIL_P(entry)) {
2433
- return entry;
2417
+ //data->conn_res = conn_res;
2418
+ return entry;
2434
2419
  } else if (isPersistent) {
2435
- return Data_Wrap_Struct(le_pconn_struct,
2420
+ //data->conn_res = conn_res;
2421
+ entry = Data_Wrap_Struct(le_pconn_struct,
2436
2422
  _ruby_ibm_db_mark_pconn_struct, _ruby_ibm_db_free_pconn_struct,
2437
2423
  conn_res);
2424
+ data->entry = entry;
2438
2425
  } else {
2439
- return Data_Wrap_Struct(le_conn_struct,
2440
- _ruby_ibm_db_mark_conn_struct, _ruby_ibm_db_free_conn_struct,
2441
- conn_res);
2426
+ data->conn_res = conn_res;
2427
+ /* return Data_Wrap_Struct(le_conn_struct,
2428
+ _ruby_ibm_db_mark_conn_struct, _ruby_ibm_db_free_conn_struct,
2429
+ conn_res);
2430
+ */
2442
2431
  }
2432
+
2443
2433
  }
2444
2434
 
2445
2435
  /* */
@@ -2450,7 +2440,8 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2450
2440
  {
2451
2441
  connect_args *conn_args = NULL;
2452
2442
  connect_helper_args *helper_args = NULL;
2453
-
2443
+ conn_handle *conn_res = NULL;
2444
+
2454
2445
  VALUE r_db, r_uid, r_passwd, options,return_value;
2455
2446
  VALUE r_literal_replacement = Qnil;
2456
2447
 
@@ -2459,36 +2450,37 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2459
2450
  #endif
2460
2451
 
2461
2452
  VALUE error = Qnil;
2462
-
2453
+
2454
+
2463
2455
  rb_scan_args(argc, argv, "32", &r_db, &r_uid, &r_passwd, &options, &r_literal_replacement );
2464
2456
 
2465
2457
  /* Allocate the mwmory for necessary components */
2466
2458
 
2467
2459
  conn_args = ALLOC( connect_args );
2468
2460
  memset(conn_args,'\0',sizeof(struct _ibm_db_connect_args_struct));
2469
-
2461
+
2470
2462
  #ifndef UNICODE_SUPPORT_VERSION
2471
2463
  conn_args->database = (SQLCHAR *) RSTRING_PTR( r_db );
2472
2464
  conn_args->database_len = (SQLSMALLINT) RSTRING_LEN( r_db );
2473
2465
 
2474
2466
  conn_args->uid = (SQLCHAR *) RSTRING_PTR( r_uid );
2475
2467
  conn_args->uid_len = (SQLSMALLINT) RSTRING_LEN( r_uid );
2476
-
2468
+
2477
2469
  conn_args->password = (SQLCHAR *) RSTRING_PTR( r_passwd );
2478
2470
  conn_args->password_len = (SQLSMALLINT) RSTRING_LEN( r_passwd );
2471
+
2479
2472
  #else
2480
2473
  r_db_utf16 = _ruby_ibm_db_export_str_to_utf16( r_db );
2481
2474
  r_db_ascii = _ruby_ibm_db_export_str_to_ascii( r_db );
2482
2475
  r_uid_utf16 = _ruby_ibm_db_export_str_to_utf16( r_uid );
2483
2476
  r_passwd_utf16 = _ruby_ibm_db_export_str_to_utf16( r_passwd );
2484
-
2477
+
2485
2478
  conn_args->database = (SQLWCHAR *) RSTRING_PTR( r_db_utf16 );
2486
2479
  conn_args->database_len = (SQLSMALLINT) RSTRING_LEN( r_db_utf16 )/sizeof(SQLWCHAR);
2487
2480
  /*RSTRING returns the number of bytes, while CLI expects number of SQLWCHAR(2 bytes) elements, hence dividing the len by 2*/
2488
2481
 
2489
2482
  conn_args->uid = (SQLWCHAR *) RSTRING_PTR( r_uid_utf16 );
2490
- conn_args->uid_len = (SQLSMALLINT) RSTRING_LEN( r_uid_utf16 )/sizeof(SQLWCHAR);
2491
-
2483
+ conn_args->uid_len = (SQLSMALLINT) RSTRING_LEN( r_uid_utf16 )/sizeof(SQLWCHAR);
2492
2484
  conn_args->password = (SQLWCHAR *) RSTRING_PTR( r_passwd_utf16 );
2493
2485
  conn_args->password_len = (SQLSMALLINT) RSTRING_LEN( r_passwd_utf16 )/sizeof(SQLWCHAR);
2494
2486
  #endif
@@ -2503,15 +2495,17 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2503
2495
  } else {
2504
2496
  conn_args->ctlg_conn = 1;
2505
2497
  }
2498
+
2506
2499
 
2507
- helper_args = ALLOC( connect_helper_args );
2500
+ helper_args = ALLOC( connect_helper_args );
2508
2501
  memset(helper_args,'\0',sizeof(struct _ibm_db_connect_helper_args_struct));
2502
+
2509
2503
 
2510
2504
  helper_args->conn_args = conn_args;
2511
2505
  helper_args->isPersistent = isPersistent;
2512
2506
  helper_args->options = &options;
2513
2507
  helper_args->error = &error;
2514
-
2508
+
2515
2509
  if( isPersistent ) {
2516
2510
  /*If making a persistent connection calculate the hash key to cache the connection in persistence list*/
2517
2511
  #ifndef UNICODE_SUPPORT_VERSION
@@ -2526,43 +2520,67 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2526
2520
  } else {
2527
2521
  helper_args->hKey = Qnil;
2528
2522
  }
2529
-
2530
2523
  if( !NIL_P(r_literal_replacement) ) {
2531
2524
  helper_args->literal_replacement = NUM2INT(r_literal_replacement);
2532
2525
  } else {
2533
2526
  helper_args->literal_replacement = SET_QUOTED_LITERAL_REPLACEMENT_ON; /*QUOTED LITERAL replacemnt is ON by default*/
2534
2527
  }
2535
-
2536
2528
  /* Call the function where the actual logic is being run*/
2537
2529
  #ifdef UNICODE_SUPPORT_VERSION
2538
- //return_value = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_connect_helper2, helper_args,
2539
- return_value = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_connect_helper2, helper_args,
2540
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
2530
+
2531
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_connect_helper2, helper_args, (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
2532
+
2533
+
2534
+ conn_res = helper_args->conn_res;
2535
+
2536
+ if(helper_args->isPersistent)
2537
+ {
2538
+ if(helper_args-> entry == NULL)
2539
+ {
2540
+ return_value = Qnil;
2541
+ }
2542
+ else
2543
+ {
2544
+ return_value = helper_args->entry;
2545
+ }
2546
+ }
2547
+ else
2548
+ {
2549
+ if( conn_res == NULL )
2550
+ {
2551
+ return_value = Qnil;
2552
+ }
2553
+ else
2554
+ {
2555
+ return_value = Data_Wrap_Struct(le_conn_struct, _ruby_ibm_db_mark_conn_struct, _ruby_ibm_db_free_conn_struct, conn_res);
2556
+ }
2557
+ }
2541
2558
  #else
2542
2559
  return_value = _ruby_ibm_db_connect_helper2( helper_args );
2543
2560
  #endif
2544
-
2545
2561
  /* Free the memory allocated */
2546
2562
  if(conn_args != NULL) {
2547
2563
  /* Memory to structure elements of helper_args is not allocated explicitly hence it is automatically freed by Ruby.
2548
2564
  Dont try to explicitly free it, else a double free exception is thrown and the application will crash
2549
2565
  with memory dump.
2550
2566
  */
2551
- helper_args->conn_args = NULL;
2552
- ruby_xfree( conn_args );
2553
- conn_args = NULL;
2567
+ helper_args->conn_args = NULL;
2568
+ ruby_xfree( conn_args );
2569
+ conn_args = NULL;
2554
2570
  }
2555
-
2556
2571
  if ( helper_args != NULL ) {
2557
- ruby_xfree( helper_args );
2558
- helper_args = NULL;
2572
+ ruby_xfree( helper_args );
2573
+ helper_args = NULL;
2559
2574
  }
2560
-
2561
2575
  if( return_value == Qnil ){
2562
- rb_throw( RSTRING_PTR(error), Qnil );
2563
- }
2576
+ rb_throw( RSTRING_PTR(error), Qnil );
2577
+ }
2564
2578
  return return_value;
2565
2579
  }
2580
+
2581
+
2582
+
2583
+
2566
2584
  /*Check for feasibility of moving to other file*/
2567
2585
  typedef struct _rounding_mode_struct {
2568
2586
  stmt_handle *stmt_res;
@@ -2714,7 +2732,7 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client( set_handle_attr_args
2714
2732
  rnd_mode->stmt_res = stmt_res;
2715
2733
 
2716
2734
  _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(rnd_mode, conn_res);
2717
-
2735
+
2718
2736
  _ruby_ibm_db_free_stmt_struct( rnd_mode->stmt_res );
2719
2737
  rnd_mode->stmt_res = NULL;
2720
2738
  stmt_res = NULL;
@@ -2809,6 +2827,7 @@ static void _ruby_ibm_db_clear_conn_err_cache()
2809
2827
  */
2810
2828
  VALUE ibm_db_connect(int argc, VALUE *argv, VALUE self)
2811
2829
  {
2830
+
2812
2831
  _ruby_ibm_db_clear_conn_err_cache();
2813
2832
 
2814
2833
  return _ruby_ibm_db_connect_helper( argc, argv, 0 );
@@ -2873,13 +2892,14 @@ VALUE ibm_db_connect(int argc, VALUE *argv, VALUE self)
2873
2892
  VALUE ibm_db_pconnect(int argc, VALUE *argv, VALUE self)
2874
2893
  {
2875
2894
  _ruby_ibm_db_clear_conn_err_cache();
2876
-
2877
2895
  return _ruby_ibm_db_connect_helper( argc, argv, 1);
2896
+
2878
2897
  }
2879
2898
  /*
2880
2899
  * CreateDB helper
2881
2900
  */
2882
2901
  VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet, VALUE mode, int createNX) {
2902
+
2883
2903
 
2884
2904
  VALUE return_value = Qfalse;
2885
2905
  #ifdef UNICODE_SUPPORT_VERSION
@@ -2895,13 +2915,13 @@ VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet,
2895
2915
 
2896
2916
  if (!NIL_P(connection)) {
2897
2917
  Data_Get_Struct(connection, conn_handle, conn_res);
2898
-
2918
+
2899
2919
  if( 0 == createDbSupported ) {
2900
2920
  rb_warn("Create Database not supported: This function is only supported from DB2 Client v97fp4 version and onwards");
2901
2921
  return Qfalse;
2902
2922
  }
2903
-
2904
- if (!conn_res->handle_active) {
2923
+
2924
+ if (!conn_res || !conn_res->handle_active) {
2905
2925
  rb_warn("Connection is not active");
2906
2926
  return Qfalse;
2907
2927
  }
@@ -2953,10 +2973,10 @@ VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet,
2953
2973
 
2954
2974
  _ruby_ibm_db_clear_conn_err_cache();
2955
2975
 
2956
- #ifdef UNICODE_SUPPORT_VERSION
2957
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLCreateDB_helper, create_db_args,
2958
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLCreateDB_helper, create_db_args,
2976
+ #ifdef UNICODE_SUPPORT_VERSION
2977
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLCreateDB_helper, create_db_args,
2959
2978
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL );
2979
+ rc = create_db_args->rc;
2960
2980
  #else
2961
2981
  rc = _ruby_ibm_db_SQLCreateDB_helper( create_db_args );
2962
2982
  #endif
@@ -3056,8 +3076,8 @@ VALUE ruby_ibm_db_dropDb_helper(VALUE connection, VALUE dbName) {
3056
3076
  rb_warn("Drop Database not supported: This function is only supported from DB2 Client v97fp4 version and onwards");
3057
3077
  return Qfalse;
3058
3078
  }
3059
-
3060
- if (!conn_res->handle_active) {
3079
+
3080
+ if (!conn_res || !conn_res->handle_active) {
3061
3081
  rb_warn("Connection is not active");
3062
3082
  return Qfalse;
3063
3083
  }
@@ -3083,10 +3103,10 @@ VALUE ruby_ibm_db_dropDb_helper(VALUE connection, VALUE dbName) {
3083
3103
 
3084
3104
  _ruby_ibm_db_clear_conn_err_cache();
3085
3105
 
3086
- #ifdef UNICODE_SUPPORT_VERSION
3087
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLDropDB_helper, drop_db_args,
3088
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDropDB_helper, drop_db_args,
3106
+ #ifdef UNICODE_SUPPORT_VERSION
3107
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDropDB_helper, drop_db_args,
3089
3108
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL );
3109
+ rc = drop_db_args->rc;
3090
3110
  #else
3091
3111
  rc = _ruby_ibm_db_SQLDropDB_helper( drop_db_args );
3092
3112
  #endif
@@ -3288,12 +3308,11 @@ VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self)
3288
3308
 
3289
3309
  if (!NIL_P(connection)) {
3290
3310
  Data_Get_Struct(connection, conn_handle, conn_res);
3291
-
3292
- if (!conn_res->handle_active) {
3311
+
3312
+ if (!conn_res || !conn_res->handle_active) {
3293
3313
  rb_warn("Connection is not active");
3294
3314
  return Qfalse;
3295
3315
  }
3296
-
3297
3316
  /* If value in handle is different from value passed in */
3298
3317
  if (argc == 2) {
3299
3318
  autocommit = FIX2INT(value);
@@ -3304,16 +3323,13 @@ VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self)
3304
3323
  handleAttr_args->handle = &( conn_res->hdbc );
3305
3324
  handleAttr_args->strLength = SQL_IS_INTEGER;
3306
3325
  handleAttr_args->attribute = SQL_ATTR_AUTOCOMMIT;
3307
-
3308
3326
 
3309
3327
  #ifndef PASE
3310
3328
  handleAttr_args->valuePtr = (SQLPOINTER)autocommit;
3311
3329
  #else
3312
3330
  handleAttr_args->valuePtr = (SQLPOINTER)&autocommit;
3313
3331
  #endif
3314
-
3315
3332
  rc = _ruby_ibm_db_SQLSetConnectAttr_helper( handleAttr_args );
3316
-
3317
3333
  if ( rc == SQL_ERROR ) {
3318
3334
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
3319
3335
  } else {
@@ -3323,7 +3339,7 @@ VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self)
3323
3339
  * Hence set flag_transaction to 0 indicating no transaction is in progress */
3324
3340
  if( autocommit == SQL_AUTOCOMMIT_ON ) {
3325
3341
  conn_res->transaction_active = 0;
3326
- }
3342
+ }
3327
3343
  }
3328
3344
  }
3329
3345
  ruby_xfree( handleAttr_args );
@@ -3333,12 +3349,10 @@ VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self)
3333
3349
  ret_val = INT2NUM(conn_res->auto_commit);
3334
3350
  }
3335
3351
  }
3336
-
3337
3352
  if ( handleAttr_args != NULL ) {
3338
3353
  ruby_xfree( handleAttr_args );
3339
3354
  handleAttr_args = NULL;
3340
3355
  }
3341
-
3342
3356
  return ret_val;
3343
3357
  }
3344
3358
  /* */
@@ -3434,6 +3448,7 @@ static void _ruby_ibm_db_add_param_cache( stmt_handle *stmt_res, int param_no, c
3434
3448
  */
3435
3449
  VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long param_type, long data_type,
3436
3450
  long precision, long scale, long size, stmt_handle *stmt_res, describeparam_args *data) {
3451
+
3437
3452
  int rc = 0;
3438
3453
  VALUE return_value = Qtrue;
3439
3454
  #ifdef UNICODE_SUPPORT_VERSION
@@ -3446,10 +3461,11 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3446
3461
  case 3:
3447
3462
  param_type = SQL_PARAM_INPUT;
3448
3463
 
3449
- #ifdef UNICODE_SUPPORT_VERSION
3450
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3451
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3464
+ #ifdef UNICODE_SUPPORT_VERSION
3465
+
3466
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3452
3467
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
3468
+ rc = data->rc;
3453
3469
  #else
3454
3470
  rc = _ruby_ibm_db_SQLDescribeParam_helper( data );
3455
3471
  #endif
@@ -3467,10 +3483,10 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3467
3483
 
3468
3484
  case 4:
3469
3485
 
3470
- #ifdef UNICODE_SUPPORT_VERSION
3471
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3472
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3486
+ #ifdef UNICODE_SUPPORT_VERSION
3487
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3473
3488
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
3489
+ rc = data->rc;
3474
3490
  #else
3475
3491
  rc = _ruby_ibm_db_SQLDescribeParam_helper( data );
3476
3492
  #endif
@@ -3488,10 +3504,10 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3488
3504
 
3489
3505
  case 5:
3490
3506
 
3491
- #ifdef UNICODE_SUPPORT_VERSION
3492
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3493
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3507
+ #ifdef UNICODE_SUPPORT_VERSION
3508
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3494
3509
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3510
+ rc = data->rc;
3495
3511
  #else
3496
3512
  rc = _ruby_ibm_db_SQLDescribeParam_helper( data );
3497
3513
  #endif
@@ -3510,10 +3526,10 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3510
3526
 
3511
3527
  case 6:
3512
3528
 
3513
- #ifdef UNICODE_SUPPORT_VERSION
3514
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3515
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3529
+ #ifdef UNICODE_SUPPORT_VERSION
3530
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3516
3531
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3532
+ rc = data->rc;
3517
3533
  #else
3518
3534
  rc = _ruby_ibm_db_SQLDescribeParam_helper( data );
3519
3535
  #endif
@@ -3689,6 +3705,7 @@ VALUE ibm_db_bind_param(int argc, VALUE *argv, VALUE self)
3689
3705
  ruby_xfree( desc_param_args );
3690
3706
  desc_param_args = NULL;
3691
3707
  }
3708
+
3692
3709
  return return_value;
3693
3710
  }
3694
3711
  /* */
@@ -3728,7 +3745,8 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
3728
3745
  /* Check to see if it's a persistent connection; if so, just return true */
3729
3746
  Data_Get_Struct(connection, conn_handle, conn_res);
3730
3747
 
3731
- if (!conn_res->handle_active) {
3748
+
3749
+ if (!conn_res || !conn_res->handle_active) {
3732
3750
  rb_warn("Connection is not active");
3733
3751
  return Qfalse;
3734
3752
  }
@@ -3743,10 +3761,10 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
3743
3761
  end_X_args->handleType = SQL_HANDLE_DBC;
3744
3762
  end_X_args->completionType = SQL_ROLLBACK; /*Remeber you are rolling back the transaction*/
3745
3763
 
3746
- #ifdef UNICODE_SUPPORT_VERSION
3747
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
3748
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
3764
+ #ifdef UNICODE_SUPPORT_VERSION
3765
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
3749
3766
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
3767
+ rc = end_X_args->rc;
3750
3768
  #else
3751
3769
  rc = _ruby_ibm_db_SQLEndTran( end_X_args );
3752
3770
  #endif
@@ -3763,18 +3781,16 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
3763
3781
  }
3764
3782
 
3765
3783
  #ifdef UNICODE_SUPPORT_VERSION
3766
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLDisconnect_helper, &(conn_res->hdbc),
3767
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDisconnect_helper, &(conn_res->hdbc),
3768
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
3784
+ rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDisconnect_helper, &(conn_res->hdbc),
3785
+ (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
3769
3786
  #else
3770
- rc = _ruby_ibm_db_SQLDisconnect_helper( &(conn_res->hdbc) );
3787
+ rc = _ruby_ibm_db_SQLDisconnect_helper( &(conn_res->hdbc) );
3771
3788
  #endif
3772
3789
 
3773
3790
  if ( rc == SQL_ERROR ) {
3774
3791
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
3775
3792
  return_value = Qfalse;
3776
3793
  } else {
3777
-
3778
3794
  rc = SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc);
3779
3795
  if ( rc == SQL_ERROR ) {
3780
3796
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
@@ -3798,6 +3814,7 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
3798
3814
  } else {
3799
3815
  return_value = Qfalse;
3800
3816
  }
3817
+
3801
3818
  return return_value;
3802
3819
  }
3803
3820
  /* */
@@ -3940,10 +3957,10 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3940
3957
  }
3941
3958
  col_privileges_args->stmt_res = stmt_res;
3942
3959
 
3943
- #ifdef UNICODE_SUPPORT_VERSION
3944
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLColumnPrivileges_helper, col_privileges_args,
3945
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumnPrivileges_helper, col_privileges_args,
3960
+ #ifdef UNICODE_SUPPORT_VERSION
3961
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumnPrivileges_helper, col_privileges_args,
3946
3962
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3963
+ rc = col_privileges_args->rc;
3947
3964
  #else
3948
3965
  rc = _ruby_ibm_db_SQLColumnPrivileges_helper( col_privileges_args );
3949
3966
  #endif
@@ -3952,7 +3969,6 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3952
3969
 
3953
3970
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
3954
3971
  NULL, NULL, -1, 1, 1 );
3955
-
3956
3972
  _ruby_ibm_db_free_stmt_struct( stmt_res );
3957
3973
  stmt_res = NULL;
3958
3974
 
@@ -4066,7 +4082,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4066
4082
  if (!NIL_P(connection)) {
4067
4083
  Data_Get_Struct(connection, conn_handle, conn_res);
4068
4084
 
4069
- if ( !conn_res->handle_active ) {
4085
+ if ( !conn_res || !conn_res->handle_active ) {
4070
4086
  rb_warn("Connection is not active");
4071
4087
  return_value = Qfalse;
4072
4088
  } else {
@@ -4121,10 +4137,10 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4121
4137
  }
4122
4138
  col_metadata_args->stmt_res = stmt_res;
4123
4139
 
4124
- #ifdef UNICODE_SUPPORT_VERSION
4125
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLColumns_helper, col_metadata_args,
4126
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumns_helper, col_metadata_args,
4140
+ #ifdef UNICODE_SUPPORT_VERSION
4141
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumns_helper, col_metadata_args,
4127
4142
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4143
+ rc = col_metadata_args->rc;
4128
4144
  #else
4129
4145
  rc = _ruby_ibm_db_SQLColumns_helper( col_metadata_args );
4130
4146
  #endif
@@ -4133,7 +4149,6 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4133
4149
 
4134
4150
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
4135
4151
  NULL, NULL, -1, 1, 1 );
4136
-
4137
4152
  _ruby_ibm_db_free_stmt_struct( stmt_res );
4138
4153
  stmt_res = NULL;
4139
4154
 
@@ -4207,6 +4222,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4207
4222
  */
4208
4223
  VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4209
4224
  {
4225
+
4210
4226
  VALUE r_qualifier = Qnil;
4211
4227
  VALUE r_owner = Qnil;
4212
4228
  VALUE r_table_name = Qnil;
@@ -4288,10 +4304,10 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4288
4304
 
4289
4305
  col_metadata_args->stmt_res = stmt_res;
4290
4306
 
4291
- #ifdef UNICODE_SUPPORT_VERSION
4292
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLForeignKeys_helper, col_metadata_args,
4293
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLForeignKeys_helper, col_metadata_args,
4307
+ #ifdef UNICODE_SUPPORT_VERSION
4308
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLForeignKeys_helper, col_metadata_args,
4294
4309
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4310
+ rc = col_metadata_args->rc;
4295
4311
  #else
4296
4312
  rc = _ruby_ibm_db_SQLForeignKeys_helper( col_metadata_args );
4297
4313
  #endif
@@ -4300,7 +4316,6 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4300
4316
 
4301
4317
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
4302
4318
  NULL, NULL, -1, 1, 1 );
4303
-
4304
4319
  _ruby_ibm_db_free_stmt_struct( stmt_res );
4305
4320
  stmt_res = NULL;
4306
4321
 
@@ -4445,10 +4460,10 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4445
4460
  }
4446
4461
  col_metadata_args->stmt_res = stmt_res;
4447
4462
 
4448
- #ifdef UNICODE_SUPPORT_VERSION
4449
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLPrimaryKeys_helper, col_metadata_args,
4450
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrimaryKeys_helper, col_metadata_args,
4463
+ #ifdef UNICODE_SUPPORT_VERSION
4464
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrimaryKeys_helper, col_metadata_args,
4451
4465
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4466
+ rc = col_metadata_args->rc;
4452
4467
  #else
4453
4468
  rc = _ruby_ibm_db_SQLPrimaryKeys_helper( col_metadata_args );
4454
4469
  #endif
@@ -4457,7 +4472,6 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4457
4472
 
4458
4473
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
4459
4474
  NULL, NULL, -1, 1, 1 );
4460
-
4461
4475
  _ruby_ibm_db_free_stmt_struct( stmt_res );
4462
4476
  stmt_res = NULL;
4463
4477
 
@@ -4582,7 +4596,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4582
4596
  if (!NIL_P(connection)) {
4583
4597
  Data_Get_Struct(connection, conn_handle, conn_res);
4584
4598
 
4585
- if (!conn_res->handle_active) {
4599
+ if (!conn_res || !conn_res->handle_active) {
4586
4600
  rb_warn("Connection is not active");
4587
4601
  return_value = Qfalse;
4588
4602
  } else {
@@ -4637,10 +4651,10 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4637
4651
  }
4638
4652
  col_metadata_args->stmt_res = stmt_res;
4639
4653
 
4640
- #ifdef UNICODE_SUPPORT_VERSION
4641
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLProcedureColumns_helper, col_metadata_args,
4642
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedureColumns_helper, col_metadata_args,
4654
+ #ifdef UNICODE_SUPPORT_VERSION
4655
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedureColumns_helper, col_metadata_args,
4643
4656
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
4657
+ rc = col_metadata_args->rc;
4644
4658
  #else
4645
4659
  rc = _ruby_ibm_db_SQLProcedureColumns_helper( col_metadata_args );
4646
4660
  #endif
@@ -4649,7 +4663,6 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4649
4663
 
4650
4664
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
4651
4665
  NULL, NULL, -1, 1, 1 );
4652
-
4653
4666
  _ruby_ibm_db_free_stmt_struct( stmt_res );
4654
4667
  stmt_res = NULL;
4655
4668
 
@@ -4750,7 +4763,7 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4750
4763
  if (!NIL_P(connection)) {
4751
4764
  Data_Get_Struct(connection, conn_handle, conn_res);
4752
4765
 
4753
- if (!conn_res->handle_active) {
4766
+ if (!conn_res || !conn_res->handle_active) {
4754
4767
  rb_warn("Connection is not active");
4755
4768
  return_value = Qfalse;
4756
4769
  } else {
@@ -4795,10 +4808,10 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4795
4808
  }
4796
4809
  proc_metadata_args->stmt_res = stmt_res;
4797
4810
 
4798
- #ifdef UNICODE_SUPPORT_VERSION
4799
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLProcedures_helper, proc_metadata_args,
4800
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedures_helper, proc_metadata_args,
4811
+ #ifdef UNICODE_SUPPORT_VERSION
4812
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedures_helper, proc_metadata_args,
4801
4813
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
4814
+ rc = proc_metadata_args->rc;
4802
4815
  #else
4803
4816
  rc = _ruby_ibm_db_SQLProcedures_helper( proc_metadata_args );
4804
4817
  #endif
@@ -4807,7 +4820,6 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4807
4820
 
4808
4821
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
4809
4822
  NULL, NULL, -1, 1, 1 );
4810
-
4811
4823
  _ruby_ibm_db_free_stmt_struct( stmt_res );
4812
4824
  stmt_res = NULL;
4813
4825
 
@@ -4925,7 +4937,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4925
4937
  if (!NIL_P(connection)) {
4926
4938
  Data_Get_Struct(connection, conn_handle, conn_res);
4927
4939
 
4928
- if (!conn_res->handle_active) {
4940
+ if (!conn_res || !conn_res->handle_active) {
4929
4941
  rb_warn("Connection is not active");
4930
4942
  return_value = Qfalse;
4931
4943
  } else {
@@ -4973,10 +4985,10 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4973
4985
  }
4974
4986
  col_metadata_args->stmt_res = stmt_res;
4975
4987
 
4976
- #ifdef UNICODE_SUPPORT_VERSION
4977
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLSpecialColumns_helper, col_metadata_args,
4978
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLSpecialColumns_helper, col_metadata_args,
4988
+ #ifdef UNICODE_SUPPORT_VERSION
4989
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLSpecialColumns_helper, col_metadata_args,
4979
4990
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
4991
+ rc = col_metadata_args->rc;
4980
4992
  #else
4981
4993
  rc = _ruby_ibm_db_SQLSpecialColumns_helper( col_metadata_args );
4982
4994
  #endif
@@ -4985,7 +4997,6 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4985
4997
 
4986
4998
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
4987
4999
  NULL, NULL, -1, 1, 1 );
4988
-
4989
5000
  _ruby_ibm_db_free_stmt_struct( stmt_res );
4990
5001
  stmt_res = NULL;
4991
5002
 
@@ -5085,6 +5096,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
5085
5096
  */
5086
5097
  VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5087
5098
  {
5099
+
5088
5100
  VALUE r_qualifier = Qnil;
5089
5101
  VALUE r_owner = Qnil;
5090
5102
  VALUE r_table_name = Qnil;
@@ -5121,7 +5133,7 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5121
5133
  if (!NIL_P(connection)) {
5122
5134
  Data_Get_Struct(connection, conn_handle, conn_res);
5123
5135
 
5124
- if (!conn_res->handle_active) {
5136
+ if (!conn_res || !conn_res->handle_active) {
5125
5137
  rb_warn("Connection is not active");
5126
5138
  return_value = Qfalse;
5127
5139
  } else {
@@ -5169,10 +5181,10 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5169
5181
  }
5170
5182
  col_metadata_args->stmt_res = stmt_res;
5171
5183
 
5172
- #ifdef UNICODE_SUPPORT_VERSION
5173
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLStatistics_helper, col_metadata_args,
5174
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLStatistics_helper, col_metadata_args,
5184
+ #ifdef UNICODE_SUPPORT_VERSION
5185
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLStatistics_helper, col_metadata_args,
5175
5186
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5187
+ rc = col_metadata_args->rc;
5176
5188
  #else
5177
5189
  rc = _ruby_ibm_db_SQLStatistics_helper( col_metadata_args );
5178
5190
  #endif
@@ -5181,7 +5193,6 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5181
5193
 
5182
5194
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
5183
5195
  NULL, NULL, -1, 1, 1 );
5184
-
5185
5196
  _ruby_ibm_db_free_stmt_struct( stmt_res );
5186
5197
  stmt_res = NULL;
5187
5198
 
@@ -5329,10 +5340,10 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5329
5340
 
5330
5341
  table_privileges_args->stmt_res = stmt_res;
5331
5342
 
5332
- #ifdef UNICODE_SUPPORT_VERSION
5333
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLTablePrivileges_helper, table_privileges_args,
5334
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTablePrivileges_helper, table_privileges_args,
5343
+ #ifdef UNICODE_SUPPORT_VERSION
5344
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTablePrivileges_helper, table_privileges_args,
5335
5345
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5346
+ rc = table_privileges_args->rc;
5336
5347
  #else
5337
5348
  rc = _ruby_ibm_db_SQLTablePrivileges_helper( table_privileges_args );
5338
5349
  #endif
@@ -5341,7 +5352,6 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5341
5352
 
5342
5353
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
5343
5354
  NULL, NULL, -1, 1, 1 );
5344
-
5345
5355
  _ruby_ibm_db_free_stmt_struct( stmt_res );
5346
5356
  stmt_res = NULL;
5347
5357
 
@@ -5447,7 +5457,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5447
5457
  if (!NIL_P(connection)) {
5448
5458
  Data_Get_Struct(connection, conn_handle, conn_res);
5449
5459
 
5450
- if (!conn_res->handle_active) {
5460
+ if (!conn_res || !conn_res->handle_active) {
5451
5461
  rb_warn("Connection is not active");
5452
5462
  return_value = Qfalse;
5453
5463
  } else {
@@ -5504,10 +5514,10 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5504
5514
 
5505
5515
  table_metadata_args->stmt_res = stmt_res;
5506
5516
 
5507
- #ifdef UNICODE_SUPPORT_VERSION
5508
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLTables_helper, table_metadata_args,
5509
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTables_helper, table_metadata_args,
5517
+ #ifdef UNICODE_SUPPORT_VERSION
5518
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTables_helper, table_metadata_args,
5510
5519
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5520
+ rc = table_metadata_args->rc;
5511
5521
  #else
5512
5522
  rc = _ruby_ibm_db_SQLTables_helper( table_metadata_args );
5513
5523
  #endif
@@ -5516,7 +5526,6 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5516
5526
 
5517
5527
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1,
5518
5528
  NULL, NULL, -1, 1, 1 );
5519
-
5520
5529
  _ruby_ibm_db_free_stmt_struct( stmt_res );
5521
5530
  stmt_res = NULL;
5522
5531
 
@@ -5575,7 +5584,7 @@ VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self)
5575
5584
  if (!NIL_P(connection)) {
5576
5585
  Data_Get_Struct(connection, conn_handle, conn_res);
5577
5586
 
5578
- if (!conn_res->handle_active) {
5587
+ if (!conn_res || !conn_res->handle_active) {
5579
5588
  rb_warn("Connection is not active");
5580
5589
  return Qfalse;
5581
5590
  }
@@ -5587,10 +5596,10 @@ VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self)
5587
5596
  end_X_args->handleType = SQL_HANDLE_DBC;
5588
5597
  end_X_args->completionType = SQL_COMMIT; /*Remeber you are Commiting the transaction*/
5589
5598
 
5590
- #ifdef UNICODE_SUPPORT_VERSION
5591
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
5592
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
5599
+ #ifdef UNICODE_SUPPORT_VERSION
5600
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
5593
5601
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
5602
+ rc = end_X_args->rc;
5594
5603
  #else
5595
5604
  rc = _ruby_ibm_db_SQLEndTran( end_X_args );
5596
5605
  #endif
@@ -5609,7 +5618,6 @@ VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self)
5609
5618
  return Qtrue;
5610
5619
  }
5611
5620
  }
5612
-
5613
5621
  return Qfalse;
5614
5622
  }
5615
5623
  /* */
@@ -5668,10 +5676,10 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
5668
5676
  prepare_args->stmt_res = stmt_res;
5669
5677
 
5670
5678
  /* Prepare the stmt. The cursor type requested has already been set in _ruby_ibm_db_assign_options */
5671
- #ifdef UNICODE_SUPPORT_VERSION
5672
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLPrepare_helper, prepare_args,
5673
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrepare_helper, prepare_args,
5679
+ #ifdef UNICODE_SUPPORT_VERSION
5680
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrepare_helper, prepare_args,
5674
5681
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5682
+ rc = prepare_args->rc;
5675
5683
  #else
5676
5684
  rc = _ruby_ibm_db_SQLPrepare_helper( prepare_args );
5677
5685
  #endif
@@ -5751,15 +5759,17 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5751
5759
  /* This function basically is a wrap of the _ruby_ibm_db_do_prepare and _ruby_ibm_db_execute_stmt */
5752
5760
  /* After completing statement execution, it returns the statement resource */
5753
5761
  rb_scan_args(argc, argv, "21", &connection, &stmt, &options);
5762
+
5754
5763
 
5755
5764
  if (!NIL_P(connection)) {
5756
5765
  Data_Get_Struct(connection, conn_handle, conn_res);
5757
-
5758
- if (!conn_res->handle_active) {
5766
+
5767
+ if (!conn_res || !conn_res->handle_active) {
5759
5768
  rb_warn("Connection is not active");
5760
5769
  return Qfalse;
5761
5770
  }
5762
-
5771
+
5772
+
5763
5773
  if (!NIL_P(stmt)) {
5764
5774
  exec_direct_args = ALLOC( exec_cum_prepare_args );
5765
5775
  memset(exec_direct_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
@@ -5776,11 +5786,11 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5776
5786
  rb_warn("Supplied parameter is invalid");
5777
5787
  return Qfalse;
5778
5788
  }
5779
-
5789
+
5780
5790
  _ruby_ibm_db_clear_stmt_err_cache();
5781
5791
 
5782
5792
  stmt_res = _ibm_db_new_stmt_struct(conn_res);
5783
-
5793
+
5784
5794
  /* Allocates the stmt handle */
5785
5795
  /* returns the stat_handle back to the calling function */
5786
5796
  rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
@@ -5807,19 +5817,19 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5807
5817
 
5808
5818
  exec_direct_args->stmt_res = stmt_res;
5809
5819
 
5810
- #ifdef UNICODE_SUPPORT_VERSION
5811
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLExecDirect_helper, exec_direct_args,
5812
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLExecDirect_helper, exec_direct_args,
5820
+
5821
+ #ifdef UNICODE_SUPPORT_VERSION
5822
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLExecDirect_helper, exec_direct_args,
5813
5823
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5824
+ rc = exec_direct_args->rc;
5814
5825
  #else
5815
5826
  rc = _ruby_ibm_db_SQLExecDirect_helper( exec_direct_args );
5816
5827
  #endif
5817
-
5828
+
5818
5829
  if ( rc == SQL_ERROR ) {
5819
5830
 
5820
5831
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt,
5821
5832
  SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 1 );
5822
-
5823
5833
  _ruby_ibm_db_free_stmt_struct( stmt_res );
5824
5834
  stmt_res = NULL;
5825
5835
 
@@ -5836,7 +5846,6 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5836
5846
  ruby_xfree( exec_direct_args );
5837
5847
  exec_direct_args = NULL;
5838
5848
  }
5839
-
5840
5849
  return return_value;
5841
5850
  }
5842
5851
  /* */
@@ -5883,10 +5892,10 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
5883
5892
  freeStmt_args->stmt_res = stmt_res;
5884
5893
  freeStmt_args->option = SQL_CLOSE;
5885
5894
 
5886
- #ifdef UNICODE_SUPPORT_VERSION
5887
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLFreeStmt_helper, freeStmt_args,
5888
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLFreeStmt_helper, freeStmt_args,
5895
+ #ifdef UNICODE_SUPPORT_VERSION
5896
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLFreeStmt_helper, freeStmt_args,
5889
5897
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5898
+ rc = freeStmt_args->rc;
5890
5899
  #else
5891
5900
  rc = _ruby_ibm_db_SQLFreeStmt_helper( freeStmt_args );
5892
5901
  #endif
@@ -5985,7 +5994,7 @@ VALUE ibm_db_prepare(int argc, VALUE *argv, VALUE self)
5985
5994
  if (!NIL_P(connection)) {
5986
5995
  Data_Get_Struct(connection, conn_handle, conn_res);
5987
5996
 
5988
- if (!conn_res->handle_active) {
5997
+ if (!conn_res || !conn_res->handle_active) {
5989
5998
  rb_warn("Connection is not active");
5990
5999
  return Qfalse;
5991
6000
  }
@@ -6487,6 +6496,7 @@ static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, VALUE *error ) {
6487
6496
  static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int bind_cmp_list,
6488
6497
  int bind_params, VALUE *error )
6489
6498
  {
6499
+
6490
6500
  int rc = SQL_SUCCESS;
6491
6501
  param_node *curr = NULL; /* To traverse the list */
6492
6502
 
@@ -6649,6 +6659,7 @@ void var_assign(char *name, VALUE value) {
6649
6659
  ruby_xfree( statement );
6650
6660
  statement = NULL;
6651
6661
  #endif
6662
+
6652
6663
  }
6653
6664
 
6654
6665
  /*
@@ -6756,6 +6767,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6756
6767
  *error = rb_str_new2("Execute Failed due to: <error message could not be retrieved>");
6757
6768
  #endif
6758
6769
  }
6770
+ bind_array->return_value = Qnil;
6759
6771
  return Qnil;
6760
6772
  }
6761
6773
 
@@ -6778,15 +6790,18 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6778
6790
  #else
6779
6791
  *error = rb_str_new2("Param is not an array");
6780
6792
  #endif
6793
+ bind_array->return_value = Qnil;
6781
6794
  return Qnil;
6782
6795
  }
6783
6796
 
6784
6797
  ret_value = _ruby_ibm_db_desc_and_bind_param_list(bind_array, error );
6785
6798
 
6786
6799
  if(ret_value == Qnil ) {
6800
+ bind_array->return_value = Qnil;
6787
6801
  return Qnil;
6788
6802
  }
6789
6803
  if(ret_value == Qfalse) {
6804
+ bind_array->return_value = Qfalse;
6790
6805
  return Qfalse;
6791
6806
  }
6792
6807
 
@@ -6800,6 +6815,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6800
6815
  #else
6801
6816
  *error = rb_str_new2("Number of params passed are more than bound parameters");
6802
6817
  #endif
6818
+ bind_array->return_value = Qnil;
6803
6819
  return Qnil;
6804
6820
  } else if ( num < stmt_res->num_params ) {
6805
6821
  /* Fewer parameters than we expected */
@@ -6808,6 +6824,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6808
6824
  #else
6809
6825
  *error = rb_str_new2("Number of params passed are less than bound parameters");
6810
6826
  #endif
6827
+ bind_array->return_value = Qnil;
6811
6828
  return Qnil;
6812
6829
  }
6813
6830
 
@@ -6818,6 +6835,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6818
6835
  #else
6819
6836
  *error = rb_str_new2("Parameters not bound");
6820
6837
  #endif
6838
+ bind_array->return_value = Qnil;
6821
6839
  return Qnil;
6822
6840
  } else {
6823
6841
  /* The 1 denotes that you work with the whole list */
@@ -6826,6 +6844,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6826
6844
  rc = _ruby_ibm_db_execute_helper2(stmt_res, NULL, 1, 0, error );
6827
6845
 
6828
6846
  if ( rc == SQL_ERROR ) {
6847
+ bind_array->return_value = Qnil;
6829
6848
  return Qnil;
6830
6849
  }
6831
6850
  }
@@ -6853,6 +6872,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6853
6872
  *error = rb_str_new2("Statement Execute Failed: <error message could not be retrieved>");
6854
6873
  #endif
6855
6874
  }
6875
+ bind_array->return_value = Qnil;
6856
6876
  return Qnil;
6857
6877
  }
6858
6878
 
@@ -6892,7 +6912,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6892
6912
  ruby_xfree( put_param_data_args );
6893
6913
  put_param_data_args = NULL;
6894
6914
  }
6895
-
6915
+ bind_array->return_value = Qnil;
6896
6916
  return Qnil;
6897
6917
  }
6898
6918
  rc = _ruby_ibm_db_SQLParamData_helper( put_param_data_args );
@@ -6921,11 +6941,12 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6921
6941
  *error = rb_str_new2("Sending data failed: <error message could not be retrieved>");
6922
6942
  #endif
6923
6943
  }
6924
-
6944
+ bind_array->return_value = Qnil;
6925
6945
  return Qnil;
6926
6946
  }
6927
6947
  }
6928
6948
 
6949
+ bind_array->return_value = Qtrue;
6929
6950
  return Qtrue;
6930
6951
  }
6931
6952
  /*
@@ -6989,10 +7010,10 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
6989
7010
  bind_array->num = 0;
6990
7011
  bind_array->error = &error;
6991
7012
 
6992
- #ifdef UNICODE_SUPPORT_VERSION
6993
- //ret_value = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_execute_helper, bind_array,
6994
- ret_value = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_execute_helper, bind_array,
7013
+ #ifdef UNICODE_SUPPORT_VERSION
7014
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_execute_helper, bind_array,
6995
7015
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7016
+ ret_value = bind_array->return_value;
6996
7017
  #else
6997
7018
  ret_value = _ruby_ibm_db_execute_helper( bind_array );
6998
7019
  #endif
@@ -7155,7 +7176,7 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
7155
7176
  if (!NIL_P(connection)) {
7156
7177
  Data_Get_Struct(connection, conn_handle, conn_res);
7157
7178
 
7158
- if (!conn_res->handle_active) {
7179
+ if (!conn_res || !conn_res->handle_active) {
7159
7180
  rb_warn("Connection is not active");
7160
7181
  return Qnil;
7161
7182
  }
@@ -7309,7 +7330,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
7309
7330
  if (!NIL_P(connection)) {
7310
7331
  Data_Get_Struct(connection, conn_handle, conn_res);
7311
7332
 
7312
- if (!conn_res->handle_active) {
7333
+ if (!conn_res || !conn_res->handle_active) {
7313
7334
  rb_warn("Connection is not active");
7314
7335
  return Qnil;
7315
7336
  }
@@ -7475,7 +7496,7 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
7475
7496
  if( resType == DB_CONN ) { /*Resource Type is connection*/
7476
7497
  Data_Get_Struct(conn_or_stmt, conn_handle, conn_res);
7477
7498
 
7478
- if ( !conn_res->handle_active ) {
7499
+ if (!conn_res || !conn_res->handle_active ) {
7479
7500
  rb_warn("Connection is not active");
7480
7501
  return Qnil;
7481
7502
  }
@@ -7775,10 +7796,10 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
7775
7796
  nextresultparams->stmt_res = stmt_res;
7776
7797
  nextresultparams->new_hstmt = &new_hstmt;
7777
7798
 
7778
- #ifdef UNICODE_SUPPORT_VERSION
7779
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLNextResult_helper, nextresultparams,
7780
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNextResult_helper, nextresultparams,
7799
+ #ifdef UNICODE_SUPPORT_VERSION
7800
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNextResult_helper, nextresultparams,
7781
7801
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7802
+ rc = nextresultparams->rc;
7782
7803
  #else
7783
7804
  rc = _ruby_ibm_db_SQLNextResult_helper( nextresultparams );
7784
7805
  #endif
@@ -7811,7 +7832,7 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
7811
7832
  new_stmt_res->hstmt = new_hstmt;
7812
7833
  new_stmt_res->hdbc = stmt_res->hdbc;
7813
7834
  new_stmt_res->is_freed = 0;
7814
-
7835
+
7815
7836
  ret_value = Data_Wrap_Struct(le_stmt_struct,
7816
7837
  _ruby_ibm_db_mark_stmt_struct, _ruby_ibm_db_free_stmt_struct,
7817
7838
  new_stmt_res);
@@ -7827,6 +7848,7 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
7827
7848
  ruby_xfree( nextresultparams );
7828
7849
  nextresultparams = NULL;
7829
7850
  }
7851
+
7830
7852
  return ret_value;
7831
7853
  }
7832
7854
  /* */
@@ -7875,10 +7897,10 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
7875
7897
  result_cols_args->stmt_res = stmt_res;
7876
7898
  result_cols_args->count = 0;
7877
7899
 
7878
- #ifdef UNICODE_SUPPORT_VERSION
7879
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLNumResultCols_helper, result_cols_args,
7880
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNumResultCols_helper, result_cols_args,
7900
+ #ifdef UNICODE_SUPPORT_VERSION
7901
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNumResultCols_helper, result_cols_args,
7881
7902
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7903
+ rc = result_cols_args->rc;
7882
7904
  #else
7883
7905
  rc = _ruby_ibm_db_SQLNumResultCols_helper( result_cols_args );
7884
7906
  #endif
@@ -7907,7 +7929,6 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
7907
7929
  ruby_xfree( result_cols_args );
7908
7930
  result_cols_args = NULL;
7909
7931
  }
7910
-
7911
7932
  return ret_val;
7912
7933
  }
7913
7934
  /* */
@@ -7969,10 +7990,10 @@ VALUE ibm_db_num_rows(int argc, VALUE *argv, VALUE self)
7969
7990
  row_count_args->stmt_res = stmt_res;
7970
7991
  row_count_args->count = 0;
7971
7992
 
7972
- #ifdef UNICODE_SUPPORT_VERSION
7973
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLRowCount_helper, row_count_args,
7974
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLRowCount_helper, row_count_args,
7993
+ #ifdef UNICODE_SUPPORT_VERSION
7994
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLRowCount_helper, row_count_args,
7975
7995
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7996
+ rc = row_count_args->rc;
7976
7997
  #else
7977
7998
  rc = _ruby_ibm_db_SQLRowCount_helper( row_count_args );
7978
7999
  #endif
@@ -8026,10 +8047,10 @@ static int _ruby_ibm_db_get_column_by_name(stmt_handle *stmt_res, VALUE column,
8026
8047
  if ( stmt_res->column_info == NULL ) {
8027
8048
  if ( release_gil == 1 ) {
8028
8049
 
8029
- #ifdef UNICODE_SUPPORT_VERSION
8030
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_get_result_set_info, stmt_res,
8031
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_get_result_set_info, stmt_res,
8050
+ #ifdef UNICODE_SUPPORT_VERSION
8051
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_get_result_set_info, stmt_res,
8032
8052
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8053
+ rc = stmt_res->rc;
8033
8054
  #else
8034
8055
  rc = _ruby_ibm_db_get_result_set_info( stmt_res );
8035
8056
  #endif
@@ -8190,10 +8211,10 @@ VALUE ibm_db_field_display_size(int argc, VALUE *argv, VALUE self)
8190
8211
  colattr_args->col_num = col+1;
8191
8212
  colattr_args->FieldIdentifier = SQL_DESC_DISPLAY_SIZE;
8192
8213
 
8193
- #ifdef UNICODE_SUPPORT_VERSION
8194
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8195
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8214
+ #ifdef UNICODE_SUPPORT_VERSION
8215
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8196
8216
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8217
+ rc = colattr_args->rc;
8197
8218
  #else
8198
8219
  rc = _ruby_ibm_db_SQLColAttributes_helper( colattr_args );
8199
8220
  #endif
@@ -8511,10 +8532,10 @@ VALUE ibm_db_field_width(int argc, VALUE *argv, VALUE self)
8511
8532
  colattr_args->col_num = col+1;
8512
8533
  colattr_args->FieldIdentifier = SQL_DESC_LENGTH;
8513
8534
 
8514
- #ifdef UNICODE_SUPPORT_VERSION
8515
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8516
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8535
+ #ifdef UNICODE_SUPPORT_VERSION
8536
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8517
8537
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8538
+ rc = colattr_args->rc;
8518
8539
  #else
8519
8540
  rc = _ruby_ibm_db_SQLColAttributes_helper( colattr_args );
8520
8541
  #endif
@@ -8532,7 +8553,6 @@ VALUE ibm_db_field_width(int argc, VALUE *argv, VALUE self)
8532
8553
  ruby_xfree( colattr_args );
8533
8554
  colattr_args = NULL;
8534
8555
  }
8535
-
8536
8556
  return ret_val;
8537
8557
  }
8538
8558
  /* */
@@ -8602,36 +8622,30 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
8602
8622
  end_tran_args *end_X_args = NULL;
8603
8623
 
8604
8624
  rb_scan_args(argc, argv, "1", &connection);
8605
-
8606
8625
  if (!NIL_P(connection)) {
8607
8626
  Data_Get_Struct(connection, conn_handle, conn_res);
8608
-
8609
- if (!conn_res->handle_active) {
8627
+ if (!conn_res || !conn_res->handle_active) {
8610
8628
  rb_warn("Connection is not active");
8611
8629
  return Qfalse;
8612
8630
  }
8613
-
8614
8631
  end_X_args = ALLOC( end_tran_args );
8615
8632
  memset(end_X_args,'\0',sizeof(struct _ibm_db_end_tran_args_struct));
8616
8633
 
8617
8634
  end_X_args->hdbc = &(conn_res->hdbc);
8618
8635
  end_X_args->handleType = SQL_HANDLE_DBC;
8619
8636
  end_X_args->completionType = SQL_ROLLBACK; /*Remeber you are Rollingback the transaction*/
8620
-
8621
8637
  #ifdef UNICODE_SUPPORT_VERSION
8622
- //rc = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
8623
- rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
8638
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
8624
8639
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
8640
+ rc = end_X_args->rc;
8625
8641
  #else
8626
8642
  rc = _ruby_ibm_db_SQLEndTran( end_X_args );
8627
8643
  #endif
8628
-
8629
8644
  /*Free the memory allocated*/
8630
8645
  if(end_X_args != NULL) {
8631
8646
  ruby_xfree( end_X_args );
8632
8647
  end_X_args = NULL;
8633
8648
  }
8634
-
8635
8649
  if ( rc == SQL_ERROR ) {
8636
8650
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
8637
8651
  return Qfalse;
@@ -8640,7 +8654,6 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
8640
8654
  return Qtrue;
8641
8655
  }
8642
8656
  }
8643
-
8644
8657
  return Qfalse;
8645
8658
  }
8646
8659
  /* */
@@ -8710,7 +8723,6 @@ static RETCODE _ruby_ibm_db_get_data(stmt_handle *stmt_res, int col_num, short c
8710
8723
  ruby_xfree( getData_args );
8711
8724
  getData_args = NULL;
8712
8725
  }
8713
-
8714
8726
  return rc;
8715
8727
  }
8716
8728
  /* */
@@ -8842,6 +8854,8 @@ int isNullLOB(VALUE *return_value,int i,stmt_handle *stmt_res,int op)
8842
8854
  In all other cases the value returned will be either Qfalse (meaning SQL_NO_DATA), VALUE or Qnil (meaning the value is nil)
8843
8855
  */
8844
8856
  static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8857
+
8858
+
8845
8859
  long col_num;
8846
8860
  RETCODE rc;
8847
8861
  SQLPOINTER out_ptr;
@@ -8854,6 +8868,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8854
8868
  VALUE return_value = Qnil;
8855
8869
  stmt_handle *stmt_res = data->stmt_res;
8856
8870
  VALUE column = data->column;
8871
+ VALUE ret_value;
8857
8872
 
8858
8873
  if(TYPE(column) == T_STRING) {
8859
8874
  col_num = _ruby_ibm_db_get_column_by_name(stmt_res, column, 0);
@@ -8880,6 +8895,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8880
8895
  *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
8881
8896
  #endif
8882
8897
  }
8898
+ data->return_value = Qnil;
8883
8899
  return Qnil;
8884
8900
  }
8885
8901
  }
@@ -8890,6 +8906,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8890
8906
  #else
8891
8907
  *(data->error) = rb_str_new2("Column ordinal out of range" );
8892
8908
  #endif
8909
+ data->return_value = Qnil;
8893
8910
  return Qnil;
8894
8911
  }
8895
8912
 
@@ -8933,6 +8950,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8933
8950
 
8934
8951
  if ( out_ptr == NULL ) {
8935
8952
  rb_warn( "Failed to Allocate Memory while trying to retrieve the result" );
8953
+ data->return_value = Qnil;
8936
8954
  return Qnil;
8937
8955
  }
8938
8956
 
@@ -8943,10 +8961,12 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8943
8961
  #endif
8944
8962
 
8945
8963
  if ( rc == SQL_ERROR ) {
8964
+ data->return_value = Qfalse;
8946
8965
  return Qfalse;
8947
8966
  }
8948
8967
  if (out_length == SQL_NULL_DATA) {
8949
8968
  ruby_xfree( out_ptr );
8969
+ data->return_value = Qnil;
8950
8970
  return Qnil;
8951
8971
  } else {
8952
8972
  #ifdef UNICODE_SUPPORT_VERSION
@@ -8956,6 +8976,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8956
8976
  #endif
8957
8977
  ruby_xfree( out_ptr );
8958
8978
  out_ptr = NULL;
8979
+ data->return_value = return_value;
8959
8980
  return return_value;
8960
8981
  }
8961
8982
  break;
@@ -8978,22 +8999,26 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8978
8999
 
8979
9000
  if ( out_ptr == NULL ) {
8980
9001
  rb_warn( "Failed to Allocate Memory while trying to retrieve the result" );
9002
+ data->return_value = Qnil;
8981
9003
  return Qnil;
8982
9004
  }
8983
9005
 
8984
9006
  rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_CHAR, out_ptr, in_length, &out_length);
8985
9007
 
8986
9008
  if ( rc == SQL_ERROR ) {
9009
+ data->return_value = Qfalse;
8987
9010
  return Qfalse;
8988
9011
  }
8989
9012
 
8990
9013
  if (out_length == SQL_NULL_DATA) {
8991
9014
  ruby_xfree( out_ptr );
9015
+ data->return_value = Qnil;
8992
9016
  return Qnil;
8993
9017
  } else {
8994
9018
  return_value = rb_str_new2((char*)out_ptr);
8995
9019
  ruby_xfree( out_ptr );
8996
9020
  out_ptr = NULL;
9021
+ data->return_value = return_value;
8997
9022
  return return_value;
8998
9023
  }
8999
9024
  break;
@@ -9001,12 +9026,16 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9001
9026
  case SQL_INTEGER:
9002
9027
  rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_LONG, &long_val, sizeof(long_val), &out_length);
9003
9028
  if ( rc == SQL_ERROR ) {
9029
+ data->return_value = Qfalse;
9004
9030
  return Qfalse;
9005
9031
  }
9006
9032
  if (out_length == SQL_NULL_DATA) {
9033
+ data->return_value = Qnil;
9007
9034
  return Qnil;
9008
9035
  } else {
9009
- return INT2NUM(long_val);
9036
+ VALUE ret_value = INT2NUM(long_val);
9037
+ data->return_value = ret_value;
9038
+ return ret_value;
9010
9039
  }
9011
9040
  break;
9012
9041
 
@@ -9015,12 +9044,16 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9015
9044
  case SQL_DOUBLE:
9016
9045
  rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_DOUBLE, &double_val, sizeof(double_val), &out_length);
9017
9046
  if ( rc == SQL_ERROR ) {
9047
+ data->return_value = Qfalse;
9018
9048
  return Qfalse;
9019
9049
  }
9020
9050
  if (out_length == SQL_NULL_DATA) {
9051
+ data->return_value = Qnil;
9021
9052
  return Qnil;
9022
9053
  } else {
9023
- return rb_float_new(double_val);
9054
+ VALUE ret_value = rb_float_new(double_val);
9055
+ data->return_value = ret_value;
9056
+ return ret_value;
9024
9057
  }
9025
9058
  break;
9026
9059
 
@@ -9029,10 +9062,12 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9029
9062
  rc = _ruby_ibm_db_get_length(stmt_res, col_num+1, &in_length);
9030
9063
 
9031
9064
  if ( rc == SQL_ERROR ) {
9065
+ data->return_value = Qfalse;
9032
9066
  return Qfalse;
9033
9067
  }
9034
9068
 
9035
9069
  if (in_length == SQL_NULL_DATA) {
9070
+ data->return_value = Qnil;
9036
9071
  return Qnil;
9037
9072
  }
9038
9073
 
@@ -9046,6 +9081,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9046
9081
 
9047
9082
  if ( out_ptr == NULL ) {
9048
9083
  rb_warn( "Failed to Allocate Memory for LOB Data" );
9084
+ data->return_value = Qnil;
9049
9085
  return Qnil;
9050
9086
  }
9051
9087
 
@@ -9056,6 +9092,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9056
9092
  #endif
9057
9093
 
9058
9094
  if (rc == SQL_ERROR) {
9095
+ data->return_value = Qfalse;
9059
9096
  return Qfalse;
9060
9097
  }
9061
9098
 
@@ -9067,7 +9104,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9067
9104
 
9068
9105
  ruby_xfree( out_ptr );
9069
9106
  out_ptr = NULL;
9070
-
9107
+ data->return_value = return_value;
9071
9108
  return return_value;
9072
9109
  break;
9073
9110
 
@@ -9081,16 +9118,20 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9081
9118
  rc = _ruby_ibm_db_get_length( stmt_res, col_num+1, &in_length );
9082
9119
 
9083
9120
  if ( rc == SQL_ERROR ) {
9121
+ data->return_value = Qfalse;
9084
9122
  return Qfalse;
9085
9123
  }
9086
9124
 
9087
9125
  if (in_length == SQL_NULL_DATA) {
9126
+ data->return_value = Qnil;
9088
9127
  return Qnil;
9089
9128
  }
9090
9129
 
9091
9130
  switch (stmt_res->s_bin_mode) {
9092
- case PASSTHRU:
9093
- return rb_str_new("",0);
9131
+ case PASSTHRU:
9132
+ ret_value = rb_str_new("",0);
9133
+ data->return_value = ret_value;
9134
+ return ret_value;
9094
9135
  break;
9095
9136
  /* returns here */
9096
9137
  case CONVERT:
@@ -9104,18 +9145,20 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9104
9145
 
9105
9146
  if ( out_ptr == NULL ) {
9106
9147
  rb_warn( "Failed to Allocate Memory for LOB Data" );
9148
+ data->return_value = Qnil;
9107
9149
  return Qnil;
9108
9150
  }
9109
9151
 
9110
9152
  rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, lob_bind_type, out_ptr, in_length, in_length, &out_length);
9111
9153
 
9112
9154
  if (rc == SQL_ERROR) {
9155
+ data->return_value = Qfalse;
9113
9156
  return Qfalse;
9114
9157
  }
9115
9158
  return_value = rb_str_new((char*)out_ptr,out_length);
9116
9159
  ruby_xfree( out_ptr );
9117
9160
  out_ptr = NULL;
9118
-
9161
+ data->return_value = return_value;
9119
9162
  return return_value;
9120
9163
  default:
9121
9164
  break;
@@ -9126,10 +9169,12 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9126
9169
  rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_BINARY, NULL, 0, (SQLINTEGER *)&in_length);
9127
9170
 
9128
9171
  if ( rc == SQL_ERROR ) {
9172
+ data->return_value = Qfalse;
9129
9173
  return Qfalse;
9130
9174
  }
9131
9175
 
9132
9176
  if (in_length == SQL_NULL_DATA) {
9177
+ data->return_value = Qnil;
9133
9178
  return Qnil;
9134
9179
  }
9135
9180
 
@@ -9138,6 +9183,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9138
9183
 
9139
9184
  if ( out_ptr == NULL ) {
9140
9185
  rb_warn( "Failed to Allocate Memory for LOB Data" );
9186
+ data->return_value = Qnil;
9141
9187
  return Qnil;
9142
9188
  }
9143
9189
 
@@ -9146,6 +9192,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9146
9192
  if (rc == SQL_ERROR) {
9147
9193
  ruby_xfree( out_ptr );
9148
9194
  out_ptr = NULL;
9195
+ data->return_value = Qfalse;
9149
9196
  return Qfalse;
9150
9197
  }
9151
9198
 
@@ -9157,13 +9204,14 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9157
9204
 
9158
9205
  ruby_xfree( out_ptr );
9159
9206
  out_ptr = NULL;
9160
-
9207
+ data->return_value = return_value;
9161
9208
  return return_value;
9162
9209
 
9163
9210
  default:
9164
9211
  break;
9165
9212
  }
9166
9213
 
9214
+ data->return_value = Qfalse;
9167
9215
  return Qfalse;
9168
9216
  }
9169
9217
  /* }}} */
@@ -9208,10 +9256,10 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
9208
9256
  if ( !NIL_P( stmt ) ) {
9209
9257
  Data_Get_Struct(stmt, stmt_handle, result_args->stmt_res);
9210
9258
 
9211
- #ifdef UNICODE_SUPPORT_VERSION
9212
- //ret_val = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_result_helper, result_args,
9213
- ret_val = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_result_helper, result_args,
9259
+ #ifdef UNICODE_SUPPORT_VERSION
9260
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_result_helper, result_args,
9214
9261
  (void *)_ruby_ibm_db_Statement_level_UBF, result_args->stmt_res );
9262
+ ret_val = result_args->return_value;
9215
9263
  #else
9216
9264
  ret_val = _ruby_ibm_db_result_helper( result_args );
9217
9265
  #endif
@@ -9287,6 +9335,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9287
9335
  *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
9288
9336
  #endif
9289
9337
  }
9338
+ data->return_value = Qnil;
9290
9339
  return Qnil;
9291
9340
  }
9292
9341
  }
@@ -9311,6 +9360,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9311
9360
  *(data->error) = rb_str_new2("Column binding cannot be done: <error message could not be retrieved>");
9312
9361
  #endif
9313
9362
  }
9363
+ data->return_value = Qnil;
9314
9364
  return Qnil;
9315
9365
  }
9316
9366
  }
@@ -9360,6 +9410,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9360
9410
  #else
9361
9411
  *(data->error) = rb_str_new2("Requested row number must be a positive value");
9362
9412
  #endif
9413
+ data->return_value = Qnil;
9363
9414
  return Qnil;
9364
9415
  } else {
9365
9416
  /*row_number is NULL or 0; just fetch next row*/
@@ -9378,6 +9429,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9378
9429
  }
9379
9430
 
9380
9431
  if (rc == SQL_NO_DATA_FOUND) {
9432
+ data->return_value = Qfalse;
9381
9433
  return Qfalse;
9382
9434
  } else if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
9383
9435
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
@@ -9397,6 +9449,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9397
9449
  *(data->error) = rb_str_new2("Fetch Failure: <error message could not be retrieved>");
9398
9450
  #endif
9399
9451
  }
9452
+ data->return_value = Qnil;
9400
9453
  return Qnil;
9401
9454
  }
9402
9455
  /* copy the data over return_value */
@@ -9484,6 +9537,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9484
9537
  out_ptr = (SQLPOINTER)ALLOC_N(char, tmp_length+1);
9485
9538
  if ( out_ptr == NULL ) {
9486
9539
  rb_warn( "Failed to allocate Memory");
9540
+ data->return_value = Qnil;
9487
9541
  return Qnil;
9488
9542
  }
9489
9543
  memset(out_ptr,'\0',tmp_length+1);
@@ -9492,6 +9546,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9492
9546
  if ( rc == SQL_ERROR ) {
9493
9547
  ruby_xfree( out_ptr );
9494
9548
  out_ptr = NULL;
9549
+ data->return_value = Qfalse;
9495
9550
  return Qfalse;
9496
9551
  }
9497
9552
  if (out_length == SQL_NULL_DATA) {
@@ -9536,6 +9591,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9536
9591
 
9537
9592
  if(tmpStr == NULL ){
9538
9593
  rb_warn( "Failed to Allocate Memory for Decimal Data" );
9594
+ data->return_value = Qnil;
9539
9595
  return Qnil;
9540
9596
  }
9541
9597
 
@@ -9674,6 +9730,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9674
9730
  ruby_xfree( out_ptr );
9675
9731
  out_ptr = NULL;
9676
9732
  out_length = 0;
9733
+ data->return_value = Qfalse;
9677
9734
  return Qfalse;
9678
9735
  }
9679
9736
 
@@ -9725,6 +9782,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9725
9782
  *(data->error) = rb_str_new2("Failed to Determine XML Size: <error message could not be retrieved>");
9726
9783
  #endif
9727
9784
  }
9785
+ data->return_value = Qnil;
9728
9786
  return Qnil;
9729
9787
  }
9730
9788
 
@@ -9744,6 +9802,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9744
9802
 
9745
9803
  if ( out_ptr == NULL ) {
9746
9804
  rb_warn( "Failed to Allocate Memory for XML Data" );
9805
+ data->return_value = Qnil;
9747
9806
  return Qnil;
9748
9807
  }
9749
9808
 
@@ -9751,6 +9810,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9751
9810
  if (rc == SQL_ERROR) {
9752
9811
  ruby_xfree( out_ptr );
9753
9812
  out_ptr = NULL;
9813
+ data->return_value = Qfalse;
9754
9814
  return Qfalse;
9755
9815
  }
9756
9816
 
@@ -9812,6 +9872,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9812
9872
 
9813
9873
  if ( out_ptr == NULL ) {
9814
9874
  rb_warn( "Failed to Allocate Memory for LOB Data" );
9875
+ data->return_value = Qnil;
9815
9876
  return Qnil;
9816
9877
  }
9817
9878
 
@@ -9824,6 +9885,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9824
9885
  ruby_xfree( out_ptr );
9825
9886
  out_ptr = NULL;
9826
9887
  out_length = 0;
9888
+ data->return_value = Qfalse;
9827
9889
  return Qfalse;
9828
9890
  }
9829
9891
 
@@ -9858,6 +9920,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9858
9920
  }
9859
9921
  }
9860
9922
 
9923
+ data->return_value = return_value;
9861
9924
  return return_value;
9862
9925
  }
9863
9926
  /*
@@ -9896,6 +9959,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
9896
9959
  *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
9897
9960
  #endif
9898
9961
  }
9962
+ data->return_value = Qnil;
9899
9963
  return Qnil;
9900
9964
  }
9901
9965
  }
@@ -9932,6 +9996,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
9932
9996
  #else
9933
9997
  *(data->error) = rb_str_new2("Requested row number must be a positive value");
9934
9998
  #endif
9999
+ data->return_value = Qnil;
9935
10000
  return Qnil;
9936
10001
  } else {
9937
10002
  /*row_number is NULL or 0; just fetch next row*/
@@ -9952,7 +10017,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
9952
10017
  ret_val = Qfalse;
9953
10018
  }
9954
10019
  }
9955
-
10020
+ data->return_value = ret_val;
9956
10021
  return ret_val;
9957
10022
  }
9958
10023
  /* */
@@ -10012,10 +10077,10 @@ VALUE ibm_db_fetch_row(int argc, VALUE *argv, VALUE self)
10012
10077
  helper_args->arg_count = argc;
10013
10078
  helper_args->error = &error;
10014
10079
 
10015
- #ifdef UNICODE_SUPPORT_VERSION
10016
- //ret_val = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_fetch_row_helper, helper_args,
10017
- ret_val = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_fetch_row_helper, helper_args,
10080
+ #ifdef UNICODE_SUPPORT_VERSION
10081
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_fetch_row_helper, helper_args,
10018
10082
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10083
+ ret_val = helper_args->return_value;
10019
10084
  #else
10020
10085
  ret_val = _ruby_ibm_db_fetch_row_helper( helper_args );
10021
10086
  #endif
@@ -10181,14 +10246,15 @@ VALUE ibm_db_fetch_assoc(int argc, VALUE *argv, VALUE self) {
10181
10246
  helper_args->error = &error;
10182
10247
  helper_args->funcType = FETCH_ASSOC;
10183
10248
 
10184
- #ifdef UNICODE_SUPPORT_VERSION
10185
- //ret_val = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10186
- ret_val = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10249
+ #ifdef UNICODE_SUPPORT_VERSION
10250
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10187
10251
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10252
+ ret_val = helper_args->return_value;
10253
+
10188
10254
  #else
10189
10255
  ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
10190
10256
  #endif
10191
-
10257
+
10192
10258
  /*Free Memory Allocated*/
10193
10259
  if ( helper_args != NULL) {
10194
10260
  ruby_xfree( helper_args );
@@ -10269,10 +10335,10 @@ VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
10269
10335
  helper_args->error = &error;
10270
10336
  helper_args->funcType = FETCH_ASSOC;
10271
10337
 
10272
- #ifdef UNICODE_SUPPORT_VERSION
10273
- //row_res->hash = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10274
- row_res->hash = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10338
+ #ifdef UNICODE_SUPPORT_VERSION
10339
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10275
10340
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10341
+ row_res->hash = helper_args->return_value;
10276
10342
  #else
10277
10343
  row_res->hash = _ruby_ibm_db_bind_fetch_helper( helper_args );
10278
10344
  #endif
@@ -10295,7 +10361,7 @@ VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
10295
10361
  ruby_xfree( row_res );
10296
10362
  row_res = NULL;
10297
10363
  return Qfalse;
10298
- }
10364
+ }
10299
10365
  }
10300
10366
  /* */
10301
10367
 
@@ -10352,10 +10418,11 @@ VALUE ibm_db_fetch_array(int argc, VALUE *argv, VALUE self)
10352
10418
  helper_args->error = &error;
10353
10419
  helper_args->funcType = FETCH_INDEX;
10354
10420
 
10355
- #ifdef UNICODE_SUPPORT_VERSION
10356
- //ret_val = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10357
- ret_val = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10421
+ #ifdef UNICODE_SUPPORT_VERSION
10422
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10358
10423
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10424
+ ret_val = helper_args->return_value;
10425
+
10359
10426
  #else
10360
10427
  ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
10361
10428
  #endif
@@ -10429,10 +10496,10 @@ VALUE ibm_db_fetch_both(int argc, VALUE *argv, VALUE self)
10429
10496
  helper_args->error = &error;
10430
10497
  helper_args->funcType = FETCH_BOTH;
10431
10498
 
10432
- #ifdef UNICODE_SUPPORT_VERSION
10433
- //ret_val = rb_thread_call_without_gvl ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10434
- ret_val = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10499
+ #ifdef UNICODE_SUPPORT_VERSION
10500
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10435
10501
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10502
+ ret_val = helper_args->return_value;
10436
10503
  #else
10437
10504
  ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
10438
10505
  #endif
@@ -10523,7 +10590,7 @@ VALUE ibm_db_set_option(int argc, VALUE *argv, VALUE self)
10523
10590
  /*
10524
10591
  Retrieves the server information by calling the SQLGetInfo_helper function and wraps it up into server_info object
10525
10592
  */
10526
- static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10593
+ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10527
10594
  conn_handle *conn_res = NULL;
10528
10595
 
10529
10596
  int rc = 0;
@@ -10558,6 +10625,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10558
10625
 
10559
10626
  if ( rc == SQL_ERROR ) {
10560
10627
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10628
+ getInfo_args->return_value = Qfalse;
10561
10629
  return Qfalse;
10562
10630
  } else {
10563
10631
 
@@ -10576,9 +10644,9 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10576
10644
 
10577
10645
  memset(buffer11, '\0', sizeof(buffer11));
10578
10646
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
10579
-
10580
10647
  if ( rc == SQL_ERROR ) {
10581
10648
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10649
+ getInfo_args->return_value = Qfalse;
10582
10650
  return Qfalse;
10583
10651
  } else {
10584
10652
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10587,7 +10655,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10587
10655
  rb_iv_set(return_value, "@DBMS_VER", rb_str_new2(buffer11));
10588
10656
  #endif
10589
10657
  }
10590
-
10591
10658
  #ifndef PASE /* i5/OS DB_CODEPAGE handled natively */
10592
10659
  /* DB_CODEPAGE */
10593
10660
  bufferint32 = 0;
@@ -10601,6 +10668,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10601
10668
 
10602
10669
  if ( rc == SQL_ERROR ) {
10603
10670
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10671
+ getInfo_args->return_value = Qfalse;
10604
10672
  return Qfalse;
10605
10673
  } else {
10606
10674
  rb_iv_set(return_value, "@DB_CODEPAGE", INT2NUM(bufferint32));
@@ -10618,6 +10686,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10618
10686
 
10619
10687
  if ( rc == SQL_ERROR ) {
10620
10688
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10689
+ getInfo_args->return_value = Qfalse;
10621
10690
  return Qfalse;
10622
10691
  } else {
10623
10692
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10639,6 +10708,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10639
10708
 
10640
10709
  if ( rc == SQL_ERROR ) {
10641
10710
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10711
+ getInfo_args->return_value = Qfalse;
10642
10712
  return Qfalse;
10643
10713
  } else {
10644
10714
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10659,6 +10729,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10659
10729
 
10660
10730
  if ( rc == SQL_ERROR ) {
10661
10731
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10732
+ getInfo_args->return_value = Qfalse;
10662
10733
  return Qfalse;
10663
10734
  } else {
10664
10735
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10680,10 +10751,10 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10680
10751
 
10681
10752
  if ( rc == SQL_ERROR ) {
10682
10753
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10754
+ getInfo_args->return_value = Qfalse;
10683
10755
  return Qfalse;
10684
10756
  } else {
10685
10757
  VALUE keywordsStr, keywordsArray;
10686
-
10687
10758
  #ifdef UNICODE_SUPPORT_VERSION
10688
10759
  keywordsStr = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer3k, out_length);
10689
10760
  keywordsArray = rb_str_split(keywordsStr, RSTRING_PTR(_ruby_ibm_db_export_char_to_utf8_rstr(",")) );
@@ -10691,7 +10762,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10691
10762
  keywordsStr = rb_str_new2( buffer3k );
10692
10763
  keywordsArray = rb_str_split(keywordsStr, ",");
10693
10764
  #endif
10694
-
10695
10765
  rb_iv_set(return_value, "@KEYWORDS", keywordsArray);
10696
10766
  }
10697
10767
 
@@ -10706,6 +10776,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10706
10776
 
10707
10777
  if ( rc == SQL_ERROR ) {
10708
10778
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10779
+ getInfo_args->return_value = Qfalse;
10709
10780
  return Qfalse;
10710
10781
  } else {
10711
10782
  VALUE dft_isolation = Qnil;
@@ -10744,10 +10815,8 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10744
10815
  dft_isolation = rb_str_new2("NC");
10745
10816
  #endif
10746
10817
  }
10747
-
10748
10818
  rb_iv_set(return_value, "@DFT_ISOLATION", dft_isolation);
10749
10819
  }
10750
-
10751
10820
  #ifndef PASE /* i5/OS ISOLATION_OPTION handled natively */
10752
10821
  /* ISOLATION_OPTION */
10753
10822
  getInfo_args->infoType = SQL_TXN_ISOLATION_OPTION;
@@ -10757,15 +10826,14 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10757
10826
 
10758
10827
  bitmask = 0;
10759
10828
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
10760
-
10761
10829
  if ( rc == SQL_ERROR ) {
10762
10830
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10831
+ getInfo_args->return_value = Qfalse;
10763
10832
  return Qfalse;
10764
10833
  } else {
10765
10834
  VALUE array;
10766
10835
 
10767
10836
  array = rb_ary_new();
10768
-
10769
10837
  if( bitmask & SQL_TXN_READ_UNCOMMITTED ) {
10770
10838
  #ifdef UNICODE_SUPPORT_VERSION
10771
10839
  rb_ary_push(array, _ruby_ibm_db_export_char_to_utf8_rstr("UR"));
@@ -10801,7 +10869,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10801
10869
  rb_ary_push(array, rb_str_new2("NC"));
10802
10870
  #endif
10803
10871
  }
10804
-
10805
10872
  rb_iv_set(return_value, "@ISOLATION_OPTION", array);
10806
10873
  }
10807
10874
  #endif /* PASE */
@@ -10814,9 +10881,9 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10814
10881
 
10815
10882
  bufferint32 = 0;
10816
10883
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
10817
-
10818
10884
  if ( rc == SQL_ERROR ) {
10819
10885
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10886
+ getInfo_args->return_value = Qfalse;
10820
10887
  return Qfalse;
10821
10888
  } else {
10822
10889
  VALUE conformance = Qnil;
@@ -10863,9 +10930,9 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10863
10930
 
10864
10931
  memset(buffer11, '\0', sizeof(buffer11));
10865
10932
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
10866
-
10867
10933
  if ( rc == SQL_ERROR ) {
10868
10934
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10935
+ getInfo_args->return_value = Qfalse;
10869
10936
  return Qfalse;
10870
10937
  } else {
10871
10938
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10878,7 +10945,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10878
10945
  rb_iv_set(return_value, "@PROCEDURES", Qfalse);
10879
10946
  }
10880
10947
  }
10881
-
10882
10948
  /* IDENTIFIER_QUOTE_CHAR */
10883
10949
  getInfo_args->infoType = SQL_IDENTIFIER_QUOTE_CHAR;
10884
10950
  getInfo_args->infoValue = (SQLPOINTER)buffer11;
@@ -10890,6 +10956,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10890
10956
 
10891
10957
  if ( rc == SQL_ERROR ) {
10892
10958
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10959
+ getInfo_args->return_value = Qfalse;
10893
10960
  return Qfalse;
10894
10961
  } else {
10895
10962
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10910,6 +10977,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10910
10977
 
10911
10978
  if ( rc == SQL_ERROR ) {
10912
10979
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
10980
+ getInfo_args->return_value = Qfalse;
10913
10981
  return Qfalse;
10914
10982
  } else {
10915
10983
  #ifdef UNICODE_SUPPORT_VERSION
@@ -10929,11 +10997,10 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10929
10997
  getInfo_args->buff_length = sizeof( bufferint16 );
10930
10998
  out_length = 0;
10931
10999
  bufferint16 = 0;
10932
-
10933
11000
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
10934
-
10935
11001
  if ( rc == SQL_ERROR ) {
10936
11002
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11003
+ getInfo_args->return_value = Qfalse;
10937
11004
  return Qfalse;
10938
11005
  } else {
10939
11006
  rb_iv_set(return_value, "@MAX_COL_NAME_LEN", INT2NUM(bufferint16));
@@ -10950,11 +11017,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10950
11017
 
10951
11018
  if ( rc == SQL_ERROR ) {
10952
11019
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11020
+ getInfo_args->return_value = Qfalse;
10953
11021
  return Qfalse;
10954
11022
  } else {
10955
11023
  rb_iv_set(return_value, "@MAX_ROW_SIZE", INT2NUM(bufferint32));
10956
11024
  }
10957
-
10958
11025
  #ifndef PASE /* i5/OS MAX_IDENTIFIER_LEN handled natively */
10959
11026
  /* MAX_IDENTIFIER_LEN */
10960
11027
  getInfo_args->infoType = SQL_MAX_IDENTIFIER_LEN;
@@ -10967,6 +11034,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10967
11034
 
10968
11035
  if ( rc == SQL_ERROR ) {
10969
11036
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11037
+ getInfo_args->return_value = Qfalse;
10970
11038
  return Qfalse;
10971
11039
  } else {
10972
11040
  rb_iv_set(return_value, "@MAX_IDENTIFIER_LEN", INT2NUM(bufferint16));
@@ -10983,6 +11051,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10983
11051
 
10984
11052
  if ( rc == SQL_ERROR ) {
10985
11053
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11054
+ getInfo_args->return_value = Qfalse;
10986
11055
  return Qfalse;
10987
11056
  } else {
10988
11057
  rb_iv_set(return_value, "@MAX_INDEX_SIZE", INT2NUM(bufferint32));
@@ -10999,6 +11068,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10999
11068
 
11000
11069
  if ( rc == SQL_ERROR ) {
11001
11070
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11071
+ getInfo_args->return_value = Qfalse;
11002
11072
  return Qfalse;
11003
11073
  } else {
11004
11074
  rb_iv_set(return_value, "@MAX_PROC_NAME_LEN", INT2NUM(bufferint16));
@@ -11016,6 +11086,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
11016
11086
 
11017
11087
  if ( rc == SQL_ERROR ) {
11018
11088
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11089
+ getInfo_args->return_value = Qfalse;
11019
11090
  return Qfalse;
11020
11091
  } else {
11021
11092
  rb_iv_set(return_value, "@MAX_SCHEMA_NAME_LEN", INT2NUM(bufferint16));
@@ -11032,6 +11103,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
11032
11103
 
11033
11104
  if ( rc == SQL_ERROR ) {
11034
11105
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11106
+ getInfo_args->return_value = Qfalse;
11035
11107
  return Qfalse;
11036
11108
  } else {
11037
11109
  rb_iv_set(return_value, "@MAX_STATEMENT_LEN", INT2NUM(bufferint32));
@@ -11048,6 +11120,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
11048
11120
 
11049
11121
  if ( rc == SQL_ERROR ) {
11050
11122
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11123
+ getInfo_args->return_value = Qfalse;
11051
11124
  return Qfalse;
11052
11125
  } else {
11053
11126
  rb_iv_set(return_value, "@MAX_TABLE_NAME_LEN", INT2NUM(bufferint16));
@@ -11064,6 +11137,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
11064
11137
 
11065
11138
  if ( rc == SQL_ERROR ) {
11066
11139
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11140
+ getInfo_args->return_value = Qfalse;
11067
11141
  return Qfalse;
11068
11142
  } else {
11069
11143
  VALUE rv = Qnil;
@@ -11080,6 +11154,8 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
11080
11154
  rb_iv_set(return_value, "@NON_NULLABLE_COLUMNS", rv);
11081
11155
  }
11082
11156
 
11157
+ getInfo_args->return_value=return_value;
11158
+
11083
11159
  return return_value;
11084
11160
  }
11085
11161
  /* */
@@ -11163,28 +11239,34 @@ VALUE ibm_db_server_info(int argc, VALUE *argv, VALUE self)
11163
11239
  get_info_args *getInfo_args = NULL;
11164
11240
 
11165
11241
  rb_scan_args(argc, argv, "1", &connection);
11242
+
11243
+
11244
+ if(NIL_P(&connection))
11245
+ {
11246
+ }
11247
+ if(&connection == NULL)
11248
+ {
11249
+ }
11166
11250
 
11167
11251
  if (!NIL_P(connection)) {
11168
11252
  Data_Get_Struct(connection, conn_handle, conn_res);
11169
-
11170
- if (!conn_res->handle_active) {
11253
+
11254
+ if (!conn_res || !conn_res->handle_active) {
11171
11255
  rb_warn("Connection is not active");
11172
11256
  return Qfalse;
11173
11257
  }
11174
-
11175
11258
  getInfo_args = ALLOC( get_info_args );
11176
11259
  memset(getInfo_args,'\0',sizeof(struct _ibm_db_get_info_struct));
11177
-
11260
+
11178
11261
  getInfo_args->conn_res = conn_res;
11179
11262
  getInfo_args->out_length = NULL;
11180
11263
  getInfo_args->infoType = 0;
11181
11264
  getInfo_args->infoValue = NULL;
11182
11265
  getInfo_args->buff_length = 0;
11183
-
11184
11266
  #ifdef UNICODE_SUPPORT_VERSION
11185
- //return_value = rb_thread_call_without_gvl ( (void *)ibm_db_server_info_helper, getInfo_args,
11186
- return_value = ibm_Ruby_Thread_Call ( (void *)ibm_db_server_info_helper, getInfo_args,
11267
+ ibm_Ruby_Thread_Call ( (void *)ibm_db_server_info_helper, getInfo_args,
11187
11268
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
11269
+ return_value = getInfo_args->return_value;
11188
11270
  #else
11189
11271
  return_value = ibm_db_server_info_helper( getInfo_args );
11190
11272
  #endif
@@ -11232,6 +11314,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11232
11314
 
11233
11315
  if ( rc == SQL_ERROR ) {
11234
11316
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11317
+ getInfo_args->return_value = Qfalse;
11235
11318
  return Qfalse;
11236
11319
  } else {
11237
11320
  #ifdef UNICODE_SUPPORT_VERSION
@@ -11252,6 +11335,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11252
11335
 
11253
11336
  if ( rc == SQL_ERROR ) {
11254
11337
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11338
+ getInfo_args->return_value = Qfalse;
11255
11339
  return Qfalse;
11256
11340
  } else {
11257
11341
  #ifdef UNICODE_SUPPORT_VERSION
@@ -11272,6 +11356,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11272
11356
 
11273
11357
  if ( rc == SQL_ERROR ) {
11274
11358
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11359
+ getInfo_args->return_value = Qfalse;
11275
11360
  return Qfalse;
11276
11361
  } else {
11277
11362
  #ifdef UNICODE_SUPPORT_VERSION
@@ -11292,6 +11377,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11292
11377
 
11293
11378
  if ( rc == SQL_ERROR ) {
11294
11379
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11380
+ getInfo_args->return_value = Qfalse;
11295
11381
  return Qfalse;
11296
11382
  } else {
11297
11383
  #ifdef UNICODE_SUPPORT_VERSION
@@ -11313,6 +11399,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11313
11399
 
11314
11400
  if ( rc == SQL_ERROR ) {
11315
11401
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11402
+ getInfo_args->return_value = Qfalse;
11316
11403
  return Qfalse;
11317
11404
  } else {
11318
11405
  #ifdef UNICODE_SUPPORT_VERSION
@@ -11334,6 +11421,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11334
11421
 
11335
11422
  if ( rc == SQL_ERROR ) {
11336
11423
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11424
+ getInfo_args->return_value = Qfalse;
11337
11425
  return Qfalse;
11338
11426
  } else {
11339
11427
  VALUE conformance = Qnil;
@@ -11377,6 +11465,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11377
11465
 
11378
11466
  if ( rc == SQL_ERROR ) {
11379
11467
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11468
+ getInfo_args->return_value = Qfalse;
11380
11469
  return Qfalse;
11381
11470
  } else {
11382
11471
  rb_iv_set(return_value, "@APPL_CODEPAGE", INT2NUM(bufferint32));
@@ -11393,12 +11482,14 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11393
11482
 
11394
11483
  if ( rc == SQL_ERROR ) {
11395
11484
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 0 );
11485
+ getInfo_args->return_value = Qfalse;
11396
11486
  return Qfalse;
11397
11487
  } else {
11398
11488
  rb_iv_set(return_value, "@CONN_CODEPAGE", INT2NUM(bufferint32));
11399
11489
  }
11400
11490
  #endif /* PASE */
11401
11491
 
11492
+ getInfo_args->return_value = return_value;
11402
11493
  return return_value;
11403
11494
  }
11404
11495
  /* */
@@ -11455,7 +11546,7 @@ VALUE ibm_db_client_info(int argc, VALUE *argv, VALUE self)
11455
11546
  if (!NIL_P(connection)) {
11456
11547
  Data_Get_Struct(connection, conn_handle, conn_res);
11457
11548
 
11458
- if (!conn_res->handle_active) {
11549
+ if (!conn_res || !conn_res->handle_active) {
11459
11550
  rb_warn("Connection is not active");
11460
11551
  return Qfalse;
11461
11552
  }
@@ -11469,10 +11560,11 @@ VALUE ibm_db_client_info(int argc, VALUE *argv, VALUE self)
11469
11560
  getInfo_args->infoValue = NULL;
11470
11561
  getInfo_args->buff_length = 0;
11471
11562
 
11472
- #ifdef UNICODE_SUPPORT_VERSION
11473
- //return_value = rb_thread_call_without_gvl ( (void *)ibm_db_client_info_helper, getInfo_args,
11474
- return_value = ibm_Ruby_Thread_Call ( (void *)ibm_db_client_info_helper, getInfo_args,
11563
+ #ifdef UNICODE_SUPPORT_VERSION
11564
+ ibm_Ruby_Thread_Call ( (void *)ibm_db_client_info_helper, getInfo_args,
11475
11565
  (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
11566
+ return_value = getInfo_args->return_value;
11567
+
11476
11568
  #else
11477
11569
  return_value = ibm_db_client_info_helper( getInfo_args );
11478
11570
  #endif
@@ -11605,15 +11697,16 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11605
11697
 
11606
11698
  rb_scan_args(argc, argv, "3", &conn_or_stmt, &option, &r_type);
11607
11699
 
11700
+
11608
11701
  if (!NIL_P(r_type)) type = NUM2LONG(r_type);
11702
+
11609
11703
 
11610
11704
  if (!NIL_P(conn_or_stmt)) {
11611
11705
  /* Checking to see if we are getting a connection option (1) or a statement option (non - 1) */
11612
11706
  if (type == 1) {
11613
11707
  Data_Get_Struct(conn_or_stmt, conn_handle, conn_res);
11614
-
11615
11708
  /* Check to ensure the connection resource given is active */
11616
- if (!conn_res->handle_active) {
11709
+ if (!conn_res || !conn_res->handle_active) {
11617
11710
  rb_warn("Connection is not active");
11618
11711
  return Qfalse;
11619
11712
  }
@@ -11628,7 +11721,6 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11628
11721
  value = (SQLCHAR *)ALLOC_N(SQLCHAR, ACCTSTR_LEN + 1);
11629
11722
  memset(value,'\0', ACCTSTR_LEN + 1);
11630
11723
  #endif
11631
-
11632
11724
  get_handleAttr_args = ALLOC( get_handle_attr_args );
11633
11725
  memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
11634
11726
 
@@ -11641,12 +11733,10 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11641
11733
  get_handleAttr_args->buff_length = (ACCTSTR_LEN+1);
11642
11734
  #endif
11643
11735
  get_handleAttr_args->out_length = &out_length;
11644
-
11645
11736
  rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
11646
11737
 
11647
11738
  ruby_xfree( get_handleAttr_args );
11648
11739
  get_handleAttr_args = NULL;
11649
-
11650
11740
  if (rc == SQL_ERROR) {
11651
11741
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
11652
11742
  ret_val = Qfalse;
@@ -11667,7 +11757,6 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11667
11757
  /* At this point we know we are to retreive a statement option */
11668
11758
  } else {
11669
11759
  Data_Get_Struct(conn_or_stmt, stmt_handle, stmt_res);
11670
-
11671
11760
  /* Check that the option given is not null */
11672
11761
  if (!NIL_P(option)) {
11673
11762
  op_integer=(SQLINTEGER)FIX2INT(option);
@@ -11681,17 +11770,14 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11681
11770
  get_handleAttr_args->valuePtr = &value_int;
11682
11771
  get_handleAttr_args->buff_length = SQL_IS_INTEGER;
11683
11772
  get_handleAttr_args->out_length = NULL;
11684
-
11685
11773
  rc = _ruby_ibm_db_SQLGetStmtAttr_helper( get_handleAttr_args );
11686
11774
 
11687
11775
  ruby_xfree( get_handleAttr_args );
11688
11776
  get_handleAttr_args = NULL;
11689
-
11690
11777
  if (rc == SQL_ERROR) {
11691
11778
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 1 );
11692
11779
  return Qfalse;
11693
11780
  }
11694
-
11695
11781
  return INT2NUM(value_int);
11696
11782
  } else {
11697
11783
  rb_warn("Invalid option specified");
@@ -11706,7 +11792,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11706
11792
  } else {
11707
11793
  rb_warn("Supplied resource handle is invalid");
11708
11794
  return Qfalse;
11709
- }
11795
+ }
11710
11796
  }
11711
11797
 
11712
11798