mysql 2.6 → 2.7

data/mysql.c.in

@@ -1,5 +1,5 @@
 /*	ruby mysql module
- *	$Id: mysql.c.in,v 1.16 2005/04/19 14:20:03 tommy Exp $
+ *	$Id: mysql.c.in,v 1.30 2005/08/21 15:15:38 tommy Exp $
  */
 
 #include "ruby.h"
@@ -14,6 +14,8 @@
 #include <mysql/mysqld_error.h>
 #endif
 
+#define MYSQL_RUBY_VERSION 20700
+
 #define GC_STORE_RESULT_LIMIT 20
 
 #ifndef Qtrue		/* ruby 1.2.x ? */
@@ -42,10 +44,14 @@
 #define GetMysqlStruct(obj)	(Check_Type(obj, T_DATA), (struct mysql*)DATA_PTR(obj))
 #define GetHandler(obj)		(Check_Type(obj, T_DATA), &(((struct mysql*)DATA_PTR(obj))->handler))
 #define GetMysqlRes(obj)	(Check_Type(obj, T_DATA), ((struct mysql_res*)DATA_PTR(obj))->res)
+#define GetMysqlStmt(obj)	(Check_Type(obj, T_DATA), ((struct mysql_stmt*)DATA_PTR(obj))->stmt)
 
 VALUE cMysql;
 VALUE cMysqlRes;
 VALUE cMysqlField;
+VALUE cMysqlStmt;
+VALUE cMysqlRowOffset;
+VALUE cMysqlTime;
 VALUE eMysql;
 
 static int store_result_count = 0;
@@ -61,6 +67,25 @@ struct mysql_res {
     char freed;
 };
 
+#if MYSQL_VERSION_ID >= 40101
+struct mysql_stmt {
+    MYSQL_STMT *stmt;
+    char closed;
+    struct {
+	int n;
+	MYSQL_BIND *bind;
+	unsigned long *length;
+	MYSQL_TIME *buffer;
+    } param;
+    struct {
+	int n;
+	MYSQL_BIND *bind;
+	my_bool *is_null;
+	unsigned long *length;
+    } result;
+    MYSQL_RES *res;
+};
+#endif
 
 /*	free Mysql class object		*/
 static void free_mysql(struct mysql* my)
@@ -79,10 +104,64 @@ static void free_mysqlres(struct mysql_res* resp)
     free(resp);
 }
 
+#if MYSQL_VERSION_ID >= 40101
+static void free_mysqlstmt_memory(struct mysql_stmt *s)
+{
+    if (s->param.bind) {
+	xfree(s->param.bind);
+	s->param.bind = NULL;
+    }
+    if (s->param.length) {
+	xfree(s->param.length);
+	s->param.length = NULL;
+    }
+    if (s->param.buffer) {
+	xfree(s->param.buffer);
+	s->param.buffer = NULL;
+    }
+    s->param.n = 0;
+    if (s->res) {
+	mysql_free_result(s->res);
+	s->res = NULL;
+    }
+    if (s->result.bind) {
+	int i;
+	for (i = 0; i < s->result.n; i++) {
+	    if (s->result.bind[i].buffer)
+		xfree(s->result.bind[i].buffer);
+	}
+	xfree(s->result.bind);
+	s->result.bind = NULL;
+    }
+    if (s->result.is_null) {
+	xfree(s->result.is_null);
+	s->result.is_null = NULL;
+    }
+    if (s->result.length) {
+	xfree(s->result.length);
+	s->result.length = NULL;
+    }
+    s->result.n = 0;
+}
+
+static void free_mysqlstmt(struct mysql_stmt* s)
+{
+    free_mysqlstmt_memory(s);
+    if (s->closed == Qfalse)
+	mysql_stmt_close(s->stmt);
+    if (s->res)
+	mysql_free_result(s->res);
+    free(s);
+}
+#endif
+
 static void mysql_raise(MYSQL* m)
 {
     VALUE e = rb_exc_new2(eMysql, mysql_error(m));
     rb_iv_set(e, "errno", INT2FIX(mysql_errno(m)));
+#if MYSQL_VERSION_ID >= 40101
+    rb_iv_set(e, "sqlstate", rb_tainted_str_new2(mysql_sqlstate(m)));
+#endif
     rb_exc_raise(e);
 }
 
@@ -275,6 +354,9 @@ static VALUE options(int argc, VALUE* argv, VALUE obj)
 #endif
 #if MYSQL_VERSION_ID >= 40100
     case MYSQL_SHARED_MEMORY_BASE_NAME:
+#endif
+#if MYSQL_VERSION_ID >= 40101
+    case MYSQL_SET_CLIENT_IP:
 #endif
 	if (val == Qnil)
 	    rb_raise(rb_eArgError, "wrong # of arguments(1 for 2)");
@@ -614,6 +696,7 @@ static VALUE use_result(VALUE obj)
     return mysqlres2obj(res);
 }
 
+static VALUE res_free(VALUE);
 /*	query(sql)	*/
 static VALUE query(VALUE obj, VALUE sql)
 {
@@ -621,7 +704,7 @@ static VALUE query(VALUE obj, VALUE sql)
     Check_Type(sql, T_STRING);
     if (rb_block_given_p()) {
 #if MYSQL_VERSION_ID >= 40101
-	if (mysql_set_server_option(m, MYSQL_OPTION_MULTI_STATEMENTS_ON) != 0)
+        if (mysql_get_server_version(m) >= 40101 && mysql_set_server_option(m, MYSQL_OPTION_MULTI_STATEMENTS_ON) != 0)
 	    mysql_raise(m);
 #endif
 	if (mysql_real_query(m, RSTRING(sql)->ptr, RSTRING(sql)->len) != 0)
@@ -632,7 +715,6 @@ static VALUE query(VALUE obj, VALUE sql)
 		if (mysql_field_count(m) != 0)
 		    mysql_raise(m);
 	    } else {
-		static VALUE res_free(VALUE);
 		VALUE robj = mysqlres2obj(res);
 		rb_ensure(rb_yield, robj, res_free, robj);
 	    }
@@ -755,6 +837,37 @@ static VALUE sqlstate(VALUE obj)
 }
 #endif
 
+#if MYSQL_VERSION_ID >= 40102
+/*	stmt_init()	*/
+static VALUE stmt_init(VALUE obj)
+{
+    MYSQL *m = GetHandler(obj);
+    MYSQL_STMT *s;
+    struct mysql_stmt* stmt;
+    my_bool true = 1;
+    VALUE st_obj;
+
+    if ((s = mysql_stmt_init(m)) == NULL)
+	mysql_raise(m);
+    if (mysql_stmt_attr_set(s, STMT_ATTR_UPDATE_MAX_LENGTH, &true))
+	rb_raise(rb_eArgError, "mysql_stmt_attr_set() failed");
+    st_obj = Data_Make_Struct(cMysqlStmt, struct mysql_stmt, 0, free_mysqlstmt, stmt);
+    memset(stmt, 0, sizeof(*stmt));
+    stmt->stmt = s;
+    stmt->closed = Qfalse;
+    return st_obj;
+}
+
+static VALUE stmt_prepare(VALUE obj, VALUE query);
+/*	prepare(query)	*/
+static VALUE prepare(VALUE obj, VALUE query)
+{
+    VALUE st;
+    st = stmt_init(obj);
+    return stmt_prepare(st, query);
+}
+#endif
+
 /*	query_with_result()	*/
 static VALUE query_with_result(VALUE obj)
 {
@@ -791,7 +904,7 @@ static VALUE reconnect_set(VALUE obj, VALUE flag)
  * Mysql::Result object method
  */
 
-/*	check if alread freed	*/
+/*	check if already freed	*/
 static void check_free(VALUE obj)
 {
     struct mysql_res* resp = DATA_PTR(obj);
@@ -912,8 +1025,6 @@ static VALUE fetch_hash2(VALUE obj, VALUE with_table)
     hash = rb_hash_new();
     for (i=0; i<n; i++) {
 	VALUE col;
-	if (row[i] == NULL)
-	    continue;
 	if (with_table == Qnil || with_table == Qfalse)
 	    col = rb_tainted_str_new2(fields[i].name);
 	else {
@@ -979,15 +1090,21 @@ static VALUE num_rows(VALUE obj)
 /*	row_seek(offset)	*/
 static VALUE row_seek(VALUE obj, VALUE offset)
 {
+    MYSQL_ROW_OFFSET prev_offset;
+    if (CLASS_OF(offset) != cMysqlRowOffset)
+	rb_raise(rb_eTypeError, "wrong argument type %s (expected Mysql::RowOffset)", rb_obj_classname(offset));
     check_free(obj);
-    return INT2NUM((int)mysql_row_seek(GetMysqlRes(obj), (MYSQL_ROWS*)NUM2INT(offset)));
+    prev_offset = mysql_row_seek(GetMysqlRes(obj), DATA_PTR(offset));
+    return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, prev_offset);
 }
 
 /*	row_tell()	*/
 static VALUE row_tell(VALUE obj)
 {
+    MYSQL_ROW_OFFSET offset;
     check_free(obj);
-    return INT2NUM((int)mysql_row_tell(GetMysqlRes(obj)));
+    offset = mysql_row_tell(GetMysqlRes(obj));
+    return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, offset);
 }
 
 /*	each {...}	*/
@@ -1079,6 +1196,586 @@ static VALUE field_is_pri_key(VALUE obj)
 }
 #endif
 
+#if MYSQL_VERSION_ID >= 40102
+/*-------------------------------
+ * Mysql::Stmt object method
+ */
+
+/*	check if stmt is already closed */
+static void check_stmt_closed(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    if (s->closed == Qtrue)
+	rb_raise(eMysql, "Mysql::Stmt object is already closed");
+}
+
+static void mysql_stmt_raise(MYSQL_STMT* s)
+{
+    VALUE e = rb_exc_new2(eMysql, mysql_stmt_error(s));
+    rb_iv_set(e, "errno", INT2FIX(mysql_stmt_errno(s)));
+    rb_iv_set(e, "sqlstate", rb_tainted_str_new2(mysql_stmt_sqlstate(s)));
+    rb_exc_raise(e);
+}
+
+/*	affected_rows()	*/
+static VALUE stmt_affected_rows(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    my_ulonglong n;
+    check_stmt_closed(obj);
+    n = mysql_stmt_affected_rows(s->stmt);
+    return INT2NUM(n);
+}
+
+#if 0
+/*	attr_get(option)	*/
+static VALUE stmt_attr_get(VALUE obj, VALUE opt)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    check_stmt_closed(obj);
+    if (NUM2INT(opt) == STMT_ATTR_UPDATE_MAX_LENGTH) {
+	my_bool arg;
+	mysql_stmt_attr_get(s->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &arg);
+	return arg == 1 ? Qtrue : Qfalse;
+    }
+    rb_raise(eMysql, "unknown option: %d", NUM2INT(opt));
+}
+
+/*	attr_set(option, arg)	*/
+static VALUE stmt_attr_set(VALUE obj, VALUE opt, VALUE val)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    check_stmt_closed(obj);
+    if (NUM2INT(opt) == STMT_ATTR_UPDATE_MAX_LENGTH) {
+	my_bool arg;
+	arg = (val == Qnil || val == Qfalse) ? 0 : 1;
+	mysql_stmt_attr_set(s->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &arg);
+	return obj;
+    }
+    rb_raise(eMysql, "unknown option: %d", NUM2INT(opt));
+}
+#endif
+
+/*	bind_result(bind,...)	*/
+static enum enum_field_types buffer_type(MYSQL_FIELD *field);
+static VALUE stmt_bind_result(int argc, VALUE *argv, VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    int i;
+    MYSQL_FIELD *field;
+
+    check_stmt_closed(obj);
+    if (argc != s->result.n)
+	rb_raise(eMysql, "bind_result: result value count(%d) != number of argument(%d)", s->result.n, argc);
+    for (i = 0; i < argc; i++) {
+	if (argv[i] == Qnil || argv[i] == rb_cNilClass) {
+	    field = mysql_fetch_fields(s->res);
+	    s->result.bind[i].buffer_type = buffer_type(&field[i]);
+	}
+	else if (argv[i] == rb_cString)
+	    s->result.bind[i].buffer_type = MYSQL_TYPE_STRING;
+	else if (argv[i] == rb_cNumeric || argv[i] == rb_cInteger || argv[i] == rb_cFixnum)
+	    s->result.bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
+	else if (argv[i] == rb_cFloat)
+	    s->result.bind[i].buffer_type = MYSQL_TYPE_DOUBLE;
+	else if (argv[i] == cMysqlTime)
+	    s->result.bind[i].buffer_type = MYSQL_TYPE_DATETIME;
+	else
+	    rb_raise(rb_eTypeError, "unrecognized class: %s", RSTRING(rb_inspect(argv[i]))->ptr);
+	if (mysql_stmt_bind_result(s->stmt, s->result.bind))
+	    mysql_stmt_raise(s->stmt);
+    }
+    return obj;
+}
+
+/*	close()	*/
+static VALUE stmt_close(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    check_stmt_closed(obj);
+    mysql_stmt_close(s->stmt);
+    s->closed = Qtrue;
+    return Qnil;
+}
+
+/*	data_seek(offset)	*/
+static VALUE stmt_data_seek(VALUE obj, VALUE offset)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    check_stmt_closed(obj);
+    mysql_stmt_data_seek(s->stmt, NUM2INT(offset));
+    return obj;
+}
+
+/*	execute(arg,...)	*/
+static VALUE stmt_execute(int argc, VALUE *argv, VALUE obj)
+{
+    struct mysql_stmt *s = DATA_PTR(obj);
+    MYSQL_STMT *stmt = s->stmt;
+    my_bool true = 1;
+    my_bool false = 0;
+    int i;
+
+    check_stmt_closed(obj);
+    if (s->param.n != argc)
+	rb_raise(eMysql, "execute: param_count(%d) != number of argument(%d)", s->param.n, argc);
+    memset(s->param.bind, 0, sizeof(*(s->param.bind))*argc);
+    for (i = 0; i < argc; i++) {
+	switch (TYPE(argv[i])) {
+	case T_NIL:
+	    s->param.bind[i].buffer_type = MYSQL_TYPE_NULL;
+	    s->param.bind[i].is_null = &true;
+	    break;
+	case T_FIXNUM:
+	    s->param.bind[i].buffer_type = MYSQL_TYPE_LONG;
+	    s->param.bind[i].buffer = &(s->param.buffer[i]);
+	    *(long*)(s->param.bind[i].buffer) = FIX2INT(argv[i]);
+	    break;
+	case T_BIGNUM:
+	    s->param.bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
+	    s->param.bind[i].buffer = &(s->param.buffer[i]);
+	    *(long long*)(s->param.bind[i].buffer) = rb_big2ll(argv[i]);
+	    break;
+	case T_FLOAT:
+	    s->param.bind[i].buffer_type = MYSQL_TYPE_DOUBLE;
+	    s->param.bind[i].buffer = &(s->param.buffer[i]);
+	    *(double*)(s->param.bind[i].buffer) = NUM2DBL(argv[i]);
+	    break;
+	case T_STRING:
+	    s->param.bind[i].buffer_type = MYSQL_TYPE_STRING;
+	    s->param.bind[i].buffer = RSTRING(argv[i])->ptr;
+	    s->param.bind[i].buffer_length = RSTRING(argv[i])->len;
+	    s->param.length[i] = RSTRING(argv[i])->len;
+	    s->param.bind[i].length = &(s->param.length[i]);
+	    break;
+	default:
+	    if (CLASS_OF(argv[i]) == rb_cTime) {
+		MYSQL_TIME t;
+		VALUE a = rb_funcall(argv[i], rb_intern("to_a"), 0);
+		s->param.bind[i].buffer_type = MYSQL_TYPE_DATETIME;
+		s->param.bind[i].buffer = &(s->param.buffer[i]);
+		t.second_part = 0;
+		t.neg = 0;
+		t.second = FIX2INT(RARRAY(a)->ptr[0]);
+		t.minute = FIX2INT(RARRAY(a)->ptr[1]);
+		t.hour = FIX2INT(RARRAY(a)->ptr[2]);
+		t.day = FIX2INT(RARRAY(a)->ptr[3]);
+		t.month = FIX2INT(RARRAY(a)->ptr[4]);
+		t.year = FIX2INT(RARRAY(a)->ptr[5]);
+		*(MYSQL_TIME*)&(s->param.buffer[i]) = t;
+	    } else if (CLASS_OF(argv[i]) == cMysqlTime) {
+		MYSQL_TIME t;
+		s->param.bind[i].buffer_type = MYSQL_TYPE_DATETIME;
+		s->param.bind[i].buffer = &(s->param.buffer[i]);
+		t.second_part = 0;
+		t.neg = 0;
+		t.second = NUM2INT(rb_iv_get(argv[i], "second"));
+		t.minute = NUM2INT(rb_iv_get(argv[i], "minute"));
+		t.hour = NUM2INT(rb_iv_get(argv[i], "hour"));
+		t.day = NUM2INT(rb_iv_get(argv[i], "day"));
+		t.month = NUM2INT(rb_iv_get(argv[i], "month"));
+		t.year = NUM2INT(rb_iv_get(argv[i], "year"));
+		*(MYSQL_TIME*)&(s->param.buffer[i]) = t;
+	    } else
+		rb_raise(rb_eTypeError, "unsupported type: %d", TYPE(argv[i]));
+	}
+    }
+    if (mysql_stmt_bind_param(stmt, s->param.bind))
+	mysql_stmt_raise(stmt);
+
+    if (mysql_stmt_execute(stmt))
+	mysql_stmt_raise(stmt);
+    if (s->res) {
+	MYSQL_FIELD *field;
+	if (mysql_stmt_store_result(stmt))
+	    mysql_stmt_raise(stmt);
+	field = mysql_fetch_fields(s->res);
+	for (i = 0; i < s->result.n; i++) {
+	    if (s->result.bind[i].buffer_type == MYSQL_TYPE_STRING ||
+		s->result.bind[i].buffer_type == MYSQL_TYPE_BLOB) {
+		s->result.bind[i].buffer = xmalloc(field[i].max_length);
+                memset(s->result.bind[i].buffer, 0, field[i].max_length);
+		s->result.bind[i].buffer_length = field[i].max_length;
+	    } else {
+		s->result.bind[i].buffer = xmalloc(sizeof(MYSQL_TIME));
+		s->result.bind[i].buffer_length = sizeof(MYSQL_TIME);
+                memset(s->result.bind[i].buffer, 0, sizeof(MYSQL_TIME));
+	    }
+	}
+	if (mysql_stmt_bind_result(s->stmt, s->result.bind))
+	    mysql_stmt_raise(s->stmt);
+    }
+    return obj;
+}
+
+/*	fetch()		*/
+static VALUE stmt_fetch(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    VALUE ret;
+    int i;
+    int r;
+
+    check_stmt_closed(obj);
+    r = mysql_stmt_fetch(s->stmt);
+    if (r == MYSQL_NO_DATA)
+	return Qnil;
+    if (r == 1)
+	mysql_stmt_raise(s->stmt);
+
+    ret = rb_ary_new2(s->result.n);
+    for (i = 0; i < s->result.n; i++) {
+	if (s->result.is_null[i])
+	    rb_ary_push(ret, Qnil);
+	else {
+	    VALUE v;
+	    MYSQL_TIME *t;
+	    switch (s->result.bind[i].buffer_type) {
+	    case MYSQL_TYPE_LONG:
+		v = INT2NUM(*(long*)s->result.bind[i].buffer);
+		break;
+	    case MYSQL_TYPE_LONGLONG:
+		v = rb_ll2inum(*(long long*)s->result.bind[i].buffer);
+		break;
+	    case MYSQL_TYPE_DOUBLE:
+		v = rb_float_new(*(double*)s->result.bind[i].buffer);
+		break;
+	    case MYSQL_TYPE_TIMESTAMP:
+	    case MYSQL_TYPE_DATE:
+	    case MYSQL_TYPE_TIME:
+	    case MYSQL_TYPE_DATETIME:
+		t = (MYSQL_TIME*)s->result.bind[i].buffer;
+		v = rb_obj_alloc(cMysqlTime);
+		rb_funcall(v, rb_intern("initialize"), 8,
+			   INT2FIX(t->year), INT2FIX(t->month),
+			   INT2FIX(t->day), INT2FIX(t->hour),
+			   INT2FIX(t->minute), INT2FIX(t->second),
+			   (t->neg ? Qtrue : Qfalse),
+			   INT2FIX(t->second_part));
+		break;
+	    case MYSQL_TYPE_STRING:
+	    case MYSQL_TYPE_BLOB:
+		v = rb_tainted_str_new(s->result.bind[i].buffer, s->result.length[i]);
+		break;
+	    default:
+		rb_raise(rb_eTypeError, "unknown buffer_type: %d", s->result.bind[i].buffer_type);
+	    }
+	    rb_ary_push(ret, v);
+	}
+    }
+    return ret;
+}
+
+/*	each {...}	*/
+static VALUE stmt_each(VALUE obj)
+{
+    VALUE row;
+    check_stmt_closed(obj);
+    while ((row = stmt_fetch(obj)) != Qnil)
+	rb_yield(row);
+    return obj;
+}
+
+/*	field_count()	*/
+static VALUE stmt_field_count(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    unsigned int n;
+    check_stmt_closed(obj);
+    n = mysql_stmt_field_count(s->stmt);
+    return INT2NUM(n);
+}
+
+/*	free_result()	*/
+static VALUE stmt_free_result(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    check_stmt_closed(obj);
+    if (s->res) {
+	mysql_free_result(s->res);
+	s->res = NULL;
+    }
+    if (mysql_stmt_free_result(s->stmt))
+	mysql_stmt_raise(s->stmt);
+    return obj;
+}
+
+/*	insert_id()	*/
+static VALUE stmt_insert_id(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    my_ulonglong n;
+    check_stmt_closed(obj);
+    n = mysql_stmt_insert_id(s->stmt);
+    return INT2NUM(n);
+}
+
+/*	num_rows()	*/
+static VALUE stmt_num_rows(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    my_ulonglong n;
+    check_stmt_closed(obj);
+    n = mysql_stmt_num_rows(s->stmt);
+    return INT2NUM(n);
+}
+
+/*	param_count()		*/
+static VALUE stmt_param_count(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    unsigned long n;
+    check_stmt_closed(obj);
+    n = mysql_stmt_param_count(s->stmt);
+    return INT2NUM(n);
+}
+
+/*	prepare(query)	*/
+static enum enum_field_types buffer_type(MYSQL_FIELD *field)
+{
+    switch (field->type) {
+    case FIELD_TYPE_TINY:
+    case FIELD_TYPE_SHORT:
+    case FIELD_TYPE_INT24:
+    case FIELD_TYPE_YEAR:
+	return MYSQL_TYPE_LONG;
+    case FIELD_TYPE_LONG:
+    case FIELD_TYPE_LONGLONG:
+	return MYSQL_TYPE_LONGLONG;
+    case FIELD_TYPE_FLOAT:
+    case FIELD_TYPE_DOUBLE:
+	return MYSQL_TYPE_DOUBLE;
+    case FIELD_TYPE_TIMESTAMP:
+	return MYSQL_TYPE_TIMESTAMP;
+    case FIELD_TYPE_DATE:
+	return MYSQL_TYPE_DATE;
+    case FIELD_TYPE_TIME:
+	return MYSQL_TYPE_TIME;
+    case FIELD_TYPE_DATETIME:
+	return MYSQL_TYPE_DATETIME;
+    case FIELD_TYPE_STRING:
+    case FIELD_TYPE_VAR_STRING:
+    case FIELD_TYPE_SET:
+    case FIELD_TYPE_ENUM:
+    case FIELD_TYPE_DECIMAL:
+#if MYSQL_VERSION_ID >= 50003
+    case FIELD_TYPE_NEWDECIMAL:
+#endif
+	return MYSQL_TYPE_STRING;
+    case FIELD_TYPE_BLOB:
+	return MYSQL_TYPE_BLOB;
+    case FIELD_TYPE_NULL:
+	return MYSQL_TYPE_NULL;
+    default:
+	rb_raise(rb_eTypeError, "unknown type: %d", field->type);
+    }
+}
+
+static VALUE stmt_prepare(VALUE obj, VALUE query)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    int n;
+    int i;
+    MYSQL_FIELD *field;
+
+    free_mysqlstmt_memory(s);
+    check_stmt_closed(obj);
+    Check_Type(query, T_STRING);
+    if (mysql_stmt_prepare(s->stmt, RSTRING(query)->ptr, RSTRING(query)->len))
+	mysql_stmt_raise(s->stmt);
+
+    n = mysql_stmt_param_count(s->stmt);
+    s->param.n = n;
+    s->param.bind = xmalloc(sizeof(s->param.bind[0]) * n);
+    s->param.length = xmalloc(sizeof(s->param.length[0]) * n);
+    s->param.buffer = xmalloc(sizeof(s->param.buffer[0]) * n);
+
+    s->res = mysql_stmt_result_metadata(s->stmt);
+    if (s->res) {
+	n = s->result.n = mysql_num_fields(s->res);
+	s->result.bind = xmalloc(sizeof(s->result.bind[0]) * n);
+	s->result.is_null = xmalloc(sizeof(s->result.is_null[0]) * n);
+	s->result.length = xmalloc(sizeof(s->result.length[0]) * n);
+	field = mysql_fetch_fields(s->res);
+	memset(s->result.bind, 0, sizeof(s->result.bind[0]) * n);
+	for (i = 0; i < n; i++) {
+	    s->result.bind[i].buffer_type = buffer_type(&field[i]);
+	    s->result.bind[i].is_null = &(s->result.is_null[i]);
+	    s->result.bind[i].length = &(s->result.length[i]);
+	}
+    } else {
+	if (mysql_stmt_errno(s->stmt))
+	    mysql_stmt_raise(s->stmt);
+    }
+
+    return obj;
+}
+
+#if 0
+/*	reset()		*/
+static VALUE stmt_reset(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    check_stmt_closed(obj);
+    if (mysql_stmt_reset(s->stmt))
+	mysql_stmt_raise(s->stmt);
+    return obj;
+}
+#endif
+
+/*	result_metadata()	*/
+static VALUE stmt_result_metadata(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    MYSQL_RES *res;
+    check_stmt_closed(obj);
+    res = mysql_stmt_result_metadata(s->stmt);
+    if (res == NULL && mysql_stmt_errno(s->stmt) != 0)
+	mysql_stmt_raise(s->stmt);
+    return mysqlres2obj(res);
+}
+
+/*	row_seek(offset)	*/
+static VALUE stmt_row_seek(VALUE obj, VALUE offset)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    MYSQL_ROW_OFFSET prev_offset;
+    if (CLASS_OF(offset) != cMysqlRowOffset)
+	rb_raise(rb_eTypeError, "wrong argument type %s (expected Mysql::RowOffset)", rb_obj_classname(offset));
+    check_stmt_closed(obj);
+    prev_offset = mysql_stmt_row_seek(s->stmt, DATA_PTR(offset));
+    return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, prev_offset);
+}
+
+/*	row_tell()	*/
+static VALUE stmt_row_tell(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    MYSQL_ROW_OFFSET offset;
+    check_stmt_closed(obj);
+    offset = mysql_stmt_row_tell(s->stmt);
+    return Data_Wrap_Struct(cMysqlRowOffset, 0, NULL, offset);
+}
+
+#if 0
+/*	send_long_data(col, data)	*/
+static VALUE stmt_send_long_data(VALUE obj, VALUE col, VALUE data)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    int c;
+    check_stmt_closed(obj);
+    c = NUM2INT(col);
+    if (0 <= c && c < s->param.n) {
+	s->param.bind[c].buffer_type = MYSQL_TYPE_STRING;
+	if (mysql_stmt_bind_param(s->stmt, s->param.bind))
+	    mysql_stmt_raise(s->stmt);
+    }
+    if (mysql_stmt_send_long_data(s->stmt, c, RSTRING(data)->ptr, RSTRING(data)->len))
+	mysql_stmt_raise(s->stmt);
+    return obj;
+}
+#endif
+
+/*	sqlstate()	*/
+static VALUE stmt_sqlstate(VALUE obj)
+{
+    struct mysql_stmt* s = DATA_PTR(obj);
+    return rb_tainted_str_new2(mysql_stmt_sqlstate(s->stmt));
+}
+
+/*-------------------------------
+ * Mysql::Time object method
+ */
+
+static VALUE time_initialize(int argc, VALUE* argv, VALUE obj)
+{
+    VALUE year, month, day, hour, minute, second, neg, second_part;
+    rb_scan_args(argc, argv, "08", &year, &month, &day, &hour, &minute, &second, &neg, &second_part);
+#define NILorFIXvalue(o)	(NIL_P(o) ? INT2FIX(0) : (Check_Type(o, T_FIXNUM), o))
+    rb_iv_set(obj, "year", NILorFIXvalue(year));
+    rb_iv_set(obj, "month", NILorFIXvalue(month));
+    rb_iv_set(obj, "day", NILorFIXvalue(day));
+    rb_iv_set(obj, "hour", NILorFIXvalue(hour));
+    rb_iv_set(obj, "minute", NILorFIXvalue(minute));
+    rb_iv_set(obj, "second", NILorFIXvalue(second));
+    rb_iv_set(obj, "neg", (neg == Qnil || neg == Qfalse) ? Qfalse : Qtrue);
+    rb_iv_set(obj, "second_part", NILorFIXvalue(second_part));
+}
+
+static VALUE time_inspect(VALUE obj)
+{
+    char buf[36];
+    sprintf(buf, "#<Mysql::Time:%04d-%02d-%02d %02d:%02d:%02d>",
+	    NUM2INT(rb_iv_get(obj, "year")),
+	    NUM2INT(rb_iv_get(obj, "month")),
+	    NUM2INT(rb_iv_get(obj, "day")),
+	    NUM2INT(rb_iv_get(obj, "hour")),
+	    NUM2INT(rb_iv_get(obj, "minute")),
+	    NUM2INT(rb_iv_get(obj, "second")));
+    return rb_str_new2(buf);
+}
+
+static VALUE time_to_s(VALUE obj)
+{
+    char buf[20];
+    sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d",
+	    NUM2INT(rb_iv_get(obj, "year")),
+	    NUM2INT(rb_iv_get(obj, "month")),
+	    NUM2INT(rb_iv_get(obj, "day")),
+	    NUM2INT(rb_iv_get(obj, "hour")),
+	    NUM2INT(rb_iv_get(obj, "minute")),
+	    NUM2INT(rb_iv_get(obj, "second")));
+    return rb_str_new2(buf);
+}
+
+#define DefineMysqlTimeGetMethod(m)\
+static VALUE time_get_##m(VALUE obj)\
+{return rb_iv_get(obj, #m);}
+
+DefineMysqlTimeGetMethod(year)
+DefineMysqlTimeGetMethod(month)
+DefineMysqlTimeGetMethod(day)
+DefineMysqlTimeGetMethod(hour)
+DefineMysqlTimeGetMethod(minute)
+DefineMysqlTimeGetMethod(second)
+DefineMysqlTimeGetMethod(neg)
+DefineMysqlTimeGetMethod(second_part)
+
+#define DefineMysqlTimeSetMethod(m)\
+static VALUE time_set_##m(VALUE obj, VALUE v)\
+{rb_iv_set(obj, #m, NILorFIXvalue(v)); return v;}
+
+DefineMysqlTimeSetMethod(year)
+DefineMysqlTimeSetMethod(month)
+DefineMysqlTimeSetMethod(day)
+DefineMysqlTimeSetMethod(hour)
+DefineMysqlTimeSetMethod(minute)
+DefineMysqlTimeSetMethod(second)
+DefineMysqlTimeSetMethod(second_part)
+
+static VALUE time_set_neg(VALUE obj, VALUE v)
+{
+    rb_iv_set(obj, "neg", (v == Qnil || v == Qfalse) ? Qfalse : Qtrue);
+    return v;
+}
+
+static VALUE time_equal(VALUE obj, VALUE v)
+{
+    if (CLASS_OF(v) == cMysqlTime &&
+	NUM2INT(rb_iv_get(obj, "year")) == NUM2INT(rb_iv_get(v, "year")) &&
+	NUM2INT(rb_iv_get(obj, "month")) == NUM2INT(rb_iv_get(v, "month")) &&
+	NUM2INT(rb_iv_get(obj, "day")) == NUM2INT(rb_iv_get(v, "day")) &&
+	NUM2INT(rb_iv_get(obj, "hour")) == NUM2INT(rb_iv_get(v, "hour")) &&
+	NUM2INT(rb_iv_get(obj, "minute")) == NUM2INT(rb_iv_get(v, "minute")) &&
+	NUM2INT(rb_iv_get(obj, "second")) == NUM2INT(rb_iv_get(v, "second")) &&
+	rb_iv_get(obj, "neg") == rb_iv_get(v, "neg") &&
+	NUM2INT(rb_iv_get(obj, "second_part")) == NUM2INT(rb_iv_get(v, "second_part")))
+	return Qtrue;
+    return Qfalse;
+}
+
+#endif
+
 /*-------------------------------
  * Mysql::Error object method
  */
@@ -1093,6 +1790,11 @@ static VALUE error_errno(VALUE obj)
     return rb_iv_get(obj, "errno");
 }
 
+static VALUE error_sqlstate(VALUE obj)
+{
+    return rb_iv_get(obj, "sqlstate");
+}
+
 /*-------------------------------
  *	Initialize
  */
@@ -1102,6 +1804,11 @@ void Init_mysql(void)
     cMysql = rb_define_class("Mysql", rb_cObject);
     cMysqlRes = rb_define_class_under(cMysql, "Result", rb_cObject);
     cMysqlField = rb_define_class_under(cMysql, "Field", rb_cObject);
+#if MYSQL_VERSION_ID >= 40102
+    cMysqlStmt = rb_define_class_under(cMysql, "Stmt", rb_cObject);
+    cMysqlRowOffset = rb_define_class_under(cMysql, "RowOffset", rb_cObject);
+    cMysqlTime = rb_define_class_under(cMysql, "Time", rb_cObject);
+#endif
     eMysql = rb_define_class_under(cMysql, "Error", rb_eStandardError);
 
     rb_define_global_const("MysqlRes", cMysqlRes);
@@ -1200,6 +1907,10 @@ void Init_mysql(void)
 #ifdef HAVE_MYSQL_SSL_SET
     rb_define_method(cMysql, "ssl_set", ssl_set, -1);
 #endif
+#if MYSQL_VERSION_ID >= 40102
+    rb_define_method(cMysql, "stmt_init", stmt_init, 0);
+    rb_define_method(cMysql, "prepare", prepare, 1);
+#endif
 #if MYSQL_VERSION_ID >= 40100
     rb_define_method(cMysql, "more_results", more_results, 0);
     rb_define_method(cMysql, "more_results?", more_results, 0);
@@ -1216,6 +1927,7 @@ void Init_mysql(void)
     rb_define_method(cMysql, "reconnect=", reconnect_set, 1);
 
     /* Mysql constant */
+    rb_define_const(cMysql, "VERSION", INT2FIX(MYSQL_RUBY_VERSION));
 #if MYSQL_VERSION_ID >= 32200
     rb_define_const(cMysql, "OPT_CONNECT_TIMEOUT", INT2NUM(MYSQL_OPT_CONNECT_TIMEOUT));
     rb_define_const(cMysql, "OPT_COMPRESS", INT2NUM(MYSQL_OPT_COMPRESS));
@@ -1237,6 +1949,10 @@ void Init_mysql(void)
     rb_define_const(cMysql, "OPT_READ_TIMEOUT", INT2NUM(MYSQL_OPT_READ_TIMEOUT));
     rb_define_const(cMysql, "OPT_WRITE_TIMEOUT", INT2NUM(MYSQL_OPT_WRITE_TIMEOUT));
     rb_define_const(cMysql, "SECURE_AUTH", INT2NUM(MYSQL_SECURE_AUTH));
+    rb_define_const(cMysql, "OPT_GUESS_CONNECTION", INT2NUM(MYSQL_OPT_GUESS_CONNECTION));
+    rb_define_const(cMysql, "OPT_USE_EMBEDDED_CONNECTION", INT2NUM(MYSQL_OPT_USE_EMBEDDED_CONNECTION));
+    rb_define_const(cMysql, "OPT_USE_REMOTE_CONNECTION", INT2NUM(MYSQL_OPT_USE_REMOTE_CONNECTION));
+    rb_define_const(cMysql, "SET_CLIENT_IP", INT2NUM(MYSQL_SET_CLIENT_IP));
 #endif
     rb_define_const(cMysql, "REFRESH_GRANT", INT2NUM(REFRESH_GRANT));
     rb_define_const(cMysql, "REFRESH_LOG", INT2NUM(REFRESH_LOG));
@@ -1401,9 +2117,68 @@ void Init_mysql(void)
     rb_define_const(cMysqlField, "PART_KEY_FLAG", INT2NUM(PART_KEY_FLAG));
 #endif
 
+#if MYSQL_VERSION_ID >= 40102
+    /* Mysql::Stmt object method */
+    rb_define_method(cMysqlStmt, "affected_rows", stmt_affected_rows, 0);
+#if 0
+    rb_define_method(cMysqlStmt, "attr_get", stmt_attr_get, 1);
+    rb_define_method(cMysqlStmt, "attr_set", stmt_attr_set, 2);
+#endif
+    rb_define_method(cMysqlStmt, "bind_result", stmt_bind_result, -1);
+    rb_define_method(cMysqlStmt, "close", stmt_close, 0);
+    rb_define_method(cMysqlStmt, "data_seek", stmt_data_seek, 1);
+    rb_define_method(cMysqlStmt, "each", stmt_each, 0);
+    rb_define_method(cMysqlStmt, "execute", stmt_execute, -1);
+    rb_define_method(cMysqlStmt, "fetch", stmt_fetch, 0);
+    rb_define_method(cMysqlStmt, "field_count", stmt_field_count, 0);
+    rb_define_method(cMysqlStmt, "free_result", stmt_free_result, 0);
+    rb_define_method(cMysqlStmt, "insert_id", stmt_insert_id, 0);
+    rb_define_method(cMysqlStmt, "num_rows", stmt_num_rows, 0);
+    rb_define_method(cMysqlStmt, "param_count", stmt_param_count, 0);
+    rb_define_method(cMysqlStmt, "prepare", stmt_prepare, 1);
+#if 0
+    rb_define_method(cMysqlStmt, "reset", stmt_reset, 0);
+#endif
+    rb_define_method(cMysqlStmt, "result_metadata", stmt_result_metadata, 0);
+    rb_define_method(cMysqlStmt, "row_seek", stmt_row_seek, 1);
+    rb_define_method(cMysqlStmt, "row_tell", stmt_row_tell, 0);
+#if 0
+    rb_define_method(cMysqlStmt, "send_long_data", stmt_send_long_data, 2);
+#endif
+    rb_define_method(cMysqlStmt, "sqlstate", stmt_sqlstate, 0);
+
+#if 0
+    rb_define_const(cMysqlStmt, "ATTR_UPDATE_MAX_LENGTH", INT2NUM(STMT_ATTR_UPDATE_MAX_LENGTH));
+#endif
+
+    /* Mysql::Time object method */
+    rb_define_method(cMysqlTime, "initialize", time_initialize, -1);
+    rb_define_method(cMysqlTime, "inspect", time_inspect, 0);
+    rb_define_method(cMysqlTime, "to_s", time_to_s, 0);
+    rb_define_method(cMysqlTime, "year", time_get_year, 0);
+    rb_define_method(cMysqlTime, "month", time_get_month, 0);
+    rb_define_method(cMysqlTime, "day", time_get_day, 0);
+    rb_define_method(cMysqlTime, "hour", time_get_hour, 0);
+    rb_define_method(cMysqlTime, "minute", time_get_minute, 0);
+    rb_define_method(cMysqlTime, "second", time_get_second, 0);
+    rb_define_method(cMysqlTime, "neg", time_get_neg, 0);
+    rb_define_method(cMysqlTime, "second_part", time_get_second_part, 0);
+    rb_define_method(cMysqlTime, "year=", time_set_year, 1);
+    rb_define_method(cMysqlTime, "month=", time_set_month, 1);
+    rb_define_method(cMysqlTime, "day=", time_set_day, 1);
+    rb_define_method(cMysqlTime, "hour=", time_set_hour, 1);
+    rb_define_method(cMysqlTime, "minute=", time_set_minute, 1);
+    rb_define_method(cMysqlTime, "second=", time_set_second, 1);
+    rb_define_method(cMysqlTime, "neg=", time_set_neg, 1);
+    rb_define_method(cMysqlTime, "second_part=", time_set_second_part, 1);
+    rb_define_method(cMysqlTime, "==", time_equal, 1);
+
+#endif
+
     /* Mysql::Error object method */
     rb_define_method(eMysql, "error", error_error, 0);
     rb_define_method(eMysql, "errno", error_errno, 0);
+    rb_define_method(eMysql, "sqlstate", error_sqlstate, 0);
 
     /* Mysql::Error constant */
 }