1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 2006-2014 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: Andrey Hristov <andrey@mysql.com> |
16: | Ulf Wendel <uwendel@mysql.com> |
17: | Georg Richter <georg@mysql.com> |
18: +----------------------------------------------------------------------+
19: */
20:
21: /* $Id: mysqlnd_result.c,v 1.1.1.4 2014/06/15 20:03:52 misho Exp $ */
22: #include "php.h"
23: #include "mysqlnd.h"
24: #include "mysqlnd_wireprotocol.h"
25: #include "mysqlnd_block_alloc.h"
26: #include "mysqlnd_priv.h"
27: #include "mysqlnd_result.h"
28: #include "mysqlnd_result_meta.h"
29: #include "mysqlnd_statistics.h"
30: #include "mysqlnd_debug.h"
31: #include "mysqlnd_ext_plugin.h"
32:
33: #define MYSQLND_SILENT
34:
35:
36: /* {{{ mysqlnd_res::initialize_result_set_rest */
37: static enum_func_status
38: MYSQLND_METHOD(mysqlnd_res, initialize_result_set_rest)(MYSQLND_RES * const result TSRMLS_DC)
39: {
40: unsigned int i;
41: zval **data_cursor = result->stored_data? result->stored_data->data:NULL;
42: zval **data_begin = result->stored_data? result->stored_data->data:NULL;
43: unsigned int field_count = result->meta? result->meta->field_count : 0;
44: uint64_t row_count = result->stored_data? result->stored_data->row_count:0;
45: enum_func_status ret = PASS;
46: DBG_ENTER("mysqlnd_res::initialize_result_set_rest");
47:
48: if (!data_cursor || row_count == result->stored_data->initialized_rows) {
49: DBG_RETURN(ret);
50: }
51: while ((data_cursor - data_begin) < (int)(row_count * field_count)) {
52: if (NULL == data_cursor[0]) {
53: enum_func_status rc = result->m.row_decoder(
54: result->stored_data->row_buffers[(data_cursor - data_begin) / field_count],
55: data_cursor,
56: result->meta->field_count,
57: result->meta->fields,
58: result->conn->options->numeric_and_datetime_as_unicode,
59: result->conn->options->int_and_float_native,
60: result->conn->stats TSRMLS_CC);
61: if (rc != PASS) {
62: ret = FAIL;
63: break;
64: }
65: result->stored_data->initialized_rows++;
66: for (i = 0; i < result->field_count; i++) {
67: /*
68: NULL fields are 0 length, 0 is not more than 0
69: String of zero size, definitely can't be the next max_length.
70: Thus for NULL and zero-length we are quite efficient.
71: */
72: if (Z_TYPE_P(data_cursor[i]) >= IS_STRING) {
73: unsigned long len = Z_STRLEN_P(data_cursor[i]);
74: if (result->meta->fields[i].max_length < len) {
75: result->meta->fields[i].max_length = len;
76: }
77: }
78: }
79: }
80: data_cursor += field_count;
81: }
82: DBG_RETURN(ret);
83: }
84: /* }}} */
85:
86:
87: /* {{{ mysqlnd_rset_zval_ptr_dtor */
88: static void
89: mysqlnd_rset_zval_ptr_dtor(zval **zv, enum_mysqlnd_res_type type, zend_bool * copy_ctor_called TSRMLS_DC)
90: {
91: DBG_ENTER("mysqlnd_rset_zval_ptr_dtor");
92: if (!zv || !*zv) {
93: *copy_ctor_called = FALSE;
94: DBG_ERR_FMT("zv was NULL");
95: DBG_VOID_RETURN;
96: }
97: /*
98: This zval is not from the cache block.
99: Thus the refcount is -1 than of a zval from the cache,
100: because the zvals from the cache are owned by it.
101: */
102: if (type == MYSQLND_RES_PS_BUF || type == MYSQLND_RES_PS_UNBUF) {
103: *copy_ctor_called = FALSE;
104: ; /* do nothing, zval_ptr_dtor will do the job*/
105: } else if (Z_REFCOUNT_PP(zv) > 1) {
106: /*
107: Not a prepared statement, then we have to
108: call copy_ctor and then zval_ptr_dtor()
109:
110: In Unicode mode the destruction of the zvals should not call
111: zval_copy_ctor() because then we will leak.
112: I suppose we can use UG(unicode) in mysqlnd.c when freeing a result set
113: to check if we need to call copy_ctor().
114:
115: If the type is IS_UNICODE, which can happen with PHP6, then we don't
116: need to copy_ctor, as the data doesn't point to our internal buffers.
117: If it's string (in PHP5 always) and in PHP6 if data is binary, then
118: it still points to internal buffers and has to be copied.
119: */
120: if (Z_TYPE_PP(zv) == IS_STRING) {
121: zval_copy_ctor(*zv);
122: }
123: *copy_ctor_called = TRUE;
124: } else {
125: /*
126: noone but us point to this, so we can safely ZVAL_NULL the zval,
127: so Zend does not try to free what the zval points to - which is
128: in result set buffers
129: */
130: *copy_ctor_called = FALSE;
131: if (Z_TYPE_PP(zv) == IS_STRING) {
132: ZVAL_NULL(*zv);
133: }
134: }
135: zval_ptr_dtor(zv);
136: DBG_VOID_RETURN;
137: }
138: /* }}} */
139:
140:
141: /* {{{ mysqlnd_res::unbuffered_free_last_data */
142: static void
143: MYSQLND_METHOD(mysqlnd_res, unbuffered_free_last_data)(MYSQLND_RES * result TSRMLS_DC)
144: {
145: MYSQLND_RES_UNBUFFERED *unbuf = result->unbuf;
146:
147: DBG_ENTER("mysqlnd_res::unbuffered_free_last_data");
148:
149: if (!unbuf) {
150: DBG_VOID_RETURN;
151: }
152:
153: if (unbuf->last_row_data) {
154: unsigned int i, ctor_called_count = 0;
155: zend_bool copy_ctor_called;
156: MYSQLND_STATS *global_stats = result->conn? result->conn->stats:NULL;
157:
158: for (i = 0; i < result->field_count; i++) {
159: mysqlnd_rset_zval_ptr_dtor(&(unbuf->last_row_data[i]), result->type, ©_ctor_called TSRMLS_CC);
160: if (copy_ctor_called) {
161: ++ctor_called_count;
162: }
163: }
164: DBG_INF_FMT("copy_ctor_called_count=%u", ctor_called_count);
165: /* By using value3 macros we hold a mutex only once, there is no value2 */
166: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(global_stats,
167: STAT_COPY_ON_WRITE_PERFORMED,
168: ctor_called_count,
169: STAT_COPY_ON_WRITE_SAVED,
170: result->field_count - ctor_called_count);
171: /* Free last row's zvals */
172: mnd_efree(unbuf->last_row_data);
173: unbuf->last_row_data = NULL;
174: }
175: if (unbuf->last_row_buffer) {
176: DBG_INF("Freeing last row buffer");
177: /* Nothing points to this buffer now, free it */
178: unbuf->last_row_buffer->free_chunk(unbuf->last_row_buffer TSRMLS_CC);
179: unbuf->last_row_buffer = NULL;
180: }
181:
182: DBG_VOID_RETURN;
183: }
184: /* }}} */
185:
186:
187: /* {{{ mysqlnd_res::free_buffered_data */
188: static void
189: MYSQLND_METHOD(mysqlnd_res, free_buffered_data)(MYSQLND_RES * result TSRMLS_DC)
190: {
191: MYSQLND_RES_BUFFERED *set = result->stored_data;
192: unsigned int field_count = result->field_count;
193: int64_t row;
194:
195: DBG_ENTER("mysqlnd_res::free_buffered_data");
196: DBG_INF_FMT("Freeing "MYSQLND_LLU_SPEC" row(s)", set->row_count);
197:
198: if (set->data) {
199: unsigned int copy_on_write_performed = 0;
200: unsigned int copy_on_write_saved = 0;
201: zval **data = set->data;
202: set->data = NULL; /* prevent double free if following loop is interrupted */
203:
204: for (row = set->row_count - 1; row >= 0; row--) {
205: zval **current_row = data + row * field_count;
206: MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row];
207: int64_t col;
208:
209: if (current_row != NULL) {
210: for (col = field_count - 1; col >= 0; --col) {
211: if (current_row[col]) {
212: zend_bool copy_ctor_called;
213: mysqlnd_rset_zval_ptr_dtor(&(current_row[col]), result->type, ©_ctor_called TSRMLS_CC);
214: if (copy_ctor_called) {
215: ++copy_on_write_performed;
216: } else {
217: ++copy_on_write_saved;
218: }
219: }
220: }
221: }
222: current_buffer->free_chunk(current_buffer TSRMLS_CC);
223: }
224:
225: MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_COPY_ON_WRITE_PERFORMED, copy_on_write_performed,
226: STAT_COPY_ON_WRITE_SAVED, copy_on_write_saved);
227: mnd_efree(data);
228: }
229:
230: if (set->row_buffers) {
231: mnd_efree(set->row_buffers);
232: set->row_buffers = NULL;
233: }
234: set->data_cursor = NULL;
235: set->row_count = 0;
236:
237: mnd_efree(set);
238:
239: DBG_VOID_RETURN;
240: }
241: /* }}} */
242:
243:
244: /* {{{ mysqlnd_res::free_result_buffers */
245: static void
246: MYSQLND_METHOD(mysqlnd_res, free_result_buffers)(MYSQLND_RES * result TSRMLS_DC)
247: {
248: DBG_ENTER("mysqlnd_res::free_result_buffers");
249: DBG_INF_FMT("%s", result->unbuf? "unbuffered":(result->stored_data? "buffered":"unknown"));
250:
251: if (result->unbuf) {
252: result->m.unbuffered_free_last_data(result TSRMLS_CC);
253: mnd_efree(result->unbuf);
254: result->unbuf = NULL;
255: } else if (result->stored_data) {
256: result->m.free_buffered_data(result TSRMLS_CC);
257: result->stored_data = NULL;
258: }
259:
260: if (result->lengths) {
261: mnd_efree(result->lengths);
262: result->lengths = NULL;
263: }
264:
265: if (result->row_packet) {
266: PACKET_FREE(result->row_packet);
267: result->row_packet = NULL;
268: }
269:
270: if (result->result_set_memory_pool) {
271: mysqlnd_mempool_destroy(result->result_set_memory_pool TSRMLS_CC);
272: result->result_set_memory_pool = NULL;
273: }
274:
275: DBG_VOID_RETURN;
276: }
277: /* }}} */
278:
279:
280: /* {{{ mysqlnd_internal_free_result_contents */
281: static
282: void mysqlnd_internal_free_result_contents(MYSQLND_RES * result TSRMLS_DC)
283: {
284: DBG_ENTER("mysqlnd_internal_free_result_contents");
285:
286: result->m.free_result_buffers(result TSRMLS_CC);
287:
288: if (result->meta) {
289: result->meta->m->free_metadata(result->meta TSRMLS_CC);
290: result->meta = NULL;
291: }
292:
293: DBG_VOID_RETURN;
294: }
295: /* }}} */
296:
297:
298: /* {{{ mysqlnd_internal_free_result */
299: static
300: void mysqlnd_internal_free_result(MYSQLND_RES * result TSRMLS_DC)
301: {
302: DBG_ENTER("mysqlnd_internal_free_result");
303: result->m.free_result_contents(result TSRMLS_CC);
304:
305: if (result->conn) {
306: result->conn->m->free_reference(result->conn TSRMLS_CC);
307: result->conn = NULL;
308: }
309:
310: mnd_pefree(result, result->persistent);
311:
312: DBG_VOID_RETURN;
313: }
314: /* }}} */
315:
316:
317: /* {{{ mysqlnd_res::read_result_metadata */
318: static enum_func_status
319: MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES * result, MYSQLND_CONN_DATA * conn TSRMLS_DC)
320: {
321: DBG_ENTER("mysqlnd_res::read_result_metadata");
322:
323: /*
324: Make it safe to call it repeatedly for PS -
325: better free and allocate a new because the number of field might change
326: (select *) with altered table. Also for statements which skip the PS
327: infrastructure!
328: */
329: if (result->meta) {
330: result->meta->m->free_metadata(result->meta TSRMLS_CC);
331: result->meta = NULL;
332: }
333:
334: result->meta = result->m.result_meta_init(result->field_count, result->persistent TSRMLS_CC);
335: if (!result->meta) {
336: SET_OOM_ERROR(*conn->error_info);
337: DBG_RETURN(FAIL);
338: }
339:
340: /* 1. Read all fields metadata */
341:
342: /* It's safe to reread without freeing */
343: if (FAIL == result->meta->m->read_metadata(result->meta, conn TSRMLS_CC)) {
344: result->m.free_result_contents(result TSRMLS_CC);
345: DBG_RETURN(FAIL);
346: }
347: /* COM_FIELD_LIST is broken and has premature EOF, thus we need to hack here and in mysqlnd_res_meta.c */
348: result->field_count = result->meta->field_count;
349:
350: /*
351: 2. Follows an EOF packet, which the client of mysqlnd_read_result_metadata()
352: should consume.
353: 3. If there is a result set, it follows. The last packet will have 'eof' set
354: If PS, then no result set follows.
355: */
356:
357: DBG_RETURN(PASS);
358: }
359: /* }}} */
360:
361:
362: /* {{{ mysqlnd_query_read_result_set_header */
363: enum_func_status
364: mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s TSRMLS_DC)
365: {
366: MYSQLND_STMT_DATA * stmt = s ? s->data:NULL;
367: enum_func_status ret;
368: MYSQLND_PACKET_RSET_HEADER * rset_header = NULL;
369: MYSQLND_PACKET_EOF * fields_eof = NULL;
370:
371: DBG_ENTER("mysqlnd_query_read_result_set_header");
372: DBG_INF_FMT("stmt=%lu", stmt? stmt->stmt_id:0);
373:
374: ret = FAIL;
375: do {
376: rset_header = conn->protocol->m.get_rset_header_packet(conn->protocol, FALSE TSRMLS_CC);
377: if (!rset_header) {
378: SET_OOM_ERROR(*conn->error_info);
379: ret = FAIL;
380: break;
381: }
382:
383: SET_ERROR_AFF_ROWS(conn);
384:
385: if (FAIL == (ret = PACKET_READ(rset_header, conn))) {
386: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error reading result set's header");
387: break;
388: }
389:
390: if (rset_header->error_info.error_no) {
391: /*
392: Cover a protocol design error: error packet does not
393: contain the server status. Therefore, the client has no way
394: to find out whether there are more result sets of
395: a multiple-result-set statement pending. Luckily, in 5.0 an
396: error always aborts execution of a statement, wherever it is
397: a multi-statement or a stored procedure, so it should be
398: safe to unconditionally turn off the flag here.
399: */
400: conn->upsert_status->server_status &= ~SERVER_MORE_RESULTS_EXISTS;
401: /*
402: This will copy the error code and the messages, as they
403: are buffers in the struct
404: */
405: COPY_CLIENT_ERROR(*conn->error_info, rset_header->error_info);
406: ret = FAIL;
407: DBG_ERR_FMT("error=%s", rset_header->error_info.error);
408: /* Return back from CONN_QUERY_SENT */
409: CONN_SET_STATE(conn, CONN_READY);
410: break;
411: }
412: conn->error_info->error_no = 0;
413:
414: switch (rset_header->field_count) {
415: case MYSQLND_NULL_LENGTH: { /* LOAD DATA LOCAL INFILE */
416: zend_bool is_warning;
417: DBG_INF("LOAD DATA");
418: conn->last_query_type = QUERY_LOAD_LOCAL;
419: conn->field_count = 0; /* overwrite previous value, or the last value could be used and lead to bug#53503 */
420: CONN_SET_STATE(conn, CONN_SENDING_LOAD_DATA);
421: ret = mysqlnd_handle_local_infile(conn, rset_header->info_or_local_file, &is_warning TSRMLS_CC);
422: CONN_SET_STATE(conn, (ret == PASS || is_warning == TRUE)? CONN_READY:CONN_QUIT_SENT);
423: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_NON_RSET_QUERY);
424: break;
425: }
426: case 0: /* UPSERT */
427: DBG_INF("UPSERT");
428: conn->last_query_type = QUERY_UPSERT;
429: conn->field_count = rset_header->field_count;
430: memset(conn->upsert_status, 0, sizeof(*conn->upsert_status));
431: conn->upsert_status->warning_count = rset_header->warning_count;
432: conn->upsert_status->server_status = rset_header->server_status;
433: conn->upsert_status->affected_rows = rset_header->affected_rows;
434: conn->upsert_status->last_insert_id = rset_header->last_insert_id;
435: SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
436: rset_header->info_or_local_file, rset_header->info_or_local_file_len,
437: conn->persistent);
438: /* Result set can follow UPSERT statement, check server_status */
439: if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
440: CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);
441: } else {
442: CONN_SET_STATE(conn, CONN_READY);
443: }
444: ret = PASS;
445: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_NON_RSET_QUERY);
446: break;
447: default: do { /* Result set */
448: MYSQLND_RES * result;
449: enum_mysqlnd_collected_stats statistic = STAT_LAST;
450:
451: DBG_INF("Result set pending");
452: SET_EMPTY_MESSAGE(conn->last_message, conn->last_message_len, conn->persistent);
453:
454: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_RSET_QUERY);
455: memset(conn->upsert_status, 0, sizeof(*conn->upsert_status));
456: /* restore after zeroing */
457: SET_ERROR_AFF_ROWS(conn);
458:
459: conn->last_query_type = QUERY_SELECT;
460: CONN_SET_STATE(conn, CONN_FETCHING_DATA);
461: /* PS has already allocated it */
462: conn->field_count = rset_header->field_count;
463: if (!stmt) {
464: result = conn->current_result = conn->m->result_init(rset_header->field_count, conn->persistent TSRMLS_CC);
465: } else {
466: if (!stmt->result) {
467: DBG_INF("This is 'SHOW'/'EXPLAIN'-like query.");
468: /*
469: This is 'SHOW'/'EXPLAIN'-like query. Current implementation of
470: prepared statements can't send result set metadata for these queries
471: on prepare stage. Read it now.
472: */
473: result = stmt->result = conn->m->result_init(rset_header->field_count, stmt->persistent TSRMLS_CC);
474: } else {
475: /*
476: Update result set metadata if it for some reason changed between
477: prepare and execute, i.e.:
478: - in case of 'SELECT ?' we don't know column type unless data was
479: supplied to mysql_stmt_execute, so updated column type is sent
480: now.
481: - if data dictionary changed between prepare and execute, for
482: example a table used in the query was altered.
483: Note, that now (4.1.3) we always send metadata in reply to
484: COM_STMT_EXECUTE (even if it is not necessary), so either this or
485: previous branch always works.
486: */
487: }
488: result = stmt->result;
489: }
490: if (!result) {
491: SET_OOM_ERROR(*conn->error_info);
492: ret = FAIL;
493: break;
494: }
495:
496: if (FAIL == (ret = result->m.read_result_metadata(result, conn TSRMLS_CC))) {
497: /* For PS, we leave them in Prepared state */
498: if (!stmt && conn->current_result) {
499: mnd_efree(conn->current_result);
500: conn->current_result = NULL;
501: }
502: DBG_ERR("Error occurred while reading metadata");
503: break;
504: }
505:
506: /* Check for SERVER_STATUS_MORE_RESULTS if needed */
507: fields_eof = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC);
508: if (!fields_eof) {
509: SET_OOM_ERROR(*conn->error_info);
510: ret = FAIL;
511: break;
512: }
513: if (FAIL == (ret = PACKET_READ(fields_eof, conn))) {
514: DBG_ERR("Error occurred while reading the EOF packet");
515: result->m.free_result_contents(result TSRMLS_CC);
516: mnd_efree(result);
517: if (!stmt) {
518: conn->current_result = NULL;
519: } else {
520: stmt->result = NULL;
521: memset(stmt, 0, sizeof(MYSQLND_STMT));
522: stmt->state = MYSQLND_STMT_INITTED;
523: }
524: } else {
525: unsigned int to_log = MYSQLND_G(log_mask);
526: to_log &= fields_eof->server_status;
527: DBG_INF_FMT("warnings=%u server_status=%u", fields_eof->warning_count, fields_eof->server_status);
528: conn->upsert_status->warning_count = fields_eof->warning_count;
529: /*
530: If SERVER_MORE_RESULTS_EXISTS is set then this is either MULTI_QUERY or a CALL()
531: The first packet after sending the query/com_execute has the bit set only
532: in this cases. Not sure why it's a needed but it marks that the whole stream
533: will include many result sets. What actually matters are the bits set at the end
534: of every result set (the EOF packet).
535: */
536: conn->upsert_status->server_status = fields_eof->server_status;
537: if (fields_eof->server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) {
538: statistic = STAT_BAD_INDEX_USED;
539: } else if (fields_eof->server_status & SERVER_QUERY_NO_INDEX_USED) {
540: statistic = STAT_NO_INDEX_USED;
541: } else if (fields_eof->server_status & SERVER_QUERY_WAS_SLOW) {
542: statistic = STAT_QUERY_WAS_SLOW;
543: }
544: if (to_log) {
545: #if A0
546: char *backtrace = mysqlnd_get_backtrace(TSRMLS_C);
547: php_log_err(backtrace TSRMLS_CC);
548: efree(backtrace);
549: #endif
550: }
551: MYSQLND_INC_CONN_STATISTIC(conn->stats, statistic);
552: }
553: } while (0);
554: PACKET_FREE(fields_eof);
555: break; /* switch break */
556: }
557: } while (0);
558: PACKET_FREE(rset_header);
559:
560: DBG_INF(ret == PASS? "PASS":"FAIL");
561: DBG_RETURN(ret);
562: }
563: /* }}} */
564:
565:
566: /* {{{ mysqlnd_fetch_lengths_buffered */
567: /*
568: Do lazy initialization for buffered results. As PHP strings have
569: length inside, this function makes not much sense in the context
570: of PHP, to be called as separate function. But let's have it for
571: completeness.
572: */
573: static unsigned long *
574: mysqlnd_fetch_lengths_buffered(MYSQLND_RES * const result TSRMLS_DC)
575: {
576: unsigned int i;
577: zval **previous_row;
578: MYSQLND_RES_BUFFERED *set = result->stored_data;
579:
580: /*
581: If:
582: - unbuffered result
583: - first row has not been read
584: - last_row has been read
585: */
586: if (set->data_cursor == NULL ||
587: set->data_cursor == set->data ||
588: ((set->data_cursor - set->data) > (set->row_count * result->meta->field_count) ))
589: {
590: return NULL;/* No rows or no more rows */
591: }
592:
593: previous_row = set->data_cursor - result->meta->field_count;
594: for (i = 0; i < result->meta->field_count; i++) {
595: result->lengths[i] = (Z_TYPE_P(previous_row[i]) == IS_NULL)? 0:Z_STRLEN_P(previous_row[i]);
596: }
597:
598: return result->lengths;
599: }
600: /* }}} */
601:
602:
603: /* {{{ mysqlnd_fetch_lengths_unbuffered */
604: static unsigned long *
605: mysqlnd_fetch_lengths_unbuffered(MYSQLND_RES * const result TSRMLS_DC)
606: {
607: /* simulate output of libmysql */
608: return (!result->unbuf || result->unbuf->last_row_data || result->unbuf->eof_reached)? result->lengths:NULL;
609: }
610: /* }}} */
611:
612:
613: /* {{{ mysqlnd_res::fetch_lengths */
614: PHPAPI unsigned long * _mysqlnd_fetch_lengths(MYSQLND_RES * const result TSRMLS_DC)
615: {
616: return result->m.fetch_lengths? result->m.fetch_lengths(result TSRMLS_CC) : NULL;
617: }
618: /* }}} */
619:
620:
621: /* {{{ mysqlnd_fetch_row_unbuffered_c */
622: static MYSQLND_ROW_C
623: mysqlnd_fetch_row_unbuffered_c(MYSQLND_RES * result TSRMLS_DC)
624: {
625: enum_func_status ret;
626: MYSQLND_ROW_C retrow = NULL;
627: unsigned int i,
628: field_count = result->field_count;
629: MYSQLND_PACKET_ROW *row_packet = result->row_packet;
630: unsigned long *lengths = result->lengths;
631:
632: DBG_ENTER("mysqlnd_fetch_row_unbuffered_c");
633:
634: if (result->unbuf->eof_reached) {
635: /* No more rows obviously */
636: DBG_RETURN(retrow);
637: }
638: if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
639: SET_CLIENT_ERROR(*result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
640: UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
641: DBG_RETURN(retrow);
642: }
643: if (!row_packet) {
644: /* Not fully initialized object that is being cleaned up */
645: DBG_RETURN(retrow);
646: }
647: /* Let the row packet fill our buffer and skip additional mnd_malloc + memcpy */
648: row_packet->skip_extraction = FALSE;
649:
650: /*
651: If we skip rows (row == NULL) we have to
652: result->m.unbuffered_free_last_data() before it. The function returns always true.
653: */
654: if (PASS == (ret = PACKET_READ(row_packet, result->conn)) && !row_packet->eof) {
655: result->unbuf->row_count++;
656:
657: result->m.unbuffered_free_last_data(result TSRMLS_CC);
658:
659: result->unbuf->last_row_data = row_packet->fields;
660: result->unbuf->last_row_buffer = row_packet->row_buffer;
661: row_packet->fields = NULL;
662: row_packet->row_buffer = NULL;
663:
664: MYSQLND_INC_CONN_STATISTIC(result->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
665:
666: if (!row_packet->skip_extraction) {
667: MYSQLND_FIELD *field = result->meta->fields;
668: struct mysqlnd_field_hash_key * hash_key = result->meta->zend_hash_keys;
669:
670: enum_func_status rc = result->m.row_decoder(result->unbuf->last_row_buffer,
671: result->unbuf->last_row_data,
672: row_packet->field_count,
673: row_packet->fields_metadata,
674: result->conn->options->numeric_and_datetime_as_unicode,
675: result->conn->options->int_and_float_native,
676: result->conn->stats TSRMLS_CC);
677: if (PASS != rc) {
678: DBG_RETURN(retrow);
679: }
680:
681: retrow = mnd_malloc(result->field_count * sizeof(char *));
682: if (retrow) {
683: for (i = 0; i < field_count; i++, field++, hash_key++) {
684: zval *data = result->unbuf->last_row_data[i];
685: unsigned int len;
686:
687: if (Z_TYPE_P(data) != IS_NULL) {
688: convert_to_string(data);
689: retrow[i] = Z_STRVAL_P(data);
690: len = Z_STRLEN_P(data);
691: } else {
692: retrow[i] = NULL;
693: len = 0;
694: }
695:
696: if (lengths) {
697: lengths[i] = len;
698: }
699:
700: if (field->max_length < len) {
701: field->max_length = len;
702: }
703: }
704: } else {
705: SET_OOM_ERROR(*result->conn->error_info);
706: }
707: }
708: } else if (ret == FAIL) {
709: if (row_packet->error_info.error_no) {
710: COPY_CLIENT_ERROR(*result->conn->error_info, row_packet->error_info);
711: DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);
712: }
713: CONN_SET_STATE(result->conn, CONN_READY);
714: result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
715: } else if (row_packet->eof) {
716: /* Mark the connection as usable again */
717: DBG_INF_FMT("warnings=%u server_status=%u", row_packet->warning_count, row_packet->server_status);
718: result->unbuf->eof_reached = TRUE;
719: memset(result->conn->upsert_status, 0, sizeof(*result->conn->upsert_status));
720: result->conn->upsert_status->warning_count = row_packet->warning_count;
721: result->conn->upsert_status->server_status = row_packet->server_status;
722: /*
723: result->row_packet will be cleaned when
724: destroying the result object
725: */
726: if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
727: CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
728: } else {
729: CONN_SET_STATE(result->conn, CONN_READY);
730: }
731: result->m.unbuffered_free_last_data(result TSRMLS_CC);
732: }
733:
734: DBG_RETURN(retrow);
735: }
736: /* }}} */
737:
738:
739: /* {{{ mysqlnd_fetch_row_unbuffered */
740: static enum_func_status
741: mysqlnd_fetch_row_unbuffered(MYSQLND_RES * result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
742: {
743: enum_func_status ret;
744: zval *row = (zval *) param;
745: MYSQLND_PACKET_ROW *row_packet = result->row_packet;
746:
747: DBG_ENTER("mysqlnd_fetch_row_unbuffered");
748:
749: *fetched_anything = FALSE;
750: if (result->unbuf->eof_reached) {
751: /* No more rows obviously */
752: DBG_RETURN(PASS);
753: }
754: if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
755: SET_CLIENT_ERROR(*result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
756: DBG_RETURN(FAIL);
757: }
758: if (!row_packet) {
759: /* Not fully initialized object that is being cleaned up */
760: DBG_RETURN(FAIL);
761: }
762: /* Let the row packet fill our buffer and skip additional mnd_malloc + memcpy */
763: row_packet->skip_extraction = row? FALSE:TRUE;
764:
765: /*
766: If we skip rows (row == NULL) we have to
767: result->m.unbuffered_free_last_data() before it. The function returns always true.
768: */
769: if (PASS == (ret = PACKET_READ(row_packet, result->conn)) && !row_packet->eof) {
770: result->m.unbuffered_free_last_data(result TSRMLS_CC);
771:
772: result->unbuf->last_row_data = row_packet->fields;
773: result->unbuf->last_row_buffer = row_packet->row_buffer;
774: row_packet->fields = NULL;
775: row_packet->row_buffer = NULL;
776:
777: MYSQLND_INC_CONN_STATISTIC(result->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
778:
779: if (!row_packet->skip_extraction) {
780: HashTable *row_ht = Z_ARRVAL_P(row);
781: MYSQLND_FIELD *field = result->meta->fields;
782: struct mysqlnd_field_hash_key * hash_key = result->meta->zend_hash_keys;
783: unsigned int i, field_count = result->field_count;
784: unsigned long *lengths = result->lengths;
785:
786: enum_func_status rc = result->m.row_decoder(result->unbuf->last_row_buffer,
787: result->unbuf->last_row_data,
788: field_count,
789: row_packet->fields_metadata,
790: result->conn->options->numeric_and_datetime_as_unicode,
791: result->conn->options->int_and_float_native,
792: result->conn->stats TSRMLS_CC);
793: if (PASS != rc) {
794: DBG_RETURN(FAIL);
795: }
796: for (i = 0; i < field_count; i++, field++, hash_key++) {
797: zval *data = result->unbuf->last_row_data[i];
798: unsigned int len = (Z_TYPE_P(data) == IS_NULL)? 0:Z_STRLEN_P(data);
799:
800: if (lengths) {
801: lengths[i] = len;
802: }
803:
804: if (flags & MYSQLND_FETCH_NUM) {
805: Z_ADDREF_P(data);
806: zend_hash_next_index_insert(row_ht, &data, sizeof(zval *), NULL);
807: }
808: if (flags & MYSQLND_FETCH_ASSOC) {
809: /* zend_hash_quick_update needs length + trailing zero */
810: /* QQ: Error handling ? */
811: /*
812: zend_hash_quick_update does not check, as add_assoc_zval_ex do, whether
813: the index is a numeric and convert it to it. This however means constant
814: hashing of the column name, which is not needed as it can be precomputed.
815: */
816: Z_ADDREF_P(data);
817: if (hash_key->is_numeric == FALSE) {
818: #if MYSQLND_UNICODE
819: zend_u_hash_quick_update(Z_ARRVAL_P(row), IS_UNICODE,
820: hash_key->ustr,
821: hash_key->ulen + 1,
822: hash_key->key,
823: (void *) &data, sizeof(zval *), NULL);
824: #else
825: zend_hash_quick_update(Z_ARRVAL_P(row),
826: field->name,
827: field->name_length + 1,
828: hash_key->key,
829: (void *) &data, sizeof(zval *), NULL);
830: #endif
831: } else {
832: zend_hash_index_update(Z_ARRVAL_P(row),
833: hash_key->key,
834: (void *) &data, sizeof(zval *), NULL);
835: }
836: }
837: if (field->max_length < len) {
838: field->max_length = len;
839: }
840: }
841: }
842: *fetched_anything = TRUE;
843: result->unbuf->row_count++;
844: } else if (ret == FAIL) {
845: if (row_packet->error_info.error_no) {
846: COPY_CLIENT_ERROR(*result->conn->error_info, row_packet->error_info);
847: DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);
848: }
849: CONN_SET_STATE(result->conn, CONN_READY);
850: result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
851: } else if (row_packet->eof) {
852: /* Mark the connection as usable again */
853: DBG_INF_FMT("warnings=%u server_status=%u", row_packet->warning_count, row_packet->server_status);
854: result->unbuf->eof_reached = TRUE;
855: memset(result->conn->upsert_status, 0, sizeof(*result->conn->upsert_status));
856: result->conn->upsert_status->warning_count = row_packet->warning_count;
857: result->conn->upsert_status->server_status = row_packet->server_status;
858: /*
859: result->row_packet will be cleaned when
860: destroying the result object
861: */
862: if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
863: CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
864: } else {
865: CONN_SET_STATE(result->conn, CONN_READY);
866: }
867: result->m.unbuffered_free_last_data(result TSRMLS_CC);
868: }
869:
870: DBG_INF_FMT("ret=%s fetched=%u", ret == PASS? "PASS":"FAIL", *fetched_anything);
871: DBG_RETURN(PASS);
872: }
873: /* }}} */
874:
875:
876: /* {{{ mysqlnd_res::use_result */
877: static MYSQLND_RES *
878: MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES * const result, zend_bool ps TSRMLS_DC)
879: {
880: DBG_ENTER("mysqlnd_res::use_result");
881:
882: SET_EMPTY_ERROR(*result->conn->error_info);
883:
884: if (ps == FALSE) {
885: result->type = MYSQLND_RES_NORMAL;
886: result->m.fetch_row = result->m.fetch_row_normal_unbuffered;
887: result->m.fetch_lengths = mysqlnd_fetch_lengths_unbuffered;
888: result->m.row_decoder = php_mysqlnd_rowp_read_text_protocol;
889: result->lengths = mnd_ecalloc(result->field_count, sizeof(unsigned long));
890: if (!result->lengths) {
891: goto oom;
892: }
893: } else {
894: result->type = MYSQLND_RES_PS_UNBUF;
895: result->m.fetch_row = NULL;
896: /* result->m.fetch_row() will be set in mysqlnd_ps.c */
897: result->m.fetch_lengths = NULL; /* makes no sense */
898: result->m.row_decoder = php_mysqlnd_rowp_read_binary_protocol;
899: result->lengths = NULL;
900: }
901:
902: result->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size) TSRMLS_CC);
903: result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED));
904: if (!result->result_set_memory_pool || !result->unbuf) {
905: goto oom;
906: }
907:
908: /*
909: Will be freed in the mysqlnd_internal_free_result_contents() called
910: by the resource destructor. mysqlnd_fetch_row_unbuffered() expects
911: this to be not NULL.
912: */
913: /* FALSE = non-persistent */
914: result->row_packet = result->conn->protocol->m.get_row_packet(result->conn->protocol, FALSE TSRMLS_CC);
915: if (!result->row_packet) {
916: goto oom;
917: }
918: result->row_packet->result_set_memory_pool = result->result_set_memory_pool;
919: result->row_packet->field_count = result->field_count;
920: result->row_packet->binary_protocol = ps;
921: result->row_packet->fields_metadata = result->meta->fields;
922: result->row_packet->bit_fields_count = result->meta->bit_fields_count;
923: result->row_packet->bit_fields_total_len = result->meta->bit_fields_total_len;
924:
925: DBG_RETURN(result);
926: oom:
927: SET_OOM_ERROR(*result->conn->error_info);
928: DBG_RETURN(NULL);
929: }
930: /* }}} */
931:
932:
933: /* {{{ mysqlnd_fetch_row_buffered_c */
934: static MYSQLND_ROW_C
935: mysqlnd_fetch_row_buffered_c(MYSQLND_RES * result TSRMLS_DC)
936: {
937: MYSQLND_ROW_C ret = NULL;
938: MYSQLND_RES_BUFFERED *set = result->stored_data;
939:
940: DBG_ENTER("mysqlnd_fetch_row_buffered_c");
941:
942: /* If we haven't read everything */
943: if (set->data_cursor &&
944: (set->data_cursor - set->data) < (set->row_count * result->meta->field_count))
945: {
946: zval **current_row = set->data_cursor;
947: MYSQLND_FIELD *field = result->meta->fields;
948: struct mysqlnd_field_hash_key * hash_key = result->meta->zend_hash_keys;
949: unsigned int i;
950:
951: if (NULL == current_row[0]) {
952: uint64_t row_num = (set->data_cursor - set->data) / result->meta->field_count;
953: enum_func_status rc = result->m.row_decoder(set->row_buffers[row_num],
954: current_row,
955: result->meta->field_count,
956: result->meta->fields,
957: result->conn->options->numeric_and_datetime_as_unicode,
958: result->conn->options->int_and_float_native,
959: result->conn->stats TSRMLS_CC);
960: if (rc != PASS) {
961: DBG_RETURN(ret);
962: }
963: set->initialized_rows++;
964: for (i = 0; i < result->field_count; i++) {
965: /*
966: NULL fields are 0 length, 0 is not more than 0
967: String of zero size, definitely can't be the next max_length.
968: Thus for NULL and zero-length we are quite efficient.
969: */
970: if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
971: unsigned long len = Z_STRLEN_P(current_row[i]);
972: if (field->max_length < len) {
973: field->max_length = len;
974: }
975: }
976: }
977: }
978:
979: set->data_cursor += result->meta->field_count;
980: MYSQLND_INC_GLOBAL_STATISTIC(STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_BUF);
981:
982: ret = mnd_malloc(result->field_count * sizeof(char *));
983: if (ret) {
984: for (i = 0; i < result->field_count; i++, field++, hash_key++) {
985: zval *data = current_row[i];
986:
987: if (Z_TYPE_P(data) != IS_NULL) {
988: convert_to_string(data);
989: ret[i] = Z_STRVAL_P(data);
990: } else {
991: ret[i] = NULL;
992: }
993: }
994: }
995: /* there is no conn handle in this function thus we can't set OOM in error_info */
996: } else {
997: set->data_cursor = NULL;
998: DBG_INF("EOF reached");
999: }
1000: DBG_RETURN(ret);
1001: }
1002: /* }}} */
1003:
1004:
1005: /* {{{ mysqlnd_fetch_row_buffered */
1006: static enum_func_status
1007: mysqlnd_fetch_row_buffered(MYSQLND_RES * result, void *param, unsigned int flags, zend_bool *fetched_anything TSRMLS_DC)
1008: {
1009: unsigned int i;
1010: zval *row = (zval *) param;
1011: MYSQLND_RES_BUFFERED *set = result->stored_data;
1012: enum_func_status ret = FAIL;
1013:
1014: DBG_ENTER("mysqlnd_fetch_row_buffered");
1015:
1016: /* If we haven't read everything */
1017: if (set->data_cursor &&
1018: (set->data_cursor - set->data) < (set->row_count * result->meta->field_count))
1019: {
1020: zval **current_row = set->data_cursor;
1021: MYSQLND_FIELD *field = result->meta->fields;
1022: struct mysqlnd_field_hash_key * hash_key = result->meta->zend_hash_keys;
1023:
1024: if (NULL == current_row[0]) {
1025: uint64_t row_num = (set->data_cursor - set->data) / result->meta->field_count;
1026: enum_func_status rc = result->m.row_decoder(set->row_buffers[row_num],
1027: current_row,
1028: result->meta->field_count,
1029: result->meta->fields,
1030: result->conn->options->numeric_and_datetime_as_unicode,
1031: result->conn->options->int_and_float_native,
1032: result->conn->stats TSRMLS_CC);
1033: if (rc != PASS) {
1034: DBG_RETURN(FAIL);
1035: }
1036: set->initialized_rows++;
1037: for (i = 0; i < result->field_count; i++) {
1038: /*
1039: NULL fields are 0 length, 0 is not more than 0
1040: String of zero size, definitely can't be the next max_length.
1041: Thus for NULL and zero-length we are quite efficient.
1042: */
1043: if (Z_TYPE_P(current_row[i]) >= IS_STRING) {
1044: unsigned long len = Z_STRLEN_P(current_row[i]);
1045: if (field->max_length < len) {
1046: field->max_length = len;
1047: }
1048: }
1049: }
1050: }
1051:
1052: for (i = 0; i < result->field_count; i++, field++, hash_key++) {
1053: zval *data = current_row[i];
1054:
1055: if (flags & MYSQLND_FETCH_NUM) {
1056: Z_ADDREF_P(data);
1057: zend_hash_next_index_insert(Z_ARRVAL_P(row), &data, sizeof(zval *), NULL);
1058: }
1059: if (flags & MYSQLND_FETCH_ASSOC) {
1060: /* zend_hash_quick_update needs length + trailing zero */
1061: /* QQ: Error handling ? */
1062: /*
1063: zend_hash_quick_update does not check, as add_assoc_zval_ex do, whether
1064: the index is a numeric and convert it to it. This however means constant
1065: hashing of the column name, which is not needed as it can be precomputed.
1066: */
1067: Z_ADDREF_P(data);
1068: if (hash_key->is_numeric == FALSE) {
1069: #if MYSQLND_UNICODE
1070: zend_u_hash_quick_update(Z_ARRVAL_P(row), IS_UNICODE,
1071: hash_key->ustr,
1072: hash_key->ulen + 1,
1073: hash_key->key,
1074: (void *) &data, sizeof(zval *), NULL);
1075: #else
1076: zend_hash_quick_update(Z_ARRVAL_P(row),
1077: field->name,
1078: field->name_length + 1,
1079: hash_key->key,
1080: (void *) &data, sizeof(zval *), NULL);
1081: #endif
1082: } else {
1083: zend_hash_index_update(Z_ARRVAL_P(row),
1084: hash_key->key,
1085: (void *) &data, sizeof(zval *), NULL);
1086: }
1087: }
1088: }
1089: set->data_cursor += result->meta->field_count;
1090: *fetched_anything = TRUE;
1091: MYSQLND_INC_GLOBAL_STATISTIC(STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_BUF);
1092: ret = PASS;
1093: } else {
1094: set->data_cursor = NULL;
1095: *fetched_anything = FALSE;
1096: ret = PASS;
1097: DBG_INF("EOF reached");
1098: }
1099: DBG_INF_FMT("ret=PASS fetched=%u", *fetched_anything);
1100: DBG_RETURN(ret);
1101: }
1102: /* }}} */
1103:
1104:
1105: #define STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY 2
1106:
1107: /* {{{ mysqlnd_res::store_result_fetch_data */
1108: enum_func_status
1109: MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result,
1110: MYSQLND_RES_METADATA *meta,
1111: zend_bool binary_protocol TSRMLS_DC)
1112: {
1113: enum_func_status ret;
1114: MYSQLND_PACKET_ROW *row_packet = NULL;
1115: unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows = 1;
1116: MYSQLND_RES_BUFFERED *set;
1117:
1118: DBG_ENTER("mysqlnd_res::store_result_fetch_data");
1119:
1120: result->stored_data = set = mnd_ecalloc(1, sizeof(MYSQLND_RES_BUFFERED));
1121: if (!set) {
1122: SET_OOM_ERROR(*conn->error_info);
1123: ret = FAIL;
1124: goto end;
1125: }
1126: if (free_rows) {
1127: set->row_buffers = mnd_emalloc((size_t)(free_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
1128: if (!set->row_buffers) {
1129: SET_OOM_ERROR(*conn->error_info);
1130: ret = FAIL;
1131: goto end;
1132: }
1133: }
1134: set->references = 1;
1135:
1136: /* non-persistent */
1137: row_packet = conn->protocol->m.get_row_packet(conn->protocol, FALSE TSRMLS_CC);
1138: if (!row_packet) {
1139: SET_OOM_ERROR(*conn->error_info);
1140: ret = FAIL;
1141: goto end;
1142: }
1143: row_packet->result_set_memory_pool = result->result_set_memory_pool;
1144: row_packet->field_count = meta->field_count;
1145: row_packet->binary_protocol = binary_protocol;
1146: row_packet->fields_metadata = meta->fields;
1147: row_packet->bit_fields_count = meta->bit_fields_count;
1148: row_packet->bit_fields_total_len = meta->bit_fields_total_len;
1149:
1150: row_packet->skip_extraction = TRUE; /* let php_mysqlnd_rowp_read() not allocate row_packet->fields, we will do it */
1151:
1152: while (FAIL != (ret = PACKET_READ(row_packet, conn)) && !row_packet->eof) {
1153: if (!free_rows) {
1154: uint64_t total_allocated_rows = free_rows = next_extend = next_extend * 11 / 10; /* extend with 10% */
1155: MYSQLND_MEMORY_POOL_CHUNK ** new_row_buffers;
1156: total_allocated_rows += set->row_count;
1157:
1158: /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */
1159: if (total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
1160: SET_OOM_ERROR(*conn->error_info);
1161: ret = FAIL;
1162: goto end;
1163: }
1164: new_row_buffers = mnd_erealloc(set->row_buffers, (size_t)(total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
1165: if (!new_row_buffers) {
1166: SET_OOM_ERROR(*conn->error_info);
1167: ret = FAIL;
1168: goto end;
1169: }
1170: set->row_buffers = new_row_buffers;
1171: }
1172: free_rows--;
1173: set->row_buffers[set->row_count] = row_packet->row_buffer;
1174:
1175: set->row_count++;
1176:
1177: /* So row_packet's destructor function won't efree() it */
1178: row_packet->fields = NULL;
1179: row_packet->row_buffer = NULL;
1180:
1181: /*
1182: No need to FREE_ALLOCA as we can reuse the
1183: 'lengths' and 'fields' arrays. For lengths its absolutely safe.
1184: 'fields' is reused because the ownership of the strings has been
1185: transfered above.
1186: */
1187: }
1188: /* Overflow ? */
1189: if (set->row_count) {
1190: /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */
1191: if (set->row_count * meta->field_count * sizeof(zval *) > SIZE_MAX) {
1192: SET_OOM_ERROR(*conn->error_info);
1193: ret = FAIL;
1194: goto end;
1195: }
1196: /* if pecalloc is used valgrind barks gcc version 4.3.1 20080507 (prerelease) [gcc-4_3-branch revision 135036] (SUSE Linux) */
1197: set->data = mnd_emalloc((size_t)(set->row_count * meta->field_count * sizeof(zval *)));
1198: if (!set->data) {
1199: SET_OOM_ERROR(*conn->error_info);
1200: ret = FAIL;
1201: goto end;
1202: }
1203: memset(set->data, 0, (size_t)(set->row_count * meta->field_count * sizeof(zval *)));
1204: }
1205:
1206: MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats,
1207: binary_protocol? STAT_ROWS_BUFFERED_FROM_CLIENT_PS:
1208: STAT_ROWS_BUFFERED_FROM_CLIENT_NORMAL,
1209: set->row_count);
1210:
1211: /* Finally clean */
1212: if (row_packet->eof) {
1213: memset(conn->upsert_status, 0, sizeof(*conn->upsert_status));
1214: conn->upsert_status->warning_count = row_packet->warning_count;
1215: conn->upsert_status->server_status = row_packet->server_status;
1216: }
1217: /* save some memory */
1218: if (free_rows) {
1219: /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */
1220: if (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
1221: SET_OOM_ERROR(*conn->error_info);
1222: ret = FAIL;
1223: goto end;
1224: }
1225: set->row_buffers = mnd_erealloc(set->row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)));
1226: }
1227:
1228: if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
1229: CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);
1230: } else {
1231: CONN_SET_STATE(conn, CONN_READY);
1232: }
1233:
1234: if (ret == FAIL) {
1235: COPY_CLIENT_ERROR(set->error_info, row_packet->error_info);
1236: } else {
1237: /* Position at the first row */
1238: set->data_cursor = set->data;
1239:
1240: /* libmysql's documentation says it should be so for SELECT statements */
1241: conn->upsert_status->affected_rows = set->row_count;
1242: }
1243: DBG_INF_FMT("ret=%s row_count=%u warnings=%u server_status=%u",
1244: ret == PASS? "PASS":"FAIL", (uint) set->row_count, conn->upsert_status->warning_count, conn->upsert_status->server_status);
1245: end:
1246: PACKET_FREE(row_packet);
1247:
1248: DBG_RETURN(ret);
1249: }
1250: /* }}} */
1251:
1252:
1253: /* {{{ mysqlnd_res::store_result */
1254: static MYSQLND_RES *
1255: MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,
1256: MYSQLND_CONN_DATA * const conn,
1257: zend_bool ps_protocol TSRMLS_DC)
1258: {
1259: enum_func_status ret;
1260:
1261: DBG_ENTER("mysqlnd_res::store_result");
1262:
1263: /* We need the conn because we are doing lazy zval initialization in buffered_fetch_row */
1264: result->conn = conn->m->get_reference(conn TSRMLS_CC);
1265: result->type = MYSQLND_RES_NORMAL;
1266: result->m.fetch_row = result->m.fetch_row_normal_buffered;
1267: result->m.fetch_lengths = mysqlnd_fetch_lengths_buffered;
1268: result->m.row_decoder = ps_protocol? php_mysqlnd_rowp_read_binary_protocol:
1269: php_mysqlnd_rowp_read_text_protocol;
1270:
1271: result->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size) TSRMLS_CC);
1272: result->lengths = mnd_ecalloc(result->field_count, sizeof(unsigned long));
1273:
1274: if (!result->result_set_memory_pool || !result->lengths) {
1275: SET_OOM_ERROR(*conn->error_info);
1276: DBG_RETURN(NULL);
1277: }
1278:
1279: CONN_SET_STATE(conn, CONN_FETCHING_DATA);
1280:
1281: ret = result->m.store_result_fetch_data(conn, result, result->meta, ps_protocol TSRMLS_CC);
1282: if (FAIL == ret) {
1283: if (result->stored_data) {
1284: COPY_CLIENT_ERROR(*conn->error_info, result->stored_data->error_info);
1285: } else {
1286: SET_OOM_ERROR(*conn->error_info);
1287: }
1288: DBG_RETURN(NULL);
1289: }
1290: /* libmysql's documentation says it should be so for SELECT statements */
1291: conn->upsert_status->affected_rows = result->stored_data->row_count;
1292:
1293: DBG_RETURN(result);
1294: }
1295: /* }}} */
1296:
1297:
1298: /* {{{ mysqlnd_res::skip_result */
1299: static enum_func_status
1300: MYSQLND_METHOD(mysqlnd_res, skip_result)(MYSQLND_RES * const result TSRMLS_DC)
1301: {
1302: zend_bool fetched_anything;
1303:
1304: DBG_ENTER("mysqlnd_res::skip_result");
1305: /*
1306: Unbuffered sets
1307: A PS could be prepared - there is metadata and thus a stmt->result but the
1308: fetch_row function isn't actually set (NULL), thus we have to skip these.
1309: */
1310: if (!result->stored_data && result->unbuf &&
1311: !result->unbuf->eof_reached && result->m.fetch_row)
1312: {
1313: DBG_INF("skipping result");
1314: /* We have to fetch all data to clean the line */
1315: MYSQLND_INC_CONN_STATISTIC(result->conn->stats,
1316: result->type == MYSQLND_RES_NORMAL? STAT_FLUSHED_NORMAL_SETS:
1317: STAT_FLUSHED_PS_SETS);
1318:
1319: while ((PASS == result->m.fetch_row(result, NULL, 0, &fetched_anything TSRMLS_CC)) && fetched_anything == TRUE) {
1320: /* do nothing */;
1321: }
1322: }
1323: DBG_RETURN(PASS);
1324: }
1325: /* }}} */
1326:
1327:
1328: /* {{{ mysqlnd_res::free_result */
1329: static enum_func_status
1330: MYSQLND_METHOD(mysqlnd_res, free_result)(MYSQLND_RES * result, zend_bool implicit TSRMLS_DC)
1331: {
1332: DBG_ENTER("mysqlnd_res::free_result");
1333:
1334: result->m.skip_result(result TSRMLS_CC);
1335: MYSQLND_INC_CONN_STATISTIC(result->conn? result->conn->stats : NULL,
1336: implicit == TRUE? STAT_FREE_RESULT_IMPLICIT:
1337: STAT_FREE_RESULT_EXPLICIT);
1338:
1339: result->m.free_result_internal(result TSRMLS_CC);
1340: DBG_RETURN(PASS);
1341: }
1342: /* }}} */
1343:
1344:
1345: /* {{{ mysqlnd_res::data_seek */
1346: static enum_func_status
1347: MYSQLND_METHOD(mysqlnd_res, data_seek)(MYSQLND_RES * result, uint64_t row TSRMLS_DC)
1348: {
1349: DBG_ENTER("mysqlnd_res::data_seek");
1350: DBG_INF_FMT("row=%lu", row);
1351:
1352: if (!result->stored_data) {
1353: return FAIL;
1354: }
1355:
1356: /* libmysql just moves to the end, it does traversing of a linked list */
1357: if (row >= result->stored_data->row_count) {
1358: result->stored_data->data_cursor = NULL;
1359: } else {
1360: result->stored_data->data_cursor = result->stored_data->data + row * result->meta->field_count;
1361: }
1362:
1363: DBG_RETURN(PASS);
1364: }
1365: /* }}} */
1366:
1367:
1368: /* {{{ mysqlnd_res::num_rows */
1369: static uint64_t
1370: MYSQLND_METHOD(mysqlnd_res, num_rows)(const MYSQLND_RES * const result TSRMLS_DC)
1371: {
1372: /* Be compatible with libmysql. We count row_count, but will return 0 */
1373: return result->stored_data? result->stored_data->row_count:(result->unbuf && result->unbuf->eof_reached? result->unbuf->row_count:0);
1374: }
1375: /* }}} */
1376:
1377:
1378: /* {{{ mysqlnd_res::num_fields */
1379: static unsigned int
1380: MYSQLND_METHOD(mysqlnd_res, num_fields)(const MYSQLND_RES * const result TSRMLS_DC)
1381: {
1382: return result->field_count;
1383: }
1384: /* }}} */
1385:
1386:
1387: /* {{{ mysqlnd_res::fetch_field */
1388: static const MYSQLND_FIELD *
1389: MYSQLND_METHOD(mysqlnd_res, fetch_field)(MYSQLND_RES * const result TSRMLS_DC)
1390: {
1391: DBG_ENTER("mysqlnd_res::fetch_field");
1392: do {
1393: if (result->meta) {
1394: /*
1395: We optimize the result set, so we don't convert all the data from raw buffer format to
1396: zval arrays during store. In the case someone doesn't read all the lines this will
1397: save time. However, when a metadata call is done, we need to calculate max_length.
1398: We don't have control whether max_length will be used, unfortunately. Otherwise we
1399: could have been able to skip that step.
1400: Well, if the mysqli API switches from returning stdClass to class like mysqli_field_metadata,
1401: then we can have max_length as dynamic property, which will be calculated during runtime and
1402: not during mysqli_fetch_field() time.
1403: */
1404: if (result->stored_data && (result->stored_data->initialized_rows < result->stored_data->row_count)) {
1405: DBG_INF_FMT("We have decode the whole result set to be able to satisfy this meta request");
1406: /* we have to initialize the rest to get the updated max length */
1407: if (PASS != result->m.initialize_result_set_rest(result TSRMLS_CC)) {
1408: break;
1409: }
1410: }
1411: DBG_RETURN(result->meta->m->fetch_field(result->meta TSRMLS_CC));
1412: }
1413: } while (0);
1414: DBG_RETURN(NULL);
1415: }
1416: /* }}} */
1417:
1418:
1419: /* {{{ mysqlnd_res::fetch_field_direct */
1420: static const MYSQLND_FIELD *
1421: MYSQLND_METHOD(mysqlnd_res, fetch_field_direct)(MYSQLND_RES * const result, MYSQLND_FIELD_OFFSET fieldnr TSRMLS_DC)
1422: {
1423: DBG_ENTER("mysqlnd_res::fetch_field_direct");
1424: do {
1425: if (result->meta) {
1426: /*
1427: We optimize the result set, so we don't convert all the data from raw buffer format to
1428: zval arrays during store. In the case someone doesn't read all the lines this will
1429: save time. However, when a metadata call is done, we need to calculate max_length.
1430: We don't have control whether max_length will be used, unfortunately. Otherwise we
1431: could have been able to skip that step.
1432: Well, if the mysqli API switches from returning stdClass to class like mysqli_field_metadata,
1433: then we can have max_length as dynamic property, which will be calculated during runtime and
1434: not during mysqli_fetch_field_direct() time.
1435: */
1436: if (result->stored_data && (result->stored_data->initialized_rows < result->stored_data->row_count)) {
1437: DBG_INF_FMT("We have decode the whole result set to be able to satisfy this meta request");
1438: /* we have to initialized the rest to get the updated max length */
1439: if (PASS != result->m.initialize_result_set_rest(result TSRMLS_CC)) {
1440: break;
1441: }
1442: }
1443: DBG_RETURN(result->meta->m->fetch_field_direct(result->meta, fieldnr TSRMLS_CC));
1444: }
1445: } while (0);
1446:
1447: DBG_RETURN(NULL);
1448: }
1449: /* }}} */
1450:
1451:
1452: /* {{{ mysqlnd_res::fetch_field */
1453: static const MYSQLND_FIELD *
1454: MYSQLND_METHOD(mysqlnd_res, fetch_fields)(MYSQLND_RES * const result TSRMLS_DC)
1455: {
1456: DBG_ENTER("mysqlnd_res::fetch_fields");
1457: do {
1458: if (result->meta) {
1459: if (result->stored_data && (result->stored_data->initialized_rows < result->stored_data->row_count)) {
1460: /* we have to initialize the rest to get the updated max length */
1461: if (PASS != result->m.initialize_result_set_rest(result TSRMLS_CC)) {
1462: break;
1463: }
1464: }
1465: DBG_RETURN(result->meta->m->fetch_fields(result->meta TSRMLS_CC));
1466: }
1467: } while (0);
1468: DBG_RETURN(NULL);
1469: }
1470: /* }}} */
1471:
1472:
1473:
1474: /* {{{ mysqlnd_res::field_seek */
1475: static MYSQLND_FIELD_OFFSET
1476: MYSQLND_METHOD(mysqlnd_res, field_seek)(MYSQLND_RES * const result, MYSQLND_FIELD_OFFSET field_offset TSRMLS_DC)
1477: {
1478: MYSQLND_FIELD_OFFSET return_value = 0;
1479: if (result->meta) {
1480: return_value = result->meta->current_field;
1481: result->meta->current_field = field_offset;
1482: }
1483: return return_value;
1484: }
1485: /* }}} */
1486:
1487:
1488: /* {{{ mysqlnd_res::field_tell */
1489: static MYSQLND_FIELD_OFFSET
1490: MYSQLND_METHOD(mysqlnd_res, field_tell)(const MYSQLND_RES * const result TSRMLS_DC)
1491: {
1492: return result->meta? result->meta->m->field_tell(result->meta TSRMLS_CC) : 0;
1493: }
1494: /* }}} */
1495:
1496:
1497: /* {{{ mysqlnd_res::fetch_into */
1498: static void
1499: MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * result, unsigned int flags,
1500: zval *return_value,
1501: enum_mysqlnd_extension extension TSRMLS_DC ZEND_FILE_LINE_DC)
1502: {
1503: zend_bool fetched_anything;
1504:
1505: DBG_ENTER("mysqlnd_res::fetch_into");
1506:
1507: if (!result->m.fetch_row) {
1508: RETVAL_NULL();
1509: DBG_VOID_RETURN;
1510: }
1511: /*
1512: Hint Zend how many elements we will have in the hash. Thus it won't
1513: extend and rehash the hash constantly.
1514: */
1515: mysqlnd_array_init(return_value, mysqlnd_num_fields(result) * 2);
1516: if (FAIL == result->m.fetch_row(result, (void *)return_value, flags, &fetched_anything TSRMLS_CC)) {
1517: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading a row");
1518: zval_dtor(return_value);
1519: RETVAL_FALSE;
1520: } else if (fetched_anything == FALSE) {
1521: zval_dtor(return_value);
1522: switch (extension) {
1523: case MYSQLND_MYSQLI:
1524: RETVAL_NULL();
1525: break;
1526: case MYSQLND_MYSQL:
1527: RETVAL_FALSE;
1528: break;
1529: default:exit(0);
1530: }
1531: }
1532: /*
1533: return_value is IS_NULL for no more data and an array for data. Thus it's ok
1534: to return here.
1535: */
1536: DBG_VOID_RETURN;
1537: }
1538: /* }}} */
1539:
1540:
1541: /* {{{ mysqlnd_res::fetch_row_c */
1542: static MYSQLND_ROW_C
1543: MYSQLND_METHOD(mysqlnd_res, fetch_row_c)(MYSQLND_RES * result TSRMLS_DC)
1544: {
1545: MYSQLND_ROW_C ret = NULL;
1546: DBG_ENTER("mysqlnd_res::fetch_row_c");
1547:
1548: if (result->m.fetch_row) {
1549: if (result->m.fetch_row == result->m.fetch_row_normal_buffered) {
1550: DBG_RETURN(mysqlnd_fetch_row_buffered_c(result TSRMLS_CC));
1551: } else if (result->m.fetch_row == result->m.fetch_row_normal_unbuffered) {
1552: DBG_RETURN(mysqlnd_fetch_row_unbuffered_c(result TSRMLS_CC));
1553: } else {
1554: php_error_docref(NULL TSRMLS_CC, E_ERROR, "result->m.fetch_row has invalid value. Report to the developers");
1555: }
1556: }
1557: DBG_RETURN(ret);
1558: }
1559: /* }}} */
1560:
1561:
1562: /* {{{ mysqlnd_res::fetch_all */
1563: static void
1564: MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * result, unsigned int flags, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
1565: {
1566: zval *row;
1567: ulong i = 0;
1568: MYSQLND_RES_BUFFERED *set = result->stored_data;
1569:
1570: DBG_ENTER("mysqlnd_res::fetch_all");
1571:
1572: if ((!result->unbuf && !set)) {
1573: php_error_docref(NULL TSRMLS_CC, E_WARNING, "fetch_all can be used only with buffered sets");
1574: if (result->conn) {
1575: SET_CLIENT_ERROR(*result->conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "fetch_all can be used only with buffered sets");
1576: }
1577: RETVAL_NULL();
1578: DBG_VOID_RETURN;
1579: }
1580:
1581: /* 4 is a magic value. The cast is safe, if larger then the array will be later extended - no big deal :) */
1582: mysqlnd_array_init(return_value, set? (unsigned int) set->row_count : 4);
1583:
1584: do {
1585: MAKE_STD_ZVAL(row);
1586: mysqlnd_fetch_into(result, flags, row, MYSQLND_MYSQLI);
1587: if (Z_TYPE_P(row) != IS_ARRAY) {
1588: zval_ptr_dtor(&row);
1589: break;
1590: }
1591: add_index_zval(return_value, i++, row);
1592: } while (1);
1593:
1594: DBG_VOID_RETURN;
1595: }
1596: /* }}} */
1597:
1598:
1599: /* {{{ mysqlnd_res::fetch_field_data */
1600: static void
1601: MYSQLND_METHOD(mysqlnd_res, fetch_field_data)(MYSQLND_RES * result, unsigned int offset, zval *return_value TSRMLS_DC)
1602: {
1603: zval row;
1604: zval **entry;
1605: unsigned int i = 0;
1606:
1607: DBG_ENTER("mysqlnd_res::fetch_field_data");
1608: DBG_INF_FMT("offset=%u", offset);
1609:
1610: if (!result->m.fetch_row) {
1611: RETVAL_NULL();
1612: DBG_VOID_RETURN;
1613: }
1614: /*
1615: Hint Zend how many elements we will have in the hash. Thus it won't
1616: extend and rehash the hash constantly.
1617: */
1618: INIT_PZVAL(&row);
1619: mysqlnd_fetch_into(result, MYSQLND_FETCH_NUM, &row, MYSQLND_MYSQL);
1620: if (Z_TYPE(row) != IS_ARRAY) {
1621: zval_dtor(&row);
1622: RETVAL_NULL();
1623: DBG_VOID_RETURN;
1624: }
1625: zend_hash_internal_pointer_reset(Z_ARRVAL(row));
1626: while (i++ < offset) {
1627: zend_hash_move_forward(Z_ARRVAL(row));
1628: zend_hash_get_current_data(Z_ARRVAL(row), (void **)&entry);
1629: }
1630:
1631: zend_hash_get_current_data(Z_ARRVAL(row), (void **)&entry);
1632:
1633: *return_value = **entry;
1634: zval_copy_ctor(return_value);
1635: Z_SET_REFCOUNT_P(return_value, 1);
1636: zval_dtor(&row);
1637:
1638: DBG_VOID_RETURN;
1639: }
1640: /* }}} */
1641:
1642:
1643: MYSQLND_CLASS_METHODS_START(mysqlnd_res)
1644: NULL, /* fetch_row */
1645: mysqlnd_fetch_row_buffered,
1646: mysqlnd_fetch_row_unbuffered,
1647: MYSQLND_METHOD(mysqlnd_res, use_result),
1648: MYSQLND_METHOD(mysqlnd_res, store_result),
1649: MYSQLND_METHOD(mysqlnd_res, fetch_into),
1650: MYSQLND_METHOD(mysqlnd_res, fetch_row_c),
1651: MYSQLND_METHOD(mysqlnd_res, fetch_all),
1652: MYSQLND_METHOD(mysqlnd_res, fetch_field_data),
1653: MYSQLND_METHOD(mysqlnd_res, num_rows),
1654: MYSQLND_METHOD(mysqlnd_res, num_fields),
1655: MYSQLND_METHOD(mysqlnd_res, skip_result),
1656: MYSQLND_METHOD(mysqlnd_res, data_seek),
1657: MYSQLND_METHOD(mysqlnd_res, field_seek),
1658: MYSQLND_METHOD(mysqlnd_res, field_tell),
1659: MYSQLND_METHOD(mysqlnd_res, fetch_field),
1660: MYSQLND_METHOD(mysqlnd_res, fetch_field_direct),
1661: MYSQLND_METHOD(mysqlnd_res, fetch_fields),
1662: MYSQLND_METHOD(mysqlnd_res, read_result_metadata),
1663: NULL, /* fetch_lengths */
1664: MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data),
1665: MYSQLND_METHOD(mysqlnd_res, initialize_result_set_rest),
1666: MYSQLND_METHOD(mysqlnd_res, free_result_buffers),
1667: MYSQLND_METHOD(mysqlnd_res, free_result),
1668:
1669: mysqlnd_internal_free_result, /* free_result_internal */
1670: mysqlnd_internal_free_result_contents, /* free_result_contents */
1671: MYSQLND_METHOD(mysqlnd_res, free_buffered_data),
1672: MYSQLND_METHOD(mysqlnd_res, unbuffered_free_last_data),
1673:
1674: NULL /* row_decoder */,
1675: mysqlnd_result_meta_init
1676: MYSQLND_CLASS_METHODS_END;
1677:
1678:
1679: /* {{{ mysqlnd_result_init */
1680: PHPAPI MYSQLND_RES *
1681: mysqlnd_result_init(unsigned int field_count, zend_bool persistent TSRMLS_DC)
1682: {
1683: size_t alloc_size = sizeof(MYSQLND_RES) + mysqlnd_plugin_count() * sizeof(void *);
1684: MYSQLND_RES *ret = mnd_pecalloc(1, alloc_size, persistent);
1685:
1686: DBG_ENTER("mysqlnd_result_init");
1687:
1688: if (!ret) {
1689: DBG_RETURN(NULL);
1690: }
1691:
1692: ret->persistent = persistent;
1693: ret->field_count = field_count;
1694: ret->m = *mysqlnd_result_get_methods();
1695:
1696: DBG_RETURN(ret);
1697: }
1698: /* }}} */
1699:
1700:
1701: /*
1702: * Local variables:
1703: * tab-width: 4
1704: * c-basic-offset: 4
1705: * End:
1706: * vim600: noet sw=4 ts=4 fdm=marker
1707: * vim<600: noet sw=4 ts=4
1708: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mysqlnd_result.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