copy changes (mongodb#283)

Author: jchemburkar

definitions/src/lib.rs

@@ -412,3 +412,11 @@ pub enum RowStatus {
     SQL_ROW_ERROR = 5,
     SQL_ROW_SUCCESS_WITH_INFO = 6,
 }
+
+#[derive(Clone, Copy, Debug, Default, FromPrimitive, PartialEq)]
+#[repr(u32)]
+pub enum AccessMode {
+    ReadWrite = 0,
+    #[default]
+    ReadOnly,
+}

odbc/src/api/connect_attr_tests.rs

@@ -7,18 +7,21 @@
 mod unit {
     use crate::{
         errors::ODBCError,
-        handles::definitions::{Connection, ConnectionAttributes, ConnectionState, MongoHandle},
+        handles::definitions::{
+            Connection, ConnectionAttributes, ConnectionState, Env, EnvState, MongoHandle,
+        },
         util::connection_attribute_to_string,
-        SQLGetConnectAttrW, SQLSetConnectAttrW,
+        SQLGetConnectAttrW, SQLGetDiagFieldW, SQLSetConnectAttrW,
     };
-    use cstr::input_text_to_string_w;
-    use definitions::{ConnectionAttribute, Integer, Pointer, SqlReturn, UInteger};
+    use cstr::{input_text_to_string_w, WideChar};
+    use definitions::{
+        AccessMode, ConnectionAttribute, HandleType, Integer, Pointer, SqlReturn, UInteger, WChar,
+    };
+    use std::ffi::c_void;
+    use std::mem::size_of;
     use std::sync::RwLock;
 
     mod get {
-        use std::mem::size_of;
-
-        use cstr::WideChar;
 
         use super::*;
 
@@ -205,9 +208,74 @@ mod unit {
         }
     }
 
-    const UNSUPPORTED_ATTRS: [ConnectionAttribute; 18] = [
+    // Test setting the access mode attribute
+    #[test]
+    fn get_set_access_mode() {
+        unsafe {
+            let env = &mut MongoHandle::Env(Env::with_state(EnvState::Allocated));
+            let conn = Connection::with_state(env, ConnectionState::Connected);
+            let mongo_handle: *mut _ = &mut MongoHandle::Connection(conn);
+            let value_ptr: *mut std::ffi::c_void = Box::into_raw(Box::new([0u8; 40])) as *mut _;
+
+            // check the existing default value is read only
+            assert_eq!(
+                SqlReturn::SUCCESS,
+                SQLGetConnectAttrW(
+                    mongo_handle as *mut _,
+                    ConnectionAttribute::SQL_ATTR_ACCESS_MODE as i32,
+                    value_ptr,
+                    0,
+                    &mut 0,
+                )
+            );
+            assert_eq!(AccessMode::ReadOnly as u32, *(value_ptr as *mut UInteger));
+
+            // check that setting to ReadWrite provides sucesss with info and the value remains read only
+            assert_eq!(
+                SqlReturn::SUCCESS_WITH_INFO,
+                SQLSetConnectAttrW(
+                    mongo_handle as *mut _,
+                    ConnectionAttribute::SQL_ATTR_ACCESS_MODE as i32,
+                    (AccessMode::ReadWrite as u32) as Pointer,
+                    0,
+                )
+            );
+
+            let message_text = &mut [0; 89 * size_of::<WideChar>()] as *mut _ as *mut c_void;
+            assert_eq!(
+                SqlReturn::SUCCESS,
+                SQLGetDiagFieldW(
+                    HandleType::SQL_HANDLE_DBC,
+                    mongo_handle as *mut _,
+                    1,
+                    6, //DiagType::SQL_DIAG_MESSAGE_TEXT
+                    message_text,
+                    89 * size_of::<WideChar>() as i16,
+                    &mut 0
+                )
+            );
+            assert_eq!(
+             "[MongoDB][API] Invalid value for attribute SQL_MODE_READ_WRITE, changed to SQL_MODE_READ\0",
+                cstr::from_widechar_ref_lossy(&*(message_text as *const [WideChar; 89]))
+            );
+
+            assert_eq!(
+                SqlReturn::SUCCESS,
+                SQLGetConnectAttrW(
+                    mongo_handle as *mut _,
+                    ConnectionAttribute::SQL_ATTR_ACCESS_MODE as i32,
+                    value_ptr,
+                    0,
+                    &mut 0,
+                )
+            );
+            assert_eq!(AccessMode::ReadOnly as u32, *(value_ptr as *mut UInteger));
+            let _ = Box::from_raw(value_ptr as *mut WChar);
+        }
+    }
+
+    const UNSUPPORTED_ATTRS: [ConnectionAttribute; 17] = [
         ConnectionAttribute::SQL_ATTR_ASYNC_ENABLE,
-        ConnectionAttribute::SQL_ATTR_ACCESS_MODE,
         ConnectionAttribute::SQL_ATTR_AUTOCOMMIT,
         ConnectionAttribute::SQL_ATTR_TRACE,
         ConnectionAttribute::SQL_ATTR_TRACEFILE,

odbc/src/api/functions.rs

@@ -15,12 +15,12 @@ use mongodb::bson::{doc, Bson};
 use cstr::{input_text_to_string_w, input_text_to_string_w_allow_null, Charset, WideChar};
 
 use definitions::{
-    AllocType, AsyncEnable, AttrConnectionPooling, AttrCpMatch, AttrOdbcVersion, BindType,
-    CDataType, Concurrency, ConnectionAttribute, CursorScrollable, CursorSensitivity, CursorType,
-    Desc, DiagType, DriverConnectOption, EnvironmentAttribute, FetchOrientation, FreeStmtOption,
-    HDbc, HDesc, HEnv, HStmt, HWnd, Handle, HandleType, Integer, Len, NoScan, Pointer, RetCode,
-    RetrieveData, RowStatus, SmallInt, SqlBool, SqlDataType, SqlReturn, StatementAttribute, ULen,
-    USmallInt, UseBookmarks, SQL_NTS,
+    AccessMode, AllocType, AsyncEnable, AttrConnectionPooling, AttrCpMatch, AttrOdbcVersion,
+    BindType, CDataType, Concurrency, ConnectionAttribute, CursorScrollable, CursorSensitivity,
+    CursorType, Desc, DiagType, DriverConnectOption, EnvironmentAttribute, FetchOrientation,
+    FreeStmtOption, HDbc, HDesc, HEnv, HStmt, HWnd, Handle, HandleType, Integer, Len, NoScan,
+    Pointer, RetCode, RetrieveData, RowStatus, SmallInt, SqlBool, SqlDataType, SqlReturn,
+    StatementAttribute, ULen, USmallInt, UseBookmarks, SQL_NTS,
 };
 use function_name::named;
 use log::{debug, error, info};
@@ -1184,22 +1184,10 @@ pub unsafe extern "C" fn SQLDriverConnectW(
                 function_name!()
             );
 
-            // SQL_NO_PROMPT is the only option supported for DriverCompletion
-            match FromPrimitive::from_u16(driver_completion) {
-                Some(driver_completion) => match driver_completion {
-                    DriverConnectOption::SQL_DRIVER_COMPLETE
-                    | DriverConnectOption::SQL_DRIVER_COMPLETE_REQUIRED
-                    | DriverConnectOption::SQL_DRIVER_PROMPT => {
-                        add_diag_info!(
-                            conn_handle,
-                            ODBCError::UnsupportedDriverConnectOption(format!(
-                                "{driver_completion:?}"
-                            ))
-                        );
-                        return SqlReturn::ERROR;
-                    }
-                    DriverConnectOption::SQL_DRIVER_NO_PROMPT => {}
-                },
+            // We will treat any valid option passed for DriverComplete as a no-op
+            // because we don't have any UI involved in the process and don't plan to add any in the future
+            match <DriverConnectOption as FromPrimitive>::from_u16(driver_completion) {
+                Some(_) => {}
                 None => {
                     add_diag_info!(
                         conn_handle,
@@ -1916,6 +1904,9 @@ unsafe fn sql_get_connect_attrw_helper(
                 let connection_timeout = attributes.connection_timeout.unwrap_or(0);
                 i32_len::set_output_fixed_data(&connection_timeout, value_ptr, string_length_ptr)
             }
+            ConnectionAttribute::SQL_ATTR_ACCESS_MODE => {
+                i32_len::set_output_fixed_data(&AccessMode::ReadOnly, value_ptr, string_length_ptr)
+            }
             _ => {
                 err = Some(ODBCError::UnsupportedConnectionAttribute(
                     connection_attribute_to_string(attribute),
@@ -3579,6 +3570,23 @@ unsafe fn set_connect_attrw_helper(
                     SqlReturn::SUCCESS_WITH_INFO
                 }
             },
+            ConnectionAttribute::SQL_ATTR_ACCESS_MODE => {
+                match FromPrimitive::from_u32(value_ptr as u32) {
+                    Some(AccessMode::ReadOnly) => SqlReturn::SUCCESS,
+                    Some(AccessMode::ReadWrite) => {
+                        conn_handle.add_diag_info(ODBCError::OptionValueChanged(
+                            "SQL_MODE_READ_WRITE",
+                            "SQL_MODE_READ",
+                        ));
+                        SqlReturn::SUCCESS_WITH_INFO
+                    }
+                    None => {
+                        conn_handle
+                            .add_diag_info(ODBCError::InvalidAttrValue("SQL_ATTR_ACCESS_MODE"));
+                        SqlReturn::ERROR
+                    }
+                }
+            }
             _ => {
                 err = Some(ODBCError::UnsupportedConnectionAttribute(
                     connection_attribute_to_string(attribute),

odbc/tests/connection_tests.rs

@@ -92,7 +92,7 @@ macro_rules! test_connection_diagnostics {
 mod integration {
     use crate::common::verify_sql_diagnostics;
     use atsql::{SQLAllocHandle, SQLDisconnect, SQLDriverConnectW, SQLFreeHandle};
-    use constants::{NOT_IMPLEMENTED, NO_DSN_OR_DRIVER, UNABLE_TO_CONNECT};
+    use constants::{NO_DSN_OR_DRIVER, UNABLE_TO_CONNECT};
     use definitions::{DriverConnectOption, Handle, HandleType, SqlReturn};
     use std::ptr::null_mut;
 
@@ -122,30 +122,30 @@ mod integration {
             "[MongoDB][API] Missing property \"Driver\" or \"DSN\" in connection string"
     );
     test_connection_diagnostics!(
-        unsupported_driver_connect_option_prompt,
+        missing_driver_driver_connect_option_prompt,
         in_connection_string = "USER=N_A;SERVER=N_A;PWD=N_A",
         driver_completion = DriverConnectOption::SQL_DRIVER_PROMPT,
-        expected_sql_state = NOT_IMPLEMENTED,
+        expected_sql_state = NO_DSN_OR_DRIVER,
         expected_sql_return = SqlReturn::ERROR,
         expected_error_message =
-            "[MongoDB][API] The driver connect option SQL_DRIVER_PROMPT is not supported"
+            "[MongoDB][API] Missing property \"Driver\" or \"DSN\" in connection string"
     );
     test_connection_diagnostics!(
-        unsupported_driver_connect_option_complete,
+        missing_driver_driver_connect_option_complete,
         in_connection_string = "USER=N_A;SERVER=N_A;PWD=N_A",
         driver_completion = DriverConnectOption::SQL_DRIVER_COMPLETE,
-        expected_sql_state = NOT_IMPLEMENTED,
+        expected_sql_state = NO_DSN_OR_DRIVER,
         expected_sql_return = SqlReturn::ERROR,
         expected_error_message =
-            "[MongoDB][API] The driver connect option SQL_DRIVER_COMPLETE is not supported"
+            "[MongoDB][API] Missing property \"Driver\" or \"DSN\" in connection string"
     );
     test_connection_diagnostics!(
-        unsupported_driver_connect_option_complete_required,
+        missing_driver_driver_connect_option_complete_required,
         in_connection_string = "USER=N_A;SERVER=N_A;PWD=N_A",
         driver_completion = DriverConnectOption::SQL_DRIVER_COMPLETE_REQUIRED,
-        expected_sql_state = NOT_IMPLEMENTED,
+        expected_sql_state = NO_DSN_OR_DRIVER,
         expected_sql_return = SqlReturn::ERROR,
         expected_error_message =
-            "[MongoDB][API] The driver connect option SQL_DRIVER_COMPLETE_REQUIRED is not supported"
+            "[MongoDB][API] Missing property \"Driver\" or \"DSN\" in connection string"
     );
 }