How can I get/list/see all the descendants of a commit with git (or gitk)?

Question

If you use gitk --all, you can see all the commits of your repo, from all branches. I want something like that except only the descendants of a given commit.

Answer 1

I think this might do what you want. All commits in all branches, that have A as ancestor:

gitk --all --ancestry-path A..

Answer 2

In short:

git log --all BRANCH~1..

In detail, with examples: This is the complete tree of a repository I just created:

$ git log --graph --oneline --decorate --all
* e3972be (HEAD, a) a-6
* 2707d79 a-5
* cdea9a7 a-4
| * 65b716e (c) c-5
| * ebe2a0e c-4
|/  
| * 2ed9abe (b) b-4
|/  
* ace558e (master) 3
* 20db61f 2
* 3923af1 1

Aside from --all, another thing is obvious: master -> HEAD:

$ git log --graph --oneline --decorate master..
* e3972be (HEAD, a) a-6
* 2707d79 a-5
* cdea9a7 a-4

So I tried combining them, and it almost got me what we wanted:

$ git log --graph --oneline --decorate --all master..
* e3972be (HEAD, a) a-6
* 2707d79 a-5
* cdea9a7 a-4
* 65b716e (c) c-5
* ebe2a0e c-4
* 2ed9abe (b) b-4

But unfortunately, this doesn't show the relationship between the branches, since the branch we're asking about was omitted. So we have to use log from the parent of master like so:

$ git log --graph --oneline --decorate --all master~1..
* e3972be (HEAD, a) a-6
* 2707d79 a-5
* cdea9a7 a-4
| * 65b716e (c) c-5
| * ebe2a0e c-4
|/  
| * 2ed9abe (b) b-4
|/  
* ace558e (master) 3

Ta-da! (I don't know if this simply didn't work in the past, but just in case: I'm on git version 1.7.1)

EDIT 2017-11-17 - Thanks to STW for actually showing the problem with this: Independent trees would mess this up. Commits that are entirely independent of master would be included in this output. Starting from a copy of the above repo, this is what my last command would output:

$ git checkout --orphan z
Switched to a new branch 'z'
$ git commit --allow-empty -m'z-1'
[z (root-commit) bc0c0bb] z-1
$ git commit --allow-empty -m'z-2'
[z 1183713] z-2

$ git log --graph --oneline --decorate --all master~1..
* 1183713 (HEAD -> z) z-2
* bc0c0bb z-1
* 6069f73 (a) a-6
* 654d106 a-5
* a218c59 a-4
| * 338432a (c) c-5
| * 2115318 c-4
|/  
| * 43a34dc (b) b-4
|/  
* ce05471 (master) 3

The z branch, being created as an orphan, has no common history with master, so z-1 and z-2 should have been excluded but were not. This is what --ancestry-path is for, I now get. Including it will exclude branch z:

$ git log --graph --oneline --decorate --all --ancestry-path master~1..
* 6069f73 (a) a-6
* 654d106 a-5
* a218c59 a-4
| * 338432a (c) c-5
| * 2115318 c-4
|/  
| * 43a34dc (b) b-4
|/  
* ce05471 (master) 3

For completeness, even given that it already had --ancestry-path, the current top answer does not show the branch relationship correctly because it excludes the commit on master itself:

$ git log --graph --oneline --decorate --all --ancestry-path master..
* 6069f73 (a) a-6
* 654d106 a-5
* a218c59 a-4
* 338432a (c) c-5
* 2115318 c-4
* 43a34dc (b) b-4

Answer 3

A commit only knows about its parent ( and hence all the way up) but has no clue about its children / descendants. You must use a notation like A..B to find it.

For example if you want to find commits in current branch since the given commit A, you can do something like this:

git rev-list A..

Answer 4

I was able to do this for all branches using bash/git.

This lists the descendant commits (and the given root):

git_list_all_descendant_hashes() {
    COMMIT=$1
    if [[ ${#COMMIT} -lt 40 ]]; then # short commit hash, need full hash
        COMMIT=`git rev-parse ${COMMIT}`
    fi

    declare -A ALL_HASHES

    while IFS= read -r string; do
        IFS=' ' read -r -a array <<< $string
        key=${array[0]}
        value=${array[@]:1}
        ALL_HASHES[${key}]=$value
    done <<< $(git rev-list --children --all)

    declare -A HASHES # subset of ALL_HASHES that are descendants

    HASHES[${COMMIT}]=1

    added_hashes=1
    while [[ ${added_hashes} -gt 0 ]]; do
        added_hashes=0
        # this loop is inefficient, as it will iterate over all collected hashes each time a hash is found to have new children
        for hash in ${!HASHES[@]}; do
            for child_hash in ${ALL_HASHES[${hash}]}; do
                if [[ ! -v HASHES[$child_hash] ]]; then
                    added_hashes=1
                    HASHES[${child_hash}]=1
                fi
            done
        done
    done

    for hash in ${!HASHES[@]}; do
        echo ${hash}
    done
}

You can invoke it with:

git_descendants() {
    # the --short flag is a hack that'll return an error code if no argument is given, but git_list_all_descendant_hashes actually needs to turn it into a full hash
    COMMIT=`git rev-parse --short $1 2>/dev/null || git rev-parse HEAD`
    git log --graph --oneline --decorate ^${COMMIT}^@ $(git_list_all_descendant_hashes ${COMMIT})
}

If a descendant has multiple parents (i.e. from a merge commit), it'll show its non-root ancestry as well. This is something I was happy with, so I didn't bother figuring out how to get rid of it.