把分组键映射为可批量更新的聚合状态

1876            auto emplace_result = state.emplaceKey(method.data, i, *aggregates_pool);18771878            if constexpr (top_k)1879            {1880                if (emplace_result.isInserted())1881                {1882                    if (state.isNullAt(i))1883                        method.top_k_heap.push(heap_key_cols, i);1884                    else1885                        method.top_k_heap.push(heap_key_cols, i, emplace_result.getKey());1886                }1887            }18881889            /// If a new key is inserted, initialize the states of the aggregate functions, and possibly something related to the key.1890            if (emplace_result.isInserted())1891            {1892                /// exception-safety - if you can not allocate memory or create states, then destructors will not be called.1893                emplace_result.setMapped(nullptr);1894

1905                if (!aggregate_data)1906                    aggregate_data = aggregates_pool->alignedAlloc(total_size_of_aggregate_states, align_aggregate_states);19071908                createAggregateStates(aggregate_data, use_compiled_functions);1909                emplace_result.setMapped(aggregate_data);1910            }1911            else1912                aggregate_data = emplace_result.getMapped();19131914            if constexpr (top_k)1915            {1916                if (method.top_k_heap.needsTrim())1917                {1918                    trimHeapAndPruneHashTable(method, &destroyed_states, i);1919                    skip_bitmap = nullptr;1920                    state.resetCache();1921                }1922            }19231924            chassert(aggregate_data != nullptr);1925            places[i] = aggregate_data;

2039    /// Add values to the aggregate functions.2040    for (size_t i = 0; i < aggregate_functions.size(); ++i)2041    {2042#if USE_EMBEDDED_COMPILER2043        if (use_compiled_functions && is_aggregate_function_compiled[i])2044            continue;2045#endif20462047        const AggregateFunctionInstruction * inst = aggregate_instructions + i;20482049        if (all_keys_are_const || (inst->can_optimize_equal_keys_ranges && has_only_one_value_since_last_reset))2050        {2051            ProfileEvents::increment(ProfileEvents::AggregationOptimizedEqualRangesOfKeys);2052            addBatchSinglePlace(row_begin, row_end, inst, places[key_start] + inst->state_offset, aggregates_pool);2053        }2054        else2055        {2056            addBatch(row_begin, row_end, inst, places, aggregates_pool, all_places_are_non_null);2057        }

446    /// Find a cell with the same key or an empty cell, starting from the specified position and further along the collision resolution chain.447    size_t ALWAYS_INLINE findCell(const Key & x, size_t hash_value, size_t place_value) const448    {449        while (!buf[place_value].isZero(*this) && !buf[place_value].keyEquals(x, hash_value, *this))450        {451            place_value = grower.next(place_value);452#ifdef DBMS_HASH_MAP_COUNT_COLLISIONS453            ++collisions;454#endif455        }456457        return place_value;458    }

1037    void ALWAYS_INLINE emplaceNonZeroImpl(size_t place_value, KeyHolder && key_holder,1038                                          LookupResult & it, bool & inserted, size_t hash_value)1039    {1040        it = &buf[place_value];10411042        if (!buf[place_value].isZero(*this))1043        {1044            keyHolderDiscardKey(key_holder);1045            inserted = false;1046            return;1047        }10481049        keyHolderPersistKey(key_holder);1050        const auto & key = keyHolderGetKey(key_holder);10511052        new (&buf[place_value]) Cell(key, *this);1053        buf[place_value].setHash(hash_value);1054        inserted = true;1055        ++m_size;

1057        if (unlikely(grower.overflow(m_size)))1058        {1059            try1060            {1061                resize();1062            }1063            catch (...)1064            {1065                /** If we have not resized successfully, then there will be problems.1066                  * There remains a key, but uninitialized mapped-value,1067                  *  which, perhaps, can not even be called a destructor.1068                  */1069                --m_size;1070                buf[place_value].setZero();1071                inserted = false;1072                keyHolderDiscardKey(key_holder);1073                throw;1074            }10751076            // The hash table was rehashed, so we have to re-find the key.1077            size_t new_place = findCell(key, hash_value, grower.place(hash_value));1078            chassert(!buf[new_place].isZero(*this));