[Vectorized][Function] Support geolocation functions on vectorized engine

be/src/geo/geo_types.cpp

@@ -17,9 +17,12 @@
 
 #include "geo/geo_types.h"
 
+#include <s2/s2cap.h>
 #include <s2/s2cell.h>
 #include <s2/s2earth.h>
 #include <s2/s2latlng.h>
+#include <s2/s2polygon.h>
+#include <s2/s2polyline.h>
 #include <s2/util/coding/coder.h>
 #include <s2/util/units/length-units.h>
 #include <stdio.h>
@@ -31,6 +34,18 @@
 
 namespace doris {
 
+GeoPoint::GeoPoint() : _point(new S2Point()) {}
+GeoPoint::~GeoPoint() = default;
+
+GeoLine::GeoLine() = default;
+GeoLine::~GeoLine() = default;
+
+GeoPolygon::GeoPolygon() = default;
+GeoPolygon::~GeoPolygon() = default;
+
+GeoCircle::GeoCircle() = default;
+GeoCircle::~GeoCircle() = default;
+
 void print_s2point(std::ostream& os, const S2Point& point) {
  S2LatLng coord(point);
  os << std::setprecision(12) << coord.lng().degrees() << " " << coord.lat().degrees();
@@ -206,45 +221,59 @@ GeoShape* GeoShape::from_encoded(const void* ptr, size_t size) {
 }
 
 GeoParseStatus GeoPoint::from_coord(double x, double y) {
- return to_s2point(x, y, &_point);
+ return to_s2point(x, y, _point.get());
 }
 
 GeoParseStatus GeoPoint::from_coord(const GeoCoordinate& coord) {
- return to_s2point(coord, &_point);
+ return to_s2point(coord, _point.get());
 }
 
 std::string GeoPoint::to_string() const {
  return as_wkt();
 }
 
 void GeoPoint::encode(std::string* buf) {
- buf->append((const char*)&_point, sizeof(_point));
+ buf->append((const char*)_point.get(), sizeof(*_point));
 }
 
 bool GeoPoint::decode(const void* data, size_t size) {
- if (size < sizeof(_point)) {
+ if (size < sizeof(*_point)) {
  return false;
  }
- memcpy(&_point, data, size);
+ memcpy(_point.get(), data, size);
  return true;
 }
 
 double GeoPoint::x() const {
- return S2LatLng(_point).lng().degrees();
+ return S2LatLng(*_point).lng().degrees();
 }
 
 double GeoPoint::y() const {
- return S2LatLng(_point).lat().degrees();
+ return S2LatLng(*_point).lat().degrees();
 }
 
 std::string GeoPoint::as_wkt() const {
  std::stringstream ss;
  ss << "POINT (";
- print_s2point(ss, _point);
+ print_s2point(ss, *_point);
  ss << ")";
  return ss.str();
 }
 
+bool GeoPoint::ComputeDistance(double x_lng, double x_lat, double y_lng, double y_lat,
+ double* distance) {
+ S2LatLng x = S2LatLng::FromDegrees(x_lat, x_lng);
+ if (!x.is_valid()) {
+ return false;
+ }
+ S2LatLng y = S2LatLng::FromDegrees(y_lat, y_lng);
+ if (!y.is_valid()) {
+ return false;
+ }
+ *distance = S2Earth::ToMeters(x.GetDistance(y));
+ return true;
+}
+
 GeoParseStatus GeoLine::from_coords(const GeoCoordinateList& list) {
  return to_s2polyline(list, &_polyline);
 }
@@ -318,7 +347,7 @@ bool GeoPolygon::contains(const GeoShape* rhs) const {
  switch (rhs->type()) {
  case GEO_SHAPE_POINT: {
  const GeoPoint* point = (const GeoPoint*)rhs;
- return _polygon->Contains(point->point());
+ return _polygon->Contains(*point->point());
  }
  case GEO_SHAPE_LINE_STRING: {
  const GeoLine* line = (const GeoLine*)rhs;
@@ -351,7 +380,7 @@ bool GeoCircle::contains(const GeoShape* rhs) const {
  switch (rhs->type()) {
  case GEO_SHAPE_POINT: {
  const GeoPoint* point = (const GeoPoint*)rhs;
- return _cap->Contains(point->point());
+ return _cap->Contains(*point->point());
  }
  default:
  return false;

be/src/geo/geo_types.h

@@ -17,18 +17,22 @@
 
 #pragma once
 
-#include <s2/s2cap.h>
-#include <s2/s2point.h>
-#include <s2/s2polygon.h>
-#include <s2/s2polyline.h>
-
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "geo/geo_common.h"
 #include "geo/wkt_parse_type.h"
 
+class S2Polyline;
+class S2Polygon;
+class S2Cap;
+
+template <typename T>
+class Vector3;
+typedef Vector3<double> Vector3_d;
+using S2Point = Vector3_d;
+
 namespace doris {
 
 class GeoShape {
@@ -59,15 +63,18 @@ class GeoShape {
 
 class GeoPoint : public GeoShape {
 public:
- GeoPoint() {}
- ~GeoPoint() override {}
+ GeoPoint();
+ ~GeoPoint() override;
 
  GeoParseStatus from_coord(double x, double y);
  GeoParseStatus from_coord(const GeoCoordinate& point);
 
  GeoShapeType type() const override { return GEO_SHAPE_POINT; }
 
- const S2Point& point() const { return _point; }
+ const S2Point* point() const { return _point.get(); }
+
+ static bool ComputeDistance(double x_lng, double x_lat, double y_lng, double y_lat,
+ double* distance);
 
  std::string to_string() const override;
  std::string as_wkt() const override;
@@ -80,13 +87,13 @@ class GeoPoint : public GeoShape {
  bool decode(const void* data, size_t size) override;
 
 private:
- S2Point _point;
+std::unique_ptr<S2Point> _point;
 };
 
 class GeoLine : public GeoShape {
 public:
- GeoLine() {}
- ~GeoLine() override {}
+ GeoLine();
+ ~GeoLine() override;
 
  GeoParseStatus from_coords(const GeoCoordinateList& list);
 
@@ -105,8 +112,8 @@ class GeoLine : public GeoShape {
 
 class GeoPolygon : public GeoShape {
 public:
- GeoPolygon() {}
- ~GeoPolygon() override {}
+ GeoPolygon();
+ ~GeoPolygon() override;
 
  GeoParseStatus from_coords(const GeoCoordinateListList& list);
 
@@ -126,8 +133,8 @@ class GeoPolygon : public GeoShape {
 
 class GeoCircle : public GeoShape {
 public:
- GeoCircle() {}
- ~GeoCircle() {}
+ GeoCircle();
+ ~GeoCircle() override;
 
  GeoParseStatus init(double lng, double lat, double radius);
 

be/src/vec/CMakeLists.txt

@@ -136,6 +136,7 @@ set(VEC_FILES
  functions/comparison_equal_for_null.cpp
  functions/function_json.cpp
  functions/function_datetime_floor_ceil.cpp
+ functions/functions_geo.cpp
  functions/hll_cardinality.cpp
  functions/hll_empty.cpp
  functions/hll_hash.cpp