fix: review findings before 0.5.0, bump to 0.5.0-beta.2

AsyncTransaction.__aexit__ now delegates to Transaction.__exit__, so a
manual commit or rollback inside an async with block no longer raises on
exit or replaces the block's own exception.

Transaction.rollback() is a no-op once the transaction has ended, and a
failed commit() leaves the transaction active, so the documented
except: tx.rollback(); raise handler never hides the real error.

Database.open(':memory:') gives each open a private in-memory database;
memory://name keeps the shared one. A DSN with any scheme is passed to
the engine untouched instead of becoming a relative directory named
after the scheme. open() defaults to ':memory:' and releases the GIL,
as does prepare().

execute_batch accepts any iterable of parameter sets, not only a list.

Type stubs gain Vector, the four *_prepared methods on Transaction and
AsyncTransaction, and the open() default.

CI and publish build wheels for CPython 3.9 through 3.13 instead of 3.12
only, CI tests 3.9, 3.12 and 3.13, and a pre-release tag creates a
pre-release on GitHub.

Author: semihalev

.github/workflows/ci.yml

@@ -52,7 +52,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist -i python3.12
+          args: --release --out dist -i python3.9 python3.10 python3.11 python3.12 python3.13
           manylinux: auto
 
       - name: Upload wheels
@@ -69,7 +69,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python: ['3.12']
+        python: ['3.9', '3.12', '3.13']
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
@@ -99,7 +99,7 @@ jobs:
       - name: Install wheel and test dependencies
         shell: bash
         run: |
-          pip install dist/*.whl
+          pip install --no-index --find-links dist stoolap-python
           pip install pytest pytest-asyncio
 
       - name: Run tests

.github/workflows/publish.yml

@@ -49,7 +49,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist -i python3.12
+          args: --release --out dist -i python3.9 python3.10 python3.11 python3.12 python3.13
           manylinux: auto
 
       - name: Upload wheels
@@ -110,3 +110,4 @@ jobs:
         uses: softprops/action-gh-release@v2
         with:
           generate_release_notes: true
+          prerelease: ${{ contains(github.ref_name, 'a') || contains(github.ref_name, 'b') || contains(github.ref_name, 'rc') }}

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stoolap-python"
-version = "0.5.0-beta.1"
+version = "0.5.0-beta.2"
 edition = "2021"
 authors = ["Stoolap Contributors"]
 license = "Apache-2.0"

Cargo.toml

@@ -55,6 +55,10 @@ raw = db.query_raw("SELECT id, name FROM users ORDER BY id")
 db.close()
 ```
 
+Each `Database.open(":memory:")` is a private database. To share one in-memory database between opens in the same process, give it a name: `Database.open("memory://name")`.
+
+`query()` and `query_one()` key each row by column name, so two result columns with the same name (for example `a.id` and `b.id` in a join) collapse into one key. Alias them, or use `query_raw()`, when that matters.
+
 ## Prepared Statements
 
 Parse SQL once, execute many times with different parameters:
@@ -99,7 +103,7 @@ except:
     raise
 ```
 
-Transactions support `execute()`, `query()`, `query_one()`, `query_raw()`, and `execute_batch()` with both positional (`$1, $2`) and named (`:key`) parameters.
+Transactions support `execute()`, `query()`, `query_one()`, `query_raw()`, and `execute_batch()` with both positional (`$1, $2`) and named (`:key`) parameters. A statement prepared on the database runs inside a transaction with `execute_prepared(stmt, params)`, `query_prepared`, `query_one_prepared` and `query_raw_prepared`. `rollback()` is a no-op once the transaction has ended, so the handler above never hides the original error.
 
 ## Batch Execution
 

README.md

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "stoolap-python"
-version = "0.5.0b1"
+version = "0.5.0b2"
 description = "High-performance Python driver for Stoolap embedded SQL database"
 readme = "README.md"
 license = { text = "Apache-2.0" }

pyproject.toml

@@ -144,11 +144,9 @@ async def __aenter__(self) -> "AsyncTransaction":
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> bool:
-        if exc_type is not None:
-            await self.rollback()
-        else:
-            await self.commit()
-        return False
+        # Same rules as the sync context manager: commit on clean exit,
+        # rollback on exception, no-op if the block already ended the tx.
+        return await asyncio.to_thread(self._tx.__exit__, exc_type, exc_val, exc_tb)
 
     def __repr__(self) -> str:
         return repr(self._tx)

python/stoolap/__init__.py

@@ -21,6 +21,11 @@ __all__: list[str]
 
 class StoolapError(RuntimeError): ...
 
+class Vector:
+    def __init__(self, data: Sequence[float]) -> None: ...
+    def to_list(self) -> List[float]: ...
+    def __len__(self) -> int: ...
+
 class Database:
     @staticmethod
     def open(path: str = ":memory:") -> "Database": ...
@@ -40,6 +45,10 @@ class Transaction:
     def query_one(self, sql: str, params: Params = None) -> Optional[Dict[str, Any]]: ...
     def query_raw(self, sql: str, params: Params = None) -> Dict[str, Any]: ...
     def execute_batch(self, sql: str, params_list: Sequence[ParamSet]) -> int: ...
+    def execute_prepared(self, stmt: "PreparedStatement", params: Params = None) -> int: ...
+    def query_prepared(self, stmt: "PreparedStatement", params: Params = None) -> List[Dict[str, Any]]: ...
+    def query_one_prepared(self, stmt: "PreparedStatement", params: Params = None) -> Optional[Dict[str, Any]]: ...
+    def query_raw_prepared(self, stmt: "PreparedStatement", params: Params = None) -> Dict[str, Any]: ...
     def commit(self) -> None: ...
     def rollback(self) -> None: ...
     def __enter__(self) -> "Transaction": ...
@@ -73,6 +82,10 @@ class AsyncTransaction:
     async def query_one(self, sql: str, params: Params = None) -> Optional[Dict[str, Any]]: ...
     async def query_raw(self, sql: str, params: Params = None) -> Dict[str, Any]: ...
     async def execute_batch(self, sql: str, params_list: Sequence[ParamSet]) -> int: ...
+    async def execute_prepared(self, stmt: Union["AsyncPreparedStatement", PreparedStatement], params: Params = None) -> int: ...
+    async def query_prepared(self, stmt: Union["AsyncPreparedStatement", PreparedStatement], params: Params = None) -> List[Dict[str, Any]]: ...
+    async def query_one_prepared(self, stmt: Union["AsyncPreparedStatement", PreparedStatement], params: Params = None) -> Optional[Dict[str, Any]]: ...
+    async def query_raw_prepared(self, stmt: Union["AsyncPreparedStatement", PreparedStatement], params: Params = None) -> Dict[str, Any]: ...
     async def commit(self) -> None: ...
     async def rollback(self) -> None: ...
     async def __aenter__(self) -> "AsyncTransaction": ...

python/stoolap/__init__.pyi

@@ -14,6 +14,7 @@
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
 use stoolap::api::Database as ApiDatabase;
@@ -36,13 +37,14 @@ impl Database {
     /// Open a database connection.
     ///
     /// Accepts:
-    /// - `:memory:` or empty string for in-memory database
-    /// - `memory://` for in-memory database
+    /// - `:memory:` or empty string for a private in-memory database
+    /// - `memory://name` for an in-memory database shared by every open of that name
     /// - `./mydb` or `file:///path/to/db` for file-based database
     #[staticmethod]
-    fn open(path: &str) -> PyResult<Self> {
+    #[pyo3(signature = (path=":memory:"))]
+    fn open(py: Python<'_>, path: &str) -> PyResult<Self> {
         let dsn = translate_path(path);
-        let db = ApiDatabase::open(&dsn).map_err(to_py)?;
+        let db = py.allow_threads(|| ApiDatabase::open(&dsn)).map_err(to_py)?;
         Ok(Self { db: Arc::new(db) })
     }
 
@@ -137,13 +139,14 @@ impl Database {
         &self,
         py: Python<'_>,
         sql: &str,
-        params_list: &Bound<'_, PyList>,
+        params_list: &Bound<'_, PyAny>,
     ) -> PyResult<i64> {
         let sql = sql.to_string();
 
         // Parse all param sets on the Python thread (need GIL)
-        let mut all_params = Vec::with_capacity(params_list.len());
-        for item in params_list.iter() {
+        let mut all_params = Vec::with_capacity(params_list.len().unwrap_or(0));
+        for item in params_list.try_iter()? {
+            let item = item?;
             let bind = parse_params(Some(&item))?;
             match bind {
                 BindParams::Positional(p) => all_params.push(p),
@@ -171,8 +174,8 @@ impl Database {
     /// Create a prepared statement.
     ///
     /// Parses SQL once and caches the execution plan.
-    fn prepare(&self, sql: &str) -> PyResult<PreparedStatement> {
-        PreparedStatement::new(Arc::clone(&self.db), sql)
+    fn prepare(&self, py: Python<'_>, sql: &str) -> PyResult<PreparedStatement> {
+        py.allow_threads(|| PreparedStatement::new(Arc::clone(&self.db), sql))
     }
 
     /// Begin a transaction.
@@ -192,17 +195,39 @@ impl Database {
 }
 
 /// Translate user-friendly paths to Stoolap DSN format.
+///
+/// `:memory:` gets a DSN unique to this open, so two `:memory:` databases in
+/// one process never share tables and closing one leaves the other open.
+/// Anything that already carries a scheme is passed through untouched and
+/// left to the engine to validate; a bare path becomes `file://path`.
 fn translate_path(path: &str) -> String {
+    static MEMORY_OPENS: AtomicU64 = AtomicU64::new(0);
+
     let trimmed = path.trim();
     if trimmed.is_empty() || trimmed == ":memory:" {
-        "memory://".to_string()
-    } else if trimmed.starts_with("memory://") || trimmed.starts_with("file://") {
+        let n = MEMORY_OPENS.fetch_add(1, Ordering::Relaxed);
+        format!("memory://py-{}-{n}", std::process::id())
+    } else if has_scheme(trimmed) {
         trimmed.to_string()
     } else {
         format!("file://{trimmed}")
     }
 }
 
+/// True when `s` starts with an RFC 3986 scheme followed by `://`.
+fn has_scheme(s: &str) -> bool {
+    match s.find("://") {
+        Some(idx) if idx > 0 => {
+            let scheme = &s[..idx];
+            scheme.chars().next().is_some_and(|c| c.is_ascii_alphabetic())
+                && scheme
+                    .chars()
+                    .all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
+        }
+        _ => false,
+    }
+}
+
 /// Convert named params to stoolap NamedParams.
 pub fn to_named_params(named: &[(String, stoolap::core::Value)]) -> stoolap::api::NamedParams {
     let mut np = stoolap::api::NamedParams::new();

src/database.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 use pyo3::prelude::*;
-use pyo3::types::PyList;
 use std::sync::Arc;
 
 use stoolap::api::{Database as ApiDatabase, Statement as ApiStatement};
@@ -99,10 +98,11 @@ impl PreparedStatement {
     ///
     /// Auto-wraps in a transaction. Returns total rows affected.
     #[pyo3(signature = (params_list,))]
-    fn execute_batch(&self, py: Python<'_>, params_list: &Bound<'_, PyList>) -> PyResult<i64> {
+    fn execute_batch(&self, py: Python<'_>, params_list: &Bound<'_, PyAny>) -> PyResult<i64> {
         // Parse all param sets while holding GIL
-        let mut all_params = Vec::with_capacity(params_list.len());
-        for item in params_list.iter() {
+        let mut all_params = Vec::with_capacity(params_list.len().unwrap_or(0));
+        for item in params_list.try_iter()? {
+            let item = item?;
             let bind = parse_params(Some(&item))?;
             match bind {
                 BindParams::Positional(p) => all_params.push(p),