ClickHouse/src/Functions/polygonsWithin.cpp

120 lines
3.4 KiB
C++
Raw Normal View History

2021-02-20 13:59:37 +00:00
#include <Functions/FunctionFactory.h>
#include <Functions/geometryConverters.h>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <common/logger_useful.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeCustomGeo.h>
#include <memory>
#include <utility>
2021-02-20 13:59:37 +00:00
namespace DB
{
2021-02-20 17:44:18 +00:00
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
template <typename Point>
2021-02-20 13:59:37 +00:00
class FunctionPolygonsWithin : public IFunction
{
public:
static inline const char * name;
2021-02-20 13:59:37 +00:00
explicit FunctionPolygonsWithin() = default;
2021-06-01 12:20:52 +00:00
static FunctionPtr create(ContextPtr)
2021-02-20 13:59:37 +00:00
{
return std::make_shared<FunctionPolygonsWithin>();
}
String getName() const override
{
return name;
}
bool isVariadic() const override
{
return false;
}
size_t getNumberOfArguments() const override
{
return 2;
}
DataTypePtr getReturnTypeImpl(const DataTypes &) const override
{
return std::make_shared<DataTypeUInt8>();
}
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & /*result_type*/, size_t input_rows_count) const override
{
auto res_column = ColumnUInt8::create();
auto & res_data = res_column->getData();
res_data.reserve(input_rows_count);
callOnTwoGeometryDataTypes<Point>(arguments[0].type, arguments[1].type, [&](const auto & left_type, const auto & right_type)
{
using LeftConverterType = std::decay_t<decltype(left_type)>;
using RightConverterType = std::decay_t<decltype(right_type)>;
using LeftConverter = typename LeftConverterType::Type;
using RightConverter = typename RightConverterType::Type;
2021-02-26 15:29:26 +00:00
if constexpr (std::is_same_v<ColumnToPointsConverter<Point>, LeftConverter> || std::is_same_v<ColumnToPointsConverter<Point>, RightConverter>)
2021-02-20 17:44:18 +00:00
throw Exception(fmt::format("Any argument of function {} must not be Point", getName()), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
else
2021-02-20 13:59:37 +00:00
{
2021-02-26 15:29:26 +00:00
auto first = LeftConverter::convert(arguments[0].column->convertToFullColumnIfConst());
auto second = RightConverter::convert(arguments[1].column->convertToFullColumnIfConst());
2021-02-20 17:44:18 +00:00
/// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Assign)
for (size_t i = 0; i < input_rows_count; i++)
{
boost::geometry::correct(first[i]);
boost::geometry::correct(second[i]);
2021-02-20 13:59:37 +00:00
2021-02-20 17:44:18 +00:00
res_data.emplace_back(boost::geometry::within(first[i], second[i]));
}
2021-02-20 13:59:37 +00:00
}
});
return res_column;
}
bool useDefaultImplementationForConstants() const override
{
return true;
}
};
template <>
const char * FunctionPolygonsWithin<CartesianPoint>::name = "polygonsWithinCartesian";
template <>
const char * FunctionPolygonsWithin<SphericalPoint>::name = "polygonsWithinSpherical";
2021-02-20 13:59:37 +00:00
void registerFunctionPolygonsWithin(FunctionFactory & factory)
{
factory.registerFunction<FunctionPolygonsWithin<CartesianPoint>>();
factory.registerFunction<FunctionPolygonsWithin<SphericalPoint>>();
2021-02-20 13:59:37 +00:00
}
2020-06-21 14:54:13 +00:00
2021-02-20 13:59:37 +00:00
}