merge

diff --git a/ext/mysqli/mysqli_api.c b/ext/mysqli/mysqli_api.c
index 5c9cd6e0a29a58cf9382edb151c50b16559d8ffc..f156346990d5294ec0d9e8c606573904736c16b9 100644 (file)
--- a/ext/mysqli/mysqli_api.c
+++ b/ext/mysqli/mysqli_api.c
@@ -166,7 +166,7 @@ int mysqli_stmt_bind_param_do_bind(MY_STMT *stmt, unsigned int argc, unsigned in
        if (argc == start) {
                return PASS;
        }
-       params = safe_emalloc(argc - start, sizeof(MYSQLND_PARAM_BIND), 0);
+       params = mysqlnd_stmt_alloc_param_bind(stmt->stmt);
        for (i = 0; i < (argc - start); i++) {
                zend_uchar type;
                switch (types[i]) {
@@ -190,7 +190,7 @@ int mysqli_stmt_bind_param_do_bind(MY_STMT *stmt, unsigned int argc, unsigned in
                                /* We count parameters from 1 */
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Undefined fieldtype %c (parameter %d)", types[i], i + start + 1);
                                ret = FAIL;
-                               efree(params);
+                               mysqlnd_stmt_free_param_bind(stmt->stmt, params);
                                goto end;
                }
                params[i].zv = *(args[i + start]);
@@ -452,9 +452,7 @@ static int
 mysqli_stmt_bind_result_do_bind(MY_STMT *stmt, zval ***args, unsigned int argc, unsigned int start TSRMLS_DC)
 {
        unsigned int i;
-       MYSQLND_RESULT_BIND *params;
-
-       params = safe_emalloc(argc - start, sizeof(MYSQLND_RESULT_BIND), 0);
+       MYSQLND_RESULT_BIND * params = mysqlnd_stmt_alloc_result_bind(stmt->stmt);
        for (i = 0; i < (argc - start); i++) {
                params[i].zv = *(args[i + start]);
        }

diff --git a/ext/mysqli/mysqli_libmysql.h b/ext/mysqli/mysqli_libmysql.h
index 84fb7c81ae70b5be118c589133154f451f30309d..8e0c735b1a85e65e3af657ac3ad4f0818a180752 100644 (file)
--- a/ext/mysqli/mysqli_libmysql.h
+++ b/ext/mysqli/mysqli_libmysql.h
@@ -31,6 +31,7 @@
 
 #define mysqli_result_is_unbuffered(r)         ((r)->handle && (r)->handle->status == MYSQL_STATUS_USE_RESULT)
 #define mysqli_server_status(c)                                (c)->server_status
+#define mysqli_stmt_get_id(s)                          ((s)->stmt_id)
 #define mysqli_stmt_warning_count(s)           mysql_warning_count((s)->mysql)
 #define mysqli_stmt_server_status(s)           (s)->mysql->server_status
 #define mysqli_stmt_get_connection(s)          (s)->mysql

diff --git a/ext/mysqli/mysqli_mysqlnd.h b/ext/mysqli/mysqli_mysqlnd.h
index 1468ef224446054f4fa3f793f83bba034d44dd85..3072835c55d371df2a22ebc8c62fe8fc2133bb2d 100644 (file)
--- a/ext/mysqli/mysqli_mysqlnd.h
+++ b/ext/mysqli/mysqli_mysqlnd.h
@@ -32,9 +32,10 @@
 
 #define mysqli_result_is_unbuffered(r) ((r)->unbuf)
 #define mysqli_server_status(c)                        (c)->upsert_status.server_status
+#define mysqli_stmt_get_id(s)                  ((s)->data->stmt_id)
 #define mysqli_stmt_warning_count(s)   mysqlnd_stmt_warning_count((s))
-#define mysqli_stmt_server_status(s)   (s)->upsert_status.server_status
-#define mysqli_stmt_get_connection(s)  (s)->conn
+#define mysqli_stmt_server_status(s)   mysqlnd_stmt_server_status((s))
+#define mysqli_stmt_get_connection(s)  (s)->data->conn
 #define mysqli_close(c, how)                   mysqlnd_close((c), (how))
 #define mysqli_stmt_close(c, implicit) mysqlnd_stmt_close((c), (implicit))
 #define mysqli_free_result(r, implicit)        mysqlnd_free_result((r), (implicit))

diff --git a/ext/mysqli/mysqli_prop.c b/ext/mysqli/mysqli_prop.c
index 4b38ac871a23acc96599f539a7526e6cafd24fef..04d746566f91299f1fb55b22a3d9b4e2bf5128fb 100644 (file)
--- a/ext/mysqli/mysqli_prop.c
+++ b/ext/mysqli/mysqli_prop.c
@@ -266,7 +266,7 @@ static int stmt_id_read(mysqli_object *obj, zval **retval TSRMLS_DC)
        if (!p) {
                ZVAL_NULL(*retval);
        } else {
-               ZVAL_LONG(*retval, p->stmt->stmt_id);
+               ZVAL_LONG(*retval, mysqli_stmt_get_id(p->stmt));
        }
        return SUCCESS;
 }

diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c
index 7940cead3a6e9198159201b45291eff4dc28820d..3a31a1d7e6022f34c7ebb3c7eefad61aae452e14 100644 (file)
--- a/ext/mysqlnd/mysqlnd.c
+++ b/ext/mysqlnd/mysqlnd.c
@@ -142,8 +142,8 @@ MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND *conn TSRMLS_DC)
 
        mysqlnd_local_infile_default(conn);
        if (conn->current_result) {
-               conn->current_result->m.free_result_contents(conn->current_result TSRMLS_CC);
-               mnd_efree(conn->current_result);
+               conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC);
+//             mnd_pefree(conn->current_result, conn->current_result->persistent);
                conn->current_result = NULL;
        }
 
@@ -1089,7 +1089,7 @@ MYSQLND_METHOD(mysqlnd_conn, list_fields)(MYSQLND *conn, const char *table, cons
           Prepare for the worst case.
           MyISAM goes to 2500 BIT columns, double it for safety.
         */
-       result = mysqlnd_result_init(5000 TSRMLS_CC);
+       result = mysqlnd_result_init(5000, conn->persistent TSRMLS_CC);
 
 
        if (FAIL == result->m.read_result_metadata(result, conn TSRMLS_CC)) {

diff --git a/ext/mysqlnd/mysqlnd.h b/ext/mysqlnd/mysqlnd.h
index c3b2f6bf4de4a93454541b439be0ddc11a407fa9..1539c7b5255cacd76488d97889a8c9b84ae13a51 100644 (file)
--- a/ext/mysqlnd/mysqlnd.h
+++ b/ext/mysqlnd/mysqlnd.h
@@ -137,60 +137,6 @@ PHPAPI enum_func_status _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQ
 #define mysqlnd_free_result(r,e_or_i)  ((MYSQLND_RES*)r)->m.free_result(((MYSQLND_RES*)(r)), (e_or_i) TSRMLS_CC)
 #define mysqlnd_data_seek(result, row) (result)->m.seek_data((result), (row) TSRMLS_CC)
 
-/*****************************************************************************************************/
-#if defined(MYSQLND_USE_OPTIMISATIONS) && MYSQLND_USE_OPTIMISATIONS == 1
-
-/* Errors */
-#define mysqlnd_errno(conn)                            (conn)->error_info.error_no
-#define mysqlnd_error(conn)                            (conn)->error_info.error
-#define mysqlnd_sqlstate(conn)                 ((conn)->error_info.sqlstate[0] ? conn->error_info.sqlstate:MYSQLND_SQLSTATE_NULL)
-
-/* Charset */
-#define mysqlnd_character_set_name(conn) (conn)->charset->name
-
-/* Simple metadata */
-#define mysqlnd_field_count(conn)              (conn)->field_count
-#define mysqlnd_insert_id(conn)                        (conn)->upsert_status.last_insert_id
-#define mysqlnd_affected_rows(conn)            (conn)->upsert_status.affected_rows
-#define mysqlnd_warning_count(conn)            (conn)->upsert_status.warning_count
-#define mysqlnd_info(conn)                     (conn)->last_message
-#define mysqlnd_get_server_info(conn)  (conn)->server_version
-#define mysqlnd_get_host_info(conn)            (conn)->host_info
-#define mysqlnd_get_proto_info(conn)   (conn)->protocol_version
-#define mysqlnd_thread_id(conn)                        (conn)->thread_id
-
-#define mysqlnd_num_rows(result)               ((result)->stored_data? (result)->stored_data->row_count:0)
-#define mysqlnd_num_fields(result)             (result)->field_count
-
-#define mysqlnd_fetch_lengths(result)  ((result)->m.fetch_lengths? (result)->m.fetch_lengths((result)  TSRMLS_CC) : NULL)
-
-#define mysqlnd_field_seek(result, ofs)                        (result)->m.seek_field((result), (ofs))
-#define mysqlnd_field_tell(result)                             ((result)->meta? (result)->meta->current_field:0)
-#define mysqlnd_fetch_field(result)                            (result)->m.fetch_field((result) TSRMLS_CC)
-#define mysqlnd_fetch_field_direct(result,fnr) (result)->m.fetch_field_direct((result), (fnr) TSRMLS_CC)
-#define mysqlnd_fetch_fields(result)                   (result)->m.fetch_fields((result) TSRMLS_CC)
-
-/* mysqlnd metadata */
-#define mysqlnd_get_client_info()              MYSQLND_VERSION
-#define mysqlnd_get_client_version()   MYSQLND_VERSION_ID
-
-/* PS */
-#define mysqlnd_stmt_insert_id(stmt)           (stmt)->upsert_status.last_insert_id
-#define mysqlnd_stmt_affected_rows(stmt)       (stmt)->upsert_status.affected_rows
-#define mysqlnd_stmt_num_rows(stmt)                    (stmt)->result? mysqlnd_num_rows((stmt)->result):0
-#define mysqlnd_stmt_param_count(stmt)         (stmt)->param_count
-#define mysqlnd_stmt_field_count(stmt)         (stmt)->field_count
-#define mysqlnd_stmt_warning_count(stmt)       (stmt)->upsert_status.warning_count
-#define mysqlnd_stmt_errno(stmt)                       (stmt)->error_info.error_no
-#define mysqlnd_stmt_error(stmt)                       (stmt)->error_info.error
-#define mysqlnd_stmt_sqlstate(stmt)                    ((stmt)->error_info.sqlstate[0] ? (stmt)->error_info.sqlstate:MYSQLND_SQLSTATE_NULL)
-
-
-
-/*****************************************************************************************************/
-#else /* Using plain functions */
-/*****************************************************************************************************/
-
 /* Errors */
 #define mysqlnd_errno(conn)                            (conn)->m->get_error_no((conn) TSRMLS_CC)
 #define mysqlnd_error(conn)                            (conn)->m->get_error_str((conn) TSRMLS_CC)
@@ -233,15 +179,16 @@ PHPAPI unsigned int       mysqlnd_get_client_version();
 #define mysqlnd_stmt_param_count(stmt)         (stmt)->m->get_param_count((stmt) TSRMLS_CC)
 #define mysqlnd_stmt_field_count(stmt)         (stmt)->m->get_field_count((stmt) TSRMLS_CC)
 #define mysqlnd_stmt_warning_count(stmt)       (stmt)->m->get_warning_count((stmt) TSRMLS_CC)
+#define mysqlnd_stmt_server_status(stmt)       (stmt)->m->get_server_status((stmt) TSRMLS_CC)
 #define mysqlnd_stmt_errno(stmt)                       (stmt)->m->get_error_no((stmt) TSRMLS_CC)
 #define mysqlnd_stmt_error(stmt)                       (stmt)->m->get_error_str((stmt) TSRMLS_CC)
 #define mysqlnd_stmt_sqlstate(stmt)                    (stmt)->m->get_sqlstate((stmt) TSRMLS_CC)
-#endif /* MYSQLND_USE_OPTIMISATIONS */
-/*****************************************************************************************************/
 
 
 PHPAPI void mysqlnd_efree_param_bind_dtor(MYSQLND_PARAM_BIND * param_bind TSRMLS_DC);
 PHPAPI void mysqlnd_efree_result_bind_dtor(MYSQLND_RESULT_BIND * result_bind TSRMLS_DC);
+PHPAPI void mysqlnd_free_param_bind_dtor(MYSQLND_PARAM_BIND * param_bind TSRMLS_DC);
+PHPAPI void mysqlnd_free_result_bind_dtor(MYSQLND_RESULT_BIND * result_bind TSRMLS_DC);
 
 
 PHPAPI const char * mysqlnd_field_type_name(enum mysqlnd_field_types field_type);
@@ -288,16 +235,18 @@ PHPAPI ulong mysqlnd_old_escape_string(char *newstr, const char *escapestr, size
 #define mysqlnd_stmt_data_seek(stmt, row)      (stmt)->m->seek_data((stmt), (row) TSRMLS_CC)
 #define mysqlnd_stmt_prepare(stmt, q, qlen)    (stmt)->m->prepare((stmt), (q), (qlen) TSRMLS_CC)
 #define mysqlnd_stmt_execute(stmt)                     (stmt)->m->execute((stmt) TSRMLS_CC)
-#define mysqlnd_stmt_send_long_data(s,p,d,l) (s)->m->send_long_data((s), (p), (d), (l) TSRMLS_CC)
-#define mysqlnd_stmt_bind_param(stmt,bind)     (stmt)->m->bind_parameters((stmt), (bind) TSRMLS_CC)
-#define mysqlnd_stmt_bind_one_param(s,n,z,t)   (s)->m->bind_one_parameter((s), (n), (z), (t) TSRMLS_CC)
-#define mysqlnd_stmt_refresh_bind_param(s)     (s)->m->refresh_bind_param((s) TSRMLS_CC)
-#define mysqlnd_stmt_set_param_bind_dtor(s,d)  (s)->m->set_param_bind_dtor((s), (d) TSRMLS_CC)
-#define mysqlnd_stmt_bind_result(stmt,bind)    (stmt)->m->bind_result((stmt), (bind) TSRMLS_CC)
-#define mysqlnd_stmt_bind_one_result(s,no)     (s)->m->bind_one_result((s), (no) TSRMLS_CC)
-#define mysqlnd_stmt_set_result_bind_dtor(s,d) (s)->m->set_result_bind_dtor((s), (d) TSRMLS_CC)
-#define mysqlnd_stmt_param_metadata(stmt)      (stmt)->m->get_parameter_metadata((stmt))
-#define mysqlnd_stmt_result_metadata(stmt)     (stmt)->m->get_result_metadata((stmt) TSRMLS_CC)
+#define mysqlnd_stmt_send_long_data(stmt,p,d,l)        (stmt)->m->send_long_data((stmt), (p), (d), (l) TSRMLS_CC)
+#define mysqlnd_stmt_alloc_param_bind(stmt)                    (stmt)->m->alloc_parameter_bind((stmt) TSRMLS_CC)
+#define mysqlnd_stmt_free_param_bind(stmt,bind)                (stmt)->m->free_parameter_bind((stmt), (bind) TSRMLS_CC)
+#define mysqlnd_stmt_bind_param(stmt,bind)                     (stmt)->m->bind_parameters((stmt), (bind) TSRMLS_CC)
+#define mysqlnd_stmt_bind_one_param(stmt,n,z,t)                (stmt)->m->bind_one_parameter((stmt), (n), (z), (t) TSRMLS_CC)
+#define mysqlnd_stmt_refresh_bind_param(s)                     (s)->m->refresh_bind_param((s) TSRMLS_CC)
+#define mysqlnd_stmt_alloc_result_bind(stmt)           (stmt)->m->alloc_result_bind((stmt) TSRMLS_CC)
+#define mysqlnd_stmt_free_result_bind(stmt,bind)       (stmt)->m->free_result_bind((stmt), (bind) TSRMLS_CC)
+#define mysqlnd_stmt_bind_result(stmt,bind)                    (stmt)->m->bind_result((stmt), (bind) TSRMLS_CC)
+#define mysqlnd_stmt_bind_one_result(s,no)                     (s)->m->bind_one_result((s), (no) TSRMLS_CC)
+#define mysqlnd_stmt_param_metadata(stmt)                      (stmt)->m->get_parameter_metadata((stmt))
+#define mysqlnd_stmt_result_metadata(stmt)                     (stmt)->m->get_result_metadata((stmt) TSRMLS_CC)
 
 #define        mysqlnd_stmt_free_result(stmt)          (stmt)->m->free_result((stmt) TSRMLS_CC)
 #define        mysqlnd_stmt_close(stmt, implicit)      (stmt)->m->dtor((stmt), (implicit) TSRMLS_CC)

diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c
index a22aaa3dcae5a64d0682ea586c3d017b4772fdf7..36ecf4e7d656d302d61aaa2d8372839e4b02247c 100644 (file)
--- a/ext/mysqlnd/mysqlnd_ps.c
+++ b/ext/mysqlnd/mysqlnd_ps.c
@@ -61,8 +61,9 @@ static enum_func_status mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const
 
 /* {{{ mysqlnd_stmt::store_result */
 static MYSQLND_RES *
-MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret;
        MYSQLND *conn = stmt->conn;
        MYSQLND_RES *result;
@@ -78,7 +79,7 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
        if (stmt->cursor_exists) {
                /* Silently convert buffered to unbuffered, for now */
-               DBG_RETURN(stmt->m->use_result(stmt TSRMLS_CC));
+               DBG_RETURN(s->m->use_result(s TSRMLS_CC));
        }
 
        /* Nothing to store for UPSERT/LOAD DATA*/
@@ -90,7 +91,7 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
                DBG_RETURN(NULL);
        }
 
-       stmt->default_rset_handler = stmt->m->store_result;
+       stmt->default_rset_handler = s->m->store_result;
 
        SET_EMPTY_ERROR(stmt->error_info);
        SET_EMPTY_ERROR(stmt->conn->error_info);
@@ -125,8 +126,9 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::get_result */
 static MYSQLND_RES *
-MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND *conn = stmt->conn;
        MYSQLND_RES *result;
 
@@ -140,7 +142,7 @@ MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
        if (stmt->cursor_exists) {
                /* Silently convert buffered to unbuffered, for now */
-               DBG_RETURN(stmt->m->use_result(stmt TSRMLS_CC));
+               DBG_RETURN(s->m->use_result(s TSRMLS_CC));
        }
 
        /* Nothing to store for UPSERT/LOAD DATA*/
@@ -154,7 +156,7 @@ MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
        SET_EMPTY_ERROR(stmt->conn->error_info);
        MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS);
 
-       result = mysqlnd_result_init(stmt->result->field_count TSRMLS_CC);      
+       result = mysqlnd_result_init(stmt->result->field_count, stmt->persistent TSRMLS_CC);    
 
        result->meta = stmt->result->meta->m->clone_metadata(stmt->result->meta, FALSE TSRMLS_CC);
 
@@ -174,8 +176,9 @@ MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::more_results */
 static zend_bool
-MYSQLND_METHOD(mysqlnd_stmt, more_results)(const MYSQLND_STMT * stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, more_results)(const MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::more_results");
        /* (conn->state == CONN_NEXT_RESULT_PENDING) too */
        DBG_RETURN((stmt->conn && (stmt->conn->upsert_status.server_status &
@@ -188,8 +191,9 @@ MYSQLND_METHOD(mysqlnd_stmt, more_results)(const MYSQLND_STMT * stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::next_result */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, next_result)(MYSQLND_STMT * stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, next_result)(MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND *conn = stmt->conn;
 
        DBG_ENTER("mysqlnd_stmt::next_result");
@@ -204,17 +208,18 @@ MYSQLND_METHOD(mysqlnd_stmt, next_result)(MYSQLND_STMT * stmt TSRMLS_DC)
        }
 
        /* Free space for next result */
-       mysqlnd_internal_free_stmt_content(stmt TSRMLS_CC);
+       mysqlnd_internal_free_stmt_content(s TSRMLS_CC);
 
-       DBG_RETURN(mysqlnd_stmt_execute_parse_response(stmt TSRMLS_CC));
+       DBG_RETURN(mysqlnd_stmt_execute_parse_response(s TSRMLS_CC));
 }
 /* }}} */
 
 
 /* {{{ mysqlnd_stmt_skip_metadata */
 static enum_func_status
-mysqlnd_stmt_skip_metadata(MYSQLND_STMT *stmt TSRMLS_DC)
+mysqlnd_stmt_skip_metadata(MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        /* Follows parameter metadata, we have just to skip it, as libmysql does */
        unsigned int i = 0;
        enum_func_status ret = PASS;
@@ -240,8 +245,9 @@ mysqlnd_stmt_skip_metadata(MYSQLND_STMT *stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt_read_prepare_response */
 static enum_func_status
-mysqlnd_stmt_read_prepare_response(MYSQLND_STMT *stmt TSRMLS_DC)
+mysqlnd_stmt_read_prepare_response(MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND_PACKET_PREPARE_RESPONSE * prepare_resp;
        enum_func_status ret = PASS;
 
@@ -274,8 +280,9 @@ done:
 
 /* {{{ mysqlnd_stmt_prepare_read_eof */
 static enum_func_status
-mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT *stmt TSRMLS_DC)
+mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND_PACKET_EOF * fields_eof;
        enum_func_status ret;
 
@@ -287,7 +294,7 @@ mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT *stmt TSRMLS_DC)
                if (stmt->result) {
                        stmt->result->m.free_result_contents(stmt->result TSRMLS_CC);
                        mnd_efree(stmt->result);
-                       memset(stmt, 0, sizeof(MYSQLND_STMT));
+                       memset(stmt, 0, sizeof(MYSQLND_STMT_DATA));
                        stmt->state = MYSQLND_STMT_INITTED;
                }
        } else {
@@ -304,9 +311,11 @@ mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT *stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::prepare */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * const query, unsigned int query_len TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const s, const char * const query, unsigned int query_len TSRMLS_DC)
 {
-       MYSQLND_STMT *stmt_to_prepare = stmt;
+       MYSQLND_STMT_DATA * stmt = s->data;
+       MYSQLND_STMT * s_to_prepare = s;
+       MYSQLND_STMT_DATA * stmt_to_prepare = stmt;
 
        DBG_ENTER("mysqlnd_stmt::prepare");
        DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
@@ -321,8 +330,8 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * co
                /* See if we have to clean the wire */
                if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
                        /* Do implicit use_result and then flush the result */
-                       stmt->default_rset_handler = stmt->m->use_result;
-                       stmt->default_rset_handler(stmt TSRMLS_CC);
+                       stmt->default_rset_handler = s->m->use_result;
+                       stmt->default_rset_handler(s TSRMLS_CC);
                }
                /* No 'else' here please :) */
                if (stmt->state > MYSQLND_STMT_WAITING_USE_OR_STORE) {
@@ -332,18 +341,19 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * co
                  Create a new test statement, which we will prepare, but if anything
                  fails, we will scrap it.
                */
-               stmt_to_prepare = mysqlnd_stmt_init(stmt->conn);
+               s_to_prepare = mysqlnd_stmt_init(stmt->conn);
+               stmt_to_prepare = s_to_prepare->data;
        }
 
-       if (FAIL == stmt_to_prepare->conn->m->simple_command(stmt_to_prepare->conn, COM_STMT_PREPARE, query,
-                                                                                                                       query_len, PROT_LAST, FALSE, TRUE TSRMLS_CC) ||
-               FAIL == mysqlnd_stmt_read_prepare_response(stmt_to_prepare TSRMLS_CC)) {
+       if (FAIL == stmt_to_prepare->conn->m->simple_command(stmt_to_prepare->conn, COM_STMT_PREPARE, query, query_len, PROT_LAST, FALSE, TRUE TSRMLS_CC) ||
+               FAIL == mysqlnd_stmt_read_prepare_response(s_to_prepare TSRMLS_CC))
+       {
                goto fail;
        }
 
        if (stmt_to_prepare->param_count) {
-               if (FAIL == mysqlnd_stmt_skip_metadata(stmt_to_prepare TSRMLS_CC) ||
-                       FAIL == mysqlnd_stmt_prepare_read_eof(stmt_to_prepare TSRMLS_CC))
+               if (FAIL == mysqlnd_stmt_skip_metadata(s_to_prepare TSRMLS_CC) ||
+                       FAIL == mysqlnd_stmt_prepare_read_eof(s_to_prepare TSRMLS_CC))
                {
                        goto fail;
                }
@@ -355,7 +365,7 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * co
          no metadata at prepare.
        */
        if (stmt_to_prepare->field_count) {
-               MYSQLND_RES *result = mysqlnd_result_init(stmt_to_prepare->field_count TSRMLS_CC);
+               MYSQLND_RES * result = mysqlnd_result_init(stmt_to_prepare->field_count, stmt_to_prepare->persistent TSRMLS_CC);
                /* Allocate the result now as it is needed for the reading of metadata */
                stmt_to_prepare->result = result; 
 
@@ -364,19 +374,19 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * co
                result->type = MYSQLND_RES_PS_BUF;
 
                if (FAIL == result->m.read_result_metadata(result, stmt_to_prepare->conn TSRMLS_CC) ||
-                       FAIL == mysqlnd_stmt_prepare_read_eof(stmt_to_prepare TSRMLS_CC)) {
+                       FAIL == mysqlnd_stmt_prepare_read_eof(s_to_prepare TSRMLS_CC)) {
                        goto fail;
                }
        }
 
        if (stmt_to_prepare != stmt) {
                /* Free old buffers, binding and resources on server */
-               stmt->m->net_close(stmt, TRUE TSRMLS_CC);
+               s->m->net_close(s, TRUE TSRMLS_CC);
 
-               memcpy(stmt, stmt_to_prepare, sizeof(MYSQLND_STMT));
+               memcpy(stmt, stmt_to_prepare, sizeof(MYSQLND_STMT_DATA));
 
                /* Now we will have a clean new statement object */
-               mnd_efree(stmt_to_prepare);
+               mnd_pefree(stmt_to_prepare, stmt_to_prepare->persistent);
        }
        stmt->state = MYSQLND_STMT_PREPARED;
        DBG_INF("PASS");
@@ -384,7 +394,7 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const stmt, const char * co
 
 fail:
        if (stmt_to_prepare != stmt) {
-               stmt_to_prepare->m->dtor(stmt_to_prepare, TRUE TSRMLS_CC);
+               s_to_prepare->m->dtor(s_to_prepare, TRUE TSRMLS_CC);
        }
        stmt->state = MYSQLND_STMT_INITTED;
 
@@ -396,16 +406,17 @@ fail:
 
 /* {{{ mysqlnd_stmt_execute_parse_response */
 static enum_func_status
-mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const stmt TSRMLS_DC)
+mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret;
-       MYSQLND *conn = stmt->conn;
+       MYSQLND * conn = stmt->conn;
 
        DBG_ENTER("mysqlnd_stmt_execute_parse_response");
 
        CONN_SET_STATE(conn, CONN_QUERY_SENT);
 
-       ret = mysqlnd_query_read_result_set_header(stmt->conn, stmt TSRMLS_CC);
+       ret = mysqlnd_query_read_result_set_header(stmt->conn, s TSRMLS_CC);
        if (ret == FAIL) {
                stmt->error_info = conn->error_info;
                stmt->upsert_status.affected_rows = conn->upsert_status.affected_rows;
@@ -451,7 +462,7 @@ mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const stmt TSRMLS_DC)
                                stmt->cursor_exists = TRUE;
                                CONN_SET_STATE(conn, CONN_READY);
                                /* Only cursor read */
-                               stmt->default_rset_handler = stmt->m->use_result;
+                               stmt->default_rset_handler = s->m->use_result;
                                DBG_INF("use_result");
                        } else if (stmt->flags & CURSOR_TYPE_READ_ONLY) {
                                DBG_INF("asked for cursor but got none");
@@ -466,12 +477,12 @@ mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const stmt TSRMLS_DC)
                                  precached on client and server's resources are freed.
                                */
                                /* preferred is buffered read */
-                               stmt->default_rset_handler = stmt->m->store_result;
+                               stmt->default_rset_handler = s->m->store_result;
                                DBG_INF("store_result");
                        } else {
                                DBG_INF("no cursor");
                                /* preferred is unbuffered read */
-                               stmt->default_rset_handler = stmt->m->use_result;
+                               stmt->default_rset_handler = s->m->use_result;
                                DBG_INF("use_result");
                        }
                }
@@ -485,8 +496,9 @@ mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::execute */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret;
        MYSQLND         *conn = stmt->conn;
        zend_uchar      *request;
@@ -538,8 +550,8 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
                if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
                        DBG_INF("fetching result set header");
                        /* Do implicit use_result and then flush the result */
-                       stmt->default_rset_handler = stmt->m->use_result;
-                       stmt->default_rset_handler(stmt TSRMLS_CC);
+                       stmt->default_rset_handler = s->m->use_result;
+                       stmt->default_rset_handler(s TSRMLS_CC);
                }
 
                if (stmt->state > MYSQLND_STMT_WAITING_USE_OR_STORE) {
@@ -593,7 +605,7 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
                        DBG_RETURN(FAIL);
                }
        }
-       request = mysqlnd_stmt_execute_generate_request(stmt, &request_len, &free_request TSRMLS_CC);
+       request = mysqlnd_stmt_execute_generate_request(s, &request_len, &free_request TSRMLS_CC);
        
        /* support for buffer types should be added here ! */
 
@@ -612,7 +624,7 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
        }
        stmt->execute_count++;
 
-       ret = mysqlnd_stmt_execute_parse_response(stmt TSRMLS_CC);
+       ret = mysqlnd_stmt_execute_parse_response(s TSRMLS_CC);
 
        if (ret == PASS && conn->last_query_type == QUERY_UPSERT && stmt->upsert_status.affected_rows) {
                MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_PS, stmt->upsert_status.affected_rows);
@@ -626,7 +638,8 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const stmt TSRMLS_DC)
 enum_func_status
 mysqlnd_fetch_stmt_row_buffered(MYSQLND_RES *result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
 {
-       MYSQLND_STMT *stmt = (MYSQLND_STMT *) param;
+       MYSQLND_STMT * s = (MYSQLND_STMT *) param;
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND_RES_BUFFERED *set = result->stored_data;
        unsigned int field_count = result->meta->field_count;
 
@@ -722,7 +735,8 @@ static enum_func_status
 mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES *result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
 {
        enum_func_status ret;
-       MYSQLND_STMT *stmt = (MYSQLND_STMT *) param;
+       MYSQLND_STMT * s = (MYSQLND_STMT *) param;
+       MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
        MYSQLND_PACKET_ROW *row_packet = result->row_packet;
 
        DBG_ENTER("mysqlnd_stmt_fetch_row_unbuffered");
@@ -842,8 +856,9 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES *result, void *param, unsigned int
 
 /* {{{ mysqlnd_stmt::use_result */
 static MYSQLND_RES *
-MYSQLND_METHOD(mysqlnd_stmt, use_result)(MYSQLND_STMT *stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, use_result)(MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND_RES *result;
        MYSQLND *conn = stmt->conn;
 
@@ -885,7 +900,8 @@ enum_func_status
 mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
 {
        enum_func_status ret;
-       MYSQLND_STMT *stmt = (MYSQLND_STMT *) param;
+       MYSQLND_STMT * s = (MYSQLND_STMT *) param;
+       MYSQLND_STMT_DATA * stmt = s? s->data : NULL;
        zend_uchar buf[STMT_ID_LENGTH /* statement id */ + 4 /* number of rows to fetch */];
        MYSQLND_PACKET_ROW *row_packet = result->row_packet;
 
@@ -1023,8 +1039,9 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int fla
 
 /* {{{ mysqlnd_stmt::fetch */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const stmt, zend_bool * const fetched_anything TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const s, zend_bool * const fetched_anything TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret;
        DBG_ENTER("mysqlnd_stmt::fetch");
        DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
@@ -1038,7 +1055,7 @@ MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const stmt, zend_bool * const
        } else if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
                /* Execute only once. We have to free the previous contents of user's bound vars */
 
-               stmt->default_rset_handler(stmt TSRMLS_CC);
+               stmt->default_rset_handler(s TSRMLS_CC);
        }
        stmt->state = MYSQLND_STMT_USER_FETCHING;
 
@@ -1065,7 +1082,7 @@ MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const stmt, zend_bool * const
                stmt->result_zvals_separated_once = TRUE;
        }
 
-       ret = stmt->result->m.fetch_row(stmt->result, (void*)stmt, 0, fetched_anything TSRMLS_CC);
+       ret = stmt->result->m.fetch_row(stmt->result, (void*)s, 0, fetched_anything TSRMLS_CC);
        DBG_RETURN(ret);
 }
 /* }}} */
@@ -1073,8 +1090,9 @@ MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const stmt, zend_bool * const
 
 /* {{{ mysqlnd_stmt::reset */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret = PASS;
        zend_uchar cmd_buf[STMT_ID_LENGTH /* statement id */];
 
@@ -1104,7 +1122,7 @@ MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const stmt TSRMLS_DC)
                */
                if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
                        DBG_INF("fetching result set header");
-                       stmt->default_rset_handler(stmt TSRMLS_CC);
+                       stmt->default_rset_handler(s TSRMLS_CC);
                        stmt->state = MYSQLND_STMT_USER_FETCHING;
                }
 
@@ -1138,9 +1156,10 @@ MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::send_long_data */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const stmt, unsigned int param_no,
+MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const s, unsigned int param_no,
                                                                                         const char * const data, unsigned long length TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret = FAIL;
        MYSQLND * conn = stmt->conn;
        zend_uchar *cmd_buf;
@@ -1240,16 +1259,17 @@ MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const stmt, unsigned
 
 /* {{{ mysqlnd_stmt::bind_parameters */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, bind_parameters)(MYSQLND_STMT * const stmt, MYSQLND_PARAM_BIND * const param_bind TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, bind_parameters)(MYSQLND_STMT * const s, MYSQLND_PARAM_BIND * const param_bind TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::bind_param");
        DBG_INF_FMT("stmt=%lu param_count=%u", stmt->stmt_id, stmt->param_count);
 
        if (stmt->state < MYSQLND_STMT_PREPARED) {
                SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
                DBG_ERR("not prepared");
-               if (param_bind && stmt->param_bind_dtor) {
-                       stmt->param_bind_dtor(param_bind TSRMLS_CC);
+               if (param_bind) {
+                       s->m->free_parameter_bind(s, param_bind TSRMLS_CC);
                }
                DBG_RETURN(FAIL);
        }
@@ -1281,8 +1301,8 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_parameters)(MYSQLND_STMT * const stmt, MYSQLND
                                        zval_ptr_dtor(&stmt->param_bind[i].zv);
                                }
                        }
-                       if (stmt->param_bind != param_bind && stmt->param_bind_dtor) {
-                               stmt->param_bind_dtor(stmt->param_bind TSRMLS_CC);
+                       if (stmt->param_bind != param_bind) {
+                               s->m->free_parameter_bind(s, stmt->param_bind TSRMLS_CC);
                        }
                }
 
@@ -1308,9 +1328,10 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_parameters)(MYSQLND_STMT * const stmt, MYSQLND
 
 /* {{{ mysqlnd_stmt::bind_one_parameter */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter)(MYSQLND_STMT * const stmt, unsigned int param_no,
+MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter)(MYSQLND_STMT * const s, unsigned int param_no,
                                                                                                 zval * const zv, zend_uchar type TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::bind_one_parameter");
        DBG_INF_FMT("stmt=%lu param_no=%d param_count=%u type=%d",
                                stmt->stmt_id, param_no, stmt->param_count, type);
@@ -1359,8 +1380,9 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter)(MYSQLND_STMT * const stmt, unsi
 
 /* {{{ mysqlnd_stmt::refresh_bind_param */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, refresh_bind_param)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, refresh_bind_param)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::refresh_bind_param");
        DBG_INF_FMT("stmt=%lu param_count=%u", stmt->stmt_id, stmt->param_count);
 
@@ -1382,32 +1404,20 @@ MYSQLND_METHOD(mysqlnd_stmt, refresh_bind_param)(MYSQLND_STMT * const stmt TSRML
 /* }}} */
 
 
-/* {{{ mysqlnd_stmt::set_bind_param_dtor */
-static void
-MYSQLND_METHOD(mysqlnd_stmt, set_param_bind_dtor)(MYSQLND_STMT * const stmt,
-                                                                                                 void (*param_bind_dtor)(MYSQLND_PARAM_BIND * dtor TSRMLS_DC) TSRMLS_DC)
-{
-       DBG_ENTER("mysqlnd_stmt::set_bind_param_dtor");
-       DBG_INF_FMT("stmt=%p", param_bind_dtor);
-       stmt->param_bind_dtor = param_bind_dtor;
-       DBG_VOID_RETURN;
-}
-/* }}} */
-
-
 /* {{{ mysqlnd_stmt::bind_result */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const stmt,
+MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const s,
                                                                                  MYSQLND_RESULT_BIND * const result_bind TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::bind_result");
        DBG_INF_FMT("stmt=%lu field_count=%u", stmt->stmt_id, stmt->field_count);
 
 
        if (stmt->state < MYSQLND_STMT_PREPARED) {
                SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
-               if (result_bind && stmt->result_bind_dtor) {
-                       stmt->result_bind_dtor(result_bind TSRMLS_CC);
+               if (result_bind) {
+                       s->m->free_result_bind(s, result_bind TSRMLS_CC);
                }
                DBG_ERR("not prepared");
                DBG_RETURN(FAIL);
@@ -1424,7 +1434,7 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const stmt,
                        DBG_RETURN(FAIL);
                }
 
-               mysqlnd_stmt_separate_result_bind(stmt TSRMLS_CC);
+               mysqlnd_stmt_separate_result_bind(s TSRMLS_CC);
                stmt->result_zvals_separated_once = FALSE;
                stmt->result_bind = result_bind;
                for (i = 0; i < stmt->field_count; i++) {
@@ -1438,8 +1448,8 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const stmt,
                        */
                        stmt->result_bind[i].bound = TRUE;
                }
-       } else if (result_bind && stmt->result_bind_dtor) {
-               stmt->result_bind_dtor(result_bind TSRMLS_CC);
+       } else if (result_bind) {
+               s->m->free_result_bind(s, result_bind TSRMLS_CC);
        }
        DBG_INF("PASS");
        DBG_RETURN(PASS);
@@ -1449,8 +1459,9 @@ 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 s, unsigned int param_no TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::bind_result");
        DBG_INF_FMT("stmt=%lu field_count=%u", stmt->stmt_id, stmt->field_count);
 
@@ -1470,7 +1481,7 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_one_result)(MYSQLND_STMT * const stmt, unsigne
        SET_EMPTY_ERROR(stmt->conn->error_info);
 
        if (stmt->field_count) {
-               mysqlnd_stmt_separate_one_result_bind(stmt, param_no TSRMLS_CC);
+               mysqlnd_stmt_separate_one_result_bind(s, param_no TSRMLS_CC);
                /* Guaranteed is that stmt->result_bind is NULL */
                if (!stmt->result_bind) {
                        stmt->result_bind = mnd_ecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND));
@@ -1491,23 +1502,11 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_one_result)(MYSQLND_STMT * const stmt, unsigne
 /* }}} */
 
 
-/* {{{ mysqlnd_stmt::set_bind_result_dtor */
-static void
-MYSQLND_METHOD(mysqlnd_stmt, set_result_bind_dtor)(MYSQLND_STMT * const stmt,
-                                                                                                  void (*result_bind_dtor)(MYSQLND_RESULT_BIND * dtor TSRMLS_DC) TSRMLS_DC)
-{
-       DBG_ENTER("mysqlnd_stmt::set_bind_param_dtor");
-       DBG_INF_FMT("stmt=%p", result_bind_dtor);
-       stmt->result_bind_dtor = result_bind_dtor;
-       DBG_VOID_RETURN;
-}
-/* }}} */
-
-
 /* {{{ mysqlnd_stmt::insert_id */
 static uint64_t
-MYSQLND_METHOD(mysqlnd_stmt, insert_id)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, insert_id)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->upsert_status.last_insert_id;
 }
 /* }}} */
@@ -1515,8 +1514,9 @@ MYSQLND_METHOD(mysqlnd_stmt, insert_id)(const MYSQLND_STMT * const stmt TSRMLS_D
 
 /* {{{ mysqlnd_stmt::affected_rows */
 static uint64_t
-MYSQLND_METHOD(mysqlnd_stmt, affected_rows)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, affected_rows)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->upsert_status.affected_rows;
 }
 /* }}} */
@@ -1524,8 +1524,9 @@ MYSQLND_METHOD(mysqlnd_stmt, affected_rows)(const MYSQLND_STMT * const stmt TSRM
 
 /* {{{ mysqlnd_stmt::num_rows */
 static uint64_t
-MYSQLND_METHOD(mysqlnd_stmt, num_rows)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, num_rows)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->result? mysqlnd_num_rows(stmt->result):0;
 }
 /* }}} */
@@ -1533,17 +1534,29 @@ MYSQLND_METHOD(mysqlnd_stmt, num_rows)(const MYSQLND_STMT * const stmt TSRMLS_DC
 
 /* {{{ mysqlnd_stmt::warning_count */
 static unsigned int
-MYSQLND_METHOD(mysqlnd_stmt, warning_count)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, warning_count)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->upsert_status.warning_count;
 }
 /* }}} */
 
 
+/* {{{ mysqlnd_stmt::server_status */
+static unsigned int
+MYSQLND_METHOD(mysqlnd_stmt, server_status)(const MYSQLND_STMT * const s TSRMLS_DC)
+{
+       MYSQLND_STMT_DATA * stmt = s->data;
+       return stmt->upsert_status.server_status;
+}
+/* }}} */
+
+
 /* {{{ mysqlnd_stmt::field_count */
 static unsigned int
-MYSQLND_METHOD(mysqlnd_stmt, field_count)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, field_count)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->field_count;
 }
 /* }}} */
@@ -1551,8 +1564,9 @@ MYSQLND_METHOD(mysqlnd_stmt, field_count)(const MYSQLND_STMT * const stmt TSRMLS
 
 /* {{{ mysqlnd_stmt::param_count */
 static unsigned int
-MYSQLND_METHOD(mysqlnd_stmt, param_count)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, param_count)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->param_count;
 }
 /* }}} */
@@ -1560,8 +1574,9 @@ MYSQLND_METHOD(mysqlnd_stmt, param_count)(const MYSQLND_STMT * const stmt TSRMLS
 
 /* {{{ mysqlnd_stmt::errno */
 static unsigned int
-MYSQLND_METHOD(mysqlnd_stmt, errno)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, errno)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->error_info.error_no;
 }
 /* }}} */
@@ -1569,8 +1584,9 @@ MYSQLND_METHOD(mysqlnd_stmt, errno)(const MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::error */
 static const char *
-MYSQLND_METHOD(mysqlnd_stmt, error)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, error)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->error_info.error;
 }
 /* }}} */
@@ -1578,8 +1594,9 @@ MYSQLND_METHOD(mysqlnd_stmt, error)(const MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::sqlstate */
 static const char *
-MYSQLND_METHOD(mysqlnd_stmt, sqlstate)(const MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, sqlstate)(const MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->error_info.sqlstate[0] ? stmt->error_info.sqlstate:MYSQLND_SQLSTATE_NULL;
 }
 /* }}} */
@@ -1587,8 +1604,9 @@ MYSQLND_METHOD(mysqlnd_stmt, sqlstate)(const MYSQLND_STMT * const stmt TSRMLS_DC
 
 /* {{{ 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 s, uint64_t row TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        return stmt->result? stmt->result->m.seek_data(stmt->result, row TSRMLS_CC) : FAIL;
 }
 /* }}} */
@@ -1596,8 +1614,9 @@ MYSQLND_METHOD(mysqlnd_stmt, data_seek)(const MYSQLND_STMT * const stmt, uint64_
 
 /* {{{ mysqlnd_stmt::param_metadata */
 static MYSQLND_RES *
-MYSQLND_METHOD(mysqlnd_stmt, param_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, param_metadata)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        if (!stmt->param_count) {
                return NULL;
        }
@@ -1609,8 +1628,9 @@ MYSQLND_METHOD(mysqlnd_stmt, param_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC
 
 /* {{{ mysqlnd_stmt::result_metadata */
 static MYSQLND_RES *
-MYSQLND_METHOD(mysqlnd_stmt, result_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, result_metadata)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND_RES *result;
 
        DBG_ENTER("mysqlnd_stmt::result_metadata");
@@ -1634,7 +1654,7 @@ MYSQLND_METHOD(mysqlnd_stmt, result_metadata)(MYSQLND_STMT * const stmt TSRMLS_D
          In the meantime we don't need a zval cache reference for this fake
          result set, so we don't get one.
        */
-       result = mysqlnd_result_init(stmt->field_count TSRMLS_CC);
+       result = mysqlnd_result_init(stmt->field_count, stmt->persistent TSRMLS_CC);
        result->type = MYSQLND_RES_NORMAL;
        result->m.fetch_row = result->m.fetch_row_normal_unbuffered;
        result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED));
@@ -1649,10 +1669,11 @@ MYSQLND_METHOD(mysqlnd_stmt, result_metadata)(MYSQLND_STMT * const stmt TSRMLS_D
 
 /* {{{ mysqlnd_stmt::attr_set */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, attr_set)(MYSQLND_STMT * const stmt,
+MYSQLND_METHOD(mysqlnd_stmt, attr_set)(MYSQLND_STMT * const s,
                                                                           enum mysqlnd_stmt_attr attr_type,
                                                                           const void * const value TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        unsigned long val = *(unsigned long *) value;
        DBG_ENTER("mysqlnd_stmt::attr_set");
        DBG_INF_FMT("stmt=%lu attr_type=%u value=%lu", stmt->stmt_id, attr_type, val);
@@ -1697,10 +1718,11 @@ MYSQLND_METHOD(mysqlnd_stmt, attr_set)(MYSQLND_STMT * const stmt,
 
 /* {{{ mysqlnd_stmt::attr_get */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, attr_get)(const MYSQLND_STMT * const stmt,
+MYSQLND_METHOD(mysqlnd_stmt, attr_get)(const MYSQLND_STMT * const s,
                                                                           enum mysqlnd_stmt_attr attr_type,
                                                                           void * const value TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::attr_set");
        DBG_INF_FMT("stmt=%lu attr_type=%u", stmt->stmt_id, attr_type);
 
@@ -1725,8 +1747,9 @@ MYSQLND_METHOD(mysqlnd_stmt, attr_get)(const MYSQLND_STMT * const stmt,
 /* free_result() doesn't actually free stmt->result but only the buffers */
 /* {{{ mysqlnd_stmt::free_result */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt::free_result");
        DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
 
@@ -1742,8 +1765,8 @@ MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
        if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
                DBG_INF("fetching result set header");
                /* Do implicit use_result and then flush the result */
-               stmt->default_rset_handler = stmt->m->use_result;
-               stmt->default_rset_handler(stmt TSRMLS_CC);
+               stmt->default_rset_handler = s->m->use_result;
+               stmt->default_rset_handler(s TSRMLS_CC);
        }
 
        if (stmt->state > MYSQLND_STMT_WAITING_USE_OR_STORE) {
@@ -1754,7 +1777,7 @@ MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
                  Separate the bound variables, which point to the result set, then
                  destroy the set.
                */
-               mysqlnd_stmt_separate_result_bind(stmt TSRMLS_CC);
+               mysqlnd_stmt_separate_result_bind(s TSRMLS_CC);
 
                /* Now we can destroy the result set */
                stmt->result->m.free_result_buffers(stmt->result TSRMLS_CC);
@@ -1774,8 +1797,9 @@ MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 
 /* {{{ mysqlnd_stmt_separate_result_bind */
-void mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const stmt TSRMLS_DC)
+void mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        unsigned int i;
 
        DBG_ENTER("mysqlnd_stmt_separate_result_bind");
@@ -1817,9 +1841,7 @@ void mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const stmt TSRMLS_DC)
                        }
                }
        }
-       if (stmt->result_bind_dtor) {
-               stmt->result_bind_dtor(stmt->result_bind TSRMLS_CC);
-       }
+       s->m->free_result_bind(s, stmt->result_bind TSRMLS_CC);
        stmt->result_bind = NULL;
 
        DBG_VOID_RETURN;
@@ -1828,8 +1850,9 @@ 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 s, unsigned int param_no TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_stmt_separate_one_result_bind");
        DBG_INF_FMT("stmt=%lu result_bind=%p field_count=%u param_no=%d",
                                stmt->stmt_id, stmt->result_bind, stmt->field_count, param_no);
@@ -1875,8 +1898,9 @@ void mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const stmt, unsigned i
 
 /* {{{ mysqlnd_internal_free_stmt_content */
 static
-void mysqlnd_internal_free_stmt_content(MYSQLND_STMT * const stmt TSRMLS_DC)
+void mysqlnd_internal_free_stmt_content(MYSQLND_STMT * const s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        DBG_ENTER("mysqlnd_internal_free_stmt_content");
        DBG_INF_FMT("stmt=%lu param_bind=%p param_count=%u",
                                stmt->stmt_id, stmt->param_bind, stmt->param_count);
@@ -1898,9 +1922,7 @@ void mysqlnd_internal_free_stmt_content(MYSQLND_STMT * const stmt TSRMLS_DC)
                                zval_ptr_dtor(&stmt->param_bind[i].zv);
                        }
                }
-               if (stmt->param_bind_dtor) {
-                       stmt->param_bind_dtor(stmt->param_bind TSRMLS_CC);
-               }
+               s->m->free_parameter_bind(s, stmt->param_bind TSRMLS_CC);
                stmt->param_bind = NULL;
        }
 
@@ -1908,7 +1930,7 @@ void mysqlnd_internal_free_stmt_content(MYSQLND_STMT * const stmt TSRMLS_DC)
          First separate the bound variables, which point to the result set, then
          destroy the set.
        */
-       mysqlnd_stmt_separate_result_bind(stmt TSRMLS_CC);
+       mysqlnd_stmt_separate_result_bind(s TSRMLS_CC);
        /* Not every statement has a result set attached */
        if (stmt->result) {
                stmt->result->m.free_result_internal(stmt->result TSRMLS_CC);
@@ -1922,8 +1944,9 @@ void mysqlnd_internal_free_stmt_content(MYSQLND_STMT * const stmt TSRMLS_DC)
 
 /* {{{ mysqlnd_stmt::net_close */
 static enum_func_status
-MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const stmt, zend_bool implicit TSRMLS_DC)
+MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const s, zend_bool implicit TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        MYSQLND * conn = stmt->conn;
        zend_uchar cmd_buf[STMT_ID_LENGTH /* statement id */];
        enum_mysqlnd_collected_stats stat = STAT_LAST;
@@ -1943,7 +1966,7 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const stmt, zend_
                DBG_INF_FMT("stmt->state=%d", stmt->state);
                if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
                        DBG_INF("fetching result set header");
-                       stmt->default_rset_handler(stmt TSRMLS_CC);
+                       stmt->default_rset_handler(s TSRMLS_CC);
                        stmt->state = MYSQLND_STMT_USER_FETCHING;
                }
 
@@ -1952,7 +1975,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(s) && mysqlnd_stmt_next_result(s) == PASS);
        /*
          After this point we are allowed to free the result set,
          as we have cleaned the line
@@ -1985,11 +2008,11 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const stmt, zend_
        }
 
        if (stmt->execute_cmd_buffer.buffer) {
-               mnd_efree(stmt->execute_cmd_buffer.buffer);
+               mnd_pefree(stmt->execute_cmd_buffer.buffer, stmt->persistent);
                stmt->execute_cmd_buffer.buffer = NULL;
        }
 
-       mysqlnd_internal_free_stmt_content(stmt TSRMLS_CC);
+       mysqlnd_internal_free_stmt_content(s TSRMLS_CC);
 
        if (stmt->conn) {
                stmt->conn->m->free_reference(stmt->conn TSRMLS_CC);
@@ -2002,9 +2025,11 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const stmt, zend_
 
 /* {{{ mysqlnd_stmt::dtor */
 static enum_func_status
-MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const stmt, zend_bool implicit TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const s, zend_bool implicit TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        enum_func_status ret;
+       zend_bool persistent = stmt->persistent;
 
        DBG_ENTER("mysqlnd_stmt::dtor");
        DBG_INF_FMT("stmt=%p", stmt);
@@ -2012,8 +2037,9 @@ MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const stmt, zend_bool implicit
        MYSQLND_INC_GLOBAL_STATISTIC(implicit == TRUE?  STAT_STMT_CLOSE_IMPLICIT:
                                                                                                        STAT_STMT_CLOSE_EXPLICIT);
 
-       ret = stmt->m->net_close(stmt, implicit TSRMLS_CC);
-       mnd_efree(stmt);
+       ret = s->m->net_close(s, implicit TSRMLS_CC);
+       mnd_pefree(stmt, persistent);
+       mnd_pefree(s, persistent);
 
        DBG_INF(ret == PASS? "PASS":"FAIL");
        DBG_RETURN(ret);
@@ -2021,6 +2047,49 @@ MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const stmt, zend_bool implicit
 /* }}} */
 
 
+/* {{{ mysqlnd_stmt::alloc_param_bind */
+static MYSQLND_PARAM_BIND *
+MYSQLND_METHOD(mysqlnd_stmt, alloc_param_bind)(MYSQLND_STMT * const s TSRMLS_DC)
+{
+       MYSQLND_STMT_DATA * stmt = s->data;
+       DBG_ENTER("mysqlnd_stmt::alloc_param_bind");
+       DBG_RETURN(pecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND), stmt->persistent));
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_stmt::alloc_result_bind */
+static MYSQLND_RESULT_BIND *
+MYSQLND_METHOD(mysqlnd_stmt, alloc_result_bind)(MYSQLND_STMT * const s TSRMLS_DC)
+{
+       MYSQLND_STMT_DATA * stmt = s->data;
+       DBG_ENTER("mysqlnd_stmt::alloc_result_bind");
+       DBG_RETURN(pecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND), stmt->persistent));
+}
+/* }}} */
+
+
+/* {{{ param_bind::free_parameter_bind */
+PHPAPI void
+MYSQLND_METHOD(mysqlnd_stmt, free_parameter_bind)(MYSQLND_STMT * const s, MYSQLND_PARAM_BIND * param_bind TSRMLS_DC)
+{
+       MYSQLND_STMT_DATA * stmt = s->data;
+       mnd_pefree(param_bind, stmt->persistent);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_stmt::free_result_bind */
+PHPAPI void
+MYSQLND_METHOD(mysqlnd_stmt, free_result_bind)(MYSQLND_STMT * const s, MYSQLND_RESULT_BIND * result_bind TSRMLS_DC)
+{
+       MYSQLND_STMT_DATA * stmt = s->data;
+       mnd_pefree(result_bind, stmt->persistent);
+}
+/* }}} */
+
+
+
 MYSQLND_CLASS_METHODS_START(mysqlnd_stmt)
        MYSQLND_METHOD(mysqlnd_stmt, prepare),
        MYSQLND_METHOD(mysqlnd_stmt, execute),
@@ -2040,10 +2109,8 @@ MYSQLND_CLASS_METHODS_START(mysqlnd_stmt)
        MYSQLND_METHOD(mysqlnd_stmt, bind_parameters),
        MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter),
        MYSQLND_METHOD(mysqlnd_stmt, refresh_bind_param),
-       MYSQLND_METHOD(mysqlnd_stmt, set_param_bind_dtor),
        MYSQLND_METHOD(mysqlnd_stmt, bind_result),
        MYSQLND_METHOD(mysqlnd_stmt, bind_one_result),
-       MYSQLND_METHOD(mysqlnd_stmt, set_result_bind_dtor),
        MYSQLND_METHOD(mysqlnd_stmt, send_long_data),
        MYSQLND_METHOD(mysqlnd_stmt, param_metadata),
        MYSQLND_METHOD(mysqlnd_stmt, result_metadata),
@@ -2061,7 +2128,14 @@ MYSQLND_CLASS_METHODS_START(mysqlnd_stmt)
        MYSQLND_METHOD(mysqlnd_stmt, sqlstate),
 
        MYSQLND_METHOD(mysqlnd_stmt, attr_get),
-       MYSQLND_METHOD(mysqlnd_stmt, attr_set), 
+       MYSQLND_METHOD(mysqlnd_stmt, attr_set),
+
+
+       MYSQLND_METHOD(mysqlnd_stmt, alloc_param_bind),
+       MYSQLND_METHOD(mysqlnd_stmt, alloc_result_bind),
+       MYSQLND_METHOD(mysqlnd_stmt, free_parameter_bind),
+       MYSQLND_METHOD(mysqlnd_stmt, free_result_bind),
+       MYSQLND_METHOD(mysqlnd_stmt, server_status)
 MYSQLND_CLASS_METHODS_END;
 
 
@@ -2069,15 +2143,17 @@ MYSQLND_CLASS_METHODS_END;
 MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC)
 {
        size_t alloc_size = sizeof(MYSQLND_STMT) + mysqlnd_plugin_count() * sizeof(void *);
-       MYSQLND_STMT *stmt = mnd_ecalloc(1, alloc_size);
+       MYSQLND_STMT * ret = mnd_pemalloc(alloc_size, conn->persistent);
+       MYSQLND_STMT_DATA * stmt = ret->data = mnd_pecalloc(1, sizeof(MYSQLND_STMT_DATA), conn->persistent);
 
        DBG_ENTER("_mysqlnd_stmt_init");
        DBG_INF_FMT("stmt=%p", stmt); 
 
-       stmt->m = mysqlnd_stmt_methods;
+       ret->m = mysqlnd_stmt_methods;
+       stmt->persistent = conn->persistent;
        stmt->state = MYSQLND_STMT_INITTED;
        stmt->execute_cmd_buffer.length = 4096;
-       stmt->execute_cmd_buffer.buffer = mnd_emalloc(stmt->execute_cmd_buffer.length);
+       stmt->execute_cmd_buffer.buffer = mnd_pemalloc(stmt->execute_cmd_buffer.length, stmt->persistent);
 
        stmt->prefetch_rows = MYSQLND_DEFAULT_PREFETCH_ROWS;
        /*
@@ -2086,11 +2162,7 @@ MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC)
          or normal query result will close it then.
        */
        stmt->conn = conn->m->get_reference(conn TSRMLS_CC);
-
-       stmt->m->set_param_bind_dtor(stmt, mysqlnd_efree_param_bind_dtor TSRMLS_CC); 
-       stmt->m->set_result_bind_dtor(stmt, mysqlnd_efree_result_bind_dtor TSRMLS_CC); 
-
-       DBG_RETURN(stmt);
+       DBG_RETURN(ret);
 }
 /* }}} */
 
@@ -2108,22 +2180,6 @@ PHPAPI void ** _mysqlnd_plugin_get_plugin_stmt_data(const MYSQLND_STMT * stmt, u
 /* }}} */
 
 
-/* {{{ mysqlnd_efree_param_bind_dtor */
-PHPAPI void
-mysqlnd_efree_param_bind_dtor(MYSQLND_PARAM_BIND * param_bind TSRMLS_DC)
-{
-       mnd_efree(param_bind);
-}
-/* }}} */
-
-
-/* {{{ mysqlnd_efree_result_bind_dtor */
-PHPAPI void
-mysqlnd_efree_result_bind_dtor(MYSQLND_RESULT_BIND * result_bind TSRMLS_DC)
-{
-       mnd_efree(result_bind);
-}
-/* }}} */
 
 /* {{{ _mysqlnd_init_ps_subsystem */
 void _mysqlnd_init_ps_subsystem()

diff --git a/ext/mysqlnd/mysqlnd_ps_codec.c b/ext/mysqlnd/mysqlnd_ps_codec.c
index ec1e05e9a78480e22ca35c6e8d57355b8da8609c..dba749211c5403deaee1220251c11360b9dccb95 100644 (file)
--- a/ext/mysqlnd/mysqlnd_ps_codec.c
+++ b/ext/mysqlnd/mysqlnd_ps_codec.c
@@ -595,9 +595,10 @@ mysqlnd_stmt_copy_it(zval *** copies, zval *original, unsigned int param_count,
 
 /* {{{ mysqlnd_stmt_execute_store_params */
 static void
-mysqlnd_stmt_execute_store_params(MYSQLND_STMT *stmt, zend_uchar **buf, zend_uchar **p,
+mysqlnd_stmt_execute_store_params(MYSQLND_STMT * s, zend_uchar **buf, zend_uchar **p,
                                                                  size_t *buf_len, unsigned int null_byte_offset TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        unsigned int i = 0;
        size_t left = (*buf_len - (*p - *buf));
        size_t data_size = 0;
@@ -784,9 +785,10 @@ mysqlnd_stmt_execute_store_params(MYSQLND_STMT *stmt, zend_uchar **buf, zend_uch
 
 
 /* {{{ mysqlnd_stmt_execute_generate_request */
-zend_uchar* mysqlnd_stmt_execute_generate_request(MYSQLND_STMT *stmt, size_t *request_len,
-                                                                                                 zend_bool *free_buffer TSRMLS_DC)
+zend_uchar* mysqlnd_stmt_execute_generate_request(MYSQLND_STMT * s, size_t *request_len,
+                                                                                                 zend_bool * free_buffer TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s->data;
        zend_uchar      *p = stmt->execute_cmd_buffer.buffer,
                                *cmd_buffer = stmt->execute_cmd_buffer.buffer;
        size_t cmd_buffer_length = stmt->execute_cmd_buffer.length;
@@ -815,7 +817,7 @@ zend_uchar* mysqlnd_stmt_execute_generate_request(MYSQLND_STMT *stmt, size_t *re
        int1store(p, stmt->send_types_to_server); 
        p++;
 
-       mysqlnd_stmt_execute_store_params(stmt, &cmd_buffer, &p, &cmd_buffer_length, null_byte_offset TSRMLS_CC);
+       mysqlnd_stmt_execute_store_params(s, &cmd_buffer, &p, &cmd_buffer_length, null_byte_offset TSRMLS_CC);
 
        *free_buffer = (cmd_buffer != stmt->execute_cmd_buffer.buffer);
        *request_len = (p - cmd_buffer);

diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c
index 1c9af8472bcb4702899cbd1e68a53a1eb5ea91c1..ac3761868b2562a4678150e47944460660a20a2d 100644 (file)
--- a/ext/mysqlnd/mysqlnd_result.c
+++ b/ext/mysqlnd/mysqlnd_result.c
@@ -280,7 +280,7 @@ void mysqlnd_internal_free_result_contents(MYSQLND_RES *result TSRMLS_DC)
        result->m.free_result_buffers(result TSRMLS_CC);
 
        if (result->meta) {
-               result->meta->m->free_metadata(result->meta, FALSE TSRMLS_CC);
+               result->meta->m->free_metadata(result->meta TSRMLS_CC);
                result->meta = NULL;
        }
 
@@ -301,7 +301,7 @@ void mysqlnd_internal_free_result(MYSQLND_RES *result TSRMLS_DC)
                result->conn = NULL;
        }
 
-       mnd_efree(result);
+       mnd_pefree(result, result->persistent);
 
        DBG_VOID_RETURN;
 }
@@ -321,11 +321,11 @@ MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES *result, MYSQLND *
          infrastructure!
        */
        if (result->meta) {
-               result->meta->m->free_metadata(result->meta, FALSE TSRMLS_CC);
+               result->meta->m->free_metadata(result->meta TSRMLS_CC);
                result->meta = NULL;
        }
 
-       result->meta = mysqlnd_result_meta_init(result->field_count TSRMLS_CC);
+       result->meta = mysqlnd_result_meta_init(result->field_count, result->persistent TSRMLS_CC);
 
        /* 1. Read all fields metadata */
 
@@ -351,8 +351,9 @@ MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES *result, MYSQLND *
 
 /* {{{ mysqlnd_query_read_result_set_header */
 enum_func_status
-mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC)
+mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT * s TSRMLS_DC)
 {
+       MYSQLND_STMT_DATA * stmt = s ? s->data:NULL;
        enum_func_status ret;
        MYSQLND_PACKET_RSET_HEADER * rset_header;
 
@@ -440,7 +441,7 @@ mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC
                                /* PS has already allocated it */
                                conn->field_count = rset_header->field_count;
                                if (!stmt) {
-                                       result = conn->current_result = mysqlnd_result_init(rset_header->field_count TSRMLS_CC);
+                                       result = conn->current_result = mysqlnd_result_init(rset_header->field_count, conn->persistent TSRMLS_CC);
                                } else {
                                        if (!stmt->result) {
                                                DBG_INF("This is 'SHOW'/'EXPLAIN'-like query.");
@@ -449,7 +450,7 @@ mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC
                                                  prepared statements can't send result set metadata for these queries
                                                  on prepare stage. Read it now.
                                                */
-                                               result = stmt->result = mysqlnd_result_init(rset_header->field_count TSRMLS_CC);
+                                               result = stmt->result = mysqlnd_result_init(rset_header->field_count, stmt->persistent TSRMLS_CC);
                                        } else {
                                                /*
                                                  Update result set metadata if it for some reason changed between
@@ -1524,16 +1525,17 @@ MYSQLND_METHOD(mysqlnd_res, fetch_field_data)(MYSQLND_RES *result, unsigned int
 /* }}} */
 
 
-/* {{{ mysqlnd_result_init */
+/* {{{ mysqlnd_result_init_ex */
 PHPAPI MYSQLND_RES *
-mysqlnd_result_init(unsigned int field_count TSRMLS_DC)
+mysqlnd_result_init(unsigned int field_count, zend_bool persistent TSRMLS_DC)
 {
        size_t alloc_size = sizeof(MYSQLND_RES) + mysqlnd_plugin_count() * sizeof(void *);
-       MYSQLND_RES *ret = mnd_ecalloc(1, alloc_size);
+       MYSQLND_RES *ret = mnd_pecalloc(1, alloc_size, persistent);
 
        DBG_ENTER("mysqlnd_result_init");
        DBG_INF_FMT("field_count=%u", field_count);
 
+       ret->persistent         = persistent;
        ret->field_count        = field_count;
 
        ret->m.use_result       = MYSQLND_METHOD(mysqlnd_res, use_result);

diff --git a/ext/mysqlnd/mysqlnd_result.h b/ext/mysqlnd/mysqlnd_result.h
index 1e9494419be3e8bc6eab73ee9807f88f27b38fd0..088fc697028acb930413c4f1d294d00f4a4a57d5 100644 (file)
--- a/ext/mysqlnd/mysqlnd_result.h
+++ b/ext/mysqlnd/mysqlnd_result.h
@@ -23,9 +23,9 @@
 #ifndef MYSQLND_RESULT_H
 #define MYSQLND_RESULT_H
 
-PHPAPI MYSQLND_RES * mysqlnd_result_init(unsigned int field_count TSRMLS_DC);
+PHPAPI MYSQLND_RES * mysqlnd_result_init(unsigned int field_count, zend_bool persistent TSRMLS_DC);
 
-enum_func_status mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC);
+enum_func_status mysqlnd_query_read_result_set_header(MYSQLND * conn, MYSQLND_STMT * stmt TSRMLS_DC);
 
 #endif /* MYSQLND_RESULT_H */
 

diff --git a/ext/mysqlnd/mysqlnd_result_meta.c b/ext/mysqlnd/mysqlnd_result_meta.c
index 5186f6d94f95546e86a8e661bdd85729e7f6629c..0ceee4bac3138b3f843b832db89e08d0fe1b08e1 100644 (file)
--- a/ext/mysqlnd/mysqlnd_result_meta.c
+++ b/ext/mysqlnd/mysqlnd_result_meta.c
@@ -150,12 +150,13 @@ MYSQLND_METHOD(mysqlnd_res_meta, read_metadata)(MYSQLND_RES_METADATA * const met
        DBG_ENTER("mysqlnd_res_meta::read_metadata");
 
        field_packet = conn->protocol->m.get_result_field_packet(conn->protocol, FALSE TSRMLS_CC);
+       field_packet->persistent_alloc = meta->persistent;
        for (;i < meta->field_count; i++) {
                long idx;
 
                if (meta->fields[i].root) {
                        /* We re-read metadata for PS */
-                       mnd_efree(meta->fields[i].root);
+                       mnd_pefree(meta->fields[i].root, meta->persistent);
                        meta->fields[i].root = NULL;
                }
 
@@ -260,21 +261,20 @@ MYSQLND_METHOD(mysqlnd_res_meta, read_metadata)(MYSQLND_RES_METADATA * const met
 
 /* {{{ mysqlnd_res_meta::free */
 static void
-MYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA *meta, zend_bool persistent TSRMLS_DC)
+MYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA * meta TSRMLS_DC)
 {
        int i;
        MYSQLND_FIELD *fields;
-
        DBG_ENTER("mysqlnd_res_meta::free");
-       DBG_INF_FMT("persistent=%d", persistent);
+       DBG_INF_FMT("persistent=%d", meta->persistent);
 
        if ((fields = meta->fields)) {
                DBG_INF("Freeing fields metadata");
                i = meta->field_count;
                while (i--) {
-                       php_mysqlnd_free_field_metadata(fields++, persistent TSRMLS_CC);
+                       php_mysqlnd_free_field_metadata(fields++, meta->persistent TSRMLS_CC);
                }
-               mnd_pefree(meta->fields, persistent);
+               mnd_pefree(meta->fields, meta->persistent);
                meta->fields = NULL;
        }
 
@@ -284,16 +284,16 @@ MYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA *meta, zend_bool per
                if (UG(unicode)) {
                        for (i = 0; i < meta->field_count; i++) {
                                if (meta->zend_hash_keys[i].ustr.v) {
-                                       mnd_pefree(meta->zend_hash_keys[i].ustr.v, persistent);
+                                       mnd_pefree(meta->zend_hash_keys[i].ustr.v, meta->persistent);
                                }
                        }
                }
 #endif
-               mnd_pefree(meta->zend_hash_keys, persistent);
+               mnd_pefree(meta->zend_hash_keys, meta->persistent);
                meta->zend_hash_keys = NULL;
        }
        DBG_INF("Freeing metadata structure");
-       mnd_pefree(meta, persistent);
+       mnd_pefree(meta, meta->persistent);
 
        DBG_VOID_RETURN;
 }
@@ -314,6 +314,7 @@ MYSQLND_METHOD(mysqlnd_res_meta, clone_metadata)(const MYSQLND_RES_METADATA * co
        DBG_ENTER("mysqlnd_res_meta::clone_metadata");
        DBG_INF_FMT("persistent=%d", persistent);
 
+       new_meta->persistent = persistent;
        new_meta->zend_hash_keys = mnd_pemalloc(len, persistent);
        memcpy(new_meta->zend_hash_keys, meta->zend_hash_keys, len);
        new_meta->m = meta->m;
@@ -435,16 +436,18 @@ MYSQLND_CLASS_METHODS_END;
 
 /* {{{ mysqlnd_result_meta_init */
 PHPAPI MYSQLND_RES_METADATA *
-mysqlnd_result_meta_init(unsigned int field_count TSRMLS_DC)
+mysqlnd_result_meta_init(unsigned int field_count, zend_bool persistent TSRMLS_DC)
 {
        MYSQLND_RES_METADATA *ret;
        DBG_ENTER("mysqlnd_result_meta_init");
+       DBG_INF_FMT("persistent=%d", persistent);
 
        /* +1 is to have empty marker at the end */
-       ret = mnd_ecalloc(1, sizeof(MYSQLND_RES_METADATA));
+       ret = mnd_pecalloc(1, sizeof(MYSQLND_RES_METADATA), persistent);
+       ret->persistent = persistent;
        ret->field_count = field_count;
-       ret->fields = mnd_ecalloc(field_count + 1, sizeof(MYSQLND_FIELD));
-       ret->zend_hash_keys = mnd_ecalloc(field_count, sizeof(struct mysqlnd_field_hash_key));
+       ret->fields = mnd_pecalloc(field_count + 1, sizeof(MYSQLND_FIELD), ret->persistent);
+       ret->zend_hash_keys = mnd_pecalloc(field_count, sizeof(struct mysqlnd_field_hash_key), ret->persistent);
 
        ret->m = & mysqlnd_mysqlnd_res_meta_methods;
        DBG_INF_FMT("meta=%p", ret);

diff --git a/ext/mysqlnd/mysqlnd_result_meta.h b/ext/mysqlnd/mysqlnd_result_meta.h
index 84e495d4c4949e6e1098183e8b88eedc922e65b8..05d868e3a9fad16cbde08132a729553526a0266f 100644 (file)
--- a/ext/mysqlnd/mysqlnd_result_meta.h
+++ b/ext/mysqlnd/mysqlnd_result_meta.h
@@ -24,7 +24,7 @@
 #define MYSQLND_RESULT_META_H
 
 
-PHPAPI MYSQLND_RES_METADATA * mysqlnd_result_meta_init(unsigned int field_count TSRMLS_DC);
+PHPAPI MYSQLND_RES_METADATA * mysqlnd_result_meta_init(unsigned int field_count, zend_bool persistent TSRMLS_DC);
 
 
 

diff --git a/ext/mysqlnd/mysqlnd_structs.h b/ext/mysqlnd/mysqlnd_structs.h
index e9a7681b6e0d73dd42547e888489922deff81f45..52f27ab2920ac2f711f48de2095daa5b48d340be 100644 (file)
--- a/ext/mysqlnd/mysqlnd_structs.h
+++ b/ext/mysqlnd/mysqlnd_structs.h
@@ -189,6 +189,7 @@ typedef struct st_mysqlnd_net       MYSQLND_NET;
 typedef struct st_mysqlnd_protocol     MYSQLND_PROTOCOL;
 typedef struct st_mysqlnd_res  MYSQLND_RES;
 typedef char**                                         MYSQLND_ROW_C;          /* return data as array of strings */
+typedef struct st_mysqlnd_stmt_data    MYSQLND_STMT_DATA;
 typedef struct st_mysqlnd_stmt MYSQLND_STMT;
 typedef unsigned int                   MYSQLND_FIELD_OFFSET;
 
@@ -527,9 +528,9 @@ typedef const MYSQLND_FIELD *       (*func_mysqlnd_res_meta__fetch_field)(MYSQLND_RES_
 typedef const MYSQLND_FIELD *  (*func_mysqlnd_res_meta__fetch_field_direct)(const MYSQLND_RES_METADATA * const meta, MYSQLND_FIELD_OFFSET fieldnr TSRMLS_DC);
 typedef const MYSQLND_FIELD *  (*func_mysqlnd_res_meta__fetch_fields)(MYSQLND_RES_METADATA * const meta TSRMLS_DC);
 typedef MYSQLND_FIELD_OFFSET   (*func_mysqlnd_res_meta__field_tell)(const MYSQLND_RES_METADATA * const meta TSRMLS_DC);
-typedef enum_func_status               (*func_mysqlnd_res_meta__read_metadata)(MYSQLND_RES_METADATA * const meta, MYSQLND *conn TSRMLS_DC);
+typedef enum_func_status               (*func_mysqlnd_res_meta__read_metadata)(MYSQLND_RES_METADATA * const meta, MYSQLND * conn TSRMLS_DC);
 typedef MYSQLND_RES_METADATA * (*func_mysqlnd_res_meta__clone_metadata)(const MYSQLND_RES_METADATA * const meta, zend_bool persistent TSRMLS_DC);
-typedef void                                   (*func_mysqlnd_res_meta__free_metadata)(MYSQLND_RES_METADATA *meta, zend_bool persistent TSRMLS_DC);
+typedef void                                   (*func_mysqlnd_res_meta__free_metadata)(MYSQLND_RES_METADATA * meta TSRMLS_DC);
 
 struct st_mysqlnd_res_meta_methods
 {
@@ -559,10 +560,8 @@ typedef enum_func_status   (*func_mysqlnd_stmt__fetch)(MYSQLND_STMT * const stmt,
 typedef enum_func_status       (*func_mysqlnd_stmt__bind_parameters)(MYSQLND_STMT * const stmt, MYSQLND_PARAM_BIND * const param_bind TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__bind_one_parameter)(MYSQLND_STMT * const stmt, unsigned int param_no, zval * const zv, zend_uchar  type TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__refresh_bind_param)(MYSQLND_STMT * const stmt TSRMLS_DC);
-typedef void                           (*func_mysqlnd_stmt__set_param_bind_dtor)(MYSQLND_STMT * const stmt, void (*param_bind_dtor)(MYSQLND_PARAM_BIND * TSRMLS_DC) TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__bind_result)(MYSQLND_STMT * const stmt, MYSQLND_RESULT_BIND * const result_bind TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__bind_one_result)(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC);
-typedef void                           (*func_mysqlnd_stmt__set_result_bind_dtor)(MYSQLND_STMT * const stmt, void (*result_bind_dtor)(MYSQLND_RESULT_BIND * TSRMLS_DC) TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__send_long_data)(MYSQLND_STMT * const stmt, unsigned int param_num, const char * const data, unsigned long length TSRMLS_DC);
 typedef MYSQLND_RES *          (*func_mysqlnd_stmt__get_parameter_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC);
 typedef MYSQLND_RES *          (*func_mysqlnd_stmt__get_result_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC);
@@ -577,7 +576,11 @@ typedef const char *               (*func_mysqlnd_stmt__get_error_str)(const MYSQLND_STMT * c
 typedef const char *           (*func_mysqlnd_stmt__get_sqlstate)(const MYSQLND_STMT * const stmt TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__get_attribute)(const MYSQLND_STMT * const stmt, enum mysqlnd_stmt_attr attr_type, void * const value TSRMLS_DC);
 typedef enum_func_status       (*func_mysqlnd_stmt__set_attribute)(MYSQLND_STMT * const stmt, enum mysqlnd_stmt_attr attr_type, const void * const value TSRMLS_DC);
-
+typedef MYSQLND_PARAM_BIND *(*func_mysqlnd_stmt__alloc_param_bind)(MYSQLND_STMT * const stmt TSRMLS_DC);
+typedef MYSQLND_RESULT_BIND*(*func_mysqlnd_stmt__alloc_result_bind)(MYSQLND_STMT * const stmt TSRMLS_DC);
+typedef        void                            (*func_mysqlnd_stmt__free_parameter_bind)(MYSQLND_STMT * const stmt, MYSQLND_PARAM_BIND * TSRMLS_DC);
+typedef        void                            (*func_mysqlnd_stmt__free_result_bind)(MYSQLND_STMT * const stmt, MYSQLND_RESULT_BIND * TSRMLS_DC);
+typedef unsigned int           (*func_mysqlnd_stmt__server_status)(const MYSQLND_STMT * const stmt TSRMLS_DC);
 
 struct st_mysqlnd_stmt_methods
 {
@@ -598,10 +601,8 @@ struct st_mysqlnd_stmt_methods
        func_mysqlnd_stmt__bind_parameters bind_parameters;
        func_mysqlnd_stmt__bind_one_parameter bind_one_parameter;
        func_mysqlnd_stmt__refresh_bind_param refresh_bind_param;
-       func_mysqlnd_stmt__set_param_bind_dtor set_param_bind_dtor;
        func_mysqlnd_stmt__bind_result bind_result;
        func_mysqlnd_stmt__bind_one_result bind_one_result;
-       func_mysqlnd_stmt__set_result_bind_dtor set_result_bind_dtor;
        func_mysqlnd_stmt__send_long_data send_long_data;
        func_mysqlnd_stmt__get_parameter_metadata get_parameter_metadata;
        func_mysqlnd_stmt__get_result_metadata get_result_metadata;
@@ -620,6 +621,14 @@ struct st_mysqlnd_stmt_methods
 
        func_mysqlnd_stmt__get_attribute get_attribute;
        func_mysqlnd_stmt__set_attribute set_attribute;
+
+       func_mysqlnd_stmt__alloc_param_bind alloc_parameter_bind;
+       func_mysqlnd_stmt__alloc_result_bind alloc_result_bind;
+
+       func_mysqlnd_stmt__free_parameter_bind free_parameter_bind;
+       func_mysqlnd_stmt__free_result_bind free_result_bind;
+
+       func_mysqlnd_stmt__server_status get_server_status;
 };
 
 
@@ -748,6 +757,7 @@ struct st_mysqlnd_result_metadata
        /* We need this to make fast allocs in rowp_read */
        unsigned int                                    bit_fields_count;
        size_t                                                  bit_fields_total_len; /* trailing \0 not counted */
+       zend_bool                                               persistent;
 
        struct st_mysqlnd_res_meta_methods *m;
 };
@@ -803,6 +813,7 @@ struct st_mysqlnd_res
        struct st_mysqlnd_packet_row * row_packet;
 
        MYSQLND_MEMORY_POOL * result_set_memory_pool;
+       zend_bool                               persistent;
 };
 
 
@@ -820,7 +831,7 @@ struct st_mysqlnd_result_bind
 };
 
 
-struct st_mysqlnd_stmt
+struct st_mysqlnd_stmt_data
 {
        MYSQLND                                         *conn;
        unsigned long                           stmt_id;
@@ -834,6 +845,7 @@ struct st_mysqlnd_stmt
        MYSQLND_PARAM_BIND                      *param_bind;
        MYSQLND_RESULT_BIND                     *result_bind;
        zend_bool                                       result_zvals_separated_once;
+       zend_bool                                       persistent;
 
        MYSQLND_UPSERT_STATUS           upsert_status;
 
@@ -847,10 +859,12 @@ struct st_mysqlnd_stmt
 
        MYSQLND_CMD_BUFFER                      execute_cmd_buffer;
        unsigned int                            execute_count;/* count how many times the stmt was executed */
+};
 
-       void                                            (*param_bind_dtor)(MYSQLND_PARAM_BIND * TSRMLS_DC);
-       void                                            (*result_bind_dtor)(MYSQLND_RESULT_BIND * TSRMLS_DC);
 
+struct st_mysqlnd_stmt
+{
+       MYSQLND_STMT_DATA * data;
        struct st_mysqlnd_stmt_methods  *m;
 };
 

diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.c b/ext/mysqlnd/mysqlnd_wireprotocol.c
index 5710377882eacc2040837ed8171962d8fe95dc5f..ea41a9a137797e254b8d3864819dba83bdf7aa64 100644 (file)
--- a/ext/mysqlnd/mysqlnd_wireprotocol.c
+++ b/ext/mysqlnd/mysqlnd_wireprotocol.c
@@ -929,8 +929,8 @@ php_mysqlnd_rset_field_read(void *_packet, MYSQLND *conn TSRMLS_DC)
                (len = php_mysqlnd_net_field_length(&p)) &&
                len != MYSQLND_NULL_LENGTH)
        {
-               DBG_INF_FMT("Def found, length %lu", len);
-               meta->def = mnd_emalloc(len + 1);
+               DBG_INF_FMT("Def found, length %lu, persistent=%d", len, packet->persistent_alloc);
+               meta->def = mnd_pemalloc(len + 1, packet->persistent_alloc);
                memcpy(meta->def, p, len);
                meta->def[len] = '\0';
                meta->def_length = len;
@@ -943,7 +943,8 @@ php_mysqlnd_rset_field_read(void *_packet, MYSQLND *conn TSRMLS_DC)
                                                "shorter than expected", p - begin - packet->header.size);
        }
 
-       root_ptr = meta->root = mnd_emalloc(total_len);
+       DBG_INF_FMT("allocing root. persistent=%d", packet->persistent_alloc);
+       root_ptr = meta->root = mnd_pemalloc(total_len, packet->persistent_alloc);
        meta->root_len = total_len;
        /* Now do allocs */
        if (meta->catalog && meta->catalog != mysqlnd_empty_string) {

diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.h b/ext/mysqlnd/mysqlnd_wireprotocol.h
index beb54845ed4881028d8d85ab7e165bbeeb9eacf6..6d5cdff421c517dac0c3b25e55bcdf13450cb1e5 100644 (file)
--- a/ext/mysqlnd/mysqlnd_wireprotocol.h
+++ b/ext/mysqlnd/mysqlnd_wireprotocol.h
@@ -174,6 +174,7 @@ typedef struct st_mysqlnd_packet_res_field {
        /* For table definitions, empty for result sets */
        zend_bool                               skip_parsing;
        zend_bool                               stupid_list_fields_eof;
+       zend_bool                               persistent_alloc;
 
        MYSQLND_ERROR_INFO              error_info;
 } MYSQLND_PACKET_RES_FIELD;

diff --git a/ext/pdo_mysql/mysql_statement.c b/ext/pdo_mysql/mysql_statement.c
index d8d40edb3e906be720f1a86037b6205983369fe1..22b3474b0faaf4d61e9f6f72137528fd50364bf1 100755 (executable)
--- a/ext/pdo_mysql/mysql_statement.c
+++ b/ext/pdo_mysql/mysql_statement.c
@@ -264,7 +264,7 @@ static int pdo_mysql_stmt_execute_prepared_mysqlnd(pdo_stmt_t *stmt TSRMLS_DC) /
        }
 
        /* for SHOW/DESCRIBE and others the column/field count is not available before execute */
-       stmt->column_count = S->stmt->field_count;
+       stmt->column_count = mysql_stmt_field_count(S->stmt);
        for (i = 0; i < stmt->column_count; i++) {
                mysqlnd_stmt_bind_one_result(S->stmt, i);
        }
@@ -376,7 +376,7 @@ static int pdo_mysql_stmt_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
                        /* for SHOW/DESCRIBE and others the column/field count is not available before execute */
                        int i;
 
-                       stmt->column_count = S->stmt->field_count;
+                       stmt->column_count = mysql_stmt_field_count(S->stmt);
                        for (i = 0; i < stmt->column_count; i++) {
                                mysqlnd_stmt_bind_one_result(S->stmt, i);
                        }
@@ -745,8 +745,8 @@ static int pdo_mysql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsig
        }
 #if PDO_USE_MYSQLND
        if (S->stmt) {
-               Z_ADDREF_P(S->stmt->result_bind[colno].zv);
-               *ptr = (char*)&S->stmt->result_bind[colno].zv;
+               Z_ADDREF_P(S->stmt->data->result_bind[colno].zv);
+               *ptr = (char*)&S->stmt->data->result_bind[colno].zv;
                *len = sizeof(zval);
                PDO_DBG_RETURN(1);
        }