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

   1 /*
   2  * Bacula Catalog Database Get record interface routines
   3  *  Note, these routines generally get a record by id or
   4  *        by name.  If more logic is involved, the routine
   5  *        should be in find.c
   6  *
   7  *    Kern Sibbald, March 2000
   8  *
   9  *    Version $Id$
  10  */
  11
  12 /*
  13    Copyright (C) 2000-2005 Kern Sibbald
  14
  15    This program is free software; you can redistribute it and/or
  16    modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation; either version 2 of
  18    the License, or (at your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public
  26    License along with this program; if not, write to the Free
  27    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  28    MA 02111-1307, USA.
  29
  30  */
  31
  32
  33 /* The following is necessary so that we do not include
  34  * the dummy external definition of DB.
  35  */
  36 #define __SQL_C                       /* indicate that this is sql.c */
  37
  38 #include "bacula.h"
  39 #include "cats.h"
  40
  41 #if    HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL
  42
  43 /* -----------------------------------------------------------------------
  44  *
  45  *   Generic Routines (or almost generic)
  46  *
  47  * -----------------------------------------------------------------------
  48  */
  49
  50 /* Forward referenced functions */
  51 static int db_get_file_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr, FILE_DBR *fdbr);
  52 static int db_get_filename_record(JCR *jcr, B_DB *mdb);
  53 static int db_get_path_record(JCR *jcr, B_DB *mdb);
  54
  55
  56 /* Imported subroutines */
  57 extern void print_result(B_DB *mdb);
  58 extern int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
  59 extern void split_path_and_file(JCR *jcr, B_DB *mdb, const char *fname);
  60
  61
  62
  63 /*
  64  * Given a full filename (with path), look up the File record
  65  * (with attributes) in the database.
  66  *
  67  *  Returns: 0 on failure
  68  *           1 on success with the File record in FILE_DBR
  69  */
  70 int db_get_file_attributes_record(JCR *jcr, B_DB *mdb, char *fname, JOB_DBR *jr, FILE_DBR *fdbr)
  71 {
  72    int stat;
  73    Dmsg1(100, "db_get_file_att_record fname=%s \n", fname);
  74
  75    db_lock(mdb);
  76    split_path_and_file(jcr, mdb, fname);
  77
  78    fdbr->FilenameId = db_get_filename_record(jcr, mdb);
  79
  80    fdbr->PathId = db_get_path_record(jcr, mdb);
  81
  82    stat = db_get_file_record(jcr, mdb, jr, fdbr);
  83
  84    db_unlock(mdb);
  85
  86    return stat;
  87 }
  88
  89
  90 /*
  91  * Get a File record
  92  * Returns: 0 on failure
  93  *          1 on success
  94  *
  95  *  DO NOT use Jmsg in this routine.
  96  *
  97  *  Note in this routine, we do not use Jmsg because it may be
  98  *    called to get attributes of a non-existent file, which is
  99  *    "normal" if a new file is found during Verify.
 100  */
 101 static
 102 int db_get_file_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr, FILE_DBR *fdbr)
 103 {
 104    SQL_ROW row;
 105    int stat = 0;
 106    char ed1[50], ed2[50], ed3[50];
 107
 108    if (jcr->JobLevel == L_VERIFY_DISK_TO_CATALOG) {
 109    Mmsg(mdb->cmd,
 110 "SELECT FileId, LStat, MD5 FROM File,Job WHERE "
 111 "File.JobId=Job.JobId AND File.PathId=%s AND "
 112 "File.FilenameId=%s AND Job.Type='B' AND Job.JobSTATUS='T' AND "
 113 "ClientId=%s ORDER BY StartTime DESC LIMIT 1",
 114       edit_int64(fdbr->PathId, ed1),
 115       edit_int64(fdbr->FilenameId, ed2),
 116       edit_int64(jr->ClientId,ed3));
 117
 118    } else {
 119       Mmsg(mdb->cmd,
 120 "SELECT FileId, LStat, MD5 FROM File WHERE File.JobId=%u AND File.PathId=%u AND "
 121 "File.FilenameId=%u", fdbr->JobId, fdbr->PathId, fdbr->FilenameId);
 122    }
 123    Dmsg3(050, "Get_file_record JobId=%u FilenameId=%u PathId=%u\n",
 124       fdbr->JobId, fdbr->FilenameId, fdbr->PathId);
 125
 126    Dmsg1(100, "Query=%s\n", mdb->cmd);
 127
 128    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 129       mdb->num_rows = sql_num_rows(mdb);
 130       Dmsg1(050, "get_file_record num_rows=%d\n", (int)mdb->num_rows);
 131       if (mdb->num_rows > 1) {
 132          Mmsg1(&mdb->errmsg, _("get_file_record want 1 got rows=%d\n"),
 133             mdb->num_rows);
 134       }
 135       if (mdb->num_rows >= 1) {
 136          if ((row = sql_fetch_row(mdb)) == NULL) {
 137             Mmsg1(&mdb->errmsg, _("Error fetching row: %s\n"), sql_strerror(mdb));
 138          } else {
 139             fdbr->FileId = (FileId_t)str_to_int64(row[0]);
 140             bstrncpy(fdbr->LStat, row[1], sizeof(fdbr->LStat));
 141             bstrncpy(fdbr->SIG, row[2], sizeof(fdbr->SIG));
 142             stat = 1;
 143          }
 144       } else {
 145          Mmsg2(&mdb->errmsg, _("File record for PathId=%u FilenameId=%u not found.\n"),
 146             fdbr->PathId, fdbr->FilenameId);
 147       }
 148       sql_free_result(mdb);
 149    } else {
 150       Mmsg(mdb->errmsg, _("File record not found in Catalog.\n"));
 151    }
 152    return stat;
 153
 154 }
 155
 156 /* Get Filename record
 157  * Returns: 0 on failure
 158  *          FilenameId on success
 159  *
 160  *   DO NOT use Jmsg in this routine (see notes for get_file_record)
 161  */
 162 static int db_get_filename_record(JCR *jcr, B_DB *mdb)
 163 {
 164    SQL_ROW row;
 165    int FilenameId = 0;
 166
 167    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
 168    db_escape_string(mdb->esc_name, mdb->fname, mdb->fnl);
 169
 170    Mmsg(mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
 171    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 172       char ed1[30];
 173       mdb->num_rows = sql_num_rows(mdb);
 174       if (mdb->num_rows > 1) {
 175          Mmsg2(&mdb->errmsg, _("More than one Filename!: %s for file: %s\n"),
 176             edit_uint64(mdb->num_rows, ed1), mdb->fname);
 177          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
 178       }
 179       if (mdb->num_rows >= 1) {
 180          if ((row = sql_fetch_row(mdb)) == NULL) {
 181             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 182          } else {
 183             FilenameId = atoi(row[0]);
 184             if (FilenameId <= 0) {
 185                Mmsg2(&mdb->errmsg, _("Get DB Filename record %s found bad record: %d\n"),
 186                   mdb->cmd, FilenameId);
 187                FilenameId = 0;
 188             }
 189          }
 190       } else {
 191          Mmsg1(&mdb->errmsg, _("Filename record: %s not found.\n"), mdb->fname);
 192       }
 193       sql_free_result(mdb);
 194    } else {
 195       Mmsg(mdb->errmsg, _("Filename record: %s not found in Catalog.\n"), mdb->fname);
 196    }
 197    return FilenameId;
 198 }
 199
 200 /* Get path record
 201  * Returns: 0 on failure
 202  *          PathId on success
 203  *
 204  *   DO NOT use Jmsg in this routine (see notes for get_file_record)
 205  */
 206 static int db_get_path_record(JCR *jcr, B_DB *mdb)
 207 {
 208    SQL_ROW row;
 209    uint32_t PathId = 0;
 210
 211    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->pnl+2);
 212    db_escape_string(mdb->esc_name, mdb->path, mdb->pnl);
 213
 214    if (mdb->cached_path_id != 0 && mdb->cached_path_len == mdb->pnl &&
 215        strcmp(mdb->cached_path, mdb->path) == 0) {
 216       return mdb->cached_path_id;
 217    }
 218
 219    Mmsg(mdb->cmd, "SELECT PathId FROM Path WHERE Path='%s'", mdb->esc_name);
 220
 221    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 222       char ed1[30];
 223       mdb->num_rows = sql_num_rows(mdb);
 224       if (mdb->num_rows > 1) {
 225          Mmsg2(&mdb->errmsg, _("More than one Path!: %s for path: %s\n"),
 226             edit_uint64(mdb->num_rows, ed1), mdb->path);
 227          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
 228       }
 229       /* Even if there are multiple paths, take the first one */
 230       if (mdb->num_rows >= 1) {
 231          if ((row = sql_fetch_row(mdb)) == NULL) {
 232             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 233          } else {
 234             PathId = atoi(row[0]);
 235             if (PathId <= 0) {
 236                Mmsg2(&mdb->errmsg, _("Get DB path record %s found bad record: %u\n"),
 237                   mdb->cmd, PathId);
 238                PathId = 0;
 239             } else {
 240                /* Cache path */
 241                if (PathId != mdb->cached_path_id) {
 242                   mdb->cached_path_id = PathId;
 243                   mdb->cached_path_len = mdb->pnl;
 244                   pm_strcpy(&mdb->cached_path, mdb->path);
 245                }
 246             }
 247          }
 248       } else {
 249          Mmsg1(&mdb->errmsg, _("Path record: %s not found.\n"), mdb->path);
 250       }
 251       sql_free_result(mdb);
 252    } else {
 253       Mmsg(mdb->errmsg, _("Path record: %s not found in Catalog.\n"), mdb->path);
 254    }
 255    return PathId;
 256 }
 257
 258
 259 /*
 260  * Get Job record for given JobId or Job name
 261  * Returns: 0 on failure
 262  *          1 on success
 263  */
 264 int db_get_job_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
 265 {
 266    SQL_ROW row;
 267    char ed1[50];
 268
 269    db_lock(mdb);
 270    if (jr->JobId == 0) {
 271       Mmsg(mdb->cmd, "SELECT VolSessionId,VolSessionTime,"
 272 "PoolId,StartTime,EndTime,JobFiles,JobBytes,JobTDate,Job,JobStatus,"
 273 "Type,Level,ClientId "
 274 "FROM Job WHERE Job='%s'", jr->Job);
 275     } else {
 276       Mmsg(mdb->cmd, "SELECT VolSessionId,VolSessionTime,"
 277 "PoolId,StartTime,EndTime,JobFiles,JobBytes,JobTDate,Job,JobStatus,"
 278 "Type,Level,ClientId "
 279 "FROM Job WHERE JobId=%s",
 280           edit_int64(jr->JobId, ed1));
 281     }
 282
 283    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 284       db_unlock(mdb);
 285       return 0;                       /* failed */
 286    }
 287    if ((row = sql_fetch_row(mdb)) == NULL) {
 288       Mmsg1(&mdb->errmsg, _("No Job found for JobId %u\n"), jr->JobId);
 289       sql_free_result(mdb);
 290       db_unlock(mdb);
 291       return 0;                       /* failed */
 292    }
 293
 294    jr->VolSessionId = str_to_uint64(row[0]);
 295    jr->VolSessionTime = str_to_uint64(row[1]);
 296    jr->PoolId = str_to_int64(row[2]);
 297    bstrncpy(jr->cStartTime, row[3]!=NULL?row[3]:"", sizeof(jr->cStartTime));
 298    bstrncpy(jr->cEndTime, row[4]!=NULL?row[4]:"", sizeof(jr->cEndTime));
 299    jr->JobFiles = atol(row[5]);
 300    jr->JobBytes = str_to_int64(row[6]);
 301    jr->JobTDate = str_to_int64(row[7]);
 302    bstrncpy(jr->Job, row[8]!=NULL?row[8]:"", sizeof(jr->Job));
 303    jr->JobStatus = (int)*row[9];
 304    jr->JobType = (int)*row[10];
 305    jr->JobLevel = (int)*row[11];
 306    jr->ClientId = str_to_uint64(row[12]!=NULL?row[12]:(char *)"");
 307    sql_free_result(mdb);
 308
 309    db_unlock(mdb);
 310    return 1;
 311 }
 312
 313 /*
 314  * Find VolumeNames for a given JobId
 315  *  Returns: 0 on error or no Volumes found
 316  *           number of volumes on success
 317  *              Volumes are concatenated in VolumeNames
 318  *              separated by a vertical bar (|) in the order
 319  *              that they were written.
 320  *
 321  *  Returns: number of volumes on success
 322  */
 323 int db_get_job_volume_names(JCR *jcr, B_DB *mdb, JobId_t JobId, POOLMEM **VolumeNames)
 324 {
 325    SQL_ROW row;
 326    char ed1[50];
 327    int stat = 0;
 328    int i;
 329
 330    db_lock(mdb);
 331    /* Get one entry per VolumeName, but "sort" by VolIndex */
 332    Mmsg(mdb->cmd,
 333         "SELECT VolumeName,MAX(VolIndex) FROM JobMedia,Media WHERE "
 334         "JobMedia.JobId=%s AND JobMedia.MediaId=Media.MediaId "
 335         "GROUP BY VolumeName "
 336         "ORDER BY 2 ASC", edit_int64(JobId,ed1));
 337
 338    Dmsg1(130, "VolNam=%s\n", mdb->cmd);
 339    *VolumeNames[0] = 0;
 340    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 341       mdb->num_rows = sql_num_rows(mdb);
 342       Dmsg1(130, "Num rows=%d\n", mdb->num_rows);
 343       if (mdb->num_rows <= 0) {
 344          Mmsg1(&mdb->errmsg, _("No volumes found for JobId=%d\n"), JobId);
 345          stat = 0;
 346       } else {
 347          stat = mdb->num_rows;
 348          for (i=0; i < stat; i++) {
 349             if ((row = sql_fetch_row(mdb)) == NULL) {
 350                Mmsg2(&mdb->errmsg, _("Error fetching row %d: ERR=%s\n"), i, sql_strerror(mdb));
 351                Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 352                stat = 0;
 353                break;
 354             } else {
 355                if (*VolumeNames[0] != 0) {
 356                   pm_strcat(VolumeNames, "|");
 357                }
 358                pm_strcat(VolumeNames, row[0]);
 359             }
 360          }
 361       }
 362       sql_free_result(mdb);
 363    } else {
 364       Mmsg(mdb->errmsg, _("No Volume for JobId %d found in Catalog.\n"), JobId);
 365    }
 366    db_unlock(mdb);
 367    return stat;
 368 }
 369
 370 /*
 371  * Find Volume parameters for a give JobId
 372  *  Returns: 0 on error or no Volumes found
 373  *           number of volumes on success
 374  *           List of Volumes and start/end file/blocks (malloced structure!)
 375  *
 376  *  Returns: number of volumes on success
 377  */
 378 int db_get_job_volume_parameters(JCR *jcr, B_DB *mdb, JobId_t JobId, VOL_PARAMS **VolParams)
 379 {
 380    SQL_ROW row;
 381    char ed1[50];
 382    int stat = 0;
 383    int i;
 384    VOL_PARAMS *Vols = NULL;
 385
 386    db_lock(mdb);
 387    Mmsg(mdb->cmd,
 388 "SELECT VolumeName,MediaType,FirstIndex,LastIndex,StartFile,"
 389 "JobMedia.EndFile,StartBlock,JobMedia.EndBlock"
 390 " FROM JobMedia,Media WHERE JobMedia.JobId=%s"
 391 " AND JobMedia.MediaId=Media.MediaId ORDER BY VolIndex,JobMediaId",
 392         edit_int64(JobId, ed1));
 393
 394    Dmsg1(130, "VolNam=%s\n", mdb->cmd);
 395    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 396       mdb->num_rows = sql_num_rows(mdb);
 397       Dmsg1(130, "Num rows=%d\n", mdb->num_rows);
 398       if (mdb->num_rows <= 0) {
 399          Mmsg1(&mdb->errmsg, _("No volumes found for JobId=%d\n"), JobId);
 400          stat = 0;
 401       } else {
 402          stat = mdb->num_rows;
 403          if (stat > 0) {
 404             *VolParams = Vols = (VOL_PARAMS *)malloc(stat * sizeof(VOL_PARAMS));
 405          }
 406          for (i=0; i < stat; i++) {
 407             if ((row = sql_fetch_row(mdb)) == NULL) {
 408                Mmsg2(&mdb->errmsg, _("Error fetching row %d: ERR=%s\n"), i, sql_strerror(mdb));
 409                Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 410                stat = 0;
 411                break;
 412             } else {
 413                bstrncpy(Vols[i].VolumeName, row[0], MAX_NAME_LENGTH);
 414                bstrncpy(Vols[i].MediaType, row[1], MAX_NAME_LENGTH);
 415                Vols[i].FirstIndex = str_to_uint64(row[2]);
 416                Vols[i].LastIndex = str_to_uint64(row[3]);
 417                Vols[i].StartFile = str_to_uint64(row[4]);
 418                Vols[i].EndFile = str_to_uint64(row[5]);
 419                Vols[i].StartBlock = str_to_uint64(row[6]);
 420                Vols[i].EndBlock = str_to_uint64(row[7]);
 421             }
 422          }
 423       }
 424       sql_free_result(mdb);
 425    }
 426    db_unlock(mdb);
 427    return stat;
 428 }
 429
 430
 431
 432 /*
 433  * Get the number of pool records
 434  *
 435  * Returns: -1 on failure
 436  *          number on success
 437  */
 438 int db_get_num_pool_records(JCR *jcr, B_DB *mdb)
 439 {
 440    int stat = 0;
 441
 442    db_lock(mdb);
 443    Mmsg(mdb->cmd, "SELECT count(*) from Pool");
 444    stat = get_sql_record_max(jcr, mdb);
 445    db_unlock(mdb);
 446    return stat;
 447 }
 448
 449 /*
 450  * This function returns a list of all the Pool record ids.
 451  *  The caller must free ids if non-NULL.
 452  *
 453  *  Returns 0: on failure
 454  *          1: on success
 455  */
 456 int db_get_pool_ids(JCR *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
 457 {
 458    SQL_ROW row;
 459    int stat = 0;
 460    int i = 0;
 461    uint32_t *id;
 462
 463    db_lock(mdb);
 464    *ids = NULL;
 465    Mmsg(mdb->cmd, "SELECT PoolId FROM Pool");
 466    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 467       *num_ids = sql_num_rows(mdb);
 468       if (*num_ids > 0) {
 469          id = (uint32_t *)malloc(*num_ids * sizeof(uint32_t));
 470          while ((row = sql_fetch_row(mdb)) != NULL) {
 471             id[i++] = str_to_uint64(row[0]);
 472          }
 473          *ids = id;
 474       }
 475       sql_free_result(mdb);
 476       stat = 1;
 477    } else {
 478       Mmsg(mdb->errmsg, _("Pool id select failed: ERR=%s\n"), sql_strerror(mdb));
 479       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 480       stat = 0;
 481    }
 482    db_unlock(mdb);
 483    return stat;
 484 }
 485
 486 /*
 487  * This function returns a list of all the Client record ids.
 488  *  The caller must free ids if non-NULL.
 489  *
 490  *  Returns 0: on failure
 491  *          1: on success
 492  */
 493 int db_get_client_ids(JCR *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
 494 {
 495    SQL_ROW row;
 496    int stat = 0;
 497    int i = 0;
 498    uint32_t *id;
 499
 500    db_lock(mdb);
 501    *ids = NULL;
 502    Mmsg(mdb->cmd, "SELECT ClientId FROM Client");
 503    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 504       *num_ids = sql_num_rows(mdb);
 505       if (*num_ids > 0) {
 506          id = (uint32_t *)malloc(*num_ids * sizeof(uint32_t));
 507          while ((row = sql_fetch_row(mdb)) != NULL) {
 508             id[i++] = str_to_uint64(row[0]);
 509          }
 510          *ids = id;
 511       }
 512       sql_free_result(mdb);
 513       stat = 1;
 514    } else {
 515       Mmsg(mdb->errmsg, _("Client id select failed: ERR=%s\n"), sql_strerror(mdb));
 516       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 517       stat = 0;
 518    }
 519    db_unlock(mdb);
 520    return stat;
 521 }
 522
 523
 524
 525 /* Get Pool Record
 526  * If the PoolId is non-zero, we get its record,
 527  *  otherwise, we search on the PoolName
 528  *
 529  * Returns: 0 on failure
 530  *          id on success
 531  */
 532 int db_get_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pdbr)
 533 {
 534    SQL_ROW row;
 535    int stat = 0;
 536    char ed1[50];
 537
 538    db_lock(mdb);
 539    if (pdbr->PoolId != 0) {               /* find by id */
 540       Mmsg(mdb->cmd,
 541 "SELECT PoolId,Name,NumVols,MaxVols,UseOnce,UseCatalog,AcceptAnyVolume,"
 542 "AutoPrune,Recycle,VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,"
 543 "MaxVolBytes,PoolType,LabelType,LabelFormat FROM Pool WHERE Pool.PoolId=%s",
 544          edit_int64(pdbr->PoolId, ed1));
 545    } else {                           /* find by name */
 546       Mmsg(mdb->cmd,
 547 "SELECT PoolId,Name,NumVols,MaxVols,UseOnce,UseCatalog,AcceptAnyVolume,"
 548 "AutoPrune,Recycle,VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,"
 549 "MaxVolBytes,PoolType,LabelType,LabelFormat FROM Pool WHERE Pool.Name='%s'",
 550          pdbr->Name);
 551    }
 552
 553    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 554       mdb->num_rows = sql_num_rows(mdb);
 555       if (mdb->num_rows > 1) {
 556          char ed1[30];
 557          Mmsg1(&mdb->errmsg, _("More than one Pool!: %s\n"),
 558             edit_uint64(mdb->num_rows, ed1));
 559          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 560       } else if (mdb->num_rows == 1) {
 561          if ((row = sql_fetch_row(mdb)) == NULL) {
 562             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 563             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 564          } else {
 565             pdbr->PoolId = str_to_int64(row[0]);
 566             bstrncpy(pdbr->Name, row[1]!=NULL?row[1]:"", sizeof(pdbr->Name));
 567             pdbr->NumVols = str_to_int64(row[2]);
 568             pdbr->MaxVols = str_to_int64(row[3]);
 569             pdbr->UseOnce = str_to_int64(row[4]);
 570             pdbr->UseCatalog = str_to_int64(row[5]);
 571             pdbr->AcceptAnyVolume = str_to_int64(row[6]);
 572             pdbr->AutoPrune = str_to_int64(row[7]);
 573             pdbr->Recycle = str_to_int64(row[8]);
 574             pdbr->VolRetention = str_to_int64(row[9]);
 575             pdbr->VolUseDuration = str_to_int64(row[10]);
 576             pdbr->MaxVolJobs = str_to_int64(row[11]);
 577             pdbr->MaxVolFiles = str_to_int64(row[12]);
 578             pdbr->MaxVolBytes = str_to_uint64(row[13]);
 579             bstrncpy(pdbr->PoolType, row[14]!=NULL?row[14]:"", sizeof(pdbr->PoolType));
 580             pdbr->LabelType = str_to_int64(row[15]);
 581             bstrncpy(pdbr->LabelFormat, row[16]!=NULL?row[16]:"", sizeof(pdbr->LabelFormat));
 582             stat = pdbr->PoolId;
 583          }
 584       } else {
 585          Mmsg(mdb->errmsg, _("Pool record not found in Catalog.\n"));
 586       }
 587       sql_free_result(mdb);
 588    } else {
 589       Mmsg(mdb->errmsg, _("Pool record not found in Catalog.\n"));
 590    }
 591    db_unlock(mdb);
 592    return stat;
 593 }
 594
 595 /* Get Client Record
 596  * If the ClientId is non-zero, we get its record,
 597  *  otherwise, we search on the Client Name
 598  *
 599  * Returns: 0 on failure
 600  *          1 on success
 601  */
 602 int db_get_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cdbr)
 603 {
 604    SQL_ROW row;
 605    int stat = 0;
 606    char ed1[50];
 607
 608    db_lock(mdb);
 609    if (cdbr->ClientId != 0) {               /* find by id */
 610       Mmsg(mdb->cmd,
 611 "SELECT ClientId,Name,Uname,AutoPrune,FileRetention,JobRetention "
 612 "FROM Client WHERE Client.ClientId=%s",
 613         edit_int64(cdbr->ClientId, ed1));
 614    } else {                           /* find by name */
 615       Mmsg(mdb->cmd,
 616 "SELECT ClientId,Name,Uname,AutoPrune,FileRetention,JobRetention "
 617 "FROM Client WHERE Client.Name='%s'", cdbr->Name);
 618    }
 619
 620    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 621       mdb->num_rows = sql_num_rows(mdb);
 622       if (mdb->num_rows > 1) {
 623          Mmsg1(&mdb->errmsg, _("More than one Client!: %s\n"),
 624             edit_uint64(mdb->num_rows, ed1));
 625          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 626       } else if (mdb->num_rows == 1) {
 627          if ((row = sql_fetch_row(mdb)) == NULL) {
 628             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 629             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 630          } else {
 631             cdbr->ClientId = str_to_int64(row[0]);
 632             bstrncpy(cdbr->Name, row[1]!=NULL?row[1]:"", sizeof(cdbr->Name));
 633             bstrncpy(cdbr->Uname, row[2]!=NULL?row[1]:"", sizeof(cdbr->Uname));
 634             cdbr->AutoPrune = str_to_int64(row[3]);
 635             cdbr->FileRetention = str_to_int64(row[4]);
 636             cdbr->JobRetention = str_to_int64(row[5]);
 637             stat = 1;
 638          }
 639       } else {
 640          Mmsg(mdb->errmsg, _("Client record not found in Catalog.\n"));
 641       }
 642       sql_free_result(mdb);
 643    } else {
 644       Mmsg(mdb->errmsg, _("Client record not found in Catalog.\n"));
 645    }
 646    db_unlock(mdb);
 647    return stat;
 648 }
 649
 650 /*
 651  * Get Counter Record
 652  *
 653  * Returns: 0 on failure
 654  *          1 on success
 655  */
 656 int db_get_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 657 {
 658    SQL_ROW row;
 659
 660    db_lock(mdb);
 661    Mmsg(mdb->cmd, "SELECT MinValue,MaxValue,CurrentValue,WrapCounter "
 662       "FROM Counters WHERE Counter='%s'", cr->Counter);
 663
 664    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 665       mdb->num_rows = sql_num_rows(mdb);
 666
 667       /* If more than one, report error, but return first row */
 668       if (mdb->num_rows > 1) {
 669          Mmsg1(&mdb->errmsg, _("More than one Counter!: %d\n"), (int)(mdb->num_rows));
 670          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 671       }
 672       if (mdb->num_rows >= 1) {
 673          if ((row = sql_fetch_row(mdb)) == NULL) {
 674             Mmsg1(&mdb->errmsg, _("error fetching Counter row: %s\n"), sql_strerror(mdb));
 675             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 676             sql_free_result(mdb);
 677             db_unlock(mdb);
 678             return 0;
 679          }
 680          cr->MinValue = atoi(row[0]);
 681          cr->MaxValue = atoi(row[1]);
 682          cr->CurrentValue = atoi(row[2]);
 683          if (row[3]) {
 684             bstrncpy(cr->WrapCounter, row[3], sizeof(cr->WrapCounter));
 685          } else {
 686             cr->WrapCounter[0] = 0;
 687          }
 688          sql_free_result(mdb);
 689          db_unlock(mdb);
 690          return 1;
 691       }
 692       sql_free_result(mdb);
 693    } else {
 694       Mmsg(mdb->errmsg, _("Counter record: %s not found in Catalog.\n"), cr->Counter);
 695    }
 696    db_unlock(mdb);
 697    return 0;
 698 }
 699
 700
 701 /* Get FileSet Record
 702  * If the FileSetId is non-zero, we get its record,
 703  *  otherwise, we search on the name
 704  *
 705  * Returns: 0 on failure
 706  *          id on success
 707  */
 708 int db_get_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
 709 {
 710    SQL_ROW row;
 711    int stat = 0;
 712    char ed1[50];
 713
 714    db_lock(mdb);
 715    if (fsr->FileSetId != 0) {               /* find by id */
 716       Mmsg(mdb->cmd,
 717            "SELECT FileSetId,FileSet,MD5,CreateTime FROM FileSet "
 718            "WHERE FileSetId=%s",
 719            edit_int64(fsr->FileSetId, ed1));
 720    } else {                           /* find by name */
 721       Mmsg(mdb->cmd,
 722            "SELECT FileSetId,FileSet,CreateTime,MD5 FROM FileSet "
 723            "WHERE FileSet='%s' ORDER BY CreateTime DESC LIMIT 1", fsr->FileSet);
 724    }
 725
 726    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 727       mdb->num_rows = sql_num_rows(mdb);
 728       if (mdb->num_rows > 1) {
 729          char ed1[30];
 730          Mmsg1(&mdb->errmsg, _("Error got %s FileSets but expected only one!\n"),
 731             edit_uint64(mdb->num_rows, ed1));
 732          sql_data_seek(mdb, mdb->num_rows-1);
 733       }
 734       if ((row = sql_fetch_row(mdb)) == NULL) {
 735          Mmsg1(&mdb->errmsg, _("FileSet record \"%s\" not found.\n"), fsr->FileSet);
 736       } else {
 737          fsr->FileSetId = str_to_int64(row[0]);
 738          bstrncpy(fsr->FileSet, row[1]!=NULL?row[1]:"", sizeof(fsr->FileSet));
 739          bstrncpy(fsr->MD5, row[2]!=NULL?row[2]:"", sizeof(fsr->MD5));
 740          bstrncpy(fsr->cCreateTime, row[3]!=NULL?row[3]:"", sizeof(fsr->cCreateTime));
 741          stat = fsr->FileSetId;
 742       }
 743       sql_free_result(mdb);
 744    } else {
 745       Mmsg(mdb->errmsg, _("FileSet record not found in Catalog.\n"));
 746    }
 747    db_unlock(mdb);
 748    return stat;
 749 }
 750
 751
 752 /*
 753  * Get the number of Media records
 754  *
 755  * Returns: -1 on failure
 756  *          number on success
 757  */
 758 int db_get_num_media_records(JCR *jcr, B_DB *mdb)
 759 {
 760    int stat = 0;
 761
 762    db_lock(mdb);
 763    Mmsg(mdb->cmd, "SELECT count(*) from Media");
 764    stat = get_sql_record_max(jcr, mdb);
 765    db_unlock(mdb);
 766    return stat;
 767 }
 768
 769
 770 /*
 771  * This function returns a list of all the Media record ids for
 772  *     the current Pool.
 773  *  The caller must free ids if non-NULL.
 774  *
 775  *  Returns 0: on failure
 776  *          1: on success
 777  */
 778 int db_get_media_ids(JCR *jcr, B_DB *mdb, uint32_t PoolId, int *num_ids, uint32_t *ids[])
 779 {
 780    SQL_ROW row;
 781    int stat = 0;
 782    int i = 0;
 783    uint32_t *id;
 784    char ed1[50];
 785
 786    db_lock(mdb);
 787    *ids = NULL;
 788    Mmsg(mdb->cmd, "SELECT MediaId FROM Media WHERE PoolId=%s",
 789        edit_int64(PoolId, ed1));
 790    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 791       *num_ids = sql_num_rows(mdb);
 792       if (*num_ids > 0) {
 793          id = (uint32_t *)malloc(*num_ids * sizeof(uint32_t));
 794          while ((row = sql_fetch_row(mdb)) != NULL) {
 795             id[i++] = (uint32_t)atoi(row[0]);
 796          }
 797          *ids = id;
 798       }
 799       sql_free_result(mdb);
 800       stat = 1;
 801    } else {
 802       Mmsg(mdb->errmsg, _("Media id select failed: ERR=%s\n"), sql_strerror(mdb));
 803       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 804       stat = 0;
 805    }
 806    db_unlock(mdb);
 807    return stat;
 808 }
 809
 810
 811 /* Get Media Record
 812  *
 813  * Returns: 0 on failure
 814  *          id on success
 815  */
 816 int db_get_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 817 {
 818    SQL_ROW row;
 819    int stat = 0;
 820    char ed1[50];
 821
 822    db_lock(mdb);
 823    if (mr->MediaId == 0 && mr->VolumeName[0] == 0) {
 824       Mmsg(mdb->cmd, "SELECT count(*) from Media");
 825       mr->MediaId = get_sql_record_max(jcr, mdb);
 826       db_unlock(mdb);
 827       return 1;
 828    }
 829    if (mr->MediaId != 0) {               /* find by id */
 830       Mmsg(mdb->cmd, "SELECT MediaId,VolumeName,VolJobs,VolFiles,VolBlocks,"
 831          "VolBytes,VolMounts,VolErrors,VolWrites,MaxVolBytes,VolCapacityBytes,"
 832          "MediaType,VolStatus,PoolId,VolRetention,VolUseDuration,MaxVolJobs,"
 833          "MaxVolFiles,Recycle,Slot,FirstWritten,LastWritten,InChanger,"
 834          "EndFile,EndBlock,VolParts,LabelType "
 835          "FROM Media WHERE MediaId=%s",
 836          edit_int64(mr->MediaId, ed1));
 837    } else {                           /* find by name */
 838       Mmsg(mdb->cmd, "SELECT MediaId,VolumeName,VolJobs,VolFiles,VolBlocks,"
 839          "VolBytes,VolMounts,VolErrors,VolWrites,MaxVolBytes,VolCapacityBytes,"
 840          "MediaType,VolStatus,PoolId,VolRetention,VolUseDuration,MaxVolJobs,"
 841          "MaxVolFiles,Recycle,Slot,FirstWritten,LastWritten,InChanger,"
 842          "EndFile,EndBlock,VolParts,LabelType "
 843          "FROM Media WHERE VolumeName='%s'", mr->VolumeName);
 844    }
 845
 846    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 847       mdb->num_rows = sql_num_rows(mdb);
 848       if (mdb->num_rows > 1) {
 849          char ed1[30];
 850          Mmsg1(&mdb->errmsg, _("More than one Volume!: %s\n"),
 851             edit_uint64(mdb->num_rows, ed1));
 852          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 853       } else if (mdb->num_rows == 1) {
 854          if ((row = sql_fetch_row(mdb)) == NULL) {
 855             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 856             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 857          } else {
 858             /* return values */
 859             mr->MediaId = str_to_int64(row[0]);
 860             bstrncpy(mr->VolumeName, row[1]!=NULL?row[1]:"", sizeof(mr->VolumeName));
 861             mr->VolJobs = str_to_int64(row[2]);
 862             mr->VolFiles = str_to_int64(row[3]);
 863             mr->VolBlocks = str_to_int64(row[4]);
 864             mr->VolBytes = str_to_uint64(row[5]);
 865             mr->VolMounts = str_to_int64(row[6]);
 866             mr->VolErrors = str_to_int64(row[7]);
 867             mr->VolWrites = str_to_int64(row[8]);
 868             mr->MaxVolBytes = str_to_uint64(row[9]);
 869             mr->VolCapacityBytes = str_to_uint64(row[10]);
 870             bstrncpy(mr->MediaType, row[11]!=NULL?row[11]:"", sizeof(mr->MediaType));
 871             bstrncpy(mr->VolStatus, row[12]!=NULL?row[12]:"", sizeof(mr->VolStatus));
 872             mr->PoolId = str_to_int64(row[13]);
 873             mr->VolRetention = str_to_uint64(row[14]);
 874             mr->VolUseDuration = str_to_uint64(row[15]);
 875             mr->MaxVolJobs = str_to_int64(row[16]);
 876             mr->MaxVolFiles = str_to_int64(row[17]);
 877             mr->Recycle = str_to_int64(row[18]);
 878             mr->Slot = str_to_int64(row[19]);
 879             bstrncpy(mr->cFirstWritten, row[20]!=NULL?row[20]:"", sizeof(mr->cFirstWritten));
 880             mr->FirstWritten = (time_t)str_to_utime(mr->cFirstWritten);
 881             bstrncpy(mr->cLastWritten, row[21]!=NULL?row[21]:"", sizeof(mr->cLastWritten));
 882             mr->LastWritten = (time_t)str_to_utime(mr->cLastWritten);
 883             mr->InChanger = str_to_uint64(row[22]);
 884             mr->EndFile = str_to_uint64(row[23]);
 885             mr->EndBlock = str_to_uint64(row[24]);
 886             mr->VolParts = str_to_int64(row[25]);
 887             mr->LabelType = str_to_int64(row[26]);
 888             stat = mr->MediaId;
 889          }
 890       } else {
 891          if (mr->MediaId != 0) {
 892             Mmsg1(&mdb->errmsg, _("Media record MediaId=%u not found.\n"), mr->MediaId);
 893          } else {
 894             Mmsg1(&mdb->errmsg, _("Media record for Volume \"%s\" not found.\n"),
 895                   mr->VolumeName);
 896          }
 897       }
 898       sql_free_result(mdb);
 899    } else {
 900       if (mr->MediaId != 0) {
 901          Mmsg(mdb->errmsg, _("Media record for MediaId=%u not found in Catalog.\n"),
 902             mr->MediaId);
 903        } else {
 904          Mmsg(mdb->errmsg, _("Media record for Vol=%s not found in Catalog.\n"),
 905             mr->VolumeName);
 906    }   }
 907    db_unlock(mdb);
 908    return stat;
 909 }
 910
 911
 912 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL*/