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       if (m_connected) {
 240          sql_free_result();
 241       }
 242       db_list->remove(this);
 243       if (m_connected && m_db_handle) {
 244          sqlite3_close(m_db_handle);
 245       }
 246       if (rwl_is_init(&m_lock)) {
 247          rwl_destroy(&m_lock);
 248       }
 249       free_pool_memory(errmsg);
 250       free_pool_memory(cmd);
 251       free_pool_memory(cached_path);
 252       free_pool_memory(fname);
 253       free_pool_memory(path);
 254       free_pool_memory(esc_name);
 255       free_pool_memory(esc_path);
 256       free_pool_memory(esc_obj);
 257       if (m_db_driver) {
 258          free(m_db_driver);
 259       }
 260       if (m_db_name) {
 261          free(m_db_name);
 262       }
 263       delete this;
 264       if (db_list->size() == 0) {
 265          delete db_list;
 266          db_list = NULL;
 267       }
 268    }
 269    V(mutex);
 270 }
 271
 272 void B_DB_SQLITE::db_thread_cleanup(void)
 273 {
 274    sqlite3_thread_cleanup();
 275 }
 276
 277 /*
 278  * Escape strings so that SQLite is happy
 279  *
 280  *   NOTE! len is the length of the old string. Your new
 281  *         string must be long enough (max 2*old+1) to hold
 282  *         the escaped output.
 283  */
 284 void B_DB_SQLITE::db_escape_string(JCR *jcr, char *snew, char *old, int len)
 285 {
 286    char *n, *o;
 287
 288    n = snew;
 289    o = old;
 290    while (len--) {
 291       switch (*o) {
 292       case '\'':
 293          *n++ = '\'';
 294          *n++ = '\'';
 295          o++;
 296          break;
 297       case 0:
 298          *n++ = '\\';
 299          *n++ = 0;
 300          o++;
 301          break;
 302       default:
 303          *n++ = *o++;
 304          break;
 305       }
 306    }
 307    *n = 0;
 308 }
 309
 310 /*
 311  * Escape binary object so that SQLite is happy
 312  * Memory is stored in B_DB struct, no need to free it
 313  *
 314  * TODO: this should be implemented  (escape \0)
 315  */
 316 char *B_DB_SQLITE::db_escape_object(JCR *jcr, char *old, int len)
 317 {
 318    int l;
 319    int max = len*2;           /* TODO: too big, should be *4/3 */
 320
 321    esc_obj = check_pool_memory_size(esc_obj, max);
 322    l = bin_to_base64(esc_obj, max, old, len, true);
 323    esc_obj[l] = 0;
 324    ASSERT(l < max);    /* TODO: add check for l */
 325
 326    return esc_obj;
 327 }
 328
 329 /*
 330  * Unescape binary object so that SQLIte is happy
 331  *
 332  * TODO: need to be implemented (escape \0)
 333  */
 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    base64_to_bin(*dest, expected_len+1, from, strlen(from));
 345    *dest_len = 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_result_handler(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_result_handler,
 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    sql_free_result();
 486    if (m_sqlite_errmsg) {
 487       sqlite3_free(m_sqlite_errmsg);
 488       m_sqlite_errmsg = NULL;
 489    }
 490
 491    stat = sqlite3_get_table(m_db_handle, (char *)query, &m_result,
 492                             &m_num_rows, &m_num_fields, &m_sqlite_errmsg);
 493
 494    m_row_number = 0;               /* no row fetched */
 495    if (stat != 0) {                   /* something went wrong */
 496       m_num_rows = m_num_fields = 0;
 497       Dmsg0(500, "sql_query finished\n");
 498    } else {
 499       Dmsg0(500, "sql_query finished\n");
 500       retval = true;
 501    }
 502    return retval;
 503 }
 504
 505 void B_DB_SQLITE::sql_free_result(void)
 506 {
 507    db_lock(this);
 508    if (m_fields) {
 509       free(m_fields);
 510       m_fields = NULL;
 511    }
 512    if (m_result) {
 513       sqlite3_free_table(m_result);
 514       m_result = NULL;
 515    }
 516    m_col_names = NULL;
 517    m_num_rows = m_num_fields = 0;
 518    db_unlock(this);
 519 }
 520
 521 /*
 522  * Fetch one row at a time
 523  */
 524 SQL_ROW B_DB_SQLITE::sql_fetch_row(void)
 525 {
 526    if (!m_result || (m_row_number >= m_num_rows)) {
 527       return NULL;
 528    }
 529    m_row_number++;
 530    return &m_result[m_num_fields * m_row_number];
 531 }
 532
 533 const char *B_DB_SQLITE::sql_strerror(void)
 534 {
 535    return m_sqlite_errmsg ? m_sqlite_errmsg : "unknown";
 536 }
 537
 538 void B_DB_SQLITE::sql_data_seek(int row)
 539 {
 540    /*
 541     * Set the row number to be returned on the next call to sql_fetch_row
 542     */
 543    m_row_number = row;
 544 }
 545
 546 int B_DB_SQLITE::sql_affected_rows(void)
 547 {
 548    return sqlite3_changes(m_db_handle);
 549 }
 550
 551 uint64_t B_DB_SQLITE::sql_insert_autokey_record(const char *query, const char *table_name)
 552 {
 553    /*
 554     * First execute the insert query and then retrieve the currval.
 555     */
 556    if (!sql_query(query)) {
 557       return 0;
 558    }
 559
 560    m_num_rows = sql_affected_rows();
 561    if (m_num_rows != 1) {
 562       return 0;
 563    }
 564
 565    changes++;
 566
 567    return sqlite3_last_insert_rowid(m_db_handle);
 568 }
 569
 570 SQL_FIELD *B_DB_SQLITE::sql_fetch_field(void)
 571 {
 572    int i, j, len;
 573
 574    /* We are in the middle of a db_sql_query and we want to get fields info */
 575    if (m_col_names != NULL) {
 576       if (m_num_fields > m_field_number) {
 577          m_sql_field.name = m_col_names[m_field_number];
 578          /* We don't have the maximum field length, so we can use 80 as
 579           * estimation.
 580           */
 581          len = MAX(cstrlen(m_sql_field.name), 80/m_num_fields);
 582          m_sql_field.max_length = len;
 583
 584          m_field_number++;
 585          m_sql_field.type = 0;  /* not numeric */
 586          m_sql_field.flags = 1; /* not null */
 587          return &m_sql_field;
 588       } else {                  /* too much fetch_field() */
 589          return NULL;
 590       }
 591    }
 592
 593    /* We are after a sql_query() that stores the result in m_results */
 594    if (!m_fields || m_fields_size < m_num_fields) {
 595       if (m_fields) {
 596          free(m_fields);
 597          m_fields = NULL;
 598       }
 599       Dmsg1(500, "allocating space for %d fields\n", m_num_fields);
 600       m_fields = (SQL_FIELD *)malloc(sizeof(SQL_FIELD) * m_num_fields);
 601       m_fields_size = m_num_fields;
 602
 603       for (i = 0; i < m_num_fields; i++) {
 604          Dmsg1(500, "filling field %d\n", i);
 605          m_fields[i].name = m_result[i];
 606          m_fields[i].max_length = cstrlen(m_fields[i].name);
 607          for (j = 1; j <= m_num_rows; j++) {
 608             if (m_result[i + m_num_fields * j]) {
 609                len = (uint32_t)cstrlen(m_result[i + m_num_fields * j]);
 610             } else {
 611                len = 0;
 612             }
 613             if (len > m_fields[i].max_length) {
 614                m_fields[i].max_length = len;
 615             }
 616          }
 617          m_fields[i].type = 0;
 618          m_fields[i].flags = 1;        /* not null */
 619
 620          Dmsg4(500, "sql_fetch_field finds field '%s' has length='%d' type='%d' and IsNull=%d\n",
 621                m_fields[i].name, m_fields[i].max_length, m_fields[i].type, m_fields[i].flags);
 622       }
 623    }
 624
 625    /*
 626     * Increment field number for the next time around
 627     */
 628    return &m_fields[m_field_number++];
 629 }
 630
 631 bool B_DB_SQLITE::sql_field_is_not_null(int field_type)
 632 {
 633    switch (field_type) {
 634    case 1:
 635       return true;
 636    default:
 637       return false;
 638    }
 639 }
 640
 641 bool B_DB_SQLITE::sql_field_is_numeric(int field_type)
 642 {
 643    switch (field_type) {
 644    case 1:
 645       return true;
 646    default:
 647       return false;
 648    }
 649 }
 650
 651 /*
 652  * Returns true if OK
 653  *         false if failed
 654  */
 655 bool B_DB_SQLITE::sql_batch_start(JCR *jcr)
 656 {
 657    bool retval;
 658
 659    db_lock(this);
 660    retval = sql_query("CREATE TEMPORARY TABLE batch ("
 661                               "FileIndex integer,"
 662                               "JobId integer,"
 663                               "Path blob,"
 664                               "Name blob,"
 665                               "LStat tinyblob,"
 666                               "MD5 tinyblob,"
 667                               "DeltaSeq integer)");
 668    db_unlock(this);
 669
 670    return retval;
 671 }
 672
 673 /* set error to something to abort operation */
 674 /*
 675  * Returns true if OK
 676  *         false if failed
 677  */
 678 bool B_DB_SQLITE::sql_batch_end(JCR *jcr, const char *error)
 679 {
 680    m_status = 0;
 681
 682    return true;
 683 }
 684
 685 /*
 686  * Returns true if OK
 687  *         false if failed
 688  */
 689 bool B_DB_SQLITE::sql_batch_insert(JCR *jcr, ATTR_DBR *ar)
 690 {
 691    const char *digest;
 692    char ed1[50];
 693
 694    esc_name = check_pool_memory_size(esc_name, fnl*2+1);
 695    db_escape_string(jcr, esc_name, fname, fnl);
 696
 697    esc_path = check_pool_memory_size(esc_path, pnl*2+1);
 698    db_escape_string(jcr, esc_path, path, pnl);
 699
 700    if (ar->Digest == NULL || ar->Digest[0] == 0) {
 701       digest = "0";
 702    } else {
 703       digest = ar->Digest;
 704    }
 705
 706    Mmsg(cmd, "INSERT INTO batch VALUES "
 707         "(%u,%s,'%s','%s','%s','%s',%u)",
 708         ar->FileIndex, edit_int64(ar->JobId,ed1), esc_path,
 709         esc_name, ar->attr, digest, ar->DeltaSeq);
 710
 711    return sql_query(cmd);
 712 }
 713
 714 /*
 715  * Initialize database data structure. In principal this should
 716  * never have errors, or it is really fatal.
 717  */
 718 B_DB *db_init_database(JCR *jcr, const char *db_driver, const char *db_name,
 719                        const char *db_user, const char *db_password,
 720                        const char *db_address, int db_port,
 721                        const char *db_socket, bool mult_db_connections,
 722                        bool disable_batch_insert)
 723 {
 724    B_DB *mdb = NULL;
 725
 726    P(mutex);                          /* lock DB queue */
 727    /*
 728     * Look to see if DB already open
 729     */
 730    if (db_list && !mult_db_connections) {
 731       foreach_dlist(mdb, db_list) {
 732          if (mdb->db_match_database(db_driver, db_name, db_address, db_port)) {
 733             Dmsg1(300, "DB REopen %s\n", db_name);
 734             mdb->increment_refcount();
 735             goto bail_out;
 736          }
 737       }
 738    }
 739    Dmsg0(300, "db_init_database first time\n");
 740    mdb = New(B_DB_SQLITE(jcr, db_driver, db_name, db_user, db_password,
 741                          db_address, db_port, db_socket, mult_db_connections,
 742                          disable_batch_insert));
 743
 744 bail_out:
 745    V(mutex);
 746    return mdb;
 747 }
 748
 749 #endif /* HAVE_SQLITE3 */