Query Indirect GroupMember Records

From my experience, accessing direct group members isn't too bad - you just iterate the group and for all user members just pull their details. If it is a group member, you just recursively call your function that iterates the group.

Where things get really sticky is when you try to figure out the indirect members - I've found that when you start trying to traverse the role hierarchy on a user by user basis, unless you have a flat structure you very quickly run out of SOQL queries.

Here's an example of traversing a group and subgroups to get all user ids:

    public static Set<id> GetUserIdsFromGroup(Id groupId)
    {
        // store the results in a set so we don't get duplicates
        Set<Id> result=new Set<Id>();
        String userType = Schema.SObjectType.User.getKeyPrefix();
        String groupType = Schema.SObjectType.Group.getKeyPrefix();

        // Loop through all group members in a group
        for (GroupMember m : [Select Id, UserOrGroupId From GroupMember Where GroupId = :groupId])
        {
            // If the user or group id is a user
            if (((String)m.UserOrGroupId).startsWith(userType))
            {
                result.add(m.UserOrGroupId);
            }
            // If the user or group id is a group
            // Note: there may be a problem with governor limits if this is called too many times
            else if (((String)m.UserOrGroupId).startsWith(groupType))
            {
                // Call this function again but pass in the group found within this group
                result.addAll(GetUSerIdsFromGroup(m.UserOrGroupId));
            }
        }

        return result;  
    }

that will do the trick. what you basically have to do is to traverse through the nested groups by self referencing the getGroupsForIds() method

// return list of all groups the user belongs to via direct or indirect membership
public Group[] getGroupsForUser(Id userId){

    Set<Id> groupIds = getGroupsForIds(new Set<Id>{userId});
 return [
   select Id
        , Name
     from Group
    where Id IN: groupIds];

}

// return all ids the user belongs to via direct or indirect membership
public Set<Id> getGroupsForIds(Set<Id> userOrGroupIds){

    Set<Id> output = new Set<Id>();

    Set<Id> nestedGroupIds = new Set<Id>();

    // only query actual groups and not roles and queues
    list<GroupMember> records = [
        select id
             , GroupId
             , UserOrGroupId
          from GroupMember
         where UserOrGroupId =: userOrGroupIds
        and UserOrGroupId != null
           and Group.Type = 'Regular'];

    for (GroupMember record:records)
    {
        // found a group, remember for traversal
        if (!(record.UserOrGroupId + '').startsWith('005'))
        {
            nestedGroupIds.add(record.UserOrGroupId);   
        }
        else
        {
            output.add(record.GroupId);
        }
    }

    // call self to get nested groups we found
    if (nestedGroupIds.size() > 0)
    {
        output.addAll(getGroupsForIds(nestedGroupIds));
    }

    return output;
}