void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
msgpack_packer_ext_registry_t* dst)
{
#ifdef HAVE_RB_HASH_DUP
dst->hash = rb_hash_dup(src->hash);
dst->cache = rb_hash_dup(src->cache);
#else
dst->hash = rb_funcall(src->hash, rb_intern("dup"), 0);
dst->cache = rb_funcall(src->cache, rb_intern("dup"), 0);
#endif
}
/* call-seq:
* client.store_result
*
* Return the next result object from a query which
* yielded multiple result sets.
*/
static VALUE rb_mysql_client_store_result(VALUE self)
{
MYSQL_RES * result;
VALUE resultObj;
#ifdef HAVE_RUBY_ENCODING_H
mysql2_result_wrapper * result_wrapper;
#endif
GET_CLIENT(self);
result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
if (result == NULL) {
if (mysql_errno(wrapper->client) != 0) {
rb_raise_mysql2_error(wrapper);
}
/* no data and no error, so query was not a SELECT */
return Qnil;
}
resultObj = rb_mysql_result_to_obj(result);
/* pass-through query options for result construction later */
rb_iv_set(resultObj, "@query_options", rb_hash_dup(rb_iv_get(self, "@current_query_options")));
#ifdef HAVE_RUBY_ENCODING_H
GetMysql2Result(resultObj, result_wrapper);
result_wrapper->encoding = wrapper->encoding;
#endif
return resultObj;
}
static VALUE Packer_registered_types_internal(VALUE self)
{
PACKER(self, pk);
#ifdef HAVE_RB_HASH_DUP
return rb_hash_dup(pk->ext_registry.hash);
#else
return rb_funcall(pk->ext_registry.hash, rb_intern("dup"), 0);
#endif
}
/*
* call-seq:
* entry.to_hash => Hash
*
* Convert the entry to a hash.
*/
VALUE
rb_ldap_entry_to_hash (VALUE self)
{
RB_LDAPENTRY_DATA *edata;
VALUE hash, dn_ary;
GET_LDAPENTRY_DATA (self, edata);
hash = rb_hash_dup(edata->attr);
dn_ary = rb_ary_new3(1, edata->dn);
rb_hash_aset(hash, rb_tainted_str_new2("dn"), dn_ary);
return hash;
}
static VALUE Factory_registered_types_internal(VALUE self)
{
FACTORY(self, fc);
VALUE uk_mapping = rb_hash_new();
for(int i=0; i < 256; i++) {
if(fc->ukrg.array[i] != Qnil) {
rb_hash_aset(uk_mapping, INT2FIX(i - 128), fc->ukrg.array[i]);
}
}
#ifdef HAVE_RB_HASH_DUP
return rb_ary_new3(2, rb_hash_dup(fc->pkrg.hash), uk_mapping);
#else
return rb_ary_new3(2, rb_funcall(fc->pkrg.hash, rb_intern("dup"), 0), uk_mapping);
#endif
}
/* call-seq:
* client.async_result
*
* Returns the result for the last async issued query.
*/
static VALUE rb_mysql_client_async_result(VALUE self) {
MYSQL_RES * result;
VALUE resultObj;
#ifdef HAVE_RUBY_ENCODING_H
mysql2_result_wrapper * result_wrapper;
#endif
GET_CLIENT(self);
/* if we're not waiting on a result, do nothing */
if (NIL_P(wrapper->active_thread))
return Qnil;
REQUIRE_CONNECTED(wrapper);
if (rb_thread_blocking_region(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
/* an error occurred, mark this connection inactive */
MARK_CONN_INACTIVE(self);
return rb_raise_mysql2_error(wrapper);
}
VALUE is_streaming = rb_hash_aref(rb_iv_get(self, "@current_query_options"), sym_stream);
if(is_streaming == Qtrue) {
result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
} else {
result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
}
if (result == NULL) {
if (mysql_errno(wrapper->client) != 0) {
MARK_CONN_INACTIVE(self);
rb_raise_mysql2_error(wrapper);
}
/* no data and no error, so query was not a SELECT */
return Qnil;
}
resultObj = rb_mysql_result_to_obj(result);
/* pass-through query options for result construction later */
rb_iv_set(resultObj, "@query_options", rb_hash_dup(rb_iv_get(self, "@current_query_options")));
#ifdef HAVE_RUBY_ENCODING_H
GetMysql2Result(resultObj, result_wrapper);
result_wrapper->encoding = wrapper->encoding;
#endif
return resultObj;
}
/* call-seq:
* client.async_result
*
* Returns the result for the last async issued query.
*/
static VALUE rb_mysql_client_async_result(VALUE self) {
MYSQL_RES * result;
VALUE resultObj;
VALUE current, is_streaming;
GET_CLIENT(self);
/* if we're not waiting on a result, do nothing */
if (NIL_P(wrapper->active_thread))
return Qnil;
REQUIRE_CONNECTED(wrapper);
if ((VALUE)rb_thread_call_without_gvl(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
/* an error occurred, mark this connection inactive */
MARK_CONN_INACTIVE(self);
return rb_raise_mysql2_error(wrapper);
}
is_streaming = rb_hash_aref(rb_iv_get(self, "@current_query_options"), sym_stream);
if (is_streaming == Qtrue) {
result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
} else {
result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
}
if (result == NULL) {
if (mysql_errno(wrapper->client) != 0) {
MARK_CONN_INACTIVE(self);
rb_raise_mysql2_error(wrapper);
}
/* no data and no error, so query was not a SELECT */
return Qnil;
}
current = rb_hash_dup(rb_iv_get(self, "@current_query_options"));
(void)RB_GC_GUARD(current);
Check_Type(current, T_HASH);
resultObj = rb_mysql_result_to_obj(self, wrapper->encoding, current, result, Qnil);
return resultObj;
}
/* call-seq:
* client.store_result
*
* Return the next result object from a query which
* yielded multiple result sets.
*/
static VALUE rb_mysql_client_store_result(VALUE self)
{
MYSQL_RES * result;
VALUE resultObj;
VALUE current;
GET_CLIENT(self);
result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
if (result == NULL) {
if (mysql_errno(wrapper->client) != 0) {
rb_raise_mysql2_error(wrapper);
}
/* no data and no error, so query was not a SELECT */
return Qnil;
}
current = rb_hash_dup(rb_iv_get(self, "@current_query_options"));
(void)RB_GC_GUARD(current);
Check_Type(current, T_HASH);
resultObj = rb_mysql_result_to_obj(self, wrapper->encoding, current, result, Qnil);
return resultObj;
}
/* call-seq:
* client.query(sql, options = {})
*
* Query the database with +sql+, with optional +options+. For the possible
* options, see @@default_query_options on the Mysql2::Client class.
*/
static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
#ifndef _WIN32
struct async_query_args async_args;
#endif
struct nogvl_send_query_args args;
int async = 0;
VALUE opts, current;
VALUE thread_current = rb_thread_current();
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *conn_enc;
#endif
GET_CLIENT(self);
REQUIRE_CONNECTED(wrapper);
args.mysql = wrapper->client;
current = rb_hash_dup(rb_iv_get(self, "@query_options"));
RB_GC_GUARD(current);
Check_Type(current, T_HASH);
rb_iv_set(self, "@current_query_options", current);
if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) {
rb_funcall(current, intern_merge_bang, 1, opts);
if (rb_hash_aref(current, sym_async) == Qtrue) {
async = 1;
}
}
Check_Type(args.sql, T_STRING);
#ifdef HAVE_RUBY_ENCODING_H
conn_enc = rb_to_encoding(wrapper->encoding);
/* ensure the string is in the encoding the connection is expecting */
args.sql = rb_str_export_to_enc(args.sql, conn_enc);
#endif
args.sql_ptr = RSTRING_PTR(args.sql);
args.sql_len = RSTRING_LEN(args.sql);
/* see if this connection is still waiting on a result from a previous query */
if (NIL_P(wrapper->active_thread)) {
/* mark this connection active */
wrapper->active_thread = thread_current;
} else if (wrapper->active_thread == thread_current) {
rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result");
} else {
VALUE inspect = rb_inspect(wrapper->active_thread);
const char *thr = StringValueCStr(inspect);
rb_raise(cMysql2Error, "This connection is in use by: %s", thr);
RB_GC_GUARD(inspect);
}
args.wrapper = wrapper;
#ifndef _WIN32
rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0);
if (!async) {
async_args.fd = wrapper->client->net.fd;
async_args.self = self;
rb_rescue2(do_query, (VALUE)&async_args, disconnect_and_raise, self, rb_eException, (VALUE)0);
return rb_mysql_client_async_result(self);
} else {
return Qnil;
}
#else
do_send_query(&args);
/* this will just block until the result is ready */
return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self);
#endif
}
VALUE hash_spec_rb_hash_dup(VALUE self, VALUE hash) {
return rb_hash_dup(hash);
}
static inline void
args_setup_kw_rest_parameter(VALUE keyword_hash, VALUE *locals)
{
locals[0] = NIL_P(keyword_hash) ? rb_hash_new() : rb_hash_dup(keyword_hash);
}
/* call-seq: stmt.execute
*
* Executes the current prepared statement, returns +result+.
*/
static VALUE execute(int argc, VALUE *argv, VALUE self) {
MYSQL_BIND *bind_buffers = NULL;
unsigned long *length_buffers = NULL;
unsigned long bind_count;
long i;
MYSQL_STMT *stmt;
MYSQL_RES *metadata;
VALUE current;
VALUE resultObj;
VALUE *params_enc;
int is_streaming;
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *conn_enc;
#endif
GET_STATEMENT(self);
GET_CLIENT(stmt_wrapper->client);
#ifdef HAVE_RUBY_ENCODING_H
conn_enc = rb_to_encoding(wrapper->encoding);
#endif
/* Scratch space for string encoding exports, allocate on the stack. */
params_enc = alloca(sizeof(VALUE) * argc);
stmt = stmt_wrapper->stmt;
bind_count = mysql_stmt_param_count(stmt);
if (argc != (long)bind_count) {
rb_raise(cMysql2Error, "Bind parameter count (%ld) doesn't match number of arguments (%d)", bind_count, argc);
}
// setup any bind variables in the query
if (bind_count > 0) {
bind_buffers = xcalloc(bind_count, sizeof(MYSQL_BIND));
length_buffers = xcalloc(bind_count, sizeof(unsigned long));
for (i = 0; i < argc; i++) {
bind_buffers[i].buffer = NULL;
params_enc[i] = Qnil;
switch (TYPE(argv[i])) {
case T_NIL:
bind_buffers[i].buffer_type = MYSQL_TYPE_NULL;
break;
case T_FIXNUM:
#if SIZEOF_INT < SIZEOF_LONG
bind_buffers[i].buffer_type = MYSQL_TYPE_LONGLONG;
bind_buffers[i].buffer = xmalloc(sizeof(long long int));
*(long*)(bind_buffers[i].buffer) = FIX2LONG(argv[i]);
#else
bind_buffers[i].buffer_type = MYSQL_TYPE_LONG;
bind_buffers[i].buffer = xmalloc(sizeof(int));
*(long*)(bind_buffers[i].buffer) = FIX2INT(argv[i]);
#endif
break;
case T_BIGNUM:
bind_buffers[i].buffer_type = MYSQL_TYPE_LONGLONG;
bind_buffers[i].buffer = xmalloc(sizeof(long long int));
*(LONG_LONG*)(bind_buffers[i].buffer) = rb_big2ll(argv[i]);
break;
case T_FLOAT:
bind_buffers[i].buffer_type = MYSQL_TYPE_DOUBLE;
bind_buffers[i].buffer = xmalloc(sizeof(double));
*(double*)(bind_buffers[i].buffer) = NUM2DBL(argv[i]);
break;
case T_STRING:
{
params_enc[i] = argv[i];
#ifdef HAVE_RUBY_ENCODING_H
params_enc[i] = rb_str_export_to_enc(params_enc[i], conn_enc);
#endif
set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
}
break;
default:
// TODO: what Ruby type should support MYSQL_TYPE_TIME
if (CLASS_OF(argv[i]) == rb_cTime || CLASS_OF(argv[i]) == cDateTime) {
MYSQL_TIME t;
VALUE rb_time = argv[i];
bind_buffers[i].buffer_type = MYSQL_TYPE_DATETIME;
bind_buffers[i].buffer = xmalloc(sizeof(MYSQL_TIME));
memset(&t, 0, sizeof(MYSQL_TIME));
t.neg = 0;
t.second_part = FIX2INT(rb_funcall(rb_time, intern_usec, 0));
t.second = FIX2INT(rb_funcall(rb_time, intern_sec, 0));
t.minute = FIX2INT(rb_funcall(rb_time, intern_min, 0));
t.hour = FIX2INT(rb_funcall(rb_time, intern_hour, 0));
t.day = FIX2INT(rb_funcall(rb_time, intern_day, 0));
t.month = FIX2INT(rb_funcall(rb_time, intern_month, 0));
t.year = FIX2INT(rb_funcall(rb_time, intern_year, 0));
*(MYSQL_TIME*)(bind_buffers[i].buffer) = t;
} else if (CLASS_OF(argv[i]) == cDate) {
MYSQL_TIME t;
VALUE rb_time = argv[i];
bind_buffers[i].buffer_type = MYSQL_TYPE_DATE;
bind_buffers[i].buffer = xmalloc(sizeof(MYSQL_TIME));
memset(&t, 0, sizeof(MYSQL_TIME));
t.second_part = 0;
t.neg = 0;
t.day = FIX2INT(rb_funcall(rb_time, intern_day, 0));
t.month = FIX2INT(rb_funcall(rb_time, intern_month, 0));
t.year = FIX2INT(rb_funcall(rb_time, intern_year, 0));
*(MYSQL_TIME*)(bind_buffers[i].buffer) = t;
} else if (CLASS_OF(argv[i]) == cBigDecimal) {
bind_buffers[i].buffer_type = MYSQL_TYPE_NEWDECIMAL;
// DECIMAL are represented with the "string representation of the
// original server-side value", see
// https://dev.mysql.com/doc/refman/5.7/en/c-api-prepared-statement-type-conversions.html
// This should be independent of the locale used both on the server
// and the client side.
VALUE rb_val_as_string = rb_funcall(argv[i], intern_to_s, 0);
params_enc[i] = rb_val_as_string;
#ifdef HAVE_RUBY_ENCODING_H
params_enc[i] = rb_str_export_to_enc(params_enc[i], conn_enc);
#endif
set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
}
break;
}
}
// copies bind_buffers into internal storage
if (mysql_stmt_bind_param(stmt, bind_buffers)) {
FREE_BINDS;
rb_raise_mysql2_stmt_error(stmt_wrapper);
}
}
if ((VALUE)rb_thread_call_without_gvl(nogvl_execute, stmt, RUBY_UBF_IO, 0) == Qfalse) {
FREE_BINDS;
rb_raise_mysql2_stmt_error(stmt_wrapper);
}
FREE_BINDS;
metadata = mysql_stmt_result_metadata(stmt);
if (metadata == NULL) {
if (mysql_stmt_errno(stmt) != 0) {
// either CR_OUT_OF_MEMORY or CR_UNKNOWN_ERROR. both fatal.
wrapper->active_thread = Qnil;
rb_raise_mysql2_stmt_error(stmt_wrapper);
}
// no data and no error, so query was not a SELECT
return Qnil;
}
current = rb_hash_dup(rb_iv_get(stmt_wrapper->client, "@query_options"));
(void)RB_GC_GUARD(current);
Check_Type(current, T_HASH);
is_streaming = (Qtrue == rb_hash_aref(current, sym_stream));
if (!is_streaming) {
// recieve the whole result set from the server
if (mysql_stmt_store_result(stmt)) {
mysql_free_result(metadata);
rb_raise_mysql2_stmt_error(stmt_wrapper);
}
wrapper->active_thread = Qnil;
}
resultObj = rb_mysql_result_to_obj(stmt_wrapper->client, wrapper->encoding, current, metadata, self);
if (!is_streaming) {
// cache all result
rb_funcall(resultObj, intern_each, 0);
}
return resultObj;
}
