wip: execute_arc

Author: pacman82

odbc-api/src/connection.rs

@@ -15,6 +15,7 @@ use std::{
     fmt::{self, Debug, Display},
     mem::ManuallyDrop,
     str,
+    sync::Arc,
     thread::panicking,
 };
 
@@ -298,6 +299,25 @@ impl<'c> Connection<'c> {
         Ok(Some(cursor))
     }
 
+    /// Like [`Connection::execute`], but takes ownership of an `Arc<Self>`.
+    pub fn execute_arc(
+        self: Arc<Self>,
+        query: &str,
+        params: impl ParameterCollectionRef,
+        query_timeout_sec: Option<usize>,
+    ) -> Result<Option<CursorImpl<StatementConnection<Arc<Connection<'c>>>>>, Error>  {
+        let query = SqlText::new(query);
+        let lazy_statement = move || {
+            let mut stmt = self.allocate_statement()?;
+            if let Some(query_timeout_sec) = query_timeout_sec {
+                stmt.set_query_timeout_sec(query_timeout_sec)
+                    .into_result(&stmt)?;
+            }
+            Ok(stmt)
+        };
+        execute_with_parameters(lazy_statement, Some(&query), params)
+    }
+
     /// Prepares an SQL statement. This is recommended for repeated execution of similar queries.
     ///
     /// Should your use case require you to execute the same query several times with different

odbc-api/src/statement_connection.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use odbc_sys::{HStmt, Handle, HandleType};
 
 use crate::{
@@ -12,8 +14,20 @@ pub struct StatementConnection<C> {
     _parent: C,
 }
 
-impl<'env> StatementConnection<Connection<'env>> {
-    pub(crate) unsafe fn new(handle: HStmt, parent: Connection<'env>) -> Self {
+impl<C> Drop for StatementConnection<C> {
+    fn drop(&mut self) {
+        unsafe {
+            drop_handle(self.handle as Handle, HandleType::Stmt);
+        }
+    }
+}
+
+impl<C> StatementConnection<C> {
+    /// # Safety
+    /// 
+    /// Handle must be a valid statement handle and the parent connection must be valid for the
+    /// lifetime of parent.
+    pub(crate) unsafe fn new(handle: HStmt, parent: C) -> Self {
         Self {
             _parent: parent,
             handle,
@@ -25,14 +39,6 @@ impl<'env> StatementConnection<Connection<'env>> {
     }
 }
 
-impl<C> Drop for StatementConnection<C> {
-    fn drop(&mut self) {
-        unsafe {
-            drop_handle(self.handle as Handle, HandleType::Stmt);
-        }
-    }
-}
-
 /// According to the ODBC documentation this is safe. See:
 /// <https://docs.microsoft.com/en-us/sql/odbc/reference/develop-app/multithreading>
 ///
@@ -77,3 +83,10 @@ impl AsStatementRef for StatementConnection<Connection<'_>> {
         self.as_stmt_ref()
     }
 }
+
+impl AsStatementRef for StatementConnection<Arc<Connection<'_>>> {
+    fn as_stmt_ref(&mut self) -> StatementRef<'_> {
+        todo!();
+        self.as_stmt_ref()
+    }
+}

odbc-api/tests/integration.rs

@@ -36,13 +36,7 @@ use odbc_api::{
 use widestring::Utf16String;
 
 use std::{
-    ffi::CString,
-    io::{self, Write},
-    iter,
-    num::NonZeroUsize,
-    ptr::null_mut,
-    str, thread,
-    time::{Duration, Instant},
+    ffi::CString, io::{self, Write}, iter, num::NonZeroUsize, ptr::null_mut, str, sync::Arc, thread, time::{Duration, Instant}
 };
 
 const MSSQL: &Profile = &Profile {
@@ -571,6 +565,33 @@ fn into_cursor(profile: &Profile) {
     assert_eq!(expected, actual);
 }
 
+/// We want to be able to create multiple statements with the utilizing the same connection, yet we
+/// in some cases it might be hard to keep track of the ownership of the connection separately. So
+/// essentially we want our statements to be owning an `Arc` to connection.
+#[test_case(MSSQL; "Microsoft SQL Server")]
+#[test_case(MARIADB; "Maria DB")]
+#[test_case(SQLITE_3; "SQLite 3")]
+#[test_case(POSTGRES; "PostgreSQL")]
+fn shared_ownership_of_connections_by_statement(profile: &Profile) {
+    // Given
+    let table_name = table_name!();
+    let (conn, table) = Given::new(&table_name)
+        .column_types(&["INT"])
+        .values_by_column(&[
+            &[
+                Some("42")
+            ],
+        ])
+        .build(profile)
+        .unwrap();
+
+    // When
+    let conn = Arc::new(conn);
+    let cursor_1 = conn.clone().execute_arc(&table.sql_all_ordered_by_id(), (), None).unwrap().unwrap();
+    let cursor_2 = conn.execute_arc(&table.sql_all_ordered_by_id(), (), None).unwrap().unwrap();
+    // drop(conn); // This line would not compile without the `Arc` around the connection type
+}
+
 /// Strong exception safety for `into_cursor`. Our first query will fail, because it will query a
 /// non-existing table, but our second one using the same connection will succeed. This is one
 /// scenario in which it is useful not to "swallow" the connection in case of an error.
@@ -1483,20 +1504,20 @@ fn var_char_slice_mut_as_input_output_parameter(profile: &Profile) {
     let conn = profile.connection().unwrap();
     conn.execute(
         r#"
-        IF EXISTS (SELECT name FROM sysobjects WHERE name = 'TestInOutText')  
-        DROP PROCEDURE TestInOutText  
+        IF EXISTS (SELECT name FROM sysobjects WHERE name = 'TestInOutText')
+        DROP PROCEDURE TestInOutText
         "#,
         (),
         None,
     )
     .unwrap();
 
     conn.execute(
-        r#"CREATE PROCEDURE TestInOutText   
-        @OutParm VARCHAR(15) OUTPUT   
+        r#"CREATE PROCEDURE TestInOutText
+        @OutParm VARCHAR(15) OUTPUT
         AS
-        SELECT @OutParm = 'Hello, World!'  
-        RETURN 99  
+        SELECT @OutParm = 'Hello, World!'
+        RETURN 99
         "#,
         (),
         None,
@@ -2822,20 +2843,20 @@ fn output_parameter(profile: &Profile) {
     let conn = profile.connection().unwrap();
     conn.execute(
         r#"
-        IF EXISTS (SELECT name FROM sysobjects WHERE name = 'TestOutputParam')  
-        DROP PROCEDURE TestOutputParam  
+        IF EXISTS (SELECT name FROM sysobjects WHERE name = 'TestOutputParam')
+        DROP PROCEDURE TestOutputParam
         "#,
         (),
         None,
     )
     .unwrap();
 
     conn.execute(
-        r#"CREATE PROCEDURE TestOutputParam   
-        @OutParm int OUTPUT   
+        r#"CREATE PROCEDURE TestOutputParam
+        @OutParm int OUTPUT
         AS
-        SELECT @OutParm = @OutParm + 5  
-        RETURN 99  
+        SELECT @OutParm = @OutParm + 5
+        RETURN 99
         "#,
         (),
         None,