Hi,
I have a backup set with the following schedule and retention rules
- Diff every month, incremental every day
- Keep 12 months of diffs, keep 60 days of incrementals

I have attached a screenshot of the current config.
This config means that there is an incremental consolidation every day, for example:

If I have:
Diff - xxx-10
Inc - xxx-11 to xxx-39
Diff - xxx-40
Inc - xxx-41 to xxx-69
Diff - xxx-70

then when incremental xxx-71 is created xxx-11 and xxx-12 are consolidate into a larger xxx-12

What I would really like to do is keep "at least" 60 days of incrementals but without having to run the consolidation every days.

In the above example I think that would actually work as follows:

- Reflect would create Inc xxx-71 to xxx-99
- Reflect would then create Diff xxx-100 and delete Inc xxx-11 to xxx-39

It would have to not delete an Inc until it could delete all the Incs related to the previous Diff (in this case xxx-10).

This would lead to a situation in which I had a minimum of 60 Incs and up to a maximum of 90 Incs which is fine.

Of course if I just change the settings to "keep 90 days of incs" then I will just have the consolidation problem under the previous Diff.

I would also want it to keep at least 60 days even if a diff was generated half way through the month (i.e. not just incs for the previous two diffs, but incs for the previous two months, regardless of what diffs have been created).

So, I'm wondering if there is a way to configure it as "keep at least 60 days of incrementals, but rather than consolidate incrementals, keep additional incrementals until no longer needed for intergrity"

Any thoughts would be much appreciated.

Normally the way you would achieve this is by simply disabling the Incremental retention policy entirely and then relying on Diff purges to purge Incrementals.  In that case, you'll never need consolidation.  But you're creating monthly Diffs and want to retain those for 12 months, so in your case this strategy would have you retaining daily Incrementals for a year.

If you set an Incremental retention policy such that Reflect determines that ALL and ONLY the entire Incremental chain under a given Full/Diff should be purged, then Reflect will simply delete them.  But you wouldn't be able to achieve that outcome reliably.  The reason is that month don't all have the same number of days, so you'll have different numbers of Incrementals under different Diffs.  This means that regardless of whether you tried to specify Incremental retention in terms of time or quantity of backups, you'll never get to a point where Reflect always identifies EXACTLY the full set of Incrementals under a given Diff as appropriate to purge.  And that doesn't even consider cases where you might manually create an additional Inc or might end up with an unexpected Full at some point due to something like a Windows Recovery partition change during a feature update.

Reflect doesn't allow "flexible" retention periods. You could achieve a setup where the Incremental retention policy was only evaluated at all at the end of the month, which would be key since otherwise "60 days" or even "60 Incrementals" when evaluated in the middle of the month would never correspond to a full Incremental chain under a single parent Diff. That is doable with a strategy that involves two separate definition files working on the same backup job, which I've helped users set up, but even that wouldn't help you here for the reason I described above.

So there's no way to achieve exactly what you want.  If it would be feasible for you, then one option you might consider is creating more frequent Fulls and then having a Diff retention of only 60-90 days.  In that case, purging the Diff would also purge all Incs.  But other than that, you'll either need to retain a lot of Incrementals to reliably purge without ever encountering consolidation, or else accept consolidation.