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 * Initialize database data structure. In principal this should
74 * never have errors, or it is really fatal.
77 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
78 const char *db_address, int db_port, const char *db_socket,
79 int mult_db_connections)
83 P(mutex); /* lock DB queue */
84 /* Look to see if DB already open */
85 if (!mult_db_connections) {
86 for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
87 if (bstrcmp(mdb->db_name, db_name) &&
88 bstrcmp(mdb->db_address, db_address) &&
89 mdb->db_port == db_port) {
90 Dmsg2(300, "DB REopen %d %s\n", mdb->ref_count, db_name);
93 return mdb; /* already open */
97 Dmsg0(300, "db_open first time\n");
98 mdb = (B_DB *) malloc(sizeof(B_DB));
99 memset(mdb, 0, sizeof(B_DB));
100 mdb->db_name = bstrdup(db_name);
101 mdb->have_insert_id = TRUE;
102 mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
104 mdb->cmd = get_pool_memory(PM_EMSG); /* get command buffer */
105 mdb->cached_path = get_pool_memory(PM_FNAME);
106 mdb->cached_path_id = 0;
108 mdb->fname = get_pool_memory(PM_FNAME);
109 mdb->path = get_pool_memory(PM_FNAME);
110 mdb->esc_name = get_pool_memory(PM_FNAME);
111 mdb->esc_name2 = get_pool_memory(PM_FNAME);
112 mdb->allow_transactions = mult_db_connections;
113 qinsert(&db_list, &mdb->bq); /* put db in list */
119 * Now actually open the database. This can generate errors,
120 * which are returned in the errmsg
122 * DO NOT close the database or free(mdb) here !!!!
125 db_open_database(JCR *jcr, B_DB *mdb)
133 if (mdb->connected) {
137 mdb->connected = FALSE;
139 if ((errstat=rwl_init(&mdb->lock)) != 0) {
140 Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
146 /* open the database */
147 len = strlen(working_directory) + strlen(mdb->db_name) + 5;
148 db_name = (char *)malloc(len);
149 strcpy(db_name, working_directory);
150 strcat(db_name, "/");
151 strcat(db_name, mdb->db_name);
152 strcat(db_name, ".db");
153 if (stat(db_name, &statbuf) != 0) {
154 Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
162 int stat = sqlite3_open(db_name, &mdb->db);
163 if (stat != SQLITE_OK) {
164 mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
165 sqlite3_close(mdb->db);
168 mdb->sqlite_errmsg = NULL;
172 mdb->db = sqlite_open(
173 db_name, /* database name */
175 &mdb->sqlite_errmsg); /* error message */
178 Dmsg0(300, "sqlite_open\n");
180 if (mdb->db == NULL) {
181 Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
182 db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
188 if (!check_tables_version(jcr, mdb)) {
193 mdb->connected = true;
199 db_close_database(JCR *jcr, B_DB *mdb)
204 db_end_transaction(jcr, mdb);
207 if (mdb->ref_count == 0) {
209 if (mdb->connected && mdb->db) {
210 sqlite_close(mdb->db);
212 rwl_destroy(&mdb->lock);
213 free_pool_memory(mdb->errmsg);
214 free_pool_memory(mdb->cmd);
215 free_pool_memory(mdb->cached_path);
216 free_pool_memory(mdb->fname);
217 free_pool_memory(mdb->path);
218 free_pool_memory(mdb->esc_name);
219 free_pool_memory(mdb->esc_name2);
229 * Return the next unique index (auto-increment) for
230 * the given table. Return 0 on error.
232 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
240 "SELECT id FROM NextId WHERE TableName=\"%s\"", table);
241 if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
242 Mmsg(mdb->errmsg, _("next_index query error: ERR=%s\n"), sql_strerror(mdb));
246 if ((row = sql_fetch_row(mdb)) == NULL) {
247 Mmsg(mdb->errmsg, _("Error fetching index: ERR=%s\n"), sql_strerror(mdb));
251 bstrncpy(index, row[0], 28);
252 sql_free_result(mdb);
255 "UPDATE NextId SET id=id+1 WHERE TableName=\"%s\"", table);
256 if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
257 Mmsg(mdb->errmsg, _("next_index update error: ERR=%s\n"), sql_strerror(mdb));
261 sql_free_result(mdb);
265 strcpy(index, "NULL");
271 * Escape strings so that SQLite is happy
273 * NOTE! len is the length of the old string. Your new
274 * string must be long enough (max 2*old+1) to hold
275 * the escaped output.
278 db_escape_string(char *snew, char *old, int len)
305 DB_RESULT_HANDLER *result_handler;
310 * Convert SQLite's callback into Bacula DB callback
312 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
314 struct rh_data *rh_data = (struct rh_data *)arh_data;
316 if (rh_data->result_handler) {
317 (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
323 * Submit a general SQL command (cmd), and for each row returned,
324 * the sqlite_handler is called with the ctx.
326 int db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
328 struct rh_data rh_data;
332 if (mdb->sqlite_errmsg) {
334 sqlite3_free(mdb->sqlite_errmsg);
336 actuallyfree(mdb->sqlite_errmsg);
338 mdb->sqlite_errmsg = NULL;
340 rh_data.result_handler = result_handler;
342 stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
344 Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
353 * Submit a sqlite query and retrieve all the data
355 int my_sqlite_query(B_DB *mdb, const char *cmd)
359 if (mdb->sqlite_errmsg) {
361 sqlite3_free(mdb->sqlite_errmsg);
363 actuallyfree(mdb->sqlite_errmsg);
365 mdb->sqlite_errmsg = NULL;
367 stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
368 &mdb->sqlite_errmsg);
369 mdb->row = 0; /* row fetched */
373 /* Fetch one row at a time */
374 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
376 if (mdb->row >= mdb->nrow) {
380 return &mdb->result[mdb->ncolumn * mdb->row];
383 void my_sqlite_free_table(B_DB *mdb)
387 if (mdb->fields_defined) {
388 for (i=0; i < sql_num_fields(mdb); i++) {
389 free(mdb->fields[i]);
392 mdb->fields_defined = false;
394 sqlite_free_table(mdb->result);
395 mdb->nrow = mdb->ncolumn = 0;
398 void my_sqlite_field_seek(B_DB *mdb, int field)
401 if (mdb->result == NULL) {
404 /* On first call, set up the fields */
405 if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
406 mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
407 for (i=0; i < sql_num_fields(mdb); i++) {
408 mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
409 mdb->fields[i]->name = mdb->result[i];
410 mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
411 mdb->fields[i]->max_length = mdb->fields[i]->length;
412 for (j=1; j <= mdb->nrow; j++) {
414 if (mdb->result[i + mdb->ncolumn *j]) {
415 len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
419 if (len > mdb->fields[i]->max_length) {
420 mdb->fields[i]->max_length = len;
423 mdb->fields[i]->type = 0;
424 mdb->fields[i]->flags = 1; /* not null */
426 mdb->fields_defined = TRUE;
428 if (field > sql_num_fields(mdb)) {
429 field = sql_num_fields(mdb);
435 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
437 return mdb->fields[mdb->field++];
440 char *my_sqlite_batch_lock_query = "BEGIN";
441 char *my_sqlite_batch_unlock_query = "COMMIT";
442 char *my_sqlite_batch_fill_path_query = "INSERT INTO Path (Path) "
443 " SELECT DISTINCT Path FROM batch "
444 " EXCEPT SELECT Path FROM Path ";
446 char *my_sqlite_batch_fill_filename_query = "INSERT INTO Filename (Name) "
447 " SELECT DISTINCT Name FROM batch "
448 " EXCEPT SELECT Name FROM Filename ";
452 #endif /* HAVE_SQLITE */