Add more functionality to track entity in addition add the select method for the query

Author: IdanHaim

pyravendb/d_commands/database_commands.py

@@ -147,6 +147,7 @@ def put_index(self, index_name, index_def, overwrite=False):
         response = self._requests_handler.http_request_handler(path, "GET")
         if not overwrite and response.status_code != 404:
             raise exceptions.InvalidOperationException("Cannot put index:{0},index already exists".format(index_name))
+
         data = index_def.to_json()
         return self._requests_handler.http_request_handler(path, "PUT", data=data).json()
 
@@ -200,7 +201,7 @@ def update_by_index(self, index_name, query, scripted_patch=None, options=None):
             scripted_patch = scripted_patch.to_json()
 
         response = self._requests_handler.http_request_handler(path, "EVAL", data=scripted_patch)
-        if response.status_code != 200:
+        if response.status_code != 200 and response.status_code != 202:
             raise response.raise_for_status()
         return response.json()
 
@@ -217,7 +218,7 @@ def delete_by_index(self, index_name, query, options=None):
         """
         path = Utils.build_path(index_name, query, options)
         response = self._requests_handler.http_request_handler(path, "DELETE")
-        if response.status_code != 200:
+        if response.status_code != 200 and response.status_code != 202:
             try:
                 raise exceptions.ErrorResponseException(response.json()["Error"][:100])
             except ValueError:
@@ -270,6 +271,9 @@ def query(self, index_name, index_query, includes=None, metadata_only=False, ind
         if index_query.sort_fields:
             for field in index_query.sort_fields:
                 path += "&sort={0}".format(field)
+        if index_query.fetch:
+            for item in index_query.fetch:
+                path += "&fetch={0}".format(item)
         if metadata_only:
             path += "&metadata-only=true"
         if index_entries_only:

pyravendb/data/indexes.py

@@ -40,8 +40,8 @@ def __str__(self):
 class IndexDefinition(object):
     def __init__(self, index_map, name=None, **kwargs):
         """
-        @param index_maps: The map of the index
-        :type str
+        @param index_map: The map of the index
+        :type str or tuple
         @param name: The name of the index
         :type str
         @param kwargs: Can be use to initialize the other option in the index definition
@@ -58,16 +58,14 @@ def __init__(self, index_map, name=None, **kwargs):
         self._is_compiled = False
         self.is_side_by_side_index = kwargs.get("is_side_by_side_index", False)
         self.is_test_index = kwargs.get("is_test_index", False)
-        self.is_map_reduce = kwargs.get("is_map_reduce", False)
         self.lock_mod = kwargs.get("lock_mod", IndexLockMode.Unlock)
         self.max_index_outputs_per_document = kwargs.get("max_index_outputs_per_document", None)
         self.sort_options = kwargs.get("sort_options", {})
         self.spatial_indexes = kwargs.get("spatial_indexes", {})
         self.stores = kwargs.get("stores", {})
         self.suggestions = kwargs.get("suggestions", {})
         self.term_vectors = kwargs.get("term_vectors", {})
-        self.maps = kwargs.get("maps", set())
-        self.map = index_map
+        self.maps = (index_map,) if isinstance(index_map, str) else tuple(set(index_map, ))
 
     @property
     def type(self):
@@ -79,9 +77,15 @@ def type(self):
             return "MapReduce"
         return "Map"
 
+    @property
+    def is_map_reduce(self):
+        return True if self.reduce else False
+
     @property
     def map(self):
-        return list(self.maps)[0]
+        if not isinstance(self.maps, str):
+            return self.maps[0]
+        return self.maps
 
     @map.setter
     def map(self, value):
@@ -96,7 +100,7 @@ def to_json(self):
                 "InternalFieldsMapping": self.internal_fields_mapping, "IsCompiled": self._is_compiled,
                 "IsMapReduce": self.is_map_reduce, "IsSideBySideIndex": self.is_side_by_side_index,
                 "IsTestIndex": self.is_test_index, "LockMode": str(self.lock_mod), "Map": self.map,
-                "Maps": list(self.maps),
+                "Maps": self.maps,
                 "MaxIndexOutputsPerDocument": self.max_index_outputs_per_document, "Name": self.name,
                 "Reduce": self.reduce, "SortOptions": {key: str(self.sort_options[key]) for key in self.sort_options},
                 "SpatialIndexes": self.spatial_indexes,
@@ -115,6 +119,8 @@ def __init__(self, query="", total_size=0, skipped_results=0, default_operator=N
         :type int
         @param default_operator: The operator of the query (AND or OR) the default value is OR
         :type Enum.QueryOperator
+        @param fetch fetch only the terms you want from the index
+        :type list
     """
         self.query = query
         self.total_size = total_size
@@ -124,6 +130,7 @@ def __init__(self, query="", total_size=0, skipped_results=0, default_operator=N
         self.default_operator = default_operator
         self.sort_hints = kwargs.get("sort_hints", {})
         self.sort_fields = kwargs.get("sort_fields", {})
+        self.fetch = kwargs.get("fetch", [])
         self.wait_for_non_stale_results = kwargs.get("wait_for_non_stale_results", False)
 
     @property

pyravendb/store/session_query.py

@@ -14,6 +14,7 @@ def __init__(self, session):
         self.negate = False
         self._sort_hints = set()
         self._sort_fields = set()
+        self.fetch = None
 
     def __call__(self, object_type=None, index_name=None, using_default_operator=None,
                  wait_for_non_stale_results=False, includes=None, with_statistics=False, nested_object_types=None):
@@ -44,6 +45,17 @@ def __call__(self, object_type=None, index_name=None, using_default_operator=Non
         self._with_statistics = with_statistics
         return self
 
+    def select(self, *args):
+        """
+        Fetch only the required fields from the server
+
+        @param args: The name of the terms you like to acquire
+
+        """
+        if args:
+            self.fetch = args
+        return self
+
     def _lucene_builder(self, value, action=None):
         lucene_text = Utils.to_lucene(value, action=action)
 
@@ -287,6 +299,7 @@ def _execute_query(self):
             response = self.session.database_commands. \
                 query(self.index_name, IndexQuery(self.query_builder, default_operator=self.using_default_operator,
                                                   sort_hints=self._sort_hints, sort_fields=self._sort_fields,
+                                                  fetch=self.fetch,
                                                   wait_for_non_stale_results=self.wait_for_non_stale_results),
                       includes=self.includes)
             if response["IsStale"] and self.wait_for_non_stale_results:
@@ -299,12 +312,15 @@ def _execute_query(self):
         results = []
         response_results = response.pop("Results")
         response_includes = response.pop("Includes")
+
         for result in response_results:
             entity, metadata, original_metadata = Utils.convert_to_entity(result, self.object_type, conventions,
-                                                                          self.nested_object_types)
-            self.session.save_entity(key=original_metadata.get("@id", None), entity=entity,
-                                     original_metadata=original_metadata,
-                                     metadata=metadata, document=result)
+                                                                          self.nested_object_types,
+                                                                          fetch=False if not self.fetch else True)
+            if not self.fetch:
+                self.session.save_entity(key=original_metadata.get("@id", None), entity=entity,
+                                         original_metadata=original_metadata,
+                                         metadata=metadata, document=result)
             results.append(entity)
         self.session.save_includes(response_includes)
         if self._with_statistics:

pyravendb/tests/session_tests/query_test.py

@@ -25,8 +25,10 @@ def setUpClass(cls):
         cls.index_map = ("from doc in docs "
                          "select new {"
                          "name = doc.name,"
-                         "key = doc.key}")
-        cls.index_sort = IndexDefinition(index_map=cls.index_map, sort_options={"key": SortOptions.float})
+                         "key = doc.key,"
+                         "doc_id = (doc.name + \" \") + doc.key}")
+        cls.index_sort = IndexDefinition(index_map=cls.index_map, sort_options={"key": SortOptions.float},
+                                         stores={"doc_id": "Yes"})
         cls.db.put_index("Testing_Sort", index_def=cls.index_sort, overwrite=True)
         cls.db.put("products/101", {"name": "test101", "key": 2, "order": "a"},
                    {"Raven-Entity-Name": "Products", "Raven-Python-Type": "query_test.Product"})
@@ -141,3 +143,17 @@ def test_query_with_nested_object(self):
                 session.query(object_type=Company, nested_object_types={"product": Product}).where_equals(
                     "name", "withNesting"))
             self.assertTrue(isinstance(query_results[0], Company) and isinstance(query_results[0].product, Product))
+
+    def test_query_with_fetch_terms(self):
+        with self.document_store.open_session() as session:
+            query_results = list(
+                session.query(index_name="Testing_Sort", wait_for_non_stale_results=True).where_between_or_equal
+                ("key", 2, 4).select("doc_id"))
+
+            found_in_all = True
+            for result in query_results:
+                if not hasattr(result,"doc_id"):
+                    found_in_all = False
+                    break
+
+            self.assertTrue(found_in_all)

pyravendb/tools/utils.py

@@ -89,35 +89,43 @@ def is_inherit(parent, child):
             return Utils.is_inherit(parent, child.__base__)
 
     @staticmethod
-    def convert_to_entity(document, object_type, conventions, nested_object_types=None):
+    def convert_to_entity(document, object_type, conventions, nested_object_types=None, fetch=False):
         metadata = document.pop("@metadata")
         original_metadata = metadata.copy()
         type_from_metadata = conventions.try_get_type_from_metadata(metadata)
         entity = _DynamicStructure(**document)
-        object_from_metadata = None
-        if type_from_metadata is not None:
-            object_from_metadata = Utils.import_class(type_from_metadata)
-
-        if object_from_metadata is None:
-            if object_type is not None:
-                entity.__class__ = object_type
-                metadata["Raven-Python-Type"] = "{0}.{1}".format(object_type.__module__, object_type.__name__)
-        else:
-            if object_type and not Utils.is_inherit(object_type, object_from_metadata):
-                raise exceptions.InvalidOperationException(
-                    "Unable to cast object of type {0} to type {1}".format(object_from_metadata, object_type))
-            entity.__class__ = object_from_metadata
-        # Checking the class for initialize
-        entity_initialize_dict = Utils.make_initialize_dict(document, entity.__class__.__init__)
+        if not fetch:
+            object_from_metadata = None
+            if type_from_metadata is not None:
+                object_from_metadata = Utils.import_class(type_from_metadata)
+
+            if object_from_metadata is None:
+                if object_type is not None:
+                    entity.__class__ = object_type
+                    metadata["Raven-Python-Type"] = "{0}.{1}".format(object_type.__module__, object_type.__name__)
+            else:
+                if object_type and not Utils.is_inherit(object_type, object_from_metadata):
+                    raise exceptions.InvalidOperationException(
+                        "Unable to cast object of type {0} to type {1}".format(object_from_metadata, object_type))
+                entity.__class__ = object_from_metadata
+            # Checking the class for initialize
+            entity_initialize_dict = Utils.make_initialize_dict(document, entity.__class__.__init__)
 
-        entity = entity.__class__(**entity_initialize_dict)
+            entity = entity.__class__(**entity_initialize_dict)
 
         if nested_object_types:
             for key in nested_object_types:
                 attr = getattr(entity, key)
                 if attr:
                     try:
-                        if nested_object_types[key] is datetime:
+                        if isinstance(attr, list):
+                            nested_list = []
+                            for attribute in attr:
+                                nested_list.append(nested_object_types[key](
+                                    **Utils.make_initialize_dict(attribute, nested_object_types[key].__init__)))
+                            setattr(entity, key, nested_list)
+
+                        elif nested_object_types[key] is datetime:
                             setattr(entity, key, Utils.string_to_datetime(attr))
                         elif nested_object_types[key] is timedelta:
                             setattr(entity, key, Utils.string_to_timedelta(attr))

setup.py

@@ -3,7 +3,7 @@
 setup(
     name='pyravendb',
     packages=find_packages(),
-    version='1.2.0',
+    version='1.3.0',
     description='This is the official python client for RavenDB document database',
     author='Idan Haim Shalom',
     author_email='haimdude@gmail.com',