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