1 files changed, 143 insertions, 3 deletions

diff --git a/sql/item_geofunc.cc b/sql/item_geofunc.cc
index 20ac6f0c88c..f2cc2e61b96 100644
--- a/sql/item_geofunc.cc
+++ b/sql/item_geofunc.cc
@@ -136,7 +136,7 @@ String *Item_func_geometry_from_json::val_str(String *str)
     {
       String *sv= args[1]->val_str(&tmp_js);
       my_error(ER_WRONG_VALUE_FOR_TYPE, MYF(0),
-               "option", sv->c_ptr_safe(), "ST_GeometryFromJSON");
+               "option", sv->c_ptr_safe(), "ST_GeomFromGeoJSON");
       null_value= 1;
       return 0;
     }
@@ -173,7 +173,7 @@ String *Item_func_geometry_from_json::val_str(String *str)
       code= ER_GEOJSON_NOT_CLOSED;
       break;
     case Geometry::GEOJ_DIMENSION_NOT_SUPPORTED:
-      my_error(ER_GIS_INVALID_DATA, MYF(0), "ST_GeometryFromJSON");
+      my_error(ER_GIS_INVALID_DATA, MYF(0), "ST_GeomFromGeoJSON");
       break;
     default:
       report_json_error_ex(js, &je, func_name(), 0, Sql_condition::WARN_LEVEL_WARN);
@@ -2528,11 +2528,151 @@ mem_error:
 }
 
 
+double Item_func_sphere_distance::val_real()
+{
+  /* To test null_value of item, first get well-known bytes as a backups */
+  String bak1, bak2;
+  String *arg1= args[0]->val_str(&bak1);
+  String *arg2= args[1]->val_str(&bak2);
+  double distance= 0.0;
+  double sphere_radius= 6370986.0; // Default radius equals Earth radius
+  
+  null_value= (args[0]->null_value || args[1]->null_value);
+  if (null_value)
+  {
+    return 0;
+  }
+
+  if (arg_count == 3)
+  {
+    sphere_radius= args[2]->val_real();
+    // Radius cannot be Null
+    if (args[2]->null_value)
+    {
+      null_value= true;
+      return 0;
+    }
+    if (sphere_radius <= 0)
+    {
+      my_error(ER_INTERNAL_ERROR, MYF(0), "Radius must be greater than zero.");
+      return 1;
+    }
+  }
+  Geometry_buffer buffer1, buffer2;
+  Geometry *g1, *g2;
+  if (!(g1= Geometry::construct(&buffer1, arg1->ptr(), arg1->length())) ||
+      !(g2= Geometry::construct(&buffer2, arg2->ptr(), arg2->length())))
+  {
+    my_error(ER_GIS_INVALID_DATA, MYF(0), "ST_Distance_Sphere");
+    goto handle_errors;
+  }
+// Method allowed for points and multipoints
+  if (!(g1->get_class_info()->m_type_id == Geometry::wkb_point ||
+        g1->get_class_info()->m_type_id == Geometry::wkb_multipoint) ||
+      !(g2->get_class_info()->m_type_id == Geometry::wkb_point ||
+        g2->get_class_info()->m_type_id == Geometry::wkb_multipoint))
+  {
+    // Generate error message in case different geometry is used? 
+    my_error(ER_INTERNAL_ERROR, MYF(0), func_name());
+    return 0;
+  }
+  distance= spherical_distance_points(g1, g2, sphere_radius);
+  if (distance < 0)
+  {
+    my_error(ER_INTERNAL_ERROR, MYF(0), "Returned distance cannot be negative.");
+    return 1;
+  }
+  return distance;
+
+  handle_errors:
+    return 0;
+}
+
+
+double Item_func_sphere_distance::spherical_distance_points(Geometry *g1,
+                                                            Geometry *g2,
+                                                            const double r)
+{
+  double res= 0.0;
+   // Length for the single point (25 Bytes)
+  uint32 len= SRID_SIZE + POINT_DATA_SIZE + WKB_HEADER_SIZE;
+  int error= 0;
+
+  switch (g2->get_class_info()->m_type_id)
+  {
+    case Geometry::wkb_point:
+    // Optimization for point-point case
+      if (g1->get_class_info()->m_type_id == Geometry::wkb_point)
+      {
+        res= static_cast<Gis_point *>(g2)->calculate_haversine(g1, r, &error);
+      }
+      else
+      {
+        // Optimization for single point in Multipoint
+        if (g1->get_data_size() == len)
+        {
+          res= static_cast<Gis_point *>(g2)->calculate_haversine(g1, r, &error);
+        }
+        else
+        {
+          // There are multipoints in g1
+          // g1 is MultiPoint and calculate MP.sphericaldistance from g2 Point
+          if (g1->get_data_size() != GET_SIZE_ERROR)
+            static_cast<Gis_point *>(g2)->spherical_distance_multipoints(
+                                        (Gis_multi_point *)g1, r, &res, &error);
+        }
+      }
+      break;
+
+    case Geometry::wkb_multipoint:
+      // Optimization for point-point case
+      if (g1->get_class_info()->m_type_id == Geometry::wkb_point)
+      {
+         // Optimization for single point in Multipoint g2
+        if (g2->get_data_size() == len)
+        {
+          res= static_cast<Gis_point *>(g1)->calculate_haversine(g2, r, &error);
+        }
+        else
+        {
+          if (g2->get_data_size() != GET_SIZE_ERROR)
+          // g1 is a point (casted to multi_point) and g2 multipoint
+            static_cast<Gis_point *>(g1)->spherical_distance_multipoints(
+                                        (Gis_multi_point *)g2, r, &res, &error);
+        }
+      }
+      else
+      {
+        // Multipoints in g1 and g2 - no optimization
+        static_cast<Gis_multi_point *>(g1)->spherical_distance_multipoints(
+                                        (Gis_multi_point *)g2, r, &res, &error);
+      }
+      break;
+
+    default:
+      DBUG_ASSERT(0);
+      break;
+  }
+
+  if (res < 0)
+    goto handle_error;
+
+  handle_error:
+    if (error > 0)
+      my_error(ER_STD_OUT_OF_RANGE_ERROR, MYF(0),
+               "Longitude should be [-180,180]", "ST_Distance_Sphere");
+    else if(error < 0)
+      my_error(ER_STD_OUT_OF_RANGE_ERROR, MYF(0),
+               "Latitude should be [-90,90]", "ST_Distance_Sphere");
+  return res;
+}
+
+
 String *Item_func_pointonsurface::val_str(String *str)
 {
   Gcalc_operation_transporter trn(&func, &collector);
 
-  DBUG_ENTER("Item_func_pointonsurface::val_real");
+  DBUG_ENTER("Item_func_pointonsurface::val_str");
   DBUG_ASSERT(fixed == 1);
   String *res= args[0]->val_str(&tmp_value);
   Geometry_buffer buffer;