]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/sqlite.c
Fix merge conflict leftover
[bacula/bacula] / bacula / src / cats / sqlite.c
1 /*
2    Bacula® - The Network Backup Solution
3
4    Copyright (C) 2000-2007 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 two of the GNU 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 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  *    Version $Id$
34  */
35
36
37
38 /* The following is necessary so that we do not include
39  * the dummy external definition of DB.
40  */
41 #define __SQL_C                       /* indicate that this is sql.c */
42
43 #include "bacula.h"
44 #include "cats.h"
45
46 #if    HAVE_SQLITE || HAVE_SQLITE3
47
48 /* -----------------------------------------------------------------------
49  *
50  *    SQLite dependent defines and subroutines
51  *
52  * -----------------------------------------------------------------------
53  */
54
55 /* List of open databases */
56 static BQUEUE db_list = {&db_list, &db_list};
57
58 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
59
60 int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
61
62 /*
63  * Retrieve database type
64  */
65 const char *
66 db_get_type(void)
67 {
68 #ifdef HAVE_SQLITE3
69    return "SQLite3";
70 #else
71    return "SQLite";
72 #endif
73 }
74
75 /*
76  * When using mult_db_connections = 1, 
77  * sqlite can be BUSY. We just need sleep a little in this case.
78  */
79
80 #ifdef HAVE_SQLITE3
81 static int my_busy_handler(void *arg, int calls)
82 {
83    bmicrosleep(0, 500);
84    return 1;
85 }
86 #else
87 static int my_busy_handler(void *arg, const char* p, int calls)
88 {
89    bmicrosleep(0, 500);
90    return 1;
91 }
92 #endif
93
94
95 /*
96  * Initialize database data structure. In principal this should
97  * never have errors, or it is really fatal.
98  */
99 B_DB *
100 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
101                  const char *db_address, int db_port, const char *db_socket,
102                  int mult_db_connections)
103 {
104    B_DB *mdb;
105
106    P(mutex);                          /* lock DB queue */
107    /* Look to see if DB already open */
108    if (!mult_db_connections) {
109       for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
110          if (bstrcmp(mdb->db_name, db_name) &&
111              bstrcmp(mdb->db_address, db_address) &&
112              mdb->db_port == db_port) {
113             Dmsg2(300, "DB REopen %d %s\n", mdb->ref_count, db_name);
114             mdb->ref_count++;
115             V(mutex);
116             return mdb;                  /* already open */
117          }
118       }
119    }
120    Dmsg0(300, "db_open first time\n");
121    mdb = (B_DB *) malloc(sizeof(B_DB));
122    memset(mdb, 0, sizeof(B_DB));
123    mdb->db_name = bstrdup(db_name);
124    mdb->have_insert_id = true;
125    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
126    *mdb->errmsg = 0;
127    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
128    mdb->cached_path = get_pool_memory(PM_FNAME);
129    mdb->cached_path_id = 0;
130    mdb->ref_count = 1;
131    mdb->fname = get_pool_memory(PM_FNAME);
132    mdb->path = get_pool_memory(PM_FNAME);
133    mdb->esc_name = get_pool_memory(PM_FNAME);
134    mdb->esc_path = get_pool_memory(PM_FNAME);
135    mdb->allow_transactions = mult_db_connections;
136    qinsert(&db_list, &mdb->bq);            /* put db in list */
137    V(mutex);
138    return mdb;
139 }
140
141 /*
142  * Now actually open the database.  This can generate errors,
143  * which are returned in the errmsg
144  *
145  * DO NOT close the database or free(mdb) here !!!!
146  */
147 int
148 db_open_database(JCR *jcr, B_DB *mdb)
149 {
150    char *db_name;
151    int len;
152    struct stat statbuf;
153    int errstat;
154    int retry = 0;
155
156    P(mutex);
157    if (mdb->connected) {
158       V(mutex);
159       return 1;
160    }
161    mdb->connected = FALSE;
162
163    if ((errstat=rwl_init(&mdb->lock)) != 0) {
164       berrno be;
165       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
166             be.bstrerror(errstat));
167       V(mutex);
168       return 0;
169    }
170
171    /* open the database */
172    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
173    db_name = (char *)malloc(len);
174    strcpy(db_name, working_directory);
175    strcat(db_name, "/");
176    strcat(db_name, mdb->db_name);
177    strcat(db_name, ".db");
178    if (stat(db_name, &statbuf) != 0) {
179       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
180          db_name);
181       free(db_name);
182       V(mutex);
183       return 0;
184    }
185
186    for (mdb->db=NULL; !mdb->db && retry++ < 10; ) {
187 #ifdef HAVE_SQLITE3
188       int stat = sqlite3_open(db_name, &mdb->db);
189       if (stat != SQLITE_OK) {
190          mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db); 
191          sqlite3_close(mdb->db);
192          mdb->db = NULL;
193       } else {
194          mdb->sqlite_errmsg = NULL;
195       }
196 #else
197       mdb->db = sqlite_open(
198            db_name,                      /* database name */
199            644,                          /* mode */
200            &mdb->sqlite_errmsg);         /* error message */
201 #endif
202
203       Dmsg0(300, "sqlite_open\n");
204       if (!mdb->db) {
205          bmicrosleep(1, 0);
206       }
207    }
208    if (mdb->db == NULL) {
209       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
210          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
211       free(db_name);
212       V(mutex);
213       return 0;
214    }       
215    mdb->connected = true;
216    free(db_name);
217
218    /* set busy handler to wait when we use mult_db_connections = 1 */
219 #ifdef HAVE_SQLITE3
220    sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
221 #else
222    sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
223 #endif
224
225 #if  defined(HAVE_SQLITE3) && defined(SQLITE3_INIT_QUERY)
226    db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
227 #endif
228
229    if (!check_tables_version(jcr, mdb)) {
230       V(mutex);
231       return 0;
232    }
233
234
235    V(mutex);
236    return 1;
237 }
238
239 void
240 db_close_database(JCR *jcr, B_DB *mdb)
241 {
242    if (!mdb) {
243       return;
244    }
245    db_end_transaction(jcr, mdb);
246    P(mutex);
247    sql_free_result(mdb);
248    mdb->ref_count--;
249    if (mdb->ref_count == 0) {
250       qdchain(&mdb->bq);
251       if (mdb->connected && mdb->db) {
252          sqlite_close(mdb->db);
253       }
254       rwl_destroy(&mdb->lock);
255       free_pool_memory(mdb->errmsg);
256       free_pool_memory(mdb->cmd);
257       free_pool_memory(mdb->cached_path);
258       free_pool_memory(mdb->fname);
259       free_pool_memory(mdb->path);
260       free_pool_memory(mdb->esc_name);
261       free_pool_memory(mdb->esc_path);
262       if (mdb->db_name) {
263          free(mdb->db_name);
264       }
265       free(mdb);
266    }
267    V(mutex);
268 }
269
270 void db_thread_cleanup()
271 {
272 #ifdef HAVE_SQLITE3
273    sqlite3_thread_cleanup();
274 #endif
275 }
276
277 /*
278  * Return the next unique index (auto-increment) for
279  * the given table.  Return 0 on error.
280  */
281 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
282 {
283    strcpy(index, "NULL");
284    return 1;
285 }
286
287
288 /*
289  * Escape strings so that SQLite is happy
290  *
291  *   NOTE! len is the length of the old string. Your new
292  *         string must be long enough (max 2*old+1) to hold
293  *         the escaped output.
294  */
295 void
296 db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
297 {
298    char *n, *o;
299
300    n = snew;
301    o = old;
302    while (len--) {
303       switch (*o) {
304       case '\'':
305          *n++ = '\'';
306          *n++ = '\'';
307          o++;
308          break;
309       case 0:
310          *n++ = '\\';
311          *n++ = 0;
312          o++;
313          break;
314       default:
315          *n++ = *o++;
316          break;
317       }
318    }
319    *n = 0;
320 }
321
322 struct rh_data {
323    DB_RESULT_HANDLER *result_handler;
324    void *ctx;
325 };
326
327 /*
328  * Convert SQLite's callback into Bacula DB callback
329  */
330 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
331 {
332    struct rh_data *rh_data = (struct rh_data *)arh_data;
333
334    if (rh_data->result_handler) {
335       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
336    }
337    return 0;
338 }
339
340 /*
341  * Submit a general SQL command (cmd), and for each row returned,
342  *  the sqlite_handler is called with the ctx.
343  */
344 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
345 {
346    struct rh_data rh_data;
347    int stat;
348
349    db_lock(mdb);
350    if (mdb->sqlite_errmsg) {
351 #ifdef HAVE_SQLITE3
352       sqlite3_free(mdb->sqlite_errmsg);
353 #else
354       actuallyfree(mdb->sqlite_errmsg);
355 #endif
356       mdb->sqlite_errmsg = NULL;
357    }
358    rh_data.result_handler = result_handler;
359    rh_data.ctx = ctx;
360    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
361    if (stat != 0) {
362       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
363       db_unlock(mdb);
364       return false;
365    }
366    db_unlock(mdb);
367    return true;
368 }
369
370 /*
371  * Submit a sqlite query and retrieve all the data
372  */
373 int my_sqlite_query(B_DB *mdb, const char *cmd)
374 {
375    int stat;
376
377    my_sqlite_free_table(mdb);
378    if (mdb->sqlite_errmsg) {
379 #ifdef HAVE_SQLITE3
380       sqlite3_free(mdb->sqlite_errmsg);
381 #else
382       actuallyfree(mdb->sqlite_errmsg);
383 #endif
384       mdb->sqlite_errmsg = NULL;
385    }
386    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
387             &mdb->sqlite_errmsg);
388    mdb->row = 0;                      /* row fetched */
389    return stat;
390 }
391
392 /* Fetch one row at a time */
393 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
394 {
395    if (mdb->row >= mdb->nrow) {
396       return NULL;
397    }
398    mdb->row++;
399    return &mdb->result[mdb->ncolumn * mdb->row];
400 }
401
402 void my_sqlite_free_table(B_DB *mdb)
403 {
404    int i;
405
406    if (mdb->fields_defined) {
407       for (i=0; i < sql_num_fields(mdb); i++) {
408          free(mdb->fields[i]);
409       }
410       free(mdb->fields);
411       mdb->fields_defined = false;
412    }
413    if (mdb->result) {
414       sqlite_free_table(mdb->result);
415       mdb->result = NULL;
416    }
417    mdb->nrow = mdb->ncolumn = 0;
418 }
419
420 void my_sqlite_field_seek(B_DB *mdb, int field)
421 {
422    int i, j;
423    if (mdb->result == NULL) {
424       return;
425    }
426    /* On first call, set up the fields */
427    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
428       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
429       for (i=0; i < sql_num_fields(mdb); i++) {
430          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
431          mdb->fields[i]->name = mdb->result[i];
432          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
433          mdb->fields[i]->max_length = mdb->fields[i]->length;
434          for (j=1; j <= mdb->nrow; j++) {
435             int len;
436             if (mdb->result[i + mdb->ncolumn *j]) {
437                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
438             } else {
439                len = 0;
440             }
441             if (len > mdb->fields[i]->max_length) {
442                mdb->fields[i]->max_length = len;
443             }
444          }
445          mdb->fields[i]->type = 0;
446          mdb->fields[i]->flags = 1;        /* not null */
447       }
448       mdb->fields_defined = true;
449    }
450    if (field > sql_num_fields(mdb) - 1) {
451       field = sql_num_fields(mdb) - 1;
452     }
453     mdb->field = field;
454 }
455
456 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
457 {
458    if (mdb->fields_defined && mdb->field < sql_num_fields(mdb)) {
459       return mdb->fields[mdb->field++];
460    } else {
461       mdb->field = 0;
462       return NULL;
463    }
464 }
465
466 #ifdef HAVE_BATCH_FILE_INSERT
467 const char *my_sqlite_batch_lock_query = "BEGIN";
468 const char *my_sqlite_batch_unlock_query = "COMMIT";
469
470 const char *my_sqlite_batch_fill_path_query = 
471    "INSERT INTO Path (Path)" 
472    " SELECT DISTINCT Path FROM batch"
473    " EXCEPT SELECT Path FROM Path";
474
475 const char *my_sqlite_batch_fill_filename_query = 
476    "INSERT INTO Filename (Name)"
477    " SELECT DISTINCT Name FROM batch "
478    " EXCEPT SELECT Name FROM Filename";
479 #endif /* HAVE_BATCH_FILE_INSERT */
480
481
482 #endif /* HAVE_SQLITE */