#include <iostream>
#include <fstream>
#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 <sstream>
#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
.substr(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* utf8Str = new char[len];
WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8Str, len, NULL, NULL);
std
::string result(utf8Str);
delete[] wstr;
delete[] utf8Str;
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
.substr(0, fieldName
.find('\0'));
fieldName = trim(fieldName);
fieldName = convertDBFToUTF8(fieldName);
return fieldName;
}
// 用于处理DBF字符串字段的函数
std
::string processDBFString(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
::ifstream file(filename, std
::ios
::binary);
if (!file) return false;
// 读取文件头
file
.read(reinterpret_cast<char*>(&header), size
of(DBFHeader));
// 读取字段描述
int num_
fields = (header
.header_size - size
of(DBFHeader) - 1) / 32;
for (int i = 0; i < num_
fields; ++i) {
FieldDescriptor fd;
file
.read(reinterpret_cast<char*>(&fd), size
of(FieldDescriptor));
fields.push_back(fd);
// 处理字段名
std
::string fieldName = processDBFFieldName(fd
.name, size
of(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 numStr = trim(std
::string(buffer));
if (numStr
.empty()) {
if (field
.type == 'I') {
value = 0; // 整数默认值
} else {
value = 0
.0; // 浮点数默认值
}
} else if (field
.decimal > 0 || numStr
.find('
.') != std
::string
::npos) {
try {
value = std
::stod(numStr);
} catch (
...) {
value = 0
.0;
}
} else {
try {
value = std
::stoi(numStr);
} catch (
...) {
value = 0;
}
}
}
break;
case 'D'
: // 日期 (格式
: YYYYMMDD)
{
std
::string dateStr(buffer);
if (dateStr
.length() == 8 && std
::all_
of(dateStr
.begin(), dateStr
.end(),
::isdigit)) {
value = dateStr
.substr(0, 4) + "-" + dateStr
.substr(4, 2) + "-" + dateStr
.substr(6, 2);
} else {
value = dateStr;
}
}
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 = processDBFString(buffer, field
.length);
value = str;
}
break;
}
row
.push_back(value);
delete[] buffer;
}
data.push_back(row);
}
return true;
}
const Table& get
Data() const { return
data; }
const std
::vector<FieldDescriptor>& get
Fields() 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
.substr(0, 4) + "-" +
date
.substr(4, 2) + "-" +
date
.substr(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, E
OF_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(E
OF_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
.get
Data();
auto&
fields = reader
.get
Fields();
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, size
of(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
.get
Fields();
// 构造完整行数据，按字段顺序填充
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
.get
Data())
.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
.get
Data()); // 移除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
::ostringstream 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
.get
Fields();
for (const auto& field
: fields) {
std
::string fieldName = processDBFFieldName(field
.name, size
of(field
.name));
std
::cout << " " << fieldName << " (type
: " << field
.type << ", length
: " << (int)field
.length << ")" << std
::endl;
}
// 显示记录数量
std
::cout << "Total records
: " << reader
.get
Data()
.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
.get
Fields()) {
std
::string fieldName = processDBFFieldName(field
.name, size
of(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;
}以上代码，数据显示输出有中文乱码，请修复代码
本文探讨了在使用OpenCsv处理csv文件时遇到的CsvRequiredFieldEmptyException异常，详细解析了问题原因在于数据字段数量与表头不匹配，并提供了解决方案。
扫一扫
873
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
