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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Common/assert_cast.h>
#include <memory>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
namespace
{
/** Transform a named tuple into an array of pairs, where the first element
* of the pair corresponds to the tuple field name and the second one to the
* tuple value.
*/
class FunctionTupleToNameValuePairs : public IFunction
{
public:
static constexpr auto name = "tupleToNameValuePairs";
static FunctionPtr create(ContextPtr)
{
return std::make_shared<FunctionTupleToNameValuePairs>();
}
String getName() const override
{
return name;
}
size_t getNumberOfArguments() const override
{
return 1;
}
bool useDefaultImplementationForConstants() const override
{
return true;
}
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override
{
return true;
}
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
{
// get the type of all the fields in the tuple
const IDataType * col = arguments[0].type.get();
const DataTypeTuple * tuple = checkAndGetDataType<DataTypeTuple>(col);
if (!tuple)
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"First argument for function {} must be a tuple.",
getName());
const auto & element_types = tuple->getElements();
if (element_types.empty())
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"The argument tuple for function {} must not be empty.",
getName());
const auto & first_element_type = element_types[0];
bool all_value_types_equal = std::all_of(element_types.begin() + 1,
element_types.end(),
[&](const auto &other)
{
return first_element_type->equals(*other);
});
if (!all_value_types_equal)
{
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
"The argument tuple for function {} must contain just one type.",
getName());
}
DataTypePtr tuple_name_type = std::make_shared<DataTypeString>();
DataTypes item_data_types = {tuple_name_type,
first_element_type};
auto item_data_type = std::make_shared<DataTypeTuple>(item_data_types);
return std::make_shared<DataTypeArray>(item_data_type);
}
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
{
const IColumn * tuple_col = arguments[0].column.get();
const DataTypeTuple * tuple = checkAndGetDataType<DataTypeTuple>(arguments[0].type.get());
const auto * tuple_col_concrete = assert_cast<const ColumnTuple*>(tuple_col);
auto keys = ColumnString::create();
MutableColumnPtr values = tuple_col_concrete->getColumn(0).cloneEmpty();
auto offsets = ColumnVector<UInt64>::create();
for (size_t row = 0; row < tuple_col_concrete->size(); ++row)
{
for (size_t col = 0; col < tuple_col_concrete->tupleSize(); ++col)
{
const std::string & key = tuple->getElementNames()[col];
const IColumn & value_column = tuple_col_concrete->getColumn(col);
values->insertFrom(value_column, row);
keys->insertData(key.data(), key.size());
}
offsets->insertValue(tuple_col_concrete->tupleSize() * (row + 1));
}
std::vector<ColumnPtr> tuple_columns = { std::move(keys), std::move(values) };
auto tuple_column = ColumnTuple::create(std::move(tuple_columns));
return ColumnArray::create(std::move(tuple_column), std::move(offsets));
}
};
}
REGISTER_FUNCTION(TupleToNameValuePairs)
{
factory.registerFunction<FunctionTupleToNameValuePairs>();
}
}
|
