Connection Session & Database Attributes

sfc-gh-daniszewski · sfc-gh-daniszewski · commit 90c9a05abfc1 · 2026-03-20T11:00:04.000Z
diff --git a/odbc/src/api/connection.rs b/odbc/src/api/connection.rs
diff --git a/odbc/src/api/error.rs b/odbc/src/api/error.rs
@@ -323,7 +323,7 @@ pub enum OdbcError {
 
     #[snafu(display("Received core protobuf error"))]
     CoreError {
-        source: CoreProtobufError,
+        source: Box<CoreProtobufError>,
         #[snafu(implicit)]
         location: Location,
     },
@@ -469,46 +469,56 @@ impl OdbcError {
             OdbcError::TextConversionFromUtf8 { .. } => SqlState::StringDataRightTruncated,
             OdbcError::TextConversionFromUtf16 { .. } => SqlState::StringDataRightTruncated,
             OdbcError::JsonBinding { .. } => SqlState::GeneralError,
-            OdbcError::CoreError {
-                source: CoreProtobufError::Application { error, message, .. },
-                ..
-            } => match error.as_ref() {
-                ErrorType::AuthError(_) => SqlState::InvalidAuthorizationSpecification,
-                ErrorType::GenericError(_) => {
-                    if message.contains("SQL compilation error") {
-                        SqlState::SyntaxErrorOrAccessRuleViolation
-                    } else {
-                        SqlState::GeneralError
-                    }
-                }
-                ErrorType::InvalidParameterValue(ProtoInvalidParameterValue {
-                    parameter, ..
-                }) => {
-                    if AUTHENTICATOR_PARAMETERS.contains(&parameter.to_uppercase()) {
-                        SqlState::InvalidAuthorizationSpecification
-                    } else {
-                        SqlState::InvalidConnectionStringAttribute
-                    }
-                }
-                ErrorType::MissingParameter(ProtoMissingParameter { parameter }) => {
-                    if AUTHENTICATOR_PARAMETERS.contains(&parameter.to_uppercase()) {
-                        SqlState::InvalidAuthorizationSpecification
-                    } else {
-                        SqlState::InvalidConnectionStringAttribute
+            OdbcError::CoreError { source, .. } => match source.as_ref() {
+                CoreProtobufError::Transport { .. } => SqlState::ClientUnableToEstablishConnection,
+                CoreProtobufError::Application {
+                    error,
+                    message,
+                    sql_state,
+                    ..
+                } => {
+                    // Prefer the ANSI SQL state forwarded from the server when present.
+                    if let Some(state) = sql_state
+                        && let Ok(parsed) = state.parse::<SqlState>()
+                    {
+                        return parsed;
                     }
-                }
-                ErrorType::InternalError(_) => {
-                    if message.contains("SQL compilation error") {
-                        SqlState::SyntaxErrorOrAccessRuleViolation
-                    } else {
-                        SqlState::GeneralError
+                    match error.as_ref() {
+                        ErrorType::AuthError(_) => SqlState::InvalidAuthorizationSpecification,
+                        ErrorType::GenericError(_) => {
+                            if message.contains("SQL compilation error") {
+                                SqlState::SyntaxErrorOrAccessRuleViolation
+                            } else {
+                                SqlState::GeneralError
+                            }
+                        }
+                        ErrorType::InvalidParameterValue(ProtoInvalidParameterValue {
+                            parameter,
+                            ..
+                        }) => {
+                            if AUTHENTICATOR_PARAMETERS.contains(&parameter.to_uppercase()) {
+                                SqlState::InvalidAuthorizationSpecification
+                            } else {
+                                SqlState::InvalidConnectionStringAttribute
+                            }
+                        }
+                        ErrorType::MissingParameter(ProtoMissingParameter { parameter }) => {
+                            if AUTHENTICATOR_PARAMETERS.contains(&parameter.to_uppercase()) {
+                                SqlState::InvalidAuthorizationSpecification
+                            } else {
+                                SqlState::InvalidConnectionStringAttribute
+                            }
+                        }
+                        ErrorType::InternalError(_) => {
+                            if message.contains("SQL compilation error") {
+                                SqlState::SyntaxErrorOrAccessRuleViolation
+                            } else {
+                                SqlState::GeneralError
+                            }
+                        }
+                        ErrorType::LoginError(_) => SqlState::InvalidAuthorizationSpecification,
                     }
                 }
-                ErrorType::LoginError(_) => SqlState::InvalidAuthorizationSpecification,
-            },
-            OdbcError::CoreError { source, .. } => match source {
-                CoreProtobufError::Transport { .. } => SqlState::ClientUnableToEstablishConnection,
-                CoreProtobufError::Application { .. } => SqlState::GeneralError,
             },
             OdbcError::ProtoRequiredFieldMissing { .. } => SqlState::GeneralError,
             OdbcError::ArrowArrayStreamReaderCreation { .. } => SqlState::GeneralError,
@@ -520,7 +530,7 @@ impl OdbcError {
 
     pub fn to_native_error(&self) -> sql::Integer {
         match self {
-            OdbcError::CoreError { source, .. } => match source {
+            OdbcError::CoreError { source, .. } => match source.as_ref() {
                 CoreProtobufError::Application { error, .. } => match error.as_ref() {
                     ErrorType::LoginError(login_error) => login_error.code,
                     _ => 0,
@@ -546,12 +556,13 @@ impl OdbcError {
                 message: driver_exception.message,
                 status_code: driver_exception.status_code,
                 error_trace: driver_exception.error_trace,
+                sql_state: driver_exception.sql_state,
                 location,
             },
             ProtoError::Transport(message) => CoreProtobufError::Transport { message, location },
         };
         OdbcError::CoreError {
-            source: core_error,
+            source: Box::new(core_error),
             location,
         }
     }
@@ -572,6 +583,8 @@ pub enum CoreProtobufError {
         message: String,
         status_code: i32,
         error_trace: Vec<ErrorTraceEntry>,
+        /// ANSI SQL state forwarded from the server response, if present.
+        sql_state: Option<String>,
         location: Location,
     },
     #[snafu(display("Transport error: {message}"))]
diff --git a/odbc/src/api/handle_allocation.rs b/odbc/src/api/handle_allocation.rs
@@ -35,6 +35,9 @@ pub fn alloc_connection() -> OdbcResult<*mut Connection> {
         diagnostic_info: DiagnosticInfo::default(),
         pre_connection_attrs: Default::default(),
         numeric_settings: Default::default(),
+        access_mode: 0,                   // SQL_MODE_READ_WRITE
+        quiet_mode: std::ptr::null_mut(), // no window handle
+        packet_size: 0,                   // driver-defined
     });
     Ok(Box::into_raw(dbc))
 }
diff --git a/odbc/src/api/sql_state.rs b/odbc/src/api/sql_state.rs
@@ -165,6 +165,10 @@ pub enum SqlState {
     /// 2H000 - Invalid collation name
     InvalidCollationName,
 
+    // Invalid catalog name class (3D)
+    /// 3D000 - Invalid catalog name
+    InvalidCatalogName,
+
     // Syntax error or access rule violation class (42)
     /// 42000 - Syntax error or access rule violation
     SyntaxErrorOrAccessRuleViolation,
@@ -368,6 +372,7 @@ impl SqlState {
             SqlState::ReadingSqlDataNotPermitted => "2F004",
             SqlState::FunctionExecutedNoReturnStatement => "2F005",
             SqlState::InvalidCollationName => "2H000",
+            SqlState::InvalidCatalogName => "3D000",
             SqlState::SyntaxErrorOrAccessRuleViolation => "42000",
             SqlState::BaseTableOrViewAlreadyExists => "42S01",
             SqlState::BaseTableOrViewNotFound => "42S02",
@@ -542,6 +547,7 @@ impl FromStr for SqlState {
             "2F004" => SqlState::ReadingSqlDataNotPermitted,
             "2F005" => SqlState::FunctionExecutedNoReturnStatement,
             "2H000" => SqlState::InvalidCollationName,
+            "3D000" => SqlState::InvalidCatalogName,
             "42000" => SqlState::SyntaxErrorOrAccessRuleViolation,
             "42S01" => SqlState::BaseTableOrViewAlreadyExists,
             "42S02" => SqlState::BaseTableOrViewNotFound,
diff --git a/odbc/src/api/types/odbc_types.rs b/odbc/src/api/types/odbc_types.rs
@@ -23,14 +23,26 @@ const SQL_SF_CONN_ATTR_BASE: i32 = 0x4000 + 0x53;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ConnectionAttribute {
     // Standard ODBC attributes (from sql.h / sqlext.h)
+    /// SQL_ATTR_ACCESS_MODE (101)
+    AccessMode,
     /// SQL_ATTR_AUTOCOMMIT (102)
     Autocommit,
     /// SQL_ATTR_LOGIN_TIMEOUT (103)
     LoginTimeout,
+    /// SQL_ATTR_TXN_ISOLATION (108)
+    TxnIsolation,
     /// SQL_ATTR_CURRENT_CATALOG (109)
     CurrentCatalog,
+    /// SQL_ATTR_QUIET_MODE (111)
+    QuietMode,
+    /// SQL_ATTR_PACKET_SIZE (112)
+    PacketSize,
     /// SQL_ATTR_CONNECTION_TIMEOUT (113)
     ConnectionTimeout,
+    /// SQL_ATTR_CONNECTION_DEAD (1209) — read-only
+    ConnectionDead,
+    /// SQL_ATTR_AUTO_IPD (10001) — read-only
+    AutoIpd,
 
     // Custom Snowflake attributes (matching sf_odbc.h)
     /// SQL_SF_CONN_ATTR_PRIV_KEY — EVP_PKEY pointer (not supported in new driver)
@@ -50,10 +62,16 @@ impl ConnectionAttribute {
     /// Returns `None` for unrecognized attributes.
     pub fn from_raw(value: i32) -> Option<Self> {
         match value {
+            101 => Some(Self::AccessMode),
             102 => Some(Self::Autocommit),
             103 => Some(Self::LoginTimeout),
+            108 => Some(Self::TxnIsolation),
             109 => Some(Self::CurrentCatalog),
+            111 => Some(Self::QuietMode),
+            112 => Some(Self::PacketSize),
             113 => Some(Self::ConnectionTimeout),
+            1209 => Some(Self::ConnectionDead),
+            10001 => Some(Self::AutoIpd),
             x if x == SQL_SF_CONN_ATTR_BASE + 1 => Some(Self::PrivKey),
             x if x == SQL_SF_CONN_ATTR_BASE + 2 => Some(Self::Application),
             x if x == SQL_SF_CONN_ATTR_BASE + 3 => Some(Self::PrivKeyContent),
@@ -71,10 +89,16 @@ impl ConnectionAttribute {
     /// Convert back to the raw ODBC attribute ID.
     pub fn as_raw(&self) -> i32 {
         match self {
+            Self::AccessMode => 101,
             Self::Autocommit => 102,
             Self::LoginTimeout => 103,
+            Self::TxnIsolation => 108,
             Self::CurrentCatalog => 109,
+            Self::QuietMode => 111,
+            Self::PacketSize => 112,
             Self::ConnectionTimeout => 113,
+            Self::ConnectionDead => 1209,
+            Self::AutoIpd => 10001,
             Self::PrivKey => SQL_SF_CONN_ATTR_BASE + 1,
             Self::Application => SQL_SF_CONN_ATTR_BASE + 2,
             Self::PrivKeyContent => SQL_SF_CONN_ATTR_BASE + 3,
@@ -712,6 +736,12 @@ pub struct Connection {
     /// Attributes set via SQLSetConnectAttr before the connection is established
     pub pre_connection_attrs: PreConnectionAttributes,
     pub numeric_settings: NumericSettings,
+    /// SQL_ATTR_ACCESS_MODE — advisory only (default SQL_MODE_READ_WRITE = 0)
+    pub access_mode: sql::UInteger,
+    /// SQL_ATTR_QUIET_MODE — window handle pointer (default null)
+    pub quiet_mode: sql::Pointer,
+    /// SQL_ATTR_PACKET_SIZE — pre-connect only (default 0 = driver-defined)
+    pub packet_size: sql::UInteger,
 }
 
 #[derive(Debug, Clone)]
diff --git a/odbc/src/c_api.rs b/odbc/src/c_api.rs
@@ -246,14 +246,21 @@ pub unsafe extern "C" fn SQLSetConnectAttr(
     string_length: sql::Integer,
 ) -> sql::RetCode {
     api::diagnostic::clear_diag_info(sql::HandleType::Dbc, connection_handle);
+    let mut warnings = vec![];
     let result = api::connection::set_connect_attr::<Narrow>(
         connection_handle,
         attribute,
         value,
         string_length,
+        &mut warnings,
+    );
+    api::diagnostic::set_diag_info_from_warnings(
+        sql::HandleType::Dbc,
+        connection_handle,
+        &warnings,
     );
     api::diagnostic::set_diag_info_from_result(sql::HandleType::Dbc, connection_handle, &result);
-    result.to_sql_code()
+    result.to_sql_code_with_warnings(&warnings)
 }
 
 /// # Safety
@@ -266,14 +273,21 @@ pub unsafe extern "C" fn SQLSetConnectAttrW(
     string_length: sql::Integer,
 ) -> sql::RetCode {
     api::diagnostic::clear_diag_info(sql::HandleType::Dbc, connection_handle);
+    let mut warnings = vec![];
     let result = api::connection::set_connect_attr::<Wide>(
         connection_handle,
         attribute,
         value,
         string_length,
+        &mut warnings,
+    );
+    api::diagnostic::set_diag_info_from_warnings(
+        sql::HandleType::Dbc,
+        connection_handle,
+        &warnings,
     );
     api::diagnostic::set_diag_info_from_result(sql::HandleType::Dbc, connection_handle, &result);
-    result.to_sql_code()
+    result.to_sql_code_with_warnings(&warnings)
 }
 
 /// # Safety
diff --git a/odbc_tests/tests/odbc-api/connecting/CMakeLists.txt b/odbc_tests/tests/odbc-api/connecting/CMakeLists.txt
@@ -4,3 +4,4 @@ add_odbc_test(odbc_api_alloc_handle_tests alloc_handle_tests.cpp)
 add_odbc_test(odbc_api_connect_tests connect_tests.cpp)
 add_odbc_test(odbc_api_driver_connect_tests driver_connect_tests.cpp)
 add_odbc_test(odbc_api_browse_connect_tests browse_connect_tests.cpp)
+add_odbc_test(odbc_api_conn_attr_tests conn_attr_tests.cpp)
diff --git a/odbc_tests/tests/odbc-api/connecting/conn_attr_tests.cpp b/odbc_tests/tests/odbc-api/connecting/conn_attr_tests.cpp
