VALUE Field::init_copy(VALUE copy, VALUE orig) { //Copy this object to a new one. Open the cap file again Field* FieldCopy = NULL; Field* FieldOrig = NULL; if (copy == orig) { return copy; } if(TYPE(orig)!=T_DATA || RDATA(orig)->dfree!=(RUBY_DATA_FUNC)Field::free) { rb_raise(rb_eTypeError, "Wrong argument type"); } Data_Get_Struct(copy, Field, FieldCopy); Data_Get_Struct(orig, Field, FieldOrig); //Copy the Ruby property @packet, then copy the native Field objects too rb_iv_set(copy, "@packet", rb_iv_get(orig, "@packet")); *FieldCopy = *FieldOrig; return copy; }
/* :nodoc: * * Initialize a new instance of Sedna. Undocumented, because Sedna.connect should * be used instead. */ static VALUE cSedna_initialize(VALUE self, VALUE options) { VALUE host_k, db_k, user_k, pw_k, host_v, db_v, user_v, pw_v; char *host, *db, *user, *pw; // Ensure the argument is a Hash. Check_Type(options, T_HASH); // Store the symbols of the valid hash keys. host_k = ID2SYM(rb_intern("host")); db_k = ID2SYM(rb_intern("database")); user_k = ID2SYM(rb_intern("username")); pw_k = ID2SYM(rb_intern("password")); // Get the connection details or set them to the default values if not given. if(NIL_P(host_v = rb_hash_aref(options, host_k))) host = strdup(DEFAULT_HOST); else host = StringValuePtr(host_v); if(NIL_P(db_v = rb_hash_aref(options, db_k ))) db = strdup(DEFAULT_DB); else db = StringValuePtr(db_v); if(NIL_P(user_v = rb_hash_aref(options, user_k))) user = strdup(DEFAULT_USER); else user = StringValuePtr(user_v); if(NIL_P(pw_v = rb_hash_aref(options, pw_k ))) pw = strdup(DEFAULT_PW); else pw = StringValuePtr(pw_v); // Save all connection details to instance variables. rb_iv_set(self, IV_HOST, rb_str_new2(host)); rb_iv_set(self, IV_DB, rb_str_new2(db)); rb_iv_set(self, IV_USER, rb_str_new2(user)); rb_iv_set(self, IV_PW, rb_str_new2(pw)); #ifdef NON_BLOCKING // Create a mutex if this build supports non-blocking queries. rb_iv_set(self, IV_MUTEX, rb_mutex_new()); #endif // Connect to the database. SCA c = { sedna_struct(self), host, db, user, pw }; sedna_connect(self, &c); // Initialize @autocommit to true. rb_iv_set(self, IV_AUTOCOMMIT, Qtrue); return self; }
/* * call-seq: * X509::Store.new => store * */ static VALUE ossl_x509store_initialize(int argc, VALUE *argv, VALUE self) { X509_STORE *store; /* BUG: This method takes any number of arguments but appears to ignore them. */ GetX509Store(self, store); X509_STORE_set_verify_cb_func(store, ossl_verify_cb); ossl_x509store_set_vfy_cb(self, Qnil); #if (OPENSSL_VERSION_NUMBER < 0x00907000L) rb_iv_set(self, "@flags", INT2NUM(0)); rb_iv_set(self, "@purpose", INT2NUM(0)); rb_iv_set(self, "@trust", INT2NUM(0)); #endif /* last verification status */ rb_iv_set(self, "@error", Qnil); rb_iv_set(self, "@error_string", Qnil); rb_iv_set(self, "@chain", Qnil); rb_iv_set(self, "@time", Qnil); return self; }
/* * Initialize the node with its value and id. * Setup containers for the children, features * and dependencies of this node. */ static VALUE birch_initialize(VALUE self, VALUE value, VALUE id) { VALUE parent; VALUE children; VALUE children_hash; VALUE features; VALUE edges; parent = Qnil; children = rb_ary_new(); children_hash = rb_hash_new(); features = rb_hash_new(); edges = rb_ary_new(); rb_iv_set(self, "@value", value); rb_iv_set(self, "@id", id); rb_iv_set(self, "@parent", parent); rb_iv_set(self, "@children", children); rb_iv_set(self, "@children_hash", children_hash); rb_iv_set(self, "@features", features); rb_iv_set(self, "@edges", edges); return self; }
// RenderStates#initialize_copy(state) VALUE rbRenderStates::InitializeCopy( VALUE aSelf, VALUE aState ) { sf::RenderStates* states = rbRenderStates::ToSFML( aSelf ); *states = *rbRenderStates::ToSFML( aState ); VALUE transform = rbMacros::ToRubyNoGC( &states->transform, rbTransform::Class ); rb_iv_set( aSelf, "@__ref__transform", transform ); rb_iv_set( transform, "@__ref__state_owner", aSelf ); rb_obj_freeze( transform ); VALUE texture = rbMacros::ToRubyNoGC( const_cast< sf::Texture* >( states->texture ), rbTexture::Class ); rb_iv_set( aSelf, "@__ref__texture", texture ); rb_iv_set( texture, "@__ref__state_owner", aSelf ); rb_obj_freeze( texture ); VALUE shader = rbMacros::ToRubyNoGC( const_cast< sf::Shader* >( states->shader ), rbShader::Class ); rb_iv_set( aSelf, "@__ref__shader", shader ); rb_iv_set( shader, "@__ref__state_owner", aSelf ); rb_obj_freeze( shader ); return aSelf; }
static VALUE nstruct_add_type(VALUE type, int argc, VALUE *argv, VALUE nst) { VALUE ofs, size; ID id; int i; VALUE name=Qnil; size_t *shape=NULL; int ndim=0; ssize_t stride; narray_view_t *nt; int j; for (i=0; i<argc; i++) { switch(TYPE(argv[i])) { case T_STRING: case T_SYMBOL: if (NIL_P(name)) { name = argv[i]; break; } rb_raise(rb_eArgError,"multiple name in struct definition"); case T_ARRAY: if (shape) { rb_raise(rb_eArgError,"multiple shape in struct definition"); } ndim = RARRAY_LEN(argv[i]); if (ndim > NA_MAX_DIMENSION) { rb_raise(rb_eArgError,"too large number of dimensions"); } if (ndim == 0) { rb_raise(rb_eArgError,"array is empty"); } shape = ALLOCA_N(size_t, ndim); na_array_to_internal_shape(Qnil, argv[i], shape); break; } } id = rb_to_id(name); name = ID2SYM(id); if (rb_obj_is_kind_of(type,cNArray)) { narray_t *na; GetNArray(type,na); type = CLASS_OF(type); ndim = na->ndim; shape = na->shape; } type = rb_narray_view_new(type,ndim,shape); GetNArrayView(type,nt); nt->stridx = ALLOC_N(stridx_t,ndim); stride = na_dtype_elmsz(CLASS_OF(type)); for (j=ndim; j--; ) { SDX_SET_STRIDE(nt->stridx[j], stride); stride *= shape[j]; } ofs = rb_iv_get(nst, "__offset__"); nt->offset = NUM2SIZET(ofs); size = rb_funcall(type, rb_intern("byte_size"), 0); rb_iv_set(nst, "__offset__", rb_funcall(ofs,'+',1,size)); rb_ary_push(rb_iv_get(nst,"__members__"), rb_ary_new3(4,name,type,ofs,size)); // <- field definition return Qnil; }
static VALUE ossl_asn1_decode0(unsigned char **pp, long length, long *offset, long depth, int once, int yield) { unsigned char *start, *p; const unsigned char *p0; long len, off = *offset; int hlen, tag, tc, j; VALUE ary, asn1data, value, tag_class; ary = rb_ary_new(); p = *pp; while(length > 0){ start = p; p0 = p; j = ASN1_get_object(&p0, &len, &tag, &tc, length); p = (unsigned char *)p0; if(j & 0x80) ossl_raise(eASN1Error, NULL); hlen = p - start; if(yield){ VALUE arg = rb_ary_new(); rb_ary_push(arg, LONG2NUM(depth)); rb_ary_push(arg, LONG2NUM(off)); rb_ary_push(arg, LONG2NUM(hlen)); rb_ary_push(arg, LONG2NUM(len)); rb_ary_push(arg, (j & V_ASN1_CONSTRUCTED) ? Qtrue : Qfalse); rb_ary_push(arg, ossl_asn1_class2sym(tc)); rb_ary_push(arg, INT2NUM(tag)); rb_yield(arg); } length -= hlen; off += hlen; if(len > length) ossl_raise(eASN1Error, "value is too short"); if((tc & V_ASN1_PRIVATE) == V_ASN1_PRIVATE) tag_class = sPRIVATE; else if((tc & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC) tag_class = sCONTEXT_SPECIFIC; else if((tc & V_ASN1_APPLICATION) == V_ASN1_APPLICATION) tag_class = sAPPLICATION; else tag_class = sUNIVERSAL; if(j & V_ASN1_CONSTRUCTED){ /* TODO: if j == 0x21 it is indefinite length object. */ if((j == 0x21) && (len == 0)){ long lastoff = off; value = ossl_asn1_decode0(&p, length, &off, depth+1, 0, yield); len = off - lastoff; } else value = ossl_asn1_decode0(&p, len, &off, depth+1, 0, yield); } else{ value = rb_str_new((const char *)p, len); p += len; off += len; } if(tag_class == sUNIVERSAL && tag < ossl_asn1_info_size && ossl_asn1_info[tag].klass){ VALUE klass = *ossl_asn1_info[tag].klass; long flag = 0; if(!rb_obj_is_kind_of(value, rb_cArray)){ switch(tag){ case V_ASN1_BOOLEAN: value = decode_bool(start, hlen+len); break; case V_ASN1_INTEGER: value = decode_int(start, hlen+len); break; case V_ASN1_BIT_STRING: value = decode_bstr(start, hlen+len, &flag); break; case V_ASN1_NULL: value = decode_null(start, hlen+len); break; case V_ASN1_ENUMERATED: value = decode_enum(start, hlen+len); break; case V_ASN1_OBJECT: value = decode_obj(start, hlen+len); break; case V_ASN1_UTCTIME: /* FALLTHROUGH */ case V_ASN1_GENERALIZEDTIME: value = decode_time(start, hlen+len); break; default: /* use original value */ break; } } asn1data = rb_funcall(klass, rb_intern("new"), 1, value); if(tag == V_ASN1_BIT_STRING){ rb_iv_set(asn1data, "@unused_bits", LONG2NUM(flag)); } } else{ asn1data = rb_funcall(cASN1Data, rb_intern("new"), 3, value, INT2NUM(tag), ID2SYM(tag_class)); } rb_ary_push(ary, asn1data); length -= len; if(once) break; } *pp = p; *offset = off; return ary; }
// // def initialize(query_id, query, client) // static VALUE query_initialize(VALUE self, VALUE query_id, VALUE query, VALUE client) { rb_iv_set(self, "@query_id", query_id); rb_iv_set(self, "@query", query); rb_iv_set(self, "@client", client); rb_iv_set(self, "@done", Qfalse); }
static VALUE display_initialize(int argc, VALUE* argv, VALUE self) { caca_display_t *display; caca_canvas_t *canvas = NULL; const char *driver = NULL; VALUE cv = Qnil; VALUE arg1, arg2; rb_scan_args(argc, argv, "02", &arg1, &arg2); if(CLASS_OF(arg1) == cCanvas) { cv = arg1; if(CLASS_OF(arg2) == cCanvas) { rb_raise(rb_eArgError, "Only one argument can be a Caca::Canvas"); } } else if(CLASS_OF(arg2) == cCanvas) { cv = arg2; } if(TYPE(arg1) == T_STRING) { driver = StringValuePtr(arg1); if(TYPE(arg2) == T_STRING) { rb_raise(rb_eArgError, "Only one argument can be a string"); } } else if(TYPE(arg2) == T_STRING) { driver = StringValuePtr(arg2); } if(cv != Qnil) canvas = DATA_PTR(cv); if(driver == NULL) { display = caca_create_display(canvas); if(display && NIL_P(cv)) { cv = canvas_create(caca_get_canvas(display)); } } else { display = caca_create_display_with_driver(canvas, driver); } if(display == NULL) { rb_raise(rb_eRuntimeError, "%s", strerror(errno)); } _SELF = display; rb_iv_set(self, "@canvas", cv); return self; }
/* * call-seq: * column.select(options) {|record| ...} -> Groonga::Hash * column.select(query, options) -> Groonga::Hash * column.select(expression, options) -> Groonga::Hash * * カラムが所属するテーブルからブロックまたは文字列で指定し * た条件にマッチするレコードを返す。返されたテーブルには * +expression+という特異メソッドがあり、指定した条件を表し * ているGroonga::Expressionを取得できる。 * Groonga::Expression#snippetを使うことにより、指定した条件 * 用のスニペットを簡単に生成できる。 * * results = description_column.select do |column| * column =~ "groonga" * end * snippet = results.expression.snippet([["<em>", "</em>"]]) * results.each do |record| * puts "#{record['name']}の説明文の中で「groonga」が含まれる部分" * snippet.execute(record["description"].each do |snippet| * puts "---" * puts "#{snippet}..." * puts "---" * end * end * * 出力例 * Ruby/groongaの説明文の中で「groonga」が含まれる部分 * --- * Ruby/<em>groonga</em>は<em>groonga</em>のいわゆるDB-APIの層の... * --- * * _query_には「[カラム名]:[演算子][値]」という書式で条件を * 指定する。演算子は以下の通り。 * * [なし] * [カラム値] == [値] * [<tt>!</tt>] * [カラム値] != [値] * [<tt><</tt>] * [カラム値] < [値] * [<tt>></tt>] * [カラム値] > [値] * [<tt><=</tt>] * [カラム値] <= [値] * [<tt>>=</tt>] * [カラム値] >= [値] * [<tt>@</tt>] * [カラム値]が[値]を含んでいるかどうか * * 例: * "groonga" # _column_カラムの値が"groonga"のレコードにマッチ * "name:daijiro" # _column_カラムが属しているテーブルの * # "name"カラムの値が"daijiro"のレコードにマッチ * "description:@groonga" # _column_カラムが属しているテーブルの * # "description"カラムが * # "groonga"を含んでいるレコードにマッチ * * _expression_には既に作成済みのGroonga::Expressionを渡す * * ブロックで条件を指定する場合は * Groonga::ColumnExpressionBuilderを参照。 * * _options_に指定可能な値は以下の通り。 * * [+:operator+] * マッチしたレコードをどのように扱うか。指定可能な値は以 * 下の通り。省略した場合はGroonga::Operation::OR。 * * [Groonga::Operation::OR] * マッチしたレコードを追加。すでにレコードが追加され * ている場合は何もしない。 * [Groonga::Operation::AND] * マッチしたレコードのスコアを増加。マッチしなかった * レコードを削除。 * [Groonga::Operation::BUT] * マッチしたレコードを削除。 * [Groonga::Operation::ADJUST] * マッチしたレコードのスコアを増加。 * * [+:result+] * 検索結果を格納するテーブル。マッチしたレコードが追加さ * れていく。省略した場合は新しくテーブルを作成して返す。 * * [+:name+] * 条件の名前。省略した場合は名前を付けない。 * * [+:syntax+] * _query_の構文。省略した場合は+:query+。 * * 参考: Groonga::Expression#parse. * * [+:allow_pragma+] * query構文時にプラグマを利用するかどうか。省略した場合は * 利用する。 * * 参考: Groonga::Expression#parse. * * [+:allow_column+] * query構文時にカラム指定を利用するかどうか。省略した場合 * は利用する。 * * 参考: Groonga::Expression#parse. * * [+:allow_update+] * script構文時に更新操作を利用するかどうか。省略した場合 * は利用する。 * * 参考: Groonga::Expression#parse. */ static VALUE rb_grn_column_select (int argc, VALUE *argv, VALUE self) { grn_ctx *context; grn_obj *table, *column, *result, *expression; grn_operator operator = GRN_OP_OR; VALUE options; VALUE rb_query, condition_or_options; VALUE rb_name, rb_operator, rb_result, rb_syntax; VALUE rb_allow_pragma, rb_allow_column, rb_allow_update; VALUE builder; VALUE rb_expression = Qnil; rb_query = Qnil; rb_scan_args(argc, argv, "02", &condition_or_options, &options); rb_grn_column_deconstruct(SELF(self), &column, &context, NULL, NULL, NULL, NULL, NULL); table = grn_column_table(context, column); if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options, rb_cString))) { rb_query = condition_or_options; } else if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options, rb_cGrnExpression))) { rb_expression = condition_or_options; } else { if (!NIL_P(options)) rb_raise(rb_eArgError, "should be [query_string, option_hash], " "[expression, option_hash] " "or [option_hash]: %s", rb_grn_inspect(rb_ary_new4(argc, argv))); options = condition_or_options; } rb_grn_scan_options(options, "operator", &rb_operator, "result", &rb_result, "name", &rb_name, "syntax", &rb_syntax, "allow_pragma", &rb_allow_pragma, "allow_column", &rb_allow_column, "allow_update", &rb_allow_update, NULL); if (!NIL_P(rb_operator)) operator = NUM2INT(rb_operator); if (NIL_P(rb_result)) { result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC, table, 0); rb_result = GRNTABLE2RVAL(context, result, RB_GRN_TRUE); } else { result = RVAL2GRNTABLE(rb_result, &context); } if (NIL_P(rb_expression)) { builder = rb_grn_column_expression_builder_new(self, rb_name, rb_query); rb_funcall(builder, rb_intern("syntax="), 1, rb_syntax); rb_funcall(builder, rb_intern("allow_pragma="), 1, rb_allow_pragma); rb_funcall(builder, rb_intern("allow_column="), 1, rb_allow_column); rb_funcall(builder, rb_intern("allow_update="), 1, rb_allow_update); rb_expression = rb_grn_column_expression_builder_build(builder); } rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)), &expression, NULL, NULL, NULL, NULL, NULL); grn_table_select(context, table, expression, result, operator); rb_grn_context_check(context, self); rb_attr(rb_singleton_class(rb_result), rb_intern("expression"), RB_GRN_TRUE, RB_GRN_FALSE, RB_GRN_FALSE); rb_iv_set(rb_result, "@expression", rb_expression); return rb_result; }
// ---- File ---- VALUE rbhtp_file_initialize( VALUE self, VALUE raw_file ) { rb_iv_set( self, "@file", raw_file ); return Qnil; }
/* :nodoc: */ static VALUE counter_start(VALUE self) { rb_iv_set(self, "@st", rb_funcall(mSDL, rb_intern("getTicks"), 0)); rb_iv_set(self, "@counting", Qtrue); return self; }
static VALUE statement_Execute(VALUE self) { int i; CS_DATAFMT col; CS_DATAFMT *cols; EX_COLUMN_DATA *col_data; CS_INT rc; CS_INT resulttype; CS_INT num_cols; CS_INT col_len; CS_INT row_count = 0; CS_INT rows_read; CS_INT num_errors = 0; CS_SERVERMSG servermsg; VALUE err; char *error_msg; struct timeval start, stop; int print_rows = 1; char message[128]; char* buf; CS_DATEREC date_rec; char output[200]; CS_INT output_len; int tempInt; CS_BIGINT tempBigInt; double tempDouble; CS_NUMERIC tempNumeric; char* tempText; char* newTempText; int tempTextLen; CS_INT data_rc; int isNull = 0; CS_DATE tempDate; CS_DATETIME tempDateTime; TDS_Connection* conn; CS_COMMAND * cmd; VALUE connection; VALUE query; VALUE columns; VALUE rows; VALUE status; VALUE errors; VALUE date_parts[8]; VALUE column; VALUE row; VALUE column_name = rb_str_new2("name"); VALUE column_type = rb_str_new2("type"); VALUE column_size = rb_str_new2("size"); VALUE column_scale = rb_str_new2("scale"); VALUE column_precision = rb_str_new2("precision"); VALUE column_value; connection = rb_iv_get(self, "@connection"); query = rb_iv_get(self, "@query"); columns = rb_ary_new(); rb_iv_set(self, "@columns", columns); rows = rb_ary_new(); rb_iv_set(self, "@rows", rows); Data_Get_Struct(connection, TDS_Connection, conn); buf = value_to_cstr(query); rb_iv_set(self, "@status", Qnil); rb_iv_set(self, "@messages", rb_ary_new()); errors = rb_ary_new(); rb_iv_set(self, "@errors", errors); ct_diag(conn->connection, CS_INIT, CS_UNUSED, CS_UNUSED, NULL); // if ( ct_callback(conn->context, NULL, CS_SET, CS_CLIENTMSG_CB, (CS_VOID *)clientmsg_cb) != CS_SUCCEED ) { // error_message("ct_callback CS_CLIENTMSG_CB failed\n"); // } // if ( ct_callback(conn->context, NULL, CS_SET, CS_SERVERMSG_CB, (CS_VOID *)servermsg_cb) != CS_SUCCEED ) { // error_message("ct_callback CS_SERVERMSG_CB failed\n"); // } ct_cmd_alloc(conn->connection, &cmd); ct_command(cmd, CS_LANG_CMD, buf, CS_NULLTERM, CS_UNUSED); ct_send(cmd); if ( ct_diag(conn->connection, CS_STATUS, CS_SERVERMSG_TYPE, CS_UNUSED, &num_errors) != CS_SUCCEED ) { error_message("ct_diag CS_STATUS CS_SERVERMSG_TYPE failed"); } if (num_errors > 0) { // fprintf(stderr, "%d errors found\n", num_errors); for (i = 0; i < num_errors; i++) { if ( ct_diag(conn->connection, CS_GET, CS_SERVERMSG_TYPE, i+1, &servermsg) != CS_SUCCEED ) { error_message("ct_diag CS_GET CS_SERVERMSG_TYPE failed"); } if (servermsg.severity > 0) { // error_message(servermsg.text); rb_ary_push(errors, rb_str_new2(servermsg.text)); } } if ( ct_diag(conn->connection, CS_CLEAR, CS_SERVERMSG_TYPE, CS_UNUSED, NULL) != CS_SUCCEED ) { error_message("ct_diag CS_CLEAR CS_SERVERMSG_TYPE failed"); } } // Raise errors from ct_command/ct_send err = rb_funcall(errors, rb_intern("first"), 0); // FIXME: should probably display all errors instead of just first if(RTEST(err)) { error_msg = value_to_cstr(err); rb_raise(rb_eIOError, error_msg); ct_cmd_drop(cmd); return Qnil; } // TODO: // - We should have an array of malloc'd cols // - Then we bind / fetch to those // - Finish conversions... while ((rc = ct_results(cmd, &resulttype)) == CS_SUCCEED) { switch (resulttype) { case CS_ROW_RESULT: rc = ct_res_info(cmd, CS_NUMDATA, &num_cols, sizeof(num_cols), &col_len); if (rc != CS_SUCCEED) { fprintf(stderr, "ct_res_info() failed\n"); return 1; } col_data = (EX_COLUMN_DATA *)malloc(num_cols * sizeof (EX_COLUMN_DATA)); if (col_data == NULL) { fprintf(stderr, "ex_fetch_data: malloc() failed"); return CS_MEM_ERROR; } cols = (CS_DATAFMT *)malloc(num_cols * sizeof (CS_DATAFMT)); if (cols == NULL) { fprintf(stderr, "ex_fetch_data: malloc() failed"); free(col_data); return CS_MEM_ERROR; } // Get column information for (i = 0; i < num_cols; i++) { rc = ct_describe(cmd, (i+1), &cols[i]); if ( rc != CS_SUCCEED ) { fprintf(stderr, "ct_describe failed on col #%d", i+1); } column_value = rb_hash_new(); // fprintf(stderr, "%s\n", cols[i].name); if (cols[i].name) { rb_hash_aset(column_value, column_name, rb_str_new2(cols[i].name)); } else { rb_hash_aset(column_value, column_name, Qnil); } rb_hash_aset(column_value, column_type, rb_str_new2(column_type_name(cols[i]))); rb_hash_aset(column_value, column_size, INT2FIX(cols[i].maxlength)); rb_hash_aset(column_value, column_scale, INT2FIX(cols[i].scale)); rb_hash_aset(column_value, column_precision, INT2FIX(cols[i].precision)); rb_ary_push(columns, column_value); } // Fetch data while (((rc = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &rows_read)) == CS_SUCCEED) || (rc == CS_ROW_FAIL)) { row_count = row_count + rows_read; row = rb_hash_new(); rb_ary_push(rows, row); // Create Ruby objects for (i = 0; i < num_cols; i++) { // if (col_data[i].indicator == -1) { // rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); // continue; // } switch (cols[i].datatype) { case CS_TINYINT_TYPE: case CS_BIT_TYPE: data_rc = ct_get_data(cmd, (i + 1), &tempInt, sizeof(tempInt), &output_len); if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } else { if(tempInt == 1) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qtrue); } else { rb_hash_aset(row, rb_str_new2(cols[i].name), Qfalse); } } tempInt = -1; break; case CS_INT_TYPE: case CS_SMALLINT_TYPE: data_rc = ct_get_data(cmd, (i + 1), &tempInt, sizeof(tempInt), &output_len); if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } else { rb_hash_aset(row, rb_str_new2(cols[i].name), INT2FIX(tempInt)); } tempInt = -1; break; case CS_DATETIME_TYPE: case CS_DATETIME4_TYPE: data_rc = ct_get_data(cmd, (i + 1), &tempDateTime, sizeof(tempDateTime), &output_len); if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } else { if ( cs_dt_crack(conn->context, CS_DATETIME_TYPE, &tempDateTime, &date_rec) == CS_SUCCEED ) { if(date_rec.dateyear && date_rec.datemonth && date_rec.datedmonth) { date_parts[0] = INT2FIX(date_rec.dateyear); date_parts[1] = INT2FIX(date_rec.datemonth+1); date_parts[2] = INT2FIX(date_rec.datedmonth); date_parts[3] = INT2FIX(date_rec.datehour); date_parts[4] = INT2FIX(date_rec.dateminute); date_parts[5] = INT2FIX(date_rec.datesecond); date_parts[6] = INT2FIX(date_rec.datemsecond); date_parts[7] = INT2FIX(date_rec.datetzone); // String (fastest known so far, but pushes the burden to ActiveRecord for parsing) sprintf(output, "%d-%02d-%02d %02d:%02d:%02d.%03d", date_rec.dateyear, date_rec.datemonth+1, date_rec.datedmonth, date_rec.datehour, date_rec.dateminute, date_rec.datesecond, date_rec.datemsecond); rb_hash_aset(row, rb_str_new2(cols[i].name), rb_str_new2(output)); // DateTime - this is slow a f*ck //rb_hash_aset(row, rb_str_new2(cols[i].name), rb_funcall2(rb_DateTime, rb_intern("civil"), 6, &date_parts[0])); // Time - way faster than DateTime // FIXME: should we be assuming utc?! // rb_hash_aset(row, rb_str_new2(cols[i].name), rb_funcall2(rb_cTime, rb_intern("utc"), 6, &date_parts[0])); } else { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } } else { fprintf(stderr, "cs_dt_crack failed\n"); } } // tempDateTime = 0; // not sure how to clear this... break; // case CS_REAL_TYPE: case CS_FLOAT_TYPE: // case CS_MONEY_TYPE: // case CS_MONEY4_TYPE: data_rc = ct_get_data(cmd, (i + 1), &tempDouble, sizeof(tempDouble), &output_len); if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } else { rb_hash_aset(row, rb_str_new2(cols[i].name), rb_float_new(tempDouble)); } tempDouble = -1.0; break; // case CS_BIGINT_TYPE: // error_message("HELLO BIGINT!"); // break; case CS_DECIMAL_TYPE: case CS_NUMERIC_TYPE: // fprintf(stderr, "CS_NUMERIC_TYPE detected - name: %s\n", cols[i].name); data_rc = ct_get_data(cmd, (i + 1), &tempNumeric, sizeof(tempNumeric), &output_len); if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } else { // fprintf(stderr, "tempNumeric output_len: %d, precision: %d, scale: %d, array: %s\n", output_len, tempNumeric.precision, tempNumeric.scale, tempNumeric.array); col.datatype = CS_CHAR_TYPE; col.format = CS_FMT_NULLTERM; col.maxlength = 200; // col.maxlength = cols[i].precision + 1; data_rc = cs_convert(conn->context, &cols[i], &tempNumeric, &col, output, &output_len); if ( data_rc != CS_SUCCEED ) { error_message("CS_NUMERIC_TYPE conversion failed"); fprintf(stderr, "cs_convert returned: %d\n", data_rc); } // fprintf(stderr, "numeric output_len: %d, output: %s\n", output_len, output); rb_hash_aset(row, rb_str_new2(cols[i].name), LL2NUM(strtoll(output, NULL, 10))); } break; case CS_CHAR_TYPE: case CS_LONGCHAR_TYPE: case CS_TEXT_TYPE: case CS_VARCHAR_TYPE: case CS_UNICHAR_TYPE: case CS_UNIQUE_TYPE: // @todo should this one be handled differently? isNull = 0; tempTextLen = 1; // 1 for \0 do { newTempText = realloc((tempTextLen == 1 ? NULL : tempText), tempTextLen + (1000 * sizeof(char))); // allocate another 1000 chars if (newTempText != NULL) { tempText = newTempText; } else { fprintf(stderr, "realloc error\n"); } data_rc = ct_get_data(cmd, (i + 1), tempText + tempTextLen - 1, 1000, &output_len); if (tempTextLen == 1 && output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) { isNull = 1; } tempTextLen = tempTextLen + output_len; } while (data_rc == CS_SUCCEED); if (data_rc != CS_END_DATA && data_rc != CS_END_ITEM) { fprintf(stderr, "ct_get_data failed, data_rc = %d\n", data_rc); return data_rc; } tempText[tempTextLen-1] = '\0'; if (isNull == 1) { rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); } else { rb_hash_aset(row, rb_str_new2(cols[i].name), rb_str_new2(tempText)); } free(tempText); tempText = NULL; break; case CS_BINARY_TYPE: case CS_LONGBINARY_TYPE: case CS_VARBINARY_TYPE: case CS_IMAGE_TYPE: // rb_hash_aset(row, rb_str_new2(tds->res_info->columns[i]->column_name), rb_str_new((char *) ((TDSBLOB *) src)->textvalue, tds->res_info->columns[i]->column_cur_size)); rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); break; default: rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil); printf("\nUnexpected datatype: %d\n", cols[i].datatype); } } } if( rc != CS_END_DATA ) { fprintf(stderr, "ct_fetch failed"); } free(cols); cols = NULL; free(col_data); col_data = NULL; break; case CS_CMD_SUCCEED: rb_iv_set(self, "@status", Qnil); break; case CS_CMD_FAIL: if ( ct_diag(conn->connection, CS_STATUS, CS_SERVERMSG_TYPE, CS_UNUSED, &num_errors) != CS_SUCCEED ) { error_message("ct_diag CS_STATUS CS_SERVERMSG_TYPE failed"); } if (num_errors > 0) { // fprintf(stderr, "%d errors found\n", num_errors); for (i = 0; i < num_errors; i++) { if ( ct_diag(conn->connection, CS_GET, CS_SERVERMSG_TYPE, i+1, &servermsg) != CS_SUCCEED ) { error_message("ct_diag CS_GET CS_SERVERMSG_TYPE failed"); } if (servermsg.severity > 0) { // error_message(servermsg.text); rb_ary_push(errors, rb_str_new2(servermsg.text)); } } if ( ct_diag(conn->connection, CS_CLEAR, CS_SERVERMSG_TYPE, CS_UNUSED, NULL) != CS_SUCCEED ) { error_message("ct_diag CS_CLEAR CS_SERVERMSG_TYPE failed"); } } err = rb_funcall(errors, rb_intern("first"), 0); // FIXME: should probably display all errors instead of just first if(RTEST(err)) { error_msg = value_to_cstr(err); rb_raise(rb_eIOError, error_msg); } else { rb_raise(rb_eIOError, "CS_CMD_FAIL without server error message"); } // rb_iv_set(self, "@status", INT2FIX(0)); break; case CS_CMD_DONE: rb_iv_set(self, "@status", Qnil); break; case CS_STATUS_RESULT: // FIXME: We should probably do something here, right? break; default: fprintf(stderr, "ct_results returned unexpected result type: %d\n", resulttype); break; } } ct_cmd_drop(cmd); return Qnil; }
static VALUE connection_Initialize(VALUE self, VALUE connection_hash) { TDS_Connection* conn; char *servername = NULL; char *username = NULL; char *password = NULL; char *confile = NULL; char *charset = NULL; VALUE temp; VALUE errors; CS_RETCODE ret; Data_Get_Struct(self, TDS_Connection, conn); cs_ctx_alloc(CS_VERSION_100, &conn->context); ct_init(conn->context, CS_VERSION_100); ct_con_alloc(conn->context, &conn->connection); // conn->context->msg_handler = connection_handle_message; // conn->context->err_handler = connection_handle_message; /* now let's get the connection parameters */ temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("username"))); username = value_to_cstr(temp); temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("password"))); password = value_to_cstr(temp); temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("servername"))); servername = value_to_cstr(temp); temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("charset"))); charset = value_to_cstr(temp); if(charset==NULL) { charset = strdup("ISO-8859-1"); } /* validate parameters */ if (!servername) { rb_raise(rb_eArgError, "You must specify a servername"); return Qnil; } if (!username) { rb_raise(rb_eArgError, "No username specified"); return Qnil; } if (!password) { password = strdup(""); } // printf("*** servername='%s', username='******' password='******'\n", servername, username, password); ct_con_props(conn->connection, CS_SET, CS_USERNAME, username, CS_NULLTERM, NULL); ct_con_props(conn->connection, CS_SET, CS_PASSWORD, password, CS_NULLTERM, NULL); /* Try to open a connection */ ret = ct_connect(conn->connection, servername, CS_NULLTERM); /* free up all the memory */ if (username) { free(username); username = NULL; } if (password) { free(password); password = NULL; } if (servername) { free(servername); } if(ret!=CS_SUCCEED) { rb_raise(rb_eIOError, "Connection failed"); return Qnil; } rb_iv_set(self, "@messages", rb_ary_new()); errors = rb_ary_new(); rb_iv_set(self, "@errors", errors); return Qnil; }
VALUE Extension1_initialize(VALUE self) { rb_iv_set(self,"@test",1); rb_iv_set(self,"@test2",2); return self; }
/** * Call QuantizeImages. * * Ruby usage: * - @verbatim ImageList#quantize @endverbatim * - @verbatim ImageList#quantize(number_colors) @endverbatim * - @verbatim ImageList#quantize(number_colors, colorspace) @endverbatim * - @verbatim ImageList#quantize(number_colors, colorspace, dither) @endverbatim * - @verbatim ImageList#quantize(number_colors, colorspace, dither, tree_depth) @endverbatim * - @verbatim ImageList#quantize(number_colors, colorspace, dither, tree_depth, measure_error) @endverbatim * * Notes: * - Default number_colors is 256 * - Default coorspace is Magick::RGBColorsapce * - Default dither is true * - Default tree_depth is 0 * - Default measure_error is false * - Sets \@scene to the same value as self.scene * * @param argc number of input arguments * @param argv array of input arguments * @param self this object * @return a new ImageList with quantized images */ VALUE ImageList_quantize(int argc, VALUE *argv, VALUE self) { Image *images, *new_images; Image *new_image; QuantizeInfo quantize_info; ExceptionInfo *exception; VALUE new_imagelist, scene; GetQuantizeInfo(&quantize_info); switch (argc) { case 5: quantize_info.measure_error = (MagickBooleanType) RTEST(argv[4]); case 4: quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]); case 3: #if defined(HAVE_TYPE_DITHERMETHOD) && defined(HAVE_ENUM_NODITHERMETHOD) if (rb_obj_is_kind_of(argv[2], Class_DitherMethod)) { VALUE_TO_ENUM(argv[2], quantize_info.dither_method, DitherMethod); quantize_info.dither = quantize_info.dither_method != NoDitherMethod; } #else quantize_info.dither = (MagickBooleanType) RTEST(argv[2]); #endif case 2: VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType); case 1: quantize_info.number_colors = NUM2ULONG(argv[0]); case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 5)", argc); break; } // Convert image array to image sequence, clone image sequence. exception = AcquireExceptionInfo(); images = images_from_imagelist(self); new_images = CloneImageList(images, exception); rm_split(images); rm_check_exception(exception, new_images, DestroyOnError); rm_ensure_result(new_images); (void) QuantizeImages(&quantize_info, new_images); rm_check_exception(exception, new_images, DestroyOnError); (void) DestroyExceptionInfo(exception); // Create new ImageList object, convert mapped image sequence to images, // append to images array. new_imagelist = ImageList_new(); while ((new_image = RemoveFirstImageFromList(&new_images))) { imagelist_push(new_imagelist, rm_image_new(new_image)); } // Set @scene in new ImageList object to same value as in self. scene = rb_iv_get(self, "@scene"); (void) rb_iv_set(new_imagelist, "@scene", scene); RB_GC_GUARD(new_imagelist); RB_GC_GUARD(scene); return new_imagelist; }
VALUE ruv_buffer_write(int argc, VALUE* argv, VALUE rb_buffer) { VALUE rb_str, rb_offset, rb_length, rb_extern_enc, rb_cBuffer; size_t offset, length, max_length, char_count; ruv_buffer_t *buffer; rb_encoding *rb_extern_encoding; Data_Get_Struct(rb_buffer, ruv_buffer_t, buffer); rb_scan_args(argc, argv, "13", &rb_str, &rb_offset, &rb_length, &rb_extern_enc); StringValue(rb_str); // encoding: use specified external encoding if provided // otherwise use Encoding.default_external as default if(!NIL_P(rb_extern_enc)) { rb_extern_encoding = rb_enc_get(rb_extern_enc); } else { rb_extern_encoding = rb_default_external_encoding(); } // convert to external encoding rb_str = rb_str_export_to_enc(rb_str, rb_extern_encoding); // offset: either specified in params or 0 if(!NIL_P(rb_offset)) { Check_Type(rb_offset, T_FIXNUM); offset = NUM2SIZET(rb_offset); if(offset >= buffer->length) { rb_raise(rb_eArgError, "Overflow! offset is larger than buffer size."); } } else { offset = 0; } // max length: the smaller of the max available space or the whole ruby string max_length = MIN(buffer->length - offset, (size_t)RSTRING_LEN(rb_str)); // length: number of bytes to write. (include half chars) if(!NIL_P(rb_length)) { Check_Type(rb_length, T_FIXNUM); length = NUM2SIZET(rb_length); } else { length = max_length; } // If we are not writing the whole string into the buffer, // re-adjust length so we don't write half a character (uft8, etc) // 1). get char count from calculated byte length // 2). get byte length back from char count // This way only whole char is written to buffer if(length != (size_t)RSTRING_LEN(rb_str)) { char_count = rb_str_sublen(rb_str, length); length = rb_str_offset(rb_str, char_count); } memcpy(buffer->data + offset, RSTRING_PTR(rb_str), length); // set instance variable so we know how much characters are written rb_cBuffer = rb_obj_class(rb_buffer); rb_iv_set(rb_cBuffer, RUV_BUFFER_CHAR_WRITTEN_SYM, SIZET2NUM(char_count)); return SIZET2NUM(length); }
// ---- Header Line ---- VALUE rbhtp_header_line_initialize( VALUE self, VALUE raw_header_line ) { rb_iv_set( self, "@header_line", raw_header_line ); return Qnil; }
// ---- URI ---- VALUE rbhtp_uri_initialize( VALUE self, VALUE raw_uri ) { rb_iv_set( self, "@uri", raw_uri ); return Qnil; }
/* :nodoc: */ static VALUE counter_stop(VALUE self) { rb_iv_set(self, "@st", INT2NUM(0)); rb_iv_set(self, "@counting", Qfalse); return self; }
// ---- Conn ---- VALUE rbhtp_conn_initialize( VALUE self, VALUE raw_conn, VALUE connp ) { rb_iv_set( self, "@conn", raw_conn ); rb_iv_set( self, "@connp", connp ); return Qnil; }
VALUE Service_initialize(VALUE self, VALUE path) { rb_iv_set(self, "@path", path); return self; }
/* * call-seq: * Groonga::Snippet.new(options={}) * * スニペットを作成する。_options_に指定可能な値は以下の通 * り。 * * [+:context+] * スキーマ作成時に使用するGroonga::Contextを指定する。 * 省略した場合はGroonga::Context.defaultを使用する。 * * [+:normalize+] * キーワード文字列・スニペット元の文字列を正規化するかど * うか。省略した場合は+false+で正規化しない。 * * [+:skip_leading_spaces+] * 先頭の空白を無視するかどうか。省略した場合は+false+で無 * 視しない。 * * [+:width+] * スニペット文字列の長さ。省略した場合は100文字。 * * [+:max_results+] * 生成するスニペットの最大数。省略した場合は3。 * * [+:html_escape+] * スニペット内の+<+, +>+, +&+, +"+をHTMLエスケープするか * どうか。省略した場合は+false+で、HTMLエスケープしない。 * * [+:default_open_tag+] * デフォルトの開始タグ。省略した場合は""(空文字列) * * [+:default_close_tag+] * デフォルトの終了タグ。省略した場合は""(空文字列) */ static VALUE rb_grn_snippet_initialize (int argc, VALUE *argv, VALUE self) { RbGrnSnippet *rb_grn_snippet; grn_ctx *context = NULL; grn_snip *snippet = NULL; VALUE options; VALUE rb_context, rb_normalize, rb_skip_leading_spaces; VALUE rb_width, rb_max_results, rb_default_open_tag, rb_default_close_tag; VALUE rb_html_escape; int flags = GRN_SNIP_COPY_TAG; unsigned int width = 100; unsigned int max_results = 3; char *default_open_tag = NULL; unsigned int default_open_tag_length = 0; char *default_close_tag = NULL; unsigned int default_close_tag_length = 0; grn_snip_mapping *mapping = NULL; rb_scan_args(argc, argv, "01", &options); rb_grn_scan_options(options, "context", &rb_context, "normalize", &rb_normalize, "skip_leading_spaces", &rb_skip_leading_spaces, "width", &rb_width, "max_results", &rb_max_results, "default_open_tag", &rb_default_open_tag, "default_close_tag", &rb_default_close_tag, "html_escape", &rb_html_escape, NULL); context = rb_grn_context_ensure(&rb_context); if (RVAL2CBOOL(rb_normalize)) flags |= GRN_SNIP_NORMALIZE; if (RVAL2CBOOL(rb_skip_leading_spaces)) flags |= GRN_SNIP_SKIP_LEADING_SPACES; if (!NIL_P(rb_width)) width = NUM2UINT(rb_width); if (!NIL_P(rb_max_results)) max_results = NUM2UINT(rb_max_results); if (!NIL_P(rb_default_open_tag)) { default_open_tag = StringValuePtr(rb_default_open_tag); default_open_tag_length = RSTRING_LEN(rb_default_open_tag); } if (!NIL_P(rb_default_close_tag)) { default_close_tag = StringValuePtr(rb_default_close_tag); default_close_tag_length = RSTRING_LEN(rb_default_close_tag); } if (RVAL2CBOOL(rb_html_escape)) mapping = (grn_snip_mapping *)-1; snippet = grn_snip_open(context, flags, width, max_results, default_open_tag, default_open_tag_length, default_close_tag, default_close_tag_length, mapping); rb_grn_context_check(context, rb_ary_new4(argc, argv)); rb_grn_snippet = ALLOC(RbGrnSnippet); DATA_PTR(self) = rb_grn_snippet; rb_grn_snippet->context = context; rb_grn_snippet->snippet = snippet; rb_grn_snippet->owner = RB_GRN_TRUE; rb_iv_set(self, "@context", rb_context); return Qnil; }
static VALUE cDO_OracleCommand_execute_reader(int argc, VALUE *argv[], VALUE self) { VALUE reader, query; VALUE field_names, field_types; VALUE column_metadata, column, column_name; int i; long field_count; int infer_types = 0; VALUE cursor = rb_funcall2(self, DO_ID_EXECUTE, argc, (VALUE *)argv); if (rb_obj_class(cursor) != cOCI8_Cursor) { rb_raise(eArgumentError, "\"%s\" is invalid SELECT query", StringValuePtr(query)); } column_metadata = rb_funcall(cursor, DO_ID_COLUMN_METADATA, 0); field_count = RARRAY_LEN(column_metadata); // reduce field_count by 1 if RAW_RNUM_ is present as last column // (generated by DataMapper to simulate LIMIT and OFFSET) column = rb_ary_entry(column_metadata, field_count-1); column_name = rb_funcall(column, DO_ID_NAME, 0); if (strncmp(RSTRING_PTR(column_name), "RAW_RNUM_", RSTRING_LEN(column_name)) == 0) field_count--; reader = rb_funcall(cDO_OracleReader, DO_ID_NEW, 0); rb_iv_set(reader, "@reader", cursor); rb_iv_set(reader, "@field_count", INT2NUM(field_count)); field_names = rb_ary_new(); field_types = rb_iv_get(self, "@field_types"); if ( field_types == Qnil || 0 == RARRAY_LEN(field_types) ) { field_types = rb_ary_new(); infer_types = 1; } else if (RARRAY_LEN(field_types) != field_count) { // Whoops... wrong number of types passed to set_types. Close the reader and raise // and error rb_funcall(reader, DO_ID_CLOSE, 0); rb_raise(eArgumentError, "Field-count mismatch. Expected %ld fields, but the query yielded %ld", RARRAY_LEN(field_types), field_count); } for ( i = 0; i < field_count; i++ ) { column = rb_ary_entry(column_metadata, i); column_name = rb_funcall(column, DO_ID_NAME, 0); rb_ary_push(field_names, column_name); if ( infer_types == 1 ) { rb_ary_push(field_types, infer_ruby_type(rb_iv_get(column, "@data_type"), rb_funcall(column, DO_ID_PRECISION, 0), rb_funcall(column, DO_ID_SCALE, 0)) ); } } rb_iv_set(reader, "@position", INT2NUM(0)); rb_iv_set(reader, "@fields", field_names); rb_iv_set(reader, "@field_types", field_types); rb_iv_set(reader, "@last_row", Qfalse); return reader; }
static VALUE cDO_OracleConnection_initialize(VALUE self, VALUE uri) { VALUE r_host, r_port, r_path, r_user, r_password; VALUE r_query, r_time_zone; char *non_blocking = NULL; char *time_zone = NULL; char set_time_zone_command[80]; char *host = "localhost", *port = "1521", *path = NULL; char *connect_string; long connect_string_length; VALUE oci8_conn; r_user = rb_funcall(uri, rb_intern("user"), 0); r_password = rb_funcall(uri, rb_intern("password"), 0); r_host = rb_funcall(uri, rb_intern("host"), 0); if ( Qnil != r_host && RSTRING_LEN(r_host) > 0) { host = StringValuePtr(r_host); } r_port = rb_funcall(uri, rb_intern("port"), 0); if ( Qnil != r_port ) { r_port = rb_funcall(r_port, DO_ID_TO_S, 0); port = StringValuePtr(r_port); } r_path = rb_funcall(uri, rb_intern("path"), 0); if ( Qnil != r_path ) { path = StringValuePtr(r_path); } // If just host name is specified then use it as TNS names alias if ((r_host != Qnil && RSTRING_LEN(r_host) > 0) && (r_port == Qnil) && (r_path == Qnil || RSTRING_LEN(r_path) == 0)) { connect_string = host; // If database name is specified in path (in format "/database") } else if (path != NULL && strlen(path) > 1) { connect_string_length = strlen(host) + strlen(port) + strlen(path) + 4; connect_string = (char *)calloc(connect_string_length, sizeof(char)); snprintf(connect_string, connect_string_length, "//%s:%s%s", host, port, path); } else { rb_raise(eDO_ConnectionError, "Database must be specified"); } // oci8_conn = rb_funcall(cOCI8, DO_ID_NEW, 3, r_user, r_password, RUBY_STRING(connect_string)); oci8_conn = rb_funcall(cDO_OracleConnection, rb_intern("oci8_new"), 3, r_user, r_password, RUBY_STRING(connect_string)); // Pull the querystring off the URI r_query = rb_funcall(uri, rb_intern("query"), 0); non_blocking = get_uri_option(r_query, "non_blocking"); // Enable non-blocking mode if (non_blocking != NULL && strcmp(non_blocking, "true") == 0) rb_funcall(oci8_conn, rb_intern("non_blocking="), 1, Qtrue); // By default enable auto-commit mode rb_funcall(oci8_conn, rb_intern("autocommit="), 1, Qtrue); // Set prefetch rows to 100 to increase fetching performance SELECTs with many rows rb_funcall(oci8_conn, rb_intern("prefetch_rows="), 1, INT2NUM(100)); // Set session time zone // at first look for option in connection string time_zone = get_uri_option(r_query, "time_zone"); rb_iv_set(self, "@uri", uri); rb_iv_set(self, "@connection", oci8_conn); // if no option specified then look in ENV['TZ'] if (time_zone == NULL) { r_time_zone = rb_funcall(cDO_OracleConnection, rb_intern("ruby_time_zone"), 0); if (!NIL_P(r_time_zone)) time_zone = StringValuePtr(r_time_zone); } if (time_zone) { snprintf(set_time_zone_command, 80, "alter session set time_zone = '%s'", time_zone); execute_sql(self, RUBY_STRING(set_time_zone_command)); } execute_sql(self, RUBY_STRING("alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'")); execute_sql(self, RUBY_STRING("alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS.FF'")); execute_sql(self, RUBY_STRING("alter session set nls_timestamp_tz_format = 'YYYY-MM-DD HH24:MI:SS.FF TZH:TZM'")); return Qtrue; }
static VALUE ossl_x509store_set_time(VALUE self, VALUE time) { rb_iv_set(self, "@time", time); return time; }
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, defaults; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *conn_enc; #endif GET_CLIENT(self); REQUIRE_OPEN_DB(wrapper); args.mysql = wrapper->client; defaults = rb_iv_get(self, "@query_options"); if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) { opts = rb_funcall(defaults, intern_merge, 1, opts); rb_iv_set(self, "@query_options", opts); if (rb_hash_aref(opts, sym_async) == Qtrue) { async = 1; } } else { opts = defaults; } 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 // see if this connection is still waiting on a result from a previous query if (wrapper->active == 0) { // mark this connection active wrapper->active = 1; } else { rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result"); } args.wrapper = wrapper; rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0); #ifndef _WIN32 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 // this will just block until the result is ready return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self); #endif }
/* * When a flow is deleted or expired a +OFPT_FLOW_REMOVED+ message is sent as long * as the +OFPFF_SEND_FLOW_REM+ bit is toggled in the +flags+ bitmap during * flow setup. A user would not explicitly instantiate a {FlowRemoved} object but * would be created while parsing the +OPPT_FLOW_REMOVED+ message. * Returns an object that encapsulates the +OPPT_FLOW_REMOVED+ OpenFlow message. * * @overload initialize(options={}) * @example * FlowRemoved.new( * :datapath_id => 0xabc, * :transaction_id => 0, * :match => Match, * :cookie => 123456789, * :priority => 65535, * :reason => 0, * :duration_sec => 1, * :duration_nsec => 783000000, * :idle_timeout => 1, * :packet_count => 1 * :byte_count=> 64 * ) * * @param [Hash] options * the options to create a message with. * * @option options [Symbol] :datapath_id * message originator identifier. * * @option options [Symbol] :transaction_id * unsolicited message transaction_id is zero. * * @option options [Symbol] :match * a {Match} object describing the flow fields copied from the corresponding * flow setup message. * * @option options [Symbol] :cookie * an opaque handle copied from the corresponding * flow setup message. * * @option options [Symbol] :priority * the priority level of the flow copied from the corresponding * flow setup message. * * @option options [Symbol] :reason * the reason why the flow is removed. * * @option options [Symbol] :duration_sec * the number of seconds the flow was active. * * @option options [Symbol] :duration_nsec * the number of nanoseconds the flow was active. * * @option options [Symbol] :idle_timeout * time elapsed in seconds before the flow is removed, copied from the * corresponding flow setup message. * * @option options [Symbol] :packet_count * a counter of the total number of packets. * * @option options [Symbol] :byte_count * a counter of the total number of bytes. * * @return [FlowRemoved] self */ static VALUE flow_removed_init( VALUE self, VALUE options ) { rb_iv_set( self, "@attribute", options ); return self; }
static VALUE rg_set_unlock_gvl(VALUE self, VALUE rb_boolean) { return rb_iv_set(self, "unlock_gvl", rb_boolean); }
static VALUE exc_set_backtrace(VALUE exc, VALUE bt) { return rb_iv_set(exc, "bt", rb_check_backtrace(bt)); }