How to Revert a Git Merge Commit?

When working with Git, merge commits are created to combine changes from one branch into another, integrating new features, bug fixes, or updates. However, there are times when you may need to revert a merge commit—for example, if it introduced a bug, caused conflicts, or if a feature needs to be rolled back temporarily.

In this post, we’ll cover what a merge commit is, scenarios where reverting a merge commit is necessary, and different methods to safely revert a merge commit in Git.

Understanding Merge Commits

A merge commit is a special type of commit in Git that represents the merging of two branches. It has two or more parent commits, as it brings changes from one branch into another. Unlike regular commits, which have a single parent, merge commits are unique because they capture the history of both branches.

Reasons to Revert a Merge Commit

There are various reasons you may want to revert a merge commit:

• Bug Introduction: The merged branch introduced bugs that need to be removed from the main branch.
• Feature Rollback: The feature introduced by the merge commit needs to be temporarily removed or postponed.
• Conflict Resolution Issues: The merge was unsuccessful or caused issues that need to be resolved differently.

Reverting a merge commit doesn’t mean permanently deleting it; instead, it creates a new commit that undoes the changes introduced by the merge, allowing you to maintain a clear history of all changes.

How to Identify a Merge Commit

To revert a merge commit, you’ll need to identify the specific merge commit you want to revert. Use the following command to view your commit history:

git log --oneline --graph

In the output, merge commits will appear as commits with multiple parents. They are usually labeled with “Merge branch …” messages. Once you’ve identified the merge commit you want to revert, note down its hash (a unique identifier for each commit in Git).

How to Revert a Merge Commit

There are two main ways to revert a merge commit in Git:

1. Revert with git revert -m: This is the most common and safest method, creating a new commit that undoes the changes introduced by the merge.
2. Rollback with git reset: This method is more aggressive and is typically used when you’re working alone or on a feature branch.

Method 1: Using git revert -m

The git revert -m command allows you to safely undo a merge commit by creating a new commit that reverses its changes. This method is generally recommended because it preserves the branch’s history and makes it easier for other team members to follow.

Steps to Revert a Merge Commit with git revert -m

1. Identify the Merge Commit Hash Use git log --oneline or git log --graph to identify the merge commit hash. For example:

   git log --oneline --graph

Suppose you want to revert a merge commit with the hash abc123.

2. Use the git revert Command with the -m Flag Run the following command to revert the merge commit:

   git revert -m 1 <merge-commit-hash>

Replace <merge-commit-hash> with the actual hash (e.g., abc123). The -m flag tells Git which parent branch to keep. Most commonly, -m 1 is used, which retains the main branch while reverting the merged branch.

• -m 1: Refers to the first parent, which is typically the branch you’re currently on.
• -m 2: Refers to the second parent, which is the branch that was merged.

1. Commit the Reversion Git will automatically create a new commit that undoes the changes from the merge. You can push this commit to your remote branch to share the reversion with your team:

   git push origin <branch-name>

Example of Reverting a Merge Commit

Let’s say the merge commit you want to revert has the hash abc123, and it merged the feature-branch into main. To revert this merge, you would run:

git revert -m 1 abc123

This command creates a new commit on main that undoes the changes from feature-branch.

Method 2: Using git reset (Caution Required)

The git reset command is a more aggressive way to remove commits, as it moves the branch pointer to an earlier commit and effectively “deletes” the subsequent commits. This approach rewrites history and should be used with caution, especially if you are working in a shared repository.

This method is usually safe only in private or feature branches and when you are certain no one else has pulled the merge commit.

Steps to Rollback with git reset

1. Identify the Commit Prior to the Merge Find the hash of the commit right before the merge commit. For example, if the merge commit is abc123, the prior commit may be xyz456.
2. Use git reset to Move the Branch Pointer Run the following command to reset your branch to the earlier commit:

   git reset --hard <previous-commit-hash>

Replace <previous-commit-hash> with the hash of the commit before the merge (e.g., xyz456).

3. Push the Changes If you’re working in a remote branch and need to push the changes, you’ll need to force push:

   git push --force origin <branch-name>

Warning: git reset --hard will delete any changes after the specified commit. Use it cautiously, especially when working in a shared repository.

Example of Using git reset to Undo a Merge Commit

Suppose you’re on main, and you want to roll back to the commit xyz456, right before the merge commit abc123. You would run:

git reset --hard xyz456
git push --force origin main

This will move the main branch back to xyz456, effectively removing the merge commit and any other commits after xyz456.

Best Practices for Reverting a Merge Commit

• Prefer git revert over git reset: In shared branches, using git revert -m is generally safer and maintains a clear history.
• Communicate with Your Team: Inform your team about the reversion, especially if working on a shared branch. They may need to rebase or reset their local branches.
• Avoid Force Pushing to Main Branches: If you must use git reset, avoid using it on main branches where other team members are working, as it can lead to merge conflicts and lost changes.

Troubleshooting Common Issues

• Conflict During Revert: If you encounter conflicts while reverting, Git will pause for you to resolve them. Follow the instructions to manually resolve conflicts, then use git revert --continue to complete the revert.
• Mistaken Revert: If you accidentally revert a merge, you can revert the revert by identifying the revert commit and using git revert <revert-commit-hash>.

Summary

Reverting a merge commit in Git is a common but essential skill for managing codebases and maintaining stability in your branches. Here’s a quick recap:

1. Identify the Merge Commit: Use git log to find the merge commit hash.
2. Choose Your Revert Method:

• git revert -m 1 <merge-commit-hash>: The safest option, recommended for shared branches.
• git reset --hard <previous-commit-hash>: Only for private branches, as it rewrites history.

1. Commit and Push: Push the reversion to the remote repository and inform your team if necessary.

By using these techniques and best practices, you can confidently revert merge commits in Git while minimizing risks to your workflow.