admin/yakpanel-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
03e73a2c4cd74b48492f021ef7fbbc7c6288f82c
yakpanel-core/class/public/sqlite_easy.py

3094 lines
92 KiB
Python
Raw Normal View History

Initial YakPanel commit
2026-04-07 02:04:22 +05:30
# Easy Sqlite Toolkit
# Author Zhj<2022-12-06>
import typing
import fcntl
import os
import sqlite3
import time
import traceback
import re
import copy
import weakref
from functools import reduce
from contextlib import contextmanager
import public
from .gcmanager import gc_enable, gc_disable
from .tools import is_number
from .exceptions import HintException, PanelError
_BASE_DIR = '/www/server/panel'
# 记录错误日志
def _log(e):
if isinstance(e, HintException):
return
# 日志目录
log_dir = '{}/logs/sqlite_easy/{}'.format(_BASE_DIR, time.strftime('%Y%m'))
# 确保目录已创建
if not os.path.exists(log_dir):
os.makedirs(log_dir, 0o600)
# 记录错误日志
with open('{}/{}.log'.format(log_dir, time.strftime('%d')), 'a') as fp:
fp.write('[{}]{}\n'.format(time.strftime('%Y-%m-%d %X'), str(e)))
# 如果是异常，打印异常堆栈信息
if isinstance(e, BaseException):
fp.write('{}\n'.format(traceback.format_exc()))
# 日志打印
def _log2(s, log_file='sqlite_client.log'):
log_dir = '{}/logs'.format(_BASE_DIR)
# 确保目录已创建
if not os.path.exists(log_dir):
os.makedirs(log_dir, 0o600)
with open('{}/{}'.format(log_dir, log_file), 'a') as fp:
fp.write('[{}]{}\n'.format(time.strftime('%Y-%m-%d %X'), s))
def _to_tuple(p):
'''
@name 将输入参数转为元组
@author Zhj<2022-07-16>
@param p<mixed> 输入参数
@return tuple
'''
# 输入参数为元组时 直接返回
if isinstance(p, tuple):
return p
# 输入参数为列表时 转为元组
if isinstance(p, list):
return tuple(p)
# 其他情况 直接创建一个元组 并将参数放入其中
return (p,)
# 正则表达式列表
# 匹配SQL字段名称的正则表达式
match_field_reg = re.compile(r'^(?:`?(\w+)`?\.)?`?(\w+)`?$', flags=re.IGNORECASE)
# 匹配表名的正则表达式
match_table_name_reg = re.compile(r'^([\w`]+)(?:(?:\s+AS\s+|\s+)([\w`]+))?$', flags=re.IGNORECASE)
# 匹配【?】号的正则表达式
search_question_reg = re.compile(r'\?')
# 匹配查询字段名称的正则表达式
match_row_key_reg = re.compile(r'^(?:distinct\s+)?(?:[\w`]+\.)?([\w`]+)(?:(?:\s+AS\s+|\s+)([\w`]+))?$', flags=re.IGNORECASE)
# 匹配查询字段别名的正则表达式
search_row_key_reg = re.compile(r'(?:\s+AS\s+|\s+)([\w`]+)$', flags=re.IGNORECASE)
# 匹配SQL逻辑操作符【AND】【OR】的正则表达式
search_logic_opt_reg = re.compile(r'\s+(?:AND|OR)\s+', flags=re.IGNORECASE)
# 匹配以【1 AND 】开头的WHERE语句的正则表达式
match_where_str_begin_reg = re.compile(r'^1\s+(?:AND|OR)\s+', flags=re.IGNORECASE)
# 匹配引号【'】【"】的正则表达式
search_quote_reg = re.compile(r'(?<!\\)([\'"])')
# 匹配子查询的正则表达式
search_subquery_reg = re.compile(r'^(\([\s\S]+?\))(?:(?:\s+AS\s+|\s+)([\w`]+))?$', flags=re.IGNORECASE)
def _add_backtick_for_field(field):
'''
@name 给字段名添加反引号
@author Zhj<2022-07-16>
@param field<string> 字段名
@return string
'''
return match_field_reg.sub(lambda m: '{}{}'.format(
'' if m.group(1) is None else '`%s`.' % m.group(1),
'`%s`' % m.group(2)
), str(field).strip())
def _format_cursor(cursor):
'''
@name 将cursor对象转换为list对象
@author Zhj<2023-04-25>
@param cursor<sqlite.Cursor> 游标对象
@return list
'''
gc_disable()
cols = tuple(map(lambda x: x[0], cursor.description))
data = []
for row in cursor:
d = {}
i = 0
for col in cols:
d[col] = row[i]
i += 1
data.append(d)
cursor.close()
gc_enable()
return data
@contextmanager
def _auto_repair_context(db_path):
'''
@name 自动修复sqlite数据库的上下文环境
@author Zhj<2023-03-15>
@param db_path<string> sqlite数据库绝对路径
@return void
'''
# os.chdir(_BASE_DIR)
# sys.path.insert(0, _BASE_DIR)
#
# import core.include.public as public
# path = os.getcwd()
# monitor_backpath = path + '/backupDB/monitor_mgr_bak.db'
# safety_backpath = path + '/backupDB/safety_bak.db'
try:
yield
except BaseException as e:
if str(db_path).startswith(':memory:'):
raise e
if str(e) in ['database disk image is malformed', 'file is not a database']:
# TODO 修复数据库
# public.ExecShell('\cp -rf %s %s' % (monitor_backpath,db_path))
# public.ExecShell('\cp -rf %s %s' % (safety_backpath,db_path))
pass
raise e
class Where:
'''
@name where条件收集类
@author Zhj<2022-07-16>
'''
__slots__ = ['__WHERE_STR', '__BIND_PARAMS']
def __init__(self):
self.__WHERE_STR = '1'
self.__BIND_PARAMS = ()
# def __del__(self):
# self.clear()
def add(self, condition, bind_params=(), logic='AND'):
'''
@name 添加where条件
@author Zhj<2022-07-16>
@param condition<string> where条件
@param bind_params<tuple|list> 绑定参数
@param logic<string> 逻辑运算符 AND|OR
@return self
'''
self.__judge_the_logic(logic)
# 当检测condition为字段名且存在参数绑定时，自动添加"=?"
if match_field_reg.match(condition) and len(_to_tuple(bind_params)) > 0:
condition = '{} = ?'.format(_add_backtick_for_field(condition))
where_str = ' {} ({})' if search_logic_opt_reg.search(condition) else ' {} {}'
self.__WHERE_STR += where_str.format(logic.upper(), str(condition))
self.__BIND_PARAMS += _to_tuple(bind_params)
return self
def add_where_in(self, field, vals, logic='AND', not_in=False):
'''
@name 添加where IN查询条件
@param field<string> 字段名
@param vals<list|tuple> 查询条件
@param logic<string> 逻辑运算符 AND|OR
@param not_in<bool> 是否为NOT IN
@return self
'''
self.__judge_the_logic(logic)
if isinstance(vals, str) or isinstance(vals, int) or isinstance(vals, float):
vals = [vals]
# 空列表
# (IN)构建where 0
# (NOT IN)构建where 1
if len(vals) == 0:
self.__WHERE_STR += ' {} {}'.format(logic.upper(), 1 if not_in else 0)
return self
# 元组转列表
if isinstance(vals, tuple):
vals = list(vals)
# 去重
vals = list(set(vals))
# 构造where条件
tmp = []
where_params = ()
# 绑定参数过多时使用字符串拼接
is_to_more_vals = len(vals) > 300
if is_to_more_vals:
for val in vals:
if is_number(val):
tmp.append(str(val))
continue
tmp.append("'{}'".format(search_quote_reg.sub(r'\\\1', str(val))))
else:
for val in vals:
tmp.append('?')
where_params += (val,)
self.__WHERE_STR += ' {} {} {} ({})'.format(
logic.upper(),
_add_backtick_for_field(field),
'IN' if not not_in else 'NOT IN',
','.join(tmp)
)
self.__BIND_PARAMS += where_params
return self
def add_nest(self, where_obj, logic='AND'):
self.__judge_the_logic(logic)
if not isinstance(where_obj, Where):
raise RuntimeError('parameter where_obj must a type of Where')
self.__WHERE_STR += ' {} ({})'.format(logic.upper(), where_obj.to_string())
self.__BIND_PARAMS += where_obj.get_bind_params()
return self
def __judge_the_logic(self, logic):
if logic.upper() not in ['AND', 'OR']:
raise RuntimeError('parameter logic must be AND or OR')
def to_string(self):
where_str = match_where_str_begin_reg.sub('', self.__WHERE_STR)
if len(where_str) == 0:
return '1'
return where_str
def get_bind_params(self):
return self.__BIND_PARAMS
def build(self):
'''
@name 获取where条件表达式和绑定参数
@author Zhj<2022-07-16>
@return (where条件<string>, 绑定参数<tuple>)
'''
where_str = match_where_str_begin_reg.sub('', self.__WHERE_STR)
if len(where_str) == 0:
return '', ()
return ' WHERE {}'.format(where_str), self.__BIND_PARAMS
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__WHERE_STR = '1'
self.__BIND_PARAMS = ()
return self
class Limit:
'''
@name limit条件收集类
@author Zhj<2022-07-16>
'''
__slots__ = ['__LIMIT', '__SKIP']
def __init__(self):
self.__LIMIT = None
self.__SKIP = None
# def __del__(self):
# self.clear()
def set_limit(self, limit):
'''
@name 设置limit
@author Zhj<2022-07-16>
@param limit<integer> 查询行数
@return self
'''
self.__LIMIT = int(limit)
return self
def set_skip(self, skip):
'''
@name 设置skip
@author Zhj<2022-07-16>
@param skip<integer> 跳过的行数
@return self
'''
self.__SKIP = int(skip)
return self
def build(self):
'''
@name 获取limit条件表达式
@author Zhj<2022-17-16>
@return string
'''
if self.__LIMIT is None:
return ''
if self.__SKIP is None:
return ' LIMIT {}'.format(str(self.__LIMIT))
return ' LIMIT {},{}'.format(str(self.__SKIP), str(self.__LIMIT))
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__LIMIT = None
self.__SKIP = None
return self
class Order:
'''
@name order排序条件收集类
@author ZHj<2022-07-16>
'''
__slots__ = ['__ORDERS', '__BIND_PARAMS']
def __init__(self):
self.__ORDERS = []
self.__BIND_PARAMS = ()
# def __del__(self):
# self.clear()
def add_order(self, field, ordering='ASC', params=()):
'''
@name 添加排序条件
@author Zhj<2022-07-16>
@param field<string> 字段名
@param ordering<string> 排序方式 ASC|DESC
@param params<list|tuple> 绑定参数
@return self
'''
self.__ORDERS.append('{} {}'.format(
_add_backtick_for_field(field),
ordering.upper()
))
self.__BIND_PARAMS += _to_tuple(params)
return self
def build(self):
'''
@name 获取排序条件表达式和绑定参数
@author Zhj<2022-07-16>
@return (排序条件表达式<string>, 绑定参数<tuple>)
'''
if len(self.__ORDERS) == 0:
return '', ()
return ' ORDER BY {}'.format(', '.join(self.__ORDERS)), self.__BIND_PARAMS
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__ORDERS = []
self.__BIND_PARAMS = ()
return self
class Field:
'''
@name 查询字段收集类
@author Zhj<2022-07-16>
'''
__slots__ = ['__FIELDS']
def __init__(self):
self.__FIELDS = []
# def __del__(self):
# self.clear()
def set_fields(self, *fields):
'''
@name 设置查询字段
@author Zhj<2022-07-17>
@param fields<tuple> 查询字段列表
@return self
'''
self.__FIELDS = list(
map(lambda field: _add_backtick_for_field(field),
filter(lambda x: x is not None, fields)
)
)
return self
def add_fields(self, *fields):
'''
@name 添加查询字段
@author Zhj<2022-07-16>
@param fields<tuple> 查询字段列表
@return self
'''
self.__FIELDS += list(
map(lambda field: _add_backtick_for_field(field),
filter(lambda x: x is not None, fields)
)
)
return self
def build(self):
'''
@name 获取查询字段列表
@author Zhj<2022-07-16>
@return string
'''
if len(self.__FIELDS) == 0:
return '*'
return ', '.join(list(set(self.__FIELDS)))
def is_empty(self):
'''
@name 检查是否为空
@author Zhj<2022-07-20>
@return bool
'''
return len(self.__FIELDS) == 0
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__FIELDS = []
return self
class Group:
'''
@name 分组条件收集类
@author Zhj<2022-07-16>
'''
__slots__ = ['__GROUPS', '__BIND_PARAMS']
def __init__(self):
self.__GROUPS = []
self.__BIND_PARAMS = ()
# def __del__(self):
# self.clear()
def add_group(self, condition, params=()):
'''
@name 添加分组条件
@author Zhj<2022-07-16>
@param condition<string> 分组条件
@param params<list|tuple> 绑定参数
@return self
'''
self.__GROUPS.append(str(condition).strip())
self.__BIND_PARAMS += _to_tuple(params)
return self
def build(self):
'''
@name 获取分组条件表达式和绑定参数
@author Zhj<2022-07-16>
@return (分组条件表达式<string>, 绑定参数<tuple>)
'''
if len(self.__GROUPS) == 0:
return '', ()
return ' GROUP BY {}'.format(', '.join(self.__GROUPS)), self.__BIND_PARAMS
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__GROUPS = []
self.__BIND_PARAMS = ()
return self
class Having:
'''
@name 分组筛选条件收集类
@author Zhj<2022-07-16>
'''
__slots__ = ['__HAVINGS', '__BIND_PARAMS']
def __init__(self):
self.__HAVINGS = []
self.__BIND_PARAMS = ()
# def __del__(self):
# self.clear()
def add_having(self, condition, params=()):
'''
@name 添加分组筛选条件
@author Zhj<2022-07-16>
@param condition<string> 分组筛选条件
@param params<list|tuple> 绑定参数
@return self
'''
self.__HAVINGS.append(str(condition).strip())
self.__BIND_PARAMS += _to_tuple(params)
return self
def build(self):
'''
@name 获取分组筛选条件表达式和绑定参数
@author Zhj<2022-07-16>
@return (分组筛选条件表达式<string>, 绑定参数<tuple>)
'''
if len(self.__HAVINGS) == 0:
return '', ()
return ' HAVING {}'.format(', '.join(self.__HAVINGS)), self.__BIND_PARAMS
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__HAVINGS = []
self.__BIND_PARAMS = ()
return self
class Join:
'''
@name 关联条件收集类
@author Zhj<2022-07-16>
'''
__slots__ = ['__JOINS']
def __init__(self):
self.__JOINS = []
# def __del__(self):
# self.clear()
def add_join(self, expression, condition, join_type='INNER', table_prefix=''):
'''
@name 添加关联条件
@author Zhj<2022-07-16>
@param expression<string> 表达式
@param condition<string> 关联条件
@param join_type<string> 关联方式 INNER|LEFT|RIGHT
@param table_prefix<string> 表前缀
@return self
'''
m = match_table_name_reg.match(expression)
if m:
expression = '{}{}'.format(
_add_backtick_for_field('{}{}'.format(table_prefix, m.group(1).strip('`'))),
'' if m.group(2) is None else ' AS {}'.format(_add_backtick_for_field(m.group(2)))
)
self.__JOINS.append('{} JOIN {} ON {}'.format(
join_type.upper(),
str(expression).strip(),
str(condition).strip()
))
return self
def build(self):
'''
@name 获取关联条件表达式
@author Zhj<2022-07-16>
@return string
'''
if len(self.__JOINS) == 0:
return ''
return ' ' + ' '.join(self.__JOINS)
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-16>
@return self
'''
self.__JOINS = []
return self
class Update:
'''
@name Update条件
@author Zhj<2022-07-17>
'''
__slots__ = ['__UPDATES', '__BIND_PARAMS']
def __init__(self):
self.__UPDATES = []
self.__BIND_PARAMS = ()
# def __del__(self):
# self.clear()
def add(self, field, value):
'''
@name 添加更新条件
@author Zhj<2022-07-17>
@param field<string> 字段名
@param value<integer|string> 值
@return self
'''
self.__UPDATES.append('{} = ?'.format(_add_backtick_for_field(field)))
self.__BIND_PARAMS += _to_tuple(value)
return self
def increment(self, field, step=1):
'''
@name 自增
@author Zhj<2022-07-17>
@param field<string> 字段名
@param step<integer> 值
@return self
'''
self.__UPDATES.append('{field} = {field} + {step}'.format(
field=_add_backtick_for_field(field),
step=str(int(step))
))
return self
def decrement(self, field, step=1):
'''
@name 自减
@author Zhj<2022-07-17>
@param field<string> 字段名
@param step<integer> 值
@return self
'''
self.__UPDATES.append('{field} = {field} - {step}'.format(
field=_add_backtick_for_field(field),
step=str(int(step))
))
return self
def exp(self, field, exp):
'''
@name 添加原生表达式
@author Zhj<2022-12-08>
@param field<string> 字段名
@param exp<string> 原生表达式
@return:
'''
self.__UPDATES.append('{field} = {exp}'.format(
field=_add_backtick_for_field(field),
exp=str(exp)
))
return self
def build(self):
'''
@name 获取更新表达式和绑定参数
@author Zhj<2022-07-17>
@return self
'''
if self.is_empty():
return '', ()
return ', '.join(self.__UPDATES), self.__BIND_PARAMS
def is_empty(self):
'''
@name 检查update条件是否为空
@author Zhj<2022-07-17>
@return bool
'''
return len(self.__UPDATES) == 0
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-07-17>
@return self
'''
self.__UPDATES = []
self.__BIND_PARAMS = ()
return self
class Duplicate(Update):
'''
@name Duplicate条件
@author Zhj<2024-12-19>
'''
def __init__(self):
Update.__init__(self)
def build(self):
if self.is_empty():
return '', ()
raw_sql, binds = Update.build(self)
return ' ON CONFLICT DO UPDATE SET ' + raw_sql, binds
class AlterTable:
__slots__ = ['__weakref__', '__QUERY', '__COLUMNS', '__RENAME_TABLE', '__ALTERS']
def __init__(self, query):
if not isinstance(query, SqliteEasy):
raise RuntimeError('参数query必须是一个SqliteEasy类型')
self.__QUERY = weakref.proxy(query)
self.__COLUMNS = []
self.__RENAME_TABLE = None
self.__ALTERS = []
# def __del__(self):
# self.clear()
# self.__COLUMNS = []
# self.__ALTERS = []
# self.__QUERY = None
def rename_table(self, new_table_name):
'''
@name 更新表名
@author Zhj<2022-09-21>
@param new_table_name<string> 新表名
@return self
'''
self.__RENAME_TABLE = ' RENAME TO {}'.format(_add_backtick_for_field(new_table_name))
return self
def rename_column(self, col_name, new_col_name):
'''
@name 更新字段名
@author Zhj<2022-09-21>
@param col_name<string> 当前字段名
@param new_col_name<string> 新字段名
@return self
'''
if self.__column_exists(col_name):
self.__ALTERS.append(' RENAME COLUMN {} TO {}'.format(_add_backtick_for_field(col_name), _add_backtick_for_field(new_col_name)))
self.__COLUMNS.remove(col_name)
self.__COLUMNS.append(new_col_name)
return self
def add_column(self, col_name, prop, force=False):
'''
@name 新增字段
@author Zhj<2022-09-21>
@param col_name<string> 字段名
@param prop<string> 字段属性
@param force<?bool> 是否强制新增(删除旧的字段)[可选]
@return self
'''
if force:
self.drop_column(col_name)
if not self.__column_exists(col_name):
self.__ALTERS.append(' ADD COLUMN {} {}'.format(_add_backtick_for_field(col_name), prop))
self.__COLUMNS.append(col_name)
return self
def drop_column(self, col_name):
'''
@name 删除字段
@author Zhj<2022-09-21>
@param col_name<string> 字段名
@return self
'''
if self.__column_exists(col_name):
self.__ALTERS.append(' DROP COLUMN {}'.format(_add_backtick_for_field(col_name)))
self.__COLUMNS.remove(col_name)
return self
def __column_exists(self, col_name):
'''
@name 检查字段是否已经存在
@author Zhj<2022-09-21>
@param col_name<string> 字段名
@return bool
'''
if len(self.__COLUMNS) == 0:
self.__COLUMNS = self.__QUERY.get_columns()
return col_name in self.__COLUMNS
def build(self, table_name):
'''
@name 构建语句
@author Zhj<2022-09-21>
@param table_name<string> 表名
@return string|None
'''
if self.is_empty():
return None
ret = "begin;\n"
ret += "\n".join(list(map(lambda x: 'ALTER TABLE {}{};'.format(table_name, x), self.__ALTERS)))
ret += "ALTER TABLE {}{};\n".format(table_name,
self.__RENAME_TABLE) if self.__RENAME_TABLE is not None else "\n"
ret += 'commit;'
return ret
def is_empty(self):
'''
@name 检查更新条件是否为空
@author Zhj<2022-09-21>
@return bool
'''
return self.__RENAME_TABLE is None and len(self.__ALTERS) == 0
def clear(self):
'''
@name 清空收集数据
@author Zhj<2022-09-21>
@return self
'''
self.__ALTERS = []
return self
class DbConnection:
'''
@name Sqlite数据库连接类(相比Db类更加底层)
@author Zhj<2022-12-13>
'''
__slots__ = ['__DB_NAME', '__DB_PATH', '__DB_LOCK_FILE', '__CONN', '__DEBUG_LOG', 'ENGINE']
def __init__(self, db_name, engine=None):
'''
@name 初始化函数
@author Zhj<2022-12-14>
@param db_name<string> 数据库名称(全路径 不包含.db)
@return void
'''
self.ENGINE = sqlite3 if engine is None else engine
self.__DB_NAME = db_name
self.__DB_PATH = '{}.db'.format(db_name)
if str(db_name).startswith(':memory:'):
self.__DB_PATH = ':memory:'
else:
if os.path.exists(db_name):
self.__DB_PATH = db_name
# 数据库连接对象
self.__CONN: typing.Optional[sqlite3.Connection] = None
# 数据库并发文件锁
self.__DB_LOCK_FILE = None
if self.__DB_PATH != ':memory:':
self.__DB_LOCK_FILE = '/tmp/aap_locks/{}.lock'.format(self.__DB_PATH.replace('/', '____'))
dirname = os.path.dirname(self.__DB_LOCK_FILE)
if not os.path.exists(dirname):
os.makedirs(dirname, 0o775)
if not os.path.exists(self.__DB_LOCK_FILE):
with open(self.__DB_LOCK_FILE, 'ab'):
pass
# 连接数据库
self.connect()
# # 析构函数
# def __del__(self):
# try:
# # 关闭数据库连接
# self.close()
# except BaseException as e:
# _log(e)
# 数据库读操作并发锁
@contextmanager
def __rlock(self):
if self.__DB_LOCK_FILE is not None:
with open(self.__DB_LOCK_FILE, 'rb') as fp:
fcntl.flock(fp.fileno(), fcntl.LOCK_SH)
yield
else:
yield
# 数据库写操作并发锁
@contextmanager
def __wlock(self):
if self.__DB_LOCK_FILE is not None:
with open(self.__DB_LOCK_FILE, 'rb+') as fp:
fcntl.flock(fp.fileno(), fcntl.LOCK_EX)
yield
else:
yield
# 获取sqlite连接对象
def conn_obj(self) -> sqlite3.Connection:
'''
@name 获取sqlite数据库连接对象<sqlite3.Connection>
@author Zhj<2022-12-22>
@return sqlite3.Connection|None
'''
return self.__CONN
# 连接sqlite
def connect(self):
if isinstance(self.__CONN, self.ENGINE.Connection):
return self.__CONN
# 连接数据库(写)
self.__CONN = self.ENGINE.connect(self.__DB_PATH, timeout=15, check_same_thread=False)
self.__CONN.text_factory = str
self.__CONN.isolation_level = 'IMMEDIATE'
# 关闭连接
def close(self):
'''
@name 关闭sqlite连接
'''
# 关闭sqlite数据库连接
if isinstance(self.__CONN, self.ENGINE.Connection):
try:
self.__CONN.close()
except BaseException as e:
_log(e)
# 开启事务(sqlite自动开启，无需手动调用)
def start_transaction(self):
'''
@name 开启事务
@return bool
'''
return True
# 提交事务
def commit(self) -> bool:
'''
@name 提交事务
@return bool
'''
if isinstance(self.__CONN, self.ENGINE.Connection) and self.__CONN.in_transaction:
self.__CONN.commit()
return True
return False
# 回滚事务
def rollback(self) -> bool:
'''
@name 回滚事务
@return bool
'''
if isinstance(self.__CONN, self.ENGINE.Connection) and self.__CONN.in_transaction:
self.__CONN.rollback()
return True
return False
# 重试辅助函数
def __sqlite_retry_help(self, fn, *args, **kwargs):
retries = 25 # 尝试最大次数
retry_interval = 20 # 每次尝试间隔时间/ms
while retries > 0:
try:
return fn(*args, **kwargs)
except (
SystemError, KeyError, self.ENGINE.InterfaceError, self.ENGINE.InternalError, self.ENGINE.OperationalError) as e:
# 数据库操作错误，不是锁协议错误，直接抛出异常
if isinstance(e, self.ENGINE.OperationalError) and str(e) not in ['locking protocol',
'database is locked']:
raise e
# 最后一次尝试失败后直接raise异常
if retries == 1:
raise e
# 打印异常信息
_log(e)
e = None
del (e,)
time.sleep(retry_interval * 0.001)
finally:
retries -= 1
# 查询
def query(self, sql, params=(), take_first=False):
'''
@name 执行查询SQL
@param sql<string> sql语句
@param params<list|tuple> 绑定参数[可选]
@param take_first<bool> 是否只获取一行数据[可选 默认获取所有行]
@return list|dict|None
'''
# 读锁
with self.__rlock():
s_time = time.time()
e_time = s_time
try:
ret = self.__sqlite_retry_help(self.__query_help, sql, params, take_first)
e_time = time.time()
return ret
finally:
if e_time - s_time > 1:
_log2('{}s {}'.format(round(e_time - s_time, 2),
reduce(lambda x, y: search_question_reg.sub(
str(y) if is_number(y) else "'%s'" % y, x, 1), params, sql)),
'sqlite_slow.log')
# 查询(辅助函数)
def __query_help(self, sql, params=(), take_first=False):
with _auto_repair_context(self.__DB_PATH):
try:
# 执行SQL
# 获取游标对象
cur = self.__CONN.execute(sql, _to_tuple(params))
except:
# 打印sql语句与绑定参数
_log('{}\nbindings: {}\ndb: {}'.format(sql, params, self.__DB_NAME))
cur = None
del (cur,)
# 抛出异常
raise
try:
s_time = time.time()
ret = _format_cursor(cur)
e_time = time.time()
if e_time - s_time > 1:
_log2('{}s format_cursor'.format(round(e_time - s_time, 2)), 'sqlite_slow.log')
del (cur,)
# 只获取首行数据
if take_first:
if len(ret) == 0:
return None
return ret[0]
return list(ret)
except:
# 打印sql语句与绑定参数
_log('{}\nbindings: {}\ndb: {}'.format(sql, params, self.__DB_NAME))
cur = None
del (cur,)
raise
# 执行单条SQL语句
def execute(self, sql, params=(), get_rowid=False):
'''
@name 执行SQL
@param sql<string> sql语句
@param params<tuple|list> 绑定参数
@param get_rowid<bool> 获取插入ID
@return int 影响行数或插入ID
'''
# 写锁
with self.__wlock():
return self.__sqlite_retry_help(self.__execute_help, sql, params, get_rowid)
# 执行单条SQL语句(辅助函数)
def __execute_help(self, sql, params=(), get_rowid=False):
with _auto_repair_context(self.__DB_PATH):
try:
# 获取游标对象
cur = self.__CONN.cursor()
# 执行SQL
cur.execute(sql, _to_tuple(params))
except:
# 打印sql语句与绑定参数
_log('{}\nbindings: {}\ndb: {}'.format(sql, params, self.__DB_NAME))
cur = None
del (cur,)
# 抛出异常
raise
try:
# 获取新插入数据ID
if get_rowid:
return cur.lastrowid
# 返回受影响的行数
return cur.rowcount
finally:
# 主动关闭Cursor
cur.close()
cur = None
del (cur,)
# 执行批量写入
def execute_many(self, sql, params=()):
'''
@name 批量插入
@param sql<string> sql语句
@param params<tuple|list> 绑定参数
@return int 影响行数
'''
# 写锁
with self.__wlock():
return self.__sqlite_retry_help(self.__execute_many_help, sql, params)
# 执行批量写入(辅助函数)
def __execute_many_help(self, sql, params=()):
with _auto_repair_context(self.__DB_PATH):
try:
# 获取游标对象
cur = self.__CONN.cursor()
# 执行SQL
cur.executemany(sql, params)
except:
# 打印sql语句与绑定参数
_log('{}\nbindings: {}\ndb: {}'.format(sql, params, self.__DB_NAME))
cur = None
del (cur,)
# 抛出异常
raise
rowcount = cur.rowcount
# 主动关闭Cursor
cur.close()
cur = None
del (cur,)
return rowcount
# 执行多条SQL语句
def execute_script(self, sql):
'''
@name 批量执行SQL
@param sql<string> sql语句集合
@return bool
'''
# 写锁
with self.__wlock():
return self.__sqlite_retry_help(self.__execute_script_help, sql)
# 执行多条SQL语句(辅助函数)
def __execute_script_help(self, sql):
with _auto_repair_context(self.__DB_PATH):
try:
# 获取游标对象
cur = self.__CONN.cursor()
# 执行SQL
cur.executescript(sql)
except:
# 打印sql语句与绑定参数
_log('{}\ndb: {}'.format(sql, self.__DB_NAME))
cur = None
del (cur,)
# 抛出异常
raise
# 主动关闭Cursor
cur.close()
cur = None
del (cur,)
return True
# 执行vacuum整理数据库空间
def vacuum(self):
'''
@name 执行vaccum整理数据库空间
@author Zhj<2022-12-22>
@return int
'''
# 写锁
with self.__wlock():
return self.execute('vacuum')
# 备份数据库
def backup(self, dest_conn) -> bool:
'''
@name 将当前数据库备份到目标数据库
@author Zhj<2022-12-22>
@param dest_conn<DbConnection> 目标数据库连接对象
@return bool
'''
if dest_conn.conn_obj() is None:
raise PanelError('dest_conn not connect to sqlite.')
# 写锁
with self.__wlock():
with _auto_repair_context(self.__DB_PATH):
# 开始备份(全量备份)
self.__CONN.backup(dest_conn.conn_obj())
return True
# 导出数据库
def dump(self, dest_file: str, row_check_func: typing.Optional[callable] = None) -> bool:
"""
@name 导出数据库
@author Zhj<2024-08-08>
@param dest_file<str> 目标文件
@param row_check_func<?callable> 语句行检查函数 row_check_func(row: str) -> bool
@return bool
"""
# 写锁
with self.__wlock():
with open(dest_file, 'w') as fp:
for row in self.__CONN.iterdump():
# 当传入了语句行检查函数时，执行检查函数
if row_check_func is not None and not row_check_func(row):
continue
# 导出数据行
fp.write(row + '\n')
return True
class Snapshot:
__slots__ = ['pk', 'from_sub_query', 'table', 'prefix', 'alias', 'where', 'limit', 'order',
'field', 'group', 'having', 'join', 'update', 'duplicate']
class Db:
'''
@name Sqlite数据库连接类
@author Zhj<2022-07-18>
'''
__slots__ = ['__DB_NAME', '__DB_CONN', '__AUTO_COMMIT', '__AUTO_VACUUM', '__NEED_VACUUM', '__DEBUG_LOG', '__QUERIES', 'ENGINE']
__DB_ROOT_DIR = '{}/data/'.format(_BASE_DIR)
def __init__(self, db_name, engine=None, auto_connect: bool = True):
'''
@name 初始化函数
@author Zhj<2022-12-14>
@param db_name<string> 数据库名称
@param brandnew<bool> 是否开启一个全新连接
@return void
'''
self.ENGINE = sqlite3 if engine is None else engine
if str(db_name).startswith(':memory:'):
self.__DB_NAME = db_name # 内存数据库
else:
self.__DB_NAME = os.path.join(self.__DB_ROOT_DIR, re.sub(r'\.db$', '', db_name)) # 数据库名称(全路径 不带.db)
self.__DB_CONN: typing.Optional[DbConnection] = None # 数据库连接对象
self.__AUTO_COMMIT = True # 是否自动提交事务(默认自动提交)
self.__AUTO_VACUUM = False # 是否自动释放空间
self.__NEED_VACUUM = False # 事务提交后是否需要释放空间
self.__DEBUG_LOG = False # 是否开启调试日志
self.__QUERIES = [] # 查询构造器数量
if auto_connect:
self._connect()
def __del__(self):
self.close()
del (self.__DB_CONN,)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_trackback):
self.close()
def _connect(self):
'''
@name 连接Sqlite数据库
@author Zhj<2022-07-16>
@return self
'''
self.__DB_CONN = DbConnection(db_name=self.__DB_NAME, engine=self.ENGINE)
return self
def close(self):
'''
@name 将数据库连接返回连接池
@author Zhj<2022-07-16>
@return self
'''
try:
# 释放数据库连接
if self.__DB_CONN is None:
return
self.__DB_CONN.close()
self.__DB_CONN = None
except BaseException as e:
_log(e)
def client(self):
'''
@name 获取数据库连接对象
@return SqliteClient
'''
return self.__DB_CONN
def db_name(self):
'''
@name 获取数据库名称
@author Zhj<2022-09-07>
@return string
'''
return self.__DB_NAME
def auto_vacuum(self, auto_vacuum=True):
'''
@name 设置是否自动释放空间
@author Zhj<2022-09-27>
@param auto_vacuum<?bool> 是否自动释放空间
@return self
'''
self.__AUTO_VACUUM = auto_vacuum
return self
def need_vacuum(self, need_vacuum=True):
'''
@name 设置是否需要清理空间
@author Zhj<2022-09-02>
@param need_vacuum<?bool> 是否需要清理空间
@return self
'''
self.__NEED_VACUUM = need_vacuum
return self
def autocommit(self, autocommit=True):
'''
@name 设置自动提交事务状态
@author Zhj<2022-07-17>
@param autocommit<bool> 是否自动提交事务
@return self
'''
self.__AUTO_COMMIT = autocommit
return self
def is_autocommit(self):
'''
@name 是否自动提交事务
@return bool
'''
return self.__AUTO_COMMIT
def is_autovacuum(self):
'''
@name 是否自动释放空间
@return bool
'''
return self.__AUTO_VACUUM
def commit(self):
'''
@name 提交事务
@author Zhj<2022-07-17>
@return bool
'''
if self.__DB_CONN is None:
return False
# 记录commit语句执行开始时间
s_time = time.time()
# 提交事务
ret = self.__DB_CONN.commit()
# 写日志
if self.is_debug():
self.debug_log('commit', self.db_name(), time.time() - s_time)
# 开启了自动释放空间时
# 释放空间
if self.__NEED_VACUUM and self.is_autovacuum():
self.__NEED_VACUUM = False
self.vacuum()
return ret
def rollback(self):
'''
@name 回滚事务
@author Zhj<2022-07-17>
@return bool
'''
if self.__DB_CONN is None:
return False
self.__NEED_VACUUM = False
# 记录rollback语句执行开始时间
s_time = time.time()
ret = self.__DB_CONN.rollback()
# 写日志
if self.is_debug():
self.debug_log('rollback', self.db_name(), time.time() - s_time)
return ret
def query(self):
'''
@name 获取查询构造器对象
@author Zhj<2022-07-18>
@return SqliteEasy
'''
self.__QUERIES.append(None)
return SqliteEasy(self)
def query_done(self):
'''
@name 标记查询构造器已关闭
@author Zhj<2023-02-08>
@return None
'''
del (self.__QUERIES[-1:],)
def queries(self):
'''
@name 查看当前查询构造器数量
@author Zhj<2023-02-08>
@return int
'''
return len(self.__QUERIES)
def vacuum(self):
'''
@name 释放空间
@author Zhj<2022-12-22>
@return int
'''
# 记录vacuum语句执行开始时间
s_time = time.time()
# 执行vacuum
ret = self.__DB_CONN.vacuum()
# 写日志
if self.is_debug():
self.debug_log('vacuum', self.db_name(), time.time() - s_time)
return ret
def backup(self, dest_db):
'''
@name 备份数据库(>=py3.7)
@author Zhj<2022-12-22>
@param dest_db<Db> 目标数据库连接对象
@return bool
'''
if not isinstance(dest_db, Db):
raise PanelError('dest_db must a Db object.')
# 记录执行备份开始时间
s_time = time.time()
# 开始备份
ret = self.__DB_CONN.backup(dest_db.client())
# 写日志
if self.is_debug():
self.debug_log('backup to {}'.format(dest_db.db_name()), self.db_name(), time.time() - s_time)
return ret
def dump(self, dest_file: str, row_check_func: typing.Optional[callable] = None) -> bool:
'''
@name 导出数据库(>=py3.7)
@author Zhj<2024-08-08>
@param dest_file<str> 目标文件
@param row_check_func<?callable> 语句行检查函数 row_check_func(row: str) -> bool
@return bool
'''
# 记录执行导出开始时间
s_time = time.time()
# 开始导出
ret = self.__DB_CONN.dump(dest_file, row_check_func)
# 写日志
if self.is_debug():
self.debug_log('dump to {}'.format(dest_file), self.db_name(), time.time() - s_time)
return ret
def debug(self, debug_state=True):
'''
@name 设置调试
@param debug_state<bool> 调试状态
@return self
'''
self.__DEBUG_LOG = debug_state
return self
def is_debug(self):
'''
@name 检查当前是否开启了调试日志
@return bool
'''
return self.__DEBUG_LOG
def debug_log(self, content, db_name, cost_time):
'''
@name 写查询日志
@author Zhj<2022-09-27>
@param content<string> sql语句
@param db_name<string> 数据库名称
@param cost_time<float> 执行耗时/s
@return void
'''
# 获取当前日期时间
cur_datetime = time.strftime('%Y-%m-%d %X')
# sql查询日志目录
log_dir = '{}/logs/sql_log/{}'.format(_BASE_DIR, time.strftime('%Y%m'))
# 目录不存在时创建
if not os.path.exists(log_dir):
os.makedirs(log_dir, 0o600)
with open('{}/{}.log'.format(log_dir, cur_datetime[8:10]), 'a') as fp:
fp.write('[{}]{} {}ms {}\n'.format(cur_datetime, db_name, round(cost_time * 1000, 2), content))
def synchronous_off(self):
'''
@name 关闭同步
@author Zhj<2023-02-17>
@return self
'''
self.__DB_CONN.execute_script('PRAGMA synchronous=0;')
return self
def synchronous_off_wal(self):
'''
@name 设置WAL日志模式并关闭同步
@author Zhj<2023-02-17>
@return self
'''
self.__DB_CONN.execute_script('PRAGMA journal_mode=wal;\nPRAGMA synchronous=0;\nPRAGMA temp_store=memory;\nPRAGMA mmap_size=30000000000;')
return self
def integrity_check(self):
'''
@name 检查数据库是否完整
@author Zhj<2023-03-15>
@return bool
'''
try:
ret = self.__DB_CONN.query('PRAGMA integrity_check', take_first=True)
return ret['integrity_check'] == 'ok'
except:
return False
class SqliteEasy:
'''
@name Sqlite查询类
@author Zhj<2022-07-15>
'''
__slots__ = ['__weakref__', '__DB', '__DB_TABLE', '__FETCH_SQL', '__EXPLAIN', '__PK', '__OPT_PREFIX', '__OPT_ALIAS',
'__OPT_WHERE', '__OPT_LIMIT', '__OPT_ORDER', '__OPT_FIELD', '__OPT_GROUP', '__OPT_HAVING',
'__OPT_JOIN', '__OPT_UPDATE', '__OPT_DUPLICATE', '__OPT_ALTER_TABLE', '__FROM_SUB_QUERY',
'__CONFLICT_OPTIONS']
def __init__(self, db: typing.Optional[Db] = None):
self.__DB = None # 数据库对象
self.__DB_TABLE = None # 表名(包含前缀)
self.__FETCH_SQL = False # 是否输出sql语句
self.__EXPLAIN = False # 分析sql语句
self.__PK = None # 主键字段名
self.__OPT_PREFIX = 'bt_' # 表前缀
self.__OPT_ALIAS = None # 表别名
self.__OPT_WHERE = Where() # where条件
self.__OPT_LIMIT = Limit() # limit条件
self.__OPT_ORDER = Order() # order条件
self.__OPT_FIELD = Field() # field条件
self.__OPT_GROUP = Group() # group条件
self.__OPT_HAVING = Having() # having条件
self.__OPT_JOIN = Join() # 联表条件
self.__OPT_UPDATE = Update() # update条件
self.__OPT_DUPLICATE = Duplicate() # Duplicate
self.__OPT_ALTER_TABLE = AlterTable(self) # 更新表结构条件
self.__FROM_SUB_QUERY = False # 是否通过子查询
self.__CONFLICT_OPTIONS = (
'ROLLBACK', # 回滚
'ABORT', # 撤销
'FAIL', # 抛出失败异常
'IGNORE', # 忽略
'REPLACE', # 覆盖
) # 发生约束冲突时，额外的处理选项
if db is not None:
self.__DB = db
def __del__(self):
self.close()
self.__OPT_WHERE = None
self.__OPT_LIMIT = None
self.__OPT_ORDER = None
self.__OPT_FIELD = None
self.__OPT_GROUP = None
self.__OPT_HAVING = None
self.__OPT_JOIN = None
self.__OPT_UPDATE = None
self.__OPT_ALTER_TABLE = None
del (self.__OPT_WHERE,
self.__OPT_LIMIT,
self.__OPT_ORDER,
self.__OPT_FIELD,
self.__OPT_GROUP,
self.__OPT_HAVING,
self.__OPT_JOIN,
self.__OPT_UPDATE,
self.__OPT_ALTER_TABLE,)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
self.close()
def set_db(self, db):
'''
@name 设置数据库对象
@author Zhj<2022-07-18>
@param db<Db> 数据库对象
@return self
'''
if not isinstance(db, Db):
raise PanelError('db must a instance of core.include.sqlite_server.Db')
self.__DB = db
return self
def get_db(self):
'''
@name 获取数据库对象
@author Zhj<2022-07-18>
@return Db|None
'''
return self.__DB
def set_pk(self, pk):
'''
@name 设置主键字段名
@author Zhj<2022-07-19>
@param pk<string> 主键字段名
@return self
'''
self.__PK = pk
return self
def set_where_obj(self, where_obj):
'''
@name 设置Where对象
@author Zhj<2022-07-19>
@param where_obj<Where> Where对象
@return self
'''
if not isinstance(where_obj, Where):
raise PanelError('where_obj must a instance of core.include.sqlite_server.Where')
self.__OPT_WHERE = where_obj
return self
def get_where_obj(self):
'''
@name 获取Where对象
@return Where
'''
return self.__OPT_WHERE
def set_limit_obj(self, limit_obj):
'''
@name 设置Limit对象
@author Zhj<2022-07-19>
@param limit_obj<Limit> Limit对象
@return self
'''
if not isinstance(limit_obj, Limit):
raise PanelError('limit_obj must a instance of core.include.sqlite_server.Limit')
self.__OPT_LIMIT = limit_obj
return self
def set_order_obj(self, order_obj):
'''
@name 设置Order对象
@author Zhj<2022-07-19>
@param order_obj<Order> Order对象
@return self
'''
if not isinstance(order_obj, Order):
raise PanelError('order_obj must a instance of core.include.sqlite_server.Order')
self.__OPT_ORDER = order_obj
return self
def set_field_obj(self, field_obj):
'''
@name 设置Field对象
@author Zhj<2022-07-19>
@param field_obj<Field> Field对象
@return self
'''
if not isinstance(field_obj, Field):
raise PanelError('field_obj must a instance of core.include.sqlite_server.Field')
self.__OPT_FIELD = field_obj
return self
def set_group_obj(self, group_obj):
'''
@name 设置Group对象
@author Zhj<2022-07-19>
@param group_obj<Group> Group对象
@return self
'''
if not isinstance(group_obj, Group):
raise PanelError('group_obj must a instance of core.include.sqlite_server.Group')
self.__OPT_GROUP = group_obj
return self
def set_having_obj(self, having_obj):
'''
@name 设置Having对象
@author Zhj<2022-07-19>
@param having_obj<Having> Having对象
@return self
'''
if not isinstance(having_obj, Having):
raise PanelError('having_obj must a instance of core.include.sqlite_server.Having')
self.__OPT_HAVING = having_obj
return self
def set_join_obj(self, join_obj):
'''
@name 设置Join对象
@author Zhj<2022-07-19>
@param join_obj<Join> Join对象
@return self
'''
if not isinstance(join_obj, Join):
raise PanelError('join_obj must a instance of core.include.sqlite_server.Join')
self.__OPT_JOIN = join_obj
return self
def set_update_obj(self, update_obj):
'''
@name 设置Update对象
@author Zhj<2022-07-19>
@param update_obj<Update> Update对象
@return self
'''
if not isinstance(update_obj, Update):
raise PanelError('update_obj must a instance of core.include.sqlite_server.Update')
self.__OPT_UPDATE = update_obj
return self
def set_duplicate_obj(self, duplicate_obj):
'''
@name 设置Duplicated对象
@author Zhj<2022-07-19>
@param duplicate_obj<Duplicate> Duplicate对象
@return self
'''
if not isinstance(duplicate_obj, Duplicate):
raise PanelError('duplicate_obj must a instance of core.include.sqlite_server.Duplicate')
self.__OPT_DUPLICATE = duplicate_obj
return self
def set_alter_table_obj(self, alter_table_obj):
'''
@name 设置AlterTable对象
@author Zhj<2022-07-19>
@param alter_table_obj<AlterTable> AlterTable对象
@return self
'''
if not isinstance(alter_table_obj, AlterTable):
raise PanelError('alter_table_obj must a instance of core.include.sqlite_server.AlterTable')
self.__OPT_ALTER_TABLE = alter_table_obj
return self
def close(self):
'''
@name 关闭游标并将数据库连接返回连接池
@author Zhj<2022-07-16>
@return self
'''
try:
self.__DB.query_done()
self.__DB = None
# 清理查询条件
self.__clear()
except:
pass
def autocommit(self, autocommit=True):
'''
@name 设置自动提交事务状态
@author Zhj<2022-07-17>
@param autocommit<bool> 是否自动提交事务
@return self
'''
if self.__DB is not None:
self.__DB.autocommit(autocommit)
return self
def commit(self):
'''
@name 提交事务
@author Zhj<2022-07-17>
@return bool
'''
if self.__DB is None:
return False
# 提交事务
return self.__DB.commit()
def rollback(self):
'''
@name 回滚事务
@author Zhj<2022-07-17>
@return bool
'''
if self.__DB is None:
return False
# 回滚事务
return self.__DB.rollback()
def vacuum(self):
"""
@name 释放空间
@author Zhj<2023-11-13>
@return bool
"""
if self.__DB is None:
return False
return self.__DB.vacuum()
def fetch_sql(self, fetch_sql=True):
'''
@name 设置是否输入sql原生语句
@author Zhj<2022-07-18>
@param fetch_sql<bool> 是否输入sql原生语句
@return self
'''
self.__FETCH_SQL = fetch_sql
return self
def explain(self, explain=True):
'''
@name 设置EXPLAIN
@author Zhj<2022-07-20>
@param explain<bool> 是否开启EXPLAIN
@return self
'''
self.__EXPLAIN = explain
return self
def prefix(self, prefix):
'''
@name 设置表前缀
@author Zhj<2022-07-16>
@param prefix<string> 表前缀
@return self
'''
self.__OPT_PREFIX = prefix
return self
def name(self, table_name):
'''
@name 设置表名(不包含前缀)
@author Zhj<2022-07-16>
@param table_name<string> 表名(不包含前缀)
@return self
'''
return self.table(table_name, False)
def table(self, table_name, is_fullname=True):
'''
@name 设置表名(包含前缀)
@param table_name<string> 表名
@param is_fullname<bool> 是否完整表名(不包含前缀)
@return self
'''
m = match_table_name_reg.match(table_name)
if m is None or m.group(1) is None:
raise PanelError('Invalid table name：{}'.format(table_name))
self.__DB_TABLE = m.group(1).strip('`')
# 添加前缀
if not is_fullname and self.__OPT_PREFIX is not None:
self.__DB_TABLE = self.__OPT_PREFIX + self.__DB_TABLE
if m.group(2) is not None:
self.__OPT_ALIAS = m.group(2).strip('`')
# 重置主键字段名
self.__PK = None
return self
# 使用子查询
def from_sub_query(self, sub_query):
# 当传入查询构造器对象时，将其转为SQL语句
if isinstance(sub_query, SqliteEasy):
sub_query = sub_query.build_sql(True)
m = search_subquery_reg.search(str(sub_query))
if m is None or m.group(1) is None:
raise PanelError('Invalid sub-query：{}'.format(sub_query))
self.__DB_TABLE = m.group(1)
if m.group(2) is not None:
self.__OPT_ALIAS = m.group(2).strip('`')
# 重置主键字段名
self.__PK = None
self.__FROM_SUB_QUERY = True
return self
def alias(self, alias):
'''
@name 设置表别名
@author Zhj<2022-07-16>
@param alias<string> 表别名
@return self
'''
self.__OPT_ALIAS = alias
return self
def field(self, *fields):
'''
@name 添加查询字段
@author Zhj<2022-07-15>
@param fields<tuple> 查询字段列表
@return self
'''
self.__OPT_FIELD.add_fields(*fields)
return self
def join(self, exp, condition, join_type='INNER', add_table_prefix=True):
'''
@name 添加关联条件
@author Zhj<2022-07-17>
@param exp<string> 表达式
@param condition<string> 关联条件
@param join_type<string> 关联方式 INNER|LEFT|RIGHT
@param add_table_prefix<bool> 是否添加表前缀[可选 默认自动添加]
@return self
'''
table_prefix = ''
if add_table_prefix and self.__OPT_PREFIX is not None:
table_prefix = self.__OPT_PREFIX
self.__OPT_JOIN.add_join(exp, condition, join_type, table_prefix)
return self
def inner_join(self, exp, condition, add_table_prefix=True):
'''
@name 添加内连接关联条件
@param exp<string> 表达式
@param condition<string> 关联条件
@param add_table_prefix<bool> 是否添加表前缀[可选 默认自动添加]
@return self
'''
return self.join(exp, condition, 'INNER', add_table_prefix)
def left_join(self, exp, condition, add_table_prefix=True):
'''
@name 添加左连接关联条件
@author Zhj<2022-07-17>
@param exp<string> 表达式
@param condition<string> 关联条件
@param add_table_prefix<bool> 是否添加表前缀[可选 默认自动添加]
@return self
'''
return self.join(exp, condition, 'LEFT', add_table_prefix)
def right_join(self, exp, condition, add_table_prefix=True):
'''
@name 添加右连接关联条件
@author Zhj<2022-07-17>
@param exp<string> 表达式
@param condition<string> 关联条件
@param add_table_prefix<bool> 是否添加表前缀[可选 默认自动添加]
@return self
'''
return self.join(exp, condition, 'RIGHT', add_table_prefix)
def where(self, condition, params=()):
'''
@name 添加where条件 AND
@author Zhj<2022-07-16>
@param condition<string> where条件
@param params<list|tuple> 绑定参数
@return self
'''
self.__OPT_WHERE.add(condition, params)
return self
def where_or(self, condition, params=()):
'''
@name 添加where条件 OR
@author Zhj<2022-07-16>
@param condition<string> where条件
@param params<list|tuple> 绑定参数
@return self
'''
self.__OPT_WHERE.add(condition, params, 'OR')
return self
def where_in(self, field, vals, logic='AND'):
'''
@name 添加where条件 IN
@author Zhj<2022-07-16>
@param field<string> 字段名
@param vals<list|tuple> 查询参数列表
@param logic<string> 逻辑运算符 AND|OR
@return self
'''
self.__OPT_WHERE.add_where_in(field, vals, logic)
return self
def where_not_in(self, field, vals, logic='AND'):
'''
@name 添加where条件 IN
@author Zhj<2022-07-16>
@param field<string> 字段名
@param vals<list|tuple> 查询参数列表
@param logic<string> 逻辑运算符 AND|OR
@return self
'''
self.__OPT_WHERE.add_where_in(field, vals, logic, True)
return self
# 嵌套where
@contextmanager
def where_nest(self, logic: str = 'and'):
query = SqliteEasy(self.__DB)
yield query
self.__OPT_WHERE.add_nest(query.get_where_obj(), logic)
def group(self, condition, params=()):
'''
@name 添加分组条件
@author Zhj<2022-07-17>
@param condition<string> 分组条件
@param params<list|tuple> 绑定参数
@return self
'''
self.__OPT_GROUP.add_group(condition, params)
return self
def having(self, condition, params=()):
'''
@name 添加分组筛选条件
@author Zhj<2022-07-17>
@param condition<string> 分组筛选条件
@param params<list|tuple> 绑定参数
@return self
'''
self.__OPT_HAVING.add_having(condition, params)
return self
def order(self, field, ordering='ASC', params=()):
'''
@name 添加排序条件
@author Zhj<2022-07-17>
@param field<string> 字段名
@param ordering<string> 排序方式 ASC|DESC
@param params<list|tuple> 绑定参数
@return self
'''
self.__OPT_ORDER.add_order(field, ordering, params)
return self
def limit(self, limit, skip=None):
'''
@name 设置返回行数
@author Zhj<2022-07-16>
@param limit<integer> 返回的行数
@param skip<?integer> 跳过的行数
@return self
'''
self.__OPT_LIMIT.set_limit(limit)
if skip is not None:
self.__OPT_LIMIT.set_skip(skip)
return self
def skip(self, skip):
'''
@name 设置跳过的行数
@author Zhj<2022-07-16>
@param skip<integer> 跳过的行数
@return self
'''
self.__OPT_LIMIT.set_skip(skip)
return self
def query(self, raw_sql, params=(), take_first=False, clear_conditions=True):
'''
@name 查询
@author Zhj<2022-07-17>
@param raw_sql<string> sql语句
@param params<list|tuple> 绑定参数[可选]
@param take_first<bool> 是否只获取一行数据[可选 默认获取所有行]
@param clear_conditions<?bool> 是否清空查询条件[可选 默认清空]
@return list|dict|None
'''
if self.__DB is None:
return None
# 记录语句执行开始时间
s_time = time.time()
# 执行sql语句
ret = self.__DB.client().query(raw_sql, _to_tuple(params), take_first)
# 写日志
if self.__DB.is_debug():
self.__DB.debug_log(self.__to_raw_sql(raw_sql, _to_tuple(params)), self.__DB.db_name(),
time.time() - s_time)
# 自动提交事务
# if self.__is_autocommit():
# self.commit()
# 清空查询条件
if clear_conditions:
self.__clear()
return ret
def execute(self, raw_sql, params=(), get_rowid=False, clear_conditions=True):
'''
@name 执行一条sql语句并返回影响的行数
@author Zhj<2022-07-18>
@param raw_sql<string> sql语句
@param params<list|tuple> 绑定参数[可选]
@param get_rowid<bool> 获取插入ID[可选 默认返回影响的行数]
@param clear_conditions<?bool> 是否清空查询条件[可选 默认清空]
@return integer
'''
if self.__DB is None:
return 0
# 记录语句执行开始时间
s_time = time.time()
# 执行sql语句
ret = self.__DB.client().execute(raw_sql, _to_tuple(params), get_rowid)
# 写日志
if self.__DB.is_debug():
self.__DB.debug_log(self.__to_raw_sql(raw_sql, _to_tuple(params)), self.__DB.db_name(),
time.time() - s_time)
# 自动提交事务
if self.__is_autocommit():
self.commit()
# 清空查询条件
if clear_conditions:
self.__clear()
return ret
def execute_script(self, sql_script, clear_conditions=True):
'''
@name 执行多条sql语句(注意：执行这个方法会自动提交之前的事务，本次执行不会加入事务，事务请编写在sql脚本中)
@author Zhj<2022-07-18>
@param sql_script<string> sql语句
@param clear_conditions<?bool> 是否清空查询条件[可选 默认清空]
@return bool
'''
if self.__DB is None:
return False
# 记录语句执行开始时间
s_time = time.time()
# 执行sql语句
self.__DB.client().execute_script(sql_script)
# 写日志
if self.__DB.is_debug():
self.__DB.debug_log(sql_script, self.__DB.db_name(), time.time() - s_time)
# 清空查询条件
if clear_conditions:
self.__clear()
return True
def insert(self, data, option=None, get_rowid=True):
'''
@name 插入一条数据
@author Zhj<2022-07-17>
@param data<dict|list> 插入数据
@param option<?string> 额外选项[可选]
@param get_rowid<bool> 获取插入ID[可选 默认返回影响的行数]
@return integer|string
'''
if self.__DB_TABLE is None:
raise PanelError('Insert failed: table name not provide.')
# 传入dict类型之外的情况
if not isinstance(data, dict):
# list类型：尝试insert_all
if isinstance(data, list):
return self.insert_all(data, option=option)
# 其它类型：抛出异常提示
raise PanelError('Insert failed: parameter "data" type must be dict.')
# 检查冲突选项是否正确
if option is not None and str(option).upper() not in self.__CONFLICT_OPTIONS:
raise PanelError('option must be one of: {}'.format(', '.join(self.__CONFLICT_OPTIONS)))
placeholders = []
ks = data.keys()
params = ()
for k in ks:
placeholders.append('?')
params += (data[k],)
# build deplicate sql and bind params
duplicate_sql, duplicate_binds = self.__OPT_DUPLICATE.build()
params += duplicate_binds
raw_sql = 'INSERT{} INTO {} ({}) VALUES ({}){}'.format(
' OR {}'.format(str(option).upper()) if option is not None else '',
_add_backtick_for_field(self.__DB_TABLE),
', '.join(list(map(lambda x: _add_backtick_for_field(x), ks))),
','.join(placeholders),
duplicate_sql
)
# 输出sql原生语句
if self.__FETCH_SQL:
return self.__to_raw_sql(raw_sql, params)
# 输出SQL语句分析信息
if self.__EXPLAIN:
return self.explain_raw_sql(raw_sql, params)
# 执行sql语句
return self.execute(raw_sql, params, get_rowid)
def insert_all(self, data_list, clear_conditions=True, option=None):
'''
@name 批量插入数据
@author Zhj<2022-07-17>
@param data_list<list> 批量插入数据
@param clear_conditions<?bool> 是否清空查询条件[可选 默认清空]
@param option<?string> 额外选项[可选]
@return integer
'''
if self.__DB is None or len(data_list) == 0:
return 0
# 检查冲突选项是否正确
if option is not None and str(option).upper() not in self.__CONFLICT_OPTIONS:
raise PanelError('option must be one of: {}'.format(', '.join(self.__CONFLICT_OPTIONS)))
ks = data_list[0].keys()
# build deplicate sql and bind params
duplicate_sql, duplicate_binds = self.__OPT_DUPLICATE.build()
# 生成sql语句
raw_sql = 'INSERT{} INTO {} ({}) VALUES ({}){}'.format(
' OR {}'.format(str(option).upper()) if option is not None else '',
_add_backtick_for_field(self.__DB_TABLE),
', '.join(list(map(lambda x: _add_backtick_for_field(x), ks))),
','.join(list(map(lambda x: '?', ks))),
duplicate_sql
)
# 绑定参数
params = list(map(lambda x: _to_tuple(list(map(lambda y: x[y], ks))), data_list))
params += duplicate_binds
# 记录语句执行开始时间
s_time = time.time()
# 执行sql语句
ret = self.__DB.client().execute_many(raw_sql, params)
# 写日志
if self.__DB.is_debug():
# 构造一个真实的批量写入sql
debug_raw_sql = raw_sql
i = len(params) - 1
pad_str = ', ({})'.format(','.join(list(map(lambda x: '?', ks))))
while i:
debug_raw_sql += pad_str
i -= 1
# 将绑定参数扁平化
debug_params = ()
for p in params:
debug_params += p
self.__DB.debug_log(self.__to_raw_sql(debug_raw_sql, _to_tuple(debug_params)), self.__DB.db_name(),
time.time() - s_time)
# 自动提交事务
if self.__is_autocommit():
self.commit()
# 清空查询条件
if clear_conditions:
self.__clear()
# 返回新增的行数
return ret
def increment(self, field, step=1):
'''
@name 自增数值
@author Zhj<2022-07-17>
@param field<string> 字段名
@param step<integer> 值
@return self
'''
self.__OPT_UPDATE.increment(field, step)
return self
def decrement(self, field, step=1):
'''
@name 自减数值
@author Zhj<2022-07-17>
@param field<string> 字段名
@param step<integer> 值
@return self
'''
self.__OPT_UPDATE.decrement(field, step)
return self
def exp(self, field, exp):
'''
@name 使用原生表达式更新
@param field<string> 字段名
@param exp<string> 原生表达式
@return self
'''
self.__OPT_UPDATE.exp(field, exp)
return self
def update(self, data=None):
'''
@name 更新表数据
@author Zhj<2022-07-17>
@param data<?dict> 更新数据
@return integer|string
'''
if data is not None:
# 更新数据不是字典类型 返回0
if not isinstance(data, dict):
return 0
for k, v in data.items():
self.__OPT_UPDATE.add(k, v)
# 更新条件为空 返回0
if self.__OPT_UPDATE.is_empty():
return 0
update_str, update_params = self.__OPT_UPDATE.build()
join_str = self.__OPT_JOIN.build()
where_str, where_params = self.__OPT_WHERE.build()
limit_str = self.__OPT_LIMIT.build()
raw_sql = 'UPDATE {table_name}{join_condition} SET {exprission}' \
'{where_condition}{limit_condition}'.format_map({
'table_name': self.__build_table_name(True),
'join_condition': join_str,
'exprission': update_str,
'where_condition': where_str,
'limit_condition': limit_str,
})
bind_params = update_params + where_params
# 输出原生sql语句
if self.__FETCH_SQL:
return self.__to_raw_sql(raw_sql, bind_params)
# 输出SQL语句分析信息
if self.__EXPLAIN:
return self.explain_raw_sql(raw_sql, bind_params)
# 执行sql语句
return self.execute(raw_sql, bind_params)
def delete(self):
'''
@name 删除表数据
@author Zhj<2022-07-17>
@return integer|string
'''
join_str = self.__OPT_JOIN.build()
where_str, where_params = self.__OPT_WHERE.build()
limit_str = self.__OPT_LIMIT.build()
raw_sql = 'DELETE FROM {table_name}{join_condition}{where_condition}{limit_condition}'.format(
table_name=self.__build_table_name(True),
join_condition=join_str,
where_condition=where_str,
limit_condition=limit_str
)
# 输出原生sql语句
if self.__FETCH_SQL:
return self.__to_raw_sql(raw_sql, where_params)
# 输出SQL语句分析信息
if self.__EXPLAIN:
return self.explain_raw_sql(raw_sql, where_params)
# 执行sql语句
ret = self.execute(raw_sql, where_params)
# 自动提交事务时
# 且开启了自动释放空间时
# 释放空间
if self.__is_autocommit() and self.__is_autovacuum():
self.__DB.vacuum()
# 否则
# 记录本次事务提交后需要释放空间
else:
self.__DB.need_vacuum()
return ret
def find(self):
'''
@name 查询一行数据
@author Zhj<2022-07-17>
@return dict|None|string
'''
self.__OPT_LIMIT.set_limit(1)
# 构建sql语句和绑定参数
raw_sql, bind_params = self.__build_sql()
# 输出原生sql语句
if self.__FETCH_SQL:
return self.__to_raw_sql(raw_sql, bind_params)
# 输出SQL语句分析信息
if self.__EXPLAIN:
return self.explain_raw_sql(raw_sql, bind_params)
return self.query(raw_sql, bind_params, True)
def select(self):
'''
@name 查询多行数据
@author Zhj<2022-07-17>
@return list|None|string
'''
# 构建sql语句和绑定参数
raw_sql, bind_params = self.__build_sql()
# 输出原生sql语句
if self.__FETCH_SQL:
return self.__to_raw_sql(raw_sql, bind_params)
# 输出SQL语句分析信息
if self.__EXPLAIN:
return self.explain_raw_sql(raw_sql, bind_params)
return self.query(raw_sql, bind_params)
def value(self, field):
'''
@name 获取某个字段的值
@author Zhj<2022-07-17>
@param field<string> 字段名
@return string|integer|None
'''
self.__OPT_FIELD.set_fields(field)
ret = self.find()
# 输出原生sql语句或SQL语句分析信息
if self.__FETCH_SQL or self.__EXPLAIN:
return ret
if ret is None:
return None
return ret.get(self.__get_row_key(field), None)
def column(self, field, dict_key=None):
'''
@name 获取指定字段的值列表或字典
@author Zhj<2022-07-17>
@param field<string|None> 字段名
@param dict_key<?string> 字典键(字段名)
@return list|dict|string
'''
if self.__OPT_FIELD.is_empty() and field is not None:
self.__OPT_FIELD.set_fields(*filter(lambda x: x is not None, [field, dict_key]))
ret = self.select()
# 输出原生sql语句或SQL语句分析信息
if self.__FETCH_SQL or self.__EXPLAIN:
return ret
if ret is None:
# 指定了键时 返回字典
if dict_key is not None:
return {}
return []
# 返回列表
if dict_key is None:
return list(map(lambda x: x.get(self.__get_row_key(field), None), ret))
# 返回字典
d = {}
f_k = None if field is None else self.__get_row_key(field)
d_k = self.__get_row_key(dict_key)
for item in ret:
k = item.get(d_k, None)
if k is None:
continue
d[k] = item if f_k is None else item.get(f_k, None)
return d
def count(self):
'''
@name 统计行数
@author Zhj<2022-07-17>
@return integer
'''
ret = self.value('COUNT(*)')
# 输出原生sql语句或SQL语句分析信息
if self.__FETCH_SQL or self.__EXPLAIN:
return ret
if ret is None:
ret = 0
return int(ret)
def avg(self, field, precsicion=None):
'''
@name 统计平均值
@author Zhj<2022-07-17>
@param field<string> 字段名
@param precision<?integer> 小数点精度
@return float
'''
field = 'AVG({})'.format(_add_backtick_for_field(field))
if precsicion is not None and is_number(precsicion):
field = 'ROUND({},{})'.format(field, precsicion)
ret = self.value(field)
# 输出原生sql语句或SQL语句分析信息
if self.__FETCH_SQL or self.__EXPLAIN:
return ret
if ret is None:
ret = 0
return float(ret)
def sum(self, field, precsicion=None):
'''
@name 统计总和
@author Zhj<2022-07-17>
@param field<string> 字段名
@param precision<?integer> 小数点精度
@return integer
'''
field = 'SUM({})'.format(_add_backtick_for_field(field))
if precsicion is not None and is_number(precsicion):
field = 'ROUND({},{})'.format(field, precsicion)
ret = self.value(field)
# 输出原生sql语句或SQL语句分析信息
if self.__FETCH_SQL or self.__EXPLAIN:
return ret
if ret is None:
ret = 0
return int(ret)
def exists(self):
'''
@name 检查数据是否存在
@author Zhj<2022-07-18>
@return bool
'''
self.__OPT_LIMIT.set_limit(1)
# 构建sql语句和绑定参数
raw_sql, bind_params = self.__build_sql()
k = 'bt__exists'
raw_sql = 'SELECT EXISTS({}) AS `{}`'.format(raw_sql, k)
# 输出原生sql语句
if self.__FETCH_SQL:
return self.__to_raw_sql(raw_sql, bind_params)
# 输出SQL语句分析信息
if self.__EXPLAIN:
return self.explain_raw_sql(raw_sql, bind_params)
# 执行sql语句
ret = self.query(raw_sql, bind_params, True)
if ret is None or not isinstance(ret, dict):
return False
return True if int(ret.get(k, 0)) == 1 else False
# 设置insert时唯一索引重复时的更新操作
def duplicate(self, update: typing.Dict[str, str]):
self.__OPT_DUPLICATE.clear()
for k, v in update.items():
self.__OPT_DUPLICATE.exp(k, v)
return self
# TODO 强制索引
def force_index(self, index_name: str):
pass
def build_sql(self, sub_query=False, alias=None):
'''
@name 构建sql查询语句(合并绑定参数)
@author Zhj<2022-07-17>
@param sub_query<bool> 是否为子查询
@return string
'''
raw_sql = self.__to_raw_sql(*self.__build_sql())
# 子查询
if sub_query:
raw_sql = '(%s)' % raw_sql
# 别名
if alias is not None:
raw_sql = '%s AS %s' % (raw_sql, _add_backtick_for_field(alias))
return raw_sql
def get_pk(self):
'''
@name 获取主键字段名
@author Zhj<2022-07-18>
@return string|None
'''
if self.__PK is not None:
return self.__PK
ret = self.query('PRAGMA TABLE_INFO({})'.format(self.__build_table_name(False)), take_first=True,
clear_conditions=False)
if ret is None:
return None
self.__PK = ret.get('name', None)
return self.__PK
def get_columns(self):
'''
@name 获取所有列名
@author Zhj<2022-09-21>
@return list
'''
ret = self.query('PRAGMA TABLE_INFO({})'.format(self.__build_table_name(False)), clear_conditions=False)
return [column['name'] for column in ret]
def add_column(self, col_name, prop, force=False):
'''
@name 新建字段
@author Zhj<2022-09-21>
@param col_name<string> 字段名
@param prop<string> 字段属性
@param force<?bool> 是否强制新增(删除旧的字段)[可选]
@return self
'''
self.__OPT_ALTER_TABLE.add_column(col_name, prop, force)
return self
def drop_column(self, col_name):
'''
@name 删除字段
@author Zhj<2022-09-21>
@param col_name<string> 字段名
@return self
'''
self.__OPT_ALTER_TABLE.drop_column(col_name)
return self
def rename_column(self, col_name, new_col_name):
'''
@name 更新字段名
@author Zhj<2022-09-21>
@param col_name<string> 当前字段名
@param new_col_name<string> 新字段名
@return self
'''
self.__OPT_ALTER_TABLE.rename_column(col_name, new_col_name)
return self
def alter_table(self):
'''
@name 更新表结构
@author Zhj<2022-09-21>
@return bool
'''
if self.__OPT_ALTER_TABLE.is_empty():
return False
raw_sql = self.__OPT_ALTER_TABLE.build(self.__build_table_name(False))
self.execute_script(raw_sql)
return True
def add_index(self, idx_name, idx_col):
'''
@name 创建索引
@author Zhj<2022-10-11>
@param idx_name<string> 索引名称
@param idx_col<string|list> 字段名称
@return self
'''
if not isinstance(idx_col, list):
idx_col = [idx_col]
self.execute('CREATE INDEX IF NOT EXISTS {} ON {} ({})'.format(
_add_backtick_for_field(idx_name),
self.__build_table_name(False),
','.join(list(map(lambda x: _add_backtick_for_field(x), idx_col)))
))
return self
def drop_index(self, idx_name):
'''
@name 删除索引
@author Zhj<2022-10-11>
@param idx_name<string> 索引名称
@return self
'''
self.execute('DROP INDEX IF EXISTS {} ON {}'.format(
_add_backtick_for_field(idx_name),
self.__build_table_name(False)
))
return self
def fork(self):
'''
@name 克隆一个查询构造器
@author Zhj<2022-07-19>
@return SqliteEasy|None
'''
if self.__DB is None:
return None
query = self.__DB.query()
query.set_pk(self.__PK)
if self.__FROM_SUB_QUERY:
query.from_sub_query(self.__DB_TABLE)
else:
query.table(self.__DB_TABLE)
query.prefix(self.__OPT_PREFIX)
query.alias(self.__OPT_ALIAS)
query.set_where_obj(copy.deepcopy(self.__OPT_WHERE))
query.set_limit_obj(copy.deepcopy(self.__OPT_LIMIT))
query.set_order_obj(copy.deepcopy(self.__OPT_ORDER))
query.set_field_obj(copy.deepcopy(self.__OPT_FIELD))
query.set_group_obj(copy.deepcopy(self.__OPT_GROUP))
query.set_having_obj(copy.deepcopy(self.__OPT_HAVING))
query.set_join_obj(copy.deepcopy(self.__OPT_JOIN))
query.set_update_obj(copy.deepcopy(self.__OPT_UPDATE))
query.set_duplicate_obj(copy.deepcopy(self.__OPT_DUPLICATE))
return query
def snapshot(self):
'''
@name 创建查询构造器快照
@author Zhj<2025-01-07>
@return SqliteEasy|None
'''
snapshot = Snapshot()
snapshot.pk = self.__PK
snapshot.from_sub_query = self.__FROM_SUB_QUERY
snapshot.table = self.__DB_TABLE
snapshot.prefix = self.__OPT_PREFIX
snapshot.alias = self.__OPT_ALIAS
snapshot.where = copy.deepcopy(self.__OPT_WHERE)
snapshot.limit = copy.deepcopy(self.__OPT_LIMIT)
snapshot.order = copy.deepcopy(self.__OPT_ORDER)
snapshot.field = copy.deepcopy(self.__OPT_FIELD)
snapshot.group = copy.deepcopy(self.__OPT_GROUP)
snapshot.having = copy.deepcopy(self.__OPT_HAVING)
snapshot.join = copy.deepcopy(self.__OPT_JOIN)
snapshot.update = copy.deepcopy(self.__OPT_UPDATE)
snapshot.duplicate = copy.deepcopy(self.__OPT_DUPLICATE)
return snapshot
def restore_from_snapshot(self, snapshot):
'''
@name 通过快照还原查询构造器
@author Zhj<2025-01-07>
@return self
'''
if not isinstance(snapshot, Snapshot):
raise PanelError('snapshot must a instance of core.include.sqlite_server.Snapshot')
self.set_pk(snapshot.pk)
if snapshot.from_sub_query:
self.from_sub_query(snapshot.table)
else:
self.table(snapshot.table)
self.prefix(snapshot.prefix)
self.alias(snapshot.alias)
self.set_where_obj(copy.deepcopy(snapshot.where))
self.set_limit_obj(copy.deepcopy(snapshot.limit))
self.set_order_obj(copy.deepcopy(snapshot.order))
self.set_field_obj(copy.deepcopy(snapshot.field))
self.set_group_obj(copy.deepcopy(snapshot.group))
self.set_having_obj(copy.deepcopy(snapshot.having))
self.set_join_obj(copy.deepcopy(snapshot.join))
self.set_update_obj(copy.deepcopy(snapshot.update))
self.set_duplicate_obj(copy.deepcopy(snapshot.duplicate))
# self.set_alter_table_obj(copy.deepcopy(snapshot.alter_table))
return self
def explain_raw_sql(self, raw_sql, bind_params=()):
'''
@name 分析SQL语句
@author Zhj<2022-07-21>
@param raw_sql<string> SQL语句
@param bind_params<list|tuple> 绑定参数
@return string|None
'''
ret = self.query('EXPLAIN QUERY PLAN {}'.format(raw_sql), _to_tuple(bind_params))
if ret is None:
return None
return "\n".join(list(map(lambda x: x.get('detail', ''), ret)))
def __to_raw_sql(self, raw_sql, bind_params=()):
'''
@name 将sql语句和绑定参数合并
@author Zhj<2022-07-18>
@param raw_sql<string> sql语句(含有参数绑定占位符)
@param bind_params<tuple> 绑定参数
@return string
'''
return reduce(lambda x, y: search_question_reg.sub(str(y) if is_number(y) else "'%s'" % y, x, 1), bind_params, repr(raw_sql)[1:-1])
def __build_sql(self):
'''
@name 构建sql查询语句与绑定参数
@author Zhj<2022-07-18>
@return (sql语句<string>, 绑定参数<tuple>)
'''
fields = self.__OPT_FIELD.build()
join_condition = self.__OPT_JOIN.build()
where_condition, where_params = self.__OPT_WHERE.build()
group_condition, group_params = self.__OPT_GROUP.build()
having_condition, having_params = self.__OPT_HAVING.build()
order_condition, order_params = self.__OPT_ORDER.build()
limit_condition = self.__OPT_LIMIT.build()
# 查询语句
raw_sql = 'SELECT {fields} FROM {table_name}' \
'{join_condition}{where_condition}{group_condition}' \
'{order_condition}{having_condition}{limit_condition}'.format_map({
'fields': fields,
'table_name': self.__build_table_name(),
'join_condition': join_condition,
'where_condition': where_condition,
'group_condition': group_condition,
'having_condition': having_condition,
'order_condition': order_condition,
'limit_condition': limit_condition,
})
# 绑定参数
bind_params = ()
bind_params += where_params
bind_params += group_params
bind_params += having_params
bind_params += order_params
return raw_sql, bind_params
def __build_table_name(self, contain_alias=True):
'''
@name 构建表名
@author Zhj<2022-07-17>
@param contain_alias<bool> 是否包含别名
@return string
'''
table_name = self.__DB_TABLE if self.__FROM_SUB_QUERY else _add_backtick_for_field(self.__DB_TABLE)
table_alias = ''
if contain_alias:
table_alias = '' if self.__OPT_ALIAS is None else ' AS {}'.format(
_add_backtick_for_field(self.__OPT_ALIAS)
)
return '{}{}'.format(table_name, table_alias)
def __get_row_key(self, field):
'''
@name 获取字段名对应的字典键名
@author Zhj<2022-07-18>
@param field<string> 字段名
@return string|None
'''
# 移除字符串两段空白字符
field = str(field).strip()
m = match_row_key_reg.match(field)
# 不符合字段规则
# 返回None
if m is None:
# 检查有无设置别名
m = search_row_key_reg.search(field)
# 设置了别名
if m:
return m.group(1).strip('`')
return field
# 设置了别名时
# 获取别名
if m.group(2) is not None:
return m.group(2).strip('`')
# 获取字段名 不包含前缀表名
return m.group(1).strip('`')
def __is_autocommit(self):
'''
@name 检查是否自动提交事务
@author Zhj<2022-07-18>
@return bool
'''
if self.__DB is None:
return False
return self.__DB.is_autocommit()
def __is_autovacuum(self):
'''
@name 检查是否自动释放空间
@author Zhj<2022-09-27>
@return bool
'''
if self.__DB is None:
return False
return self.__DB.is_autovacuum()
def __clear(self):
'''
@name 清空查询条件
@author Zhj<2022-07-17>
@return void
'''
self.__PK = None
self.__OPT_ALIAS = None
self.__OPT_FIELD.clear()
self.__OPT_JOIN.clear()
self.__OPT_WHERE.clear()
self.__OPT_GROUP.clear()
self.__OPT_HAVING.clear()
self.__OPT_ORDER.clear()
self.__OPT_LIMIT.clear()
self.__OPT_UPDATE.clear()
self.__OPT_DUPLICATE.clear()
Reference in New Issue Copy Permalink