X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fcats%2Fsql.c;h=2c4fa431eea984f7731af79abf59191dac2725d6;hb=59d4303c028e69e3ffe32e0b7f38bdce5c7b5cc0;hp=ad7ce60caad1692216742c1b46d31ad7a1d9e280;hpb=798adaee607d9b913115853e5fb84f2e2a424975;p=bacula%2Fbacula

diff --git a/bacula/src/cats/sql.c b/bacula/src/cats/sql.c
index ad7ce60caa..2c4fa431ee 100644
--- a/bacula/src/cats/sql.c
+++ b/bacula/src/cats/sql.c
@@ -1,54 +1,73 @@
 /*
- * Bacula Catalog Database interface routines
- * 
- *     Almost generic set of SQL database interface routines
- *	(with a little more work)
- *
- *    Kern Sibbald, March 2000
- *
- *    Version $Id$
- */
+   Bacula® - The Network Backup Solution
 
-/*
-   Copyright (C) 2000-2004 Kern Sibbald and John Walker
+   Copyright (C) 2000-2009 Free Software Foundation Europe e.V.
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of
-   the License, or (at your option) any later version.
+   The main author of Bacula is Kern Sibbald, with contributions from
+   many others, a complete list can be found in the file AUTHORS.
+   This program is Free Software; you can redistribute it and/or
+   modify it under the terms of version three of the GNU Affero General Public
+   License as published by the Free Software Foundation and included
+   in the file LICENSE.
 
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    General Public License for more details.
 
-   You should have received a copy of the GNU General Public
-   License along with this program; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-   MA 02111-1307, USA.
-
- */
+   You should have received a copy of the GNU Affero General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
 
-/* The following is necessary so that we do not include
- * the dummy external definition of B_DB.
+   Bacula® is a registered trademark of Kern Sibbald.
+   The licensor of Bacula is the Free Software Foundation Europe
+   (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
+   Switzerland, email:ftf@fsfeurope.org.
+*/
+/*
+ * Bacula Catalog Database interface routines
+ *
+ *     Almost generic set of SQL database interface routines
+ *      (with a little more work)
+ *     SQL engine specific routines are in mysql.c, postgresql.c,
+ *       sqlite.c, ...
+ *
+ *    Kern Sibbald, March 2000
+ *
+ *    Version $Id: sql.c 8034 2008-11-11 14:33:46Z ricozz $
  */
-#define __SQL_C 		      /* indicate that this is sql.c */
 
 #include "bacula.h"
-#include "cats.h"
 
-#if    HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL
+#if HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL || HAVE_INGRES || HAVE_DBI
 
-uint32_t bacula_db_version = 0;
+#include "cats.h"
+#include "bdb_priv.h"
+#include "sql_glue.h"
 
 /* Forward referenced subroutines */
 void print_dashes(B_DB *mdb);
 void print_result(B_DB *mdb);
 
+dbid_list::dbid_list()
+{
+   memset(this, 0, sizeof(dbid_list));
+   max_ids = 1000;
+   DBId = (DBId_t *)malloc(max_ids * sizeof(DBId_t));
+   num_ids = num_seen = tot_ids = 0;
+   PurgedFiles = NULL;
+}
+
+dbid_list::~dbid_list()
+{
+   free(DBId);
+}
+
 /*
  * Called here to retrieve an integer from the database
  */
-static int int_handler(void *ctx, int num_fields, char **row)
+int db_int_handler(void *ctx, int num_fields, char **row)
 {
    uint32_t *val = (uint32_t *)ctx;
 
@@ -56,7 +75,7 @@ static int int_handler(void *ctx, int num_fields, char **row)
 
    if (row[0]) {
       Dmsg1(800, "int_handler finds '%s'\n", row[0]);
-      *val = atoi(row[0]);
+      *val = str_to_int64(row[0]);
    } else {
       Dmsg0(800, "int_handler finds zero\n");
       *val = 0;
@@ -64,35 +83,149 @@ static int int_handler(void *ctx, int num_fields, char **row)
    Dmsg0(800, "int_handler finishes\n");
    return 0;
 }
-       
 
+/*
+ * Called here to retrieve a 32/64 bit integer from the database.
+ *   The returned integer will be extended to 64 bit.
+ */
+int db_int64_handler(void *ctx, int num_fields, char **row)
+{
+   db_int64_ctx *lctx = (db_int64_ctx *)ctx;
+
+   if (row[0]) {
+      lctx->value = str_to_int64(row[0]);
+      lctx->count++;
+   }
+   return 0;
+}
+
+/*
+ * Called here to retrieve a btime from the database.
+ *   The returned integer will be extended to 64 bit.
+ */
+int db_strtime_handler(void *ctx, int num_fields, char **row)
+{
+   db_int64_ctx *lctx = (db_int64_ctx *)ctx;
+
+   if (row[0]) {
+      lctx->value = str_to_utime(row[0]);
+      lctx->count++;
+   }
+   return 0;
+}
+
+/*
+ * Use to build a comma separated list of values from a query. "10,20,30"
+ */
+int db_list_handler(void *ctx, int num_fields, char **row)
+{
+   db_list_ctx *lctx = (db_list_ctx *)ctx;
+   if (num_fields == 1 && row[0]) {
+      lctx->add(row[0]);
+   }
+   return 0;
+}
+
+/*
+ * specific context passed from db_check_max_connections to db_max_connections_handler.
+ */
+struct max_connections_context {
+   B_DB *db;
+   uint32_t nr_connections;
+};
+
+/*
+ * Called here to retrieve an integer from the database
+ */
+static inline int db_max_connections_handler(void *ctx, int num_fields, char **row)
+{
+   struct max_connections_context *context;
+   uint32_t index;
+
+   context = (struct max_connections_context *)ctx;
+   switch (db_get_type_index(context->db)) {
+   case SQL_TYPE_MYSQL:
+      index = 1;
+   default:
+      index = 0;
+   }
+
+   if (row[index]) {
+      context->nr_connections = str_to_int64(row[index]);
+   } else {
+      Dmsg0(800, "int_handler finds zero\n");
+      context->nr_connections = 0;
+   }
+   return 0;
+}
+
+/*
+ * Check catalog max_connections setting
+ */
+bool db_check_max_connections(JCR *jcr, B_DB *mdb, uint32_t max_concurrent_jobs)
+{
+   struct max_connections_context context;
+
+   /* Without Batch insert, no need to verify max_connections */
+   if (!mdb->batch_insert_available())
+      return true;
+
+   context.db = mdb;
+   context.nr_connections = 0;
+
+   /* Check max_connections setting */
+   if (!db_sql_query(mdb, sql_get_max_connections[db_get_type_index(mdb)],
+                     db_max_connections_handler, &context)) {
+      Jmsg(jcr, M_ERROR, 0, "Can't verify max_connections settings %s", mdb->errmsg);
+      return false;
+   }
+   if (context.nr_connections && max_concurrent_jobs && max_concurrent_jobs > context.nr_connections) {
+      Mmsg(mdb->errmsg,
+           _("Potential performance problem:\n"
+             "max_connections=%d set for %s database \"%s\" should be larger than Director's "
+             "MaxConcurrentJobs=%d\n"),
+           context.nr_connections, db_get_type(mdb), mdb->get_db_name(), max_concurrent_jobs);
+      Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
+      return false;
+   }
+
+   return true;
+}
 
 /* NOTE!!! The following routines expect that the
  *  calling subroutine sets and clears the mutex
  */
 
 /* Check that the tables correspond to the version we want */
-int check_tables_version(JCR *jcr, B_DB *mdb)
+bool check_tables_version(JCR *jcr, B_DB *mdb)
 {
+   uint32_t bacula_db_version = 0;
    const char *query = "SELECT VersionId FROM Version";
-  
+
    bacula_db_version = 0;
-   db_sql_query(mdb, query, int_handler, (void *)&bacula_db_version);
+   if (!db_sql_query(mdb, query, db_int_handler, (void *)&bacula_db_version)) {
+      Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
+      return false;
+   }
    if (bacula_db_version != BDB_VERSION) {
-      Mmsg(&mdb->errmsg, "Version error for database \"%s\". Wanted %d, got %d\n",
-	  mdb->db_name, BDB_VERSION, bacula_db_version);
+      Mmsg(mdb->errmsg, "Version error for database \"%s\". Wanted %d, got %d\n",
+          mdb->get_db_name(), BDB_VERSION, bacula_db_version);
       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
-      return 0;
+      return false;
    }
-   return 1;
+   return true;
 }
 
-/* Utility routine for queries. The database MUST be locked before calling here. */
+/*
+ * Utility routine for queries. The database MUST be locked before calling here.
+ * Returns: 0 on failure
+ *          1 on success
+ */
 int
 QueryDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
 {
-   int status;
-   if ((status=sql_query(mdb, cmd)) != 0) {
+   sql_free_result(mdb);
+   if (!sql_query(mdb, cmd, QF_STORE_RESULT)) {
       m_msg(file, line, &mdb->errmsg, _("query %s failed:\n%s\n"), cmd, sql_strerror(mdb));
       j_msg(file, line, jcr, M_FATAL, 0, "%s", mdb->errmsg);
       if (verbose) {
@@ -101,20 +234,20 @@ QueryDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
       return 0;
    }
 
-   mdb->result = sql_store_result(mdb);
-
-   return mdb->result != NULL;
+   return 1;
 }
 
-/* 
- * Utility routine to do inserts   
- * Returns: 0 on failure      
- *	    1 on success
+/*
+ * Utility routine to do inserts
+ * Returns: 0 on failure
+ *          1 on success
  */
 int
 InsertDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
 {
-   if (sql_query(mdb, cmd)) {
+   int num_rows;
+
+   if (!sql_query(mdb, cmd)) {
       m_msg(file, line, &mdb->errmsg,  _("insert %s failed:\n%s\n"), cmd, sql_strerror(mdb));
       j_msg(file, line, jcr, M_FATAL, 0, "%s", mdb->errmsg);
       if (verbose) {
@@ -122,15 +255,11 @@ InsertDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
       }
       return 0;
    }
-   if (mdb->have_insert_id) {
-      mdb->num_rows = sql_affected_rows(mdb);
-   } else {
-      mdb->num_rows = 1;
-   }
-   if (mdb->num_rows != 1) {
+   num_rows = sql_affected_rows(mdb);
+   if (num_rows != 1) {
       char ed1[30];
-      m_msg(file, line, &mdb->errmsg, _("Insertion problem: affected_rows=%s\n"), 
-	 edit_uint64(mdb->num_rows, ed1));
+      m_msg(file, line, &mdb->errmsg, _("Insertion problem: affected_rows=%s\n"),
+         edit_uint64(num_rows, ed1));
       if (verbose) {
          j_msg(file, line, jcr, M_INFO, 0, "%s\n", cmd);
       }
@@ -142,13 +271,14 @@ InsertDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
 
 /* Utility routine for updates.
  *  Returns: 0 on failure
- *	     1 on success  
+ *           1 on success
  */
 int
 UpdateDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
 {
+   int num_rows;
 
-   if (sql_query(mdb, cmd)) {
+   if (!sql_query(mdb, cmd)) {
       m_msg(file, line, &mdb->errmsg, _("update %s failed:\n%s\n"), cmd, sql_strerror(mdb));
       j_msg(file, line, jcr, M_ERROR, 0, "%s", mdb->errmsg);
       if (verbose) {
@@ -156,11 +286,11 @@ UpdateDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
       }
       return 0;
    }
-   mdb->num_rows = sql_affected_rows(mdb);
-   if (mdb->num_rows < 1) {
+   num_rows = sql_affected_rows(mdb);
+   if (num_rows < 1) {
       char ed1[30];
-      m_msg(file, line, &mdb->errmsg, _("Update problem: affected_rows=%s\n"), 
-	 edit_uint64(mdb->num_rows, ed1));
+      m_msg(file, line, &mdb->errmsg, _("Update failed: affected_rows=%s for %s\n"),
+         edit_uint64(num_rows, ed1), cmd);
       if (verbose) {
 //       j_msg(file, line, jcr, M_INFO, 0, "%s\n", cmd);
       }
@@ -170,16 +300,17 @@ UpdateDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
    return 1;
 }
 
-/* Utility routine for deletes	 
+/*
+ * Utility routine for deletes
  *
  * Returns: -1 on error
- *	     n number of rows affected
+ *           n number of rows affected
  */
 int
 DeleteDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
 {
 
-   if (sql_query(mdb, cmd)) {
+   if (!sql_query(mdb, cmd)) {
       m_msg(file, line, &mdb->errmsg, _("delete %s failed:\n%s\n"), cmd, sql_strerror(mdb));
       j_msg(file, line, jcr, M_ERROR, 0, "%s", mdb->errmsg);
       if (verbose) {
@@ -197,7 +328,7 @@ DeleteDB(const char *file, int line, JCR *jcr, B_DB *mdb, char *cmd)
  *  No locking done
  *
  * Returns: -1 on failure
- *	    count on success
+ *          count on success
  */
 int get_sql_record_max(JCR *jcr, B_DB *mdb)
 {
@@ -207,9 +338,9 @@ int get_sql_record_max(JCR *jcr, B_DB *mdb)
    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
       if ((row = sql_fetch_row(mdb)) == NULL) {
          Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
-	 stat = -1;
+         stat = -1;
       } else {
-	 stat = atoi(row[0]);
+         stat = str_to_int64(row[0]);
       }
       sql_free_result(mdb);
    } else {
@@ -227,99 +358,6 @@ char *db_strerror(B_DB *mdb)
    return mdb->errmsg;
 }
 
-/*
- * Lock database, this can be called multiple times by the same
- *   thread without blocking, but must be unlocked the number of
- *   times it was locked.
- */
-void _db_lock(const char *file, int line, B_DB *mdb)
-{
-   int errstat;
-   if ((errstat=rwl_writelock(&mdb->lock)) != 0) {
-      e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
-	   strerror(errstat));
-   }
-}    
-
-/*
- * Unlock the database. This can be called multiple times by the
- *   same thread up to the number of times that thread called
- *   db_lock()/
- */
-void _db_unlock(const char *file, int line, B_DB *mdb)
-{
-   int errstat;
-   if ((errstat=rwl_writeunlock(&mdb->lock)) != 0) {
-      e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
-	   strerror(errstat));
-   }
-}    
-
-/*
- * Start a transaction. This groups inserts and makes things
- *  much more efficient. Usually started when inserting 
- *  file attributes.
- */
-void db_start_transaction(JCR *jcr, B_DB *mdb)
-{
-#ifdef xAVE_SQLITE
-   db_lock(mdb);
-   /* Allow only 10,000 changes per transaction */
-   if (mdb->transaction && mdb->changes > 10000) {
-      db_end_transaction(jcr, mdb);
-   }
-   if (!mdb->transaction) {   
-      my_sqlite_query(mdb, "BEGIN");  /* begin transaction */
-      Dmsg0(400, "Start SQLite transaction\n");
-      mdb->transaction = 1;
-   }
-   db_unlock(mdb);
-#endif
-
-/*
- * This is turned off because transactions break
- * if multiple simultaneous jobs are run.    
- */
-#ifdef xAVE_POSTGRESQL
-   db_lock(mdb);
-   /* Allow only 25,000 changes per transaction */
-   if (mdb->transaction && mdb->changes > 25000) {
-      db_end_transaction(jcr, mdb);
-   }
-   if (!mdb->transaction) {   
-      db_sql_query(mdb, "BEGIN", NULL, NULL);  /* begin transaction */
-      Dmsg0(400, "Start PosgreSQL transaction\n");
-      mdb->transaction = 1;
-   }
-   db_unlock(mdb);
-#endif
-}
-
-void db_end_transaction(JCR *jcr, B_DB *mdb)
-{
-#ifdef xAVE_SQLITE
-   db_lock(mdb);
-   if (mdb->transaction) {
-      my_sqlite_query(mdb, "COMMIT"); /* end transaction */
-      mdb->transaction = 0;
-      Dmsg1(400, "End SQLite transaction changes=%d\n", mdb->changes);
-   }
-   mdb->changes = 0;
-   db_unlock(mdb);
-#endif
-
-#ifdef xAVE_POSTGRESQL
-   db_lock(mdb);
-   if (mdb->transaction) {
-      db_sql_query(mdb, "COMMIT", NULL, NULL); /* end transaction */
-      mdb->transaction = 0;
-      Dmsg1(400, "End PostgreSQL transaction changes=%d\n", mdb->changes);
-   }
-   mdb->changes = 0;
-   db_unlock(mdb);
-#endif
-}
-
 /*
  * Given a full filename, split it into its path
  *  and filename parts. They are returned in pool memory
@@ -329,40 +367,39 @@ void split_path_and_file(JCR *jcr, B_DB *mdb, const char *fname)
 {
    const char *p, *f;
 
-   /* Find path without the filename.  
+   /* Find path without the filename.
     * I.e. everything after the last / is a "filename".
     * OK, maybe it is a directory name, but we treat it like
     * a filename. If we don't find a / then the whole name
     * must be a path name (e.g. c:).
     */
    for (p=f=fname; *p; p++) {
-      if (*p == '/') {
-	 f = p; 		      /* set pos of last slash */
+      if (IsPathSeparator(*p)) {
+         f = p;                       /* set pos of last slash */
       }
    }
-   if (*f == '/') {                   /* did we find a slash? */
-      f++;			      /* yes, point to filename */
-   } else {			      /* no, whole thing must be path name */
+   if (IsPathSeparator(*f)) {                   /* did we find a slash? */
+      f++;                            /* yes, point to filename */
+   } else {                           /* no, whole thing must be path name */
       f = p;
    }
 
    /* If filename doesn't exist (i.e. root directory), we
-    * simply create a blank name consisting of a single 
+    * simply create a blank name consisting of a single
     * space. This makes handling zero length filenames
     * easier.
     */
    mdb->fnl = p - f;
    if (mdb->fnl > 0) {
       mdb->fname = check_pool_memory_size(mdb->fname, mdb->fnl+1);
-      memcpy(mdb->fname, f, mdb->fnl);	  /* copy filename */
+      memcpy(mdb->fname, f, mdb->fnl);    /* copy filename */
       mdb->fname[mdb->fnl] = 0;
    } else {
-      mdb->fname[0] = ' ';            /* blank filename */
-      mdb->fname[1] = 0;
-      mdb->fnl = 1;
+      mdb->fname[0] = 0;
+      mdb->fnl = 0;
    }
 
-   mdb->pnl = f - fname;    
+   mdb->pnl = f - fname;
    if (mdb->pnl > 0) {
       mdb->path = check_pool_memory_size(mdb->path, mdb->pnl+1);
       memcpy(mdb->path, fname, mdb->pnl);
@@ -370,28 +407,48 @@ void split_path_and_file(JCR *jcr, B_DB *mdb, const char *fname)
    } else {
       Mmsg1(&mdb->errmsg, _("Path length is zero. File=%s\n"), fname);
       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
-      mdb->path[0] = ' ';
-      mdb->path[1] = 0;
-      mdb->pnl = 1;
+      mdb->path[0] = 0;
+      mdb->pnl = 0;
    }
 
    Dmsg2(500, "split path=%s file=%s\n", mdb->path, mdb->fname);
 }
 
+/*
+ * Set maximum field length to something reasonable
+ */
+static int max_length(int max_length)
+{
+   int max_len = max_length;
+   /* Sanity check */
+   if (max_len < 0) {
+      max_len = 2;
+   } else if (max_len > 100) {
+      max_len = 100;
+   }
+   return max_len;
+}
+
 /*
  * List dashes as part of header for listing SQL results in a table
  */
-void
-list_dashes(B_DB *mdb, DB_LIST_HANDLER *send, void *ctx)
+void list_dashes(B_DB *mdb, DB_LIST_HANDLER *send, void *ctx)
 {
    SQL_FIELD  *field;
    int i, j;
+   int len;
+   int num_fields;
 
    sql_field_seek(mdb, 0);
    send(ctx, "+");
-   for (i = 0; i < sql_num_fields(mdb); i++) {
+   num_fields = sql_num_fields(mdb);
+   for (i = 0; i < num_fields; i++) {
       field = sql_fetch_field(mdb);
-      for (j = 0; j < (int)field->max_length + 2; j++) {
+      if (!field) {
+         break;
+      }
+      len = max_length(field->max_length + 2);
+      for (j = 0; j < len; j++) {
          send(ctx, "-");
       }
       send(ctx, "+");
@@ -399,46 +456,180 @@ list_dashes(B_DB *mdb, DB_LIST_HANDLER *send, void *ctx)
    send(ctx, "\n");
 }
 
+/* Small handler to print the last line of a list xxx command */
+static void last_line_handler(void *vctx, const char *str)
+{
+   LIST_CTX *ctx = (LIST_CTX *)vctx;
+   bstrncat(ctx->line, str, sizeof(ctx->line));
+}
+
+int list_result(void *vctx, int nb_col, char **row)
+{
+   SQL_FIELD *field;
+   int i, col_len, max_len = 0;
+   int num_fields;
+   char buf[2000], ewc[30];
+
+   LIST_CTX *pctx = (LIST_CTX *)vctx;
+   DB_LIST_HANDLER *send = pctx->send;
+   e_list_type type = pctx->type;
+   B_DB *mdb = pctx->mdb;
+   void *ctx = pctx->ctx;
+   JCR *jcr = pctx->jcr;
+
+   num_fields = sql_num_fields(mdb);
+   if (!pctx->once) {
+      pctx->once = true;
+
+      Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
+      /* determine column display widths */
+      sql_field_seek(mdb, 0);
+      for (i = 0; i < num_fields; i++) {
+         Dmsg1(800, "list_result processing field %d\n", i);
+         field = sql_fetch_field(mdb);
+         if (!field) {
+            break;
+         }
+         col_len = cstrlen(field->name);
+         if (type == VERT_LIST) {
+            if (col_len > max_len) {
+               max_len = col_len;
+            }
+         } else {
+            if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
+               field->max_length += (field->max_length - 1) / 3;
+            }  
+            if (col_len < (int)field->max_length) {
+               col_len = field->max_length;
+            }  
+            if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
+               col_len = 4;                 /* 4 = length of the word "NULL" */
+            }
+            field->max_length = col_len;    /* reset column info */
+         }
+      }
+
+      pctx->num_rows++;
+
+      Dmsg0(800, "list_result finished first loop\n");
+      if (type == VERT_LIST) {
+         goto vertical_list;
+      }
+
+      Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
+
+      /* Keep the result to display the same line at the end of the table */
+      list_dashes(mdb, last_line_handler, pctx);
+      send(ctx, pctx->line);
+
+      send(ctx, "|");
+      sql_field_seek(mdb, 0);
+      for (i = 0; i < num_fields; i++) {
+         Dmsg1(800, "list_result looking at field %d\n", i);
+         field = sql_fetch_field(mdb);
+         if (!field) {
+            break;
+         }
+         max_len = max_length(field->max_length);
+         bsnprintf(buf, sizeof(buf), " %-*s |", max_len, field->name);
+         send(ctx, buf);
+      }
+      send(ctx, "\n");
+      list_dashes(mdb, send, ctx);      
+   }
+   
+   Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
+
+   sql_field_seek(mdb, 0);
+   send(ctx, "|");
+   for (i = 0; i < num_fields; i++) {
+      field = sql_fetch_field(mdb);
+      if (!field) {
+         break;
+      }
+      max_len = max_length(field->max_length);
+      if (row[i] == NULL) {
+         bsnprintf(buf, sizeof(buf), " %-*s |", max_len, "NULL");
+      } else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
+         bsnprintf(buf, sizeof(buf), " %*s |", max_len,
+                   add_commas(row[i], ewc));
+      } else {
+         bsnprintf(buf, sizeof(buf), " %-*s |", max_len, row[i]);
+      }
+      send(ctx, buf);
+   }
+   send(ctx, "\n");
+   return 0;
+
+vertical_list:
+
+   Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
+
+   sql_field_seek(mdb, 0);
+   for (i = 0; i < num_fields; i++) {
+      field = sql_fetch_field(mdb);
+      if (!field) {
+         break;
+      }
+      if (row[i] == NULL) {
+         bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, "NULL");
+      } else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
+         bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name,
+                   add_commas(row[i], ewc));
+      } else {
+         bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, row[i]);
+      }
+      send(ctx, buf);
+   }
+   send(ctx, "\n");
+   return 0;
+}
+
 /*
- * If full_list is set, we list vertically, otherwise, we 
- * list on one line horizontally.      
+ * If full_list is set, we list vertically, otherwise, we
+ *  list on one line horizontally.
+ * Return number of rows
  */
-void
-list_result(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type type)
+int list_result(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type type)
 {
    SQL_FIELD *field;
    SQL_ROW row;
    int i, col_len, max_len = 0;
+   int num_fields;
    char buf[2000], ewc[30];
 
    Dmsg0(800, "list_result starts\n");
-   if (mdb->result == NULL || sql_num_rows(mdb) == 0) {
+   if (sql_num_rows(mdb) == 0) {
       send(ctx, _("No results to list.\n"));
-      return;
+      return sql_num_rows(mdb);
    }
 
-   Dmsg1(800, "list_result starts looking at %d fields\n", sql_num_fields(mdb));
+   num_fields = sql_num_fields(mdb);
+   Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
    /* determine column display widths */
    sql_field_seek(mdb, 0);
-   for (i = 0; i < sql_num_fields(mdb); i++) {
+   for (i = 0; i < num_fields; i++) {
       Dmsg1(800, "list_result processing field %d\n", i);
       field = sql_fetch_field(mdb);
-      col_len = strlen(field->name);
+      if (!field) {
+         break;
+      }
+      col_len = cstrlen(field->name);
       if (type == VERT_LIST) {
-	 if (col_len > max_len) {
-	    max_len = col_len;
-	 }
+         if (col_len > max_len) {
+            max_len = col_len;
+         }
       } else {
-	 if (IS_NUM(field->type) && (int)field->max_length > 0) { /* fixup for commas */
-	    field->max_length += (field->max_length - 1) / 3;
-	 }
-	 if (col_len < (int)field->max_length) {
-	    col_len = field->max_length;
-	 }
-	 if (col_len < 4 && !IS_NOT_NULL(field->flags)) {
+         if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
+            field->max_length += (field->max_length - 1) / 3;
+         }  
+         if (col_len < (int)field->max_length) {
+            col_len = field->max_length;
+         }  
+         if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
             col_len = 4;                 /* 4 = length of the word "NULL" */
-	 }
-	 field->max_length = col_len;	 /* reset column info */
+         }
+         field->max_length = col_len;    /* reset column info */
       }
    }
 
@@ -447,61 +638,121 @@ list_result(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type t
       goto vertical_list;
    }
 
-   Dmsg1(800, "list_result starts second loop looking at %d fields\n", sql_num_fields(mdb));
+   Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
    list_dashes(mdb, send, ctx);
    send(ctx, "|");
    sql_field_seek(mdb, 0);
-   for (i = 0; i < sql_num_fields(mdb); i++) {
+   for (i = 0; i < num_fields; i++) {
       Dmsg1(800, "list_result looking at field %d\n", i);
       field = sql_fetch_field(mdb);
-      bsnprintf(buf, sizeof(buf), " %-*s |", (int)field->max_length, field->name);
+      if (!field) {
+         break;
+      }
+      max_len = max_length(field->max_length);
+      bsnprintf(buf, sizeof(buf), " %-*s |", max_len, field->name);
       send(ctx, buf);
    }
    send(ctx, "\n");
    list_dashes(mdb, send, ctx);
 
-   Dmsg1(800, "list_result starts third loop looking at %d fields\n", sql_num_fields(mdb));
+   Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
    while ((row = sql_fetch_row(mdb)) != NULL) {
       sql_field_seek(mdb, 0);
       send(ctx, "|");
-      for (i = 0; i < sql_num_fields(mdb); i++) {
-	 field = sql_fetch_field(mdb);
-	 if (row[i] == NULL) {
-            bsnprintf(buf, sizeof(buf), " %-*s |", (int)field->max_length, "NULL");
-	 } else if (IS_NUM(field->type) && !jcr->gui && is_an_integer(row[i])) {
-            bsnprintf(buf, sizeof(buf), " %*s |", (int)field->max_length,       
-		      add_commas(row[i], ewc));
-	 } else {
-            bsnprintf(buf, sizeof(buf), " %-*s |", (int)field->max_length, row[i]);
-	 }
-	 send(ctx, buf);
+      for (i = 0; i < num_fields; i++) {
+         field = sql_fetch_field(mdb);
+         if (!field) {
+            break;
+         }
+         max_len = max_length(field->max_length);
+         if (row[i] == NULL) {
+            bsnprintf(buf, sizeof(buf), " %-*s |", max_len, "NULL");
+         } else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
+            bsnprintf(buf, sizeof(buf), " %*s |", max_len,
+                      add_commas(row[i], ewc));
+         } else {
+            bsnprintf(buf, sizeof(buf), " %-*s |", max_len, row[i]);
+         }
+         send(ctx, buf);
       }
       send(ctx, "\n");
    }
    list_dashes(mdb, send, ctx);
-   return;
+   return sql_num_rows(mdb);
 
 vertical_list:
-   
-   Dmsg1(800, "list_result starts vertical list at %d fields\n", sql_num_fields(mdb));
+
+   Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
    while ((row = sql_fetch_row(mdb)) != NULL) {
       sql_field_seek(mdb, 0);
-      for (i = 0; i < sql_num_fields(mdb); i++) {
-	 field = sql_fetch_field(mdb);
-	 if (row[i] == NULL) {
+      for (i = 0; i < num_fields; i++) {
+         field = sql_fetch_field(mdb);
+         if (!field) {
+            break;
+         }
+         if (row[i] == NULL) {
             bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, "NULL");
-	 } else if (IS_NUM(field->type) && !jcr->gui && is_an_integer(row[i])) {
-            bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, 
-		add_commas(row[i], ewc));
-	 } else {
+         } else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
+            bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name,
+                add_commas(row[i], ewc));
+         } else {
             bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, row[i]);
-	 }
-	 send(ctx, buf);
+         }
+         send(ctx, buf);
       }
       send(ctx, "\n");
    }
-   return;
+   return sql_num_rows(mdb);
 }
 
+/* 
+ * Open a new connexion to mdb catalog. This function is used
+ * by batch and accurate mode.
+ */
+bool db_open_batch_connexion(JCR *jcr, B_DB *mdb)
+{
+   bool multi_db;
+
+   if (mdb->batch_insert_available())
+      multi_db = true;   /* we force a new connection only if batch insert is enabled */
+   else
+      multi_db = false;
+
+   if (!jcr->db_batch) {
+      jcr->db_batch = db_clone_database_connection(mdb, jcr, multi_db);
+      if (!jcr->db_batch) {
+         Mmsg0(&mdb->errmsg, _("Could not init database batch connection"));
+         Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
+         return false;
+      }
+
+      if (!db_open_database(jcr, jcr->db_batch)) {
+         Mmsg2(&mdb->errmsg,  _("Could not open database \"%s\": ERR=%s\n"),
+              jcr->db_batch->get_db_name(), db_strerror(jcr->db_batch));
+         Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
+         return false;
+      }      
+   }
+   return true;
+}
+
+/*
+ * !!! WARNING !!! Use this function only when bacula is stopped.
+ * ie, after a fatal signal and before exiting the program
+ * Print information about a B_DB object.
+ */
+void db_debug_print(JCR *jcr, FILE *fp)
+{
+   B_DB *mdb = jcr->db;
+
+   if (!mdb) {
+      return;
+   }
+
+   fprintf(fp, "B_DB=%p db_name=%s db_user=%s connected=%s\n",
+           mdb, NPRTB(mdb->get_db_name()), NPRTB(mdb->get_db_user()), mdb->is_connected() ? "true" : "false");
+   fprintf(fp, "\tcmd=\"%s\" changes=%i\n", NPRTB(mdb->cmd), mdb->changes);
+   mdb->print_lock_info(fp);
+}
 
-#endif /* HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL */
+#endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL || HAVE_INGRES || HAVE_DBI */