db_create_media_record(B_DB *mdb, MEDIA_DBR *mr)
 {
    int stat;
-   char ed1[30], ed2[30], ed3[30];
+   char ed1[30], ed2[30], ed3[30], ed4[30];
 
    db_lock(mdb);
    Mmsg(&mdb->cmd, "SELECT MediaId FROM Media WHERE VolumeName='%s'", 
 
    /* Must create it */
    Mmsg(&mdb->cmd, 
-"INSERT INTO Media (VolumeName,MediaType,PoolId,MaxVolBytes,VolCapacityBytes, \
-Recycle,VolRetention,VolStatus,Slot) VALUES ('%s','%s',%u,%s,%s,%d,%s,'%s',%d)", 
+"INSERT INTO Media (VolumeName,MediaType,PoolId,MaxVolBytes,VolCapacityBytes," 
+"Recycle,VolRetention,VolUseDuration,VolStatus,Slot) "
+"VALUES ('%s','%s',%u,%s,%s,%d,%s,%s,'%s',%d)", 
                  mr->VolumeName,
                  mr->MediaType, mr->PoolId, 
                  edit_uint64(mr->MaxVolBytes,ed1),
                  edit_uint64(mr->VolCapacityBytes, ed2),
                  mr->Recycle,
                  edit_uint64(mr->VolRetention, ed3),
+                 edit_uint64(mr->VolUseDuration, ed4),
                  mr->VolStatus,
                  mr->Slot);
 
 
 extern void print_result(B_DB *mdb);
 extern int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
 
-
-/* Find job start time. Used to find last full save
+/*
+ * Find job start time. Used to find last full save
  * for Incremental and Differential saves.
  *     
  * Returns: 0 on failure
       /* Differential is since last Full backup */
       if (jr->Level == L_DIFFERENTIAL) {
         Mmsg(&mdb->cmd, 
-"SELECT JobId from Job WHERE JobStatus='T' and Type='%c' and \
-Level='%c' and Name='%s' and ClientId=%d and FileSetId=%d \
-ORDER by StartTime DESC LIMIT 1",
+"SELECT JobId FROM Job WHERE JobStatus='T' AND Type='%c' AND \
+Level='%c' AND Name='%s' AND ClientId=%d AND FileSetId=%d \
+ORDER BY StartTime DESC LIMIT 1",
           jr->Type, L_FULL, jr->Name, jr->ClientId, jr->FileSetId);
       /* Incremental is since last Full, Incremental, or Differential */
       } else if (jr->Level == L_INCREMENTAL) {
         Mmsg(&mdb->cmd, 
-"SELECT JobId from Job WHERE JobStatus='T' and Type='%c' and \
-(Level='%c' or Level='%c' or Level='%c') and Name='%s' and ClientId=%d \
-ORDER by StartTime DESC LIMIT 1",
+"SELECT JobId FROM Job WHERE JobStatus='T' AND Type='%c' AND \
+Level IN ('%c','%c','%c') AND Name='%s' AND ClientId=%d \
+ORDER BY StartTime DESC LIMIT 1",
           jr->Type, L_INCREMENTAL, L_DIFFERENTIAL, L_FULL, jr->Name,
           jr->ClientId);
       } else {
    }
 
    Dmsg1(100, "Submitting: %s\n", mdb->cmd);
-   Mmsg(&mdb->cmd, "SELECT StartTime from Job WHERE Job.JobId=%d", JobId);
+   Mmsg(&mdb->cmd, "SELECT StartTime FROM Job WHERE Job.JobId=%d", JobId);
 
    if (!QUERY_DB(mdb, mdb->cmd)) {
       Mmsg1(&mdb->errmsg, _("Query error for start time request: %s\n"), mdb->cmd);
 
 db_update_pool_record(B_DB *mdb, POOL_DBR *pr)
 {
    int stat;
-   char ed1[50];
+   char ed1[50], ed2[50], ed3[50];
 
    db_lock(mdb);
    Mmsg(&mdb->cmd,
-"UPDATE Pool SET NumVols=%d, MaxVols=%d, UseOnce=%d, UseCatalog=%d, \
-AcceptAnyVolume=%d, VolRetention='%s',LabelFormat='%s' WHERE PoolId=%u",
+"UPDATE Pool SET NumVols=%d,MaxVols=%d,UseOnce=%d,UseCatalog=%d," 
+"AcceptAnyVolume=%d,VolRetention='%s',VolUseDuration='%s',"
+"MaxVolJobs=%u,MaxVolFiles=%u,MaxVolBytes=%s,Recycle=%d,"
+"AutoPrune=%d,LabelFormat='%s' WHERE PoolId=%u",
       pr->NumVols, pr->MaxVols, pr->UseOnce, pr->UseCatalog,
       pr->AcceptAnyVolume, edit_uint64(pr->VolRetention, ed1),
+      edit_uint64(pr->VolUseDuration, ed2),
+      pr->MaxVolJobs, pr->MaxVolFiles,
+      edit_uint64(pr->MaxVolBytes, ed3),
+      pr->Recycle, pr->AutoPrune,
       pr->LabelFormat, pr->PoolId);
 
    stat = UPDATE_DB(mdb, mdb->cmd);
 
    return stat;
 }
 
+/*
+ * This is a common routine used to stuff the Pool DB record defaults
+ *   into the Media DB record just before creating a media (Volume) 
+ *   record.
+ */
+static void set_pool_dbr_defaults_in_media_dbr(MEDIA_DBR *mr, POOL_DBR *pr)
+{
+   mr->PoolId = pr->PoolId;
+   strcpy(mr->VolStatus, "Append");
+   mr->Recycle = pr->Recycle;
+   mr->VolRetention = pr->VolRetention;
+   mr->VolUseDuration = pr->VolUseDuration;
+   mr->MaxVolJobs = pr->MaxVolJobs;
+   mr->MaxVolFiles = pr->MaxVolFiles;
+   mr->MaxVolBytes = pr->MaxVolBytes;
+}
+
 
 /*
  *  Add Volumes to an existing Pool
       slot = atoi(ua->cmd);
    }
           
-   mr.PoolId = pr.PoolId;
-   strcpy(mr.VolStatus, "Append");
-   mr.Recycle = pr.Recycle;
-   mr.VolRetention = pr.VolRetention;
-   mr.VolUseDuration = pr.VolUseDuration;
-   mr.MaxVolJobs = pr.MaxVolJobs;
-   mr.MaxVolFiles = pr.MaxVolFiles;
-   mr.MaxVolBytes = pr.MaxVolBytes;
+   set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
    for (i=startnum; i < num+startnum; i++) { 
       sprintf(mr.VolumeName, name, i);
       mr.Slot = slot++;
    return 1; 
 }
 
+/*
+ * This is a common routine to create or update a
+ *   Pool DB base record from a Pool Resource. We handle
+ *   the setting of MaxVols and NumVols slightly differently
+ *   depending on if we are creating the Pool or we are
+ *   simply bringing it into agreement with the resource (updage).
+ */
+void set_pooldbr_from_poolres(POOL_DBR *pr, POOL *pool, int create)
+{
+   strcpy(pr->PoolType, pool->pool_type);
+   if (create) {
+      pr->MaxVols = pool->max_volumes;
+      pr->NumVols = 0;
+   } else {         /* update pool */
+      if (pr->MaxVols != pool->max_volumes) {
+        pr->MaxVols = pool->max_volumes;
+      }
+      if (pr->MaxVols != 0 && pr->MaxVols < pr->NumVols) {
+        pr->MaxVols = pr->NumVols;
+      }
+   }
+   pr->UseOnce = pool->use_volume_once;
+   pr->UseCatalog = pool->use_catalog;
+   pr->AcceptAnyVolume = pool->accept_any_volume;
+   pr->Recycle = pool->Recycle;
+   pr->VolRetention = pool->VolRetention;
+   pr->VolUseDuration = pool->VolUseDuration;
+   pr->MaxVolJobs = pool->MaxVolJobs;
+   pr->MaxVolFiles = pool->MaxVolFiles;
+   pr->MaxVolBytes = pool->MaxVolBytes;
+   if (pool->label_format) {
+      strcpy(pr->LabelFormat, pool->label_format);
+   } else {
+      strcpy(pr->LabelFormat, "*");    /* none */
+   }
+}
+
+
 /*
  * Create a pool record from a given Pool resource
  *   Also called from backup.c
       return 0;                      /* exists */
    }
 
-   strcpy(pr.PoolType, pool->pool_type);
-   pr.MaxVols = pool->max_volumes;
-   pr.NumVols = 0;
-   pr.UseOnce = pool->use_volume_once;
-   pr.UseCatalog = pool->use_catalog;
-   pr.AcceptAnyVolume = pool->accept_any_volume;
-   pr.Recycle = pool->Recycle;
-   pr.VolRetention = pool->VolRetention;
-   pr.VolUseDuration = pool->VolUseDuration;
-   pr.MaxVolJobs = pool->MaxVolJobs;
-   pr.MaxVolFiles = pool->MaxVolFiles;
-   pr.MaxVolBytes = pool->MaxVolBytes;
-   pr.AutoPrune = pool->AutoPrune;
-   if (pool->label_format) {
-      strcpy(pr.LabelFormat, pool->label_format);
-   } else {
-      strcpy(pr.LabelFormat, "*");    /* none */
-   }
+   set_pooldbr_from_poolres(&pr, pool, 1);
 
    if (!db_create_pool_record(db, &pr)) {
       return -1;                     /* error */
    if (!get_pool_dbr(ua, &pr)) {
       return 0;
    }
-   strcpy(pr.PoolType, pool->pool_type);
-   if (pr.MaxVols != pool->max_volumes) {
-      pr.MaxVols = pool->max_volumes;
-   }
-   if (pr.MaxVols != 0 && pr.MaxVols < pr.NumVols) {
-      pr.MaxVols = pr.NumVols;
-   }
-   pr.UseOnce = pool->use_volume_once;
-   pr.UseCatalog = pool->use_catalog;
-   pr.AcceptAnyVolume = pool->accept_any_volume;
-   pr.Recycle = pool->Recycle;
-   pr.VolRetention = pool->VolRetention;
-   pr.VolUseDuration = pool->VolUseDuration;
-   pr.MaxVolJobs = pool->MaxVolJobs;
-   pr.MaxVolFiles = pool->MaxVolFiles;
-   pr.MaxVolBytes = pool->MaxVolBytes;
 
-   if (pool->label_format) {
-      strcpy(pr.LabelFormat, pool->label_format);
-   } else {
-      strcpy(pr.LabelFormat, "*");    /* none */
-   }
+   set_pooldbr_from_poolres(&pr, pool, 0); /* update */
+
    id = db_update_pool_record(ua->db, &pr);
    if (id <= 0) {
       bsendmsg(ua, _("db_update_pool_record returned %d. ERR=%s\n"),
    if (!select_pool_dbr(ua, &pr)) {
       return 1;
    }
-   mr.PoolId = pr.PoolId;
-   strcpy(mr.VolStatus, "Append");
-   mr.Recycle = pr.Recycle;
-   mr.VolRetention = pr.VolRetention;
 
    ua->jcr->store = store;
    bsendmsg(ua, _("Connecting to Storage daemon %s at %s:%d ...\n"), 
    unbash_spaces(mr.MediaType);
    unbash_spaces(pr.Name);
    if (ok) {
-      mr.Recycle = pr.Recycle;
-      mr.VolRetention = pr.VolRetention;
-      mr.VolUseDuration = pr.VolUseDuration;
-      mr.MaxVolJobs = pr.MaxVolJobs;
-      mr.MaxVolFiles = pr.MaxVolFiles;
-      mr.MaxVolBytes = pr.MaxVolBytes;
+      set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
       if (db_create_media_record(ua->db, &mr)) {
          bsendmsg(ua, _("Media record for Volume=%s successfully created.\n"),
            mr.VolumeName);