Wie funktioniert "Git Merge" im Detail?

Ich möchte einen genauen Algorithmus (oder einen ähnlichen) hinter 'git merge' kennen. Die Antworten zumindest auf diese Unterfragen sind hilfreich:

• Wie erkennt git den Kontext einer bestimmten nicht widersprüchlichen Änderung?
• Wie findet Git heraus, dass es in genau diesen Zeilen einen Konflikt gibt?
• Welche Dinge führt Git automatisch zusammen?
• Wie funktioniert git, wenn es keine gemeinsame Basis für das Zusammenführen von Zweigen gibt?
• Wie funktioniert Git, wenn es mehrere gemeinsame Grundlagen für das Zusammenführen von Zweigen gibt?
• Was passiert, wenn ich mehrere Zweige gleichzeitig zusammenführe?
• Was ist ein Unterschied zwischen Zusammenführungsstrategien?

Aber die Beschreibung eines ganzen Algorithmus wird viel besser sein.

Am besten suchen Sie nach einer Beschreibung eines 3-Wege-Zusammenführungsalgorithmus. Eine Beschreibung auf hoher Ebene würde ungefähr so ​​aussehen:

1. Suchen Sie eine geeignete Zusammenführungsbasis B- eine Version der Datei, die ein Vorfahr der beiden neuen Versionen ( Xund Y) ist, und normalerweise die neueste dieser Basis (obwohl es Fälle gibt, in denen sie weiter zurückgehen muss, eine davon die Funktionen von gits Standard recursiveMerge)
2. Führen Sie Unterschiede Xmit Bund Ymit durch B.
3. Gehen Sie durch die Änderungsblöcke, die in den beiden Unterschieden angegeben sind. Wenn beide Seiten dieselbe Änderung an derselben Stelle einführen, akzeptieren Sie eine der beiden. Wenn einer eine Änderung einführt und der andere diese Region in Ruhe lässt, führen Sie die Änderung im Finale ein. Wenn beide Änderungen an einer Stelle einführen, diese jedoch nicht übereinstimmen, markieren Sie einen Konflikt, der manuell gelöst werden soll.

Der vollständige Algorithmus befasst sich ausführlicher damit und enthält sogar einige Dokumentationen ( https://github.com/git/git/blob/master/Documentation/technical/trivial-merge.txt) sowie die git help XXXSeiten , wobei XXX ist eine merge-base, merge-file, merge, merge-one-fileund möglicherweise einige andere). Wenn das nicht tief genug ist, gibt es immer Quellcode ...

Wie funktioniert Git, wenn es mehrere gemeinsame Grundlagen für das Zusammenführen von Zweigen gibt?

Dieser Artikel war sehr hilfreich: http://codicesoftware.blogspot.com/2011/09/merge-recursive-strategy.html (hier ist Teil 2 ).

Rekursiv verwendet diff3 rekursiv, um einen virtuellen Zweig zu generieren, der als Vorfahr verwendet wird.

Z.B:

(A)----(B)----(C)-----(F)
        |      |       |
        |      |   +---+
        |      |   |
        |      +-------+
        |          |   |
        |      +---+   |
        |      |       |
        +-----(D)-----(E)

Dann:

git checkout E
git merge F

Es gibt 2 beste gemeinsame Vorfahren (gemeinsame Vorfahren, die keine Vorfahren anderer sind) Cund D. Git führt sie zu einem neuen virtuellen Zweig zusammen Vund verwendet sie dann Vals Basis.

(A)----(B)----(C)--------(F)
        |      |          |
        |      |      +---+
        |      |      |
        |      +----------+
        |      |      |   |
        |      +--(V) |   |
        |          |  |   |
        |      +---+  |   |
        |      |      |   |
        |      +------+   |
        |      |          |
        +-----(D)--------(E)

Ich nehme an, Git würde einfach mit dem fortfahren, wenn es mehr gemeinsame Vorfahren gäbe, die Vmit dem nächsten verschmelzen .

Der Artikel besagt, dass Git bei einem Zusammenführungskonflikt beim Generieren des virtuellen Zweigs die Konfliktmarkierungen einfach dort belässt, wo sie sich befinden, und fortfährt.

Was passiert, wenn ich mehrere Zweige gleichzeitig zusammenführe?

Wie @Nevik Rehnel erklärte, hängt es von der Strategie ab, es wird im man git-merge MERGE STRATEGIESAbschnitt gut erklärt .

Nur octopusund ours/ oder theirsdas gleichzeitige Zusammenführen mehrerer Zweige unterstützen dies recursivebeispielsweise nicht.

octopusweigert sich zusammenzuführen, wenn es Konflikte geben würde, und oursist eine triviale Zusammenführung, so dass es keine Konflikte geben kann.

Diese Befehle generieren ein neues Commit und haben mehr als 2 Eltern.

Ich habe eine merge -X octopusauf Git 1.8.5 ohne Konflikte gemacht, um zu sehen, wie es geht.

Ausgangszustand:

   +--B
   |
A--+--C
   |
   +--D

Aktion:

git checkout B
git merge -Xoctopus C D

Neuer Zustand:

   +--B--+
   |     |
A--+--C--+--E
   |     |
   +--D--+

Wie erwartet Ehat 3 Eltern.

TODO: Wie genau Octopus mit einzelnen Dateimodifikationen arbeitet. Rekursive Zwei-mal-Zwei-3-Wege-Zusammenführungen?

Wie funktioniert git, wenn es keine gemeinsame Basis für das Zusammenführen von Zweigen gibt?

@Torek erwähnt, dass die Zusammenführung seit 2.9 ohne fehlschlägt --allow-unrelated-histories.

Ich habe es empirisch auf Git 1.8.5 ausprobiert:

git init
printf 'a\nc\n' > a
git add .
git commit -m a

git checkout --orphan b
printf 'a\nb\nc\n' > a
git add .
git commit -m b
git merge master

a enthält:

a
<<<<<<< ours
b
=======
>>>>>>> theirs
c

Dann:

git checkout --conflict=diff3 -- .

a enthält:

<<<<<<< ours
a
b
c
||||||| base
=======
a
c
>>>>>>> theirs

Deutung:

• Die Basis ist leer
• Wenn die Basis leer ist, ist es nicht möglich, Änderungen an einer einzelnen Datei aufzulösen. Nur Dinge wie das Hinzufügen neuer Dateien können behoben werden. Der obige Konflikt würde durch eine 3-Wege-Zusammenführung mit der Basis a\nc\nals einzeilige Addition gelöst
• Ich denke, dass eine 3-Wege-Zusammenführung ohne Basisdatei als 2-Wege-Zusammenführung bezeichnet wird, was nur ein Unterschied ist

Ich bin auch interessiert. Ich weiß die Antwort nicht, aber ...

Ein komplexes System, das funktioniert, hat sich aus einem einfachen System entwickelt, das funktioniert hat

Ich denke, die Verschmelzung von git ist hochentwickelt und wird sehr schwer zu verstehen sein - aber eine Möglichkeit, dies zu erreichen, sind die Vorläufer und die Konzentration auf das Herz Ihres Anliegens. Das heißt, bei zwei Dateien, die keinen gemeinsamen Vorfahren haben, wie funktioniert Git Merge, wie sie zusammengeführt werden und wo Konflikte auftreten?

Versuchen wir, einige Vorläufer zu finden. Von git help merge-file:

git merge-file is designed to be a minimal clone of RCS merge; that is,
       it implements all of RCS merge's functionality which is needed by
       git(1).

Aus Wikipedia: http://en.wikipedia.org/wiki/Git_%28software%29 -> http://en.wikipedia.org/wiki/Three-way_merge#Three-way_merge -> http: //en.wikipedia .org / wiki / Diff3 -> http://www.cis.upenn.edu/~bcpierce/papers/diff3-short.pdf

Dieser letzte Link ist ein PDF eines Papiers, das den diff3Algorithmus im Detail beschreibt. Hier ist eine Google PDF-Viewer-Version . Es ist nur 12 Seiten lang und der Algorithmus ist nur ein paar Seiten lang - aber eine umfassende mathematische Behandlung. Das mag etwas zu formal erscheinen, aber wenn Sie die Zusammenführung von git verstehen möchten, müssen Sie zuerst die einfachere Version verstehen. Ich habe es noch nicht überprüft, aber mit einem Namen wie diff3müssen Sie wahrscheinlich auch diff verstehen (das einen längsten gemeinsamen Subsequenzalgorithmus verwendet). Es kann jedoch eine intuitivere Erklärung diff3geben, wenn Sie eine Google ...

Jetzt habe ich gerade ein Experiment durchgeführt diff3und git merge-file. Sie nehmen die gleichen drei Eingabedateien version1 oldversion version2 und markieren Konflikte die Art und Weise gleich, mit <<<<<<< version1, =======, >>>>>>> version2( diff3auch hat ||||||| oldversion), ihr gemeinsames Erbe zeigt.

Früher habe ich eine leere Datei für oldversion und nahezu identische Dateien für version1 und version2 mit nur einem zusätzlichen Zeile hinzugefügt version2 .

Ergebnis: git merge-fileidentifizierte die einzelne geänderte Zeile als Konflikt; diff3behandelte aber die ganzen zwei Dateien als Konflikt. So ausgefeilt diff3 auch ist, die Zusammenführung von git ist selbst in diesem einfachsten Fall noch ausgefeilter.

Hier sind die tatsächlichen Ergebnisse (ich habe die Antwort von @ twalberg für den Text verwendet). Beachten Sie die benötigten Optionen (siehe entsprechende Seiten).

$ git merge-file -p fun1.txt fun0.txt fun2.txt

You might be best off looking for a description of a 3-way merge algorithm. A
high-level description would go something like this:

    Find a suitable merge base B - a version of the file that is an ancestor of
both of the new versions (X and Y), and usually the most recent such base
(although there are cases where it will have to go back further, which is one
of the features of gits default recursive merge) Perform diffs of X with B and
Y with B.  Walk through the change blocks identified in the two diffs. If both
sides introduce the same change in the same spot, accept either one; if one
introduces a change and the other leaves that region alone, introduce the
change in the final; if both introduce changes in a spot, but they don't match,
mark a conflict to be resolved manually.
<<<<<<< fun1.txt
=======
THIS IS A BIT DIFFERENT
>>>>>>> fun2.txt

The full algorithm deals with this in a lot more detail, and even has some
documentation (/usr/share/doc/git-doc/technical/trivial-merge.txt for one,
along with the git help XXX pages, where XXX is one of merge-base, merge-file,
merge, merge-one-file and possibly a few others). If that's not deep enough,
there's always source code...

$ diff3 -m fun1.txt fun0.txt fun2.txt

<<<<<<< fun1.txt
You might be best off looking for a description of a 3-way merge algorithm. A
high-level description would go something like this:

    Find a suitable merge base B - a version of the file that is an ancestor of
both of the new versions (X and Y), and usually the most recent such base
(although there are cases where it will have to go back further, which is one
of the features of gits default recursive merge) Perform diffs of X with B and
Y with B.  Walk through the change blocks identified in the two diffs. If both
sides introduce the same change in the same spot, accept either one; if one
introduces a change and the other leaves that region alone, introduce the
change in the final; if both introduce changes in a spot, but they don't match,
mark a conflict to be resolved manually.

The full algorithm deals with this in a lot more detail, and even has some
documentation (/usr/share/doc/git-doc/technical/trivial-merge.txt for one,
along with the git help XXX pages, where XXX is one of merge-base, merge-file,
merge, merge-one-file and possibly a few others). If that's not deep enough,
there's always source code...
||||||| fun0.txt
=======
You might be best off looking for a description of a 3-way merge algorithm. A
high-level description would go something like this:

    Find a suitable merge base B - a version of the file that is an ancestor of
both of the new versions (X and Y), and usually the most recent such base
(although there are cases where it will have to go back further, which is one
of the features of gits default recursive merge) Perform diffs of X with B and
Y with B.  Walk through the change blocks identified in the two diffs. If both
sides introduce the same change in the same spot, accept either one; if one
introduces a change and the other leaves that region alone, introduce the
change in the final; if both introduce changes in a spot, but they don't match,
mark a conflict to be resolved manually.
THIS IS A BIT DIFFERENT

The full algorithm deals with this in a lot more detail, and even has some
documentation (/usr/share/doc/git-doc/technical/trivial-merge.txt for one,
along with the git help XXX pages, where XXX is one of merge-base, merge-file,
merge, merge-one-file and possibly a few others). If that's not deep enough,
there's always source code...
>>>>>>> fun2.txt

Wenn Sie wirklich daran interessiert sind, ist es ein bisschen wie ein Kaninchenbau. Für mich scheint es so tief wie reguläre Ausdrücke, der längste gängige Subsequenzalgorithmus für Diff, kontextfreie Grammatiken oder relationale Algebra. Wenn Sie dem auf den Grund gehen wollen, können Sie es meiner Meinung nach, aber es wird einige entschlossene Studien erfordern.

Hier ist die ursprüngliche Implementierung

http://git.kaarsemaker.net/git/blob/857f26d2f41e16170e48076758d974820af685ff/git-merge-recursive.py

Grundsätzlich erstellen Sie eine Liste gemeinsamer Vorfahren für zwei Commits und führen sie dann rekursiv zusammen, indem Sie sie entweder schnell weiterleiten oder virtuelle Commits erstellen, die als Grundlage für eine Drei-Wege-Zusammenführung der Dateien verwendet werden.

Wie erkennt git den Kontext einer bestimmten nicht widersprüchlichen Änderung?
Wie findet Git heraus, dass es in genau diesen Zeilen einen Konflikt gibt?

Wenn sich auf beiden Seiten der Zusammenführung dieselbe Zeile geändert hat, liegt ein Konflikt vor. Wenn dies nicht der Fall ist, wird die Änderung von einer Seite (falls vorhanden) akzeptiert.

Welche Dinge führt Git automatisch zusammen?

Änderungen, die nicht in Konflikt stehen (siehe oben)

Wie funktioniert Git, wenn es mehrere gemeinsame Grundlagen für das Zusammenführen von Zweigen gibt?

Nach der Definition einer Git-Merge-Basis gibt es immer nur eine (den neuesten gemeinsamen Vorfahren).

Was passiert, wenn ich mehrere Zweige gleichzeitig zusammenführe?

Das hängt von der Merge - Strategie (nur die octopusund die ours/ theirsStrategien unterstützen Verschmelzung mehr als zwei Zweige).

Was ist ein Unterschied zwischen Zusammenführungsstrategien?

Dies wird in der git mergeManpage erklärt .