#include "net_drizzle.h"
=pod
=head1 NAME
Net::Drizzle::Result - result object for Net::Drizzle
=head1 METHODS
=over 4
=cut
MODULE = Net::Drizzle::Result PACKAGE = Net::Drizzle::Result
VERSIONCHECK: DISABLE
=item my $column = $result->column_next();
Get next buffered column from a result structure.
=cut
net_col*
column_next(SV *self_sv)
CODE:
net_result *self_result = XS_STATE(net_result*, self_sv);
drizzle_result_st *result = self_result->result;
drizzle_column_st * col = drizzle_column_next(result);
if (col) {
RETVAL = _create_col(self_sv, col);
} else {
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
=item my $err = $result->error_code();
get the error code for result.
=cut
int
error_code(net_result *self)
CODE:
drizzle_result_st *result = self->result;
if (result == NULL) {
Perl_croak(aTHX_ "result is null");
}
RETVAL = drizzle_result_error_code(result);
OUTPUT:
RETVAL
=item my $err = $result->error();
get the error message for result.
=cut
const char*
error(net_result *self)
CODE:
drizzle_result_st *result = self->result;
RETVAL = drizzle_result_error(result);
OUTPUT:
RETVAL
=item my $info = $result->info();
get the info message.
=cut
const char*
info(net_result *self)
CODE:
drizzle_result_st *result = self->result;
RETVAL = drizzle_result_info(result);
OUTPUT:
RETVAL
uint64_t
row_count(net_result *self)
CODE:
drizzle_result_st *result = self->result;
RETVAL = drizzle_result_row_count(result);
OUTPUT:
RETVAL
uint64_t
insert_id(net_result *self)
CODE:
drizzle_result_st *result = self->result;
RETVAL = drizzle_result_insert_id(result);
OUTPUT:
RETVAL
uint16_t
warning_count(net_result *self)
CODE:
drizzle_result_st *result = self->result;
RETVAL = drizzle_result_warning_count(result);
OUTPUT:
RETVAL
=item my $column_count = $result->column_count();
get the number of columns.
=cut
unsigned int
column_count(net_result *self)
CODE:
drizzle_result_st *result = self->result;
RETVAL = drizzle_result_column_count(result);
OUTPUT:
RETVAL
=item $result->buffer();
Buffer all data for a result.
=cut
drizzle_return_t
buffer(net_result *self)
CODE:
drizzle_result_st *result = self->result;
drizzle_return_t ret = drizzle_result_buffer(result);
if (ret != DRIZZLE_RETURN_OK) {
drizzle_con_st * con = drizzle_result_drizzle_con(result);
drizzle_st * drizzle = drizzle_con_drizzle(con);
Perl_croak(aTHX_ "drizzle_result_buffer:%s\n", drizzle_error(drizzle));
}
RETVAL = ret;
OUTPUT:
RETVAL
=item my $col = $result->column_read();
Read column information.
=cut
net_col*
column_read(SV *self_sv)
CODE:
net_result * self_result = XS_STATE(net_result *, self_sv);
drizzle_result_st *result = self_result->result;
drizzle_return_t ret;
drizzle_column_st *col = drizzle_column_read(result, NULL, &ret);
if (col != NULL) {
RETVAL = _create_col(self_sv, col);
} else {
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
=item $result->row_next();
Get next buffered row from a fully buffered result.
=item $result->fetchrow_arrayref();
alias of row_next() for DBI users
=cut
SV*
row_next(net_result *self)
CODE:
drizzle_result_st *result = self->result;
drizzle_row_t row = drizzle_row_next(result);
uint16_t cnt = drizzle_result_column_count(result);
if (row) {
RETVAL = row2arrayref(row, cnt);
} else {
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
=item row_buffer
Buffer one row.
=cut
SV*
row_buffer(net_result *self)
CODE:
drizzle_result_st *result = self->result;
drizzle_return_t ret;
drizzle_row_t row = drizzle_row_buffer(result, &ret);
uint16_t cnt = drizzle_result_column_count(result);
if (ret == DRIZZLE_RETURN_OK && row) {
RETVAL = row2arrayref(row, cnt);
} else {
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
=item $result->set_column_count($n);
Set the number of fields in a result set.
=cut
SV*
set_column_count(SV*self_sv, U16 column_count)
CODE:
net_result * self_result = XS_STATE(net_result*, self_sv);
drizzle_result_st *result = self_result->result;
drizzle_result_set_column_count(result, column_count);
RETVAL = SvREFCNT_inc(self_sv);
OUTPUT:
RETVAL
=item my $column = $result->column_create();
Create a instance of Net::Drizzle::Column.
=cut
net_col*
column_create(SV* self_sv)
CODE:
net_result * self_result = XS_STATE(net_result*, self_sv);
drizzle_result_st *result = self_result->result;
drizzle_column_st *col_raw = drizzle_column_create(result, NULL);
if (col_raw == NULL) {
drizzle_con_st * con = drizzle_result_drizzle_con(result);
drizzle_st * drizzle = drizzle_con_drizzle(con);
Perl_croak(aTHX_ "drizzle_column_create:%s\n", drizzle_error(drizzle));
}
RETVAL = _create_col(self_sv, col_raw);
OUTPUT:
RETVAL
=item $result->calc_row_size();
Set result row packet size from field and size arrays.
=cut
SV*
calc_row_size(SV * self, ...)
CODE:
drizzle_result_st *result = XS_STATE(net_result*, self)->result;
int i;
size_t *sizes;
drizzle_field_t * fields;
Newx(sizes, items-1, size_t);
Newx(fields, items-1, drizzle_field_t);
for (i=1; i<items; i++) { /* 1 means "skip SV* self" */
STRLEN len;
fields[i-1] = SvPV(ST(i), len);
sizes[i-1] = len;
LOG("%d, %s, %d\n", i-1, fields[i-1], sizes[i-1]);
}
drizzle_result_calc_row_size(result, fields, sizes);
Safefree(sizes);
Safefree(fields);
RETVAL = SvREFCNT_inc(self);
OUTPUT:
RETVAL
=item $result->fields_write(...);
Send a fields over a connection
=cut
SV*
fields_write(SV * self, ...)
CODE:
drizzle_result_st *result = XS_STATE(net_result*, self)->result;
int i;
for (i=1; i<items; i++) { /* 1 means "skip SV* self" */
size_t size;
drizzle_field_t field;
field = SvPV(ST(i), size);
drizzle_return_t ret = drizzle_field_write(result, field, size, size);
if (ret != DRIZZLE_RETURN_OK) {
drizzle_con_st * con = drizzle_result_drizzle_con(result);
drizzle_st * drizzle = drizzle_con_drizzle(con);
Perl_croak(aTHX_ "drizzle_column_create:%s\n", drizzle_error(drizzle));
}
}
RETVAL = SvREFCNT_inc(self);
OUTPUT:
RETVAL
=item my $row_number = $result->row_read;
Get next row number for unbuffered results. Use the $result->field* functions
to read individual fields after this function succeeds.
=cut
uint64_t
row_read(net_result *result)
CODE:
drizzle_return_t ret;
uint64_t cur = drizzle_row_read(result->result, &ret);
if (ret != DRIZZLE_RETURN_OK) {
drizzle_con_st * con = drizzle_result_drizzle_con(result->result);
drizzle_st * drizzle = drizzle_con_drizzle(con);
Perl_croak(aTHX_ "drizzle_column_create:%s\n", drizzle_error(drizzle));
}
RETVAL = cur;
OUTPUT:
RETVAL
=item my ($ret, $field) = $res->field_buffer();
Buffer one field.
=cut
void
field_buffer(net_result *result)
PPCODE:
/* my ($ret, $field) = $res->field_buffer(); */
drizzle_return_t ret;
size_t total;
drizzle_field_t field = drizzle_field_buffer(result->result, &total, &ret);
mXPUSHi(ret);
mXPUSHs(field != NULL ? newSVpv(field, total) : newSV(0));
XSRETURN(2);
=back
=head2 METHODS for servers
=over 4
=item $result->set_eof();
Set EOF for a result.
=cut
SV *
set_eof(SV *self_sv, bool eof)
CODE:
net_result * self_result = XS_STATE(net_result *, self_sv);
drizzle_result_st *result = self_result->result;
drizzle_result_set_eof(result, eof);
RETVAL = SvREFCNT_inc_simple(self_sv);
OUTPUT:
RETVAL
=item $result->write($flush);
Write result packet.
=cut
SV *
write(SV *self_sv, bool flush)
CODE:
net_result * self_result = XS_STATE(net_result *, self_sv);
drizzle_result_st *result = self_result->result;
drizzle_con_st * con = drizzle_result_drizzle_con(result);
drizzle_result_write(con, result, flush);
RETVAL = SvREFCNT_inc(self_sv);
OUTPUT:
RETVAL
=item $result->row_write();
Write next row.
=cut
void
row_write(net_result *result)
CODE:
drizzle_row_write(result->result);
void
DESTROY(net_result *self)
CODE:
LOG("DESTROY result 0x%X, drizzle->refcnt=%d\n", (unsigned int)self->drizzle, (int)SvREFCNT(self->drizzle));
if (self->drizzle != NULL) {
SvREFCNT_dec(self->drizzle);
}
if (self->con != NULL) {
SvREFCNT_dec(self->con);
}
if (self->query != NULL) {
SvREFCNT_dec(self->query);
}
Safefree(self);
=back
=head1 SEE ALSO
L<Net::Drizzle>
=cut