]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/sql_create.c
Cleanup new timeout code for bconsole
[bacula/bacula] / bacula / src / cats / sql_create.c
1 /*
2    Bacula® - The Network Backup Solution
3
4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
5
6    The main author of Bacula is Kern Sibbald, with contributions from
7    many others, a complete list can be found in the file AUTHORS.
8    This program is Free Software; you can redistribute it and/or
9    modify it under the terms of version two of the GNU General Public
10    License as published by the Free Software Foundation and included
11    in the file LICENSE.
12
13    This program is distributed in the hope that it will be useful, but
14    WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16    General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21    02110-1301, USA.
22
23    Bacula® is a registered trademark of Kern Sibbald.
24    The licensor of Bacula is the Free Software Foundation Europe
25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26    Switzerland, email:ftf@fsfeurope.org.
27 */
28 /*
29  * Bacula Catalog Database Create record interface routines
30  *
31  *    Kern Sibbald, March 2000
32  *
33  *    Version $Id$
34  */
35
36 /* The following is necessary so that we do not include
37  * the dummy external definition of DB.
38  */
39 #define __SQL_C                       /* indicate that this is sql.c */
40
41 #include "bacula.h"
42 #include "cats.h"
43
44 static const int dbglevel = 500;
45
46 #if    HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL || HAVE_DBI
47
48 /* -----------------------------------------------------------------------
49  *
50  *   Generic Routines (or almost generic)
51  *
52  * -----------------------------------------------------------------------
53  */
54
55 /* Forward referenced subroutines */
56 #ifndef HAVE_BATCH_FILE_INSERT
57 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
58 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar);
59 #endif /* HAVE_BATCH_FILE_INSERT */
60
61
62 /* Create a new record for the Job
63  * Returns: false on failure
64  *          true  on success
65  */
66 bool
67 db_create_job_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
68 {
69    char dt[MAX_TIME_LENGTH];
70    time_t stime;
71    struct tm tm;
72    bool ok;
73    utime_t JobTDate;
74    char ed1[30],ed2[30];
75
76    db_lock(mdb);
77
78    stime = jr->SchedTime;
79    ASSERT(stime != 0);
80
81    (void)localtime_r(&stime, &tm);
82    strftime(dt, sizeof(dt), "%Y-%m-%d %H:%M:%S", &tm);
83    JobTDate = (utime_t)stime;
84
85    /* Must create it */
86    Mmsg(mdb->cmd,
87 "INSERT INTO Job (Job,Name,Type,Level,JobStatus,SchedTime,JobTDate,ClientId) "
88 "VALUES ('%s','%s','%c','%c','%c','%s',%s,%s)",
89            jr->Job, jr->Name, (char)(jr->JobType), (char)(jr->JobLevel),
90            (char)(jr->JobStatus), dt, edit_uint64(JobTDate, ed1),
91            edit_int64(jr->ClientId, ed2));
92
93    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
94       Mmsg2(&mdb->errmsg, _("Create DB Job record %s failed. ERR=%s\n"),
95             mdb->cmd, sql_strerror(mdb));
96       jr->JobId = 0;
97       ok = false;
98    } else {
99       jr->JobId = sql_insert_id(mdb, NT_("Job"));
100       ok = true;
101    }
102    db_unlock(mdb);
103    return ok;
104 }
105
106
107 /* Create a JobMedia record for medium used this job
108  * Returns: false on failure
109  *          true  on success
110  */
111 bool
112 db_create_jobmedia_record(JCR *jcr, B_DB *mdb, JOBMEDIA_DBR *jm)
113 {
114    bool ok = true;
115    int count;
116    char ed1[50], ed2[50];
117
118    db_lock(mdb);
119
120    /* Now get count for VolIndex */
121    Mmsg(mdb->cmd, "SELECT count(*) from JobMedia WHERE JobId=%s",
122         edit_int64(jm->JobId, ed1));
123    count = get_sql_record_max(jcr, mdb);
124    if (count < 0) {
125       count = 0;
126    }
127    count++;
128
129    /* Note, jm->Strip is not used and is not likely to be used
130     * in the near future, so I have removed it from the insert
131     * to save space in the DB. KES June 2006.
132     */
133    Mmsg(mdb->cmd,
134         "INSERT INTO JobMedia (JobId,MediaId,FirstIndex,LastIndex,"
135         "StartFile,EndFile,StartBlock,EndBlock,VolIndex,Copy) "
136         "VALUES (%s,%s,%u,%u,%u,%u,%u,%u,%u,%u)",
137         edit_int64(jm->JobId, ed1),
138         edit_int64(jm->MediaId, ed2),
139         jm->FirstIndex, jm->LastIndex,
140         jm->StartFile, jm->EndFile, jm->StartBlock, jm->EndBlock,count,
141         jm->Copy);
142
143    Dmsg0(300, mdb->cmd);
144    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
145       Mmsg2(&mdb->errmsg, _("Create JobMedia record %s failed: ERR=%s\n"), mdb->cmd,
146          sql_strerror(mdb));
147       ok = false;
148    } else {
149       /* Worked, now update the Media record with the EndFile and EndBlock */
150       Mmsg(mdb->cmd,
151            "UPDATE Media SET EndFile=%u, EndBlock=%u WHERE MediaId=%u",
152            jm->EndFile, jm->EndBlock, jm->MediaId);
153       if (!UPDATE_DB(jcr, mdb, mdb->cmd)) {
154          Mmsg2(&mdb->errmsg, _("Update Media record %s failed: ERR=%s\n"), mdb->cmd,
155               sql_strerror(mdb));
156          ok = false;
157       }
158    }
159    db_unlock(mdb);
160    Dmsg0(300, "Return from JobMedia\n");
161    return ok;
162 }
163
164 /* Create Unique Pool record
165  * Returns: false on failure
166  *          true  on success
167  */
168 bool
169 db_create_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
170 {
171    bool stat;        
172    char ed1[30], ed2[30], ed3[50], ed4[50], ed5[50];
173
174    Dmsg0(200, "In create pool\n");
175    db_lock(mdb);
176    Mmsg(mdb->cmd, "SELECT PoolId,Name FROM Pool WHERE Name='%s'", pr->Name);
177    Dmsg1(200, "selectpool: %s\n", mdb->cmd);
178
179    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
180       mdb->num_rows = sql_num_rows(mdb);
181       if (mdb->num_rows > 0) {
182          Mmsg1(&mdb->errmsg, _("pool record %s already exists\n"), pr->Name);
183          sql_free_result(mdb);
184          db_unlock(mdb);
185          return false;
186       }
187       sql_free_result(mdb);
188    }
189
190    /* Must create it */
191    Mmsg(mdb->cmd,
192 "INSERT INTO Pool (Name,NumVols,MaxVols,UseOnce,UseCatalog,"
193 "AcceptAnyVolume,AutoPrune,Recycle,VolRetention,VolUseDuration,"
194 "MaxVolJobs,MaxVolFiles,MaxVolBytes,PoolType,LabelType,LabelFormat,"
195 "RecyclePoolId,ScratchPoolId) "
196 "VALUES ('%s',%u,%u,%d,%d,%d,%d,%d,%s,%s,%u,%u,%s,'%s',%d,'%s',%s,%s)",
197                   pr->Name,
198                   pr->NumVols, pr->MaxVols,
199                   pr->UseOnce, pr->UseCatalog,
200                   pr->AcceptAnyVolume,
201                   pr->AutoPrune, pr->Recycle,
202                   edit_uint64(pr->VolRetention, ed1),
203                   edit_uint64(pr->VolUseDuration, ed2),
204                   pr->MaxVolJobs, pr->MaxVolFiles,
205                   edit_uint64(pr->MaxVolBytes, ed3),
206                   pr->PoolType, pr->LabelType, pr->LabelFormat,
207                   edit_int64(pr->RecyclePoolId,ed4),
208                   edit_int64(pr->ScratchPoolId,ed5));
209    Dmsg1(200, "Create Pool: %s\n", mdb->cmd);
210    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
211       Mmsg2(&mdb->errmsg, _("Create db Pool record %s failed: ERR=%s\n"),
212             mdb->cmd, sql_strerror(mdb));
213       pr->PoolId = 0;
214       stat = false;
215    } else {
216       pr->PoolId = sql_insert_id(mdb, NT_("Pool"));
217       stat = true;
218    }
219    db_unlock(mdb);
220    return stat;
221 }
222
223 /*
224  * Create Unique Device record
225  * Returns: false on failure
226  *          true  on success
227  */
228 bool
229 db_create_device_record(JCR *jcr, B_DB *mdb, DEVICE_DBR *dr)
230 {
231    bool ok;
232    char ed1[30], ed2[30];
233
234    Dmsg0(200, "In create Device\n");
235    db_lock(mdb);
236    Mmsg(mdb->cmd, "SELECT DeviceId,Name FROM Device WHERE Name='%s'", dr->Name);
237    Dmsg1(200, "selectdevice: %s\n", mdb->cmd);
238
239    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
240       mdb->num_rows = sql_num_rows(mdb);
241       if (mdb->num_rows > 0) {
242          Mmsg1(&mdb->errmsg, _("Device record %s already exists\n"), dr->Name);
243          sql_free_result(mdb);
244          db_unlock(mdb);
245          return false;
246       }
247       sql_free_result(mdb);
248    }
249
250    /* Must create it */
251    Mmsg(mdb->cmd,
252 "INSERT INTO Device (Name,MediaTypeId,StorageId) VALUES ('%s',%s,%s)",
253                   dr->Name,
254                   edit_uint64(dr->MediaTypeId, ed1),
255                   edit_int64(dr->StorageId, ed2));
256    Dmsg1(200, "Create Device: %s\n", mdb->cmd);
257    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
258       Mmsg2(&mdb->errmsg, _("Create db Device record %s failed: ERR=%s\n"),
259             mdb->cmd, sql_strerror(mdb));
260       dr->DeviceId = 0;
261       ok = false;
262    } else {
263       dr->DeviceId = sql_insert_id(mdb, NT_("Device"));
264       ok = true;
265    }
266    db_unlock(mdb);
267    return ok;
268 }
269
270
271
272 /*
273  * Create a Unique record for Storage -- no duplicates
274  * Returns: false on failure
275  *          true  on success with id in sr->StorageId
276  */
277 bool db_create_storage_record(JCR *jcr, B_DB *mdb, STORAGE_DBR *sr)
278 {
279    SQL_ROW row;
280    bool ok;
281
282    db_lock(mdb);
283    Mmsg(mdb->cmd, "SELECT StorageId,AutoChanger FROM Storage WHERE Name='%s'", sr->Name);
284
285    sr->StorageId = 0;
286    sr->created = false;
287    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
288       mdb->num_rows = sql_num_rows(mdb);
289       /* If more than one, report error, but return first row */
290       if (mdb->num_rows > 1) {
291          Mmsg1(&mdb->errmsg, _("More than one Storage record!: %d\n"), (int)(mdb->num_rows));
292          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
293       }
294       if (mdb->num_rows >= 1) {
295          if ((row = sql_fetch_row(mdb)) == NULL) {
296             Mmsg1(&mdb->errmsg, _("error fetching Storage row: %s\n"), sql_strerror(mdb));
297             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
298             sql_free_result(mdb);
299             db_unlock(mdb);
300             return false;
301          }
302          sr->StorageId = str_to_int64(row[0]);
303          sr->AutoChanger = atoi(row[1]);   /* bool */
304          sql_free_result(mdb);
305          db_unlock(mdb);
306          return true;
307       }
308       sql_free_result(mdb);
309    }
310
311    /* Must create it */
312    Mmsg(mdb->cmd, "INSERT INTO Storage (Name,AutoChanger)"
313         " VALUES ('%s',%d)", sr->Name, sr->AutoChanger);
314
315    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
316       Mmsg2(&mdb->errmsg, _("Create DB Storage record %s failed. ERR=%s\n"),
317             mdb->cmd, sql_strerror(mdb));
318       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
319       ok = false;
320    } else {
321       sr->StorageId = sql_insert_id(mdb, NT_("Storage"));
322       sr->created = true;
323       ok = true;
324    }
325    db_unlock(mdb);
326    return ok;
327 }
328
329
330 /*
331  * Create Unique MediaType record
332  * Returns: false on failure
333  *          true  on success
334  */
335 bool
336 db_create_mediatype_record(JCR *jcr, B_DB *mdb, MEDIATYPE_DBR *mr)
337 {
338    bool stat;        
339
340    Dmsg0(200, "In create mediatype\n");
341    db_lock(mdb);
342    Mmsg(mdb->cmd, "SELECT MediaTypeId,MediaType FROM MediaType WHERE MediaType='%s'", mr->MediaType);
343    Dmsg1(200, "selectmediatype: %s\n", mdb->cmd);
344
345    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
346       mdb->num_rows = sql_num_rows(mdb);
347       if (mdb->num_rows > 0) {
348          Mmsg1(&mdb->errmsg, _("mediatype record %s already exists\n"), mr->MediaType);
349          sql_free_result(mdb);
350          db_unlock(mdb);
351          return false;
352       }
353       sql_free_result(mdb);
354    }
355
356    /* Must create it */
357    Mmsg(mdb->cmd,
358 "INSERT INTO MediaType (MediaType,ReadOnly) "
359 "VALUES ('%s',%d)",
360                   mr->MediaType,
361                   mr->ReadOnly);
362    Dmsg1(200, "Create mediatype: %s\n", mdb->cmd);
363    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
364       Mmsg2(&mdb->errmsg, _("Create db mediatype record %s failed: ERR=%s\n"),
365             mdb->cmd, sql_strerror(mdb));
366       mr->MediaTypeId = 0;
367       stat = false;
368    } else {
369       mr->MediaTypeId = sql_insert_id(mdb, NT_("MediaType"));
370       stat = true;
371    }
372    db_unlock(mdb);
373    return stat;
374 }
375
376
377 /*
378  * Create Media record. VolumeName and non-zero Slot must be unique
379  *
380  * Returns: 0 on failure
381  *          1 on success
382  */
383 int
384 db_create_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
385 {
386    int stat;
387    char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50], ed7[50], ed8[50];
388    char ed9[50], ed10[50], ed11[50], ed12[50];
389    struct tm tm;
390
391    db_lock(mdb);
392    Mmsg(mdb->cmd, "SELECT MediaId FROM Media WHERE VolumeName='%s'",
393            mr->VolumeName);
394    Dmsg1(500, "selectpool: %s\n", mdb->cmd);
395
396    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
397       mdb->num_rows = sql_num_rows(mdb);
398       if (mdb->num_rows > 0) {
399          Mmsg1(&mdb->errmsg, _("Volume \"%s\" already exists.\n"), mr->VolumeName);
400          sql_free_result(mdb);
401          db_unlock(mdb);
402          return 0;
403       }
404       sql_free_result(mdb);
405    }
406
407    /* Must create it */
408    Mmsg(mdb->cmd,
409 "INSERT INTO Media (VolumeName,MediaType,MediaTypeId,PoolId,MaxVolBytes,"
410 "VolCapacityBytes,Recycle,VolRetention,VolUseDuration,MaxVolJobs,MaxVolFiles,"
411 "VolStatus,Slot,VolBytes,InChanger,VolReadTime,VolWriteTime,VolParts,"
412 "EndFile,EndBlock,LabelType,StorageId,DeviceId,LocationId,"
413 "ScratchPoolId,RecyclePoolId,Enabled)"
414 "VALUES ('%s','%s',0,%u,%s,%s,%d,%s,%s,%u,%u,'%s',%d,%s,%d,%s,%s,%d,0,0,%d,%s,"
415 "%s,%s,%s,%s,%d)",
416           mr->VolumeName,
417           mr->MediaType, mr->PoolId,
418           edit_uint64(mr->MaxVolBytes,ed1),
419           edit_uint64(mr->VolCapacityBytes, ed2),
420           mr->Recycle,
421           edit_uint64(mr->VolRetention, ed3),
422           edit_uint64(mr->VolUseDuration, ed4),
423           mr->MaxVolJobs,
424           mr->MaxVolFiles,
425           mr->VolStatus,
426           mr->Slot,
427           edit_uint64(mr->VolBytes, ed5),
428           mr->InChanger,
429           edit_int64(mr->VolReadTime, ed6),
430           edit_int64(mr->VolWriteTime, ed7),
431           mr->VolParts,
432           mr->LabelType,
433           edit_int64(mr->StorageId, ed8), 
434           edit_int64(mr->DeviceId, ed9), 
435           edit_int64(mr->LocationId, ed10), 
436           edit_int64(mr->ScratchPoolId, ed11), 
437           edit_int64(mr->RecyclePoolId, ed12), 
438           mr->Enabled
439           );
440
441
442    Dmsg1(500, "Create Volume: %s\n", mdb->cmd);
443    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
444       Mmsg2(&mdb->errmsg, _("Create DB Media record %s failed. ERR=%s\n"),
445             mdb->cmd, sql_strerror(mdb));
446       stat = 0;
447    } else {
448       mr->MediaId = sql_insert_id(mdb, NT_("Media"));
449       stat = 1;
450       if (mr->set_label_date) {
451          char dt[MAX_TIME_LENGTH];
452          if (mr->LabelDate == 0) {
453             mr->LabelDate = time(NULL);
454          }
455          (void)localtime_r(&mr->LabelDate, &tm);
456          strftime(dt, sizeof(dt), "%Y-%m-%d %H:%M:%S", &tm);
457          Mmsg(mdb->cmd, "UPDATE Media SET LabelDate='%s' "
458               "WHERE MediaId=%d", dt, mr->MediaId);
459          stat = UPDATE_DB(jcr, mdb, mdb->cmd);
460       }
461       /*
462        * Make sure that if InChanger is non-zero any other identical slot
463        *   has InChanger zero.
464        */
465       db_make_inchanger_unique(jcr, mdb, mr);
466    }
467
468    db_unlock(mdb);
469    return stat;
470 }
471
472 /*
473  * Create a Unique record for the client -- no duplicates
474  * Returns: 0 on failure
475  *          1 on success with id in cr->ClientId
476  */
477 int db_create_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
478 {
479    SQL_ROW row;
480    int stat;
481    char ed1[50], ed2[50];
482
483    db_lock(mdb);
484    Mmsg(mdb->cmd, "SELECT ClientId,Uname FROM Client WHERE Name='%s'", cr->Name);
485
486    cr->ClientId = 0;
487    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
488       mdb->num_rows = sql_num_rows(mdb);
489       /* If more than one, report error, but return first row */
490       if (mdb->num_rows > 1) {
491          Mmsg1(&mdb->errmsg, _("More than one Client!: %d\n"), (int)(mdb->num_rows));
492          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
493       }
494       if (mdb->num_rows >= 1) {
495          if ((row = sql_fetch_row(mdb)) == NULL) {
496             Mmsg1(&mdb->errmsg, _("error fetching Client row: %s\n"), sql_strerror(mdb));
497             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
498             sql_free_result(mdb);
499             db_unlock(mdb);
500             return 0;
501          }
502          cr->ClientId = str_to_int64(row[0]);
503          if (row[1]) {
504             bstrncpy(cr->Uname, row[1], sizeof(cr->Uname));
505          } else {
506             cr->Uname[0] = 0;         /* no name */
507          }
508          sql_free_result(mdb);
509          db_unlock(mdb);
510          return 1;
511       }
512       sql_free_result(mdb);
513    }
514
515    /* Must create it */
516    Mmsg(mdb->cmd, "INSERT INTO Client (Name,Uname,AutoPrune,"
517 "FileRetention,JobRetention) VALUES "
518 "('%s','%s',%d,%s,%s)", cr->Name, cr->Uname, cr->AutoPrune,
519       edit_uint64(cr->FileRetention, ed1),
520       edit_uint64(cr->JobRetention, ed2));
521
522    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
523       Mmsg2(&mdb->errmsg, _("Create DB Client record %s failed. ERR=%s\n"),
524             mdb->cmd, sql_strerror(mdb));
525       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
526       cr->ClientId = 0;
527       stat = 0;
528    } else {
529       cr->ClientId = sql_insert_id(mdb, NT_("Client"));
530       stat = 1;
531    }
532    db_unlock(mdb);
533    return stat;
534 }
535
536
537 /* Create a Unique record for the Path -- no duplicates */
538 int db_create_path_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
539 {
540    SQL_ROW row;
541    int stat;
542
543    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->pnl+2);
544    db_escape_string(jcr, mdb, mdb->esc_name, mdb->path, mdb->pnl);
545
546    if (mdb->cached_path_id != 0 && mdb->cached_path_len == mdb->pnl &&
547        strcmp(mdb->cached_path, mdb->path) == 0) {
548       ar->PathId = mdb->cached_path_id;
549       return 1;
550    }
551
552    Mmsg(mdb->cmd, "SELECT PathId FROM Path WHERE Path='%s'", mdb->esc_name);
553
554    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
555       mdb->num_rows = sql_num_rows(mdb);
556       if (mdb->num_rows > 1) {
557          char ed1[30];
558          Mmsg2(&mdb->errmsg, _("More than one Path!: %s for path: %s\n"),
559             edit_uint64(mdb->num_rows, ed1), mdb->path);
560          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
561       }
562       /* Even if there are multiple paths, take the first one */
563       if (mdb->num_rows >= 1) {
564          if ((row = sql_fetch_row(mdb)) == NULL) {
565             Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
566             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
567             sql_free_result(mdb);
568             ar->PathId = 0;
569             ASSERT(ar->PathId);
570             return 0;
571          }
572          ar->PathId = str_to_int64(row[0]);
573          sql_free_result(mdb);
574          /* Cache path */
575          if (ar->PathId != mdb->cached_path_id) {
576             mdb->cached_path_id = ar->PathId;
577             mdb->cached_path_len = mdb->pnl;
578             pm_strcpy(mdb->cached_path, mdb->path);
579          }
580          ASSERT(ar->PathId);
581          return 1;
582       }
583       sql_free_result(mdb);
584    }
585
586    Mmsg(mdb->cmd, "INSERT INTO Path (Path) VALUES ('%s')", mdb->esc_name);
587
588    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
589       Mmsg2(&mdb->errmsg, _("Create db Path record %s failed. ERR=%s\n"),
590          mdb->cmd, sql_strerror(mdb));
591       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
592       ar->PathId = 0;
593       stat = 0;
594    } else {
595       ar->PathId = sql_insert_id(mdb, NT_("Path"));
596       stat = 1;
597    }
598
599    /* Cache path */
600    if (stat && ar->PathId != mdb->cached_path_id) {
601       mdb->cached_path_id = ar->PathId;
602       mdb->cached_path_len = mdb->pnl;
603       pm_strcpy(mdb->cached_path, mdb->path);
604    }
605    return stat;
606 }
607
608 /*
609  * Create a Unique record for the counter -- no duplicates
610  * Returns: 0 on failure
611  *          1 on success with counter filled in
612  */
613 int db_create_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
614 {
615    COUNTER_DBR mcr;
616    int stat;
617
618    db_lock(mdb);
619    memset(&mcr, 0, sizeof(mcr));
620    bstrncpy(mcr.Counter, cr->Counter, sizeof(mcr.Counter));
621    if (db_get_counter_record(jcr, mdb, &mcr)) {
622       memcpy(cr, &mcr, sizeof(COUNTER_DBR));
623       db_unlock(mdb);
624       return 1;
625    }
626
627    /* Must create it */
628    Mmsg(mdb->cmd, "INSERT INTO Counters (Counter,MinValue,MaxValue,CurrentValue,"
629       "WrapCounter) VALUES ('%s','%d','%d','%d','%s')",
630       cr->Counter, cr->MinValue, cr->MaxValue, cr->CurrentValue,
631       cr->WrapCounter);
632
633    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
634       Mmsg2(&mdb->errmsg, _("Create DB Counters record %s failed. ERR=%s\n"),
635             mdb->cmd, sql_strerror(mdb));
636       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
637       stat = 0;
638    } else {
639       stat = 1;
640    }
641    db_unlock(mdb);
642    return stat;
643 }
644
645
646 /*
647  * Create a FileSet record. This record is unique in the
648  *  name and the MD5 signature of the include/exclude sets.
649  *  Returns: 0 on failure
650  *           1 on success with FileSetId in record
651  */
652 bool db_create_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
653 {
654    SQL_ROW row;
655    bool stat;
656    struct tm tm;
657
658    db_lock(mdb);
659    fsr->created = false;
660    Mmsg(mdb->cmd, "SELECT FileSetId,CreateTime FROM FileSet WHERE "
661 "FileSet='%s' AND MD5='%s'", fsr->FileSet, fsr->MD5);
662
663    fsr->FileSetId = 0;
664    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
665       mdb->num_rows = sql_num_rows(mdb);
666       if (mdb->num_rows > 1) {
667          Mmsg1(&mdb->errmsg, _("More than one FileSet!: %d\n"), (int)(mdb->num_rows));
668          Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
669       }
670       if (mdb->num_rows >= 1) {
671          if ((row = sql_fetch_row(mdb)) == NULL) {
672             Mmsg1(&mdb->errmsg, _("error fetching FileSet row: ERR=%s\n"), sql_strerror(mdb));
673             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
674             sql_free_result(mdb);
675             db_unlock(mdb);
676             return false;
677          }
678          fsr->FileSetId = str_to_int64(row[0]);
679          if (row[1] == NULL) {
680             fsr->cCreateTime[0] = 0;
681          } else {
682             bstrncpy(fsr->cCreateTime, row[1], sizeof(fsr->cCreateTime));
683          }
684          sql_free_result(mdb);
685          db_unlock(mdb);
686          return true;
687       }
688       sql_free_result(mdb);
689    }
690
691    if (fsr->CreateTime == 0 && fsr->cCreateTime[0] == 0) {
692       fsr->CreateTime = time(NULL);
693    }
694    (void)localtime_r(&fsr->CreateTime, &tm);
695    strftime(fsr->cCreateTime, sizeof(fsr->cCreateTime), "%Y-%m-%d %H:%M:%S", &tm);
696
697    /* Must create it */
698       Mmsg(mdb->cmd, "INSERT INTO FileSet (FileSet,MD5,CreateTime) "
699 "VALUES ('%s','%s','%s')", fsr->FileSet, fsr->MD5, fsr->cCreateTime);
700
701    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
702       Mmsg2(&mdb->errmsg, _("Create DB FileSet record %s failed. ERR=%s\n"),
703             mdb->cmd, sql_strerror(mdb));
704       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
705       fsr->FileSetId = 0;
706       stat = false;
707    } else {
708       fsr->FileSetId = sql_insert_id(mdb, NT_("FileSet"));
709       fsr->created = true;
710       stat = true;
711    }
712
713    db_unlock(mdb);
714    return stat;
715 }
716
717
718 /*
719  *  struct stat
720  *  {
721  *      dev_t         st_dev;       * device *
722  *      ino_t         st_ino;       * inode *
723  *      mode_t        st_mode;      * protection *
724  *      nlink_t       st_nlink;     * number of hard links *
725  *      uid_t         st_uid;       * user ID of owner *
726  *      gid_t         st_gid;       * group ID of owner *
727  *      dev_t         st_rdev;      * device type (if inode device) *
728  *      off_t         st_size;      * total size, in bytes *
729  *      unsigned long st_blksize;   * blocksize for filesystem I/O *
730  *      unsigned long st_blocks;    * number of blocks allocated *
731  *      time_t        st_atime;     * time of last access *
732  *      time_t        st_mtime;     * time of last modification *
733  *      time_t        st_ctime;     * time of last inode change *
734  *  };
735  */
736
737 #ifdef HAVE_BATCH_FILE_INSERT
738
739 /*  All sql_batch_* functions are used to do bulk batch insert in File/Filename/Path
740  *  tables. This code can be activated by adding "#define HAVE_BATCH_FILE_INSERT 1"
741  *  in baconfig.h
742  *  
743  *  To sum up :
744  *   - bulk load a temp table
745  *   - insert missing filenames into filename with a single query (lock filenames 
746  *   - table before that to avoid possible duplicate inserts with concurrent update)
747  *   - insert missing paths into path with another single query
748  *   - then insert the join between the temp, filename and path tables into file.
749  */
750
751 /* 
752  * Returns 1 if OK
753  *         0 if failed
754  */
755 bool my_batch_start(JCR *jcr, B_DB *mdb)
756 {
757    bool ok;
758
759    db_lock(mdb);
760    ok =  db_sql_query(mdb,
761              "CREATE TEMPORARY TABLE batch ("
762                 "FileIndex integer,"
763                 "JobId integer,"
764                 "Path blob,"
765                 "Name blob,"
766                 "LStat tinyblob,"
767                 "MD5 tinyblob)",NULL, NULL);
768    db_unlock(mdb);
769    return ok;
770 }
771
772 /* 
773  * Returns 1 if OK
774  *         0 if failed
775  */
776 bool my_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
777 {
778    size_t len;
779    const char *digest;
780    char ed1[50];
781
782    mdb->esc_name = check_pool_memory_size(mdb->esc_name, mdb->fnl*2+1);
783    db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);
784
785    mdb->esc_path = check_pool_memory_size(mdb->esc_path, mdb->pnl*2+1);
786    db_escape_string(jcr, mdb, mdb->esc_path, mdb->path, mdb->pnl);
787
788    if (ar->Digest == NULL || ar->Digest[0] == 0) {
789       digest = "0";
790    } else {
791       digest = ar->Digest;
792    }
793
794    len = Mmsg(mdb->cmd, "INSERT INTO batch VALUES (%u,%s,'%s','%s','%s','%s')",
795               ar->FileIndex, edit_int64(ar->JobId,ed1), mdb->esc_path, 
796               mdb->esc_name, ar->attr, digest);
797
798    return INSERT_DB(jcr, mdb, mdb->cmd);
799 }
800
801 /* set error to something to abort operation */
802 /* 
803  * Returns 1 if OK
804  *         0 if failed
805  */
806 bool my_batch_end(JCR *jcr, B_DB *mdb, const char *error)
807 {
808    
809    Dmsg0(50, "sql_batch_end started\n");
810
811    if (mdb) {
812 #ifdef HAVE_DBI 
813       mdb->status = (dbi_error_flag)0;
814 #else
815       mdb->status = 0;
816 #endif
817    }
818    return true;
819 }
820
821 /* 
822  * Returns 1 if OK
823  *         0 if failed
824  */
825 bool db_write_batch_file_records(JCR *jcr)
826 {
827    int JobStatus = jcr->JobStatus;
828
829    if (!jcr->batch_started) {         /* no files to backup ? */
830       Dmsg0(50,"db_create_file_record : no files\n");
831       return true;
832    }
833    if (job_canceled(jcr)) {
834       return false;
835    }
836
837    Dmsg1(50,"db_create_file_record changes=%u\n",jcr->db_batch->changes);
838
839    jcr->JobStatus = JS_AttrInserting;
840    if (!sql_batch_end(jcr, jcr->db_batch, NULL)) {
841       Jmsg1(jcr, M_FATAL, 0, "Batch end %s\n", jcr->db_batch->errmsg);
842       return false;
843    }
844    if (job_canceled(jcr)) {
845       return false;
846    }
847
848
849    /* we have to lock tables */
850    if (!db_sql_query(jcr->db_batch, sql_batch_lock_path_query, NULL, NULL)) {
851       Jmsg1(jcr, M_FATAL, 0, "Lock Path table %s\n", jcr->db_batch->errmsg);
852       return false;
853    }
854
855    if (!db_sql_query(jcr->db_batch, sql_batch_fill_path_query, NULL, NULL)) {
856       Jmsg1(jcr, M_FATAL, 0, "Fill Path table %s\n",jcr->db_batch->errmsg);
857       db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query, NULL, NULL);
858       return false;
859    }
860    
861    if (!db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query,NULL,NULL)) {
862       Jmsg1(jcr, M_FATAL, 0, "Unlock Path table %s\n", jcr->db_batch->errmsg);
863       return false;      
864    }
865
866    /* we have to lock tables */
867    if (!db_sql_query(jcr->db_batch,sql_batch_lock_filename_query,NULL, NULL)) {
868       Jmsg1(jcr, M_FATAL, 0, "Lock Filename table %s\n", jcr->db_batch->errmsg);
869       return false;
870    }
871    
872    if (!db_sql_query(jcr->db_batch,sql_batch_fill_filename_query, NULL,NULL)) {
873       Jmsg1(jcr,M_FATAL,0,"Fill Filename table %s\n",jcr->db_batch->errmsg);
874       db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query, NULL, NULL);
875       return false;            
876    }
877
878    if (!db_sql_query(jcr->db_batch, sql_batch_unlock_tables_query,NULL,NULL)) {
879       Jmsg1(jcr, M_FATAL, 0, "Unlock Filename table %s\n", jcr->db_batch->errmsg);
880       return false;
881    }
882    
883    if (!db_sql_query(jcr->db_batch, 
884        "INSERT INTO File (FileIndex, JobId, PathId, FilenameId, LStat, MD5)"
885          "SELECT batch.FileIndex, batch.JobId, Path.PathId, "
886                 "Filename.FilenameId,batch.LStat, batch.MD5 "
887            "FROM batch "
888            "JOIN Path ON (batch.Path = Path.Path) "
889            "JOIN Filename ON (batch.Name = Filename.Name)",
890                      NULL,NULL))
891    {
892       Jmsg1(jcr, M_FATAL, 0, "Fill File table %s\n", jcr->db_batch->errmsg);
893       return false;
894    }
895
896    db_sql_query(jcr->db_batch, "DROP TABLE batch", NULL,NULL);
897
898    jcr->JobStatus = JobStatus;         /* reset entry status */
899    return true;
900 }
901
902 /*
903  * Create File record in B_DB
904  *
905  *  In order to reduce database size, we store the File attributes,
906  *  the FileName, and the Path separately.  In principle, there
907  *  is a single FileName record and a single Path record, no matter
908  *  how many times it occurs.  This is this subroutine, we separate
909  *  the file and the path and fill temporary tables with this three records.
910  */
911 bool db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
912 {
913    Dmsg1(dbglevel, "Fname=%s\n", ar->fname);
914    Dmsg0(dbglevel, "put_file_into_catalog\n");
915
916    /* Open the dedicated connexion */
917    if (!jcr->batch_started) {
918
919       if (!db_open_batch_connexion(jcr, mdb)) {
920          return false;
921       }
922       if (!sql_batch_start(jcr, jcr->db_batch)) {
923          Mmsg1(&mdb->errmsg, 
924               "Can't start batch mode: ERR=%s", db_strerror(jcr->db_batch));
925          Jmsg1(jcr, M_FATAL, 0, "%s", mdb->errmsg);
926          return false;
927       }
928       jcr->batch_started = true;
929    }
930    B_DB *bdb = jcr->db_batch;
931
932    /*
933     * Make sure we have an acceptable attributes record.
934     */
935    if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES ||
936          ar->Stream == STREAM_UNIX_ATTRIBUTES_EX)) {
937       Mmsg1(&mdb->errmsg, _("Attempt to put non-attributes into catalog. Stream=%d\n"),
938          ar->Stream);
939       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
940       return false;
941    }
942
943    split_path_and_file(jcr, bdb, ar->fname);
944
945
946 /*
947  * if (bdb->changes > 100000) {
948  *    db_write_batch_file_records(jcr);
949  *    bdb->changes = 0;
950  *     sql_batch_start(jcr, bdb);
951  * }
952  */
953
954    return sql_batch_insert(jcr, bdb, ar);
955 }
956
957 #else  /* ! HAVE_BATCH_FILE_INSERT */
958
959 /*
960  * Create File record in B_DB
961  *
962  *  In order to reduce database size, we store the File attributes,
963  *  the FileName, and the Path separately.  In principle, there
964  *  is a single FileName record and a single Path record, no matter
965  *  how many times it occurs.  This is this subroutine, we separate
966  *  the file and the path and create three database records.
967  */
968 bool db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
969 {
970    db_lock(mdb);
971    Dmsg1(dbglevel, "Fname=%s\n", ar->fname);
972    Dmsg0(dbglevel, "put_file_into_catalog\n");
973    /*
974     * Make sure we have an acceptable attributes record.
975     */
976    if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES ||
977          ar->Stream == STREAM_UNIX_ATTRIBUTES_EX)) {
978       Mmsg1(&mdb->errmsg, _("Attempt to put non-attributes into catalog. Stream=%d\n"),
979          ar->Stream);
980       Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
981       goto bail_out;
982    }
983
984
985    split_path_and_file(jcr, mdb, ar->fname);
986
987    if (!db_create_filename_record(jcr, mdb, ar)) {
988       goto bail_out;
989    }
990    Dmsg1(dbglevel, "db_create_filename_record: %s\n", mdb->esc_name);
991
992
993    if (!db_create_path_record(jcr, mdb, ar)) {
994       goto bail_out;
995    }
996    Dmsg1(dbglevel, "db_create_path_record: %s\n", mdb->esc_name);
997
998    /* Now create master File record */
999    if (!db_create_file_record(jcr, mdb, ar)) {
1000       goto bail_out;
1001    }
1002    Dmsg0(dbglevel, "db_create_file_record OK\n");
1003
1004    Dmsg3(dbglevel, "CreateAttributes Path=%s File=%s FilenameId=%d\n", mdb->path, mdb->fname, ar->FilenameId);
1005    db_unlock(mdb);
1006    return true;
1007
1008 bail_out:
1009    db_unlock(mdb);
1010    return false;
1011 }
1012
1013
1014 /*
1015  * This is the master File entry containing the attributes.
1016  *  The filename and path records have already been created.
1017  */
1018 static int db_create_file_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1019 {
1020    int stat;
1021    static const char *no_digest = "0";
1022    const char *digest;
1023
1024    ASSERT(ar->JobId);
1025    ASSERT(ar->PathId);
1026    ASSERT(ar->FilenameId);
1027
1028    if (ar->Digest == NULL || ar->Digest[0] == 0) {
1029       digest = no_digest;
1030    } else {
1031       digest = ar->Digest;
1032    }
1033
1034    /* Must create it */
1035    Mmsg(mdb->cmd,
1036         "INSERT INTO File (FileIndex,JobId,PathId,FilenameId,"
1037         "LStat,MD5) VALUES (%u,%u,%u,%u,'%s','%s')",
1038         ar->FileIndex, ar->JobId, ar->PathId, ar->FilenameId,
1039         ar->attr, digest);
1040
1041    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
1042       Mmsg2(&mdb->errmsg, _("Create db File record %s failed. ERR=%s"),
1043          mdb->cmd, sql_strerror(mdb));
1044       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
1045       ar->FileId = 0;
1046       stat = 0;
1047    } else {
1048       ar->FileId = sql_insert_id(mdb, NT_("File"));
1049       stat = 1;
1050    }
1051    return stat;
1052 }
1053
1054 /* Create a Unique record for the filename -- no duplicates */
1055 static int db_create_filename_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
1056 {
1057    SQL_ROW row;
1058
1059    mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
1060    db_escape_string(jcr, mdb, mdb->esc_name, mdb->fname, mdb->fnl);
1061    
1062    Mmsg(mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
1063
1064    if (QUERY_DB(jcr, mdb, mdb->cmd)) {
1065       mdb->num_rows = sql_num_rows(mdb);
1066       if (mdb->num_rows > 1) {
1067          char ed1[30];
1068          Mmsg2(&mdb->errmsg, _("More than one Filename! %s for file: %s\n"),
1069             edit_uint64(mdb->num_rows, ed1), mdb->fname);
1070          Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
1071       }
1072       if (mdb->num_rows >= 1) {
1073          if ((row = sql_fetch_row(mdb)) == NULL) {
1074             Mmsg2(&mdb->errmsg, _("Error fetching row for file=%s: ERR=%s\n"),
1075                 mdb->fname, sql_strerror(mdb));
1076             Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
1077             ar->FilenameId = 0;
1078          } else {
1079             ar->FilenameId = str_to_int64(row[0]);
1080          }
1081          sql_free_result(mdb);
1082          return ar->FilenameId > 0;
1083       }
1084       sql_free_result(mdb);
1085    }
1086
1087    Mmsg(mdb->cmd, "INSERT INTO Filename (Name) VALUES ('%s')", mdb->esc_name);
1088
1089    if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
1090       Mmsg2(&mdb->errmsg, _("Create db Filename record %s failed. ERR=%s\n"),
1091             mdb->cmd, sql_strerror(mdb));
1092       Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
1093       ar->FilenameId = 0;
1094    } else {
1095       ar->FilenameId = sql_insert_id(mdb, NT_("Filename"));
1096    }
1097    return ar->FilenameId > 0;
1098 }
1099
1100 bool db_write_batch_file_records(JCR *jcr)
1101 {
1102    return true;
1103 }
1104
1105 #endif /* ! HAVE_BATCH_FILE_INSERT */
1106
1107 #endif /* HAVE_SQLITE3 || HAVE_MYSQL || HAVE_SQLITE || HAVE_POSTGRESQL || HAVE_DBI */