users := []User{{
		Name:     "groupby",
		Age:      10,
		Birthday: Now(),
		Active:   true,
	}, {
		Name:     "groupby",
		Age:      20,
		Birthday: Now(),
	}, {
		Name:     "groupby",
		Age:      30,
		Birthday: Now(),
		Active:   true,
	}, {
		Name:     "groupby1",
		Age:      110,
		Birthday: Now(),
	}, {
		Name:     "groupby1",
		Age:      220,
		Birthday: Now(),

// GroupBy group by clause
type GroupBy struct {
	Columns []Column
	Having  []Expression
}

// Name from clause name
func (groupBy GroupBy) Name() string {
	return "GROUP BY"
}

// Build build group by clause
func (groupBy GroupBy) Build(builder Builder) {
	for idx, column := range groupBy.Columns {
		if idx > 0 {
			builder.WriteByte(',')
		}

		builder.WriteQuoted(column)
	}

	if len(groupBy.Having) > 0 {

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.exception.IllegalBehaviorStateException;
import org.dbflute.util.DfTypeUtil;

/**
 * @author FreeGen
 */
public class GroupBhv extends BsGroupBhv {
    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {

import jakarta.annotation.Resource;

public class GroupService {

    @Resource
    protected GroupBhv groupBhv;

    @Resource
    protected FessConfig fessConfig;

    @Resource
    protected UserBhv userBhv;

    public List<Group> getGroupList(final GroupPager groupPager) {

        final PagingResultBean<Group> groupList = groupBhv.selectPage(cb -> {
            cb.paging(groupPager.getPageSize(), groupPager.getCurrentPageNumber());

            .groupBy { "${it.major}.${it.minor}" }
            .map { (_, v) -> v.maxOrNull()!!.format() }

        // Limit to first and last release of each major version
        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }

	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.GroupBy{
				Columns: []clause.Column{{Name: "role"}},
				Having:  []clause.Expression{clause.Eq{"role", "admin"}},
			}},
			"SELECT * FROM `users` GROUP BY `role` HAVING `role` = ?",
			[]interface{}{"admin"},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.GroupBy{
				Columns: []clause.Column{{Name: "role"}},

                        os to (testProject to performanceTestDuration)
                    }
            }
        }
        return pairs.groupBy({ it.first }, { it.second })
            .mapValues { entry -> entry.value.groupBy({ it.first }, { it.second }) }
    }

    private
    fun readPerformanceTestConfigurations(performanceTestsCiJson: File): List<PerformanceTestConfiguration> {

	<component name="userBhv" class="org.codelibs.fess.es.user.exbhv.UserBhv"/>
	<component name="roleBhv" class="org.codelibs.fess.es.user.exbhv.RoleBhv"/>
	<component name="groupBhv" class="org.codelibs.fess.es.user.exbhv.GroupBhv"/>

        assertArrayEquals(new String[] { "group1", "group2" }, groups);

        OpenIdConnectCredential credential = new OpenIdConnectCredential(attributes);
        assertEquals("******@****.***", credential.getUserId());
        assertArrayEquals(new String[] { "group1", "group2" }, credential.getUserGroups());
    }

        @VisibleForTesting
        @JvmStatic
        fun selectVersionsFrom(minimumSupported: String, allVersions: List<String>): List<String> {
            val versionsByMinor = allVersions
                .groupBy { it.take(3) } // e.g. 1.9
                .toSortedMap()
            val latests = buildList {
                versionsByMinor.entries.forEachIndexed { idx, entry ->
                    // Earliest stable of the minor