VALUE
pg_tmbc_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
{
t_pg_coder *p_coder = NULL;
t_pg_result *p_result = pgresult_get_this(result);
t_tmbc *this = (t_tmbc *) p_typemap;
t_typemap *default_tm;
if (PQgetisnull(p_result->pgresult, tuple, field)) {
return Qnil;
}
p_coder = this->convs[field].cconv;
if( p_coder ){
char * val = PQgetvalue( p_result->pgresult, tuple, field );
int len = PQgetlength( p_result->pgresult, tuple, field );
if( p_coder->dec_func ){
return p_coder->dec_func(p_coder, val, len, tuple, field, ENCODING_GET(result));
} else {
t_pg_coder_dec_func dec_func;
dec_func = pg_coder_dec_func( p_coder, PQfformat(p_result->pgresult, field) );
return dec_func(p_coder, val, len, tuple, field, ENCODING_GET(result));
}
}
default_tm = DATA_PTR( this->typemap.default_typemap );
return default_tm->funcs.typecast_result_value( default_tm, result, tuple, field );
}
VALUE
pg_new_result_autoclear(PGresult *result, VALUE rb_pgconn)
{
VALUE self = pg_new_result(result, rb_pgconn);
t_pg_result *this = pgresult_get_this(self);
this->autoclear = 1;
return self;
}
/*
* call-seq:
* res.clear() -> nil
*
* Clears the PG::Result object as the result of the query.
*
* If PG::Result#autoclear? is true then the result is marked as cleared
* and the underlying C struct will be cleared automatically by libpq.
*
*/
VALUE
pg_result_clear(VALUE self)
{
t_pg_result *this = pgresult_get_this(self);
if( !this->autoclear )
PQclear(pgresult_get(self));
this->pgresult = NULL;
return Qnil;
}
/*
* call-seq:
* res.check -> nil
*
* Raises appropriate exception if PG::Result is in a bad state.
*/
VALUE
pg_result_check( VALUE self )
{
t_pg_result *this = pgresult_get_this(self);
VALUE error, exception, klass;
char * sqlstate;
if(this->pgresult == NULL)
{
PGconn *conn = pg_get_pgconn(this->connection);
error = rb_str_new2( PQerrorMessage(conn) );
}
else
{
switch (PQresultStatus(this->pgresult))
{
case PGRES_TUPLES_OK:
case PGRES_COPY_OUT:
case PGRES_COPY_IN:
#ifdef HAVE_CONST_PGRES_COPY_BOTH
case PGRES_COPY_BOTH:
#endif
#ifdef HAVE_CONST_PGRES_SINGLE_TUPLE
case PGRES_SINGLE_TUPLE:
#endif
case PGRES_EMPTY_QUERY:
case PGRES_COMMAND_OK:
return self;
case PGRES_BAD_RESPONSE:
case PGRES_FATAL_ERROR:
case PGRES_NONFATAL_ERROR:
error = rb_str_new2( PQresultErrorMessage(this->pgresult) );
break;
default:
error = rb_str_new2( "internal error : unknown result status." );
}
}
PG_ENCODING_SET_NOCHECK( error, ENCODING_GET(self) );
sqlstate = PQresultErrorField( this->pgresult, PG_DIAG_SQLSTATE );
klass = lookup_error_class( sqlstate );
exception = rb_exc_new3( klass, error );
rb_iv_set( exception, "@connection", this->connection );
rb_iv_set( exception, "@result", this->pgresult ? self : Qnil );
rb_exc_raise( exception );
/* Not reached */
return self;
}
static VALUE
pg_tmas_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
{
VALUE ret;
char * val;
int len;
t_pg_result *p_result = pgresult_get_this(result);
if (PQgetisnull(p_result->pgresult, tuple, field)) {
return Qnil;
}
val = PQgetvalue( p_result->pgresult, tuple, field );
len = PQgetlength( p_result->pgresult, tuple, field );
if ( 0 == PQfformat(p_result->pgresult, field) ) {
ret = pg_text_dec_string(NULL, val, len, tuple, field, ENCODING_GET(result));
} else {
ret = pg_bin_dec_bytea(NULL, val, len, tuple, field, ENCODING_GET(result));
}
return ret;
}
/*
* call-seq:
* res.autoclear? -> boolean
*
* Returns +true+ if the underlying C struct will be cleared automatically by libpq.
* Elsewise the result is cleared by PG::Result#clear or by the GC when it's no longer in use.
*
*/
VALUE
pgresult_autoclear_p( VALUE self )
{
t_pg_result *this = pgresult_get_this(self);
return this->autoclear ? Qtrue : Qfalse;
}
/*
* call-seq:
* res.cleared? -> boolean
*
* Returns +true+ if the backend result memory has been free'd.
*/
VALUE
pgresult_cleared_p( VALUE self )
{
t_pg_result *this = pgresult_get_this(self);
return this->pgresult ? Qfalse : Qtrue;
}
