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.
26 #include "apr_strings.h"
28 #include "apr_buckets.h"
30 #include "apr_dbd_internal.h"
32 #define MAX_RETRY_COUNT 15
33 #define MAX_RETRY_SLEEP 100000
35 struct apr_dbd_transaction_t {
43 apr_dbd_transaction_t *trans;
45 apr_dbd_prepared_t *prep;
55 struct apr_dbd_row_t {
56 apr_dbd_results_t *res;
57 apr_dbd_column_t **columns;
58 apr_dbd_row_t *next_row;
63 struct apr_dbd_results_t {
67 apr_dbd_row_t *next_row;
74 struct apr_dbd_prepared_t {
76 apr_dbd_prepared_t *next;
79 apr_dbd_type_e *types;
82 #define dbd_sqlite3_is_success(x) (((x) == SQLITE_DONE) || ((x) == SQLITE_OK))
84 static int dbd_sqlite3_select_internal(apr_pool_t *pool,
86 apr_dbd_results_t **results,
87 sqlite3_stmt *stmt, int seek)
89 int ret, retry_count = 0, column_count;
90 size_t i, num_tuples = 0;
92 apr_dbd_row_t *row = NULL;
93 apr_dbd_row_t *lastrow = NULL;
94 apr_dbd_column_t *column;
97 column_count = sqlite3_column_count(stmt);
99 *results = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
101 (*results)->stmt = stmt;
102 (*results)->sz = column_count;
103 (*results)->random = seek;
104 (*results)->next_row = 0;
105 (*results)->tuples = 0;
106 (*results)->col_names = apr_pcalloc(pool, column_count * sizeof(char *));
107 (*results)->pool = pool;
109 ret = sqlite3_step(stmt);
110 if (ret == SQLITE_BUSY) {
111 if (retry_count++ > MAX_RETRY_COUNT) {
114 apr_dbd_mutex_unlock();
115 apr_sleep(MAX_RETRY_SLEEP);
116 apr_dbd_mutex_lock();
118 } else if (ret == SQLITE_ROW) {
120 row = apr_palloc(pool, sizeof(apr_dbd_row_t));
122 increment = sizeof(apr_dbd_column_t *);
123 length = increment * (*results)->sz;
124 row->columns = apr_palloc(pool, length);
125 row->columnCount = column_count;
126 for (i = 0; i < (*results)->sz; i++) {
127 column = apr_palloc(pool, sizeof(apr_dbd_column_t));
128 row->columns[i] = column;
129 /* copy column name once only */
130 if ((*results)->col_names[i] == NULL) {
131 (*results)->col_names[i] =
132 apr_pstrdup(pool, sqlite3_column_name(stmt, i));
134 column->name = (*results)->col_names[i];
135 column->size = sqlite3_column_bytes(stmt, i);
136 column->type = sqlite3_column_type(stmt, i);
137 column->value = NULL;
138 switch (column->type) {
142 hold = (char *) sqlite3_column_text(stmt, i);
144 column->value = apr_pstrmemdup(pool, hold,
149 hold = (char *) sqlite3_column_blob(stmt, i);
151 column->value = apr_pstrmemdup(pool, hold,
159 row->rownum = num_tuples++;
161 (*results)->tuples = num_tuples;
162 if ((*results)->next_row == 0) {
163 (*results)->next_row = row;
166 lastrow->next_row = row;
170 } while (ret == SQLITE_ROW || ret == SQLITE_BUSY);
172 if (dbd_sqlite3_is_success(ret)) {
178 static int dbd_sqlite3_select(apr_pool_t *pool, apr_dbd_t *sql,
179 apr_dbd_results_t **results, const char *query,
182 sqlite3_stmt *stmt = NULL;
183 const char *tail = NULL;
186 if (sql->trans && sql->trans->errnum) {
187 return sql->trans->errnum;
190 apr_dbd_mutex_lock();
192 ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
193 if (dbd_sqlite3_is_success(ret)) {
194 ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
196 sqlite3_finalize(stmt);
198 apr_dbd_mutex_unlock();
200 if (TXN_NOTICE_ERRORS(sql->trans)) {
201 sql->trans->errnum = ret;
206 static const char *dbd_sqlite3_get_name(const apr_dbd_results_t *res, int n)
208 if ((n < 0) || ((size_t)n >= res->sz)) {
212 return res->col_names[n];
215 static int dbd_sqlite3_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
216 apr_dbd_row_t **rowp, int rownum)
221 *rowp = res->next_row;
224 res->next_row = (*rowp)->next_row;
227 if (rownum > res->tuples) {
231 *rowp = res->next_row;
232 for (; *rowp != 0; i++, *rowp = (*rowp)->next_row) {
242 static const char *dbd_sqlite3_get_entry(const apr_dbd_row_t *row, int n)
244 apr_dbd_column_t *column;
246 if ((n < 0) || (n >= row->columnCount)) {
249 column = row->columns[n];
250 value = column->value;
254 static apr_status_t dbd_sqlite3_datum_get(const apr_dbd_row_t *row, int n,
255 apr_dbd_type_e type, void *data)
257 if ((n < 0) || ((size_t)n >= row->res->sz)) {
261 if (row->columns[n]->type == SQLITE_NULL) {
266 case APR_DBD_TYPE_TINY:
267 *(char*)data = atoi(row->columns[n]->value);
269 case APR_DBD_TYPE_UTINY:
270 *(unsigned char*)data = atoi(row->columns[n]->value);
272 case APR_DBD_TYPE_SHORT:
273 *(short*)data = atoi(row->columns[n]->value);
275 case APR_DBD_TYPE_USHORT:
276 *(unsigned short*)data = atoi(row->columns[n]->value);
278 case APR_DBD_TYPE_INT:
279 *(int*)data = atoi(row->columns[n]->value);
281 case APR_DBD_TYPE_UINT:
282 *(unsigned int*)data = atoi(row->columns[n]->value);
284 case APR_DBD_TYPE_LONG:
285 *(long*)data = atol(row->columns[n]->value);
287 case APR_DBD_TYPE_ULONG:
288 *(unsigned long*)data = atol(row->columns[n]->value);
290 case APR_DBD_TYPE_LONGLONG:
291 *(apr_int64_t*)data = apr_atoi64(row->columns[n]->value);
293 case APR_DBD_TYPE_ULONGLONG:
294 *(apr_uint64_t*)data = apr_atoi64(row->columns[n]->value);
296 case APR_DBD_TYPE_FLOAT:
297 *(float*)data = (float)atof(row->columns[n]->value);
299 case APR_DBD_TYPE_DOUBLE:
300 *(double*)data = atof(row->columns[n]->value);
302 case APR_DBD_TYPE_STRING:
303 case APR_DBD_TYPE_TEXT:
304 case APR_DBD_TYPE_TIME:
305 case APR_DBD_TYPE_DATE:
306 case APR_DBD_TYPE_DATETIME:
307 case APR_DBD_TYPE_TIMESTAMP:
308 case APR_DBD_TYPE_ZTIMESTAMP:
309 *(char**)data = row->columns[n]->value;
311 case APR_DBD_TYPE_BLOB:
312 case APR_DBD_TYPE_CLOB:
315 apr_bucket_brigade *b = (apr_bucket_brigade*)data;
317 e = apr_bucket_pool_create(row->columns[n]->value,
318 row->columns[n]->size,
319 row->res->pool, b->bucket_alloc);
320 APR_BRIGADE_INSERT_TAIL(b, e);
323 case APR_DBD_TYPE_NULL:
324 *(void**)data = NULL;
333 static const char *dbd_sqlite3_error(apr_dbd_t *sql, int n)
335 return sqlite3_errmsg(sql->conn);
338 static int dbd_sqlite3_query_internal(apr_dbd_t *sql, sqlite3_stmt *stmt,
341 int ret = -1, retry_count = 0;
343 while(retry_count++ <= MAX_RETRY_COUNT) {
344 ret = sqlite3_step(stmt);
345 if (ret != SQLITE_BUSY)
348 apr_dbd_mutex_unlock();
349 apr_sleep(MAX_RETRY_SLEEP);
350 apr_dbd_mutex_lock();
353 *nrows = sqlite3_changes(sql->conn);
355 if (dbd_sqlite3_is_success(ret)) {
361 static int dbd_sqlite3_query(apr_dbd_t *sql, int *nrows, const char *query)
363 sqlite3_stmt *stmt = NULL;
364 const char *tail = NULL;
365 int ret = -1, length = 0;
367 if (sql->trans && sql->trans->errnum) {
368 return sql->trans->errnum;
371 length = strlen(query);
372 apr_dbd_mutex_lock();
375 ret = sqlite3_prepare(sql->conn, query, length, &stmt, &tail);
376 if (ret != SQLITE_OK) {
377 sqlite3_finalize(stmt);
381 ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
383 sqlite3_finalize(stmt);
384 length -= (tail - query);
386 } while (length > 0);
388 apr_dbd_mutex_unlock();
390 if (TXN_NOTICE_ERRORS(sql->trans)) {
391 sql->trans->errnum = ret;
396 static apr_status_t free_mem(void *data)
402 static const char *dbd_sqlite3_escape(apr_pool_t *pool, const char *arg,
405 char *ret = sqlite3_mprintf("%q", arg);
406 apr_pool_cleanup_register(pool, ret, free_mem,
407 apr_pool_cleanup_null);
411 static int dbd_sqlite3_prepare(apr_pool_t *pool, apr_dbd_t *sql,
412 const char *query, const char *label,
413 int nargs, int nvals, apr_dbd_type_e *types,
414 apr_dbd_prepared_t **statement)
417 const char *tail = NULL;
420 apr_dbd_mutex_lock();
422 ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
423 if (ret == SQLITE_OK) {
424 apr_dbd_prepared_t *prep;
426 prep = apr_pcalloc(sql->pool, sizeof(*prep));
428 prep->next = sql->prep;
433 /* link new statement to the handle */
438 sqlite3_finalize(stmt);
441 apr_dbd_mutex_unlock();
446 static void dbd_sqlite3_bind(apr_dbd_prepared_t *statement, const char **values)
448 sqlite3_stmt *stmt = statement->stmt;
451 for (i = 0, j = 0; i < statement->nargs; i++, j++) {
452 if (values[j] == NULL) {
453 sqlite3_bind_null(stmt, i + 1);
456 switch (statement->types[i]) {
457 case APR_DBD_TYPE_BLOB:
458 case APR_DBD_TYPE_CLOB:
460 char *data = (char *)values[j];
461 int size = atoi((char*)values[++j]);
463 /* skip table and column */
466 sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
470 sqlite3_bind_text(stmt, i + 1, values[j],
471 strlen(values[j]), SQLITE_STATIC);
480 static int dbd_sqlite3_pquery(apr_pool_t *pool, apr_dbd_t *sql,
481 int *nrows, apr_dbd_prepared_t *statement,
484 sqlite3_stmt *stmt = statement->stmt;
487 if (sql->trans && sql->trans->errnum) {
488 return sql->trans->errnum;
491 apr_dbd_mutex_lock();
493 ret = sqlite3_reset(stmt);
494 if (ret == SQLITE_OK) {
495 dbd_sqlite3_bind(statement, values);
497 ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
502 apr_dbd_mutex_unlock();
504 if (TXN_NOTICE_ERRORS(sql->trans)) {
505 sql->trans->errnum = ret;
510 static int dbd_sqlite3_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
511 apr_dbd_prepared_t *statement, va_list args)
516 if (sql->trans && sql->trans->errnum) {
517 return sql->trans->errnum;
520 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
522 for (i = 0; i < statement->nvals; i++) {
523 values[i] = va_arg(args, const char*);
526 return dbd_sqlite3_pquery(pool, sql, nrows, statement, values);
529 static int dbd_sqlite3_pselect(apr_pool_t *pool, apr_dbd_t *sql,
530 apr_dbd_results_t **results,
531 apr_dbd_prepared_t *statement, int seek,
534 sqlite3_stmt *stmt = statement->stmt;
537 if (sql->trans && sql->trans->errnum) {
538 return sql->trans->errnum;
541 apr_dbd_mutex_lock();
543 ret = sqlite3_reset(stmt);
544 if (ret == SQLITE_OK) {
545 dbd_sqlite3_bind(statement, values);
547 ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
552 apr_dbd_mutex_unlock();
554 if (TXN_NOTICE_ERRORS(sql->trans)) {
555 sql->trans->errnum = ret;
560 static int dbd_sqlite3_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
561 apr_dbd_results_t **results,
562 apr_dbd_prepared_t *statement, int seek,
568 if (sql->trans && sql->trans->errnum) {
569 return sql->trans->errnum;
572 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
574 for (i = 0; i < statement->nvals; i++) {
575 values[i] = va_arg(args, const char*);
578 return dbd_sqlite3_pselect(pool, sql, results, statement, seek, values);
581 static void dbd_sqlite3_bbind(apr_dbd_prepared_t * statement,
584 sqlite3_stmt *stmt = statement->stmt;
588 for (i = 0, j = 0; i < statement->nargs; i++, j++) {
589 type = (values[j] == NULL ? APR_DBD_TYPE_NULL : statement->types[i]);
592 case APR_DBD_TYPE_TINY:
593 sqlite3_bind_int(stmt, i + 1, *(char*)values[j]);
595 case APR_DBD_TYPE_UTINY:
596 sqlite3_bind_int(stmt, i + 1, *(unsigned char*)values[j]);
598 case APR_DBD_TYPE_SHORT:
599 sqlite3_bind_int(stmt, i + 1, *(short*)values[j]);
601 case APR_DBD_TYPE_USHORT:
602 sqlite3_bind_int(stmt, i + 1, *(unsigned short*)values[j]);
604 case APR_DBD_TYPE_INT:
605 sqlite3_bind_int(stmt, i + 1, *(int*)values[j]);
607 case APR_DBD_TYPE_UINT:
608 sqlite3_bind_int(stmt, i + 1, *(unsigned int*)values[j]);
610 case APR_DBD_TYPE_LONG:
611 sqlite3_bind_int64(stmt, i + 1, *(long*)values[j]);
613 case APR_DBD_TYPE_ULONG:
614 sqlite3_bind_int64(stmt, i + 1, *(unsigned long*)values[j]);
616 case APR_DBD_TYPE_LONGLONG:
617 sqlite3_bind_int64(stmt, i + 1, *(apr_int64_t*)values[j]);
619 case APR_DBD_TYPE_ULONGLONG:
620 sqlite3_bind_int64(stmt, i + 1, *(apr_uint64_t*)values[j]);
622 case APR_DBD_TYPE_FLOAT:
623 sqlite3_bind_double(stmt, i + 1, *(float*)values[j]);
625 case APR_DBD_TYPE_DOUBLE:
626 sqlite3_bind_double(stmt, i + 1, *(double*)values[j]);
628 case APR_DBD_TYPE_STRING:
629 case APR_DBD_TYPE_TEXT:
630 case APR_DBD_TYPE_TIME:
631 case APR_DBD_TYPE_DATE:
632 case APR_DBD_TYPE_DATETIME:
633 case APR_DBD_TYPE_TIMESTAMP:
634 case APR_DBD_TYPE_ZTIMESTAMP:
635 sqlite3_bind_text(stmt, i + 1, values[j], strlen(values[j]),
638 case APR_DBD_TYPE_BLOB:
639 case APR_DBD_TYPE_CLOB:
641 char *data = (char*)values[j];
642 apr_size_t size = *(apr_size_t*)values[++j];
644 sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
646 /* skip table and column */
650 case APR_DBD_TYPE_NULL:
652 sqlite3_bind_null(stmt, i + 1);
660 static int dbd_sqlite3_pbquery(apr_pool_t * pool, apr_dbd_t * sql,
661 int *nrows, apr_dbd_prepared_t * statement,
664 sqlite3_stmt *stmt = statement->stmt;
667 if (sql->trans && sql->trans->errnum) {
668 return sql->trans->errnum;
671 apr_dbd_mutex_lock();
673 ret = sqlite3_reset(stmt);
674 if (ret == SQLITE_OK) {
675 dbd_sqlite3_bbind(statement, values);
677 ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
682 apr_dbd_mutex_unlock();
684 if (TXN_NOTICE_ERRORS(sql->trans)) {
685 sql->trans->errnum = ret;
690 static int dbd_sqlite3_pvbquery(apr_pool_t * pool, apr_dbd_t * sql,
691 int *nrows, apr_dbd_prepared_t * statement,
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 void*);
707 return dbd_sqlite3_pbquery(pool, sql, nrows, statement, values);
710 static int dbd_sqlite3_pbselect(apr_pool_t * pool, apr_dbd_t * sql,
711 apr_dbd_results_t ** results,
712 apr_dbd_prepared_t * statement,
713 int seek, const void **values)
715 sqlite3_stmt *stmt = statement->stmt;
718 if (sql->trans && sql->trans->errnum) {
719 return sql->trans->errnum;
722 apr_dbd_mutex_lock();
724 ret = sqlite3_reset(stmt);
725 if (ret == SQLITE_OK) {
726 dbd_sqlite3_bbind(statement, values);
728 ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
733 apr_dbd_mutex_unlock();
735 if (TXN_NOTICE_ERRORS(sql->trans)) {
736 sql->trans->errnum = ret;
741 static int dbd_sqlite3_pvbselect(apr_pool_t * pool, apr_dbd_t * sql,
742 apr_dbd_results_t ** results,
743 apr_dbd_prepared_t * statement, int seek,
749 if (sql->trans && sql->trans->errnum) {
750 return sql->trans->errnum;
753 values = apr_palloc(pool, sizeof(*values) * statement->nvals);
755 for (i = 0; i < statement->nvals; i++) {
756 values[i] = va_arg(args, const void*);
759 return dbd_sqlite3_pbselect(pool, sql, results, statement, seek, values);
762 static int dbd_sqlite3_start_transaction(apr_pool_t *pool,
764 apr_dbd_transaction_t **trans)
769 ret = dbd_sqlite3_query(handle, &nrows, "BEGIN IMMEDIATE");
771 *trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
772 (*trans)->handle = handle;
773 handle->trans = *trans;
779 static int dbd_sqlite3_end_transaction(apr_dbd_transaction_t *trans)
781 int ret = -1; /* ending transaction that was never started is an error */
785 /* rollback on error or explicit rollback request */
786 if (trans->errnum || TXN_DO_ROLLBACK(trans)) {
788 ret = dbd_sqlite3_query(trans->handle, &nrows, "ROLLBACK");
790 ret = dbd_sqlite3_query(trans->handle, &nrows, "COMMIT");
792 trans->handle->trans = NULL;
798 static int dbd_sqlite3_transaction_mode_get(apr_dbd_transaction_t *trans)
801 return APR_DBD_TRANSACTION_COMMIT;
806 static int dbd_sqlite3_transaction_mode_set(apr_dbd_transaction_t *trans,
810 return APR_DBD_TRANSACTION_COMMIT;
812 return trans->mode = (mode & TXN_MODE_BITS);
815 static apr_dbd_t *dbd_sqlite3_open(apr_pool_t *pool, const char *params,
818 apr_dbd_t *sql = NULL;
819 sqlite3 *conn = NULL;
823 sqlres = sqlite3_open(params, &conn);
824 if (sqlres != SQLITE_OK) {
826 *error = apr_pstrdup(pool, sqlite3_errmsg(conn));
831 /* should we register rand or power functions to the sqlite VM? */
832 sql = apr_pcalloc(pool, sizeof(*sql));
840 static apr_status_t dbd_sqlite3_close(apr_dbd_t *handle)
842 apr_dbd_prepared_t *prep = handle->prep;
844 /* finalize all prepared statements, or we'll get SQLITE_BUSY on close */
846 sqlite3_finalize(prep->stmt);
850 sqlite3_close(handle->conn);
854 static apr_status_t dbd_sqlite3_check_conn(apr_pool_t *pool,
857 return (handle->conn != NULL) ? APR_SUCCESS : APR_EGENERAL;
860 static int dbd_sqlite3_select_db(apr_pool_t *pool, apr_dbd_t *handle,
866 static void *dbd_sqlite3_native(apr_dbd_t *handle)
871 static int dbd_sqlite3_num_cols(apr_dbd_results_t *res)
876 static int dbd_sqlite3_num_tuples(apr_dbd_results_t *res)
881 APU_MODULE_DECLARE_DATA const apr_dbd_driver_t apr_dbd_sqlite3_driver = {
886 dbd_sqlite3_check_conn,
888 dbd_sqlite3_select_db,
889 dbd_sqlite3_start_transaction,
890 dbd_sqlite3_end_transaction,
893 dbd_sqlite3_num_cols,
894 dbd_sqlite3_num_tuples,
896 dbd_sqlite3_get_entry,
901 dbd_sqlite3_pvselect,
904 dbd_sqlite3_get_name,
905 dbd_sqlite3_transaction_mode_get,
906 dbd_sqlite3_transaction_mode_set,
908 dbd_sqlite3_pvbquery,
909 dbd_sqlite3_pvbselect,
911 dbd_sqlite3_pbselect,
912 dbd_sqlite3_datum_get