1 files changed, 74 insertions, 173 deletions

diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c
index 2d4da2626b..ea275be192 100644
--- a/ext/mysqlnd/mysqlnd_result.c
+++ b/ext/mysqlnd/mysqlnd_result.c
@@ -43,8 +43,8 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND
 	const uint64_t row_count = result->row_count;
 	enum_func_status rc;
 
-	zval **data_begin = ((MYSQLND_RES_BUFFERED_ZVAL *) result)->data;
-	zval **data_cursor = data_begin;
+	zval *data_begin = ((MYSQLND_RES_BUFFERED_ZVAL *) result)->data;
+	zval *data_cursor = data_begin;
 
 	DBG_ENTER("mysqlnd_result_buffered_zval::initialize_result_set_rest");
 
@@ -52,7 +52,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND
 		DBG_RETURN(ret);
 	}
 	while ((data_cursor - data_begin) < (int)(row_count * field_count)) {
-		if (NULL == data_cursor[0]) {
+		if (Z_ISUNDEF(data_cursor[0])) {
 			rc = result->m.row_decoder(result->row_buffers[(data_cursor - data_begin) / field_count],
 									data_cursor,
 									field_count,
@@ -70,8 +70,8 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND
 				  String of zero size, definitely can't be the next max_length.
 				  Thus for NULL and zero-length we are quite efficient.
 				*/
-				if (Z_TYPE_P(data_cursor[i]) >= IS_STRING) {
-					unsigned long len = Z_STRLEN_P(data_cursor[i]);
+				if (Z_TYPE(data_cursor[i]) == IS_STRING) {
+					zend_ulong len = Z_STRLEN(data_cursor[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -99,7 +99,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RE
 
 	if (result->initialized_rows < row_count) {
 		zend_uchar * initialized = ((MYSQLND_RES_BUFFERED_C *) result)->initialized;
-		zval ** current_row = mnd_emalloc(field_count * sizeof(zval *));
+		zval * current_row = mnd_emalloc(field_count * sizeof(zval));
 
 		if (!current_row) {
 			DBG_RETURN(FAIL);
@@ -125,8 +125,8 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RE
 				  String of zero size, definitely can't be the next max_length.
 				  Thus for NULL and zero-length we are quite efficient.
 				*/
-				if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
-					unsigned long len = Z_STRLEN_P(current_row[i]);
+				if (Z_TYPE(current_row[i]) == IS_STRING) {
+					zend_ulong len = Z_STRLEN(current_row[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -141,52 +141,6 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RE
 /* }}} */
 
 
-/* {{{ mysqlnd_rset_zval_ptr_dtor */
-static void
-mysqlnd_rset_zval_ptr_dtor(zval **zv, enum_mysqlnd_res_type type, zend_bool * copy_ctor_called TSRMLS_DC)
-{
-	DBG_ENTER("mysqlnd_rset_zval_ptr_dtor");
-	DBG_INF_FMT("type=%u", type);
-	if (!zv || !*zv) {
-		*copy_ctor_called = FALSE;
-		DBG_ERR_FMT("zv was NULL");
-		DBG_VOID_RETURN;
-	}
-	/*
-	  This zval is not from the cache block.
-	  Thus the refcount is -1 than of a zval from the cache,
-	  because the zvals from the cache are owned by it.
-	*/
-	if (type == MYSQLND_RES_PS_BUF || type == MYSQLND_RES_PS_UNBUF) {
-		*copy_ctor_called = FALSE;
-		; /* do nothing, zval_ptr_dtor will do the job*/
-	} else if (Z_REFCOUNT_PP(zv) > 1) {
-		/*
-		  Not a prepared statement, then we have to
-		  call copy_ctor and then zval_ptr_dtor()
-		*/
-		if (Z_TYPE_PP(zv) == IS_STRING) {
-			zval_copy_ctor(*zv);
-		}
-		*copy_ctor_called = TRUE;
-	} else {
-		/*
-		  noone but us point to this, so we can safely ZVAL_NULL the zval,
-		  so Zend does not try to free what the zval points to - which is
-		  in result set buffers
-		*/
-		*copy_ctor_called = FALSE;
-		if (Z_TYPE_PP(zv) == IS_STRING) {
-			ZVAL_NULL(*zv);
-		}
-	}
-	DBG_INF_FMT("call the dtor on zval with refc %u", Z_REFCOUNT_PP(zv));
-	zval_ptr_dtor(zv);
-	DBG_VOID_RETURN;
-}
-/* }}} */
-
-
 /* {{{ mysqlnd_result_unbuffered::free_last_data */
 static void
 MYSQLND_METHOD(mysqlnd_result_unbuffered, free_last_data)(MYSQLND_RES_UNBUFFERED * unbuf, MYSQLND_STATS * const global_stats TSRMLS_DC)
@@ -199,23 +153,11 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, free_last_data)(MYSQLND_RES_UNBUFFERED
 
 	DBG_INF_FMT("field_count=%u", unbuf->field_count);
 	if (unbuf->last_row_data) {
-		unsigned int i, ctor_called_count = 0;
-		zend_bool copy_ctor_called;
-
+		unsigned int i;
 		for (i = 0; i < unbuf->field_count; i++) {
-			mysqlnd_rset_zval_ptr_dtor(&(unbuf->last_row_data[i]), unbuf->ps ? MYSQLND_RES_PS_UNBUF : MYSQLND_RES_NORMAL, &copy_ctor_called TSRMLS_CC);
-			if (copy_ctor_called) {
-				++ctor_called_count;
-			}
+			zval_ptr_dtor(&(unbuf->last_row_data[i]));
 		}
 
-		DBG_INF_FMT("copy_ctor_called_count=%u", ctor_called_count);
-		/* By using value3 macros we hold a mutex only once, there is no value2 */
-		MYSQLND_INC_CONN_STATISTIC_W_VALUE2(global_stats,
-											STAT_COPY_ON_WRITE_PERFORMED,
-											ctor_called_count,
-											STAT_COPY_ON_WRITE_SAVED,
-											unbuf->field_count - ctor_called_count);
 		/* Free last row's zvals */
 		mnd_efree(unbuf->last_row_data);
 		unbuf->last_row_data = NULL;
@@ -266,37 +208,25 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, free_result)(MYSQLND_RES_UNBUFFERED *
 static void
 MYSQLND_METHOD(mysqlnd_result_buffered_zval, free_result)(MYSQLND_RES_BUFFERED_ZVAL * const set TSRMLS_DC)
 {
-	zval ** data = set->data;
+	zval * data = set->data;
 
 	DBG_ENTER("mysqlnd_result_buffered_zval::free_result");
 
 	set->data = NULL; /* prevent double free if following loop is interrupted */
 	if (data) {
-		unsigned int copy_on_write_performed = 0;
-		unsigned int copy_on_write_saved = 0;
 		unsigned int field_count = set->field_count;
 		int64_t row;
 	
 		for (row = set->row_count - 1; row >= 0; row--) {
-			zval **current_row = data + row * field_count;
+			zval *current_row = data + row * field_count;
 			int64_t col;
 
 			if (current_row != NULL) {
 				for (col = field_count - 1; col >= 0; --col) {
-					if (current_row[col]) {
-						zend_bool copy_ctor_called;
-						mysqlnd_rset_zval_ptr_dtor(&(current_row[col]), set->ps? MYSQLND_RES_PS_BUF : MYSQLND_RES_NORMAL, &copy_ctor_called TSRMLS_CC);
-						if (copy_ctor_called) {
-							++copy_on_write_performed;
-						} else {
-							++copy_on_write_saved;
-						}
-					}
+					zval_ptr_dtor(&(current_row[col]));
 				}
 			}
 		}
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_COPY_ON_WRITE_PERFORMED, copy_on_write_performed,
-											  STAT_COPY_ON_WRITE_SAVED, copy_on_write_saved);
 		mnd_efree(data);
 	}
 	set->data_cursor = NULL;
@@ -630,8 +560,6 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s
 						stmt->state = MYSQLND_STMT_INITTED;
 					}
 				} else {
-					unsigned int to_log = MYSQLND_G(log_mask);
-					to_log &= 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;
 					/*
@@ -649,13 +577,6 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s
 					} else if (fields_eof->server_status & SERVER_QUERY_WAS_SLOW) {
 						statistic = STAT_QUERY_WAS_SLOW;
 					}
-					if (to_log) {
-#if A0
-						char *backtrace = mysqlnd_get_backtrace(TSRMLS_C);
-						php_log_err(backtrace TSRMLS_CC);
-						efree(backtrace);
-#endif
-					}
 					MYSQLND_INC_CONN_STATISTIC(conn->stats, statistic);
 				}
 			} while (0);
@@ -678,7 +599,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s
   of PHP, to be called as separate function. But let's have it for
   completeness.
 */
-static unsigned long *
+static zend_ulong *
 MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_lengths)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC)
 {
 	const MYSQLND_RES_BUFFERED_ZVAL * set = (MYSQLND_RES_BUFFERED_ZVAL *) result;
@@ -710,7 +631,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_lengths)(MYSQLND_RES_BUFFERED
   of PHP, to be called as separate function. But let's have it for
   completeness.
 */
-static unsigned long *
+static zend_ulong *
 MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_lengths)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC)
 {
 	const MYSQLND_RES_BUFFERED_C * set = (MYSQLND_RES_BUFFERED_C *) result;
@@ -727,7 +648,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_lengths)(MYSQLND_RES_BUFFERED *
 
 
 /* {{{ mysqlnd_result_unbuffered::fetch_lengths */
-static unsigned long *
+static zend_ulong *
 MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_lengths)(MYSQLND_RES_UNBUFFERED * const result TSRMLS_DC)
 {
 	/* simulate output of libmysql */
@@ -737,10 +658,10 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_lengths)(MYSQLND_RES_UNBUFFERED
 
 
 /* {{{ mysqlnd_res::fetch_lengths */
-static unsigned long *
+static zend_ulong *
 MYSQLND_METHOD(mysqlnd_res, fetch_lengths)(MYSQLND_RES * const result TSRMLS_DC)
 {
-	unsigned long * ret;
+	zend_ulong * ret;
 	DBG_ENTER("mysqlnd_res::fetch_lengths");
 	ret = result->stored_data && result->stored_data->m.fetch_lengths ?
 					result->stored_data->m.fetch_lengths(result->stored_data TSRMLS_CC) :
@@ -810,11 +731,11 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi
 				*row = mnd_malloc(field_count * sizeof(char *));
 				if (*row) {
 					MYSQLND_FIELD * field = meta->fields;
-					unsigned long * lengths = result->unbuf->lengths;
+					zend_ulong * lengths = result->unbuf->lengths;
 
 					for (i = 0; i < field_count; i++, field++) {
-						zval * data = result->unbuf->last_row_data[i];
-						unsigned int len = (Z_TYPE_P(data) == IS_NULL)? 0:Z_STRLEN_P(data);
+						zval * data = &result->unbuf->last_row_data[i];
+						unsigned int len = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
 
 /* BEGIN difference between normal normal fetch and _c */
 						if (Z_TYPE_P(data) != IS_NULL) {
@@ -928,15 +849,15 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
 			{
 				HashTable * row_ht = Z_ARRVAL_P(row);
 				MYSQLND_FIELD * field = meta->fields;
-				unsigned long * lengths = result->unbuf->lengths;
+				zend_ulong * lengths = result->unbuf->lengths;
 
 				for (i = 0; i < field_count; i++, field++) {
-					zval * data = result->unbuf->last_row_data[i];
-					unsigned int len = (Z_TYPE_P(data) == IS_NULL)? 0:Z_STRLEN_P(data);
+					zval * data = &result->unbuf->last_row_data[i];
+					unsigned int len = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
 
 					if (flags & MYSQLND_FETCH_NUM) {
-						Z_ADDREF_P(data);
-						zend_hash_next_index_insert(row_ht, &data, sizeof(zval *), NULL);
+						Z_TRY_ADDREF_P(data);
+						zend_hash_next_index_insert(row_ht, data);
 					}
 					if (flags & MYSQLND_FETCH_ASSOC) {
 						/* zend_hash_quick_update needs length + trailing zero */
@@ -946,15 +867,11 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
 						  the index is a numeric and convert it to it. This however means constant
 						  hashing of the column name, which is not needed as it can be precomputed.
 						*/
-						Z_ADDREF_P(data);
+						Z_TRY_ADDREF_P(data);
 						if (meta->zend_hash_keys[i].is_numeric == FALSE) {
-							zend_hash_quick_update(Z_ARRVAL_P(row),
-												   field->name,
-												   field->name_length + 1,
-												   meta->zend_hash_keys[i].key,
-												   (void *) &data, sizeof(zval *), NULL);
+							zend_hash_update(Z_ARRVAL_P(row), meta->fields[i].sname, data);
 						} else {
-							zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, (void *) &data, sizeof(zval *), NULL);
+							zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
 						}
 					}
 
@@ -1063,10 +980,10 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void
 		if (set->data_cursor &&
 			(set->data_cursor - set->data) < (result->stored_data->row_count * field_count))
 		{
-			zval **current_row = set->data_cursor;
+			zval *current_row = set->data_cursor;
 			unsigned int i;
 
-			if (NULL == current_row[0]) {
+			if (Z_ISUNDEF(current_row[0])) {
 				uint64_t row_num = (set->data_cursor - set->data) / field_count;
 				enum_func_status rc = set->m.row_decoder(set->row_buffers[row_num],
 												current_row,
@@ -1084,8 +1001,8 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void
 					  String of zero size, definitely can't be the next max_length.
 					  Thus for NULL and zero-length we are quite efficient.
 					*/
-					if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
-						unsigned long len = Z_STRLEN_P(current_row[i]);
+					if (Z_TYPE(current_row[i]) == IS_STRING) {
+						zend_ulong len = Z_STRLEN(current_row[i]);
 						if (meta->fields[i].max_length < len) {
 							meta->fields[i].max_length = len;
 						}
@@ -1098,9 +1015,9 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void
 			*row = mnd_malloc(field_count * sizeof(char *));
 			if (*row) {
 				for (i = 0; i < field_count; i++) {
-					zval * data = current_row[i];
+					zval * data = &current_row[i];
 
-					set->lengths[i] = (Z_TYPE_P(data) == IS_NULL)? 0:Z_STRLEN_P(data);
+					set->lengths[i] = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
 
 					if (Z_TYPE_P(data) != IS_NULL) {
 						convert_to_string(data);
@@ -1155,9 +1072,9 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo
 		(set->data_cursor - set->data) < (set->row_count * field_count))
 	{
 		unsigned int i;
-		zval **current_row = set->data_cursor;
+		zval *current_row = set->data_cursor;
 
-		if (NULL == current_row[0]) {
+		if (Z_ISUNDEF(current_row[0])) {
 			uint64_t row_num = (set->data_cursor - set->data) / field_count;
 			enum_func_status rc = set->m.row_decoder(set->row_buffers[row_num],
 											current_row,
@@ -1175,8 +1092,8 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo
 				  String of zero size, definitely can't be the next max_length.
 				  Thus for NULL and zero-length we are quite efficient.
 				*/
-				if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
-					unsigned long len = Z_STRLEN_P(current_row[i]);
+				if (Z_TYPE(current_row[i]) == IS_STRING) {
+					zend_ulong len = Z_STRLEN(current_row[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -1185,13 +1102,13 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo
 		}
 
 		for (i = 0; i < field_count; i++) {
-			zval * data = current_row[i];
+			zval * data = &current_row[i];
 
-			set->lengths[i] = (Z_TYPE_P(data) == IS_NULL)? 0:Z_STRLEN_P(data);
+			set->lengths[i] = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
 
 			if (flags & MYSQLND_FETCH_NUM) {
-				Z_ADDREF_P(data);
-				zend_hash_next_index_insert(Z_ARRVAL_P(row), &data, sizeof(zval *), NULL);
+				Z_TRY_ADDREF_P(data);
+				zend_hash_next_index_insert(Z_ARRVAL_P(row), data);
 			}
 			if (flags & MYSQLND_FETCH_ASSOC) {
 				/* zend_hash_quick_update needs length + trailing zero */
@@ -1201,17 +1118,11 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo
 				  the index is a numeric and convert it to it. This however means constant
 				  hashing of the column name, which is not needed as it can be precomputed.
 				*/
-				Z_ADDREF_P(data);
+				Z_TRY_ADDREF_P(data);
 				if (meta->zend_hash_keys[i].is_numeric == FALSE) {
-					zend_hash_quick_update(Z_ARRVAL_P(row),
-										   meta->fields[i].name,
-										   meta->fields[i].name_length + 1,
-										   meta->zend_hash_keys[i].key,
-										   (void *) &data, sizeof(zval *), NULL);
+					zend_hash_update(Z_ARRVAL_P(row), meta->fields[i].sname, data);
 				} else {
-						zend_hash_index_update(Z_ARRVAL_P(row),
-										   meta->zend_hash_keys[i].key,
-										   (void *) &data, sizeof(zval *), NULL);
+					zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
 				}
 			}
 		}
@@ -1246,11 +1157,11 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 
 	/* If we haven't read everything */
 	if (set->current_row < set->row_count) {
-		zval **current_row;
+		zval *current_row;
 		enum_func_status rc;
 		unsigned int i;
 
-		current_row = mnd_emalloc(field_count * sizeof(zval *));
+		current_row = mnd_emalloc(field_count * sizeof(zval));
 		if (!current_row) {
 			SET_OOM_ERROR(*result->conn->error_info);
 			DBG_RETURN(FAIL);			
@@ -1276,8 +1187,8 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 				  String of zero size, definitely can't be the next max_length.
 				  Thus for NULL and zero-length we are quite efficient.
 				*/
-				if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
-					unsigned long len = Z_STRLEN_P(current_row[i]);
+				if (Z_TYPE(current_row[i]) == IS_STRING) {
+					zend_ulong len = Z_STRLEN(current_row[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -1286,13 +1197,13 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 		}
 
 		for (i = 0; i < field_count; i++) {
-			zval * data = current_row[i];
+			zval * data = &current_row[i];
 
-			set->lengths[i] = (Z_TYPE_P(data) == IS_NULL)? 0:Z_STRLEN_P(data);
+			set->lengths[i] = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
 			
 			if (flags & MYSQLND_FETCH_NUM) {
-				Z_ADDREF_P(data);
-				zend_hash_next_index_insert(Z_ARRVAL_P(row), &data, sizeof(zval *), NULL);
+				Z_TRY_ADDREF_P(data);
+				zend_hash_next_index_insert(Z_ARRVAL_P(row), data);
 			}
 			if (flags & MYSQLND_FETCH_ASSOC) {
 				/* zend_hash_quick_update needs length + trailing zero */
@@ -1302,17 +1213,11 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 				  the index is a numeric and convert it to it. This however means constant
 				  hashing of the column name, which is not needed as it can be precomputed.
 				*/
-				Z_ADDREF_P(data);
+				Z_TRY_ADDREF_P(data);
 				if (meta->zend_hash_keys[i].is_numeric == FALSE) {
-					zend_hash_quick_update(Z_ARRVAL_P(row),
-										   meta->fields[i].name,
-										   meta->fields[i].name_length + 1,
-										   meta->zend_hash_keys[i].key,
-										   (void *) &data, sizeof(zval *), NULL);
+					zend_hash_update(Z_ARRVAL_P(row), meta->fields[i].sname, data);
 				} else {
-					zend_hash_index_update(Z_ARRVAL_P(row),
-										   meta->zend_hash_keys[i].key,
-										   (void *) &data, sizeof(zval *), NULL);
+					zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
 				}
 			}
 			/*
@@ -1321,7 +1226,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 				It also simplifies the handling of Z_ADDREF_P because we don't need to check if only
 				either NUM or ASSOC is set but not both.
 			*/
-			zval_ptr_dtor(&data); 
+			zval_ptr_dtor(data); 
 		}
 		mnd_efree(current_row);
 		set->current_row++;
@@ -1540,12 +1445,12 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,
 					DBG_RETURN(NULL);
 				}
 				/* if pecalloc is used valgrind barks gcc version 4.3.1 20080507 (prerelease) [gcc-4_3-branch revision 135036] (SUSE Linux) */
-				set->data = mnd_emalloc((size_t)(set->row_count * meta->field_count * sizeof(zval *)));
+				set->data = mnd_emalloc((size_t)(set->row_count * meta->field_count * sizeof(zval)));
 				if (!set->data) {
 					SET_OOM_ERROR(*conn->error_info);
 					DBG_RETURN(NULL);
 				}
-				memset(set->data, 0, (size_t)(set->row_count * meta->field_count * sizeof(zval *)));
+				memset(set->data, 0, (size_t)(set->row_count * meta->field_count * sizeof(zval)));
 			}
 			/* Position at the first row */
 			set->data_cursor = set->data;
@@ -1819,7 +1724,7 @@ MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * result, const unsigned int
 	  Hint Zend how many elements we will have in the hash. Thus it won't
 	  extend and rehash the hash constantly.
 	*/
-	mysqlnd_array_init(return_value, mysqlnd_num_fields(result) * 2);
+	array_init_size(return_value, mysqlnd_num_fields(result) * 2);
 	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");
 		zval_dtor(return_value);
@@ -1870,8 +1775,8 @@ MYSQLND_METHOD(mysqlnd_res, fetch_row_c)(MYSQLND_RES * result TSRMLS_DC)
 static void
 MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * result, const unsigned int flags, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
 {
-	zval  *row;
-	ulong i = 0;
+	zval  row;
+	zend_ulong i = 0;
 	MYSQLND_RES_BUFFERED *set = result->stored_data;
 
 	DBG_ENTER("mysqlnd_res::fetch_all");
@@ -1886,16 +1791,15 @@ MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * result, const unsigned int
 	}
 
 	/* 4 is a magic value. The cast is safe, if larger then the array will be later extended - no big deal :) */
-	mysqlnd_array_init(return_value, set? (unsigned int) set->row_count : 4); 
+	array_init_size(return_value, set? (unsigned int) set->row_count : 4);
 
 	do {
-		MAKE_STD_ZVAL(row);
-		mysqlnd_fetch_into(result, flags, row, MYSQLND_MYSQLI);
-		if (Z_TYPE_P(row) != IS_ARRAY) {
+		mysqlnd_fetch_into(result, flags, &row, MYSQLND_MYSQLI);
+		if (Z_TYPE(row) != IS_ARRAY) {
 			zval_ptr_dtor(&row);
 			break;
 		}
-		add_index_zval(return_value, i++, row);
+		add_index_zval(return_value, i++, &row);
 	} while (1);
 
 	DBG_VOID_RETURN;
@@ -1908,7 +1812,7 @@ static void
 MYSQLND_METHOD(mysqlnd_res, fetch_field_data)(MYSQLND_RES * result, unsigned int offset, zval *return_value TSRMLS_DC)
 {
 	zval row;
-	zval **entry;
+	zval *entry;
 	unsigned int i = 0;
 
 	DBG_ENTER("mysqlnd_res::fetch_field_data");
@@ -1917,24 +1821,21 @@ MYSQLND_METHOD(mysqlnd_res, fetch_field_data)(MYSQLND_RES * result, unsigned int
 	  Hint Zend how many elements we will have in the hash. Thus it won't
 	  extend and rehash the hash constantly.
 	*/
-	INIT_PZVAL(&row);
 	mysqlnd_fetch_into(result, MYSQLND_FETCH_NUM, &row, MYSQLND_MYSQL);
 	if (Z_TYPE(row) != IS_ARRAY) {
 		zval_dtor(&row);
 		RETVAL_NULL();
 		DBG_VOID_RETURN;
 	}
+
 	zend_hash_internal_pointer_reset(Z_ARRVAL(row));
 	while (i++ < offset) {
 		zend_hash_move_forward(Z_ARRVAL(row));
-		zend_hash_get_current_data(Z_ARRVAL(row), (void **)&entry);
 	}
 
-	zend_hash_get_current_data(Z_ARRVAL(row), (void **)&entry);
+	entry = zend_hash_get_current_data(Z_ARRVAL(row));
 
-	*return_value = **entry;
-	zval_copy_ctor(return_value);
-	Z_SET_REFCOUNT_P(return_value, 1);
+	ZVAL_COPY(return_value, entry);
 	zval_dtor(&row);
 
 	DBG_VOID_RETURN;
@@ -2026,7 +1927,7 @@ mysqlnd_result_unbuffered_init(unsigned int field_count, zend_bool ps, zend_bool
 		DBG_RETURN(NULL);
 	}
 
-	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(unsigned long), persistent))) {
+	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(zend_ulong), persistent))) {
 		mnd_pefree(ret, persistent);
 		DBG_RETURN(NULL);
 	}
@@ -2066,7 +1967,7 @@ mysqlnd_result_buffered_zval_init(unsigned int field_count, zend_bool ps, zend_b
 	if (!ret) {
 		DBG_RETURN(NULL);
 	}
-	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(unsigned long), persistent))) {
+	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(zend_ulong), persistent))) {
 		mnd_pefree(ret, persistent);
 		DBG_RETURN(NULL);
 	}
@@ -2109,7 +2010,7 @@ mysqlnd_result_buffered_c_init(unsigned int field_count, zend_bool ps, zend_bool
 	if (!ret) {
 		DBG_RETURN(NULL);
 	}
-	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(unsigned long), persistent))) {
+	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(zend_ulong), persistent))) {
 		mnd_pefree(ret, persistent);
 		DBG_RETURN(NULL);
 	}