/* 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_query(VALUE self, VALUE sql, VALUE current) {
#ifndef _WIN32
struct async_query_args async_args;
#endif
struct nogvl_send_query_args args;
GET_CLIENT(self);
REQUIRE_CONNECTED(wrapper);
args.mysql = wrapper->client;
(void)RB_GC_GUARD(current);
Check_Type(current, T_HASH);
rb_iv_set(self, "@current_query_options", current);
Check_Type(sql, T_STRING);
#ifdef HAVE_RUBY_ENCODING_H
/* ensure the string is in the encoding the connection is expecting */
args.sql = rb_str_export_to_enc(sql, rb_to_encoding(wrapper->encoding));
#else
args.sql = sql;
#endif
args.sql_ptr = RSTRING_PTR(args.sql);
args.sql_len = RSTRING_LEN(args.sql);
args.wrapper = wrapper;
rb_mysql_client_set_active_thread(self);
#ifndef _WIN32
rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0);
if (rb_hash_aref(current, sym_async) == Qtrue) {
return Qnil;
} else {
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_ensure(rb_mysql_client_async_result, self, disconnect_and_mark_inactive, self);
}
#else
do_send_query(&args);
/* this will just block until the result is ready */
return rb_ensure(rb_mysql_client_async_result, self, disconnect_and_mark_inactive, self);
#endif
}
static VALUE
thread_exclusive(VALUE (*func)(ANYARGS), VALUE arg)
{
VALUE critical = rb_thread_critical;
rb_thread_critical = 1;
return rb_ensure(func, arg, set_critical, (VALUE)critical);
}
static VALUE
rbg_pangologattrs2rval_free(PangoLogAttr *attrs, long n)
{
struct rbg_pangologattrs2rval_free_args args = { attrs, n };
return rb_ensure(rbg_pangologattrs2rval_free_body, (VALUE)&args,
rbg_pangologattrs2rval_free_ensure, (VALUE)&args);
}
/*
* Get lock on media list items
*
* @yield
* @return self
* @todo fixme
*/
static VALUE
rg_lock(VALUE self)
{
libvlc_media_list_lock(_SELF(self));
if (rb_block_given_p())
rb_ensure(rb_yield, self, rg_unlock, self);
return self;
}
VALUE
rbgio_cstr_to_rval_tainted_free(char *string, gsize length)
{
struct rbgio_cstr_to_rval_tainted_free_data data = { string, length };
return rb_ensure(rbgio_cstr_to_rval_tainted_free_body, (VALUE)&data,
rbgio_cstr_to_rval_tainted_free_ensure, (VALUE)&data);
}
VALUE
rb_thread_exclusive( void)
{
VALUE old_tc = rb_thread_critical;
rb_thread_critical = Qtrue;
return rb_ensure( rb_yield, Qnil, bsruby_set_thread_critical, old_tc);
}
static void
aspirin_response_set_body(struct evhttp_request* request, VALUE body)
{
VALUE buff = Data_Wrap_Struct(rb_cData, 0, 0, request->output_buffer);
VALUE args = rb_ary_new3(2, body, buff);
rb_ensure(aspirin_response_each_body, args, aspirin_response_close_body, body);
DATA_PTR(buff) = NULL;
}
VALUE
rb_format_exception_message(VALUE exc)
{
const int old_level = rb_safe_level();
rb_set_safe_level_force(0);
return rb_ensure(format_message, exc, restore_level, (VALUE)old_level);
}
VALUE oci8_get_rowid_attr(oci8_base_t *base, ub4 attrtype)
{
rowid_arg_t arg;
arg.base = base;
arg.attrtype = attrtype;
arg.ridp = NULL;
return rb_ensure(get_rowid_attr, (VALUE)&arg, rowid_ensure, (VALUE)&arg);
}
VALUE
rbgutil_gslist2ary_boxed_and_free(GSList *const list, GType gtype)
{
struct rbgutil_gslist2ary_boxed_and_free_data data = { list, gtype };
return rb_ensure(rbgutil_gslist2ary_boxed_and_free_body, (VALUE)&data,
rbgutil_gslist2ary_boxed_and_free_ensure, (VALUE)&data);
}
static VALUE
stackprof_run(int argc, VALUE *argv, VALUE self)
{
rb_need_block();
stackprof_start(argc, argv, self);
rb_ensure(rb_yield, Qundef, stackprof_stop, self);
return stackprof_results(0, 0, self);
}
/*
* call-seq:
* Groonga::Array.create(options={}) -> Groonga::Array
* Groonga::Array.create(options={}) {|table| ... }
*
* キーのないテーブルを生成する。ブロックを指定すると、そのブ
* ロックに生成したテーブルが渡され、ブロックを抜けると自動的
* にテーブルが破棄される。
*
* @example
* #無名一時テーブルを生成する。
* Groonga::Array.create
*
* #無名永続テーブルを生成する。
* Groonga::Array.create(:path => "/tmp/array.grn")
*
* #名前付き永続テーブルを生成する。ただし、ファイル名は気にしない。
* Groonga::Array.create(:name => "Bookmarks",
* :persistent => true)
*
* #それぞれのレコードに512バイトの値を格納できる無名一時テーブルを生成する。
* Groonga::Array.create(:value => 512)
*
* @param [::Hash] options The name and value
* pairs. Omitted names are initialized as the default value.
* @option options [Grrnga::Context] :context (Groonga::Context.default) The context
* テーブルが利用するGrrnga::Context
* @option options :name The name
* テーブルの名前。名前をつけると、Groonga::Context#[]に名
* 前を指定してテーブルを取得することができる。省略すると
* 無名テーブルになり、テーブルIDでのみ取得できる。
* @option options :path The path
* テーブルを保存するパス。パスを指定すると永続テーブルとな
* り、プロセス終了後もレコードは保持される。次回起動時に
* Groonga::Context#[]で保存されたレコードを利用することが
* できる。省略すると一時テーブルになり、プロセスが終了する
* とレコードは破棄される。
* @option options :persistent The persistent
* +true+ を指定すると永続テーブルとなる。 +path+ を省略した
* 場合は自動的にパスが付加される。 +:context+ で指定した
* Groonga::Contextに結びついているデータベースが一時デー
* タベースの場合は例外が発生する。
* @option options :value_type (nil) The value_type
* 値の型を指定する。省略すると値のための領域を確保しない。
* 値を保存したい場合は必ず指定すること。
* 参考: Groonga::Type.new
* @option options [Groonga::Record#n_sub_records] :sub_records The sub_records
* +true+ を指定すると#groupでグループ化したときに、
* Groonga::Record#n_sub_recordsでグループに含まれるレコー
* ドの件数を取得できる。
*/
static VALUE
rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
{
grn_ctx *context = NULL;
grn_obj *value_type = NULL, *table;
const char *name = NULL, *path = NULL;
unsigned name_size = 0;
grn_obj_flags flags = GRN_OBJ_TABLE_NO_KEY;
VALUE rb_table;
VALUE options, rb_context, rb_name, rb_path, rb_persistent;
VALUE rb_value_type, rb_sub_records;
rb_scan_args(argc, argv, "01", &options);
rb_grn_scan_options(options,
"context", &rb_context,
"name", &rb_name,
"path", &rb_path,
"persistent", &rb_persistent,
"value_type", &rb_value_type,
"sub_records", &rb_sub_records,
NULL);
context = rb_grn_context_ensure(&rb_context);
if (!NIL_P(rb_name)) {
name = StringValuePtr(rb_name);
name_size = RSTRING_LEN(rb_name);
flags |= GRN_OBJ_PERSISTENT;
}
if (!NIL_P(rb_path)) {
path = StringValueCStr(rb_path);
flags |= GRN_OBJ_PERSISTENT;
}
if (RVAL2CBOOL(rb_persistent))
flags |= GRN_OBJ_PERSISTENT;
if (!NIL_P(rb_value_type))
value_type = RVAL2GRNOBJECT(rb_value_type, &context);
if (RVAL2CBOOL(rb_sub_records))
flags |= GRN_OBJ_WITH_SUBREC;
table = grn_table_create(context, name, name_size, path,
flags, NULL, value_type);
if (!table)
rb_grn_context_check(context, rb_ary_new4(argc, argv));
rb_table = GRNOBJECT2RVAL(klass, context, table, GRN_TRUE);
rb_grn_context_check(context, rb_table);
rb_iv_set(rb_table, "@context", rb_context);
if (rb_block_given_p())
return rb_ensure(rb_yield, rb_table, rb_grn_object_close, rb_table);
else
return rb_table;
}
/*
* call-seq:
* AIO.read(cb) -> string
*
* Asynchronously reads a file.This is an initial *blocking* implementation until
* cross platform notification is supported.
*/
static VALUE
rb_aio_s_read(VALUE aio, VALUE cb)
{
rb_aiocb_t *cbs = GetCBStruct(cb);
if (rb_block_given_p()){
cbs->rcb = rb_block_proc();
}
return rb_ensure(rb_aio_read, (VALUE)&cbs->cb, control_block_close, cb);
}
VALUE
yield_or_return_result( VALUE result)
{
struct pgresult_data *r;
Data_Get_Struct( result, struct pgresult_data, r);
return rb_block_given_p() ?
rb_ensure( rb_yield, result, pgresult_clear, result) : result;
}
static VALUE
rg_activate(VALUE self)
{
pango_renderer_activate(_SELF(self));
if (rb_block_given_p()) {
rb_ensure(rb_yield, self, rg_deactivate, self);
}
return self;
}
static VALUE
gobj_freeze_notify(VALUE self)
{
g_object_freeze_notify(RVAL2GOBJ(self));
if (rb_block_given_p()) {
return rb_ensure(rb_yield, self, gobj_thaw_notify, self);
}
return self;
}
static VALUE
rg_block_activate(VALUE self)
{
gtk_action_block_activate(_SELF(self));
if (rb_block_given_p())
rb_ensure(rb_yield, self, rg_unblock_activate, self);
return self;
}
static VALUE
bdb_log_hcae(VALUE lsn)
{
struct dblsnst *lsnst;
Data_Get_Struct(lsn, struct dblsnst, lsnst);
lsnst->flags = DB_PREV;
return rb_ensure(bdb_log_i_get, lsn, bdb_log_cursor_close, lsn);
}
/*
* call-seq:
* conn.send( sql, *bind_values) { |conn| ... } -> nil
*
* Sends an asynchronous SQL query request specified by +sql+ to the
* PostgreSQL server.
*
* Use Pg::Conn#fetch to fetch the results after you waited for data.
*
* Pg::Conn.connect do |conn|
* conn.send "select pg_sleep(3), * from t;" do
* ins = [ conn.socket]
* loop do
* r = IO.select ins, nil, nil, 0.5
* break if r
* puts Time.now
* end
* res = conn.fetch
* res.each { |w| puts w.inspect }
* end
* end
*/
VALUE
pgconn_send( int argc, VALUE *argv, VALUE self)
{
VALUE cmd, par;
pg_parse_parameters( argc, argv, &cmd, &par);
pg_statement_send( self, cmd, par);
return rb_ensure( rb_yield, self, clear_resultqueue, self);
}
static void
each_group(void)
{
if (group_blocking) {
rb_raise(rb_eRuntimeError, "parallel group iteration");
}
group_blocking = (int)Qtrue;
rb_ensure(group_iterate, 0, group_ensure, 0);
}
VALUE
rbg_gslist2rval_with_type(GSList *const list, RBGRValueFuncWithType conv, GType gtype,
GFreeFunc free_list, GFreeFunc free_elem)
{
struct list2rval_with_type_args args = {{list, NULL, free_list, free_elem}, conv, gtype};
return rb_ensure(gslist2rval_with_type_body, (VALUE)&args,
gslist2rval_ensure, (VALUE)&args);
}
static void
each_passwd(void)
{
if (passwd_blocking) {
rb_raise(rb_eRuntimeError, "parallel passwd iteration");
}
passwd_blocking = (int)Qtrue;
rb_ensure(passwd_iterate, 0, passwd_ensure, 0);
}
VALUE
rbg_gslist2rval(GSList *const list, RBGRValueFunc conv,
GFreeFunc free_list, GFreeFunc free_elem)
{
struct list2rval_args args = {list, conv, free_list, free_elem};
return rb_ensure(gslist2rval_body, (VALUE)&args,
gslist2rval_ensure, (VALUE)&args);
}
/*
* call-seq:
* conn.backup( label) { |result| ... } -> nil
*
* Call the pg_start_backup() and pg_stop_backup() functions.
*/
VALUE
pgconn_backup( VALUE self, VALUE label)
{
VALUE cmd, arg;
cmd = rb_str_new2( "select pg_start_backup($1);");
arg = rb_ary_new3( 1, label);
pgresult_clear( pg_statement_exec( self, cmd, arg));
return rb_ensure( rb_yield, Qnil, backup_end, self);
}
static VALUE
lock(VALUE self)
{
GST_MESSAGE_LOCK(SELF(self));
if (rb_block_given_p()) {
rb_ensure(rb_yield, Qnil, unlock, self);
}
return Qnil;
}
static VALUE
gdkwin_enable_synchronized_configure(VALUE self)
{
gdk_window_enable_synchronized_configure(_SELF(self));
if (rb_block_given_p()) {
rb_ensure(rb_yield, self, gdkwin_configure_finished, self);
}
return self;
}
/*
* call-seq:
* AIO.lio_listio(cb1, cb2, ...) -> array
*
* Schedules a batch of read requests for execution by the kernel in order
* to reduce system calls.Blocks until all the requests complete and returns
* an array equal in length to the given files, with the read buffers as string
* elements.The number of operations is currently limited to 16 due to cross
* platform limitations.
*
* open_nocancel("first.txt\0", 0x0, 0x1B6) = 3 0
* fstat(0x3, 0xBFFFEE04, 0x1B6) = 0 0
* open_nocancel("second.txt\0", 0x0, 0x1B6) = 4 0
* fstat(0x4, 0xBFFFEE04, 0x1B6) = 0 0
* open_nocancel("third.txt\0", 0x0, 0x1B6) = 5 0
* fstat(0x5, 0xBFFFEE04, 0x1B6) = 0 0
* fstat64(0x1, 0xBFFFE234, 0x1B6) = 0 0
* ioctl(0x1, 0x4004667A, 0xBFFFE29C) = 0 0
* lio_listio(0x2, 0xBFFFEE64, 0x3) = 0 0
* close_nocancel(0x4) = 0 0
* close_nocancel(0x3) = 0 0
*/
static VALUE
rb_aio_s_lio_listio(VALUE aio, VALUE cbs)
{
VALUE mode_arg, mode;
int ops;
ops = RARRAY_LEN(cbs);
mode_arg = RARRAY_PTR(cbs)[0];
mode = (mode_arg == c_aio_wait || mode_arg == c_aio_nowait || mode_arg == c_aio_nop) ? rb_ary_shift(cbs) : c_aio_wait;
if (ops > AIO_MAX_LIST) return c_aio_queue;
switch(NUM2INT(mode)){
case LIO_WAIT:
return rb_ensure(rb_aio_lio_listio_blocking, (VALUE)cbs, rb_io_closes, (VALUE)cbs);
case LIO_NOWAIT:
return rb_aio_lio_listio_non_blocking((VALUE)cbs);
case LIO_NOP:
return rb_ensure(rb_aio_lio_listio_noop, (VALUE)cbs, rb_io_closes, (VALUE)cbs);
}
rb_aio_error("Only modes AIO::WAIT, AIO::NOWAIT and AIO::NOP supported");
}
static void
signal_condvar(ConditionVariable *condvar)
{
VALUE waking;
//rb_thread_critical = 1;
waking = rb_ensure(wake_one, (VALUE)&condvar->waiting, set_critical, 0);
if (RTEST(waking)) {
run_thread(waking);
}
}
/*
* call-seq:
* conn.copy_stdout( sql, *bind_values) { ... } -> nil
*
* Read lines from a +COPY+ command. The form of the lines depends
* on the statement's parameters.
*
* conn.copy_stdout "copy t to stdout;" do
* l = conn.getline
* ary = l.split /\t/
* ary.map! { |x|
* unless x == "\\N" then
* x.gsub! /\\(.)/ do
* case $1
* when "t" then "\t"
* when "n" then "\n"
* when "\\" then "\\"
* end
* end
* end
* }
* ...
* end
*/
VALUE
pgconn_copy_stdout( int argc, VALUE *argv, VALUE self)
{
VALUE cmd, par;
VALUE res;
pg_parse_parameters( argc, argv, &cmd, &par);
res = pg_statement_exec( self, cmd, par);
return rb_ensure( rb_yield, res, get_end, self);
}
static VALUE
cr_device_acquire (VALUE self)
{
cairo_device_acquire (_SELF);
cr_device_check_status (_SELF);
if (rb_block_given_p ())
return rb_ensure (rb_yield, self, cr_device_release, self);
else
return self;
}
