anysite-cli 0.1.5__tar.gz → 0.1.6__tar.gz

{anysite_cli-0.1.5 → anysite_cli-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anysite-cli
-Version: 0.1.5
+Version: 0.1.6
 Summary: CLI for Anysite API - web data extraction for humans and AI agents
 Project-URL: Homepage, https://anysite.io
 Project-URL: Documentation, https://docs.anysite.io/cli

{anysite_cli-0.1.5 → anysite_cli-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "anysite-cli"
-version = "0.1.5"
+version = "0.1.6"
 description = "CLI for Anysite API - web data extraction for humans and AI agents"
 readme = "README.md"
 license = "MIT"

{anysite_cli-0.1.5 → anysite_cli-0.1.6}/src/anysite/dataset/db_loader.py

@@ -326,13 +326,14 @@ class DatasetDbLoader:
                 total += 1
 
         # DELETE removed records (skipped in append mode)
+        ph = self._placeholder()
         if result.removed and sync_mode == "full":
             safe_col = sanitize_identifier(db_key_col)
             for record in result.removed:
                 key_val = _get_key_val(record)
                 if key_val is not None:
                     self.adapter.execute(
-                        f"DELETE FROM {table_name} WHERE {safe_col} = ?",
+                        f"DELETE FROM {table_name} WHERE {safe_col} = {ph}",
                         (str(key_val),),
                     )
                     total += 1
@@ -354,14 +355,14 @@ class DatasetDbLoader:
                 for field_name in changed_fields:
                     new_val = record.get(field_name)
                     safe_field = sanitize_identifier(field_name)
-                    set_parts.append(f"{safe_field} = ?")
+                    set_parts.append(f"{safe_field} = {ph}")
                     params.append(new_val)
 
                 params.append(str(key_val))
                 sql = (
                     f"UPDATE {table_name} "
                     f"SET {', '.join(set_parts)} "
-                    f"WHERE {safe_col} = ?"
+                    f"WHERE {safe_col} = {ph}"
                 )
                 self.adapter.execute(sql, tuple(params))
                 total += 1
@@ -375,6 +376,12 @@ class DatasetDbLoader:
                 return other.dependency.field
         return None
 
+    def _placeholder(self) -> str:
+        """Get the parameter placeholder for the dialect."""
+        if self._dialect == "postgres":
+            return "%s"
+        return "?"
+
     def _auto_id_type(self) -> str:
         """Get the auto-increment ID column type for the dialect."""
         if self._dialect == "postgres":

{anysite_cli-0.1.5 → anysite_cli-0.1.6}/tests/test_dataset/test_db_loader.py

@@ -1,7 +1,6 @@
 """Tests for dataset DB loader with SQLite in-memory adapter."""
 
 import json
-
 import pytest
 
 from anysite.dataset.db_loader import DatasetDbLoader, _extract_dot_value, _filter_record
@@ -736,3 +735,101 @@ class TestAppendSyncMode:
             rows = adapter.fetch_all("SELECT * FROM posts")
             assert len(rows) == 1
             assert rows[0]["uid"] == "a"
+
+
+class TestPostgresPlaceholders:
+    """Test that diff-based sync uses %s placeholders for postgres dialect."""
+
+    def _setup_two_snapshots(self, tmp_path, source_id, old_records, new_records):
+        source_dir = get_source_dir(tmp_path / "data", source_id)
+        write_parquet(old_records, source_dir / "2026-01-01.parquet")
+        write_parquet(new_records, source_dir / "2026-01-02.parquet")
+
+    def test_delete_uses_percent_s(self, tmp_path):
+        """DELETE query uses %s placeholder for postgres."""
+        sources = [
+            DatasetSource(
+                id="items", endpoint="/api/items",
+                db_load=DbLoadConfig(key="name", sync="full"),
+            ),
+        ]
+        config = _make_config(tmp_path, sources)
+
+        self._setup_two_snapshots(
+            tmp_path, "items",
+            old_records=[
+                {"name": "Alice", "score": 90},
+                {"name": "Bob", "score": 80},
+            ],
+            new_records=[{"name": "Alice", "score": 90}],
+        )
+
+        # Use real SQLite adapter for initial load, then mock for diff sync
+        adapter = _sqlite_adapter()
+        with adapter:
+            source_dir = get_source_dir(tmp_path / "data", "items")
+            loader = DatasetDbLoader(config, adapter)
+            loader._full_insert(
+                sources[0], "items", source_dir / "2026-01-01.parquet"
+            )
+
+            # Patch dialect to postgres and spy on execute
+            loader2 = DatasetDbLoader(config, adapter)
+            loader2._dialect = "postgres"
+            original_execute = adapter.execute
+            calls = []
+
+            def spy_execute(sql, params=None):
+                calls.append((sql, params))
+                # Replace %s with ? for SQLite execution
+                original_execute(sql.replace("%s", "?"), params)
+
+            adapter.execute = spy_execute
+            loader2.load_all()
+
+            # Verify DELETE used %s
+            delete_calls = [c for c in calls if "DELETE" in c[0]]
+            assert len(delete_calls) == 1
+            assert "%s" in delete_calls[0][0]
+            assert "?" not in delete_calls[0][0]
+
+    def test_update_uses_percent_s(self, tmp_path):
+        """UPDATE query uses %s placeholders for postgres."""
+        sources = [
+            DatasetSource(
+                id="items", endpoint="/api/items",
+                db_load=DbLoadConfig(key="name"),
+            ),
+        ]
+        config = _make_config(tmp_path, sources)
+
+        self._setup_two_snapshots(
+            tmp_path, "items",
+            old_records=[{"name": "Alice", "score": 90}],
+            new_records=[{"name": "Alice", "score": 95}],
+        )
+
+        adapter = _sqlite_adapter()
+        with adapter:
+            source_dir = get_source_dir(tmp_path / "data", "items")
+            loader = DatasetDbLoader(config, adapter)
+            loader._full_insert(
+                sources[0], "items", source_dir / "2026-01-01.parquet"
+            )
+
+            loader2 = DatasetDbLoader(config, adapter)
+            loader2._dialect = "postgres"
+            original_execute = adapter.execute
+            calls = []
+
+            def spy_execute(sql, params=None):
+                calls.append((sql, params))
+                original_execute(sql.replace("%s", "?"), params)
+
+            adapter.execute = spy_execute
+            loader2.load_all()
+
+            update_calls = [c for c in calls if "UPDATE" in c[0]]
+            assert len(update_calls) == 1
+            assert "%s" in update_calls[0][0]
+            assert "?" not in update_calls[0][0]