Reindexer context support

pyreindexer/example/main.py

@@ -1,3 +1,5 @@
+from datetime import timedelta
+
 from pyreindexer import RxConnector
 from pyreindexer.exceptions import ApiError
 from pyreindexer.query import CondType
@@ -22,7 +24,7 @@ def create_index_example(db, namespace):
     try:
         db.index_add(namespace, index_definition)
     except ApiError:
-        db.index_drop(namespace, 'id')
+        db.index_drop(namespace, 'id', timedelta(milliseconds = 1000))
         db.index_add(namespace, index_definition)
 
 
@@ -55,10 +57,10 @@ def create_items_example(db, namespace):
 def select_item_query_example(db, namespace):
     item_name_for_lookup = 'item_0'
 
-    return db.select("SELECT * FROM " + namespace + " WHERE name='" + item_name_for_lookup + "'")
+    return (db.select("SELECT * FROM " + namespace + " WHERE name='" + item_name_for_lookup + "'", timedelta(milliseconds = 1000)))
 
 def select_all_item_query_example(db, namespace):
-    return db.select("SELECT * FROM " + namespace)
+    return db.select("SELECT * FROM " + namespace, timedelta(milliseconds = 1000))
 
 def print_all_records_from_namespace(db, namespace, message):
     selected_items_tr = select_all_item_query_example(db, namespace)
@@ -85,7 +87,7 @@ def transaction_example(db, namespace, items_in_base):
     transaction.update(item)
 
     # stop transaction and commit changes to namespace
-    transaction.commit()
+    transaction.commit(timedelta(milliseconds = 1000))
 
     print_all_records_from_namespace(db, namespace, 'Transaction results count: ')
 
@@ -104,15 +106,15 @@ def query_example(db, namespace):
                       .where('value', CondType.CondEq, 'check')
                       .sort('id')
                       .limit(4)
-                      .execute())
+                      .execute(timedelta(milliseconds = 1000)))
     print(f'Query results count (limited): {selected_items.count()}')
     for item in selected_items:
         print('Item: ', item)
 
     # delete some items
     del_count = (db.new_query(namespace)
                  .where('name', CondType.CondEq, 'item_1')
-                 .delete())
+                 .delete(timedelta(milliseconds = 1000)))
     print(f'Deleted count: {del_count}')
 
     # query all actual items

pyreindexer/lib/include/pyobjtools.cc

@@ -189,38 +189,38 @@ PyObject* pyValueFromJsonValue(const gason::JsonValue& value) {
 	PyObject* pyValue = nullptr;
 
 	switch (value.getTag()) {
-		case gason::JSON_NUMBER:
+		case gason::JsonTag::JSON_NUMBER:
 			pyValue = PyLong_FromLongLong(value.toNumber()); // new ref
 			break;
-		case gason::JSON_DOUBLE:
+		case gason::JsonTag::JSON_DOUBLE:
 			pyValue = PyFloat_FromDouble(value.toDouble()); // new ref
 			break;
-		case gason::JSON_STRING: {
+		case gason::JsonTag::JSON_STRING: {
 			auto sv = value.toString();
 			pyValue = PyUnicode_FromStringAndSize(sv.data(), sv.size()); // new ref
 			break;
 		}
-		case gason::JSON_NULL:
+		case gason::JsonTag::JSON_NULL:
 			pyValue = Py_None;
 			Py_INCREF(pyValue); // new ref
 			break;
-		case gason::JSON_TRUE:
+		case gason::JsonTag::JSON_TRUE:
 			pyValue = Py_True;
 			Py_INCREF(pyValue); // new ref
 			break;
-		case gason::JSON_FALSE:
+		case gason::JsonTag::JSON_FALSE:
 			pyValue = Py_False;
 			Py_INCREF(pyValue); // new ref
 			break;
-		case gason::JSON_ARRAY:
+		case gason::JsonTag::JSON_ARRAY:
 			pyValue = PyList_New(0); // new ref
 			for (const auto& v : value) {
 				PyObject* dictFromJson = pyValueFromJsonValue(v.value); // stolen ref
 				PyList_Append(pyValue, dictFromJson); // new ref
 				Py_XDECREF(dictFromJson);
 			}
 			break;
-		case gason::JSON_OBJECT:
+		case gason::JsonTag::JSON_OBJECT:
 			pyValue = PyDict_New(); // new ref
 			for (const auto& v : value) {
 				PyObject* dictFromJson = pyValueFromJsonValue(v.value); // stolen ref
@@ -230,7 +230,7 @@ PyObject* pyValueFromJsonValue(const gason::JsonValue& value) {
 				Py_XDECREF(dictFromJson);
 			}
 			break;
-		case gason::JSON_EMPTY:
+		case gason::JsonTag::JSON_EMPTY:
 			throw gason::Exception("Unexpected `JSON_EMPTY` tag");
 			break;
 	}

pyreindexer/lib/include/query_wrapper.cc

@@ -220,7 +220,8 @@ reindexer::Error QueryWrapper::buildQuery(reindexer::Query& query) {
 	return error;
 }
 
-reindexer::Error QueryWrapper::SelectQuery(std::unique_ptr<QueryResultsWrapper>& qr) {
+reindexer::Error QueryWrapper::SelectQuery(std::unique_ptr<QueryResultsWrapper>& qr,
+										   std::chrono::milliseconds timeout) {
 	reindexer::Query query;
 	auto err = buildQuery(query);
 	if (!err.ok()) {
@@ -232,26 +233,27 @@ reindexer::Error QueryWrapper::SelectQuery(std::unique_ptr<QueryResultsWrapper>&
 	}
 
 	qr = std::make_unique<QueryResultsWrapper>(db_);
-	return db_->SelectQuery(query, *qr);
+	return db_->SelectQuery(query, *qr, timeout);
 }
 
-reindexer::Error QueryWrapper::UpdateQuery(std::unique_ptr<QueryResultsWrapper>& qr) {
+reindexer::Error QueryWrapper::UpdateQuery(std::unique_ptr<QueryResultsWrapper>& qr,
+										   std::chrono::milliseconds timeout) {
 	reindexer::Query query;
 	auto err = buildQuery(query);
 	if (!err.ok()) {
 		return err;
 	}
 	qr = std::make_unique<QueryResultsWrapper>(db_);
-	return db_->UpdateQuery(query, *qr);
+	return db_->UpdateQuery(query, *qr, timeout);
 }
 
-reindexer::Error QueryWrapper::DeleteQuery(size_t& count) {
+reindexer::Error QueryWrapper::DeleteQuery(size_t& count, std::chrono::milliseconds timeout) {
 	reindexer::Query query;
 	auto err = buildQuery(query);
 	if (!err.ok()) {
 		return err;
 	}
-	return db_->DeleteQuery(query, count);
+	return db_->DeleteQuery(query, count, timeout);
 }
 
 void QueryWrapper::Set(std::string_view field, const reindexer::VariantArray& values,

pyreindexer/lib/include/query_wrapper.h

@@ -54,9 +54,9 @@ class QueryWrapper {
 
 	void Modifier(QueryItemType type);
 
-	reindexer::Error SelectQuery(std::unique_ptr<QueryResultsWrapper>& qr);
-	reindexer::Error UpdateQuery(std::unique_ptr<QueryResultsWrapper>& qr);
-	reindexer::Error DeleteQuery(size_t& count);
+	reindexer::Error SelectQuery(std::unique_ptr<QueryResultsWrapper>& qr, std::chrono::milliseconds timeout);
+	reindexer::Error UpdateQuery(std::unique_ptr<QueryResultsWrapper>& qr, std::chrono::milliseconds timeout);
+	reindexer::Error DeleteQuery(size_t& count, std::chrono::milliseconds timeout);
 
 	enum class IsExpression { Yes, No };
 	void Set(std::string_view field, const reindexer::VariantArray& values, IsExpression isExpression);

pyreindexer/lib/include/queryresults_wrapper.h

@@ -30,8 +30,8 @@ class QueryResultsWrapper {
 		it_ = qres_->begin();
 	}
 
-	Error Select(const std::string& query) {
-		return db_->Select(query, *this);
+	Error Select(std::string_view query, std::chrono::milliseconds timeout) {
+		return db_->Select(query, *this, timeout);
 	}
 
 	Error Status() {

pyreindexer/lib/include/transaction_wrapper.h

@@ -33,8 +33,8 @@ class TransactionWrapper {
 		transaction_ = std::move(transaction);
 	}
 
-	Error Start(std::string_view ns) {
-		return db_->StartTransaction(ns, *this);
+	Error Start(std::string_view ns, std::chrono::milliseconds timeout) {
+		return db_->StartTransaction(ns, *this, timeout);
 	}
 
 	ItemT NewItem() {
@@ -47,14 +47,14 @@ class TransactionWrapper {
 		return db_->Modify(*transaction_, std::move(item), mode);
 	}
 
-	Error Commit(size_t& count) {
+	Error Commit(size_t& count, std::chrono::milliseconds timeout) {
 		assert(transaction_.has_value());
-		return db_->CommitTransaction(*transaction_, count);
+		return db_->CommitTransaction(*transaction_, count, timeout);
 	}
 
-	Error Rollback() {
+	Error Rollback(std::chrono::milliseconds timeout) {
 		assert(transaction_.has_value());
-		return db_->RollbackTransaction(*transaction_);
+		return db_->RollbackTransaction(*transaction_, timeout);
 	}
 
 private: