fastmssql 0.2.4__cp39-cp39-win_amd64.whl → 0.2.7__cp39-cp39-win_amd64.whl

{fastmssql-0.2.4.dist-info → fastmssql-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmssql
-Version: 0.2.4
+Version: 0.2.7
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: Other/Proprietary License
@@ -29,59 +29,57 @@ Project-URL: Homepage, https://github.com/Rivendael/pymssql-rs
 
 # Fastmssql ⚡
 
-A **blazingly fast** Python library for Microsoft SQL Server that delivers **significant performance improvements** over standard libraries. Built with Rust using the [Tiberius](https://github.com/prisma/tiberius) driver, [PyO3](https://github.com/PyO3/pyo3), and [bb8](https://github.com/djc/bb8) connection pooling.
+A Python library for Microsoft SQL Server built with Rust using the [Tiberius](https://github.com/prisma/tiberius) driver, [PyO3](https://github.com/PyO3/pyo3), and [bb8](https://github.com/djc/bb8) connection pooling.
 
-> **🚀 Performance Highlight**: Achieves **3,493 requests/second** and **0.08 KB memory per query** in our benchmarks
-
-[![Performance](https://img.shields.io/badge/Performance-3493_RPS-brightgreen)](https://github.com/Rivendael/pymssql-rs)
-[![Memory](https://img.shields.io/badge/Memory-0.08_KB/query-blue)](https://github.com/Rivendael/pymssql-rs)
-[![Speed](https://img.shields.io/badge/Speed-High_Performance-orange)](https://github.com/Rivendael/pymssql-rs)
 [![Language](https://img.shields.io/badge/Language-Rust_Backend-red)](https://github.com/Rivendael/pymssql-rs)
 [![Async](https://img.shields.io/badge/Async-Native_Tokio-blue)](https://github.com/Rivendael/pymssql-rs)
+[![Performance](https://img.shields.io/badge/Performance-17%2C800%2B_RPS-brightgreen)](https://github.com/Rivendael/pymssql-rs)
 
 ## Features
 
-- **High Performance**: Built with Rust for memory safety and speed
+- **High Performance**: Exceptional throughput with 17,800+ RPS capability
+- **Rust-Powered Backend**: Built with Rust for memory safety and reliability
 - **No ODBC Required**: Direct native SQL Server connection without ODBC drivers
-- **Connection Pooling**: Advanced bb8-based connection pool for optimal performance
-- **Async-Only Design**: Built on Tokio for excellent concurrency with clean async/await API
+- **Connection Pooling**: Intelligent bb8-based connection pooling (default: 75 max, 25 min idle)
+- **Async-Only Design**: Built on Tokio with clean async/await API
 - **Context Managers**: Automatic resource management with `async with`
 - **Type Safety**: Strong typing with automatic Python type conversion
-- **Thread Safety**: Full support for concurrent operations
+- **Thread Safety**: Support for concurrent operations
 - **Cross-Platform**: Works on Windows, macOS, and Linux
 - **Simple API**: Clean, intuitive async-only interface
 
-## ⚡ Performance
-
-Fastmssql delivers **excellent performance** that outperforms standard Python SQL Server libraries in our testing:
-
-### 🚀 Benchmark Results
+## Performance Highlights
 
-| Library | RPS (Requests/Second) | Performance vs fastmssql |
-|---------|----------------------|--------------------------|
-| **fastmssql** | **3,493** | **Baseline** |
-| Other Python libraries | ~300-600* | **5-11x slower** |
+Fastmssql delivers exceptional database performance through Rust-powered architecture:
 
-*Benchmarks performed with 20 concurrent workers executing `SELECT @@VERSION` queries on our test environment. Performance of other libraries may vary based on configuration, environment, and specific use cases. We recommend conducting your own benchmarks for your specific requirements.*
+- **Outstanding Throughput**: Up to **17,800+ RPS** with multiple connection pattern
+- **High Performance**: **5,000+ RPS** with single connection (default usage)
+- **Low Latency**: ~2ms average query latency under high load
+- **Scalable Architecture**: Linear scaling with multiple connection objects
+- **Production Ready**: Stable API with comprehensive error handling
+- **Connection Pooling**: Efficient resource management with configurable pools
+- **Type Conversion**: Automatic conversion between SQL Server and Python types
+- **SSL/TLS Support**: Secure connections with flexible encryption options
 
-### 🧠 Memory Efficiency
+### Performance Benchmarks
 
-Fastmssql delivers **exceptional memory efficiency** with minimal overhead:
+| Pattern | RPS | Configuration | Use Case |
+|---------|-----|---------------|----------|
+| Single Connection (Default) | **5,000+** | Default pool (75/25) | Standard applications |
+| Multiple Connections | **17,800+** | 50 workers, high_throughput() | High-concurrency scenarios |
+| Conservative Load | 3,500+ | Shared connection | Traditional pooling |
 
-| Metric | Value | Description |
-|--------|-------|-------------|
-| **Per Query Overhead** | **0.08 KB** | Memory used per database query |
-| **Concurrent Overhead** | **3.52 KB** | Memory per concurrent operation |
-| **Connection Pool** | **5.26 MB** | One-time pool initialization |
-| **Memory Leaks** | **None** | Actually reduces memory over time |
+**Benchmark Environment:**
+- Database: SQL Server (local instance)
+- Query: `SELECT 1` (minimal overhead)  
+- Test Duration: 15-30 seconds per test
+- Hardware: Modern development machine
 
-**Memory Efficiency Highlights:**
-- **12,800 queries per MB** of memory overhead
-- **Zero memory leaks** - memory usage decreases over time
-- **100-1000x more efficient** than libraries without connection pooling
-- **Stable memory usage** under high concurrent load
-
-*Traditional Python SQL Server libraries typically use 50-200 KB per operation due to connection overhead and lack of efficient pooling.*
+**Key Performance Insights:**
+1. **Multiple Connection Objects**: Creating separate `Connection()` objects eliminates serialization bottlenecks
+2. **Pool Configuration**: Use `PoolConfig.high_throughput()` for demanding workloads
+3. **Optimal Worker Count**: 30-50 concurrent workers provides best throughput
+4. **Tokio Optimization**: Aggressive threading configuration maximizes async performance
 
 ## Installation
 
@@ -115,8 +113,6 @@ cd mssql-python-rust
 
 ## Quick Start
 
-> **💡 Performance Tip**: Always reuse `Connection` objects! Each `Connection` manages a connection pool, so creating multiple `Connection` instances defeats the purpose of pooling and hurts performance. Create one `Connection` per database and reuse it throughout your application.
-
 ### Basic Async Usage (Recommended)
 
 ```python
@@ -185,6 +181,40 @@ async def main():
 asyncio.run(main())
 ```
 
+### Performance Patterns
+
+For maximum performance in high-concurrency scenarios, create multiple Connection objects:
+
+```python
+import asyncio
+from fastmssql import Connection, PoolConfig
+
+async def high_performance_pattern():
+    """Optimal pattern for maximum throughput."""
+    connection_string = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
+    config = PoolConfig.high_throughput()  # Optimized settings
+    
+    async def worker():
+        # Each worker gets its own Connection object for maximum throughput
+        async with Connection(connection_string, pool_config=config) as conn:
+            for _ in range(1000):
+                # Use proper SQL Server parameterization with @param syntax
+                result = await conn.execute("SELECT data FROM my_table WHERE id = @id", {"id": 123})
+                # Process results...
+    
+    # Launch multiple workers - each with their own connection
+    workers = [asyncio.create_task(worker()) for _ in range(50)]
+    await asyncio.gather(*workers)
+    
+    # This pattern can achieve 17,800+ RPS
+
+asyncio.run(high_performance_pattern())
+```
+
+**Key Performance Insight**: While a single Connection object provides excellent performance (5,000+ RPS), 
+creating multiple Connection objects eliminates serialization bottlenecks and can achieve 17,800+ RPS 
+for maximum throughput scenarios.
+
 ### Connection Pool Configuration
 
 Configure the connection pool for your specific needs:
@@ -206,95 +236,29 @@ async def main():
     async with Connection(connection_string, pool_config) as conn:
         result = await conn.execute("SELECT * FROM users")
         
-    # Predefined configurations for common scenarios
-    high_throughput_config = PoolConfig.high_throughput()  # 20 connections, optimized for load
-    low_resource_config = PoolConfig.low_resource()        # 3 connections, minimal resources  
-    dev_config = PoolConfig.development()                  # 5 connections, shorter timeouts
-
-asyncio.run(main())
-```
-
-### 🔥 Maximum Performance Configuration
-
-For applications requiring **extreme performance**, use the high-throughput configuration:
-
-```python
-import asyncio
-from fastmssql import Connection, PoolConfig
-
-async def main():
-    # Maximum performance setup
-    extreme_config = PoolConfig.high_throughput()  # Optimized for 3000+ RPS
+    # Predefined configurations for different scenarios
+    high_throughput_config = PoolConfig.high_throughput()     # 100 connections, optimized for high RPS
+    maximum_performance = PoolConfig.maximum_performance()     # 150 connections, optimized for peak load
+    low_resource_config = PoolConfig.low_resource()           # 3 connections, minimal resources  
+    dev_config = PoolConfig.development()                     # 5 connections, shorter timeouts
+
+    # Default configuration is optimized for high performance
+    # Default: max_size=75, min_idle=25 - ready for production workloads
     
-    async with Connection(connection_string, extreme_config) as conn:
-        # This setup achieves 3,493 RPS in benchmarks
-        
-        # Concurrent workers for maximum throughput
-        async def worker():
-            result = await conn.execute("SELECT @@VERSION")
+    # For maximum throughput, use multiple Connection objects:
+    async def high_perf_worker():
+        async with Connection(connection_string, maximum_performance) as conn:
+            result = await conn.execute("SELECT * FROM fast_table")
             return result.rows()
-        
-        # Run 20 concurrent workers
-        tasks = [worker() for _ in range(20)]
-        results = await asyncio.gather(*tasks)
-        
-        # Pool monitoring
-        stats = await conn.pool_stats()
-        print(f"Pool utilization: {stats['active_connections']}/{stats['max_size']}")
+    
+    # Each worker gets its own connection for optimal performance
+    tasks = [asyncio.create_task(high_perf_worker()) for _ in range(50)]
+    results = await asyncio.gather(*tasks)
 
 asyncio.run(main())
 ```
 
-**Performance Tips:**
-- **Reuse Connection objects**: Create one `Connection` per database and reuse it across your application
-- Use `PoolConfig.high_throughput()` for maximum RPS
-- Leverage `asyncio.gather()` for concurrent operations  
-- Monitor pool stats to optimize connection count
-- Consider connection lifetime for long-running applications
 
-**⚠️ Performance Anti-Pattern:**
-```python
-# DON'T DO THIS - Creates new pool for each operation
-async def bad_example():
-    async with Connection(conn_str) as conn:  # New pool created
-        return await conn.execute("SELECT 1")
-    
-    async with Connection(conn_str) as conn:  # Another new pool created
-        return await conn.execute("SELECT 2")
-```
-
-**✅ Correct Pattern:**
-```python
-# DO THIS - Reuse the same connection pool
-async def good_example():
-    async with Connection(conn_str) as conn:  # Single pool created
-        result1 = await conn.execute("SELECT 1")
-        result2 = await conn.execute("SELECT 2")  # Reuses same pool
-        return result1, result2
-```
-
-### Connection Pool Benefits
-
-The bb8 connection pool provides significant performance improvements over traditional Python libraries:
-
-| Metric | Traditional Python | fastmssql | Improvement |
-|--------|-------------------|-----------|-------------|
-| **Connection Setup** | 50ms | 0.1ms | **500x faster** |
-| **Memory per Query** | 50-200 KB | 0.08 KB | **625-2500x less** |
-| **10 Concurrent Queries** | 500ms | 150ms | **3.3x faster** |
-| **100 Concurrent Queries** | 5000ms | 400ms | **12.5x faster** |
-| **1000 Concurrent Queries** | Timeouts/Errors | 2.9s | **Stable** |
-| **Memory Leaks** | Common | None | **Zero leaks** |
-
-**Key Benefits:**
-- **Connection Reuse**: Eliminates connection establishment overhead (500x improvement)
-- **Memory Efficiency**: Uses 625-2500x less memory per operation (0.08 KB vs 50-200 KB)
-- **Zero Memory Leaks**: Automatic cleanup with decreasing memory usage over time
-- **Concurrency**: Safe multi-threaded access with automatic pooling
-- **Resource Management**: Intelligent memory and connection lifecycle management
-- **Load Balancing**: Intelligent connection distribution across threads
-- **Fault Tolerance**: Built-in retry logic and connection health checks
-- **Timeouts**: Configurable timeouts prevent hanging connections
 
 ### Connection Strings
 
@@ -390,89 +354,6 @@ async def main():
 asyncio.run(main())
 ```
 
-### Performance Comparison: bb8 Connection Pool
-
-The bb8 connection pool dramatically improves performance, especially under load:
-
-```python
-import asyncio
-import time
-from fastmssql import Connection
-
-async def performance_comparison():
-    connection_string = "Server=localhost;Database=test;User Id=myuser;Password=mypass"
-    
-    # Sequential async operations (still efficient with pool reuse)
-    start = time.time()
-    async with Connection(connection_string) as conn:
-        for i in range(10):
-            result = await conn.execute("SELECT COUNT(*) FROM users")
-    sequential_time = time.time() - start
-
-    # Concurrent async operations (much faster with bb8 pool)
-    start = time.time()
-    async def concurrent_queries():
-        tasks = []
-        for i in range(10):
-            async def query():
-                async with Connection(connection_string) as conn:  # Pool reuse
-                    return await conn.execute("SELECT COUNT(*) FROM users")
-            tasks.append(query())
-        return await asyncio.gather(*tasks)
-    
-    await concurrent_queries()
-    concurrent_time = time.time() - start
-    
-    print(f"Sequential: {sequential_time:.3f}s")
-    print(f"Concurrent: {concurrent_time:.3f}s") 
-    print(f"Improvement: {sequential_time/concurrent_time:.1f}x faster")
-
-asyncio.run(performance_comparison())
-```
-
-**Real-world Performance Benefits:**
-- **Web Applications**: Handle 100+ concurrent requests without connection exhaustion
-- **Batch Processing**: Process large datasets with optimal resource usage
-- **Microservices**: Reliable database connections across service boundaries
-- **Data Analytics**: Concurrent query execution for faster insights
-
-## Examples
-
-Run the provided examples to see async patterns and features:
-
-```bash
-# Basic asynchronous usage
-python examples/basic_usage.py
-
-# Advanced asynchronous features  
-python examples/advanced_usage.py
-
-# Asynchronous usage patterns
-python examples/async_usage.py
-
-# Advanced pool configuration
-python examples/advanced_pool_config.py
-
-# Connection parameters demonstration
-python examples/connection_parameters_demo.py
-```
-
-### Key API Improvements
-
-Our async-only design provides a clean, intuitive interface:
-
-```python
-# ✅ Clean async API (New Design)
-async with Connection(connection_string) as conn:
-    result = await conn.execute(sql)           # Intuitive!
-    rows_affected = await conn.execute_non_query(sql)
-
-# ❌ Old confusing API (Removed)
-# async with Connection(connection_string) as conn:
-#     result = await conn.execute_async(sql)   # Confusing suffixes
-#     rows_affected = await conn.execute_non_query_async(sql)
-```
-
 ## Development
 
 ### Building from Source
@@ -655,19 +536,6 @@ async with mssql.connect_async(conn_str) as conn:
     print(f"Pool utilization: {stats['active_connections']}/{stats['connections']}")
 ```
 
-**Features:**
-- Async-only operations for maximum performance
-- Automatic connection pooling with bb8
-- Configurable pool settings via `PoolConfig`
-- Pool statistics and monitoring
-- Improved concurrent performance
-- Better resource management
-
-**Breaking Changes:**
-- None - the API is fully backward compatible
-- All existing code continues to work without modification
-- Performance improvements are automatic
-
 ## Advanced Usage Patterns
 
 ### Custom Pool Configuration for Different Scenarios
@@ -756,7 +624,7 @@ async def olap_operations():
         return quarterly_report
 ```
 
-## Troubleshooting
+## API Reference
 
 ### Common Issues
 

fastmssql-0.2.7.dist-info/RECORD

@@ -0,0 +1,6 @@
+fastmssql-0.2.7.dist-info/METADATA,sha256=d_Ungip-AytC0OJ27HiasAjTDCCNoOTfYztUE7H_q3k,25322
+fastmssql-0.2.7.dist-info/WHEEL,sha256=SFq8SBzC81NB5ITKJAU_CjsCJk-sqmjha07boBg64KU,94
+fastmssql-0.2.7.dist-info/licenses/LICENSE,sha256=sHV8b3wGLX_KE9w2JVnp80n-2hQphvBuBfCOlnH4ya0,4904
+fastmssql/__init__.py,sha256=9iNqDR_5_4hVjSx20Q1XFDbRbJnVyvB2uq3otWBctnM,29702
+fastmssql/fastmssql.cp39-win_amd64.pyd,sha256=Z5l1l9M6YgsbySBoDgLH7uEOlKCWQg5rt3PvcRWAKdE,3640832
+fastmssql-0.2.7.dist-info/RECORD,,