hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
8f9f37a56f13dbfb91fe31c9b8ed7ea61e2cd1d3
oceanbase/src/sql/engine/expr/ob_expr_st_distance_sphere.cpp

220 lines
8.3 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
* This file contains implementation for st_distance_sphere expr.
*/
#define USING_LOG_PREFIX SQL_ENG
#include "sql/engine/expr/ob_expr_st_distance_sphere.h"
#include "lib/geo/ob_geo_func_common.h"
#include "lib/geo/ob_geo_func_register.h"
#include "sql/engine/expr/ob_geo_expr_utils.h"
using namespace oceanbase::common;
using namespace oceanbase::sql;
namespace oceanbase
{
namespace sql
{
ObExprSTDistanceSphere::ObExprSTDistanceSphere(common::ObIAllocator &alloc)
: ObFuncExprOperator(alloc,
T_FUN_SYS_ST_DISTANCE_SPHERE,
N_ST_DISTANCE_SPHERE,
TWO_OR_THREE,
NOT_ROW_DIMENSION)
{
}
ObExprSTDistanceSphere::~ObExprSTDistanceSphere()
{
}
int ObExprSTDistanceSphere::calc_result_typeN(ObExprResType& type,
ObExprResType* types_stack,
int64_t param_num,
common::ObExprTypeCtx& type_ctx) const
{
int ret = OB_SUCCESS;
UNUSED(type_ctx);
type.set_type(ObDoubleType);
ObObjType type0 = types_stack[0].get_type();
ObObjType type1 = types_stack[1].get_type();
if (ob_is_null(type0) || ob_is_null(type1)) {
// do nothing
} else {
if (!ob_is_geometry(type0)) {
types_stack[0].set_calc_type(ObLongTextType);
types_stack[0].set_calc_collation_type(CS_TYPE_BINARY);
types_stack[0].set_calc_collation_level(CS_LEVEL_IMPLICIT);
}
if (!ob_is_geometry(type1)) {
types_stack[1].set_calc_type(ObLongTextType);
types_stack[1].set_calc_collation_type(CS_TYPE_BINARY);
types_stack[1].set_calc_collation_level(CS_LEVEL_IMPLICIT);
}
}
if (3 == param_num) {
ObObjType radius_type = types_stack[2].get_type();
if (ob_is_null(radius_type)) {
// do nothing
} else if (!ob_is_double_tc(radius_type)) {
types_stack[2].set_calc_type(ObDoubleType);
}
}
return ret;
}
int ObExprSTDistanceSphere::eval_st_distance_sphere(const ObExpr &expr,
ObEvalCtx &ctx,
ObDatum &res)
{
int ret = OB_SUCCESS;
uint32_t arg_num = expr.arg_cnt_;
bool is_null_result = false;
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
omt::ObSrsCacheGuard srs_guard;
const ObSrsItem *srs1 = NULL;
const ObSrsItem *srs2 = NULL;
ObDatum *wkb1_datum = NULL;
ObDatum *wkb2_datum = NULL;
ObString wkb1;
ObString wkb2;
ObString wkb1_copy;
ObString wkb2_copy;
ObGeometry *g1 = NULL;
ObGeometry *g2 = NULL;
ObGeoSrid srid1 = UINT32_MAX;
ObGeoSrid srid2 = UINT32_MAX;
double sphere_radius = DEFAULT_SRID0_SPHERE_RADIUS;
double result = 0.0;
if (OB_FAIL(expr.args_[0]->eval(ctx, wkb1_datum))) {
LOG_WARN("fail to eval wkb1 datum", K(ret));
} else if (wkb1_datum->is_null()) {
is_null_result = true;
} else if (OB_FAIL(expr.args_[1]->eval(ctx, wkb2_datum))) {
LOG_WARN("fail to eval wkb2 datum", K(ret));
} else if (wkb2_datum->is_null()) {
is_null_result = true;
} else if (FALSE_IT(wkb1 = wkb1_datum->get_string())) {
} else if (FALSE_IT(wkb2 = wkb2_datum->get_string())) {
} else if (OB_FAIL(ObTextStringHelper::read_real_string_data(tmp_allocator, *wkb1_datum,
expr.args_[0]->datum_meta_, expr.args_[0]->obj_meta_.has_lob_header(), wkb1))) {
LOG_WARN("fail to get real string data", K(ret), K(wkb1));
} else if (OB_FAIL(ObTextStringHelper::read_real_string_data(tmp_allocator, *wkb2_datum,
expr.args_[1]->datum_meta_, expr.args_[1]->obj_meta_.has_lob_header(), wkb2))) {
LOG_WARN("fail to get real string data", K(ret), K(wkb2));
} else if (OB_FAIL(ob_write_string(tmp_allocator, wkb1, wkb1_copy))) {
LOG_WARN("fail to copy wkb1", K(ret), K(wkb1));
} else if (OB_FAIL(ObGeoExprUtils::get_srs_item(ctx, srs_guard, wkb1_copy, srs1,
true, N_ST_DISTANCE_SPHERE))) {
LOG_WARN("fail to get srs1 item", K(ret), K(wkb1_copy));
} else if (OB_FAIL(ObGeoExprUtils::build_geometry(tmp_allocator, wkb1_copy,
g1, srs1, N_ST_DISTANCE_SPHERE))) {
LOG_WARN("fail to create geo1", K(ret), K(wkb1_copy));
} else if (OB_FAIL(ob_write_string(tmp_allocator, wkb2, wkb2_copy))) {
LOG_WARN("fail to copy wkb2", K(ret), K(wkb2));
} else if (OB_FAIL(ObGeoExprUtils::get_srs_item(ctx, srs_guard, wkb2_copy, srs2,
true, N_ST_DISTANCE_SPHERE))) {
LOG_WARN("fail to get srs2 item", K(ret), K(wkb2_copy));
} else if (OB_FAIL(ObGeoExprUtils::build_geometry(tmp_allocator, wkb2_copy,
g2, srs2, N_ST_DISTANCE_SPHERE))) {
LOG_WARN("fail to create geo2", K(ret), K(wkb2_copy));
} else {
srid1 = OB_ISNULL(srs1) ? 0:srs1->get_srid();
srid2 = OB_ISNULL(srs2) ? 0:srs2->get_srid();
if (srid1 != srid2) {
ret = OB_ERR_GIS_DIFFERENT_SRIDS;
LOG_USER_ERROR(OB_ERR_GIS_DIFFERENT_SRIDS, get_func_name(), srid1, srid2);
} else if (OB_NOT_NULL(srs1)) { // Non-zero SRS overrides default radius.
if (ObSrsType::PROJECTED_SRS == srs1->srs_type()) {
char type_pair[ERR_INFO_LEN] = {0};
snprintf(type_pair, ERR_INFO_LEN, "%s, %s", ObGeoTypeUtil::get_geo_name_by_type(g1->type()),
ObGeoTypeUtil::get_geo_name_by_type(g2->type()));
ret = OB_ERR_NOT_IMPLEMENTED_FOR_PROJECTED_SRS;
LOG_USER_ERROR(OB_ERR_NOT_IMPLEMENTED_FOR_PROJECTED_SRS, get_func_name(), type_pair);
} else {
double a = srs1->semi_major_axis();
double b = srs1->semi_minor_axis();
if (a == b) {
sphere_radius = 0; // Avoid possible loss of precission.
} else {
sphere_radius = ((2.0 * a + b) / 3.0); // Mean radius, as defined by the IUGG
}
}
}
}
if (OB_SUCC(ret) && !is_null_result && arg_num == 3) {
ObDatum *radius_datum = NULL;
if (OB_FAIL(expr.args_[2]->eval(ctx, radius_datum))) {
LOG_WARN("fail to eval radius datum", K(ret));
} else if (radius_datum->is_null()) {
is_null_result = true;
} else {
sphere_radius = radius_datum->get_double();
if (sphere_radius <= 0.0) {
ret = OB_ERR_NONPOSITIVE_RADIUS;
LOG_USER_ERROR(OB_ERR_NONPOSITIVE_RADIUS, get_func_name(), sphere_radius);
}
}
}
if (OB_SUCC(ret) && !is_null_result) {
ObGeoEvalCtx gis_context(&tmp_allocator, srs1);
if (OB_FAIL(gis_context.append_val_arg(sphere_radius))) {
LOG_WARN("fail to append sphere_radius to gis_context", K(ret), K(sphere_radius));
} else if (OB_FAIL(gis_context.append_geo_arg(g1)) || OB_FAIL(gis_context.append_geo_arg(g2))) {
LOG_WARN("fail to append geo arg to gis_context", K(ret));
} else if (OB_FAIL(ObGeoFunc<ObGeoFuncType::DistanceSphere>::gis_func::eval(gis_context, result))) {
LOG_WARN("fail to eval distance sphere", K(ret));
if (OB_ERR_LONGITUDE_OUT_OF_RANGE == ret) {
LOG_USER_ERROR(OB_ERR_LONGITUDE_OUT_OF_RANGE, result, N_ST_DISTANCE_SPHERE, -180.0, 180.0);
} else if (OB_ERR_LATITUDE_OUT_OF_RANGE == ret) {
LOG_USER_ERROR(OB_ERR_LATITUDE_OUT_OF_RANGE, result, N_ST_DISTANCE_SPHERE, -90.0, 90.0);
} else {
ObGeoExprUtils::geo_func_error_handle(ret, N_ST_DISTANCE_SPHERE);
}
} else if (std::isinf(result)) {
ret = OB_ERROR_OUT_OF_RANGE;
LOG_WARN("INFINITY", K(ret), K(result));
}
}
if (OB_SUCC(ret)) {
if (is_null_result) {
res.set_null();
} else {
res.set_double(result);
}
}
return ret;
}
int ObExprSTDistanceSphere::cg_expr(ObExprCGCtx &expr_cg_ctx,
const ObRawExpr &raw_expr,
ObExpr &rt_expr) const
{
UNUSED(expr_cg_ctx);
UNUSED(raw_expr);
rt_expr.eval_func_ = eval_st_distance_sphere;
return OB_SUCCESS;
}
} // namespace sql
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink