2 Bacula® - The Network Backup Solution
4 Copyright (C) 2009-2010 Free Software Foundation Europe e.V.
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 three of the GNU Affero General Public
10 License as published by the Free Software Foundation, which is
11 listed in the file LICENSE.
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.
18 You should have received a copy of the GNU Affero 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
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.
31 #if HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL || HAVE_INGRES || HAVE_DBI
36 #include "lib/htable.h"
40 #define dbglevel_sql 15
42 static int result_handler(void *ctx, int fields, char **row)
45 Pmsg4(0, "%s\t%s\t%s\t%s\n",
46 row[0], row[1], row[2], row[3]);
47 } else if (fields == 5) {
48 Pmsg5(0, "%s\t%s\t%s\t%s\t%s\n",
49 row[0], row[1], row[2], row[3], row[4]);
50 } else if (fields == 6) {
51 Pmsg6(0, "%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]);
53 } else if (fields == 7) {
54 Pmsg7(0, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
55 row[0], row[1], row[2], row[3], row[4], row[5], row[6]);
60 Bvfs::Bvfs(JCR *j, B_DB *mdb) {
63 db = mdb; /* need to inc ref count */
64 jobids = get_pool_memory(PM_NAME);
65 prev_dir = get_pool_memory(PM_NAME);
66 pattern = get_pool_memory(PM_NAME);
67 *jobids = *prev_dir = *pattern = 0;
68 dir_filenameid = pwd_id = offset = 0;
69 see_copies = see_all_versions = false;
72 list_entries = result_handler;
78 free_pool_memory(jobids);
79 free_pool_memory(pattern);
80 free_pool_memory(prev_dir);
88 void Bvfs::filter_jobid()
94 /* Query used by Bweb to filter clients, activated when using
99 "SELECT DISTINCT JobId FROM Job JOIN Client USING (ClientId) "
100 "JOIN (SELECT ClientId FROM client_group_member "
101 "JOIN client_group USING (client_group_id) "
102 "JOIN bweb_client_group_acl USING (client_group_id) "
103 "JOIN bweb_user USING (userid) "
104 "WHERE bweb_user.username = '%s' "
105 ") AS filter USING (ClientId) "
106 " WHERE JobId IN (%s)",
110 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
111 db_sql_query(db, query.c_str(), db_list_handler, &ctx);
112 pm_strcpy(jobids, ctx.list);
115 void Bvfs::set_jobid(JobId_t id)
117 Mmsg(jobids, "%lld", (uint64_t)id);
121 void Bvfs::set_jobids(char *ids)
123 pm_strcpy(jobids, ids);
128 * TODO: Find a way to let the user choose how he wants to display
129 * files and directories
134 * Working Object to store PathId already seen (avoid
135 * database queries), equivalent to %cache_ppathid in perl
147 htable *cache_ppathid;
152 cache_ppathid = (htable *)malloc(sizeof(htable));
153 cache_ppathid->init(&link, &link, NITEMS);
155 nodes = (hlink *) malloc(max_node * sizeof (hlink));
157 table_node = New(alist(5, owned_by_alist));
158 table_node->append(nodes);
162 if (++nb_node >= max_node) {
164 nodes = (hlink *)malloc(max_node * sizeof(hlink));
165 table_node->append(nodes);
167 return nodes + nb_node;
170 bool lookup(char *pathid) {
171 bool ret = cache_ppathid->lookup(pathid) != NULL;
175 void insert(char *pathid) {
176 hlink *h = get_hlink();
177 cache_ppathid->insert(pathid, h);
181 cache_ppathid->destroy();
186 pathid_cache(const pathid_cache &); /* prohibit pass by value */
187 pathid_cache &operator= (const pathid_cache &);/* prohibit class assignment*/
190 /* Return the parent_dir with the trailing / (update the given string)
191 * TODO: see in the rest of bacula if we don't have already this function
197 char *bvfs_parent_dir(char *path)
200 int len = strlen(path) - 1;
202 if (len >= 0 && path[len] == '/') { /* if directory, skip last / */
208 while (p > path && !IsPathSeparator(*p)) {
216 /* Return the basename of the with the trailing /
217 * TODO: see in the rest of bacula if we don't have
218 * this function already
220 char *bvfs_basename_dir(char *path)
223 int len = strlen(path) - 1;
225 if (path[len] == '/') { /* if directory, skip last / */
231 while (p > path && !IsPathSeparator(*p)) {
235 p++; /* skip first / */
241 static void build_path_hierarchy(JCR *jcr, B_DB *mdb,
242 pathid_cache &ppathid_cache,
243 char *org_pathid, char *path)
245 Dmsg1(dbglevel, "build_path_hierarchy(%s)\n", path);
248 char *bkp = mdb->path;
249 strncpy(pathid, org_pathid, sizeof(pathid));
251 /* Does the ppathid exist for this ? we use a memory cache... In order to
252 * avoid the full loop, we consider that if a dir is allready in the
253 * PathHierarchy table, then there is no need to calculate all the
256 while (path && *path)
258 if (!ppathid_cache.lookup(pathid))
261 "SELECT PPathId FROM PathHierarchy WHERE PathId = %s",
264 QUERY_DB(jcr, mdb, mdb->cmd);
265 /* Do we have a result ? */
266 if (sql_num_rows(mdb) > 0) {
267 ppathid_cache.insert(pathid);
268 /* This dir was in the db ...
269 * It means we can leave, the tree has allready been built for
274 /* search or create parent PathId in Path table */
275 mdb->path = bvfs_parent_dir(path);
276 mdb->pnl = strlen(mdb->path);
277 if (!db_create_path_record(jcr, mdb, &parent)) {
280 ppathid_cache.insert(pathid);
283 "INSERT INTO PathHierarchy (PathId, PPathId) "
285 pathid, (uint64_t) parent.PathId);
287 INSERT_DB(jcr, mdb, mdb->cmd);
289 edit_uint64(parent.PathId, pathid);
290 path = mdb->path; /* already done */
293 /* It's already in the cache. We can leave, no time to waste here,
294 * all the parent dirs have allready been done
306 * Internal function to update path_hierarchy cache with a shared pathid cache
308 static void update_path_hierarchy_cache(JCR *jcr,
310 pathid_cache &ppathid_cache,
313 Dmsg0(dbglevel, "update_path_hierarchy_cache()\n");
317 edit_uint64(JobId, jobid);
320 db_start_transaction(jcr, mdb);
322 Mmsg(mdb->cmd, "SELECT 1 FROM Job WHERE JobId = %s AND HasCache=1", jobid);
324 if (!QUERY_DB(jcr, mdb, mdb->cmd) || sql_num_rows(mdb) > 0) {
325 Dmsg1(dbglevel, "already computed %d\n", (uint32_t)JobId );
329 /* Inserting path records for JobId */
330 Mmsg(mdb->cmd, "INSERT INTO PathVisibility (PathId, JobId) "
331 "SELECT DISTINCT PathId, JobId "
332 "FROM (SELECT PathId, JobId FROM File WHERE JobId = %s "
334 "SELECT PathId, BaseFiles.JobId "
335 "FROM BaseFiles JOIN File AS F USING (FileId) "
336 "WHERE BaseFiles.JobId = %s) AS B",
338 QUERY_DB(jcr, mdb, mdb->cmd);
340 /* Now we have to do the directory recursion stuff to determine missing
341 * visibility We try to avoid recursion, to be as fast as possible We also
342 * only work on not allready hierarchised directories...
345 "SELECT PathVisibility.PathId, Path "
346 "FROM PathVisibility "
347 "JOIN Path ON( PathVisibility.PathId = Path.PathId) "
348 "LEFT JOIN PathHierarchy "
349 "ON (PathVisibility.PathId = PathHierarchy.PathId) "
350 "WHERE PathVisibility.JobId = %s "
351 "AND PathHierarchy.PathId IS NULL "
352 "ORDER BY Path", jobid);
353 Dmsg1(dbglevel_sql, "q=%s\n", mdb->cmd);
354 QUERY_DB(jcr, mdb, mdb->cmd);
356 /* TODO: I need to reuse the DB connection without emptying the result
357 * So, now i'm copying the result in memory to be able to query the
358 * catalog descriptor again.
360 num = sql_num_rows(mdb);
362 char **result = (char **)malloc (num * 2 * sizeof(char *));
366 while((row = sql_fetch_row(mdb))) {
367 result[i++] = bstrdup(row[0]);
368 result[i++] = bstrdup(row[1]);
373 build_path_hierarchy(jcr, mdb, ppathid_cache, result[i], result[i+1]);
382 "INSERT INTO PathVisibility (PathId, JobId) "
383 "SELECT a.PathId,%s "
385 "SELECT DISTINCT h.PPathId AS PathId "
386 "FROM PathHierarchy AS h "
387 "JOIN PathVisibility AS p ON (h.PathId=p.PathId) "
388 "WHERE p.JobId=%s) AS a LEFT JOIN "
390 "FROM PathVisibility "
391 "WHERE JobId=%s) AS b ON (a.PathId = b.PathId) "
392 "WHERE b.PathId IS NULL", jobid, jobid, jobid);
395 QUERY_DB(jcr, mdb, mdb->cmd);
396 } while (sql_affected_rows(mdb) > 0);
398 Mmsg(mdb->cmd, "UPDATE Job SET HasCache=1 WHERE JobId=%s", jobid);
399 UPDATE_DB(jcr, mdb, mdb->cmd);
402 db_end_transaction(jcr, mdb);
407 * Find an store the filename descriptor for empty directories Filename.Name=''
409 DBId_t Bvfs::get_dir_filenameid()
412 if (dir_filenameid) {
413 return dir_filenameid;
416 Mmsg(q, "SELECT FilenameId FROM Filename WHERE Name = ''");
417 db_sql_query(db, q.c_str(), db_int_handler, &id);
419 return dir_filenameid;
422 void bvfs_update_cache(JCR *jcr, B_DB *mdb)
425 db_list_ctx jobids_list;
428 db_start_transaction(jcr, mdb);
431 /* TODO: Remove this code when updating make_bacula_table script */
432 Mmsg(mdb->cmd, "SELECT 1 FROM Job WHERE HasCache<>2 LIMIT 1");
433 if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
434 Dmsg0(dbglevel, "Creating cache table\n");
435 Mmsg(mdb->cmd, "ALTER TABLE Job ADD HasCache int DEFAULT 0");
436 QUERY_DB(jcr, mdb, mdb->cmd);
439 "CREATE TABLE PathHierarchy ( "
440 "PathId integer NOT NULL, "
441 "PPathId integer NOT NULL, "
442 "CONSTRAINT pathhierarchy_pkey "
443 "PRIMARY KEY (PathId))");
444 QUERY_DB(jcr, mdb, mdb->cmd);
447 "CREATE INDEX pathhierarchy_ppathid "
448 "ON PathHierarchy (PPathId)");
449 QUERY_DB(jcr, mdb, mdb->cmd);
452 "CREATE TABLE PathVisibility ("
453 "PathId integer NOT NULL, "
454 "JobId integer NOT NULL, "
455 "Size int8 DEFAULT 0, "
456 "Files int4 DEFAULT 0, "
457 "CONSTRAINT pathvisibility_pkey "
458 "PRIMARY KEY (JobId, PathId))");
459 QUERY_DB(jcr, mdb, mdb->cmd);
462 "CREATE INDEX pathvisibility_jobid "
463 "ON PathVisibility (JobId)");
464 QUERY_DB(jcr, mdb, mdb->cmd);
470 "SELECT JobId from Job "
471 "WHERE HasCache = 0 "
472 "AND Type IN ('B') AND JobStatus IN ('T', 'f', 'A') "
475 db_sql_query(mdb, mdb->cmd, db_list_handler, &jobids_list);
477 bvfs_update_path_hierarchy_cache(jcr, mdb, jobids_list.list);
479 db_end_transaction(jcr, mdb);
480 db_start_transaction(jcr, mdb);
481 Dmsg0(dbglevel, "Cleaning pathvisibility\n");
483 "DELETE FROM PathVisibility "
485 "(SELECT 1 FROM Job WHERE JobId=PathVisibility.JobId)");
486 nb = DELETE_DB(jcr, mdb, mdb->cmd);
487 Dmsg1(dbglevel, "Affected row(s) = %d\n", nb);
489 db_end_transaction(jcr, mdb);
494 * Update the bvfs cache for given jobids (1,2,3,4)
497 bvfs_update_path_hierarchy_cache(JCR *jcr, B_DB *mdb, char *jobids)
499 pathid_cache ppathid_cache;
504 int stat = get_next_jobid_from_list(&p, &JobId);
511 Dmsg1(dbglevel, "Updating cache for %lld\n", (uint64_t)JobId);
512 update_path_hierarchy_cache(jcr, mdb, ppathid_cache, JobId);
517 * Update the bvfs cache for current jobids
519 void Bvfs::update_cache()
521 bvfs_update_path_hierarchy_cache(jcr, db, jobids);
524 /* Change the current directory, returns true if the path exists */
525 bool Bvfs::ch_dir(const char *path)
527 pm_strcpy(db->path, path);
528 db->pnl = strlen(db->path);
529 ch_dir(db_get_path_record(jcr, db));
534 * Get all file versions for a specified client
535 * TODO: Handle basejobs using different client
537 void Bvfs::get_all_file_versions(DBId_t pathid, DBId_t fnid, const char *client)
539 Dmsg3(dbglevel, "get_all_file_versions(%lld, %lld, %s)\n", (uint64_t)pathid,
540 (uint64_t)fnid, client);
541 char ed1[50], ed2[50];
544 Mmsg(q, " AND Job.Type IN ('C', 'B') ");
546 Mmsg(q, " AND Job.Type = 'B' ");
552 "SELECT 'V', File.PathId, File.FilenameId, File.Md5, "
554 "File.JobId, File.LStat, File.FileId, "
556 "Media.VolumeName, Media.InChanger "
557 "FROM File, Job, Client, JobMedia, Media "
558 "WHERE File.FilenameId = %s "
559 "AND File.PathId=%s "
560 "AND File.JobId = Job.JobId "
561 "AND Job.JobId = JobMedia.JobId "
562 "AND File.FileIndex >= JobMedia.FirstIndex "
563 "AND File.FileIndex <= JobMedia.LastIndex "
564 "AND JobMedia.MediaId = Media.MediaId "
565 "AND Job.ClientId = Client.ClientId "
566 "AND Client.Name = '%s' "
567 "%s ORDER BY FileId LIMIT %d OFFSET %d"
568 ,edit_uint64(fnid, ed1), edit_uint64(pathid, ed2), client, q.c_str(),
570 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
571 db_sql_query(db, query.c_str(), list_entries, user_data);
574 DBId_t Bvfs::get_root()
577 return db_get_path_record(jcr, db);
580 static int path_handler(void *ctx, int fields, char **row)
582 Bvfs *fs = (Bvfs *) ctx;
583 return fs->_handle_path(ctx, fields, row);
586 int Bvfs::_handle_path(void *ctx, int fields, char **row)
588 if (bvfs_is_dir(row)) {
589 /* can have the same path 2 times */
590 if (strcmp(row[BVFS_Name], prev_dir)) {
591 pm_strcpy(prev_dir, row[BVFS_Name]);
592 return list_entries(user_data, fields, row);
599 * Retrieve . and .. information
601 void Bvfs::ls_special_dirs()
603 Dmsg1(dbglevel, "ls_special_dirs(%lld)\n", (uint64_t)pwd_id);
604 char ed1[50], ed2[50];
608 if (!dir_filenameid) {
609 get_dir_filenameid();
612 /* Will fetch directories */
617 "(SELECT PPathId AS PathId, '..' AS Path "
618 "FROM PathHierarchy "
621 "SELECT %s AS PathId, '.' AS Path)",
622 edit_uint64(pwd_id, ed1), ed1);
625 Mmsg(query2,// 1 2 3 4 5 6
626 "SELECT 'D', tmp.PathId, 0, tmp.Path, JobId, LStat, FileId "
627 "FROM %s AS tmp LEFT JOIN ( " // get attributes if any
628 "SELECT File1.PathId AS PathId, File1.JobId AS JobId, "
629 "File1.LStat AS LStat, File1.FileId AS FileId FROM File AS File1 "
630 "WHERE File1.FilenameId = %s "
631 "AND File1.JobId IN (%s)) AS listfile1 "
632 "ON (tmp.PathId = listfile1.PathId) "
633 "ORDER BY tmp.Path, JobId DESC ",
634 query.c_str(), edit_uint64(dir_filenameid, ed2), jobids);
636 Dmsg1(dbglevel_sql, "q=%s\n", query2.c_str());
637 db_sql_query(db, query2.c_str(), path_handler, this);
640 /* Returns true if we have dirs to read */
643 Dmsg1(dbglevel, "ls_dirs(%lld)\n", (uint64_t)pwd_id);
644 char ed1[50], ed2[50];
652 int len = strlen(pattern);
653 query.check_size(len*2+1);
654 db_escape_string(jcr, db, query.c_str(), pattern, len);
655 Mmsg(filter, " AND Path2.Path %s '%s' ", match_query[db_get_type_index(db)], query.c_str());
658 if (!dir_filenameid) {
659 get_dir_filenameid();
662 /* the sql query displays same directory multiple time, take the first one */
665 /* Let's retrieve the list of the visible dirs in this dir ...
666 * First, I need the empty filenameid to locate efficiently
667 * the dirs in the file table
668 * my $dir_filenameid = $self->get_dir_filenameid();
670 /* Then we get all the dir entries from File ... */
673 "SELECT 'D', PathId, 0, Path, JobId, LStat, FileId FROM ( "
674 "SELECT Path1.PathId AS PathId, Path1.Path AS Path, "
675 "lower(Path1.Path) AS lpath, "
676 "listfile1.JobId AS JobId, listfile1.LStat AS LStat, "
677 "listfile1.FileId AS FileId "
679 "SELECT DISTINCT PathHierarchy1.PathId AS PathId "
680 "FROM PathHierarchy AS PathHierarchy1 "
681 "JOIN Path AS Path2 "
682 "ON (PathHierarchy1.PathId = Path2.PathId) "
683 "JOIN PathVisibility AS PathVisibility1 "
684 "ON (PathHierarchy1.PathId = PathVisibility1.PathId) "
685 "WHERE PathHierarchy1.PPathId = %s "
686 "AND PathVisibility1.JobId IN (%s) "
689 "JOIN Path AS Path1 ON (listpath1.PathId = Path1.PathId) "
691 "LEFT JOIN ( " /* get attributes if any */
692 "SELECT File1.PathId AS PathId, File1.JobId AS JobId, "
693 "File1.LStat AS LStat, File1.FileId AS FileId FROM File AS File1 "
694 "WHERE File1.FilenameId = %s "
695 "AND File1.JobId IN (%s)) AS listfile1 "
696 "ON (listpath1.PathId = listfile1.PathId) "
697 ") AS A ORDER BY 2,3 DESC LIMIT %d OFFSET %d",
698 edit_uint64(pwd_id, ed1),
701 edit_uint64(dir_filenameid, ed2),
705 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
708 db_sql_query(db, query.c_str(), path_handler, this);
709 nb_record = sql_num_rows(db);
712 return nb_record == limit;
715 void build_ls_files_query(B_DB *db, POOL_MEM &query,
716 const char *JobId, const char *PathId,
717 const char *filter, int64_t limit, int64_t offset)
719 if (db_get_type_index(db) == SQL_TYPE_POSTGRESQL) {
720 Mmsg(query, sql_bvfs_list_files[db_get_type_index(db)],
721 JobId, PathId, JobId, PathId,
722 filter, limit, offset);
724 Mmsg(query, sql_bvfs_list_files[db_get_type_index(db)],
725 JobId, PathId, JobId, PathId,
726 limit, offset, filter, JobId, JobId);
730 /* Returns true if we have files to read */
731 bool Bvfs::ls_files()
737 Dmsg1(dbglevel, "ls_files(%lld)\n", (uint64_t)pwd_id);
746 edit_uint64(pwd_id, pathid);
748 int len = strlen(pattern);
749 query.check_size(len*2+1);
750 db_escape_string(jcr, db, query.c_str(), pattern, len);
751 Mmsg(filter, " AND Filename.Name %s '%s' ", match_query[db_get_type_index(db)], query.c_str());
754 build_ls_files_query(db, query,
755 jobids, pathid, filter.c_str(),
758 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
761 db_sql_query(db, query.c_str(), list_entries, user_data);
762 nb_record = sql_num_rows(db);
765 return nb_record == limit;
770 * Return next Id from comma separated list
773 * 1 if next Id returned
774 * 0 if no more Ids are in list
775 * -1 there is an error
776 * TODO: merge with get_next_jobid_from_list() and get_next_dbid_from_list()
778 static int get_next_id_from_list(char **p, int64_t *Id)
780 const int maxlen = 30;
785 for (int i=0; i<maxlen; i++) {
788 } else if (*q == ',') {
797 } else if (!is_a_number(id)) {
798 return -1; /* error */
801 *Id = str_to_int64(id);
805 static int get_path_handler(void *ctx, int fields, char **row)
807 POOL_MEM *buf = (POOL_MEM *) ctx;
808 pm_strcpy(*buf, row[0]);
812 static bool check_temp(char *output_table)
814 if (output_table[0] == 'b' &&
815 output_table[1] == '2' &&
816 is_an_integer(output_table + 2))
823 bool Bvfs::drop_restore_list(char *output_table)
826 if (check_temp(output_table)) {
827 Mmsg(query, "DROP TABLE %s", output_table);
828 db_sql_query(db, query.c_str(), NULL, NULL);
834 bool Bvfs::compute_restore_list(char *fileid, char *dirid, char *hardlink,
843 if ((*fileid && !is_a_number_list(fileid)) ||
844 (*dirid && !is_a_number_list(dirid)) ||
845 (*hardlink && !is_a_number_list(hardlink))||
846 (!*hardlink && !*fileid && !*dirid && !*hardlink))
850 if (!check_temp(output_table)) {
854 Mmsg(query, "CREATE TABLE btemp%s AS ", output_table);
856 if (*fileid) { /* Select files with their direct id */
858 Mmsg(tmp,"SELECT JobId, JobTDate, FileIndex, FilenameId, PathId, FileId "
859 "FROM File JOIN Job USING (JobId) WHERE FileId IN (%s)",
861 pm_strcat(query, tmp.c_str());
864 /* Add a directory content */
865 while (get_next_id_from_list(&dirid, &id) == 1) {
866 Mmsg(tmp, "SELECT Path FROM Path WHERE PathId=%lld", id);
868 if (!db_sql_query(db, tmp.c_str(), get_path_handler, (void *)&tmp2)) {
869 Dmsg0(dbglevel, "Can't search for path\n");
873 if (!strcmp(tmp2.c_str(), "")) { /* path not found */
874 Dmsg3(dbglevel, "Path not found %lld q=%s s=%s\n",
875 id, tmp.c_str(), tmp2.c_str());
878 /* escape % and _ for LIKE search */
879 tmp.check_size((strlen(tmp2.c_str())+1) * 2);
880 char *p = tmp.c_str();
881 for (char *s = tmp2.c_str(); *s ; s++) {
882 if (*s == '%' || *s == '_' || *s == '\\') {
892 size_t len = strlen(tmp.c_str());
893 tmp2.check_size((len+1) * 2);
894 db_escape_string(jcr, db, tmp2.c_str(), tmp.c_str(), len);
897 query.strcat(" UNION ");
900 Mmsg(tmp, "SELECT JobId, JobTDate, File.FileIndex, File.FilenameId, "
901 "File.PathId, FileId "
902 "FROM Path JOIN File USING (PathId) JOIN Job USING (JobId) "
903 "WHERE Path.Path LIKE '%s' AND File.JobId IN (%s) ",
904 tmp2.c_str(), jobids);
905 query.strcat(tmp.c_str());
908 query.strcat(" UNION ");
910 /* A directory can have files from a BaseJob */
911 Mmsg(tmp, "SELECT File.JobId, JobTDate, BaseFiles.FileIndex, "
912 "File.FilenameId, File.PathId, BaseFiles.FileId "
914 "JOIN File USING (FileId) "
915 "JOIN Job ON (BaseFiles.JobId = Job.JobId) "
916 "JOIN Path USING (PathId) "
917 "WHERE Path.Path LIKE '%s' AND BaseFiles.JobId IN (%s) ",
918 tmp2.c_str(), jobids);
919 query.strcat(tmp.c_str());
922 /* expect jobid,fileindex */
923 int64_t prev_jobid=0;
924 while (get_next_id_from_list(&hardlink, &jobid) == 1) {
925 if (get_next_id_from_list(&hardlink, &id) != 1) {
926 Dmsg0(dbglevel, "hardlink should be two by two\n");
929 if (jobid != prev_jobid) { /* new job */
930 if (prev_jobid == 0) { /* first jobid */
932 query.strcat(" UNION ");
934 } else { /* end last job, start new one */
935 tmp.strcat(") UNION ");
936 query.strcat(tmp.c_str());
938 Mmsg(tmp, "SELECT JobId, JobTDate, FileIndex, FilenameId, "
940 "FROM File JOIN Job USING (JobId) WHERE JobId = %lld "
941 "AND FileIndex IN (%lld", jobid, id);
944 } else { /* same job, add new findex */
945 Mmsg(tmp2, ", %lld", id);
946 tmp.strcat(tmp2.c_str());
950 if (prev_jobid != 0) { /* end last job */
952 query.strcat(tmp.c_str());
956 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
958 if (!db_sql_query(db, query.c_str(), NULL, NULL)) {
959 Dmsg0(dbglevel, "Can't execute q\n");
963 /* TODO: handle basejob and SQLite3 */
964 Mmsg(query, sql_bvfs_select[db_get_type_index(db)], output_table, output_table);
966 /* TODO: handle jobid filter */
967 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
968 if (!db_sql_query(db, query.c_str(), NULL, NULL)) {
969 Dmsg0(dbglevel, "Can't execute q\n");
974 if (db_get_type_index(db) == SQL_TYPE_MYSQL) {
975 Mmsg(query, "CREATE INDEX idx_%s ON b2%s (JobId)",
976 output_table, output_table);
982 Mmsg(query, "DROP TABLE btemp%s", output_table);
983 db_sql_query(db, query.c_str(), NULL, NULL);
987 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL || HAVE_INGRES || HAVE_DBI */