Method executeImpl

src/Functions/map.cpp:847–919

    }

    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
    {
        /// handle null constant value in arguments
        NullPresence null_presence = getNullPresense(arguments);
        if (null_presence.has_null_constant)
            return result_type->createColumnConstWithDefaultValue(input_rows_count);

        const auto * col_map = checkAndGetColumn<ColumnMap>(arguments[0].column.get());
        const auto * col_const_map = checkAndGetColumnConst<ColumnMap>(arguments[0].column.get());
        const DataTypeMap * map_type = checkAndGetDataType<DataTypeMap>(arguments[0].type.get());
        if ((!col_map && !col_const_map) || !map_type)
            throw Exception(ErrorCodes::LOGICAL_ERROR,
                "First argument for function '{}' must be map, got '{}' instead",
                getName(),arguments[0].type->getName());

        if (col_const_map)
            col_map = typeid_cast<const ColumnMap *>(&col_const_map->getDataColumn());

        auto & key_column = col_map->getKey();
        auto & value_column = col_map->getValue();
        auto & offsets = col_map->getOffsets();

        /// At first step calculate indices in array of values for requested keys.
        auto indices_column = DataTypeNumber<UInt64>().createColumn();
        indices_column->reserve(input_rows_count);
        auto & indices_data = assert_cast<ColumnVector<UInt64> &>(*indices_column).getData();

        bool executed = false;
        if (!isColumnConst(*arguments[1].column))
        {
            executed = FunctionArrayElement::matchKeyToIndexNumber(key_column, offsets, !!col_const_map, *arguments[1].column, indices_data)
                || FunctionArrayElement::matchKeyToIndexString(key_column, offsets, !!col_const_map, *arguments[1].column, indices_data);
        }
        else
        {
            Field index = (*arguments[1].column)[0];

            /// try convert const index to right type
            auto index_lit = std::make_shared<ASTLiteral>(index);
            Field key_field = tryConvertToMapKeyField(map_type->getKeyType(), index_lit->getColumnName());
            if (!key_field.isNull())
                index = key_field;

            executed = FunctionArrayElement::matchKeyToIndexNumberConst(key_column, offsets, index, indices_data)
                || FunctionArrayElement::matchKeyToIndexStringConst(key_column, offsets, index, indices_data);
        }
        if (!executed)
            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
                "Illegal types of arguments: {}, {} for function {}",
                arguments[0].type->getName(), arguments[1].type->getName(), getName());

        auto col_res = IColumn::mutate(result_type->createColumn());
        auto & col_res_ref = typeid_cast<ColumnNullable &>(*col_res);
        bool add_nullable = !value_column.lowCardinality() && value_column.canBeInsideNullable();
        for (size_t i = 0, size = indices_data.size(); i < size; ++i)
        {
            auto offset = col_const_map ? 0: offsets[i - 1];
            if (indices_data[i] == 0)