841 lines
29 KiB
Python
841 lines
29 KiB
Python
"""
|
||
SQLite数据库操作通用公共类
|
||
提供数据库连接、表管理、CRUD操作等通用功能
|
||
"""
|
||
import sqlite3
|
||
import threading
|
||
import time
|
||
from typing import List, Dict, Any, Optional, Union
|
||
from pathlib import Path
|
||
from datetime import datetime
|
||
|
||
|
||
class SQLiteError(Exception):
|
||
"""SQLite操作基础异常类"""
|
||
def __init__(self, message: str, sqlite_error_code: int = None, sql: str = None,
|
||
params: tuple = None, db_path: str = None):
|
||
super().__init__(message)
|
||
self.message = message
|
||
self.sqlite_error_code = sqlite_error_code
|
||
self.sql = sql
|
||
self.params = params
|
||
self.db_path = db_path
|
||
|
||
def __str__(self):
|
||
error_info = f"SQLiteError: {self.message}"
|
||
if self.sqlite_error_code:
|
||
error_info += f" (错误代码: {self.sqlite_error_code})"
|
||
if self.sql:
|
||
error_info += f"\nSQL: {self.sql}"
|
||
if self.params:
|
||
error_info += f"\n参数: {self.params}"
|
||
if self.db_path:
|
||
error_info += f"\n数据库: {self.db_path}"
|
||
return error_info
|
||
|
||
|
||
class SQLiteBusyError(SQLiteError):
|
||
"""SQLite BUSY错误异常（用于并发控制）"""
|
||
def __init__(self, message: str, sqlite_error_code: int = None, sql: str = None,
|
||
params: tuple = None, db_path: str = None, retry_attempt: int = None, max_retries: int = None):
|
||
super().__init__(message, sqlite_error_code, sql, params, db_path)
|
||
self.retry_attempt = retry_attempt
|
||
self.max_retries = max_retries
|
||
|
||
def __str__(self):
|
||
error_info = f"SQLiteBusyError: {self.message}"
|
||
if self.sqlite_error_code:
|
||
error_info += f" (错误代码: {self.sqlite_error_code})"
|
||
if self.retry_attempt is not None and self.max_retries is not None:
|
||
error_info += f" (重试 {self.retry_attempt}/{self.max_retries})"
|
||
if self.sql:
|
||
error_info += f"\nSQL: {self.sql}"
|
||
if self.params:
|
||
error_info += f"\n参数: {self.params}"
|
||
if self.db_path:
|
||
error_info += f"\n数据库: {self.db_path}"
|
||
return error_info
|
||
|
||
|
||
def _handle_sqlite_error(error: sqlite3.Error, operation: str, sql: str = None,
|
||
params: tuple = None, db_path: str = None,
|
||
retry_attempt: int = None, max_retries: int = None) -> SQLiteError:
|
||
"""
|
||
将SQLite错误转换为自定义异常
|
||
|
||
Args:
|
||
error: 原始SQLite错误
|
||
operation: 操作描述
|
||
sql: 执行的SQL语句
|
||
params: SQL参数
|
||
db_path: 数据库路径
|
||
retry_attempt: 重试次数（用于BUSY错误）
|
||
max_retries: 最大重试次数
|
||
|
||
Returns:
|
||
SQLiteError: 对应的自定义异常
|
||
"""
|
||
error_code = getattr(error, 'sqlite_errorcode', None)
|
||
error_name = getattr(error, 'sqlite_errorname', None)
|
||
|
||
error_message = f"{operation}失败: {str(error)}"
|
||
if error_name:
|
||
error_message += f" ({error_name})"
|
||
|
||
# 如果是SQLITE_BUSY错误，返回SQLiteBusyError（用于并发控制）
|
||
if error_name == 'SQLITE_BUSY':
|
||
return SQLiteBusyError(
|
||
message=error_message,
|
||
sqlite_error_code=error_code,
|
||
sql=sql,
|
||
params=params,
|
||
db_path=db_path,
|
||
retry_attempt=retry_attempt,
|
||
max_retries=max_retries
|
||
)
|
||
|
||
# 其他所有错误都返回通用的SQLiteError
|
||
return SQLiteError(
|
||
message=error_message,
|
||
sqlite_error_code=error_code,
|
||
sql=sql,
|
||
params=params,
|
||
db_path=db_path
|
||
)
|
||
|
||
|
||
class SQLiteHandler:
|
||
"""SQLite数据库操作通用类（单例模式）"""
|
||
|
||
_lock = threading.Lock() # 单例锁
|
||
_instances = {}
|
||
@classmethod
|
||
def get_instance(cls,db_path, *args, **kwargs):
|
||
# 使用文件路径作为键
|
||
key = db_path
|
||
if key not in cls._instances:
|
||
with cls._lock:
|
||
if key not in cls._instances: # 双重检查
|
||
cls._instances[key] = cls(db_path, *args, **kwargs)
|
||
return cls._instances[key]
|
||
|
||
def __init__(self, db_path: str = "three.db", max_readers: int = 10, busy_timeout: int = 5000):
|
||
"""
|
||
初始化SQLite处理器
|
||
|
||
Args:
|
||
db_path: 数据库文件路径，默认为app.db
|
||
max_readers: 最大并发读取数，默认为10
|
||
busy_timeout: SQLITE_BUSY超时时间（毫秒），默认为5000毫秒
|
||
"""
|
||
self.db_path = db_path
|
||
self.max_readers = max_readers
|
||
self.busy_timeout = busy_timeout
|
||
|
||
# 读写分离锁
|
||
self._read_lock = threading.RLock() # 读锁（允许多个读）
|
||
self._write_lock = threading.Lock() # 写锁
|
||
self._active_readers = 0 # 当前活跃读取数
|
||
|
||
# 连接配置
|
||
self._connection_params = {
|
||
# 是否检测相同的线程（False允许在不同线程间共享连接）
|
||
"check_same_thread": False,
|
||
# 设置数据库操作超时时间（秒）
|
||
"timeout": 10
|
||
}
|
||
|
||
# SQLITE_BUSY重试配置
|
||
self.busy_retry_attempts = 3 # 重试次数
|
||
self.busy_retry_delay = 1 # 重试延迟（秒）
|
||
|
||
# 确保数据库目录存在
|
||
db_dir = Path(db_path).parent
|
||
if not db_dir.exists():
|
||
db_dir.mkdir(parents=True, exist_ok=True)
|
||
|
||
# 初始化数据库参数
|
||
self._setup_database_params()
|
||
|
||
def _setup_database_params(self):
|
||
"""设置数据库连接参数"""
|
||
try:
|
||
# 创建临时连接来设置参数
|
||
conn = sqlite3.connect(self.db_path, **self._connection_params)
|
||
|
||
# 启用WAL模式（Write-Ahead Logging）
|
||
cursor = conn.execute("PRAGMA journal_mode = WAL")
|
||
journal_mode = cursor.fetchone()[0]
|
||
print(f"WAL模式设置: {journal_mode}")
|
||
|
||
# 启用外键约束
|
||
conn.execute("PRAGMA foreign_keys = ON")
|
||
|
||
# 设置SQLITE_BUSY超时
|
||
conn.execute(f"PRAGMA busy_timeout = {self.busy_timeout}")
|
||
|
||
# 设置行工厂为字典形式
|
||
conn.row_factory = sqlite3.Row
|
||
|
||
conn.close()
|
||
print("数据库参数设置完成")
|
||
except sqlite3.Error as e:
|
||
print(f"设置数据库参数失败: {e}")
|
||
raise
|
||
|
||
def _create_connection(self) -> sqlite3.Connection:
|
||
"""创建新的数据库连接"""
|
||
conn = sqlite3.connect(self.db_path, **self._connection_params)
|
||
conn.set_trace_callback(lambda x: print(x))
|
||
conn.row_factory = sqlite3.Row
|
||
return conn
|
||
|
||
def _acquire_read_lock(self):
|
||
"""获取读锁"""
|
||
with self._read_lock:
|
||
if self._active_readers >= self.max_readers:
|
||
raise SQLiteBusyError(f"已达到最大并发读取数: {self.max_readers}")
|
||
self._active_readers += 1
|
||
|
||
def _release_read_lock(self):
|
||
"""释放读锁"""
|
||
with self._read_lock:
|
||
self._active_readers -= 1
|
||
|
||
def _acquire_write_lock(self):
|
||
"""获取写锁，超时时间为30秒"""
|
||
if not self._write_lock.acquire(timeout=30):
|
||
raise SQLiteBusyError("获取写锁超时（30秒），可能发生死锁")
|
||
|
||
|
||
|
||
def execute_read(self, sql: str, params: tuple = None) -> list:
|
||
"""
|
||
执行读操作SQL语句（使用读写锁）
|
||
|
||
Args:
|
||
sql: SQL语句
|
||
params: 参数元组
|
||
|
||
Returns:
|
||
list: 查询结果列表
|
||
|
||
Raises:
|
||
SQLiteError: SQL执行错误
|
||
SQLiteBusyError: 并发读取数超过限制
|
||
"""
|
||
start_time = time.time()
|
||
|
||
# 获取读锁
|
||
self._acquire_read_lock()
|
||
|
||
conn = self._create_connection()
|
||
try:
|
||
if params:
|
||
cursor = conn.execute(sql, params)
|
||
else:
|
||
cursor = conn.execute(sql)
|
||
# 获取所有结果并返回，避免连接关闭后游标失效
|
||
results = cursor.fetchall()
|
||
return results
|
||
except sqlite3.Error as e:
|
||
# 抛出自定义异常
|
||
raise _handle_sqlite_error(e, "执行读操作", sql, params, self.db_path)
|
||
finally:
|
||
# 关闭连接
|
||
if conn:
|
||
conn.close()
|
||
# 释放读锁
|
||
self._release_read_lock()
|
||
|
||
# 记录执行时间
|
||
execution_time = time.time() - start_time
|
||
if execution_time > 1.0:
|
||
print(f"⚠️ 读操作执行时间过长: {execution_time:.3f}秒 - SQL: {sql[:100]}{'...' if len(sql) > 100 else ''}")
|
||
|
||
def execute_write(self, sql: str, params: tuple = None) -> sqlite3.Cursor:
|
||
"""
|
||
执行写操作SQL语句（使用读写锁和BEGIN IMMEDIATE事务）
|
||
|
||
Args:
|
||
sql: SQL语句
|
||
params: 参数元组
|
||
|
||
Returns:
|
||
sqlite3.Cursor: 执行结果游标
|
||
|
||
Raises:
|
||
SQLiteError: SQL执行错误
|
||
SQLiteBusyError: SQLITE_BUSY错误，达到最大重试次数
|
||
"""
|
||
start_time = time.time()
|
||
|
||
# 获取写锁
|
||
self._acquire_write_lock()
|
||
|
||
conn = self._create_connection()
|
||
cursor = None
|
||
|
||
try:
|
||
# 使用BEGIN IMMEDIATE事务
|
||
for attempt in range(self.busy_retry_attempts):
|
||
try:
|
||
# 开始IMMEDIATE事务
|
||
conn.execute("BEGIN IMMEDIATE")
|
||
|
||
# 执行SQL
|
||
if params:
|
||
cursor = conn.execute(sql, params)
|
||
else:
|
||
cursor = conn.execute(sql)
|
||
|
||
# 提交事务
|
||
conn.commit()
|
||
return cursor
|
||
|
||
except sqlite3.OperationalError as e:
|
||
# 如果是SQLITE_BUSY错误，进行重试
|
||
if "database is locked" in str(e) or "SQLITE_BUSY" in str(e):
|
||
if attempt < self.busy_retry_attempts - 1:
|
||
conn.rollback()
|
||
print(f"SQLITE_BUSY错误，第{attempt + 1}次重试...")
|
||
time.sleep(self.busy_retry_delay)
|
||
continue
|
||
else:
|
||
# 最后一次尝试失败
|
||
conn.rollback()
|
||
raise _handle_sqlite_error(
|
||
e, "执行写操作", sql, params, self.db_path,
|
||
attempt, self.busy_retry_attempts
|
||
)
|
||
else:
|
||
# 其他操作错误，直接抛出
|
||
conn.rollback()
|
||
raise _handle_sqlite_error(e, "执行写操作", sql, params, self.db_path)
|
||
except sqlite3.Error as e:
|
||
# 其他SQLite错误，回滚并抛出
|
||
conn.rollback()
|
||
raise _handle_sqlite_error(e, "执行写操作", sql, params, self.db_path)
|
||
|
||
except sqlite3.Error as e:
|
||
raise
|
||
finally:
|
||
# 关闭连接
|
||
if conn:
|
||
conn.close()
|
||
# 释放写锁
|
||
self._write_lock.release()
|
||
|
||
# 记录执行时间
|
||
execution_time = time.time() - start_time
|
||
if execution_time > 1.0:
|
||
print(f"⚠️ 写操作执行时间过长: {execution_time:.3f}秒 - SQL: {sql[:100]}{'...' if len(sql) > 100 else ''}")
|
||
|
||
def executemany_write(self, sql: str, params_list: List[tuple]) -> sqlite3.Cursor:
|
||
"""
|
||
执行批量写操作
|
||
|
||
Args:
|
||
sql: SQL语句
|
||
params_list: 参数列表
|
||
|
||
Returns:
|
||
sqlite3.Cursor: 游标对象
|
||
|
||
Raises:
|
||
SQLiteError: SQL执行错误
|
||
SQLiteBusyError: SQLITE_BUSY错误，达到最大重试次数
|
||
"""
|
||
start_time = time.time()
|
||
|
||
# 获取写锁
|
||
self._acquire_write_lock()
|
||
|
||
conn = self._create_connection()
|
||
cursor = None
|
||
|
||
try:
|
||
# 使用BEGIN IMMEDIATE事务
|
||
for attempt in range(self.busy_retry_attempts):
|
||
try:
|
||
# 开始IMMEDIATE事务
|
||
conn.execute("BEGIN IMMEDIATE")
|
||
|
||
# 执行批量SQL
|
||
cursor = conn.cursor()
|
||
cursor.executemany(sql, params_list)
|
||
|
||
# 提交事务
|
||
conn.commit()
|
||
return cursor
|
||
|
||
except sqlite3.OperationalError as e:
|
||
# 如果是SQLITE_BUSY错误，进行重试
|
||
if "database is locked" in str(e) or "SQLITE_BUSY" in str(e):
|
||
if attempt < self.busy_retry_attempts - 1:
|
||
conn.rollback()
|
||
print(f"SQLITE_BUSY错误，第{attempt + 1}次重试...")
|
||
time.sleep(self.busy_retry_delay)
|
||
continue
|
||
else:
|
||
# 最后一次尝试失败
|
||
conn.rollback()
|
||
raise _handle_sqlite_error(
|
||
e, "执行批量写操作", sql, params_list, self.db_path,
|
||
attempt, self.busy_retry_attempts
|
||
)
|
||
else:
|
||
# 其他操作错误，直接抛出
|
||
conn.rollback()
|
||
raise _handle_sqlite_error(e, "执行批量写操作", sql, params_list, self.db_path)
|
||
except sqlite3.Error as e:
|
||
# 其他SQLite错误，回滚并抛出
|
||
conn.rollback()
|
||
raise _handle_sqlite_error(e, "执行批量写操作", sql, params_list, self.db_path)
|
||
|
||
except sqlite3.Error as e:
|
||
raise
|
||
finally:
|
||
# 关闭连接
|
||
if conn:
|
||
conn.close()
|
||
# 释放写锁
|
||
self._write_lock.release()
|
||
|
||
# 记录执行时间
|
||
execution_time = time.time() - start_time
|
||
if execution_time > 1.0:
|
||
print(f"⚠️ 批量写操作执行时间过长: {execution_time:.3f}秒 - SQL: {sql[:100]}{'...' if len(sql) > 100 else ''} (批量数量: {len(params_list)})")
|
||
|
||
def fetch_all(self, sql: str, params: tuple = None) -> List[Dict[str, Any]]:
|
||
"""
|
||
查询所有记录（使用读连接）
|
||
|
||
Args:
|
||
sql: 查询SQL
|
||
params: 查询参数
|
||
|
||
Returns:
|
||
List[Dict[str, Any]]: 查询结果列表
|
||
"""
|
||
start_time = time.time()
|
||
|
||
conn = None
|
||
try:
|
||
# 获取读锁
|
||
self._acquire_read_lock()
|
||
|
||
conn = self._create_connection()
|
||
cursor = conn.cursor()
|
||
|
||
# 执行查询
|
||
if params:
|
||
cursor.execute(sql, params)
|
||
else:
|
||
cursor.execute(sql)
|
||
|
||
rows = cursor.fetchall()
|
||
return [dict(row) for row in rows]
|
||
except sqlite3.Error as e:
|
||
# 抛出自定义异常
|
||
raise _handle_sqlite_error(e, "执行读操作", sql, params, self.db_path)
|
||
finally:
|
||
# 关闭连接
|
||
if conn:
|
||
conn.close()
|
||
# 释放读锁
|
||
self._release_read_lock()
|
||
|
||
# 记录执行时间
|
||
execution_time = time.time() - start_time
|
||
if execution_time > 1.0:
|
||
print(f"⚠️ fetch_all执行时间过长: {execution_time:.3f}秒 - SQL: {sql[:100]}{'...' if len(sql) > 100 else ''}")
|
||
|
||
def fetch_one(self, sql: str, params: tuple = None) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
查询单条记录（使用读连接）
|
||
|
||
Args:
|
||
sql: 查询SQL
|
||
params: 查询参数
|
||
|
||
Returns:
|
||
Optional[Dict[str, Any]]: 查询结果，如果没有记录返回None
|
||
"""
|
||
start_time = time.time()
|
||
|
||
conn = None
|
||
try:
|
||
# 获取读锁
|
||
self._acquire_read_lock()
|
||
|
||
conn = self._create_connection()
|
||
cursor = conn.cursor()
|
||
|
||
# 执行查询
|
||
if params:
|
||
cursor.execute(sql, params)
|
||
else:
|
||
cursor.execute(sql)
|
||
|
||
row = cursor.fetchone()
|
||
return dict(row) if row else None
|
||
except sqlite3.Error as e:
|
||
# 抛出自定义异常
|
||
raise _handle_sqlite_error(e, "执行读操作", sql, params, self.db_path)
|
||
finally:
|
||
# 关闭连接
|
||
if conn:
|
||
conn.close()
|
||
# 释放读锁
|
||
self._release_read_lock()
|
||
|
||
# 记录执行时间
|
||
execution_time = time.time() - start_time
|
||
if execution_time > 1.0:
|
||
print(f"⚠️ fetch_one执行时间过长: {execution_time:.3f}秒 - SQL: {sql[:100]}{'...' if len(sql) > 100 else ''}")
|
||
|
||
def insert(self, table: str, data: Dict[str, Any]) -> int:
|
||
"""
|
||
插入单条记录（使用写连接）
|
||
|
||
Args:
|
||
table: 表名
|
||
data: 插入数据字典
|
||
|
||
Returns:
|
||
int: 插入记录的主键ID
|
||
"""
|
||
columns = ', '.join(data.keys())
|
||
placeholders = ', '.join(['?'] * len(data))
|
||
sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
|
||
|
||
cursor = self.execute_write(sql, tuple(data.values()))
|
||
return cursor.lastrowid
|
||
|
||
def insert_select(self, target_table: str, target_columns: List[str],
|
||
source_table: str, source_columns: List[str],
|
||
where_condition: str = None, where_params: tuple = None) -> int:
|
||
"""
|
||
使用 INSERT INTO ... SELECT ... WHERE 语法从源表向目标表插入数据
|
||
Args:
|
||
target_table: 目标表名
|
||
target_columns: 目标表的列名列表
|
||
source_table: 源表名
|
||
source_columns: 源表的列名列表，与目标表列一一对应
|
||
where_condition: WHERE条件语句（不含WHERE关键字）
|
||
where_params: WHERE条件参数
|
||
|
||
Returns:
|
||
int: 插入的记录数量
|
||
"""
|
||
# 构建目标列和源列的字符串
|
||
target_cols_str = ', '.join(target_columns)
|
||
source_cols_str = ', '.join(source_columns)
|
||
|
||
# 构建基础SQL
|
||
sql = f"INSERT INTO {target_table} ({target_cols_str}) SELECT {source_cols_str} FROM {source_table}"
|
||
|
||
# 添加WHERE条件（如果有）
|
||
if where_condition:
|
||
sql += f" WHERE {where_condition}"
|
||
|
||
# 执行SQL语句
|
||
cursor = self.execute_write(sql, where_params)
|
||
return cursor.rowcount
|
||
|
||
def insert_many(self, table: str, data_list: List[Dict[str, Any]]) -> int:
|
||
"""
|
||
批量插入记录（使用写连接）
|
||
|
||
Args:
|
||
table: 表名
|
||
data_list: 数据字典列表
|
||
|
||
Returns:
|
||
int: 插入的记录数量
|
||
"""
|
||
if not data_list:
|
||
return 0
|
||
|
||
columns = ', '.join(data_list[0].keys())
|
||
placeholders = ', '.join(['?'] * len(data_list[0]))
|
||
sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
|
||
|
||
params_list = [tuple(data.values()) for data in data_list]
|
||
cursor = self.executemany_write(sql, params_list)
|
||
return cursor.rowcount
|
||
|
||
def update(self, table: str, data: Dict[str, Any], where: str, where_params: tuple = None) -> int:
|
||
"""
|
||
更新记录（使用写连接）
|
||
|
||
Args:
|
||
table: 表名
|
||
data: 更新数据字典
|
||
where: WHERE条件
|
||
where_params: WHERE条件参数
|
||
|
||
Returns:
|
||
int: 更新的记录数量
|
||
"""
|
||
set_clause = ', '.join([f"{key} = ?" for key in data.keys()])
|
||
sql = f"UPDATE {table} SET {set_clause} WHERE {where}"
|
||
|
||
params = tuple(data.values())
|
||
if where_params:
|
||
params += where_params
|
||
|
||
cursor = self.execute_write(sql, params)
|
||
return cursor.rowcount
|
||
|
||
def delete(self, table: str, where: str, where_params: tuple = None) -> int:
|
||
"""
|
||
删除记录（使用写连接）
|
||
|
||
Args:
|
||
table: 表名
|
||
where: WHERE条件
|
||
where_params: WHERE条件参数
|
||
|
||
Returns:
|
||
int: 删除的记录数量
|
||
"""
|
||
sql = f"DELETE FROM {table} WHERE {where}"
|
||
cursor = self.execute_write(sql, where_params)
|
||
return cursor.rowcount
|
||
|
||
def add_column(self, table_name: str, column_name: str, column_type: str) -> bool:
|
||
"""
|
||
添加列到表（使用写连接）
|
||
|
||
Args:
|
||
table_name: 表名
|
||
column_name: 列名
|
||
column_type: 列数据类型
|
||
|
||
Returns:
|
||
bool: 是否添加成功
|
||
"""
|
||
if not self.table_exists(table_name):
|
||
print(f"表 {table_name} 不存在")
|
||
return False
|
||
|
||
sql = f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type}"
|
||
|
||
try:
|
||
self.execute_write(sql)
|
||
print(f"列 {column_name} 添加到表 {table_name} 成功")
|
||
return True
|
||
except sqlite3.Error as e:
|
||
print(f"添加列 {column_name} 到表 {table_name} 失败: {e}")
|
||
return False
|
||
|
||
def table_exists(self, table_name: str) -> bool:
|
||
"""
|
||
检查表是否存在（使用读连接）
|
||
|
||
Args:
|
||
table_name: 表名
|
||
|
||
Returns:
|
||
bool: 表是否存在
|
||
"""
|
||
sql = "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
|
||
result = self.fetch_one(sql, (table_name,))
|
||
return result is not None
|
||
|
||
def create_table(self, table_name: str, columns: Dict[str, str]) -> bool:
|
||
"""
|
||
创建表（使用写连接）
|
||
|
||
Args:
|
||
table_name: 表名
|
||
columns: 列定义字典，格式为 {列名: 数据类型}
|
||
|
||
Returns:
|
||
bool: 是否创建成功
|
||
"""
|
||
if self.table_exists(table_name):
|
||
print(f"表 {table_name} 已存在")
|
||
return True
|
||
|
||
# 构建CREATE TABLE语句
|
||
column_definitions = ', '.join([f"{col_name} {col_type}" for col_name, col_type in columns.items()])
|
||
sql = f"CREATE TABLE {table_name} ({column_definitions})"
|
||
|
||
try:
|
||
self.execute_write(sql)
|
||
print(f"表 {table_name} 创建成功")
|
||
return True
|
||
except sqlite3.Error as e:
|
||
print(f"创建表 {table_name} 失败: {e}")
|
||
return False
|
||
|
||
def get_table_info(self, table_name: str) -> List[Dict[str, Any]]:
|
||
"""
|
||
获取表结构信息（使用读连接）
|
||
|
||
Args:
|
||
table_name: 表名
|
||
|
||
Returns:
|
||
List[Dict[str, Any]]: 表结构信息列表
|
||
"""
|
||
if not self.table_exists(table_name):
|
||
print(f"表 {table_name} 不存在")
|
||
return []
|
||
|
||
sql = f"PRAGMA table_info({table_name})"
|
||
return self.fetch_all(sql)
|
||
|
||
def get_table_count(self, table_name: str, where: str = None, where_params: tuple = None) -> int:
|
||
"""
|
||
获取表记录数量（使用读连接）
|
||
|
||
Args:
|
||
table_name: 表名
|
||
where: WHERE条件
|
||
where_params: WHERE条件参数
|
||
|
||
Returns:
|
||
int: 记录数量
|
||
"""
|
||
sql = f"SELECT COUNT(*) as count FROM {table_name}"
|
||
if where:
|
||
sql += f" WHERE {where}"
|
||
|
||
result = self.fetch_one(sql, where_params)
|
||
return result['count'] if result else 0
|
||
|
||
def vacuum(self,max_retries=3):
|
||
"""执行VACUUM操作，优化数据库（使用写连接）"""
|
||
for attempt in range(max_retries):
|
||
try:
|
||
self.execute_write("VACUUM")
|
||
return True
|
||
except SQLiteBusyError:
|
||
if attempt < max_retries - 1:
|
||
time.sleep(2 ** attempt) # 指数退避
|
||
else:
|
||
raise
|
||
|
||
def backup_database(self, backup_path: str) -> bool:
|
||
"""
|
||
备份数据库到指定文件（使用写连接）
|
||
|
||
Args:
|
||
backup_path: 备份文件路径
|
||
|
||
Returns:
|
||
bool: 备份是否成功
|
||
"""
|
||
try:
|
||
# 确保备份目录存在
|
||
backup_dir = Path(backup_path).parent
|
||
if not backup_dir.exists():
|
||
backup_dir.mkdir(parents=True, exist_ok=True)
|
||
|
||
# 使用SQLite的备份API
|
||
source_conn = self._create_connection()
|
||
backup_conn = sqlite3.connect(backup_path)
|
||
|
||
# 执行备份
|
||
source_conn.backup(backup_conn)
|
||
backup_conn.close()
|
||
|
||
print(f"数据库备份成功: {backup_path}")
|
||
return True
|
||
except sqlite3.Error as e:
|
||
print(f"数据库备份失败: {e}")
|
||
return False
|
||
|
||
def create_incremental_backup(self, backup_dir: str, max_backups: int = 10) -> bool:
|
||
"""
|
||
创建增量备份，自动管理备份文件数量
|
||
|
||
Args:
|
||
backup_dir: 备份目录
|
||
max_backups: 最大备份文件数量
|
||
|
||
Returns:
|
||
bool: 备份是否成功
|
||
"""
|
||
try:
|
||
# 确保备份目录存在
|
||
backup_path = Path(backup_dir)
|
||
if not backup_path.exists():
|
||
backup_path.mkdir(parents=True, exist_ok=True)
|
||
|
||
# 生成备份文件名（包含时间戳）
|
||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
db_name = Path(self.db_path).stem
|
||
backup_file = backup_path / f"{db_name}_backup_{timestamp}.db"
|
||
|
||
# 执行备份
|
||
success = self.backup_database(str(backup_file))
|
||
|
||
if success:
|
||
# 清理旧的备份文件
|
||
backup_files = list(backup_path.glob(f"{db_name}_backup_*.db"))
|
||
backup_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
|
||
|
||
# 删除超出数量的旧备份
|
||
for old_backup in backup_files[max_backups:]:
|
||
old_backup.unlink()
|
||
print(f"删除旧备份: {old_backup.name}")
|
||
|
||
print(f"增量备份完成，当前备份数量: {min(len(backup_files), max_backups)}")
|
||
|
||
return success
|
||
except Exception as e:
|
||
print(f"增量备份失败: {e}")
|
||
return False
|
||
|
||
# 使用示例
|
||
if __name__ == "__main__":
|
||
# 创建数据库处理器
|
||
db = SQLiteHandler.get_instance("db/three.db", max_readers=50, busy_timeout=4000)
|
||
|
||
# # 创建表
|
||
# columns = {
|
||
# "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
|
||
# "name": "TEXT NOT NULL",
|
||
# "age": "INTEGER",
|
||
# "created_at": "TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
|
||
# }
|
||
# db.create_table("users", columns)
|
||
|
||
# # 插入数据
|
||
# user_data = {"name": "张三", "age": 25}
|
||
# user_id = db.insert("users", user_data)
|
||
# print(f"插入用户ID: {user_id}")
|
||
|
||
# # 批量插入
|
||
# users_data = [
|
||
# {"name": "李四", "age": 30},
|
||
# {"name": "王五", "age": 28}
|
||
# ]
|
||
# count = db.insert_many("users", users_data)
|
||
# print(f"批量插入数量: {count}")
|
||
|
||
# # 查询数据
|
||
# users = db.fetch_all("SELECT * FROM users")
|
||
# print("所有用户:", users)
|
||
|
||
# # 更新数据
|
||
# update_count = db.update("users", {"age": 26}, "id = ?", (user_id,))
|
||
# print(f"更新记录数: {update_count}")
|
||
|
||
# # 查询单条
|
||
# user = db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
|
||
# print("单个用户:", user)
|
||
|
||
# # 删除数据
|
||
# delete_count = db.delete("users", "age > ?", (25,))
|
||
# print(f"删除记录数: {delete_count}")
|
||
|
||
# # 获取表信息
|
||
# table_info = db.get_table_info("users")
|
||
# print("表结构:", table_info)
|
||
|