storage.c

// storage.c
#include "database.h"
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

#ifdef _WIN32
#include <windows.h>
#include <direct.h>
#include <string.h> /* MSVC 下 _stricmp/_strnicmp/_strdup 在此声明 */

#ifndef strcasecmp
#define strcasecmp _stricmp
#endif
#ifndef strncasecmp
#define strncasecmp _strnicmp
#endif
#ifndef strdup
#define strdup _strdup
#endif

#else
#include <dirent.h>
#include <unistd.h>
#include <strings.h> /* 提供 strcasecmp/strncasecmp 在 POSIX 下 */
#include <string.h>  /* memcpy/strcmp/strncmp 等通用函数 */
#endif

// ==================== B+ 树通用比较逻辑 ====================

// 比较两个 Key 的大小
// 返回值: <0 (k1<k2), 0 (k1==k2), >0 (k1>k2)
int compare_keys(void* k1, void* k2, const char* type, int size) {
	if (strcmp(type, "int") == 0) {
		int v1 = *(int*)k1;
		int v2 = *(int*)k2;
		return v1 - v2;
	}
	else if (strcmp(type, "float") == 0) {
		float f1 = *(float*)k1;
		float f2 = *(float*)k2;
		if (f1 < f2) return -1;
		if (f1 > f2) return 1;
		return 0;
	}
	else {
		// char 类型
		return strncmp((char*)k1, (char*)k2, size);
	}
}

// ==================== B+ 树底层 IO ====================

void get_index_filename(const char* tableName, char* outName) {
	sprintf(outName, "%s.idx", tableName);
}

void node_read(FILE* fp, long offset, BPlusNode* node) {
	fseek(fp, offset, SEEK_SET);
	fread(node, sizeof(BPlusNode), 1, fp);
}

void node_write(FILE* fp, long offset, BPlusNode* node) {
	fseek(fp, offset, SEEK_SET);
	fwrite(node, sizeof(BPlusNode), 1, fp);
}

void header_read(FILE* fp, IndexHeader* header) {
	fseek(fp, 0, SEEK_SET);
	fread(header, sizeof(IndexHeader), 1, fp);
}

void header_write(FILE* fp, IndexHeader* header) {
	fseek(fp, 0, SEEK_SET);
	fwrite(header, sizeof(IndexHeader), 1, fp);
}

long node_alloc(FILE* fp, IndexHeader* header) {
	long offset = header->nextFreeOffset;
	header->nextFreeOffset += sizeof(BPlusNode);
	header->nodeCount++;
	header_write(fp, header);
	return offset;
}

void node_init(BPlusNode* node, int isLeaf, long selfOffset) {
	memset(node, 0, sizeof(BPlusNode));
	node->isLeaf = isLeaf;
	node->selfOffset = selfOffset;
	node->parentOffset = INVALID_OFFSET;
	node->prevLeaf = INVALID_OFFSET;
	node->nextLeaf = INVALID_OFFSET;
	node->keyCount = 0;
	for (int i = 0; i <= BPLUS_ORDER; i++) node->ptrs[i] = INVALID_OFFSET;
}

// ==================== B+ 树操作 (通用版) ====================

// 查找叶子
long bplus_find_leaf(FILE* fp, long rootOffset, void* key, const char* type, int size) {
	long currOffset = rootOffset;
	BPlusNode curr;

	while (currOffset != INVALID_OFFSET) {
		node_read(fp, currOffset, &curr);
		if (curr.isLeaf) return currOffset;

		int i = 0;
		while (i < curr.keyCount && compare_keys(key, curr.keys[i], type, size) >= 0) {
			i++;
		}
		currOffset = curr.ptrs[i];
	}
	return INVALID_OFFSET;
}

// 插入到父节点 (简化版：仅处理根分裂)
void bplus_insert_into_parent(FILE* fp, IndexHeader* header, long leftOffset, void* key, long rightOffset) {
	BPlusNode leftChild;
	node_read(fp, leftOffset, &leftChild);
	long parentOffset = leftChild.parentOffset;

	if (parentOffset == INVALID_OFFSET) {
		long newRootOffset = node_alloc(fp, header);
		BPlusNode newRoot;
		node_init(&newRoot, 0, newRootOffset);

		newRoot.keyCount = 1;
		memcpy(newRoot.keys[0], key, header->keySize);
		newRoot.ptrs[0] = leftOffset;
		newRoot.ptrs[1] = rightOffset;

		node_write(fp, newRootOffset, &newRoot);
		header->rootOffset = newRootOffset;
		header_write(fp, header);

		leftChild.parentOffset = newRootOffset;
		node_write(fp, leftOffset, &leftChild);

		BPlusNode rightChild;
		node_read(fp, rightOffset, &rightChild);
		rightChild.parentOffset = newRootOffset;
		node_write(fp, rightOffset, &rightChild);
	}
}

// 插入 Key
void bplus_insert_key(FILE* fp, IndexHeader* header, void* key, long dataOffset) {
	long leafOffset = bplus_find_leaf(fp, header->rootOffset, key, header->keyType, header->keySize);

	if (leafOffset == INVALID_OFFSET) {
		// 空树初始化
		long newRoot = node_alloc(fp, header);
		BPlusNode rootNode;
		node_init(&rootNode, 1, newRoot);
		memcpy(rootNode.keys[0], key, header->keySize);
		rootNode.ptrs[0] = dataOffset;
		rootNode.keyCount = 1;

		header->rootOffset = newRoot;
		header_write(fp, header);
		node_write(fp, newRoot, &rootNode);
		return;
	}

	BPlusNode leaf;
	node_read(fp, leafOffset, &leaf);

	// 检查重复
	for (int i = 0; i < leaf.keyCount; i++) {
		if (compare_keys(leaf.keys[i], key, header->keyType, header->keySize) == 0) {
			// 已存在
			return;
		}
	}

	// 插入位置
	int insertIdx = 0;
	while (insertIdx < leaf.keyCount && compare_keys(leaf.keys[insertIdx], key, header->keyType, header->keySize) < 0) {
		insertIdx++;
	}

	// 移动
	for (int i = leaf.keyCount; i > insertIdx; i--) {
		memcpy(leaf.keys[i], leaf.keys[i - 1], header->keySize);
		leaf.ptrs[i] = leaf.ptrs[i - 1];
	}
	memcpy(leaf.keys[insertIdx], key, header->keySize);
	leaf.ptrs[insertIdx] = dataOffset;
	leaf.keyCount++;

	if (leaf.keyCount < BPLUS_ORDER) {
		node_write(fp, leafOffset, &leaf);
	}
	else {
		// 分裂
		long newLeafOffset = node_alloc(fp, header);
		BPlusNode newLeaf;
		node_init(&newLeaf, 1, newLeafOffset);

		int splitIdx = (BPLUS_ORDER + 1) / 2;
		int moveCount = leaf.keyCount - splitIdx;

		for (int i = 0; i < moveCount; i++) {
			memcpy(newLeaf.keys[i], leaf.keys[splitIdx + i], header->keySize);
			newLeaf.ptrs[i] = leaf.ptrs[splitIdx + i];
		}
		newLeaf.keyCount = moveCount;
		leaf.keyCount = splitIdx;

		newLeaf.nextLeaf = leaf.nextLeaf;
		newLeaf.prevLeaf = leafOffset;
		leaf.nextLeaf = newLeafOffset;

		node_write(fp, leafOffset, &leaf);
		node_write(fp, newLeafOffset, &newLeaf);

		bplus_insert_into_parent(fp, header, leafOffset, newLeaf.keys[0], newLeafOffset);
	}
}

// 初始化索引头
void bplus_init_index_with_type(const char* tableName, const char* type, int size) {
	char idxName[64];
	get_index_filename(tableName, idxName);

	FILE* fp = fopen(idxName, "rb");
	if (!fp) {
		fp = fopen(idxName, "wb");
		IndexHeader header;
		header.rootOffset = INVALID_OFFSET;
		header.nextFreeOffset = sizeof(IndexHeader);
		header.nodeCount = 0;
		strncpy(header.keyType, type, 8);
		header.keySize = size;
		fwrite(&header, sizeof(IndexHeader), 1, fp);
	}
	if (fp) fclose(fp);
}

// ==================== 数据文件操作 ====================

int dat_insert_record(const char* tableName, void* data, int size, void* keyPtr, const char* keyType, int keySize) {
	FILE* fp = fopen(DB_FILE_DATA, "ab");
	if (!fp) return 0;

	char nameBuf[TABLE_NAME_LEN] = { 0 };
	strncpy(nameBuf, tableName, TABLE_NAME_LEN - 1);
	fwrite(nameBuf, sizeof(char), TABLE_NAME_LEN, fp);
	fwrite(&size, sizeof(int), 1, fp);

	long headerOffset = ftell(fp);
	RecordHeader rh; rh.bValid = 1;
	fwrite(&rh, sizeof(RecordHeader), 1, fp);
	fwrite(data, size, 1, fp);
	fclose(fp);

	// 更新索引
	char idxName[64];
	get_index_filename(tableName, idxName);
	FILE* fpIdx = fopen(idxName, "rb+");
	if (!fpIdx) {
		// 索引可能未初始化
		bplus_init_index_with_type(tableName, keyType, keySize);
		fpIdx = fopen(idxName, "rb+");
	}

	if (fpIdx) {
		IndexHeader header;
		header_read(fpIdx, &header);
		bplus_insert_key(fpIdx, &header, keyPtr, headerOffset);
		fclose(fpIdx);
	}
	return 1;
}

// dat_search_record: 读取实际存储长度，并只拷贝实际字节到 outData。
// 返回 1 成功并填充 outStoredSize（若 outStoredSize != NULL），0 失败
int dat_search_record(const char* tableName, void* keyPtr, void* outData, int size, int* outStoredSize) {
	char idxName[64];
	get_index_filename(tableName, idxName);
	FILE* fpIdx = fopen(idxName, "rb");
	if (!fpIdx) return 0;

	IndexHeader header;
	header_read(fpIdx, &header);
	long leafOffset = bplus_find_leaf(fpIdx, header.rootOffset, keyPtr, header.keyType, header.keySize);

	long dataOffset = INVALID_OFFSET;
	if (leafOffset != INVALID_OFFSET) {
		BPlusNode leaf;
		node_read(fpIdx, leafOffset, &leaf);
		for (int i = 0; i < leaf.keyCount; i++) {
			if (compare_keys(leaf.keys[i], keyPtr, header.keyType, header.keySize) == 0) {
				dataOffset = leaf.ptrs[i];
				break;
			}
		}
	}
	fclose(fpIdx);

	if (dataOffset != INVALID_OFFSET) {
		FILE* fpDat = fopen(DB_FILE_DATA, "rb");
		if (fpDat) {
			// dataOffset 指向 RecordHeader 的起始（插入时保存的 headerOffset）
			// 实际长度存放在 dataOffset - sizeof(int)
			int storedSize = 0;
			if (fseek(fpDat, dataOffset - sizeof(int), SEEK_SET) == 0) {
				fread(&storedSize, sizeof(int), 1, fpDat);
			}
			fseek(fpDat, dataOffset, SEEK_SET);
			RecordHeader rh;
			fread(&rh, sizeof(RecordHeader), 1, fpDat);
			if (rh.bValid) {
				int toRead = storedSize;
				if (toRead > size) toRead = size;
				// 读实际存在的字节
				if (toRead > 0) fread(outData, toRead, 1, fpDat);
				// 若调用方期望更大的缓冲，清零剩余
				if (size > toRead) memset((char*)outData + toRead, 0, size - toRead);
				if (outStoredSize) *outStoredSize = storedSize;
				fclose(fpDat);
				return 1;
			}
			fclose(fpDat);
		}
	}
	return 0;
}

int dat_delete_record(const char* tableName, void* keyPtr) {
	char idxName[64];
	get_index_filename(tableName, idxName);
	FILE* fpIdx = fopen(idxName, "rb+");
	if (!fpIdx) return 0;

	IndexHeader header;
	header_read(fpIdx, &header);

	long leafOffset = bplus_find_leaf(fpIdx, header.rootOffset, keyPtr, header.keyType, header.keySize);
	long dataOffset = INVALID_OFFSET;
	int foundIdx = -1;

	if (leafOffset != INVALID_OFFSET) {
		BPlusNode leaf;
		node_read(fpIdx, leafOffset, &leaf);
		for (int i = 0; i < leaf.keyCount; i++) {
			if (compare_keys(leaf.keys[i], keyPtr, header.keyType, header.keySize) == 0) {
				dataOffset = leaf.ptrs[i];
				foundIdx = i;
				break;
			}
		}
		// 物理移除 Key
		if (foundIdx != -1) {
			for (int i = foundIdx; i < leaf.keyCount - 1; i++) {
				memcpy(leaf.keys[i], leaf.keys[i + 1], header.keySize);
				leaf.ptrs[i] = leaf.ptrs[i + 1];
			}
			leaf.keyCount--;
			node_write(fpIdx, leafOffset, &leaf);
		}
	}
	fclose(fpIdx);

	if (dataOffset != INVALID_OFFSET) {
		FILE* fpDat = fopen(DB_FILE_DATA, "rb+");
		if (fpDat) {
			fseek(fpDat, dataOffset, SEEK_SET);
			RecordHeader rh; rh.bValid = 0;
			fwrite(&rh, sizeof(RecordHeader), 1, fpDat);
			fclose(fpDat);
			return 1;
		}
	}
	return 0;
}

// 辅助: 根据 Key 获取 Offset (用于 Update)
long dat_get_offset_by_key(const char* tableName, void* keyPtr) {
	char idxName[64];
	get_index_filename(tableName, idxName);
	FILE* fpIdx = fopen(idxName, "rb");
	if (!fpIdx) return INVALID_OFFSET;

	IndexHeader header;
	header_read(fpIdx, &header);
	long leafOffset = bplus_find_leaf(fpIdx, header.rootOffset, keyPtr, header.keyType, header.keySize);
	long dataOffset = INVALID_OFFSET;

	if (leafOffset != INVALID_OFFSET) {
		BPlusNode leaf;
		node_read(fpIdx, leafOffset, &leaf);
		for (int i = 0; i < leaf.keyCount; i++) {
			if (compare_keys(leaf.keys[i], keyPtr, header.keyType, header.keySize) == 0) {
				dataOffset = leaf.ptrs[i];
				break;
			}
		}
	}
	fclose(fpIdx);
	return dataOffset;
}

// 辅助: 覆盖更新
int dat_overwrite_record(long dataOffset, void* newData, int size) {
	if (dataOffset == INVALID_OFFSET) return 0;
	FILE* fpDat = fopen(DB_FILE_DATA, "rb+");
	if (!fpDat) return 0;

	// 跳过 Header
	fseek(fpDat, dataOffset + sizeof(RecordHeader), SEEK_SET);
	fwrite(newData, size, 1, fpDat);
	fclose(fpDat);
	return 1;
}

int dat_update_record(const char* tableName, int pkValIsUnused, void* newData, int size) {
	// 占位函数，实际逻辑在 Manager 层使用 dat_overwrite_record
	return 0;
}

// ==================== 基础表操作 (Legacy) ====================

void InitSystem() {
	FILE* fp = fopen(DB_FILE_SCHEMA, "rb");
	if (!fp) { fp = fopen(DB_FILE_SCHEMA, "wb"); if (fp) fclose(fp); }
	else fclose(fp);
	fp = fopen(DB_FILE_DATA, "rb");
	if (!fp) { fp = fopen(DB_FILE_DATA, "wb"); if (fp) fclose(fp); }
	else fclose(fp);
}

int dbf_check_exists(const char* name) {
	FILE* fp = fopen(DB_FILE_SCHEMA, "rb");
	if (!fp) return 0;
	char sep, tName[TABLE_NAME_LEN]; int cnt;
	while (fread(&sep, 1, 1, fp) == 1) {
		if (sep != '~') continue;
		fread(tName, TABLE_NAME_LEN, 1, fp);
		fread(&cnt, sizeof(int), 1, fp);
		if (strcmp(tName, name) == 0) { fclose(fp); return 1; }
		fseek(fp, sizeof(TableMode) * cnt, SEEK_CUR);
	}
	fclose(fp);
	return 0;
}

int dbf_get_schema(const char* name, TableMeta* outTable) {
	FILE* fp = fopen(DB_FILE_SCHEMA, "rb");
	if (!fp) return 0;
	char sep;
	while (fread(&sep, 1, 1, fp) == 1) {
		if (sep != '~') continue;
		fread(outTable->sTableName, TABLE_NAME_LEN, 1, fp);
		fread(&(outTable->iFieldCount), sizeof(int), 1, fp);
		if (strcmp(outTable->sTableName, name) == 0) {
			fread(outTable->fields, sizeof(TableMode), outTable->iFieldCount, fp);
			fclose(fp);
			return 1;
		}
		fseek(fp, sizeof(TableMode) * outTable->iFieldCount, SEEK_CUR);
	}
	fclose(fp);
	return 0;
}

static int write_one_table(FILE* fp, const TableMeta* m) {
	char sep = '~';
	if (fwrite(&sep, 1, 1, fp) != 1) return 0;
	if (fwrite(m->sTableName, TABLE_NAME_LEN, 1, fp) != 1) return 0;
	if (fwrite(&m->iFieldCount, sizeof(int), 1, fp) != 1) return 0;
	if (m->iFieldCount < 0 || m->iFieldCount > MAX_FIELDS) return 0;
	if (fwrite(m->fields, sizeof(TableMode), m->iFieldCount, fp) != (size_t)m->iFieldCount) return 0;
	return 1;
}



int SaveTableToDBF(TableMeta* table) {
	if (dbf_check_exists(table->sTableName)) return 0;
	FILE* fp = fopen(DB_FILE_SCHEMA, "ab");
	if (!fp) return 0;
	char sep = '~';
	fwrite(&sep, 1, 1, fp);
	fwrite(table->sTableName, TABLE_NAME_LEN, 1, fp);
	fwrite(&(table->iFieldCount), sizeof(int), 1, fp);
	fwrite(table->fields, sizeof(TableMode), table->iFieldCount, fp);
	fclose(fp);
	// 初始化空索引
	// 注意：这里无法初始化索引类型，因为还不知道主键是啥，推迟到第一次插入时
	return 1;
}

int dbf_update_schema(const char* tableName, const TableMeta* newMeta) {
	if (!tableName || !newMeta) return 0;

	FILE* in = fopen(DB_FILE_SCHEMA, "rb");
	if (!in) {
		// schema 文件都没有，说明系统未初始化或文件丢了
		return 0;
	}

	// 临时文件
	const char* tmpName = "my_database.dbf.tmp";
	FILE* out = fopen(tmpName, "wb");
	if (!out) {
		fclose(in);
		return 0;
	}

	int replaced = 0;
	char sep;

	while (fread(&sep, 1, 1, in) == 1) {
		if (sep != '~') {
			// 容错：遇到脏字节就跳过（或直接 break）
			continue;
		}

		TableMeta t;
		memset(&t, 0, sizeof(t));

		// 读表名、字段数
		if (fread(t.sTableName, TABLE_NAME_LEN, 1, in) != 1) break;
		if (fread(&t.iFieldCount, sizeof(int), 1, in) != 1) break;

		if (t.iFieldCount < 0 || t.iFieldCount > MAX_FIELDS) {
			// 文件损坏
			break;
		}

		// 读字段数组
		if (fread(t.fields, sizeof(TableMode), t.iFieldCount, in) != (size_t)t.iFieldCount) break;

		// 写出：目标表替换，其余原样写回
		if (strcmp(t.sTableName, tableName) == 0) {
			if (!write_one_table(out, newMeta)) {
				fclose(in);
				fclose(out);
				remove(tmpName);
				return 0;
			}
			replaced = 1;
		}
		else {
			if (!write_one_table(out, &t)) {
				fclose(in);
				fclose(out);
				remove(tmpName);
				return 0;
			}
		}
	}

	fclose(in);
	fclose(out);

	if (!replaced) {
		// 没找到目标表，说明表不存在或 dbf 内容异常
		remove(tmpName);
		return 0;
	}

	// 用 tmp 覆盖原 dbf
	// Windows 上 rename 覆盖可能失败，所以先 remove 再 rename
	remove(DB_FILE_SCHEMA);
	if (rename(tmpName, DB_FILE_SCHEMA) != 0) {
		// 恢复失败：tmp 还在
		return 0;
	}

	return 1;
}

void DisplayTableNames() {
	FILE* fp = fopen(DB_FILE_SCHEMA, "rb");
	if (!fp) { printf("Empty\n"); return; }
	fseek(fp, 0, SEEK_END);
	if (ftell(fp) == 0) { printf("Empty\n"); fclose(fp); return; }
	rewind(fp);
	printf("\nTables:\n");
	char sep, tName[TABLE_NAME_LEN]; int cnt;
	while (fread(&sep, 1, 1, fp) == 1) {
		if (sep != '~') continue;
		fread(tName, TABLE_NAME_LEN, 1, fp);
		fread(&cnt, sizeof(int), 1, fp);
		printf("- %s\n", tName);
		fseek(fp, sizeof(TableMode) * cnt, SEEK_CUR);
	}
	fclose(fp);
}

void DisplayTableStruct(const char* name) {
	TableMeta t;
	if (dbf_get_schema(name, &t)) {
		printf("Table: %s\n", t.sTableName);
		for (int i = 0; i < t.iFieldCount; i++)
			if (t.fields[i].bValidFlag) // 跳过无效列
				printf(" %s (%s, %d) %s\n", t.fields[i].sFieldName, t.fields[i].sType, t.fields[i].iSize, t.fields[i].bKey ? "PK" : "");
	}
}

// 辅助函数：物理标记数据无效
static void dat_mark_all_invalid(const char* targetName) {
	FILE* fp = fopen(DB_FILE_DATA, "rb+");
	if (!fp) return;
	char currName[TABLE_NAME_LEN]; int size; RecordHeader rh;
	while (fread(currName, TABLE_NAME_LEN, 1, fp) == 1) {
		if (fread(&size, 4, 1, fp) != 1) break;
		long hPos = ftell(fp);
		if (fread(&rh, sizeof(RecordHeader), 1, fp) != 1) break;
		if (strcmp(currName, targetName) == 0 && rh.bValid) {
			rh.bValid = 0;
			fseek(fp, hPos, SEEK_SET);
			fwrite(&rh, sizeof(RecordHeader), 1, fp);
			fseek(fp, size, SEEK_CUR);
		}
		else {
			fseek(fp, size, SEEK_CUR);
		}
	}
	fclose(fp);
}

// 辅助：重写 DBF (Schema)
static int dbf_rewrite_excluding(const char* excludeName) {
	FILE* fp = fopen(DB_FILE_SCHEMA, "rb");
	if (!fp) return 0;
	// 简单实现：读取所有到内存链表，然后重写
	typedef struct Node { TableMeta m; struct Node* next; } Node;
	Node* head = NULL; Node* tail = NULL;
	char sep;
	while (fread(&sep, 1, 1, fp) == 1) {
		if (sep != '~') continue;
		TableMeta t;
		fread(t.sTableName, TABLE_NAME_LEN, 1, fp);
		fread(&t.iFieldCount, 4, 1, fp);
		fread(t.fields, sizeof(TableMode), t.iFieldCount, fp);
		if (strcmp(t.sTableName, excludeName) != 0) {
			Node* n = (Node*)malloc(sizeof(Node)); n->m = t; n->next = NULL;
			if (tail) tail->next = n; else head = n; tail = n;
		}
	}
	fclose(fp);
	fp = fopen(DB_FILE_SCHEMA, "wb");
	Node* curr = head;
	while (curr) {
		char s = '~'; fwrite(&s, 1, 1, fp);
		fwrite(curr->m.sTableName, TABLE_NAME_LEN, 1, fp);
		fwrite(&curr->m.iFieldCount, 4, 1, fp);
		fwrite(curr->m.fields, sizeof(TableMode), curr->m.iFieldCount, fp);
		Node* tmp = curr; curr = curr->next; free(tmp);
	}
	fclose(fp);
	return 1;
}

int sys_drop_table(const char* tableName) {
	if (!dbf_check_exists(tableName)) return 0;
	dat_mark_all_invalid(tableName);
	char idxName[64]; sprintf(idxName, "%s.idx", tableName); remove(idxName);
	dbf_rewrite_excluding(tableName);
	return 1;
}

int dat_scan_all(TableMeta* table, ResultSet* resultSet) {
	FILE* fp = fopen(DB_FILE_DATA, "rb");
	if (!fp) return 0;
	if (resultSet->records == NULL) resultSet->records = (void**)malloc(sizeof(void*) * MAX_RECORDS);
	// 分配或重分配 recordSizes
	if (resultSet->recordSizes == NULL) resultSet->recordSizes = (int*)malloc(sizeof(int) * MAX_RECORDS);
	resultSet->recordCount = 0;

	char currName[TABLE_NAME_LEN]; int size; RecordHeader rh;
	while (fread(currName, TABLE_NAME_LEN, 1, fp) == 1) {
		if (fread(&size, 4, 1, fp) != 1) break;
		if (fread(&rh, sizeof(RecordHeader), 1, fp) != 1) break;
		if (strcmp(currName, table->sTableName) == 0 && rh.bValid) {
			void* data = malloc(size);
			fread(data, size, 1, fp);
			if (resultSet->recordCount < MAX_RECORDS) {
				resultSet->records[resultSet->recordCount] = data;
				resultSet->recordSizes[resultSet->recordCount] = size;
				resultSet->recordCount++;
			}
			else free(data);
		}
		else {
			fseek(fp, size, SEEK_CUR);
		}
	}
	fclose(fp);
	return 1;
}



int storage_apply_alter(const char* tableName,
	const TableMeta* oldMeta,
	const TableMeta* newMeta,
	int alterType)
{
	(void)oldMeta;   // Phase 1 暂时不用
	(void)alterType; // Phase 1 暂时不用

	if (!tableName || !newMeta) return 0;

	// Phase 1：ALTER 全部归结为 “更新 dbf 的该表 schema”
	// 之后你要做 dat rewrite / idx rebuild，可以在这里按 alterType 分支加。
	return dbf_update_schema(tableName, newMeta);
}

// 简单文件拷贝
static int file_copy(const char* src, const char* dst) {
	FILE* in = fopen(src, "rb");
	if (!in) return 0;
	FILE* out = fopen(dst, "wb");
	if (!out) { fclose(in); return 0; }

	char buf[4096];
	size_t n;
	while ((n = fread(buf, 1, sizeof(buf), in)) > 0) {
		if (fwrite(buf, 1, n, out) != n) { fclose(in); fclose(out); return 0; }
	}
	fclose(in);
	fclose(out);
	return 1;
}

// 创建目录（若已存在视为成功）
static int ensure_dir_exists(const char* path) {
	if (!path) return 0;
#ifdef _WIN32
	if (_mkdir(path) == 0) return 1;
	if (errno == EEXIST) return 1;
	return 0;
#else
	if (mkdir(path, 0755) == 0) return 1;
	if (errno == EEXIST) return 1;
	return 0;
#endif
}

// 判断后缀是否为 .idx (忽略大小写)
static int is_idx_file(const char* name) {
	if (!name) return 0;
	const char* dot = strrchr(name, '.');
	if (!dot) return 0;
	return strcasecmp(dot, ".idx") == 0;
}

// 判断后缀是否为 .dat (忽略大小写)
static int is_dat_file(const char* name) {
	if (!name) return 0;
	const char* dot = strrchr(name, '.');
	if (!dot) return 0;
	return strcasecmp(dot, ".dat") == 0;
}

// 备份数据库文件与所有索引文件到 backupDir
int backup_database(const char* backupDir) {
	if (!backupDir) return 0;
	if (!ensure_dir_exists(backupDir)) {
		printf("Error: cannot create backup directory '%s'\n", backupDir);
		return 0;
	}

	// 路径分隔符
	const char sep =
#ifdef _WIN32
		'\\';
#else
		'/';
#endif

	char dst[1024];

	// 复制 schema 和 data 文件
	snprintf(dst, sizeof(dst), "%s%c%s", backupDir, sep, DB_FILE_SCHEMA);
	if (!file_copy(DB_FILE_SCHEMA, dst)) {
		printf("Error: failed to copy %s to %s\n", DB_FILE_SCHEMA, dst);
		return 0;
	}
	snprintf(dst, sizeof(dst), "%s%c%s", backupDir, sep, DB_FILE_DATA);
	if (!file_copy(DB_FILE_DATA, dst)) {
		printf("Error: failed to copy %s to %s\n", DB_FILE_DATA, dst);
		return 0;
	}

	// 复制当前目录下的所有 .idx 和 .dat 文件（包含 system_*.dat）
#ifdef _WIN32
	{
		WIN32_FIND_DATAA fd;
		HANDLE h = FindFirstFileA("*.*", &fd);
		if (h != INVALID_HANDLE_VALUE) {
			do {
				if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue;
				if (is_idx_file(fd.cFileName) || is_dat_file(fd.cFileName)) {
					// 跳过备份目标已经复制的 DB_FILE_SCHEMA（.dbf）不用，DB_FILE_DATA 已单独复制也可覆盖
					snprintf(dst, sizeof(dst), "%s%c%s", backupDir, sep, fd.cFileName);
					if (!file_copy(fd.cFileName, dst)) {
						FindClose(h);
						printf("Warning: failed to copy file %s\n", fd.cFileName);
					}
				}
			} while (FindNextFileA(h, &fd));
			FindClose(h);
		}
	}
#else
	{
		DIR* d = opendir(".");
		if (d) {
			struct dirent* ent;
			while ((ent = readdir(d)) != NULL) {
				// 跳过目录
#ifdef DT_DIR
				if (ent->d_type == DT_DIR) continue;
#endif
				if (is_idx_file(ent->d_name) || is_dat_file(ent->d_name)) {
					// 跳过当前目录下的非数据文件
					snprintf(dst, sizeof(dst), "%s%c%s", backupDir, sep, ent->d_name);
					if (!file_copy(ent->d_name, dst)) {
						printf("Warning: failed to copy file %s\n", ent->d_name);
					}
				}
			}
			closedir(d);
		}
	}
#endif

	return 1;
}

// 从 backupDir 恢复数据库文件和索引文件到当前目录（覆盖）
int restore_database(const char* backupDir) {
	if (!backupDir) return 0;

	// 路径分隔符
	const char sep =
#ifdef _WIN32
		'\\';
#else
		'/';
#endif

	char src[1024];

	// 恢复 schema 和 data（优先）
	snprintf(src, sizeof(src), "%s%c%s", backupDir, sep, DB_FILE_SCHEMA);
	if (!file_copy(src, DB_FILE_SCHEMA)) {
		printf("Error: failed to restore %s from %s\n", DB_FILE_SCHEMA, src);
		return 0;
	}
	snprintf(src, sizeof(src), "%s%c%s", backupDir, sep, DB_FILE_DATA);
	if (!file_copy(src, DB_FILE_DATA)) {
		printf("Error: failed to restore %s from %s\n", DB_FILE_DATA, src);
		return 0;
	}

	// 恢复 .idx 和 .dat 文件：遍历 backupDir 内的文件
#ifdef _WIN32
	{
		char pattern[1024];
		snprintf(pattern, sizeof(pattern), "%s%c*.*", backupDir, sep);
		WIN32_FIND_DATAA fd;
		HANDLE h = FindFirstFileA(pattern, &fd);
		if (h != INVALID_HANDLE_VALUE) {
			do {
				if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue;
				if (is_idx_file(fd.cFileName) || is_dat_file(fd.cFileName)) {
					snprintf(src, sizeof(src), "%s%c%s", backupDir, sep, fd.cFileName);
					if (!file_copy(src, fd.cFileName)) {
						FindClose(h);
						printf("Warning: failed to restore file %s\n", fd.cFileName);
					}
				}
			} while (FindNextFileA(h, &fd));
			FindClose(h);
		}
	}
#else
	{
		DIR* d = opendir(backupDir);
		if (d) {
			struct dirent* ent;
			while ((ent = readdir(d)) != NULL) {
				// 构造完整路径
				if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) continue;
				char full[1024];
				snprintf(full, sizeof(full), "%s%c%s", backupDir, sep, ent->d_name);
				// 只处理 .idx 和 .dat 文件
				if (is_idx_file(ent->d_name) || is_dat_file(ent->d_name)) {
					if (!file_copy(full, ent->d_name)) {
						printf("Warning: failed to restore file %s\n", ent->d_name);
					}
				}
			}
			closedir(d);
		}
	}
#endif

	return 1;
}