/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- dbd_sqlite3_select_internal
- dbd_sqlite3_select
- dbd_sqlite3_get_name
- dbd_sqlite3_get_row
- dbd_sqlite3_get_entry
- dbd_sqlite3_datum_get
- dbd_sqlite3_error
- dbd_sqlite3_query_internal
- dbd_sqlite3_query
- free_mem
- dbd_sqlite3_escape
- dbd_sqlite3_prepare
- dbd_sqlite3_bind
- dbd_sqlite3_pquery
- dbd_sqlite3_pvquery
- dbd_sqlite3_pselect
- dbd_sqlite3_pvselect
- dbd_sqlite3_bbind
- dbd_sqlite3_pbquery
- dbd_sqlite3_pvbquery
- dbd_sqlite3_pbselect
- dbd_sqlite3_pvbselect
- dbd_sqlite3_start_transaction
- dbd_sqlite3_end_transaction
- dbd_sqlite3_transaction_mode_get
- dbd_sqlite3_transaction_mode_set
- dbd_sqlite3_open
- dbd_sqlite3_close
- dbd_sqlite3_check_conn
- dbd_sqlite3_select_db
- dbd_sqlite3_native
- dbd_sqlite3_num_cols
- dbd_sqlite3_num_tuples
/* 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"
#if APU_HAVE_SQLITE3
#include <ctype.h>
#include <stdlib.h>
#include <sqlite3.h>
#include "apr_strings.h"
#include "apr_time.h"
#include "apr_buckets.h"
#include "apr_dbd_internal.h"
#define MAX_RETRY_COUNT 15
#define MAX_RETRY_SLEEP 100000
struct apr_dbd_transaction_t {
int mode;
int errnum;
apr_dbd_t *handle;
};
struct apr_dbd_t {
sqlite3 *conn;
apr_dbd_transaction_t *trans;
apr_pool_t *pool;
apr_dbd_prepared_t *prep;
};
typedef struct {
char *name;
char *value;
int size;
int type;
} apr_dbd_column_t;
struct apr_dbd_row_t {
apr_dbd_results_t *res;
apr_dbd_column_t **columns;
apr_dbd_row_t *next_row;
int columnCount;
int rownum;
};
struct apr_dbd_results_t {
int random;
sqlite3 *handle;
sqlite3_stmt *stmt;
apr_dbd_row_t *next_row;
size_t sz;
int tuples;
char **col_names;
apr_pool_t *pool;
};
struct apr_dbd_prepared_t {
sqlite3_stmt *stmt;
apr_dbd_prepared_t *next;
int nargs;
int nvals;
apr_dbd_type_e *types;
};
#define dbd_sqlite3_is_success(x) (((x) == SQLITE_DONE) || ((x) == SQLITE_OK))
static int dbd_sqlite3_select_internal(apr_pool_t *pool,
apr_dbd_t *sql,
apr_dbd_results_t **results,
sqlite3_stmt *stmt, int seek)
{
int i, ret, retry_count = 0, column_count;
size_t num_tuples = 0;
int increment = 0;
apr_dbd_row_t *row = NULL;
apr_dbd_row_t *lastrow = NULL;
apr_dbd_column_t *column;
char *hold = NULL;
column_count = sqlite3_column_count(stmt);
if (!*results) {
*results = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
}
(*results)->stmt = stmt;
(*results)->sz = column_count;
(*results)->random = seek;
(*results)->next_row = 0;
(*results)->tuples = 0;
(*results)->col_names = apr_pcalloc(pool, column_count * sizeof(char *));
(*results)->pool = pool;
do {
ret = sqlite3_step(stmt);
if (ret == SQLITE_BUSY) {
if (retry_count++ > MAX_RETRY_COUNT) {
ret = SQLITE_ERROR;
} else {
apr_dbd_mutex_unlock();
apr_sleep(MAX_RETRY_SLEEP);
apr_dbd_mutex_lock();
}
} else if (ret == SQLITE_ROW) {
int length;
apr_dbd_column_t *col;
row = apr_palloc(pool, sizeof(apr_dbd_row_t));
row->res = *results;
increment = sizeof(apr_dbd_column_t *);
length = increment * (*results)->sz;
row->columns = apr_palloc(pool, length);
row->columnCount = column_count;
for (i = 0; i < (*results)->sz; i++) {
column = apr_palloc(pool, sizeof(apr_dbd_column_t));
row->columns[i] = column;
/* copy column name once only */
if ((*results)->col_names[i] == NULL) {
(*results)->col_names[i] =
apr_pstrdup(pool, sqlite3_column_name(stmt, i));
}
column->name = (*results)->col_names[i];
column->size = sqlite3_column_bytes(stmt, i);
column->type = sqlite3_column_type(stmt, i);
column->value = NULL;
switch (column->type) {
case SQLITE_FLOAT:
case SQLITE_INTEGER:
case SQLITE_TEXT:
hold = (char *) sqlite3_column_text(stmt, i);
if (hold) {
column->value = apr_pstrmemdup(pool, hold,
column->size);
}
break;
case SQLITE_BLOB:
hold = (char *) sqlite3_column_blob(stmt, i);
if (hold) {
column->value = apr_pstrmemdup(pool, hold,
column->size);
}
break;
case SQLITE_NULL:
break;
}
col = row->columns[i];
}
row->rownum = num_tuples++;
row->next_row = 0;
(*results)->tuples = num_tuples;
if ((*results)->next_row == 0) {
(*results)->next_row = row;
}
if (lastrow != 0) {
lastrow->next_row = row;
}
lastrow = row;
}
} while (ret == SQLITE_ROW || ret == SQLITE_BUSY);
if (dbd_sqlite3_is_success(ret)) {
ret = 0;
}
return ret;
}
static int dbd_sqlite3_select(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results, const char *query,
int seek)
{
sqlite3_stmt *stmt = NULL;
const char *tail = NULL;
int ret;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
if (dbd_sqlite3_is_success(ret)) {
ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
}
sqlite3_finalize(stmt);
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static const char *dbd_sqlite3_get_name(const apr_dbd_results_t *res, int n)
{
if ((n < 0) || (n >= res->sz)) {
return NULL;
}
return res->col_names[n];
}
static int dbd_sqlite3_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
apr_dbd_row_t **rowp, int rownum)
{
int i = 0;
if (rownum == -1) {
*rowp = res->next_row;
if (*rowp == 0)
return -1;
res->next_row = (*rowp)->next_row;
return 0;
}
if (rownum > res->tuples) {
return -1;
}
rownum--;
*rowp = res->next_row;
for (; *rowp != 0; i++, *rowp = (*rowp)->next_row) {
if (i == rownum) {
return 0;
}
}
return -1;
}
static const char *dbd_sqlite3_get_entry(const apr_dbd_row_t *row, int n)
{
apr_dbd_column_t *column;
const char *value;
if ((n < 0) || (n >= row->columnCount)) {
return NULL;
}
column = row->columns[n];
value = column->value;
return value;
}
static apr_status_t dbd_sqlite3_datum_get(const apr_dbd_row_t *row, int n,
apr_dbd_type_e type, void *data)
{
if ((n < 0) || (n >= row->res->sz)) {
return APR_EGENERAL;
}
if (row->columns[n]->type == SQLITE_NULL) {
return APR_ENOENT;
}
switch (type) {
case APR_DBD_TYPE_TINY:
*(char*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_UTINY:
*(unsigned char*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_SHORT:
*(short*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_USHORT:
*(unsigned short*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_INT:
*(int*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_UINT:
*(unsigned int*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_LONG:
*(long*)data = atol(row->columns[n]->value);
break;
case APR_DBD_TYPE_ULONG:
*(unsigned long*)data = atol(row->columns[n]->value);
break;
case APR_DBD_TYPE_LONGLONG:
*(apr_int64_t*)data = apr_atoi64(row->columns[n]->value);
break;
case APR_DBD_TYPE_ULONGLONG:
*(apr_uint64_t*)data = apr_atoi64(row->columns[n]->value);
break;
case APR_DBD_TYPE_FLOAT:
*(float*)data = atof(row->columns[n]->value);
break;
case APR_DBD_TYPE_DOUBLE:
*(double*)data = atof(row->columns[n]->value);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
*(char**)data = row->columns[n]->value;
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
apr_bucket *e;
apr_bucket_brigade *b = (apr_bucket_brigade*)data;
e = apr_bucket_pool_create(row->columns[n]->value,
row->columns[n]->size,
row->res->pool, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
break;
case APR_DBD_TYPE_NULL:
*(void**)data = NULL;
break;
default:
return APR_EGENERAL;
}
return APR_SUCCESS;
}
static const char *dbd_sqlite3_error(apr_dbd_t *sql, int n)
{
return sqlite3_errmsg(sql->conn);
}
static int dbd_sqlite3_query_internal(apr_dbd_t *sql, sqlite3_stmt *stmt,
int *nrows)
{
int ret = -1, retry_count = 0;
while(retry_count++ <= MAX_RETRY_COUNT) {
ret = sqlite3_step(stmt);
if (ret != SQLITE_BUSY)
break;
apr_dbd_mutex_unlock();
apr_sleep(MAX_RETRY_SLEEP);
apr_dbd_mutex_lock();
}
*nrows = sqlite3_changes(sql->conn);
if (dbd_sqlite3_is_success(ret)) {
ret = 0;
}
return ret;
}
static int dbd_sqlite3_query(apr_dbd_t *sql, int *nrows, const char *query)
{
sqlite3_stmt *stmt = NULL;
const char *tail = NULL;
int ret = -1, length = 0;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
length = strlen(query);
apr_dbd_mutex_lock();
do {
ret = sqlite3_prepare(sql->conn, query, length, &stmt, &tail);
if (ret != SQLITE_OK) {
sqlite3_finalize(stmt);
break;
}
ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
sqlite3_finalize(stmt);
length -= (tail - query);
query = tail;
} while (length > 0);
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static apr_status_t free_mem(void *data)
{
sqlite3_free(data);
return APR_SUCCESS;
}
static const char *dbd_sqlite3_escape(apr_pool_t *pool, const char *arg,
apr_dbd_t *sql)
{
char *ret = sqlite3_mprintf("%q", arg);
apr_pool_cleanup_register(pool, ret, free_mem,
apr_pool_cleanup_null);
return ret;
}
static int dbd_sqlite3_prepare(apr_pool_t *pool, apr_dbd_t *sql,
const char *query, const char *label,
int nargs, int nvals, apr_dbd_type_e *types,
apr_dbd_prepared_t **statement)
{
sqlite3_stmt *stmt;
const char *tail = NULL;
int ret;
apr_dbd_mutex_lock();
ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
if (ret == SQLITE_OK) {
apr_dbd_prepared_t *prep;
prep = apr_pcalloc(sql->pool, sizeof(*prep));
prep->stmt = stmt;
prep->next = sql->prep;
prep->nargs = nargs;
prep->nvals = nvals;
prep->types = types;
/* link new statement to the handle */
sql->prep = prep;
*statement = prep;
} else {
sqlite3_finalize(stmt);
}
apr_dbd_mutex_unlock();
return ret;
}
static void dbd_sqlite3_bind(apr_dbd_prepared_t *statement, const char **values)
{
sqlite3_stmt *stmt = statement->stmt;
int i, j;
for (i = 0, j = 0; i < statement->nargs; i++, j++) {
if (values[j] == NULL) {
sqlite3_bind_null(stmt, i + 1);
}
else {
switch (statement->types[i]) {
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
char *data = (char *)values[j];
int size = atoi((char*)values[++j]);
/* skip table and column */
j += 2;
sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
}
break;
default:
sqlite3_bind_text(stmt, i + 1, values[j],
strlen(values[j]), SQLITE_STATIC);
break;
}
}
}
return;
}
static int dbd_sqlite3_pquery(apr_pool_t *pool, apr_dbd_t *sql,
int *nrows, apr_dbd_prepared_t *statement,
const char **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret = -1;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bind(statement, values);
ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t *statement, va_list args)
{
const char **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const char*);
}
return dbd_sqlite3_pquery(pool, sql, nrows, statement, values);
}
static int dbd_sqlite3_pselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement, int seek,
const char **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bind(statement, values);
ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement, int seek,
va_list args)
{
const char **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const char*);
}
return dbd_sqlite3_pselect(pool, sql, results, statement, seek, values);
}
static void dbd_sqlite3_bbind(apr_dbd_prepared_t * statement,
const void **values)
{
sqlite3_stmt *stmt = statement->stmt;
int i, j;
apr_dbd_type_e type;
for (i = 0, j = 0; i < statement->nargs; i++, j++) {
type = (values[j] == NULL ? APR_DBD_TYPE_NULL : statement->types[i]);
switch (type) {
case APR_DBD_TYPE_TINY:
sqlite3_bind_int(stmt, i + 1, *(char*)values[j]);
break;
case APR_DBD_TYPE_UTINY:
sqlite3_bind_int(stmt, i + 1, *(unsigned char*)values[j]);
break;
case APR_DBD_TYPE_SHORT:
sqlite3_bind_int(stmt, i + 1, *(short*)values[j]);
break;
case APR_DBD_TYPE_USHORT:
sqlite3_bind_int(stmt, i + 1, *(unsigned short*)values[j]);
break;
case APR_DBD_TYPE_INT:
sqlite3_bind_int(stmt, i + 1, *(int*)values[j]);
break;
case APR_DBD_TYPE_UINT:
sqlite3_bind_int(stmt, i + 1, *(unsigned int*)values[j]);
break;
case APR_DBD_TYPE_LONG:
sqlite3_bind_int64(stmt, i + 1, *(long*)values[j]);
break;
case APR_DBD_TYPE_ULONG:
sqlite3_bind_int64(stmt, i + 1, *(unsigned long*)values[j]);
break;
case APR_DBD_TYPE_LONGLONG:
sqlite3_bind_int64(stmt, i + 1, *(apr_int64_t*)values[j]);
break;
case APR_DBD_TYPE_ULONGLONG:
sqlite3_bind_int64(stmt, i + 1, *(apr_uint64_t*)values[j]);
break;
case APR_DBD_TYPE_FLOAT:
sqlite3_bind_double(stmt, i + 1, *(float*)values[j]);
break;
case APR_DBD_TYPE_DOUBLE:
sqlite3_bind_double(stmt, i + 1, *(double*)values[j]);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
sqlite3_bind_text(stmt, i + 1, values[j], strlen(values[j]),
SQLITE_STATIC);
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
char *data = (char*)values[j];
apr_size_t size = *(apr_size_t*)values[++j];
sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
/* skip table and column */
j += 2;
}
break;
case APR_DBD_TYPE_NULL:
default:
sqlite3_bind_null(stmt, i + 1);
break;
}
}
return;
}
static int dbd_sqlite3_pbquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
const void **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret = -1;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bbind(statement, values);
ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvbquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
va_list args)
{
const void **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const void*);
}
return dbd_sqlite3_pbquery(pool, sql, nrows, statement, values);
}
static int dbd_sqlite3_pbselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement,
int seek, const void **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bbind(statement, values);
ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvbselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement, int seek,
va_list args)
{
const void **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const void*);
}
return dbd_sqlite3_pbselect(pool, sql, results, statement, seek, values);
}
static int dbd_sqlite3_start_transaction(apr_pool_t *pool,
apr_dbd_t *handle,
apr_dbd_transaction_t **trans)
{
int ret = 0;
int nrows = 0;
ret = dbd_sqlite3_query(handle, &nrows, "BEGIN IMMEDIATE");
if (!*trans) {
*trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
(*trans)->handle = handle;
handle->trans = *trans;
}
return ret;
}
static int dbd_sqlite3_end_transaction(apr_dbd_transaction_t *trans)
{
int ret = -1; /* ending transaction that was never started is an error */
int nrows = 0;
if (trans) {
/* rollback on error or explicit rollback request */
if (trans->errnum || TXN_DO_ROLLBACK(trans)) {
trans->errnum = 0;
ret = dbd_sqlite3_query(trans->handle, &nrows, "ROLLBACK");
} else {
ret = dbd_sqlite3_query(trans->handle, &nrows, "COMMIT");
}
trans->handle->trans = NULL;
}
return ret;
}
static int dbd_sqlite3_transaction_mode_get(apr_dbd_transaction_t *trans)
{
if (!trans)
return APR_DBD_TRANSACTION_COMMIT;
return trans->mode;
}
static int dbd_sqlite3_transaction_mode_set(apr_dbd_transaction_t *trans,
int mode)
{
if (!trans)
return APR_DBD_TRANSACTION_COMMIT;
return trans->mode = (mode & TXN_MODE_BITS);
}
static apr_dbd_t *dbd_sqlite3_open(apr_pool_t *pool, const char *params,
const char **error)
{
apr_dbd_t *sql = NULL;
sqlite3 *conn = NULL;
int sqlres;
if (!params)
return NULL;
sqlres = sqlite3_open(params, &conn);
if (sqlres != SQLITE_OK) {
if (error) {
*error = apr_pstrdup(pool, sqlite3_errmsg(conn));
}
sqlite3_close(conn);
return NULL;
}
/* should we register rand or power functions to the sqlite VM? */
sql = apr_pcalloc(pool, sizeof(*sql));
sql->conn = conn;
sql->pool = pool;
sql->trans = NULL;
return sql;
}
static apr_status_t dbd_sqlite3_close(apr_dbd_t *handle)
{
apr_dbd_prepared_t *prep = handle->prep;
/* finalize all prepared statements, or we'll get SQLITE_BUSY on close */
while (prep) {
sqlite3_finalize(prep->stmt);
prep = prep->next;
}
sqlite3_close(handle->conn);
return APR_SUCCESS;
}
static apr_status_t dbd_sqlite3_check_conn(apr_pool_t *pool,
apr_dbd_t *handle)
{
return (handle->conn != NULL) ? APR_SUCCESS : APR_EGENERAL;
}
static int dbd_sqlite3_select_db(apr_pool_t *pool, apr_dbd_t *handle,
const char *name)
{
return APR_ENOTIMPL;
}
static void *dbd_sqlite3_native(apr_dbd_t *handle)
{
return handle->conn;
}
static int dbd_sqlite3_num_cols(apr_dbd_results_t *res)
{
return res->sz;
}
static int dbd_sqlite3_num_tuples(apr_dbd_results_t *res)
{
return res->tuples;
}
APU_MODULE_DECLARE_DATA const apr_dbd_driver_t apr_dbd_sqlite3_driver = {
"sqlite3",
NULL,
dbd_sqlite3_native,
dbd_sqlite3_open,
dbd_sqlite3_check_conn,
dbd_sqlite3_close,
dbd_sqlite3_select_db,
dbd_sqlite3_start_transaction,
dbd_sqlite3_end_transaction,
dbd_sqlite3_query,
dbd_sqlite3_select,
dbd_sqlite3_num_cols,
dbd_sqlite3_num_tuples,
dbd_sqlite3_get_row,
dbd_sqlite3_get_entry,
dbd_sqlite3_error,
dbd_sqlite3_escape,
dbd_sqlite3_prepare,
dbd_sqlite3_pvquery,
dbd_sqlite3_pvselect,
dbd_sqlite3_pquery,
dbd_sqlite3_pselect,
dbd_sqlite3_get_name,
dbd_sqlite3_transaction_mode_get,
dbd_sqlite3_transaction_mode_set,
"?",
dbd_sqlite3_pvbquery,
dbd_sqlite3_pvbselect,
dbd_sqlite3_pbquery,
dbd_sqlite3_pbselect,
dbd_sqlite3_datum_get
};
#endif