How to preview git-pull?

After doing a git fetch, do a git log HEAD..origin/master to show the log entries between your last common commit and the origin's master branch. To show the diffs, use either git log -p HEAD..origin/master to show each patch, or git diff HEAD...origin/master (three dots not two) to show a single diff.

There normally isn't any need to undo a fetch, because doing a fetch only updates the remote branches and none of your branches. If you're not prepared to do a pull and merge in all the remote commits, you can use git cherry-pick to accept only the specific remote commits you want. Later, when you're ready to get everything, a git pull will merge in the rest of the commits.

Update: I'm not entirely sure why you want to avoid the use of git fetch. All git fetch does is update your local copy of the remote branches. This local copy doesn't have anything to do with any of your branches, and it doesn't have anything to do with uncommitted local changes. I have heard of people who run git fetch in a cron job because it's so safe. (I wouldn't normally recommend doing that, though.)

I think git fetch is what your looking for.

It will pull the changes and objects without committing them to your local repo's index.

They can be merged later with git merge.

Man Page

Edit: Further Explination

Straight from the Git- SVN Crash Course link

Now, how do you get any new changes from a remote repository? You fetch them:

git fetch http://host.xz/path/to/repo.git/ 

At this point they are in your repository and you can examine them using:

git log origin 

You can also diff the changes. You can also use git log HEAD..origin to see just the changes you don't have in your branch. Then if would like to merge them - just do:

git merge origin

Note that if you don't specify a branch to fetch, it will conveniently default to the tracking remote.

Reading the man page is honestly going to give you the best understanding of options and how to use it.

I'm just trying to do this by examples and memory, I don't currently have a box to test out on. You should look at:

git log -p //log with diff

A fetch can be undone with git reset --hard (link) , however all uncommitted changes in your tree will be lost as well as the changes you've fetched.

This useful commands below I picked from this link https://gist.github.com/jtdp/5443297. Thanks to https://gist.github.com/jtdp

git fetch origin

# show commit logs of changes
git log master..origin/master

# show diffs of changes
git diff master..origin/master

# apply the changes by merge..
git merge origin/master

# .. or just pull the changes
git pull

If you don't want git-fetch to update your local .git, just copy your local repo to a temp dir and do a pull there. Here is a shor-hand:

$ alias gtp="tar -c . | (cd /tmp && mkdir tp && cd tp && tar -x && git pull; rm -rf /tmp/tp)"

Ex.:

$ git status
# On branch master
nothing to commit (working directory clean)

$ gtp
remote: Finding sources: 100% (25/25)
remote: Total 25 (delta 10), reused 25 (delta 10)
Unpacking objects: 100% (25/25), done.
From ssh://my.git.domain/reapO
   32d61dc..05287d6  master     -> origin/master
Updating 32d61dc..05287d6
Fast-forward
 subdir/some.file       |    2 +-
 .../somepath/by.tes    |    3 ++-
 .../somepath/data      |   11 +++++++++++
 3 files changed, 14 insertions(+), 2 deletions(-)

$ git status
# On branch master
nothing to commit (working directory clean)

$ git fetch
remote: Finding sources: 100% (25/25)
remote: Total 25 (delta 10), reused 25 (delta 10)
Unpacking objects: 100% (25/25), done.
From ssh://my.git.domain/reapO
   32d61dc..05287d6  master     -> origin/master

$ git status
# On branch master
# Your branch is behind 'origin/master' by 3 commits, and can be fast-forwarded.
#
nothing to commit (working directory clean)

13 years later, you now have With a prefetch task in "git maintenance"^(man)

The prefetch task updates the object directory with the latest objects from all registered remotes.

For each remote, a git fetch command is run.
The refmap is custom to avoid updating local or remote branches (those in refs/heads or refs/remotes).
Instead, the remote refs are stored in refs/prefetch/<remote>/.
Also, tags are not updated.

This is done to avoid disrupting the remote-tracking branches.
The end users expect these refs to stay unmoved unless they initiate a fetch.

With prefetch task, however, the objects necessary to complete a later real fetch would already be obtained, so the real fetch would go faster.
In the ideal case, it will just become an update to a bunch of remote-tracking branches without any object transfer.

And you can also do, since Git 2.32 (Q2 2021) a git fetch --prefetch, again without modifying your last fetch state.

See commit 32f6788, commit cfd781e, commit 2e03115 (16 Apr 2021), and commit a039a1f (06 Apr 2021) by Derrick Stolee (derrickstolee).
^{(Merged by Junio C Hamano -- gitster -- in commit d250f90, 30 Apr 2021)}

fetch: add --prefetch option

^{Helped-by: Tom Saeger
Helped-by: Ramsay Jones
Signed-off-by: Derrick Stolee}

The --prefetch option will be used by the 'prefetch' maintenance task instead of sending refspecs explicitly across the command-line.
The intention is to modify the refspec to place all results in refs/prefetch/ instead of anywhere else.

Create helper method filter_prefetch_refspec() to modify a given refspec to fit the rules expected of the prefetch task:

• Negative refspecs are preserved.
• Refspecs without a destination are removed.
• Refspecs whose source starts with "refs/tags/" are removed.
• Other refspecs are placed within "refs/prefetch/".

Finally, we add the 'force' option to ensure that prefetch refs are replaced as necessary.

There are some interesting cases that are worth testing.

An earlier version of this change dropped the "i--" from the loop that deletes a refspec item and shifts the remaining entries down.
This allowed some refspecs to not be modified.
The subtle part about the first --prefetch test is that the refs/tags/* refspec appears directly before the refs/heads/bogus/* refspec.
Without that "i--", this ordering would remove the "refs/tags/*" refspec and leave the last one unmodified, placing the result in "refs/heads/*".

It is possible to have an empty refspec.
This is typically the case for remotes other than the origin, where users want to fetch a specific tag or branch.
To correctly test this case, we need to further remove the upstream remote for the local branch.
Thus, we are testing a refspec that will be deleted, leaving nothing to fetch.

fetch-options now includes in its man page:

--prefetch

Modify the configured refspec to place all refs into the refs/prefetch/ namespace.