libsql 0.1.3rc1__tar.gz → 0.1.5__tar.gz

{libsql-0.1.3rc1 → libsql-0.1.5}/Cargo.lock

@@ -815,8 +815,9 @@ dependencies = [
 
 [[package]]
 name = "libsql"
-version = "0.9.15"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acd99c54790a50cffb62b1bf3e82c747fafad296c2fd21acce3154e4d9112241"
 dependencies = [
  "anyhow",
  "async-stream",
@@ -854,8 +855,9 @@ dependencies = [
 
 [[package]]
 name = "libsql-ffi"
-version = "0.9.15"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f72c71234e1ad056592c977f5353b9ee87a2f9923cc7ac80bce52b7e30dbe702"
 dependencies = [
  "bindgen",
  "cc",
@@ -865,8 +867,9 @@ dependencies = [
 
 [[package]]
 name = "libsql-hrana"
-version = "0.9.15"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ce12bd586bde040a4bd33b291df6bf26dc56379629e1cb5d50e08a1bd31d56"
 dependencies = [
  "base64 0.21.7",
  "bytes",
@@ -876,8 +879,9 @@ dependencies = [
 
 [[package]]
 name = "libsql-rusqlite"
-version = "0.9.15"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc5d27776273a28e4eb1a63e9abb924f7e0d8a3f26b5b713724826f3e0c8bf6f"
 dependencies = [
  "bitflags 2.6.0",
  "fallible-iterator 0.2.0",
@@ -890,7 +894,8 @@ dependencies = [
 [[package]]
 name = "libsql-sqlite3-parser"
 version = "0.13.0"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15a90128c708356af8f7d767c9ac2946692c9112b4f74f07b99a01a60680e413"
 dependencies = [
  "bitflags 2.6.0",
  "cc",
@@ -906,8 +911,9 @@ dependencies = [
 
 [[package]]
 name = "libsql-sys"
-version = "0.9.15"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11f4b1c9314de9c3f4d768e3b03d5e2d0b95747423dcb55c69494c49a3630728"
 dependencies = [
  "bytes",
  "libsql-ffi",
@@ -919,8 +925,9 @@ dependencies = [
 
 [[package]]
 name = "libsql_replication"
-version = "0.9.15"
-source = "git+https://github.com/tursodatabase/libsql/?rev=57043b60f3db38236187a8905bee62b35bf18afb#57043b60f3db38236187a8905bee62b35bf18afb"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc5717bf0fd5ef39a40094bb606332e03a37d19b65d96399506453a8ee132167"
 dependencies = [
  "aes",
  "async-stream",
@@ -1230,7 +1237,7 @@ dependencies = [
 
 [[package]]
 name = "pylibsql"
-version = "0.1.3-pre.1"
+version = "0.1.5"
 dependencies = [
  "libsql",
  "pyo3",

{libsql-0.1.3rc1 → libsql-0.1.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pylibsql"
-version = "0.1.3-pre.1"
+version = "0.1.5"
 edition = "2021"
 
 [lib]
@@ -8,7 +8,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 pyo3 = "0.19.0"
-libsql = { git = "https://github.com/tursodatabase/libsql/", rev = "57043b60f3db38236187a8905bee62b35bf18afb", features = ["encryption"]  }
+libsql = { version = "0.9.18", features = ["encryption"]  }
 tokio = { version = "1.29.1", features = [ "rt-multi-thread" ] }
 tracing-subscriber = "0.3"
 

{libsql-0.1.3rc1 → libsql-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libsql
-Version: 0.1.3rc1
+Version: 0.1.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{libsql-0.1.3rc1 → libsql-0.1.5}/docs/api.md

@@ -32,6 +32,16 @@ Rolls back the current transaction and starts a new one.
 
 Closes the database connection.
 
+### `with` statement
+
+Connection objects can be used as context managers to ensure that transactions are properly committed or rolled back. When entering the context, the connection object is returned. When exiting:
+- Without exception: automatically commits the transaction
+- With exception: automatically rolls back the transaction
+
+This behavior is compatible with Python's `sqlite3` module. Context managers work correctly in both transactional and autocommit modes.
+
+When mixing manual transaction control with context managers, the context manager's commit/rollback will apply to any active transaction at the time of exit. Manual calls to `commit()` or `rollback()` within the context are allowed and will start a new transaction as usual.
+
 ### execute(sql, parameters=())
 
 Create a new cursor object and executes the SQL statement.

{libsql-0.1.3rc1 → libsql-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "libsql"
-version = "0.1.3-pre.1"
+version = "0.1.5"
 requires-python = ">=3.7"
 classifiers = [
     "Programming Language :: Rust",

{libsql-0.1.3rc1 → libsql-0.1.5}/src/lib.rs

@@ -3,13 +3,23 @@ use pyo3::create_exception;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyList, PyTuple};
-use std::cell::{OnceCell, RefCell};
+use std::cell::RefCell;
 use std::sync::{Arc, OnceLock};
 use std::time::Duration;
 use tokio::runtime::{Handle, Runtime};
 
 const LEGACY_TRANSACTION_CONTROL: i32 = -1;
 
+enum ListOrTuple<'py> {
+    List(&'py PyList),
+    Tuple(&'py PyTuple),
+}
+
+struct ListOrTupleIterator<'py> {
+    index: usize,
+    inner: &'py ListOrTuple<'py>
+}
+
 fn rt() -> Handle {
     static RT: OnceLock<Runtime> = OnceLock::new();
 
@@ -38,14 +48,14 @@ fn is_remote_path(path: &str) -> bool {
 
 #[pyfunction]
 #[cfg(not(Py_3_12))]
-#[pyo3(signature = (database, timeout=5.0, isolation_level="DEFERRED".to_string(), check_same_thread=true, uri=false, sync_url=None, sync_interval=None, auth_token="", encryption_key=None))]
+#[pyo3(signature = (database, timeout=5.0, isolation_level="DEFERRED".to_string(), _check_same_thread=true, _uri=false, sync_url=None, sync_interval=None, auth_token="", encryption_key=None))]
 fn connect(
     py: Python<'_>,
     database: String,
     timeout: f64,
     isolation_level: Option<String>,
-    check_same_thread: bool,
-    uri: bool,
+    _check_same_thread: bool,
+    _uri: bool,
     sync_url: Option<String>,
     sync_interval: Option<f64>,
     auth_token: &str,
@@ -56,8 +66,8 @@ fn connect(
         database,
         timeout,
         isolation_level,
-        check_same_thread,
-        uri,
+        _check_same_thread,
+        _uri,
         sync_url,
         sync_interval,
         auth_token,
@@ -68,14 +78,14 @@ fn connect(
 
 #[pyfunction]
 #[cfg(Py_3_12)]
-#[pyo3(signature = (database, timeout=5.0, isolation_level="DEFERRED".to_string(), check_same_thread=true, uri=false, sync_url=None, sync_interval=None, auth_token="", encryption_key=None, autocommit = LEGACY_TRANSACTION_CONTROL))]
+#[pyo3(signature = (database, timeout=5.0, isolation_level="DEFERRED".to_string(), _check_same_thread=true, _uri=false, sync_url=None, sync_interval=None, auth_token="", encryption_key=None, autocommit = LEGACY_TRANSACTION_CONTROL))]
 fn connect(
     py: Python<'_>,
     database: String,
     timeout: f64,
     isolation_level: Option<String>,
-    check_same_thread: bool,
-    uri: bool,
+    _check_same_thread: bool,
+    _uri: bool,
     sync_url: Option<String>,
     sync_interval: Option<f64>,
     auth_token: &str,
@@ -87,8 +97,8 @@ fn connect(
         database,
         timeout,
         isolation_level.clone(),
-        check_same_thread,
-        uri,
+        _check_same_thread,
+        _uri,
         sync_url,
         sync_interval,
         auth_token,
@@ -111,8 +121,8 @@ fn _connect_core(
     database: String,
     timeout: f64,
     isolation_level: Option<String>,
-    check_same_thread: bool,
-    uri: bool,
+    _check_same_thread: bool,
+    _uri: bool,
     sync_url: Option<String>,
     sync_interval: Option<f64>,
     auth_token: &str,
@@ -220,7 +230,7 @@ unsafe impl Send for Connection {}
 
 #[pymethods]
 impl Connection {
-    fn close(self_: PyRef<'_, Self>, py: Python<'_>) -> PyResult<()> {
+    fn close(self_: PyRef<'_, Self>, _py: Python<'_>) -> PyResult<()> {
         self_.conn.replace(None);
         Ok(())
     }
@@ -286,7 +296,7 @@ impl Connection {
     fn execute(
         self_: PyRef<'_, Self>,
         sql: String,
-        parameters: Option<&PyTuple>,
+        parameters: Option<ListOrTuple>,
     ) -> PyResult<Cursor> {
         let cursor = Connection::cursor(&self_)?;
         rt().block_on(async { execute(&cursor, sql, parameters).await })?;
@@ -300,7 +310,7 @@ impl Connection {
     ) -> PyResult<Cursor> {
         let cursor = Connection::cursor(&self_)?;
         for parameters in parameters.unwrap().iter() {
-            let parameters = parameters.extract::<&PyTuple>()?;
+            let parameters = parameters.extract::<ListOrTuple>()?;
             rt().block_on(async { execute(&cursor, sql.clone(), Some(parameters)).await })?;
         }
         Ok(cursor)
@@ -330,11 +340,14 @@ impl Connection {
     fn in_transaction(self_: PyRef<'_, Self>) -> PyResult<bool> {
         #[cfg(Py_3_12)]
         {
-            return Ok(
+            Ok(
                 !self_.conn.borrow().as_ref().unwrap().is_autocommit() || self_.autocommit == 0
-            );
+            )
+        }
+        #[cfg(not(Py_3_12))]
+        {
+            Ok(!self_.conn.borrow().as_ref().unwrap().is_autocommit())
         }
-        Ok(!self_.conn.borrow().as_ref().unwrap().is_autocommit())
     }
 
     #[getter]
@@ -354,6 +367,26 @@ impl Connection {
         self_.autocommit = autocommit;
         Ok(())
     }
+
+    fn __enter__(slf: PyRef<'_, Self>) -> PyResult<PyRef<'_, Self>> {
+        Ok(slf)
+    }
+
+    fn __exit__(
+        self_: PyRef<'_, Self>,
+        exc_type: Option<&PyAny>,
+        _exc_val: Option<&PyAny>,
+        _exc_tb: Option<&PyAny>,
+    ) -> PyResult<bool> {
+        if exc_type.is_none() {
+            // Commit on clean exit
+            Connection::commit(self_)?;
+        } else {
+            // Rollback on error
+            Connection::rollback(self_)?;
+        }
+        Ok(false) // Always propagate exceptions
+    }
 }
 
 #[pyclass]
@@ -396,7 +429,7 @@ impl Cursor {
     fn execute<'a>(
         self_: PyRef<'a, Self>,
         sql: String,
-        parameters: Option<&PyTuple>,
+        parameters: Option<ListOrTuple>,
     ) -> PyResult<pyo3::PyRef<'a, Self>> {
         rt().block_on(async { execute(&self_, sql, parameters).await })?;
         Ok(self_)
@@ -408,7 +441,7 @@ impl Cursor {
         parameters: Option<&PyList>,
     ) -> PyResult<pyo3::PyRef<'a, Cursor>> {
         for parameters in parameters.unwrap().iter() {
-            let parameters = parameters.extract::<&PyTuple>()?;
+            let parameters = parameters.extract::<ListOrTuple>()?;
             rt().block_on(async { execute(&self_, sql.clone(), Some(parameters)).await })?;
         }
         Ok(self_)
@@ -552,7 +585,11 @@ async fn begin_transaction(conn: &libsql_core::Connection) -> PyResult<()> {
     Ok(())
 }
 
-async fn execute(cursor: &Cursor, sql: String, parameters: Option<&PyTuple>) -> PyResult<()> {
+async fn execute<'py>(
+    cursor: &Cursor,
+    sql: String,
+    parameters: Option<ListOrTuple<'py>>,
+) -> PyResult<()> {
     if cursor.conn.borrow().as_ref().is_none() {
         return Err(PyValueError::new_err("Connection already closed"));
     }
@@ -576,7 +613,10 @@ async fn execute(cursor: &Cursor, sql: String, parameters: Option<&PyTuple>) ->
                 } else if let Ok(value) = param.extract::<&[u8]>() {
                     libsql_core::Value::Blob(value.to_vec())
                 } else {
-                    return Err(PyValueError::new_err("Unsupported parameter type"));
+                    return Err(PyValueError::new_err(format!(
+                        "Unsupported parameter type {}",
+                        param.to_string()
+                    )));
                 };
                 params.push(param);
             }
@@ -653,6 +693,44 @@ fn convert_row(py: Python, row: libsql_core::Row, column_count: i32) -> PyResult
 
 create_exception!(libsql, Error, pyo3::exceptions::PyException);
 
+impl<'py> FromPyObject<'py> for ListOrTuple<'py> {
+    fn extract(ob: &'py PyAny) -> PyResult<Self> {
+        if let Ok(list) = ob.downcast::<PyList>() {
+            Ok(ListOrTuple::List(list))
+        } else if let Ok(tuple) = ob.downcast::<PyTuple>() {
+            Ok(ListOrTuple::Tuple(tuple))
+        } else {
+            Err(PyValueError::new_err(
+                "Expected a list or tuple for parameters",
+            ))
+        }
+    }
+}
+
+impl<'py> ListOrTuple<'py> {
+    pub fn iter(&self) -> ListOrTupleIterator {
+        ListOrTupleIterator{
+            index: 0,
+            inner: self,
+        }
+    }
+}
+
+impl<'py> Iterator for ListOrTupleIterator<'py> {
+    type Item = &'py PyAny;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let rv = match self.inner {
+            ListOrTuple::List(list) => list.get_item(self.index),
+            ListOrTuple::Tuple(tuple) => tuple.get_item(self.index),
+        };
+
+        rv.ok().map(|item| {
+            self.index += 1;
+            item
+        })
+    }
+}
 #[pymodule]
 fn libsql(py: Python, m: &PyModule) -> PyResult<()> {
     let _ = tracing_subscriber::fmt::try_init();

{libsql-0.1.3rc1 → libsql-0.1.5}/tests/test_suite.py

@@ -6,16 +6,19 @@ import libsql
 import pytest
 import tempfile
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_connection_timeout(provider):
     conn = connect(provider, ":memory:", timeout=1.0)
     conn.close()
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_connection_close(provider):
     conn = connect(provider, ":memory:")
     conn.close()
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_execute(provider):
     conn = connect(provider, ":memory:")
@@ -23,6 +26,9 @@ def test_execute(provider):
     conn.execute("INSERT INTO users VALUES (1, 'alice@example.com')")
     res = conn.execute("SELECT * FROM users")
     assert (1, "alice@example.com") == res.fetchone()
+    # allow lists for parameters as well
+    res = conn.execute("SELECT * FROM users WHERE id = ?", [1])
+    assert (1, "alice@example.com") == res.fetchone()
 
 
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
@@ -34,6 +40,7 @@ def test_cursor_execute(provider):
     res = cur.execute("SELECT * FROM users")
     assert (1, "alice@example.com") == res.fetchone()
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_cursor_close(provider):
     conn = connect(provider, ":memory:")
@@ -47,6 +54,7 @@ def test_cursor_close(provider):
     with pytest.raises(Exception):
         cur.execute("SELECT * FROM users")
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_executemany(provider):
     conn = connect(provider, ":memory:")
@@ -198,7 +206,9 @@ def test_connection_autocommit(provider):
     res = cur.execute("SELECT * FROM users")
     assert (1, "alice@example.com") == res.fetchone()
 
-    conn = connect(provider, ":memory:", timeout=5, isolation_level="DEFERRED", autocommit=-1)
+    conn = connect(
+        provider, ":memory:", timeout=5, isolation_level="DEFERRED", autocommit=-1
+    )
     assert conn.isolation_level == "DEFERRED"
     assert conn.autocommit == -1
     cur = conn.cursor()
@@ -210,7 +220,9 @@ def test_connection_autocommit(provider):
     assert (1, "alice@example.com") == res.fetchone()
 
     # Test autocommit Enabled (True)
-    conn = connect(provider, ":memory:", timeout=5, isolation_level=None, autocommit=True)
+    conn = connect(
+        provider, ":memory:", timeout=5, isolation_level=None, autocommit=True
+    )
     assert conn.isolation_level == None
     assert conn.autocommit == True
     cur = conn.cursor()
@@ -221,7 +233,9 @@ def test_connection_autocommit(provider):
     res = cur.execute("SELECT * FROM users")
     assert (1, "bob@example.com") == res.fetchone()
 
-    conn = connect(provider, ":memory:", timeout=5, isolation_level="DEFERRED", autocommit=True)
+    conn = connect(
+        provider, ":memory:", timeout=5, isolation_level="DEFERRED", autocommit=True
+    )
     assert conn.isolation_level == "DEFERRED"
     assert conn.autocommit == True
     cur = conn.cursor()
@@ -233,7 +247,9 @@ def test_connection_autocommit(provider):
     assert (1, "bob@example.com") == res.fetchone()
 
     # Test autocommit Disabled (False)
-    conn = connect(provider, ":memory:", timeout=5, isolation_level="DEFERRED", autocommit=False)
+    conn = connect(
+        provider, ":memory:", timeout=5, isolation_level="DEFERRED", autocommit=False
+    )
     assert conn.isolation_level == "DEFERRED"
     assert conn.autocommit == False
     cur = conn.cursor()
@@ -260,6 +276,7 @@ def test_params(provider):
     res = cur.execute("SELECT * FROM users")
     assert (1, "alice@example.com") == res.fetchone()
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_none_param(provider):
     conn = connect(provider, ":memory:")
@@ -272,6 +289,7 @@ def test_none_param(provider):
     assert results[0] == (1, None)
     assert results[1] == (2, "alice@example.com")
 
+
 @pytest.mark.parametrize("provider", ["libsql", "sqlite"])
 def test_fetchmany(provider):
     conn = connect(provider, ":memory:")
@@ -321,6 +339,194 @@ def test_int64(provider):
     assert [(1, 1099511627776)] == res.fetchall()
 
 
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_commit(provider):
+    """Test that context manager commits on clean exit"""
+    conn = connect(provider, ":memory:")
+    with conn as c:
+        c.execute("CREATE TABLE t(x)")
+        c.execute("INSERT INTO t VALUES (1)")
+    # Changes should be committed
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 1
+
+
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_rollback(provider):
+    """Test that context manager rolls back on exception"""
+    conn = connect(provider, ":memory:")
+    try:
+        with conn as c:
+            c.execute("CREATE TABLE t(x)")
+            c.execute("INSERT INTO t VALUES (1)")
+            raise ValueError("Test exception")
+    except ValueError:
+        pass
+    # Changes should be rolled back
+    cur = conn.cursor()
+    try:
+        cur.execute("SELECT COUNT(*) FROM t")
+        # If we get here, the table exists (rollback didn't work)
+        assert False, "Table should not exist after rollback"
+    except Exception:
+        # Table doesn't exist, which is what we expect after rollback
+        pass
+
+
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_autocommit(provider):
+    """Test that context manager works correctly with autocommit mode"""
+    conn = connect(provider, ":memory:", isolation_level=None)  # autocommit mode
+    with conn as c:
+        c.execute("CREATE TABLE t(x)")
+        c.execute("INSERT INTO t VALUES (1)")
+    # In autocommit mode, changes are committed immediately
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 1
+
+
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_nested(provider):
+    """Test nested context managers"""
+    conn = connect(provider, ":memory:")
+    with conn as c1:
+        c1.execute("CREATE TABLE t(x)")
+        c1.execute("INSERT INTO t VALUES (1)")
+        with conn as c2:
+            c2.execute("INSERT INTO t VALUES (2)")
+        # Inner context commits
+        cur = conn.cursor()
+        cur.execute("SELECT COUNT(*) FROM t")
+        assert cur.fetchone()[0] == 2
+    # Outer context also commits
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 2
+
+
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_connection_reuse(provider):
+    """Test that connection remains usable after context manager exit"""
+    conn = connect(provider, ":memory:")
+    
+    # First use with context manager
+    with conn as c:
+        c.execute("CREATE TABLE t(x)")
+        c.execute("INSERT INTO t VALUES (1)")
+    
+    # Connection should still be valid
+    cur = conn.cursor()
+    cur.execute("INSERT INTO t VALUES (2)")
+    conn.commit()
+    
+    # Verify both inserts worked
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 2
+    
+    # Use context manager again
+    with conn as c:
+        c.execute("INSERT INTO t VALUES (3)")
+    
+    # Final verification
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 3
+    
+    conn.close()
+
+
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_nested_exception(provider):
+    """Test exception handling in nested context managers"""
+    conn = connect(provider, ":memory:")
+    
+    # Create table outside context
+    conn.execute("CREATE TABLE t(x)")
+    conn.commit()
+    
+    # Test that nested context managers share the same transaction
+    # An exception in an inner context will roll back the entire transaction
+    try:
+        with conn as c1:
+            c1.execute("INSERT INTO t VALUES (1)")
+            try:
+                with conn as c2:
+                    c2.execute("INSERT INTO t VALUES (2)")
+                    raise ValueError("Inner exception")
+            except ValueError:
+                pass
+            # The inner rollback affects the entire transaction
+            # So value 1 is also rolled back
+            c1.execute("INSERT INTO t VALUES (3)")
+    except:
+        pass
+    
+    # Only value 3 should be committed (1 and 2 were rolled back together)
+    cur = conn.cursor()
+    cur.execute("SELECT x FROM t ORDER BY x")
+    results = cur.fetchall()
+    assert results == [(3,)]
+    
+    # Test outer exception after nested context commits
+    conn.execute("DROP TABLE t")
+    conn.execute("CREATE TABLE t(x)")
+    conn.commit()
+    
+    try:
+        with conn as c1:
+            c1.execute("INSERT INTO t VALUES (10)")
+            with conn as c2:
+                c2.execute("INSERT INTO t VALUES (20)")
+                # Inner context will commit both values
+            # This will cause outer rollback but values are already committed
+            raise RuntimeError("Outer exception")
+    except RuntimeError:
+        pass
+    
+    # Values 10 and 20 should be committed by inner context
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 2
+
+
+@pytest.mark.parametrize("provider", ["libsql", "sqlite"])
+def test_context_manager_manual_transaction_control(provider):
+    """Test mixing manual transaction control with context managers"""
+    conn = connect(provider, ":memory:")
+    
+    with conn as c:
+        c.execute("CREATE TABLE t(x)")
+        c.execute("INSERT INTO t VALUES (1)")
+        
+        # Manual commit within context
+        c.commit()
+        
+        # Start new transaction
+        c.execute("INSERT INTO t VALUES (2)")
+        # This will be committed by context manager
+    
+    # Both values should be present
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM t")
+    assert cur.fetchone()[0] == 2
+    
+    # Test manual rollback within context
+    with conn as c:
+        c.execute("INSERT INTO t VALUES (3)")
+        
+        # Manual rollback
+        c.rollback()
+        
+        # New transaction
+        c.execute("INSERT INTO t VALUES (4)")
+        # This will be committed by context manager
+    
+    # Should have values 1, 2, and 4 (not 3)
+    cur.execute("SELECT x FROM t ORDER BY x")
+    results = cur.fetchall()
+    assert results == [(1,), (2,), (4,)]
+
+
 def connect(provider, database, timeout=5, isolation_level="DEFERRED", autocommit=-1):
     if provider == "libsql-remote":
         from urllib import request
@@ -331,9 +537,7 @@ def connect(provider, database, timeout=5, isolation_level="DEFERRED", autocommi
             raise Exception("libsql-remote server is not running")
         if res.getcode() != 200:
             raise Exception("libsql-remote server is not running")
-        return libsql.connect(
-            database, sync_url="http://localhost:8080", auth_token=""
-        )
+        return libsql.connect(database, sync_url="http://localhost:8080", auth_token="")
     if provider == "libsql":
         if sys.version_info < (3, 12):
             return libsql.connect(
@@ -343,15 +547,23 @@ def connect(provider, database, timeout=5, isolation_level="DEFERRED", autocommi
             if autocommit == -1:
                 autocommit = libsql.LEGACY_TRANSACTION_CONTROL
             return libsql.connect(
-                database, timeout=timeout, isolation_level=isolation_level, autocommit=autocommit
+                database,
+                timeout=timeout,
+                isolation_level=isolation_level,
+                autocommit=autocommit,
             )
     if provider == "sqlite":
         if sys.version_info < (3, 12):
-            return sqlite3.connect(database, timeout=timeout, isolation_level=isolation_level)
+            return sqlite3.connect(
+                database, timeout=timeout, isolation_level=isolation_level
+            )
         else:
             if autocommit == -1:
                 autocommit = sqlite3.LEGACY_TRANSACTION_CONTROL
             return sqlite3.connect(
-                database, timeout=timeout, isolation_level=isolation_level, autocommit=autocommit
+                database,
+                timeout=timeout,
+                isolation_level=isolation_level,
+                autocommit=autocommit,
             )
     raise Exception(f"Provider `{provider}` is not supported")