#include <io
stream>
#include <f
stream>
#include <vector>
#include <map>
#include <algorithm>
#include <functional>
#include <cctype>
#include <memory>
#include <variant>
#include <regex>
#include <cmath>
#include <unordered_map>
#include <locale>
#include <iomanip>
#include <s
stream>
#ifdef _WIN32
#include <windows.h>
#include <io.h>
#include <fcntl.h>
#endif
// 基础类型定义
using Value = std::variant<int, double, std::
string, bool>;
using Row = std::vector<Value>;
using Table = std::vector<Row>;
using ColumnMap = std::unordered_map<std::
string, int>;
// 字符串处理函数
std::
string trim(const std::
string&
str) {
// 去除字符串两端的空白字符
size_t first =
str.find_first_not_of(" \t\n\r\f\v");
if (first == std::
string::npos) return "";
size_t last =
str.find_last_not_of(" \t\n\r\f\v");
return
str.sub
str(first, (last - first + 1));
}
// 改进的DBF编码转换函数
std::
string convertDBFToUTF8(const std::
string&
str) {
#ifdef _WIN32
if (
str.empty
()) return
str;
// 尝试从GBK转换为UTF-8
int len = MultiByteToWideChar(936, 0,
str.c_
str(), -1,
NULL, 0);
if (len > 0) {
wchar_t*
wstr = new wchar_t[len];
MultiByteToWideChar(936, 0,
str.c_
str(), -1,
wstr, len);
len = WideCharToMultiByte(CP_UTF8, 0,
wstr, -1,
NULL, 0,
NULL,
NULL);
if (len > 0) {
char* utf8
Str = new char[len];
WideCharToMultiByte(CP_UTF8, 0,
wstr, -1, utf8
Str, len,
NULL,
NULL);
std::
string result(utf8
Str);
delete[]
wstr;
delete[] utf8
Str;
return result;
}
delete[]
wstr;
}
return
str;
#else
return
str; // 非Windows平台直接返回
#endif
}
// 用于处理DBF字段名的函数
std::
string processDBFFieldName(const char* name, size_t len) {
std::
string fieldName(name, len);
fieldName = fieldName.sub
str(0, fieldName.find('\0'));
fieldName = trim(fieldName);
fieldName = convertDBFToUTF8(fieldName);
return fieldName;
}
// 用于处理DBF字符串字段的函数
std::
string processDBF
String(const char*
str, size_t len) {
std::
string result(
str, len);
result = trim(result);
result = convertDBFToUTF8(result);
return result;
}
struct FieldDescriptor {
char name[11];
char type;
uint32_t address;
uint8_t length;
uint8_t decimal;
};
struct DBFHeader {
uint8_t version;
uint8_t last_update[3];
uint32_t num_records;
uint16_t header_size;
uint16_t record_size;
};
// DBF 文件读取器
class DBFReader {
public:
DBFReader(const std::
string& filename) : filename(filename) {}
bool read
() {
std::if
stream file(filename, std::ios::binary);
if (!file) return false;
// 读取文件头
file.read(reinterpret_cast<char*>(&header), sizeof(DBFHeader));
// 读取字段描述
int num_fields = (header.header_size - sizeof(DBFHeader) - 1) / 32;
for (int i = 0; i < num_fields; ++i) {
FieldDescriptor fd;
file.read(reinterpret_cast<char*>(&fd), sizeof(FieldDescriptor));
fields.push_back(fd);
// 处理字段名
std::
string fieldName = processDBFFieldName(fd.name, sizeof(fd.name));
columnMap[fieldName] = i;
}
// 跳过文件头结束符
file.seekg(header.header_size);
// 读取记录
for (int i = 0; i < header.num_records; ++i) {
char delete_flag;
file.read(&delete_flag, 1);
if (delete_flag == '*') {
file.seekg(header.record_size - 1, std::ios::cur);
continue; // 跳过已删除记录
}
Row row;
for (size_t j = 0; j < fields.size
(); j++) {
const auto& field = fields[j];
char* buffer = new char[field.length + 1];
file.read(buffer, field.length);
buffer[field.length] = '\0';
// 转换数据类型
Value value;
switch (field.type) {
case 'N': // 数值
case 'I': // 整数
case 'F': // 浮点数
{
std::
string num
Str = trim(std::
string(buffer));
if (num
Str.empty
()) {
if (field.type == 'I') {
value = 0; // 整数默认值
} else {
value = 0.0; // 浮点数默认值
}
} else if (field.decimal > 0 || num
Str.find('.') != std::
string::npos) {
try {
value = std::stod(num
Str);
} catch (...) {
value = 0.0;
}
} else {
try {
value = std::stoi(num
Str);
} catch (...) {
value = 0;
}
}
}
break;
case 'D': // 日期 (格式: YYYYMMDD)
{
std::
string date
Str(buffer);
if (date
Str.length
() == 8 && std::all_of(date
Str.begin
(), date
Str.end
(), ::isdigit)) {
value = date
Str.sub
str(0, 4) + "-" + date
Str.sub
str(4, 2) + "-" + date
Str.sub
str(6, 2);
} else {
value = date
Str;
}
}
break;
case 'L': // 逻辑
{
char c = std::toupper(buffer[0]);
value = (c == 'T' || c == 'Y' || c == '1');
}
break;
case 'C': // 字符
case 'M': // 备注
default:
{
// 处理字符串字段
std::
string str = processDBF
String(buffer, field.length);
value =
str;
}
break;
}
row.push_back(value);
delete[] buffer;
}
data.push_back(row);
}
return true;
}
const Table& getData
() const { return data; }
const std::vector<FieldDescriptor>& getFields
() const { return fields; }
const ColumnMap& getColumnMap
() const { return columnMap; }
private:
std::
string parseDate(const char* buffer) {
// 简单日期转换: YYYYMMDD -> YYYY-MM-DD
std::
string date(buffer);
if (date.length
() == 8 &&
std::all_of(date.begin
(), date.end
(), ::isdigit)) {
return date.sub
str(0, 4) + "-" +
date.sub
str(4, 2) + "-" +
date.sub
str(6, 2);
}
return date;
}
std::
string filename;
DBFHeader header;
std::vector<FieldDescriptor> fields;
Table data;
ColumnMap columnMap;
};
// SQL 查询解析器
class SQLParser {
public:
enum TokenType {
SELECT, FROM, WHERE, INSERT, INTO, VALUES, UPDATE, SET, DELETE_TOKEN,
AND, OR, NOT, EQ, NEQ, LT, GT, LTE, GTE, COMMA, LPAREN, RPAREN,
IDENTIFIER,
STRING, NUMBER, BOOL, STAR, EOF_TOKEN
};
struct Token {
TokenType type;
std::
string value;
// 添加构造函数以支持初始化列表
Token(TokenType t) : type(t) {}
Token(TokenType t, const std::
string& v) : type(t), value(v) {}
};
explicit SQLParser(const std::
string& sql) : sql(sql), pos(0) {}
std::vector<Token> tokenize
() {
std::vector<Token> tokens;
while (pos < sql.size
()) {
char c = sql[pos];
if (std::isspace(c)) {
pos++;
continue;
}
// 处理标识符和关键字
if (std::isalpha(c) || c == '_') {
std::
string ident;
while (pos < sql.size
() &&
(std::isalnum(sql[pos]) || sql[pos] == '_')) {
ident += sql[pos++];
}
std::transform(ident.begin
(), ident.end
(), ident.begin
(), ::toupper);
if (ident == "SELECT") tokens.push_back(Token(SELECT));
else if (ident == "FROM") tokens.push_back(Token(FROM));
else if (ident == "WHERE") tokens.push_back(Token(WHERE));
else if (ident == "INSERT") tokens.push_back(Token(INSERT));
else if (ident == "INTO") tokens.push_back(Token(INTO));
else if (ident == "VALUES") tokens.push_back(Token(VALUES));
else if (ident == "UPDATE") tokens.push_back(Token(UPDATE));
else if (ident == "SET") tokens.push_back(Token(SET));
else if (ident == "DELETE") tokens.push_back(Token(DELETE_TOKEN));
else if (ident == "
AND") tokens.push_back(Token(
AND));
else if (ident == "OR") tokens.push_back(Token(OR));
else if (ident == "NOT") tokens.push_back(Token(NOT));
else if (ident == "TRUE" || ident == "FALSE") {
tokens.push_back(Token(BOOL, ident));
}
else {
tokens.push_back(Token(IDENTIFIER, ident));
}
continue;
}
// 处理数字
if (std::isdigit(c) || c == '.') {
std::
string num;
bool hasDecimal = false;
while (pos < sql.size
() &&
(std::isdigit(sql[pos]) || sql[pos] == '.')) {
if (sql[pos] == '.') {
if (hasDecimal) break;
hasDecimal = true;
}
num += sql[pos++];
}
tokens.push_back(Token(NUMBER, num));
continue;
}
// 处理字符串
if (c == '\'') {
pos++;
std::
string str;
while (pos < sql.size
() && sql[pos] != '\'') {
if (sql[pos] == '\\' && pos + 1 < sql.size
()) {
pos++;
switch (sql[pos]) {
case 'n':
str += '\n'; break;
case 't':
str += '\t'; break;
case 'r':
str += '\r'; break;
default:
str += sql[pos]; break;
}
} else {
str += sql[pos];
}
pos++;
}
if (pos < sql.size
() && sql[pos] == '\'') pos++;
tokens.push_back(Token(
STRING,
str));
continue;
}
// 处理操作符
switch (c) {
case '*': tokens.push_back(Token(STAR)); break;
case ',': tokens.push_back(Token(COMMA)); break;
case '(': tokens.push_back(Token(LPAREN)); break;
case ')': tokens.push_back(Token(RPAREN)); break;
case '=': tokens.push_back(Token(EQ)); break;
case '<':
if (pos + 1 < sql.size
() && sql[pos + 1] == '>') {
tokens.push_back(Token(NEQ));
pos++;
} else if (pos + 1 < sql.size
() && sql[pos + 1] == '=') {
tokens.push_back(Token(LTE));
pos++;
} else {
tokens.push_back(Token(LT));
}
break;
case '>':
if (pos + 1 < sql.size
() && sql[pos + 1] == '=') {
tokens.push_back(Token(GTE));
pos++;
} else {
tokens.push_back(Token(GT));
}
break;
case '!':
if (pos + 1 < sql.size
() && sql[pos + 1] == '=') {
tokens.push_back(Token(NEQ));
pos++;
}
break;
}
pos++;
}
tokens.push_back(Token(EOF_TOKEN));
return tokens;
}
private:
std::
string sql;
size_t pos;
};
// SQL 查询执行引擎
class SQLExecutor {
public:
SQLExecutor(DBFReader& reader) : reader(reader) {}
Table execute(const std::
string& sql) {
SQLParser parser(sql);
auto tokens = parser.tokenize
();
if (tokens.empty
()) return {};
switch (tokens[0].type) {
case SQLParser::SELECT: return executeSelect(tokens);
case SQLParser::INSERT: return executeInsert(tokens);
case SQLParser::UPDATE: return executeUpdate(tokens);
case SQLParser::DELETE_TOKEN: return executeDelete(tokens);
default:
std::cerr << "Unsupported SQL statement" << std::endl;
return {};
}
}
private:
// SELECT 查询执行
Table executeSelect(const std::vector<SQLParser::Token>& tokens) {
Table result;
auto& data = reader.getData
();
auto& fields = reader.getFields
();
auto& columnMap = reader.getColumnMap
();
// 解析字段列表
std::vector<std::
string> selectedColumns;
size_t pos = 1; // 跳过SELECT
if (pos < tokens.size
() && tokens[pos].type == SQLParser::STAR) {
for (const auto& field : fields) {
std::
string fieldName = processDBFFieldName(field.name, sizeof(field.name));
selectedColumns.push_back(fieldName);
}
pos += 2; // 跳过 * 和 FROM
} else {
while (pos < tokens.size
() && tokens[pos].type != SQLParser::FROM) {
if (tokens[pos].type == SQLParser::IDENTIFIER) {
selectedColumns.push_back(tokens[pos].value);
}
pos++;
}
if (pos < tokens.size
()) pos++; // 跳过FROM
}
// 解析表名 (忽略，因为只有一个表)
if (pos < tokens.size
() && tokens[pos].type == SQLParser::IDENTIFIER) {
std::
string tableName = tokens[pos].value;
pos++;
}
// 解析WHERE条件
std::function<bool(const Row&)> condition = [](const Row&) { return true; };
if (pos < tokens.size
() && tokens[pos].type == SQLParser::WHERE) {
pos++;
condition = parseCondition(tokens, pos, columnMap);
}
// 执行查询
for (const auto& row : data) {
if (condition(row)) {
Row resultRow;
for (const auto& col : selectedColumns) {
// 尝试直接匹配
auto it = columnMap.find(col);
if (it != columnMap.end
()) {
resultRow.push_back(row[it->second]);
} else {
// 如果直接匹配失败，尝试其他可能的编码格式
bool found = false;
for (const auto& pair : columnMap) {
// 比较去除空格后的字段名
std::
string mapKey = pair.first;
std::
string reqKey = col;
// 去除空格
mapKey.erase(std::remove(mapKey.begin
(), mapKey.end
(), ' '), mapKey.end
());
reqKey.erase(std::remove(reqKey.begin
(), reqKey.end
(), ' '), reqKey.end
());
if (mapKey == reqKey) {
resultRow.push_back(row[pair.second]);
found = true;
break;
}
}
if (!found) {
resultRow.push_back(std::
string(""));
}
}
}
result.push_back(resultRow);
}
}
return result;
}
// INSERT 语句执行
Table executeInsert(const std::vector<SQLParser::Token>& tokens) {
size_t pos = 1; // 跳过INSERT
if (tokens[pos].type != SQLParser::INTO) {
std::cerr << "Expected INTO after INSERT" << std::endl;
return {};
}
pos++; // 跳过INTO
if (tokens[pos].type != SQLParser::IDENTIFIER) {
std::cerr << "Expected table name after INTO" << std::endl;
return {};
}
std::
string tableName = tokens[pos++].value;
if (tokens[pos].type != SQLParser::LPAREN) {
std::cerr << "Expected '(' after table name" << std::endl;
return {};
}
pos++; // 跳过'('
// 解析列名
std::vector<std::
string> columns;
while (pos < tokens.size
() && tokens[pos].type != SQLParser::RPAREN) {
if (tokens[pos].type == SQLParser::IDENTIFIER) {
columns.push_back(tokens[pos].value);
}
pos++;
if (tokens[pos].type == SQLParser::COMMA) pos++;
}
pos++; // 跳过')'
if (tokens[pos].type != SQLParser::VALUES) {
std::cerr << "Expected VALUES after column list" << std::endl;
return {};
}
pos++; // 跳过VALUES
if (tokens[pos].type != SQLParser::LPAREN) {
std::cerr << "Expected '(' after VALUES" << std::endl;
return {};
}
pos++; // 跳过'('
// 解析值
Row newRow;
while (pos < tokens.size
() && tokens[pos].type != SQLParser::RPAREN) {
if (tokens[pos].type == SQLParser::
STRING) {
newRow.push_back(tokens[pos].value);
}
else if (tokens[pos].type == SQLParser::NUMBER) {
if (tokens[pos].value.find('.') != std::
string::npos) {
newRow.push_back(std::stod(tokens[pos].value));
} else {
newRow.push_back(std::stoi(tokens[pos].value));
}
}
else if (tokens[pos].type == SQLParser::BOOL) {
newRow.push_back((tokens[pos].value == "TRUE"));
}
else if (tokens[pos].type == SQLParser::IDENTIFIER) {
// 假设为列名或其他不支持的类型，暂不处理
newRow.push_back(tokens[pos].value);
}
pos++;
if (tokens[pos].type == SQLParser::COMMA) pos++;
}
pos++; // 跳过')'
// 验证列数与值数一致
if (columns.size
() != newRow.size
()) {
std::cerr << "Column count does not match value count" << std::endl;
return {};
}
// 获取列映射
const auto& columnMap = reader.getColumnMap
();
const auto& fields = reader.getFields
();
// 构造完整行数据，按字段顺序填充
Row fullRow(fields.size
());
for (size_t i = 0; i < columns.size
(); ++i) {
auto it = columnMap.find(columns[i]);
if (it == columnMap.end
()) {
std::cerr << "Unknown column: " << columns[i] << std::endl;
return {};
}
fullRow[it->second] = newRow[i];
}
// 添加新行到数据表
const_cast<Table&>(reader.getData
()).push_back(fullRow);
// 返回新插入的行
Table result;
result.push_back(fullRow);
return result;
}
// UPDATE 语句执行
Table executeUpdate(const std::vector<SQLParser::Token>& tokens) {
size_t pos = 1; // 跳过UPDATE
if (tokens[pos].type != SQLParser::IDENTIFIER) {
std::cerr << "Expected table name after UPDATE" << std::endl;
return {};
}
std::
string tableName = tokens[pos++].value;
if (tokens[pos].type != SQLParser::SET) {
std::cerr << "Expected SET after table name in UPDATE" << std::endl;
return {};
}
pos++; // 跳过SET
// 解析更新字段
std::vector<std::pair<std::
string, Value>> updates;
while (pos < tokens.size
() && tokens[pos].type == SQLParser::IDENTIFIER) {
std::
string colName = tokens[pos++].value;
if (pos < tokens.size
() && tokens[pos].type == SQLParser::EQ) {
pos++; // 跳过=
Value value;
if (tokens[pos].type == SQLParser::
STRING) {
value = tokens[pos].value;
}
else if (tokens[pos].type == SQLParser::NUMBER) {
if (tokens[pos].value.find('.') != std::
string::npos) {
value = std::stod(tokens[pos].value);
} else {
value = std::stoi(tokens[pos].value);
}
}
else if (tokens[pos].type == SQLParser::BOOL) {
value = (tokens[pos].value == "TRUE");
}
pos++; // 跳过值
updates.push_back({colName, value});
}
if (pos < tokens.size
() && tokens[pos].type == SQLParser::COMMA) {
pos++; // 跳过逗号
}
}
// 解析WHERE条件
std::function<bool(const Row&)> condition = [](const Row&) { return true; };
if (pos < tokens.size
() && tokens[pos].type == SQLParser::WHERE) {
pos++;
condition = parseCondition(tokens, pos, reader.getColumnMap
());
}
// 执行更新
auto& data = const_cast<Table&>(reader.getData
()); // 移除const
const auto& columnMap = reader.getColumnMap
();
Table updatedRows;
for (auto& row : data) {
if (condition(row)) {
// 该行满足更新条件
for (const auto& [colName, value] : updates) {
auto it = columnMap.find(colName);
if (it != columnMap.end
()) {
row[it->second] = value;
}
}
updatedRows.push_back(row);
}
}
return updatedRows;
}
// DELETE 语句执行
Table executeDelete(const std::vector<SQLParser::Token>& tokens) {
// 实现删除逻辑
std::cout << "DELETE operation executed" << std::endl;
return {};
}
public:
// 解析WHERE条件
std::function<bool(const Row&)> parseCondition(
const std::vector<SQLParser::Token>& tokens,
size_t& pos,
const ColumnMap& columnMap)
{
// 递归解析条件表达式
return parseExpression(tokens, pos, columnMap);
}
std::function<bool(const Row&)> parseExpression(
const std::vector<SQLParser::Token>& tokens,
size_t& pos,
const ColumnMap& columnMap)
{
auto left = parseTerm(tokens, pos, columnMap);
while (pos < tokens.size
()) {
if (tokens[pos].type == SQLParser::
AND) {
pos++;
auto right = parseTerm(tokens, pos, columnMap);
return [=](const Row& row) {
return left(row) && right(row);
};
}
else if (tokens[pos].type == SQLParser::OR) {
pos++;
auto right = parseTerm(tokens, pos, columnMap);
return [=](const Row& row) {
return left(row) || right(row);
};
}
else {
break;
}
}
return left;
}
std::function<bool(const Row&)> parseTerm(
const std::vector<SQLParser::Token>& tokens,
size_t& pos,
const ColumnMap& columnMap)
{
if (tokens[pos].type == SQLParser::LPAREN) {
pos++;
auto expr = parseExpression(tokens, pos, columnMap);
if (tokens[pos].type == SQLParser::RPAREN) pos++;
return expr;
}
if (tokens[pos].type == SQLParser::NOT) {
pos++;
auto expr = parseTerm(tokens, pos, columnMap);
return [=](const Row& row) {
return !expr(row);
};
}
return parseComparison(tokens, pos, columnMap);
}
std::function<bool(const Row&)> parseComparison(
const std::vector<SQLParser::Token>& tokens,
size_t& pos,
const ColumnMap& columnMap)
{
if (pos >= tokens.size
()) return [](const Row&) { return false; };
std::
string colName = tokens[pos].value;
pos++;
if (pos >= tokens.size
()) return [](const Row&) { return false; };
SQLParser::TokenType op = tokens[pos].type;
pos++;
if (pos >= tokens.size
()) return [](const Row&) { return false; };
Value value;
if (tokens[pos].type == SQLParser::
STRING) {
value = tokens[pos].value;
}
else if (tokens[pos].type == SQLParser::NUMBER) {
if (tokens[pos].value.find('.') != std::
string::npos) {
value = std::stod(tokens[pos].value);
} else {
value = std::stoi(tokens[pos].value);
}
}
else if (tokens[pos].type == SQLParser::BOOL) {
value = (tokens[pos].value == "TRUE");
}
pos++;
// 查找字段索引
int colIndex = -1;
auto it = columnMap.find(colName);
if (it != columnMap.end
()) {
colIndex = it->second;
} else {
// 如果直接查找失败，尝试其他匹配方式
for (const auto& pair : columnMap) {
std::
string mapKey = pair.first;
std::
string reqKey = colName;
// 去除空格后比较
mapKey.erase(std::remove(mapKey.begin
(), mapKey.end
(), ' '), mapKey.end
());
reqKey.erase(std::remove(reqKey.begin
(), reqKey.end
(), ' '), reqKey.end
());
if (mapKey == reqKey) {
colIndex = pair.second;
break;
}
}
}
if (colIndex == -1) {
return [](const Row&) { return false; };
}
switch (op) {
case SQLParser::EQ:
return [=](const Row& row) {
return row[colIndex] == value;
};
case SQLParser::NEQ:
return [=](const Row& row) {
return row[colIndex] != value;
};
case SQLParser::LT:
return [=](const Row& row) {
return compareValues(row[colIndex], value) < 0;
};
case SQLParser::GT:
return [=](const Row& row) {
return compareValues(row[colIndex], value) > 0;
};
case SQLParser::LTE:
return [=](const Row& row) {
return compareValues(row[colIndex], value) <= 0;
};
case SQLParser::GTE:
return [=](const Row& row) {
return compareValues(row[colIndex], value) >= 0;
};
default:
return [](const Row&) { return false; };
}
}
int compareValues(const Value& a, const Value& b) {
if (a.index
() != b.index
()) {
// 尝试转换为相同类型
if (std::holds_alternative<int>(a) && std::holds_alternative<double>(b)) {
return compareValues(Value(static_cast<double>(std::get<0>(a))), b);
}
if (std::holds_alternative<double>(a) && std::holds_alternative<int>(b)) {
return compareValues(a, Value(static_cast<double>(std::get<0>(b))));
}
return 0; // 不同类型无法比较
}
switch (a.index
()) {
case 0: // int
return (std::get<0>(a) == std::get<0>(b)) ? 0 : (std::get<0>(a) < std::get<0>(b)) ? -1 : 1;
case 1: // double
return (std::get<1>(a) == std::get<1>(b)) ? 0 : (std::get<1>(a) < std::get<1>(b)) ? -1 : 1;
case 2: //
string
return std::get<2>(a).compare(std::get<2>(b));
case 3: // bool
return static_cast<int>(std::get<3>(a)) -
static_cast<int>(std::get<3>(b));
default:
return 0;
}
}
DBFReader& reader;
};
// 结果打印函数
void printTable(const Table& table, const std::vector<std::
string>& headers) {
// 计算列宽
std::vector<size_t> widths(headers.size
(), 0);
for (size_t i = 0; i < headers.size
(); i++) {
widths[i] = headers[i].size
();
}
for (const auto& row : table) {
for (size_t i = 0; i < row.size
(); i++) {
size_t len = 0;
std::visit([&](const auto& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, std::
string>) {
len = arg.size
();
} else if constexpr (std::is_same_v<T, int> ||
std::is_same_v<T, double>) {
std::o
stringstream oss;
oss << arg;
len = oss.
str().size
();
} else if constexpr (std::is_same_v<T, bool>) {
len = 5; // "false"的长度
}
}, row[i]);
widths[i] = std::max(widths[i], len);
}
}
// 打印表头
for (size_t i = 0; i < headers.size
(); i++) {
std::cout << std::left << std::setw(widths[i] + 2) << headers[i];
}
std::cout << "\n";
for (size_t i = 0; i < headers.size
(); i++) {
std::cout << std::
string(widths[i] + 2, '-');
}
std::cout << "\n";
// 打印数据
for (const auto& row : table) {
for (size_t i = 0; i < row.size
(); i++) {
std::visit([&](const auto& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, std::
string>) {
std::cout << std::left << std::setw(widths[i] + 2) << arg;
} else if constexpr (std::is_same_v<T, int>) {
std::cout << std::right << std::setw(widths[i] + 2) << arg;
} else if constexpr (std::is_same_v<T, double>) {
std::cout << std::fixed << std::setprecision(2)
<< std::right << std::setw(widths[i] + 2) << arg;
} else if constexpr (std::is_same_v<T, bool>) {
std::cout << std::right << std::setw(widths[i] + 2)
<< (arg ? "true" : "false");
}
}, row[i]);
}
std::cout << "\n";
}
}
int main
() {
#ifdef _WIN32
// 设置控制台代码页为UTF-8，支持中文输出
SetConsoleOutputCP(CP_UTF8);
SetConsoleCP(CP_UTF8);
// 设置本地化以支持宽字符输出
std::setlocale(LC_ALL, "zh_CN.UTF-8");
#endif
// 读取DBF文件
DBFReader reader("d:\\employees.dbf");
if (!reader.read
()) {
std::cerr << "Failed to read DBF file. Please make sure 'employees.dbf' exists in the current directory." << std::endl;
// 列出当前目录下的文件以帮助调试
std::cout << "Files in current directory:" << std::endl;
system("dir *.dbf");
return 1;
}
std::cout << "DBF file read successfully." << std::endl;
// 创建SQL执行器
SQLExecutor executor(reader);
// 显示字段信息
std::cout << "Fields in DBF file:" << std::endl;
const auto& fields = reader.getFields
();
for (const auto& field : fields) {
std::
string fieldName = processDBFFieldName(field.name, sizeof(field.name));
std::cout << " " << fieldName << " (type: " << field.type << ", length: " << (int)field.length << ")" << std::endl;
}
// 显示记录数量
std::cout << "Total records: " << reader.getData
().size
() << std::endl;
// 执行SQL查询 - 显示所有记录
std::cout << "\nSQL: SELECT * FROM employees\n";
Table result = executor.execute("SELECT * FROM employees");
// 准备表头
std::vector<std::
string> headers;
for (const auto& field : reader.getFields
()) {
std::
string fieldName = processDBFFieldName(field.name, sizeof(field.name));
headers.push_back(fieldName);
}
// 打印结果
printTable(result, headers);
// 执行另一个查询 - 查询成绩大于80的学生
std::cout << "\nSQL: SELECT 姓名, 成绩 FROM employees WHERE 成绩 > 80\n";
result = executor.execute("SELECT 姓名, 成绩 FROM employees WHERE 成绩 > 80");
printTable(result, {"姓名", "成绩"});
// 查询特定班级的学生
std::cout << "\nSQL: SELECT 学号, 姓名, 班组 FROM employees WHERE 班组 = '一年一班 '\n";
result = executor.execute("SELECT 学号, 姓名, 班组 FROM employees WHERE 班组 = '一年一班'");
printTable(result, {"学号", "姓名", "班组"});
return 0;
}以上代码，数据显示输出有中文乱码，请修复代码
本文介绍了如何在C++中实现宽字符（wchar_t）与窄字符（char）字符串之间的相互转换。通过设置本地环境来确保正确的编码转换，并提供了具体的实现代码示例。
string wstr2str(const wstring& wstr)
{// convert the wstring into string
string curLocale = setlocale(LC_ALL, NULL); 
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
