Re: "git pull . <branch>" versus "git merge <branch>"

Previous thread: git-apply quirks by Don Zickus on Tuesday, June 10, 2008 - 12:40 pm. (1 message)

Next thread: Help rescuing a repository by Luke Lu on Tuesday, June 10, 2008 - 6:19 pm. (4 messages)
From: Rene Herman
Date: Tuesday, June 10, 2008 - 5:51 pm

Good day.

The manpages seem to be making somewhat of a point of mentioning &quot;git 
pull . &lt;branch&gt;&quot; as the way to merge a local branch into the current one 
but a simple &quot;git merge &lt;branch&gt;&quot; seems to work well. Is there a difference?

Rene.
--

From: David Symonds
Date: Tuesday, June 10, 2008 - 6:06 pm

git pull also does a fetch in it's usual mode of operation, and runs
git merge to do merge changes in the remote-tracking branches.


Dave.
--

From: Rene Herman
Date: Tuesday, June 10, 2008 - 6:13 pm

So in the case of merging a branch from the local repository into the 
current branch, there is no difference between the two?

Rene.
--

From: Miklos Vajna
Date: Tuesday, June 10, 2008 - 6:56 pm

On Wed, Jun 11, 2008 at 03:13:45AM +0200, Rene Herman &lt;rene.herman@keyacces=

There is no difference, but you really want to use git merge and not git
pull in such a case, I guess the git pull form is supported mainly to
keep backwards compatibility.
From: Rene Herman
Date: Tuesday, June 10, 2008 - 7:01 pm

Thanks much, nice and clear! It might be good to adjust the git-pull 
manpage a bit if the merge is preferred? It sorts of sounds like its 
advertising the pull method now.

Regards,
Rene
--

From: Paolo Bonzini
Date: Tuesday, June 10, 2008 - 7:04 pm

However, when you're on a tracking merge only &quot;git pull&quot; will merge the 
right branch automatically into the current branch, fetching the branch 
name to merge from the config.  If the branch.*.remote config key is 
&quot;.&quot;, it will do a local merge.

Note that &quot;git pull .&quot; is optimized in that the fetch does nothing 
except setting up MERGE_HEAD.

Paolo
--

From: Rene Herman
Date: Tuesday, June 10, 2008 - 7:09 pm

Rene.
--

From: Paolo Bonzini
Date: Tuesday, June 10, 2008 - 10:23 pm

Tracking *branch*, sorry.  A branch that has configuration options like

	[branch &quot;foo&quot;]
		remote = origin
		merge = next

so that git knows that, when you're on branch foo, &quot;git pull&quot; is 
actually equivalent to &quot;git pull origin next:foo&quot;.

Paolo
--

From: Daniel Barkalow
Date: Wednesday, June 11, 2008 - 10:56 am

Those manpage sections predate the existance of &quot;git merge &lt;branch&gt;&quot;. If 
you're not planning to use git before November 2006, there's no reason to 
use the &quot;git pull .&quot; form. They should probably be replaced with more 
helpful examples at this point.

	-Daniel
*This .sig left intentionally blank*
--

From: Brandon Casey
Date: Wednesday, June 11, 2008 - 11:32 am

Was there some past discussion of the ui merits of a separate 'merge' command
for dealing with local merges and a 'pull' command for remote merges? I
understand merge is the backend. The question has to do with the high-level
user interface: one command or two? Why wasn't git-pull enough?

I ask because elsewhere in this thread Miklos suggests that git-merge should
be preferred over git-pull when dealing with a local repostory and you suggest
here that the documentation should be updated to use the 'git merge' method
instead of 'git pull'. I had the impression that git-merge was only used by
those who had not yet gotten their mind around the pull methodology. So it
was more of an 'ease the transition from other SCMs' rather than the recommended
way of doing things.

-brandon

--

From: Daniel Barkalow
Date: Wednesday, June 11, 2008 - 12:46 pm

&quot;git pull . &lt;branch&gt;&quot; does &quot;git fetch . &lt;branch&gt;&quot; and then merges it. Of 
course, &quot;git fetch . &lt;branch&gt;&quot; does nothing at all, and it's weird as a 
user interface to have the only (simple) way of selecting something to 
merge be to fetch it as if from a remote repository, but from the local 
repository. After all, no other purely local operation requires you to 

I think everybody uses &quot;git merge&quot; instead of &quot;git pull .&quot; these days. 
It's shorter and less fiddly to type, and doesn't polute your bash reverse 
search for &quot;git pull&lt;tab&gt;&quot; with local things. And, if you've got a bunch 
of local branches, which is not uncommon and very much native to git, the 
intuitive thing is to merge them with &quot;git merge&quot; instead of treating them 
as if they weren't local.

It's also now pretty common to want to do &quot;git fetch &lt;remote&gt;&quot;, inspect 
it, decide whether this is something you want to merge (and depend on), 
and do &quot;git merge &lt;tracking&gt;&quot; to include it in your branch if you want it. 
(And being able to fetch stuff from a remote location, and later do a 
merge without any non-local information is also very git-style.)

Of course, if you're pulling from a remote repository, you generally want 
to use &quot;git pull&quot;, but you wouldn't be using &quot;git pull .&quot;

	-Daniel
*This .sig left intentionally blank*
--

From: Brandon Casey
Date: Wednesday, June 11, 2008 - 2:01 pm

I don't agree with this paragraph. I think it _would_ be weird if you had
to type 'git fetch' and then 'git merge' (or git pull) when operating on
a local repository, but that is not necessary. It is only necessary to
type 'git pull'. There is symmetry between operating on a remote repository
and operating on a local repository. The user does not need to know that
a noop fetch is first performed, or whether the pull command detects that
it is operating on a local repository and just skips the fetch, any more than
the user is required to know the exact sequence of events that allows an ssh

Not sure about this one either. I think git-merge is intuitive to those who are
familiar with the operation of git-pull, specifically those that understand how
to use git-fetch and that git-pull does a fetch and then a merge. For those new
to git, I think git-fetch takes a little while to get a handle on.

git-pull allows treating all branches as equal for merging purposes. A user does
not have to differentiate between a local and a remote branch by using different
commands. So I did not see it as 'treating [a local branch] as if they weren't local',
but instead as a single command to merge branches regardless of whether they are
local or remote.

Suggesting git-merge is what requires the user to make a distinction between local

Yes, I agree that it is common to fetch and inspect before merging. The
'git merge &lt;tracking&gt;' could have been 'git pull . &lt;tracking&gt;', which only
requires typing one additional character. The user _must_ know how to use
git-pull, and the concept of '.' as a placeholder for the local repository
takes only a moment to digest. git-merge is an additional command that the
user must know when to use and when not to use. Well maybe that exaggerates
the point a little, git-merge is not that complicated, but it is an additional
command to learn with little benefit that I see.

To summarize my point, I think the recommended advertised merge command could
be one single ...
From: Mikael Magnusson
Date: Wednesday, June 11, 2008 - 2:49 pm

I've used git for a couple of months, and I've never used git-pull, only fetch
and merge. To me it doesn't make any sense that you would want to merge changes
without looking at them first. It also seems very strange to me to treat
not-yet-fetched branches on a remote the same as a local branch. I don't really
have any useful input other than that you shouldn't assume what other people

For me, git-pull is that additional command, and using git-pull .
&lt;branch&gt; to merge

The output of git-reflog is easier to read when you know what you're
looking for,
the actual commit message and author info that log outputs is usually
superfluous.

-- 
Mikael Magnusson
--

From: Rene Herman
Date: Wednesday, June 11, 2008 - 5:56 pm

For what it's worth I (as thread starter) agree with this. At least in 
my mind local and remote branches are very different and I do not mind 
having to &quot;fetch&quot; the latter first before merging (nor combine the two 
through a &quot;pull&quot;).

I can see the reason for the other viewpoint as well since it emphasises 
a point about local and remote branches _not_ being very different after 
all but that's more a symmetry to the implementor than it is to a user I 
feel. For the user, local and remote branches just are different.

And as such I feel it actually helps to just use &quot;merge&quot;. Thanks for the 
answers everyone -- this was a matter of a user worrying that he wasn't 
getting it...

Rene
--

From: Junio C Hamano
Date: Wednesday, June 11, 2008 - 4:01 pm

There isn't any.

&quot;git pull . this_branch&quot; is just a natural and logical consequence that
you can fetch and merge a branch B from remote U with &quot;git pull $U $B&quot;.

&quot;git merge that_branch&quot; exists and useful because people on average merge
local branches more than they fetch and merge from remote repository.


--

From: Rene Herman
Date: Wednesday, June 11, 2008 - 6:00 pm

Thank you. Slowly getting more comfortable with git...

Rene.
--

Previous thread: git-apply quirks by Don Zickus on Tuesday, June 10, 2008 - 12:40 pm. (1 message)

Next thread: Help rescuing a repository by Luke Lu on Tuesday, June 10, 2008 - 6:19 pm. (4 messages)