| /* 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 |
