/* {{{ mysqlnd_mempool_free_chunk */
static void
-mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk)
+mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL * pool, void * ptr)
{
DBG_ENTER("mysqlnd_mempool_free_chunk");
/* Try to back-off and guess if this is the last block allocated */
- if ((char*)chunk == (char*)pool->arena->ptr - ZEND_MM_ALIGNED_SIZE(sizeof(MYSQLND_MEMORY_POOL_CHUNK) + chunk->size)) {
+ if (ptr == pool->last) {
/*
This was the last allocation. Lucky us, we can free
a bit of memory from the pool. Next time we will return from the same ptr.
*/
- pool->arena->ptr = (char*)chunk;
+ pool->arena->ptr = (char*)ptr;
+ pool->last = NULL;
}
DBG_VOID_RETURN;
}
/* {{{ mysqlnd_mempool_resize_chunk */
-static MYSQLND_MEMORY_POOL_CHUNK *
-mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size)
+static void *
+mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL * pool, void * ptr, size_t old_size, size_t size)
{
DBG_ENTER("mysqlnd_mempool_resize_chunk");
/* Try to back-off and guess if this is the last block allocated */
- if (((char*)chunk == (char*)pool->arena->ptr - ZEND_MM_ALIGNED_SIZE(sizeof(MYSQLND_MEMORY_POOL_CHUNK) + chunk->size))
- && (ZEND_MM_ALIGNED_SIZE(sizeof(MYSQLND_MEMORY_POOL_CHUNK) + size) <= ((char*)pool->arena->end - (char*)chunk))) {
+ if (ptr == pool->last
+ && (ZEND_MM_ALIGNED_SIZE(size) <= ((char*)pool->arena->end - (char*)ptr))) {
/*
This was the last allocation. Lucky us, we can free
a bit of memory from the pool. Next time we will return from the same ptr.
*/
- pool->arena->ptr = (char*)chunk + ZEND_MM_ALIGNED_SIZE(sizeof(MYSQLND_MEMORY_POOL_CHUNK) + size);
+ pool->arena->ptr = (char*)ptr + ZEND_MM_ALIGNED_SIZE(size);
} else {
- MYSQLND_MEMORY_POOL_CHUNK *new_chunk = mysqlnd_arena_alloc(&pool->arena, sizeof(MYSQLND_MEMORY_POOL_CHUNK) + size);
- memcpy(new_chunk, chunk, sizeof(MYSQLND_MEMORY_POOL_CHUNK) + MIN(size, chunk->size));
- chunk = new_chunk;
+ void *new_ptr = mysqlnd_arena_alloc(&pool->arena, size);
+ memcpy(new_ptr, ptr, MIN(old_size, size));
+ pool->last = ptr = new_ptr;
}
- chunk->size = size;
- DBG_RETURN(chunk);
+ DBG_RETURN(ptr);
}
/* }}} */
/* {{{ mysqlnd_mempool_get_chunk */
-static MYSQLND_MEMORY_POOL_CHUNK *
-mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, unsigned int size)
+static void *
+mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, size_t size)
{
- MYSQLND_MEMORY_POOL_CHUNK *chunk = NULL;
+ void *ptr = NULL;
DBG_ENTER("mysqlnd_mempool_get_chunk");
- chunk = mysqlnd_arena_alloc(&pool->arena, sizeof(MYSQLND_MEMORY_POOL_CHUNK) + size);
- chunk->size = size;
+ ptr = mysqlnd_arena_alloc(&pool->arena, size);
+ pool->last = ptr;
- DBG_RETURN(chunk);
+ DBG_RETURN(ptr);
}
/* }}} */
if (Z_ISUNDEF(current_row[0])) {
uint64_t row_num = (set->data_cursor - set->data) / field_count;
- enum_func_status rc = result->stored_data->m.row_decoder(result->stored_data->row_buffers[row_num],
+ enum_func_status rc = result->stored_data->m.row_decoder(&result->stored_data->row_buffers[row_num],
current_row,
meta->field_count,
meta->fields,
result->unbuf->last_row_data = row_packet->fields;
result->unbuf->last_row_buffer = row_packet->row_buffer;
row_packet->fields = NULL;
- row_packet->row_buffer = NULL;
+ row_packet->row_buffer.ptr = NULL;
- if (PASS != result->unbuf->m.row_decoder(result->unbuf->last_row_buffer,
+ if (PASS != result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer,
result->unbuf->last_row_data,
row_packet->field_count,
row_packet->fields_metadata,
report leaks.
*/
row_packet->result_set_memory_pool->free_chunk(
- row_packet->result_set_memory_pool, row_packet->row_buffer);
- row_packet->row_buffer = NULL;
+ row_packet->result_set_memory_pool, row_packet->row_buffer.ptr);
+ row_packet->row_buffer.ptr = NULL;
}
result->unbuf->row_count++;
result->unbuf->last_row_data = row_packet->fields;
result->unbuf->last_row_buffer = row_packet->row_buffer;
row_packet->fields = NULL;
- row_packet->row_buffer = NULL;
+ row_packet->row_buffer.ptr = NULL;
- if (PASS != result->unbuf->m.row_decoder(result->unbuf->last_row_buffer,
+ if (PASS != result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer,
result->unbuf->last_row_data,
row_packet->field_count,
row_packet->fields_metadata,
report leaks.
*/
row_packet->result_set_memory_pool->free_chunk(
- row_packet->result_set_memory_pool, row_packet->row_buffer);
- row_packet->row_buffer = NULL;
+ row_packet->result_set_memory_pool, row_packet->row_buffer.ptr);
+ row_packet->row_buffer.ptr = NULL;
}
/* We asked for one row, the next one should be EOF, eat it */
ret = PACKET_READ(conn, row_packet);
- if (row_packet->row_buffer) {
+ if (row_packet->row_buffer.ptr) {
row_packet->result_set_memory_pool->free_chunk(
- row_packet->result_set_memory_pool, row_packet->row_buffer);
- row_packet->row_buffer = NULL;
+ row_packet->result_set_memory_pool, row_packet->row_buffer.ptr);
+ row_packet->row_buffer.ptr = NULL;
}
MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_CURSOR);
if (Z_ISUNDEF(data_cursor[0])) {
unsigned int i;
const size_t current_row_num = (data_cursor - data_begin) / field_count;
- enum_func_status rc = result->m.row_decoder(result->row_buffers[current_row_num],
+ enum_func_status rc = result->m.row_decoder(&result->row_buffers[current_row_num],
data_cursor,
field_count,
meta->fields,
continue;
}
- rc = result->m.row_decoder(result->row_buffers[i], current_row, field_count, meta->fields, int_and_float_native, stats);
+ rc = result->m.row_decoder(&result->row_buffers[i], current_row, field_count, meta->fields, int_and_float_native, stats);
if (rc != PASS) {
ret = FAIL;
mnd_efree(unbuf->last_row_data);
unbuf->last_row_data = NULL;
}
- if (unbuf->last_row_buffer) {
+ if (unbuf->last_row_buffer.ptr) {
DBG_INF("Freeing last row buffer");
/* Nothing points to this buffer now, free it */
unbuf->result_set_memory_pool->free_chunk(
- unbuf->result_set_memory_pool, unbuf->last_row_buffer);
- unbuf->last_row_buffer = NULL;
+ unbuf->result_set_memory_pool, unbuf->last_row_buffer.ptr);
+ unbuf->last_row_buffer.ptr = NULL;
}
DBG_VOID_RETURN;
result->unbuf->last_row_data = row_packet->fields;
result->unbuf->last_row_buffer = row_packet->row_buffer;
row_packet->fields = NULL;
- row_packet->row_buffer = NULL;
+ row_packet->row_buffer.ptr = NULL;
MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
if (!row_packet->skip_extraction) {
unsigned int i, field_count = meta->field_count;
- enum_func_status rc = result->unbuf->m.row_decoder(result->unbuf->last_row_buffer,
+ enum_func_status rc = result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer,
result->unbuf->last_row_data,
field_count,
row_packet->fields_metadata,
result->unbuf->last_row_data = row_packet->fields;
result->unbuf->last_row_buffer = row_packet->row_buffer;
row_packet->fields = NULL;
- row_packet->row_buffer = NULL;
+ row_packet->row_buffer.ptr = NULL;
MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
if (!row_packet->skip_extraction) {
unsigned int i, field_count = meta->field_count;
- enum_func_status rc = result->unbuf->m.row_decoder(result->unbuf->last_row_buffer,
+ enum_func_status rc = result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer,
result->unbuf->last_row_data,
field_count,
row_packet->fields_metadata,
if (Z_ISUNDEF(current_row[0])) {
uint64_t row_num = (set->data_cursor - set->data) / field_count;
- enum_func_status rc = set->m.row_decoder(set->row_buffers[row_num],
+ enum_func_status rc = set->m.row_decoder(&set->row_buffers[row_num],
current_row,
field_count,
meta->fields,
if (Z_ISUNDEF(current_row[0])) {
const size_t row_num = (set->data_cursor - set->data) / field_count;
- enum_func_status rc = set->m.row_decoder(set->row_buffers[row_num],
+ enum_func_status rc = set->m.row_decoder(&set->row_buffers[row_num],
current_row,
field_count,
meta->fields,
DBG_RETURN(FAIL);
}
- rc = result->stored_data->m.row_decoder(result->stored_data->row_buffers[set->current_row],
+ rc = result->stored_data->m.row_decoder(&result->stored_data->row_buffers[set->current_row],
current_row,
field_count,
meta->fields,
enum_func_status
MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result,
MYSQLND_RES_METADATA * meta,
- MYSQLND_MEMORY_POOL_CHUNK ***row_buffers,
+ MYSQLND_ROW_BUFFER **row_buffers,
zend_bool binary_protocol)
{
enum_func_status ret;
while (FAIL != (ret = PACKET_READ(conn, &row_packet)) && !row_packet.eof) {
if (!free_rows) {
- MYSQLND_MEMORY_POOL_CHUNK ** new_row_buffers;
+ MYSQLND_ROW_BUFFER * new_row_buffers;
total_allocated_rows += set->row_count;
if (total_allocated_rows < 1024) {
}
/* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */
- if (total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
+ if (total_allocated_rows * sizeof(MYSQLND_ROW_BUFFER) > SIZE_MAX) {
SET_OOM_ERROR(conn->error_info);
ret = FAIL;
goto free_end;
}
if (*row_buffers) {
- new_row_buffers = mnd_erealloc(*row_buffers, (size_t)(total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
+ new_row_buffers = mnd_erealloc(*row_buffers, (size_t)(total_allocated_rows * sizeof(MYSQLND_ROW_BUFFER)));
} else {
- new_row_buffers = mnd_emalloc((size_t)(total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
+ new_row_buffers = mnd_emalloc((size_t)(total_allocated_rows * sizeof(MYSQLND_ROW_BUFFER)));
}
if (!new_row_buffers) {
SET_OOM_ERROR(conn->error_info);
/* So row_packet's destructor function won't efree() it */
row_packet.fields = NULL;
- row_packet.row_buffer = NULL;
+ row_packet.row_buffer.ptr = NULL;
/*
No need to FREE_ALLOCA as we can reuse the
/* save some memory */
if (free_rows) {
/* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */
- if (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
+ if (set->row_count * sizeof(MYSQLND_ROW_BUFFER) > SIZE_MAX) {
SET_OOM_ERROR(conn->error_info);
ret = FAIL;
goto free_end;
}
- *row_buffers = mnd_erealloc(*row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
+ *row_buffers = mnd_erealloc(*row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_ROW_BUFFER)));
}
if (UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) {
const unsigned int flags)
{
enum_func_status ret;
- MYSQLND_MEMORY_POOL_CHUNK ***row_buffers = NULL;
+ MYSQLND_ROW_BUFFER **row_buffers = NULL;
DBG_ENTER("mysqlnd_res::store_result");
DBG_RETURN(NULL);
}
- ret = MYSQLND_MEMORY_POOL_CHUNK_PTR(pool->get_chunk(pool, alloc_size));
+ ret = pool->get_chunk(pool, alloc_size);
memset(ret, 0, alloc_size);
- ret->lengths = MYSQLND_MEMORY_POOL_CHUNK_PTR(pool->get_chunk(pool, field_count * sizeof(size_t)));
+ ret->lengths = pool->get_chunk(pool, field_count * sizeof(size_t));
memset(ret->lengths, 0, field_count * sizeof(size_t));
ret->result_set_memory_pool = pool;
DBG_RETURN(NULL);
}
- ret = MYSQLND_MEMORY_POOL_CHUNK_PTR(pool->get_chunk(pool, alloc_size));
+ ret = pool->get_chunk(pool, alloc_size);
memset(ret, 0, alloc_size);
if (FAIL == mysqlnd_error_info_init(&ret->error_info, 0)) {
DBG_RETURN(NULL);
}
- ret->lengths = MYSQLND_MEMORY_POOL_CHUNK_PTR(pool->get_chunk(pool, field_count * sizeof(size_t)));
+ ret->lengths = pool->get_chunk(pool, field_count * sizeof(size_t));
memset(ret->lengths, 0, field_count * sizeof(size_t));
ret->result_set_memory_pool = pool;
DBG_RETURN(NULL);
}
- ret = MYSQLND_MEMORY_POOL_CHUNK_PTR(pool->get_chunk(pool, alloc_size));
+ ret = pool->get_chunk(pool, alloc_size);
memset(ret, 0, alloc_size);
if (FAIL == mysqlnd_error_info_init(&ret->error_info, 0)) {
DBG_RETURN(NULL);
}
- ret->lengths = MYSQLND_MEMORY_POOL_CHUNK_PTR(pool->get_chunk(pool, field_count * sizeof(size_t)));
+ ret->lengths = pool->get_chunk(pool, field_count * sizeof(size_t));
memset(ret->lengths, 0, field_count * sizeof(size_t));
ret->result_set_memory_pool = pool;
typedef struct st_mysqlnd_memory_pool MYSQLND_MEMORY_POOL;
-typedef struct st_mysqlnd_memory_pool_chunk MYSQLND_MEMORY_POOL_CHUNK;
-typedef struct st_mysqlnd_memory_pool_chunk_llist MYSQLND_MEMORY_POOL_CHUNK_LLIST;
-
-
-#define MYSQLND_MEMORY_POOL_CHUNK_LIST_SIZE 100
struct st_mysqlnd_memory_pool
{
zend_arena *arena;
+ void *last;
- MYSQLND_MEMORY_POOL_CHUNK* (*get_chunk)(MYSQLND_MEMORY_POOL * pool, unsigned int size);
- MYSQLND_MEMORY_POOL_CHUNK* (*resize_chunk)(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size);
- void (*free_chunk)(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk);
+ void* (*get_chunk)(MYSQLND_MEMORY_POOL * pool, size_t size);
+ void* (*resize_chunk)(MYSQLND_MEMORY_POOL * pool, void * ptr, size_t old_size, size_t size);
+ void (*free_chunk)(MYSQLND_MEMORY_POOL * pool, void * ptr);
};
-struct st_mysqlnd_memory_pool_chunk
+
+typedef struct st_mysqlnd_row_buffer MYSQLND_ROW_BUFFER;
+
+struct st_mysqlnd_row_buffer
{
- size_t app;
+ void *ptr;
size_t size;
};
-#define MYSQLND_MEMORY_POOL_CHUNK_PTR(chunk) \
- ((void*)((char*)(chunk) + sizeof(MYSQLND_MEMORY_POOL_CHUNK)))
typedef struct st_mysqlnd_cmd_buffer
{
/* for decoding - binary or text protocol */
-typedef enum_func_status (*func_mysqlnd_res__row_decoder)(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+typedef enum_func_status (*func_mysqlnd_res__row_decoder)(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats);
typedef enum_func_status (*func_mysqlnd_res__read_result_metadata)(MYSQLND_RES * result, MYSQLND_CONN_DATA * conn);
typedef const size_t * (*func_mysqlnd_res__fetch_lengths)(MYSQLND_RES * const result);
-typedef enum_func_status (*func_mysqlnd_res__store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result, MYSQLND_RES_METADATA * meta, MYSQLND_MEMORY_POOL_CHUNK *** row_buffers, zend_bool binary_protocol);
+typedef enum_func_status (*func_mysqlnd_res__store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result, MYSQLND_RES_METADATA * meta, MYSQLND_ROW_BUFFER ** row_buffers, zend_bool binary_protocol);
typedef void (*func_mysqlnd_res__free_result_buffers)(MYSQLND_RES * result); /* private */
typedef enum_func_status (*func_mysqlnd_res__free_result)(MYSQLND_RES * result, const zend_bool implicit);
#define def_mysqlnd_buffered_result_parent \
- MYSQLND_MEMORY_POOL_CHUNK **row_buffers; \
+ MYSQLND_ROW_BUFFER *row_buffers; \
uint64_t row_count; \
uint64_t initialized_rows; \
\
/* For unbuffered (both normal and PS) */
zval *last_row_data;
- MYSQLND_MEMORY_POOL_CHUNK *last_row_buffer;
+ MYSQLND_ROW_BUFFER last_row_buffer;
/*
Column lengths of current row - both buffered and unbuffered.
MYSQLND_STATS * stats,
MYSQLND_ERROR_INFO * error_info,
MYSQLND_MEMORY_POOL * pool,
- MYSQLND_MEMORY_POOL_CHUNK ** buffer,
+ MYSQLND_ROW_BUFFER * buffer,
size_t * data_size)
{
enum_func_status ret = PASS;
if (first_iteration) {
first_iteration = FALSE;
- *buffer = pool->get_chunk(pool, *data_size + prealloc_more_bytes);
- if (!*buffer) {
+ buffer->ptr = pool->get_chunk(pool, *data_size + prealloc_more_bytes);
+ if (!buffer->ptr) {
ret = FAIL;
break;
}
- p = MYSQLND_MEMORY_POOL_CHUNK_PTR(*buffer);
+ p = buffer->ptr;
} else if (!first_iteration) {
/* Empty packet after MYSQLND_MAX_PACKET_SIZE packet. That's ok, break */
if (!header.size) {
/*
We have to realloc the buffer.
*/
- *buffer = pool->resize_chunk(pool, *buffer, *data_size + prealloc_more_bytes);
- if (!*buffer) {
+ buffer->ptr = pool->resize_chunk(pool, buffer->ptr, *data_size - header.size, *data_size + prealloc_more_bytes);
+ if (!buffer->ptr) {
SET_OOM_ERROR(error_info);
ret = FAIL;
break;
}
/* The position could have changed, recalculate */
- p = (zend_uchar *) MYSQLND_MEMORY_POOL_CHUNK_PTR(*buffer) + (*data_size - header.size);
+ p = (zend_uchar *) buffer->ptr + (*data_size - header.size);
}
if (PASS != (ret = pfc->data->m.receive(pfc, vio, p, header.size, stats, error_info))) {
break;
}
}
- if (ret == FAIL && *buffer) {
- pool->free_chunk(pool, *buffer);
- *buffer = NULL;
+ if (ret == FAIL && buffer->ptr) {
+ pool->free_chunk(pool, buffer->ptr);
+ buffer->ptr = NULL;
}
DBG_RETURN(ret);
}
/* {{{ php_mysqlnd_rowp_read_binary_protocol */
enum_func_status
-php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+php_mysqlnd_rowp_read_binary_protocol(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats)
{
unsigned int i;
- const zend_uchar * p = MYSQLND_MEMORY_POOL_CHUNK_PTR(row_buffer);
+ const zend_uchar * p = row_buffer->ptr;
const zend_uchar * null_ptr;
zend_uchar bit;
zval *current_field, *end_field, *start_field;
/* {{{ php_mysqlnd_rowp_read_text_protocol */
enum_func_status
-php_mysqlnd_rowp_read_text_protocol_aux(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+php_mysqlnd_rowp_read_text_protocol_aux(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats)
{
unsigned int i;
zval *current_field, *end_field, *start_field;
- zend_uchar * p = MYSQLND_MEMORY_POOL_CHUNK_PTR(row_buffer);
- size_t data_size = row_buffer->app;
+ zend_uchar * p = row_buffer->ptr;
+ size_t data_size = row_buffer->size;
const zend_uchar * const packet_end = (zend_uchar*) p + data_size;
DBG_ENTER("php_mysqlnd_rowp_read_text_protocol_aux");
/* {{{ php_mysqlnd_rowp_read_text_protocol_zval */
enum_func_status
-php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats)
{
/* {{{ php_mysqlnd_rowp_read_text_protocol_c */
enum_func_status
-php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats)
{
to keep (and copy) the lengths externally.
*/
packet->header.size = data_size;
- packet->row_buffer->app = data_size;
+ packet->row_buffer.size = data_size;
- if (ERROR_MARKER == (*(p = MYSQLND_MEMORY_POOL_CHUNK_PTR(packet->row_buffer)))) {
+ if (ERROR_MARKER == (*(p = packet->row_buffer.ptr))) {
/*
Error message as part of the result set,
not good but we should not hang. See:
DBG_ENTER("php_mysqlnd_rowp_free_mem");
p = (MYSQLND_PACKET_ROW *) _packet;
- if (p->row_buffer) {
- p->result_set_memory_pool->free_chunk(p->result_set_memory_pool, p->row_buffer);
- p->row_buffer = NULL;
+ if (p->row_buffer.ptr) {
+ p->result_set_memory_pool->free_chunk(p->result_set_memory_pool, p->row_buffer.ptr);
+ p->row_buffer.ptr = NULL;
}
/*
Don't free packet->fields :
uint16_t warning_count;
uint16_t server_status;
- struct st_mysqlnd_memory_pool_chunk *row_buffer;
+ MYSQLND_ROW_BUFFER row_buffer;
MYSQLND_MEMORY_POOL * result_set_memory_pool;
zend_bool skip_extraction;
PHPAPI extern const char * const mysqlnd_empty_string;
-enum_func_status php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+enum_func_status php_mysqlnd_rowp_read_binary_protocol(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats);
-enum_func_status php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+enum_func_status php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats);
-enum_func_status php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields,
+enum_func_status php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_ROW_BUFFER * row_buffer, zval * fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, MYSQLND_STATS * stats);
projects / php / commitdiff