git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/sql_glue.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2009-2014 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from many
   7    others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    Bacula® is a registered trademark of Kern Sibbald.
  15 */
  16 /*
  17  * Bacula Glue code for the catalog refactoring.
  18  *
  19  * Written by Marco van Wieringen, November 2009
  20  */
  21
  22 #include "bacula.h"
  23
  24 #if HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL
  25
  26 #include "cats.h"
  27 #include "bdb_priv.h"
  28 #include "sql_glue.h"
  29
  30 /* -----------------------------------------------------------------------
  31  *
  32  *   Generic Glue Routines
  33  *
  34  * -----------------------------------------------------------------------
  35  */
  36 bool db_match_database(B_DB *mdb, const char *db_driver, const char *db_name,
  37                        const char *db_address, int db_port)
  38 {
  39    return mdb->db_match_database(db_driver, db_name, db_address, db_port);
  40 }
  41
  42 B_DB *db_clone_database_connection(B_DB *mdb, JCR *jcr, bool mult_db_connections)
  43 {
  44    return mdb->db_clone_database_connection(jcr, mult_db_connections);
  45 }
  46
  47 const char *db_get_type(B_DB *mdb)
  48 {
  49    return mdb->db_get_type();
  50 }
  51
  52 int db_get_type_index(B_DB *mdb)
  53 {
  54    return mdb->db_get_type_index();
  55 }
  56
  57 bool db_open_database(JCR *jcr, B_DB *mdb)
  58 {
  59    return mdb->db_open_database(jcr);
  60 }
  61
  62 void db_close_database(JCR *jcr, B_DB *mdb)
  63 {
  64    if (mdb) {
  65       mdb->db_close_database(jcr);
  66    }
  67 }
  68
  69 void db_thread_cleanup(B_DB *mdb)
  70 {
  71    mdb->db_thread_cleanup();
  72 }
  73
  74 void db_escape_string(JCR *jcr, B_DB *mdb, char *snew, char *old, int len)
  75 {
  76    mdb->db_escape_string(jcr, snew, old, len);
  77 }
  78
  79 char *db_escape_object(JCR *jcr, B_DB *mdb, char *old, int len)
  80 {
  81    return mdb->db_escape_object(jcr, old, len);
  82 }
  83
  84 void db_unescape_object(JCR *jcr, B_DB *mdb,
  85                         char *from, int32_t expected_len,
  86                         POOLMEM **dest, int32_t *len)
  87 {
  88    mdb->db_unescape_object(jcr, from, expected_len, dest, len);
  89 }
  90
  91 void db_start_transaction(JCR *jcr, B_DB *mdb)
  92 {
  93    mdb->db_start_transaction(jcr);
  94 }
  95
  96 void db_end_transaction(JCR *jcr, B_DB *mdb)
  97 {
  98    mdb->db_end_transaction(jcr);
  99 }
 100
 101 bool db_sql_query(B_DB *mdb, const char *query, int flags)
 102 {
 103    mdb->errmsg[0] = 0;
 104    return mdb->db_sql_query(query, flags);
 105 }
 106
 107 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 108 {
 109    mdb->errmsg[0] = 0;
 110    return mdb->db_sql_query(query, result_handler, ctx);
 111 }
 112
 113 bool db_big_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 114 {
 115    mdb->errmsg[0] = 0;
 116    return mdb->db_big_sql_query(query, result_handler, ctx);
 117 }
 118
 119 void sql_free_result(B_DB *mdb)
 120 {
 121    ((B_DB_PRIV *)mdb)->sql_free_result();
 122 }
 123
 124 SQL_ROW sql_fetch_row(B_DB *mdb)
 125 {
 126    return ((B_DB_PRIV *)mdb)->sql_fetch_row();
 127 }
 128
 129 bool sql_query(B_DB *mdb, const char *query, int flags)
 130 {
 131    mdb->errmsg[0] = 0;
 132    return ((B_DB_PRIV *)mdb)->sql_query(query, flags);
 133 }
 134
 135 const char *sql_strerror(B_DB *mdb)
 136 {
 137    return ((B_DB_PRIV *)mdb)->sql_strerror();
 138 }
 139
 140 int sql_num_rows(B_DB *mdb)
 141 {
 142    return ((B_DB_PRIV *)mdb)->sql_num_rows();
 143 }
 144
 145 void sql_data_seek(B_DB *mdb, int row)
 146 {
 147    ((B_DB_PRIV *)mdb)->sql_data_seek(row);
 148 }
 149
 150 int sql_affected_rows(B_DB *mdb)
 151 {
 152    return ((B_DB_PRIV *)mdb)->sql_affected_rows();
 153 }
 154
 155 uint64_t sql_insert_autokey_record(B_DB *mdb, const char *query, const char *table_name)
 156 {
 157    return ((B_DB_PRIV *)mdb)->sql_insert_autokey_record(query, table_name);
 158 }
 159
 160 void sql_field_seek(B_DB *mdb, int field)
 161 {
 162    ((B_DB_PRIV *)mdb)->sql_field_seek(field);
 163 }
 164
 165 SQL_FIELD *sql_fetch_field(B_DB *mdb)
 166 {
 167    return ((B_DB_PRIV *)mdb)->sql_fetch_field();
 168 }
 169
 170 int sql_num_fields(B_DB *mdb)
 171 {
 172    return ((B_DB_PRIV *)mdb)->sql_num_fields();
 173 }
 174
 175 bool sql_field_is_not_null(B_DB *mdb, int field_type)
 176 {
 177    return ((B_DB_PRIV *)mdb)->sql_field_is_not_null(field_type);
 178 }
 179
 180 bool sql_field_is_numeric(B_DB *mdb, int field_type)
 181 {
 182    return ((B_DB_PRIV *)mdb)->sql_field_is_numeric(field_type);
 183 }
 184
 185 bool sql_batch_start(JCR *jcr, B_DB *mdb)
 186 {
 187    return ((B_DB_PRIV *)mdb)->sql_batch_start(jcr);
 188 }
 189
 190 bool sql_batch_end(JCR *jcr, B_DB *mdb, const char *error)
 191 {
 192    return ((B_DB_PRIV *)mdb)->sql_batch_end(jcr, error);
 193 }
 194
 195 bool sql_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 196 {
 197    return ((B_DB_PRIV *)mdb)->sql_batch_insert(jcr, ar);
 198 }
 199
 200 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL */