Update DocC documentation with new features (RPC, BCP, Transactions)

Author: vkuttyp

Sources/SQLClientSwift/SQLClientSwift.docc/BulkInsert.md

@@ -0,0 +1,35 @@
+# Bulk Insert (BCP)
+
+High-performance insertion of large datasets using the Bulk Copy (BCP) protocol.
+
+## Overview
+
+The Bulk Copy (BCP) interface is significantly faster than standard `INSERT` statements when loading thousands of rows. SQLClient provides a simple `bulkInsert` method that leverages the underlying FreeTDS BCP implementation.
+
+### Usage
+
+To perform a bulk insert, prepare an array of ``SQLRow`` objects and specify the target table name.
+
+```swift
+var rows: [SQLRow] = []
+for i in 1...1000 {
+    let storage: [(key: String, value: Sendable)] = [
+        (key: "Id", value: i),
+        (key: "Name", value: "User \(i)")
+    ]
+    rows.append(SQLRow(storage, columnTypes: [:]))
+}
+
+let insertedCount = try await client.bulkInsert(table: "Users", rows: rows)
+print("Successfully inserted \(insertedCount) rows.")
+```
+
+### Considerations
+
+- **Encoding**: Currently, BCP works best with standard `VARCHAR` columns.
+- **Table Existence**: The target table must exist in the database before calling `bulkInsert`.
+- **Permissions**: The database user must have the necessary permissions to perform bulk operations.
+
+## Methods
+
+- ``SQLClient/bulkInsert(table:rows:)``

Sources/SQLClientSwift/SQLClientSwift.docc/RPC.md

@@ -0,0 +1,46 @@
+# Stored Procedures (RPC)
+
+Execute stored procedures efficiently using Remote Procedure Calls (RPC).
+
+## Overview
+
+Remote Procedure Calls are the native way to execute stored procedures in SQL Server. Unlike building an `EXEC` string, RPC correctly handles input and output parameters, return statuses, and is generally more efficient.
+
+### Usage
+
+To call a stored procedure, use the `executeRPC` method along with an array of ``SQLParameter`` objects.
+
+```swift
+let params = [
+    SQLParameter(name: "@InVal", value: 42),
+    SQLParameter(name: "@OutVal", value: 0, isOutput: true)
+]
+
+let result = try await client.executeRPC("MyProcedure", parameters: params)
+
+// Access output parameters
+if let resultVal = result.outputParameters["@OutVal"] as? NSNumber {
+    print("Result from procedure: \(resultVal.intValue)")
+}
+
+// Access return status
+if let status = result.returnStatus {
+    print("Procedure returned status: \(status)")
+}
+```
+
+### Advantages of RPC
+
+- **Type Safety**: Parameters are passed with their native types.
+- **Output Parameters**: Built-in support for capturing values from `OUTPUT` parameters.
+- **Performance**: Skips some of the parsing overhead associated with ad-hoc T-SQL.
+
+## Related Types
+
+- ``SQLParameter``
+- ``SQLClientResult/outputParameters``
+- ``SQLClientResult/returnStatus``
+
+## Methods
+
+- ``SQLClient/executeRPC(_:parameters:)``

Sources/SQLClientSwift/SQLClientSwift.docc/SQLClientSwift.md

@@ -13,6 +13,9 @@ SQLClient-Swift provides a clean, asynchronous API for interacting with SQL Serv
 - **Type Safety**: Automatic mapping of database rows to Swift `Decodable` types.
 - **Thread Safety**: Uses Swift actors to ensure safe concurrent access to database connections.
 - **Full Encryption Support**: Supports TLS/SSL for Azure SQL and modern SQL Server instances.
+- **Stored Procedures**: Full support for Remote Procedure Calls (RPC) with output parameters.
+- **Bulk Copy (BCP)**: High-performance data ingestion for large datasets.
+- **Connection Pooling**: Built-in support for managing reusable connection pools.
 
 ## Topics
 
@@ -22,3 +25,11 @@ SQLClient-Swift provides a clean, asynchronous API for interacting with SQL Serv
 - ``SQLClientConnectionOptions``
 - ``SQLClientResult``
 - ``SQLRow``
+- ``SQLParameter``
+
+### Advanced Features
+
+- ``SQLClientPool``
+- <doc:Transactions>
+- <doc:BulkInsert>
+- <doc:RPC>

Sources/SQLClientSwift/SQLClientSwift.docc/Transactions.md

@@ -0,0 +1,30 @@
+# Transactions
+
+Execute multiple SQL statements within a single atomic transaction.
+
+## Overview
+
+SQLClient allows you to explicitly manage database transactions using the `beginTransaction`, `commitTransaction`, and `rollbackTransaction` methods. This ensures that a group of operations either all succeed or all fail together, maintaining data integrity.
+
+### Usage
+
+```swift
+try await client.beginTransaction()
+do {
+    try await client.run("INSERT INTO Orders (Id, Total) VALUES (1, 100)")
+    try await client.run("UPDATE Inventory SET Stock = Stock - 1 WHERE ProductId = 5")
+    
+    // Commit the changes to the database
+    try await client.commitTransaction()
+} catch {
+    // If any operation fails, roll back the entire transaction
+    try await client.rollbackTransaction()
+    throw error
+}
+```
+
+## Methods
+
+- ``SQLClient/beginTransaction()``
+- ``SQLClient/commitTransaction()``
+- ``SQLClient/rollbackTransaction()``