[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.2

version 1.1.1.1, 2012/02/21 23:47:58 version 1.1.1.2, 2012/05/29 12:34:41
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;
   
                 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 = set->data + row * field_count;
                         MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row];                          MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row];
Line 213  MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLN Line 209  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 217  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(set->data);
                 set->data = NULL;                  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 262  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 315  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 332  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 360  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 374  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 396  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 426  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;                                conn->upsert_status->warning_count = rset_header->warning_count;
                                conn->upsert_status.server_status = rset_header->server_status;                                conn->upsert_status->server_status = rset_header->server_status;
                                conn->upsert_status.affected_rows = rset_header->affected_rows;                                conn->upsert_status->affected_rows = rset_header->affected_rows;
                                conn->upsert_status.last_insert_id = rset_header->last_insert_id;                                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 450  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 486  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 518  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 504  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY
                                 /* 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;
                                 }                                  }
Line 537  mysqlnd_query_read_result_set_header(MYSQLND *conn, MY Line 523  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 531  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 634  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 669  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 700  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;                result->conn->upsert_status->warning_count = row_packet->warning_count;
                result->conn->upsert_status.server_status = row_packet->server_status;                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 742  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 749  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 784  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 840  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 849  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;                result->conn->upsert_status->warning_count = row_packet->warning_count;
                result->conn->upsert_status.server_status = row_packet->server_status;                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 874  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 920  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 950  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 1008  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 1023  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 1102  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 1112  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 1153  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 1185  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 1206  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;                conn->upsert_status->warning_count = row_packet->warning_count;
                conn->upsert_status.server_status = row_packet->server_status;                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 1248  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 1325  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 1489  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 1498  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 1559  MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES *  Line 1522  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 1562  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 1634  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 1678  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 1685  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.2

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