1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
#pragma once
#include <Core/Field.h>
#include <Parsers/IAST_fwd.h>
#include <AggregateFunctions/IAggregateFunction.h>
#include <Core/SortDescription.h>
#include <DataTypes/IDataType.h>
#include <Core/Names.h>
#include <Core/Types.h>
namespace DB
{
class ASTFunction;
class ActionsDAG;
using ActionsDAGPtr = std::shared_ptr<ActionsDAG>;
struct WindowFunctionDescription
{
std::string column_name;
const ASTFunction * function_node = nullptr;
AggregateFunctionPtr aggregate_function;
Array function_parameters;
DataTypes argument_types;
Names argument_names;
std::string dump() const;
};
struct WindowFrame
{
enum class FrameType { ROWS, GROUPS, RANGE };
enum class BoundaryType { Unbounded, Current, Offset };
// This flag signifies that the frame properties were not set explicitly by
// user, but the fields of this structure still have to contain proper values
// for the default frame of RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.
bool is_default = true;
FrameType type = FrameType::RANGE;
// UNBOUNDED FOLLOWING for the frame end is forbidden by the standard, but for
// uniformity the begin_preceding still has to be set to true for UNBOUNDED
// frame start.
// Offset might be both preceding and following, controlled by begin_preceding,
// but the offset value must be positive.
BoundaryType begin_type = BoundaryType::Unbounded;
Field begin_offset = 0;
bool begin_preceding = true;
// Here as well, Unbounded can only be UNBOUNDED FOLLOWING, and end_preceding
// must be false.
BoundaryType end_type = BoundaryType::Current;
Field end_offset = 0;
bool end_preceding = false;
// Throws BAD_ARGUMENTS exception if the frame definition is incorrect, e.g.
// the frame start comes later than the frame end.
void checkValid() const;
std::string toString() const;
void toString(WriteBuffer & buf) const;
bool operator == (const WindowFrame & other) const
{
// We don't compare is_default because it's not a real property of the
// frame, and only influences how we display it.
return other.type == type
&& other.begin_type == begin_type
&& other.begin_offset == begin_offset
&& other.begin_preceding == begin_preceding
&& other.end_type == end_type
&& other.end_offset == end_offset
&& other.end_preceding == end_preceding
;
}
};
struct WindowDescription
{
std::string window_name;
// We don't care about the particular order of keys for PARTITION BY, only
// that they are sorted. For now we always require ASC, but we could be more
// flexible and match any direction, or even different order of columns.
SortDescription partition_by;
SortDescription order_by;
// To calculate the window function, we sort input data first by PARTITION BY,
// then by ORDER BY. This field holds this combined sort order.
SortDescription full_sort_description;
std::vector<ActionsDAGPtr> partition_by_actions;
std::vector<ActionsDAGPtr> order_by_actions;
WindowFrame frame;
// The window functions that are calculated for this window.
std::vector<WindowFunctionDescription> window_functions;
std::string dump() const;
void checkValid() const;
};
using WindowFunctionDescriptions = std::vector<WindowFunctionDescription>;
using WindowDescriptions = std::unordered_map<std::string, WindowDescription>;
}
|
