Added something new

Author: Peng Ren

.github/workflows/ci.yml

@@ -0,0 +1,89 @@
+name: CI Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
+    
+    services:
+      mongodb:
+        image: mongo:8.0
+        env:
+          MONGO_INITDB_ROOT_USERNAME: admin
+          MONGO_INITDB_ROOT_PASSWORD: secret
+        ports:
+          - 27017:27017
+        options: >-
+          --health-cmd "mongosh --eval 'db.runCommand({ping: 1})' --quiet"
+          --health-interval 30s
+          --health-timeout 10s
+          --health-retries 5
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Cache pip dependencies
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-py${{ matrix.python-version }}-pip-${{ hashFiles('**/requirements-test.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-py${{ matrix.python-version }}-pip-
+
+    - name: Install MongoDB shell
+      run: |
+        wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo apt-key add -
+        echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
+        sudo apt-get update
+        sudo apt-get install -y mongodb-mongosh
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements-test.txt
+
+    - name: Wait for MongoDB to be ready
+      run: |
+        echo "Waiting for MongoDB to be ready..."
+        for i in {1..30}; do
+          if mongosh --host localhost:27017 --username admin --password secret --authenticationDatabase admin --eval "db.runCommand({ping: 1})" --quiet; then
+            echo "MongoDB is ready!"
+            break
+          fi
+          echo "Attempt $i: MongoDB not ready yet, waiting..."
+          sleep 2
+        done
+
+    - name: Set up test database
+      run: |
+        echo "Setting up test database..."
+        python tests/mongo_test_helper.py setup || true
+
+    - name: Run tests
+      run: |
+        python -m pytest tests/ -v --tb=short
+
+    - name: Run tests with coverage
+      run: |
+        python -m pytest tests/ --cov=pymongosql --cov-report=term-missing --cov-report=xml
+
+    - name: Upload coverage reports
+      if: github.event_name == 'push' && secrets.CODECOV_TOKEN
+      uses: codecov/codecov-action@v3
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: ./coverage.xml
+        fail_ci_if_error: false

25

@@ -79,7 +79,9 @@ def arraysize(self) -> int:
 
     @arraysize.setter
     def arraysize(self, value: int) -> None:
-        if value <= 0 or value > self.DEFAULT_FETCH_SIZE:
+        if value <= 0:
+            raise ValueError("arraysize must be positive")
+        if value > self.DEFAULT_FETCH_SIZE:
             raise ProgrammingError(
                 f"MaxResults is more than maximum allowed length {self.DEFAULT_FETCH_SIZE}."
             )

pymongosql/common.py

@@ -1,19 +1,150 @@
 # -*- coding: utf-8 -*-
 import logging
-from typing import Optional, Type
+from typing import Optional, Type, Dict, Any, Union
+from urllib.parse import quote_plus
 
-from .error import NotSupportedError
+from pymongo import MongoClient
+from pymongo.database import Database
+from pymongo.collection import Collection
+from pymongo.errors import PyMongoError, ConnectionFailure
+
+from .error import NotSupportedError, DatabaseError, OperationalError
 from .common import BaseCursor
+from .cursor import Cursor
 
 _logger = logging.getLogger(__name__)
 
 
 class Connection:
+    """MongoDB connection wrapper that provides SQL-like interface"""
 
     def __init__(
         self,
+        host: str,
+        port: int,
+        database: str = None,
+        username: str = None,
+        password: str = None,
+        auth_source: str = None,
+        ssl: bool = None,
+        ssl_cert_reqs: str = None,
+        connection_timeout: int = None,
+        server_selection_timeout: int = None,
         **kwargs,
-    ) -> None: ...
+    ) -> None:
+        """Initialize MongoDB connection
+
+        Args:
+            host: MongoDB host (required)
+            port: MongoDB port (required)
+            database: Default database name (optional)
+            username: Username for authentication (optional)
+            password: Password for authentication (optional)
+            auth_source: Authentication database (optional)
+            ssl: Enable SSL (optional)
+            ssl_cert_reqs: SSL certificate requirements (optional)
+            connection_timeout: Connection timeout in ms (optional)
+            server_selection_timeout: Server selection timeout in ms (optional)
+            **kwargs: Additional PyMongo connection parameters
+        """
+        self._host = host
+        self._port = port
+        self._database_name = database
+        self._username = username
+        self._password = password
+        self._auth_source = auth_source
+        self._ssl = ssl
+        self._ssl_cert_reqs = ssl_cert_reqs
+        self._connection_timeout = connection_timeout
+        self._server_selection_timeout = server_selection_timeout
+
+        self._autocommit = True
+        self._in_transaction = False
+        self._client: Optional[MongoClient] = None
+        self._database: Optional[Database] = None
+        self.cursor_pool = []
+        self.cursor_class = Cursor
+        self.cursor_kwargs = kwargs
+
+        # Establish connection
+        self._connect()
+
+    def _connect(self) -> None:
+        """Establish connection to MongoDB"""
+        try:
+            # Build connection string
+            if self._username and self._password:
+                auth_string = (
+                    f"{quote_plus(self._username)}:{quote_plus(self._password)}@"
+                )
+            else:
+                auth_string = ""
+
+            connection_string = f"mongodb://{auth_string}{self._host}:{self._port}/"
+
+            # Connection options with defaults only when needed
+            options = {}
+
+            if self._connection_timeout is not None:
+                options["connectTimeoutMS"] = self._connection_timeout
+            if self._server_selection_timeout is not None:
+                options["serverSelectionTimeoutMS"] = self._server_selection_timeout
+            if self._ssl is not None:
+                options["ssl"] = self._ssl
+            if self._ssl_cert_reqs is not None:
+                options["ssl_cert_reqs"] = self._ssl_cert_reqs
+
+            if self._username and self._auth_source:
+                options["authSource"] = self._auth_source
+
+            # Create client
+            self._client = MongoClient(connection_string, **options)
+
+            # Test connection
+            self._client.admin.command("ping")
+
+            # Set database if specified
+            if self._database_name:
+                self._database = self._client[self._database_name]
+
+            _logger.info(
+                f"Successfully connected to MongoDB at {self._host}:{self._port}"
+            )
+
+        except ConnectionFailure as e:
+            _logger.error(f"Failed to connect to MongoDB: {e}")
+            raise OperationalError(f"Could not connect to MongoDB: {e}")
+        except Exception as e:
+            _logger.error(f"Unexpected error during connection: {e}")
+            raise DatabaseError(f"Database connection error: {e}")
+
+    @property
+    def client(self) -> MongoClient:
+        """Get the PyMongo client"""
+        if self._client is None:
+            raise OperationalError("No active connection")
+        return self._client
+
+    @property
+    def database(self) -> Database:
+        """Get the current database"""
+        if self._database is None:
+            raise OperationalError("No database selected")
+        return self._database
+
+    def use_database(self, database_name: str) -> None:
+        """Switch to a different database"""
+        if self._client is None:
+            raise OperationalError("No active connection")
+        self._database_name = database_name
+        self._database = self._client[database_name]
+        _logger.info(f"Switched to database: {database_name}")
+
+    def get_collection(self, collection_name: str) -> Collection:
+        """Get a collection from the current database"""
+        if self._database is None:
+            raise OperationalError("No database selected")
+        return self._database[collection_name]
 
     @property
     def autocommit(self) -> bool:
@@ -37,31 +168,107 @@ def in_transaction(self) -> bool:
     def in_transaction(self, value: bool) -> bool:
         self._in_transaction = False
 
+    @property
+    def host(self) -> str:
+        """Get the hostname"""
+        return self._host
+
+    @property
+    def port(self) -> int:
+        """Get the port number"""
+        return self._port
+
+    @property
+    def database_name(self) -> str:
+        """Get the database name"""
+        return self._database_name
+
+    @property
+    def username(self) -> str:
+        """Get the username"""
+        return self._username
+
+    @property
+    def password(self) -> str:
+        """Get the password"""
+        return self._password
+
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
+    @property
+    def is_connected(self) -> bool:
+        """Check if connected to MongoDB"""
+        return self._client is not None
+
+    @property
+    def database_instance(self):
+        """Get the database instance"""
+        return self._database
+
+    def disconnect(self) -> None:
+        """Disconnect from MongoDB (alias for close)"""
+        self.close()
+
+    def __str__(self) -> str:
+        """String representation of the connection"""
+        status = "connected" if self.is_connected else "disconnected"
+        return f"Connection(host={self._host}, port={self._port}, database={self._database_name}, status={status})"
+
     def cursor(self, cursor: Optional[Type[BaseCursor]] = None, **kwargs) -> BaseCursor:
         kwargs.update(self.cursor_kwargs)
         if not cursor:
             cursor = self.cursor_class
 
-        return cursor(
+        new_cursor = cursor(
             connection=self,
             **kwargs,
         )
+        self.cursor_pool.append(new_cursor)
+        return new_cursor
 
-    def close(self) -> None: ...
+    def close(self) -> None:
+        """Close the MongoDB connection"""
+        try:
+            # Close all cursors
+            for cursor in self.cursor_pool:
+                cursor.close()
+            self.cursor_pool.clear()
+
+            # Close client connection
+            if self._client:
+                self._client.close()
+                self._client = None
+                self._database = None
+
+            _logger.info("MongoDB connection closed")
+        except Exception as e:
+            _logger.error(f"Error closing connection: {e}")
 
     def begin(self) -> None:
         self._autocommit = False
         self._in_transaction = True
 
-    def commit(self) -> None: ...
+    def commit(self) -> None:
+        """Commit transaction (MongoDB doesn't support traditional transactions in the same way)"""
+        self._in_transaction = False
+        self._autocommit = True
 
     def rollback(self) -> None:
-        raise NotSupportedError
+        raise NotSupportedError(
+            "MongoDB doesn't support rollback in the traditional SQL sense"
+        )
 
-    def test_connection(self) -> bool: ...
+    def test_connection(self) -> bool:
+        """Test if the connection is alive"""
+        try:
+            if self._client:
+                self._client.admin.command("ping")
+                return True
+            return False
+        except Exception as e:
+            _logger.error(f"Connection test failed: {e}")
+            return False