Prepared psqlpy for OTLP

Signed-off-by: chandr-andr (Kiselev Aleksandr) <chandr@chandr.net>

Author: chandr-andr

python/psqlpy/_internal/__init__.pyi

@@ -288,6 +288,16 @@ class Cursor:
     It can be used as an asynchronous iterator.
     """
 
+    cursor_name: str
+    querystring: str
+    parameters: Sequence[Any]
+    prepared: bool | None
+    conn_dbname: str | None
+    user: str | None
+    host_addrs: list[str]
+    hosts: list[str]
+    ports: list[int]
+
     def __aiter__(self: Self) -> Self: ...
     async def __anext__(self: Self) -> QueryResult: ...
     async def __aenter__(self: Self) -> Self: ...
@@ -424,6 +434,12 @@ class Transaction:
     `.transaction()`.
     """
 
+    conn_dbname: str | None
+    user: str | None
+    host_addrs: list[str]
+    hosts: list[str]
+    ports: list[int]
+
     async def __aenter__(self: Self) -> Self: ...
     async def __aexit__(
         self: Self,
@@ -874,6 +890,12 @@ class Connection:
     It can be created only from connection pool.
     """
 
+    conn_dbname: str | None
+    user: str | None
+    host_addrs: list[str]
+    hosts: list[str]
+    ports: list[int]
+
     async def __aenter__(self: Self) -> Self: ...
     async def __aexit__(
         self: Self,

src/driver/connection.rs

@@ -2,8 +2,8 @@ use bytes::BytesMut;
 use deadpool_postgres::Pool;
 use futures_util::pin_mut;
 use pyo3::{buffer::PyBuffer, pyclass, pymethods, Py, PyAny, PyErr, Python};
-use std::{collections::HashSet, sync::Arc};
-use tokio_postgres::binary_copy::BinaryCopyInWriter;
+use std::{collections::HashSet, net::IpAddr, sync::Arc};
+use tokio_postgres::{binary_copy::BinaryCopyInWriter, config::Host, Config};
 
 use crate::{
     exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
@@ -24,12 +24,21 @@ use super::{
 pub struct Connection {
     db_client: Option<Arc<PsqlpyConnection>>,
     db_pool: Option<Pool>,
+    pg_config: Arc<Config>,
 }
 
 impl Connection {
     #[must_use]
-    pub fn new(db_client: Option<Arc<PsqlpyConnection>>, db_pool: Option<Pool>) -> Self {
-        Connection { db_client, db_pool }
+    pub fn new(
+        db_client: Option<Arc<PsqlpyConnection>>,
+        db_pool: Option<Pool>,
+        pg_config: Arc<Config>,
+    ) -> Self {
+        Connection {
+            db_client,
+            db_pool,
+            pg_config,
+        }
     }
 
     #[must_use]
@@ -45,12 +54,70 @@ impl Connection {
 
 impl Default for Connection {
     fn default() -> Self {
-        Connection::new(None, None)
+        Connection::new(None, None, Arc::new(Config::default()))
     }
 }
 
 #[pymethods]
 impl Connection {
+    #[getter]
+    fn conn_dbname(&self) -> Option<&str> {
+        self.pg_config.get_dbname()
+    }
+
+    #[getter]
+    fn user(&self) -> Option<&str> {
+        self.pg_config.get_user()
+    }
+
+    #[getter]
+    fn host_addrs(&self) -> Vec<String> {
+        let mut host_addrs_vec = vec![];
+
+        let host_addrs = self.pg_config.get_hostaddrs();
+        for ip_addr in host_addrs {
+            match ip_addr {
+                IpAddr::V4(ipv4) => {
+                    host_addrs_vec.push(ipv4.to_string());
+                }
+                IpAddr::V6(ipv6) => {
+                    host_addrs_vec.push(ipv6.to_string());
+                }
+            }
+        }
+
+        host_addrs_vec
+    }
+
+    #[getter]
+    fn hosts(&self) -> Vec<String> {
+        let mut hosts_vec = vec![];
+
+        let hosts = self.pg_config.get_hosts();
+        for host in hosts {
+            match host {
+                Host::Tcp(host) => {
+                    hosts_vec.push(host.to_string());
+                }
+                Host::Unix(host) => {
+                    hosts_vec.push(host.display().to_string());
+                }
+            }
+        }
+
+        hosts_vec
+    }
+
+    #[getter]
+    fn ports(&self) -> Vec<&u16> {
+        return self.pg_config.get_ports().iter().collect::<Vec<&u16>>();
+    }
+
+    #[getter]
+    fn options(&self) -> Option<&str> {
+        return self.pg_config.get_options();
+    }
+
     async fn __aenter__<'a>(self_: Py<Self>) -> RustPSQLDriverPyResult<Py<Self>> {
         let (db_client, db_pool) = pyo3::Python::with_gil(|gil| {
             let self_ = self_.borrow(gil);
@@ -283,6 +350,7 @@ impl Connection {
         if let Some(db_client) = &self.db_client {
             return Ok(Transaction::new(
                 db_client.clone(),
+                self.pg_config.clone(),
                 false,
                 false,
                 isolation_level,
@@ -318,6 +386,7 @@ impl Connection {
         if let Some(db_client) = &self.db_client {
             return Ok(Cursor::new(
                 db_client.clone(),
+                self.pg_config.clone(),
                 querystring,
                 parameters,
                 "cur_name".into(),

src/driver/connection_pool.rs

@@ -139,10 +139,10 @@ pub fn connect(
     let pool = db_pool_builder.build()?;
 
     Ok(ConnectionPool {
-        pool,
-        pg_config,
-        ca_file,
-        ssl_mode,
+        pool: pool,
+        pg_config: Arc::new(pg_config),
+        ca_file: ca_file,
+        ssl_mode: ssl_mode,
     })
 }
 
@@ -208,7 +208,7 @@ impl ConnectionPoolStatus {
 #[pyclass(subclass)]
 pub struct ConnectionPool {
     pool: Pool,
-    pg_config: Config,
+    pg_config: Arc<Config>,
     ca_file: Option<String>,
     ssl_mode: Option<SslMode>,
 }
@@ -222,10 +222,10 @@ impl ConnectionPool {
         ssl_mode: Option<SslMode>,
     ) -> Self {
         ConnectionPool {
-            pool,
-            pg_config,
-            ca_file,
-            ssl_mode,
+            pool: pool,
+            pg_config: Arc::new(pg_config),
+            ca_file: ca_file,
+            ssl_mode: ssl_mode,
         }
     }
 }
@@ -499,7 +499,7 @@ impl ConnectionPool {
 
     #[must_use]
     pub fn acquire(&self) -> Connection {
-        Connection::new(None, Some(self.pool.clone()))
+        Connection::new(None, Some(self.pool.clone()), self.pg_config.clone())
     }
 
     #[must_use]
@@ -522,7 +522,10 @@ impl ConnectionPool {
     /// # Errors
     /// May return Err Result if cannot get new connection from the pool.
     pub async fn connection(self_: pyo3::Py<Self>) -> RustPSQLDriverPyResult<Connection> {
-        let db_pool = pyo3::Python::with_gil(|gil| self_.borrow(gil).pool.clone());
+        let (db_pool, pg_config) = pyo3::Python::with_gil(|gil| {
+            let slf = self_.borrow(gil);
+            (slf.pool.clone(), slf.pg_config.clone())
+        });
         let db_connection = tokio_runtime()
             .spawn(async move {
                 Ok::<deadpool_postgres::Object, RustPSQLDriverError>(db_pool.get().await?)
@@ -532,6 +535,7 @@ impl ConnectionPool {
         Ok(Connection::new(
             Some(Arc::new(PsqlpyConnection::PoolConn(db_connection))),
             None,
+            pg_config,
         ))
     }
 

src/driver/cursor.rs

@@ -1,8 +1,9 @@
-use std::sync::Arc;
+use std::{net::IpAddr, sync::Arc};
 
 use pyo3::{
     exceptions::PyStopAsyncIteration, pyclass, pymethods, Py, PyAny, PyErr, PyObject, Python,
 };
+use tokio_postgres::{config::Host, Config};
 
 use crate::{
     exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
@@ -90,6 +91,7 @@ impl CursorObjectTrait for PsqlpyConnection {
 #[pyclass(subclass)]
 pub struct Cursor {
     db_transaction: Option<Arc<PsqlpyConnection>>,
+    pg_config: Arc<Config>,
     querystring: String,
     parameters: Option<Py<PyAny>>,
     cursor_name: String,
@@ -104,6 +106,7 @@ impl Cursor {
     #[must_use]
     pub fn new(
         db_transaction: Arc<PsqlpyConnection>,
+        pg_config: Arc<Config>,
         querystring: String,
         parameters: Option<Py<PyAny>>,
         cursor_name: String,
@@ -113,6 +116,7 @@ impl Cursor {
     ) -> Self {
         Cursor {
             db_transaction: Some(db_transaction),
+            pg_config,
             querystring,
             parameters,
             cursor_name,
@@ -127,6 +131,79 @@ impl Cursor {
 
 #[pymethods]
 impl Cursor {
+    #[getter]
+    fn conn_dbname(&self) -> Option<&str> {
+        self.pg_config.get_dbname()
+    }
+
+    #[getter]
+    fn user(&self) -> Option<&str> {
+        self.pg_config.get_user()
+    }
+
+    #[getter]
+    fn host_addrs(&self) -> Vec<String> {
+        let mut host_addrs_vec = vec![];
+
+        let host_addrs = self.pg_config.get_hostaddrs();
+        for ip_addr in host_addrs {
+            match ip_addr {
+                IpAddr::V4(ipv4) => {
+                    host_addrs_vec.push(ipv4.to_string());
+                }
+                IpAddr::V6(ipv6) => {
+                    host_addrs_vec.push(ipv6.to_string());
+                }
+            }
+        }
+
+        host_addrs_vec
+    }
+
+    #[getter]
+    fn hosts(&self) -> Vec<String> {
+        let mut hosts_vec = vec![];
+
+        let hosts = self.pg_config.get_hosts();
+        for host in hosts {
+            match host {
+                Host::Tcp(host) => {
+                    hosts_vec.push(host.to_string());
+                }
+                Host::Unix(host) => {
+                    hosts_vec.push(host.display().to_string());
+                }
+            }
+        }
+
+        hosts_vec
+    }
+
+    #[getter]
+    fn ports(&self) -> Vec<&u16> {
+        return self.pg_config.get_ports().iter().collect::<Vec<&u16>>();
+    }
+
+    #[getter]
+    fn cursor_name(&self) -> String {
+        return self.cursor_name.clone();
+    }
+
+    #[getter]
+    fn querystring(&self) -> String {
+        return self.querystring.clone();
+    }
+
+    #[getter]
+    fn parameters(&self) -> Option<Py<PyAny>> {
+        return self.parameters.clone();
+    }
+
+    #[getter]
+    fn prepared(&self) -> Option<bool> {
+        return self.prepared.clone();
+    }
+
     #[must_use]
     fn __aiter__(slf: Py<Self>) -> Py<Self> {
         slf

src/driver/listener/core.rs

@@ -28,7 +28,7 @@ use super::structs::{
 
 #[pyclass]
 pub struct Listener {
-    pg_config: Config,
+    pg_config: Arc<Config>,
     ca_file: Option<String>,
     ssl_mode: Option<SslMode>,
     channel_callbacks: Arc<RwLock<ChannelCallbacks>>,
@@ -42,14 +42,14 @@ pub struct Listener {
 
 impl Listener {
     #[must_use]
-    pub fn new(pg_config: Config, ca_file: Option<String>, ssl_mode: Option<SslMode>) -> Self {
+    pub fn new(pg_config: Arc<Config>, ca_file: Option<String>, ssl_mode: Option<SslMode>) -> Self {
         Listener {
-            pg_config,
+            pg_config: pg_config.clone(),
             ca_file,
             ssl_mode,
             channel_callbacks: Arc::default(),
             listen_abort_handler: Option::default(),
-            connection: Connection::new(None, None),
+            connection: Connection::new(None, None, pg_config.clone()),
             receiver: Option::default(),
             listen_query: Arc::default(),
             is_listened: Arc::new(RwLock::new(false)),
@@ -218,8 +218,11 @@ impl Listener {
         tokio_runtime().spawn(connection);
 
         self.receiver = Some(Arc::new(RwLock::new(receiver)));
-        self.connection =
-            Connection::new(Some(Arc::new(PsqlpyConnection::SingleConn(client))), None);
+        self.connection = Connection::new(
+            Some(Arc::new(PsqlpyConnection::SingleConn(client))),
+            None,
+            self.pg_config.clone(),
+        );
 
         self.is_started = true;