hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

reformat source code

Browse Source 
according to code styles, 'AccessModifierOffset' should be -2.
This commit is contained in:
gm
2021-06-16 15:48:42 +08:00
committed by MizuhaHimuraki
parent 8c4a2f26a6
commit 4a92b6d7df
3314 changed files with 23131 additions and 23401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/sql/resolver/cmd/ob_alter_system_resolver.h
View File

@ -23,7 +23,7 @@ class ObPartitionKey;
namespace sql {
class ObSystemCmdStmt;
class ObAlterSystemResolverUtil {
public:
public:
static int sanity_check(const ParseNode* parse_tree, ObItemType item_type);
// resolve opt_ip_port
@ -54,7 +54,7 @@ class ObAlterSystemResolverUtil {
#define DEF_SIMPLE_CMD_RESOLVER(name) \
class name : public ObSystemCmdResolver { \
public: \
public: \
name(ObResolverParams& params) : ObSystemCmdResolver(params) \
{} \
virtual ~name() \
@ -148,38 +148,38 @@ DEF_SIMPLE_CMD_RESOLVER(ObBackupSetEncryptionResolver);
DEF_SIMPLE_CMD_RESOLVER(ObBackupSetDecryptionResolver);
class ObPhysicalRestoreTenantResolver : public ObSystemCmdResolver {
public:
public:
ObPhysicalRestoreTenantResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
{}
virtual ~ObPhysicalRestoreTenantResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int resolve_decryption_passwd(obrpc::ObPhysicalRestoreTenantArg& arg);
};
class ObAlterSystemSetResolver : public ObSystemCmdResolver {
public:
public:
ObAlterSystemSetResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
{}
virtual ~ObAlterSystemSetResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int check_param_valid(int64_t tenant_id, const common::ObString& name_node, const common::ObString& value_node);
};
class ObSetConfigResolver : public ObSystemCmdResolver {
public:
public:
ObSetConfigResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
{}
virtual ~ObSetConfigResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int check_param_valid(int64_t tenant_id, const common::ObString& name_node, const common::ObString& value_node);
};

162
src/sql/resolver/cmd/ob_alter_system_stmt.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObFreezeStmt : public ObSystemCmdStmt {
public:
public:
ObFreezeStmt()
: ObSystemCmdStmt(stmt::T_FREEZE),
major_freeze_(false),
@ -74,7 +74,7 @@ class ObFreezeStmt : public ObSystemCmdStmt {
TO_STRING_KV(
N_STMT_TYPE, ((int)stmt_type_), K_(major_freeze), K(opt_server_list_), K(opt_tenant_ids_), K(opt_partition_key_));
private:
private:
bool major_freeze_;
// for major_freeze, it is ignore server list
// for minor_freeze, it is candidate server list
@ -88,7 +88,7 @@ class ObFreezeStmt : public ObSystemCmdStmt {
};
class ObFlushCacheStmt : public ObSystemCmdStmt {
public:
public:
ObFlushCacheStmt() : ObSystemCmdStmt(stmt::T_FLUSH_CACHE), flush_cache_arg_(), is_global_(false)
{}
virtual ~ObFlushCacheStmt()
@ -100,7 +100,7 @@ class ObFlushCacheStmt : public ObSystemCmdStmt {
};
class ObLoadBaselineStmt : public ObSystemCmdStmt {
public:
public:
ObLoadBaselineStmt() : ObSystemCmdStmt(stmt::T_LOAD_BASELINE), load_baseline_arg_()
{}
virtual ~ObLoadBaselineStmt()
@ -111,7 +111,7 @@ class ObLoadBaselineStmt : public ObSystemCmdStmt {
};
class ObFlushKVCacheStmt : public ObSystemCmdStmt {
public:
public:
ObFlushKVCacheStmt() : ObSystemCmdStmt(stmt::T_FLUSH_KVCACHE)
{}
virtual ~ObFlushKVCacheStmt()
@ -123,7 +123,7 @@ class ObFlushKVCacheStmt : public ObSystemCmdStmt {
};
class ObFlushIlogCacheStmt : public ObSystemCmdStmt {
public:
public:
ObFlushIlogCacheStmt() : ObSystemCmdStmt(stmt::T_FLUSH_ILOGCACHE), file_id_(0)
{}
virtual ~ObFlushIlogCacheStmt()
@ -134,7 +134,7 @@ class ObFlushIlogCacheStmt : public ObSystemCmdStmt {
};
class ObFlushDagWarningsStmt : public ObSystemCmdStmt {
public:
public:
ObFlushDagWarningsStmt() : ObSystemCmdStmt(stmt::T_FLUSH_DAG_WARNINGS)
{}
virtual ~ObFlushDagWarningsStmt()
@ -143,7 +143,7 @@ class ObFlushDagWarningsStmt : public ObSystemCmdStmt {
};
class ObAdminServerStmt : public ObSystemCmdStmt {
public:
public:
ObAdminServerStmt() : ObSystemCmdStmt(stmt::T_ADMIN_SERVER), op_(obrpc::ObAdminServerArg::ADD)
{}
@ -174,14 +174,14 @@ class ObAdminServerStmt : public ObSystemCmdStmt {
op_ = op;
}
private:
private:
obrpc::ObAdminServerArg::AdminServerOp op_;
obrpc::ObServerList server_list_;
common::ObZone zone_;
};
class ObAdminZoneStmt : public ObSystemCmdStmt {
public:
public:
ObAdminZoneStmt() : ObSystemCmdStmt(stmt::T_ADMIN_ZONE), arg_()
{}
@ -271,12 +271,12 @@ class ObAdminZoneStmt : public ObSystemCmdStmt {
return arg_;
}
private:
private:
obrpc::ObAdminZoneArg arg_;
};
class ObSwitchReplicaRoleStmt : public ObSystemCmdStmt {
public:
public:
ObSwitchReplicaRoleStmt() : ObSystemCmdStmt(stmt::T_SWITCH_REPLICA_ROLE)
{}
virtual ~ObSwitchReplicaRoleStmt()
@ -289,12 +289,12 @@ class ObSwitchReplicaRoleStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminSwitchReplicaRoleArg rpc_arg_;
};
class ObSwitchRSRoleStmt : public ObSystemCmdStmt {
public:
public:
ObSwitchRSRoleStmt() : ObSystemCmdStmt(stmt::T_SWITCH_RS_ROLE)
{}
virtual ~ObSwitchRSRoleStmt()
@ -307,12 +307,12 @@ class ObSwitchRSRoleStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminSwitchRSRoleArg rpc_arg_;
};
class ObChangeReplicaStmt : public ObSystemCmdStmt {
public:
public:
ObChangeReplicaStmt() : ObSystemCmdStmt(stmt::T_CHANGE_REPLICA)
{}
virtual ~ObChangeReplicaStmt()
@ -325,12 +325,12 @@ class ObChangeReplicaStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminChangeReplicaArg rpc_arg_;
};
class ObDropReplicaStmt : public ObSystemCmdStmt {
public:
public:
ObDropReplicaStmt() : ObSystemCmdStmt(stmt::T_DROP_REPLICA)
{}
virtual ~ObDropReplicaStmt()
@ -343,12 +343,12 @@ class ObDropReplicaStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminDropReplicaArg rpc_arg_;
};
class ObMigrateReplicaStmt : public ObSystemCmdStmt {
public:
public:
ObMigrateReplicaStmt() : ObSystemCmdStmt(stmt::T_MIGRATE_REPLICA)
{}
virtual ~ObMigrateReplicaStmt()
@ -361,12 +361,12 @@ class ObMigrateReplicaStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminMigrateReplicaArg rpc_arg_;
};
class ObReportReplicaStmt : public ObSystemCmdStmt {
public:
public:
ObReportReplicaStmt() : ObSystemCmdStmt(stmt::T_REPORT_REPLICA)
{}
virtual ~ObReportReplicaStmt()
@ -379,12 +379,12 @@ class ObReportReplicaStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminReportReplicaArg rpc_arg_;
};
class ObRecycleReplicaStmt : public ObSystemCmdStmt {
public:
public:
ObRecycleReplicaStmt() : ObSystemCmdStmt(stmt::T_RECYCLE_REPLICA)
{}
virtual ~ObRecycleReplicaStmt()
@ -397,12 +397,12 @@ class ObRecycleReplicaStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminRecycleReplicaArg rpc_arg_;
};
class ObAdminMergeStmt : public ObSystemCmdStmt {
public:
public:
ObAdminMergeStmt() : ObSystemCmdStmt(stmt::T_ADMIN_MERGE)
{}
virtual ~ObAdminMergeStmt()
@ -415,12 +415,12 @@ class ObAdminMergeStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminMergeArg rpc_arg_;
};
class ObClearRoottableStmt : public ObSystemCmdStmt {
public:
public:
ObClearRoottableStmt() : ObSystemCmdStmt(stmt::T_CLEAR_ROOT_TABLE)
{}
virtual ~ObClearRoottableStmt()
@ -433,12 +433,12 @@ class ObClearRoottableStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminClearRoottableArg rpc_arg_;
};
class ObRefreshSchemaStmt : public ObSystemCmdStmt {
public:
public:
ObRefreshSchemaStmt() : ObSystemCmdStmt(stmt::T_REFRESH_SCHEMA)
{}
virtual ~ObRefreshSchemaStmt()
@ -451,12 +451,12 @@ class ObRefreshSchemaStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminRefreshSchemaArg rpc_arg_;
};
class ObRefreshMemStatStmt : public ObSystemCmdStmt {
public:
public:
ObRefreshMemStatStmt() : ObSystemCmdStmt(stmt::T_REFRESH_MEMORY_STAT)
{}
virtual ~ObRefreshMemStatStmt()
@ -469,12 +469,12 @@ class ObRefreshMemStatStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminRefreshMemStatArg rpc_arg_;
};
class ObSetConfigStmt : public ObSystemCmdStmt {
public:
public:
ObSetConfigStmt() : ObSystemCmdStmt(stmt::T_ALTER_SYSTEM_SET_PARAMETER)
{}
virtual ~ObSetConfigStmt()
@ -487,12 +487,12 @@ class ObSetConfigStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminSetConfigArg rpc_arg_;
};
class ObSetTPStmt : public ObSystemCmdStmt {
public:
public:
ObSetTPStmt() : ObSystemCmdStmt(stmt::T_ALTER_SYSTEM_SETTP)
{}
virtual ~ObSetTPStmt()
@ -505,12 +505,12 @@ class ObSetTPStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminSetTPArg rpc_arg_;
};
class ObMigrateUnitStmt : public ObSystemCmdStmt {
public:
public:
ObMigrateUnitStmt() : ObSystemCmdStmt(stmt::T_MIGRATE_UNIT)
{}
virtual ~ObMigrateUnitStmt()
@ -523,12 +523,12 @@ class ObMigrateUnitStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(rpc_arg));
private:
private:
obrpc::ObAdminMigrateUnitArg rpc_arg_;
};
class ObClearLocationCacheStmt : public ObSystemCmdStmt {
public:
public:
ObClearLocationCacheStmt() : ObSystemCmdStmt(stmt::T_CLEAR_LOCATION_CACHE)
{}
virtual ~ObClearLocationCacheStmt()
@ -539,12 +539,12 @@ class ObClearLocationCacheStmt : public ObSystemCmdStmt {
return rpc_arg_;
}
private:
private:
obrpc::ObAdminClearLocationCacheArg rpc_arg_;
};
class ObReloadGtsStmt : public ObSystemCmdStmt {
public:
public:
ObReloadGtsStmt() : ObSystemCmdStmt(stmt::T_RELOAD_GTS)
{}
virtual ~ObReloadGtsStmt()
@ -552,7 +552,7 @@ class ObReloadGtsStmt : public ObSystemCmdStmt {
};
class ObReloadUnitStmt : public ObSystemCmdStmt {
public:
public:
ObReloadUnitStmt() : ObSystemCmdStmt(stmt::T_RELOAD_UNIT)
{}
virtual ~ObReloadUnitStmt()
@ -560,7 +560,7 @@ class ObReloadUnitStmt : public ObSystemCmdStmt {
};
class ObReloadServerStmt : public ObSystemCmdStmt {
public:
public:
ObReloadServerStmt() : ObSystemCmdStmt(stmt::T_RELOAD_SERVER)
{}
virtual ~ObReloadServerStmt()
@ -568,7 +568,7 @@ class ObReloadServerStmt : public ObSystemCmdStmt {
};
class ObReloadZoneStmt : public ObSystemCmdStmt {
public:
public:
ObReloadZoneStmt() : ObSystemCmdStmt(stmt::T_RELOAD_ZONE)
{}
virtual ~ObReloadZoneStmt()
@ -576,7 +576,7 @@ class ObReloadZoneStmt : public ObSystemCmdStmt {
};
class ObClearMergeErrorStmt : public ObSystemCmdStmt {
public:
public:
ObClearMergeErrorStmt() : ObSystemCmdStmt(stmt::T_CLEAR_MERGE_ERROR)
{}
virtual ~ObClearMergeErrorStmt()
@ -584,7 +584,7 @@ class ObClearMergeErrorStmt : public ObSystemCmdStmt {
};
class ObUpgradeVirtualSchemaStmt : public ObSystemCmdStmt {
public:
public:
ObUpgradeVirtualSchemaStmt() : ObSystemCmdStmt(stmt::T_UPGRADE_VIRTUAL_SCHEMA)
{}
virtual ~ObUpgradeVirtualSchemaStmt()
@ -592,7 +592,7 @@ class ObUpgradeVirtualSchemaStmt : public ObSystemCmdStmt {
};
class ObAdminUpgradeCmdStmt : public ObSystemCmdStmt {
public:
public:
enum AdminUpgradeOp {
BEGIN = 1,
END = 2,
@ -611,12 +611,12 @@ class ObAdminUpgradeCmdStmt : public ObSystemCmdStmt {
op_ = op;
}
private:
private:
AdminUpgradeOp op_;
};
class ObAdminRollingUpgradeCmdStmt : public ObSystemCmdStmt {
public:
public:
enum AdminUpgradeOp {
BEGIN = 1,
END = 2,
@ -635,12 +635,12 @@ class ObAdminRollingUpgradeCmdStmt : public ObSystemCmdStmt {
op_ = op;
}
private:
private:
AdminUpgradeOp op_;
};
class ObRestoreTenantStmt : public ObSystemCmdStmt {
public:
public:
ObRestoreTenantStmt() : ObSystemCmdStmt(stmt::T_RESTORE_TENANT), rpc_arg_()
{}
virtual ~ObRestoreTenantStmt()
@ -651,12 +651,12 @@ class ObRestoreTenantStmt : public ObSystemCmdStmt {
return rpc_arg_;
}
private:
private:
obrpc::ObRestoreTenantArg rpc_arg_;
};
class ObPhysicalRestoreTenantStmt : public ObSystemCmdStmt {
public:
public:
ObPhysicalRestoreTenantStmt() : ObSystemCmdStmt(stmt::T_PHYSICAL_RESTORE_TENANT), rpc_arg_()
{}
virtual ~ObPhysicalRestoreTenantStmt()
@ -667,12 +667,12 @@ class ObPhysicalRestoreTenantStmt : public ObSystemCmdStmt {
return rpc_arg_;
}
private:
private:
obrpc::ObPhysicalRestoreTenantArg rpc_arg_;
};
class ObRunJobStmt : public ObSystemCmdStmt {
public:
public:
ObRunJobStmt() : ObSystemCmdStmt(stmt::T_RUN_JOB)
{}
virtual ~ObRunJobStmt()
@ -683,12 +683,12 @@ class ObRunJobStmt : public ObSystemCmdStmt {
return rpc_arg_;
}
private:
private:
obrpc::ObRunJobArg rpc_arg_;
};
class ObRunUpgradeJobStmt : public ObSystemCmdStmt {
public:
public:
ObRunUpgradeJobStmt() : ObSystemCmdStmt(stmt::T_ADMIN_RUN_UPGRADE_JOB)
{}
virtual ~ObRunUpgradeJobStmt()
@ -699,12 +699,12 @@ class ObRunUpgradeJobStmt : public ObSystemCmdStmt {
return rpc_arg_;
}
private:
private:
obrpc::ObUpgradeJobArg rpc_arg_;
};
class ObStopUpgradeJobStmt : public ObSystemCmdStmt {
public:
public:
ObStopUpgradeJobStmt() : ObSystemCmdStmt(stmt::T_ADMIN_STOP_UPGRADE_JOB)
{}
virtual ~ObStopUpgradeJobStmt()
@ -715,12 +715,12 @@ class ObStopUpgradeJobStmt : public ObSystemCmdStmt {
return rpc_arg_;
}
private:
private:
obrpc::ObUpgradeJobArg rpc_arg_;
};
class ObRefreshTimeZoneInfoStmt : public ObSystemCmdStmt {
public:
public:
ObRefreshTimeZoneInfoStmt() : ObSystemCmdStmt(stmt::T_REFRESH_TIME_ZONE_INFO), tenant_id_(OB_INVALID_TENANT_ID)
{}
virtual ~ObRefreshTimeZoneInfoStmt()
@ -739,7 +739,7 @@ class ObRefreshTimeZoneInfoStmt : public ObSystemCmdStmt {
};
class ObCancelTaskStmt : public ObSystemCmdStmt {
public:
public:
ObCancelTaskStmt() : ObSystemCmdStmt(stmt::T_CANCEL_TASK), task_type_(share::MAX_SYS_TASK_TYPE), task_id_()
{}
virtual ~ObCancelTaskStmt()
@ -766,13 +766,13 @@ class ObCancelTaskStmt : public ObSystemCmdStmt {
return ret;
}
private:
private:
share::ObSysTaskType task_type_;
common::ObString task_id_;
};
class ObSetDiskValidStmt : public ObSystemCmdStmt {
public:
public:
ObSetDiskValidStmt() : ObSystemCmdStmt(stmt::T_SET_DISK_VALID), server_()
{}
virtual ~ObSetDiskValidStmt()
@ -783,7 +783,7 @@ class ObSetDiskValidStmt : public ObSystemCmdStmt {
};
class ObAddDiskStmt : public ObSystemCmdStmt {
public:
public:
ObAddDiskStmt() : ObSystemCmdStmt(stmt::T_ALTER_DISKGROUP_ADD_DISK)
{}
virtual ~ObAddDiskStmt()
@ -794,7 +794,7 @@ class ObAddDiskStmt : public ObSystemCmdStmt {
};
class ObDropDiskStmt : public ObSystemCmdStmt {
public:
public:
ObDropDiskStmt() : ObSystemCmdStmt(stmt::T_ALTER_DISKGROUP_DROP_DISK)
{}
virtual ~ObDropDiskStmt()
@ -805,7 +805,7 @@ class ObDropDiskStmt : public ObSystemCmdStmt {
};
class ObEnableSqlThrottleStmt : public ObSystemCmdStmt {
public:
public:
ObEnableSqlThrottleStmt()
: ObSystemCmdStmt(stmt::T_ENABLE_SQL_THROTTLE),
priority_(99),
@ -877,7 +877,7 @@ class ObEnableSqlThrottleStmt : public ObSystemCmdStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(priority), K_(rt), K_(io), K_(network), K_(cpu), K_(logical_reads),
K_(queue_time));
private:
private:
int64_t priority_;
double rt_;
int64_t io_;
@ -888,13 +888,13 @@ class ObEnableSqlThrottleStmt : public ObSystemCmdStmt {
};
class ObDisableSqlThrottleStmt : public ObSystemCmdStmt {
public:
public:
ObDisableSqlThrottleStmt() : ObSystemCmdStmt(stmt::T_DISABLE_SQL_THROTTLE)
{}
};
class ObChangeTenantStmt : public ObSystemCmdStmt {
public:
public:
ObChangeTenantStmt() : ObSystemCmdStmt(stmt::T_CHANGE_TENANT), tenant_id_(OB_INVALID_TENANT_ID)
{}
virtual ~ObChangeTenantStmt()
@ -913,7 +913,7 @@ class ObChangeTenantStmt : public ObSystemCmdStmt {
};
class ObArchiveLogStmt : public ObSystemCmdStmt {
public:
public:
ObArchiveLogStmt() : ObSystemCmdStmt(stmt::T_ARCHIVE_LOG), enable_(true)
{}
virtual ~ObArchiveLogStmt()
@ -928,12 +928,12 @@ class ObArchiveLogStmt : public ObSystemCmdStmt {
}
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(enable));
private:
private:
bool enable_;
};
class ObBackupDatabaseStmt : public ObSystemCmdStmt {
public:
public:
ObBackupDatabaseStmt() : ObSystemCmdStmt(stmt::T_BACKUP_DATABASE), tenant_id_(OB_INVALID_ID), incremental_(false)
{}
virtual ~ObBackupDatabaseStmt()
@ -962,13 +962,13 @@ class ObBackupDatabaseStmt : public ObSystemCmdStmt {
}
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(tenant_id), K_(incremental));
private:
private:
uint64_t tenant_id_;
bool incremental_;
};
class ObBackupManageStmt : public ObSystemCmdStmt {
public:
public:
ObBackupManageStmt()
: ObSystemCmdStmt(stmt::T_BACKUP_MANAGE),
tenant_id_(OB_INVALID_ID),
@ -1006,14 +1006,14 @@ class ObBackupManageStmt : public ObSystemCmdStmt {
}
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(tenant_id), K_(type), K_(value));
private:
private:
uint64_t tenant_id_;
obrpc::ObBackupManageArg::Type type_;
int64_t value_;
};
class ObBackupSetEncryptionStmt : public ObSystemCmdStmt {
public:
public:
ObBackupSetEncryptionStmt();
virtual ~ObBackupSetEncryptionStmt()
{}
@ -1029,14 +1029,14 @@ class ObBackupSetEncryptionStmt : public ObSystemCmdStmt {
TO_STRING_KV(
N_STMT_TYPE, ((int)stmt_type_), "mode", share::ObBackupEncryptionMode::to_str(mode_), K_(encrypted_passwd));
private:
private:
share::ObBackupEncryptionMode::EncryptionMode mode_;
char passwd_buf_[OB_MAX_PASSWORD_LENGTH];
ObString encrypted_passwd_;
};
class ObBackupSetDecryptionStmt : public ObSystemCmdStmt {
public:
public:
ObBackupSetDecryptionStmt();
virtual ~ObBackupSetDecryptionStmt()
{}
@ -1047,7 +1047,7 @@ class ObBackupSetDecryptionStmt : public ObSystemCmdStmt {
int add_passwd(const ObString& passwd);
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(pos), K_(passwd_array));
private:
private:
char passwd_array_[OB_MAX_PASSWORD_ARRAY_LENGTH];
int64_t pos_;
};

4
src/sql/resolver/cmd/ob_bootstrap_resolver.h
View File

@ -18,13 +18,13 @@
namespace oceanbase {
namespace sql {
class ObBootstrapResolver : public ObSystemCmdResolver {
public:
public:
explicit ObBootstrapResolver(ObResolverParams& params);
virtual ~ObBootstrapResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObBootstrapResolver);
};
} // namespace sql

4
src/sql/resolver/cmd/ob_bootstrap_stmt.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObBootstrapStmt : public ObSystemCmdStmt {
public:
public:
ObBootstrapStmt() : ObSystemCmdStmt(stmt::T_BOOTSTRAP), bootstrap_arg_()
{}
explicit ObBootstrapStmt(common::ObIAllocator* name_pool) : ObSystemCmdStmt(name_pool, stmt::T_BOOTSTRAP)
@ -49,7 +49,7 @@ class ObBootstrapStmt : public ObSystemCmdStmt {
}
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(bootstrap_arg));
public:
public:
obrpc::ObBootstrapArg bootstrap_arg_;
DISALLOW_COPY_AND_ASSIGN(ObBootstrapStmt);
};

4
src/sql/resolver/cmd/ob_clear_balance_task_stmt.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObClearBalanceTaskStmt : public ObSystemCmdStmt {
public:
public:
ObClearBalanceTaskStmt() : ObSystemCmdStmt(stmt::T_CLEAR_BALANCE_TASK), arg_()
{}
explicit ObClearBalanceTaskStmt(common::ObIAllocator* name_pool)
@ -44,7 +44,7 @@ class ObClearBalanceTaskStmt : public ObSystemCmdStmt {
return arg_;
}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObClearBalanceTaskStmt);
obrpc::ObAdminClearBalanceTaskArg arg_;
};

4
src/sql/resolver/cmd/ob_cmd_resolver.h
View File

@ -19,13 +19,13 @@
namespace oceanbase {
namespace sql {
class ObCMDResolver : public ObStmtResolver {
public:
public:
explicit ObCMDResolver(ObResolverParams& params) : ObStmtResolver(params)
{}
virtual ~ObCMDResolver()
{}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCMDResolver);
};
} // namespace sql

4
src/sql/resolver/cmd/ob_cmd_stmt.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObCMDStmt : public ObStmt, public ObICmd {
public:
public:
ObCMDStmt(common::ObIAllocator* name_pool, stmt::StmtType type) : ObStmt(name_pool, type)
{}
explicit ObCMDStmt(stmt::StmtType type) : ObStmt(type)
@ -31,7 +31,7 @@ class ObCMDStmt : public ObStmt, public ObICmd {
return get_stmt_type();
}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCMDStmt);
};
} // namespace sql

8
src/sql/resolver/cmd/ob_create_restore_point_resolver.h
View File

@ -18,20 +18,20 @@
namespace oceanbase {
namespace sql {
class ObCreateRestorePointResolver : public ObSystemCmdResolver {
public:
public:
explicit ObCreateRestorePointResolver(ObResolverParams& params);
virtual ~ObCreateRestorePointResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateRestorePointResolver);
// function members
private:
private:
// data members
};

4
src/sql/resolver/cmd/ob_create_restore_point_stmt.h
View File

@ -21,7 +21,7 @@
namespace oceanbase {
namespace sql {
class ObCreateRestorePointStmt : public ObSystemCmdStmt {
public:
public:
explicit ObCreateRestorePointStmt(common::ObIAllocator* name_pool)
: ObSystemCmdStmt(name_pool, stmt::T_CREATE_RESTORE_POINT), create_restore_point_arg_(), restore_point_name_()
{}
@ -49,7 +49,7 @@ class ObCreateRestorePointStmt : public ObSystemCmdStmt {
return restore_point_name_;
}
private:
private:
obrpc::ObCreateRestorePointArg create_restore_point_arg_;
ObString restore_point_name_;
DISALLOW_COPY_AND_ASSIGN(ObCreateRestorePointStmt);

8
src/sql/resolver/cmd/ob_drop_restore_point_resolver.h
View File

@ -18,20 +18,20 @@
namespace oceanbase {
namespace sql {
class ObDropRestorePointResolver : public ObSystemCmdResolver {
public:
public:
explicit ObDropRestorePointResolver(ObResolverParams& params);
virtual ~ObDropRestorePointResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObDropRestorePointResolver);
// function members
private:
private:
// data members
};

4
src/sql/resolver/cmd/ob_drop_restore_point_stmt.h
View File

@ -21,7 +21,7 @@
namespace oceanbase {
namespace sql {
class ObDropRestorePointStmt : public ObSystemCmdStmt {
public:
public:
explicit ObDropRestorePointStmt(common::ObIAllocator* name_pool)
: ObSystemCmdStmt(name_pool, stmt::T_DROP_RESTORE_POINT), drop_restore_point_arg_(), restore_point_name_()
{}
@ -48,7 +48,7 @@ class ObDropRestorePointStmt : public ObSystemCmdStmt {
return restore_point_name_;
}
private:
private:
obrpc::ObDropRestorePointArg drop_restore_point_arg_;
ObString restore_point_name_;
DISALLOW_COPY_AND_ASSIGN(ObDropRestorePointStmt);

4
src/sql/resolver/cmd/ob_empty_query_resolver.h
View File

@ -16,14 +16,14 @@
namespace oceanbase {
namespace sql {
class ObEmptyQueryResolver : public ObCMDResolver {
public:
public:
explicit ObEmptyQueryResolver(ObResolverParams& params) : ObCMDResolver(params)
{}
virtual ~ObEmptyQueryResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObEmptyQueryResolver);
};
} // namespace sql

4
src/sql/resolver/cmd/ob_empty_query_stmt.h
View File

@ -18,14 +18,14 @@
namespace oceanbase {
namespace sql {
class ObEmptyQueryStmt : public ObCMDStmt {
public:
public:
ObEmptyQueryStmt() : ObCMDStmt(stmt::T_EMPTY_QUERY)
{}
virtual ~ObEmptyQueryStmt()
{}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObEmptyQueryStmt);
};

4
src/sql/resolver/cmd/ob_kill_resolver.h
View File

@ -16,14 +16,14 @@
namespace oceanbase {
namespace sql {
class ObKillResolver : public ObCMDResolver {
public:
public:
explicit ObKillResolver(ObResolverParams& params) : ObCMDResolver(params)
{}
virtual ~ObKillResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObKillResolver);
};
} // namespace sql

4
src/sql/resolver/cmd/ob_kill_stmt.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObKillStmt : public ObCMDStmt {
public:
public:
ObKillStmt() : ObCMDStmt(stmt::T_KILL), is_query_(false), value_expr_(NULL)
{}
virtual ~ObKillStmt()
@ -40,7 +40,7 @@ class ObKillStmt : public ObCMDStmt {
return is_query_;
}
private:
private:
bool is_query_;
ObRawExpr* value_expr_;
DISALLOW_COPY_AND_ASSIGN(ObKillStmt);

4
src/sql/resolver/cmd/ob_load_data_resolver.h
View File

@ -21,7 +21,7 @@ class ObLoadDataStmt;
struct ObDataInFileStruct;
class ObLoadDataResolver : public ObCMDResolver {
public:
public:
explicit ObLoadDataResolver(ObResolverParams& params) : ObCMDResolver(params), current_scope_(T_LOAD_DATA_SCOPE)
{}
virtual ~ObLoadDataResolver()
@ -49,7 +49,7 @@ class ObLoadDataResolver : public ObCMDResolver {
int validate_stmt(ObLoadDataStmt* stmt);
int resolve_hints(const ParseNode& node);
private:
private:
enum ParameterEnum {
ENUM_OPT_LOCAL = 0,
ENUM_FILE_NAME,

8
src/sql/resolver/cmd/ob_load_data_stmt.h
View File

@ -129,7 +129,7 @@ struct ObDataInFileStruct {
};
class ObLoadDataHint {
public:
public:
ObLoadDataHint()
{
reset();
@ -155,13 +155,13 @@ class ObLoadDataHint {
TO_STRING_KV("Int Hint Item", common::ObArrayWrap<int64_t>(integer_values_, TOTAL_INT_ITEM), "String Hint Item",
common::ObArrayWrap<ObString>(string_values_, TOTAL_STRING_ITEM));
private:
private:
int64_t integer_values_[TOTAL_INT_ITEM];
ObString string_values_[TOTAL_STRING_ITEM];
};
class ObLoadDataStmt : public ObCMDStmt {
public:
public:
struct FieldOrVarStruct {
FieldOrVarStruct()
: field_or_var_name_(), column_id_(OB_INVALID_ID), column_type_(common::ObMaxType), is_table_column_(true)
@ -232,7 +232,7 @@ class ObLoadDataStmt : public ObCMDStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(load_args), K_(data_struct_in_file), K_(field_or_var_list),
K_(assignments), K_(hints), K_(is_default_table_columns));
private:
private:
ObLoadArgument load_args_;
ObDataInFileStruct data_struct_in_file_;
common::ObSEArray<FieldOrVarStruct, 4> field_or_var_list_;

78
src/sql/resolver/cmd/ob_resource_resolver.h
View File

@ -26,17 +26,17 @@ namespace sql {
template <class T>
class ObResourcePoolOptionResolver {
public:
public:
ObResourcePoolOptionResolver(){};
~ObResourcePoolOptionResolver(){};
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObResourcePoolOptionResolver);
public:
public:
int resolve_options(T* stmt, ParseNode* node) const;
private:
private:
int resolve_option(T* stmt, ParseNode* node) const;
int resolve_zone_list(T* stmt, ParseNode* node) const;
int resolve_unit_num_option(T* stmt, ParseNode* node) const;
@ -208,17 +208,17 @@ int ObResourcePoolOptionResolver<T>::resolve_zone_list(T* stmt, ParseNode* node)
// use template to reuse for alter unit.
template <class T>
class ObResourceUnitOptionResolver {
public:
public:
ObResourceUnitOptionResolver(){};
~ObResourceUnitOptionResolver(){};
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObResourceUnitOptionResolver);
public:
public:
int resolve_options(T* stmt, ParseNode* node) const;
private:
private:
int resolve_option(T* stmt, ParseNode* node) const;
};
@ -371,96 +371,96 @@ int ObResourceUnitOptionResolver<T>::resolve_option(T* stmt, ParseNode* option_n
* Resource Pool Resolver
**************************************************/
class ObCreateResourcePoolResolver : public ObCMDResolver {
public:
public:
explicit ObCreateResourcePoolResolver(ObResolverParams& params);
virtual ~ObCreateResourcePoolResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateResourcePoolResolver);
// function members
private:
private:
// data members
};
class ObSplitResourcePoolResolver : public ObCMDResolver {
public:
public:
explicit ObSplitResourcePoolResolver(ObResolverParams& params);
virtual ~ObSplitResourcePoolResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int resolve_split_pool_list(ObSplitResourcePoolStmt* stmt, const ParseNode& parse_node);
int resolve_corresponding_zone_list(ObSplitResourcePoolStmt* stmt, const ParseNode& parse_node);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObSplitResourcePoolResolver);
// function members
private:
private:
// data members
};
class ObMergeResourcePoolResolver : public ObCMDResolver {
public:
public:
explicit ObMergeResourcePoolResolver(ObResolverParams& params);
virtual ~ObMergeResourcePoolResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int resolve_old_merge_pool_list(ObMergeResourcePoolStmt* stmt, const ParseNode& parse_node);
int resolve_new_merge_pool_list(ObMergeResourcePoolStmt* stmt, const ParseNode& parse_node);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObMergeResourcePoolResolver);
// function members
private:
private:
// data members
};
class ObAlterResourcePoolResolver : public ObCMDResolver {
public:
public:
explicit ObAlterResourcePoolResolver(ObResolverParams& params);
virtual ~ObAlterResourcePoolResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObAlterResourcePoolResolver);
// function members
private:
private:
// data members
};
class ObDropResourcePoolResolver : public ObCMDResolver {
public:
public:
explicit ObDropResourcePoolResolver(ObResolverParams& params);
virtual ~ObDropResourcePoolResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObDropResourcePoolResolver);
// function members
private:
private:
// data members
};
@ -468,53 +468,53 @@ class ObDropResourcePoolResolver : public ObCMDResolver {
* Resource Unit Resolver
**************************************************/
class ObCreateResourceUnitResolver : public ObCMDResolver {
public:
public:
explicit ObCreateResourceUnitResolver(ObResolverParams& params);
virtual ~ObCreateResourceUnitResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateResourceUnitResolver);
// function members
private:
private:
// data members
};
class ObAlterResourceUnitResolver : public ObCMDResolver {
public:
public:
explicit ObAlterResourceUnitResolver(ObResolverParams& params);
virtual ~ObAlterResourceUnitResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObAlterResourceUnitResolver);
// function members
};
class ObDropResourceUnitResolver : public ObCMDResolver {
public:
public:
explicit ObDropResourceUnitResolver(ObResolverParams& params);
virtual ~ObDropResourceUnitResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObDropResourceUnitResolver);
// function members
private:
private:
// data members
};

32
src/sql/resolver/cmd/ob_resource_stmt.h
View File

@ -20,7 +20,7 @@ namespace oceanbase {
namespace sql {
class ObCreateResourcePoolStmt : public ObDDLStmt {
public:
public:
ObCreateResourcePoolStmt(common::ObIAllocator* name_pool)
: ObDDLStmt(name_pool, stmt::T_CREATE_RESOURCE_POOL), arg_(){};
ObCreateResourcePoolStmt() : ObDDLStmt(stmt::T_CREATE_RESOURCE_POOL), arg_(){};
@ -67,7 +67,7 @@ class ObCreateResourcePoolStmt : public ObDDLStmt {
return arg_;
}
private:
private:
obrpc::ObCreateResourcePoolArg arg_;
/* functions */
/* variables */
@ -75,7 +75,7 @@ class ObCreateResourcePoolStmt : public ObDDLStmt {
};
class ObSplitResourcePoolStmt : public ObDDLStmt {
public:
public:
ObSplitResourcePoolStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_SPLIT_RESOURCE_POOL), arg_()
{}
ObSplitResourcePoolStmt() : ObDDLStmt(stmt::T_SPLIT_RESOURCE_POOL), arg_()
@ -107,13 +107,13 @@ class ObSplitResourcePoolStmt : public ObDDLStmt {
return arg_;
}
private:
private:
obrpc::ObSplitResourcePoolArg arg_;
DISALLOW_COPY_AND_ASSIGN(ObSplitResourcePoolStmt);
};
class ObMergeResourcePoolStmt : public ObDDLStmt {
public:
public:
ObMergeResourcePoolStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_MERGE_RESOURCE_POOL), arg_()
{}
ObMergeResourcePoolStmt() : ObDDLStmt(stmt::T_MERGE_RESOURCE_POOL), arg_()
@ -141,13 +141,13 @@ class ObMergeResourcePoolStmt : public ObDDLStmt {
return arg_;
}
private:
private:
obrpc::ObMergeResourcePoolArg arg_;
DISALLOW_COPY_AND_ASSIGN(ObMergeResourcePoolStmt);
};
class ObAlterResourcePoolStmt : public ObDDLStmt {
public:
public:
ObAlterResourcePoolStmt(common::ObIAllocator* name_pool)
: ObDDLStmt(name_pool, stmt::T_ALTER_RESOURCE_POOL), arg_(){};
ObAlterResourcePoolStmt() : ObDDLStmt(stmt::T_ALTER_RESOURCE_POOL), arg_(){};
@ -189,7 +189,7 @@ class ObAlterResourcePoolStmt : public ObDDLStmt {
return arg_;
}
private:
private:
/* functions */
/* variables */
obrpc::ObAlterResourcePoolArg arg_;
@ -197,7 +197,7 @@ class ObAlterResourcePoolStmt : public ObDDLStmt {
};
class ObDropResourcePoolStmt : public ObDDLStmt {
public:
public:
ObDropResourcePoolStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_DROP_RESOURCE_POOL), arg_(){};
ObDropResourcePoolStmt() : ObDDLStmt(stmt::T_DROP_RESOURCE_POOL), arg_(){};
virtual ~ObDropResourcePoolStmt(){};
@ -222,7 +222,7 @@ class ObDropResourcePoolStmt : public ObDDLStmt {
return arg_;
}
private:
private:
/* functions */
/* variables */
obrpc::ObDropResourcePoolArg arg_;
@ -230,7 +230,7 @@ class ObDropResourcePoolStmt : public ObDDLStmt {
};
class ObCreateResourceUnitStmt : public ObDDLStmt {
public:
public:
ObCreateResourceUnitStmt(common::ObIAllocator* name_pool)
: ObDDLStmt(name_pool, stmt::T_CREATE_RESOURCE_UNIT), arg_(){};
ObCreateResourceUnitStmt() : ObDDLStmt(stmt::T_CREATE_RESOURCE_UNIT), arg_(){};
@ -288,7 +288,7 @@ class ObCreateResourceUnitStmt : public ObDDLStmt {
return arg_;
}
private:
private:
/* functions */
/* variables */
obrpc::ObCreateResourceUnitArg arg_;
@ -296,7 +296,7 @@ class ObCreateResourceUnitStmt : public ObDDLStmt {
};
class ObAlterResourceUnitStmt : public ObDDLStmt {
public:
public:
ObAlterResourceUnitStmt(common::ObIAllocator* name_pool)
: ObDDLStmt(name_pool, stmt::T_ALTER_RESOURCE_UNIT), arg_(){};
ObAlterResourceUnitStmt() : ObDDLStmt(stmt::T_ALTER_RESOURCE_UNIT), arg_(){};
@ -350,7 +350,7 @@ class ObAlterResourceUnitStmt : public ObDDLStmt {
return arg_;
}
private:
private:
/* functions */
/* variables */
obrpc::ObAlterResourceUnitArg arg_;
@ -358,7 +358,7 @@ class ObAlterResourceUnitStmt : public ObDDLStmt {
};
class ObDropResourceUnitStmt : public ObDDLStmt {
public:
public:
ObDropResourceUnitStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_DROP_RESOURCE_UNIT), arg_()
{}
ObDropResourceUnitStmt() : ObDDLStmt(stmt::T_DROP_RESOURCE_UNIT), arg_()
@ -385,7 +385,7 @@ class ObDropResourceUnitStmt : public ObDDLStmt {
return arg_;
}
private:
private:
/* functions */
/* variables */
obrpc::ObDropResourceUnitArg arg_;

4
src/sql/resolver/cmd/ob_set_names_resolver.h
View File

@ -18,13 +18,13 @@ namespace oceanbase {
namespace sql {
// resolver for both SET NAMES and SET CHARSET
class ObSetNamesResolver : public ObCMDResolver {
public:
public:
explicit ObSetNamesResolver(ObResolverParams& params);
virtual ~ObSetNamesResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObSetNamesResolver);
};

8
src/sql/resolver/cmd/ob_set_names_stmt.h
View File

@ -18,7 +18,7 @@ namespace oceanbase {
namespace sql {
// statement for both SET NAMES and SET CHARSET
class ObSetNamesStmt : public ObCMDStmt {
public:
public:
ObSetNamesStmt()
: ObCMDStmt(stmt::T_SET_NAMES), is_set_names_(true), is_default_charset_(false), is_default_collation_(false)
{}
@ -72,11 +72,11 @@ class ObSetNamesStmt : public ObCMDStmt {
TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(is_set_names), K_(is_default_charset), K_(is_default_collation),
K_(charset), K_(collation));
private:
private:
// types and constants
private:
private:
// function members
private:
private:
// data members
bool is_set_names_; // SET NAMES or SET CHARSET?
bool is_default_charset_;

4
src/sql/resolver/cmd/ob_set_transaction_resolver.h
View File

@ -17,13 +17,13 @@
namespace oceanbase {
namespace sql {
class ObSetTransactionResolver : public ObCMDResolver {
public:
public:
explicit ObSetTransactionResolver(ObResolverParams& params);
virtual ~ObSetTransactionResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int build_isolation_expr(ObRawExpr*& expr, int32_t level);
int build_access_expr(ObRawExpr*& expr, const bool is_read_only);
int scope_resolve(const ParseNode& parse_tree, share::ObSetVar::SetScopeType& scope);

20
src/sql/resolver/cmd/ob_show_resolver.h
View File

@ -16,15 +16,15 @@
namespace oceanbase {
namespace sql {
class ObShowResolver : public ObSelectResolver {
public:
public:
class ObShowResolverContext;
class ShowColumnInfo;
explicit ObShowResolver(ObResolverParams& params);
virtual ~ObShowResolver();
virtual int resolve(const ParseNode& parse_tree);
protected:
private:
protected:
private:
class ObSqlStrGenerator;
struct ObShowSqlSet;
int get_database_info(const ParseNode* databse_node, const common::ObString& database_name, uint64_t real_tenant_id,
@ -42,7 +42,7 @@ class ObShowResolver : public ObSelectResolver {
int process_select_type(ObSelectStmt* select_stmt, stmt::StmtType stmt_type, const ParseNode& parse_tree);
virtual int resolve_column_ref_expr(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObShowResolver);
}; // ObShowresolver
@ -107,7 +107,7 @@ struct ObShowResolver::ObShowSqlSet {
}; // ObShowSqlSet
class ObShowResolver::ObSqlStrGenerator {
public:
public:
ObSqlStrGenerator() : sql_buf_(NULL), sql_buf_pos_(0)
{}
virtual ~ObSqlStrGenerator()
@ -118,14 +118,14 @@ class ObShowResolver::ObSqlStrGenerator {
virtual int gen_limit_str(int64_t offset, int64_t row_cnt);
void assign_sql_str(common::ObString& sql_str);
private:
private:
char* sql_buf_;
int64_t sql_buf_pos_;
DISALLOW_COPY_AND_ASSIGN(ObSqlStrGenerator);
}; // ObSqlstrgenerator
class ObShowResolver::ObShowResolverContext {
public:
public:
ObShowResolverContext()
: cur_tenant_id_(common::OB_INVALID_ID),
actual_tenant_id_(common::OB_INVALID_ID),
@ -168,12 +168,12 @@ class ObShowResolver::ObShowResolverContext {
K_(show_database_id), K_(show_table_id), K_(stmt_type), K_(global_scope), K_(like_pattern), K_(like_escape),
K_(column_name));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObShowResolverContext);
}; // ObShowResolvercontext
class ObShowResolver::ShowColumnInfo {
public:
public:
ShowColumnInfo() : display_name_(), qualified_name_()
{}
~ShowColumnInfo()
@ -182,7 +182,7 @@ class ObShowResolver::ShowColumnInfo {
ObQualifiedName qualified_name_;
TO_STRING_KV(K_(display_name), K_(qualified_name));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ShowColumnInfo);
}; // ShowColumninfo

4
src/sql/resolver/cmd/ob_system_cmd_resolver.h
View File

@ -18,13 +18,13 @@
namespace oceanbase {
namespace sql {
class ObSystemCmdResolver : public ObStmtResolver {
public:
public:
explicit ObSystemCmdResolver(ObResolverParams& params) : ObStmtResolver(params)
{}
virtual ~ObSystemCmdResolver()
{}
private:
private:
/* functions */
/* variables */
DISALLOW_COPY_AND_ASSIGN(ObSystemCmdResolver);

4
src/sql/resolver/cmd/ob_system_cmd_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObSystemCmdStmt : public ObStmt, public ObICmd {
public:
public:
ObSystemCmdStmt(common::ObIAllocator* name_pool, stmt::StmtType type) : ObStmt(name_pool, type)
{}
explicit ObSystemCmdStmt(stmt::StmtType type) : ObStmt(type)
@ -30,7 +30,7 @@ class ObSystemCmdStmt : public ObStmt, public ObICmd {
return get_stmt_type();
}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObSystemCmdStmt);
};
} // namespace sql

8
src/sql/resolver/cmd/ob_variable_set_resolver.h
View File

@ -18,24 +18,24 @@
namespace oceanbase {
namespace sql {
class ObVariableSetResolver : public ObStmtResolver {
public:
public:
explicit ObVariableSetResolver(ObResolverParams& params);
virtual ~ObVariableSetResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObVariableSetResolver);
};
class ObAlterSessionSetResolver : public ObStmtResolver {
public:
public:
explicit ObAlterSessionSetResolver(ObResolverParams& params);
virtual ~ObAlterSessionSetResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObAlterSessionSetResolver);
};

6
src/sql/resolver/cmd/ob_variable_set_stmt.h
View File

@ -21,9 +21,9 @@
namespace oceanbase {
namespace sql {
class ObVariableSetStmt : public ObDDLStmt {
public:
public:
class VariableSetNode {
public:
public:
VariableSetNode()
: variable_name_(),
is_system_variable_(false),
@ -96,7 +96,7 @@ class ObVariableSetStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(actual_tenant_id), K_(variable_nodes));
private:
private:
uint64_t actual_tenant_id_;
common::ObArray<VariableSetNode, common::ModulePageAllocator, true> variable_nodes_;
bool has_global_variable_;