[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Bacula-devel] libdbi backend to catalog database


Thanks,

>
>  If you did not explicitly malloc them in your code, then they probably need to
>  be free'ed in a different way. If you point me to the code that does the
>  malloc, I can respond better ...

Ok, in line 981 to 988 I malloc buf. This function return buf. In line
461, my_dbi_fetch_row call my_dbi_getvalue (and return buf to
mdb->row[j]). So, mdb->row[j] have many buf malloced.

To free all, in line 625 I use a looping and free every mdb->row[j].

Please, see the dbi.c attached.

But I have another problem more confusing

Like I wrote, libdbi does't has support to PQ*CopyData functions. The
solution is use void* dbi_driver_specific_function(dbi_driver, const
char*) function and returns a function pointer to the specifed custom
function.

In lines
820 int (*custom_function)(void*, const char*, int);
863 custom_function =
dbi_driver_specific_function(dbi_conn_get_driver(mdb->db),
"PQputCopyData")
865 res = custom_function(myconn->connection, (const char *)mdb->cmd, (int)len);

I declare a function pointer to custom_function, call specific
function (here, PQputCopyData) and use this.

Ok, no problems here. When I compiling this, Bacula saw:

Compiling dbi.c
dbi.c: In function 'int my_dbi_batch_insert(JCR*, B_DB*, ATTR_DBR*)':
dbi.c:863: error: invalid conversion from 'void*' to 'int (*)(void*,
const char*, int)'
make[1]: ** [dbi.o] Erro 1

I don't understend why invalid conversion. Any suggestion about?

Thanks.

PS1: In http://libdbi-drivers.cvs.sourceforge.net/libdbi-drivers/libdbi-drivers/tests/test_dbi.c?view=markup
lines 600 and 602 it compiling and run. Have Bacula any special flag
to impossibility this construction?




PS2: dbi.c and cats.h has attached.
/*
   Bacula® - The Network Backup Solution

   Copyright (C) 2003-2008 Free Software Foundation Europe e.V.

   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 two of the GNU 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
   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., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.

   Bacula® is a registered trademark of John Walker.
   The licensor of Bacula is the Free Software Foundation Europe
   (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
   Switzerland, email:ftf@xxxxxxxxxxxxxx
*/
/*
 * Bacula Catalog Database routines specific to DBI
 *   These are DBI specific routines
 *
 *    João Henrique Freitas, December 2007
 *    based upon work done by Dan Langille, December 2003 and
 *    by Kern Sibbald, March 2000
 *
 *    Version $Id$
 */


/* The following is necessary so that we do not include
 * the dummy external definition of DB.
 */
#define __SQL_C                       /* indicate that this is sql.c */

#include "bacula.h"
#include "cats.h"

#ifdef HAVE_DBI

/* -----------------------------------------------------------------------
 *
 *   DBI dependent defines and subroutines
 *
 * -----------------------------------------------------------------------
 */

/* List of open databases */
static BQUEUE db_list = {&db_list, &db_list};

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

/*
 * Retrieve database type
 */
const char *
db_get_type(void)
{
   return "DBI";
}

/*
 * Initialize database data structure. In principal this should
 * never have errors, or it is really fatal.
 */
B_DB *
db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
                 const char *db_address, int db_port, const char *db_socket, 
                 int mult_db_connections)
{
   B_DB *mdb;
   char db_driver[10];
   char db_driverdir[256];

   /* Constraint the db_driver */
   if(db_type  == -1) {
      Jmsg(jcr, M_FATAL, 0, _("A dbi driver for DBI must be supplied.\n"));
      return NULL;
   }
   
   /* Do the correct selection of driver. 
    * Can be one of the varius supported by libdbi 
    */
   switch (db_type) {
   case SQL_TYPE_MYSQL:
      bstrncpy(db_driver,"mysql", sizeof(db_driver));
      break;
   case SQL_TYPE_POSTGRESQL:
      bstrncpy(db_driver,"pgsql", sizeof(db_driver));
      break;
   case SQL_TYPE_SQLITE:
      bstrncpy(db_driver,"pgsql", sizeof(db_driver));
      break;
   }
   
   /* Set db_driverdir whereis is the libdbi drivers */
   bstrncpy(db_driverdir, DBI_DRIVER_DIR, 255);
   
   if (!db_user) {
      Jmsg(jcr, M_FATAL, 0, _("A user name for DBI must be supplied.\n"));
      return NULL;
   }
   P(mutex);                          /* lock DB queue */
   if (!mult_db_connections) {
      /* Look to see if DB already open */
      for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
         if (bstrcmp(mdb->db_name, db_name) &&
             bstrcmp(mdb->db_address, db_address) &&
             bstrcmp(mdb->db_driver, db_driver) &&
             mdb->db_port == db_port) { 
            Dmsg4(100, "DB REopen %d %s %s erro: %d\n", mdb->ref_count, db_driver, db_name, 
                  dbi_conn_error(mdb->db, NULL));
            mdb->ref_count++;
            V(mutex);
            return mdb;                  /* already open */
         }
      }
   }
   Dmsg0(100, "db_open first time\n");
   mdb = (B_DB *)malloc(sizeof(B_DB));
   memset(mdb, 0, sizeof(B_DB));
   mdb->db_name = bstrdup(db_name);
   mdb->db_user = bstrdup(db_user);
   if (db_password) {
      mdb->db_password = bstrdup(db_password);
   }
   if (db_address) {
      mdb->db_address  = bstrdup(db_address);
   }
   if (db_socket) {
      mdb->db_socket   = bstrdup(db_socket);
   }
   if (db_driverdir) {
      mdb->db_driverdir = bstrdup(db_driverdir);
   }
   if (db_driver) {
      mdb->db_driver    = bstrdup(db_driver);
   }
   mdb->db_type        = db_type;
   mdb->db_port        = db_port;
   mdb->have_insert_id = TRUE;
   mdb->errmsg         = get_pool_memory(PM_EMSG); /* get error message buffer */
   *mdb->errmsg        = 0;
   mdb->cmd            = get_pool_memory(PM_EMSG); /* get command buffer */
   mdb->cached_path    = get_pool_memory(PM_FNAME);
   mdb->cached_path_id = 0;
   mdb->ref_count      = 1;
   mdb->fname          = get_pool_memory(PM_FNAME);
   mdb->path           = get_pool_memory(PM_FNAME);
   mdb->esc_name       = get_pool_memory(PM_FNAME);
   mdb->esc_path      = get_pool_memory(PM_FNAME);
   mdb->allow_transactions = mult_db_connections;
   qinsert(&db_list, &mdb->bq);            /* put db in list */
   V(mutex);
   return mdb;
}

/*
 * Now actually open the database.  This can generate errors,
 *   which are returned in the errmsg
 *
 * DO NOT close the database or free(mdb) here  !!!!
 */
int
db_open_database(JCR *jcr, B_DB *mdb)
{   
   int errstat;
   int dbstat;
   const char *errmsg;
   char buf[10], *port;
   int numdrivers; 
   
   P(mutex);
   if (mdb->connected) {
      V(mutex);
      return 1;
   }
   mdb->connected = false;

   if ((errstat=rwl_init(&mdb->lock)) != 0) {
      berrno be;
      Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
            be.bstrerror(errstat));
      V(mutex);
      return 0;
   }

   if (mdb->db_port) {
      bsnprintf(buf, sizeof(buf), "%d", mdb->db_port);
      port = buf;
   } else {
      port = NULL;
   }
   
   numdrivers = dbi_initialize_r(mdb->db_driverdir, &(mdb->instance));
   if (numdrivers < 0) {
      Mmsg2(&mdb->errmsg, _("Unable to locate the DBD drivers to DBI interface in: \n"
                               "db_driverdir=%s. It is probaly not found any drivers\n"),
                               mdb->db_driverdir,numdrivers);
      V(mutex);
      return 0;
   }
   mdb->db = (void **)dbi_conn_new_r(mdb->db_driver, mdb->instance);
   dbi_conn_set_option(mdb->db, "host", mdb->db_address); /* default = localhost */
   dbi_conn_set_option(mdb->db, "port", port);            /* default port */
   dbi_conn_set_option(mdb->db, "username", mdb->db_user);     /* login name */
   dbi_conn_set_option(mdb->db, "password", mdb->db_password); /* password */
   dbi_conn_set_option(mdb->db, "dbname", mdb->db_name);       /* database name */
      
   /* If connection fails, try at 5 sec intervals for 30 seconds. */
   for (int retry=0; retry < 6; retry++) {
         
      dbstat = dbi_conn_connect(mdb->db); 
      if ( dbstat == 0) {
         break;
      }
         
      dbi_conn_error(mdb->db, &errmsg);
      Dmsg1(50, "dbi error: %s\n", errmsg);
                   
      bmicrosleep(5, 0);
         
   }
   
   if ( dbstat != 0 ) {
      Mmsg3(&mdb->errmsg, _("Unable to connect to DBI interface.\n"
                       "Type=%s Database=%s User=%s\n"
                       "It is probably not running or your password is incorrect.\n"),
                        mdb->db_driver, mdb->db_name, mdb->db_user);
      V(mutex);
      return 0;           
   } 
   
   Dmsg0(50, "dbi_real_connect done\n");
   Dmsg3(50, "db_user=%s db_name=%s db_password=%s\n",
                    mdb->db_user, mdb->db_name,
                    mdb->db_password==NULL?"(NULL)":mdb->db_password);

   mdb->connected = true;

   if (!check_tables_version(jcr, mdb)) {
      V(mutex);
      return 0;
   }
   
   switch (mdb->db_type) {
   case SQL_TYPE_MYSQL:
      /* Set connection timeout to 8 days specialy for batch mode */
      sql_query(mdb, "SET wait_timeout=691200");
      sql_query(mdb, "SET interactive_timeout=691200");
      break;
   case SQL_TYPE_POSTGRESQL:
      /* tell PostgreSQL we are using standard conforming strings
         and avoid warnings such as:
         WARNING:  nonstandard use of \\ in a string literal
      */
      sql_query(mdb, "SET datestyle TO 'ISO, YMD'");
      sql_query(mdb, "set standard_conforming_strings=on");
      break;
   case SQL_TYPE_SQLITE:
      break;
   }
   
   V(mutex);
   return 1;
}

void
db_close_database(JCR *jcr, B_DB *mdb)
{
   if (!mdb) {
      return;
   }
   db_end_transaction(jcr, mdb);
   P(mutex);
   sql_free_result(mdb);
   mdb->ref_count--;
   if (mdb->ref_count == 0) {
      qdchain(&mdb->bq);
      if (mdb->connected && mdb->db) {
         //sql_close(mdb);
         dbi_shutdown_r(mdb->instance);
         mdb->db = NULL;
         mdb->instance = NULL;
      }
      rwl_destroy(&mdb->lock);
      free_pool_memory(mdb->errmsg);
      free_pool_memory(mdb->cmd);
      free_pool_memory(mdb->cached_path);
      free_pool_memory(mdb->fname);
      free_pool_memory(mdb->path);
      free_pool_memory(mdb->esc_name);
      free_pool_memory(mdb->esc_path);
      if (mdb->db_name) {
         free(mdb->db_name);
      }
      if (mdb->db_user) {
         free(mdb->db_user);
      }
      if (mdb->db_password) {
         free(mdb->db_password);
      }
      if (mdb->db_address) {
         free(mdb->db_address);
      }
      if (mdb->db_socket) {
         free(mdb->db_socket);
      }
      if (mdb->db_driverdir) {
         free(mdb->db_driverdir);
      }
      if (mdb->db_driver) {
          free(mdb->db_driver);
      }
      free(mdb);            
   }   
   V(mutex);
}

void db_thread_cleanup()
{ }

/*
 * Return the next unique index (auto-increment) for
 * the given table.  Return NULL on error.
 *
 */
int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
{
   strcpy(index, "NULL");
   return 1;
}


/*
 * Escape strings so that DBI is happy
 *
 *   NOTE! len is the length of the old string. Your new
 *         string must be long enough (max 2*old+1) to hold
 *         the escaped output.
 * 
 * dbi_conn_quote_string_copy receives a pointer to pointer.
 * We need copy the value of pointer to snew because libdbi change the 
 * pointer
 */
void
db_escape_string(JCR *jcr, B_DB *mdb, char *snew, char *old, int len)
{
   char *inew;
   char *pnew;
   
   if (len == 0) {
      snew[0] = 0; 
   } else {
      /* correct the size of old basead in len
       * and copy new string to inew
       */
      inew = (char *)malloc(sizeof(char) * len + 1);
      bstrncpy(inew,old,len + 1);
      /* escape the correct size of old */
      dbi_conn_escape_string_copy(mdb->db, inew, &pnew);
      free(inew);
      /* copy the escaped string to snew */
      bstrncpy(snew, pnew, 2 * len + 1);   
   }
   
   Dmsg2(500, "dbi_conn_escape_string_copy %p %s\n",snew,snew);
   
}

/*
 * Submit a general SQL command (cmd), and for each row returned,
 *  the sqlite_handler is called with the ctx.
 */
bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
{
   SQL_ROW row;

   Dmsg0(500, "db_sql_query started\n");

   db_lock(mdb);
   if (sql_query(mdb, query) != 0) {
      Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
      db_unlock(mdb);
      Dmsg0(500, "db_sql_query failed\n");
      return false;
   }
   Dmsg0(500, "db_sql_query succeeded. checking handler\n");

   if (result_handler != NULL) {
      Dmsg0(500, "db_sql_query invoking handler\n");
      if ((mdb->result = sql_store_result(mdb)) != NULL) {
         int num_fields = sql_num_fields(mdb);

         Dmsg0(500, "db_sql_query sql_store_result suceeded\n");
         while ((row = sql_fetch_row(mdb)) != NULL) {

            Dmsg0(500, "db_sql_query sql_fetch_row worked\n");
            if (result_handler(ctx, num_fields, row))
               break;
         }

        sql_free_result(mdb);
      }
   }
   db_unlock(mdb);

   Dmsg0(500, "db_sql_query finished\n");

   return true;
}



DBI_ROW my_dbi_fetch_row(B_DB *mdb)
{
   int j;
   DBI_ROW row = NULL; // by default, return NULL

   Dmsg0(500, "my_dbi_fetch_row start\n");

   if (!mdb->row || mdb->row_size < mdb->num_fields) {
      int num_fields = mdb->num_fields;
      Dmsg1(500, "we have need space of %d bytes\n", sizeof(char *) * mdb->num_fields);

      if (mdb->row) {
         Dmsg0(500, "my_dbi_fetch_row freeing space\n");
         Dmsg2(500, "my_dbi_free_row row: '%p' num_fields: '%d'\n", mdb->row, mdb->num_fields);
         if (mdb->num_rows != 0) {
            for(j = 0; j < mdb->num_fields; j++) {
               Dmsg2(500, "my_dbi_free_row row '%p' '%d'\n", mdb->row[j], j);
                  if(mdb->row[j]) {
                     free(mdb->row[j]);
                  }                  
            } 
         }
         free(mdb->row);
      }
      num_fields += 20;                  /* add a bit extra */
      mdb->row = (DBI_ROW)malloc(sizeof(char *) * num_fields);
      mdb->row_size = num_fields;

      // now reset the row_number now that we have the space allocated
      mdb->row_number = 1;
   }

   // if still within the result set
   if (mdb->row_number <= mdb->num_rows) {
      Dmsg2(500, "my_dbi_fetch_row row number '%d' is acceptable (0..%d)\n", mdb->row_number, mdb->num_rows);
      // get each value from this row
      for (j = 0; j < mdb->num_fields; j++) {
         mdb->row[j] = my_dbi_getvalue(mdb->result, mdb->row_number, j);
         Dmsg3(500, "my_dbi_fetch_row field '%p' '%d' has value '%s'\n",mdb->row[j], j, mdb->row[j]);
      }
      // increment the row number for the next call
      mdb->row_number++;

      row = mdb->row;
   } else {
      Dmsg2(500, "my_dbi_fetch_row row number '%d' is NOT acceptable (0..%d)\n", mdb->row_number, mdb->num_rows);
   }

   Dmsg1(500, "my_dbi_fetch_row finishes returning %p\n", row);

   return row;
}

int my_dbi_max_length(B_DB *mdb, int field_num) {
   //
   // for a given column, find the max length
   //
   int max_length;
   int i;
   int this_length;
   char *cbuf;

   max_length = 0;
   for (i = 0; i < mdb->num_rows; i++) {
      if (my_dbi_getisnull(mdb->result, i, field_num)) {
          this_length = 4;        // "NULL"
      } else {
          // TODO: error
         cbuf = my_dbi_getvalue(mdb->result, i, field_num);
         this_length = cstrlen(cbuf);
         free(cbuf);
      }

      if (max_length < this_length) {
          max_length = this_length;
      }
   }

   return max_length;
}

DBI_FIELD * my_dbi_fetch_field(B_DB *mdb)
{
   int     i;
   int     dbi_index;

   Dmsg0(500, "my_dbi_fetch_field starts\n");

   if (!mdb->fields || mdb->fields_size < mdb->num_fields) {
      if (mdb->fields) {
         free(mdb->fields);
      }
      Dmsg1(500, "allocating space for %d fields\n", mdb->num_fields);
      mdb->fields = (DBI_FIELD *)malloc(sizeof(DBI_FIELD) * mdb->num_fields);
      mdb->fields_size = mdb->num_fields;

      for (i = 0; i < mdb->num_fields; i++) {
         dbi_index = i + 1;
         Dmsg1(500, "filling field %d\n", i);
         mdb->fields[i].name       = (char *)dbi_result_get_field_name(mdb->result, dbi_index);
         mdb->fields[i].max_length = my_dbi_max_length(mdb, i);
         mdb->fields[i].type       = dbi_result_get_field_type_idx(mdb->result, dbi_index);
         mdb->fields[i].flags      = dbi_result_get_field_attribs_idx(mdb->result, dbi_index);

         Dmsg4(500, "my_dbi_fetch_field finds field '%s' has length='%d' type='%d' and IsNull=%d\n",
            mdb->fields[i].name, mdb->fields[i].max_length, mdb->fields[i].type,
            mdb->fields[i].flags);
      } // end for
   } // end if

   // increment field number for the next time around

   Dmsg0(500, "my_dbi_fetch_field finishes\n");
   return &mdb->fields[mdb->field_number++];
}

void my_dbi_data_seek(B_DB *mdb, int row)
{
   // set the row number to be returned on the next call
   // to my_dbi_fetch_row
   mdb->row_number = row;
}

void my_dbi_field_seek(B_DB *mdb, int field)
{
   mdb->field_number = field;
}

/*
 * Note, if this routine returns 1 (failure), Bacula expects
 *  that no result has been stored.
 *
 *  Returns:  0  on success
 *            1  on failure
 *
 */
int my_dbi_query(B_DB *mdb, const char *query)
{
   const char *errmsg;
   Dmsg1(500, "my_dbi_query started %s\n", query);
   // We are starting a new query.  reset everything.
   mdb->num_rows     = -1;
   mdb->row_number   = -1;
   mdb->field_number = -1;

   if (mdb->result) {
      dbi_result_free(mdb->result);  /* hmm, someone forgot to free?? */
      mdb->result = NULL;
   }
         
   mdb->result = (void **)dbi_conn_query(mdb->db, query);
      
   if (!mdb->result) {
      Dmsg2(50, "Query failed: %s %p\n", query, mdb->result);      
      goto bail_out;
   }
   
   mdb->status = (dbi_error_flag) dbi_conn_error(mdb->db, &errmsg);
   
   if (mdb->status == DBI_ERROR_NONE) {
      Dmsg1(500, "we have a result\n", query);

      // how many fields in the set?
      mdb->num_fields = dbi_result_get_numfields(mdb->result);
      Dmsg1(500, "we have %d fields\n", mdb->num_fields);

      mdb->num_rows = dbi_result_get_numrows(mdb->result);
      Dmsg1(500, "we have %d rows\n", mdb->num_rows);

      mdb->status = (dbi_error_flag) 0;                  /* succeed */
   } else {
      Dmsg1(50, "Result status failed: %s\n", query);
      goto bail_out;
   }

   Dmsg0(500, "my_dbi_query finishing\n");
   return mdb->status;

bail_out:
   mdb->status = (dbi_error_flag) dbi_conn_error(mdb->db,NULL);
   dbi_conn_error(mdb->db, &errmsg);
   Dmsg4(500, "my_dbi_query we failed dbi error: "
                   "'%s' '%p' '%d' flag '%d''\n", errmsg, mdb->result, mdb->result, mdb->status);
   dbi_result_free(mdb->result);
   mdb->result = NULL;
   mdb->status = (dbi_error_flag) 1;                   /* failed */
   return mdb->status;
}

void my_dbi_free_result(B_DB *mdb)
{ 
   
   db_lock(mdb);  
   int i = 0;
   if (mdb->result) {
      Dmsg1(500, "my_dbi_free_result result '%p'\n", mdb->result);
      dbi_result_free(mdb->result);
   }

   mdb->result = NULL;
   
   if (mdb->row) {
      Dmsg2(500, "my_dbi_free_result row: '%p' num_fields: '%d'\n", mdb->row, mdb->num_fields);
      if (mdb->num_rows != 0) {
         for(i = 0; i < mdb->num_fields; i++) {
            Dmsg2(500, "my_dbi_free_result row '%p' '%d'\n", mdb->row[i], i);
            if(mdb->row[i]) {
               free(mdb->row[i]);
            }
         } 
      }
      free(mdb->row);
      mdb->row = NULL;
   }

   if (mdb->fields) {
      free(mdb->fields);
      mdb->fields = NULL;
   }
   db_unlock(mdb);
   //Dmsg0(500, "my_dbi_free_result finish\n");
   
}

const char *my_dbi_strerror(B_DB *mdb) 
{
   const char *errmsg;
   
   dbi_conn_error(mdb->db, &errmsg);
        
   return errmsg;
}

#ifdef HAVE_BATCH_FILE_INSERT

/*
 * This can be a bit strang but is the one way to do
 * 
 * Returns 1 if OK
 *         0 if failed
 */
int my_dbi_batch_start(JCR *jcr, B_DB *mdb)
{
   char *query;
   
   Dmsg0(500, "my_dbi_batch_start started\n");
   
   switch (mdb->db_type) {
   case SQL_TYPE_MYSQL:
      db_lock(mdb);
      if (my_dbi_query(mdb,
                              "CREATE TEMPORARY TABLE batch ("
                                  "FileIndex integer,"
                                  "JobId integer,"
                                  "Path blob,"
                                  "Name blob,"
                                  "LStat tinyblob,"
                                  "MD5 tinyblob)") == 1)
      {
         Dmsg0(500, "my_dbi_batch_start failed\n");
         return 1;
      }
      db_unlock(mdb);
      Dmsg0(500, "my_dbi_batch_start finishing\n");
      return 1;
      break;
   case SQL_TYPE_POSTGRESQL:
      query = "COPY batch FROM STDIN";

      if (my_dbi_query(mdb,
                              "CREATE TEMPORARY TABLE batch ("
                                  "fileindex int,"
                                  "jobid int,"
                                  "path varchar,"
                                  "name varchar,"
                                  "lstat varchar,"
                                  "md5 varchar)") == 1)
      {
         Dmsg0(500, "my_dbi_batch_start failed\n");
         return 1;
      }
      
      // We are starting a new query.  reset everything.
      mdb->num_rows     = -1;
      mdb->row_number   = -1;
      mdb->field_number = -1;

      my_dbi_free_result(mdb);

      for (int i=0; i < 10; i++) {
         my_dbi_query(mdb, query);
         if (mdb->result) {
            break;
         }
         bmicrosleep(5, 0);
      }
      if (!mdb->result) {
         Dmsg1(50, "Query failed: %s\n", query);
         goto bail_out;
      }

      //mdb->status = (dbi_error_flag)dbi_conn_error_flag(mdb->db);
      mdb->status = DBI_ERROR_NONE;
         
      if (mdb->status == DBI_ERROR_NONE) {
         // how many fields in the set?
         mdb->num_fields = dbi_result_get_numfields(mdb->result);
         mdb->num_rows   = dbi_result_get_numrows(mdb->result);
         mdb->status = (dbi_error_flag) 1;
      } else {
         Dmsg1(50, "Result status failed: %s\n", query);
         goto bail_out;
      }

      Dmsg0(500, "my_postgresql_batch_start finishing\n");

      return mdb->status;
      break;
   case SQL_TYPE_SQLITE:
      db_lock(mdb);
      if (my_dbi_query(mdb,
                              "CREATE TEMPORARY TABLE batch ("
                                  "FileIndex integer,"
                                  "JobId integer,"
                                  "Path blob,"
                                  "Name blob,"
                                  "LStat tinyblob,"
                                  "MD5 tinyblob)") == 1)
      {
         Dmsg0(500, "my_dbi_batch_start failed\n");
         goto bail_out;
      }
      db_unlock(mdb);
      Dmsg0(500, "my_dbi_batch_start finishing\n");
      return 1;
      break;
   }
   
bail_out:
   Mmsg1(&mdb->errmsg, _("error starting batch mode: %s"), my_dbi_strerror(mdb));
   mdb->status = (dbi_error_flag) 0;
   my_dbi_free_result(mdb);
   mdb->result = NULL;
   return mdb->status;
}

/* set error to something to abort operation */
int my_dbi_batch_end(JCR *jcr, B_DB *mdb, const char *error)
{
   Dmsg0(500, "my_dbi_batch_end started\n");

   if (!mdb) {                  /* no files ? */
      return 0;
   }

   switch (mdb->db_type) {
   case SQL_TYPE_MYSQL:
      if(mdb) {
         mdb->status = (dbi_error_flag) 0;
      }
      break;
   case SQL_TYPE_POSTGRESQL:
//      do { 
//            //res = PQputCopyEnd(mdb->db, error);
//            res = 1;
//         } while (res == 0 && --count > 0);
//
//         if (res == 1) {
//            Dmsg0(500, "ok\n");
//            mdb->status = (dbi_error_flag) 1;
//         }
//         
      //   if (res <= 0) {
      //      Dmsg0(500, "we failed\n");
      //      mdb->status = 0;
      //      Mmsg1(&mdb->errmsg, _("error ending batch mode: %s"), PQerrorMessage(mdb->db));
      //   }
      break;
   case SQL_TYPE_SQLITE:
      if(mdb) {
         mdb->status = (dbi_error_flag) 0;
      }
      break;
   }

   Dmsg0(500, "my_dbi_batch_end finishing\n");

   return true;      
}

int my_dbi_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
{
   int res;
   int count=30;
   //dbi_conn_t *myconn = *(mdb->db);
   dbi_conn_t *myconn;  
   int (*custom_function)(void*, const char*, int);   
   size_t len;
   char *digest;
   char ed1[50];

   Dmsg0(500, "my_dbi_batch_insert started \n");
   
   mdb->esc_name = check_pool_memory_size(mdb->esc_name, mdb->fnl*2+1);
   db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);

   mdb->esc_path = check_pool_memory_size(mdb->esc_path, mdb->pnl*2+1);
   db_escape_string(jcr, mdb, mdb->esc_path, mdb->path, mdb->pnl);


   if (ar->Digest == NULL || ar->Digest[0] == 0) {
      digest = "0";
   } else {
      digest = ar->Digest;
   }

   switch (mdb->db_type) {
   case SQL_TYPE_MYSQL:
      len = Mmsg(mdb->cmd, "INSERT INTO batch VALUES (%u,%s,'%s','%s','%s','%s')",
                      ar->FileIndex, edit_int64(ar->JobId,ed1), mdb->esc_path, 
                      mdb->esc_name, ar->attr, digest);
      if (my_dbi_query(mdb,mdb->cmd) == 1)
      {
         Dmsg0(500, "my_dbi_batch_insert failed\n");
         goto bail_out;
      }
      
      Dmsg0(500, "my_dbi_batch_insert finishing\n");
      
      return 1;
      break;
   case SQL_TYPE_POSTGRESQL:
      len = Mmsg(mdb->cmd, "%u\t%s\t%s\t%s\t%s\t%s\n", 
                     ar->FileIndex, edit_int64(ar->JobId, ed1), mdb->esc_path, 
                     mdb->esc_name, ar->attr, digest);
      
      /* libdbi don't support CopyData and we need call a postgresql
       * specific function to do this work
       */
      if ((custom_function = dbi_driver_specific_function(dbi_conn_get_driver(mdb->db), "PQputCopyData")) != NULL) {
         do { 
            res = custom_function(myconn->connection, (const char *)mdb->cmd, (int)len);
         } while (res == 0 && --count > 0);

         if (res == 1) {
            Dmsg0(500, "ok\n");
            mdb->changes++;
            mdb->status = (dbi_error_flag) 1;
         }

         if (res <= 0) {
            Dmsg0(500, "my_dbi_batch_insert failed\n");
            goto bail_out;
         }

         Dmsg0(500, "my_dbi_batch_insert finishing\n");
         return mdb->status;
      } else {
         Dmsg0(500, "my_dbi_batch_insert failed\n");
         goto bail_out;
      }
      break;
   case SQL_TYPE_SQLITE:
      len = Mmsg(mdb->cmd, "INSERT INTO batch VALUES (%u,%s,'%s','%s','%s','%s')",
                      ar->FileIndex, edit_int64(ar->JobId,ed1), mdb->esc_path, 
                      mdb->esc_name, ar->attr, digest);
      if (my_dbi_query(mdb,mdb->cmd) == 1)
      {
         Dmsg0(500, "my_dbi_batch_insert failed\n");
         goto bail_out;
      }
      
      Dmsg0(500, "my_dbi_batch_insert finishing\n");
      
      return 1;
      break;
   }
    
bail_out:
  Mmsg1(&mdb->errmsg, _("error inserting batch mode: %s"), my_dbi_strerror(mdb));
  mdb->status = (dbi_error_flag) 0;
  my_dbi_free_result(mdb);  
  return mdb->status;
}

#endif /* HAVE_BATCH_FILE_INSERT */

/* my_dbi_getisnull
 * like PQgetisnull
 * int PQgetisnull(const PGresult *res,
 *              int row_number,
 *               int column_number);
 * 
 *  use dbi_result_seek_row to search in result set
 */
int my_dbi_getisnull(dbi_result *result, int row_number, int column_number) {
   int i;

   if(row_number == 0) {
      row_number++;
   }
   
   column_number++;
   
   if(dbi_result_seek_row(result, row_number)) {

      i = dbi_result_field_is_null_idx(result,column_number);

      return i;
   } else {
           
      return 0;
   }
                
}
/* my_dbi_getvalue 
 * like PQgetvalue;
 * char *PQgetvalue(const PGresult *res,
 *                int row_number,
 *                int column_number);
 *
 * use dbi_result_seek_row to search in result set
 * use example to return only strings
 */
char *my_dbi_getvalue(dbi_result *result, int row_number, unsigned int column_number) {

   /* TODO: This is very bad, need refactoring */
   //POOLMEM *buf = get_pool_memory(PM_FNAME);
   char *buf = NULL;
   const char *errmsg;
   const char *field_name;     
   unsigned short dbitype;
   int32_t field_length = 0;
   int64_t num;
        
   /* correct the index for dbi interface
    * dbi index begins 1
    * I prefer do not change others functions
    */
   Dmsg3(600, "my_dbi_getvalue pre-starting result '%p' row number '%d' column number '%d'\n", 
                                result, row_number, column_number);
        
   column_number++;

   if(row_number == 0) {
     row_number++;
   }
      
   Dmsg3(600, "my_dbi_getvalue starting result '%p' row number '%d' column number '%d'\n", 
                        result, row_number, column_number);
   
   if(dbi_result_seek_row(result, row_number)) {

      field_name = dbi_result_get_field_name(result, column_number);
      field_length = dbi_result_get_field_length(result, field_name);
      dbitype = dbi_result_get_field_type_idx(result,column_number);
      
      if(field_length) {
         //buf = check_pool_memory_size(buf, field_length + 1);
         buf = (char *)malloc(sizeof(char *) * field_length + 1);
      } else {
         /* if numbers */
         //buf = check_pool_memory_size(buf, 50);
         buf = (char *)malloc(sizeof(char *) * 50);
      }
      
      Dmsg4(500, "my_dbi_getvalue result '%p' type '%d' \n\tfield name '%s'\n\t"
            "field_length '%d'\n", 
            result, dbitype, field_name, field_length);
      
      switch (dbitype) {
      case DBI_TYPE_INTEGER:
         num = dbi_result_get_longlong(result, field_name);         
         edit_int64(num, buf);
         field_length = strlen(buf);
         break;
      case DBI_TYPE_STRING:
         if(field_length) {
            field_length = bsnprintf(buf, field_length + 1, "%s", 
            dbi_result_get_string(result, field_name));
         } else {
            buf[0] = 0;
         }
         break;
      case DBI_TYPE_BINARY:
         /* dbi_result_get_binary return a NULL pointer if value is empty
         * following, change this to what Bacula espected
         */
         if(field_length) {
            field_length = bsnprintf(buf, field_length + 1, "%s", 
                  dbi_result_get_binary(result, field_name));
         } else {
            buf[0] = 0;
         }
         break;
      case DBI_TYPE_DATETIME:
         time_t last;
         struct tm tm;
         
         last = dbi_result_get_datetime(result, field_name);
         
         if(last == -1) {
                field_length = bsnprintf(buf, 20, "0000-00-00 00:00:00"); 
         } else {
            (void)localtime_r(&last, &tm);
            field_length = bsnprintf(buf, 20, "%04d-%02d-%02d %02d:%02d:%02d",
                  (tm.tm_year + 1900), (tm.tm_mon + 1), tm.tm_mday,
                  tm.tm_hour, tm.tm_min, tm.tm_sec);
         }
         break;
      }

   } else {
      dbi_conn_error(dbi_result_get_conn(result), &errmsg);
      Dmsg1(500, "my_dbi_getvalue error: %s\n", errmsg);
   }
                
   Dmsg3(500, "my_dbi_getvalue finish result '%p' num bytes '%d' data '%s'\n", 
      result, field_length, buf);
   
   return buf;
}

int my_dbi_sql_insert_id(B_DB *mdb, char *table_name)
{
   /*
    Obtain the current value of the sequence that
    provides the serial value for primary key of the table.

    currval is local to our session.  It is not affected by
    other transactions.

    Determine the name of the sequence.
    PostgreSQL automatically creates a sequence using
    <table>_<column>_seq.
    At the time of writing, all tables used this format for
    for their primary key: <table>id
    Except for basefiles which has a primary key on baseid.
    Therefore, we need to special case that one table.

    everything else can use the PostgreSQL formula.
   */
   
   char      sequence[30];  
   uint64_t    id = 0;

   if (mdb->db_type == SQL_TYPE_POSTGRESQL) {
           
      if (strcasecmp(table_name, "basefiles") == 0) {
         bstrncpy(sequence, "basefiles_baseid", sizeof(sequence));
      } else {
         bstrncpy(sequence, table_name, sizeof(sequence));
         bstrncat(sequence, "_",        sizeof(sequence));
         bstrncat(sequence, table_name, sizeof(sequence));
         bstrncat(sequence, "id",       sizeof(sequence));
      }

      bstrncat(sequence, "_seq", sizeof(sequence));
      id = dbi_conn_sequence_last(mdb->db, NT_(sequence));
   } else {
      id = dbi_conn_sequence_last(mdb->db, NT_(table_name));
   }
   
   return id;
}

#ifdef HAVE_BATCH_FILE_INSERT
const char *my_dbi_batch_lock_path_query[3] = {
   /* Mysql */
   "LOCK TABLES Path write, batch write, Path as p write",
   /* Postgresql */
   "BEGIN; LOCK TABLE Path IN SHARE ROW EXCLUSIVE MODE",
   /* SQLite */
   "BEGIN"};  

const char *my_dbi_batch_lock_filename_query[3] = {
   /* Mysql */
   "LOCK TABLES Filename write, batch write, Filename as f write",
   /* Postgresql */
   "BEGIN; LOCK TABLE Filename IN SHARE ROW EXCLUSIVE MODE",
   /* SQLite */
   "BEGIN"};

const char *my_dbi_batch_unlock_tables_query[3] = {
   /* Mysql */
   "UNLOCK TABLES",
   /* Postgresql */
   "COMMIT",
   /* SQLite */
   "COMMIT"};

const char *my_dbi_batch_fill_path_query[3] = {
   /* Mysql */
   "INSERT INTO Path (Path) "
   "SELECT a.Path FROM " 
   "(SELECT DISTINCT Path FROM batch) AS a WHERE NOT EXISTS "
   "(SELECT Path FROM Path AS p WHERE p.Path = a.Path)",
   /* Postgresql */
   "INSERT INTO Path (Path) "
   "SELECT a.Path FROM "
   "(SELECT DISTINCT Path FROM batch) AS a "
   "WHERE NOT EXISTS (SELECT Path FROM Path WHERE Path = a.Path) ",
   /* SQLite */
   "INSERT INTO Path (Path)" 
   " SELECT DISTINCT Path FROM batch"
   " EXCEPT SELECT Path FROM Path"};

const char *my_dbi_batch_fill_filename_query[3] = {
   /* Mysql */
   "INSERT INTO Filename (Name) "
   "SELECT a.Name FROM " 
   "(SELECT DISTINCT Name FROM batch) AS a WHERE NOT EXISTS "
   "(SELECT Name FROM Filename AS f WHERE f.Name = a.Name)",
   /* Postgresql */
   "INSERT INTO Filename (Name) "
   "SELECT a.Name FROM "
   "(SELECT DISTINCT Name FROM batch) as a "
   "WHERE NOT EXISTS "
   "(SELECT Name FROM Filename WHERE Name = a.Name)",
   /* SQLite */
   "INSERT INTO Filename (Name)"
   " SELECT DISTINCT Name FROM batch "
   " EXCEPT SELECT Name FROM Filename"};
#endif /* HAVE_BATCH_FILE_INSERT */

#endif /* HAVE_DBI */
/*
   Bacula® - The Network Backup Solution

   Copyright (C) 2000-2008 Free Software Foundation Europe e.V.

   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 two of the GNU 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
   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., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.

   Bacula® is a registered trademark of John Walker.
   The licensor of Bacula is the Free Software Foundation Europe
   (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
   Switzerland, email:ftf@xxxxxxxxxxxxxx
*/
/*
 * SQL header file
 *
 *   by Kern E. Sibbald
 *
 *   Anyone who accesses the database will need to include
 *   this file.
 *
 * This file contains definitions common to sql.c and
 * the external world, and definitions destined only
 * for the external world. This is control with
 * the define __SQL_C, which is defined only in sql.c
 *
 *    Version $Id: cats.h 6469 2008-02-23 09:01:32Z kerns $
 */

/*
   Here is how database versions work. 

   While I am working on a new release with database changes, the
   update scripts are in the src/cats directory under the names
   update_xxx_tables.in.  Most of the time, I make database updates
   in one go and immediately update the version, but not always.  If
   there are going to be several updates as is the case with version
   1.37, then I will often forgo changing the version until the last
   update otherwise I will end up with too many versions and a lot
   of confusion.

   When I am pretty sure there will be no more updates, I will
   change the version from 8 to 9 (in the present case), and when I
   am 100% sure there will be no more changes, the update script
   will be copied to the updatedb directory with the correct name
   (in the present case 8 to 9).

   Now, in principle, each of the different DB implementations 
   can have a different version, but in practice they are all
   the same (simplifies things). The exception is the internal
   database, which is no longer used, and hence, no longer changes.
 */


#ifndef __SQL_H_
#define __SQL_H_ 1

enum {
   SQL_TYPE_MYSQL      = 0,
   SQL_TYPE_POSTGRESQL = 1,
   SQL_TYPE_SQLITE     = 2
};


typedef void (DB_LIST_HANDLER)(void *, const char *);
typedef int (DB_RESULT_HANDLER)(void *, int, char **);

#define db_lock(mdb)   _db_lock(__FILE__, __LINE__, mdb)
#define db_unlock(mdb) _db_unlock(__FILE__, __LINE__, mdb)

#ifdef __SQL_C

#if defined(BUILDING_CATS)
#ifdef HAVE_SQLITE

#define BDB_VERSION 10

#include <sqlite.h>

/* Define opaque structure for sqlite */
struct sqlite {
   char dummy;
};

#define IS_NUM(x)             ((x) == 1)
#define IS_NOT_NULL(x)        ((x) == 1)

typedef struct s_sql_field {
   char *name;                        /* name of column */
   int length;                        /* length */
   int max_length;                    /* max length */
   uint32_t type;                     /* type */
   uint32_t flags;                    /* flags */
} SQL_FIELD;

/*
 * This is the "real" definition that should only be
 * used inside sql.c and associated database interface
 * subroutines.
 *                    S Q L I T E
 */
struct B_DB {
   BQUEUE bq;                         /* queue control */
   brwlock_t lock;                    /* transaction lock */
   struct sqlite *db;
   char **result;
   int status;
   int nrow;                          /* nrow returned from sqlite */
   int ncolumn;                       /* ncolum returned from sqlite */
   int num_rows;                      /* used by code */
   int row;                           /* seek row */
   int field;                         /* seek field */
   SQL_FIELD **fields;                /* defined fields */
   int ref_count;
   char *db_name;
   char *db_user;
   char *db_address;                  /* host name address */
   char *db_socket;                   /* socket for local access */
   char *db_password;
   int  db_port;                      /* port for host name address */
   bool connected;                    /* connection made to db */
   bool have_insert_id;               /* do not have insert id */
   bool fields_defined;               /* set when fields defined */
   char *sqlite_errmsg;               /* error message returned by sqlite */
   POOLMEM *errmsg;                   /* nicely edited error message */
   POOLMEM *cmd;                      /* SQL command string */
   POOLMEM *cached_path;              /* cached path name */
   int cached_path_len;               /* length of cached path */
   uint32_t cached_path_id;           /* cached path id */
   bool allow_transactions;           /* transactions allowed */
   bool transaction;                  /* transaction started */
   int changes;                       /* changes during transaction */
   POOLMEM *fname;                    /* Filename only */
   POOLMEM *path;                     /* Path only */
   POOLMEM *esc_name;                 /* Escaped file name */
   POOLMEM *esc_path;                 /* Escaped path name */
   int fnl;                           /* file name length */
   int pnl;                           /* path name length */
};


/*
 * "Generic" names for easier conversion
 *
 *                    S Q L I T E
 */
#define sql_store_result(x)   (x)->result
#define sql_free_result(x)    my_sqlite_free_table(x)
#define sql_fetch_row(x)      my_sqlite_fetch_row(x)
#define sql_query(x, y)       my_sqlite_query((x), (y))
#ifdef HAVE_SQLITE3
#define sql_insert_id(x,y)    sqlite3_last_insert_rowid((x)->db)
#define sql_close(x)          sqlite3_close((x)->db)
#else
#define sql_insert_id(x,y)    sqlite_last_insert_rowid((x)->db)
#define sql_close(x)          sqlite_close((x)->db)
#endif
#define sql_strerror(x)       (x)->sqlite_errmsg?(x)->sqlite_errmsg:"unknown"
#define sql_num_rows(x)       (x)->nrow
#define sql_data_seek(x, i)   (x)->row = (i)
#define sql_affected_rows(x)  1
#define sql_field_seek(x, y)  my_sqlite_field_seek((x), (y))
#define sql_fetch_field(x)    my_sqlite_fetch_field(x)
#define sql_num_fields(x)     ((x)->ncolumn)
#define SQL_ROW               char**

#define sql_batch_start(x,y)    my_batch_start(x,y) 
#define sql_batch_end(x,y,z)    my_batch_end(x,y,z)   
#define sql_batch_insert(x,y,z) my_batch_insert(x,y,z)
#define sql_batch_lock_path_query       my_sqlite_batch_lock_query
#define sql_batch_lock_filename_query   my_sqlite_batch_lock_query
#define sql_batch_unlock_tables_query   my_sqlite_batch_unlock_query
#define sql_batch_fill_filename_query   my_sqlite_batch_fill_filename_query
#define sql_batch_fill_path_query       my_sqlite_batch_fill_path_query    

/* In cats/sqlite.c */
void       my_sqlite_free_table(B_DB *mdb);
SQL_ROW    my_sqlite_fetch_row(B_DB *mdb);
int        my_sqlite_query(B_DB *mdb, const char *cmd);
void       my_sqlite_field_seek(B_DB *mdb, int field);
SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb);
extern const char* my_sqlite_batch_lock_query;
extern const char* my_sqlite_batch_unlock_query;
extern const char* my_sqlite_batch_fill_filename_query;
extern const char* my_sqlite_batch_fill_path_query;


#else

/*                    S Q L I T E 3            */
 

#ifdef HAVE_SQLITE3


#define BDB_VERSION 10

#include <sqlite3.h>

/* Define opaque structure for sqlite */
struct sqlite3 {
   char dummy;
};

#define IS_NUM(x)             ((x) == 1)
#define IS_NOT_NULL(x)        ((x) == 1)

typedef struct s_sql_field {
   char *name;                        /* name of column */
   int length;                        /* length */
   int max_length;                    /* max length */
   uint32_t type;                     /* type */
   uint32_t flags;                    /* flags */
} SQL_FIELD;

/*
 * This is the "real" definition that should only be
 * used inside sql.c and associated database interface
 * subroutines.
 *                    S Q L I T E
 */
struct B_DB {
   BQUEUE bq;                         /* queue control */
   brwlock_t lock;                    /* transaction lock */
   struct sqlite3 *db;
   char **result;
   int status;
   int nrow;                          /* nrow returned from sqlite */
   int ncolumn;                       /* ncolum returned from sqlite */
   int num_rows;                      /* used by code */
   int row;                           /* seek row */
   int field;                         /* seek field */
   SQL_FIELD **fields;                /* defined fields */
   int ref_count;
   char *db_name;
   char *db_user;
   char *db_address;                  /* host name address */
   char *db_socket;                   /* socket for local access */
   char *db_password;
   int  db_port;                      /* port for host name address */
   bool connected;                    /* connection made to db */
   bool have_insert_id;               /* do not have insert id */
   bool fields_defined;               /* set when fields defined */
   char *sqlite_errmsg;               /* error message returned by sqlite */
   POOLMEM *errmsg;                   /* nicely edited error message */
   POOLMEM *cmd;                      /* SQL command string */
   POOLMEM *cached_path;              /* cached path name */
   int cached_path_len;               /* length of cached path */
   uint32_t cached_path_id;           /* cached path id */
   bool allow_transactions;           /* transactions allowed */
   bool transaction;                  /* transaction started */
   int changes;                       /* changes during transaction */
   POOLMEM *fname;                    /* Filename only */
   POOLMEM *path;                     /* Path only */
   POOLMEM *esc_name;                 /* Escaped file name */
   POOLMEM *esc_path;                 /* Escaped path name */
   int fnl;                           /* file name length */
   int pnl;                           /* path name length */
};

/*
 * Conversion of sqlite 2 names to sqlite3
 */
#define sqlite_last_insert_rowid sqlite3_last_insert_rowid
#define sqlite_open sqlite3_open
#define sqlite_close sqlite3_close
#define sqlite_result sqlite3_result
#define sqlite_exec sqlite3_exec
#define sqlite_get_table sqlite3_get_table
#define sqlite_free_table sqlite3_free_table


/*
 * "Generic" names for easier conversion
 *
 *                    S Q L I T E 3
 */
#define sql_store_result(x)   (x)->result
#define sql_free_result(x)    my_sqlite_free_table(x)
#define sql_fetch_row(x)      my_sqlite_fetch_row(x)
#define sql_query(x, y)       my_sqlite_query((x), (y))
#ifdef HAVE_SQLITE3
#define sql_insert_id(x,y)    sqlite3_last_insert_rowid((x)->db)
#define sql_close(x)          sqlite3_close((x)->db)
#else
#define sql_insert_id(x,y)    sqlite_last_insert_rowid((x)->db)
#define sql_close(x)          sqlite_close((x)->db)
#endif
#define sql_strerror(x)       (x)->sqlite_errmsg?(x)->sqlite_errmsg:"unknown"
#define sql_num_rows(x)       (x)->nrow
#define sql_data_seek(x, i)   (x)->row = (i)
#define sql_affected_rows(x)  1
#define sql_field_seek(x, y)  my_sqlite_field_seek((x), (y))
#define sql_fetch_field(x)    my_sqlite_fetch_field(x)
#define sql_num_fields(x)     ((x)->ncolumn)
#define sql_batch_start(x,y)    my_batch_start(x,y)   
#define sql_batch_end(x,y,z)    my_batch_end(x,y,z)   
#define sql_batch_insert(x,y,z) my_batch_insert(x,y,z)
#define SQL_ROW               char**
#define sql_batch_lock_path_query       my_sqlite_batch_lock_query
#define sql_batch_lock_filename_query   my_sqlite_batch_lock_query
#define sql_batch_unlock_tables_query   my_sqlite_batch_unlock_query
#define sql_batch_fill_filename_query   my_sqlite_batch_fill_filename_query
#define sql_batch_fill_path_query       my_sqlite_batch_fill_path_query

/* In cats/sqlite.c */
void       my_sqlite_free_table(B_DB *mdb);
SQL_ROW    my_sqlite_fetch_row(B_DB *mdb);
int        my_sqlite_query(B_DB *mdb, const char *cmd);
void       my_sqlite_field_seek(B_DB *mdb, int field);
SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb);
extern const char* my_sqlite_batch_lock_query;
extern const char* my_sqlite_batch_unlock_query;
extern const char* my_sqlite_batch_fill_filename_query;
extern const char* my_sqlite_batch_fill_path_query;


#else

#ifdef HAVE_MYSQL

#define BDB_VERSION 10

#include <mysql.h>

/*
 * This is the "real" definition that should only be
 * used inside sql.c and associated database interface
 * subroutines.
 *
 *                     M Y S Q L
 */
struct B_DB {
   BQUEUE bq;                         /* queue control */
   brwlock_t lock;                    /* transaction lock */
   MYSQL mysql;
   MYSQL *db;
   MYSQL_RES *result;
   int status;
   my_ulonglong num_rows;
   int ref_count;
   char *db_name;
   char *db_user;
   char *db_password;
   char *db_address;                  /* host address */
   char *db_socket;                   /* socket for local access */
   int db_port;                       /* port of host address */
   int have_insert_id;                /* do have insert_id() */
   bool connected;
   POOLMEM *errmsg;                   /* nicely edited error message */
   POOLMEM *cmd;                      /* SQL command string */
   POOLMEM *cached_path;
   int cached_path_len;               /* length of cached path */
   uint32_t cached_path_id;
   int changes;                       /* changes made to db */
   POOLMEM *fname;                    /* Filename only */
   POOLMEM *path;                     /* Path only */
   POOLMEM *esc_name;                 /* Escaped file name */
   POOLMEM *esc_path;                 /* Escaped path name */
   int fnl;                           /* file name length */
   int pnl;                           /* path name length */
};

#define DB_STATUS int

/* "Generic" names for easier conversion */
#define sql_store_result(x)   mysql_store_result((x)->db)
#define sql_use_result(x)     mysql_use_result((x)->db)
#define sql_free_result(x)    my_mysql_free_result(x)
#define sql_fetch_row(x)      mysql_fetch_row((x)->result)
#define sql_query(x, y)       mysql_query((x)->db, (y))
#define sql_strerror(x)       mysql_error((x)->db)
#define sql_num_rows(x)       mysql_num_rows((x)->result)
#define sql_data_seek(x, i)   mysql_data_seek((x)->result, (i))
#define sql_affected_rows(x)  mysql_affected_rows((x)->db)
#define sql_insert_id(x,y)    mysql_insert_id((x)->db)
#define sql_field_seek(x, y)  mysql_field_seek((x)->result, (y))
#define sql_fetch_field(x)    mysql_fetch_field((x)->result)
#define sql_num_fields(x)     (int)mysql_num_fields((x)->result)
#define SQL_ROW               MYSQL_ROW
#define SQL_FIELD             MYSQL_FIELD

#define sql_batch_start(x,y)    my_batch_start(x,y)
#define sql_batch_end(x,y,z)    my_batch_end(x,y,z)   
#define sql_batch_insert(x,y,z) my_batch_insert(x,y,z)   
#define sql_batch_lock_path_query       my_mysql_batch_lock_path_query
#define sql_batch_lock_filename_query   my_mysql_batch_lock_filename_query
#define sql_batch_unlock_tables_query   my_mysql_batch_unlock_tables_query
#define sql_batch_fill_filename_query   my_mysql_batch_fill_filename_query
#define sql_batch_fill_path_query       my_mysql_batch_fill_path_query


extern const char* my_mysql_batch_lock_path_query;
extern const char* my_mysql_batch_lock_filename_query;
extern const char* my_mysql_batch_unlock_tables_query;
extern const char* my_mysql_batch_fill_filename_query;
extern const char* my_mysql_batch_fill_path_query;
extern void  my_mysql_free_result(B_DB *mdb);

#else

#ifdef HAVE_POSTGRESQL

#define BDB_VERSION 10

#include <libpq-fe.h>

/* TEMP: the following is taken from select OID, typname from pg_type; */
#define IS_NUM(x)        ((x) == 20 || (x) == 21 || (x) == 23 || (x) == 700 || (x) == 701)
#define IS_NOT_NULL(x)   ((x) == 1)

typedef char **POSTGRESQL_ROW;
typedef struct pg_field {
   char         *name;
   int           max_length;
   unsigned int  type;
   unsigned int  flags;       // 1 == not null
} POSTGRESQL_FIELD;


/*
 * This is the "real" definition that should only be
 * used inside sql.c and associated database interface
 * subroutines.
 *
 *                     P O S T G R E S Q L
 */
struct B_DB {
   BQUEUE bq;                         /* queue control */
   brwlock_t lock;                    /* transaction lock */
   PGconn *db;
   PGresult *result;
   int status;
   POSTGRESQL_ROW row;
   POSTGRESQL_FIELD *fields;
   int num_rows;
   int row_size;                  /* size of malloced rows */
   int num_fields;
   int fields_size;               /* size of malloced fields */
   int row_number;                /* row number from my_postgresql_data_seek */
   int field_number;              /* field number from my_postgresql_field_seek */
   int ref_count;
   char *db_name;
   char *db_user;
   char *db_password;
   char *db_address;              /* host address */
   char *db_socket;               /* socket for local access */
   int db_port;                   /* port of host address */
   int have_insert_id;            /* do have insert_id() */
   bool connected;
   POOLMEM *errmsg;               /* nicely edited error message */
   POOLMEM *cmd;                  /* SQL command string */
   POOLMEM *cached_path;
   int cached_path_len;           /* length of cached path */
   uint32_t cached_path_id;
   bool allow_transactions;       /* transactions allowed */
   bool transaction;              /* transaction started */
   int changes;                   /* changes made to db */
   POOLMEM *fname;                /* Filename only */
   POOLMEM *path;                 /* Path only */
   POOLMEM *esc_name;             /* Escaped file name */
   POOLMEM *esc_path;             /* Escaped path name */
   int fnl;                       /* file name length */
   int pnl;                       /* path name length */
};     

void               my_postgresql_free_result(B_DB *mdb);
POSTGRESQL_ROW     my_postgresql_fetch_row  (B_DB *mdb);
int                my_postgresql_query      (B_DB *mdb, const char *query);
void               my_postgresql_data_seek  (B_DB *mdb, int row);
int                my_postgresql_currval    (B_DB *mdb, char *table_name);
void               my_postgresql_field_seek (B_DB *mdb, int row);
POSTGRESQL_FIELD * my_postgresql_fetch_field(B_DB *mdb);

int my_postgresql_batch_start(JCR *jcr, B_DB *mdb);
int my_postgresql_batch_end(JCR *jcr, B_DB *mdb, const char *error);
typedef struct ATTR_DBR ATTR_DBR;
int my_postgresql_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
char *my_postgresql_copy_escape(char *dest, char *src, size_t len);

extern const char* my_pg_batch_lock_path_query;
extern const char* my_pg_batch_lock_filename_query;
extern const char* my_pg_batch_unlock_tables_query;
extern const char* my_pg_batch_fill_filename_query;
extern const char* my_pg_batch_fill_path_query;

/* "Generic" names for easier conversion */
#define sql_store_result(x)   ((x)->result)
#define sql_free_result(x)    my_postgresql_free_result(x)
#define sql_fetch_row(x)      my_postgresql_fetch_row(x)
#define sql_query(x, y)       my_postgresql_query((x), (y))
#define sql_close(x)          PQfinish((x)->db)
#define sql_strerror(x)       PQerrorMessage((x)->db)
#define sql_num_rows(x)       ((unsigned) PQntuples((x)->result))
#define sql_data_seek(x, i)   my_postgresql_data_seek((x), (i))
#define sql_affected_rows(x)  ((unsigned) atoi(PQcmdTuples((x)->result)))
#define sql_insert_id(x,y)    my_postgresql_currval((x), (y))
#define sql_field_seek(x, y)  my_postgresql_field_seek((x), (y))
#define sql_fetch_field(x)    my_postgresql_fetch_field(x)
#define sql_num_fields(x)     ((x)->num_fields)

#define sql_batch_start(x,y)    my_postgresql_batch_start(x,y)   
#define sql_batch_end(x,y,z)    my_postgresql_batch_end(x,y,z)   
#define sql_batch_insert(x,y,z) my_postgresql_batch_insert(x,y,z)
#define sql_batch_lock_path_query       my_pg_batch_lock_path_query
#define sql_batch_lock_filename_query   my_pg_batch_lock_filename_query
#define sql_batch_unlock_tables_query   my_pg_batch_unlock_tables_query
#define sql_batch_fill_filename_query   my_pg_batch_fill_filename_query
#define sql_batch_fill_path_query       my_pg_batch_fill_path_query

#define SQL_ROW               POSTGRESQL_ROW
#define SQL_FIELD             POSTGRESQL_FIELD

#else

#ifdef HAVE_DBI

#define BDB_VERSION 10

#include <dbi/dbi.h>

#ifdef HAVE_BATCH_FILE_INSERT
#include <dbi/dbi-dev.h>
#endif //HAVE_BATCH_FILE_INSERT

#define IS_NUM(x)        ((x) == 1 || (x) == 2 )
#define IS_NOT_NULL(x)   ((x) == (1 << 0))

typedef char **DBI_ROW;
typedef struct dbi_field {
   char         *name;
   int           max_length;
   unsigned int  type;
   unsigned int  flags;       // 1 == not null
} DBI_FIELD;


/*
 * This is the "real" definition that should only be
 * used inside sql.c and associated database interface
 * subroutines.
 *
 *                     D B I
 */
struct B_DB {
   BQUEUE bq;                         /* queue control */
   brwlock_t lock;                    /* transaction lock */
   dbi_conn *db;
   dbi_result *result;
   dbi_inst instance;
   // TODO: change dbi_error_flag to int for more compatible with bacula
   dbi_error_flag status;
   DBI_ROW row;
   DBI_FIELD *fields;
   int num_rows;
   int row_size;                  /* size of malloced rows */
   int num_fields;
   int fields_size;               /* size of malloced fields */
   int row_number;                /* row number from my_postgresql_data_seek */
   int field_number;              /* field number from my_postgresql_field_seek */
   int ref_count;
   int db_type;                   /* DBI driver defined */
   char *db_driverdir ;           /* DBI driver dir */
   char *db_driver;               /* DBI type database */
   char *db_name;
   char *db_user;
   char *db_password;
   char *db_address;              /* host address */
   char *db_socket;               /* socket for local access */
   int db_port;                   /* port of host address */
   int have_insert_id;            /* do have insert_id() */
   bool connected;
   POOLMEM *errmsg;               /* nicely edited error message */
   POOLMEM *cmd;                  /* SQL command string */
   POOLMEM *cached_path;
   int cached_path_len;           /* length of cached path */
   uint32_t cached_path_id;
   bool allow_transactions;       /* transactions allowed */
   bool transaction;              /* transaction started */
   int changes;                   /* changes made to db */
   POOLMEM *fname;                /* Filename only */
   POOLMEM *path;                 /* Path only */
   POOLMEM *esc_name;             /* Escaped file name */
   POOLMEM *esc_path;             /* Escaped path name */
   int fnl;                       /* file name length */
   int pnl;                       /* path name length */
};     

void               my_dbi_free_result(B_DB *mdb);
DBI_ROW            my_dbi_fetch_row  (B_DB *mdb);
int                my_dbi_query      (B_DB *mdb, const char *query);
void               my_dbi_data_seek  (B_DB *mdb, int row);
void               my_dbi_field_seek (B_DB *mdb, int row);
DBI_FIELD *        my_dbi_fetch_field(B_DB *mdb);
const char *       my_dbi_strerror   (B_DB *mdb);
int                my_dbi_getisnull  (dbi_result *result, int row_number, int column_number);
char *             my_dbi_getvalue   (dbi_result *result, int row_number, unsigned int column_number);
int                my_dbi_sql_insert_id(B_DB *mdb, char *table_name);

int my_dbi_batch_start(JCR *jcr, B_DB *mdb);
int my_dbi_batch_end(JCR *jcr, B_DB *mdb, const char *error);
typedef struct ATTR_DBR ATTR_DBR;
int my_dbi_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);

extern const char* my_dbi_batch_lock_path_query[3];
extern const char* my_dbi_batch_lock_filename_query[3];
extern const char* my_dbi_batch_unlock_tables_query[3];
extern const char* my_dbi_batch_fill_filename_query[3];
extern const char* my_dbi_batch_fill_path_query[3];

/* "Generic" names for easier conversion */
#define sql_store_result(x)   (x)->result
#define sql_free_result(x)    my_dbi_free_result(x)
#define sql_fetch_row(x)      my_dbi_fetch_row(x)
#define sql_query(x, y)       my_dbi_query((x), (y))
#define sql_close(x)          dbi_conn_close((x)->db)
#define sql_strerror(x)       my_dbi_strerror(x)
#define sql_num_rows(x)       dbi_result_get_numrows((x)->result)
#define sql_data_seek(x, i)   my_dbi_data_seek((x), (i))
/* #define sql_affected_rows(x)  dbi_result_get_numrows_affected((x)->result) */
#define sql_affected_rows(x)  1
#define sql_insert_id(x,y)    my_dbi_sql_insert_id((x), (y))
#define sql_field_seek(x, y)  my_dbi_field_seek((x), (y))
#define sql_fetch_field(x)    my_dbi_fetch_field(x)
#define sql_num_fields(x)     ((x)->num_fields)
#define sql_batch_start(x,y)    my_dbi_batch_start(x,y)   
#define sql_batch_end(x,y,z)    my_dbi_batch_end(x,y,z)   
#define sql_batch_insert(x,y,z) my_dbi_batch_insert(x,y,z)
#define sql_batch_lock_path_query       my_dbi_batch_lock_path_query[db_type]
#define sql_batch_lock_filename_query   my_dbi_batch_lock_filename_query[db_type]
#define sql_batch_unlock_tables_query   my_dbi_batch_unlock_tables_query[db_type]
#define sql_batch_fill_filename_query   my_dbi_batch_fill_filename_query[db_type]
#define sql_batch_fill_path_query       my_dbi_batch_fill_path_query[db_type]

#define SQL_ROW               DBI_ROW
#define SQL_FIELD             DBI_FIELD


#else  /* USE BACULA DB routines */

#define HAVE_BACULA_DB 1

/* Change this each time there is some incompatible
 * file format change!!!!
 */
#define BDB_VERSION 13                /* file version number */

struct s_control {
   int bdb_version;                   /* Version number */
   uint32_t JobId;                    /* next Job Id */
   uint32_t PoolId;                   /* next Pool Id */
   uint32_t MediaId;                  /* next Media Id */
   uint32_t JobMediaId;               /* next JobMedia Id */
   uint32_t ClientId;                 /* next Client Id */
   uint32_t FileSetId;                /* nest FileSet Id */
   time_t time;                       /* time file written */
};


/* This is the REAL definition for using the
 *  Bacula internal DB
 */
struct B_DB {
   BQUEUE bq;                         /* queue control */
/* pthread_mutex_t mutex;  */         /* single thread lock */
   brwlock_t lock;                    /* transaction lock */
   int ref_count;                     /* number of times opened */
   struct s_control control;          /* control file structure */
   int cfd;                           /* control file device */
   FILE *jobfd;                       /* Jobs records file descriptor */
   FILE *poolfd;                      /* Pool records fd */
   FILE *mediafd;                     /* Media records fd */
   FILE *jobmediafd;                  /* JobMedia records fd */
   FILE *clientfd;                    /* Client records fd */
   FILE *filesetfd;                   /* FileSet records fd */
   char *db_name;                     /* name of database */
   POOLMEM *errmsg;                   /* nicely edited error message */
   POOLMEM *cmd;                      /* Command string */
   POOLMEM *cached_path;
   int cached_path_len;               /* length of cached path */
   uint32_t cached_path_id;
};

#endif /* HAVE_SQLITE3 */
#endif /* HAVE_MYSQL */
#endif /* HAVE_SQLITE */
#endif /* HAVE_POSTGRESQL */
#endif /* HAVE_DBI */
#endif

/* Use for better error location printing */
#define UPDATE_DB(jcr, db, cmd) UpdateDB(__FILE__, __LINE__, jcr, db, cmd)
#define INSERT_DB(jcr, db, cmd) InsertDB(__FILE__, __LINE__, jcr, db, cmd)
#define QUERY_DB(jcr, db, cmd) QueryDB(__FILE__, __LINE__, jcr, db, cmd)
#define DELETE_DB(jcr, db, cmd) DeleteDB(__FILE__, __LINE__, jcr, db, cmd)


#else    /* not __SQL_C */

/* This is a "dummy" definition for use outside of sql.c
 */
struct B_DB {
   int dummy;                         /* for SunOS compiler */
};     

#endif /*  __SQL_C */

/* ==============================================================   
 *
 *  What follows are definitions that are used "globally" for all 
 *   the different SQL engines and both inside and external to the
 *   cats directory.
 */

extern uint32_t bacula_db_version;

/*
 * These are the sizes of the current definitions of database
 *  Ids.  In general, FileId_t can be set to uint64_t and it
 *  *should* work.  Users have reported back that it does work
 *  for PostgreSQL.  For the other types, all places in Bacula
 *  have been converted, but no one has actually tested it.
 * In principle, the only field that really should need to be
 *  64 bits is the FileId_t
 */
typedef uint32_t FileId_t;
typedef uint32_t DBId_t;              /* general DB id type */
typedef uint32_t JobId_t;

#define faddr_t long

/*
 * Structure used when calling db_get_query_ids()
 *  allows the subroutine to return a list of ids.
 */
class dbid_list : public SMARTALLOC {
public:
   DBId_t *DBId;                      /* array of DBIds */
   char *PurgedFiles;                 /* Array of PurgedFile flags */
   int num_ids;                       /* num of ids actually stored */
   int max_ids;                       /* size of id array */
   int num_seen;                      /* number of ids processed */
   int tot_ids;                       /* total to process */

   dbid_list();                       /* in sql.c */
   ~dbid_list();                      /* in sql.c */
};




/* Job information passed to create job record and update
 * job record at end of job. Note, although this record
 * contains all the fields found in the Job database record,
 * it also contains fields found in the JobMedia record.
 */
/* Job record */
struct JOB_DBR {
   JobId_t JobId;
   char Job[MAX_NAME_LENGTH];         /* Job unique name */
   char Name[MAX_NAME_LENGTH];        /* Job base name */
   int JobType;                       /* actually char(1) */
   int JobLevel;                      /* actually char(1) */
   int JobStatus;                     /* actually char(1) */
   DBId_t ClientId;                   /* Id of client */
   DBId_t PoolId;                     /* Id of pool */
   DBId_t FileSetId;                  /* Id of FileSet */
   DBId_t PriorJobId;                 /* Id of migrated (prior) job */
   time_t SchedTime;                  /* Time job scheduled */
   time_t StartTime;                  /* Job start time */
   time_t EndTime;                    /* Job termination time of orig job */
   time_t RealEndTime;                /* Job termination time of this job */
   utime_t JobTDate;                  /* Backup time/date in seconds */
   uint32_t VolSessionId;
   uint32_t VolSessionTime;
   uint32_t JobFiles;
   uint32_t JobErrors;
   uint32_t JobMissingFiles;
   uint64_t JobBytes;
   int PurgedFiles;
   int HasBase;

   /* Note, FirstIndex, LastIndex, Start/End File and Block
    * are only used in the JobMedia record.
    */
   uint32_t FirstIndex;               /* First index this Volume */
   uint32_t LastIndex;                /* Last index this Volume */
   uint32_t StartFile;
   uint32_t EndFile;
   uint32_t StartBlock;
   uint32_t EndBlock;

   char cSchedTime[MAX_TIME_LENGTH];
   char cStartTime[MAX_TIME_LENGTH];
   char cEndTime[MAX_TIME_LENGTH];
   char cRealEndTime[MAX_TIME_LENGTH];
   /* Extra stuff not in DB */
   int limit;                         /* limit records to display */
   faddr_t rec_addr;
};

/* Job Media information used to create the media records
 * for each Volume used for the job.
 */
/* JobMedia record */
struct JOBMEDIA_DBR {
   DBId_t JobMediaId;                 /* record id */
   JobId_t  JobId;                    /* JobId */
   DBId_t MediaId;                    /* MediaId */
   uint32_t FirstIndex;               /* First index this Volume */
   uint32_t LastIndex;                /* Last index this Volume */
   uint32_t StartFile;                /* File for start of data */
   uint32_t EndFile;                  /* End file on Volume */
   uint32_t StartBlock;               /* start block on tape */
   uint32_t EndBlock;                 /* last block */
   uint32_t Copy;                     /* identical copy */
};


/* Volume Parameter structure */
struct VOL_PARAMS {
   char VolumeName[MAX_NAME_LENGTH];  /* Volume name */
   char MediaType[MAX_NAME_LENGTH];   /* Media Type */
   char Storage[MAX_NAME_LENGTH];     /* Storage name */
   uint32_t VolIndex;                 /* Volume seqence no. */
   uint32_t FirstIndex;               /* First index this Volume */
   uint32_t LastIndex;                /* Last index this Volume */
   uint32_t StartFile;                /* File for start of data */
   uint32_t EndFile;                  /* End file on Volume */
   uint32_t StartBlock;               /* start block on tape */
   uint32_t EndBlock;                 /* last block */
   int32_t Slot;                      /* Slot */
// uint32_t Copy;                     /* identical copy */
// uint32_t Stripe;                   /* RAIT strip number */
};


/* Attributes record -- NOT same as in database because
 *  in general, this "record" creates multiple database
 *  records (e.g. pathname, filename, fileattributes).
 */
struct ATTR_DBR {
   char *fname;                       /* full path & filename */
   char *link;                        /* link if any */
   char *attr;                        /* attributes statp */
   uint32_t FileIndex;
   uint32_t Stream;
   JobId_t  JobId;
   DBId_t ClientId;
   DBId_t PathId;
   DBId_t FilenameId;
   FileId_t FileId;
   char *Digest;
   int DigestType;
};


/* File record -- same format as database */
struct FILE_DBR {
   FileId_t FileId;
   uint32_t FileIndex;
   JobId_t  JobId;
   DBId_t FilenameId;
   DBId_t PathId;
   JobId_t  MarkId;
   char LStat[256];
   char Digest[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
   int DigestType;                    /* NO_SIG/MD5_SIG/SHA1_SIG */
};

/* Pool record -- same format as database */
struct POOL_DBR {
   DBId_t PoolId;
   char Name[MAX_NAME_LENGTH];        /* Pool name */
   uint32_t NumVols;                  /* total number of volumes */
   uint32_t MaxVols;                  /* max allowed volumes */
   int32_t LabelType;                 /* Bacula/ANSI/IBM */
   int32_t UseOnce;                   /* set to use once only */
   int32_t UseCatalog;                /* set to use catalog */
   int32_t AcceptAnyVolume;           /* set to accept any volume sequence */
   int32_t AutoPrune;                 /* set to prune automatically */
   int32_t Recycle;                   /* default Vol recycle flag */
   utime_t  VolRetention;             /* retention period in seconds */
   utime_t  VolUseDuration;           /* time in secs volume can be used */
   uint32_t MaxVolJobs;               /* Max Jobs on Volume */
   uint32_t MaxVolFiles;              /* Max files on Volume */
   uint64_t MaxVolBytes;              /* Max bytes on Volume */
   DBId_t RecyclePoolId;              /* RecyclePool destination when media is purged */
   char PoolType[MAX_NAME_LENGTH];
   char LabelFormat[MAX_NAME_LENGTH];
   /* Extra stuff not in DB */
   faddr_t rec_addr;
};

class DEVICE_DBR {
public:
   DBId_t DeviceId;
   char Name[MAX_NAME_LENGTH];        /* Device name */
   DBId_t MediaTypeId;                /* MediaType */
   DBId_t StorageId;                  /* Storage id if autochanger */
   uint32_t DevMounts;                /* Number of times mounted */
   uint32_t DevErrors;                /* Number of read/write errors */
   uint64_t DevReadBytes;             /* Number of bytes read */
   uint64_t DevWriteBytes;            /* Number of bytew written */
   uint64_t DevReadTime;              /* time spent reading volume */
   uint64_t DevWriteTime;             /* time spent writing volume */
   uint64_t DevReadTimeSincCleaning;  /* read time since cleaning */
   uint64_t DevWriteTimeSincCleaning; /* write time since cleaning */
   time_t   CleaningDate;             /* time last cleaned */
   utime_t  CleaningPeriod;           /* time between cleanings */
};

class STORAGE_DBR {
public:
   DBId_t StorageId;
   char Name[MAX_NAME_LENGTH];        /* Device name */
   int AutoChanger;                   /* Set if autochanger */

   /* Not in database */
   bool created;                      /* set if created by db_create ... */
};

class MEDIATYPE_DBR {
public:
   DBId_t MediaTypeId;
   char MediaType[MAX_NAME_LENGTH];   /* MediaType string */
   int ReadOnly;                      /* Set if read-only */
};


/* Media record -- same as the database */
struct MEDIA_DBR {
   DBId_t MediaId;                    /* Unique volume id */
   char VolumeName[MAX_NAME_LENGTH];  /* Volume name */
   char MediaType[MAX_NAME_LENGTH];   /* Media type */
   DBId_t PoolId;                     /* Pool id */
   time_t   FirstWritten;             /* Time Volume first written this usage */
   time_t   LastWritten;              /* Time Volume last written */
   time_t   LabelDate;                /* Date/Time Volume labeled */
   time_t   InitialWrite;             /* Date/Time Volume first written */
   int32_t  LabelType;                /* Label (Bacula/ANSI/IBM) */
   uint32_t VolJobs;                  /* number of jobs on this medium */
   uint32_t VolFiles;                 /* Number of files */
   uint32_t VolBlocks;                /* Number of blocks */
   uint32_t VolMounts;                /* Number of times mounted */
   uint32_t VolErrors;                /* Number of read/write errors */
   uint32_t VolWrites;                /* Number of writes */
   uint32_t VolReads;                 /* Number of reads */
   uint64_t VolBytes;                 /* Number of bytes written */
   uint32_t VolParts;                 /* Number of parts written */
   uint64_t MaxVolBytes;              /* Max bytes to write to Volume */
   uint64_t VolCapacityBytes;         /* capacity estimate */
   uint64_t VolReadTime;              /* time spent reading volume */
   uint64_t VolWriteTime;             /* time spent writing volume */
   utime_t  VolRetention;             /* Volume retention in seconds */
   utime_t  VolUseDuration;           /* time in secs volume can be used */
   uint32_t MaxVolJobs;               /* Max Jobs on Volume */
   uint32_t MaxVolFiles;              /* Max files on Volume */
   int32_t  Recycle;                  /* recycle yes/no */
   int32_t  Slot;                     /* slot in changer */
   int32_t  Enabled;                  /* 0=disabled, 1=enabled, 2=archived */
   int32_t  InChanger;                /* Volume currently in changer */
   DBId_t   StorageId;                /* Storage record Id */
   uint32_t EndFile;                  /* Last file on volume */
   uint32_t EndBlock;                 /* Last block on volume */
   uint32_t RecycleCount;             /* Number of times recycled */
   char     VolStatus[20];            /* Volume status */
   DBId_t   DeviceId;                 /* Device where Vol last written */
   DBId_t   LocationId;               /* Where Volume is -- user defined */
   DBId_t   ScratchPoolId;            /* Where to move if scratch */
   DBId_t   RecyclePoolId;            /* Where to move when recycled */
   /* Extra stuff not in DB */
   faddr_t rec_addr;                  /* found record address */
   /* Since the database returns times as strings, this is how we pass
    *   them back.
    */
   char    cFirstWritten[MAX_TIME_LENGTH]; /* FirstWritten returned from DB */
   char    cLastWritten[MAX_TIME_LENGTH];  /* LastWritten returned from DB */
   char    cLabelDate[MAX_TIME_LENGTH];    /* LabelData returned from DB */
   char    cInitialWrite[MAX_TIME_LENGTH]; /* InitialWrite returned from DB */
   bool    set_first_written;                
   bool    set_label_date;
};

/* Client record -- same as the database */
struct CLIENT_DBR {
   DBId_t ClientId;                   /* Unique Client id */
   int AutoPrune;
   utime_t FileRetention;
   utime_t JobRetention;
   char Name[MAX_NAME_LENGTH];        /* Client name */
   char Uname[256];                   /* Uname for client */
};

/* Counter record as in database */
struct COUNTER_DBR {
   char Counter[MAX_NAME_LENGTH];
   int32_t MinValue;
   int32_t MaxValue;
   int32_t CurrentValue;
   char WrapCounter[MAX_NAME_LENGTH];
};


/* FileSet record -- same as the database */
struct FILESET_DBR {
   DBId_t FileSetId;                  /* Unique FileSet id */
   char FileSet[MAX_NAME_LENGTH];     /* FileSet name */
   char MD5[50];                      /* MD5 signature of include/exclude */
   time_t CreateTime;                 /* date created */
   /*
    * This is where we return CreateTime
    */
   char cCreateTime[MAX_TIME_LENGTH]; /* CreateTime as returned from DB */
   /* Not in DB but returned by db_create_fileset() */
   bool created;                      /* set when record newly created */
};

/* Call back context for getting a 32/64 bit value from the database */
struct db_int64_ctx {
   int64_t value;                     /* value returned */
   int count;                         /* number of values seen */
};


#include "protos.h"
#include "jcr.h"
#include "sql_cmds.h"

/*
 * Exported globals from sql.c  
 */
extern int DLL_IMP_EXP db_type;        /* SQL engine type index */

/*
 * Some functions exported by sql.c for use within the
 *   cats directory.
 */
void list_result(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type type);
void list_dashes(B_DB *mdb, DB_LIST_HANDLER *send, void *ctx);
int get_sql_record_max(JCR *jcr, B_DB *mdb);
bool check_tables_version(JCR *jcr, B_DB *mdb);
void _db_unlock(const char *file, int line, B_DB *mdb);
void _db_lock(const char *file, int line, B_DB *mdb);
const char *db_get_type(void);

void print_dashes(B_DB *mdb);
void print_result(B_DB *mdb);
int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
int InsertDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
int DeleteDB(const char *file, int line, JCR *jcr, B_DB *db, char *delete_cmd);
int UpdateDB(const char *file, int line, JCR *jcr, B_DB *db, char *update_cmd);
void split_path_and_file(JCR *jcr, B_DB *mdb, const char *fname);
#endif /* __SQL_H_ */
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Bacula-devel mailing list
Bacula-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.sourceforge.net/lists/listinfo/bacula-devel


This mailing list archive is a service of Copilotco.