hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
7301597e49d5e72129c61bacbdd62fbde4149ef7
oceanbase/src/sql/engine/expr/ob_expr_xml_element.cpp

468 lines
20 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 is for func xmlelement.
*/
#define USING_LOG_PREFIX SQL_ENG
#include "ob_expr_xml_element.h"
#include "sql/engine/ob_exec_context.h"
#ifdef OB_BUILD_ORACLE_XML
#include "lib/xml/ob_xml_util.h"
#include "sql/engine/expr/ob_expr_xml_func_helper.h"
#endif
using namespace oceanbase::common;
using namespace oceanbase::sql;
namespace oceanbase
{
namespace sql
{
ObExprXmlElement::ObExprXmlElement(ObIAllocator &alloc)
: ObFuncExprOperator(alloc, T_FUN_SYS_XML_ELEMENT, N_XML_ELEMENT, MORE_THAN_ZERO, VALID_FOR_GENERATED_COL, NOT_ROW_DIMENSION)
{
}
ObExprXmlElement::~ObExprXmlElement()
{
}
int ObExprXmlElement::calc_result_typeN(ObExprResType& type,
ObExprResType* types_stack,
int64_t param_num,
ObExprTypeCtx& type_ctx) const
{
UNUSED(type_ctx);
int ret = OB_SUCCESS;
if (OB_UNLIKELY(param_num < 3)) {
ret = OB_ERR_PARAM_SIZE;
LOG_WARN("invalid param number", K(ret), K(param_num));
} else if (!is_called_in_sql()) {
ret = OB_ERR_SP_LILABEL_MISMATCH;
LOG_WARN("expr call in pl semantics disallowed", K(ret), K(N_XML_ELEMENT));
LOG_USER_ERROR(OB_ERR_SP_LILABEL_MISMATCH, static_cast<int>(strlen(N_XML_ELEMENT)), N_XML_ELEMENT);
} else {
// check opt_escaping
if (!ob_is_integer_type(types_stack[0].get_type())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid escaping opt type", K(ret), K(types_stack[0].get_type()));
} else {
for (int i = 2; i < param_num && OB_SUCC(ret); i++) {
const ObObjType obj_type = types_stack[i].get_type();
if (i == 2) {
if (ob_is_null(obj_type)) {
// do nothing
} else if (obj_type == ObNumberType) {
// do nothing
} else if (types_stack[i].get_collation_type() == CS_TYPE_BINARY) {
ret = OB_ERR_INVALID_XML_DATATYPE;
LOG_USER_ERROR(OB_ERR_INVALID_XML_DATATYPE, "Character", "-");
LOG_WARN("Unsupport for string typee with binary charset input.", K(ret), K(obj_type));
} else if (ob_is_string_tc(obj_type)) {
types_stack[i].set_calc_type(ObVarcharType);
types_stack[i].set_calc_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
} else {
ret = OB_ERR_INVALID_XML_DATATYPE;
LOG_USER_ERROR(OB_ERR_INVALID_XML_DATATYPE, "Character", "-");
LOG_WARN("Unsupport for string typee with binary charset input.", K(ret), K(obj_type));
}
} else if (i == 3 && ob_is_json(obj_type)) {
// do nothing, result from xmlAttributes
} else if (ob_is_string_type(obj_type)) {
if (types_stack[i].get_collation_type() == CS_TYPE_BINARY) {
types_stack[i].set_calc_collation_type(CS_TYPE_BINARY);
} else if (types_stack[i].get_charset_type() != CHARSET_UTF8MB4) {
types_stack[i].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
}
} else if (ObUserDefinedSQLType == types_stack[i].get_type()) { // xmltype
types_stack[i].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
} else if (ObExtendType == types_stack[i].get_type()) {
types_stack[i].set_calc_type(ObUserDefinedSQLType);
types_stack[i].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
} else {
types_stack[i].set_calc_type(ObVarcharType);
types_stack[i].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
}
}
}
}
if (OB_SUCC(ret)) {
type.set_sql_udt(ObXMLSqlType);
}
return ret;
}
#ifdef OB_BUILD_ORACLE_XML
int ObExprXmlElement::eval_xml_element(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res)
{
INIT_SUCC(ret);
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
ObDatum *datum = NULL;
int num_args = expr.arg_cnt_;
ObString name_tag;
int need_escape = 0;
int is_name = 0;
ObVector<ObObj, ElementObjCacheStatArena> value_vec;
const ObIJsonBase *attr_json = NULL;
ObString binary_str;
ObString blob_locator;
bool has_attribute = false;
ObXmlElement *element = NULL;
ObXmlDocument *res_doc = NULL;
ObMulModeMemCtx* mem_ctx = nullptr;
lib::ObMallocHookAttrGuard malloc_guard(lib::ObMemAttr(ObXMLExprHelper::get_tenant_id(ctx.exec_ctx_.get_my_session()), "XMLModule"));
if (OB_ISNULL(ctx.exec_ctx_.get_my_session())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get session failed.", K(ret));
} else if (OB_FAIL(ObXmlUtil::create_mulmode_tree_context(&tmp_allocator, mem_ctx))) {
LOG_WARN("fail to create tree memory context", K(ret));
} else if (OB_UNLIKELY(num_args < 3)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid args num", K(ret), K(num_args));
} else {
expr.args_[0]->eval(ctx, datum);
need_escape = datum->get_int();
expr.args_[1]->eval(ctx, datum);
is_name = datum->get_int();
if (need_escape != 0 && need_escape != 1) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid escaping opt", K(ret), K(need_escape));
} else if (need_escape == 0 && is_name == 0) {
ret = OB_ERR_XML_MISSING_COMMA;
LOG_WARN("xml element param invalid", K(ret));
} else if (OB_FAIL(expr.args_[2]->eval(ctx, datum))) {
LOG_WARN("expr args 1 failed", K(ret), K(expr.args_[2]));
} else if(expr.args_[2]->datum_meta_.type_ == ObNumberType) {
ret = OB_ERR_INVALID_XML_DATATYPE;
LOG_USER_ERROR(OB_ERR_INVALID_XML_DATATYPE, "Character", "-");
LOG_WARN("Unsupport for string typee with binary charset input.", K(ret), K(expr.args_[2]->datum_meta_.type_));
} else if (OB_FAIL(ObTextStringHelper::get_string(expr, tmp_allocator, 2, datum, name_tag))) {
LOG_WARN("get xml plain text failed", K(ret));
}
}
for (int i = 3; OB_SUCC(ret) && i < num_args && OB_SUCC(ret); i++) {
ObObjType val_type = expr.args_[i]->datum_meta_.type_;
ObItemType item_type = expr.args_[i]->type_;
if (OB_FAIL(expr.args_[i]->eval(ctx, datum))) {
LOG_WARN("expr args failed", K(ret), K(i));
} else if (ob_is_json(val_type) && i == 3) { // result from attribute
has_attribute = true;
void *buf = NULL;
if (OB_ISNULL(buf = tmp_allocator.alloc(sizeof(ObJsonBin)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("fail to alloc memory", K(ret), K(sizeof(ObJsonBin)));
} else {
ObJsonBin *j_bin = new (buf) ObJsonBin(datum->get_string().ptr(), datum->get_string().length(), &tmp_allocator);
attr_json = static_cast<const ObIJsonBase*>(j_bin);
if (OB_FAIL(j_bin->reset_iter())) {
LOG_WARN("fail to reset iter", K(ret));
} else if (attr_json->json_type() != ObJsonNodeType::J_ARRAY) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid json type", K(ret), K(attr_json->json_type()));
}
}
} else { // element value
ObString xml_value_data = datum->get_string();
ObExpr *xml_arg = expr.args_[i];
bool validity = false;
if (val_type == ObUserDefinedSQLType) { // xmltype
if (OB_FAIL(ObTextStringHelper::read_real_string_data(&tmp_allocator,
ObObjType::ObLongTextType,
xml_arg->datum_meta_.cs_type_,
true, xml_value_data))) {
LOG_WARN("fail to get real data.", K(ret), K(xml_value_data));
// } else if (OB_FAIL(ObXMLExprHelper::check_xml_document_unparsed(mem_ctx, xml_value_data, validity))) {
// LOG_WARN("check document unparsed failed", K(ret), K(xml_value_data));
// } else if (!validity) {
// ret = OB_ERR_XML_PARSE;
// LOG_WARN("input a unparsed document and parsing failed", K(ret), K(i), K(xml_value_data));
} else {
ObObj temp_value;
temp_value.set_string(ObUserDefinedSQLType, xml_value_data);
value_vec.push_back(temp_value);
}
} else if (OB_FAIL(ObTextStringHelper::read_real_string_data(tmp_allocator, *datum,
xml_arg->datum_meta_,
xml_arg->obj_meta_.has_lob_header(),
xml_value_data))) {
LOG_WARN("fail to get real data.", K(ret), K(xml_value_data));
} else if (expr.args_[i]->datum_meta_.cs_type_ == CS_TYPE_BINARY) { // binary
const ObObjMeta obj_meta = expr.args_[i]->obj_meta_;
ObObj obj;
ObObj tmp_result;
ObCastCtx cast_ctx(&tmp_allocator, NULL, CM_NONE, CS_TYPE_INVALID);
obj.set_string(ObVarcharType, xml_value_data);
if (OB_FAIL(ObHexUtils::rawtohex(obj, cast_ctx, tmp_result))) {
LOG_WARN("fail to check xml binary syntax", K(ret));
} else if (OB_FAIL(construct_value_array(tmp_allocator,
tmp_result.get_string(),
value_vec))) {
LOG_WARN("construct value array failed", K(ret));
}
} else { // varchar
if (need_escape) {
ObStringBuffer *escape_value = nullptr;
if (OB_ISNULL(escape_value = OB_NEWx(ObStringBuffer, &tmp_allocator, (&tmp_allocator)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("fail to allocate buffer", K(ret));
} else if (OB_FAIL(ObXmlParserUtils::escape_xml_text(xml_value_data, *escape_value))) {
LOG_WARN("escape xml value failed", K(ret), K(need_escape));
} else if (OB_FAIL(construct_value_array(tmp_allocator,
ObString(escape_value->length(), escape_value->ptr()),
value_vec))) {
LOG_WARN("construct value array failed", K(ret));
}
} else if (OB_FAIL(construct_value_array(tmp_allocator,
xml_value_data,
value_vec))) {
LOG_WARN("construct value array failed", K(ret));
}
}
}
}
ObStringBuffer tmp_buff(&tmp_allocator);
ObString text_xml;
ObXmlDocument *xml_doc = nullptr;
bool tag_validity = false;
bool doc_validity = true;
ObXmlText *tag_name_start;
ObXmlText *tag_name_end;
ObString start_tag("<>");
ObString end_tag("</>");
if (OB_FAIL(ret)) {
} else if (!has_attribute && name_tag.empty()) {
if (OB_ISNULL(tag_name_start = OB_NEWx(ObXmlText, mem_ctx->allocator_, ObMulModeNodeType::M_TEXT, mem_ctx))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("new xml text failed", K(ret));
} else if (OB_FALSE_IT(tag_name_start->set_text(start_tag))) {
} else if (OB_ISNULL(tag_name_end = OB_NEWx(ObXmlText, mem_ctx->allocator_, ObMulModeNodeType::M_TEXT, mem_ctx))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("new xml text failed", K(ret));
} else if (OB_FALSE_IT(tag_name_end->set_text(end_tag))) {
}
}
if (OB_FAIL(ret)) {
LOG_WARN("ret failed", K(ret));
} else if (OB_ISNULL(element = OB_NEWx(ObXmlElement, (mem_ctx->allocator_), ObMulModeNodeType::M_ELEMENT, mem_ctx))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate mem failed", K(ret));
} else if (!has_attribute && name_tag.empty() && OB_FAIL(element->add_element(tag_name_start))) {
LOG_WARN("element add start element failed", K(ret));
} else if (OB_FAIL(construct_element(mem_ctx, name_tag, value_vec, attr_json, element, tag_validity))) {
LOG_WARN("construct_element failed", K(ret));
} else if (!has_attribute && name_tag.empty() && OB_FAIL(element->add_element(tag_name_end))) {
LOG_WARN("element add end element failed", K(ret));
} else if (OB_ISNULL(res_doc = OB_NEWx(ObXmlDocument, (mem_ctx->allocator_), ObMulModeNodeType::M_UNPARSED, mem_ctx))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate mem failed", K(ret));
} else if (OB_FAIL(res_doc->add_element(element))) {
LOG_WARN("res doc add element failed", K(ret));
} else if (tag_validity && element->get_unparse() && OB_FAIL(ObXMLExprHelper::check_doc_validity(mem_ctx, res_doc, doc_validity))) { // && element.get_unparse()
LOG_WARN("check doc validity failed", K(ret), K(tag_validity));
} else if ((!tag_validity || !doc_validity)) {
res_doc->set_xml_type(ObMulModeNodeType::M_UNPARSED);
} else if (tag_validity && doc_validity) {
static_cast<ObXmlElement*>(res_doc->at(0))->set_unparse(0);
res_doc->set_xml_type(ObMulModeNodeType::M_DOCUMENT);
}
if (OB_FAIL(ret)) {
} else if (OB_ISNULL(res_doc)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN(" failed to pack result, as res_doc is nullptr", K(ret));
} else if (OB_FAIL(res_doc->get_raw_binary(binary_str, &tmp_allocator))) {
LOG_WARN("get raw binary failed", K(ret));
} else if (OB_FAIL(ObXMLExprHelper::pack_binary_res(expr, ctx, binary_str, blob_locator))) {
LOG_WARN("pack binary res failed", K(ret), K(binary_str));
} else {
res.set_string(blob_locator.ptr(), blob_locator.length());
}
return ret;
}
int ObExprXmlElement::construct_value_array(ObIAllocator &allocator, const ObString &value, ObVector<ObObj, ElementObjCacheStatArena> &res_value)
{
INIT_SUCC(ret);
if (value.empty()) {
// donothing
} else {
ObObj temp_value;
uint32_t vec_size = res_value.size();
if (res_value.size() == 0) {
temp_value.set_string(ObVarcharType, value);
} else {
if (res_value[vec_size - 1].get_type() == ObUserDefinedSQLType) {
temp_value.set_string(ObVarcharType, value);
} else {
char *new_value = NULL;
ObString temp_from = res_value[vec_size - 1].get_string();
if (OB_ISNULL(new_value = static_cast<char *>(allocator.alloc(temp_from.length() + value.length())))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("new value allocator failed", K(ret));
} else if (OB_FAIL(res_value.remove(res_value.last()))) {
LOG_WARN("res value remove failed", K(ret));
} else {
MEMCPY(new_value, temp_from.ptr(), temp_from.length());
MEMCPY(new_value + temp_from.length(), value.ptr(), value.length());
temp_value.set_string(ObVarcharType, new_value, temp_from.length() + value.length());
}
}
}
if (OB_SUCC(ret)) {
res_value.push_back(temp_value);
}
}
return ret;
}
int ObExprXmlElement::construct_attribute(ObMulModeMemCtx* mem_ctx, const ObIJsonBase *attr, ObXmlElement *&element)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(attr)) { // do nothing
} else if (attr->json_type() != ObJsonNodeType::J_ARRAY) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid json type", K(ret), K(attr->json_type()));
} else if (attr->element_count() % 2 != 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("attribute element count invalid", K(ret), K(attr->element_count()));
} else {
for (uint64_t i = 0; OB_SUCC(ret) && i < attr->element_count(); i += 2) {
ObIJsonBase *jb_name = NULL;
ObIJsonBase *jb_value = NULL;
ObString value_str = NULL;
ObString key_str = NULL;
ObXmlAttribute *attribute = NULL;
if (OB_FAIL(attr->get_array_element(i, jb_value))) {
LOG_WARN("get attribute value failed", K(ret), K(i));
} else if (OB_FAIL(attr->get_array_element(i + 1, jb_name))) {
LOG_WARN("get attribute name failed", K(ret), K(i));
} else if (OB_ISNULL(jb_name) || OB_ISNULL(jb_value)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("attribute name or value is null", K(ret), K(i), K(jb_name), K(jb_value));
} else if (jb_name->json_type() == ObJsonNodeType::J_NULL ||
jb_value->json_type() == ObJsonNodeType::J_NULL) {
LOG_DEBUG("name or content is null", K(jb_name->json_type()), K(jb_value->json_type()));
} else if (OB_FAIL(ob_write_string(*mem_ctx->allocator_, ObString(jb_value->get_data_length(), jb_value->get_data()), value_str, false))) {
LOG_WARN("write string value to string failed", K(ret), K(i), K(jb_name), K(jb_value));
} else if (OB_FAIL(ob_write_string(*mem_ctx->allocator_, ObString(jb_name->get_data_length(), jb_name->get_data()), key_str, false))) {
LOG_WARN("write string key to string failed", K(ret), K(i), K(jb_name), K(jb_value));
} else if (OB_FAIL(element->add_attr_by_str(key_str, value_str, ObMulModeNodeType::M_ATTRIBUTE))) {
LOG_WARN("add element failed", K(ret));
}
}
}
return ret;
}
int ObExprXmlElement::construct_element_children(ObMulModeMemCtx* mem_ctx,
ObVector<ObObj, ElementObjCacheStatArena> &value_vec,
ObXmlElement *&element,
ObXmlElement *valid_ele)
{
int ret = OB_SUCCESS;
ObXmlText *tag_value = NULL;
if (OB_ISNULL(element)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("element node is NULL", K(ret));
}
// build xml text
for (int i = 0; OB_SUCC(ret) && i < value_vec.size(); i++) {
ObObj value = value_vec[i];
ObIMulModeBase *node = NULL;
ObXmlDocument *doc_node = NULL;
if (value.get_type() == ObUserDefinedSQLType) {
if (OB_FAIL(ObXMLExprHelper::add_binary_to_element(mem_ctx, value.get_string(), *element))) {
LOG_WARN("add binary to element failed", K(ret), K(i));
}
} else {
if (OB_ISNULL(tag_value = OB_NEWx(ObXmlText, mem_ctx->allocator_, ObMulModeNodeType::M_TEXT, mem_ctx))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("new xml text failed", K(ret));
} else if (OB_FALSE_IT(tag_value->set_text(value.get_string()))) {
} else if (OB_FAIL(element->add_element(tag_value))) {
LOG_WARN("element add element failed", K(ret));
} else {
element->set_unparse(1);
}
}
}
// if the constructed element is not unparsed, use valid_ele to replace the element
if (!element->get_unparse()) {
if (OB_ISNULL(valid_ele)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("valid element is NULL, but validity is true", K(ret));
}
ObXmlNode *xml_node = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < element->size(); i++) {
if (OB_ISNULL(xml_node = element->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("xml node is NULL", K(ret));
} else if (OB_FAIL(valid_ele->add_element(xml_node))) {
LOG_WARN("fail to add element", K(ret));
}
} // end for
if (OB_SUCC(ret)) {
element = valid_ele;
}
}
return ret;
}
int ObExprXmlElement::construct_element(ObMulModeMemCtx* mem_ctx,
const ObString &name,
ObVector<ObObj, ElementObjCacheStatArena> &value_vec,
const ObIJsonBase *attr,
ObXmlElement *&element,
bool &validity)
{
INIT_SUCC(ret);
ObXmlElement *valid_ele = NULL;
if (OB_ISNULL(element)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("element node is NULL", K(ret));
} else if (OB_FAIL(element->init())) {
LOG_WARN("element init failed", K(ret));
} else if (FALSE_IT(element->set_key(name))) {
} else if (OB_FAIL(element->alter_member_sort_policy(false))) {
LOG_WARN("fail to sort child element", K(ret));
} else if (OB_FAIL(construct_attribute(mem_ctx, attr, element))) {
LOG_WARN("fail to construct attribute", K(ret));
} else if (OB_FAIL(ObXMLExprHelper::check_element_validity(mem_ctx, element, valid_ele, validity))) {
LOG_WARN("check element validity failed", K(ret));
} else if (OB_FAIL(construct_element_children(mem_ctx, value_vec, element, valid_ele))) {
LOG_WARN("fail to construct element chidren", K(ret));
}
// set sort flag
if (OB_SUCC(ret) && OB_FAIL(element->alter_member_sort_policy(true))) {
LOG_WARN("fail to sort child element", K(ret));
}
return ret;
}
#endif
int ObExprXmlElement::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_xml_element;
return OB_SUCCESS;
}
}
}
Reference in New Issue View Git Blame Copy Permalink