fastmssql 0.5.0__cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

fastmssql/__init__.py

@@ -0,0 +1,66 @@
+"""FastMSSQL - High-Performance Microsoft SQL Server Driver for Python
+
+High-performance Rust-backed Python driver for SQL Server with async/await support,
+connection pooling, SSL/TLS encryption, and parameterized queries.
+"""
+
+# Import from the compiled Rust module
+from .fastmssql import (
+    Connection as _RustConnection,
+    PoolConfig,
+    SslConfig,
+    FastExecutionResult,
+    FastRow,
+    Parameter,
+    Parameters,
+    EncryptionLevel,
+    version,
+)
+
+
+class Connection:
+    """Thin wrapper to fix async context manager behavior."""
+    
+    def __init__(self, *args, **kwargs):
+        self._conn = _RustConnection(*args, **kwargs)
+    
+    def __getattr__(self, name):
+        return getattr(self._conn, name)
+    
+    async def __aenter__(self):
+        await self._conn.__aenter__()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self._conn.__aexit__(exc_type, exc_val, exc_tb)
+    
+    async def pool_stats(self):
+        """Get connection pool statistics and convert tuple to dict."""
+        result_tuple = await self._conn.pool_stats()
+        
+        # Convert tuple to dictionary
+        connected, connections, idle_connections, max_size, min_idle = result_tuple
+        
+        if connected:
+            return {
+                'connections': connections,
+                'idle_connections': idle_connections,
+                'max_size': max_size,
+                'min_idle': min_idle,
+                'active_connections': connections - idle_connections,
+            }
+        else:
+            return {'connected': False}
+
+
+__all__ = [
+    "Connection",
+    "PoolConfig",
+    "SslConfig",
+    "FastExecutionResult",
+    "FastRow",
+    "Parameter",
+    "Parameters",
+    "EncryptionLevel",
+    "version",
+]

fastmssql-0.5.0.dist-info/METADATA

@@ -0,0 +1,415 @@
+Metadata-Version: 2.4
+Name: fastmssql
+Version: 0.5.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: pytest>=8.4.2 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.2.0 ; extra == 'dev'
+Requires-Dist: psutil>=7.1.1 ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Summary: A high-performance async Python library for Microsoft SQL Server built on Rust for heavy workloads and low latency.
+Keywords: mssql,sqlserver,sql-server,database,async,asynchronous,rust,python,driver,client,pooling,high-performance,bulk-insert,batch,tokio,bb8,pyO3,cross-platform,windows,linux,macos,ssl,tls,connection-pool,data-ingestion,low-latency
+Author-email: Rivendael <riverb514@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Rivendael/FastMssql
+Project-URL: Repository, https://github.com/Rivendael/FastMssql
+Project-URL: Bug Tracker, https://github.com/Rivendael/FastMssql/issues
+Project-URL: Documentation, https://github.com/Rivendael/FastMssql#readme
+
+# FastMSSQL ⚡
+
+FastMSSQL is an async Python library for Microsoft SQL Server (MSSQL), built in Rust.
+Unlike standard libaries, it uses a native SQL Server client—no ODBC required—simplifying installation on Windows, macOS, and Linux.
+Great for data ingestion, bulk inserts, and large-scale query workloads.
+
+[![Python Versions](https://img.shields.io/pypi/pyversions/fastmssql)](https://pypi.org/project/fastmssql/)
+
+[![License](https://img.shields.io/badge/license-MIT%20-green)](LICENSE)
+
+[![Unit Tests](https://github.com/Rivendael/fastmssql/actions/workflows/unittests.yml/badge.svg)](https://github.com/Rivendael/fastmssql/actions/workflows/build.yml)
+
+[![Latest Release](https://img.shields.io/github/v/release/Rivendael/fastmssql)](https://github.com/Rivendael/fastmssql/releases)
+
+[![Platform](https://img.shields.io/badge/platform-Windows%20|%20Linux%20|%20macOS-lightgrey)](https://github.com/Rivendael/fastmssql)
+
+[![Rust Backend](https://img.shields.io/badge/backend-rust-orange)](https://github.com/Rivendael/pymssql-rs)
+
+## Features
+
+- High performance: optimized for very high RPS and low overhead
+- Rust core: memory‑safe and reliable, tuned Tokio runtime
+- No ODBC: native SQL Server client, no external drivers needed
+- Connection pooling: bb8‑based, smart defaults (default max_size=10, min_idle=2)
+- Async first: clean async/await API with `async with` context managers
+- Strong typing: fast conversions for common SQL Server types
+- Thread‑safe: safe to use in concurrent apps
+- Cross‑platform: Windows, macOS, Linux
+- Batch operations: high-performance bulk inserts and batch query execution
+
+
+## Key API methods
+
+Core methods for individual operations:
+
+- `query()` — SELECT statements that return rows
+- `execute()` — INSERT/UPDATE/DELETE/DDL that return affected row count
+
+```python
+# Use query() for SELECT statements
+result = await conn.query("SELECT * FROM users WHERE age > @P1", [25])
+rows = result.rows()
+
+# Use execute() for data modification
+affected = await conn.execute("INSERT INTO users (name) VALUES (@P1)", ["John"])
+```
+
+
+## Installation
+
+### From PyPI (recommended)
+
+```bash
+pip install fastmssql
+```
+
+### Prerequisites
+
+- Python 3.10 to 3.14
+- Microsoft SQL Server (any recent version)
+
+## Quick start
+
+### Basic async usage
+
+```python
+import asyncio
+from fastmssql import Connection
+
+async def main():
+    conn_str = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
+    async with Connection(conn_str) as conn:
+        # SELECT: use query() -> rows()
+        result = await conn.query("SELECT @@VERSION as version")
+        for row in result.rows():
+            print(row['version'])
+
+        # Pool statistics (tuple: connected, connections, idle, max_size, min_idle)
+        connected, connections, idle, max_size, min_idle = await conn.pool_stats()
+        print(f"Pool: connected={connected}, size={connections}/{max_size}, idle={idle}, min_idle={min_idle}")
+
+asyncio.run(main())
+```
+
+## Explicit Connection Management
+
+When not utilizing Python's context manager (async with), **FastMssql** uses *lazy connection initialization*:  
+if you call `query()` or `execute()` on a new `Connection`, the underlying pool is created if not already present. 
+
+For more control, you can explicitly connect and disconnect:
+
+```python
+import asyncio
+from fastmssql import Connection
+
+async def main():
+    conn_str = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
+    conn = Connection(conn_str)
+
+    # Explicitly connect
+    await conn.connect()
+    assert await conn.is_connected()
+
+    # Run queries
+    result = await conn.query("SELECT 42 as answer")
+    print(result.rows()[0]["answer"])  # -> 42
+
+    # Explicitly disconnect
+    await conn.disconnect()
+    assert not await conn.is_connected()
+    
+asyncio.run(main())
+```
+## Usage
+
+### Connection options
+
+You can connect either with a connection string or individual parameters.
+
+1) Connection string
+
+```python
+import asyncio
+from fastmssql import Connection
+
+async def main():
+    conn_str = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
+    async with Connection(connection_string=conn_str) as conn:
+        rows = (await conn.query("SELECT DB_NAME() as db")).rows()
+        print(rows[0]['db'])
+
+asyncio.run(main())
+```
+
+2) Individual parameters
+
+```python
+import asyncio
+from fastmssql import Connection
+
+async def main():
+    async with Connection(
+        server="localhost",
+        database="master",
+        username="myuser",
+        password="mypassword"
+    ) as conn:
+        rows = (await conn.query("SELECT SUSER_SID() as sid")).rows()
+        print(rows[0]['sid'])
+
+asyncio.run(main())
+```
+
+Note: Windows authentication (Trusted Connection) is currently not supported. Use SQL authentication (username/password).
+
+
+### Working with data
+
+```python
+import asyncio
+from fastmssql import Connection
+
+async def main():
+    async with Connection("Server=.;Database=MyDB;User Id=sa;Password=StrongPwd;") as conn:
+        # SELECT (returns rows)
+        users = (await conn.query(
+            "SELECT id, name, email FROM users WHERE active = 1"
+        )).rows()
+        for u in users:
+            print(f"User {u['id']}: {u['name']} ({u['email']})")
+
+        # INSERT / UPDATE / DELETE (returns affected row count)
+        inserted = await conn.execute(
+            "INSERT INTO users (name, email) VALUES (@P1, @P2)",
+            ["Jane", "jane@example.com"],
+        )
+        print(f"Inserted {inserted} row(s)")
+
+        updated = await conn.execute(
+            "UPDATE users SET last_login = GETDATE() WHERE id = @P1",
+            [123],
+        )
+        print(f"Updated {updated} row(s)")
+
+asyncio.run(main())
+```
+
+Parameters use positional placeholders: `@P1`, `@P2`, ... Provide values as a list in the same order.
+
+
+### Batch operations
+
+For high-throughput scenarios, use batch methods to reduce network round-trips:
+
+```python
+import asyncio
+from fastmssql import Connection
+
+async def main_fetching():
+    # Replace with your actual connection string
+    async with Connection("Server=.;Database=MyDB;User Id=sa;Password=StrongPwd;") as conn:
+        
+        # --- 1. Prepare Data for Demonstration ---
+        columns = ["name", "email", "age"]
+        data_rows = [
+            ["Alice Johnson", "alice@example.com", 28],
+            ["Bob Smith", "bob@example.com", 32],
+            ["Carol Davis", "carol@example.com", 25],
+            ["David Lee", "david@example.com", 35],
+            ["Eva Green", "eva@example.com", 29]
+        ]
+        await conn.bulk_insert("users", columns, data_rows)
+
+        # --- 2. Execute Query and Retrieve the Result Object ---
+        print("\n--- Result Object Fetching (fetchone, fetchmany, fetchall) ---")
+        
+        # The Result object is returned after the awaitable query executes.
+        result = await conn.query("SELECT name, age FROM users ORDER BY age DESC")
+        
+        # fetchone(): Retrieves the next single row synchronously.
+        oldest_user = result.fetchone() 
+        if oldest_user:
+            print(f"1. fetchone: Oldest user is {oldest_user['name']} (Age: {oldest_user['age']})")
+        
+        # fetchmany(2): Retrieves the next set of rows synchronously.
+        next_two_users = result.fetchmany(2)
+        print(f"2. fetchmany: Retrieved {len(next_two_users)} users: {[r['name'] for r in next_two_users]}.")
+        
+        # fetchall(): Retrieves all remaining rows synchronously.
+        remaining_users = result.fetchall()
+        print(f"3. fetchall: Retrieved all {len(remaining_users)} remaining users: {[r['name'] for r in remaining_users]}.")
+        
+        # Exhaustion Check: Subsequent calls return None/[]
+        print(f"4. Exhaustion Check (fetchone): {result.fetchone()}")
+        print(f"5. Exhaustion Check (fetchmany): {result.fetchmany(1)}")
+
+        # --- 3. Batch Commands for multiple operations ---
+        print("\n--- Batch Commands (execute_batch) ---")
+        commands = [
+            ("UPDATE users SET last_login = GETDATE() WHERE name = @P1", ["Alice Johnson"]),
+            ("INSERT INTO user_logs (action, user_name) VALUES (@P1, @P2)", ["login", "Alice Johnson"])
+        ]
+        
+        affected_counts = await conn.execute_batch(commands)
+        print(f"Updated {affected_counts[0]} users, inserted {affected_counts[1]} logs")
+        
+asyncio.run(main_fetching())
+```
+
+### Connection pooling
+
+Tune the pool to fit your workload. Constructor signature:
+
+```python
+from fastmssql import PoolConfig
+
+# PoolConfig(max_size=10, min_idle=2, max_lifetime_secs=None, idle_timeout_secs=None, connection_timeout_secs=30)
+config = PoolConfig(
+    max_size=20,              # max connections in pool
+    min_idle=5,               # keep at least this many idle
+    max_lifetime_secs=3600,   # recycle connections after 1h
+    idle_timeout_secs=600,    # close idle connections after 10m
+    connection_timeout_secs=30
+)
+```
+
+Presets:
+
+```python
+one.  = PoolConfig.one()                     # ~ max_size=1, min_idle=1
+low   = PoolConfig.low_resource()            # ~ max_size=3,   min_idle=1
+dev   = PoolConfig.development()             # ~ max_size=5,   min_idle=1
+high  = PoolConfig.high_throughput()         # ~ max_size=50,  min_idle=15
+maxp  = PoolConfig.performance()             # ~ max_size=100, min_idle=30
+```
+
+Apply to a connection:
+
+```python
+async with Connection(conn_str, pool_config=high) as conn:
+    rows = (await conn.query("SELECT 1 AS ok")).rows()
+```
+
+Default pool (if omitted): `max_size=10`, `min_idle=2`.
+
+
+### SSL/TLS
+
+For `Required` and `LoginOnly` encryption, you must specify how to validate the server certificate:
+
+**Option 1: Trust Server Certificate** (development/self-signed certs):
+```python
+from fastmssql import SslConfig, EncryptionLevel, Connection
+
+ssl = SslConfig(
+    encryption_level=EncryptionLevel.Required,
+    trust_server_certificate=True
+)
+
+async with Connection(conn_str, ssl_config=ssl) as conn:
+    ...
+```
+
+**Option 2: Custom CA Certificate** (production):
+```python
+from fastmssql import SslConfig, EncryptionLevel, Connection
+
+ssl = SslConfig(
+    encryption_level=EncryptionLevel.Required,
+    ca_certificate_path="/path/to/ca-cert.pem"
+)
+
+async with Connection(conn_str, ssl_config=ssl) as conn:
+    ...
+```
+
+**Note**: `trust_server_certificate` and `ca_certificate_path` are mutually exclusive.
+
+Helpers:
+
+- `SslConfig.development()` – encrypt, trust all (dev only)
+- `SslConfig.with_ca_certificate(path)` – use custom CA
+- `SslConfig.login_only()` / `SslConfig.disabled()` – legacy modes
+- `SslConfig.disabled()` – no encryption (not recommended)
+
+
+## Performance tips
+
+For maximum throughput in highly concurrent scenarios, use multiple `Connection` instances (each with its own pool) and batch your work:
+
+```python
+import asyncio
+from fastmssql import Connection, PoolConfig
+
+async def worker(conn_str, cfg):
+    async with Connection(conn_str, pool_config=cfg) as conn:
+        for _ in range(1000):
+            _ = (await conn.query("SELECT 1 as v")).rows()
+
+async def main():
+    conn_str = "Server=.;Database=master;User Id=sa;Password=StrongPwd;"
+    cfg = PoolConfig.high_throughput()
+    await asyncio.gather(*[asyncio.create_task(worker(conn_str, cfg)) for _ in range(32)])
+
+asyncio.run(main())
+```
+
+
+## Examples & benchmarks
+
+- Examples: `examples/comprehensive_example.py`
+- Benchmarks: `benchmarks/`
+
+
+## Troubleshooting
+
+- Import/build: ensure Rust toolchain and `maturin` are installed if building from source
+- Connection: verify connection string; Windows auth not supported
+- Timeouts: increase pool size or tune `connection_timeout_secs`
+- Parameters: use `@P1, @P2, ...` and pass a list of values
+
+
+## Contributing
+
+Contributions are welcome. Please open an issue or PR.
+
+
+## License
+
+FastMSSQL is licensed under MIT:
+
+See the [LICENSE](LICENSE) file for details.
+
+## Third‑party attributions
+
+Built on excellent open source projects: Tiberius, PyO3, pyo3‑asyncio, bb8, tokio, serde, pytest, maturin, and more. See `licenses/NOTICE.txt` for the full list. The full texts of Apache‑2.0 and MIT are in `licenses/`.
+
+
+## Acknowledgments
+
+Thanks to the maintainers of Tiberius, PyO3, pyo3‑asyncio, Tokio, pytest, maturin, and the broader open source community.

fastmssql-0.5.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+fastmssql-0.5.0.dist-info/METADATA,sha256=4KxzPnFJ_hIlepKELDUdT9QrapmgeaSTcrSQrB7BQtE,14059
+fastmssql-0.5.0.dist-info/WHEEL,sha256=X_Cce7mIV5wGTHIl0EkW0q8IpVi433Ij5ILty3Nzqfk,145
+fastmssql-0.5.0.dist-info/licenses/LICENSE,sha256=CWJTVQpPm5xURNm1EgddZQllDC7KDdgMfE_lY4n5Ows,1065
+fastmssql/__init__.py,sha256=8J1RvUa8coOP7Rkhdk-DkWQwrmE6xDMzmOSnAf6MohQ,1792
+fastmssql/fastmssql.abi3.so,sha256=OgVWx2ABXvn3QZVPnH4chHYVOw0XIFRwuh7j8E5phOM,2607040
+fastmssql-0.5.0.dist-info/RECORD,,

fastmssql-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp310-abi3-manylinux_2_17_x86_64
+Tag: cp310-abi3-manylinux2014_x86_64

fastmssql-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rivendael
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.