added diags and fixed tests

Author: jeffreyaven

README.md

@@ -158,38 +158,45 @@ The tests provided can be performed with a [`stackql`](https://github.com/stackq
 > curl -L https://bit.ly/stackql-zip -O && unzip stackql-zip
 > ```
 
-To run the examples and integration tests you will need to set invalid AWS credentials (to test an error condition), use this:
-
-```bash
-export AWS_ACCESS_KEY_ID="DUMMYKEYID"
-export AWS_SECRET_ACCESS_KEY="DUMMYSECRETACCESSKEY"
-```
-
 #### Without TLS
 
 To test the library with a local server *without* tls, run the following:
 
 ```bash
 sh start-server.sh
 cargo test --test integration
+# or with verbose output
+RUST_LOG=debug cargo test --test integration -- --nocapture
 sh stop-server.sh
 ```
 
-To run the examples:
+To run the examples with a local server *without* tls, use the following:
 
 ```bash
 sh start-server.sh
-RUST_LOG=debug cargo run --example simple_query # debug mode
 cargo run --example simple_query
+# or with verbose output
+RUST_LOG=debug cargo run --example simple_query
 sh stop-server.sh
 ```
-#### Without TLS
+#### With TLS
 
 To test the library with a local server *with* tls, run the following:
 
+```bash
+sh start-secure-server.sh
+cargo test --test integration_mtls
+# or with verbose output
+RUST_LOG=debug cargo test --test integration_mtls -- --nocapture
+sh stop-server.sh
+```
+To run the examples with a local server *with* tls, use the following:
+
 ```bash
 sh start-secure-server.sh
 cargo run --example simple_query_with_mtls
+# or with verbose output
+RUST_LOG=debug cargo run --example simple_query_with_mtls
 sh stop-server.sh
 ```
 

examples/simple_query.rs

@@ -88,7 +88,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //
     print_heading("REGISTRY PULL examples");
     execute_query(&conn, "REGISTRY PULL homebrew");
-    execute_query(&conn, "REGISTRY PULL github");
 
     //
     // simple select with one row
@@ -129,7 +128,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     print_heading("StackQL SELECT example");
     execute_query(
         &conn,
-        "SELECT id, name, description, stargazers_count FROM github.repos.repos WHERE org = 'stackql' AND name = 'stackql'",
+        "SELECT * FROM homebrew.formula.vw_info WHERE formula_name = 'stackql'",
     );
 
     Ok(())

examples/simple_query_with_mtls.rs

@@ -1,16 +1,81 @@
-// examples/simple_query_with_mtls.rs
+// example/simple_query_with_mtls.rs
+// Example demonstrating using PgwireLite with mutual TLS (mTLS)
 
-use pgwire_lite::PgwireLite;
+use colorize::AnsiColor;
+use pgwire_lite::{PgwireLite, Value};
 use std::env;
 use std::path::PathBuf;
 
-fn main() {
-    // Get the home directory and properly construct paths
+fn print_heading(title: &str) {
+    let title_owned = title.to_string(); // Convert &str to String
+    println!("{}", title_owned.blue().bold());
+}
+
+// Pretty print a row with formatting
+fn print_row(row: &std::collections::HashMap<String, Value>, index: usize) {
+    if index == 0 {
+        // Print header
+        println!("Row {}: {{", index);
+    } else {
+        println!("\nRow {}: {{", index);
+    }
+
+    for (key, value) in row {
+        println!(
+            "  {}: {}",
+            key.clone().green(),
+            format!("{}", value).yellow()
+        );
+    }
+    println!("}}");
+}
+
+fn execute_query(conn: &PgwireLite, query: &str) {
+    match conn.query(query) {
+        Ok(result) => {
+            println!();
+
+            println!("Elapsed time: {} ms", result.elapsed_time_ms);
+
+            println!("Result status: {:?}", result.status);
+
+            println!(
+                "{} columns, {} rows, {} notices",
+                result.col_count, result.row_count, result.notice_count
+            );
+
+            if !result.column_names.is_empty() {
+                println!("Column names: {:?}", result.column_names);
+            }
+
+            if !result.rows.is_empty() {
+                println!("Data:");
+                for (i, row) in result.rows.iter().enumerate() {
+                    print_row(row, i);
+                }
+            }
+
+            if !result.notices.is_empty() {
+                println!("Notices (detail):");
+                for notice in result.notices.iter() {
+                    if let Some(detail) = notice.fields.get("detail") {
+                        println!("{}", detail);
+                    }
+                }
+            }
+            println!();
+        }
+        Err(e) => eprintln!("Error: {}", e),
+    }
+}
+
+fn setup_tls() {
+    // Set up environment variables for TLS
     let home_dir = env::var("HOME").expect("Could not find HOME environment variable");
     let ssl_dir = PathBuf::from(&home_dir).join("ssl-test");
-
-    // Set environment variables with absolute paths
-    env::set_var("PGSSLMODE", "verify-full");
+    
+    // Configure TLS settings
+    env::set_var("PGSSLMODE", "verify-ca");  // Use verify-ca instead of verify-full to bypass hostname check
     env::set_var(
         "PGSSLCERT",
         ssl_dir
@@ -29,14 +94,80 @@ fn main() {
             .to_string_lossy()
             .to_string(),
     );
+    
+    // Disable hostname verification for testing purposes
+    env::set_var("PGSSLSNI", "0");
+}
 
-    // Create the connection with SSL enabled
-    let conn =
-        PgwireLite::new("localhost", 5444, true, "verbose").expect("Failed to create connection");
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    env_logger::init();
+    
+    // Setup TLS environment variables
+    setup_tls();
 
-    // Try to execute a simple query
-    match conn.query("SELECT 1 as col_name") {
-        Ok(result) => println!("Query result (TLS): {:?}", result),
-        Err(e) => eprintln!("Error: {}", e),
-    }
-}
+    // Create a connection configuration with TLS enabled
+    // Using IP address instead of hostname to avoid certificate validation issues
+    let conn = PgwireLite::new("127.0.0.1", 5444, true, "verbose")?;
+
+    println!();
+    println!("libpq version: {}", conn.libpq_version());
+    println!("Verbosity set to: {}", conn.verbosity());
+    println!("TLS connection: Enabled");
+    println!();
+
+    //
+    // registry list example
+    //
+    print_heading("REGISTRY LIST example");
+    execute_query(&conn, "REGISTRY LIST aws");
+
+    //
+    // registry pull examples
+    //
+    print_heading("REGISTRY PULL examples");
+    execute_query(&conn, "REGISTRY PULL homebrew");
+
+    //
+    // simple select with one row
+    //
+    print_heading("Literal SELECT example (one row)");
+    execute_query(&conn, "SELECT 1 as col_name");
+
+    //
+    // simple select with no rows
+    //
+    print_heading("Literal SELECT example (no rows)");
+    execute_query(&conn, "SELECT 1 as col_name WHERE 1=0");
+
+    //
+    // failed command - handle expected error
+    //
+    print_heading("Failed command example");
+    execute_query(&conn, "NOTACOMMAND");
+
+    //
+    // stackql provider select, multiple rows
+    //
+    print_heading("StackQL SELECT example (multiple rows)");
+    execute_query(
+        &conn,
+        "SELECT * FROM homebrew.formula.vw_usage_metrics WHERE formula_name IN ('stackql','steampipe')",
+    );
+
+    //
+    // stackql provider select, provider error, no rows
+    //
+    print_heading("StackQL SELECT example with provider error and no rows");
+    execute_query(&conn, "SELECT id, name, description, stargazers_count FROM github.repos.repos WHERE org = 'nonexistent-org'");
+
+    //
+    // another stackql provider select, should succeed
+    //
+    print_heading("StackQL SELECT example");
+    execute_query(
+        &conn,
+        "SELECT * FROM homebrew.formula.vw_info WHERE formula_name = 'stackql'",
+    );
+
+    Ok(())
+}

src/connection.rs

@@ -216,6 +216,35 @@ impl PgwireLite {
         // Create a fresh connection for this query
         let conn = Connection::new(&conn_str)?;
 
+        // Connection diagnostics
+        unsafe {
+
+            let ssl_in_use = libpq_sys::PQsslInUse((&conn).into()) != 0;
+            let host_ptr = libpq_sys::PQhost((&conn).into());
+            let port_ptr = libpq_sys::PQport((&conn).into());
+            if !host_ptr.is_null() && !port_ptr.is_null() {
+                let host = CStr::from_ptr(host_ptr).to_string_lossy();
+                let port = CStr::from_ptr(port_ptr).to_string_lossy();
+                debug!("Connected to: {}:{} (ssl: {})", host, port, ssl_in_use);
+            }
+            
+            // PQstatus output
+            let status = libpq_sys::PQstatus((&conn).into());
+            debug!("Connection status: {:?}", status);
+            
+            // PQtransactionStatus output
+            let tx_status = libpq_sys::PQtransactionStatus((&conn).into());
+            debug!("Transaction status: {:?}", tx_status);
+            
+            // PQserverVersion output
+            let server_version = libpq_sys::PQserverVersion((&conn).into());
+            let major = server_version / 10000;
+            let minor = (server_version / 100) % 100;
+            let revision = server_version % 100;
+            debug!("Server version: {}.{}.{} ({})", major, minor, revision, server_version);
+        
+        }
+
         // Apply the desired verbosity level
         debug!("Setting error verbosity to: {:?}", self.verbosity);
         unsafe {