This article explains how file deletion works, why data remains recoverable until overwritten, compares recovery difficulty across HDDs, SSDs, USB drives, and cloud storage, outlines step-by-step methods for common scenarios like accidental deletion, formatting, and physical damage, recommends recovery software, and emphasizes immediate write-stopping and backups.
This article traces the evolution of data recovery from manual backup restoration through log replay to automated replica switching, explaining RPO/RTO trade-offs, and details how 10M QPS systems implement shard-level automatic rebuild with throttling, verification, and continuous recovery as a runtime capability.
This article details a real-world incident response and recovery process after an accidental rm -rf deletion on Linux, covering filesystem internals, immediate containment steps, recovery tools like extundelete and debugfs, LVM snapshots, and preventive measures to avoid future data loss.
When a routine rm -rf command mistakenly wipes critical backup directories on a Linux server, this article walks through the immediate containment actions, detailed forensic data collection, the underlying file‑system mechanics of ext4 and XFS, and a comprehensive suite of recovery techniques—from lsof‑based live file grabs to extundelete, debugfs, LVM snapshots, and cloud‑disk imaging—ensuring you can restore lost files safely.
This article explains what the Oracle TRUNCATE command does, why recovery is challenging, and provides detailed step‑by‑step instructions for four practical tools—FY_Recover_Data, ODU, BBED, and GDUL—to restore data from a mistakenly truncated table.
This guide walks Linux administrators through why xfs_undelete is the preferred XFS recovery tool, how to install it in under five minutes, and step‑by‑step commands—including basic, time‑filtered, and type‑filtered recovery—plus three real‑world scenarios, advanced tips, and common pitfalls.
This article explains Tencent Cloud MongoDB’s backup and restore capabilities, the challenges posed by modern game workloads, and how the industry‑first key‑based flashback feature provides second‑level, fine‑grained, non‑disruptive data recovery, dramatically improving reliability and speed for game operators.
This guide explains how to restore lost MySQL data after accidental DELETE operations by using binary log replay, logical and physical backups, third‑party recovery utilities, and preventive measures such as proper binlog configuration, backup strategies, and permission controls.
This guide walks you through a full disaster‑recovery workflow for MySQL, covering emergency read‑only switching, pinpointing the deletion time via binlog, preparing a recovery instance, restoring the latest full backup with Xtrabackup or mysqldump, applying incremental binlog changes, verifying data integrity, and safely switching traffic back to the restored database.
This guide explains how to restore mistakenly deleted MySQL rows by leveraging binary logs, covering binlog activation, mode configuration, locating relevant log files, extracting the original INSERT statements or generating reverse DELETE statements, and using open‑source tools to automate the recovery process.
This guide details how to restore a CDH cluster after MySQL metadata loss caused by an accidental deletion of the MySQL data directory, covering database locking, locating deleted file handles, reconstructing shared and independent tablespaces, and verifying consistency to bring the platform back online quickly.
This guide walks through diagnosing a MySQL metadata loss in a CDH cluster, locking the database, locating deleted file handles, restoring shared and independent tablespace files, fixing table structures, verifying consistency, and explains the underlying Linux and MySQL mechanisms.
This article recounts a disastrous production server data loss caused by an accidental rm -rf command, details the step‑by‑step recovery using ext3grep, extundelete and MySQL binlog, and shares hard‑earned lessons to prevent similar incidents.
Learn how MySQL’s three essential logs—Redo Log for durability, Undo Log for transaction rollback, and Binlog for replication—work together, understand their configurations, performance trade‑offs, and practical monitoring and recovery techniques to ensure data integrity in production environments.
This guide explains WeChat’s hidden “recover” function, its official purpose and limitations, step‑by‑step recovery methods via search or settings, practical tips, backup strategies, user‑tested success rates, and the risks of third‑party tools, helping users safeguard and restore chat data.
This article explains WeChat’s hidden “recover” feature, detailing its official purpose, technical limits, step‑by‑step recovery methods, effectiveness, backup strategies, and the risks of third‑party tools, helping users safely restore lost chat records.
The article explains how Baidu Cloud Redis's Data Flashback feature combines RDB snapshots with timestamped AOF logs to provide fast, space‑efficient, point‑in‑time data recovery, overcoming the limitations of native Redis persistence in high‑traffic scenarios.
This article explains how Baidu Intelligent Cloud Redis introduces a hybrid RDB‑AOF persistence model with built‑in timestamps, enabling fast, storage‑efficient point‑in‑time recovery—addressing the limitations of native Redis RDB snapshots and AOF logs for critical game and e‑commerce workloads.
When an Oracle table is accidentally truncated, this guide explains what TRUNCATE does, why recovery is difficult, and walks through four practical tools—Fy_Recover_Data, ODU, BBED, and GDUL—detailing step‑by‑step commands to restore the lost data safely.
This article explains how to use MySQL flashback utilities such as binlog2sql, my2sql, and MyFlash to recover from accidental DML operations, covering supported SQL types, required binlog settings, tool features, command‑line usage examples, and best‑practice recommendations for preventing future data loss.
This article explains how MySQL redo logs and binlog logs work together to ensure data durability, consistency, and high availability, covering InnoDB crash‑recovery, flush policies, log file groups, binlog formats, two‑phase commit, and the complete recovery workflow.
To recover accidentally deleted MySQL rows, ensure binary logging is enabled and set to ROW mode, locate the appropriate binlog files, use mysqlbinlog (or tools like binlog2sql) to extract the original INSERT events within a time window, and replay or reconstruct them to restore the data.
This guide explains how to prevent data loss in MySQL by enabling backups and binlog, performing full restores with mysqldump or xtrabackup, executing point‑in‑time recovery, restoring individual tables, skipping erroneous SQL statements, and using flashback tools like binlog2sql and MyFlash.
After a mistaken rm -rf command wiped an entire production server, the author details the step‑by‑step recovery using ext3grep, extundelete, and MySQL binlogs, while sharing hard‑earned lessons on backup, permissions, and incident response.
After a junior engineer mistakenly ran an unguarded rm -rf command that wiped an entire production server—including MySQL and Tomcat—I documented the step‑by‑step recovery using ext3grep, extundelete, and MySQL binlog, highlighting the lessons learned for future operations.
This guide explains why a hard drive attached to a new Windows PC may deny access to the original desktop folder and provides step‑by‑step instructions to enable the built‑in Administrator account, switch users, and successfully copy the needed files.
When a MySQL 5.7 instance crashes without backups or redundancy, this guide shows how to recover both table structures and data using the open‑source tools dbsake and ibd2sql, providing exact commands, parameter explanations, and practical tips for a successful rescue.
This guide walks through recovering a deleted MySQL database stored in Docker volumes by locating the mysql.ibd file, recreating a container with the same image, and mounting the original volume, allowing the lost data to be restored without a backup.
This article explains the four major differences between MySQL’s redo log and binlog—including their purposes, recorded content, data types, and lifecycle—highlighting how redo logs ensure data durability while binlogs support replication, recovery, auditing, and high‑availability scenarios.
This article details a step‑by‑step recovery of a ClickHouse 4‑shard, 3‑replica cluster after a node’s disks failed, covering verification of residual data, Zookeeper metadata cleanup, table reconstruction, distributed table restoration, and validation of synchronization across replicas.
The article details Linear's most severe five‑year outage caused by an accidental TRUNCATE CASCADE on a PostgreSQL table, walks through the minute‑by‑minute timeline, explains why CI checks missed the error, and outlines the recovery steps and post‑mortem lessons for future database safety.
The article explains how to respond to accidental MySQL data deletion by analyzing loss causes, choosing recovery methods such as mysqldump backups, binary‑log point‑in‑time restores, or Percona’s InnoDB tool, provides step‑by‑step commands, and recommends preventive practices like regular backups, transactions, and strict permissions.
This guide explains how to answer MySQL accidental deletion interview questions and outlines practical recovery methods—including backup restoration, binlog usage, third‑party tools—and essential preventive practices such as regular backups, transaction handling, and permission management.
This guide walks through locating the Docker volume of a removed MySQL container, creating a new container with the same image, and swapping the volumes to restore the original database, providing step‑by‑step commands and screenshots for successful data recovery.
This article explains Redis AOF persistence, covering how the Append‑Only File logs write commands, the configuration options for enabling and syncing AOF, the rewrite process that compresses the log, and how AOF compares with RDB snapshots and hybrid persistence for reliable data recovery.
Vivo replaced its fragile Python‑Celery backup system on GlusterFS—characterized by two‑day MySQL backups, single‑point failures, and weak security—with a Java‑based architecture using a Redis cluster and object storage, adding automated copying, verification, point‑in‑time recovery and migration, cutting backup windows to about ten hours and achieving near‑100 % success.
A developer recounts accidentally running rm -fr /* on a production server, explains how quick interruption, clever use of remaining commands, and step‑by‑step recovery restored critical directories, and shares practical safeguards to prevent such catastrophic deletions in the future.
This guide walks through setting up a test environment, extracting binlog positions, generating rollback SQL with the my2sql tool, and safely re‑importing the data to restore rows mistakenly removed by a DELETE statement.
This tutorial demonstrates how to use PHP to create a backup directory, export MySQL tables to text files, and restore them by reading the files and executing INSERT statements, providing complete code examples for both backup and recovery processes.
reverse_sql is an open‑source utility that parses MySQL binary logs in ROW format, generates both original and reverse SQL statements, and helps recover data from accidental DML operations using multithreaded processing and flexible filtering options.
When a mistaken UPDATE statement overwrites an entire Oracle table, this guide explains four practical recovery techniques—including transaction rollback, flashback queries, LogMiner undo extraction, and RMAN backup restoration—detailing their prerequisites, commands, and trade‑offs.
This article explains how Redis ensures data durability by using two persistence strategies—Append Only File (AOF) and Redis Database (RDB) snapshots—detailing their operation, configuration options, trade‑offs, rewrite processes, and how they handle expired keys and recovery.
This article provides an in‑depth overview of MySQL backup classifications—including hot, warm, and cold backups—explains physical versus logical backup methods, compares built‑in and third‑party tools such as mysqldump, mysqlhotcopy, LVM snapshots, XtraBackup, and presents step‑by‑step command examples for each approach.
This article explains how deleted files remain on storage until overwritten, describes the role of the file allocation table and magic numbers, and provides step‑by‑step instructions for using TestDisk, command‑line tools, and secure‑delete utilities to recover or permanently erase files on Linux systems.
This guide explains why deleted files remain recoverable, how file allocation tables and magic numbers enable recovery, and provides step‑by‑step instructions for using TestDisk, handling device names, restoring open files, and securely erasing data on Linux systems.
This article explains how Redis ensures data durability by describing the two persistence mechanisms—RDB snapshots and AOF append‑only logs—including their creation, loading, configuration options, performance trade‑offs, and guidance on choosing the appropriate method for different workloads.
The article narrates how Redis, personified as a character, discovers data loss risks, implements RDB snapshotting and configurable save intervals, learns from MySQL's binary log, adopts Append‑Only File logging with flush policies, and finally adds AOF rewrite to keep storage efficient.
This guide explains TiDB Binlog fundamentals, its Pump‑Drainer architecture, how to scale Drainer nodes, use the Reparo tool to parse binlog files, and combine full backups with binlog for reliable data recovery after accidental deletions.
This guide explains how to restore a mistakenly dropped MySQL table by enabling binlog, creating backups, extracting relevant statements from the binlog, editing out DROP commands, and re‑importing the data to recover the table to its state before deletion.
This guide explains what MySQL binlog is, how to enable it in a Docker container, common binlog commands for inspection and maintenance, and demonstrates a step‑by‑step data recovery scenario using mysqlbinlog to restore a mistakenly dropped database.
This article explains how to prevent data loss in MySQL by enabling binlog in ROW format, performing full and incremental restores using mysqldump or XtraBackup, executing point‑in‑time recovery, restoring individual tables, skipping erroneous SQL statements, and using flashback tools such as binlog2sql and MyFlash.
This article explains how to safeguard PostgreSQL against data loss by using event triggers to block risky DDL operations, implementing a recycle‑bin approach for deleted objects, and applying delayed streaming replication or physical backup techniques for effective data recovery.
This article explains why PostgreSQL data loss occurs, compares DDL and DML causes, and reviews several recovery tools—including pg_resetwal, pg_dirtyread, pg_recovery, pg_filedump, WalMiner, and pageinspect—providing usage examples, summaries, and practical recommendations for effective data restoration.
This guide explains why careful file deletion matters, introduces Linux tools like lsof and extundelete for recovering mistakenly removed files, and provides step‑by‑step commands, installation instructions, and precautions to maximize recovery success while avoiding data loss.
This article introduces the open‑source pg_recovery tool for PostgreSQL, explains how to install it, and demonstrates recovering data lost through UPDATE, DELETE, ROLLBACK, and DROP COLUMN operations with practical command‑line examples.
After a client mistakenly imported 60,000 useless rows and a developer’s faulty delete command erased over 100,000 critical records, this guide explains how to use MySQL binlog to locate, extract, and replay the missing SQL statements, restore the data, and prevent future disasters.
This article recounts a real-world incident where a client mistakenly imported 60,000 rows of erroneous Excel data into a MySQL production database, leading to an accidental bulk delete, and explains how the team used MySQL binlog to recover the lost data while offering practical safeguards to prevent similar disasters.
This article explains how PolarDB‑X classifies different data‑deletion scenarios, compares traditional recovery methods like PITR, Flashback Query, and binlog‑based tools, and introduces its precise SQL‑level flashback feature that uses TraceID to quickly and accurately restore mistakenly deleted rows.
After a junior staff member mistakenly ran an unchecked rm‑rf command that erased an entire production server, the author details a step‑by‑step recovery using ext3grep, custom shell scripts, extundelete, and MySQL binlog replay, and concludes with lessons on backup, monitoring, and change management.
This guide explains how to protect MySQL data with proper backups and row‑format binlogs, then walk through full restores using mysqldump or xtrabackup, point‑in‑time recovery from binlogs, single‑table restoration, skipping erroneous SQL statements, and flashback tools like binlog2sql and MyFlash.
This article examines how misplaced quotation marks in MySQL UPDATE statements can unintentionally set fields to zero, explains MySQL’s implicit type conversion that causes the condition to always evaluate true, and offers practical steps for detecting and preventing such bugs.
A developer’s production fix using dozens of UPDATE statements unintentionally set a column to zero because of misplaced quotation marks, illustrating how MySQL’s implicit conversion and syntax quirks can turn seemingly correct SQL into disastrous data loss.
The article explains how incorrectly placed double‑quotation marks in MySQL UPDATE statements change the intended string assignment into a boolean comparison that evaluates to 0, leading to all affected rows being updated with zero values, and shows how to detect and avoid this pitfall.
This guide walks through a step‑by‑step experiment that shows how to recover MySQL files from a Linux virtual machine that cannot boot, by mounting its disk on a new VM, activating LVM volumes, copying configuration and data files, and restarting the database.
This article demonstrates how to recover MySQL data from a crashed Linux virtual machine by mounting its disk on a new VM, activating LVM logical volumes, copying configuration and data files, and restarting MySQL, illustrating a practical data rescue workflow.
This guide explains how to verify that MySQL binlog is enabled, locate binlog files, use the mysqlbinlog utility to extract change logs for specific time ranges or tables, and apply the extracted SQL to recover or roll back erroneous data modifications.
This article recounts a production server data loss caused by an erroneous rm -rf command, describes how ext3grep and extundelete were used to attempt file restoration, and explains how MySQL binlog replay finally recovered critical data while sharing lessons learned for future incident handling.
This article details a real‑world MySQL production data loss incident, explains how to identify the relevant binlog range, use binlog2sql and MyFlash to generate reverse SQL or binary logs, and outlines the step‑by‑step recovery process and post‑mortem reflections for operations teams.
The article explains how incorrectly placed quotation marks in MySQL UPDATE statements can cause expressions like "str_col=\"xxx\" = \"yyy\"" to evaluate to zero, leading to unintended data overwrites and highlights the importance of testing SQL in safe environments.
After a Fusion Computer CNA node crashed and the VRM platform became unavailable, the author recovered lost virtual machines by locating disk images, fixing OVS flow tables, using an scp command with strict host‑key checking disabled, and recreating VMs, sharing key lessons for reliable operations.
The article describes how Bitcoin‑based ransomware such as WannaRen encrypts victims' files, the large‑scale attacks on Chinese enterprises and institutions, the police investigations that led to the arrest of the mastermind Ju Mou and his accomplices, and practical advice for preventing such threats.
This article explains the structure of MySQL ROW‑mode binlogs, demonstrates how to modify binlog events with Python to recover deleted rows, locate oversized transactions, and split large transactions into smaller ones, providing practical scripts and examples for advanced database manipulation.
This article demonstrates how to recover mistakenly deleted InnoDB .ibd files by locating the open file handle through Linux procfs, locking database traffic, copying the hidden file, and restoring it to a running MySQL instance.
This article introduces Microsoft’s Windows File Recovery command‑line utility, explains its supported file types and recovery modes, details key parameters, shows how to run the winfr command, and provides the download link for quick data restoration.
This guide explains how to restore MySQL databases when the server cannot start by generating table definitions with mysqlfrm, discarding damaged InnoDB tablespaces, copying old .ibd files, and importing them back, followed by verification using mysqlcheck.
This guide explains how to use MySQL binary logs and GTID to restore accidentally deleted data, covering configuration changes, command‑line operations, extracting relevant log segments, and verifying the restored tables step by step.
This guide demonstrates how to recover MySQL 5.7 data after an accidental UPDATE by extracting row‑based binlog entries, converting them into executable SQL statements, and applying those statements to restore the original table contents.
This tutorial explains LVM snapshot principles, walks through preparing a logical volume, creating and mounting snapshots, handling common XFS UUID errors, restoring data manually or via snapshot merge, and provides practical commands and images for each step.
When a sudden incident deletes uploaded data from the /data/webapps/.../upload directory without backups, this guide walks you through installing extundelete (via EPEL or source), locating the deleted inodes, and using extundelete commands to recover the files, while explaining why read‑only mounting is essential.
A production server suffered catastrophic data loss after an rm -rf command erased the entire disk, prompting a frantic recovery effort that leveraged ext3grep, extundelete, and MySQL binlog to restore critical MySQL tables and bring the service back online.
This guide explains how to restore MySQL InnoDB tables and their dictionary metadata after accidental drops, corruption, or disk failures by using the undrop‑for‑innodb toolkit, parsing system tables, and executing a series of command‑line steps to rebuild schema and data.
This article recounts a production‑server disaster caused by an unchecked rm -rf command, details the step‑by‑step data‑recovery attempts using ext3grep, extundelete and MySQL binlogs, and shares hard‑earned lessons to prevent similar incidents.
After a junior teammate mistakenly ran an unchecked rm -rf command that wiped an entire production server, the author chronicles the frantic use of ext3grep, extundelete, and MySQL binlog recovery to restore critical data, sharing hard‑won lessons for future prevention.
After costly data‑deletion mishaps, 37 Interactive Entertainment engineered a robust, multi‑region backup platform that evolved from simple cron scripts to streaming xtrabackup with Celery‑driven task queues, encrypted HDFS/S3 storage, automated rotation and restore verification, ensuring reliable protection against high‑impact data loss.
This article provides a detailed analysis of Redis's two persistence mechanisms—RDB snapshots and AOF logging—covering their core concepts, implementation details, trigger conditions, data safety, performance impact, and recovery speed to help engineers choose the appropriate method for their workloads.
This article discusses MySQL table design choices, partitioning methods, index best practices, common causes of slow queries with optimization tips, useful diagnostic tools, and recommended actions when accidental operations or bugs affect data.
A developer’s series of MySQL UPDATE statements unintentionally set a column to zero due to misplaced quotation marks, and the article explains how MySQL parses such syntax, the resulting data loss, and best practices to avoid similar errors.
This article explains the two types of SSD power loss—normal and abnormal—detailing how SSDs preserve data, the role of capacitors and non‑volatile memory, and the checkpoint‑based strategies used to quickly reconstruct mapping tables after unexpected power interruptions.
This guide explains MariaDB 10.3 system-versioned tables, showing how to create them with PERIOD FOR SYSTEM_TIME, query historical rows using FOR SYSTEM_TIME clauses, restore previous data via export/import, partition history to reduce storage, and safely manage versioning in production environments.
This article recounts a May 2018 incident where a missing WHERE clause caused a full‑table update of user asset data, detailing the step‑by‑step recovery attempts, iterative testing, and the key lessons learned about backup, simulation, and cautious production operations.
This article explains Redis's two persistence methods—RDB snapshots and AOF append‑only logs—including their operation, configuration options, advantages, disadvantages, and guidance on choosing the appropriate strategy for data durability and recovery.
The article examines how Continuous Data Protection (CDP) transforms traditional backup and disaster‑recovery approaches by offering near‑real‑time recovery points, finer granularity, and flexible implementation models across applications, files, and storage blocks, while comparing its benefits and trade‑offs with conventional methods.
When accidental deletion removes files from the /data/webapps/.../upload directory, this guide shows how to install extundelete, locate the relevant inodes, and safely recover the lost data using read‑only mounts and specific restore commands.
After a sudden incident deleted files from /data/webapps/xxxx/upload without backup, this guide walks through installing extundelete, locating the deleted inode data, and using extundelete commands to recover as much of the lost data as possible, including tips on mounting read‑only.
This guide explains why hard drives fail, distinguishes physical and logical damage, and reviews thirteen powerful data recovery utilities—complete with features, supported file systems, and usage tips—to help you restore lost files efficiently.
MyFlash is an open‑source MySQL binlog flashback tool that directly parses binlogs, filters events, reverses row operations, and generates a rollback binlog, offering faster, version‑compatible recovery than mysqlbinlog, binlog2sql, or patched MySQL, and is available on GitHub.
Oracle provides several powerful recovery mechanisms—logical backups with the import tool, physical file restoration with incomplete recovery, LogMiner analysis of redo logs, and Flashback Query—each illustrated through a scenario where a mistaken update to the TFUNDASSET table is corrected using step‑by‑step procedures and commands.
When a sales employee's workflow records vanished after a WeChat ID change, the team traced the deletion to MySQL binary logs, extracted the relevant log entries, and used bulk UPDATE statements to replace the old user_id with the new one, fully restoring the missing data.
After a mistaken rm -rf command wiped an entire production server—including MySQL data—the author chronicles a step‑by‑step recovery using ext3grep, custom scripts, and binlog restoration, highlighting lessons learned and best practices for future incident handling.