ClickHouse

1
#include <Processors/QueryPlan/LimitByStep.h>
2
#include <Processors/Transforms/LimitByTransform.h>
3
#include <QueryPipeline/QueryPipelineBuilder.h>
4
#include <IO/Operators.h>
5
#include <Common/JSONBuilder.h>
6

7
namespace DB
8
{
9

10
static ITransformingStep::Traits getTraits()
11
{
12
    return ITransformingStep::Traits
13
    {
14
        {
15
            .returns_single_stream = true,
16
            .preserves_number_of_streams = false,
17
            .preserves_sorting = true,
18
        },
19
        {
20
            .preserves_number_of_rows = false,
21
        }
22
    };
23
}
24

25
LimitByStep::LimitByStep(
26
    const DataStream & input_stream_,
27
    size_t group_length_, size_t group_offset_, const Names & columns_)
28
    : ITransformingStep(input_stream_, input_stream_.header, getTraits())
29
    , group_length(group_length_)
30
    , group_offset(group_offset_)
31
    , columns(columns_)
32
{
33
}
34

35

36
void LimitByStep::transformPipeline(QueryPipelineBuilder & pipeline, const BuildQueryPipelineSettings &)
37
{
38
    pipeline.resize(1);
39

40
    pipeline.addSimpleTransform([&](const Block & header, QueryPipelineBuilder::StreamType stream_type) -> ProcessorPtr
41
    {
42
        if (stream_type != QueryPipelineBuilder::StreamType::Main)
43
            return nullptr;
44

45
        return std::make_shared<LimitByTransform>(header, group_length, group_offset, columns);
46
    });
47
}
48

49
void LimitByStep::describeActions(FormatSettings & settings) const
50
{
51
    String prefix(settings.offset, ' ');
52

53
    settings.out << prefix << "Columns: ";
54

55
    if (columns.empty())
56
        settings.out << "none\n";
57
    else
58
    {
59
        bool first = true;
60
        for (const auto & column : columns)
61
        {
62
            if (!first)
63
                settings.out << ", ";
64
            first = false;
65

66
            settings.out << column;
67
        }
68
        settings.out << '\n';
69
    }
70

71
    settings.out << prefix << "Length " << group_length << '\n';
72
    settings.out << prefix << "Offset " << group_offset << '\n';
73
}
74

75
void LimitByStep::describeActions(JSONBuilder::JSONMap & map) const
76
{
77
    auto columns_array = std::make_unique<JSONBuilder::JSONArray>();
78
    for (const auto & column : columns)
79
        columns_array->add(column);
80

81
    map.add("Columns", std::move(columns_array));
82
    map.add("Length", group_length);
83
    map.add("Offset", group_offset);
84
}
85

86
}
87