feat(pgwire): support current_setting() SQL function

farhan-syah · farhan-syah · commit f9e21b3f6fd2 · 2026-07-02T05:30:30.000+08:00
Extracts SHOW's GUC resolution into a shared resolve_guc helper and
adds a current_setting('name' [, missing_ok]) handler that reuses it,
covering the common ORM/driver pattern of querying server_version and
other runtime parameters via SELECT rather than SHOW.
diff --git a/nodedb/src/control/server/pgwire/handler/current_setting.rs b/nodedb/src/control/server/pgwire/handler/current_setting.rs
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+//! `current_setting(setting_name [, missing_ok])` — PostgreSQL's function
+//! form of `SHOW <param>`. Resolves from the same GUC sources as `SHOW`
+//! (see `session_show::resolve_guc`), but as a scalar function call so it
+//! can appear in `SELECT` lists like any other function.
+
+use std::sync::Arc;
+
+use pgwire::api::results::{DataRowEncoder, QueryResponse, Response};
+use pgwire::error::{ErrorInfo, PgWireError, PgWireResult};
+
+use super::super::types::text_field;
+use super::core::NodeDbPgHandler;
+
+/// Parse `SELECT current_setting('name')` or
+/// `SELECT current_setting('name', true|false)` into `(setting_name,
+/// missing_ok)`. Case-insensitive on the keyword; the setting name is
+/// lowercased to match `resolve_guc`'s expectation. Returns `None` if the
+/// SQL is not a `current_setting` call so normal planning can proceed.
+///
+/// Only string-literal arguments are handled. If the second argument isn't
+/// a clear `true`/`false` literal, `missing_ok` defaults to `false`
+/// (conservative — an unrecognised second arg should not silently suppress
+/// errors).
+pub fn parse_current_setting(sql: &str) -> Option<(String, bool)> {
+    let trimmed = sql.trim().trim_end_matches(';').trim();
+    let trimmed_upper = trimmed.to_uppercase();
+    if !trimmed_upper.starts_with("SELECT ") {
+        return None;
+    }
+
+    let rest = trimmed[7..].trim();
+    let rest_upper = rest.to_uppercase();
+    if !rest_upper.starts_with("CURRENT_SETTING(") {
+        return None;
+    }
+
+    let paren = rest.find('(')?;
+    let close = rest.rfind(')')?;
+    if close <= paren + 1 {
+        return None;
+    }
+    let args = &rest[paren + 1..close];
+
+    let parts: Vec<&str> = args.split(',').map(str::trim).collect();
+    let (name_arg, missing_ok_arg) = match parts.as_slice() {
+        [name] => (*name, None),
+        [name, missing_ok] => (*name, Some(*missing_ok)),
+        _ => return None,
+    };
+
+    let name = strip_quotes(name_arg)?;
+    if name.is_empty() {
+        return None;
+    }
+
+    let missing_ok = match missing_ok_arg {
+        Some(v) => v.eq_ignore_ascii_case("true"),
+        None => false,
+    };
+
+    Some((name.to_lowercase(), missing_ok))
+}
+
+/// Strip a single-quoted SQL string literal into its raw inner value.
+/// Escapes are not honored.
+fn strip_quotes(s: &str) -> Option<String> {
+    let s = s.trim();
+    if s.len() >= 2 {
+        let first = s.as_bytes()[0];
+        let last = s.as_bytes()[s.len() - 1];
+        if first == b'\'' && last == b'\'' {
+            let inner = &s[1..s.len() - 1];
+            if !inner.contains('\'') {
+                return Some(inner.to_string());
+            }
+        }
+    }
+    None
+}
+
+impl NodeDbPgHandler {
+    /// Handle `SELECT current_setting('name' [, missing_ok])`.
+    pub(super) fn handle_current_setting(
+        &self,
+        addr: &std::net::SocketAddr,
+        sql: &str,
+    ) -> PgWireResult<Vec<Response>> {
+        let (name, missing_ok) = match parse_current_setting(sql) {
+            Some(parsed) => parsed,
+            None => {
+                return Err(PgWireError::UserError(Box::new(ErrorInfo::new(
+                    "ERROR".to_owned(),
+                    "42601".to_owned(),
+                    "syntax error: current_setting('name' [, missing_ok])".to_owned(),
+                ))));
+            }
+        };
+
+        let schema = Arc::new(vec![text_field("current_setting")]);
+        let mut encoder = DataRowEncoder::new(schema.clone());
+
+        match self.resolve_guc(addr, &name) {
+            Ok(value) => {
+                encoder.encode_field(&value)?;
+            }
+            Err(e) => {
+                if missing_ok {
+                    encoder.encode_field(&Option::<String>::None)?;
+                } else {
+                    return Err(e);
+                }
+            }
+        }
+
+        let row = encoder.take_row();
+        Ok(vec![Response::Query(QueryResponse::new(
+            schema,
+            futures::stream::iter(vec![Ok(row)]),
+        ))])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_single_arg_form() {
+        assert_eq!(
+            parse_current_setting("SELECT current_setting('server_version_num')"),
+            Some(("server_version_num".to_string(), false))
+        );
+    }
+
+    #[test]
+    fn parses_missing_ok_true() {
+        assert_eq!(
+            parse_current_setting("SELECT current_setting('nodedb.foo', true)"),
+            Some(("nodedb.foo".to_string(), true))
+        );
+    }
+
+    #[test]
+    fn parses_missing_ok_false() {
+        assert_eq!(
+            parse_current_setting("SELECT current_setting('nodedb.foo', false)"),
+            Some(("nodedb.foo".to_string(), false))
+        );
+    }
+
+    #[test]
+    fn lowercases_setting_name() {
+        assert_eq!(
+            parse_current_setting("SELECT current_setting('SERVER_VERSION')"),
+            Some(("server_version".to_string(), false))
+        );
+    }
+
+    #[test]
+    fn is_case_insensitive_on_keyword() {
+        assert_eq!(
+            parse_current_setting("select CURRENT_SETTING('server_version')"),
+            Some(("server_version".to_string(), false))
+        );
+    }
+
+    #[test]
+    fn accepts_trailing_semicolon() {
+        assert_eq!(
+            parse_current_setting("SELECT current_setting('server_version');"),
+            Some(("server_version".to_string(), false))
+        );
+    }
+
+    #[test]
+    fn unclear_second_arg_defaults_to_false() {
+        assert_eq!(
+            parse_current_setting("SELECT current_setting('server_version', maybe)"),
+            Some(("server_version".to_string(), false))
+        );
+    }
+
+    #[test]
+    fn rejects_unrelated_select() {
+        assert_eq!(parse_current_setting("SELECT 1"), None);
+        assert_eq!(parse_current_setting("SELECT version()"), None);
+    }
+
+    #[test]
+    fn rejects_empty_arg() {
+        assert_eq!(parse_current_setting("SELECT current_setting()"), None);
+        assert_eq!(parse_current_setting("SELECT current_setting('')"), None);
+    }
+}
diff --git a/nodedb/src/control/server/pgwire/handler/mod.rs b/nodedb/src/control/server/pgwire/handler/mod.rs
@@ -2,6 +2,7 @@
 
 mod copy_handler;
 mod core;
+mod current_setting;
 mod cursor_cmds;
 mod cursor_query;
 mod dispatch;
diff --git a/nodedb/src/control/server/pgwire/handler/session_show.rs b/nodedb/src/control/server/pgwire/handler/session_show.rs
@@ -20,7 +20,7 @@ impl NodeDbPgHandler {
         addr: &std::net::SocketAddr,
         sql: &str,
     ) -> PgWireResult<Vec<Response>> {
-        use super::super::session::{is_known_pg_runtime_parameter, parse_show_command};
+        use super::super::session::parse_show_command;
         use pgwire::error::ErrorInfo;
 
         let param = match parse_show_command(sql) {
@@ -72,48 +72,59 @@ impl NodeDbPgHandler {
             ))]);
         }
 
-        // Resolve the value from the runtime-parameter sources in order:
-        // built-in PG runtime constants first, then a value explicitly set
-        // by `SET` in this session. If neither matches and the parameter
-        // is not on the known-parameter allowlist, return `42704`
-        // (`undefined_object`) — the same SQLSTATE PostgreSQL uses when
-        // a client requests an unrecognised runtime parameter. This
-        // prevents administrative commands like `SHOW DATABASES`,
-        // `SHOW ROLES`, `SHOW STATS`, `SHOW METRICS`, `SHOW MEMORY`
-        // from being silently swallowed as if they were unset session
-        // parameters; those commands are routed through the DDL / AST
-        // router before this handler is reached.
-        let builtin = match param.as_str() {
+        let value = self.resolve_guc(addr, &param)?;
+
+        let schema = Arc::new(vec![text_field(&param)]);
+        let mut encoder = DataRowEncoder::new(schema.clone());
+        encoder.encode_field(&value)?;
+        let row = encoder.take_row();
+        Ok(vec![Response::Query(QueryResponse::new(
+            schema,
+            futures::stream::iter(vec![Ok(row)]),
+        ))])
+    }
+
+    /// Resolve a runtime parameter (GUC) value the same way `SHOW <param>`
+    /// does: built-in PG-compat constants first, then a value explicitly
+    /// set by `SET` in this session. If neither matches and the parameter
+    /// is not on the known-parameter allowlist, return `42704`
+    /// (`undefined_object`) — the same SQLSTATE PostgreSQL uses when a
+    /// client requests an unrecognised runtime parameter. This prevents
+    /// administrative commands like `SHOW DATABASES`, `SHOW ROLES`,
+    /// `SHOW STATS`, `SHOW METRICS`, `SHOW MEMORY` from being silently
+    /// swallowed as if they were unset session parameters; those commands
+    /// are routed through the DDL / AST router before this handler is
+    /// reached.
+    pub(super) fn resolve_guc(
+        &self,
+        addr: &std::net::SocketAddr,
+        param: &str,
+    ) -> PgWireResult<String> {
+        use super::super::session::is_known_pg_runtime_parameter;
+        use pgwire::error::ErrorInfo;
+
+        let builtin = match param {
             "server_version" => Some(format!("NodeDB {}", crate::version::VERSION)),
             "server_version_num" => Some(nodedb_types::pg_compat::PG_COMPAT_VERSION_NUM.to_owned()),
             "server_encoding" => Some("UTF8".into()),
             _ => None,
         };
-        let session_value = self.sessions.get_parameter(addr, &param);
+        let session_value = self.sessions.get_parameter(addr, param);
 
-        let value = match (builtin, session_value) {
-            (Some(v), _) => v,
-            (None, Some(v)) => v,
+        match (builtin, session_value) {
+            (Some(v), _) => Ok(v),
+            (None, Some(v)) => Ok(v),
             (None, None) => {
-                if !is_known_pg_runtime_parameter(&param) {
+                if !is_known_pg_runtime_parameter(param) {
                     return Err(PgWireError::UserError(Box::new(ErrorInfo::new(
                         "ERROR".to_owned(),
                         "42704".to_owned(),
                         format!("unrecognized configuration parameter \"{param}\""),
                     ))));
                 }
-                String::new()
+                Ok(String::new())
             }
-        };
-
-        let schema = Arc::new(vec![text_field(&param)]);
-        let mut encoder = DataRowEncoder::new(schema.clone());
-        encoder.encode_field(&value)?;
-        let row = encoder.take_row();
-        Ok(vec![Response::Query(QueryResponse::new(
-            schema,
-            futures::stream::iter(vec![Ok(row)]),
-        ))])
+        }
     }
 
     /// SHOW ALL — return all session parameters.
diff --git a/nodedb/src/control/server/pgwire/handler/sql_exec.rs b/nodedb/src/control/server/pgwire/handler/sql_exec.rs
@@ -292,6 +292,10 @@ impl NodeDbPgHandler {
                 .await;
         }
 
+        if upper.starts_with("SELECT CURRENT_SETTING") {
+            return self.handle_current_setting(addr, sql_trimmed);
+        }
+
         // ── USE DATABASE — session reset ──────────────────────────────
         // Intercepted before the DDL router because it requires access to both
         // `self.sessions` and `addr` for the per-connection state reset.
diff --git a/nodedb/tests/wire_server_version.rs b/nodedb/tests/wire_server_version.rs
@@ -44,6 +44,42 @@ async fn pgwire_show_server_version_num_returns_pg_compat_number() {
     );
 }
 
+#[tokio::test]
+async fn pgwire_current_setting_server_version_num() {
+    let srv = TestServer::start().await;
+    let rows = srv
+        .query_text("SELECT current_setting('server_version_num')")
+        .await
+        .unwrap();
+    assert_eq!(rows.len(), 1, "got {rows:?}");
+    assert!(
+        rows[0].trim().parse::<i64>().is_ok(),
+        "must be numeric, got {rows:?}"
+    );
+}
+
+#[tokio::test]
+async fn pgwire_current_setting_server_version_is_nodedb() {
+    let srv = TestServer::start().await;
+    let rows = srv
+        .query_text("SELECT current_setting('server_version')")
+        .await
+        .unwrap();
+    assert_eq!(rows.len(), 1);
+    assert!(rows[0].contains("NodeDB"), "got {rows:?}");
+}
+
+#[tokio::test]
+async fn pgwire_current_setting_unknown_missing_ok_true_is_null() {
+    let srv = TestServer::start().await;
+    // missing_ok = true → NULL (empty text over the wire), not an error.
+    let rows = srv
+        .query_text("SELECT current_setting('nodedb.does_not_exist', true)")
+        .await
+        .unwrap();
+    assert_eq!(rows.len(), 1, "got {rows:?}");
+}
+
 /// No file under `src/control/server/` may embed digits directly inside a
 /// `"NodeDB ..."`, `"NodeDB/..."`, or `nodedb_version:...` literal — every
 /// wire-surface version must format `crate::version::VERSION` in.
