Method executeType

src/Functions/dateName.cpp:135–204

    template <typename DataType>
    ColumnPtr executeType(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const
    {
        auto * times = checkAndGetColumn<typename DataType::ColumnType>(arguments[1].column.get());
        if (!times)
            return nullptr;

        const ColumnConst * date_part_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
        if (!date_part_column)
            throw Exception(
                ErrorCodes::ILLEGAL_COLUMN,
                "Illegal column {} of first ('datepart') argument of function {}. Must be constant string.",
                arguments[0].column->getName(),
                getName());

        String date_part = date_part_column->getValue<String>();

        const DateLUTImpl * time_zone_tmp = nullptr;
        if constexpr (std::is_same_v<DataType, DataTypeDateTime64> || std::is_same_v<DataType, DataTypeDateTime>)
            time_zone_tmp = &extractTimeZoneFromFunctionArguments(arguments, 2, 1);
        else
            time_zone_tmp = &DateLUT::instance();

        const auto & times_data = times->getData();
        const DateLUTImpl & time_zone = *time_zone_tmp;

        UInt32 scale [[maybe_unused]] = 0;
        if constexpr (std::is_same_v<DataType, DataTypeDateTime64>)
        {
            scale = times->getScale();
        }

        auto result_column = ColumnString::create();
        auto & result_column_data = result_column->getChars();
        auto & result_column_offsets = result_column->getOffsets();

        /* longest possible word, 'Wednesday' */
        static constexpr size_t longest_word_length = 9;

        result_column_data.resize_fill(times_data.size() * longest_word_length);
        result_column_offsets.resize(times_data.size());

        auto * begin = reinterpret_cast<char *>(result_column_data.data());

        WriteBufferFromPointer buffer(begin, result_column_data.size());

        using TimeType = DateTypeToTimeType<DataType>;
        callOnDatePartWriter<TimeType>(date_part, [&](const auto & writer)
        {
            for (size_t i = 0; i < input_rows_count; ++i)
            {
                if constexpr (std::is_same_v<DataType, DataTypeDateTime64>)
                {
                    const auto components = DecimalUtils::split(times_data[i], scale);
                    writer.write(buffer, static_cast<Int64>(components.whole), time_zone);
                }
                else
                {
                    writer.write(buffer, times_data[i], time_zone);