Merge pull request #38 from fermyon/sqlite-support

Add SQLite support

Author: rylev

crates/spin-python-engine/Cargo.toml

@@ -11,7 +11,7 @@ crate-type = [ "cdylib" ]
 anyhow = "1"
 bytes = { version = "1.2.1", features = ["serde"] }
 http = "0.2"
-spin-sdk = { git = "https://github.com/fermyon/spin", default-features = false }
+spin-sdk = { git = "https://github.com/fermyon/spin", rev = "b42f97f0d75e7935b533cb680a2131978e6377ff", default-features = false, features=["experimental"] }
 wit-bindgen-rust = { git = "https://github.com/bytecodealliance/wit-bindgen", rev = "dde4694aaa6acf9370206527a798ac4ba6a8c5b8" }
 pyo3 = { version = "0.17.3", features = [ "abi3-py310" ] }
 once_cell = "1.16.0"

crates/spin-python-engine/src/lib.rs

@@ -7,14 +7,15 @@ use {
     once_cell::unsync::OnceCell,
     pyo3::{
         exceptions::PyAssertionError,
-        types::{PyBytes, PyMapping, PyModule},
+        types::{PyBytes, PyList, PyMapping, PyModule},
         Py, PyAny, PyErr, PyObject, PyResult, Python, ToPyObject,
     },
     spin_sdk::{
         config,
         http::{Request, Response},
         key_value, outbound_http,
         redis::{self, RedisParameter, RedisResult},
+        sqlite,
     },
     std::{collections::HashMap, env, ops::Deref, str, sync::Arc},
 };
@@ -125,6 +126,80 @@ impl Store {
     }
 }
 
+#[derive(Clone)]
+#[pyo3::pyclass]
+#[pyo3(name = "SqliteConnection")]
+struct SqliteConnection {
+    inner: Arc<sqlite::Connection>,
+}
+
+#[pyo3::pymethods]
+impl SqliteConnection {
+    fn execute(
+        &self,
+        _py: Python<'_>,
+        query: String,
+        parameters: Vec<&PyAny>,
+    ) -> PyResult<QueryResult> {
+        let parameters = parameters
+            .iter()
+            .map(|v| {
+                if let Ok(v) = v.extract::<i64>() {
+                    Ok(sqlite::ValueParam::Integer(v))
+                } else if let Ok(v) = v.extract::<f64>() {
+                    Ok(sqlite::ValueParam::Real(v))
+                } else if let Ok(v) = v.extract::<&str>() {
+                    Ok(sqlite::ValueParam::Text(v))
+                } else if v.is_none() {
+                    Ok(sqlite::ValueParam::Null)
+                } else if let Ok(v) = v.downcast::<PyBytes>() {
+                    Ok(sqlite::ValueParam::Blob(v.as_bytes()))
+                } else {
+                    Err(PyErr::from(Anyhow(anyhow!(
+                        "Unable to use {v:?} as a SQLite `execute` parameter \
+                     -- expected `int`, `float`, `bytes`, `string`, or `None`"
+                    ))))
+                }
+            })
+            .collect::<PyResult<Vec<_>>>()?;
+        let result = self
+            .inner
+            .execute(&query, &parameters)
+            .map_err(Anyhow::from)?;
+        Ok(QueryResult { inner: result })
+    }
+}
+
+#[derive(Clone)]
+#[pyo3::pyclass]
+#[pyo3(name = "QueryResult")]
+struct QueryResult {
+    inner: sqlite::QueryResult,
+}
+
+#[pyo3::pymethods]
+impl QueryResult {
+    fn rows(&self, py: Python<'_>) -> PyResult<PyObject> {
+        let rows = self.inner.rows.iter().map(|r| {
+            PyList::new(
+                py,
+                r.values.iter().map(|v| match v {
+                    sqlite::ValueResult::Integer(i) => i.to_object(py),
+                    sqlite::ValueResult::Real(r) => r.to_object(py),
+                    sqlite::ValueResult::Text(s) => s.to_object(py),
+                    sqlite::ValueResult::Blob(b) => b.to_object(py),
+                    sqlite::ValueResult::Null => py.None(),
+                }),
+            )
+        });
+        Ok(PyList::new(py, rows).into())
+    }
+
+    fn columns(&self, py: Python<'_>) -> PyResult<PyObject> {
+        Ok(PyList::new(py, self.inner.columns.iter()).into())
+    }
+}
+
 struct Anyhow(Error);
 
 impl From<Anyhow> for PyErr {
@@ -325,6 +400,27 @@ fn spin_key_value_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
     module.add_function(pyo3::wrap_pyfunction!(kv_open_default, module)?)
 }
 
+#[pyo3::pyfunction]
+fn sqlite_open(database: String) -> Result<SqliteConnection, Anyhow> {
+    Ok(SqliteConnection {
+        inner: Arc::new(sqlite::Connection::open(&database).map_err(Anyhow::from)?),
+    })
+}
+
+#[pyo3::pyfunction]
+fn sqlite_open_default() -> Result<SqliteConnection, Anyhow> {
+    Ok(SqliteConnection {
+        inner: Arc::new(sqlite::Connection::open_default().map_err(Anyhow::from)?),
+    })
+}
+
+#[pyo3::pymodule]
+#[pyo3(name = "spin_sqlite")]
+fn spin_sqlite_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    module.add_function(pyo3::wrap_pyfunction!(sqlite_open, module)?)?;
+    module.add_function(pyo3::wrap_pyfunction!(sqlite_open_default, module)?)
+}
+
 #[pyo3::pyfunction]
 fn config_get(key: String) -> Result<String, Anyhow> {
     config::get(&key).map_err(Anyhow::from)
@@ -341,6 +437,7 @@ fn do_init() -> Result<()> {
     pyo3::append_to_inittab!(spin_redis_module);
     pyo3::append_to_inittab!(spin_config_module);
     pyo3::append_to_inittab!(spin_key_value_module);
+    pyo3::append_to_inittab!(spin_sqlite_module);
 
     pyo3::prepare_freethreaded_python();
 

examples/sqlite/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+*.wasm
+.spin

examples/sqlite/README.md

@@ -0,0 +1,3 @@
+# Spin python sqlite
+
+A simple example showcasing the return of a simple response to a request that uses the SQLite funtionality of the Python SDK.

examples/sqlite/app.py

@@ -0,0 +1,9 @@
+from spin_http import Response
+from spin_sqlite import sqlite_open_default
+
+def handle_request(request):
+    conn = sqlite_open_default();
+    result = conn.execute("SELECT * FROM todos WHERE id > (?);", [1])
+    return Response(200,
+                    {"content-type": "application/json"},
+                    bytes(str(result.rows()), "utf-8"))

examples/sqlite/migration.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS todos (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  description TEXT NOT NULL,
+  due_date DATE,
+  starred BOOLEAN DEFAULT 0,
+  is_completed BOOLEAN DEFAULT 0
+);

examples/sqlite/spin.toml

@@ -0,0 +1,16 @@
+spin_manifest_version = "1"
+authors = ["Fermyon Engineering <[email protected]>"]
+description = "Spin Python SDK sqlite example"
+name = "spin-py-sqlite"
+trigger = { type = "http", base = "/" }
+version = "0.1.0"
+
+[[component]]
+id = "python-sdk-example"
+source = "app.wasm"
+sqlite_databases = ["default"]
+[component.trigger]
+route = "/..."
+[component.build]
+command = "spin py2wasm app -o app.wasm"
+watch = ["app.py"]