matrixone-python-sdk 0.1.0__py3-none-any.whl

tests/online/test_async_transaction_simple_query.py

@@ -0,0 +1,300 @@
+# 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.
+
+"""
+Test async transaction simple_query functionality
+"""
+
+import pytest
+import pytest_asyncio
+from matrixone import AsyncClient
+from matrixone.sqlalchemy_ext import boolean_match, natural_match
+
+
+class TestAsyncTransactionSimpleQuery:
+    """Test async transaction simple_query operations"""
+
+    @pytest_asyncio.fixture(scope="function")
+    async def async_client_setup(self):
+        """Setup async client for testing"""
+        client = AsyncClient()
+        await client.connect("127.0.0.1", 6001, "root", "111", "test")
+
+        # Enable fulltext indexing
+        await client.execute("SET experimental_fulltext_index=1")
+
+        # Create test database and table
+        test_db = "async_tx_simple_query_test"
+        await client.execute(f"CREATE DATABASE IF NOT EXISTS {test_db}")
+        await client.execute(f"USE {test_db}")
+
+        await client.execute("DROP TABLE IF EXISTS async_tx_docs")
+        await client.execute(
+            """
+            CREATE TABLE async_tx_docs (
+                id INT AUTO_INCREMENT PRIMARY KEY,
+                title VARCHAR(255) NOT NULL,
+                content TEXT NOT NULL,
+                category VARCHAR(100) NOT NULL
+            )
+        """
+        )
+
+        # Insert test data
+        test_docs = [
+            (
+                "Python Async Programming",
+                "Learn Python async programming with asyncio",
+                "Programming",
+            ),
+            (
+                "JavaScript Async Patterns",
+                "Modern JavaScript async patterns and promises",
+                "Programming",
+            ),
+            (
+                "Database Async Operations",
+                "Async database operations and connection pooling",
+                "Database",
+            ),
+            ("Web Async Development", "Async web development with modern frameworks", "Web"),
+            (
+                "Async Testing Strategies",
+                "Testing async code and handling async test cases",
+                "Testing",
+            ),
+        ]
+
+        for title, content, category in test_docs:
+            await client.execute(
+                f"""
+                INSERT INTO async_tx_docs (title, content, category) 
+                VALUES ('{title}', '{content}', '{category}')
+            """
+            )
+
+        # Create fulltext index
+        await client.fulltext_index.create("async_tx_docs", "ftidx_async_tx", ["title", "content"])
+
+        yield client, test_db
+
+        # Cleanup
+        try:
+            await client.fulltext_index.drop("async_tx_docs", "ftidx_async_tx")
+            await client.execute("DROP TABLE async_tx_docs")
+            await client.execute(f"DROP DATABASE {test_db}")
+        except Exception as e:
+            print(f"Cleanup warning: {e}")
+        finally:
+            await client.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_basic(self, async_client_setup):
+        """Test basic async transaction simple_query functionality"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test basic search within transaction
+            result = await tx.query("async_tx_docs").filter(boolean_match("title", "content").encourage("python")).execute()
+
+            assert result is not None
+            rows = result.fetchall()
+            assert len(rows) > 0
+
+            # Verify results contain "python"
+            for row in rows:
+                title_content = f"{row[0]} {row[1]}".lower()  # title and content
+                assert "python" in title_content
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_with_score(self, async_client_setup):
+        """Test async transaction simple_query with score"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test search with score within transaction
+            result = await tx.query(
+                "async_tx_docs.title",
+                "async_tx_docs.content",
+                boolean_match("title", "content").encourage("async").label("score"),
+            ).execute()
+
+            assert result is not None
+            rows = result.fetchall()
+            assert len(rows) > 0
+
+            # Verify results have score column
+            assert "score" in result.columns
+            score_column_index = result.columns.index("score")
+
+            # Verify score values are numeric
+            for row in rows:
+                score = row[score_column_index]
+                assert isinstance(score, (int, float))
+                assert score >= 0
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_boolean_mode(self, async_client_setup):
+        """Test async transaction simple_query with boolean mode"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test boolean mode search within transaction
+            result = (
+                await tx.query("async_tx_docs.title", "async_tx_docs.content")
+                .filter(boolean_match("title", "content").must("async").must_not("basic"))
+                .execute()
+            )
+
+            assert result is not None
+            rows = result.fetchall()
+            assert len(rows) > 0
+
+            # Verify all results contain "async" but not "basic"
+            for row in rows:
+                title_content = f"{row[0]} {row[1]}".lower()  # title and content
+                assert "async" in title_content
+                assert "basic" not in title_content
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_with_where(self, async_client_setup):
+        """Test async transaction simple_query with WHERE conditions"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test search with WHERE conditions within transaction
+            result = (
+                await tx.query("async_tx_docs.title", "async_tx_docs.content")
+                .filter(boolean_match("title", "content").encourage("programming"), "async_tx_docs.category = 'Programming'")
+                .execute()
+            )
+
+            assert result is not None
+            rows = result.fetchall()
+            assert len(rows) > 0
+
+            # Verify all results contain "programming"
+            for row in rows:
+                title_content = f"{row[0]} {row[1]}".lower()
+                assert "programming" in title_content
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_ordering_and_limit(self, async_client_setup):
+        """Test async transaction simple_query with ordering and limit"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test search with ordering and limit within transaction
+            result = (
+                await tx.query("async_tx_docs.title", "async_tx_docs.content")
+                .filter(boolean_match("title", "content").encourage("async"))
+                .order_by("async_tx_docs.title DESC")
+                .limit(2)
+                .execute()
+            )
+
+            assert result is not None
+            rows = result.fetchall()
+            assert len(rows) <= 2
+
+            # Verify results are ordered by title (descending)
+            titles = [row[0] for row in rows]  # title column
+            assert titles == sorted(titles, reverse=True)
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_explain(self, async_client_setup):
+        """Test async transaction simple_query explain functionality"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test basic query functionality within transaction
+            result = (
+                await tx.query("async_tx_docs.title", "async_tx_docs.content")
+                .filter(boolean_match("title", "content").encourage("test"), "async_tx_docs.category = 'Testing'")
+                .execute()
+            )
+
+            assert result is not None
+            rows = result.fetchall()
+            # Should find testing-related content
+            assert len(rows) > 0, "Should find testing-related content"
+
+            # Verify all results contain "test" in title or content
+            for row in rows:
+                title_content = f"{row[0]} {row[1]}".lower()
+                assert "test" in title_content, f"Row should contain 'test': {row}"
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_multiple_operations(self, async_client_setup):
+        """Test multiple async transaction simple_query operations in one transaction"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test multiple searches within the same transaction
+            results = []
+
+            # Search 1: Basic search
+            result1 = await tx.query(
+                "async_tx_docs.title", "async_tx_docs.content", boolean_match("title", "content").encourage("python")
+            ).execute()
+            results.append(result1)
+
+            # Search 2: Boolean mode
+            result2 = await tx.query(
+                "async_tx_docs.title", "async_tx_docs.content", boolean_match("title", "content").must("javascript")
+            ).execute()
+            results.append(result2)
+
+            # Search 3: With score
+            result3 = await tx.query(
+                "async_tx_docs.title",
+                "async_tx_docs.content",
+                boolean_match("title", "content").encourage("database").label("score"),
+            ).execute()
+            results.append(result3)
+
+            # Verify all searches returned results
+            for i, result in enumerate(results):
+                assert result is not None
+                rows = result.fetchall()
+                assert len(rows) > 0, f"Search {i+1} should return results"
+
+                # Verify content matches search terms
+                search_terms = ["python", "javascript", "database"]
+                term = search_terms[i]
+                for row in rows:
+                    title_content = f"{row[0]} {row[1]}".lower()
+                    assert term in title_content, f"Row should contain '{term}': {row}"
+
+    @pytest.mark.asyncio
+    async def test_async_transaction_simple_query_with_database_prefix(self, async_client_setup):
+        """Test async transaction simple_query with database prefix"""
+        client, test_db = async_client_setup
+
+        async with client.transaction() as tx:
+            # Test search with database prefix within transaction
+            result = await tx.query(
+                f"{test_db}.async_tx_docs.title",
+                f"{test_db}.async_tx_docs.content",
+                boolean_match("title", "content").encourage("web"),
+            ).execute()
+
+            assert result is not None
+            rows = result.fetchall()
+            assert len(rows) > 0
+
+            # Verify results contain "web"
+            for row in rows:
+                title_content = f"{row[0]} {row[1]}".lower()  # title and content
+                assert "web" in title_content

tests/online/test_basic_connection.py

@@ -0,0 +1,130 @@
+# 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 basic connection functionality
+
+These tests are inspired by example_01_basic_connection.py
+"""
+
+import pytest
+from matrixone import Client, AsyncClient
+from matrixone.logger import create_default_logger
+
+
+@pytest.mark.online
+class TestBasicConnection:
+    """Test basic connection functionality"""
+
+    def test_basic_connection_and_query(self, test_client):
+        """Test basic connection and simple query"""
+        # Test basic query
+        result = test_client.execute("SELECT 1 as test_value, USER() as user_info")
+        assert result is not None
+        assert len(result.rows) > 0
+        assert result.rows[0][0] == 1  # test_value should be 1
+
+    def test_database_info_queries(self, test_client):
+        """Test database information queries"""
+        # Test SHOW DATABASES
+        result = test_client.execute("SHOW DATABASES")
+        assert result is not None
+        assert len(result.rows) > 0
+
+        # Test SHOW TABLES
+        result = test_client.execute("SHOW TABLES")
+        assert result is not None
+
+    def test_connection_with_logging(self, connection_params):
+        """Test connection with custom logging"""
+        host, port, user, password, database = connection_params
+
+        # Create logger
+        logger = create_default_logger()
+
+        # Create client with logging
+        client = Client()
+        client.connect(host=host, port=port, user=user, password=password, database=database)
+
+        try:
+            # Test query with logging
+            result = client.execute("SELECT 1 as test_value")
+            assert result is not None
+            assert len(result.rows) > 0
+        finally:
+            client.disconnect()
+
+    def test_connection_error_handling(self, connection_params):
+        """Test connection error handling"""
+        host, port, user, password, database = connection_params
+
+        # Test with invalid port
+        try:
+            client = Client()
+            client.connect(host=host, port=9999, user=user, password=password, database=database)
+            # With the new connection pool architecture, connection is tested on first query
+            client.execute("SELECT 1")
+            assert False, "Should have failed with invalid port"
+        except Exception as e:
+            assert "connection" in str(e).lower() or "refused" in str(e).lower()
+
+    def test_client_context_manager(self, connection_params):
+        """Test client context manager"""
+        host, port, user, password, database = connection_params
+
+        with Client() as client:
+            client.connect(host=host, port=port, user=user, password=password, database=database)
+            result = client.execute("SELECT 1 as test_value")
+            assert result is not None
+            assert len(result.rows) > 0
+
+    @pytest.mark.asyncio
+    async def test_async_basic_connection(self, test_async_client):
+        """Test basic async connection and query"""
+        # Test basic query
+        result = await test_async_client.execute("SELECT 1 as test_value, USER() as user_info")
+        assert result is not None
+        assert len(result.rows) > 0
+        assert result.rows[0][0] == 1  # test_value should be 1
+
+    @pytest.mark.asyncio
+    async def test_async_connection_with_logging(self, connection_params):
+        """Test async connection with custom logging"""
+        host, port, user, password, database = connection_params
+
+        # Create logger
+        logger = create_default_logger()
+
+        # Create async client with logging
+        client = AsyncClient()
+        await client.connect(host=host, port=port, user=user, password=password, database=database)
+
+        try:
+            # Test query with logging
+            result = await client.execute("SELECT 1 as test_value")
+            assert result is not None
+            assert len(result.rows) > 0
+        finally:
+            await client.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_async_client_context_manager(self, connection_params):
+        """Test async client context manager"""
+        host, port, user, password, database = connection_params
+
+        async with AsyncClient() as client:
+            await client.connect(host=host, port=port, user=user, password=password, database=database)
+            result = await client.execute("SELECT 1 as test_value")
+            assert result is not None
+            assert len(result.rows) > 0

tests/online/test_client_online.py

@@ -0,0 +1,238 @@
+# 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 Client functionality - tests actual database operations
+"""
+
+import unittest
+import os
+import sys
+from datetime import datetime
+
+# Add the matrixone package to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from matrixone import Client
+from matrixone.exceptions import ConnectionError, QueryError
+
+
+class TestClientOnline(unittest.TestCase):
+    """Online tests for Client functionality"""
+
+    @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'),
+        )
+
+        # Create test database and table
+        cls.test_db = "test_client_db"
+        cls.test_table = "test_client_table"
+
+        try:
+            cls.client.execute(f"CREATE DATABASE IF NOT EXISTS {cls.test_db}")
+            cls.client.execute(f"USE {cls.test_db}")
+            cls.client.execute(
+                f"""
+                CREATE TABLE IF NOT EXISTS {cls.test_table} (
+                    id INT PRIMARY KEY,
+                    name VARCHAR(100),
+                    value INT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """
+            )
+
+            # Insert test data
+            cls.client.execute(f"INSERT INTO {cls.test_table} VALUES (1, 'test1', 100, NOW())")
+            cls.client.execute(f"INSERT INTO {cls.test_table} VALUES (2, 'test2', 200, NOW())")
+            cls.client.execute(f"INSERT INTO {cls.test_table} VALUES (3, 'test3', 300, NOW())")
+
+        except Exception as e:
+            print(f"Setup failed: {e}")
+            raise
+
+    @classmethod
+    def tearDownClass(cls):
+        """Clean up test database"""
+        try:
+            cls.client.execute(f"DROP DATABASE IF EXISTS {cls.test_db}")
+        except Exception as e:
+            print(f"Cleanup failed: {e}")
+
+    def test_basic_connection_and_query(self):
+        """Test basic connection and query functionality"""
+        # Test simple query
+        result = self.client.execute("SELECT 1 as test_value")
+        rows = result.fetchall()
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0][0], 1)
+
+        # Test query with parameters
+        result = self.client.execute("SELECT ? as param_value", (42,))
+        rows = result.fetchall()
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0][0], 42)
+
+    def test_table_operations(self):
+        """Test table operations"""
+        # Test SELECT
+        result = self.client.execute(f"SELECT * FROM {self.test_table} ORDER BY id")
+        rows = result.fetchall()
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(rows[0][0], 1)  # id
+        self.assertEqual(rows[0][1], 'test1')  # name
+
+        # Test INSERT
+        self.client.execute(f"INSERT INTO {self.test_table} VALUES (4, 'test4', 400, NOW())")
+
+        # Verify INSERT
+        result = self.client.execute(f"SELECT COUNT(*) FROM {self.test_table}")
+        count = result.fetchone()[0]
+        self.assertEqual(count, 4)
+
+        # Test UPDATE
+        self.client.execute(f"UPDATE {self.test_table} SET value = 500 WHERE id = 4")
+
+        # Verify UPDATE
+        result = self.client.execute(f"SELECT value FROM {self.test_table} WHERE id = 4")
+        value = result.fetchone()[0]
+        self.assertEqual(value, 500)
+
+        # Test DELETE
+        self.client.execute(f"DELETE FROM {self.test_table} WHERE id = 4")
+
+        # Verify DELETE
+        result = self.client.execute(f"SELECT COUNT(*) FROM {self.test_table}")
+        count = result.fetchone()[0]
+        self.assertEqual(count, 3)
+
+    def test_transaction_operations(self):
+        """Test transaction operations"""
+        with self.client.transaction() as tx:
+            # Insert within transaction
+            tx.execute(f"INSERT INTO {self.test_table} VALUES (5, 'test5', 500, NOW())")
+
+            # Verify within transaction
+            result = tx.execute(f"SELECT COUNT(*) FROM {self.test_table}")
+            count = result.fetchone()[0]
+            self.assertEqual(count, 4)
+
+        # Verify transaction commit
+        result = self.client.execute(f"SELECT COUNT(*) FROM {self.test_table}")
+        count = result.fetchone()[0]
+        self.assertEqual(count, 4)
+
+        # Test transaction rollback
+        try:
+            with self.client.transaction() as tx:
+                tx.execute(f"INSERT INTO {self.test_table} VALUES (6, 'test6', 600, NOW())")
+                # Force rollback by raising exception
+                raise Exception("Test rollback")
+        except Exception:
+            pass
+
+        # Verify rollback
+        result = self.client.execute(f"SELECT COUNT(*) FROM {self.test_table}")
+        count = result.fetchone()[0]
+        self.assertEqual(count, 4)  # Should still be 4, not 5
+
+        # Clean up
+        self.client.execute(f"DELETE FROM {self.test_table} WHERE id = 5")
+
+    def test_error_handling(self):
+        """Test error handling"""
+        # Test connection error handling
+        with self.assertRaises(QueryError):
+            self.client.execute("SELECT * FROM non_existent_table")
+
+        # Test invalid SQL
+        with self.assertRaises(QueryError):
+            self.client.execute("INVALID SQL STATEMENT")
+
+    def test_result_set_operations(self):
+        """Test result set operations"""
+        result = self.client.execute(f"SELECT * FROM {self.test_table} ORDER BY id")
+
+        # Test fetchone
+        first_row = result.fetchone()
+        self.assertIsNotNone(first_row)
+        self.assertEqual(first_row[0], 1)
+
+        # Test fetchmany
+        next_rows = result.fetchmany(2)
+        self.assertEqual(len(next_rows), 2)
+        self.assertEqual(next_rows[0][0], 2)
+        self.assertEqual(next_rows[1][0], 3)
+
+        # Test fetchall (should return remaining rows)
+        remaining_rows = result.fetchall()
+        self.assertEqual(len(remaining_rows), 0)  # Should be empty
+
+        # Test column names
+        result = self.client.execute(f"SELECT id, name, value FROM {self.test_table} LIMIT 1")
+        columns = result.keys()
+        expected_columns = ['id', 'name', 'value']
+        self.assertEqual(list(columns), expected_columns)
+
+    def test_parameter_binding(self):
+        """Test parameter binding"""
+        # Test string parameters
+        result = self.client.execute(f"SELECT * FROM {self.test_table} WHERE name = ?", ('test1',))
+        rows = result.fetchall()
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0][1], 'test1')
+
+        # Test numeric parameters
+        result = self.client.execute(f"SELECT * FROM {self.test_table} WHERE value = ?", (200,))
+        rows = result.fetchall()
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0][2], 200)
+
+        # Test multiple parameters
+        result = self.client.execute(f"SELECT * FROM {self.test_table} WHERE name = ? AND value > ?", ('test2', 150))
+        rows = result.fetchall()
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0][1], 'test2')
+        self.assertEqual(rows[0][2], 200)
+
+    def test_connection_pooling(self):
+        """Test connection pooling and reuse"""
+        # Execute multiple queries to test connection reuse
+        for i in range(5):
+            result = self.client.execute("SELECT 1 as test")
+            rows = result.fetchall()
+            self.assertEqual(len(rows), 1)
+            self.assertEqual(rows[0][0], 1)
+
+        # Test concurrent-like operations
+        results = []
+        for i in range(3):
+            result = self.client.execute(f"SELECT COUNT(*) FROM {self.test_table}")
+            count = result.fetchone()[0]
+            results.append(count)
+
+        # All should return the same count
+        for count in results:
+            self.assertEqual(count, 3)
+
+
+if __name__ == '__main__':
+    unittest.main()