[CP] fix executor core

src/observer/mysql/obmp_connect.cpp

@@ -607,7 +607,7 @@ int ObMPConnect::load_privilege_info(ObSQLSessionInfo &session)
           } else if (OB_FAIL(ObSQLUtils::check_and_convert_db_name(
                       cs_type, perserve_lettercase, db_name))) {
             LOG_WARN("fail to check and convert database name", K(db_name), K(ret));
-          } else if (OB_FAIL(ObSQLUtils::cvt_db_name_to_org(schema_guard, &session, db_name))) {
+          } else if (OB_FAIL(ObSQLUtils::cvt_db_name_to_org(schema_guard, &session, db_name, NULL/*allocator*/))) {
             LOG_WARN("fail to convert db name to org");
           } else {
             login_info.db_ = db_name;

src/observer/mysql/obmp_init_db.cpp

@@ -218,7 +218,7 @@ int ObMPInitDB::do_process(sql::ObSQLSessionInfo *session)
     LOG_WARN("can only access oceanbase database when tenant changed", K(ret));
   } else {
     session->get_session_priv_info(session_priv);
-    if (OB_FAIL(ObSQLUtils::cvt_db_name_to_org(schema_guard, session, db_name_))) {
+    if (OB_FAIL(ObSQLUtils::cvt_db_name_to_org(schema_guard, session, db_name_, NULL/*allocator*/))) {
       LOG_WARN("fail to cvt db name to orignal", K(db_name_), K(ret));
     } else if (OB_FAIL(schema_guard.check_db_access(session_priv, db_name_))) {
       LOG_WARN("fail to check db access.", K_(db_name), K(ret));

src/sql/ob_sql_utils.cpp

@@ -1119,7 +1119,8 @@ int ObSQLUtils::check_and_convert_db_name(const ObCollationType cs_type, const b
 /* 将用户输入的dbname换成数据库内部存放的大小写 */
 int ObSQLUtils::cvt_db_name_to_org(share::schema::ObSchemaGetterGuard &schema_guard,
                                    const ObSQLSessionInfo *session,
-                                   common::ObString &name)
+                                   common::ObString &name,
+                                   ObIAllocator *allocator)
 {
   int ret = OB_SUCCESS;
   if (lib::is_mysql_mode() && session != NULL && !session->is_inner()) {
@@ -1134,6 +1135,9 @@ int ObSQLUtils::cvt_db_name_to_org(share::schema::ObSchemaGetterGuard &schema_gu
         LOG_WARN("fail to get database schema", K(name), K(ret));
       } else if (db_schema != NULL) {
         name = db_schema->get_database_name();
+        if (allocator != NULL) {
+          OZ(ob_write_string(*allocator, name, name));
+        }
       }
     }
   }

src/sql/ob_sql_utils.h

@@ -331,7 +331,8 @@ public:
                                        common::ObString &name);
   static int cvt_db_name_to_org(share::schema::ObSchemaGetterGuard &schema_guard,
                                 const ObSQLSessionInfo *session,
-                                common::ObString &name);
+                                common::ObString &name,
+                                ObIAllocator *allocator);
   static int check_and_convert_table_name(const common::ObCollationType cs_type,
                                           const bool preserve_lettercase,
                                           common::ObString &name,

src/sql/resolver/dcl/ob_dcl_resolver.cpp

@@ -27,7 +27,7 @@ int ObDCLResolver::check_and_convert_name(ObString &db, ObString &table)
 {
   int ret = OB_SUCCESS;
   ObNameCaseMode mode = OB_NAME_CASE_INVALID;
-  if (OB_ISNULL(session_info_)) {
+  if (OB_ISNULL(session_info_) || OB_ISNULL(allocator_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("Session info is not inited", K(ret));
   } else if (OB_FAIL(session_info_->get_name_case_mode(mode))) {
@@ -53,7 +53,8 @@ int ObDCLResolver::check_and_convert_name(ObString &db, ObString &table)
         CK (OB_NOT_NULL(schema_checker_->get_schema_guard()));
         OZ (ObSQLUtils::cvt_db_name_to_org(*schema_checker_->get_schema_guard(),
                                            session_info_,
-                                           db));
+                                           db,
+                                           allocator_));
       }
     }
   }

src/sql/resolver/dcl/ob_grant_resolver.cpp

@@ -1214,7 +1214,7 @@ int ObGrantResolver::resolve_mysql(const ParseNode &parse_tree)
 
   ParseNode *node = const_cast<ParseNode*>(&parse_tree);
   ObGrantStmt *grant_stmt = NULL;
-  if (OB_ISNULL(params_.schema_checker_) || OB_ISNULL(params_.session_info_)) {
+  if (OB_ISNULL(params_.schema_checker_) || OB_ISNULL(params_.session_info_) || OB_ISNULL(allocator_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("schema_checker or session_info not inited", "schema_checker", params_.schema_checker_,
                                                           "session_info", params_.session_info_,
@@ -1252,7 +1252,8 @@ int ObGrantResolver::resolve_mysql(const ParseNode &parse_tree)
                                          params_.session_info_->get_database_name(),
                                          db, 
                                          table, 
-                                         grant_level))) {
+                                         grant_level,
+                                         *allocator_))) {
             LOG_WARN("Resolve priv_level node error", K(ret));
           } else if (OB_FAIL(check_and_convert_name(db, table))) {
             LOG_WARN("Check and convert name error", K(db), K(table), K(ret));
@@ -1434,7 +1435,8 @@ int ObGrantResolver::resolve_priv_level(
     const ObString &session_db,
     ObString &db,
     ObString &table,
-    ObPrivLevel &grant_level)
+    ObPrivLevel &grant_level,
+    ObIAllocator &allocator)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(node)) {
@@ -1476,14 +1478,14 @@ int ObGrantResolver::resolve_priv_level(
         grant_level = OB_PRIV_DB_LEVEL;
         db.assign_ptr(node->children_[0]->str_value_,
                       static_cast<const int32_t>(node->children_[0]->str_len_));
-	    OZ (ObSQLUtils::cvt_db_name_to_org(*guard, session, db));
+	    OZ (ObSQLUtils::cvt_db_name_to_org(*guard, session, db, &allocator));
       } else if (T_IDENT == node->children_[0]->type_ && T_IDENT == node->children_[1]->type_) {
         grant_level = OB_PRIV_TABLE_LEVEL;
         db.assign_ptr(node->children_[0]->str_value_,
                       static_cast<const int32_t>(node->children_[0]->str_len_));
         table.assign_ptr(node->children_[1]->str_value_,
                          static_cast<const int32_t>(node->children_[1]->str_len_));
-	    OZ (ObSQLUtils::cvt_db_name_to_org(*guard, session, db));
+	    OZ (ObSQLUtils::cvt_db_name_to_org(*guard, session, db, &allocator));
       } else {
         ret = OB_ERR_PARSE_SQL;
         LOG_WARN("sql_parser error", K(ret));

src/sql/resolver/dcl/ob_grant_resolver.h

@@ -84,7 +84,8 @@ public:
       const common::ObString &session_db,
       common::ObString &db,
       common::ObString &table,
-      share::schema::ObPrivLevel &grant_level);
+      share::schema::ObPrivLevel &grant_level,
+      ObIAllocator &allocator);
 
   static int resolve_priv_set(
       const ParseNode *privs_node,

src/sql/resolver/dcl/ob_revoke_resolver.cpp

@@ -277,7 +277,7 @@ int ObRevokeResolver::resolve_mysql(const ParseNode &parse_tree)
           ParseNode *priv_level_node = node->children_[1];
           users_node = node->children_[2];
           //resolve priv_level
-          if (OB_ISNULL(priv_level_node)) {
+          if (OB_ISNULL(priv_level_node) || OB_ISNULL(allocator_)) {
             ret = OB_ERR_PARSE_SQL;
             LOG_WARN("Priv level node should not be NULL", K(ret));
           } else {
@@ -290,7 +290,8 @@ int ObRevokeResolver::resolve_mysql(const ParseNode &parse_tree)
                         params_.session_info_->get_database_name(), 
                         db, 
                         table, 
-                        grant_level))) {
+                        grant_level,
+                        *allocator_))) {
               LOG_WARN("Resolve priv_level node error", K(ret));
             } else if (OB_FAIL(check_and_convert_name(db, table))) {
               LOG_WARN("Check and convert name error", K(db), K(table), K(ret));

src/sql/resolver/ddl/ob_alter_database_resolver.cpp

@@ -40,7 +40,8 @@ int ObAlterDatabaseResolver::resolve(const ParseNode &parse_tree)
   if (OB_ISNULL(node)
       || OB_UNLIKELY(T_ALTER_DATABASE != node->type_)
       || OB_UNLIKELY(node->num_child_ != DATABASE_NODE_COUNT)
-      || OB_ISNULL(node->children_)) {
+      || OB_ISNULL(node->children_)
+      || OB_ISNULL(allocator_)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("invalid parse tree", K(ret));
   } else if (OB_ISNULL(session_info_)) {
@@ -86,7 +87,8 @@ int ObAlterDatabaseResolver::resolve(const ParseNode &parse_tree)
               CK (OB_NOT_NULL(schema_checker_->get_schema_guard()));
               OZ (ObSQLUtils::cvt_db_name_to_org(*schema_checker_->get_schema_guard(),
                                                  session_info_,
-                                                 database_name));
+                                                 database_name,
+                                                 allocator_));
             }
           }
         }

src/sql/resolver/ddl/ob_drop_database_resolver.cpp

@@ -98,11 +98,9 @@ int ObDropDatabaseResolver::resolve(const ParseNode &parse_tree)
             CK (OB_NOT_NULL(schema_checker_->get_schema_guard()));
             OZ (ObSQLUtils::cvt_db_name_to_org(*schema_checker_->get_schema_guard(),
                                                session_info_,
-                                               database_name));
-            OZ (deep_copy_ob_string(*allocator_,
                                                database_name,
-                                    deep_copy_database_name), database_name);
+                                               allocator_));
-            OX (drop_database_stmt->set_database_name(deep_copy_database_name));
+            OX (drop_database_stmt->set_database_name(database_name));
           }
         }
       }

src/sql/resolver/ddl/ob_outline_resolver.cpp

@@ -35,7 +35,8 @@ int ObOutlineResolver::resolve_outline_name(const ParseNode *node, ObString &db_
 
   if (OB_ISNULL(node)
       || OB_UNLIKELY(T_RELATION_FACTOR != node->type_)
-      || OB_UNLIKELY(RELATION_FACTOR_CHILD_COUNT > node->num_child_)) {
+      || OB_UNLIKELY(RELATION_FACTOR_CHILD_COUNT > node->num_child_)
+      || OB_ISNULL(allocator_)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("invalid parse tree", K(ret));
   } else if (OB_ISNULL(node->children_)) {
@@ -76,7 +77,8 @@ int ObOutlineResolver::resolve_outline_name(const ParseNode *node, ObString &db_
         CK (OB_NOT_NULL(schema_checker_->get_schema_guard()));
         OZ (ObSQLUtils::cvt_db_name_to_org(*schema_checker_->get_schema_guard(),
                                            session_info_,
-                                           db_name));
+                                           db_name,
+                                           allocator_));
       }
     }
   }

src/sql/resolver/ddl/ob_use_database_resolver.cpp

@@ -42,7 +42,8 @@ int ObUseDatabaseResolver::resolve(const ParseNode &parse_tree)
   if (OB_ISNULL(node)
       || T_USE_DATABASE != node->type_
       || 1 != node->num_child_
-      || OB_ISNULL(node->children_)) {
+      || OB_ISNULL(node->children_)
+      || OB_ISNULL(allocator_)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(node));
   } else if (OB_ISNULL(node->children_[0])
@@ -76,7 +77,8 @@ int ObUseDatabaseResolver::resolve(const ParseNode &parse_tree)
         CK (OB_NOT_NULL(schema_checker_->get_schema_guard()));
         OZ (ObSQLUtils::cvt_db_name_to_org(*schema_checker_->get_schema_guard(),
                                            session_info_,
-                                           db_name));
+                                           db_name,
+                                           allocator_));
         use_database_stmt->set_db_name(db_name);
         uint64_t tenant_id = session_info_->get_effective_tenant_id();
         share::schema::ObSessionPrivInfo session_priv;

src/sql/resolver/ob_stmt_resolver.cpp

@@ -113,7 +113,7 @@ int ObStmtResolver::resolve_table_relation_node_v2(const ParseNode *node,
       *dblink_name_len = static_cast<int32_t>(node->children_[2]->children_[0]->str_len_);
     }
   }
-  if (OB_ISNULL(session_info_)) {
+  if (OB_ISNULL(session_info_) || OB_ISNULL(allocator_)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("session is NULL", K(ret));
   } else if (OB_FAIL(session_info_->get_name_case_mode(mode))) {
@@ -152,7 +152,8 @@ int ObStmtResolver::resolve_table_relation_node_v2(const ParseNode *node,
           CK (OB_NOT_NULL(schema_checker_->get_schema_guard()));
           OZ (ObSQLUtils::cvt_db_name_to_org(*schema_checker_->get_schema_guard(),
                                              session_info_,
-                                             db_name));
+                                             db_name,
+                                             allocator_));
         }
       }
       if (OB_SUCCESS == ret && (OB_ERR_TOO_LONG_IDENT == tmp_ret || OB_WRONG_TABLE_NAME == tmp_ret)) {