perf: pre-allocate PyString column keys, cache json.dumps

- rows_to_dicts: allocate column name PyStrings once, reuse for
  every row dict (eliminates N*M PyString allocations)
- json.dumps: cache via GILOnceCell instead of module lookup per call

Author: semihalev

src/database.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList};
+use pyo3::types::{PyDict, PyList, PyString};
 use std::sync::Arc;
 
 use stoolap::api::Database as ApiDatabase;
@@ -223,12 +223,15 @@ pub fn to_named_params(named: &[(String, stoolap::core::Value)]) -> stoolap::api
 /// Convert Rows iterator to a list of Python dicts.
 pub fn rows_to_dicts(py: Python<'_>, rows: stoolap::api::Rows) -> PyResult<PyObject> {
     let columns: Vec<String> = rows.columns().to_vec();
+    // Pre-allocate column names as PyString once, reuse for every row
+    let py_col_names: Vec<Bound<'_, PyString>> =
+        columns.iter().map(|c| PyString::new(py, c)).collect();
     let result = PyList::empty(py);
 
     for row_result in rows {
         let row = row_result.map_err(to_py)?;
         let dict = PyDict::new(py);
-        for (i, col) in columns.iter().enumerate() {
+        for (i, col) in py_col_names.iter().enumerate() {
             let val = match row.get_value(i) {
                 Some(v) => value_to_py(py, v),
                 None => py.None(),
@@ -248,7 +251,10 @@ pub fn first_row_to_dict(py: Python<'_>, mut rows: stoolap::api::Rows) -> PyResu
     if let Some(row_result) = rows.next() {
         let row = row_result.map_err(to_py)?;
         let dict = PyDict::new(py);
-        for (i, col) in columns.iter().enumerate() {
+        // Single row — pre-allocate column names as PyString
+        let py_col_names: Vec<Bound<'_, PyString>> =
+            columns.iter().map(|c| PyString::new(py, c)).collect();
+        for (i, col) in py_col_names.iter().enumerate() {
             let val = match row.get_value(i) {
                 Some(v) => value_to_py(py, v),
                 None => py.None(),

src/value.rs

@@ -14,6 +14,7 @@
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{
     PyBool, PyDateAccess, PyDateTime, PyDict, PyFloat, PyInt, PyList, PyString, PyTimeAccess,
     PyTuple, timezone_utc,
@@ -23,6 +24,16 @@ use chrono::{Datelike, Timelike};
 use stoolap::api::ParamVec;
 use stoolap::core::Value;
 
+/// Cached `json.dumps` callable — avoids module lookup per JSON parameter.
+static JSON_DUMPS: GILOnceCell<PyObject> = GILOnceCell::new();
+
+fn get_json_dumps<'py>(py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+    let obj = JSON_DUMPS.get_or_try_init(py, || {
+        py.import("json")?.getattr("dumps").map(|f| f.unbind())
+    })?;
+    Ok(obj.bind(py).clone())
+}
+
 /// Parsed bind parameters from Python.
 pub enum BindParams {
     Positional(ParamVec),
@@ -63,8 +74,8 @@ pub fn py_to_value(obj: &Bound<'_, PyAny>) -> PyResult<Value> {
 
     // dict/list -> JSON string
     if obj.downcast::<PyDict>().is_ok() || obj.downcast::<PyList>().is_ok() {
-        let json_mod = obj.py().import("json")?;
-        let json_str: String = json_mod.call_method1("dumps", (obj,))?.extract()?;
+        let dumps = get_json_dumps(obj.py())?;
+        let json_str: String = dumps.call1((obj,))?.extract()?;
         return Ok(Value::json(&json_str));
     }