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

   1 /*
   2  * Bacula Catalog Database Find record interface routines
   3  *
   4  *  Note, generally, these routines are more complicated
   5  *        that a simple search by name or id. Such simple
   6  *        request are in get.c
   7  *
   8  *    Kern Sibbald, December 2000
   9  *
  10  *    Version $Id$
  11  */
  12
  13 /*
  14    Copyright (C) 2000-2005 Kern Sibbald
  15
  16    This program is free software; you can redistribute it and/or
  17    modify it under the terms of the GNU General Public License as
  18    published by the Free Software Foundation; either version 2 of
  19    the License, or (at your option) any later version.
  20
  21    This program is distributed in the hope that it will be useful,
  22    but WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  24    General Public License for more details.
  25
  26    You should have received a copy of the GNU General Public
  27    License along with this program; if not, write to the Free
  28    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  29    MA 02111-1307, USA.
  30
  31  */
  32
  33
  34 /* The following is necessary so that we do not include
  35  * the dummy external definition of DB.
  36  */
  37 #define __SQL_C                       /* indicate that this is sql.c */
  38
  39 #include "bacula.h"
  40 #include "cats.h"
  41
  42 #if    HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL
  43
  44 /* -----------------------------------------------------------------------
  45  *
  46  *   Generic Routines (or almost generic)
  47  *
  48  * -----------------------------------------------------------------------
  49  */
  50
  51 /* Imported subroutines */
  52 extern void print_result(B_DB *mdb);
  53 extern int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
  54
  55 /*
  56  * Find job start time if JobId specified, otherwise
  57  * find last full save for Incremental and Differential saves.
  58  *
  59  *  StartTime is returned in stime
  60  *
  61  * Returns: 0 on failure
  62  *          1 on success, jr is unchanged, but stime is set
  63  */
  64 int
  65 db_find_job_start_time(JCR *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM **stime)
  66 {
  67    SQL_ROW row;
  68    char ed1[50], ed2[50];
  69
  70    db_lock(mdb);
  71
  72    pm_strcpy(stime, "0000-00-00 00:00:00");   /* default */
  73    /* If no Id given, we must find corresponding job */
  74    if (jr->JobId == 0) {
  75       /* Differential is since last Full backup */
  76          Mmsg(mdb->cmd,
  77 "SELECT StartTime FROM Job WHERE JobStatus='T' AND Type='%c' AND "
  78 "Level='%c' AND Name='%s' AND ClientId=%s AND FileSetId=%s "
  79 "ORDER BY StartTime DESC LIMIT 1",
  80            jr->JobType, L_FULL, jr->Name,
  81            edit_int64(jr->ClientId, ed1), edit_int64(jr->FileSetId, ed2));
  82
  83       if (jr->JobLevel == L_DIFFERENTIAL) {
  84          /* SQL cmd for Differential backup already edited above */
  85
  86       /* Incremental is since last Full, Incremental, or Differential */
  87       } else if (jr->JobLevel == L_INCREMENTAL) {
  88          /*
  89           * For an Incremental job, we must first ensure
  90           *  that a Full backup was done (cmd edited above)
  91           *  then we do a second look to find the most recent
  92           *  backup
  93           */
  94          if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
  95             Mmsg2(&mdb->errmsg, _("Query error for start time request: ERR=%s\nCMD=%s\n"),
  96                sql_strerror(mdb), mdb->cmd);
  97             db_unlock(mdb);
  98             return 0;
  99          }
 100          if ((row = sql_fetch_row(mdb)) == NULL) {
 101             sql_free_result(mdb);
 102             Mmsg(mdb->errmsg, _("No prior Full backup Job record found.\n"));
 103             db_unlock(mdb);
 104             return 0;
 105          }
 106          sql_free_result(mdb);
 107          /* Now edit SQL command for Incremental Job */
 108          Mmsg(mdb->cmd,
 109 "SELECT StartTime FROM Job WHERE JobStatus='T' AND Type='%c' AND "
 110 "Level IN ('%c','%c','%c') AND Name='%s' AND ClientId=%s "
 111 "AND FileSetId=%s ORDER BY StartTime DESC LIMIT 1",
 112             jr->JobType, L_INCREMENTAL, L_DIFFERENTIAL, L_FULL, jr->Name,
 113             edit_int64(jr->ClientId, ed1), edit_int64(jr->FileSetId, ed2));
 114       } else {
 115          Mmsg1(&mdb->errmsg, _("Unknown level=%d\n"), jr->JobLevel);
 116          db_unlock(mdb);
 117          return 0;
 118       }
 119    } else {
 120       Dmsg1(100, "Submitting: %s\n", mdb->cmd);
 121       Mmsg(mdb->cmd, "SELECT StartTime FROM Job WHERE Job.JobId=%s",
 122            edit_int64(jr->JobId, ed1));
 123    }
 124
 125    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 126       pm_strcpy(stime, "");                   /* set EOS */
 127       Mmsg2(&mdb->errmsg, _("Query error for start time request: ERR=%s\nCMD=%s\n"),
 128          sql_strerror(mdb),  mdb->cmd);
 129       db_unlock(mdb);
 130       return 0;
 131    }
 132
 133    if ((row = sql_fetch_row(mdb)) == NULL) {
 134       Mmsg2(&mdb->errmsg, _("No Job record found: ERR=%s\nCMD=%s\n"),
 135          sql_strerror(mdb),  mdb->cmd);
 136       sql_free_result(mdb);
 137       db_unlock(mdb);
 138       return 0;
 139    }
 140    Dmsg1(100, "Got start time: %s\n", row[0]);
 141    pm_strcpy(stime, row[0]);
 142
 143    sql_free_result(mdb);
 144
 145    db_unlock(mdb);
 146    return 1;
 147 }
 148
 149 /*
 150  * Find last failed job since given start-time
 151  *   it must be either Full or Diff.
 152  *
 153  * Returns: false on failure
 154  *          true  on success, jr is unchanged and stime unchanged
 155  *                level returned in JobLevel
 156  */
 157 bool
 158 db_find_failed_job_since(JCR *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM *stime, int &JobLevel)
 159 {
 160    SQL_ROW row;
 161    char ed1[50], ed2[50];
 162
 163    db_lock(mdb);
 164    /* Differential is since last Full backup */
 165    Mmsg(mdb->cmd,
 166 "SELECT Level FROM Job WHERE JobStatus!='T' AND Type='%c' AND "
 167 "Level IN ('%c','%c') AND Name='%s' AND ClientId=%s "
 168 "AND FileSetId=%s AND StartTime>'%s' "
 169 "ORDER BY StartTime DESC LIMIT 1",
 170          jr->JobType, L_FULL, L_DIFFERENTIAL, jr->Name,
 171          edit_int64(jr->ClientId, ed1), edit_int64(jr->FileSetId, ed2),
 172          stime);
 173
 174    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 175       db_unlock(mdb);
 176       return false;
 177    }
 178
 179    if ((row = sql_fetch_row(mdb)) == NULL) {
 180       sql_free_result(mdb);
 181       db_unlock(mdb);
 182       return false;
 183    }
 184    JobLevel = (int)*row[0];
 185    sql_free_result(mdb);
 186
 187    db_unlock(mdb);
 188    return true;
 189 }
 190
 191
 192 /*
 193  * Find JobId of last job that ran.  E.g. for
 194  *   VERIFY_CATALOG we want the JobId of the last INIT.
 195  *   For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the last Job.
 196  *
 197  * Returns: 1 on success
 198  *          0 on failure
 199  */
 200 int
 201 db_find_last_jobid(JCR *jcr, B_DB *mdb, const char *Name, JOB_DBR *jr)
 202 {
 203    SQL_ROW row;
 204    char ed1[50];
 205
 206    /* Find last full */
 207    db_lock(mdb);
 208    if (jr->JobLevel == L_VERIFY_CATALOG) {
 209       Mmsg(mdb->cmd,
 210 "SELECT JobId FROM Job WHERE Type='V' AND Level='%c' AND "
 211 " JobStatus='T' AND Name='%s' AND "
 212 "ClientId=%s ORDER BY StartTime DESC LIMIT 1",
 213            L_VERIFY_INIT, jr->Name,
 214            edit_int64(jr->ClientId, ed1));
 215    } else if (jr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||
 216               jr->JobLevel == L_VERIFY_DISK_TO_CATALOG) {
 217       if (Name) {
 218          Mmsg(mdb->cmd,
 219 "SELECT JobId FROM Job WHERE Type='B' AND JobStatus='T' AND "
 220 "Name='%s' ORDER BY StartTime DESC LIMIT 1", Name);
 221       } else {
 222          Mmsg(mdb->cmd,
 223 "SELECT JobId FROM Job WHERE Type='B' AND JobStatus='T' AND "
 224 "ClientId=%s ORDER BY StartTime DESC LIMIT 1",
 225            edit_int64(jr->ClientId, ed1));
 226       }
 227    } else {
 228       Mmsg1(&mdb->errmsg, _("Unknown Job level=%c\n"), jr->JobLevel);
 229       db_unlock(mdb);
 230       return 0;
 231    }
 232    Dmsg1(100, "Query: %s\n", mdb->cmd);
 233    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 234       db_unlock(mdb);
 235       return 0;
 236    }
 237    if ((row = sql_fetch_row(mdb)) == NULL) {
 238       Mmsg1(&mdb->errmsg, _("No Job found for: %s.\n"), mdb->cmd);
 239       sql_free_result(mdb);
 240       db_unlock(mdb);
 241       return 0;
 242    }
 243
 244    jr->JobId = atoi(row[0]);
 245    sql_free_result(mdb);
 246
 247    Dmsg1(100, "db_get_last_jobid: got JobId=%d\n", jr->JobId);
 248    if (jr->JobId <= 0) {
 249       Mmsg1(&mdb->errmsg, _("No Job found for: %s\n"), mdb->cmd);
 250       db_unlock(mdb);
 251       return 0;
 252    }
 253
 254    db_unlock(mdb);
 255    return 1;
 256 }
 257
 258 /*
 259  * Find Available Media (Volume) for Pool
 260  *
 261  * Find a Volume for a given PoolId, MediaType, and Status.
 262  *
 263  * Returns: 0 on failure
 264  *          numrows on success
 265  */
 266 int
 267 db_find_next_volume(JCR *jcr, B_DB *mdb, int item, bool InChanger, MEDIA_DBR *mr)
 268 {
 269    SQL_ROW row;
 270    int numrows;
 271    const char *changer, *order;
 272    char ed1[50];
 273
 274    db_lock(mdb);
 275    if (item == -1) {       /* find oldest volume */
 276       /* Find oldest volume */
 277       Mmsg(mdb->cmd, "SELECT MediaId,VolumeName,VolJobs,VolFiles,VolBlocks,"
 278           "VolBytes,VolMounts,VolErrors,VolWrites,MaxVolBytes,VolCapacityBytes,"
 279           "VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,Recycle,Slot,"
 280           "FirstWritten,LastWritten,VolStatus,InChanger,VolParts,"
 281           "LabelType "
 282           "FROM Media WHERE PoolId=%s AND MediaType='%s' AND VolStatus IN ('Full',"
 283           "'Recycle','Purged','Used','Append') "
 284           "ORDER BY LastWritten LIMIT 1",
 285           edit_int64(mr->PoolId, ed1), mr->MediaType);
 286      item = 1;
 287    } else {
 288       /* Find next available volume */
 289       if (InChanger) {
 290          changer = "AND InChanger=1";
 291       } else {
 292          changer = "";
 293       }
 294       if (strcmp(mr->VolStatus, "Recycled") == 0 ||
 295           strcmp(mr->VolStatus, "Purged") == 0) {
 296          order = "ORDER BY LastWritten ASC,MediaId";  /* take oldest */
 297       } else {
 298          order = "ORDER BY LastWritten IS NULL,LastWritten DESC,MediaId";   /* take most recently written */
 299       }
 300       Mmsg(mdb->cmd, "SELECT MediaId,VolumeName,VolJobs,VolFiles,VolBlocks,"
 301           "VolBytes,VolMounts,VolErrors,VolWrites,MaxVolBytes,VolCapacityBytes,"
 302           "VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,Recycle,Slot,"
 303           "FirstWritten,LastWritten,VolStatus,InChanger,VolParts,"
 304           "LabelType "
 305           "FROM Media WHERE PoolId=%s AND MediaType='%s' AND VolStatus='%s' "
 306           "%s "
 307           "%s LIMIT %d",
 308           edit_int64(mr->PoolId, ed1), mr->MediaType,
 309           mr->VolStatus, changer, order, item);
 310    }
 311    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 312       db_unlock(mdb);
 313       return 0;
 314    }
 315
 316    numrows = sql_num_rows(mdb);
 317    if (item > numrows) {
 318       Mmsg2(&mdb->errmsg, _("Request for Volume item %d greater than max %d\n"),
 319          item, numrows);
 320       db_unlock(mdb);
 321       return 0;
 322    }
 323
 324    /* Seek to desired item
 325     * Note, we use base 1; SQL uses base 0
 326     */
 327    sql_data_seek(mdb, item-1);
 328
 329    if ((row = sql_fetch_row(mdb)) == NULL) {
 330       Mmsg1(&mdb->errmsg, _("No Volume record found for item %d.\n"), item);
 331       sql_free_result(mdb);
 332       db_unlock(mdb);
 333       return 0;
 334    }
 335
 336    /* Return fields in Media Record */
 337    mr->MediaId = str_to_int64(row[0]);
 338    bstrncpy(mr->VolumeName, row[1], sizeof(mr->VolumeName));
 339    mr->VolJobs = str_to_int64(row[2]);
 340    mr->VolFiles = str_to_int64(row[3]);
 341    mr->VolBlocks = str_to_int64(row[4]);
 342    mr->VolBytes = str_to_uint64(row[5]);
 343    mr->VolMounts = str_to_int64(row[6]);
 344    mr->VolErrors = str_to_int64(row[7]);
 345    mr->VolWrites = str_to_int64(row[8]);
 346    mr->MaxVolBytes = str_to_uint64(row[9]);
 347    mr->VolCapacityBytes = str_to_uint64(row[10]);
 348    mr->VolRetention = str_to_uint64(row[11]);
 349    mr->VolUseDuration = str_to_uint64(row[12]);
 350    mr->MaxVolJobs = str_to_int64(row[13]);
 351    mr->MaxVolFiles = str_to_int64(row[14]);
 352    mr->Recycle = str_to_int64(row[15]);
 353    mr->Slot = str_to_int64(row[16]);
 354    bstrncpy(mr->cFirstWritten, row[17]!=NULL?row[17]:"", sizeof(mr->cFirstWritten));
 355    mr->FirstWritten = (time_t)str_to_utime(mr->cFirstWritten);
 356    bstrncpy(mr->cLastWritten, row[18]!=NULL?row[18]:"", sizeof(mr->cLastWritten));
 357    mr->LastWritten = (time_t)str_to_utime(mr->cLastWritten);
 358    bstrncpy(mr->VolStatus, row[19], sizeof(mr->VolStatus));
 359    mr->InChanger = str_to_int64(row[20]);
 360    mr->VolParts = str_to_int64(row[21]);
 361    mr->LabelType = str_to_int64(row[22]);
 362    sql_free_result(mdb);
 363
 364    db_unlock(mdb);
 365    return numrows;
 366 }
 367
 368
 369 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL*/