dirsql 0.3.76__tar.gz → 0.3.77__tar.gz

{dirsql-0.3.76 → dirsql-0.3.77}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.76"
+version = "0.3.77"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.76 → dirsql-0.3.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.76
+Version: 0.3.77
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

{dirsql-0.3.76 → dirsql-0.3.77}/docs/reference/sdk.md

@@ -210,6 +210,12 @@ Executes a SQL query and returns rows keyed by column name.
 | BLOB | `bytes` | `Buffer` | `Value::Blob` |
 | NULL | `None` | `null` | `Value::Null` |
 
+An `INTEGER` outside JavaScript's safe integer range (magnitude greater
+than `Number.MAX_SAFE_INTEGER`, 2^53 − 1) cannot be represented as a JS
+`number` without precision loss, so the TypeScript SDK **throws** rather
+than return a rounded value. Python's `int` is unbounded, so it always
+round-trips.
+
 ### `watch`
 
 ::: code-group
@@ -351,7 +357,14 @@ An `extract` callback (and the SQLite columns it feeds) accepts:
 | SQLite column | Python value | TypeScript value | Rust `Value` |
 |---|---|---|---|
 | TEXT | `str` | `string` | `Value::Text(String)` |
-| INTEGER | `int`, `bool` | `number`, `boolean` | `Value::Integer(i64)` |
+| INTEGER | `int`, `bool` | `number`, `boolean`, `bigint` | `Value::Integer(i64)` |
 | REAL | `float` | `number` | `Value::Real(f64)` |
 | BLOB | `bytes` | `Buffer` / `Uint8Array` | `Value::Blob(Vec<u8>)` |
 | NULL | `None` | `null` | `Value::Null` |
+
+Integers are stored as a signed 64-bit `Value::Integer`. A value that does
+not fit that range is a hard error, not a lossy conversion: Python raises
+`OverflowError`, and a TypeScript `bigint` outside the `i64` range throws.
+A TypeScript `bigint` **within** `i64` range maps to `INTEGER`. Only a real
+`bytes`/`bytearray` (Python) or `Buffer`/`Uint8Array` (TypeScript) maps to
+`BLOB` — a list/array of integers does not.

{dirsql-0.3.76 → dirsql-0.3.77}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.76"
+version = "0.3.77"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.76/packages/rust → dirsql-0.3.77/packages/python}/docs/reference/sdk.md

@@ -210,6 +210,12 @@ Executes a SQL query and returns rows keyed by column name.
 | BLOB | `bytes` | `Buffer` | `Value::Blob` |
 | NULL | `None` | `null` | `Value::Null` |
 
+An `INTEGER` outside JavaScript's safe integer range (magnitude greater
+than `Number.MAX_SAFE_INTEGER`, 2^53 − 1) cannot be represented as a JS
+`number` without precision loss, so the TypeScript SDK **throws** rather
+than return a rounded value. Python's `int` is unbounded, so it always
+round-trips.
+
 ### `watch`
 
 ::: code-group
@@ -351,7 +357,14 @@ An `extract` callback (and the SQLite columns it feeds) accepts:
 | SQLite column | Python value | TypeScript value | Rust `Value` |
 |---|---|---|---|
 | TEXT | `str` | `string` | `Value::Text(String)` |
-| INTEGER | `int`, `bool` | `number`, `boolean` | `Value::Integer(i64)` |
+| INTEGER | `int`, `bool` | `number`, `boolean`, `bigint` | `Value::Integer(i64)` |
 | REAL | `float` | `number` | `Value::Real(f64)` |
 | BLOB | `bytes` | `Buffer` / `Uint8Array` | `Value::Blob(Vec<u8>)` |
 | NULL | `None` | `null` | `Value::Null` |
+
+Integers are stored as a signed 64-bit `Value::Integer`. A value that does
+not fit that range is a hard error, not a lossy conversion: Python raises
+`OverflowError`, and a TypeScript `bigint` outside the `i64` range throws.
+A TypeScript `bigint` **within** `i64` range maps to `INTEGER`. Only a real
+`bytes`/`bytearray` (Python) or `Buffer`/`Uint8Array` (TypeScript) maps to
+`BLOB` — a list/array of integers does not.

{dirsql-0.3.76 → dirsql-0.3.77}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783522894,
+  "ran_at": 1783524611,
   "exit_code": 0,
-  "commit": "aff7a746e4dfcd46d9f52f11f5cd7f680f5464ae"
+  "commit": "ee0a7c75d1e80868ace1390d0a99c92420c2f60e"
 }

{dirsql-0.3.76 → dirsql-0.3.77}/packages/python/src/lib.rs

@@ -13,9 +13,9 @@
 #[cfg(feature = "extension-module")]
 mod python {
     use ::dirsql::{DirSQL, Extension, Row, RowEvent, Table, Value, db::parse_table_name};
-    use pyo3::exceptions::PyRuntimeError;
+    use pyo3::exceptions::{PyOverflowError, PyRuntimeError};
     use pyo3::prelude::*;
-    use pyo3::types::{PyDict, PyList};
+    use pyo3::types::{PyBool, PyByteArray, PyBytes, PyDict, PyInt, PyList};
     use std::collections::HashMap;
     use std::path::PathBuf;
     use std::time::Duration;
@@ -361,21 +361,34 @@ mod python {
         }
 
         // bool must precede int (bool is a subclass of int in Python).
-        if bound.is_instance_of::<pyo3::types::PyBool>() {
+        if bound.is_instance_of::<PyBool>() {
             let b: bool = bound.extract()?;
             return Ok(Value::Integer(if b { 1 } else { 0 }));
         }
 
-        if let Ok(i) = bound.extract::<i64>() {
-            return Ok(Value::Integer(i));
+        // A Python int must round-trip losslessly or fail loudly. Falling
+        // through to f64/str would silently corrupt an out-of-i64 value
+        // (lossy Real, or a TEXT repr).
+        if bound.is_instance_of::<PyInt>() {
+            return match bound.extract::<i64>() {
+                Ok(i) => Ok(Value::Integer(i)),
+                Err(_) => Err(PyOverflowError::new_err(int_overflow_message(
+                    &bound.str()?.to_string(),
+                ))),
+            };
         }
+
         if let Ok(f) = bound.extract::<f64>() {
             return Ok(Value::Real(f));
         }
         if let Ok(s) = bound.extract::<String>() {
             return Ok(Value::Text(s));
         }
-        if let Ok(b) = bound.extract::<Vec<u8>>() {
+        // Only genuine binary types map to BLOB. A list/tuple of ints must
+        // NOT be probed as bytes (that turned `[1,2,3]` into a BLOB by
+        // magnitude); it falls through to the repr like any other sequence.
+        if bound.is_instance_of::<PyBytes>() || bound.is_instance_of::<PyByteArray>() {
+            let b: Vec<u8> = bound.extract()?;
             return Ok(Value::Blob(b));
         }
 
@@ -383,6 +396,11 @@ mod python {
         Ok(Value::Text(bound.str()?.to_string()))
     }
 
+    /// The range-error message for a Python int that does not fit `i64`.
+    fn int_overflow_message(repr: &str) -> String {
+        format!("integer {repr} exceeds the 64-bit signed range dirsql can store")
+    }
+
     fn value_to_py(py: Python<'_>, value: &Value) -> Py<PyAny> {
         match value {
             Value::Null => py.None(),
@@ -481,5 +499,12 @@ mod python {
         fn extract_error_displays_inner() {
             assert_eq!(ExtractError("bad".to_string()).to_string(), "bad");
         }
+
+        #[test]
+        fn int_overflow_message_names_the_value() {
+            let m = int_overflow_message("9223372036854775808");
+            assert!(m.contains("9223372036854775808"));
+            assert!(m.contains("exceeds"));
+        }
     }
 }

{dirsql-0.3.76/packages/python → dirsql-0.3.77/packages/rust}/docs/reference/sdk.md

@@ -210,6 +210,12 @@ Executes a SQL query and returns rows keyed by column name.
 | BLOB | `bytes` | `Buffer` | `Value::Blob` |
 | NULL | `None` | `null` | `Value::Null` |
 
+An `INTEGER` outside JavaScript's safe integer range (magnitude greater
+than `Number.MAX_SAFE_INTEGER`, 2^53 − 1) cannot be represented as a JS
+`number` without precision loss, so the TypeScript SDK **throws** rather
+than return a rounded value. Python's `int` is unbounded, so it always
+round-trips.
+
 ### `watch`
 
 ::: code-group
@@ -351,7 +357,14 @@ An `extract` callback (and the SQLite columns it feeds) accepts:
 | SQLite column | Python value | TypeScript value | Rust `Value` |
 |---|---|---|---|
 | TEXT | `str` | `string` | `Value::Text(String)` |
-| INTEGER | `int`, `bool` | `number`, `boolean` | `Value::Integer(i64)` |
+| INTEGER | `int`, `bool` | `number`, `boolean`, `bigint` | `Value::Integer(i64)` |
 | REAL | `float` | `number` | `Value::Real(f64)` |
 | BLOB | `bytes` | `Buffer` / `Uint8Array` | `Value::Blob(Vec<u8>)` |
 | NULL | `None` | `null` | `Value::Null` |
+
+Integers are stored as a signed 64-bit `Value::Integer`. A value that does
+not fit that range is a hard error, not a lossy conversion: Python raises
+`OverflowError`, and a TypeScript `bigint` outside the `i64` range throws.
+A TypeScript `bigint` **within** `i64` range maps to `INTEGER`. Only a real
+`bytes`/`bytearray` (Python) or `Buffer`/`Uint8Array` (TypeScript) maps to
+`BLOB` — a list/array of integers does not.