mysql 2.9.0-x86-mswin32-60

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
File without changes
data/COPYING ADDED
@@ -0,0 +1,56 @@
1
+ Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
2
+ You can redistribute it and/or modify it under either the terms of the GPL
3
+ (see the file GPL), or the conditions below:
4
+
5
+ 1. You may make and give away verbatim copies of the source form of the
6
+ software without restriction, provided that you duplicate all of the
7
+ original copyright notices and associated disclaimers.
8
+
9
+ 2. You may modify your copy of the software in any way, provided that
10
+ you do at least ONE of the following:
11
+
12
+ a) place your modifications in the Public Domain or otherwise
13
+ make them Freely Available, such as by posting said
14
+ modifications to Usenet or an equivalent medium, or by allowing
15
+ the author to include your modifications in the software.
16
+
17
+ b) use the modified software only within your corporation or
18
+ organization.
19
+
20
+ c) give non-standard binaries non-standard names, with
21
+ instructions on where to get the original software distribution.
22
+
23
+ d) make other distribution arrangements with the author.
24
+
25
+ 3. You may distribute the software in object code or binary form,
26
+ provided that you do at least ONE of the following:
27
+
28
+ a) distribute the binaries and library files of the software,
29
+ together with instructions (in the manual page or equivalent)
30
+ on where to get the original distribution.
31
+
32
+ b) accompany the distribution with the machine-readable source of
33
+ the software.
34
+
35
+ c) give non-standard binaries non-standard names, with
36
+ instructions on where to get the original software distribution.
37
+
38
+ d) make other distribution arrangements with the author.
39
+
40
+ 4. You may modify and include the part of the software into any other
41
+ software (possibly commercial). But some files in the distribution
42
+ are not written by the author, so that they are not under these terms.
43
+
44
+ For the list of those files and their copying conditions, see the
45
+ file LEGAL.
46
+
47
+ 5. The scripts and library files supplied as input to or produced as
48
+ output from the software do not automatically fall under the
49
+ copyright of the software, but belong to whomever generated them,
50
+ and may be sold commercially, and may be aggregated with this
51
+ software.
52
+
53
+ 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
54
+ IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
55
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56
+ PURPOSE.
@@ -0,0 +1,51 @@
1
+ $BK\%W%m%0%i%`$O%U%j!<%=%U%H%&%'%"$G$9!%(BGPL(the GNU General
2
+ Public License)$B$^$?$O0J2<$K<($9>r7o$GK\%W%m%0%i%`$r:FG[I[$G(B
3
+ $B$-$^$9!%(BGPL$B$K$D$$$F$O(BGPL$B%U%!%$%k$r;2>H$7$F2<$5$$!%(B
4
+
5
+ 1. $BJ#@=$O@)8B$J$/<+M3$G$9!%(B
6
+
7
+ 2. $B0J2<$N>r7o$N$$$:$l$+$rK~$?$9;~$KK\%W%m%0%i%`$N%=!<%9$r(B
8
+ $B<+M3$KJQ99$G$-$^$9!%(B
9
+
10
+ (a) $B%M%C%H%K%e!<%:$K%]%9%H$7$?$j!$:n<T$KJQ99$rAwIU$9$k(B
11
+ $B$J$I$NJ}K!$G!$JQ99$r8x3+$9$k!%(B
12
+
13
+ (b) $BJQ99$7$?K\%W%m%0%i%`$r<+J,$N=jB0$9$kAH?%FbIt$@$1$G(B
14
+ $B;H$&!%(B
15
+
16
+ (c) $BJQ99E@$rL@<($7$?$&$(!$%=%U%H%&%'%"$NL>A0$rJQ99$9$k!%(B
17
+ $B$=$N%=%U%H%&%'%"$rG[I[$9$k;~$K$OJQ99A0$NK\%W%m%0%i(B
18
+ $B%`$bF1;~$KG[I[$9$k!%$^$?$OJQ99A0$NK\%W%m%0%i%`$N%=!<(B
19
+ $B%9$NF~<jK!$rL@<($9$k!%(B
20
+
21
+ (d) $B$=$NB>$NJQ99>r7o$r:n<T$H9g0U$9$k!%(B
22
+
23
+ 3. $B0J2<$N>r7o$N$$$:$l$+$rK~$?$9;~$KK\%W%m%0%i%`$r%3%s%Q%$(B
24
+ $B%k$7$?%*%V%8%'%/%H%3!<%I$d<B9T7A<0$G$bG[I[$G$-$^$9!%(B
25
+
26
+ (a) $B%P%$%J%j$r<u$1<h$C$??M$,%=!<%9$rF~<j$G$-$k$h$&$K!$(B
27
+ $B%=!<%9$NF~<jK!$rL@<($9$k!%(B
28
+
29
+ (b) $B5!3#2DFI$J%=!<%9%3!<%I$rE:IU$9$k!%(B
30
+
31
+ (c) $BJQ99$r9T$C$?%P%$%J%j$OL>A0$rJQ99$7$?$&$(!$%*%j%8%J(B
32
+ $B%k$N%=!<%9%3!<%I$NF~<jK!$rL@<($9$k!%(B
33
+
34
+ (d) $B$=$NB>$NG[I[>r7o$r:n<T$H9g0U$9$k!%(B
35
+
36
+ 4. $BB>$N%W%m%0%i%`$X$N0zMQ$O$$$+$J$kL\E*$G$"$l<+M3$G$9!%$?(B
37
+ $B$@$7!$K\%W%m%0%i%`$K4^$^$l$kB>$N:n<T$K$h$k%3!<%I$O!$$=(B
38
+ $B$l$>$l$N:n<T$N0U8~$K$h$k@)8B$,2C$($i$l$k>l9g$,$"$j$^$9!%(B
39
+
40
+ $B$=$l$i%U%!%$%k$N0lMw$H$=$l$>$l$NG[I[>r7o$J$I$KIU$$$F$O(B
41
+ LEGAL$B%U%!%$%k$r;2>H$7$F$/$@$5$$!%(B
42
+
43
+ 5. $BK\%W%m%0%i%`$X$NF~NO$H$J$k%9%/%j%W%H$*$h$S!$K\%W%m%0%i(B
44
+ $B%`$+$i$N=PNO$N8"Mx$OK\%W%m%0%i%`$N:n<T$G$O$J$/!$$=$l$>(B
45
+ $B$l$NF~=PNO$r@8@.$7$??M$KB0$7$^$9!%$^$?!$K\%W%m%0%i%`$K(B
46
+ $BAH$_9~$^$l$k$?$a$N3HD%%i%$%V%i%j$K$D$$$F$bF1MM$G$9!%(B
47
+
48
+ 6. $BK\%W%m%0%i%`$OL5J]>Z$G$9!%:n<T$OK\%W%m%0%i%`$r%5%]!<%H(B
49
+ $B$9$k0U;V$O$"$j$^$9$,!$%W%m%0%i%`<+?H$N%P%0$"$k$$$OK\%W(B
50
+ $B%m%0%i%`$N<B9T$J$I$+$iH/@8$9$k$$$+$J$kB;32$KBP$7$F$b@U(B
51
+ $BG$$r;}$A$^$;$s!%(B
@@ -0,0 +1,32 @@
1
+ === 2.9.0 / 2012-11-17
2
+
3
+ DEPRECATION: Ruby 1.8.6 is no longer supported. Do not update your production
4
+ application blindly without testing first any dependency change!
5
+
6
+ * Incompatibility:
7
+ * Requires Ruby 1.8.7 or newer.
8
+
9
+ * Enhancements:
10
+ * Detect MySQL version at load time and fail on mismatch [ghazel]
11
+ * Use MySQL Connector/C for Windows binary bindings instead
12
+
13
+ * Bug fixes:
14
+ * Use RbConfig since Config is deprecated in Ruby 2.0 [tenderlove]
15
+
16
+ === 2.8.2 / 2012-11-06 / *yanked*
17
+
18
+ * Yanked:
19
+ * Changes in requirements render this gem incompatible for some users.
20
+
21
+ === 2.8.1 / 2009-08-21
22
+
23
+ * New features:
24
+ * Early support for Ruby 1.9
25
+
26
+ * Enhancements:
27
+ * Improved gem release process using Hoe as development dependency
28
+ * Implemented support for cross compilation
29
+ * Binary version built against MySQL 5.0.83
30
+
31
+ * Bug fixes:
32
+ * Improved detection of mysql and it's configuration (mysql_config)
@@ -0,0 +1,17 @@
1
+ COPYING
2
+ COPYING.ja
3
+ History.txt
4
+ Manifest.txt
5
+ README.txt
6
+ Rakefile
7
+ ext/mysql_api/extconf.rb
8
+ ext/mysql_api/mysql.c
9
+ extra/README.html
10
+ extra/README_ja.html
11
+ extra/tommy.css
12
+ lib/mysql.rb
13
+ lib/mysql/version.rb
14
+ tasks/gem.rake
15
+ tasks/native.rake
16
+ tasks/vendor_mysql.rake
17
+ test/test_mysql.rb
@@ -0,0 +1,25 @@
1
+ = MySQL/Ruby Interface
2
+
3
+ * http://github.com/luislavena/mysql-gem
4
+
5
+ == DESCRIPTION
6
+
7
+ This is the MySQL API module for Ruby. It provides the same functions for Ruby
8
+ programs that the MySQL C API provides for C programs.
9
+
10
+ This package is offered as gem for easy installation using RubyGems. It wraps
11
+ unmodified tmtm's mysql-ruby extension into a proper gem.
12
+
13
+ Please note that tmtm (Tomita Mashahiro) has deprecated development of this
14
+ extension and only update it for bug fixes.
15
+
16
+ === Warning about incompatible MySQL versions under Windows
17
+
18
+ Mixing MySQL versions will generate segmentation faults.
19
+
20
+ Running the binary version of this gem against a different version of MySQL
21
+ shared library <tt>libMySQL.dll</tt> will generate segmentation faults and
22
+ terminate your application.
23
+
24
+ Please use the exact same MAJOR.MINOR version of MySQL, see History.txt for
25
+ specific version of MySQL used to build the binaries.
@@ -0,0 +1,22 @@
1
+ #--
2
+ # Copyright (c) 2008 Luis Lavena
3
+ #
4
+ # This source code is released under the MIT License.
5
+ # See LICENSE file for details
6
+ #++
7
+
8
+ #
9
+ # NOTE: Keep this file clean.
10
+ # Add your customizations inside tasks directory.
11
+ # Thank You.
12
+ #
13
+
14
+ begin
15
+ require 'rake'
16
+ rescue LoadError
17
+ require 'rubygems'
18
+ require 'rake'
19
+ end
20
+
21
+ # load rakefile extensions (tasks)
22
+ Dir['tasks/*.rake'].sort.each { |f| load f }
@@ -0,0 +1,93 @@
1
+ # Darwin (OSX) special cases for universal binaries
2
+ # This is to avoid the lack of UB binaries for MySQL
3
+ ENV["RC_ARCHS"] = "" if RUBY_PLATFORM =~ /darwin/
4
+
5
+ require 'mkmf'
6
+
7
+ # Improved detection of mysql_config
8
+ # Code from DataObjects do_mysql adapter
9
+
10
+ # All instances of mysql_config on PATH ...
11
+ def mysql_config_paths
12
+ ENV['PATH'].split(File::PATH_SEPARATOR).collect do |path|
13
+ [ "#{path}/mysql_config", "#{path}/mysql_config5" ].
14
+ detect { |bin| File.exist?(bin) }
15
+ end
16
+ end
17
+
18
+ # The first mysql_config binary on PATH ...
19
+ def default_mysql_config_path
20
+ mysql_config_paths.compact.first
21
+ end
22
+
23
+ # Allow overriding path to mysql_config on command line using:
24
+ # ruby extconf.rb --with-mysql-config=/path/to/mysql_config
25
+ if RUBY_PLATFORM =~ /mswin|mingw/
26
+ inc, lib = dir_config('mysql')
27
+ exit 1 unless have_library("libmysql")
28
+ elsif mc = with_config('mysql-config', default_mysql_config_path) then
29
+ mc = 'mysql_config' if mc == true
30
+ cflags = `#{mc} --cflags`.chomp
31
+ exit 1 if $? != 0
32
+ libs = `#{mc} --libs`.chomp
33
+ exit 1 if $? != 0
34
+ $CPPFLAGS += ' ' + cflags
35
+ $libs = libs + " " + $libs
36
+ else
37
+ inc, lib = dir_config('mysql', '/usr/local')
38
+ libs = ['m', 'z', 'socket', 'nsl', 'mygcc']
39
+ while not find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql") do
40
+ exit 1 if libs.empty?
41
+ have_library(libs.shift)
42
+ end
43
+ end
44
+
45
+ have_func('mysql_ssl_set')
46
+ have_func('rb_str_set_len')
47
+ have_func('rb_thread_start_timer')
48
+
49
+ if have_header('mysql.h') then
50
+ src = "#include <errmsg.h>\n#include <mysqld_error.h>\n"
51
+ elsif have_header('mysql/mysql.h') then
52
+ src = "#include <mysql/errmsg.h>\n#include <mysql/mysqld_error.h>\n"
53
+ else
54
+ exit 1
55
+ end
56
+
57
+ # make mysql constant
58
+ File.open("conftest.c", "w") do |f|
59
+ f.puts src
60
+ end
61
+ if defined? cpp_command then
62
+ cpp = RbConfig.expand(cpp_command(''))
63
+ else
64
+ cpp = RbConfig.expand sprintf(CPP, $CPPFLAGS, $CFLAGS, '')
65
+ end
66
+ if RUBY_PLATFORM =~ /mswin/ && !/-E/.match(cpp)
67
+ cpp << " -E"
68
+ end
69
+ unless system "#{cpp} > confout" then
70
+ exit 1
71
+ end
72
+ File.unlink "conftest.c"
73
+
74
+ error_syms = []
75
+ IO.foreach('confout') do |l|
76
+ next unless l =~ /errmsg\.h|mysqld_error\.h/
77
+ fn = l.split(/\"/)[1]
78
+ IO.foreach(fn) do |m|
79
+ if m =~ /^#define\s+([CE]R_[0-9A-Z_]+)/ then
80
+ error_syms << $1
81
+ end
82
+ end
83
+ end
84
+ File.unlink 'confout'
85
+ error_syms.uniq!
86
+
87
+ File.open('error_const.h', 'w') do |f|
88
+ error_syms.each do |s|
89
+ f.puts " rb_define_mysql_const(#{s});"
90
+ end
91
+ end
92
+
93
+ create_makefile("mysql/mysql_api")
@@ -0,0 +1,2288 @@
1
+ /* ruby mysql module
2
+ * $Id: mysql.c 250 2010-02-11 10:42:54Z tommy $
3
+ */
4
+
5
+ #include <ruby.h>
6
+ #ifndef RSTRING_PTR
7
+ #define RSTRING_PTR(str) RSTRING(str)->ptr
8
+ #endif
9
+ #ifndef RSTRING_LEN
10
+ #define RSTRING_LEN(str) RSTRING(str)->len
11
+ #endif
12
+ #ifndef RARRAY_PTR
13
+ #define RARRAY_PTR(ary) RARRAY(ary)->ptr
14
+ #endif
15
+ #ifndef HAVE_RB_STR_SET_LEN
16
+ #define rb_str_set_len(str, length) (RSTRING_LEN(str) = (length))
17
+ #endif
18
+
19
+ #ifdef HAVE_MYSQL_H
20
+ #include <mysql.h>
21
+ #include <errmsg.h>
22
+ #include <mysqld_error.h>
23
+ #else
24
+ #include <mysql/mysql.h>
25
+ #include <mysql/errmsg.h>
26
+ #include <mysql/mysqld_error.h>
27
+ #endif
28
+
29
+ #define MYSQL_RUBY_VERSION 20802
30
+
31
+ #define GC_STORE_RESULT_LIMIT 20
32
+
33
+ #if MYSQL_VERSION_ID < 32224
34
+ #define mysql_field_count mysql_num_fields
35
+ #endif
36
+
37
+ #define NILorSTRING(obj) (NIL_P(obj)? NULL: StringValuePtr(obj))
38
+ #define NILorINT(obj) (NIL_P(obj)? 0: NUM2INT(obj))
39
+
40
+ #define GetMysqlStruct(obj) (Check_Type(obj, T_DATA), (struct mysql*)DATA_PTR(obj))
41
+ #define GetHandler(obj) (Check_Type(obj, T_DATA), &(((struct mysql*)DATA_PTR(obj))->handler))
42
+ #define GetMysqlRes(obj) (Check_Type(obj, T_DATA), ((struct mysql_res*)DATA_PTR(obj))->res)
43
+ #define GetMysqlStmt(obj) (Check_Type(obj, T_DATA), ((struct mysql_stmt*)DATA_PTR(obj))->stmt)
44
+
45
+ VALUE cMysql;
46
+ VALUE cMysqlRes;
47
+ VALUE cMysqlField;
48
+ VALUE cMysqlStmt;
49
+ VALUE cMysqlRowOffset;
50
+ VALUE cMysqlTime;
51
+ VALUE eMysql;
52
+
53
+ static int store_result_count = 0;
54
+
55
+ struct mysql {
56
+ MYSQL handler;
57
+ char connection;
58
+ char query_with_result;
59
+ };
60
+
61
+ struct mysql_res {
62
+ MYSQL_RES* res;
63
+ char freed;
64
+ };
65
+
66
+ #if MYSQL_VERSION_ID >= 40101
67
+ struct mysql_stmt {
68
+ MYSQL_STMT *stmt;
69
+ char closed;
70
+ struct {
71
+ int n;
72
+ MYSQL_BIND *bind;
73
+ unsigned long *length;
74
+ MYSQL_TIME *buffer;
75
+ } param;
76
+ struct {
77
+ int n;
78
+ MYSQL_BIND *bind;
79
+ my_bool *is_null;
80
+ unsigned long *length;
81
+ } result;
82
+ MYSQL_RES *res;
83
+ };
84
+ #endif
85
+
86
+ /* free Mysql class object */
87
+ static void free_mysql(struct mysql* my)
88
+ {
89
+ if (my->connection == Qtrue)
90
+ mysql_close(&my->handler);
91
+ xfree(my);
92
+ }
93
+
94
+ static void free_mysqlres(struct mysql_res* resp)
95
+ {
96
+ if (resp->freed == Qfalse) {
97
+ mysql_free_result(resp->res);
98
+ store_result_count--;
99
+ }
100
+ xfree(resp);
101
+ }
102
+
103
+ #if MYSQL_VERSION_ID >= 40101
104
+ static void free_mysqlstmt_memory(struct mysql_stmt *s)
105
+ {
106
+ if (s->param.bind) {
107
+ xfree(s->param.bind);
108
+ s->param.bind = NULL;
109
+ }
110
+ if (s->param.length) {
111
+ xfree(s->param.length);
112
+ s->param.length = NULL;
113
+ }
114
+ if (s->param.buffer) {
115
+ xfree(s->param.buffer);
116
+ s->param.buffer = NULL;
117
+ }
118
+ s->param.n = 0;
119
+ if (s->res) {
120
+ mysql_free_result(s->res);
121
+ s->res = NULL;
122
+ }
123
+ if (s->result.bind) {
124
+ int i;
125
+ for (i = 0; i < s->result.n; i++) {
126
+ if (s->result.bind[i].buffer)
127
+ xfree(s->result.bind[i].buffer);
128
+ s->result.bind[i].buffer = NULL;
129
+ }
130
+ xfree(s->result.bind);
131
+ s->result.bind = NULL;
132
+ }
133
+ if (s->result.is_null) {
134
+ xfree(s->result.is_null);
135
+ s->result.is_null = NULL;
136
+ }
137
+ if (s->result.length) {
138
+ xfree(s->result.length);
139
+ s->result.length = NULL;
140
+ }
141
+ s->result.n = 0;
142
+ }
143
+
144
+ static void free_execute_memory(struct mysql_stmt *s)
145
+ {
146
+ if (s->res && s->result.bind) {
147
+ int i;
148
+ for (i = 0; i < s->result.n; i++) {
149
+ if (s->result.bind[i].buffer)
150
+ xfree(s->result.bind[i].buffer);
151
+ s->result.bind[i].buffer = NULL;
152
+ }
153
+ }
154
+ mysql_stmt_free_result(s->stmt);
155
+ }
156
+
157
+ static void free_mysqlstmt(struct mysql_stmt* s)
158
+ {
159
+ free_mysqlstmt_memory(s);
160
+ if (s->closed == Qfalse)
161
+ mysql_stmt_close(s->stmt);
162
+ if (s->res)
163
+ mysql_free_result(s->res);
164
+ xfree(s);
165
+ }
166
+ #endif
167
+
168
+ static void mysql_raise(MYSQL* m)
169
+ {
170
+ VALUE e = rb_exc_new2(eMysql, mysql_error(m));
171
+ rb_iv_set(e, "errno", INT2FIX(mysql_errno(m)));
172
+ #if MYSQL_VERSION_ID >= 40101
173
+ rb_iv_set(e, "sqlstate", rb_tainted_str_new2(mysql_sqlstate(m)));
174
+ #endif
175
+ rb_exc_raise(e);
176
+ }
177
+
178
+ static VALUE mysqlres2obj(MYSQL_RES* res)
179
+ {
180
+ VALUE obj;
181
+ struct mysql_res* resp;
182
+ obj = Data_Make_Struct(cMysqlRes, struct mysql_res, 0, free_mysqlres, resp);
183
+ rb_iv_set(obj, "colname", Qnil);
184
+ rb_iv_set(obj, "tblcolname", Qnil);
185
+ resp->res = res;
186
+ resp->freed = Qfalse;
187
+ rb_obj_call_init(obj, 0, NULL);
188
+ if (++store_result_count > GC_STORE_RESULT_LIMIT)
189
+ rb_gc();
190
+ return obj;
191
+ }
192
+
193
+ /* make Mysql::Field object */
194
+ static VALUE make_field_obj(MYSQL_FIELD* f)
195
+ {
196
+ VALUE obj;
197
+ if (f == NULL)
198
+ return Qnil;
199
+ obj = rb_obj_alloc(cMysqlField);
200
+ rb_iv_set(obj, "name", f->name? rb_str_freeze(rb_tainted_str_new2(f->name)): Qnil);
201
+ rb_iv_set(obj, "table", f->table? rb_str_freeze(rb_tainted_str_new2(f->table)): Qnil);
202
+ rb_iv_set(obj, "def", f->def? rb_str_freeze(rb_tainted_str_new2(f->def)): Qnil);
203
+ rb_iv_set(obj, "type", INT2NUM(f->type));
204
+ rb_iv_set(obj, "length", INT2NUM(f->length));
205
+ rb_iv_set(obj, "max_length", INT2NUM(f->max_length));
206
+ rb_iv_set(obj, "flags", INT2NUM(f->flags));
207
+ rb_iv_set(obj, "decimals", INT2NUM(f->decimals));
208
+ return obj;
209
+ }
210
+
211
+ /*-------------------------------
212
+ * Mysql class method
213
+ */
214
+
215
+ /* init() */
216
+ static VALUE init(VALUE klass)
217
+ {
218
+ struct mysql* myp;
219
+ VALUE obj;
220
+
221
+ obj = Data_Make_Struct(klass, struct mysql, 0, free_mysql, myp);
222
+ mysql_init(&myp->handler);
223
+ myp->connection = Qfalse;
224
+ myp->query_with_result = Qtrue;
225
+ rb_obj_call_init(obj, 0, NULL);
226
+ return obj;
227
+ }
228
+
229
+ /* real_connect(host=nil, user=nil, passwd=nil, db=nil, port=nil, sock=nil, flag=nil) */
230
+ static VALUE real_connect(int argc, VALUE* argv, VALUE klass)
231
+ {
232
+ VALUE host, user, passwd, db, port, sock, flag;
233
+ char *h, *u, *p, *d, *s;
234
+ unsigned int pp, f;
235
+ struct mysql* myp;
236
+ VALUE obj;
237
+
238
+ #if MYSQL_VERSION_ID >= 32200
239
+ rb_scan_args(argc, argv, "07", &host, &user, &passwd, &db, &port, &sock, &flag);
240
+ d = NILorSTRING(db);
241
+ f = NILorINT(flag);
242
+ #elif MYSQL_VERSION_ID >= 32115
243
+ rb_scan_args(argc, argv, "06", &host, &user, &passwd, &port, &sock, &flag);
244
+ f = NILorINT(flag);
245
+ #else
246
+ rb_scan_args(argc, argv, "05", &host, &user, &passwd, &port, &sock);
247
+ #endif
248
+ h = NILorSTRING(host);
249
+ u = NILorSTRING(user);
250
+ p = NILorSTRING(passwd);
251
+ pp = NILorINT(port);
252
+ s = NILorSTRING(sock);
253
+
254
+ #ifdef HAVE_RB_THREAD_START_TIMER
255
+ rb_thread_stop_timer();
256
+ #endif
257
+ obj = Data_Make_Struct(klass, struct mysql, 0, free_mysql, myp);
258
+ #if MYSQL_VERSION_ID >= 32200
259
+ mysql_init(&myp->handler);
260
+ if (mysql_real_connect(&myp->handler, h, u, p, d, pp, s, f) == NULL)
261
+ #elif MYSQL_VERSION_ID >= 32115
262
+ if (mysql_real_connect(&myp->handler, h, u, p, pp, s, f) == NULL)
263
+ #else
264
+ if (mysql_real_connect(&myp->handler, h, u, p, pp, s) == NULL)
265
+ #endif
266
+ {
267
+ #ifdef HAVE_RB_THREAD_START_TIMER
268
+ rb_thread_start_timer();
269
+ #endif
270
+ mysql_raise(&myp->handler);
271
+ }
272
+ #ifdef HAVE_RB_THREAD_START_TIMER
273
+ rb_thread_start_timer();
274
+ #endif
275
+
276
+ myp->handler.reconnect = 0;
277
+ myp->connection = Qtrue;
278
+ myp->query_with_result = Qtrue;
279
+ rb_obj_call_init(obj, argc, argv);
280
+
281
+ return obj;
282
+ }
283
+
284
+ /* escape_string(string) */
285
+ static VALUE escape_string(VALUE klass, VALUE str)
286
+ {
287
+ VALUE ret;
288
+ Check_Type(str, T_STRING);
289
+ ret = rb_str_new(0, (RSTRING_LEN(str))*2+1);
290
+ rb_str_set_len(ret, mysql_escape_string(RSTRING_PTR(ret), RSTRING_PTR(str), RSTRING_LEN(str)));
291
+ return ret;
292
+ }
293
+
294
+ /* client_info() */
295
+ static VALUE client_info(VALUE klass)
296
+ {
297
+ return rb_tainted_str_new2(mysql_get_client_info());
298
+ }
299
+
300
+ #if MYSQL_VERSION_ID >= 32332
301
+ /* my_debug(string) */
302
+ static VALUE my_debug(VALUE obj, VALUE str)
303
+ {
304
+ mysql_debug(StringValuePtr(str));
305
+ return obj;
306
+ }
307
+ #endif
308
+
309
+ #if MYSQL_VERSION_ID >= 40000
310
+ /* client_version() */
311
+ static VALUE client_version(VALUE obj)
312
+ {
313
+ return INT2NUM(mysql_get_client_version());
314
+ }
315
+ #endif
316
+
317
+ /*-------------------------------
318
+ * Mysql object method
319
+ */
320
+
321
+ #if MYSQL_VERSION_ID >= 32200
322
+ /* real_connect(host=nil, user=nil, passwd=nil, db=nil, port=nil, sock=nil, flag=nil) */
323
+ static VALUE real_connect2(int argc, VALUE* argv, VALUE obj)
324
+ {
325
+ VALUE host, user, passwd, db, port, sock, flag;
326
+ char *h, *u, *p, *d, *s;
327
+ unsigned int pp, f;
328
+ MYSQL* m = GetHandler(obj);
329
+ rb_scan_args(argc, argv, "07", &host, &user, &passwd, &db, &port, &sock, &flag);
330
+ d = NILorSTRING(db);
331
+ f = NILorINT(flag);
332
+ h = NILorSTRING(host);
333
+ u = NILorSTRING(user);
334
+ p = NILorSTRING(passwd);
335
+ pp = NILorINT(port);
336
+ s = NILorSTRING(sock);
337
+
338
+ #ifdef HAVE_RB_THREAD_START_TIMER
339
+ rb_thread_stop_timer();
340
+ #endif
341
+ if (mysql_real_connect(m, h, u, p, d, pp, s, f) == NULL) {
342
+ #ifdef HAVE_RB_THREAD_START_TIMER
343
+ rb_thread_start_timer();
344
+ #endif
345
+ mysql_raise(m);
346
+ }
347
+ #ifdef HAVE_RB_THREAD_START_TIMER
348
+ rb_thread_start_timer();
349
+ #endif
350
+ m->reconnect = 0;
351
+ GetMysqlStruct(obj)->connection = Qtrue;
352
+
353
+ return obj;
354
+ }
355
+
356
+ /* options(opt, value=nil) */
357
+ static VALUE options(int argc, VALUE* argv, VALUE obj)
358
+ {
359
+ VALUE opt, val;
360
+ int n;
361
+ my_bool b;
362
+ char* v;
363
+ MYSQL* m = GetHandler(obj);
364
+
365
+ rb_scan_args(argc, argv, "11", &opt, &val);
366
+ switch(NUM2INT(opt)) {
367
+ case MYSQL_OPT_CONNECT_TIMEOUT:
368
+ #if MYSQL_VERSION_ID >= 40100
369
+ case MYSQL_OPT_PROTOCOL:
370
+ #endif
371
+ #if MYSQL_VERSION_ID >= 40101
372
+ case MYSQL_OPT_READ_TIMEOUT:
373
+ case MYSQL_OPT_WRITE_TIMEOUT:
374
+ #endif
375
+ if (val == Qnil)
376
+ rb_raise(rb_eArgError, "wrong # of arguments(1 for 2)");
377
+ n = NUM2INT(val);
378
+ v = (char*)&n;
379
+ break;
380
+ case MYSQL_INIT_COMMAND:
381
+ case MYSQL_READ_DEFAULT_FILE:
382
+ case MYSQL_READ_DEFAULT_GROUP:
383
+ #if MYSQL_VERSION_ID >= 32349
384
+ case MYSQL_SET_CHARSET_DIR:
385
+ case MYSQL_SET_CHARSET_NAME:
386
+ #endif
387
+ #if MYSQL_VERSION_ID >= 40100
388
+ case MYSQL_SHARED_MEMORY_BASE_NAME:
389
+ #endif
390
+ #if MYSQL_VERSION_ID >= 40101
391
+ case MYSQL_SET_CLIENT_IP:
392
+ #endif
393
+ if (val == Qnil)
394
+ rb_raise(rb_eArgError, "wrong # of arguments(1 for 2)");
395
+ v = StringValuePtr(val);
396
+ break;
397
+ #if MYSQL_VERSION_ID >= 40101
398
+ case MYSQL_SECURE_AUTH:
399
+ if (val == Qnil || val == Qfalse)
400
+ b = 1;
401
+ else
402
+ b = 0;
403
+ v = (char*)&b;
404
+ break;
405
+ #endif
406
+ #if MYSQL_VERSION_ID >= 32349
407
+ case MYSQL_OPT_LOCAL_INFILE:
408
+ if (val == Qnil || val == Qfalse)
409
+ v = NULL;
410
+ else {
411
+ n = 1;
412
+ v = (char*)&n;
413
+ }
414
+ break;
415
+ #endif
416
+ default:
417
+ v = NULL;
418
+ }
419
+
420
+ if (mysql_options(m, NUM2INT(opt), v) != 0)
421
+ rb_raise(eMysql, "unknown option: %d", NUM2INT(opt));
422
+ return obj;
423
+ }
424
+ #endif
425
+
426
+ #if MYSQL_VERSION_ID >= 32332
427
+ /* real_escape_string(string) */
428
+ static VALUE real_escape_string(VALUE obj, VALUE str)
429
+ {
430
+ MYSQL* m = GetHandler(obj);
431
+ VALUE ret;
432
+ Check_Type(str, T_STRING);
433
+ ret = rb_str_new(0, (RSTRING_LEN(str))*2+1);
434
+ rb_str_set_len(ret, mysql_real_escape_string(m, RSTRING_PTR(ret), RSTRING_PTR(str), RSTRING_LEN(str)));
435
+ return ret;
436
+ }
437
+ #endif
438
+
439
+ /* initialize() */
440
+ static VALUE initialize(int argc, VALUE* argv, VALUE obj)
441
+ {
442
+ return obj;
443
+ }
444
+
445
+ /* affected_rows() */
446
+ static VALUE affected_rows(VALUE obj)
447
+ {
448
+ return INT2NUM(mysql_affected_rows(GetHandler(obj)));
449
+ }
450
+
451
+ #if MYSQL_VERSION_ID >= 32303
452
+ /* change_user(user=nil, passwd=nil, db=nil) */
453
+ static VALUE change_user(int argc, VALUE* argv, VALUE obj)
454
+ {
455
+ VALUE user, passwd, db;
456
+ char *u, *p, *d;
457
+ MYSQL* m = GetHandler(obj);
458
+ rb_scan_args(argc, argv, "03", &user, &passwd, &db);
459
+ u = NILorSTRING(user);
460
+ p = NILorSTRING(passwd);
461
+ d = NILorSTRING(db);
462
+ if (mysql_change_user(m, u, p, d) != 0)
463
+ mysql_raise(m);
464
+ return obj;
465
+ }
466
+ #endif
467
+
468
+ #if MYSQL_VERSION_ID >= 32321
469
+ /* character_set_name() */
470
+ static VALUE character_set_name(VALUE obj)
471
+ {
472
+ return rb_tainted_str_new2(mysql_character_set_name(GetHandler(obj)));
473
+ }
474
+ #endif
475
+
476
+ /* close() */
477
+ static VALUE my_close(VALUE obj)
478
+ {
479
+ MYSQL* m = GetHandler(obj);
480
+ mysql_close(m);
481
+ GetMysqlStruct(obj)->connection = Qfalse;
482
+ return obj;
483
+ }
484
+
485
+ #if MYSQL_VERSION_ID < 40000
486
+ /* create_db(db) */
487
+ static VALUE create_db(VALUE obj, VALUE db)
488
+ {
489
+ MYSQL* m = GetHandler(obj);
490
+ if (mysql_create_db(m, StringValuePtr(db)) != 0)
491
+ mysql_raise(m);
492
+ return obj;
493
+ }
494
+
495
+ /* drop_db(db) */
496
+ static VALUE drop_db(VALUE obj, VALUE db)
497
+ {
498
+ MYSQL* m = GetHandler(obj);
499
+ if (mysql_drop_db(m, StringValuePtr(db)) != 0)
500
+ mysql_raise(m);
501
+ return obj;
502
+ }
503
+ #endif
504
+
505
+ #if MYSQL_VERSION_ID >= 32332
506
+ /* dump_debug_info() */
507
+ static VALUE dump_debug_info(VALUE obj)
508
+ {
509
+ MYSQL* m = GetHandler(obj);
510
+ if (mysql_dump_debug_info(m) != 0)
511
+ mysql_raise(m);
512
+ return obj;
513
+ }
514
+ #endif
515
+
516
+ /* errno() */
517
+ static VALUE my_errno(VALUE obj)
518
+ {
519
+ return INT2NUM(mysql_errno(GetHandler(obj)));
520
+ }
521
+
522
+ /* error() */
523
+ static VALUE my_error(VALUE obj)
524
+ {
525
+ return rb_str_new2(mysql_error(GetHandler(obj)));
526
+ }
527
+
528
+ /* field_count() */
529
+ static VALUE field_count(VALUE obj)
530
+ {
531
+ return INT2NUM(mysql_field_count(GetHandler(obj)));
532
+ }
533
+
534
+ /* host_info() */
535
+ static VALUE host_info(VALUE obj)
536
+ {
537
+ return rb_tainted_str_new2(mysql_get_host_info(GetHandler(obj)));
538
+ }
539
+
540
+ /* proto_info() */
541
+ static VALUE proto_info(VALUE obj)
542
+ {
543
+ return INT2NUM(mysql_get_proto_info(GetHandler(obj)));
544
+ }
545
+
546
+ /* server_info() */
547
+ static VALUE server_info(VALUE obj)
548
+ {
549
+ return rb_tainted_str_new2(mysql_get_server_info(GetHandler(obj)));
550
+ }
551
+
552
+ /* info() */
553
+ static VALUE info(VALUE obj)
554
+ {
555
+ const char* p = mysql_info(GetHandler(obj));
556
+ return p? rb_tainted_str_new2(p): Qnil;
557
+ }
558
+
559
+ /* insert_id() */
560
+ static VALUE insert_id(VALUE obj)
561
+ {
562
+ return ULL2NUM(mysql_insert_id(GetHandler(obj)));
563
+ }
564
+
565
+ /* kill(pid) */
566
+ static VALUE my_kill(VALUE obj, VALUE pid)
567
+ {
568
+ int p = NUM2INT(pid);
569
+ MYSQL* m = GetHandler(obj);
570
+ if (mysql_kill(m, p) != 0)
571
+ mysql_raise(m);
572
+ return obj;
573
+ }
574
+
575
+ /* list_dbs(db=nil) */
576
+ static VALUE list_dbs(int argc, VALUE* argv, VALUE obj)
577
+ {
578
+ unsigned int i, n;
579
+ VALUE db, ret;
580
+ MYSQL* m = GetHandler(obj);
581
+ MYSQL_RES* res;
582
+
583
+ rb_scan_args(argc, argv, "01", &db);
584
+ res = mysql_list_dbs(m, NILorSTRING(db));
585
+ if (res == NULL)
586
+ mysql_raise(m);
587
+
588
+ n = mysql_num_rows(res);
589
+ ret = rb_ary_new2(n);
590
+ for (i=0; i<n; i++)
591
+ rb_ary_store(ret, i, rb_tainted_str_new2(mysql_fetch_row(res)[0]));
592
+ mysql_free_result(res);
593
+ return ret;
594
+ }
595
+
596
+ /* list_fields(table, field=nil) */
597
+ static VALUE list_fields(int argc, VALUE* argv, VALUE obj)
598
+ {
599
+ VALUE table, field;
600
+ MYSQL* m = GetHandler(obj);
601
+ MYSQL_RES* res;
602
+ rb_scan_args(argc, argv, "11", &table, &field);
603
+ res = mysql_list_fields(m, StringValuePtr(table), NILorSTRING(field));
604
+ if (res == NULL)
605
+ mysql_raise(m);
606
+ return mysqlres2obj(res);
607
+ }
608
+
609
+ /* list_processes() */
610
+ static VALUE list_processes(VALUE obj)
611
+ {
612
+ MYSQL* m = GetHandler(obj);
613
+ MYSQL_RES* res = mysql_list_processes(m);
614
+ if (res == NULL)
615
+ mysql_raise(m);
616
+ return mysqlres2obj(res);
617
+ }
618
+
619
+ /* list_tables(table=nil) */
620
+ static VALUE list_tables(int argc, VALUE* argv, VALUE obj)
621
+ {
622
+ VALUE table;
623
+ MYSQL* m = GetHandler(obj);
624
+ MYSQL_RES* res;
625
+ unsigned int i, n;
626
+ VALUE ret;
627
+
628
+ rb_scan_args(argc, argv, "01", &table);
629
+ res = mysql_list_tables(m, NILorSTRING(table));
630
+ if (res == NULL)
631
+ mysql_raise(m);
632
+
633
+ n = mysql_num_rows(res);
634
+ ret = rb_ary_new2(n);
635
+ for (i=0; i<n; i++)
636
+ rb_ary_store(ret, i, rb_tainted_str_new2(mysql_fetch_row(res)[0]));
637
+ mysql_free_result(res);
638
+ return ret;
639
+ }
640
+
641
+ /* ping() */
642
+ static VALUE ping(VALUE obj)
643
+ {
644
+ MYSQL* m = GetHandler(obj);
645
+ if (mysql_ping(m) != 0)
646
+ mysql_raise(m);
647
+ return obj;
648
+ }
649
+
650
+ /* refresh(r) */
651
+ static VALUE refresh(VALUE obj, VALUE r)
652
+ {
653
+ MYSQL* m = GetHandler(obj);
654
+ if (mysql_refresh(m, NUM2INT(r)) != 0)
655
+ mysql_raise(m);
656
+ return obj;
657
+ }
658
+
659
+ /* reload() */
660
+ static VALUE reload(VALUE obj)
661
+ {
662
+ MYSQL* m = GetHandler(obj);
663
+ if (mysql_reload(m) != 0)
664
+ mysql_raise(m);
665
+ return obj;
666
+ }
667
+
668
+ /* select_db(db) */
669
+ static VALUE select_db(VALUE obj, VALUE db)
670
+ {
671
+ MYSQL* m = GetHandler(obj);
672
+ if (mysql_select_db(m, StringValuePtr(db)) != 0)
673
+ mysql_raise(m);
674
+ return obj;
675
+ }
676
+
677
+ /* shutdown() */
678
+ static VALUE my_shutdown(int argc, VALUE* argv, VALUE obj)
679
+ {
680
+ MYSQL* m = GetHandler(obj);
681
+ VALUE level;
682
+
683
+ rb_scan_args(argc, argv, "01", &level);
684
+ #if MYSQL_VERSION_ID >= 40103
685
+ if (mysql_shutdown(m, NIL_P(level) ? SHUTDOWN_DEFAULT : NUM2INT(level)) != 0)
686
+ #else
687
+ if (mysql_shutdown(m) != 0)
688
+ #endif
689
+ mysql_raise(m);
690
+ return obj;
691
+ }
692
+
693
+ /* stat() */
694
+ static VALUE my_stat(VALUE obj)
695
+ {
696
+ MYSQL* m = GetHandler(obj);
697
+ const char* s = mysql_stat(m);
698
+ if (s == NULL)
699
+ mysql_raise(m);
700
+ return rb_tainted_str_new2(s);
701
+ }
702
+
703
+ /* store_result() */
704
+ static VALUE store_result(VALUE obj)
705
+ {
706
+ MYSQL* m = GetHandler(obj);
707
+ MYSQL_RES* res = mysql_store_result(m);
708
+ if (res == NULL)
709
+ mysql_raise(m);
710
+ return mysqlres2obj(res);
711
+ }
712
+
713
+ /* thread_id() */
714
+ static VALUE thread_id(VALUE obj)
715
+ {
716
+ return INT2NUM(mysql_thread_id(GetHandler(obj)));
717
+ }
718
+
719
+ /* use_result() */
720
+ static VALUE use_result(VALUE obj)
721
+ {
722
+ MYSQL* m = GetHandler(obj);
723
+ MYSQL_RES* res = mysql_use_result(m);
724
+ if (res == NULL)
725
+ mysql_raise(m);
726
+ return mysqlres2obj(res);
727
+ }
728
+
729
+ static VALUE res_free(VALUE);
730
+ /* query(sql) */
731
+ static VALUE query(VALUE obj, VALUE sql)
732
+ {
733
+ int loop = 0;
734
+ MYSQL* m = GetHandler(obj);
735
+ Check_Type(sql, T_STRING);
736
+ if (GetMysqlStruct(obj)->connection == Qfalse) {
737
+ rb_raise(eMysql, "query: not connected");
738
+ }
739
+ if (rb_block_given_p()) {
740
+ if (mysql_real_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0)
741
+ mysql_raise(m);
742
+ do {
743
+ MYSQL_RES* res = mysql_store_result(m);
744
+ if (res == NULL) {
745
+ if (mysql_field_count(m) != 0)
746
+ mysql_raise(m);
747
+ } else {
748
+ VALUE robj = mysqlres2obj(res);
749
+ rb_ensure(rb_yield, robj, res_free, robj);
750
+ }
751
+ #if MYSQL_VERSION_ID >= 40101
752
+ if ((loop = mysql_next_result(m)) > 0)
753
+ mysql_raise(m);
754
+ } while (loop == 0);
755
+ #else
756
+ } while (0);
757
+ #endif
758
+ return obj;
759
+ }
760
+ if (mysql_real_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0)
761
+ mysql_raise(m);
762
+ if (GetMysqlStruct(obj)->query_with_result == Qfalse)
763
+ return obj;
764
+ if (mysql_field_count(m) == 0)
765
+ return Qnil;
766
+ return store_result(obj);
767
+ }
768
+
769
+ #if MYSQL_VERSION_ID >= 40100
770
+ /* server_version() */
771
+ static VALUE server_version(VALUE obj)
772
+ {
773
+ return INT2NUM(mysql_get_server_version(GetHandler(obj)));
774
+ }
775
+
776
+ /* warning_count() */
777
+ static VALUE warning_count(VALUE obj)
778
+ {
779
+ return INT2NUM(mysql_warning_count(GetHandler(obj)));
780
+ }
781
+
782
+ /* commit() */
783
+ static VALUE commit(VALUE obj)
784
+ {
785
+ MYSQL* m = GetHandler(obj);
786
+ if (mysql_commit(m) != 0)
787
+ mysql_raise(m);
788
+ return obj;
789
+ }
790
+
791
+ /* rollback() */
792
+ static VALUE rollback(VALUE obj)
793
+ {
794
+ MYSQL* m = GetHandler(obj);
795
+ if (mysql_rollback(m) != 0)
796
+ mysql_raise(m);
797
+ return obj;
798
+ }
799
+
800
+ /* autocommit() */
801
+ static VALUE autocommit(VALUE obj, VALUE mode)
802
+ {
803
+ MYSQL* m = GetHandler(obj);
804
+ int f;
805
+ f = (mode == Qnil || mode == Qfalse || (rb_type(mode) == T_FIXNUM && NUM2INT(mode) == 0)) ? 0 : 1;
806
+ if (mysql_autocommit(m, f) != 0)
807
+ mysql_raise(m);
808
+ return obj;
809
+ }
810
+ #endif
811
+
812
+ #ifdef HAVE_MYSQL_SSL_SET
813
+ /* ssl_set(key=nil, cert=nil, ca=nil, capath=nil, cipher=nil) */
814
+ static VALUE ssl_set(int argc, VALUE* argv, VALUE obj)
815
+ {
816
+ VALUE key, cert, ca, capath, cipher;
817
+ char *s_key, *s_cert, *s_ca, *s_capath, *s_cipher;
818
+ MYSQL* m = GetHandler(obj);
819
+ rb_scan_args(argc, argv, "05", &key, &cert, &ca, &capath, &cipher);
820
+ s_key = NILorSTRING(key);
821
+ s_cert = NILorSTRING(cert);
822
+ s_ca = NILorSTRING(ca);
823
+ s_capath = NILorSTRING(capath);
824
+ s_cipher = NILorSTRING(cipher);
825
+ mysql_ssl_set(m, s_key, s_cert, s_ca, s_capath, s_cipher);
826
+ return obj;
827
+ }
828
+ #endif
829
+
830
+ #if MYSQL_VERSION_ID >= 40100
831
+ /* more_results() */
832
+ static VALUE more_results(VALUE obj)
833
+ {
834
+ if (mysql_more_results(GetHandler(obj)) == 0)
835
+ return Qfalse;
836
+ else
837
+ return Qtrue;
838
+ }
839
+
840
+ static VALUE next_result(VALUE obj)
841
+ {
842
+ MYSQL* m = GetHandler(obj);
843
+ int ret;
844
+ ret = mysql_next_result(m);
845
+ if (ret > 0)
846
+ mysql_raise(m);
847
+ if (ret == 0)
848
+ return Qtrue;
849
+ return Qfalse;
850
+ }
851
+ #endif
852
+
853
+ #if MYSQL_VERSION_ID >= 40101
854
+ /* set_server_option(option) */
855
+ static VALUE set_server_option(VALUE obj, VALUE option)
856
+ {
857
+ MYSQL *m = GetHandler(obj);
858
+ if (mysql_set_server_option(m, NUM2INT(option)) != 0)
859
+ mysql_raise(m);
860
+ return obj;
861
+ }
862
+
863
+ /* sqlstate() */
864
+ static VALUE sqlstate(VALUE obj)
865
+ {
866
+ MYSQL *m = GetHandler(obj);
867
+ return rb_tainted_str_new2(mysql_sqlstate(m));
868
+ }
869
+ #endif
870
+
871
+ #if MYSQL_VERSION_ID >= 40102
872
+ /* stmt_init() */
873
+ static VALUE stmt_init(VALUE obj)
874
+ {
875
+ MYSQL *m = GetHandler(obj);
876
+ MYSQL_STMT *s;
877
+ struct mysql_stmt* stmt;
878
+ my_bool true = 1;
879
+ VALUE st_obj;
880
+
881
+ if ((s = mysql_stmt_init(m)) == NULL)
882
+ mysql_raise(m);
883
+ if (mysql_stmt_attr_set(s, STMT_ATTR_UPDATE_MAX_LENGTH, &true))
884
+ rb_raise(rb_eArgError, "mysql_stmt_attr_set() failed");
885
+ st_obj = Data_Make_Struct(cMysqlStmt, struct mysql_stmt, 0, free_mysqlstmt, stmt);
886
+ memset(stmt, 0, sizeof(*stmt));
887
+ stmt->stmt = s;
888
+ stmt->closed = Qfalse;
889
+ return st_obj;
890
+ }
891
+
892
+ static VALUE stmt_prepare(VALUE obj, VALUE query);
893
+ /* prepare(query) */
894
+ static VALUE prepare(VALUE obj, VALUE query)
895
+ {
896
+ VALUE st;
897
+ st = stmt_init(obj);
898
+ return stmt_prepare(st, query);
899
+ }
900
+ #endif
901
+
902
+ /* query_with_result() */
903
+ static VALUE query_with_result(VALUE obj)
904
+ {
905
+ return GetMysqlStruct(obj)->query_with_result? Qtrue: Qfalse;
906
+ }
907
+
908
+ /* query_with_result=(flag) */
909
+ static VALUE query_with_result_set(VALUE obj, VALUE flag)
910
+ {
911
+ if (TYPE(flag) != T_TRUE && TYPE(flag) != T_FALSE)
912
+ rb_raise(rb_eTypeError, "invalid type, required true or false.");
913
+ GetMysqlStruct(obj)->query_with_result = flag;
914
+ return flag;
915
+ }
916
+
917
+ /* reconnect() */
918
+ static VALUE reconnect(VALUE obj)
919
+ {
920
+ return GetHandler(obj)->reconnect ? Qtrue : Qfalse;
921
+ }
922
+
923
+ /* reconnect=(flag) */
924
+ static VALUE reconnect_set(VALUE obj, VALUE flag)
925
+ {
926
+ GetHandler(obj)->reconnect = (flag == Qnil || flag == Qfalse) ? 0 : 1;
927
+ return flag;
928
+ }
929
+
930
+ /*-------------------------------
931
+ * Mysql::Result object method
932
+ */
933
+
934
+ /* check if already freed */
935
+ static void check_free(VALUE obj)
936
+ {
937
+ struct mysql_res* resp = DATA_PTR(obj);
938
+ if (resp->freed == Qtrue)
939
+ rb_raise(eMysql, "Mysql::Result object is already freed");
940
+ }
941
+
942
+ /* data_seek(offset) */
943
+ static VALUE data_seek(VALUE obj, VALUE offset)
944
+ {
945
+ check_free(obj);
946
+ mysql_data_seek(GetMysqlRes(obj), NUM2INT(offset));
947
+ return obj;
948
+ }
949
+
950
+ /* fetch_field() */
951
+ static VALUE fetch_field(VALUE obj)
952
+ {
953
+ check_free(obj);
954
+ return make_field_obj(mysql_fetch_field(GetMysqlRes(obj)));
955
+ }
956
+
957
+ /* fetch_fields() */
958
+ static VALUE fetch_fields(VALUE obj)
959
+ {
960
+ MYSQL_RES* res;
961
+ MYSQL_FIELD* f;
962
+ unsigned int n;
963
+ VALUE ret;
964
+ unsigned int i;
965
+ check_free(obj);
966
+ res = GetMysqlRes(obj);
967
+ f = mysql_fetch_fields(res);
968
+ n = mysql_num_fields(res);
969
+ ret = rb_ary_new2(n);
970
+ for (i=0; i<n; i++)
971
+ rb_ary_store(ret, i, make_field_obj(&f[i]));
972
+ return ret;
973
+ }
974
+
975
+ /* fetch_field_direct(nr) */
976
+ static VALUE fetch_field_direct(VALUE obj, VALUE nr)
977
+ {
978
+ MYSQL_RES* res;
979
+ unsigned int max;
980
+ unsigned int n;
981
+ check_free(obj);
982
+ res = GetMysqlRes(obj);
983
+ max = mysql_num_fields(res);
984
+ n = NUM2INT(nr);
985
+ if (n >= max)
986
+ rb_raise(eMysql, "%d: out of range (max: %d)", n, max-1);
987
+ #if MYSQL_VERSION_ID >= 32226
988
+ return make_field_obj(mysql_fetch_field_direct(res, n));
989
+ #else
990
+ return make_field_obj(&mysql_fetch_field_direct(res, n));
991
+ #endif
992
+ }
993
+
994
+ /* fetch_lengths() */
995
+ static VALUE fetch_lengths(VALUE obj)
996
+ {
997
+ MYSQL_RES* res;
998
+ unsigned int n;
999
+ unsigned long* lengths;
1000
+ VALUE ary;
1001
+ unsigned int i;
1002
+ check_free(obj);
1003
+ res = GetMysqlRes(obj);
1004
+ n = mysql_num_fields(res);
1005
+ lengths = mysql_fetch_lengths(res);
1006
+ if (lengths == NULL)
1007
+ return Qnil;
1008
+ ary = rb_ary_new2(n);
1009
+ for (i=0; i<n; i++)
1010
+ rb_ary_store(ary, i, INT2NUM(lengths[i]));
1011
+ return ary;
1012
+ }
1013
+
1014
+ /* fetch_row() */
1015
+ static VALUE fetch_row(VALUE obj)
1016
+ {
1017
+ MYSQL_RES* res;
1018
+ unsigned int n;
1019
+ MYSQL_ROW row;
1020
+ unsigned long* lengths;
1021
+ VALUE ary;
1022
+ unsigned int i;
1023
+ check_free(obj);
1024
+ res = GetMysqlRes(obj);
1025
+ n = mysql_num_fields(res);
1026
+ row = mysql_fetch_row(res);
1027
+ lengths = mysql_fetch_lengths(res);
1028
+ if (row == NULL)
1029
+ return Qnil;
1030
+ ary = rb_ary_new2(n);
1031
+ for (i=0; i<n; i++)
1032
+ rb_ary_store(ary, i, row[i]? rb_tainted_str_new(row[i], lengths[i]): Qnil);
1033
+ return ary;
1034
+ }
1035
+
1036
+ /* fetch_hash2 (internal) */
1037
+ static VALUE fetch_hash2(VALUE obj, VALUE with_table)
1038
+ {
1039
+ MYSQL_RES* res = GetMysqlRes(obj);
1040
+ unsigned int n = mysql_num_fields(res);
1041
+ MYSQL_ROW row = mysql_fetch_row(res);
1042
+ unsigned long* lengths = mysql_fetch_lengths(res);
1043
+ MYSQL_FIELD* fields = mysql_fetch_fields(res);
1044
+ unsigned int i;
1045
+ VALUE hash;
1046
+ VALUE colname;
1047
+ if (row == NULL)
1048
+ return Qnil;
1049
+ hash = rb_hash_new();
1050
+
1051
+ if (with_table == Qnil || with_table == Qfalse) {
1052
+ colname = rb_iv_get(obj, "colname");
1053
+ if (colname == Qnil) {
1054
+ colname = rb_ary_new2(n);
1055
+ for (i=0; i<n; i++) {
1056
+ VALUE s = rb_tainted_str_new2(fields[i].name);
1057
+ rb_obj_freeze(s);
1058
+ rb_ary_store(colname, i, s);
1059
+ }
1060
+ rb_obj_freeze(colname);
1061
+ rb_iv_set(obj, "colname", colname);
1062
+ }
1063
+ } else {
1064
+ colname = rb_iv_get(obj, "tblcolname");
1065
+ if (colname == Qnil) {
1066
+ colname = rb_ary_new2(n);
1067
+ for (i=0; i<n; i++) {
1068
+ int len = strlen(fields[i].table)+strlen(fields[i].name)+1;
1069
+ VALUE s = rb_tainted_str_new(NULL, len);
1070
+ snprintf(RSTRING_PTR(s), len+1, "%s.%s", fields[i].table, fields[i].name);
1071
+ rb_obj_freeze(s);
1072
+ rb_ary_store(colname, i, s);
1073
+ }
1074
+ rb_obj_freeze(colname);
1075
+ rb_iv_set(obj, "tblcolname", colname);
1076
+ }
1077
+ }
1078
+ for (i=0; i<n; i++) {
1079
+ rb_hash_aset(hash, rb_ary_entry(colname, i), row[i]? rb_tainted_str_new(row[i], lengths[i]): Qnil);
1080
+ }
1081
+ return hash;
1082
+ }
1083
+
1084
+ /* fetch_hash(with_table=false) */
1085
+ static VALUE fetch_hash(int argc, VALUE* argv, VALUE obj)
1086
+ {
1087
+ VALUE with_table;
1088
+ check_free(obj);
1089
+ rb_scan_args(argc, argv, "01", &with_table);
1090
+ if (with_table == Qnil)
1091
+ with_table = Qfalse;
1092
+ return fetch_hash2(obj, with_table);
1093
+ }
1094
+
1095
+ /* field_seek(offset) */
1096
+ static VALUE field_seek(VALUE obj, VALUE offset)
1097
+ {
1098
+ check_free(obj);
1099
+ return INT2NUM(mysql_field_seek(GetMysqlRes(obj), NUM2INT(offset)));
1100
+ }
1101
+
1102
+ /* field_tell() */
1103
+ static VALUE field_tell(VALUE obj)
1104
+ {
1105
+ check_free(obj);
1106
+ return INT2NUM(mysql_field_tell(GetMysqlRes(obj)));
1107
+ }
1108
+
1109
+ /* free() */
1110
+ static VALUE res_free(VALUE obj)
1111
+ {
1112
+ struct mysql_res* resp = DATA_PTR(obj);
1113
+ check_free(obj);
1114
+ mysql_free_result(resp->res);
1115
+ resp->freed = Qtrue;
1116
+ store_result_count--;
1117
+ return Qnil;
1118
+ }
1119
+
1120
+ /* num_fields() */
1121
+ static VALUE num_fields(VALUE obj)
1122
+ {
1123
+ check_free(obj);
1124
+ return INT2NUM(mysql_num_fields(GetMysqlRes(obj)));
1125
+ }
1126
+
1127
+ /* num_rows() */
1128
+ static VALUE num_rows(VALUE obj)
1129
+ {
1130
+ check_free(obj);
1131
+ return INT2NUM(mysql_num_rows(GetMysqlRes(obj)));
1132
+ }
1133
+
1134
+ /* row_seek(offset) */
1135
+ static VALUE row_seek(VALUE obj, VALUE offset)
1136
+ {
1137
+ MYSQL_ROW_OFFSET prev_offset;
1138
+ if (CLASS_OF(offset) != cMysqlRowOffset)
1139
+ rb_raise(rb_eTypeError, "wrong argument type %s (expected Mysql::RowOffset)", rb_obj_classname(offset));
1140
+ check_free(obj);
1141
+ prev_offset = mysql_row_seek(GetMysqlRes(obj), DATA_PTR(offset));
1142
+ return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, prev_offset);
1143
+ }
1144
+
1145
+ /* row_tell() */
1146
+ static VALUE row_tell(VALUE obj)
1147
+ {
1148
+ MYSQL_ROW_OFFSET offset;
1149
+ check_free(obj);
1150
+ offset = mysql_row_tell(GetMysqlRes(obj));
1151
+ return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, offset);
1152
+ }
1153
+
1154
+ /* each {...} */
1155
+ static VALUE each(VALUE obj)
1156
+ {
1157
+ VALUE row;
1158
+ check_free(obj);
1159
+ while ((row = fetch_row(obj)) != Qnil)
1160
+ rb_yield(row);
1161
+ return obj;
1162
+ }
1163
+
1164
+ /* each_hash(with_table=false) {...} */
1165
+ static VALUE each_hash(int argc, VALUE* argv, VALUE obj)
1166
+ {
1167
+ VALUE with_table;
1168
+ VALUE hash;
1169
+ check_free(obj);
1170
+ rb_scan_args(argc, argv, "01", &with_table);
1171
+ if (with_table == Qnil)
1172
+ with_table = Qfalse;
1173
+ while ((hash = fetch_hash2(obj, with_table)) != Qnil)
1174
+ rb_yield(hash);
1175
+ return obj;
1176
+ }
1177
+
1178
+ /*-------------------------------
1179
+ * Mysql::Field object method
1180
+ */
1181
+
1182
+ /* hash */
1183
+ static VALUE field_hash(VALUE obj)
1184
+ {
1185
+ VALUE h = rb_hash_new();
1186
+ rb_hash_aset(h, rb_str_new2("name"), rb_iv_get(obj, "name"));
1187
+ rb_hash_aset(h, rb_str_new2("table"), rb_iv_get(obj, "table"));
1188
+ rb_hash_aset(h, rb_str_new2("def"), rb_iv_get(obj, "def"));
1189
+ rb_hash_aset(h, rb_str_new2("type"), rb_iv_get(obj, "type"));
1190
+ rb_hash_aset(h, rb_str_new2("length"), rb_iv_get(obj, "length"));
1191
+ rb_hash_aset(h, rb_str_new2("max_length"), rb_iv_get(obj, "max_length"));
1192
+ rb_hash_aset(h, rb_str_new2("flags"), rb_iv_get(obj, "flags"));
1193
+ rb_hash_aset(h, rb_str_new2("decimals"), rb_iv_get(obj, "decimals"));
1194
+ return h;
1195
+ }
1196
+
1197
+ /* inspect */
1198
+ static VALUE field_inspect(VALUE obj)
1199
+ {
1200
+ VALUE n = rb_iv_get(obj, "name");
1201
+ VALUE s = rb_str_new(0, RSTRING_LEN(n) + 16);
1202
+ sprintf(RSTRING_PTR(s), "#<Mysql::Field:%s>", RSTRING_PTR(n));
1203
+ return s;
1204
+ }
1205
+
1206
+ #define DefineMysqlFieldMemberMethod(m)\
1207
+ static VALUE field_##m(VALUE obj)\
1208
+ {return rb_iv_get(obj, #m);}
1209
+
1210
+ DefineMysqlFieldMemberMethod(name)
1211
+ DefineMysqlFieldMemberMethod(table)
1212
+ DefineMysqlFieldMemberMethod(def)
1213
+ DefineMysqlFieldMemberMethod(type)
1214
+ DefineMysqlFieldMemberMethod(length)
1215
+ DefineMysqlFieldMemberMethod(max_length)
1216
+ DefineMysqlFieldMemberMethod(flags)
1217
+ DefineMysqlFieldMemberMethod(decimals)
1218
+
1219
+ #ifdef IS_NUM
1220
+ /* is_num? */
1221
+ static VALUE field_is_num(VALUE obj)
1222
+ {
1223
+ return IS_NUM(NUM2INT(rb_iv_get(obj, "type"))) ? Qtrue : Qfalse;
1224
+ }
1225
+ #endif
1226
+
1227
+ #ifdef IS_NOT_NULL
1228
+ /* is_not_null? */
1229
+ static VALUE field_is_not_null(VALUE obj)
1230
+ {
1231
+ return IS_NOT_NULL(NUM2INT(rb_iv_get(obj, "flags"))) ? Qtrue : Qfalse;
1232
+ }
1233
+ #endif
1234
+
1235
+ #ifdef IS_PRI_KEY
1236
+ /* is_pri_key? */
1237
+ static VALUE field_is_pri_key(VALUE obj)
1238
+ {
1239
+ return IS_PRI_KEY(NUM2INT(rb_iv_get(obj, "flags"))) ? Qtrue : Qfalse;
1240
+ }
1241
+ #endif
1242
+
1243
+ #if MYSQL_VERSION_ID >= 40102
1244
+ /*-------------------------------
1245
+ * Mysql::Stmt object method
1246
+ */
1247
+
1248
+ /* check if stmt is already closed */
1249
+ static void check_stmt_closed(VALUE obj)
1250
+ {
1251
+ struct mysql_stmt* s = DATA_PTR(obj);
1252
+ if (s->closed == Qtrue)
1253
+ rb_raise(eMysql, "Mysql::Stmt object is already closed");
1254
+ }
1255
+
1256
+ static void mysql_stmt_raise(MYSQL_STMT* s)
1257
+ {
1258
+ VALUE e = rb_exc_new2(eMysql, mysql_stmt_error(s));
1259
+ rb_iv_set(e, "errno", INT2FIX(mysql_stmt_errno(s)));
1260
+ rb_iv_set(e, "sqlstate", rb_tainted_str_new2(mysql_stmt_sqlstate(s)));
1261
+ rb_exc_raise(e);
1262
+ }
1263
+
1264
+ /* affected_rows() */
1265
+ static VALUE stmt_affected_rows(VALUE obj)
1266
+ {
1267
+ struct mysql_stmt* s = DATA_PTR(obj);
1268
+ my_ulonglong n;
1269
+ check_stmt_closed(obj);
1270
+ n = mysql_stmt_affected_rows(s->stmt);
1271
+ return INT2NUM(n);
1272
+ }
1273
+
1274
+ #if 0
1275
+ /* attr_get(option) */
1276
+ static VALUE stmt_attr_get(VALUE obj, VALUE opt)
1277
+ {
1278
+ struct mysql_stmt* s = DATA_PTR(obj);
1279
+ check_stmt_closed(obj);
1280
+ if (NUM2INT(opt) == STMT_ATTR_UPDATE_MAX_LENGTH) {
1281
+ my_bool arg;
1282
+ mysql_stmt_attr_get(s->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &arg);
1283
+ return arg == 1 ? Qtrue : Qfalse;
1284
+ }
1285
+ rb_raise(eMysql, "unknown option: %d", NUM2INT(opt));
1286
+ }
1287
+
1288
+ /* attr_set(option, arg) */
1289
+ static VALUE stmt_attr_set(VALUE obj, VALUE opt, VALUE val)
1290
+ {
1291
+ struct mysql_stmt* s = DATA_PTR(obj);
1292
+ check_stmt_closed(obj);
1293
+ if (NUM2INT(opt) == STMT_ATTR_UPDATE_MAX_LENGTH) {
1294
+ my_bool arg;
1295
+ arg = (val == Qnil || val == Qfalse) ? 0 : 1;
1296
+ mysql_stmt_attr_set(s->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &arg);
1297
+ return obj;
1298
+ }
1299
+ rb_raise(eMysql, "unknown option: %d", NUM2INT(opt));
1300
+ }
1301
+ #endif
1302
+
1303
+ /* bind_result(bind,...) */
1304
+ static VALUE stmt_bind_result(int argc, VALUE *argv, VALUE obj)
1305
+ {
1306
+ struct mysql_stmt* s = DATA_PTR(obj);
1307
+ int i;
1308
+ MYSQL_FIELD *field;
1309
+
1310
+ check_stmt_closed(obj);
1311
+ if (argc != s->result.n)
1312
+ rb_raise(eMysql, "bind_result: result value count(%d) != number of argument(%d)", s->result.n, argc);
1313
+ for (i = 0; i < argc; i++) {
1314
+ if (argv[i] == Qnil || argv[i] == rb_cNilClass) {
1315
+ field = mysql_fetch_fields(s->res);
1316
+ s->result.bind[i].buffer_type = field[i].type;
1317
+ }
1318
+ else if (argv[i] == rb_cString)
1319
+ s->result.bind[i].buffer_type = MYSQL_TYPE_STRING;
1320
+ else if (argv[i] == rb_cNumeric || argv[i] == rb_cInteger || argv[i] == rb_cFixnum)
1321
+ s->result.bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
1322
+ else if (argv[i] == rb_cFloat)
1323
+ s->result.bind[i].buffer_type = MYSQL_TYPE_DOUBLE;
1324
+ else if (argv[i] == cMysqlTime)
1325
+ s->result.bind[i].buffer_type = MYSQL_TYPE_DATETIME;
1326
+ else
1327
+ rb_raise(rb_eTypeError, "unrecognized class: %s", RSTRING_PTR(rb_inspect(argv[i])));
1328
+ if (mysql_stmt_bind_result(s->stmt, s->result.bind))
1329
+ mysql_stmt_raise(s->stmt);
1330
+ }
1331
+ return obj;
1332
+ }
1333
+
1334
+ /* close() */
1335
+ static VALUE stmt_close(VALUE obj)
1336
+ {
1337
+ struct mysql_stmt* s = DATA_PTR(obj);
1338
+ check_stmt_closed(obj);
1339
+ mysql_stmt_close(s->stmt);
1340
+ s->closed = Qtrue;
1341
+ return Qnil;
1342
+ }
1343
+
1344
+ /* data_seek(offset) */
1345
+ static VALUE stmt_data_seek(VALUE obj, VALUE offset)
1346
+ {
1347
+ struct mysql_stmt* s = DATA_PTR(obj);
1348
+ check_stmt_closed(obj);
1349
+ mysql_stmt_data_seek(s->stmt, NUM2INT(offset));
1350
+ return obj;
1351
+ }
1352
+
1353
+ /* execute(arg,...) */
1354
+ static VALUE stmt_execute(int argc, VALUE *argv, VALUE obj)
1355
+ {
1356
+ struct mysql_stmt *s = DATA_PTR(obj);
1357
+ MYSQL_STMT *stmt = s->stmt;
1358
+ int i;
1359
+
1360
+ check_stmt_closed(obj);
1361
+ free_execute_memory(s);
1362
+ if (s->param.n != argc)
1363
+ rb_raise(eMysql, "execute: param_count(%d) != number of argument(%d)", s->param.n, argc);
1364
+ if (argc > 0) {
1365
+ memset(s->param.bind, 0, sizeof(*(s->param.bind))*argc);
1366
+ for (i = 0; i < argc; i++) {
1367
+ switch (TYPE(argv[i])) {
1368
+ case T_NIL:
1369
+ s->param.bind[i].buffer_type = MYSQL_TYPE_NULL;
1370
+ break;
1371
+ case T_FIXNUM:
1372
+ #if SIZEOF_INT < SIZEOF_LONG
1373
+ s->param.bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
1374
+ s->param.bind[i].buffer = &(s->param.buffer[i]);
1375
+ *(LONG_LONG*)(s->param.bind[i].buffer) = FIX2LONG(argv[i]);
1376
+ #else
1377
+ s->param.bind[i].buffer_type = MYSQL_TYPE_LONG;
1378
+ s->param.bind[i].buffer = &(s->param.buffer[i]);
1379
+ *(int*)(s->param.bind[i].buffer) = FIX2INT(argv[i]);
1380
+ #endif
1381
+ break;
1382
+ case T_BIGNUM:
1383
+ s->param.bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
1384
+ s->param.bind[i].buffer = &(s->param.buffer[i]);
1385
+ *(LONG_LONG*)(s->param.bind[i].buffer) = rb_big2ll(argv[i]);
1386
+ break;
1387
+ case T_FLOAT:
1388
+ s->param.bind[i].buffer_type = MYSQL_TYPE_DOUBLE;
1389
+ s->param.bind[i].buffer = &(s->param.buffer[i]);
1390
+ *(double*)(s->param.bind[i].buffer) = NUM2DBL(argv[i]);
1391
+ break;
1392
+ case T_STRING:
1393
+ s->param.bind[i].buffer_type = MYSQL_TYPE_STRING;
1394
+ s->param.bind[i].buffer = RSTRING_PTR(argv[i]);
1395
+ s->param.bind[i].buffer_length = RSTRING_LEN(argv[i]);
1396
+ s->param.length[i] = RSTRING_LEN(argv[i]);
1397
+ s->param.bind[i].length = &(s->param.length[i]);
1398
+ break;
1399
+ default:
1400
+ if (CLASS_OF(argv[i]) == rb_cTime) {
1401
+ MYSQL_TIME t;
1402
+ VALUE a = rb_funcall(argv[i], rb_intern("to_a"), 0);
1403
+ s->param.bind[i].buffer_type = MYSQL_TYPE_DATETIME;
1404
+ s->param.bind[i].buffer = &(s->param.buffer[i]);
1405
+ memset(&t, 0, sizeof(t)); /* avoid warning */
1406
+ t.second_part = 0;
1407
+ t.neg = 0;
1408
+ t.second = FIX2INT(RARRAY_PTR(a)[0]);
1409
+ t.minute = FIX2INT(RARRAY_PTR(a)[1]);
1410
+ t.hour = FIX2INT(RARRAY_PTR(a)[2]);
1411
+ t.day = FIX2INT(RARRAY_PTR(a)[3]);
1412
+ t.month = FIX2INT(RARRAY_PTR(a)[4]);
1413
+ t.year = FIX2INT(RARRAY_PTR(a)[5]);
1414
+ *(MYSQL_TIME*)&(s->param.buffer[i]) = t;
1415
+ } else if (CLASS_OF(argv[i]) == cMysqlTime) {
1416
+ MYSQL_TIME t;
1417
+ s->param.bind[i].buffer_type = MYSQL_TYPE_DATETIME;
1418
+ s->param.bind[i].buffer = &(s->param.buffer[i]);
1419
+ memset(&t, 0, sizeof(t)); /* avoid warning */
1420
+ t.second_part = 0;
1421
+ t.neg = 0;
1422
+ t.second = NUM2INT(rb_iv_get(argv[i], "second"));
1423
+ t.minute = NUM2INT(rb_iv_get(argv[i], "minute"));
1424
+ t.hour = NUM2INT(rb_iv_get(argv[i], "hour"));
1425
+ t.day = NUM2INT(rb_iv_get(argv[i], "day"));
1426
+ t.month = NUM2INT(rb_iv_get(argv[i], "month"));
1427
+ t.year = NUM2INT(rb_iv_get(argv[i], "year"));
1428
+ *(MYSQL_TIME*)&(s->param.buffer[i]) = t;
1429
+ } else
1430
+ rb_raise(rb_eTypeError, "unsupported type: %d", TYPE(argv[i]));
1431
+ }
1432
+ }
1433
+ if (mysql_stmt_bind_param(stmt, s->param.bind))
1434
+ mysql_stmt_raise(stmt);
1435
+ }
1436
+
1437
+ if (mysql_stmt_execute(stmt))
1438
+ mysql_stmt_raise(stmt);
1439
+ if (s->res) {
1440
+ MYSQL_FIELD *field;
1441
+ if (mysql_stmt_store_result(stmt))
1442
+ mysql_stmt_raise(stmt);
1443
+ field = mysql_fetch_fields(s->res);
1444
+ for (i = 0; i < s->result.n; i++) {
1445
+ switch(s->result.bind[i].buffer_type) {
1446
+ case MYSQL_TYPE_NULL:
1447
+ break;
1448
+ case MYSQL_TYPE_TINY:
1449
+ case MYSQL_TYPE_SHORT:
1450
+ case MYSQL_TYPE_YEAR:
1451
+ case MYSQL_TYPE_INT24:
1452
+ case MYSQL_TYPE_LONG:
1453
+ case MYSQL_TYPE_LONGLONG:
1454
+ case MYSQL_TYPE_FLOAT:
1455
+ case MYSQL_TYPE_DOUBLE:
1456
+ s->result.bind[i].buffer = xmalloc(8);
1457
+ s->result.bind[i].buffer_length = 8;
1458
+ memset(s->result.bind[i].buffer, 0, 8);
1459
+ break;
1460
+ case MYSQL_TYPE_DECIMAL:
1461
+ case MYSQL_TYPE_STRING:
1462
+ case MYSQL_TYPE_VAR_STRING:
1463
+ case MYSQL_TYPE_TINY_BLOB:
1464
+ case MYSQL_TYPE_BLOB:
1465
+ case MYSQL_TYPE_MEDIUM_BLOB:
1466
+ case MYSQL_TYPE_LONG_BLOB:
1467
+ #if MYSQL_VERSION_ID >= 50003
1468
+ case MYSQL_TYPE_NEWDECIMAL:
1469
+ case MYSQL_TYPE_BIT:
1470
+ #endif
1471
+ s->result.bind[i].buffer = xmalloc(field[i].max_length);
1472
+ memset(s->result.bind[i].buffer, 0, field[i].max_length);
1473
+ s->result.bind[i].buffer_length = field[i].max_length;
1474
+ break;
1475
+ case MYSQL_TYPE_TIME:
1476
+ case MYSQL_TYPE_DATE:
1477
+ case MYSQL_TYPE_DATETIME:
1478
+ case MYSQL_TYPE_TIMESTAMP:
1479
+ s->result.bind[i].buffer = xmalloc(sizeof(MYSQL_TIME));
1480
+ s->result.bind[i].buffer_length = sizeof(MYSQL_TIME);
1481
+ memset(s->result.bind[i].buffer, 0, sizeof(MYSQL_TIME));
1482
+ break;
1483
+ default:
1484
+ rb_raise(rb_eTypeError, "unknown buffer_type: %d", s->result.bind[i].buffer_type);
1485
+ }
1486
+ }
1487
+ if (mysql_stmt_bind_result(s->stmt, s->result.bind))
1488
+ mysql_stmt_raise(s->stmt);
1489
+ }
1490
+ return obj;
1491
+ }
1492
+
1493
+ /* fetch() */
1494
+ static VALUE stmt_fetch(VALUE obj)
1495
+ {
1496
+ struct mysql_stmt* s = DATA_PTR(obj);
1497
+ VALUE ret;
1498
+ int i;
1499
+ int r;
1500
+
1501
+ check_stmt_closed(obj);
1502
+ r = mysql_stmt_fetch(s->stmt);
1503
+ if (r == MYSQL_NO_DATA)
1504
+ return Qnil;
1505
+ #ifdef MYSQL_DATA_TRUNCATED
1506
+ if (r == MYSQL_DATA_TRUNCATED)
1507
+ rb_raise(rb_eRuntimeError, "unexpectedly data truncated");
1508
+ #endif
1509
+ if (r == 1)
1510
+ mysql_stmt_raise(s->stmt);
1511
+
1512
+ ret = rb_ary_new2(s->result.n);
1513
+ for (i = 0; i < s->result.n; i++) {
1514
+ if (s->result.is_null[i])
1515
+ rb_ary_push(ret, Qnil);
1516
+ else {
1517
+ VALUE v;
1518
+ MYSQL_TIME *t;
1519
+ switch (s->result.bind[i].buffer_type) {
1520
+ case MYSQL_TYPE_TINY:
1521
+ if (s->result.bind[i].is_unsigned)
1522
+ v = UINT2NUM(*(unsigned char *)s->result.bind[i].buffer);
1523
+ else
1524
+ v = INT2NUM(*(signed char *)s->result.bind[i].buffer);
1525
+ break;
1526
+ case MYSQL_TYPE_SHORT:
1527
+ case MYSQL_TYPE_YEAR:
1528
+ if (s->result.bind[i].is_unsigned)
1529
+ v = UINT2NUM(*(unsigned short *)s->result.bind[i].buffer);
1530
+ else
1531
+ v = INT2NUM(*(short *)s->result.bind[i].buffer);
1532
+ break;
1533
+ case MYSQL_TYPE_INT24:
1534
+ case MYSQL_TYPE_LONG:
1535
+ if (s->result.bind[i].is_unsigned)
1536
+ v = UINT2NUM(*(unsigned int *)s->result.bind[i].buffer);
1537
+ else
1538
+ v = INT2NUM(*(int *)s->result.bind[i].buffer);
1539
+ break;
1540
+ case MYSQL_TYPE_LONGLONG:
1541
+ if (s->result.bind[i].is_unsigned)
1542
+ v = ULL2NUM(*(unsigned long long *)s->result.bind[i].buffer);
1543
+ else
1544
+ v = LL2NUM(*(long long *)s->result.bind[i].buffer);
1545
+ break;
1546
+ case MYSQL_TYPE_FLOAT:
1547
+ v = rb_float_new((double)(*(float *)s->result.bind[i].buffer));
1548
+ break;
1549
+ case MYSQL_TYPE_DOUBLE:
1550
+ v = rb_float_new(*(double *)s->result.bind[i].buffer);
1551
+ break;
1552
+ case MYSQL_TYPE_TIME:
1553
+ case MYSQL_TYPE_DATE:
1554
+ case MYSQL_TYPE_DATETIME:
1555
+ case MYSQL_TYPE_TIMESTAMP:
1556
+ t = (MYSQL_TIME *)s->result.bind[i].buffer;
1557
+ v = rb_obj_alloc(cMysqlTime);
1558
+ rb_funcall(v, rb_intern("initialize"), 8,
1559
+ INT2FIX(t->year), INT2FIX(t->month),
1560
+ INT2FIX(t->day), INT2FIX(t->hour),
1561
+ INT2FIX(t->minute), INT2FIX(t->second),
1562
+ (t->neg ? Qtrue : Qfalse),
1563
+ INT2FIX(t->second_part));
1564
+ break;
1565
+ case MYSQL_TYPE_DECIMAL:
1566
+ case MYSQL_TYPE_STRING:
1567
+ case MYSQL_TYPE_VAR_STRING:
1568
+ case MYSQL_TYPE_TINY_BLOB:
1569
+ case MYSQL_TYPE_BLOB:
1570
+ case MYSQL_TYPE_MEDIUM_BLOB:
1571
+ case MYSQL_TYPE_LONG_BLOB:
1572
+ #if MYSQL_VERSION_ID >= 50003
1573
+ case MYSQL_TYPE_NEWDECIMAL:
1574
+ case MYSQL_TYPE_BIT:
1575
+ #endif
1576
+ v = rb_tainted_str_new(s->result.bind[i].buffer, s->result.length[i]);
1577
+ break;
1578
+ default:
1579
+ rb_raise(rb_eTypeError, "unknown buffer_type: %d", s->result.bind[i].buffer_type);
1580
+ }
1581
+ rb_ary_push(ret, v);
1582
+ }
1583
+ }
1584
+ return ret;
1585
+ }
1586
+
1587
+ /* each {...} */
1588
+ static VALUE stmt_each(VALUE obj)
1589
+ {
1590
+ VALUE row;
1591
+ check_stmt_closed(obj);
1592
+ while ((row = stmt_fetch(obj)) != Qnil)
1593
+ rb_yield(row);
1594
+ return obj;
1595
+ }
1596
+
1597
+ /* field_count() */
1598
+ static VALUE stmt_field_count(VALUE obj)
1599
+ {
1600
+ struct mysql_stmt* s = DATA_PTR(obj);
1601
+ unsigned int n;
1602
+ check_stmt_closed(obj);
1603
+ n = mysql_stmt_field_count(s->stmt);
1604
+ return INT2NUM(n);
1605
+ }
1606
+
1607
+ /* free_result() */
1608
+ static VALUE stmt_free_result(VALUE obj)
1609
+ {
1610
+ struct mysql_stmt* s = DATA_PTR(obj);
1611
+ check_stmt_closed(obj);
1612
+ if (mysql_stmt_free_result(s->stmt))
1613
+ mysql_stmt_raise(s->stmt);
1614
+ return obj;
1615
+ }
1616
+
1617
+ /* insert_id() */
1618
+ static VALUE stmt_insert_id(VALUE obj)
1619
+ {
1620
+ struct mysql_stmt* s = DATA_PTR(obj);
1621
+ my_ulonglong n;
1622
+ check_stmt_closed(obj);
1623
+ n = mysql_stmt_insert_id(s->stmt);
1624
+ return ULL2NUM(n);
1625
+ }
1626
+
1627
+ /* num_rows() */
1628
+ static VALUE stmt_num_rows(VALUE obj)
1629
+ {
1630
+ struct mysql_stmt* s = DATA_PTR(obj);
1631
+ my_ulonglong n;
1632
+ check_stmt_closed(obj);
1633
+ n = mysql_stmt_num_rows(s->stmt);
1634
+ return INT2NUM(n);
1635
+ }
1636
+
1637
+ /* param_count() */
1638
+ static VALUE stmt_param_count(VALUE obj)
1639
+ {
1640
+ struct mysql_stmt* s = DATA_PTR(obj);
1641
+ unsigned long n;
1642
+ check_stmt_closed(obj);
1643
+ n = mysql_stmt_param_count(s->stmt);
1644
+ return INT2NUM(n);
1645
+ }
1646
+
1647
+ /* prepare(query) */
1648
+ static VALUE stmt_prepare(VALUE obj, VALUE query)
1649
+ {
1650
+ struct mysql_stmt* s = DATA_PTR(obj);
1651
+ int n;
1652
+ int i;
1653
+ MYSQL_FIELD *field;
1654
+
1655
+ free_mysqlstmt_memory(s);
1656
+ check_stmt_closed(obj);
1657
+ Check_Type(query, T_STRING);
1658
+ if (mysql_stmt_prepare(s->stmt, RSTRING_PTR(query), RSTRING_LEN(query)))
1659
+ mysql_stmt_raise(s->stmt);
1660
+
1661
+ n = mysql_stmt_param_count(s->stmt);
1662
+ s->param.n = n;
1663
+ s->param.bind = xmalloc(sizeof(s->param.bind[0]) * n);
1664
+ s->param.length = xmalloc(sizeof(s->param.length[0]) * n);
1665
+ s->param.buffer = xmalloc(sizeof(s->param.buffer[0]) * n);
1666
+
1667
+ s->res = mysql_stmt_result_metadata(s->stmt);
1668
+ if (s->res) {
1669
+ n = s->result.n = mysql_num_fields(s->res);
1670
+ s->result.bind = xmalloc(sizeof(s->result.bind[0]) * n);
1671
+ s->result.is_null = xmalloc(sizeof(s->result.is_null[0]) * n);
1672
+ s->result.length = xmalloc(sizeof(s->result.length[0]) * n);
1673
+ field = mysql_fetch_fields(s->res);
1674
+ memset(s->result.bind, 0, sizeof(s->result.bind[0]) * n);
1675
+ for (i = 0; i < n; i++) {
1676
+ s->result.bind[i].buffer_type = field[i].type;
1677
+ #if MYSQL_VERSION_ID < 50003
1678
+ if (field[i].type == MYSQL_TYPE_DECIMAL)
1679
+ s->result.bind[i].buffer_type = MYSQL_TYPE_STRING;
1680
+ #endif
1681
+ s->result.bind[i].is_null = &(s->result.is_null[i]);
1682
+ s->result.bind[i].length = &(s->result.length[i]);
1683
+ s->result.bind[i].is_unsigned = ((field[i].flags & UNSIGNED_FLAG) != 0);
1684
+ }
1685
+ } else {
1686
+ if (mysql_stmt_errno(s->stmt))
1687
+ mysql_stmt_raise(s->stmt);
1688
+ }
1689
+
1690
+ return obj;
1691
+ }
1692
+
1693
+ #if 0
1694
+ /* reset() */
1695
+ static VALUE stmt_reset(VALUE obj)
1696
+ {
1697
+ struct mysql_stmt* s = DATA_PTR(obj);
1698
+ check_stmt_closed(obj);
1699
+ if (mysql_stmt_reset(s->stmt))
1700
+ mysql_stmt_raise(s->stmt);
1701
+ return obj;
1702
+ }
1703
+ #endif
1704
+
1705
+ /* result_metadata() */
1706
+ static VALUE stmt_result_metadata(VALUE obj)
1707
+ {
1708
+ struct mysql_stmt* s = DATA_PTR(obj);
1709
+ MYSQL_RES *res;
1710
+ check_stmt_closed(obj);
1711
+ res = mysql_stmt_result_metadata(s->stmt);
1712
+ if (res == NULL) {
1713
+ if (mysql_stmt_errno(s->stmt) != 0)
1714
+ mysql_stmt_raise(s->stmt);
1715
+ return Qnil;
1716
+ }
1717
+ return mysqlres2obj(res);
1718
+ }
1719
+
1720
+ /* row_seek(offset) */
1721
+ static VALUE stmt_row_seek(VALUE obj, VALUE offset)
1722
+ {
1723
+ struct mysql_stmt* s = DATA_PTR(obj);
1724
+ MYSQL_ROW_OFFSET prev_offset;
1725
+ if (CLASS_OF(offset) != cMysqlRowOffset)
1726
+ rb_raise(rb_eTypeError, "wrong argument type %s (expected Mysql::RowOffset)", rb_obj_classname(offset));
1727
+ check_stmt_closed(obj);
1728
+ prev_offset = mysql_stmt_row_seek(s->stmt, DATA_PTR(offset));
1729
+ return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, prev_offset);
1730
+ }
1731
+
1732
+ /* row_tell() */
1733
+ static VALUE stmt_row_tell(VALUE obj)
1734
+ {
1735
+ struct mysql_stmt* s = DATA_PTR(obj);
1736
+ MYSQL_ROW_OFFSET offset;
1737
+ check_stmt_closed(obj);
1738
+ offset = mysql_stmt_row_tell(s->stmt);
1739
+ return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, offset);
1740
+ }
1741
+
1742
+ #if 0
1743
+ /* send_long_data(col, data) */
1744
+ static VALUE stmt_send_long_data(VALUE obj, VALUE col, VALUE data)
1745
+ {
1746
+ struct mysql_stmt* s = DATA_PTR(obj);
1747
+ int c;
1748
+ check_stmt_closed(obj);
1749
+ c = NUM2INT(col);
1750
+ if (0 <= c && c < s->param.n) {
1751
+ s->param.bind[c].buffer_type = MYSQL_TYPE_STRING;
1752
+ if (mysql_stmt_bind_param(s->stmt, s->param.bind))
1753
+ mysql_stmt_raise(s->stmt);
1754
+ }
1755
+ if (mysql_stmt_send_long_data(s->stmt, c, RSTRING_PTR(data), RSTRING_LEN(data)))
1756
+ mysql_stmt_raise(s->stmt);
1757
+ return obj;
1758
+ }
1759
+ #endif
1760
+
1761
+ /* sqlstate() */
1762
+ static VALUE stmt_sqlstate(VALUE obj)
1763
+ {
1764
+ struct mysql_stmt* s = DATA_PTR(obj);
1765
+ return rb_tainted_str_new2(mysql_stmt_sqlstate(s->stmt));
1766
+ }
1767
+
1768
+ /*-------------------------------
1769
+ * Mysql::Time object method
1770
+ */
1771
+
1772
+ static VALUE time_initialize(int argc, VALUE* argv, VALUE obj)
1773
+ {
1774
+ VALUE year, month, day, hour, minute, second, neg, second_part;
1775
+ rb_scan_args(argc, argv, "08", &year, &month, &day, &hour, &minute, &second, &neg, &second_part);
1776
+ #define NILorFIXvalue(o) (NIL_P(o) ? INT2FIX(0) : (Check_Type(o, T_FIXNUM), o))
1777
+ rb_iv_set(obj, "year", NILorFIXvalue(year));
1778
+ rb_iv_set(obj, "month", NILorFIXvalue(month));
1779
+ rb_iv_set(obj, "day", NILorFIXvalue(day));
1780
+ rb_iv_set(obj, "hour", NILorFIXvalue(hour));
1781
+ rb_iv_set(obj, "minute", NILorFIXvalue(minute));
1782
+ rb_iv_set(obj, "second", NILorFIXvalue(second));
1783
+ rb_iv_set(obj, "neg", (neg == Qnil || neg == Qfalse) ? Qfalse : Qtrue);
1784
+ rb_iv_set(obj, "second_part", NILorFIXvalue(second_part));
1785
+ return obj;
1786
+ }
1787
+
1788
+ static VALUE time_inspect(VALUE obj)
1789
+ {
1790
+ char buf[36];
1791
+ sprintf(buf, "#<Mysql::Time:%04d-%02d-%02d %02d:%02d:%02d>",
1792
+ NUM2INT(rb_iv_get(obj, "year")),
1793
+ NUM2INT(rb_iv_get(obj, "month")),
1794
+ NUM2INT(rb_iv_get(obj, "day")),
1795
+ NUM2INT(rb_iv_get(obj, "hour")),
1796
+ NUM2INT(rb_iv_get(obj, "minute")),
1797
+ NUM2INT(rb_iv_get(obj, "second")));
1798
+ return rb_str_new2(buf);
1799
+ }
1800
+
1801
+ static VALUE time_to_s(VALUE obj)
1802
+ {
1803
+ char buf[20];
1804
+ sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d",
1805
+ NUM2INT(rb_iv_get(obj, "year")),
1806
+ NUM2INT(rb_iv_get(obj, "month")),
1807
+ NUM2INT(rb_iv_get(obj, "day")),
1808
+ NUM2INT(rb_iv_get(obj, "hour")),
1809
+ NUM2INT(rb_iv_get(obj, "minute")),
1810
+ NUM2INT(rb_iv_get(obj, "second")));
1811
+ return rb_str_new2(buf);
1812
+ }
1813
+
1814
+ #define DefineMysqlTimeGetMethod(m)\
1815
+ static VALUE time_get_##m(VALUE obj)\
1816
+ {return rb_iv_get(obj, #m);}
1817
+
1818
+ DefineMysqlTimeGetMethod(year)
1819
+ DefineMysqlTimeGetMethod(month)
1820
+ DefineMysqlTimeGetMethod(day)
1821
+ DefineMysqlTimeGetMethod(hour)
1822
+ DefineMysqlTimeGetMethod(minute)
1823
+ DefineMysqlTimeGetMethod(second)
1824
+ DefineMysqlTimeGetMethod(neg)
1825
+ DefineMysqlTimeGetMethod(second_part)
1826
+
1827
+ #define DefineMysqlTimeSetMethod(m)\
1828
+ static VALUE time_set_##m(VALUE obj, VALUE v)\
1829
+ {rb_iv_set(obj, #m, NILorFIXvalue(v)); return v;}
1830
+
1831
+ DefineMysqlTimeSetMethod(year)
1832
+ DefineMysqlTimeSetMethod(month)
1833
+ DefineMysqlTimeSetMethod(day)
1834
+ DefineMysqlTimeSetMethod(hour)
1835
+ DefineMysqlTimeSetMethod(minute)
1836
+ DefineMysqlTimeSetMethod(second)
1837
+ DefineMysqlTimeSetMethod(second_part)
1838
+
1839
+ static VALUE time_set_neg(VALUE obj, VALUE v)
1840
+ {
1841
+ rb_iv_set(obj, "neg", (v == Qnil || v == Qfalse) ? Qfalse : Qtrue);
1842
+ return v;
1843
+ }
1844
+
1845
+ static VALUE time_equal(VALUE obj, VALUE v)
1846
+ {
1847
+ if (CLASS_OF(v) == cMysqlTime &&
1848
+ NUM2INT(rb_iv_get(obj, "year")) == NUM2INT(rb_iv_get(v, "year")) &&
1849
+ NUM2INT(rb_iv_get(obj, "month")) == NUM2INT(rb_iv_get(v, "month")) &&
1850
+ NUM2INT(rb_iv_get(obj, "day")) == NUM2INT(rb_iv_get(v, "day")) &&
1851
+ NUM2INT(rb_iv_get(obj, "hour")) == NUM2INT(rb_iv_get(v, "hour")) &&
1852
+ NUM2INT(rb_iv_get(obj, "minute")) == NUM2INT(rb_iv_get(v, "minute")) &&
1853
+ NUM2INT(rb_iv_get(obj, "second")) == NUM2INT(rb_iv_get(v, "second")) &&
1854
+ rb_iv_get(obj, "neg") == rb_iv_get(v, "neg") &&
1855
+ NUM2INT(rb_iv_get(obj, "second_part")) == NUM2INT(rb_iv_get(v, "second_part")))
1856
+ return Qtrue;
1857
+ return Qfalse;
1858
+ }
1859
+
1860
+ #endif
1861
+
1862
+ /*-------------------------------
1863
+ * Mysql::Error object method
1864
+ */
1865
+
1866
+ static VALUE error_error(VALUE obj)
1867
+ {
1868
+ return rb_iv_get(obj, "mesg");
1869
+ }
1870
+
1871
+ static VALUE error_errno(VALUE obj)
1872
+ {
1873
+ return rb_iv_get(obj, "errno");
1874
+ }
1875
+
1876
+ static VALUE error_sqlstate(VALUE obj)
1877
+ {
1878
+ return rb_iv_get(obj, "sqlstate");
1879
+ }
1880
+
1881
+ /*-------------------------------
1882
+ * Initialize
1883
+ */
1884
+
1885
+ void Init_mysql_api(void)
1886
+ {
1887
+ int i;
1888
+ int dots = 0;
1889
+ const char *lib = mysql_get_client_info();
1890
+ for (i = 0; lib[i] != 0 && MYSQL_SERVER_VERSION[i] != 0; i++) {
1891
+ if (lib[i] == '.') {
1892
+ dots++;
1893
+ // we only compare MAJOR and MINOR
1894
+ if (dots == 2) break;
1895
+ }
1896
+ if (lib[i] != MYSQL_SERVER_VERSION[i]) {
1897
+ rb_raise(rb_eRuntimeError, "Incorrect MySQL client library version! This gem was compiled for %s but the client library is %s.", MYSQL_SERVER_VERSION, lib);
1898
+ return;
1899
+ }
1900
+ }
1901
+
1902
+ cMysql = rb_define_class("Mysql", rb_cObject);
1903
+ cMysqlRes = rb_define_class_under(cMysql, "Result", rb_cObject);
1904
+ cMysqlField = rb_define_class_under(cMysql, "Field", rb_cObject);
1905
+ #if MYSQL_VERSION_ID >= 40102
1906
+ cMysqlStmt = rb_define_class_under(cMysql, "Stmt", rb_cObject);
1907
+ cMysqlRowOffset = rb_define_class_under(cMysql, "RowOffset", rb_cObject);
1908
+ cMysqlTime = rb_define_class_under(cMysql, "Time", rb_cObject);
1909
+ #endif
1910
+ eMysql = rb_define_class_under(cMysql, "Error", rb_eStandardError);
1911
+
1912
+ rb_define_global_const("MysqlRes", cMysqlRes);
1913
+ rb_define_global_const("MysqlField", cMysqlField);
1914
+ rb_define_global_const("MysqlError", eMysql);
1915
+
1916
+ /* Mysql class method */
1917
+ rb_define_singleton_method(cMysql, "init", init, 0);
1918
+ rb_define_singleton_method(cMysql, "real_connect", real_connect, -1);
1919
+ rb_define_singleton_method(cMysql, "connect", real_connect, -1);
1920
+ rb_define_singleton_method(cMysql, "new", real_connect, -1);
1921
+ rb_define_singleton_method(cMysql, "escape_string", escape_string, 1);
1922
+ rb_define_singleton_method(cMysql, "quote", escape_string, 1);
1923
+ rb_define_singleton_method(cMysql, "client_info", client_info, 0);
1924
+ rb_define_singleton_method(cMysql, "get_client_info", client_info, 0);
1925
+ #if MYSQL_VERSION_ID >= 32332
1926
+ rb_define_singleton_method(cMysql, "debug", my_debug, 1);
1927
+ #endif
1928
+ #if MYSQL_VERSION_ID >= 40000
1929
+ rb_define_singleton_method(cMysql, "get_client_version", client_version, 0);
1930
+ rb_define_singleton_method(cMysql, "client_version", client_version, 0);
1931
+ #endif
1932
+
1933
+ /* Mysql object method */
1934
+ #if MYSQL_VERSION_ID >= 32200
1935
+ rb_define_method(cMysql, "real_connect", real_connect2, -1);
1936
+ rb_define_method(cMysql, "connect", real_connect2, -1);
1937
+ rb_define_method(cMysql, "options", options, -1);
1938
+ #endif
1939
+ rb_define_method(cMysql, "initialize", initialize, -1);
1940
+ #if MYSQL_VERSION_ID >= 32332
1941
+ rb_define_method(cMysql, "escape_string", real_escape_string, 1);
1942
+ rb_define_method(cMysql, "quote", real_escape_string, 1);
1943
+ #else
1944
+ rb_define_method(cMysql, "escape_string", escape_string, 1);
1945
+ rb_define_method(cMysql, "quote", escape_string, 1);
1946
+ #endif
1947
+ rb_define_method(cMysql, "client_info", client_info, 0);
1948
+ rb_define_method(cMysql, "get_client_info", client_info, 0);
1949
+ rb_define_method(cMysql, "affected_rows", affected_rows, 0);
1950
+ #if MYSQL_VERSION_ID >= 32303
1951
+ rb_define_method(cMysql, "change_user", change_user, -1);
1952
+ #endif
1953
+ #if MYSQL_VERSION_ID >= 32321
1954
+ rb_define_method(cMysql, "character_set_name", character_set_name, 0);
1955
+ #endif
1956
+ rb_define_method(cMysql, "close", my_close, 0);
1957
+ #if MYSQL_VERSION_ID < 40000
1958
+ rb_define_method(cMysql, "create_db", create_db, 1);
1959
+ rb_define_method(cMysql, "drop_db", drop_db, 1);
1960
+ #endif
1961
+ #if MYSQL_VERSION_ID >= 32332
1962
+ rb_define_method(cMysql, "dump_debug_info", dump_debug_info, 0);
1963
+ #endif
1964
+ rb_define_method(cMysql, "errno", my_errno, 0);
1965
+ rb_define_method(cMysql, "error", my_error, 0);
1966
+ rb_define_method(cMysql, "field_count", field_count, 0);
1967
+ #if MYSQL_VERSION_ID >= 40000
1968
+ rb_define_method(cMysql, "get_client_version", client_version, 0);
1969
+ rb_define_method(cMysql, "client_version", client_version, 0);
1970
+ #endif
1971
+ rb_define_method(cMysql, "get_host_info", host_info, 0);
1972
+ rb_define_method(cMysql, "host_info", host_info, 0);
1973
+ rb_define_method(cMysql, "get_proto_info", proto_info, 0);
1974
+ rb_define_method(cMysql, "proto_info", proto_info, 0);
1975
+ rb_define_method(cMysql, "get_server_info", server_info, 0);
1976
+ rb_define_method(cMysql, "server_info", server_info, 0);
1977
+ rb_define_method(cMysql, "info", info, 0);
1978
+ rb_define_method(cMysql, "insert_id", insert_id, 0);
1979
+ rb_define_method(cMysql, "kill", my_kill, 1);
1980
+ rb_define_method(cMysql, "list_dbs", list_dbs, -1);
1981
+ rb_define_method(cMysql, "list_fields", list_fields, -1);
1982
+ rb_define_method(cMysql, "list_processes", list_processes, 0);
1983
+ rb_define_method(cMysql, "list_tables", list_tables, -1);
1984
+ #if MYSQL_VERSION_ID >= 32200
1985
+ rb_define_method(cMysql, "ping", ping, 0);
1986
+ #endif
1987
+ rb_define_method(cMysql, "query", query, 1);
1988
+ rb_define_method(cMysql, "real_query", query, 1);
1989
+ rb_define_method(cMysql, "refresh", refresh, 1);
1990
+ rb_define_method(cMysql, "reload", reload, 0);
1991
+ rb_define_method(cMysql, "select_db", select_db, 1);
1992
+ rb_define_method(cMysql, "shutdown", my_shutdown, -1);
1993
+ rb_define_method(cMysql, "stat", my_stat, 0);
1994
+ rb_define_method(cMysql, "store_result", store_result, 0);
1995
+ rb_define_method(cMysql, "thread_id", thread_id, 0);
1996
+ rb_define_method(cMysql, "use_result", use_result, 0);
1997
+ #if MYSQL_VERSION_ID >= 40100
1998
+ rb_define_method(cMysql, "get_server_version", server_version, 0);
1999
+ rb_define_method(cMysql, "server_version", server_version, 0);
2000
+ rb_define_method(cMysql, "warning_count", warning_count, 0);
2001
+ rb_define_method(cMysql, "commit", commit, 0);
2002
+ rb_define_method(cMysql, "rollback", rollback, 0);
2003
+ rb_define_method(cMysql, "autocommit", autocommit, 1);
2004
+ #endif
2005
+ #ifdef HAVE_MYSQL_SSL_SET
2006
+ rb_define_method(cMysql, "ssl_set", ssl_set, -1);
2007
+ #endif
2008
+ #if MYSQL_VERSION_ID >= 40102
2009
+ rb_define_method(cMysql, "stmt_init", stmt_init, 0);
2010
+ rb_define_method(cMysql, "prepare", prepare, 1);
2011
+ #endif
2012
+ #if MYSQL_VERSION_ID >= 40100
2013
+ rb_define_method(cMysql, "more_results", more_results, 0);
2014
+ rb_define_method(cMysql, "more_results?", more_results, 0);
2015
+ rb_define_method(cMysql, "next_result", next_result, 0);
2016
+ #endif
2017
+ #if MYSQL_VERSION_ID >= 40101
2018
+ rb_define_method(cMysql, "set_server_option", set_server_option, 1);
2019
+ rb_define_method(cMysql, "sqlstate", sqlstate, 0);
2020
+ #endif
2021
+ rb_define_method(cMysql, "query_with_result", query_with_result, 0);
2022
+ rb_define_method(cMysql, "query_with_result=", query_with_result_set, 1);
2023
+
2024
+ rb_define_method(cMysql, "reconnect", reconnect, 0);
2025
+ rb_define_method(cMysql, "reconnect=", reconnect_set, 1);
2026
+
2027
+ /* Mysql constant */
2028
+ rb_define_const(cMysql, "VERSION", INT2FIX(MYSQL_RUBY_VERSION));
2029
+ #if MYSQL_VERSION_ID >= 32200
2030
+ rb_define_const(cMysql, "OPT_CONNECT_TIMEOUT", INT2NUM(MYSQL_OPT_CONNECT_TIMEOUT));
2031
+ rb_define_const(cMysql, "OPT_COMPRESS", INT2NUM(MYSQL_OPT_COMPRESS));
2032
+ rb_define_const(cMysql, "OPT_NAMED_PIPE", INT2NUM(MYSQL_OPT_NAMED_PIPE));
2033
+ rb_define_const(cMysql, "INIT_COMMAND", INT2NUM(MYSQL_INIT_COMMAND));
2034
+ rb_define_const(cMysql, "READ_DEFAULT_FILE", INT2NUM(MYSQL_READ_DEFAULT_FILE));
2035
+ rb_define_const(cMysql, "READ_DEFAULT_GROUP", INT2NUM(MYSQL_READ_DEFAULT_GROUP));
2036
+ #endif
2037
+ #if MYSQL_VERSION_ID >= 32349
2038
+ rb_define_const(cMysql, "SET_CHARSET_DIR", INT2NUM(MYSQL_SET_CHARSET_DIR));
2039
+ rb_define_const(cMysql, "SET_CHARSET_NAME", INT2NUM(MYSQL_SET_CHARSET_NAME));
2040
+ rb_define_const(cMysql, "OPT_LOCAL_INFILE", INT2NUM(MYSQL_OPT_LOCAL_INFILE));
2041
+ #endif
2042
+ #if MYSQL_VERSION_ID >= 40100
2043
+ rb_define_const(cMysql, "OPT_PROTOCOL", INT2NUM(MYSQL_OPT_PROTOCOL));
2044
+ rb_define_const(cMysql, "SHARED_MEMORY_BASE_NAME", INT2NUM(MYSQL_SHARED_MEMORY_BASE_NAME));
2045
+ #endif
2046
+ #if MYSQL_VERSION_ID >= 40101
2047
+ rb_define_const(cMysql, "OPT_READ_TIMEOUT", INT2NUM(MYSQL_OPT_READ_TIMEOUT));
2048
+ rb_define_const(cMysql, "OPT_WRITE_TIMEOUT", INT2NUM(MYSQL_OPT_WRITE_TIMEOUT));
2049
+ rb_define_const(cMysql, "SECURE_AUTH", INT2NUM(MYSQL_SECURE_AUTH));
2050
+ rb_define_const(cMysql, "OPT_GUESS_CONNECTION", INT2NUM(MYSQL_OPT_GUESS_CONNECTION));
2051
+ rb_define_const(cMysql, "OPT_USE_EMBEDDED_CONNECTION", INT2NUM(MYSQL_OPT_USE_EMBEDDED_CONNECTION));
2052
+ rb_define_const(cMysql, "OPT_USE_REMOTE_CONNECTION", INT2NUM(MYSQL_OPT_USE_REMOTE_CONNECTION));
2053
+ rb_define_const(cMysql, "SET_CLIENT_IP", INT2NUM(MYSQL_SET_CLIENT_IP));
2054
+ #endif
2055
+ rb_define_const(cMysql, "REFRESH_GRANT", INT2NUM(REFRESH_GRANT));
2056
+ rb_define_const(cMysql, "REFRESH_LOG", INT2NUM(REFRESH_LOG));
2057
+ rb_define_const(cMysql, "REFRESH_TABLES", INT2NUM(REFRESH_TABLES));
2058
+ #ifdef REFRESH_HOSTS
2059
+ rb_define_const(cMysql, "REFRESH_HOSTS", INT2NUM(REFRESH_HOSTS));
2060
+ #endif
2061
+ #ifdef REFRESH_STATUS
2062
+ rb_define_const(cMysql, "REFRESH_STATUS", INT2NUM(REFRESH_STATUS));
2063
+ #endif
2064
+ #ifdef REFRESH_THREADS
2065
+ rb_define_const(cMysql, "REFRESH_THREADS", INT2NUM(REFRESH_THREADS));
2066
+ #endif
2067
+ #ifdef REFRESH_SLAVE
2068
+ rb_define_const(cMysql, "REFRESH_SLAVE", INT2NUM(REFRESH_SLAVE));
2069
+ #endif
2070
+ #ifdef REFRESH_MASTER
2071
+ rb_define_const(cMysql, "REFRESH_MASTER", INT2NUM(REFRESH_MASTER));
2072
+ #endif
2073
+ #ifdef CLIENT_LONG_PASSWORD
2074
+ #endif
2075
+ #ifdef CLIENT_FOUND_ROWS
2076
+ rb_define_const(cMysql, "CLIENT_FOUND_ROWS", INT2NUM(CLIENT_FOUND_ROWS));
2077
+ #endif
2078
+ #ifdef CLIENT_LONG_FLAG
2079
+ #endif
2080
+ #ifdef CLIENT_CONNECT_WITH_DB
2081
+ #endif
2082
+ #ifdef CLIENT_NO_SCHEMA
2083
+ rb_define_const(cMysql, "CLIENT_NO_SCHEMA", INT2NUM(CLIENT_NO_SCHEMA));
2084
+ #endif
2085
+ #ifdef CLIENT_COMPRESS
2086
+ rb_define_const(cMysql, "CLIENT_COMPRESS", INT2NUM(CLIENT_COMPRESS));
2087
+ #endif
2088
+ #ifdef CLIENT_ODBC
2089
+ rb_define_const(cMysql, "CLIENT_ODBC", INT2NUM(CLIENT_ODBC));
2090
+ #endif
2091
+ #ifdef CLIENT_LOCAL_FILES
2092
+ rb_define_const(cMysql, "CLIENT_LOCAL_FILES", INT2NUM(CLIENT_LOCAL_FILES));
2093
+ #endif
2094
+ #ifdef CLIENT_IGNORE_SPACE
2095
+ rb_define_const(cMysql, "CLIENT_IGNORE_SPACE", INT2NUM(CLIENT_IGNORE_SPACE));
2096
+ #endif
2097
+ #ifdef CLIENT_CHANGE_USER
2098
+ rb_define_const(cMysql, "CLIENT_CHANGE_USER", INT2NUM(CLIENT_CHANGE_USER));
2099
+ #endif
2100
+ #ifdef CLIENT_INTERACTIVE
2101
+ rb_define_const(cMysql, "CLIENT_INTERACTIVE", INT2NUM(CLIENT_INTERACTIVE));
2102
+ #endif
2103
+ #ifdef CLIENT_SSL
2104
+ rb_define_const(cMysql, "CLIENT_SSL", INT2NUM(CLIENT_SSL));
2105
+ #endif
2106
+ #ifdef CLIENT_IGNORE_SIGPIPE
2107
+ rb_define_const(cMysql, "CLIENT_IGNORE_SIGPIPE", INT2NUM(CLIENT_IGNORE_SIGPIPE));
2108
+ #endif
2109
+ #ifdef CLIENT_TRANSACTIONS
2110
+ rb_define_const(cMysql, "CLIENT_TRANSACTIONS", INT2NUM(CLIENT_TRANSACTIONS));
2111
+ #endif
2112
+ #ifdef CLIENT_MULTI_STATEMENTS
2113
+ rb_define_const(cMysql, "CLIENT_MULTI_STATEMENTS", INT2NUM(CLIENT_MULTI_STATEMENTS));
2114
+ #endif
2115
+ #ifdef CLIENT_MULTI_RESULTS
2116
+ rb_define_const(cMysql, "CLIENT_MULTI_RESULTS", INT2NUM(CLIENT_MULTI_RESULTS));
2117
+ #endif
2118
+ #if MYSQL_VERSION_ID >= 40101
2119
+ rb_define_const(cMysql, "OPTION_MULTI_STATEMENTS_ON", INT2NUM(MYSQL_OPTION_MULTI_STATEMENTS_ON));
2120
+ rb_define_const(cMysql, "OPTION_MULTI_STATEMENTS_OFF", INT2NUM(MYSQL_OPTION_MULTI_STATEMENTS_OFF));
2121
+ #endif
2122
+
2123
+ /* Mysql::Result object method */
2124
+ rb_define_method(cMysqlRes, "data_seek", data_seek, 1);
2125
+ rb_define_method(cMysqlRes, "fetch_field", fetch_field, 0);
2126
+ rb_define_method(cMysqlRes, "fetch_fields", fetch_fields, 0);
2127
+ rb_define_method(cMysqlRes, "fetch_field_direct", fetch_field_direct, 1);
2128
+ rb_define_method(cMysqlRes, "fetch_lengths", fetch_lengths, 0);
2129
+ rb_define_method(cMysqlRes, "fetch_row", fetch_row, 0);
2130
+ rb_define_method(cMysqlRes, "fetch_hash", fetch_hash, -1);
2131
+ rb_define_method(cMysqlRes, "field_seek", field_seek, 1);
2132
+ rb_define_method(cMysqlRes, "field_tell", field_tell, 0);
2133
+ rb_define_method(cMysqlRes, "free", res_free, 0);
2134
+ rb_define_method(cMysqlRes, "num_fields", num_fields, 0);
2135
+ rb_define_method(cMysqlRes, "num_rows", num_rows, 0);
2136
+ rb_define_method(cMysqlRes, "row_seek", row_seek, 1);
2137
+ rb_define_method(cMysqlRes, "row_tell", row_tell, 0);
2138
+ rb_define_method(cMysqlRes, "each", each, 0);
2139
+ rb_define_method(cMysqlRes, "each_hash", each_hash, -1);
2140
+
2141
+ /* MysqlField object method */
2142
+ rb_define_method(cMysqlField, "name", field_name, 0);
2143
+ rb_define_method(cMysqlField, "table", field_table, 0);
2144
+ rb_define_method(cMysqlField, "def", field_def, 0);
2145
+ rb_define_method(cMysqlField, "type", field_type, 0);
2146
+ rb_define_method(cMysqlField, "length", field_length, 0);
2147
+ rb_define_method(cMysqlField, "max_length", field_max_length, 0);
2148
+ rb_define_method(cMysqlField, "flags", field_flags, 0);
2149
+ rb_define_method(cMysqlField, "decimals", field_decimals, 0);
2150
+ rb_define_method(cMysqlField, "hash", field_hash, 0);
2151
+ rb_define_method(cMysqlField, "inspect", field_inspect, 0);
2152
+ #ifdef IS_NUM
2153
+ rb_define_method(cMysqlField, "is_num?", field_is_num, 0);
2154
+ #endif
2155
+ #ifdef IS_NOT_NULL
2156
+ rb_define_method(cMysqlField, "is_not_null?", field_is_not_null, 0);
2157
+ #endif
2158
+ #ifdef IS_PRI_KEY
2159
+ rb_define_method(cMysqlField, "is_pri_key?", field_is_pri_key, 0);
2160
+ #endif
2161
+
2162
+ /* Mysql::Field constant: TYPE */
2163
+ rb_define_const(cMysqlField, "TYPE_TINY", INT2NUM(FIELD_TYPE_TINY));
2164
+ #if MYSQL_VERSION_ID >= 32115
2165
+ rb_define_const(cMysqlField, "TYPE_ENUM", INT2NUM(FIELD_TYPE_ENUM));
2166
+ #endif
2167
+ rb_define_const(cMysqlField, "TYPE_DECIMAL", INT2NUM(FIELD_TYPE_DECIMAL));
2168
+ rb_define_const(cMysqlField, "TYPE_SHORT", INT2NUM(FIELD_TYPE_SHORT));
2169
+ rb_define_const(cMysqlField, "TYPE_LONG", INT2NUM(FIELD_TYPE_LONG));
2170
+ rb_define_const(cMysqlField, "TYPE_FLOAT", INT2NUM(FIELD_TYPE_FLOAT));
2171
+ rb_define_const(cMysqlField, "TYPE_DOUBLE", INT2NUM(FIELD_TYPE_DOUBLE));
2172
+ rb_define_const(cMysqlField, "TYPE_NULL", INT2NUM(FIELD_TYPE_NULL));
2173
+ rb_define_const(cMysqlField, "TYPE_TIMESTAMP", INT2NUM(FIELD_TYPE_TIMESTAMP));
2174
+ rb_define_const(cMysqlField, "TYPE_LONGLONG", INT2NUM(FIELD_TYPE_LONGLONG));
2175
+ rb_define_const(cMysqlField, "TYPE_INT24", INT2NUM(FIELD_TYPE_INT24));
2176
+ rb_define_const(cMysqlField, "TYPE_DATE", INT2NUM(FIELD_TYPE_DATE));
2177
+ rb_define_const(cMysqlField, "TYPE_TIME", INT2NUM(FIELD_TYPE_TIME));
2178
+ rb_define_const(cMysqlField, "TYPE_DATETIME", INT2NUM(FIELD_TYPE_DATETIME));
2179
+ #if MYSQL_VERSION_ID >= 32130
2180
+ rb_define_const(cMysqlField, "TYPE_YEAR", INT2NUM(FIELD_TYPE_YEAR));
2181
+ #endif
2182
+ #if MYSQL_VERSION_ID >= 50003
2183
+ rb_define_const(cMysqlField, "TYPE_BIT", INT2NUM(FIELD_TYPE_BIT));
2184
+ rb_define_const(cMysqlField, "TYPE_NEWDECIMAL", INT2NUM(FIELD_TYPE_NEWDECIMAL));
2185
+ #endif
2186
+ rb_define_const(cMysqlField, "TYPE_SET", INT2NUM(FIELD_TYPE_SET));
2187
+ rb_define_const(cMysqlField, "TYPE_BLOB", INT2NUM(FIELD_TYPE_BLOB));
2188
+ rb_define_const(cMysqlField, "TYPE_STRING", INT2NUM(FIELD_TYPE_STRING));
2189
+ #if MYSQL_VERSION_ID >= 40000
2190
+ rb_define_const(cMysqlField, "TYPE_VAR_STRING", INT2NUM(FIELD_TYPE_VAR_STRING));
2191
+ #endif
2192
+ rb_define_const(cMysqlField, "TYPE_CHAR", INT2NUM(FIELD_TYPE_CHAR));
2193
+
2194
+ /* Mysql::Field constant: FLAG */
2195
+ rb_define_const(cMysqlField, "NOT_NULL_FLAG", INT2NUM(NOT_NULL_FLAG));
2196
+ rb_define_const(cMysqlField, "PRI_KEY_FLAG", INT2NUM(PRI_KEY_FLAG));
2197
+ rb_define_const(cMysqlField, "UNIQUE_KEY_FLAG", INT2NUM(UNIQUE_KEY_FLAG));
2198
+ rb_define_const(cMysqlField, "MULTIPLE_KEY_FLAG", INT2NUM(MULTIPLE_KEY_FLAG));
2199
+ rb_define_const(cMysqlField, "BLOB_FLAG", INT2NUM(BLOB_FLAG));
2200
+ rb_define_const(cMysqlField, "UNSIGNED_FLAG", INT2NUM(UNSIGNED_FLAG));
2201
+ rb_define_const(cMysqlField, "ZEROFILL_FLAG", INT2NUM(ZEROFILL_FLAG));
2202
+ rb_define_const(cMysqlField, "BINARY_FLAG", INT2NUM(BINARY_FLAG));
2203
+ #ifdef ENUM_FLAG
2204
+ rb_define_const(cMysqlField, "ENUM_FLAG", INT2NUM(ENUM_FLAG));
2205
+ #endif
2206
+ #ifdef AUTO_INCREMENT_FLAG
2207
+ rb_define_const(cMysqlField, "AUTO_INCREMENT_FLAG", INT2NUM(AUTO_INCREMENT_FLAG));
2208
+ #endif
2209
+ #ifdef TIMESTAMP_FLAG
2210
+ rb_define_const(cMysqlField, "TIMESTAMP_FLAG", INT2NUM(TIMESTAMP_FLAG));
2211
+ #endif
2212
+ #ifdef SET_FLAG
2213
+ rb_define_const(cMysqlField, "SET_FLAG", INT2NUM(SET_FLAG));
2214
+ #endif
2215
+ #ifdef NUM_FLAG
2216
+ rb_define_const(cMysqlField, "NUM_FLAG", INT2NUM(NUM_FLAG));
2217
+ #endif
2218
+ #ifdef PART_KEY_FLAG
2219
+ rb_define_const(cMysqlField, "PART_KEY_FLAG", INT2NUM(PART_KEY_FLAG));
2220
+ #endif
2221
+
2222
+ #if MYSQL_VERSION_ID >= 40102
2223
+ /* Mysql::Stmt object method */
2224
+ rb_define_method(cMysqlStmt, "affected_rows", stmt_affected_rows, 0);
2225
+ #if 0
2226
+ rb_define_method(cMysqlStmt, "attr_get", stmt_attr_get, 1);
2227
+ rb_define_method(cMysqlStmt, "attr_set", stmt_attr_set, 2);
2228
+ #endif
2229
+ rb_define_method(cMysqlStmt, "bind_result", stmt_bind_result, -1);
2230
+ rb_define_method(cMysqlStmt, "close", stmt_close, 0);
2231
+ rb_define_method(cMysqlStmt, "data_seek", stmt_data_seek, 1);
2232
+ rb_define_method(cMysqlStmt, "each", stmt_each, 0);
2233
+ rb_define_method(cMysqlStmt, "execute", stmt_execute, -1);
2234
+ rb_define_method(cMysqlStmt, "fetch", stmt_fetch, 0);
2235
+ rb_define_method(cMysqlStmt, "field_count", stmt_field_count, 0);
2236
+ rb_define_method(cMysqlStmt, "free_result", stmt_free_result, 0);
2237
+ rb_define_method(cMysqlStmt, "insert_id", stmt_insert_id, 0);
2238
+ rb_define_method(cMysqlStmt, "num_rows", stmt_num_rows, 0);
2239
+ rb_define_method(cMysqlStmt, "param_count", stmt_param_count, 0);
2240
+ rb_define_method(cMysqlStmt, "prepare", stmt_prepare, 1);
2241
+ #if 0
2242
+ rb_define_method(cMysqlStmt, "reset", stmt_reset, 0);
2243
+ #endif
2244
+ rb_define_method(cMysqlStmt, "result_metadata", stmt_result_metadata, 0);
2245
+ rb_define_method(cMysqlStmt, "row_seek", stmt_row_seek, 1);
2246
+ rb_define_method(cMysqlStmt, "row_tell", stmt_row_tell, 0);
2247
+ #if 0
2248
+ rb_define_method(cMysqlStmt, "send_long_data", stmt_send_long_data, 2);
2249
+ #endif
2250
+ rb_define_method(cMysqlStmt, "sqlstate", stmt_sqlstate, 0);
2251
+
2252
+ #if 0
2253
+ rb_define_const(cMysqlStmt, "ATTR_UPDATE_MAX_LENGTH", INT2NUM(STMT_ATTR_UPDATE_MAX_LENGTH));
2254
+ #endif
2255
+
2256
+ /* Mysql::Time object method */
2257
+ rb_define_method(cMysqlTime, "initialize", time_initialize, -1);
2258
+ rb_define_method(cMysqlTime, "inspect", time_inspect, 0);
2259
+ rb_define_method(cMysqlTime, "to_s", time_to_s, 0);
2260
+ rb_define_method(cMysqlTime, "year", time_get_year, 0);
2261
+ rb_define_method(cMysqlTime, "month", time_get_month, 0);
2262
+ rb_define_method(cMysqlTime, "day", time_get_day, 0);
2263
+ rb_define_method(cMysqlTime, "hour", time_get_hour, 0);
2264
+ rb_define_method(cMysqlTime, "minute", time_get_minute, 0);
2265
+ rb_define_method(cMysqlTime, "second", time_get_second, 0);
2266
+ rb_define_method(cMysqlTime, "neg", time_get_neg, 0);
2267
+ rb_define_method(cMysqlTime, "second_part", time_get_second_part, 0);
2268
+ rb_define_method(cMysqlTime, "year=", time_set_year, 1);
2269
+ rb_define_method(cMysqlTime, "month=", time_set_month, 1);
2270
+ rb_define_method(cMysqlTime, "day=", time_set_day, 1);
2271
+ rb_define_method(cMysqlTime, "hour=", time_set_hour, 1);
2272
+ rb_define_method(cMysqlTime, "minute=", time_set_minute, 1);
2273
+ rb_define_method(cMysqlTime, "second=", time_set_second, 1);
2274
+ rb_define_method(cMysqlTime, "neg=", time_set_neg, 1);
2275
+ rb_define_method(cMysqlTime, "second_part=", time_set_second_part, 1);
2276
+ rb_define_method(cMysqlTime, "==", time_equal, 1);
2277
+
2278
+ #endif
2279
+
2280
+ /* Mysql::Error object method */
2281
+ rb_define_method(eMysql, "error", error_error, 0);
2282
+ rb_define_method(eMysql, "errno", error_errno, 0);
2283
+ rb_define_method(eMysql, "sqlstate", error_sqlstate, 0);
2284
+
2285
+ /* Mysql::Error constant */
2286
+ #define rb_define_mysql_const(s) rb_define_const(eMysql, #s, INT2NUM(s))
2287
+ #include "error_const.h"
2288
+ }