fastmssql 0.2.8__cp39-cp39-macosx_11_0_arm64.whl → 0.2.9__cp39-cp39-macosx_11_0_arm64.whl

fastmssql/__init__.py

@@ -23,18 +23,25 @@ Basic Usage (Async):
     >>> 
     >>> async def main():
     ...     async with Connection("Server=localhost;Database=test;Trusted_Connection=yes") as conn:
-    ...         # Simple query
-    ...         result = await conn.execute("SELECT * FROM users")
+    ...         # SELECT queries - use query() method
+    ...         result = await conn.query("SELECT * FROM users")
     ...         async for row in result:
     ...             print(f"User: {row['name']}, Age: {row['age']}")
     ...         
-    ...         # Parameterized query
-    ...         result = await conn.execute(
+    ...         # Parameterized SELECT query
+    ...         result = await conn.query(
     ...             "SELECT * FROM users WHERE age > @P1 AND city = @P2", 
     ...             [18, "New York"]
     ...         )
     ...         rows = await result.fetchall()
     ...         print(f"Found {len(rows)} users")
+    ...         
+    ...         # INSERT/UPDATE/DELETE - use execute() method
+    ...         affected = await conn.execute(
+    ...             "INSERT INTO users (name, email, age) VALUES (@P1, @P2, @P3)",
+    ...             ["John Doe", "john@example.com", 30]
+    ...         )
+    ...         print(f"Inserted {affected} rows")
     >>> 
     >>> asyncio.run(main())
 
@@ -42,11 +49,9 @@ Basic Usage (Sync):
     >>> from fastmssql import Connection
     >>> 
     >>> with Connection("Server=localhost;Database=test;Trusted_Connection=yes") as conn:
-    ...     result = conn.execute_with_python_params(
-    ...         "SELECT COUNT(*) as count FROM users WHERE active = ?", 
-    ...         [True]
-    ...     )
-    ...     print(f"Active users: {result[0]['count']}")
+    ...     # For SELECT queries, you would typically use the async API
+    ...     # Sync usage is primarily for simple operations
+    ...     pass  # Connection established and will be closed on exit
 
 Advanced Configuration:
     >>> from fastmssql import Connection, PoolConfig, SslConfig, EncryptionLevel
@@ -232,13 +237,19 @@ class Connection:
             trusted_connection=trusted_connection
         )
     
-    async def execute(self, query, parameters=None):
+    async def query(self, query, parameters=None):
         """
-        Execute a SQL query asynchronously and return a FastExecutionResult.
+        Execute a SQL query that returns rows (SELECT statements) asynchronously.
+        
+        This method is specifically designed for SELECT queries and other statements
+        that return result sets. It uses the optimized query() method internally
+        for maximum performance when fetching data.
         
-        This method executes SQL queries with optional parameterization for security
-        and performance. It supports all types of SQL statements including SELECT,
-        INSERT, UPDATE, DELETE, and stored procedure calls.
+        Use this method for:
+            - SELECT statements
+            - Stored procedures that return result sets
+            - SHOW commands
+            - Any query that returns tabular data
         
         Parameter Binding:
             Parameters are bound using positional placeholders (@P1, @P2, etc.) in the
@@ -258,7 +269,7 @@ class Connection:
             - uuid.UUID (uniqueidentifier)
         
         Args:
-            query (str): SQL query to execute. Use @P1, @P2, etc. for parameters.
+            query (str): SQL SELECT query to execute. Use @P1, @P2, etc. for parameters.
                 Example: "SELECT * FROM users WHERE age > @P1 AND city = @P2"
                 
             parameters (list, optional): List of parameter values in order.
@@ -280,56 +291,165 @@ class Connection:
             
         Examples:
             # Simple SELECT query
-            >>> result = await conn.execute("SELECT * FROM users")
+            >>> result = await conn.query("SELECT * FROM users")
             >>> async for row in result:
             ...     print(f"User ID: {row['id']}, Name: {row['name']}")
             
             # Parameterized query
-            >>> result = await conn.execute(
+            >>> result = await conn.query(
             ...     "SELECT * FROM orders WHERE created_date > @P1 AND amount > @P2",
             ...     [datetime(2023, 1, 1), 100.0]
             ... )
             >>> rows = await result.fetchall()
             >>> print(f"Found {len(rows)} orders")
             
-            # INSERT with parameters
-            >>> result = await conn.execute(
-            ...     "INSERT INTO users (name, email, age) VALUES (@P1, @P2, @P3)",
-            ...     ["John Doe", "john@example.com", 30]
+            # Complex SELECT with joins
+            >>> result = await conn.query(
+            ...     \"\"\"SELECT u.name, u.email, COUNT(o.id) as order_count
+            ...        FROM users u 
+            ...        LEFT JOIN orders o ON u.id = o.user_id 
+            ...        WHERE u.created_date > @P1
+            ...        GROUP BY u.id, u.name, u.email
+            ...        ORDER BY order_count DESC\"\"\",
+            ...     [datetime(2023, 1, 1)]
             ... )
-            >>> print(f"Inserted {result.rowcount} row(s)")
+            >>> async for row in result:
+            ...     print(f"{row['name']}: {row['order_count']} orders")
             
-            # Stored procedure call
-            >>> result = await conn.execute(
+            # Stored procedure that returns data
+            >>> result = await conn.query(
             ...     "EXEC GetUsersByDepartment @P1, @P2",
             ...     ["Engineering", True]  # department, active_only
             ... )
             >>> users = await result.fetchall()
-            
-            # Complex query with multiple data types
-            >>> from decimal import Decimal
-            >>> from datetime import datetime
-            >>> import uuid
-            >>> 
-            >>> result = await conn.execute(
-            ...     \"\"\"UPDATE products 
-            ...        SET price = @P1, updated_date = @P2, active = @P3 
-            ...        WHERE product_id = @P4\"\"\",
-            ...     [Decimal('29.99'), datetime.now(), True, uuid.uuid4()]
-            ... )
         
         Performance Tips:
-            - Use parameterized queries instead of string formatting for better performance
+            - Use this method instead of execute() for SELECT queries for better performance
             - For large result sets, iterate asynchronously rather than calling fetchall()
             - Reuse Connection instances to benefit from connection pooling
-            - Consider batch operations for bulk data manipulation
+            - Use appropriate indexes on filtered columns
+        """
+        return await self._conn.query(query, parameters)
+    
+    async def execute(self, query, parameters=None):
+        """
+        Execute a SQL command that doesn't return rows (INSERT/UPDATE/DELETE/DDL) asynchronously.
+        
+        This method is specifically designed for SQL commands that modify data or database
+        structure but don't return result sets. It uses the optimized execute() method 
+        internally for maximum performance when performing data modifications.
+        
+        Use this method for:
+            - INSERT statements
+            - UPDATE statements
+            - DELETE statements
+            - DDL commands (CREATE, ALTER, DROP)
+            - Stored procedures that don't return result sets
+            - MERGE statements
+        
+        Parameter Binding:
+            Parameters are bound using positional placeholders (@P1, @P2, etc.) in the
+            query string. The parameter values are provided as a list in the same order.
+            
+        Supported Parameter Types:
+            - None (NULL)
+            - bool
+            - int (32-bit and 64-bit)
+            - float (32-bit and 64-bit)
+            - str (varchar, nvarchar, text)
+            - bytes (varbinary, image)
+            - datetime.datetime (datetime, datetime2)
+            - datetime.date (date)
+            - datetime.time (time)
+            - decimal.Decimal (decimal, money)
+            - uuid.UUID (uniqueidentifier)
+        
+        Args:
+            query (str): SQL command to execute. Use @P1, @P2, etc. for parameters.
+                Example: "INSERT INTO users (name, email, age) VALUES (@P1, @P2, @P3)"
+                
+            parameters (list, optional): List of parameter values in order.
+                Values are automatically converted to appropriate SQL types.
+                Example: ["John Doe", "john@example.com", 30]
+        
+        Returns:
+            int: Number of rows affected by the command.
+                - For INSERT: Number of rows inserted
+                - For UPDATE: Number of rows updated
+                - For DELETE: Number of rows deleted
+                - For DDL: Usually 0 (structure changes don't affect rows)
+        
+        Raises:
+            SqlError: If the SQL command contains syntax errors or constraint violations.
+            ConnectionError: If the database connection is lost during execution.
+            TimeoutError: If the command execution exceeds configured timeouts.
+            ParameterError: If parameter types cannot be converted or are invalid.
+            
+        Examples:
+            # INSERT with parameters
+            >>> affected = await conn.execute(
+            ...     "INSERT INTO users (name, email, age) VALUES (@P1, @P2, @P3)",
+            ...     ["John Doe", "john@example.com", 30]
+            ... )
+            >>> print(f"Inserted {affected} row(s)")
+            
+            # UPDATE with conditions
+            >>> affected = await conn.execute(
+            ...     "UPDATE users SET age = @P1, updated_date = @P2 WHERE id = @P3",
+            ...     [31, datetime.now(), 123]
+            ... )
+            >>> print(f"Updated {affected} user(s)")
+            
+            # DELETE with parameters
+            >>> affected = await conn.execute(
+            ...     "DELETE FROM users WHERE age < @P1 AND last_login < @P2",
+            ...     [18, datetime(2020, 1, 1)]
+            ... )
+            >>> print(f"Deleted {affected} inactive users")
+            
+            # DDL commands
+            >>> affected = await conn.execute(
+            ...     \"\"\"CREATE TABLE temp_data (
+            ...         id INT IDENTITY(1,1) PRIMARY KEY,
+            ...         name NVARCHAR(100) NOT NULL,
+            ...         created_date DATETIME2 DEFAULT GETDATE()
+            ...     )\"\"\"
+            ... )
+            >>> print(f"Table created (affected rows: {affected})")
+            
+            # Stored procedure that modifies data
+            >>> affected = await conn.execute(
+            ...     "EXEC UpdateUserPreferences @P1, @P2",
+            ...     [user_id, json.dumps(preferences)]
+            ... )
+            >>> print(f"Updated preferences for {affected} user(s)")
+            
+            # Batch operations
+            >>> users_to_insert = [
+            ...     ["Alice Johnson", "alice@example.com", 28],
+            ...     ["Bob Smith", "bob@example.com", 32],
+            ...     ["Carol Davis", "carol@example.com", 25]
+            ... ]
+            >>> total_affected = 0
+            >>> for user_data in users_to_insert:
+            ...     affected = await conn.execute(
+            ...         "INSERT INTO users (name, email, age) VALUES (@P1, @P2, @P3)",
+            ...         user_data
+            ...     )
+            ...     total_affected += affected
+            >>> print(f"Inserted {total_affected} users total")
+        
+        Performance Tips:
+            - Use this method instead of query() for data modification commands
+            - For bulk operations, consider using batch processing or table-valued parameters
+            - Use transactions for multiple related operations
+            - Monitor the returned affected row count for validation
         
         Security Notes:
             - Always use parameterized queries to prevent SQL injection attacks
-            - Parameter values are automatically escaped and type-checked
-            - Never concatenate user input directly into SQL query strings
+            - Validate affected row counts match expectations
+            - Consider using transactions for data consistency
         """
-        # The Rust implementation now returns results directly
         return await self._conn.execute(query, parameters)
     
     

{fastmssql-0.2.8.dist-info → fastmssql-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmssql
-Version: 0.2.8
+Version: 0.2.9
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: Other/Proprietary License
@@ -46,7 +46,23 @@ A Python library for Microsoft SQL Server built with Rust using the [Tiberius](h
 - **Type Safety**: Strong typing with automatic Python type conversion
 - **Thread Safety**: Support for concurrent operations
 - **Cross-Platform**: Works on Windows, macOS, and Linux
-- **Simple API**: Clean, intuitive async-only interface
+- **Simple API**: Clean, intuitive async-only interface with separate `query()` and `execute()` methods
+
+## Key API Methods
+
+FastMSSQL provides two distinct methods for database operations:
+
+- **`query()`** - For SELECT statements that return rows
+- **`execute()`** - For INSERT/UPDATE/DELETE statements 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"])
+```
 
 ## Performance Highlights
 
@@ -125,7 +141,9 @@ async def main():
     
     # Automatic connection pool management
     async with Connection(connection_string) as conn:
-        rows = await conn.execute("SELECT @@VERSION as version")
+        # Use query() for SELECT statements that return rows
+        result = await conn.query("SELECT @@VERSION as version")
+        rows = result.rows()
         for row in rows:
             print(row['version'])
         
@@ -151,8 +169,10 @@ async def main():
     connection_string = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
     
     async with Connection(connection_string=connection_string) as conn:
-        result = await conn.execute("SELECT @@VERSION as version")
-        for row in result.rows():
+        # Use query() for SELECT statements that return rows
+        result = await conn.query("SELECT @@VERSION as version")
+        rows = result.rows()
+        for row in rows:
             print(row['version'])
 
 asyncio.run(main())
@@ -174,8 +194,10 @@ async def main():
         username="myuser",
         password="mypassword"
     ) as conn:
-        result = await conn.execute("SELECT SUSER_NAME() as login")
-        for row in result.rows():
+        # Use query() for SELECT statements that return rows
+        result = await conn.query("SELECT SUSER_NAME() as login")
+        rows = result.rows()
+        for row in rows:
             print(f"Logged in as: {row['login']}")
 
 asyncio.run(main())
@@ -198,8 +220,9 @@ async def high_performance_pattern():
         # 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})
+                # Use query() for SELECT statements that return rows
+                result = await conn.query("SELECT data FROM my_table WHERE id = @P1", [123])
+                rows = result.rows()
                 # Process results...
     
     # Launch multiple workers - each with their own connection
@@ -234,7 +257,11 @@ async def main():
     )
 
     async with Connection(connection_string, pool_config) as conn:
-        result = await conn.execute("SELECT * FROM users")
+        # Use query() for SELECT statements that return rows
+        result = await conn.query("SELECT * FROM users")
+        rows = result.rows()
+        for row in rows:
+            print(f"User: {row['name']}")
         
     # Predefined configurations for different scenarios
     high_throughput_config = PoolConfig.high_throughput()     # 100 connections, optimized for high RPS
@@ -248,7 +275,8 @@ async def main():
     # 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")
+            # Use query() for SELECT statements that return rows
+            result = await conn.query("SELECT * FROM fast_table")
             return result.rows()
     
     # Each worker gets its own connection for optimal performance
@@ -283,21 +311,37 @@ from fastmssql import Connection
 
 async def main():
     async with Connection(connection_string) as conn:
-        # Execute queries
-        users = await conn.execute("SELECT id, name, email FROM users WHERE active = 1")
+        # === SELECT QUERIES - Use query() method (returns rows) ===
+        result = await conn.query("SELECT id, name, email FROM users WHERE active = 1")
+        rows = result.rows()
         
         # Iterate through results
-        for user in users:
-            print(f"User {user['id']}: {user['name']} ({user['email']})")
+        for row in rows:
+            print(f"User {row['id']}: {row['name']} ({row['email']})")
+        
+        # === DATA MODIFICATION - Use execute() method (returns affected row count) ===
+        # INSERT operation
+        rows_affected = await conn.execute(
+            "INSERT INTO users (name, email, active) VALUES (@P1, @P2, @P3)",
+            ["John Doe", "john@example.com", 1]
+        )
+        print(f"Inserted {rows_affected} row(s)")
+        
+        # UPDATE operation
+        rows_affected = await conn.execute(
+            "UPDATE users SET last_login = GETDATE() WHERE id = @P1",
+            [123]
+        )
+        print(f"Updated {rows_affected} row(s)")
         
-        # Execute non-query operations
-        rows_affected = await conn.execute_non_query(
-            "UPDATE users SET last_login = GETDATE() WHERE id = 123"
+        # DELETE operation
+        rows_affected = await conn.execute(
+            "DELETE FROM users WHERE active = 0 AND last_login < DATEADD(year, -1, GETDATE())"
         )
-        print(f"Updated {rows_affected} rows")
+        print(f"Deleted {rows_affected} inactive users")
         
-        # Work with different data types
-        data = await conn.execute("""
+        # === WORKING WITH DIFFERENT DATA TYPES ===
+        result = await conn.query("""
             SELECT 
                 42 as int_value,
                 3.14159 as float_value,
@@ -307,9 +351,11 @@ async def main():
                 NULL as null_value
         """)
         
-        row = data[0]
-        for column_name, value in row.items():
-            print(f"{column_name}: {value} (type: {type(value).__name__})")
+        rows = result.rows()
+        if rows:
+            row = rows[0]
+            for column_name, value in row.items():
+                print(f"{column_name}: {value} (type: {type(value).__name__})")
 
 asyncio.run(main())
 ```
@@ -329,7 +375,9 @@ async def main():
     
     # Async context manager with automatic pool management
     async with Connection(connection_string) as conn:
-        rows = await conn.execute("SELECT name FROM sys.databases")
+        # Use query() for SELECT statements that return rows
+        result = await conn.query("SELECT name FROM sys.databases")
+        rows = result.rows()
         for row in rows:
             print(row['name'])
             
@@ -340,7 +388,9 @@ async def main():
     # High-performance concurrent operations
     async def fetch_user_data(user_id):
         async with Connection(connection_string) as conn:
-            return await conn.execute(f"SELECT * FROM users WHERE id = {user_id}")
+            # Use query() for SELECT statements that return rows
+            result = await conn.query(f"SELECT * FROM users WHERE id = {user_id}")
+            return result.rows()
     
     # Execute multiple queries concurrently using the connection pool
     user_ids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
@@ -407,6 +457,29 @@ python examples/advanced_usage.py
 
 ## API Reference
 
+### Query vs Execute Methods
+
+FastMSSQL provides two distinct methods for database operations:
+
+- **`query()`** - For SELECT statements that return rows
+  - Returns a `QueryResult` object with a `rows()` method
+  - Use for retrieving data from the database
+
+- **`execute()`** - For INSERT, UPDATE, DELETE statements  
+  - Returns the number of affected rows as an integer
+  - Use for modifying data in the database
+
+**SQL Server Parameter Syntax**: Use positional parameters `@P1`, `@P2`, `@P3`, etc.
+
+```python
+# SELECT queries - use query()
+result = await conn.query("SELECT * FROM users WHERE age > @P1 AND city = @P2", [25, "New York"])
+rows = result.rows()
+
+# INSERT/UPDATE/DELETE - use execute()  
+affected = await conn.execute("INSERT INTO users (name, email) VALUES (@P1, @P2)", ["John", "john@example.com"])
+```
+
 ### Core Classes
 
 #### `Connection`
@@ -419,21 +492,45 @@ Connection(connection_string: str, pool_config: Optional[PoolConfig] = None)
 
 **Context Manager Support:**
 ```python
-# Synchronous
-with Connection(conn_str) as conn:
-    result = conn.execute("SELECT * FROM table")
-
-# Asynchronous  
+# Asynchronous (recommended)
 async with Connection(conn_str) as conn:
-    result = await conn.execute_async("SELECT * FROM table")
+    # Use query() for SELECT statements
+    result = await conn.query("SELECT * FROM table")
+    rows = result.rows()
+    
+    # Use execute() for INSERT/UPDATE/DELETE statements  
+    affected = await conn.execute("INSERT INTO table (col) VALUES (@P1)", ["value"])
+```
 ```
 
 **Methods:**
-- `execute(sql: str) -> List[Row]` - Execute a query synchronously
+- `query(sql: str, params: Optional[List] = None) -> QueryResult` - Execute SELECT queries that return rows
+- `execute(sql: str, params: Optional[List] = None) -> int` - Execute INSERT/UPDATE/DELETE statements, returns affected row count
 - `pool_stats() -> dict` - Get connection pool statistics
 - `disconnect()` - Close the connection pool
 - `is_connected() -> bool` - Check if pool is active
 
+**Method Details:**
+
+`query()` - For SELECT statements that return data:
+```python
+# Returns a QueryResult object with rows() method
+result = await conn.query("SELECT * FROM users WHERE age > @P1", [21])
+rows = result.rows()
+for row in rows:
+    print(row['name'])
+```
+
+`execute()` - For INSERT/UPDATE/DELETE statements:
+```python
+# Returns the number of affected rows
+affected = await conn.execute("INSERT INTO users (name) VALUES (@P1)", ["John"])
+print(f"Inserted {affected} row(s)")
+
+affected = await conn.execute("UPDATE users SET age = @P1 WHERE name = @P2", [25, "John"])
+print(f"Updated {affected} row(s)")
+```
+
 **Pool Statistics:**
 ```python
 stats = conn.pool_stats()
@@ -484,15 +581,17 @@ Represents a database row with column access.
 
 #### Connection Management
 ```python
-# Create connection with default pool settings
-connect(connection_string: str) -> Connection
-
-# Create async connection with default pool settings
-connect_async(connection_string: str) -> Connection
-
-# One-liner query execution
-execute(connection_string: str, sql: str) -> List[dict]
-execute_async(connection_string: str, sql: str) -> List[dict]
+# Create connection with connection pooling
+Connection(connection_string: str, pool_config: Optional[PoolConfig] = None) -> Connection
+
+# Usage with async context manager (recommended)
+async with Connection(connection_string) as conn:
+    # Use query() for SELECT statements that return rows
+    result = await conn.query("SELECT * FROM users")
+    rows = result.rows()
+    
+    # Use execute() for INSERT/UPDATE/DELETE statements that return affected count
+    affected = await conn.execute("INSERT INTO users (name) VALUES (@P1)", ["John"])
 ```
 
 #### Utility Functions
@@ -515,7 +614,8 @@ The library uses the bb8 connection pool for efficient resource management:
 ```python
 try:
     async with mssql.connect_async(connection_string) as conn:
-        result = await conn.execute("SELECT * FROM invalid_table")
+        result = await conn.query("SELECT * FROM invalid_table")
+        rows = result.rows()
 except Exception as e:
     print(f"Database error: {e}")
     # Connection automatically returned to pool even on error
@@ -529,7 +629,8 @@ This library has been upgraded to use async-only operations with the bb8 connect
 ```python  
 # Async-only with automatic connection pooling
 async with mssql.connect_async(conn_str) as conn:
-    result = await conn.execute("SELECT * FROM table")
+    result = await conn.query("SELECT * FROM table")
+    rows = result.rows()
     
     # Pool statistics
     stats = conn.pool_stats()
@@ -601,7 +702,7 @@ async def oltp_operations():
     async with mssql.connect_async(conn_str, oltp_config) as conn:
         # Fast, concurrent transactions
         tasks = [
-            conn.execute_async("SELECT * FROM users WHERE id = $1", [user_id])
+            conn.query("SELECT * FROM users WHERE id = @P1", [user_id])
             for user_id in range(1, 101)
         ]
         results = await asyncio.gather(*tasks)
@@ -611,7 +712,7 @@ olap_config = PoolConfig.low_resource()
 async def olap_operations():
     async with mssql.connect_async(conn_str, olap_config) as conn:
         # Long-running analytical queries
-        quarterly_report = await conn.execute_async("""
+        result = await conn.query("""
             SELECT 
                 DATE_TRUNC('quarter', order_date) as quarter,
                 SUM(total_amount) as total_revenue,
@@ -621,7 +722,7 @@ async def olap_operations():
             GROUP BY DATE_TRUNC('quarter', order_date)
             ORDER BY quarter
         """)
-        return quarterly_report
+        return result.rows()
 ```
 
 ## API Reference

fastmssql-0.2.9.dist-info/RECORD

@@ -0,0 +1,6 @@
+fastmssql/__init__.py,sha256=pFvT4Iki4PdpHWl3APWVeXccWxakueCkU57jbEKcIDA,30407
+fastmssql/fastmssql.cpython-39-darwin.so,sha256=ViAMZHQDCRqIRhJbx9DYfGYLlRY2IsGtoW_dBCIV6rQ,1985984
+fastmssql-0.2.9.dist-info/RECORD,,
+fastmssql-0.2.9.dist-info/WHEEL,sha256=XNDUDUieSorG-Y7wZ8qiKEUDK0umKv3PscUlyjQeFKE,102
+fastmssql-0.2.9.dist-info/METADATA,sha256=pDIeOAYMQ_EiMBU1XSn0i5EUWhukgpXOaHY3nzAli9g,28566
+fastmssql-0.2.9.dist-info/licenses/LICENSE,sha256=NwufX3BNj7RvVtnrshWhkpFOLvWc_YVpGpr3UZGFz_E,4765

fastmssql-0.2.8.dist-info/RECORD

@@ -1,6 +0,0 @@
-fastmssql/__init__.py,sha256=5D3MpxBm8I33nKOml8wlHJbfH1-9bak68md3xj1Rds0,24923
-fastmssql/fastmssql.cpython-39-darwin.so,sha256=ffOLTp3hkeGZgAy6G5mdGJeKyJfpjyt30Q67WuXN88s,2002480
-fastmssql-0.2.8.dist-info/RECORD,,
-fastmssql-0.2.8.dist-info/WHEEL,sha256=XNDUDUieSorG-Y7wZ8qiKEUDK0umKv3PscUlyjQeFKE,102
-fastmssql-0.2.8.dist-info/METADATA,sha256=pbN2t4Cuhy1rzvxweu537UUq6vrP42RZNmoOyg_Y94o,24664
-fastmssql-0.2.8.dist-info/licenses/LICENSE,sha256=NwufX3BNj7RvVtnrshWhkpFOLvWc_YVpGpr3UZGFz_E,4765