database.h

// database.h
#ifndef DATABASE_H
#define DATABASE_H
#define _CRT_NONSTDC_NO_DEPRECATE
#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// ==================== 基础配置与宏定义 ====================
#define DB_FILE_SCHEMA "my_database.dbf" // 表结构文件
#define DB_FILE_DATA   "my_database.dat" // 数据记录文件
#define FIELD_NAME_LEN 20
#define TABLE_NAME_LEN 20
#define MAX_FIELDS 20
#define MAX_SQL_LEN 1024
#define MAX_RECORDS 1000   // 最大记录数限制 (用于全表扫描或结果集)
#define MAX_TABLES_IN_JOIN 4 // 限制最多联合查询4张表

// ==================== B+ 树配置 ====================
#define BPLUS_ORDER 5             // B+树阶数
#define INVALID_OFFSET -1L        // 无效文件偏移量标记
#define MAX_KEY_LEN 32 // 定义最大键长度 (覆盖 int=4, char(20)=20)

// ==================== 1. 基础数据结构 ====================

// 字段定义
typedef struct {
	char sFieldName[FIELD_NAME_LEN];
	char sType[8];    // "int", "char", "float"
	int iSize;
	char bKey;        // 1=主键
	char bNullFlag;
	char bValidFlag;
} TableMode;

// 表元数据
typedef struct {
	char sTableName[TABLE_NAME_LEN];
	int iFieldCount;
	TableMode fields[MAX_FIELDS];
} TableMeta;

// 记录头 (存储在 .dat 文件中记录的前面)
typedef struct {
	char bValid; // 1=有效, 0=删除
} RecordHeader;

// ==================== 2. B+ 树物理结构 ====================

// 索引文件头
typedef struct {
	long rootOffset;
	long nextFreeOffset;
	int nodeCount;
	// *** 新增：记录这棵树是存什么的 ***
	char keyType[10];  // "int", "char", "float"
	int keySize;       // 4, 20, etc.
} IndexHeader;

// B+ 树节点
typedef struct {
	long selfOffset;
	long parentOffset;
	long prevLeaf;
	long nextLeaf;

	int isLeaf;
	int keyCount;

	// *** 修改：从 int keys[ORDER] 变为通用字节存储 ***
	// keys[i] 存储第 i 个键的原始内容
	unsigned char keys[BPLUS_ORDER][MAX_KEY_LEN];

	long ptrs[BPLUS_ORDER + 1];
} BPlusNode;

// ==================== 3. 查询结果集结构 ====================

typedef struct {
	TableMeta meta;
	void** records;     // 指向每条记录数据的指针数组
	int* recordSizes;   // 与 records 一一对应，记录每条记录真实的字节长度
	int recordCount;    // 结果集中记录的数量
} ResultSet;

// ==================== 4. SQL 解析结构 (修复 SqlCommand 未定义) ====================

// *** 修复报错：重新加入 SqlCommand 定义 ***
typedef struct {
	int commandType; // 1=CREATE, 2=INSERT, 3=SELECT, 4=DROP, 5=UPDATE, 6=DELETE
	union {
		// CREATE TABLE
		struct {
			TableMeta tableMeta;
		} createStmt;

		// INSERT INTO
		struct {
			char tableName[TABLE_NAME_LEN];

			// 目标列名 (例如: INSERT INTO t (col1, col2) ...)
			// 如果为 NULL 或 count=0，表示默认插入所有列
			char** targetColumns;
			int targetColCount;

			// 多行数据 (例如: VALUES (v1,v2), (v3,v4) ...)
			// 三维结构: rows[第几行][第几列] -> 字符串值
			char*** rows;
			int* rowValueCounts; // 每一行有多少个值
			int rowCount;        // 总行数
		} insertStmt;

		// SELECT
		struct {
			char** selectColumns;
			int columnCount;

			char fromTables[MAX_TABLES_IN_JOIN][TABLE_NAME_LEN];
			// *** 新增：存储对应的别名 ***
			char tableAliases[MAX_TABLES_IN_JOIN][TABLE_NAME_LEN];
			int tableCount;

			char* whereCondition;
		} selectStmt;

		// DELETE
		struct {
			char tableName[TABLE_NAME_LEN];
			char* whereCondition;
		} deleteStmt;

		// UPDATE
		struct {
			char tableName[TABLE_NAME_LEN];
			char** setColumns;      // 要修改的列名数组
			char** setValues;       // 对应的新值数组
			int setCount;           // 修改的列数量
			char* whereCondition;   // WHERE 条件
		} updateStmt;

		// DROP
		struct {
			char tableName[TABLE_NAME_LEN];
		} dropStmt;

		// ALTER
		struct {
			char tableName[TABLE_NAME_LEN];
			int alterType; // ALTER_ADD / ALTER_DROP / ALTER_RENAME / ALTER_MODIFY

			// 针对列操作
			char columnName[FIELD_NAME_LEN];     // 旧列名（DROP / RENAME / MODIFY / ADD 指定）
			char newColumnName[FIELD_NAME_LEN];  // RENAME 的新列名

			// 列的新定义（用于 ADD / MODIFY）
			char newType[16]; // "int", "float", "char"
			int newSize;      // 对 char(n) 有效
			char newNullFlag; // 0 = NOT NULL, 1 = NULL allowed

			// 可扩展：默认值指示符、position 信息等
		} alterStmt;

		// BACKUP / RESTORE
		struct {
			char dir[512]; // 备份/恢复目标目录
		} backupStmt;

	} stmtData;
} SqlCommand;

// 新增命令常量
#define CMD_BACKUP 15
#define CMD_RESTORE 16

// ==================== 5. 权限管理数据结构 ====================

// 权限类型定义
#define PERM_SELECT    0x01  // 0001
#define PERM_INSERT    0x02  // 0010
#define PERM_UPDATE    0x04  // 0100
#define PERM_DELETE    0x08  // 1000
#define PERM_CREATE    0x10  // 0001 0000
#define PERM_DROP      0x20  // 0010 0000
#define PERM_GRANT     0x40  // 0100 0000
#define PERM_ALL       0xFF  // 1111 1111
#define CMD_ALTER 14
#define ALTER_ADD    1
#define ALTER_DROP   2
#define ALTER_RENAME 3

// 角色定义
typedef struct {
	char roleName[TABLE_NAME_LEN];
	int permissions;  // 位掩码表示权限
} Role;

// 用户角色关联
typedef struct {
	char userName[TABLE_NAME_LEN];
	char roleName[TABLE_NAME_LEN];
} UserRole;

// 表权限定义
typedef struct {
	char tableName[TABLE_NAME_LEN];
	char roleName[TABLE_NAME_LEN];
	int permissions;  // 位掩码表示权限
} TablePermission;

// 权限管理命令结构
typedef struct {
	int commandType; // 7=CREATE ROLE, 8=GRANT, 9=REVOKE
	union {
		// CREATE ROLE
		struct {
			char roleName[TABLE_NAME_LEN];
			int permissions;
		} createRoleStmt;

		// GRANT
		struct {
			char roleName[TABLE_NAME_LEN];
			char tableName[TABLE_NAME_LEN];
			int permissions;
			char* userName;  // 可选，如果为空则表示授予角色权限
		} grantStmt;

		// REVOKE
		struct {
			char roleName[TABLE_NAME_LEN];
			char tableName[TABLE_NAME_LEN];
			int permissions;
			char* userName;  // 可选，如果为空则表示撤销角色权限
		} revokeStmt;
	} permData;
} PermissionCommand;

// ==================== 6. 事务管理数据结构 ====================

// 事务状态
typedef enum {
	TRANS_ACTIVE = 0,    // 活动状态
	TRANS_COMMITTED = 1, // 已提交
	TRANS_ROLLEDBACK = 2 // 已回滚
} TransactionState;

// 锁类型
typedef enum {
	LOCK_SHARED = 0,     // 共享锁
	LOCK_EXCLUS = 1   // 排他锁
} LockType;

// 锁结构
typedef struct {
	char tableName[TABLE_NAME_LEN];
	long recordOffset;    // 记录偏移量，-1表示表级锁
	LockType lockType;
	int transactionId;
	char userName[TABLE_NAME_LEN];
} Lock;

// 事务日志条目类型
typedef enum {
	LOG_INSERT = 0,      // 插入操作
	LOG_DELETE = 1,      // 删除操作
	LOG_UPDATE = 2       // 更新操作
} LogEntryType;

// 事务日志条目
typedef struct {
	LogEntryType entryType;
	int transactionId;
	char tableName[TABLE_NAME_LEN];
	long recordOffset;
	int dataSize;
	void* oldData;       // 更新/删除前的数据
	void* newData;       // 插入/更新后的数据
} TransactionLogEntry;

// 事务结构
typedef struct {
	int transactionId;
	TransactionState state;
	char userName[TABLE_NAME_LEN];
	time_t startTime;
	time_t endTime;
	int logEntryCount;
	TransactionLogEntry** logEntries; // 日志条目数组
} Transaction;

// 事务管理命令结构
typedef struct {
	int commandType; // 10=BEGIN, 11=COMMIT, 12=ROLLBACK, 13=LOCK
	union {
		// BEGIN TRANSACTION
		struct {
			int dummy; // 虚拟成员，确保结构体不为空
		} beginStmt;

		// COMMIT
		struct {
			int dummy; // 虚拟成员，确保结构体不为空
		} commitStmt;

		// ROLLBACK
		struct {
			int dummy; // 虚拟成员，确保结构体不为空
		} rollbackStmt;

		// LOCK TABLE
		struct {
			char tableName[TABLE_NAME_LEN];
			LockType lockType;
		} lockStmt;
	} transData;
} TransactionCommand;

// ==================== 7. 函数接口声明 ====================

// 系统与元数据 (Storage.c)
void InitSystem();
int SaveTableToDBF(TableMeta* table);
int dbf_get_schema(const char* name, TableMeta* outTable);
void DisplayTableStruct(const char* name);
void DisplayTableNames();
int dbf_check_exists(const char* name); // 补充声明

// B+ 树与数据操作 (Storage.c)
void bplus_init_index(const char* tableName); // 注意：实际storage.c里实现了 bplus_init_index_with_type
// 修正：支持通用 Key
int dat_insert_record(const char* tableName, void* data, int size, void* keyPtr, const char* keyType, int keySize);
// dat_search_record 现在可返回实际记录长度 via outStoredSize (若不需要可传 NULL)
int dat_search_record(const char* tableName, void* keyPtr, void* outData, int size, int* outStoredSize);
int dat_update_record(const char* tableName, int unused, void* newData, int size);
int dat_delete_record(const char* tableName, void* keyPtr); // 修正参数
int dat_scan_all(TableMeta* table, ResultSet* resultSet);
int sys_drop_table(const char* tableName);
// 补充 storage.c 中用到的辅助函数声明
long dat_get_offset_by_key(const char* tableName, void* keyPtr);
int dat_overwrite_record(long dataOffset, void* newData, int size);

// 备份/恢复 (Storage.c)
int backup_database(const char* backupDir);
int restore_database(const char* backupDir);

// 业务逻辑 (Manager.c)
int cmd_create_table(TableMeta* table);
// 修正：cmd_insert_record 已被 cmd_insert_batch 替代
// int cmd_insert_record(const char* tableName, char** values, int valueCount); 
int cmd_insert_batch(const char* tableName, char** targetCols, int targetColCount, char*** rows, int* rowValueCounts, int rowCount);
int cmd_delete_record(const char* tableName, const char* whereCondition);
int cmd_update_record(const char* tableName, char** setColumns, char** setValues, int setCount, const char* whereCondition);
int cmd_drop_table(const char* name);
// 备份/恢复接口（Manager 层封装权限检查、日志等）
int cmd_backup_database(const char* backupDir);
int cmd_restore_database(const char* backupDir);
// 修正：唯一性检查改为传指针
int check_primary_key_uniqueness(const char* tableName, TableMode* pkFieldDef, void* pkValuePtr);


// ALTER 
int cmd_alter_table(SqlCommand* cmd);
void parse_alter_statement(const char* sql, SqlCommand* cmd);

int storage_apply_alter(const char* tableName,
	const TableMeta* oldMeta,
	const TableMeta* newMeta,
	int alterType);

int dbf_update_schema(const char* tableName, const TableMeta* newMeta);


// SQL 解析 (Parser.c)
SqlCommand* sql_parser_main(const char* input);
void parse_create_statement(const char* sql, SqlCommand* cmd);
void parse_insert_statement(const char* sql, SqlCommand* cmd);
void parse_select_statement(const char* sql, SqlCommand* cmd);
void parse_delete_statement(const char* sql, SqlCommand* cmd);
void parse_update_statement(const char* sql, SqlCommand* cmd);
void parse_drop_statement(const char* sql, SqlCommand* cmd);
void parse_backup_statement(const char* sql, SqlCommand* cmd);
void parse_restore_statement(const char* sql, SqlCommand* cmd);

// 查询引擎 (Query.c)
// evaluate_condition 增加 recordSize 参数以支持兼容旧记录（ADD COLUMN 情况）
ResultSet* query_select_where(const char* tableName, const char* whereCondition);
ResultSet* query_project_columns(ResultSet* inputResultSet, char** selectColumns, int columnCount);
int evaluate_condition(void* recordData, TableMeta* table, const char* condition, int recordSize);
ResultSet* query_multitable(char tableNames[MAX_TABLES_IN_JOIN][TABLE_NAME_LEN],
	char aliases[MAX_TABLES_IN_JOIN][TABLE_NAME_LEN],
	int tableCount,
	const char* whereCondition);

// 权限管理 (Permission.c)
int init_permission_system();
int cmd_create_role(const char* roleName, int permissions);
int cmd_grant_permission(const char* roleName, const char* tableName, int permissions, const char* userName);
int cmd_revoke_permission(const char* roleName, const char* tableName, int permissions, const char* userName);
int check_permission(const char* userName, const char* tableName, int requiredPermission);
int assign_user_role(const char* userName, const char* roleName);
int remove_user_role(const char* userName, const char* roleName);
void parse_create_role_statement(const char* sql, PermissionCommand* cmd);
void parse_grant_statement(const char* sql, PermissionCommand* cmd);
void parse_revoke_statement(const char* sql, PermissionCommand* cmd);
PermissionCommand* permission_parser_main(const char* input);

// 事务管理 (Transaction.c)
int init_transaction_system();
int cmd_begin_transaction();
int cmd_commit_transaction();
int cmd_rollback_transaction();
int cmd_lock_table(const char* tableName, LockType lockType);
int cmd_unlock_table(const char* tableName);
int check_lock_conflict(const char* tableName, long recordOffset, LockType requestedLock);
int acquire_lock(const char* tableName, long recordOffset, LockType lockType);
int release_lock(const char* tableName, long recordOffset);
int log_transaction_operation(LogEntryType entryType, const char* tableName, long recordOffset, void* oldData, void* newData, int dataSize);
void parse_begin_statement(const char* sql, TransactionCommand* cmd);
void parse_commit_statement(const char* sql, TransactionCommand* cmd);
void parse_rollback_statement(const char* sql, TransactionCommand* cmd);
void parse_lock_statement(const char* sql, TransactionCommand* cmd);
TransactionCommand* transaction_parser_main(const char* input);
int get_current_transaction_id();
int is_in_transaction();

// 登录功能
int cmd_login(const char* userName);
int cmd_logout();
int cmd_current_user();

// 当前用户（全局变量）
extern char CURRENT_USER[TABLE_NAME_LEN];

// 当前事务ID（全局变量）
extern int CURRENT_TRANSACTION_ID;

#endif