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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2009-2009 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, which is
  11    listed 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 #define __SQL_C                       /* indicate that this is sql.c */
  30
  31 #include "bacula.h"
  32 #include "cats/cats.h"
  33 #include "lib/htable.h"
  34 #include "bvfs.h"
  35
  36 #define dbglevel 10
  37 #define dbglevel_sql 15
  38
  39 static int result_handler(void *ctx, int fields, char **row)
  40 {
  41    if (fields == 4) {
  42       Pmsg4(0, "%s\t%s\t%s\t%s\n",
  43             row[0], row[1], row[2], row[3]);
  44    } else if (fields == 5) {
  45       Pmsg5(0, "%s\t%s\t%s\t%s\t%s\n",
  46             row[0], row[1], row[2], row[3], row[4]);
  47    } else if (fields == 6) {
  48       Pmsg6(0, "%s\t%s\t%s\t%s\t%s\t%s\n",
  49             row[0], row[1], row[2], row[3], row[4], row[5]);
  50    } else if (fields == 7) {
  51       Pmsg7(0, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
  52             row[0], row[1], row[2], row[3], row[4], row[5], row[6]);
  53    }
  54    return 0;
  55 }
  56
  57 Bvfs::Bvfs(JCR *j, B_DB *mdb) {
  58    jcr = j;
  59    jcr->inc_use_count();
  60    db = mdb;                 /* need to inc ref count */
  61    prev_dir = get_pool_memory(PM_NAME);
  62    jobids = get_pool_memory(PM_NAME);
  63    pattern = get_pool_memory(PM_NAME);
  64    *prev_dir = *pattern = *jobids = 0;
  65    dir_filenameid = pwd_id = offset = 0;
  66    see_copies = see_all_version = false;
  67    limit = 1000;
  68    attr = new_attr(jcr);
  69    list_entries = result_handler;
  70    user_data = this;
  71 }
  72
  73 Bvfs::~Bvfs() {
  74    free_pool_memory(jobids);
  75    free_pool_memory(pattern);
  76    free_pool_memory(prev_dir);
  77    free_attr(attr);
  78    jcr->dec_use_count();
  79 }
  80
  81 /*
  82  * TODO: Find a way to let the user choose how he wants to display
  83  * files and directories
  84  */
  85
  86
  87 /*
  88  * Working Object to store PathId already seen (avoid
  89  * database queries), equivalent to %cache_ppathid in perl
  90  */
  91
  92 #define NITEMS 50000
  93 class pathid_cache {
  94 private:
  95    hlink *nodes;
  96    int nb_node;
  97    int max_node;
  98    htable *cache_ppathid;
  99
 100 public:
 101    pathid_cache() {
 102       hlink link;
 103       cache_ppathid = (htable *)malloc(sizeof(htable));
 104       cache_ppathid->init(&link, &link, NITEMS);
 105       max_node = NITEMS;
 106       nodes = (hlink *) malloc(max_node * sizeof (hlink));
 107       nb_node = 0;
 108    }
 109
 110    hlink *get_hlink() {
 111       if (nb_node >= max_node) {
 112          max_node *= 2;
 113          nodes = (hlink *)brealloc(nodes, sizeof(hlink) * max_node);
 114       }
 115       return nodes + nb_node++;
 116    }
 117
 118    bool lookup(char *pathid) {
 119       bool ret = cache_ppathid->lookup(pathid) != NULL;
 120       return ret;
 121    }
 122
 123    void insert(char *pathid) {
 124       hlink *h = get_hlink();
 125       cache_ppathid->insert(pathid, h);
 126    }
 127
 128    ~pathid_cache() {
 129       cache_ppathid->destroy();
 130       free(cache_ppathid);
 131       free(nodes);
 132    }
 133 } ;
 134
 135 /* Return the parent_dir with the trailing /  (update the given string)
 136  * TODO: see in the rest of bacula if we don't have already this function
 137  * dir=/tmp/toto/
 138  * dir=/tmp/
 139  * dir=/
 140  * dir=
 141  */
 142 char *bvfs_parent_dir(char *path)
 143 {
 144    char *p = path;
 145    int len = strlen(path) - 1;
 146
 147    if (len >= 0 && path[len] == '/') {      /* if directory, skip last / */
 148       path[len] = '\0';
 149    }
 150
 151    if (len > 0) {
 152       p += len;
 153       while (p > path && !IsPathSeparator(*p)) {
 154          p--;
 155       }
 156       p[1] = '\0';
 157    }
 158    return path;
 159 }
 160
 161 /* Return the basename of the with the trailing /
 162  * TODO: see in the rest of bacula if we don't have
 163  * this function already
 164  */
 165 char *bvfs_basename_dir(char *path)
 166 {
 167    char *p = path;
 168    int len = strlen(path) - 1;
 169
 170    if (path[len] == '/') {      /* if directory, skip last / */
 171       len -= 1;
 172    }
 173
 174    if (len > 0) {
 175       p += len;
 176       while (p > path && !IsPathSeparator(*p)) {
 177          p--;
 178       }
 179       if (*p == '/') {
 180          p++;                  /* skip first / */
 181       }
 182    }
 183    return p;
 184 }
 185
 186 static void build_path_hierarchy(JCR *jcr, B_DB *mdb,
 187                                  pathid_cache &ppathid_cache,
 188                                  char *org_pathid, char *path)
 189 {
 190    Dmsg1(dbglevel, "build_path_hierarchy(%s)\n", path);
 191    char pathid[50];
 192    ATTR_DBR parent;
 193    char *bkp = mdb->path;
 194    strncpy(pathid, org_pathid, sizeof(pathid));
 195
 196    /* Does the ppathid exist for this ? we use a memory cache...  In order to
 197     * avoid the full loop, we consider that if a dir is allready in the
 198     * brestore_pathhierarchy table, then there is no need to calculate all the
 199     * hierarchy
 200     */
 201    while (path && *path)
 202    {
 203       if (!ppathid_cache.lookup(pathid))
 204       {
 205          Mmsg(mdb->cmd,
 206               "SELECT PPathId FROM brestore_pathhierarchy WHERE PathId = %s",
 207               pathid);
 208
 209          QUERY_DB(jcr, mdb, mdb->cmd);
 210          /* Do we have a result ? */
 211          if (sql_num_rows(mdb) > 0) {
 212             ppathid_cache.insert(pathid);
 213             /* This dir was in the db ...
 214              * It means we can leave, the tree has allready been built for
 215              * this dir
 216              */
 217             goto bail_out;
 218          } else {
 219             /* search or create parent PathId in Path table */
 220             mdb->path = bvfs_parent_dir(path);
 221             mdb->pnl = strlen(mdb->path);
 222             if (!db_create_path_record(jcr, mdb, &parent)) {
 223                goto bail_out;
 224             }
 225             ppathid_cache.insert(pathid);
 226
 227             Mmsg(mdb->cmd,
 228                  "INSERT INTO brestore_pathhierarchy (PathId, PPathId) "
 229                  "VALUES (%s,%lld)",
 230                  pathid, (uint64_t) parent.PathId);
 231
 232             INSERT_DB(jcr, mdb, mdb->cmd);
 233
 234             edit_uint64(parent.PathId, pathid);
 235             path = mdb->path;   /* already done */
 236          }
 237       } else {
 238          /* It's allready in the cache.  We can leave, no time to waste here,
 239           * all the parent dirs have allready been done
 240           */
 241          goto bail_out;
 242       }
 243    }
 244
 245 bail_out:
 246    mdb->path = bkp;
 247    mdb->fnl = 0;
 248 }
 249
 250 /*
 251  * Internal function to update path_hierarchy cache with a shared pathid cache
 252  */
 253 static void update_path_hierarchy_cache(JCR *jcr,
 254                                         B_DB *mdb,
 255                                         pathid_cache &ppathid_cache,
 256                                         JobId_t JobId)
 257 {
 258    Dmsg0(dbglevel, "update_path_hierarchy_cache()\n");
 259
 260    uint32_t num;
 261    char jobid[50];
 262    edit_uint64(JobId, jobid);
 263
 264    db_lock(mdb);
 265    db_start_transaction(jcr, mdb);
 266
 267    Mmsg(mdb->cmd, "SELECT 1 FROM brestore_knownjobid WHERE JobId = %s", jobid);
 268
 269    if (!QUERY_DB(jcr, mdb, mdb->cmd) || sql_num_rows(mdb) > 0) {
 270       Dmsg1(dbglevel, "already computed %d\n", (uint32_t)JobId );
 271       goto bail_out;
 272    }
 273
 274    /* Inserting path records for JobId */
 275    Mmsg(mdb->cmd, "INSERT INTO brestore_pathvisibility (PathId, JobId) "
 276                   "SELECT DISTINCT PathId, JobId FROM File WHERE JobId = %s",
 277         jobid);
 278    QUERY_DB(jcr, mdb, mdb->cmd);
 279
 280
 281    /* Now we have to do the directory recursion stuff to determine missing
 282     * visibility We try to avoid recursion, to be as fast as possible We also
 283     * only work on not allready hierarchised directories...
 284     */
 285    Mmsg(mdb->cmd,
 286      "SELECT brestore_pathvisibility.PathId, Path "
 287        "FROM brestore_pathvisibility "
 288             "JOIN Path ON( brestore_pathvisibility.PathId = Path.PathId) "
 289             "LEFT JOIN brestore_pathhierarchy "
 290          "ON (brestore_pathvisibility.PathId = brestore_pathhierarchy.PathId) "
 291       "WHERE brestore_pathvisibility.JobId = %s "
 292         "AND brestore_pathhierarchy.PathId IS NULL "
 293       "ORDER BY Path", jobid);
 294    Dmsg1(dbglevel_sql, "q=%s\n", mdb->cmd);
 295    QUERY_DB(jcr, mdb, mdb->cmd);
 296
 297    /* TODO: I need to reuse the DB connection without emptying the result
 298     * So, now i'm copying the result in memory to be able to query the
 299     * catalog descriptor again.
 300     */
 301    num = sql_num_rows(mdb);
 302    if (num > 0) {
 303       char **result = (char **)malloc (num * 2 * sizeof(char *));
 304
 305       SQL_ROW row;
 306       int i=0;
 307       while((row = sql_fetch_row(mdb))) {
 308          result[i++] = bstrdup(row[0]);
 309          result[i++] = bstrdup(row[1]);
 310       }
 311
 312       i=0;
 313       while (num > 0) {
 314          build_path_hierarchy(jcr, mdb, ppathid_cache, result[i], result[i+1]);
 315          free(result[i++]);
 316          free(result[i++]);
 317          num--;
 318       }
 319       free(result);
 320    }
 321
 322    Mmsg(mdb->cmd,
 323   "INSERT INTO brestore_pathvisibility (PathId, JobId)  "
 324    "SELECT a.PathId,%s "
 325    "FROM ( "
 326      "SELECT DISTINCT h.PPathId AS PathId "
 327        "FROM brestore_pathhierarchy AS h "
 328        "JOIN  brestore_pathvisibility AS p ON (h.PathId=p.PathId) "
 329       "WHERE p.JobId=%s) AS a LEFT JOIN "
 330        "(SELECT PathId "
 331           "FROM brestore_pathvisibility "
 332          "WHERE JobId=%s) AS b ON (a.PathId = b.PathId) "
 333    "WHERE b.PathId IS NULL",  jobid, jobid, jobid);
 334
 335    do {
 336       QUERY_DB(jcr, mdb, mdb->cmd);
 337    } while (sql_affected_rows(mdb) > 0);
 338
 339    Mmsg(mdb->cmd, "INSERT INTO brestore_knownjobid (JobId) VALUES (%s)", jobid);
 340    INSERT_DB(jcr, mdb, mdb->cmd);
 341
 342 bail_out:
 343    db_end_transaction(jcr, mdb);
 344    db_unlock(mdb);
 345 }
 346
 347 /*
 348  * Find an store the filename descriptor for empty directories Filename.Name=''
 349  */
 350 DBId_t Bvfs::get_dir_filenameid()
 351 {
 352    uint32_t id;
 353    if (dir_filenameid) {
 354       return dir_filenameid;
 355    }
 356    POOL_MEM q;
 357    Mmsg(q, "SELECT FilenameId FROM Filename WHERE Name = ''");
 358    db_sql_query(db, q.c_str(), db_int_handler, &id);
 359    dir_filenameid = id;
 360    return dir_filenameid;
 361 }
 362
 363 void bvfs_update_cache(JCR *jcr, B_DB *mdb)
 364 {
 365    uint32_t nb=0;
 366    db_lock(mdb);
 367    db_start_transaction(jcr, mdb);
 368
 369    Mmsg(mdb->cmd, "SELECT 1 from brestore_knownjobid LIMIT 1");
 370    /* TODO: Add this code in the make_bacula_table script */
 371    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 372       Dmsg0(dbglevel, "Creating cache table\n");
 373       Mmsg(mdb->cmd,
 374            "CREATE TABLE brestore_knownjobid ("
 375            "JobId integer NOT NULL, "
 376            "CONSTRAINT brestore_knownjobid_pkey PRIMARY KEY (JobId))");
 377       QUERY_DB(jcr, mdb, mdb->cmd);
 378
 379       Mmsg(mdb->cmd,
 380            "CREATE TABLE brestore_pathhierarchy ( "
 381            "PathId integer NOT NULL, "
 382            "PPathId integer NOT NULL, "
 383            "CONSTRAINT brestore_pathhierarchy_pkey "
 384            "PRIMARY KEY (PathId))");
 385       QUERY_DB(jcr, mdb, mdb->cmd);
 386
 387       Mmsg(mdb->cmd,
 388            "CREATE INDEX brestore_pathhierarchy_ppathid "
 389            "ON brestore_pathhierarchy (PPathId)");
 390       QUERY_DB(jcr, mdb, mdb->cmd);
 391
 392       Mmsg(mdb->cmd,
 393            "CREATE TABLE brestore_pathvisibility ("
 394            "PathId integer NOT NULL, "
 395            "JobId integer NOT NULL, "
 396            "Size int8 DEFAULT 0, "
 397            "Files int4 DEFAULT 0, "
 398            "CONSTRAINT brestore_pathvisibility_pkey "
 399            "PRIMARY KEY (JobId, PathId))");
 400       QUERY_DB(jcr, mdb, mdb->cmd);
 401
 402       Mmsg(mdb->cmd,
 403            "CREATE INDEX brestore_pathvisibility_jobid "
 404            "ON brestore_pathvisibility (JobId)");
 405       QUERY_DB(jcr, mdb, mdb->cmd);
 406
 407    }
 408
 409    POOLMEM *jobids = get_pool_memory(PM_NAME);
 410    *jobids = 0;
 411
 412    Mmsg(mdb->cmd,
 413  "SELECT JobId from Job "
 414   "WHERE JobId NOT IN (SELECT JobId FROM brestore_knownjobid) "
 415     "AND Type IN ('B') AND JobStatus IN ('T', 'f', 'A') "
 416   "ORDER BY JobId");
 417
 418    db_sql_query(mdb, mdb->cmd, db_get_int_handler, jobids);
 419
 420    bvfs_update_path_hierarchy_cache(jcr, mdb, jobids);
 421
 422    db_end_transaction(jcr, mdb);
 423    db_start_transaction(jcr, mdb);
 424    Dmsg0(dbglevel, "Cleaning pathvisibility\n");
 425    Mmsg(mdb->cmd,
 426         "DELETE FROM brestore_pathvisibility "
 427          "WHERE NOT EXISTS "
 428         "(SELECT 1 FROM Job WHERE JobId=brestore_pathvisibility.JobId)");
 429    nb = DELETE_DB(jcr, mdb, mdb->cmd);
 430    Dmsg1(dbglevel, "Affected row(s) = %d\n", nb);
 431
 432    Dmsg0(dbglevel, "Cleaning knownjobid\n");
 433    Mmsg(mdb->cmd,
 434         "DELETE FROM brestore_knownjobid "
 435          "WHERE NOT EXISTS "
 436         "(SELECT 1 FROM Job WHERE JobId=brestore_knownjobid.JobId)");
 437    nb = DELETE_DB(jcr, mdb, mdb->cmd);
 438    Dmsg1(dbglevel, "Affected row(s) = %d\n", nb);
 439
 440    db_end_transaction(jcr, mdb);
 441    free_pool_memory(jobids);
 442 }
 443
 444 /*
 445  * Update the bvfs cache for given jobids (1,2,3,4)
 446  */
 447 void
 448 bvfs_update_path_hierarchy_cache(JCR *jcr, B_DB *mdb, char *jobids)
 449 {
 450    pathid_cache ppathid_cache;
 451    JobId_t JobId;
 452    char *p;
 453
 454    for (p=jobids; ; ) {
 455       int stat = get_next_jobid_from_list(&p, &JobId);
 456       if (stat < 0) {
 457          return;
 458       }
 459       if (stat == 0) {
 460          break;
 461       }
 462       Dmsg1(dbglevel, "Updating cache for %lld\n", (uint64_t) JobId);
 463       update_path_hierarchy_cache(jcr, mdb, ppathid_cache, JobId);
 464    }
 465 }
 466
 467 /*
 468  * Update the bvfs cache for current jobids
 469  */
 470 void Bvfs::update_cache()
 471 {
 472    bvfs_update_path_hierarchy_cache(jcr, db, jobids);
 473 }
 474
 475 /* Change the current directory, returns true if the path exists */
 476 bool Bvfs::ch_dir(const char *path)
 477 {
 478    pm_strcpy(db->path, path);
 479    db->pnl = strlen(db->path);
 480    ch_dir(db_get_path_record(jcr, db));
 481    return pwd_id != 0;
 482 }
 483
 484 /*
 485  * Get all file versions for a specified client
 486  */
 487 void Bvfs::get_all_file_versions(DBId_t pathid, DBId_t fnid, const char *client)
 488 {
 489    Dmsg3(dbglevel, "get_all_file_versions(%lld, %lld, %s)\n", (uint64_t)pathid,
 490          (uint64_t)fnid, client);
 491    char ed1[50], ed2[50];
 492    POOL_MEM q;
 493    if (see_copies) {
 494       Mmsg(q, " AND Job.Type IN ('C', 'B') ");
 495    } else {
 496       Mmsg(q, " AND Job.Type = 'B' ");
 497    }
 498
 499    POOL_MEM query;
 500
 501    Mmsg(query,//0       1           2          3
 502 "SELECT File.FileId, File.Md5, File.JobId, File.LStat, "
 503 //         4                5
 504        "Media.VolumeName, Media.InChanger "
 505 "FROM File, Job, Client, JobMedia, Media "
 506 "WHERE File.FilenameId = %s "
 507   "AND File.PathId=%s "
 508   "AND File.JobId = Job.JobId "
 509   "AND Job.ClientId = Client.ClientId "
 510   "AND Job.JobId = JobMedia.JobId "
 511   "AND File.FileIndex >= JobMedia.FirstIndex "
 512   "AND File.FileIndex <= JobMedia.LastIndex "
 513   "AND JobMedia.MediaId = Media.MediaId "
 514   "AND Client.Name = '%s' "
 515   "%s ORDER BY FileId LIMIT %d OFFSET %d"
 516         ,edit_uint64(fnid, ed1), edit_uint64(pathid, ed2), client, q.c_str(),
 517         limit, offset);
 518    Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
 519    db_sql_query(db, query.c_str(), list_entries, user_data);
 520 }
 521
 522 DBId_t Bvfs::get_root()
 523 {
 524    *db->path = 0;
 525    return db_get_path_record(jcr, db);
 526 }
 527
 528 static int path_handler(void *ctx, int fields, char **row)
 529 {
 530    Bvfs *fs = (Bvfs *) ctx;
 531    return fs->_handle_path(ctx, fields, row);
 532 }
 533
 534 int Bvfs::_handle_path(void *ctx, int fields, char **row)
 535 {
 536    if (fields == BVFS_DIR_RECORD) {
 537       /* can have the same path 2 times */
 538       if (strcmp(row[BVFS_Name], prev_dir)) {
 539          pm_strcpy(prev_dir, row[BVFS_Name]);
 540          return list_entries(user_data, fields, row);
 541       }
 542    }
 543    return 0;
 544 }
 545
 546 /*
 547  * Retrieve . and .. information
 548  */
 549 void Bvfs::ls_special_dirs()
 550 {
 551    Dmsg1(dbglevel, "ls_special_dirs(%lld)\n", (uint64_t)pwd_id);
 552    char ed1[50], ed2[50];
 553    if (!*jobids) {
 554       return;
 555    }
 556    if (!dir_filenameid) {
 557       get_dir_filenameid();
 558    }
 559
 560    /* Will fetch directories  */
 561    *prev_dir = 0;
 562
 563    POOL_MEM query;
 564    Mmsg(query,
 565 "((SELECT PPathId AS PathId, '..' AS Path "
 566     "FROM  brestore_pathhierarchy "
 567    "WHERE  PathId = %s) "
 568 "UNION "
 569  "(SELECT %s AS PathId, '.' AS Path))",
 570         edit_uint64(pwd_id, ed1), ed1);
 571
 572    POOL_MEM query2;
 573    Mmsg(query2,
 574 "SELECT tmp.PathId, tmp.Path, JobId, LStat "
 575   "FROM %s AS tmp  LEFT JOIN ( " // get attributes if any
 576        "SELECT File1.PathId AS PathId, File1.JobId AS JobId, "
 577               "File1.LStat AS LStat FROM File AS File1 "
 578        "WHERE File1.FilenameId = %s "
 579        "AND File1.JobId IN (%s)) AS listfile1 "
 580   "ON (tmp.PathId = listfile1.PathId) "
 581   "ORDER BY tmp.Path, JobId DESC ",
 582         query.c_str(), edit_uint64(dir_filenameid, ed2), jobids);
 583
 584    Dmsg1(dbglevel_sql, "q=%s\n", query2.c_str());
 585    db_sql_query(db, query2.c_str(), path_handler, this);
 586 }
 587
 588 /* Returns true if we have dirs to read */
 589 bool Bvfs::ls_dirs()
 590 {
 591    Dmsg1(dbglevel, "ls_dirs(%lld)\n", (uint64_t)pwd_id);
 592    char ed1[50], ed2[50];
 593    if (!*jobids) {
 594       return false;
 595    }
 596
 597    POOL_MEM filter;
 598    if (*pattern) {
 599       Mmsg(filter, " AND Path2.Path %s '%s' ", SQL_MATCH, pattern);
 600    }
 601
 602    if (!dir_filenameid) {
 603       get_dir_filenameid();
 604    }
 605
 606    /* the sql query displays same directory multiple time, take the first one */
 607    *prev_dir = 0;
 608
 609    /* Let's retrieve the list of the visible dirs in this dir ...
 610     * First, I need the empty filenameid to locate efficiently
 611     * the dirs in the file table
 612     * my $dir_filenameid = $self->get_dir_filenameid();
 613     */
 614    /* Then we get all the dir entries from File ... */
 615    POOL_MEM query;
 616    Mmsg(query,
 617 //        0     1      2      3
 618 "SELECT PathId, Path, JobId, LStat FROM ( "
 619     "SELECT Path1.PathId AS PathId, Path1.Path AS Path, "
 620            "lower(Path1.Path) AS lpath, "
 621            "listfile1.JobId AS JobId, listfile1.LStat AS LStat "
 622     "FROM ( "
 623       "SELECT DISTINCT brestore_pathhierarchy1.PathId AS PathId "
 624       "FROM brestore_pathhierarchy AS brestore_pathhierarchy1 "
 625       "JOIN Path AS Path2 "
 626         "ON (brestore_pathhierarchy1.PathId = Path2.PathId) "
 627       "JOIN brestore_pathvisibility AS brestore_pathvisibility1 "
 628         "ON (brestore_pathhierarchy1.PathId = brestore_pathvisibility1.PathId) "
 629       "WHERE brestore_pathhierarchy1.PPathId = %s "
 630       "AND brestore_pathvisibility1.jobid IN (%s) "
 631            "%s "
 632      ") AS listpath1 "
 633    "JOIN Path AS Path1 ON (listpath1.PathId = Path1.PathId) "
 634
 635    "LEFT JOIN ( " /* get attributes if any */
 636        "SELECT File1.PathId AS PathId, File1.JobId AS JobId, "
 637               "File1.LStat AS LStat FROM File AS File1 "
 638        "WHERE File1.FilenameId = %s "
 639        "AND File1.JobId IN (%s)) AS listfile1 "
 640        "ON (listpath1.PathId = listfile1.PathId) "
 641     ") AS A ORDER BY 2,3 DESC LIMIT %d OFFSET %d",
 642         edit_uint64(pwd_id, ed1),
 643         jobids,
 644         filter.c_str(),
 645         edit_uint64(dir_filenameid, ed2),
 646         jobids,
 647         limit, offset);
 648
 649    Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
 650
 651    db_lock(db);
 652    db_sql_query(db, query.c_str(), path_handler, this);
 653    nb_record = db->num_rows;
 654    db_unlock(db);
 655
 656    return nb_record == limit;
 657 }
 658
 659 /* Returns true if we have files to read */
 660 bool Bvfs::ls_files()
 661 {
 662    Dmsg1(dbglevel, "ls_files(%lld)\n", (uint64_t)pwd_id);
 663    char ed1[50];
 664    if (!*jobids) {
 665       return false;
 666    }
 667
 668    if (!pwd_id) {
 669       ch_dir(get_root());
 670    }
 671
 672    POOL_MEM filter;
 673    if (*pattern) {
 674       Mmsg(filter, " AND Filename.Name %s '%s' ", SQL_MATCH, pattern);
 675    }
 676
 677    POOL_MEM query;
 678    Mmsg(query, // 0         1              2             3          4
 679 "SELECT File.FilenameId, listfiles.Name, File.JobId, File.LStat, listfiles.id "
 680 "FROM File, ( "
 681        "SELECT Filename.Name as Name, max(File.FileId) as id "
 682          "FROM File, Filename "
 683         "WHERE File.FilenameId = Filename.FilenameId "
 684           "AND Filename.Name != '' "
 685           "AND File.PathId = %s "
 686           "AND File.JobId IN (%s) "
 687           "%s "
 688         "GROUP BY Filename.Name "
 689         "ORDER BY Filename.Name LIMIT %d OFFSET %d "
 690      ") AS listfiles "
 691 "WHERE File.FileId = listfiles.id",
 692         edit_uint64(pwd_id, ed1),
 693         jobids,
 694         filter.c_str(),
 695         limit,
 696         offset);
 697    Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
 698
 699    db_lock(db);
 700    db_sql_query(db, query.c_str(), list_entries, user_data);
 701    nb_record = db->num_rows;
 702    db_unlock(db);
 703
 704    return nb_record == limit;
 705 }