init push
This commit is contained in:
oceanbase-admin
364
src/sql/executor/ob_task.h
Normal file
364
src/sql/executor/ob_task.h
Normal file
@ -0,0 +1,364 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef OCEANBASE_SQL_EXECUTOR_OB_TASK_
|
||||
#define OCEANBASE_SQL_EXECUTOR_OB_TASK_
|
||||
|
||||
#include "share/ob_define.h"
|
||||
#include "sql/executor/ob_job.h"
|
||||
#include "lib/ob_name_id_def.h"
|
||||
#include "common/ob_partition_key.h"
|
||||
#include "share/rpc/ob_batch_proxy.h"
|
||||
|
||||
namespace oceanbase {
|
||||
namespace sql {
|
||||
class ObExecContext;
|
||||
class ObPhysicalPlan;
|
||||
class ObPhyOperator;
|
||||
class ObJob;
|
||||
class ObTaskInfo;
|
||||
class ObOpSpec;
|
||||
/*
|
||||
* To serialize a task to remote execution, you need to specify the following:
|
||||
* 1. Operator Tree
|
||||
* 2. Operator Input Array
|
||||
* 3. Query ID, Job ID, Task ID
|
||||
*/
|
||||
class ObTask {
|
||||
OB_UNIS_VERSION_V(1);
|
||||
|
||||
public:
|
||||
ObTask();
|
||||
virtual ~ObTask();
|
||||
void set_ob_task_id(const ObTaskID& ob_task_id)
|
||||
{
|
||||
ob_task_id_ = ob_task_id;
|
||||
}
|
||||
const ObTaskID& get_ob_task_id() const
|
||||
{
|
||||
return ob_task_id_;
|
||||
}
|
||||
void set_location_idx(int64_t location_idx)
|
||||
{
|
||||
location_idx_ = location_idx;
|
||||
}
|
||||
int64_t get_location_idx() const
|
||||
{
|
||||
return location_idx_;
|
||||
}
|
||||
void set_runner_server(const common::ObAddr& svr)
|
||||
{
|
||||
runner_svr_ = svr;
|
||||
}
|
||||
const common::ObAddr& get_runner_server() const
|
||||
{
|
||||
return runner_svr_;
|
||||
}
|
||||
void set_ctrl_server(const common::ObAddr& svr)
|
||||
{
|
||||
ctrl_svr_ = svr;
|
||||
}
|
||||
const common::ObAddr& get_ctrl_server() const
|
||||
{
|
||||
return ctrl_svr_;
|
||||
}
|
||||
void set_job(ObJob& job)
|
||||
{
|
||||
job_ = &job;
|
||||
}
|
||||
void set_serialize_param(ObExecContext& exec_ctx, ObPhyOperator& op_root, const ObPhysicalPlan& ser_phy_plan);
|
||||
void set_serialize_param(ObExecContext* exec_ctx, ObOpSpec* op_root, const ObPhysicalPlan* ser_phy_plan);
|
||||
void set_deserialize_param(ObExecContext& exec_ctx, ObPhysicalPlan& des_phy_plan);
|
||||
ObPhyOperator* get_root_op() const
|
||||
{
|
||||
return op_root_;
|
||||
}
|
||||
ObOpSpec* get_root_spec() const
|
||||
{
|
||||
return root_spec_;
|
||||
}
|
||||
const ObPhysicalPlan& get_des_phy_plan() const
|
||||
{
|
||||
return *des_phy_plan_;
|
||||
}
|
||||
const ObPhysicalPlan& get_ser_phy_plan() const
|
||||
{
|
||||
return *ser_phy_plan_;
|
||||
}
|
||||
ObExecContext* get_exec_context() const
|
||||
{
|
||||
return exec_ctx_;
|
||||
}
|
||||
inline void set_exec_context(ObExecContext* exec_ctx)
|
||||
{
|
||||
exec_ctx_ = exec_ctx;
|
||||
}
|
||||
inline void set_root_op(ObPhyOperator* root_op)
|
||||
{
|
||||
op_root_ = root_op;
|
||||
}
|
||||
inline void set_ser_phy_plan(const ObPhysicalPlan* ser_phy_plan)
|
||||
{
|
||||
ser_phy_plan_ = ser_phy_plan;
|
||||
}
|
||||
int add_partition_key(const common::ObPartitionKey& pkey)
|
||||
{
|
||||
return partition_keys_.push_back(pkey);
|
||||
}
|
||||
|
||||
int add_range(const common::ObNewRange& range)
|
||||
{
|
||||
return ranges_.push_back(range);
|
||||
}
|
||||
|
||||
void set_max_sql_no(int64_t max_sql_no)
|
||||
{
|
||||
max_sql_no_ = max_sql_no;
|
||||
}
|
||||
// const common::ObPartitionIArray &get_partition_keys() const { return partition_keys_; }
|
||||
const common::ObIArray<ObNewRange>& get_ranges() const
|
||||
{
|
||||
return ranges_;
|
||||
}
|
||||
int assign_ranges(const ObIArray<ObNewRange>& ranges);
|
||||
const common::ObPartitionArray& get_partition_keys() const
|
||||
{
|
||||
return partition_keys_;
|
||||
}
|
||||
static int build_cte_op_pair(ObPhyOperator* root, common::ObIArray<ObPhyOperator*>& cte_pumps);
|
||||
TO_STRING_KV(
|
||||
N_OB_TASK_ID, ob_task_id_, K_(runner_svr), K_(ctrl_svr), K_(partition_keys), K_(ranges), K_(location_idx));
|
||||
DECLARE_TO_YSON_KV;
|
||||
|
||||
protected:
|
||||
int serialize_tree(char* buf, int64_t buf_len, int64_t& pos, const ObPhyOperator& root) const;
|
||||
int deserialize_tree(const char* buf, int64_t data_len, int64_t& pos, ObPhysicalPlan& phy_plan, ObPhyOperator*& root);
|
||||
int64_t get_tree_serialize_size(const ObPhyOperator& root) const;
|
||||
|
||||
protected:
|
||||
ObExecContext* exec_ctx_;
|
||||
const ObPhysicalPlan* ser_phy_plan_;
|
||||
ObPhysicalPlan* des_phy_plan_;
|
||||
ObPhyOperator* op_root_;
|
||||
ObOpSpec* root_spec_;
|
||||
ObJob* job_;
|
||||
// the target machine to which ObTask will be sent
|
||||
common::ObAddr runner_svr_;
|
||||
// main control machine address, used to report status to the main control machine after remote execution
|
||||
common::ObAddr ctrl_svr_;
|
||||
ObTaskID ob_task_id_;
|
||||
int64_t location_idx_;
|
||||
common::ObPartitionArray partition_keys_;
|
||||
common::ObSEArray<ObNewRange, 32> ranges_;
|
||||
int64_t max_sql_no_;
|
||||
// DISALLOW_COPY_AND_ASSIGN(ObTask);
|
||||
};
|
||||
|
||||
inline void ObTask::set_serialize_param(
|
||||
ObExecContext& exec_ctx, ObPhyOperator& op_root, const ObPhysicalPlan& ser_phy_plan)
|
||||
{
|
||||
exec_ctx_ = &exec_ctx;
|
||||
op_root_ = &op_root;
|
||||
root_spec_ = NULL;
|
||||
ser_phy_plan_ = &ser_phy_plan;
|
||||
}
|
||||
|
||||
inline void ObTask::set_serialize_param(
|
||||
ObExecContext* exec_ctx, ObOpSpec* root_spec, const ObPhysicalPlan* ser_phy_plan)
|
||||
{
|
||||
exec_ctx_ = exec_ctx;
|
||||
op_root_ = NULL;
|
||||
root_spec_ = root_spec;
|
||||
ser_phy_plan_ = ser_phy_plan;
|
||||
}
|
||||
|
||||
inline void ObTask::set_deserialize_param(ObExecContext& exec_ctx, ObPhysicalPlan& des_phy_plan)
|
||||
{
|
||||
exec_ctx_ = &exec_ctx;
|
||||
des_phy_plan_ = &des_phy_plan;
|
||||
}
|
||||
|
||||
class ObMiniTask : public ObTask {
|
||||
OB_UNIS_VERSION_V(1);
|
||||
|
||||
public:
|
||||
ObMiniTask() : ObTask(), extend_root_(NULL), extend_root_spec_(NULL)
|
||||
{}
|
||||
~ObMiniTask()
|
||||
{}
|
||||
|
||||
inline void set_extend_root(ObPhyOperator* extend_root)
|
||||
{
|
||||
extend_root_ = extend_root;
|
||||
}
|
||||
inline const ObPhyOperator* get_extend_root() const
|
||||
{
|
||||
return extend_root_;
|
||||
}
|
||||
|
||||
inline void set_extend_root_spec(ObOpSpec* spec)
|
||||
{
|
||||
extend_root_spec_ = spec;
|
||||
}
|
||||
inline const ObOpSpec* get_extend_root_spec() const
|
||||
{
|
||||
return extend_root_spec_;
|
||||
}
|
||||
|
||||
TO_STRING_KV(K_(ob_task_id), K_(runner_svr), K_(ctrl_svr), K_(partition_keys), K_(ranges), K_(location_idx),
|
||||
KPC_(extend_root), KP_(extend_root_spec));
|
||||
|
||||
private:
|
||||
// For mini tasks, it is allowed to execute an extended plan when the main plan is executed,
|
||||
// this is mainly used to obtain the primary key of the conflict row of the unique index when
|
||||
// the conflict is checked. you can also bring back other column information of the conflicting
|
||||
// rowkey between the primary key and the local unique index to optimize the number of RPC
|
||||
ObPhyOperator* extend_root_;
|
||||
ObOpSpec* extend_root_spec_;
|
||||
};
|
||||
|
||||
class ObPingSqlTask {
|
||||
OB_UNIS_VERSION_V(1);
|
||||
|
||||
public:
|
||||
ObPingSqlTask();
|
||||
virtual ~ObPingSqlTask();
|
||||
TO_STRING_KV(K(trans_id_), K(sql_no_), K(task_id_), K(exec_svr_), K(part_keys_), K(cur_status_));
|
||||
|
||||
public:
|
||||
transaction::ObTransID trans_id_;
|
||||
uint64_t sql_no_;
|
||||
ObTaskID task_id_;
|
||||
common::ObAddr exec_svr_;
|
||||
common::ObPartitionArray part_keys_;
|
||||
int64_t cur_status_;
|
||||
};
|
||||
|
||||
class ObPingSqlTaskResult {
|
||||
OB_UNIS_VERSION_V(1);
|
||||
|
||||
public:
|
||||
ObPingSqlTaskResult();
|
||||
virtual ~ObPingSqlTaskResult();
|
||||
TO_STRING_KV(K(err_code_), K(ret_status_));
|
||||
|
||||
public:
|
||||
int err_code_;
|
||||
int64_t ret_status_;
|
||||
};
|
||||
|
||||
class ObDesExecContext;
|
||||
class ObRemoteTask : public obrpc::ObIFill {
|
||||
OB_UNIS_VERSION(1);
|
||||
|
||||
public:
|
||||
ObRemoteTask()
|
||||
: tenant_schema_version_(-1),
|
||||
sys_schema_version_(-1),
|
||||
runner_svr_(),
|
||||
ctrl_svr_(),
|
||||
task_id_(),
|
||||
remote_sql_info_(nullptr),
|
||||
session_info_(NULL),
|
||||
exec_ctx_(NULL),
|
||||
inner_alloc_("RemoteTask"),
|
||||
dependency_tables_(&inner_alloc_)
|
||||
{}
|
||||
~ObRemoteTask() = default;
|
||||
|
||||
void set_query_schema_version(int64_t tenant_schema_version, int64_t sys_schema_version)
|
||||
{
|
||||
tenant_schema_version_ = tenant_schema_version;
|
||||
sys_schema_version_ = sys_schema_version;
|
||||
}
|
||||
int64_t get_tenant_schema_version() const
|
||||
{
|
||||
return tenant_schema_version_;
|
||||
}
|
||||
int64_t get_sys_schema_version() const
|
||||
{
|
||||
return sys_schema_version_;
|
||||
}
|
||||
void set_session(ObSQLSessionInfo* session_info)
|
||||
{
|
||||
session_info_ = session_info;
|
||||
}
|
||||
void set_runner_svr(const common::ObAddr& runner_svr)
|
||||
{
|
||||
runner_svr_ = runner_svr;
|
||||
}
|
||||
const common::ObAddr& get_runner_svr() const
|
||||
{
|
||||
return runner_svr_;
|
||||
}
|
||||
void set_ctrl_server(const common::ObAddr& ctrl_svr)
|
||||
{
|
||||
ctrl_svr_ = ctrl_svr;
|
||||
}
|
||||
const common::ObAddr& get_ctrl_server() const
|
||||
{
|
||||
return ctrl_svr_;
|
||||
}
|
||||
void set_task_id(const ObTaskID& task_id)
|
||||
{
|
||||
task_id_ = task_id;
|
||||
}
|
||||
const ObTaskID& get_task_id() const
|
||||
{
|
||||
return task_id_;
|
||||
}
|
||||
void set_remote_sql_info(ObRemoteSqlInfo* remote_sql_info)
|
||||
{
|
||||
remote_sql_info_ = remote_sql_info;
|
||||
}
|
||||
const ObRemoteSqlInfo* get_remote_sql_info() const
|
||||
{
|
||||
return remote_sql_info_;
|
||||
}
|
||||
void set_exec_ctx(ObDesExecContext* exec_ctx)
|
||||
{
|
||||
exec_ctx_ = exec_ctx;
|
||||
}
|
||||
int assign_dependency_tables(const DependenyTableStore& dependency_tables);
|
||||
const DependenyTableStore& get_dependency_tables() const
|
||||
{
|
||||
return dependency_tables_;
|
||||
}
|
||||
int fill_buffer(char* buf, int64_t size, int64_t& filled_size) const
|
||||
{
|
||||
filled_size = 0;
|
||||
return serialize(buf, size, filled_size);
|
||||
}
|
||||
int64_t get_req_size() const
|
||||
{
|
||||
return get_serialize_size();
|
||||
}
|
||||
TO_STRING_KV(K_(tenant_schema_version), K_(sys_schema_version), K_(runner_svr), K_(ctrl_svr), K_(task_id),
|
||||
KPC_(remote_sql_info));
|
||||
DECLARE_TO_YSON_KV;
|
||||
|
||||
private:
|
||||
int64_t tenant_schema_version_;
|
||||
int64_t sys_schema_version_;
|
||||
common::ObAddr runner_svr_;
|
||||
common::ObAddr ctrl_svr_;
|
||||
ObTaskID task_id_;
|
||||
ObRemoteSqlInfo* remote_sql_info_;
|
||||
ObSQLSessionInfo* session_info_;
|
||||
ObDesExecContext* exec_ctx_;
|
||||
common::ModulePageAllocator inner_alloc_;
|
||||
DependenyTableStore dependency_tables_;
|
||||
};
|
||||
} // namespace sql
|
||||
} // namespace oceanbase
|
||||
#endif /* OCEANBASE_SQL_EXECUTOR_OB_TASK_ */
|
||||
//// end of header file
|
||||
Reference in New Issue
Block a user