ruby-odbc 0.99995 → 0.999991
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +5 -5
- data/COPYING +1 -1
- data/ChangeLog +27 -0
- data/README +8 -6
- data/doc/odbc.html +18 -11
- data/ext/extconf.rb +38 -3
- data/ext/odbc.c +1189 -186
- data/ext/utf8/extconf.rb +5 -3
- data/ruby-odbc.gemspec +1 -1
- data/test/30select.rb +1 -1
- data/test/45delete.rb +8 -0
- data/test/test.rb +3 -3
- data/test/utf8/test.rb +3 -3
- metadata +20 -20
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
|
-
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
2
|
+
SHA256:
|
3
|
+
metadata.gz: 860fc0eb5595959ec764079118f528b5b0afa5d49e919ab0f8c46e971bd7dbc0
|
4
|
+
data.tar.gz: 843b2f2427d1378489cbc6eea0cb3e3ce5daff17f42ac3a040a0a979f04dddae
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
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
|
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.
|
1
|
+
# $Id: README,v 1.47 2020/12/25 21:47:43 chw Exp chw $
|
2
2
|
|
3
|
-
ruby-odbc-0.
|
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
|
-
|
24
|
-
|
25
|
-
|
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,
|
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"
|
77
|
-
|
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
|
-
|
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-
|
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.
|
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
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
|
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
|
-
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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 =
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
-
|
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 =
|
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
|
-
|
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
|
-
*
|
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
|
-
*
|
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
|
-
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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 =
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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
|
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 ==
|
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 ==
|
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
|
-
*
|
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
|
-
*
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
*
|
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
|
-
|
4096
|
-
|
4097
|
-
|
4098
|
-
|
4099
|
-
|
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
|
-
|
5124
|
+
FUNCALL_NOARGS(ret, IDto_s)));
|
4163
5125
|
return Qnil;
|
4164
5126
|
}
|
4165
5127
|
|
4166
5128
|
/*
|
4167
5129
|
*----------------------------------------------------------------------
|
4168
5130
|
*
|
4169
|
-
*
|
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
|
-
*
|
5212
|
+
* Connection/statement option handling.
|
4251
5213
|
*
|
4252
|
-
*
|
4253
|
-
*
|
4254
|
-
*
|
4255
|
-
*
|
4256
|
-
*
|
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
|
-
*
|
4259
|
-
*
|
4260
|
-
*
|
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
|
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
|
-
|
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
|
-
*
|
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
|
-
*
|
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 =
|
4715
|
-
m =
|
4716
|
-
y =
|
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 =
|
4722
|
-
m =
|
4723
|
-
y =
|
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
|
-
*
|
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 =
|
4950
|
-
m =
|
4951
|
-
h =
|
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
|
-
*
|
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 =
|
5190
|
-
ss =
|
5191
|
-
mm =
|
5192
|
-
hh =
|
5193
|
-
d =
|
5194
|
-
m =
|
5195
|
-
y =
|
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 =
|
5206
|
-
m =
|
5207
|
-
y =
|
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
|
-
*
|
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 =
|
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
|
-
|
5687
|
-
|
5688
|
-
|
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 =
|
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
|
-
|
6345
|
-
|
6346
|
-
|
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
|
-
|
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 =
|
7451
|
+
ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
|
6477
7452
|
#else
|
6478
7453
|
msg = "SQLFetchScroll(SQL_FETCH_NEXT)";
|
6479
|
-
ret =
|
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 =
|
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
|
-
|
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 =
|
7523
|
+
ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
|
6549
7524
|
#else
|
6550
7525
|
msg = "SQLFetchScroll(SQL_FETCH_FIRST)";
|
6551
|
-
ret =
|
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
|
-
|
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 =
|
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 =
|
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
|
-
|
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 =
|
7694
|
+
ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
|
6720
7695
|
#else
|
6721
7696
|
msg = "SQLFetchScroll(SQL_FETCH_NEXT)";
|
6722
|
-
ret =
|
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 =
|
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
|
-
|
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 =
|
7767
|
+
ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
|
6793
7768
|
#else
|
6794
7769
|
msg = "SQLFetchScroll(SQL_FETCH_FIRST)";
|
6795
|
-
ret =
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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
|
7024
|
-
|
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
|
-
|
8003
|
+
uc_free(ssql);
|
7029
8004
|
#endif
|
7030
|
-
|
7031
|
-
|
7032
|
-
|
7033
|
-
|
7034
|
-
|
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 =
|
7202
|
-
time->minute =
|
7203
|
-
time->second =
|
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 =
|
7213
|
-
date->month =
|
7214
|
-
date->day =
|
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 =
|
7224
|
-
ts->month =
|
7225
|
-
ts->day =
|
7226
|
-
ts->hour =
|
7227
|
-
ts->minute =
|
7228
|
-
ts->second =
|
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 =
|
8206
|
+
ts->fraction = FUNCALL_NOARGS(arg, IDusec) * 1000;
|
7231
8207
|
#else
|
7232
|
-
ts->fraction =
|
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 =
|
7246
|
-
date->month =
|
7247
|
-
date->day =
|
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
|
-
|
7456
|
-
|
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
|
-
*
|
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
|
-
*
|
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
|
-
*
|
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 =
|
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
|
-
*
|
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
|
-
*
|
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,
|
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
|
+
*/
|