Recover specific data by using Git commands

• 3 minutes

The ability to recover data by using Git commands is crucial for developers to revert accidental changes, restore deleted files, or recover lost commits. It contributes to minimizing unexpected downtime and ensuring project continuity. However, while its benefits are clear, it's important to point out its potential risks. When applying the Git command described in this unit, it's essential to exercise proper caution, especially when manipulating commit history or reverting changes, as mistakes can lead to data loss.

Git data recovery commands

Git commands that deal with data recovery can be grouped into several categories, including recovering commits, files, specific lines of code, and deleted commits or branches.

Recovering commits

• git log: lists the commit history of a repository. You can navigate through the log to find the commit you want to recover.
• git checkout <commit>: switches to a specific commit, effectively "recovering" the state of the repository at that commit.
• git cherry-pick <commit>: applies the changes introduced by a specific commit onto your current branch.

Recovering files

• git checkout <commit> <file>: restores a specific file from a previous commit.
• git restore <file>: discards local changes and restores the file to its last committed state, assuming that you haven't yet committed the changes.

Recovering specific lines of code

• git blame <file>: displays the revision and author of each line in a file, helping you identify the commit that introduced a particular change.
• git show <commit>:<file>: displays the content of a file at a specific commit. You can specify the commit and file path to see the content as it existed at that point in time.

Recovering deleted commits or branches

• git reflog: displays a record of all commits. You can use it to find the SHA-1 hash of a previously deleted commit or branch and then checkout or restore it.
• git fsck --lost-found: checks the integrity of the repository and lists any commits that aren't reachable from any branch or tag. You can use this to recover lost commits.

Remember to use these commands with caution, especially when manipulating commit history or reverting changes. Always make sure to create a backup of your repo before you start or use git stash to save your current changes before attempting any recovery operations.

Sample scenario

Let's step through a sample scenario that illustrates the process of using Git commands to recover a deleted file. We assume that a file named example.txt residing in your Git repository has been accidentally deleted and you need to recover it.

Viewing Commit History:

• Start by displaying the commit history:
  git log
• In the commit history listing identify the SHA-1 hash of the commit where the file example.txt was last present.

Restoring the Deleted File:

• Once you've identified the SHA-1 hash of the commit, use git checkout to restore the file:
  git checkout <commit_SHA>^ -- example.txt
• Replace <commit_SHA> with the SHA-1 hash of the commit. The ^ symbol indicates the parent of that commit, effectively restoring the file to its state before deletion.

Verifying Changes:

• After restoring the file, verify that it has been successfully restored by checking the repository status:
  git status
• Validate that example.txt listed as a modified or untracked file.

Staging and Committing Changes:

• If the file is listed as modified, stage it for commit:
  git add example.txt
• Commit the changes with an appropriate commit message:
  git commit -m "Restored example.txt"