Replaces whole tables with what was captured for them.
The operation for the realms a logical restore refuses: raw table rows, and anything whose correctness depends on constraints, sequences and triggers rather than on an entity API.
The honest constraint, stated first because everything else follows from it. Strata stores CHURN, not snapshots - that is the whole reason a year of history fits in 10 GB. So the rows it can put back into a table are the rows it captured for that table, and nothing else. A table whose changes were all captured restores exactly; a table that existed before capture started, or whose drift exceeded the reconciler's per-pass bound, restores to fewer rows than it has now.
That difference is measured before anything is written, and a restore that would leave a table with materially fewer rows than it holds REFUSES unless an operator says otherwise. Silently truncating a table to the subset that happened to be captured is the single worst thing this code could do, and it is exactly what a naive implementation does.
A pre-restore snapshot is forced, as it is for a logical restore, and maintenance mode is the caller's decision: the truncate strategy needs it and the shadow-swap strategy does not, which is why the strategy describes its own cost.
$strategies : array
Strategies available, keyed by id.
$replayer : \Drupal\strata\Restore\Replayer
$flusher : \Drupal\strata\Flush\Flusher
$audit : \Drupal\strata\Restore\RestoreAudit
$notifier : ?\Drupal\strata\Event\Notifier
__construct(\Drupal\Core\Database\Connection $database, \Drupal\strata\Restore\Replayer $replayer, \Drupal\strata\Flush\Flusher $flusher, \Drupal\strata\Restore\RestoreAudit $audit, \Drupal\Core\State\StateInterface $state, \Drupal\Core\Session\AccountProxyInterface $currentUser, \Psr\Log\LoggerInterface $logger, \Drupal\strata\Event\Notifier|null $notifier = null) : mixed
Constructs a physical restore.
| \Drupal\Core\Database\Connection | $database | The connection tables are replaced on. |
| \Drupal\strata\Restore\Replayer | $replayer | Reconstructs the captured rows. |
| \Drupal\strata\Flush\Flusher | $flusher | Takes the snapshot that makes the restore undoable. |
| \Drupal\strata\Restore\RestoreAudit | $audit | Records what was done. |
| \Drupal\Core\State\StateInterface | $state | Used to put the site into maintenance mode when a strategy needs it. |
| \Drupal\Core\Session\AccountProxyInterface | $currentUser | Attributes the restore to whoever ran it. |
| \Psr\Log\LoggerInterface | $logger | Records the outcome. |
| \Drupal\strata\Event\Notifier|null | $notifier | Announces the outcome, or NULL to announce nothing. |
plan(string $table, string $target) : \Drupal\strata\Restore\PhysicalPlan
Works out what restoring a table would do, before anything is written.
| string | $table | The table. |
| string | $target | Commit id to restore to. |
What the restore would leave behind, and whether that is safe.
restore(string $table, string $target, string $strategy = 'truncate', bool $apply = false, bool $acceptRowLoss = false) : \Drupal\strata\Restore\RestoreResult
Restores one table.
| string | $table | The table. |
| string | $target | Commit id to restore to. |
| string | $strategy | Which strategy to use. |
| bool | $apply | FALSE to plan and record without writing. |
| bool | $acceptRowLoss | TRUE to proceed when the restore would leave the table with materially fewer rows than it holds. Off by default, because that is the case where a backup empties a table it never saw. |
What happened.
rowsAt(string $table, string $target) : array{rows: list<array<string,mixed>>, columns: list<string>, unreadable: int}
The rows captured for a table at a commit.
Every row subject the target's tree covers for this table is replayed. A subject the replay could not complete is counted rather than half-written: a table restored from a mix of complete and partial rows is not the table as it was at any moment.
| string | $table | The table. |
| string | $target | Commit id. |
The rows, the union of their columns, and how many could not be read.
run(string $table, string $target, string $strategy, bool $apply, bool $acceptRowLoss) : \Drupal\strata\Restore\RestoreResult
The restore itself, before anything is announced.
| string | $table | The logical table name. |
| string | $target | The commit to restore to. |
| string | $strategy | Which strategy writes the rows. |
| bool | $apply | FALSE to plan without writing. |
| bool | $acceptRowLoss | TRUE to proceed when the table would lose rows. |
What happened.
refusalFor(\Drupal\strata\Restore\PhysicalPlan $plan, string $strategy, bool $acceptRowLoss) : string|null
Why a restore would not run.
| \Drupal\strata\Restore\PhysicalPlan | $plan | What the restore would do. |
| string | $strategy | The strategy asked for. |
| bool | $acceptRowLoss | Whether the caller accepted losing rows. |
The reason, or NULL when it may proceed.
enterMaintenance(string $strategy) : bool
Puts the site into maintenance mode when the strategy needs it.
| string | $strategy | The strategy id. |
TRUE when this call turned maintenance mode on, so only it turns it back off. A site already in maintenance mode when the restore started stays in it afterwards.