mcp-dbutils 0.16.1__py3-none-any.whl → 0.18.0__py3-none-any.whl

mcp_dbutils/sqlite/handler.py

@@ -1,6 +1,7 @@
 """SQLite connection handler implementation"""
 
 import sqlite3
+import time
 
 import mcp.types as types
 
@@ -78,28 +79,51 @@ class SQLiteHandler(ConnectionHandler):
     async def _execute_query(self, sql: str) -> str:
         """Execute SQL query"""
         try:
-            # Only allow SELECT statements
-            if not sql.strip().upper().startswith("SELECT"):
-                raise ConnectionHandlerError("cannot execute DELETE statement")
-            
-            with sqlite3.connect(self.config.path) as conn:
-                conn.row_factory = sqlite3.Row
-                cur = conn.cursor()
-                self.log("debug", f"Executing query: {sql}")
-                
+            # Check if the query is a DDL statement
+            sql_upper = sql.strip().upper()
+            is_ddl = sql_upper.startswith(("CREATE", "DROP", "ALTER", "TRUNCATE"))
+            is_dml = sql_upper.startswith(("INSERT", "UPDATE", "DELETE"))
+            is_select = sql_upper.startswith("SELECT")
+
+            if not (is_select or is_ddl or is_dml):
+                raise ConnectionHandlerError("Only SELECT, DDL, and DML statements are allowed")
+
+            conn = sqlite3.connect(self.config.path)
+            cur = conn.cursor()
+
+            try:
+                start_time = time.time()
                 cur.execute(sql)
-                results = cur.fetchall()
-                rows = [dict(row) for row in results]
-
-                result_text = str({
-                    'type': self.db_type,
-                    'columns': list(rows[0].keys()) if rows else [],
-                    'rows': rows,
-                    'row_count': len(rows)
-                })
+                conn.commit()
+                end_time = time.time()
+                elapsed_ms = (end_time - start_time) * 1000
+                self.log("debug", f"Query executed in {elapsed_ms:.2f}ms")
+
+                if is_select:
+                    # Get column names
+                    columns = [description[0] for description in cur.description]
+                    # Fetch results and convert to dictionaries
+                    results = []
+                    for row in cur.fetchall():
+                        # Convert each row to a dictionary
+                        row_dict = {}
+                        for i, col_name in enumerate(columns):
+                            row_dict[col_name] = row[i]
+                        results.append(row_dict)
 
-                self.log("debug", f"Query completed, returned {len(rows)} rows")
-                return result_text
+                    return str({
+                        "columns": columns,
+                        "rows": results
+                    })
+                else:
+                    # For DDL/DML statements
+                    return "Query executed successfully"
+            except sqlite3.Error as e:
+                self.log("error", f"Query error: {str(e)}")
+                raise ConnectionHandlerError(str(e))
+            finally:
+                cur.close()
+                conn.close()
         except sqlite3.Error as e:
             error_msg = f"[{self.db_type}] Query execution failed: {str(e)}"
             raise ConnectionHandlerError(error_msg)
@@ -112,13 +136,13 @@ class SQLiteHandler(ConnectionHandler):
                 # 获取表信息
                 cur.execute(f"PRAGMA table_info({table_name})")
                 columns = cur.fetchall()
-                
+
                 # SQLite不支持表级注释，但我们可以获取表的详细信息
                 description = [
                     f"Table: {table_name}\n",
                     COLUMNS_HEADER
                 ]
-                
+
                 for col in columns:
                     col_info = [
                         f"  {col[1]} ({col[2]})",
@@ -128,9 +152,9 @@ class SQLiteHandler(ConnectionHandler):
                     ]
                     description.extend(col_info)
                     description.append("")  # Empty line between columns
-                
+
                 return "\n".join(description)
-                
+
         except sqlite3.Error as e:
             error_msg = f"Failed to get table description: {str(e)}"
             self.stats.record_error(e.__class__.__name__)
@@ -144,25 +168,25 @@ class SQLiteHandler(ConnectionHandler):
                 # SQLite provides the complete CREATE statement
                 cur.execute("SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
                 result = cur.fetchone()
-                
+
                 if not result:
                     return f"Table {table_name} not found"
-                
+
                 ddl = result[0]
-                
+
                 # Get indexes
                 cur.execute("SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name=?", (table_name,))
                 indexes = cur.fetchall()
-                
+
                 # Add index definitions
                 if indexes:
                     ddl = ddl + "\n\n-- Indexes:"
                     for idx in indexes:
                         if idx[0]:  # Some internal indexes might have NULL sql
                             ddl = ddl + "\n" + idx[0] + ";"
-                            
+
                 return ddl
-                
+
         except sqlite3.Error as e:
             error_msg = f"Failed to get table DDL: {str(e)}"
             self.stats.record_error(e.__class__.__name__)
@@ -173,43 +197,49 @@ class SQLiteHandler(ConnectionHandler):
         try:
             with sqlite3.connect(self.config.path) as conn:
                 cur = conn.cursor()
+
+                # Check if table exists
+                cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+                if not cur.fetchone():
+                    raise ConnectionHandlerError(f"Table '{table_name}' doesn't exist")
+
                 # 获取索引列表
                 cur.execute(f"PRAGMA index_list({table_name})")
                 indexes = cur.fetchall()
-                
+
                 if not indexes:
                     return f"No indexes found on table {table_name}"
-                
+
                 formatted_indexes = [f"Indexes for {table_name}:"]
-                
+
                 for idx in indexes:
                     # 获取索引详细信息
                     cur.execute(f"PRAGMA index_info({idx[1]})")
                     index_info = cur.fetchall()
-                    
+
                     # 获取索引的SQL定义
                     cur.execute("SELECT sql FROM sqlite_master WHERE type='index' AND name=?", (idx[1],))
                     sql = cur.fetchone()
-                    
+
                     index_details = [
                         f"\nIndex: {idx[1]}",
                         f"Type: {'UNIQUE' if idx[2] else 'INDEX'}",
                         COLUMNS_HEADER
                     ]
-                    
+
                     for col in index_info:
                         index_details.append(f"  - {col[2]}")
-                        
+
                     if sql and sql[0]:
                         index_details.extend([
                             "Definition:",
                             f"  {sql[0]}"
                         ])
-                        
+
                     formatted_indexes.extend(index_details)
-                
+
                 return "\n".join(formatted_indexes)
-                
+
         except sqlite3.Error as e:
             error_msg = f"Failed to get index information: {str(e)}"
             self.stats.record_error(e.__class__.__name__)
@@ -220,28 +250,33 @@ class SQLiteHandler(ConnectionHandler):
         try:
             with sqlite3.connect(self.config.path) as conn:
                 cur = conn.cursor()
-                
+
+                # Check if table exists
+                cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+                if not cur.fetchone():
+                    raise ConnectionHandlerError(f"Table '{table_name}' doesn't exist")
+
                 # Get basic table information
                 cur.execute(f"PRAGMA table_info({table_name})")
                 columns = cur.fetchall()
-                
+
                 # Count rows
                 cur.execute(f"SELECT COUNT(*) FROM {table_name}")
                 row_count = cur.fetchone()[0]
-                
+
                 # Get index information
                 cur.execute(f"PRAGMA index_list({table_name})")
                 indexes = cur.fetchall()
-                
+
                 # Get page count and size
                 cur.execute("PRAGMA page_count")
                 page_count = cur.fetchone()[0]
                 cur.execute("PRAGMA page_size")
                 page_size = cur.fetchone()[0]
-                
+
                 # Calculate total size
                 total_size = page_count * page_size
-                
+
                 # Format size in human readable format
                 def format_size(size):
                     for unit in ['B', 'KB', 'MB', 'GB']:
@@ -249,7 +284,7 @@ class SQLiteHandler(ConnectionHandler):
                             return f"{size:.2f} {unit}"
                         size /= 1024
                     return f"{size:.2f} TB"
-                
+
                 # Get column statistics
                 column_stats = []
                 for col in columns:
@@ -260,7 +295,7 @@ class SQLiteHandler(ConnectionHandler):
                     # Get distinct value count
                     cur.execute(f"SELECT COUNT(DISTINCT {col_name}) FROM {table_name}")
                     distinct_count = cur.fetchone()[0]
-                    
+
                     column_stats.append({
                         'name': col_name,
                         'type': col[2],
@@ -268,7 +303,7 @@ class SQLiteHandler(ConnectionHandler):
                         'null_percent': (null_count / row_count * 100) if row_count > 0 else 0,
                         'distinct_count': distinct_count
                     })
-                
+
                 # Format output
                 output = [
                     f"Table Statistics for {table_name}:",
@@ -279,7 +314,7 @@ class SQLiteHandler(ConnectionHandler):
                     f"  Index Count: {len(indexes)}\n",
                     "Column Statistics:"
                 ]
-                
+
                 for stat in column_stats:
                     col_info = [
                         f"  {stat['name']} ({stat['type']}):",
@@ -288,7 +323,7 @@ class SQLiteHandler(ConnectionHandler):
                     ]
                     output.extend(col_info)
                     output.append("")  # Empty line between columns
-                
+
                 return "\n".join(output)
 
         except sqlite3.Error as e:
@@ -301,21 +336,21 @@ class SQLiteHandler(ConnectionHandler):
         try:
             with sqlite3.connect(self.config.path) as conn:
                 cur = conn.cursor()
-                
+
                 # Get table info (includes PRIMARY KEY)
                 cur.execute(f"PRAGMA table_info({table_name})")
                 columns = cur.fetchall()
-                
+
                 # Get foreign keys
                 cur.execute(f"PRAGMA foreign_key_list({table_name})")
                 foreign_keys = cur.fetchall()
-                
+
                 # Get indexes (for UNIQUE constraints)
                 cur.execute(f"PRAGMA index_list({table_name})")
                 indexes = cur.fetchall()
-                
+
                 output = [f"Constraints for {table_name}:"]
-                
+
                 # Primary Key constraints
                 pk_columns = [col[1] for col in columns if col[5]]  # col[5] is pk flag
                 if pk_columns:
@@ -323,13 +358,13 @@ class SQLiteHandler(ConnectionHandler):
                         "\nPrimary Key Constraints:",
                         f"  PRIMARY KEY ({', '.join(pk_columns)})"
                     ])
-                
+
                 # Foreign Key constraints
                 if foreign_keys:
                     output.append("\nForeign Key Constraints:")
                     current_fk = None
                     fk_columns = []
-                    
+
                     for fk in foreign_keys:
                         # SQLite foreign_key_list format:
                         # id, seq, table, from, to, on_update, on_delete, match
@@ -345,10 +380,10 @@ class SQLiteHandler(ConnectionHandler):
                             output.append(f"    ON UPDATE: {fk[5]}")
                         if fk[6]:  # on_delete
                             output.append(f"    ON DELETE: {fk[6]}")
-                    
+
                     if fk_columns:
                         output.append(f"    ({', '.join(fk_columns)})")
-                
+
                 # Unique constraints (from indexes)
                 unique_indexes = [idx for idx in indexes if idx[2]]  # idx[2] is unique flag
                 if unique_indexes:
@@ -359,7 +394,7 @@ class SQLiteHandler(ConnectionHandler):
                         index_info = cur.fetchall()
                         columns = [info[2] for info in index_info]  # info[2] is column name
                         output.append(f"  UNIQUE ({', '.join(columns)})")
-                
+
                 # Check constraints
                 # Note: SQLite doesn't provide direct access to CHECK constraints through PRAGMA
                 # We need to parse the table creation SQL
@@ -368,7 +403,7 @@ class SQLiteHandler(ConnectionHandler):
                 if "CHECK" in create_sql.upper():
                     output.append("\nCheck Constraints:")
                     output.append("  See table DDL for CHECK constraints")
-                
+
                 return "\n".join(output)
 
         except sqlite3.Error as e:
@@ -381,11 +416,18 @@ class SQLiteHandler(ConnectionHandler):
         try:
             with sqlite3.connect(self.config.path) as conn:
                 cur = conn.cursor()
-                
+
+                # Check if the query is valid by preparing it
+                try:
+                    # Use prepare to validate the query without executing it
+                    conn.execute(f"EXPLAIN {sql}")
+                except sqlite3.Error as e:
+                    raise ConnectionHandlerError(f"Failed to explain query: {str(e)}")
+
                 # Get EXPLAIN output
                 cur.execute(f"EXPLAIN QUERY PLAN {sql}")
                 plan = cur.fetchall()
-                
+
                 # Format the output
                 output = [
                     "Query Execution Plan:",
@@ -393,20 +435,20 @@ class SQLiteHandler(ConnectionHandler):
                     "Details:",
                     "--------"
                 ]
-                
+
                 for step in plan:
                     # EXPLAIN QUERY PLAN format:
                     # id | parent | notused | detail
                     indent = "  " * (step[0] - step[1] if step[1] >= 0 else step[0])
                     output.append(f"{indent}{step[3]}")
-                
+
                 # Add query statistics
                 output.extend([
                     "\nNote: SQLite's EXPLAIN QUERY PLAN provides a high-level overview.",
                     "For detailed execution statistics, consider using EXPLAIN (not QUERY PLAN)",
                     "which shows the virtual machine instructions."
                 ])
-                
+
                 return "\n".join(output)
 
         except sqlite3.Error as e:
@@ -414,6 +456,21 @@ class SQLiteHandler(ConnectionHandler):
             self.stats.record_error(e.__class__.__name__)
             raise ConnectionHandlerError(error_msg)
 
+    async def test_connection(self) -> bool:
+        """Test database connection
+
+        Returns:
+            bool: True if connection is successful, False otherwise
+        """
+        try:
+            with sqlite3.connect(self.config.path) as conn:
+                cur = conn.cursor()
+                cur.execute("SELECT 1")
+                return True
+        except sqlite3.Error as e:
+            self.log("error", f"Connection test failed: {str(e)}")
+            return False
+
     async def cleanup(self):
         """Cleanup resources"""
         # Log final stats

mcp_dbutils-0.18.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: mcp-dbutils
+Version: 0.18.0
+Summary: MCP Database Utilities Service
+Author: Dong Hao
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.2.1
+Requires-Dist: mysql-connector-python>=8.2.0
+Requires-Dist: psycopg2-binary>=2.9.10
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: test
+Requires-Dist: aiosqlite>=0.19.0; extra == 'test'
+Requires-Dist: docker>=7.0.0; extra == 'test'
+Requires-Dist: pre-commit>=3.6.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'test'
+Requires-Dist: pytest-docker>=2.0.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Requires-Dist: ruff>=0.3.0; extra == 'test'
+Requires-Dist: testcontainers>=3.7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# MCP 数据库工具
+
+<!-- 项目状态徽章 -->
+[![构建状态](https://img.shields.io/github/workflow/status/donghao1393/mcp-dbutils/Quality%20Assurance?label=tests)](https://github.com/donghao1393/mcp-dbutils/actions)
+[![覆盖率](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/donghao1393/bdd0a63ec2a816539ff8c136ceb41e48/raw/coverage.json)](https://github.com/donghao1393/mcp-dbutils/actions)
+[![质量门禁状态](https://sonarcloud.io/api/project_badges/measure?project=donghao1393_mcp-dbutils&metric=alert_status)](https://sonarcloud.io/dashboard?id=donghao1393_mcp-dbutils)
+
+<!-- 版本和安装徽章 -->
+[![PyPI 版本](https://img.shields.io/pypi/v/mcp-dbutils)](https://pypi.org/project/mcp-dbutils/)
+[![PyPI 下载量](https://img.shields.io/pypi/dm/mcp-dbutils)](https://pypi.org/project/mcp-dbutils/)
+[![Smithery](https://smithery.ai/badge/@donghao1393/mcp-dbutils)](https://smithery.ai/server/@donghao1393/mcp-dbutils)
+
+<!-- 技术规格徽章 -->
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue)](https://www.python.org/)
+[![许可证](https://img.shields.io/github/license/donghao1393/mcp-dbutils)](LICENSE)
+[![GitHub 星标](https://img.shields.io/github/stars/donghao1393/mcp-dbutils?style=social)](https://github.com/donghao1393/mcp-dbutils/stargazers)
+
+[English](README_EN.md) | [文档导航](#文档导航)
+
+![Image](https://github.com/user-attachments/assets/26c4f1a1-7b19-4bdd-b9fd-34ad198b0ce3)
+
+## 简介
+
+MCP Database Utilities 是一个多功能的 MCP 服务，它使您的 AI 能够通过统一的连接配置安全地访问各种类型的数据库（SQLite、MySQL、PostgreSQL 等）进行数据分析。
+
+您可以将其视为 AI 系统和数据库之间的安全桥梁，允许 AI 在不直接访问数据库或冒数据修改风险的情况下读取和分析您的数据。
+
+### 核心特性
+
+- **安全优先**：严格只读操作，无直接数据库访问，隔离连接，按需连接，自动超时
+- **隐私保障**：本地处理，最小数据暴露，凭证保护，敏感数据屏蔽
+- **多数据库支持**：使用相同的接口连接 SQLite、MySQL、PostgreSQL
+- **简单配置**：所有数据库连接使用单个 YAML 文件
+- **高级功能**：表格浏览、架构分析和查询执行
+
+> 🔒 **安全说明**：MCP 数据库工具采用安全优先的架构设计，非常适合注重数据保护的企业、初创公司和个人用户。详细了解我们的[安全架构](docs/zh/technical/security.md)。
+
+## 快速入门
+
+我们提供了多种安装方式，包括 uvx、Docker 和 Smithery。详细的安装和配置步骤请参阅[安装指南](docs/zh/installation.md)。
+
+### 基本步骤
+
+1. **安装**：选择适合您的安装方式（[详细说明](docs/zh/installation.md)）
+2. **配置**：创建包含数据库连接信息的 YAML 文件（[配置指南](docs/zh/configuration.md)）
+3. **连接**：将配置添加到您的 AI 客户端
+4. **使用**：开始与您的数据库交互（[使用指南](docs/zh/usage.md)）
+
+### 示例交互
+
+**您**："能否列出我的数据库中的所有表？"
+
+**AI**："以下是您的数据库中的表：
+- customers（客户）
+- products（产品）
+- orders（订单）
+- inventory（库存）"
+
+**您**："customers 表的结构是什么样的？"
+
+**AI**："customers 表有以下结构：
+- id（整数，主键）
+- name（文本）
+- email（文本）
+- registration_date（日期）"
+
+## 文档导航
+
+### 入门指南
+- [安装指南](docs/zh/installation.md) - 详细的安装步骤和配置说明
+- [平台特定安装指南](docs/zh/installation-platform-specific.md) - 针对不同操作系统的安装说明
+- [配置指南](docs/zh/configuration.md) - 数据库连接配置示例和最佳实践
+- [使用指南](docs/zh/usage.md) - 基本操作流程和常见使用场景
+
+### 技术文档
+- [架构设计](docs/zh/technical/architecture.md) - 系统架构和组件说明
+- [安全架构](docs/zh/technical/security.md) - 安全特性和保护机制
+- [开发指南](docs/zh/technical/development.md) - 代码质量和开发流程
+- [测试指南](docs/zh/technical/testing.md) - 测试框架和最佳实践
+- [SonarCloud 集成](docs/zh/technical/sonarcloud-integration.md) - SonarCloud 与 AI 集成指南
+
+### 示例文档
+- [SQLite 示例](docs/zh/examples/sqlite-examples.md) - SQLite 数据库操作示例
+- [PostgreSQL 示例](docs/zh/examples/postgresql-examples.md) - PostgreSQL 数据库操作示例
+- [MySQL 示例](docs/zh/examples/mysql-examples.md) - MySQL 数据库操作示例
+- [高级 LLM 交互示例](docs/zh/examples/advanced-llm-interactions.md) - 与各类 LLM 的高级交互示例
+
+### 支持与反馈
+- [GitHub Issues](https://github.com/donghao1393/mcp-dbutils/issues) - 报告问题或请求功能
+- [Smithery](https://smithery.ai/server/@donghao1393/mcp-dbutils) - 简化安装和更新
+
+## 可用工具
+
+MCP 数据库工具提供了多种工具，使 AI 能够与您的数据库交互：
+
+- **dbutils-list-connections**：列出配置中的所有可用数据库连接
+- **dbutils-list-tables**：列出数据库中的所有表
+- **dbutils-run-query**：执行 SQL 查询（仅 SELECT）
+- **dbutils-get-stats**：获取表统计信息
+- **dbutils-list-constraints**：列出表约束
+- **dbutils-explain-query**：获取查询执行计划
+- **dbutils-get-performance**：获取数据库性能指标
+- **dbutils-analyze-query**：分析查询以进行优化
+
+有关这些工具的详细说明和使用示例，请参阅[使用指南](docs/zh/usage.md)。
+
+## 星标历史
+
+[![星标历史图表](https://starchart.cc/donghao1393/mcp-dbutils.svg?variant=adaptive)](https://starchart.cc/donghao1393/mcp-dbutils)
+
+## 许可证
+
+本项目采用 MIT 许可证 - 有关详细信息，请参阅 [LICENSE](LICENSE) 文件。

{mcp_dbutils-0.16.1.dist-info → mcp_dbutils-0.18.0.dist-info}/RECORD

@@ -1,22 +1,22 @@
 mcp_dbutils/__init__.py,sha256=6LLccQv7je2L4IpY_I3OzSJZcK32VUDJv2IY31y6eYg,1900
-mcp_dbutils/base.py,sha256=9UDhPFpw6YdkUMhAqgGyy6vuXA2C78LIGrWiW0zeB8s,30839
+mcp_dbutils/base.py,sha256=ptQfJwzYKteGokOrrkIcG3QIlz-f1Afk_XxyEHYcFLI,35957
 mcp_dbutils/config.py,sha256=bmXpOd1fyYfoyUS75I035ChT6t3wP5AyEnJ06e2ZS2o,1848
 mcp_dbutils/log.py,sha256=mqxi6I_IL-MF1F_pxBtnYZQKOHbGBJ74gsvZHVelr1w,823
 mcp_dbutils/stats.py,sha256=wMqWPfGnEOg9v5YBtTsARV-1YsFUMM_pKdzitzSU9x4,7137
 mcp_dbutils/mysql/__init__.py,sha256=gNhoHaxK1qhvMAH5AVl1vfV1rUpcbV9KZWUQb41aaQk,129
 mcp_dbutils/mysql/config.py,sha256=BTPPFqlhoTp7EBFIeLJZh8x6bCn3q9NivHYz9yZHziw,9820
-mcp_dbutils/mysql/handler.py,sha256=knBoFVYmdse5hsjr4GPi4fZhEaYOPRBPGR2d3w8qqzw,19837
+mcp_dbutils/mysql/handler.py,sha256=L2COmWts8WNQaI7wZSPtQ-BqKnpYL7DRnNk7Yw3UsxU,22285
 mcp_dbutils/mysql/server.py,sha256=1bWAu7qHYXVeTZu4wdEpS6gSVB0RoXKI3Smy_ix-y8A,8586
 mcp_dbutils/postgres/__init__.py,sha256=-2zYuEJEQ2AMvmGhH5Z_umerSvt7S4xOa_XV4wgvGfI,154
 mcp_dbutils/postgres/config.py,sha256=NyQOVhkXJ1S-JD0w-ePNjTKI1Ja-aZQkDUdHi6U7Vl4,7752
-mcp_dbutils/postgres/handler.py,sha256=ppltSKtSk-BlPpp3iEVJlmoyl4AmqKcQHx_0zHlz03Y,24403
+mcp_dbutils/postgres/handler.py,sha256=JKnh3QsF5oQ4nS-OdhMC1nWtTp235PArFncFN4pmDZ8,24670
 mcp_dbutils/postgres/server.py,sha256=_CiJC9PitpI1NB99Q1Bcs5TYADNgDpYMwv88fRHQunE,8640
 mcp_dbutils/sqlite/__init__.py,sha256=fK_3-WylCBYpBAzwuopi8hlwoIGJm2TPAlwcPWG46I0,134
 mcp_dbutils/sqlite/config.py,sha256=j67TJ8mQJ2D886MthSa-zYMtvUUYyyxYLMlNxkYoqZE,4509
-mcp_dbutils/sqlite/handler.py,sha256=25zqoQpMhRNKeO3MH2a0E5dO3-4A8sPb7q87cn7Cs0E,17746
+mcp_dbutils/sqlite/handler.py,sha256=nCgBeBp3zjpE2HNohMbh3Jpz5tNeMczt5K87JOhVWzY,19320
 mcp_dbutils/sqlite/server.py,sha256=jqpE8d9vJETMs5xYGB7P0tvNDPes6Yn5ZM_iCCF7Tv4,7181
-mcp_dbutils-0.16.1.dist-info/METADATA,sha256=mjE8oqdIRiIdiRlyWufFfxWGoHT8aGIoSaVTEuFlkJs,16714
-mcp_dbutils-0.16.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_dbutils-0.16.1.dist-info/entry_points.txt,sha256=XTjt0QmYRgKOJQT6skR9bp1EMUfIrgpHeZJPZ3CJffs,49
-mcp_dbutils-0.16.1.dist-info/licenses/LICENSE,sha256=1A_CwpWVlbjrKdVEYO77vYfnXlW7oxcilZ8FpA_BzCI,1065
-mcp_dbutils-0.16.1.dist-info/RECORD,,
+mcp_dbutils-0.18.0.dist-info/METADATA,sha256=z41vH5CzRdtLPcbzjYJ8HukwkFCPDY4ifAmmfrTh1no,6695
+mcp_dbutils-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_dbutils-0.18.0.dist-info/entry_points.txt,sha256=XTjt0QmYRgKOJQT6skR9bp1EMUfIrgpHeZJPZ3CJffs,49
+mcp_dbutils-0.18.0.dist-info/licenses/LICENSE,sha256=1A_CwpWVlbjrKdVEYO77vYfnXlW7oxcilZ8FpA_BzCI,1065
+mcp_dbutils-0.18.0.dist-info/RECORD,,