766 lines
21 KiB
C
766 lines
21 KiB
C
/* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "apu.h"
|
|
#define HAVE_MYSQL_MYSQL_H
|
|
|
|
#if APU_HAVE_MYSQL
|
|
|
|
#include "apu_version.h"
|
|
#include "apu_config.h"
|
|
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef HAVE_MYSQL_H
|
|
#include <mysql.h>
|
|
#include <errmsg.h>
|
|
#elif defined(HAVE_MYSQL_MYSQL_H)
|
|
#include <mysql/mysql.h>
|
|
#include <mysql/errmsg.h>
|
|
#endif
|
|
|
|
#include "apr_strings.h"
|
|
#include "apr_buckets.h"
|
|
|
|
#include "apr_dbd_internal.h"
|
|
|
|
/* default maximum field size 1 MB */
|
|
#define FIELDSIZE 1048575
|
|
|
|
struct apr_dbd_prepared_t {
|
|
MYSQL_STMT* stmt;
|
|
};
|
|
|
|
struct apr_dbd_transaction_t {
|
|
int errnum;
|
|
apr_dbd_t *handle;
|
|
};
|
|
|
|
struct apr_dbd_t {
|
|
MYSQL* conn ;
|
|
apr_dbd_transaction_t* trans ;
|
|
unsigned long fldsz;
|
|
};
|
|
|
|
struct apr_dbd_results_t {
|
|
int random;
|
|
MYSQL_RES *res;
|
|
MYSQL_STMT *statement;
|
|
MYSQL_BIND *bind;
|
|
};
|
|
struct apr_dbd_row_t {
|
|
MYSQL_ROW row;
|
|
apr_dbd_results_t *res;
|
|
};
|
|
|
|
static apr_status_t free_result(void *data)
|
|
{
|
|
mysql_free_result(data);
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
static int dbd_mysql_select(apr_pool_t *pool, apr_dbd_t *sql,
|
|
apr_dbd_results_t **results,
|
|
const char *query, int seek)
|
|
{
|
|
int sz;
|
|
int ret;
|
|
if (sql->trans && sql->trans->errnum) {
|
|
return sql->trans->errnum;
|
|
}
|
|
ret = mysql_query(sql->conn, query);
|
|
if (!ret) {
|
|
if (sz = mysql_field_count(sql->conn), sz > 0) {
|
|
if (!*results) {
|
|
*results = apr_palloc(pool, sizeof(apr_dbd_results_t));
|
|
}
|
|
(*results)->random = seek;
|
|
(*results)->statement = NULL;
|
|
if (seek) {
|
|
(*results)->res = mysql_store_result(sql->conn);
|
|
}
|
|
else {
|
|
(*results)->res = mysql_use_result(sql->conn);
|
|
}
|
|
apr_pool_cleanup_register(pool, (*results)->res,
|
|
free_result,apr_pool_cleanup_null);
|
|
}
|
|
} else {
|
|
ret = mysql_errno(sql->conn);
|
|
}
|
|
|
|
if (sql->trans) {
|
|
sql->trans->errnum = ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int dbd_mysql_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
|
|
apr_dbd_row_t **row, int rownum)
|
|
{
|
|
MYSQL_ROW r = NULL;
|
|
int ret = 0;
|
|
|
|
if (res->statement) {
|
|
if (res->random) {
|
|
if (rownum >= 0) {
|
|
mysql_stmt_data_seek(res->statement, (my_ulonglong)rownum);
|
|
}
|
|
}
|
|
ret = mysql_stmt_fetch(res->statement);
|
|
switch (ret) {
|
|
case 1:
|
|
ret = mysql_stmt_errno(res->statement);
|
|
break;
|
|
case MYSQL_NO_DATA:
|
|
ret = -1;
|
|
break;
|
|
default:
|
|
ret = 0; /* bad luck - get_entry will deal with this */
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
if (res->random) {
|
|
if (rownum >= 0) {
|
|
mysql_data_seek(res->res, (my_ulonglong) rownum);
|
|
}
|
|
}
|
|
r = mysql_fetch_row(res->res);
|
|
if (r == NULL) {
|
|
ret = -1;
|
|
}
|
|
}
|
|
if (ret == 0) {
|
|
if (!*row) {
|
|
*row = apr_palloc(pool, sizeof(apr_dbd_row_t));
|
|
}
|
|
(*row)->row = r;
|
|
(*row)->res = res;
|
|
}
|
|
else {
|
|
apr_pool_cleanup_run(pool, res->res, free_result);
|
|
}
|
|
return ret;
|
|
}
|
|
#if 0
|
|
/* An improved API that was proposed but not followed up */
|
|
static int dbd_mysql_get_entry(const apr_dbd_row_t *row, int n,
|
|
apr_dbd_datum_t *val)
|
|
{
|
|
MYSQL_BIND *bind;
|
|
if (row->res->statement) {
|
|
bind = &row->res->bind[n];
|
|
if (mysql_stmt_fetch_column(row->res->statement, bind, n, 0) != 0) {
|
|
val->type = APR_DBD_VALUE_NULL;
|
|
return -1;
|
|
}
|
|
if (*bind->is_null) {
|
|
val->type = APR_DBD_VALUE_NULL;
|
|
return -1;
|
|
}
|
|
else {
|
|
val->type = APR_DBD_VALUE_STRING;
|
|
val->value.stringval = bind->buffer;
|
|
}
|
|
}
|
|
else {
|
|
val->type = APR_DBD_VALUE_STRING;
|
|
val->value.stringval = row->row[n];
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
|
|
static const char *dbd_mysql_get_entry(const apr_dbd_row_t *row, int n)
|
|
{
|
|
MYSQL_BIND *bind;
|
|
if (row->res->statement) {
|
|
bind = &row->res->bind[n];
|
|
if (mysql_stmt_fetch_column(row->res->statement, bind, n, 0) != 0) {
|
|
return NULL;
|
|
}
|
|
if (*bind->is_null) {
|
|
return NULL;
|
|
}
|
|
else {
|
|
return bind->buffer;
|
|
}
|
|
}
|
|
else {
|
|
return row->row[n];
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static const char *dbd_mysql_error(apr_dbd_t *sql, int n)
|
|
{
|
|
return mysql_error(sql->conn);
|
|
}
|
|
|
|
static int dbd_mysql_query(apr_dbd_t *sql, int *nrows, const char *query)
|
|
{
|
|
int ret;
|
|
if (sql->trans && sql->trans->errnum) {
|
|
return sql->trans->errnum;
|
|
}
|
|
ret = mysql_query(sql->conn, query);
|
|
if (ret != 0) {
|
|
ret = mysql_errno(sql->conn);
|
|
}
|
|
*nrows = mysql_affected_rows(sql->conn);
|
|
if (sql->trans) {
|
|
sql->trans->errnum = ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const char *dbd_mysql_escape(apr_pool_t *pool, const char *arg,
|
|
apr_dbd_t *sql)
|
|
{
|
|
unsigned long len = strlen(arg);
|
|
char *ret = apr_palloc(pool, 2*len + 1);
|
|
mysql_real_escape_string(sql->conn, ret, arg, len);
|
|
return ret;
|
|
}
|
|
|
|
static apr_status_t stmt_close(void *data)
|
|
{
|
|
mysql_stmt_close(data);
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
static int dbd_mysql_prepare(apr_pool_t *pool, apr_dbd_t *sql,
|
|
const char *query, const char *label,
|
|
apr_dbd_prepared_t **statement)
|
|
{
|
|
/* Translate from apr_dbd to native query format */
|
|
char *myquery = apr_pstrdup(pool, query);
|
|
char *p = myquery;
|
|
const char *q;
|
|
int ret;
|
|
for (q = query; *q; ++q) {
|
|
if (q[0] == '%') {
|
|
if (isalpha(q[1])) {
|
|
*p++ = '?';
|
|
++q;
|
|
}
|
|
else if (q[1] == '%') {
|
|
/* reduce %% to % */
|
|
*p++ = *q++;
|
|
}
|
|
else {
|
|
*p++ = *q;
|
|
}
|
|
}
|
|
else {
|
|
*p++ = *q;
|
|
}
|
|
}
|
|
*p = 0;
|
|
if (!*statement) {
|
|
*statement = apr_palloc(pool, sizeof(apr_dbd_prepared_t));
|
|
}
|
|
(*statement)->stmt = mysql_stmt_init(sql->conn);
|
|
|
|
if ((*statement)->stmt) {
|
|
apr_pool_cleanup_register(pool, (*statement)->stmt,
|
|
stmt_close, apr_pool_cleanup_null);
|
|
ret = mysql_stmt_prepare((*statement)->stmt, myquery, strlen(myquery));
|
|
|
|
if (ret != 0) {
|
|
ret = mysql_stmt_errno((*statement)->stmt);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
return CR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
static int dbd_mysql_pquery(apr_pool_t *pool, apr_dbd_t *sql,
|
|
int *nrows, apr_dbd_prepared_t *statement,
|
|
int nargs, const char **values)
|
|
{
|
|
MYSQL_BIND *bind;
|
|
char *arg;
|
|
int ret;
|
|
int i;
|
|
my_bool is_null = FALSE;
|
|
|
|
if (sql->trans && sql->trans->errnum) {
|
|
return sql->trans->errnum;
|
|
}
|
|
nargs = mysql_stmt_param_count(statement->stmt);
|
|
|
|
bind = apr_palloc(pool, nargs*sizeof(MYSQL_BIND));
|
|
for (i=0; i < nargs; ++i) {
|
|
arg = (char*)values[i];
|
|
bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
|
|
bind[i].buffer = arg;
|
|
bind[i].buffer_length = strlen(arg);
|
|
bind[i].length = &bind[i].buffer_length;
|
|
bind[i].is_null = &is_null;
|
|
bind[i].is_unsigned = 0;
|
|
}
|
|
|
|
ret = mysql_stmt_bind_param(statement->stmt, bind);
|
|
if (ret != 0) {
|
|
*nrows = 0;
|
|
ret = mysql_stmt_errno(statement->stmt);
|
|
}
|
|
else {
|
|
ret = mysql_stmt_execute(statement->stmt);
|
|
if (ret != 0) {
|
|
ret = mysql_stmt_errno(statement->stmt);
|
|
}
|
|
*nrows = mysql_stmt_affected_rows(statement->stmt);
|
|
}
|
|
if (sql->trans) {
|
|
sql->trans->errnum = ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int dbd_mysql_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
|
|
apr_dbd_prepared_t *statement, va_list args)
|
|
{
|
|
MYSQL_BIND *bind;
|
|
char *arg;
|
|
int ret;
|
|
int nargs = 0;
|
|
int i;
|
|
my_bool is_null = FALSE;
|
|
|
|
if (sql->trans && sql->trans->errnum) {
|
|
return sql->trans->errnum;
|
|
}
|
|
nargs = mysql_stmt_param_count(statement->stmt);
|
|
|
|
bind = apr_palloc(pool, nargs*sizeof(MYSQL_BIND));
|
|
for (i=0; i < nargs; ++i) {
|
|
arg = va_arg(args, char*);
|
|
bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
|
|
bind[i].buffer = arg;
|
|
bind[i].buffer_length = strlen(arg);
|
|
bind[i].length = &bind[i].buffer_length;
|
|
bind[i].is_null = &is_null;
|
|
bind[i].is_unsigned = 0;
|
|
}
|
|
|
|
ret = mysql_stmt_bind_param(statement->stmt, bind);
|
|
if (ret != 0) {
|
|
*nrows = 0;
|
|
ret = mysql_stmt_errno(statement->stmt);
|
|
}
|
|
else {
|
|
ret = mysql_stmt_execute(statement->stmt);
|
|
if (ret != 0) {
|
|
ret = mysql_stmt_errno(statement->stmt);
|
|
}
|
|
*nrows = mysql_stmt_affected_rows(statement->stmt);
|
|
}
|
|
if (sql->trans) {
|
|
sql->trans->errnum = ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int dbd_mysql_pselect(apr_pool_t *pool, apr_dbd_t *sql,
|
|
apr_dbd_results_t **res,
|
|
apr_dbd_prepared_t *statement, int random,
|
|
int nargs, const char **args)
|
|
{
|
|
int i;
|
|
int nfields;
|
|
char *arg;
|
|
my_bool is_null = FALSE;
|
|
my_bool *is_nullr;
|
|
#if MYSQL_VERSION_ID >= 50000
|
|
my_bool *error;
|
|
#endif
|
|
int ret;
|
|
unsigned long *length, maxlen;
|
|
MYSQL_BIND *bind;
|
|
|
|
if (sql->trans && sql->trans->errnum) {
|
|
return sql->trans->errnum;
|
|
}
|
|
|
|
nargs = mysql_stmt_param_count(statement->stmt);
|
|
bind = apr_palloc(pool, nargs*sizeof(MYSQL_BIND));
|
|
|
|
for (i=0; i < nargs; ++i) {
|
|
arg = (char*)args[i];
|
|
bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
|
|
bind[i].buffer = arg;
|
|
bind[i].buffer_length = strlen(arg);
|
|
bind[i].length = &bind[i].buffer_length;
|
|
bind[i].is_null = &is_null;
|
|
bind[i].is_unsigned = 0;
|
|
}
|
|
|
|
ret = mysql_stmt_bind_param(statement->stmt, bind);
|
|
if (ret == 0) {
|
|
ret = mysql_stmt_execute(statement->stmt);
|
|
if (!ret) {
|
|
if (!*res) {
|
|
*res = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
|
|
}
|
|
(*res)->random = random;
|
|
(*res)->statement = statement->stmt;
|
|
(*res)->res = mysql_stmt_result_metadata(statement->stmt);
|
|
apr_pool_cleanup_register(pool, (*res)->res,
|
|
free_result, apr_pool_cleanup_null);
|
|
nfields = mysql_num_fields((*res)->res);
|
|
if (!(*res)->bind) {
|
|
(*res)->bind = apr_palloc(pool, nfields*sizeof(MYSQL_BIND));
|
|
length = apr_pcalloc(pool, nfields*sizeof(unsigned long));
|
|
#if MYSQL_VERSION_ID >= 50000
|
|
error = apr_palloc(pool, nfields*sizeof(my_bool));
|
|
#endif
|
|
is_nullr = apr_pcalloc(pool, nfields*sizeof(my_bool));
|
|
for ( i = 0; i < nfields; ++i ) {
|
|
maxlen = ((*res)->res->fields[i].length < sql->fldsz ?
|
|
(*res)->res->fields[i].length : sql->fldsz) + 1;
|
|
(*res)->bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
|
|
(*res)->bind[i].buffer_length = maxlen;
|
|
(*res)->bind[i].length = &length[i];
|
|
(*res)->bind[i].buffer = apr_palloc(pool, maxlen);
|
|
(*res)->bind[i].is_null = is_nullr+i;
|
|
#if MYSQL_VERSION_ID >= 50000
|
|
(*res)->bind[i].error = error+i;
|
|
#endif
|
|
}
|
|
}
|
|
ret = mysql_stmt_bind_result(statement->stmt, (*res)->bind);
|
|
if (!ret) {
|
|
ret = mysql_stmt_store_result(statement->stmt);
|
|
}
|
|
}
|
|
}
|
|
if (ret != 0) {
|
|
ret = mysql_stmt_errno(statement->stmt);
|
|
}
|
|
if (sql->trans) {
|
|
sql->trans->errnum = ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int dbd_mysql_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
|
|
apr_dbd_results_t **res,
|
|
apr_dbd_prepared_t *statement, int random,
|
|
va_list args)
|
|
{
|
|
int i;
|
|
int nfields;
|
|
char *arg;
|
|
my_bool is_null = FALSE;
|
|
my_bool *is_nullr;
|
|
#if MYSQL_VERSION_ID >= 50000
|
|
my_bool *error;
|
|
#endif
|
|
int ret;
|
|
unsigned long *length, maxlen;
|
|
int nargs;
|
|
MYSQL_BIND *bind;
|
|
|
|
if (sql->trans && sql->trans->errnum) {
|
|
return sql->trans->errnum;
|
|
}
|
|
|
|
nargs = mysql_stmt_param_count(statement->stmt);
|
|
bind = apr_palloc(pool, nargs*sizeof(MYSQL_BIND));
|
|
|
|
for (i=0; i < nargs; ++i) {
|
|
arg = va_arg(args, char*);
|
|
bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
|
|
bind[i].buffer = arg;
|
|
bind[i].buffer_length = strlen(arg);
|
|
bind[i].length = &bind[i].buffer_length;
|
|
bind[i].is_null = &is_null;
|
|
bind[i].is_unsigned = 0;
|
|
}
|
|
|
|
ret = mysql_stmt_bind_param(statement->stmt, bind);
|
|
if (ret == 0) {
|
|
ret = mysql_stmt_execute(statement->stmt);
|
|
if (!ret) {
|
|
if (!*res) {
|
|
*res = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
|
|
}
|
|
(*res)->random = random;
|
|
(*res)->statement = statement->stmt;
|
|
(*res)->res = mysql_stmt_result_metadata(statement->stmt);
|
|
apr_pool_cleanup_register(pool, (*res)->res,
|
|
free_result, apr_pool_cleanup_null);
|
|
nfields = mysql_num_fields((*res)->res);
|
|
if (!(*res)->bind) {
|
|
(*res)->bind = apr_palloc(pool, nfields*sizeof(MYSQL_BIND));
|
|
length = apr_pcalloc(pool, nfields*sizeof(unsigned long));
|
|
#if MYSQL_VERSION_ID >= 50000
|
|
error = apr_palloc(pool, nfields*sizeof(my_bool));
|
|
#endif
|
|
is_nullr = apr_pcalloc(pool, nfields*sizeof(my_bool));
|
|
for ( i = 0; i < nfields; ++i ) {
|
|
maxlen = ((*res)->res->fields[i].length < sql->fldsz ?
|
|
(*res)->res->fields[i].length : sql->fldsz) + 1;
|
|
(*res)->bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
|
|
(*res)->bind[i].buffer_length = maxlen;
|
|
(*res)->bind[i].length = &length[i];
|
|
(*res)->bind[i].buffer = apr_palloc(pool, maxlen);
|
|
(*res)->bind[i].is_null = is_nullr+i;
|
|
#if MYSQL_VERSION_ID >= 50000
|
|
(*res)->bind[i].error = error+i;
|
|
#endif
|
|
}
|
|
}
|
|
ret = mysql_stmt_bind_result(statement->stmt, (*res)->bind);
|
|
if (!ret) {
|
|
ret = mysql_stmt_store_result(statement->stmt);
|
|
}
|
|
}
|
|
}
|
|
if (ret != 0) {
|
|
ret = mysql_stmt_errno(statement->stmt);
|
|
}
|
|
if (sql->trans) {
|
|
sql->trans->errnum = ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int dbd_mysql_end_transaction(apr_dbd_transaction_t *trans)
|
|
{
|
|
int ret = -1;
|
|
if (trans) {
|
|
if (trans->errnum) {
|
|
trans->errnum = 0;
|
|
ret = mysql_rollback(trans->handle->conn);
|
|
}
|
|
else {
|
|
ret = mysql_commit(trans->handle->conn);
|
|
}
|
|
}
|
|
ret |= mysql_autocommit(trans->handle->conn, 1);
|
|
trans->handle->trans = NULL;
|
|
return ret;
|
|
}
|
|
/* Whether or not transactions work depends on whether the
|
|
* underlying DB supports them within MySQL. Unfortunately
|
|
* it fails silently with the default InnoDB.
|
|
*/
|
|
|
|
static int dbd_mysql_transaction(apr_pool_t *pool, apr_dbd_t *handle,
|
|
apr_dbd_transaction_t **trans)
|
|
{
|
|
/* Don't try recursive transactions here */
|
|
if (handle->trans) {
|
|
dbd_mysql_end_transaction(handle->trans) ;
|
|
}
|
|
if (!*trans) {
|
|
*trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
|
|
}
|
|
(*trans)->errnum = mysql_autocommit(handle->conn, 0);
|
|
(*trans)->handle = handle;
|
|
handle->trans = *trans;
|
|
return (*trans)->errnum;
|
|
}
|
|
|
|
static apr_dbd_t *dbd_mysql_open(apr_pool_t *pool, const char *params)
|
|
{
|
|
static const char *const delims = " \r\n\t;|,";
|
|
const char *ptr;
|
|
int i;
|
|
const char *key;
|
|
size_t klen;
|
|
const char *value;
|
|
size_t vlen;
|
|
#if MYSQL_VERSION_ID >= 50013
|
|
my_bool do_reconnect = 1;
|
|
#endif
|
|
MYSQL *real_conn;
|
|
unsigned long flags = 0;
|
|
|
|
struct {
|
|
const char *field;
|
|
const char *value;
|
|
} fields[] = {
|
|
{"host", NULL},
|
|
{"user", NULL},
|
|
{"pass", NULL},
|
|
{"dbname", NULL},
|
|
{"port", NULL},
|
|
{"sock", NULL},
|
|
{"flags", NULL},
|
|
{"fldsz", NULL},
|
|
{NULL, NULL}
|
|
};
|
|
unsigned int port = 0;
|
|
apr_dbd_t *sql = apr_pcalloc(pool, sizeof(apr_dbd_t));
|
|
sql->fldsz = FIELDSIZE;
|
|
sql->conn = mysql_init(sql->conn);
|
|
if ( sql->conn == NULL ) {
|
|
return NULL;
|
|
}
|
|
for (ptr = strchr(params, '='); ptr; ptr = strchr(ptr, '=')) {
|
|
for (key = ptr-1; isspace(*key); --key);
|
|
klen = 0;
|
|
while (isalpha(*key)) {
|
|
/* don't parse backwards off the start of the string */
|
|
if (key == params) {
|
|
--key;
|
|
++klen;
|
|
break;
|
|
}
|
|
--key;
|
|
++klen;
|
|
}
|
|
++key;
|
|
for (value = ptr+1; isspace(*value); ++value);
|
|
vlen = strcspn(value, delims);
|
|
for (i = 0; fields[i].field != NULL; i++) {
|
|
if (!strncasecmp(fields[i].field, key, klen)) {
|
|
fields[i].value = apr_pstrndup(pool, value, vlen);
|
|
break;
|
|
}
|
|
}
|
|
ptr = value+vlen;
|
|
}
|
|
if (fields[4].value != NULL) {
|
|
port = atoi(fields[4].value);
|
|
}
|
|
if (fields[6].value != NULL &&
|
|
!strcmp(fields[6].value, "CLIENT_FOUND_ROWS")) {
|
|
flags |= CLIENT_FOUND_ROWS; /* only option we know */
|
|
}
|
|
if (fields[7].value != NULL) {
|
|
sql->fldsz = atol(fields[7].value);
|
|
}
|
|
|
|
#if MYSQL_VERSION_ID >= 50013
|
|
/* the MySQL manual says this should be BEFORE mysql_real_connect */
|
|
mysql_options(sql->conn, MYSQL_OPT_RECONNECT, &do_reconnect);
|
|
#endif
|
|
|
|
real_conn = mysql_real_connect(sql->conn, fields[0].value,
|
|
fields[1].value, fields[2].value,
|
|
fields[3].value, port,
|
|
fields[5].value, flags);
|
|
|
|
if(real_conn == NULL) {
|
|
mysql_close(sql->conn);
|
|
return NULL;
|
|
}
|
|
|
|
#if MYSQL_VERSION_ID >= 50013
|
|
/* Some say this should be AFTER mysql_real_connect */
|
|
mysql_options(sql->conn, MYSQL_OPT_RECONNECT, &do_reconnect);
|
|
#endif
|
|
|
|
return sql;
|
|
}
|
|
|
|
static apr_status_t dbd_mysql_close(apr_dbd_t *handle)
|
|
{
|
|
mysql_close(handle->conn);
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
static apr_status_t dbd_mysql_check_conn(apr_pool_t *pool,
|
|
apr_dbd_t *handle)
|
|
{
|
|
return mysql_ping(handle->conn) ? APR_EGENERAL : APR_SUCCESS;
|
|
}
|
|
|
|
static int dbd_mysql_select_db(apr_pool_t *pool, apr_dbd_t* handle,
|
|
const char* name)
|
|
{
|
|
return mysql_select_db(handle->conn, name);
|
|
}
|
|
|
|
static void *dbd_mysql_native(apr_dbd_t *handle)
|
|
{
|
|
return handle->conn;
|
|
}
|
|
|
|
static int dbd_mysql_num_cols(apr_dbd_results_t *res)
|
|
{
|
|
if (res->statement) {
|
|
return mysql_stmt_field_count(res->statement);
|
|
}
|
|
else {
|
|
return mysql_num_fields(res->res);
|
|
}
|
|
}
|
|
|
|
static int dbd_mysql_num_tuples(apr_dbd_results_t *res)
|
|
{
|
|
if (res->random) {
|
|
if (res->statement) {
|
|
return (int) mysql_stmt_num_rows(res->statement);
|
|
}
|
|
else {
|
|
return (int) mysql_num_rows(res->res);
|
|
}
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static apr_status_t thread_end(void *data)
|
|
{
|
|
mysql_thread_end();
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
static void dbd_mysql_init(apr_pool_t *pool)
|
|
{
|
|
my_init();
|
|
/* FIXME: this is a guess; find out what it really does */
|
|
apr_pool_cleanup_register(pool, NULL, thread_end, apr_pool_cleanup_null);
|
|
}
|
|
APU_DECLARE_DATA const apr_dbd_driver_t apr_dbd_mysql_driver = {
|
|
"mysql",
|
|
dbd_mysql_init,
|
|
dbd_mysql_native,
|
|
dbd_mysql_open,
|
|
dbd_mysql_check_conn,
|
|
dbd_mysql_close,
|
|
dbd_mysql_select_db,
|
|
dbd_mysql_transaction,
|
|
dbd_mysql_end_transaction,
|
|
dbd_mysql_query,
|
|
dbd_mysql_select,
|
|
dbd_mysql_num_cols,
|
|
dbd_mysql_num_tuples,
|
|
dbd_mysql_get_row,
|
|
dbd_mysql_get_entry,
|
|
dbd_mysql_error,
|
|
dbd_mysql_escape,
|
|
dbd_mysql_prepare,
|
|
dbd_mysql_pvquery,
|
|
dbd_mysql_pvselect,
|
|
dbd_mysql_pquery,
|
|
dbd_mysql_pselect
|
|
};
|
|
|
|
#endif
|