datus-mysql 0.1.0__tar.gz

datus_mysql-0.1.0/.gitignore

@@ -0,0 +1,137 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# uv
+uv.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

datus_mysql-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: datus-mysql
+Version: 0.1.0
+Summary: MySQL database adapter for Datus
+Project-URL: Homepage, https://github.com/Datus-ai/datus-db-adapters
+Project-URL: Repository, https://github.com/Datus-ai/datus-db-adapters
+Project-URL: Issues, https://github.com/Datus-ai/datus-db-adapters/issues
+Author-email: DatusAI <support@datus.ai>
+License: Apache-2.0
+Keywords: adapter,database,datus,mysql
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: datus-agent>0.2.1
+Requires-Dist: datus-sqlalchemy>=0.1.0
+Requires-Dist: pymysql>=1.1.1
+Description-Content-Type: text/markdown
+
+# datus-mysql
+
+MySQL database adapter for Datus.
+
+## Installation
+
+```bash
+pip install datus-mysql
+```
+
+This will automatically install the required dependencies:
+- `datus-agent`
+- `datus-sqlalchemy`
+- `pymysql`
+
+## Usage
+
+The adapter is automatically registered with Datus when installed. Configure your database connection in your Datus configuration:
+
+```yaml
+database:
+  type: mysql
+  host: localhost
+  port: 3306
+  username: root
+  password: your_password
+  database: your_database
+```
+
+Or use programmatically:
+
+```python
+from datus_mysql import MySQLConnector
+
+# Create connector
+connector = MySQLConnector(
+    host="localhost",
+    port=3306,
+    user="root",
+    password="your_password",
+    database="mydb"
+)
+
+# Test connection
+connector.test_connection()
+
+# Execute query
+result = connector.execute_query("SELECT * FROM users LIMIT 10")
+print(result.sql_return)
+
+# Get table list
+tables = connector.get_tables()
+print(f"Tables: {tables}")
+
+# Get table schema
+schema = connector.get_schema(table_name="users")
+for column in schema:
+    print(f"{column['name']}: {column['type']}")
+```
+
+## Features
+
+- Full CRUD operations (SELECT, INSERT, UPDATE, DELETE)
+- DDL execution (CREATE, ALTER, DROP)
+- Metadata retrieval (tables, views, schemas)
+- Sample data extraction
+- Multiple result formats (pandas, arrow, csv, list)
+- Connection pooling and management
+- Comprehensive error handling
+
+## Requirements
+
+- Python >= 3.10
+- MySQL >= 5.7 or MariaDB >= 10.2
+- datus-agent >= 0.3.0
+- datus-sqlalchemy >= 0.1.0
+- pymysql >= 1.0.0
+
+## License
+
+Apache License 2.0

datus_mysql-0.1.0/README.md

@@ -0,0 +1,81 @@
+# datus-mysql
+
+MySQL database adapter for Datus.
+
+## Installation
+
+```bash
+pip install datus-mysql
+```
+
+This will automatically install the required dependencies:
+- `datus-agent`
+- `datus-sqlalchemy`
+- `pymysql`
+
+## Usage
+
+The adapter is automatically registered with Datus when installed. Configure your database connection in your Datus configuration:
+
+```yaml
+database:
+  type: mysql
+  host: localhost
+  port: 3306
+  username: root
+  password: your_password
+  database: your_database
+```
+
+Or use programmatically:
+
+```python
+from datus_mysql import MySQLConnector
+
+# Create connector
+connector = MySQLConnector(
+    host="localhost",
+    port=3306,
+    user="root",
+    password="your_password",
+    database="mydb"
+)
+
+# Test connection
+connector.test_connection()
+
+# Execute query
+result = connector.execute_query("SELECT * FROM users LIMIT 10")
+print(result.sql_return)
+
+# Get table list
+tables = connector.get_tables()
+print(f"Tables: {tables}")
+
+# Get table schema
+schema = connector.get_schema(table_name="users")
+for column in schema:
+    print(f"{column['name']}: {column['type']}")
+```
+
+## Features
+
+- Full CRUD operations (SELECT, INSERT, UPDATE, DELETE)
+- DDL execution (CREATE, ALTER, DROP)
+- Metadata retrieval (tables, views, schemas)
+- Sample data extraction
+- Multiple result formats (pandas, arrow, csv, list)
+- Connection pooling and management
+- Comprehensive error handling
+
+## Requirements
+
+- Python >= 3.10
+- MySQL >= 5.7 or MariaDB >= 10.2
+- datus-agent >= 0.3.0
+- datus-sqlalchemy >= 0.1.0
+- pymysql >= 1.0.0
+
+## License
+
+Apache License 2.0

datus_mysql-0.1.0/datus_mysql/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2025-present DatusAI, Inc.
+# Licensed under the Apache License, Version 2.0.
+# See http://www.apache.org/licenses/LICENSE-2.0 for details.
+
+from .config import MySQLConfig
+from .connector import MySQLConnector
+
+__version__ = "0.1.0"
+__all__ = ["MySQLConnector", "MySQLConfig", "register"]
+
+
+def register():
+    """Register MySQL connector with Datus registry."""
+    from datus.tools.db_tools import connector_registry
+
+    connector_registry.register("mysql", MySQLConnector)

datus_mysql-0.1.0/datus_mysql/config.py

@@ -0,0 +1,22 @@
+# Copyright 2025-present DatusAI, Inc.
+# Licensed under the Apache License, Version 2.0.
+# See http://www.apache.org/licenses/LICENSE-2.0 for details.
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MySQLConfig(BaseModel):
+    """MySQL-specific configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    host: str = Field(..., description="MySQL server host")
+    port: int = Field(default=3306, description="MySQL server port")
+    username: str = Field(..., description="MySQL username")
+    password: str = Field(default="", description="MySQL password")
+    database: Optional[str] = Field(default=None, description="Default database name")
+    charset: str = Field(default="utf8mb4", description="Character set to use")
+    autocommit: bool = Field(default=True, description="Enable autocommit mode")
+    timeout_seconds: int = Field(default=30, description="Connection timeout in seconds")

datus_mysql-0.1.0/datus_mysql/connector.py

@@ -0,0 +1,398 @@
+# Copyright 2025-present DatusAI, Inc.
+# Licensed under the Apache License, Version 2.0.
+# See http://www.apache.org/licenses/LICENSE-2.0 for details.
+
+from typing import Any, Dict, List, Optional, Set, Union, override
+from urllib.parse import quote_plus
+
+from datus.schemas.base import TABLE_TYPE
+from datus.tools.db_tools.base import list_to_in_str
+from datus.utils.constants import DBType
+from datus.utils.exceptions import DatusException, ErrorCode
+from datus.utils.loggings import get_logger
+from datus_sqlalchemy import SQLAlchemyConnector
+from pydantic import BaseModel, Field
+from sqlalchemy import text
+
+from .config import MySQLConfig
+
+logger = get_logger(__name__)
+
+
+class TableMetadataNames(BaseModel):
+    """Metadata configuration for different MySQL object types."""
+
+    show_table: str = Field(..., description="SHOW command keyword")
+    show_create_table: str = Field(..., description="SHOW CREATE command keyword")
+    info_table: str = Field(..., description="INFORMATION_SCHEMA table name")
+    table_types: Optional[List[str]] = Field(default=None, description="TABLE_TYPE values in INFORMATION_SCHEMA")
+
+
+# Metadata configuration for MySQL objects
+METADATA_DICT: Dict[TABLE_TYPE, TableMetadataNames] = {
+    "table": TableMetadataNames(
+        show_table="TABLES", show_create_table="TABLE", info_table="TABLES", table_types=["TABLE", "BASE TABLE"]
+    ),
+    "view": TableMetadataNames(
+        show_table="VIEWS",
+        show_create_table="VIEW",
+        info_table="VIEWS",
+    ),
+    "mv": TableMetadataNames(
+        show_table="MATERIALIZED VIEWS",
+        show_create_table="MATERIALIZED VIEW",
+        info_table="MATERIALIZED_VIEWS",
+    ),
+}
+
+
+def _get_metadata_config(table_type: TABLE_TYPE) -> TableMetadataNames:
+    """Get metadata configuration for given table type."""
+    if table_type not in METADATA_DICT:
+        raise DatusException(ErrorCode.COMMON_FIELD_INVALID, f"Invalid table type '{table_type}'")
+    return METADATA_DICT[table_type]
+
+
+class MySQLConnector(SQLAlchemyConnector):
+    """MySQL database connector."""
+
+    def __init__(self, config: Union[MySQLConfig, dict]):
+        """
+        Initialize MySQL connector.
+
+        Args:
+            config: MySQLConfig object or dict with configuration
+        """
+        # Handle config object or dict
+        if isinstance(config, dict):
+            config = MySQLConfig(**config)
+        elif not isinstance(config, MySQLConfig):
+            raise TypeError(f"config must be MySQLConfig or dict, got {type(config)}")
+
+        self.config = config
+        self.host = config.host
+        self.port = config.port
+        self.username = config.username
+        self.password = config.password
+        database = config.database or ""
+
+        # URL encode password to handle special characters
+        encoded_password = quote_plus(self.password) if self.password else ""
+
+        # Build connection string
+        connection_string = (
+            f"mysql+pymysql://{self.username}:{encoded_password}@{self.host}:{self.port}/"
+            f"{database}?charset={config.charset}&autocommit={'true' if config.autocommit else 'false'}"
+        )
+
+        super().__init__(connection_string, dialect=DBType.MYSQL)
+        self.database_name = database
+
+    # ==================== System Resources ====================
+
+    @override
+    def _sys_databases(self) -> Set[str]:
+        """System databases to filter out."""
+        return {"sys", "information_schema", "performance_schema", "mysql"}
+
+    @override
+    def _sys_schemas(self) -> Set[str]:
+        """System schemas to filter out (same as databases for MySQL)."""
+        return self._sys_databases()
+
+    # ==================== Utility Methods ====================
+
+    @staticmethod
+    def _quote_identifier(identifier: str) -> str:
+        """Safely wrap identifiers with backticks for MySQL-compatible dialects."""
+        escaped = identifier.replace("`", "``")
+        return f"`{escaped}`"
+
+    # ==================== Metadata Retrieval ====================
+
+    def _get_metadata(
+        self,
+        table_type: TABLE_TYPE = "table",
+        catalog_name: str = "",
+        database_name: str = "",
+    ) -> List[Dict[str, str]]:
+        """
+        Get metadata for tables/views from INFORMATION_SCHEMA.
+
+        Args:
+            table_type: Type of object (table, view, mv)
+            catalog_name: Catalog name (unused in MySQL)
+            database_name: Database name to query
+
+        Returns:
+            List of metadata dictionaries
+        """
+        self.connect()
+        database_name = database_name or self.database_name
+
+        # Build WHERE clause
+        if database_name:
+            where = f"TABLE_SCHEMA = '{database_name}'"
+        else:
+            where = f"{list_to_in_str('TABLE_SCHEMA not in', list(self._sys_databases()))}"
+
+        # Get metadata configuration
+        metadata_config = _get_metadata_config(table_type)
+
+        # Build and execute query
+        type_filter = list_to_in_str("and TABLE_TYPE in ", metadata_config.table_types)
+        query = (
+            f"SELECT TABLE_SCHEMA, TABLE_NAME "
+            f"FROM information_schema.{metadata_config.info_table} "
+            f"WHERE {where} {type_filter}"
+        )
+
+        query_result = self._execute_pandas(query)
+
+        # Format results
+        result = []
+        for i in range(len(query_result)):
+            db_name = query_result["TABLE_SCHEMA"][i]
+            tb_name = query_result["TABLE_NAME"][i]
+            result.append(
+                {
+                    "identifier": self.identifier(database_name=db_name, table_name=tb_name),
+                    "catalog_name": "",
+                    "schema_name": "",
+                    "database_name": db_name,
+                    "table_name": tb_name,
+                    "table_type": table_type,
+                }
+            )
+        return result
+
+    def _show_create(self, full_name: str, create_type: str) -> str:
+        """
+        Execute SHOW CREATE statement to get DDL.
+
+        Args:
+            full_name: Fully-qualified table name
+            create_type: Object type (TABLE, VIEW, etc.)
+
+        Returns:
+            DDL statement as string
+        """
+        sql = f"SHOW CREATE {create_type} {full_name}"
+        ddl_result = self._execute_pandas(sql)
+        if not ddl_result.empty and len(ddl_result.columns) >= 2:
+            return str(ddl_result.iloc[0, 1])
+        return f"-- DDL not available for {full_name}"
+
+    def _get_objects_with_ddl(
+        self,
+        table_type: TABLE_TYPE = "table",
+        tables: Optional[List[str]] = None,
+        catalog_name: str = "",
+        database_name: str = "",
+    ) -> List[Dict[str, str]]:
+        """
+        Get metadata with DDL statements.
+
+        Args:
+            table_type: Type of object
+            tables: Optional list of specific tables to retrieve
+            catalog_name: Catalog name (unused)
+            database_name: Database name
+
+        Returns:
+            List of metadata dictionaries with DDL
+        """
+        result = []
+        filter_tables = self._reset_filter_tables(tables, catalog_name, database_name)
+        metadata_config = _get_metadata_config(table_type)
+
+        for meta in self._get_metadata(table_type, catalog_name, database_name):
+            full_name = self.full_name(database_name=meta["database_name"], table_name=meta["table_name"])
+
+            # Skip if not in filter list
+            if filter_tables and full_name not in filter_tables:
+                continue
+
+            # Get DDL
+            try:
+                ddl = self._show_create(full_name, metadata_config.show_create_table)
+            except Exception as e:
+                logger.warning(f"Could not get DDL for {full_name}: {e}")
+                ddl = f"-- DDL not available for {meta['table_name']}"
+
+            meta["definition"] = ddl
+            result.append(meta)
+
+        return result
+
+    @override
+    def get_tables(self, catalog_name: str = "", database_name: str = "", schema_name: str = "") -> List[str]:
+        """Get list of table names."""
+        return [meta["table_name"] for meta in self._get_metadata("table", catalog_name, database_name)]
+
+    @override
+    def get_tables_with_ddl(
+        self, catalog_name: str = "", database_name: str = "", schema_name: str = "", tables: Optional[List[str]] = None
+    ) -> List[Dict[str, str]]:
+        """Get tables with DDL statements."""
+        return self._get_objects_with_ddl("table", tables, catalog_name, database_name)
+
+    @override
+    def get_views_with_ddl(
+        self, catalog_name: str = "", database_name: str = "", schema_name: str = ""
+    ) -> List[Dict[str, str]]:
+        """Get views with DDL statements."""
+        return self._get_objects_with_ddl("view", None, catalog_name, database_name)
+
+    @override
+    def get_schema(
+        self, catalog_name: str = "", database_name: str = "", schema_name: str = "", table_name: str = ""
+    ) -> List[Dict[str, Any]]:
+        """
+        Get table schema using DESCRIBE.
+
+        Args:
+            catalog_name: Catalog name (unused)
+            database_name: Database name
+            schema_name: Schema name (unused)
+            table_name: Table name
+
+        Returns:
+            List of column information dictionaries
+        """
+        if not table_name:
+            return []
+
+        database_name = database_name or self.database_name
+        full_table_name = self.full_name(database_name=database_name, table_name=table_name)
+
+        # Use DESCRIBE to get schema
+        sql = f"DESCRIBE {full_table_name}"
+        query_result = self._execute_pandas(sql)
+
+        result = []
+        for i in range(len(query_result)):
+            result.append(
+                {
+                    "cid": i,
+                    "name": query_result["Field"][i],
+                    "type": query_result["Type"][i],
+                    "nullable": query_result["Null"][i] == "YES",
+                    "default_value": query_result["Default"][i],
+                    "pk": query_result["Key"][i] == "PRI",
+                }
+            )
+        return result
+
+    # ==================== Database/Schema Management ====================
+
+    @override
+    def get_databases(self, catalog_name: str = "", include_sys: bool = False) -> List[str]:
+        """Get list of databases (MySQL uses schemas as databases)."""
+        return super().get_schemas(catalog_name=catalog_name, include_sys=include_sys)
+
+    @override
+    def get_schemas(self, catalog_name: str = "", database_name: str = "", include_sys: bool = False) -> List[str]:
+        """MySQL doesn't have separate schemas, return empty list."""
+        return []
+
+    @override
+    def _sqlalchemy_schema(
+        self, catalog_name: str = "", database_name: str = "", schema_name: str = ""
+    ) -> Optional[str]:
+        """Get schema name for SQLAlchemy Inspector (database name in MySQL)."""
+        return database_name or self.database_name
+
+    @override
+    def do_switch_context(self, catalog_name: str = "", database_name: str = "", schema_name: str = ""):
+        """Switch database context using USE statement."""
+        if database_name:
+            self.connection.execute(text(f"USE {self._quote_identifier(database_name)}"))
+
+    # ==================== Sample Data ====================
+
+    def get_sample_rows(
+        self,
+        tables: Optional[List[str]] = None,
+        top_n: int = 5,
+        catalog_name: str = "",
+        database_name: str = "",
+        schema_name: str = "",
+        table_type: TABLE_TYPE = "table",
+    ) -> List[Dict[str, str]]:
+        """Get sample rows from tables."""
+        # Delegate to base class for unsupported table types (e.g., "full")
+        if table_type == "full" or table_type not in METADATA_DICT:
+            return super().get_sample_rows(
+                tables=tables,
+                top_n=top_n,
+                catalog_name=catalog_name,
+                database_name=database_name,
+                schema_name=schema_name,
+                table_type=table_type,
+            )
+
+        self.connect()
+        database_name = database_name or self.database_name
+        result = []
+
+        # If specific tables provided, query those
+        if tables:
+            for table_name in tables:
+                full_name = self.full_name(
+                    catalog_name=catalog_name, database_name=database_name, table_name=table_name
+                )
+                sql = f"SELECT * FROM {full_name} LIMIT {top_n}"
+                df = self._execute_pandas(sql)
+                if not df.empty:
+                    result.append(
+                        {
+                            "identifier": self.identifier(
+                                catalog_name=catalog_name, database_name=database_name, table_name=table_name
+                            ),
+                            "catalog_name": catalog_name,
+                            "database_name": database_name,
+                            "schema_name": "",
+                            "table_name": table_name,
+                            "sample_rows": df.to_csv(index=False),
+                        }
+                    )
+            return result
+
+        # Otherwise get metadata and query all tables
+        metadata = self._get_metadata(table_type, "", database_name)
+        for meta in metadata:
+            full_name = self.full_name(database_name=meta["database_name"], table_name=meta["table_name"])
+            sql = f"SELECT * FROM {full_name} LIMIT {top_n}"
+            df = self._execute_pandas(sql)
+            if not df.empty:
+                result.append(
+                    {
+                        "identifier": meta["identifier"],
+                        "catalog_name": meta["catalog_name"],
+                        "database_name": meta["database_name"],
+                        "schema_name": "",
+                        "table_name": meta["table_name"],
+                        "sample_rows": df.to_csv(index=False),
+                    }
+                )
+        return result
+
+    # ==================== Utility Methods ====================
+
+    @override
+    def full_name(
+        self, catalog_name: str = "", database_name: str = "", schema_name: str = "", table_name: str = ""
+    ) -> str:
+        """Build fully-qualified table name."""
+        if database_name:
+            return f"`{database_name}`.`{table_name}`"
+        return f"`{table_name}`"
+
+    @override
+    def _reset_filter_tables(
+        self, tables: Optional[List[str]] = None, catalog_name: str = "", database_name: str = "", schema_name: str = ""
+    ) -> List[str]:
+        """Reset filter tables with full names."""
+        database_name = database_name or self.database_name
+        return super()._reset_filter_tables(tables, "", database_name, "")

datus_mysql-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "datus-mysql"
+version = "0.1.0"
+description = "MySQL database adapter for Datus"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "Apache-2.0"}
+authors = [
+    {name = "DatusAI", email = "support@datus.ai"}
+]
+keywords = ["datus", "database", "mysql", "adapter"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "datus-agent>0.2.1",
+    "datus-sqlalchemy>=0.1.0",
+    "pymysql>=1.1.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/Datus-ai/datus-db-adapters"
+Repository = "https://github.com/Datus-ai/datus-db-adapters"
+Issues = "https://github.com/Datus-ai/datus-db-adapters/issues"
+
+[project.entry-points."datus.adapters"]
+mysql = "datus_mysql:register"
+
+[tool.uv.sources]
+datus-sqlalchemy = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["datus_mysql"]

datus_mysql-0.1.0/tests/test_connector.py

@@ -0,0 +1,400 @@
+# Copyright 2025-present DatusAI, Inc.
+# Licensed under the Apache License, Version 2.0.
+# See http://www.apache.org/licenses/LICENSE-2.0 for details.
+
+import os
+import uuid
+from typing import Generator
+
+import pytest
+from datus.utils.exceptions import DatusException
+from datus_mysql import MySQLConfig, MySQLConnector
+
+
+@pytest.fixture
+def config() -> MySQLConfig:
+    """Create MySQL configuration from environment or defaults."""
+    return MySQLConfig(
+        host=os.getenv("MYSQL_HOST", "localhost"),
+        port=int(os.getenv("MYSQL_PORT", "3306")),
+        username=os.getenv("MYSQL_USER", "root"),
+        password=os.getenv("MYSQL_PASSWORD", ""),
+        database=os.getenv("MYSQL_DATABASE", "test"),
+    )
+
+
+@pytest.fixture
+def connector(config: MySQLConfig) -> Generator[MySQLConnector, None, None]:
+    """Create and cleanup MySQL connector."""
+    conn = MySQLConnector(config)
+    yield conn
+    conn.close()
+
+
+# ==================== Connection Tests ====================
+
+
+def test_connection_with_config_object(config: MySQLConfig):
+    """Test connection using config object."""
+    conn = MySQLConnector(config)
+    assert conn.test_connection()
+    conn.close()
+
+
+def test_connection_with_dict():
+    """Test connection using dict config."""
+    conn = MySQLConnector(
+        {
+            "host": os.getenv("MYSQL_HOST", "localhost"),
+            "port": int(os.getenv("MYSQL_PORT", "3306")),
+            "username": os.getenv("MYSQL_USER", "root"),
+            "password": os.getenv("MYSQL_PASSWORD", ""),
+        }
+    )
+    assert conn.test_connection()
+    conn.close()
+
+
+# ==================== Database Tests ====================
+
+
+def test_get_databases(connector: MySQLConnector):
+    """Test getting list of databases."""
+    databases = connector.get_databases()
+    assert isinstance(databases, list)
+    assert len(databases) > 0
+
+
+def test_get_databases_exclude_system(connector: MySQLConnector):
+    """Test that system databases are excluded by default."""
+    databases = connector.get_databases(include_sys=False)
+    system_dbs = {"sys", "information_schema", "performance_schema", "mysql"}
+    for db in databases:
+        assert db not in system_dbs
+
+
+# ==================== Table Metadata Tests ====================
+
+
+def test_get_tables(connector: MySQLConnector, config: MySQLConfig):
+    """Test getting table list."""
+    tables = connector.get_tables(database_name=config.database)
+    assert isinstance(tables, list)
+
+
+def test_get_tables_with_ddl(connector: MySQLConnector, config: MySQLConfig):
+    """Test getting tables with DDL."""
+    # Create a test table first
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_table_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE IF NOT EXISTS {table_name} (
+            id INT PRIMARY KEY,
+            name VARCHAR(50)
+        )
+    """
+    )
+
+    try:
+        tables = connector.get_tables_with_ddl(database_name=config.database, tables=[table_name])
+
+        if len(tables) > 0:
+            table = tables[0]
+            assert "table_name" in table
+            assert "definition" in table
+            assert table["table_type"] == "table"
+            assert "database_name" in table
+            assert table["schema_name"] == ""
+            assert "identifier" in table
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+# ==================== View Tests ====================
+
+
+def test_get_views(connector: MySQLConnector, config: MySQLConfig):
+    """Test getting view list."""
+    views = connector.get_views(database_name=config.database)
+    assert isinstance(views, list)
+
+
+def test_get_views_with_ddl(connector: MySQLConnector, config: MySQLConfig):
+    """Test getting views with DDL."""
+    # Create a test view first
+    suffix = uuid.uuid4().hex[:8]
+    view_name = f"test_view_{suffix}"
+    table_name = f"test_table_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+
+    # Create base table
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE IF NOT EXISTS {table_name} (
+            id INT PRIMARY KEY,
+            name VARCHAR(50)
+        )
+    """
+    )
+
+    # Create view
+    connector.execute_ddl(f"CREATE VIEW {view_name} AS SELECT * FROM {table_name}")
+
+    try:
+        views = connector.get_views_with_ddl(database_name=config.database)
+
+        if len(views) > 0:
+            view = [v for v in views if v["table_name"] == view_name]
+            if view:
+                assert "definition" in view[0]
+                assert view[0]["table_type"] == "view"
+    finally:
+        connector.execute_ddl(f"DROP VIEW IF EXISTS {view_name}")
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+# ==================== Schema Tests ====================
+
+
+def test_get_schema(connector: MySQLConnector, config: MySQLConfig):
+    """Test getting table schema."""
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_schema_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE IF NOT EXISTS {table_name} (
+            id INT PRIMARY KEY AUTO_INCREMENT,
+            name VARCHAR(50) NOT NULL,
+            email VARCHAR(100),
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """
+    )
+
+    try:
+        schema = connector.get_schema(database_name=config.database, table_name=table_name)
+
+        assert len(schema) == 4
+
+        # Check id column
+        id_col = [col for col in schema if col["name"] == "id"][0]
+        assert id_col["pk"] is True
+        assert "int" in id_col["type"].lower()
+
+        # Check name column
+        name_col = [col for col in schema if col["name"] == "name"][0]
+        assert name_col["nullable"] is False
+        assert "varchar" in name_col["type"].lower()
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+# ==================== Sample Data Tests ====================
+
+
+def test_get_sample_rows(connector: MySQLConnector, config: MySQLConfig):
+    """Test getting sample rows."""
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_sample_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE IF NOT EXISTS {table_name} (
+            id INT PRIMARY KEY,
+            name VARCHAR(50)
+        )
+    """
+    )
+
+    # Insert test data
+    connector.execute_insert(
+        f"""
+        INSERT INTO {table_name} (id, name) VALUES
+        (1, 'Alice'),
+        (2, 'Bob'),
+        (3, 'Charlie')
+    """
+    )
+
+    try:
+        sample_rows = connector.get_sample_rows(database_name=config.database, tables=[table_name], top_n=2)
+
+        assert len(sample_rows) == 1
+        assert sample_rows[0]["table_name"] == table_name
+        assert "sample_rows" in sample_rows[0]
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+# ==================== SQL Execution Tests ====================
+
+
+def test_execute_select(connector: MySQLConnector):
+    """Test executing SELECT query."""
+    result = connector.execute({"sql_query": "SELECT 1 as num"}, result_format="list")
+    assert result.success
+    assert not result.error
+    assert result.sql_return == [{"num": 1}]
+
+
+def test_execute_ddl(connector: MySQLConnector, config: MySQLConfig):
+    """Test DDL operations."""
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_ddl_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+
+    try:
+        # CREATE
+        create_result = connector.execute_ddl(
+            f"""
+            CREATE TABLE {table_name} (
+                id INT PRIMARY KEY,
+                name VARCHAR(50)
+            )
+        """
+        )
+        assert create_result.success
+
+        # ALTER
+        alter_result = connector.execute_ddl(f"ALTER TABLE {table_name} ADD COLUMN age INT")
+        assert alter_result.success
+
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+def test_execute_insert(connector: MySQLConnector, config: MySQLConfig):
+    """Test INSERT operation."""
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_insert_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE {table_name} (
+            id INT PRIMARY KEY,
+            name VARCHAR(50)
+        )
+    """
+    )
+
+    try:
+        insert_result = connector.execute_insert(f"INSERT INTO {table_name} (id, name) VALUES (1, 'Alice'), (2, 'Bob')")
+        assert insert_result.success
+        assert insert_result.row_count == 2
+
+        # Verify
+        query_result = connector.execute(
+            {"sql_query": f"SELECT id, name FROM {table_name} ORDER BY id"}, result_format="list"
+        )
+        assert query_result.sql_return == [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+def test_execute_update(connector: MySQLConnector, config: MySQLConfig):
+    """Test UPDATE operation."""
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_update_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE {table_name} (
+            id INT PRIMARY KEY,
+            name VARCHAR(50)
+        )
+    """
+    )
+
+    try:
+        # Insert initial data
+        connector.execute_insert(f"INSERT INTO {table_name} (id, name) VALUES (1, 'Alice'), (2, 'Bob')")
+
+        # Update
+        update_result = connector.execute_update(f"UPDATE {table_name} SET name = 'Alice Updated' WHERE id = 1")
+        assert update_result.success
+        assert update_result.row_count == 1
+
+        # Verify
+        query_result = connector.execute(
+            {"sql_query": f"SELECT name FROM {table_name} WHERE id = 1"}, result_format="list"
+        )
+        assert query_result.sql_return == [{"name": "Alice Updated"}]
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+def test_execute_delete(connector: MySQLConnector, config: MySQLConfig):
+    """Test DELETE operation."""
+    suffix = uuid.uuid4().hex[:8]
+    table_name = f"test_delete_{suffix}"
+
+    connector.switch_context(database_name=config.database)
+    connector.execute_ddl(
+        f"""
+        CREATE TABLE {table_name} (
+            id INT PRIMARY KEY,
+            name VARCHAR(50)
+        )
+    """
+    )
+
+    try:
+        # Insert initial data
+        connector.execute_insert(f"INSERT INTO {table_name} (id, name) VALUES (1, 'Alice'), (2, 'Bob')")
+
+        # Delete
+        delete_result = connector.execute_delete(f"DELETE FROM {table_name} WHERE id = 2")
+        assert delete_result.success
+        assert delete_result.row_count == 1
+
+        # Verify
+        query_result = connector.execute({"sql_query": f"SELECT id FROM {table_name}"}, result_format="list")
+        assert query_result.sql_return == [{"id": 1}]
+    finally:
+        connector.execute_ddl(f"DROP TABLE IF EXISTS {table_name}")
+
+
+# ==================== Error Handling Tests ====================
+
+
+def test_exception_on_syntax_error(connector: MySQLConnector):
+    """Test exception on SQL syntax error."""
+    with pytest.raises(DatusException):
+        connector.execute({"sql_query": "INVALID SQL SYNTAX"})
+
+
+def test_exception_on_nonexistent_table(connector: MySQLConnector):
+    """Test exception on non-existent table."""
+    with pytest.raises(DatusException):
+        connector.execute({"sql_query": f"SELECT * FROM nonexistent_table_{uuid.uuid4().hex}"})
+
+
+# ==================== Utility Tests ====================
+
+
+def test_full_name_with_database(connector: MySQLConnector):
+    """Test full_name with database."""
+    full_name = connector.full_name(database_name="mydb", table_name="mytable")
+    assert full_name == "`mydb`.`mytable`"
+
+
+def test_full_name_without_database(connector: MySQLConnector):
+    """Test full_name without database."""
+    full_name = connector.full_name(table_name="mytable")
+    assert full_name == "`mytable`"
+
+
+def test_identifier(connector: MySQLConnector):
+    """Test identifier generation."""
+    identifier = connector.identifier(database_name="mydb", table_name="mytable")
+    assert identifier == "mydb.mytable"