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    /* At this time, when mult_db_connections == true, this is for
 116     * specific console command such as bvfs or batch mode, and we don't
 117     * want to share a batch mode or bvfs. In the future, we can change
 118     * the creation function to add this parameter.
 119     */
 120    m_dedicated = mult_db_connections;
 121
 122    /*
 123     * Initialize the private members.
 124     */
 125    m_db_handle = NULL;
 126    m_result = NULL;
 127    m_sqlite_errmsg = NULL;
 128
 129    /*
 130     * Put the db in the list.
 131     */
 132    if (db_list == NULL) {
 133       db_list = New(dlist(this, &this->m_link));
 134    }
 135    db_list->append(this);
 136 }
 137
 138 B_DB_SQLITE::~B_DB_SQLITE()
 139 {
 140 }
 141
 142 /*
 143  * Now actually open the database.  This can generate errors,
 144  * which are returned in the errmsg
 145  *
 146  * DO NOT close the database or delete mdb here !!!!
 147  */
 148 bool B_DB_SQLITE::db_open_database(JCR *jcr)
 149 {
 150    bool retval = false;
 151    char *db_path;
 152    int len;
 153    struct stat statbuf;
 154    int ret;
 155    int errstat;
 156    int retry = 0;
 157
 158    P(mutex);
 159    if (m_connected) {
 160       retval = true;
 161       goto bail_out;
 162    }
 163
 164    if ((errstat=rwl_init(&m_lock)) != 0) {
 165       berrno be;
 166       Mmsg1(&errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 167             be.bstrerror(errstat));
 168       goto bail_out;
 169    }
 170
 171    /*
 172     * Open the database
 173     */
 174    len = strlen(working_directory) + strlen(m_db_name) + 5;
 175    db_path = (char *)malloc(len);
 176    strcpy(db_path, working_directory);
 177    strcat(db_path, "/");
 178    strcat(db_path, m_db_name);
 179    strcat(db_path, ".db");
 180    if (stat(db_path, &statbuf) != 0) {
 181       Mmsg1(&errmsg, _("Database %s does not exist, please create it.\n"),
 182          db_path);
 183       free(db_path);
 184       goto bail_out;
 185    }
 186
 187    for (m_db_handle = NULL; !m_db_handle && retry++ < 10; ) {
 188       ret = sqlite3_open(db_path, &m_db_handle);
 189       if (ret != SQLITE_OK) {
 190          m_sqlite_errmsg = (char *)sqlite3_errmsg(m_db_handle);
 191          sqlite3_close(m_db_handle);
 192          m_db_handle = NULL;
 193       } else {
 194          m_sqlite_errmsg = NULL;
 195       }
 196
 197       Dmsg0(300, "sqlite_open\n");
 198       if (!m_db_handle) {
 199          bmicrosleep(1, 0);
 200       }
 201    }
 202    if (m_db_handle == NULL) {
 203       Mmsg2(&errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 204          db_path, m_sqlite_errmsg ? m_sqlite_errmsg : _("unknown"));
 205       free(db_path);
 206       goto bail_out;
 207    }
 208    m_connected = true;
 209    free(db_path);
 210
 211    /*
 212     * Set busy handler to wait when we use mult_db_connections = true
 213     */
 214    sqlite3_busy_handler(m_db_handle, sqlite_busy_handler, NULL);
 215
 216 #if defined(SQLITE3_INIT_QUERY)
 217    sql_query(SQLITE3_INIT_QUERY);
 218 #endif
 219
 220    if (!check_tables_version(jcr, this)) {
 221       goto bail_out;
 222    }
 223
 224    retval = true;
 225
 226 bail_out:
 227    V(mutex);
 228    return retval;
 229 }
 230
 231 void B_DB_SQLITE::db_close_database(JCR *jcr)
 232 {
 233    if (m_connected) {
 234       db_end_transaction(jcr);
 235    }
 236    P(mutex);
 237    m_ref_count--;
 238    if (m_ref_count == 0) {
 239       sql_free_result();
 240       db_list->remove(this);
 241       if (m_connected && m_db_handle) {
 242          sqlite3_close(m_db_handle);
 243       }
 244       if (rwl_is_init(&m_lock)) {
 245          rwl_destroy(&m_lock);
 246       }
 247       free_pool_memory(errmsg);
 248       free_pool_memory(cmd);
 249       free_pool_memory(cached_path);
 250       free_pool_memory(fname);
 251       free_pool_memory(path);
 252       free_pool_memory(esc_name);
 253       free_pool_memory(esc_path);
 254       free_pool_memory(esc_obj);
 255       if (m_db_driver) {
 256          free(m_db_driver);
 257       }
 258       if (m_db_name) {
 259          free(m_db_name);
 260       }
 261       delete this;
 262       if (db_list->size() == 0) {
 263          delete db_list;
 264          db_list = NULL;
 265       }
 266    }
 267    V(mutex);
 268 }
 269
 270 void B_DB_SQLITE::db_thread_cleanup(void)
 271 {
 272    sqlite3_thread_cleanup();
 273 }
 274
 275 /*
 276  * Escape strings so that SQLite is happy
 277  *
 278  *   NOTE! len is the length of the old string. Your new
 279  *         string must be long enough (max 2*old+1) to hold
 280  *         the escaped output.
 281  */
 282 void B_DB_SQLITE::db_escape_string(JCR *jcr, char *snew, char *old, int len)
 283 {
 284    char *n, *o;
 285
 286    n = snew;
 287    o = old;
 288    while (len--) {
 289       switch (*o) {
 290       case '\'':
 291          *n++ = '\'';
 292          *n++ = '\'';
 293          o++;
 294          break;
 295       case 0:
 296          *n++ = '\\';
 297          *n++ = 0;
 298          o++;
 299          break;
 300       default:
 301          *n++ = *o++;
 302          break;
 303       }
 304    }
 305    *n = 0;
 306 }
 307
 308 /*
 309  * Escape binary object so that SQLite is happy
 310  * Memory is stored in B_DB struct, no need to free it
 311  *
 312  * TODO: this should be implemented  (escape \0)
 313  */
 314 char *B_DB_SQLITE::db_escape_object(JCR *jcr, char *old, int len)
 315 {
 316    int l;
 317    int max = len*2;           /* TODO: too big, should be *4/3 */
 318
 319    esc_obj = check_pool_memory_size(esc_obj, max);
 320    l = bin_to_base64(esc_obj, max, old, len, true);
 321    esc_obj[l] = 0;
 322    ASSERT(l < max);    /* TODO: add check for l */
 323
 324    return esc_obj;
 325 }
 326
 327 /*
 328  * Unescape binary object so that SQLIte is happy
 329  *
 330  * TODO: need to be implemented (escape \0)
 331  */
 332
 333 void B_DB_SQLITE::db_unescape_object(JCR *jcr, char *from, int32_t expected_len,
 334                                      POOLMEM **dest, int32_t *dest_len)
 335 {
 336    if (!from) {
 337       *dest[0] = 0;
 338       *dest_len = 0;
 339       return;
 340    }
 341    *dest = check_pool_memory_size(*dest, expected_len+1);
 342    base64_to_bin(*dest, expected_len+1, from, strlen(from));
 343    *dest_len = expected_len;
 344    (*dest)[expected_len]=0;
 345 }
 346
 347 /*
 348  * Start a transaction. This groups inserts and makes things
 349  * much more efficient. Usually started when inserting
 350  * file attributes.
 351  */
 352 void B_DB_SQLITE::db_start_transaction(JCR *jcr)
 353 {
 354    if (!jcr->attr) {
 355       jcr->attr = get_pool_memory(PM_FNAME);
 356    }
 357    if (!jcr->ar) {
 358       jcr->ar = (ATTR_DBR *)malloc(sizeof(ATTR_DBR));
 359    }
 360
 361    if (!m_allow_transactions) {
 362       return;
 363    }
 364
 365    db_lock(this);
 366    /*
 367     * Allow only 10,000 changes per transaction
 368     */
 369    if (m_transaction && changes > 10000) {
 370       db_end_transaction(jcr);
 371    }
 372    if (!m_transaction) {
 373       sql_query("BEGIN");  /* begin transaction */
 374       Dmsg0(400, "Start SQLite transaction\n");
 375       m_transaction = true;
 376    }
 377    db_unlock(this);
 378 }
 379
 380 void B_DB_SQLITE::db_end_transaction(JCR *jcr)
 381 {
 382    if (jcr && jcr->cached_attribute) {
 383       Dmsg0(400, "Flush last cached attribute.\n");
 384       if (!db_create_attributes_record(jcr, this, jcr->ar)) {
 385          Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 386       }
 387       jcr->cached_attribute = false;
 388    }
 389
 390    if (!m_allow_transactions) {
 391       return;
 392    }
 393
 394    db_lock(this);
 395    if (m_transaction) {
 396       sql_query("COMMIT"); /* end transaction */
 397       m_transaction = false;
 398       Dmsg1(400, "End SQLite transaction changes=%d\n", changes);
 399    }
 400    changes = 0;
 401    db_unlock(this);
 402 }
 403
 404 struct rh_data {
 405    B_DB_SQLITE *mdb;
 406    DB_RESULT_HANDLER *result_handler;
 407    void *ctx;
 408    bool initialized;
 409 };
 410
 411 /*
 412  * Convert SQLite's callback into Bacula DB callback
 413  */
 414 static int sqlite_result_handler(void *arh_data, int num_fields, char **rows, char **col_names)
 415 {
 416    struct rh_data *rh_data = (struct rh_data *)arh_data;
 417
 418    /* The db_sql_query doesn't have access to m_results, so if we wan't to get
 419     * fields information, we need to use col_names
 420     */
 421    if (!rh_data->initialized) {
 422       rh_data->mdb->set_column_names(col_names, num_fields);
 423       rh_data->initialized = true;
 424    }
 425    if (rh_data->result_handler) {
 426       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 427    }
 428
 429    return 0;
 430 }
 431
 432 /*
 433  * Submit a general SQL command (cmd), and for each row returned,
 434  *  the result_handler is called with the ctx.
 435  */
 436 bool B_DB_SQLITE::db_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 437 {
 438    bool retval = false;
 439    int stat;
 440    struct rh_data rh_data;
 441
 442    Dmsg1(500, "db_sql_query starts with '%s'\n", query);
 443
 444    db_lock(this);
 445    if (m_sqlite_errmsg) {
 446       sqlite3_free(m_sqlite_errmsg);
 447       m_sqlite_errmsg = NULL;
 448    }
 449    sql_free_result();
 450
 451    rh_data.ctx = ctx;
 452    rh_data.mdb = this;
 453    rh_data.initialized = false;
 454    rh_data.result_handler = result_handler;
 455
 456    stat = sqlite3_exec(m_db_handle, query, sqlite_result_handler,
 457                        (void *)&rh_data, &m_sqlite_errmsg);
 458
 459    if (stat != SQLITE_OK) {
 460       Mmsg(errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror());
 461       Dmsg0(500, "db_sql_query finished\n");
 462       goto bail_out;
 463    }
 464    Dmsg0(500, "db_sql_query finished\n");
 465    sql_free_result();
 466    retval = true;
 467
 468 bail_out:
 469    db_unlock(this);
 470    return retval;
 471 }
 472
 473 /*
 474  * Submit a sqlite query and retrieve all the data
 475  */
 476 bool B_DB_SQLITE::sql_query(const char *query, int flags)
 477 {
 478    int stat;
 479    bool retval = false;
 480
 481    Dmsg1(500, "sql_query starts with '%s'\n", query);
 482
 483    sql_free_result();
 484    if (m_sqlite_errmsg) {
 485       sqlite3_free(m_sqlite_errmsg);
 486       m_sqlite_errmsg = NULL;
 487    }
 488
 489    stat = sqlite3_get_table(m_db_handle, (char *)query, &m_result,
 490                             &m_num_rows, &m_num_fields, &m_sqlite_errmsg);
 491
 492    m_row_number = 0;               /* no row fetched */
 493    if (stat != 0) {                   /* something went wrong */
 494       m_num_rows = m_num_fields = 0;
 495       Dmsg0(500, "sql_query finished\n");
 496    } else {
 497       Dmsg0(500, "sql_query finished\n");
 498       retval = true;
 499    }
 500    return retval;
 501 }
 502
 503 void B_DB_SQLITE::sql_free_result(void)
 504 {
 505    db_lock(this);
 506    if (m_fields) {
 507       free(m_fields);
 508       m_fields = NULL;
 509    }
 510    if (m_result) {
 511       sqlite3_free_table(m_result);
 512       m_result = NULL;
 513    }
 514    m_col_names = NULL;
 515    m_num_rows = m_num_fields = 0;
 516    db_unlock(this);
 517 }
 518
 519 /*
 520  * Fetch one row at a time
 521  */
 522 SQL_ROW B_DB_SQLITE::sql_fetch_row(void)
 523 {
 524    if (!m_result || (m_row_number >= m_num_rows)) {
 525       return NULL;
 526    }
 527    m_row_number++;
 528    return &m_result[m_num_fields * m_row_number];
 529 }
 530
 531 const char *B_DB_SQLITE::sql_strerror(void)
 532 {
 533    return m_sqlite_errmsg ? m_sqlite_errmsg : "unknown";
 534 }
 535
 536 void B_DB_SQLITE::sql_data_seek(int row)
 537 {
 538    /*
 539     * Set the row number to be returned on the next call to sql_fetch_row
 540     */
 541    m_row_number = row;
 542 }
 543
 544 int B_DB_SQLITE::sql_affected_rows(void)
 545 {
 546    return sqlite3_changes(m_db_handle);
 547 }
 548
 549 uint64_t B_DB_SQLITE::sql_insert_autokey_record(const char *query, const char *table_name)
 550 {
 551    /*
 552     * First execute the insert query and then retrieve the currval.
 553     */
 554    if (!sql_query(query)) {
 555       return 0;
 556    }
 557
 558    m_num_rows = sql_affected_rows();
 559    if (m_num_rows != 1) {
 560       return 0;
 561    }
 562
 563    changes++;
 564
 565    return sqlite3_last_insert_rowid(m_db_handle);
 566 }
 567
 568 SQL_FIELD *B_DB_SQLITE::sql_fetch_field(void)
 569 {
 570    int i, j, len;
 571
 572    /* We are in the middle of a db_sql_query and we want to get fields info */
 573    if (m_col_names != NULL) {
 574       if (m_num_fields > m_field_number) {
 575          m_sql_field.name = m_col_names[m_field_number];
 576          /* We don't have the maximum field length, so we can use 80 as
 577           * estimation.
 578           */
 579          len = MAX(cstrlen(m_sql_field.name), 80/m_num_fields);
 580          m_sql_field.max_length = len;
 581
 582          m_field_number++;
 583          m_sql_field.type = 0;  /* not numeric */
 584          m_sql_field.flags = 1; /* not null */
 585          return &m_sql_field;
 586       } else {                  /* too much fetch_field() */
 587          return NULL;
 588       }
 589    }
 590
 591    /* We are after a sql_query() that stores the result in m_results */
 592    if (!m_fields || m_fields_size < m_num_fields) {
 593       if (m_fields) {
 594          free(m_fields);
 595          m_fields = NULL;
 596       }
 597       Dmsg1(500, "allocating space for %d fields\n", m_num_fields);
 598       m_fields = (SQL_FIELD *)malloc(sizeof(SQL_FIELD) * m_num_fields);
 599       m_fields_size = m_num_fields;
 600
 601       for (i = 0; i < m_num_fields; i++) {
 602          Dmsg1(500, "filling field %d\n", i);
 603          m_fields[i].name = m_result[i];
 604          m_fields[i].max_length = cstrlen(m_fields[i].name);
 605          for (j = 1; j <= m_num_rows; j++) {
 606             if (m_result[i + m_num_fields * j]) {
 607                len = (uint32_t)cstrlen(m_result[i + m_num_fields * j]);
 608             } else {
 609                len = 0;
 610             }
 611             if (len > m_fields[i].max_length) {
 612                m_fields[i].max_length = len;
 613             }
 614          }
 615          m_fields[i].type = 0;
 616          m_fields[i].flags = 1;        /* not null */
 617
 618          Dmsg4(500, "sql_fetch_field finds field '%s' has length='%d' type='%d' and IsNull=%d\n",
 619                m_fields[i].name, m_fields[i].max_length, m_fields[i].type, m_fields[i].flags);
 620       }
 621    }
 622
 623    /*
 624     * Increment field number for the next time around
 625     */
 626    return &m_fields[m_field_number++];
 627 }
 628
 629 bool B_DB_SQLITE::sql_field_is_not_null(int field_type)
 630 {
 631    switch (field_type) {
 632    case 1:
 633       return true;
 634    default:
 635       return false;
 636    }
 637 }
 638
 639 bool B_DB_SQLITE::sql_field_is_numeric(int field_type)
 640 {
 641    switch (field_type) {
 642    case 1:
 643       return true;
 644    default:
 645       return false;
 646    }
 647 }
 648
 649 /*
 650  * Returns true if OK
 651  *         false if failed
 652  */
 653 bool B_DB_SQLITE::sql_batch_start(JCR *jcr)
 654 {
 655    bool retval;
 656
 657    db_lock(this);
 658    retval = sql_query("CREATE TEMPORARY TABLE batch ("
 659                               "FileIndex integer,"
 660                               "JobId integer,"
 661                               "Path blob,"
 662                               "Name blob,"
 663                               "LStat tinyblob,"
 664                               "MD5 tinyblob,"
 665                               "DeltaSeq integer)");
 666    db_unlock(this);
 667
 668    return retval;
 669 }
 670
 671 /* set error to something to abort operation */
 672 /*
 673  * Returns true if OK
 674  *         false if failed
 675  */
 676 bool B_DB_SQLITE::sql_batch_end(JCR *jcr, const char *error)
 677 {
 678    m_status = 0;
 679
 680    return true;
 681 }
 682
 683 /*
 684  * Returns true if OK
 685  *         false if failed
 686  */
 687 bool B_DB_SQLITE::sql_batch_insert(JCR *jcr, ATTR_DBR *ar)
 688 {
 689    const char *digest;
 690    char ed1[50];
 691
 692    esc_name = check_pool_memory_size(esc_name, fnl*2+1);
 693    db_escape_string(jcr, esc_name, fname, fnl);
 694
 695    esc_path = check_pool_memory_size(esc_path, pnl*2+1);
 696    db_escape_string(jcr, esc_path, path, pnl);
 697
 698    if (ar->Digest == NULL || ar->Digest[0] == 0) {
 699       digest = "0";
 700    } else {
 701       digest = ar->Digest;
 702    }
 703
 704    Mmsg(cmd, "INSERT INTO batch VALUES "
 705         "(%u,%s,'%s','%s','%s','%s',%u)",
 706         ar->FileIndex, edit_int64(ar->JobId,ed1), esc_path,
 707         esc_name, ar->attr, digest, ar->DeltaSeq);
 708
 709    return sql_query(cmd);
 710 }
 711
 712 /*
 713  * Initialize database data structure. In principal this should
 714  * never have errors, or it is really fatal.
 715  */
 716 B_DB *db_init_database(JCR *jcr, const char *db_driver, const char *db_name,
 717                        const char *db_user, const char *db_password,
 718                        const char *db_address, int db_port,
 719                        const char *db_socket, bool mult_db_connections,
 720                        bool disable_batch_insert)
 721 {
 722    B_DB *mdb = NULL;
 723
 724    P(mutex);                          /* lock DB queue */
 725    /*
 726     * Look to see if DB already open
 727     */
 728    if (db_list && !mult_db_connections) {
 729       foreach_dlist(mdb, db_list) {
 730          if (mdb->db_match_database(db_driver, db_name, db_address, db_port)) {
 731             Dmsg1(300, "DB REopen %s\n", db_name);
 732             mdb->increment_refcount();
 733             goto bail_out;
 734          }
 735       }
 736    }
 737    Dmsg0(300, "db_init_database first time\n");
 738    mdb = New(B_DB_SQLITE(jcr, db_driver, db_name, db_user, db_password,
 739                          db_address, db_port, db_socket, mult_db_connections,
 740                          disable_batch_insert));
 741
 742 bail_out:
 743    V(mutex);
 744    return mdb;
 745 }
 746
 747 #endif /* HAVE_SQLITE3 */