/**

* 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.

*/

#define USING_LOG_PREFIX SQL

#include "sql/ob_dml_stmt_printer.h"

#include "sql/ob_select_stmt_printer.h"

#include "sql/ob_sql_context.h"

#include "sql/resolver/dml/ob_del_upd_stmt.h"

#include "common/ob_smart_call.h"

#include "lib/charset/ob_charset.h"

#include "sql/optimizer/ob_log_plan.h"

#include "sql/monitor/ob_sql_plan.h"

namespace oceanbase

{

using namespace common;

namespace sql

{

ObDMLStmtPrinter::ObDMLStmtPrinter(char *buf, int64_t buf_len, int64_t *pos, const ObDMLStmt *stmt,

ObSchemaGetterGuard *schema_guard,

ObObjPrintParams print_params,

const ParamStore *param_store)

: buf_(buf),

buf_len_(buf_len),

pos_(pos),

stmt_(stmt),

is_root_(false),

is_first_stmt_for_hint_(false),

print_cte_(false),

schema_guard_(schema_guard),

print_params_(print_params),

expr_printer_(buf, buf_len, pos, schema_guard_, print_params_, param_store),

param_store_(param_store)

{

}

ObDMLStmtPrinter::~ObDMLStmtPrinter()

{

}

void ObDMLStmtPrinter::init(char *buf, int64_t buf_len, int64_t *pos, ObDMLStmt *stmt)

{

buf_ = buf;

buf_len_ = buf_len;

pos_ = pos;

stmt_ = stmt;

print_cte_ = false;

}

int ObDMLStmtPrinter::set_synonym_name_recursively(ObRawExpr * cur_expr, const ObDMLStmt *stmt)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(cur_expr) || OB_ISNULL(stmt)) {

} else if (cur_expr->is_column_ref_expr()) {

ObColumnRefRawExpr *column_expr = static_cast<ObColumnRefRawExpr *>(cur_expr);

const TableItem *table_item = stmt->get_table_item_by_id(column_expr->get_table_id());

if (NULL != table_item && table_item->alias_name_.empty()) {

column_expr->set_synonym_name(table_item->synonym_name_);

column_expr->set_synonym_db_name(table_item->synonym_db_name_);

}

} else if (cur_expr->get_param_count() > 0) {

for (int64_t param_idx = 0; param_idx < cur_expr->get_param_count(); ++param_idx) {

ObRawExpr * param_expr = cur_expr->get_param_expr(param_idx);

OZ (SMART_CALL(set_synonym_name_recursively(param_expr, stmt)));

}

} else {

//do nothing

}

return ret;

}

int ObDMLStmtPrinter::print_hint()

{

int ret = OB_SUCCESS;

if (OB_ISNULL(stmt_) || OB_ISNULL(stmt_->get_query_ctx()) || OB_ISNULL(buf_) || OB_ISNULL(pos_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("stmt_ is NULL or buf_ is NULL or pos_ is NULL", K(ret));

} else {

const char *hint_begin = "/*+";

const char *hint_end = " */";

DATA_PRINTF("%s", hint_begin);

if (OB_SUCC(ret)) {

const ObQueryHint &query_hint = stmt_->get_query_ctx()->get_query_hint();

PlanText plan_text;

plan_text.buf_ = buf_;

plan_text.buf_len_ = buf_len_;

plan_text.pos_ = *pos_;

plan_text.is_oneline_ = true;

plan_text.type_ = print_params_.for_dblink_

? EXPLAIN_DBLINK_STMT

: EXPLAIN_UNINITIALIZED; // just for print hint, ExplainType set as invalid type

if (OB_FAIL(query_hint.print_stmt_hint(plan_text, *stmt_, is_first_stmt_for_hint_))) {

LOG_WARN("failed to print stmt hint", K(ret));

} else if (plan_text.pos_ == *pos_) {

// no hint, roolback buffer!

*pos_ -= strlen(hint_begin);

} else {

*pos_ = plan_text.pos_;

DATA_PRINTF("%s", hint_end);

}

}

}

return ret;

}

int ObDMLStmtPrinter::print_from(bool need_from)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(stmt_) || OB_ISNULL(buf_) || OB_ISNULL(pos_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("stmt_ is NULL or buf_ is NULL or pos_ is NULL", K(ret));

} else {

int64_t from_item_size = stmt_->get_from_item_size();

if (from_item_size > 0) {

if (need_from) {

DATA_PRINTF(" from ");

}

for (int64_t i = 0; OB_SUCC(ret) && i < from_item_size; ++i) {

const FromItem &from_item = stmt_->get_from_item(i);

const TableItem *table_item = NULL;

if (from_item.is_joined_) {

table_item = stmt_->get_joined_table(from_item.table_id_);

} else {

table_item = stmt_->get_table_item_by_id(from_item.table_id_);

}

if (OB_ISNULL(table_item)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("table_item should not be NULL", K(ret));

} else if (OB_FAIL(print_table(table_item))) {

LOG_WARN("fail to print table", K(ret), K(*table_item));

} else {

DATA_PRINTF(",");

}

}

if (OB_SUCC(ret)) {

--*pos_;

}

} else if (0 != stmt_->get_condition_exprs().count()) {

// create view v as select 1 from dual where 1;

DATA_PRINTF(" from DUAL");

} else if (lib::is_oracle_mode() && 0 == from_item_size) {

// select 1 from dual

// in oracle mode

DATA_PRINTF(" from DUAL");

}

if (OB_SUCC(ret) && !print_params_.for_dblink_) {

if (OB_FAIL(print_semi_join())) {

LOG_WARN("failed to print semi info", K(ret));

}

}

}

return ret;

}

int ObDMLStmtPrinter::print_table_with_subquery(const TableItem *table_item)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(table_item) ||

OB_ISNULL(table_item->ref_query_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected null", K(ret));

} else {

// force print alias name for select item in generated table. Otherwise,

// create view v as select 1 from dual where 1 > (select `abs(c1)` from (select abs(c1) from t));

// Definition of v would be:

// CREATE VIEW `v` AS select 1 AS `1` from DUAL where (1 > (select `abs(c1)` from ((select abs(`test`.`t`.`c1`) from `test`.`t`)) ))

// `abs(c1)` would be an unknown column.

const uint64_t subquery_print_params =

PRINT_BRACKET |

(stmt_->is_select_stmt() ? FORCE_COL_ALIAS : 0);

if (OB_FAIL(print_subquery(table_item->ref_query_,

subquery_print_params))) {

LOG_WARN("failed to print subquery", K(ret));

} else if (!table_item->alias_name_.empty()) {

DATA_PRINTF(" ");

PRINT_IDENT_WITH_QUOT(table_item->alias_name_);

} else {

DATA_PRINTF(" ");

PRINT_TABLE_NAME(print_params_, table_item);

}

}

return ret;

}

int ObDMLStmtPrinter::print_table(const TableItem *table_item,

bool no_print_alias/*default false*/)

{

int ret = OB_SUCCESS;

bool is_stack_overflow = false;

if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {

LOG_WARN("failed to check stack overflow", K(ret), K(is_stack_overflow));

} else if (is_stack_overflow) {

ret = OB_SIZE_OVERFLOW;

LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));

} else if (OB_ISNULL(stmt_) || OB_ISNULL(buf_) || OB_ISNULL(pos_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("stmt_ is NULL or buf_ is NULL or pos_ is NULL", K(ret));

} else {

switch (table_item->type_) {

case TableItem::LINK_TABLE: {

if (OB_FAIL(print_base_table(table_item))) {

LOG_WARN("failed to print base table", K(ret), K(*table_item));

} else if (!no_print_alias && !table_item->alias_name_.empty()) {

DATA_PRINTF(lib::is_oracle_mode() ? " \"%.*s\"" : " `%.*s`",

LEN_AND_PTR(table_item->alias_name_));

}

break;

}

case TableItem::BASE_TABLE: {

if (OB_FAIL(print_base_table(table_item))) {

LOG_WARN("failed to print base table", K(ret), K(*table_item));

} else if (!no_print_alias && !table_item->alias_name_.empty()) {

DATA_PRINTF(lib::is_oracle_mode() ? " \"%.*s\"" : " `%.*s`",

LEN_AND_PTR(table_item->alias_name_));

}

break;

}

case TableItem::ALIAS_TABLE: {

if (OB_FAIL(print_base_table(table_item))) {

LOG_WARN("failed to print base table", K(ret), K(*table_item));

//table in insert all can't print alias(bug:

} else if (!no_print_alias) {

DATA_PRINTF(" ");

PRINT_IDENT_WITH_QUOT(table_item->alias_name_);

}

break;

}

case TableItem::JOINED_TABLE: {

const JoinedTable *join_table = static_cast<const JoinedTable*>(table_item);

if (OB_ISNULL(join_table)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("join_table should not be NULL", K(ret));

} else {

// left table

const TableItem *left_table = join_table->left_table_;

if (OB_ISNULL(left_table)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("left_table should not be NULL", K(ret));

} else {

DATA_PRINTF("(");

if (OB_SUCC(ret)) {

if (OB_FAIL(SMART_CALL(print_table(left_table)))) {

LOG_WARN("fail to print left table", K(ret), K(*left_table));

}

}

// join type

if (OB_SUCC(ret)) {

// not support cross join and natural join

ObString type_str("");

switch (join_table->joined_type_) {

case FULL_OUTER_JOIN: {

type_str = "full join";

break;

}

case LEFT_OUTER_JOIN: {

type_str = "left join";

break;

}

case RIGHT_OUTER_JOIN: {

type_str = "right join";

break;

}

case INNER_JOIN: {

type_str = "join";

break;

}

case CONNECT_BY_JOIN: {

type_str = "connect by join";

break;

}

default: {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unknown join type", K(ret), K(join_table->joined_type_));

break;

}

}

DATA_PRINTF(" %.*s ", LEN_AND_PTR(type_str));

}

// right table

if (OB_SUCC(ret)) {

const TableItem *right_table = join_table->right_table_;

if (OB_ISNULL(right_table)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("right_table should not be NULL", K(ret));

} else if (OB_FAIL(SMART_CALL(print_table(right_table)))) {

LOG_WARN("fail to print right table", K(ret), K(*right_table));

} else {

// join conditions

const ObIArray<ObRawExpr*> &join_conditions =

join_table->join_conditions_;

int64_t join_conditions_size = join_conditions.count();

if (join_conditions_size > 0) {

DATA_PRINTF(" on ");

for (int64_t i = 0; OB_SUCC(ret) && i < join_conditions_size;

++i) {

if (OB_FAIL(expr_printer_.do_print(join_conditions.at(i), T_NONE_SCOPE))) {

LOG_WARN("fail to print join condition", K(ret));

}

DATA_PRINTF(" and ");

}

if (OB_SUCC(ret)) {

*pos_ -= 5; // strlen(" and ")

}

} else {

DATA_PRINTF(" on 1=1 ");

}

DATA_PRINTF(")");

}

}

}

}

break;

}

case TableItem::GENERATED_TABLE: {

if (OB_ISNULL(table_item->ref_query_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("table item ref query is null", K(ret));

// generated_table cannot appear in view_definition

// view在resolver阶段被转换为生成表, 需要当做基表处理

} else if (table_item->is_view_table_ && !print_params_.for_dblink_) {

PRINT_TABLE_NAME(print_params_, table_item);

if (OB_SUCC(ret)) {

if (table_item->alias_name_.length() > 0) {

DATA_PRINTF(" %.*s", LEN_AND_PTR(table_item->alias_name_));

}

}

} else if (table_item->cte_type_ != TableItem::NOT_CTE && !print_params_.for_dblink_) {

PRINT_TABLE_NAME(print_params_, table_item);

if (table_item->alias_name_.length() > 0) {

DATA_PRINTF(" %.*s", LEN_AND_PTR(table_item->alias_name_));

}

} else if (OB_FAIL(print_table_with_subquery(table_item))) {

LOG_WARN("failed to print table with subquery", K(ret));

}

break;

}

case TableItem::CTE_TABLE: {

PRINT_TABLE_NAME(print_params_, table_item);

if (! table_item->alias_name_.empty()) {

DATA_PRINTF(" ");

PRINT_IDENT_WITH_QUOT(table_item->alias_name_);

}

break;

}

case TableItem::FUNCTION_TABLE: {

DATA_PRINTF("TABLE(");

OZ (expr_printer_.do_print(table_item->function_table_expr_, T_FROM_SCOPE));

DATA_PRINTF(") ");

PRINT_IDENT_WITH_QUOT(table_item->alias_name_);

break;

}

case TableItem::JSON_TABLE: {

DATA_PRINTF("JSON_TABLE(");

OZ (expr_printer_.do_print(table_item->json_table_def_->doc_expr_, T_FROM_SCOPE));

OZ (print_json_table(table_item));

DATA_PRINTF(")");

DATA_PRINTF(" %.*s", LEN_AND_PTR(table_item->alias_name_));

break;

}

case TableItem::TEMP_TABLE: {

if (!print_params_.for_dblink_) {

PRINT_TABLE_NAME(print_params_, table_item);

if (!table_item->alias_name_.empty()) {

DATA_PRINTF(" ");

PRINT_IDENT_WITH_QUOT(table_item->alias_name_);

}

} else if (OB_FAIL(print_table_with_subquery(table_item))) {

LOG_WARN("failed to print table with subquery", K(ret));

}

break;

}

case TableItem::VALUES_TABLE: {

int64_t column_cnt = stmt_->get_column_size(table_item->table_id_);

const ObIArray<ObRawExpr *> &values = table_item->table_values_;

if (OB_UNLIKELY(column_cnt <= 0 || values.empty() || values.count() % column_cnt != 0)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("get unexpected error", K(ret), K(column_cnt), K(values));

} else {

DATA_PRINTF("(VALUES ");

for (int64_t i = 0; OB_SUCC(ret) && i < values.count(); ++i) {

if (i % column_cnt == 0) {

if (i == 0) {

DATA_PRINTF("ROW(");

} else {

DATA_PRINTF("), ROW(");

}

}

if (OB_SUCC(ret)) {

OZ (expr_printer_.do_print(values.at(i), T_FROM_SCOPE));

if (OB_SUCC(ret) && (i + 1) % column_cnt != 0) {

DATA_PRINTF(", ");

}

}

}

DATA_PRINTF("))");

DATA_PRINTF(" %.*s", LEN_AND_PTR(table_item->alias_name_));

}

break;

}

default: {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unknown table type", K(ret), K(table_item->type_));

break;

}

}

}

return ret;

}

int ObDMLStmtPrinter::print_json_return_type(int64_t value, ObDataType data_type)

{

int ret = OB_SUCCESS;

if (lib::is_mysql_mode()) {

if (OB_FAIL(print_mysql_json_return_type(value, data_type))) {

LOG_WARN("fail to print json table column in mysql mode", K(ret));

}

} else {

ParseNode parse_node;

parse_node.value_ = value;

int16_t cast_type = parse_node.int16_values_[OB_NODE_CAST_TYPE_IDX];

const ObLengthSemantics length_semantics = data_type.get_length_semantics();

const ObScale scale = data_type.get_scale();

switch (cast_type) {

case T_CHAR: {

int16_t collation = parse_node.int16_values_[OB_NODE_CAST_COLL_IDX];

int32_t len = parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX];

DATA_PRINTF("char(%d %s)", len, get_length_semantics_str(length_semantics));

break;

}

case T_VARCHAR: {

int16_t collation = parse_node.int16_values_[OB_NODE_CAST_COLL_IDX];

int32_t len = parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX];

const int32_t DEFAULT_VARCHAR_LEN = 4000;

if (BINARY_COLLATION == collation) {

DATA_PRINTF("varbinary(%d)", len);

} else {

// CHARACTER

if (len == DEFAULT_VARCHAR_LEN) {

break;

} else if (length_semantics == LS_BYTE && len == -1) {

DATA_PRINTF(" VARCHAR2");

break;

} else {

DATA_PRINTF("varchar2(%d %s)", len, get_length_semantics_str(length_semantics));

}

}

break;

}

case T_NVARCHAR2: {

DATA_PRINTF("nvarchar2(%d)", parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX]);

break;

}

case T_NCHAR: {

DATA_PRINTF("nchar(%d)", parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX]);

break;

}

case T_DATETIME: {

//oracle mode treats date as datetime

DATA_PRINTF("date");

break;

}

case T_DATE: {

DATA_PRINTF("date");

break;

}

case T_TIME: {

int16_t scale = parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX];

if (scale >= 0) {

DATA_PRINTF("time(%d)", scale);

} else {

DATA_PRINTF("time");

}

break;

}

case T_NUMBER: {

int16_t precision = parse_node.int16_values_[OB_NODE_CAST_N_PREC_IDX];

int16_t scale = parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX];

DATA_PRINTF("number(%d,%d)", precision, scale);

break;

}

case T_NUMBER_FLOAT: {

int16_t precision = parse_node.int16_values_[OB_NODE_CAST_N_PREC_IDX];

DATA_PRINTF("float(%d)", precision);

break;

}

case T_TINYINT:

case T_SMALLINT:

case T_MEDIUMINT:

case T_INT32:

case T_INT: {

DATA_PRINTF("signed");

break;

}

case T_UTINYINT:

case T_USMALLINT:

case T_UMEDIUMINT:

case T_UINT32:

case T_UINT64: {

DATA_PRINTF("unsigned");

break;

}

case T_INTERVAL_YM: {

int year_scale = ObIntervalScaleUtil::ob_scale_to_interval_ym_year_scale(static_cast<int8_t>(scale));

DATA_PRINTF("interval year(%d) to month", year_scale);

break;

}

case T_INTERVAL_DS: {

int day_scale = ObIntervalScaleUtil::ob_scale_to_interval_ds_day_scale(static_cast<int8_t>(scale));

int fs_scale = ObIntervalScaleUtil::ob_scale_to_interval_ds_second_scale(static_cast<int8_t>(scale));

DATA_PRINTF("interval day(%d) to second(%d)", day_scale, fs_scale);

break;

}

case T_TIMESTAMP_TZ: {

int16_t scale = parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX];

if (scale >= 0) {

DATA_PRINTF("timestamp(%d) with time zone", scale);

} else {

DATA_PRINTF("timestamp with time zone");

}

break;

}

case T_TIMESTAMP_LTZ: {

int16_t scale = parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX];

if (scale >= 0) {

DATA_PRINTF("timestamp(%d) with local time zone", scale);

} else {

DATA_PRINTF("timestamp with local time zone");

}

break;

}

case T_TIMESTAMP_NANO: {

int16_t scale = parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX];

if (scale >= 0) {

DATA_PRINTF("timestamp(%d)", scale);

} else {

DATA_PRINTF("timestamp");

}

break;

}

case T_RAW: {

int32_t len = parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX];

DATA_PRINTF("raw(%d)", len);

break;

}

case T_FLOAT: {

const char *type_str = lib::is_oracle_mode() ? "binary_float" : "float";

DATA_PRINTF("%s", type_str);

break;

}

case T_DOUBLE: {

const char *type_str = lib::is_oracle_mode() ? "binary_double" : "double";

DATA_PRINTF("%s", type_str);

break;

}

case T_UROWID: {

DATA_PRINTF("urowid(%d)", parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX]);

break;

}

case T_LOB: {

int16_t collation = parse_node.int16_values_[OB_NODE_CAST_COLL_IDX];

if (BINARY_COLLATION == collation) {

DATA_PRINTF("blob");

} else {

DATA_PRINTF("clob");

}

break;

}

case T_JSON: {

DATA_PRINTF("json");

break;

}

case T_LONGTEXT: {

int16_t collation = parse_node.int16_values_[OB_NODE_CAST_COLL_IDX];

if (BINARY_COLLATION == collation) {

DATA_PRINTF("blob");

} else {

DATA_PRINTF("clob");

}

break;

}

default: {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unknown cast type", K(ret), K(cast_type));

break;

}

} // end switch

} // oracle mode

return ret;

}

int ObDMLStmtPrinter::print_binary_charset_collation(int64_t value, ObDataType data_type)

{

INIT_SUCC(ret);

if (data_type.is_binary_collation()) {

DATA_PRINTF("binary ");

}

if (CHARSET_INVALID != data_type.get_charset_type()) {

DATA_PRINTF("CHARACTER SET %s ", ObCharset::charset_name(data_type.get_charset_type()));

}

if (CS_TYPE_INVALID != data_type.get_collation_type()) {

DATA_PRINTF("COLLATE %s ", ObCharset::collation_name(data_type.get_collation_type()));

}

return ret;

}

int ObDMLStmtPrinter::print_mysql_json_return_type(int64_t value, ObDataType data_type)

{

int ret = OB_SUCCESS;

ParseNode parse_node;

parse_node.value_ = value;

int16_t cast_type = data_type.get_obj_type();

const ObLengthSemantics length_semantics = data_type.get_length_semantics();

const ObScale scale = data_type.get_scale();

switch (cast_type) {

case T_CHAR: {

int32_t len = parse_node.int32_values_[0];

int32_t collation = parse_node.int32_values_[1];

if (1 == collation) {

DATA_PRINTF("binary(%d)", len);

} else {

DATA_PRINTF("char(%d) ", len);

if (OB_FAIL(ret)) {

} else if (OB_FAIL(print_binary_charset_collation(value, data_type))) {

LOG_WARN("fail to print binary,charset,collection clause", K(ret));

}

}

break;

}

case T_VARCHAR: {

int32_t collation = parse_node.int32_values_[1];

int32_t len = parse_node.int32_values_[0];

const int32_t DEFAULT_VARCHAR_LEN = 4000;

if (1 == collation) {

DATA_PRINTF("varbinary(%d) ", len);

} else {

DATA_PRINTF("varchar(%d) ", len);

if (OB_SUCC(ret) && OB_FAIL(print_binary_charset_collation(value, data_type))) {

LOG_WARN("fail to print binary,charset,collection clause", K(ret));

}

}

break;

}

case T_BIT: {

int32_t len = parse_node.int16_values_[0];

DATA_PRINTF("bit(%d) ", len);

break;

}

case T_TINYTEXT: {

int16_t collation = parse_node.int32_values_[1];

if (1 == collation) {

DATA_PRINTF("TINYBLOB ");

} else {

DATA_PRINTF("TINYTEXT ");

}

if (OB_SUCC(ret) && !collation && OB_FAIL(print_binary_charset_collation(value, data_type))) {

LOG_WARN("fail to print binary,charset,collection clause", K(ret));

}

break;

}

case T_TEXT: {

int16_t collation = parse_node.int32_values_[1];

if (1 == collation) {

DATA_PRINTF("BLOB ");

} else {

DATA_PRINTF("TEXT ");

}

if (OB_SUCC(ret) && !collation && OB_FAIL(print_binary_charset_collation(value, data_type))) {

LOG_WARN("fail to print binary,charset,collection clause", K(ret));

}

break;

}

case T_MEDIUMTEXT: {

int16_t collation = parse_node.int32_values_[1];

if (1 == collation) {

DATA_PRINTF("MEDIUMBLOB ");

} else {

DATA_PRINTF("MEDIUMTEXT ");

}

if (OB_SUCC(ret) && !collation && OB_FAIL(print_binary_charset_collation(value, data_type))) {

LOG_WARN("fail to print binary,charset,collection clause", K(ret));

}

break;

}

case T_LONGTEXT: {

int16_t collation = parse_node.int32_values_[1];

if (1 == collation) {

DATA_PRINTF("LONGBLOB ");

} else {

DATA_PRINTF("LONGTEXT ");

}

if (OB_SUCC(ret) && !collation && OB_FAIL(print_binary_charset_collation(value, data_type))) {

LOG_WARN("fail to print binary,charset,collection clause", K(ret));

}

break;

}

case T_DATETIME: {

int16_t scale = parse_node.int16_values_[1];

if (scale >= 0) {

DATA_PRINTF("datetime(%d) ", scale);

} else {

DATA_PRINTF("datetime ");

}

break;

}

case T_DATE: {

DATA_PRINTF("date ");

break;

}

case T_YEAR: {

DATA_PRINTF("year ");

break;

}

case T_TIMESTAMP: {

int16_t scale = parse_node.int16_values_[1];

if (scale >= 0) {

DATA_PRINTF("timestamp(%d) ", scale);

} else {

DATA_PRINTF("timestamp ");

}

break;

}

case T_TIME: {

int16_t scale = parse_node.int16_values_[1];

if (scale >= 0) {

DATA_PRINTF("time(%d) ", scale);

} else {

DATA_PRINTF("time ");

}

break;

}

case T_NUMBER: { // number, decimal, fixed, numeric

int16_t precision = parse_node.int16_values_[OB_NODE_CAST_N_PREC_IDX];

int16_t scale = parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX];

DATA_PRINTF("DECIMAL(%d,%d) ", precision, scale);

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_TINYINT: {

if (parse_node.int16_values_[OB_NODE_CAST_COLL_IDX] == 1) {

DATA_PRINTF("BOOL ");

} else if (parse_node.int16_values_[OB_NODE_CAST_COLL_IDX] == 2) {

DATA_PRINTF("BOOLEAN ");

} else {

DATA_PRINTF("TINYINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_SMALLINT: {

DATA_PRINTF("SMALLINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_MEDIUMINT: {

DATA_PRINTF("MEDIUMINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_INT32: {

DATA_PRINTF("INTEGER ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_INT: {

DATA_PRINTF("BIGINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_UTINYINT: {

DATA_PRINTF("TINYINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_USMALLINT:{

DATA_PRINTF("SMALLINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_UMEDIUMINT:{

DATA_PRINTF("MEDIUMINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_UINT32: {

DATA_PRINTF("INTEGER ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_UINT64: {

DATA_PRINTF("BIGINT ");

if (OB_SUCC(ret) && parse_node.int16_values_[0] != -1){

DATA_PRINTF("(%d)", parse_node.int16_values_[0]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_INTERVAL_YM: {

int year_scale = ObIntervalScaleUtil::ob_scale_to_interval_ym_year_scale(static_cast<int8_t>(scale));

DATA_PRINTF("interval year(%d) to month", year_scale);

break;

}

case T_INTERVAL_DS: {

int day_scale = ObIntervalScaleUtil::ob_scale_to_interval_ds_day_scale(static_cast<int8_t>(scale));

int fs_scale = ObIntervalScaleUtil::ob_scale_to_interval_ds_second_scale(static_cast<int8_t>(scale));

DATA_PRINTF("interval day(%d) to second(%d)", day_scale, fs_scale);

break;

}

case T_FLOAT: {

DATA_PRINTF("FLOAT ");

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[0] <= 0) {

} else {

DATA_PRINTF("(%d,%d) ", parse_node.int16_values_[0], parse_node.int16_values_[1]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_DOUBLE: {

DATA_PRINTF("DOUBLE ");

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[0] <= 0) {

} else {

DATA_PRINTF("(%d,%d) ", parse_node.int16_values_[0], parse_node.int16_values_[1]);

}

if (OB_FAIL(ret)) {

} else if (parse_node.int16_values_[3]) {

DATA_PRINTF("UNSIGNED ");

} else {

DATA_PRINTF("SIGNED ");

}

if (OB_SUCC(ret) && parse_node.int16_values_[2]) {

DATA_PRINTF("ZEROFILL ");

}

break;

}

case T_JSON: {

DATA_PRINTF("json ");

break;

}

case T_GEOMETRY: {

int32_t flag = parse_node.int32_values_[1];

if (flag == 0) {

DATA_PRINTF("GEOMETRY ");

} else if (flag == 1) {

DATA_PRINTF("POINT ");

} else if (flag == 2) {

DATA_PRINTF("LINESTRING ");

} else if (flag == 3) {

DATA_PRINTF("POLYGON ");

} else if (flag == 4) {

DATA_PRINTF("MULTIPOINT ");

} else if (flag == 5) {

DATA_PRINTF("MULTILINESTRING ");

} else if (flag == 6) {

DATA_PRINTF("MULTIPOLYGON ");

} else if (flag == 7) {

DATA_PRINTF("GEOMETRYCOLLECTION ");

}

break;

}

default: {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unknown cast type", K(ret), K(cast_type));

break;

}

} // end switch

return ret;

}

int ObDMLStmtPrinter::get_json_table_column_if_exists(int32_t id, ObDmlJtColDef* root, ObDmlJtColDef*& col)

{

INIT_SUCC(ret);

common::ObArray<ObDmlJtColDef*> col_stack;

if (OB_FAIL(col_stack.push_back(root))) {

LOG_WARN("fail to store col node tmp", K(ret));

}

bool exists = false;

while (OB_SUCC(ret) && !exists && col_stack.count() > 0) {

ObDmlJtColDef* cur_col = col_stack.at(col_stack.count() - 1);

if (OB_ISNULL(cur_col)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("current column info is null", K(ret));

} else if (cur_col->col_base_info_.id_ == id) {

exists = true;

col = cur_col;

} else if (cur_col->col_base_info_.parent_id_ < 0

|| cur_col->col_base_info_.col_type_ == static_cast<int32_t>(NESTED_COL_TYPE)) {