feat: add new tests for SQL count on empty types and OpenCypher UNWIND behavior

Author: tae898

bindings/python/docs/development/testing/test-core.md

@@ -2,7 +2,7 @@
 
 [View source code]({{ config.repo_url }}/blob/{{ config.extra.version_tag }}/bindings/python/tests/test_core.py){ .md-button }
 
-There are **15 tests** covering fundamental database operations.
+There are **16 tests** covering fundamental database operations.
 
 ## Overview
 
@@ -15,6 +15,7 @@ Tests validate:
 - Query result handling and iteration
 - Error handling
 - OpenCypher queries (when available)
+- SQL aggregate behavior on empty types
 - Vector search with HNSW indexes
 - Unicode/international character support
 - Schema introspection and metadata
@@ -48,6 +49,7 @@ Tests validate:
 
 - **cypher_queries**: Tests OpenCypher CREATE statements, MATCH queries, property access (when OpenCypher available)
 - **sql_queries**: Tests SQL queries, aggregation, filtering, joins
+- **sql_count_on_empty_type_returns_zero**: Tests `count(*)` on an empty type returns a row with `0`
 
 ### Advanced Features
 

bindings/python/docs/development/testing/test-opencypher.md

@@ -4,6 +4,10 @@
 
 The tests validate OpenCypher query support and common graph patterns.
 
+They also include regression coverage for planner behavior that matters to the
+Python bindings, such as `UNWIND` variables being usable inside `WHERE`
+predicates.
+
 ## OpenCypher
 
 OpenCypher is a declarative graph query language for pattern matching and traversal.
@@ -40,6 +44,12 @@ with arcadedb.create_database("./opencypher_test_db") as db:
 pytest tests/test_cypher.py -v
 ```
 
+## Notable Regression Coverage
+
+- `UNWIND` variables can be referenced from `WHERE` clauses during `MATCH`
+- Aggregations on missing labels still return a single row with `0`
+- Result property order remains stable for projected OpenCypher values
+
 ## OpenCypher vs SQL MATCH
 
 | Feature | SQL MATCH | OpenCypher |

bindings/python/docs/development/testing/test-schema.md

@@ -8,6 +8,7 @@ Schema tests cover:
 
 - ✅ **Type Creation** - Vertex, edge, and document types
 - ✅ **Type Queries** - Getting types and checking existence
+- ✅ **Type Query Stability** - Repeated `get_types()` calls stay duplicate-free
 - ✅ **Type Deletion** - Removing types from schema
 - ✅ **Property Creation** - Adding properties to types
 - ✅ **Property Deletion** - Removing properties
@@ -52,6 +53,7 @@ Tests querying schema for types.
 - `test_get_type()` - Get type by name
 - `test_exists_type()` - Check if type exists
 - `test_get_types()` - List all types
+- `test_get_types_has_no_duplicates_across_repeated_calls()` - Repeated calls stay stable and duplicate-free
 - `test_get_type_properties()` - List type properties
 
 **Pattern:**

bindings/python/docs/index.md

@@ -63,7 +63,7 @@ access methods**:
     ```python
     db.command("sql", "CREATE DOCUMENT TYPE Person")
     with db.transaction():
-            db.command("sql", "INSERT INTO Person SET name = 'Alice'")
+        db.command("sql", "INSERT INTO Person SET name = 'Alice'")
     ```
 
 ### HTTP API (Server Mode)

bindings/python/fix_markdown.py

@@ -8,6 +8,8 @@
    separates them (space between ':' and first bullet point).
 3) List item indentation must be a multiple of 4 spaces (0,4,8,...). Normalize to the next
    multiple of 4 for indented lists.
+4) In Python fenced code blocks, clamp accidental over-indentation after block openers such as
+    `with`, `if`, and `for` to a single additional indentation level.
 """
 from __future__ import annotations
 
@@ -51,6 +53,15 @@ def _parse_fence(line: str) -> Optional[Tuple[str, int]]:
     return fence[0], len(fence)
 
 
+def _is_python_fence(line: str) -> bool:
+    stripped = line.lstrip()
+    match = FENCE_RE.match(stripped)
+    if not match:
+        return False
+    info = match.group(2).strip().lower()
+    return info.startswith("python")
+
+
 def _is_fence_close(line: str, fence_char: str, fence_len: int) -> bool:
     stripped = line.lstrip()
     if not stripped.startswith(fence_char * fence_len):
@@ -67,25 +78,42 @@ def _is_fence_close(line: str, fence_char: str, fence_len: int) -> bool:
 
 def process_file(
     path: Path,
-) -> Optional[Tuple[int, int, int, List[int], List[int], List[int]]]:
+) -> Optional[
+    Tuple[
+        int,
+        int,
+        int,
+        int,
+        List[int],
+        List[int],
+        List[int],
+        List[int],
+        List[int],
+    ]
+]:
     original = path.read_text(encoding="utf-8")
     lines = original.splitlines()
     new_lines: list[str] = []
     in_fence = False
+    in_python_fence = False
     fence_char: Optional[str] = None
     fence_len: Optional[int] = None
     changed = False
     header_fixes = 0
     blank_lines = 0
     heading_blank_lines = 0
     list_indent_fixes = 0
+    code_indent_fixes = 0
     header_lines: List[int] = []
     blank_lines_at: List[int] = []
     heading_blank_lines_at: List[int] = []
     list_indent_lines: List[int] = []
+    code_indent_lines: List[int] = []
 
     last_list_indent_len: Optional[int] = None
     last_list_fixed_len: Optional[int] = None
+    last_code_indent_len: Optional[int] = None
+    last_code_line: Optional[str] = None
 
     i = 0
     while i < len(lines):
@@ -95,16 +123,45 @@ def process_file(
             if fence_char is not None and fence_len is not None:
                 if _is_fence_close(line, fence_char, fence_len):
                     in_fence = False
+                    in_python_fence = False
                     fence_char = None
                     fence_len = None
+                    last_code_indent_len = None
+                    last_code_line = None
+                    new_lines.append(line)
+                    i += 1
+                    continue
+
+            if in_python_fence and line.strip():
+                indent_len = len(line) - len(line.lstrip(" "))
+                if (
+                    last_code_indent_len is not None
+                    and last_code_line is not None
+                    and last_code_line.rstrip().endswith(":")
+                    and indent_len > last_code_indent_len + 4
+                ):
+                    line = " " * (last_code_indent_len + 4) + line.lstrip(" ")
+                    changed = True
+                    code_indent_fixes += 1
+                    code_indent_lines.append(i + 1)
+
+                last_code_indent_len = len(line) - len(line.lstrip(" "))
+                last_code_line = line
+            elif in_python_fence:
+                last_code_indent_len = None
+                last_code_line = None
+
             new_lines.append(line)
             i += 1
             continue
 
         fence = _parse_fence(line)
         if fence:
             in_fence = True
+            in_python_fence = _is_python_fence(line)
             fence_char, fence_len = fence
+            last_code_indent_len = None
+            last_code_line = None
             new_lines.append(line)
             i += 1
             continue
@@ -187,9 +244,11 @@ def process_file(
             header_fixes,
             blank_lines,
             list_indent_fixes,
+            code_indent_fixes,
             header_lines,
             blank_lines_at,
             list_indent_lines,
+            code_indent_lines,
             heading_blank_lines,
             heading_blank_lines_at,
         )
@@ -215,16 +274,19 @@ def main() -> int:
     total_header = 0
     total_blank = 0
     total_indent = 0
+    total_code_indent = 0
     for md_file in iter_md_files(docs_root):
         result = process_file(md_file)
         if result:
             (
                 header_fixes,
                 blank_lines,
                 list_indent_fixes,
+                code_indent_fixes,
                 header_lines,
                 blank_lines_at,
                 list_indent_lines,
+                code_indent_lines,
                 heading_blank_lines,
                 heading_blank_lines_at,
             ) = result
@@ -234,34 +296,40 @@ def main() -> int:
                     header_fixes,
                     blank_lines,
                     list_indent_fixes,
+                    code_indent_fixes,
                     header_lines,
                     blank_lines_at,
                     list_indent_lines,
+                    code_indent_lines,
                     heading_blank_lines,
                     heading_blank_lines_at,
                 )
             )
             total_header += header_fixes
             total_blank += blank_lines
             total_indent += list_indent_fixes
+            total_code_indent += code_indent_fixes
             total_blank += heading_blank_lines
 
     print(f"Updated {len(changed_files)} files")
     print(
         "Totals: "
         f"headers fixed={total_header}, "
         f"blank lines inserted={total_blank}, "
-        f"list indents normalized={total_indent}"
+        f"list indents normalized={total_indent}, "
+        f"python code indents normalized={total_code_indent}"
     )
 
     for (
         path,
         header_fixes,
         blank_lines,
         list_indent_fixes,
+        code_indent_fixes,
         header_lines,
         blank_lines_at,
         list_indent_lines,
+        code_indent_lines,
         heading_blank_lines,
         heading_blank_lines_at,
     ) in changed_files:
@@ -278,6 +346,9 @@ def main() -> int:
         if list_indent_fixes:
             print(f"  List indents normalized: {list_indent_fixes}")
             print(f"    Lines: {_format_line_list(list_indent_lines)}")
+        if code_indent_fixes:
+            print(f"  Python code indents normalized: {code_indent_fixes}")
+            print(f"    Lines: {_format_line_list(code_indent_lines)}")
 
     return 0
 

bindings/python/tests/test_core.py

@@ -37,6 +37,17 @@ def test_database_operations(temp_db_path):
         assert record.get("value") == 42
 
 
+def test_sql_count_on_empty_type_returns_zero(temp_db_path):
+    """Test SQL count(*) returns a zero row for an empty type."""
+    with arcadedb.create_database(temp_db_path) as db:
+        db.command("sql", "CREATE DOCUMENT TYPE EmptyDoc")
+
+        result = db.query("sql", "SELECT count(*) as total FROM EmptyDoc")
+        row = result.one()
+
+        assert row.get("total") == 0
+
+
 def test_rich_data_types(temp_db_path):
     """Test ArcadeDB's rich data type support with comprehensive CRUD operations.
 

bindings/python/tests/test_cypher.py

@@ -212,6 +212,24 @@ def test_opencypher_collect_and_unwind(temp_db_path):
         assert rows == [("Acme", "Alice"), ("Acme", "Bob")]
 
 
+def test_opencypher_unwind_where_uses_unwind_variable(temp_db_path):
+    """Test WHERE predicates can reference variables introduced by UNWIND."""
+    with arcadedb.create_database(temp_db_path) as db:
+        _ensure_opencypher(db)
+        _seed_graph(db)
+
+        result = db.query(
+            "opencypher",
+            "UNWIND ['Alice', 'Bob', 'Nobody'] AS expected_name "
+            "MATCH (p:Person) "
+            "WHERE p.name = expected_name "
+            "RETURN p.name AS name ORDER BY name",
+        )
+        names = [record.get("name") for record in result]
+
+        assert names == ["Alice", "Bob"]
+
+
 def test_opencypher_pattern_comprehension(temp_db_path):
     """Test pattern comprehension to derive relationship values."""
     with arcadedb.create_database(temp_db_path) as db:

bindings/python/tests/test_schema.py

@@ -173,6 +173,20 @@ def test_get_types(self, test_db):
         assert "Vertex1" in type_names
         assert "Edge1" in type_names
 
+    def test_get_types_has_no_duplicates_across_repeated_calls(self, test_db):
+        """Test get_types remains stable and duplicate-free across repeated calls."""
+        schema = test_db.schema
+        schema.create_document_type("Doc1")
+        schema.create_vertex_type("Vertex1")
+        schema.create_edge_type("Edge1")
+
+        first_names = [type_obj.getName() for type_obj in schema.get_types()]
+        second_names = [type_obj.getName() for type_obj in schema.get_types()]
+
+        assert len(first_names) == len(set(first_names))
+        assert len(second_names) == len(set(second_names))
+        assert set(first_names) == set(second_names)
+
 
 class TestTypeDeletion:
     """Test type deletion methods."""