小组成员:陈予曈、朱陈媛
 
 

170 lines
4.7 KiB

#include "gtest/gtest.h"
#include "leveldb/env.h"
#include "leveldb/db.h"
// 这个头文件是为了EncodeFixed32
#include "util/coding.h"
using namespace leveldb;
using Field = std::pair<std::string, std::string>;
using FieldArray = std::vector<std::pair<std::string, std::string>>;
constexpr int value_size = 2048;
constexpr int data_size = 128 << 20;
Status OpenDB(std::string dbName, DB **db) {
Options options;
options.create_if_missing = true;
return DB::Open(options, dbName, db);
}
std::string SerializeValue(const FieldArray& fields){
std::string value_str;
for(const auto& pair : fields){
std::string field = pair.first + ":" + pair.second;
uint32_t field_size = field.size();
char buffer[4];
EncodeFixed32(buffer, field_size);
value_str.append(buffer, 4);
value_str.append(field);
}
return value_str;
}
FieldArray ParseValue(const std::string& value_str){
FieldArray fields;
const char* data = value_str.data();
size_t length = value_str.size();
while (length >= 4) {
uint32_t field_size = DecodeFixed32(data);
if (length < 4 + field_size) {
break;
}
std::string field(data + 4, field_size);
//转义
size_t colon_pos = field.find(':');
std::string field_name = field.substr(0, colon_pos);
std::string field_value = field.substr(colon_pos + 1);
fields.push_back(std::make_pair(field_name,field_value));
data += 4 + field_size;
length -= 4 + field_size;
}
return fields;
}
std::string ExtractField(const std::string& value, const std::string& field_name) {
FieldArray fields = ParseValue(value);
for(const auto& field : fields){
if(field.first == field_name){
return field.second;
}
}
return "No such field_name";
}
std::vector<std::string> FindKeysByField(leveldb::DB* db, Field &field) {
std::vector<std::string> matching_keys;
leveldb::Iterator* it = db->NewIterator(leveldb::ReadOptions());
for (it->SeekToFirst(); it->Valid(); it->Next()) {
std::string key = it->key().ToString();
std::string value = it->value().ToString();
if (ExtractField(value, field.first) == field.second) {
matching_keys.push_back(key);
}
}
delete it;
return matching_keys;
}
//测试多字段-橙
TEST(TestSchema, Basic) {
DB *db;
if(OpenDB("testdb", &db).ok() == false) {
std::cerr << "open db failed" << std::endl;
abort();
}
std::string key = "k_1";
FieldArray fields = {
{"name", "Customer#000000001"},
{"address", "IVhzIApeRb"},
{"phone", "25-989-741-2988"}
};
// 序列化并插入
std::string value = SerializeValue(fields);
db->Put(WriteOptions(), key, value);
// 读取并反序列化
std::string value_ret;
db->Get(ReadOptions(), key, &value_ret);
auto fields_ret = ParseValue(value_ret);
//清理数据库
delete db;
}
// 测试 FindKeysByField 函数
/*
1.在测试中创建多个键值对,验证 FindKeysByField 能否正确地查找并返回匹配的键。
2.使用 FindKeysByField 查找字段值,检查它是否能够找到匹配的键。
*/
TEST(TestSchema, FindKeysByFieldTest) {
DB *db;
if (OpenDB("testdb", &db).ok() == false) {
std::cerr << "open db failed" << std::endl;
abort();
}
// 插入多个键值对
std::string key1 = "k_1";
FieldArray fields1 = {
{"name", "Customer#000000001"},
{"address", "IVhzIApeRb"},
{"phone", "25-989-741-2988"}
};
std::string value1 = SerializeValue(fields1);
db->Put(WriteOptions(), key1, value1);
std::string key2 = "k_2";
FieldArray fields2 = {
{"name", "Customer#000000002"},
{"address", "IVhzIApeRb"},
{"phone", "25-123-456-7890"}
};
std::string value2 = SerializeValue(fields2);
db->Put(WriteOptions(), key2, value2);
std::string key3 = "k_3";
FieldArray fields3 = {
{"name", "Customer#000000003"},
{"address", "TXkjZEdIrZ"},
{"phone", "25-555-888-1234"}
};
std::string value3 = SerializeValue(fields3);
db->Put(WriteOptions(), key3, value3);
// 测试 FindKeysByField
Field search_field = {"address", "IVhzIApeRb"};
std::vector<std::string> matching_keys = FindKeysByField(db, search_field);
EXPECT_EQ(matching_keys.size(), 2);
EXPECT_TRUE(std::find(matching_keys.begin(), matching_keys.end(), key1) != matching_keys.end());
EXPECT_TRUE(std::find(matching_keys.begin(), matching_keys.end(), key2) != matching_keys.end());
// 清理数据库
delete db;
}
int main(int argc, char** argv) {
// All tests currently run with the same read-only file limits.
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}