sql-query-mcp 0.4.0__tar.gz → 0.4.1__tar.gz

{sql_query_mcp-0.4.0/sql_query_mcp.egg-info → sql_query_mcp-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-query-mcp
-Version: 0.4.0
+Version: 0.4.1
 Summary: Read-only SQL MCP server for PostgreSQL and MySQL.
 Author: Andy Wang
 License-Expression: MIT

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sql-query-mcp"
-version = "0.4.0"
+version = "0.4.1"
 description = "Read-only SQL MCP server for PostgreSQL and MySQL."
 readme = "README.md"
 requires-python = ">=3.10"

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/sql_query_mcp/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.4"
+__version__ = "0.4.1"

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/sql_query_mcp/adapters/hive.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Iterator, List
+from typing import Any, Iterator, List
 from urllib.parse import parse_qs, unquote, urlparse
 
 try:
@@ -52,6 +52,10 @@ class HiveAdapter:
     def column_names(self, description) -> List[str]:
         return [column[0] for column in (description or [])]
 
+    def normalize_identifier(self, value: str) -> str:
+        # Hive table and column identifiers are case-insensitive.
+        return value.casefold()
+
     def normalize_rows(self, rows, columns: List[str]) -> List[dict]:
         return [dict(zip(columns, row)) for row in rows]
 
@@ -80,7 +84,7 @@ class HiveAdapter:
         columns = []
         in_partitions = False
         for row in rows:
-            name = self._first_value(row)
+            name = self._describe_value(row, "col_name", 0)
             if not name:
                 continue
             if str(name).startswith("# Partition Information"):
@@ -88,9 +92,8 @@ class HiveAdapter:
                 continue
             if str(name).startswith("#"):
                 continue
-            values = self._row_values(row)
-            data_type = values[1] if len(values) > 1 else None
-            comment = values[2] if len(values) > 2 else None
+            data_type = self._describe_value(row, "data_type", 1)
+            comment = self._describe_value(row, "comment", 2)
             columns.append(
                 {
                     "column_name": name,
@@ -141,7 +144,13 @@ class HiveAdapter:
             return next(iter(row.values()))
         return row[0]
 
-    def _row_values(self, row):
-        if isinstance(row, dict):
-            return list(row.values())
-        return list(row)
+    def _describe_value(self, row, key: str, index: int) -> Any:
+        # Hive table and column identifiers are case-insensitive. DESCRIBE may
+        # return tuples or dict rows, so dict key lookup follows Hive semantics.
+        if not isinstance(row, dict):
+            return row[index] if len(row) > index else None
+        lowered_key = key.lower()
+        for existing_key, value in row.items():
+            if existing_key.lower() == lowered_key:
+                return value
+        return None

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/sql_query_mcp/adapters/mysql.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 from contextlib import contextmanager
-from typing import Iterator, List
+from typing import Any, Iterator, List
 from urllib.parse import parse_qs, unquote, urlparse
 
 try:
@@ -57,7 +57,7 @@ class MySQLAdapter:
                 ORDER BY schema_name
                 """
             )
-            return [row["database_name"] for row in cur.fetchall()]
+            return [_row_value(row, "database_name") for row in cur.fetchall()]
 
     def list_tables(self, conn: object, database: str):
         with conn.cursor() as cur:
@@ -70,7 +70,14 @@ class MySQLAdapter:
                 """,
                 (database,),
             )
-            return cur.fetchall()
+            return [
+                {
+                    "database_name": _row_value(row, "database_name"),
+                    "table_name": _row_value(row, "table_name"),
+                    "table_type": _row_value(row, "table_type"),
+                }
+                for row in cur.fetchall()
+            ]
 
     def describe_table(self, conn: object, database: str, table_name: str):
         with conn.cursor() as cur:
@@ -101,13 +108,13 @@ class MySQLAdapter:
         return {
             "columns": [
                 {
-                    "column_name": row["column_name"],
-                    "data_type": row["column_type"],
+                    "column_name": _row_value(row, "column_name"),
+                    "data_type": _row_value(row, "column_type"),
                     "udt_name": None,
-                    "nullable": row["is_nullable"] == "YES",
-                    "default": row["column_default"],
-                    "primary_key": row["column_key"] == "PRI",
-                    "extra": row["extra"],
+                    "nullable": _row_value(row, "is_nullable") == "YES",
+                    "default": _row_value(row, "column_default"),
+                    "primary_key": _row_value(row, "column_key") == "PRI",
+                    "extra": _row_value(row, "extra"),
                 }
                 for row in columns
             ],
@@ -136,7 +143,7 @@ class MySQLAdapter:
     def extract_plan(self, rows):
         if not rows:
             return []
-        plan = rows[0].get("EXPLAIN", [])
+        plan = _row_value(rows[0], "EXPLAIN")
         if isinstance(plan, str):
             try:
                 return json.loads(plan)
@@ -147,6 +154,11 @@ class MySQLAdapter:
     def column_names(self, description) -> List[str]:
         return [column[0] for column in (description or [])]
 
+    def normalize_identifier(self, value: str) -> str:
+        # MySQL column names, index names, and column aliases are
+        # case-insensitive on every platform.
+        return value.casefold()
+
     def _parse_dsn(self, dsn: str) -> dict:
         parsed = urlparse(dsn)
         if parsed.scheme not in {"mysql", "mysql+pymysql"}:
@@ -169,16 +181,29 @@ class MySQLAdapter:
     def _normalize_indexes(self, rows: List[dict]) -> List[dict]:
         grouped = {}
         for row in rows:
-            index_name = row["index_name"]
+            index_name = _row_value(row, "index_name")
             item = grouped.setdefault(
                 index_name,
                 {
                     "index_name": index_name,
                     "columns": [],
-                    "unique": row["non_unique"] == 0,
+                    "unique": _row_value(row, "non_unique") == 0,
                     "primary_key": index_name == "PRIMARY",
                     "definition": None,
                 },
             )
-            item["columns"].append(row["column_name"])
+            item["columns"].append(_row_value(row, "column_name"))
         return [grouped[name] for name in sorted(grouped)]
+
+
+def _row_value(row: dict, key: str) -> Any:
+    # MySQL column names, index names, and column aliases are case-insensitive,
+    # and drivers may expose information_schema labels as COLUMN_NAME or
+    # column_name. Keep this normalization local to the MySQL adapter.
+    if key in row:
+        return row[key]
+    lowered_key = key.lower()
+    for existing_key, value in row.items():
+        if existing_key.lower() == lowered_key:
+            return value
+    raise KeyError(key)

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/sql_query_mcp/adapters/postgres.py

@@ -188,6 +188,11 @@ class PostgresAdapter:
     def column_names(self, description) -> List[str]:
         return [column.name for column in (description or [])]
 
+    def normalize_identifier(self, value: str) -> str:
+        # PostgreSQL quoted identifiers are case-sensitive, and this adapter
+        # quotes import columns with sql.Identifier, so header matching is exact.
+        return value
+
     def _get_pool(self, connection_id: str, dsn: str) -> ConnectionPool:
         if ConnectionPool is None or dict_row is None:
             raise ConfigurationError("缺少 psycopg / psycopg-pool 依赖，请先安装项目依赖。")

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/sql_query_mcp/importer.py

@@ -68,7 +68,8 @@ class TableFileImporter:
                         f"未找到表 {namespace.value}.{table_name}，或当前用户没有访问权限"
                     )
                 table_columns = [item["column_name"] for item in description["columns"]]
-                _validate_headers(headers, table_columns)
+                normalize_identifier = getattr(adapter, "normalize_identifier", _exact_identifier)
+                _validate_headers(headers, table_columns, normalize_identifier)
                 query = adapter.build_insert_query(namespace.value, table_name, headers)
                 _execute_insert(conn, config.engine, query, rows)
 
@@ -170,20 +171,42 @@ def _normalize_row(row: Sequence[object], expected_length: int) -> Tuple[object,
     return tuple(None if value == "" else value for value in row)
 
 
-def _validate_headers(headers: Sequence[str], table_columns: Sequence[str]) -> None:
+def _validate_headers(
+    headers: Sequence[str],
+    table_columns: Sequence[str],
+    normalize_identifier=None,
+) -> None:
+    if normalize_identifier is None:
+        normalize_identifier = _exact_identifier
     if not headers:
         raise QueryExecutionError("文件表头不能为空。")
     empty_headers = [index + 1 for index, header in enumerate(headers) if not header]
     if empty_headers:
         raise QueryExecutionError(f"文件表头存在空字段，位置: {empty_headers}")
-    duplicates = sorted({header for header in headers if headers.count(header) > 1})
+    normalized_headers = [normalize_identifier(header) for header in headers]
+    duplicates = sorted(
+        {
+            header
+            for header, normalized in zip(headers, normalized_headers)
+            if normalized_headers.count(normalized) > 1
+        }
+    )
     if duplicates:
         raise QueryExecutionError(f"文件表头存在重复字段: {duplicates}")
-    unknown = sorted(set(headers) - set(table_columns))
+    normalized_table_columns = {normalize_identifier(column) for column in table_columns}
+    unknown = sorted(
+        header
+        for header, normalized in zip(headers, normalized_headers)
+        if normalized not in normalized_table_columns
+    )
     if unknown:
         raise QueryExecutionError(f"文件表头包含目标表不存在的字段: {unknown}")
 
 
+def _exact_identifier(value: str) -> str:
+    return value
+
+
 def _execute_insert(conn: Any, engine: str, query: object, rows: List[Tuple[object, ...]]) -> None:
     if engine == "postgres" and hasattr(conn, "transaction"):
         with conn.transaction():

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1/sql_query_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-query-mcp
-Version: 0.4.0
+Version: 0.4.1
 Summary: Read-only SQL MCP server for PostgreSQL and MySQL.
 Author: Andy Wang
 License-Expression: MIT

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/tests/test_importer.py

@@ -108,6 +108,14 @@ class _AdapterStub:
     def build_insert_query(self, namespace: str, table_name: str, columns):
         return f"insert {namespace}.{table_name} ({','.join(columns)})"
 
+    def normalize_identifier(self, value: str) -> str:
+        return value
+
+
+class _CaseInsensitiveAdapterStub(_AdapterStub):
+    def normalize_identifier(self, value: str) -> str:
+        return value.casefold()
+
 
 class _RegistryStub:
     def __init__(self, config: ConnectionConfig, adapter: object, conn: object) -> None:
@@ -160,6 +168,56 @@ class TableFileImporterTestCase(unittest.TestCase):
         self.assertEqual(2, records[0]["row_count"])
         self.assertEqual(".csv", records[0]["extra"]["file_extension"])
 
+    def test_mysql_import_csv_accepts_header_case_by_adapter_semantics(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            csv_path = _write_csv(Path(temp_dir) / "users.csv", [["ID", "NAME"], ["1", "Alice"]])
+            conn = _ConnectionStub()
+            importer = _build_importer(
+                Path(temp_dir) / "audit.jsonl",
+                conn,
+                adapter=_CaseInsensitiveAdapterStub(),
+            )
+
+            result = importer.import_table_file(
+                "crm_mysql_prod_main_rw",
+                "users",
+                str(csv_path),
+            )
+
+        self.assertEqual(1, result["inserted_row_count"])
+        self.assertEqual(
+            [("insert crm.users (ID,NAME)", [("1", "Alice")])],
+            conn.cursor_stub.executed_many,
+        )
+
+    def test_mysql_import_csv_rejects_case_only_duplicate_header(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            csv_path = _write_csv(Path(temp_dir) / "users.csv", [["id", "ID"], ["1", "2"]])
+            conn = _ConnectionStub()
+            importer = _build_importer(
+                Path(temp_dir) / "audit.jsonl",
+                conn,
+                adapter=_CaseInsensitiveAdapterStub(),
+            )
+
+            with self.assertRaises(QueryExecutionError) as caught:
+                importer.import_table_file("crm_mysql_prod_main_rw", "users", str(csv_path))
+
+        self.assertIn("重复字段", str(caught.exception))
+        self.assertEqual([], conn.cursor_stub.executed_many)
+
+    def test_postgres_import_csv_rejects_header_with_different_case(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            csv_path = _write_csv(Path(temp_dir) / "users.csv", [["ID"], ["1"]])
+            conn = _ConnectionStub()
+            importer = _build_postgres_importer(Path(temp_dir) / "audit.jsonl", conn)
+
+            with self.assertRaises(QueryExecutionError) as caught:
+                importer.import_table_file("crm_postgres_prod_main_rw", "users", str(csv_path))
+
+        self.assertIn("不存在的字段", str(caught.exception))
+        self.assertEqual([], conn.cursor_stub.executed_many)
+
     def test_hive_import_csv_uses_existing_import_tool_path(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
             csv_path = _write_csv(
@@ -183,6 +241,28 @@ class TableFileImporterTestCase(unittest.TestCase):
             conn.cursor_stub.executed,
         )
 
+    def test_hive_import_csv_accepts_header_case_by_adapter_semantics(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            csv_path = _write_csv(Path(temp_dir) / "users.csv", [["NAME"], ["Alice"]])
+            conn = _HiveConnectionStub()
+            importer = _build_hive_importer(
+                Path(temp_dir) / "audit.jsonl",
+                conn,
+                adapter=_CaseInsensitiveAdapterStub(),
+            )
+
+            result = importer.import_table_file(
+                "warehouse_hive_prod_main_rw",
+                "users",
+                str(csv_path),
+            )
+
+        self.assertEqual(1, result["inserted_row_count"])
+        self.assertEqual(
+            [("insert analytics.users (NAME)", ("Alice",))],
+            conn.cursor_stub.executed,
+        )
+
     def test_hive_import_csv_executes_each_row_without_result_set_error(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
             csv_path = _write_csv(
@@ -384,7 +464,11 @@ class TableFileImporterTestCase(unittest.TestCase):
         self.assertEqual(0, conn.begin_calls)
 
 
-def _build_importer(log_path: Path, conn: _ConnectionStub) -> TableFileImporter:
+def _build_importer(
+    log_path: Path,
+    conn: _ConnectionStub,
+    adapter: object | None = None,
+) -> TableFileImporter:
     config = ConnectionConfig(
         connection_id="crm_mysql_prod_main_rw",
         engine="mysql",
@@ -396,6 +480,25 @@ def _build_importer(log_path: Path, conn: _ConnectionStub) -> TableFileImporter:
         enabled=True,
         default_database="crm",
     )
+    return TableFileImporter(
+        registry=_RegistryStub(config, adapter or _AdapterStub(), conn),
+        settings=ServerSettings(audit_log_path=log_path),
+        audit_logger=AuditLogger(log_path),
+    )
+
+
+def _build_postgres_importer(log_path: Path, conn: object) -> TableFileImporter:
+    config = ConnectionConfig(
+        connection_id="crm_postgres_prod_main_rw",
+        engine="postgres",
+        label="CRM PostgreSQL",
+        env="prod",
+        tenant="main",
+        role="rw",
+        dsn_env="PG_CONN",
+        enabled=True,
+        default_schema="public",
+    )
     return TableFileImporter(
         registry=_RegistryStub(config, _AdapterStub(), conn),
         settings=ServerSettings(audit_log_path=log_path),
@@ -403,7 +506,11 @@ def _build_importer(log_path: Path, conn: _ConnectionStub) -> TableFileImporter:
     )
 
 
-def _build_hive_importer(log_path: Path, conn: object) -> TableFileImporter:
+def _build_hive_importer(
+    log_path: Path,
+    conn: object,
+    adapter: object | None = None,
+) -> TableFileImporter:
     config = ConnectionConfig(
         connection_id="warehouse_hive_prod_main_rw",
         engine="hive",
@@ -416,7 +523,7 @@ def _build_hive_importer(log_path: Path, conn: object) -> TableFileImporter:
         default_database="analytics",
     )
     return TableFileImporter(
-        registry=_RegistryStub(config, _AdapterStub(), conn),
+        registry=_RegistryStub(config, adapter or _AdapterStub(), conn),
         settings=ServerSettings(audit_log_path=log_path),
         audit_logger=AuditLogger(log_path),
     )

{sql_query_mcp-0.4.0 → sql_query_mcp-0.4.1}/tests/test_validator.py

@@ -40,6 +40,32 @@ class _HiveConnectionStub:
         return self.cursor_stub
 
 
+class _MySQLCursorStub:
+    def __init__(self, result_sets) -> None:
+        self._result_sets = list(result_sets)
+        self.executed = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        return None
+
+    def execute(self, sql: str, params=None) -> None:
+        self.executed.append((sql, params))
+
+    def fetchall(self):
+        return self._result_sets.pop(0)
+
+
+class _MySQLConnectionStub:
+    def __init__(self, result_sets) -> None:
+        self.cursor_stub = _MySQLCursorStub(result_sets)
+
+    def cursor(self) -> _MySQLCursorStub:
+        return self.cursor_stub
+
+
 class ValidatorTestCase(unittest.TestCase):
     def test_accepts_plain_select(self) -> None:
         self.assertEqual("SELECT 1", validate_select_sql("SELECT 1;", "postgres"))
@@ -253,12 +279,135 @@ class ValidatorTestCase(unittest.TestCase):
         )
         self.assertEqual([], description["indexes"])
 
+    def test_hive_describe_table_reads_dict_keys_case_insensitively(self) -> None:
+        conn = _HiveConnectionStub(
+            [
+                {
+                    "COMMENT": "customer identifier",
+                    "DATA_TYPE": "int",
+                    "COL_NAME": "id",
+                }
+            ]
+        )
+
+        description = HiveAdapter().describe_table(conn, "analytics", "orders")
+
+        self.assertEqual(
+            [
+                {
+                    "column_name": "id",
+                    "data_type": "int",
+                    "udt_name": None,
+                    "nullable": True,
+                    "default": None,
+                    "primary_key": False,
+                    "extra": "customer identifier",
+                    "partition_key": False,
+                }
+            ],
+            description["columns"],
+        )
+
     def test_mysql_explain_plan_is_parsed_to_structured_json(self) -> None:
         plan = MySQLAdapter().extract_plan(
             [{"EXPLAIN": json.dumps({"query_block": {"select_id": 1}})}]
         )
         self.assertEqual({"query_block": {"select_id": 1}}, plan)
 
+    def test_mysql_explain_plan_reads_label_case_insensitively(self) -> None:
+        plan = MySQLAdapter().extract_plan(
+            [{"explain": json.dumps({"query_block": {"select_id": 1}})}]
+        )
+
+        self.assertEqual({"query_block": {"select_id": 1}}, plan)
+
+    def test_mysql_list_databases_reads_row_keys_case_insensitively(self) -> None:
+        conn = _MySQLConnectionStub([[{"DATABASE_NAME": "crm"}]])
+
+        databases = MySQLAdapter().list_databases(conn)
+
+        self.assertEqual(["crm"], databases)
+
+    def test_mysql_list_tables_returns_normalized_rows(self) -> None:
+        conn = _MySQLConnectionStub(
+            [
+                [
+                    {
+                        "DATABASE_NAME": "crm",
+                        "TABLE_NAME": "orders",
+                        "TABLE_TYPE": "BASE TABLE",
+                    }
+                ]
+            ]
+        )
+
+        tables = MySQLAdapter().list_tables(conn, "crm")
+
+        self.assertEqual(
+            [
+                {
+                    "database_name": "crm",
+                    "table_name": "orders",
+                    "table_type": "BASE TABLE",
+                }
+            ],
+            tables,
+        )
+
+    def test_mysql_describe_table_reads_metadata_keys_case_insensitively(self) -> None:
+        conn = _MySQLConnectionStub(
+            [
+                [
+                    {
+                        "COLUMN_NAME": "id",
+                        "COLUMN_TYPE": "bigint",
+                        "IS_NULLABLE": "NO",
+                        "COLUMN_DEFAULT": None,
+                        "EXTRA": "auto_increment",
+                        "COLUMN_KEY": "PRI",
+                        "ORDINAL_POSITION": 1,
+                    }
+                ],
+                [
+                    {
+                        "INDEX_NAME": "PRIMARY",
+                        "NON_UNIQUE": 0,
+                        "SEQ_IN_INDEX": 1,
+                        "COLUMN_NAME": "id",
+                    }
+                ],
+            ]
+        )
+
+        description = MySQLAdapter().describe_table(conn, "crm", "orders")
+
+        self.assertEqual(
+            [
+                {
+                    "column_name": "id",
+                    "data_type": "bigint",
+                    "udt_name": None,
+                    "nullable": False,
+                    "default": None,
+                    "primary_key": True,
+                    "extra": "auto_increment",
+                }
+            ],
+            description["columns"],
+        )
+        self.assertEqual(
+            [
+                {
+                    "index_name": "PRIMARY",
+                    "columns": ["id"],
+                    "unique": True,
+                    "primary_key": True,
+                    "definition": None,
+                }
+            ],
+            description["indexes"],
+        )
+
     def test_postgres_build_insert_query_quotes_identifiers(self) -> None:
         query = PostgresAdapter().build_insert_query(
             "public", "orders", ["order", "status"]