/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
+ Copyright (C) 2000-2010 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
+ 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.
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
+ 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.
- Bacula® is a registered trademark of John Walker.
+ 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.
* for the external world. This is control with
* the define __SQL_C, which is defined only in sql.c
*
- * Version $Id$
*/
/*
- Here is how database versions work.
+ 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
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
+ 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,
+ SQL_TYPE_SQLITE3 = 3,
+ SQL_TYPE_INGRES = 4
+};
+
typedef void (DB_LIST_HANDLER)(void *, const char *);
typedef int (DB_RESULT_HANDLER)(void *, int, char **);
#ifdef __SQL_C
+/* Current database version number for all drivers */
+#define BDB_VERSION 13
+
+
#if defined(BUILDING_CATS)
#ifdef HAVE_SQLITE
-
-#define BDB_VERSION 10
+#error "SQLite2 is now deprecated, use SQLite3 instead."
#include <sqlite.h>
* S Q L I T E
*/
struct B_DB {
- BQUEUE bq; /* queue control */
+ dlink link; /* queue control */
brwlock_t lock; /* transaction lock */
struct sqlite *db;
char **result;
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 *path; /* Path only */
POOLMEM *esc_name; /* Escaped file name */
POOLMEM *esc_path; /* Escaped path name */
+ POOLMEM *esc_obj; /* Escaped restore object */
int fnl; /* file name length */
int pnl; /* path name length */
};
*
* 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))
+#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))
+#define sql_insert_autokey_record(x, y, z) my_sqlite_insert_autokey_record((x), (y), (z))
#ifdef HAVE_SQLITE3
-#define sql_insert_id(x,y) sqlite3_last_insert_rowid((x)->db)
-#define sql_close(x) sqlite3_close((x)->db)
+#define sql_close(x) sqlite3_close((x)->db)
+#define sql_affected_rows(x) sqlite3_changes((x)->db)
#else
-#define sql_insert_id(x,y) sqlite_last_insert_rowid((x)->db)
-#define sql_close(x) sqlite_close((x)->db)
+#define sql_close(x) sqlite_close((x)->db)
+#define sql_affected_rows(x) 1
#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_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_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_MATCH "MATCH"
-#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_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
+#define sql_batch_fill_path_query my_sqlite_batch_fill_path_query
/* In cats/sqlite.c */
void my_sqlite_free_table(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 char* my_sqlite_batch_lock_query;
-extern char* my_sqlite_batch_unlock_query;
-extern char* my_sqlite_batch_fill_filename_query;
-extern char* my_sqlite_batch_fill_path_query;
+int my_sqlite_insert_autokey_record(B_DB *mdb, const char *query, const char *table_name);
+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
+#ifdef HAVE_SQLITE3
#include <sqlite3.h>
* S Q L I T E
*/
struct B_DB {
- BQUEUE bq; /* queue control */
+ dlink link; /* queue control */
brwlock_t lock; /* transaction lock */
struct sqlite3 *db;
char **result;
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 *path; /* Path only */
POOLMEM *esc_name; /* Escaped file name */
POOLMEM *esc_path; /* Escaped path name */
+ POOLMEM *esc_obj; /* Escaped restore object */
int fnl; /* file name length */
int pnl; /* path name length */
};
*
* 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))
+#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))
+#define sql_insert_autokey_record(x, y, z) my_sqlite_insert_autokey_record((x), (y), (z))
#ifdef HAVE_SQLITE3
-#define sql_insert_id(x,y) sqlite3_last_insert_rowid((x)->db)
-#define sql_close(x) sqlite3_close((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)
+#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_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) sqlite3_changes((x)->db)
+#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_MATCH "MATCH"
#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
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 char* my_sqlite_batch_lock_query;
-extern char* my_sqlite_batch_unlock_query;
-extern char* my_sqlite_batch_fill_filename_query;
-extern char* my_sqlite_batch_fill_path_query;
+int my_sqlite_insert_autokey_record(B_DB *mdb, const char *query, const char *table_name);
+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>
/*
* M Y S Q L
*/
struct B_DB {
- BQUEUE bq; /* queue control */
+ dlink link; /* queue control */
brwlock_t lock; /* transaction lock */
MYSQL mysql;
MYSQL *db;
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 */
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 */
+ POOLMEM *esc_obj; /* Escaped restore object */
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_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_autokey_record(x, y, z) my_mysql_insert_autokey_record((x), (y), (z))
+#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_MATCH "MATCH"
#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_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_path_query my_mysql_batch_fill_path_query
-extern char* my_mysql_batch_lock_path_query;
-extern char* my_mysql_batch_lock_filename_query;
-extern char* my_mysql_batch_unlock_tables_query;
-extern char* my_mysql_batch_fill_filename_query;
-extern char* 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);
+extern int my_mysql_insert_autokey_record(B_DB *mdb, const char *query, const char *table_name);
#else
#ifdef HAVE_POSTGRESQL
-#define BDB_VERSION 10
-
#include <libpq-fe.h>
/* TEMP: the following is taken from select OID, typname from pg_type; */
* P O S T G R E S Q L
*/
struct B_DB {
- BQUEUE bq; /* queue control */
+ dlink link; /* queue control */
brwlock_t lock; /* transaction lock */
PGconn *db;
PGresult *result;
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 *path; /* Path only */
POOLMEM *esc_name; /* Escaped file name */
POOLMEM *esc_path; /* Escaped path name */
+ unsigned char *esc_obj; /* Escaped restore object */
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);
+int my_postgresql_insert_autokey_record (B_DB *mdb, const char *query, const 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_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
char *my_postgresql_copy_escape(char *dest, char *src, size_t len);
-extern char* my_pg_batch_lock_path_query;
-extern char* my_pg_batch_lock_filename_query;
-extern char* my_pg_batch_unlock_tables_query;
-extern char* my_pg_batch_fill_filename_query;
-extern char* my_pg_batch_fill_path_query;
+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_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) PQresultErrorMessage((x)->result)
+#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_insert_autokey_record(x, y, z) my_postgresql_insert_autokey_record((x), (y), (z))
#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_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_ROW POSTGRESQL_ROW
#define SQL_FIELD POSTGRESQL_FIELD
+#define SQL_MATCH "~"
+
+#else
-#else /* USE BACULA DB routines */
+#ifdef HAVE_INGRES
-#define HAVE_BACULA_DB 1
+#include "myingres.h"
+
+/* TEMP: the following is taken from $(II_SYSTEM)/ingres/files/eqsqlda.h IISQ_ types */
+#define IS_NUM(x) ((x) == 10 || (x) == 30 || (x) == 31)
+#define IS_NOT_NULL(x) ((x) == 1)
-/* Change this each time there is some incompatible
- * file format change!!!!
+typedef char **INGRES_ROW;
+
+/*
+ * This is the "real" definition that should only be
+ * used inside sql.c and associated database interface
+ * subroutines.
+ *
+ * I N G R E S
*/
-#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 */
+struct B_DB {
+ dlink link; /* queue control */
+ brwlock_t lock; /* transaction lock */
+ INGconn *db;
+ INGresult *result;
+ int status;
+ INGRES_ROW row;
+ INGRES_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_ingres_data_seek */
+ int field_number; /* field number from my_ingres_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 session_id; /* unique session 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 */
+ bool explicit_commit; /* do an explicit commit after each query */
+ 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 */
+ alist *query_filters; /* Filters to convert sql queries into supported Ingres SQL */
+ int fnl; /* file name length */
+ int pnl; /* path name length */
};
+void my_ingres_free_result(B_DB *mdb);
+INGRES_ROW my_ingres_fetch_row (B_DB *mdb);
+int my_ingres_query (B_DB *mdb, const char *query);
+void my_ingres_data_seek (B_DB *mdb, int row);
+void my_ingres_field_seek (B_DB *mdb, int row);
+INGRES_FIELD * my_ingres_fetch_field(B_DB *mdb);
+void my_ingres_close (B_DB *mdb);
+int my_ingres_insert_autokey_record (B_DB *mdb, const char *query, const char *table_name);
+
+bool my_ingres_batch_start(JCR *jcr, B_DB *mdb);
+bool my_ingres_batch_end(JCR *jcr, B_DB *mdb, const char *error);
+typedef struct ATTR_DBR ATTR_DBR;
+bool my_ingres_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
+char *my_ingres_copy_escape(char *dest, char *src, size_t len);
+
+extern const char* my_ingres_batch_lock_path_query;
+extern const char* my_ingres_batch_lock_filename_query;
+extern const char* my_ingres_batch_unlock_tables_query;
+extern const char* my_ingres_batch_fill_filename_query;
+extern const char* my_ingres_batch_fill_path_query;
+
+/* "Generic" names for easier conversion */
+#define sql_store_result(x) ((x)->result)
+#define sql_free_result(x) my_ingres_free_result(x)
+#define sql_fetch_row(x) my_ingres_fetch_row(x)
+#define sql_query(x, y) my_ingres_query((x), (y))
+#define sql_close(x) my_ingres_close(x)
+#define sql_strerror(x) INGerrorMessage((x)->db)
+#define sql_num_rows(x) ((unsigned) INGntuples((x)->result))
+#define sql_data_seek(x, i) my_ingres_data_seek((x), (i))
+#define sql_affected_rows(x) ((x)->num_rows)
+#define sql_insert_autokey_record(x, y, z) my_ingres_insert_autokey_record((x), (y), (z))
+#define sql_field_seek(x, y) my_ingres_field_seek((x), (y))
+#define sql_fetch_field(x) my_ingres_fetch_field(x)
+#define sql_num_fields(x) ((x)->num_fields)
+
+#define sql_batch_start(x,y) my_ingres_batch_start(x,y)
+#define sql_batch_end(x,y,z) my_ingres_batch_end(x,y,z)
+#define sql_batch_insert(x,y,z) my_ingres_batch_insert(x,y,z)
+#define sql_batch_lock_path_query my_ingres_batch_lock_path_query
+#define sql_batch_lock_filename_query my_ingres_batch_lock_filename_query
+#define sql_batch_unlock_tables_query my_ingres_batch_unlock_tables_query
+#define sql_batch_fill_filename_query my_ingres_batch_fill_filename_query
+#define sql_batch_fill_path_query my_ingres_batch_fill_path_query
+
+#define SQL_ROW INGRES_ROW
+#define SQL_FIELD INGRES_FIELD
+#define SQL_MATCH "~"
+
+#else
+
+#ifdef HAVE_DBI
+
+#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;
+
+typedef struct dbi_field_get {
+ dlink link;
+ char *value;
+} DBI_FIELD_GET;
-/* This is the REAL definition for using the
- * Bacula internal DB
+/*
+ * 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 */
-/* pthread_mutex_t mutex; */ /* single thread lock */
+ dlink link; /* queue control */
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 */
+ dbi_conn *db;
+ dbi_result *result;
+ dbi_inst instance;
+ dbi_error_flag status;
+ DBI_ROW row;
+ DBI_FIELD *fields;
+ DBI_FIELD_GET *field_get;
+ 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 */
+ bool connected;
+ POOLMEM *errmsg; /* nicely edited error message */
+ POOLMEM *cmd; /* SQL command string */
POOLMEM *cached_path;
- int cached_path_len; /* length of 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 */
+ POOLMEM *esc_obj; /* Escaped restore object */
+ 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_getvalue (dbi_result *result, int row_number, unsigned int column_number, char *value);
+int my_dbi_insert_autokey_record(B_DB *mdb, const char *query, const 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);
+char *my_postgresql_copy_escape(char *dest, char *src, size_t len);
+// typedefs for libdbi work with postgresql copy insert
+typedef int (*custom_function_insert_t)(void*, const char*, int);
+typedef char* (*custom_function_error_t)(void*);
+typedef int (*custom_function_end_t)(void*, const char*);
+
+extern const char* my_dbi_batch_lock_path_query[5];
+extern const char* my_dbi_batch_lock_filename_query[5];
+extern const char* my_dbi_batch_unlock_tables_query[5];
+extern const char* my_dbi_batch_fill_filename_query[5];
+extern const char* my_dbi_batch_fill_path_query[5];
+extern const char* my_dbi_match[5];
+
+/* "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_MATCH my_dbi_match[db_type]
+/* #define sql_affected_rows(x) dbi_result_get_numrows_affected((x)->result) */
+#define sql_affected_rows(x) 1
+#define sql_insert_autokey_record(x, y, z) my_dbi_insert_autokey_record((x), (y), (z))
+#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
+
#endif /* HAVE_SQLITE3 */
#endif /* HAVE_MYSQL */
#endif /* HAVE_SQLITE */
#endif /* HAVE_POSTGRESQL */
+#endif /* HAVE_INGRES */
+#endif /* HAVE_DBI */
#endif
/* Use for better error location printing */
*/
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;
-/* ***FIXME*** FileId_t should *really* be uint64_t
- * but at the current time, this breaks MySQL.
+#define faddr_t long
+
+/*
+ * Structure used when calling db_get_query_ids()
+ * allows the subroutine to return a list of ids.
*/
-typedef uint32_t FileId_t;
-typedef uint32_t DBId_t; /* general DB id type */
-typedef uint32_t JobId_t;
+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 */
+};
+
-#define faddr_t long
/* Job information passed to create job record and update
uint32_t JobErrors;
uint32_t JobMissingFiles;
uint64_t JobBytes;
+ uint64_t ReadBytes;
int PurgedFiles;
int HasBase;
/* Extra stuff not in DB */
int limit; /* limit records to display */
faddr_t rec_addr;
+ uint32_t FileIndex; /* added during Verify */
};
/* Job Media information used to create the media records
uint32_t EndFile; /* End file on Volume */
uint32_t StartBlock; /* start block on tape */
uint32_t EndBlock; /* last block */
- uint32_t Copy; /* identical copy */
+// uint32_t Copy; /* identical copy */
};
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 */
+ uint64_t StartAddr; /* Start address */
+ uint64_t EndAddr; /* End address */
+ int32_t InChanger; /* InChanger flag */
// uint32_t Copy; /* identical copy */
// uint32_t Stripe; /* RAIT strip number */
};
char *attr; /* attributes statp */
uint32_t FileIndex;
uint32_t Stream;
+ uint32_t FileType;
JobId_t JobId;
DBId_t ClientId;
DBId_t PathId;
int DigestType;
};
+struct ROBJECT_DBR {
+ char *object_name;
+ char *object;
+ char *plugin_name;
+ uint32_t object_len;
+ uint32_t object_full_len;
+ uint32_t object_index;
+ int32_t object_compression;
+ uint32_t FileIndex;
+ uint32_t Stream;
+ uint32_t FileType;
+ JobId_t JobId;
+ DBId_t RestoreObjectId;
+};
+
/* File record -- same format as database */
struct FILE_DBR {
int32_t AcceptAnyVolume; /* set to accept any volume sequence */
int32_t AutoPrune; /* set to prune automatically */
int32_t Recycle; /* default Vol recycle flag */
+ uint32_t ActionOnPurge; /* action on purge, e.g. truncate the disk volume */
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 */
+ DBId_t ScratchPoolId; /* ScratchPool source when media is needed */
char PoolType[MAX_NAME_LENGTH];
char LabelFormat[MAX_NAME_LENGTH];
/* Extra stuff not in DB */
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 ActionOnPurge; /* action on purge, e.g. truncate the disk volume */
uint32_t MaxVolJobs; /* Max Jobs on Volume */
uint32_t MaxVolFiles; /* Max files on Volume */
int32_t Recycle; /* recycle yes/no */
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_first_written;
bool set_label_date;
};
int count; /* number of values seen */
};
+/* Call back context for getting a list of comma separated strings from the
+ * database
+ */
+class db_list_ctx {
+public:
+ POOLMEM *list; /* list */
+ int count; /* number of values seen */
+
+ db_list_ctx() { list = get_pool_memory(PM_FNAME); reset(); }
+ ~db_list_ctx() { free_pool_memory(list); list = NULL; }
+ void reset() { *list = 0; count = 0;}
+ void cat(const db_list_ctx &str) {
+ if (str.count > 0) {
+ if (*list) {
+ pm_strcat(list, ",");
+ }
+ pm_strcat(list, str.list);
+ count += str.count;
+ }
+ }
+private:
+ db_list_ctx(const db_list_ctx&); /* prohibit pass by value */
+ db_list_ctx &operator=(const db_list_ctx&); /* prohibit class assignment */
+};
+
#include "protos.h"
#include "jcr.h"
#include "sql_cmds.h"
+/*
+ * Exported globals from sql.c
+ */
+extern int CATS_IMP_EXP db_type; /* SQL engine type index */
+
/*
* Some functions exported by sql.c for use within the
* cats directory.
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);
+bool db_check_max_connections(JCR *jcr, B_DB *mdb, uint32_t nb);
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);
projects / bacula / bacula / blobdiff