Refactor vector parameter tests to use SQL commands for schema creation

- Updated test_vector_params_verification.py to replace schema methods with SQL commands for creating vertex types and properties.
- Updated test_vector_sql.py to similarly replace schema methods with SQL commands for vertex type and property creation.
- Ensured consistency in index verification by querying schema metadata via SQL instead of using schema methods.

Author: tae898

bindings/python/.gitignore

@@ -45,3 +45,6 @@ notebooks/
 
 # local built jars
 local-jars/
+
+# test databases
+my_test_databases/

bindings/python/README.md

@@ -35,10 +35,10 @@ import arcadedb_embedded as arcadedb
 
 # Create database (context manager for automatic open and close)
 with arcadedb.create_database("./mydb") as db:
-  # Create schema (schema ops are auto-transactional)
-  db.schema.create_document_type("Person")
-  db.schema.create_property("Person", "name", "STRING")
-  db.schema.create_property("Person", "age", "INTEGER")
+    # Create schema (DDL)
+    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    db.command("sql", "CREATE PROPERTY Person.name STRING")
+    db.command("sql", "CREATE PROPERTY Person.age INTEGER")
 
     # Insert data (requires transaction)
     with db.transaction():
@@ -48,9 +48,6 @@ with arcadedb.create_database("./mydb") as db:
     result = db.query("sql", "SELECT FROM Person WHERE age > 25")
     for record in result:
         print(f"Name: {record.get('name')}")
-
-  # SQL also works (useful when talking to a remote server),
-  # but the embedded API above is preferred for local use.
 ```
 
 **[👉 See full tutorial](https://docs.humem.ai/arcadedb/latest/getting-started/quickstart/)**

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

@@ -4,7 +4,11 @@ ArcadeDB Python bindings provide **two distinct access methods** that can be use
 
 ## Java API (Embedded Mode)
 
-Direct JVM method calls via JPype - **recommended for most Python applications**.
+Direct JVM method calls via JPype for embedded/local runtime access.
+
+!!! note "DSL-first guidance"
+    Prefer SQL/OpenCypher via `db.command(...)` and `db.query(...)` for schema, CRUD, and graph operations.
+    Wrapper APIs remain available, but examples and guides are standardized on DSL usage.
 
 ### Characteristics
 
@@ -23,16 +27,13 @@ import arcadedb_embedded as arcadedb
 # Direct database access - NO server needed
 with arcadedb.create_database("./mydb") as db:
     # Create schema (auto-transactional)
-    db.schema.create_document_type("Person")
-    db.schema.create_property("Person", "name", "STRING")
-    db.schema.create_property("Person", "age", "INTEGER")
+    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    db.command("sql", "CREATE PROPERTY Person.name STRING")
+    db.command("sql", "CREATE PROPERTY Person.age INTEGER")
 
     # Insert data (requires transaction)
     with db.transaction():
-        person = db.new_document("Person")
-        person.set("name", "Alice")
-        person.set("age", 30)
-        person.save()
+        db.command("sql", "INSERT INTO Person SET name = 'Alice', age = 30")
 
     # Query data (SQL is fine for reads)
     result = db.query("sql", "SELECT FROM Person WHERE age > 25")
@@ -54,16 +55,13 @@ try:
     db = server.create_database("mydb")
 
     # 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")
+    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    db.command("sql", "CREATE PROPERTY Person.name STRING")
+    db.command("sql", "CREATE PROPERTY Person.age INTEGER")
 
     # Data operations require explicit transactions
     with db.transaction():
-        person = db.new_document("Person")
-        person.set("name", "Alice")
-        person.set("age", 30)
-        person.save()
+        db.command("sql", "INSERT INTO Person SET name = 'Alice', age = 30")
 
     result = db.query("sql", "SELECT FROM Person WHERE age > 25")
     for record in result:
@@ -130,8 +128,7 @@ try:
     if not response.ok:
         raise RuntimeError(f"Insert failed: {response.status_code} {response.text}")
     # 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():`.
+    # the HTTP transactional endpoints or embedded `with db.transaction():` blocks.
 
     # Query data via HTTP
     response = requests.post(
@@ -205,16 +202,13 @@ try:
     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")
+    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    db.command("sql", "CREATE PROPERTY Person.name STRING")
+    db.command("sql", "CREATE PROPERTY Person.age INTEGER")
 
     # Data operations require explicit transactions
     with db.transaction():
-        person = db.new_document("Person")
-        person.set("name", "Alice")
-        person.set("age", 30)
-        person.save()
+        db.command("sql", "INSERT INTO Person SET name = 'Alice', age = 30")
 
     # Query same data using HTTP API (remote access)
     auth = HTTPBasicAuth("root", "password123")
@@ -248,11 +242,11 @@ finally:
 
 ## When to Use Each
 
-### Use Java API When:
+### Use Embedded Mode When:
 
 - Single Python process application
 - Maximum performance required
-- Complex data manipulation
+- Local SQL/OpenCypher workflows
 - Batch processing
 - Local development/testing
 
@@ -265,16 +259,16 @@ finally:
 - Microservices architecture
 - Cross-network access
 
-### Use Both When:
+### Use Hybrid Access When:
 
 - Local high-performance operations + remote monitoring
 - Hybrid applications with embedded + web components
-- Development (Java API) + production monitoring (HTTP API)
+- Development (embedded) + production monitoring (HTTP API)
 
 ## Common Misconceptions
 
-- ❌ **"Java API is only for Java"**
-    - ✅ Java API is Python calling Java via JPype (fully Pythonic)
+- ❌ **"Embedded mode is only for Java"**
+    - ✅ Embedded mode is Python calling Java via JPype (fully Pythonic)
 - ❌ **"HTTP API is inferior"**
     - ✅ HTTP API enables remote access (different purpose)
 - ❌ **"Must choose one or the other"**

bindings/python/docs/api/async_executor.md

@@ -446,12 +446,12 @@ import time
 # Create database
 db = arcadedb.create_database("./async_demo")
 
-# Create schema (Schema API is auto-transactional)
-db.schema.create_vertex_type("Product")
-db.schema.create_property("Product", "productId", "LONG")
-db.schema.create_property("Product", "name", "STRING")
-db.schema.create_property("Product", "price", "DECIMAL")
-db.schema.create_index("Product", ["productId"], unique=True)
+# Create schema (ArcadeDB SQL DDL)
+db.command("sql", "CREATE VERTEX TYPE Product")
+db.command("sql", "CREATE PROPERTY Product.productId LONG")
+db.command("sql", "CREATE PROPERTY Product.name STRING")
+db.command("sql", "CREATE PROPERTY Product.price DECIMAL")
+db.command("sql", "CREATE INDEX ON Product (productId) UNIQUE")
 
 # Prepare async executor
 async_exec = (db.async_executor()

bindings/python/docs/api/batch.md

@@ -61,10 +61,10 @@ import arcadedb_embedded as arcadedb
 db = arcadedb.create_database("./mydb")
 
 # Create schema
-db.schema.create_vertex_type("User")
-db.schema.create_property("User", "userId", "LONG")
-db.schema.create_property("User", "name", "STRING")
-db.schema.create_index("User", ["userId"], unique=True)
+db.command("sql", "CREATE VERTEX TYPE User")
+db.command("sql", "CREATE PROPERTY User.userId LONG")
+db.command("sql", "CREATE PROPERTY User.name STRING")
+db.command("sql", "CREATE INDEX ON User (userId) UNIQUE")
 
 # Batch create vertices
 with db.batch_context(batch_size=10000, parallel=8) as batch:
@@ -372,11 +372,11 @@ import time
 db = arcadedb.create_database("./bulk_db")
 
 # Create schema
-db.schema.create_vertex_type("Product")
-db.schema.create_property("Product", "productId", "LONG")
-db.schema.create_property("Product", "name", "STRING")
-db.schema.create_property("Product", "price", "DECIMAL")
-db.schema.create_index("Product", ["productId"], unique=True)
+db.command("sql", "CREATE VERTEX TYPE Product")
+db.command("sql", "CREATE PROPERTY Product.productId LONG")
+db.command("sql", "CREATE PROPERTY Product.name STRING")
+db.command("sql", "CREATE PROPERTY Product.price DECIMAL")
+db.command("sql", "CREATE INDEX ON Product (productId) UNIQUE")
 
 # Generate sample data
 products = [
@@ -429,9 +429,9 @@ db.close()
 
 ```python
 # ✅ Good: Schema defined before batch
-db.schema.create_vertex_type("User")
-db.schema.create_property("User", "userId", "LONG")
-db.schema.create_index("User", ["userId"], unique=True)
+db.command("sql", "CREATE VERTEX TYPE User")
+db.command("sql", "CREATE PROPERTY User.userId LONG")
+db.command("sql", "CREATE INDEX ON User (userId) UNIQUE")
 
 with db.batch_context() as batch:
     # Batch operations

bindings/python/docs/api/database.md

@@ -2,6 +2,10 @@
 
 Complete API reference for working with ArcadeDB databases in Python.
 
+!!! note "DSL-first usage"
+    For application code and examples, prefer SQL/OpenCypher via `db.command(...)` and `db.query(...)`.
+    This page also documents wrapper/object methods for compatibility and low-level API completeness.
+
 ## Module Functions
 
 ### create_database
@@ -30,9 +34,8 @@ Create a new database at the specified path.
 import arcadedb_embedded as arcadedb
 
 with arcadedb.create_database("./mydb") as db:
-    # Schema operations are auto-transactional
-    db.schema.create_document_type("Person")
-    db.schema.create_property("Person", "name", "STRING")
+    db.command("sql", "CREATE DOCUMENT TYPE Person")
+    db.command("sql", "CREATE PROPERTY Person.name STRING")
 ```
 
 !!! tip "Use Context Manager"
@@ -199,24 +202,16 @@ Execute a command (write operation). Commands modify data and **require a transa
 **Example:**
 
 ```python
-# 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")
+# Schema operations
+db.command("sql", "CREATE DOCUMENT TYPE Person")
+db.command("sql", "CREATE PROPERTY Person.name STRING")
+db.command("sql", "CREATE PROPERTY Person.age INTEGER")
 
 # 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 via API
-    doc.set("age", 31)
-    doc.save()
-
-    # Delete data
-    doc.delete()
+    db.command("sql", "INSERT INTO Person SET name = ?, age = ?", "Alice", 30)
+    db.command("sql", "UPDATE Person SET age = 31 WHERE name = 'Alice'")
+    db.command("sql", "DELETE FROM Person WHERE name = 'Alice'")
 ```
 
 !!! warning "Transaction Required"
@@ -225,14 +220,10 @@ with db.transaction():
     ```python
     # ✅ Correct
     with db.transaction():
-        doc = db.new_document("Person")
-        doc.set("name", "Alice")
-        doc.save()
+        db.command("sql", "INSERT INTO Person SET name = 'Alice'")
 
     # ❌ Will fail
-    doc = db.new_document("Person")
-    doc.set("name", "Alice")
-    # doc.save() outside a transaction will raise
+    db.command("sql", "INSERT INTO Person SET name = 'Alice'")
     ```
 
 ---
@@ -254,9 +245,7 @@ Create a transaction context manager.
 ```python
 with db.transaction():
     for name in ["Alice", "Bob"]:
-        doc = db.new_document("Person")
-        doc.set("name", name)
-        doc.save()
+        db.command("sql", "INSERT INTO Person SET name = ?", name)
     # Automatic commit on success, rollback on exception
 ```
 
@@ -267,9 +256,7 @@ with db.transaction():
 db.begin()
 try:
     for name in ["Alice", "Bob"]:
-        doc = db.new_document("Person")
-        doc.set("name", name)
-        doc.save()
+        db.command("sql", "INSERT INTO Person SET name = ?", name)
     db.commit()
 except Exception as e:
     db.rollback()
@@ -438,9 +425,9 @@ Lookup a record by an indexed key (O(1) index-based lookup).
 **Example:**
 
 ```python
-db.schema.create_vertex_type("User")
-db.schema.create_property("User", "email", "STRING")
-db.schema.create_index("User", ["email"], unique=True)
+db.command("sql", "CREATE VERTEX TYPE User")
+db.command("sql", "CREATE PROPERTY User.email STRING")
+db.command("sql", "CREATE INDEX ON User (email) UNIQUE")
 
 with db.transaction():
     db.new_vertex("User").set("email", "alice@example.com").save()
@@ -607,9 +594,9 @@ Create a vector index for similarity search (JVector implementation). Existing r
 import numpy as np
 
 # Create schema (auto-transactional)
-db.schema.create_vertex_type("Document")
-db.schema.create_property("Document", "embedding", "ARRAY_OF_FLOATS")
-db.schema.create_property("Document", "id", "STRING")
+db.command("sql", "CREATE VERTEX TYPE Document")
+db.command("sql", "CREATE PROPERTY Document.embedding ARRAY_OF_FLOATS")
+db.command("sql", "CREATE PROPERTY Document.id STRING")
 
 # Create vector index
 index = db.create_vector_index("Document", "embedding", dimensions=384)

bindings/python/docs/api/exceptions.md

@@ -376,11 +376,10 @@ def safe_database_operation():
             db = arcadedb.create_database("./mydb")
 
             # Initialize schema
-            # Prefer Schema API for embedded usage (auto-transactional)
-            db.schema.create_document_type("Person")
-            db.schema.create_property("Person", "name", "STRING")
-            db.schema.create_property("Person", "email", "STRING")
-            db.schema.create_index("Person", ["email"], unique=True)
+            db.command("sql", "CREATE DOCUMENT TYPE Person")
+            db.command("sql", "CREATE PROPERTY Person.name STRING")
+            db.command("sql", "CREATE PROPERTY Person.email STRING")
+            db.command("sql", "CREATE INDEX ON Person (email) UNIQUE")
         else:
             db = arcadedb.open_database("./mydb")