lazy-mysql 0.1.0__tar.gz

lazy_mysql-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tinycen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lazy_mysql-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: lazy_mysql
+Version: 0.1.0
+Summary: A lazy MySQL client for Python
+Home-page: https://github.com/tinycen/lazy_mysql
+Author: tinycen
+Author-email: sky_ruocen@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pymysql
+
+# lazy_mysql
+
+A lightweight Python library for simplified MySQL database operations.
+
+## Features
+
+- Unified SQL execution interface
+- Export table structure to Markdown format
+- Query result formatting
+- Simplified insert, update, and select operations
+- Transaction support
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from lazy_mysql.executor import SQLExecutor
+
+# Initialize connection
+config = {
+    'host': 'localhost',
+    'user': 'root',
+    'password': 'password',
+    'database': 'test_db'
+}
+
+executor = SQLExecutor(config)
+
+# Query example
+result = executor.select('users', ['id', 'name'])
+print(result)
+
+# Insert example
+executor.insert('users', {'name': 'John', 'age': 30}, commit=True)
+```
+
+## Requirements
+
+- mysql-connector-python>=9.4.0
+- pandas>=2.3.1
+
+Note: Compatibility with versions below these requirements has not been verified.
+
+
+## License
+This project is licensed under the MIT License.

lazy_mysql-0.1.0/README.md

@@ -0,0 +1,51 @@
+# lazy_mysql
+
+A lightweight Python library for simplified MySQL database operations.
+
+## Features
+
+- Unified SQL execution interface
+- Export table structure to Markdown format
+- Query result formatting
+- Simplified insert, update, and select operations
+- Transaction support
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from lazy_mysql.executor import SQLExecutor
+
+# Initialize connection
+config = {
+    'host': 'localhost',
+    'user': 'root',
+    'password': 'password',
+    'database': 'test_db'
+}
+
+executor = SQLExecutor(config)
+
+# Query example
+result = executor.select('users', ['id', 'name'])
+print(result)
+
+# Insert example
+executor.insert('users', {'name': 'John', 'age': 30}, commit=True)
+```
+
+## Requirements
+
+- mysql-connector-python>=9.4.0
+- pandas>=2.3.1
+
+Note: Compatibility with versions below these requirements has not been verified.
+
+
+## License
+This project is licensed under the MIT License.

lazy_mysql-0.1.0/lazy_mysql.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: lazy-mysql
+Version: 0.1.0
+Summary: A lazy MySQL client for Python
+Home-page: https://github.com/tinycen/lazy_mysql
+Author: tinycen
+Author-email: sky_ruocen@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pymysql
+
+# lazy_mysql
+
+A lightweight Python library for simplified MySQL database operations.
+
+## Features
+
+- Unified SQL execution interface
+- Export table structure to Markdown format
+- Query result formatting
+- Simplified insert, update, and select operations
+- Transaction support
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from lazy_mysql.executor import SQLExecutor
+
+# Initialize connection
+config = {
+    'host': 'localhost',
+    'user': 'root',
+    'password': 'password',
+    'database': 'test_db'
+}
+
+executor = SQLExecutor(config)
+
+# Query example
+result = executor.select('users', ['id', 'name'])
+print(result)
+
+# Insert example
+executor.insert('users', {'name': 'John', 'age': 30}, commit=True)
+```
+
+## Requirements
+
+- mysql-connector-python>=9.4.0
+- pandas>=2.3.1
+
+Note: Compatibility with versions below these requirements has not been verified.
+
+
+## License
+This project is licensed under the MIT License.

lazy_mysql-0.1.0/lazy_mysql.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+setup.py
+lazy_mysql.egg-info/PKG-INFO
+lazy_mysql.egg-info/SOURCES.txt
+lazy_mysql.egg-info/dependency_links.txt
+lazy_mysql.egg-info/requires.txt
+lazy_mysql.egg-info/top_level.txt
+tools/__init__.py
+tools/result_formatter.py
+tools/table_export.py
+tools/where_clause.py
+utils/__init__.py
+utils/connect.py
+utils/insert.py
+utils/select.py
+utils/update.py

lazy_mysql-0.1.0/lazy_mysql.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lazy_mysql-0.1.0/lazy_mysql.egg-info/requires.txt

@@ -0,0 +1 @@
+pymysql

lazy_mysql-0.1.0/lazy_mysql.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+tools
+utils

lazy_mysql-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lazy_mysql-0.1.0/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='lazy_mysql',
+    version='0.1.0',
+    packages=find_packages(),
+    install_requires=[
+        'pymysql',
+    ],
+    author='tinycen',
+    author_email='sky_ruocen@qq.com',
+    description='A lazy MySQL client for Python',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/tinycen/lazy_mysql',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.10',
+)

lazy_mysql-0.1.0/tools/result_formatter.py

@@ -0,0 +1,43 @@
+import pandas as pd
+
+def fetch_format( executor , sql , fetch_mode , output_format = "" , show_count = False , data_label = None ,
+                  params = None , self_close = False ) :
+    """
+    定义解析结果程序(格式化返回结果)
+    :param executor: SQLExecutor 实例
+    :param sql: SQL语句
+    :param fetch_mode: 获取模式
+    :param output_format: 输出格式
+    :param show_count: 是否显示结果数量
+    :param data_label: 数据标签
+    :param params: 参数
+    :param self_close: 是否自动关闭连接
+    :return: 查询结果
+    """
+    executor.execute( sql , params , self_close = self_close )
+
+    if data_label is None :
+        data_label = [ ]
+
+    if fetch_mode == "all" :
+        myresult = executor.mycursor.fetchall()  # 接收全部的返回结果行,返回结果为 tuple（元组）
+        if output_format == "list_1" :
+            if myresult is None :
+                return [ ]
+            data = [ myresult[ 0 ] for myresult in myresult ] if myresult else [ ]
+            myresult = data
+        elif "df" in output_format :
+            myresult = pd.DataFrame( myresult , columns = data_label )
+            if "dict" in output_format :
+                myresult = myresult.to_dict( "records" )
+    elif fetch_mode == "oneTuple" :
+        myresult = executor.mycursor.fetchone()  # 接收全部的返回结果行,返回结果为 tuple（元组）
+    else :
+        result = executor.mycursor.fetchone()
+        myresult = result[ 0 ] if result else None
+
+    if show_count :
+        num = len( myresult )
+        print( f"查询结果数量：{num}" )
+        return myresult , num
+    return myresult

lazy_mysql-0.1.0/tools/table_export.py

@@ -0,0 +1,36 @@
+def export_table_md( executor , table_name , save_path = None , self_close = True ) :
+    """
+    将 table 中的字段和字段类型，导出为md格式文件
+    :param executor: SQLExecutor 实例
+    :param table_name: 表名
+    :param save_path: 保存路径
+    :param self_close: 是否自动关闭连接
+    :return: None
+    """
+    # 检查表是否存在
+    executor.execute(f"SHOW TABLES LIKE '{table_name}'", self_close=False)
+    if not executor.mycursor.fetchone():
+        raise ValueError(f"表 {table_name} 不存在")
+        
+    # 执行查询获取表结构(使用SHOW FULL COLUMNS)
+    query = f"SHOW FULL COLUMNS FROM {table_name}"
+    print(f"执行查询: {query}")  # 调试输出
+    executor.execute(query , self_close = self_close)
+    # 获取查询结果
+    result = executor.mycursor.fetchall()
+    # print(f"原始查询结果: {result}")  # 调试输出
+    
+    # 解析结果(取Field,Type,Comment字段)
+    result = [(row[0], row[1], row[8]) for row in result]
+    # 解析结果并生成Markdown内容
+    md_content = f"## {table_name} 表结构\n\n"
+    md_content += "| 字段名 | 字段类型 | 字段描述 |\n"
+    md_content += "| --- | --- | --- |\n"
+    for row in result:
+        field_name, field_type, field_comment = row
+        md_content += f"| {field_name} | {field_type} | {field_comment} |\n"
+    # 写入Markdown文件
+    if save_path is None :
+        save_path = f"{table_name}.md"
+    with open(save_path, 'w', encoding='utf-8') as md_file:
+        md_file.write(md_content)

lazy_mysql-0.1.0/tools/where_clause.py

@@ -0,0 +1,26 @@
+def build_where_clause( where_conditions ) :
+    """
+    构造WHERE子句和对应的参数列表
+
+    :param where_conditions: WHERE条件，格式为字典，每个值可以是:
+        - 简单值: 默认使用 = 比较
+        - 元组: (比较运算符, 值) 如 ('>', 100)
+    :return: (where_clause, params) - WHERE子句字符串和参数列表
+    """
+    if not where_conditions :
+        return None , None
+
+    clauses = []
+    params = []
+    
+    for field, value in where_conditions.items() :
+        if isinstance(value, tuple) and len(value) == 2 :
+            operator, val = value
+            clauses.append(f"{field} {operator} %s")
+            params.append(val)
+        else :
+            clauses.append(f"{field} = %s")
+            params.append(value)
+            
+    where_clause = ' AND '.join(clauses)
+    return where_clause , params

lazy_mysql-0.1.0/utils/connect.py

@@ -0,0 +1,58 @@
+import mysql.connector
+
+# 获取数据库连接和游标
+def connection( sql_config ,database=None ) :
+
+    """
+    建立数据库连接并返回连接对象和游标对象
+
+    Args:
+        sql_config (object): 数据库配置对象，包含host, port, user, passwd, default_database等属性
+        database (str, optional): 数据库名称，database参数优先使用，默认使用 sql_config.default_database
+    Returns:
+        tuple: (数据库连接对象, 游标对象)
+    """
+    if database is not None :
+        database = database
+    elif not hasattr(sql_config, 'default_database') or sql_config.default_database is None:
+        database = "new_schema"
+    else:
+        database = sql_config.default_database
+        
+    try:
+        # 新版本使用password参数和推荐参数
+        # buffered=True - 缓冲查询结果，避免多次查询时出现'Unread result found'错误
+        # pool_size=5 - 连接池最大连接数，控制并发连接数量，
+        # pool_reset_session=True - 连接返回池时重置会话变量，确保连接状态干净
+        # pool_name="shop_pool" - 连接池名称，用于标识和管理连接池 
+        # 如果设置了 pool_reset_session 就必须设置 pool_name ，省略会报错- AttributeError: 
+        # Pool name 'rm-wz93y5aqe2f5gvu5uto.mysql.rds.aliyuncs.com_3306_root_yqq_new_schema' is too long
+        # use_pure=True - 使用纯Python实现而非C扩展，提高兼容性，减少外部依赖（实测，设置在为False会导致连接失败！）
+
+        mydb = mysql.connector.connect(
+            host=sql_config.host,
+            port=sql_config.port,
+            user=sql_config.user,
+            password=sql_config.passwd,
+            database=database,
+            buffered=True,
+            use_pure=True
+         )
+        mycursor = mydb.cursor(buffered=True)
+    except TypeError:
+        # 旧版本兼容模式
+        mydb = mysql.connector.connect(
+            host=sql_config.host,
+            port=sql_config.port,
+            user=sql_config.user,
+            passwd=sql_config.passwd,
+            database=database,
+            use_pure=True
+        )
+        mycursor = mydb.cursor()
+    
+    # 检查版本是否过时
+    if tuple(map(int, mysql.connector.__version__.split('.')[:2])) < (9, 4):
+        print(f"警告: MySQL连接器版本{mysql.connector.__version__}已过时，建议升级到9.4.0或更高版本")
+        print("pip install --upgrade mysql-connector-python")
+    return mydb , mycursor

lazy_mysql-0.1.0/utils/insert.py

@@ -0,0 +1,18 @@
+from ..executor import SQLExecutor
+
+def insert(executor: SQLExecutor, table_name, insert_fields, commit=False, self_close=False):
+    """
+    通用的SQL插入执行器方法，
+    :param executor: SQLExecutor 实例
+    :param table_name: 表名
+    :param insert_fields: 字段和值，格式为字典，如 {'field1': 'value1', 'field2': 'value2'}
+    :param commit: 是否自动提交
+    :param self_close: 是否自动关闭连接
+    :return: None
+    """
+    # 构造SQL语句
+    sql = f'''INSERT INTO {table_name} 
+                ({', '.join(insert_fields.keys())}) VALUES ({', '.join(['%s'] * len(insert_fields))});'''
+    values = tuple(insert_fields.values())
+
+    executor.execute(sql, values, commit, self_close)

lazy_mysql-0.1.0/utils/select.py

@@ -0,0 +1,104 @@
+from ..executor import SQLExecutor
+from ..tools.where_clause import build_where_clause
+
+def select(executor: SQLExecutor, table_names, select_fields, where_conditions, order_by=None, limit=None,
+           join_conditions=None, self_close=False, fetch_config=None):
+    """
+    通用的SQL查询执行器方法，支持JOIN操作
+    :param executor: SQLExecutor 实例
+    :param table_names: 表名，可以是字符串或列表
+    :param select_fields: 要查询的字段列表
+    :param where_conditions: WHERE条件，格式为字典
+    :param order_by: ORDER BY子句
+    :param limit: LIMIT子句
+    :param join_conditions: JOIN条件，格式为字典，如 {"join_type": "JOIN", "conditions": ["field1", "=", "field2"]}
+    :param self_close: 是否自动关闭连接
+    :param fetch_config: 获取配置
+    :return: 查询结果
+    """
+    # 处理select_fields参数
+    if isinstance(select_fields, dict):
+        # 如果是字典，自动添加表名前缀
+        processed_fields = []
+        for table, fields in select_fields.items():
+            for field in fields:
+                processed_fields.append(f"{table}.{field}")
+        columns = processed_fields
+    else :
+        columns = select_fields
+    # 构造select子句
+    select_clause = ', '.join(columns)
+
+    # 处理表名
+    if isinstance(table_names, str):
+        # 单个表
+        sql = f"SELECT {select_clause} FROM {table_names}"
+    elif isinstance(table_names, list):
+        # 多个表，需要JOIN
+        main_table = table_names[0]
+        sql = f"SELECT {select_clause} FROM {main_table}"
+        
+        # 添加JOIN子句
+        if join_conditions:
+            # JOIN操作，table_names必须是包含至少两个表名的列表
+            if isinstance(table_names, str) or len(table_names) < 2:
+                raise ValueError("存在JOIN操作时，table_names必须是包含至少两个表名的列表")
+            join_type = join_conditions.get("join_type", "JOIN")
+            conditions = join_conditions.get("conditions", [])
+            
+            # 为每个额外的表添加JOIN子句
+            for i, join_table in enumerate(table_names[1:], start=1):
+                # 如果提供了具体的JOIN条件，则使用它
+                if conditions and len(conditions) >= 3:
+                    field1, operator, field2 = conditions[0], conditions[1], conditions[2]
+                    # 如果字段名没有表前缀，添加主表前缀
+                    if '.' not in field1:
+                        field1 = f"{main_table}.{field1}"
+                    if '.' not in field2:
+                        field2 = f"{join_table}.{field2}"
+                    sql += f" {join_type} {join_table} ON {field1} {operator} {field2}"
+                else:
+                    # 默认使用item_id进行JOIN
+                    sql += f" {join_type} {join_table} ON {main_table}.item_id = {join_table}.item_id"
+    else:
+        raise ValueError("table_names must be a string or a list of strings")
+
+    # 构造WHERE子句
+    where_clause, params = build_where_clause(where_conditions)
+    if where_clause:
+        sql += f" WHERE {where_clause}"
+
+    # 添加ORDER BY子句（如果提供）
+    if order_by:
+        sql += f" ORDER BY {order_by}"
+
+    # 添加LIMIT子句（如果提供）
+    if limit:
+        sql += f" LIMIT {limit}"
+
+    if fetch_config is None:
+        fetch_config = {}
+
+    fetch_mode = fetch_config["fetch_mode"]
+    output_format = fetch_config["output_format"]
+    show_count = fetch_config.get("show_count", False)
+    
+    # 获取data_label参数
+    data_label = fetch_config.get("data_label", None)
+    
+    # 如果data_label为None，则根据select_fields自动生成
+    if data_label is None and "df" in output_format :
+        if isinstance(select_fields, dict):
+            # 如果select_fields是字典，展平为列表
+            data_label = []
+            for table, fields in select_fields.items():
+                for field in fields:
+                    if field in data_label :
+                        raise ValueError(f"字段值重复：Field '{field}' already exists in data_label")
+                    data_label.append(field)
+        else:
+            # 如果select_fields是列表，直接使用
+            data_label = select_fields
+
+    result = executor.fetch_format(sql, fetch_mode, output_format, show_count, data_label, params, self_close)
+    return result

lazy_mysql-0.1.0/utils/update.py

@@ -0,0 +1,26 @@
+from ..executor import SQLExecutor
+from ..tools.where_clause import build_where_clause
+
+def update(executor: SQLExecutor, table_name, update_fields, where_conditions, commit=False, self_close=False):
+    """
+    通用的SQL更新执行器方法，支持动态构造WHERE子句
+
+    :param executor: SQLExecutor 实例
+    :param table_name: 表名
+    :param update_fields: 需要更新的字段和值，格式为字典，如 {'field1': 'value1', 'field2': 'value2'}
+    :param where_conditions: WHERE条件，格式为字典，如 {'field1': 'value1', 'field2': 'value2'}
+    :param commit: 是否自动提交
+    :param self_close: 是否自动关闭连接
+    :return: None
+    """
+    # 构造SET子句
+    set_clause = ', '.join([f"{field} = %s" for field in update_fields.keys()])
+
+    # 构造WHERE子句
+    where_clause, params = build_where_clause(where_conditions)
+
+    # 构造SQL语句
+    sql = f'''UPDATE {table_name} SET {set_clause} WHERE {where_clause};'''
+
+    # 执行SQL
+    executor.execute(sql, params, commit, self_close)