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 /* windows directory / */
203 if (len == 2 && B_ISALPHA(path[0])
211 if (len >= 0 && path[len] == '/') { /* if directory, skip last / */
217 while (p > path && !IsPathSeparator(*p)) {
225 /* Return the basename of the with the trailing /
226 * TODO: see in the rest of bacula if we don't have
227 * this function already
229 char *bvfs_basename_dir(char *path)
232 int len = strlen(path) - 1;
234 if (path[len] == '/') { /* if directory, skip last / */
240 while (p > path && !IsPathSeparator(*p)) {
244 p++; /* skip first / */
250 static void build_path_hierarchy(JCR *jcr, B_DB *mdb,
251 pathid_cache &ppathid_cache,
252 char *org_pathid, char *path)
254 Dmsg1(dbglevel, "build_path_hierarchy(%s)\n", path);
257 char *bkp = mdb->path;
258 strncpy(pathid, org_pathid, sizeof(pathid));
260 /* Does the ppathid exist for this ? we use a memory cache... In order to
261 * avoid the full loop, we consider that if a dir is allready in the
262 * PathHierarchy table, then there is no need to calculate all the
265 while (path && *path)
267 if (!ppathid_cache.lookup(pathid))
270 "SELECT PPathId FROM PathHierarchy WHERE PathId = %s",
273 QUERY_DB(jcr, mdb, mdb->cmd);
274 /* Do we have a result ? */
275 if (sql_num_rows(mdb) > 0) {
276 ppathid_cache.insert(pathid);
277 /* This dir was in the db ...
278 * It means we can leave, the tree has allready been built for
283 /* search or create parent PathId in Path table */
284 mdb->path = bvfs_parent_dir(path);
285 mdb->pnl = strlen(mdb->path);
286 if (!db_create_path_record(jcr, mdb, &parent)) {
289 ppathid_cache.insert(pathid);
292 "INSERT INTO PathHierarchy (PathId, PPathId) "
294 pathid, (uint64_t) parent.PathId);
296 INSERT_DB(jcr, mdb, mdb->cmd);
298 edit_uint64(parent.PathId, pathid);
299 path = mdb->path; /* already done */
302 /* It's already in the cache. We can leave, no time to waste here,
303 * all the parent dirs have allready been done
315 * Internal function to update path_hierarchy cache with a shared pathid cache
317 static void update_path_hierarchy_cache(JCR *jcr,
319 pathid_cache &ppathid_cache,
322 Dmsg0(dbglevel, "update_path_hierarchy_cache()\n");
326 edit_uint64(JobId, jobid);
329 db_start_transaction(jcr, mdb);
331 Mmsg(mdb->cmd, "SELECT 1 FROM Job WHERE JobId = %s AND HasCache=1", jobid);
333 if (!QUERY_DB(jcr, mdb, mdb->cmd) || sql_num_rows(mdb) > 0) {
334 Dmsg1(dbglevel, "already computed %d\n", (uint32_t)JobId );
338 /* Inserting path records for JobId */
339 Mmsg(mdb->cmd, "INSERT INTO PathVisibility (PathId, JobId) "
340 "SELECT DISTINCT PathId, JobId "
341 "FROM (SELECT PathId, JobId FROM File WHERE JobId = %s "
343 "SELECT PathId, BaseFiles.JobId "
344 "FROM BaseFiles JOIN File AS F USING (FileId) "
345 "WHERE BaseFiles.JobId = %s) AS B",
347 QUERY_DB(jcr, mdb, mdb->cmd);
349 /* Now we have to do the directory recursion stuff to determine missing
350 * visibility We try to avoid recursion, to be as fast as possible We also
351 * only work on not allready hierarchised directories...
354 "SELECT PathVisibility.PathId, Path "
355 "FROM PathVisibility "
356 "JOIN Path ON( PathVisibility.PathId = Path.PathId) "
357 "LEFT JOIN PathHierarchy "
358 "ON (PathVisibility.PathId = PathHierarchy.PathId) "
359 "WHERE PathVisibility.JobId = %s "
360 "AND PathHierarchy.PathId IS NULL "
361 "ORDER BY Path", jobid);
362 Dmsg1(dbglevel_sql, "q=%s\n", mdb->cmd);
363 QUERY_DB(jcr, mdb, mdb->cmd);
365 /* TODO: I need to reuse the DB connection without emptying the result
366 * So, now i'm copying the result in memory to be able to query the
367 * catalog descriptor again.
369 num = sql_num_rows(mdb);
371 char **result = (char **)malloc (num * 2 * sizeof(char *));
375 while((row = sql_fetch_row(mdb))) {
376 result[i++] = bstrdup(row[0]);
377 result[i++] = bstrdup(row[1]);
382 build_path_hierarchy(jcr, mdb, ppathid_cache, result[i], result[i+1]);
390 if (mdb->db_get_type_index() == SQL_TYPE_SQLITE3) {
392 "INSERT INTO PathVisibility (PathId, JobId) "
393 "SELECT DISTINCT h.PPathId AS PathId, %s "
394 "FROM PathHierarchy AS h "
395 "WHERE h.PathId IN (SELECT PathId FROM PathVisibility WHERE JobId=%s) "
396 "AND h.PPathId NOT IN (SELECT PathId FROM PathVisibility WHERE JobId=%s)",
397 jobid, jobid, jobid );
401 "INSERT INTO PathVisibility (PathId, JobId) "
402 "SELECT a.PathId,%s "
404 "SELECT DISTINCT h.PPathId AS PathId "
405 "FROM PathHierarchy AS h "
406 "JOIN PathVisibility AS p ON (h.PathId=p.PathId) "
407 "WHERE p.JobId=%s) AS a LEFT JOIN "
409 "FROM PathVisibility "
410 "WHERE JobId=%s) AS b ON (a.PathId = b.PathId) "
411 "WHERE b.PathId IS NULL", jobid, jobid, jobid);
415 QUERY_DB(jcr, mdb, mdb->cmd);
416 } while (sql_affected_rows(mdb) > 0);
418 Mmsg(mdb->cmd, "UPDATE Job SET HasCache=1 WHERE JobId=%s", jobid);
419 UPDATE_DB(jcr, mdb, mdb->cmd);
422 db_end_transaction(jcr, mdb);
427 * Find an store the filename descriptor for empty directories Filename.Name=''
429 DBId_t Bvfs::get_dir_filenameid()
432 if (dir_filenameid) {
433 return dir_filenameid;
436 Mmsg(q, "SELECT FilenameId FROM Filename WHERE Name = ''");
437 db_sql_query(db, q.c_str(), db_int_handler, &id);
439 return dir_filenameid;
442 void bvfs_update_cache(JCR *jcr, B_DB *mdb)
445 db_list_ctx jobids_list;
448 db_start_transaction(jcr, mdb);
451 /* TODO: Remove this code when updating make_bacula_table script */
452 Mmsg(mdb->cmd, "SELECT 1 FROM Job WHERE HasCache<>2 LIMIT 1");
453 if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
454 Dmsg0(dbglevel, "Creating cache table\n");
455 Mmsg(mdb->cmd, "ALTER TABLE Job ADD HasCache int DEFAULT 0");
456 QUERY_DB(jcr, mdb, mdb->cmd);
459 "CREATE TABLE PathHierarchy ( "
460 "PathId integer NOT NULL, "
461 "PPathId integer NOT NULL, "
462 "CONSTRAINT pathhierarchy_pkey "
463 "PRIMARY KEY (PathId))");
464 QUERY_DB(jcr, mdb, mdb->cmd);
467 "CREATE INDEX pathhierarchy_ppathid "
468 "ON PathHierarchy (PPathId)");
469 QUERY_DB(jcr, mdb, mdb->cmd);
472 "CREATE TABLE PathVisibility ("
473 "PathId integer NOT NULL, "
474 "JobId integer NOT NULL, "
475 "Size int8 DEFAULT 0, "
476 "Files int4 DEFAULT 0, "
477 "CONSTRAINT pathvisibility_pkey "
478 "PRIMARY KEY (JobId, PathId))");
479 QUERY_DB(jcr, mdb, mdb->cmd);
482 "CREATE INDEX pathvisibility_jobid "
483 "ON PathVisibility (JobId)");
484 QUERY_DB(jcr, mdb, mdb->cmd);
490 "SELECT JobId from Job "
491 "WHERE HasCache = 0 "
492 "AND Type IN ('B') AND JobStatus IN ('T', 'f', 'A') "
495 db_sql_query(mdb, mdb->cmd, db_list_handler, &jobids_list);
497 bvfs_update_path_hierarchy_cache(jcr, mdb, jobids_list.list);
499 db_end_transaction(jcr, mdb);
500 db_start_transaction(jcr, mdb);
501 Dmsg0(dbglevel, "Cleaning pathvisibility\n");
503 "DELETE FROM PathVisibility "
505 "(SELECT 1 FROM Job WHERE JobId=PathVisibility.JobId)");
506 nb = DELETE_DB(jcr, mdb, mdb->cmd);
507 Dmsg1(dbglevel, "Affected row(s) = %d\n", nb);
509 db_end_transaction(jcr, mdb);
514 * Update the bvfs cache for given jobids (1,2,3,4)
517 bvfs_update_path_hierarchy_cache(JCR *jcr, B_DB *mdb, char *jobids)
519 pathid_cache ppathid_cache;
524 int stat = get_next_jobid_from_list(&p, &JobId);
531 Dmsg1(dbglevel, "Updating cache for %lld\n", (uint64_t)JobId);
532 update_path_hierarchy_cache(jcr, mdb, ppathid_cache, JobId);
537 * Update the bvfs cache for current jobids
539 void Bvfs::update_cache()
541 bvfs_update_path_hierarchy_cache(jcr, db, jobids);
544 /* Change the current directory, returns true if the path exists */
545 bool Bvfs::ch_dir(const char *path)
547 pm_strcpy(db->path, path);
548 db->pnl = strlen(db->path);
549 ch_dir(db_get_path_record(jcr, db));
554 * Get all file versions for a specified client
555 * TODO: Handle basejobs using different client
557 void Bvfs::get_all_file_versions(DBId_t pathid, DBId_t fnid, const char *client)
559 Dmsg3(dbglevel, "get_all_file_versions(%lld, %lld, %s)\n", (uint64_t)pathid,
560 (uint64_t)fnid, client);
561 char ed1[50], ed2[50];
564 Mmsg(q, " AND Job.Type IN ('C', 'B') ");
566 Mmsg(q, " AND Job.Type = 'B' ");
572 "SELECT 'V', File.PathId, File.FilenameId, File.Md5, "
574 "File.JobId, File.LStat, File.FileId, "
576 "Media.VolumeName, Media.InChanger "
577 "FROM File, Job, Client, JobMedia, Media "
578 "WHERE File.FilenameId = %s "
579 "AND File.PathId=%s "
580 "AND File.JobId = Job.JobId "
581 "AND Job.JobId = JobMedia.JobId "
582 "AND File.FileIndex >= JobMedia.FirstIndex "
583 "AND File.FileIndex <= JobMedia.LastIndex "
584 "AND JobMedia.MediaId = Media.MediaId "
585 "AND Job.ClientId = Client.ClientId "
586 "AND Client.Name = '%s' "
587 "%s ORDER BY FileId LIMIT %d OFFSET %d"
588 ,edit_uint64(fnid, ed1), edit_uint64(pathid, ed2), client, q.c_str(),
590 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
591 db_sql_query(db, query.c_str(), list_entries, user_data);
594 DBId_t Bvfs::get_root()
597 return db_get_path_record(jcr, db);
600 static int path_handler(void *ctx, int fields, char **row)
602 Bvfs *fs = (Bvfs *) ctx;
603 return fs->_handle_path(ctx, fields, row);
606 int Bvfs::_handle_path(void *ctx, int fields, char **row)
608 if (bvfs_is_dir(row)) {
609 /* can have the same path 2 times */
610 if (strcmp(row[BVFS_Name], prev_dir)) {
611 pm_strcpy(prev_dir, row[BVFS_Name]);
612 return list_entries(user_data, fields, row);
619 * Retrieve . and .. information
621 void Bvfs::ls_special_dirs()
623 Dmsg1(dbglevel, "ls_special_dirs(%lld)\n", (uint64_t)pwd_id);
624 char ed1[50], ed2[50];
628 if (!dir_filenameid) {
629 get_dir_filenameid();
632 /* Will fetch directories */
637 "(SELECT PPathId AS PathId, '..' AS Path "
638 "FROM PathHierarchy "
641 "SELECT %s AS PathId, '.' AS Path)",
642 edit_uint64(pwd_id, ed1), ed1);
645 Mmsg(query2,// 1 2 3 4 5 6
646 "SELECT 'D', tmp.PathId, 0, tmp.Path, JobId, LStat, FileId "
647 "FROM %s AS tmp LEFT JOIN ( " // get attributes if any
648 "SELECT File1.PathId AS PathId, File1.JobId AS JobId, "
649 "File1.LStat AS LStat, File1.FileId AS FileId FROM File AS File1 "
650 "WHERE File1.FilenameId = %s "
651 "AND File1.JobId IN (%s)) AS listfile1 "
652 "ON (tmp.PathId = listfile1.PathId) "
653 "ORDER BY tmp.Path, JobId DESC ",
654 query.c_str(), edit_uint64(dir_filenameid, ed2), jobids);
656 Dmsg1(dbglevel_sql, "q=%s\n", query2.c_str());
657 db_sql_query(db, query2.c_str(), path_handler, this);
660 /* Returns true if we have dirs to read */
663 Dmsg1(dbglevel, "ls_dirs(%lld)\n", (uint64_t)pwd_id);
664 char ed1[50], ed2[50];
672 Mmsg(filter, " AND Path2.Path %s '%s' ",
673 match_query[db_get_type_index(db)], pattern);
676 if (!dir_filenameid) {
677 get_dir_filenameid();
680 /* the sql query displays same directory multiple time, take the first one */
683 /* Let's retrieve the list of the visible dirs in this dir ...
684 * First, I need the empty filenameid to locate efficiently
685 * the dirs in the file table
686 * my $dir_filenameid = $self->get_dir_filenameid();
688 /* Then we get all the dir entries from File ... */
691 "SELECT 'D', PathId, 0, Path, JobId, LStat, FileId FROM ( "
692 "SELECT Path1.PathId AS PathId, Path1.Path AS Path, "
693 "lower(Path1.Path) AS lpath, "
694 "listfile1.JobId AS JobId, listfile1.LStat AS LStat, "
695 "listfile1.FileId AS FileId "
697 "SELECT DISTINCT PathHierarchy1.PathId AS PathId "
698 "FROM PathHierarchy AS PathHierarchy1 "
699 "JOIN Path AS Path2 "
700 "ON (PathHierarchy1.PathId = Path2.PathId) "
701 "JOIN PathVisibility AS PathVisibility1 "
702 "ON (PathHierarchy1.PathId = PathVisibility1.PathId) "
703 "WHERE PathHierarchy1.PPathId = %s "
704 "AND PathVisibility1.JobId IN (%s) "
707 "JOIN Path AS Path1 ON (listpath1.PathId = Path1.PathId) "
709 "LEFT JOIN ( " /* get attributes if any */
710 "SELECT File1.PathId AS PathId, File1.JobId AS JobId, "
711 "File1.LStat AS LStat, File1.FileId AS FileId FROM File AS File1 "
712 "WHERE File1.FilenameId = %s "
713 "AND File1.JobId IN (%s)) AS listfile1 "
714 "ON (listpath1.PathId = listfile1.PathId) "
715 ") AS A ORDER BY 2,3 DESC LIMIT %d OFFSET %d",
716 edit_uint64(pwd_id, ed1),
719 edit_uint64(dir_filenameid, ed2),
723 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
726 db_sql_query(db, query.c_str(), path_handler, this);
727 nb_record = sql_num_rows(db);
730 return nb_record == limit;
733 void build_ls_files_query(B_DB *db, POOL_MEM &query,
734 const char *JobId, const char *PathId,
735 const char *filter, int64_t limit, int64_t offset)
737 if (db_get_type_index(db) == SQL_TYPE_POSTGRESQL) {
738 Mmsg(query, sql_bvfs_list_files[db_get_type_index(db)],
739 JobId, PathId, JobId, PathId,
740 filter, limit, offset);
742 Mmsg(query, sql_bvfs_list_files[db_get_type_index(db)],
743 JobId, PathId, JobId, PathId,
744 limit, offset, filter, JobId, JobId);
748 /* Returns true if we have files to read */
749 bool Bvfs::ls_files()
755 Dmsg1(dbglevel, "ls_files(%lld)\n", (uint64_t)pwd_id);
764 edit_uint64(pwd_id, pathid);
766 Mmsg(filter, " AND Filename.Name %s '%s' ",
767 match_query[db_get_type_index(db)], pattern);
770 build_ls_files_query(db, query,
771 jobids, pathid, filter.c_str(),
774 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
777 db_sql_query(db, query.c_str(), list_entries, user_data);
778 nb_record = sql_num_rows(db);
781 return nb_record == limit;
786 * Return next Id from comma separated list
789 * 1 if next Id returned
790 * 0 if no more Ids are in list
791 * -1 there is an error
792 * TODO: merge with get_next_jobid_from_list() and get_next_dbid_from_list()
794 static int get_next_id_from_list(char **p, int64_t *Id)
796 const int maxlen = 30;
801 for (int i=0; i<maxlen; i++) {
804 } else if (*q == ',') {
813 } else if (!is_a_number(id)) {
814 return -1; /* error */
817 *Id = str_to_int64(id);
821 static int get_path_handler(void *ctx, int fields, char **row)
823 POOL_MEM *buf = (POOL_MEM *) ctx;
824 pm_strcpy(*buf, row[0]);
828 static bool check_temp(char *output_table)
830 if (output_table[0] == 'b' &&
831 output_table[1] == '2' &&
832 is_an_integer(output_table + 2))
839 void Bvfs::clear_cache()
841 db_sql_query(db, "BEGIN", NULL, NULL);
842 db_sql_query(db, "UPDATE Job SET HasCache=0", NULL, NULL);
843 db_sql_query(db, "TRUNCATE PathHierarchy", NULL, NULL);
844 db_sql_query(db, "TRUNCATE PathVisibility", NULL, NULL);
845 db_sql_query(db, "COMMIT", NULL, NULL);
848 bool Bvfs::drop_restore_list(char *output_table)
851 if (check_temp(output_table)) {
852 Mmsg(query, "DROP TABLE %s", output_table);
853 db_sql_query(db, query.c_str(), NULL, NULL);
859 bool Bvfs::compute_restore_list(char *fileid, char *dirid, char *hardlink,
868 if ((*fileid && !is_a_number_list(fileid)) ||
869 (*dirid && !is_a_number_list(dirid)) ||
870 (*hardlink && !is_a_number_list(hardlink))||
871 (!*hardlink && !*fileid && !*dirid && !*hardlink))
875 if (!check_temp(output_table)) {
879 Mmsg(query, "CREATE TABLE btemp%s AS ", output_table);
881 if (*fileid) { /* Select files with their direct id */
883 Mmsg(tmp,"SELECT JobId, JobTDate, FileIndex, FilenameId, PathId, FileId "
884 "FROM File JOIN Job USING (JobId) WHERE FileId IN (%s)",
886 pm_strcat(query, tmp.c_str());
889 /* Add a directory content */
890 while (get_next_id_from_list(&dirid, &id) == 1) {
891 Mmsg(tmp, "SELECT Path FROM Path WHERE PathId=%lld", id);
893 if (!db_sql_query(db, tmp.c_str(), get_path_handler, (void *)&tmp2)) {
894 Dmsg0(dbglevel, "Can't search for path\n");
898 if (!strcmp(tmp2.c_str(), "")) { /* path not found */
899 Dmsg3(dbglevel, "Path not found %lld q=%s s=%s\n",
900 id, tmp.c_str(), tmp2.c_str());
903 /* escape % and _ for LIKE search */
904 tmp.check_size((strlen(tmp2.c_str())+1) * 2);
905 char *p = tmp.c_str();
906 for (char *s = tmp2.c_str(); *s ; s++) {
907 if (*s == '%' || *s == '_' || *s == '\\') {
917 size_t len = strlen(tmp.c_str());
918 tmp2.check_size((len+1) * 2);
919 db_escape_string(jcr, db, tmp2.c_str(), tmp.c_str(), len);
922 query.strcat(" UNION ");
925 Mmsg(tmp, "SELECT JobId, JobTDate, File.FileIndex, File.FilenameId, "
926 "File.PathId, FileId "
927 "FROM Path JOIN File USING (PathId) JOIN Job USING (JobId) "
928 "WHERE Path.Path LIKE '%s' AND File.JobId IN (%s) ",
929 tmp2.c_str(), jobids);
930 query.strcat(tmp.c_str());
933 query.strcat(" UNION ");
935 /* A directory can have files from a BaseJob */
936 Mmsg(tmp, "SELECT File.JobId, JobTDate, BaseFiles.FileIndex, "
937 "File.FilenameId, File.PathId, BaseFiles.FileId "
939 "JOIN File USING (FileId) "
940 "JOIN Job ON (BaseFiles.JobId = Job.JobId) "
941 "JOIN Path USING (PathId) "
942 "WHERE Path.Path LIKE '%s' AND BaseFiles.JobId IN (%s) ",
943 tmp2.c_str(), jobids);
944 query.strcat(tmp.c_str());
947 /* expect jobid,fileindex */
948 int64_t prev_jobid=0;
949 while (get_next_id_from_list(&hardlink, &jobid) == 1) {
950 if (get_next_id_from_list(&hardlink, &id) != 1) {
951 Dmsg0(dbglevel, "hardlink should be two by two\n");
954 if (jobid != prev_jobid) { /* new job */
955 if (prev_jobid == 0) { /* first jobid */
957 query.strcat(" UNION ");
959 } else { /* end last job, start new one */
960 tmp.strcat(") UNION ");
961 query.strcat(tmp.c_str());
963 Mmsg(tmp, "SELECT JobId, JobTDate, FileIndex, FilenameId, "
965 "FROM File JOIN Job USING (JobId) WHERE JobId = %lld "
966 "AND FileIndex IN (%lld", jobid, id);
969 } else { /* same job, add new findex */
970 Mmsg(tmp2, ", %lld", id);
971 tmp.strcat(tmp2.c_str());
975 if (prev_jobid != 0) { /* end last job */
977 query.strcat(tmp.c_str());
981 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
983 if (!db_sql_query(db, query.c_str(), NULL, NULL)) {
984 Dmsg0(dbglevel, "Can't execute q\n");
988 /* TODO: handle basejob and SQLite3 */
989 Mmsg(query, sql_bvfs_select[db_get_type_index(db)], output_table, output_table);
991 /* TODO: handle jobid filter */
992 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
993 if (!db_sql_query(db, query.c_str(), NULL, NULL)) {
994 Dmsg0(dbglevel, "Can't execute q\n");
999 if (db_get_type_index(db) == SQL_TYPE_MYSQL) {
1000 Mmsg(query, "CREATE INDEX idx_%s ON b2%s (JobId)",
1001 output_table, output_table);
1002 Dmsg1(dbglevel_sql, "q=%s\n", query.c_str());
1003 if (!db_sql_query(db, query.c_str(), NULL, NULL)) {
1004 Dmsg0(dbglevel, "Can't execute q\n");
1012 Mmsg(query, "DROP TABLE btemp%s", output_table);
1013 db_sql_query(db, query.c_str(), NULL, NULL);
1017 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_POSTGRESQL || HAVE_INGRES || HAVE_DBI */