Re: Pull and fetch

Hi all, I'm still reading git tutorial.txt and I'm again confused.

  A more cautious Alice might wish to examine Bob's changes before
  pulling them.  She can do this by creating a temporary branch just
  for the purpose of studying Bob's changes:

  -------------------------------------
  $ git fetch /home/bob/myrepo master:bob-incoming
  -------------------------------------

  which fetches the changes from Bob's master branch into a new branch
  named bob-incoming.  (Unlike git pull, git fetch just fetches a copy
  of Bob's line of development without doing any merging).  Then

  -------------------------------------
  $ git log -p master..bob-incoming
  -------------------------------------

  shows a list of all the changes that Bob made since he branched from
  Alice's master branch.

OK, make sense. So let's try with an experiment:
paolo@paolo-desktop:~$ mkdir test
paolo@paolo-desktop:~$ cd test
paolo@paolo-desktop:~/test$ git-init-db 
defaulting to local storage area
paolo@paolo-desktop:~/test$ git fetch ../git master:testbranch
warning: no common commits
remote: Generating pack...
[skip]
paolo@paolo-desktop:~/test$ git pull ../git master:testbranchpull
* refs/heads/testbranchpull: storing branch 'master' of ../git
  commit: e945f95

Now I have 3 branches:
paolo@paolo-desktop:~/test$ git branch
* master
  testbranch
  testbranchpull

All the branches have the same content, I expect to see differences between testbranch and testbranchpull. The first one is the end result of a fetch, the second one is the end result of a pull.

git status always says:
  nothing to commit

Why?
What will happen if I repeat the same commands:
  git fetch ../git master:testbranch
  git pull ../git master:testbranchpull
after a change in the git master branch?

Thanks in advance?

Kind regards, Paolo Ciarrocchi

On Thu, 23 Nov 2006 20:39:50 +0100 Paolo Ciarrocchi <paolo.ciarrocchi@gmail.com> wrote:

At this point your "master" branch will be empty. You can see this by doing a "git log"

If you do "git log" at this point you'll see your master branch is still empty. All you've done is fetched the remote branch into your new repo as "testbranch"

This command is different than fetch. After fetching the remote branch into your repo as "testbranchpull", it then merges it with your currently checked out branch (master). At this point if you do a "git log" you'll see your master is now populated with the results of the merge (well in this case a fast forward).

So this nicely shows the difference of fetch and pull, and explains how your "master" branch came to have something in it.

Yes, they will all have the same content. As your local repo diverges from the remote (as you make local commits) the difference between fetch and pull will become more obvious and pronounced.

This just means you have no uncommitted local changes in your repo. Edit one of the file, and before committing the change, do "git status" again and it will list the file as modified.

Try it out :o)

Afterward, both testbranch and testbranchpull will be direct copies of the other repo's master. The fetch command will do nothing to "master". However, after updating your testbranchpull, the pull command will merge (or fast forward) its contents into "master".

Cheers,

On Thu, Nov 23, 2006 at 08:39:50PM +0100, Paolo Ciarrocchi wrote:

Your experiment is quite different from what's described above; you're fetching into an *empty* repository, instead of fetching a branch that diverged from the work in the repository:

and you're running "pull" with a syntax that has so far only been introduced for "fetch":

By its nature a tutorial tends to follow a narrow path, and not offer much explanation of what will happen if you stray from that path.

That said, I agree that the treatment of pull and fetch here could be better. And the ref:ref syntax for pull may be an obvious enough thing to try that we should document it here. Just as long as we keep it short....

Attempt to clarify somewhat the difference between pull and merge, and give a little more details on the pull syntax.

I'm still not happy with this section: the explanation of the origin branch isn't great, but maybe that should be left alone pending the use-separate-remotes change; and we need to explain how to set up a public repository and push to it.

Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
---
 Documentation/tutorial.txt |   41 ++++++++++++++++++++++++++---------------
 1 files changed, 26 insertions(+), 15 deletions(-)

On 11/26/06, J. Bruce Fields <bfields@fieldses.org> wrote:

A lot more clear in my opinion.

Acked-by: Paolo Ciarrocchi <paolo.ciarrocchi@gmail.com>

Ciao,

On 11/23/06, Sean <seanlkml@sympatico.ca> wrote:

Fair enough.

OK

Thanks, now I think I have a clear picture. I think it's worth to add some more info to tutorial.txt about difference between fetch and pull. I don't believe I'm the only confused user ;-)

I was confused by the "merge" terminology, if I fetch to an empty branch the concept of copy is easy to be understood, but if I fetch to a branch that contains data then it's somehow more difficult to think about fetching without thinking of "merge the remote branch into local".

But now I think I understood it ;-)

Sure, sorry about that. It was not my intention, I just pressed the wrong button :)

Regards,