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_;

2
src/sql/resolver/dcl/ob_alter_user_primary_zone_resolver.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObAlterUserPrimaryZoneResolver : public ObDCLResolver {
public:
public:
explicit ObAlterUserPrimaryZoneResolver(ObResolverParams& params);
virtual ~ObAlterUserPrimaryZoneResolver();
virtual int resolve(const ParseNode& parse_tree);

6
src/sql/resolver/dcl/ob_alter_user_primary_zone_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObAlterUserPrimaryZoneStmt : public ObDDLStmt {
public:
public:
ObAlterUserPrimaryZoneStmt();
explicit ObAlterUserPrimaryZoneStmt(common::ObIAllocator* name_pool);
virtual ~ObAlterUserPrimaryZoneStmt();
@ -44,11 +44,11 @@ class ObAlterUserPrimaryZoneStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(stmt_type), K_(arg));
public:
public:
// data members
obrpc::ObAlterDatabaseArg arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObAlterUserPrimaryZoneStmt);
};
} // end namespace sql

4
src/sql/resolver/dcl/ob_alter_user_profile_resolver.h
View File

@ -20,12 +20,12 @@
namespace oceanbase {
namespace sql {
class ObAlterUserProfileResolver : public ObDCLResolver {
public:
public:
explicit ObAlterUserProfileResolver(ObResolverParams& params);
virtual ~ObAlterUserProfileResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int resolve_set_role(const ParseNode& parse_tree);
int resolve_default_role(const ParseNode& parse_tree);
int resolve_default_role_clause(const ParseNode* parse_tree, obrpc::ObAlterUserProfileArg& arg,

6
src/sql/resolver/dcl/ob_alter_user_profile_stmt.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObAlterUserProfileStmt : public ObDDLStmt {
public:
public:
ObAlterUserProfileStmt();
explicit ObAlterUserProfileStmt(common::ObIAllocator* name_pool);
virtual ~ObAlterUserProfileStmt();
@ -37,12 +37,12 @@ class ObAlterUserProfileStmt : public ObDDLStmt {
return set_role_flag_;
}
private:
private:
// data members
obrpc::ObAlterUserProfileArg arg_;
int set_role_flag_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObAlterUserProfileStmt);
};
} // end namespace sql

4
src/sql/resolver/dcl/ob_create_role_resolver.h
View File

@ -17,13 +17,13 @@
namespace oceanbase {
namespace sql {
class ObCreateRoleResolver : public ObDCLResolver {
public:
public:
explicit ObCreateRoleResolver(ObResolverParams& params);
virtual ~ObCreateRoleResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateRoleResolver);
};

6
src/sql/resolver/dcl/ob_create_role_stmt.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObCreateRoleStmt : public ObDDLStmt {
public:
public:
explicit ObCreateRoleStmt(common::ObIAllocator* name_pool);
ObCreateRoleStmt();
virtual ~ObCreateRoleStmt();
@ -59,14 +59,14 @@ class ObCreateRoleStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
uint64_t tenant_id_;
common::ObString role_name_;
common::ObString password_;
obrpc::ObCreateRoleArg create_role_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCreateRoleStmt);
};
} // end namespace sql

4
src/sql/resolver/dcl/ob_create_user_resolver.h
View File

@ -17,13 +17,13 @@
namespace oceanbase {
namespace sql {
class ObCreateUserResolver : public ObDCLResolver {
public:
public:
explicit ObCreateUserResolver(ObResolverParams& params);
virtual ~ObCreateUserResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateUserResolver);
};

6
src/sql/resolver/dcl/ob_create_user_stmt.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObCreateUserStmt : public ObDDLStmt {
public:
public:
explicit ObCreateUserStmt(common::ObIAllocator* name_pool);
ObCreateUserStmt();
virtual ~ObCreateUserStmt();
@ -76,7 +76,7 @@ class ObCreateUserStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
uint64_t tenant_id_;
common::ObStrings users_; // (user1, host1, pass1, need_enc1;
@ -87,7 +87,7 @@ class ObCreateUserStmt : public ObDDLStmt {
uint64_t profile_id_; // only used in oracle mode
obrpc::ObCreateUserArg create_user_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCreateUserStmt);
};
} // end namespace sql

6
src/sql/resolver/dcl/ob_dcl_resolver.h
View File

@ -17,13 +17,13 @@
namespace oceanbase {
namespace sql {
class ObDCLResolver : public ObStmtResolver {
public:
public:
explicit ObDCLResolver(ObResolverParams& params) : ObStmtResolver(params)
{}
virtual ~ObDCLResolver()
{}
protected:
protected:
int check_and_convert_name(common::ObString& db, common::ObString& table);
int check_password_strength(common::ObString& password, common::ObString& user_name);
int check_number_count(common::ObString& password, const int64_t& number_count);
@ -36,7 +36,7 @@ class ObDCLResolver : public ObStmtResolver {
enum ObPasswordPolicy { LOW = 0, MEDIUM };
static const char password_mask_ = '*';
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObDCLResolver);
};
} // namespace sql

4
src/sql/resolver/dcl/ob_dcl_stmt.h
View File

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

4
src/sql/resolver/dcl/ob_drop_role_resolver.h
View File

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

6
src/sql/resolver/dcl/ob_drop_role_stmt.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObDropRoleStmt : public ObDDLStmt {
public:
public:
explicit ObDropRoleStmt(common::ObIAllocator* name_pool);
ObDropRoleStmt();
virtual ~ObDropRoleStmt();
@ -51,13 +51,13 @@ class ObDropRoleStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
uint64_t tenant_id_;
common::ObString role_name_;
obrpc::ObDropUserArg drop_role_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObDropRoleStmt);
};
} // end namespace sql

4
src/sql/resolver/dcl/ob_drop_user_resolver.h
View File

@ -17,13 +17,13 @@
namespace oceanbase {
namespace sql {
class ObDropUserResolver : public ObDCLResolver {
public:
public:
explicit ObDropUserResolver(ObResolverParams& params);
virtual ~ObDropUserResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObDropUserResolver);
};

6
src/sql/resolver/dcl/ob_drop_user_stmt.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObDropUserStmt : public ObDDLStmt {
public:
public:
explicit ObDropUserStmt(common::ObIAllocator* name_pool);
ObDropUserStmt();
virtual ~ObDropUserStmt();
@ -46,12 +46,12 @@ class ObDropUserStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
common::ObStrings users_; // user1,host1; usr2,host2;...
uint64_t tenant_id_;
obrpc::ObDropUserArg drop_user_arg_; // for returning exec_tenant_id_
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObDropUserStmt);
};
} // end namespace sql

6
src/sql/resolver/dcl/ob_grant_resolver.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObGrantResolver : public ObDCLResolver {
public:
public:
explicit ObGrantResolver(ObResolverParams& params);
virtual ~ObGrantResolver();
@ -60,7 +60,7 @@ class ObGrantResolver : public ObDCLResolver {
ObIArray<ObString>& user_name_array, const ObGrantStmt* grant_stmt, const ObString& user_name,
const ObString& host_name);
private:
private:
int build_table_priv_arary_for_all(
ObGrantStmt* grant_stmt, share::ObRawObjPrivArray& table_priv_array, bool is_owner);
int check_obj_priv_valid(ObGrantStmt* grant_stmt, share::ObRawObjPriv ora_obj_priv);
@ -74,7 +74,7 @@ class ObGrantResolver : public ObDCLResolver {
int check_duplicated_privs_with_info_ora(const ParseNode* privs_node, bool& duplicated_privs, bool& priv_has_execute);
static int trans_ora_sys_priv_to_obj(ParseNode* priv_type_node);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObGrantResolver);
};

6
src/sql/resolver/dcl/ob_grant_stmt.h
View File

@ -23,7 +23,7 @@ namespace oceanbase {
namespace sql {
class ObGrantStmt : public ObDDLStmt {
public:
public:
explicit ObGrantStmt(common::ObIAllocator* name_pool);
ObGrantStmt();
virtual ~ObGrantStmt();
@ -176,7 +176,7 @@ class ObGrantStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
ObPrivSet priv_set_;
share::schema::ObPrivLevel grant_level_;
@ -201,7 +201,7 @@ class ObGrantStmt : public ObDDLStmt {
ObSEArray<uint64_t, 4> ref_col_ids_;
ObSelectStmt* ref_query_; // when grant, check table,view privs.
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObGrantStmt);
};
} // end namespace sql

4
src/sql/resolver/dcl/ob_lock_user_resolver.h
View File

@ -17,12 +17,12 @@
namespace oceanbase {
namespace sql {
class ObLockUserResolver : public ObDCLResolver {
public:
public:
explicit ObLockUserResolver(ObResolverParams& params);
virtual ~ObLockUserResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObLockUserResolver);
};

6
src/sql/resolver/dcl/ob_lock_user_stmt.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObLockUserStmt : public ObDDLStmt {
public:
public:
ObLockUserStmt();
explicit ObLockUserStmt(common::ObIAllocator* name_pool);
virtual ~ObLockUserStmt();
@ -53,13 +53,13 @@ class ObLockUserStmt : public ObDDLStmt {
return true;
}
private:
private:
// data members
uint64_t tenant_id_;
common::ObStrings user_; // user1,host1; usr2,host2;...
bool locked_;
obrpc::ObLockUserArg lock_user_arg_; // for returning exec_tenant_id_
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObLockUserStmt);
};
} // end namespace sql

4
src/sql/resolver/dcl/ob_rename_user_resolver.h
View File

@ -17,13 +17,13 @@
namespace oceanbase {
namespace sql {
class ObRenameUserResolver : public ObDCLResolver {
public:
public:
explicit ObRenameUserResolver(ObResolverParams& params);
virtual ~ObRenameUserResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRenameUserResolver);
};

6
src/sql/resolver/dcl/ob_rename_user_stmt.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObRenameUserStmt : public ObDDLStmt {
public:
public:
explicit ObRenameUserStmt(common::ObIAllocator* name_pool);
ObRenameUserStmt();
virtual ~ObRenameUserStmt();
@ -42,14 +42,14 @@ class ObRenameUserStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
common::ObStrings rename_infos_; // (from1_user, from1_host, to1_user, to1_host), (from2_user, from2_host, to2_user,
// to2_host)
uint64_t tenant_id_;
obrpc::ObRenameUserArg rename_user_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRenameUserStmt);
};
} // end namespace sql

6
src/sql/resolver/dcl/ob_revoke_resolver.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObRevokeResolver : public ObDCLResolver {
private:
private:
int resolve_revoke_role_inner(const ParseNode* revoke_role, ObRevokeStmt* revoke_stmt);
int resolve_revoke_sysprivs_inner(const ParseNode* revoke_role, ObRevokeStmt* revoke_stmt);
int resolve_mysql(const ParseNode& parse_tree);
@ -27,13 +27,13 @@ class ObRevokeResolver : public ObDCLResolver {
share::ObRawObjPrivArray& obj_priv_array, bool& revoke_all_ora);
static int trans_ora_sys_priv_to_obj(ParseNode* priv_type_node);
public:
public:
explicit ObRevokeResolver(ObResolverParams& params);
virtual ~ObRevokeResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRevokeResolver);
};

6
src/sql/resolver/dcl/ob_revoke_stmt.h
View File

@ -21,7 +21,7 @@ namespace oceanbase {
namespace sql {
class ObRevokeStmt : public ObDDLStmt {
public:
public:
explicit ObRevokeStmt(common::ObIAllocator* name_pool);
ObRevokeStmt();
virtual ~ObRevokeStmt();
@ -123,7 +123,7 @@ class ObRevokeStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
ObPrivSet priv_set_;
share::schema::ObPrivLevel grant_level_;
@ -146,7 +146,7 @@ class ObRevokeStmt : public ObDDLStmt {
uint64_t grantor_id_;
bool revoke_all_ora_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRevokeStmt);
};
} // end namespace sql

6
src/sql/resolver/dcl/ob_set_password_resolver.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObSetPasswordResolver : public ObDCLResolver {
public:
public:
explicit ObSetPasswordResolver(ObResolverParams& params);
virtual ~ObSetPasswordResolver();
@ -27,11 +27,11 @@ class ObSetPasswordResolver : public ObDCLResolver {
static bool is_valid_mysql41_passwd(const common::ObString& str);
private:
private:
int resolve_oracle_password_strength(
common::ObString& user_name, common::ObString& hostname, common::ObString& password);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObSetPasswordResolver);
};

6
src/sql/resolver/dcl/ob_set_password_stmt.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObSetPasswordStmt : public ObDDLStmt {
public:
public:
explicit ObSetPasswordStmt(common::ObIAllocator* name_pool);
ObSetPasswordStmt();
virtual ~ObSetPasswordStmt();
@ -63,7 +63,7 @@ class ObSetPasswordStmt : public ObDDLStmt {
}
DECLARE_VIRTUAL_TO_STRING;
private:
private:
// data members
common::ObStrings user_pwd_; // username1, hostname1, passwd1;
// username2, hostname2, passwd2...
@ -73,7 +73,7 @@ class ObSetPasswordStmt : public ObDDLStmt {
bool for_current_user_;
obrpc::ObSetPasswdArg set_password_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObSetPasswordStmt);
};
} // end namespace sql

4
src/sql/resolver/ddl/ob_alter_baseline_resolver.h
View File

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

6
src/sql/resolver/ddl/ob_alter_baseline_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObAlterBaselineStmt : public ObDDLStmt {
public:
public:
ObAlterBaselineStmt() : ObDDLStmt(stmt::T_ALTER_BASELINE), alter_baseline_arg_()
{}
@ -28,10 +28,10 @@ class ObAlterBaselineStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(alter_baseline_arg));
public:
public:
obrpc::ObAlterPlanBaselineArg alter_baseline_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObAlterBaselineStmt);
};
} // namespace sql

4
src/sql/resolver/ddl/ob_alter_database_resolver.h
View File

@ -21,12 +21,12 @@ class ObAlterDatabaseResolver : public ObDDLResolver {
static const int64_t DATABASE_OPTION = 1;
static const int64_t DATABASE_NODE_COUNT = 2;
public:
public:
explicit ObAlterDatabaseResolver(ObResolverParams& params);
virtual ~ObAlterDatabaseResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObAlterDatabaseResolver);
};

4
src/sql/resolver/ddl/ob_alter_database_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObAlterDatabaseStmt : public ObDDLStmt {
public:
public:
ObAlterDatabaseStmt();
explicit ObAlterDatabaseStmt(common::ObIAllocator* name_pool);
virtual ~ObAlterDatabaseStmt();
@ -59,7 +59,7 @@ class ObAlterDatabaseStmt : public ObDDLStmt {
TO_STRING_KV(K_(alter_database_arg));
private:
private:
obrpc::ObAlterDatabaseArg alter_database_arg_;
};

4
src/sql/resolver/ddl/ob_alter_outline_resolver.h
View File

@ -17,14 +17,14 @@
namespace oceanbase {
namespace sql {
class ObAlterOutlineResolver : public ObOutlineResolver {
public:
public:
explicit ObAlterOutlineResolver(ObResolverParams& params) : ObOutlineResolver(params)
{}
virtual ~ObAlterOutlineResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
static const int64_t OUTLINE_CHILD_COUNT = 3;
DISALLOW_COPY_AND_ASSIGN(ObAlterOutlineResolver);
};

4
src/sql/resolver/ddl/ob_alter_outline_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObAlterOutlineStmt : public ObDDLStmt {
public:
public:
ObAlterOutlineStmt() : ObDDLStmt(stmt::T_ALTER_OUTLINE), alter_outline_arg_(), outline_stmt_(NULL)
{}
virtual ~ObAlterOutlineStmt()
@ -70,7 +70,7 @@ class ObAlterOutlineStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(alter_outline_arg), K_(outline_stmt));
private:
private:
obrpc::ObAlterOutlineArg alter_outline_arg_;
ObStmt* outline_stmt_; // the stmt for outline
DISALLOW_COPY_AND_ASSIGN(ObAlterOutlineStmt);

8
src/sql/resolver/ddl/ob_alter_sequence_resolver.h
View File

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

4
src/sql/resolver/ddl/ob_alter_table_resolver.h
View File

@ -26,7 +26,7 @@ class ObAlterTableResolver : public ObDDLResolver {
static const int64_t ALTER_TABLE_NODE_COUNT = 2;
static const int64_t TABLE = 0; // 0. table_node
static const int64_t ACTION_LIST = 1; // 1. alter table action list
public:
public:
explicit ObAlterTableResolver(ObResolverParams& params);
virtual ~ObAlterTableResolver();
virtual int resolve(const ParseNode& parse_tree);
@ -57,7 +57,7 @@ class ObAlterTableResolver : public ObDDLResolver {
};
int resolve_column_index(const common::ObString& column_name);
private:
private:
int check_dup_foreign_keys_exist(
share::schema::ObSchemaGetterGuard* schema_guard, const obrpc::ObCreateForeignKeyArg& foreign_key_arg);
int resolve_alter_table_option_list(const ParseNode& node);

4
src/sql/resolver/ddl/ob_alter_table_stmt.h
View File

@ -23,7 +23,7 @@ namespace oceanbase {
namespace sql {
class ObAlterTableStmt : public ObTableStmt {
public:
public:
explicit ObAlterTableStmt(common::ObIAllocator* name_pool);
ObAlterTableStmt();
virtual ~ObAlterTableStmt();
@ -129,7 +129,7 @@ class ObAlterTableStmt : public ObTableStmt {
}
INHERIT_TO_STRING_KV("ObTableStmt", ObTableStmt, K_(stmt_type), K_(alter_table_arg), K_(index_arg_list));
private:
private:
obrpc::ObAlterTableArg alter_table_arg_;
bool is_comment_table_;
bool is_alter_system_;

4
src/sql/resolver/ddl/ob_alter_tablegroup_resolver.h
View File

@ -22,7 +22,7 @@ class ObAlterTablegroupResolver : public ObTableGroupResolver {
static const int TG_NAME = 0;
static const int TABLE_LIST = 1;
public:
public:
explicit ObAlterTablegroupResolver(ObResolverParams& params);
virtual ~ObAlterTablegroupResolver();
virtual int resolve(const ParseNode& parse_tree);
@ -31,7 +31,7 @@ class ObAlterTablegroupResolver : public ObTableGroupResolver {
return static_cast<ObAlterTablegroupStmt*>(stmt_);
};
private:
private:
int resolve_partition_options(const ParseNode& node);
int resolve_add_partition(const ParseNode& node);
int resolve_drop_partition(const ParseNode& node);

4
src/sql/resolver/ddl/ob_alter_tablegroup_stmt.h
View File

@ -21,7 +21,7 @@ namespace oceanbase {
namespace sql {
class ObAlterTablegroupStmt : public ObTablegroupStmt {
public:
public:
explicit ObAlterTablegroupStmt(common::ObIAllocator* name_pool);
ObAlterTablegroupStmt();
virtual ~ObAlterTablegroupStmt();
@ -49,7 +49,7 @@ class ObAlterTablegroupStmt : public ObTablegroupStmt {
TO_STRING_KV(K_(alter_tablegroup_arg));
private:
private:
obrpc::ObAlterTablegroupArg alter_tablegroup_arg_;
DISALLOW_COPY_AND_ASSIGN(ObAlterTablegroupStmt);
};

4
src/sql/resolver/ddl/ob_create_database_resolver.h
View File

@ -22,12 +22,12 @@ class ObCreateDatabaseResolver : public ObDDLResolver {
static const int64_t DATABASE_OPTION = 2;
static const int64_t DATABASE_NODE_COUNT = 3;
public:
public:
explicit ObCreateDatabaseResolver(ObResolverParams& params);
virtual ~ObCreateDatabaseResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateDatabaseResolver);
};

4
src/sql/resolver/ddl/ob_create_database_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObCreateDatabaseStmt : public ObDDLStmt {
public:
public:
ObCreateDatabaseStmt();
explicit ObCreateDatabaseStmt(common::ObIAllocator* name_pool);
virtual ~ObCreateDatabaseStmt();
@ -48,7 +48,7 @@ class ObCreateDatabaseStmt : public ObDDLStmt {
TO_STRING_KV(K_(create_database_arg));
private:
private:
bool is_charset_specify_;
bool is_collation_specify_;
obrpc::ObCreateDatabaseArg create_database_arg_;

4
src/sql/resolver/ddl/ob_create_dblink_resolver.h
View File

@ -25,12 +25,12 @@ class ObCreateDbLinkResolver : public ObDDLResolver {
static const int64_t OPT_CLUSTER = 5;
static const int64_t DBLINK_NODE_COUNT = 6;
public:
public:
explicit ObCreateDbLinkResolver(ObResolverParams& params);
virtual ~ObCreateDbLinkResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateDbLinkResolver);
};

4
src/sql/resolver/ddl/ob_create_dblink_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObCreateDbLinkStmt : public ObDDLStmt {
public:
public:
ObCreateDbLinkStmt();
explicit ObCreateDbLinkStmt(common::ObIAllocator* name_pool);
virtual ~ObCreateDbLinkStmt();
@ -72,7 +72,7 @@ class ObCreateDbLinkStmt : public ObDDLStmt {
TO_STRING_KV(K_(create_dblink_arg));
private:
private:
obrpc::ObCreateDbLinkArg create_dblink_arg_;
};
} // namespace sql

2
src/sql/resolver/ddl/ob_create_func_resolver.h
View File

@ -23,7 +23,7 @@ namespace oceanbase {
namespace sql {
class ObCreateFuncResolver : public ObDDLResolver {
public:
public:
explicit ObCreateFuncResolver(ObResolverParams& params);
virtual ~ObCreateFuncResolver();

4
src/sql/resolver/ddl/ob_create_func_stmt.h
View File

@ -20,7 +20,7 @@ namespace oceanbase {
namespace sql {
class ObCreateFuncStmt : public ObDDLStmt {
public:
public:
ObCreateFuncStmt() : ObDDLStmt(stmt::T_CREATE_FUNC)
{}
~ObCreateFuncStmt()
@ -36,7 +36,7 @@ class ObCreateFuncStmt : public ObDDLStmt {
return create_func_arg_;
}
private:
private:
obrpc::ObCreateUserDefinedFunctionArg create_func_arg_;
DISALLOW_COPY_AND_ASSIGN(ObCreateFuncStmt);
};

6
src/sql/resolver/ddl/ob_create_index_resolver.h
View File

@ -21,14 +21,14 @@ class ObCreateIndexArg;
namespace sql {
class ObCreateIndexStmt;
class ObCreateIndexResolver : public ObDDLResolver {
public:
public:
static const int64_t CREATE_INDEX_CHILD_NUM = 7;
explicit ObCreateIndexResolver(ObResolverParams& params);
virtual ~ObCreateIndexResolver();
virtual int resolve(const ParseNode& parse_tree);
protected:
protected:
int resolve_index_name_node(ParseNode* index_name_node, ObCreateIndexStmt* crt_idx_stmt);
int resolve_index_table_name_node(ParseNode* index_table_name_node, ObCreateIndexStmt* crt_idx_stmt);
int resolve_index_column_node(ParseNode* index_column_node, const bool is_fulltext_index,
@ -41,7 +41,7 @@ class ObCreateIndexResolver : public ObDDLResolver {
int set_table_option_to_stmt();
int add_new_indexkey_for_oracle_temp_table();
private:
private:
bool is_oracle_temp_table_;
bool is_spec_block_size;
DISALLOW_COPY_AND_ASSIGN(ObCreateIndexResolver);

4
src/sql/resolver/ddl/ob_create_index_stmt.h
View File

@ -25,7 +25,7 @@ namespace sql {
class ObCreateIndexStmt : public ObPartitionedStmt {
const static int OB_DEFAULT_ARRAY_SIZE = 16;
public:
public:
explicit ObCreateIndexStmt(common::ObIAllocator* name_pool);
ObCreateIndexStmt();
virtual ~ObCreateIndexStmt();
@ -103,7 +103,7 @@ class ObCreateIndexStmt : public ObPartitionedStmt {
}
TO_STRING_KV(K_(stmt_type), K_(create_index_arg));
private:
private:
obrpc::ObCreateIndexArg create_index_arg_;
uint64_t table_id_;
DISALLOW_COPY_AND_ASSIGN(ObCreateIndexStmt);

4
src/sql/resolver/ddl/ob_create_outline_resolver.h
View File

@ -18,14 +18,14 @@ namespace oceanbase {
namespace sql {
class ObCreateOutlineStmt;
class ObCreateOutlineResolver : public ObOutlineResolver {
public:
public:
explicit ObCreateOutlineResolver(ObResolverParams& params) : ObOutlineResolver(params)
{}
virtual ~ObCreateOutlineResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int resolve_sql_id(const ParseNode* node, ObCreateOutlineStmt& create_outline_stmt);
int resolve_hint(const ParseNode* node, ObCreateOutlineStmt& create_outline_stmt);
static const int64_t OUTLINE_CHILD_COUNT = 5;

4
src/sql/resolver/ddl/ob_create_outline_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObCreateOutlineStmt : public ObDDLStmt {
public:
public:
ObCreateOutlineStmt()
: ObDDLStmt(stmt::T_CREATE_OUTLINE), create_outline_arg_(), max_concurrent_(-1), outline_stmt_(NULL)
{}
@ -106,7 +106,7 @@ class ObCreateOutlineStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(create_outline_arg), K_(outline_stmt));
private:
private:
obrpc::ObCreateOutlineArg create_outline_arg_;
common::ObString sql_id_;
common::ObString hint_;

4
src/sql/resolver/ddl/ob_create_profile_resolver.h
View File

@ -19,13 +19,13 @@ namespace oceanbase {
namespace sql {
class ObUserProfileResolver : public ObDDLResolver {
public:
public:
explicit ObUserProfileResolver(ObResolverParams& params);
virtual ~ObUserProfileResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int fill_arg(int64_t type, ObObj& value, obrpc::ObProfileDDLArg& arg);
int resolver_password_verify_function(const ParseNode* node, obrpc::ObProfileDDLArg& arg);
// disallow copy

6
src/sql/resolver/ddl/ob_create_profile_stmt.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObUserProfileStmt : public ObDDLStmt {
public:
public:
explicit ObUserProfileStmt(common::ObIAllocator* name_pool);
ObUserProfileStmt();
virtual ~ObUserProfileStmt();
@ -35,11 +35,11 @@ class ObUserProfileStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(create_profile_arg));
private:
private:
// data members
obrpc::ObProfileDDLArg create_profile_arg_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObUserProfileStmt);
};
} // end namespace sql

8
src/sql/resolver/ddl/ob_create_sequence_resolver.h
View File

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

4
src/sql/resolver/ddl/ob_create_synonym_resolver.h
View File

@ -22,12 +22,12 @@ namespace oceanbase {
namespace sql {
class ObCreateSynonymStmt;
class ObCreateSynonymResolver : public ObDDLResolver {
public:
public:
explicit ObCreateSynonymResolver(ObResolverParams& params);
virtual ~ObCreateSynonymResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int check_valid(const ObCreateSynonymStmt* synonym_stmt);
DISALLOW_COPY_AND_ASSIGN(ObCreateSynonymResolver);
};

6
src/sql/resolver/ddl/ob_create_synonym_stmt.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObCreateSynonymStmt : public ObDDLStmt {
public:
public:
const static int OB_DEFAULT_ARRAY_SIZE = 16;
explicit ObCreateSynonymStmt(common::ObIAllocator* name_pool);
ObCreateSynonymStmt();
@ -88,9 +88,9 @@ class ObCreateSynonymStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(create_synonym_arg));
private:
private:
// int set_table_id(ObStmtResolver &ctx, const uint64_t table_id);
private:
private:
obrpc::ObCreateSynonymArg create_synonym_arg_;
};

4
src/sql/resolver/ddl/ob_create_table_like_resolver.h
View File

@ -20,7 +20,7 @@ namespace oceanbase {
namespace sql {
class ObCreateTableLikeResolver : public ObDDLResolver {
public:
public:
explicit ObCreateTableLikeResolver(ObResolverParams& params);
virtual ~ObCreateTableLikeResolver();
virtual int resolve(const ParseNode& parse_tree);
@ -29,7 +29,7 @@ class ObCreateTableLikeResolver : public ObDDLResolver {
return static_cast<ObCreateTableLikeStmt*>(stmt_);
};
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCreateTableLikeResolver);
};

4
src/sql/resolver/ddl/ob_create_table_like_stmt.h
View File

@ -21,7 +21,7 @@ namespace oceanbase {
namespace sql {
class ObCreateTableLikeStmt : public ObDDLStmt {
public:
public:
explicit ObCreateTableLikeStmt(common::ObIAllocator* name_pool);
ObCreateTableLikeStmt();
virtual ~ObCreateTableLikeStmt();
@ -90,7 +90,7 @@ class ObCreateTableLikeStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(stmt_type), K_(create_table_like_arg));
private:
private:
obrpc::ObCreateTableLikeArg create_table_like_arg_;
};

8
src/sql/resolver/ddl/ob_create_table_resolver.h
View File

@ -24,7 +24,7 @@ namespace oceanbase {
namespace sql {
class ObCreateTableResolver : public ObDDLResolver {
public:
public:
// store generated column and its' dependent expr.
struct GenColExpr {
GenColExpr(uint64_t col_id, ObRawExpr* gen_col_expr) : col_id_(col_id), gen_col_expr_(gen_col_expr)
@ -43,10 +43,10 @@ class ObCreateTableResolver : public ObDDLResolver {
virtual int resolve(const ParseNode& parse_tree);
private:
private:
enum ResolveRule { RESOLVE_ALL = 0, RESOLVE_COL_ONLY, RESOLVE_NON_COL };
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateTableResolver);
// function members
@ -106,7 +106,7 @@ class ObCreateTableResolver : public ObDDLResolver {
bool is_uk_uk_duplicate(const ObIArray<int64_t>& uk_idx, const ObIArray<obrpc::ObCreateIndexArg>& index_arg_list);
int resolve_auto_partition(const ParseNode* partition_node);
private:
private:
// data members
uint64_t cur_column_id_;
common::ObSEArray<uint64_t, 16> primary_keys_;

8
src/sql/resolver/ddl/ob_create_table_stmt.h
View File

@ -21,7 +21,7 @@ namespace oceanbase {
namespace sql {
class ObCreateTableStmt : public ObTableStmt {
public:
public:
explicit ObCreateTableStmt(common::ObIAllocator* name_pool);
ObCreateTableStmt();
virtual ~ObCreateTableStmt();
@ -116,10 +116,10 @@ class ObCreateTableStmt : public ObTableStmt {
}
INHERIT_TO_STRING_KV("ObTableStmt", ObTableStmt, K_(stmt_type), K_(create_table_arg), K_(index_arg_list));
private:
private:
int set_table_id(ObStmtResolver& ctx, const uint64_t table_id);
private:
private:
obrpc::ObCreateTableArg create_table_arg_;
bool is_view_stmt_;
share::schema::ObStmtNeedPrivs::NeedPrivs view_need_privs_;
@ -134,7 +134,7 @@ class ObCreateTableStmt : public ObTableStmt {
// }
//
// create table xxx as already_exist_table, pay attention to whether data are need
protected:
protected:
ObSelectStmt* sub_select_stmt_; // create table ... as select...
ObSelectStmt* view_define_;
};

4
src/sql/resolver/ddl/ob_create_tablegroup_resolver.h
View File

@ -24,12 +24,12 @@ class ObCreateTablegroupResolver : public ObTableGroupResolver {
static const int64_t TABLEGROUP_OPTION = 2;
static const int64_t PARTITION_OPTION = 3;
public:
public:
explicit ObCreateTablegroupResolver(ObResolverParams& params);
virtual ~ObCreateTablegroupResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObCreateTablegroupResolver);
};

4
src/sql/resolver/ddl/ob_create_tablegroup_stmt.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObCreateTablegroupStmt : public ObTablegroupStmt {
public:
public:
ObCreateTablegroupStmt();
explicit ObCreateTablegroupStmt(common::ObIAllocator* name_pool);
virtual ~ObCreateTablegroupStmt();
@ -51,7 +51,7 @@ class ObCreateTablegroupStmt : public ObTablegroupStmt {
}
TO_STRING_KV(K_(create_tablegroup_arg));
private:
private:
obrpc::ObCreateTablegroupArg create_tablegroup_arg_;
DISALLOW_COPY_AND_ASSIGN(ObCreateTablegroupStmt);
};

8
src/sql/resolver/ddl/ob_create_tenant_resolver.h
View File

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

4
src/sql/resolver/ddl/ob_create_tenant_stmt.h
View File

@ -21,7 +21,7 @@
namespace oceanbase {
namespace sql {
class ObCreateTenantStmt : public ObDDLStmt {
public:
public:
explicit ObCreateTenantStmt(common::ObIAllocator* name_pool);
ObCreateTenantStmt();
virtual ~ObCreateTenantStmt();
@ -74,7 +74,7 @@ class ObCreateTenantStmt : public ObDDLStmt {
return create_tenant_arg_;
}
private:
private:
obrpc::ObCreateTenantArg create_tenant_arg_;
common::ObArray<ObVariableSetStmt::VariableSetNode, common::ModulePageAllocator, true> sys_var_nodes_;
DISALLOW_COPY_AND_ASSIGN(ObCreateTenantStmt);

6
src/sql/resolver/ddl/ob_create_view_resolver.h
View File

@ -35,13 +35,13 @@ class ObCreateViewResolver : public ObDDLResolver {
static const int64_t WITH_OPT_NODE = 6;
static const int64_t ROOT_NUM_CHILD = 7;
public:
public:
explicit ObCreateViewResolver(ObResolverParams& params);
virtual ~ObCreateViewResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
int resolve_column_list(ParseNode* view_columns_node, common::ObIArray<common::ObString>& column_list);
int check_select_stmt_col_name(SelectItem& select_item, ObArray<int64_t>& index_array, int64_t pos,
common::hash::ObHashSet<ObString>& view_col_names);
@ -54,7 +54,7 @@ class ObCreateViewResolver : public ObDDLResolver {
int stmt_print(
const ObSelectStmt* stmt, common::ObIArray<common::ObString>* column_list, common::ObString& expanded_view);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCreateViewResolver);
};
} // namespace sql

6
src/sql/resolver/ddl/ob_create_view_stmt.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObCreateViewStmt : public ObStmt {
public:
public:
explicit ObCreateViewStmt(common::ObIAllocator* name_pool);
ObCreateViewStmt();
virtual ~ObCreateViewStmt();
@ -38,10 +38,10 @@ class ObCreateViewStmt : public ObStmt {
return true;
}
protected:
protected:
common::ObIAllocator* name_pool_;
private:
private:
ObSelectStmt* definition_stmt_;
common::ObString view_name_;
common::ObString view_definition_;

10
src/sql/resolver/ddl/ob_database_resolver.h
View File

@ -23,15 +23,15 @@ namespace oceanbase {
namespace sql {
template <class T>
class ObDatabaseResolver {
public:
public:
ObDatabaseResolver() : alter_option_bitset_(), collation_already_set_(false)
{}
~ObDatabaseResolver(){};
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObDatabaseResolver);
public:
public:
static int resolve_primary_zone(T* stmt, ParseNode* node);
int resolve_database_options(T* stmt, ParseNode* node);
const common::ObBitSet<>& get_alter_option_bitset() const
@ -39,11 +39,11 @@ class ObDatabaseResolver {
return alter_option_bitset_;
};
private:
private:
int resolve_database_option(T* stmt, ParseNode* node);
int resolve_zone_list(T* stmt, ParseNode* node) const;
private:
private:
common::ObBitSet<> alter_option_bitset_;
bool collation_already_set_;
};

6
src/sql/resolver/ddl/ob_ddl_resolver.h
View File

@ -96,7 +96,7 @@ struct ObColumnResolveStat {
};
class ObDDLResolver : public ObStmtResolver {
public:
public:
enum INDEX_TYPE { NOT_SPECIFIED = 0, LOCAL_INDEX = 1, GLOBAL_INDEX = 2 };
enum INDEX_KEYNAME { NORMAL_KEY = 0, UNIQUE_KEY = 1, DOMAIN_KEY = 2 };
enum COLUMN_NODE {
@ -240,7 +240,7 @@ class ObDDLResolver : public ObStmtResolver {
int resolve_subpartition_option(
ObPartitionedStmt* stmt, ParseNode* subpart_node, share::schema::ObTableSchema& table_schema);
protected:
protected:
static int check_same_substr_expr(ObRawExpr& left, ObRawExpr& right, bool& same);
static int check_uniq_allow(ObResolverParams& params, share::schema::ObTableSchema& table_schema,
obrpc::ObCreateIndexArg& index_arg, ObRawExpr* part_func_expr, common::ObIArray<ObRawExpr*>& constraint_exprs,
@ -505,7 +505,7 @@ class ObDDLResolver : public ObStmtResolver {
int64_t table_dop_; // default value is 1
int64_t hash_subpart_num_;
private:
private:
template <typename STMT>
DISALLOW_COPY_AND_ASSIGN(ObDDLResolver);
};

4
src/sql/resolver/ddl/ob_ddl_stmt.h
View File

@ -20,7 +20,7 @@ namespace sql {
class ObDDLStmt : public ObStmt, public ObICmd {
const static int OB_DEFAULT_ARRAY_SIZE = 16;
public:
public:
ObDDLStmt(common::ObIAllocator* name_pool, stmt::StmtType type) : ObStmt(name_pool, type)
{}
explicit ObDDLStmt(stmt::StmtType type) : ObStmt(type)
@ -40,7 +40,7 @@ class ObDDLStmt : public ObStmt, public ObICmd {
}
virtual int get_first_stmt(common::ObString& first_stmt);
private:
private:
ObArenaAllocator allocator_;
DISALLOW_COPY_AND_ASSIGN(ObDDLStmt);
};

6
src/sql/resolver/ddl/ob_drop_database_resolver.h
View File

@ -16,7 +16,7 @@
namespace oceanbase {
namespace sql {
class ObDropDatabaseResolver : public ObDDLResolver {
public:
public:
const static int64_t IF_EXIST = 0;
const static int64_t DBNAME = 1;
const static int64_t DB_NODE_COUNT = 2;
@ -26,11 +26,11 @@ class ObDropDatabaseResolver : public ObDDLResolver {
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObDropDatabaseResolver);
private:
private:
// data members
};

4
src/sql/resolver/ddl/ob_drop_database_stmt.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObDropDatabaseStmt : public ObDDLStmt {
public:
public:
ObDropDatabaseStmt(common::ObIAllocator* name_pool)
: ObDDLStmt(name_pool, stmt::T_DROP_DATABASE), drop_database_arg_(), server_charset_(), server_collation_()
{}
@ -75,7 +75,7 @@ class ObDropDatabaseStmt : public ObDDLStmt {
drop_database_arg_.to_recyclebin_ = to_recyclebin;
}
private:
private:
obrpc::ObDropDatabaseArg drop_database_arg_;
common::ObString server_charset_;
common::ObString server_collation_;

4
src/sql/resolver/ddl/ob_drop_dblink_resolver.h
View File

@ -20,12 +20,12 @@ class ObDropDbLinkResolver : public ObDDLResolver {
static const int64_t DBLINK_NAME = 0;
static const int64_t DBLINK_NODE_COUNT = 1;
public:
public:
explicit ObDropDbLinkResolver(ObResolverParams& params);
virtual ~ObDropDbLinkResolver();
virtual int resolve(const ParseNode& parse_tree);
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObDropDbLinkResolver);
};

4
src/sql/resolver/ddl/ob_drop_dblink_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObDropDbLinkStmt : public ObDDLStmt {
public:
public:
ObDropDbLinkStmt();
explicit ObDropDbLinkStmt(common::ObIAllocator* name_pool);
virtual ~ObDropDbLinkStmt();
@ -47,7 +47,7 @@ class ObDropDbLinkStmt : public ObDDLStmt {
TO_STRING_KV(K_(drop_dblink_arg));
private:
private:
obrpc::ObDropDbLinkArg drop_dblink_arg_;
};
} // namespace sql

4
src/sql/resolver/ddl/ob_drop_func_resolver.h
View File

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

4
src/sql/resolver/ddl/ob_drop_func_stmt.h
View File

@ -17,7 +17,7 @@ namespace oceanbase {
namespace sql {
class ObDropFuncStmt : public ObDDLStmt {
public:
public:
ObDropFuncStmt() : ObDDLStmt(stmt::T_DROP_FUNC), drop_func_arg_()
{}
~ObDropFuncStmt()
@ -40,7 +40,7 @@ class ObDropFuncStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(drop_func_arg));
private:
private:
obrpc::ObDropUserDefinedFunctionArg drop_func_arg_;
DISALLOW_COPY_AND_ASSIGN(ObDropFuncStmt);
};

4
src/sql/resolver/ddl/ob_drop_index_resolver.h
View File

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

6
src/sql/resolver/ddl/ob_drop_index_stmt.h
View File

@ -21,7 +21,7 @@
namespace oceanbase {
namespace sql {
class ObDropIndexStmt : public ObDDLStmt {
public:
public:
explicit ObDropIndexStmt(common::ObIAllocator* name_pool);
ObDropIndexStmt();
virtual ~ObDropIndexStmt();
@ -56,10 +56,10 @@ class ObDropIndexStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(stmt_type), K_(drop_index_arg));
protected:
protected:
common::ObIAllocator* name_pool_;
private:
private:
obrpc::ObDropIndexArg drop_index_arg_;
uint64_t table_id_;
DISALLOW_COPY_AND_ASSIGN(ObDropIndexStmt);

4
src/sql/resolver/ddl/ob_drop_outline_resolver.h
View File

@ -17,14 +17,14 @@
namespace oceanbase {
namespace sql {
class ObDropOutlineResolver : public ObOutlineResolver {
public:
public:
explicit ObDropOutlineResolver(ObResolverParams& params) : ObOutlineResolver(params)
{}
virtual ~ObDropOutlineResolver()
{}
virtual int resolve(const ParseNode& parse_tree);
private:
private:
static const int64_t OUTLINE_CHILD_COUNT = 1;
DISALLOW_COPY_AND_ASSIGN(ObDropOutlineResolver);
};

4
src/sql/resolver/ddl/ob_drop_outline_stmt.h
View File

@ -18,7 +18,7 @@
namespace oceanbase {
namespace sql {
class ObDropOutlineStmt : public ObDDLStmt {
public:
public:
ObDropOutlineStmt() : ObDDLStmt(stmt::T_DROP_OUTLINE), drop_outline_arg_()
{}
~ObDropOutlineStmt()
@ -45,7 +45,7 @@ class ObDropOutlineStmt : public ObDDLStmt {
}
TO_STRING_KV(K_(drop_outline_arg));
private:
private:
obrpc::ObDropOutlineArg drop_outline_arg_;
DISALLOW_COPY_AND_ASSIGN(ObDropOutlineStmt);
};

Some files were not shown because too many files have changed in this diff Show More