ClickHouse

1
#include <DataTypes/DataTypeString.h>
2
#include <DataTypes/DataTypeCustomGeo.h>
3
#include <Functions/FunctionFactory.h>
4
#include <Functions/FunctionHelpers.h>
5
#include <Functions/geometryConverters.h>
6
#include <Columns/ColumnString.h>
7

8
#include <string>
9
#include <memory>
10

11
namespace DB
12
{
13

14
namespace ErrorCodes
15
{
16
    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
17
}
18

19
namespace
20
{
21

22
template <class DataTypeName, class Geometry, class Serializer, class NameHolder>
23
class FunctionReadWKT : public IFunction
24
{
25
public:
26
    explicit FunctionReadWKT() = default;
27

28
    static constexpr const char * name = NameHolder::name;
29

30
    String getName() const override
31
    {
32
        return name;
33
    }
34

35
    size_t getNumberOfArguments() const override
36
    {
37
        return 1;
38
    }
39

40
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
41

42
    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
43
    {
44
        if (checkAndGetDataType<DataTypeString>(arguments[0].get()) == nullptr)
45
        {
46
            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "First argument should be String");
47
        }
48

49
        return DataTypeFactory::instance().get(DataTypeName().getName());
50
    }
51

52
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & /*result_type*/, size_t input_rows_count) const override
53
    {
54
        const auto * column_string = checkAndGetColumn<ColumnString>(arguments[0].column.get());
55

56
        Serializer serializer;
57
        Geometry geometry;
58

59
        for (size_t i = 0; i < input_rows_count; ++i)
60
        {
61
            const auto & str = column_string->getDataAt(i).toString();
62
            boost::geometry::read_wkt(str, geometry);
63
            serializer.add(geometry);
64
        }
65

66
        return serializer.finalize();
67
    }
68

69
    bool useDefaultImplementationForConstants() const override
70
    {
71
        return true;
72
    }
73

74
    static FunctionPtr create(ContextPtr)
75
    {
76
        return std::make_shared<FunctionReadWKT<DataTypeName, Geometry, Serializer, NameHolder>>();
77
    }
78
};
79

80
struct ReadWKTPointNameHolder
81
{
82
    static constexpr const char * name = "readWKTPoint";
83
};
84

85
struct ReadWKTRingNameHolder
86
{
87
    static constexpr const char * name = "readWKTRing";
88
};
89

90
struct ReadWKTPolygonNameHolder
91
{
92
    static constexpr const char * name = "readWKTPolygon";
93
};
94

95
struct ReadWKTMultiPolygonNameHolder
96
{
97
    static constexpr const char * name = "readWKTMultiPolygon";
98
};
99

100
}
101

102
REGISTER_FUNCTION(ReadWKT)
103
{
104
    factory.registerFunction<FunctionReadWKT<DataTypePointName, CartesianPoint, PointSerializer<CartesianPoint>, ReadWKTPointNameHolder>>();
105
    factory.registerFunction<FunctionReadWKT<DataTypeRingName, CartesianRing, RingSerializer<CartesianPoint>, ReadWKTRingNameHolder>>();
106
    factory.registerFunction<FunctionReadWKT<DataTypePolygonName, CartesianPolygon, PolygonSerializer<CartesianPoint>, ReadWKTPolygonNameHolder>>();
107
    factory.registerFunction<FunctionReadWKT<DataTypeMultiPolygonName, CartesianMultiPolygon, MultiPolygonSerializer<CartesianPoint>, ReadWKTMultiPolygonNameHolder>>();
108
}
109

110
}
111