Add Query support

README.md

@@ -838,7 +838,7 @@ Adds where condition to DB query with interface args for composite indexes
 ### Query.where\_uuid
 
 ```python
-def where_uuid(index: str, condition: CondType, *keys: str) -> Query
+def where_uuid(index: str, condition: CondType, *uuids: UUID) -> Query
 ```
 
 Adds where condition to DB query with UUID as string args.
@@ -848,7 +848,7 @@ Adds where condition to DB query with UUID as string args.
 #### Arguments:
     index (string): Field name used in condition clause
     condition (:enum:`CondType`): Type of condition
-    keys (*string): Value of index to be compared with. For composite indexes keys must be list,
+    uuids (*:obj:`UUID`): Value of index to be compared with. For composite indexes uuids must be list,
         with value of each sub-index
 
 #### Returns:
@@ -1051,19 +1051,21 @@ Gets fields facet value. Applicable to multiple data fields and the result of th
 
 ```python
 def sort(
-        index: str,
-        desc: bool = False,
-        keys: Union[simple_types, tuple[list[simple_types],
-                                        ...]] = None) -> Query
+    index: str,
+    desc: bool = False,
+    forced_sort_values: Union[simple_types, tuple[list[simple_types],
+                                                  ...]] = None
+) -> Query
 ```
 
-Applies sort order to return from query items. If values argument specified, then items equal to values,
-    if found will be placed in the top positions. Forced sort is support for the first sorting field only
+Applies sort order to return from query items. If forced_sort_values argument specified, then items equal to
+    values, if found will be placed in the top positions. Forced sort is support for the first sorting field
+    only
 
 #### Arguments:
     index (string): The index name
     desc (bool): Sort in descending order
-    keys (union[simple_types, (list[simple_types], ...)]):
+    forced_sort_values (union[simple_types, (list[simple_types], ...)]):
         Value of index to match. For composite indexes keys must be list, with value of each sub-index
 
 #### Returns:

pyreindexer/example/main.py

@@ -57,8 +57,20 @@ def select_item_query_example(db, namespace):
 
     return db.select("SELECT * FROM " + namespace + " WHERE name='" + item_name_for_lookup + "'")
 
+def select_all_item_query_example(db, namespace):
+    return db.select("SELECT * FROM " + namespace)
+
+def print_all_records_from_namespace(db, namespace, message):
+    selected_items_tr = select_all_item_query_example(db, namespace)
+
+    res_count = selected_items_tr.count()
+    print(message, res_count)
+
+    for item in selected_items_tr:
+        print('Item: ', item)
 
 def transaction_example(db, namespace, items_in_base):
+    # start transaction
     transaction = db.new_transaction(namespace)
 
     items_count = len(items_in_base)
@@ -75,18 +87,10 @@ def transaction_example(db, namespace, items_in_base):
     # stop transaction and commit changes to namespace
     transaction.commit()
 
-    # print records from namespace
-    selected_items_tr = select_item_query_example(db, namespace)
-
-    res_count = selected_items_tr.count()
-    print('Transaction results count: ', res_count)
-
-    # disposable QueryResults iterator
-    for item in selected_items_tr:
-        print('Item: ', item)
-
+    print_all_records_from_namespace(db, namespace, 'Transaction results count: ')
 
 def query_example(db, namespace):
+    # query all items
     any_items = (db.new_query(namespace)
                  .where('value', CondType.CondAny)
                  .sort('id')
@@ -95,6 +99,7 @@ def query_example(db, namespace):
     for item in any_items:
         print('Item: ', item)
 
+    # query some items
     selected_items = (db.new_query(namespace)
                       .where('value', CondType.CondEq, 'check')
                       .sort('id')
@@ -104,19 +109,20 @@ def query_example(db, namespace):
     for item in selected_items:
         print('Item: ', item)
 
+    # delete some items
     del_count = (db.new_query(namespace)
                  .where('name', CondType.CondEq, 'item_1')
                  .delete())
     print(f'Deleted count: {del_count}')
 
+    # query all actual items
     any_items = (db.new_query(namespace)
                  .where('value', CondType.CondAny)
                  .must_execute())
     print(f'Query results count (Any after delete): {any_items.count()}')
     for item in any_items:
         print('Item: ', item)
 
-
 def rx_example():
     db = RxConnector('builtin:///tmp/pyrx')
     #    db = RxConnector('cproto://127.0.0.1:6534/pyrx')

pyreindexer/lib/include/pyobjtools.cc

@@ -99,8 +99,8 @@ void PyObjectToJson(PyObject** obj, reindexer::WrSerializer& wrSer) {
 	}
 }
 
-std::vector<std::string> PyObjectToJson(PyObject** obj) {
-	std::vector<std::string> values;
+reindexer::h_vector<std::string, 2> PyObjectToJson(PyObject** obj) {
+	reindexer::h_vector<std::string, 2> values;
 
 	reindexer::WrSerializer wrSer;
 	if (PyDict_Check(*obj)) {
@@ -132,8 +132,8 @@ std::vector<std::string> PyObjectToJson(PyObject** obj) {
 	return values;
 }
 
-std::vector<std::string> ParseStrListToStrVec(PyObject** list) {
-	std::vector<std::string> result;
+reindexer::h_vector<std::string, 2> ParseStrListToStrVec(PyObject** list) {
+	reindexer::h_vector<std::string, 2> result;
 
 	Py_ssize_t sz = PyList_Size(*list);
 	result.reserve(sz);
@@ -191,8 +191,8 @@ reindexer::Variant convert(PyObject** value) {
 	return {};
 }
 
-std::vector<reindexer::Variant> ParseListToVec(PyObject** list) {
-	std::vector<reindexer::Variant> result;
+reindexer::VariantArray ParseListToVec(PyObject** list) {
+	reindexer::VariantArray result;
 
 	Py_ssize_t sz = PyList_Size(*list);
 	result.reserve(sz);

pyreindexer/lib/include/pyobjtools.h

@@ -3,14 +3,15 @@
 #include <Python.h>
 #include <vector>
 #include "core/keyvalue/variant.h"
+#include "estl/h_vector.h"
 
 namespace pyreindexer {
 
-std::vector<std::string> ParseStrListToStrVec(PyObject** list);
-std::vector<reindexer::Variant> ParseListToVec(PyObject** list);
+reindexer::h_vector<std::string, 2> ParseStrListToStrVec(PyObject** list);
+reindexer::VariantArray ParseListToVec(PyObject** list);
 
 void PyObjectToJson(PyObject** obj, reindexer::WrSerializer& wrSer);
-std::vector<std::string> PyObjectToJson(PyObject** obj);
+reindexer::h_vector<std::string, 2> PyObjectToJson(PyObject** obj);
 PyObject* PyObjectFromJson(reindexer::span<char> json);
 
 }  // namespace pyreindexer

pyreindexer/lib/include/query_wrapper.cc

@@ -4,14 +4,15 @@
 
 #include "core/query/query.h"
 #include "core/keyvalue/uuid.h"
+#include "queryresults_wrapper.h"
 
 namespace pyreindexer {
 QueryWrapper::QueryWrapper(DBInterface* db, std::string_view ns) : db_{db} {
 	assert(db_);
 	ser_.PutVString(ns);
 }
 
-void QueryWrapper::Where(std::string_view index, CondType condition, const std::vector<reindexer::Variant>& keys) {
+void QueryWrapper::Where(std::string_view index, CondType condition, const reindexer::VariantArray& keys) {
 	ser_.PutVarUint(QueryItemType::QueryCondition);
 	ser_.PutVString(index);
 	ser_.PutVarUint(nextOperation_);
@@ -22,7 +23,7 @@ void QueryWrapper::Where(std::string_view index, CondType condition, const std::
 	++queriesCount_;
 }
 
-void QueryWrapper::WhereSubQuery(QueryWrapper& query, CondType condition, const std::vector<reindexer::Variant>& keys) {
+void QueryWrapper::WhereSubQuery(QueryWrapper& query, CondType condition, const reindexer::VariantArray& keys) {
 	ser_.PutVarUint(QueryItemType::QuerySubQueryCondition);
 	ser_.PutVarUint(nextOperation_);
 	ser_.PutVString(query.ser_.Slice());
@@ -44,7 +45,8 @@ void QueryWrapper::WhereFieldSubQuery(std::string_view index, CondType condition
 	++queriesCount_;
 }
 
-void QueryWrapper::WhereUUID(std::string_view index, CondType condition, const std::vector<std::string>& keys) {
+void QueryWrapper::WhereUUID(std::string_view index, CondType condition,
+							 const reindexer::h_vector<std::string, 2>& keys) {
 	ser_.PutVarUint(QueryItemType::QueryCondition);
 	ser_.PutVString(index);
 	ser_.PutVarUint(nextOperation_);
@@ -129,7 +131,7 @@ void QueryWrapper::Aggregate(std::string_view index, AggType type) {
 	ser_.PutVString(index);
 }
 
-void QueryWrapper::Aggregation(const std::vector<std::string>& fields) {
+void QueryWrapper::Aggregation(const reindexer::h_vector<std::string, 2>& fields) {
 	ser_.PutVarUint(QueryItemType::QueryAggregation);
 	ser_.PutVarUint(AggType::AggFacet);
 	ser_.PutVarUint(fields.size());
@@ -138,11 +140,11 @@ void QueryWrapper::Aggregation(const std::vector<std::string>& fields) {
 	}
 }
 
-void QueryWrapper::Sort(std::string_view index, bool desc, const std::vector<reindexer::Variant>& keys) {
+void QueryWrapper::Sort(std::string_view index, bool desc, const reindexer::VariantArray& sortValues) {
 	ser_.PutVarUint(QueryItemType::QuerySortIndex);
 	ser_.PutVString(index);
 	ser_.PutVarUint(desc? 1 : 0);
-	putKeys(keys);
+	putKeys(sortValues);
 }
 
 void QueryWrapper::LogOp(OpType op) {
@@ -183,13 +185,14 @@ void serializeJoinQuery(JoinType type, reindexer::WrSerializer& data, reindexer:
 }
 } // namespace
 
-void QueryWrapper::addJoinQueries(const std::vector<QueryWrapper*>& queries, reindexer::WrSerializer& buffer) const {
+void QueryWrapper::addJoinQueries(const reindexer::h_vector<QueryWrapper*, 1>& queries, reindexer::WrSerializer& buffer)
+ const {
 	for (auto query : queries) {
 		serializeJoinQuery(query->joinType_, query->ser_, buffer);
 	}
 }
 
-reindexer::Error QueryWrapper::prepareQuery(reindexer::Query& query) {
+reindexer::Error QueryWrapper::buildQuery(reindexer::Query& query) {
 	reindexer::Error error = errOK;
 	try {
 		// current query (root)
@@ -217,9 +220,9 @@ reindexer::Error QueryWrapper::prepareQuery(reindexer::Query& query) {
 	return error;
 }
 
-reindexer::Error QueryWrapper::ExecuteQuery(ExecuteType type, QueryResultsWrapper& qr) {
+reindexer::Error QueryWrapper::SelectQuery(std::unique_ptr<QueryResultsWrapper>& qr) {
 	reindexer::Query query;
-	auto err = prepareQuery(query);
+	auto err = buildQuery(query);
 	if (!err.ok()) {
 		return err;
 	}
@@ -228,29 +231,30 @@ reindexer::Error QueryWrapper::ExecuteQuery(ExecuteType type, QueryResultsWrappe
 		return reindexer::Error(ErrorCode::errQueryExec, "WAL queries are not supported");
 	}
 
-	switch (type) {
-		case ExecuteType::Select:
-			err = db_->SelectQuery(query, qr);
-			break;
-		case ExecuteType::Update:
-			err = db_->UpdateQuery(query, qr);
-			break;
-		default:
-			assert(false);
+	qr = std::make_unique<QueryResultsWrapper>(db_);
+	return db_->SelectQuery(query, *qr);
+}
+
+reindexer::Error QueryWrapper::UpdateQuery(std::unique_ptr<QueryResultsWrapper>& qr) {
+	reindexer::Query query;
+	auto err = buildQuery(query);
+	if (!err.ok()) {
+		return err;
 	}
-	return err;
+	qr = std::make_unique<QueryResultsWrapper>(db_);
+	return db_->UpdateQuery(query, *qr);
 }
 
 reindexer::Error QueryWrapper::DeleteQuery(size_t& count) {
 	reindexer::Query query;
-	auto err = prepareQuery(query);
+	auto err = buildQuery(query);
 	if (!err.ok()) {
 		return err;
 	}
 	return db_->DeleteQuery(query, count);
 }
 
-void QueryWrapper::Set(std::string_view field, const std::vector<reindexer::Variant>& values,
+void QueryWrapper::Set(std::string_view field, const reindexer::VariantArray& values,
 					   IsExpression isExpression) {
 	ser_.PutVarUint(QueryItemType::QueryUpdateFieldV2);
 	ser_.PutVString(field);
@@ -262,7 +266,7 @@ void QueryWrapper::Set(std::string_view field, const std::vector<reindexer::Vari
 	}
 }
 
-void QueryWrapper::SetObject(std::string_view field, const std::vector<std::string>& values) {
+void QueryWrapper::SetObject(std::string_view field, const reindexer::h_vector<std::string, 2>& values) {
 	ser_.PutVarUint(QueryItemType::QueryUpdateObject);
 	ser_.PutVString(field);
 	ser_.PutVarUint(values.size()); // values count
@@ -315,21 +319,21 @@ reindexer::Error QueryWrapper::On(std::string_view joinField, CondType condition
 	return errOK;
 }
 
-void QueryWrapper::SelectFilter(const std::vector<std::string>& fields) {
+void QueryWrapper::SelectFilter(const reindexer::h_vector<std::string, 2>& fields) {
 	for (const auto& field : fields) {
 		ser_.PutVarUint(QueryItemType::QuerySelectFilter);
 		ser_.PutVString(field);
 	}
 }
 
-void QueryWrapper::AddFunctions(const std::vector<std::string>& functions) {
+void QueryWrapper::AddFunctions(const reindexer::h_vector<std::string, 2>& functions) {
 	for (const auto& function : functions) {
 		ser_.PutVarUint(QueryItemType::QuerySelectFunction);
 		ser_.PutVString(function);
 	}
 }
 
-void QueryWrapper::AddEqualPosition(const std::vector<std::string>& equalPositions) {
+void QueryWrapper::AddEqualPosition(const reindexer::h_vector<std::string, 2>& equalPositions) {
 	ser_.PutVarUint(QueryItemType::QueryEqualPosition);
 	ser_.PutVarUint(openedBrackets_.empty()? 0 : int(openedBrackets_.back() + 1));
 	ser_.PutVarUint(equalPositions.size());
@@ -338,7 +342,7 @@ void QueryWrapper::AddEqualPosition(const std::vector<std::string>& equalPositio
 	}
 }
 
-void QueryWrapper::putKeys(const std::vector<reindexer::Variant>& keys) {
+void QueryWrapper::putKeys(const reindexer::VariantArray& keys) {
 	ser_.PutVarUint(keys.size());
 	for (const auto& key : keys) {
 		ser_.PutVariant(key);