/* [<][>][^][v][top][bottom][index][help] */
/* 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.
*/
/* Overview of what this is and does:
* http://www.apache.org/~niq/dbd.html
*/
#ifndef APR_DBD_INTERNAL_H
#define APR_DBD_INTERNAL_H
#include <stdarg.h>
#include "apr_dbd.h"
#ifdef __cplusplus
extern "C" {
#endif
#define TXN_IGNORE_ERRORS(t) \
((t) && ((t)->mode & APR_DBD_TRANSACTION_IGNORE_ERRORS))
#define TXN_NOTICE_ERRORS(t) \
((t) && !((t)->mode & APR_DBD_TRANSACTION_IGNORE_ERRORS))
#define TXN_DO_COMMIT(t) (!((t)->mode & APR_DBD_TRANSACTION_ROLLBACK))
#define TXN_DO_ROLLBACK(t) ((t)->mode & APR_DBD_TRANSACTION_ROLLBACK)
#define TXN_MODE_BITS \
(APR_DBD_TRANSACTION_ROLLBACK|APR_DBD_TRANSACTION_IGNORE_ERRORS)
struct apr_dbd_driver_t {
/** name */
const char *name;
/** init: allow driver to perform once-only initialisation.
* Called once only. May be NULL
*/
void (*init)(apr_pool_t *pool);
/** native_handle: return the native database handle of the underlying db
*
* @param handle - apr_dbd handle
* @return - native handle
*/
void *(*native_handle)(apr_dbd_t *handle);
/** open: obtain a database connection from the server rec.
* Must be explicitly closed when you're finished with it.
* WARNING: only use this when you need a connection with
* a lifetime other than a request
*
* @param pool - a pool to use for error messages (if any).
* @param params - connection parameters.
* @param error - descriptive error.
* @return database handle, or NULL on error.
*/
apr_dbd_t *(*open)(apr_pool_t *pool, const char *params,
const char **error);
/** check_conn: check status of a database connection
*
* @param pool - a pool to use for error messages (if any).
* @param handle - the connection to check
* @return APR_SUCCESS or error
*/
apr_status_t (*check_conn)(apr_pool_t *pool, apr_dbd_t *handle);
/** close: close/release a connection obtained from open()
*
* @param handle - the connection to release
* @return APR_SUCCESS or error
*/
apr_status_t (*close)(apr_dbd_t *handle);
/** set_dbname: select database name. May be a no-op if not supported.
*
* @param pool - working pool
* @param handle - the connection
* @param name - the database to select
* @return 0 for success or error code
*/
int (*set_dbname)(apr_pool_t* pool, apr_dbd_t *handle, const char *name);
/** transaction: start a transaction. May be a no-op.
*
* @param pool - a pool to use for error messages (if any).
* @param handle - the connection
* @param trans - ptr to a transaction. May be null on entry
* @return 0 for success or error code
*/
int (*start_transaction)(apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_transaction_t **trans);
/** end_transaction: end a transaction
* (commit on success, rollback on error).
* May be a no-op.
*
* @param trans - the transaction.
* @return 0 for success or error code
*/
int (*end_transaction)(apr_dbd_transaction_t *trans);
/** query: execute an SQL query that doesn't return a result set
*
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the SQL statement to execute
* @return 0 for success or error code
*/
int (*query)(apr_dbd_t *handle, int *nrows, const char *statement);
/** select: execute an SQL query that returns a result set
*
* @param pool - pool to allocate the result set
* @param handle - the connection
* @param res - pointer to result set pointer. May point to NULL on entry
* @param statement - the SQL statement to execute
* @param random - 1 to support random access to results (seek any row);
* 0 to support only looping through results in order
* (async access - faster)
* @return 0 for success or error code
*/
int (*select)(apr_pool_t *pool, apr_dbd_t *handle, apr_dbd_results_t **res,
const char *statement, int random);
/** num_cols: get the number of columns in a results set
*
* @param res - result set.
* @return number of columns
*/
int (*num_cols)(apr_dbd_results_t *res);
/** num_tuples: get the number of rows in a results set
* of a synchronous select
*
* @param res - result set.
* @return number of rows, or -1 if the results are asynchronous
*/
int (*num_tuples)(apr_dbd_results_t *res);
/** get_row: get a row from a result set
*
* @param pool - pool to allocate the row
* @param res - result set pointer
* @param row - pointer to row pointer. May point to NULL on entry
* @param rownum - row number, or -1 for "next row". Ignored if random
* access is not supported.
* @return 0 for success, -1 for rownum out of range or data finished
*/
int (*get_row)(apr_pool_t *pool, apr_dbd_results_t *res,
apr_dbd_row_t **row, int rownum);
/** get_entry: get an entry from a row
*
* @param row - row pointer
* @param col - entry number
* @param val - entry to fill
* @return 0 for success, -1 for no data, +1 for general error
*/
const char* (*get_entry)(const apr_dbd_row_t *row, int col);
/** error: get current error message (if any)
*
* @param handle - the connection
* @param errnum - error code from operation that returned an error
* @return the database current error message, or message for errnum
* (implementation-dependent whether errnum is ignored)
*/
const char *(*error)(apr_dbd_t *handle, int errnum);
/** escape: escape a string so it is safe for use in query/select
*
* @param pool - pool to alloc the result from
* @param string - the string to escape
* @param handle - the connection
* @return the escaped, safe string
*/
const char *(*escape)(apr_pool_t *pool, const char *string,
apr_dbd_t *handle);
/** prepare: prepare a statement
*
* @param pool - pool to alloc the result from
* @param handle - the connection
* @param query - the SQL query
* @param label - A label for the prepared statement.
* use NULL for temporary prepared statements
* (eg within a Request in httpd)
* @param nargs - number of parameters in the query
* @param nvals - number of values passed in p[b]query/select
* @param types - pointer to an array with types of parameters
* @param statement - statement to prepare. May point to null on entry.
* @return 0 for success or error code
*/
int (*prepare)(apr_pool_t *pool, apr_dbd_t *handle, const char *query,
const char *label, int nargs, int nvals,
apr_dbd_type_e *types, apr_dbd_prepared_t **statement);
/** pvquery: query using a prepared statement + args
*
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param args - args to prepared statement
* @return 0 for success or error code
*/
int (*pvquery)(apr_pool_t *pool, apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, va_list args);
/** pvselect: select using a prepared statement + args
*
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param args - args to prepared statement
* @return 0 for success or error code
*/
int (*pvselect)(apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res,
apr_dbd_prepared_t *statement, int random, va_list args);
/** pquery: query using a prepared statement + args
*
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param args - args to prepared statement
* @return 0 for success or error code
*/
int (*pquery)(apr_pool_t *pool, apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, const char **args);
/** pselect: select using a prepared statement + args
*
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param args - args to prepared statement
* @return 0 for success or error code
*/
int (*pselect)(apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res, apr_dbd_prepared_t *statement,
int random, const char **args);
/** get_name: get a column title from a result set
*
* @param res - result set pointer
* @param col - entry number
* @return param name, or NULL if col is out of bounds.
*/
const char* (*get_name)(const apr_dbd_results_t *res, int col);
/** transaction_mode_get: get the mode of transaction
*
* @param trans - the transaction.
* @return mode of transaction
*/
int (*transaction_mode_get)(apr_dbd_transaction_t *trans);
/** transaction_mode_set: get the mode of transaction
*
* @param trans - the transaction.
* @param mode - new mode of the transaction
* @return the mode of transaction in force after the call
*/
int (*transaction_mode_set)(apr_dbd_transaction_t *trans, int mode);
/** format of prepared statement parameters */
const char *pformat;
/** pvbquery: query using a prepared statement + binary args
*
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param args - binary args to prepared statement
* @return 0 for success or error code
*/
int (*pvbquery)(apr_pool_t *pool, apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, va_list args);
/** pvbselect: select using a prepared statement + binary args
*
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param args - binary args to prepared statement
* @return 0 for success or error code
*/
int (*pvbselect)(apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res,
apr_dbd_prepared_t *statement, int random, va_list args);
/** pbquery: query using a prepared statement + binary args
*
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param args - binary args to prepared statement
* @return 0 for success or error code
*/
int (*pbquery)(apr_pool_t *pool, apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement,const void **args);
/** pbselect: select using a prepared statement + binary args
*
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param args - binary args to prepared statement
* @return 0 for success or error code
*/
int (*pbselect)(apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res, apr_dbd_prepared_t *statement,
int random, const void **args);
/** datum_get: get a binary entry from a row
*
* @param row - row pointer
* @param col - entry number
* @param type - type of data to get
* @param data - pointer to data, allocated by the caller
* @return APR_SUCCESS, an error code on error or if col is out of bounds
*/
apr_status_t (*datum_get)(const apr_dbd_row_t *row, int col,
apr_dbd_type_e type, void *data);
};
/* Export mutex lock/unlock for drivers that need it
* deprecated; create a per-dbd mutex within the (*init) function
* to avoid blocking other providers running on other threads
*/
APU_DECLARE(apr_status_t) apr_dbd_mutex_lock(void);
APU_DECLARE(apr_status_t) apr_dbd_mutex_unlock(void);
#ifdef __cplusplus
}
#endif
#endif