SQL RecycleBin — Undo is a query, not a restore.

Undo is a query,
not a restore.

SQL RecycleBin captures every DELETE and UPDATE on your protected tables into a page-compressed JSON store. When someone forgets the WHERE clause, query the lost rows as real typed columns and undo the transaction with one command—no backup restore, no $2,000 log-reader tool, and zero downtime.

EXEC rb.Enable @Table = 'dbo.Orders'; -- then EXEC rb.UndoLast @Table = 'dbo.Orders';

ALTER TABLE Safe Schema-resilient JSON storage

IDENTITY_INSERT Preserves original PK IDs automatically

PolyForm 1.0.0 Free for personal & noncommercial use

Recovery Capability	Point-in-Time Backup Restore	3rd-Party Log Forensics	Temporal Tables	SQL RecycleBin (rb.*)
Mean Time to Recover (1,000 rows)	30–120+ minutes	15–45 minutes	Manual T-SQL merge	< 5 seconds (1 command)
Preserves Newer Concurrent Transactions	No (unless restored side-by-side)	Yes	Yes	Yes (surgical per-TxId undo)
Works in SIMPLE Recovery Mode	No (full/diff checkpoints only)	Fails once log truncates	Yes	Yes (persistent table store)
Zero Friction with `ALTER TABLE`	N/A	N/A	Restricts certain DDL changes	Yes (JSON storage + dynamic OPENJSON)
Captures `ChangedBy`, `AppName`, `HostName`	No	Partial (SID only)	No built-in session metadata	Yes (built into every ChangeLog row)
Automatic `IDENTITY_INSERT` Handling	Manual scripting	Manual script export	Manual scripting	Automatic inside rb.UndoTransaction
SQL Server Express (2017+) Support	Yes	Often restricted	Yes	100% Supported

Recovery Capability

Point-in-Time Backup Restore

3rd-Party Log Forensics

Temporal Tables

SQL RecycleBin (rb.*)

Mean Time to Recover (1,000 rows)

30–120+ minutes

15–45 minutes

Manual T-SQL merge

< 5 seconds (1 command)

Preserves Newer Concurrent Transactions

No (unless restored side-by-side)

Yes

Yes (surgical per-TxId undo)

Works in SIMPLE Recovery Mode

No (full/diff checkpoints only)

Fails once log truncates

Yes

Yes (persistent table store)

Zero Friction with ALTER TABLE

N/A

Restricts certain DDL changes

Yes (JSON storage + dynamic OPENJSON)

Captures ChangedBy, AppName, HostName

Partial (SID only)

No built-in session metadata

Yes (built into every ChangeLog row)

Automatic IDENTITY_INSERT Handling

Manual scripting

Manual script export

Manual scripting

Automatic inside rb.UndoTransaction

SQL Server Express (2017+) Support

Yes

Often restricted

Yes

100% Supported

CASE STUDY #01 E-Commerce & Order Fulfillment SQL Server 2022 Standard Command: rb.UndoTransaction

The Partial SSMS Selection: Recovering 1,842 Settled Black Friday Orders Without Halting Checkout

1,842 rows Restored with original PKs

3.8 sec Total time to undo

0 lost Subsequent live orders

The Incident

During peak Black Friday settlement triage, an on-call engineer wrote DELETE dbo.Orders WHERE Status = N'Paid' AND Customer LIKE N'QA_SMOKE_%'; in SSMS to remove three smoke-test rows. When highlighting the query with the mouse, the AND Customer LIKE... line was clipped out of the selection before hitting F5. Instantly, 1,842 paid customer orders vanished while 60+ new orders per minute continued streaming into dbo.Orders.

Why Standard Restore Failed

Taking the 480 GB production database offline for a point-in-time restore would have halted Black Friday checkout for 40+ minutes and wiped out hundreds of newer orders placed seconds after the mistake.

The SQL RecycleBin Recovery

The DBA queried EXEC rb.Deleted @Table = N'dbo.Orders', @Top = 2000;, confirmed all 1,842 rows shared TxId = 9481022 from HostName = 'OPS-JUMPBOX-02', and executed EXEC rb.UndoTransaction @Table = N'dbo.Orders', @TxId = 9481022;. SQL RecycleBin toggled IDENTITY_INSERT dbo.Orders ON, re-inserted all 1,842 rows with their exact original OrderId keys, and left every newer checkout completely untouched.

-- 1. What the engineer highlighted by accident in SSMS:
DELETE dbo.Orders WHERE Status = N'Paid';
--   AND Customer LIKE N'QA_SMOKE_%';  <-- left unselected!
-- (1842 rows affected)

-- 2. Inspect deleted rows & isolate the exact Transaction ID:
EXEC rb.Deleted @Table = N'dbo.Orders', @Top = 5;
-- Returns ChangeId, ChangedAt, ChangedBy='sa_triage',
-- plus typed OrderId, Customer, Amount, Status, CreatedAt

SELECT DISTINCT TxId, ChangedBy, HostName, COUNT(*) AS DeletedRows
FROM rb.ChangeLog
WHERE SchemaName = N'dbo' AND TableName = N'Orders' AND Restored = 0
GROUP BY TxId, ChangedBy, HostName;
-- TxId: 9481022 | ChangedBy: sa_triage | HostName: OPS-JUMPBOX-02 | Rows: 1842

-- 3. Surgically undo ONLY TxId 9481022 while live checkouts continue:
EXEC rb.UndoTransaction @Table = N'dbo.Orders', @TxId = 9481022;
-- rb: restored 1842 deleted row(s), reverted 0 update(s) on [dbo].[Orders].

// Stored in rb.ChangeLog (Page Compressed)
{
  "ChangeId": 41092,
  "SchemaName": "dbo",
  "TableName": "Orders",
  "Operation": "D",
  "TxId": 9481022,
  "KeyValues": "{\"OrderId\":10481}",
  "RowBefore": "{\"OrderId\":10481,\"Customer\":\"Nordic Logistics AB\",\"Amount\":18400.00,\"Status\":\"Paid\",\"CreatedAt\":\"2026-11-27T14:02:11\"}",
  "RowAfter": null,
  "ChangedBy": "sa_triage",
  "AppName": "Microsoft SQL Server Management Studio - Query",
  "HostName": "OPS-JUMPBOX-02",
  "ChangedAt": "2026-11-27T14:04:02.118Z",
  "Restored": 1
}

-- Timeline Comparison:
14:04:02.118  Accidental DELETE removes 1,842 rows (OrderId 8600..10484)
14:04:03.000  Live customers place 14 new orders (OrderId 10485..10498)
14:04:05.910  EXEC rb.UndoTransaction @Table='dbo.Orders', @TxId=9481022

✓ Original OrderIds 8600..10484 re-inserted via automatic IDENTITY_INSERT ON
✓ Newer OrderIds 10485..10498 preserved without interruption
✓ PK collision guard (WHERE NOT EXISTS) prevented any duplicate key errors

CASE STUDY #02 B2B Multi-Tenant SaaS SQL Server 2019 Express Command: rb.Updated + rb.Restore

Surviving Both an `ALTER TABLE` Migration and a Mass-Zeroing Billing Update on SQL Server Express

4,120 tenants Pricing tiers reverted

11.2 sec Point-in-time table rollback

SQL Express No Enterprise license needed

The Incident

A fast-growing B2B SaaS platform running on SQL Server 2019 Express deployed a release that first ran ALTER TABLE dbo.Subscriptions ADD GracePeriodDays INT NULL; and then executed a post-deploy cleanup script intended to zero out expired sandbox trials. Due to a faulty predicate in the migration runner, the script executed UPDATE dbo.Subscriptions SET MonthlyRate = 0, BillingTier = N'Free'; across all 4,120 active paying tenants.

Why Standard Approaches Failed

SQL Server Express lacks Enterprise audit suites, and traditional column-mapped audit triggers fail or miss columns when ALTER TABLE modifies the schema immediately prior to an incident.

The SQL RecycleBin Recovery

Because SQL RecycleBin serializes rows with FOR JSON PATH and inspects live sys.columns metadata dynamically via rb.internal_GetTableMeta, the preceding ALTER TABLE didn't break capture or recovery. The team verified the before/after JSON in rb.Updated and ran EXEC rb.Restore @Table = N'dbo.Subscriptions', @Since = '2026-09-14T14:20:00'; to revert every tenant's exact custom pricing tier.

-- 1. Release script added a column, then ran a buggy mass UPDATE:
ALTER TABLE dbo.Subscriptions ADD GracePeriodDays INT NULL;
UPDATE dbo.Subscriptions SET MonthlyRate = 0, BillingTier = N'Free';
-- (4120 rows affected)

-- 2. Inspect the before and after values captured during the update:
EXEC rb.Updated
    @Table = N'dbo.Subscriptions',
    @Top   = 20,
    @Since = '2026-09-14T14:20:00';

-- 3. Roll the table's captured changes back to before the deployment:
EXEC rb.Restore
    @Table = N'dbo.Subscriptions',
    @Since = '2026-09-14T14:20:00';
-- rb: restored 0 deleted row(s), reverted 4120 update(s) on [dbo].[Subscriptions].

// Output from EXEC rb.Updated @Table = N'dbo.Subscriptions'
KeyValues : {"SubId": 501}
ChangedBy : "deploy_runner"
AppName   : "DbUp-Migration-Cli"

RowBefore : {
  "SubId": 501,
  "TenantName": "Aether BioLabs",
  "MonthlyRate": 1499.00,
  "BillingTier": "Enterprise",
  "GracePeriodDays": null
}

RowAfter  : {
  "SubId": 501,
  "TenantName": "Aether BioLabs",
  "MonthlyRate": 0.00,
  "BillingTier": "Free",
  "GracePeriodDays": null
}

-- How rb.internal_GetTableMeta handles ALTER TABLE automatically:
1. Trigger uses `SELECT d.* FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES`
   so newly added columns are automatically serialized without recreating triggers.
2. During `rb.UndoTransaction`, `rb.internal_GetTableMeta` queries `sys.columns`
   dynamically and generates:
   UPDATE t SET t.[TenantName] = src.[TenantName],
                t.[MonthlyRate] = src.[MonthlyRate],
                t.[BillingTier] = src.[BillingTier],
                t.[GracePeriodDays] = src.[GracePeriodDays]
   FROM [dbo].[Subscriptions] AS t
   JOIN OPENJSON(@rows) WITH (...) AS src ON t.[SubId] = src.[SubId];

CASE STUDY #03 Wealth Management & Financial Ledger PowerShell Module: SqlRecycleBin Cmdlets: Invoke-SqlRecycleBinBypass + Restore-SqlRecycleBinPointInTime

Bypassing 2.4M Nightly ETL Archival Rows While Reversing a Multi-Step Portfolio Rebalance Error

0% overhead During nightly ETL via Bypass

2 stacked TXs Unwound newest-first

42.8 MB 14-day PAGE-compressed store

The Incident & Operational Challenge

A wealth management firm needed protection on dbo.ClientAllocations during business hours, where analysts run ad-hoc portfolio adjustments, but also ran a nightly PowerShell ETL pipeline that purged and reloaded 2.4 million historical staging rows. One afternoon, an analyst ran a bad DELETE followed immediately by a bad UPDATE in an attempt to "fix" the first mistake—compounding the damage across two separate transactions.

The Session-Context Pitfall

Calling rb.BypassOn in one Invoke-Sqlcmd call and the ETL script in a second call fails because Invoke-Sqlcmd opens a new SQL connection per invocation, losing SESSION_CONTEXT(N'rb_bypass').

The SQL RecycleBin Recovery

Using the official SqlRecycleBin PowerShell module, the team wrapped their nightly ETL in Invoke-SqlRecycleBinBypass (which batches rb.BypassOn, the workload, and rb.BypassOff on a single connection). When the afternoon double-accident occurred, the ops engineer ran Restore-SqlRecycleBinPointInTime, which automatically iterated captured transactions in reverse chronological order (ORDER BY LastChange DESC)—first reverting the bad UPDATE, then re-inserting the deleted allocations.

# 1. Inspect deleted and updated rows directly as PowerShell objects:
Get-SqlRecycleBinDeletedRow `
    -ServerInstance 'SQL-PROD-01' `
    -Database 'WealthLedger' `
    -Table 'dbo.ClientAllocations' -Top 50

Get-SqlRecycleBinUpdatedRow `
    -ServerInstance 'SQL-PROD-01' `
    -Database 'WealthLedger' `
    -Table 'dbo.ClientAllocations' -Top 50

# 2. Unwind both the bad UPDATE and bad DELETE (newest transaction first):
Restore-SqlRecycleBinPointInTime `
    -ServerInstance 'SQL-PROD-01' `
    -Database 'WealthLedger' `
    -Table 'dbo.ClientAllocations' `
    -Since ([datetime]'2026-10-12T16:15:00Z')

# Nightly Scheduled Job: Skip trigger capture for 2.4M-row maintenance
# Wraps rb.BypassOn + Script + rb.BypassOff inside ONE connection batch:
Invoke-SqlRecycleBinBypass `
    -ServerInstance 'SQL-PROD-01' `
    -Database 'WealthLedger' `
    -InputFile 'C:\Jobs\NightlyPortfolioRollup.sql'

# Purge captured history older than 14 days in 50,000-row batches:
Clear-SqlRecycleBinHistory `
    -ServerInstance 'SQL-PROD-01' `
    -Database 'WealthLedger' `
    -KeepDays 14 -Confirm:$false

PS> Get-SqlRecycleBinStatus -ServerInstance 'SQL-PROD-01' -Database 'WealthLedger'

SchemaName TableName          EnabledAt           Captured PendingRestore StoreSizeMB
---------- ---------          ---------           -------- -------------- -----------
dbo        ClientAllocations  2026-08-01 09:00:00    14820              0        42.8
dbo        RebalanceOrders    2026-08-01 09:00:00     6310              0        42.8

CASE STUDY #04 Healthcare Clinic Scheduling SQL Server 2019 Standard Forensics + Parent/Child FK Recovery

Pinpointing a Rogue Desktop Client & Restoring Parent-Child Tables Across Foreign Keys

< 30 sec Time to identify workstation

310 + 485 Parent & child rows restored

0 FK errors Parent-first restore workflow

The Incident

At 08:45 AM, front-desk staff at a regional multi-specialty clinic noticed 310 upcoming patient appointments (dbo.Appointments) and 485 linked clinical intake notes (dbo.AppointmentNotes) had disappeared. Because six different internal tools and desktop applications connected to the database, the IT team had no idea what triggered the deletion or whether it was still happening.

The Foreign Key & Attribution Challenge

Restoring child rows in dbo.AppointmentNotes before restoring parent rows in dbo.Appointments fails due to FK_AppointmentNotes_Appointments—and parent rows must retain their exact original ApptId identity values for the child foreign keys to match.

The SQL RecycleBin Recovery

Running EXEC rb.Deleted @Table = N'dbo.Appointments' immediately revealed AppName = 'ClinicScheduler-WinForms-v1.8' and HostName = 'RECEPTION-PC-07', where a stuck macro key had purged the day's queue. The DBA isolated that workstation, then ran EXEC rb.UndoLast @Table = N'dbo.Appointments' first (which restored all 310 parent rows with original ApptId identity keys), followed immediately by EXEC rb.UndoLast @Table = N'dbo.AppointmentNotes'.

-- 1. Identify WHO, WHICH APP, and WHICH WORKSTATION deleted the rows:
SELECT TOP (5)
    ChangeId, TxId, ChangedAt, ChangedBy, AppName, HostName, KeyValues
FROM rb.ChangeLog
WHERE TableName = N'Appointments' AND Operation = 'D' AND Restored = 0
ORDER BY ChangeId DESC;

-- 2. Restore PARENT table first (automatically preserves ApptId IDENTITY PKs):
EXEC rb.UndoLast @Table = N'dbo.Appointments';
-- rb: restored 310 deleted row(s), reverted 0 update(s) on [dbo].[Appointments].

-- 3. Restore CHILD table second (FK_AppointmentNotes_Appointments succeeds):
EXEC rb.UndoLast @Table = N'dbo.AppointmentNotes';
-- rb: restored 485 deleted row(s), reverted 0 update(s) on [dbo].[AppointmentNotes].

// Built-in Forensic Columns Captured on Every Trigger Execution:
ChangedBy : "CLINIC\svc_desk"          -- via ORIGINAL_LOGIN()
AppName   : "ClinicScheduler-WinForms-v1.8" -- via APP_NAME()
HostName  : "RECEPTION-PC-07"          -- via HOST_NAME()
ChangedAt : "2026-10-29 08:44:51.902"  -- via SYSUTCDATETIME()
TxId      : 11804921                   -- via CURRENT_TRANSACTION_ID()

// Note: If both Parent and Child were deleted inside the same explicit
// transaction or cascade, they share the same CURRENT_TRANSACTION_ID()!

-- Why Parent-Before-Child Restore Works Cleanly:
1. `rb.UndoTransaction` detects `is_identity = 1` on `dbo.Appointments.ApptId`.
2. It dynamically wraps the `INSERT` in:
   `SET IDENTITY_INSERT [dbo].[Appointments] ON; ... SET IDENTITY_INSERT [dbo].[Appointments] OFF;`
3. Because all 310 parent rows come back with their exact original `ApptId` values
   (e.g. 301..610), restoring `dbo.AppointmentNotes` immediately afterward satisfies
   every foreign key reference without disabling or dropping constraints.

Stored Procedure	Parameters	What It Does
`EXEC rb.Enable`	`@Table SYSNAME`	Starts capturing `DELETE` and `UPDATE` on a table (e.g., `'dbo.Orders'`). Requires a Primary Key. Generates trigger `rb_trg_<Table>`.
`EXEC rb.Disable`	`@Table SYSNAME`	Drops the capture trigger and removes the table from `rb.EnabledTables` (existing history in `rb.ChangeLog` is retained).
`EXEC rb.Deleted`	`@Table SYSNAME, @Top INT = 10, @Since DATETIME2(3) = NULL`	Projects recently deleted rows (`Restored = 0`) from JSON back into real typed columns matching the table's current schema.
`EXEC rb.Updated`	`@Table SYSNAME, @Top INT = 10, @Since DATETIME2(3) = NULL`	Returns recent updates (`Restored = 0`) with `KeyValues`, `RowBefore` JSON, and `RowAfter` JSON side-by-side.
`EXEC rb.UndoLast`	`@Table SYSNAME`	Finds the most recent un-restored `TxId` on the table and calls `rb.UndoTransaction` to reverse it.
`EXEC rb.UndoTransaction`	`@Table SYSNAME, @TxId BIGINT`	Re-inserts deleted rows (handling `IDENTITY_INSERT` and skipping PK collisions) and reverts updated rows for a specific `@TxId`.
`EXEC rb.Restore`	`@Table SYSNAME, @Since DATETIME2(3)`	Rolls the table's captured changes back to `@Since` by undoing every captured transaction newest-first (`ORDER BY LastChange DESC`).
`EXEC rb.BypassOn / rb.BypassOff`	None	Sets `SESSION_CONTEXT(N'rb_bypass')` to `1` or `0` so ETL and bulk maintenance jobs in the current session skip capture.
`EXEC rb.Cleanup`	`@KeepDays INT = NULL`	Purges history older than `@KeepDays` (defaults to `14` from `rb.Config`) in 50,000-row batches to avoid log growth.
`EXEC rb.Status`	None	Returns enabled tables, total captured change counts, pending restore counts, and `rb.ChangeLog` store size in MB.

Stored Procedure

Parameters

What It Does

EXEC rb.Enable

@Table SYSNAME

Starts capturing DELETE and UPDATE on a table (e.g., 'dbo.Orders'). Requires a Primary Key. Generates trigger rb_trg_<Table>.

EXEC rb.Disable

@Table SYSNAME

Drops the capture trigger and removes the table from rb.EnabledTables (existing history in rb.ChangeLog is retained).

EXEC rb.Deleted

@Table SYSNAME, @Top INT = 10, @Since DATETIME2(3) = NULL

Projects recently deleted rows (`Restored = 0`) from JSON back into real typed columns matching the table's current schema.

EXEC rb.Updated

@Table SYSNAME, @Top INT = 10, @Since DATETIME2(3) = NULL

Returns recent updates (`Restored = 0`) with KeyValues, RowBefore JSON, and RowAfter JSON side-by-side.

EXEC rb.UndoLast

@Table SYSNAME

Finds the most recent un-restored TxId on the table and calls rb.UndoTransaction to reverse it.

EXEC rb.UndoTransaction

@Table SYSNAME, @TxId BIGINT

Re-inserts deleted rows (handling IDENTITY_INSERT and skipping PK collisions) and reverts updated rows for a specific @TxId.

EXEC rb.Restore

@Table SYSNAME, @Since DATETIME2(3)

Rolls the table's captured changes back to @Since by undoing every captured transaction newest-first (ORDER BY LastChange DESC).

EXEC rb.BypassOn / rb.BypassOff

None

Sets SESSION_CONTEXT(N'rb_bypass') to 1 or 0 so ETL and bulk maintenance jobs in the current session skip capture.

EXEC rb.Cleanup

@KeepDays INT = NULL

Purges history older than @KeepDays (defaults to 14 from rb.Config) in 50,000-row batches to avoid log growth.

EXEC rb.Status

None

Returns enabled tables, total captured change counts, pending restore counts, and rb.ChangeLog store size in MB.

PowerShell Cmdlet	Wraps	What It Does
`Install-SqlRecycleBin`	`install.sql`	Installs the `rb` schema, tables, and stored procedures on a target database. Idempotent and safe to re-run.
`Uninstall-SqlRecycleBin`	`uninstall.sql`	Removes SQL RecycleBin and drops all `rb` objects. Permanently deletes captured history (supports `-Force`).
`Enable-SqlRecycleBinCapture`	`rb.Enable`	Starts capturing `DELETE` and `UPDATE` on a table (requires a primary key).
`Disable-SqlRecycleBinCapture`	`rb.Disable`	Stops capturing on a table.
`Get-SqlRecycleBinDeletedRow`	`rb.Deleted`	Returns recently deleted rows as typed PowerShell objects into the pipeline.
`Get-SqlRecycleBinUpdatedRow`	`rb.Updated`	Returns recent updates with before/after JSON payloads.
`Restore-SqlRecycleBinLast`	`rb.UndoLast`	Undoes the most recent captured transaction on a table.
`Restore-SqlRecycleBinTransaction`	`rb.UndoTransaction`	Undoes a specific transaction by `-TxId`.
`Restore-SqlRecycleBinPointInTime`	`rb.Restore`	Undoes every captured change on a table since a given `-Since` timestamp.
`Invoke-SqlRecycleBinBypass`	`rb.BypassOn / Off`	Runs a `-Query` or `-InputFile` script with capture bypassed inside a single shared connection batch.
`Clear-SqlRecycleBinHistory`	`rb.Cleanup`	Purges history beyond a retention window (`-KeepDays`).
`Get-SqlRecycleBinStatus`	`rb.Status`	Returns enabled tables, capture counts, and change-log store size in MB.
`Invoke-SqlRecycleBinDemo`	`demo.sql`	Runs the full accident-to-recovery smoke test against a scratch database.

PowerShell Cmdlet

Wraps

What It Does

Install-SqlRecycleBin

install.sql

Installs the rb schema, tables, and stored procedures on a target database. Idempotent and safe to re-run.

Uninstall-SqlRecycleBin

uninstall.sql

Removes SQL RecycleBin and drops all rb objects. Permanently deletes captured history (supports -Force).

Enable-SqlRecycleBinCapture

rb.Enable

Starts capturing DELETE and UPDATE on a table (requires a primary key).

Disable-SqlRecycleBinCapture

rb.Disable

Stops capturing on a table.

Get-SqlRecycleBinDeletedRow

rb.Deleted

Returns recently deleted rows as typed PowerShell objects into the pipeline.

Get-SqlRecycleBinUpdatedRow

rb.Updated

Returns recent updates with before/after JSON payloads.

Restore-SqlRecycleBinLast

rb.UndoLast

Undoes the most recent captured transaction on a table.

Restore-SqlRecycleBinTransaction

rb.UndoTransaction

Undoes a specific transaction by -TxId.

Restore-SqlRecycleBinPointInTime

rb.Restore

Undoes every captured change on a table since a given -Since timestamp.

Invoke-SqlRecycleBinBypass

rb.BypassOn / Off

Runs a -Query or -InputFile script with capture bypassed inside a single shared connection batch.

Clear-SqlRecycleBinHistory

rb.Cleanup

Purges history beyond a retention window (-KeepDays).

Get-SqlRecycleBinStatus

rb.Status

Returns enabled tables, capture counts, and change-log store size in MB.

Invoke-SqlRecycleBinDemo

demo.sql

Runs the full accident-to-recovery smoke test against a scratch database.

Undo is a query,
not a restore.

SQL Server never got Oracle’s Flashback Query.

Point-in-time restore is slow and lossy

Log-reader forensics cost $2,000+ per seat

Express is left out & rigid triggers break

How SQL RecycleBin Works

Enable capture, once per table

Automatic JSON snapshot on change

Query typed columns, then Undo

Trigger & Bypass Check

Page-Compressed Store

rb.internal_GetTableMeta

Transactional Reversal

Case Studies: From Incident to Sub-10-Second Undo

The Partial SSMS Selection: Recovering 1,842 Settled Black Friday Orders Without Halting Checkout

Surviving Both an `ALTER TABLE` Migration and a Mass-Zeroing Billing Update on SQL Server Express

Bypassing 2.4M Nightly ETL Archival Rows While Reversing a Multi-Step Portfolio Rebalance Error

Pinpointing a Rogue Desktop Client & Restoring Parent-Child Tables Across Foreign Keys

T-SQL Stored Procedures & PowerShell Module

Architectural Note: Why `Invoke-SqlRecycleBinBypass` Exists as Its Own Cmdlet

Honest Limitations (v1)

⚠️ TRUNCATE, DROP & Minimally-Logged Bulk Ops

🔑 Primary Key Required

🔄 Updating Primary Key Values

⚡ Trigger Write Overhead & LOB Sizing

Pricing & Commercial Licensing

SQL Server never got Oracle’s Flashback Query.

Point-in-time restore is slow and lossy

Log-reader forensics cost $2,000+ per seat

Express is left out & rigid triggers break

How SQL RecycleBin Works

Enable capture, once per table

Automatic JSON snapshot on change

Query typed columns, then Undo

Trigger & Bypass Check

Page-Compressed Store

rb.internal_GetTableMeta

Transactional Reversal

Case Studies: From Incident to Sub-10-Second Undo

The Partial SSMS Selection: Recovering 1,842 Settled Black Friday Orders Without Halting Checkout

Surviving Both an ALTER TABLE Migration and a Mass-Zeroing Billing Update on SQL Server Express

Bypassing 2.4M Nightly ETL Archival Rows While Reversing a Multi-Step Portfolio Rebalance Error

Pinpointing a Rogue Desktop Client & Restoring Parent-Child Tables Across Foreign Keys

T-SQL Stored Procedures & PowerShell Module

Architectural Note: Why Invoke-SqlRecycleBinBypass Exists as Its Own Cmdlet

Honest Limitations (v1)

⚠️ TRUNCATE, DROP & Minimally-Logged Bulk Ops

🔑 Primary Key Required

🔄 Updating Primary Key Values

⚡ Trigger Write Overhead & LOB Sizing

Pricing & Commercial Licensing

Surviving Both an `ALTER TABLE` Migration and a Mass-Zeroing Billing Update on SQL Server Express

Architectural Note: Why `Invoke-SqlRecycleBinBypass` Exists as Its Own Cmdlet