Annotation of embedaddon/php/ext/mysqlnd/mysqlnd_ps.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 2006-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Georg Richter <georg@mysql.com> |
16: | Andrey Hristov <andrey@mysql.com> |
17: | Ulf Wendel <uwendel@mysql.com> |
18: +----------------------------------------------------------------------+
19: */
20:
21: /* $Id: mysqlnd_ps.c 321634 2012-01-01 13:15:04Z felipe $ */
22: #include "php.h"
23: #include "mysqlnd.h"
24: #include "mysqlnd_wireprotocol.h"
25: #include "mysqlnd_priv.h"
26: #include "mysqlnd_result.h"
27: #include "mysqlnd_result_meta.h"
28: #include "mysqlnd_statistics.h"
29: #include "mysqlnd_debug.h"
30: #include "mysqlnd_block_alloc.h"
31:
32:
33: #define MYSQLND_SILENT
34:
35:
36: const char * const mysqlnd_not_bound_as_blob = "Can't send long data for non-string/non-binary data types";
37: const char * const mysqlnd_stmt_not_prepared = "Statement not prepared";
38:
39: static struct st_mysqlnd_stmt_methods *mysqlnd_stmt_methods;
40:
41: /* Exported by mysqlnd_ps_codec.c */
42: enum_func_status mysqlnd_stmt_execute_generate_request(MYSQLND_STMT * const s, zend_uchar ** request, size_t *request_len, zend_bool * free_buffer TSRMLS_DC);
43:
44: enum_func_status mysqlnd_stmt_fetch_row_buffered(MYSQLND_RES *result, void *param,
45: unsigned int flags,
46: zend_bool *fetched_anything TSRMLS_DC);
47:
48: enum_func_status mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param,
49: unsigned int flags,
50: zend_bool *fetched_anything TSRMLS_DC);
51:
52: static void mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const stmt TSRMLS_DC);
53: static void mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC);
54:
55: /* {{{ mysqlnd_stmt::store_result */
56: static MYSQLND_RES *
57: MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const s TSRMLS_DC)
58: {
59: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
60: enum_func_status ret;
61: MYSQLND * conn;
62: MYSQLND_RES * result;
63: zend_bool to_cache = FALSE;
64:
65: DBG_ENTER("mysqlnd_stmt::store_result");
66: if (!stmt || !stmt->conn || !stmt->result) {
67: DBG_RETURN(NULL);
68: }
69: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
70:
71: conn = stmt->conn;
72:
73: /* be compliant with libmysql - NULL will turn */
74: if (!stmt->field_count) {
75: DBG_RETURN(NULL);
76: }
77:
78: if (stmt->cursor_exists) {
79: /* Silently convert buffered to unbuffered, for now */
80: DBG_RETURN(s->m->use_result(s TSRMLS_CC));
81: }
82:
83: /* Nothing to store for UPSERT/LOAD DATA*/
84: if (CONN_GET_STATE(conn) != CONN_FETCHING_DATA ||
85: stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE)
86: {
87: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
88: UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
89: DBG_RETURN(NULL);
90: }
91:
92: stmt->default_rset_handler = s->m->store_result;
93:
94: SET_EMPTY_ERROR(stmt->error_info);
95: SET_EMPTY_ERROR(stmt->conn->error_info);
96: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_PS_BUFFERED_SETS);
97:
98: result = stmt->result;
99: result->type = MYSQLND_RES_PS_BUF;
100: result->m.fetch_row = mysqlnd_stmt_fetch_row_buffered;
101: result->m.fetch_lengths = NULL;/* makes no sense */
102:
103: result->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size) TSRMLS_CC);
104:
105: ret = result->m.store_result_fetch_data(conn, result, result->meta, TRUE, to_cache TSRMLS_CC);
106:
107: if (PASS == ret) {
108: /* libmysql API docs say it should be so for SELECT statements */
109: stmt->upsert_status.affected_rows = stmt->result->stored_data->row_count;
110:
111: stmt->state = MYSQLND_STMT_USE_OR_STORE_CALLED;
112: } else {
113: conn->error_info = result->stored_data->error_info;
114: stmt->result->m.free_result_contents(stmt->result TSRMLS_CC);
115: mnd_efree(stmt->result);
116: stmt->result = NULL;
117: stmt->state = MYSQLND_STMT_PREPARED;
118: }
119:
120: DBG_RETURN(result);
121: }
122: /* }}} */
123:
124:
125: /* {{{ mysqlnd_stmt::get_result */
126: static MYSQLND_RES *
127: MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const s TSRMLS_DC)
128: {
129: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
130: MYSQLND * conn;
131: MYSQLND_RES *result;
132:
133: DBG_ENTER("mysqlnd_stmt::get_result");
134: if (!stmt || !stmt->conn || !stmt->result) {
135: DBG_RETURN(NULL);
136: }
137: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
138:
139: conn = stmt->conn;
140:
141: /* be compliant with libmysql - NULL will turn */
142: if (!stmt->field_count) {
143: DBG_RETURN(NULL);
144: }
145:
146: if (stmt->cursor_exists) {
147: /* Silently convert buffered to unbuffered, for now */
148: DBG_RETURN(s->m->use_result(s TSRMLS_CC));
149: }
150:
151: /* Nothing to store for UPSERT/LOAD DATA*/
152: if (CONN_GET_STATE(conn) != CONN_FETCHING_DATA || stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE) {
153: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
154: UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
155: DBG_RETURN(NULL);
156: }
157:
158: SET_EMPTY_ERROR(stmt->error_info);
159: SET_EMPTY_ERROR(stmt->conn->error_info);
160: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS);
161:
162: do {
163: result = conn->m->result_init(stmt->result->field_count, stmt->persistent TSRMLS_CC);
164: if (!result) {
165: SET_OOM_ERROR(stmt->conn->error_info);
166: break;
167: }
168:
169: result->meta = stmt->result->meta->m->clone_metadata(stmt->result->meta, FALSE TSRMLS_CC);
170: if (!result->meta) {
171: SET_OOM_ERROR(stmt->conn->error_info);
172: break;
173: }
174:
175: if ((result = result->m.store_result(result, conn, TRUE TSRMLS_CC))) {
176: stmt->upsert_status.affected_rows = result->stored_data->row_count;
177: stmt->state = MYSQLND_STMT_PREPARED;
178: result->type = MYSQLND_RES_PS_BUF;
179: } else {
180: stmt->error_info = conn->error_info;
181: stmt->state = MYSQLND_STMT_PREPARED;
182: break;
183: }
184: DBG_RETURN(result);
185: } while (0);
186:
187: if (result) {
188: result->m.free_result(result, TRUE TSRMLS_CC);
189: }
190: DBG_RETURN(NULL);
191: }
192: /* }}} */
193:
194:
195: /* {{{ mysqlnd_stmt::more_results */
196: static zend_bool
197: MYSQLND_METHOD(mysqlnd_stmt, more_results)(const MYSQLND_STMT * s TSRMLS_DC)
198: {
199: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
200: DBG_ENTER("mysqlnd_stmt::more_results");
201: /* (conn->state == CONN_NEXT_RESULT_PENDING) too */
202: DBG_RETURN((stmt && stmt->conn && (stmt->conn->upsert_status.server_status &
203: SERVER_MORE_RESULTS_EXISTS))?
204: TRUE:
205: FALSE);
206: }
207: /* }}} */
208:
209:
210: /* {{{ mysqlnd_stmt::next_result */
211: static enum_func_status
212: MYSQLND_METHOD(mysqlnd_stmt, next_result)(MYSQLND_STMT * s TSRMLS_DC)
213: {
214: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
215: MYSQLND * conn;
216:
217: DBG_ENTER("mysqlnd_stmt::next_result");
218: if (!stmt || !stmt->conn || !stmt->result) {
219: DBG_RETURN(FAIL);
220: }
221: conn = stmt->conn;
222: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
223:
224: if (CONN_GET_STATE(conn) != CONN_NEXT_RESULT_PENDING || !(conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS)) {
225: DBG_RETURN(FAIL);
226: }
227:
228: DBG_INF_FMT("server_status=%u cursor=%u", stmt->upsert_status.server_status, stmt->upsert_status.server_status & SERVER_STATUS_CURSOR_EXISTS);
229: DBG_INF_FMT("server_status=%u cursor=%u", conn->upsert_status.server_status, conn->upsert_status.server_status & SERVER_STATUS_CURSOR_EXISTS);
230:
231: /* Free space for next result */
232: s->m->free_stmt_content(s TSRMLS_CC);
233: {
234: enum_func_status ret = s->m->parse_execute_response(s TSRMLS_CC);
235: DBG_RETURN(ret);
236: }
237: }
238: /* }}} */
239:
240:
241: /* {{{ mysqlnd_stmt_skip_metadata */
242: static enum_func_status
243: mysqlnd_stmt_skip_metadata(MYSQLND_STMT * s TSRMLS_DC)
244: {
245: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
246: /* Follows parameter metadata, we have just to skip it, as libmysql does */
247: unsigned int i = 0;
248: enum_func_status ret = FAIL;
249: MYSQLND_PACKET_RES_FIELD * field_packet;
250:
251: DBG_ENTER("mysqlnd_stmt_skip_metadata");
252: if (!stmt || !stmt->conn || !stmt->conn->protocol) {
253: DBG_RETURN(FAIL);
254: }
255: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
256:
257: field_packet = stmt->conn->protocol->m.get_result_field_packet(stmt->conn->protocol, FALSE TSRMLS_CC);
258: if (!field_packet) {
259: SET_OOM_ERROR(stmt->error_info);
260: SET_OOM_ERROR(stmt->conn->error_info);
261: } else {
262: ret = PASS;
263: field_packet->skip_parsing = TRUE;
264: for (;i < stmt->param_count; i++) {
265: if (FAIL == PACKET_READ(field_packet, stmt->conn)) {
266: ret = FAIL;
267: break;
268: }
269: }
270: PACKET_FREE(field_packet);
271: }
272:
273: DBG_RETURN(ret);
274: }
275: /* }}} */
276:
277:
278: /* {{{ mysqlnd_stmt_read_prepare_response */
279: static enum_func_status
280: mysqlnd_stmt_read_prepare_response(MYSQLND_STMT * s TSRMLS_DC)
281: {
282: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
283: MYSQLND_PACKET_PREPARE_RESPONSE * prepare_resp;
284: enum_func_status ret = FAIL;
285:
286: DBG_ENTER("mysqlnd_stmt_read_prepare_response");
287: if (!stmt || !stmt->conn || !stmt->conn->protocol) {
288: DBG_RETURN(FAIL);
289: }
290: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
291:
292: prepare_resp = stmt->conn->protocol->m.get_prepare_response_packet(stmt->conn->protocol, FALSE TSRMLS_CC);
293: if (!prepare_resp) {
294: SET_OOM_ERROR(stmt->error_info);
295: SET_OOM_ERROR(stmt->conn->error_info);
296: goto done;
297: }
298:
299: if (FAIL == PACKET_READ(prepare_resp, stmt->conn)) {
300: goto done;
301: }
302:
303: if (0xFF == prepare_resp->error_code) {
304: stmt->error_info = stmt->conn->error_info = prepare_resp->error_info;
305: goto done;
306: }
307: ret = PASS;
308: stmt->stmt_id = prepare_resp->stmt_id;
309: stmt->warning_count = stmt->conn->upsert_status.warning_count = prepare_resp->warning_count;
310: stmt->field_count = stmt->conn->field_count = prepare_resp->field_count;
311: stmt->param_count = prepare_resp->param_count;
312: done:
313: PACKET_FREE(prepare_resp);
314:
315: DBG_RETURN(ret);
316: }
317: /* }}} */
318:
319:
320: /* {{{ mysqlnd_stmt_prepare_read_eof */
321: static enum_func_status
322: mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT * s TSRMLS_DC)
323: {
324: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
325: MYSQLND_PACKET_EOF * fields_eof;
326: enum_func_status ret = FAIL;
327:
328: DBG_ENTER("mysqlnd_stmt_prepare_read_eof");
329: if (!stmt || !stmt->conn || !stmt->conn->protocol) {
330: DBG_RETURN(FAIL);
331: }
332: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
333:
334: fields_eof = stmt->conn->protocol->m.get_eof_packet(stmt->conn->protocol, FALSE TSRMLS_CC);
335: if (!fields_eof) {
336: SET_OOM_ERROR(stmt->error_info);
337: SET_OOM_ERROR(stmt->conn->error_info);
338: } else {
339: if (FAIL == (ret = PACKET_READ(fields_eof, stmt->conn))) {
340: if (stmt->result) {
341: stmt->result->m.free_result_contents(stmt->result TSRMLS_CC);
342: mnd_efree(stmt->result);
343: memset(stmt, 0, sizeof(MYSQLND_STMT_DATA));
344: stmt->state = MYSQLND_STMT_INITTED;
345: }
346: } else {
347: stmt->upsert_status.server_status = fields_eof->server_status;
348: stmt->upsert_status.warning_count = fields_eof->warning_count;
349: stmt->state = MYSQLND_STMT_PREPARED;
350: }
351: PACKET_FREE(fields_eof);
352: }
353:
354: DBG_RETURN(ret);
355: }
356: /* }}} */
357:
358:
359: /* {{{ mysqlnd_stmt::prepare */
360: static enum_func_status
361: MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const s, const char * const query, unsigned int query_len TSRMLS_DC)
362: {
363: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
364: MYSQLND_STMT * s_to_prepare = s;
365: MYSQLND_STMT_DATA * stmt_to_prepare = stmt;
366:
367: DBG_ENTER("mysqlnd_stmt::prepare");
368: if (!stmt || !stmt->conn) {
369: DBG_RETURN(FAIL);
370: }
371: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
372:
373: SET_ERROR_AFF_ROWS(stmt);
374: SET_ERROR_AFF_ROWS(stmt->conn);
375:
376: SET_EMPTY_ERROR(stmt->error_info);
377: SET_EMPTY_ERROR(stmt->conn->error_info);
378:
379: if (stmt->state > MYSQLND_STMT_INITTED) {
380: /* See if we have to clean the wire */
381: if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
382: /* Do implicit use_result and then flush the result */
383: stmt->default_rset_handler = s->m->use_result;
384: stmt->default_rset_handler(s TSRMLS_CC);
385: }
386: /* No 'else' here please :) */
387: if (stmt->state > MYSQLND_STMT_WAITING_USE_OR_STORE && stmt->result) {
388: stmt->result->m.skip_result(stmt->result TSRMLS_CC);
389: }
390: /*
391: Create a new test statement, which we will prepare, but if anything
392: fails, we will scrap it.
393: */
394: s_to_prepare = stmt->conn->m->stmt_init(stmt->conn TSRMLS_CC);
395: if (!s_to_prepare) {
396: goto fail;
397: }
398: stmt_to_prepare = s_to_prepare->data;
399: }
400:
401: 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) ||
402: FAIL == mysqlnd_stmt_read_prepare_response(s_to_prepare TSRMLS_CC))
403: {
404: goto fail;
405: }
406:
407: if (stmt_to_prepare->param_count) {
408: if (FAIL == mysqlnd_stmt_skip_metadata(s_to_prepare TSRMLS_CC) ||
409: FAIL == mysqlnd_stmt_prepare_read_eof(s_to_prepare TSRMLS_CC))
410: {
411: goto fail;
412: }
413: }
414:
415: /*
416: Read metadata only if there is actual result set.
417: Beware that SHOW statements bypass the PS framework and thus they send
418: no metadata at prepare.
419: */
420: if (stmt_to_prepare->field_count) {
421: MYSQLND_RES * result = stmt->conn->m->result_init(stmt_to_prepare->field_count, stmt_to_prepare->persistent TSRMLS_CC);
422: if (!result) {
423: SET_OOM_ERROR(stmt->conn->error_info);
424: goto fail;
425: }
426: /* Allocate the result now as it is needed for the reading of metadata */
427: stmt_to_prepare->result = result;
428:
429: result->conn = stmt_to_prepare->conn->m->get_reference(stmt_to_prepare->conn TSRMLS_CC);
430:
431: result->type = MYSQLND_RES_PS_BUF;
432:
433: if (FAIL == result->m.read_result_metadata(result, stmt_to_prepare->conn TSRMLS_CC) ||
434: FAIL == mysqlnd_stmt_prepare_read_eof(s_to_prepare TSRMLS_CC))
435: {
436: goto fail;
437: }
438: }
439:
440: if (stmt_to_prepare != stmt) {
441: /* swap */
442: size_t real_size = sizeof(MYSQLND_STMT) + mysqlnd_plugin_count() * sizeof(void *);
443: char * tmp_swap = mnd_malloc(real_size);
444: memcpy(tmp_swap, s, real_size);
445: memcpy(s, s_to_prepare, real_size);
446: memcpy(s_to_prepare, tmp_swap, real_size);
447: mnd_free(tmp_swap);
448: {
449: MYSQLND_STMT_DATA * tmp_swap_data = stmt_to_prepare;
450: stmt_to_prepare = stmt;
451: stmt = tmp_swap_data;
452: }
453: s_to_prepare->m->dtor(s_to_prepare, TRUE TSRMLS_CC);
454: }
455: stmt->state = MYSQLND_STMT_PREPARED;
456: DBG_INF("PASS");
457: DBG_RETURN(PASS);
458:
459: fail:
460: if (stmt_to_prepare != stmt && s_to_prepare) {
461: s_to_prepare->m->dtor(s_to_prepare, TRUE TSRMLS_CC);
462: }
463: stmt->state = MYSQLND_STMT_INITTED;
464:
465: DBG_INF("FAIL");
466: DBG_RETURN(FAIL);
467: }
468: /* }}} */
469:
470:
471: /* {{{ mysqlnd_stmt_execute_parse_response */
472: static enum_func_status
473: mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const s TSRMLS_DC)
474: {
475: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
476: enum_func_status ret;
477: MYSQLND * conn;
478:
479: DBG_ENTER("mysqlnd_stmt_execute_parse_response");
480: if (!stmt || !stmt->conn) {
481: DBG_RETURN(FAIL);
482: }
483: conn = stmt->conn;
484: CONN_SET_STATE(conn, CONN_QUERY_SENT);
485:
486: ret = mysqlnd_query_read_result_set_header(stmt->conn, s TSRMLS_CC);
487: if (ret == FAIL) {
488: stmt->error_info = conn->error_info;
489: stmt->upsert_status.affected_rows = conn->upsert_status.affected_rows;
490: if (CONN_GET_STATE(conn) == CONN_QUIT_SENT) {
491: /* close the statement here, the connection has been closed */
492: }
493: stmt->state = MYSQLND_STMT_PREPARED;
494: stmt->send_types_to_server = 1;
495: } else {
496: /*
497: stmt->send_types_to_server has already been set to 0 in
498: mysqlnd_stmt_execute_generate_request / mysqlnd_stmt_execute_store_params
499: In case there is a situation in which binding was done for integer and the
500: value is > LONG_MAX or < LONG_MIN, there is string conversion and we have
501: to resend the types. Next execution will also need to resend the type.
502: */
503: SET_EMPTY_ERROR(stmt->error_info);
504: SET_EMPTY_ERROR(stmt->conn->error_info);
505: stmt->upsert_status = conn->upsert_status;
506: stmt->state = MYSQLND_STMT_EXECUTED;
507: if (conn->last_query_type == QUERY_UPSERT || conn->last_query_type == QUERY_LOAD_LOCAL) {
508: DBG_INF("PASS");
509: DBG_RETURN(PASS);
510: }
511:
512: stmt->result->type = MYSQLND_RES_PS_BUF;
513: if (!stmt->result->conn) {
514: /*
515: For SHOW we don't create (bypasses PS in server)
516: a result set at prepare and thus a connection was missing
517: */
518: stmt->result->conn = stmt->conn->m->get_reference(stmt->conn TSRMLS_CC);
519: }
520:
521: /* Update stmt->field_count as SHOW sets it to 0 at prepare */
522: stmt->field_count = stmt->result->field_count = conn->field_count;
523: stmt->result->lengths = NULL;
524: if (stmt->field_count) {
525: stmt->state = MYSQLND_STMT_WAITING_USE_OR_STORE;
526: /*
527: We need to set this because the user might not call
528: use_result() or store_result() and we should be able to scrap the
529: data on the line, if he just decides to close the statement.
530: */
531: DBG_INF_FMT("server_status=%u cursor=%u", stmt->upsert_status.server_status,
532: stmt->upsert_status.server_status & SERVER_STATUS_CURSOR_EXISTS);
533:
534: if (stmt->upsert_status.server_status & SERVER_STATUS_CURSOR_EXISTS) {
535: DBG_INF("cursor exists");
536: stmt->cursor_exists = TRUE;
537: CONN_SET_STATE(conn, CONN_READY);
538: /* Only cursor read */
539: stmt->default_rset_handler = s->m->use_result;
540: DBG_INF("use_result");
541: } else if (stmt->flags & CURSOR_TYPE_READ_ONLY) {
542: DBG_INF("asked for cursor but got none");
543: /*
544: We have asked for CURSOR but got no cursor, because the condition
545: above is not fulfilled. Then...
546:
547: This is a single-row result set, a result set with no rows, EXPLAIN,
548: SHOW VARIABLES, or some other command which either a) bypasses the
549: cursors framework in the server and writes rows directly to the
550: network or b) is more efficient if all (few) result set rows are
551: precached on client and server's resources are freed.
552: */
553: /* preferred is buffered read */
554: stmt->default_rset_handler = s->m->store_result;
555: DBG_INF("store_result");
556: } else {
557: DBG_INF("no cursor");
558: /* preferred is unbuffered read */
559: stmt->default_rset_handler = s->m->use_result;
560: DBG_INF("use_result");
561: }
562: }
563: }
564: #ifndef MYSQLND_DONT_SKIP_OUT_PARAMS_RESULTSET
565: if (stmt->upsert_status.server_status & SERVER_PS_OUT_PARAMS) {
566: s->m->free_stmt_content(s TSRMLS_CC);
567: DBG_INF("PS OUT Variable RSet, skipping");
568: /* OUT params result set. Skip for now to retain compatibility */
569: ret = mysqlnd_stmt_execute_parse_response(s TSRMLS_CC);
570: }
571: #endif
572:
573: DBG_INF(ret == PASS? "PASS":"FAIL");
574: DBG_RETURN(ret);
575: }
576: /* }}} */
577:
578:
579: /* {{{ mysqlnd_stmt::execute */
580: static enum_func_status
581: MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const s TSRMLS_DC)
582: {
583: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
584: enum_func_status ret;
585: MYSQLND * conn;
586: zend_uchar *request = NULL;
587: size_t request_len;
588: zend_bool free_request;
589:
590: DBG_ENTER("mysqlnd_stmt::execute");
591: if (!stmt || !stmt->conn) {
592: DBG_RETURN(FAIL);
593: }
594: conn = stmt->conn;
595: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
596:
597: SET_ERROR_AFF_ROWS(stmt);
598: SET_ERROR_AFF_ROWS(stmt->conn);
599:
600: if (stmt->result && stmt->state >= MYSQLND_STMT_PREPARED && stmt->field_count) {
601: /*
602: We don need to copy the data from the buffers which we will clean.
603: Because it has already been copied. See
604: #ifndef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
605: */
606: #ifdef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
607: if (stmt->result_bind &&
608: stmt->result_zvals_separated_once == TRUE &&
609: stmt->state >= MYSQLND_STMT_USER_FETCHING)
610: {
611: /*
612: We need to copy the data from the buffers which we will clean.
613: The bound variables point to them only if the user has started
614: to fetch data (MYSQLND_STMT_USER_FETCHING).
615: We need to check 'result_zvals_separated_once' or we will leak
616: in the following scenario
617: prepare("select 1 from dual");
618: execute();
619: fetch(); <-- no binding, but that's not a problem
620: bind_result();
621: execute(); <-- here we will leak because we separate without need
622: */
623: unsigned int i;
624: for (i = 0; i < stmt->field_count; i++) {
625: if (stmt->result_bind[i].bound == TRUE) {
626: zval_copy_ctor(stmt->result_bind[i].zv);
627: }
628: }
629: }
630: #endif
631:
632: /*
633: If right after execute() we have to call the appropriate
634: use_result() or store_result() and clean.
635: */
636: if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
637: DBG_INF("fetching result set header");
638: /* Do implicit use_result and then flush the result */
639: stmt->default_rset_handler = s->m->use_result;
640: stmt->default_rset_handler(s TSRMLS_CC);
641: }
642:
643: if (stmt->state > MYSQLND_STMT_WAITING_USE_OR_STORE) {
644: DBG_INF("skipping result");
645: /* Flush if anything is left and unbuffered set */
646: stmt->result->m.skip_result(stmt->result TSRMLS_CC);
647: }
648:
649: if (stmt->state > MYSQLND_STMT_PREPARED) {
650: /* As the buffers have been freed, we should go back to PREPARED */
651: stmt->state = MYSQLND_STMT_PREPARED;
652: }
653:
654: /*
655: Executed, but the user hasn't started to fetch
656: This will clean also the metadata, but after the EXECUTE call we will
657: have it again.
658: */
659: stmt->result->m.free_result_buffers(stmt->result TSRMLS_CC);
660: } else if (stmt->state < MYSQLND_STMT_PREPARED) {
661: /* Only initted - error */
662: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE,
663: mysqlnd_out_of_sync);
664: SET_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
665: DBG_INF("FAIL");
666: DBG_RETURN(FAIL);
667: }
668:
669: if (stmt->param_count) {
670: unsigned int i, not_bound = 0;
671: if (!stmt->param_bind) {
672: SET_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, UNKNOWN_SQLSTATE,
673: "No data supplied for parameters in prepared statement");
674: DBG_INF("FAIL");
675: DBG_RETURN(FAIL);
676: }
677: for (i = 0; i < stmt->param_count; i++) {
678: if (stmt->param_bind[i].zv == NULL) {
679: not_bound++;
680: }
681: }
682: if (not_bound) {
683: char * msg;
684: spprintf(&msg, 0, "No data supplied for %u parameter%s in prepared statement",
685: not_bound, not_bound>1 ?"s":"");
686: SET_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, UNKNOWN_SQLSTATE, msg);
687: if (msg) {
688: efree(msg); /* allocated by spprintf */
689: }
690: DBG_INF("FAIL");
691: DBG_RETURN(FAIL);
692: }
693: }
694: ret = s->m->generate_execute_request(s, &request, &request_len, &free_request TSRMLS_CC);
695: if (ret == PASS) {
696: /* support for buffer types should be added here ! */
697: ret = stmt->conn->m->simple_command(stmt->conn, COM_STMT_EXECUTE, (char *)request, request_len,
698: PROT_LAST /* we will handle the response packet*/,
699: FALSE, FALSE TSRMLS_CC);
700: } else {
701: SET_STMT_ERROR(stmt, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, "Couldn't generate the request. Possibly OOM.");
702: }
703:
704: if (free_request) {
705: mnd_efree(request);
706: }
707:
708: if (ret == FAIL) {
709: stmt->error_info = conn->error_info;
710: DBG_INF("FAIL");
711: DBG_RETURN(FAIL);
712: }
713: stmt->execute_count++;
714:
715: ret = s->m->parse_execute_response(s TSRMLS_CC);
716:
717: DBG_INF_FMT("server_status=%u cursor=%u", stmt->upsert_status.server_status, stmt->upsert_status.server_status & SERVER_STATUS_CURSOR_EXISTS);
718:
719: if (ret == PASS && conn->last_query_type == QUERY_UPSERT && stmt->upsert_status.affected_rows) {
720: MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_PS, stmt->upsert_status.affected_rows);
721: }
722: DBG_RETURN(ret);
723: }
724: /* }}} */
725:
726:
727: /* {{{ mysqlnd_stmt_fetch_row_buffered */
728: enum_func_status
729: mysqlnd_stmt_fetch_row_buffered(MYSQLND_RES *result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
730: {
731: MYSQLND_STMT * s = (MYSQLND_STMT *) param;
732: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
733: MYSQLND_RES_BUFFERED *set = result->stored_data;
734: unsigned int field_count = result->meta->field_count;
735:
736: DBG_ENTER("mysqlnd_stmt_fetch_row_buffered");
737: *fetched_anything = FALSE;
738: DBG_INF_FMT("stmt=%lu", stmt != NULL ? stmt->stmt_id : 0L);
739:
740: /* If we haven't read everything */
741: if (set->data_cursor &&
742: (set->data_cursor - set->data) < (set->row_count * field_count))
743: {
744: /* The user could have skipped binding - don't crash*/
745: if (stmt->result_bind) {
746: unsigned int i;
747: MYSQLND_RES_METADATA * meta = result->meta;
748: zval **current_row = set->data_cursor;
749:
750: if (NULL == current_row[0]) {
751: uint64_t row_num = (set->data_cursor - set->data) / field_count;
752: enum_func_status rc = result->m.row_decoder(set->row_buffers[row_num],
753: current_row,
754: meta->field_count,
755: meta->fields,
756: result->stored_data->persistent,
757: result->conn->options.numeric_and_datetime_as_unicode,
758: result->conn->options.int_and_float_native,
759: result->conn->stats TSRMLS_CC);
760: if (PASS != rc) {
761: DBG_RETURN(FAIL);
762: }
763: set->initialized_rows++;
764: if (stmt->update_max_length) {
765: for (i = 0; i < result->field_count; i++) {
766: /*
767: NULL fields are 0 length, 0 is not more than 0
768: String of zero size, definitely can't be the next max_length.
769: Thus for NULL and zero-length we are quite efficient.
770: */
771: if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
772: unsigned long len = Z_STRLEN_P(current_row[i]);
773: if (meta->fields[i].max_length < len) {
774: meta->fields[i].max_length = len;
775: }
776: }
777: }
778: }
779: }
780:
781: for (i = 0; i < result->field_count; i++) {
782: /* Clean what we copied last time */
783: #ifndef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
784: if (stmt->result_bind[i].zv) {
785: zval_dtor(stmt->result_bind[i].zv);
786: }
787: #endif
788: /* copy the type */
789: if (stmt->result_bind[i].bound == TRUE) {
790: DBG_INF_FMT("i=%u type=%u", i, Z_TYPE_P(current_row[i]));
791: if (Z_TYPE_P(current_row[i]) != IS_NULL) {
792: /*
793: Copy the value.
794: Pre-condition is that the zvals in the result_bind buffer
795: have been ZVAL_NULL()-ed or to another simple type
796: (int, double, bool but not string). Because of the reference
797: counting the user can't delete the strings the variables point to.
798: */
799:
800: Z_TYPE_P(stmt->result_bind[i].zv) = Z_TYPE_P(current_row[i]);
801: stmt->result_bind[i].zv->value = current_row[i]->value;
802: #ifndef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
803: zval_copy_ctor(stmt->result_bind[i].zv);
804: #endif
805: } else {
806: ZVAL_NULL(stmt->result_bind[i].zv);
807: }
808: }
809: }
810: }
811: set->data_cursor += field_count;
812: *fetched_anything = TRUE;
813: /* buffered result sets don't have a connection */
814: MYSQLND_INC_GLOBAL_STATISTIC(STAT_ROWS_FETCHED_FROM_CLIENT_PS_BUF);
815: DBG_INF("row fetched");
816: } else {
817: set->data_cursor = NULL;
818: DBG_INF("no more data");
819: }
820: DBG_INF("PASS");
821: DBG_RETURN(PASS);
822: }
823: /* }}} */
824:
825:
826: /* {{{ mysqlnd_stmt_fetch_row_unbuffered */
827: static enum_func_status
828: mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES *result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
829: {
830: enum_func_status ret;
831: MYSQLND_STMT * s = (MYSQLND_STMT *) param;
832: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
833: MYSQLND_PACKET_ROW * row_packet;
834:
835: DBG_ENTER("mysqlnd_stmt_fetch_row_unbuffered");
836:
837: *fetched_anything = FALSE;
838:
839: if (result->unbuf->eof_reached) {
840: /* No more rows obviously */
841: DBG_INF("eof reached");
842: DBG_RETURN(PASS);
843: }
844: if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
845: SET_CLIENT_ERROR(result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
846: UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
847: DBG_ERR("command out of sync");
848: DBG_RETURN(FAIL);
849: }
850: if (!(row_packet = result->row_packet)) {
851: DBG_RETURN(FAIL);
852: }
853:
854: /* Let the row packet fill our buffer and skip additional malloc + memcpy */
855: row_packet->skip_extraction = stmt && stmt->result_bind? FALSE:TRUE;
856:
857: /*
858: If we skip rows (stmt == NULL || stmt->result_bind == NULL) we have to
859: result->m.unbuffered_free_last_data() before it. The function returns always true.
860: */
861: if (PASS == (ret = PACKET_READ(row_packet, result->conn)) && !row_packet->eof) {
862: unsigned int i, field_count = result->field_count;
863:
864: if (!row_packet->skip_extraction) {
865: result->m.unbuffered_free_last_data(result TSRMLS_CC);
866:
867: DBG_INF("extracting data");
868: result->unbuf->last_row_data = row_packet->fields;
869: result->unbuf->last_row_buffer = row_packet->row_buffer;
870: row_packet->fields = NULL;
871: row_packet->row_buffer = NULL;
872:
873: if (PASS != result->m.row_decoder(result->unbuf->last_row_buffer,
874: result->unbuf->last_row_data,
875: row_packet->field_count,
876: row_packet->fields_metadata,
877: FALSE,
878: result->conn->options.numeric_and_datetime_as_unicode,
879: result->conn->options.int_and_float_native,
880: result->conn->stats TSRMLS_CC))
881: {
882: DBG_RETURN(FAIL);
883: }
884:
885: for (i = 0; i < field_count; i++) {
886: if (stmt->result_bind[i].bound == TRUE) {
887: zval *data = result->unbuf->last_row_data[i];
888: /*
889: stmt->result_bind[i].zv has been already destructed
890: in result->m.unbuffered_free_last_data()
891: */
892: #ifndef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
893: zval_dtor(stmt->result_bind[i].zv);
894: #endif
895: if (IS_NULL != (Z_TYPE_P(stmt->result_bind[i].zv) = Z_TYPE_P(data)) ) {
896: if (
897: (Z_TYPE_P(data) == IS_STRING
898: #if MYSQLND_UNICODE
899: || Z_TYPE_P(data) == IS_UNICODE
900: #endif
901: )
902: && (result->meta->fields[i].max_length < (unsigned long) Z_STRLEN_P(data)))
903: {
904: result->meta->fields[i].max_length = Z_STRLEN_P(data);
905: }
906: stmt->result_bind[i].zv->value = data->value;
907: /* copied data, thus also the ownership. Thus null data */
908: ZVAL_NULL(data);
909: }
910: }
911: }
912: MYSQLND_INC_CONN_STATISTIC(stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_UNBUF);
913: } else {
914: DBG_INF("skipping extraction");
915: /*
916: Data has been allocated and usually result->m.unbuffered_free_last_data()
917: frees it but we can't call this function as it will cause problems with
918: the bound variables. Thus we need to do part of what it does or Zend will
919: report leaks.
920: */
921: row_packet->row_buffer->free_chunk(row_packet->row_buffer TSRMLS_CC);
922: row_packet->row_buffer = NULL;
923: }
924:
925: result->unbuf->row_count++;
926: *fetched_anything = TRUE;
927: } else if (ret == FAIL) {
928: if (row_packet->error_info.error_no) {
929: stmt->conn->error_info = row_packet->error_info;
930: stmt->error_info = row_packet->error_info;
931: }
932: CONN_SET_STATE(result->conn, CONN_READY);
933: result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
934: } else if (row_packet->eof) {
935: DBG_INF("EOF");
936: /* Mark the connection as usable again */
937: result->unbuf->eof_reached = TRUE;
938: result->conn->upsert_status.warning_count = row_packet->warning_count;
939: result->conn->upsert_status.server_status = row_packet->server_status;
940: /*
941: result->row_packet will be cleaned when
942: destroying the result object
943: */
944: if (result->conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS) {
945: CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
946: } else {
947: CONN_SET_STATE(result->conn, CONN_READY);
948: }
949: }
950:
951: DBG_INF_FMT("ret=%s fetched_anything=%u", ret == PASS? "PASS":"FAIL", *fetched_anything);
952: DBG_RETURN(ret);
953: }
954: /* }}} */
955:
956:
957: /* {{{ mysqlnd_stmt::use_result */
958: static MYSQLND_RES *
959: MYSQLND_METHOD(mysqlnd_stmt, use_result)(MYSQLND_STMT * s TSRMLS_DC)
960: {
961: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
962: MYSQLND_RES *result;
963: MYSQLND * conn;
964:
965: DBG_ENTER("mysqlnd_stmt::use_result");
966: if (!stmt || !stmt->conn || !stmt->result) {
967: DBG_RETURN(NULL);
968: }
969: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
970:
971: conn = stmt->conn;
972:
973: if (!stmt->field_count ||
974: (!stmt->cursor_exists && CONN_GET_STATE(conn) != CONN_FETCHING_DATA) ||
975: (stmt->cursor_exists && CONN_GET_STATE(conn) != CONN_READY) ||
976: (stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE))
977: {
978: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
979: UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
980: DBG_ERR("command out of sync");
981: DBG_RETURN(NULL);
982: }
983:
984: SET_EMPTY_ERROR(stmt->error_info);
985:
986: MYSQLND_INC_CONN_STATISTIC(stmt->conn->stats, STAT_PS_UNBUFFERED_SETS);
987: result = stmt->result;
988:
989: DBG_INF_FMT("%scursor exists", stmt->cursor_exists? "":"no ");
990: result->m.use_result(stmt->result, TRUE TSRMLS_CC);
991: result->m.fetch_row = stmt->cursor_exists? mysqlnd_fetch_stmt_row_cursor:
992: mysqlnd_stmt_fetch_row_unbuffered;
993: stmt->state = MYSQLND_STMT_USE_OR_STORE_CALLED;
994:
995: DBG_INF_FMT("%p", result);
996: DBG_RETURN(result);
997: }
998: /* }}} */
999:
1000:
1001: #define STMT_ID_LENGTH 4
1002:
1003: /* {{{ mysqlnd_fetch_row_cursor */
1004: enum_func_status
1005: mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
1006: {
1007: enum_func_status ret;
1008: MYSQLND_STMT * s = (MYSQLND_STMT *) param;
1009: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1010: zend_uchar buf[STMT_ID_LENGTH /* statement id */ + 4 /* number of rows to fetch */];
1011: MYSQLND_PACKET_ROW * row_packet;
1012:
1013: DBG_ENTER("mysqlnd_fetch_stmt_row_cursor");
1014:
1015: if (!stmt || !stmt->conn || !result || !result->conn || !result->unbuf) {
1016: DBG_ERR("no statement");
1017: DBG_RETURN(FAIL);
1018: }
1019:
1020: DBG_INF_FMT("stmt=%lu flags=%u", stmt->stmt_id, flags);
1021:
1022: if (stmt->state < MYSQLND_STMT_USER_FETCHING) {
1023: /* Only initted - error */
1024: SET_CLIENT_ERROR(stmt->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE,
1025: mysqlnd_out_of_sync);
1026: DBG_ERR("command out of sync");
1027: DBG_RETURN(FAIL);
1028: }
1029: if (!(row_packet = result->row_packet)) {
1030: DBG_RETURN(FAIL);
1031: }
1032:
1033: SET_EMPTY_ERROR(stmt->error_info);
1034: SET_EMPTY_ERROR(stmt->conn->error_info);
1035:
1036: int4store(buf, stmt->stmt_id);
1037: int4store(buf + STMT_ID_LENGTH, 1); /* for now fetch only one row */
1038:
1039: if (FAIL == stmt->conn->m->simple_command(stmt->conn, COM_STMT_FETCH, (char *)buf, sizeof(buf),
1040: PROT_LAST /* we will handle the response packet*/,
1041: FALSE, TRUE TSRMLS_CC)) {
1042: stmt->error_info = stmt->conn->error_info;
1043: DBG_RETURN(FAIL);
1044: }
1045:
1046: row_packet->skip_extraction = stmt->result_bind? FALSE:TRUE;
1047:
1048: if (PASS == (ret = PACKET_READ(row_packet, result->conn)) && !row_packet->eof) {
1049: unsigned int i, field_count = result->field_count;
1050:
1051: DBG_INF_FMT("skip_extraction=%u", row_packet->skip_extraction);
1052: if (!row_packet->skip_extraction) {
1053: result->m.unbuffered_free_last_data(result TSRMLS_CC);
1054:
1055: DBG_INF("extracting data");
1056: result->unbuf->last_row_data = row_packet->fields;
1057: result->unbuf->last_row_buffer = row_packet->row_buffer;
1058: row_packet->fields = NULL;
1059: row_packet->row_buffer = NULL;
1060:
1061: if (PASS != result->m.row_decoder(result->unbuf->last_row_buffer,
1062: result->unbuf->last_row_data,
1063: row_packet->field_count,
1064: row_packet->fields_metadata,
1065: FALSE,
1066: result->conn->options.numeric_and_datetime_as_unicode,
1067: result->conn->options.int_and_float_native,
1068: result->conn->stats TSRMLS_CC))
1069: {
1070: DBG_RETURN(FAIL);
1071: }
1072:
1073: /* If no result bind, do nothing. We consumed the data */
1074: for (i = 0; i < field_count; i++) {
1075: if (stmt->result_bind[i].bound == TRUE) {
1076: zval *data = result->unbuf->last_row_data[i];
1077: /*
1078: stmt->result_bind[i].zv has been already destructed
1079: in result->m.unbuffered_free_last_data()
1080: */
1081: #ifndef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
1082: zval_dtor(stmt->result_bind[i].zv);
1083: #endif
1084: DBG_INF_FMT("i=%u bound_var=%p type=%u refc=%u", i, stmt->result_bind[i].zv,
1085: Z_TYPE_P(data), Z_REFCOUNT_P(stmt->result_bind[i].zv));
1086: if (IS_NULL != (Z_TYPE_P(stmt->result_bind[i].zv) = Z_TYPE_P(data))) {
1087: if ((Z_TYPE_P(data) == IS_STRING
1088: #if MYSQLND_UNICODE
1089: || Z_TYPE_P(data) == IS_UNICODE
1090: #endif
1091: )
1092: && (result->meta->fields[i].max_length < (unsigned long) Z_STRLEN_P(data)))
1093: {
1094: result->meta->fields[i].max_length = Z_STRLEN_P(data);
1095: }
1096: stmt->result_bind[i].zv->value = data->value;
1097: /* copied data, thus also the ownership. Thus null data */
1098: ZVAL_NULL(data);
1099: }
1100: }
1101: }
1102: } else {
1103: DBG_INF("skipping extraction");
1104: /*
1105: Data has been allocated and usually result->m.unbuffered_free_last_data()
1106: frees it but we can't call this function as it will cause problems with
1107: the bound variables. Thus we need to do part of what it does or Zend will
1108: report leaks.
1109: */
1110: row_packet->row_buffer->free_chunk(row_packet->row_buffer TSRMLS_CC);
1111: row_packet->row_buffer = NULL;
1112: }
1113: /* We asked for one row, the next one should be EOF, eat it */
1114: ret = PACKET_READ(row_packet, result->conn);
1115: if (row_packet->row_buffer) {
1116: row_packet->row_buffer->free_chunk(row_packet->row_buffer TSRMLS_CC);
1117: row_packet->row_buffer = NULL;
1118: }
1119: MYSQLND_INC_CONN_STATISTIC(stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_CURSOR);
1120:
1121: result->unbuf->row_count++;
1122: *fetched_anything = TRUE;
1123: } else {
1124: *fetched_anything = FALSE;
1125:
1126: stmt->upsert_status.warning_count =
1127: stmt->conn->upsert_status.warning_count =
1128: row_packet->warning_count;
1129:
1130: stmt->upsert_status.server_status =
1131: stmt->conn->upsert_status.server_status =
1132: row_packet->server_status;
1133:
1134: result->unbuf->eof_reached = row_packet->eof;
1135: }
1136: stmt->upsert_status.warning_count =
1137: stmt->conn->upsert_status.warning_count =
1138: row_packet->warning_count;
1139: stmt->upsert_status.server_status =
1140: stmt->conn->upsert_status.server_status =
1141: row_packet->server_status;
1142:
1143: DBG_INF_FMT("ret=%s fetched=%u server_status=%u warnings=%u eof=%u",
1144: ret == PASS? "PASS":"FAIL", *fetched_anything,
1145: row_packet->server_status, row_packet->warning_count,
1146: result->unbuf->eof_reached);
1147: DBG_RETURN(ret);
1148: }
1149: /* }}} */
1150:
1151:
1152: /* {{{ mysqlnd_stmt::fetch */
1153: static enum_func_status
1154: MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const s, zend_bool * const fetched_anything TSRMLS_DC)
1155: {
1156: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1157: enum_func_status ret;
1158: DBG_ENTER("mysqlnd_stmt::fetch");
1159: if (!stmt || !stmt->conn) {
1160: DBG_RETURN(FAIL);
1161: }
1162: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
1163:
1164: if (!stmt->result ||
1165: stmt->state < MYSQLND_STMT_WAITING_USE_OR_STORE) {
1166: SET_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
1167:
1168: DBG_ERR("command out of sync");
1169: DBG_RETURN(FAIL);
1170: } else if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
1171: /* Execute only once. We have to free the previous contents of user's bound vars */
1172:
1173: stmt->default_rset_handler(s TSRMLS_CC);
1174: }
1175: stmt->state = MYSQLND_STMT_USER_FETCHING;
1176:
1177: SET_EMPTY_ERROR(stmt->error_info);
1178: SET_EMPTY_ERROR(stmt->conn->error_info);
1179:
1180: DBG_INF_FMT("result_bind=%p separated_once=%u", stmt->result_bind, stmt->result_zvals_separated_once);
1181: /*
1182: The user might have not bound any variables for result.
1183: Do the binding once she does it.
1184: */
1185: if (stmt->result_bind && !stmt->result_zvals_separated_once) {
1186: unsigned int i;
1187: /*
1188: mysqlnd_stmt_store_result() has been called free the bind
1189: variables to prevent leaking of their previous content.
1190: */
1191: for (i = 0; i < stmt->result->field_count; i++) {
1192: if (stmt->result_bind[i].bound == TRUE) {
1193: zval_dtor(stmt->result_bind[i].zv);
1194: ZVAL_NULL(stmt->result_bind[i].zv);
1195: }
1196: }
1197: stmt->result_zvals_separated_once = TRUE;
1198: }
1199:
1200: ret = stmt->result->m.fetch_row(stmt->result, (void*)s, 0, fetched_anything TSRMLS_CC);
1201: DBG_RETURN(ret);
1202: }
1203: /* }}} */
1204:
1205:
1206: /* {{{ mysqlnd_stmt::reset */
1207: static enum_func_status
1208: MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const s TSRMLS_DC)
1209: {
1210: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1211: enum_func_status ret = PASS;
1212: zend_uchar cmd_buf[STMT_ID_LENGTH /* statement id */];
1213:
1214: DBG_ENTER("mysqlnd_stmt::reset");
1215: if (!stmt || !stmt->conn) {
1216: DBG_RETURN(FAIL);
1217: }
1218: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
1219:
1220: SET_EMPTY_ERROR(stmt->error_info);
1221: SET_EMPTY_ERROR(stmt->conn->error_info);
1222:
1223: if (stmt->stmt_id) {
1224: MYSQLND * conn = stmt->conn;
1225: if (stmt->param_bind) {
1226: unsigned int i;
1227: DBG_INF("resetting long data");
1228: /* Reset Long Data */
1229: for (i = 0; i < stmt->param_count; i++) {
1230: if (stmt->param_bind[i].flags & MYSQLND_PARAM_BIND_BLOB_USED) {
1231: stmt->param_bind[i].flags &= ~MYSQLND_PARAM_BIND_BLOB_USED;
1232: }
1233: }
1234: }
1235:
1236: /*
1237: If the user decided to close the statement right after execute()
1238: We have to call the appropriate use_result() or store_result() and
1239: clean.
1240: */
1241: do {
1242: if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
1243: DBG_INF("fetching result set header");
1244: stmt->default_rset_handler(s TSRMLS_CC);
1245: stmt->state = MYSQLND_STMT_USER_FETCHING;
1246: }
1247:
1248: if (stmt->result) {
1249: DBG_INF("skipping result");
1250: stmt->result->m.skip_result(stmt->result TSRMLS_CC);
1251: }
1252: } while (mysqlnd_stmt_more_results(s) && mysqlnd_stmt_next_result(s) == PASS);
1253:
1254: /*
1255: Don't free now, let the result be usable. When the stmt will again be
1256: executed then the result set will be cleaned, the bound variables will
1257: be separated before that.
1258: */
1259:
1260: int4store(cmd_buf, stmt->stmt_id);
1261: if (CONN_GET_STATE(conn) == CONN_READY &&
1262: FAIL == (ret = conn->m->simple_command(conn, COM_STMT_RESET, (char *)cmd_buf,
1263: sizeof(cmd_buf), PROT_OK_PACKET,
1264: FALSE, TRUE TSRMLS_CC))) {
1265: stmt->error_info = conn->error_info;
1266: }
1267: stmt->upsert_status = conn->upsert_status;
1268:
1269: stmt->state = MYSQLND_STMT_PREPARED;
1270: }
1271: DBG_INF(ret == PASS? "PASS":"FAIL");
1272: DBG_RETURN(ret);
1273: }
1274: /* }}} */
1275:
1276:
1277: /* {{{ mysqlnd_stmt::send_long_data */
1278: static enum_func_status
1279: MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const s, unsigned int param_no,
1280: const char * const data, unsigned long length TSRMLS_DC)
1281: {
1282: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1283: enum_func_status ret = FAIL;
1284: MYSQLND * conn;
1285: zend_uchar *cmd_buf;
1286: enum php_mysqlnd_server_command cmd = COM_STMT_SEND_LONG_DATA;
1287:
1288: DBG_ENTER("mysqlnd_stmt::send_long_data");
1289: if (!stmt || !stmt->conn) {
1290: DBG_RETURN(FAIL);
1291: }
1292: DBG_INF_FMT("stmt=%lu param_no=%u data_len=%lu", stmt->stmt_id, param_no, length);
1293:
1294: conn = stmt->conn;
1295:
1296: SET_EMPTY_ERROR(stmt->error_info);
1297: SET_EMPTY_ERROR(stmt->conn->error_info);
1298:
1299: if (stmt->state < MYSQLND_STMT_PREPARED) {
1300: SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
1301: DBG_ERR("not prepared");
1302: DBG_RETURN(FAIL);
1303: }
1304: if (!stmt->param_bind) {
1305: SET_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
1306: DBG_ERR("command out of sync");
1307: DBG_RETURN(FAIL);
1308: }
1309:
1310: if (param_no >= stmt->param_count) {
1311: SET_STMT_ERROR(stmt, CR_INVALID_PARAMETER_NO, UNKNOWN_SQLSTATE, "Invalid parameter number");
1312: DBG_ERR("invalid param_no");
1313: DBG_RETURN(FAIL);
1314: }
1315: if (stmt->param_bind[param_no].type != MYSQL_TYPE_LONG_BLOB) {
1316: SET_STMT_ERROR(stmt, CR_INVALID_BUFFER_USE, UNKNOWN_SQLSTATE, mysqlnd_not_bound_as_blob);
1317: DBG_ERR("param_no is not of a blob type");
1318: DBG_RETURN(FAIL);
1319: }
1320:
1321: /*
1322: XXX: Unfortunately we have to allocate additional buffer to be able the
1323: additional data, which is like a header inside the payload.
1324: This should be optimised, but it will be a pervasive change, so
1325: conn->m->simple_command() will accept not a buffer, but actually MYSQLND_STRING*
1326: terminated by NULL, to send. If the strings are not big, we can collapse them
1327: on the buffer every connection has, but otherwise we will just send them
1328: one by one to the wire.
1329: */
1330:
1331: if (CONN_GET_STATE(conn) == CONN_READY) {
1332: size_t packet_len;
1333: cmd_buf = mnd_emalloc(packet_len = STMT_ID_LENGTH + 2 + length);
1334: if (cmd_buf) {
1335: stmt->param_bind[param_no].flags |= MYSQLND_PARAM_BIND_BLOB_USED;
1336:
1337: int4store(cmd_buf, stmt->stmt_id);
1338: int2store(cmd_buf + STMT_ID_LENGTH, param_no);
1339: memcpy(cmd_buf + STMT_ID_LENGTH + 2, data, length);
1340:
1341: /* COM_STMT_SEND_LONG_DATA doesn't send an OK packet*/
1342: ret = conn->m->simple_command(conn, cmd, (char *)cmd_buf, packet_len, PROT_LAST , FALSE, TRUE TSRMLS_CC);
1343: mnd_efree(cmd_buf);
1344: if (FAIL == ret) {
1345: stmt->error_info = conn->error_info;
1346: }
1347: } else {
1348: ret = FAIL;
1349: SET_OOM_ERROR(stmt->error_info);
1350: SET_OOM_ERROR(conn->error_info);
1351: }
1352: /*
1353: Cover protocol error: COM_STMT_SEND_LONG_DATA was designed to be quick and not
1354: sent response packets. According to documentation the only way to get an error
1355: is to have out-of-memory on the server-side. However, that's not true, as if
1356: max_allowed_packet_size is smaller than the chunk being sent to the server, the
1357: latter will complain with an error message. However, normally we don't expect
1358: an error message, thus we continue. When sending the next command, which expects
1359: response we will read the unexpected data and error message will look weird.
1360: Therefore we do non-blocking read to clean the line, if there is a need.
1361: Nevertheless, there is a built-in protection when sending a command packet, that
1362: checks if the line is clear - useful for debug purposes and to be switched off
1363: in release builds.
1364:
1365: Maybe we can make it automatic by checking what's the value of
1366: max_allowed_packet_size on the server and resending the data.
1367: */
1368: #ifdef MYSQLND_DO_WIRE_CHECK_BEFORE_COMMAND
1369: #if HAVE_USLEEP && !defined(PHP_WIN32)
1370: usleep(120000);
1371: #endif
1372: if ((packet_len = conn->net->m.consume_uneaten_data(conn->net, cmd TSRMLS_CC))) {
1373: php_error_docref(NULL TSRMLS_CC, E_WARNING, "There was an error "
1374: "while sending long data. Probably max_allowed_packet_size "
1375: "is smaller than the data. You have to increase it or send "
1376: "smaller chunks of data. Answer was "MYSQLND_SZ_T_SPEC" bytes long.", packet_len);
1377: SET_STMT_ERROR(stmt, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE,
1378: "Server responded to COM_STMT_SEND_LONG_DATA.");
1379: ret = FAIL;
1380: }
1381: #endif
1382: }
1383:
1384: DBG_INF(ret == PASS? "PASS":"FAIL");
1385: DBG_RETURN(ret);
1386: }
1387: /* }}} */
1388:
1389:
1390: /* {{{ mysqlnd_stmt::bind_parameters */
1391: static enum_func_status
1392: MYSQLND_METHOD(mysqlnd_stmt, bind_parameters)(MYSQLND_STMT * const s, MYSQLND_PARAM_BIND * const param_bind TSRMLS_DC)
1393: {
1394: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1395: DBG_ENTER("mysqlnd_stmt::bind_param");
1396: if (!stmt || !stmt->conn) {
1397: DBG_RETURN(FAIL);
1398: }
1399: DBG_INF_FMT("stmt=%lu param_count=%u", stmt->stmt_id, stmt->param_count);
1400:
1401: if (stmt->state < MYSQLND_STMT_PREPARED) {
1402: SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
1403: DBG_ERR("not prepared");
1404: if (param_bind) {
1405: s->m->free_parameter_bind(s, param_bind TSRMLS_CC);
1406: }
1407: DBG_RETURN(FAIL);
1408: }
1409:
1410: SET_EMPTY_ERROR(stmt->error_info);
1411: SET_EMPTY_ERROR(stmt->conn->error_info);
1412:
1413: if (stmt->param_count) {
1414: unsigned int i = 0;
1415:
1416: if (!param_bind) {
1417: SET_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, "Re-binding (still) not supported");
1418: DBG_ERR("Re-binding (still) not supported");
1419: DBG_RETURN(FAIL);
1420: } else if (stmt->param_bind) {
1421: DBG_INF("Binding");
1422: /*
1423: There is already result bound.
1424: Forbid for now re-binding!!
1425: */
1426: for (i = 0; i < stmt->param_count; i++) {
1427: /*
1428: We may have the last reference, then call zval_ptr_dtor()
1429: or we may leak memory.
1430: Switching from bind_one_parameter to bind_parameters may result in zv being NULL
1431: */
1432: if (stmt->param_bind[i].zv) {
1433: zval_ptr_dtor(&stmt->param_bind[i].zv);
1434: }
1435: }
1436: if (stmt->param_bind != param_bind) {
1437: s->m->free_parameter_bind(s, stmt->param_bind TSRMLS_CC);
1438: }
1439: }
1440:
1441: stmt->param_bind = param_bind;
1442: for (i = 0; i < stmt->param_count; i++) {
1443: /* The client will use stmt_send_long_data */
1444: DBG_INF_FMT("%u is of type %u", i, stmt->param_bind[i].type);
1445: /* Prevent from freeing */
1446: /* Don't update is_ref, or we will leak during conversion */
1447: Z_ADDREF_P(stmt->param_bind[i].zv);
1448: stmt->param_bind[i].flags = 0;
1449: if (stmt->param_bind[i].type == MYSQL_TYPE_LONG_BLOB) {
1450: stmt->param_bind[i].flags &= ~MYSQLND_PARAM_BIND_BLOB_USED;
1451: }
1452: }
1453: stmt->send_types_to_server = 1;
1454: }
1455: DBG_INF("PASS");
1456: DBG_RETURN(PASS);
1457: }
1458: /* }}} */
1459:
1460:
1461: /* {{{ mysqlnd_stmt::bind_one_parameter */
1462: static enum_func_status
1463: MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter)(MYSQLND_STMT * const s, unsigned int param_no,
1464: zval * const zv, zend_uchar type TSRMLS_DC)
1465: {
1466: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1467: DBG_ENTER("mysqlnd_stmt::bind_one_parameter");
1468: if (!stmt || !stmt->conn) {
1469: DBG_RETURN(FAIL);
1470: }
1471: DBG_INF_FMT("stmt=%lu param_no=%u param_count=%u type=%u",
1472: stmt->stmt_id, param_no, stmt->param_count, type);
1473:
1474: if (stmt->state < MYSQLND_STMT_PREPARED) {
1475: SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
1476: DBG_ERR("not prepared");
1477: DBG_RETURN(FAIL);
1478: }
1479:
1480: if (param_no >= stmt->param_count) {
1481: SET_STMT_ERROR(stmt, CR_INVALID_PARAMETER_NO, UNKNOWN_SQLSTATE, "Invalid parameter number");
1482: DBG_ERR("invalid param_no");
1483: DBG_RETURN(FAIL);
1484: }
1485: SET_EMPTY_ERROR(stmt->error_info);
1486: SET_EMPTY_ERROR(stmt->conn->error_info);
1487:
1488: if (stmt->param_count) {
1489: if (!stmt->param_bind) {
1490: stmt->param_bind = mnd_ecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND));
1491: if (!stmt->param_bind) {
1492: DBG_RETURN(FAIL);
1493: }
1494: }
1495:
1496: /* Prevent from freeing */
1497: /* Don't update is_ref, or we will leak during conversion */
1498: Z_ADDREF_P(zv);
1499: DBG_INF("Binding");
1500: /* Release what we had, if we had */
1501: if (stmt->param_bind[param_no].zv) {
1502: zval_ptr_dtor(&stmt->param_bind[param_no].zv);
1503: }
1504: if (type == MYSQL_TYPE_LONG_BLOB) {
1505: /* The client will use stmt_send_long_data */
1506: stmt->param_bind[param_no].flags &= ~MYSQLND_PARAM_BIND_BLOB_USED;
1507: }
1508: stmt->param_bind[param_no].zv = zv;
1509: stmt->param_bind[param_no].type = type;
1510:
1511: stmt->send_types_to_server = 1;
1512: }
1513: DBG_INF("PASS");
1514: DBG_RETURN(PASS);
1515: }
1516: /* }}} */
1517:
1518:
1519: /* {{{ mysqlnd_stmt::refresh_bind_param */
1520: static enum_func_status
1521: MYSQLND_METHOD(mysqlnd_stmt, refresh_bind_param)(MYSQLND_STMT * const s TSRMLS_DC)
1522: {
1523: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1524: DBG_ENTER("mysqlnd_stmt::refresh_bind_param");
1525: if (!stmt || !stmt->conn) {
1526: DBG_RETURN(FAIL);
1527: }
1528: DBG_INF_FMT("stmt=%lu param_count=%u", stmt->stmt_id, stmt->param_count);
1529:
1530: if (stmt->state < MYSQLND_STMT_PREPARED) {
1531: SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
1532: DBG_ERR("not prepared");
1533: DBG_RETURN(FAIL);
1534: }
1535:
1536: SET_EMPTY_ERROR(stmt->error_info);
1537: SET_EMPTY_ERROR(stmt->conn->error_info);
1538:
1539: if (stmt->param_count) {
1540: stmt->send_types_to_server = 1;
1541: }
1542: DBG_INF("PASS");
1543: DBG_RETURN(PASS);
1544: }
1545: /* }}} */
1546:
1547:
1548: /* {{{ mysqlnd_stmt::bind_result */
1549: static enum_func_status
1550: MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const s,
1551: MYSQLND_RESULT_BIND * const result_bind TSRMLS_DC)
1552: {
1553: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1554: DBG_ENTER("mysqlnd_stmt::bind_result");
1555: if (!stmt || !stmt->conn) {
1556: DBG_RETURN(FAIL);
1557: }
1558: DBG_INF_FMT("stmt=%lu field_count=%u", stmt->stmt_id, stmt->field_count);
1559:
1560: if (stmt->state < MYSQLND_STMT_PREPARED) {
1561: SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
1562: if (result_bind) {
1563: s->m->free_result_bind(s, result_bind TSRMLS_CC);
1564: }
1565: DBG_ERR("not prepared");
1566: DBG_RETURN(FAIL);
1567: }
1568:
1569: SET_EMPTY_ERROR(stmt->error_info);
1570: SET_EMPTY_ERROR(stmt->conn->error_info);
1571:
1572: if (stmt->field_count) {
1573: unsigned int i = 0;
1574:
1575: if (!result_bind) {
1576: DBG_ERR("no result bind passed");
1577: DBG_RETURN(FAIL);
1578: }
1579:
1580: mysqlnd_stmt_separate_result_bind(s TSRMLS_CC);
1581: stmt->result_zvals_separated_once = FALSE;
1582: stmt->result_bind = result_bind;
1583: for (i = 0; i < stmt->field_count; i++) {
1584: /* Prevent from freeing */
1585: Z_ADDREF_P(stmt->result_bind[i].zv);
1586: DBG_INF_FMT("ref of %p = %u", stmt->result_bind[i].zv, Z_REFCOUNT_P(stmt->result_bind[i].zv));
1587: /*
1588: Don't update is_ref !!! it's not our job
1589: Otherwise either 009.phpt or mysqli_stmt_bind_result.phpt
1590: will fail.
1591: */
1592: stmt->result_bind[i].bound = TRUE;
1593: }
1594: } else if (result_bind) {
1595: s->m->free_result_bind(s, result_bind TSRMLS_CC);
1596: }
1597: DBG_INF("PASS");
1598: DBG_RETURN(PASS);
1599: }
1600: /* }}} */
1601:
1602:
1603: /* {{{ mysqlnd_stmt::bind_result */
1604: static enum_func_status
1605: MYSQLND_METHOD(mysqlnd_stmt, bind_one_result)(MYSQLND_STMT * const s, unsigned int param_no TSRMLS_DC)
1606: {
1607: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1608: DBG_ENTER("mysqlnd_stmt::bind_result");
1609: if (!stmt || !stmt->conn) {
1610: DBG_RETURN(FAIL);
1611: }
1612: DBG_INF_FMT("stmt=%lu field_count=%u", stmt->stmt_id, stmt->field_count);
1613:
1614: if (stmt->state < MYSQLND_STMT_PREPARED) {
1615: SET_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, UNKNOWN_SQLSTATE, mysqlnd_stmt_not_prepared);
1616: DBG_ERR("not prepared");
1617: DBG_RETURN(FAIL);
1618: }
1619:
1620: if (param_no >= stmt->field_count) {
1621: SET_STMT_ERROR(stmt, CR_INVALID_PARAMETER_NO, UNKNOWN_SQLSTATE, "Invalid parameter number");
1622: DBG_ERR("invalid param_no");
1623: DBG_RETURN(FAIL);
1624: }
1625:
1626: SET_EMPTY_ERROR(stmt->error_info);
1627: SET_EMPTY_ERROR(stmt->conn->error_info);
1628:
1629: if (stmt->field_count) {
1630: mysqlnd_stmt_separate_one_result_bind(s, param_no TSRMLS_CC);
1631: /* Guaranteed is that stmt->result_bind is NULL */
1632: if (!stmt->result_bind) {
1633: stmt->result_bind = mnd_ecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND));
1634: } else {
1635: stmt->result_bind = mnd_erealloc(stmt->result_bind, stmt->field_count * sizeof(MYSQLND_RESULT_BIND));
1636: }
1637: if (!stmt->result_bind) {
1638: DBG_RETURN(FAIL);
1639: }
1640: ALLOC_INIT_ZVAL(stmt->result_bind[param_no].zv);
1641: /*
1642: Don't update is_ref !!! it's not our job
1643: Otherwise either 009.phpt or mysqli_stmt_bind_result.phpt
1644: will fail.
1645: */
1646: stmt->result_bind[param_no].bound = TRUE;
1647: }
1648: DBG_INF("PASS");
1649: DBG_RETURN(PASS);
1650: }
1651: /* }}} */
1652:
1653:
1654: /* {{{ mysqlnd_stmt::insert_id */
1655: static uint64_t
1656: MYSQLND_METHOD(mysqlnd_stmt, insert_id)(const MYSQLND_STMT * const s TSRMLS_DC)
1657: {
1658: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1659: return stmt? stmt->upsert_status.last_insert_id : 0;
1660: }
1661: /* }}} */
1662:
1663:
1664: /* {{{ mysqlnd_stmt::affected_rows */
1665: static uint64_t
1666: MYSQLND_METHOD(mysqlnd_stmt, affected_rows)(const MYSQLND_STMT * const s TSRMLS_DC)
1667: {
1668: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1669: return stmt? stmt->upsert_status.affected_rows : 0;
1670: }
1671: /* }}} */
1672:
1673:
1674: /* {{{ mysqlnd_stmt::num_rows */
1675: static uint64_t
1676: MYSQLND_METHOD(mysqlnd_stmt, num_rows)(const MYSQLND_STMT * const s TSRMLS_DC)
1677: {
1678: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1679: return stmt && stmt->result? mysqlnd_num_rows(stmt->result):0;
1680: }
1681: /* }}} */
1682:
1683:
1684: /* {{{ mysqlnd_stmt::warning_count */
1685: static unsigned int
1686: MYSQLND_METHOD(mysqlnd_stmt, warning_count)(const MYSQLND_STMT * const s TSRMLS_DC)
1687: {
1688: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1689: return stmt? stmt->upsert_status.warning_count : 0;
1690: }
1691: /* }}} */
1692:
1693:
1694: /* {{{ mysqlnd_stmt::server_status */
1695: static unsigned int
1696: MYSQLND_METHOD(mysqlnd_stmt, server_status)(const MYSQLND_STMT * const s TSRMLS_DC)
1697: {
1698: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1699: return stmt? stmt->upsert_status.server_status : 0;
1700: }
1701: /* }}} */
1702:
1703:
1704: /* {{{ mysqlnd_stmt::field_count */
1705: static unsigned int
1706: MYSQLND_METHOD(mysqlnd_stmt, field_count)(const MYSQLND_STMT * const s TSRMLS_DC)
1707: {
1708: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1709: return stmt? stmt->field_count : 0;
1710: }
1711: /* }}} */
1712:
1713:
1714: /* {{{ mysqlnd_stmt::param_count */
1715: static unsigned int
1716: MYSQLND_METHOD(mysqlnd_stmt, param_count)(const MYSQLND_STMT * const s TSRMLS_DC)
1717: {
1718: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1719: return stmt? stmt->param_count : 0;
1720: }
1721: /* }}} */
1722:
1723:
1724: /* {{{ mysqlnd_stmt::errno */
1725: static unsigned int
1726: MYSQLND_METHOD(mysqlnd_stmt, errno)(const MYSQLND_STMT * const s TSRMLS_DC)
1727: {
1728: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1729: return stmt? stmt->error_info.error_no : 0;
1730: }
1731: /* }}} */
1732:
1733:
1734: /* {{{ mysqlnd_stmt::error */
1735: static const char *
1736: MYSQLND_METHOD(mysqlnd_stmt, error)(const MYSQLND_STMT * const s TSRMLS_DC)
1737: {
1738: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1739: return stmt? stmt->error_info.error : 0;
1740: }
1741: /* }}} */
1742:
1743:
1744: /* {{{ mysqlnd_stmt::sqlstate */
1745: static const char *
1746: MYSQLND_METHOD(mysqlnd_stmt, sqlstate)(const MYSQLND_STMT * const s TSRMLS_DC)
1747: {
1748: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1749: return stmt && stmt->error_info.sqlstate[0] ? stmt->error_info.sqlstate:MYSQLND_SQLSTATE_NULL;
1750: }
1751: /* }}} */
1752:
1753:
1754: /* {{{ mysqlnd_stmt::data_seek */
1755: static enum_func_status
1756: MYSQLND_METHOD(mysqlnd_stmt, data_seek)(const MYSQLND_STMT * const s, uint64_t row TSRMLS_DC)
1757: {
1758: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1759: return stmt && stmt->result? stmt->result->m.seek_data(stmt->result, row TSRMLS_CC) : FAIL;
1760: }
1761: /* }}} */
1762:
1763:
1764: /* {{{ mysqlnd_stmt::param_metadata */
1765: static MYSQLND_RES *
1766: MYSQLND_METHOD(mysqlnd_stmt, param_metadata)(MYSQLND_STMT * const s TSRMLS_DC)
1767: {
1768: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1769: if (!stmt || !stmt->param_count) {
1770: return NULL;
1771: }
1772: return NULL;
1773: }
1774: /* }}} */
1775:
1776:
1777: /* {{{ mysqlnd_stmt::result_metadata */
1778: static MYSQLND_RES *
1779: MYSQLND_METHOD(mysqlnd_stmt, result_metadata)(MYSQLND_STMT * const s TSRMLS_DC)
1780: {
1781: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1782: MYSQLND_RES *result;
1783:
1784: DBG_ENTER("mysqlnd_stmt::result_metadata");
1785: if (!stmt) {
1786: DBG_RETURN(NULL);
1787: }
1788: DBG_INF_FMT("stmt=%u field_count=%u", stmt->stmt_id, stmt->field_count);
1789:
1790: if (!stmt->field_count || !stmt->conn || !stmt->result || !stmt->result->meta) {
1791: DBG_INF("NULL");
1792: DBG_RETURN(NULL);
1793: }
1794:
1795: if (stmt->update_max_length && stmt->result->stored_data) {
1796: /* stored result, we have to update the max_length before we clone the meta data :( */
1797: stmt->result->m.initialize_result_set_rest(stmt->result TSRMLS_CC);
1798: }
1799: /*
1800: TODO: This implementation is kind of a hack,
1801: find a better way to do it. In different functions I have put
1802: fuses to check for result->m.fetch_row() being NULL. This should
1803: be handled in a better way.
1804:
1805: In the meantime we don't need a zval cache reference for this fake
1806: result set, so we don't get one.
1807: */
1808: do {
1809: result = stmt->conn->m->result_init(stmt->field_count, stmt->persistent TSRMLS_CC);
1810: if (!result) {
1811: break;
1812: }
1813: result->type = MYSQLND_RES_NORMAL;
1814: result->m.fetch_row = result->m.fetch_row_normal_unbuffered;
1815: result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED));
1816: if (!result->unbuf) {
1817: break;
1818: }
1819: result->unbuf->eof_reached = TRUE;
1820: result->meta = stmt->result->meta->m->clone_metadata(stmt->result->meta, FALSE TSRMLS_CC);
1821: if (!result->meta) {
1822: break;
1823: }
1824:
1825: DBG_INF_FMT("result=%p", result);
1826: DBG_RETURN(result);
1827: } while (0);
1828:
1829: SET_OOM_ERROR(stmt->conn->error_info);
1830: if (result) {
1831: result->m.free_result(result, TRUE TSRMLS_CC);
1832: }
1833: DBG_RETURN(NULL);
1834: }
1835: /* }}} */
1836:
1837:
1838: /* {{{ mysqlnd_stmt::attr_set */
1839: static enum_func_status
1840: MYSQLND_METHOD(mysqlnd_stmt, attr_set)(MYSQLND_STMT * const s,
1841: enum mysqlnd_stmt_attr attr_type,
1842: const void * const value TSRMLS_DC)
1843: {
1844: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1845: DBG_ENTER("mysqlnd_stmt::attr_set");
1846: if (!stmt) {
1847: DBG_RETURN(FAIL);
1848: }
1849: DBG_INF_FMT("stmt=%lu attr_type=%u", stmt->stmt_id, attr_type);
1850:
1851: switch (attr_type) {
1852: case STMT_ATTR_UPDATE_MAX_LENGTH:{
1853: zend_uchar bval = *(zend_uchar *) value;
1854: /*
1855: XXX : libmysql uses my_bool, but mysqli uses ulong as storage on the stack
1856: and mysqlnd won't be used out of the scope of PHP -> use ulong.
1857: */
1858: stmt->update_max_length = bval? TRUE:FALSE;
1859: break;
1860: }
1861: case STMT_ATTR_CURSOR_TYPE: {
1862: unsigned int ival = *(unsigned int *) value;
1863: if (ival > (unsigned long) CURSOR_TYPE_READ_ONLY) {
1864: SET_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "Not implemented");
1865: DBG_INF("FAIL");
1866: DBG_RETURN(FAIL);
1867: }
1868: stmt->flags = ival;
1869: break;
1870: }
1871: case STMT_ATTR_PREFETCH_ROWS: {
1872: unsigned int ival = *(unsigned int *) value;
1873: if (ival == 0) {
1874: ival = MYSQLND_DEFAULT_PREFETCH_ROWS;
1875: } else if (ival > 1) {
1876: SET_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "Not implemented");
1877: DBG_INF("FAIL");
1878: DBG_RETURN(FAIL);
1879: }
1880: stmt->prefetch_rows = ival;
1881: break;
1882: }
1883: default:
1884: SET_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "Not implemented");
1885: DBG_RETURN(FAIL);
1886: }
1887: DBG_INF("PASS");
1888: DBG_RETURN(PASS);
1889: }
1890: /* }}} */
1891:
1892:
1893: /* {{{ mysqlnd_stmt::attr_get */
1894: static enum_func_status
1895: MYSQLND_METHOD(mysqlnd_stmt, attr_get)(const MYSQLND_STMT * const s,
1896: enum mysqlnd_stmt_attr attr_type,
1897: void * const value TSRMLS_DC)
1898: {
1899: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1900: DBG_ENTER("mysqlnd_stmt::attr_set");
1901: if (!stmt) {
1902: DBG_RETURN(FAIL);
1903: }
1904: DBG_INF_FMT("stmt=%lu attr_type=%u", stmt->stmt_id, attr_type);
1905:
1906: switch (attr_type) {
1907: case STMT_ATTR_UPDATE_MAX_LENGTH:
1908: *(zend_bool *) value= stmt->update_max_length;
1909: break;
1910: case STMT_ATTR_CURSOR_TYPE:
1911: *(unsigned long *) value= stmt->flags;
1912: break;
1913: case STMT_ATTR_PREFETCH_ROWS:
1914: *(unsigned long *) value= stmt->prefetch_rows;
1915: break;
1916: default:
1917: DBG_RETURN(FAIL);
1918: }
1919: DBG_INF_FMT("value=%lu", value);
1920: DBG_RETURN(PASS);
1921: }
1922: /* }}} */
1923:
1924: /* free_result() doesn't actually free stmt->result but only the buffers */
1925: /* {{{ mysqlnd_stmt::free_result */
1926: static enum_func_status
1927: MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const s TSRMLS_DC)
1928: {
1929: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1930: DBG_ENTER("mysqlnd_stmt::free_result");
1931: if (!stmt || !stmt->conn) {
1932: DBG_RETURN(FAIL);
1933: }
1934: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
1935:
1936: if (!stmt->result) {
1937: DBG_INF("no result");
1938: DBG_RETURN(PASS);
1939: }
1940:
1941: /*
1942: If right after execute() we have to call the appropriate
1943: use_result() or store_result() and clean.
1944: */
1945: if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
1946: DBG_INF("fetching result set header");
1947: /* Do implicit use_result and then flush the result */
1948: stmt->default_rset_handler = s->m->use_result;
1949: stmt->default_rset_handler(s TSRMLS_CC);
1950: }
1951:
1952: if (stmt->state > MYSQLND_STMT_WAITING_USE_OR_STORE) {
1953: DBG_INF("skipping result");
1954: /* Flush if anything is left and unbuffered set */
1955: stmt->result->m.skip_result(stmt->result TSRMLS_CC);
1956: /*
1957: Separate the bound variables, which point to the result set, then
1958: destroy the set.
1959: */
1960: mysqlnd_stmt_separate_result_bind(s TSRMLS_CC);
1961:
1962: /* Now we can destroy the result set */
1963: stmt->result->m.free_result_buffers(stmt->result TSRMLS_CC);
1964: }
1965:
1966: if (stmt->state > MYSQLND_STMT_PREPARED) {
1967: /* As the buffers have been freed, we should go back to PREPARED */
1968: stmt->state = MYSQLND_STMT_PREPARED;
1969: }
1970:
1971: /* Line is free! */
1972: CONN_SET_STATE(stmt->conn, CONN_READY);
1973:
1974: DBG_RETURN(PASS);
1975: }
1976: /* }}} */
1977:
1978:
1979: /* {{{ mysqlnd_stmt_separate_result_bind */
1980: static void
1981: mysqlnd_stmt_separate_result_bind(MYSQLND_STMT * const s TSRMLS_DC)
1982: {
1983: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
1984: unsigned int i;
1985:
1986: DBG_ENTER("mysqlnd_stmt_separate_result_bind");
1987: if (!stmt) {
1988: DBG_VOID_RETURN;
1989: }
1990: DBG_INF_FMT("stmt=%lu result_bind=%p field_count=%u",
1991: stmt->stmt_id, stmt->result_bind, stmt->field_count);
1992:
1993: if (!stmt->result_bind) {
1994: DBG_VOID_RETURN;
1995: }
1996:
1997: /*
1998: Because only the bound variables can point to our internal buffers, then
1999: separate or free only them. Free is possible because the user could have
2000: lost reference.
2001: */
2002: for (i = 0; i < stmt->field_count; i++) {
2003: /* Let's try with no cache */
2004: if (stmt->result_bind[i].bound == TRUE) {
2005: DBG_INF_FMT("%u has refcount=%u", i, Z_REFCOUNT_P(stmt->result_bind[i].zv));
2006: /*
2007: We have to separate the actual zval value of the bound
2008: variable from our allocated zvals or we will face double-free
2009: */
2010: if (Z_REFCOUNT_P(stmt->result_bind[i].zv) > 1) {
2011: #ifdef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
2012: zval_copy_ctor(stmt->result_bind[i].zv);
2013: #endif
2014: zval_ptr_dtor(&stmt->result_bind[i].zv);
2015: } else {
2016: /*
2017: If it is a string, what is pointed will be freed
2018: later in free_result(). We need to remove the variable to
2019: which the user has lost reference.
2020: */
2021: #ifdef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
2022: ZVAL_NULL(stmt->result_bind[i].zv);
2023: #endif
2024: zval_ptr_dtor(&stmt->result_bind[i].zv);
2025: }
2026: }
2027: }
2028: s->m->free_result_bind(s, stmt->result_bind TSRMLS_CC);
2029: stmt->result_bind = NULL;
2030:
2031: DBG_VOID_RETURN;
2032: }
2033: /* }}} */
2034:
2035:
2036: /* {{{ mysqlnd_stmt_separate_one_result_bind */
2037: static void
2038: mysqlnd_stmt_separate_one_result_bind(MYSQLND_STMT * const s, unsigned int param_no TSRMLS_DC)
2039: {
2040: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2041: DBG_ENTER("mysqlnd_stmt_separate_one_result_bind");
2042: if (!stmt) {
2043: DBG_VOID_RETURN;
2044: }
2045: DBG_INF_FMT("stmt=%lu result_bind=%p field_count=%u param_no=%u",
2046: stmt->stmt_id, stmt->result_bind, stmt->field_count, param_no);
2047:
2048: if (!stmt->result_bind) {
2049: DBG_VOID_RETURN;
2050: }
2051:
2052: /*
2053: Because only the bound variables can point to our internal buffers, then
2054: separate or free only them. Free is possible because the user could have
2055: lost reference.
2056: */
2057: /* Let's try with no cache */
2058: if (stmt->result_bind[param_no].bound == TRUE) {
2059: DBG_INF_FMT("%u has refcount=%u", param_no, Z_REFCOUNT_P(stmt->result_bind[param_no].zv));
2060: /*
2061: We have to separate the actual zval value of the bound
2062: variable from our allocated zvals or we will face double-free
2063: */
2064: if (Z_REFCOUNT_P(stmt->result_bind[param_no].zv) > 1) {
2065: #ifdef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
2066: zval_copy_ctor(stmt->result_bind[param_no].zv);
2067: #endif
2068: zval_ptr_dtor(&stmt->result_bind[param_no].zv);
2069: } else {
2070: /*
2071: If it is a string, what is pointed will be freed
2072: later in free_result(). We need to remove the variable to
2073: which the user has lost reference.
2074: */
2075: #ifdef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
2076: ZVAL_NULL(stmt->result_bind[param_no].zv);
2077: #endif
2078: zval_ptr_dtor(&stmt->result_bind[param_no].zv);
2079: }
2080: }
2081:
2082: DBG_VOID_RETURN;
2083: }
2084: /* }}} */
2085:
2086:
2087: /* {{{ mysqlnd_stmt::free_stmt_content */
2088: static void
2089: MYSQLND_METHOD(mysqlnd_stmt, free_stmt_content)(MYSQLND_STMT * const s TSRMLS_DC)
2090: {
2091: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2092: DBG_ENTER("mysqlnd_stmt::free_stmt_content");
2093: if (!stmt) {
2094: DBG_VOID_RETURN;
2095: }
2096: DBG_INF_FMT("stmt=%lu param_bind=%p param_count=%u",
2097: stmt->stmt_id, stmt->param_bind, stmt->param_count);
2098:
2099: /* Destroy the input bind */
2100: if (stmt->param_bind) {
2101: unsigned int i;
2102: /*
2103: Because only the bound variables can point to our internal buffers, then
2104: separate or free only them. Free is possible because the user could have
2105: lost reference.
2106: */
2107: for (i = 0; i < stmt->param_count; i++) {
2108: /*
2109: If bind_one_parameter was used, but not everything was
2110: bound and nothing was fetched, then some `zv` could be NULL
2111: */
2112: if (stmt->param_bind[i].zv) {
2113: zval_ptr_dtor(&stmt->param_bind[i].zv);
2114: }
2115: }
2116: s->m->free_parameter_bind(s, stmt->param_bind TSRMLS_CC);
2117: stmt->param_bind = NULL;
2118: }
2119:
2120: /*
2121: First separate the bound variables, which point to the result set, then
2122: destroy the set.
2123: */
2124: mysqlnd_stmt_separate_result_bind(s TSRMLS_CC);
2125: /* Not every statement has a result set attached */
2126: if (stmt->result) {
2127: stmt->result->m.free_result_internal(stmt->result TSRMLS_CC);
2128: stmt->result = NULL;
2129: }
2130:
2131: DBG_VOID_RETURN;
2132: }
2133: /* }}} */
2134:
2135:
2136: /* {{{ mysqlnd_stmt::net_close */
2137: static enum_func_status
2138: MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const s, zend_bool implicit TSRMLS_DC)
2139: {
2140: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2141: MYSQLND * conn;
2142: zend_uchar cmd_buf[STMT_ID_LENGTH /* statement id */];
2143: enum_mysqlnd_collected_stats statistic = STAT_LAST;
2144:
2145: DBG_ENTER("mysqlnd_stmt::net_close");
2146: if (!stmt || !stmt->conn) {
2147: DBG_RETURN(FAIL);
2148: }
2149: DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
2150:
2151: conn = stmt->conn;
2152:
2153: SET_EMPTY_ERROR(stmt->error_info);
2154: SET_EMPTY_ERROR(stmt->conn->error_info);
2155:
2156: /*
2157: If the user decided to close the statement right after execute()
2158: We have to call the appropriate use_result() or store_result() and
2159: clean.
2160: */
2161: do {
2162: DBG_INF_FMT("stmt->state=%u", stmt->state);
2163: if (stmt->state == MYSQLND_STMT_WAITING_USE_OR_STORE) {
2164: DBG_INF("fetching result set header");
2165: stmt->default_rset_handler(s TSRMLS_CC);
2166: stmt->state = MYSQLND_STMT_USER_FETCHING;
2167: }
2168:
2169: /* unbuffered set not fetched to the end ? Clean the line */
2170: if (stmt->result) {
2171: DBG_INF("skipping result");
2172: stmt->result->m.skip_result(stmt->result TSRMLS_CC);
2173: }
2174: } while (mysqlnd_stmt_more_results(s) && mysqlnd_stmt_next_result(s) == PASS);
2175: /*
2176: After this point we are allowed to free the result set,
2177: as we have cleaned the line
2178: */
2179: if (stmt->stmt_id) {
2180: MYSQLND_INC_GLOBAL_STATISTIC(implicit == TRUE? STAT_FREE_RESULT_IMPLICIT:
2181: STAT_FREE_RESULT_EXPLICIT);
2182:
2183: int4store(cmd_buf, stmt->stmt_id);
2184: if (CONN_GET_STATE(conn) == CONN_READY &&
2185: FAIL == conn->m->simple_command(conn, COM_STMT_CLOSE, (char *)cmd_buf, sizeof(cmd_buf),
2186: PROT_LAST /* COM_STMT_CLOSE doesn't send an OK packet*/,
2187: FALSE, TRUE TSRMLS_CC)) {
2188: stmt->error_info = conn->error_info;
2189: DBG_RETURN(FAIL);
2190: }
2191: }
2192: switch (stmt->execute_count) {
2193: case 0:
2194: statistic = STAT_PS_PREPARED_NEVER_EXECUTED;
2195: break;
2196: case 1:
2197: statistic = STAT_PS_PREPARED_ONCE_USED;
2198: break;
2199: default:
2200: break;
2201: }
2202: if (statistic != STAT_LAST) {
2203: MYSQLND_INC_CONN_STATISTIC(conn->stats, statistic);
2204: }
2205:
2206: if (stmt->execute_cmd_buffer.buffer) {
2207: mnd_pefree(stmt->execute_cmd_buffer.buffer, stmt->persistent);
2208: stmt->execute_cmd_buffer.buffer = NULL;
2209: }
2210:
2211: s->m->free_stmt_content(s TSRMLS_CC);
2212:
2213: if (stmt->conn) {
2214: stmt->conn->m->free_reference(stmt->conn TSRMLS_CC);
2215: stmt->conn = NULL;
2216: }
2217:
2218: DBG_RETURN(PASS);
2219: }
2220: /* }}} */
2221:
2222: /* {{{ mysqlnd_stmt::dtor */
2223: static enum_func_status
2224: MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const s, zend_bool implicit TSRMLS_DC)
2225: {
2226: MYSQLND_STMT_DATA * stmt = (s != NULL) ? s->data:NULL;
2227: enum_func_status ret = FAIL;
2228: zend_bool persistent = (s != NULL) ? s->persistent : 0;
2229:
2230: DBG_ENTER("mysqlnd_stmt::dtor");
2231: if (stmt) {
2232:
2233: DBG_INF_FMT("stmt=%p", stmt);
2234:
2235: MYSQLND_INC_GLOBAL_STATISTIC(implicit == TRUE? STAT_STMT_CLOSE_IMPLICIT:
2236: STAT_STMT_CLOSE_EXPLICIT);
2237:
2238: ret = s->m->net_close(s, implicit TSRMLS_CC);
2239: mnd_pefree(stmt, persistent);
2240: }
2241: mnd_pefree(s, persistent);
2242:
2243: DBG_INF(ret == PASS? "PASS":"FAIL");
2244: DBG_RETURN(ret);
2245: }
2246: /* }}} */
2247:
2248:
2249: /* {{{ mysqlnd_stmt::alloc_param_bind */
2250: static MYSQLND_PARAM_BIND *
2251: MYSQLND_METHOD(mysqlnd_stmt, alloc_param_bind)(MYSQLND_STMT * const s TSRMLS_DC)
2252: {
2253: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2254: DBG_ENTER("mysqlnd_stmt::alloc_param_bind");
2255: if (!stmt) {
2256: DBG_RETURN(NULL);
2257: }
2258: DBG_RETURN(mnd_pecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND), stmt->persistent));
2259: }
2260: /* }}} */
2261:
2262:
2263: /* {{{ mysqlnd_stmt::alloc_result_bind */
2264: static MYSQLND_RESULT_BIND *
2265: MYSQLND_METHOD(mysqlnd_stmt, alloc_result_bind)(MYSQLND_STMT * const s TSRMLS_DC)
2266: {
2267: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2268: DBG_ENTER("mysqlnd_stmt::alloc_result_bind");
2269: if (!stmt) {
2270: DBG_RETURN(NULL);
2271: }
2272: DBG_RETURN(mnd_pecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND), stmt->persistent));
2273: }
2274: /* }}} */
2275:
2276:
2277: /* {{{ param_bind::free_parameter_bind */
2278: PHPAPI void
2279: MYSQLND_METHOD(mysqlnd_stmt, free_parameter_bind)(MYSQLND_STMT * const s, MYSQLND_PARAM_BIND * param_bind TSRMLS_DC)
2280: {
2281: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2282: if (stmt) {
2283: mnd_pefree(param_bind, stmt->persistent);
2284: }
2285: }
2286: /* }}} */
2287:
2288:
2289: /* {{{ mysqlnd_stmt::free_result_bind */
2290: PHPAPI void
2291: MYSQLND_METHOD(mysqlnd_stmt, free_result_bind)(MYSQLND_STMT * const s, MYSQLND_RESULT_BIND * result_bind TSRMLS_DC)
2292: {
2293: MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
2294: if (stmt) {
2295: mnd_pefree(result_bind, stmt->persistent);
2296: }
2297: }
2298: /* }}} */
2299:
2300:
2301:
2302: MYSQLND_CLASS_METHODS_START(mysqlnd_stmt)
2303: MYSQLND_METHOD(mysqlnd_stmt, prepare),
2304: MYSQLND_METHOD(mysqlnd_stmt, execute),
2305: MYSQLND_METHOD(mysqlnd_stmt, use_result),
2306: MYSQLND_METHOD(mysqlnd_stmt, store_result),
2307: MYSQLND_METHOD(mysqlnd_stmt, get_result),
2308: MYSQLND_METHOD(mysqlnd_stmt, more_results),
2309: MYSQLND_METHOD(mysqlnd_stmt, next_result),
2310: MYSQLND_METHOD(mysqlnd_stmt, free_result),
2311: MYSQLND_METHOD(mysqlnd_stmt, data_seek),
2312: MYSQLND_METHOD(mysqlnd_stmt, reset),
2313: MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close),
2314: MYSQLND_METHOD(mysqlnd_stmt, dtor),
2315:
2316: MYSQLND_METHOD(mysqlnd_stmt, fetch),
2317:
2318: MYSQLND_METHOD(mysqlnd_stmt, bind_parameters),
2319: MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter),
2320: MYSQLND_METHOD(mysqlnd_stmt, refresh_bind_param),
2321: MYSQLND_METHOD(mysqlnd_stmt, bind_result),
2322: MYSQLND_METHOD(mysqlnd_stmt, bind_one_result),
2323: MYSQLND_METHOD(mysqlnd_stmt, send_long_data),
2324: MYSQLND_METHOD(mysqlnd_stmt, param_metadata),
2325: MYSQLND_METHOD(mysqlnd_stmt, result_metadata),
2326:
2327: MYSQLND_METHOD(mysqlnd_stmt, insert_id),
2328: MYSQLND_METHOD(mysqlnd_stmt, affected_rows),
2329: MYSQLND_METHOD(mysqlnd_stmt, num_rows),
2330:
2331: MYSQLND_METHOD(mysqlnd_stmt, param_count),
2332: MYSQLND_METHOD(mysqlnd_stmt, field_count),
2333: MYSQLND_METHOD(mysqlnd_stmt, warning_count),
2334:
2335: MYSQLND_METHOD(mysqlnd_stmt, errno),
2336: MYSQLND_METHOD(mysqlnd_stmt, error),
2337: MYSQLND_METHOD(mysqlnd_stmt, sqlstate),
2338:
2339: MYSQLND_METHOD(mysqlnd_stmt, attr_get),
2340: MYSQLND_METHOD(mysqlnd_stmt, attr_set),
2341:
2342:
2343: MYSQLND_METHOD(mysqlnd_stmt, alloc_param_bind),
2344: MYSQLND_METHOD(mysqlnd_stmt, alloc_result_bind),
2345: MYSQLND_METHOD(mysqlnd_stmt, free_parameter_bind),
2346: MYSQLND_METHOD(mysqlnd_stmt, free_result_bind),
2347: MYSQLND_METHOD(mysqlnd_stmt, server_status),
2348: mysqlnd_stmt_execute_generate_request,
2349: mysqlnd_stmt_execute_parse_response,
2350: MYSQLND_METHOD(mysqlnd_stmt, free_stmt_content)
2351: MYSQLND_CLASS_METHODS_END;
2352:
2353:
2354: /* {{{ _mysqlnd_stmt_init */
2355: MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC)
2356: {
2357: size_t alloc_size = sizeof(MYSQLND_STMT) + mysqlnd_plugin_count() * sizeof(void *);
2358: MYSQLND_STMT * ret = mnd_pecalloc(1, alloc_size, conn->persistent);
2359: MYSQLND_STMT_DATA * stmt = NULL;
2360:
2361: DBG_ENTER("_mysqlnd_stmt_init");
2362: do {
2363: if (!ret) {
2364: break;
2365: }
2366: ret->m = mysqlnd_stmt_methods;
2367: ret->persistent = conn->persistent;
2368:
2369: stmt = ret->data = mnd_pecalloc(1, sizeof(MYSQLND_STMT_DATA), conn->persistent);
2370: DBG_INF_FMT("stmt=%p", stmt);
2371: if (!stmt) {
2372: break;
2373: }
2374: stmt->persistent = conn->persistent;
2375: stmt->state = MYSQLND_STMT_INITTED;
2376: stmt->execute_cmd_buffer.length = 4096;
2377: stmt->execute_cmd_buffer.buffer = mnd_pemalloc(stmt->execute_cmd_buffer.length, stmt->persistent);
2378: if (!stmt->execute_cmd_buffer.buffer) {
2379: break;
2380: }
2381:
2382: stmt->prefetch_rows = MYSQLND_DEFAULT_PREFETCH_ROWS;
2383: /*
2384: Mark that we reference the connection, thus it won't be
2385: be destructed till there is open statements. The last statement
2386: or normal query result will close it then.
2387: */
2388: stmt->conn = conn->m->get_reference(conn TSRMLS_CC);
2389:
2390: DBG_RETURN(ret);
2391: } while (0);
2392:
2393: SET_OOM_ERROR(conn->error_info);
2394: if (ret) {
2395: ret->m->dtor(ret, TRUE TSRMLS_CC);
2396: ret = NULL;
2397: }
2398: DBG_RETURN(NULL);
2399: }
2400: /* }}} */
2401:
2402:
2403: /* {{{ _mysqlnd_plugin_get_plugin_stmt_data */
2404: PHPAPI void ** _mysqlnd_plugin_get_plugin_stmt_data(const MYSQLND_STMT * stmt, unsigned int plugin_id TSRMLS_DC)
2405: {
2406: DBG_ENTER("_mysqlnd_plugin_get_plugin_stmt_data");
2407: DBG_INF_FMT("plugin_id=%u", plugin_id);
2408: if (!stmt || plugin_id >= mysqlnd_plugin_count()) {
2409: return NULL;
2410: }
2411: DBG_RETURN((void *)((char *)stmt + sizeof(MYSQLND_STMT) + plugin_id * sizeof(void *)));
2412: }
2413: /* }}} */
2414:
2415:
2416: /* {{{ _mysqlnd_init_ps_subsystem */
2417: void _mysqlnd_init_ps_subsystem()
2418: {
2419: mysqlnd_stmt_methods = &MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_stmt);
2420: _mysqlnd_init_ps_fetch_subsystem();
2421: }
2422: /* }}} */
2423:
2424:
2425: /* {{{ mysqlnd_conn_get_methods */
2426: PHPAPI struct st_mysqlnd_stmt_methods * mysqlnd_stmt_get_methods()
2427: {
2428: return mysqlnd_stmt_methods;
2429: }
2430: /* }}} */
2431:
2432:
2433: /* {{{ mysqlnd_conn_set_methods */
2434: PHPAPI void mysqlnd_stmt_set_methods(struct st_mysqlnd_stmt_methods *methods)
2435: {
2436: mysqlnd_stmt_methods = methods;
2437: }
2438: /* }}} */
2439:
2440:
2441: /*
2442: * Local variables:
2443: * tab-width: 4
2444: * c-basic-offset: 4
2445: * End:
2446: * vim600: noet sw=4 ts=4 fdm=marker
2447: * vim<600: noet sw=4 ts=4
2448: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mysqlnd_ps.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mysqlnd