This commit was manufactured by cvs2svn to create tag 'php_5_3_0alpha2'.php-5.3.0alpha2

22 files changed, 746 insertions, 1252 deletions

diff --git a/ext/mysqlnd/config-win.h b/ext/mysqlnd/config-win.h
index bc44050de3..86018221a6 100644
--- a/ext/mysqlnd/config-win.h
+++ b/ext/mysqlnd/config-win.h
@@ -3,9 +3,6 @@ This file is public domain and comes with NO WARRANTY of any kind */
 
 /* Defines for Win32 to make it compatible for MySQL */
 
-#ifndef _MYSQLND_CONFIG_WIN_H
-#define _MYSQLND_CONFIG_WIN_H
-
 #include <sys/locking.h>
 #include <windows.h>
 #include <math.h>			/* Because of rint() */
@@ -13,35 +10,18 @@ This file is public domain and comes with NO WARRANTY of any kind */
 #include <io.h>
 #include <malloc.h>
 
-#include <win32/php_stdint.h>
-
-#ifndef HAVE_INT8_T
-#define HAVE_INT8_T
-#endif
-#ifndef HAVE_UINT8_T
-#define HAVE_UINT8_T
-#endif
-#ifndef HAVE_INT16_T
-#define HAVE_INT16_T
-#endif
-#ifndef HAVE_UINT16_T
-#define HAVE_UINT16_T
-#endif
-#ifndef HAVE_INT32_T
-#define HAVE_INT32_T
-#endif
-#ifndef HAVE_UINT32_T
-#define HAVE_UINT32_T
-#endif
-#ifndef HAVE_INT64_T
-#define HAVE_INT64_T
+#if defined(__NT__)
+#define	SYSTEM_TYPE	"NT"
+#elif defined(__WIN2000__)
+#define	SYSTEM_TYPE	"WIN2000"
+#else
+#define	SYSTEM_TYPE	"Win95/Win98"
 #endif
-#ifndef HAVE_UINT64_T
-#define HAVE_UINT64_T
-#endif
-
 
-#ifndef _WIN64
+#ifdef _WIN64
+#define MACHINE_TYPE	"ia64"		/* Define to machine type name */
+#else
+#define MACHINE_TYPE	"i32"		/* Define to machine type name */
 #ifndef _WIN32
 #define _WIN32				/* Compatible with old source */
 #endif
@@ -50,11 +30,22 @@ This file is public domain and comes with NO WARRANTY of any kind */
 #endif
 #endif /* _WIN64 */
 #ifndef __WIN__
-#define __WIN__				/* To make it easier in VC++ */
+#define __WIN__                       /* To make it easier in VC++ */
 #endif
 
+#define LONGLONG_MIN	((__int64) 0x8000000000000000)
+#define LONGLONG_MAX	((__int64) 0x7FFFFFFFFFFFFFFF)
+#define LL(A)		((__int64) A)
+
 /* Type information */
 
+typedef unsigned short  ushort;
+typedef unsigned int    uint;
+typedef unsigned __int64 ulonglong;	/* Microsofts 64 bit types */
+typedef __int64	longlong;
+typedef int sigset_t;
+#define longlong_defined
+
 #define SIZEOF_CHAR		1
 #define SIZEOF_LONG		4
 #define SIZEOF_LONG_LONG	8
@@ -63,53 +54,45 @@ This file is public domain and comes with NO WARRANTY of any kind */
 #ifndef _WIN64
 /* Optimized store functions for Intel x86 */
 
-#define sint2korr(A)	(*((int16_t *) (A)))
-#define sint3korr(A)	((int32_t) ((((zend_uchar) (A)[2]) & 128) ? \
-										(((uint32_t) 255L << 24) | \
-										(((uint32_t) (zend_uchar) (A)[2]) << 16) |\
-										(((uint32_t) (zend_uchar) (A)[1]) << 8) | \
-										((uint32_t) (zend_uchar) (A)[0])) : \
-										(((uint32_t) (zend_uchar) (A)[2]) << 16) |\
-										(((uint32_t) (zend_uchar) (A)[1]) << 8) | \
-										((uint32_t) (zend_uchar) (A)[0])))
-#define sint4korr(A)	(*((int32_t *) (A)))
-#define uint2korr(A)	(*((uint16_t *) (A)))
-#define uint3korr(A)	(int32_t) (*((uint32_t *) (A)) & 0xFFFFFF)
-#define uint4korr(A)	(*((uint32_t *) (A)))
-#define uint5korr(A)	((uint64_t)(((uint32_t) ((zend_uchar) (A)[0])) +\
-									(((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
-									(((uint32_t) ((zend_uchar) (A)[2])) << 16) +\
-									(((uint32_t) ((zend_uchar) (A)[3])) << 24)) +\
-									(((uint64_t) ((zend_uchar) (A)[4])) << 32))
-#define uint8korr(A)	(*((uint64_t *) (A)))
-#define sint8korr(A)	(*((int64_t *) (A)))
-#define int2store(T,A)	*((uint16_t*) (T))= (uint16_t) (A)
-#define int3store(T,A)		{	*(T)=  (zend_uchar) ((A));\
-								*(T+1)=(zend_uchar) (((uint32_t) (A) >> 8));\
-								*(T+2)=(zend_uchar) (((A) >> 16)); }
-#define int4store(T,A)	*((int32_t *) (T))= (int32_t) (A)
-#define int5store(T,A)	{	*(T)= (zend_uchar)((A));\
-							*((T)+1)=(zend_uchar) (((A) >> 8));\
-							*((T)+2)=(zend_uchar) (((A) >> 16));\
-							*((T)+3)=(zend_uchar) (((A) >> 24)); \
-							*((T)+4)=(zend_uchar) (((A) >> 32)); }
-#define int8store(T,A)	*((uint64_t *) (T))= (uint64_t) (A)
-
-#define float8get(V,M)	{	*((int32_t *) &V) = *((int32_t*) M); \
-							*(((int32_t *) &V)+1) = *(((int32_t*) M)+1); }
-#define float8store(T,V) {	*((int32_t *) T) = *((int32_t*) &V); \
-							*(((int32_t *) T)+1) = *(((int32_t*) &V)+1); }
-#define float4get(V,M) { *((int32_t *) &(V)) = *((int32_t*) (M)); }
+#define sint2korr(A)	(*((int16 *) (A)))
+#define sint3korr(A)	((int32) ((((uchar) (A)[2]) & 128) ? \
+				  (((uint32) 255L << 24) | \
+				   (((uint32) (uchar) (A)[2]) << 16) |\
+				   (((uint32) (uchar) (A)[1]) << 8) | \
+				   ((uint32) (uchar) (A)[0])) : \
+				  (((uint32) (uchar) (A)[2]) << 16) |\
+				  (((uint32) (uchar) (A)[1]) << 8) | \
+				  ((uint32) (uchar) (A)[0])))
+#define sint4korr(A)	(*((long *) (A)))
+#define uint2korr(A)	(*((uint16 *) (A)))
+#define uint3korr(A)	(long) (*((unsigned long *) (A)) & 0xFFFFFF)
+#define uint4korr(A)	(*((unsigned long *) (A)))
+#define uint5korr(A)	((ulonglong)(((uint32) ((uchar) (A)[0])) +\
+				    (((uint32) ((uchar) (A)[1])) << 8) +\
+				    (((uint32) ((uchar) (A)[2])) << 16) +\
+				    (((uint32) ((uchar) (A)[3])) << 24)) +\
+			 	    (((ulonglong) ((uchar) (A)[4])) << 32))
+#define uint8korr(A)	(*((ulonglong *) (A)))
+#define sint8korr(A)	(*((longlong *) (A)))
+#define int2store(T,A)	*((uint16*) (T))= (uint16) (A)
+#define int3store(T,A)		{ *(T)=  (uchar) ((A));\
+				  *(T+1)=(uchar) (((uint) (A) >> 8));\
+				  *(T+2)=(uchar) (((A) >> 16)); }
+#define int4store(T,A)	*((long *) (T))= (long) (A)
+#define int5store(T,A)	{ *(T)= (uchar)((A));\
+			  *((T)+1)=(uchar) (((A) >> 8));\
+			  *((T)+2)=(uchar) (((A) >> 16));\
+			  *((T)+3)=(uchar) (((A) >> 24)); \
+			  *((T)+4)=(uchar) (((A) >> 32)); }
+#define int8store(T,A)	*((ulonglong *) (T))= (ulonglong) (A)
+
+#define doubleget(V,M)	{ *((long *) &V) = *((long*) M); \
+			  *(((long *) &V)+1) = *(((long*) M)+1); }
+#define doublestore(T,V) { *((long *) T) = *((long*) &V); \
+			   *(((long *) T)+1) = *(((long*) &V)+1); }
+#define float4get(V,M) { *((long *) &(V)) = *((long*) (M)); }
+#define float8get(V,M) doubleget((V),(M))
+#define float4store(V,M) memcpy((byte*) V,(byte*) (&M),sizeof(float))
+#define float8store(V,M) doublestore((V),(M))
 
 #endif /* _WIN64 */
-
-#endif /* _MYSQLND_CONFIG_WIN_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: noet sw=4 ts=4 fdm=marker
- * vim<600: noet sw=4 ts=4
- */
diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c
index 68cac9dda3..0a4c718011 100644
--- a/ext/mysqlnd/mysqlnd.c
+++ b/ext/mysqlnd/mysqlnd.c
@@ -268,8 +268,7 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND *conn TSRMLS_DC)
 /* {{{ mysqlnd_simple_command_handle_response */
 enum_func_status
 mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type ok_packet,
-									   zend_bool silent, enum php_mysqlnd_server_command command,
-									   zend_bool ignore_upsert_status
+									   zend_bool silent, enum php_mysqlnd_server_command command
 									   TSRMLS_DC)
 {
 	enum_func_status ret;
@@ -310,12 +309,10 @@ mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type
 									ok_response.message, ok_response.message_len,
 									conn->persistent);
 
-					if (!ignore_upsert_status) {
-						conn->upsert_status.warning_count = ok_response.warning_count;
-						conn->upsert_status.server_status = ok_response.server_status;
-						conn->upsert_status.affected_rows = ok_response.affected_rows;
-						conn->upsert_status.last_insert_id = ok_response.last_insert_id;
-					}
+					conn->upsert_status.warning_count = ok_response.warning_count;
+					conn->upsert_status.server_status = ok_response.server_status;
+					conn->upsert_status.affected_rows = ok_response.affected_rows;
+					conn->upsert_status.last_insert_id = ok_response.last_insert_id;
 				}
 			}
 			PACKET_FREE_ALLOCA(ok_response);
@@ -370,8 +367,7 @@ mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type
 enum_func_status
 mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command,
 					   const char * const arg, size_t arg_len,
-					   enum php_mysql_packet_type ok_packet, zend_bool silent, 
-					   zend_bool ignore_upsert_status TSRMLS_DC)
+					   enum php_mysql_packet_type ok_packet, zend_bool silent TSRMLS_DC)
 {
 	enum_func_status ret = PASS;
 	php_mysql_packet_command cmd_packet;
@@ -394,9 +390,7 @@ mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command,
 	}
 
 	/* clean UPSERT info */
-	if (!ignore_upsert_status) {
-		memset(&conn->upsert_status, 0, sizeof(conn->upsert_status));
-	}
+	memset(&conn->upsert_status, 0, sizeof(conn->upsert_status));
 	SET_ERROR_AFF_ROWS(conn);
 	SET_EMPTY_ERROR(conn->error_info);
 
@@ -415,7 +409,7 @@ mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command,
 		DBG_ERR("Server is gone");
 		ret = FAIL;
 	} else if (ok_packet != PROT_LAST) {
-		ret = mysqlnd_simple_command_handle_response(conn, ok_packet, silent, command, ignore_upsert_status TSRMLS_CC);
+		ret = mysqlnd_simple_command_handle_response(conn, ok_packet, silent, command TSRMLS_CC);
 	}
 
 	/*
@@ -439,9 +433,9 @@ MYSQLND_METHOD(mysqlnd_conn, set_server_option)(MYSQLND * const conn,
 	char buffer[2];
 	DBG_ENTER("mysqlnd_conn::set_server_option");
 
-	int2store(buffer, (unsigned int) option);
+	int2store(buffer, (uint) option);
 	ret = mysqlnd_simple_command(conn, COM_SET_OPTION, buffer, sizeof(buffer),
-								 PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC);
+								 PROT_EOF_PACKET, FALSE TSRMLS_CC);
 	DBG_RETURN(ret);
 }
 /* }}} */
@@ -758,12 +752,12 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn,
 
 		mysqlnd_local_infile_default(conn);
 		{
-			unsigned int buf_size;
-			buf_size = MYSQLND_G(net_read_buffer_size); /* this is long, cast to unsigned int*/
+			uint buf_size;
+			buf_size = MYSQLND_G(net_read_buffer_size); /* this is long, cast to uint*/
 			conn->m->set_client_option(conn, MYSQLND_OPT_NET_READ_BUFFER_SIZE,
 								   		(char *)&buf_size TSRMLS_CC);
 
-			buf_size = MYSQLND_G(net_cmd_buffer_size); /* this is long, cast to unsigned int*/
+			buf_size = MYSQLND_G(net_cmd_buffer_size); /* this is long, cast to uint*/
 			conn->m->set_client_option(conn, MYSQLND_OPT_NET_CMD_BUFFER_SIZE,
 								   		(char *)&buf_size TSRMLS_CC);			
 		}
@@ -781,7 +775,7 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn,
 		conn->result_set_memory_pool = mysqlnd_mempool_create(16000 TSRMLS_CC);
 #if PHP_MAJOR_VERSION >= 6
 		{
-			unsigned int as_unicode = 1;
+			uint as_unicode = 1;
 			conn->m->set_client_option(conn, MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE,
 									   (char *)&as_unicode TSRMLS_CC);
 			DBG_INF("unicode set");
@@ -856,7 +850,7 @@ MYSQLND_METHOD(mysqlnd_conn, query)(MYSQLND *conn, const char *query, unsigned i
 
 	if (PASS != mysqlnd_simple_command(conn, COM_QUERY, query, query_len,
 									   PROT_LAST /* we will handle the OK packet*/,
-									   FALSE, FALSE TSRMLS_CC)) {
+									   FALSE TSRMLS_CC)) {
 		DBG_RETURN(FAIL);
 	}
 	CONN_SET_STATE(conn, CONN_QUERY_SENT);
@@ -870,218 +864,6 @@ MYSQLND_METHOD(mysqlnd_conn, query)(MYSQLND *conn, const char *query, unsigned i
 /* }}} */
 
 
-/* {{{ mysqlnd_conn::send_query */
-static enum_func_status
-MYSQLND_METHOD(mysqlnd_conn, send_query)(MYSQLND *conn, const char *query, unsigned int query_len TSRMLS_DC)
-{
-	enum_func_status ret;
-	DBG_ENTER("mysqlnd_conn::send_query");
-	DBG_INF_FMT("conn=%llu query=%s", conn->thread_id, query);
-
-	ret = mysqlnd_simple_command(conn, COM_QUERY, query, query_len,
-								 PROT_LAST /* we will handle the OK packet*/,
-								 FALSE, FALSE TSRMLS_CC);
-	CONN_SET_STATE(conn, CONN_QUERY_SENT);
-	DBG_RETURN(ret);
-}
-/* }}} */
-
-/* {{{ mysqlnd_conn::send_query */
-static enum_func_status
-MYSQLND_METHOD(mysqlnd_conn, reap_query)(MYSQLND * conn TSRMLS_DC)
-{
-	enum_mysqlnd_connection_state state = CONN_GET_STATE(conn);
-	DBG_ENTER("mysqlnd_conn::reap_query");
-	DBG_INF_FMT("conn=%llu", conn->thread_id);
-
-	if (state <= CONN_READY || state == CONN_QUIT_SENT) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not opened, clear or has been closed");
-		DBG_RETURN(FAIL);	
-	}
-	DBG_RETURN(mysqlnd_query_read_result_set_header(conn, NULL TSRMLS_CC));
-}
-/* }}} */
-
-
-#include "php_network.h"
-
-MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array TSRMLS_DC)
-{
-	int cnt = 0;
-	MYSQLND **p = conn_array, **p_p;
-	MYSQLND **ret = NULL;
-
-	while (*p) {
-		if (CONN_GET_STATE(*p) <= CONN_READY || CONN_GET_STATE(*p) == CONN_QUIT_SENT) {
-			cnt++;
-		}
-		p++;
-	}
-	if (cnt) {
-		MYSQLND **ret_p = ret = ecalloc(cnt + 1, sizeof(MYSQLND *));
-		p_p = p = conn_array;
-		while (*p) {
-			if (CONN_GET_STATE(*p) <= CONN_READY || CONN_GET_STATE(*p) == CONN_QUIT_SENT) {
-				*ret_p = *p;
-				*p = NULL;
-				ret_p++;
-			} else {
-				*p_p = *p;
-				p_p++;
-			}
-			p++;
-		}
-		*ret_p = NULL; 
-	}
-	return ret;
-}
-
-
-/* {{{ stream_select mysqlnd_stream_array_to_fd_set functions */
-static int mysqlnd_stream_array_to_fd_set(MYSQLND **conn_array, fd_set *fds, php_socket_t *max_fd TSRMLS_DC)
-{
-	php_socket_t this_fd;
-	int cnt = 0;
-	MYSQLND **p = conn_array;
-
-	while (*p) {
-		/* get the fd.
-		 * NB: Most other code will NOT use the PHP_STREAM_CAST_INTERNAL flag
-		 * when casting.  It is only used here so that the buffered data warning
-		 * is not displayed.
-		 * */
-		if (SUCCESS == php_stream_cast((*p)->net.stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL,
-										(void*)&this_fd, 1) && this_fd >= 0) {
-			
-			PHP_SAFE_FD_SET(this_fd, fds);
-
-			if (this_fd > *max_fd) {
-				*max_fd = this_fd;
-			}
-			cnt++;
-		}
-		p++;
-	}
-	return cnt ? 1 : 0;
-}
-
-static int mysqlnd_stream_array_from_fd_set(MYSQLND **conn_array, fd_set *fds TSRMLS_DC)
-{
-	php_socket_t this_fd;
-	int ret = 0;
-	zend_bool disproportion = FALSE;
-
-
-	MYSQLND **fwd = conn_array, **bckwd = conn_array;
-
-	while (*fwd) {
-		if (SUCCESS == php_stream_cast((*fwd)->net.stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL,
-										(void*)&this_fd, 1) && this_fd >= 0) {
-			if (PHP_SAFE_FD_ISSET(this_fd, fds)) {
-				if (disproportion) {
-					*bckwd = *fwd;
-				}
-				bckwd++;
-				fwd++;
-				ret++;
-				continue;
-			}
-		}
-		disproportion = TRUE;
-		fwd++;
-	}
-	*bckwd = NULL;/* NULL-terminate the list */
-	
-	return ret;
-}
-
-
-#ifndef PHP_WIN32
-#define php_select(m, r, w, e, t)	select(m, r, w, e, t)
-#else
-#include "win32/select.h"
-#endif
-
-/* {{{ _mysqlnd_poll */
-PHPAPI enum_func_status
-_mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQLND ***dont_poll, long sec, long usec, uint * desc_num TSRMLS_DC)
-{
-
-	struct timeval	tv;
-	struct timeval *tv_p = NULL;
-	fd_set			rfds, wfds, efds;
-	php_socket_t	max_fd = 0;
-	int				retval, sets = 0;
-	int				set_count, max_set_count = 0;
-	DBG_ENTER("mysqlnd_poll");
-
-	if (sec < 0 || usec < 0) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Negative values passed for sec and/or usec");
-		DBG_RETURN(FAIL);
-	}
-
-	*dont_poll = mysqlnd_stream_array_check_for_readiness(r_array TSRMLS_CC);
-
-	FD_ZERO(&rfds);
-	FD_ZERO(&wfds);
-	FD_ZERO(&efds);
-
-	if (r_array != NULL) {
-		set_count = mysqlnd_stream_array_to_fd_set(r_array, &rfds, &max_fd TSRMLS_CC);
-		if (set_count > max_set_count) {
-			max_set_count = set_count;
-		}
-		sets += set_count;
-	}
-
-	if (e_array != NULL) {
-		set_count = mysqlnd_stream_array_to_fd_set(e_array, &efds, &max_fd TSRMLS_CC);
-		if (set_count > max_set_count) {
-			max_set_count = set_count;
-		}
-		sets += set_count;
-	}
-
-	if (!sets) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, *dont_poll ? "All arrays passed are clear":"No stream arrays were passed");
-		DBG_RETURN(FAIL);
-	}
-
-	PHP_SAFE_MAX_FD(max_fd, max_set_count);
-
-	/* Solaris + BSD do not like microsecond values which are >= 1 sec */
-	if (usec > 999999) {
-		tv.tv_sec = sec + (usec / 1000000);
-		tv.tv_usec = usec % 1000000;			
-	} else {
-		tv.tv_sec = sec;
-		tv.tv_usec = usec;
-	}
-
-	tv_p = &tv;
-	
-	retval = php_select(max_fd + 1, &rfds, &wfds, &efds, tv_p);
-
-	if (retval == -1) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to select [%d]: %s (max_fd=%d)",
-						errno, strerror(errno), max_fd);
-		DBG_RETURN(FAIL);
-	}
-
-	if (r_array != NULL) {
-		mysqlnd_stream_array_from_fd_set(r_array, &rfds TSRMLS_CC);
-	}
-	if (e_array != NULL) {
-		mysqlnd_stream_array_from_fd_set(e_array, &efds TSRMLS_CC);
-	}
-
-	*desc_num = retval;
-
-	DBG_RETURN(PASS);
-}
-/* }}} */
-
-
 /*
   COM_FIELD_LIST is special, different from a SHOW FIELDS FROM :
   - There is no result set header - status from the command, which
@@ -1115,7 +897,7 @@ MYSQLND_METHOD(mysqlnd_conn, list_fields)(MYSQLND *conn, const char *table, cons
 
 	if (PASS != mysqlnd_simple_command(conn, COM_FIELD_LIST, buff, p - buff,
 									   PROT_LAST /* we will handle the OK packet*/,
-									   FALSE, TRUE TSRMLS_CC)) {
+									   FALSE TSRMLS_CC)) {
 		DBG_RETURN(NULL);
 	}
 	/*
@@ -1236,7 +1018,7 @@ MYSQLND_METHOD(mysqlnd_conn, dump_debug_info)(MYSQLND * const conn TSRMLS_DC)
 {
 	DBG_ENTER("mysqlnd_conn::dump_debug_info");
 	DBG_INF_FMT("conn=%llu", conn->thread_id);
-	DBG_RETURN(mysqlnd_simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC));
+	DBG_RETURN(mysqlnd_simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE TSRMLS_CC));
 }
 /* }}} */
 
@@ -1252,7 +1034,7 @@ MYSQLND_METHOD(mysqlnd_conn, select_db)(MYSQLND * const conn,
 	DBG_ENTER("mysqlnd_conn::select_db");
 	DBG_INF_FMT("conn=%llu db=%s", conn->thread_id, db);
 
-	ret = mysqlnd_simple_command(conn, COM_INIT_DB, db, db_len, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC);
+	ret = mysqlnd_simple_command(conn, COM_INIT_DB, db, db_len, PROT_OK_PACKET, FALSE TSRMLS_CC);
 	/*
 	  The server sends 0 but libmysql doesn't read it and has established
 	  a protocol of giving back -1. Thus we have to follow it :(
@@ -1273,7 +1055,7 @@ MYSQLND_METHOD(mysqlnd_conn, ping)(MYSQLND * const conn TSRMLS_DC)
 	DBG_ENTER("mysqlnd_conn::ping");
 	DBG_INF_FMT("conn=%llu", conn->thread_id);
 
-	ret = mysqlnd_simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, TRUE, TRUE TSRMLS_CC);
+	ret = mysqlnd_simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, TRUE TSRMLS_CC);
 	/*
 	  The server sends 0 but libmysql doesn't read it and has established
 	  a protocol of giving back -1. Thus we have to follow it :(
@@ -1296,7 +1078,7 @@ MYSQLND_METHOD(mysqlnd_conn, stat)(MYSQLND *conn, char **message, unsigned int *
 	DBG_ENTER("mysqlnd_conn::stat");
 	DBG_INF_FMT("conn=%llu", conn->thread_id);
 
-	ret = mysqlnd_simple_command(conn, COM_STATISTICS, NULL, 0, PROT_LAST, FALSE, TRUE TSRMLS_CC);
+	ret = mysqlnd_simple_command(conn, COM_STATISTICS, NULL, 0, PROT_LAST, FALSE TSRMLS_CC);
 	if (FAIL == ret) {
 		DBG_RETURN(FAIL);
 	}
@@ -1330,14 +1112,14 @@ MYSQLND_METHOD(mysqlnd_conn, kill)(MYSQLND *conn, unsigned int pid TSRMLS_DC)
 
 	/* If we kill ourselves don't expect OK packet, PROT_LAST will skip it */
 	if (pid != conn->thread_id) {
-		ret = mysqlnd_simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC);
+		ret = mysqlnd_simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_OK_PACKET, FALSE TSRMLS_CC);
 		/*
 		  The server sends 0 but libmysql doesn't read it and has established
 		  a protocol of giving back -1. Thus we have to follow it :(
 		*/
 		SET_ERROR_AFF_ROWS(conn);
 	} else if (PASS == (ret = mysqlnd_simple_command(conn, COM_PROCESS_KILL, buff,
-													 4, PROT_LAST, FALSE, TRUE TSRMLS_CC))) {
+													 4, PROT_LAST, FALSE TSRMLS_CC))) {
 		CONN_SET_STATE(conn, CONN_QUIT_SENT);
 	}
 	DBG_RETURN(ret);
@@ -1382,7 +1164,7 @@ MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * con
 
 /* {{{ mysqlnd_conn::refresh */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_conn, refresh)(MYSQLND * const conn, uint8_t options TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_conn, refresh)(MYSQLND * const conn, unsigned long options TSRMLS_DC)
 {
 	zend_uchar bits[1];
 	DBG_ENTER("mysqlnd_conn::refresh");
@@ -1390,14 +1172,14 @@ MYSQLND_METHOD(mysqlnd_conn, refresh)(MYSQLND * const conn, uint8_t options TSRM
 
 	int1store(bits, options);
 
-	DBG_RETURN(mysqlnd_simple_command(conn, COM_REFRESH, (char *)bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC));
+	DBG_RETURN(mysqlnd_simple_command(conn, COM_REFRESH, (char *)bits, 1, PROT_OK_PACKET, FALSE TSRMLS_CC));
 }
 /* }}} */
 
 
 /* {{{ mysqlnd_conn::shutdown */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_conn, shutdown)(MYSQLND * const conn, uint8_t level TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_conn, shutdown)(MYSQLND * const conn, unsigned long level TSRMLS_DC)
 {
 	zend_uchar bits[1];
 	DBG_ENTER("mysqlnd_conn::shutdown");
@@ -1405,7 +1187,7 @@ MYSQLND_METHOD(mysqlnd_conn, shutdown)(MYSQLND * const conn, uint8_t level TSRML
 
 	int1store(bits, level);
 
-	DBG_RETURN(mysqlnd_simple_command(conn, COM_SHUTDOWN, (char *)bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC));
+	DBG_RETURN(mysqlnd_simple_command(conn, COM_SHUTDOWN, (char *)bits, 1, PROT_OK_PACKET, FALSE TSRMLS_CC));
 }
 /* }}} */
 
@@ -1424,7 +1206,7 @@ mysqlnd_send_close(MYSQLND * conn TSRMLS_DC)
 		case CONN_READY:
 			DBG_INF("Connection clean, sending COM_QUIT");
 			ret =  mysqlnd_simple_command(conn, COM_QUIT, NULL, 0, PROT_LAST,
-										  TRUE, TRUE TSRMLS_CC);
+										  TRUE TSRMLS_CC);
 			/* Do nothing */
 			break;
 		case CONN_SENDING_LOAD_DATA:
@@ -1479,12 +1261,10 @@ MYSQLND_METHOD(mysqlnd_conn, close)(MYSQLND * conn, enum_connection_close_type c
 	DBG_ENTER("mysqlnd_conn::close");
 	DBG_INF_FMT("conn=%llu", conn->thread_id);
 
-	if (conn->state >= CONN_READY) {
-		MYSQLND_INC_CONN_STATISTIC(&conn->stats, stat);
-		MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS);
-		if (conn->persistent) {
-			MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
-		}
+	MYSQLND_INC_CONN_STATISTIC(&conn->stats, stat);
+	MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS);
+	if (conn->persistent) {
+		MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
 	}
 
 	/*
@@ -1584,7 +1364,7 @@ MYSQLND_METHOD(mysqlnd_conn, field_count)(const MYSQLND * const conn)
 
 
 /* {{{ mysqlnd_conn::insert_id */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_conn, insert_id)(const MYSQLND * const conn)
 {
 	return conn->upsert_status.last_insert_id;
@@ -1593,7 +1373,7 @@ MYSQLND_METHOD(mysqlnd_conn, insert_id)(const MYSQLND * const conn)
 
 
 /* {{{ mysqlnd_conn::affected_rows */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_conn, affected_rows)(const MYSQLND * const conn)
 {
 	return conn->upsert_status.affected_rows;
@@ -1672,7 +1452,7 @@ MYSQLND_METHOD(mysqlnd_conn, charset_name)(const MYSQLND * const conn)
 
 
 /* {{{ mysqlnd_conn::thread_id */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_conn, thread_id)(const MYSQLND * const conn)
 {
 	return conn->thread_id;
@@ -1733,17 +1513,9 @@ MYSQLND_METHOD(mysqlnd_conn, next_result)(MYSQLND * const conn TSRMLS_DC)
 	  in mysqlnd_store_result() or mysqlnd_fetch_row_unbuffered()
 	*/
 	if (FAIL == (ret = mysqlnd_query_read_result_set_header(conn, NULL TSRMLS_CC))) {
-		/*
-		  There can be an error in the middle of a multi-statement, which will cancel the multi-statement.
-		  So there are no more results and we should just return FALSE, error_no has been set
-		*/
-		if (!conn->error_info.error_no) {
-			DBG_ERR_FMT("Serious error. %s::%d", __FILE__, __LINE__);
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error. PID=%d", getpid());
-			CONN_SET_STATE(conn, CONN_QUIT_SENT);
-		} else {
-			DBG_INF_FMT("Error from the server : (%d) %s", conn->error_info.error_no, conn->error_info.error);
-		}
+		DBG_ERR_FMT("Serious error. %s::%d", __FILE__, __LINE__);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error. PID=%d", getpid());
+		CONN_SET_STATE(conn, CONN_QUIT_SENT);
 	}
 
 	DBG_RETURN(ret);
@@ -1859,7 +1631,7 @@ MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn,
 
 	if (PASS != mysqlnd_simple_command(conn, COM_CHANGE_USER, buffer, p - buffer,
 									   PROT_LAST /* we will handle the OK packet*/,
-									   FALSE, TRUE TSRMLS_CC)) {
+									   FALSE TSRMLS_CC)) {
 		DBG_RETURN(FAIL);
 	}
 
@@ -1922,11 +1694,11 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn,
 	switch (option) {
 #if PHP_MAJOR_VERSION >= 6
 		case MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE:
-			conn->options.numeric_and_datetime_as_unicode = *(unsigned int*) value;
+			conn->options.numeric_and_datetime_as_unicode = *(uint*) value;
 			break;
 #endif
 		case MYSQLND_OPT_NET_CMD_BUFFER_SIZE:
-			conn->net.cmd_buffer.length = *(unsigned int*) value;
+			conn->net.cmd_buffer.length = *(uint*) value;
 			if (!conn->net.cmd_buffer.buffer) {
 				conn->net.cmd_buffer.buffer = mnd_pemalloc(conn->net.cmd_buffer.length, conn->persistent);
 			} else {
@@ -1936,26 +1708,26 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn,
 			}
 			break;
 		case MYSQLND_OPT_NET_READ_BUFFER_SIZE:
-			conn->options.net_read_buffer_size = *(unsigned int*) value;
+			conn->options.net_read_buffer_size = *(uint*) value;
 			break;
 #ifdef MYSQLND_STRING_TO_INT_CONVERSION
-		case MYSQLND_OPT_INT_AND_FLOAT_NATIVE:
-			conn->options.int_and_float_native = *(unsigned int*) value;
+		case MYSQLND_OPT_INT_AND_YEAR_AS_INT:
+			conn->options.int_and_year_as_int = *(uint*) value;
 			break;
 #endif
 		case MYSQL_OPT_CONNECT_TIMEOUT:
-			conn->options.timeout_connect = *(unsigned int*) value;
+			conn->options.timeout_connect = *(uint*) value;
 			break;
 #ifdef WHEN_SUPPORTED_BY_MYSQLI
 		case MYSQL_OPT_READ_TIMEOUT:
-			conn->options.timeout_read = *(unsigned int*) value;
+			conn->options.timeout_read = *(uint*) value;
 			break;
 		case MYSQL_OPT_WRITE_TIMEOUT:
-			conn->options.timeout_write = *(unsigned int*) value;
+			conn->options.timeout_write = *(uint*) value;
 			break;
 #endif
 		case MYSQL_OPT_LOCAL_INFILE:
-			if (!value || (*(unsigned int*) value) ? 1 : 0) {
+			if (!value || (*(uint*) value) ? 1 : 0) {
 				conn->options.flags |= CLIENT_LOCAL_FILES;
 			} else {
 				conn->options.flags &= ~CLIENT_LOCAL_FILES;
@@ -2130,8 +1902,6 @@ MYSQLND_CLASS_METHODS_START(mysqlnd_conn)
 	MYSQLND_METHOD(mysqlnd_conn, escape_string),
 	MYSQLND_METHOD(mysqlnd_conn, set_charset),
 	MYSQLND_METHOD(mysqlnd_conn, query),
-	MYSQLND_METHOD(mysqlnd_conn, send_query),
-	MYSQLND_METHOD(mysqlnd_conn, reap_query),
 	MYSQLND_METHOD(mysqlnd_conn, use_result),
 	MYSQLND_METHOD(mysqlnd_conn, store_result),
 	MYSQLND_METHOD(mysqlnd_conn, background_store_result),
diff --git a/ext/mysqlnd/mysqlnd.h b/ext/mysqlnd/mysqlnd.h
index a8d0211924..cc6afab51c 100644
--- a/ext/mysqlnd/mysqlnd.h
+++ b/ext/mysqlnd/mysqlnd.h
@@ -23,14 +23,14 @@
 #ifndef MYSQLND_H
 #define MYSQLND_H
 
-#define MYSQLND_VERSION "mysqlnd 5.0.5-dev - 081106 - $Revision$"
-#define MYSQLND_VERSION_ID 50005
+#define MYSQLND_VERSION "mysqlnd 5.0.4-dev - 080501 - $Revision$"
+#define MYSQLND_VERSION_ID 50004
 
 /* This forces inlining of some accessor functions */
-#define MYSQLND_USE_OPTIMISATIONS 1
+#define MYSQLND_USE_OPTIMISATIONS 0
 
 
-#define MYSQLND_STRING_TO_INT_CONVERSION
+/* #define MYSQLND_STRING_TO_INT_CONVERSION */
 /*
   This force mysqlnd to do a single (or more depending on ammount of data)
   non-blocking read() calls before sending a command to the server. Useful
@@ -74,7 +74,7 @@ PHPAPI void _mysqlnd_end_psession(MYSQLND *conn TSRMLS_DC);
 PHPAPI void mysqlnd_minfo_print_hash(zval *values);
 #define mysqlnd_thread_safe()	TRUE
 
-PHPAPI const MYSQLND_CHARSET * mysqlnd_find_charset_nr(unsigned int charsetno);
+PHPAPI const MYSQLND_CHARSET * mysqlnd_find_charset_nr(uint charsetno);
 PHPAPI const MYSQLND_CHARSET * mysqlnd_find_charset_name(const char * const charsetname);
 
 
@@ -106,12 +106,8 @@ PHPAPI void _mysqlnd_debug(const char *mode TSRMLS_DC);
 
 #define mysqlnd_close(conn,is_forced)					(conn)->m->close((conn), (is_forced) TSRMLS_CC)
 #define mysqlnd_query(conn, query_str, query_len)		(conn)->m->query((conn), (query_str), (query_len) TSRMLS_CC)
-#define mysqlnd_async_query(conn, query_str, query_len)	(conn)->m->send_query((conn), (query_str), (query_len) TSRMLS_CC)
-#define mysqlnd_poll(r, err, d_pull,sec,usec,desc_num)	_mysqlnd_poll((r), (err), (d_pull), (sec), (usec), (desc_num) TSRMLS_CC)
-#define mysqlnd_reap_async_query(conn)					(conn)->m->reap_query((conn) TSRMLS_CC)
 #define mysqlnd_unbuffered_skip_result(result)			(result)->m.skip_result((result) TSRMLS_CC)
 
-PHPAPI enum_func_status _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQLND ***dont_poll, long sec, long usec, uint * desc_num TSRMLS_DC);
 
 #define mysqlnd_use_result(conn)		(conn)->m->use_result((conn) TSRMLS_CC)
 #define mysqlnd_store_result(conn)		(conn)->m->store_result((conn) TSRMLS_CC)
diff --git a/ext/mysqlnd/mysqlnd_block_alloc.c b/ext/mysqlnd/mysqlnd_block_alloc.c
index 1991e413f2..0bc85b25cc 100644
--- a/ext/mysqlnd/mysqlnd_block_alloc.c
+++ b/ext/mysqlnd/mysqlnd_block_alloc.c
@@ -31,7 +31,7 @@
 static void
 mysqlnd_mempool_free_contents(MYSQLND_MEMORY_POOL * pool TSRMLS_DC)
 {
-	unsigned int i;
+	uint i;
 	DBG_ENTER("mysqlnd_mempool_dtor");
 	for (i = 0; i < pool->free_chunk_list_elements; i++) {
 		MYSQLND_MEMORY_POOL_CHUNK * chunk = pool->free_chunk_list[i];
@@ -76,7 +76,7 @@ mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it
 
 /* {{{ mysqlnd_mempool_resize_chunk */
 static void
-mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC)
+mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, uint size TSRMLS_DC)
 {
 	DBG_ENTER("mysqlnd_mempool_resize_chunk");
 	if (chunk->from_pool) {
@@ -124,7 +124,7 @@ mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int siz
 
 /* {{{ mysqlnd_mempool_get_chunk */
 static
-MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, unsigned int size TSRMLS_DC)
+MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, uint size TSRMLS_DC)
 {
 	MYSQLND_MEMORY_POOL_CHUNK *chunk = NULL;
 	DBG_ENTER("mysqlnd_mempool_get_chunk");
diff --git a/ext/mysqlnd/mysqlnd_charset.c b/ext/mysqlnd/mysqlnd_charset.c
index e4ce06e36c..5e72c7decd 100644
--- a/ext/mysqlnd/mysqlnd_charset.c
+++ b/ext/mysqlnd/mysqlnd_charset.c
@@ -25,7 +25,7 @@
 
 /* {{{ utf8 functions */
 
-static unsigned int check_mb_utf8_sequence(const char *start, const char *end)
+static uint check_mb_utf8_sequence(const char *start, const char *end)
 {
 	zend_uchar	c;
 
@@ -63,13 +63,13 @@ static unsigned int check_mb_utf8_sequence(const char *start, const char *end)
 	return 0;
 }
 
-static unsigned int check_mb_utf8_valid(const char *start, const char *end)
+static uint check_mb_utf8_valid(const char *start, const char *end)
 {
-	unsigned int len = check_mb_utf8_sequence(start, end);
+	uint len = check_mb_utf8_sequence(start, end);
 	return (len > 1)? len:0;
 }
 
-static unsigned int mysqlnd_mbcharlen_utf8(unsigned int utf8)
+static uint mysqlnd_mbcharlen_utf8(uint utf8)
 {
 	if (utf8 < 0x80) {
 		return 1;		/* single byte character */
@@ -91,19 +91,19 @@ static unsigned int mysqlnd_mbcharlen_utf8(unsigned int utf8)
 
 
 /* {{{ big5 functions */
-#define valid_big5head(c)	(0xA1 <= (unsigned int)(c) && (unsigned int)(c) <= 0xF9)
-#define valid_big5tail(c)	((0x40 <= (unsigned int)(c) && (unsigned int)(c) <= 0x7E) || \
-							(0xA1 <= (unsigned int)(c) && (unsigned int)(c) <= 0xFE))
+#define valid_big5head(c)	(0xA1 <= (uint)(c) && (uint)(c) <= 0xF9)
+#define valid_big5tail(c)	((0x40 <= (uint)(c) && (uint)(c) <= 0x7E) || \
+							(0xA1 <= (uint)(c) && (uint)(c) <= 0xFE))
 
 #define isbig5code(c,d) (isbig5head(c) && isbig5tail(d))
 
-static unsigned int check_mb_big5(const char *start, const char *end)
+static uint check_mb_big5(const char *start, const char *end)
 {
 	return (valid_big5head(*(start)) && (end - start) > 1 && valid_big5tail(*(start + 1)) ? 2 : 0);
 }
 
 
-static unsigned int mysqlnd_mbcharlen_big5(unsigned int big5)
+static uint mysqlnd_mbcharlen_big5(uint big5)
 {
 	return (valid_big5head(big5)) ? 2 : 1;
 }
@@ -115,14 +115,14 @@ static unsigned int mysqlnd_mbcharlen_big5(unsigned int big5)
 #define valid_cp932tail(c) ((0x40 <= (c) && (c) <= 0x7E) || (0x80 <= (c) && c <= 0xFC))
 
 
-static unsigned int check_mb_cp932(const char *start, const char *end)
+static uint check_mb_cp932(const char *start, const char *end)
 {
 	return (valid_cp932head((zend_uchar)start[0]) && (end - start >  1) &&
 			valid_cp932tail((zend_uchar)start[1])) ? 2 : 0;
 }
 
 
-static unsigned int mysqlnd_mbcharlen_cp932(unsigned int cp932)
+static uint mysqlnd_mbcharlen_cp932(uint cp932)
 {
 	return (valid_cp932head((zend_uchar)cp932)) ? 2 : 1;
 }
@@ -132,7 +132,7 @@ static unsigned int mysqlnd_mbcharlen_cp932(unsigned int cp932)
 /* {{{ euckr functions */
 #define valid_euckr(c)	((0xA1 <= (zend_uchar)(c) && (zend_uchar)(c) <= 0xFE))
 
-static unsigned int check_mb_euckr(const char *start, const char *end)
+static uint check_mb_euckr(const char *start, const char *end)
 {
 	if (end - start <= 1) {
 		return 0;	/* invalid length */
@@ -147,7 +147,7 @@ static unsigned int check_mb_euckr(const char *start, const char *end)
 }
 
 
-static unsigned int mysqlnd_mbcharlen_euckr(unsigned int kr)
+static uint mysqlnd_mbcharlen_euckr(uint kr)
 {
 	return (valid_euckr(kr)) ? 2 : 1;
 }
@@ -160,7 +160,7 @@ static unsigned int mysqlnd_mbcharlen_euckr(unsigned int kr)
 #define valid_eucjpms_ss2(c)	(((c) & 0xFF) == 0x8E)
 #define valid_eucjpms_ss3(c)	(((c) & 0xFF) == 0x8F)
 
-static unsigned int check_mb_eucjpms(const char *start, const char *end)
+static uint check_mb_eucjpms(const char *start, const char *end)
 {
 	if (*((zend_uchar *)start) < 0x80) {
 		return 0;	/* invalid eucjpms character */
@@ -179,7 +179,7 @@ static unsigned int check_mb_eucjpms(const char *start, const char *end)
 }
 
 
-static unsigned int mysqlnd_mbcharlen_eucjpms(unsigned int jpms)
+static uint mysqlnd_mbcharlen_eucjpms(uint jpms)
 {
 	if (valid_eucjpms(jpms) || valid_eucjpms_ss2(jpms)) {
 		return 2;
@@ -197,14 +197,14 @@ static unsigned int mysqlnd_mbcharlen_eucjpms(unsigned int jpms)
 #define valid_gb2312_tail(c)	(0xA1 <= (zend_uchar)(c) && (zend_uchar)(c) <= 0xFE)
 
 
-static unsigned int check_mb_gb2312(const char *start, const char *end)
+static uint check_mb_gb2312(const char *start, const char *end)
 {
-	return (valid_gb2312_head((unsigned int)start[0]) && end - start > 1 && 
-			valid_gb2312_tail((unsigned int)start[1])) ? 2 : 0;
+	return (valid_gb2312_head((uint)start[0]) && end - start > 1 && 
+			valid_gb2312_tail((uint)start[1])) ? 2 : 0;
 }
 
 
-static unsigned int mysqlnd_mbcharlen_gb2312(unsigned int gb)
+static uint mysqlnd_mbcharlen_gb2312(uint gb)
 {
 	return (valid_gb2312_head(gb)) ? 2 : 1;
 }
@@ -215,12 +215,12 @@ static unsigned int mysqlnd_mbcharlen_gb2312(unsigned int gb)
 #define valid_gbk_head(c)	(0x81<=(zend_uchar)(c) && (zend_uchar)(c)<=0xFE)
 #define valid_gbk_tail(c)	((0x40<=(zend_uchar)(c) && (zend_uchar)(c)<=0x7E) || (0x80<=(zend_uchar)(c) && (zend_uchar)(c)<=0xFE))
 
-static unsigned int check_mb_gbk(const char *start, const char *end)
+static uint check_mb_gbk(const char *start, const char *end)
 {
 	return (valid_gbk_head(start[0]) && (end) - (start) > 1 && valid_gbk_tail(start[1])) ? 2 : 0;
 }
 
-static unsigned int mysqlnd_mbcharlen_gbk(unsigned int gbk)
+static uint mysqlnd_mbcharlen_gbk(uint gbk)
 {
 	return (valid_gbk_head(gbk) ? 2 : 1);
 }
@@ -234,13 +234,13 @@ static unsigned int mysqlnd_mbcharlen_gbk(unsigned int gbk)
 							 (0x80 <= (c) && (c) <= 0x7C))
 
 
-static unsigned int check_mb_sjis(const char *start, const char *end)
+static uint check_mb_sjis(const char *start, const char *end)
 {
 	return (valid_sjis_head((zend_uchar)start[0]) && (end - start) > 1 && valid_sjis_tail((zend_uchar)start[1])) ? 2 : 0;
 }
 
 
-static unsigned int mysqlnd_mbcharlen_sjis(unsigned int sjis)
+static uint mysqlnd_mbcharlen_sjis(uint sjis)
 {
 	return (valid_sjis_head((zend_uchar)sjis)) ? 2 : 1;
 }
@@ -248,12 +248,12 @@ static unsigned int mysqlnd_mbcharlen_sjis(unsigned int sjis)
 
 
 /* {{{ ucs2 functions */
-static unsigned int check_mb_ucs2(const char *start __attribute((unused)), const char *end __attribute((unused)))
+static uint check_mb_ucs2(const char *start __attribute((unused)), const char *end __attribute((unused)))
 {
 	return 2; /* always 2 */
 }
 
-static unsigned int mysqlnd_mbcharlen_ucs2(unsigned int ucs2 __attribute((unused)))
+static uint mysqlnd_mbcharlen_ucs2(uint ucs2 __attribute((unused)))
 {
 	return 2; /* always 2 */
 }
@@ -266,9 +266,9 @@ static unsigned int mysqlnd_mbcharlen_ucs2(unsigned int ucs2 __attribute((unused
 #define valid_ujis_ss2(c) 	(((c)&0xFF) == 0x8E)
 #define valid_ujis_ss3(c) 	(((c)&0xFF) == 0x8F)
 
-static unsigned int check_mb_ujis(const char *start, const char *end)
+static uint check_mb_ujis(const char *start, const char *end)
 {
-	if (*(zend_uchar*)start < 0x80) {
+	if (*(uchar*)start < 0x80) {
 		return 0;	/* invalid ujis character */
 	}
 	if (valid_ujis(*(start)) && valid_ujis(*((start)+1))) {
@@ -284,7 +284,7 @@ static unsigned int check_mb_ujis(const char *start, const char *end)
 }
 
 
-static unsigned int mysqlnd_mbcharlen_ujis(unsigned int ujis)
+static uint mysqlnd_mbcharlen_ujis(uint ujis)
 {
 	return (valid_ujis(ujis)? 2: valid_ujis_ss2(ujis)? 2: valid_ujis_ss3(ujis)? 3: 1);
 }
@@ -430,7 +430,7 @@ const MYSQLND_CHARSET mysqlnd_charsets[] =
 
 
 /* {{{ mysqlnd_find_charset_nr */
-PHPAPI const MYSQLND_CHARSET * mysqlnd_find_charset_nr(unsigned int charsetnr)
+PHPAPI const MYSQLND_CHARSET * mysqlnd_find_charset_nr(uint charsetnr)
 {
 	const MYSQLND_CHARSET * c = mysqlnd_charsets;
 
@@ -473,7 +473,7 @@ PHPAPI ulong mysqlnd_cset_escape_quotes(const MYSQLND_CHARSET * const cset, char
 	DBG_ENTER("mysqlnd_cset_escape_quotes");
 
 	for (;escapestr < end; escapestr++) {
-		unsigned int len = 0;
+		uint len = 0;
 		/* check unicode characters */
 		
 		if (cset->char_maxlen > 1 && (len = cset->mb_valid(escapestr, end))) {
@@ -528,7 +528,7 @@ PHPAPI ulong mysqlnd_cset_escape_slashes(const MYSQLND_CHARSET * const cset, cha
 	
 	for (;escapestr < end; escapestr++) {
 		char esc = '\0';
-		unsigned int len = 0;
+		uint len = 0;
 
 		/* check unicode characters */
 		if (cset->char_maxlen > 1 && (len = cset->mb_valid(escapestr, end))) {
diff --git a/ext/mysqlnd/mysqlnd_debug.c b/ext/mysqlnd/mysqlnd_debug.c
index e82935d2a6..0722e27478 100644
--- a/ext/mysqlnd/mysqlnd_debug.c
+++ b/ext/mysqlnd/mysqlnd_debug.c
@@ -89,7 +89,7 @@ MYSQLND_METHOD(mysqlnd_debug, log)(MYSQLND_DEBUG * self,
 	enum_func_status ret;
 	int i;
 	char * message_line;
-	unsigned int message_line_len;
+	uint message_line_len;
 	unsigned int flags = self->flags;
 	char pid_buffer[10], time_buffer[30], file_buffer[200],
 		 line_buffer[6], level_buffer[7];
@@ -194,7 +194,7 @@ MYSQLND_METHOD(mysqlnd_debug, log_va)(MYSQLND_DEBUG *self,
 	int i;
 	enum_func_status ret;
 	char * message_line, *buffer;
-	unsigned int message_line_len;
+	uint message_line_len;
 	va_list args;
 	unsigned int flags = self->flags;
 	char pid_buffer[10], time_buffer[30], file_buffer[200],
@@ -301,7 +301,7 @@ MYSQLND_METHOD(mysqlnd_debug, log_va)(MYSQLND_DEBUG *self,
 static zend_bool
 MYSQLND_METHOD(mysqlnd_debug, func_enter)(MYSQLND_DEBUG * self,
 										  unsigned int line, const char * const file,
-										  char * func_name, unsigned int func_name_len)
+										  char * func_name, uint func_name_len)
 {
 #ifdef MYSQLND_THREADED
 	MYSQLND_ZTS(self);
@@ -422,7 +422,7 @@ enum mysqlnd_debug_parser_state
 static void
 MYSQLND_METHOD(mysqlnd_debug, set_mode)(MYSQLND_DEBUG * self, const char * const mode)
 {
-	unsigned int mode_len = strlen(mode), i;
+	uint mode_len = strlen(mode), i;
 	enum mysqlnd_debug_parser_state state = PARSER_WAIT_MODIFIER;
 
 	self->flags = 0;
@@ -487,7 +487,7 @@ MYSQLND_METHOD(mysqlnd_debug, set_mode)(MYSQLND_DEBUG * self, const char * const
 						if (mode[j] == ',' || mode[j] == ':') {
 							if (j > i + 2) {
 								char func_name[1024];
-								unsigned int func_name_len = MIN(sizeof(func_name) - 1, j - i - 1);
+								uint func_name_len = MIN(sizeof(func_name) - 1, j - i - 1);
 								memcpy(func_name, mode + i + 1, func_name_len);
 								func_name[func_name_len] = '\0'; 
 
@@ -683,7 +683,7 @@ void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D)
 	DBG_INF_FMT("size=%lu ptr=%p", size, ret); 
 
 	if (MYSQLND_G(collect_memory_statistics)) {
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EMALLOC_COUNT, 1, STAT_MEM_EMALLOC_AMMOUNT, size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(STAT_MEM_EMALLOC_COUNT, 1, STAT_MEM_EMALLOC_AMMOUNT, size);
 	}
 	DBG_RETURN(ret);
 }
@@ -710,7 +710,7 @@ void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D)
 	if (MYSQLND_G(collect_memory_statistics)) {
 		enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_MALLOC_COUNT:STAT_MEM_EMALLOC_COUNT;
 		enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_MALLOC_AMMOUNT:STAT_MEM_EMALLOC_AMMOUNT;
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(s1, 1, s2, size);
 	}
 
 	DBG_RETURN(ret);
@@ -719,7 +719,7 @@ void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D)
 
 
 /* {{{ _mysqlnd_ecalloc */
-void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
+void * _mysqlnd_ecalloc(uint nmemb, size_t size MYSQLND_MEM_D)
 {
 	void *ret;
 	DBG_ENTER(mysqlnd_ecalloc_name);
@@ -736,7 +736,7 @@ void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
 	DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC));
 	DBG_INF_FMT("size=%lu ptr=%p", size, ret); 
 	if (MYSQLND_G(collect_memory_statistics)) {
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_ECALLOC_COUNT, 1, STAT_MEM_ECALLOC_AMMOUNT, size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(STAT_MEM_ECALLOC_COUNT, 1, STAT_MEM_ECALLOC_AMMOUNT, size);
 	}
 	DBG_RETURN(ret);
 }
@@ -744,7 +744,7 @@ void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
 
 
 /* {{{ _mysqlnd_pecalloc */
-void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D)
+void * _mysqlnd_pecalloc(uint nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D)
 {
 	void *ret;
 	DBG_ENTER(mysqlnd_pecalloc_name);
@@ -763,7 +763,7 @@ void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent M
 	if (MYSQLND_G(collect_memory_statistics)) {
 		enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_CALLOC_COUNT:STAT_MEM_ECALLOC_COUNT;
 		enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_CALLOC_AMMOUNT:STAT_MEM_ECALLOC_AMMOUNT;
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(s1, 1, s2, size);
 	}
 
 	DBG_RETURN(ret);
@@ -790,7 +790,7 @@ void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D)
 	DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC));
 	DBG_INF_FMT("new_ptr=%p", ret); 
 	if (MYSQLND_G(collect_memory_statistics)) {
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EREALLOC_COUNT, 1, STAT_MEM_EREALLOC_AMMOUNT, new_size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(STAT_MEM_EREALLOC_COUNT, 1, STAT_MEM_EREALLOC_AMMOUNT, new_size);
 	}
 	DBG_RETURN(ret);
 }
@@ -819,7 +819,7 @@ void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQL
 	if (MYSQLND_G(collect_memory_statistics)) {
 		enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_REALLOC_COUNT:STAT_MEM_EREALLOC_COUNT;
 		enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_REALLOC_AMMOUNT:STAT_MEM_EREALLOC_AMMOUNT;
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, new_size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(s1, 1, s2, new_size);
 	}
 	DBG_RETURN(ret);
 }
@@ -881,7 +881,7 @@ void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D)
 
 	DBG_INF_FMT("size=%lu ptr=%p", size, ret); 
 	if (MYSQLND_G(collect_memory_statistics)) {
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_MALLOC_COUNT, 1, STAT_MEM_MALLOC_AMMOUNT, size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(STAT_MEM_MALLOC_COUNT, 1, STAT_MEM_MALLOC_AMMOUNT, size);
 	}
 	DBG_RETURN(ret);
 }
@@ -889,7 +889,7 @@ void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D)
 
 
 /* {{{ _mysqlnd_calloc */
-void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
+void * _mysqlnd_calloc(uint nmemb, size_t size MYSQLND_MEM_D)
 {
 	void *ret;
 	DBG_ENTER(mysqlnd_calloc_name);
@@ -899,7 +899,7 @@ void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
 
 	DBG_INF_FMT("size=%lu ptr=%p", size, ret); 
 	if (MYSQLND_G(collect_memory_statistics)) {
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_CALLOC_COUNT, 1, STAT_MEM_CALLOC_AMMOUNT, size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(STAT_MEM_CALLOC_COUNT, 1, STAT_MEM_CALLOC_AMMOUNT, size);
 	}
 	DBG_RETURN(ret);
 }
@@ -920,7 +920,7 @@ void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D)
 	DBG_INF_FMT("new_ptr=%p", ret);
 
 	if (MYSQLND_G(collect_memory_statistics)) {
-		MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_REALLOC_COUNT, 1, STAT_MEM_REALLOC_AMMOUNT, new_size);
+		MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(STAT_MEM_REALLOC_COUNT, 1, STAT_MEM_REALLOC_AMMOUNT, new_size);
 	}
 	DBG_RETURN(ret);
 }
diff --git a/ext/mysqlnd/mysqlnd_debug.h b/ext/mysqlnd/mysqlnd_debug.h
index 58b11e34aa..7b1ba88ae7 100644
--- a/ext/mysqlnd/mysqlnd_debug.h
+++ b/ext/mysqlnd/mysqlnd_debug.h
@@ -36,7 +36,7 @@ struct st_mysqlnd_debug_methods
 	enum_func_status (*log_va)(MYSQLND_DEBUG *self, unsigned int line, const char * const file,
 							   unsigned int level, const char * type, const char *format, ...);
 	zend_bool (*func_enter)(MYSQLND_DEBUG *self, unsigned int line, const char * const file,
-							char * func_name, unsigned int func_name_len);
+							char * func_name, uint func_name_len);
 	enum_func_status (*func_leave)(MYSQLND_DEBUG *self, unsigned int line, const char * const file);
 	enum_func_status (*close)(MYSQLND_DEBUG *self);
 	enum_func_status (*free_handle)(MYSQLND_DEBUG *self);
@@ -65,14 +65,14 @@ MYSQLND_DEBUG *mysqlnd_debug_init(TSRMLS_D);
 
 void *	_mysqlnd_emalloc(size_t size MYSQLND_MEM_D);
 void *	_mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D);
-void *	_mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D);
-void *	_mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D);
+void *	_mysqlnd_ecalloc(uint nmemb, size_t size MYSQLND_MEM_D);
+void *	_mysqlnd_pecalloc(uint nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D);
 void *	_mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D);
 void *	_mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D);
 void 	_mysqlnd_efree(void *ptr MYSQLND_MEM_D);
 void 	_mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D);
 void *	_mysqlnd_malloc(size_t size MYSQLND_MEM_D);
-void *	_mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D);
+void *	_mysqlnd_calloc(uint nmemb, size_t size MYSQLND_MEM_D);
 void *	_mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D);
 void	_mysqlnd_free(void *ptr MYSQLND_MEM_D);
 
@@ -92,13 +92,13 @@ char *	mysqlnd_get_backtrace(TSRMLS_D);
 #elif MYSQLND_DBG_ENABLED == 0
 
 
-static inline void DBG_INF(const char * const msg) {}
-static inline void DBG_ERR(const char * const msg) {}
-static inline void DBG_INF_FMT(const char * const format, ...) {}
-static inline void DBG_ERR_FMT(const char * const format, ...) {}
-static inline void DBG_ENTER(const char * const func_name) {}
+static inline void DBG_INF(char *msg) {}
+static inline void DBG_ERR(char *msg) {}
+static inline void DBG_INF_FMT(char *format, ...) {}
+static inline void DBG_ERR_FMT(char *format, ...) {}
+static inline void DBG_ENTER(char *func_name) {}
 #define DBG_RETURN(value)	return (value)
-#define DBG_VOID_RETURN		return
+#define DBG_VOID_RETURN		return;
 #endif
 
 
diff --git a/ext/mysqlnd/mysqlnd_enum_n_def.h b/ext/mysqlnd/mysqlnd_enum_n_def.h
index 2b397ffaad..f08faef826 100644
--- a/ext/mysqlnd/mysqlnd_enum_n_def.h
+++ b/ext/mysqlnd/mysqlnd_enum_n_def.h
@@ -136,7 +136,7 @@ typedef enum mysqlnd_option
 	MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE = 200,
 #endif
 #ifdef MYSQLND_STRING_TO_INT_CONVERSION
-	MYSQLND_OPT_INT_AND_FLOAT_NATIVE = 201,
+	MYSQLND_OPT_INT_AND_YEAR_AS_INT = 201,
 #endif
 	MYSQLND_OPT_NET_CMD_BUFFER_SIZE = 202,
 	MYSQLND_OPT_NET_READ_BUFFER_SIZE = 203,
@@ -303,7 +303,6 @@ typedef enum mysqlnd_connection_close_type
 	MYSQLND_CLOSE_LAST	/* for checking, should always be last */
 } enum_connection_close_type;
 
-
 typedef enum mysqlnd_collected_stats
 {
 	STAT_BYTES_SENT,
@@ -312,21 +311,6 @@ typedef enum mysqlnd_collected_stats
 	STAT_PACKETS_RECEIVED,
 	STAT_PROTOCOL_OVERHEAD_IN,
 	STAT_PROTOCOL_OVERHEAD_OUT,
-	STAT_BYTES_RECEIVED_OK,
-	STAT_BYTES_RECEIVED_EOF,
-	STAT_BYTES_RECEIVED_RSET_HEADER,
-	STAT_BYTES_RECEIVED_RSET_FIELD_META,
-	STAT_BYTES_RECEIVED_RSET_ROW,
-	STAT_BYTES_RECEIVED_PREPARE_RESPONSE,
-	STAT_BYTES_RECEIVED_CHANGE_USER,
-	STAT_PACKETS_SENT_CMD,
-	STAT_PACKETS_RECEIVED_OK,
-	STAT_PACKETS_RECEIVED_EOF,
-	STAT_PACKETS_RECEIVED_RSET_HEADER,
-	STAT_PACKETS_RECEIVED_RSET_FIELD_META,
-	STAT_PACKETS_RECEIVED_RSET_ROW,
-	STAT_PACKETS_RECEIVED_PREPARE_RESPONSE,
-	STAT_PACKETS_RECEIVED_CHANGE_USER,
 	STAT_RSET_QUERY,
 	STAT_NON_RSET_QUERY,
 	STAT_NO_INDEX_USED,
@@ -383,48 +367,6 @@ typedef enum mysqlnd_collected_stats
 	STAT_MEM_REALLOC_COUNT,
 	STAT_MEM_REALLOC_AMMOUNT,
 	STAT_MEM_FREE_COUNT,
-	STAT_TEXT_TYPE_FETCHED_NULL,
-	STAT_TEXT_TYPE_FETCHED_BIT,
-	STAT_TEXT_TYPE_FETCHED_INT8,
-	STAT_TEXT_TYPE_FETCHED_INT16,
-	STAT_TEXT_TYPE_FETCHED_INT24,
-	STAT_TEXT_TYPE_FETCHED_INT32,
-	STAT_TEXT_TYPE_FETCHED_INT64,
-	STAT_TEXT_TYPE_FETCHED_DECIMAL,
-	STAT_TEXT_TYPE_FETCHED_FLOAT,
-	STAT_TEXT_TYPE_FETCHED_DOUBLE,
-	STAT_TEXT_TYPE_FETCHED_DATE,
-	STAT_TEXT_TYPE_FETCHED_YEAR,
-	STAT_TEXT_TYPE_FETCHED_TIME,
-	STAT_TEXT_TYPE_FETCHED_DATETIME,
-	STAT_TEXT_TYPE_FETCHED_TIMESTAMP,
-	STAT_TEXT_TYPE_FETCHED_STRING,
-	STAT_TEXT_TYPE_FETCHED_BLOB,
-	STAT_TEXT_TYPE_FETCHED_ENUM,
-	STAT_TEXT_TYPE_FETCHED_SET,
-	STAT_TEXT_TYPE_FETCHED_GEOMETRY,
-	STAT_TEXT_TYPE_FETCHED_OTHER,
-	STAT_BINARY_TYPE_FETCHED_NULL,
-	STAT_BINARY_TYPE_FETCHED_BIT,
-	STAT_BINARY_TYPE_FETCHED_INT8,
-	STAT_BINARY_TYPE_FETCHED_INT16,
-	STAT_BINARY_TYPE_FETCHED_INT24,
-	STAT_BINARY_TYPE_FETCHED_INT32,
-	STAT_BINARY_TYPE_FETCHED_INT64,
-	STAT_BINARY_TYPE_FETCHED_DECIMAL,
-	STAT_BINARY_TYPE_FETCHED_FLOAT,
-	STAT_BINARY_TYPE_FETCHED_DOUBLE,
-	STAT_BINARY_TYPE_FETCHED_DATE,
-	STAT_BINARY_TYPE_FETCHED_YEAR,
-	STAT_BINARY_TYPE_FETCHED_TIME,
-	STAT_BINARY_TYPE_FETCHED_DATETIME,
-	STAT_BINARY_TYPE_FETCHED_TIMESTAMP,
-	STAT_BINARY_TYPE_FETCHED_STRING,
-	STAT_BINARY_TYPE_FETCHED_BLOB,
-	STAT_BINARY_TYPE_FETCHED_ENUM,
-	STAT_BINARY_TYPE_FETCHED_SET,
-	STAT_BINARY_TYPE_FETCHED_GEOMETRY,
-	STAT_BINARY_TYPE_FETCHED_OTHER,
 	STAT_LAST /* Should be always the last */
 } enum_mysqlnd_collected_stats;
 
diff --git a/ext/mysqlnd/mysqlnd_libmysql_compat.h b/ext/mysqlnd/mysqlnd_libmysql_compat.h
index 7b3dce098c..662cc45af3 100644
--- a/ext/mysqlnd/mysqlnd_libmysql_compat.h
+++ b/ext/mysqlnd/mysqlnd_libmysql_compat.h
@@ -31,7 +31,7 @@
 #define MYSQL_ROW				MYSQLND_ROW_C
 #define MYSQL					MYSQLND
 #define my_bool					zend_bool
-#define my_ulonglong			uint64_t
+#define my_ulonglong			uint64
 
 #define MYSQL_VERSION_ID		MYSQLND_VERSION_ID
 #define MYSQL_SERVER_VERSION	MYSQLND_VERSION
diff --git a/ext/mysqlnd/mysqlnd_loaddata.c b/ext/mysqlnd/mysqlnd_loaddata.c
index 12032c13c6..3298c10380 100644
--- a/ext/mysqlnd/mysqlnd_loaddata.c
+++ b/ext/mysqlnd/mysqlnd_loaddata.c
@@ -27,8 +27,7 @@
 
 enum_func_status mysqlnd_simple_command_handle_response(MYSQLND *conn,
 										enum php_mysql_packet_type ok_packet,
-										zend_bool silent, enum php_mysqlnd_server_command command,
-										zend_bool ignore_upsert_status
+										zend_bool silent, enum php_mysqlnd_server_command command
 									  	TSRMLS_DC);
 
 
@@ -86,7 +85,7 @@ int mysqlnd_local_infile_init(void **ptr, char *filename, void **userdata TSRMLS
 
 /* {{{ mysqlnd_local_infile_read */
 static
-int mysqlnd_local_infile_read(void *ptr, char *buf, unsigned int buf_len TSRMLS_DC)
+int mysqlnd_local_infile_read(void *ptr, char *buf, uint buf_len TSRMLS_DC)
 {
 	MYSQLND_INFILE_INFO	*info = (MYSQLND_INFILE_INFO *)ptr;
 	int count;
@@ -107,7 +106,7 @@ int mysqlnd_local_infile_read(void *ptr, char *buf, unsigned int buf_len TSRMLS_
 
 /* {{{ mysqlnd_local_infile_error */
 static
-int	mysqlnd_local_infile_error(void *ptr, char *error_buf, unsigned int error_buf_len TSRMLS_DC)
+int	mysqlnd_local_infile_error(void *ptr, char *error_buf, uint error_buf_len TSRMLS_DC)
 {
 	MYSQLND_INFILE_INFO	*info = (MYSQLND_INFILE_INFO *)ptr;
 
@@ -177,7 +176,7 @@ mysqlnd_handle_local_infile(MYSQLND *conn, const char *filename, zend_bool *is_w
 	char				*buf;
 	char				empty_packet[MYSQLND_HEADER_SIZE];
 	enum_func_status	result = FAIL;
-	unsigned int				buflen = 4096;
+	uint				buflen = 4096;
 	void				*info = NULL;
 	int					bufsize;
 	size_t				ret;
@@ -242,8 +241,9 @@ mysqlnd_handle_local_infile(MYSQLND *conn, const char *filename, zend_bool *is_w
 
 infile_error:
 	/* get response from server and update upsert values */
-	if (FAIL == mysqlnd_simple_command_handle_response(conn, PROT_OK_PACKET, FALSE, COM_QUERY, FALSE TSRMLS_CC)) {
+	if (FAIL == mysqlnd_simple_command_handle_response(conn, PROT_OK_PACKET, FALSE, COM_QUERY TSRMLS_CC)) {
 		result = FAIL;
+		goto infile_error;
 	}
 
 	(*conn->infile.local_infile_end)(info TSRMLS_CC);
diff --git a/ext/mysqlnd/mysqlnd_palloc.c b/ext/mysqlnd/mysqlnd_palloc.c
index 1d72dcd634..f64dd17ada 100644
--- a/ext/mysqlnd/mysqlnd_palloc.c
+++ b/ext/mysqlnd/mysqlnd_palloc.c
@@ -492,7 +492,7 @@ void mysqlnd_palloc_zval_ptr_dtor(zval **zv, MYSQLND_THD_ZVAL_PCACHE * const thd
 					thd_cache->gc_list.last_added,
 					*thd_cache->gc_list.last_added,
 					cache->free_list.canary1, cache->free_list.canary2);
-		if ((thd_cache->gc_list.last_added - thd_cache->gc_list.ptr_line) > (int) cache->max_items) {
+		if ((thd_cache->gc_list.last_added - thd_cache->gc_list.ptr_line) > cache->max_items) {
 			DBG_ERR("Buffer overflow follows");
 			DBG_ERR_FMT("parent->max_items=%d parent->free_items=%d diff=%d",
 						cache->max_items, cache->free_items,
diff --git a/ext/mysqlnd/mysqlnd_portability.h b/ext/mysqlnd/mysqlnd_portability.h
index b2334182b9..b7c4c8f096 100644
--- a/ext/mysqlnd/mysqlnd_portability.h
+++ b/ext/mysqlnd/mysqlnd_portability.h
@@ -59,198 +59,173 @@ This file is public domain and comes with NO WARRANTY of any kind */
 #define HAVE_LONG_LONG 1
 #endif
 
-
 /* Typdefs for easyier portability */
-#ifndef HAVE_INT8_T
+
 #ifndef HAVE_INT8
-typedef signed char int8_t;			/* Signed integer >= 8    bits */
+#ifndef HAVE_INT8_T
+typedef signed char int8;			/* Signed integer >= 8    bits */
 #else
-typedef int8 int8_t;				/* Signed integer >= 8    bits */
+typedef int8_t int8;				/* Signed integer >= 8    bits */
 #endif
 #endif
 
-#ifndef HAVE_UINT8_T
+
 #ifndef HAVE_UINT8
-typedef unsigned char uint8_t;		/* Unsigned integer >= 8    bits */
+#ifndef HAVE_UINT8_T
+typedef unsigned char uint8;		/* Unsigned integer >= 8    bits */
 #else
-typedef uint8 uint8_t;				/* Signed integer >= 8    bits */
+typedef uint8_t uint8;				/* Signed integer >= 8    bits */
 #endif
 #endif
 
-#ifndef HAVE_INT16_T
 #ifndef HAVE_INT16
-typedef signed short int16_t;		/* Signed integer >= 16 bits */
+#ifndef HAVE_INT16_T
+typedef signed short int16;			/* Signed integer >= 16 bits */
 #else
-typedef int16 int16_t;				/* Signed integer >= 16 bits */
+typedef int16_t int16;				/* Signed integer >= 16 bits */
 #endif
 #endif
 
-#ifndef HAVE_UINT16_T
 #ifndef HAVE_UINT16
-typedef unsigned short uint16_t;		/* Signed integer >= 16 bits */
+#ifndef HAVE_UINT16_T
+typedef unsigned short uint16;		/* Signed integer >= 16 bits */
 #else
-typedef uint16 uint16_t;			/* Signed integer >= 16 bits */
+typedef uint16_t uint16;			/* Signed integer >= 16 bits */
 #endif
 #endif
 
+#ifndef HAVE_UCHAR
+typedef unsigned char uchar;		/* Short for unsigned char */
+#endif
 
-#ifndef HAVE_INT32_T
-#ifdef HAVE_INT32
-typedef int32 int32_t;
+#ifndef HAVE_INT32
+#ifdef HAVE_INT32_T
+typedef int32_t int32;
 #elif SIZEOF_INT == 4
-typedef signed int int32_t;
+typedef signed int int32;
 #elif SIZEOF_LONG == 4
-typedef signed long int32_t;
+typedef signed long int32;
 #else
 error "Neither int nor long is of 4 bytes width"
 #endif
-#endif /* HAVE_INT32_T */
+#endif /* HAVE_INT32 */
+
 
-#ifndef HAVE_UINT32_T
-#ifdef HAVE_UINT32
-typedef uint32 uint32_t;
+#ifndef HAVE_UINT32
+#ifdef HAVE_UINT32_T
+typedef uint32_t uint32;
 #elif SIZEOF_INT == 4
-typedef unsigned int uint32_t;
+typedef unsigned int uint32;
 #elif SIZEOF_LONG == 4
-typedef unsigned long uint32_t;
+typedef unsigned long uint32;
 #else
 #error "Neither int nor long is of 4 bytes width"
 #endif
-#endif /* HAVE_UINT32_T */
+#endif /* HAVE_UINT32 */
 
-#ifndef HAVE_INT64_T
-#ifdef HAVE_INT64
-typedef int64 int64_t;
+
+#ifndef HAVE_INT64
+#ifdef HAVE_INT64_T
+typedef int64_t int64;
 #elif SIZEOF_INT == 8
-typedef signed int int64_t;
+typedef signed int int64;
 #elif SIZEOF_LONG == 8
-typedef signed long int64_t;
+typedef signed long int64;
 #elif SIZEOF_LONG_LONG == 8
 #ifdef PHP_WIN32
-typedef __int64 int64_t;
+typedef __int64 int64;
 #else
-typedef signed long long int64_t;
+typedef signed long long int64;
 #endif
 #else
 #error "Neither int nor long nor long long is of 8 bytes width"
 #endif
-#endif /* HAVE_INT64_T */
+#endif /* HAVE_INT64 */
+
 
-#ifndef HAVE_UINT64_T
-#ifdef HAVE_UINT64
-typedef uint64 uint64_t;
+#ifndef HAVE_UINT64
+#ifdef HAVE_UINT64_T
+typedef uint64_t uint64;
 #elif SIZEOF_INT == 8
-typedef unsigned int uint64_t;
+typedef unsigned int uint64;
 #elif SIZEOF_LONG == 8
-typedef unsigned long uint64_t;
+typedef unsigned long uint64;
 #elif SIZEOF_LONG_LONG == 8
 #ifdef PHP_WIN32
-typedef unsigned __int64 uint64_t;
+typedef unsigned __int64 uint64;
 #else
-typedef unsigned long long uint64_t;
+typedef unsigned long long uint64;
 #endif
 #else
 #error "Neither int nor long nor long long is of 8 bytes width"
 #endif
-#endif /* HAVE_INT64_T */
+#endif /* HAVE_INT64 */
 
 
 #ifdef PHP_WIN32
 #define MYSQLND_LLU_SPEC "%I64u"
 #define MYSQLND_LL_SPEC "%I64d"
-#define MYSQLND_SZ_T_SPEC "%Id"
 #ifndef L64
 #define L64(x) x##i64
 #endif
 #else
-
-#if __i386__
-#define MYSQLND_LL_SPEC	"%lli"
-#define MYSQLND_LLU_SPEC "%llu"
-#endif
-
-#if __ia64__
-#define MYSQLND_LL_SPEC	"%li"
-#define MYSQLND_LLU_SPEC "%lu"
-#endif
-
-#if __powerpc64__
-#define MYSQLND_LL_SPEC	"%li"
-#define MYSQLND_LLU_SPEC "%lu"
-#endif
-
-#if __x86_64__
-#define MYSQLND_LL_SPEC	"%li"
-#define MYSQLND_LLU_SPEC "%lu"
-#endif
-
-#if __s390x__
-#define MYSQLND_LL_SPEC	"%li"
-#define MYSQLND_LLU_SPEC "%lu"
-#endif
-
-#if __powerpc__ && !__powerpc64__
-#define MYSQLND_LL_SPEC	"%lli"
 #define MYSQLND_LLU_SPEC "%llu"
-#endif
-
-#if __s390__ && !__s390x__
-#define MYSQLND_LL_SPEC	"%lli"
-#define MYSQLND_LLU_SPEC "%llu"
-#endif
-
-#define MYSQLND_SZ_T_SPEC "%zd"
+#define MYSQLND_LL_SPEC "%lld"
 #ifndef L64
 #define L64(x) x##LL
 #endif
 #endif
 
 
-#define int1store(T,A)	do { *((int8_t*) (T)) = (A); } while(0)
-#define uint1korr(A)	(*(((uint8_t*)(A))))
+typedef int64 longlong;
+typedef uint64 ulonglong;
+
+
+#define int1store(T,A)	do { *((zend_uchar*) (T)) = (A); } while(0)
+#define uint1korr(A)	(*(((uint8*)(A))))
 
 /* Bit values are sent in reverted order of bytes, compared to normal !!! */
-#define bit_uint2korr(A) ((uint16_t) (((uint16_t) (((zend_uchar*) (A))[1])) +\
-									((uint16_t) (((zend_uchar*) (A))[0]) << 8)))
-#define bit_uint3korr(A) ((uint32_t) (((uint32_t) (((zend_uchar*) (A))[2])) +\
-									(((uint32_t) (((zend_uchar*) (A))[1])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[0])) << 16)))
-
-#define bit_uint4korr(A) ((uint32_t) (((uint32_t) (((zend_uchar*) (A))[3])) +\
-									(((uint32_t) (((zend_uchar*) (A))[2])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[1])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[0])) << 24)))
-
-#define bit_uint5korr(A)  ((uint64_t)(((uint32_t) ((zend_uchar) (A)[4])) +\
-                                  (((uint32_t) ((zend_uchar) (A)[3])) << 8) +\
-                                  (((uint32_t) ((zend_uchar) (A)[2])) << 16) +\
-                                  (((uint32_t) ((zend_uchar) (A)[1])) << 24)) +\
-                               (((uint64_t) ((zend_uchar) (A)[0])) << 32))
-
-#define bit_uint6korr(A)	((uint64_t)(((uint32_t) (((zend_uchar*) (A))[5])) +\
-									(((uint32_t) (((zend_uchar*) (A))[4])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[3])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[2])) << 24)) +\
-									(((uint64_t) (((uint32_t) (((zend_uchar*) (A))[1])) +\
-									(((uint32_t) (((zend_uchar*) (A))[0]) << 8)))) << 32))
-
-#define bit_uint7korr(A)	((uint64_t)(((uint32_t) (((zend_uchar*) (A))[6])) +\
-									(((uint32_t) (((zend_uchar*) (A))[5])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[4])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[3])) << 24)) +\
-									(((uint64_t) (((uint32_t) (((zend_uchar*) (A))[2])) +\
-									(((uint32_t) (((zend_uchar*) (A))[1])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[0])) << 16))) << 32))
-
-
-#define bit_uint8korr(A) ((uint64_t)(((uint32_t) (((zend_uchar*) (A))[7])) +\
-									(((uint32_t) (((zend_uchar*) (A))[6])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[5])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[4])) << 24)) +\
-									(((uint64_t) (((uint32_t) (((zend_uchar*) (A))[3])) +\
-									(((uint32_t) (((zend_uchar*) (A))[2])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[1])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[0])) << 24))) << 32))
+#define bit_uint2korr(A) ((uint16) (((uint16) (((uchar*) (A))[1])) +\
+									((uint16) (((uchar*) (A))[0]) << 8)))
+#define bit_uint3korr(A) ((uint32) (((uint32) (((uchar*) (A))[2])) +\
+									(((uint32) (((uchar*) (A))[1])) << 8) +\
+									(((uint32) (((uchar*) (A))[0])) << 16)))
+
+#define bit_uint4korr(A) ((uint32) (((uint32) (((uchar*) (A))[3])) +\
+									(((uint32) (((uchar*) (A))[2])) << 8) +\
+									(((uint32) (((uchar*) (A))[1])) << 16) +\
+									(((uint32) (((uchar*) (A))[0])) << 24)))
+
+#define bit_uint5korr(A)  ((ulonglong)(((uint32) ((uchar) (A)[4])) +\
+                                  (((uint32) ((uchar) (A)[3])) << 8) +\
+                                  (((uint32) ((uchar) (A)[2])) << 16) +\
+                                  (((uint32) ((uchar) (A)[1])) << 24)) +\
+                               (((ulonglong) ((uchar) (A)[0])) << 32))
+
+#define bit_uint6korr(A)	((ulonglong)(((uint32) (((uchar*) (A))[5])) +\
+									(((uint32) (((uchar*) (A))[4])) << 8) +\
+									(((uint32) (((uchar*) (A))[3])) << 16) +\
+									(((uint32) (((uchar*) (A))[2])) << 24)) +\
+									(((ulonglong) (((uint32) (((uchar*) (A))[1])) +\
+									(((uint32) (((uchar*) (A))[0]) << 8)))) << 32))
+
+#define bit_uint7korr(A)	((ulonglong)(((uint32) (((uchar*) (A))[6])) +\
+									(((uint32) (((uchar*) (A))[5])) << 8) +\
+									(((uint32) (((uchar*) (A))[4])) << 16) +\
+									(((uint32) (((uchar*) (A))[3])) << 24)) +\
+									(((ulonglong) (((uint32) (((uchar*) (A))[2])) +\
+									(((uint32) (((uchar*) (A))[1])) << 8) +\
+									(((uint32) (((uchar*) (A))[0])) << 16))) << 32))
+
+
+#define bit_uint8korr(A) ((ulonglong)(((uint32) (((uchar*) (A))[7])) +\
+									(((uint32) (((uchar*) (A))[6])) << 8) +\
+									(((uint32) (((uchar*) (A))[5])) << 16) +\
+									(((uint32) (((uchar*) (A))[4])) << 24)) +\
+									(((ulonglong) (((uint32) (((uchar*) (A))[3])) +\
+									(((uint32) (((uchar*) (A))[2])) << 8) +\
+									(((uint32) (((uchar*) (A))[1])) << 16) +\
+									(((uint32) (((uchar*) (A))[0])) << 24))) << 32))
 
 
 /*
@@ -258,118 +233,120 @@ typedef unsigned long long uint64_t;
 **  (low byte first)
 */
 
-/* Optimized store functions for Intel x86, non-valid for WIN64. __i386__ is GCC */
+/* Optimized store functions for Intel x86, non-valid for WIN64 */
 #if defined(__i386__) && !defined(_WIN64)
-#define sint2korr(A)    (*((int16_t *) (A)))
-#define sint3korr(A)    ((int32_t) ((((zend_uchar) (A)[2]) & 128) ? \
-                   (((uint32_t) 255L << 24) | \
-                   (((uint32_t) (zend_uchar) (A)[2]) << 16) |\
-                   (((uint32_t) (zend_uchar) (A)[1]) << 8) | \
-                    ((uint32_t) (zend_uchar) (A)[0])) : \
-                   (((uint32_t) (zend_uchar) (A)[2]) << 16) |\
-                   (((uint32_t) (zend_uchar) (A)[1]) << 8) | \
-                    ((uint32_t) (zend_uchar) (A)[0])))
+#define sint2korr(A)    (*((int16 *) (A)))
+#define sint3korr(A)    ((int32) ((((uchar) (A)[2]) & 128) ? \
+                   (((uint32) 255L << 24) | \
+                   (((uint32) (uchar) (A)[2]) << 16) |\
+                   (((uint32) (uchar) (A)[1]) << 8) | \
+                    ((uint32) (uchar) (A)[0])) : \
+                   (((uint32) (uchar) (A)[2]) << 16) |\
+                   (((uint32) (uchar) (A)[1]) << 8) | \
+                    ((uint32) (uchar) (A)[0])))
 #define sint4korr(A)  (*((long *) (A)))
 
-#define uint2korr(A)  (*((uint16_t *) (A)))
-#define uint3korr(A)  (uint32_t) (((uint32_t) ((zend_uchar) (A)[0])) +\
-                               (((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
-                               (((uint32_t) ((zend_uchar) (A)[2])) << 16))
+#define uint2korr(A)  (*((uint16 *) (A)))
+#define uint3korr(A)  (uint32) (((uint32) ((uchar) (A)[0])) +\
+                               (((uint32) ((uchar) (A)[1])) << 8) +\
+                               (((uint32) ((uchar) (A)[2])) << 16))
 #define uint4korr(A)  (*((unsigned long *) (A)))
 
 
 
-#define uint8korr(A)    (*((uint64_t *) (A)))
-#define sint8korr(A)    (*((int64_t *) (A)))
-#define int2store(T,A)    *((uint16_t*) (T))= (uint16_t) (A)
+#define uint8korr(A)    (*((ulonglong *) (A)))
+#define sint8korr(A)    (*((longlong *) (A)))
+#define int2store(T,A)    *((uint16*) (T))= (uint16) (A)
 #define int3store(T,A)   { \
-                  *(T)=  (zend_uchar) ((A));\
-                  *(T+1)=(zend_uchar) (((uint32_t) (A) >> 8));\
-                  *(T+2)=(zend_uchar) (((A) >> 16)); }
+                  *(T)=  (uchar) ((A));\
+                  *(T+1)=(uchar) (((uint) (A) >> 8));\
+                  *(T+2)=(uchar) (((A) >> 16)); }
 #define int4store(T,A)    *((long *) (T))= (long) (A)
 #define int5store(T,A)    { \
-              *((zend_uchar *)(T))= (zend_uchar)((A));\
-              *(((zend_uchar *)(T))+1)=(zend_uchar) (((A) >> 8));\
-              *(((zend_uchar *)(T))+2)=(zend_uchar) (((A) >> 16));\
-              *(((zend_uchar *)(T))+3)=(zend_uchar) (((A) >> 24)); \
-              *(((zend_uchar *)(T))+4)=(zend_uchar) (((A) >> 32)); }
+              *((uchar *)(T))= (uchar)((A));\
+              *(((uchar *)(T))+1)=(uchar) (((A) >> 8));\
+              *(((uchar *)(T))+2)=(uchar) (((A) >> 16));\
+              *(((uchar *)(T))+3)=(uchar) (((A) >> 24)); \
+              *(((uchar *)(T))+4)=(uchar) (((A) >> 32)); }
 
 /* From Andrey Hristov, based on int5store() */
 #define int6store(T,A)    { \
-              *(((zend_uchar *)(T)))= (zend_uchar)((A));\
-              *(((zend_uchar *)(T))+1))=(zend_uchar) (((A) >> 8));\
-              *(((zend_uchar *)(T))+2))=(zend_uchar) (((A) >> 16));\
-              *(((zend_uchar *)(T))+3))=(zend_uchar) (((A) >> 24)); \
-              *(((zend_uchar *)(T))+4))=(zend_uchar) (((A) >> 32)); \
-              *(((zend_uchar *)(T))+5))=(zend_uchar) (((A) >> 40)); }
+              *(((uchar *)(T)))= (uchar)((A));\
+              *(((uchar *)(T))+1))=(uchar) (((A) >> 8));\
+              *(((uchar *)(T))+2))=(uchar) (((A) >> 16));\
+              *(((uchar *)(T))+3))=(uchar) (((A) >> 24)); \
+              *(((uchar *)(T))+4))=(uchar) (((A) >> 32)); \
+              *(((uchar *)(T))+5))=(uchar) (((A) >> 40)); }
 
-#define int8store(T,A)    *((uint64_t *) (T))= (uint64_t) (A)
+#define int8store(T,A)    *((ulonglong *) (T))= (ulonglong) (A)
 
 typedef union {
   double v;
   long m[2];
-} float8get_union;
-#define float8get(V,M)    { ((float8get_union *)&(V))->m[0] = *((long*) (M)); \
-                            ((float8get_union *)&(V))->m[1] = *(((long*) (M))+1); }
-#define float8store(T,V) { *((long *) (T))     = ((float8get_union *)&(V))->m[0]; \
-                           *(((long *) (T))+1) = ((float8get_union *)&(V))->m[1]; }
+} doubleget_union;
+#define doubleget(V,M)    { ((doubleget_union *)&(V))->m[0] = *((long*) (M)); \
+                            ((doubleget_union *)&(V))->m[1] = *(((long*) (M))+1); }
+#define doublestore(T,V) { *((long *) (T))     = ((doubleget_union *)&(V))->m[0]; \
+                           *(((long *) (T))+1) = ((doubleget_union *)&(V))->m[1]; }
 #define float4get(V,M)	{ *((float *) &(V)) = *((float*) (M)); }
-/* From Andrey Hristov based on float8get */
+#define float8get(V,M)	doubleget((V),(M))
+/* From Andrey Hristov based on doubleget */
 #define floatget(V,M)    memcpy((char*) &(V),(char*) (M),sizeof(float))
+#define floatstore       float4store
+#define float4store(V,M) memcpy((char*) (V),(char*) (&M),sizeof(float))
+#define float8store(V,M) doublestore((V),(M))
 #endif /* __i386__ */ 
 
-
-/* If we haven't defined sint2korr, which is because the platform is not x86 or it's WIN64 */
 #ifndef sint2korr
-#define sint2korr(A)    (int16_t) (((int16_t) ((zend_uchar) (A)[0])) +\
-                                 ((int16_t) ((int16_t) (A)[1]) << 8))
-#define sint3korr(A)    ((int32_t) ((((zend_uchar) (A)[2]) & 128) ? \
-                  (((uint32_t) 255L << 24) | \
-                  (((uint32_t) (zend_uchar) (A)[2]) << 16) |\
-                  (((uint32_t) (zend_uchar) (A)[1]) << 8) | \
-                   ((uint32_t) (zend_uchar) (A)[0])) : \
-                  (((uint32_t) (zend_uchar) (A)[2]) << 16) |\
-                  (((uint32_t) (zend_uchar) (A)[1]) << 8) | \
-                  ((uint32_t) (zend_uchar) (A)[0])))
-#define sint4korr(A)  (int32_t) (((int32_t) ((zend_uchar) (A)[0])) +\
-                              (((int32_t) ((zend_uchar) (A)[1]) << 8)) +\
-                              (((int32_t) ((zend_uchar) (A)[2]) << 16)) +\
-                              (((int32_t) ((int16_t) (A)[3]) << 24)))
-
-#define sint8korr(A)  (int64_t) uint8korr(A)
-#define uint2korr(A)  (uint16_t) (((uint16_t) ((zend_uchar) (A)[0])) +\
-                               ((uint16_t) ((zend_uchar) (A)[1]) << 8))
-#define uint3korr(A)  (uint32_t) (((uint32_t) ((zend_uchar) (A)[0])) +\
-                               (((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
-                               (((uint32_t) ((zend_uchar) (A)[2])) << 16))
-#define uint4korr(A)  (uint32_t) (((uint32_t) ((zend_uchar) (A)[0])) +\
-                               (((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
-                               (((uint32_t) ((zend_uchar) (A)[2])) << 16) +\
-                               (((uint32_t) ((zend_uchar) (A)[3])) << 24))
-
-
-#define bit_uint8korr(A) ((uint64_t)(((uint32_t) (((zend_uchar*) (A))[7])) +\
-									(((uint32_t) (((zend_uchar*) (A))[6])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[5])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[4])) << 24)) +\
-									(((uint64_t) (((uint32_t) (((zend_uchar*) (A))[3])) +\
-									(((uint32_t) (((zend_uchar*) (A))[2])) << 8) +\
-									(((uint32_t) (((zend_uchar*) (A))[1])) << 16) +\
-									(((uint32_t) (((zend_uchar*) (A))[0])) << 24))) << 32))
-
-#define uint8korr(A)	((uint64_t)(((uint32_t) ((zend_uchar) (A)[0])) +\
-									(((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
-									(((uint32_t) ((zend_uchar) (A)[2])) << 16) +\
-									(((uint32_t) ((zend_uchar) (A)[3])) << 24)) +\
-									(((uint64_t) (((uint32_t) ((zend_uchar) (A)[4])) +\
-									(((uint32_t) ((zend_uchar) (A)[5])) << 8) +\
-									(((uint32_t) ((zend_uchar) (A)[6])) << 16) +\
-									(((uint32_t) ((zend_uchar) (A)[7])) << 24))) << 32))
-
-
-#define int2store(T,A)  do { uint32_t def_temp= (uint32_t) (A) ;\
-                  *((zend_uchar*) (T))  =  (zend_uchar)(def_temp); \
-                  *((zend_uchar*) (T+1)) = (zend_uchar)((def_temp >> 8)); } while (0)
+#define sint2korr(A)    (int16) (((int16) ((uchar) (A)[0])) +\
+                                 ((int16) ((int16) (A)[1]) << 8))
+#define sint3korr(A)    ((int32) ((((uchar) (A)[2]) & 128) ? \
+                  (((uint32) 255L << 24) | \
+                  (((uint32) (uchar) (A)[2]) << 16) |\
+                  (((uint32) (uchar) (A)[1]) << 8) | \
+                   ((uint32) (uchar) (A)[0])) : \
+                  (((uint32) (uchar) (A)[2]) << 16) |\
+                  (((uint32) (uchar) (A)[1]) << 8) | \
+                  ((uint32) (uchar) (A)[0])))
+#define sint4korr(A)  (int32) (((int32) ((uchar) (A)[0])) +\
+                              (((int32) ((uchar) (A)[1]) << 8)) +\
+                              (((int32) ((uchar) (A)[2]) << 16)) +\
+                              (((int32) ((int16) (A)[3]) << 24)))
+
+#define sint8korr(A)  (longlong) uint8korr(A)
+#define uint2korr(A)  (uint16) (((uint16) ((uchar) (A)[0])) +\
+                               ((uint16) ((uchar) (A)[1]) << 8))
+#define uint3korr(A)  (uint32) (((uint32) ((uchar) (A)[0])) +\
+                               (((uint32) ((uchar) (A)[1])) << 8) +\
+                               (((uint32) ((uchar) (A)[2])) << 16))
+#define uint4korr(A)  (uint32) (((uint32) ((uchar) (A)[0])) +\
+                               (((uint32) ((uchar) (A)[1])) << 8) +\
+                               (((uint32) ((uchar) (A)[2])) << 16) +\
+                               (((uint32) ((uchar) (A)[3])) << 24))
+
+
+#define bit_uint8korr(A) ((ulonglong)(((uint32) (((uchar*) (A))[7])) +\
+									(((uint32) (((uchar*) (A))[6])) << 8) +\
+									(((uint32) (((uchar*) (A))[5])) << 16) +\
+									(((uint32) (((uchar*) (A))[4])) << 24)) +\
+									(((ulonglong) (((uint32) (((uchar*) (A))[3])) +\
+									(((uint32) (((uchar*) (A))[2])) << 8) +\
+									(((uint32) (((uchar*) (A))[1])) << 16) +\
+									(((uint32) (((uchar*) (A))[0])) << 24))) << 32))
+
+#define uint8korr(A)	((ulonglong)(((uint32) ((uchar) (A)[0])) +\
+									(((uint32) ((uchar) (A)[1])) << 8) +\
+									(((uint32) ((uchar) (A)[2])) << 16) +\
+									(((uint32) ((uchar) (A)[3])) << 24)) +\
+									(((ulonglong) (((uint32) ((uchar) (A)[4])) +\
+									(((uint32) ((uchar) (A)[5])) << 8) +\
+									(((uint32) ((uchar) (A)[6])) << 16) +\
+									(((uint32) ((uchar) (A)[7])) << 24))) << 32))
+
+
+#define int2store(T,A)  do { uint def_temp= (uint) (A) ;\
+                  *((uchar*) (T))  =  (uchar)(def_temp); \
+                  *((uchar*) (T+1)) = (uchar)((def_temp >> 8)); } while (0)
 #define int3store(T,A)  do { /*lint -save -e734 */\
                   *(((char *)(T)))   = (char) ((A));\
                   *(((char *)(T))+1) = (char) (((A) >> 8));\
@@ -394,11 +371,17 @@ typedef union {
                   *(((char *)(T))+3) = (char)(((A) >> 24)); \
                   *(((char *)(T))+4) = (char)(((A) >> 32)); \
                   *(((char *)(T))+5) = (char)(((A) >> 40)); } while (0)
-#define int8store(T,A)        { uint32_t def_temp= (uint32_t) (A), def_temp2= (uint32_t) ((A) >> 32); \
+#define int8store(T,A)        { uint def_temp= (uint) (A), def_temp2= (uint) ((A) >> 32); \
                   int4store((T),def_temp); \
                   int4store((T+4),def_temp2); \
                 }
 #ifdef WORDS_BIGENDIAN
+#define float4store(T,A) do { \
+                          *(((char *)(T)))   = (char) ((char *) &A)[3];\
+                          *(((char *)(T))+1) = (char) ((char *) &A)[2];\
+                          *(((char *)(T))+2) = (char) ((char *) &A)[1];\
+                          *(((char *)(T))+3) = (char) ((char *) &A)[0]; } while (0)
+
 #define float4get(V,M)   do { float def_temp;\
                           ((char*) &def_temp)[0] = (M)[3];\
                           ((char*) &def_temp)[1] = (M)[2];\
@@ -428,9 +411,10 @@ typedef union {
                          } while (0)
 #else
 #define float4get(V,M)   memcpy((char*) &(V),(char*) (M),sizeof(float))
+#define float4store(V,M) memcpy((char*) (V),(char*) (&M),sizeof(float))
 
 #if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN)
-#define float8store(T,V)  do { \
+#define doublestore(T,V)  do { \
                          *(((char *)(T)))= ((char *) &(V))[4];\
                          *(((char *)(T))+1)=(char) ((char *) &(V))[5];\
                          *(((char *)(T))+2)=(char) ((char *) &(V))[6];\
@@ -439,7 +423,7 @@ typedef union {
                          *(((char *)(T))+5)=(char) ((char *) &(V))[1];\
                          *(((char *)(T))+6)=(char) ((char *) &(V))[2];\
                          *(((char *)(T))+7)=(char) ((char *) &(V))[3];} while (0)
-#define float8get(V,M) do { double def_temp;\
+#define doubleget(V,M) do { double def_temp;\
                          ((char*) &def_temp)[0]=(M)[4];\
                          ((char*) &def_temp)[1]=(M)[5];\
                          ((char*) &def_temp)[2]=(M)[6];\
@@ -451,11 +435,11 @@ typedef union {
                          (V) = def_temp; } while (0)
 #endif /* __FLOAT_WORD_ORDER */
 
+#define float8get(V,M)   doubleget((V),(M))
+#define float8store(V,M) doublestore((V),(M))
 #endif /* WORDS_BIGENDIAN */
 
 #endif /* sint2korr */
-/* To here if the platform is not x86 or it's WIN64 */
-
 
 /* Define-funktions for reading and storing in machine format from/to
    short/long to/from some place in memory V should be a (not
@@ -463,15 +447,51 @@ typedef union {
 
 #ifdef WORDS_BIGENDIAN
 
-#define float8get(V,M)		memcpy((char*) &(V),(char*)  (M), sizeof(double))
-#define float8store(T,V)	memcpy((char*)  (T),(char*) &(V), sizeof(double))
+#define ushortget(V,M)  { V = (uint16) (((uint16) ((uchar) (M)[1]))+\
+                                        ((uint16) ((uint16) (M)[0]) << 8)); }
+#define shortget(V,M)   { V = (short) (((short) ((uchar) (M)[1]))+\
+                                       ((short) ((short) (M)[0]) << 8)); }
+#define longget(V,M)    do { int32 def_temp;\
+              ((char*) &def_temp)[0]=(M)[0];\
+              ((char*) &def_temp)[1]=(M)[1];\
+              ((char*) &def_temp)[2]=(M)[2];\
+              ((char*) &def_temp)[3]=(M)[3];\
+              (V)=def_temp; } while (0)
+#define ulongget(V,M)    do { uint32 def_temp;\
+              ((char*) &def_temp)[0]=(M)[0];\
+              ((char*) &def_temp)[1]=(M)[1];\
+              ((char*) &def_temp)[2]=(M)[2];\
+              ((char*) &def_temp)[3]=(M)[3];\
+              (V)=def_temp; }  while (0)
+#define shortstore(T,A) do { \
+              uint def_temp=(uint) (A) ;\
+              *(((char *)(T))+1)=(char)(def_temp); \
+              *(((char *)(T))+0)=(char)(def_temp >> 8); } while (0)
+#define longstore(T,A)  do { \
+              *(((char *)(T))+3)=(char)((A));\
+              *(((char *)(T))+2)=(char)(((A) >> 8));\
+              *(((char *)(T))+1)=(char)(((A) >> 16));\
+              *(((char *)(T))+0)=(char)(((A) >> 24)); }  while (0)
+
+#define doubleget(V,M)		memcpy((char*) &(V),(char*)  (M), sizeof(double))
+#define doublestore(T,V)	memcpy((char*)  (T),(char*) &(V), sizeof(double))
+#define longlongget(V,M)	memcpy((char*) &(V),(char*)  (M), sizeof(ulonglong))
+#define longlongstore(T,V)	memcpy((char*)  (T),(char*) &(V), sizeof(ulonglong))
 
 #else
 
-#ifndef float8get
-#define float8get(V,M)    memcpy((char*) &(V),(char*) (M),sizeof(double))
-#define float8store(T,V)  memcpy((char*) (T),(char*) &(V),sizeof(double))
-#endif /* float8get */
+#define ushortget(V,M)  { V = uint2korr((M)); }
+#define shortget(V,M)   { V = sint2korr((M)); }
+#define longget(V,M)    { V = sint4korr((M)); }
+#define ulongget(V,M)   { V = uint4korr((M)); }
+#define shortstore(T,V)   int2store((T),(V))
+#define longstore(T,V)    int4store((T),(V))
+#ifndef doubleget
+#define doubleget(V,M)    memcpy((char*) &(V),(char*) (M),sizeof(double))
+#define doublestore(T,V)  memcpy((char*) (T),(char*) &(V),sizeof(double))
+#endif /* doubleget */
+#define longlongget(V,M)   memcpy((char*) &(V),(char*) (M),sizeof(ulonglong))
+#define longlongstore(T,V) memcpy((char*) (T),(char*) &(V),sizeof(ulonglong))
 
 #endif /* WORDS_BIGENDIAN */
 
diff --git a/ext/mysqlnd/mysqlnd_priv.h b/ext/mysqlnd/mysqlnd_priv.h
index 8059441a77..0a666cd314 100644
--- a/ext/mysqlnd/mysqlnd_priv.h
+++ b/ext/mysqlnd/mysqlnd_priv.h
@@ -98,7 +98,7 @@
 #define MAX_CHARSET_LEN			32
 
 
-#define SET_ERROR_AFF_ROWS(s)	(s)->upsert_status.affected_rows = (uint64_t) ~0
+#define SET_ERROR_AFF_ROWS(s)	(s)->upsert_status.affected_rows = (uint64) ~0
 
 /* Error handling */
 #define SET_NEW_MESSAGE(buf, buf_len, message, len, persistent) \
@@ -150,7 +150,7 @@
 
 /* PS stuff */
 typedef void (*ps_field_fetch_func)(zval *zv, const MYSQLND_FIELD * const field,
-									unsigned int pack_len, zend_uchar **row,
+									uint pack_len, zend_uchar **row,
 									zend_bool everything_as_unicode TSRMLS_DC);
 struct st_mysqlnd_perm_bind {
 	ps_field_fetch_func func;
@@ -173,7 +173,7 @@ enum_func_status mysqlnd_handle_local_infile(MYSQLND *conn, const char *filename
 void _mysqlnd_init_ps_subsystem();/* This one is private, mysqlnd_library_init() will call it */
 
 void ps_fetch_from_1_to_8_bytes(zval *zv, const MYSQLND_FIELD * const field,
-								unsigned int pack_len, zend_uchar **row, zend_bool as_unicode,
+								uint pack_len, zend_uchar **row, zend_bool as_unicode,
 								unsigned int byte_count TSRMLS_DC);
 
 
diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c
index 78cdd8e74c..05bc1ac997 100644
--- a/ext/mysqlnd/mysqlnd_ps.c
+++ b/ext/mysqlnd/mysqlnd_ps.c
@@ -39,8 +39,7 @@ const char * const mysqlnd_stmt_not_prepared = "Statement not prepared";
 enum_func_status mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command,
 										const char * const arg, size_t arg_len,
 										enum php_mysql_packet_type ok_packet,
-										zend_bool silent, zend_bool ignore_upsert_status
-										TSRMLS_DC);
+										zend_bool silent TSRMLS_DC);
 
 /* Exported by mysqlnd_ps_codec.c */
 zend_uchar* mysqlnd_stmt_execute_generate_request(MYSQLND_STMT *stmt, size_t *request_len,
@@ -58,7 +57,7 @@ enum_func_status mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param,
 											   zend_bool *fetched_anything TSRMLS_DC);
 
 static void mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const stmt TSRMLS_DC);
-static void mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC);
+static void mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const stmt, uint param_no TSRMLS_DC);
 
 static void mysqlnd_internal_free_stmt_content(MYSQLND_STMT * const stmt TSRMLS_DC);
 static enum_func_status mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const stmt TSRMLS_DC);
@@ -421,7 +420,7 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * co
 	}
 
 	if (FAIL == mysqlnd_simple_command(stmt_to_prepare->conn, COM_STMT_PREPARE, query,
-									   query_len, PROT_LAST, FALSE, TRUE TSRMLS_CC) ||
+									   query_len, PROT_LAST, FALSE TSRMLS_CC) ||
 		FAIL == mysqlnd_stmt_read_prepare_response(stmt_to_prepare TSRMLS_CC)) {
 		goto fail;
 	}
@@ -653,7 +652,7 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
 	}
 
 	if (stmt->param_count) {
-		unsigned int i, not_bound = 0;
+		uint i, not_bound = 0;
 		if (!stmt->param_bind) {
 			SET_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, UNKNOWN_SQLSTATE,
 							 "No data supplied for parameters in prepared statement");
@@ -683,7 +682,7 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 	ret = mysqlnd_simple_command(stmt->conn, COM_STMT_EXECUTE, (char *)request, request_len,
 								 PROT_LAST /* we will handle the response packet*/,
-								 FALSE, FALSE TSRMLS_CC);
+								 FALSE TSRMLS_CC);
 
 	if (free_request) {
 		mnd_efree(request);
@@ -708,7 +707,7 @@ mysqlnd_fetch_stmt_row_buffered(MYSQLND_RES *result, void *param, unsigned int f
 {
 	MYSQLND_STMT *stmt = (MYSQLND_STMT *) param;
 	MYSQLND_RES_BUFFERED *set = result->stored_data;
-	unsigned int field_count = result->meta->field_count;
+	uint field_count = result->meta->field_count;
 
 	DBG_ENTER("mysqlnd_fetch_stmt_row_buffered");
 	DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
@@ -724,7 +723,7 @@ mysqlnd_fetch_stmt_row_buffered(MYSQLND_RES *result, void *param, unsigned int f
 			zval **current_row = set->data_cursor;
 
 			if (NULL == current_row[0]) {
-				uint64_t row_num = (set->data_cursor - set->data) / field_count;
+				uint64 row_num = (set->data_cursor - set->data) / field_count;
 				set->initialized_rows++;
 				result->m.row_decoder(set->row_buffers[row_num],
 									  current_row,
@@ -866,7 +865,7 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES *result, void *param, unsigned int
 							|| Z_TYPE_P(data) == IS_UNICODE
 #endif
 							)
-							 && (result->meta->fields[i].max_length < (unsigned long) Z_STRLEN_P(data)))
+							 && (result->meta->fields[i].max_length < Z_STRLEN_P(data)))
 						{
 							result->meta->fields[i].max_length = Z_STRLEN_P(data);
 						}
@@ -967,14 +966,13 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int fla
 	php_mysql_packet_row *row_packet = result->row_packet;
 
 	DBG_ENTER("mysqlnd_fetch_stmt_row_cursor");
+	DBG_INF_FMT("stmt=%lu flags=%u", stmt->stmt_id, flags);
 
 	if (!stmt) {
 		DBG_ERR("no statement");
 		DBG_RETURN(FAIL);
 	}
 
-	DBG_INF_FMT("stmt=%lu flags=%u", stmt->stmt_id, flags);
-
 	if (stmt->state < MYSQLND_STMT_USER_FETCHING) {
 		/* Only initted - error */
 		SET_CLIENT_ERROR(stmt->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE,
@@ -991,7 +989,7 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int fla
 
 	if (FAIL == mysqlnd_simple_command(stmt->conn, COM_STMT_FETCH, (char *)buf, sizeof(buf),
 									   PROT_LAST /* we will handle the response packet*/,
-									   FALSE, TRUE TSRMLS_CC)) {
+									   FALSE TSRMLS_CC)) {
 		stmt->error_info = stmt->conn->error_info;
 		DBG_RETURN(FAIL);
 	}
@@ -1034,7 +1032,7 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int fla
 							|| Z_TYPE_P(data) == IS_UNICODE
 #endif
 							)
-							 && (result->meta->fields[i].max_length < (unsigned long) Z_STRLEN_P(data)))
+							 && (result->meta->fields[i].max_length < Z_STRLEN_P(data)))
 						{
 							result->meta->fields[i].max_length = Z_STRLEN_P(data);
 						}
@@ -1183,7 +1181,7 @@ MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const stmt TSRMLS_DC)
 		if (CONN_GET_STATE(conn) == CONN_READY &&
 			FAIL == (ret = mysqlnd_simple_command(conn, COM_STMT_RESET, (char *)cmd_buf,
 												  sizeof(cmd_buf), PROT_OK_PACKET,
-												  FALSE, TRUE TSRMLS_CC))) {
+												  FALSE TSRMLS_CC))) {
 			stmt->error_info = conn->error_info;
 		}
 		stmt->upsert_status = conn->upsert_status;
@@ -1255,7 +1253,7 @@ MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const stmt, unsigned
 
 		/* COM_STMT_SEND_LONG_DATA doesn't send an OK packet*/
 		ret = mysqlnd_simple_command(conn, cmd, (char *)cmd_buf, packet_len,
-									 PROT_LAST , FALSE, TRUE TSRMLS_CC);
+									 PROT_LAST , FALSE TSRMLS_CC);
 		mnd_efree(cmd_buf);
 		if (FAIL == ret) {
 			stmt->error_info = conn->error_info;
@@ -1284,7 +1282,7 @@ MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const stmt, unsigned
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "There was an error "
 							 "while sending long data. Probably max_allowed_packet_size "
 							 "is smaller than the data. You have to increase it or send "
-							 "smaller chunks of data. Answer was "MYSQLND_SZ_T_SPEC" bytes long.", packet_len);
+							 "smaller chunks of data. Answer was %u bytes long.", packet_len);
 			SET_STMT_ERROR(stmt, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE,
 							"Server responded to COM_STMT_SEND_LONG_DATA.");
 			ret = FAIL;
@@ -1477,7 +1475,7 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const stmt,
 	SET_EMPTY_ERROR(stmt->conn->error_info);
 
 	if (stmt->field_count) {
-		unsigned int i = 0;
+		uint i = 0;
 
 		if (!result_bind) {
 			DBG_ERR("no result bind passed");
@@ -1508,7 +1506,7 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const stmt,
 
 /* {{{ mysqlnd_stmt::bind_result */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, bind_one_result)(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, bind_one_result)(MYSQLND_STMT * const stmt, uint param_no TSRMLS_DC)
 {
 	DBG_ENTER("mysqlnd_stmt::bind_result");
 	DBG_INF_FMT("stmt=%lu field_count=%u", stmt->stmt_id, stmt->field_count);
@@ -1564,7 +1562,7 @@ MYSQLND_METHOD(mysqlnd_stmt, set_result_bind_dtor)(MYSQLND_STMT * const stmt,
 
 
 /* {{{ mysqlnd_stmt::insert_id */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_stmt, insert_id)(const MYSQLND_STMT * const stmt)
 {
 	return stmt->upsert_status.last_insert_id;
@@ -1573,7 +1571,7 @@ MYSQLND_METHOD(mysqlnd_stmt, insert_id)(const MYSQLND_STMT * const stmt)
 
 
 /* {{{ mysqlnd_stmt::affected_rows */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_stmt, affected_rows)(const MYSQLND_STMT * const stmt)
 {
 	return stmt->upsert_status.affected_rows;
@@ -1582,7 +1580,7 @@ MYSQLND_METHOD(mysqlnd_stmt, affected_rows)(const MYSQLND_STMT * const stmt)
 
 
 /* {{{ mysqlnd_stmt::num_rows */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_stmt, num_rows)(const MYSQLND_STMT * const stmt)
 {
 	return stmt->result? mysqlnd_num_rows(stmt->result):0;
@@ -1646,7 +1644,7 @@ MYSQLND_METHOD(mysqlnd_stmt, sqlstate)(const MYSQLND_STMT * const stmt)
 
 /* {{{ mysqlnd_stmt::data_seek */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, data_seek)(const MYSQLND_STMT * const stmt, uint64_t row TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, data_seek)(const MYSQLND_STMT * const stmt, uint64 row TSRMLS_DC)
 {
 	return stmt->result? stmt->result->m.seek_data(stmt->result, row TSRMLS_CC) : FAIL;
 }
@@ -1887,7 +1885,7 @@ void mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 
 /* {{{ mysqlnd_stmt_separate_one_result_bind */
-void mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC)
+void mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const stmt, uint param_no TSRMLS_DC)
 {
 	DBG_ENTER("mysqlnd_stmt_separate_one_result_bind");
 	DBG_INF_FMT("stmt=%lu result_bind=%p field_count=%u param_no=%d",
@@ -2011,7 +2009,7 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const stmt, zend_
 			DBG_INF("skipping result");
 			stmt->result->m.skip_result(stmt->result TSRMLS_CC);
 		}
-	} while (mysqlnd_stmt_more_results(stmt) && mysqlnd_stmt_next_result(stmt) == PASS);
+	} while (mysqlnd_stmt_more_results(stmt) && mysqlnd_stmt_next_result(stmt));
 	/*
 	  After this point we are allowed to free the result set,
 	  as we have cleaned the line
@@ -2024,7 +2022,7 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const stmt, zend_
 		if (CONN_GET_STATE(conn) == CONN_READY &&
 			FAIL == mysqlnd_simple_command(conn, COM_STMT_CLOSE, (char *)cmd_buf, sizeof(cmd_buf),
 										   PROT_LAST /* COM_STMT_CLOSE doesn't send an OK packet*/,
-										   FALSE, TRUE TSRMLS_CC)) {
+										   FALSE TSRMLS_CC)) {
 			stmt->error_info = conn->error_info;
 			DBG_RETURN(FAIL);
 		}
diff --git a/ext/mysqlnd/mysqlnd_ps_codec.c b/ext/mysqlnd/mysqlnd_ps_codec.c
index 2f80714e66..2b37987306 100644
--- a/ext/mysqlnd/mysqlnd_ps_codec.c
+++ b/ext/mysqlnd/mysqlnd_ps_codec.c
@@ -28,6 +28,17 @@
 #define MYSQLND_SILENT
 
 
+
+typedef int8  my_int8;
+typedef uint8  my_uint8;
+
+typedef int16 my_int16;
+typedef uint16 my_uint16;
+
+typedef int32   my_int32;
+typedef uint32 my_uint32;
+
+
 enum mysqlnd_timestamp_type
 {
   MYSQLND_TIMESTAMP_NONE= -2,
@@ -47,6 +58,7 @@ struct st_mysqlnd_time
 };
 
 
+
 struct st_mysqlnd_perm_bind mysqlnd_ps_fetch_functions[MYSQL_TYPE_LAST + 1];
 
 #define MYSQLND_PS_SKIP_RESULT_W_LEN	-1
@@ -54,7 +66,7 @@ struct st_mysqlnd_perm_bind mysqlnd_ps_fetch_functions[MYSQL_TYPE_LAST + 1];
 
 /* {{{ ps_fetch_from_1_to_8_bytes */
 void ps_fetch_from_1_to_8_bytes(zval *zv, const MYSQLND_FIELD * const field,
-								unsigned int pack_len, zend_uchar **row, zend_bool as_unicode,
+								uint pack_len, zend_uchar **row, zend_bool as_unicode,
 								unsigned int byte_count TSRMLS_DC)
 {
 	char tmp[22];
@@ -63,17 +75,17 @@ void ps_fetch_from_1_to_8_bytes(zval *zv, const MYSQLND_FIELD * const field,
 	DBG_ENTER("ps_fetch_from_1_to_8_bytes");
 	DBG_INF_FMT("zv=%p byte_count=%d", zv, byte_count);
 	if (field->flags & UNSIGNED_FLAG) {
-		uint64_t uval = 0;
+		uint64 uval = 0;
 
 		switch (byte_count) {
-			case 8:uval = is_bit? (uint64_t) bit_uint8korr(*row):(uint64_t) uint8korr(*row);break;
+			case 8:uval = is_bit? (uint64) bit_uint8korr(*row):(uint64) uint8korr(*row);break;
 			case 7:uval = bit_uint7korr(*row);break;
 			case 6:uval = bit_uint6korr(*row);break;
 			case 5:uval = bit_uint5korr(*row);break;
-			case 4:uval = is_bit? (uint64_t) bit_uint4korr(*row):(uint64_t) uint4korr(*row);break;
-			case 3:uval = is_bit? (uint64_t) bit_uint3korr(*row):(uint64_t) uint3korr(*row);break;
-			case 2:uval = is_bit? (uint64_t) bit_uint2korr(*row):(uint64_t) uint2korr(*row);break;
-			case 1:uval = (uint64_t) uint1korr(*row);break;
+			case 4:uval = is_bit? (uint64) bit_uint4korr(*row):(uint64) uint4korr(*row);break;
+			case 3:uval = is_bit? (uint64) bit_uint3korr(*row):(uint64) uint3korr(*row);break;
+			case 2:uval = is_bit? (uint64) bit_uint2korr(*row):(uint64) uint2korr(*row);break;
+			case 1:uval = (uint64) uint1korr(*row);break;
 		}
 
 #if SIZEOF_LONG==4
@@ -92,21 +104,21 @@ void ps_fetch_from_1_to_8_bytes(zval *zv, const MYSQLND_FIELD * const field,
 		}
 	} else {
 		/* SIGNED */
-		int64_t lval = 0;
+		int64 lval = 0;
 		switch (byte_count) {
-			case 8:lval = (int64_t) sint8korr(*row);break;
+			case 8:lval = (int64) sint8korr(*row);break;
 			/*
 			  7, 6 and 5 are not possible.
 			  BIT is only unsigned, thus only uint5|6|7 macroses exist
 			*/
-			case 4:lval = (int64_t) sint4korr(*row);break;
-			case 3:lval = (int64_t) sint3korr(*row);break;
-			case 2:lval = (int64_t) sint2korr(*row);break;
-			case 1:lval = (int64_t) *(int8_t*)*row;break;
+			case 4:lval = (int64) sint4korr(*row);break;
+			case 3:lval = (int64) sint3korr(*row);break;
+			case 2:lval = (int64) sint2korr(*row);break;
+			case 1:lval = (int64) *(my_int8*)*row;break;
 		}
 
 #if SIZEOF_LONG==4
-	    if ((L64(2147483647) < (int64_t) lval) || (L64(-2147483648) > (int64_t) lval)) {
+	    if ((L64(2147483647) < (int64) lval) || (L64(-2147483648) > (int64) lval)) {
 			DBG_INF("stringify");
 			tmp_len = sprintf((char *)&tmp, MYSQLND_LL_SPEC, lval);
 		} else 
@@ -137,7 +149,7 @@ void ps_fetch_from_1_to_8_bytes(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_null */
 static
 void ps_fetch_null(zval *zv, const MYSQLND_FIELD * const field,
-				   unsigned int pack_len, zend_uchar **row,
+				   uint pack_len, zend_uchar **row,
 				   zend_bool as_unicode TSRMLS_DC)
 {
 	ZVAL_NULL(zv);
@@ -148,7 +160,7 @@ void ps_fetch_null(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_int8 */
 static
 void ps_fetch_int8(zval *zv, const MYSQLND_FIELD * const field,
-				   unsigned int pack_len, zend_uchar **row,
+				   uint pack_len, zend_uchar **row,
 				   zend_bool as_unicode TSRMLS_DC)
 {
 	ps_fetch_from_1_to_8_bytes(zv, field, pack_len, row, as_unicode, 1 TSRMLS_CC);
@@ -159,7 +171,7 @@ void ps_fetch_int8(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_int16 */
 static
 void ps_fetch_int16(zval *zv, const MYSQLND_FIELD * const field,
-					unsigned int pack_len, zend_uchar **row,
+					uint pack_len, zend_uchar **row,
 					zend_bool as_unicode TSRMLS_DC)
 {
 	ps_fetch_from_1_to_8_bytes(zv, field, pack_len, row, as_unicode, 2 TSRMLS_CC);
@@ -170,7 +182,7 @@ void ps_fetch_int16(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_int32 */
 static
 void ps_fetch_int32(zval *zv, const MYSQLND_FIELD * const field,
-					unsigned int pack_len, zend_uchar **row,
+					uint pack_len, zend_uchar **row,
 					zend_bool as_unicode TSRMLS_DC)
 {
 	ps_fetch_from_1_to_8_bytes(zv, field, pack_len, row, as_unicode, 4 TSRMLS_CC);
@@ -181,7 +193,7 @@ void ps_fetch_int32(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_int64 */
 static
 void ps_fetch_int64(zval *zv, const MYSQLND_FIELD * const field,
-					unsigned int pack_len, zend_uchar **row,
+					uint pack_len, zend_uchar **row,
 					zend_bool as_unicode TSRMLS_DC)
 {
 	ps_fetch_from_1_to_8_bytes(zv, field, pack_len, row, as_unicode, 8 TSRMLS_CC);
@@ -192,7 +204,7 @@ void ps_fetch_int64(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_float */
 static
 void ps_fetch_float(zval *zv, const MYSQLND_FIELD * const field,
-					unsigned int pack_len, zend_uchar **row,
+					uint pack_len, zend_uchar **row,
 					zend_bool as_unicode TSRMLS_DC)
 {
 	float value;
@@ -209,7 +221,7 @@ void ps_fetch_float(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_double */
 static
 void ps_fetch_double(zval *zv, const MYSQLND_FIELD * const field,
-					unsigned int pack_len, zend_uchar **row,
+					uint pack_len, zend_uchar **row,
 					zend_bool as_unicode TSRMLS_DC)
 {
 	double value;
@@ -226,7 +238,7 @@ void ps_fetch_double(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_time */
 static
 void ps_fetch_time(zval *zv, const MYSQLND_FIELD * const field,
-				   unsigned int pack_len, zend_uchar **row,
+				   uint pack_len, zend_uchar **row,
 				   zend_bool as_unicode TSRMLS_DC)
 {
 	struct st_mysqlnd_time t;
@@ -284,7 +296,7 @@ void ps_fetch_time(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_date */
 static
 void ps_fetch_date(zval *zv, const MYSQLND_FIELD * const field,
-				   unsigned int pack_len, zend_uchar **row,
+				   uint pack_len, zend_uchar **row,
 				   zend_bool as_unicode TSRMLS_DC)
 {
 	struct st_mysqlnd_time t = {0};
@@ -335,7 +347,7 @@ void ps_fetch_date(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_datetime */
 static
 void ps_fetch_datetime(zval *zv, const MYSQLND_FIELD * const field,
-					   unsigned int pack_len, zend_uchar **row,
+					   uint pack_len, zend_uchar **row,
 					   zend_bool as_unicode TSRMLS_DC)
 {
 	struct st_mysqlnd_time t;
@@ -394,7 +406,7 @@ void ps_fetch_datetime(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_string */
 static
 void ps_fetch_string(zval *zv, const MYSQLND_FIELD * const field,
-					 unsigned int pack_len, zend_uchar **row,
+					 uint pack_len, zend_uchar **row,
 					 zend_bool as_unicode TSRMLS_DC)
 {
 	/*
@@ -424,7 +436,7 @@ void ps_fetch_string(zval *zv, const MYSQLND_FIELD * const field,
 /* {{{ ps_fetch_bit */
 static
 void ps_fetch_bit(zval *zv, const MYSQLND_FIELD * const field,
-				  unsigned int pack_len, zend_uchar **row,
+				  uint pack_len, zend_uchar **row,
 				  zend_bool as_unicode TSRMLS_DC)
 {
 	unsigned long length= php_mysqlnd_net_field_length(row);
@@ -578,7 +590,7 @@ void _mysqlnd_init_ps_subsystem()
 
 /* {{{ mysqlnd_stmt_copy_it */
 static void
-mysqlnd_stmt_copy_it(zval *** copies, zval *original, unsigned int param_count, unsigned int current)
+mysqlnd_stmt_copy_it(zval *** copies, zval *original, uint param_count, uint current)
 {
 	if (!*copies) {
 		*copies = ecalloc(param_count, sizeof(zval *));					
@@ -597,8 +609,8 @@ mysqlnd_stmt_execute_store_params(MYSQLND_STMT *stmt, zend_uchar **buf, zend_uch
 								  size_t *buf_len, unsigned int null_byte_offset TSRMLS_DC)
 {
 	unsigned int i = 0;
-	size_t left = (*buf_len - (*p - *buf));
-	size_t data_size = 0;
+	unsigned left = (*buf_len - (*p - *buf));
+	unsigned int data_size = 0;
 	zval **copies = NULL;/* if there are different types */
 
 /* 1. Store type information */
diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c
index 9af957bc39..6b94e2ca92 100644
--- a/ext/mysqlnd/mysqlnd_result.c
+++ b/ext/mysqlnd/mysqlnd_result.c
@@ -95,11 +95,11 @@ void * mysqlnd_fetch_thread(void *arg)
 /* {{{ mysqlnd_res_initialize_result_set_rest */
 void mysqlnd_res_initialize_result_set_rest(MYSQLND_RES * const result TSRMLS_DC)
 {
-	unsigned int i;
+	uint i;
 	zval **data_cursor = result->stored_data->data;
 	zval **data_begin = result->stored_data->data;
-	unsigned int field_count = result->meta->field_count;
-	unsigned int row_count = result->stored_data->row_count;
+	uint field_count = result->meta->field_count;
+	uint row_count = result->stored_data->row_count;
 	if (!data_cursor || row_count == result->stored_data->initialized_rows) {
 		return;
 	}
@@ -214,15 +214,11 @@ void mysqlnd_free_buffered_data(MYSQLND_RES *result TSRMLS_DC)
 		current_buffer->free_chunk(current_buffer, TRUE TSRMLS_CC);
 	}
 	DBG_INF("Freeing data & row_buffer");
-	if (set->data) {
-		pefree(set->data, set->persistent);
-		set->data = NULL;
-	}
-	if (set->row_buffers) {
-		pefree(set->row_buffers, set->persistent);
-		set->row_buffers	= NULL;
-	}
-	set->data_cursor = NULL;
+	pefree(set->data, set->persistent);
+	pefree(set->row_buffers, set->persistent);
+	set->data			= NULL;
+	set->row_buffers	= NULL;
+	set->data_cursor	= NULL;
 	set->row_count	= 0;
 	if (set->qcache) {
 		mysqlnd_qcache_free_cache_reference(&set->qcache);
@@ -1030,7 +1026,7 @@ mysqlnd_fetch_row_buffered_c(MYSQLND_RES *result TSRMLS_DC)
 		unsigned int i;
 
 		if (NULL == current_row[0]) {
-			uint64_t row_num = (set->data_cursor - set->data) / result->meta->field_count;
+			uint64 row_num = (set->data_cursor - set->data) / result->meta->field_count;
 			set->initialized_rows++;
 			result->m.row_decoder(set->row_buffers[row_num],
 								  current_row,
@@ -1096,7 +1092,7 @@ mysqlnd_fetch_row_buffered(MYSQLND_RES *result, void *param, unsigned int flags,
 		struct mysqlnd_field_hash_key *zend_hash_key = result->meta->zend_hash_keys;
 
 		if (NULL == current_row[0]) {
-			uint64_t row_num = (set->data_cursor - set->data) / result->meta->field_count;
+			uint64 row_num = (set->data_cursor - set->data) / result->meta->field_count;
 			set->initialized_rows++;
 			result->m.row_decoder(set->row_buffers[row_num],
 								  current_row,
@@ -1179,7 +1175,7 @@ mysqlnd_fetch_row_buffered(MYSQLND_RES *result, void *param, unsigned int flags,
 /* }}} */
 
 
-#define STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY 2
+#define STORE_RESULT_PREALLOCATED_SET 10
 
 /* {{{ mysqlnd_store_result_fetch_data */
 enum_func_status
@@ -1190,24 +1186,21 @@ mysqlnd_store_result_fetch_data(MYSQLND * const conn, MYSQLND_RES *result,
 {
 	enum_func_status ret;
 	php_mysql_packet_row *row_packet;
-	unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows = 1;
+	unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET, free_rows;
 	MYSQLND_RES_BUFFERED *set;
 
 	DBG_ENTER("mysqlnd_store_result_fetch_data");
 	DBG_INF_FMT("conn=%llu binary_proto=%d to_cache=%d",
 				conn->thread_id, binary_protocol, to_cache);
 
+	free_rows = next_extend;
+
 	result->stored_data	= set = mnd_pecalloc(1, sizeof(MYSQLND_RES_BUFFERED), to_cache);
-	if (free_rows) {
-		set->row_buffers = mnd_pemalloc(free_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *), to_cache);
-	}
+	set->row_buffers= mnd_pemalloc(STORE_RESULT_PREALLOCATED_SET * sizeof(MYSQLND_MEMORY_POOL_CHUNK *), to_cache);
 	set->persistent	= to_cache;
 	set->qcache		= to_cache? mysqlnd_qcache_get_cache_reference(conn->qcache):NULL;
 	set->references	= 1;
 
-	result->m.row_decoder = binary_protocol? php_mysqlnd_rowp_read_binary_protocol:
-											 php_mysqlnd_rowp_read_text_protocol;
-
 	/* non-persistent */
 	PACKET_INIT(row_packet, PROT_ROW_PACKET, php_mysql_packet_row *, FALSE);
 	row_packet->field_count = meta->field_count;
@@ -1220,15 +1213,18 @@ mysqlnd_store_result_fetch_data(MYSQLND * const conn, MYSQLND_RES *result,
 
 	while (FAIL != (ret = PACKET_READ(row_packet, conn)) && !row_packet->eof) {
 		if (!free_rows) {
-			uint64_t total_allocated_rows = free_rows = next_extend = next_extend * 11 / 10; /* extend with 10% */
-			total_allocated_rows += set->row_count;
+			uint64 total_rows = free_rows = next_extend = next_extend * 5 / 3; /* extend with 33% */
+			total_rows += set->row_count;
 			set->row_buffers = mnd_perealloc(set->row_buffers,
-											 total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *),
+											 total_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *),
 											 set->persistent);
 		}
 		free_rows--;
 		set->row_buffers[set->row_count] = row_packet->row_buffer;
 
+		result->m.row_decoder = binary_protocol? php_mysqlnd_rowp_read_binary_protocol:
+												 php_mysqlnd_rowp_read_text_protocol;
+
 		set->row_count++;
 
 		/* So row_packet's destructor function won't efree() it */
@@ -1243,12 +1239,7 @@ mysqlnd_store_result_fetch_data(MYSQLND * const conn, MYSQLND_RES *result,
 		*/
 	}
 	/* Overflow ? */
-	if (set->row_count) {
-		/* 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(set->row_count * meta->field_count * sizeof(zval *), to_cache);
-		memset(set->data, 0, set->row_count * meta->field_count * sizeof(zval *));
-	}
-
+	set->data = mnd_pecalloc(set->row_count * meta->field_count, sizeof(zval *), to_cache);
 	MYSQLND_INC_CONN_STATISTIC_W_VALUE(&conn->stats,
 									   binary_protocol? STAT_ROWS_BUFFERED_FROM_CLIENT_PS:
 														STAT_ROWS_BUFFERED_FROM_CLIENT_NORMAL,
@@ -1361,7 +1352,7 @@ mysqlnd_fetch_row_async_buffered(MYSQLND_RES *result, void *param, unsigned int
 
 	/* At the point we are still under LOCK */
 	if (set->data_cursor && (set->data_cursor - set->data) < (set->row_count)) {
-		uint64_t row_num = set->data_cursor - set->data;
+		uint64 row_num = set->data_cursor - set->data;
 		zval **current_row = *set->data_cursor++;
 		set->initialized_rows++;
 		/* We don't forget to release the lock */
@@ -1482,8 +1473,8 @@ mysqlnd_background_store_result_fetch_data(MYSQLND_RES *result TSRMLS_DC)
 	while (FAIL != (ret = PACKET_READ(row_packet, conn)) && !row_packet->eof) {
 		tsrm_mutex_lock(set->LOCK);
 		if (!free_rows) {
-			uint64_t total_rows = free_rows = next_extend = next_extend * 5 / 3; /* extend with 33% */
-			uint64_t old_size;
+			uint64 total_rows = free_rows = next_extend = next_extend * 5 / 3; /* extend with 33% */
+			uint64 old_size;
 			total_rows += set->row_count;
 
 			old_size = set->data_size;
@@ -1500,7 +1491,7 @@ mysqlnd_background_store_result_fetch_data(MYSQLND_RES *result TSRMLS_DC)
 		set->data[set->row_count] = row_packet->fields;
 
 		if (set->decode_in_foreground == FALSE) {
-			unsigned int i;
+			uint i;
 			result->m.row_decoder(set->row_buffers[set->row_count],
 								  set->data[set->row_count],
 								  result->meta->field_count,
@@ -1698,7 +1689,7 @@ MYSQLND_METHOD(mysqlnd_res, free_result)(MYSQLND_RES *result, zend_bool implicit
 
 /* {{{ mysqlnd_res::data_seek */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_res, data_seek)(MYSQLND_RES *result, uint64_t row TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_res, data_seek)(MYSQLND_RES *result, uint64 row TSRMLS_DC)
 {
 	DBG_ENTER("mysqlnd_res::data_seek");
 	DBG_INF_FMT("row=%lu", row);
@@ -1720,7 +1711,7 @@ MYSQLND_METHOD(mysqlnd_res, data_seek)(MYSQLND_RES *result, uint64_t row TSRMLS_
 
 
 /* {{{ mysqlnd_res::num_rows */
-static uint64_t
+static uint64
 MYSQLND_METHOD(mysqlnd_res, num_rows)(const MYSQLND_RES * const result)
 {
 	/* Be compatible with libmysql. We count row_count, but will return 0 */
@@ -1902,7 +1893,7 @@ MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES *result, unsigned int flags,
 		DBG_VOID_RETURN;
 	}	
 
-	mysqlnd_array_init(return_value, (unsigned int) set->row_count);
+	mysqlnd_array_init(return_value, (uint) set->row_count);
 
 	while (set->data_cursor &&
 		   (set->data_cursor - set->data) < (set->row_count * result->meta->field_count))
diff --git a/ext/mysqlnd/mysqlnd_statistics.c b/ext/mysqlnd/mysqlnd_statistics.c
index 7135ba3dbf..eb8645b132 100644
--- a/ext/mysqlnd/mysqlnd_statistics.c
+++ b/ext/mysqlnd/mysqlnd_statistics.c
@@ -30,7 +30,6 @@
 
 /* {{{ mysqlnd_stats_values_names 
  */
-
 const MYSQLND_STRING mysqlnd_stats_values_names[STAT_LAST] =
 {
 	{ STR_W_LEN("bytes_sent") },
@@ -39,21 +38,6 @@ const MYSQLND_STRING mysqlnd_stats_values_names[STAT_LAST] =
 	{ STR_W_LEN("packets_received") },
 	{ STR_W_LEN("protocol_overhead_in") },
 	{ STR_W_LEN("protocol_overhead_out") },
-	{ STR_W_LEN("bytes_received_ok_packet") }, 
-	{ STR_W_LEN("bytes_received_eof_packet") }, 
-	{ STR_W_LEN("bytes_received_rset_header_packet") }, 
-	{ STR_W_LEN("bytes_received_rset_field_meta_packet") }, 
-	{ STR_W_LEN("bytes_received_rset_row_packet") }, 
-	{ STR_W_LEN("bytes_received_prepare_response_packet") }, 
-	{ STR_W_LEN("bytes_received_change_user_packet") }, 
-	{ STR_W_LEN("packets_sent_command") }, 
-	{ STR_W_LEN("packets_received_ok") }, 
-	{ STR_W_LEN("packets_received_eof") }, 
-	{ STR_W_LEN("packets_received_rset_header") }, 
-	{ STR_W_LEN("packets_received_rset_field_meta") }, 
-	{ STR_W_LEN("packets_received_rset_row") }, 
-	{ STR_W_LEN("packets_received_prepare_response") }, 
-	{ STR_W_LEN("packets_received_change_user") }, 
 	{ STR_W_LEN("result_set_queries") },
 	{ STR_W_LEN("non_result_set_queries") },
 	{ STR_W_LEN("no_index_used") },
@@ -107,51 +91,9 @@ const MYSQLND_STRING mysqlnd_stats_values_names[STAT_LAST] =
 	{ STR_W_LEN("mem_malloc_ammount") },
 	{ STR_W_LEN("mem_calloc_count") },
 	{ STR_W_LEN("mem_calloc_ammount") },
-	{ STR_W_LEN("mem_realloc_count") },
+	{ STR_W_LEN("mem_realloc_calloc") },
 	{ STR_W_LEN("mem_realloc_ammount") },
-	{ STR_W_LEN("mem_free_count") },
-	{ STR_W_LEN("proto_text_fetched_null") },
-	{ STR_W_LEN("proto_text_fetched_bit") },
-	{ STR_W_LEN("proto_text_fetched_tinyint") },
-	{ STR_W_LEN("proto_text_fetched_short") },
-	{ STR_W_LEN("proto_text_fetched_int24") },
-	{ STR_W_LEN("proto_text_fetched_int") },
-	{ STR_W_LEN("proto_text_fetched_bigint") },
-	{ STR_W_LEN("proto_text_fetched_decimal") },
-	{ STR_W_LEN("proto_text_fetched_float") },
-	{ STR_W_LEN("proto_text_fetched_double") },
-	{ STR_W_LEN("proto_text_fetched_date") },
-	{ STR_W_LEN("proto_text_fetched_year") },
-	{ STR_W_LEN("proto_text_fetched_time") },
-	{ STR_W_LEN("proto_text_fetched_datetime") },
-	{ STR_W_LEN("proto_text_fetched_timestamp") },
-	{ STR_W_LEN("proto_text_fetched_string") },
-	{ STR_W_LEN("proto_text_fetched_blob") },
-	{ STR_W_LEN("proto_text_fetched_enum") },
-	{ STR_W_LEN("proto_text_fetched_set") },
-	{ STR_W_LEN("proto_text_fetched_geometry") },
-	{ STR_W_LEN("proto_text_fetched_other") },
-	{ STR_W_LEN("proto_binary_fetched_null") },
-	{ STR_W_LEN("proto_binary_fetched_bit") },
-	{ STR_W_LEN("proto_binary_fetched_tinyint") },
-	{ STR_W_LEN("proto_binary_fetched_short") },
-	{ STR_W_LEN("proto_binary_fetched_int24") },
-	{ STR_W_LEN("proto_binary_fetched_int") },
-	{ STR_W_LEN("proto_binary_fetched_bigint") },
-	{ STR_W_LEN("proto_binary_fetched_decimal") },
-	{ STR_W_LEN("proto_binary_fetched_float") },
-	{ STR_W_LEN("proto_binary_fetched_double") },
-	{ STR_W_LEN("proto_binary_fetched_date") },
-	{ STR_W_LEN("proto_binary_fetched_year") },
-	{ STR_W_LEN("proto_binary_fetched_time") },
-	{ STR_W_LEN("proto_binary_fetched_datetime") },
-	{ STR_W_LEN("proto_binary_fetched_timestamp") },
-	{ STR_W_LEN("proto_binary_fetched_string") },
-	{ STR_W_LEN("proto_binary_fetched_blob") },
-	{ STR_W_LEN("proto_binary_fetched_enum") },
-	{ STR_W_LEN("proto_binary_fetched_set") },
-	{ STR_W_LEN("proto_binary_fetched_geometry") },
-	{ STR_W_LEN("proto_binary_fetched_other") }	
+	{ STR_W_LEN("mem_free_count") }
 };
 /* }}} */
 
diff --git a/ext/mysqlnd/mysqlnd_statistics.h b/ext/mysqlnd/mysqlnd_statistics.h
index 32177e71ba..e9a3acf86e 100644
--- a/ext/mysqlnd/mysqlnd_statistics.h
+++ b/ext/mysqlnd/mysqlnd_statistics.h
@@ -38,7 +38,7 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 
 #define MYSQLND_INC_GLOBAL_STATISTIC(statistic) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
+ 	if (MYSQLND_G(collect_statistics)) { \
 		DBG_INF_FMT("Global stat increase [%s]", mysqlnd_stats_values_names[statistic]); \
  		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
 		mysqlnd_global_stats->values[(statistic)]++; \
@@ -46,36 +46,33 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 	}\
  }
 
-#define MYSQLND_DEC_CONN_STATISTIC(conn_stats, statistic) \
+#define MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(statistic1, value1, statistic2, value2) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
-		DBG_INF_FMT("Global&conn stat decrease [%s]", mysqlnd_stats_values_names[statistic]); \
+ 	if (MYSQLND_G(collect_statistics)) { \
+		DBG_INF_FMT("Global stats increase w value [%s] [%s]", mysqlnd_stats_values_names[statistic1], mysqlnd_stats_values_names[statistic2]); \
  		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
-		mysqlnd_global_stats->values[(statistic)]--; \
+		mysqlnd_global_stats->values[(statistic1)] += (value1); \
+		mysqlnd_global_stats->values[(statistic2)] += (value2); \
 		tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
-		if ((conn_stats)) { \
-			((MYSQLND_STATS *) conn_stats)->values[(statistic)]--; \
-		} \
 	}\
  }
 
-#define MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(statistic1, value1, statistic2, value2) \
+#define MYSQLND_DEC_CONN_STATISTIC(conn_stats, statistic) \
  { \
  	if (MYSQLND_G(collect_statistics)) { \
-		uint64_t v1 = (uint64_t) (value1); \
-		uint64_t v2 = (uint64_t) (value2); \
-		DBG_INF_FMT("Global stat increase [%s] [%s]", mysqlnd_stats_values_names[statistic1], mysqlnd_stats_values_names[statistic2]); \
-										\
+		DBG_INF_FMT("Global&conn stat decrease [%s]", mysqlnd_stats_values_names[statistic]); \
  		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
-		if (statistic1 != STAT_LAST) mysqlnd_global_stats->values[(statistic1)]+= v1; \
-		if (statistic2 != STAT_LAST) mysqlnd_global_stats->values[(statistic2)]+= v2; \
+		mysqlnd_global_stats->values[(statistic)]--; \
 		tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
+		if ((conn_stats)) { \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic)]--; \
+		} \
 	}\
  }
 
 #define MYSQLND_INC_CONN_STATISTIC(conn_stats, statistic) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
+ 	if (MYSQLND_G(collect_statistics)) { \
 		DBG_INF_FMT("Global&Conn stat increase [%s]", mysqlnd_stats_values_names[statistic]); \
  		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
 		mysqlnd_global_stats->values[(statistic)]++; \
@@ -88,8 +85,8 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 
 #define MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn_stats, statistic, value) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
-		uint64_t v = (uint64_t) (value); \
+ 	if (MYSQLND_G(collect_statistics)) { \
+		uint64 v = (uint64) (value); \
 		DBG_INF_FMT("Global&Conn stat increase w value [%s]", mysqlnd_stats_values_names[statistic]); \
 		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
 		mysqlnd_global_stats->values[(statistic)] += v; \
@@ -100,40 +97,22 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 	}\
  }
 
-#define MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn_stats, statistic1, value1, statistic2, value2) \
- { \
- 	if (MYSQLND_G(collect_statistics)) { \
-		uint64_t v1 = (uint64_t) (value1); \
-		uint64_t v2 = (uint64_t) (value2); \
-								 \
-		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
-		if (statistic1 != STAT_LAST) mysqlnd_global_stats->values[(statistic1)]+= v1; \
-		if (statistic2 != STAT_LAST) mysqlnd_global_stats->values[(statistic2)]+= v2; \
-		tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
-		if ((conn_stats)) { \
-			if (statistic1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic1)]+= v1; \
-			if (statistic2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic2)]+= v2; \
-		} \
-	} \
- }
-
-
 #define MYSQLND_INC_CONN_STATISTIC_W_VALUE3(conn_stats, statistic1, value1, statistic2, value2, statistic3, value3) \
  { \
  	if (MYSQLND_G(collect_statistics)) { \
-		uint64_t v1 = (uint64_t) (value1); \
-		uint64_t v2 = (uint64_t) (value2); \
-		uint64_t v3 = (uint64_t) (value3); \
-								 		\
+		uint64 v1 = (uint64) (value1); \
+		uint64 v2 = (uint64) (value2); \
+		uint64 v3 = (uint64) (value3); \
+								 \
 		tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
-		if (statistic1 != STAT_LAST) mysqlnd_global_stats->values[(statistic1)]+= v1; \
-		if (statistic2 != STAT_LAST) mysqlnd_global_stats->values[(statistic2)]+= v2; \
-		if (statistic3 != STAT_LAST) mysqlnd_global_stats->values[(statistic3)]+= v3; \
+		mysqlnd_global_stats->values[(statistic1)]+= v1; \
+		mysqlnd_global_stats->values[(statistic2)]+= v2; \
+		mysqlnd_global_stats->values[(statistic3)]+= v3; \
 		tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
 		if ((conn_stats)) { \
-			if (statistic1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic1)]+= v1; \
-			if (statistic2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic2)]+= v2; \
-			if (statistic3 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic3)]+= v3; \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic1)]+= v1; \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic2)]+= v2; \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic3)]+= v3; \
 		} \
 	} \
  }
@@ -143,16 +122,26 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 
 #define MYSQLND_INC_GLOBAL_STATISTIC(statistic) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
+ 	if (MYSQLND_G(collect_statistics)) { \
 		DBG_INF_FMT("Global stat increase [%s]", mysqlnd_stats_values_names[statistic]); \
 		mysqlnd_global_stats->values[(statistic)]++; \
 	} \
  }
 
+#define MYSQLND_INC_GLOBAL_STATISTIC2_W_VALUE(statistic1, value1, statistic2, value2) \
+ { \
+ 	if (MYSQLND_G(collect_statistics)) { \
+		DBG_INF_FMT("Global stats increase w value [%s] [%s]", \
+			mysqlnd_stats_values_names[statistic1], mysqlnd_stats_values_names[statistic2]); \
+		mysqlnd_global_stats->values[(statistic1)] += (value1); \
+		mysqlnd_global_stats->values[(statistic2)] += (value2); \
+	}\
+ }
+
 
 #define MYSQLND_DEC_CONN_STATISTIC(conn_stats, statistic) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
+ 	if (MYSQLND_G(collect_statistics)) { \
 		DBG_INF_FMT("Global&Conn stat decrease [%s]", mysqlnd_stats_values_names[statistic]); \
 		mysqlnd_global_stats->values[(statistic)]--; \
 		if ((conn_stats)) { \
@@ -161,21 +150,9 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 	} \
  }
 
-#define MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(statistic1, value1, statistic2, value2) \
- { \
- 	if (MYSQLND_G(collect_statistics)) { \
-		uint64_t v1 = (uint64_t) (value1); \
-		uint64_t v2 = (uint64_t) (value2); \
-		DBG_INF_FMT("Global stat increase [%s] [%s]", mysqlnd_stats_values_names[statistic1], mysqlnd_stats_values_names[statistic2]); \
-			\
-		if (statistic1 != STAT_LAST) mysqlnd_global_stats->values[(statistic1)]+= v1; \
-		if (statistic2 != STAT_LAST) mysqlnd_global_stats->values[(statistic2)]+= v2; \
-	}\
- }
-
 #define MYSQLND_INC_CONN_STATISTIC(conn_stats, statistic) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
+ 	if (MYSQLND_G(collect_statistics)) { \
 		DBG_INF_FMT("Global&Conn stat increase [%s]", mysqlnd_stats_values_names[statistic]); \
 		mysqlnd_global_stats->values[(statistic)]++; \
 		if ((conn_stats)) { \
@@ -186,9 +163,9 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 
 #define MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn_stats, statistic, value) \
  { \
- 	if (MYSQLND_G(collect_statistics) && statistic != STAT_LAST) { \
-		uint64_t v = (uint64_t) (value); \
-		DBG_INF_FMT("Global&Conn stats increase w value [%s]", mysqlnd_stats_values_names[statistic]); \
+	uint64 v = (uint64) (value); \
+	DBG_INF_FMT("Global&Conn stats increase w value [%s]", mysqlnd_stats_values_names[statistic]); \
+ 	if (MYSQLND_G(collect_statistics)) { \
 		mysqlnd_global_stats->values[(statistic)] += v; \
 		if ((conn_stats)) { \
 			((MYSQLND_STATS *) conn_stats)->values[(statistic)] += v; \
@@ -196,35 +173,20 @@ extern const MYSQLND_STRING mysqlnd_stats_values_names[];
 	} \
  } 
 
-#define MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn_stats, statistic1, value1, statistic2, value2) \
- { \
- 	if (MYSQLND_G(collect_statistics)) { \
-		uint64_t v1 = (uint64_t) (value1); \
-		uint64_t v2 = (uint64_t) (value2); \
-								 \
-		if (statistic1 != STAT_LAST) mysqlnd_global_stats->values[(statistic1)]+= v1; \
-		if (statistic2 != STAT_LAST) mysqlnd_global_stats->values[(statistic2)]+= v2; \
-		if ((conn_stats)) { \
-			if (statistic1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic1)]+= v1; \
-			if (statistic2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic2)]+= v2; \
-		} \
-	} \
- }
-
 #define MYSQLND_INC_CONN_STATISTIC_W_VALUE3(conn_stats, statistic1, value1, statistic2, value2, statistic3, value3) \
  { \
  	if (MYSQLND_G(collect_statistics)) { \
-		uint64_t v1 = (uint64_t) (value1); \
-		uint64_t v2 = (uint64_t) (value2); \
-		uint64_t v3 = (uint64_t) (value3); \
+		uint64 v1 = (uint64) (value1); \
+		uint64 v2 = (uint64) (value2); \
+		uint64 v3 = (uint64) (value3); \
 								\
-		if (statistic1 != STAT_LAST) mysqlnd_global_stats->values[(statistic1)]+= v1; \
-		if (statistic2 != STAT_LAST) mysqlnd_global_stats->values[(statistic2)]+= v2; \
-		if (statistic3 != STAT_LAST) mysqlnd_global_stats->values[(statistic3)]+= v3; \
+		mysqlnd_global_stats->values[(statistic1)]+= v1; \
+		mysqlnd_global_stats->values[(statistic2)]+= v2; \
+		mysqlnd_global_stats->values[(statistic3)]+= v3; \
 		if ((conn_stats)) { \
-			if (statistic1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic1)]+= v1; \
-			if (statistic2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic2)]+= v2; \
-			if (statistic3 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[(statistic3)]+= v3; \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic1)]+= v1; \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic2)]+= v2; \
+			((MYSQLND_STATS *) conn_stats)->values[(statistic3)]+= v3; \
 		} \
 	} \
  }
diff --git a/ext/mysqlnd/mysqlnd_structs.h b/ext/mysqlnd/mysqlnd_structs.h
index 3343da5a50..2f6dcfa2e1 100644
--- a/ext/mysqlnd/mysqlnd_structs.h
+++ b/ext/mysqlnd/mysqlnd_structs.h
@@ -33,23 +33,23 @@ typedef struct st_mysqlnd_memory_pool_chunk_llist MYSQLND_MEMORY_POOL_CHUNK_LLIS
 struct st_mysqlnd_memory_pool
 {
 	zend_uchar *arena;
-	unsigned int refcount;
-	unsigned int arena_size;
-	unsigned int free_size;
+	uint refcount;
+	uint arena_size;
+	uint free_size;
 
 	MYSQLND_MEMORY_POOL_CHUNK* free_chunk_list[MYSQLND_MEMORY_POOL_CHUNK_LIST_SIZE];
-	unsigned int free_chunk_list_elements;
+	uint free_chunk_list_elements;
 
-	MYSQLND_MEMORY_POOL_CHUNK*	(*get_chunk)(MYSQLND_MEMORY_POOL * pool, unsigned int size TSRMLS_DC);
+	MYSQLND_MEMORY_POOL_CHUNK*	(*get_chunk)(MYSQLND_MEMORY_POOL * pool, uint size TSRMLS_DC);
 };
 
 struct st_mysqlnd_memory_pool_chunk
 {
-	uint64_t			app;
+	uint64				app;
 	MYSQLND_MEMORY_POOL *pool;
 	zend_uchar			*ptr;
-	unsigned int				size;
-	void				(*resize_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC);
+	uint				size;
+	void				(*resize_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, uint size TSRMLS_DC);
 	void				(*free_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it TSRMLS_DC);
 	zend_bool			from_pool;
 };
@@ -94,8 +94,8 @@ typedef struct st_mysqlnd_upsert_result
 {
 	unsigned int	warning_count;
 	unsigned int	server_status;
-	uint64_t		affected_rows;
-	uint64_t		last_insert_id;
+	uint64			affected_rows;
+	uint64			last_insert_id;
 } mysqlnd_upsert_status;
 
 
@@ -124,14 +124,14 @@ typedef struct st_mysqlnd_infile_info
 /* character set information */
 typedef struct st_mysqlnd_charset
 {
-	unsigned int		nr;
+	uint		nr;
 	const char	*name;
 	const char	*collation;
-	unsigned int		char_minlen;
-	unsigned int		char_maxlen;
+	uint		char_minlen;
+	uint		char_maxlen;
 	const char	*comment;
-	unsigned int 		(*mb_charlen)(unsigned int c);
-	unsigned int 		(*mb_valid)(const char *start, const char *end);
+	uint 		(*mb_charlen)(uint c);
+	uint 		(*mb_valid)(const char *start, const char *end);
 } MYSQLND_CHARSET;
 
 
@@ -139,8 +139,8 @@ typedef struct st_mysqlnd_charset
 typedef struct st_mysqlnd_infile
 {
 	int		(*local_infile_init)(void **ptr, char *filename, void **userdata TSRMLS_DC);
-	int		(*local_infile_read)(void *ptr, char *buf, unsigned int buf_len TSRMLS_DC);
-	int		(*local_infile_error)(void *ptr, char *error_msg, unsigned int error_msg_len TSRMLS_DC);
+	int		(*local_infile_read)(void *ptr, char *buf, uint buf_len TSRMLS_DC);
+	int		(*local_infile_error)(void *ptr, char *error_msg, uint error_msg_len TSRMLS_DC);
 	void	(*local_infile_end)(void *ptr TSRMLS_DC);
 	zval	*callback;
 	void	*userdata;
@@ -149,14 +149,14 @@ typedef struct st_mysqlnd_infile
 typedef struct st_mysqlnd_option
 {
 	/* timeouts */
-	unsigned int		timeout_connect;
-	unsigned int		timeout_read;
-	unsigned int		timeout_write;
+	uint		timeout_connect;
+	uint		timeout_read;
+	uint		timeout_write;
 
 	ulong		flags;
 
 	/* init commands - we need to send them to server directly after connect */
-	unsigned int		num_commands;
+	uint		num_commands;
 	char		**init_commands;
 
 	/* configuration file information */
@@ -177,7 +177,7 @@ typedef struct st_mysqlnd_option
 
 	zend_bool	numeric_and_datetime_as_unicode;
 #ifdef MYSQLND_STRING_TO_INT_CONVERSION
-	zend_bool	int_and_float_native;
+	zend_bool	int_and_year_as_int;
 #endif
 	unsigned int net_read_buffer_size;
 } MYSQLND_OPTION;
@@ -210,7 +210,7 @@ typedef enum_func_status  (*mysqlnd_fetch_row_func)(MYSQLND_RES *result,
 
 typedef struct st_mysqlnd_stats
 {
-	uint64_t	values[STAT_LAST];
+	uint64	values[STAT_LAST];
 #ifdef ZTS
 	MUTEX_T	LOCK_access;
 #endif
@@ -237,8 +237,6 @@ struct st_mysqlnd_conn_methods
 	ulong				(*escape_string)(const MYSQLND * const conn, char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC);
 	enum_func_status	(*set_charset)(MYSQLND * const conn, const char * const charset TSRMLS_DC);
 	enum_func_status	(*query)(MYSQLND *conn, const char *query, unsigned int query_len TSRMLS_DC);
-	enum_func_status	(*send_query)(MYSQLND *conn, const char *query, unsigned int query_len TSRMLS_DC);
-	enum_func_status	(*reap_query)(MYSQLND *conn TSRMLS_DC);
 	MYSQLND_RES *		(*use_result)(MYSQLND * const conn TSRMLS_DC);
 	MYSQLND_RES *		(*store_result)(MYSQLND * const conn TSRMLS_DC);
 	MYSQLND_RES *		(*background_store_result)(MYSQLND * const conn TSRMLS_DC);
@@ -247,8 +245,8 @@ struct st_mysqlnd_conn_methods
 
 	MYSQLND_STMT *		(*stmt_init)(MYSQLND * const conn TSRMLS_DC);
 
-	enum_func_status	(*shutdown_server)(MYSQLND * const conn, uint8_t level TSRMLS_DC);
-	enum_func_status	(*refresh_server)(MYSQLND * const conn, uint8_t options TSRMLS_DC);
+	enum_func_status	(*shutdown_server)(MYSQLND * const conn, unsigned long level TSRMLS_DC);
+	enum_func_status	(*refresh_server)(MYSQLND * const conn, unsigned long options TSRMLS_DC);
 
 	enum_func_status	(*ping)(MYSQLND * const conn TSRMLS_DC);
 	enum_func_status	(*kill_connection)(MYSQLND *conn, unsigned int pid TSRMLS_DC);
@@ -259,7 +257,7 @@ struct st_mysqlnd_conn_methods
 	unsigned int		(*get_error_no)(const MYSQLND * const conn);
 	const char *		(*get_error_str)(const MYSQLND * const conn);
 	const char *		(*get_sqlstate)(const MYSQLND * const conn);
-	uint64_t			(*get_thread_id)(const MYSQLND * const conn);
+	uint64				(*get_thread_id)(const MYSQLND * const conn);
 	void				(*get_statistics)(const MYSQLND * const conn, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
 
 	unsigned long		(*get_server_version)(const MYSQLND * const conn);
@@ -272,8 +270,8 @@ struct st_mysqlnd_conn_methods
 	MYSQLND_RES *		(*list_fields)(MYSQLND *conn, const char *table, const char *achtung_wild TSRMLS_DC);
 	MYSQLND_RES *		(*list_method)(MYSQLND *conn, const char *query, const char *achtung_wild, char *par1 TSRMLS_DC);
 
-	uint64_t			(*get_last_insert_id)(const MYSQLND * const conn);
-	uint64_t			(*get_affected_rows)(const MYSQLND * const conn);
+	uint64				(*get_last_insert_id)(const MYSQLND * const conn);
+	uint64				(*get_affected_rows)(const MYSQLND * const conn);
 	unsigned int		(*get_warning_count)(const MYSQLND * const conn);
 
 	unsigned int		(*get_field_count)(const MYSQLND * const conn);
@@ -304,10 +302,10 @@ struct st_mysqlnd_res_methods
 	MYSQLND_ROW_C 		(*fetch_row_c)(MYSQLND_RES *result TSRMLS_DC);
 	void 				(*fetch_all)(MYSQLND_RES *result, unsigned int flags, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
 	void 				(*fetch_field_data)(MYSQLND_RES *result, unsigned int offset, zval *return_value TSRMLS_DC);
-	uint64_t			(*num_rows)(const MYSQLND_RES * const result);
+	uint64				(*num_rows)(const MYSQLND_RES * const result);
 	unsigned int		(*num_fields)(const MYSQLND_RES * const result);
 	enum_func_status	(*skip_result)(MYSQLND_RES * const result TSRMLS_DC);
-	enum_func_status	(*seek_data)(MYSQLND_RES * result, uint64_t row TSRMLS_DC);
+	enum_func_status	(*seek_data)(MYSQLND_RES * result, uint64 row TSRMLS_DC);
 	MYSQLND_FIELD_OFFSET (*seek_field)(MYSQLND_RES * const result, MYSQLND_FIELD_OFFSET field_offset);
 	MYSQLND_FIELD_OFFSET (*field_tell)(const MYSQLND_RES * const result);
 	const MYSQLND_FIELD *(*fetch_field)(MYSQLND_RES * const result TSRMLS_DC);
@@ -322,7 +320,7 @@ struct st_mysqlnd_res_methods
 	void 				(*free_result_contents)(MYSQLND_RES *result TSRMLS_DC);
 
 	/* for decoding - binary or text protocol */	
-	void 				(*row_decoder)(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields, unsigned int field_count, MYSQLND_FIELD *fields_metadata, MYSQLND *conn TSRMLS_DC);
+	void 				(*row_decoder)(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields, uint field_count, MYSQLND_FIELD *fields_metadata, MYSQLND *conn TSRMLS_DC);
 };
 
 
@@ -349,7 +347,7 @@ struct st_mysqlnd_stmt_methods
 	zend_bool			(*more_results)(const MYSQLND_STMT * const stmt TSRMLS_DC);
 	enum_func_status	(*next_result)(MYSQLND_STMT * const stmt TSRMLS_DC);
 	enum_func_status	(*free_result)(MYSQLND_STMT * const stmt TSRMLS_DC);
-	enum_func_status	(*seek_data)(const MYSQLND_STMT * const stmt, uint64_t row TSRMLS_DC);
+	enum_func_status	(*seek_data)(const MYSQLND_STMT * const stmt, uint64 row TSRMLS_DC);
 	enum_func_status	(*reset)(MYSQLND_STMT * const stmt TSRMLS_DC);
 	enum_func_status	(*net_close)(MYSQLND_STMT * const stmt, zend_bool implicit TSRMLS_DC); /* private */
 	enum_func_status	(*dtor)(MYSQLND_STMT * const stmt, zend_bool implicit TSRMLS_DC); /* use this for mysqlnd_stmt_close */
@@ -361,16 +359,16 @@ struct st_mysqlnd_stmt_methods
 	enum_func_status	(*refresh_bind_param)(MYSQLND_STMT * const stmt TSRMLS_DC);
 	void				(*set_param_bind_dtor)(MYSQLND_STMT * const stmt, void (*param_bind_dtor)(MYSQLND_PARAM_BIND *)  TSRMLS_DC);
 	enum_func_status	(*bind_result)(MYSQLND_STMT * const stmt, MYSQLND_RESULT_BIND * const result_bind TSRMLS_DC);
-	enum_func_status	(*bind_one_result)(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC);
+	enum_func_status	(*bind_one_result)(MYSQLND_STMT * const stmt, uint param_no TSRMLS_DC);
 	void				(*set_result_bind_dtor)(MYSQLND_STMT * const stmt, void (*result_bind_dtor)(MYSQLND_RESULT_BIND *) TSRMLS_DC);
 	enum_func_status	(*send_long_data)(MYSQLND_STMT * const stmt, unsigned int param_num,
 										  const char * const data, unsigned long length TSRMLS_DC);
 	MYSQLND_RES *		(*get_parameter_metadata)(MYSQLND_STMT * const stmt);
 	MYSQLND_RES *		(*get_result_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC);
 
-	uint64_t			(*get_last_insert_id)(const MYSQLND_STMT * const stmt);
-	uint64_t			(*get_affected_rows)(const MYSQLND_STMT * const stmt);
-	uint64_t			(*get_num_rows)(const MYSQLND_STMT * const stmt);
+	uint64				(*get_last_insert_id)(const MYSQLND_STMT * const stmt);
+	uint64				(*get_affected_rows)(const MYSQLND_STMT * const stmt);
+	uint64				(*get_num_rows)(const MYSQLND_STMT * const stmt);
 
 	unsigned int		(*get_param_count)(const MYSQLND_STMT * const stmt);
 	unsigned int		(*get_field_count)(const MYSQLND_STMT * const stmt);
@@ -397,7 +395,7 @@ struct st_mysqlnd_connection
 	char			*passwd;
 	unsigned int	*passwd_len;
 	char			*scheme;
-	uint64_t		thread_id;
+	uint64			thread_id;
 	char			*server_version;
 	char			*host_info;
 	unsigned char	*scramble;
@@ -504,11 +502,11 @@ struct st_mysqlnd_result_metadata
 struct st_mysqlnd_background_buffered_result
 {
 	zval			***data;
-	uint64_t		data_size;
+	uint64			data_size;
 	zval			***data_cursor;
 	MYSQLND_MEMORY_POOL_CHUNK **row_buffers;
-	uint64_t		row_count;
-	uint64_t		initialized_rows;
+	uint64			row_count;
+	uint64			initialized_rows;
 	zend_bool		persistent;
 
 	MYSQLND_QCACHE	*qcache;
@@ -531,8 +529,8 @@ struct st_mysqlnd_buffered_result
 	zval				**data;
 	zval				**data_cursor;
 	MYSQLND_MEMORY_POOL_CHUNK **row_buffers;
-	uint64_t			row_count;
-	uint64_t			initialized_rows;
+	uint64				row_count;
+	uint64				initialized_rows;
 	zend_bool			persistent;
 
 	MYSQLND_QCACHE		*qcache;
@@ -548,7 +546,7 @@ struct st_mysqlnd_unbuffered_result
 	zval				**last_row_data;
 	MYSQLND_MEMORY_POOL_CHUNK *last_row_buffer;
 
-	uint64_t			row_count;
+	uint64				row_count;
 	zend_bool			eof_reached;
 };
 
diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.c b/ext/mysqlnd/mysqlnd_wireprotocol.c
index 5148c54155..81cf51422e 100644
--- a/ext/mysqlnd/mysqlnd_wireprotocol.c
+++ b/ext/mysqlnd/mysqlnd_wireprotocol.c
@@ -35,6 +35,7 @@
 #include <winsock.h>
 #endif
 
+
 #define USE_CORK 0
 
 #define MYSQLND_SILENT 1
@@ -43,13 +44,13 @@
 #define MYSQLND_DUMP_HEADER_N_BODY_FULL2
 
 
-#define	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_size, packet_type_as_text, packet_type) \
+#define	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_size, packet_type) \
 	{ \
 		if (FAIL == mysqlnd_read_header((conn), &((packet)->header) TSRMLS_CC)) {\
 			CONN_SET_STATE(conn, CONN_QUIT_SENT); \
 			SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);\
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", mysqlnd_server_gone); \
-			DBG_ERR_FMT("Can't read %s's header", (packet_type_as_text)); \
+			DBG_ERR_FMT("Can't read %s's header", (packet_type)); \
 			DBG_RETURN(FAIL);\
 		}\
 		if ((buf_size) < (packet)->header.size) { \
@@ -61,13 +62,9 @@
 			CONN_SET_STATE(conn, CONN_QUIT_SENT); \
 			SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);\
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", mysqlnd_server_gone); \
-			DBG_ERR_FMT("Empty %s packet body", (packet_type_as_text)); \
+			DBG_ERR_FMT("Empty %s packet body", (packet_type)); \
 			DBG_RETURN(FAIL);\
 		} \
-		MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats, packet_type_to_statistic_byte_count[packet_type], \
-											MYSQLND_HEADER_SIZE + (packet)->header.size, \
-											packet_type_to_statistic_packet_count[packet_type], \
-											1); \
 	}
 
 
@@ -79,7 +76,7 @@ char * const mysqlnd_empty_string = "";
 
 /* Used in mysqlnd_debug.c */
 char * mysqlnd_read_header_name	= "mysqlnd_read_header";
-char * mysqlnd_read_body_name	= "mysqlnd_read_body";
+char * mysqlnd_read_body_name		= "mysqlnd_read_body";
 
 
 /* {{{ mysqlnd_command_to_text 
@@ -97,36 +94,6 @@ const char * const mysqlnd_command_to_text[COM_END] =
 /* }}} */
 
 
-
-static enum_mysqlnd_collected_stats packet_type_to_statistic_byte_count[PROT_LAST] =
-{
-	STAT_LAST,
-	STAT_LAST,
-	STAT_BYTES_RECEIVED_OK,
-	STAT_BYTES_RECEIVED_EOF,
-	STAT_LAST,
-	STAT_BYTES_RECEIVED_RSET_HEADER,
-	STAT_BYTES_RECEIVED_RSET_FIELD_META,
-	STAT_BYTES_RECEIVED_RSET_ROW,
-	STAT_BYTES_RECEIVED_PREPARE_RESPONSE,
-	STAT_BYTES_RECEIVED_CHANGE_USER,
-};
-
-static enum_mysqlnd_collected_stats packet_type_to_statistic_packet_count[PROT_LAST] =
-{
-	STAT_LAST,
-	STAT_LAST,
-	STAT_PACKETS_RECEIVED_OK,
-	STAT_PACKETS_RECEIVED_EOF,
-	STAT_LAST,
-	STAT_PACKETS_RECEIVED_RSET_HEADER,
-	STAT_PACKETS_RECEIVED_RSET_FIELD_META,
-	STAT_PACKETS_RECEIVED_RSET_ROW,
-	STAT_PACKETS_RECEIVED_PREPARE_RESPONSE,
-	STAT_PACKETS_RECEIVED_CHANGE_USER,
-};
-
-
 /* {{{ php_mysqlnd_net_field_length 
    Get next field's length */
 unsigned long php_mysqlnd_net_field_length(zend_uchar **packet)
@@ -158,48 +125,48 @@ unsigned long php_mysqlnd_net_field_length(zend_uchar **packet)
 
 /* {{{ php_mysqlnd_net_field_length_ll 
    Get next field's length */
-uint64_t php_mysqlnd_net_field_length_ll(zend_uchar **packet)
+uint64 php_mysqlnd_net_field_length_ll(zend_uchar **packet)
 {
 	register zend_uchar *p= (zend_uchar *)*packet;
 
 	if (*p < 251) {
 		(*packet)++;
-		return (uint64_t) *p;
+		return (uint64) *p;
 	}
 
 	switch (*p) {
 		case 251:
 			(*packet)++;
-			return (uint64_t) MYSQLND_NULL_LENGTH;
+			return (uint64) MYSQLND_NULL_LENGTH;
 		case 252:
 			(*packet) += 3;
-			return (uint64_t) uint2korr(p + 1);
+			return (uint64) uint2korr(p + 1);
 		case 253:
 			(*packet) += 4;
-			return (uint64_t) uint3korr(p + 1);
+			return (uint64) uint3korr(p + 1);
 		default:
 			(*packet) += 9;
-			return (uint64_t) uint8korr(p + 1);
+			return (uint64) uint8korr(p + 1);
 	}
 }
 /* }}} */
 
 
 /* {{{ php_mysqlnd_net_store_length */
-zend_uchar *php_mysqlnd_net_store_length(zend_uchar *packet, uint64_t length)
+zend_uchar *php_mysqlnd_net_store_length(zend_uchar *packet, uint64 length)
 {
-	if (length < (uint64_t) L64(251)) {
+	if (length < (uint64) L64(251)) {
 		*packet = (zend_uchar) length;
 		return packet + 1;
 	}
 
-	if (length < (uint64_t) L64(65536)) {
+	if (length < (uint64) L64(65536)) {
 		*packet++ = 252;
-		int2store(packet,(unsigned int) length);
+		int2store(packet,(uint) length);
 		return packet + 2;
 	}
 
-	if (length < (uint64_t) L64(16777216)) {
+	if (length < (uint64) L64(16777216)) {
 		*packet++ = 253;
 		int3store(packet,(ulong) length);
 		return packet + 3;
@@ -247,8 +214,8 @@ size_t php_mysqlnd_consume_uneaten_data(MYSQLND * const conn, enum php_mysqlnd_s
 			DBG_ERR_FMT("Skipped %u bytes. Last command %s hasn't consumed all the output from the server",
 						bytes_consumed, mysqlnd_command_to_text[net->last_command]);
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Skipped %u bytes. Last command %s hasn't "
-							 "consumed all the output from the server",
-							 bytes_consumed, mysqlnd_command_to_text[net->last_command]);
+							 "consumed all the output from the server. PID=%d",
+							 bytes_consumed, mysqlnd_command_to_text[net->last_command], getpid());
 		}
 	}
 	net->last_command = cmd;
@@ -315,7 +282,7 @@ int mysqlnd_set_sock_no_delay(php_stream *stream)
 
 
 /* We assume that MYSQLND_HEADER_SIZE is 4 bytes !! */
-#define STORE_HEADER_SIZE(safe_storage, buffer)  int4store((safe_storage), (*(uint32_t *)(buffer)))
+#define STORE_HEADER_SIZE(safe_storage, buffer)  int4store((safe_storage), (*(uint32 *)(buffer)))
 #define RESTORE_HEADER_SIZE(buffer, safe_storage) STORE_HEADER_SIZE((safe_storage), (buffer))
 
 /* {{{ mysqlnd_stream_write_w_header */
@@ -346,7 +313,7 @@ size_t mysqlnd_stream_write_w_header(MYSQLND * const conn, char * const buf, siz
 	while (left > MYSQLND_MAX_PACKET_SIZE) {
 		STORE_HEADER_SIZE(safe_storage, p);
 		int3store(p, MYSQLND_MAX_PACKET_SIZE);
-		int1store(p + 3, net->packet_no);
+		int1store(p + 3, net->packet_no);		
 		net->packet_no++;
 		ret = php_stream_write(net->stream, (char *)p, MYSQLND_MAX_PACKET_SIZE + MYSQLND_HEADER_SIZE);
 		RESTORE_HEADER_SIZE(p, safe_storage);
@@ -359,7 +326,7 @@ size_t mysqlnd_stream_write_w_header(MYSQLND * const conn, char * const buf, siz
 	/* Even for zero size payload we have to send a packet */
 	STORE_HEADER_SIZE(safe_storage, p);
 	int3store(p, left);
-	int1store(p + 3, net->packet_no);
+	int1store(p + 3, net->packet_no);		
 	net->packet_no++;
 	ret = php_stream_write(net->stream, (char *)p, left + MYSQLND_HEADER_SIZE);
 	RESTORE_HEADER_SIZE(p, safe_storage);
@@ -368,7 +335,7 @@ size_t mysqlnd_stream_write_w_header(MYSQLND * const conn, char * const buf, siz
 		DBG_ERR_FMT("Can't %u send bytes", count);
 		conn->state = CONN_QUIT_SENT;
 		SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
-	}
+	}	
 
 	MYSQLND_INC_CONN_STATISTIC_W_VALUE3(&conn->stats,
 			STAT_BYTES_SENT, count + packets_sent * MYSQLND_HEADER_SIZE,
@@ -404,12 +371,12 @@ size_t mysqlnd_stream_write_w_command(MYSQLND * const conn, enum php_mysqlnd_ser
 	setsockopt(((php_netstream_data_t*)net->stream->abstract)->socket,
 				IPPROTO_TCP, TCP_CORK, &corked, sizeof(corked));
 
-	int1store(safe_storage + MYSQLND_HEADER_SIZE, command);
+	int1store(safe_storage + MYSQLND_HEADER_SIZE, command);		
 	while (left > MYSQLND_MAX_PACKET_SIZE) {
 		size_t body_size = MYSQLND_MAX_PACKET_SIZE;
 
 		int3store(safe_storage, MYSQLND_MAX_PACKET_SIZE);
-		int1store(safe_storage + 3, net->packet_no);
+		int1store(safe_storage + 3, net->packet_no);		
 		net->packet_no++;
 		
 		ret = php_stream_write(net->stream, (char *)safe_storage, header_len);
@@ -498,8 +465,8 @@ mysqlnd_read_header(MYSQLND *conn, mysqlnd_packet_header *header TSRMLS_DC)
 	DBG_ERR_FMT("Packets out of order. Expected %d received %d. Packet size=%d",
 				net->packet_no, header->packet_no, header->size);
 
-	php_error(E_WARNING, "Packets out of order. Expected %d received %d. Packet size="MYSQLND_SZ_T_SPEC,
-			  net->packet_no, header->packet_no, header->size);
+	php_error(E_WARNING, "Packets out of order. Expected %d received %d. Packet size=%d. PID=%d",
+			  net->packet_no, header->packet_no, header->size, getpid());
 	DBG_RETURN(FAIL);
 }
 /* }}} */
@@ -567,7 +534,7 @@ php_mysqlnd_greet_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_greet_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "greeting", PROT_GREET_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "greeting");
 
 	packet->protocol_version = uint1korr(p);
 	p++;
@@ -584,7 +551,7 @@ php_mysqlnd_greet_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 		*/
 		if (packet->error_no == 1040) {
 			memcpy(packet->sqlstate, "08004", MYSQLND_SQLSTATE_LENGTH);
-		}
+		}							 
 		DBG_RETURN(PASS);
 	}
 
@@ -615,7 +582,7 @@ php_mysqlnd_greet_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 	if (p - buf < packet->header.size) {
 		/* scramble_buf is split into two parts */
 		memcpy(packet->scramble_buf + SCRAMBLE_LENGTH_323,
-				p, SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
+		   		p, SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
 	} else {
 		packet->pre41 = TRUE;
 	}
@@ -628,8 +595,8 @@ php_mysqlnd_greet_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("GREET packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "GREET packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
-						 p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "GREET packet %d bytes shorter than expected. PID=%d",
+						 p - begin - packet->header.size, getpid());
 	}
 
 	DBG_RETURN(PASS);
@@ -662,7 +629,7 @@ void php_mysqlnd_greet_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
 static
 void php_mysqlnd_crypt(zend_uchar *buffer, const zend_uchar *s1, const zend_uchar *s2, size_t len)
 {
-	const zend_uchar *s1_end = s1 + len;
+	const unsigned char *s1_end = s1 + len;
 	while (s1 < s1_end) {
 		*buffer++= *s1++ ^ *s2++;
 	}
@@ -675,8 +642,8 @@ void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const sc
 						  const zend_uchar * const password)
 {
 	PHP_SHA1_CTX context;
-	zend_uchar sha1[SHA1_MAX_LENGTH];
-	zend_uchar sha2[SHA1_MAX_LENGTH];
+	unsigned char sha1[SHA1_MAX_LENGTH];
+	unsigned char sha2[SHA1_MAX_LENGTH];
 	
 
 	/* Phase 1: hash password */
@@ -686,17 +653,17 @@ void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const sc
 
 	/* Phase 2: hash sha1 */
 	PHP_SHA1Init(&context);
-	PHP_SHA1Update(&context, (zend_uchar*)sha1, SHA1_MAX_LENGTH);
+	PHP_SHA1Update(&context, (unsigned char*)sha1, SHA1_MAX_LENGTH);
 	PHP_SHA1Final(sha2, &context);
 
 	/* Phase 3: hash scramble + sha2 */
 	PHP_SHA1Init(&context);
 	PHP_SHA1Update(&context, scramble, SCRAMBLE_LENGTH);
-	PHP_SHA1Update(&context, (zend_uchar*)sha2, SHA1_MAX_LENGTH);
+	PHP_SHA1Update(&context, (unsigned char*)sha2, SHA1_MAX_LENGTH);
 	PHP_SHA1Final(buffer, &context);
 
 	/* let's crypt buffer now */
-	php_mysqlnd_crypt(buffer, (const zend_uchar *)buffer, (const zend_uchar *)sha1, SHA1_MAX_LENGTH);
+	php_mysqlnd_crypt(buffer, (const uchar *)buffer, (const uchar *)sha1, SHA1_MAX_LENGTH);
 }
 /* }}} */
 
@@ -744,7 +711,8 @@ size_t php_mysqlnd_auth_write(void *_packet, MYSQLND *conn TSRMLS_DC)
 		/* In 4.1 we use CLIENT_SECURE_CONNECTION and thus the len of the buf should be passed */
 		int1store(p, 20);
 		p++;
-		php_mysqlnd_scramble((zend_uchar*)p, packet->server_scramble_buf, (zend_uchar*)packet->password);
+		php_mysqlnd_scramble((unsigned char*)p, packet->server_scramble_buf,
+							 (unsigned char *)packet->password);
 		p+= 20;
 	} else {
 		/* Zero length */
@@ -787,7 +755,7 @@ php_mysqlnd_ok_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_ok_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "OK", PROT_OK_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "OK");
 
 	/* Should be always 0x0 or 0xFF for error */
 	packet->field_count = uint1korr(p);
@@ -824,8 +792,8 @@ php_mysqlnd_ok_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "OK packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
-						 p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "OK packet %d bytes shorter than expected. PID=%d",
+						 p - begin - packet->header.size, getpid());
 	}
 
 	DBG_RETURN(PASS);
@@ -866,7 +834,7 @@ php_mysqlnd_eof_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_eof_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "EOF", PROT_EOF_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "EOF");
 
 	/* Should be always 0xFE */
 	packet->field_count = uint1korr(p);
@@ -897,8 +865,8 @@ php_mysqlnd_eof_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("EOF packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "EOF packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
-						 p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "EOF packet %d bytes shorter than expected. PID=%d",
+						 p - begin - packet->header.size, getpid());
 	}
 	
 	DBG_INF_FMT("EOF packet: fields=%d status=%d warnings=%d",
@@ -939,8 +907,6 @@ size_t php_mysqlnd_cmd_write(void *_packet, MYSQLND *conn TSRMLS_DC)
 	if (error_reporting) {
 		EG(error_reporting) = 0;
 	}
-
-	MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_PACKETS_SENT_CMD);
 	
 #ifdef MYSQLND_DO_WIRE_CHECK_BEFORE_COMMAND
 	php_mysqlnd_consume_uneaten_data(conn, packet->command TSRMLS_CC);
@@ -1006,7 +972,7 @@ php_mysqlnd_rset_header_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_rset_header_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "resultset header", PROT_RSET_HEADER_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "resultset header");
 
 	/*
 	  Don't increment. First byte is 0xFF on error, but otherwise is starting byte
@@ -1062,8 +1028,8 @@ php_mysqlnd_rset_header_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 	}
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("RSET_HEADER packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "GREET packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
-						 p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "GREET packet %d bytes shorter than expected. PID=%d",
+						 p - begin - packet->header.size, getpid());
 	}
 
 	DBG_RETURN(PASS);
@@ -1120,7 +1086,7 @@ php_mysqlnd_rset_field_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_rset_field_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "field", PROT_RSET_FLD_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "field");
 
 	if (packet->skip_parsing) {
 		DBG_RETURN(PASS);
@@ -1202,8 +1168,8 @@ php_mysqlnd_rset_field_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("RSET field packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Result set field packet "MYSQLND_SZ_T_SPEC" bytes "
-				 		"shorter than expected", p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Result set field packet %d bytes "
+						 "shorter than expected. PID=%d", p - begin - packet->header.size, getpid());
 	}
 
 	root_ptr = meta->root = mnd_emalloc(total_len);
@@ -1280,7 +1246,7 @@ void php_mysqlnd_rset_field_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
 
 static enum_func_status
 php_mysqlnd_read_row_ex(MYSQLND *conn, MYSQLND_MEMORY_POOL_CHUNK **buffer,
-						uint64_t *data_size, zend_bool persistent_alloc,
+						uint64 *data_size, zend_bool persistent_alloc,
 						unsigned int prealloc_more_bytes TSRMLS_DC)
 {
 	enum_func_status ret = PASS;
@@ -1335,7 +1301,7 @@ php_mysqlnd_read_row_ex(MYSQLND *conn, MYSQLND_MEMORY_POOL_CHUNK **buffer,
 
 		if (!mysqlnd_read_body(conn, p, header.size TSRMLS_CC)) {
 			DBG_ERR("Empty row packet body");
-			php_error(E_WARNING, "Empty row packet body");
+			php_error(E_WARNING, "Empty row packet body. PID=%d", getpid());
 			ret = FAIL;
 			break;
 		}
@@ -1355,7 +1321,7 @@ php_mysqlnd_read_row_ex(MYSQLND *conn, MYSQLND_MEMORY_POOL_CHUNK **buffer,
 
 /* {{{ php_mysqlnd_rowp_read_binary_protocol */
 void php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
-										   unsigned int field_count, MYSQLND_FIELD *fields_metadata,
+										   uint field_count, MYSQLND_FIELD *fields_metadata,
 										   MYSQLND *conn TSRMLS_DC)
 {
 	int i;
@@ -1400,46 +1366,10 @@ void php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffe
 		if (*null_ptr & bit) {
 			DBG_INF("It's null");
 			ZVAL_NULL(*current_field);
-			MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_BINARY_TYPE_FETCHED_NULL);
 		} else {
 			enum_mysqlnd_field_types type = fields_metadata[i].type;
 			mysqlnd_ps_fetch_functions[type].func(*current_field, &fields_metadata[i],
 												  0, &p, as_unicode TSRMLS_CC);
-
-			if (MYSQLND_G(collect_statistics)) {
-				enum_mysqlnd_collected_stats statistic;
-				switch (fields_metadata[i].type) {
-					case MYSQL_TYPE_DECIMAL:	statistic = STAT_BINARY_TYPE_FETCHED_DECIMAL; break;
-					case MYSQL_TYPE_TINY:		statistic = STAT_BINARY_TYPE_FETCHED_INT8; break;
-					case MYSQL_TYPE_SHORT:		statistic = STAT_BINARY_TYPE_FETCHED_INT16; break;
-					case MYSQL_TYPE_LONG:		statistic = STAT_BINARY_TYPE_FETCHED_INT32; break;
-					case MYSQL_TYPE_FLOAT:		statistic = STAT_BINARY_TYPE_FETCHED_FLOAT; break;
-					case MYSQL_TYPE_DOUBLE:		statistic = STAT_BINARY_TYPE_FETCHED_DOUBLE; break;
-					case MYSQL_TYPE_NULL:		statistic = STAT_BINARY_TYPE_FETCHED_NULL; break;
-					case MYSQL_TYPE_TIMESTAMP:	statistic = STAT_BINARY_TYPE_FETCHED_TIMESTAMP; break;
-					case MYSQL_TYPE_LONGLONG:	statistic = STAT_BINARY_TYPE_FETCHED_INT64; break;
-					case MYSQL_TYPE_INT24:		statistic = STAT_BINARY_TYPE_FETCHED_INT24; break;
-					case MYSQL_TYPE_DATE:		statistic = STAT_BINARY_TYPE_FETCHED_DATE; break;
-					case MYSQL_TYPE_TIME:		statistic = STAT_BINARY_TYPE_FETCHED_TIME; break;
-					case MYSQL_TYPE_DATETIME:	statistic = STAT_BINARY_TYPE_FETCHED_DATETIME; break;
-					case MYSQL_TYPE_YEAR:		statistic = STAT_BINARY_TYPE_FETCHED_YEAR; break;
-					case MYSQL_TYPE_NEWDATE:	statistic = STAT_BINARY_TYPE_FETCHED_DATE; break;
-					case MYSQL_TYPE_VARCHAR:	statistic = STAT_BINARY_TYPE_FETCHED_STRING; break;
-					case MYSQL_TYPE_BIT:		statistic = STAT_BINARY_TYPE_FETCHED_BIT; break;
-					case MYSQL_TYPE_NEWDECIMAL:	statistic = STAT_BINARY_TYPE_FETCHED_DECIMAL; break;
-					case MYSQL_TYPE_ENUM:		statistic = STAT_BINARY_TYPE_FETCHED_ENUM; break;
-					case MYSQL_TYPE_SET:		statistic = STAT_BINARY_TYPE_FETCHED_SET; break;
-					case MYSQL_TYPE_TINY_BLOB:	statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_MEDIUM_BLOB:statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_LONG_BLOB:	statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_BLOB:		statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_VAR_STRING:	statistic = STAT_BINARY_TYPE_FETCHED_STRING; break;
-					case MYSQL_TYPE_STRING:		statistic = STAT_BINARY_TYPE_FETCHED_STRING; break;
-					case MYSQL_TYPE_GEOMETRY:	statistic = STAT_BINARY_TYPE_FETCHED_GEOMETRY; break;
-					default: statistic = STAT_BINARY_TYPE_FETCHED_OTHER; break;
-				}			
-				MYSQLND_INC_CONN_STATISTIC(&conn->stats, statistic);
-			}
 		}
 		if (!((bit<<=1) & 255)) {
 			bit = 1;	/* to the following byte */
@@ -1454,7 +1384,7 @@ void php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffe
 
 /* {{{ php_mysqlnd_rowp_read_text_protocol */
 void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
-										 unsigned int field_count, MYSQLND_FIELD *fields_metadata,
+										 uint field_count, MYSQLND_FIELD *fields_metadata,
 										 MYSQLND *conn TSRMLS_DC)
 {
 	int i;
@@ -1465,7 +1395,7 @@ void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer,
 	zend_uchar *bit_area = (zend_uchar*) row_buffer->ptr + data_size + 1; /* we allocate from here */
 	zend_bool as_unicode = conn->options.numeric_and_datetime_as_unicode;
 #ifdef MYSQLND_STRING_TO_INT_CONVERSION
-	zend_bool as_int_or_float = conn->options.int_and_float_native;
+	zend_bool as_int = conn->options.int_and_year_as_int;
 #endif
 
 	DBG_ENTER("php_mysqlnd_rowp_read_text_protocol");
@@ -1513,43 +1443,9 @@ void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer,
 			struct st_mysqlnd_perm_bind perm_bind =
 					mysqlnd_ps_fetch_functions[fields_metadata[i].type];
 #endif
-			if (MYSQLND_G(collect_statistics)) {
-				enum_mysqlnd_collected_stats statistic;
-				switch (fields_metadata[i].type) {
-					case MYSQL_TYPE_DECIMAL:	statistic = STAT_TEXT_TYPE_FETCHED_DECIMAL; break;
-					case MYSQL_TYPE_TINY:		statistic = STAT_TEXT_TYPE_FETCHED_INT8; break;
-					case MYSQL_TYPE_SHORT:		statistic = STAT_TEXT_TYPE_FETCHED_INT16; break;
-					case MYSQL_TYPE_LONG:		statistic = STAT_TEXT_TYPE_FETCHED_INT32; break;
-					case MYSQL_TYPE_FLOAT:		statistic = STAT_TEXT_TYPE_FETCHED_FLOAT; break;
-					case MYSQL_TYPE_DOUBLE:		statistic = STAT_TEXT_TYPE_FETCHED_DOUBLE; break;
-					case MYSQL_TYPE_NULL:		statistic = STAT_TEXT_TYPE_FETCHED_NULL; break;
-					case MYSQL_TYPE_TIMESTAMP:	statistic = STAT_TEXT_TYPE_FETCHED_TIMESTAMP; break;
-					case MYSQL_TYPE_LONGLONG:	statistic = STAT_TEXT_TYPE_FETCHED_INT64; break;
-					case MYSQL_TYPE_INT24:		statistic = STAT_TEXT_TYPE_FETCHED_INT24; break;
-					case MYSQL_TYPE_DATE:		statistic = STAT_TEXT_TYPE_FETCHED_DATE; break;
-					case MYSQL_TYPE_TIME:		statistic = STAT_TEXT_TYPE_FETCHED_TIME; break;
-					case MYSQL_TYPE_DATETIME:	statistic = STAT_TEXT_TYPE_FETCHED_DATETIME; break;
-					case MYSQL_TYPE_YEAR:		statistic = STAT_TEXT_TYPE_FETCHED_YEAR; break;
-					case MYSQL_TYPE_NEWDATE:	statistic = STAT_TEXT_TYPE_FETCHED_DATE; break;
-					case MYSQL_TYPE_VARCHAR:	statistic = STAT_TEXT_TYPE_FETCHED_STRING; break;
-					case MYSQL_TYPE_BIT:		statistic = STAT_TEXT_TYPE_FETCHED_BIT; break;
-					case MYSQL_TYPE_NEWDECIMAL:	statistic = STAT_TEXT_TYPE_FETCHED_DECIMAL; break;
-					case MYSQL_TYPE_ENUM:		statistic = STAT_TEXT_TYPE_FETCHED_ENUM; break;
-					case MYSQL_TYPE_SET:		statistic = STAT_TEXT_TYPE_FETCHED_SET; break;
-					case MYSQL_TYPE_TINY_BLOB:	statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_MEDIUM_BLOB:statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_LONG_BLOB:	statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_BLOB:		statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
-					case MYSQL_TYPE_VAR_STRING:	statistic = STAT_TEXT_TYPE_FETCHED_STRING; break;
-					case MYSQL_TYPE_STRING:		statistic = STAT_TEXT_TYPE_FETCHED_STRING; break;
-					case MYSQL_TYPE_GEOMETRY:	statistic = STAT_TEXT_TYPE_FETCHED_GEOMETRY; break;
-					default: statistic = STAT_TEXT_TYPE_FETCHED_OTHER; break;
-				}			
-				MYSQLND_INC_CONN_STATISTIC(&conn->stats, statistic);
-			}
 
 #ifdef MYSQLND_STRING_TO_INT_CONVERSION
-			if (as_int_or_float && perm_bind.php_type == IS_LONG &&
+			if (as_int && perm_bind.php_type == IS_LONG &&
 				perm_bind.pack_len <= SIZEOF_LONG)
 			{
 				zend_uchar save = *(p + len);
@@ -1558,44 +1454,28 @@ void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer,
 				if (perm_bind.pack_len < SIZEOF_LONG)
 				{
 					/* direct conversion */
-					int64_t v =
-#ifndef PHP_WIN32
-						atoll((char *) p);
-#else
-						_atoi64((char *) p);
-#endif
+					int64 v = atoll((char *) p);
 					ZVAL_LONG(*current_field, v);
 				} else {
-					uint64_t v =
-#ifndef PHP_WIN32
-						(uint64_t) atoll((char *) p);
-#else
-						(uint64_t) _atoi64((char *) p);
-#endif
-					zend_bool uns = fields_metadata[i].flags & UNSIGNED_FLAG? TRUE:FALSE;
+					uint64 v = (uint64) atoll((char *) p);
+					zend_bool uns = packet->fields_metadata[i].flags & UNSIGNED_FLAG? TRUE:FALSE;
 					/* We have to make it ASCIIZ temporarily */
 #if SIZEOF_LONG==8
 					if (uns == TRUE && v > 9223372036854775807L)
 #elif SIZEOF_LONG==4
 					if ((uns == TRUE && v > L64(2147483647)) || 
-						(uns == FALSE && (( L64(2147483647) < (int64_t) v) ||
-						(L64(-2147483648) > (int64_t) v))))
+						(uns == FALSE && (( L64(2147483647) < (int64) v) ||
+						(L64(-2147483648) > (int64) v))))
 #endif /* SIZEOF */
 					{
 						ZVAL_STRINGL(*current_field, (char *)p, len, 0);
 					} else {
-						ZVAL_LONG(*current_field, (int64_t)v);
+						ZVAL_LONG(*current_field, (int64)v);
 					}
 				}
 				*(p + len) = save;
-			} else if (as_int_or_float && perm_bind.php_type == IS_DOUBLE) {
-				zend_uchar save = *(p + len);
-				/* We have to make it ASCIIZ temporarily */
-				*(p + len) = '\0';
-				ZVAL_DOUBLE(*current_field, atof((char *) p));
-				*(p + len) = save;
 			} else
-#endif /* MYSQLND_STRING_TO_INT_CONVERSION */
+#endif
 			if (fields_metadata[i].type == MYSQL_TYPE_BIT) {
 				/*
 				  BIT fields are specially handled. As they come as bit mask, we have
@@ -1615,7 +1495,8 @@ void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer,
 				*/
 				p -= len;
 				if (Z_TYPE_PP(current_field) == IS_LONG) {
-					bit_area += 1 + sprintf((char *)start, "%ld", Z_LVAL_PP(current_field));
+					bit_area += 1 + sprintf((char *)start, MYSQLND_LLU_SPEC,
+											(int64) Z_LVAL_PP(current_field));
 #if PHP_MAJOR_VERSION >= 6
 					if (as_unicode) {
 						ZVAL_UTF8_STRINGL(*current_field, start, bit_area - start - 1, 0);
@@ -1693,7 +1574,7 @@ void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer,
 				if (Z_TYPE_P(*current_field) == IS_STRING) {
 					((mysqlnd_zval *) obj)->point_type = MYSQLND_POINTS_INT_BUFFER;
 				} else {
-					((mysqlnd_zval *) obj)->point_type = MYSQLND_POINTS_EXT_BUFFER;
+					((mysqlnd_zval *) obj)->point_type = MYSQLND_POINTS_EXT_BUFFER;					
 				}
 			}
 #endif
@@ -1725,7 +1606,7 @@ php_mysqlnd_rowp_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 	size_t old_chunk_size = net->stream->chunk_size;
 	php_mysql_packet_row *packet= (php_mysql_packet_row *) _packet;
 	size_t post_alloc_for_bit_fields = 0;
-	uint64_t data_size = 0;
+	uint64 data_size = 0;
 
 	DBG_ENTER("php_mysqlnd_rowp_read");
 
@@ -1741,10 +1622,6 @@ php_mysqlnd_rowp_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 	if (FAIL == ret) {
 		goto end;
 	}
-	MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats, packet_type_to_statistic_byte_count[PROT_ROW_PACKET],
-										MYSQLND_HEADER_SIZE + packet->header.size,
-										packet_type_to_statistic_packet_count[PROT_ROW_PACKET],
-										1);
 
 	/* packet->row_buffer->ptr is of size 'data_size + 1' */
 	packet->header.size = data_size;
@@ -1850,7 +1727,7 @@ php_mysqlnd_stats_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_stats_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "statistics", PROT_STATS_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "statistics");
 
 	packet->message = mnd_pemalloc(packet->header.size + 1, conn->persistent);
 	memcpy(packet->message, buf, packet->header.size);
@@ -1895,7 +1772,7 @@ php_mysqlnd_prepare_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_prepare_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "prepare", PROT_PREPARE_RESP_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "prepare");
 	
 	data_size = packet->header.size;
 	packet->error_code = uint1korr(p);
@@ -1915,7 +1792,7 @@ php_mysqlnd_prepare_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 		data_size != PREPARE_RESPONSE_SIZE_50 &&
 		!(data_size > PREPARE_RESPONSE_SIZE_50)) {
 		DBG_ERR_FMT("Wrong COM_STMT_PREPARE response size. Received %d", data_size);
-		php_error(E_WARNING, "Wrong COM_STMT_PREPARE response size. Received %d", data_size);
+		php_error(E_WARNING, "Wrong COM_STMT_PREPARE response size. Received %d. PID=%d", data_size, getpid());
 		DBG_RETURN(FAIL);
 	}
 
@@ -1941,8 +1818,8 @@ php_mysqlnd_prepare_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("PREPARE packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "PREPARE packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
-						 p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "PREPARE packet %d bytes shorter than expected. PID=%d",
+						 p - begin - packet->header.size, getpid());
 	}
 
 	DBG_RETURN(PASS);
@@ -1974,7 +1851,7 @@ php_mysqlnd_chg_user_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 
 	DBG_ENTER("php_mysqlnd_chg_user_read");
 
-	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "change user response", PROT_CHG_USER_PACKET);
+	PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "change user response ");
 
 	/*
 	  Don't increment. First byte is 0xFF on error, but otherwise is starting byte
@@ -2001,8 +1878,8 @@ php_mysqlnd_chg_user_read(void *_packet, MYSQLND *conn TSRMLS_DC)
 	}
 	if (p - begin > packet->header.size) {
 		DBG_ERR_FMT("CHANGE_USER packet %d bytes shorter than expected", p - begin - packet->header.size);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "CHANGE_USER packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
-						 p - begin - packet->header.size);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "CHANGE_USER packet %d bytes shorter than expected. PID=%d",
+						 p - begin - packet->header.size, getpid());
 	}
 
 	DBG_RETURN(PASS);
diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.h b/ext/mysqlnd/mysqlnd_wireprotocol.h
index 71af6e11c9..d27baac85b 100644
--- a/ext/mysqlnd/mysqlnd_wireprotocol.h
+++ b/ext/mysqlnd/mysqlnd_wireprotocol.h
@@ -27,6 +27,10 @@
 
 #define MYSQLND_NULL_LENGTH	(unsigned long) ~0
 
+typedef zend_uchar	mysqlnd_1b;
+typedef zend_ushort mysqlnd_2b;
+typedef zend_uint	mysqlnd_4b;
+
 /* Used in mysqlnd_debug.c */
 extern char * mysqlnd_read_header_name;
 extern char * mysqlnd_read_body_name;
@@ -133,19 +137,19 @@ typedef struct st_mysqlnd_packet_header {
 /* Server greets the client */
 typedef struct st_php_mysql_packet_greet {
 	mysqlnd_packet_header		header;
-	uint8_t		protocol_version;
-	char		*server_version;
-	uint32_t	thread_id;
-	zend_uchar	scramble_buf[SCRAMBLE_LENGTH];
+	mysqlnd_1b		protocol_version;
+	char			*server_version;
+	mysqlnd_4b		thread_id;
+	zend_uchar		scramble_buf[SCRAMBLE_LENGTH];
 	/* 1 byte pad */
-	uint16_t	server_capabilities;
-	uint8_t		charset_no;
-	uint16_t	server_status;
+	mysqlnd_2b		server_capabilities;
+	mysqlnd_1b		charset_no;
+	mysqlnd_2b		server_status;
 	/* 13 byte pad*/
-	zend_bool	pre41;
+	zend_bool		pre41;
 	/* If error packet, we use these */
-	char 		error[MYSQLND_ERRMSG_SIZE+1];
-	char 		sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
+	char 			error[MYSQLND_ERRMSG_SIZE+1];
+	char 			sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
 	unsigned int 	error_no;
 } php_mysql_packet_greet;
 
@@ -153,9 +157,9 @@ typedef struct st_php_mysql_packet_greet {
 /* Client authenticates */
 typedef struct st_php_mysql_packet_auth {
 	mysqlnd_packet_header		header;
-	uint32_t	client_flags;
-	uint32_t	max_packet_size;
-	uint8_t	charset_no;
+	mysqlnd_4b	client_flags;
+	uint32		max_packet_size;
+	mysqlnd_1b	charset_no;
 	/* 23 byte pad */
 	const char	*user;
 	/* 8 byte scramble */
@@ -172,16 +176,16 @@ typedef struct st_php_mysql_packet_auth {
 /* OK packet */
 typedef struct st_php_mysql_packet_ok {
 	mysqlnd_packet_header		header;
-	uint8_t		field_count; /* always 0x0 */
-	uint64_t	affected_rows;
-	uint64_t	last_insert_id;
-	uint16_t	server_status;
-	uint16_t	warning_count;
-	char		*message;
-	size_t		message_len;
+	mysqlnd_1b		field_count; /* always 0x0 */
+	uint64	affected_rows;
+	uint64	last_insert_id;
+	mysqlnd_2b		server_status;
+	mysqlnd_2b		warning_count;
+	char			*message;
+	size_t			message_len;
 	/* If error packet, we use these */
-	char 		error[MYSQLND_ERRMSG_SIZE+1];
-	char 		sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
+	char 			error[MYSQLND_ERRMSG_SIZE+1];
+	char 			sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
 	unsigned int 	error_no;
 } php_mysql_packet_ok;
 
@@ -198,12 +202,12 @@ typedef struct st_php_mysql_packet_command {
 /* EOF packet */
 typedef struct st_php_mysql_packet_eof {
 	mysqlnd_packet_header		header;
-	uint8_t		field_count; /* 0xFE */
-	uint16_t	warning_count;
-	uint16_t	server_status;
+	mysqlnd_1b		field_count; /* 0xFE */
+	mysqlnd_2b		warning_count;
+	mysqlnd_2b		server_status;
 	/* If error packet, we use these */
-	char 		error[MYSQLND_ERRMSG_SIZE+1];
-	char 		sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
+	char 			error[MYSQLND_ERRMSG_SIZE+1];
+	char 			sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
 	unsigned int 	error_no;
 } php_mysql_packet_eof;
 /* EOF packet */
@@ -223,13 +227,13 @@ typedef struct st_php_mysql_packet_rset_header {
 	  These are filled if no SELECT query. For SELECT warning_count
 	  and server status are in the last row packet, the EOF packet.
 	*/
-	uint16_t	warning_count;
-	uint16_t	server_status;
-	uint64_t	affected_rows;
-	uint64_t	last_insert_id;
+	mysqlnd_2b			warning_count;
+	mysqlnd_2b			server_status;
+	uint64		affected_rows;
+	uint64		last_insert_id;
 	/* This is for both LOAD DATA or info, when no result set */
-	char		*info_or_local_file;
-	size_t		info_or_local_file_len;
+	char				*info_or_local_file;
+	size_t				info_or_local_file_len;
 	/* If error packet, we use these */
 	mysqlnd_error_info	error_info;
 } php_mysql_packet_rset_header;
@@ -248,15 +252,15 @@ typedef struct st_php_mysql_packet_res_field {
 /* Row packet */
 struct st_php_mysql_packet_row {
 	mysqlnd_packet_header	header;
-	zval		**fields;
-	uint32_t	field_count;
-	zend_bool	eof;
+	zval			**fields;
+	mysqlnd_4b		field_count;
+	zend_bool		eof;
 	/*
 	  These are, of course, only for SELECT in the EOF packet,
 	  which is detected by this packet
 	*/
-	uint16_t	warning_count;
-	uint16_t	server_status;
+	mysqlnd_2b		warning_count;
+	mysqlnd_2b		server_status;
 
 	struct st_mysqlnd_memory_pool_chunk	*row_buffer;
 
@@ -300,10 +304,10 @@ typedef struct st_php_mysql_packet_prepare_response {
 /* Statistics packet */
 typedef struct st_php_mysql_packet_chg_user_resp {
 	mysqlnd_packet_header	header;
-	uint32_t			field_count;
+	mysqlnd_4b			field_count;
 	
 	/* message_len is not part of the packet*/
-	uint16_t			server_capabilities;
+	mysqlnd_2b			server_capabilities;
 	/* If error packet, we use these */
 	mysqlnd_error_info	error_info;
 } php_mysql_packet_chg_user_resp;
@@ -319,16 +323,16 @@ size_t php_mysqlnd_consume_uneaten_data(MYSQLND * const conn, enum php_mysqlnd_s
 void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const scramble, const zend_uchar * const pass);
 
 unsigned long	php_mysqlnd_net_field_length(zend_uchar **packet);
-zend_uchar *	php_mysqlnd_net_store_length(zend_uchar *packet, uint64_t length);
+zend_uchar *	php_mysqlnd_net_store_length(zend_uchar *packet, uint64 length);
 
 extern char * const mysqlnd_empty_string;
 
 
 void php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
-										   unsigned int field_count, MYSQLND_FIELD *fields_metadata, MYSQLND *conn TSRMLS_DC);
+										   uint field_count, MYSQLND_FIELD *fields_metadata, MYSQLND *conn TSRMLS_DC);
 
 void php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
-										 unsigned int field_count, MYSQLND_FIELD *fields_metadata, MYSQLND *conn TSRMLS_DC);
+										 uint field_count, MYSQLND_FIELD *fields_metadata, MYSQLND *conn TSRMLS_DC);
 
 #endif /* MYSQLND_WIREPROTOCOL_H */
 
diff --git a/ext/mysqlnd/php_mysqlnd.c b/ext/mysqlnd/php_mysqlnd.c
index fa0dcf5549..40155ed31e 100644
--- a/ext/mysqlnd/php_mysqlnd.c
+++ b/ext/mysqlnd/php_mysqlnd.c
@@ -107,19 +107,18 @@ PHP_MINFO_FUNCTION(mysqlnd)
 	php_info_print_table_start();
 	php_info_print_table_header(2, "mysqlnd", "enabled");
 	php_info_print_table_row(2, "Version", mysqlnd_get_client_info());
-	snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_cmd_buffer_size));
-	php_info_print_table_row(2, "Command buffer size", buf);
-	snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_read_buffer_size));
-	php_info_print_table_row(2, "Read buffer size", buf);
-	php_info_print_table_row(2, "Collecting statistics", MYSQLND_G(collect_statistics)? "Yes":"No");
-	php_info_print_table_row(2, "Collecting memory statistics", MYSQLND_G(collect_memory_statistics)? "Yes":"No");
-	php_info_print_table_end();
 
 	/* Print client stats */
-	php_info_print_table_start();
 	php_info_print_table_header(2, "Client statistics", "");
 	mysqlnd_get_client_stats(&values);
 	mysqlnd_minfo_print_hash(&values);
+	php_info_print_table_row(2, "Collecting statistics", MYSQLND_G(collect_statistics)? "Yes":"No");
+	php_info_print_table_row(2, "Collecting memory statistics", MYSQLND_G(collect_memory_statistics)? "Yes":"No");
+
+	snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_cmd_buffer_size));
+	php_info_print_table_row(2, "Command buffer size", buf);
+	snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_read_buffer_size));
+	php_info_print_table_row(2, "Read buffer size", buf);
 
 	zval_dtor(&values);
 	php_info_print_table_end();