datus-postgresql 0.1.4__tar.gz → 0.1.5__tar.gz

datus_postgresql-0.1.5/.gitignore

@@ -0,0 +1,143 @@
+# 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
+
+
+.omc
+
+uv.toml
+*/uv.toml

{datus_postgresql-0.1.4 → datus_postgresql-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datus-postgresql
-Version: 0.1.4
+Version: 0.1.5
 Summary: PostgreSQL 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
@@ -14,8 +14,8 @@ 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-db-core>=0.1.0
-Requires-Dist: datus-sqlalchemy>=0.1.2
+Requires-Dist: datus-db-core>=0.1.3
+Requires-Dist: datus-sqlalchemy>=0.1.6
 Requires-Dist: psycopg2-binary>=2.9.11
 Requires-Dist: pydantic>=2.0.0
 Description-Content-Type: text/markdown

{datus_postgresql-0.1.4 → datus_postgresql-0.1.5}/datus_postgresql/connector.py

@@ -2,10 +2,10 @@
 # Licensed under the Apache License, Version 2.0.
 # See http://www.apache.org/licenses/LICENSE-2.0 for details.
 
+from collections import OrderedDict
 from typing import Any, Dict, List, Optional, Set, Union, override
 from urllib.parse import quote_plus
 
-from pandas import DataFrame
 from pydantic import BaseModel, Field
 from sqlalchemy import create_engine, text
 
@@ -13,6 +13,7 @@ from datus_db_core import (
     TABLE_TYPE,
     DatusDbException,
     ErrorCode,
+    MigrationTargetMixin,
     get_logger,
     list_to_in_str,
 )
@@ -52,7 +53,7 @@ def _get_metadata_config(table_type: TABLE_TYPE) -> TableMetadataNames:
     return METADATA_DICT[table_type]
 
 
-class PostgreSQLConnector(SQLAlchemyConnector):
+class PostgreSQLConnector(SQLAlchemyConnector, MigrationTargetMixin):
     """PostgreSQL database connector."""
 
     def __init__(self, config: Union[PostgreSQLConfig, dict]):
@@ -68,7 +69,6 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         elif not isinstance(config, PostgreSQLConfig):
             raise TypeError(f"config must be PostgreSQLConfig or dict, got {type(config)}")
 
-        self.config = config
         self.host = config.host
         self.port = config.port
         self.username = config.username
@@ -90,8 +90,13 @@ class PostgreSQLConnector(SQLAlchemyConnector):
             dialect="postgresql",
             timeout_seconds=config.timeout_seconds,
         )
-        self.database_name = database
-        self.schema_name = config.schema_name or "public"
+        # Set after super().__init__() so BaseSqlConnector doesn't overwrite
+        # with a plain ConnectionConfig (which lacks sslmode, etc.)
+        self.config = config
+        self._default_database = database
+        self._default_schema = config.schema_name or "public"
+        self._engines: OrderedDict = OrderedDict()  # LRU cache: database_name -> engine
+        self._max_engines = 8
 
     # ==================== System Resources ====================
 
@@ -113,11 +118,7 @@ class PostgreSQLConnector(SQLAlchemyConnector):
 
     # ==================== Utility Methods ====================
 
-    @staticmethod
-    def _quote_identifier(identifier: str) -> str:
-        """Safely wrap identifiers with double quotes for PostgreSQL."""
-        escaped = identifier.replace('"', '""')
-        return f'"{escaped}"'
+    # quote_identifier: uses BaseSqlConnector default (ANSI double quotes)
 
     def _build_connection_string(self, database_name: str) -> str:
         """Build a PostgreSQL connection string for a given database."""
@@ -128,24 +129,6 @@ class PostgreSQLConnector(SQLAlchemyConnector):
             f"@{self.host}:{self.port}/{database_name}?sslmode={self.config.sslmode}"
         )
 
-    def _execute_on_database(self, sql: str, database_name: str) -> DataFrame:
-        """Execute a query on a specific database using a temporary connection.
-
-        Thread-safe: creates an isolated connection without mutating self.
-        """
-        if database_name == self.database_name:
-            return self._execute_pandas(sql)
-
-        conn_str = self._build_connection_string(database_name)
-        engine = create_engine(conn_str)
-        try:
-            with engine.connect() as conn:
-                result = conn.execute(text(sql))
-                rows = [row._asdict() for row in result.fetchall()]
-                return DataFrame(rows)
-        finally:
-            engine.dispose()
-
     # ==================== Metadata Retrieval ====================
 
     def _get_metadata(
@@ -177,8 +160,9 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         if table_type == "mv":
             # pg_matviews is scoped to the current database connection.
             # Use a temporary connection if a different database is requested (thread-safe).
+            safe_schema = schema_name.replace("'", "''") if schema_name else ""
             if schema_name:
-                where = f"schemaname = '{schema_name}'"
+                where = f"schemaname = '{safe_schema}'"
             else:
                 where = f"{list_to_in_str('schemaname not in', list(self._sys_schemas()))}"
 
@@ -187,11 +171,13 @@ class PostgreSQLConnector(SQLAlchemyConnector):
                 FROM pg_matviews
                 WHERE {where}
             """
-            query_result = self._execute_on_database(query, database_name)
+            query_result = self._execute_pandas(query, database_name=database_name)
         else:
             # Tables and views use information_schema (supports table_catalog filter)
+            safe_schema = schema_name.replace("'", "''") if schema_name else ""
+            safe_db = database_name.replace("'", "''") if database_name else ""
             if schema_name:
-                where = f"table_schema = '{schema_name}'"
+                where = f"table_schema = '{safe_schema}'"
             else:
                 where = f"{list_to_in_str('table_schema not in', list(self._sys_schemas()))}"
 
@@ -203,9 +189,9 @@ class PostgreSQLConnector(SQLAlchemyConnector):
             query = f"""
                 SELECT table_schema, table_name
                 FROM information_schema.{metadata_config.info_table}
-                WHERE table_catalog = '{database_name}' AND {where} {type_filter}
+                WHERE table_catalog = '{safe_db}' AND {where} {type_filter}
             """
-            query_result = self._execute_pandas(query)
+            query_result = self._execute_pandas(query, database_name=database_name)
 
         # Format results
         result = []
@@ -238,10 +224,13 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         """
         full_name = self.full_name(schema_name=schema_name, table_name=table_name)
 
+        safe_schema = schema_name.replace("'", "''") if schema_name else ""
+        safe_table = table_name.replace("'", "''") if table_name else ""
+
         if object_type == "VIEW":
             # Get view definition
             sql = f"""
-                SELECT pg_get_viewdef('{schema_name}.{table_name}'::regclass, true) as definition
+                SELECT pg_get_viewdef('{safe_schema}.{safe_table}'::regclass, true) as definition
             """
             result = self._execute_pandas(sql)
             if not result.empty and result["definition"][0]:
@@ -253,7 +242,7 @@ class PostgreSQLConnector(SQLAlchemyConnector):
             sql = f"""
                 SELECT definition
                 FROM pg_matviews
-                WHERE schemaname = '{schema_name}' AND matviewname = '{table_name}'
+                WHERE schemaname = '{safe_schema}' AND matviewname = '{safe_table}'
             """
             result = self._execute_pandas(sql)
             if not result.empty and result["definition"][0]:
@@ -269,7 +258,7 @@ class PostgreSQLConnector(SQLAlchemyConnector):
             col_defs = []
             pk_cols = []
             for col in columns:
-                col_def = f"    {self._quote_identifier(col['name'])} {col['type']}"
+                col_def = f"    {self.quote_identifier(col['name'])} {col['type']}"
                 if not col.get("nullable", True):
                     col_def += " NOT NULL"
                 if col.get("default_value"):
@@ -281,7 +270,7 @@ class PostgreSQLConnector(SQLAlchemyConnector):
             ddl = f"CREATE TABLE {full_name} (\n"
             ddl += ",\n".join(col_defs)
             if pk_cols:
-                pk_names = ", ".join(self._quote_identifier(c) for c in pk_cols)
+                pk_names = ", ".join(self.quote_identifier(c) for c in pk_cols)
                 ddl += f",\n    PRIMARY KEY ({pk_names})"
             ddl += "\n);"
             return ddl
@@ -397,6 +386,10 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         database_name = database_name or self.database_name
         schema_name = schema_name or self.schema_name
 
+        safe_db = database_name.replace("'", "''") if database_name else ""
+        safe_schema = schema_name.replace("'", "''") if schema_name else ""
+        safe_table = table_name.replace("'", "''") if table_name else ""
+
         # Use INFORMATION_SCHEMA to get schema with comments
         sql = f"""
             SELECT
@@ -414,16 +407,16 @@ class PostgreSQLConnector(SQLAlchemyConnector):
                     ON tc.constraint_name = kcu.constraint_name
                     AND tc.table_schema = kcu.table_schema
                 WHERE tc.constraint_type = 'PRIMARY KEY'
-                    AND tc.table_schema = '{schema_name}'
-                    AND tc.table_name = '{table_name}'
+                    AND tc.table_schema = '{safe_schema}'
+                    AND tc.table_name = '{safe_table}'
             ) pk ON c.column_name = pk.column_name
             LEFT JOIN pg_catalog.pg_statio_all_tables st
                 ON st.schemaname = c.table_schema AND st.relname = c.table_name
             LEFT JOIN pg_catalog.pg_description pgd
                 ON pgd.objoid = st.relid AND pgd.objsubid = c.ordinal_position
-            WHERE c.table_catalog = '{database_name}'
-              AND c.table_schema = '{schema_name}'
-              AND c.table_name = '{table_name}'
+            WHERE c.table_catalog = '{safe_db}'
+              AND c.table_schema = '{safe_schema}'
+              AND c.table_name = '{safe_table}'
             ORDER BY c.ordinal_position
         """
         query_result = self._execute_pandas(sql)
@@ -462,7 +455,8 @@ class PostgreSQLConnector(SQLAlchemyConnector):
     def get_schemas(self, catalog_name: str = "", database_name: str = "", include_sys: bool = False) -> List[str]:
         """Get list of schemas in the current database."""
         database_name = database_name or self.database_name
-        sql = f"SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '{database_name}'"
+        safe_db = database_name.replace("'", "''") if database_name else ""
+        sql = f"SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '{safe_db}'"
         result = self._execute_pandas(sql)
         schemas = result["schema_name"].tolist()
 
@@ -479,21 +473,88 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         """Get schema name for SQLAlchemy Inspector."""
         return schema_name or self.schema_name
 
+    def _get_engine(self, database_name: str = ""):
+        """Get or create engine for the given database. Thread-safe.
+
+        PostgreSQL requires different connection strings per database,
+        so each database gets its own engine with connection pool.
+        Uses LRU eviction (max 8 engines) to avoid holding too many connections.
+        """
+        db = database_name or self.database_name
+        with self._engine_lock:
+            if db in self._engines:
+                self._engines.move_to_end(db)
+                return self._engines[db]
+            conn_str = self._build_connection_string(db)
+            engine = create_engine(
+                conn_str,
+                pool_size=5,
+                max_overflow=10,
+                pool_timeout=self.timeout_seconds,
+                pool_recycle=3600,
+                pool_pre_ping=True,
+            )
+            self._engines[db] = engine
+            while len(self._engines) > self._max_engines:
+                _, evicted = self._engines.popitem(last=False)
+                try:
+                    evicted.dispose()
+                except Exception as e:
+                    logger.warning(f"Error disposing evicted engine: {e}")
+            return engine
+
+    @override
+    def _conn(self, catalog_name: str = "", database_name: str = "", schema_name: str = ""):
+        """Checkout connection from the correct per-database engine. Thread-safe.
+
+        Overrides base _conn() to avoid writing to shared self.engine.
+        Each thread gets a connection from the engine matching its database_name.
+        """
+        from contextlib import contextmanager
+
+        @contextmanager
+        def _pg_conn():
+            effective_database = database_name or self.database_name
+            effective_schema = schema_name or self.schema_name
+            effective_catalog = catalog_name or self.catalog_name
+            engine = self._get_engine(effective_database)
+            conn = engine.connect()
+            try:
+                self.do_switch_context(conn, effective_catalog, effective_database, effective_schema)
+                yield conn
+            except Exception:
+                try:
+                    conn.rollback()
+                except Exception:
+                    pass
+                raise
+            finally:
+                conn.close()
+
+        return _pg_conn()
+
+    @override
+    def close(self):
+        """Dispose all engines (per-database pool + parent engine)."""
+        for engine in self._engines.values():
+            try:
+                engine.dispose()
+            except Exception as e:
+                logger.warning(f"Error disposing engine: {e}")
+        self._engines.clear()
+        # Dispose parent engine that may have been created via connect()/_ensure_engine()
+        super().close()
+
     @override
-    def do_switch_context(self, catalog_name: str = "", database_name: str = "", schema_name: str = ""):
-        """Switch database/schema context.
+    def do_switch_context(self, conn, catalog_name: str = "", database_name: str = "", schema_name: str = ""):
+        """Apply schema context to a connection.
 
-        PostgreSQL requires reconnection to switch databases.
-        Schema switching only updates self.schema_name since all queries
-        use explicit schema qualification via full_name().
+        Database switching is handled by _conn() which picks the right engine
+        based on the effective database_name.
         """
-        if database_name and database_name != self.database_name:
-            self.connection_string = self._build_connection_string(database_name)
-            self.close()
-            self.connect()
-            self.database_name = database_name
         if schema_name:
-            self.schema_name = schema_name
+            conn.execute(text(f"SET search_path TO {self.quote_identifier(schema_name)}"))
+            conn.commit()
 
     # ==================== Sample Data ====================
 
@@ -591,10 +652,10 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         database_name = database_name or self.database_name
         schema_name = schema_name or self.schema_name
         if database_name and schema_name:
-            return f"{self._quote_identifier(database_name)}.{self._quote_identifier(schema_name)}.{self._quote_identifier(table_name)}"
+            return f"{self.quote_identifier(database_name)}.{self.quote_identifier(schema_name)}.{self.quote_identifier(table_name)}"
         if schema_name:
-            return f"{self._quote_identifier(schema_name)}.{self._quote_identifier(table_name)}"
-        return self._quote_identifier(table_name)
+            return f"{self.quote_identifier(schema_name)}.{self.quote_identifier(table_name)}"
+        return self.quote_identifier(table_name)
 
     @override
     def _reset_filter_tables(
@@ -607,3 +668,66 @@ class PostgreSQLConnector(SQLAlchemyConnector):
         """Reset filter tables with full names."""
         schema_name = schema_name or self.schema_name
         return super()._reset_filter_tables(tables, "", database_name, schema_name)
+
+    # ==================== MigrationTargetMixin ====================
+
+    def describe_migration_capabilities(self) -> Dict[str, Any]:
+        return {
+            "supported": True,
+            "dialect_family": "postgres-like",
+            "requires": [],  # OLTP — no distribution/partition required
+            "forbids": [
+                "DUPLICATE KEY (StarRocks-only)",
+                "DISTRIBUTED BY HASH ... BUCKETS (StarRocks-only)",
+                "ENGINE = (MySQL/ClickHouse syntax)",
+            ],
+            "type_hints": {
+                "HUGEINT": "NUMERIC(38,0) (Postgres has no HUGEINT/LARGEINT)",
+                "LARGEINT": "NUMERIC(38,0)",
+                "unbounded VARCHAR": "TEXT (prefer TEXT over unbounded VARCHAR)",
+                "TIMESTAMP WITH TIME ZONE": "TIMESTAMPTZ",
+                "JSON": "JSONB (prefer for indexing)",
+                "BOOLEAN": "BOOLEAN (no TINYINT cast needed)",
+            },
+            "example_ddl": (
+                "CREATE TABLE public.t (\n"
+                "  id BIGSERIAL PRIMARY KEY,\n"
+                "  name VARCHAR(255),\n"
+                "  created_at TIMESTAMPTZ DEFAULT now()\n"
+                ")"
+            ),
+        }
+
+    def suggest_table_layout(self, columns: List[Dict[str, Any]]) -> Dict[str, Any]:
+        # Postgres is OLTP — no distribution keys or bucketing required
+        return {}
+
+    def validate_ddl(self, ddl: str) -> List[str]:
+        errors: List[str] = []
+        upper = ddl.upper()
+
+        if "DUPLICATE KEY" in upper:
+            errors.append("DUPLICATE KEY is StarRocks-only syntax; Postgres does not support it")
+        if "BUCKETS" in upper and "DISTRIBUTED BY" in upper:
+            errors.append("DISTRIBUTED BY ... BUCKETS is StarRocks syntax; Postgres does not support it")
+        if "ENGINE =" in upper or "ENGINE=" in upper:
+            errors.append("ENGINE clause is MySQL/ClickHouse syntax; not supported in Postgres")
+        if "ORDER BY" in upper and "CREATE TABLE" in upper:
+            # Rough heuristic: top-level ORDER BY inside CREATE TABLE is ClickHouse's
+            # MergeTree syntax. Postgres allows ORDER BY inside CTAS SELECT, so this
+            # check is intentionally loose (only flags when accompanied by ENGINE).
+            if "ENGINE" in upper:
+                errors.append("ORDER BY inside CREATE TABLE is ClickHouse syntax; use CREATE INDEX in Postgres")
+
+        return errors
+
+    def map_source_type(self, source_dialect: str, source_type: str) -> Optional[str]:
+        import re as _re
+
+        base = _re.sub(r"\(.*\)", "", source_type.strip().upper()).strip()
+        overrides = {
+            "HUGEINT": "NUMERIC(38,0)",
+            "LARGEINT": "NUMERIC(38,0)",
+            "DATETIME": "TIMESTAMP",
+        }
+        return overrides.get(base)

{datus_postgresql-0.1.4 → datus_postgresql-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datus-postgresql"
-version = "0.1.4"
+version = "0.1.5"
 description = "PostgreSQL database adapter for Datus"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -18,8 +18,8 @@ classifiers = [
 ]
 
 dependencies = [
-    "datus-db-core>=0.1.0",
-    "datus-sqlalchemy>=0.1.2",
+    "datus-db-core>=0.1.3",
+    "datus-sqlalchemy>=0.1.6",
     "psycopg2-binary>=2.9.11",
     "pydantic>=2.0.0",
 ]

{datus_postgresql-0.1.4 → datus_postgresql-0.1.5}/tests/unit/test_connector_unit.py

@@ -2,7 +2,7 @@
 # Licensed under the Apache License, Version 2.0.
 # See http://www.apache.org/licenses/LICENSE-2.0 for details.
 
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -193,28 +193,28 @@ def test_sys_schemas():
 @pytest.mark.acceptance
 def test_quote_identifier_basic():
     """Test _quote_identifier with basic identifier."""
-    assert PostgreSQLConnector._quote_identifier("table_name") == '"table_name"'
+    assert PostgreSQLConnector.quote_identifier(MagicMock(), "table_name") == '"table_name"'
 
 
 @pytest.mark.acceptance
 def test_quote_identifier_with_double_quotes():
     """Test _quote_identifier escapes double quotes."""
-    assert PostgreSQLConnector._quote_identifier('table"name') == '"table""name"'
+    assert PostgreSQLConnector.quote_identifier(MagicMock(), 'table"name') == '"table""name"'
 
 
 def test_quote_identifier_with_multiple_double_quotes():
     """Test _quote_identifier escapes multiple double quotes."""
-    assert PostgreSQLConnector._quote_identifier('ta"ble"name') == '"ta""ble""name"'
+    assert PostgreSQLConnector.quote_identifier(MagicMock(), 'ta"ble"name') == '"ta""ble""name"'
 
 
 def test_quote_identifier_empty_string():
     """Test _quote_identifier with empty string."""
-    assert PostgreSQLConnector._quote_identifier("") == '""'
+    assert PostgreSQLConnector.quote_identifier(MagicMock(), "") == '""'
 
 
 def test_quote_identifier_special_characters():
     """Test _quote_identifier with special characters."""
-    assert PostgreSQLConnector._quote_identifier("table-name_123") == '"table-name_123"'
+    assert PostgreSQLConnector.quote_identifier(MagicMock(), "table-name_123") == '"table-name_123"'
 
 
 @pytest.mark.acceptance
@@ -396,3 +396,117 @@ def test_connector_schema_name_default():
         connector = PostgreSQLConnector(config)
 
         assert connector.schema_name == "public"
+
+
+# ==================== _get_engine LRU Cache Tests ====================
+
+
+def _make_connector():
+    """Helper: create a PostgreSQLConnector with mocked parent __init__."""
+    import threading
+
+    config = PostgreSQLConfig(username="user", password="pass", database="default_db")
+    with patch("datus_sqlalchemy.SQLAlchemyConnector.__init__", return_value=None):
+        connector = PostgreSQLConnector(config)
+    # Parent __init__ is mocked, so set attributes that _get_engine needs
+    connector._engine_lock = threading.Lock()
+    connector.engine = None
+    connector._owns_engine = False
+    connector.timeout_seconds = 30
+    return connector
+
+
+def test_get_engine_returns_same_engine_for_same_db():
+    """Requesting the same database twice returns the cached engine."""
+    connector = _make_connector()
+    with patch("datus_postgresql.connector.create_engine", return_value=MagicMock()) as mock_ce:
+        e1 = connector._get_engine("db1")
+        e2 = connector._get_engine("db1")
+
+    assert e1 is e2
+    mock_ce.assert_called_once()
+
+
+def test_get_engine_creates_different_engines_per_db():
+    """Different databases get different engines."""
+    connector = _make_connector()
+    engines = [MagicMock(), MagicMock()]
+    with patch("datus_postgresql.connector.create_engine", side_effect=engines):
+        e1 = connector._get_engine("db1")
+        e2 = connector._get_engine("db2")
+
+    assert e1 is not e2
+
+
+def test_get_engine_evicts_lru_when_over_max():
+    """When cache exceeds max_engines, the least-recently-used engine is disposed."""
+    connector = _make_connector()
+    connector._max_engines = 3
+
+    created_engines = []
+
+    def make_engine(*args, **kwargs):
+        e = MagicMock()
+        created_engines.append(e)
+        return e
+
+    with patch("datus_postgresql.connector.create_engine", side_effect=make_engine):
+        connector._get_engine("db1")
+        connector._get_engine("db2")
+        connector._get_engine("db3")
+        # All 3 fit within max_engines=3
+        assert len(connector._engines) == 3
+        created_engines[0].dispose.assert_not_called()
+
+        # Adding a 4th should evict db1 (LRU)
+        connector._get_engine("db4")
+        assert len(connector._engines) == 3
+        assert "db1" not in connector._engines
+        created_engines[0].dispose.assert_called_once()
+
+
+def test_get_engine_lru_access_refreshes_order():
+    """Accessing an existing engine moves it to most-recently-used, protecting it from eviction."""
+    connector = _make_connector()
+    connector._max_engines = 3
+
+    created_engines = {}
+
+    def make_engine(*args, **kwargs):
+        e = MagicMock()
+        created_engines[len(created_engines)] = e
+        return e
+
+    with patch("datus_postgresql.connector.create_engine", side_effect=make_engine):
+        connector._get_engine("db1")  # engines[0]
+        connector._get_engine("db2")  # engines[1]
+        connector._get_engine("db3")  # engines[2]
+
+        # Access db1 again — moves it to MRU
+        connector._get_engine("db1")
+
+        # Add db4 — should evict db2 (now LRU), NOT db1
+        connector._get_engine("db4")
+
+    assert "db1" in connector._engines
+    assert "db2" not in connector._engines
+    assert "db3" in connector._engines
+    assert "db4" in connector._engines
+    created_engines[1].dispose.assert_called_once()  # db2 evicted
+
+
+def test_close_disposes_all_cached_engines():
+    """close() disposes all cached engines and clears the cache."""
+    connector = _make_connector()
+
+    mock_engines = [MagicMock(), MagicMock()]
+    with patch("datus_postgresql.connector.create_engine", side_effect=mock_engines):
+        connector._get_engine("db1")
+        connector._get_engine("db2")
+
+    with patch("datus_sqlalchemy.SQLAlchemyConnector.close"):
+        connector.close()
+
+    for e in mock_engines:
+        e.dispose.assert_called_once()
+    assert len(connector._engines) == 0

datus_postgresql-0.1.5/tests/unit/test_migration_mixin.py

@@ -0,0 +1,89 @@
+# Copyright 2025-present DatusAI, Inc.
+# Licensed under the Apache License, Version 2.0.
+# See http://www.apache.org/licenses/LICENSE-2.0 for details.
+
+"""Tests for PostgreSQL MigrationTargetMixin implementation."""
+
+import pytest
+
+from datus_db_core import MigrationTargetMixin
+from datus_postgresql import PostgreSQLConnector
+
+
+@pytest.fixture
+def connector():
+    return PostgreSQLConnector.__new__(PostgreSQLConnector)
+
+
+class TestMixinInheritance:
+    def test_postgresql_is_migration_target(self, connector):
+        assert isinstance(connector, MigrationTargetMixin)
+
+
+class TestDescribeMigrationCapabilities:
+    def test_supported_true(self, connector):
+        result = connector.describe_migration_capabilities()
+        assert result["supported"] is True
+
+    def test_dialect_family_postgres_like(self, connector):
+        result = connector.describe_migration_capabilities()
+        assert result["dialect_family"] == "postgres-like"
+
+    def test_no_hard_requirements(self, connector):
+        """Postgres is OLTP — no distribution/partition required."""
+        result = connector.describe_migration_capabilities()
+        assert result["requires"] == []
+
+    def test_type_hints_mention_text_over_varchar(self, connector):
+        result = connector.describe_migration_capabilities()
+        hints_str = " ".join(result["type_hints"].values()).upper()
+        assert "TEXT" in hints_str
+
+    def test_example_ddl_is_simple(self, connector):
+        result = connector.describe_migration_capabilities()
+        ddl = result["example_ddl"].upper()
+        assert "CREATE TABLE" in ddl
+        # Should NOT contain DUPLICATE KEY or BUCKETS
+        assert "DUPLICATE KEY" not in ddl
+        assert "BUCKETS" not in ddl
+
+
+class TestValidateDdl:
+    def test_accepts_standard_postgres_ddl(self, connector):
+        ddl = "CREATE TABLE public.t (id BIGSERIAL PRIMARY KEY, name VARCHAR(255))"
+        assert connector.validate_ddl(ddl) == []
+
+    def test_rejects_duplicate_key_starrocks_syntax(self, connector):
+        ddl = """CREATE TABLE public.t (id BIGINT)
+        DUPLICATE KEY(id)
+        DISTRIBUTED BY HASH(id) BUCKETS 10"""
+        errors = connector.validate_ddl(ddl)
+        assert any("DUPLICATE KEY" in e.upper() or "STARROCKS" in e.upper() for e in errors)
+
+    def test_rejects_distributed_by_hash_buckets(self, connector):
+        ddl = "CREATE TABLE public.t (id BIGINT) DISTRIBUTED BY HASH(id) BUCKETS 10"
+        errors = connector.validate_ddl(ddl)
+        assert any("BUCKETS" in e.upper() or "STARROCKS" in e.upper() for e in errors)
+
+
+class TestSuggestTableLayout:
+    def test_returns_empty_dict(self, connector):
+        """Postgres doesn't need distribution keys — OLTP."""
+        columns = [
+            {"name": "id", "type": "BIGINT", "nullable": False},
+            {"name": "name", "type": "VARCHAR", "nullable": True},
+        ]
+        layout = connector.suggest_table_layout(columns)
+        assert layout == {}
+
+
+class TestMapSourceType:
+    def test_hugeint_to_numeric(self, connector):
+        assert connector.map_source_type("duckdb", "HUGEINT") == "NUMERIC(38,0)"
+
+    def test_largeint_to_numeric(self, connector):
+        """StarRocks LARGEINT has no direct Postgres equivalent."""
+        assert connector.map_source_type("starrocks", "LARGEINT") == "NUMERIC(38,0)"
+
+    def test_unknown_returns_none(self, connector):
+        assert connector.map_source_type("duckdb", "VARCHAR") is None