refactor: simplify DuckDB store to native JSON storage only

- Remove native_storage parameter from DuckDBSerializationAdapter and DuckDBStore
- Remove value_json TEXT column from schema, use only value_dict JSON column
- Update all SQL statements to work with single value_dict column
- Remove TestDuckDBStoreTextMode test class
- Remove test_text_mode_storage() and test_native_vs_stringified_storage() tests
- Update test_native_sql_queryability() to use correct JSON path for nested value
- Regenerate sync library with simplified implementation

This simplification focuses on native JSON storage for better queryability
and removes the complexity of supporting dual storage modes.

Co-authored-by: William Easton <strawgate@users.noreply.github.com>

Author: github-actions[bot]

key-value/key-value-aio/src/key_value/aio/stores/duckdb/store.py

@@ -18,31 +18,22 @@
 
 
 class DuckDBSerializationAdapter(SerializationAdapter):
-    """Adapter for DuckDB with support for native JSON and TEXT storage modes."""
+    """Adapter for DuckDB with native JSON storage."""
 
-    _native_storage: bool
-
-    def __init__(self, *, native_storage: bool = True) -> None:
-        """Initialize the DuckDB adapter.
-
-        Args:
-            native_storage: If True, use JSON column for native dict storage.
-                          If False, use TEXT column for stringified JSON.
-        """
+    def __init__(self) -> None:
+        """Initialize the DuckDB adapter."""
         super().__init__()
 
-        self._native_storage = native_storage
         self._date_format = "datetime"
-        # Always use string format - DuckDB needs JSON strings for both TEXT and JSON columns
+        # Use string format - DuckDB needs JSON strings for JSON columns
         self._value_format = "string"
 
     @override
     def prepare_dump(self, data: dict[str, Any]) -> dict[str, Any]:
         """Prepare data for dumping to DuckDB.
 
-        Moves the value to the appropriate column (value_dict or value_json)
-        and sets the other column to None. Also includes version, key, and collection
-        fields in the JSON for compatibility with deserialization.
+        Stores the value in the value_dict JSON column and includes version, key,
+        and collection fields in the JSON for compatibility with deserialization.
         """
         value = data.pop("value")
 
@@ -51,7 +42,7 @@ def prepare_dump(self, data: dict[str, Any]) -> dict[str, Any]:
         key = data.pop("key", None)
         collection_name = data.pop("collection", None)
 
-        # Build the document to store in JSON columns
+        # Build the document to store in JSON column
         json_document: dict[str, Any] = {"value": value}
 
         if version is not None:
@@ -61,32 +52,23 @@ def prepare_dump(self, data: dict[str, Any]) -> dict[str, Any]:
         if collection_name is not None:
             json_document["collection"] = collection_name
 
-        # Set both columns to None, then populate the appropriate one
-        data["value_json"] = None
-        data["value_dict"] = None
-
-        if self._native_storage:
-            # For native storage, convert the document to JSON string for DuckDB's JSON column
-            # DuckDB will parse it and store it as native JSON
-            data["value_dict"] = json.dumps(json_document)
-        else:
-            # For TEXT storage, store as JSON string
-            data["value_json"] = json.dumps(json_document)
+        # Store as JSON string for DuckDB's JSON column
+        # DuckDB will parse it and store it as native JSON
+        data["value_dict"] = json.dumps(json_document)
 
         return data
 
     @override
     def prepare_load(self, data: dict[str, Any]) -> dict[str, Any]:
         """Prepare data loaded from DuckDB for conversion to ManagedEntry.
 
-        Extracts value, version, key, and collection from the JSON columns
+        Extracts value, version, key, and collection from the JSON column
         and handles timezone conversion for DuckDB's naive timestamps.
         """
-        value_json = data.pop("value_json", None)
         value_dict = data.pop("value_dict", None)
 
-        # Parse the JSON document from the appropriate column
-        json_document = self._parse_json_column(value_dict, value_json)
+        # Parse the JSON document from the value_dict column
+        json_document = self._parse_json_column(value_dict)
 
         # Extract fields from the JSON document
         data["value"] = json_document.get("value")
@@ -102,27 +84,20 @@ def prepare_load(self, data: dict[str, Any]) -> dict[str, Any]:
 
         return data
 
-    def _parse_json_column(self, value_dict: Any, value_json: Any) -> dict[str, Any]:  # noqa: ANN401
-        """Parse JSON from value_dict or value_json column."""
-        if value_dict is not None:
-            # Native storage mode - value_dict can be dict or string (DuckDB JSON returns as string)
-            if isinstance(value_dict, dict):
-                return cast(dict[str, Any], value_dict)
-            if isinstance(value_dict, str):
-                parsed: dict[str, Any] = json.loads(value_dict)
-                return parsed
-            msg = f"value_dict has unexpected type: {type(value_dict)}"
+    def _parse_json_column(self, value_dict: Any) -> dict[str, Any]:
+        """Parse JSON from value_dict column."""
+        if value_dict is None:
+            msg = "value_dict column contains no data"
             raise DeserializationError(message=msg)
 
-        if value_json is not None:
-            # Stringified JSON mode - parse from string
-            if isinstance(value_json, str):
-                parsed_json: dict[str, Any] = json.loads(value_json)
-                return parsed_json
-            msg = f"value_json has unexpected type: {type(value_json)}"
-            raise DeserializationError(message=msg)
+        # value_dict can be dict or string (DuckDB JSON returns as string)
+        if isinstance(value_dict, dict):
+            return cast("dict[str, Any]", value_dict)
+        if isinstance(value_dict, str):
+            parsed: dict[str, Any] = json.loads(value_dict)
+            return parsed
 
-        msg = "Neither value_dict nor value_json column contains data"
+        msg = f"value_dict has unexpected type: {type(value_dict)}"
         raise DeserializationError(message=msg)
 
     def _convert_timestamps_to_utc(self, data: dict[str, Any]) -> None:
@@ -146,9 +121,8 @@ class DuckDBStore(BaseContextManagerStore, BaseStore):
     The store uses native DuckDB types (JSON, TIMESTAMP) to enable efficient SQL queries
     on stored data. Users can query the database directly for analytics or data exploration.
 
-    Storage modes:
-    - native_storage=True: Stores values in a JSON column as native dicts for queryability
-    - native_storage=False: Stores values as stringified JSON in a TEXT column
+    Values are stored in a JSON column as native dicts, allowing direct SQL queries
+    on the stored data for analytics and reporting.
 
     Note on connection ownership: When you provide an existing connection, the store
     will take ownership and close it when the store is closed or garbage collected.
@@ -167,7 +141,6 @@ def __init__(
         *,
         connection: duckdb.DuckDBPyConnection,
         table_name: str = "kv_entries",
-        native_storage: bool = True,
         default_collection: str | None = None,
         seed: SEED_DATA_TYPE | None = None,
     ) -> None:
@@ -180,8 +153,6 @@ def __init__(
         Args:
             connection: An existing DuckDB connection to use.
             table_name: Name of the table to store key-value entries. Defaults to "kv_entries".
-            native_storage: If True, use native JSON column for dict storage; if False, use TEXT for stringified JSON.
-                Default is True for better queryability and native type support.
             default_collection: The default collection to use if no collection is provided.
             seed: Optional seed data to pre-populate the store.
         """
@@ -192,7 +163,6 @@ def __init__(
         *,
         database_path: Path | str | None = None,
         table_name: str = "kv_entries",
-        native_storage: bool = True,
         default_collection: str | None = None,
         seed: SEED_DATA_TYPE | None = None,
     ) -> None:
@@ -201,8 +171,6 @@ def __init__(
         Args:
             database_path: Path to the database file. If None or ':memory:', uses in-memory database.
             table_name: Name of the table to store key-value entries. Defaults to "kv_entries".
-            native_storage: If True, use native JSON column for dict storage; if False, use TEXT for stringified JSON.
-                Default is True for better queryability and native type support.
             default_collection: The default collection to use if no collection is provided.
             seed: Optional seed data to pre-populate the store.
         """
@@ -213,7 +181,6 @@ def __init__(
         connection: duckdb.DuckDBPyConnection | None = None,
         database_path: Path | str | None = None,
         table_name: str = "kv_entries",
-        native_storage: bool = True,
         default_collection: str | None = None,
         seed: SEED_DATA_TYPE | None = None,
     ) -> None:
@@ -223,8 +190,6 @@ def __init__(
             connection: An existing DuckDB connection to use.
             database_path: Path to the database file. If None or ':memory:', uses in-memory database.
             table_name: Name of the table to store key-value entries. Defaults to "kv_entries".
-            native_storage: If True, use native JSON column for dict storage; if False, use TEXT for stringified JSON.
-                Default is True for better queryability and native type support.
             default_collection: The default collection to use if no collection is provided.
             seed: Optional seed data to pre-populate the store.
         """
@@ -248,7 +213,7 @@ def __init__(
             self._owns_connection = True
 
         self._is_closed = False
-        self._adapter = DuckDBSerializationAdapter(native_storage=native_storage)
+        self._adapter = DuckDBSerializationAdapter()
         self._table_name = table_name
         self._stable_api = False
 
@@ -264,8 +229,7 @@ def _get_create_table_sql(self) -> str:
             CREATE TABLE IF NOT EXISTS {self._table_name} (
                 collection VARCHAR NOT NULL,
                 key VARCHAR NOT NULL,
-                value_json TEXT,
-                value_dict JSON,
+                value_dict JSON NOT NULL,
                 created_at TIMESTAMP,
                 expires_at TIMESTAMP,
                 PRIMARY KEY (collection, key)
@@ -301,7 +265,7 @@ def _get_select_sql(self) -> str:
             SQL SELECT statement with placeholders.
         """
         return f"""
-            SELECT value_json, value_dict, created_at, expires_at
+            SELECT value_dict, created_at, expires_at
             FROM {self._table_name}
             WHERE collection = ? AND key = ?
         """  # noqa: S608
@@ -314,8 +278,8 @@ def _get_insert_sql(self) -> str:
         """
         return f"""
             INSERT OR REPLACE INTO {self._table_name}
-            (collection, key, value_json, value_dict, created_at, expires_at)
-            VALUES (?, ?, ?, ?, ?, ?)
+            (collection, key, value_dict, created_at, expires_at)
+            VALUES (?, ?, ?, ?, ?)
         """  # noqa: S608
 
     def _get_delete_sql(self) -> str:
@@ -335,17 +299,15 @@ async def _setup(self) -> None:
         """Initialize the database schema for key-value storage.
 
         The schema uses native DuckDB types for efficient querying:
-        - value_json: TEXT column storing stringified JSON (used when native_storage=False)
-        - value_dict: JSON column storing native dicts (used when native_storage=True)
+        - value_dict: JSON column storing native dicts for queryability
         - created_at: TIMESTAMP for native datetime operations
         - expires_at: TIMESTAMP for native expiration queries
 
-        This design follows the Elasticsearch/MongoDB pattern of separating native and stringified
-        storage, enabling:
-        - Direct SQL queries on the database for analytics (when using native storage)
+        This design enables:
+        - Direct SQL queries on the database for analytics
         - Efficient expiration cleanup: DELETE FROM table WHERE expires_at < now()
         - Metadata queries without JSON deserialization
-        - Flexibility to choose between native dict storage and stringified JSON
+        - Native JSON column support for rich querying capabilities
         """
         # Create the main table for storing key-value entries
         self._connection.execute(self._get_create_table_sql())
@@ -360,7 +322,7 @@ async def _setup(self) -> None:
     async def _get_managed_entry(self, *, key: str, collection: str) -> ManagedEntry | None:
         """Retrieve a managed entry by key from the specified collection.
 
-        Reconstructs the ManagedEntry from value columns and metadata columns
+        Reconstructs the ManagedEntry from value column and metadata columns
         using the serialization adapter.
         """
         if self._is_closed:
@@ -375,11 +337,10 @@ async def _get_managed_entry(self, *, key: str, collection: str) -> ManagedEntry
         if result is None:
             return None
 
-        value_json, value_dict, created_at, expires_at = result
+        value_dict, created_at, expires_at = result
 
-        # Build document dict for the adapter (exclude None values)
+        # Build document dict for the adapter
         document: dict[str, Any] = {
-            "value_json": value_json,
             "value_dict": value_dict,
         }
 
@@ -411,15 +372,14 @@ async def _put_managed_entry(
             raise RuntimeError(msg)
 
         # Use adapter to dump the managed entry to a dict with key and collection
-        document = self._adapter.dump_dict(entry=managed_entry, exclude_none=False, key=key, collection=collection)
+        document = self._adapter.dump_dict(entry=managed_entry, key=key, collection=collection)
 
         # Insert or replace the entry with metadata in separate columns
         self._connection.execute(
             self._get_insert_sql(),
             [
                 collection,
                 key,
-                document["value_json"],
                 document["value_dict"],
                 document.get("created_at"),
                 document.get("expires_at"),