H3 - add function h3ToGeo

src/Functions/h3toGeo.cpp

@@ -0,0 +1,102 @@
+#if !defined(ARCADIA_BUILD)
+#    include "config_functions.h"
+#endif
+
+#if USE_H3
+
+#include <array>
+#include <math.h>
+#include <Columns/ColumnArray.h>
+#include <Columns/ColumnTuple.h>
+#include <Columns/ColumnsNumber.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <Functions/FunctionFactory.h>
+#include <Functions/IFunction.h>
+#include <Common/typeid_cast.h>
+#include <ext/range.h>
+
+#include <h3api.h>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+    extern const int ILLEGAL_COLUMN;
+
+}
+
+namespace
+{
+
+/// Implements the function h3ToGeo which takes a single argument (h3Index)
+/// and returns the latitude and longitude that correspond to the provided h3 index
+class FunctionH3ToGeo : public IFunction
+{
+public:
+    static constexpr auto name = "H3ToGeo";
+
+    static FunctionPtr create(ContextConstPtr) { return std::make_shared<FunctionH3ToGeo>(); }
+
+    std::string getName() const override { return name; }
+
+    size_t getNumberOfArguments() const override { return 1; }
+    bool useDefaultImplementationForConstants() const override { return true; }
+
+        DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
+        {
+            const auto * arg = arguments[0].get();
+            if (!WhichDataType(arg).isUInt64())
+                throw Exception(
+                    "Illegal type " + arg->getName() + " of argument " + std::to_string(1) + " of function " + getName() + ". Must be UInt64",
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            return std::make_shared<DataTypeTuple>(
+                DataTypes{std::make_shared<DataTypeFloat64>(), std::make_shared<DataTypeFloat64>()},
+                Strings{"latitude", "longitude"});
+        }
+
+        ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
+        {
+            const auto * col_index = arguments[0].column.get();
+
+            auto dst = ColumnVector<Float64>::create();
+
+            auto & dst_data = dst->getData();
+            dst_data.resize(input_rows_count);
+            ColumnPtr res_column;
+
+
+            auto latitude = ColumnFloat64::create(input_rows_count);
+            auto longitude = ColumnFloat64::create(input_rows_count);
+
+            ColumnFloat64::Container & lon_data = longitude->getData();
+            ColumnFloat64::Container & lat_data = latitude->getData();
+
+            for (const auto row : ext::range(0, input_rows_count))
+            {
+                const UInt64 h3Index = col_index->getUInt(row);
+                GeoCoord coord;
+                h3ToGeo(h3Index,&coord);
+                lon_data[row] = coord.lon;
+                lat_data[row] = coord.lat;
+
+            }
+            MutableColumns result;
+            result.emplace_back(std::move(latitude));
+            result.emplace_back(std::move(longitude));
+            return ColumnTuple::create(std::move(result));
+        }
+};
+
+}
+
+void registerFunctionH3ToGeo(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionH3ToGeo>();
+}
+
+}
+
+#endif

src/Functions/registerFunctionsGeo.cpp

@@ -28,6 +28,7 @@ void registerFunctionSvg(FunctionFactory & factory);
 
 #if USE_H3
 void registerFunctionGeoToH3(FunctionFactory &);
+void registerFunctionH3ToGeo(FunctionFactory &);
 void registerFunctionH3EdgeAngle(FunctionFactory &);
 void registerFunctionH3EdgeLengthM(FunctionFactory &);
 void registerFunctionH3GetResolution(FunctionFactory &);
@@ -66,6 +67,7 @@ void registerFunctionsGeo(FunctionFactory & factory)
 
 #if USE_H3
     registerFunctionGeoToH3(factory);
+    registerFunctionH3ToGeo(factory);
     registerFunctionH3EdgeAngle(factory);
     registerFunctionH3EdgeLengthM(factory);
     registerFunctionH3GetResolution(factory);