From 4d2735007d53b2609eb59de8b1d445481cb09713 Mon Sep 17 00:00:00 2001 From: Andrey Hristov Date: Wed, 9 Dec 2009 16:57:03 +0000 Subject: [PATCH] Remove disabled code - threaded fetching. This can be implemented on a upper level and by offloading it we reduce the complexity of the core. --- ext/mysqli/mysqli.c | 8 - ext/mysqli/mysqli_mysqlnd.h | 1 - ext/mysqli/mysqli_nonapi.c | 16 +- ext/mysqli/php_mysqli_structs.h | 3 - ext/mysqlnd/config9.m4 | 9 - ext/mysqlnd/mysqlnd.c | 98 ------ ext/mysqlnd/mysqlnd.h | 5 - ext/mysqlnd/mysqlnd_debug.c | 48 --- ext/mysqlnd/mysqlnd_ps.c | 75 ----- ext/mysqlnd/mysqlnd_result.c | 507 -------------------------------- ext/mysqlnd/mysqlnd_result.h | 5 - ext/mysqlnd/mysqlnd_structs.h | 44 --- ext/mysqlnd/php_mysqlnd.c | 7 +- 13 files changed, 3 insertions(+), 823 deletions(-) diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c index f4a98b6745..47e2a9e53f 100644 --- a/ext/mysqli/mysqli.c +++ b/ext/mysqli/mysqli.c @@ -734,9 +734,6 @@ PHP_MINIT_FUNCTION(mysqli) /* for mysqli_query */ REGISTER_LONG_CONSTANT("MYSQLI_STORE_RESULT", MYSQLI_STORE_RESULT, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MYSQLI_USE_RESULT", MYSQLI_USE_RESULT, CONST_CS | CONST_PERSISTENT); -#if defined(MYSQLI_USE_MYSQLND) && defined(MYSQLND_THREADED) - REGISTER_LONG_CONSTANT("MYSQLI_BG_STORE_RESULT", MYSQLI_BG_STORE_RESULT, CONST_CS | CONST_PERSISTENT); -#endif #if defined (MYSQLI_USE_MYSQLND) REGISTER_LONG_CONSTANT("MYSQLI_ASYNC", MYSQLI_ASYNC, CONST_CS | CONST_PERSISTENT); #endif @@ -1093,11 +1090,6 @@ PHP_FUNCTION(mysqli_result_construct) case MYSQLI_USE_RESULT: result = mysql_use_result(mysql->mysql); break; -#if defined(MYSQLI_USE_MYSQLND) && defined(MYSQLND_THREADED) - case MYSQLI_BG_STORE_RESULT: - result = mysqli_bg_store_result(mysql->mysql); - break; -#endif default: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid value for resultmode"); } diff --git a/ext/mysqli/mysqli_mysqlnd.h b/ext/mysqli/mysqli_mysqlnd.h index b815dec632..121db77253 100644 --- a/ext/mysqli/mysqli_mysqlnd.h +++ b/ext/mysqli/mysqli_mysqlnd.h @@ -37,7 +37,6 @@ #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)) -#define mysqli_bg_store_result(r) mysqlnd_bg_store_result((r)) #define mysqli_async_query(c, q, l) mysqlnd_async_query((c), (q), (l)) #define mysqli_change_user_silent(c, u, p, d) mysqlnd_change_user((c), (u), (p), (d), TRUE) diff --git a/ext/mysqli/mysqli_nonapi.c b/ext/mysqli/mysqli_nonapi.c index 0195b060ed..34fd353e95 100644 --- a/ext/mysqli/mysqli_nonapi.c +++ b/ext/mysqli/mysqli_nonapi.c @@ -524,11 +524,7 @@ PHP_FUNCTION(mysqli_query) php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty query"); RETURN_FALSE; } - if ((resultmode & ~MYSQLI_ASYNC) != MYSQLI_USE_RESULT && (resultmode & ~MYSQLI_ASYNC) != MYSQLI_STORE_RESULT -#if defined(MYSQLI_USE_MYSQLND) && defined(MYSQLND_THREADED) - && (resultmode & ~MYSQLI_ASYNC) != MYSQLI_BG_STORE_RESULT -#endif - ) { + if ((resultmode & ~MYSQLI_ASYNC) != MYSQLI_USE_RESULT && (resultmode & ~MYSQLI_ASYNC) != MYSQLI_STORE_RESULT) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid value for resultmode"); RETURN_FALSE; } @@ -569,11 +565,6 @@ PHP_FUNCTION(mysqli_query) case MYSQLI_USE_RESULT: result = mysql_use_result(mysql->mysql); break; -#if defined(MYSQLI_USE_MYSQLND) && defined(MYSQLND_THREADED) - case MYSQLI_BG_STORE_RESULT: - result = mysqli_bg_store_result(mysql->mysql); - break; -#endif } if (!result) { php_mysqli_throw_sql_exception((char *)mysql_sqlstate(mysql->mysql), mysql_errno(mysql->mysql) TSRMLS_CC, @@ -807,11 +798,6 @@ PHP_FUNCTION(mysqli_reap_async_query) case MYSQLI_USE_RESULT: result = mysql_use_result(mysql->mysql); break; -#if defined(MYSQLI_USE_MYSQLND) && defined(MYSQLND_THREADED) - case MYSQLI_BG_STORE_RESULT: - result = mysqli_bg_store_result(mysql->mysql); - break; -#endif } if (!result) { diff --git a/ext/mysqli/php_mysqli_structs.h b/ext/mysqli/php_mysqli_structs.h index 821b27b3ee..aa57ad06a7 100644 --- a/ext/mysqli/php_mysqli_structs.h +++ b/ext/mysqli/php_mysqli_structs.h @@ -308,9 +308,6 @@ PHP_MYSQLI_EXPORT(zend_object_value) mysqli_objects_new(zend_class_entry * TSRML #define MYSQLI_STORE_RESULT 0 #define MYSQLI_USE_RESULT 1 #ifdef MYSQLI_USE_MYSQLND -#ifdef MYSQLND_THREADED -#define MYSQLI_BG_STORE_RESULT 4 -#endif #define MYSQLI_ASYNC 8 #else /* libmysql */ diff --git a/ext/mysqlnd/config9.m4 b/ext/mysqlnd/config9.m4 index b3b802cd38..beaf814762 100644 --- a/ext/mysqlnd/config9.m4 +++ b/ext/mysqlnd/config9.m4 @@ -3,11 +3,6 @@ dnl $Id$ dnl config.m4 for mysqlnd driver -PHP_ARG_ENABLE(mysqlnd_threading, whether to enable threaded fetch in mysqlnd, -[ --enable-mysqlnd-threading - EXPERIMENTAL: Enable mysqlnd threaded fetch. - Note: This forces ZTS on!], no, no) - PHP_ARG_ENABLE(disable_mysqlnd_compression_support, whether to disable compressed protocol support in mysqlnd, [ --disable-mysqlnd-compression-support Enable support for the MySQL compressed protocol in mysqlnd], yes) @@ -29,10 +24,6 @@ if test "$PHP_MYSQLND_ENABLED" = "yes"; then PHP_ADD_BUILD_DIR([ext/mysqlnd], 1) dnl Windows uses config.w32 thus this code is safe for now - if test "$PHP_MYSQLND_THREADING" = "yes"; then - PHP_BUILD_THREAD_SAFE - AC_DEFINE([MYSQLND_THREADED], 1, [Use mysqlnd internal threading]) - fi if test "$PHP_MYSQLND_COMPRESSION_SUPPORT" != "no"; then AC_DEFINE([MYSQLND_COMPRESSION_ENABLED], 1, [Enable compressed protocol support]) diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c index 6c01ca98d3..11a7be6b2a 100644 --- a/ext/mysqlnd/mysqlnd.c +++ b/ext/mysqlnd/mysqlnd.c @@ -245,22 +245,6 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND *conn TSRMLS_DC) conn->m->free_contents(conn TSRMLS_CC); conn->m->free_options(conn TSRMLS_CC); -#ifdef MYSQLND_THREADED - if (conn->thread_is_running) { - pthread_mutex_lock(&conn->LOCK_work); - conn->thread_killed = TRUE; - pthread_cond_signal(&conn->COND_work); - pthread_cond_wait(&conn->COND_thread_ended, &conn->LOCK_work); - pthread_mutex_unlock(&conn->LOCK_work); - } - - tsrm_mutex_free(conn->LOCK_state); - - pthread_cond_destroy(&conn->COND_work); - pthread_cond_destroy(&conn->COND_work_done); - pthread_mutex_destroy(&conn->LOCK_work); -#endif - mnd_pefree(conn, conn->persistent); DBG_VOID_RETURN; @@ -823,21 +807,6 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn, DBG_INF("unicode set"); } #endif -#ifdef MYSQLND_THREADED - { - pthread_t th; - pthread_attr_t connection_attrib; - conn->tsrm_ls = tsrm_ls; - - pthread_attr_init(&connection_attrib); - pthread_attr_setdetachstate(&connection_attrib, PTHREAD_CREATE_DETACHED); - - conn->thread_is_running = TRUE; - if (pthread_create(&th, &connection_attrib, mysqlnd_fetch_thread, (void*)conn)) { - conn->thread_is_running = FALSE; - } - } -#endif if (conn->options.init_commands) { int current_command = 0; @@ -1630,25 +1599,12 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference)(MYSQLND * const conn TSRMLS /* {{{ mysqlnd_conn::get_state */ -#ifdef MYSQLND_THREADED -static enum mysqlnd_connection_state -MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_state)(MYSQLND * const conn TSRMLS_DC) -{ - enum mysqlnd_connection_state state; - DBG_ENTER("mysqlnd_conn::get_state"); - tsrm_mutex_lock(conn->LOCK_state); - state = conn->state; - tsrm_mutex_unlock(conn->LOCK_state); - DBG_RETURN(state); -} -#else static enum mysqlnd_connection_state MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_state)(MYSQLND * const conn TSRMLS_DC) { DBG_ENTER("mysqlnd_conn::get_state"); DBG_RETURN(conn->state); } -#endif /* }}} */ @@ -1657,14 +1613,8 @@ static void MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state)(MYSQLND * const conn, enum mysqlnd_connection_state new_state TSRMLS_DC) { DBG_ENTER("mysqlnd_conn::set_state"); -#ifdef MYSQLND_THREADED - tsrm_mutex_lock(conn->LOCK_state); -#endif DBG_INF_FMT("New state=%d", new_state); conn->state = new_state; -#ifdef MYSQLND_THREADED - tsrm_mutex_unlock(conn->LOCK_state); -#endif DBG_VOID_RETURN; } /* }}} */ @@ -2190,44 +2140,6 @@ MYSQLND_METHOD(mysqlnd_conn, store_result)(MYSQLND * const conn TSRMLS_DC) /* }}} */ -/* {{{ mysqlnd_conn::background_store_result */ -MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_conn, background_store_result)(MYSQLND * const conn TSRMLS_DC) -{ - MYSQLND_RES *result; - - DBG_ENTER("mysqlnd_conn::store_result"); - DBG_INF_FMT("conn=%llu", conn->thread_id); - - if (!conn->current_result) { - DBG_RETURN(NULL); - } - - /* Nothing to store for UPSERT/LOAD DATA*/ - if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) { - SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, - mysqlnd_out_of_sync); - DBG_ERR("Command out of sync"); - DBG_RETURN(NULL); - } - - MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_BUFFERED_SETS); - - result = conn->current_result; - - result = result->m.background_store_result(result, conn, FALSE TSRMLS_CC); - - /* - Should be here, because current_result is used by the fetching thread to get data info - The thread is contacted in mysqlnd_res::background_store_result(). - */ - conn->current_result = NULL; - - DBG_RETURN(result); -} -/* }}} */ - - /* {{{ mysqlnd_conn::get_connection_stats */ static void MYSQLND_METHOD(mysqlnd_conn, get_connection_stats)(const MYSQLND * const conn, @@ -2254,7 +2166,6 @@ MYSQLND_CLASS_METHODS_START(mysqlnd_conn) 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), MYSQLND_METHOD(mysqlnd_conn, next_result), MYSQLND_METHOD(mysqlnd_conn, more_results), @@ -2326,15 +2237,6 @@ PHPAPI MYSQLND *_mysqlnd_init(zend_bool persistent TSRMLS_DC) ret->net.stream_read = mysqlnd_read_from_stream; ret->net.stream_write = mysqlnd_stream_write; -#ifdef MYSQLND_THREADED - ret->LOCK_state = tsrm_mutex_alloc(); - - pthread_mutex_init(&ret->LOCK_work, NULL); - pthread_cond_init(&ret->COND_work, NULL); - pthread_cond_init(&ret->COND_work_done, NULL); - pthread_cond_init(&ret->COND_thread_ended, NULL); -#endif - DBG_RETURN(ret); } /* }}} */ diff --git a/ext/mysqlnd/mysqlnd.h b/ext/mysqlnd/mysqlnd.h index 33d22f0bd2..bdcc15c263 100644 --- a/ext/mysqlnd/mysqlnd.h +++ b/ext/mysqlnd/mysqlnd.h @@ -129,7 +129,6 @@ PHPAPI enum_func_status _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQ #define mysqlnd_use_result(conn) (conn)->m->use_result((conn) TSRMLS_CC) #define mysqlnd_store_result(conn) (conn)->m->store_result((conn) TSRMLS_CC) -#define mysqlnd_bg_store_result(conn) (conn)->m->background_store_result((conn) TSRMLS_CC) #define mysqlnd_next_result(conn) (conn)->m->next_result((conn) TSRMLS_CC) #define mysqlnd_more_results(conn) (conn)->m->more_results((conn) TSRMLS_CC) #define mysqlnd_free_result(r,e_or_i) ((MYSQLND_RES*)r)->m.free_result(((MYSQLND_RES*)(r)), (e_or_i) TSRMLS_CC) @@ -279,7 +278,6 @@ PHPAPI ulong mysqlnd_old_escape_string(char *newstr, const char *escapestr, size /* PS */ #define mysqlnd_stmt_init(conn) (conn)->m->stmt_init((conn) TSRMLS_CC) #define mysqlnd_stmt_store_result(stmt) (!mysqlnd_stmt_field_count((stmt)) ? PASS:((stmt)->m->store_result((stmt) TSRMLS_CC)? PASS:FAIL)) -#define mysqlnd_stmt_bg_store_result(stmt) (!mysqlnd_stmt_field_count((stmt)) ? PASS:((stmt)->m->background_store_result((stmt) TSRMLS_CC)? PASS:FAIL)) #define mysqlnd_stmt_get_result(stmt) (stmt)->m->get_result((stmt) TSRMLS_CC) #define mysqlnd_stmt_more_results(stmt) (stmt)->m->more_results((stmt) TSRMLS_CC) #define mysqlnd_stmt_next_result(stmt) (stmt)->m->next_result((stmt) TSRMLS_CC) @@ -380,9 +378,6 @@ ZEND_BEGIN_MODULE_GLOBALS(mysqlnd) long net_cmd_buffer_size; long net_read_buffer_size; long log_mask; -#ifdef MYSQLND_THREADED - THREAD_T thread_id; -#endif long net_read_timeout; ZEND_END_MODULE_GLOBALS(mysqlnd) diff --git a/ext/mysqlnd/mysqlnd_debug.c b/ext/mysqlnd/mysqlnd_debug.c index a052748850..37a5160a23 100644 --- a/ext/mysqlnd/mysqlnd_debug.c +++ b/ext/mysqlnd/mysqlnd_debug.c @@ -95,12 +95,6 @@ MYSQLND_METHOD(mysqlnd_debug, log)(MYSQLND_DEBUG * self, line_buffer[6], level_buffer[7]; MYSQLND_ZTS(self); -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - return PASS; /* don't trace background threads */ - } -#endif - if (!self->stream) { if (FAIL == self->m->open(self, FALSE)) { return FAIL; @@ -201,12 +195,6 @@ MYSQLND_METHOD(mysqlnd_debug, log_va)(MYSQLND_DEBUG *self, line_buffer[6], level_buffer[7]; MYSQLND_ZTS(self); -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - return PASS; /* don't trace background threads */ - } -#endif - if (!self->stream) { if (FAIL == self->m->open(self, FALSE)) { return FAIL; @@ -303,17 +291,9 @@ MYSQLND_METHOD(mysqlnd_debug, func_enter)(MYSQLND_DEBUG * self, unsigned int line, const char * const file, char * func_name, unsigned int func_name_len) { -#ifdef MYSQLND_THREADED - MYSQLND_ZTS(self); -#endif if ((self->flags & MYSQLND_DEBUG_DUMP_TRACE) == 0 || self->file_name == NULL) { return FALSE; } -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - return FALSE; /* don't trace background threads */ - } -#endif if (zend_stack_count(&self->call_stack) >= self->nest_level_limit) { return FALSE; } @@ -351,17 +331,9 @@ MYSQLND_METHOD(mysqlnd_debug, func_leave)(MYSQLND_DEBUG * self, unsigned int lin const char * const file) { char *func_name; -#ifdef MYSQLND_THREADED - MYSQLND_ZTS(self); -#endif if ((self->flags & MYSQLND_DEBUG_DUMP_TRACE) == 0 || self->file_name == NULL) { return PASS; } -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - return PASS; /* don't trace background threads */ - } -#endif if (zend_stack_count(&self->call_stack) >= self->nest_level_limit) { return PASS; } @@ -670,11 +642,6 @@ void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D) { void *ret; DBG_ENTER(mysqlnd_emalloc_name); -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - DBG_RETURN(_mysqlnd_pemalloc(size, 1 TSRMLS_CC ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)); - } -#endif DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC)); @@ -723,11 +690,6 @@ void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) { void *ret; DBG_ENTER(mysqlnd_ecalloc_name); -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - DBG_RETURN(_mysqlnd_pecalloc(nmemb, size, 1 TSRMLS_CC ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)); - } -#endif DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC)); @@ -776,11 +738,6 @@ void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D) { void *ret; DBG_ENTER(mysqlnd_erealloc_name); -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - DBG_RETURN(_mysqlnd_perealloc(ptr, new_size, 1 TSRMLS_CC ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)); - } -#endif DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("ptr=%p new_size=%lu", ptr, new_size); DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC)); @@ -830,11 +787,6 @@ void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQL void _mysqlnd_efree(void *ptr MYSQLND_MEM_D) { DBG_ENTER(mysqlnd_efree_name); -#ifdef MYSQLND_THREADED - if (MYSQLND_G(thread_id) != tsrm_thread_id()) { - DBG_RETURN(_mysqlnd_pefree(ptr, 1 TSRMLS_CC ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)); - } -#endif DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("ptr=%p", ptr); DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC)); diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c index 38c554306c..a8e4fe32a5 100644 --- a/ext/mysqlnd/mysqlnd_ps.c +++ b/ext/mysqlnd/mysqlnd_ps.c @@ -133,80 +133,6 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const stmt TSRMLS_DC) /* }}} */ -/* {{{ mysqlnd_stmt::background_store_result */ -static MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_stmt, background_store_result)(MYSQLND_STMT * const stmt TSRMLS_DC) -{ - enum_func_status ret; - MYSQLND *conn = stmt->conn; - MYSQLND_RES *result; - zend_bool to_cache = FALSE; - - DBG_ENTER("mysqlnd_stmt::background_store_result"); - DBG_INF_FMT("stmt=%lu", stmt->stmt_id); - - /* be compliant with libmysql - NULL will turn */ - if (!stmt->field_count) { - DBG_RETURN(NULL); - } - - if (stmt->cursor_exists) { - /* Silently convert buffered to unbuffered, for now */ - MYSQLND_RES * res = stmt->m->use_result(stmt TSRMLS_CC); - DBG_RETURN(res); - } - - /* Nothing to store for UPSERT/LOAD DATA*/ - if (CONN_GET_STATE(conn) != CONN_FETCHING_DATA || - stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE) - { - SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, - UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); - DBG_RETURN(NULL); - } - - stmt->default_rset_handler = stmt->m->store_result; - - SET_EMPTY_ERROR(stmt->error_info); - SET_EMPTY_ERROR(stmt->conn->error_info); - MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_PS_BUFFERED_SETS); - - result = stmt->result; - result->type = MYSQLND_RES_PS_BUF; - result->m.fetch_row = mysqlnd_fetch_stmt_row_buffered; - result->m.fetch_lengths = NULL;/* makes no sense */ - if (!result->zval_cache) { - result->zval_cache = mysqlnd_palloc_get_thd_cache_reference(conn->zval_cache); - } - - /* Create room for 'next_extend' rows */ - - /* Not set for SHOW statements at PREPARE stage */ - if (result->conn) { - result->conn->m->free_reference(result->conn TSRMLS_CC); - result->conn = NULL; /* store result does not reference the connection */ - } - - ret = result->m.store_result_fetch_data(conn, result, result->meta, TRUE, to_cache TSRMLS_CC); - - if (PASS == ret) { - /* libmysql API docs say it should be so for SELECT statements */ - stmt->upsert_status.affected_rows = stmt->result->stored_data->row_count; - - stmt->state = MYSQLND_STMT_USE_OR_STORE_CALLED; - } else { - conn->error_info = result->stored_data->error_info; - stmt->result->m.free_result_contents(stmt->result TSRMLS_CC); - mnd_efree(stmt->result); - stmt->result = NULL; - stmt->state = MYSQLND_STMT_PREPARED; - } - - DBG_RETURN(result); -} -/* }}} */ - - /* {{{ mysqlnd_stmt::get_result */ static MYSQLND_RES * MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const stmt TSRMLS_DC) @@ -2122,7 +2048,6 @@ MYSQLND_CLASS_METHODS_START(mysqlnd_stmt) MYSQLND_METHOD(mysqlnd_stmt, execute), MYSQLND_METHOD(mysqlnd_stmt, use_result), MYSQLND_METHOD(mysqlnd_stmt, store_result), - MYSQLND_METHOD(mysqlnd_stmt, background_store_result), MYSQLND_METHOD(mysqlnd_stmt, get_result), MYSQLND_METHOD(mysqlnd_stmt, more_results), MYSQLND_METHOD(mysqlnd_stmt, next_result), diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c index a1877e38cb..b997148f84 100644 --- a/ext/mysqlnd/mysqlnd_result.c +++ b/ext/mysqlnd/mysqlnd_result.c @@ -33,65 +33,6 @@ #define MYSQLND_SILENT -#ifdef MYSQLND_THREADED -/* {{{ mysqlnd_fetch_thread */ -void * mysqlnd_fetch_thread(void *arg) -{ - MYSQLND *conn = (MYSQLND *) arg; - MYSQLND_RES * result = NULL; - void ***tsrm_ls = conn->tsrm_ls; -#ifndef MYSQLND_SILENT - printf("THREAD] conn=%p tsrm_ls=%p\n", conn, conn->tsrm_ls); -#endif - do { - pthread_mutex_lock(&conn->LOCK_work); - while (conn->thread_killed == FALSE && !conn->current_result) { -#ifndef MYSQLND_SILENT - printf("THREAD] Waiting for work in %s\n", __FUNCTION__); -#endif - pthread_cond_wait(&conn->COND_work, &conn->LOCK_work); - } - if (conn->thread_killed == TRUE) { -#ifndef MYSQLND_SILENT - printf("THREAD] Thread killed in %s\n", __FUNCTION__); -#endif - pthread_cond_signal(&conn->COND_thread_ended); - pthread_mutex_unlock(&conn->LOCK_work); - break; - } -#ifndef MYSQLND_SILENT - printf("THREAD] Got work in %s\n", __FUNCTION__); -#endif - CONN_SET_STATE(conn, CONN_FETCHING_DATA); - result = conn->current_result; - conn->current_result = NULL; - pthread_cond_signal(&conn->COND_work); /* sent notification back */ - pthread_mutex_unlock(&conn->LOCK_work); - -#ifndef MYSQLND_SILENT - printf("THREAD] Starting fetch %s\n", __FUNCTION__); -#endif - mysqlnd_background_store_result_fetch_data(result TSRMLS_CC); - - /* do fetch the data from the wire */ - - pthread_mutex_lock(&conn->LOCK_work); - CONN_SET_STATE(conn, CONN_READY); - pthread_cond_signal(&conn->COND_work_done); -#ifndef MYSQLND_SILENT - printf("THREAD] Signaling work done in %s\n", __FUNCTION__); -#endif - pthread_mutex_unlock(&conn->LOCK_work); - } while (1); - -#ifndef MYSQLND_SILENT - printf("THREAD] Exiting worker thread in %s\n", __FUNCTION__); -#endif - return NULL; -} -/* }}} */ -#endif /* MYSQLND_THREADED */ - /* {{{ mysqlnd_res::initialize_result_set_rest */ static void @@ -253,85 +194,6 @@ MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLND_RES *result TSRMLS_DC) /* }}} */ -#ifdef MYSQLND_THREADED -/* {{{ mysqlnd_free_background_buffered_data */ -void mysqlnd_free_background_buffered_data(MYSQLND_RES *result TSRMLS_DC) -{ - MYSQLND_THD_ZVAL_PCACHE *zval_cache = result->zval_cache; - MYSQLND_RES_BG_BUFFERED *set = result->bg_stored_data; - unsigned int field_count = result->field_count; - int row; - - DBG_ENTER("mysqlnd_free_buffered_data"); - DBG_INF_FMT("Freeing "MYSQLND_LLU_SPEC" row(s)", set->row_count); - - do { - tsrm_mutex_lock(set->LOCK); - if (set->bg_fetch_finished) { - tsrm_mutex_unlock(set->LOCK); - break; - } - tsrm_mutex_unlock(set->LOCK); -#if HAVE_USLEEP - usleep(2000); -#else - { - volatile int i; - for (i = 0; i < 1000; i++); - } -#endif - } while (1); - - DBG_INF_FMT("before: real_usage=%lu usage=%lu", zend_memory_usage(TRUE TSRMLS_CC), zend_memory_usage(FALSE TSRMLS_CC)); - for (row = set->row_count - 1; row >= 0; row--) { - MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row]; - /* It could be the case that the user fetched no rows - then no set->data */ - if (row < set->data_size && set->data[row]) { - zval **current_row = set->data[row]; - unsigned int col; - - for (col = 0; col < field_count; col++) { - zend_bool copy_ctor_called; - mysqlnd_palloc_zval_ptr_dtor(&(current_row[col]), zval_cache, - result->type, ©_ctor_called TSRMLS_CC); -#if MYSQLND_DEBUG_MEMORY - DBG_INF_FMT("Copy_ctor_called=%d", copy_ctor_called); -#endif - MYSQLND_INC_GLOBAL_STATISTIC(copy_ctor_called? STAT_COPY_ON_WRITE_PERFORMED: - STAT_COPY_ON_WRITE_SAVED); - } -#if MYSQLND_DEBUG_MEMORY - DBG_INF("Freeing current_row & current_buffer"); -#endif - mnd_pefree(current_row, set->persistent); - } - current_buffer->free_chunk(current_buffer, TRUE TSRMLS_CC); - } - DBG_INF("Freeing data & row_buffer"); - mnd_pefree(set->data, set->persistent); - mnd_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); - } - - if (set->LOCK) { - tsrm_mutex_free(set->LOCK); - } - - DBG_INF("Freeing set"); - mnd_pefree(set, set->persistent); - - DBG_INF_FMT("after: real_usage=%lu usage=%lu", zend_memory_usage(TRUE TSRMLS_CC), zend_memory_usage(FALSE TSRMLS_CC)); - DBG_VOID_RETURN; -} -/* }}} */ -#endif /* MYSQL_THREADING */ - - /* {{{ mysqlnd_res::free_result_buffers */ static void MYSQLND_METHOD(mysqlnd_res, free_result_buffers)(MYSQLND_RES *result TSRMLS_DC) @@ -347,12 +209,6 @@ MYSQLND_METHOD(mysqlnd_res, free_result_buffers)(MYSQLND_RES *result TSRMLS_DC) result->m.free_buffered_data(result TSRMLS_CC); result->stored_data = NULL; } -#ifdef MYSQLND_THREADED - else if (result->bg_stored_data) { - mysqlnd_free_background_buffered_data(result TSRMLS_CC); - result->bg_stored_data = NULL; - } -#endif if (result->lengths) { mnd_efree(result->lengths); @@ -690,45 +546,6 @@ unsigned long * mysqlnd_fetch_lengths_buffered(MYSQLND_RES * const result) /* }}} */ -#ifdef MYSQLND_THREADED -/* {{{ mysqlnd_fetch_lengths_async_buffered */ -/* - Do lazy initialization for buffered results. As PHP strings have - length inside, this function makes not much sense in the context - of PHP, to be called as separate function. But let's have it for - completeness. -*/ -static -unsigned long * mysqlnd_fetch_lengths_async_buffered(MYSQLND_RES * const result) -{ - int i; - zval **previous_row; - MYSQLND_RES_BG_BUFFERED *set = result->bg_stored_data; - - /* - If: - - unbuffered result - - first row has not been read - - last_row has been read - */ - if (set->data_cursor == NULL || - set->data_cursor == set->data || - ((set->data_cursor - set->data) > set->row_count)) - { - return NULL;/* No rows or no more rows */ - } - - previous_row = *(set->data_cursor - 1); - for (i = 0; i < result->meta->field_count; i++) { - result->lengths[i] = (Z_TYPE_P(previous_row[i]) == IS_NULL)? 0:Z_STRLEN_P(previous_row[i]); - } - - return result->lengths; -} -/* }}} */ -#endif - - /* {{{ mysqlnd_fetch_lengths_unbuffered */ static unsigned long * mysqlnd_fetch_lengths_unbuffered(MYSQLND_RES * const result) @@ -1355,329 +1172,6 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result, /* }}} */ -#ifdef MYSQLND_THREADED -/* {{{ mysqlnd_fetch_row_async_buffered */ -static enum_func_status -mysqlnd_fetch_row_async_buffered(MYSQLND_RES *result, void *param, unsigned int flags, - zend_bool *fetched_anything TSRMLS_DC) -{ - zval *row = (zval *) param; - MYSQLND_RES_BG_BUFFERED *set = result->bg_stored_data; - - DBG_ENTER("mysqlnd_fetch_row_async_buffered"); - DBG_INF_FMT("flags=%u row=%p", flags, row); - - do { - tsrm_mutex_lock(set->LOCK); - if (set->bg_fetch_finished == TRUE) { - /* Don't unlock here, will be done later */ - break; - } - if (!set->data_cursor || (set->data_cursor - set->data) < (set->row_count)) { - tsrm_mutex_unlock(set->LOCK); -#if HAVE_USLEEP - usleep(2000); -#else - volatile int i = 0; - for (int i = 0; i < 100; i++); -#endif - } else { - break; - } - } while (1); - - /* 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; - zval **current_row = *set->data_cursor++; - unsigned int i; - - set->initialized_rows++; - /* We don't forget to release the lock */ - tsrm_mutex_unlock(set->LOCK); - - /* If there was no decoding in background, we have to decode here */ - if (set->decode_in_foreground == TRUE) { - MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row_num]; - result->m.row_decoder(current_buffer, - current_row, - result->meta->field_count, - result->meta->fields, - result->conn->options.numeric_and_datetime_as_unicode, - result->conn->options.int_and_float_native, - result->conn->zval_cache, - &result->conn->stats TSRMLS_CC); - - for (i = 0; i < result->field_count; i++) { - /* - NULL fields are 0 length, 0 is not more than 0 - String of zero size, definitely can't be the next max_length. - Thus for NULL and zero-length we are quite efficient. - */ - if (Z_TYPE_P(current_row[i]) >= IS_STRING) { - unsigned long len = Z_STRLEN_P(current_row[i]); - if (result->meta->fields[i].max_length < len) { - result->meta->fields[i].max_length = len; - } - } - } - } - - - for (i = 0; i < result->field_count; i++) { - zval *data = current_row[i]; - - /* - Let us later know what to do with this zval. If ref_count > 1, we will just - decrease it, otherwise free it. zval_ptr_dtor() make this very easy job. - */ - Z_ADDREF_P(data); - - if ((flags & MYSQLND_FETCH_BOTH) == MYSQLND_FETCH_BOTH) { - Z_ADDREF_P(data); - } - if (flags & MYSQLND_FETCH_NUM) { - zend_hash_next_index_insert(Z_ARRVAL_P(row), &data, sizeof(zval *), NULL); - } - if (flags & MYSQLND_FETCH_ASSOC) { - /* zend_hash_quick_update needs length + trailing zero */ - /* QQ: Error handling ? */ - /* - zend_hash_quick_update does not check, as add_assoc_zval_ex do, whether - the index is a numeric and convert it to it. This however means constant - hashing of the column name, which is not needed as it can be precomputed. - */ - if (result->meta->zend_hash_keys[i].is_numeric == FALSE) { -#if PHP_MAJOR_VERSION >= 6 - zend_u_hash_quick_update(Z_ARRVAL_P(row), IS_UNICODE, - result->meta->zend_hash_keys[i].ustr, - result->meta->zend_hash_keys[i].ulen + 1, - result->meta->zend_hash_keys[i].key, - (void *) &data, sizeof(zval *), NULL); -#else - zend_hash_quick_update(Z_ARRVAL_P(row), - result->meta->fields[i].name, - result->meta->fields[i].name_length + 1, - result->meta->zend_hash_keys[i].key, - (void *) &data, sizeof(zval *), NULL); -#endif - } else { - zend_hash_index_update(Z_ARRVAL_P(row), - result->meta->zend_hash_keys[i].key, - (void *) &data, sizeof(zval *), NULL); - } - } - } - *fetched_anything = TRUE; - MYSQLND_INC_GLOBAL_STATISTIC(STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_BUF); - } else { - set->data_cursor = NULL; - /* We don't forget to release the lock */ - tsrm_mutex_unlock(set->LOCK); - *fetched_anything = FALSE; - DBG_INF("EOF reached"); - } - - DBG_INF_FMT("ret=PASS fetched=%d", *fetched_anything); - DBG_RETURN(PASS); -} -/* }}} */ - - -/* {{{ mysqlnd_background_store_result_fetch_data */ -enum_func_status -mysqlnd_background_store_result_fetch_data(MYSQLND_RES *result TSRMLS_DC) -{ - enum_func_status ret; - php_mysql_packet_row *row_packet; - unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows; - MYSQLND_RES_BG_BUFFERED *set = result->bg_stored_data; - MYSQLND *conn = result->conn; - - DBG_ENTER("mysqlnd_background_store_result_fetch_data"); - - free_rows = next_extend; - - /* persistent */ - PACKET_INIT(row_packet, PROT_ROW_PACKET, php_mysql_packet_row *, TRUE); - row_packet->result_set_memory_pool = result->result_set_memory_pool; - row_packet->field_count = result->meta->field_count; - row_packet->binary_protocol = result->m.row_decoder == php_mysqlnd_rowp_read_binary_protocol; - row_packet->fields_metadata = result->meta->fields; - row_packet->bit_fields_count = result->meta->bit_fields_count; - row_packet->bit_fields_total_len= result->meta->bit_fields_total_len; - row_packet->persistent_alloc = TRUE; - - 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; - total_rows += set->row_count; - - old_size = set->data_size; - set->data_size = total_rows; - set->data = mnd_perealloc(set->data, set->data_size * sizeof(zval **), set->persistent); -#if 0 - memset(set->data + old_size, 0, (set->data_size - old_size) * sizeof(zval **)); -#endif - set->row_buffers = mnd_perealloc(set->row_buffers, - total_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *), - set->persistent); - } - set->row_buffers[set->row_count] = row_packet->row_buffer; - set->data[set->row_count] = row_packet->fields; - - if (set->decode_in_foreground == FALSE) { - unsigned int i; - result->m.row_decoder(set->row_buffers[set->row_count], - set->data[set->row_count], - result->meta->field_count, - result->meta->fields, - result->conn->options.numeric_and_datetime_as_unicode, - result->conn->options.int_and_float_native, - result->conn->zval_cache, - &result->conn->stats TSRMLS_CC); - - for (i = 0; i < result->field_count; i++) { - /* - NULL fields are 0 length, 0 is not more than 0 - String of zero size, definitely can't be the next max_length. - Thus for NULL and zero-length we are quite efficient. - */ - if (Z_TYPE_P(set->data[set->row_count][i]) >= IS_STRING) { - unsigned long len = Z_STRLEN_P(set->data[set->row_count][i]); - if (result->meta->fields[i].max_length < len) { - result->meta->fields[i].max_length = len; - } - } - } - } - set->row_count++; - - tsrm_mutex_unlock(set->LOCK); - free_rows--; - - /* So row_packet's destructor function won't efree() it */ - row_packet->row_buffer = NULL; - row_packet->fields = NULL; - - /* - No need to FREE_ALLOCA as we can reuse the - 'lengths' and 'fields' arrays. For lengths its absolutely safe. - 'fields' is reused because the ownership of the strings has been - transfered above. - */ - } -#if 0 - MYSQLND_INC_CONN_STATISTIC_W_VALUE(&conn->stats, - binary_protocol? STAT_ROWS_BUFFERED_FROM_CLIENT_PS: - STAT_ROWS_BUFFERED_FROM_CLIENT_NORMAL, - set->row_count); -#endif - tsrm_mutex_lock(set->LOCK); - /* Finally clean */ - if (row_packet->eof) { - set->upsert_status.warning_count = row_packet->warning_count; - set->upsert_status.server_status = row_packet->server_status; - } - /* save some memory */ - if (free_rows) { - set->data_size = set->row_count; - set->data = mnd_perealloc(set->data, - (size_t) set->data_size * sizeof(zval **), set->persistent); - set->row_buffers = mnd_perealloc(set->row_buffers, - set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *), - set->persistent); - } - if (ret == FAIL) { - set->error_info = row_packet->error_info; - } else { - /* Position at the first row */ - set->data_cursor = set->data; - - /* libmysql's documentation says it should be so for SELECT statements */ - conn->upsert_status.affected_rows = set->row_count; - set->upsert_status.affected_rows = set->row_count; - } - set->bg_fetch_finished = TRUE; - tsrm_mutex_unlock(set->LOCK); - - PACKET_FREE(row_packet); - - if (conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS) { - CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING); - } else { - CONN_SET_STATE(conn, CONN_READY); - } - DBG_INF_FMT("ret=%s row_count=%u warnings=%u server_status=%u", ret == PASS? "PASS":"FAIL", - set->row_count, conn->upsert_status.warning_count, conn->upsert_status.server_status); - DBG_RETURN(ret); -} -/* }}} */ -#endif - - -/* {{{ mysqlnd_res::background_store_result */ -static MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_res, background_store_result)(MYSQLND_RES * result, MYSQLND * const conn, zend_bool ps TSRMLS_DC) -{ -#ifndef MYSQLND_THREADED - return (result->m.store_result(result, conn, ps TSRMLS_CC)); -#else - enum_func_status ret; - zend_bool to_cache = TRUE; - - DBG_ENTER("mysqlnd_res::background_store_result"); - DBG_INF_FMT("conn=%d ps_protocol=%d", conn->thread_id, ps); - - /* We need the conn because we are doing lazy zval initialization in buffered_fetch_row */ - result->conn = conn->m->get_reference(conn TSRMLS_CC); - result->type = MYSQLND_RES_NORMAL; - result->m.fetch_row = mysqlnd_fetch_row_async_buffered; - result->m.fetch_lengths = mysqlnd_fetch_lengths_async_buffered; - - result->bg_stored_data = mnd_pecalloc(1, sizeof(MYSQLND_RES_BG_BUFFERED), to_cache); - result->bg_stored_data->data_size = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY; - result->bg_stored_data->data = mnd_pecalloc(result->bg_stored_data->data_size, sizeof(zval **), to_cache); - result->bg_stored_data->row_buffers = mnd_pemalloc(STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY * sizeof(MYSQLND_MEMORY_POOL_CHUNK *), to_cache); - result->bg_stored_data->persistent = to_cache; - result->bg_stored_data->qcache = to_cache? mysqlnd_qcache_get_cache_reference(conn->qcache):NULL; - result->bg_stored_data->references = 1; - - result->bg_stored_data->LOCK = tsrm_mutex_alloc(); - - result->m.row_decoder = ps? php_mysqlnd_rowp_read_binary_protocol: - php_mysqlnd_rowp_read_text_protocol; - - CONN_SET_STATE(conn, CONN_FETCHING_DATA); - /* - This should be definitely TRUE. Decoding in background means creating zvals - which is not very safe for Zend MM, will complain in debug mode and more problems - also manifest themselves - unstable. - */ - result->bg_stored_data->decode_in_foreground = TRUE; - - result->lengths = mnd_ecalloc(result->field_count, sizeof(unsigned long)); - - pthread_mutex_lock(&conn->LOCK_work); - - pthread_cond_signal(&conn->COND_work); - do { - pthread_cond_wait(&conn->COND_work, &conn->LOCK_work); - } while (conn->current_result); /* this is our invariant */ - pthread_mutex_unlock(&conn->LOCK_work); - -#if 0 - ret = mysqlnd_background_store_result_fetch_data(result TSRMLS_CC); -#endif - - DBG_RETURN(result); -#endif -} -/* }}} */ - - /* {{{ mysqlnd_res::skip_result */ static enum_func_status MYSQLND_METHOD(mysqlnd_res, skip_result)(MYSQLND_RES * const result TSRMLS_DC) @@ -2030,7 +1524,6 @@ MYSQLND_RES *mysqlnd_result_init(unsigned int field_count, MYSQLND_THD_ZVAL_PCAC ret->m.use_result = MYSQLND_METHOD(mysqlnd_res, use_result); ret->m.store_result = MYSQLND_METHOD(mysqlnd_res, store_result); - ret->m.background_store_result = MYSQLND_METHOD(mysqlnd_res, background_store_result); ret->m.free_result = MYSQLND_METHOD(mysqlnd_res, free_result); ret->m.seek_data = MYSQLND_METHOD(mysqlnd_res, data_seek); ret->m.num_rows = MYSQLND_METHOD(mysqlnd_res, num_rows); diff --git a/ext/mysqlnd/mysqlnd_result.h b/ext/mysqlnd/mysqlnd_result.h index 8308204a6b..ee5199c58d 100644 --- a/ext/mysqlnd/mysqlnd_result.h +++ b/ext/mysqlnd/mysqlnd_result.h @@ -27,11 +27,6 @@ MYSQLND_RES *mysqlnd_result_init(unsigned int field_count, MYSQLND_THD_ZVAL_PCAC enum_func_status mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC); -#ifdef MYSQLND_THREADED -void * mysqlnd_fetch_thread(void *arg); -#endif - -enum_func_status mysqlnd_background_store_result_fetch_data(MYSQLND_RES *result TSRMLS_DC); #endif /* MYSQLND_RESULT_H */ /* diff --git a/ext/mysqlnd/mysqlnd_structs.h b/ext/mysqlnd/mysqlnd_structs.h index f4485f1d1e..ec08a4d399 100644 --- a/ext/mysqlnd/mysqlnd_structs.h +++ b/ext/mysqlnd/mysqlnd_structs.h @@ -195,7 +195,6 @@ typedef struct st_mysqlnd_result_bind MYSQLND_RESULT_BIND; typedef struct st_mysqlnd_result_metadata MYSQLND_RES_METADATA; typedef struct st_mysqlnd_buffered_result MYSQLND_RES_BUFFERED; -typedef struct st_mysqlnd_background_buffered_result MYSQLND_RES_BG_BUFFERED; typedef struct st_mysqlnd_unbuffered_result MYSQLND_RES_UNBUFFERED; typedef struct st_mysqlnd_debug MYSQLND_DEBUG; @@ -262,7 +261,6 @@ struct st_mysqlnd_conn_methods 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); enum_func_status (*next_result)(MYSQLND * const conn TSRMLS_DC); zend_bool (*more_results)(const MYSQLND * const conn TSRMLS_DC); @@ -323,7 +321,6 @@ struct st_mysqlnd_res_methods MYSQLND_RES * (*use_result)(MYSQLND_RES * const result, zend_bool ps_protocol TSRMLS_DC); MYSQLND_RES * (*store_result)(MYSQLND_RES * result, MYSQLND * const conn, zend_bool ps TSRMLS_DC); - MYSQLND_RES * (*background_store_result)(MYSQLND_RES * result, MYSQLND * const conn, zend_bool ps TSRMLS_DC); void (*fetch_into)(MYSQLND_RES *result, unsigned int flags, zval *return_value, enum_mysqlnd_extension ext TSRMLS_DC ZEND_FILE_LINE_DC); 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); @@ -380,7 +377,6 @@ struct st_mysqlnd_stmt_methods enum_func_status (*execute)(MYSQLND_STMT * const stmt TSRMLS_DC); MYSQLND_RES * (*use_result)(MYSQLND_STMT * const stmt TSRMLS_DC); MYSQLND_RES * (*store_result)(MYSQLND_STMT * const stmt TSRMLS_DC); - MYSQLND_RES * (*background_store_result)(MYSQLND_STMT * const stmt TSRMLS_DC); MYSQLND_RES * (*get_result)(MYSQLND_STMT * const stmt TSRMLS_DC); zend_bool (*more_results)(const MYSQLND_STMT * const stmt TSRMLS_DC); enum_func_status (*next_result)(MYSQLND_STMT * const stmt TSRMLS_DC); @@ -496,20 +492,6 @@ struct st_mysqlnd_connection /* stats */ MYSQLND_STATS stats; -#ifdef MYSQLND_THREADED - MUTEX_T LOCK_state; - - pthread_cond_t COND_work_done; - - pthread_mutex_t LOCK_work; - pthread_cond_t COND_work; - pthread_cond_t COND_thread_ended; - zend_bool thread_is_running; - zend_bool thread_killed; - void *** tsrm_ls; -#endif - - struct st_mysqlnd_conn_methods *m; }; @@ -541,31 +523,6 @@ struct st_mysqlnd_result_metadata }; -struct st_mysqlnd_background_buffered_result -{ - zval ***data; - uint64_t data_size; - zval ***data_cursor; - MYSQLND_MEMORY_POOL_CHUNK **row_buffers; - uint64_t row_count; - uint64_t initialized_rows; - zend_bool persistent; - - MYSQLND_QCACHE *qcache; - unsigned int references; - - zend_bool decode_in_foreground; - -#ifdef ZTS - zend_bool bg_fetch_finished; - MUTEX_T LOCK; -#endif - - mysqlnd_error_info error_info; - mysqlnd_upsert_status upsert_status; -}; - - struct st_mysqlnd_buffered_result { zval **data; @@ -606,7 +563,6 @@ struct st_mysqlnd_res /* To be used with store_result() - both normal and PS */ MYSQLND_RES_BUFFERED *stored_data; - MYSQLND_RES_BG_BUFFERED *bg_stored_data; MYSQLND_RES_UNBUFFERED *unbuf; /* diff --git a/ext/mysqlnd/php_mysqlnd.c b/ext/mysqlnd/php_mysqlnd.c index 585e5d86a7..a8d427ee4e 100644 --- a/ext/mysqlnd/php_mysqlnd.c +++ b/ext/mysqlnd/php_mysqlnd.c @@ -198,7 +198,7 @@ static PHP_MSHUTDOWN_FUNCTION(mysqlnd) /* }}} */ -#if defined(PHP_DEBUG) || defined(MYSQLND_THREADED) +#if defined(PHP_DEBUG) /* {{{ PHP_RINIT_FUNCTION */ static PHP_RINIT_FUNCTION(mysqlnd) @@ -212,9 +212,6 @@ static PHP_RINIT_FUNCTION(mysqlnd) dbg->m->set_mode(dbg, MYSQLND_G(debug)); MYSQLND_G(dbg) = dbg; } -#endif -#ifdef MYSQLND_THREADED - MYSQLND_G(thread_id) = tsrm_thread_id(); #endif return SUCCESS; } @@ -256,7 +253,7 @@ zend_module_entry mysqlnd_module_entry = { mysqlnd_functions, PHP_MINIT(mysqlnd), PHP_MSHUTDOWN(mysqlnd), -#if defined(PHP_DEBUG) || defined(MYSQLND_THREADED) +#if defined(PHP_DEBUG) PHP_RINIT(mysqlnd), #else NULL, -- 2.49.0