ibm_db 2.5.26 → 2.5.27

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,845 +1,851 @@
1
- /*
2
- +----------------------------------------------------------------------+
3
- | Licensed Materials - Property of IBM |
4
- | |
5
- | (C) Copyright IBM Corporation 2009, 2010, 2012 |
6
- +----------------------------------------------------------------------+
7
- | Authors: Praveen Devarao |
8
- +----------------------------------------------------------------------+
9
- */
10
-
11
-
12
- /*
13
- This C file contains functions that perform DB operations, which can take long time to complete.
14
- For Eg: - Like SQLConnect, SQLFetch etc.
15
-
16
- This file in general will contain functions that make CLI calls and
17
- depending on whether the call will be transferred to server or not the functions are termed long time comsuming or not.
18
-
19
- The functions which will contact the server and hence can be time consuming will be called by ruby's (1.9 onwards)
20
- rb_thread_blocking_region method, which inturn will release the GVL while these operations are being performed.
21
- With this the executing thread will become unblocking allowing concurrent threads perform operations simultaneously.
22
- */
23
-
24
- #include "ruby_ibm_db_cli.h"
25
-
26
- /*
27
- This function connects to the database using either SQLConnect or SQLDriverConnect CLI API
28
- depending on whether it is a cataloged or an uncataloged connection.
29
- */
30
- int _ruby_ibm_db_SQLConnect_helper(connect_args *data) {
31
- if(data->ctlg_conn == 1) {
32
- #ifndef UNICODE_SUPPORT_VERSION
33
- return SQLConnect( (SQLHDBC)*(data->hdbc), (SQLCHAR *)data->database,
34
- (SQLSMALLINT)data->database_len, (SQLCHAR *)data->uid, (SQLSMALLINT)data->uid_len,
35
- (SQLCHAR *)data->password, (SQLSMALLINT)data->password_len );
36
- #else
37
- return SQLConnectW( (SQLHDBC)*(data->hdbc), data->database,
38
- data->database_len, data->uid, data->uid_len,
39
- data->password, data->password_len );
40
- #endif
41
- } else {
42
- #ifndef UNICODE_SUPPORT_VERSION
43
- return SQLDriverConnect( (SQLHDBC) *(data->hdbc), (SQLHWND)NULL,
44
- (SQLCHAR*)data->database, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT );
45
- #else
46
- return SQLDriverConnectW( (SQLHDBC) *(data->hdbc), (SQLHWND)NULL,
47
- data->database, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT );
48
- #endif
49
- }
50
- }
51
-
52
- /*
53
- This function issues SQLDisconnect to disconnect from the Dataserver
54
- */
55
- int _ruby_ibm_db_SQLDisconnect_helper(SQLHANDLE *hdbc) {
56
- return SQLDisconnect( (SQLHDBC) *hdbc );
57
- }
58
-
59
- /*
60
- Connection level Unblock function. This function is called when a thread interruput is issued while executing a
61
- connection level SQL call
62
- */
63
- void _ruby_ibm_db_Connection_level_UBF(void *data) {
64
- return;
65
- }
66
-
67
- /*
68
- This function will commit and end the inprogress transaction by issuing a SQLCommit
69
- */
70
- int _ruby_ibm_db_SQLEndTran(end_tran_args *endtran_args) {
71
- return SQLEndTran( endtran_args->handleType, *(endtran_args->hdbc), endtran_args->completionType );
72
- }
73
-
74
- /*
75
- This function call the SQLDescribeParam cli call to get the description of the parameter in the sql specified
76
- */
77
- int _ruby_ibm_db_SQLDescribeParam_helper(describeparam_args *data) {
78
- int rc = 0;
79
- data->stmt_res->is_executing = 1;
80
-
81
- rc = SQLDescribeParam( (SQLHSTMT) data->stmt_res->hstmt, (SQLUSMALLINT)data->param_no, &(data->sql_data_type),
82
- &(data->sql_precision), &(data->sql_scale), &(data->sql_nullable) );
83
-
84
- data->stmt_res->is_executing = 0;
85
-
86
- return rc;
87
- }
88
-
89
- /*
90
- This function call the SQLDescribeCol cli call to get the description of the parameter in the sql specified
91
- */
92
- int _ruby_ibm_db_SQLDescribeCol_helper(describecol_args *data) {
93
- int i = data->col_no - 1;
94
- int rc = 0;
95
-
96
- data->stmt_res->is_executing = 1;
97
-
98
- #ifdef UNICODE_SUPPORT_VERSION
99
- rc = SQLDescribeColW( (SQLHSTMT)data->stmt_res->hstmt, (SQLSMALLINT)(data->col_no),
100
- data->stmt_res->column_info[i].name, data->buff_length, &(data->name_length),
101
- &(data->stmt_res->column_info[i].type), &(data->stmt_res->column_info[i].size),
102
- &(data->stmt_res->column_info[i].scale), &(data->stmt_res->column_info[i].nullable) );
103
- #else
104
- rc = SQLDescribeCol( (SQLHSTMT)data->stmt_res->hstmt, (SQLSMALLINT)(data->col_no),
105
- data->stmt_res->column_info[i].name, data->buff_length, &(data->name_length),
106
- &(data->stmt_res->column_info[i].type), &(data->stmt_res->column_info[i].size),
107
- &(data->stmt_res->column_info[i].scale), &(data->stmt_res->column_info[i].nullable) );
108
- #endif
109
-
110
- data->stmt_res->is_executing = 0;
111
-
112
- return rc;
113
- }
114
-
115
- /*
116
- This function call the SQLBindCol cli call to get the description of the parameter in the sql specified
117
- */
118
- int _ruby_ibm_db_SQLBindCol_helper(bind_col_args *data) {
119
- int rc = 0;
120
-
121
- data->stmt_res->is_executing = 1;
122
-
123
- rc = SQLBindCol( (SQLHSTMT) data->stmt_res->hstmt, (SQLUSMALLINT)(data->col_num),
124
- data->TargetType, data->TargetValuePtr, data->buff_length,
125
- data->out_length );
126
-
127
- data->stmt_res->is_executing = 0;
128
-
129
- return rc;
130
- }
131
-
132
- /*
133
- This function calls SQLColumnPrivileges cli call to get the list of columns and the associated privileges
134
- */
135
- int _ruby_ibm_db_SQLColumnPrivileges_helper(metadata_args *data) {
136
- int rc = 0;
137
-
138
- data->stmt_res->is_executing = 1;
139
-
140
- #ifndef UNICODE_SUPPORT_VERSION
141
- rc = SQLColumnPrivileges( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
142
- data->owner, data->owner_len, data->table_name, data->table_name_len,
143
- data->column_name, data->column_name_len );
144
- #else
145
- rc = SQLColumnPrivilegesW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
146
- data->owner, data->owner_len, data->table_name, data->table_name_len,
147
- data->column_name, data->column_name_len );
148
- #endif
149
-
150
- data->stmt_res->is_executing = 0;
151
-
152
- return rc;
153
-
154
- }
155
-
156
- /*
157
- This function calls SQLColumns cli call to get the list of columns and the associated metadata of the table
158
- */
159
- int _ruby_ibm_db_SQLColumns_helper(metadata_args *data) {
160
- int rc = 0;
161
-
162
- data->stmt_res->is_executing = 1;
163
-
164
- #ifndef UNICODE_SUPPORT_VERSION
165
- rc = SQLColumns( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
166
- data->owner, data->owner_len, data->table_name, data->table_name_len,
167
- data->column_name, data->column_name_len );
168
- #else
169
- rc = SQLColumnsW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
170
- data->owner, data->owner_len, data->table_name, data->table_name_len,
171
- data->column_name, data->column_name_len );
172
- #endif
173
-
174
- data->stmt_res->is_executing = 0;
175
-
176
- return rc;
177
- }
178
-
179
- /*
180
- This function calls SQLPrimaryKeys cli call to get the list of primay key columns and the associated metadata
181
- */
182
- int _ruby_ibm_db_SQLPrimaryKeys_helper(metadata_args *data) {
183
- int rc = 0;
184
-
185
- data->stmt_res->is_executing = 1;
186
-
187
- #ifndef UNICODE_SUPPORT_VERSION
188
- rc = SQLPrimaryKeys( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
189
- data->owner, data->owner_len, data->table_name, data->table_name_len );
190
- #else
191
- rc = SQLPrimaryKeysW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
192
- data->owner, data->owner_len, data->table_name, data->table_name_len );
193
- #endif
194
-
195
- data->stmt_res->is_executing = 0;
196
-
197
- return rc;
198
- }
199
-
200
- /*
201
- This function calls SQLForeignKeys cli call to get the list of foreign key columns and the associated metadata
202
- */
203
- int _ruby_ibm_db_SQLForeignKeys_helper(metadata_args *data) {
204
- int rc = 0;
205
-
206
- data->stmt_res->is_executing = 1;
207
-
208
- #ifndef UNICODE_SUPPORT_VERSION
209
- rc = SQLForeignKeys( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
210
- data->owner, data->owner_len, data->table_name , data->table_name_len, NULL, SQL_NTS,
211
- NULL, SQL_NTS, NULL, SQL_NTS );
212
- #else
213
- rc = SQLForeignKeysW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
214
- data->owner, data->owner_len, data->table_name , data->table_name_len, NULL, SQL_NTS,
215
- NULL, SQL_NTS, NULL, SQL_NTS );
216
- #endif
217
-
218
- data->stmt_res->is_executing = 0;
219
-
220
- return rc;
221
- }
222
-
223
- /*
224
- This function calls SQLProcedureColumns cli call to get the list of parameters
225
- and associated metadata of the stored procedure
226
- */
227
- int _ruby_ibm_db_SQLProcedureColumns_helper(metadata_args *data) {
228
- int rc = 0;
229
-
230
- data->stmt_res->is_executing = 1;
231
-
232
- #ifndef UNICODE_SUPPORT_VERSION
233
- rc = SQLProcedureColumns( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
234
- data->owner_len, data->proc_name, data->proc_name_len, data->column_name, data->column_name_len );
235
- #else
236
- rc = SQLProcedureColumnsW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
237
- data->owner_len, data->proc_name, data->proc_name_len, data->column_name, data->column_name_len );
238
- #endif
239
-
240
- data->stmt_res->is_executing = 0;
241
-
242
- return rc;
243
- }
244
-
245
- /*
246
- This function calls SQLProcedures cli call to get the list of stored procedures
247
- and associated metadata of the stored procedure
248
- */
249
- int _ruby_ibm_db_SQLProcedures_helper(metadata_args *data) {
250
- int rc = 0;
251
-
252
- data->stmt_res->is_executing = 1;
253
-
254
- #ifndef UNICODE_SUPPORT_VERSION
255
- rc = SQLProcedures( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
256
- data->owner_len, data->proc_name, data->proc_name_len );
257
- #else
258
- rc = SQLProceduresW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
259
- data->owner_len, data->proc_name, data->proc_name_len );
260
- #endif
261
-
262
- data->stmt_res->is_executing = 0;
263
-
264
- return rc;
265
- }
266
-
267
- /*
268
- This function calls SQLSpecialColumns cli call to get the metadata related to the special columns
269
- (Unique index or primary key column) and associated metadata
270
- */
271
- int _ruby_ibm_db_SQLSpecialColumns_helper(metadata_args *data) {
272
- int rc = 0;
273
-
274
- data->stmt_res->is_executing = 1;
275
-
276
- #ifndef UNICODE_SUPPORT_VERSION
277
- rc = SQLSpecialColumns( (SQLHSTMT) data->stmt_res->hstmt, SQL_BEST_ROWID, data->qualifier, data->qualifier_len,
278
- data->owner, data->owner_len, data->table_name, data->table_name_len,
279
- (SQLUSMALLINT)data->scope, SQL_NULLABLE );
280
- #else
281
- rc = SQLSpecialColumnsW( (SQLHSTMT) data->stmt_res->hstmt, SQL_BEST_ROWID, data->qualifier, data->qualifier_len,
282
- data->owner, data->owner_len, data->table_name, data->table_name_len,
283
- (SQLUSMALLINT)data->scope, SQL_NULLABLE );
284
- #endif
285
-
286
- data->stmt_res->is_executing = 0;
287
-
288
- return rc;
289
- }
290
-
291
- /*
292
- This function calls SQLStatistics cli call to get the index information for a given table.
293
- */
294
- int _ruby_ibm_db_SQLStatistics_helper(metadata_args *data) {
295
- int rc = 0;
296
-
297
- data->stmt_res->is_executing = 1;
298
-
299
- #ifndef UNICODE_SUPPORT_VERSION
300
- rc = SQLStatistics( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
301
- data->owner_len, data->table_name, data->table_name_len, (SQLUSMALLINT)data->unique, SQL_QUICK );
302
- #else
303
- rc = SQLStatisticsW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
304
- data->owner_len, data->table_name, data->table_name_len, (SQLUSMALLINT)data->unique, SQL_QUICK );
305
- #endif
306
-
307
- data->stmt_res->is_executing = 0;
308
-
309
- return rc;
310
- }
311
-
312
- /*
313
- This function calls SQLTablePrivileges cli call to retrieve list of tables and
314
- the asscociated privileges for each table.
315
- */
316
- int _ruby_ibm_db_SQLTablePrivileges_helper(metadata_args *data) {
317
- int rc = 0;
318
-
319
- data->stmt_res->is_executing = 1;
320
-
321
- #ifndef UNICODE_SUPPORT_VERSION
322
- rc = SQLTablePrivileges( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
323
- data->owner, data->owner_len, data->table_name, data->table_name_len );
324
- #else
325
- rc = SQLTablePrivilegesW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
326
- data->owner, data->owner_len, data->table_name, data->table_name_len );
327
- #endif
328
-
329
- data->stmt_res->is_executing = 0;
330
-
331
- return rc;
332
- }
333
-
334
- /*
335
- This function calls SQLTables cli call to retrieve list of tables in the specified schema and
336
- the asscociated metadata for each table.
337
- */
338
- int _ruby_ibm_db_SQLTables_helper(metadata_args *data) {
339
- int rc = 0;
340
-
341
- data->stmt_res->is_executing = 1;
342
-
343
- #ifndef UNICODE_SUPPORT_VERSION
344
- rc = SQLTables( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
345
- data->owner_len, data->table_name, data->table_name_len, data->table_type, data->table_type_len );
346
- #else
347
- rc = SQLTablesW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
348
- data->owner_len, data->table_name, data->table_name_len, data->table_type, data->table_type_len );
349
- #endif
350
-
351
- data->stmt_res->is_executing = 0;
352
-
353
- return rc;
354
- }
355
-
356
- /*
357
- This function calls SQLExecDirect cli call to execute a statement directly
358
- */
359
- int _ruby_ibm_db_SQLExecDirect_helper(exec_cum_prepare_args *data) {
360
- int rc = 0;
361
-
362
- data->stmt_res->is_executing = 1;
363
-
364
- #ifndef UNICODE_SUPPORT_VERSION
365
- rc = SQLExecDirect( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
366
- #else
367
- rc = SQLExecDirectW( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
368
- #endif
369
-
370
- data->stmt_res->is_executing = 0;
371
-
372
- return rc;
373
- }
374
-
375
- /*
376
- This function calls SQLCreateDb cli call
377
- */
378
- int _ruby_ibm_db_SQLCreateDB_helper(create_drop_db_args *data) {
379
- int rc = 0;
380
- #ifndef UNICODE_SUPPORT_VERSION
381
- #ifdef _WIN32
382
- HINSTANCE cliLib = NULL;
383
- FARPROC sqlcreatedb;
384
- cliLib = DLOPEN( LIBDB2 );
385
- sqlcreatedb = DLSYM( cliLib, "SQLCreateDb" );
386
- #elif _AIX
387
- void *cliLib = NULL;
388
- typedef int (*sqlcreatedbType)( SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER );
389
- sqlcreatedbType sqlcreatedb;
390
- /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
391
- cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
392
- sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDb" );
393
- #else
394
- void *cliLib = NULL;
395
- typedef int (*sqlcreatedbType)( SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER );
396
- sqlcreatedbType sqlcreatedb;
397
- cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
398
- sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDb" );
399
- #endif
400
- #else
401
- #ifdef _WIN32
402
- HINSTANCE cliLib = NULL;
403
- FARPROC sqlcreatedb;
404
- cliLib = DLOPEN( LIBDB2 );
405
- sqlcreatedb = DLSYM( cliLib, "SQLCreateDbW" );
406
- #elif _AIX
407
- void *cliLib = NULL;
408
- typedef int (*sqlcreatedbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER );
409
- sqlcreatedbType sqlcreatedb;
410
- /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
411
- cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
412
- sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDbW" );
413
- #else
414
- void *cliLib = NULL;
415
- typedef int (*sqlcreatedbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER );
416
- sqlcreatedbType sqlcreatedb;
417
- cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
418
- sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDbW" );
419
- #endif
420
- #endif
421
-
422
- rc = (*sqlcreatedb)( (SQLHSTMT) data->conn_res->hdbc, data->dbName, (SQLINTEGER)data->dbName_string_len,
423
- data->codeSet, (SQLINTEGER)data->codeSet_string_len,
424
- data->mode, (SQLINTEGER)data->mode_string_len );
425
- DLCLOSE( cliLib );
426
- return rc;
427
- }
428
-
429
- /*
430
- This function calls SQLDropDb cli call
431
- */
432
- int _ruby_ibm_db_SQLDropDB_helper(create_drop_db_args *data) {
433
- int rc = 0;
434
- #ifndef UNICODE_SUPPORT_VERSION
435
- #ifdef _WIN32
436
- HINSTANCE cliLib = NULL;
437
- FARPROC sqldropdb;
438
- cliLib = DLOPEN( LIBDB2 );
439
- sqldropdb = DLSYM( cliLib, "SQLDropDb" );
440
- #elif _AIX
441
- void *cliLib = NULL;
442
- typedef int (*sqldropdbType)( SQLHDBC, SQLCHAR *, SQLINTEGER);
443
- sqldropdbType sqldropdb;
444
- /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
445
- cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
446
- sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDb" );
447
- #else
448
- void *cliLib = NULL;
449
- typedef int (*sqldropdbType)( SQLHDBC, SQLCHAR *, SQLINTEGER);
450
- sqldropdbType sqldropdb;
451
- cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
452
- sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDb" );
453
- #endif
454
- #else
455
- #ifdef _WIN32
456
- HINSTANCE cliLib = NULL;
457
- FARPROC sqldropdb;
458
- cliLib = DLOPEN( LIBDB2 );
459
- sqldropdb = DLSYM( cliLib, "SQLDropDbW" );
460
- #elif _AIX
461
- void *cliLib = NULL;
462
- typedef int (*sqldropdbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER);
463
- sqldropdbType sqldropdb;
464
- /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
465
- cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
466
- sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDbW" );
467
- #else
468
- void *cliLib = NULL;
469
- typedef int (*sqldropdbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER);
470
- sqldropdbType sqldropdb;
471
- cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
472
- sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDbW" );
473
- #endif
474
- #endif
475
-
476
- rc = (*sqldropdb)( (SQLHSTMT) data->conn_res->hdbc, data->dbName, (SQLINTEGER)data->dbName_string_len );
477
-
478
- DLCLOSE( cliLib );
479
- return rc;
480
- }
481
-
482
- /*
483
- This function calls SQLPrepare cli call to prepare the given statement
484
- */
485
- int _ruby_ibm_db_SQLPrepare_helper(exec_cum_prepare_args *data) {
486
- int rc = 0;
487
-
488
- data->stmt_res->is_executing = 1;
489
-
490
- #ifndef UNICODE_SUPPORT_VERSION
491
- rc = SQLPrepare( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
492
- #else
493
- rc = SQLPrepareW( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
494
- #endif
495
-
496
- data->stmt_res->is_executing = 0;
497
-
498
- return rc;
499
- }
500
-
501
- /*
502
- This function calls SQLFreeStmt to end processing on the statement referenced by statement handle
503
- */
504
- int _ruby_ibm_db_SQLFreeStmt_helper(free_stmt_args *data) {
505
- int rc = 0;
506
-
507
- data->stmt_res->is_executing = 1;
508
-
509
- SQLFreeStmt((SQLHSTMT)data->stmt_res->hstmt, data->option );
510
-
511
- data->stmt_res->is_executing = 0;
512
-
513
- return rc;
514
- }
515
-
516
- /*
517
- This function calls SQLExecute cli call to execute the prepared
518
- */
519
- int _ruby_ibm_db_SQLExecute_helper(stmt_handle *stmt_res) {
520
- int rc = 0;
521
-
522
- stmt_res->is_executing = 1;
523
-
524
- rc = SQLExecute( (SQLHSTMT) stmt_res->hstmt );
525
-
526
- stmt_res->is_executing = 0;
527
-
528
- return rc;
529
- }
530
-
531
- /*
532
- This function calls SQLParamData cli call to read if there is still data to be sent
533
- */
534
- int _ruby_ibm_db_SQLParamData_helper(param_cum_put_data_args *data) {
535
- int rc = 0;
536
-
537
- data->stmt_res->is_executing = 1;
538
-
539
- rc = SQLParamData( (SQLHSTMT) data->stmt_res->hstmt, (SQLPOINTER *) &(data->valuePtr) );
540
-
541
- data->stmt_res->is_executing = 0;
542
-
543
- return rc;
544
- }
545
-
546
- /*
547
- This function calls SQLColAttributes cli call to get the specified attribute of the column in result set
548
- */
549
- int _ruby_ibm_db_SQLColAttributes_helper(col_attr_args *data) {
550
- int rc = 0;
551
-
552
- data->stmt_res->is_executing = 1;
553
-
554
- rc = SQLColAttributes( (SQLHSTMT) data->stmt_res->hstmt, data->col_num,
555
- data->FieldIdentifier, NULL, 0, NULL, &(data->num_attr) );
556
-
557
- data->stmt_res->is_executing = 0;
558
-
559
- return rc;
560
- }
561
-
562
- /*
563
- This function calls SQLPutData cli call to supply parameter data value
564
- */
565
- int _ruby_ibm_db_SQLPutData_helper(param_cum_put_data_args *data) {
566
- int rc = 0;
567
-
568
- data->stmt_res->is_executing = 1;
569
-
570
- rc = SQLPutData( (SQLHSTMT) data->stmt_res->hstmt, (SQLPOINTER)(((param_node*)(data->valuePtr))->svalue),
571
- ((param_node*)(data->valuePtr))->ivalue );
572
-
573
- data->stmt_res->is_executing = 0;
574
-
575
- return rc;
576
- }
577
-
578
- /*
579
- This function calls SQLGetData cli call to retrieve data for a single column
580
- */
581
- int _ruby_ibm_db_SQLGetData_helper(get_data_args *data) {
582
- int rc = 0;
583
-
584
- data->stmt_res->is_executing = 1;
585
-
586
- rc = SQLGetData( (SQLHSTMT) data->stmt_res->hstmt, data->col_num, data->targetType, data->buff,
587
- data->buff_length, data->out_length);
588
-
589
- data->stmt_res->is_executing = 0;
590
-
591
- return rc;
592
- }
593
-
594
- /*
595
- This function calls SQLGetLength cli call to retrieve the length of the lob value
596
- */
597
- int _ruby_ibm_db_SQLGetLength_helper(get_length_args *data) {
598
- int col_num = data->col_num;
599
- int rc = 0;
600
-
601
- data->stmt_res->is_executing = 1;
602
-
603
- rc = SQLGetLength( (SQLHSTMT) *( data->new_hstmt ), data->stmt_res->column_info[col_num-1].loc_type,
604
- data->stmt_res->column_info[col_num-1].lob_loc, data->sLength,
605
- &(data->stmt_res->column_info[col_num-1].loc_ind) );
606
-
607
- data->stmt_res->is_executing = 0;
608
-
609
- return rc;
610
- }
611
-
612
- /*
613
- This function calls SQLGetSubString cli call to retrieve portion of the lob value
614
- */
615
- int _ruby_ibm_db_SQLGetSubString_helper(get_subString_args *data) {
616
- int col_num = data->col_num;
617
- int rc = 0;
618
-
619
- data->stmt_res->is_executing = 1;
620
-
621
- rc = SQLGetSubString( (SQLHSTMT) *( data->new_hstmt ), data->stmt_res->column_info[col_num-1].loc_type,
622
- data->stmt_res->column_info[col_num-1].lob_loc, 1, data->forLength, data->targetCType,
623
- data->buffer, data->buff_length, data->out_length,
624
- &(data->stmt_res->column_info[col_num-1].loc_ind) );
625
-
626
- data->stmt_res->is_executing = 0;
627
-
628
- return rc;
629
- }
630
-
631
- /*
632
- This function calls SQLNextResult cli call to fetch the multiple result sets that might be returned by a stored Proc
633
- */
634
- int _ruby_ibm_db_SQLNextResult_helper(next_result_args *data) {
635
- int rc = 0;
636
-
637
- data->stmt_res->is_executing = 1;
638
-
639
- rc = SQLNextResult( (SQLHSTMT) data->stmt_res->hstmt, (SQLHSTMT) *(data->new_hstmt) );
640
-
641
- data->stmt_res->is_executing = 0;
642
-
643
- return rc;
644
- }
645
-
646
- /*
647
- This function calls SQLFetchScroll cli call to fetch the specified rowset of data from result
648
- */
649
- int _ruby_ibm_db_SQLFetchScroll_helper(fetch_data_args *data) {
650
- int rc = 0;
651
-
652
- data->stmt_res->is_executing = 1;
653
-
654
- rc = SQLFetchScroll( (SQLHSTMT) data->stmt_res->hstmt, data->fetchOrientation, data->fetchOffset);
655
-
656
- data->stmt_res->is_executing = 0;
657
-
658
- return rc;
659
- }
660
-
661
- /*
662
- This function calls SQLFetch cli call to advance the cursor to
663
- the next row of the result set, and retrieves any bound columns
664
- */
665
- int _ruby_ibm_db_SQLFetch_helper(fetch_data_args *data) {
666
- int rc = 0;
667
-
668
- data->stmt_res->is_executing = 1;
669
-
670
- rc = SQLFetch( (SQLHSTMT) data->stmt_res->hstmt );
671
-
672
- data->stmt_res->is_executing = 0;
673
-
674
- return rc;
675
- }
676
-
677
- /*
678
- This function calls SQLNumResultCols cli call to fetch the number of fields contained in a result set
679
- */
680
- int _ruby_ibm_db_SQLNumResultCols_helper(row_col_count_args *data) {
681
- int rc = 0;
682
-
683
- data->stmt_res->is_executing = 1;
684
-
685
- rc = SQLNumResultCols( (SQLHSTMT) data->stmt_res->hstmt, (SQLSMALLINT*) &(data->count) );
686
-
687
- data->stmt_res->is_executing = 0;
688
-
689
- return rc;
690
- }
691
-
692
- /*
693
- This function calls SQLNumParams cli call to fetch the number of parameter markers in an SQL statement
694
- */
695
- int _ruby_ibm_db_SQLNumParams_helper(row_col_count_args *data) {
696
- int rc = 0;
697
-
698
- data->stmt_res->is_executing = 1;
699
-
700
- rc = SQLNumParams( (SQLHSTMT) data->stmt_res->hstmt, (SQLSMALLINT*) &(data->count) );
701
-
702
- data->stmt_res->is_executing = 0;
703
-
704
- return rc;
705
- }
706
-
707
- /*
708
- This function calls SQLRowCount cli call to fetch the number of rows affected by the SQL statement
709
- */
710
- int _ruby_ibm_db_SQLRowCount_helper(sql_row_count_args *data) {
711
- int rc = 0;
712
-
713
- data->stmt_res->is_executing = 1;
714
-
715
- rc = SQLRowCount( (SQLHSTMT) data->stmt_res->hstmt, (SQLLEN*) &(data->count) );
716
-
717
- data->stmt_res->is_executing = 0;
718
-
719
- return rc;
720
- }
721
-
722
- /*
723
- This function calls SQLGetInfo cli call to get general information about DBMS, which the app is connected to
724
- */
725
- int _ruby_ibm_db_SQLGetInfo_helper(get_info_args *data) {
726
- #ifndef UNICODE_SUPPORT_VERSION
727
- return SQLGetInfo( data->conn_res->hdbc, data->infoType, data->infoValue, data->buff_length, data->out_length);
728
- #else
729
- return SQLGetInfoW( data->conn_res->hdbc, data->infoType, data->infoValue, data->buff_length, data->out_length);
730
- #endif
731
- }
732
-
733
- /*
734
- This function calls SQLGetDiagRec cli call to get the current values of a diagnostic record that contains error
735
- */
736
- int _ruby_ibm_db_SQLGetDiagRec_helper(get_diagRec_args *data) {
737
- #ifdef UNICODE_SUPPORT_VERSION
738
- return SQLGetDiagRecW( data->hType, data->handle, data->recNum, data->SQLState, data->NativeErrorPtr,
739
- data->msgText, data->buff_length, data->text_length_ptr );
740
- #else
741
- return SQLGetDiagRec(data->hType, data->handle, data->recNum, data->SQLState, data->NativeErrorPtr,
742
- data->msgText, data->buff_length, data->text_length_ptr );
743
- #endif
744
- }
745
-
746
- /*
747
- This function calls SQLSetStmtAttr cli call to set attributes related to a statement
748
- */
749
- int _ruby_ibm_db_SQLSetStmtAttr_helper(set_handle_attr_args *data) {
750
- #ifndef UNICODE_SUPPORT_VERSION
751
- return SQLSetStmtAttr( (SQLHSTMT) *(data->handle), data->attribute, data->valuePtr, data->strLength );
752
- #else
753
- return SQLSetStmtAttrW( (SQLHSTMT) *(data->handle), data->attribute, data->valuePtr, data->strLength );
754
- #endif
755
- }
756
-
757
- /*
758
- This function calls SQLSetConnectAttr cli call to set attributes that govern aspects of connections
759
- */
760
- int _ruby_ibm_db_SQLSetConnectAttr_helper(set_handle_attr_args *data) {
761
- #ifndef UNICODE_SUPPORT_VERSION
762
- return SQLSetConnectAttr( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr, data->strLength );
763
- #else
764
- return SQLSetConnectAttrW( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr, data->strLength );
765
- #endif
766
- }
767
-
768
- /*
769
- This function calls SQLSetEnvAttr cli call to set an environment attribute
770
- */
771
- int _ruby_ibm_db_SQLSetEnvAttr_helper(set_handle_attr_args *data) {
772
- return SQLSetEnvAttr( (SQLHENV) *(data->handle), data->attribute, data->valuePtr, data->strLength);
773
- }
774
-
775
- /*
776
- This function calls SQLGetStmtAttr cli call to set an environment attribute
777
-
778
- The unicode equivalent of SQLGetStmtAttr is not used because the attributes being retrieved currently are not of type char or binary (SQL_IS_INTEGER). If support for retrieving a string type is provided then use the SQLGetStmtAttrW function accordingly
779
- In get_last_serial_id although we are retrieving a char type, it is converted back to an integer (atoi). The char to integer conversion function in unicode equivalent will be more complicated and is unnecessary for this case.
780
-
781
- */
782
- int _ruby_ibm_db_SQLGetStmtAttr_helper(get_handle_attr_args *data) {
783
- return SQLGetStmtAttr( (SQLHSTMT) *(data->handle), data->attribute, data->valuePtr,
784
- data->buff_length, data->out_length);
785
- }
786
-
787
- /*
788
- This function calls SQLGetConnectAttr cli call to set an environment attribute
789
- */
790
- int _ruby_ibm_db_SQLGetConnectAttr_helper(get_handle_attr_args *data) {
791
- #ifndef UNICODE_SUPPORT_VERSION
792
- return SQLGetConnectAttr( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr,
793
- data->buff_length, data->out_length);
794
- #else
795
- return SQLGetConnectAttrW( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr,
796
- data->buff_length, data->out_length);
797
- #endif
798
- }
799
-
800
- /*
801
- This function calls SQLBindFileToParam cli call
802
- */
803
- int _ruby_ibm_db_SQLBindFileToParam_helper(stmt_handle *stmt_res, param_node *curr) {
804
- int rc = 0;
805
-
806
- stmt_res->is_executing = 1;
807
-
808
- rc = SQLBindFileToParam( (SQLHSTMT)stmt_res->hstmt, curr->param_num,
809
- curr->data_type, (SQLCHAR*)curr->svalue,
810
- (SQLSMALLINT*)&(curr->ivalue), &(curr->file_options),
811
- curr->ivalue, &(curr->bind_indicator) );
812
-
813
- stmt_res->is_executing = 0;
814
-
815
- return rc;
816
- }
817
-
818
- /*
819
- This function calls SQLBindParameter cli call
820
- */
821
- int _ruby_ibm_db_SQLBindParameter_helper(bind_parameter_args *data) {
822
- int rc = 0;
823
-
824
- data->stmt_res->is_executing = 1;
825
-
826
- rc = SQLBindParameter( (SQLHSTMT) data->stmt_res->hstmt, data->param_num, data->IOType, data->valueType,
827
- data->paramType, data->colSize, data->decimalDigits, data->paramValPtr, data->buff_length,
828
- data->out_length );
829
-
830
- data->stmt_res->is_executing = 0;
831
-
832
- return rc;
833
- }
834
-
835
- /*
836
- Statement level thread unblock function. This fuction cancels a statement level SQL call issued when requested for,
837
- allowing for a safe interrupt of the thread.
838
- */
839
- void _ruby_ibm_db_Statement_level_UBF(stmt_handle *stmt_res) {
840
- int rc = 0;
841
- if( stmt_res->is_executing == 1 ) {
842
- rc = SQLCancel( (SQLHSTMT) stmt_res->hstmt );
843
- }
844
- return;
845
- }
1
+ /*
2
+ +----------------------------------------------------------------------+
3
+ | Licensed Materials - Property of IBM |
4
+ | |
5
+ | (C) Copyright IBM Corporation 2009 - 2015 |
6
+ +----------------------------------------------------------------------+
7
+ | Authors: Praveen Devarao, Arvind Gupta |
8
+ +----------------------------------------------------------------------+
9
+ */
10
+
11
+
12
+ /*
13
+ This C file contains functions that perform DB operations, which can take long time to complete.
14
+ For Eg: - Like SQLConnect, SQLFetch etc.
15
+
16
+ This file in general will contain functions that make CLI calls and
17
+ depending on whether the call will be transferred to server or not the functions are termed long time comsuming or not.
18
+
19
+ The functions which will contact the server and hence can be time consuming will be called by ruby's (1.9 onwards)
20
+ rb_thread_blocking_region method, which inturn will release the GVL while these operations are being performed.
21
+ With this the executing thread will become unblocking allowing concurrent threads perform operations simultaneously.
22
+ */
23
+
24
+ #include "ruby.h"
25
+
26
+ #include "ruby_ibm_db_cli.h"
27
+
28
+ /*
29
+ This function connects to the database using either SQLConnect or SQLDriverConnect CLI API
30
+ depending on whether it is a cataloged or an uncataloged connection.
31
+ */
32
+ int _ruby_ibm_db_SQLConnect_helper(connect_args *data) {
33
+ if(data->ctlg_conn == 1) {
34
+ #ifndef UNICODE_SUPPORT_VERSION
35
+ return SQLConnect( (SQLHDBC)*(data->hdbc), (SQLCHAR *)data->database,
36
+ (SQLSMALLINT)data->database_len, (SQLCHAR *)data->uid, (SQLSMALLINT)data->uid_len,
37
+ (SQLCHAR *)data->password, (SQLSMALLINT)data->password_len );
38
+ #else
39
+ return SQLConnectW( (SQLHDBC)*(data->hdbc), data->database,
40
+ data->database_len, data->uid, data->uid_len,
41
+ data->password, data->password_len );
42
+ #endif
43
+ } else {
44
+ #ifndef UNICODE_SUPPORT_VERSION
45
+ return SQLDriverConnect( (SQLHDBC) *(data->hdbc), (SQLHWND)NULL,
46
+ (SQLCHAR*)data->database, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT );
47
+ #else
48
+ return SQLDriverConnectW( (SQLHDBC) *(data->hdbc), (SQLHWND)NULL,
49
+ data->database, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT );
50
+ #endif
51
+ }
52
+ }
53
+
54
+ /*
55
+ This function issues SQLDisconnect to disconnect from the Dataserver
56
+ */
57
+ int _ruby_ibm_db_SQLDisconnect_helper(SQLHANDLE *hdbc) {
58
+ return SQLDisconnect( (SQLHDBC) *hdbc );
59
+ }
60
+
61
+ /*
62
+ Connection level Unblock function. This function is called when a thread interruput is issued while executing a
63
+ connection level SQL call
64
+ */
65
+ void _ruby_ibm_db_Connection_level_UBF(void *data) {
66
+ return;
67
+ }
68
+
69
+ /*
70
+ This function will commit and end the inprogress transaction by issuing a SQLCommit
71
+ */
72
+ int _ruby_ibm_db_SQLEndTran(end_tran_args *endtran_args) {
73
+ int rc = 0;
74
+ rc = SQLEndTran( endtran_args->handleType, *(endtran_args->hdbc), endtran_args->completionType );
75
+ endtran_args->rc = rc;
76
+ return rc;
77
+ }
78
+
79
+ /*
80
+ This function call the SQLDescribeParam cli call to get the description of the parameter in the sql specified
81
+ */
82
+ int _ruby_ibm_db_SQLDescribeParam_helper(describeparam_args *data) {
83
+ int rc = 0;
84
+ data->stmt_res->is_executing = 1;
85
+
86
+ rc = SQLDescribeParam( (SQLHSTMT) data->stmt_res->hstmt, (SQLUSMALLINT)data->param_no, &(data->sql_data_type),
87
+ &(data->sql_precision), &(data->sql_scale), &(data->sql_nullable) );
88
+
89
+ data->stmt_res->is_executing = 0;
90
+ data->rc = rc;
91
+ return rc;
92
+ }
93
+
94
+ /*
95
+ This function call the SQLDescribeCol cli call to get the description of the parameter in the sql specified
96
+ */
97
+ int _ruby_ibm_db_SQLDescribeCol_helper(describecol_args *data) {
98
+ int i = data->col_no - 1;
99
+ int rc = 0;
100
+
101
+ data->stmt_res->is_executing = 1;
102
+
103
+ #ifdef UNICODE_SUPPORT_VERSION
104
+ rc = SQLDescribeColW( (SQLHSTMT)data->stmt_res->hstmt, (SQLSMALLINT)(data->col_no),
105
+ data->stmt_res->column_info[i].name, data->buff_length, &(data->name_length),
106
+ &(data->stmt_res->column_info[i].type), &(data->stmt_res->column_info[i].size),
107
+ &(data->stmt_res->column_info[i].scale), &(data->stmt_res->column_info[i].nullable) );
108
+ #else
109
+ rc = SQLDescribeCol( (SQLHSTMT)data->stmt_res->hstmt, (SQLSMALLINT)(data->col_no),
110
+ data->stmt_res->column_info[i].name, data->buff_length, &(data->name_length),
111
+ &(data->stmt_res->column_info[i].type), &(data->stmt_res->column_info[i].size),
112
+ &(data->stmt_res->column_info[i].scale), &(data->stmt_res->column_info[i].nullable) );
113
+ #endif
114
+
115
+ data->stmt_res->is_executing = 0;
116
+
117
+ return rc;
118
+ }
119
+
120
+ /*
121
+ This function call the SQLBindCol cli call to get the description of the parameter in the sql specified
122
+ */
123
+ int _ruby_ibm_db_SQLBindCol_helper(bind_col_args *data) {
124
+ int rc = 0;
125
+ data->stmt_res->is_executing = 1;
126
+
127
+ rc = SQLBindCol( (SQLHSTMT) data->stmt_res->hstmt, (SQLUSMALLINT)(data->col_num),
128
+ data->TargetType, data->TargetValuePtr, data->buff_length,
129
+ data->out_length );
130
+
131
+ data->stmt_res->is_executing = 0;
132
+ return rc;
133
+ }
134
+
135
+ /*
136
+ This function calls SQLColumnPrivileges cli call to get the list of columns and the associated privileges
137
+ */
138
+ int _ruby_ibm_db_SQLColumnPrivileges_helper(metadata_args *data) {
139
+ int rc = 0;
140
+
141
+ data->stmt_res->is_executing = 1;
142
+
143
+ #ifndef UNICODE_SUPPORT_VERSION
144
+ rc = SQLColumnPrivileges( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
145
+ data->owner, data->owner_len, data->table_name, data->table_name_len,
146
+ data->column_name, data->column_name_len );
147
+ #else
148
+ rc = SQLColumnPrivilegesW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
149
+ data->owner, data->owner_len, data->table_name, data->table_name_len,
150
+ data->column_name, data->column_name_len );
151
+ #endif
152
+
153
+ data->stmt_res->is_executing = 0;
154
+ data->rc=rc;
155
+ return rc;
156
+
157
+ }
158
+
159
+ /*
160
+ This function calls SQLColumns cli call to get the list of columns and the associated metadata of the table
161
+ */
162
+ int _ruby_ibm_db_SQLColumns_helper(metadata_args *data) {
163
+ int rc = 0;
164
+
165
+ data->stmt_res->is_executing = 1;
166
+
167
+ #ifndef UNICODE_SUPPORT_VERSION
168
+ rc = SQLColumns( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
169
+ data->owner, data->owner_len, data->table_name, data->table_name_len,
170
+ data->column_name, data->column_name_len );
171
+ #else
172
+ rc = SQLColumnsW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
173
+ data->owner, data->owner_len, data->table_name, data->table_name_len,
174
+ data->column_name, data->column_name_len );
175
+ #endif
176
+
177
+ data->stmt_res->is_executing = 0;
178
+ data->rc = rc;
179
+ return rc;
180
+ }
181
+
182
+ /*
183
+ This function calls SQLPrimaryKeys cli call to get the list of primay key columns and the associated metadata
184
+ */
185
+ int _ruby_ibm_db_SQLPrimaryKeys_helper(metadata_args *data) {
186
+ int rc = 0;
187
+
188
+ data->stmt_res->is_executing = 1;
189
+
190
+ #ifndef UNICODE_SUPPORT_VERSION
191
+ rc = SQLPrimaryKeys( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
192
+ data->owner, data->owner_len, data->table_name, data->table_name_len );
193
+ #else
194
+ rc = SQLPrimaryKeysW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
195
+ data->owner, data->owner_len, data->table_name, data->table_name_len );
196
+ #endif
197
+
198
+ data->stmt_res->is_executing = 0;
199
+ data->rc = rc;
200
+ return rc;
201
+ }
202
+
203
+ /*
204
+ This function calls SQLForeignKeys cli call to get the list of foreign key columns and the associated metadata
205
+ */
206
+ int _ruby_ibm_db_SQLForeignKeys_helper(metadata_args *data) {
207
+ int rc = 0;
208
+
209
+ data->stmt_res->is_executing = 1;
210
+
211
+ #ifndef UNICODE_SUPPORT_VERSION
212
+ rc = SQLForeignKeys( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
213
+ data->owner, data->owner_len, data->table_name , data->table_name_len, NULL, SQL_NTS,
214
+ NULL, SQL_NTS, NULL, SQL_NTS );
215
+ #else
216
+ rc = SQLForeignKeysW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
217
+ data->owner, data->owner_len, data->table_name , data->table_name_len, NULL, SQL_NTS,
218
+ NULL, SQL_NTS, NULL, SQL_NTS );
219
+ #endif
220
+
221
+ data->stmt_res->is_executing = 0;
222
+ data->rc = rc;
223
+ return rc;
224
+ }
225
+
226
+ /*
227
+ This function calls SQLProcedureColumns cli call to get the list of parameters
228
+ and associated metadata of the stored procedure
229
+ */
230
+ int _ruby_ibm_db_SQLProcedureColumns_helper(metadata_args *data) {
231
+ int rc = 0;
232
+
233
+ data->stmt_res->is_executing = 1;
234
+
235
+ #ifndef UNICODE_SUPPORT_VERSION
236
+ rc = SQLProcedureColumns( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
237
+ data->owner_len, data->proc_name, data->proc_name_len, data->column_name, data->column_name_len );
238
+ #else
239
+ rc = SQLProcedureColumnsW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
240
+ data->owner_len, data->proc_name, data->proc_name_len, data->column_name, data->column_name_len );
241
+ #endif
242
+
243
+ data->stmt_res->is_executing = 0;
244
+ data->rc = rc;
245
+ return rc;
246
+ }
247
+
248
+ /*
249
+ This function calls SQLProcedures cli call to get the list of stored procedures
250
+ and associated metadata of the stored procedure
251
+ */
252
+ int _ruby_ibm_db_SQLProcedures_helper(metadata_args *data) {
253
+ int rc = 0;
254
+
255
+ data->stmt_res->is_executing = 1;
256
+
257
+ #ifndef UNICODE_SUPPORT_VERSION
258
+ rc = SQLProcedures( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
259
+ data->owner_len, data->proc_name, data->proc_name_len );
260
+ #else
261
+ rc = SQLProceduresW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
262
+ data->owner_len, data->proc_name, data->proc_name_len );
263
+ #endif
264
+
265
+ data->stmt_res->is_executing = 0;
266
+ data->rc = rc;
267
+ return rc;
268
+ }
269
+
270
+ /*
271
+ This function calls SQLSpecialColumns cli call to get the metadata related to the special columns
272
+ (Unique index or primary key column) and associated metadata
273
+ */
274
+ int _ruby_ibm_db_SQLSpecialColumns_helper(metadata_args *data) {
275
+ int rc = 0;
276
+
277
+ data->stmt_res->is_executing = 1;
278
+
279
+ #ifndef UNICODE_SUPPORT_VERSION
280
+ rc = SQLSpecialColumns( (SQLHSTMT) data->stmt_res->hstmt, SQL_BEST_ROWID, data->qualifier, data->qualifier_len,
281
+ data->owner, data->owner_len, data->table_name, data->table_name_len,
282
+ (SQLUSMALLINT)data->scope, SQL_NULLABLE );
283
+ #else
284
+ rc = SQLSpecialColumnsW( (SQLHSTMT) data->stmt_res->hstmt, SQL_BEST_ROWID, data->qualifier, data->qualifier_len,
285
+ data->owner, data->owner_len, data->table_name, data->table_name_len,
286
+ (SQLUSMALLINT)data->scope, SQL_NULLABLE );
287
+ #endif
288
+
289
+ data->stmt_res->is_executing = 0;
290
+ data->rc = rc;
291
+ return rc;
292
+ }
293
+
294
+ /*
295
+ This function calls SQLStatistics cli call to get the index information for a given table.
296
+ */
297
+ int _ruby_ibm_db_SQLStatistics_helper(metadata_args *data) {
298
+ int rc = 0;
299
+
300
+ data->stmt_res->is_executing = 1;
301
+
302
+ #ifndef UNICODE_SUPPORT_VERSION
303
+ rc = SQLStatistics( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
304
+ data->owner_len, data->table_name, data->table_name_len, (SQLUSMALLINT)data->unique, SQL_QUICK );
305
+ #else
306
+ rc = SQLStatisticsW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
307
+ data->owner_len, data->table_name, data->table_name_len, (SQLUSMALLINT)data->unique, SQL_QUICK );
308
+ #endif
309
+
310
+ data->stmt_res->is_executing = 0;
311
+ data->rc= rc;
312
+ return rc;
313
+ }
314
+
315
+ /*
316
+ This function calls SQLTablePrivileges cli call to retrieve list of tables and
317
+ the asscociated privileges for each table.
318
+ */
319
+ int _ruby_ibm_db_SQLTablePrivileges_helper(metadata_args *data) {
320
+ int rc = 0;
321
+
322
+ data->stmt_res->is_executing = 1;
323
+
324
+ #ifndef UNICODE_SUPPORT_VERSION
325
+ rc = SQLTablePrivileges( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
326
+ data->owner, data->owner_len, data->table_name, data->table_name_len );
327
+ #else
328
+ rc = SQLTablePrivilegesW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len,
329
+ data->owner, data->owner_len, data->table_name, data->table_name_len );
330
+ #endif
331
+
332
+ data->stmt_res->is_executing = 0;
333
+ data->rc = rc;
334
+ return rc;
335
+ }
336
+
337
+ /*
338
+ This function calls SQLTables cli call to retrieve list of tables in the specified schema and
339
+ the asscociated metadata for each table.
340
+ */
341
+ int _ruby_ibm_db_SQLTables_helper(metadata_args *data) {
342
+ int rc = 0;
343
+
344
+ data->stmt_res->is_executing = 1;
345
+
346
+ #ifndef UNICODE_SUPPORT_VERSION
347
+ rc = SQLTables( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
348
+ data->owner_len, data->table_name, data->table_name_len, data->table_type, data->table_type_len );
349
+ #else
350
+ rc = SQLTablesW( (SQLHSTMT) data->stmt_res->hstmt, data->qualifier, data->qualifier_len, data->owner,
351
+ data->owner_len, data->table_name, data->table_name_len, data->table_type, data->table_type_len );
352
+ #endif
353
+
354
+ data->stmt_res->is_executing = 0;
355
+ data->rc = rc;
356
+ return rc;
357
+ }
358
+
359
+ /*
360
+ This function calls SQLExecDirect cli call to execute a statement directly
361
+ */
362
+ int _ruby_ibm_db_SQLExecDirect_helper(exec_cum_prepare_args *data) {
363
+ int rc = 0;
364
+
365
+ data->stmt_res->is_executing = 1;
366
+
367
+ #ifndef UNICODE_SUPPORT_VERSION
368
+ rc = SQLExecDirect( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
369
+ #else
370
+ rc = SQLExecDirectW( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
371
+ #endif
372
+
373
+ data->stmt_res->is_executing = 0;
374
+ data->rc=rc;
375
+ return rc;
376
+ }
377
+
378
+ /*
379
+ This function calls SQLCreateDb cli call
380
+ */
381
+ int _ruby_ibm_db_SQLCreateDB_helper(create_drop_db_args *data) {
382
+ int rc = 0;
383
+ #ifndef UNICODE_SUPPORT_VERSION
384
+ #ifdef _WIN32
385
+ HINSTANCE cliLib = NULL;
386
+ FARPROC sqlcreatedb;
387
+ cliLib = DLOPEN( LIBDB2 );
388
+ sqlcreatedb = DLSYM( cliLib, "SQLCreateDb" );
389
+ #elif _AIX
390
+ void *cliLib = NULL;
391
+ typedef int (*sqlcreatedbType)( SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER );
392
+ sqlcreatedbType sqlcreatedb;
393
+ /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
394
+ cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
395
+ sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDb" );
396
+ #else
397
+ void *cliLib = NULL;
398
+ typedef int (*sqlcreatedbType)( SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER );
399
+ sqlcreatedbType sqlcreatedb;
400
+ cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
401
+ sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDb" );
402
+ #endif
403
+ #else
404
+ #ifdef _WIN32
405
+ HINSTANCE cliLib = NULL;
406
+ FARPROC sqlcreatedb;
407
+ cliLib = DLOPEN( LIBDB2 );
408
+ sqlcreatedb = DLSYM( cliLib, "SQLCreateDbW" );
409
+ #elif _AIX
410
+ void *cliLib = NULL;
411
+ typedef int (*sqlcreatedbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER );
412
+ sqlcreatedbType sqlcreatedb;
413
+ /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
414
+ cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
415
+ sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDbW" );
416
+ #else
417
+ void *cliLib = NULL;
418
+ typedef int (*sqlcreatedbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER );
419
+ sqlcreatedbType sqlcreatedb;
420
+ cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
421
+ sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDbW" );
422
+ #endif
423
+ #endif
424
+
425
+ rc = (*sqlcreatedb)( (SQLHSTMT) data->conn_res->hdbc, data->dbName, (SQLINTEGER)data->dbName_string_len,
426
+ data->codeSet, (SQLINTEGER)data->codeSet_string_len,
427
+ data->mode, (SQLINTEGER)data->mode_string_len );
428
+ data->rc =rc;
429
+ DLCLOSE( cliLib );
430
+ return rc;
431
+ }
432
+
433
+ /*
434
+ This function calls SQLDropDb cli call
435
+ */
436
+ int _ruby_ibm_db_SQLDropDB_helper(create_drop_db_args *data) {
437
+ int rc = 0;
438
+ #ifndef UNICODE_SUPPORT_VERSION
439
+ #ifdef _WIN32
440
+ HINSTANCE cliLib = NULL;
441
+ FARPROC sqldropdb;
442
+ cliLib = DLOPEN( LIBDB2 );
443
+ sqldropdb = DLSYM( cliLib, "SQLDropDb" );
444
+ #elif _AIX
445
+ void *cliLib = NULL;
446
+ typedef int (*sqldropdbType)( SQLHDBC, SQLCHAR *, SQLINTEGER);
447
+ sqldropdbType sqldropdb;
448
+ /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
449
+ cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
450
+ sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDb" );
451
+ #else
452
+ void *cliLib = NULL;
453
+ typedef int (*sqldropdbType)( SQLHDBC, SQLCHAR *, SQLINTEGER);
454
+ sqldropdbType sqldropdb;
455
+ cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
456
+ sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDb" );
457
+ #endif
458
+ #else
459
+ #ifdef _WIN32
460
+ HINSTANCE cliLib = NULL;
461
+ FARPROC sqldropdb;
462
+ cliLib = DLOPEN( LIBDB2 );
463
+ sqldropdb = DLSYM( cliLib, "SQLDropDbW" );
464
+ #elif _AIX
465
+ void *cliLib = NULL;
466
+ typedef int (*sqldropdbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER);
467
+ sqldropdbType sqldropdb;
468
+ /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
469
+ cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
470
+ sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDbW" );
471
+ #else
472
+ void *cliLib = NULL;
473
+ typedef int (*sqldropdbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER);
474
+ sqldropdbType sqldropdb;
475
+ cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
476
+ sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDbW" );
477
+ #endif
478
+ #endif
479
+
480
+ rc = (*sqldropdb)( (SQLHSTMT) data->conn_res->hdbc, data->dbName, (SQLINTEGER)data->dbName_string_len );
481
+
482
+ DLCLOSE( cliLib );
483
+ return rc;
484
+ }
485
+
486
+ /*
487
+ This function calls SQLPrepare cli call to prepare the given statement
488
+ */
489
+ int _ruby_ibm_db_SQLPrepare_helper(exec_cum_prepare_args *data) {
490
+ int rc = 0;
491
+
492
+ data->stmt_res->is_executing = 1;
493
+
494
+ #ifndef UNICODE_SUPPORT_VERSION
495
+ rc = SQLPrepare( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
496
+ #else
497
+ rc = SQLPrepareW( (SQLHSTMT) data->stmt_res->hstmt, data->stmt_string, (SQLINTEGER)data->stmt_string_len );
498
+ #endif
499
+
500
+ data->stmt_res->is_executing = 0;
501
+
502
+ return rc;
503
+ }
504
+
505
+ /*
506
+ This function calls SQLFreeStmt to end processing on the statement referenced by statement handle
507
+ */
508
+ int _ruby_ibm_db_SQLFreeStmt_helper(free_stmt_args *data) {
509
+ int rc = 0;
510
+
511
+ data->stmt_res->is_executing = 1;
512
+
513
+ rc = SQLFreeStmt((SQLHSTMT)data->stmt_res->hstmt, data->option );
514
+
515
+ data->stmt_res->is_executing = 0;
516
+ data->rc = rc;
517
+ return rc;
518
+ }
519
+
520
+ /*
521
+ This function calls SQLExecute cli call to execute the prepared
522
+ */
523
+ int _ruby_ibm_db_SQLExecute_helper(stmt_handle *stmt_res) {
524
+ int rc = 0;
525
+
526
+ stmt_res->is_executing = 1;
527
+
528
+ rc = SQLExecute( (SQLHSTMT) stmt_res->hstmt );
529
+
530
+ stmt_res->is_executing = 0;
531
+
532
+ return rc;
533
+ }
534
+
535
+ /*
536
+ This function calls SQLParamData cli call to read if there is still data to be sent
537
+ */
538
+ int _ruby_ibm_db_SQLParamData_helper(param_cum_put_data_args *data) {
539
+ int rc = 0;
540
+
541
+ data->stmt_res->is_executing = 1;
542
+
543
+ rc = SQLParamData( (SQLHSTMT) data->stmt_res->hstmt, (SQLPOINTER *) &(data->valuePtr) );
544
+
545
+ data->stmt_res->is_executing = 0;
546
+
547
+ return rc;
548
+ }
549
+
550
+ /*
551
+ This function calls SQLColAttributes cli call to get the specified attribute of the column in result set
552
+ */
553
+ int _ruby_ibm_db_SQLColAttributes_helper(col_attr_args *data) {
554
+ int rc = 0;
555
+
556
+ data->stmt_res->is_executing = 1;
557
+
558
+ rc = SQLColAttributes( (SQLHSTMT) data->stmt_res->hstmt, data->col_num,
559
+ data->FieldIdentifier, NULL, 0, NULL, &(data->num_attr) );
560
+
561
+ data->stmt_res->is_executing = 0;
562
+ data->rc = rc;
563
+ return rc;
564
+ }
565
+
566
+ /*
567
+ This function calls SQLPutData cli call to supply parameter data value
568
+ */
569
+ int _ruby_ibm_db_SQLPutData_helper(param_cum_put_data_args *data) {
570
+ int rc = 0;
571
+
572
+ data->stmt_res->is_executing = 1;
573
+
574
+ rc = SQLPutData( (SQLHSTMT) data->stmt_res->hstmt, (SQLPOINTER)(((param_node*)(data->valuePtr))->svalue),
575
+ ((param_node*)(data->valuePtr))->ivalue );
576
+
577
+ data->stmt_res->is_executing = 0;
578
+
579
+ return rc;
580
+ }
581
+
582
+ /*
583
+ This function calls SQLGetData cli call to retrieve data for a single column
584
+ */
585
+ int _ruby_ibm_db_SQLGetData_helper(get_data_args *data) {
586
+ int rc = 0;
587
+
588
+ data->stmt_res->is_executing = 1;
589
+
590
+ rc = SQLGetData( (SQLHSTMT) data->stmt_res->hstmt, data->col_num, data->targetType, data->buff,
591
+ data->buff_length, data->out_length);
592
+
593
+ data->stmt_res->is_executing = 0;
594
+
595
+ return rc;
596
+ }
597
+
598
+ /*
599
+ This function calls SQLGetLength cli call to retrieve the length of the lob value
600
+ */
601
+ int _ruby_ibm_db_SQLGetLength_helper(get_length_args *data) {
602
+ int col_num = data->col_num;
603
+ int rc = 0;
604
+
605
+ data->stmt_res->is_executing = 1;
606
+
607
+ rc = SQLGetLength( (SQLHSTMT) *( data->new_hstmt ), data->stmt_res->column_info[col_num-1].loc_type,
608
+ data->stmt_res->column_info[col_num-1].lob_loc, data->sLength,
609
+ &(data->stmt_res->column_info[col_num-1].loc_ind) );
610
+
611
+ data->stmt_res->is_executing = 0;
612
+
613
+ return rc;
614
+ }
615
+
616
+ /*
617
+ This function calls SQLGetSubString cli call to retrieve portion of the lob value
618
+ */
619
+ int _ruby_ibm_db_SQLGetSubString_helper(get_subString_args *data) {
620
+ int col_num = data->col_num;
621
+ int rc = 0;
622
+
623
+ data->stmt_res->is_executing = 1;
624
+
625
+ rc = SQLGetSubString( (SQLHSTMT) *( data->new_hstmt ), data->stmt_res->column_info[col_num-1].loc_type,
626
+ data->stmt_res->column_info[col_num-1].lob_loc, 1, data->forLength, data->targetCType,
627
+ data->buffer, data->buff_length, data->out_length,
628
+ &(data->stmt_res->column_info[col_num-1].loc_ind) );
629
+
630
+ data->stmt_res->is_executing = 0;
631
+
632
+ return rc;
633
+ }
634
+
635
+ /*
636
+ This function calls SQLNextResult cli call to fetch the multiple result sets that might be returned by a stored Proc
637
+ */
638
+ int _ruby_ibm_db_SQLNextResult_helper(next_result_args *data) {
639
+ int rc = 0;
640
+
641
+ data->stmt_res->is_executing = 1;
642
+
643
+ rc = SQLNextResult( (SQLHSTMT) data->stmt_res->hstmt, (SQLHSTMT) *(data->new_hstmt) );
644
+
645
+ data->stmt_res->is_executing = 0;
646
+ data->rc = rc;
647
+ return rc;
648
+ }
649
+
650
+ /*
651
+ This function calls SQLFetchScroll cli call to fetch the specified rowset of data from result
652
+ */
653
+ int _ruby_ibm_db_SQLFetchScroll_helper(fetch_data_args *data) {
654
+ int rc = 0;
655
+
656
+ data->stmt_res->is_executing = 1;
657
+
658
+ rc = SQLFetchScroll( (SQLHSTMT) data->stmt_res->hstmt, data->fetchOrientation, data->fetchOffset);
659
+
660
+ data->stmt_res->is_executing = 0;
661
+
662
+ return rc;
663
+ }
664
+
665
+ /*
666
+ This function calls SQLFetch cli call to advance the cursor to
667
+ the next row of the result set, and retrieves any bound columns
668
+ */
669
+ int _ruby_ibm_db_SQLFetch_helper(fetch_data_args *data) {
670
+ int rc = 0;
671
+
672
+ data->stmt_res->is_executing = 1;
673
+
674
+ rc = SQLFetch( (SQLHSTMT) data->stmt_res->hstmt );
675
+
676
+ data->stmt_res->is_executing = 0;
677
+
678
+ return rc;
679
+ }
680
+
681
+ /*
682
+ This function calls SQLNumResultCols cli call to fetch the number of fields contained in a result set
683
+ */
684
+ int _ruby_ibm_db_SQLNumResultCols_helper(row_col_count_args *data) {
685
+ int rc = 0;
686
+
687
+ data->stmt_res->is_executing = 1;
688
+
689
+ rc = SQLNumResultCols( (SQLHSTMT) data->stmt_res->hstmt, (SQLSMALLINT*) &(data->count) );
690
+
691
+ data->stmt_res->is_executing = 0;
692
+ data->rc = rc;
693
+ return rc;
694
+ }
695
+
696
+ /*
697
+ This function calls SQLNumParams cli call to fetch the number of parameter markers in an SQL statement
698
+ */
699
+ int _ruby_ibm_db_SQLNumParams_helper(row_col_count_args *data) {
700
+ int rc = 0;
701
+
702
+ data->stmt_res->is_executing = 1;
703
+
704
+ rc = SQLNumParams( (SQLHSTMT) data->stmt_res->hstmt, (SQLSMALLINT*) &(data->count) );
705
+
706
+ data->stmt_res->is_executing = 0;
707
+
708
+ return rc;
709
+ }
710
+
711
+ /*
712
+ This function calls SQLRowCount cli call to fetch the number of rows affected by the SQL statement
713
+ */
714
+ int _ruby_ibm_db_SQLRowCount_helper(sql_row_count_args *data) {
715
+ int rc = 0;
716
+
717
+ data->stmt_res->is_executing = 1;
718
+
719
+ rc = SQLRowCount( (SQLHSTMT) data->stmt_res->hstmt, (SQLLEN*) &(data->count) );
720
+
721
+ data->stmt_res->is_executing = 0;
722
+
723
+ return rc;
724
+ }
725
+
726
+ /*
727
+ This function calls SQLGetInfo cli call to get general information about DBMS, which the app is connected to
728
+ */
729
+ int _ruby_ibm_db_SQLGetInfo_helper(get_info_args *data) {
730
+ #ifndef UNICODE_SUPPORT_VERSION
731
+ return SQLGetInfo( data->conn_res->hdbc, data->infoType, data->infoValue, data->buff_length, data->out_length);
732
+ #else
733
+ return SQLGetInfoW( data->conn_res->hdbc, data->infoType, data->infoValue, data->buff_length, data->out_length);
734
+ #endif
735
+ }
736
+
737
+ /*
738
+ This function calls SQLGetDiagRec cli call to get the current values of a diagnostic record that contains error
739
+ */
740
+ int _ruby_ibm_db_SQLGetDiagRec_helper(get_diagRec_args *data) {
741
+ #ifdef UNICODE_SUPPORT_VERSION
742
+ int rc= SQLGetDiagRecW( data->hType, data->handle, data->recNum, data->SQLState, data->NativeErrorPtr,
743
+ data->msgText, data->buff_length, data->text_length_ptr );
744
+ data->return_code=rc;
745
+ return rc;
746
+ #else
747
+ return SQLGetDiagRec(data->hType, data->handle, data->recNum, data->SQLState, data->NativeErrorPtr,
748
+ data->msgText, data->buff_length, data->text_length_ptr );
749
+ #endif
750
+ }
751
+
752
+ /*
753
+ This function calls SQLSetStmtAttr cli call to set attributes related to a statement
754
+ */
755
+ int _ruby_ibm_db_SQLSetStmtAttr_helper(set_handle_attr_args *data) {
756
+ #ifndef UNICODE_SUPPORT_VERSION
757
+ return SQLSetStmtAttr( (SQLHSTMT) *(data->handle), data->attribute, data->valuePtr, data->strLength );
758
+ #else
759
+ return SQLSetStmtAttrW( (SQLHSTMT) *(data->handle), data->attribute, data->valuePtr, data->strLength );
760
+ #endif
761
+ }
762
+
763
+ /*
764
+ This function calls SQLSetConnectAttr cli call to set attributes that govern aspects of connections
765
+ */
766
+ int _ruby_ibm_db_SQLSetConnectAttr_helper(set_handle_attr_args *data) {
767
+ #ifndef UNICODE_SUPPORT_VERSION
768
+ return SQLSetConnectAttr( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr, data->strLength );
769
+ #else
770
+ return SQLSetConnectAttrW( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr, data->strLength );
771
+ #endif
772
+ }
773
+
774
+ /*
775
+ This function calls SQLSetEnvAttr cli call to set an environment attribute
776
+ */
777
+ int _ruby_ibm_db_SQLSetEnvAttr_helper(set_handle_attr_args *data) {
778
+ return SQLSetEnvAttr( (SQLHENV) *(data->handle), data->attribute, data->valuePtr, data->strLength);
779
+ }
780
+
781
+ /*
782
+ This function calls SQLGetStmtAttr cli call to set an environment attribute
783
+
784
+ The unicode equivalent of SQLGetStmtAttr is not used because the attributes being retrieved currently are not of type char or binary (SQL_IS_INTEGER). If support for retrieving a string type is provided then use the SQLGetStmtAttrW function accordingly
785
+ In get_last_serial_id although we are retrieving a char type, it is converted back to an integer (atoi). The char to integer conversion function in unicode equivalent will be more complicated and is unnecessary for this case.
786
+
787
+ */
788
+ int _ruby_ibm_db_SQLGetStmtAttr_helper(get_handle_attr_args *data) {
789
+ return SQLGetStmtAttr( (SQLHSTMT) *(data->handle), data->attribute, data->valuePtr,
790
+ data->buff_length, data->out_length);
791
+ }
792
+
793
+ /*
794
+ This function calls SQLGetConnectAttr cli call to set an environment attribute
795
+ */
796
+ int _ruby_ibm_db_SQLGetConnectAttr_helper(get_handle_attr_args *data) {
797
+ #ifndef UNICODE_SUPPORT_VERSION
798
+ return SQLGetConnectAttr( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr,
799
+ data->buff_length, data->out_length);
800
+ #else
801
+ return SQLGetConnectAttrW( (SQLHDBC) *(data->handle), data->attribute, data->valuePtr,
802
+ data->buff_length, data->out_length);
803
+ #endif
804
+ }
805
+
806
+ /*
807
+ This function calls SQLBindFileToParam cli call
808
+ */
809
+ int _ruby_ibm_db_SQLBindFileToParam_helper(stmt_handle *stmt_res, param_node *curr) {
810
+ int rc = 0;
811
+
812
+ stmt_res->is_executing = 1;
813
+
814
+ rc = SQLBindFileToParam( (SQLHSTMT)stmt_res->hstmt, curr->param_num,
815
+ curr->data_type, (SQLCHAR*)curr->svalue,
816
+ (SQLSMALLINT*)&(curr->ivalue), &(curr->file_options),
817
+ curr->ivalue, &(curr->bind_indicator) );
818
+
819
+ stmt_res->is_executing = 0;
820
+
821
+ return rc;
822
+ }
823
+
824
+ /*
825
+ This function calls SQLBindParameter cli call
826
+ */
827
+ int _ruby_ibm_db_SQLBindParameter_helper(bind_parameter_args *data) {
828
+ int rc = 0;
829
+
830
+ data->stmt_res->is_executing = 1;
831
+
832
+ rc = SQLBindParameter( (SQLHSTMT) data->stmt_res->hstmt, data->param_num, data->IOType, data->valueType,
833
+ data->paramType, data->colSize, data->decimalDigits, data->paramValPtr, data->buff_length,
834
+ data->out_length );
835
+
836
+ data->stmt_res->is_executing = 0;
837
+
838
+ return rc;
839
+ }
840
+
841
+ /*
842
+ Statement level thread unblock function. This fuction cancels a statement level SQL call issued when requested for,
843
+ allowing for a safe interrupt of the thread.
844
+ */
845
+ void _ruby_ibm_db_Statement_level_UBF(stmt_handle *stmt_res) {
846
+ int rc = 0;
847
+ if( stmt_res->is_executing == 1 ) {
848
+ rc = SQLCancel( (SQLHSTMT) stmt_res->hstmt );
849
+ }
850
+ return;
851
+ }