hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

[FEAT MERGE] GIS

Browse Source
This commit is contained in:
obdev
2022-12-23 12:08:27 +00:00
committed by ob-robot
parent 38846e73d6
commit 40d215fc5a
519 changed files with 158600 additions and 8396 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
unittest/sql/engine/expr/CMakeLists.txt
View File

@ -4,6 +4,8 @@
#sql_unittest(ob_expr_equal_test)
#sql_unittest(ob_expr_res_type_map_test)
#sql_unittest(ob_expr_operator_factory_test)
sql_unittest(ob_geo_expr_utils_test)
sql_unittest(test_gis_dispatcher test_gis_dispatcher.cpp ob_geo_func_testx.cpp ob_geo_func_testy.cpp)
# engine_expr_test_lrpad_SOURCES=engine/expr/ob_expr_lrpad_test.cpp
#ob_postfix_expression_test_SOURCES = ob_postfix_expression_test.cpp

75
unittest/sql/engine/expr/ob_geo_expr_utils_test.cpp Normal file
View File

@ -0,0 +1,75 @@
/**
* 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 testcase for ob_geo_expr_utils.
*/
#include <gtest/gtest.h>
#include "sql/engine/expr/ob_geo_expr_utils.h"
using namespace oceanbase::common;
using namespace oceanbase::sql;
class ObExprGeoUtilsTest : public ::testing::Test
{
public:
ObExprGeoUtilsTest();
virtual ~ObExprGeoUtilsTest();
virtual void SetUp();
virtual void TearDown();
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObExprGeoUtilsTest);
};
ObExprGeoUtilsTest::ObExprGeoUtilsTest()
{
}
ObExprGeoUtilsTest::~ObExprGeoUtilsTest()
{
}
void ObExprGeoUtilsTest::SetUp()
{
}
void ObExprGeoUtilsTest::TearDown()
{
}
TEST_F(ObExprGeoUtilsTest, parse_axis_order_test)
{
ObGeoAxisOrder axis_order;
ASSERT_EQ(OB_SUCCESS, ObGeoExprUtils::parse_axis_order(ObString("axis-order=lat-long"), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::LAT_LONG, axis_order);
ASSERT_EQ(OB_SUCCESS, ObGeoExprUtils::parse_axis_order(ObString(" axis-order= long-lat "), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::LONG_LAT, axis_order);
ASSERT_EQ(OB_SUCCESS, ObGeoExprUtils::parse_axis_order(ObString(" axis-order= srid-defined "), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::SRID_DEFINED, axis_order);
ASSERT_EQ(OB_ERR_PARSER_SYNTAX, ObGeoExprUtils::parse_axis_order(ObString(" axis-order: = long-lat ,"), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::INVALID, axis_order);
ASSERT_EQ(OB_ERR_PARSER_SYNTAX, ObGeoExprUtils::parse_axis_order(ObString(" axis-order= long-lat ,"), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::INVALID, axis_order);
ASSERT_EQ(OB_ERR_PARSER_SYNTAX, ObGeoExprUtils::parse_axis_order(ObString(" axis-order= srid-defined, axis-order = srid-defined"), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::INVALID, axis_order);
ASSERT_EQ(OB_ERR_PARSER_SYNTAX, ObGeoExprUtils::parse_axis_order(ObString(" . = ."), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::INVALID, axis_order);
ASSERT_EQ(OB_ERR_PARSER_SYNTAX, ObGeoExprUtils::parse_axis_order(ObString(""), "unit_test", axis_order));
ASSERT_EQ(ObGeoAxisOrder::INVALID, axis_order);
}
int main(int argc, char **argv)
{
oceanbase::common::ObLogger::get_logger().set_log_level("DEBUG");
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}

221
unittest/sql/engine/expr/ob_geo_func_testx.cpp Normal file
View File

@ -0,0 +1,221 @@
/**
* 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 geo_func_mockx.
*/
#include "lib/geo/ob_geo_dispatcher.h"
#include "lib/geo/ob_geo_ibin.h"
#include "ob_geo_func_testx.h"
#include "ob_geo_func_testy.h"
using namespace oceanbase::common;
namespace oceanbase
{
namespace sql
{
// unittest codes
class ObGeoFuncTypeXImpl : public ObIGeoDispatcher<int, ObGeoFuncTypeXImpl>
{
public:
ObGeoFuncTypeXImpl();
virtual ~ObGeoFuncTypeXImpl() = default;
// template for unary
template <typename GeometyType>
struct Eval {
static int eval(const ObGeometry *g, const ObGeoEvalCtx &context, int &result)
{
UNUSED(context);
result = static_cast<int>(g->type());
return OB_SUCCESS;
}
};
template <typename GeometyType>
struct EvalTree {
static int eval(const ObGeometry *g, const ObGeoEvalCtx &context, int &result)
{
UNUSED(context);
result = static_cast<int>(g->type());
return OB_SUCCESS;
}
};
// templates for binary
template <typename GeometyType1, typename GeometyType2>
struct EvalWkbBi {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSED(context);
result = 0;
result += static_cast<int>(g1->type());
result += static_cast<int>(g2->type());
return OB_SUCCESS;
}
};
template <typename GeometyType1, typename GeometyType2>
struct EvalWkbBiGeog {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSED(context);
result = 0;
result += static_cast<int>(g1->type());
result += static_cast<int>(g2->type());
return OB_SUCCESS;
}
};
OB_GEO_CART_TREE_FUNC_DEFAULT(int, OB_ERR_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS);
OB_GEO_GEOG_TREE_FUNC_DEFAULT(int, OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS);
// unary specialization for geographic geometrycollection
template <>
struct Eval<ObWkbGeogCollection> {
static int eval(const ObGeometry *g, const ObGeoEvalCtx &context, int &result)
{
UNUSED(context);
result = static_cast<int>(g->type());
return OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS;
}
};
// binary specialization for geographic geometrycollection and geographic geometrycollection
template <>
struct EvalWkbBiGeog<ObWkbGeogCollection, ObWkbGeogCollection> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSED(context);
result = 0;
result += static_cast<int>(g1->type());
result += static_cast<int>(g2->type());
return OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS;
}
};
// binary specialization for geographic multipoint and geographic multipoint
template <>
struct EvalWkbBiGeog<ObWkbGeogMultiPoint, ObWkbGeogMultiPoint> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
ObGeoEvalCtx gis_context(context.get_allocator(), context.get_srs());
ObString dumy_wkb(4, 4, "dumy");
ObIWkbGeogPoint gmp1;
ObIWkbGeogPoint gmp2;
gmp1.set_data(dumy_wkb);
gmp2.set_data(dumy_wkb);
gis_context.append_geo_arg(&gmp1);
gis_context.append_geo_arg(&gmp2);
return ObGeoFuncTypeX::eval(gis_context, result);
}
};
// binary partial specialization for geographic point
template <typename GeometyType2>
struct EvalWkbBiGeog<ObWkbGeogPoint, GeometyType2> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = 100;
return OB_SUCCESS;
}
};
};
template <typename GeometyType1>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<GeometyType1, ObWkbGeogPoint> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = -100;
return OB_SUCCESS;
}
};
// binary specializations
template <>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<ObWkbGeogPoint, ObWkbGeogPoint> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
INIT_SUCC(ret);
UNUSEDx(context, g1, g2);
result = 300;
int tmp_result;
ret = ObGeoFuncMockY::eval(context, tmp_result);
result += tmp_result;
return OB_SUCCESS;
}
};
template <>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<ObWkbGeogPolygon, ObWkbGeogPoint> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = 400;
return OB_SUCCESS;
}
};
template <>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<ObWkbGeogPoint, ObWkbGeogPolygon> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = -400;
return OB_SUCCESS;
}
};
template <>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<ObWkbGeogPolygon, ObWkbGeogPolygon> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = 800;
return OB_SUCCESS;
}
};
// binary partial specialization for geographic polygon
template<typename GeometryType2>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<ObWkbGeogPolygon, GeometryType2> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = 777;
throw boost::geometry::centroid_exception();
return OB_SUCCESS;
}
};
template<typename GeometryType1>
struct ObGeoFuncTypeXImpl::EvalWkbBiGeog<GeometryType1, ObWkbGeogPolygon> {
static int eval(const ObGeometry *g1, const ObGeometry *g2, const ObGeoEvalCtx &context, int &result)
{
UNUSEDx(context, g1, g2);
result = 666;
throw boost::geometry::centroid_exception();
return OB_SUCCESS;
}
};
// implement of outer class eval
// use an outer class to void implement templates in header files
int ObGeoFuncTypeX::eval(const ObGeoEvalCtx &gis_context, int &result)
{
return ObGeoFuncTypeXImpl::eval_geo_func(gis_context, result);
}
} // sql
} // oceanbase

34
unittest/sql/engine/expr/ob_geo_func_testx.h Normal file
View File

@ -0,0 +1,34 @@
/**
* 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 geo_func_mockx.
*/
#ifndef OCEANBASE_SQL_OB_GEO_FUNC_TESTX_H_
#define OCEANBASE_SQL_OB_GEO_FUNC_TESTX_H_
#include "lib/geo/ob_geo_func_common.h"
namespace oceanbase
{
namespace sql
{
class ObGeoFuncTypeX
{
public:
ObGeoFuncTypeX();
virtual ~ObGeoFuncTypeX() = default;
static int eval(const common::ObGeoEvalCtx &gis_context, int &result);
};
} // sql
} // oceanbase
#endif // OCEANBASE_SQL_OB_GEO_FUNC_TESTX_H_

356
unittest/sql/engine/expr/ob_geo_func_testy.cpp Normal file
View File

@ -0,0 +1,356 @@
/**
* 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 ob_geo_func_testy.
*/
#include "lib/geo/ob_geo_dispatcher.h"
#include "ob_geo_func_testy.h"
using namespace oceanbase::common;
namespace oceanbase
{
namespace sql
{
// unittest codes
constexpr int max_crs_type = 3;
constexpr int max_geo_type = 8;
int g_test_geo_unary_func_result[max_crs_type][max_geo_type];
int g_test_geo_binary_func_result[max_crs_type][max_geo_type][max_crs_type][max_geo_type];
#if 0
ObIWkbGeomPoint cp;
ObIWkbGeomLineString cl;
ObIWkbGeomPolygon ca;
ObIWkbGeomMultiPoint cmp;
ObIWkbGeomMultiLineString cml;
ObIWkbGeomMultiPolygon cma;
ObIWkbGeomCollection cc;
ObIWkbGeogPoint gp;
ObIWkbGeogLineString gl;
ObIWkbGeogPolygon ga;
ObIWkbGeogMultiPoint gmp;
ObIWkbGeogMultiLineString gml;
ObIWkbGeogMultiPolygon gma;
ObIWkbGeogCollection gc;
#endif
template<typename CHECK_TYPE>
bool check_geo_type(const ObGeometry *g) {
bool bool_ret = false;
switch(g->crs()) {
case ObGeoCRS::Cartesian :{
switch(g->type()) {
case ObGeoType::POINT: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomPoint));
break;
}
case ObGeoType::LINESTRING: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomLineString));
break;
}
case ObGeoType::POLYGON: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomPolygon));
break;
}
case ObGeoType::MULTIPOINT: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomMultiPoint));
break;
}
case ObGeoType::MULTILINESTRING: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomMultiLineString));
break;
}
case ObGeoType::MULTIPOLYGON: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomMultiPolygon));
break;
}
case ObGeoType::GEOMETRYCOLLECTION: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeomCollection));
break;
}
default:{
break;
}
}
break;
}
case ObGeoCRS::Geographic :{
switch(g->type()) {
case ObGeoType::POINT: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogPoint));
break;
}
case ObGeoType::LINESTRING: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogLineString));
break;
}
case ObGeoType::POLYGON: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogPolygon));
break;
}
case ObGeoType::MULTIPOINT: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogMultiPoint));
break;
}
case ObGeoType::MULTILINESTRING: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogMultiLineString));
break;
}
case ObGeoType::MULTIPOLYGON: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogMultiPolygon));
break;
}
case ObGeoType::GEOMETRYCOLLECTION: {
bool_ret = (typeid(CHECK_TYPE) == typeid(ObWkbGeogCollection));
break;
}
default:{
break;
}
}
break;
}
default:{
break;
}
}
return bool_ret;
}
#define OB_GEO_UNARY_TEST_FUNC_DEFINE(GEO_TYPE) \
template <> \
struct Eval<GEO_TYPE> { \
static int eval(const ObGeometry *g, const ObGeoEvalCtx &context, int &result) { \
UNUSED(context); \
if (check_geo_type<GEO_TYPE>(g) == false) { \
return OB_INVALID_ARGUMENT; \
} \
result = g_test_geo_unary_func_result[static_cast<int>(g->crs())][static_cast<int>(g->type())]; \
return OB_SUCCESS; \
} \
}
#define OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(GEO_TYPE1, GEO_TYPE2) \
template <> \
struct EvalWkbBi<GEO_TYPE1, GEO_TYPE2> { \
static int eval(const ObGeometry *g1, const ObGeometry *g2, \
const ObGeoEvalCtx &context, int &result) \
{ \
UNUSED(context); \
if (check_geo_type<GEO_TYPE1>(g1) == false) { \
return OB_INVALID_ARGUMENT; \
} \
if (check_geo_type<GEO_TYPE2>(g2) == false) { \
return OB_INVALID_ARGUMENT; \
} \
result = g_test_geo_binary_func_result[static_cast<int>(g1->crs())][static_cast<int>(g1->type())][static_cast<int>(g2->crs())][static_cast<int>(g2->type())]; \
return OB_SUCCESS; \
} \
}
#define OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(GEO_TYPE1, GEO_TYPE2) \
template <> \
struct EvalWkbBiGeog<GEO_TYPE1, GEO_TYPE2> { \
static int eval(const ObGeometry *g1, const ObGeometry *g2, \
const ObGeoEvalCtx &context, int &result) \
{ \
UNUSED(context); \
if (check_geo_type<GEO_TYPE1>(g1) == false) { \
return OB_INVALID_ARGUMENT; \
} \
if (check_geo_type<GEO_TYPE2>(g2) == false) { \
return OB_INVALID_ARGUMENT; \
} \
result = g_test_geo_binary_func_result[static_cast<int>(g1->crs())][static_cast<int>(g1->type())][static_cast<int>(g2->crs())][static_cast<int>(g2->type())]; \
return OB_SUCCESS; \
} \
}
int ob_test_init_geo_dispatcher_result() {
for (int crs_type = 1; crs_type < static_cast<int>(ObGeoCRS::Geographic) + 1; crs_type++) {
for (int g1_type = 0; g1_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g1_type++) {
g_test_geo_unary_func_result[crs_type][g1_type] = (crs_type << 8) + g1_type;
}
}
for (int crs_type = 1; crs_type < static_cast<int>(ObGeoCRS::Geographic) + 1; crs_type++) {
for (int g1_type = 0; g1_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g1_type++) {
for (int g2_type = 0; g2_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g2_type++) {
g_test_geo_binary_func_result[crs_type][g1_type][crs_type][g2_type] = (crs_type << 8) + g1_type + g2_type;
}
}
}
return OB_SUCCESS;
}
int ob_test_init_geo_dispatcher_ret = ob_test_init_geo_dispatcher_result();
class ObGeoFuncMockyImpl : public ObIGeoDispatcher<int, ObGeoFuncMockyImpl>
{
public:
ObGeoFuncMockyImpl();
virtual ~ObGeoFuncMockyImpl() = default;
// template for unary
OB_GEO_UNARY_FUNC_DEFAULT(int, OB_ERR_GIS_INVALID_DATA);
OB_GEO_TREE_UNARY_FUNC_DEFAULT(int, OB_ERR_GIS_INVALID_DATA);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomPoint);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomLineString);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeomCollection);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogPoint);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogLineString);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon);
OB_GEO_UNARY_TEST_FUNC_DEFINE(ObWkbGeogCollection);
// template for binary
OB_GEO_CART_BINARY_FUNC_DEFAULT(int, OB_ERR_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS);
OB_GEO_GEOG_BINARY_FUNC_DEFAULT(int, OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPoint, ObWkbGeomCollection);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomLineString, ObWkbGeomCollection);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomPolygon, ObWkbGeomCollection);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPoint, ObWkbGeomCollection);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiLineString, ObWkbGeomCollection);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomMultiPolygon, ObWkbGeomCollection);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomMultiPoint);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomMultiLineString);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomMultiPolygon);
OB_GEO_CART_BINARY_TEST_FUNC_DEFINE(ObWkbGeomCollection, ObWkbGeomCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPoint, ObWkbGeogCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogLineString, ObWkbGeogCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogPolygon, ObWkbGeogCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPoint, ObWkbGeogCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiLineString, ObWkbGeogCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogMultiPolygon, ObWkbGeogCollection);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogMultiPoint);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogMultiLineString);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogMultiPolygon);
OB_GEO_GEOG_BINARY_TEST_FUNC_DEFINE(ObWkbGeogCollection, ObWkbGeogCollection);
OB_GEO_CART_TREE_FUNC_DEFAULT(int, OB_ERR_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS);
OB_GEO_GEOG_TREE_FUNC_DEFAULT(int, OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS);
};
// implement of outer class eval
// use an outer class to void implement templates in header files
int ObGeoFuncMockY::eval(const ObGeoEvalCtx &gis_context, int &result)
{
return ObGeoFuncMockyImpl::eval_geo_func(gis_context, result);
}
} // sql
} // oceanbase

37
unittest/sql/engine/expr/ob_geo_func_testy.h Normal file
View File

@ -0,0 +1,37 @@
/**
* 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 ob_geo_func_testy.
*/
#ifndef OCEANBASE_SQL_OB_GEO_FUNC_TESTY_H_
#define OCEANBASE_SQL_OB_GEO_FUNC_TESTY_H_
#include "lib/geo/ob_geo_func_common.h"
namespace oceanbase
{
namespace sql
{
extern int g_test_geo_unary_func_result[3][8];
extern int g_test_geo_binary_func_result[3][8][3][8];
class ObGeoFuncMockY
{
public:
ObGeoFuncMockY();
virtual ~ObGeoFuncMockY() = default;
static int eval(const common::ObGeoEvalCtx &gis_context, int &result);
};
} // sql
} // oceanbase
#endif // OCEANBASE_SQL_OB_GEO_FUNC_TESTY_H_

268
unittest/sql/engine/expr/test_gis_dispatcher.cpp Normal file
View File

@ -0,0 +1,268 @@
#include <gtest/gtest.h>
#include <sys/time.h>
#include "lib/geo/ob_geo_func_register.h"
#include "ob_geo_func_testx.h"
#include "ob_geo_func_testy.h"
#include "lib/json_type/ob_json_common.h"
using namespace oceanbase::common;
namespace oceanbase {
namespace sql {
class TestGisDispatcher : public ::testing::Test {
public:
TestGisDispatcher()
{}
~TestGisDispatcher()
{}
virtual void SetUp()
{}
virtual void TearDown()
{}
static void SetUpTestCase()
{}
static void TearDownTestCase()
{}
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(TestGisDispatcher);
};
// X will call functor Y
enum class ObGeoFuncTestType
{
NotImplemented = 0,
TypeX = 1,
TypeY = 2
};
template <ObGeoFuncTestType func_type>
struct ObGisTestFunc {
typedef ObGeoFuncNotImplemented geo_func;
};
template <>
struct ObGisTestFunc<ObGeoFuncTestType::TypeX> {
typedef ObGeoFuncTypeX geo_func;
};
template <>
struct ObGisTestFunc<ObGeoFuncTestType::TypeY> {
typedef ObGeoFuncMockY geo_func;
};
TEST_F(TestGisDispatcher, not_impl)
{
ObIWkbGeomPoint cp;
ObIWkbGeogPoint gp;
int ret = OB_SUCCESS;
int result;
ObGeoEvalCtx gis_context;
ret = ObGisTestFunc<ObGeoFuncTestType::NotImplemented>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_ERR_GIS_INVALID_DATA);
ret = OB_SUCCESS;
ret = ObGeoFunc<ObGeoFuncType::NotImplemented>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_ERR_GIS_INVALID_DATA);
}
TEST_F(TestGisDispatcher, dispatcher)
{
ObString dumy_wkb(4, 4, "dumy");
ObIWkbGeomPoint cp;
ObIWkbGeomLineString cl;
ObIWkbGeomPolygon ca;
ObIWkbGeomMultiPoint cmp;
ObIWkbGeomMultiLineString cml;
ObIWkbGeomMultiPolygon cma;
ObIWkbGeomCollection cc;
ObIWkbGeogPoint gp;
ObIWkbGeogLineString gl;
ObIWkbGeogPolygon ga;
ObIWkbGeogMultiPoint gmp;
ObIWkbGeogMultiLineString gml;
ObIWkbGeogMultiPolygon gma;
ObIWkbGeogCollection gc;
ObArenaAllocator allocator(ObModIds::TEST);
ObSrsItem srs(NULL);
ObGeoEvalCtx gis_context(&allocator, &srs);
ObGeometry *gis_args[3][8] = {{0}};
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::POINT)] = &cp;
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::LINESTRING)] = &cl;
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::POLYGON)] = &ca;
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::MULTIPOINT)] = &cmp;
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::MULTILINESTRING)] = &cml;
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::MULTIPOLYGON)] = &cma;
gis_args[static_cast<int>(ObGeoCRS::Cartesian)][static_cast<int>(ObGeoType::GEOMETRYCOLLECTION)] = &cc;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::POINT)] = &gp;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::LINESTRING)] = &gl;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::POLYGON)] = &ga;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::MULTIPOINT)] = &gmp;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::MULTILINESTRING)] = &gml;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::MULTIPOLYGON)] = &gma;
gis_args[static_cast<int>(ObGeoCRS::Geographic)][static_cast<int>(ObGeoType::GEOMETRYCOLLECTION)] = &gc;
int result = 0;
int ret = OB_SUCCESS;
for (int crs_type = 1; crs_type < static_cast<int>(ObGeoCRS::Geographic) + 1; crs_type++) {
for (int g1_type = 1; g1_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g1_type++) {
gis_args[crs_type][g1_type]->set_data(dumy_wkb);
}
}
for (int crs_type = 1; crs_type < static_cast<int>(ObGeoCRS::Geographic) + 1; crs_type++) {
for (int g1_type = 1; g1_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g1_type++) {
gis_context.ut_set_geo_count(1);
gis_context.ut_set_geo_arg(0, gis_args[crs_type][g1_type]);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeY>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, g_test_geo_unary_func_result[crs_type][g1_type]);
}
}
for (int crs_type = 1; crs_type < static_cast<int>(ObGeoCRS::Geographic) + 1; crs_type++) {
for (int g1_type = 1; g1_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g1_type++) {
for (int g2_type = 1; g2_type < static_cast<int>(ObGeoType::GEOMETRYCOLLECTION) + 1; g2_type++) {
gis_context.ut_set_geo_count(2);
gis_context.ut_set_geo_arg(0, gis_args[crs_type][g1_type]);
gis_context.ut_set_geo_arg(1, gis_args[crs_type][g2_type]);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeY>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, g_test_geo_binary_func_result[crs_type][g1_type][crs_type][g2_type]);
}
}
}
}
TEST_F(TestGisDispatcher, specialization_and_exception_test)
{
ObIWkbGeomPoint cp;
ObIWkbGeomPolygon ca;
ObIWkbGeogPoint gp;
ObIWkbGeogLineString gl;
ObIWkbGeogPolygon ga;
ObIWkbGeogCollection gm;
ObString dumy_wkb(4, 4, "dumy");
cp.set_data(dumy_wkb);
ca.set_data(dumy_wkb);
gp.set_data(dumy_wkb);
gl.set_data(dumy_wkb);
ga.set_data(dumy_wkb);
gm.set_data(dumy_wkb);
int ret = OB_SUCCESS;
ObArenaAllocator allocator(ObModIds::TEST);
ObSrsItem srs(NULL);
ObGeoEvalCtx gis_context(&allocator, &srs);
ret = gis_context.append_geo_arg(&cp);
ASSERT_EQ(ret, OB_SUCCESS);
int result = 0;
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 1);
gis_context.ut_set_geo_arg(0, &ca);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 3);
gis_context.ut_set_geo_arg(0, &gp);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 1);
gis_context.ut_set_geo_arg(0, &ga);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 3);
gis_context.ut_set_geo_arg(0, &gm);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS);
ASSERT_EQ(result, 7);
gis_context.ut_set_geo_count(2);
gis_context.ut_set_geo_arg(0, &ca);
gis_context.ut_set_geo_arg(1, &ca);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 6);
gis_context.ut_set_geo_arg(0, &ga);
gis_context.ut_set_geo_arg(1, &ga);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 800);
gis_context.ut_set_geo_arg(0, &gm);
gis_context.ut_set_geo_arg(1, &gm);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_ERR_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS);
ASSERT_EQ(result, 14);
// test "functor" call "functor"
ObIWkbGeogMultiPoint gmp;
gmp.set_data(dumy_wkb);
gis_context.ut_set_geo_arg(0, &gmp);
gis_context.ut_set_geo_arg(1, &gmp);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 814);
gis_context.ut_set_geo_arg(0, &gp);
gis_context.ut_set_geo_arg(1, &gmp);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 100);
gis_context.ut_set_geo_arg(0, &gmp);
gis_context.ut_set_geo_arg(1, &gp);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, -100);
gis_context.ut_set_geo_arg(0, &gp);
gis_context.ut_set_geo_arg(1, &ga);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, -400);
gis_context.ut_set_geo_arg(0, &ga);
gis_context.ut_set_geo_arg(1, &gp);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(result, 400);
// exception test
gis_context.ut_set_geo_arg(0, &ga);
gis_context.ut_set_geo_arg(1, &gl);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_ERR_BOOST_GEOMETRY_CENTROID_EXCEPTION);
ASSERT_EQ(result, 777);
gis_context.ut_set_geo_arg(0, &gl);
gis_context.ut_set_geo_arg(1, &ga);
ret = ObGisTestFunc<ObGeoFuncTestType::TypeX>::geo_func::eval(gis_context, result);
ASSERT_EQ(ret, OB_ERR_BOOST_GEOMETRY_CENTROID_EXCEPTION);
ASSERT_EQ(result, 666);
}
} // namespace sql
} // namespace oceanbase
int main(int argc, char** argv)
{
::testing::InitGoogleTest(&argc, argv);
/*
system("rm -f test_gis_dispatcher.log");
OB_LOGGER.set_file_name("test_json_bin.log");
OB_LOGGER.set_log_level("INFO");
*/
return RUN_ALL_TESTS();
}