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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Bacula Catalog Database Create record interface routines
  30  *
  31  *    Kern Sibbald, March 2000
  32  *
  33  *    Version $Id$
  34  */
  35
  36 /* The following is necessary so that we do not include
  37  * the dummy external definition of DB.
  38  */
  39 #define __SQL_C                       /* indicate that this is sql.c */
  40
  41 #include "bacula.h"
  42 #include "cats.h"
  43
  44 static const int dbglevel = 500;
  45
  46 #if    HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL || HAVE_DBI
  47
  48 /* -----------------------------------------------------------------------
  49  *
  50  *   Generic Routines (or almost generic)
  51  *
  52  * -----------------------------------------------------------------------
  53  */
  54
  55 /* Forward referenced subroutines */
  56 #ifndef HAVE_BATCH_FILE_INSERT
  57 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
  58 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
  59 #endif /* HAVE_BATCH_FILE_INSERT */
  60
  61
  62 /* Create a new record for the Job
  63  * Returns: false on failure
  64  *          true  on success
  65  */
  66 bool
  67 db_create_job_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
  68 {
  69    char dt[MAX_TIME_LENGTH];
  70    time_t stime;
  71    struct tm tm;
  72    bool ok;
  73    utime_t JobTDate;
  74    char ed1[30],ed2[30];
  75
  76    db_lock(mdb);
  77
  78    stime = jr->SchedTime;
  79    ASSERT(stime != 0);
  80
  81    (void)localtime_r(&stime, &tm);
  82    strftime(dt, sizeof(dt), "%Y-%m-%d %H:%M:%S", &tm);
  83    JobTDate = (utime_t)stime;
  84
  85    /* Must create it */
  86    Mmsg(mdb->cmd,
  87 "INSERT INTO Job (Job,Name,Type,Level,JobStatus,SchedTime,JobTDate,ClientId) "
  88 "VALUES ('%s','%s','%c','%c','%c','%s',%s,%s)",
  89            jr->Job, jr->Name, (char)(jr->JobType), (char)(jr->JobLevel),
  90            (char)(jr->JobStatus), dt, edit_uint64(JobTDate, ed1),
  91            edit_int64(jr->ClientId, ed2));
  92
  93    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
  94       Mmsg2(&mdb->errmsg, _("Create DB Job record %s failed. ERR=%s\n"),
  95             mdb->cmd, sql_strerror(mdb));
  96       jr->JobId = 0;
  97       ok = false;
  98    } else {
  99       jr->JobId = sql_insert_id(mdb, NT_("Job"));
 100       ok = true;
 101    }
 102    db_unlock(mdb);
 103    return ok;
 104 }
 105
 106
 107 /* Create a JobMedia record for medium used this job
 108  * Returns: false on failure
 109  *          true  on success
 110  */
 111 bool
 112 db_create_jobmedia_record(JCR *jcr, B_DB *mdb, JOBMEDIA_DBR *jm)
 113 {
 114    bool ok = true;
 115    int count;
 116    char ed1[50], ed2[50];
 117
 118    db_lock(mdb);
 119
 120    /* Now get count for VolIndex */
 121    Mmsg(mdb->cmd, "SELECT count(*) from JobMedia WHERE JobId=%s",
 122         edit_int64(jm->JobId, ed1));
 123    count = get_sql_record_max(jcr, mdb);
 124    if (count < 0) {
 125       count = 0;
 126    }
 127    count++;
 128
 129    /* Note, jm->Strip is not used and is not likely to be used
 130     * in the near future, so I have removed it from the insert
 131     * to save space in the DB. KES June 2006.
 132     */
 133    Mmsg(mdb->cmd,
 134         "INSERT INTO JobMedia (JobId,MediaId,FirstIndex,LastIndex,"
 135         "StartFile,EndFile,StartBlock,EndBlock,VolIndex,Copy) "
 136         "VALUES (%s,%s,%u,%u,%u,%u,%u,%u,%u,%u)",
 137         edit_int64(jm->JobId, ed1),
 138         edit_int64(jm->MediaId, ed2),
 139         jm->FirstIndex, jm->LastIndex,
 140         jm->StartFile, jm->EndFile, jm->StartBlock, jm->EndBlock,count,
 141         jm->Copy);
 142
 143    Dmsg0(300, mdb->cmd);
 144    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 145       Mmsg2(&mdb->errmsg, _("Create JobMedia record %s failed: ERR=%s\n"), mdb->cmd,
 146          sql_strerror(mdb));
 147       ok = false;
 148    } else {
 149       /* Worked, now update the Media record with the EndFile and EndBlock */
 150       Mmsg(mdb->cmd,
 151            "UPDATE Media SET EndFile=%u, EndBlock=%u WHERE MediaId=%u",
 152            jm->EndFile, jm->EndBlock, jm->MediaId);
 153       if (!UPDATE_DB(jcr, mdb, mdb->cmd)) {
 154          Mmsg2(&mdb->errmsg, _("Update Media record %s failed: ERR=%s\n"), mdb->cmd,
 155               sql_strerror(mdb));
 156          ok = false;
 157       }
 158    }
 159    db_unlock(mdb);
 160    Dmsg0(300, "Return from JobMedia\n");
 161    return ok;
 162 }
 163
 164 /* Create Unique Pool record
 165  * Returns: false on failure
 166  *          true  on success
 167  */
 168 bool
 169 db_create_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
 170 {
 171    bool stat;
 172    char ed1[30], ed2[30], ed3[50], ed4[50], ed5[50];
 173
 174    Dmsg0(200, "In create pool\n");
 175    db_lock(mdb);
 176    Mmsg(mdb->cmd, "SELECT PoolId,Name FROM Pool WHERE Name='%s'", pr->Name);
 177    Dmsg1(200, "selectpool: %s\n", mdb->cmd);
 178
 179    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 180       mdb->num_rows = sql_num_rows(mdb);
 181       if (mdb->num_rows > 0) {
 182          Mmsg1(&mdb->errmsg, _("pool record %s already exists\n"), pr->Name);
 183          sql_free_result(mdb);
 184          db_unlock(mdb);
 185          return false;
 186       }
 187       sql_free_result(mdb);
 188    }
 189
 190    /* Must create it */
 191    Mmsg(mdb->cmd,
 192 "INSERT INTO Pool (Name,NumVols,MaxVols,UseOnce,UseCatalog,"
 193 "AcceptAnyVolume,AutoPrune,Recycle,VolRetention,VolUseDuration,"
 194 "MaxVolJobs,MaxVolFiles,MaxVolBytes,PoolType,LabelType,LabelFormat,"
 195 "RecyclePoolId,ScratchPoolId) "
 196 "VALUES ('%s',%u,%u,%d,%d,%d,%d,%d,%s,%s,%u,%u,%s,'%s',%d,'%s',%s,%s)",
 197                   pr->Name,
 198                   pr->NumVols, pr->MaxVols,
 199                   pr->UseOnce, pr->UseCatalog,
 200                   pr->AcceptAnyVolume,
 201                   pr->AutoPrune, pr->Recycle,
 202                   edit_uint64(pr->VolRetention, ed1),
 203                   edit_uint64(pr->VolUseDuration, ed2),
 204                   pr->MaxVolJobs, pr->MaxVolFiles,
 205                   edit_uint64(pr->MaxVolBytes, ed3),
 206                   pr->PoolType, pr->LabelType, pr->LabelFormat,
 207                   edit_int64(pr->RecyclePoolId,ed4),
 208                   edit_int64(pr->ScratchPoolId,ed5));
 209    Dmsg1(200, "Create Pool: %s\n", mdb->cmd);
 210    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 211       Mmsg2(&mdb->errmsg, _("Create db Pool record %s failed: ERR=%s\n"),
 212             mdb->cmd, sql_strerror(mdb));
 213       pr->PoolId = 0;
 214       stat = false;
 215    } else {
 216       pr->PoolId = sql_insert_id(mdb, NT_("Pool"));
 217       stat = true;
 218    }
 219    db_unlock(mdb);
 220    return stat;
 221 }
 222
 223 /*
 224  * Create Unique Device record
 225  * Returns: false on failure
 226  *          true  on success
 227  */
 228 bool
 229 db_create_device_record(JCR *jcr, B_DB *mdb, DEVICE_DBR *dr)
 230 {
 231    bool ok;
 232    char ed1[30], ed2[30];
 233
 234    Dmsg0(200, "In create Device\n");
 235    db_lock(mdb);
 236    Mmsg(mdb->cmd, "SELECT DeviceId,Name FROM Device WHERE Name='%s'", dr->Name);
 237    Dmsg1(200, "selectdevice: %s\n", mdb->cmd);
 238
 239    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 240       mdb->num_rows = sql_num_rows(mdb);
 241       if (mdb->num_rows > 0) {
 242          Mmsg1(&mdb->errmsg, _("Device record %s already exists\n"), dr->Name);
 243          sql_free_result(mdb);
 244          db_unlock(mdb);
 245          return false;
 246       }
 247       sql_free_result(mdb);
 248    }
 249
 250    /* Must create it */
 251    Mmsg(mdb->cmd,
 252 "INSERT INTO Device (Name,MediaTypeId,StorageId) VALUES ('%s',%s,%s)",
 253                   dr->Name,
 254                   edit_uint64(dr->MediaTypeId, ed1),
 255                   edit_int64(dr->StorageId, ed2));
 256    Dmsg1(200, "Create Device: %s\n", mdb->cmd);
 257    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 258       Mmsg2(&mdb->errmsg, _("Create db Device record %s failed: ERR=%s\n"),
 259             mdb->cmd, sql_strerror(mdb));
 260       dr->DeviceId = 0;
 261       ok = false;
 262    } else {
 263       dr->DeviceId = sql_insert_id(mdb, NT_("Device"));
 264       ok = true;
 265    }
 266    db_unlock(mdb);
 267    return ok;
 268 }
 269
 270
 271
 272 /*
 273  * Create a Unique record for Storage -- no duplicates
 274  * Returns: false on failure
 275  *          true  on success with id in sr->StorageId
 276  */
 277 bool db_create_storage_record(JCR *jcr, B_DB *mdb, STORAGE_DBR *sr)
 278 {
 279    SQL_ROW row;
 280    bool ok;
 281
 282    db_lock(mdb);
 283    Mmsg(mdb->cmd, "SELECT StorageId,AutoChanger FROM Storage WHERE Name='%s'", sr->Name);
 284
 285    sr->StorageId = 0;
 286    sr->created = false;
 287    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 288       mdb->num_rows = sql_num_rows(mdb);
 289       /* If more than one, report error, but return first row */
 290       if (mdb->num_rows > 1) {
 291          Mmsg1(&mdb->errmsg, _("More than one Storage record!: %d\n"), (int)(mdb->num_rows));
 292          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 293       }
 294       if (mdb->num_rows >= 1) {
 295          if ((row = sql_fetch_row(mdb)) == NULL) {
 296             Mmsg1(&mdb->errmsg, _("error fetching Storage row: %s\n"), sql_strerror(mdb));
 297             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 298             sql_free_result(mdb);
 299             db_unlock(mdb);
 300             return false;
 301          }
 302          sr->StorageId = str_to_int64(row[0]);
 303          sr->AutoChanger = atoi(row[1]);   /* bool */
 304          sql_free_result(mdb);
 305          db_unlock(mdb);
 306          return true;
 307       }
 308       sql_free_result(mdb);
 309    }
 310
 311    /* Must create it */
 312    Mmsg(mdb->cmd, "INSERT INTO Storage (Name,AutoChanger)"
 313         " VALUES ('%s',%d)", sr->Name, sr->AutoChanger);
 314
 315    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 316       Mmsg2(&mdb->errmsg, _("Create DB Storage record %s failed. ERR=%s\n"),
 317             mdb->cmd, sql_strerror(mdb));
 318       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 319       ok = false;
 320    } else {
 321       sr->StorageId = sql_insert_id(mdb, NT_("Storage"));
 322       sr->created = true;
 323       ok = true;
 324    }
 325    db_unlock(mdb);
 326    return ok;
 327 }
 328
 329
 330 /*
 331  * Create Unique MediaType record
 332  * Returns: false on failure
 333  *          true  on success
 334  */
 335 bool
 336 db_create_mediatype_record(JCR *jcr, B_DB *mdb, MEDIATYPE_DBR *mr)
 337 {
 338    bool stat;
 339
 340    Dmsg0(200, "In create mediatype\n");
 341    db_lock(mdb);
 342    Mmsg(mdb->cmd, "SELECT MediaTypeId,MediaType FROM MediaType WHERE MediaType='%s'", mr->MediaType);
 343    Dmsg1(200, "selectmediatype: %s\n", mdb->cmd);
 344
 345    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 346       mdb->num_rows = sql_num_rows(mdb);
 347       if (mdb->num_rows > 0) {
 348          Mmsg1(&mdb->errmsg, _("mediatype record %s already exists\n"), mr->MediaType);
 349          sql_free_result(mdb);
 350          db_unlock(mdb);
 351          return false;
 352       }
 353       sql_free_result(mdb);
 354    }
 355
 356    /* Must create it */
 357    Mmsg(mdb->cmd,
 358 "INSERT INTO MediaType (MediaType,ReadOnly) "
 359 "VALUES ('%s',%d)",
 360                   mr->MediaType,
 361                   mr->ReadOnly);
 362    Dmsg1(200, "Create mediatype: %s\n", mdb->cmd);
 363    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 364       Mmsg2(&mdb->errmsg, _("Create db mediatype record %s failed: ERR=%s\n"),
 365             mdb->cmd, sql_strerror(mdb));
 366       mr->MediaTypeId = 0;
 367       stat = false;
 368    } else {
 369       mr->MediaTypeId = sql_insert_id(mdb, NT_("MediaType"));
 370       stat = true;
 371    }
 372    db_unlock(mdb);
 373    return stat;
 374 }
 375
 376
 377 /*
 378  * Create Media record. VolumeName and non-zero Slot must be unique
 379  *
 380  * Returns: 0 on failure
 381  *          1 on success
 382  */
 383 int
 384 db_create_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 385 {
 386    int stat;
 387    char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50], ed7[50], ed8[50];
 388    char ed9[50], ed10[50], ed11[50], ed12[50];
 389    struct tm tm;
 390
 391    db_lock(mdb);
 392    Mmsg(mdb->cmd, "SELECT MediaId FROM Media WHERE VolumeName='%s'",
 393            mr->VolumeName);
 394    Dmsg1(500, "selectpool: %s\n", mdb->cmd);
 395
 396    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 397       mdb->num_rows = sql_num_rows(mdb);
 398       if (mdb->num_rows > 0) {
 399          Mmsg1(&mdb->errmsg, _("Volume \"%s\" already exists.\n"), mr->VolumeName);
 400          sql_free_result(mdb);
 401          db_unlock(mdb);
 402          return 0;
 403       }
 404       sql_free_result(mdb);
 405    }
 406
 407    /* Must create it */
 408    Mmsg(mdb->cmd,
 409 "INSERT INTO Media (VolumeName,MediaType,MediaTypeId,PoolId,MaxVolBytes,"
 410 "VolCapacityBytes,Recycle,VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,"
 411 "VolStatus,Slot,VolBytes,InChanger,VolReadTime,VolWriteTime,VolParts,"
 412 "EndFile,EndBlock,LabelType,StorageId,DeviceId,LocationId,"
 413 "ScratchPoolId,RecyclePoolId,Enabled)"
 414 "VALUES ('%s','%s',0,%u,%s,%s,%d,%s,%s,%u,%u,'%s',%d,%s,%d,%s,%s,%d,0,0,%d,%s,"
 415 "%s,%s,%s,%s,%d)",
 416           mr->VolumeName,
 417           mr->MediaType, mr->PoolId,
 418           edit_uint64(mr->MaxVolBytes,ed1),
 419           edit_uint64(mr->VolCapacityBytes, ed2),
 420           mr->Recycle,
 421           edit_uint64(mr->VolRetention, ed3),
 422           edit_uint64(mr->VolUseDuration, ed4),
 423           mr->MaxVolJobs,
 424           mr->MaxVolFiles,
 425           mr->VolStatus,
 426           mr->Slot,
 427           edit_uint64(mr->VolBytes, ed5),
 428           mr->InChanger,
 429           edit_int64(mr->VolReadTime, ed6),
 430           edit_int64(mr->VolWriteTime, ed7),
 431           mr->VolParts,
 432           mr->LabelType,
 433           edit_int64(mr->StorageId, ed8),
 434           edit_int64(mr->DeviceId, ed9),
 435           edit_int64(mr->LocationId, ed10),
 436           edit_int64(mr->ScratchPoolId, ed11),
 437           edit_int64(mr->RecyclePoolId, ed12),
 438           mr->Enabled
 439           );
 440
 441
 442    Dmsg1(500, "Create Volume: %s\n", mdb->cmd);
 443    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 444       Mmsg2(&mdb->errmsg, _("Create DB Media record %s failed. ERR=%s\n"),
 445             mdb->cmd, sql_strerror(mdb));
 446       stat = 0;
 447    } else {
 448       mr->MediaId = sql_insert_id(mdb, NT_("Media"));
 449       stat = 1;
 450       if (mr->set_label_date) {
 451          char dt[MAX_TIME_LENGTH];
 452          if (mr->LabelDate == 0) {
 453             mr->LabelDate = time(NULL);
 454          }
 455          (void)localtime_r(&mr->LabelDate, &tm);
 456          strftime(dt, sizeof(dt), "%Y-%m-%d %H:%M:%S", &tm);
 457          Mmsg(mdb->cmd, "UPDATE Media SET LabelDate='%s' "
 458               "WHERE MediaId=%d", dt, mr->MediaId);
 459          stat = UPDATE_DB(jcr, mdb, mdb->cmd);
 460       }
 461       /*
 462        * Make sure that if InChanger is non-zero any other identical slot
 463        *   has InChanger zero.
 464        */
 465       db_make_inchanger_unique(jcr, mdb, mr);
 466    }
 467
 468    db_unlock(mdb);
 469    return stat;
 470 }
 471
 472 /*
 473  * Create a Unique record for the client -- no duplicates
 474  * Returns: 0 on failure
 475  *          1 on success with id in cr->ClientId
 476  */
 477 int db_create_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
 478 {
 479    SQL_ROW row;
 480    int stat;
 481    char ed1[50], ed2[50];
 482
 483    db_lock(mdb);
 484    Mmsg(mdb->cmd, "SELECT ClientId,Uname FROM Client WHERE Name='%s'", cr->Name);
 485
 486    cr->ClientId = 0;
 487    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 488       mdb->num_rows = sql_num_rows(mdb);
 489       /* If more than one, report error, but return first row */
 490       if (mdb->num_rows > 1) {
 491          Mmsg1(&mdb->errmsg, _("More than one Client!: %d\n"), (int)(mdb->num_rows));
 492          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 493       }
 494       if (mdb->num_rows >= 1) {
 495          if ((row = sql_fetch_row(mdb)) == NULL) {
 496             Mmsg1(&mdb->errmsg, _("error fetching Client row: %s\n"), sql_strerror(mdb));
 497             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 498             sql_free_result(mdb);
 499             db_unlock(mdb);
 500             return 0;
 501          }
 502          cr->ClientId = str_to_int64(row[0]);
 503          if (row[1]) {
 504             bstrncpy(cr->Uname, row[1], sizeof(cr->Uname));
 505          } else {
 506             cr->Uname[0] = 0;         /* no name */
 507          }
 508          sql_free_result(mdb);
 509          db_unlock(mdb);
 510          return 1;
 511       }
 512       sql_free_result(mdb);
 513    }
 514
 515    /* Must create it */
 516    Mmsg(mdb->cmd, "INSERT INTO Client (Name,Uname,AutoPrune,"
 517 "FileRetention,JobRetention) VALUES "
 518 "('%s','%s',%d,%s,%s)", cr->Name, cr->Uname, cr->AutoPrune,
 519       edit_uint64(cr->FileRetention, ed1),
 520       edit_uint64(cr->JobRetention, ed2));
 521
 522    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 523       Mmsg2(&mdb->errmsg, _("Create DB Client record %s failed. ERR=%s\n"),
 524             mdb->cmd, sql_strerror(mdb));
 525       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 526       cr->ClientId = 0;
 527       stat = 0;
 528    } else {
 529       cr->ClientId = sql_insert_id(mdb, NT_("Client"));
 530       stat = 1;
 531    }
 532    db_unlock(mdb);
 533    return stat;
 534 }
 535
 536
 537 /* Create a Unique record for the Path -- no duplicates */
 538 int db_create_path_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 539 {
 540    SQL_ROW row;
 541    int stat;
 542
 543    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->pnl+2);
 544    db_escape_string(jcr, mdb, mdb->esc_name, mdb->path, mdb->pnl);
 545
 546    if (mdb->cached_path_id != 0 && mdb->cached_path_len == mdb->pnl &&
 547        strcmp(mdb->cached_path, mdb->path) == 0) {
 548       ar->PathId = mdb->cached_path_id;
 549       return 1;
 550    }
 551
 552    Mmsg(mdb->cmd, "SELECT PathId FROM Path WHERE Path='%s'", mdb->esc_name);
 553
 554    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 555       mdb->num_rows = sql_num_rows(mdb);
 556       if (mdb->num_rows > 1) {
 557          char ed1[30];
 558          Mmsg2(&mdb->errmsg, _("More than one Path!: %s for path: %s\n"),
 559             edit_uint64(mdb->num_rows, ed1), mdb->path);
 560          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
 561       }
 562       /* Even if there are multiple paths, take the first one */
 563       if (mdb->num_rows >= 1) {
 564          if ((row = sql_fetch_row(mdb)) == NULL) {
 565             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 566             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 567             sql_free_result(mdb);
 568             ar->PathId = 0;
 569             ASSERT(ar->PathId);
 570             return 0;
 571          }
 572          ar->PathId = str_to_int64(row[0]);
 573          sql_free_result(mdb);
 574          /* Cache path */
 575          if (ar->PathId != mdb->cached_path_id) {
 576             mdb->cached_path_id = ar->PathId;
 577             mdb->cached_path_len = mdb->pnl;
 578             pm_strcpy(mdb->cached_path, mdb->path);
 579          }
 580          ASSERT(ar->PathId);
 581          return 1;
 582       }
 583       sql_free_result(mdb);
 584    }
 585
 586    Mmsg(mdb->cmd, "INSERT INTO Path (Path) VALUES ('%s')", mdb->esc_name);
 587
 588    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 589       Mmsg2(&mdb->errmsg, _("Create db Path record %s failed. ERR=%s\n"),
 590          mdb->cmd, sql_strerror(mdb));
 591       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
 592       ar->PathId = 0;
 593       stat = 0;
 594    } else {
 595       ar->PathId = sql_insert_id(mdb, NT_("Path"));
 596       stat = 1;
 597    }
 598
 599    /* Cache path */
 600    if (stat && ar->PathId != mdb->cached_path_id) {
 601       mdb->cached_path_id = ar->PathId;
 602       mdb->cached_path_len = mdb->pnl;
 603       pm_strcpy(mdb->cached_path, mdb->path);
 604    }
 605    return stat;
 606 }
 607
 608 /*
 609  * Create a Unique record for the counter -- no duplicates
 610  * Returns: 0 on failure
 611  *          1 on success with counter filled in
 612  */
 613 int db_create_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 614 {
 615    COUNTER_DBR mcr;
 616    int stat;
 617
 618    db_lock(mdb);
 619    memset(&mcr, 0, sizeof(mcr));
 620    bstrncpy(mcr.Counter, cr->Counter, sizeof(mcr.Counter));
 621    if (db_get_counter_record(jcr, mdb, &mcr)) {
 622       memcpy(cr, &mcr, sizeof(COUNTER_DBR));
 623       db_unlock(mdb);
 624       return 1;
 625    }
 626
 627    /* Must create it */
 628    Mmsg(mdb->cmd, "INSERT INTO Counters (Counter,MinValue,MaxValue,CurrentValue,"
 629       "WrapCounter) VALUES ('%s','%d','%d','%d','%s')",
 630       cr->Counter, cr->MinValue, cr->MaxValue, cr->CurrentValue,
 631       cr->WrapCounter);
 632
 633    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 634       Mmsg2(&mdb->errmsg, _("Create DB Counters record %s failed. ERR=%s\n"),
 635             mdb->cmd, sql_strerror(mdb));
 636       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 637       stat = 0;
 638    } else {
 639       stat = 1;
 640    }
 641    db_unlock(mdb);
 642    return stat;
 643 }
 644
 645
 646 /*
 647  * Create a FileSet record. This record is unique in the
 648  *  name and the MD5 signature of the include/exclude sets.
 649  *  Returns: 0 on failure
 650  *           1 on success with FileSetId in record
 651  */
 652 bool db_create_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
 653 {
 654    SQL_ROW row;
 655    bool stat;
 656    struct tm tm;
 657
 658    db_lock(mdb);
 659    fsr->created = false;
 660    Mmsg(mdb->cmd, "SELECT FileSetId,CreateTime FROM FileSet WHERE "
 661 "FileSet='%s' AND MD5='%s'", fsr->FileSet, fsr->MD5);
 662
 663    fsr->FileSetId = 0;
 664    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 665       mdb->num_rows = sql_num_rows(mdb);
 666       if (mdb->num_rows > 1) {
 667          Mmsg1(&mdb->errmsg, _("More than one FileSet!: %d\n"), (int)(mdb->num_rows));
 668          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 669       }
 670       if (mdb->num_rows >= 1) {
 671          if ((row = sql_fetch_row(mdb)) == NULL) {
 672             Mmsg1(&mdb->errmsg, _("error fetching FileSet row: ERR=%s\n"), sql_strerror(mdb));
 673             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 674             sql_free_result(mdb);
 675             db_unlock(mdb);
 676             return false;
 677          }
 678          fsr->FileSetId = str_to_int64(row[0]);
 679          if (row[1] == NULL) {
 680             fsr->cCreateTime[0] = 0;
 681          } else {
 682             bstrncpy(fsr->cCreateTime, row[1], sizeof(fsr->cCreateTime));
 683          }
 684          sql_free_result(mdb);
 685          db_unlock(mdb);
 686          return true;
 687       }
 688       sql_free_result(mdb);
 689    }
 690
 691    if (fsr->CreateTime == 0 && fsr->cCreateTime[0] == 0) {
 692       fsr->CreateTime = time(NULL);
 693    }
 694    (void)localtime_r(&fsr->CreateTime, &tm);
 695    strftime(fsr->cCreateTime, sizeof(fsr->cCreateTime), "%Y-%m-%d %H:%M:%S", &tm);
 696
 697    /* Must create it */
 698       Mmsg(mdb->cmd, "INSERT INTO FileSet (FileSet,MD5,CreateTime) "
 699 "VALUES ('%s','%s','%s')", fsr->FileSet, fsr->MD5, fsr->cCreateTime);
 700
 701    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 702       Mmsg2(&mdb->errmsg, _("Create DB FileSet record %s failed. ERR=%s\n"),
 703             mdb->cmd, sql_strerror(mdb));
 704       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 705       fsr->FileSetId = 0;
 706       stat = false;
 707    } else {
 708       fsr->FileSetId = sql_insert_id(mdb, NT_("FileSet"));
 709       fsr->created = true;
 710       stat = true;
 711    }
 712
 713    db_unlock(mdb);
 714    return stat;
 715 }
 716
 717
 718 /*
 719  *  struct stat
 720  *  {
 721  *      dev_t         st_dev;       * device *
 722  *      ino_t         st_ino;       * inode *
 723  *      mode_t        st_mode;      * protection *
 724  *      nlink_t       st_nlink;     * number of hard links *
 725  *      uid_t         st_uid;       * user ID of owner *
 726  *      gid_t         st_gid;       * group ID of owner *
 727  *      dev_t         st_rdev;      * device type (if inode device) *
 728  *      off_t         st_size;      * total size, in bytes *
 729  *      unsigned long st_blksize;   * blocksize for filesystem I/O *
 730  *      unsigned long st_blocks;    * number of blocks allocated *
 731  *      time_t        st_atime;     * time of last access *
 732  *      time_t        st_mtime;     * time of last modification *
 733  *      time_t        st_ctime;     * time of last inode change *
 734  *  };
 735  */
 736
 737 #ifdef HAVE_BATCH_FILE_INSERT
 738
 739 /*  All sql_batch_* functions are used to do bulk batch insert in File/Filename/Path
 740  *  tables. This code can be activated by adding "#define HAVE_BATCH_FILE_INSERT 1"
 741  *  in baconfig.h
 742  *
 743  *  To sum up :
 744  *   - bulk load a temp table
 745  *   - insert missing filenames into filename with a single query (lock filenames
 746  *   - table before that to avoid possible duplicate inserts with concurrent update)
 747  *   - insert missing paths into path with another single query
 748  *   - then insert the join between the temp, filename and path tables into file.
 749  */
 750
 751 /*
 752  * Returns 1 if OK
 753  *         0 if failed
 754  */
 755 bool my_batch_start(JCR *jcr, B_DB *mdb)
 756 {
 757    bool ok;
 758
 759    db_lock(mdb);
 760    ok =  db_sql_query(mdb,
 761              "CREATE TEMPORARY TABLE batch ("
 762                 "FileIndex integer,"
 763                 "JobId integer,"
 764                 "Path blob,"
 765                 "Name blob,"
 766                 "LStat tinyblob,"
 767                 "MD5 tinyblob)",NULL, NULL);
 768    db_unlock(mdb);
 769    return ok;
 770 }
 771
 772 /*
 773  * Returns 1 if OK
 774  *         0 if failed
 775  */
 776 bool my_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 777 {
 778    size_t len;
 779    const char *digest;
 780    char ed1[50];
 781
 782    mdb->esc_name = check_pool_memory_size(mdb->esc_name, mdb->fnl*2+1);
 783    db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);
 784
 785    mdb->esc_path = check_pool_memory_size(mdb->esc_path, mdb->pnl*2+1);
 786    db_escape_string(jcr, mdb, mdb->esc_path, mdb->path, mdb->pnl);
 787
 788    if (ar->Digest == NULL || ar->Digest[0] == 0) {
 789       digest = "0";
 790    } else {
 791       digest = ar->Digest;
 792    }
 793
 794    len = Mmsg(mdb->cmd, "INSERT INTO batch VALUES (%u,%s,'%s','%s','%s','%s')",
 795               ar->FileIndex, edit_int64(ar->JobId,ed1), mdb->esc_path,
 796               mdb->esc_name, ar->attr, digest);
 797
 798    return INSERT_DB(jcr, mdb, mdb->cmd);
 799 }
 800
 801 /* set error to something to abort operation */
 802 /*
 803  * Returns 1 if OK
 804  *         0 if failed
 805  */
 806 bool my_batch_end(JCR *jcr, B_DB *mdb, const char *error)
 807 {
 808
 809    Dmsg0(50, "sql_batch_end started\n");
 810
 811    if (mdb) {
 812 #ifdef HAVE_DBI
 813       mdb->status = (dbi_error_flag)0;
 814 #else
 815       mdb->status = 0;
 816 #endif
 817    }
 818    return true;
 819 }
 820
 821 /*
 822  * Returns 1 if OK
 823  *         0 if failed
 824  */
 825 bool db_write_batch_file_records(JCR *jcr)
 826 {
 827    int JobStatus = jcr->JobStatus;
 828
 829    if (!jcr->batch_started) {         /* no files to backup ? */
 830       Dmsg0(50,"db_create_file_record : no files\n");
 831       return true;
 832    }
 833    if (job_canceled(jcr)) {
 834       return false;
 835    }
 836
 837    Dmsg1(50,"db_create_file_record changes=%u\n",jcr->db_batch->changes);
 838
 839    jcr->JobStatus = JS_AttrInserting;
 840    if (!sql_batch_end(jcr, jcr->db_batch, NULL)) {
 841       Jmsg1(jcr, M_FATAL, 0, "Batch end %s\n", jcr->db_batch->errmsg);
 842       return false;
 843    }
 844    if (job_canceled(jcr)) {
 845       return false;
 846    }
 847
 848
 849    /* we have to lock tables */
 850    if (!db_sql_query(jcr->db_batch, sql_batch_lock_path_query, NULL, NULL)) {
 851       Jmsg1(jcr, M_FATAL, 0, "Lock Path table %s\n", jcr->db_batch->errmsg);
 852       return false;
 853    }
 854
 855    if (!db_sql_query(jcr->db_batch, sql_batch_fill_path_query, NULL, NULL)) {
 856       Jmsg1(jcr, M_FATAL, 0, "Fill Path table %s\n",jcr->db_batch->errmsg);
 857       db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query, NULL, NULL);
 858       return false;
 859    }
 860
 861    if (!db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query,NULL,NULL)) {
 862       Jmsg1(jcr, M_FATAL, 0, "Unlock Path table %s\n", jcr->db_batch->errmsg);
 863       return false;
 864    }
 865
 866    /* we have to lock tables */
 867    if (!db_sql_query(jcr->db_batch,sql_batch_lock_filename_query,NULL, NULL)) {
 868       Jmsg1(jcr, M_FATAL, 0, "Lock Filename table %s\n", jcr->db_batch->errmsg);
 869       return false;
 870    }
 871
 872    if (!db_sql_query(jcr->db_batch,sql_batch_fill_filename_query, NULL,NULL)) {
 873       Jmsg1(jcr,M_FATAL,0,"Fill Filename table %s\n",jcr->db_batch->errmsg);
 874       db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query, NULL, NULL);
 875       return false;
 876    }
 877
 878    if (!db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query,NULL,NULL)) {
 879       Jmsg1(jcr, M_FATAL, 0, "Unlock Filename table %s\n", jcr->db_batch->errmsg);
 880       return false;
 881    }
 882
 883    if (!db_sql_query(jcr->db_batch,
 884        "INSERT INTO File (FileIndex, JobId, PathId, FilenameId, LStat, MD5)"
 885          "SELECT batch.FileIndex, batch.JobId, Path.PathId, "
 886                 "Filename.FilenameId,batch.LStat, batch.MD5 "
 887            "FROM batch "
 888            "JOIN Path ON (batch.Path = Path.Path) "
 889            "JOIN Filename ON (batch.Name = Filename.Name)",
 890                      NULL,NULL))
 891    {
 892       Jmsg1(jcr, M_FATAL, 0, "Fill File table %s\n", jcr->db_batch->errmsg);
 893       return false;
 894    }
 895
 896    db_sql_query(jcr->db_batch, "DROP TABLE batch", NULL,NULL);
 897
 898    jcr->JobStatus = JobStatus;         /* reset entry status */
 899    return true;
 900 }
 901
 902 /*
 903  * Create File record in B_DB
 904  *
 905  *  In order to reduce database size, we store the File attributes,
 906  *  the FileName, and the Path separately.  In principle, there
 907  *  is a single FileName record and a single Path record, no matter
 908  *  how many times it occurs.  This is this subroutine, we separate
 909  *  the file and the path and fill temporary tables with this three records.
 910  */
 911 bool db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 912 {
 913    Dmsg1(dbglevel, "Fname=%s\n", ar->fname);
 914    Dmsg0(dbglevel, "put_file_into_catalog\n");
 915
 916    /* Open the dedicated connexion */
 917    if (!jcr->batch_started) {
 918
 919       if (!db_open_batch_connexion(jcr, mdb)) {
 920          return false;
 921       }
 922       if (!sql_batch_start(jcr, jcr->db_batch)) {
 923          Mmsg1(&mdb->errmsg,
 924               "Can't start batch mode: ERR=%s", db_strerror(jcr->db_batch));
 925          Jmsg1(jcr, M_FATAL, 0, "%s", mdb->errmsg);
 926          return false;
 927       }
 928       jcr->batch_started = true;
 929    }
 930    B_DB *bdb = jcr->db_batch;
 931
 932    /*
 933     * Make sure we have an acceptable attributes record.
 934     */
 935    if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES ||
 936          ar->Stream == STREAM_UNIX_ATTRIBUTES_EX)) {
 937       Mmsg1(&mdb->errmsg, _("Attempt to put non-attributes into catalog. Stream=%d\n"),
 938          ar->Stream);
 939       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
 940       return false;
 941    }
 942
 943    split_path_and_file(jcr, bdb, ar->fname);
 944
 945
 946 /*
 947  * if (bdb->changes > 100000) {
 948  *    db_write_batch_file_records(jcr);
 949  *    bdb->changes = 0;
 950  *     sql_batch_start(jcr, bdb);
 951  * }
 952  */
 953
 954    return sql_batch_insert(jcr, bdb, ar);
 955 }
 956
 957 #else  /* ! HAVE_BATCH_FILE_INSERT */
 958
 959 /*
 960  * Create File record in B_DB
 961  *
 962  *  In order to reduce database size, we store the File attributes,
 963  *  the FileName, and the Path separately.  In principle, there
 964  *  is a single FileName record and a single Path record, no matter
 965  *  how many times it occurs.  This is this subroutine, we separate
 966  *  the file and the path and create three database records.
 967  */
 968 bool db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 969 {
 970    db_lock(mdb);
 971    Dmsg1(dbglevel, "Fname=%s\n", ar->fname);
 972    Dmsg0(dbglevel, "put_file_into_catalog\n");
 973    /*
 974     * Make sure we have an acceptable attributes record.
 975     */
 976    if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES ||
 977          ar->Stream == STREAM_UNIX_ATTRIBUTES_EX)) {
 978       Mmsg1(&mdb->errmsg, _("Attempt to put non-attributes into catalog. Stream=%d\n"),
 979          ar->Stream);
 980       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 981       goto bail_out;
 982    }
 983
 984
 985    split_path_and_file(jcr, mdb, ar->fname);
 986
 987    if (!db_create_filename_record(jcr, mdb, ar)) {
 988       goto bail_out;
 989    }
 990    Dmsg1(dbglevel, "db_create_filename_record: %s\n", mdb->esc_name);
 991
 992
 993    if (!db_create_path_record(jcr, mdb, ar)) {
 994       goto bail_out;
 995    }
 996    Dmsg1(dbglevel, "db_create_path_record: %s\n", mdb->esc_name);
 997
 998    /* Now create master File record */
 999    if (!db_create_file_record(jcr, mdb, ar)) {
1000       goto bail_out;
1001    }
1002    Dmsg0(dbglevel, "db_create_file_record OK\n");
1003
1004    Dmsg3(dbglevel, "CreateAttributes Path=%s File=%s FilenameId=%d\n", mdb->path, mdb->fname, ar->FilenameId);
1005    db_unlock(mdb);
1006    return true;
1007
1008 bail_out:
1009    db_unlock(mdb);
1010    return false;
1011 }
1012
1013
1014 /*
1015  * This is the master File entry containing the attributes.
1016  *  The filename and path records have already been created.
1017  */
1018 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1019 {
1020    int stat;
1021    static const char *no_digest = "0";
1022    const char *digest;
1023
1024    ASSERT(ar->JobId);
1025    ASSERT(ar->PathId);
1026    ASSERT(ar->FilenameId);
1027
1028    if (ar->Digest == NULL || ar->Digest[0] == 0) {
1029       digest = no_digest;
1030    } else {
1031       digest = ar->Digest;
1032    }
1033
1034    /* Must create it */
1035    Mmsg(mdb->cmd,
1036         "INSERT INTO File (FileIndex,JobId,PathId,FilenameId,"
1037         "LStat,MD5) VALUES (%u,%u,%u,%u,'%s','%s')",
1038         ar->FileIndex, ar->JobId, ar->PathId, ar->FilenameId,
1039         ar->attr, digest);
1040
1041    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
1042       Mmsg2(&mdb->errmsg, _("Create db File record %s failed. ERR=%s"),
1043          mdb->cmd, sql_strerror(mdb));
1044       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
1045       ar->FileId = 0;
1046       stat = 0;
1047    } else {
1048       ar->FileId = sql_insert_id(mdb, NT_("File"));
1049       stat = 1;
1050    }
1051    return stat;
1052 }
1053
1054 /* Create a Unique record for the filename -- no duplicates */
1055 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1056 {
1057    SQL_ROW row;
1058
1059    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
1060    db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);
1061
1062    Mmsg(mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
1063
1064    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
1065       mdb->num_rows = sql_num_rows(mdb);
1066       if (mdb->num_rows > 1) {
1067          char ed1[30];
1068          Mmsg2(&mdb->errmsg, _("More than one Filename! %s for file: %s\n"),
1069             edit_uint64(mdb->num_rows, ed1), mdb->fname);
1070          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
1071       }
1072       if (mdb->num_rows >= 1) {
1073          if ((row = sql_fetch_row(mdb)) == NULL) {
1074             Mmsg2(&mdb->errmsg, _("Error fetching row for file=%s: ERR=%s\n"),
1075                 mdb->fname, sql_strerror(mdb));
1076             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
1077             ar->FilenameId = 0;
1078          } else {
1079             ar->FilenameId = str_to_int64(row[0]);
1080          }
1081          sql_free_result(mdb);
1082          return ar->FilenameId > 0;
1083       }
1084       sql_free_result(mdb);
1085    }
1086
1087    Mmsg(mdb->cmd, "INSERT INTO Filename (Name) VALUES ('%s')", mdb->esc_name);
1088
1089    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
1090       Mmsg2(&mdb->errmsg, _("Create db Filename record %s failed. ERR=%s\n"),
1091             mdb->cmd, sql_strerror(mdb));
1092       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
1093       ar->FilenameId = 0;
1094    } else {
1095       ar->FilenameId = sql_insert_id(mdb, NT_("Filename"));
1096    }
1097    return ar->FilenameId > 0;
1098 }
1099
1100 bool db_write_batch_file_records(JCR *jcr)
1101 {
1102    return true;
1103 }
1104
1105 #endif /* ! HAVE_BATCH_FILE_INSERT */
1106
1107 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL || HAVE_DBI */