2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2009 Free Software Foundation Europe e.V.
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 two of the GNU General Public
10 License as published by the Free Software Foundation and included
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.
18 You should have received a copy of the GNU 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
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.
29 * Bacula Catalog Database routines specific to SQLite
31 * Kern Sibbald, January 2002
38 /* The following is necessary so that we do not include
39 * the dummy external definition of DB.
41 #define __SQL_C /* indicate that this is sql.c */
46 #if HAVE_SQLITE || HAVE_SQLITE3
48 /* -----------------------------------------------------------------------
50 * SQLite dependent defines and subroutines
52 * -----------------------------------------------------------------------
55 /* List of open databases */
56 static BQUEUE db_list = {&db_list, &db_list};
58 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
61 * Retrieve database type
74 * When using mult_db_connections = 1,
75 * sqlite can be BUSY. We just need sleep a little in this case.
79 static int my_busy_handler(void *arg, int calls)
85 static int my_busy_handler(void *arg, const char* p, int calls)
94 * Initialize database data structure. In principal this should
95 * never have errors, or it is really fatal.
98 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
99 const char *db_address, int db_port, const char *db_socket,
100 int mult_db_connections)
104 P(mutex); /* lock DB queue */
105 /* Look to see if DB already open */
106 if (!mult_db_connections) {
107 for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
108 if (bstrcmp(mdb->db_name, db_name) &&
109 bstrcmp(mdb->db_address, db_address) &&
110 mdb->db_port == db_port) {
111 Dmsg2(300, "DB REopen %d %s\n", mdb->ref_count, db_name);
114 return mdb; /* already open */
118 Dmsg0(300, "db_open first time\n");
119 mdb = (B_DB *) malloc(sizeof(B_DB));
120 memset(mdb, 0, sizeof(B_DB));
121 mdb->db_name = bstrdup(db_name);
122 mdb->have_insert_id = true;
123 mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
125 mdb->cmd = get_pool_memory(PM_EMSG); /* get command buffer */
126 mdb->cached_path = get_pool_memory(PM_FNAME);
127 mdb->cached_path_id = 0;
129 mdb->fname = get_pool_memory(PM_FNAME);
130 mdb->path = get_pool_memory(PM_FNAME);
131 mdb->esc_name = get_pool_memory(PM_FNAME);
132 mdb->esc_path = get_pool_memory(PM_FNAME);
133 mdb->allow_transactions = mult_db_connections;
134 qinsert(&db_list, &mdb->bq); /* put db in list */
140 * Now actually open the database. This can generate errors,
141 * which are returned in the errmsg
143 * DO NOT close the database or free(mdb) here !!!!
146 db_open_database(JCR *jcr, B_DB *mdb)
155 if (mdb->connected) {
159 mdb->connected = FALSE;
161 if ((errstat=rwl_init(&mdb->lock)) != 0) {
163 Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
164 be.bstrerror(errstat));
169 /* open the database */
170 len = strlen(working_directory) + strlen(mdb->db_name) + 5;
171 db_name = (char *)malloc(len);
172 strcpy(db_name, working_directory);
173 strcat(db_name, "/");
174 strcat(db_name, mdb->db_name);
175 strcat(db_name, ".db");
176 if (stat(db_name, &statbuf) != 0) {
177 Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
184 for (mdb->db=NULL; !mdb->db && retry++ < 10; ) {
186 int stat = sqlite3_open(db_name, &mdb->db);
187 if (stat != SQLITE_OK) {
188 mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
189 sqlite3_close(mdb->db);
192 mdb->sqlite_errmsg = NULL;
195 mdb->db = sqlite_open(
196 db_name, /* database name */
198 &mdb->sqlite_errmsg); /* error message */
201 Dmsg0(300, "sqlite_open\n");
206 if (mdb->db == NULL) {
207 Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
208 db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
213 mdb->connected = true;
216 /* set busy handler to wait when we use mult_db_connections = 1 */
218 sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
220 sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
223 #if defined(HAVE_SQLITE3) && defined(SQLITE3_INIT_QUERY)
224 db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
227 if (!check_tables_version(jcr, mdb)) {
238 db_close_database(JCR *jcr, B_DB *mdb)
243 db_end_transaction(jcr, mdb);
245 sql_free_result(mdb);
247 if (mdb->ref_count == 0) {
249 if (mdb->connected && mdb->db) {
250 sqlite_close(mdb->db);
252 rwl_destroy(&mdb->lock);
253 free_pool_memory(mdb->errmsg);
254 free_pool_memory(mdb->cmd);
255 free_pool_memory(mdb->cached_path);
256 free_pool_memory(mdb->fname);
257 free_pool_memory(mdb->path);
258 free_pool_memory(mdb->esc_name);
259 free_pool_memory(mdb->esc_path);
268 void db_check_backend_thread_safe()
270 #ifdef HAVE_BATCH_FILE_INSERT
271 if (!sqlite3_threadsafe()) {
272 Emsg0(M_ABORT, 0, _("SQLite3 client library must be thread-safe "
273 "when using BatchMode.\n"));
278 void db_thread_cleanup()
281 sqlite3_thread_cleanup();
286 * Return the next unique index (auto-increment) for
287 * the given table. Return 0 on error.
289 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
291 strcpy(index, "NULL");
297 * Escape strings so that SQLite is happy
299 * NOTE! len is the length of the old string. Your new
300 * string must be long enough (max 2*old+1) to hold
301 * the escaped output.
304 db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
331 DB_RESULT_HANDLER *result_handler;
336 * Convert SQLite's callback into Bacula DB callback
338 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
340 struct rh_data *rh_data = (struct rh_data *)arh_data;
342 if (rh_data->result_handler) {
343 (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
349 * Submit a general SQL command (cmd), and for each row returned,
350 * the sqlite_handler is called with the ctx.
352 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
354 struct rh_data rh_data;
358 if (mdb->sqlite_errmsg) {
360 sqlite3_free(mdb->sqlite_errmsg);
362 actuallyfree(mdb->sqlite_errmsg);
364 mdb->sqlite_errmsg = NULL;
366 rh_data.result_handler = result_handler;
368 stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
369 if (stat != SQLITE_OK) {
370 Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
379 * Submit a sqlite query and retrieve all the data
381 int my_sqlite_query(B_DB *mdb, const char *cmd)
385 my_sqlite_free_table(mdb);
386 if (mdb->sqlite_errmsg) {
388 sqlite3_free(mdb->sqlite_errmsg);
390 actuallyfree(mdb->sqlite_errmsg);
392 mdb->sqlite_errmsg = NULL;
394 stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
395 &mdb->sqlite_errmsg);
396 mdb->row = 0; /* no row fetched yet */
397 if (stat != 0) { /* something went wrong */
398 mdb->nrow = mdb->ncolumn = 0;
403 /* Fetch one row at a time */
404 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
406 if (!mdb->result || (mdb->row >= mdb->nrow)) {
410 return &mdb->result[mdb->ncolumn * mdb->row];
413 void my_sqlite_free_table(B_DB *mdb)
417 if (mdb->fields_defined) {
418 for (i=0; i < sql_num_fields(mdb); i++) {
419 if (mdb->fields[i]) {
420 free(mdb->fields[i]);
421 mdb->fields[i] = NULL;
428 mdb->fields_defined = false;
431 sqlite_free_table(mdb->result);
434 mdb->nrow = mdb->ncolumn = 0;
437 void my_sqlite_field_seek(B_DB *mdb, int field)
440 if (mdb->result == NULL) {
444 /* On first call, set up the fields */
445 if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
446 mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
447 for (i=0; i < sql_num_fields(mdb); i++) {
448 mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
449 mdb->fields[i]->name = mdb->result[i];
450 mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
451 mdb->fields[i]->max_length = mdb->fields[i]->length;
452 for (j=1; j <= mdb->nrow; j++) {
454 if (mdb->result[i + mdb->ncolumn *j]) {
455 len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
459 if (len > mdb->fields[i]->max_length) {
460 mdb->fields[i]->max_length = len;
463 mdb->fields[i]->type = 0;
464 mdb->fields[i]->flags = 1; /* not null */
466 mdb->fields_defined = true;
468 if (sql_num_fields(mdb) <= 0) {
470 } else if (field > sql_num_fields(mdb) - 1) {
471 field = sql_num_fields(mdb) - 1;
476 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
478 if (mdb->fields_defined && mdb->field < sql_num_fields(mdb)) {
479 return mdb->fields[mdb->field++];
486 #ifdef HAVE_BATCH_FILE_INSERT
487 const char *my_sqlite_batch_lock_query = "BEGIN";
488 const char *my_sqlite_batch_unlock_query = "COMMIT";
490 const char *my_sqlite_batch_fill_path_query =
491 "INSERT INTO Path (Path)"
492 " SELECT DISTINCT Path FROM batch"
493 " EXCEPT SELECT Path FROM Path";
495 const char *my_sqlite_batch_fill_filename_query =
496 "INSERT INTO Filename (Name)"
497 " SELECT DISTINCT Name FROM batch "
498 " EXCEPT SELECT Name FROM Filename";
499 #endif /* HAVE_BATCH_FILE_INSERT */
502 #endif /* HAVE_SQLITE */