git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/sqlite.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2011 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version three of the GNU Affero General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Bacula Catalog Database routines specific to SQLite
  30  *
  31  *    Kern Sibbald, January 2002
  32  *
  33  * Major rewrite by Marco van Wieringen, January 2010 for catalog refactoring.
  34  */
  35
  36 #include "bacula.h"
  37
  38 #if HAVE_SQLITE3
  39
  40 #include "cats.h"
  41 #include "bdb_priv.h"
  42 #include <sqlite3.h>
  43 #include "bdb_sqlite.h"
  44
  45 /* -----------------------------------------------------------------------
  46  *
  47  *    SQLite dependent defines and subroutines
  48  *
  49  * -----------------------------------------------------------------------
  50  */
  51
  52 /*
  53  * List of open databases
  54  */
  55 static dlist *db_list = NULL;
  56
  57 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  58
  59 /*
  60  * When using mult_db_connections = true,
  61  * sqlite can be BUSY. We just need sleep a little in this case.
  62  */
  63 static int sqlite_busy_handler(void *arg, int calls)
  64 {
  65    bmicrosleep(0, 500);
  66    return 1;
  67 }
  68
  69 B_DB_SQLITE::B_DB_SQLITE(JCR *jcr,
  70                          const char *db_driver,
  71                          const char *db_name,
  72                          const char *db_user,
  73                          const char *db_password,
  74                          const char *db_address,
  75                          int db_port,
  76                          const char *db_socket,
  77                          bool mult_db_connections,
  78                          bool disable_batch_insert)
  79 {
  80    /*
  81     * Initialize the parent class members.
  82     */
  83    m_db_interface_type = SQL_INTERFACE_TYPE_SQLITE3;
  84    m_db_type = SQL_TYPE_SQLITE3;
  85    m_db_driver = bstrdup("SQLite3");
  86    m_db_name = bstrdup(db_name);
  87    if (disable_batch_insert) {
  88       m_disabled_batch_insert = true;
  89       m_have_batch_insert = false;
  90    } else {
  91       m_disabled_batch_insert = false;
  92 #if defined(USE_BATCH_FILE_INSERT)
  93 #if defined(HAVE_SQLITE3_THREADSAFE)
  94       m_have_batch_insert = sqlite3_threadsafe();
  95 #else
  96       m_have_batch_insert = false;
  97 #endif /* HAVE_SQLITE3_THREADSAFE */
  98 #else
  99       m_have_batch_insert = false;
 100 #endif /* USE_BATCH_FILE_INSERT */
 101    }
 102    errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 103    *errmsg = 0;
 104    cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 105    cached_path = get_pool_memory(PM_FNAME);
 106    cached_path_id = 0;
 107    m_ref_count = 1;
 108    fname = get_pool_memory(PM_FNAME);
 109    path = get_pool_memory(PM_FNAME);
 110    esc_name = get_pool_memory(PM_FNAME);
 111    esc_path = get_pool_memory(PM_FNAME);
 112    esc_obj  = get_pool_memory(PM_FNAME);
 113    m_allow_transactions = mult_db_connections;
 114
 115    /*
 116     * Initialize the private members.
 117     */
 118    m_db_handle = NULL;
 119    m_result = NULL;
 120    m_sqlite_errmsg = NULL;
 121
 122    /*
 123     * Put the db in the list.
 124     */
 125    if (db_list == NULL) {
 126       db_list = New(dlist(this, &this->m_link));
 127    }
 128    db_list->append(this);
 129 }
 130
 131 B_DB_SQLITE::~B_DB_SQLITE()
 132 {
 133 }
 134
 135 /*
 136  * Now actually open the database.  This can generate errors,
 137  * which are returned in the errmsg
 138  *
 139  * DO NOT close the database or delete mdb here !!!!
 140  */
 141 bool B_DB_SQLITE::db_open_database(JCR *jcr)
 142 {
 143    bool retval = false;
 144    char *db_path;
 145    int len;
 146    struct stat statbuf;
 147    int ret;
 148    int errstat;
 149    int retry = 0;
 150
 151    P(mutex);
 152    if (m_connected) {
 153       retval = true;
 154       goto bail_out;
 155    }
 156
 157    if ((errstat=rwl_init(&m_lock)) != 0) {
 158       berrno be;
 159       Mmsg1(&errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 160             be.bstrerror(errstat));
 161       goto bail_out;
 162    }
 163
 164    /*
 165     * Open the database
 166     */
 167    len = strlen(working_directory) + strlen(m_db_name) + 5;
 168    db_path = (char *)malloc(len);
 169    strcpy(db_path, working_directory);
 170    strcat(db_path, "/");
 171    strcat(db_path, m_db_name);
 172    strcat(db_path, ".db");
 173    if (stat(db_path, &statbuf) != 0) {
 174       Mmsg1(&errmsg, _("Database %s does not exist, please create it.\n"),
 175          db_path);
 176       free(db_path);
 177       goto bail_out;
 178    }
 179
 180    for (m_db_handle = NULL; !m_db_handle && retry++ < 10; ) {
 181       ret = sqlite3_open(db_path, &m_db_handle);
 182       if (ret != SQLITE_OK) {
 183          m_sqlite_errmsg = (char *)sqlite3_errmsg(m_db_handle);
 184          sqlite3_close(m_db_handle);
 185          m_db_handle = NULL;
 186       } else {
 187          m_sqlite_errmsg = NULL;
 188       }
 189
 190       Dmsg0(300, "sqlite_open\n");
 191       if (!m_db_handle) {
 192          bmicrosleep(1, 0);
 193       }
 194    }
 195    if (m_db_handle == NULL) {
 196       Mmsg2(&errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 197          db_path, m_sqlite_errmsg ? m_sqlite_errmsg : _("unknown"));
 198       free(db_path);
 199       goto bail_out;
 200    }
 201    m_connected = true;
 202    free(db_path);
 203
 204    /*
 205     * Set busy handler to wait when we use mult_db_connections = true
 206     */
 207    sqlite3_busy_handler(m_db_handle, sqlite_busy_handler, NULL);
 208
 209 #if defined(SQLITE3_INIT_QUERY)
 210    sql_query(SQLITE3_INIT_QUERY);
 211 #endif
 212
 213    if (!check_tables_version(jcr, this)) {
 214       goto bail_out;
 215    }
 216
 217    retval = true;
 218
 219 bail_out:
 220    V(mutex);
 221    return retval;
 222 }
 223
 224 void B_DB_SQLITE::db_close_database(JCR *jcr)
 225 {
 226    db_end_transaction(jcr);
 227    P(mutex);
 228    sql_free_result();
 229    m_ref_count--;
 230    if (m_ref_count == 0) {
 231       db_list->remove(this);
 232       if (m_connected && m_db_handle) {
 233          sqlite3_close(m_db_handle);
 234       }
 235       rwl_destroy(&m_lock);
 236       free_pool_memory(errmsg);
 237       free_pool_memory(cmd);
 238       free_pool_memory(cached_path);
 239       free_pool_memory(fname);
 240       free_pool_memory(path);
 241       free_pool_memory(esc_name);
 242       free_pool_memory(esc_path);
 243       free_pool_memory(esc_obj);
 244       if (m_db_driver) {
 245          free(m_db_driver);
 246       }
 247       if (m_db_name) {
 248          free(m_db_name);
 249       }
 250       delete this;
 251       if (db_list->size() == 0) {
 252          delete db_list;
 253          db_list = NULL;
 254       }
 255    }
 256    V(mutex);
 257 }
 258
 259 void B_DB_SQLITE::db_thread_cleanup(void)
 260 {
 261    sqlite3_thread_cleanup();
 262 }
 263
 264 /*
 265  * Escape strings so that SQLite is happy
 266  *
 267  *   NOTE! len is the length of the old string. Your new
 268  *         string must be long enough (max 2*old+1) to hold
 269  *         the escaped output.
 270  */
 271 void B_DB_SQLITE::db_escape_string(JCR *jcr, char *snew, char *old, int len)
 272 {
 273    char *n, *o;
 274
 275    n = snew;
 276    o = old;
 277    while (len--) {
 278       switch (*o) {
 279       case '\'':
 280          *n++ = '\'';
 281          *n++ = '\'';
 282          o++;
 283          break;
 284       case 0:
 285          *n++ = '\\';
 286          *n++ = 0;
 287          o++;
 288          break;
 289       default:
 290          *n++ = *o++;
 291          break;
 292       }
 293    }
 294    *n = 0;
 295 }
 296
 297 /*
 298  * Escape binary object so that SQLite is happy
 299  * Memory is stored in B_DB struct, no need to free it
 300  *
 301  * TODO: this should be implemented  (escape \0)
 302  */
 303 char *B_DB_SQLITE::db_escape_object(JCR *jcr, char *old, int len)
 304 {
 305    char *n, *o;
 306
 307    n = esc_obj = check_pool_memory_size(esc_obj, len*2+1);
 308    o = old;
 309    while (len--) {
 310       switch (*o) {
 311       case '\'':
 312          *n++ = '\'';
 313          *n++ = '\'';
 314          o++;
 315          break;
 316       case 0:
 317          *n++ = '\\';
 318          *n++ = 0;
 319          o++;
 320          break;
 321       default:
 322          *n++ = *o++;
 323          break;
 324       }
 325    }
 326    *n = 0;
 327    return esc_obj;
 328 }
 329
 330 /*
 331  * Unescape binary object so that SQLIte is happy
 332  *
 333  * TODO: need to be implemented (escape \0)
 334  */
 335 void B_DB_SQLITE::db_unescape_object(JCR *jcr, char *from, int32_t expected_len,
 336                                      POOLMEM **dest, int32_t *dest_len)
 337 {
 338    if (!from) {
 339       *dest[0] = 0;
 340       *dest_len = 0;
 341       return;
 342    }
 343    *dest = check_pool_memory_size(*dest, expected_len+1);
 344    *dest_len = expected_len;
 345    memcpy(*dest, from, expected_len);
 346    (*dest)[expected_len]=0;
 347 }
 348
 349 /*
 350  * Start a transaction. This groups inserts and makes things
 351  * much more efficient. Usually started when inserting
 352  * file attributes.
 353  */
 354 void B_DB_SQLITE::db_start_transaction(JCR *jcr)
 355 {
 356    if (!jcr->attr) {
 357       jcr->attr = get_pool_memory(PM_FNAME);
 358    }
 359    if (!jcr->ar) {
 360       jcr->ar = (ATTR_DBR *)malloc(sizeof(ATTR_DBR));
 361    }
 362
 363    if (!m_allow_transactions) {
 364       return;
 365    }
 366
 367    db_lock(this);
 368    /*
 369     * Allow only 10,000 changes per transaction
 370     */
 371    if (m_transaction && changes > 10000) {
 372       db_end_transaction(jcr);
 373    }
 374    if (!m_transaction) {
 375       sql_query("BEGIN");  /* begin transaction */
 376       Dmsg0(400, "Start SQLite transaction\n");
 377       m_transaction = true;
 378    }
 379    db_unlock(this);
 380 }
 381
 382 void B_DB_SQLITE::db_end_transaction(JCR *jcr)
 383 {
 384    if (jcr && jcr->cached_attribute) {
 385       Dmsg0(400, "Flush last cached attribute.\n");
 386       if (!db_create_attributes_record(jcr, this, jcr->ar)) {
 387          Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 388       }
 389       jcr->cached_attribute = false;
 390    }
 391
 392    if (!m_allow_transactions) {
 393       return;
 394    }
 395
 396    db_lock(this);
 397    if (m_transaction) {
 398       sql_query("COMMIT"); /* end transaction */
 399       m_transaction = false;
 400       Dmsg1(400, "End SQLite transaction changes=%d\n", changes);
 401    }
 402    changes = 0;
 403    db_unlock(this);
 404 }
 405
 406 struct rh_data {
 407    B_DB_SQLITE *mdb;
 408    DB_RESULT_HANDLER *result_handler;
 409    void *ctx;
 410    bool initialized;
 411 };
 412
 413 /*
 414  * Convert SQLite's callback into Bacula DB callback
 415  */
 416 static int sqlite_sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 417 {
 418    struct rh_data *rh_data = (struct rh_data *)arh_data;
 419
 420    /* The db_sql_query doesn't have access to m_results, so if we wan't to get
 421     * fields information, we need to use col_names
 422     */
 423    if (!rh_data->initialized) {
 424       rh_data->mdb->set_column_names(col_names, num_fields);
 425       rh_data->initialized = true;
 426    }
 427    if (rh_data->result_handler) {
 428       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 429    }
 430
 431    return 0;
 432 }
 433
 434 /*
 435  * Submit a general SQL command (cmd), and for each row returned,
 436  *  the result_handler is called with the ctx.
 437  */
 438 bool B_DB_SQLITE::db_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 439 {
 440    bool retval = false;
 441    int stat;
 442    struct rh_data rh_data;
 443
 444    Dmsg1(500, "db_sql_query starts with '%s'\n", query);
 445
 446    db_lock(this);
 447    if (m_sqlite_errmsg) {
 448       sqlite3_free(m_sqlite_errmsg);
 449       m_sqlite_errmsg = NULL;
 450    }
 451    sql_free_result();
 452
 453    rh_data.ctx = ctx;
 454    rh_data.mdb = this;
 455    rh_data.initialized = false;
 456    rh_data.result_handler = result_handler;
 457
 458    stat = sqlite3_exec(m_db_handle, query, sqlite_sqlite_result,
 459                        (void *)&rh_data, &m_sqlite_errmsg);
 460
 461    if (stat != SQLITE_OK) {
 462       Mmsg(errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror());
 463       Dmsg0(500, "db_sql_query finished\n");
 464       goto bail_out;
 465    }
 466    Dmsg0(500, "db_sql_query finished\n");
 467    sql_free_result();
 468    retval = true;
 469
 470 bail_out:
 471    db_unlock(this);
 472    return retval;
 473 }
 474
 475 /*
 476  * Submit a sqlite query and retrieve all the data
 477  */
 478 bool B_DB_SQLITE::sql_query(const char *query, int flags)
 479 {
 480    int stat;
 481    bool retval = false;
 482
 483    Dmsg1(500, "sql_query starts with '%s'\n", query);
 484
 485    if (m_result) {
 486       sql_free_result();
 487    }
 488    if (m_sqlite_errmsg) {
 489       sqlite3_free(m_sqlite_errmsg);
 490       m_sqlite_errmsg = NULL;
 491    }
 492
 493    stat = sqlite3_get_table(m_db_handle, (char *)query, &m_result,
 494                             &m_num_rows, &m_num_fields, &m_sqlite_errmsg);
 495
 496    m_row_number = 0;               /* no row fetched */
 497    if (stat != 0) {                   /* something went wrong */
 498       m_num_rows = m_num_fields = 0;
 499       Dmsg0(500, "sql_query finished\n");
 500    } else {
 501       Dmsg0(500, "sql_query finished\n");
 502       retval = true;
 503    }
 504    return retval;
 505 }
 506
 507 void B_DB_SQLITE::sql_free_result(void)
 508 {
 509    db_lock(this);
 510    if (m_fields) {
 511       free(m_fields);
 512       m_fields = NULL;
 513    }
 514    if (m_result) {
 515       sqlite3_free_table(m_result);
 516       m_result = NULL;
 517    }
 518    m_col_names = NULL;
 519    m_num_rows = m_num_fields = 0;
 520    db_unlock(this);
 521 }
 522
 523 /*
 524  * Fetch one row at a time
 525  */
 526 SQL_ROW B_DB_SQLITE::sql_fetch_row(void)
 527 {
 528    if (!m_result || (m_row_number >= m_num_rows)) {
 529       return NULL;
 530    }
 531    m_row_number++;
 532    return &m_result[m_num_fields * m_row_number];
 533 }
 534
 535 const char *B_DB_SQLITE::sql_strerror(void)
 536 {
 537    return m_sqlite_errmsg ? m_sqlite_errmsg : "unknown";
 538 }
 539
 540 void B_DB_SQLITE::sql_data_seek(int row)
 541 {
 542    /*
 543     * Set the row number to be returned on the next call to sql_fetch_row
 544     */
 545    m_row_number = row;
 546 }
 547
 548 int B_DB_SQLITE::sql_affected_rows(void)
 549 {
 550    return sqlite3_changes(m_db_handle);
 551 }
 552
 553 uint64_t B_DB_SQLITE::sql_insert_autokey_record(const char *query, const char *table_name)
 554 {
 555    /*
 556     * First execute the insert query and then retrieve the currval.
 557     */
 558    if (!sql_query(query)) {
 559       return 0;
 560    }
 561
 562    m_num_rows = sql_affected_rows();
 563    if (m_num_rows != 1) {
 564       return 0;
 565    }
 566
 567    changes++;
 568
 569    return sqlite3_last_insert_rowid(m_db_handle);
 570 }
 571
 572 SQL_FIELD *B_DB_SQLITE::sql_fetch_field(void)
 573 {
 574    int i, j, len;
 575
 576    /* We are in the middle of a db_sql_query and we want to get fields info */
 577    if (m_col_names != NULL) {
 578       if (m_num_fields > m_field_number) {
 579          m_sql_field.name = m_col_names[m_field_number];
 580          /* We don't have the maximum field length, so we can use 80 as
 581           * estimation.
 582           */
 583          len = MAX(cstrlen(m_sql_field.name), 80/m_num_fields);
 584          m_sql_field.max_length = len;
 585
 586          m_field_number++;
 587          m_sql_field.type = 0;  /* not numeric */
 588          m_sql_field.flags = 1; /* not null */
 589          return &m_sql_field;
 590       } else {                  /* too much fetch_field() */
 591          return NULL;
 592       }
 593    }
 594
 595    /* We are after a sql_query() that stores the result in m_results */
 596    if (!m_fields || m_fields_size < m_num_fields) {
 597       if (m_fields) {
 598          free(m_fields);
 599          m_fields = NULL;
 600       }
 601       Dmsg1(500, "allocating space for %d fields\n", m_num_fields);
 602       m_fields = (SQL_FIELD *)malloc(sizeof(SQL_FIELD) * m_num_fields);
 603       m_fields_size = m_num_fields;
 604
 605       for (i = 0; i < m_num_fields; i++) {
 606          Dmsg1(500, "filling field %d\n", i);
 607          m_fields[i].name = m_result[i];
 608          m_fields[i].max_length = cstrlen(m_fields[i].name);
 609          for (j = 1; j <= m_num_rows; j++) {
 610             if (m_result[i + m_num_fields * j]) {
 611                len = (uint32_t)cstrlen(m_result[i + m_num_fields * j]);
 612             } else {
 613                len = 0;
 614             }
 615             if (len > m_fields[i].max_length) {
 616                m_fields[i].max_length = len;
 617             }
 618          }
 619          m_fields[i].type = 0;
 620          m_fields[i].flags = 1;        /* not null */
 621
 622          Dmsg4(500, "sql_fetch_field finds field '%s' has length='%d' type='%d' and IsNull=%d\n",
 623                m_fields[i].name, m_fields[i].max_length, m_fields[i].type, m_fields[i].flags);
 624       }
 625    }
 626
 627    /*
 628     * Increment field number for the next time around
 629     */
 630    return &m_fields[m_field_number++];
 631 }
 632
 633 bool B_DB_SQLITE::sql_field_is_not_null(int field_type)
 634 {
 635    switch (field_type) {
 636    case 1:
 637       return true;
 638    default:
 639       return false;
 640    }
 641 }
 642
 643 bool B_DB_SQLITE::sql_field_is_numeric(int field_type)
 644 {
 645    switch (field_type) {
 646    case 1:
 647       return true;
 648    default:
 649       return false;
 650    }
 651 }
 652
 653 /*
 654  * Returns true if OK
 655  *         false if failed
 656  */
 657 bool B_DB_SQLITE::sql_batch_start(JCR *jcr)
 658 {
 659    bool retval;
 660
 661    db_lock(this);
 662    retval = sql_query("CREATE TEMPORARY TABLE batch ("
 663                               "FileIndex integer,"
 664                               "JobId integer,"
 665                               "Path blob,"
 666                               "Name blob,"
 667                               "LStat tinyblob,"
 668                               "MD5 tinyblob,"
 669                               "MarkId integer)");
 670    db_unlock(this);
 671
 672    return retval;
 673 }
 674
 675 /* set error to something to abort operation */
 676 /*
 677  * Returns true if OK
 678  *         false if failed
 679  */
 680 bool B_DB_SQLITE::sql_batch_end(JCR *jcr, const char *error)
 681 {
 682    m_status = 0;
 683
 684    return true;
 685 }
 686
 687 /*
 688  * Returns true if OK
 689  *         false if failed
 690  */
 691 bool B_DB_SQLITE::sql_batch_insert(JCR *jcr, ATTR_DBR *ar)
 692 {
 693    size_t len;
 694    const char *digest;
 695    char ed1[50];
 696
 697    esc_name = check_pool_memory_size(esc_name, fnl*2+1);
 698    db_escape_string(jcr, esc_name, fname, fnl);
 699
 700    esc_path = check_pool_memory_size(esc_path, pnl*2+1);
 701    db_escape_string(jcr, esc_path, path, pnl);
 702
 703    if (ar->Digest == NULL || ar->Digest[0] == 0) {
 704       digest = "0";
 705    } else {
 706       digest = ar->Digest;
 707    }
 708
 709    len = Mmsg(cmd, "INSERT INTO batch VALUES "
 710                    "(%u,%s,'%s','%s','%s','%s',%u)",
 711                    ar->FileIndex, edit_int64(ar->JobId,ed1), esc_path,
 712                    esc_name, ar->attr, digest, ar->DeltaSeq);
 713
 714    return sql_query(cmd);
 715 }
 716
 717 /*
 718  * Initialize database data structure. In principal this should
 719  * never have errors, or it is really fatal.
 720  */
 721 B_DB *db_init_database(JCR *jcr, const char *db_driver, const char *db_name,
 722                        const char *db_user, const char *db_password,
 723                        const char *db_address, int db_port,
 724                        const char *db_socket, bool mult_db_connections,
 725                        bool disable_batch_insert)
 726 {
 727    B_DB *mdb = NULL;
 728
 729    P(mutex);                          /* lock DB queue */
 730    /*
 731     * Look to see if DB already open
 732     */
 733    if (db_list && !mult_db_connections) {
 734       foreach_dlist(mdb, db_list) {
 735          if (mdb->db_match_database(db_driver, db_name, db_address, db_port)) {
 736             Dmsg1(300, "DB REopen %s\n", db_name);
 737             mdb->increment_refcount();
 738             goto bail_out;
 739          }
 740       }
 741    }
 742    Dmsg0(300, "db_init_database first time\n");
 743    mdb = New(B_DB_SQLITE(jcr, db_driver, db_name, db_user, db_password,
 744                          db_address, db_port, db_socket, mult_db_connections,
 745                          disable_batch_insert));
 746
 747 bail_out:
 748    V(mutex);
 749    return mdb;
 750 }
 751
 752 #endif /* HAVE_SQLITE3 */