PostgresClientKit

In PostgresClientKit, the deinitializers for Connection, Statement, and Cursor automatically call close(). This can lead to unexpected closures if you reuse variables for subsequent SQL commands.

The Problem: If you assign a new Statement to a variable that currently holds an old Statement, the old Statement is deinitialized. Its deinitializer calls close(), which closes any active Cursor associated with that statement. If your Cursor was only being held by that statement, it will be closed unexpectedly.

Solutions:

1. Explicit Close: Call .close() on the first Statement before preparing a new one.
2. Unique Variables: Assign each Statement instance to a unique variable name.
3. Scope Isolation: Wrap each SQL command execution in its own do { ... } block. This ensures the Statement and Cursor are deinitialized and deallocated before the next command begins.

// Problematic pattern:
var statement = try connection.prepareStatement(text: "SELECT 1")
var cursor = try statement.execute()

// This assignment triggers deinit of the first statement, which closes the first cursor
statement = try connection.prepareStatement(text: "SELECT 2") 
// cursor.isClosed will now be true

// Recommended pattern (Scope Isolation):
do {
    let statement = try connection.prepareStatement(text: "SELECT 1")
    let cursor = try statement.execute()
    // use cursor...
}

do {
    let statement = try connection.prepareStatement(text: "SELECT 2")
    let cursor = try statement.execute()
    // use cursor...
}

To see messages sent directly from the Postgres server within your Swift application, follow these steps:

1. Configure Postgres Server: Set the client_min_messages parameter in your postgresql.conf file (e.g., client_min_messages = debug5).
2. Capture Logs: You can capture these messages in one of two ways:
   • Via Logger: Increase the Postgres.logger level to .finer or higher. PostgresClientKit will then log the messages received from the server.
   • Via ConnectionDelegate: Implement the ConnectionDelegate protocol and the connection(_:didReceiveNotice:) method. Assign an instance of this class to the delegate property of your Connection.

Note: The delegate property on Connection is weak. You must maintain a strong reference to your delegate instance in your own code to prevent it from being deallocated.

// Example: Implementing a delegate to receive notices
class MyConnectionDelegate: ConnectionDelegate {
    func connection(_ connection: Connection, didReceiveNotice notice: Notice) {
        print("Received notice: \(notice)")
    }
}

let myDelegate = MyConnectionDelegate()
// Ensure myDelegate is held by a strong reference elsewhere
connection.delegate = myDelegate

You can integrate PostgresClientKit into your project using Swift Package Manager (Xcode or standalone), or CocoaPods.

Xcode Project (Package Dependency)

1. Select File > Add Packages...
2. Enter the URL: https://github.com/codewinsdotcom/PostgresClientKit
3. Set version requirements (e.g., Up To Next Major Version starting from 1.0.0).
4. Click Add Package.

Standalone Swift Package (Package.swift)

Add the package to your dependencies and reference the product in your targets:

dependencies: [
    .package(url: "https://github.com/codewinsdotcom/PostgresClientKit", from: "1.0.0"),
],
targets: [
    .target(
        name: "MyProject",
        dependencies: ["PostgresClientKit"]),
]

CocoaPods

Add the following to your Podfile:

target 'MyApp' do
  pod 'PostgresClientKit', '~> 1.0'
end

Then run pod install.

After installation, import the library in your Swift files:

import PostgresClientKit