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

   1 /*
   2  * Bacula Catalog Database Create record interface routines
   3  *
   4  *    Kern Sibbald, March 2000
   5  *
   6  *    Version $Id$
   7  */
   8
   9 /*
  10    Copyright (C) 2000-2003 Kern Sibbald and John Walker
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25    MA 02111-1307, USA.
  26
  27  */
  28
  29 /* The following is necessary so that we do not include
  30  * the dummy external definition of DB.
  31  */
  32 #define __SQL_C                       /* indicate that this is sql.c */
  33
  34 #include "bacula.h"
  35 #include "cats.h"
  36
  37 #if    HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL
  38
  39 /* -----------------------------------------------------------------------
  40  *
  41  *   Generic Routines (or almost generic)
  42  *
  43  * -----------------------------------------------------------------------
  44  */
  45
  46 /* Forward referenced subroutines */
  47 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
  48 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
  49 static int db_create_path_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
  50
  51
  52 /* Imported subroutines */
  53 extern void print_dashes(B_DB *mdb);
  54 extern void print_result(B_DB *mdb);
  55 extern int QueryDB(char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
  56 extern int InsertDB(char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
  57 extern void split_path_and_filename(JCR *jcr, B_DB *mdb, char *fname);
  58
  59
  60 /* Create a new record for the Job
  61  * Returns: 0 on failure
  62  *          1 on success
  63  */
  64 int
  65 db_create_job_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
  66 {
  67    char dt[MAX_TIME_LENGTH];
  68    time_t stime;
  69    struct tm tm;
  70    int stat;
  71    utime_t JobTDate;
  72    char ed1[30];
  73
  74    db_lock(mdb);
  75
  76    stime = jr->SchedTime;
  77    ASSERT(stime != 0);
  78
  79    localtime_r(&stime, &tm);
  80    strftime(dt, sizeof(dt), "%Y-%m-%d %T", &tm);
  81    JobTDate = (utime_t)stime;
  82
  83    /* Must create it */
  84    Mmsg(&mdb->cmd,
  85 "INSERT INTO Job (Job,Name,Type,Level,JobStatus,SchedTime,JobTDate) VALUES \
  86 ('%s','%s','%c','%c','%c','%s',%s)",
  87            jr->Job, jr->Name, (char)(jr->Type), (char)(jr->Level),
  88            (char)(jr->JobStatus), dt, edit_uint64(JobTDate, ed1));
  89
  90    sql_table_name(mdb, _("Job"));
  91    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
  92       Mmsg2(&mdb->errmsg, _("Create DB Job record %s failed. ERR=%s\n"),
  93             mdb->cmd, sql_strerror(mdb));
  94       jr->JobId = 0;
  95       stat = 0;
  96    } else {
  97       jr->JobId = sql_insert_id(mdb);
  98       stat = 1;
  99    }
 100    db_unlock(mdb);
 101    return stat;
 102 }
 103
 104 /* Create a JobMedia record for medium used this job
 105  * Returns: 0 on failure
 106  *          1 on success
 107  */
 108 int
 109 db_create_jobmedia_record(JCR *jcr, B_DB *mdb, JOBMEDIA_DBR *jm)
 110 {
 111    int stat;
 112    int count;
 113
 114    db_lock(mdb);
 115 #ifdef not_used_in_new_code
 116    Mmsg(&mdb->cmd, "SELECT JobId, MediaId FROM JobMedia WHERE \
 117 JobId=%d AND MediaId=%d", jm->JobId, jm->MediaId);
 118
 119    Dmsg0(30, mdb->cmd);
 120    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 121       mdb->num_rows = sql_num_rows(mdb);
 122       if (mdb->num_rows > 0) {
 123          Mmsg0(&mdb->errmsg, _("Create JobMedia failed. Record already exists.\n"));
 124          sql_free_result(mdb);
 125          db_unlock(mdb);
 126          Dmsg0(0, "Already have JobMedia record\n");
 127          return 0;
 128       }
 129       sql_free_result(mdb);
 130    }
 131 #endif
 132
 133    /* Now get count for VolIndex */
 134    Mmsg(&mdb->cmd, "SELECT count(*) from JobMedia");
 135    count = get_sql_record_max(jcr, mdb);
 136    if (count < 0) {
 137       count = 0;
 138    }
 139    count++;
 140
 141    /* Must create it */
 142    Mmsg(&mdb->cmd,
 143 "INSERT INTO JobMedia (JobId,MediaId,FirstIndex,LastIndex,\
 144 StartFile,EndFile,StartBlock,EndBlock,VolIndex) \
 145 VALUES (%u,%u,%u,%u,%u,%u,%u,%u,%u)",
 146        jm->JobId, jm->MediaId, jm->FirstIndex, jm->LastIndex,
 147        jm->StartFile, jm->EndFile, jm->StartBlock, jm->EndBlock,count);
 148
 149    Dmsg0(30, mdb->cmd);
 150    sql_table_name(mdb, _("JobMedia"));
 151    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 152       Mmsg2(&mdb->errmsg, _("Create db JobMedia record %s failed. ERR=%s\n"), mdb->cmd,
 153          sql_strerror(mdb));
 154       stat = 0;
 155    } else {
 156       stat = 1;
 157    }
 158    db_unlock(mdb);
 159    Dmsg0(30, "Return from JobMedia\n");
 160    return stat;
 161 }
 162
 163
 164
 165 /* Create Unique Pool record
 166  * Returns: 0 on failure
 167  *          1 on success
 168  */
 169 int
 170 db_create_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
 171 {
 172    int stat;
 173    char ed1[30], ed2[30], ed3[50];
 174
 175    Dmsg0(200, "In create pool\n");
 176    db_lock(mdb);
 177    Mmsg(&mdb->cmd, "SELECT PoolId,Name FROM Pool WHERE Name='%s'", pr->Name);
 178    Dmsg1(200, "selectpool: %s\n", mdb->cmd);
 179
 180    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 181
 182       mdb->num_rows = sql_num_rows(mdb);
 183
 184       if (mdb->num_rows > 0) {
 185          Mmsg1(&mdb->errmsg, _("pool record %s already exists\n"), pr->Name);
 186          sql_free_result(mdb);
 187          db_unlock(mdb);
 188          return 0;
 189       }
 190       sql_free_result(mdb);
 191    }
 192
 193    /* Must create it */
 194    Mmsg(&mdb->cmd,
 195 "INSERT INTO Pool (Name,NumVols,MaxVols,UseOnce,UseCatalog,\
 196 AcceptAnyVolume,AutoPrune,Recycle,VolRetention,VolUseDuration,\
 197 MaxVolJobs,MaxVolFiles,MaxVolBytes,PoolType,LabelFormat) \
 198 VALUES ('%s',%u,%u,%d,%d,%d,%d,%d,%s,%s,%u,%u,%s,'%s','%s')",
 199                   pr->Name,
 200                   pr->NumVols, pr->MaxVols,
 201                   pr->UseOnce, pr->UseCatalog,
 202                   pr->AcceptAnyVolume,
 203                   pr->AutoPrune, pr->Recycle,
 204                   edit_uint64(pr->VolRetention, ed1),
 205                   edit_uint64(pr->VolUseDuration, ed2),
 206                   pr->MaxVolJobs, pr->MaxVolFiles,
 207                   edit_uint64(pr->MaxVolBytes, ed3),
 208                   pr->PoolType, pr->LabelFormat);
 209    Dmsg1(200, "Create Pool: %s\n", mdb->cmd);
 210    sql_table_name(mdb, _("Pool"));
 211    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 212       Mmsg2(&mdb->errmsg, _("Create db Pool record %s failed: ERR=%s\n"),
 213             mdb->cmd, sql_strerror(mdb));
 214       pr->PoolId = 0;
 215       stat = 0;
 216    } else {
 217       pr->PoolId = sql_insert_id(mdb);
 218       stat = 1;
 219    }
 220    db_unlock(mdb);
 221
 222    return stat;
 223 }
 224
 225
 226 /*
 227  * Create Media record. VolumeName and non-zero Slot must be unique
 228  *
 229  * Returns: 0 on failure
 230  *          1 on success
 231  */
 232 int
 233 db_create_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 234 {
 235    int stat;
 236    char ed1[30], ed2[30], ed3[30], ed4[30], ed5[30];
 237    char dt[MAX_TIME_LENGTH];
 238    struct tm tm;
 239
 240    db_lock(mdb);
 241    Mmsg(&mdb->cmd, "SELECT MediaId FROM Media WHERE VolumeName='%s'",
 242            mr->VolumeName);
 243    Dmsg1(110, "selectpool: %s\n", mdb->cmd);
 244
 245    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 246       mdb->num_rows = sql_num_rows(mdb);
 247       if (mdb->num_rows > 0) {
 248          Mmsg1(&mdb->errmsg, _("Volume \"%s\" already exists.\n"), mr->VolumeName);
 249          sql_free_result(mdb);
 250          db_unlock(mdb);
 251          return 0;
 252       }
 253       sql_free_result(mdb);
 254    }
 255
 256    /* Make sure that if InChanger is non-zero any other identical slot
 257     *   has InChanger zero.
 258     */
 259    db_make_inchanger_unique(jcr, mdb, mr);
 260
 261    /* Must create it */
 262    if (mr->LabelDate) {
 263       localtime_r(&mr->LabelDate, &tm);
 264       strftime(dt, sizeof(dt), "%Y-%m-%d %T", &tm);
 265    } else {
 266       bstrncpy(dt, "0000-00-00 00:00:00", sizeof(dt));
 267    }
 268    Mmsg(&mdb->cmd,
 269 #ifdef HAVE_POSTGRESQL
 270 "INSERT INTO Media (VolumeName,MediaType,PoolId,MaxVolBytes,VolCapacityBytes,"
 271 "Recycle,VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,"
 272 "VolStatus,Slot,VolBytes,Drive,InChanger) "
 273 "VALUES ('%s','%s',%u,%s,%s,%d,%s,%s,%u,%u,'%s',%d,%s,%d,%d)",
 274                   mr->VolumeName,
 275                   mr->MediaType, mr->PoolId,
 276                   edit_uint64(mr->MaxVolBytes,ed1),
 277                   edit_uint64(mr->VolCapacityBytes, ed2),
 278                   mr->Recycle,
 279                   edit_uint64(mr->VolRetention, ed3),
 280                   edit_uint64(mr->VolUseDuration, ed4),
 281                   mr->MaxVolJobs,
 282                   mr->MaxVolFiles,
 283                   mr->VolStatus,
 284                   mr->Slot,
 285                   edit_uint64(mr->VolBytes, ed5),
 286                   mr->Drive,
 287                   mr->InChanger);
 288 #else
 289 "INSERT INTO Media (VolumeName,MediaType,PoolId,MaxVolBytes,VolCapacityBytes,"
 290 "Recycle,VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,"
 291 "VolStatus,LabelDate,Slot,VolBytes,Drive,InChanger) "
 292 "VALUES ('%s','%s',%u,%s,%s,%d,%s,%s,%u,%u,'%s','%s',%d,%s,%d,%d)",
 293                   mr->VolumeName,
 294                   mr->MediaType, mr->PoolId,
 295                   edit_uint64(mr->MaxVolBytes,ed1),
 296                   edit_uint64(mr->VolCapacityBytes, ed2),
 297                   mr->Recycle,
 298                   edit_uint64(mr->VolRetention, ed3),
 299                   edit_uint64(mr->VolUseDuration, ed4),
 300                   mr->MaxVolJobs,
 301                   mr->MaxVolFiles,
 302                   mr->VolStatus, dt,
 303                   mr->Slot,
 304                   edit_uint64(mr->VolBytes, ed5),
 305                   mr->Drive,
 306                   mr->InChanger);
 307 #endif
 308
 309    Dmsg1(500, "Create Volume: %s\n", mdb->cmd);
 310    sql_table_name(mdb, _("Media"));
 311    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 312       Mmsg2(&mdb->errmsg, _("Create DB Media record %s failed. ERR=%s\n"),
 313             mdb->cmd, sql_strerror(mdb));
 314       stat = 0;
 315    } else {
 316       mr->MediaId = sql_insert_id(mdb);
 317       stat = 1;
 318    }
 319    db_unlock(mdb);
 320    return stat;
 321 }
 322
 323
 324
 325 /*
 326  * Create a Unique record for the client -- no duplicates
 327  * Returns: 0 on failure
 328  *          1 on success with id in cr->ClientId
 329  */
 330 int db_create_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
 331 {
 332    SQL_ROW row;
 333    int stat;
 334    char ed1[30], ed2[30];
 335
 336    db_lock(mdb);
 337    Mmsg(&mdb->cmd, "SELECT ClientId,Uname FROM Client WHERE Name='%s'", cr->Name);
 338
 339    cr->ClientId = 0;
 340    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 341
 342       mdb->num_rows = sql_num_rows(mdb);
 343
 344       /* If more than one, report error, but return first row */
 345       if (mdb->num_rows > 1) {
 346          Mmsg1(&mdb->errmsg, _("More than one Client!: %d\n"), (int)(mdb->num_rows));
 347          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 348       }
 349       if (mdb->num_rows >= 1) {
 350          if ((row = sql_fetch_row(mdb)) == NULL) {
 351             Mmsg1(&mdb->errmsg, _("error fetching Client row: %s\n"), sql_strerror(mdb));
 352             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 353             sql_free_result(mdb);
 354             db_unlock(mdb);
 355             return 0;
 356          }
 357          cr->ClientId = atoi(row[0]);
 358          if (row[1]) {
 359             bstrncpy(cr->Uname, row[1], sizeof(cr->Uname));
 360          } else {
 361             cr->Uname[0] = 0;         /* no name */
 362          }
 363          sql_free_result(mdb);
 364          db_unlock(mdb);
 365          return 1;
 366       }
 367       sql_free_result(mdb);
 368    }
 369
 370    /* Must create it */
 371    Mmsg(&mdb->cmd, "INSERT INTO Client (Name, Uname, AutoPrune, \
 372 FileRetention, JobRetention) VALUES \
 373 ('%s', '%s', %d, %s, %s)", cr->Name, cr->Uname, cr->AutoPrune,
 374       edit_uint64(cr->FileRetention, ed1),
 375       edit_uint64(cr->JobRetention, ed2));
 376
 377    sql_table_name(mdb, _("Client"));
 378    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 379       Mmsg2(&mdb->errmsg, _("Create DB Client record %s failed. ERR=%s\n"),
 380             mdb->cmd, sql_strerror(mdb));
 381       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 382       cr->ClientId = 0;
 383       stat = 0;
 384    } else {
 385       cr->ClientId = sql_insert_id(mdb);
 386       stat = 1;
 387    }
 388    db_unlock(mdb);
 389    return stat;
 390 }
 391
 392
 393 /*
 394  * Create a Unique record for the counter -- no duplicates
 395  * Returns: 0 on failure
 396  *          1 on success with counter filled in
 397  */
 398 int db_create_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 399 {
 400    COUNTER_DBR mcr;
 401    int stat;
 402
 403    db_lock(mdb);
 404    memset(&mcr, 0, sizeof(mcr));
 405    bstrncpy(mcr.Counter, cr->Counter, sizeof(mcr.Counter));
 406    if (db_get_counter_record(jcr, mdb, &mcr)) {
 407       memcpy(cr, &mcr, sizeof(COUNTER_DBR));
 408       db_unlock(mdb);
 409       return 1;
 410    }
 411
 412    /* Must create it */
 413    Mmsg(&mdb->cmd, "INSERT INTO Counters (Counter,MinValue,MaxValue,CurrentValue,"
 414       "WrapCounter) VALUES ('%s','%d','%d','%d','%s')",
 415       cr->Counter, cr->MinValue, cr->MaxValue, cr->CurrentValue,
 416       cr->WrapCounter);
 417
 418    sql_table_name(mdb, _("Counters"));
 419    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 420       Mmsg2(&mdb->errmsg, _("Create DB Counters record %s failed. ERR=%s\n"),
 421             mdb->cmd, sql_strerror(mdb));
 422       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 423       stat = 0;
 424    } else {
 425       stat = 1;
 426    }
 427    db_unlock(mdb);
 428    return stat;
 429 }
 430
 431
 432 /*
 433  * Create a FileSet record. This record is unique in the
 434  *  name and the MD5 signature of the include/exclude sets.
 435  *  Returns: 0 on failure
 436  *           1 on success with FileSetId in record
 437  */
 438 int db_create_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
 439 {
 440    SQL_ROW row;
 441    int stat;
 442    struct tm tm;
 443
 444    db_lock(mdb);
 445    fsr->created = false;
 446    Mmsg(&mdb->cmd, "SELECT FileSetId,CreateTime FROM FileSet WHERE "
 447 "FileSet='%s' AND MD5='%s'", fsr->FileSet, fsr->MD5);
 448
 449    fsr->FileSetId = 0;
 450    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 451
 452       mdb->num_rows = sql_num_rows(mdb);
 453
 454       if (mdb->num_rows > 1) {
 455          Mmsg1(&mdb->errmsg, _("More than one FileSet!: %d\n"), (int)(mdb->num_rows));
 456          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 457       }
 458       if (mdb->num_rows >= 1) {
 459          if ((row = sql_fetch_row(mdb)) == NULL) {
 460             Mmsg1(&mdb->errmsg, _("error fetching FileSet row: ERR=%s\n"), sql_strerror(mdb));
 461             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 462             sql_free_result(mdb);
 463             db_unlock(mdb);
 464             return 0;
 465          }
 466          fsr->FileSetId = atoi(row[0]);
 467          if (row[1] == NULL) {
 468             fsr->cCreateTime[0] = 0;
 469          } else {
 470             bstrncpy(fsr->cCreateTime, row[1], sizeof(fsr->cCreateTime));
 471          }
 472          sql_free_result(mdb);
 473          db_unlock(mdb);
 474          return 1;
 475       }
 476       sql_free_result(mdb);
 477    }
 478
 479    if (fsr->CreateTime == 0 && fsr->cCreateTime[0] == 0) {
 480       fsr->CreateTime = time(NULL);
 481    }
 482    localtime_r(&fsr->CreateTime, &tm);
 483    strftime(fsr->cCreateTime, sizeof(fsr->cCreateTime), "%Y-%m-%d %T", &tm);
 484
 485    /* Must create it */
 486       Mmsg(&mdb->cmd, "INSERT INTO FileSet (FileSet,MD5,CreateTime) "
 487 "VALUES ('%s','%s','%s')", fsr->FileSet, fsr->MD5, fsr->cCreateTime);
 488
 489    sql_table_name(mdb, _("FileSet"));
 490    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 491       Mmsg2(&mdb->errmsg, _("Create DB FileSet record %s failed. ERR=%s\n"),
 492             mdb->cmd, sql_strerror(mdb));
 493       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 494       fsr->FileSetId = 0;
 495       stat = 0;
 496    } else {
 497       fsr->FileSetId = sql_insert_id(mdb);
 498       fsr->created = true;
 499       stat = 1;
 500    }
 501
 502    db_unlock(mdb);
 503    return stat;
 504 }
 505
 506
 507 /*
 508  *  struct stat
 509  *  {
 510  *      dev_t         st_dev;       * device *
 511  *      ino_t         st_ino;       * inode *
 512  *      mode_t        st_mode;      * protection *
 513  *      nlink_t       st_nlink;     * number of hard links *
 514  *      uid_t         st_uid;       * user ID of owner *
 515  *      gid_t         st_gid;       * group ID of owner *
 516  *      dev_t         st_rdev;      * device type (if inode device) *
 517  *      off_t         st_size;      * total size, in bytes *
 518  *      unsigned long st_blksize;   * blocksize for filesystem I/O *
 519  *      unsigned long st_blocks;    * number of blocks allocated *
 520  *      time_t        st_atime;     * time of last access *
 521  *      time_t        st_mtime;     * time of last modification *
 522  *      time_t        st_ctime;     * time of last inode change *
 523  *  };
 524  */
 525
 526
 527
 528 /*
 529  * Create File record in B_DB
 530  *
 531  *  In order to reduce database size, we store the File attributes,
 532  *  the FileName, and the Path separately.  In principle, there
 533  *  is a single FileName record and a single Path record, no matter
 534  *  how many times it occurs.  This is this subroutine, we separate
 535  *  the file and the path and create three database records.
 536  */
 537 int db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 538 {
 539
 540    Dmsg1(100, "Fname=%s\n", ar->fname);
 541    Dmsg0(50, "put_file_into_catalog\n");
 542    /*
 543     * Make sure we have an acceptable attributes record.
 544     */
 545    if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES ||
 546          ar->Stream == STREAM_UNIX_ATTRIBUTES_EX)) {
 547       Mmsg0(&mdb->errmsg, _("Attempt to put non-attributes into catalog\n"));
 548       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 549       return 0;
 550    }
 551
 552    db_lock(mdb);
 553
 554    split_path_and_filename(jcr, mdb, ar->fname);
 555
 556    if (!db_create_filename_record(jcr, mdb, ar)) {
 557       db_unlock(mdb);
 558       return 0;
 559    }
 560    Dmsg1(500, "db_create_filename_record: %s\n", mdb->esc_name);
 561
 562
 563    if (!db_create_path_record(jcr, mdb, ar)) {
 564       db_unlock(mdb);
 565       return 0;
 566    }
 567    Dmsg1(500, "db_create_path_record: %s\n", mdb->esc_name);
 568
 569    /* Now create master File record */
 570    if (!db_create_file_record(jcr, mdb, ar)) {
 571       db_unlock(mdb);
 572       return 0;
 573    }
 574    Dmsg0(500, "db_create_file_record OK\n");
 575
 576    Dmsg3(100, "CreateAttributes Path=%s File=%s FilenameId=%d\n", mdb->path, mdb->fname, ar->FilenameId);
 577    db_unlock(mdb);
 578    return 1;
 579 }
 580
 581 /*
 582  * This is the master File entry containing the attributes.
 583  *  The filename and path records have already been created.
 584  */
 585 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 586 {
 587    int stat;
 588
 589    ASSERT(ar->JobId);
 590    ASSERT(ar->PathId);
 591    ASSERT(ar->FilenameId);
 592
 593    /* Must create it */
 594    Mmsg(&mdb->cmd,
 595 "INSERT INTO File (FileIndex,JobId,PathId,FilenameId,"
 596 "LStat,MD5) VALUES (%u,%u,%u,%u,'%s','0')",
 597       ar->FileIndex, ar->JobId, ar->PathId, ar->FilenameId,
 598       ar->attr);
 599
 600    sql_table_name(mdb, _("File"));
 601    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 602       Mmsg2(&mdb->errmsg, _("Create db File record %s failed. ERR=%s"),
 603          mdb->cmd, sql_strerror(mdb));
 604       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 605       ar->FileId = 0;
 606       stat = 0;
 607    } else {
 608       ar->FileId = sql_insert_id(mdb);
 609       stat = 1;
 610    }
 611    return stat;
 612 }
 613
 614 /* Create a Unique record for the Path -- no duplicates */
 615 static int db_create_path_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 616 {
 617    SQL_ROW row;
 618    int stat;
 619
 620    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->pnl+2);
 621    db_escape_string(mdb->esc_name, mdb->path, mdb->pnl);
 622
 623    if (mdb->cached_path_id != 0 && mdb->cached_path_len == mdb->pnl &&
 624        strcmp(mdb->cached_path, mdb->path) == 0) {
 625       ar->PathId = mdb->cached_path_id;
 626       return 1;
 627    }
 628
 629    Mmsg(&mdb->cmd, "SELECT PathId FROM Path WHERE Path='%s'", mdb->esc_name);
 630
 631    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 632       mdb->num_rows = sql_num_rows(mdb);
 633       if (mdb->num_rows > 1) {
 634          char ed1[30];
 635          Mmsg2(&mdb->errmsg, _("More than one Path!: %s for path: %s\n"),
 636             edit_uint64(mdb->num_rows, ed1), mdb->path);
 637          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
 638       }
 639       /* Even if there are multiple paths, take the first one */
 640       if (mdb->num_rows >= 1) {
 641          if ((row = sql_fetch_row(mdb)) == NULL) {
 642             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
 643             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 644             sql_free_result(mdb);
 645             ar->PathId = 0;
 646             ASSERT(ar->PathId);
 647             return 0;
 648          }
 649          ar->PathId = atoi(row[0]);
 650          sql_free_result(mdb);
 651          /* Cache path */
 652          if (ar->PathId != mdb->cached_path_id) {
 653             mdb->cached_path_id = ar->PathId;
 654             mdb->cached_path_len = mdb->pnl;
 655             pm_strcpy(&mdb->cached_path, mdb->path);
 656          }
 657          ASSERT(ar->PathId);
 658          return 1;
 659       }
 660
 661       sql_free_result(mdb);
 662    }
 663
 664    Mmsg(&mdb->cmd, "INSERT INTO Path (Path) VALUES ('%s')", mdb->esc_name);
 665
 666    sql_table_name(mdb, _("Path"));
 667    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 668       Mmsg2(&mdb->errmsg, _("Create db Path record %s failed. ERR=%s\n"),
 669          mdb->cmd, sql_strerror(mdb));
 670       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 671       ar->PathId = 0;
 672       stat = 0;
 673    } else {
 674       ar->PathId = sql_insert_id(mdb);
 675       stat = 1;
 676    }
 677
 678    /* Cache path */
 679    if (stat && ar->PathId != mdb->cached_path_id) {
 680       mdb->cached_path_id = ar->PathId;
 681       mdb->cached_path_len = mdb->pnl;
 682       pm_strcpy(&mdb->cached_path, mdb->path);
 683    }
 684    return stat;
 685 }
 686
 687 /* Create a Unique record for the filename -- no duplicates */
 688 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 689 {
 690    SQL_ROW row;
 691
 692    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
 693    db_escape_string(mdb->esc_name, mdb->fname, mdb->fnl);
 694
 695    Mmsg(&mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
 696
 697    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
 698       mdb->num_rows = sql_num_rows(mdb);
 699       if (mdb->num_rows > 1) {
 700          char ed1[30];
 701          Mmsg2(&mdb->errmsg, _("More than one Filename! %s for file: %s\n"),
 702             edit_uint64(mdb->num_rows, ed1), mdb->fname);
 703          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
 704       }
 705       if (mdb->num_rows >= 1) {
 706          if ((row = sql_fetch_row(mdb)) == NULL) {
 707             Mmsg2(&mdb->errmsg, _("Error fetching row for file=%s: ERR=%s\n"),
 708                 mdb->fname, sql_strerror(mdb));
 709             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 710             ar->FilenameId = 0;
 711          } else {
 712             ar->FilenameId = atoi(row[0]);
 713          }
 714          sql_free_result(mdb);
 715          return ar->FilenameId > 0;
 716       }
 717       sql_free_result(mdb);
 718    }
 719
 720    Mmsg(&mdb->cmd, "INSERT INTO Filename (Name) VALUES ('%s')", mdb->esc_name);
 721
 722    sql_table_name(mdb, _("Filename"));
 723    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
 724       Mmsg2(&mdb->errmsg, _("Create db Filename record %s failed. ERR=%s\n"),
 725             mdb->cmd, sql_strerror(mdb));
 726       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
 727       ar->FilenameId = 0;
 728    } else {
 729       ar->FilenameId = sql_insert_id(mdb);
 730    }
 731    return ar->FilenameId > 0;
 732 }
 733
 734 #endif /* HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL */