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

tests/online/test_orm_cte_integration.py

@@ -0,0 +1,269 @@
+# 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 CTE (Common Table Expression) integration with MatrixOneQuery
+
+This test verifies that the new SQLAlchemy-style CTE support works correctly
+with MatrixOneQuery, including:
+- Creating CTEs from queries
+- Using CTEs in other queries
+- Multiple CTEs in a single query
+- CTE parameter handling
+"""
+
+import pytest
+from sqlalchemy import Column, Integer, String, create_engine, text
+from sqlalchemy.orm import sessionmaker
+
+from matrixone.client import Client
+from matrixone.orm import CTE, declarative_base
+
+Base = declarative_base()
+
+
+class User(Base):
+    __tablename__ = "cte_users"
+    id = Column(Integer, primary_key=True)
+    name = Column(String(50))
+    department = Column(String(50))
+    salary = Column(Integer)
+
+
+class Article(Base):
+    __tablename__ = "cte_articles"
+    id = Column(Integer, primary_key=True)
+    title = Column(String(100))
+    author_id = Column(Integer)
+    views = Column(Integer)
+
+
+class TestORMCTEIntegration:
+    """Test CTE integration with MatrixOneQuery"""
+
+    @pytest.fixture(autouse=True)
+    def setup_and_cleanup(self, connection_params, test_database):
+        """Setup test database and tables"""
+        host, port, user, password, database = connection_params
+        self.client = Client(host=host, port=port, user=user, password=password, database=database)
+        self.test_db = f"cte_test_db_{test_database}"
+
+        # Create test database
+        self.client.execute(f"CREATE DATABASE IF NOT EXISTS {self.test_db}")
+        self.client.execute(f"USE {self.test_db}")
+
+        # Create tables
+        self.client.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS {self.test_db}.cte_users (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                name VARCHAR(50),
+                department VARCHAR(50),
+                salary INT
+            )
+        """
+        )
+
+        self.client.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS {self.test_db}.cte_articles (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                title VARCHAR(100),
+                author_id INT,
+                views INT
+            )
+        """
+        )
+
+        # Insert test data
+        self.client.execute(
+            f"""
+            INSERT INTO {self.test_db}.cte_users (name, department, salary) VALUES
+            ('Alice', 'Engineering', 80000),
+            ('Bob', 'Engineering', 90000),
+            ('Charlie', 'Marketing', 70000),
+            ('Diana', 'Marketing', 75000),
+            ('Eve', 'Sales', 60000)
+        """
+        )
+
+        self.client.execute(
+            f"""
+            INSERT INTO {self.test_db}.cte_articles (title, author_id, views) VALUES
+            ('Python Tutorial', 1, 1000),
+            ('Database Design', 1, 800),
+            ('Marketing Strategy', 3, 600),
+            ('Sales Tips', 5, 400),
+            ('Advanced Python', 2, 1200)
+        """
+        )
+
+        yield
+
+        # Cleanup
+        try:
+            self.client.execute(f"DROP DATABASE IF EXISTS {self.test_db}")
+        except:
+            pass
+        # Client doesn't have close method, it's automatically managed
+
+    def test_basic_cte_creation(self):
+        """Test basic CTE creation from a query"""
+        # Create a CTE for high-salary users
+        high_salary_users = self.client.query(User).filter(User.salary > 75000).cte("high_salary_users")
+
+        # Verify CTE object properties
+        assert isinstance(high_salary_users, CTE)
+        assert high_salary_users.name == "high_salary_users"
+        assert high_salary_users.recursive == False
+
+        # Get SQL from CTE
+        cte_sql, cte_params = high_salary_users.as_sql()
+        assert "SELECT" in cte_sql
+        assert "cte_users" in cte_sql
+        assert "salary > 75000" in cte_sql
+
+    def test_cte_usage_in_query(self):
+        """Test using a CTE in another query"""
+        # Create CTE for engineering users
+        engineering_users = self.client.query(User).filter(User.department == "Engineering").cte("engineering_users")
+
+        # Use CTE in another query
+        result = self.client.query(engineering_users).all()
+
+        # Should return 2 users (Alice and Bob)
+        assert len(result) == 2
+        # Check that we got engineering users (Alice and Bob)
+        # Since we're querying from CTE, we get RowData objects with '*' attribute
+        # The actual data is in _values tuple: (id, name, department, salary)
+        names = [row._values[1] for row in result]  # name is at index 1
+        assert "Alice" in names
+        assert "Bob" in names
+
+    def test_multiple_ctes_in_query(self):
+        """Test using multiple CTEs in a single query"""
+        # Create first CTE: high-salary users
+        high_salary = self.client.query(User).filter(User.salary > 70000).cte("high_salary")
+
+        # Create second CTE: popular articles
+        popular_articles = self.client.query(Article).filter(Article.views > 500).cte("popular_articles")
+
+        # Use both CTEs in a query with with_cte method
+        result = (
+            self.client.query(high_salary)
+            .with_cte(popular_articles)
+            .join(popular_articles, onclause="high_salary.id = popular_articles.author_id")
+            .all()
+        )
+
+        # Should return users who have popular articles and high salary
+        assert len(result) >= 0  # At least Alice (high salary + popular articles)
+
+    def test_cte_with_aggregation(self):
+        """Test CTE with aggregation functions"""
+        # Create CTE with department statistics
+        dept_stats = self.client.query(User.department, User.salary).cte("dept_stats")
+
+        # Use CTE in aggregation query
+        result = self.client.query(dept_stats).all()
+
+        # Should return all department-salary combinations
+        assert len(result) == 5  # 5 users total
+
+    def test_recursive_cte_flag(self):
+        """Test recursive CTE flag"""
+        # Create a recursive CTE (even though we won't use recursion in this test)
+        recursive_cte = self.client.query(User).filter(User.id == 1).cte("recursive_users", recursive=True)
+
+        assert recursive_cte.recursive == True
+        assert recursive_cte.name == "recursive_users"
+
+    def test_cte_in_transaction(self):
+        """Test CTE usage within a transaction"""
+        with self.client.transaction() as tx:
+            # Create CTE within transaction
+            tx_users = tx.query(User).filter(User.department == "Marketing").cte("tx_users")
+
+            # Use CTE within transaction
+            result = tx.query(tx_users).all()
+
+            # Should return 2 marketing users
+            assert len(result) == 2
+            names = [row._values[1] for row in result]  # name is at index 1
+            assert all(name in ["Charlie", "Diana"] for name in names)
+
+    def test_cte_with_join(self):
+        """Test CTE with JOIN operations"""
+        # Create CTE for users with articles - select specific columns to avoid ambiguity
+        users_with_articles = (
+            self.client.query(User.id, User.name, User.department, User.salary)
+            .join("cte_articles", onclause="cte_users.id = cte_articles.author_id")
+            .cte("users_with_articles")
+        )
+
+        # Query from the CTE
+        result = self.client.query(users_with_articles).all()
+
+        # Should return users who have written articles
+        assert len(result) >= 0
+        # All returned users should have written at least one article
+
+    def test_cte_sql_generation(self):
+        """Test that CTE generates correct SQL"""
+        # Create a simple CTE
+        simple_cte = self.client.query(User.id, User.name).filter(User.salary > 80000).cte("simple_cte")
+
+        # Get the SQL
+        cte_sql, params = simple_cte.as_sql()
+
+        # Verify SQL structure
+        assert "SELECT" in cte_sql
+        assert "cte_users" in cte_sql
+        assert "id" in cte_sql
+        assert "name" in cte_sql
+        assert "salary > 80000" in cte_sql
+
+        # Use CTE in a query and check final SQL
+        query = self.client.query(simple_cte)
+        final_sql, final_params = query._build_sql()
+
+        # Should have WITH clause
+        assert "WITH simple_cte AS" in final_sql
+        assert "SELECT * FROM simple_cte" in final_sql
+
+    def test_cte_parameter_handling(self):
+        """Test that CTE parameters are handled correctly"""
+        # Create CTE with parameterized query
+        param_cte = self.client.query(User).filter(User.salary > 75000).cte("param_cte")  # This should generate a parameter
+
+        # Use CTE in query
+        result = self.client.query(param_cte).all()
+
+        # Should return high-salary users
+        assert len(result) == 2  # Alice and Bob
+        salaries = [row._values[3] for row in result]  # salary is at index 3
+        assert all(salary > 75000 for salary in salaries)
+
+    def test_cte_with_raw_sql(self):
+        """Test CTE creation with raw SQL string"""
+        # Create CTE with raw SQL
+        raw_cte = CTE("raw_cte", f"SELECT * FROM {self.test_db}.cte_users WHERE salary > 80000")
+
+        # Use in query
+        result = self.client.query(raw_cte).all()
+
+        # Should return high-salary users
+        assert len(result) == 1  # Only Bob
+        assert result[0]._values[1] == "Bob"  # name is at index 1
+        assert result[0]._values[3] > 80000  # salary is at index 3

tests/online/test_orm_online.py

@@ -0,0 +1,270 @@
+# 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 ORM functionality - tests actual database operations
+"""
+
+import pytest
+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 sqlalchemy import Column, Integer, String, DECIMAL
+
+# SQLAlchemy compatibility import
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from matrixone.orm import declarative_base
+
+Base = declarative_base()
+from matrixone.exceptions import QueryError
+from .test_config import online_config
+
+
+class User(Base):
+    """Test user model"""
+
+    __tablename__ = "test_users"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(100))
+    email = Column(String(100))
+    age = Column(Integer)
+
+
+class Product(Base):
+    """Test product model"""
+
+    __tablename__ = "test_products"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(100))
+    price = Column(DECIMAL(10, 2))
+    category = Column(String(50))
+
+
+class TestORMOnline:
+    """Online tests for ORM functionality"""
+
+    @pytest.fixture(scope="class")
+    def test_client(self):
+        """Create and connect Client for testing"""
+        host, port, user, password, database = online_config.get_connection_params()
+        client = Client()
+        client.connect(host=host, port=port, user=user, password=password, database=database)
+        try:
+            yield client
+        finally:
+            try:
+                client.disconnect()
+            except Exception as e:
+                print(f"Warning: Failed to disconnect client: {e}")
+
+    @pytest.fixture(scope="class")
+    def test_database(self, test_client):
+        """Set up test database and tables"""
+        test_db = "test_orm_db"
+
+        try:
+            test_client.execute(f"CREATE DATABASE IF NOT EXISTS {test_db}")
+            test_client.execute(f"USE {test_db}")
+
+            # Create test tables using SQLAlchemy models
+            Base.metadata.create_all(test_client._engine)
+
+            # Insert test data
+            test_client.execute(
+                """
+                INSERT INTO test_users VALUES 
+                (1, 'John Doe', 'john@example.com', 30),
+                (2, 'Jane Smith', 'jane@example.com', 25),
+                (3, 'Bob Johnson', 'bob@example.com', 35)
+            """
+            )
+
+            test_client.execute(
+                """
+                INSERT INTO test_products VALUES 
+                (1, 'Laptop', 999.99, 'Electronics'),
+                (2, 'Book', 19.99, 'Education'),
+                (3, 'Phone', 699.99, 'Electronics')
+            """
+            )
+
+            yield test_db
+
+        finally:
+            # Clean up
+            try:
+                test_client.execute(f"DROP DATABASE IF EXISTS {test_db}")
+            except Exception as e:
+                print(f"Cleanup failed: {e}")
+
+    def test_model_creation_and_attributes(self):
+        """Test model creation and attribute access"""
+        user = User(id=1, name="Test User", email="test@example.com", age=30)
+
+        assert user.id == 1
+        assert user.name == "Test User"
+        assert user.email == "test@example.com"
+        assert user.age == 30
+
+        # Test attribute access (SQLAlchemy models don't have to_dict by default)
+        assert hasattr(user, 'id')
+        assert hasattr(user, 'name')
+        assert hasattr(user, 'email')
+        assert hasattr(user, 'age')
+
+    def test_model_table_creation(self):
+        """Test creating tables from models"""
+        # This test verifies that the model metadata is correctly set up
+        assert User.__tablename__ == "test_users"
+        assert Product.__tablename__ == "test_products"
+
+        # Check that columns are properly defined
+        assert hasattr(User, '__table__')
+        assert 'id' in [col.name for col in User.__table__.columns]
+        assert 'name' in [col.name for col in User.__table__.columns]
+        assert 'email' in [col.name for col in User.__table__.columns]
+        assert 'age' in [col.name for col in User.__table__.columns]
+
+    def test_orm_query_basic_operations(self, test_client, test_database):
+        """Test basic ORM query operations"""
+        # Test all() method
+        users = test_client.query(User).all()
+        assert len(users) == 3
+
+        # Test first() method
+        first_user = test_client.query(User).first()
+        assert first_user is not None
+        assert isinstance(first_user, User)
+
+        # Test filter_by() method
+        john = test_client.query(User).filter_by(name="John Doe").first()
+        assert john is not None
+        assert john.name == "John Doe"
+        assert john.email == "john@example.com"
+
+    def test_orm_query_filtering(self, test_client, test_database):
+        """Test ORM query filtering"""
+        # Test filter_by with multiple conditions
+        electronics = test_client.query(Product).filter_by(category="Electronics").all()
+        assert len(electronics) == 2
+
+        # Test filter() method with conditions
+        expensive_products = test_client.query(Product).filter("price > ?", 500).all()
+        assert len(expensive_products) == 2
+
+        # Test combined filtering
+        expensive_electronics = test_client.query(Product).filter_by(category="Electronics").filter("price > ?", 500).all()
+        assert len(expensive_electronics) == 2
+
+    def test_orm_query_counting(self, test_client, test_database):
+        """Test ORM query counting"""
+        # Test count() method
+        total_users = test_client.query(User).count()
+        assert total_users == 3
+
+        # Test count() with filter
+        electronics_count = test_client.query(Product).filter_by(category="Electronics").count()
+        assert electronics_count == 2
+
+        # Test count() with complex filter
+        expensive_count = test_client.query(Product).filter("price > ?", 500).count()
+        assert expensive_count == 2
+
+    def test_orm_query_ordering(self, test_client, test_database):
+        """Test ORM query ordering"""
+        from matrixone.orm import desc
+
+        # Test order_by ascending (default)
+        users_asc = test_client.query(User).order_by("age").all()
+        assert len(users_asc) == 3
+        assert users_asc[0].age <= users_asc[1].age <= users_asc[2].age
+
+        # Test order_by descending
+        users_desc = test_client.query(User).order_by(desc("age")).all()
+        assert len(users_desc) == 3
+        assert users_desc[0].age >= users_desc[1].age >= users_desc[2].age
+
+    def test_orm_query_limiting(self, test_client, test_database):
+        """Test ORM query limiting"""
+        # Test limit()
+        limited_users = test_client.query(User).limit(2).all()
+        assert len(limited_users) == 2
+
+        # Test limit() with order_by
+        top_users = test_client.query(User).order_by("age").limit(1).all()
+        assert len(top_users) == 1
+        assert top_users[0].age == 25  # Youngest user
+
+    def test_orm_model_instantiation(self, test_client, test_database):
+        """Test model instantiation from query results"""
+        # Get a user from database
+        user = test_client.query(User).filter_by(name="John Doe").first()
+        assert user is not None
+        assert isinstance(user, User)
+        assert user.id == 1
+        assert user.name == "John Doe"
+        assert user.email == "john@example.com"
+        assert user.age == 30
+
+        # Test that we can access all attributes
+        assert hasattr(user, 'id')
+        assert hasattr(user, 'name')
+        assert hasattr(user, 'email')
+        assert hasattr(user, 'age')
+
+    def test_orm_error_handling(self, test_client, test_database):
+        """Test ORM error handling"""
+        # Test querying non-existent table
+        with pytest.raises(QueryError):
+            test_client.query(User).filter("invalid_column = ?", "value").all()
+
+        # Test invalid filter syntax
+        with pytest.raises(QueryError):
+            test_client.query(User).filter("invalid_syntax").all()
+
+    def test_orm_complex_queries(self, test_client, test_database):
+        """Test complex ORM queries"""
+        # Test multiple filters
+        result = (
+            test_client.query(Product)
+            .filter_by(category="Electronics")
+            .filter("price > ?", 500)
+            .order_by("price")
+            .limit(1)
+            .all()
+        )
+
+        assert len(result) == 1
+        assert result[0].category == "Electronics"
+        assert result[0].price > 500
+
+        # Test chaining multiple operations
+        users = test_client.query(User).filter("age > ?", 25).order_by("age").limit(2).all()
+
+        assert len(users) == 2
+        assert all(user.age > 25 for user in users)
+        assert users[0].age <= users[1].age  # Should be ordered by age
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])