[BACK]Return to mysqlnd_result.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mysqlnd

Diff for /embedaddon/php/ext/mysqlnd/mysqlnd_result.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2012/02/21 23:47:58 version 1.1.1.4, 2014/06/15 20:03:52
Line 2 Line 2
   +----------------------------------------------------------------------+    +----------------------------------------------------------------------+
   | PHP Version 5                                                        |    | PHP Version 5                                                        |
   +----------------------------------------------------------------------+    +----------------------------------------------------------------------+
  | Copyright (c) 2006-2012 The PHP Group                                |  | Copyright (c) 2006-2014 The PHP Group                                |
   +----------------------------------------------------------------------+    +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |    | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |    | that is bundled with this package in the file LICENSE, and is        |
Line 12 Line 12
   | obtain it through the world-wide-web, please send a note to          |    | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |    | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+    +----------------------------------------------------------------------+
  | Authors: Georg Richter <georg@mysql.com>                             |  | Authors: Andrey Hristov <andrey@mysql.com>                           |
  |          Andrey Hristov <andrey@mysql.com>                           | 
   |          Ulf Wendel <uwendel@mysql.com>                              |    |          Ulf Wendel <uwendel@mysql.com>                              |
     |          Georg Richter <georg@mysql.com>                             |
   +----------------------------------------------------------------------+    +----------------------------------------------------------------------+
 */  */
   
Line 28 Line 28
 #include "mysqlnd_result_meta.h"  #include "mysqlnd_result_meta.h"
 #include "mysqlnd_statistics.h"  #include "mysqlnd_statistics.h"
 #include "mysqlnd_debug.h"  #include "mysqlnd_debug.h"
   #include "mysqlnd_ext_plugin.h"
   
 #define MYSQLND_SILENT  #define MYSQLND_SILENT
   
Line 54  MYSQLND_METHOD(mysqlnd_res, initialize_result_set_rest Line 55  MYSQLND_METHOD(mysqlnd_res, initialize_result_set_rest
                                                                         data_cursor,                                                                          data_cursor,
                                                                         result->meta->field_count,                                                                          result->meta->field_count,
                                                                         result->meta->fields,                                                                          result->meta->fields,
                                                                        result->stored_data->persistent,                                                                        result->conn->options->numeric_and_datetime_as_unicode,
                                                                        result->conn->options.numeric_and_datetime_as_unicode,                                                                        result->conn->options->int_and_float_native,
                                                                        result->conn->options.int_and_float_native, 
                                                                         result->conn->stats TSRMLS_CC);                                                                          result->conn->stats TSRMLS_CC);
                         if (rc != PASS) {                          if (rc != PASS) {
                                 ret = FAIL;                                  ret = FAIL;
Line 150  MYSQLND_METHOD(mysqlnd_res, unbuffered_free_last_data) Line 150  MYSQLND_METHOD(mysqlnd_res, unbuffered_free_last_data)
                 DBG_VOID_RETURN;                  DBG_VOID_RETURN;
         }          }
   
         DBG_INF_FMT("last_row_data=%p", unbuf->last_row_data);  
         if (unbuf->last_row_data) {          if (unbuf->last_row_data) {
                 unsigned int i, ctor_called_count = 0;                  unsigned int i, ctor_called_count = 0;
                 zend_bool copy_ctor_called;                  zend_bool copy_ctor_called;
                 MYSQLND_STATS *global_stats = result->conn? result->conn->stats:NULL;                  MYSQLND_STATS *global_stats = result->conn? result->conn->stats:NULL;
   
                 DBG_INF_FMT("%u columns to free", result->field_count);  
                 for (i = 0; i < result->field_count; i++) {                  for (i = 0; i < result->field_count; i++) {
                         mysqlnd_rset_zval_ptr_dtor(&(unbuf->last_row_data[i]), result->type, &copy_ctor_called TSRMLS_CC);                          mysqlnd_rset_zval_ptr_dtor(&(unbuf->last_row_data[i]), result->type, &copy_ctor_called TSRMLS_CC);
                         if (copy_ctor_called) {                          if (copy_ctor_called) {
Line 197  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN Line 195  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN
         DBG_ENTER("mysqlnd_res::free_buffered_data");          DBG_ENTER("mysqlnd_res::free_buffered_data");
         DBG_INF_FMT("Freeing "MYSQLND_LLU_SPEC" row(s)", set->row_count);          DBG_INF_FMT("Freeing "MYSQLND_LLU_SPEC" row(s)", set->row_count);
   
         DBG_INF("Freeing data & row_buffer");  
         if (set->data) {          if (set->data) {
                 unsigned int copy_on_write_performed = 0;                  unsigned int copy_on_write_performed = 0;
                 unsigned int copy_on_write_saved = 0;                  unsigned int copy_on_write_saved = 0;
                   zval **data = set->data;
                   set->data = NULL; /* prevent double free if following loop is interrupted */
   
                 DBG_INF_FMT("before: real_usage=%lu  usage=%lu", zend_memory_usage(TRUE TSRMLS_CC), zend_memory_usage(FALSE TSRMLS_CC));  
                 for (row = set->row_count - 1; row >= 0; row--) {                  for (row = set->row_count - 1; row >= 0; row--) {
                        zval **current_row = set->data + row * field_count;                        zval **current_row = data + row * field_count;
                         MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row];                          MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row];
                         int64_t col;                          int64_t col;
   
Line 213  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN Line 211  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN
                                         if (current_row[col]) {                                          if (current_row[col]) {
                                                 zend_bool copy_ctor_called;                                                  zend_bool copy_ctor_called;
                                                 mysqlnd_rset_zval_ptr_dtor(&(current_row[col]), result->type, &copy_ctor_called TSRMLS_CC);                                                  mysqlnd_rset_zval_ptr_dtor(&(current_row[col]), result->type, &copy_ctor_called TSRMLS_CC);
 #if MYSQLND_DEBUG_MEMORY  
                                                 DBG_INF_FMT("Copy_ctor_called=%u", copy_ctor_called);  
 #endif  
                                                 if (copy_ctor_called) {                                                  if (copy_ctor_called) {
                                                         ++copy_on_write_performed;                                                          ++copy_on_write_performed;
                                                 } else {                                                  } else {
Line 224  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN Line 219  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN
                                         }                                          }
                                 }                                  }
                         }                          }
 #if MYSQLND_DEBUG_MEMORY  
                         DBG_INF("Freeing current_row & current_buffer");  
 #endif  
                         current_buffer->free_chunk(current_buffer TSRMLS_CC);                          current_buffer->free_chunk(current_buffer TSRMLS_CC);
                 }                  }
   
                 MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_COPY_ON_WRITE_PERFORMED, copy_on_write_performed,                  MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_COPY_ON_WRITE_PERFORMED, copy_on_write_performed,
                                                                                           STAT_COPY_ON_WRITE_SAVED, copy_on_write_saved);                                                                                            STAT_COPY_ON_WRITE_SAVED, copy_on_write_saved);
                mnd_pefree(set->data, set->persistent);                mnd_efree(data);
                set->data = NULL; 
         }          }
   
         if (set->row_buffers) {          if (set->row_buffers) {
                mnd_pefree(set->row_buffers, set->persistent);                mnd_efree(set->row_buffers);
                 set->row_buffers        = NULL;                  set->row_buffers        = NULL;
         }          }
         set->data_cursor = NULL;          set->data_cursor = NULL;
         set->row_count  = 0;          set->row_count  = 0;
   
        DBG_INF("Freeing set");        mnd_efree(set);
        mnd_pefree(set, set->persistent); 
   
         DBG_INF_FMT("after: real_usage=%lu  usage=%lu", zend_memory_usage(TRUE TSRMLS_CC), zend_memory_usage(FALSE TSRMLS_CC));  
         DBG_VOID_RETURN;          DBG_VOID_RETURN;
 }  }
 /* }}} */  /* }}} */
Line 274  MYSQLND_METHOD(mysqlnd_res, free_result_buffers)(MYSQL Line 263  MYSQLND_METHOD(mysqlnd_res, free_result_buffers)(MYSQL
         }          }
   
         if (result->row_packet) {          if (result->row_packet) {
                 DBG_INF("Freeing packet");  
                 PACKET_FREE(result->row_packet);                  PACKET_FREE(result->row_packet);
                 result->row_packet = NULL;                  result->row_packet = NULL;
         }          }
   
         if (result->result_set_memory_pool) {          if (result->result_set_memory_pool) {
                 DBG_INF("Freeing memory pool");  
                 mysqlnd_mempool_destroy(result->result_set_memory_pool TSRMLS_CC);                  mysqlnd_mempool_destroy(result->result_set_memory_pool TSRMLS_CC);
                 result->result_set_memory_pool = NULL;                  result->result_set_memory_pool = NULL;
         }          }
Line 329  void mysqlnd_internal_free_result(MYSQLND_RES * result Line 316  void mysqlnd_internal_free_result(MYSQLND_RES * result
   
 /* {{{ mysqlnd_res::read_result_metadata */  /* {{{ mysqlnd_res::read_result_metadata */
 static enum_func_status  static enum_func_status
MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES * result, MYSQLND *conn TSRMLS_DC)MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES * result, MYSQLND_CONN_DATA * conn TSRMLS_DC)
 {  {
         DBG_ENTER("mysqlnd_res::read_result_metadata");          DBG_ENTER("mysqlnd_res::read_result_metadata");
   
Line 346  MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQ Line 333  MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQ
   
         result->meta = result->m.result_meta_init(result->field_count, result->persistent TSRMLS_CC);          result->meta = result->m.result_meta_init(result->field_count, result->persistent TSRMLS_CC);
         if (!result->meta) {          if (!result->meta) {
                SET_OOM_ERROR(conn->error_info);                SET_OOM_ERROR(*conn->error_info);
                 DBG_RETURN(FAIL);                  DBG_RETURN(FAIL);
         }          }
   
Line 374  MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQ Line 361  MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQ
   
 /* {{{ mysqlnd_query_read_result_set_header */  /* {{{ mysqlnd_query_read_result_set_header */
 enum_func_status  enum_func_status
mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT * s TSRMLS_DC)mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s TSRMLS_DC)
 {  {
         MYSQLND_STMT_DATA * stmt = s ? s->data:NULL;          MYSQLND_STMT_DATA * stmt = s ? s->data:NULL;
         enum_func_status ret;          enum_func_status ret;
Line 388  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 375  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
         do {          do {
                 rset_header = conn->protocol->m.get_rset_header_packet(conn->protocol, FALSE TSRMLS_CC);                  rset_header = conn->protocol->m.get_rset_header_packet(conn->protocol, FALSE TSRMLS_CC);
                 if (!rset_header) {                  if (!rset_header) {
                        SET_OOM_ERROR(conn->error_info);                        SET_OOM_ERROR(*conn->error_info);
                         ret = FAIL;                          ret = FAIL;
                         break;                          break;
                 }                  }
Line 410  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 397  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                           a multi-statement or a stored procedure, so it should be                            a multi-statement or a stored procedure, so it should be
                           safe to unconditionally turn off the flag here.                            safe to unconditionally turn off the flag here.
                         */                          */
                        conn->upsert_status.server_status &= ~SERVER_MORE_RESULTS_EXISTS;                        conn->upsert_status->server_status &= ~SERVER_MORE_RESULTS_EXISTS;
                         /*                          /*
                           This will copy the error code and the messages, as they                            This will copy the error code and the messages, as they
                           are buffers in the struct                            are buffers in the struct
                         */                          */
                        conn->error_info = rset_header->error_info;                        COPY_CLIENT_ERROR(*conn->error_info, rset_header->error_info);
                         ret = FAIL;                          ret = FAIL;
                         DBG_ERR_FMT("error=%s", rset_header->error_info.error);                          DBG_ERR_FMT("error=%s", rset_header->error_info.error);
                         /* Return back from CONN_QUERY_SENT */                          /* Return back from CONN_QUERY_SENT */
                         CONN_SET_STATE(conn, CONN_READY);                          CONN_SET_STATE(conn, CONN_READY);
                         break;                          break;
                 }                  }
                conn->error_info.error_no = 0;                conn->error_info->error_no = 0;
   
                 switch (rset_header->field_count) {                  switch (rset_header->field_count) {
                         case MYSQLND_NULL_LENGTH: {     /* LOAD DATA LOCAL INFILE */                          case MYSQLND_NULL_LENGTH: {     /* LOAD DATA LOCAL INFILE */
Line 440  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 427  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                 DBG_INF("UPSERT");                                  DBG_INF("UPSERT");
                                 conn->last_query_type = QUERY_UPSERT;                                  conn->last_query_type = QUERY_UPSERT;
                                 conn->field_count = rset_header->field_count;                                  conn->field_count = rset_header->field_count;
                                conn->upsert_status.warning_count = rset_header->warning_count;                                memset(conn->upsert_status, 0, sizeof(*conn->upsert_status));
                                conn->upsert_status.server_status = rset_header->server_status;                                conn->upsert_status->warning_count = rset_header->warning_count;
                                conn->upsert_status.affected_rows = rset_header->affected_rows;                                conn->upsert_status->server_status = rset_header->server_status;
                                conn->upsert_status.last_insert_id = rset_header->last_insert_id;                                conn->upsert_status->affected_rows = rset_header->affected_rows;
                                 conn->upsert_status->last_insert_id = rset_header->last_insert_id;
                                 SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,                                  SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
                                                                 rset_header->info_or_local_file, rset_header->info_or_local_file_len,                                                                  rset_header->info_or_local_file, rset_header->info_or_local_file_len,
                                                                 conn->persistent);                                                                  conn->persistent);
                                 /* Result set can follow UPSERT statement, check server_status */                                  /* Result set can follow UPSERT statement, check server_status */
                                if (conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS) {                                if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
                                         CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);                                          CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);
                                 } else {                                  } else {
                                         CONN_SET_STATE(conn, CONN_READY);                                          CONN_SET_STATE(conn, CONN_READY);
Line 464  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 452  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                 SET_EMPTY_MESSAGE(conn->last_message, conn->last_message_len, conn->persistent);                                  SET_EMPTY_MESSAGE(conn->last_message, conn->last_message_len, conn->persistent);
   
                                 MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_RSET_QUERY);                                  MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_RSET_QUERY);
                                memset(&conn->upsert_status, 0, sizeof(conn->upsert_status));                                memset(conn->upsert_status, 0, sizeof(*conn->upsert_status));
                                 /* restore after zeroing */                                  /* restore after zeroing */
                                 SET_ERROR_AFF_ROWS(conn);                                  SET_ERROR_AFF_ROWS(conn);
   
Line 500  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 488  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                         result = stmt->result;                                          result = stmt->result;
                                 }                                  }
                                 if (!result) {                                  if (!result) {
                                        SET_OOM_ERROR(conn->error_info);                                        SET_OOM_ERROR(*conn->error_info);
                                         ret = FAIL;                                          ret = FAIL;
                                         break;                                          break;
                                 }                                  }
Line 511  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 499  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                                 mnd_efree(conn->current_result);                                                  mnd_efree(conn->current_result);
                                                 conn->current_result = NULL;                                                  conn->current_result = NULL;
                                         }                                          }
                                        DBG_ERR("Error ocurred while reading metadata");                                        DBG_ERR("Error occurred while reading metadata");
                                         break;                                          break;
                                 }                                  }
   
                                 /* Check for SERVER_STATUS_MORE_RESULTS if needed */                                  /* Check for SERVER_STATUS_MORE_RESULTS if needed */
                                 fields_eof = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC);                                  fields_eof = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC);
                                 if (!fields_eof) {                                  if (!fields_eof) {
                                        SET_OOM_ERROR(conn->error_info);                                        SET_OOM_ERROR(*conn->error_info);
                                         ret = FAIL;                                          ret = FAIL;
                                         break;                                          break;
                                 }                                  }
                                 if (FAIL == (ret = PACKET_READ(fields_eof, conn))) {                                  if (FAIL == (ret = PACKET_READ(fields_eof, conn))) {
                                        DBG_ERR("Error ocurred while reading the EOF packet");                                        DBG_ERR("Error occurred while reading the EOF packet");
                                         result->m.free_result_contents(result TSRMLS_CC);                                          result->m.free_result_contents(result TSRMLS_CC);
                                         mnd_efree(result);                                          mnd_efree(result);
                                         if (!stmt) {                                          if (!stmt) {
Line 537  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 525  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                         unsigned int to_log = MYSQLND_G(log_mask);                                          unsigned int to_log = MYSQLND_G(log_mask);
                                         to_log &= fields_eof->server_status;                                          to_log &= fields_eof->server_status;
                                         DBG_INF_FMT("warnings=%u server_status=%u", fields_eof->warning_count, fields_eof->server_status);                                          DBG_INF_FMT("warnings=%u server_status=%u", fields_eof->warning_count, fields_eof->server_status);
                                        conn->upsert_status.warning_count = fields_eof->warning_count;                                        conn->upsert_status->warning_count = fields_eof->warning_count;
                                         /*                                          /*
                                           If SERVER_MORE_RESULTS_EXISTS is set then this is either MULTI_QUERY or a CALL()                                            If SERVER_MORE_RESULTS_EXISTS is set then this is either MULTI_QUERY or a CALL()
                                           The first packet after sending the query/com_execute has the bit set only                                            The first packet after sending the query/com_execute has the bit set only
Line 545  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 533  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                           will include many result sets. What actually matters are the bits set at the end                                            will include many result sets. What actually matters are the bits set at the end
                                           of every result set (the EOF packet).                                            of every result set (the EOF packet).
                                         */                                          */
                                        conn->upsert_status.server_status = fields_eof->server_status;                                        conn->upsert_status->server_status = fields_eof->server_status;
                                         if (fields_eof->server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) {                                          if (fields_eof->server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) {
                                                 statistic = STAT_BAD_INDEX_USED;                                                  statistic = STAT_BAD_INDEX_USED;
                                         } else if (fields_eof->server_status & SERVER_QUERY_NO_INDEX_USED) {                                          } else if (fields_eof->server_status & SERVER_QUERY_NO_INDEX_USED) {
Line 648  mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TS Line 636  mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TS
                 DBG_RETURN(retrow);                  DBG_RETURN(retrow);
         }          }
         if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {          if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
                SET_CLIENT_ERROR(result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC,                SET_CLIENT_ERROR(*result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
                                                  UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);                                                    UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); 
                 DBG_RETURN(retrow);                  DBG_RETURN(retrow);
         }          }
Line 683  mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TS Line 671  mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TS
                                                                                   result->unbuf->last_row_data,                                                                                    result->unbuf->last_row_data,
                                                                                   row_packet->field_count,                                                                                    row_packet->field_count,
                                                                                   row_packet->fields_metadata,                                                                                    row_packet->fields_metadata,
                                                                                  FALSE,                                                                                  result->conn->options->numeric_and_datetime_as_unicode,
                                                                                  result->conn->options.numeric_and_datetime_as_unicode,                                                                                  result->conn->options->int_and_float_native,
                                                                                  result->conn->options.int_and_float_native, 
                                                                                   result->conn->stats TSRMLS_CC);                                                                                    result->conn->stats TSRMLS_CC);
                         if (PASS != rc) {                          if (PASS != rc) {
                                 DBG_RETURN(retrow);                                  DBG_RETURN(retrow);
Line 715  mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TS Line 702  mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TS
                                         }                                          }
                                 }                                  }
                         } else {                          } else {
                                SET_OOM_ERROR(result->conn->error_info);                                SET_OOM_ERROR(*result->conn->error_info);
                         }                          }
                 }                  }
         } else if (ret == FAIL) {          } else if (ret == FAIL) {
                 if (row_packet->error_info.error_no) {                  if (row_packet->error_info.error_no) {
                        result->conn->error_info = row_packet->error_info;                        COPY_CLIENT_ERROR(*result->conn->error_info, row_packet->error_info);
                         DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);                          DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);
                 }                  }
                 CONN_SET_STATE(result->conn, CONN_READY);                  CONN_SET_STATE(result->conn, CONN_READY);
                 result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */                  result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
         } else if (row_packet->eof) {          } else if (row_packet->eof) {
                 /* Mark the connection as usable again */                  /* Mark the connection as usable again */
                DBG_INF_FMT("warningss=%u server_status=%u", row_packet->warning_count, row_packet->server_status);                DBG_INF_FMT("warnings=%u server_status=%u", row_packet->warning_count, row_packet->server_status);
                 result->unbuf->eof_reached = TRUE;                  result->unbuf->eof_reached = TRUE;
                result->conn->upsert_status.warning_count = row_packet->warning_count;                memset(result->conn->upsert_status, 0, sizeof(*result->conn->upsert_status));
                result->conn->upsert_status.server_status = row_packet->server_status;                result->conn->upsert_status->warning_count = row_packet->warning_count;
                 result->conn->upsert_status->server_status = row_packet->server_status;
                 /*                  /*
                   result->row_packet will be cleaned when                    result->row_packet will be cleaned when
                   destroying the result object                    destroying the result object
                 */                  */
                if (result->conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS) {                if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
                         CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);                          CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
                 } else {                  } else {
                         CONN_SET_STATE(result->conn, CONN_READY);                          CONN_SET_STATE(result->conn, CONN_READY);
Line 757  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi Line 745  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi
         MYSQLND_PACKET_ROW      *row_packet = result->row_packet;          MYSQLND_PACKET_ROW      *row_packet = result->row_packet;
   
         DBG_ENTER("mysqlnd_fetch_row_unbuffered");          DBG_ENTER("mysqlnd_fetch_row_unbuffered");
         DBG_INF_FMT("flags=%u", flags);  
   
         *fetched_anything = FALSE;          *fetched_anything = FALSE;
         if (result->unbuf->eof_reached) {          if (result->unbuf->eof_reached) {
Line 765  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi Line 752  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi
                 DBG_RETURN(PASS);                  DBG_RETURN(PASS);
         }          }
         if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {          if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
                SET_CLIENT_ERROR(result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);                SET_CLIENT_ERROR(*result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                 DBG_RETURN(FAIL);                  DBG_RETURN(FAIL);
         }          }
         if (!row_packet) {          if (!row_packet) {
Line 800  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi Line 787  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi
                                                                                         result->unbuf->last_row_data,                                                                                          result->unbuf->last_row_data,
                                                                                         field_count,                                                                                          field_count,
                                                                                         row_packet->fields_metadata,                                                                                          row_packet->fields_metadata,
                                                                                        FALSE,                                                                                        result->conn->options->numeric_and_datetime_as_unicode,
                                                                                        result->conn->options.numeric_and_datetime_as_unicode,                                                                                        result->conn->options->int_and_float_native,
                                                                                        result->conn->options.int_and_float_native, 
                                                                                         result->conn->stats TSRMLS_CC);                                                                                          result->conn->stats TSRMLS_CC);
                         if (PASS != rc) {                          if (PASS != rc) {
                                 DBG_RETURN(FAIL);                                  DBG_RETURN(FAIL);
Line 857  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi Line 843  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi
                 result->unbuf->row_count++;                  result->unbuf->row_count++;
         } else if (ret == FAIL) {          } else if (ret == FAIL) {
                 if (row_packet->error_info.error_no) {                  if (row_packet->error_info.error_no) {
                        result->conn->error_info = row_packet->error_info;                        COPY_CLIENT_ERROR(*result->conn->error_info, row_packet->error_info);
                         DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);                          DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);
                 }                  }
                 CONN_SET_STATE(result->conn, CONN_READY);                  CONN_SET_STATE(result->conn, CONN_READY);
Line 866  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi Line 852  mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, voi
                 /* Mark the connection as usable again */                  /* Mark the connection as usable again */
                 DBG_INF_FMT("warnings=%u server_status=%u", row_packet->warning_count, row_packet->server_status);                  DBG_INF_FMT("warnings=%u server_status=%u", row_packet->warning_count, row_packet->server_status);
                 result->unbuf->eof_reached = TRUE;                  result->unbuf->eof_reached = TRUE;
                result->conn->upsert_status.warning_count = row_packet->warning_count;                memset(result->conn->upsert_status, 0, sizeof(*result->conn->upsert_status));
                result->conn->upsert_status.server_status = row_packet->server_status;                result->conn->upsert_status->warning_count = row_packet->warning_count;
                 result->conn->upsert_status->server_status = row_packet->server_status;
                 /*                  /*
                   result->row_packet will be cleaned when                    result->row_packet will be cleaned when
                   destroying the result object                    destroying the result object
                 */                  */
                if (result->conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS) {                if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
                         CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);                          CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
                 } else {                  } else {
                         CONN_SET_STATE(result->conn, CONN_READY);                          CONN_SET_STATE(result->conn, CONN_READY);
Line 891  static MYSQLND_RES * Line 878  static MYSQLND_RES *
 MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES * const result, zend_bool ps TSRMLS_DC)  MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES * const result, zend_bool ps TSRMLS_DC)
 {  {
         DBG_ENTER("mysqlnd_res::use_result");          DBG_ENTER("mysqlnd_res::use_result");
         DBG_INF_FMT("ps=%u", ps);  
   
        SET_EMPTY_ERROR(result->conn->error_info);        SET_EMPTY_ERROR(*result->conn->error_info);
   
   
         if (ps == FALSE) {          if (ps == FALSE) {
                 result->type                    = MYSQLND_RES_NORMAL;                  result->type                    = MYSQLND_RES_NORMAL;
                 result->m.fetch_row             = result->m.fetch_row_normal_unbuffered;                  result->m.fetch_row             = result->m.fetch_row_normal_unbuffered;
Line 939  MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES *  Line 924  MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES * 
   
         DBG_RETURN(result);          DBG_RETURN(result);
 oom:  oom:
        SET_OOM_ERROR(result->conn->error_info);        SET_OOM_ERROR(*result->conn->error_info);
         DBG_RETURN(NULL);          DBG_RETURN(NULL);
 }  }
 /* }}} */  /* }}} */
Line 969  mysqlnd_fetch_row_buffered_c(MYSQLND_RES * result TSRM Line 954  mysqlnd_fetch_row_buffered_c(MYSQLND_RES * result TSRM
                                                                                         current_row,                                                                                          current_row,
                                                                                         result->meta->field_count,                                                                                          result->meta->field_count,
                                                                                         result->meta->fields,                                                                                          result->meta->fields,
                                                                                        FALSE,                                                                                        result->conn->options->numeric_and_datetime_as_unicode,
                                                                                        result->conn->options.numeric_and_datetime_as_unicode,                                                                                        result->conn->options->int_and_float_native,
                                                                                        result->conn->options.int_and_float_native, 
                                                                                         result->conn->stats TSRMLS_CC);                                                                                          result->conn->stats TSRMLS_CC);
                         if (rc != PASS) {                          if (rc != PASS) {
                                 DBG_RETURN(ret);                                  DBG_RETURN(ret);
Line 1028  mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void  Line 1012  mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void 
         enum_func_status ret = FAIL;          enum_func_status ret = FAIL;
   
         DBG_ENTER("mysqlnd_fetch_row_buffered");          DBG_ENTER("mysqlnd_fetch_row_buffered");
         DBG_INF_FMT("flags=%u row=%p", flags, row);  
   
         /* If we haven't read everything */          /* If we haven't read everything */
         if (set->data_cursor &&          if (set->data_cursor &&
Line 1044  mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void  Line 1027  mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void 
                                                                                         current_row,                                                                                          current_row,
                                                                                         result->meta->field_count,                                                                                          result->meta->field_count,
                                                                                         result->meta->fields,                                                                                          result->meta->fields,
                                                                                        result->stored_data->persistent,                                                                                        result->conn->options->numeric_and_datetime_as_unicode,
                                                                                        result->conn->options.numeric_and_datetime_as_unicode,                                                                                        result->conn->options->int_and_float_native,
                                                                                        result->conn->options.int_and_float_native, 
                                                                                         result->conn->stats TSRMLS_CC);                                                                                          result->conn->stats TSRMLS_CC);
                         if (rc != PASS) {                          if (rc != PASS) {
                                 DBG_RETURN(FAIL);                                  DBG_RETURN(FAIL);
Line 1124  mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void  Line 1106  mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void 
   
 /* {{{ mysqlnd_res::store_result_fetch_data */  /* {{{ mysqlnd_res::store_result_fetch_data */
 enum_func_status  enum_func_status
MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND * const conn, MYSQLND_RES * result,MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result,
                                                                                                         MYSQLND_RES_METADATA *meta,                                                                                                          MYSQLND_RES_METADATA *meta,
                                                                                                        zend_bool binary_protocol,                                                                                                        zend_bool binary_protocol TSRMLS_DC)
                                                                                                        zend_bool to_cache TSRMLS_DC) 
 {  {
         enum_func_status ret;          enum_func_status ret;
         MYSQLND_PACKET_ROW *row_packet = NULL;          MYSQLND_PACKET_ROW *row_packet = NULL;
Line 1135  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M Line 1116  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M
         MYSQLND_RES_BUFFERED *set;          MYSQLND_RES_BUFFERED *set;
   
         DBG_ENTER("mysqlnd_res::store_result_fetch_data");          DBG_ENTER("mysqlnd_res::store_result_fetch_data");
         DBG_INF_FMT("conn=%llu binary_proto=%u to_cache=%u",  
                                 conn->thread_id, binary_protocol, to_cache);  
   
        result->stored_data     = set = mnd_pecalloc(1, sizeof(MYSQLND_RES_BUFFERED), to_cache);        result->stored_data     = set = mnd_ecalloc(1, sizeof(MYSQLND_RES_BUFFERED));
         if (!set) {          if (!set) {
                SET_OOM_ERROR(conn->error_info);                SET_OOM_ERROR(*conn->error_info);
                 ret = FAIL;                  ret = FAIL;
                 goto end;                  goto end;
         }          }
         if (free_rows) {          if (free_rows) {
                set->row_buffers = mnd_pemalloc((size_t)(free_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), to_cache);                set->row_buffers = mnd_emalloc((size_t)(free_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
                 if (!set->row_buffers) {                  if (!set->row_buffers) {
                        SET_OOM_ERROR(conn->error_info);                        SET_OOM_ERROR(*conn->error_info);
                         ret = FAIL;                          ret = FAIL;
                         goto end;                          goto end;
                 }                  }
         }          }
         set->persistent = to_cache;  
         set->references = 1;          set->references = 1;
   
         result->m.row_decoder = binary_protocol? php_mysqlnd_rowp_read_binary_protocol:  
                                                                                          php_mysqlnd_rowp_read_text_protocol;  
   
         /* non-persistent */          /* non-persistent */
         row_packet = conn->protocol->m.get_row_packet(conn->protocol, FALSE TSRMLS_CC);          row_packet = conn->protocol->m.get_row_packet(conn->protocol, FALSE TSRMLS_CC);
         if (!row_packet) {          if (!row_packet) {
                SET_OOM_ERROR(conn->error_info);                SET_OOM_ERROR(*conn->error_info);
                 ret = FAIL;                  ret = FAIL;
                 goto end;                  goto end;
         }          }
Line 1182  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M Line 1157  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M
   
                         /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */                          /* 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_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
                                SET_OOM_ERROR(conn->error_info);                                SET_OOM_ERROR(*conn->error_info);
                                 ret = FAIL;                                  ret = FAIL;
                                 goto end;                                  goto end;
                         }                          }
                        new_row_buffers = mnd_perealloc(set->row_buffers,                        new_row_buffers = mnd_erealloc(set->row_buffers, (size_t)(total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
                                                                                        (size_t)(total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), 
                                                                                        set->persistent); 
                         if (!new_row_buffers) {                          if (!new_row_buffers) {
                                SET_OOM_ERROR(conn->error_info);                                SET_OOM_ERROR(*conn->error_info);
                                 ret = FAIL;                                  ret = FAIL;
                                 goto end;                                  goto end;
                         }                          }
Line 1216  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M Line 1189  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M
         if (set->row_count) {          if (set->row_count) {
                 /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */                  /* 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 * meta->field_count * sizeof(zval *) > SIZE_MAX) {                  if (set->row_count * meta->field_count * sizeof(zval *) > SIZE_MAX) {
                        SET_OOM_ERROR(conn->error_info);                        SET_OOM_ERROR(*conn->error_info);
                         ret = FAIL;                          ret = FAIL;
                         goto end;                          goto end;
                 }                  }
                 /* if pecalloc is used valgrind barks gcc version 4.3.1 20080507 (prerelease) [gcc-4_3-branch revision 135036] (SUSE Linux) */                  /* if pecalloc is used valgrind barks gcc version 4.3.1 20080507 (prerelease) [gcc-4_3-branch revision 135036] (SUSE Linux) */
                set->data = mnd_pemalloc((size_t)(set->row_count * meta->field_count * sizeof(zval *)), to_cache);                set->data = mnd_emalloc((size_t)(set->row_count * meta->field_count * sizeof(zval *)));
                 if (!set->data) {                  if (!set->data) {
                        SET_OOM_ERROR(conn->error_info);                        SET_OOM_ERROR(*conn->error_info);
                         ret = FAIL;                          ret = FAIL;
                         goto end;                          goto end;
                 }                  }
Line 1237  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M Line 1210  MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(M
   
         /* Finally clean */          /* Finally clean */
         if (row_packet->eof) {           if (row_packet->eof) { 
                conn->upsert_status.warning_count = row_packet->warning_count;                memset(conn->upsert_status, 0, sizeof(*conn->upsert_status));
                conn->upsert_status.server_status = row_packet->server_status;                conn->upsert_status->warning_count = row_packet->warning_count;
                 conn->upsert_status->server_status = row_packet->server_status;
         }          }
         /* save some memory */          /* save some memory */
         if (free_rows) {          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 */                  /* 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_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
                        SET_OOM_ERROR(conn->error_info);                        SET_OOM_ERROR(*conn->error_info);
                         ret = FAIL;                          ret = FAIL;
                         goto end;                          goto end;
                 }                  }
                set->row_buffers = mnd_perealloc(set->row_buffers,                set->row_buffers = mnd_erealloc(set->row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
                                                                                 (size_t) (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), 
                                                                                 set->persistent); 
         }          }
   
        if (conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS) {        if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
                 CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);                  CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);
         } else {          } else {
                 CONN_SET_STATE(conn, CONN_READY);                  CONN_SET_STATE(conn, CONN_READY);
         }          }
   
         if (ret == FAIL) {          if (ret == FAIL) {
                set->error_info = row_packet->error_info;                COPY_CLIENT_ERROR(set->error_info, row_packet->error_info);
         } else {          } else {
                 /* Position at the first row */                  /* Position at the first row */
                 set->data_cursor = set->data;                  set->data_cursor = set->data;
   
                 /* libmysql's documentation says it should be so for SELECT statements */                  /* libmysql's documentation says it should be so for SELECT statements */
                conn->upsert_status.affected_rows = set->row_count;                conn->upsert_status->affected_rows = set->row_count;
         }          }
         DBG_INF_FMT("ret=%s row_count=%u warnings=%u server_status=%u",          DBG_INF_FMT("ret=%s row_count=%u warnings=%u server_status=%u",
                                ret == PASS? "PASS":"FAIL", (uint) set->row_count, conn->upsert_status.warning_count, conn->upsert_status.server_status);                                ret == PASS? "PASS":"FAIL", (uint) set->row_count, conn->upsert_status->warning_count, conn->upsert_status->server_status);
 end:  end:
         PACKET_FREE(row_packet);          PACKET_FREE(row_packet);
   
Line 1281  end: Line 1253  end:
 /* {{{ mysqlnd_res::store_result */  /* {{{ mysqlnd_res::store_result */
 static MYSQLND_RES *  static MYSQLND_RES *
 MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,  MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,
                                                                                  MYSQLND * const conn,                                                                                  MYSQLND_CONN_DATA * const conn,
                                                                                   zend_bool ps_protocol TSRMLS_DC)                                                                                    zend_bool ps_protocol TSRMLS_DC)
 {  {
         enum_func_status ret;          enum_func_status ret;
         zend_bool to_cache = FALSE;  
   
         DBG_ENTER("mysqlnd_res::store_result");          DBG_ENTER("mysqlnd_res::store_result");
         DBG_INF_FMT("conn=%u ps_protocol=%u", conn->thread_id, ps_protocol);  
   
         /* We need the conn because we are doing lazy zval initialization in buffered_fetch_row */          /* We need the conn because we are doing lazy zval initialization in buffered_fetch_row */
         result->conn                    = conn->m->get_reference(conn TSRMLS_CC);          result->conn                    = conn->m->get_reference(conn TSRMLS_CC);
         result->type                    = MYSQLND_RES_NORMAL;          result->type                    = MYSQLND_RES_NORMAL;
         result->m.fetch_row             = result->m.fetch_row_normal_buffered;          result->m.fetch_row             = result->m.fetch_row_normal_buffered;
         result->m.fetch_lengths = mysqlnd_fetch_lengths_buffered;          result->m.fetch_lengths = mysqlnd_fetch_lengths_buffered;
           result->m.row_decoder = ps_protocol? php_mysqlnd_rowp_read_binary_protocol:
                                                                                    php_mysqlnd_rowp_read_text_protocol;
   
         result->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size) TSRMLS_CC);          result->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size) TSRMLS_CC);
         result->lengths = mnd_ecalloc(result->field_count, sizeof(unsigned long));          result->lengths = mnd_ecalloc(result->field_count, sizeof(unsigned long));
   
         if (!result->result_set_memory_pool || !result->lengths) {          if (!result->result_set_memory_pool || !result->lengths) {
                SET_OOM_ERROR(conn->error_info);                SET_OOM_ERROR(*conn->error_info);
                 DBG_RETURN(NULL);                  DBG_RETURN(NULL);
         }          }
   
         CONN_SET_STATE(conn, CONN_FETCHING_DATA);          CONN_SET_STATE(conn, CONN_FETCHING_DATA);
   
        ret = result->m.store_result_fetch_data(conn, result, result->meta, ps_protocol, to_cache TSRMLS_CC);        ret = result->m.store_result_fetch_data(conn, result, result->meta, ps_protocol TSRMLS_CC);
         if (FAIL == ret) {          if (FAIL == ret) {
                 if (result->stored_data) {                  if (result->stored_data) {
                        conn->error_info = result->stored_data->error_info;                        COPY_CLIENT_ERROR(*conn->error_info, result->stored_data->error_info);
                 } else {                  } else {
                        SET_OOM_ERROR(conn->error_info);                        SET_OOM_ERROR(*conn->error_info);
                 }                  }
                 DBG_RETURN(NULL);                  DBG_RETURN(NULL);
         }          }
         /* libmysql's documentation says it should be so for SELECT statements */          /* libmysql's documentation says it should be so for SELECT statements */
        conn->upsert_status.affected_rows = result->stored_data->row_count;        conn->upsert_status->affected_rows = result->stored_data->row_count;
   
         DBG_RETURN(result);          DBG_RETURN(result);
 }  }
Line 1357  static enum_func_status Line 1330  static enum_func_status
 MYSQLND_METHOD(mysqlnd_res, free_result)(MYSQLND_RES * result, zend_bool implicit TSRMLS_DC)  MYSQLND_METHOD(mysqlnd_res, free_result)(MYSQLND_RES * result, zend_bool implicit TSRMLS_DC)
 {  {
         DBG_ENTER("mysqlnd_res::free_result");          DBG_ENTER("mysqlnd_res::free_result");
         DBG_INF_FMT("implicit=%u", implicit);  
   
         result->m.skip_result(result TSRMLS_CC);          result->m.skip_result(result TSRMLS_CC);
         MYSQLND_INC_CONN_STATISTIC(result->conn? result->conn->stats : NULL,          MYSQLND_INC_CONN_STATISTIC(result->conn? result->conn->stats : NULL,
Line 1522  MYSQLND_METHOD(mysqlnd_res, field_tell)(const MYSQLND_ Line 1494  MYSQLND_METHOD(mysqlnd_res, field_tell)(const MYSQLND_
 /* }}} */  /* }}} */
   
   
 /* for php_addslashes */  
 #include "ext/standard/php_string.h"  
   
 /* {{{ mysqlnd_res::fetch_into */  /* {{{ mysqlnd_res::fetch_into */
 static void  static void
 MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * result, unsigned int flags,  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * result, unsigned int flags,
Line 1534  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES *  Line 1503  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * 
         zend_bool fetched_anything;          zend_bool fetched_anything;
   
         DBG_ENTER("mysqlnd_res::fetch_into");          DBG_ENTER("mysqlnd_res::fetch_into");
         DBG_INF_FMT("flags=%u mysqlnd_extension=%u", flags, extension);  
   
         if (!result->m.fetch_row) {          if (!result->m.fetch_row) {
                 RETVAL_NULL();                  RETVAL_NULL();
Line 1547  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES *  Line 1515  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * 
         mysqlnd_array_init(return_value, mysqlnd_num_fields(result) * 2);          mysqlnd_array_init(return_value, mysqlnd_num_fields(result) * 2);
         if (FAIL == result->m.fetch_row(result, (void *)return_value, flags, &fetched_anything TSRMLS_CC)) {          if (FAIL == result->m.fetch_row(result, (void *)return_value, flags, &fetched_anything TSRMLS_CC)) {
                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading a row");                  php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading a row");
                   zval_dtor(return_value);
                 RETVAL_FALSE;                  RETVAL_FALSE;
         } else if (fetched_anything == FALSE) {          } else if (fetched_anything == FALSE) {
                 zval_dtor(return_value);                  zval_dtor(return_value);
Line 1559  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES *  Line 1528  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * 
                                 break;                                  break;
                         default:exit(0);                          default:exit(0);
                 }                  }
        }         }
         /*          /*
           return_value is IS_NULL for no more data and an array for data. Thus it's ok            return_value is IS_NULL for no more data and an array for data. Thus it's ok
           to return here.            to return here.
Line 1599  MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * r Line 1568  MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * r
         MYSQLND_RES_BUFFERED *set = result->stored_data;          MYSQLND_RES_BUFFERED *set = result->stored_data;
   
         DBG_ENTER("mysqlnd_res::fetch_all");          DBG_ENTER("mysqlnd_res::fetch_all");
         DBG_INF_FMT("flags=%u", flags);  
   
         if ((!result->unbuf && !set)) {          if ((!result->unbuf && !set)) {
                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "fetch_all can be used only with buffered sets");                  php_error_docref(NULL TSRMLS_CC, E_WARNING, "fetch_all can be used only with buffered sets");
                 if (result->conn) {                  if (result->conn) {
                        SET_CLIENT_ERROR(result->conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "fetch_all can be used only with buffered sets");                        SET_CLIENT_ERROR(*result->conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "fetch_all can be used only with buffered sets");
                 }                  }
                 RETVAL_NULL();                  RETVAL_NULL();
                 DBG_VOID_RETURN;                  DBG_VOID_RETURN;
Line 1672  MYSQLND_METHOD(mysqlnd_res, fetch_field_data)(MYSQLND_ Line 1640  MYSQLND_METHOD(mysqlnd_res, fetch_field_data)(MYSQLND_
 /* }}} */  /* }}} */
   
   
 static   
 MYSQLND_CLASS_METHODS_START(mysqlnd_res)  MYSQLND_CLASS_METHODS_START(mysqlnd_res)
         NULL, /* fetch_row */          NULL, /* fetch_row */
         mysqlnd_fetch_row_buffered,          mysqlnd_fetch_row_buffered,
Line 1717  mysqlnd_result_init(unsigned int field_count, zend_boo Line 1684  mysqlnd_result_init(unsigned int field_count, zend_boo
         MYSQLND_RES *ret = mnd_pecalloc(1, alloc_size, persistent);          MYSQLND_RES *ret = mnd_pecalloc(1, alloc_size, persistent);
   
         DBG_ENTER("mysqlnd_result_init");          DBG_ENTER("mysqlnd_result_init");
         DBG_INF_FMT("field_count=%u", field_count);  
   
         if (!ret) {          if (!ret) {
                 DBG_RETURN(NULL);                  DBG_RETURN(NULL);
Line 1725  mysqlnd_result_init(unsigned int field_count, zend_boo Line 1691  mysqlnd_result_init(unsigned int field_count, zend_boo
   
         ret->persistent         = persistent;          ret->persistent         = persistent;
         ret->field_count        = field_count;          ret->field_count        = field_count;
        ret->m = mysqlnd_mysqlnd_res_methods;        ret->m = *mysqlnd_result_get_methods();
   
         DBG_RETURN(ret);          DBG_RETURN(ret);
 }  }
 /* }}} */  /* }}} */
   
   
 /* {{{ _mysqlnd_plugin_get_plugin_result_data */  
 PHPAPI void ** _mysqlnd_plugin_get_plugin_result_data(const MYSQLND_RES * result, unsigned int plugin_id TSRMLS_DC)  
 {  
         DBG_ENTER("_mysqlnd_plugin_get_plugin_result_data");  
         DBG_INF_FMT("plugin_id=%u", plugin_id);  
         if (!result || plugin_id >= mysqlnd_plugin_count()) {  
                 return NULL;  
         }  
         DBG_RETURN((void *)((char *)result + sizeof(MYSQLND_RES) + plugin_id * sizeof(void *)));  
 }  
 /* }}} */  
   
   
 /* {{{ mysqlnd_result_get_methods */  
 PHPAPI struct st_mysqlnd_res_methods *  
 mysqlnd_result_get_methods()  
 {  
         return &mysqlnd_mysqlnd_res_methods;  
 }  
 /* }}} */  
   
 /*  /*
  * Local variables:   * Local variables:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>