Merge pull request #14 from IdanHaim/master

master

Author: IdanHaim

pyravendb/d_commands/database_commands.py

@@ -263,7 +263,7 @@ def query(self, index_name, index_query, includes=None, metadata_only=False, ind
             raise ValueError("None query is invalid")
         if not isinstance(index_query, IndexQuery):
             raise ValueError("query must be IndexQuery type")
-        path = "indexes/{0}?&pageSize={1}".format(Utils.quote_key(index_name), index_query.page_size)
+        path = "indexes/{0}?".format(Utils.quote_key(index_name))
         if index_query.default_operator is QueryOperator.AND:
             path += "&operator={0}".format(index_query.default_operator.value)
         if index_query.query:
@@ -283,6 +283,10 @@ def query(self, index_name, index_query, includes=None, metadata_only=False, ind
             path += "&debug=entries"
         if includes and len(includes) > 0:
             path += "".join("&include=" + item for item in includes)
+        if index_query.start:
+            path += "&start={0}".format(index_query.start)
+
+        path += "&pageSize={0}".format(index_query.page_size)
         response = self._requests_handler.http_request_handler(path, "GET",
                                                                force_read_from_master=force_read_from_master).json()
         if "Error" in response:

pyravendb/data/indexes.py

@@ -109,7 +109,7 @@ def to_json(self):
 
 
 class IndexQuery(object):
-    def __init__(self, query="", total_size=0, skipped_results=0, default_operator=None, **kwargs):
+    def __init__(self, query="", total_size=0, skipped_results=0, default_operator=None, start=None, **kwargs):
         """
         @param query: Actual query that will be performed (Lucene syntax).
         :type str
@@ -125,13 +125,16 @@ def __init__(self, query="", total_size=0, skipped_results=0, default_operator=N
         self.query = query
         self.total_size = total_size
         self.skipped_results = skipped_results
-        self._page_size = 128
         self.__page_size_set = False
+        self._page_size = 128
+        if "page_size" in kwargs:
+            self.page_size = kwargs["page_size"]
         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)
+        self.start = start
 
     @property
     def page_size(self):

pyravendb/store/session_query.py

@@ -23,6 +23,8 @@ def __init__(self, session):
         self._sort_hints = set()
         self._sort_fields = set()
         self.fetch = None
+        self._page_size = None
+        self._start = 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):
@@ -254,6 +256,16 @@ def where_between_or_equal(self, field_name, start, end):
         self.query_builder += "{0}:{1}".format(field_name, lucene_text)
         return self
 
+    def take(self, count):
+        # This method control on the number of the server return results
+        self._page_size = count
+        return self
+
+    def skip(self, count):
+        # This method tell the server to return the results from count and on
+        self._start = count
+        return self
+
     def where_greater_than(self, field_name, value):
         return self.where_between(field_name, value, None)
 
@@ -270,7 +282,9 @@ def where_not_none(self, field_name):
         if len(self.query_builder) > 0:
             self.query_builder += ' '
         self.query_builder += '('
-        self.where_equals(field_name, '*', escape_query_options=EscapeQueryOptions.RawQuery).and_also().add_not().where_equals(field_name, None)
+        self.where_equals(field_name, '*',
+                          escape_query_options=EscapeQueryOptions.RawQuery).and_also().add_not().where_equals(
+            field_name, None)
         self.query_builder += ')'
         return self
 
@@ -323,12 +337,14 @@ def _execute_query(self):
         conventions = self.session.conventions
         end_time = time.time() + conventions.timeout
         while True:
-            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)
+            index_query = 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,
+                                     start=self._start)
+            if self._page_size is not None:
+                index_query.page_size = self._page_size
+            response = self.session.database_commands.query(self.index_name, index_query, includes=self.includes)
             if response["IsStale"] and self.wait_for_non_stale_results:
                 if time.time() > end_time:
                     raise ErrorResponseException("The index is still stale after reached the timeout")

pyravendb/tests/database_commands_tests/test_query.py

@@ -8,6 +8,8 @@ class TestQuery(TestBase):
     def setUpClass(cls):
         super(TestQuery, cls).setUpClass()
         cls.db.put("products/10", {"Name": "test"}, {"Raven-Entity-Name": "Products", "Raven-Python-Type": "object"})
+        cls.db.put("products/11", {"Name": "test2"}, {"Raven-Entity-Name": "Products", "Raven-Python-Type": "object"})
+        cls.db.put("products/12", {"Name": "test3"}, {"Raven-Entity-Name": "Products", "Raven-Python-Type": "object"})
 
     def test_only_query(self):
         self.db.put_index("Testing", self.index, True)
@@ -31,3 +33,8 @@ def test_fail(self):
     def test_fail_none_response(self):
         with self.assertRaises(exceptions.ErrorResponseException):
             self.db.query("IndexIsNotExists", IndexQuery("Tag:Products"))
+
+    def test_only_query_change_page_size_and_add_start(self):
+        self.db.put_index("Testing", self.index, True)
+        response = self.db.query("Testing", IndexQuery("Tag:Products", page_size=1, start=1))
+        self.assertEqual(response["Results"][0]["Name"], "test2")

pyravendb/tests/session_tests/test_query.py

@@ -188,6 +188,10 @@ def test_query_with_fetch_terms(self):
 
             self.assertTrue(found_in_all)
 
+    def test_where_starts_with_skip_take(self):
+        with self.document_store.open_session() as session:
+            query_result = list(session.query().where_starts_with("name", "test").take(4).skip("2"))
+            self.assertEqual(len(query_result), 4)
 
 if __name__ == "__main__":
     unittest.main()