Merge branch 'benchmark' into HEAD

Author: rafalh

include/graphqlservice/GraphQLService.h

@@ -1109,13 +1109,45 @@ struct ModifiedResult
 		co_await params.launch;
 
 		auto awaitedResult = co_await std::move(result);
+		using vector_type = std::decay_t<decltype(awaitedResult)>;
+
+		// Shortcut for std::vector of non-awaitable scalars. No need to go async. Results are ready.
+		if constexpr (std::is_floating_point_v<typename vector_type::value_type>
+			|| std::is_integral_v<typename vector_type::value_type >//also for bool
+			|| std::is_same<std::string, typename vector_type::value_type>::value
+			|| std::is_same<response::IdType, typename vector_type::value_type>::value)
+		{
+			ResolverResult document;
+			document.data.push_back(response::ValueToken::StartArray {});
+			document.data.push_back(response::ValueToken::Reserve { awaitedResult.size() });
+			if constexpr (std::is_same<bool, typename vector_type::value_type>::value)
+			{
+				for (auto r : awaitedResult)
+					document.data.append(response::ValueToken::BoolValue { std::move(r) });
+			}
+			else
+			{
+				for (auto& r : awaitedResult)
+				{
+					if constexpr (std::is_integral_v<typename vector_type::value_type>)
+						document.data.append(response::ValueToken::IntValue { std::move(r) });
+					else if constexpr (std::is_floating_point_v<typename vector_type::value_type>)
+						document.data.append(response::ValueToken::FloatValue { std::move(r) });
+					else if constexpr (std::is_same<response::IdType,
+										   typename vector_type::value_type>::value)
+						document.data.append(response::ValueToken::IdValue { std::move(r) });
+					else document.data.append(response::ValueToken::StringValue { std::move(r) });
+				}
+			}
+			document.data.push_back(response::ValueToken::EndArray {});
+			co_return document;
+		}
 
 		children.reserve(awaitedResult.size());
 		params.errorPath = std::make_optional(
 			field_path { parentPath ? std::make_optional(std::cref(*parentPath)) : std::nullopt,
 				path_segment { std::size_t { 0 } } });
 
-		using vector_type = std::decay_t<decltype(awaitedResult)>;
 
 		if constexpr (!std::is_same_v<std::decay_t<typename vector_type::reference>,
 						  typename vector_type::value_type>)

include/graphqlservice/JSONResponse.h

@@ -7,12 +7,14 @@
 #define JSONRESPONSE_H
 
 #include "GraphQLResponse.h"
+#include "GraphQLService.h"
 
 #include "internal/DllExports.h"
 
 namespace graphql::response {
 
 [[nodiscard("unnecessary conversion")]] JSONRESPONSE_EXPORT std::string toJSON(Value&& response);
+[[nodiscard("unnecessary conversion")]] JSONRESPONSE_EXPORT std::string toJSON(service::ResolverResult&& response);
 
 [[nodiscard("unnecessary conversion")]] JSONRESPONSE_EXPORT Value parseJSON(
 	const std::string& json);

samples/CMakeLists.txt

@@ -14,6 +14,7 @@ if(GRAPHQL_BUILD_MODULES)
   add_subdirectory(stitched)
 endif()
 
+
 add_subdirectory(validation)
 
 if(GRAPHQL_BUILD_HTTP_SAMPLE)

samples/proxy/schema/schema.graphql

@@ -11,6 +11,8 @@ enum OperationType {
   SUBSCRIPTION
 }
 
+
+
 input QueryInput {
   type: OperationType!
   query: String!

samples/today/TodayMock.cpp

@@ -229,6 +229,17 @@ std::optional<std::vector<std::shared_ptr<object::AppointmentEdge>>> Appointment
 	return result;
 }
 
+std::vector<double> AppointmentConnection::getBigArray() const noexcept
+{
+	std::vector<double> ret(1000);
+	int i = 0;
+	for (auto& r : ret)
+	{
+		r = i++;
+	}
+	return ret;
+}
+
 Task::Task(response::IdType&& id, std::string&& title, bool isComplete)
 	: _id(std::move(id))
 	, _title(std::make_shared<response::Value>(std::move(title)))

samples/today/TodayMock.h

@@ -174,6 +174,7 @@ class AppointmentConnection
 
 	std::shared_ptr<object::PageInfo> getPageInfo() const noexcept;
 	std::optional<std::vector<std::shared_ptr<object::AppointmentEdge>>> getEdges() const noexcept;
+	std::vector<double> getBigArray() const noexcept;
 
 private:
 	std::shared_ptr<PageInfo> _pageInfo;

samples/today/benchmark.cpp

@@ -106,6 +106,7 @@ int main(int argc, char** argv)
 							isNow
 						}
 					}
+					bigArray
 				}
 			})gql"sv);
 			const auto startValidate = std::chrono::steady_clock::now();
@@ -117,14 +118,60 @@ int main(int argc, char** argv)
 			}
 
 			const auto startResolve = std::chrono::steady_clock::now();
-			auto response = service->resolve({ query }).get();
-			const auto startToJson = std::chrono::steady_clock::now();
 
-			if (response::toJSON(std::move(response)).empty())
+			decltype(std::chrono::steady_clock::now()) startToJson;
+
+
+
+			/*
+			Z tego zrobić test
+			std::string a = response::toJSON(service->visit({ query }).get());
+			std::string b = response::toJSON(service->resolve({ query }).get());
+
+			std::cout << "Visit: " << a << std::endl;
+			std::cout << "Resolve: " << b << std::endl;
+
+			if (a.compare(b) != 0)
 			{
-				std::cerr << "Failed to convert to JSON!" << std::endl;
-				break;
+				std::cout << "Visit"
+						  << " is not "
+						  << "Resolve" << std::endl;
 			}
+			else
+			{			
+				std::cout << "Visit is equal Resolve" << std::endl;
+			}*/
+
+
+
+			if (0)
+			{
+				auto resolverResult = service->visit({ query }).get();
+				startToJson = std::chrono::steady_clock::now();
+
+				if (response::toJSON(std::move(resolverResult)).empty())
+				{
+					std::cerr << "Failed to convert to JSON!" << std::endl;
+					break;
+				}
+			}
+			else
+			{
+				auto response = service->resolve({ query }).get();
+				startToJson = std::chrono::steady_clock::now();
+
+				if (response::toJSON(std::move(response)).empty())
+				{
+					std::cerr << "Failed to convert to JSON!" << std::endl;
+					break;
+				}
+			}
+
+
+
+
+
+
 
 			const auto endToJson = std::chrono::steady_clock::now();
 

samples/today/schema.today.graphql

@@ -40,6 +40,8 @@ type Query {
 
     "Test C++ keyword names"
     default: String
+
+    
 }
 
 "Node interface for Relay support"
@@ -60,6 +62,7 @@ type AppointmentEdge {
 type AppointmentConnection {
     pageInfo: PageInfo!
     edges: [AppointmentEdge]
+	bigArray: [Float!]!
 }
 
 type TaskEdge {

src/CMakeLists.txt

@@ -404,7 +404,7 @@ endif()
 if(BUILD_GRAPHQLJSON)
   add_library(cppgraphqlgen::graphqljson ALIAS graphqljson)
   target_compile_features(graphqljson PUBLIC cxx_std_20)
-  target_link_libraries(graphqljson PUBLIC graphqlresponse)
+  target_link_libraries(graphqljson PUBLIC graphqlresponse graphqlservice)
   target_sources(graphqljson PUBLIC FILE_SET HEADERS
     BASE_DIRS ${INCLUDE_ROOT}
     FILES ${INCLUDE_ROOT}/graphqlservice/JSONResponse.h)

src/RapidJSONResponse.cpp

@@ -103,6 +103,16 @@ class StreamWriter : public std::enable_shared_from_this<StreamWriter>
 	rapidjson::Writer<rapidjson::StringBuffer> _writer;
 };
 
+std::string toJSON(service::ResolverResult&& response)
+{
+	rapidjson::StringBuffer buffer;
+	auto writer = std::make_shared<ValueVisitor>(std::make_shared<StreamWriter>(buffer));
+
+	std::move(response).visit().visit(writer);
+
+	return stream.str();
+}
+
 std::string toJSON(Value&& response)
 {
 	rapidjson::StringBuffer buffer;

src/SchemaLoader.cpp

@@ -655,6 +655,10 @@ void SchemaLoader::visitObjectTypeExtension(const peg::ast_node& objectTypeExten
 			}
 		}
 	}
+	else
+	{
+		visitObjectTypeDefinition(objectTypeExtension);
+	}
 }
 
 void SchemaLoader::visitInterfaceTypeDefinition(const peg::ast_node& interfaceTypeDefinition)

src/TaoCppJSONResponse.cpp

@@ -137,6 +137,19 @@ class StreamWriter : public std::enable_shared_from_this<StreamWriter>
 	std::vector<Scope> _scopeStack;
 };
 
+
+
+
+std::string toJSON(service::ResolverResult&& response)
+{
+	std::ostringstream stream;
+	auto writer = std::make_shared<ValueVisitor>(std::make_shared<StreamWriter>(stream));
+
+	std::move(response).visit().visit(writer);
+
+	return stream.str();
+}
+
 std::string toJSON(Value&& response)
 {
 	std::ostringstream stream;