1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include "apu_version.h"
22 #include "apu_config.h"
27 #if defined(HAVE_MYSQL_MYSQL_H)
28 #if defined(HAVE_MYSQL_MY_GLOBAL_H)
29 #include <mysql/my_global.h>
30 #if defined(HAVE_MYSQL_MY_SYS_H)
31 #include <mysql/my_sys.h>
34 #include <mysql/mysql.h>
35 #include <mysql/errmsg.h>
36 #else /* !defined(HAVE_MYSQL_MYSQL_H) */
37 #if defined(HAVE_MY_GLOBAL_H)
38 #include <my_global.h>
39 #if defined(HAVE_MY_SYS_H)
47 #include "apr_strings.h"
49 #include "apr_buckets.h"
51 #include "apr_dbd_internal.h"
53 /* default maximum field size 1 MB */
54 #define FIELDSIZE 1048575
56 struct apr_dbd_prepared_t {
60 apr_dbd_type_e *types;
63 struct apr_dbd_transaction_t {
71 apr_dbd_transaction_t* trans ;
75 struct apr_dbd_results_t {
78 MYSQL_STMT *statement;
82 struct apr_dbd_row_t {
84 apr_dbd_results_t *res;
88 /* MySQL specific bucket for BLOB types */
89 typedef struct apr_bucket_lob apr_bucket_lob;
91 * A bucket referring to a MySQL BLOB
93 struct apr_bucket_lob {
94 /** Number of buckets using this memory */
95 apr_bucket_refcount refcount;
96 /** The row this bucket refers to */
97 const apr_dbd_row_t *row;
98 /** The column this bucket refers to */
100 /** The pool into which any needed structures should
101 * be created while reading from this bucket */
102 apr_pool_t *readpool;
105 static void lob_bucket_destroy(void *data);
106 static apr_status_t lob_bucket_read(apr_bucket *e, const char **str,
107 apr_size_t *len, apr_read_type_e block);
108 static apr_bucket *apr_bucket_lob_make(apr_bucket *b,
109 const apr_dbd_row_t *row, int col,
110 apr_off_t offset, apr_size_t len,
112 static apr_bucket *apr_bucket_lob_create(const apr_dbd_row_t *row, int col,
114 apr_size_t len, apr_pool_t *p,
115 apr_bucket_alloc_t *list);
116 static int dbd_mysql_num_cols(apr_dbd_results_t *res);
118 static const apr_bucket_type_t apr_bucket_type_lob = {
119 "LOB", 5, APR_BUCKET_DATA,
122 apr_bucket_setaside_notimpl,
123 apr_bucket_shared_split,
124 apr_bucket_shared_copy
127 static void lob_bucket_destroy(void *data)
129 apr_bucket_lob *f = data;
131 if (apr_bucket_shared_destroy(f)) {
132 /* no need to destroy database objects here; it will get
133 * done automatically when the pool gets cleaned up */
138 static apr_status_t lob_bucket_read(apr_bucket *e, const char **str,
139 apr_size_t *len, apr_read_type_e block)
141 apr_bucket_lob *a = e->data;
142 const apr_dbd_row_t *row = a->row;
143 apr_dbd_results_t *res = row->res;
145 apr_bucket *b = NULL;
147 apr_size_t blength = e->length; /* bytes remaining in file past offset */
148 apr_off_t boffset = e->start;
149 MYSQL_BIND *bind = &res->bind[col];
151 *str = NULL; /* in case we die prematurely */
153 /* fetch from offset if not at the beginning */
155 rv = mysql_stmt_fetch_column(res->statement, bind, col,
156 (unsigned long) boffset);
161 blength -= blength > bind->buffer_length ? bind->buffer_length : blength;
162 *len = e->length - blength;
165 /* allocate new buffer, since we used this one for the bucket */
166 bind->buffer = apr_palloc(res->pool, bind->buffer_length);
169 * Change the current bucket to refer to what we read,
170 * even if we read nothing because we hit EOF.
172 apr_bucket_pool_make(e, *str, *len, res->pool);
174 /* If we have more to read from the field, then create another bucket */
176 /* for efficiency, we can just build a new apr_bucket struct
177 * to wrap around the existing LOB bucket */
178 b = apr_bucket_alloc(sizeof(*b), e->list);
179 b->start = boffset + *len;
182 b->type = &apr_bucket_type_lob;
183 b->free = apr_bucket_free;
185 APR_BUCKET_INSERT_AFTER(e, b);
188 lob_bucket_destroy(a);
194 static apr_bucket *apr_bucket_lob_make(apr_bucket *b,
195 const apr_dbd_row_t *row, int col,
196 apr_off_t offset, apr_size_t len,
201 f = apr_bucket_alloc(sizeof(*f), b->list);
206 b = apr_bucket_shared_make(b, f, offset, len);
207 b->type = &apr_bucket_type_lob;
212 static apr_bucket *apr_bucket_lob_create(const apr_dbd_row_t *row, int col,
214 apr_size_t len, apr_pool_t *p,
215 apr_bucket_alloc_t *list)
217 apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
220 b->free = apr_bucket_free;
222 return apr_bucket_lob_make(b, row, col, offset, len, p);
225 static apr_status_t free_result(void *data)
227 mysql_free_result(data);
231 static int dbd_mysql_select(apr_pool_t *pool, apr_dbd_t *sql,
232 apr_dbd_results_t **results,
233 const char *query, int seek)
237 if (sql->trans && sql->trans->errnum) {
238 return sql->trans->errnum;
240 ret = mysql_query(sql->conn, query);
242 if (sz = mysql_field_count(sql->conn), sz > 0) {
244 *results = apr_palloc(pool, sizeof(apr_dbd_results_t));
246 (*results)->random = seek;
247 (*results)->statement = NULL;
248 (*results)->pool = pool;
250 (*results)->res = mysql_store_result(sql->conn);
253 (*results)->res = mysql_use_result(sql->conn);
255 apr_pool_cleanup_register(pool, (*results)->res,
256 free_result,apr_pool_cleanup_null);
259 ret = mysql_errno(sql->conn);
262 if (TXN_NOTICE_ERRORS(sql->trans)) {
263 sql->trans->errnum = ret;
268 static const char *dbd_mysql_get_name(const apr_dbd_results_t *res, int n)
270 if ((n < 0) || (n >= (int) mysql_num_fields(res->res))) {
274 return mysql_fetch_fields(res->res)[n].name;
277 static int dbd_mysql_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
278 apr_dbd_row_t **row, int rownum)
283 if (res->statement) {
286 mysql_stmt_data_seek(res->statement, (my_ulonglong) --rownum);
289 return -1; /* invalid row */
292 ret = mysql_stmt_fetch(res->statement);
295 ret = mysql_stmt_errno(res->statement);
301 ret = 0; /* bad luck - get_entry will deal with this */
308 mysql_data_seek(res->res, (my_ulonglong) --rownum);
311 return -1; /* invalid row */
314 r = mysql_fetch_row(res->res);
321 *row = apr_palloc(pool, sizeof(apr_dbd_row_t));
325 (*row)->len = mysql_fetch_lengths(res->res);
328 apr_pool_cleanup_run(res->pool, res->res, free_result);
333 /* An improved API that was proposed but not followed up */
334 static int dbd_mysql_get_entry(const apr_dbd_row_t *row, int n,
335 apr_dbd_datum_t *val)
338 if (dbd_mysql_num_cols(row->res) <= n) {
341 if (row->res->statement) {
342 bind = &row->res->bind[n];
343 if (mysql_stmt_fetch_column(row->res->statement, bind, n, 0) != 0) {
344 val->type = APR_DBD_VALUE_NULL;
347 if (*bind->is_null) {
348 val->type = APR_DBD_VALUE_NULL;
352 val->type = APR_DBD_VALUE_STRING;
353 val->value.stringval = bind->buffer;
357 val->type = APR_DBD_VALUE_STRING;
358 val->value.stringval = row->row[n];
364 static const char *dbd_mysql_get_entry(const apr_dbd_row_t *row, int n)
367 if (dbd_mysql_num_cols(row->res) <= n) {
370 if (row->res->statement) {
371 bind = &row->res->bind[n];
372 if (mysql_stmt_fetch_column(row->res->statement, bind, n, 0) != 0) {
375 if (*bind->is_null) {
389 static apr_status_t dbd_mysql_datum_get(const apr_dbd_row_t *row, int n,
390 apr_dbd_type_e type, void *data)
392 if (row->res->statement) {
393 MYSQL_BIND *bind = &row->res->bind[n];
394 unsigned long len = *bind->length;
396 if (mysql_stmt_fetch_column(row->res->statement, bind, n, 0) != 0) {
400 if (*bind->is_null) {
405 case APR_DBD_TYPE_TINY:
406 *(char*)data = atoi(bind->buffer);
408 case APR_DBD_TYPE_UTINY:
409 *(unsigned char*)data = atoi(bind->buffer);
411 case APR_DBD_TYPE_SHORT:
412 *(short*)data = atoi(bind->buffer);
414 case APR_DBD_TYPE_USHORT:
415 *(unsigned short*)data = atoi(bind->buffer);
417 case APR_DBD_TYPE_INT:
418 *(int*)data = atoi(bind->buffer);
420 case APR_DBD_TYPE_UINT:
421 *(unsigned int*)data = atoi(bind->buffer);
423 case APR_DBD_TYPE_LONG:
424 *(long*)data = atol(bind->buffer);
426 case APR_DBD_TYPE_ULONG:
427 *(unsigned long*)data = atol(bind->buffer);
429 case APR_DBD_TYPE_LONGLONG:
430 *(apr_int64_t*)data = apr_atoi64(bind->buffer);
432 case APR_DBD_TYPE_ULONGLONG:
433 *(apr_uint64_t*)data = apr_atoi64(bind->buffer);
435 case APR_DBD_TYPE_FLOAT:
436 *(float*)data = (float) atof(bind->buffer);
438 case APR_DBD_TYPE_DOUBLE:
439 *(double*)data = atof(bind->buffer);
441 case APR_DBD_TYPE_STRING:
442 case APR_DBD_TYPE_TEXT:
443 case APR_DBD_TYPE_TIME:
444 case APR_DBD_TYPE_DATE:
445 case APR_DBD_TYPE_DATETIME:
446 case APR_DBD_TYPE_TIMESTAMP:
447 case APR_DBD_TYPE_ZTIMESTAMP:
448 *((char*)bind->buffer+bind->buffer_length-1) = '\0';
449 *(char**)data = bind->buffer;
451 case APR_DBD_TYPE_BLOB:
452 case APR_DBD_TYPE_CLOB:
455 apr_bucket_brigade *b = (apr_bucket_brigade*)data;
457 e = apr_bucket_lob_create(row, n, 0, len,
458 row->res->pool, b->bucket_alloc);
459 APR_BRIGADE_INSERT_TAIL(b, e);
462 case APR_DBD_TYPE_NULL:
463 *(void**)data = NULL;
470 if (row->row[n] == NULL) {
475 case APR_DBD_TYPE_TINY:
476 *(char*)data = atoi(row->row[n]);
478 case APR_DBD_TYPE_UTINY:
479 *(unsigned char*)data = atoi(row->row[n]);
481 case APR_DBD_TYPE_SHORT:
482 *(short*)data = atoi(row->row[n]);
484 case APR_DBD_TYPE_USHORT:
485 *(unsigned short*)data = atoi(row->row[n]);
487 case APR_DBD_TYPE_INT:
488 *(int*)data = atoi(row->row[n]);
490 case APR_DBD_TYPE_UINT:
491 *(unsigned int*)data = atoi(row->row[n]);
493 case APR_DBD_TYPE_LONG:
494 *(long*)data = atol(row->row[n]);
496 case APR_DBD_TYPE_ULONG:
497 *(unsigned long*)data = atol(row->row[n]);
499 case APR_DBD_TYPE_LONGLONG:
500 *(apr_int64_t*)data = apr_atoi64(row->row[n]);
502 case APR_DBD_TYPE_ULONGLONG:
503 *(apr_uint64_t*)data = apr_atoi64(row->row[n]);
505 case APR_DBD_TYPE_FLOAT:
506 *(float*)data = (float) atof(row->row[n]);
508 case APR_DBD_TYPE_DOUBLE:
509 *(double*)data = atof(row->row[n]);
511 case APR_DBD_TYPE_STRING:
512 case APR_DBD_TYPE_TEXT:
513 case APR_DBD_TYPE_TIME:
514 case APR_DBD_TYPE_DATE:
515 case APR_DBD_TYPE_DATETIME:
516 case APR_DBD_TYPE_TIMESTAMP:
517 case APR_DBD_TYPE_ZTIMESTAMP:
518 *(char**)data = row->row[n];
520 case APR_DBD_TYPE_BLOB:
521 case APR_DBD_TYPE_CLOB:
524 apr_bucket_brigade *b = (apr_bucket_brigade*)data;
526 e = apr_bucket_pool_create(row->row[n], row->len[n],
527 row->res->pool, b->bucket_alloc);
528 APR_BRIGADE_INSERT_TAIL(b, e);
531 case APR_DBD_TYPE_NULL:
532 *(void**)data = NULL;
541 static const char *dbd_mysql_error(apr_dbd_t *sql, int n)
543 return mysql_error(sql->conn);
546 static int dbd_mysql_query(apr_dbd_t *sql, int *nrows, const char *query)
549 if (sql->trans && sql->trans->errnum) {
550 return sql->trans->errnum;
552 ret = mysql_query(sql->conn, query);
554 ret = mysql_errno(sql->conn);
556 *nrows = (int) mysql_affected_rows(sql->conn);
557 if (TXN_NOTICE_ERRORS(sql->trans)) {
558 sql->trans->errnum = ret;
563 static const char *dbd_mysql_escape(apr_pool_t *pool, const char *arg,
566 unsigned long len = strlen(arg);
567 char *ret = apr_palloc(pool, 2*len + 1);
568 mysql_real_escape_string(sql->conn, ret, arg, len);
572 static apr_status_t stmt_close(void *data)
574 mysql_stmt_close(data);
578 static int dbd_mysql_prepare(apr_pool_t *pool, apr_dbd_t *sql,
579 const char *query, const char *label,
580 int nargs, int nvals, apr_dbd_type_e *types,
581 apr_dbd_prepared_t **statement)
583 /* Translate from apr_dbd to native query format */
587 *statement = apr_palloc(pool, sizeof(apr_dbd_prepared_t));
589 (*statement)->stmt = mysql_stmt_init(sql->conn);
591 if ((*statement)->stmt) {
592 apr_pool_cleanup_register(pool, (*statement)->stmt,
593 stmt_close, apr_pool_cleanup_null);
594 ret = mysql_stmt_prepare((*statement)->stmt, query, strlen(query));
597 ret = mysql_stmt_errno((*statement)->stmt);
600 (*statement)->nargs = nargs;
601 (*statement)->nvals = nvals;
602 (*statement)->types = types;
607 return CR_OUT_OF_MEMORY;
610 static void dbd_mysql_bind(apr_dbd_prepared_t *statement,
611 const char **values, MYSQL_BIND *bind)
615 for (i = 0, j = 0; i < statement->nargs; i++, j++) {
616 bind[i].length = &bind[i].buffer_length;
617 bind[i].is_unsigned = 0;
618 bind[i].is_null = NULL;
620 if (values[j] == NULL) {
621 bind[i].buffer_type = MYSQL_TYPE_NULL;
624 switch (statement->types[i]) {
625 case APR_DBD_TYPE_BLOB:
626 case APR_DBD_TYPE_CLOB:
627 bind[i].buffer_type = MYSQL_TYPE_LONG_BLOB;
628 bind[i].buffer = (void*)values[j];
629 bind[i].buffer_length = atol(values[++j]);
631 /* skip table and column */
635 bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
636 bind[i].buffer = (void*)values[j];
637 bind[i].buffer_length = strlen(values[j]);
646 static int dbd_mysql_pquery_internal(apr_pool_t *pool, apr_dbd_t *sql,
647 int *nrows, apr_dbd_prepared_t *statement,
652 ret = mysql_stmt_bind_param(statement->stmt, bind);
655 ret = mysql_stmt_errno(statement->stmt);
658 ret = mysql_stmt_execute(statement->stmt);
660 ret = mysql_stmt_errno(statement->stmt);
662 *nrows = (int) mysql_stmt_affected_rows(statement->stmt);
668 static int dbd_mysql_pquery(apr_pool_t *pool, apr_dbd_t *sql,
669 int *nrows, apr_dbd_prepared_t *statement,
675 if (sql->trans && sql->trans->errnum) {
676 return sql->trans->errnum;
679 bind = apr_palloc(pool, statement->nargs * sizeof(MYSQL_BIND));
681 dbd_mysql_bind(statement, values, bind);
683 ret = dbd_mysql_pquery_internal(pool, sql, nrows, statement, bind);
685 if (TXN_NOTICE_ERRORS(sql->trans)) {
686 sql->trans->errnum = ret;
691 static int dbd_mysql_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
692 apr_dbd_prepared_t *statement, va_list args)
697 if (sql->trans && sql->trans->errnum) {
698 return sql->trans->errnum;
701 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
703 for (i = 0; i < statement->nvals; i++) {
704 values[i] = va_arg(args, const char*);
707 return dbd_mysql_pquery(pool, sql, nrows, statement, values);
710 static int dbd_mysql_pselect_internal(apr_pool_t *pool, apr_dbd_t *sql,
711 apr_dbd_results_t **res,
712 apr_dbd_prepared_t *statement,
713 int random, MYSQL_BIND *bind)
717 #if MYSQL_VERSION_ID >= 50000
721 unsigned long *length, maxlen;
723 ret = mysql_stmt_bind_param(statement->stmt, bind);
725 ret = mysql_stmt_execute(statement->stmt);
728 *res = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
730 (*res)->random = random;
731 (*res)->statement = statement->stmt;
732 (*res)->res = mysql_stmt_result_metadata(statement->stmt);
734 apr_pool_cleanup_register(pool, (*res)->res,
735 free_result, apr_pool_cleanup_null);
736 nfields = mysql_num_fields((*res)->res);
738 (*res)->bind = apr_palloc(pool, nfields*sizeof(MYSQL_BIND));
739 length = apr_pcalloc(pool, nfields*sizeof(unsigned long));
740 #if MYSQL_VERSION_ID >= 50000
741 error = apr_palloc(pool, nfields*sizeof(my_bool));
743 is_nullr = apr_pcalloc(pool, nfields*sizeof(my_bool));
744 for ( i = 0; i < nfields; ++i ) {
745 maxlen = ((*res)->res->fields[i].length < sql->fldsz ?
746 (*res)->res->fields[i].length : sql->fldsz) + 1;
747 if ((*res)->res->fields[i].type == MYSQL_TYPE_BLOB) {
748 (*res)->bind[i].buffer_type = MYSQL_TYPE_LONG_BLOB;
751 (*res)->bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
753 (*res)->bind[i].buffer_length = maxlen;
754 (*res)->bind[i].length = &length[i];
755 (*res)->bind[i].buffer = apr_palloc(pool, maxlen);
756 (*res)->bind[i].is_null = is_nullr+i;
757 #if MYSQL_VERSION_ID >= 50000
758 (*res)->bind[i].error = error+i;
762 ret = mysql_stmt_bind_result(statement->stmt, (*res)->bind);
764 ret = mysql_stmt_store_result(statement->stmt);
769 ret = mysql_stmt_errno(statement->stmt);
775 static int dbd_mysql_pselect(apr_pool_t *pool, apr_dbd_t *sql,
776 apr_dbd_results_t **res,
777 apr_dbd_prepared_t *statement, int random,
783 if (sql->trans && sql->trans->errnum) {
784 return sql->trans->errnum;
787 bind = apr_palloc(pool, statement->nargs * sizeof(MYSQL_BIND));
789 dbd_mysql_bind(statement, args, bind);
791 ret = dbd_mysql_pselect_internal(pool, sql, res, statement, random, bind);
793 if (TXN_NOTICE_ERRORS(sql->trans)) {
794 sql->trans->errnum = ret;
799 static int dbd_mysql_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
800 apr_dbd_results_t **res,
801 apr_dbd_prepared_t *statement, int random,
807 if (sql->trans && sql->trans->errnum) {
808 return sql->trans->errnum;
811 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
813 for (i = 0; i < statement->nvals; i++) {
814 values[i] = va_arg(args, const char*);
817 return dbd_mysql_pselect(pool, sql, res, statement, random, values);
820 static void dbd_mysql_bbind(apr_pool_t *pool, apr_dbd_prepared_t *statement,
821 const void **values, MYSQL_BIND *bind)
827 for (i = 0, j = 0; i < statement->nargs; i++, j++) {
828 arg = (void *)values[j];
830 bind[i].length = &bind[i].buffer_length;
831 bind[i].is_null = NULL;
833 type = (arg == NULL ? APR_DBD_TYPE_NULL : statement->types[i]);
835 case APR_DBD_TYPE_TINY:
836 bind[i].buffer = arg;
837 bind[i].buffer_type = MYSQL_TYPE_TINY;
838 bind[i].is_unsigned = 0;
840 case APR_DBD_TYPE_UTINY:
841 bind[i].buffer = arg;
842 bind[i].buffer_type = MYSQL_TYPE_TINY;
843 bind[i].is_unsigned = 1;
845 case APR_DBD_TYPE_SHORT:
846 bind[i].buffer = arg;
847 bind[i].buffer_type = MYSQL_TYPE_SHORT;
848 bind[i].is_unsigned = 0;
850 case APR_DBD_TYPE_USHORT:
851 bind[i].buffer = arg;
852 bind[i].buffer_type = MYSQL_TYPE_SHORT;
853 bind[i].is_unsigned = 1;
855 case APR_DBD_TYPE_INT:
856 bind[i].buffer = arg;
857 bind[i].buffer_type = MYSQL_TYPE_LONG;
858 bind[i].is_unsigned = 0;
860 case APR_DBD_TYPE_UINT:
861 bind[i].buffer = arg;
862 bind[i].buffer_type = MYSQL_TYPE_LONG;
863 bind[i].is_unsigned = 1;
865 case APR_DBD_TYPE_LONG:
866 if (sizeof(int) == sizeof(long)) {
867 bind[i].buffer = arg;
870 bind[i].buffer = apr_palloc(pool, sizeof(int));
871 *(int*)bind[i].buffer = *(long*)arg;
873 bind[i].buffer_type = MYSQL_TYPE_LONG;
874 bind[i].is_unsigned = 0;
876 case APR_DBD_TYPE_ULONG:
877 if (sizeof(unsigned int) == sizeof(unsigned long)) {
878 bind[i].buffer = arg;
881 bind[i].buffer = apr_palloc(pool, sizeof(unsigned int));
882 *(unsigned int*)bind[i].buffer = *(unsigned long*)arg;
884 bind[i].buffer_type = MYSQL_TYPE_LONG;
885 bind[i].is_unsigned = 1;
887 case APR_DBD_TYPE_LONGLONG:
888 if (sizeof(my_ulonglong) == sizeof(apr_int64_t)) {
889 bind[i].buffer = arg;
890 bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
892 else { /* have to downsize, long long is not portable */
893 bind[i].buffer = apr_palloc(pool, sizeof(long));
894 *(long*)bind[i].buffer = (long) *(apr_int64_t*)arg;
895 bind[i].buffer_type = MYSQL_TYPE_LONG;
897 bind[i].is_unsigned = 0;
899 case APR_DBD_TYPE_ULONGLONG:
900 if (sizeof(my_ulonglong) == sizeof(apr_uint64_t)) {
901 bind[i].buffer = arg;
902 bind[i].buffer_type = MYSQL_TYPE_LONGLONG;
904 else { /* have to downsize, long long is not portable */
905 bind[i].buffer = apr_palloc(pool, sizeof(long));
906 *(unsigned long*)bind[i].buffer =
907 (unsigned long) *(apr_uint64_t*)arg;
908 bind[i].buffer_type = MYSQL_TYPE_LONG;
910 bind[i].is_unsigned = 1;
912 case APR_DBD_TYPE_FLOAT:
913 bind[i].buffer = arg;
914 bind[i].buffer_type = MYSQL_TYPE_FLOAT;
915 bind[i].is_unsigned = 0;
917 case APR_DBD_TYPE_DOUBLE:
918 bind[i].buffer = arg;
919 bind[i].buffer_type = MYSQL_TYPE_DOUBLE;
920 bind[i].is_unsigned = 0;
922 case APR_DBD_TYPE_STRING:
923 case APR_DBD_TYPE_TEXT:
924 case APR_DBD_TYPE_TIME:
925 case APR_DBD_TYPE_DATE:
926 case APR_DBD_TYPE_DATETIME:
927 case APR_DBD_TYPE_TIMESTAMP:
928 case APR_DBD_TYPE_ZTIMESTAMP:
929 bind[i].buffer = arg;
930 bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
931 bind[i].is_unsigned = 0;
932 bind[i].buffer_length = strlen((const char *)arg);
934 case APR_DBD_TYPE_BLOB:
935 case APR_DBD_TYPE_CLOB:
936 bind[i].buffer = (void *)arg;
937 bind[i].buffer_type = MYSQL_TYPE_LONG_BLOB;
938 bind[i].is_unsigned = 0;
939 bind[i].buffer_length = *(apr_size_t*)values[++j];
941 /* skip table and column */
944 case APR_DBD_TYPE_NULL:
946 bind[i].buffer_type = MYSQL_TYPE_NULL;
954 static int dbd_mysql_pbquery(apr_pool_t *pool, apr_dbd_t *sql,
955 int *nrows, apr_dbd_prepared_t *statement,
961 if (sql->trans && sql->trans->errnum) {
962 return sql->trans->errnum;
965 bind = apr_palloc(pool, statement->nargs * sizeof(MYSQL_BIND));
967 dbd_mysql_bbind(pool, statement, values, bind);
969 ret = dbd_mysql_pquery_internal(pool, sql, nrows, statement, bind);
971 if (TXN_NOTICE_ERRORS(sql->trans)) {
972 sql->trans->errnum = ret;
977 static int dbd_mysql_pvbquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
978 apr_dbd_prepared_t *statement, va_list args)
983 if (sql->trans && sql->trans->errnum) {
984 return sql->trans->errnum;
987 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
989 for (i = 0; i < statement->nvals; i++) {
990 values[i] = va_arg(args, const void*);
993 return dbd_mysql_pbquery(pool, sql, nrows, statement, values);
996 static int dbd_mysql_pbselect(apr_pool_t *pool, apr_dbd_t *sql,
997 apr_dbd_results_t **res,
998 apr_dbd_prepared_t *statement, int random,
1004 if (sql->trans && sql->trans->errnum) {
1005 return sql->trans->errnum;
1008 bind = apr_palloc(pool, statement->nargs * sizeof(MYSQL_BIND));
1010 dbd_mysql_bbind(pool, statement, args, bind);
1012 ret = dbd_mysql_pselect_internal(pool, sql, res, statement, random, bind);
1014 if (TXN_NOTICE_ERRORS(sql->trans)) {
1015 sql->trans->errnum = ret;
1020 static int dbd_mysql_pvbselect(apr_pool_t *pool, apr_dbd_t *sql,
1021 apr_dbd_results_t **res,
1022 apr_dbd_prepared_t *statement, int random,
1025 const void **values;
1028 if (sql->trans && sql->trans->errnum) {
1029 return sql->trans->errnum;
1032 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
1034 for (i = 0; i < statement->nvals; i++) {
1035 values[i] = va_arg(args, const void*);
1038 return dbd_mysql_pbselect(pool, sql, res, statement, random, values);
1041 static int dbd_mysql_end_transaction(apr_dbd_transaction_t *trans)
1045 /* rollback on error or explicit rollback request */
1046 if (trans->errnum || TXN_DO_ROLLBACK(trans)) {
1048 ret = mysql_rollback(trans->handle->conn);
1051 ret = mysql_commit(trans->handle->conn);
1054 ret |= mysql_autocommit(trans->handle->conn, 1);
1055 trans->handle->trans = NULL;
1058 /* Whether or not transactions work depends on whether the
1059 * underlying DB supports them within MySQL. Unfortunately
1060 * it fails silently with the default InnoDB.
1063 static int dbd_mysql_transaction(apr_pool_t *pool, apr_dbd_t *handle,
1064 apr_dbd_transaction_t **trans)
1066 /* Don't try recursive transactions here */
1067 if (handle->trans) {
1068 dbd_mysql_end_transaction(handle->trans) ;
1071 *trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
1073 (*trans)->errnum = mysql_autocommit(handle->conn, 0);
1074 (*trans)->handle = handle;
1075 handle->trans = *trans;
1076 return (*trans)->errnum;
1079 static int dbd_mysql_transaction_mode_get(apr_dbd_transaction_t *trans)
1082 return APR_DBD_TRANSACTION_COMMIT;
1087 static int dbd_mysql_transaction_mode_set(apr_dbd_transaction_t *trans,
1091 return APR_DBD_TRANSACTION_COMMIT;
1093 return trans->mode = (mode & TXN_MODE_BITS);
1096 static apr_dbd_t *dbd_mysql_open(apr_pool_t *pool, const char *params,
1099 static const char *const delims = " \r\n\t;|,";
1106 #if MYSQL_VERSION_ID >= 50013
1107 my_bool do_reconnect = 1;
1110 unsigned long flags = 0;
1125 {"reconnect", NULL},
1128 unsigned int port = 0;
1129 apr_dbd_t *sql = apr_pcalloc(pool, sizeof(apr_dbd_t));
1130 sql->fldsz = FIELDSIZE;
1131 sql->conn = mysql_init(sql->conn);
1132 if ( sql->conn == NULL ) {
1135 for (ptr = strchr(params, '='); ptr; ptr = strchr(ptr, '=')) {
1136 /* don't dereference memory that may not belong to us */
1137 if (ptr == params) {
1141 for (key = ptr-1; apr_isspace(*key); --key);
1143 while (apr_isalpha(*key)) {
1144 /* don't parse backwards off the start of the string */
1145 if (key == params) {
1154 for (value = ptr+1; apr_isspace(*value); ++value);
1155 vlen = strcspn(value, delims);
1156 for (i = 0; fields[i].field != NULL; i++) {
1157 if (!strncasecmp(fields[i].field, key, klen)) {
1158 fields[i].value = apr_pstrndup(pool, value, vlen);
1164 if (fields[4].value != NULL) {
1165 port = atoi(fields[4].value);
1167 if (fields[6].value != NULL &&
1168 !strcmp(fields[6].value, "CLIENT_FOUND_ROWS")) {
1169 flags |= CLIENT_FOUND_ROWS; /* only option we know */
1171 if (fields[7].value != NULL) {
1172 sql->fldsz = atol(fields[7].value);
1174 if (fields[8].value != NULL) {
1175 mysql_options(sql->conn, MYSQL_READ_DEFAULT_GROUP, fields[8].value);
1177 #if MYSQL_VERSION_ID >= 50013
1178 if (fields[9].value != NULL) {
1179 do_reconnect = atoi(fields[9].value) ? 1 : 0;
1183 #if MYSQL_VERSION_ID >= 50013
1184 /* the MySQL manual says this should be BEFORE mysql_real_connect */
1185 mysql_options(sql->conn, MYSQL_OPT_RECONNECT, &do_reconnect);
1188 real_conn = mysql_real_connect(sql->conn, fields[0].value,
1189 fields[1].value, fields[2].value,
1190 fields[3].value, port,
1191 fields[5].value, flags);
1193 if(real_conn == NULL) {
1195 *error = apr_pstrdup(pool, mysql_error(sql->conn));
1197 mysql_close(sql->conn);
1201 #if MYSQL_VERSION_ID >= 50013
1202 /* Some say this should be AFTER mysql_real_connect */
1203 mysql_options(sql->conn, MYSQL_OPT_RECONNECT, &do_reconnect);
1209 static apr_status_t dbd_mysql_close(apr_dbd_t *handle)
1211 mysql_close(handle->conn);
1215 static apr_status_t dbd_mysql_check_conn(apr_pool_t *pool,
1218 return mysql_ping(handle->conn) ? APR_EGENERAL : APR_SUCCESS;
1221 static int dbd_mysql_select_db(apr_pool_t *pool, apr_dbd_t* handle,
1224 return mysql_select_db(handle->conn, name);
1227 static void *dbd_mysql_native(apr_dbd_t *handle)
1229 return handle->conn;
1232 static int dbd_mysql_num_cols(apr_dbd_results_t *res)
1234 if (res->statement) {
1235 return mysql_stmt_field_count(res->statement);
1238 return mysql_num_fields(res->res);
1242 static int dbd_mysql_num_tuples(apr_dbd_results_t *res)
1245 if (res->statement) {
1246 return (int) mysql_stmt_num_rows(res->statement);
1249 return (int) mysql_num_rows(res->res);
1257 static apr_status_t thread_end(void *data)
1263 static void dbd_mysql_init(apr_pool_t *pool)
1266 mysql_thread_init();
1268 /* FIXME: this is a guess; find out what it really does */
1269 apr_pool_cleanup_register(pool, NULL, thread_end, apr_pool_cleanup_null);
1271 APU_MODULE_DECLARE_DATA const apr_dbd_driver_t apr_dbd_mysql_driver = {
1276 dbd_mysql_check_conn,
1278 dbd_mysql_select_db,
1279 dbd_mysql_transaction,
1280 dbd_mysql_end_transaction,
1284 dbd_mysql_num_tuples,
1286 dbd_mysql_get_entry,
1295 dbd_mysql_transaction_mode_get,
1296 dbd_mysql_transaction_mode_set,
1299 dbd_mysql_pvbselect,