matrixone-python-sdk 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

matrixone/async_client.py

@@ -34,9 +34,10 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .account import Account, User
+from .async_metadata_manager import AsyncMetadataManager
 from .async_vector_index_manager import AsyncVectorManager
 from .base_client import BaseMatrixOneClient, BaseMatrixOneExecutor
-from .connection_hooks import ConnectionHook, ConnectionAction, create_connection_hook
+from .connection_hooks import ConnectionAction, ConnectionHook, create_connection_hook
 from .exceptions import (
     AccountError,
     ConnectionError,
@@ -48,7 +49,6 @@ from .exceptions import (
     SnapshotError,
 )
 from .logger import MatrixOneLogger, create_default_logger
-from .async_metadata_manager import AsyncMetadataManager
 from .pitr import Pitr
 from .pubsub import Publication, Subscription
 from .snapshot import Snapshot, SnapshotLevel
@@ -1837,7 +1837,6 @@ class AsyncClient(BaseMatrixOneClient):
         """Cleanup when object is garbage collected"""
         # Don't try to cleanup in __del__ as it can cause issues with event loops
         # The fixture should handle proper cleanup
-        pass
 
     def get_sqlalchemy_engine(self) -> AsyncEngine:
         """
@@ -1920,6 +1919,7 @@ class AsyncClient(BaseMatrixOneClient):
             and other SDK components. External users should use execute() instead.
         """
         import time
+
         from sqlalchemy import text
 
         start_time = time.time()
@@ -2554,6 +2554,103 @@ class AsyncClient(BaseMatrixOneClient):
         except Exception as e:
             raise QueryError(f"Failed to get git version: {e}")
 
+    async def get_secondary_index_tables(self, table_name: str) -> List[str]:
+        """
+        Get all secondary index table names for a given table in the current database (async version).
+
+        Args:
+            table_name: Name of the table to get secondary indexes for
+
+        Returns:
+            List of secondary index table names
+
+        Examples::
+
+            >>> async with AsyncClient() as client:
+            ...     await client.connect(host='localhost', port=6001, user='root', password='111', database='test')
+            ...     index_tables = await client.get_secondary_index_tables('cms_all_content_chunk_info')
+            ...     print(index_tables)
+        """
+        from .index_utils import build_get_index_tables_sql
+
+        # Get current database from connection params
+        database = self._connection_params.get('database') if hasattr(self, '_connection_params') else None
+
+        sql, params = build_get_index_tables_sql(table_name, database)
+        result = await self.execute(sql, params)
+        return [row[0] for row in result.fetchall()]
+
+    async def get_secondary_index_table_by_name(self, table_name: str, index_name: str) -> Optional[str]:
+        """
+        Get the physical table name of a secondary index by its index name in the current database (async version).
+
+        Args:
+            table_name: Name of the table
+            index_name: Name of the secondary index
+
+        Returns:
+            Physical table name of the secondary index, or None if not found
+
+        Examples::
+
+            >>> async with AsyncClient() as client:
+            ...     await client.connect(host='localhost', port=6001, user='root', password='111', database='test')
+            ...     index_table = await client.get_secondary_index_table_by_name('cms_all_content_chunk_info', 'cms_id')
+            ...     print(index_table)
+        """
+        from .index_utils import build_get_index_table_by_name_sql
+
+        # Get current database from connection params
+        database = self._connection_params.get('database') if hasattr(self, '_connection_params') else None
+
+        sql, params = build_get_index_table_by_name_sql(table_name, index_name, database)
+        result = await self.execute(sql, params)
+        row = result.fetchone()
+        return row[0] if row else None
+
+    async def verify_table_index_counts(self, table_name: str) -> int:
+        """
+        Verify that the main table and all its secondary index tables have the same row count (async version).
+
+        This method compares the COUNT(*) of the main table with all its secondary index tables
+        in a single SQL query for consistency. If counts don't match, raises an exception.
+
+        Args:
+            table_name: Name of the table to verify
+
+        Returns:
+            Row count (int) if verification succeeds
+
+        Raises:
+            ValueError: If any secondary index table has a different count than the main table,
+                       with details about all counts in the error message
+
+        Examples::
+
+            >>> async with AsyncClient() as client:
+            ...     await client.connect(host='localhost', port=6001, user='root', password='111', database='test')
+            ...     count = await client.verify_table_index_counts('cms_all_content_chunk_info')
+            ...     print(f"✓ Verification passed, row count: {count}")
+
+            >>> # If verification fails:
+            >>> try:
+            ...     count = await client.verify_table_index_counts('some_table')
+            ... except ValueError as e:
+            ...     print(f"Verification failed: {e}")
+        """
+        from .index_utils import build_verify_counts_sql, process_verify_result
+
+        # Get all secondary index tables
+        index_tables = await self.get_secondary_index_tables(table_name)
+
+        # Build and execute verification SQL
+        sql = build_verify_counts_sql(table_name, index_tables)
+        result = await self.execute(sql)
+        row = result.fetchone()
+
+        # Process result and raise exception if verification fails
+        return process_verify_result(table_name, index_tables, row)
+
     async def __aenter__(self):
         return self
 

matrixone/async_metadata_manager.py

@@ -19,8 +19,10 @@ This module provides async metadata scanning capabilities for MatrixOne tables,
 allowing users to analyze table statistics, column information, and data distribution.
 """
 
-from typing import Optional, List, Dict, Any, Union
+from typing import Any, Dict, List, Optional, Union
+
 from sqlalchemy.engine import Result
+
 from .metadata import BaseMetadataManager, MetadataColumn, MetadataRow
 
 

matrixone/client.py

@@ -30,7 +30,7 @@ from sqlalchemy.engine import Engine
 
 from .account import AccountManager, TransactionAccountManager
 from .base_client import BaseMatrixOneClient, BaseMatrixOneExecutor
-from .connection_hooks import ConnectionHook, ConnectionAction, create_connection_hook
+from .connection_hooks import ConnectionAction, ConnectionHook, create_connection_hook
 from .exceptions import ConnectionError, QueryError
 from .logger import MatrixOneLogger, create_default_logger
 from .metadata import MetadataManager, TransactionMetadataManager
@@ -1698,8 +1698,9 @@ class Client(BaseMatrixOneClient):
             table_name = model_class.__tablename__
             table = model_class.__table__
 
+            from sqlalchemy.schema import CreateIndex, CreateTable
+
             from .sqlalchemy_ext import FulltextIndex, VectorIndex
-            from sqlalchemy.schema import CreateTable, CreateIndex
 
             try:
                 engine_context = self.get_sqlalchemy_engine().begin()
@@ -2612,6 +2613,105 @@ class Client(BaseMatrixOneClient):
 
         return self
 
+    def get_secondary_index_tables(self, table_name: str) -> List[str]:
+        """
+        Get all secondary index table names for a given table in the current database.
+
+        Args:
+            table_name: Name of the table to get secondary indexes for
+
+        Returns:
+            List of secondary index table names
+
+        Examples::
+
+            >>> client = Client()
+            >>> client.connect(host='localhost', port=6001, user='root', password='111', database='test')
+            >>> index_tables = client.get_secondary_index_tables('cms_all_content_chunk_info')
+            >>> print(index_tables)
+            ['__mo_index_secondary_..._cms_id', '__mo_index_secondary_..._idx_all_content_length']
+        """
+        from .index_utils import build_get_index_tables_sql
+
+        # Get current database from connection params
+        database = self._connection_params.get('database') if hasattr(self, '_connection_params') else None
+
+        sql, params = build_get_index_tables_sql(table_name, database)
+        result = self.execute(sql, params)
+        return [row[0] for row in result.fetchall()]
+
+    def get_secondary_index_table_by_name(self, table_name: str, index_name: str) -> Optional[str]:
+        """
+        Get the physical table name of a secondary index by its index name in the current database.
+
+        Args:
+            table_name: Name of the table
+            index_name: Name of the secondary index
+
+        Returns:
+            Physical table name of the secondary index, or None if not found
+
+        Examples::
+
+            >>> client = Client()
+            >>> client.connect(host='localhost', port=6001, user='root', password='111', database='test')
+            >>> index_table = client.get_secondary_index_table_by_name('cms_all_content_chunk_info', 'cms_id')
+            >>> print(index_table)
+            '__mo_index_secondary_018cfbda-bde1-7c3e-805c-3f8e71769f75_cms_id'
+        """
+        from .index_utils import build_get_index_table_by_name_sql
+
+        # Get current database from connection params
+        database = self._connection_params.get('database') if hasattr(self, '_connection_params') else None
+
+        sql, params = build_get_index_table_by_name_sql(table_name, index_name, database)
+        result = self.execute(sql, params)
+        row = result.fetchone()
+        return row[0] if row else None
+
+    def verify_table_index_counts(self, table_name: str) -> int:
+        """
+        Verify that the main table and all its secondary index tables have the same row count.
+
+        This method compares the COUNT(*) of the main table with all its secondary index tables
+        in a single SQL query for consistency. If counts don't match, raises an exception.
+
+        Args:
+            table_name: Name of the table to verify
+
+        Returns:
+            Row count (int) if verification succeeds
+
+        Raises:
+            ValueError: If any secondary index table has a different count than the main table,
+                       with details about all counts in the error message
+
+        Examples::
+
+            >>> client = Client()
+            >>> client.connect(host='localhost', port=6001, user='root', password='111', database='test')
+            >>> count = client.verify_table_index_counts('cms_all_content_chunk_info')
+            >>> print(f"✓ Verification passed, row count: {count}")
+
+            >>> # If verification fails:
+            >>> try:
+            ...     count = client.verify_table_index_counts('some_table')
+            ... except ValueError as e:
+            ...     print(f"Verification failed: {e}")
+        """
+        from .index_utils import build_verify_counts_sql, process_verify_result
+
+        # Get all secondary index tables
+        index_tables = self.get_secondary_index_tables(table_name)
+
+        # Build and execute verification SQL
+        sql = build_verify_counts_sql(table_name, index_tables)
+        result = self.execute(sql)
+        row = result.fetchone()
+
+        # Process result and raise exception if verification fails
+        return process_verify_result(table_name, index_tables, row)
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.disconnect()
 

matrixone/connection_hooks.py

@@ -18,6 +18,7 @@ Connection hooks for MatrixOne clients
 
 from enum import Enum
 from typing import Callable, List, Optional, Union
+
 from sqlalchemy import event
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
@@ -68,13 +69,13 @@ class ConnectionHook:
             event.listen(engine.sync_engine, "connect", self._on_connect_sync)
             event.listen(engine.sync_engine, "before_cursor_execute", self._on_before_cursor_execute)
             if hasattr(self._client_ref, 'logger'):
-                self._client_ref.logger.info("Attached connection hook to async engine")
+                self._client_ref.logger.debug("Attached connection hook to async engine")
         else:
             # For sync engines, listen to both connect and before_cursor_execute events
             event.listen(engine, "connect", self._on_connect_sync)
             event.listen(engine, "before_cursor_execute", self._on_before_cursor_execute)
             if hasattr(self._client_ref, 'logger'):
-                self._client_ref.logger.info("Attached connection hook to sync engine")
+                self._client_ref.logger.debug("Attached connection hook to sync engine")
 
     def _on_connect_sync(self, dbapi_connection, connection_record):
         """SQLAlchemy event handler for new connections (sync)"""
@@ -85,7 +86,7 @@ class ConnectionHook:
                 try:
                     # Log that the hook is being executed
                     if hasattr(self._client_ref, 'logger'):
-                        self._client_ref.logger.info(f"Executing connection hook on new connection {conn_id}")
+                        self._client_ref.logger.debug(f"Executing connection hook on new connection {conn_id}")
                     # Pass the connection to avoid creating new connections
                     self.execute_sync_with_connection(self._client_ref, dbapi_connection)
                     self._executed_connections.add(conn_id)
@@ -103,7 +104,7 @@ class ConnectionHook:
                 try:
                     # Log that the hook is being executed
                     if hasattr(self._client_ref, 'logger'):
-                        self._client_ref.logger.info(f"Executing connection hook on connection {conn_id}")
+                        self._client_ref.logger.debug(f"Executing connection hook on connection {conn_id}")
                     # Use the connection to avoid creating new connections
                     self.execute_sync_with_connection(self._client_ref, conn.connection)
                     self._executed_connections.add(conn_id)
@@ -211,7 +212,7 @@ class ConnectionHook:
             cursor = dbapi_connection.cursor()
             cursor.execute("SET experimental_ivf_index = 1")
             cursor.close()
-            client.logger.info("✓ Enabled IVF vector operations")
+            client.logger.debug("✓ Enabled IVF vector operations")
         except Exception as e:
             client.logger.warning(f"Failed to enable IVF: {e}")
 
@@ -222,7 +223,7 @@ class ConnectionHook:
             cursor = dbapi_connection.cursor()
             cursor.execute("SET experimental_hnsw_index = 1")
             cursor.close()
-            client.logger.info("✓ Enabled HNSW vector operations")
+            client.logger.debug("✓ Enabled HNSW vector operations")
         except Exception as e:
             client.logger.warning(f"Failed to enable HNSW: {e}")
 
@@ -233,7 +234,7 @@ class ConnectionHook:
             cursor = dbapi_connection.cursor()
             cursor.execute("SET experimental_fulltext_index = 1")
             cursor.close()
-            client.logger.info("✓ Enabled fulltext search operations")
+            client.logger.debug("✓ Enabled fulltext search operations")
         except Exception as e:
             client.logger.warning(f"Failed to enable fulltext: {e}")
 

matrixone/exceptions.py

@@ -20,70 +20,46 @@ MatrixOne SDK Exceptions
 class MatrixOneError(Exception):
     """Base exception for all MatrixOne SDK errors"""
 
-    pass
-
 
 class ConnectionError(MatrixOneError):
     """Raised when connection to MatrixOne fails"""
 
-    pass
-
 
 class QueryError(MatrixOneError):
     """Raised when SQL query execution fails"""
 
-    pass
-
 
 class ConfigurationError(MatrixOneError):
     """Raised when configuration is invalid"""
 
-    pass
-
 
 class SnapshotError(MatrixOneError):
     """Raised when snapshot operations fail"""
 
-    pass
-
 
 class CloneError(MatrixOneError):
     """Raised when clone operations fail"""
 
-    pass
-
 
 class MoCtlError(MatrixOneError):
     """Raised when mo_ctl operations fail"""
 
-    pass
-
 
 class RestoreError(MatrixOneError):
     """Raised when restore operations fail"""
 
-    pass
-
 
 class PitrError(MatrixOneError):
     """Raised when PITR operations fail"""
 
-    pass
-
 
 class PubSubError(MatrixOneError):
     """Raised when publish-subscribe operations fail"""
 
-    pass
-
 
 class AccountError(MatrixOneError):
     """Raised when account management operations fail"""
 
-    pass
-
 
 class VersionError(MatrixOneError):
     """Raised when version compatibility check fails"""
-
-    pass

matrixone/index_utils.py

@@ -0,0 +1,143 @@
+# Copyright 2021 - 2022 Matrix Origin
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Index utilities - Shared logic for secondary index operations
+"""
+
+from typing import List, Tuple
+
+
+def build_get_index_tables_sql(table_name: str, database: str = None) -> Tuple[str, Tuple]:
+    """
+    Build SQL to get all secondary index table names for a given table.
+
+    Args:
+        table_name: Name of the table
+        database: Name of the database (optional, but recommended to avoid cross-database conflicts)
+
+    Returns:
+        Tuple of (sql, params)
+    """
+    if database:
+        sql = """
+            SELECT DISTINCT index_table_name
+            FROM mo_catalog.mo_indexes
+            JOIN mo_catalog.mo_tables ON mo_indexes.table_id = mo_tables.rel_id
+            WHERE relname = ? AND reldatabase = ? AND type = 'MULTIPLE'
+        """
+        return sql, (table_name, database)
+    else:
+        # Fallback to old behavior if database is not provided
+        sql = """
+            SELECT DISTINCT index_table_name
+            FROM mo_catalog.mo_indexes
+            JOIN mo_catalog.mo_tables ON mo_indexes.table_id = mo_tables.rel_id
+            WHERE relname = ? AND type = 'MULTIPLE'
+        """
+        return sql, (table_name,)
+
+
+def build_get_index_table_by_name_sql(table_name: str, index_name: str, database: str = None) -> Tuple[str, Tuple]:
+    """
+    Build SQL to get the physical table name of a secondary index by its index name.
+
+    Args:
+        table_name: Name of the table
+        index_name: Name of the secondary index
+        database: Name of the database (optional, but recommended to avoid cross-database conflicts)
+
+    Returns:
+        Tuple of (sql, params)
+    """
+    if database:
+        sql = """
+            SELECT DISTINCT index_table_name
+            FROM mo_catalog.mo_indexes
+            JOIN mo_catalog.mo_tables ON mo_indexes.table_id = mo_tables.rel_id
+            WHERE relname = ? AND name = ? AND reldatabase = ?
+        """
+        return sql, (table_name, index_name, database)
+    else:
+        # Fallback to old behavior if database is not provided
+        sql = """
+            SELECT DISTINCT index_table_name
+            FROM mo_catalog.mo_indexes
+            JOIN mo_catalog.mo_tables ON mo_indexes.table_id = mo_tables.rel_id
+            WHERE relname = ? AND name = ?
+        """
+        return sql, (table_name, index_name)
+
+
+def build_verify_counts_sql(table_name: str, index_tables: List[str]) -> str:
+    """
+    Build SQL to verify counts of main table and all index tables in a single query.
+
+    Args:
+        table_name: Name of the main table
+        index_tables: List of index table names
+
+    Returns:
+        SQL string
+    """
+    if not index_tables:
+        return f"SELECT COUNT(*) FROM `{table_name}`"
+
+    select_parts = [f"(SELECT COUNT(*) FROM `{table_name}`) as main_count"]
+    for idx, index_table in enumerate(index_tables):
+        select_parts.append(f"(SELECT COUNT(*) FROM `{index_table}`) as idx{idx}_count")
+
+    return "SELECT " + ", ".join(select_parts)
+
+
+def process_verify_result(table_name: str, index_tables: List[str], row: Tuple) -> int:
+    """
+    Process the verification result and raise exception if counts don't match.
+
+    Args:
+        table_name: Name of the main table
+        index_tables: List of index table names
+        row: Result row from the verification SQL
+
+    Returns:
+        Row count if verification succeeds
+
+    Raises:
+        ValueError: If any index table has a different count
+    """
+    main_count = row[0]
+
+    if not index_tables:
+        return main_count
+
+    index_counts = {}
+    mismatch = []
+
+    for idx, index_table in enumerate(index_tables):
+        index_count = row[idx + 1]
+        index_counts[index_table] = index_count
+        if index_count != main_count:
+            mismatch.append(index_table)
+
+    # If there's a mismatch, raise an exception with details
+    if mismatch:
+        error_details = [f"Main table '{table_name}': {main_count} rows"]
+        for index_table, count in index_counts.items():
+            status = "✗ MISMATCH" if index_table in mismatch else "✓"
+            error_details.append(f"{status} Index '{index_table}': {count} rows")
+
+        error_msg = "Index count verification failed!\n" + "\n".join(error_details)
+        raise ValueError(error_msg)
+
+    return main_count

matrixone/metadata.py

@@ -19,10 +19,11 @@ This module provides metadata scanning capabilities for MatrixOne tables,
 allowing users to analyze table statistics, column information, and data distribution.
 """
 
-from typing import Optional, List, Dict, Any, Union
-from sqlalchemy.engine import Result
 from dataclasses import dataclass
 from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from sqlalchemy.engine import Result
 
 
 class MetadataColumn(Enum):

matrixone/moctl.py

@@ -40,8 +40,6 @@ from .exceptions import MatrixOneError
 class MoCtlError(MatrixOneError):
     """Raised when mo_ctl operations fail"""
 
-    pass
-
 
 class MoCtlManager:
     """

matrixone/sqlalchemy_ext/__init__.py

@@ -147,6 +147,7 @@ __all__ = [
     "FulltextIndex",
     "FulltextAlgorithmType",
     "FulltextModeType",
+    "FulltextParserType",
     "FulltextSearchBuilder",
     "create_fulltext_index",
     "fulltext_search_builder",

matrixone/version.py

@@ -519,8 +519,6 @@ def requires_version(
 class VersionError(MatrixOneError):
     """Raised when version compatibility check fails"""
 
-    pass
-
 
 # Initialize common feature requirements
 def _initialize_default_features():

{matrixone_python_sdk-0.1.2.dist-info → matrixone_python_sdk-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrixone-python-sdk
-Version: 0.1.2
+Version: 0.1.4
 Summary: A comprehensive Python SDK for MatrixOne database operations with vector search, fulltext search, and advanced features
 Home-page: https://github.com/matrixorigin/matrixone
 Author: MatrixOne Team

{matrixone_python_sdk-0.1.2.dist-info → matrixone_python_sdk-0.1.4.dist-info}/RECORD

@@ -1,17 +1,18 @@
 matrixone/__init__.py,sha256=7bePzwzerZTiZIlbUT9zI_u4fp49DvQNcIqyiIvEVVs,3966
 matrixone/account.py,sha256=0r9xLNTiUfXa3xWZQUhEJ_uUcNp_gja-YulOR5iYDU4,24712
-matrixone/async_client.py,sha256=krF9xtn_aGS45VcShV5eYy89FHk0mCI9Ig-8RufBJmY,151518
-matrixone/async_metadata_manager.py,sha256=7k5qtQbKO-52IXzhDN0qhvYdp5wars5M6ZjdSLfD8RM,10230
+matrixone/async_client.py,sha256=yluma410CLUy3FhxMxeOm-5uhRwhD-ONzMIJd-dEuvg,155669
+matrixone/async_metadata_manager.py,sha256=W3TJBCy56diDPBzimpBImFrmf9DBc7iiS5CdBHLAh_Q,10232
 matrixone/async_orm.py,sha256=O4Rf85MnZg0_fuLvbHGfOPrHI2OLznYwLk9eam5J5ik,4864
 matrixone/async_vector_index_manager.py,sha256=fVnS00zgbUXw4YmZR-wRCzm541n30TLlmXXmXV34ELU,23134
 matrixone/base_client.py,sha256=PUhq0c7Si9OIk83B4ZZ73ozwaHDRZ1zi0Q94YixseqY,6952
-matrixone/client.py,sha256=XWEXEq8FlMfAJ4O4qbnriy2S7qmYGmpLeWe37HHrzg0,183615
+matrixone/client.py,sha256=NONid82vkq2GYWVfJqjHgFjeTBkXauEEvcoYtSoeuYs,187735
 matrixone/config.py,sha256=jrm1rLBhLWrX3dVdPx67sFaZ_9M8Vj4hImVrAmFaYbw,13917
-matrixone/connection_hooks.py,sha256=kjv0HMCUZkma-9nTndNBV66NVcp4cTWs-8u5b6KCj2E,13530
-matrixone/exceptions.py,sha256=oUQUY_TD8UTSzZzbwGdUgQ0kFJIYZq5Fx-vFsMaOfvw,1787
+matrixone/connection_hooks.py,sha256=5o7heheRQ8pLguoUQxEoo023519rT2-OhloPW-vORpE,13538
+matrixone/exceptions.py,sha256=VsGgESLl4vm5-9QbigyE5RTwFujyoYXhQuGhGKoujFw,1667
+matrixone/index_utils.py,sha256=ofEm0PHKE4VIGuq4ymeJPtA5NvV1afwZfHPLN2bd6Dw,4862
 matrixone/logger.py,sha256=aZmetje_AqtyxFxsqZvp-3R68n8I_ldplRGfV2MHg48,26105
-matrixone/metadata.py,sha256=wHQNrW4bRYOriujZv-ym9F68XEwJJt8N23xcyNQ9wKY,31706
-matrixone/moctl.py,sha256=rLt69ZlhIr_pCbyu8cImKgdR_YOGf85XvqCHcW12sc0,6714
+matrixone/metadata.py,sha256=Yf0eJywe3BUqg6aEywSWh9neRcVsrgf6g-uaZFvqLOA,31707
+matrixone/moctl.py,sha256=b_qQPSK52JiyyUH4PYzAuhJPk8dAD6LRfT_sFGsf23o,6704
 matrixone/orm.py,sha256=QWNdfJ067KcgWU-eB__vXwJuANBaDUeVVG7thFH5kiU,90473
 matrixone/pitr.py,sha256=NPsexPsJXIAiJTH3oMyFOwiXWjvfohPzWQyFHhQKh5k,21632
 matrixone/pubsub.py,sha256=ckaG6Z3IuEtcdwp11qvB88PrCDHYymocSOJ1v4TftzY,26893
@@ -19,8 +20,8 @@ matrixone/restore.py,sha256=xAbsRUL-2hCk6YpuouVLbiwc3GwUNzCoIVEFtcmghkg,15791
 matrixone/search_vector_index.py,sha256=NjQpluaPcja66herm-OYq3nNeNAqY_-FGGL4SOBOWNA,46075
 matrixone/snapshot.py,sha256=cOatk26Z6Jt6aAdasOMejxxiv73S7Z2o2if_va20Ihg,18103
 matrixone/sql_builder.py,sha256=ZR9TpRkV4cN_RiDJQXMLwSzodpESyxAqV-TTIr--ZbY,29009
-matrixone/version.py,sha256=jsHOK9_liBu4zT4r2PWUu4RqIEcYmCGERdMdVJZhJ14,19923
-matrixone/sqlalchemy_ext/__init__.py,sha256=L9f3mizOwnUSBRlaondoePqvnLo9o_CKe42pdkEf0Sk,4003
+matrixone/version.py,sha256=7wpMFVqDjGE16bFtnvFwbcnAI3mzz2zMZPpc9v7G9-c,19913
+matrixone/sqlalchemy_ext/__init__.py,sha256=YrcXthWkpN-mkRq6293t6Su5D39MdsEKYu_g1lz4qgI,4029
 matrixone/sqlalchemy_ext/adapters.py,sha256=-PoQtxN8uveto4Me2BTyTq1FoeSj8qo3TkUKAhoUd4w,5286
 matrixone/sqlalchemy_ext/dialect.py,sha256=wrAQDjDDpCz6HT2Atrz7QXAzbyxaNTbRXcauh2REa1A,21100
 matrixone/sqlalchemy_ext/fulltext_index.py,sha256=OceS34yg1kG-1uopG1lDf7GbVyRiUnxzKHDUHYLNLuA,27614
@@ -30,7 +31,7 @@ matrixone/sqlalchemy_ext/ivf_config.py,sha256=-esAijWMfyF1GUJivpZh-F4lvyKRmY8LYI
 matrixone/sqlalchemy_ext/table_builder.py,sha256=JVritBPnCXZt0eJUivDrmGdlpaYO-uL7i2n24HiarEE,12870
 matrixone/sqlalchemy_ext/vector_index.py,sha256=dasW3kT4f69io9y6DLQMarvf1FTbzh0UN-HALs0kBVs,55907
 matrixone/sqlalchemy_ext/vector_type.py,sha256=HaOJ9dRdW_yrecD9qGUucW9bMfM3zCxbDC-0Ca32Kmk,30669
-matrixone_python_sdk-0.1.2.dist-info/licenses/LICENSE,sha256=-PpUMwDyMyFlH9H7cnzkTh0Uo42tRvz43k7hnxe7G_I,11252
+matrixone_python_sdk-0.1.4.dist-info/licenses/LICENSE,sha256=-PpUMwDyMyFlH9H7cnzkTh0Uo42tRvz43k7hnxe7G_I,11252
 tests/__init__.py,sha256=odB22tIaJIHSwRhumhDlQYD6Fug_C0opWa07dSKkeQs,694
 tests/offline/__init__.py,sha256=M13mz7gtVDS0_dJUW1EFyyiAGhEj282k3ia7eWA3dPs,703
 tests/offline/conftest.py,sha256=Mz_NT6GBOxqSZsSCR2SXe1pkSpLGKT2-ssWNHhh9xOg,2494
@@ -38,7 +39,7 @@ tests/offline/test_account.py,sha256=uCHKPOBGiJrpEwXdyF2CoNoS5yqxuyKJgLTPMvKZQbk
 tests/offline/test_async_client_query_comprehensive.py,sha256=HmLg8iYlD6l5K4lJN5VSXhJDtKGg17vym-9KaX6WDzY,45416
 tests/offline/test_basic.py,sha256=pVyPnidD5jIoC8_40U1iXND29399G-0O5e4itm-2uhc,1710
 tests/offline/test_case_sensitivity.py,sha256=aYlhA5F8RSlSy6wl3HWIrPylE3Z3eAUf4RWQohwD0eA,8715
-tests/offline/test_connection_hooks_offline.py,sha256=pMbkjiEdn5ShljuX8QZRVnsMQLbJxI43tfb0saohBRw,11678
+tests/offline/test_connection_hooks_offline.py,sha256=mqnummeGGEvqeevG2R7-0VexnBquo4CJyTtmLhMa7Ps,11686
 tests/offline/test_dialect_schema_handling.py,sha256=WK22Cu3cI1uZ2RtmXmkwnWrYXrwMdcXkhqHTwp0Bqqo,24380
 tests/offline/test_explain_methods.py,sha256=QGSwqGGulZ-8e0pnshQ9A0JwC-CQZ6GcE7mkp_LIYIw,12683
 tests/offline/test_filter_logical_in.py,sha256=Qb-bJiy5lhQaVlTeVNVZ75v6Xyx4Qd2IS_faaxC4VUg,8967
@@ -77,6 +78,7 @@ tests/online/test_account_management.py,sha256=mWIF3kPaegcb-JEhHBM9LrSae2xZ3ppjk
 tests/online/test_advanced_features.py,sha256=f0oOe1bB6dT4bXZqx4LzrWd4ljwwcr9iIZLDHnTdPhU,13641
 tests/online/test_async_client_interfaces.py,sha256=ZT2kWm-ZT_O-_ZkGE7mVLE5c52_eRsbCC_wEksrUis0,12295
 tests/online/test_async_client_online.py,sha256=LZp0QXk4l4FfuQOHNNg__degRTwh9K61StFtEmeUmZ8,10906
+tests/online/test_async_index_verification_online.py,sha256=zevl8BKAIGRyJ0ndnUmW_oQpC_rc2_W0ATPb152OMag,10162
 tests/online/test_async_model_insert_online.py,sha256=YPlcNjuaeimvG355JjjgyZUPfa9J0HtC5FVJr9uIp_k,10857
 tests/online/test_async_orm_online.py,sha256=8wjQb9oXMyNh4HQ1YkwiFYfHo73_YVPicOR_aiXrbEg,11039
 tests/online/test_async_simple_query_online.py,sha256=nBMsCv-GaEiSRxh1juLNCiXNNsfUwWRApQvStzLeGr4,31021
@@ -91,6 +93,7 @@ tests/online/test_filter_logical_in_online.py,sha256=-OrmHSMyk6nYap5OCICaImt9AQ5
 tests/online/test_fulltext_comprehensive.py,sha256=lJ_XMkZnHe1HPsbXS9O5F9tBBsPKTBNUnx78KgKTv3w,74063
 tests/online/test_fulltext_label_online.py,sha256=1ExVrGIOA7dfG6UiB7Ul6xeLrLY9u6oAjjT4hYNtr8E,16534
 tests/online/test_fulltext_search_online.py,sha256=711WdigiDR71nwtqLlVl39_lNocbWlNnJR5W6hBhl50,33660
+tests/online/test_index_verification_online.py,sha256=Uz8Gjvjm2SdNhpXeun_Y8KOQ1VOs601WLMmxWTMzNa0,7510
 tests/online/test_ivf_stats_online.py,sha256=Fdi_-bleJVXtWzHNfeA6eCgVdlvSvpEfop7GGUZTQ9E,19845
 tests/online/test_logger_integration.py,sha256=iv0TrKZGRg-oxjbp55fYixbfpdqLFWQDR8mXeaSKArg,11824
 tests/online/test_matrixone_query_orm.py,sha256=WYH6HxcfnNqtQ05kKHRcmwmWHXtDz8Ts0pUwuSdgo_U,20130
@@ -115,8 +118,8 @@ tests/online/test_transaction_query_methods.py,sha256=VaPvHOYskwJVyM7lvVvBJ6Hqhd
 tests/online/test_unified_filter_online.py,sha256=86JwEKUaBLNuLGJlR4E0zjzdWL5xVFyYLvyxbzkdEVI,21214
 tests/online/test_vector_comprehensive.py,sha256=vmnwwVXLA7lUI_zSK3fJcf1HKx2AvrVDcUT0_d-gQwg,26980
 tests/online/test_version_management.py,sha256=BU8Vc1fDKNCwhRliZi6XmEnd0HYdHuki9Xxi09vnriA,11416
-matrixone_python_sdk-0.1.2.dist-info/METADATA,sha256=eZci5V6XBGdSXpvmVs7SNdkFcLWvRCx2Lh9F-xBiG2c,20815
-matrixone_python_sdk-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrixone_python_sdk-0.1.2.dist-info/entry_points.txt,sha256=4wUGPC_7_f5ZDR33JRo1LZmmTuyfkYAv41_5H5Qy-Ik,138
-matrixone_python_sdk-0.1.2.dist-info/top_level.txt,sha256=LQZabpBx_dtQk8JbKeH3MbjmC8HYDLE8UQeEf6NfQJA,16
-matrixone_python_sdk-0.1.2.dist-info/RECORD,,
+matrixone_python_sdk-0.1.4.dist-info/METADATA,sha256=EOKIuyVQVsFc316C84HjVLJYxD-7fMtq7a307ypoJ54,20815
+matrixone_python_sdk-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrixone_python_sdk-0.1.4.dist-info/entry_points.txt,sha256=4wUGPC_7_f5ZDR33JRo1LZmmTuyfkYAv41_5H5Qy-Ik,138
+matrixone_python_sdk-0.1.4.dist-info/top_level.txt,sha256=LQZabpBx_dtQk8JbKeH3MbjmC8HYDLE8UQeEf6NfQJA,16
+matrixone_python_sdk-0.1.4.dist-info/RECORD,,

tests/offline/test_connection_hooks_offline.py

@@ -106,7 +106,7 @@ class TestConnectionHook:
         # Verify that cursor.execute was called with the correct SQL
         self.mock_cursor.execute.assert_called_with("SET experimental_ivf_index = 1")
         self.mock_cursor.close.assert_called_once()
-        self.mock_client.logger.info.assert_called_with("✓ Enabled IVF vector operations")
+        self.mock_client.logger.debug.assert_called_with("✓ Enabled IVF vector operations")
 
     def test_execute_sync_with_hnsw_action(self):
         """Test synchronous execution with HNSW action"""
@@ -117,7 +117,7 @@ class TestConnectionHook:
         # Verify that cursor.execute was called with the correct SQL
         self.mock_cursor.execute.assert_called_with("SET experimental_hnsw_index = 1")
         self.mock_cursor.close.assert_called_once()
-        self.mock_client.logger.info.assert_called_with("✓ Enabled HNSW vector operations")
+        self.mock_client.logger.debug.assert_called_with("✓ Enabled HNSW vector operations")
 
     def test_execute_sync_with_fulltext_action(self):
         """Test synchronous execution with fulltext action"""
@@ -128,7 +128,7 @@ class TestConnectionHook:
         # Verify that cursor.execute was called with the correct SQL
         self.mock_cursor.execute.assert_called_with("SET experimental_fulltext_index = 1")
         self.mock_cursor.close.assert_called_once()
-        self.mock_client.logger.info.assert_called_with("✓ Enabled fulltext search operations")
+        self.mock_client.logger.debug.assert_called_with("✓ Enabled fulltext search operations")
 
     def test_execute_sync_with_vector_action(self):
         """Test synchronous execution with vector action (enables both IVF and HNSW)"""
@@ -140,8 +140,8 @@ class TestConnectionHook:
         expected_calls = [call("SET experimental_ivf_index = 1"), call("SET experimental_hnsw_index = 1")]
         self.mock_cursor.execute.assert_has_calls(expected_calls, any_order=True)
         self.mock_cursor.close.assert_called()
-        self.mock_client.logger.info.assert_any_call("✓ Enabled IVF vector operations")
-        self.mock_client.logger.info.assert_any_call("✓ Enabled HNSW vector operations")
+        self.mock_client.logger.debug.assert_any_call("✓ Enabled IVF vector operations")
+        self.mock_client.logger.debug.assert_any_call("✓ Enabled HNSW vector operations")
 
     def test_execute_sync_with_all_action(self):
         """Test synchronous execution with all action"""
@@ -157,9 +157,9 @@ class TestConnectionHook:
         ]
         self.mock_cursor.execute.assert_has_calls(expected_calls, any_order=True)
         self.mock_cursor.close.assert_called()
-        self.mock_client.logger.info.assert_any_call("✓ Enabled IVF vector operations")
-        self.mock_client.logger.info.assert_any_call("✓ Enabled HNSW vector operations")
-        self.mock_client.logger.info.assert_any_call("✓ Enabled fulltext search operations")
+        self.mock_client.logger.debug.assert_any_call("✓ Enabled IVF vector operations")
+        self.mock_client.logger.debug.assert_any_call("✓ Enabled HNSW vector operations")
+        self.mock_client.logger.debug.assert_any_call("✓ Enabled fulltext search operations")
 
     def test_execute_sync_with_custom_hook(self):
         """Test synchronous execution with custom hook"""

tests/online/test_async_index_verification_online.py

@@ -0,0 +1,259 @@
+# Copyright 2021 - 2022 Matrix Origin
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Online tests for async secondary index verification functionality
+"""
+
+import pytest
+import pytest_asyncio
+import os
+import sys
+
+# Add the matrixone package to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from matrixone import AsyncClient
+from matrixone.orm import declarative_base
+from sqlalchemy import Column, String, Integer, Index
+from .test_config import online_config
+
+
+class TestAsyncIndexVerificationOnline:
+    """Online tests for async secondary index verification"""
+
+    @pytest_asyncio.fixture(scope="function")
+    async def async_client_with_test_table(self):
+        """Create AsyncClient with test table"""
+        host, port, user, password, database = online_config.get_connection_params()
+        client = AsyncClient()
+        await client.connect(host=host, port=port, user=user, password=password, database=database)
+
+        test_table = "test_async_index_table"
+
+        try:
+            # Define ORM model with secondary indexes
+            Base = declarative_base()
+
+            class TestTable(Base):
+                __tablename__ = test_table
+
+                id = Column(Integer, primary_key=True)
+                name = Column(String(100))
+                category = Column(String(50))
+                value = Column(Integer)
+
+                # Define secondary indexes
+                __table_args__ = (
+                    Index('idx_async_name', 'name'),
+                    Index('idx_async_category', 'category'),
+                    Index('idx_async_value', 'value'),
+                )
+
+            # Drop table if exists and create new one using SDK API
+            try:
+                await client.drop_table(TestTable)
+            except:
+                pass
+
+            # Create table with indexes using SDK API
+            await client.create_table(TestTable)
+
+            # Insert test data using SDK API
+            test_data = [
+                {'id': i, 'name': f'async_name_{i}', 'category': f'cat_{i % 5}', 'value': i * 10} for i in range(1, 101)
+            ]
+            await client.batch_insert(TestTable, test_data)
+
+            yield client, test_table, TestTable
+
+        finally:
+            # Clean up using SDK API
+            try:
+                await client.drop_table(TestTable)
+                await client.disconnect()
+            except Exception as e:
+                print(f"Cleanup failed: {e}")
+
+    @pytest.mark.asyncio
+    async def test_async_get_secondary_index_tables(self, async_client_with_test_table):
+        """Test async getting all secondary index table names"""
+        client, test_table, TestTable = async_client_with_test_table
+
+        index_tables = await client.get_secondary_index_tables(test_table)
+
+        # Should have 3 secondary indexes
+        assert len(index_tables) == 3, f"Expected 3 indexes, got {len(index_tables)}"
+
+        # All index tables should start with __mo_index_secondary_
+        for index_table in index_tables:
+            assert index_table.startswith(
+                '__mo_index_secondary_'
+            ), f"Index table name should start with '__mo_index_secondary_', got {index_table}"
+
+
+class TestAsyncIndexVerificationOnline:
+    """Online tests for async secondary index verification"""
+
+    @pytest_asyncio.fixture(scope="function")
+    async def async_client_with_test_table(self):
+        """Create AsyncClient with test table"""
+        host, port, user, password, database = online_config.get_connection_params()
+        client = AsyncClient()
+        await client.connect(host=host, port=port, user=user, password=password, database=database)
+
+        test_table = "test_async_index_table"
+
+        try:
+            # Define ORM model with secondary indexes
+            Base = declarative_base()
+
+            class TestTable(Base):
+                __tablename__ = test_table
+
+                id = Column(Integer, primary_key=True)
+                name = Column(String(100))
+                category = Column(String(50))
+                value = Column(Integer)
+
+                # Define secondary indexes
+                __table_args__ = (
+                    Index('idx_async_name', 'name'),
+                    Index('idx_async_category', 'category'),
+                    Index('idx_async_value', 'value'),
+                )
+
+            # Drop table if exists and create new one using SDK API
+            try:
+                await client.drop_table(TestTable)
+            except:
+                pass
+
+            # Create table with indexes using SDK API
+            await client.create_table(TestTable)
+
+            # Insert test data using SDK API
+            test_data = [
+                {'id': i, 'name': f'async_name_{i}', 'category': f'cat_{i % 5}', 'value': i * 10} for i in range(1, 101)
+            ]
+            await client.batch_insert(TestTable, test_data)
+
+            yield client, test_table, TestTable
+
+        finally:
+            # Clean up using SDK API
+            try:
+                await client.drop_table(TestTable)
+                await client.disconnect()
+            except Exception as e:
+                print(f"Cleanup failed: {e}")
+
+    @pytest.mark.asyncio
+    async def test_async_get_secondary_index_table_by_name(self, async_client_with_test_table):
+        """Test async getting physical table name of a secondary index by its name"""
+        client, test_table, TestTable = async_client_with_test_table
+
+        # Test getting idx_async_name
+        idx_name_table = await client.get_secondary_index_table_by_name(test_table, 'idx_async_name')
+        assert idx_name_table is not None, "idx_async_name should exist"
+        assert idx_name_table.startswith('__mo_index_secondary_')
+
+        # Test getting idx_async_category
+        idx_category_table = await client.get_secondary_index_table_by_name(test_table, 'idx_async_category')
+        assert idx_category_table is not None, "idx_async_category should exist"
+        assert idx_category_table.startswith('__mo_index_secondary_')
+
+        # Test getting idx_async_value
+        idx_value_table = await client.get_secondary_index_table_by_name(test_table, 'idx_async_value')
+        assert idx_value_table is not None, "idx_async_value should exist"
+        assert idx_value_table.startswith('__mo_index_secondary_')
+
+        # Test non-existent index
+        non_existent = await client.get_secondary_index_table_by_name(test_table, 'idx_non_existent')
+        assert non_existent is None, "Non-existent index should return None"
+
+    @pytest.mark.asyncio
+    async def test_async_verify_table_index_counts(self, async_client_with_test_table):
+        """Test async verify_table_index_counts when counts match"""
+        client, test_table, TestTable = async_client_with_test_table
+
+        # All indexes should have the same count as the main table
+        count = await client.verify_table_index_counts(test_table)
+
+        # Should return 100 (number of inserted rows)
+        assert count == 100, f"Expected count 100, got {count}"
+
+        # Verify count matches query result using SDK API
+        actual_count = await client.query(TestTable).count()
+        assert count == actual_count, "Verify result should match actual count"
+
+    @pytest.mark.asyncio
+    async def test_async_verify_table_without_indexes(self, async_client_with_test_table):
+        """Test async verify_table_index_counts on table without secondary indexes"""
+        client, test_table, TestTable = async_client_with_test_table
+
+        # Define a simple model without secondary indexes
+        Base = declarative_base()
+
+        class SimpleTable(Base):
+            __tablename__ = "test_async_simple_table"
+            id = Column(Integer, primary_key=True)
+            value = Column(Integer)
+
+        # Create table using SDK API
+        try:
+            await client.drop_table(SimpleTable)
+        except:
+            pass
+
+        await client.create_table(SimpleTable)
+
+        # Insert data using SDK API
+        test_data = [{'id': 1, 'value': 100}, {'id': 2, 'value': 200}]
+        await client.batch_insert(SimpleTable, test_data)
+
+        # Verification should succeed and return count
+        count = await client.verify_table_index_counts("test_async_simple_table")
+        assert count == 2, f"Expected count 2, got {count}"
+
+        # Cleanup using SDK API
+        await client.drop_table(SimpleTable)
+
+    @pytest.mark.asyncio
+    async def test_async_index_table_mapping(self, async_client_with_test_table):
+        """Test that all indexes can be retrieved both ways (async)"""
+        client, test_table, TestTable = async_client_with_test_table
+
+        # Get all index tables
+        all_index_tables = await client.get_secondary_index_tables(test_table)
+
+        # Get each index by name
+        index_names = ['idx_async_name', 'idx_async_category', 'idx_async_value']
+        retrieved_tables = []
+
+        for index_name in index_names:
+            table = await client.get_secondary_index_table_by_name(test_table, index_name)
+            assert table is not None, f"Index {index_name} should exist"
+            retrieved_tables.append(table)
+
+        # All retrieved tables should be in the all_index_tables list
+        for table in retrieved_tables:
+            assert table in all_index_tables, f"Retrieved table {table} should be in all index tables"
+
+        # Both lists should have the same length
+        assert len(retrieved_tables) == len(all_index_tables), "Number of retrieved tables should match total index tables"
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])

tests/online/test_index_verification_online.py

@@ -0,0 +1,194 @@
+# Copyright 2021 - 2022 Matrix Origin
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Online tests for secondary index verification functionality
+"""
+
+import unittest
+import os
+import sys
+
+# Add the matrixone package to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from matrixone import Client
+from matrixone.orm import declarative_base
+from sqlalchemy import Column, String, Integer, Index
+
+
+class TestIndexVerificationOnline(unittest.TestCase):
+    """Online tests for secondary index verification"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up test database connection"""
+        cls.client = Client(
+            host=os.getenv('MATRIXONE_HOST', '127.0.0.1'),
+            port=int(os.getenv('MATRIXONE_PORT', '6001')),
+            user=os.getenv('MATRIXONE_USER', 'root'),
+            password=os.getenv('MATRIXONE_PASSWORD', '111'),
+            database=os.getenv('MATRIXONE_DATABASE', 'test'),
+        )
+
+        cls.test_table = "test_index_table"
+
+        try:
+            # Define ORM model with secondary indexes
+            Base = declarative_base()
+
+            class TestTable(Base):
+                __tablename__ = cls.test_table
+
+                id = Column(Integer, primary_key=True)
+                name = Column(String(100))
+                category = Column(String(50))
+                value = Column(Integer)
+
+                # Define secondary indexes
+                __table_args__ = (
+                    Index('idx_name', 'name'),
+                    Index('idx_category', 'category'),
+                    Index('idx_value', 'value'),
+                )
+
+            cls.TestTable = TestTable
+
+            # Drop table if exists and create new one
+            try:
+                cls.client.drop_table(TestTable)
+            except:
+                pass
+
+            # Create table with indexes using SDK API
+            cls.client.create_table(TestTable)
+
+            # Insert test data using SDK API
+            test_data = [{'id': i, 'name': f'name_{i}', 'category': f'cat_{i % 5}', 'value': i * 10} for i in range(1, 101)]
+            cls.client.batch_insert(TestTable, test_data)
+
+        except Exception as e:
+            print(f"Setup failed: {e}")
+            raise
+
+    @classmethod
+    def tearDownClass(cls):
+        """Clean up test database"""
+        try:
+            cls.client.drop_table(cls.TestTable)
+        except Exception as e:
+            print(f"Cleanup failed: {e}")
+
+    def test_get_secondary_index_tables(self):
+        """Test getting all secondary index table names"""
+        index_tables = self.client.get_secondary_index_tables(self.test_table)
+
+        # Should have 3 secondary indexes
+        self.assertEqual(len(index_tables), 3, f"Expected 3 indexes, got {len(index_tables)}")
+
+        # All index tables should start with __mo_index_secondary_
+        for index_table in index_tables:
+            self.assertTrue(
+                index_table.startswith('__mo_index_secondary_'),
+                f"Index table name should start with '__mo_index_secondary_', got {index_table}",
+            )
+
+    def test_get_secondary_index_table_by_name(self):
+        """Test getting physical table name of a secondary index by its name"""
+        # Test getting idx_name
+        idx_name_table = self.client.get_secondary_index_table_by_name(self.test_table, 'idx_name')
+        self.assertIsNotNone(idx_name_table, "idx_name should exist")
+        self.assertTrue(idx_name_table.startswith('__mo_index_secondary_'))
+
+        # Test getting idx_category
+        idx_category_table = self.client.get_secondary_index_table_by_name(self.test_table, 'idx_category')
+        self.assertIsNotNone(idx_category_table, "idx_category should exist")
+        self.assertTrue(idx_category_table.startswith('__mo_index_secondary_'))
+
+        # Test getting idx_value
+        idx_value_table = self.client.get_secondary_index_table_by_name(self.test_table, 'idx_value')
+        self.assertIsNotNone(idx_value_table, "idx_value should exist")
+        self.assertTrue(idx_value_table.startswith('__mo_index_secondary_'))
+
+        # Test non-existent index
+        non_existent = self.client.get_secondary_index_table_by_name(self.test_table, 'idx_non_existent')
+        self.assertIsNone(non_existent, "Non-existent index should return None")
+
+    def test_verify_table_index_counts(self):
+        """Test verify_table_index_counts when counts match"""
+        # All indexes should have the same count as the main table
+        count = self.client.verify_table_index_counts(self.test_table)
+
+        # Should return 100 (number of inserted rows)
+        self.assertEqual(count, 100, f"Expected count 100, got {count}")
+
+        # Verify count matches query result using SDK API
+        actual_count = self.client.query(self.TestTable).count()
+        self.assertEqual(count, actual_count, "Verify result should match actual count")
+
+    def test_verify_table_without_indexes(self):
+        """Test verify_table_index_counts on table without secondary indexes"""
+        # Define a simple model without secondary indexes
+        Base = declarative_base()
+
+        class SimpleTable(Base):
+            __tablename__ = "test_simple_table"
+            id = Column(Integer, primary_key=True)
+            value = Column(Integer)
+
+        # Create table using SDK API
+        try:
+            self.client.drop_table(SimpleTable)
+        except:
+            pass
+
+        self.client.create_table(SimpleTable)
+
+        # Insert data using SDK API
+        test_data = [{'id': 1, 'value': 100}, {'id': 2, 'value': 200}]
+        self.client.batch_insert(SimpleTable, test_data)
+
+        # Verification should succeed and return count
+        count = self.client.verify_table_index_counts("test_simple_table")
+        self.assertEqual(count, 2, f"Expected count 2, got {count}")
+
+        # Cleanup using SDK API
+        self.client.drop_table(SimpleTable)
+
+    def test_index_table_mapping(self):
+        """Test that all indexes can be retrieved both ways"""
+        # Get all index tables
+        all_index_tables = self.client.get_secondary_index_tables(self.test_table)
+
+        # Get each index by name
+        index_names = ['idx_name', 'idx_category', 'idx_value']
+        retrieved_tables = []
+
+        for index_name in index_names:
+            table = self.client.get_secondary_index_table_by_name(self.test_table, index_name)
+            self.assertIsNotNone(table, f"Index {index_name} should exist")
+            retrieved_tables.append(table)
+
+        # All retrieved tables should be in the all_index_tables list
+        for table in retrieved_tables:
+            self.assertIn(table, all_index_tables, f"Retrieved table {table} should be in all index tables")
+
+        # Both lists should have the same length
+        self.assertEqual(
+            len(retrieved_tables), len(all_index_tables), "Number of retrieved tables should match total index tables"
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()