RDBC-780 IndexesFromClientTest::canExplain

Author: poissoncorp

ravendb/documents/commands/explain.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import json
+from typing import Dict, Any, TYPE_CHECKING, Optional, List
+
+import requests
+from ravendb import RavenCommand, IndexQuery, ServerNode
+from ravendb.extensions.json_extensions import JsonExtensions
+
+if TYPE_CHECKING:
+    from ravendb.documents.conventions import DocumentConventions
+
+
+class ExplainQueryResult:
+    def __init__(self, index: str, reason: str):
+        self.index = index
+        self.reason = reason
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> ExplainQueryResult:
+        return cls(json_dict["Index"], json_dict["Reason"])
+
+
+class ExplainQueryCommand(RavenCommand[List[ExplainQueryResult]]):
+    def __init__(self, conventions: DocumentConventions, index_query: IndexQuery):
+        super().__init__(list)
+        if conventions is None:
+            raise ValueError("Conventions cannot be None")
+        if index_query is None:
+            raise ValueError("Index query cannot be None")
+
+        self._conventions = conventions
+        self._index_query = index_query
+
+    def create_request(self, node: ServerNode) -> requests.Request:
+        path = f"{node.url}/databases/{node.database}/queries?debug=explain"
+        return requests.Request(
+            "POST", path, data=JsonExtensions.write_index_query(self._conventions, self._index_query)
+        )
+
+    def set_response(self, response: Optional[str], from_cache: bool) -> None:
+        if response is None:
+            return
+
+        json_node = json.loads(response)
+        results = json_node.get("Results", None)
+        if results is None:
+            self._throw_invalid_response()
+            return
+
+        self.result = [ExplainQueryResult.from_json(res) for res in results]
+
+    def is_read_request(self) -> bool:
+        return True

ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/test_indexes_from_client.py

@@ -1,7 +1,8 @@
 import time
 from typing import Optional
 
-from ravendb import QueryStatistics
+from ravendb import QueryStatistics, IndexQuery
+from ravendb.documents.commands.explain import ExplainQueryCommand
 from ravendb.documents.operations.statistics import GetStatisticsOperation
 from ravendb.documents.indexes.index_creation import IndexCreation
 from ravendb.documents.queries.more_like_this import MoreLikeThisOptions
@@ -218,3 +219,27 @@ def _stats_callback(qs: QueryStatistics) -> None:
             index_names = self.store.maintenance.send(GetIndexNamesOperation(0, 10))
             self.assertEqual(1, len(index_names))
             self.assertIn(index_name, index_names)
+
+    def test_can_explain(self):
+        with self.store.open_session() as session:
+            session.store(User(name="Fitzchak"))
+            session.store(User(name="Arek"))
+            session.save_changes()
+
+        with self.store.open_session() as session:
+
+            def _stats_callback(qs: QueryStatistics) -> None:
+                stats = qs
+
+            users = list(session.query(object_type=User).statistics(_stats_callback).where_equals("name", "Arek"))
+            users = list(session.query(object_type=User).statistics(_stats_callback).where_greater_than("age", 10))
+
+            index_query = IndexQuery("from users")
+            command = ExplainQueryCommand(self.store.conventions, index_query)
+
+            self.store.get_request_executor().execute_command(command)
+
+            explanations = command.result
+            self.assertEqual(1, len(explanations))
+            self.assertIsNotNone(explanations[0].index)
+            self.assertIsNotNone(explanations[0].reason)