/* 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; }