MNDR:

- cleanup in mysqlnd_result.c
- switch from zend_ulong to size_t for lengths. Accordingly change
  mysqli and pdo_mysql for this.

1 files changed, 98 insertions, 90 deletions

diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c
index 7d9529ffb5..057a5d0eb9 100644
--- a/ext/mysqlnd/mysqlnd_result.c
+++ b/ext/mysqlnd/mysqlnd_result.c
@@ -31,8 +31,10 @@
 
 /* {{{ mysqlnd_result_buffered_zval::initialize_result_set_rest */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND_RES_BUFFERED * const result, MYSQLND_RES_METADATA * const meta,
-																		 MYSQLND_STATS * stats, zend_bool int_and_float_native)
+MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND_RES_BUFFERED * const result,
+																		 MYSQLND_RES_METADATA * const meta,
+																		 MYSQLND_STATS * stats,
+																		 zend_bool int_and_float_native)
 {
 	unsigned int i;
 	enum_func_status ret = PASS;
@@ -68,7 +70,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND
 				  Thus for NULL and zero-length we are quite efficient.
 				*/
 				if (Z_TYPE(data_cursor[i]) == IS_STRING) {
-					zend_ulong len = Z_STRLEN(data_cursor[i]);
+					const size_t len = Z_STRLEN(data_cursor[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -84,8 +86,10 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND
 
 /* {{{ mysqlnd_result_buffered_c::initialize_result_set_rest */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RES_BUFFERED * const result, MYSQLND_RES_METADATA * const meta,
-																	  MYSQLND_STATS * stats, zend_bool int_and_float_native)
+MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RES_BUFFERED * const result,
+																	  MYSQLND_RES_METADATA * const meta,
+																	  MYSQLND_STATS * stats,
+																	  zend_bool int_and_float_native)
 {
 	unsigned int i;
 	enum_func_status ret = PASS;
@@ -123,7 +127,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RE
 				  Thus for NULL and zero-length we are quite efficient.
 				*/
 				if (Z_TYPE(current_row[i]) == IS_STRING) {
-					zend_ulong len = Z_STRLEN(current_row[i]);
+					const size_t len = Z_STRLEN(current_row[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -432,7 +436,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
 			  a multi-statement or a stored procedure, so it should be
 			  safe to unconditionally turn off the flag here.
 			*/
-			conn->upsert_status->server_status &= ~SERVER_MORE_RESULTS_EXISTS;
+			UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & ~SERVER_MORE_RESULTS_EXISTS);
 			/*
 			  This will copy the error code and the messages, as they
 			  are buffers in the struct
@@ -463,15 +467,15 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
 				conn->last_query_type = QUERY_UPSERT;
 				conn->field_count = rset_header->field_count;
 				UPSERT_STATUS_RESET(conn->upsert_status);
-				conn->upsert_status->warning_count = rset_header->warning_count;
-				conn->upsert_status->server_status = rset_header->server_status;
-				conn->upsert_status->affected_rows = rset_header->affected_rows;
-				conn->upsert_status->last_insert_id = rset_header->last_insert_id;
+				UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, rset_header->warning_count);
+				UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, rset_header->server_status);
+				UPSERT_STATUS_SET_AFFECTED_ROWS(conn->upsert_status, rset_header->affected_rows);
+				UPSERT_STATUS_SET_LAST_INSERT_ID(conn->upsert_status, rset_header->last_insert_id);
 				SET_NEW_MESSAGE(conn->last_message.s, conn->last_message.l,
 								rset_header->info_or_local_file.s, rset_header->info_or_local_file.l,
 								conn->persistent);
 				/* Result set can follow UPSERT statement, check server_status */
-				if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
+				if (UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) {
 					SET_CONNECTION_STATE(&conn->state, CONN_NEXT_RESULT_PENDING);
 				} else {
 					SET_CONNECTION_STATE(&conn->state, CONN_READY);
@@ -563,7 +567,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
 					}
 				} else {
 					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;
+					UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, fields_eof->warning_count);
 					/*
 					  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
@@ -571,7 +575,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
 					  will include many result sets. What actually matters are the bits set at the end
 					  of every result set (the EOF packet).
 					*/
-					conn->upsert_status->server_status = fields_eof->server_status;
+					UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, fields_eof->server_status);
 					if (fields_eof->server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) {
 						statistic = STAT_BAD_INDEX_USED;
 					} else if (fields_eof->server_status & SERVER_QUERY_NO_INDEX_USED) {
@@ -601,7 +605,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 zend_ulong *
+static const size_t *
 MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_lengths)(MYSQLND_RES_BUFFERED * const result)
 {
 	const MYSQLND_RES_BUFFERED_ZVAL * set = (MYSQLND_RES_BUFFERED_ZVAL *) result;
@@ -633,7 +637,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 zend_ulong *
+static const size_t *
 MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_lengths)(MYSQLND_RES_BUFFERED * const result)
 {
 	const MYSQLND_RES_BUFFERED_C * set = (MYSQLND_RES_BUFFERED_C *) result;
@@ -650,7 +654,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_lengths)(MYSQLND_RES_BUFFERED *
 
 
 /* {{{ mysqlnd_result_unbuffered::fetch_lengths */
-static zend_ulong *
+static const size_t *
 MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_lengths)(MYSQLND_RES_UNBUFFERED * const result)
 {
 	/* simulate output of libmysql */
@@ -660,10 +664,10 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_lengths)(MYSQLND_RES_UNBUFFERED
 
 
 /* {{{ mysqlnd_res::fetch_lengths */
-static zend_ulong *
+static const size_t *
 MYSQLND_METHOD(mysqlnd_res, fetch_lengths)(MYSQLND_RES * const result)
 {
-	zend_ulong * ret;
+	const size_t * 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) :
@@ -683,7 +687,7 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi
 	enum_func_status	ret;
 	MYSQLND_ROW_C		*row = (MYSQLND_ROW_C *) param;
 	MYSQLND_PACKET_ROW	*row_packet = result->unbuf->row_packet;
-	const MYSQLND_RES_METADATA * const meta = result->meta;
+	MYSQLND_RES_METADATA * const meta = result->meta;
 
 	DBG_ENTER("mysqlnd_result_unbuffered::fetch_row_c");
 
@@ -733,11 +737,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;
-					zend_ulong * lengths = result->unbuf->lengths;
+					size_t * 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_STRING)? Z_STRLEN_P(data) : 0;
+						const size_t 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) {
@@ -776,13 +780,13 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi
 		result->unbuf->eof_reached = TRUE;
 
 		UPSERT_STATUS_RESET(result->conn->upsert_status);
-		result->conn->upsert_status->warning_count = row_packet->warning_count;
-		result->conn->upsert_status->server_status = row_packet->server_status;
+		UPSERT_STATUS_SET_WARNINGS(result->conn->upsert_status, row_packet->warning_count);
+		UPSERT_STATUS_SET_SERVER_STATUS(result->conn->upsert_status, row_packet->server_status);
 		/*
 		  result->row_packet will be cleaned when
 		  destroying the result object
 		*/
-		if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
+		if (UPSERT_STATUS_GET_SERVER_STATUS(result->conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) {
 			SET_CONNECTION_STATE(&result->conn->state, CONN_NEXT_RESULT_PENDING);
 		} else {
 			SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
@@ -841,22 +845,22 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
 			unsigned int i, field_count = meta->field_count;
 
 			enum_func_status rc = result->unbuf->m.row_decoder(result->unbuf->last_row_buffer,
-											result->unbuf->last_row_data,
-											field_count,
-											row_packet->fields_metadata,
-											result->conn->options->int_and_float_native,
-											result->conn->stats);
+															   result->unbuf->last_row_data,
+															   field_count,
+															   row_packet->fields_metadata,
+															   result->conn->options->int_and_float_native,
+															   result->conn->stats);
 			if (PASS != rc) {
 				DBG_RETURN(FAIL);
 			}
 			{
 				HashTable * row_ht = Z_ARRVAL_P(row);
 				MYSQLND_FIELD * field = meta->fields;
-				zend_ulong * lengths = result->unbuf->lengths;
+				size_t * 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_STRING)? Z_STRLEN_P(data) : 0;
+					const size_t len = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
 
 					if (flags & MYSQLND_FETCH_NUM) {
 						Z_TRY_ADDREF_P(data);
@@ -872,9 +876,9 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
 						*/
 						Z_TRY_ADDREF_P(data);
 						if (meta->zend_hash_keys[i].is_numeric == FALSE) {
-							zend_hash_update(Z_ARRVAL_P(row), meta->fields[i].sname, data);
+							zend_hash_update(row_ht, meta->fields[i].sname, data);
 						} else {
-							zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
+							zend_hash_index_update(row_ht, meta->zend_hash_keys[i].key, data);
 						}
 					}
 
@@ -903,13 +907,13 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
 		result->unbuf->eof_reached = TRUE;
 
 		UPSERT_STATUS_RESET(result->conn->upsert_status);
-		result->conn->upsert_status->warning_count = row_packet->warning_count;
-		result->conn->upsert_status->server_status = row_packet->server_status;
+		UPSERT_STATUS_SET_WARNINGS(result->conn->upsert_status, row_packet->warning_count);
+		UPSERT_STATUS_SET_SERVER_STATUS(result->conn->upsert_status, row_packet->server_status);
 		/*
 		  result->row_packet will be cleaned when
 		  destroying the result object
 		*/
-		if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
+		if (UPSERT_STATUS_GET_SERVER_STATUS(result->conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) {
 			SET_CONNECTION_STATE(&result->conn->state, CONN_NEXT_RESULT_PENDING);
 		} else {
 			SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
@@ -998,15 +1002,15 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void
 				if (rc != PASS) {
 					DBG_RETURN(FAIL);
 				}
-				set->initialized_rows++;
-				for (i = 0; i < field_count; i++) {
+				++set->initialized_rows;
+				for (i = 0; i < field_count; ++i) {
 					/*
 					  NULL fields are 0 length, 0 is not more than 0
 					  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(current_row[i]) == IS_STRING) {
-						zend_ulong len = Z_STRLEN(current_row[i]);
+						const size_t len = Z_STRLEN(current_row[i]);
 						if (meta->fields[i].max_length < len) {
 							meta->fields[i].max_length = len;
 						}
@@ -1018,7 +1022,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void
 			/* there is no conn handle in this function thus we can't set OOM in error_info */
 			*row = mnd_malloc(field_count * sizeof(char *));
 			if (*row) {
-				for (i = 0; i < field_count; i++) {
+				for (i = 0; i < field_count; ++i) {
 					zval * data = &current_row[i];
 
 					set->lengths[i] = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
@@ -1063,41 +1067,39 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void
 static enum_func_status
 MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, void * param, const unsigned int flags, zend_bool * fetched_anything)
 {
+	enum_func_status ret = FAIL;
 	zval * row = (zval *) param;
 	const MYSQLND_RES_METADATA * const meta = result->meta;
-	unsigned int field_count = meta->field_count;
-	enum_func_status ret = FAIL;
+	const unsigned int field_count = meta->field_count;
 	MYSQLND_RES_BUFFERED_ZVAL * set = (MYSQLND_RES_BUFFERED_ZVAL *) result->stored_data;
 
 	DBG_ENTER("mysqlnd_result_buffered_zval::fetch_row");
 
 	/* If we haven't read everything */
-	if (set->data_cursor &&
-		(set->data_cursor - set->data) < (set->row_count * field_count))
-	{
+	if (set->data_cursor && (set->data_cursor - set->data) < (set->row_count * field_count)) {
 		unsigned int i;
 		zval *current_row = set->data_cursor;
 
 		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,
-											field_count,
-											meta->fields,
-											result->conn->options->int_and_float_native,
-											result->conn->stats);
+													 current_row,
+													 field_count,
+													 meta->fields,
+													 result->conn->options->int_and_float_native,
+													 result->conn->stats);
 			if (rc != PASS) {
 				DBG_RETURN(FAIL);
 			}
-			set->initialized_rows++;
-			for (i = 0; i < field_count; i++) {
+			++set->initialized_rows;
+			for (i = 0; i < field_count; ++i) {
 				/*
 				  NULL fields are 0 length, 0 is not more than 0
 				  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(current_row[i]) == IS_STRING) {
-					zend_ulong len = Z_STRLEN(current_row[i]);
+					const size_t len = Z_STRLEN(current_row[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -1105,7 +1107,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo
 			}
 		}
 
-		for (i = 0; i < field_count; i++) {
+		for (i = 0; i < field_count; ++i) {
 			zval * data = &current_row[i];
 
 			set->lengths[i] = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
@@ -1150,10 +1152,10 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo
 static enum_func_status
 MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void * param, const unsigned int flags, zend_bool * fetched_anything)
 {
+	enum_func_status ret = FAIL;
 	zval * row = (zval *) param;
 	const MYSQLND_RES_METADATA * const meta = result->meta;
-	unsigned int field_count = meta->field_count;
-	enum_func_status ret = FAIL;
+	const unsigned int field_count = meta->field_count;
 
 	MYSQLND_RES_BUFFERED_C * set = (MYSQLND_RES_BUFFERED_C *) result->stored_data;
 
@@ -1161,8 +1163,8 @@ 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;
 		enum_func_status rc;
+		zval * current_row;
 		unsigned int i;
 
 		current_row = mnd_emalloc(field_count * sizeof(zval));
@@ -1172,27 +1174,27 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 		}
 
 		rc = result->stored_data->m.row_decoder(result->stored_data->row_buffers[set->current_row],
-										current_row,
-										field_count,
-										meta->fields,
-										result->conn->options->int_and_float_native,
-										result->conn->stats);
+												current_row,
+												field_count,
+												meta->fields,
+												result->conn->options->int_and_float_native,
+												result->conn->stats);
 		if (rc != PASS) {
 			DBG_RETURN(FAIL);
 		}
 		if (!(set->initialized[set->current_row >> 3] & (1 << (set->current_row & 7)))) {
 			set->initialized[set->current_row >> 3] |= (1 << (set->current_row & 7)); /* mark initialized */
 
-			set->initialized_rows++;
+			++set->initialized_rows;
 
-			for (i = 0; i < field_count; i++) {
+			for (i = 0; i < field_count; ++i) {
 				/*
 				  NULL fields are 0 length, 0 is not more than 0
 				  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(current_row[i]) == IS_STRING) {
-					zend_ulong len = Z_STRLEN(current_row[i]);
+					const size_t len = Z_STRLEN(current_row[i]);
 					if (meta->fields[i].max_length < len) {
 						meta->fields[i].max_length = len;
 					}
@@ -1200,7 +1202,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 			}
 		}
 
-		for (i = 0; i < field_count; i++) {
+		for (i = 0; i < field_count; ++i) {
 			zval * data = &current_row[i];
 
 			set->lengths[i] = (Z_TYPE_P(data) == IS_STRING)? Z_STRLEN_P(data) : 0;
@@ -1233,7 +1235,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void
 			zval_ptr_dtor(data);
 		}
 		mnd_efree(current_row);
-		set->current_row++;
+		++set->current_row;
 		MYSQLND_INC_GLOBAL_STATISTIC(STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_BUF);
 		*fetched_anything = TRUE;
 		ret = PASS;
@@ -1276,14 +1278,11 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
 													zend_bool binary_protocol)
 {
 	enum_func_status ret;
-	MYSQLND_PACKET_ROW * row_packet = NULL;
 	unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows = 1;
-	MYSQLND_RES_BUFFERED *set;
+	MYSQLND_RES_BUFFERED * set = result->stored_data;
+	MYSQLND_PACKET_ROW * row_packet = NULL;
 
 	DBG_ENTER("mysqlnd_res::store_result_fetch_data");
-
-	set = result->stored_data;
-
 	if (!set || !row_buffers) {
 		ret = FAIL;
 		goto end;
@@ -1296,8 +1295,6 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
 			goto end;
 		}
 	}
-	set->references	= 1;
-
 	/* non-persistent */
 	row_packet = conn->payload_decoder_factory->m.get_row_packet(conn->payload_decoder_factory, FALSE);
 	if (!row_packet) {
@@ -1305,6 +1302,8 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
 		ret = FAIL;
 		goto end;
 	}
+	set->references	= 1;
+
 	row_packet->result_set_memory_pool = result->stored_data->result_set_memory_pool;
 	row_packet->field_count = meta->field_count;
 	row_packet->binary_protocol = binary_protocol;
@@ -1359,8 +1358,8 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
 	/* Finally clean */
 	if (row_packet->eof) {
 		UPSERT_STATUS_RESET(conn->upsert_status);
-		conn->upsert_status->warning_count = row_packet->warning_count;
-		conn->upsert_status->server_status = row_packet->server_status;
+		UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, row_packet->warning_count);
+		UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, row_packet->server_status);
 	}
 	/* save some memory */
 	if (free_rows) {
@@ -1373,7 +1372,7 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
 		*row_buffers = mnd_perealloc(*row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), 0);
 	}
 
-	if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
+	if (UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) {
 		SET_CONNECTION_STATE(&conn->state, CONN_NEXT_RESULT_PENDING);
 	} else {
 		SET_CONNECTION_STATE(&conn->state, CONN_READY);
@@ -1383,10 +1382,13 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
 		COPY_CLIENT_ERROR(&set->error_info, row_packet->error_info);
 	} else {
 		/* libmysql's documentation says it should be so for SELECT statements */
-		conn->upsert_status->affected_rows = set->row_count;
+		UPSERT_STATUS_SET_AFFECTED_ROWS(conn->upsert_status, set->row_count);
 	}
 	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,
+				UPSERT_STATUS_GET_WARNINGS(conn->upsert_status),
+				UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status));
 end:
 	PACKET_FREE(row_packet);
 	DBG_INF_FMT("rows=%llu", (unsigned long long)result->stored_data->row_count);
@@ -1438,10 +1440,10 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,
 		}
 		DBG_RETURN(NULL);
 	} else {
-	/* Overflow ? */
 		if (flags & MYSQLND_STORE_NO_COPY) {
-			MYSQLND_RES_METADATA * meta = result->meta;
+			const MYSQLND_RES_METADATA * const meta = result->meta;
 			MYSQLND_RES_BUFFERED_ZVAL * set = (MYSQLND_RES_BUFFERED_ZVAL *) result->stored_data;
+
 			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 */
 				if (set->row_count * meta->field_count * sizeof(zval *) > SIZE_MAX) {
@@ -1466,7 +1468,7 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,
 	}
 
 	/* libmysql's documentation says it should be so for SELECT statements */
-	conn->upsert_status->affected_rows = result->stored_data->row_count;
+	UPSERT_STATUS_SET_AFFECTED_ROWS(conn->upsert_status, result->stored_data->row_count);
 
 	DBG_RETURN(result);
 }
@@ -1570,7 +1572,7 @@ static uint64_t
 MYSQLND_METHOD(mysqlnd_result_unbuffered, num_rows)(const MYSQLND_RES_UNBUFFERED * const result)
 {
 	/* Be compatible with libmysql. We count row_count, but will return 0 */
-	return result->eof_reached? result->row_count:0;
+	return result->eof_reached? result->row_count : 0;
 }
 /* }}} */
 
@@ -1624,7 +1626,9 @@ MYSQLND_METHOD(mysqlnd_res, fetch_field)(MYSQLND_RES * const result)
 			if (result->stored_data && (result->stored_data->initialized_rows < result->stored_data->row_count)) {
 				DBG_INF_FMT("We have decode the whole result set to be able to satisfy this meta request");
 				/* we have to initialize the rest to get the updated max length */
-				if (PASS != result->stored_data->m.initialize_result_set_rest(result->stored_data, result->meta, result->conn->stats,
+				if (PASS != result->stored_data->m.initialize_result_set_rest(result->stored_data,
+																			  result->meta,
+																			  result->conn->stats,
 																			  result->conn->options->int_and_float_native))
 				{
 					break;
@@ -1658,7 +1662,9 @@ MYSQLND_METHOD(mysqlnd_res, fetch_field_direct)(MYSQLND_RES * const result, cons
 			if (result->stored_data && (result->stored_data->initialized_rows < result->stored_data->row_count)) {
 				DBG_INF_FMT("We have decode the whole result set to be able to satisfy this meta request");
 				/* we have to initialized the rest to get the updated max length */
-				if (PASS != result->stored_data->m.initialize_result_set_rest(result->stored_data, result->meta, result->conn->stats,
+				if (PASS != result->stored_data->m.initialize_result_set_rest(result->stored_data,
+																			  result->meta,
+																			  result->conn->stats,
 																			  result->conn->options->int_and_float_native))
 				{
 					break;
@@ -1682,7 +1688,9 @@ MYSQLND_METHOD(mysqlnd_res, fetch_fields)(MYSQLND_RES * const result)
 		if (result->meta) {
 			if (result->stored_data && (result->stored_data->initialized_rows < result->stored_data->row_count)) {
 				/* we have to initialize the rest to get the updated max length */
-				if (PASS != result->stored_data->m.initialize_result_set_rest(result->stored_data, result->meta, result->conn->stats,
+				if (PASS != result->stored_data->m.initialize_result_set_rest(result->stored_data,
+																			  result->meta,
+																			  result->conn->stats,
 																			  result->conn->options->int_and_float_native))
 				{
 					break;
@@ -1931,7 +1939,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(zend_ulong), persistent))) {
+	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(size_t), persistent))) {
 		mnd_pefree(ret, persistent);
 		DBG_RETURN(NULL);
 	}
@@ -1971,7 +1979,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(zend_ulong), persistent))) {
+	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(size_t), persistent))) {
 		mnd_pefree(ret, persistent);
 		DBG_RETURN(NULL);
 	}
@@ -2014,7 +2022,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(zend_ulong), persistent))) {
+	if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(size_t), persistent))) {
 		mnd_pefree(ret, persistent);
 		DBG_RETURN(NULL);
 	}