2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2007 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 plus additions
11 that are listed in the file LICENSE.
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 John Walker.
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;
60 int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
64 * Retrieve database type
73 * When using mult_db_connections = 1,
74 * sqlite can be BUSY. We just need sleep a little in this case.
78 static int my_busy_handler(void *arg, int calls)
84 static int my_busy_handler(void *arg, const char* p, int calls)
93 * Initialize database data structure. In principal this should
94 * never have errors, or it is really fatal.
97 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
98 const char *db_address, int db_port, const char *db_socket,
99 int mult_db_connections)
103 P(mutex); /* lock DB queue */
104 /* Look to see if DB already open */
105 if (!mult_db_connections) {
106 for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
107 if (bstrcmp(mdb->db_name, db_name) &&
108 bstrcmp(mdb->db_address, db_address) &&
109 mdb->db_port == db_port) {
110 Dmsg2(300, "DB REopen %d %s\n", mdb->ref_count, db_name);
113 return mdb; /* already open */
117 Dmsg0(300, "db_open first time\n");
118 mdb = (B_DB *) malloc(sizeof(B_DB));
119 memset(mdb, 0, sizeof(B_DB));
120 mdb->db_name = bstrdup(db_name);
121 mdb->have_insert_id = TRUE;
122 mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
124 mdb->cmd = get_pool_memory(PM_EMSG); /* get command buffer */
125 mdb->cached_path = get_pool_memory(PM_FNAME);
126 mdb->cached_path_id = 0;
128 mdb->fname = get_pool_memory(PM_FNAME);
129 mdb->path = get_pool_memory(PM_FNAME);
130 mdb->esc_name = get_pool_memory(PM_FNAME);
131 mdb->esc_path = get_pool_memory(PM_FNAME);
132 mdb->allow_transactions = mult_db_connections;
133 qinsert(&db_list, &mdb->bq); /* put db in list */
139 * Now actually open the database. This can generate errors,
140 * which are returned in the errmsg
142 * DO NOT close the database or free(mdb) here !!!!
145 db_open_database(JCR *jcr, B_DB *mdb)
153 if (mdb->connected) {
157 mdb->connected = FALSE;
159 if ((errstat=rwl_init(&mdb->lock)) != 0) {
160 Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
166 /* open the database */
167 len = strlen(working_directory) + strlen(mdb->db_name) + 5;
168 db_name = (char *)malloc(len);
169 strcpy(db_name, working_directory);
170 strcat(db_name, "/");
171 strcat(db_name, mdb->db_name);
172 strcat(db_name, ".db");
173 if (stat(db_name, &statbuf) != 0) {
174 Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
182 int stat = sqlite3_open(db_name, &mdb->db);
183 if (stat != SQLITE_OK) {
184 mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
185 sqlite3_close(mdb->db);
188 mdb->sqlite_errmsg = NULL;
192 mdb->db = sqlite_open(
193 db_name, /* database name */
195 &mdb->sqlite_errmsg); /* error message */
198 Dmsg0(300, "sqlite_open\n");
200 if (mdb->db == NULL) {
201 Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
202 db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
207 mdb->connected = true;
209 if (!check_tables_version(jcr, mdb)) {
214 /* set busy handler to wait when we use mult_db_connections = 1 */
216 sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
218 sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
226 db_close_database(JCR *jcr, B_DB *mdb)
231 db_end_transaction(jcr, mdb);
233 sql_free_result(mdb);
235 if (mdb->ref_count == 0) {
237 if (mdb->connected && mdb->db) {
238 sqlite_close(mdb->db);
240 rwl_destroy(&mdb->lock);
241 free_pool_memory(mdb->errmsg);
242 free_pool_memory(mdb->cmd);
243 free_pool_memory(mdb->cached_path);
244 free_pool_memory(mdb->fname);
245 free_pool_memory(mdb->path);
246 free_pool_memory(mdb->esc_name);
247 free_pool_memory(mdb->esc_path);
256 void db_thread_cleanup()
260 * Return the next unique index (auto-increment) for
261 * the given table. Return 0 on error.
263 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
271 "SELECT id FROM NextId WHERE TableName=\"%s\"", table);
272 if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
273 Mmsg(mdb->errmsg, _("next_index query error: ERR=%s\n"), sql_strerror(mdb));
277 if ((row = sql_fetch_row(mdb)) == NULL) {
278 Mmsg(mdb->errmsg, _("Error fetching index: ERR=%s\n"), sql_strerror(mdb));
282 bstrncpy(index, row[0], 28);
283 sql_free_result(mdb);
286 "UPDATE NextId SET id=id+1 WHERE TableName=\"%s\"", table);
287 if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
288 Mmsg(mdb->errmsg, _("next_index update error: ERR=%s\n"), sql_strerror(mdb));
292 sql_free_result(mdb);
296 strcpy(index, "NULL");
302 * Escape strings so that SQLite is happy
304 * NOTE! len is the length of the old string. Your new
305 * string must be long enough (max 2*old+1) to hold
306 * the escaped output.
309 db_escape_string(char *snew, char *old, int len)
336 DB_RESULT_HANDLER *result_handler;
341 * Convert SQLite's callback into Bacula DB callback
343 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
345 struct rh_data *rh_data = (struct rh_data *)arh_data;
347 if (rh_data->result_handler) {
348 (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
354 * Submit a general SQL command (cmd), and for each row returned,
355 * the sqlite_handler is called with the ctx.
357 int db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
359 struct rh_data rh_data;
363 if (mdb->sqlite_errmsg) {
365 sqlite3_free(mdb->sqlite_errmsg);
367 actuallyfree(mdb->sqlite_errmsg);
369 mdb->sqlite_errmsg = NULL;
371 rh_data.result_handler = result_handler;
373 stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
375 Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
384 * Submit a sqlite query and retrieve all the data
386 int my_sqlite_query(B_DB *mdb, const char *cmd)
390 my_sqlite_free_table(mdb);
391 if (mdb->sqlite_errmsg) {
393 sqlite3_free(mdb->sqlite_errmsg);
395 actuallyfree(mdb->sqlite_errmsg);
397 mdb->sqlite_errmsg = NULL;
399 stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
400 &mdb->sqlite_errmsg);
401 mdb->row = 0; /* row fetched */
405 /* Fetch one row at a time */
406 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
408 if (mdb->row >= mdb->nrow) {
412 return &mdb->result[mdb->ncolumn * mdb->row];
415 void my_sqlite_free_table(B_DB *mdb)
419 if (mdb->fields_defined) {
420 for (i=0; i < sql_num_fields(mdb); i++) {
421 free(mdb->fields[i]);
424 mdb->fields_defined = false;
427 sqlite_free_table(mdb->result);
430 mdb->nrow = mdb->ncolumn = 0;
433 void my_sqlite_field_seek(B_DB *mdb, int field)
436 if (mdb->result == NULL) {
439 /* On first call, set up the fields */
440 if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
441 mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
442 for (i=0; i < sql_num_fields(mdb); i++) {
443 mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
444 mdb->fields[i]->name = mdb->result[i];
445 mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
446 mdb->fields[i]->max_length = mdb->fields[i]->length;
447 for (j=1; j <= mdb->nrow; j++) {
449 if (mdb->result[i + mdb->ncolumn *j]) {
450 len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
454 if (len > mdb->fields[i]->max_length) {
455 mdb->fields[i]->max_length = len;
458 mdb->fields[i]->type = 0;
459 mdb->fields[i]->flags = 1; /* not null */
461 mdb->fields_defined = TRUE;
463 if (field > sql_num_fields(mdb)) {
464 field = sql_num_fields(mdb);
470 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
472 return mdb->fields[mdb->field++];
475 char *my_sqlite_batch_lock_query = "BEGIN";
476 char *my_sqlite_batch_unlock_query = "COMMIT";
477 char *my_sqlite_batch_fill_path_query = "INSERT INTO Path (Path) "
478 " SELECT DISTINCT Path FROM batch "
479 " EXCEPT SELECT Path FROM Path ";
481 char *my_sqlite_batch_fill_filename_query = "INSERT INTO Filename (Name) "
482 " SELECT DISTINCT Name FROM batch "
483 " EXCEPT SELECT Name FROM Filename ";
487 #endif /* HAVE_SQLITE */