Git Pull | Atlassian Git Tutorial (2024)

Git pull usage

How it works

The git pull command first runs git fetch which downloads content from the specified remote repository. Then a git merge is executed to merge the remote content refs and heads into a new local merge commit. To better demonstrate the pull and merging process let us consider the following example. Assume we have a repository with a mainbranch and a remote origin.

In this scenario, git pull will download all the changes from the point where the local and maindiverged. In this example, that point is E. git pull will fetch the diverged remote commits which are A-B-C. The pull process will then create a new local merge commit containing the content of the new diverged remote commits.

In the above diagram, we can see the new commit H. This commit is a new merge commit that contains the contents of remote A-B-C commits and has a combined log message. This example is one of a few git pull merging strategies. A --rebase option can be passed to git pull to use a rebase merging strategy instead of a merge commit. The next example will demonstrate how a rebase pull works. Assume that we are at a starting point of our first diagram, and we have executed git pull --rebase.

In this diagram, we can now see that a rebase pull does not create the new H commit. Instead, the rebase has copied the remote commits A--B--C and rewritten the local commits E--F--G to appear after them them in the local origin/maincommit history.

Common Options

gitpull<remote>

Fetch the specified remote’s copy of the current branch and immediately merge it into the local copy. This is the same as git fetch ＜remote＞ followed by git merge origin/＜current-branch＞.

gitpull--no-commit<remote>

Similar to the default invocation, fetches the remote content but does not create a new merge commit.

gitpull--rebase<remote>

Same as the previous pull Instead of using git merge to integrate the remote branch with the local one, use git rebase.

gitpull--verbose

Gives verbose output during a pull which displays the content being downloaded and the merge details.

Git pull discussion

You can think of git pull as Git's version of svn update. It’s an easy way to synchronize your local repository with upstream changes. The following diagram explains each step of the pulling process.

You start out thinking your repository is synchronized, but then git fetch reveals that origin's version of mainhas progressed since you last checked it. Then git merge immediately integrates the remote maininto the local one.

Git pull and syncing

Pulling via Rebase

gitconfig--globalbranch.autosetuprebasealways

After running that command, all git pull commands will integrate via git rebase instead of git merge.

Git Pull Examples

The following examples demonstrate how to use git pull in common scenarios:

Default Behavior

gitpull

Executing the default invocation of git pull will is equivalent to git fetch origin HEAD and git merge HEAD where HEAD is ref pointing to the current branch.

Git pull on remotes

gitcheckoutnew_feature
gitpull<remoterepo>

This example first performs a checkout and switches to the branch. Following that, the git pull is executed with being passed. This will implicitly pull down the newfeature branch from . Once the download is complete it will initiate a git merge.

Git pull rebase instead of merge

The following example demonstrates how to synchronize with the central repository's mainbranch using a rebase:

gitcheckoutmain
gitpull--rebaseorigin

This simply moves your local changes onto the top of what everybody else has already contributed.

Share this article

Next Topic