/*
- * 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$
- */
+ Bacula(R) - The Network Backup Solution
-/*
- Copyright (C) 2000-2003 Kern Sibbald and John Walker
+ Copyright (C) 2000-2016 Kern Sibbald
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2 of
- the License, or (at your option) any later version.
+ The original author of Bacula is Kern Sibbald, with contributions
+ from many others, a complete list can be found in the file AUTHORS.
- 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 may use this file and others of this release according to the
+ license defined in the LICENSE file, which includes the Affero General
+ Public License, v3.0 ("AGPLv3") and some additional permissions and
+ terms pursuant to its AGPLv3 Section 7.
- You should have received a copy of the GNU General Public
- License along with this program; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- MA 02111-1307, USA.
+ This notice must be preserved when any source code is
+ conveyed and/or propagated.
+ Bacula(R) is a registered trademark of Kern Sibbald.
+*/
+/*
+ * Catalog DB header file
+ *
+ * Written by Kern E. Sibbald
+ *
+ * Anyone who accesses the database will need to include
+ * this file.
*/
-#ifndef __SQL_H_
-#define __SQL_H_ 1
+#ifndef __CATS_H_
+#define __CATS_H_ 1
+/*
+ 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).
+ */
-typedef void (DB_LIST_HANDLER)(void *, char *);
-typedef int (DB_RESULT_HANDLER)(void *, int, char **);
+/* Current database version number for all drivers */
+#define BDB_VERSION 15
-#define db_lock(mdb) _db_lock(__FILE__, __LINE__, mdb)
-#define db_unlock(mdb) _db_unlock(__FILE__, __LINE__, mdb)
+typedef void (DB_LIST_HANDLER)(void *, const char *);
+typedef int (DB_RESULT_HANDLER)(void *, int, char **);
-#ifdef __SQL_C
+/* What kind of database we have */
+typedef enum {
+ SQL_TYPE_MYSQL = 0,
+ SQL_TYPE_POSTGRESQL = 1,
+ SQL_TYPE_SQLITE3 = 2,
+ SQL_TYPE_UNKNOWN = 99
+} SQL_DBTYPE;
-#ifdef HAVE_SQLITE
+/* What kind of driver we have */
+typedef enum {
+ SQL_DRIVER_TYPE_MYSQL = 0,
+ SQL_DRIVER_TYPE_POSTGRESQL = 1,
+ SQL_DRIVER_TYPE_SQLITE3 = 2,
+} SQL_DRIVER;
-#define BDB_VERSION 6
-#include <sqlite.h>
+/* ==============================================================
+ *
+ * What follows are definitions that are used "globally" for all
+ * the different SQL engines and both inside and external to the
+ * cats directory.
+ */
-/* Define opaque structure for sqlite */
-struct sqlite {
- char dummy;
-};
+#define faddr_t long
-#define IS_NUM(x) ((x) == 1)
-#define IS_NOT_NULL(x) ((x) == 1)
+/*
+ * Generic definition of a sql_row.
+ */
+typedef char **SQL_ROW;
-typedef struct s_sql_field {
+/*
+ * Generic definition of a a sql_field.
+ */
+typedef struct sql_field {
char *name; /* name of column */
- uint32_t length; /* length */
- uint32_t max_length; /* max 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
- */
-typedef struct s_db {
- BQUEUE bq; /* queue control */
- brwlock_t lock; /* transaction lock */
- struct sqlite *db;
- char **result;
- int nrow; /* nrow returned from sqlite */
- int ncolumn; /* ncolum returned from sqlite */
- int num_rows; /* used by code */
- int row; /* seek row */
- int have_insert_id; /* do not have insert id */
- int fields_defined; /* set when fields defined */
- 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 */
- int connected;
- 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 */
- int transaction; /* transaction started */
- int changes; /* changes during transaction */
- POOLMEM *fname; /* Filename only */
- POOLMEM *path; /* Path only */
- POOLMEM *esc_name; /* Escaped file/path name */
- int fnl; /* file name length */
- int pnl; /* path name length */
-} B_DB;
-
-
-/*
- * "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)
-#define sql_close(x) sqlite_close((x)->db)
-#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_insert_id(x) sqlite_last_insert_rowid((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) (unsigned)((x)->ncolumn)
-#define SQL_ROW char**
-
-
-
-/* In cats/sqlite.c */
-extern int my_sqlite_query(B_DB *mdb, char *cmd);
-extern SQL_ROW my_sqlite_fetch_row(B_DB *mdb);
-extern void my_sqlite_free_table(B_DB *mdb);
-
-#else
-
-#ifdef HAVE_MYSQL
-
-#define BDB_VERSION 6
-
-#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
- */
-typedef struct s_db {
- BQUEUE bq; /* queue control */
- brwlock_t lock; /* transaction lock */
- MYSQL mysql;
- MYSQL *db;
- MYSQL_RES *result;
- 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() */
- int 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/path name */
- int fnl; /* file name length */
- int pnl; /* path name length */
-} B_DB;
-
-
-/* "Generic" names for easier conversion */
-#define sql_store_result(x) mysql_store_result((x)->db)
-#define sql_free_result(x) mysql_free_result((x)->result)
-#define sql_fetch_row(x) mysql_fetch_row((x)->result)
-#define sql_query(x, y) mysql_query((x)->db, y)
-#define sql_close(x) mysql_close((x)->db)
-#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) 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) mysql_num_fields((x)->result)
-#define SQL_ROW MYSQL_ROW
-#define SQL_FIELD MYSQL_FIELD
-
-#else /* USE BACULA DB routines */
-
-#define HAVE_BACULA_DB 1
-
-/* Change this each time there is some incompatible
- * file format change!!!!
+ * Structure used when calling db_get_query_ids()
+ * allows the subroutine to return a list of ids.
*/
-#define BDB_VERSION 12 /* 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 */
+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 */
};
-
-/* This is the REAL definition for using the
- * Bacula internal DB
- */
-typedef struct s_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;
-} B_DB;
-
-#endif /* HAVE_MYSQL */
-#endif /* HAVE_SQLITE */
-
-/* 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
- */
-typedef struct s_db {
- int dummy; /* for SunOS compiler */
-} B_DB;
-
-#endif /* __SQL_C */
-
-extern uint32_t bacula_db_version;
-
-/* ***FIXME*** FileId_t should be uint64_t */
-typedef uint32_t FileId_t;
-typedef uint32_t DBId_t; /* general DB id type */
-typedef uint32_t JobId_t;
-
-#define faddr_t long
-
-
/* 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,
JobId_t JobId;
char Job[MAX_NAME_LENGTH]; /* Job unique name */
char Name[MAX_NAME_LENGTH]; /* Job base name */
- int Type; /* actually char(1) */
- int Level; /* actually char(1) */
+ int JobType; /* actually char(1) */
+ int JobLevel; /* actually char(1) */
int JobStatus; /* actually char(1) */
- uint32_t ClientId; /* Id of client */
- uint32_t PoolId; /* Id of pool */
- uint32_t FileSetId; /* Id of FileSet */
+ 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 */
+ 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 JobErrors;
uint32_t JobMissingFiles;
uint64_t JobBytes;
+ uint64_t ReadBytes;
+ int PurgedFiles;
+ int HasBase;
/* Note, FirstIndex, LastIndex, Start/End File and Block
* are only used in the JobMedia record.
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 order; /* 0 ASC, 1 DESC */
+ 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
*/
/* JobMedia record */
struct JOBMEDIA_DBR {
- uint32_t JobMediaId; /* record id */
+ DBId_t JobMediaId; /* record id */
JobId_t JobId; /* JobId */
- uint32_t MediaId; /* MediaId */
+ 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 */
/* Volume Parameter structure */
struct VOL_PARAMS {
char VolumeName[MAX_NAME_LENGTH]; /* Volume name */
- uint32_t VolIndex; /* Volume seqence no. */
+ 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 */
+ uint64_t StartAddr; /* Start address */
+ uint64_t EndAddr; /* End address */
+ int32_t InChanger; /* InChanger flag */
};
char *attr; /* attributes statp */
uint32_t FileIndex;
uint32_t Stream;
+ uint32_t FileType;
+ uint32_t DeltaSeq;
JobId_t JobId;
- uint32_t ClientId;
- uint32_t PathId;
- uint32_t FilenameId;
+ DBId_t ClientId;
+ DBId_t PathId;
+ DBId_t FilenameId;
FileId_t FileId;
+ char *Digest;
+ int DigestType;
+};
+
+struct ROBJECT_DBR {
+ char *object_name;
+ char *object;
+ char *plugin_name;
+ char *JobIds;
+ 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;
};
FileId_t FileId;
uint32_t FileIndex;
JobId_t JobId;
- uint32_t FilenameId;
- uint32_t PathId;
+ DBId_t FilenameId;
+ DBId_t PathId;
JobId_t MarkId;
+ uint32_t DeltaSeq;
char LStat[256];
-/* int Status; */
- char SIG[50];
- int SigType; /* NO_SIG/MD5_SIG/SHA1_SIG */
+ 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 {
- uint32_t PoolId;
+ 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 */
+ 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 */
- char PoolType[MAX_NAME_LENGTH];
+ 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 */
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 {
- uint32_t MediaId; /* Unique volume id */
+class MEDIA_DBR {
+public:
+ MEDIA_DBR() { memset(this, 0, sizeof(MEDIA_DBR)); };
+ ~MEDIA_DBR() { };
+ void clear() { memset(this, 0, sizeof(MEDIA_DBR)); };
+ void copy(MEDIA_DBR *omr) { memcpy(this, omr, sizeof(MEDIA_DBR)); };
+
+ DBId_t MediaId; /* Unique volume id */
char VolumeName[MAX_NAME_LENGTH]; /* Volume name */
char MediaType[MAX_NAME_LENGTH]; /* Media type */
- uint32_t PoolId; /* Pool id */
- time_t FirstWritten; /* Time Volume first written */
+ 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 VolWrites; /* Number of writes */
+ uint64_t VolReads; /* Number of reads */
uint64_t VolBytes; /* Number of bytes written */
+ uint64_t VolABytes; /* Size of aligned volume */
+ uint64_t VolHoleBytes; /* The size of Holes */
+ uint32_t VolHoles; /* Number of holes */
+ uint32_t VolType; /* Device type of where Volume labeled */
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 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 */
int32_t Slot; /* slot in changer */
- int32_t Drive; /* drive in changer */
+ int32_t Enabled; /* 0=disabled, 1=enabled, 2=archived */
int32_t InChanger; /* Volume currently in changer */
- char VolStatus[20]; /* Volume status */
+ 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 cFirstWritten[MAX_TIME_LENGTH]; /* FirstWritten returned from DB */
char cLastWritten[MAX_TIME_LENGTH]; /* LastWritten returned from DB */
- char cLabelData[MAX_TIME_LENGTH]; /* LabelData returned from DB */
+ char cLabelDate[MAX_TIME_LENGTH]; /* LabelData returned from DB */
+ char cInitialWrite[MAX_TIME_LENGTH]; /* InitialWrite returned from DB */
+ char *exclude_list; /* Optionnal exclude list for db_find_next_volume() */
+ bool set_first_written;
+ bool set_label_date;
};
/* Client record -- same as the database */
struct CLIENT_DBR {
- uint32_t ClientId; /* Unique Client id */
+ DBId_t ClientId; /* Unique Client id */
int AutoPrune;
utime_t FileRetention;
utime_t JobRetention;
/* FileSet record -- same as the database */
struct FILESET_DBR {
- uint32_t FileSetId; /* Unique FileSet id */
+ 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 */
bool created; /* set when record newly created */
};
+class SNAPSHOT_DBR {
+public:
+ SNAPSHOT_DBR() {
+ memset(this, 0, sizeof(SNAPSHOT_DBR));
+ };
+ ~SNAPSHOT_DBR() {
+ reset();
+ };
+ void debug(int level) {
+ Dmsg8(DT_SNAPSHOT|level,
+ "Snapshot %s:\n"
+ " Volume: %s\n"
+ " Device: %s\n"
+ " Id: %d\n"
+ " FileSet: %s\n"
+ " CreateDate: %s\n"
+ " Client: %s\n"
+ " Type: %s\n",
+ Name, NPRT(Volume), NPRT(Device), SnapshotId,
+ FileSet, CreateDate, Client, Type);
+ };
+ char *as_arg(POOLMEM **out) {
+ bash_spaces(Name);
+ bash_spaces(Type);
+
+ if (Volume) {
+ bash_spaces(Volume);
+ }
+ if (Device) {
+ bash_spaces(Device);
+ }
+
+ Mmsg(out, "name=%s volume=%s device=%s tdate=%d type=%s",
+ Name, NPRTB(Volume), NPRTB(Device), CreateTDate, Type);
+
+ unbash_spaces(Name);
+ unbash_spaces(Type);
+ if (Volume) {
+ unbash_spaces(Volume);
+ }
+ if (Device) {
+ unbash_spaces(Device);
+ }
+ return *out;
+ };
+ void reset() {
+ if (need_to_free) {
+ if (Volume) {
+ free(Volume);
+ }
+ if (Device) {
+ free(Device);
+ }
+ if (errmsg) {
+ free(errmsg);
+ }
+ errmsg = Volume = Device = NULL;
+ }
+ need_to_free = false;
+ };
+ bool need_to_free; /* Need to free the internal memory */
+ /* Used when searching snapshots */
+ char created_after[MAX_TIME_LENGTH];
+ char created_before[MAX_TIME_LENGTH];
+ bool expired; /* Look for CreateTDate > (NOW - Retention) */
+ bool sorted_client; /* Results sorted by Client, SnapshotId */
+ int status; /* Status of the snapshot */
+
+ DBId_t SnapshotId; /* Unique Snapshot ID */
+ DBId_t JobId; /* Related JobId */
+ DBId_t FileSetId; /* FileSetId if any */
+ DBId_t ClientId; /* From which client this snapshot comes */
+ char Name[MAX_NAME_LENGTH]; /* Snapshot Name */
+ char FileSet[MAX_NAME_LENGTH];/* FileSet name if any */
+ char Client[MAX_NAME_LENGTH]; /* Client name */
+ char Type[MAX_NAME_LENGTH]; /* zfs, btrfs, lvm, netapp, */
+ char Comment[MAX_NAME_LENGTH];/* Comment */
+ char CreateDate[MAX_TIME_LENGTH]; /* Create date as string */
+ time_t CreateTDate; /* Create TDate (in sec, since epoch) */
+ char *Volume; /* Volume taken in snapshot */
+ char *Device; /* Device, Pool, Directory, ... */
+ char *errmsg; /* Error associated with a snapshot */
+ utime_t Retention; /* Number of second before pruning the snapshot */
+ uint64_t Size; /* Snapshot Size */
+};
+
+/* Call back context for getting a 32/64 bit value from the database */
+class db_int64_ctx {
+public:
+ int64_t value; /* value returned */
+ int count; /* number of values seen */
+
+ db_int64_ctx() : value(0), count(0) {};
+ ~db_int64_ctx() {};
+private:
+ db_int64_ctx(const db_int64_ctx&); /* prohibit pass by value */
+ db_int64_ctx &operator=(const db_int64_ctx&); /* prohibit class assignment */
+};
+
+/* 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 add(const db_list_ctx &str) {
+ if (str.count > 0) {
+ if (*list) {
+ pm_strcat(list, ",");
+ }
+ pm_strcat(list, str.list);
+ count += str.count;
+ }
+ }
+ void add(const char *str) {
+ if (count > 0) {
+ pm_strcat(list, ",");
+ }
+ pm_strcat(list, 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 */
+};
+/* sql_query flags */
+#define QF_STORE_RESULT 0x01
+
+/* sql_list.c */
+enum e_list_type {
+ HORZ_LIST, /* list */
+ VERT_LIST, /* llist */
+ ARG_LIST, /* key1=v1 key2=v2 key3=v3 */
+ FAILED_JOBS,
+ INCOMPLETE_JOBS
+};
+
+#include "bdb.h"
#include "protos.h"
#include "jcr.h"
-
-#endif /* __SQL_H_ */
+#include "sql_cmds.h"
+
+
+/* Object used in db_list_xxx function */
+class LIST_CTX {
+public:
+ char line[256]; /* Used to print last dash line */
+ int32_t num_rows;
+
+ e_list_type type; /* Vertical/Horizontal */
+ DB_LIST_HANDLER *send; /* send data back */
+ bool once; /* Used to print header one time */
+ void *ctx; /* send() user argument */
+ BDB *mdb;
+ JCR *jcr;
+
+ void empty() {
+ once = false;
+ line[0] = '\0';
+ }
+
+ void send_dashes() {
+ if (*line) {
+ send(ctx, line);
+ }
+ }
+
+ LIST_CTX(JCR *j, BDB *m, DB_LIST_HANDLER *h, void *c, e_list_type t) {
+ line[0] = '\0';
+ once = false;
+ num_rows = 0;
+ type = t;
+ send = h;
+ ctx = c;
+ jcr = j;
+ mdb = m;
+ }
+};
+
+/* Functions exported by sql.c for use within the cats directory. */
+int list_result(void *vctx, int cols, char **row);
+int list_result(JCR *jcr, BDB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type type);
+int get_sql_record_max(JCR *jcr, BDB *mdb);
+void list_dashes(BDB *mdb, DB_LIST_HANDLER *send, void *ctx);
+
+void print_dashes(BDB *mdb);
+void print_result(BDB *mdb);
+int QueryDB(const char *file, int line, JCR *jcr, BDB *db, char *select_cmd);
+int InsertDB(const char *file, int line, JCR *jcr, BDB *db, char *select_cmd);
+int DeleteDB(const char *file, int line, JCR *jcr, BDB *db, char *delete_cmd);
+void split_path_and_file(JCR *jcr, BDB *mdb, const char *fname);
+
+#endif /* __CATS_H_ */