init push
This commit is contained in:
oceanbase-admin
997
src/sql/ob_select_stmt_printer.cpp
Normal file
997
src/sql/ob_select_stmt_printer.cpp
Normal file
@ -0,0 +1,997 @@
|
||||
/**
|
||||
* 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_select_stmt_printer.h"
|
||||
#include "sql/ob_sql_context.h"
|
||||
#include "sql/resolver/expr/ob_raw_expr_util.h"
|
||||
#include "sql/resolver/expr/ob_raw_expr.h"
|
||||
#include "lib/allocator/page_arena.h"
|
||||
namespace oceanbase {
|
||||
using namespace common;
|
||||
namespace sql {
|
||||
|
||||
void ObSelectStmtPrinter::init(
|
||||
char* buf, int64_t buf_len, int64_t* pos, ObSelectStmt* stmt, ObIArray<ObString>* column_list, bool is_set_subquery)
|
||||
{
|
||||
ObDMLStmtPrinter::init(buf, buf_len, pos, stmt);
|
||||
column_list_ = column_list;
|
||||
is_set_subquery_ = is_set_subquery;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::do_print()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
|
||||
if (OB_UNLIKELY(!is_inited_)) {
|
||||
ret = OB_NOT_INIT;
|
||||
LOG_WARN("not inited!", K(ret));
|
||||
} else if (OB_ISNULL(stmt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("stmt should not be NULL", K(ret));
|
||||
} else if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
if (OB_UNLIKELY(NULL != column_list_ && column_list_->count() != select_stmt->get_select_item_size())) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("column_list size should be equal select_item size",
|
||||
K(ret),
|
||||
K(column_list_->count()),
|
||||
K(select_stmt->get_select_item_size()));
|
||||
} else {
|
||||
expr_printer_.init(buf_, buf_len_, pos_, print_params_);
|
||||
if (stmt_->is_unpivot_select()) {
|
||||
if (OB_FAIL(print_unpivot())) {
|
||||
LOG_WARN("fail to print_unpivot", KPC(stmt_->get_transpose_item()), K(ret));
|
||||
}
|
||||
} else if (OB_FAIL(print())) {
|
||||
LOG_WARN("fail to print stmt", KPC(stmt_), K(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
|
||||
if (OB_ISNULL(stmt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("stmt_ should not be NULL", K(ret));
|
||||
} else if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
if (!select_stmt->is_root_stmt() || is_set_subquery_) {
|
||||
DATA_PRINTF("(");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
if (select_stmt->get_generated_cte_count() != 0 && OB_FAIL(print_with())) {
|
||||
LOG_WARN("print with failed");
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
if (select_stmt->has_set_op()) {
|
||||
// union, intersect, except
|
||||
if (OB_FAIL(print_set_op_stmt())) {
|
||||
LOG_WARN("fail to print set_op stmt", K(ret), K(*stmt_));
|
||||
}
|
||||
} else if (OB_FAIL(print_basic_stmt())) {
|
||||
LOG_WARN("fail to print basic stmt", K(ret), K(*stmt_));
|
||||
}
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (!select_stmt->is_root_stmt() || is_set_subquery_) {
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_unpivot()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(stmt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("stmt_ should not be NULL", K(ret));
|
||||
} else if (OB_UNLIKELY(!stmt_->is_select_stmt()) || OB_UNLIKELY(!stmt_->is_unpivot_select()) ||
|
||||
OB_UNLIKELY(stmt_->get_table_items().count() != 1) || OB_ISNULL(stmt_->get_table_item(0)->ref_query_) ||
|
||||
OB_UNLIKELY(stmt_->get_table_item(0)->ref_query_->get_table_items().count() != 1)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(stmt_->get_table_items().count()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
if (!select_stmt->is_root_stmt()) {
|
||||
DATA_PRINTF("(");
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(print_select())) {
|
||||
LOG_WARN("fail to print select", K(ret), K(*stmt_));
|
||||
}
|
||||
}
|
||||
|
||||
DATA_PRINTF(" FROM ");
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(print_table(stmt_->get_table_item(0)->ref_query_->get_table_item(0)))) {
|
||||
LOG_WARN("fail to print table", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
const TransposeItem& transpose_item = *select_stmt->get_transpose_item();
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
DATA_PRINTF(" UNPIVOT %s (", (transpose_item.is_include_null() ? "INCLUDE NULLS" : "EXCLUDE NULLS"));
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (transpose_item.unpivot_columns_.count() == 1) {
|
||||
DATA_PRINTF("%.*s", transpose_item.unpivot_columns_[0].length(), transpose_item.unpivot_columns_[0].ptr());
|
||||
} else {
|
||||
DATA_PRINTF("(");
|
||||
for (int64_t i = 0; i < transpose_item.unpivot_columns_.count() && OB_SUCC(ret); ++i) {
|
||||
DATA_PRINTF("%.*s,", transpose_item.unpivot_columns_[i].length(), transpose_item.unpivot_columns_[i].ptr());
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--(*pos_);
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DATA_PRINTF(" FOR ");
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (transpose_item.for_columns_.count() == 1) {
|
||||
DATA_PRINTF("%.*s", transpose_item.for_columns_[0].length(), transpose_item.for_columns_[0].ptr());
|
||||
} else {
|
||||
DATA_PRINTF("(");
|
||||
for (int64_t i = 0; i < transpose_item.for_columns_.count() && OB_SUCC(ret); ++i) {
|
||||
DATA_PRINTF("%.*s,", transpose_item.for_columns_[i].length(), transpose_item.for_columns_[i].ptr());
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--(*pos_);
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DATA_PRINTF(" IN (");
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
for (int64_t i = 0; i < transpose_item.in_pairs_.count() && OB_SUCC(ret); ++i) {
|
||||
const TransposeItem::InPair& in_pair = transpose_item.in_pairs_[i];
|
||||
if (in_pair.column_names_.count() == 1) {
|
||||
DATA_PRINTF("%.*s", in_pair.column_names_[0].length(), in_pair.column_names_[0].ptr());
|
||||
} else {
|
||||
DATA_PRINTF("(");
|
||||
for (int64_t j = 0; j < in_pair.column_names_.count() && OB_SUCC(ret); ++j) {
|
||||
DATA_PRINTF("%.*s,", in_pair.column_names_[j].length(), in_pair.column_names_[j].ptr());
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--(*pos_);
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret) && !in_pair.exprs_.empty()) {
|
||||
DATA_PRINTF(" AS ");
|
||||
if (OB_SUCC(ret)) {
|
||||
HEAP_VAR(char[OB_MAX_DEFAULT_VALUE_LENGTH], expr_str_buf)
|
||||
{
|
||||
MEMSET(expr_str_buf, 0, sizeof(expr_str_buf));
|
||||
if (in_pair.exprs_.count() == 1) {
|
||||
ObRawExpr* expr = in_pair.exprs_.at(0);
|
||||
int64_t pos = 0;
|
||||
ObRawExprPrinter expr_printer(expr_str_buf, OB_MAX_DEFAULT_VALUE_LENGTH, &pos, stmt_->tz_info_);
|
||||
if (OB_FAIL(expr_printer.do_print(expr, T_NONE_SCOPE, true))) {
|
||||
LOG_WARN("print expr definition failed", KPC(expr), K(ret));
|
||||
} else {
|
||||
DATA_PRINTF("%.*s", static_cast<int32_t>(pos), expr_str_buf);
|
||||
}
|
||||
} else {
|
||||
DATA_PRINTF("(");
|
||||
for (int64_t j = 0; j < in_pair.exprs_.count() && OB_SUCC(ret); ++j) {
|
||||
ObRawExpr* expr = in_pair.exprs_.at(j);
|
||||
int64_t pos = 0;
|
||||
ObRawExprPrinter expr_printer(expr_str_buf, OB_MAX_DEFAULT_VALUE_LENGTH, &pos, stmt_->tz_info_);
|
||||
if (OB_FAIL(expr_printer.do_print(expr, T_NONE_SCOPE, true))) {
|
||||
LOG_WARN("print expr definition failed", KPC(expr), K(ret));
|
||||
} else {
|
||||
DATA_PRINTF("%.*s,", static_cast<int32_t>(pos), expr_str_buf);
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--(*pos_);
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (i != transpose_item.in_pairs_.count() - 1) {
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
}
|
||||
DATA_PRINTF(" )");
|
||||
}
|
||||
|
||||
DATA_PRINTF(" )");
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (!select_stmt->is_root_stmt()) {
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
int ObSelectStmtPrinter::print_set_op_stmt()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(stmt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("stmt_ should not be NULL", K(ret));
|
||||
} else if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
ObSEArray<ObSelectStmt*, 2> child_stmts;
|
||||
if (!select_stmt->has_set_op() || 2 > select_stmt->get_set_query().count()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN(
|
||||
"stmt_ should have set_op", K(ret), K(select_stmt->has_set_op()), K(select_stmt->get_set_query().count()));
|
||||
} else if (OB_FAIL(child_stmts.assign(select_stmt->get_set_query()))) {
|
||||
LOG_WARN("failed to assign stmts", K(ret));
|
||||
} else if (OB_ISNULL(child_stmts.at(0))) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("child_stmt should not be NULL", K(ret));
|
||||
} else {
|
||||
if (select_stmt->get_children_swapped()) {
|
||||
std::swap(child_stmts.at(0), child_stmts.at(1));
|
||||
}
|
||||
bool is_set_subquery = true;
|
||||
ObSelectStmtPrinter stmt_printer(
|
||||
buf_, buf_len_, pos_, child_stmts.at(0), print_params_, column_list_, is_set_subquery);
|
||||
ObString set_op_str = ObString::make_string(ObSelectStmt::set_operator_str(select_stmt->get_set_op()));
|
||||
if (OB_FAIL(stmt_printer.do_print())) {
|
||||
LOG_WARN("fail to print left stmt", K(ret), K(*child_stmts.at(0)));
|
||||
}
|
||||
for (int64_t i = 1; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
|
||||
DATA_PRINTF(" %.*s ", LEN_AND_PTR(set_op_str)); // print set_op
|
||||
if (!select_stmt->is_set_distinct()) {
|
||||
DATA_PRINTF(" all ");
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_ISNULL(child_stmts.at(i))) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("child_stmt should not be NULL", K(ret));
|
||||
} else {
|
||||
stmt_printer.init(buf_, buf_len_, pos_, child_stmts.at(i), column_list_, is_set_subquery);
|
||||
if (OB_FAIL(stmt_printer.do_print())) {
|
||||
LOG_WARN("fail to print child stmt", K(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_FAIL(print_order_by())) {
|
||||
LOG_WARN("fail to print order by", K(ret));
|
||||
} else if (OB_FAIL(print_limit())) {
|
||||
LOG_WARN("fail to print limit", K(ret));
|
||||
} else if (OB_FAIL(print_fetch())) {
|
||||
LOG_WARN("fail to print fetch", K(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_basic_stmt()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(stmt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("stmt_ should not be NULL", K(ret));
|
||||
} else if (OB_FAIL(print_select())) {
|
||||
LOG_WARN("fail to print select", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_from())) {
|
||||
LOG_WARN("fail to print from", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_where())) {
|
||||
LOG_WARN("fail to print where", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_start_with())) {
|
||||
LOG_WARN("fail to print start with", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_connect_by())) {
|
||||
LOG_WARN("fail to print connect by", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_group_by())) {
|
||||
LOG_WARN("fail to print group by", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_having())) {
|
||||
LOG_WARN("fail to print having", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_order_by())) {
|
||||
LOG_WARN("fail to print order by", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_limit())) {
|
||||
LOG_WARN("fail to print limit", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_fetch())) {
|
||||
LOG_WARN("fail to print fetch", K(ret), K(*stmt_));
|
||||
} else if (OB_FAIL(print_for_update())) {
|
||||
LOG_WARN("fail to print for update", K(ret), K(*stmt_));
|
||||
} else {
|
||||
// do-nothing
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_select()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
DATA_PRINTF("select ");
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
bool is_oracle_mode = share::is_oracle_mode();
|
||||
if (OB_FAIL(print_hint())) { // hint
|
||||
LOG_WARN("fail to print hint", K(ret), K(*select_stmt));
|
||||
} else if (select_stmt->is_unpivot_select()) {
|
||||
DATA_PRINTF(" * ");
|
||||
} else {
|
||||
if (select_stmt->has_distinct()) { // distinct
|
||||
DATA_PRINTF("distinct ");
|
||||
}
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); ++i) {
|
||||
const SelectItem& select_item = select_stmt->get_select_item(i);
|
||||
if (select_item.is_implicit_added_)
|
||||
continue;
|
||||
ObRawExpr* expr = select_item.expr_;
|
||||
bool need_add_alias = force_col_alias_;
|
||||
if (OB_ISNULL(expr)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("select item expr is null");
|
||||
} else if (select_item.is_real_alias_) {
|
||||
need_add_alias = true;
|
||||
} else if (select_stmt->is_root_stmt()) {
|
||||
if (print_params_.is_show_create_view_) {
|
||||
need_add_alias = true;
|
||||
}
|
||||
} else if (OB_ISNULL(select_stmt->get_parent_namespace_stmt())) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("upper_scope_stmt is NULL", K(ret));
|
||||
} else if (select_stmt->get_parent_namespace_stmt()->is_delete_stmt() ||
|
||||
select_stmt->get_parent_namespace_stmt()->is_update_stmt() ||
|
||||
(select_stmt->get_parent_namespace_stmt()->is_root_stmt() && is_set_subquery_)) {
|
||||
need_add_alias = true;
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
ObRawExpr* tmp_expr = expr;
|
||||
if (OB_FAIL(ObRawExprUtils::erase_inner_added_exprs(tmp_expr, expr))) {
|
||||
LOG_WARN("erase inner cast expr failed", K(ret));
|
||||
} else if (OB_ISNULL(expr)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("expr is null");
|
||||
} else if (need_add_alias && NULL != column_list_ && select_item.is_real_alias_) {
|
||||
expr->set_alias_column_name(column_list_->at(i));
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(expr_printer_.do_print(expr, T_FIELD_LIST_SCOPE))) {
|
||||
LOG_WARN("fail to print select expr", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret) && need_add_alias) {
|
||||
ObString alias_string;
|
||||
bool have_double_quotation = false;
|
||||
if (NULL != column_list_) {
|
||||
alias_string = column_list_->at(i);
|
||||
} else if (!select_item.alias_name_.empty()) {
|
||||
alias_string = select_item.alias_name_;
|
||||
} else {
|
||||
alias_string = select_item.expr_name_;
|
||||
}
|
||||
ObArenaAllocator arena_alloc;
|
||||
if (is_oracle_mode && OB_FAIL(remove_double_quotation_for_string(alias_string, arena_alloc))) {
|
||||
LOG_WARN("failed to remove double quotation for string", K(ret));
|
||||
} else {
|
||||
DATA_PRINTF(is_oracle_mode ? " AS \"%.*s\"" : " AS `%.*s`", LEN_AND_PTR(alias_string));
|
||||
}
|
||||
}
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--*pos_;
|
||||
}
|
||||
}
|
||||
// select_items
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::remove_double_quotation_for_string(ObString& alias_string, ObIAllocator& allocator)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
const char* str = alias_string.ptr();
|
||||
int32_t length = alias_string.length();
|
||||
if (OB_ISNULL(str) && OB_UNLIKELY(length > 0)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("get unexpected null", K(str), K(length), K(ret));
|
||||
} else if (length > 0) {
|
||||
char* buff = static_cast<char*>(allocator.alloc(length));
|
||||
if (OB_ISNULL(buff)) {
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
LOG_WARN("failed to alloc memory failed.", K(buff), K(length), K(alias_string), K(ret));
|
||||
} else {
|
||||
int32_t len_str = 0;
|
||||
for (int32_t i = 0; len_str < length && i < length; ++i) {
|
||||
if (str[i] == '\"') {
|
||||
/*do nothing*/
|
||||
} else {
|
||||
buff[len_str++] = str[i];
|
||||
}
|
||||
}
|
||||
alias_string.assign_ptr(buff, static_cast<int64_t>(len_str));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_start_with()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
const ObIArray<ObRawExpr*>& start_with_exprs = select_stmt->get_start_with_exprs();
|
||||
int64_t start_with_exprs_size = start_with_exprs.count();
|
||||
if (start_with_exprs_size > 0) {
|
||||
DATA_PRINTF(" start with ");
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < start_with_exprs_size; ++i) {
|
||||
if (OB_FAIL(expr_printer_.do_print(start_with_exprs.at(i), T_NONE_SCOPE))) {
|
||||
LOG_WARN("fail to print having expr", K(ret));
|
||||
}
|
||||
DATA_PRINTF(" and ");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
*pos_ -= 5; // strlen(" and ")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_connect_by()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
const ObIArray<ObRawExpr*>& connect_by_exprs = select_stmt->get_connect_by_exprs();
|
||||
int64_t connect_by_exprs_size = connect_by_exprs.count();
|
||||
if (connect_by_exprs_size > 0) {
|
||||
DATA_PRINTF(" connect by ");
|
||||
if (select_stmt->is_nocycle()) {
|
||||
DATA_PRINTF("nocycle ");
|
||||
}
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < connect_by_exprs_size; ++i) {
|
||||
if (OB_FAIL(expr_printer_.do_print(connect_by_exprs.at(i), T_NONE_SCOPE))) {
|
||||
LOG_WARN("fail to print having expr", K(ret));
|
||||
}
|
||||
DATA_PRINTF(" and ");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
*pos_ -= 5; // strlen(" and ")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_group_by()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
const ObIArray<ObRawExpr*>& group_exprs = select_stmt->get_group_exprs();
|
||||
const ObIArray<ObRawExpr*>& rollup_exprs = select_stmt->get_rollup_exprs();
|
||||
const ObIArray<ObGroupingSetsItem>& groupingsets_items = select_stmt->get_grouping_sets_items();
|
||||
const ObIArray<ObMultiRollupItem>& multi_rollup_items = select_stmt->get_multi_rollup_items();
|
||||
int64_t group_exprs_size = group_exprs.count();
|
||||
int64_t rollup_exprs_size = rollup_exprs.count();
|
||||
int64_t grouping_sets_size = groupingsets_items.count();
|
||||
int64_t multi_rollup_size = multi_rollup_items.count();
|
||||
if (group_exprs_size + rollup_exprs_size + grouping_sets_size + multi_rollup_size > 0) {
|
||||
DATA_PRINTF(" group by ");
|
||||
if (OB_SUCC(ret) && grouping_sets_size > 0) {
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < grouping_sets_size; ++i) {
|
||||
const ObIArray<ObGroupbyExpr>& grouping_sets_exprs = groupingsets_items.at(i).grouping_sets_exprs_;
|
||||
DATA_PRINTF(" grouping sets (");
|
||||
for (int64_t j = 0; OB_SUCC(ret) && j < grouping_sets_exprs.count(); ++j) {
|
||||
const ObIArray<ObRawExpr*>& groupby_exprs = grouping_sets_exprs.at(j).groupby_exprs_;
|
||||
DATA_PRINTF("(");
|
||||
for (int64_t k = 0; OB_SUCC(ret) && k < groupby_exprs.count(); ++k) {
|
||||
if (OB_FAIL(expr_printer_.do_print(groupby_exprs.at(k), T_GROUP_SCOPE))) {
|
||||
LOG_WARN("fail to print group expr", K(ret));
|
||||
} else if (k < groupby_exprs.count() - 1) {
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
}
|
||||
DATA_PRINTF("),");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(print_multi_rollup_items(groupingsets_items.at(i).multi_rollup_items_))) {
|
||||
LOG_WARN("failed to print multi rollup items", K(ret));
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--*pos_;
|
||||
}
|
||||
DATA_PRINTF("),");
|
||||
}
|
||||
}
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < group_exprs_size; ++i) {
|
||||
if (OB_FAIL(expr_printer_.do_print(group_exprs.at(i), T_GROUP_SCOPE))) {
|
||||
LOG_WARN("fail to print group expr", K(ret));
|
||||
}
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
if (rollup_exprs_size > 0) {
|
||||
if (lib::is_oracle_mode()) {
|
||||
DATA_PRINTF(" rollup( ");
|
||||
} else { /* do nothing. */
|
||||
}
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < rollup_exprs_size; ++i) {
|
||||
if (OB_FAIL(expr_printer_.do_print(rollup_exprs.at(i), T_GROUP_SCOPE))) {
|
||||
LOG_WARN("fail to print group expr", K(ret));
|
||||
}
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
} else if (multi_rollup_size > 0) {
|
||||
if (OB_FAIL(print_multi_rollup_items(multi_rollup_items))) {
|
||||
LOG_WARN("failed to print multi rollup items", K(ret));
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--*pos_;
|
||||
}
|
||||
if (rollup_exprs_size > 0) {
|
||||
if (lib::is_oracle_mode()) {
|
||||
DATA_PRINTF(" ) ");
|
||||
} else {
|
||||
DATA_PRINTF(" with rollup ");
|
||||
}
|
||||
} else { /* do nothing. */
|
||||
}
|
||||
}
|
||||
} else { /* do nothing. */
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_multi_rollup_items(const ObIArray<ObMultiRollupItem>& rollup_items)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < rollup_items.count(); ++i) {
|
||||
const ObIArray<ObGroupbyExpr>& rollup_list_exprs = rollup_items.at(i).rollup_list_exprs_;
|
||||
DATA_PRINTF(" rollup (");
|
||||
for (int64_t j = 0; OB_SUCC(ret) && j < rollup_list_exprs.count(); ++j) {
|
||||
const ObIArray<ObRawExpr*>& groupby_exprs = rollup_list_exprs.at(j).groupby_exprs_;
|
||||
DATA_PRINTF("(");
|
||||
for (int64_t k = 0; OB_SUCC(ret) && k < groupby_exprs.count(); ++k) {
|
||||
if (OB_FAIL(expr_printer_.do_print(groupby_exprs.at(k), T_GROUP_SCOPE))) {
|
||||
LOG_WARN("fail to print group expr", K(ret));
|
||||
} else if (k < groupby_exprs.count() - 1) {
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
}
|
||||
if (j < rollup_list_exprs.count() - 1) {
|
||||
DATA_PRINTF("),");
|
||||
} else {
|
||||
DATA_PRINTF(")");
|
||||
}
|
||||
}
|
||||
DATA_PRINTF("),");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_having()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
const ObIArray<ObRawExpr*>& having_exprs = select_stmt->get_having_exprs();
|
||||
int64_t having_exprs_size = having_exprs.count();
|
||||
if (having_exprs_size > 0) {
|
||||
DATA_PRINTF(" having ");
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < having_exprs_size; ++i) {
|
||||
if (OB_FAIL(expr_printer_.do_print(having_exprs.at(i), T_NONE_SCOPE))) {
|
||||
LOG_WARN("fail to print having expr", K(ret));
|
||||
}
|
||||
DATA_PRINTF(" and ");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
*pos_ -= 5; // strlen(" and ")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_order_by()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
ObArenaAllocator alloc;
|
||||
ObConstRawExpr expr(alloc);
|
||||
int64_t order_item_size = select_stmt->get_order_item_size();
|
||||
if (order_item_size > 0) {
|
||||
if (select_stmt->is_order_siblings()) {
|
||||
DATA_PRINTF(" order siblings by");
|
||||
} else {
|
||||
DATA_PRINTF(" order by");
|
||||
}
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < order_item_size; ++i) {
|
||||
const OrderItem& order_item = select_stmt->get_order_item(i);
|
||||
ObRawExpr* order_expr = order_item.expr_;
|
||||
int64_t sel_item_pos = -1;
|
||||
for (int64_t j = 0; j < select_stmt->get_select_item_size(); ++j) {
|
||||
if (order_item.expr_ == select_stmt->get_select_item(j).expr_) {
|
||||
sel_item_pos = j + 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (sel_item_pos != -1) {
|
||||
ObObjParam val;
|
||||
val.set_int(sel_item_pos);
|
||||
val.set_scale(0);
|
||||
val.set_param_meta();
|
||||
expr.set_expr_type(T_INT);
|
||||
expr.set_value(val);
|
||||
order_expr = &expr;
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
DATA_PRINTF(" ");
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(expr_printer_.do_print(order_expr, T_ORDER_SCOPE))) {
|
||||
LOG_WARN("fail to print order by expr", K(ret));
|
||||
} else if (share::is_mysql_mode()) {
|
||||
if (is_descending_direction(order_item.order_type_)) {
|
||||
DATA_PRINTF(" desc");
|
||||
}
|
||||
} else if (order_item.order_type_ == NULLS_FIRST_ASC) {
|
||||
DATA_PRINTF(" asc nulls first");
|
||||
} else if (order_item.order_type_ == NULLS_LAST_ASC) { // use default value
|
||||
/*do nothing*/
|
||||
} else if (order_item.order_type_ == NULLS_FIRST_DESC) { // use default value
|
||||
DATA_PRINTF(" desc");
|
||||
} else if (order_item.order_type_ == NULLS_LAST_DESC) {
|
||||
DATA_PRINTF(" desc nulls last");
|
||||
} else { /*do nothing*/
|
||||
}
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
--*pos_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_for_update()
|
||||
{
|
||||
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 if (!stmt_->is_select_stmt()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Not a valid select stmt", K(stmt_->get_stmt_type()), K(ret));
|
||||
} else if (is_oracle_mode()) {
|
||||
if (is_generated_table_ || stmt_->get_parent_namespace_stmt() != NULL) {
|
||||
// do nothing
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
bool has_for_update_ = false;
|
||||
int64_t wait_time = -1;
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_table_size(); ++i) {
|
||||
const TableItem* table = NULL;
|
||||
if (OB_ISNULL(table = select_stmt->get_table_item(i))) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("table item is null", K(ret));
|
||||
} else if (table->for_update_) {
|
||||
has_for_update_ = true;
|
||||
wait_time = table->for_update_wait_us_;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret) && has_for_update_) {
|
||||
DATA_PRINTF(" for update");
|
||||
const ObIArray<ObColumnRefRawExpr*>& for_update_cols = select_stmt->get_for_update_columns();
|
||||
if (OB_SUCC(ret) && !select_stmt->get_for_update_columns().empty()) {
|
||||
DATA_PRINTF(" of");
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < for_update_cols.count(); ++i) {
|
||||
DATA_PRINTF(" ");
|
||||
if (OB_FAIL(ret)) {
|
||||
// do nothing
|
||||
} else if (OB_FAIL(expr_printer_.do_print(for_update_cols.at(i), T_NONE_SCOPE))) {
|
||||
LOG_WARN("fail to print for update column", K(ret));
|
||||
} else if (i != for_update_cols.count() - 1) {
|
||||
DATA_PRINTF(",");
|
||||
}
|
||||
}
|
||||
}
|
||||
if (OB_SUCC(ret) && wait_time >= 0) {
|
||||
if (wait_time > 0) {
|
||||
DATA_PRINTF(" wait %lld", wait_time / 1000000LL);
|
||||
} else {
|
||||
DATA_PRINTF(" nowait");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
if (select_stmt->get_table_size() > 0) {
|
||||
const TableItem* table_item = select_stmt->get_table_item(0);
|
||||
if (OB_ISNULL(table_item)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("table item is NULL", K(ret));
|
||||
} else if (table_item->for_update_) {
|
||||
DATA_PRINTF(" for update");
|
||||
if (OB_SUCC(ret) && table_item->for_update_wait_us_ > 0) {
|
||||
DATA_PRINTF(" wait %lld", table_item->for_update_wait_us_ / 1000000LL);
|
||||
}
|
||||
} else { /*do nothing*/
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// restore CTE's complete definition
|
||||
int ObSelectStmtPrinter::print_with()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
DATA_PRINTF("WITH ");
|
||||
if (OB_SUCC(ret)) {
|
||||
const ObSelectStmt* select_stmt = static_cast<const ObSelectStmt*>(stmt_);
|
||||
const common::ObIArray<TableItem*>& cte_tables = select_stmt->get_CTE_table_items();
|
||||
int64_t this_stmt_generated_cte_count = select_stmt->get_generated_cte_count();
|
||||
|
||||
for (int64_t i = 0; i < this_stmt_generated_cte_count && OB_SUCC(ret); ++i) {
|
||||
TableItem* cte_table = cte_tables.at(i);
|
||||
// print definition
|
||||
if (OB_ISNULL(cte_table)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("the cte tableitem can not be null", K(ret));
|
||||
} else if (TableItem::NORMAL_CTE == cte_table->cte_type_ || TableItem::RECURSIVE_CTE == cte_table->cte_type_) {
|
||||
if (OB_ISNULL(cte_table->node_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("the parser node of a cte table can not be null", K(ret));
|
||||
} else if (OB_FAIL(print_cte_define_title(cte_table))) {
|
||||
LOG_WARN("print column name failed", K(ret));
|
||||
} else if (OB_FAIL(print_table(cte_table, true))) {
|
||||
LOG_WARN("print table failed", K(ret));
|
||||
} else if ((TableItem::RECURSIVE_CTE == cte_table->cte_type_) && OB_FAIL(print_search_and_cycle(cte_table))) {
|
||||
LOG_WARN("print search and cycle failed", K(ret));
|
||||
}
|
||||
} else {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("unexpected cte type", K(ret), K(cte_table->cte_type_));
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
// do nothing
|
||||
} else if (i == this_stmt_generated_cte_count - 1) {
|
||||
DATA_PRINTF(" ");
|
||||
} else {
|
||||
DATA_PRINTF(", ");
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_cte_define_title(TableItem* cte_table)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObSelectStmt* sub_select_stmt = NULL;
|
||||
PRINT_TABLE_NAME(cte_table);
|
||||
if (OB_ISNULL(cte_table->node_->children_[1]) && (TableItem::RECURSIVE_CTE == cte_table->cte_type_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("the recursive cte must have the colume definition", K(ret));
|
||||
} else if (OB_NOT_NULL(cte_table->node_->children_[1])) {
|
||||
DATA_PRINTF("(");
|
||||
sub_select_stmt = cte_table->ref_query_;
|
||||
const ObIArray<SelectItem>& sub_select_items = sub_select_stmt->get_select_items();
|
||||
// print column
|
||||
for (int64_t i = 0; i < sub_select_items.count() && OB_SUCC(ret); ++i) {
|
||||
if (T_CTE_SEARCH_COLUMN == sub_select_items.at(i).expr_->get_expr_type() ||
|
||||
T_CTE_CYCLE_COLUMN == sub_select_items.at(i).expr_->get_expr_type()) {
|
||||
// pseudo-column no need to print
|
||||
} else {
|
||||
DATA_PRINTF("%.*s", LEN_AND_PTR(sub_select_items.at(i).alias_name_));
|
||||
if (i != sub_select_items.count() - 1 &&
|
||||
T_CTE_SEARCH_COLUMN != sub_select_items.at(i + 1).expr_->get_expr_type() &&
|
||||
T_CTE_CYCLE_COLUMN != sub_select_items.at(i + 1).expr_->get_expr_type()) {
|
||||
DATA_PRINTF(", ");
|
||||
}
|
||||
}
|
||||
}
|
||||
DATA_PRINTF(")");
|
||||
} else {
|
||||
// do nothing, the normal cte without column alias is OK
|
||||
}
|
||||
DATA_PRINTF(" as ");
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObSelectStmtPrinter::print_search_and_cycle(TableItem* cte_table)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObArenaAllocator allocator("PrintSelectStmt");
|
||||
ObSelectStmt* sub_select_stmt = NULL;
|
||||
if (OB_ISNULL(sub_select_stmt = cte_table->ref_query_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("the cte table must have ref sub query", K(ret));
|
||||
} else if (OB_ISNULL(cte_table->node_->children_[1])) {
|
||||
// do nothing
|
||||
} else {
|
||||
const ObIArray<SelectItem>& sub_select_items = sub_select_stmt->get_select_items();
|
||||
const ObIArray<OrderItem>& search_items = sub_select_stmt->get_search_by_items();
|
||||
if (!search_items.empty()) {
|
||||
DATA_PRINTF(" search ");
|
||||
if (sub_select_stmt->is_breadth_search()) {
|
||||
DATA_PRINTF("breadth first by ");
|
||||
} else {
|
||||
DATA_PRINTF("depth first by ");
|
||||
}
|
||||
}
|
||||
|
||||
for (int64_t i = 0; i < search_items.count() && OB_SUCC(ret); ++i) {
|
||||
allocator.reuse();
|
||||
ObString column_name = ((ObColumnRefRawExpr*)(search_items.at(i).expr_))->get_column_name();
|
||||
CONVERT_CHARSET_FOR_RPINT(allocator, column_name);
|
||||
DATA_PRINTF(" %.*s ", LEN_AND_PTR(column_name));
|
||||
if (share::is_mysql_mode()) {
|
||||
if (is_descending_direction(search_items.at(i).order_type_)) {
|
||||
DATA_PRINTF("DESC ");
|
||||
}
|
||||
} else if (search_items.at(i).order_type_ == NULLS_FIRST_ASC) {
|
||||
DATA_PRINTF("ASC NULLS FIRST ");
|
||||
} else if (search_items.at(i).order_type_ == NULLS_LAST_ASC) { // use default value
|
||||
/*do nothing*/
|
||||
} else if (search_items.at(i).order_type_ == NULLS_FIRST_DESC) { // use default value
|
||||
DATA_PRINTF("DESC ");
|
||||
} else if (search_items.at(i).order_type_ == NULLS_LAST_DESC) {
|
||||
DATA_PRINTF("DESC NULLS LAST ");
|
||||
}
|
||||
if (i != search_items.count() - 1) {
|
||||
DATA_PRINTF(", ");
|
||||
} else {
|
||||
DATA_PRINTF(" ");
|
||||
}
|
||||
}
|
||||
|
||||
for (int64_t i = 0; i < sub_select_items.count() && OB_SUCC(ret); ++i) {
|
||||
if (T_CTE_SEARCH_COLUMN == sub_select_items.at(i).expr_->get_expr_type()) {
|
||||
DATA_PRINTF("set ");
|
||||
DATA_PRINTF(" %.*s ", LEN_AND_PTR(sub_select_items.at(i).alias_name_));
|
||||
}
|
||||
}
|
||||
|
||||
const ObIArray<ColumnItem>& cycle_items = sub_select_stmt->get_cycle_items();
|
||||
if (!cycle_items.empty()) {
|
||||
DATA_PRINTF("cycle ");
|
||||
}
|
||||
|
||||
for (int64_t i = 0; i < cycle_items.count() && OB_SUCC(ret); ++i) {
|
||||
allocator.reuse();
|
||||
ObString column_name = ((ObColumnRefRawExpr*)(cycle_items.at(i).expr_))->get_column_name();
|
||||
CONVERT_CHARSET_FOR_RPINT(allocator, column_name);
|
||||
DATA_PRINTF("%.*s ", LEN_AND_PTR(column_name));
|
||||
if (i != cycle_items.count() - 1) {
|
||||
DATA_PRINTF(", ");
|
||||
} else {
|
||||
DATA_PRINTF(" ");
|
||||
}
|
||||
}
|
||||
|
||||
for (int64_t i = 0; i < sub_select_items.count() && OB_SUCC(ret); ++i) {
|
||||
if (T_CTE_CYCLE_COLUMN == sub_select_items.at(i).expr_->get_expr_type()) {
|
||||
ObRawExpr* v;
|
||||
ObRawExpr* d_v;
|
||||
DATA_PRINTF("set ");
|
||||
DATA_PRINTF("%.*s ", LEN_AND_PTR(sub_select_items.at(i).alias_name_));
|
||||
DATA_PRINTF("to ");
|
||||
((ObPseudoColumnRawExpr*)(sub_select_items.at(i).expr_))->get_cte_cycle_value(v, d_v);
|
||||
if (OB_ISNULL(v) || OB_ISNULL(d_v) || !v->is_const_expr() || !d_v->is_const_expr()) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("Unexpected const expr", K(ret), KPC(v), KPC(d_v));
|
||||
} else {
|
||||
ObObj non_cycle_vale = ((ObConstRawExpr*)v)->get_value();
|
||||
ObObj cycle_vale = ((ObConstRawExpr*)d_v)->get_value();
|
||||
DATA_PRINTF("'%.*s' ", LEN_AND_PTR(non_cycle_vale.get_string()));
|
||||
DATA_PRINTF("default ");
|
||||
DATA_PRINTF("'%.*s' ", LEN_AND_PTR(cycle_vale.get_string()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // end of namespace sql
|
||||
} // end of namespace oceanbase
|
||||
Reference in New Issue
Block a user