Refactor schema operations to be auto-transactional in tests

- Updated multiple test files to remove explicit transaction blocks for schema operations.
- Ensured that document and vertex types are created without wrapping them in transactions, leveraging the auto-transactional behavior of the database.
- Improved readability and maintainability of test code by simplifying transaction management.

Author: tae898

bindings/python/README.md

@@ -2,7 +2,7 @@
 
 Native Python bindings for ArcadeDB - the multi-model database that supports Graph, Document, Key/Value, Search Engine, Time Series, and Vector models.
 
-**Status**: ✅ Production Ready | **Tests**: 204 Passing | **Platforms**: 6 Supported
+**Status**: ✅ Production Ready | **Tests**: 221 Passing | **Platforms**: 6 Supported
 
 ---
 
@@ -45,7 +45,7 @@ We publish development versions (`X.Y.Z.devN`) for every push to main when `pom.
 ```python
 import arcadedb_embedded as arcadedb
 
-# Create database (context manager for automatic cleanup)
+# Create database (context manager for automatic open and close)
 with arcadedb.create_database("/tmp/mydb") as db:
     # Create schema
     db.command("sql", "CREATE DOCUMENT TYPE Person")
@@ -76,7 +76,7 @@ with arcadedb.create_database("/tmp/mydb") as db:
 - ⚡ **High performance**: Direct JVM integration via JPype
 - 🔒 **ACID transactions**: Full transaction support
 - 🎯 **Vector storage**: Store and query vector embeddings with JVector indexing
-- 📥 **Data import**: Built-in CSV, XML, ArcadeDB JSONL import
+- 📥 **Data import**: Built-in CSV and ArcadeDB JSONL import
 
 ---
 
@@ -94,12 +94,12 @@ The `arcadedb-embedded` package is platform-specific and self-contained:
 
 | Platform      | Wheel Size | JRE Size | Installed Size | Tests         |
 | ------------- | ---------- | -------- | -------------- | ------------- |
-| Windows ARM64 | 209.4M     | 47.6M    | ~274M          | 204 passed ✅ |
-| macOS ARM64   | 210.8M     | 53.9M    | ~280M          | 204 passed ✅ |
-| macOS Intel   | 211.9M     | 55.3M    | ~281M          | 204 passed ✅ |
-| Windows x64   | 211.6M     | 51.6M    | ~278M          | 204 passed ✅ |
-| Linux ARM64   | 214.1M     | 61.8M    | ~288M          | 204 passed ✅ |
-| Linux x64     | 215.0M     | 62.7M    | ~289M          | 204 passed ✅ |
+| Windows ARM64 | 209.4M     | 47.6M    | ~274M          | 221 passed ✅ |
+| macOS ARM64   | 210.8M     | 53.9M    | ~280M          | 221 passed ✅ |
+| macOS Intel   | 211.9M     | 55.3M    | ~281M          | 221 passed ✅ |
+| Windows x64   | 211.6M     | 51.6M    | ~278M          | 221 passed ✅ |
+| Linux ARM64   | 214.1M     | 61.8M    | ~288M          | 221 passed ✅ |
+| Linux x64     | 215.0M     | 62.7M    | ~289M          | 221 passed ✅ |
 
 **Note**: Some JARs are excluded to optimize package size (e.g., gRPC wire protocol). See `jar_exclusions.txt` for details.
 
@@ -109,7 +109,7 @@ Import: `import arcadedb_embedded as arcadedb`
 
 ## 🧪 Testing
 
-**Status**: 204 tests + 7 example scripts passing on all 6 platforms
+**Status**: 221 tests + 7 example scripts passing on all 6 platforms
 
 ```bash
 # Run all tests
@@ -209,7 +209,7 @@ arcadedb_embedded/
 ├── transactions.py      # TransactionContext manager
 ├── schema.py            # Schema management API
 ├── vector.py            # Vector search and JVector indexing
-├── importer.py          # Data import (CSV, XML)
+├── importer.py          # Data import (CSV, JSONL)
 ├── exporter.py          # Data export (JSONL, GraphML, GraphSON, CSV)
 ├── batch.py             # Batch operations context
 ├── async_executor.py    # Asynchronous query execution

bindings/python/docs/api-access-methods.md

@@ -21,14 +21,19 @@ import arcadedb_embedded as arcadedb
 
 # Direct database access - NO server needed
 with arcadedb.create_database("/tmp/mydb") as db:
-    # Create schema
-    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    # Create schema (auto-transactional)
+    db.schema.create_document_type("Person")
+    db.schema.create_property("Person", "name", "STRING")
+    db.schema.create_property("Person", "age", "INTEGER")
 
     # Insert data (requires transaction)
     with db.transaction():
-        db.command("sql", "INSERT INTO Person SET name = 'Alice', age = 30")
+        person = db.new_document("Person")
+        person.set("name", "Alice")
+        person.set("age", 30)
+        person.save()
 
-    # Query data
+    # Query data (SQL is fine for reads)
     result = db.query("sql", "SELECT FROM Person WHERE age > 25")
     for record in result:
         print(f"Name: {record.get('name')}")
@@ -46,10 +51,17 @@ server.start()
 try:
     db = server.create_database("mydb")
 
-    # Same Java API calls as standalone
+    # Schema operations are auto-transactional
+    db.schema.create_document_type("Person")
+    db.schema.create_property("Person", "name", "STRING")
+    db.schema.create_property("Person", "age", "INTEGER")
+
+    # Data operations require explicit transactions
     with db.transaction():
-        db.command("sql", "CREATE DOCUMENT TYPE Person")
-        db.command("sql", "INSERT INTO Person SET name = 'Alice', age = 30")
+        person = db.new_document("Person")
+        person.set("name", "Alice")
+        person.set("age", 30)
+        person.save()
 
     result = db.query("sql", "SELECT FROM Person WHERE age > 25")
     for record in result:
@@ -111,6 +123,9 @@ try:
         }
     )
     assert response.status_code == 200
+    # Note: HTTP commands are auto-transactional per request. For multi-statement atomicity, use
+    # the HTTP transactional endpoints or perform batch writes with the embedded API via
+    # `with db.transaction():`.
 
     # Query data via HTTP
     response = requests.post(
@@ -144,9 +159,17 @@ try:
     # Create database using Java API (fastest)
     db = server.create_database("hybriddb")
 
+    # Schema operations are auto-transactional
+    db.schema.create_document_type("Person")
+    db.schema.create_property("Person", "name", "STRING")
+    db.schema.create_property("Person", "age", "INTEGER")
+
+    # Data operations require explicit transactions
     with db.transaction():
-        db.command("sql", "CREATE DOCUMENT TYPE Person")
-        db.command("sql", "INSERT INTO Person SET name = 'Alice', age = 30")
+        person = db.new_document("Person")
+        person.set("name", "Alice")
+        person.set("age", 30)
+        person.save()
 
     # Query same data using HTTP API (remote access)
     auth = HTTPBasicAuth("root", "password123")

bindings/python/docs/api/async_executor.md

@@ -426,7 +426,7 @@ import arcadedb_embedded as arcadedb
 import time
 
 # Create database
-db = arcadedb.create_database("./async_demo", create_if_not_exists=True)
+db = arcadedb.create_database("./async_demo")
 
 # Create schema
 with db.transaction():
@@ -502,6 +502,16 @@ print(f"Speedup: {sync_time / async_time:.1f}x")
 
 ## Best Practices
 
+### 0. Set a Commit Cadence
+
+```python
+async_exec = db.async_executor()
+async_exec.set_commit_every(500)  # Ensures async writes are persisted transactionally
+```
+
+- Configure `set_commit_every()` for every async workload so writes are grouped into transactions.
+- Tune the batch size to balance commit overhead and memory.
+
 ### 1. Always Close the Executor
 
 ```python

bindings/python/docs/api/batch.md

@@ -49,7 +49,7 @@ db.batch_context(
 ```python
 import arcadedb_embedded as arcadedb
 
-db = arcadedb.create_database("./mydb", create_if_not_exists=True)
+db = arcadedb.create_database("./mydb")
 
 # Create schema
 with db.transaction():
@@ -358,7 +358,7 @@ with db.batch_context(
 import arcadedb_embedded as arcadedb
 import time
 
-db = arcadedb.create_database("./bulk_db", create_if_not_exists=True)
+db = arcadedb.create_database("./bulk_db")
 
 # Create schema
 with db.transaction():

bindings/python/docs/api/database.md

@@ -31,8 +31,9 @@ import arcadedb_embedded as arcadedb
 
 db = arcadedb.create_database("/tmp/mydb")
 try:
-    # Use database
-    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    # Schema operations are auto-transactional
+    db.schema.create_document_type("Person")
+    db.schema.create_property("Person", "name", "STRING")
 finally:
     db.close()
 ```
@@ -72,7 +73,7 @@ Open an existing database.
 ```python
 with arcadedb.open_database("/tmp/mydb") as db:
     result = db.query("sql", "SELECT FROM Person")
-    print(f"Found {len(result)} records")
+    print(f"Found {len(list(result))} records")
 ```
 
 ---
@@ -201,30 +202,39 @@ Execute a command (write operation). Commands modify data and **require a transa
 **Example:**
 
 ```python
-# Must be in a transaction
-with db.transaction():
-    # Create type
-    db.command("sql", "CREATE DOCUMENT TYPE Person")
+# Schema operations are auto-transactional
+db.schema.create_document_type("Person")
+db.schema.create_property("Person", "name", "STRING")
+db.schema.create_property("Person", "age", "INTEGER")
 
-    # Insert data
-    db.command("sql", "INSERT INTO Person SET name = ?, age = ?", "Alice", 30)
+# Data operations must be in a transaction
+with db.transaction():
+    doc = db.new_document("Person")
+    doc.set("name", "Alice")
+    doc.set("age", 30)
+    doc.save()
 
-    # Update data
-    db.command("sql", "UPDATE Person SET age = 31 WHERE name = 'Alice'")
+    # Update data via API
+    doc.set("age", 31)
+    doc.save()
 
     # Delete data
-    db.command("sql", "DELETE FROM Person WHERE name = 'Alice'")
+    db.delete(doc)
 ```
 
 !!! warning "Transaction Required"
     Write operations must be wrapped in a transaction:
     ```python
     # ✅ Correct
     with db.transaction():
-        db.command("sql", "INSERT INTO Person SET name = 'Alice'")
+        doc = db.new_document("Person")
+        doc.set("name", "Alice")
+        doc.save()
 
     # ❌ Will fail
-    db.command("sql", "INSERT INTO Person SET name = 'Alice'")
+    doc = db.new_document("Person")
+    doc.set("name", "Alice")
+    # doc.save() outside a transaction will raise
     ```
 
 ---
@@ -245,8 +255,10 @@ Create a transaction context manager.
 
 ```python
 with db.transaction():
-    db.command("sql", "INSERT INTO Person SET name = 'Alice'")
-    db.command("sql", "INSERT INTO Person SET name = 'Bob'")
+    for name in ["Alice", "Bob"]:
+        doc = db.new_document("Person")
+        doc.set("name", name)
+        doc.save()
     # Automatic commit on success, rollback on exception
 ```
 
@@ -256,8 +268,10 @@ with db.transaction():
 # Alternative: manual control
 db.begin()
 try:
-    db.command("sql", "INSERT INTO Person SET name = 'Alice'")
-    db.command("sql", "INSERT INTO Person SET name = 'Bob'")
+    for name in ["Alice", "Bob"]:
+        doc = db.new_document("Person")
+        doc.set("name", name)
+        doc.save()
     db.commit()
 except Exception as e:
     db.rollback()
@@ -668,7 +682,18 @@ from arcadedb_embedded import ArcadeDBError
 
 try:
     with arcadedb.create_database("/tmp/mydb") as db:
-        db.command("sql", "INVALID SQL")
+        # Schema operations are auto-transactional
+        db.schema.create_document_type("User")
+        db.schema.create_property("User", "email", "STRING")
+        db.schema.create_index("User", ["email"], unique=True)
+
+        # Data operations require an explicit transaction
+        with db.transaction():
+            doc = db.new_document("User")
+            doc.set("email", "alice@example.com").save()
+
+            dup = db.new_document("User")
+            dup.set("email", "alice@example.com").save()
 except ArcadeDBError as e:
     print(f"Error: {e}")
 ```
@@ -694,7 +719,8 @@ db.close()
 ```python
 # ✅ Good
 with db.transaction():
-    db.command("sql", "INSERT INTO Person SET name = 'Alice'")
+    person = db.new_document("Person")
+    person.set("name", "Alice").save()
 
 # ❌ Will fail
 db.command("sql", "INSERT INTO Person SET name = 'Alice'")

bindings/python/docs/api/record-wrappers.md

@@ -24,8 +24,8 @@ import arcadedb_embedded as arcadedb
 from arcadedb_embedded.graph import Document, Vertex, Edge
 
 with arcadedb.create_database("/tmp/mydb") as db:
-    with db.transaction():
-        db.schema.create_document_type("Note")
+    # Schema operations are auto-transactional
+    db.schema.create_document_type("Note")
 
     # Create a document
     with db.transaction():
@@ -188,8 +188,8 @@ traversing edges.
 ### Creating Vertices
 
 ```python
-with db.transaction():
-    db.schema.create_vertex_type("Person")
+# Schema operations are auto-transactional
+db.schema.create_vertex_type("Person")
 
 with db.transaction():
     alice = db.new_vertex("Person")