Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

(db/snapshot) Optimize snapshot mock db #2896

Merged
merged 6 commits into from
Jul 20, 2020
Merged

(db/snapshot) Optimize snapshot mock db #2896

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
6dfb0dd
Add mysql time statices
Jul 15, 2020
439fa38
Add detail timestamp recorder
Jul 17, 2020
8eebc43
Optimize snapshot mock DB
Jul 17, 2020
ffa86a0
Remove surplus space
Jul 17, 2020
c143472
Merge branch 'master' into snapshot-mock-o
BossZou Jul 20, 2020
7d61148
Updat meta test
Jul 20, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 4 additions & 3 deletions core/src/db/meta/MetaAdapter.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,7 @@ class MetaAdapter {
// TODO move select logic to here
auto session = CreateSession();
std::vector<typename T::Ptr> resources;
auto status = session->Select<T, snapshot::ID_TYPE>(snapshot::IdField::Name, id, resources);
auto status = session->Select<T, snapshot::ID_TYPE>(snapshot::IdField::Name, id, {}, resources);
if (status.ok() && !resources.empty()) {
// TODO: may need to check num of resources
resource = resources.at(0);
Expand All @@ -53,15 +53,16 @@ class MetaAdapter {
Status
SelectBy(const std::string& field, const U& value, std::vector<typename ResourceT::Ptr>& resources) {
auto session = CreateSession();
return session->Select<ResourceT, U>(field, value, resources);
return session->Select<ResourceT, U>(field, value, {}, resources);
}

template <typename ResourceT, typename U>
Status
SelectResourceIDs(std::vector<int64_t>& ids, const std::string& filter_field, const U& filter_value) {
std::vector<typename ResourceT::Ptr> resources;
auto session = CreateSession();
auto status = session->Select<ResourceT, U>(filter_field, filter_value, resources);
std::vector<std::string> target_attrs = {F_ID};
auto status = session->Select<ResourceT, U>(filter_field, filter_value, target_attrs, resources);
if (!status.ok()) {
return status;
}
Expand Down
175 changes: 117 additions & 58 deletions core/src/db/meta/MetaSession.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,7 @@
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

Expand All @@ -41,7 +42,8 @@ class MetaSession {
public:
template <typename ResourceT, typename U>
Status
Select(const std::string& field, const U& value, std::vector<typename ResourceT::Ptr>& resources);
Select(const std::string& field, const U& value, const std::vector<std::string>& target_attrs,
std::vector<typename ResourceT::Ptr>& resources);

template <typename ResourceT>
Status
Expand Down Expand Up @@ -90,7 +92,8 @@ class MetaSession {

template <typename T, typename U>
Status
MetaSession::Select(const std::string& field, const U& value, std::vector<typename T::Ptr>& resources) {
MetaSession::Select(const std::string& field, const U& value, const std::vector<std::string>& target_attrs,
std::vector<typename T::Ptr>& resources) {
MetaQueryContext context;
context.table_ = T::Name;

Expand All @@ -100,6 +103,11 @@ MetaSession::Select(const std::string& field, const U& value, std::vector<typena
context.filter_attrs_ = {{field, field_value}};
}

if (!target_attrs.empty()) {
context.all_required_ = false;
context.query_fields_ = target_attrs;
}

AttrsMapList attrs;
auto status = db_engine_->Query(context, attrs);
if (!status.ok()) {
Expand All @@ -112,135 +120,186 @@ MetaSession::Select(const std::string& field, const U& value, std::vector<typena

for (auto raw : attrs) {
auto resource = snapshot::CreateResPtr<T>();

std::unordered_map<std::string, std::string>::iterator iter;
auto mf_p = std::dynamic_pointer_cast<snapshot::MappingsField>(resource);
if (mf_p != nullptr) {
std::string mapping = raw[F_MAPPINGS];
auto mapping_json = nlohmann::json::parse(mapping);
std::set<int64_t> mappings;
for (auto& ele : mapping_json) {
mappings.insert(ele.get<int64_t>());
iter = raw.find(F_MAPPINGS);
if (iter != raw.end()) {
auto mapping_json = nlohmann::json::parse(iter->second);
std::set<int64_t> mappings;
for (auto& ele : mapping_json) {
mappings.insert(ele.get<int64_t>());
}
mf_p->GetMappings() = mappings;
}
mf_p->GetMappings() = mappings;
}

auto sf_p = std::dynamic_pointer_cast<snapshot::StateField>(resource);
if (sf_p != nullptr) {
auto status_str = raw[F_STATE];
auto status_int = std::stol(status_str);
switch (static_cast<snapshot::State>(status_int)) {
case snapshot::PENDING: {
sf_p->ResetStatus();
break;
}
case snapshot::ACTIVE: {
sf_p->ResetStatus();
sf_p->Activate();
break;
}
case snapshot::DEACTIVE: {
sf_p->ResetStatus();
sf_p->Deactivate();
break;
iter = raw.find(F_STATE);
if (iter != raw.end()) {
auto status_int = std::stol(iter->second);
switch (static_cast<snapshot::State>(status_int)) {
case snapshot::PENDING: {
sf_p->ResetStatus();
break;
}
case snapshot::ACTIVE: {
sf_p->ResetStatus();
sf_p->Activate();
break;
}
case snapshot::DEACTIVE: {
sf_p->ResetStatus();
sf_p->Deactivate();
break;
}
default: { return Status(SERVER_UNSUPPORTED_ERROR, "Invalid state value"); }
}
default: { return Status(SERVER_UNSUPPORTED_ERROR, "Invalid state value"); }
}
}

auto lsn_f = std::dynamic_pointer_cast<snapshot::LsnField>(resource);
if (lsn_f != nullptr) {
auto lsn = std::stoul(raw[F_LSN]);
lsn_f->SetLsn(lsn);
iter = raw.find(F_LSN);
if (iter != raw.end()) {
auto lsn = std::stoul(iter->second);
lsn_f->SetLsn(lsn);
}
}

auto created_on_f = std::dynamic_pointer_cast<snapshot::CreatedOnField>(resource);
if (created_on_f != nullptr) {
auto created_on = std::stol(raw[F_CREATED_ON]);
created_on_f->SetCreatedTime(created_on);
iter = raw.find(F_CREATED_ON);
if (iter != raw.end()) {
auto created_on = std::stol(iter->second);
created_on_f->SetCreatedTime(created_on);
}
}

auto update_on_p = std::dynamic_pointer_cast<snapshot::UpdatedOnField>(resource);
if (update_on_p != nullptr) {
auto update_on = std::stol(raw[F_UPDATED_ON]);
update_on_p->SetUpdatedTime(update_on);
iter = raw.find(F_UPDATED_ON);
if (iter != raw.end()) {
auto update_on = std::stol(iter->second);
update_on_p->SetUpdatedTime(update_on);
}
}

auto id_p = std::dynamic_pointer_cast<snapshot::IdField>(resource);
if (id_p != nullptr) {
auto t_id = std::stol(raw[F_ID]);
id_p->SetID(t_id);
iter = raw.find(F_ID);
if (iter != raw.end()) {
auto t_id = std::stol(iter->second);
id_p->SetID(t_id);
}
}

auto cid_p = std::dynamic_pointer_cast<snapshot::CollectionIdField>(resource);
if (cid_p != nullptr) {
auto cid = std::stol(raw[F_COLLECTON_ID]);
cid_p->SetCollectionId(cid);
iter = raw.find(F_COLLECTON_ID);
if (iter != raw.end()) {
auto cid = std::stol(iter->second);
cid_p->SetCollectionId(cid);
}
}

auto sid_p = std::dynamic_pointer_cast<snapshot::SchemaIdField>(resource);
if (sid_p != nullptr) {
auto sid = std::stol(raw[F_SCHEMA_ID]);
sid_p->SetSchemaId(sid);
iter = raw.find(F_SCHEMA_ID);
if (iter != raw.end()) {
auto sid = std::stol(iter->second);
sid_p->SetSchemaId(sid);
}
}

auto num_p = std::dynamic_pointer_cast<snapshot::NumField>(resource);
if (num_p != nullptr) {
auto num = std::stol(raw[F_NUM]);
num_p->SetNum(num);
iter = raw.find(F_NUM);
if (iter != raw.end()) {
auto num = std::stol(iter->second);
num_p->SetNum(num);
}
}

auto ftype_p = std::dynamic_pointer_cast<snapshot::FtypeField>(resource);
if (ftype_p != nullptr) {
auto ftype = std::stol(raw[F_FTYPE]);
ftype_p->SetFtype(ftype);
iter = raw.find(F_FTYPE);
if (iter != raw.end()) {
auto ftype = std::stol(iter->second);
ftype_p->SetFtype(ftype);
}
}

auto fid_p = std::dynamic_pointer_cast<snapshot::FieldIdField>(resource);
if (fid_p != nullptr) {
auto fid = std::stol(raw[F_FIELD_ID]);
fid_p->SetFieldId(fid);
iter = raw.find(F_FIELD_ID);
if (iter != raw.end()) {
auto fid = std::stol(iter->second);
fid_p->SetFieldId(fid);
}
}

auto feid_p = std::dynamic_pointer_cast<snapshot::FieldElementIdField>(resource);
if (feid_p != nullptr) {
auto feid = std::stol(raw[F_FIELD_ELEMENT_ID]);
feid_p->SetFieldElementId(feid);
iter = raw.find(F_FIELD_ELEMENT_ID);
if (iter != raw.end()) {
auto feid = std::stol(iter->second);
feid_p->SetFieldElementId(feid);
}
}

auto pid_p = std::dynamic_pointer_cast<snapshot::PartitionIdField>(resource);
if (pid_p != nullptr) {
auto p_id = std::stol(raw[F_PARTITION_ID]);
pid_p->SetPartitionId(p_id);
iter = raw.find(F_PARTITION_ID);
if (iter != raw.end()) {
auto p_id = std::stol(iter->second);
pid_p->SetPartitionId(p_id);
}
}

auto sgid_p = std::dynamic_pointer_cast<snapshot::SegmentIdField>(resource);
if (sgid_p != nullptr) {
auto sg_id = std::stol(raw[F_SEGMENT_ID]);
sgid_p->SetSegmentId(sg_id);
iter = raw.find(F_SEGMENT_ID);
if (iter != raw.end()) {
auto sg_id = std::stol(iter->second);
sgid_p->SetSegmentId(sg_id);
}
}

auto name_p = std::dynamic_pointer_cast<snapshot::NameField>(resource);
if (name_p != nullptr) {
auto name = raw[F_NAME];
name_p->SetName(name);
iter = raw.find(F_NAME);
if (iter != raw.end()) {
name_p->SetName(iter->second);
}
}

auto pf_p = std::dynamic_pointer_cast<snapshot::ParamsField>(resource);
if (pf_p != nullptr) {
auto params = nlohmann::json::parse(raw[F_PARAMS]);
pf_p->SetParams(params);
iter = raw.find(F_PARAMS);
if (iter != raw.end()) {
auto params = nlohmann::json::parse(iter->second);
pf_p->SetParams(params);
}
}

auto size_p = std::dynamic_pointer_cast<snapshot::SizeField>(resource);
if (size_p != nullptr) {
auto size = std::stol(raw[F_SIZE]);
size_p->SetSize(size);
iter = raw.find(F_SIZE);
if (iter != raw.end()) {
auto size = std::stol(iter->second);
size_p->SetSize(size);
}
}

auto rc_p = std::dynamic_pointer_cast<snapshot::RowCountField>(resource);
if (rc_p != nullptr) {
auto rc = std::stol(raw[F_ROW_COUNT]);
rc_p->SetRowCount(rc);
iter = raw.find(F_ROW_COUNT);
if (iter != raw.end()) {
auto rc = std::stol(iter->second);
rc_p->SetRowCount(rc);
}
}

resources.push_back(std::move(resource));
Expand Down
Loading