class AggregateCollectorBenchmark {

    private final List<Row1> rows = IntStream.range(0, 10_000).mapToObj(Row1::new).toList();

    private AggregateCollector collector;

    @SuppressWarnings("unchecked")
    @Setup
    public void setup() {<FILL_FUNCTION_BODY>}

    @Benchmark
    public Iterable<Row> measureAggregateCollector() {
        Object[] state = collector.supplier().get();
        BiConsumer<Object[], Row> accumulator = collector.accumulator();
        Function<Object[], Iterable<Row>> finisher = collector.finisher();
        for (int i = 0; i < rows.size(); i++) {
            accumulator.accept(state, rows.get(i));
        }
        return finisher.apply(state);
    }
}

        RowCollectExpression inExpr0 = new RowCollectExpression(0);
        Functions functions = Functions.load(Settings.EMPTY, new SessionSettingRegistry(Set.of()));
        SumAggregation<?> sumAggregation = (SumAggregation<?>) functions.getQualified(
            Signature.aggregate(
                SumAggregation.NAME,
                DataTypes.INTEGER.getTypeSignature(),
                DataTypes.LONG.getTypeSignature()
            ),
            List.of(DataTypes.INTEGER),
            DataTypes.INTEGER
        );
        var memoryManager = new OnHeapMemoryManager(bytes -> {});
        collector = new AggregateCollector(
            Collections.singletonList(inExpr0),
            RamAccounting.NO_ACCOUNTING,
            memoryManager,
            Version.CURRENT,
            AggregateMode.ITER_FINAL,
            new AggregationFunction[] { sumAggregation },
            Version.CURRENT,
            new Input[][] { {inExpr0 } },
            new Input[] { Literal.BOOLEAN_TRUE }
        );
    
<no_super_class>