dbd/apr_dbd_sqlite3.c

   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
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include "apu.h"
  18
  19 #if APU_HAVE_SQLITE3
  20
  21 #include <ctype.h>
  22 #include <stdlib.h>
  23
  24 #include <sqlite3.h>
  25
  26 #include "apr_strings.h"
  27 #include "apr_time.h"
  28 #include "apr_buckets.h"
  29
  30 #include "apr_dbd_internal.h"
  31
  32 #define MAX_RETRY_COUNT 15
  33 #define MAX_RETRY_SLEEP 100000
  34
  35 struct apr_dbd_transaction_t {
  36     int mode;
  37     int errnum;
  38     apr_dbd_t *handle;
  39 };
  40
  41 struct apr_dbd_t {
  42     sqlite3 *conn;
  43     apr_dbd_transaction_t *trans;
  44     apr_pool_t *pool;
  45     apr_dbd_prepared_t *prep;
  46 };
  47
  48 typedef struct {
  49     char *name;
  50     char *value;
  51     int size;
  52     int type;
  53 } apr_dbd_column_t;
  54
  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;
  59     int columnCount;
  60     int rownum;
  61 };
  62
  63 struct apr_dbd_results_t {
  64     int random;
  65     sqlite3 *handle;
  66     sqlite3_stmt *stmt;
  67     apr_dbd_row_t *next_row;
  68     size_t sz;
  69     int tuples;
  70     char **col_names;
  71     apr_pool_t *pool;
  72 };
  73
  74 struct apr_dbd_prepared_t {
  75     sqlite3_stmt *stmt;
  76     apr_dbd_prepared_t *next;
  77     int nargs;
  78     int nvals;
  79     apr_dbd_type_e *types;
  80 };
  81
  82 #define dbd_sqlite3_is_success(x) (((x) == SQLITE_DONE) || ((x) == SQLITE_OK))
  83
  84 static int dbd_sqlite3_select_internal(apr_pool_t *pool,
  85                                        apr_dbd_t *sql,
  86                                        apr_dbd_results_t **results,
  87                                        sqlite3_stmt *stmt, int seek)
  88 {
  89     int i, ret, retry_count = 0, column_count;
  90     size_t num_tuples = 0;
  91     int increment = 0;
  92     apr_dbd_row_t *row = NULL;
  93     apr_dbd_row_t *lastrow = NULL;
  94     apr_dbd_column_t *column;
  95     char *hold = NULL;
  96
  97     column_count = sqlite3_column_count(stmt);
  98     if (!*results) {
  99         *results = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
 100     }
 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;
 108     do {
 109         ret = sqlite3_step(stmt);
 110         if (ret == SQLITE_BUSY) {
 111             if (retry_count++ > MAX_RETRY_COUNT) {
 112                 ret = SQLITE_ERROR;
 113             } else {
 114                 apr_dbd_mutex_unlock();
 115                 apr_sleep(MAX_RETRY_SLEEP);
 116                 apr_dbd_mutex_lock();
 117             }
 118         } else if (ret == SQLITE_ROW) {
 119             int length;
 120             apr_dbd_column_t *col;
 121             row = apr_palloc(pool, sizeof(apr_dbd_row_t));
 122             row->res = *results;
 123             increment = sizeof(apr_dbd_column_t *);
 124             length = increment * (*results)->sz;
 125             row->columns = apr_palloc(pool, length);
 126             row->columnCount = column_count;
 127             for (i = 0; i < (*results)->sz; i++) {
 128                 column = apr_palloc(pool, sizeof(apr_dbd_column_t));
 129                 row->columns[i] = column;
 130                 /* copy column name once only */
 131                 if ((*results)->col_names[i] == NULL) {
 132                     (*results)->col_names[i] =
 133                         apr_pstrdup(pool, sqlite3_column_name(stmt, i));
 134                 }
 135                 column->name = (*results)->col_names[i];
 136                 column->size = sqlite3_column_bytes(stmt, i);
 137                 column->type = sqlite3_column_type(stmt, i);
 138                 column->value = NULL;
 139                 switch (column->type) {
 140                 case SQLITE_FLOAT:
 141                 case SQLITE_INTEGER:
 142                 case SQLITE_TEXT:
 143                     hold = (char *) sqlite3_column_text(stmt, i);
 144                     if (hold) {
 145                         column->value = apr_pstrmemdup(pool, hold,
 146                                                        column->size);
 147                     }
 148                     break;
 149                 case SQLITE_BLOB:
 150                     hold = (char *) sqlite3_column_blob(stmt, i);
 151                     if (hold) {
 152                         column->value = apr_pstrmemdup(pool, hold,
 153                                                        column->size);
 154                     }
 155                     break;
 156                 case SQLITE_NULL:
 157                     break;
 158                 }
 159                 col = row->columns[i];
 160             }
 161             row->rownum = num_tuples++;
 162             row->next_row = 0;
 163             (*results)->tuples = num_tuples;
 164             if ((*results)->next_row == 0) {
 165                 (*results)->next_row = row;
 166             }
 167             if (lastrow != 0) {
 168                 lastrow->next_row = row;
 169             }
 170             lastrow = row;
 171         }
 172     } while (ret == SQLITE_ROW || ret == SQLITE_BUSY);
 173
 174     if (dbd_sqlite3_is_success(ret)) {
 175         ret = 0;
 176     }
 177     return ret;
 178 }
 179
 180 static int dbd_sqlite3_select(apr_pool_t *pool, apr_dbd_t *sql,
 181                               apr_dbd_results_t **results, const char *query,
 182                               int seek)
 183 {
 184     sqlite3_stmt *stmt = NULL;
 185     const char *tail = NULL;
 186     int ret;
 187
 188     if (sql->trans && sql->trans->errnum) {
 189         return sql->trans->errnum;
 190     }
 191
 192     apr_dbd_mutex_lock();
 193
 194     ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
 195     if (dbd_sqlite3_is_success(ret)) {
 196         ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
 197     }
 198     sqlite3_finalize(stmt);
 199
 200     apr_dbd_mutex_unlock();
 201
 202     if (TXN_NOTICE_ERRORS(sql->trans)) {
 203         sql->trans->errnum = ret;
 204     }
 205     return ret;
 206 }
 207
 208 static const char *dbd_sqlite3_get_name(const apr_dbd_results_t *res, int n)
 209 {
 210     if ((n < 0) || (n >= res->sz)) {
 211         return NULL;
 212     }
 213
 214     return res->col_names[n];
 215 }
 216
 217 static int dbd_sqlite3_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
 218                                apr_dbd_row_t **rowp, int rownum)
 219 {
 220     int i = 0;
 221
 222     if (rownum == -1) {
 223         *rowp = res->next_row;
 224         if (*rowp == 0)
 225             return -1;
 226         res->next_row = (*rowp)->next_row;
 227         return 0;
 228     }
 229     if (rownum > res->tuples) {
 230         return -1;
 231     }
 232     rownum--;
 233     *rowp = res->next_row;
 234     for (; *rowp != 0; i++, *rowp = (*rowp)->next_row) {
 235         if (i == rownum) {
 236             return 0;
 237         }
 238     }
 239
 240     return -1;
 241
 242 }
 243
 244 static const char *dbd_sqlite3_get_entry(const apr_dbd_row_t *row, int n)
 245 {
 246     apr_dbd_column_t *column;
 247     const char *value;
 248     if ((n < 0) || (n >= row->columnCount)) {
 249         return NULL;
 250     }
 251     column = row->columns[n];
 252     value = column->value;
 253     return value;
 254 }
 255
 256 static apr_status_t dbd_sqlite3_datum_get(const apr_dbd_row_t *row, int n,
 257                                           apr_dbd_type_e type, void *data)
 258 {
 259     if ((n < 0) || (n >= row->res->sz)) {
 260       return APR_EGENERAL;
 261     }
 262
 263     if (row->columns[n]->type == SQLITE_NULL) {
 264         return APR_ENOENT;
 265     }
 266
 267     switch (type) {
 268     case APR_DBD_TYPE_TINY:
 269         *(char*)data = atoi(row->columns[n]->value);
 270         break;
 271     case APR_DBD_TYPE_UTINY:
 272         *(unsigned char*)data = atoi(row->columns[n]->value);
 273         break;
 274     case APR_DBD_TYPE_SHORT:
 275         *(short*)data = atoi(row->columns[n]->value);
 276         break;
 277     case APR_DBD_TYPE_USHORT:
 278         *(unsigned short*)data = atoi(row->columns[n]->value);
 279         break;
 280     case APR_DBD_TYPE_INT:
 281         *(int*)data = atoi(row->columns[n]->value);
 282         break;
 283     case APR_DBD_TYPE_UINT:
 284         *(unsigned int*)data = atoi(row->columns[n]->value);
 285         break;
 286     case APR_DBD_TYPE_LONG:
 287         *(long*)data = atol(row->columns[n]->value);
 288         break;
 289     case APR_DBD_TYPE_ULONG:
 290         *(unsigned long*)data = atol(row->columns[n]->value);
 291         break;
 292     case APR_DBD_TYPE_LONGLONG:
 293         *(apr_int64_t*)data = apr_atoi64(row->columns[n]->value);
 294         break;
 295     case APR_DBD_TYPE_ULONGLONG:
 296         *(apr_uint64_t*)data = apr_atoi64(row->columns[n]->value);
 297         break;
 298     case APR_DBD_TYPE_FLOAT:
 299         *(float*)data = atof(row->columns[n]->value);
 300         break;
 301     case APR_DBD_TYPE_DOUBLE:
 302         *(double*)data = atof(row->columns[n]->value);
 303         break;
 304     case APR_DBD_TYPE_STRING:
 305     case APR_DBD_TYPE_TEXT:
 306     case APR_DBD_TYPE_TIME:
 307     case APR_DBD_TYPE_DATE:
 308     case APR_DBD_TYPE_DATETIME:
 309     case APR_DBD_TYPE_TIMESTAMP:
 310     case APR_DBD_TYPE_ZTIMESTAMP:
 311         *(char**)data = row->columns[n]->value;
 312         break;
 313     case APR_DBD_TYPE_BLOB:
 314     case APR_DBD_TYPE_CLOB:
 315         {
 316         apr_bucket *e;
 317         apr_bucket_brigade *b = (apr_bucket_brigade*)data;
 318
 319         e = apr_bucket_pool_create(row->columns[n]->value,
 320                                    row->columns[n]->size,
 321                                    row->res->pool, b->bucket_alloc);
 322         APR_BRIGADE_INSERT_TAIL(b, e);
 323         }
 324         break;
 325     case APR_DBD_TYPE_NULL:
 326         *(void**)data = NULL;
 327         break;
 328     default:
 329         return APR_EGENERAL;
 330     }
 331
 332     return APR_SUCCESS;
 333 }
 334
 335 static const char *dbd_sqlite3_error(apr_dbd_t *sql, int n)
 336 {
 337     return sqlite3_errmsg(sql->conn);
 338 }
 339
 340 static int dbd_sqlite3_query_internal(apr_dbd_t *sql, sqlite3_stmt *stmt,
 341                                       int *nrows)
 342 {
 343     int ret = -1, retry_count = 0;
 344
 345     while(retry_count++ <= MAX_RETRY_COUNT) {
 346         ret = sqlite3_step(stmt);
 347         if (ret != SQLITE_BUSY)
 348             break;
 349
 350         apr_dbd_mutex_unlock();
 351         apr_sleep(MAX_RETRY_SLEEP);
 352         apr_dbd_mutex_lock();
 353     }
 354
 355     *nrows = sqlite3_changes(sql->conn);
 356
 357     if (dbd_sqlite3_is_success(ret)) {
 358         ret = 0;
 359     }
 360     return ret;
 361 }
 362
 363 static int dbd_sqlite3_query(apr_dbd_t *sql, int *nrows, const char *query)
 364 {
 365     sqlite3_stmt *stmt = NULL;
 366     const char *tail = NULL;
 367     int ret = -1, length = 0;
 368
 369     if (sql->trans && sql->trans->errnum) {
 370         return sql->trans->errnum;
 371     }
 372
 373     length = strlen(query);
 374     apr_dbd_mutex_lock();
 375
 376     do {
 377         ret = sqlite3_prepare(sql->conn, query, length, &stmt, &tail);
 378         if (ret != SQLITE_OK) {
 379             sqlite3_finalize(stmt);
 380             break;
 381         }
 382
 383         ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
 384
 385         sqlite3_finalize(stmt);
 386         length -= (tail - query);
 387         query = tail;
 388     } while (length > 0);
 389
 390     apr_dbd_mutex_unlock();
 391
 392     if (TXN_NOTICE_ERRORS(sql->trans)) {
 393         sql->trans->errnum = ret;
 394     }
 395     return ret;
 396 }
 397
 398 static apr_status_t free_mem(void *data)
 399 {
 400     sqlite3_free(data);
 401     return APR_SUCCESS;
 402 }
 403
 404 static const char *dbd_sqlite3_escape(apr_pool_t *pool, const char *arg,
 405                                       apr_dbd_t *sql)
 406 {
 407     char *ret = sqlite3_mprintf("%q", arg);
 408     apr_pool_cleanup_register(pool, ret, free_mem,
 409                               apr_pool_cleanup_null);
 410     return ret;
 411 }
 412
 413 static int dbd_sqlite3_prepare(apr_pool_t *pool, apr_dbd_t *sql,
 414                                const char *query, const char *label,
 415                                int nargs, int nvals, apr_dbd_type_e *types,
 416                                apr_dbd_prepared_t **statement)
 417 {
 418     sqlite3_stmt *stmt;
 419     const char *tail = NULL;
 420     int ret;
 421
 422     apr_dbd_mutex_lock();
 423
 424     ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
 425     if (ret == SQLITE_OK) {
 426         apr_dbd_prepared_t *prep;
 427
 428         prep = apr_pcalloc(sql->pool, sizeof(*prep));
 429         prep->stmt = stmt;
 430         prep->next = sql->prep;
 431         prep->nargs = nargs;
 432         prep->nvals = nvals;
 433         prep->types = types;
 434
 435         /* link new statement to the handle */
 436         sql->prep = prep;
 437
 438         *statement = prep;
 439     } else {
 440         sqlite3_finalize(stmt);
 441     }
 442
 443     apr_dbd_mutex_unlock();
 444
 445     return ret;
 446 }
 447
 448 static void dbd_sqlite3_bind(apr_dbd_prepared_t *statement, const char **values)
 449 {
 450     sqlite3_stmt *stmt = statement->stmt;
 451     int i, j;
 452
 453     for (i = 0, j = 0; i < statement->nargs; i++, j++) {
 454         if (values[j] == NULL) {
 455             sqlite3_bind_null(stmt, i + 1);
 456         }
 457         else {
 458             switch (statement->types[i]) {
 459             case APR_DBD_TYPE_BLOB:
 460             case APR_DBD_TYPE_CLOB:
 461                 {
 462                 char *data = (char *)values[j];
 463                 int size = atoi((char*)values[++j]);
 464
 465                 /* skip table and column */
 466                 j += 2;
 467
 468                 sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
 469                 }
 470                 break;
 471             default:
 472                 sqlite3_bind_text(stmt, i + 1, values[j],
 473                                   strlen(values[j]), SQLITE_STATIC);
 474                 break;
 475             }
 476         }
 477     }
 478
 479     return;
 480 }
 481
 482 static int dbd_sqlite3_pquery(apr_pool_t *pool, apr_dbd_t *sql,
 483                               int *nrows, apr_dbd_prepared_t *statement,
 484                               const char **values)
 485 {
 486     sqlite3_stmt *stmt = statement->stmt;
 487     int ret = -1;
 488
 489     if (sql->trans && sql->trans->errnum) {
 490         return sql->trans->errnum;
 491     }
 492
 493     apr_dbd_mutex_lock();
 494
 495     ret = sqlite3_reset(stmt);
 496     if (ret == SQLITE_OK) {
 497         dbd_sqlite3_bind(statement, values);
 498
 499         ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
 500
 501         sqlite3_reset(stmt);
 502     }
 503
 504     apr_dbd_mutex_unlock();
 505
 506     if (TXN_NOTICE_ERRORS(sql->trans)) {
 507         sql->trans->errnum = ret;
 508     }
 509     return ret;
 510 }
 511
 512 static int dbd_sqlite3_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
 513                                apr_dbd_prepared_t *statement, va_list args)
 514 {
 515     const char **values;
 516     int i;
 517
 518     if (sql->trans && sql->trans->errnum) {
 519         return sql->trans->errnum;
 520     }
 521
 522     values = apr_palloc(pool, sizeof(*values) * statement->nvals);
 523
 524     for (i = 0; i < statement->nvals; i++) {
 525         values[i] = va_arg(args, const char*);
 526     }
 527
 528     return dbd_sqlite3_pquery(pool, sql, nrows, statement, values);
 529 }
 530
 531 static int dbd_sqlite3_pselect(apr_pool_t *pool, apr_dbd_t *sql,
 532                                apr_dbd_results_t **results,
 533                                apr_dbd_prepared_t *statement, int seek,
 534                                const char **values)
 535 {
 536     sqlite3_stmt *stmt = statement->stmt;
 537     int ret;
 538
 539     if (sql->trans && sql->trans->errnum) {
 540         return sql->trans->errnum;
 541     }
 542
 543     apr_dbd_mutex_lock();
 544
 545     ret = sqlite3_reset(stmt);
 546     if (ret == SQLITE_OK) {
 547         dbd_sqlite3_bind(statement, values);
 548
 549         ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
 550
 551         sqlite3_reset(stmt);
 552     }
 553
 554     apr_dbd_mutex_unlock();
 555
 556     if (TXN_NOTICE_ERRORS(sql->trans)) {
 557         sql->trans->errnum = ret;
 558     }
 559     return ret;
 560 }
 561
 562 static int dbd_sqlite3_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
 563                                 apr_dbd_results_t **results,
 564                                 apr_dbd_prepared_t *statement, int seek,
 565                                 va_list args)
 566 {
 567     const char **values;
 568     int i;
 569
 570     if (sql->trans && sql->trans->errnum) {
 571         return sql->trans->errnum;
 572     }
 573
 574     values = apr_palloc(pool, sizeof(*values) * statement->nvals);
 575
 576     for (i = 0; i < statement->nvals; i++) {
 577         values[i] = va_arg(args, const char*);
 578     }
 579
 580     return dbd_sqlite3_pselect(pool, sql, results, statement, seek, values);
 581 }
 582
 583 static void dbd_sqlite3_bbind(apr_dbd_prepared_t * statement,
 584                               const void **values)
 585 {
 586     sqlite3_stmt *stmt = statement->stmt;
 587     int i, j;
 588     apr_dbd_type_e type;
 589
 590     for (i = 0, j = 0; i < statement->nargs; i++, j++) {
 591         type = (values[j] == NULL ? APR_DBD_TYPE_NULL : statement->types[i]);
 592
 593         switch (type) {
 594         case APR_DBD_TYPE_TINY:
 595             sqlite3_bind_int(stmt, i + 1, *(char*)values[j]);
 596             break;
 597         case APR_DBD_TYPE_UTINY:
 598             sqlite3_bind_int(stmt, i + 1, *(unsigned char*)values[j]);
 599             break;
 600         case APR_DBD_TYPE_SHORT:
 601             sqlite3_bind_int(stmt, i + 1, *(short*)values[j]);
 602             break;
 603         case APR_DBD_TYPE_USHORT:
 604             sqlite3_bind_int(stmt, i + 1, *(unsigned short*)values[j]);
 605             break;
 606         case APR_DBD_TYPE_INT:
 607             sqlite3_bind_int(stmt, i + 1, *(int*)values[j]);
 608             break;
 609         case APR_DBD_TYPE_UINT:
 610             sqlite3_bind_int(stmt, i + 1, *(unsigned int*)values[j]);
 611             break;
 612         case APR_DBD_TYPE_LONG:
 613             sqlite3_bind_int64(stmt, i + 1, *(long*)values[j]);
 614             break;
 615         case APR_DBD_TYPE_ULONG:
 616             sqlite3_bind_int64(stmt, i + 1, *(unsigned long*)values[j]);
 617             break;
 618         case APR_DBD_TYPE_LONGLONG:
 619             sqlite3_bind_int64(stmt, i + 1, *(apr_int64_t*)values[j]);
 620             break;
 621         case APR_DBD_TYPE_ULONGLONG:
 622             sqlite3_bind_int64(stmt, i + 1, *(apr_uint64_t*)values[j]);
 623             break;
 624         case APR_DBD_TYPE_FLOAT:
 625             sqlite3_bind_double(stmt, i + 1, *(float*)values[j]);
 626             break;
 627         case APR_DBD_TYPE_DOUBLE:
 628             sqlite3_bind_double(stmt, i + 1, *(double*)values[j]);
 629             break;
 630         case APR_DBD_TYPE_STRING:
 631         case APR_DBD_TYPE_TEXT:
 632         case APR_DBD_TYPE_TIME:
 633         case APR_DBD_TYPE_DATE:
 634         case APR_DBD_TYPE_DATETIME:
 635         case APR_DBD_TYPE_TIMESTAMP:
 636         case APR_DBD_TYPE_ZTIMESTAMP:
 637             sqlite3_bind_text(stmt, i + 1, values[j], strlen(values[j]),
 638                               SQLITE_STATIC);
 639             break;
 640         case APR_DBD_TYPE_BLOB:
 641         case APR_DBD_TYPE_CLOB:
 642             {
 643             char *data = (char*)values[j];
 644             apr_size_t size = *(apr_size_t*)values[++j];
 645
 646             sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
 647
 648             /* skip table and column */
 649             j += 2;
 650             }
 651             break;
 652         case APR_DBD_TYPE_NULL:
 653         default:
 654             sqlite3_bind_null(stmt, i + 1);
 655             break;
 656         }
 657     }
 658
 659     return;
 660 }
 661
 662 static int dbd_sqlite3_pbquery(apr_pool_t * pool, apr_dbd_t * sql,
 663                                int *nrows, apr_dbd_prepared_t * statement,
 664                                const void **values)
 665 {
 666     sqlite3_stmt *stmt = statement->stmt;
 667     int ret = -1;
 668
 669     if (sql->trans && sql->trans->errnum) {
 670         return sql->trans->errnum;
 671     }
 672
 673     apr_dbd_mutex_lock();
 674
 675     ret = sqlite3_reset(stmt);
 676     if (ret == SQLITE_OK) {
 677         dbd_sqlite3_bbind(statement, values);
 678
 679         ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
 680
 681         sqlite3_reset(stmt);
 682     }
 683
 684     apr_dbd_mutex_unlock();
 685
 686     if (TXN_NOTICE_ERRORS(sql->trans)) {
 687         sql->trans->errnum = ret;
 688     }
 689     return ret;
 690 }
 691
 692 static int dbd_sqlite3_pvbquery(apr_pool_t * pool, apr_dbd_t * sql,
 693                                 int *nrows, apr_dbd_prepared_t * statement,
 694                                 va_list args)
 695 {
 696     const void **values;
 697     int i;
 698
 699     if (sql->trans && sql->trans->errnum) {
 700         return sql->trans->errnum;
 701     }
 702
 703     values = apr_palloc(pool, sizeof(*values) * statement->nvals);
 704
 705     for (i = 0; i < statement->nvals; i++) {
 706         values[i] = va_arg(args, const void*);
 707     }
 708
 709     return dbd_sqlite3_pbquery(pool, sql, nrows, statement, values);
 710 }
 711
 712 static int dbd_sqlite3_pbselect(apr_pool_t * pool, apr_dbd_t * sql,
 713                                 apr_dbd_results_t ** results,
 714                                 apr_dbd_prepared_t * statement,
 715                                 int seek, const void **values)
 716 {
 717     sqlite3_stmt *stmt = statement->stmt;
 718     int ret;
 719
 720     if (sql->trans && sql->trans->errnum) {
 721         return sql->trans->errnum;
 722     }
 723
 724     apr_dbd_mutex_lock();
 725
 726     ret = sqlite3_reset(stmt);
 727     if (ret == SQLITE_OK) {
 728         dbd_sqlite3_bbind(statement, values);
 729
 730         ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
 731
 732         sqlite3_reset(stmt);
 733     }
 734
 735     apr_dbd_mutex_unlock();
 736
 737     if (TXN_NOTICE_ERRORS(sql->trans)) {
 738         sql->trans->errnum = ret;
 739     }
 740     return ret;
 741 }
 742
 743 static int dbd_sqlite3_pvbselect(apr_pool_t * pool, apr_dbd_t * sql,
 744                                  apr_dbd_results_t ** results,
 745                                  apr_dbd_prepared_t * statement, int seek,
 746                                  va_list args)
 747 {
 748     const void **values;
 749     int i;
 750
 751     if (sql->trans && sql->trans->errnum) {
 752         return sql->trans->errnum;
 753     }
 754
 755     values = apr_palloc(pool, sizeof(*values) * statement->nvals);
 756
 757     for (i = 0; i < statement->nvals; i++) {
 758         values[i] = va_arg(args, const void*);
 759     }
 760
 761     return dbd_sqlite3_pbselect(pool, sql, results, statement, seek, values);
 762 }
 763
 764 static int dbd_sqlite3_start_transaction(apr_pool_t *pool,
 765                                          apr_dbd_t *handle,
 766                                          apr_dbd_transaction_t **trans)
 767 {
 768     int ret = 0;
 769     int nrows = 0;
 770
 771     ret = dbd_sqlite3_query(handle, &nrows, "BEGIN IMMEDIATE");
 772     if (!*trans) {
 773         *trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
 774         (*trans)->handle = handle;
 775         handle->trans = *trans;
 776     }
 777
 778     return ret;
 779 }
 780
 781 static int dbd_sqlite3_end_transaction(apr_dbd_transaction_t *trans)
 782 {
 783     int ret = -1; /* ending transaction that was never started is an error */
 784     int nrows = 0;
 785
 786     if (trans) {
 787         /* rollback on error or explicit rollback request */
 788         if (trans->errnum || TXN_DO_ROLLBACK(trans)) {
 789             trans->errnum = 0;
 790             ret = dbd_sqlite3_query(trans->handle, &nrows, "ROLLBACK");
 791         } else {
 792             ret = dbd_sqlite3_query(trans->handle, &nrows, "COMMIT");
 793         }
 794         trans->handle->trans = NULL;
 795     }
 796
 797     return ret;
 798 }
 799
 800 static int dbd_sqlite3_transaction_mode_get(apr_dbd_transaction_t *trans)
 801 {
 802     if (!trans)
 803         return APR_DBD_TRANSACTION_COMMIT;
 804
 805     return trans->mode;
 806 }
 807
 808 static int dbd_sqlite3_transaction_mode_set(apr_dbd_transaction_t *trans,
 809                                             int mode)
 810 {
 811     if (!trans)
 812         return APR_DBD_TRANSACTION_COMMIT;
 813
 814     return trans->mode = (mode & TXN_MODE_BITS);
 815 }
 816
 817 static apr_dbd_t *dbd_sqlite3_open(apr_pool_t *pool, const char *params)
 818 {
 819     apr_dbd_t *sql = NULL;
 820     sqlite3 *conn = NULL;
 821     int sqlres;
 822     if (!params)
 823         return NULL;
 824     sqlres = sqlite3_open(params, &conn);
 825     if (sqlres != SQLITE_OK) {
 826         sqlite3_close(conn);
 827         return NULL;
 828     }
 829     /* should we register rand or power functions to the sqlite VM? */
 830     sql = apr_pcalloc(pool, sizeof(*sql));
 831     sql->conn = conn;
 832     sql->pool = pool;
 833     sql->trans = NULL;
 834
 835     return sql;
 836 }
 837
 838 static apr_status_t dbd_sqlite3_close(apr_dbd_t *handle)
 839 {
 840     apr_dbd_prepared_t *prep = handle->prep;
 841
 842     /* finalize all prepared statements, or we'll get SQLITE_BUSY on close */
 843     while (prep) {
 844         sqlite3_finalize(prep->stmt);
 845         prep = prep->next;
 846     }
 847
 848     sqlite3_close(handle->conn);
 849     return APR_SUCCESS;
 850 }
 851
 852 static apr_status_t dbd_sqlite3_check_conn(apr_pool_t *pool,
 853                                            apr_dbd_t *handle)
 854 {
 855     return (handle->conn != NULL) ? APR_SUCCESS : APR_EGENERAL;
 856 }
 857
 858 static int dbd_sqlite3_select_db(apr_pool_t *pool, apr_dbd_t *handle,
 859                                  const char *name)
 860 {
 861     return APR_ENOTIMPL;
 862 }
 863
 864 static void *dbd_sqlite3_native(apr_dbd_t *handle)
 865 {
 866     return handle->conn;
 867 }
 868
 869 static int dbd_sqlite3_num_cols(apr_dbd_results_t *res)
 870 {
 871     return res->sz;
 872 }
 873
 874 static int dbd_sqlite3_num_tuples(apr_dbd_results_t *res)
 875 {
 876     return res->tuples;
 877 }
 878
 879 APU_DECLARE_DATA const apr_dbd_driver_t apr_dbd_sqlite3_driver = {
 880     "sqlite3",
 881     NULL,
 882     dbd_sqlite3_native,
 883     dbd_sqlite3_open,
 884     dbd_sqlite3_check_conn,
 885     dbd_sqlite3_close,
 886     dbd_sqlite3_select_db,
 887     dbd_sqlite3_start_transaction,
 888     dbd_sqlite3_end_transaction,
 889     dbd_sqlite3_query,
 890     dbd_sqlite3_select,
 891     dbd_sqlite3_num_cols,
 892     dbd_sqlite3_num_tuples,
 893     dbd_sqlite3_get_row,
 894     dbd_sqlite3_get_entry,
 895     dbd_sqlite3_error,
 896     dbd_sqlite3_escape,
 897     dbd_sqlite3_prepare,
 898     dbd_sqlite3_pvquery,
 899     dbd_sqlite3_pvselect,
 900     dbd_sqlite3_pquery,
 901     dbd_sqlite3_pselect,
 902     dbd_sqlite3_get_name,
 903     dbd_sqlite3_transaction_mode_get,
 904     dbd_sqlite3_transaction_mode_set,
 905     "?",
 906     dbd_sqlite3_pvbquery,
 907     dbd_sqlite3_pvbselect,
 908     dbd_sqlite3_pbquery,
 909     dbd_sqlite3_pbselect,
 910     dbd_sqlite3_datum_get
 911 };
 912 #endif