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