feat: make SQL_ATTR_CURRENT_CATALOG readable and applied, and export SQL_PARAM_*

The spec makes SQL_ATTR_CURRENT_CATALOG and SQL_DATABASE_NAME one value under
two names, but the attribute was handle-local and write-only: SQLGetConnectAttr
answered "" while SQLGetInfo answered the real catalog, and setting it returned
SQL_SUCCESS while switching nothing. Reported from the Trino driver, where the
derivation added in b2f79b7 was correct in principle and inert in practice.

Two defaulted Backend methods close it. current_catalog reports the session's
catalog, and both readers now consult the same two sources in the same order —
what the application set, else what the session is using. set_current_catalog
applies a change, and SQLSetConnectAttr stores the value only once it succeeds;
the default reports HYC00, since storing a catalog the session never switched
to tells an application its unqualified names resolve somewhere they do not. A
value set before connecting is applied at connect, alongside autocommit and
isolation.

SQL_PARAM_SUCCESS and its four siblings move from pub(crate) in ffi::params to
public constants in types. odbc-sys lacks them, so a driver asserting what its
own executions wrote into SQL_ATTR_PARAM_STATUS_PTR had to declare local
copies.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: maltesander

CHANGELOG.md

@@ -56,6 +56,24 @@ Everything a driver has to change for the catalog rework, in one place.
 
 ### Added
 
+- `Backend::current_catalog` and `Backend::set_current_catalog`, both defaulted,
+  make `SQL_ATTR_CURRENT_CATALOG` more than a handle-local string.
+  `SQLGetConnectAttr` and `SQLGetInfo(SQL_DATABASE_NAME)` — one value under two
+  names, per the spec — now read the same two sources in the same order: what
+  the application set, else what the session is actually using. Without the
+  second source the attribute was write-only, answering `""` while the info type
+  answered the real catalog. `SQLSetConnectAttr` asks the backend to switch and
+  stores the value only if that succeeds; the default reports `HYC00`, because
+  storing a catalog the session never switched to tells an application its
+  unqualified names resolve somewhere they do not. A value set before connecting
+  is applied at connect, like autocommit and isolation.
+
+- `SQL_PARAM_SUCCESS`, `SQL_PARAM_ERROR`, `SQL_PARAM_SUCCESS_WITH_INFO`,
+  `SQL_PARAM_UNUSED` and `SQL_PARAM_DIAG_UNAVAILABLE` are public in
+  `types`. `odbc-sys` does not define them, and a driver asserting what its own
+  executions wrote into `SQL_ATTR_PARAM_STATUS_PTR` needs to name them rather
+  than declare local copies.
+
 - `conformance::info_group_inconsistencies` checks the `SQLGetInfo` groups whose
   members constrain each other, and returns one message per violation. Core
   cannot police a backend's `get_info` at runtime — that method runs first and

src/backend.rs

@@ -179,6 +179,42 @@ pub trait Backend: Sized + Send + Sync + 'static {
         info_type: crate::types::InfoType,
     ) -> Result<InfoValue, Self::Error>;
 
+    /// The catalog the session is currently using, if the data source has a
+    /// current catalog at all.
+    ///
+    /// Read by `SQLGetConnectAttr(SQL_ATTR_CURRENT_CATALOG)` and, because the
+    /// spec makes them one value, by `SQLGetInfo(SQL_DATABASE_NAME)`. An
+    /// application's own `SQLSetConnectAttr` value takes precedence, since that
+    /// is what it asked for; this answers when it has set nothing.
+    ///
+    /// Defaults to `None`, meaning "this data source has no current catalog to
+    /// report" — the empty string, which is what both readers then produce.
+    ///
+    /// A backend that returns `Some` should also implement
+    /// [`Backend::set_current_catalog`], or an application can read the catalog
+    /// and not change it.
+    fn current_catalog(_conn: &Self::Connection) -> Option<Cow<'static, str>> {
+        None
+    }
+
+    /// Switch the session to `catalog`.
+    ///
+    /// Called by `SQLSetConnectAttr(SQL_ATTR_CURRENT_CATALOG)`. The spec's
+    /// example is a driver sending `USE database`; for a single-tier driver it
+    /// may be changing a directory.
+    ///
+    /// The default reports `HYC00`, which is the honest answer for a backend
+    /// that cannot switch catalogs: storing the value and returning
+    /// `SQL_SUCCESS` would tell an application its unqualified names now
+    /// resolve somewhere they do not. Core stores the value only once this
+    /// returns `Ok`.
+    fn set_current_catalog(_conn: &Self::Connection, _catalog: &str) -> Result<(), Self::Error> {
+        Err(OdbcError::NotImplemented {
+            feature: "SQL_ATTR_CURRENT_CATALOG".into(),
+        }
+        .into())
+    }
+
     /// Return driver-level info that does not require an active connection.
     ///
     /// The Windows Driver Manager calls `SQLGetInfoW` for types like

src/ffi/connect_attr.rs

@@ -1,5 +1,6 @@
 //! Generic implementations of SQLSetConnectAttrW and SQLGetConnectAttrW.
 
+use std::borrow::Cow;
 use std::ffi::c_void;
 
 use odbc_sys::ConnectionAttribute;
@@ -44,7 +45,26 @@ pub(crate) fn apply_pending_connect_attrs<B: Backend>(
     handle: &mut ConnectionHandle<B>,
 ) -> Result<(), OdbcError> {
     apply_pending_autocommit::<B>(handle)?;
-    apply_pending_txn_isolation::<B>(handle)
+    apply_pending_txn_isolation::<B>(handle)?;
+    apply_pending_current_catalog::<B>(handle)
+}
+
+/// Apply a `SQL_ATTR_CURRENT_CATALOG` value that was set before the connection
+/// was open. See [`apply_pending_connect_attrs`].
+fn apply_pending_current_catalog<B: Backend>(
+    handle: &mut ConnectionHandle<B>,
+) -> Result<(), OdbcError> {
+    let Some(catalog) = handle
+        .attr_strings
+        .get(&ConnectionAttribute::CURRENT_CATALOG.0)
+        .cloned()
+    else {
+        return Ok(());
+    };
+    let Some(connection) = handle.connection.as_ref() else {
+        return Ok(());
+    };
+    B::set_current_catalog(connection, &catalog).into_odbc()
 }
 
 /// Apply a `SQL_ATTR_AUTOCOMMIT` value that was set before the connection was
@@ -382,7 +402,12 @@ pub unsafe fn sql_set_connect_attr_w<B: Backend>(
                     Ok(SqlReturn::SUCCESS)
                 }
 
-                // String-valued: SQL_ATTR_CURRENT_CATALOG — decode UTF-16.
+                // String-valued: SQL_ATTR_CURRENT_CATALOG — decode UTF-16, then
+                // ask the backend to switch. Storing without switching would
+                // tell an application its unqualified names now resolve
+                // somewhere they do not; a backend that cannot switch reports
+                // HYC00 from the default `set_current_catalog`, and nothing is
+                // stored.
                 _ if attr == ConnectionAttribute::CURRENT_CATALOG => {
                     if value_ptr.is_null() {
                         conn.attr_strings.remove(&attribute);
@@ -400,6 +425,14 @@ pub unsafe fn sql_set_connect_attr_w<B: Backend>(
                             string_length / 2
                         };
                         let s = utf16_to_string(value_ptr as *const u16, len_code_units)?;
+                        // Applied here when connected; a value set before the
+                        // connection exists is stored and applied by
+                        // `apply_pending_current_catalog` at connect, since the
+                        // spec lists this attribute as settable either side of
+                        // one.
+                        if let Some(connection) = conn.connection.as_ref() {
+                            B::set_current_catalog(connection, &s).into_odbc()?;
+                        }
                         conn.attr_strings.insert(attribute, s);
                     }
                     Ok(SqlReturn::SUCCESS)
@@ -652,12 +685,22 @@ pub unsafe fn sql_get_connect_attr_w<B: Backend>(
                     Ok(SqlReturn::SUCCESS)
                 }
 
-                // SQL_ATTR_CURRENT_CATALOG: return stored string or empty.
+                // SQL_ATTR_CURRENT_CATALOG: what the application set, else what
+                // the session is actually using. Without the second half this
+                // attribute is write-only — it answers "" while
+                // `SQLGetInfo(SQL_DATABASE_NAME)`, which the spec makes the same
+                // value, answers the real catalog.
                 _ if attr == ConnectionAttribute::CURRENT_CATALOG => {
                     let s = conn
                         .attr_strings
                         .get(&attribute)
                         .cloned()
+                        .or_else(|| {
+                            conn.connection
+                                .as_ref()
+                                .and_then(|c| B::current_catalog(c))
+                                .map(Cow::into_owned)
+                        })
                         .unwrap_or_default();
                     // write_utf16 takes buf_len and len_ptr as i16 (SQLSMALLINT),
                     // but GetConnectAttrW uses i32 (SQLINTEGER). Validate the
@@ -702,7 +745,7 @@ mod tests {
     use super::*;
     use crate::ffi::handle::{sql_alloc_handle, sql_free_handle};
     use crate::test_utils::{
-        MockBackend, MockConnection, MockIsolationBackend, MockIsolationConnection,
+        MockAltBackend, MockBackend, MockConnection, MockIsolationBackend, MockIsolationConnection,
         MockUnappliedIsolationBackend, with_handle,
     };
     use odbc_sys::HandleType;
@@ -932,6 +975,50 @@ mod tests {
         }
     }
 
+    /// `SQL_ATTR_CURRENT_CATALOG` and `SQL_DATABASE_NAME` are one value under
+    /// two names, so they must read the same two sources in the same order:
+    /// what the application set, else what the session is actually using. With
+    /// only the first, the attribute is write-only — it answers `""` while the
+    /// info type answers the real catalog.
+    #[test]
+    fn current_catalog_falls_back_to_the_session_catalog() {
+        unsafe {
+            let (env, conn) = alloc_env_conn_for::<MockAltBackend>();
+            assert_eq!(driver_connect::<MockAltBackend>(conn), SqlReturn::SUCCESS);
+
+            let mut buf = [0u16; 64];
+            let mut len: i32 = 0;
+            assert_eq!(
+                sql_get_connect_attr_w::<MockAltBackend>(
+                    conn,
+                    ConnectionAttribute::CURRENT_CATALOG.0,
+                    buf.as_mut_ptr().cast(),
+                    (buf.len() * 2) as i32,
+                    &mut len,
+                ),
+                SqlReturn::SUCCESS
+            );
+            let attr = String::from_utf16_lossy(&buf[..(len / 2) as usize]);
+            assert_eq!(
+                attr, "alt_catalog",
+                "the attribute must report the session catalog when the \
+                 application has set none"
+            );
+
+            // The same value under its other name.
+            let (_, info) = crate::conformance::observe_string_value::<MockAltBackend>(
+                conn,
+                crate::types::SQL_DATABASE_NAME,
+            );
+            assert_eq!(
+                info, attr,
+                "SQL_DATABASE_NAME and SQL_ATTR_CURRENT_CATALOG disagree"
+            );
+
+            cleanup_for::<MockAltBackend>(env, conn);
+        }
+    }
+
     /// `SQL_ATTR_ASYNC_ENABLE` and `SQL_ATTR_ODBC_CURSORS` are the two
     /// connection attributes the spec declares `SQLULEN` — "A SQLULEN value
     /// that specifies whether a function called with a statement on the

src/ffi/execute.rs

@@ -18,9 +18,9 @@ use crate::utf16::utf16_to_string;
 /// See [`crate::ffi::params::report_params_processed`].
 unsafe fn report_param_set<B: Backend>(stmt: &StatementHandle<B>, succeeded: bool) {
     let status = if succeeded {
-        crate::ffi::params::SQL_PARAM_SUCCESS
+        crate::types::SQL_PARAM_SUCCESS
     } else {
-        crate::ffi::params::SQL_PARAM_ERROR
+        crate::types::SQL_PARAM_ERROR
     };
     // SAFETY: the caller's contract, forwarded.
     unsafe { crate::ffi::params::report_params_processed(stmt, status) };
@@ -1171,7 +1171,7 @@ mod tests {
             );
             assert_eq!(
                 status,
-                crate::ffi::params::SQL_PARAM_SUCCESS,
+                crate::types::SQL_PARAM_SUCCESS,
                 "SQL_ATTR_PARAM_STATUS_PTR was not written"
             );
 
@@ -1218,7 +1218,7 @@ mod tests {
             );
 
             assert_eq!(processed, 1);
-            assert_eq!(status, crate::ffi::params::SQL_PARAM_ERROR);
+            assert_eq!(status, crate::types::SQL_PARAM_ERROR);
 
             cleanup_env_conn_stmt_for::<MockBackend>(env, conn, stmt);
         }

src/ffi/info.rs

@@ -359,10 +359,21 @@ pub unsafe fn sql_get_info_w<B: Backend>(
             // `SQL_ATTR_CURRENT_CATALOG`, which the spec makes the same value
             // as `SQL_DATABASE_NAME`. Read before the dispatch below, which
             // borrows the handle's diagnostics mutably.
+            // What the application set, else what the session is actually
+            // using — the same two sources, in the same order, that
+            // `SQLGetConnectAttr(SQL_ATTR_CURRENT_CATALOG)` reads. The spec
+            // makes these one value, so they must not consult different things.
             let current_catalog = handle
                 .attr_strings
                 .get(&odbc_sys::ConnectionAttribute::CURRENT_CATALOG.0)
-                .cloned();
+                .cloned()
+                .or_else(|| {
+                    handle
+                        .connection
+                        .as_ref()
+                        .and_then(|c| B::current_catalog(c))
+                        .map(std::borrow::Cow::into_owned)
+                });
             let current_catalog = current_catalog.as_deref();
             let info = match handle.connection.as_ref() {
                 Some(conn) => match info_type_id {

src/ffi/params.rs

@@ -14,8 +14,8 @@ use crate::{
     panic::panic_safe,
     types::{
         ColumnValue, ParamDescriptor, SQL_DATA_AT_EXEC, SQL_DEFAULT_PARAM_SIZE,
-        SQL_LEN_DATA_AT_EXEC_OFFSET, SQL_NTS, SQL_NULL_DATA, SqlReturn, SqlState, ULen,
-        c_data_type_from_raw, param_type_from_raw,
+        SQL_LEN_DATA_AT_EXEC_OFFSET, SQL_NTS, SQL_NULL_DATA, SQL_PARAM_ERROR, SQL_PARAM_SUCCESS,
+        SqlReturn, SqlState, ULen, c_data_type_from_raw, param_type_from_raw,
     },
     utf16::utf16_to_string,
 };
@@ -855,13 +855,6 @@ pub(crate) unsafe fn collect_params(
 /// # Safety
 /// Every output binding's `value_ptr` / `str_len_or_ind_ptr` must point to a
 /// valid writable buffer, as guaranteed by the `SQLBindParameter` contract.
-/// `SQL_PARAM_SUCCESS` — the parameter-status value for a set the data source
-/// processed without a diagnostic.
-pub(crate) const SQL_PARAM_SUCCESS: u16 = 0;
-/// `SQL_PARAM_ERROR` — the parameter-status value for a set whose execution
-/// failed.
-pub(crate) const SQL_PARAM_ERROR: u16 = 5;
-
 /// Write one processed parameter set through `SQL_ATTR_PARAMS_PROCESSED_PTR`
 /// and `status` into the first element of `SQL_ATTR_PARAM_STATUS_PTR`, when the
 /// application set either.

src/test_utils.rs

@@ -468,6 +468,11 @@ impl Backend for MockBackend {
     fn quoted_identifier_case(_conn: &Self::Connection) -> u16 {
         crate::types::SQL_IC_SENSITIVE
     }
+    // Switching succeeds; `current_catalog` stays at its `None` default, so the
+    // getter's application-set branch is what these tests exercise.
+    fn set_current_catalog(_conn: &Self::Connection, _catalog: &str) -> Result<(), MockError> {
+        Ok(())
+    }
     // Non-`SQL_TC_NONE`, as `txn_isolation_options` above declares a level.
     fn txn_capable(_conn: &Self::Connection) -> u16 {
         crate::types::SQL_TC_ALL as u16
@@ -945,6 +950,15 @@ impl Backend for MockAltBackend {
     fn quoted_identifier_case(_conn: &Self::Connection) -> u16 {
         crate::types::SQL_IC_LOWER
     }
+    // Reports a session catalog, so the getter's fallback branch — and
+    // `SQL_DATABASE_NAME`, which reads the same two sources — have something to
+    // find when the application has set nothing.
+    fn current_catalog(_conn: &Self::Connection) -> Option<Cow<'static, str>> {
+        Some(Cow::Borrowed("alt_catalog"))
+    }
+    fn set_current_catalog(_conn: &Self::Connection, _catalog: &str) -> Result<(), MockError> {
+        Ok(())
+    }
     fn txn_capable(_conn: &Self::Connection) -> u16 {
         crate::types::SQL_TC_DML as u16
     }

src/types/constants.rs

@@ -199,6 +199,24 @@ pub const SQL_NC_START: u16 = 0x0002;
 /// the `ASC` / `DESC` keywords.
 pub const SQL_NC_END: u16 = 0x0004;
 
+/// The `SQL_PARAM_*` values a driver writes into the array
+/// `SQL_ATTR_PARAM_STATUS_PTR` points at, one per parameter set an execution
+/// processed. Absent from `odbc-sys`, and public here because a driver
+/// asserting what its own executions wrote needs to name them.
+///
+/// `SQL_PARAM_SUCCESS` — the set was processed without a diagnostic.
+pub const SQL_PARAM_SUCCESS: u16 = 0;
+/// `SQL_PARAM_DIAG_UNAVAILABLE` — the set produced a diagnostic the driver
+/// cannot attribute to it individually.
+pub const SQL_PARAM_DIAG_UNAVAILABLE: u16 = 1;
+/// `SQL_PARAM_ERROR` — the set's execution failed.
+pub const SQL_PARAM_ERROR: u16 = 5;
+/// `SQL_PARAM_SUCCESS_WITH_INFO` — processed, with a diagnostic raised for it.
+pub const SQL_PARAM_SUCCESS_WITH_INFO: u16 = 6;
+/// `SQL_PARAM_UNUSED` — not processed, because an earlier set's failure ended
+/// the execution.
+pub const SQL_PARAM_UNUSED: u16 = 7;
+
 /// `SQL_UNSPECIFIED` — it is unspecified whether cursors make visible the
 /// changes another cursor made to a result set; they "may make visible none,
 /// some, or all such changes". The spec's default for the

src/types/mod.rs

@@ -81,11 +81,12 @@ pub use constants::{
     SQL_NTS, SQL_NULL_DATA, SQL_NUMERIC_FUNCTIONS, SQL_ODBC_API_CONFORMANCE,
     SQL_ODBC_SAG_CLI_CONFORMANCE, SQL_ODBC_SQL_CONFORMANCE, SQL_OIC_CORE,
     SQL_OJ_ALL_COMPARISON_OPS, SQL_OJ_FULL, SQL_OJ_INNER, SQL_OJ_LEFT, SQL_OJ_NESTED,
-    SQL_OJ_NOT_ORDERED, SQL_OJ_RIGHT, SQL_OUTER_JOINS, SQL_PARC_BATCH, SQL_PARC_NO_BATCH,
-    SQL_PAS_BATCH, SQL_PAS_NO_BATCH, SQL_PAS_NO_SELECT, SQL_PC_NOT_PSEUDO, SQL_PC_PSEUDO,
-    SQL_PC_UNKNOWN, SQL_POSITION, SQL_PRED_BASIC, SQL_PRED_CHAR, SQL_PRED_NONE, SQL_PROCEDURE_TERM,
-    SQL_PROCEDURES, SQL_PT_FUNCTION, SQL_PT_PROCEDURE, SQL_PT_UNKNOWN, SQL_QUICK,
-    SQL_QUOTED_IDENTIFIER_CASE, SQL_REFRESH, SQL_RESTRICT, SQL_ROW_UPDATES, SQL_ROWVER,
+    SQL_OJ_NOT_ORDERED, SQL_OJ_RIGHT, SQL_OUTER_JOINS, SQL_PARAM_DIAG_UNAVAILABLE, SQL_PARAM_ERROR,
+    SQL_PARAM_SUCCESS, SQL_PARAM_SUCCESS_WITH_INFO, SQL_PARAM_UNUSED, SQL_PARC_BATCH,
+    SQL_PARC_NO_BATCH, SQL_PAS_BATCH, SQL_PAS_NO_BATCH, SQL_PAS_NO_SELECT, SQL_PC_NOT_PSEUDO,
+    SQL_PC_PSEUDO, SQL_PC_UNKNOWN, SQL_POSITION, SQL_PRED_BASIC, SQL_PRED_CHAR, SQL_PRED_NONE,
+    SQL_PROCEDURE_TERM, SQL_PROCEDURES, SQL_PT_FUNCTION, SQL_PT_PROCEDURE, SQL_PT_UNKNOWN,
+    SQL_QUICK, SQL_QUOTED_IDENTIFIER_CASE, SQL_REFRESH, SQL_RESTRICT, SQL_ROW_UPDATES, SQL_ROWVER,
     SQL_SC_FIPS127_2_TRANSITIONAL, SQL_SC_SQL92_ENTRY, SQL_SC_SQL92_FULL,
     SQL_SC_SQL92_INTERMEDIATE, SQL_SCOPE_CURROW, SQL_SCOPE_SESSION, SQL_SCOPE_TRANSACTION,
     SQL_SEARCHABLE, SQL_SENSITIVE, SQL_SET_DEFAULT, SQL_SET_NULL, SQL_SO_FORWARD_ONLY,