]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/sqlite.c
tweak comments
[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 /*
61  * Retrieve database type
62  */
63 const char *
64 db_get_type(void)
65 {
66 #ifdef HAVE_SQLITE3
67    return "SQLite3";
68 #else
69    return "SQLite";
70 #endif
71 }
72
73 /*
74  * When using mult_db_connections = 1, 
75  * sqlite can be BUSY. We just need sleep a little in this case.
76  */
77
78 #ifdef HAVE_SQLITE3
79 static int my_busy_handler(void *arg, int calls)
80 {
81    bmicrosleep(0, 500);
82    return 1;
83 }
84 #else
85 static int my_busy_handler(void *arg, const char* p, int calls)
86 {
87    bmicrosleep(0, 500);
88    return 1;
89 }
90 #endif
91
92
93 /*
94  * Initialize database data structure. In principal this should
95  * never have errors, or it is really fatal.
96  */
97 B_DB *
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)
101 {
102    B_DB *mdb;
103
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);
112             mdb->ref_count++;
113             V(mutex);
114             return mdb;                  /* already open */
115          }
116       }
117    }
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 */
124    *mdb->errmsg = 0;
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;
128    mdb->ref_count = 1;
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 */
135    V(mutex);
136    return mdb;
137 }
138
139 /*
140  * Now actually open the database.  This can generate errors,
141  * which are returned in the errmsg
142  *
143  * DO NOT close the database or free(mdb) here !!!!
144  */
145 int
146 db_open_database(JCR *jcr, B_DB *mdb)
147 {
148    char *db_name;
149    int len;
150    struct stat statbuf;
151    int errstat;
152    int retry = 0;
153
154    P(mutex);
155    if (mdb->connected) {
156       V(mutex);
157       return 1;
158    }
159    mdb->connected = FALSE;
160
161    if ((errstat=rwl_init(&mdb->lock)) != 0) {
162       berrno be;
163       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
164             be.bstrerror(errstat));
165       V(mutex);
166       return 0;
167    }
168
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"),
178          db_name);
179       free(db_name);
180       V(mutex);
181       return 0;
182    }
183
184    for (mdb->db=NULL; !mdb->db && retry++ < 10; ) {
185 #ifdef HAVE_SQLITE3
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);
190          mdb->db = NULL;
191       } else {
192          mdb->sqlite_errmsg = NULL;
193       }
194 #else
195       mdb->db = sqlite_open(
196            db_name,                      /* database name */
197            644,                          /* mode */
198            &mdb->sqlite_errmsg);         /* error message */
199 #endif
200
201       Dmsg0(300, "sqlite_open\n");
202       if (!mdb->db) {
203          bmicrosleep(1, 0);
204       }
205    }
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"));
209       free(db_name);
210       V(mutex);
211       return 0;
212    }       
213    mdb->connected = true;
214    free(db_name);
215
216    /* set busy handler to wait when we use mult_db_connections = 1 */
217 #ifdef HAVE_SQLITE3
218    sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
219 #else
220    sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
221 #endif
222
223 #if  defined(HAVE_SQLITE3) && defined(SQLITE3_INIT_QUERY)
224    db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
225 #endif
226
227    if (!check_tables_version(jcr, mdb)) {
228       V(mutex);
229       return 0;
230    }
231
232
233    V(mutex);
234    return 1;
235 }
236
237 void
238 db_close_database(JCR *jcr, B_DB *mdb)
239 {
240    if (!mdb) {
241       return;
242    }
243    db_end_transaction(jcr, mdb);
244    P(mutex);
245    sql_free_result(mdb);
246    mdb->ref_count--;
247    if (mdb->ref_count == 0) {
248       qdchain(&mdb->bq);
249       if (mdb->connected && mdb->db) {
250          sqlite_close(mdb->db);
251       }
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);
260       if (mdb->db_name) {
261          free(mdb->db_name);
262       }
263       free(mdb);
264    }
265    V(mutex);
266 }
267
268 void db_thread_cleanup()
269 {
270 #ifdef HAVE_SQLITE3
271    sqlite3_thread_cleanup();
272 #endif
273 }
274
275 /*
276  * Return the next unique index (auto-increment) for
277  * the given table.  Return 0 on error.
278  */
279 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
280 {
281    strcpy(index, "NULL");
282    return 1;
283 }
284
285
286 /*
287  * Escape strings so that SQLite is happy
288  *
289  *   NOTE! len is the length of the old string. Your new
290  *         string must be long enough (max 2*old+1) to hold
291  *         the escaped output.
292  */
293 void
294 db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
295 {
296    char *n, *o;
297
298    n = snew;
299    o = old;
300    while (len--) {
301       switch (*o) {
302       case '\'':
303          *n++ = '\'';
304          *n++ = '\'';
305          o++;
306          break;
307       case 0:
308          *n++ = '\\';
309          *n++ = 0;
310          o++;
311          break;
312       default:
313          *n++ = *o++;
314          break;
315       }
316    }
317    *n = 0;
318 }
319
320 struct rh_data {
321    DB_RESULT_HANDLER *result_handler;
322    void *ctx;
323 };
324
325 /*
326  * Convert SQLite's callback into Bacula DB callback
327  */
328 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
329 {
330    struct rh_data *rh_data = (struct rh_data *)arh_data;
331
332    if (rh_data->result_handler) {
333       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
334    }
335    return 0;
336 }
337
338 /*
339  * Submit a general SQL command (cmd), and for each row returned,
340  *  the sqlite_handler is called with the ctx.
341  */
342 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
343 {
344    struct rh_data rh_data;
345    int stat;
346
347    db_lock(mdb);
348    if (mdb->sqlite_errmsg) {
349 #ifdef HAVE_SQLITE3
350       sqlite3_free(mdb->sqlite_errmsg);
351 #else
352       actuallyfree(mdb->sqlite_errmsg);
353 #endif
354       mdb->sqlite_errmsg = NULL;
355    }
356    rh_data.result_handler = result_handler;
357    rh_data.ctx = ctx;
358    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
359    if (stat != 0) {
360       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
361       db_unlock(mdb);
362       return false;
363    }
364    db_unlock(mdb);
365    return true;
366 }
367
368 /*
369  * Submit a sqlite query and retrieve all the data
370  */
371 int my_sqlite_query(B_DB *mdb, const char *cmd)
372 {
373    int stat;
374
375    my_sqlite_free_table(mdb);
376    if (mdb->sqlite_errmsg) {
377 #ifdef HAVE_SQLITE3
378       sqlite3_free(mdb->sqlite_errmsg);
379 #else
380       actuallyfree(mdb->sqlite_errmsg);
381 #endif
382       mdb->sqlite_errmsg = NULL;
383    }
384    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
385             &mdb->sqlite_errmsg);
386    mdb->row = 0;                      /* row fetched */
387    return stat;
388 }
389
390 /* Fetch one row at a time */
391 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
392 {
393    if (mdb->row >= mdb->nrow) {
394       return NULL;
395    }
396    mdb->row++;
397    return &mdb->result[mdb->ncolumn * mdb->row];
398 }
399
400 void my_sqlite_free_table(B_DB *mdb)
401 {
402    int i;
403
404    if (mdb->fields_defined) {
405       for (i=0; i < sql_num_fields(mdb); i++) {
406          free(mdb->fields[i]);
407       }
408       free(mdb->fields);
409       mdb->fields_defined = false;
410    }
411    if (mdb->result) {
412       sqlite_free_table(mdb->result);
413       mdb->result = NULL;
414    }
415    mdb->nrow = mdb->ncolumn = 0;
416 }
417
418 void my_sqlite_field_seek(B_DB *mdb, int field)
419 {
420    int i, j;
421    if (mdb->result == NULL) {
422       return;
423    }
424    /* On first call, set up the fields */
425    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
426       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
427       for (i=0; i < sql_num_fields(mdb); i++) {
428          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
429          mdb->fields[i]->name = mdb->result[i];
430          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
431          mdb->fields[i]->max_length = mdb->fields[i]->length;
432          for (j=1; j <= mdb->nrow; j++) {
433             int len;
434             if (mdb->result[i + mdb->ncolumn *j]) {
435                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
436             } else {
437                len = 0;
438             }
439             if (len > mdb->fields[i]->max_length) {
440                mdb->fields[i]->max_length = len;
441             }
442          }
443          mdb->fields[i]->type = 0;
444          mdb->fields[i]->flags = 1;        /* not null */
445       }
446       mdb->fields_defined = true;
447    }
448    if (field > sql_num_fields(mdb) - 1) {
449       field = sql_num_fields(mdb) - 1;
450     }
451     mdb->field = field;
452 }
453
454 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
455 {
456    if (mdb->fields_defined && mdb->field < sql_num_fields(mdb)) {
457       return mdb->fields[mdb->field++];
458    } else {
459       mdb->field = 0;
460       return NULL;
461    }
462 }
463
464 #ifdef HAVE_BATCH_FILE_INSERT
465 const char *my_sqlite_batch_lock_query = "BEGIN";
466 const char *my_sqlite_batch_unlock_query = "COMMIT";
467
468 const char *my_sqlite_batch_fill_path_query = 
469    "INSERT INTO Path (Path)" 
470    " SELECT DISTINCT Path FROM batch"
471    " EXCEPT SELECT Path FROM Path";
472
473 const char *my_sqlite_batch_fill_filename_query = 
474    "INSERT INTO Filename (Name)"
475    " SELECT DISTINCT Name FROM batch "
476    " EXCEPT SELECT Name FROM Filename";
477 #endif /* HAVE_BATCH_FILE_INSERT */
478
479
480 #endif /* HAVE_SQLITE */