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 = 10;
  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    ASSERT(ar->FileType != FT_BASE);
 914
 915    Dmsg1(dbglevel, "Fname=%s\n", ar->fname);
 916    Dmsg0(dbglevel, "put_file_into_catalog\n");
 917
 918    /* Open the dedicated connexion */
 919    if (!jcr->batch_started) {
 920
 921       if (!db_open_batch_connexion(jcr, mdb)) {
 922          return false;
 923       }
 924       if (!sql_batch_start(jcr, jcr->db_batch)) {
 925          Mmsg1(&mdb->errmsg,
 926               "Can't start batch mode: ERR=%s", db_strerror(jcr->db_batch));
 927          Jmsg1(jcr, M_FATAL, 0, "%s", mdb->errmsg);
 928          return false;
 929       }
 930       jcr->batch_started = true;
 931    }
 932    B_DB *bdb = jcr->db_batch;
 933
 934    split_path_and_file(jcr, bdb, ar->fname);
 935
 936
 937 /*
 938  * if (bdb->changes > 100000) {
 939  *    db_write_batch_file_records(jcr);
 940  *    bdb->changes = 0;
 941  *     sql_batch_start(jcr, bdb);
 942  * }
 943  */
 944
 945    return sql_batch_insert(jcr, bdb, ar);
 946 }
 947
 948 #else  /* ! HAVE_BATCH_FILE_INSERT */
 949
 950 /*
 951  * Create File record in B_DB
 952  *
 953  *  In order to reduce database size, we store the File attributes,
 954  *  the FileName, and the Path separately.  In principle, there
 955  *  is a single FileName record and a single Path record, no matter
 956  *  how many times it occurs.  This is this subroutine, we separate
 957  *  the file and the path and create three database records.
 958  */
 959 bool db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 960 {
 961    db_lock(mdb);
 962    Dmsg1(dbglevel, "Fname=%s\n", ar->fname);
 963    Dmsg0(dbglevel, "put_file_into_catalog\n");
 964
 965    split_path_and_file(jcr, mdb, ar->fname);
 966
 967    if (!db_create_filename_record(jcr, mdb, ar)) {
 968       goto bail_out;
 969    }
 970    Dmsg1(dbglevel, "db_create_filename_record: %s\n", mdb->esc_name);
 971
 972
 973    if (!db_create_path_record(jcr, mdb, ar)) {
 974       goto bail_out;
 975    }
 976    Dmsg1(dbglevel, "db_create_path_record: %s\n", mdb->esc_name);
 977
 978    /* Now create master File record */
 979    if (!db_create_file_record(jcr, mdb, ar)) {
 980       goto bail_out;
 981    }
 982    Dmsg0(dbglevel, "db_create_file_record OK\n");
 983
 984    Dmsg3(dbglevel, "CreateAttributes Path=%s File=%s FilenameId=%d\n", mdb->path, mdb->fname, ar->FilenameId);
 985    db_unlock(mdb);
 986    return true;
 987
 988 bail_out:
 989    db_unlock(mdb);
 990    return false;
 991 }
 992
 993
 994 /*
 995  * This is the master File entry containing the attributes.
 996  *  The filename and path records have already been created.
 997  */
 998 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 999 {
1000    int stat;
1001    static const char *no_digest = "0";
1002    const char *digest;
1003
1004    ASSERT(ar->JobId);
1005    ASSERT(ar->PathId);
1006    ASSERT(ar->FilenameId);
1007
1008    if (ar->Digest == NULL || ar->Digest[0] == 0) {
1009       digest = no_digest;
1010    } else {
1011       digest = ar->Digest;
1012    }
1013
1014    /* Must create it */
1015    Mmsg(mdb->cmd,
1016         "INSERT INTO File (FileIndex,JobId,PathId,FilenameId,"
1017         "LStat,MD5) VALUES (%u,%u,%u,%u,'%s','%s')",
1018         ar->FileIndex, ar->JobId, ar->PathId, ar->FilenameId,
1019         ar->attr, digest);
1020
1021    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
1022       Mmsg2(&mdb->errmsg, _("Create db File record %s failed. ERR=%s"),
1023          mdb->cmd, sql_strerror(mdb));
1024       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
1025       ar->FileId = 0;
1026       stat = 0;
1027    } else {
1028       ar->FileId = sql_insert_id(mdb, NT_("File"));
1029       stat = 1;
1030    }
1031    return stat;
1032 }
1033
1034 /* Create a Unique record for the filename -- no duplicates */
1035 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1036 {
1037    SQL_ROW row;
1038
1039    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
1040    db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);
1041
1042    Mmsg(mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
1043
1044    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
1045       mdb->num_rows = sql_num_rows(mdb);
1046       if (mdb->num_rows > 1) {
1047          char ed1[30];
1048          Mmsg2(&mdb->errmsg, _("More than one Filename! %s for file: %s\n"),
1049             edit_uint64(mdb->num_rows, ed1), mdb->fname);
1050          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
1051       }
1052       if (mdb->num_rows >= 1) {
1053          if ((row = sql_fetch_row(mdb)) == NULL) {
1054             Mmsg2(&mdb->errmsg, _("Error fetching row for file=%s: ERR=%s\n"),
1055                 mdb->fname, sql_strerror(mdb));
1056             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
1057             ar->FilenameId = 0;
1058          } else {
1059             ar->FilenameId = str_to_int64(row[0]);
1060          }
1061          sql_free_result(mdb);
1062          return ar->FilenameId > 0;
1063       }
1064       sql_free_result(mdb);
1065    }
1066
1067    Mmsg(mdb->cmd, "INSERT INTO Filename (Name) VALUES ('%s')", mdb->esc_name);
1068
1069    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
1070       Mmsg2(&mdb->errmsg, _("Create db Filename record %s failed. ERR=%s\n"),
1071             mdb->cmd, sql_strerror(mdb));
1072       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
1073       ar->FilenameId = 0;
1074    } else {
1075       ar->FilenameId = sql_insert_id(mdb, NT_("Filename"));
1076    }
1077    return ar->FilenameId > 0;
1078 }
1079
1080 bool db_write_batch_file_records(JCR *jcr)
1081 {
1082    return true;
1083 }
1084
1085 #endif /* ! HAVE_BATCH_FILE_INSERT */
1086
1087
1088 /* List of SQL commands to create temp table and indicies  */
1089 const char *create_temp_basefile[4] = {
1090    /* MySQL */
1091    "CREATE TEMPORARY TABLE basefile%lld ("
1092    "Path BLOB NOT NULL,"
1093    "Name BLOB NOT NULL)",
1094
1095    /* Postgresql */
1096    "CREATE TEMPORARY TABLE basefile%lld ("
1097 //   "CREATE TABLE basefile%lld ("
1098    "Path TEXT,"
1099    "Name TEXT)",
1100
1101    /* SQLite */
1102    "CREATE TEMPORARY TABLE basefile%lld ("
1103    "Path TEXT,"
1104    "Name TEXT)",
1105
1106    /* SQLite3 */
1107    "CREATE TEMPORARY TABLE basefile%lld ("
1108    "Path TEXT,"
1109    "Name TEXT)"
1110 };
1111
1112 /*
1113  * Create file attributes record, or base file attributes record
1114  */
1115 bool db_create_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1116 {
1117    bool ret;
1118
1119    /*
1120     * Make sure we have an acceptable attributes record.
1121     */
1122    if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES ||
1123          ar->Stream == STREAM_UNIX_ATTRIBUTES_EX)) {
1124       Jmsg(jcr, M_FATAL, 0, _("Attempt to put non-attributes into catalog. Stream=%d\n"));
1125       return false;
1126    }
1127
1128    if (ar->FileType != FT_BASE) {
1129       ret = db_create_file_attributes_record(jcr, mdb, ar);
1130
1131    } else if (jcr->HasBase) {
1132       ret = db_create_base_file_attributes_record(jcr, mdb, ar);
1133
1134    } else {
1135       Jmsg0(jcr, M_FATAL, 0, _("Can't Copy/Migrate job using BaseJob"));
1136       ret = true;               /* in copy/migration what do we do ? */
1137    }
1138
1139    return ret;
1140 }
1141
1142 /*
1143  * Create Base File record in B_DB
1144  *
1145  */
1146 bool db_create_base_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1147 {
1148    bool ret;
1149    Dmsg1(dbglevel, "create_base_file Fname=%s\n", ar->fname);
1150    Dmsg0(dbglevel, "put_base_file_into_catalog\n");
1151
1152    db_lock(mdb);
1153    split_path_and_file(jcr, mdb, ar->fname);
1154
1155    mdb->esc_name = check_pool_memory_size(mdb->esc_name, mdb->fnl*2+1);
1156    db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);
1157
1158    mdb->esc_path = check_pool_memory_size(mdb->esc_path, mdb->pnl*2+1);
1159    db_escape_string(jcr, mdb, mdb->esc_path, mdb->path, mdb->pnl);
1160
1161    Mmsg(mdb->cmd, "INSERT INTO basefile%lld (Path, Name) VALUES ('%s','%s')",
1162         (uint64_t)jcr->JobId, mdb->esc_path, mdb->esc_name);
1163
1164    ret = INSERT_DB(jcr, mdb, mdb->cmd);
1165    db_unlock(mdb);
1166
1167    return ret;
1168 }
1169
1170 /*
1171  * Cleanup the base file temporary tables
1172  */
1173 static void db_cleanup_base_file(JCR *jcr, B_DB *mdb)
1174 {
1175    POOL_MEM buf(PM_MESSAGE);
1176    Mmsg(buf, "DROP TABLE new_basefile%lld", (uint64_t) jcr->JobId);
1177    db_sql_query(mdb, buf.c_str(), NULL, NULL);
1178
1179    Mmsg(buf, "DROP TABLE basefile%lld", (uint64_t) jcr->JobId);
1180    db_sql_query(mdb, buf.c_str(), NULL, NULL);
1181 }
1182
1183 /*
1184  * Put all base file seen in the backup to the BaseFile table
1185  * and cleanup temporary tables
1186  */
1187 bool db_commit_base_file_attributes_record(JCR *jcr, B_DB *mdb)
1188 {
1189    bool ret;
1190    char ed1[50];
1191
1192    db_lock(mdb);
1193
1194    Mmsg(mdb->cmd,
1195   "INSERT INTO BaseFiles (BaseJobId, JobId, FileId, FileIndex) ( "
1196    "SELECT B.JobId AS BaseJobId, %s AS JobId, "
1197           "B.FileId, B.FileIndex "
1198      "FROM basefile%s AS A, new_basefile%s AS B "
1199     "WHERE A.Path = B.Path "
1200       "AND A.Name = B.Name "
1201     "ORDER BY B.FileId)",
1202         edit_uint64(jcr->JobId, ed1), ed1, ed1);
1203    ret = QUERY_DB(jcr, mdb, mdb->cmd);
1204    jcr->nb_base_files_used = sql_affected_rows(mdb);
1205    db_cleanup_base_file(jcr, mdb);
1206
1207    db_unlock(mdb);
1208    return ret;
1209 }
1210
1211 /*
1212  * Find the last "accurate" backup state with Base jobs
1213  * 1) Get all files with jobid in list (F subquery)
1214  * 2) Take only the last version of each file (Temp subquery) => accurate list is ok
1215  * 3) Put the result in a temporary table for the end of job
1216  *
1217  */
1218 bool db_create_base_file_list(JCR *jcr, B_DB *mdb, char *jobids)
1219 {
1220    bool ret=false;
1221
1222    db_lock(mdb);
1223
1224    if (!*jobids) {
1225       Mmsg(mdb->errmsg, _("ERR=JobIds are empty\n"));
1226       goto bail_out;
1227    }
1228
1229    Mmsg(mdb->cmd, create_temp_basefile[db_type], (uint64_t) jcr->JobId);
1230    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
1231       goto bail_out;
1232    }
1233
1234    Mmsg(mdb->cmd,
1235 "CREATE TEMPORARY TABLE new_basefile%lld AS ( "
1236 //"CREATE TABLE new_basefile%lld AS ( "
1237   "SELECT Path.Path AS Path, Filename.Name AS Name, File.FileIndex AS FileIndex,"
1238          "File.JobId AS JobId, File.LStat AS LStat, File.FileId AS FileId, "
1239          "File.MD5 AS MD5 "
1240   "FROM ( "
1241    "SELECT max(FileId) as FileId, PathId, FilenameId "
1242      "FROM (SELECT FileId, PathId, FilenameId FROM File WHERE JobId IN (%s)) AS F "
1243     "GROUP BY PathId, FilenameId "
1244    ") AS Temp "
1245   "JOIN Filename ON (Filename.FilenameId = Temp.FilenameId) "
1246   "JOIN Path ON (Path.PathId = Temp.PathId) "
1247   "JOIN File ON (File.FileId = Temp.FileId) "
1248  "WHERE File.FileIndex > 0)",
1249         (uint64_t)jcr->JobId, jobids);
1250    ret = QUERY_DB(jcr, mdb, mdb->cmd);
1251 bail_out:
1252    db_unlock(mdb);
1253    return ret;
1254 }
1255
1256 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL || HAVE_DBI */