ruby-odbc 0.99995 → 0.999991

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 (14) hide show
  1. checksums.yaml +5 -5
  2. data/COPYING +1 -1
  3. data/ChangeLog +27 -0
  4. data/README +8 -6
  5. data/doc/odbc.html +18 -11
  6. data/ext/extconf.rb +38 -3
  7. data/ext/odbc.c +1189 -186
  8. data/ext/utf8/extconf.rb +5 -3
  9. data/ruby-odbc.gemspec +1 -1
  10. data/test/30select.rb +1 -1
  11. data/test/45delete.rb +8 -0
  12. data/test/test.rb +3 -3
  13. data/test/utf8/test.rb +3 -3
  14. metadata +20 -20
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
- SHA1:
3
- metadata.gz: c7479d33fa9c59ff9ddceda117a54eff5b755a40
4
- data.tar.gz: ffe877023d88272ddb59da531bf1fda03cdf6c35
2
+ SHA256:
3
+ metadata.gz: 860fc0eb5595959ec764079118f528b5b0afa5d49e919ab0f8c46e971bd7dbc0
4
+ data.tar.gz: 843b2f2427d1378489cbc6eea0cb3e3ce5daff17f42ac3a040a0a979f04dddae
5
5
  SHA512:
6
- metadata.gz: 95b9dd91fe942297cd879cfc83c82af7fe9a2aeaabcff01a65a9870b89886e8a7d729f8a2119241d46363282081bfeb9d8c0a21daf8836b619807deea947d0e8
7
- data.tar.gz: 328aa7cff9af2f30af215560abc65d947879468299e31e449d7c919cb146a84effde0f88e9816fd7633230c70ecded79417db8dae00d1cb882f76b114f2d6040
6
+ metadata.gz: 600c7ef68780fa4f3eae56dddd7ca01fa1cbd425b58a0c50663688bcefddc6b2471b79e0a51e044d95c570e531a91e4b883c5aa9b813c84c1997498e93024f5e
7
+ data.tar.gz: 020cd8f08ffce0d846262d839db86b8741db74eeb0ce774ce69aa99d09a56a5b9cd70abf36b06d27f9216118aff945d3ace3778c93f914794c30420c8a43dfab
data/COPYING CHANGED
@@ -1,4 +1,4 @@
1
- Ruby/ODBC is copyrighted free software by Christian Werner <chw@ch-werner.de>
1
+ Ruby/ODBC is copyrighted free software by Christian Werner chw at ch-werner.de
2
2
  You can redistribute it and/or modify it under either the terms of the GPL
3
3
  (see the file GPL), or the conditions below:
4
4
 
data/ChangeLog CHANGED
@@ -1,6 +1,33 @@
1
1
  ODBC binding for Ruby
2
2
  ---------------------
3
3
 
4
+ Sat Dec 26 2020 version 0.999991 released
5
+
6
+ * update to compile with newer Ruby releases
7
+ * report larger width for SQL_(DECIMAL|NUMERIC) columns
8
+
9
+ Wed Feb 28 2018 version 0.99999 released
10
+
11
+ * update to compile with newer Ruby releases, thanks
12
+ Lars Kanis for patch
13
+ * added ODBC::Database.login_timeout to get/set the
14
+ SQL_LOGIN_TIMEOUT connection attribute
15
+
16
+ Wed Feb 15 2017 version 0.99998 released
17
+
18
+ * minor update to compile with Ruby 2.4, thangs to Kevin Deisz
19
+ * preset output vars before SQLColAttributes() call
20
+
21
+ Wed Apr 15 2015 version 0.99997 released
22
+
23
+ * fixed bug (typo) when compiling with Ruby < 2.0
24
+
25
+ Wed Mar 25 2015 version 0.99996 released
26
+
27
+ * when built for Ruby >= 2.0 release GVL for potentially
28
+ long running ODBC API functions, thanks Matt Conover
29
+ for initial implementation
30
+
4
31
  Wed Mar 13 2013 version 0.99995 released
5
32
 
6
33
  * added ODBC::Database.use_sql_column_name= flag to switch
data/README CHANGED
@@ -1,6 +1,6 @@
1
- # $Id: README,v 1.42 2013/03/13 19:24:03 chw Exp chw $
1
+ # $Id: README,v 1.47 2020/12/25 21:47:43 chw Exp chw $
2
2
 
3
- ruby-odbc-0.99995
3
+ ruby-odbc-0.999991
4
4
 
5
5
  This is an ODBC binding for Ruby. So far it has been tested with
6
6
 
@@ -20,9 +20,11 @@ This is an ODBC binding for Ruby. So far it has been tested with
20
20
 
21
21
  - Ruby 2.0.0, SQLite/ODBC >= 0.93, unixODBC 2.2.14 on Ubuntu 12.04 x86
22
22
 
23
- Michael Neumann <neumann@s-direktnet.de> and
24
- Will Merrell <wmerrell@catalystcorp.com> reported successful compilation
25
- with Cygwin on Win32.
23
+ - Ruby >= 2.4
24
+
25
+ Michael Neumann <neumann @nospam@ s-direktnet.de> and
26
+ Will Merrell <wmerrell @nospam@ catalystcorp.com> reported successful
27
+ compilation with Cygwin on Win32.
26
28
 
27
29
  Requirements:
28
30
 
@@ -108,5 +110,5 @@ TODO:
108
110
  Author:
109
111
 
110
112
  Christian Werner
111
- mailto:chw@ch-werner.de
113
+ mailto:chw @nospam@ ch-werner.de
112
114
  http://www.ch-werner.de/rubyodbc
data/doc/odbc.html CHANGED
@@ -1,7 +1,7 @@
1
1
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
2
2
  "http://www.w3.org/TR/html4/strict.dtd">
3
3
  <html lang="en">
4
- <head>
4
+ <head>
5
5
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
6
6
  <meta http-equiv="Content-Style-Type" content="text/css">
7
7
  <meta name="Keywords" lang="en" content="ODBC Binding for Ruby">
@@ -14,7 +14,7 @@
14
14
  }
15
15
  address { text-align: right }
16
16
  div.lastmodifed { text-align: right }
17
- div.language { text-align: right }
17
+ div.language { text-align: right }
18
18
  pre {
19
19
  white-space: pre;
20
20
  background-color: antiquewhite;
@@ -27,7 +27,7 @@
27
27
  <body>
28
28
  <h1><a name="reference">Ruby ODBC Reference</a></h1>
29
29
  <div class = "lastmodifed">
30
- Last update: Wed, 13 March 2013
30
+ Last update: Wed, 28 February 2018
31
31
  </div>
32
32
  <hr>
33
33
  <div>
@@ -73,8 +73,10 @@
73
73
  <dd>Gets or sets the process-wide connection pooling attribute.
74
74
  <dt><a name="ODBC::to_time1">
75
75
  <code>to_time(<var>timestamp</var>)</code></a>
76
- <dt><a name="ODBC::to_time2"><code>to_time(<var>date</var>,[<var>time</var>])</code></a>
77
- <dt><a name="ODBC::to_time3"><code>to_time(<var>time</var>,[<var>date</var>])</code></a>
76
+ <dt><a name="ODBC::to_time2">
77
+ <code>to_time(<var>date</var>,[<var>time</var>])</code></a>
78
+ <dt><a name="ODBC::to_time3">
79
+ <code>to_time(<var>time</var>,[<var>date</var>])</code></a>
78
80
  <dd>Creates a <code>Time</code> object from the specified arguments,
79
81
  which must be <a href="#ODBC::Date">ODBC::Date</a>,
80
82
  <a href="#ODBC::Time">ODBC::Time</a>, or
@@ -89,7 +91,7 @@
89
91
  [{|<var>dbc</var>| <var>block</var>}]</code></a>
90
92
  <dd>If no block is specified, a connection to the given data source
91
93
  is established and a <a href="#ODBC::Database">ODBC::Database</a>
92
- object is returned, identifying that connection. Otherwise,
94
+ object is returned, identifying that connection. Otherwise,
93
95
  the block is executed with the database object. When the block
94
96
  is finished, the connection is automatically released.
95
97
  Options are:
@@ -383,10 +385,11 @@
383
385
  <a href="#dbc_get_option"><code>ODBC::Database.get_option</code></a>,
384
386
  <a href="#dbc_set_option"><code>ODBC::Database.set_option</code></a>,
385
387
  <a href="#stmt_get_option"><code>ODBC::Statement.get_option</code></a>,
386
- and
388
+ and
387
389
  <a href="#stmt_set_option"><code>ODBC::Statement.set_option</code></a>
388
390
  yielding integers:
389
391
  <dd><var>SQL_AUTOCOMMIT</var>,
392
+ <var>SQL_LOGIN_TIMEOUT</var>,
390
393
  <var>SQL_CONCURRENCY</var>,
391
394
  <var>SQL_QUERY_TIMEOUT</var>,
392
395
  <var>SQL_MAX_ROWS</var>,
@@ -591,7 +594,7 @@
591
594
  of the underlying ODBC function <code>SQLGetInfo()</code> as a
592
595
  specific Ruby type the optional parameter <var>sql_type</var>
593
596
  can be given as e.g.
594
- <code>ODBC::SQL_SMALLINT</code> (yielding integer),
597
+ <code>ODBC::SQL_SMALLINT</code> (yielding integer),
595
598
  <code>ODBC::SQL_INTEGER</code> (yielding integer), and
596
599
  <code>ODBC::SQL_CHAR</code> (yielding string).
597
600
  <dt><a name="run"><code>run(<var>sql</var>[,<var>args...</var>])</code></a>
@@ -668,9 +671,13 @@ aproc.statement.drop</pre>
668
671
  <dt><a name="timeout"><code>timeout[=<var>intval</var>]</code></a>
669
672
  <dd>Sets or queries the number of seconds to wait for queries to
670
673
  execute on the connection before returning.
674
+ <dt><a name="login_timeout">
675
+ <code>login_timeout[=<var>intval</var>]</code></a>
676
+ <dd>Sets or queries the number of seconds to wait for a login to
677
+ complete on the connection before returning.
671
678
  <dt><a name="maxlength"><code>maxlength[=<var>intval</var>]</code></a>
672
679
  <dd>Sets or queries the maximum amount of data that will be returned
673
- from a character or binary column.
680
+ from a character or binary column.
674
681
  <dt><a name="cursortype">
675
682
  <code>cursortype[=<var>intval</var>]</code></a>
676
683
  <dd>Sets or queries the cursor type used for fetches.
@@ -1262,7 +1269,7 @@ out_value = stmt.param_output_value(2);</pre>
1262
1269
  <dd>Queries or sets attributes in the <var>attrs</var> Hash of the
1263
1270
  ODBC driver object. The <var>key</var>s and <var>value</var>s
1264
1271
  should be Strings.
1265
- </dl>
1272
+ </dl>
1266
1273
  <h3>singleton methods:</h3>
1267
1274
  <dl>
1268
1275
  <dt><a name="ODBC::Driver.new"><code>new</code></a>
@@ -1291,7 +1298,7 @@ out_value = stmt.param_output_value(2);</pre>
1291
1298
  <a href="#ODBC::Statement">ODBC::Statement</a>.
1292
1299
  <dt><code>[[<var>args*</var>]]</code>
1293
1300
  <dd>Synonym for <code>call</code>.
1294
- </dl>
1301
+ </dl>
1295
1302
  </div>
1296
1303
  <div>
1297
1304
  <hr>
data/ext/extconf.rb CHANGED
@@ -20,6 +20,7 @@ end
20
20
 
21
21
  dir_config("odbc")
22
22
  have_header("version.h")
23
+ have_header("ruby/version.h")
23
24
  have_header("sql.h") || begin
24
25
  puts "ERROR: sql.h not found"
25
26
  exit 1
@@ -78,6 +79,40 @@ rescue
78
79
  puts "WARNING: the option -DHAVE_TYPE_SQLULEN"
79
80
  end
80
81
  $have_odbcinst_h = have_header("odbcinst.h")
82
+ begin
83
+ if PLATFORM !~ /(mingw|cygwin)/ then
84
+ header = "sqltypes.h"
85
+ else
86
+ header = ["windows.h", "sqltypes.h"]
87
+ end
88
+ if defined? have_type
89
+ have_type("SQLROWOFFSET", header)
90
+ else
91
+ throw
92
+ end
93
+ rescue
94
+ puts "WARNING: please check sqltypes.h for SQLROWOFFSET manually,"
95
+ puts "WARNING: if defined, modify CFLAGS in Makefile to contain"
96
+ puts "WARNING: the option -DHAVE_TYPE_SQLROWOFFSET"
97
+ end
98
+ $have_odbcinst_h = have_header("odbcinst.h")
99
+ begin
100
+ if PLATFORM !~ /(mingw|cygwin)/ then
101
+ header = "sqltypes.h"
102
+ else
103
+ header = ["windows.h", "sqltypes.h"]
104
+ end
105
+ if defined? have_type
106
+ have_type("SQLROWSETSIZE", header)
107
+ else
108
+ throw
109
+ end
110
+ rescue
111
+ puts "WARNING: please check sqltypes.h for SQLROWSETSIZE manually,"
112
+ puts "WARNING: if defined, modify CFLAGS in Makefile to contain"
113
+ puts "WARNING: the option -DHAVE_TYPE_SQLROWSETSIZE"
114
+ end
115
+ $have_odbcinst_h = have_header("odbcinst.h")
81
116
 
82
117
  if PLATFORM =~ /mswin32/ then
83
118
  if !have_library_ex("odbc32", "SQLAllocConnect", "sql.h") ||
@@ -90,9 +125,9 @@ if PLATFORM =~ /mswin32/ then
90
125
  have_func("SQLInstallerError", "odbcinst.h")
91
126
  # mingw untested !!!
92
127
  elsif PLATFORM =~ /(mingw|cygwin)/ then
93
- have_library("odbc32", "")
94
- have_library("odbccp32", "")
95
- have_library("user32", "")
128
+ have_library("odbc32")
129
+ have_library("odbccp32")
130
+ have_library("user32")
96
131
  elsif (testdlopen && PLATFORM !~ /(macos|darwin)/ && CONFIG["CC"] =~ /gcc/ && have_func("dlopen", "dlfcn.h") && have_library("dl", "dlopen")) then
97
132
  $LDFLAGS+=" -Wl,-init -Wl,ruby_odbc_init -Wl,-fini -Wl,ruby_odbc_fini"
98
133
  $CPPFLAGS+=" -DHAVE_SQLCONFIGDATASOURCE"
data/ext/odbc.c CHANGED
@@ -1,6 +1,6 @@
1
1
  /*
2
2
  * ODBC-Ruby binding
3
- * Copyright (c) 2001-2013 Christian Werner <chw@ch-werner.de>
3
+ * Copyright (c) 2001-2020 Christian Werner <chw@ch-werner.de>
4
4
  * Portions copyright (c) 2004 Ryszard Niewisiewicz <micz@fibernet.pl>
5
5
  * Portions copyright (c) 2006 Carl Blakeley <cblakeley@openlinksw.co.uk>
6
6
  *
@@ -8,7 +8,7 @@
8
8
  * and redistribution of this file and for a
9
9
  * DISCLAIMER OF ALL WARRANTIES.
10
10
  *
11
- * $Id: odbc.c,v 1.75 2013/03/13 19:31:13 chw Exp chw $
11
+ * $Id: odbc.c,v 1.80 2020/12/25 21:45:42 chw Exp chw $
12
12
  */
13
13
 
14
14
  #undef ODBCVER
@@ -22,6 +22,9 @@
22
22
  #ifdef HAVE_VERSION_H
23
23
  #include "version.h"
24
24
  #endif
25
+ #ifdef HAVE_RUBY_VERSION_H
26
+ #include "ruby/version.h"
27
+ #endif
25
28
  #ifdef HAVE_SQL_H
26
29
  #include <sql.h>
27
30
  #else
@@ -49,16 +52,32 @@ typedef SQLCHAR SQLTCHAR;
49
52
  #endif
50
53
 
51
54
  #ifndef HAVE_TYPE_SQLLEN
52
- #define SQLLEN SQLINTEGER
55
+ #define SQLLEN SQLINTEGER
53
56
  #endif
54
57
  #ifndef HAVE_TYPE_SQLULEN
55
58
  #define SQLULEN SQLUINTEGER
56
59
  #endif
60
+ #ifndef HAVE_TYPE_SQLROWOFFSET
61
+ #define SQLROWOFFSET SQLLEN
62
+ #endif
63
+ #ifndef HAVE_TYPE_SQLROWSETSIZE
64
+ #define SQLROWSETSIZE SQLULEN
65
+ #endif
57
66
 
58
67
  #if (RUBY_VERSION_MAJOR <= 1) && (RUBY_VERSION_MINOR < 9)
59
68
  #define TIME_USE_USEC 1
60
69
  #endif
61
70
 
71
+ #if (RUBY_API_VERSION_CODE >= 20500)
72
+ #define FUNCALL_NOARGS(o, m) rb_funcall((o), (m), 0)
73
+ #else
74
+ #define FUNCALL_NOARGS(o, m) rb_funcall((o), (m), 0, NULL)
75
+ #endif
76
+
77
+ #ifdef HAVE_RUBY_THREAD_H
78
+ #include "ruby/thread.h"
79
+ #endif
80
+
62
81
  /*
63
82
  * Conditionally undefine aliases of ODBC installer UNICODE functions.
64
83
  */
@@ -163,7 +182,7 @@ typedef struct dbc {
163
182
  VALUE self;
164
183
  VALUE env;
165
184
  struct env *envp;
166
- LINK stmts;
185
+ LINK stmts;
167
186
  SQLHDBC hdbc;
168
187
  VALUE rbtime;
169
188
  VALUE gmtime;
@@ -355,7 +374,911 @@ static const char *colnamebuf[] = {
355
374
  /*
356
375
  *----------------------------------------------------------------------
357
376
  *
358
- * UNICODE converters et.al.
377
+ * Wrappers for long running SQL APIs with GVL released.
378
+ *
379
+ *----------------------------------------------------------------------
380
+ */
381
+
382
+ #ifdef RUBY_CALL_WO_GVL_FLAG_SKIP_CHECK_INTS_
383
+
384
+ static void
385
+ empty_ubf(void *args)
386
+ {
387
+ }
388
+
389
+ struct S_SQLCONNECT {
390
+ SQLHDBC hdbc;
391
+ SQLTCHAR *dsn;
392
+ SQLSMALLINT dsn_len;
393
+ SQLTCHAR *usr;
394
+ SQLSMALLINT usr_len;
395
+ SQLTCHAR *pwd;
396
+ SQLSMALLINT pwd_len;
397
+ };
398
+
399
+ static void *
400
+ F_SQLCONNECT(void *args)
401
+ {
402
+ size_t ret;
403
+ struct S_SQLCONNECT *argp = (struct S_SQLCONNECT *) args;
404
+
405
+ ret = SQLConnect(argp->hdbc, argp->dsn, argp->dsn_len,
406
+ argp->usr, argp->usr_len, argp->pwd, argp->pwd_len);
407
+ return (void *) ret;
408
+ }
409
+
410
+ static inline SQLRETURN
411
+ SQLCONNECT(SQLHDBC hdbc, SQLTCHAR *dsn, SQLSMALLINT dsn_len, SQLTCHAR *usr,
412
+ SQLSMALLINT usr_len, SQLTCHAR *pwd, SQLSMALLINT pwd_len)
413
+ {
414
+ size_t ret;
415
+ struct S_SQLCONNECT arg;
416
+
417
+ arg.hdbc = hdbc;
418
+ arg.dsn = dsn;
419
+ arg.dsn_len = dsn_len;
420
+ arg.usr = usr;
421
+ arg.usr_len = usr_len;
422
+ arg.pwd = pwd;
423
+ arg.pwd_len = pwd_len;
424
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLCONNECT, &arg,
425
+ empty_ubf, &arg);
426
+ return ret;
427
+ }
428
+
429
+ struct S_SQLDRIVERCONNECT {
430
+ SQLHDBC hdbc;
431
+ SQLHWND hwnd;
432
+ SQLTCHAR *connin;
433
+ SQLSMALLINT connin_len;
434
+ SQLTCHAR *connout;
435
+ SQLSMALLINT connout_max;
436
+ SQLSMALLINT *connout_len;
437
+ SQLUSMALLINT compl;
438
+ };
439
+
440
+ static void *
441
+ F_SQLDRIVERCONNECT(void *args)
442
+ {
443
+ size_t ret;
444
+ struct S_SQLDRIVERCONNECT *argp = (struct S_SQLDRIVERCONNECT *) args;
445
+
446
+ ret = SQLDriverConnect(argp->hdbc, argp->hwnd, argp->connin,
447
+ argp->connin_len, argp->connout, argp->connout_max,
448
+ argp->connout_len, argp->compl);
449
+ return (void *) ret;
450
+ }
451
+
452
+ static inline SQLRETURN
453
+ SQLDRIVERCONNECT(SQLHDBC hdbc, SQLHWND hwnd, SQLTCHAR *connin,
454
+ SQLSMALLINT connin_len, SQLTCHAR *connout,
455
+ SQLSMALLINT connout_max, SQLSMALLINT *connout_len,
456
+ SQLUSMALLINT compl)
457
+ {
458
+ size_t ret;
459
+ struct S_SQLDRIVERCONNECT arg;
460
+
461
+ arg.hdbc = hdbc;
462
+ arg.hwnd = hwnd;
463
+ arg.connin = connin;
464
+ arg.connin_len = connin_len;
465
+ arg.connout = connout;
466
+ arg.connout_max = connout_max;
467
+ arg.connout_len = connout_len;
468
+ arg.compl = compl;
469
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLDRIVERCONNECT, &arg,
470
+ empty_ubf, &arg);
471
+ return ret;
472
+ }
473
+
474
+ struct S_SQLDISCONNECT {
475
+ SQLHSTMT hstmt;
476
+ };
477
+
478
+ static void *
479
+ F_SQLDISCONNECT(void *args)
480
+ {
481
+ size_t ret;
482
+ struct S_SQLDISCONNECT *argp = (struct S_SQLDISCONNECT *) args;
483
+
484
+ ret = SQLDisconnect(argp->hstmt);
485
+ return (void *) ret;
486
+ }
487
+
488
+ static inline SQLRETURN
489
+ SQLDISCONNECT(SQLHSTMT hstmt)
490
+ {
491
+ size_t ret;
492
+ struct S_SQLDISCONNECT arg;
493
+
494
+ arg.hstmt = hstmt;
495
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLDISCONNECT, &arg,
496
+ empty_ubf, &arg);
497
+ return ret;
498
+ }
499
+
500
+ struct S_SQLTABLES {
501
+ SQLHSTMT hdbc;
502
+ SQLTCHAR *cat;
503
+ SQLSMALLINT cat_len;
504
+ SQLTCHAR *sch;
505
+ SQLSMALLINT sch_len;
506
+ SQLTCHAR *tbl;
507
+ SQLSMALLINT tbl_len;
508
+ SQLTCHAR *typ;
509
+ SQLSMALLINT typ_len;
510
+ };
511
+
512
+ static void *
513
+ F_SQLTABLES(void *args)
514
+ {
515
+ size_t ret;
516
+ struct S_SQLTABLES *argp = (struct S_SQLTABLES *) args;
517
+
518
+ ret = SQLTables(argp->hdbc, argp->cat, argp->cat_len,
519
+ argp->sch, argp->sch_len, argp->tbl,
520
+ argp->tbl_len, argp->typ, argp->typ_len);
521
+ return (void *) ret;
522
+ }
523
+
524
+ static inline SQLRETURN
525
+ SQLTABLES(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
526
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
527
+ SQLSMALLINT tbl_len, SQLTCHAR *typ, SQLSMALLINT typ_len)
528
+ {
529
+ size_t ret;
530
+ struct S_SQLTABLES arg;
531
+
532
+ arg.hdbc = hdbc;
533
+ arg.cat = cat;
534
+ arg.cat_len = cat_len;
535
+ arg.sch = sch;
536
+ arg.sch_len = sch_len;
537
+ arg.tbl = tbl;
538
+ arg.tbl_len = tbl_len;
539
+ arg.typ = typ;
540
+ arg.typ_len = typ_len;
541
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLTABLES, &arg,
542
+ empty_ubf, &arg);
543
+ return ret;
544
+ }
545
+
546
+ struct S_SQLCOLUMNS {
547
+ SQLHSTMT hdbc;
548
+ SQLTCHAR *cat;
549
+ SQLSMALLINT cat_len;
550
+ SQLTCHAR *sch;
551
+ SQLSMALLINT sch_len;
552
+ SQLTCHAR *tbl;
553
+ SQLSMALLINT tbl_len;
554
+ SQLTCHAR *col;
555
+ SQLSMALLINT col_len;
556
+ };
557
+
558
+ static void *
559
+ F_SQLCOLUMNS(void *args)
560
+ {
561
+ size_t ret;
562
+ struct S_SQLCOLUMNS *argp = (struct S_SQLCOLUMNS *) args;
563
+
564
+ ret = SQLColumns(argp->hdbc, argp->cat, argp->cat_len,
565
+ argp->sch, argp->sch_len, argp->tbl,
566
+ argp->tbl_len, argp->col, argp->col_len);
567
+ return (void *) ret;
568
+ }
569
+
570
+ static inline SQLRETURN
571
+ SQLCOLUMNS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
572
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
573
+ SQLSMALLINT tbl_len, SQLTCHAR *col, SQLSMALLINT col_len)
574
+ {
575
+ size_t ret;
576
+ struct S_SQLCOLUMNS arg;
577
+
578
+ arg.hdbc = hdbc;
579
+ arg.cat = cat;
580
+ arg.cat_len = cat_len;
581
+ arg.sch = sch;
582
+ arg.sch_len = sch_len;
583
+ arg.tbl = tbl;
584
+ arg.tbl_len = tbl_len;
585
+ arg.col = col;
586
+ arg.col_len = col_len;
587
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLCOLUMNS, &arg,
588
+ empty_ubf, &arg);
589
+ return ret;
590
+ }
591
+
592
+ struct S_SQLPRIMARYKEYS {
593
+ SQLHSTMT hdbc;
594
+ SQLTCHAR *cat;
595
+ SQLSMALLINT cat_len;
596
+ SQLTCHAR *sch;
597
+ SQLSMALLINT sch_len;
598
+ SQLTCHAR *tbl;
599
+ SQLSMALLINT tbl_len;
600
+ };
601
+
602
+ static void *
603
+ F_SQLPRIMARYKEYS(void *args)
604
+ {
605
+ size_t ret;
606
+ struct S_SQLPRIMARYKEYS *argp = (struct S_SQLPRIMARYKEYS *) args;
607
+
608
+ ret = SQLPrimaryKeys(argp->hdbc, argp->cat, argp->cat_len,
609
+ argp->sch, argp->sch_len, argp->tbl, argp->tbl_len);
610
+ return (void *) ret;
611
+ }
612
+
613
+ static inline SQLRETURN
614
+ SQLPRIMARYKEYS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
615
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
616
+ SQLSMALLINT tbl_len)
617
+ {
618
+ size_t ret;
619
+ struct S_SQLPRIMARYKEYS arg;
620
+
621
+ arg.hdbc = hdbc;
622
+ arg.cat = cat;
623
+ arg.cat_len = cat_len;
624
+ arg.sch = sch;
625
+ arg.sch_len = sch_len;
626
+ arg.tbl = tbl;
627
+ arg.tbl_len = tbl_len;
628
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLPRIMARYKEYS, &arg,
629
+ empty_ubf, &arg);
630
+ return ret;
631
+ }
632
+
633
+ struct S_SQLFOREIGNKEYS {
634
+ SQLHSTMT hdbc;
635
+ SQLTCHAR *pkcat;
636
+ SQLSMALLINT pkcat_len;
637
+ SQLTCHAR *pksch;
638
+ SQLSMALLINT pksch_len;
639
+ SQLTCHAR *pktbl;
640
+ SQLSMALLINT pktbl_len;
641
+ SQLTCHAR *fkcat;
642
+ SQLSMALLINT fkcat_len;
643
+ SQLTCHAR *fksch;
644
+ SQLSMALLINT fksch_len;
645
+ SQLTCHAR *fktbl;
646
+ SQLSMALLINT fktbl_len;
647
+ };
648
+
649
+ static void *
650
+ F_SQLFOREIGNKEYS(void *args)
651
+ {
652
+ size_t ret;
653
+ struct S_SQLFOREIGNKEYS *argp = (struct S_SQLFOREIGNKEYS *) args;
654
+
655
+ ret = SQLForeignKeys(argp->hdbc, argp->pkcat, argp->pkcat_len,
656
+ argp->pksch, argp->pksch_len,
657
+ argp->pktbl, argp->pktbl_len,
658
+ argp->fkcat, argp->fkcat_len,
659
+ argp->fksch, argp->fksch_len,
660
+ argp->fktbl, argp->fktbl_len);
661
+ return (void *) ret;
662
+ }
663
+
664
+ static inline SQLRETURN
665
+ SQLFOREIGNKEYS(SQLHDBC hdbc, SQLTCHAR *pkcat, SQLSMALLINT pkcat_len,
666
+ SQLTCHAR *pksch, SQLSMALLINT pksch_len, SQLTCHAR *pktbl,
667
+ SQLSMALLINT pktbl_len, SQLTCHAR *fkcat, SQLSMALLINT fkcat_len,
668
+ SQLTCHAR *fksch, SQLSMALLINT fksch_len, SQLTCHAR *fktbl,
669
+ SQLSMALLINT fktbl_len)
670
+ {
671
+ size_t ret;
672
+ struct S_SQLFOREIGNKEYS arg;
673
+
674
+ arg.hdbc = hdbc;
675
+ arg.pkcat = pkcat;
676
+ arg.pkcat_len = pkcat_len;
677
+ arg.pksch = pksch;
678
+ arg.pksch_len = pksch_len;
679
+ arg.pktbl = pktbl;
680
+ arg.pktbl_len = pktbl_len;
681
+ arg.fkcat = fkcat;
682
+ arg.fkcat_len = fkcat_len;
683
+ arg.fksch = fksch;
684
+ arg.fksch_len = fksch_len;
685
+ arg.fktbl = fktbl;
686
+ arg.fktbl_len = fktbl_len;
687
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLFOREIGNKEYS, &arg,
688
+ empty_ubf, &arg);
689
+ return ret;
690
+ }
691
+
692
+ struct S_SQLPROCEDURES {
693
+ SQLHSTMT hdbc;
694
+ SQLTCHAR *cat;
695
+ SQLSMALLINT cat_len;
696
+ SQLTCHAR *sch;
697
+ SQLSMALLINT sch_len;
698
+ SQLTCHAR *prc;
699
+ SQLSMALLINT prc_len;
700
+ };
701
+
702
+ static void *
703
+ F_SQLPROCEDURES(void *args)
704
+ {
705
+ size_t ret;
706
+ struct S_SQLPROCEDURES *argp = (struct S_SQLPROCEDURES *) args;
707
+
708
+ ret = SQLProcedures(argp->hdbc, argp->cat, argp->cat_len,
709
+ argp->sch, argp->sch_len, argp->prc, argp->prc_len);
710
+ return (void *) ret;
711
+ }
712
+
713
+ static inline SQLRETURN
714
+ SQLPROCEDURES(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
715
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *prc,
716
+ SQLSMALLINT prc_len)
717
+ {
718
+ size_t ret;
719
+ struct S_SQLPROCEDURES arg;
720
+
721
+ arg.hdbc = hdbc;
722
+ arg.cat = cat;
723
+ arg.cat_len = cat_len;
724
+ arg.sch = sch;
725
+ arg.sch_len = sch_len;
726
+ arg.prc = prc;
727
+ arg.prc_len = prc_len;
728
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLPROCEDURES, &arg,
729
+ empty_ubf, &arg);
730
+ return ret;
731
+ }
732
+
733
+ struct S_SQLPROCEDURECOLUMNS {
734
+ SQLHSTMT hdbc;
735
+ SQLTCHAR *cat;
736
+ SQLSMALLINT cat_len;
737
+ SQLTCHAR *sch;
738
+ SQLSMALLINT sch_len;
739
+ SQLTCHAR *prc;
740
+ SQLSMALLINT prc_len;
741
+ SQLTCHAR *col;
742
+ SQLSMALLINT col_len;
743
+ };
744
+
745
+ static void *
746
+ F_SQLPROCEDURECOLUMNS(void *args)
747
+ {
748
+ size_t ret;
749
+ struct S_SQLPROCEDURECOLUMNS *argp = (struct S_SQLPROCEDURECOLUMNS *) args;
750
+
751
+ ret = SQLProcedureColumns(argp->hdbc, argp->cat, argp->cat_len,
752
+ argp->sch, argp->sch_len, argp->prc,
753
+ argp->prc_len, argp->col, argp->col_len);
754
+ return (void *) ret;
755
+ }
756
+
757
+ static inline SQLRETURN
758
+ SQLPROCEDURECOLUMNS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
759
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *prc,
760
+ SQLSMALLINT prc_len, SQLTCHAR *col, SQLSMALLINT col_len)
761
+ {
762
+ size_t ret;
763
+ struct S_SQLPROCEDURECOLUMNS arg;
764
+
765
+ arg.hdbc = hdbc;
766
+ arg.cat = cat;
767
+ arg.cat_len = cat_len;
768
+ arg.sch = sch;
769
+ arg.sch_len = sch_len;
770
+ arg.prc = prc;
771
+ arg.prc_len = prc_len;
772
+ arg.col = col;
773
+ arg.col_len = col_len;
774
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLPROCEDURECOLUMNS, &arg,
775
+ empty_ubf, &arg);
776
+ return ret;
777
+ }
778
+
779
+ struct S_SQLTABLEPRIVILEGES {
780
+ SQLHSTMT hdbc;
781
+ SQLTCHAR *cat;
782
+ SQLSMALLINT cat_len;
783
+ SQLTCHAR *sch;
784
+ SQLSMALLINT sch_len;
785
+ SQLTCHAR *tbl;
786
+ SQLSMALLINT tbl_len;
787
+ };
788
+
789
+ static void *
790
+ F_SQLTABLEPRIVILEGES(void *args)
791
+ {
792
+ size_t ret;
793
+ struct S_SQLTABLEPRIVILEGES *argp = (struct S_SQLTABLEPRIVILEGES *) args;
794
+
795
+ ret = SQLTablePrivileges(argp->hdbc, argp->cat, argp->cat_len,
796
+ argp->sch, argp->sch_len, argp->tbl,
797
+ argp->tbl_len);
798
+ return (void *) ret;
799
+ }
800
+
801
+ static inline SQLRETURN
802
+ SQLTABLEPRIVILEGES(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
803
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
804
+ SQLSMALLINT tbl_len)
805
+ {
806
+ size_t ret;
807
+ struct S_SQLTABLEPRIVILEGES arg;
808
+
809
+ arg.hdbc = hdbc;
810
+ arg.cat = cat;
811
+ arg.cat_len = cat_len;
812
+ arg.sch = sch;
813
+ arg.sch_len = sch_len;
814
+ arg.tbl = tbl;
815
+ arg.tbl_len = tbl_len;
816
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLTABLEPRIVILEGES, &arg,
817
+ empty_ubf, &arg);
818
+ return ret;
819
+ }
820
+
821
+ struct S_SQLSTATISTICS {
822
+ SQLHSTMT hdbc;
823
+ SQLTCHAR *cat;
824
+ SQLSMALLINT cat_len;
825
+ SQLTCHAR *sch;
826
+ SQLSMALLINT sch_len;
827
+ SQLTCHAR *tbl;
828
+ SQLSMALLINT tbl_len;
829
+ SQLUSMALLINT uniq;
830
+ SQLUSMALLINT resv;
831
+ };
832
+
833
+ static void *
834
+ F_SQLSTATISTICS(void *args)
835
+ {
836
+ size_t ret;
837
+ struct S_SQLSTATISTICS *argp = (struct S_SQLSTATISTICS *) args;
838
+
839
+ ret = SQLStatistics(argp->hdbc, argp->cat, argp->cat_len,
840
+ argp->sch, argp->sch_len, argp->tbl,
841
+ argp->tbl_len, argp->uniq, argp->resv);
842
+ return (void *) ret;
843
+ }
844
+
845
+ static inline SQLRETURN
846
+ SQLSTATISTICS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
847
+ SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
848
+ SQLSMALLINT tbl_len, SQLUSMALLINT uniq, SQLUSMALLINT resv)
849
+ {
850
+ size_t ret;
851
+ struct S_SQLSTATISTICS arg;
852
+
853
+ arg.hdbc = hdbc;
854
+ arg.cat = cat;
855
+ arg.cat_len = cat_len;
856
+ arg.sch = sch;
857
+ arg.sch_len = sch_len;
858
+ arg.tbl = tbl;
859
+ arg.tbl_len = tbl_len;
860
+ arg.uniq = uniq;
861
+ arg.resv = resv;
862
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLSTATISTICS, &arg,
863
+ empty_ubf, &arg);
864
+ return ret;
865
+ }
866
+
867
+ struct S_SQLSPECIALCOLUMNS {
868
+ SQLHSTMT hdbc;
869
+ SQLUSMALLINT idtyp;
870
+ SQLTCHAR *cat;
871
+ SQLSMALLINT cat_len;
872
+ SQLTCHAR *sch;
873
+ SQLSMALLINT sch_len;
874
+ SQLTCHAR *tbl;
875
+ SQLSMALLINT tbl_len;
876
+ SQLUSMALLINT scope;
877
+ SQLUSMALLINT nulbl;
878
+ };
879
+
880
+ static void *
881
+ F_SQLSPECIALCOLUMNS(void *args)
882
+ {
883
+ size_t ret;
884
+ struct S_SQLSPECIALCOLUMNS *argp = (struct S_SQLSPECIALCOLUMNS *) args;
885
+
886
+ ret = SQLSpecialColumns(argp->hdbc, argp->idtyp, argp->cat, argp->cat_len,
887
+ argp->sch, argp->sch_len, argp->tbl,
888
+ argp->tbl_len, argp->scope, argp->nulbl);
889
+ return (void *) ret;
890
+ }
891
+
892
+ static inline SQLRETURN
893
+ SQLSPECIALCOLUMNS(SQLHDBC hdbc, SQLUSMALLINT idtyp, SQLTCHAR *cat,
894
+ SQLSMALLINT cat_len, SQLTCHAR *sch, SQLSMALLINT sch_len,
895
+ SQLTCHAR *tbl, SQLSMALLINT tbl_len,
896
+ SQLUSMALLINT scope, SQLUSMALLINT nulbl)
897
+ {
898
+ size_t ret;
899
+ struct S_SQLSPECIALCOLUMNS arg;
900
+
901
+ arg.hdbc = hdbc;
902
+ arg.idtyp = idtyp;
903
+ arg.cat = cat;
904
+ arg.cat_len = cat_len;
905
+ arg.sch = sch;
906
+ arg.sch_len = sch_len;
907
+ arg.tbl = tbl;
908
+ arg.tbl_len = tbl_len;
909
+ arg.scope = scope;
910
+ arg.nulbl = nulbl;
911
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLSPECIALCOLUMNS, &arg,
912
+ empty_ubf, &arg);
913
+ return ret;
914
+ }
915
+
916
+ struct S_SQLGETTYPEINFO {
917
+ SQLHSTMT hdbc;
918
+ SQLSMALLINT type;
919
+ };
920
+
921
+ static void *
922
+ F_SQLGETTYPEINFO(void *args)
923
+ {
924
+ size_t ret;
925
+ struct S_SQLGETTYPEINFO *argp = (struct S_SQLGETTYPEINFO *) args;
926
+
927
+ ret = SQLGetTypeInfo(argp->hdbc, argp->type);
928
+ return (void *) ret;
929
+ }
930
+
931
+ static inline SQLRETURN
932
+ SQLGETTYPEINFO(SQLHDBC hdbc, SQLSMALLINT type)
933
+ {
934
+ size_t ret;
935
+ struct S_SQLGETTYPEINFO arg;
936
+
937
+ arg.hdbc = hdbc;
938
+ arg.type = type;
939
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLGETTYPEINFO, &arg,
940
+ empty_ubf, &arg);
941
+ return ret;
942
+ }
943
+
944
+ #if (ODBCVER >= 0x0300)
945
+
946
+ struct S_SQLENDTRAN {
947
+ SQLSMALLINT htype;
948
+ SQLHANDLE handle;
949
+ SQLSMALLINT op;
950
+ };
951
+
952
+ static void *
953
+ F_SQLENDTRAN(void *args)
954
+ {
955
+ size_t ret;
956
+ struct S_SQLENDTRAN *argp = (struct S_SQLENDTRAN *) args;
957
+
958
+ ret = SQLEndTran(argp->htype, argp->handle, argp->op);
959
+ return (void *) ret;
960
+ }
961
+
962
+ static inline SQLRETURN
963
+ SQLENDTRAN(SQLUSMALLINT htype, SQLHANDLE handle, SQLUSMALLINT op)
964
+ {
965
+ size_t ret;
966
+ struct S_SQLENDTRAN arg;
967
+
968
+ arg.htype = htype;
969
+ arg.handle = handle;
970
+ arg.op = op;
971
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLENDTRAN, &arg,
972
+ empty_ubf, &arg);
973
+ return ret;
974
+ }
975
+
976
+ #else
977
+
978
+ struct S_SQLTRANSACT {
979
+ SQLHENV henv;
980
+ SQLHDBC hdbc;
981
+ SQLSMALLINT op;
982
+ };
983
+
984
+ static void *
985
+ F_SQLTRANSACT(void *args)
986
+ {
987
+ size_t ret;
988
+ struct S_SQLTRANSACT *argp = (struct S_SQLTRANSACT *) args;
989
+
990
+ ret = SQLTransact(argp->henv, argp->hdbc, argp->op);
991
+ return (void *) ret;
992
+ }
993
+
994
+ static inline SQLRETURN
995
+ SQLTRANSACT(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT op)
996
+ {
997
+ size_t ret;
998
+ struct S_SQLTRANSACT arg;
999
+
1000
+ arg.henv = henv;
1001
+ arg.hdbc = hdbc;
1002
+ arg.op = op;
1003
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLTRANCACT, &arg,
1004
+ empty_ubf, &arg);
1005
+ return ret;
1006
+ }
1007
+
1008
+ #endif
1009
+
1010
+ struct S_SQLEXECDIRECT {
1011
+ SQLHSTMT hstmt;
1012
+ SQLTCHAR *sql;
1013
+ SQLINTEGER len;
1014
+ };
1015
+
1016
+ static void *
1017
+ F_SQLEXECDIRECT(void *args)
1018
+ {
1019
+ size_t ret;
1020
+ struct S_SQLEXECDIRECT *argp = (struct S_SQLEXECDIRECT *) args;
1021
+
1022
+ ret = SQLExecDirect(argp->hstmt, argp->sql, argp->len);
1023
+ return (void *) ret;
1024
+ }
1025
+
1026
+ static void
1027
+ F_SQLEXECDIRECT_UBF(void *args)
1028
+ {
1029
+ struct S_SQLEXECDIRECT *argp = (struct S_SQLEXECDIRECT *) args;
1030
+
1031
+ SQLCancel(argp->hstmt);
1032
+ }
1033
+
1034
+ static inline SQLRETURN
1035
+ SQLEXECDIRECT(SQLHSTMT hstmt, SQLTCHAR *sql, SQLINTEGER len)
1036
+ {
1037
+ size_t ret;
1038
+ struct S_SQLEXECDIRECT arg;
1039
+
1040
+ arg.hstmt = hstmt;
1041
+ arg.sql = sql;
1042
+ arg.len = len;
1043
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLEXECDIRECT, &arg,
1044
+ F_SQLEXECDIRECT_UBF, &arg);
1045
+ return ret;
1046
+ }
1047
+
1048
+ struct S_SQLEXECUTE {
1049
+ SQLHSTMT hstmt;
1050
+ };
1051
+
1052
+ static void *
1053
+ F_SQLEXECUTE(void *args)
1054
+ {
1055
+ size_t ret;
1056
+ struct S_SQLEXECUTE *argp = (struct S_SQLEXECUTE *) args;
1057
+
1058
+ ret = SQLExecute(argp->hstmt);
1059
+ return (void *) ret;
1060
+ }
1061
+
1062
+ static void
1063
+ F_SQLEXECUTE_UBF(void *args)
1064
+ {
1065
+ struct S_SQLEXECUTE *argp = (struct S_SQLEXECUTE *) args;
1066
+
1067
+ SQLCancel(argp->hstmt);
1068
+ }
1069
+
1070
+ static inline SQLRETURN
1071
+ SQLEXECUTE(SQLHSTMT hstmt)
1072
+ {
1073
+ size_t ret;
1074
+ struct S_SQLEXECUTE arg;
1075
+
1076
+ arg.hstmt = hstmt;
1077
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLEXECUTE, &arg,
1078
+ F_SQLEXECUTE_UBF, &arg);
1079
+ return ret;
1080
+ }
1081
+
1082
+ struct S_SQLPREPARE {
1083
+ SQLHSTMT hstmt;
1084
+ SQLTCHAR *sql;
1085
+ SQLINTEGER len;
1086
+ };
1087
+
1088
+ static void *
1089
+ F_SQLPREPARE(void *args)
1090
+ {
1091
+ size_t ret;
1092
+ struct S_SQLPREPARE *argp = (struct S_SQLPREPARE *) args;
1093
+
1094
+ ret = SQLPrepare(argp->hstmt, argp->sql, argp->len);
1095
+ return (void *) ret;
1096
+ }
1097
+
1098
+ static void
1099
+ F_SQLPREPARE_UBF(void *args)
1100
+ {
1101
+ struct S_SQLPREPARE *argp = (struct S_SQLPREPARE *) args;
1102
+
1103
+ SQLCancel(argp->hstmt);
1104
+ }
1105
+
1106
+ static inline SQLRETURN
1107
+ SQLPREPARE(SQLHSTMT hstmt, SQLTCHAR *sql, SQLINTEGER len)
1108
+ {
1109
+ size_t ret;
1110
+ struct S_SQLPREPARE arg;
1111
+
1112
+ arg.hstmt = hstmt;
1113
+ arg.sql = sql;
1114
+ arg.len = len;
1115
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLPREPARE, &arg,
1116
+ F_SQLPREPARE_UBF, &arg);
1117
+ return ret;
1118
+ }
1119
+
1120
+ struct S_SQLMORERESULTS {
1121
+ SQLHSTMT hstmt;
1122
+ };
1123
+
1124
+ static void *
1125
+ F_SQLMORERESULTS(void *args)
1126
+ {
1127
+ size_t ret;
1128
+ struct S_SQLMORERESULTS *argp = (struct S_SQLMORERESULTS *) args;
1129
+
1130
+ ret = SQLMoreResults(argp->hstmt);
1131
+ return (void *) ret;
1132
+ }
1133
+
1134
+ static inline SQLRETURN
1135
+ SQLMORERESULTS(SQLHSTMT hstmt)
1136
+ {
1137
+ size_t ret;
1138
+ struct S_SQLMORERESULTS arg;
1139
+
1140
+ arg.hstmt = hstmt;
1141
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLMORERESULTS, &arg,
1142
+ empty_ubf, &arg);
1143
+ return ret;
1144
+ }
1145
+
1146
+ struct S_SQLFETCH {
1147
+ SQLHSTMT hstmt;
1148
+ };
1149
+
1150
+ static void *
1151
+ F_SQLFETCH(void *args)
1152
+ {
1153
+ size_t ret;
1154
+ struct S_SQLFETCH *argp = (struct S_SQLFETCH *) args;
1155
+
1156
+ ret = SQLFetch(argp->hstmt);
1157
+ return (void *) ret;
1158
+ }
1159
+
1160
+ static inline SQLRETURN
1161
+ SQLFETCH(SQLHSTMT hstmt)
1162
+ {
1163
+ size_t ret;
1164
+ struct S_SQLFETCH arg;
1165
+
1166
+ arg.hstmt = hstmt;
1167
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLFETCH, &arg,
1168
+ empty_ubf, &arg);
1169
+ return ret;
1170
+ }
1171
+
1172
+ #if (ODBCVER >= 0x0300)
1173
+
1174
+ struct S_SQLFETCHSCROLL {
1175
+ SQLHSTMT hstmt;
1176
+ SQLSMALLINT dir;
1177
+ SQLROWOFFSET offs;
1178
+ };
1179
+
1180
+ static void *
1181
+ F_SQLFETCHSCROLL(void *args)
1182
+ {
1183
+ size_t ret;
1184
+ struct S_SQLFETCHSCROLL *argp = (struct S_SQLFETCHSCROLL *) args;
1185
+
1186
+ ret = SQLFetchScroll(argp->hstmt, argp->dir, argp->offs);
1187
+ return (void *) ret;
1188
+ }
1189
+
1190
+ static inline SQLRETURN
1191
+ SQLFETCHSCROLL(SQLHSTMT hstmt, SQLSMALLINT dir, SQLROWOFFSET offs)
1192
+ {
1193
+ size_t ret;
1194
+ struct S_SQLFETCHSCROLL arg;
1195
+
1196
+ arg.hstmt = hstmt;
1197
+ arg.dir = dir;
1198
+ arg.offs = offs;
1199
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLFETCHSCROLL, &arg,
1200
+ empty_ubf, &arg);
1201
+ return ret;
1202
+ }
1203
+
1204
+ #else
1205
+
1206
+ struct S_SQLEXTENDEDFETCH {
1207
+ SQLHSTMT hstmt;
1208
+ SQLUSMALLINT type;
1209
+ SQLROWOFFSET row;
1210
+ SQLROWSETSIZE *rowp;
1211
+ SQLUSMALLINT *status
1212
+ };
1213
+
1214
+ static void *
1215
+ F_SQLEXTENDEDFETCH(void *args)
1216
+ {
1217
+ size_t ret;
1218
+ struct S_SQLEXTENDEDFETCH *argp = (struct S_SQLEXTENDEDFETCH *) args;
1219
+
1220
+ ret = SQLExtendedFetch(argp->hstmt, argp->type, argp->row, argp->rowp,
1221
+ argp->status);
1222
+ return (void *) ret;
1223
+ }
1224
+
1225
+ static inline SQLRETURN
1226
+ SQLEXTENDEDFETCH(SQLHSTMT hstmt, SQLUSMALLINT type, SQLROWOFFSET row,
1227
+ SQLROWSETSIZE *rowp, SQLUSMALLINT *status)
1228
+ {
1229
+ size_t ret;
1230
+ struct S_SQLEXTENDEDFETCH arg;
1231
+
1232
+ arg.hstmt = hstmt;
1233
+ arg.type = type;
1234
+ arg.row = row;
1235
+ arg.rowp = rowp;
1236
+ arg.status = status;
1237
+ ret = (size_t) rb_thread_call_without_gvl(F_SQLEXTENDEDFETCH, &arg,
1238
+ empty_ubf, &arg);
1239
+ return ret;
1240
+ }
1241
+
1242
+ #endif
1243
+
1244
+ #else
1245
+
1246
+ #define SQLCONNECT SQLConnect
1247
+ #define SQLDRIVERCONNECT SQLDriverConnect
1248
+ #define SQLDISCONNECT SQLDisconnect
1249
+ #define SQLTABLES SQLTables
1250
+ #define SQLCOLUMNS SQLColumns
1251
+ #define SQLPRIMARYKEYS SQLPrimaryKeys
1252
+ #define SQLFOREIGNKEYS SQLForeignKeys
1253
+ #define SQLPROCEDURES SQLProcedures
1254
+ #define SQLPROCEDURECOLUMNS SQLProcedureColumns
1255
+ #define SQLTABLEPRIVILEGES SQLTablePrivileges
1256
+ #define SQLSTATISTICS SQLStatistics
1257
+ #define SQLSPECIALCOLUMNS SQLSpecialColumns
1258
+ #define SQLGETTYPEINFO SQLGetTypeInfo
1259
+ #if (ODBCVER >= 0x0300)
1260
+ #define SQLENDTRAN SQLEndTran
1261
+ #else
1262
+ #define SQLTRANSACT SQLTransact
1263
+ #endif
1264
+ #define SQLEXECDIRECT SQLExecDirect
1265
+ #define SQLEXECUTE SQLExecute
1266
+ #define SQLPREPARE SQLPrepare
1267
+ #define SQLMORERESULTS SQLMoreResults
1268
+ #define SQLFETCH SQLFetch
1269
+ #if (ODBCVER >= 0x0300)
1270
+ #define SQLFETCHSCROLL SQLFetchScroll
1271
+ #else
1272
+ #define SQLEXTENDEDFETCH SQLExtendedFetch
1273
+ #endif
1274
+
1275
+ #endif
1276
+
1277
+
1278
+ /*
1279
+ *----------------------------------------------------------------------
1280
+ *
1281
+ * UNICODE converters et.al.
359
1282
  *
360
1283
  *----------------------------------------------------------------------
361
1284
  */
@@ -390,7 +1313,7 @@ uc_strchr(SQLWCHAR *str, SQLWCHAR c)
390
1313
 
391
1314
  static int
392
1315
  mkutf(char *dest, SQLWCHAR *src, int len)
393
- {
1316
+ {
394
1317
  int i;
395
1318
  char *cp = dest;
396
1319
 
@@ -629,7 +1552,7 @@ uc_free(SQLWCHAR *str)
629
1552
  /*
630
1553
  *----------------------------------------------------------------------
631
1554
  *
632
- * Things for ODBC::DSN
1555
+ * Things for ODBC::DSN
633
1556
  *
634
1557
  *----------------------------------------------------------------------
635
1558
  */
@@ -656,7 +1579,7 @@ dsn_init(VALUE self)
656
1579
  /*
657
1580
  *----------------------------------------------------------------------
658
1581
  *
659
- * Things for ODBC::Driver
1582
+ * Things for ODBC::Driver
660
1583
  *
661
1584
  *----------------------------------------------------------------------
662
1585
  */
@@ -683,7 +1606,7 @@ drv_init(VALUE self)
683
1606
  /*
684
1607
  *----------------------------------------------------------------------
685
1608
  *
686
- * Cleanup routines and GC mark/free callbacks.
1609
+ * Cleanup routines and GC mark/free callbacks.
687
1610
  *
688
1611
  *----------------------------------------------------------------------
689
1612
  */
@@ -745,7 +1668,7 @@ list_first(LINK *head)
745
1668
  static int
746
1669
  list_empty(LINK *head)
747
1670
  {
748
- return head->succ == NULL;
1671
+ return head->succ == NULL;
749
1672
  }
750
1673
 
751
1674
  static void
@@ -799,7 +1722,7 @@ free_dbc(DBC *p)
799
1722
  tracemsg(2, fprintf(stderr, "ObjFree: DBC %p\n", p););
800
1723
  if (p->hdbc != SQL_NULL_HDBC) {
801
1724
  callsql(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
802
- SQLDisconnect(p->hdbc), "SQLDisconnect");
1725
+ SQLDISCONNECT(p->hdbc), "SQLDisconnect");
803
1726
  callsql(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
804
1727
  SQLFreeConnect(p->hdbc), "SQLFreeConnect");
805
1728
  p->hdbc = SQL_NULL_HDBC;
@@ -910,7 +1833,7 @@ free_stmt(STMT *q)
910
1833
  static void
911
1834
  start_gc()
912
1835
  {
913
- rb_funcall(rb_mGC, IDstart, 0, NULL);
1836
+ FUNCALL_NOARGS(rb_mGC, IDstart);
914
1837
  }
915
1838
 
916
1839
  static void
@@ -932,7 +1855,7 @@ mark_stmt(STMT *q)
932
1855
  /*
933
1856
  *----------------------------------------------------------------------
934
1857
  *
935
- * Set internal error (or warning) message.
1858
+ * Set internal error (or warning) message.
936
1859
  *
937
1860
  *----------------------------------------------------------------------
938
1861
  */
@@ -955,7 +1878,7 @@ set_err(const char *msg, int warn)
955
1878
  /*
956
1879
  *----------------------------------------------------------------------
957
1880
  *
958
- * Functions to retrieve last SQL error or warning.
1881
+ * Functions to retrieve last SQL error or warning.
959
1882
  *
960
1883
  *----------------------------------------------------------------------
961
1884
  */
@@ -985,6 +1908,7 @@ get_err_or_info(SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, int isinfo)
985
1908
  msg[SQL_MAX_MESSAGE_LENGTH - 1] = '\0';
986
1909
  switch (err) {
987
1910
  case SQL_SUCCESS:
1911
+ case SQL_SUCCESS_WITH_INFO:
988
1912
  #ifdef UNICODE
989
1913
  v = uc_str_new2(state);
990
1914
  #else
@@ -1286,7 +2210,7 @@ succeeded_nodata(SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, SQLRETURN ret,
1286
2210
  /*
1287
2211
  *----------------------------------------------------------------------
1288
2212
  *
1289
- * Return ENV from VALUE.
2213
+ * Return ENV from VALUE.
1290
2214
  *
1291
2215
  *----------------------------------------------------------------------
1292
2216
  */
@@ -1327,7 +2251,7 @@ get_env(VALUE self)
1327
2251
  /*
1328
2252
  *----------------------------------------------------------------------
1329
2253
  *
1330
- * Return DBC from VALUE.
2254
+ * Return DBC from VALUE.
1331
2255
  *
1332
2256
  *----------------------------------------------------------------------
1333
2257
  */
@@ -1353,7 +2277,7 @@ get_dbc(VALUE self)
1353
2277
  /*
1354
2278
  *----------------------------------------------------------------------
1355
2279
  *
1356
- * Raise ODBC error from Ruby.
2280
+ * Raise ODBC error from Ruby.
1357
2281
  *
1358
2282
  *----------------------------------------------------------------------
1359
2283
  */
@@ -1384,7 +2308,7 @@ dbc_raise(VALUE self, VALUE msg)
1384
2308
  /*
1385
2309
  *----------------------------------------------------------------------
1386
2310
  *
1387
- * Obtain an ENV.
2311
+ * Obtain an ENV.
1388
2312
  *
1389
2313
  *----------------------------------------------------------------------
1390
2314
  */
@@ -1422,7 +2346,7 @@ env_new(VALUE self)
1422
2346
  /*
1423
2347
  *----------------------------------------------------------------------
1424
2348
  *
1425
- * Obtain array of known DSNs.
2349
+ * Obtain array of known DSNs.
1426
2350
  *
1427
2351
  *----------------------------------------------------------------------
1428
2352
  */
@@ -1477,7 +2401,7 @@ dbc_dsns(VALUE self)
1477
2401
  /*
1478
2402
  *----------------------------------------------------------------------
1479
2403
  *
1480
- * Obtain array of known drivers.
2404
+ * Obtain array of known drivers.
1481
2405
  *
1482
2406
  *----------------------------------------------------------------------
1483
2407
  */
@@ -1553,7 +2477,7 @@ dbc_drivers(VALUE self)
1553
2477
  /*
1554
2478
  *----------------------------------------------------------------------
1555
2479
  *
1556
- * Management methods.
2480
+ * Management methods.
1557
2481
  *
1558
2482
  *----------------------------------------------------------------------
1559
2483
  */
@@ -1599,7 +2523,7 @@ conf_dsn(int argc, VALUE *argv, VALUE self, int op)
1599
2523
  if (rb_obj_is_kind_of(attr, rb_cHash) == Qtrue) {
1600
2524
  VALUE a, x;
1601
2525
 
1602
- a = rb_funcall(attr, IDkeys, 0, NULL);
2526
+ a = FUNCALL_NOARGS(attr, IDkeys);
1603
2527
  while ((x = rb_ary_shift(a)) != Qnil) {
1604
2528
  VALUE v = rb_hash_aref(attr, x);
1605
2529
 
@@ -1872,7 +2796,7 @@ dbc_rfdsn(int argc, VALUE *argv, VALUE self)
1872
2796
  /*
1873
2797
  *----------------------------------------------------------------------
1874
2798
  *
1875
- * Return last ODBC error or warning.
2799
+ * Return last ODBC error or warning.
1876
2800
  *
1877
2801
  *----------------------------------------------------------------------
1878
2802
  */
@@ -1900,7 +2824,7 @@ dbc_clrerror(VALUE self)
1900
2824
  /*
1901
2825
  *----------------------------------------------------------------------
1902
2826
  *
1903
- * Connection instance initializer.
2827
+ * Connection instance initializer.
1904
2828
  *
1905
2829
  *----------------------------------------------------------------------
1906
2830
  */
@@ -1972,7 +2896,7 @@ dbc_new(int argc, VALUE *argv, VALUE self)
1972
2896
  /*
1973
2897
  *----------------------------------------------------------------------
1974
2898
  *
1975
- * Connect to data source.
2899
+ * Connect to data source.
1976
2900
  *
1977
2901
  *----------------------------------------------------------------------
1978
2902
  */
@@ -2062,7 +2986,7 @@ dbc_connect(int argc, VALUE *argv, VALUE self)
2062
2986
  rb_raise(Cerror, "%s", msg);
2063
2987
  }
2064
2988
  if (!succeeded(SQL_NULL_HENV, dbc, SQL_NULL_HSTMT,
2065
- SQLConnect(dbc, (SQLTCHAR *) sdsn, SQL_NTS,
2989
+ SQLCONNECT(dbc, (SQLTCHAR *) sdsn, SQL_NTS,
2066
2990
  (SQLTCHAR *) suser,
2067
2991
  (SQLSMALLINT) (suser ? SQL_NTS : 0),
2068
2992
  (SQLTCHAR *) spasswd,
@@ -2104,7 +3028,7 @@ dbc_drvconnect(VALUE self, VALUE drv)
2104
3028
  VALUE d, a, x;
2105
3029
 
2106
3030
  d = rb_str_new2("");
2107
- a = rb_funcall(rb_iv_get(drv, "@attrs"), IDkeys, 0, NULL);
3031
+ a = FUNCALL_NOARGS(rb_iv_get(drv, "@attrs"), IDkeys);
2108
3032
  while ((x = rb_ary_shift(a)) != Qnil) {
2109
3033
  VALUE v = rb_hash_aref(rb_iv_get(drv, "@attrs"), x);
2110
3034
 
@@ -2146,7 +3070,7 @@ dbc_drvconnect(VALUE self, VALUE drv)
2146
3070
  rb_raise(Cerror, "%s", msg);
2147
3071
  }
2148
3072
  if (!succeeded(e->henv, dbc, SQL_NULL_HSTMT,
2149
- SQLDriverConnect(dbc, NULL, (SQLTCHAR *) sdrv, SQL_NTS,
3073
+ SQLDRIVERCONNECT(dbc, NULL, (SQLTCHAR *) sdrv, SQL_NTS,
2150
3074
  NULL, 0, NULL, SQL_DRIVER_NOPROMPT),
2151
3075
  &msg, "SQLDriverConnect")) {
2152
3076
  #ifdef UNICODE
@@ -2214,7 +3138,7 @@ dbc_use_scn(int argc, VALUE *argv, VALUE self)
2214
3138
  /*
2215
3139
  *----------------------------------------------------------------------
2216
3140
  *
2217
- * Drop all active statements from data source.
3141
+ * Drop all active statements from data source.
2218
3142
  *
2219
3143
  *----------------------------------------------------------------------
2220
3144
  */
@@ -2238,7 +3162,7 @@ dbc_dropall(VALUE self)
2238
3162
  /*
2239
3163
  *----------------------------------------------------------------------
2240
3164
  *
2241
- * Disconnect from data source.
3165
+ * Disconnect from data source.
2242
3166
  *
2243
3167
  *----------------------------------------------------------------------
2244
3168
  */
@@ -2259,7 +3183,7 @@ dbc_disconnect(int argc, VALUE *argv, VALUE self)
2259
3183
  }
2260
3184
  if (list_empty(&p->stmts)) {
2261
3185
  callsql(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
2262
- SQLDisconnect(p->hdbc), "SQLDisconnect");
3186
+ SQLDISCONNECT(p->hdbc), "SQLDisconnect");
2263
3187
  if (!succeeded(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
2264
3188
  SQLFreeConnect(p->hdbc), &msg, "SQLFreeConnect")) {
2265
3189
  rb_raise(Cerror, "%s", msg);
@@ -2275,11 +3199,21 @@ dbc_disconnect(int argc, VALUE *argv, VALUE self)
2275
3199
  /*
2276
3200
  *----------------------------------------------------------------------
2277
3201
  *
2278
- * Database meta data via SQLGetInfo()
3202
+ * Database meta data via SQLGetInfo()
2279
3203
  *
2280
3204
  *----------------------------------------------------------------------
2281
3205
  */
2282
3206
 
3207
+ #ifndef SQL_DTC_TRANSITION_COST
3208
+ #define SQL_DTC_TRANSITION_COST 1750
3209
+ #endif
3210
+ #ifndef SQL_DTC_ENLIST_EXPENSIZE
3211
+ #define SQL_DTC_ENLIST_EXPENDSIZE 1
3212
+ #endif
3213
+ #ifndef SQL_DTC_UNENLIST_EXPENSIZE
3214
+ #define SQL_DTC_UNENLIST_EXPENDSIZE 2
3215
+ #endif
3216
+
2283
3217
  #define GI_CONST_SINT(x) { #x, x, SQL_C_SHORT }
2284
3218
  #define GI_CONST_INT(x) { #x, x, SQL_C_LONG }
2285
3219
  #define GI_CONST_BITS(x) { #x, x, SQL_C_LONG }
@@ -3189,7 +4123,7 @@ dbc_getinfo(int argc, VALUE *argv, VALUE self)
3189
4123
  /*
3190
4124
  *----------------------------------------------------------------------
3191
4125
  *
3192
- * Fill column type array for statement.
4126
+ * Fill column type array for statement.
3193
4127
  *
3194
4128
  *----------------------------------------------------------------------
3195
4129
  */
@@ -3199,10 +4133,10 @@ make_coltypes(SQLHSTMT hstmt, int ncols, char **msgp)
3199
4133
  {
3200
4134
  int i;
3201
4135
  COLTYPE *ret = NULL;
3202
- SQLLEN type, size = 0;
3203
4136
 
3204
4137
  for (i = 0; i < ncols; i++) {
3205
4138
  SQLUSMALLINT ic = i + 1;
4139
+ SQLLEN type = SQL_UNKNOWN_TYPE, size = 0;
3206
4140
 
3207
4141
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3208
4142
  SQLColAttributes(hstmt, ic,
@@ -3228,6 +4162,7 @@ make_coltypes(SQLHSTMT hstmt, int ncols, char **msgp)
3228
4162
  }
3229
4163
  for (i = 0; i < ncols; i++) {
3230
4164
  SQLUSMALLINT ic = i + 1;
4165
+ SQLLEN type = SQL_UNKNOWN_TYPE, size = 0;
3231
4166
 
3232
4167
  callsql(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3233
4168
  SQLColAttributes(hstmt, ic,
@@ -3313,6 +4248,22 @@ make_coltypes(SQLHSTMT hstmt, int ncols, char **msgp)
3313
4248
  }
3314
4249
  break;
3315
4250
  #endif
4251
+ case SQL_DECIMAL:
4252
+ case SQL_NUMERIC:
4253
+ if ((size == 0) || (size > SEGSIZE)) {
4254
+ size = SQL_NO_TOTAL;
4255
+ }
4256
+ if (size != SQL_NO_TOTAL) {
4257
+ size += 2; /* sign and decimal point */
4258
+ size += 1; /* NUL terminator */
4259
+ }
4260
+ #ifdef UNICODE
4261
+ type = SQL_C_WCHAR;
4262
+ size *= sizeof (SQLWCHAR);
4263
+ #else
4264
+ type = SQL_C_CHAR;
4265
+ #endif
4266
+ break;
3316
4267
  default:
3317
4268
  if ((size == 0) || (size > SEGSIZE)) {
3318
4269
  size = SQL_NO_TOTAL;
@@ -3340,7 +4291,7 @@ make_coltypes(SQLHSTMT hstmt, int ncols, char **msgp)
3340
4291
  /*
3341
4292
  *----------------------------------------------------------------------
3342
4293
  *
3343
- * Fill parameter info array for statement.
4294
+ * Fill parameter info array for statement.
3344
4295
  *
3345
4296
  *----------------------------------------------------------------------
3346
4297
  */
@@ -3367,7 +4318,7 @@ make_paraminfo(SQLHSTMT hstmt, int nump, char **msgp)
3367
4318
  #ifdef UNICODE
3368
4319
  paraminfo[i].outtype = SQL_WCHAR;
3369
4320
  #else
3370
- paraminfo[i].outtype = SQL_WCHAR;
4321
+ paraminfo[i].outtype = SQL_CHAR;
3371
4322
  #endif
3372
4323
  paraminfo[i].coldef_max = 0;
3373
4324
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
@@ -3420,7 +4371,7 @@ retain_paraminfo_override(STMT *q, int nump, PARAMINFO *paraminfo)
3420
4371
  /*
3421
4372
  *----------------------------------------------------------------------
3422
4373
  *
3423
- * Wrap SQLHSTMT into struct/VALUE.
4374
+ * Wrap SQLHSTMT into struct/VALUE.
3424
4375
  *
3425
4376
  *----------------------------------------------------------------------
3426
4377
  */
@@ -3465,7 +4416,7 @@ wrap_stmt(VALUE dbc, DBC *p, SQLHSTMT hstmt, STMT **qp)
3465
4416
  /*
3466
4417
  *----------------------------------------------------------------------
3467
4418
  *
3468
- * Create statement with result.
4419
+ * Create statement with result.
3469
4420
  *
3470
4421
  *----------------------------------------------------------------------
3471
4422
  */
@@ -3575,7 +4526,7 @@ upcase_if(char *string, int upc)
3575
4526
  /*
3576
4527
  *----------------------------------------------------------------------
3577
4528
  *
3578
- * Constructor: make column from statement.
4529
+ * Constructor: make column from statement.
3579
4530
  *
3580
4531
  *----------------------------------------------------------------------
3581
4532
  */
@@ -3585,7 +4536,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3585
4536
  {
3586
4537
  VALUE obj, v;
3587
4538
  SQLUSMALLINT ic = i + 1;
3588
- SQLLEN iv = 0;
4539
+ SQLLEN iv;
3589
4540
  #ifdef UNICODE
3590
4541
  SQLWCHAR name[SQL_MAX_MESSAGE_LENGTH];
3591
4542
  #else
@@ -3657,6 +4608,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3657
4608
  #endif
3658
4609
  }
3659
4610
  rb_iv_set(obj, "@table", v);
4611
+ iv = SQL_UNKNOWN_TYPE;
3660
4612
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3661
4613
  SQLColAttributes(hstmt, ic, SQL_COLUMN_TYPE, NULL,
3662
4614
  0, NULL, &iv),
@@ -3667,6 +4619,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3667
4619
  }
3668
4620
  rb_iv_set(obj, "@type", v);
3669
4621
  v = Qnil;
4622
+ iv = 0;
3670
4623
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3671
4624
  SQLColAttributes(hstmt, ic,
3672
4625
  #if (ODBCVER >= 0x0300)
@@ -3692,6 +4645,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3692
4645
  }
3693
4646
  rb_iv_set(obj, "@length", v);
3694
4647
  v = Qnil;
4648
+ iv = SQL_NO_NULLS;
3695
4649
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3696
4650
  SQLColAttributes(hstmt, ic, SQL_COLUMN_NULLABLE, NULL,
3697
4651
  0, NULL, &iv),
@@ -3700,6 +4654,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3700
4654
  }
3701
4655
  rb_iv_set(obj, "@nullable", v);
3702
4656
  v = Qnil;
4657
+ iv = 0;
3703
4658
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3704
4659
  SQLColAttributes(hstmt, ic, SQL_COLUMN_SCALE, NULL,
3705
4660
  0, NULL, &iv),
@@ -3708,6 +4663,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3708
4663
  }
3709
4664
  rb_iv_set(obj, "@scale", v);
3710
4665
  v = Qnil;
4666
+ iv = 0;
3711
4667
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3712
4668
  SQLColAttributes(hstmt, ic, SQL_COLUMN_PRECISION, NULL,
3713
4669
  0, NULL, &iv),
@@ -3716,23 +4672,26 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3716
4672
  }
3717
4673
  rb_iv_set(obj, "@precision", v);
3718
4674
  v = Qnil;
4675
+ iv = SQL_UNSEARCHABLE;
3719
4676
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3720
4677
  SQLColAttributes(hstmt, ic, SQL_COLUMN_SEARCHABLE, NULL,
3721
4678
  0, NULL, &iv),
3722
4679
  NULL, "SQLColAttributes(SQL_COLUMN_SEARCHABLE)")) {
3723
- v = (iv == SQL_NO_NULLS) ? Qfalse : Qtrue;
4680
+ v = (iv == SQL_UNSEARCHABLE) ? Qfalse : Qtrue;
3724
4681
  }
3725
4682
  rb_iv_set(obj, "@searchable", v);
3726
4683
  v = Qnil;
4684
+ iv = SQL_FALSE;
3727
4685
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3728
4686
  SQLColAttributes(hstmt, ic, SQL_COLUMN_UNSIGNED, NULL,
3729
4687
  0, NULL, &iv),
3730
4688
  NULL, "SQLColAttributes(SQL_COLUMN_UNSIGNED)")) {
3731
- v = (iv == SQL_NO_NULLS) ? Qfalse : Qtrue;
4689
+ v = (iv == SQL_FALSE) ? Qfalse : Qtrue;
3732
4690
  }
3733
4691
  rb_iv_set(obj, "@unsigned", v);
3734
4692
  v = Qnil;
3735
4693
  #ifdef SQL_COLUMN_AUTO_INCREMENT
4694
+ iv = SQL_FALSE;
3736
4695
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3737
4696
  SQLColAttributes(hstmt, ic, SQL_COLUMN_AUTO_INCREMENT, NULL,
3738
4697
  0, NULL, &iv),
@@ -3747,7 +4706,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
3747
4706
  /*
3748
4707
  *----------------------------------------------------------------------
3749
4708
  *
3750
- * Constructor: make parameter from statement.
4709
+ * Constructor: make parameter from statement.
3751
4710
  *
3752
4711
  *----------------------------------------------------------------------
3753
4712
  */
@@ -3760,9 +4719,9 @@ make_param(STMT *q, int i)
3760
4719
 
3761
4720
  obj = rb_obj_alloc(Cparam);
3762
4721
  #ifdef UNICODE
3763
- v = q->paraminfo ? q->paraminfo[i].type : SQL_VARCHAR;
3764
- #else
3765
4722
  v = q->paraminfo ? q->paraminfo[i].type : SQL_WVARCHAR;
4723
+ #else
4724
+ v = q->paraminfo ? q->paraminfo[i].type : SQL_VARCHAR;
3766
4725
  #endif
3767
4726
  rb_iv_set(obj, "@type", INT2NUM(v));
3768
4727
  v = q->paraminfo ? q->paraminfo[i].coldef : 0;
@@ -3787,7 +4746,7 @@ make_param(STMT *q, int i)
3787
4746
  /*
3788
4747
  *----------------------------------------------------------------------
3789
4748
  *
3790
- * Query tables/columns/keys/indexes/types of data source.
4749
+ * Query tables/columns/keys/indexes/types of data source.
3791
4750
  *
3792
4751
  *----------------------------------------------------------------------
3793
4752
  */
@@ -3900,7 +4859,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3900
4859
  switch (mode) {
3901
4860
  case INFO_TABLES:
3902
4861
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3903
- SQLTables(hstmt, NULL, 0, NULL, 0,
4862
+ SQLTABLES(hstmt, NULL, 0, NULL, 0,
3904
4863
  swhich, (swhich == NULL) ? 0 : SQL_NTS,
3905
4864
  NULL, 0),
3906
4865
  &msg, "SQLTables")) {
@@ -3909,7 +4868,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3909
4868
  break;
3910
4869
  case INFO_COLUMNS:
3911
4870
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3912
- SQLColumns(hstmt, NULL, 0, NULL, 0,
4871
+ SQLCOLUMNS(hstmt, NULL, 0, NULL, 0,
3913
4872
  swhich, (swhich == NULL) ? 0 : SQL_NTS,
3914
4873
  swhich2, (swhich2 == NULL) ? 0 : SQL_NTS),
3915
4874
  &msg, "SQLColumns")) {
@@ -3918,7 +4877,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3918
4877
  break;
3919
4878
  case INFO_PRIMKEYS:
3920
4879
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3921
- SQLPrimaryKeys(hstmt, NULL, 0, NULL, 0,
4880
+ SQLPRIMARYKEYS(hstmt, NULL, 0, NULL, 0,
3922
4881
  swhich, (swhich == NULL) ? 0 : SQL_NTS),
3923
4882
  &msg, "SQLPrimaryKeys")) {
3924
4883
  goto error;
@@ -3926,7 +4885,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3926
4885
  break;
3927
4886
  case INFO_INDEXES:
3928
4887
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3929
- SQLStatistics(hstmt, NULL, 0, NULL, 0,
4888
+ SQLSTATISTICS(hstmt, NULL, 0, NULL, 0,
3930
4889
  swhich, (swhich == NULL) ? 0 : SQL_NTS,
3931
4890
  (SQLUSMALLINT) (RTEST(which2) ?
3932
4891
  SQL_INDEX_UNIQUE : SQL_INDEX_ALL),
@@ -3937,14 +4896,14 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3937
4896
  break;
3938
4897
  case INFO_TYPES:
3939
4898
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3940
- SQLGetTypeInfo(hstmt, (SQLSMALLINT) itype),
4899
+ SQLGETTYPEINFO(hstmt, (SQLSMALLINT) itype),
3941
4900
  &msg, "SQLGetTypeInfo")) {
3942
4901
  goto error;
3943
4902
  }
3944
4903
  break;
3945
4904
  case INFO_FORKEYS:
3946
4905
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3947
- SQLForeignKeys(hstmt, NULL, 0, NULL, 0,
4906
+ SQLFOREIGNKEYS(hstmt, NULL, 0, NULL, 0,
3948
4907
  swhich, (swhich == NULL) ? 0 : SQL_NTS,
3949
4908
  NULL, 0, NULL, 0,
3950
4909
  swhich2, (swhich2 == NULL) ? 0 : SQL_NTS),
@@ -3954,7 +4913,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3954
4913
  break;
3955
4914
  case INFO_TPRIV:
3956
4915
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3957
- SQLTablePrivileges(hstmt, NULL, 0, NULL, 0, swhich,
4916
+ SQLTABLEPRIVILEGES(hstmt, NULL, 0, NULL, 0, swhich,
3958
4917
  (swhich == NULL) ? 0 : SQL_NTS),
3959
4918
  &msg, "SQLTablePrivileges")) {
3960
4919
  goto error;
@@ -3962,7 +4921,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3962
4921
  break;
3963
4922
  case INFO_PROCS:
3964
4923
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3965
- SQLProcedures(hstmt, NULL, 0, NULL, 0,
4924
+ SQLPROCEDURES(hstmt, NULL, 0, NULL, 0,
3966
4925
  swhich, (swhich == NULL) ? 0 : SQL_NTS),
3967
4926
  &msg, "SQLProcedures")) {
3968
4927
  goto error;
@@ -3970,7 +4929,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3970
4929
  break;
3971
4930
  case INFO_PROCCOLS:
3972
4931
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3973
- SQLProcedureColumns(hstmt, NULL, 0, NULL, 0,
4932
+ SQLPROCEDURECOLUMNS(hstmt, NULL, 0, NULL, 0,
3974
4933
  swhich,
3975
4934
  (swhich == NULL) ? 0 : SQL_NTS,
3976
4935
  swhich2,
@@ -3981,7 +4940,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
3981
4940
  break;
3982
4941
  case INFO_SPECCOLS:
3983
4942
  if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
3984
- SQLSpecialColumns(hstmt, (SQLUSMALLINT) iid,
4943
+ SQLSPECIALCOLUMNS(hstmt, (SQLUSMALLINT) iid,
3985
4944
  NULL, 0, NULL, 0,
3986
4945
  swhich,
3987
4946
  (swhich == NULL) ? 0 : SQL_NTS,
@@ -4071,7 +5030,7 @@ dbc_speccols(int argc, VALUE *argv, VALUE self)
4071
5030
  /*
4072
5031
  *----------------------------------------------------------------------
4073
5032
  *
4074
- * Transaction stuff.
5033
+ * Transaction stuff.
4075
5034
  *
4076
5035
  *----------------------------------------------------------------------
4077
5036
  */
@@ -4081,6 +5040,7 @@ dbc_trans(VALUE self, int what)
4081
5040
  {
4082
5041
  ENV *e;
4083
5042
  SQLHDBC dbc = SQL_NULL_HDBC;
5043
+ SQLRETURN ret;
4084
5044
  char *msg;
4085
5045
 
4086
5046
  e = get_env(self);
@@ -4090,16 +5050,18 @@ dbc_trans(VALUE self, int what)
4090
5050
  d = get_dbc(self);
4091
5051
  dbc = d->hdbc;
4092
5052
  }
4093
- if (!succeeded(e->henv, dbc, SQL_NULL_HSTMT,
4094
5053
  #if (ODBCVER >= 0x0300)
4095
- SQLEndTran((SQLSMALLINT)
4096
- ((dbc == SQL_NULL_HDBC) ? SQL_HANDLE_ENV :
4097
- SQL_HANDLE_DBC),
4098
- (dbc == SQL_NULL_HDBC) ? e->henv : dbc,
4099
- (SQLSMALLINT) what),
5054
+ ret = SQLENDTRAN((SQLSMALLINT)
5055
+ ((dbc == SQL_NULL_HDBC) ? SQL_HANDLE_ENV : SQL_HANDLE_DBC),
5056
+ (dbc == SQL_NULL_HDBC) ? e->henv : dbc,
5057
+ (SQLSMALLINT) what);
5058
+ #else
5059
+ ret = SQLTRANSACT(e->henv, dbc, (SQLUSMALLINT) what);
5060
+ #endif
5061
+ if (!succeeded(e->henv, dbc, SQL_NULL_HSTMT, ret,
5062
+ #if (ODBCVER >= 0x0300)
4100
5063
  &msg, "SQLEndTran"
4101
5064
  #else
4102
- SQLTransact(e->henv, dbc, (SQLUSMALLINT) what),
4103
5065
  &msg, "SQLTransact"
4104
5066
  #endif
4105
5067
  )) {
@@ -4159,14 +5121,14 @@ dbc_transaction(VALUE self)
4159
5121
  }
4160
5122
  ret = rb_ary_entry(a, 1);
4161
5123
  rb_exc_raise(rb_exc_new3(rb_obj_class(ret),
4162
- rb_funcall(ret, IDto_s, 0, 0)));
5124
+ FUNCALL_NOARGS(ret, IDto_s)));
4163
5125
  return Qnil;
4164
5126
  }
4165
5127
 
4166
5128
  /*
4167
5129
  *----------------------------------------------------------------------
4168
5130
  *
4169
- * Environment attribute handling.
5131
+ * Environment attribute handling.
4170
5132
  *
4171
5133
  *----------------------------------------------------------------------
4172
5134
  */
@@ -4247,17 +5209,17 @@ env_odbcver(int argc, VALUE *argv, VALUE self)
4247
5209
  /*
4248
5210
  *----------------------------------------------------------------------
4249
5211
  *
4250
- * Connection/statement option handling.
5212
+ * Connection/statement option handling.
4251
5213
  *
4252
- * Note:
4253
- * ODBC 2 allows statement options to be set using SQLSetConnectOption,
4254
- * establishing the statement option as a default for any hstmts
4255
- * later allocated for that hdbc. This feature was deprecated in
4256
- * ODBC 3.x and may not work with ODBC 3.x drivers.
5214
+ * Note:
5215
+ * ODBC 2 allows statement options to be set using SQLSetConnectOption,
5216
+ * establishing the statement option as a default for any hstmts
5217
+ * later allocated for that hdbc. This feature was deprecated in
5218
+ * ODBC 3.x and may not work with ODBC 3.x drivers.
4257
5219
  *
4258
- * Although the Database class includes attribute accessors for
4259
- * statement-level options, a safer alternative, if using an ODBC 3
4260
- * driver, is to set the option directly on the Statement instance.
5220
+ * Although the Database class includes attribute accessors for
5221
+ * statement-level options, a safer alternative, if using an ODBC 3
5222
+ * driver, is to set the option directly on the Statement instance.
4261
5223
  *
4262
5224
  *----------------------------------------------------------------------
4263
5225
  */
@@ -4276,6 +5238,7 @@ static struct {
4276
5238
 
4277
5239
  /* yielding ints */
4278
5240
  OPT_CONST_INT(SQL_AUTOCOMMIT, OPT_LEVEL_DBC),
5241
+ OPT_CONST_INT(SQL_LOGIN_TIMEOUT, OPT_LEVEL_DBC),
4279
5242
  OPT_CONST_INT(SQL_NOSCAN, OPT_LEVEL_BOTH),
4280
5243
  OPT_CONST_INT(SQL_CONCURRENCY, OPT_LEVEL_BOTH),
4281
5244
  OPT_CONST_INT(SQL_QUERY_TIMEOUT, OPT_LEVEL_BOTH),
@@ -4293,12 +5256,16 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
4293
5256
  {
4294
5257
  DBC *p = NULL;
4295
5258
  STMT *q = NULL;
4296
- VALUE val, val2, vstr;
5259
+ VALUE val, val2 = Qnil;
4297
5260
  SQLINTEGER v;
4298
5261
  char *msg;
4299
5262
  int level = isstmt ? OPT_LEVEL_STMT : OPT_LEVEL_DBC;
4300
5263
 
4301
- rb_scan_args(argc, argv, (op == -1) ? "11" : "01", &val, &val2);
5264
+ if (op == -1) {
5265
+ rb_scan_args(argc, argv, "11", &val, &val2);
5266
+ } else {
5267
+ rb_scan_args(argc, argv, "01", &val);
5268
+ }
4302
5269
  if (isstmt) {
4303
5270
  Data_Get_Struct(self, STMT, q);
4304
5271
  if (q->dbc == Qnil) {
@@ -4314,6 +5281,7 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
4314
5281
  }
4315
5282
  }
4316
5283
  if (op == -1) {
5284
+ VALUE vstr;
4317
5285
  char *string;
4318
5286
  int i, op_found = 0;
4319
5287
 
@@ -4385,8 +5353,8 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
4385
5353
  if (val == Qnil) {
4386
5354
  return v ? Qtrue : Qfalse;
4387
5355
  }
4388
- v = (TYPE(val) == T_FIXNUM) ?
4389
- (FIX2INT(val) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF) :
5356
+ v = (TYPE(val) == T_FIXNUM) ?
5357
+ (FIX2INT(val) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF) :
4390
5358
  (RTEST(val) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
4391
5359
  break;
4392
5360
 
@@ -4394,11 +5362,12 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
4394
5362
  if (val == Qnil) {
4395
5363
  return v ? Qtrue : Qfalse;
4396
5364
  }
4397
- v = (TYPE(val) == T_FIXNUM) ?
4398
- (FIX2INT(val) ? SQL_NOSCAN_ON : SQL_NOSCAN_OFF) :
5365
+ v = (TYPE(val) == T_FIXNUM) ?
5366
+ (FIX2INT(val) ? SQL_NOSCAN_ON : SQL_NOSCAN_OFF) :
4399
5367
  (RTEST(val) ? SQL_NOSCAN_ON : SQL_NOSCAN_OFF);
4400
5368
  break;
4401
5369
 
5370
+ case SQL_LOGIN_TIMEOUT:
4402
5371
  case SQL_CONCURRENCY:
4403
5372
  case SQL_QUERY_TIMEOUT:
4404
5373
  case SQL_MAX_ROWS:
@@ -4424,7 +5393,7 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
4424
5393
  rb_raise(Cerror, "%s", msg);
4425
5394
  }
4426
5395
  } else {
4427
- if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
5396
+ if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
4428
5397
  SQLSetStmtOption(q->hstmt, (SQLUSMALLINT) op,
4429
5398
  (SQLUINTEGER) v),
4430
5399
  &msg, "SQLSetStmtOption(%d)", op)) {
@@ -4458,6 +5427,12 @@ dbc_timeout(int argc, VALUE *argv, VALUE self)
4458
5427
  return do_option(argc, argv, self, 0, SQL_QUERY_TIMEOUT);
4459
5428
  }
4460
5429
 
5430
+ static VALUE
5431
+ dbc_login_timeout(int argc, VALUE *argv, VALUE self)
5432
+ {
5433
+ return do_option(argc, argv, self, 0, SQL_LOGIN_TIMEOUT);
5434
+ }
5435
+
4461
5436
  static VALUE
4462
5437
  dbc_maxlength(int argc, VALUE *argv, VALUE self)
4463
5438
  {
@@ -4539,7 +5514,7 @@ stmt_getsetoption(int argc, VALUE *argv, VALUE self)
4539
5514
  /*
4540
5515
  *----------------------------------------------------------------------
4541
5516
  *
4542
- * Scan literal date/time/timestamp to TIMESTAMP_STRUCT.
5517
+ * Scan literal date/time/timestamp to TIMESTAMP_STRUCT.
4543
5518
  *
4544
5519
  *----------------------------------------------------------------------
4545
5520
  */
@@ -4573,7 +5548,7 @@ scan_dtts(VALUE str, int do_d, int do_t, TIMESTAMP_STRUCT *ts)
4573
5548
  ts->day = dd;
4574
5549
  return 1;
4575
5550
  }
4576
- if (do_t &&
5551
+ if (do_t &&
4577
5552
  (sscanf(cstr, "{t '%d:%d:%d' %c", &hh, &mmm, &ss, &c) == 4) &&
4578
5553
  (c == '}')) {
4579
5554
  ts->hour = yy;
@@ -4617,7 +5592,7 @@ next:
4617
5592
  /*
4618
5593
  *----------------------------------------------------------------------
4619
5594
  *
4620
- * Date methods.
5595
+ * Date methods.
4621
5596
  *
4622
5597
  *----------------------------------------------------------------------
4623
5598
  */
@@ -4638,7 +5613,7 @@ date_new(int argc, VALUE *argv, VALUE self)
4638
5613
  {
4639
5614
  DATE_STRUCT *date;
4640
5615
  VALUE obj = Data_Make_Struct(self, DATE_STRUCT, 0, xfree, date);
4641
-
5616
+
4642
5617
  rb_obj_call_init(obj, argc, argv);
4643
5618
  return obj;
4644
5619
  }
@@ -4711,16 +5686,16 @@ date_init(int argc, VALUE *argv, VALUE self)
4711
5686
  if (argc > 1) {
4712
5687
  rb_raise(rb_eArgError, "wrong # arguments");
4713
5688
  }
4714
- d = rb_funcall(y, IDday, 0, NULL);
4715
- m = rb_funcall(y, IDmonth, 0, NULL);
4716
- y = rb_funcall(y, IDyear, 0, NULL);
5689
+ d = FUNCALL_NOARGS(y, IDday);
5690
+ m = FUNCALL_NOARGS(y, IDmonth);
5691
+ y = FUNCALL_NOARGS(y, IDyear);
4717
5692
  } else if (rb_obj_is_kind_of(y, rb_cDate) == Qtrue) {
4718
5693
  if (argc > 1) {
4719
5694
  rb_raise(rb_eArgError, "wrong # arguments");
4720
5695
  }
4721
- d = rb_funcall(y, IDmday, 0, NULL);
4722
- m = rb_funcall(y, IDmonth, 0, NULL);
4723
- y = rb_funcall(y, IDyear, 0, NULL);
5696
+ d = FUNCALL_NOARGS(y, IDmday);
5697
+ m = FUNCALL_NOARGS(y, IDmonth);
5698
+ y = FUNCALL_NOARGS(y, IDyear);
4724
5699
  } else if ((argc == 1) && (rb_obj_is_kind_of(y, rb_cString) == Qtrue)) {
4725
5700
  if (date_load1(self, y, 0) != Qnil) {
4726
5701
  return self;
@@ -4852,7 +5827,7 @@ date_cmp(VALUE self, VALUE date)
4852
5827
  /*
4853
5828
  *----------------------------------------------------------------------
4854
5829
  *
4855
- * Time methods.
5830
+ * Time methods.
4856
5831
  *
4857
5832
  *----------------------------------------------------------------------
4858
5833
  */
@@ -4873,7 +5848,7 @@ time_new(int argc, VALUE *argv, VALUE self)
4873
5848
  {
4874
5849
  TIME_STRUCT *time;
4875
5850
  VALUE obj = Data_Make_Struct(self, TIME_STRUCT, 0, xfree, time);
4876
-
5851
+
4877
5852
  rb_obj_call_init(obj, argc, argv);
4878
5853
  return obj;
4879
5854
  }
@@ -4887,7 +5862,7 @@ time_load1(VALUE self, VALUE str, int load)
4887
5862
  if (scan_dtts(str, 0, 1, &tss)) {
4888
5863
  TIME_STRUCT *time;
4889
5864
  VALUE obj;
4890
-
5865
+
4891
5866
  if (load) {
4892
5867
  obj = Data_Make_Struct(self, TIME_STRUCT, 0, xfree, time);
4893
5868
  } else {
@@ -4946,9 +5921,9 @@ time_init(int argc, VALUE *argv, VALUE self)
4946
5921
  if (argc > 1) {
4947
5922
  rb_raise(rb_eArgError, "wrong # arguments");
4948
5923
  }
4949
- s = rb_funcall(h, IDsec, 0, NULL);
4950
- m = rb_funcall(h, IDmin, 0, NULL);
4951
- h = rb_funcall(h, IDhour, 0, NULL);
5924
+ s = FUNCALL_NOARGS(h, IDsec);
5925
+ m = FUNCALL_NOARGS(h, IDmin);
5926
+ h = FUNCALL_NOARGS(h, IDhour);
4952
5927
  } else if ((argc == 1) && (rb_obj_is_kind_of(h, rb_cString) == Qtrue)) {
4953
5928
  if (time_load1(self, h, 0) != Qnil) {
4954
5929
  return self;
@@ -5080,7 +6055,7 @@ time_cmp(VALUE self, VALUE time)
5080
6055
  /*
5081
6056
  *----------------------------------------------------------------------
5082
6057
  *
5083
- * TimeStamp methods.
6058
+ * TimeStamp methods.
5084
6059
  *
5085
6060
  *----------------------------------------------------------------------
5086
6061
  */
@@ -5186,13 +6161,13 @@ timestamp_init(int argc, VALUE *argv, VALUE self)
5186
6161
  if (argc > 1) {
5187
6162
  rb_raise(rb_eArgError, "wrong # arguments");
5188
6163
  }
5189
- f = rb_funcall(y, IDusec, 0, NULL);
5190
- ss = rb_funcall(y, IDsec, 0, NULL);
5191
- mm = rb_funcall(y, IDmin, 0, NULL);
5192
- hh = rb_funcall(y, IDhour, 0, NULL);
5193
- d = rb_funcall(y, IDday, 0, NULL);
5194
- m = rb_funcall(y, IDmonth, 0, NULL);
5195
- y = rb_funcall(y, IDyear, 0, NULL);
6164
+ f = FUNCALL_NOARGS(y, IDusec);
6165
+ ss = FUNCALL_NOARGS(y, IDsec);
6166
+ mm = FUNCALL_NOARGS(y, IDmin);
6167
+ hh = FUNCALL_NOARGS(y, IDhour);
6168
+ d = FUNCALL_NOARGS(y, IDday);
6169
+ m = FUNCALL_NOARGS(y, IDmonth);
6170
+ y = FUNCALL_NOARGS(y, IDyear);
5196
6171
  f = INT2NUM(NUM2INT(f) * 1000);
5197
6172
  } else if (rb_obj_is_kind_of(y, rb_cDate) == Qtrue) {
5198
6173
  if (argc > 1) {
@@ -5202,9 +6177,9 @@ timestamp_init(int argc, VALUE *argv, VALUE self)
5202
6177
  ss = INT2FIX(0);
5203
6178
  mm = INT2FIX(0);
5204
6179
  hh = INT2FIX(0);
5205
- d = rb_funcall(y, IDmday, 0, NULL);
5206
- m = rb_funcall(y, IDmonth, 0, NULL);
5207
- y = rb_funcall(y, IDyear, 0, NULL);
6180
+ d = FUNCALL_NOARGS(y, IDmday);
6181
+ m = FUNCALL_NOARGS(y, IDmonth);
6182
+ y = FUNCALL_NOARGS(y, IDyear);
5208
6183
  } else if ((argc == 1) && (rb_obj_is_kind_of(y, rb_cString) == Qtrue)) {
5209
6184
  if (timestamp_load1(self, y, 0) != Qnil) {
5210
6185
  return self;
@@ -5423,7 +6398,7 @@ timestamp_cmp(VALUE self, VALUE timestamp)
5423
6398
  /*
5424
6399
  *----------------------------------------------------------------------
5425
6400
  *
5426
- * Statement methods.
6401
+ * Statement methods.
5427
6402
  *
5428
6403
  *----------------------------------------------------------------------
5429
6404
  */
@@ -5481,7 +6456,7 @@ check_ncols(STMT *q)
5481
6456
  (q->coltypes == NULL)) {
5482
6457
  COLTYPE *coltypes = NULL;
5483
6458
  SQLSMALLINT cols = 0;
5484
-
6459
+
5485
6460
  if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
5486
6461
  SQLNumResultCols(q->hstmt, &cols), NULL,
5487
6462
  "SQLNumResultCols")
@@ -5679,13 +6654,13 @@ stmt_param_output_value(int argc, VALUE *argv, VALUE self)
5679
6654
 
5680
6655
  time = (TIME_STRUCT *) q->paraminfo[vnum].outbuf;
5681
6656
  frac = rb_float_new(0.0);
5682
- now = rb_funcall(rb_cTime, IDnow, 0, NULL);
6657
+ now = FUNCALL_NOARGS(rb_cTime, IDnow);
5683
6658
  v = rb_funcall(rb_cTime,
5684
6659
  (q->dbcp->gmtime == Qtrue) ? IDutc : IDlocal,
5685
6660
  7,
5686
- rb_funcall(now, IDyear, 0, NULL),
5687
- rb_funcall(now, IDmonth, 0, NULL),
5688
- rb_funcall(now, IDday, 0, NULL),
6661
+ FUNCALL_NOARGS(now, IDyear),
6662
+ FUNCALL_NOARGS(now, IDmonth),
6663
+ FUNCALL_NOARGS(now, IDday),
5689
6664
  INT2NUM(time->hour),
5690
6665
  INT2NUM(time->minute),
5691
6666
  INT2NUM(time->second),
@@ -5985,7 +6960,7 @@ do_fetch(STMT *q, int mode)
5985
6960
  }
5986
6961
  if (q->dbcp != NULL && q->dbcp->use_sql_column_name == Qtrue) {
5987
6962
  use_scn = 1;
5988
- }
6963
+ }
5989
6964
  switch (mode & DOFETCH_MODES) {
5990
6965
  case DOFETCH_HASH:
5991
6966
  case DOFETCH_HASH2:
@@ -6336,14 +7311,14 @@ do_fetch(STMT *q, int mode)
6336
7311
 
6337
7312
  time = (TIME_STRUCT *) valp;
6338
7313
  frac = rb_float_new(0.0);
6339
- now = rb_funcall(rb_cTime, IDnow, 0, NULL);
7314
+ now = FUNCALL_NOARGS(rb_cTime, IDnow);
6340
7315
  v = rb_funcall(rb_cTime,
6341
7316
  (q->dbcp->gmtime == Qtrue) ?
6342
7317
  IDutc : IDlocal,
6343
7318
  7,
6344
- rb_funcall(now, IDyear, 0, NULL),
6345
- rb_funcall(now, IDmonth, 0, NULL),
6346
- rb_funcall(now, IDday, 0, NULL),
7319
+ FUNCALL_NOARGS(now, IDyear),
7320
+ FUNCALL_NOARGS(now, IDmonth),
7321
+ FUNCALL_NOARGS(now, IDday),
6347
7322
  INT2NUM(time->hour),
6348
7323
  INT2NUM(time->minute),
6349
7324
  INT2NUM(time->second),
@@ -6460,7 +7435,7 @@ stmt_fetch1(VALUE self, int bang)
6460
7435
  const char *msg;
6461
7436
  char *err;
6462
7437
  #if (ODBCVER < 0x0300)
6463
- SQLUINTEGER nRows;
7438
+ SQLROWSETSIZE nRows;
6464
7439
  SQLUSMALLINT rowStat[1];
6465
7440
  #endif
6466
7441
 
@@ -6473,10 +7448,10 @@ stmt_fetch1(VALUE self, int bang)
6473
7448
  }
6474
7449
  #if (ODBCVER < 0x0300)
6475
7450
  msg = "SQLExtendedFetch(SQL_FETCH_NEXT)";
6476
- ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
7451
+ ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
6477
7452
  #else
6478
7453
  msg = "SQLFetchScroll(SQL_FETCH_NEXT)";
6479
- ret = SQLFetchScroll(q->hstmt, SQL_FETCH_NEXT, 0);
7454
+ ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_NEXT, 0);
6480
7455
  #endif
6481
7456
  if (ret == SQL_NO_DATA) {
6482
7457
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6492,7 +7467,7 @@ usef:
6492
7467
  /* Fallback to SQLFetch() when others not implemented */
6493
7468
  msg = "SQLFetch";
6494
7469
  q->usef = 1;
6495
- ret = SQLFetch(q->hstmt);
7470
+ ret = SQLFETCH(q->hstmt);
6496
7471
  if (ret == SQL_NO_DATA) {
6497
7472
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
6498
7473
  return Qnil;
@@ -6532,7 +7507,7 @@ stmt_fetch_first1(VALUE self, int bang, int nopos)
6532
7507
  const char *msg;
6533
7508
  char *err;
6534
7509
  #if (ODBCVER < 0x0300)
6535
- SQLUINTEGER nRows;
7510
+ SQLROWSETSIZE nRows;
6536
7511
  SQLUSMALLINT rowStat[1];
6537
7512
  #endif
6538
7513
 
@@ -6545,10 +7520,10 @@ stmt_fetch_first1(VALUE self, int bang, int nopos)
6545
7520
  }
6546
7521
  #if (ODBCVER < 0x0300)
6547
7522
  msg = "SQLExtendedFetch(SQL_FETCH_FIRST)";
6548
- ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
7523
+ ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
6549
7524
  #else
6550
7525
  msg = "SQLFetchScroll(SQL_FETCH_FIRST)";
6551
- ret = SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0);
7526
+ ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0);
6552
7527
  #endif
6553
7528
  if (ret == SQL_NO_DATA) {
6554
7529
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6583,7 +7558,7 @@ stmt_fetch_scroll1(int argc, VALUE *argv, VALUE self, int bang)
6583
7558
  int idir, ioffs = 1;
6584
7559
  char msg[128], *err;
6585
7560
  #if (ODBCVER < 0x0300)
6586
- SQLUINTEGER nRows;
7561
+ SQLROWSETSIZE nRows;
6587
7562
  SQLUSMALLINT rowStat[1];
6588
7563
  #endif
6589
7564
 
@@ -6598,11 +7573,11 @@ stmt_fetch_scroll1(int argc, VALUE *argv, VALUE self, int bang)
6598
7573
  }
6599
7574
  #if (ODBCVER < 0x0300)
6600
7575
  sprintf(msg, "SQLExtendedFetch(%d)", idir);
6601
- ret = SQLExtendedFetch(q->hstmt, (SQLSMALLINT) idir, (SQLINTEGER) ioffs,
7576
+ ret = SQLEXTENDEDFETCH(q->hstmt, (SQLSMALLINT) idir, (SQLROWOFFSET) ioffs,
6602
7577
  &nRows, rowStat);
6603
7578
  #else
6604
7579
  sprintf(msg, "SQLFetchScroll(%d)", idir);
6605
- ret = SQLFetchScroll(q->hstmt, (SQLSMALLINT) idir, (SQLINTEGER) ioffs);
7580
+ ret = SQLFETCHSCROLL(q->hstmt, (SQLSMALLINT) idir, (SQLROWOFFSET) ioffs);
6606
7581
  #endif
6607
7582
  if (ret == SQL_NO_DATA) {
6608
7583
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6703,7 +7678,7 @@ stmt_fetch_hash1(int argc, VALUE *argv, VALUE self, int bang)
6703
7678
  const char *msg;
6704
7679
  char *err;
6705
7680
  #if (ODBCVER < 0x0300)
6706
- SQLUINTEGER nRows;
7681
+ SQLROWSETSIZE nRows;
6707
7682
  SQLUSMALLINT rowStat[1];
6708
7683
  #endif
6709
7684
 
@@ -6716,10 +7691,10 @@ stmt_fetch_hash1(int argc, VALUE *argv, VALUE self, int bang)
6716
7691
  }
6717
7692
  #if (ODBCVER < 0x0300)
6718
7693
  msg = "SQLExtendedFetch(SQL_FETCH_NEXT)";
6719
- ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
7694
+ ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
6720
7695
  #else
6721
7696
  msg = "SQLFetchScroll(SQL_FETCH_NEXT)";
6722
- ret = SQLFetchScroll(q->hstmt, SQL_FETCH_NEXT, 0);
7697
+ ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_NEXT, 0);
6723
7698
  #endif
6724
7699
  if (ret == SQL_NO_DATA) {
6725
7700
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6735,7 +7710,7 @@ usef:
6735
7710
  /* Fallback to SQLFetch() when others not implemented */
6736
7711
  msg = "SQLFetch";
6737
7712
  q->usef = 1;
6738
- ret = SQLFetch(q->hstmt);
7713
+ ret = SQLFETCH(q->hstmt);
6739
7714
  if (ret == SQL_NO_DATA) {
6740
7715
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
6741
7716
  return Qnil;
@@ -6776,7 +7751,7 @@ stmt_fetch_first_hash1(int argc, VALUE *argv, VALUE self, int bang, int nopos)
6776
7751
  const char *msg;
6777
7752
  char *err;
6778
7753
  #if (ODBCVER < 0x0300)
6779
- SQLUINTEGER nRows;
7754
+ SQLROWSETSIZE nRows;
6780
7755
  SQLUSMALLINT rowStat[1];
6781
7756
  #endif
6782
7757
 
@@ -6789,10 +7764,10 @@ stmt_fetch_first_hash1(int argc, VALUE *argv, VALUE self, int bang, int nopos)
6789
7764
  }
6790
7765
  #if (ODBCVER < 0x0300)
6791
7766
  msg = "SQLExtendedFetch(SQL_FETCH_FIRST)";
6792
- ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
7767
+ ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
6793
7768
  #else
6794
7769
  msg = "SQLFetchScroll(SQL_FETCH_FIRST)";
6795
- ret = SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0);
7770
+ ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0);
6796
7771
  #endif
6797
7772
  if (ret == SQL_NO_DATA) {
6798
7773
  (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6818,19 +7793,19 @@ stmt_each(VALUE self)
6818
7793
  VALUE row, res = Qnil;
6819
7794
  STMT *q;
6820
7795
  #if (ODBCVER < 0x0300)
6821
- SQLUINTEGER nRows;
7796
+ SQLROWSETSIZE nRows;
6822
7797
  SQLUSMALLINT rowStat[1];
6823
7798
  #endif
6824
7799
 
6825
7800
  Data_Get_Struct(self, STMT, q);
6826
7801
  #if (ODBCVER < 0x0300)
6827
7802
  switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
6828
- SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
7803
+ SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
6829
7804
  rowStat),
6830
7805
  "SQLExtendedFetch(SQL_FETCH_FIRST)"))
6831
7806
  #else
6832
7807
  switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
6833
- SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0),
7808
+ SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0),
6834
7809
  "SQLFetchScroll(SQL_FETCH_FIRST)"))
6835
7810
  #endif
6836
7811
  {
@@ -6868,7 +7843,7 @@ stmt_each_hash(int argc, VALUE *argv, VALUE self)
6868
7843
  STMT *q;
6869
7844
  int mode = stmt_hash_mode(argc, argv, self);
6870
7845
  #if (ODBCVER < 0x0300)
6871
- SQLUINTEGER nRows;
7846
+ SQLROWSETSIZE nRows;
6872
7847
  SQLUSMALLINT rowStat[1];
6873
7848
  #endif
6874
7849
 
@@ -6884,12 +7859,12 @@ stmt_each_hash(int argc, VALUE *argv, VALUE self)
6884
7859
  Data_Get_Struct(self, STMT, q);
6885
7860
  #if (ODBCVER < 0x0300)
6886
7861
  switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
6887
- SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
7862
+ SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
6888
7863
  rowStat),
6889
7864
  "SQLExtendedFetch(SQL_FETCH_FIRST)"))
6890
7865
  #else
6891
7866
  switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
6892
- SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0),
7867
+ SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0),
6893
7868
  "SQLFetchScroll(SQL_FETCH_FIRST)"))
6894
7869
  #endif
6895
7870
  {
@@ -6955,6 +7930,7 @@ stmt_prep_int(int argc, VALUE *argv, VALUE self, int mode)
6955
7930
  STMT *q = NULL;
6956
7931
  VALUE sql, dbc, stmt;
6957
7932
  SQLHSTMT hstmt;
7933
+ SQLRETURN ret;
6958
7934
  #ifdef UNICODE
6959
7935
  SQLWCHAR *ssql = NULL;
6960
7936
  #else
@@ -7004,10 +7980,8 @@ stmt_prep_int(int argc, VALUE *argv, VALUE self, int mode)
7004
7980
  ssql = (SQLCHAR *) csql;
7005
7981
  #endif
7006
7982
  if ((mode & MAKERES_EXECD)) {
7007
- SQLRETURN ret;
7008
-
7009
- if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
7010
- (ret = SQLExecDirect(hstmt, ssql, SQL_NTS)),
7983
+ ret = SQLEXECDIRECT(hstmt, ssql, SQL_NTS);
7984
+ if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt, ret,
7011
7985
  &msg, "SQLExecDirect('%s')", csql)) {
7012
7986
  goto sqlerr;
7013
7987
  }
@@ -7020,22 +7994,24 @@ stmt_prep_int(int argc, VALUE *argv, VALUE self, int mode)
7020
7994
  }
7021
7995
  hstmt = SQL_NULL_HSTMT;
7022
7996
  }
7023
- } else if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
7024
- SQLPrepare(hstmt, ssql, SQL_NTS),
7997
+ } else {
7998
+ ret = SQLPREPARE(hstmt, ssql, SQL_NTS);
7999
+ if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt, ret,
7025
8000
  &msg, "SQLPrepare('%s')", csql)) {
7026
8001
  sqlerr:
7027
8002
  #ifdef UNICODE
7028
- uc_free(ssql);
8003
+ uc_free(ssql);
7029
8004
  #endif
7030
- callsql(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
7031
- SQLFreeStmt(hstmt, SQL_DROP), "SQLFreeStmt(SQL_DROP)");
7032
- if (q != NULL) {
7033
- q->hstmt = SQL_NULL_HSTMT;
7034
- unlink_stmt(q);
8005
+ callsql(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
8006
+ SQLFreeStmt(hstmt, SQL_DROP), "SQLFreeStmt(SQL_DROP)");
8007
+ if (q != NULL) {
8008
+ q->hstmt = SQL_NULL_HSTMT;
8009
+ unlink_stmt(q);
8010
+ }
8011
+ rb_raise(Cerror, "%s", msg);
8012
+ } else {
8013
+ mode |= MAKERES_PREPARE;
7035
8014
  }
7036
- rb_raise(Cerror, "%s", msg);
7037
- } else {
7038
- mode |= MAKERES_PREPARE;
7039
8015
  }
7040
8016
  #ifdef UNICODE
7041
8017
  uc_free(ssql);
@@ -7198,9 +8174,9 @@ bind_one_param(int pnum, VALUE arg, STMT *q, char **msgp, int *outpp)
7198
8174
  ctype = SQL_C_TIME;
7199
8175
  time = (TIME_STRUCT *) valp;
7200
8176
  memset(time, 0, sizeof (TIME_STRUCT));
7201
- time->hour = rb_funcall(arg, IDhour, 0, NULL);
7202
- time->minute = rb_funcall(arg, IDmin, 0, NULL);
7203
- time->second = rb_funcall(arg, IDsec, 0, NULL);
8177
+ time->hour = FUNCALL_NOARGS(arg, IDhour);
8178
+ time->minute = FUNCALL_NOARGS(arg, IDmin);
8179
+ time->second = FUNCALL_NOARGS(arg, IDsec);
7204
8180
  rlen = 1;
7205
8181
  vlen = sizeof (TIME_STRUCT);
7206
8182
  } else if (q->paraminfo[pnum].type == SQL_DATE) {
@@ -7209,9 +8185,9 @@ bind_one_param(int pnum, VALUE arg, STMT *q, char **msgp, int *outpp)
7209
8185
  ctype = SQL_C_DATE;
7210
8186
  date = (DATE_STRUCT *) valp;
7211
8187
  memset(date, 0, sizeof (DATE_STRUCT));
7212
- date->year = rb_funcall(arg, IDyear, 0, NULL);
7213
- date->month = rb_funcall(arg, IDmonth, 0, NULL);
7214
- date->day = rb_funcall(arg, IDday, 0, NULL);
8188
+ date->year = FUNCALL_NOARGS(arg, IDyear);
8189
+ date->month = FUNCALL_NOARGS(arg, IDmonth);
8190
+ date->day = FUNCALL_NOARGS(arg, IDday);
7215
8191
  rlen = 1;
7216
8192
  vlen = sizeof (TIMESTAMP_STRUCT);
7217
8193
  } else {
@@ -7220,16 +8196,16 @@ bind_one_param(int pnum, VALUE arg, STMT *q, char **msgp, int *outpp)
7220
8196
  ctype = SQL_C_TIMESTAMP;
7221
8197
  ts = (TIMESTAMP_STRUCT *) valp;
7222
8198
  memset(ts, 0, sizeof (TIMESTAMP_STRUCT));
7223
- ts->year = rb_funcall(arg, IDyear, 0, NULL);
7224
- ts->month = rb_funcall(arg, IDmonth, 0, NULL);
7225
- ts->day = rb_funcall(arg, IDday, 0, NULL);
7226
- ts->hour = rb_funcall(arg, IDhour, 0, NULL);
7227
- ts->minute = rb_funcall(arg, IDmin, 0, NULL);
7228
- ts->second = rb_funcall(arg, IDsec, 0, NULL);
8199
+ ts->year = FUNCALL_NOARGS(arg, IDyear);
8200
+ ts->month = FUNCALL_NOARGS(arg, IDmonth);
8201
+ ts->day = FUNCALL_NOARGS(arg, IDday);
8202
+ ts->hour = FUNCALL_NOARGS(arg, IDhour);
8203
+ ts->minute = FUNCALL_NOARGS(arg, IDmin);
8204
+ ts->second = FUNCALL_NOARGS(arg, IDsec);
7229
8205
  #ifdef TIME_USE_USEC
7230
- ts->fraction = rb_funcall(arg, IDusec, 0, NULL) * 1000;
8206
+ ts->fraction = FUNCALL_NOARGS(arg, IDusec) * 1000;
7231
8207
  #else
7232
- ts->fraction = rb_funcall(arg, IDnsec, 0, NULL);
8208
+ ts->fraction = FUNCALL_NOARGS(arg, IDnsec);
7233
8209
  #endif
7234
8210
  rlen = 1;
7235
8211
  vlen = sizeof (TIMESTAMP_STRUCT);
@@ -7242,9 +8218,9 @@ bind_one_param(int pnum, VALUE arg, STMT *q, char **msgp, int *outpp)
7242
8218
  ctype = SQL_C_DATE;
7243
8219
  date = (DATE_STRUCT *) valp;
7244
8220
  memset(date, 0, sizeof (DATE_STRUCT));
7245
- date->year = rb_funcall(arg, IDyear, 0, NULL);
7246
- date->month = rb_funcall(arg, IDmonth, 0, NULL);
7247
- date->day = rb_funcall(arg, IDmday, 0, NULL);
8221
+ date->year = FUNCALL_NOARGS(arg, IDyear);
8222
+ date->month = FUNCALL_NOARGS(arg, IDmonth);
8223
+ date->day = FUNCALL_NOARGS(arg, IDmday);
7248
8224
  rlen = 1;
7249
8225
  vlen = sizeof (DATE_STRUCT);
7250
8226
  break;
@@ -7452,8 +8428,8 @@ stmt_exec_int(int argc, VALUE *argv, VALUE self, int mode)
7452
8428
  goto error;
7453
8429
  }
7454
8430
  }
7455
- if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
7456
- (ret = SQLExecute(q->hstmt)),
8431
+ ret = SQLEXECUTE(q->hstmt);
8432
+ if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret,
7457
8433
  &msg, "SQLExecute")) {
7458
8434
  error:
7459
8435
  #ifdef UNICODE
@@ -7512,7 +8488,7 @@ static VALUE
7512
8488
  stmt_do(int argc, VALUE *argv, VALUE self)
7513
8489
  {
7514
8490
  VALUE stmt;
7515
-
8491
+
7516
8492
  if (argc < 1) {
7517
8493
  rb_raise(rb_eArgError, "wrong # of arguments");
7518
8494
  }
@@ -7557,7 +8533,7 @@ stmt_ignorecase(int argc, VALUE *argv, VALUE self)
7557
8533
  /*
7558
8534
  *----------------------------------------------------------------------
7559
8535
  *
7560
- * Create statement without implicit SQL prepare or execute.
8536
+ * Create statement without implicit SQL prepare or execute.
7561
8537
  *
7562
8538
  *----------------------------------------------------------------------
7563
8539
  */
@@ -7580,7 +8556,7 @@ stmt_new(VALUE self)
7580
8556
  /*
7581
8557
  *----------------------------------------------------------------------
7582
8558
  *
7583
- * Procedures with statements.
8559
+ * Procedures with statements.
7584
8560
  *
7585
8561
  *----------------------------------------------------------------------
7586
8562
  */
@@ -7671,7 +8647,7 @@ stmt_procwrap(int argc, VALUE *argv, VALUE self)
7671
8647
  /*
7672
8648
  *----------------------------------------------------------------------
7673
8649
  *
7674
- * Module functions.
8650
+ * Module functions.
7675
8651
  *
7676
8652
  *----------------------------------------------------------------------
7677
8653
  */
@@ -7758,7 +8734,7 @@ again:
7758
8734
  rb_raise(rb_eTypeError, "expecting ODBC::Date");
7759
8735
  }
7760
8736
  } else {
7761
- VALUE now = rb_funcall(rb_cTime, IDnow, 0, NULL);
8737
+ VALUE now = FUNCALL_NOARGS(rb_cTime, IDnow);
7762
8738
 
7763
8739
  y = rb_funcall(rb_cTime, IDyear, 1, now);
7764
8740
  m = rb_funcall(rb_cTime, IDmonth, 1, now);
@@ -7854,7 +8830,7 @@ mod_trace(int argc, VALUE *argv, VALUE self)
7854
8830
  /*
7855
8831
  *----------------------------------------------------------------------
7856
8832
  *
7857
- * Table of constants and intern'ed string mappings.
8833
+ * Table of constants and intern'ed string mappings.
7858
8834
  *
7859
8835
  *----------------------------------------------------------------------
7860
8836
  */
@@ -7990,10 +8966,26 @@ static struct {
7990
8966
  O_CONST2(SQL_OV_ODBC3, 3),
7991
8967
  #endif
7992
8968
  #ifdef SQL_ATTR_CONNECTION_POOLING
8969
+ #ifdef SQL_CP_OFF
7993
8970
  O_CONST(SQL_CP_OFF),
8971
+ #else
8972
+ O_CONST2(SQL_CP_OFF, 0),
8973
+ #endif
8974
+ #ifdef SQL_CP_ONE_PER_DRIVER
7994
8975
  O_CONST(SQL_CP_ONE_PER_DRIVER),
8976
+ #else
8977
+ O_CONST2(SQL_CP_ONE_PER_DRIVER, 1),
8978
+ #endif
8979
+ #ifdef SQL_CP_ONE_PER_HENV
7995
8980
  O_CONST(SQL_CP_ONE_PER_HENV),
8981
+ #else
8982
+ O_CONST2(SQL_CP_ONE_PER_HENV, 2),
8983
+ #endif
8984
+ #ifdef SQL_CP_DEFAULT
7996
8985
  O_CONST(SQL_CP_DEFAULT),
8986
+ #else
8987
+ O_CONST2(SQL_CP_DEFAULT, 0),
8988
+ #endif
7997
8989
  #else
7998
8990
  O_CONST2(SQL_CP_OFF, 0),
7999
8991
  O_CONST2(SQL_CP_ONE_PER_DRIVER, 0),
@@ -8107,7 +9099,7 @@ static struct {
8107
9099
  /*
8108
9100
  *----------------------------------------------------------------------
8109
9101
  *
8110
- * Module initializer.
9102
+ * Module initializer.
8111
9103
  *
8112
9104
  *----------------------------------------------------------------------
8113
9105
  */
@@ -8128,7 +9120,7 @@ Init_odbc()
8128
9120
  rb_cDate = rb_eval_string("Date");
8129
9121
 
8130
9122
  if (rb_const_defined(rb_cObject, modid)) {
8131
- v = rb_const_get(rb_cObject, modid);
9123
+ v = rb_const_get(rb_cObject, modid);
8132
9124
  if (TYPE(v) != T_MODULE) {
8133
9125
  rb_raise(rb_eTypeError, "%s already defined", modname);
8134
9126
  }
@@ -8294,6 +9286,8 @@ Init_odbc()
8294
9286
  rb_define_method(Cdbc, "maxrows=", dbc_maxrows, -1);
8295
9287
  rb_define_method(Cdbc, "timeout", dbc_timeout, -1);
8296
9288
  rb_define_method(Cdbc, "timeout=", dbc_timeout, -1);
9289
+ rb_define_method(Cdbc, "login_timeout", dbc_login_timeout, -1);
9290
+ rb_define_method(Cdbc, "login_timeout=", dbc_login_timeout, -1);
8297
9291
  rb_define_method(Cdbc, "maxlength", dbc_maxlength, -1);
8298
9292
  rb_define_method(Cdbc, "maxlength=", dbc_maxlength, -1);
8299
9293
  rb_define_method(Cdbc, "rowsetsize", dbc_rowsetsize, -1);
@@ -8330,7 +9324,7 @@ Init_odbc()
8330
9324
  rb_define_method(Cstmt, "fetch_scroll!", stmt_fetch_scroll_bang, -1);
8331
9325
  rb_define_method(Cstmt, "fetch_hash", stmt_fetch_hash, -1);
8332
9326
  rb_define_method(Cstmt, "fetch_hash!", stmt_fetch_hash_bang, -1);
8333
- rb_define_method(Cstmt, "fetch_first_hash", stmt_fetch_first_hash, 0);
9327
+ rb_define_method(Cstmt, "fetch_first_hash", stmt_fetch_first_hash, -1);
8334
9328
  rb_define_method(Cstmt, "fetch_many", stmt_fetch_many, 1);
8335
9329
  rb_define_method(Cstmt, "fetch_all", stmt_fetch_all, 0);
8336
9330
  rb_define_method(Cstmt, "each", stmt_each, 0);
@@ -8470,3 +9464,12 @@ Init_odbc()
8470
9464
  }
8471
9465
  #endif
8472
9466
  }
9467
+
9468
+ /*
9469
+ * Local Variables:
9470
+ * mode: c
9471
+ * c-basic-offset: 4
9472
+ * fill-column: 78
9473
+ * tab-width: 8
9474
+ * End:
9475
+ */