connection.h

Go to the documentation of this file.

#pragma once
 
#include "client_context.h"
#include "database.h"
#include "udf_function.h"
 
namespace kuzu {
namespace main {
 
class Connection {
 friend class kuzu::testing::BaseGraphTest;
 friend class kuzu::testing::PrivateGraphTest;
 friend class kuzu::testing::TestHelper;
 friend class kuzu::testing::TestRunner;
 friend class kuzu::benchmark::Benchmark;
 friend class kuzu::testing::TinySnbDDLTest;
 friend class ConnectionExecuteAsyncWorker;
 friend class ConnectionQueryAsyncWorker;
 
public:
 KUZU_API explicit Connection(Database* database);
 KUZU_API ~Connection();
 KUZU_API void setMaxNumThreadForExec(uint64_t numThreads);
 KUZU_API uint64_t getMaxNumThreadForExec();
 
 KUZU_API std::unique_ptr<QueryResult> query(std::string_view query);
 
 KUZU_API std::unique_ptr<PreparedStatement> prepare(std::string_view query);
 template<typename... Args>
 inline std::unique_ptr<QueryResult> execute(PreparedStatement* preparedStatement,
 std::pair<std::string, Args>... args) {
 std::unordered_map<std::string, std::unique_ptr<common::Value>> inputParameters;
 return executeWithParams(preparedStatement, std::move(inputParameters), args...);
 }
 KUZU_API std::unique_ptr<QueryResult> executeWithParams(PreparedStatement* preparedStatement,
 std::unordered_map<std::string, std::unique_ptr<common::Value>> inputParams);
 KUZU_API void interrupt();
 
 KUZU_API void setQueryTimeOut(uint64_t timeoutInMS);
 
 // Note: this function throws exception if creating scalar function fails.
 template<typename TR, typename... Args>
 void createScalarFunction(std::string name, TR (*udfFunc)(Args...)) {
 addScalarFunction(name, function::UDF::getFunction<TR, Args...>(name, udfFunc));
 }
 
 // Note: this function throws exception if creating scalar function fails.
 template<typename TR, typename... Args>
 void createScalarFunction(std::string name, std::vector<common::LogicalTypeID> parameterTypes,
 common::LogicalTypeID returnType, TR (*udfFunc)(Args...)) {
 addScalarFunction(name, function::UDF::getFunction<TR, Args...>(name, udfFunc,
 std::move(parameterTypes), returnType));
 }
 
 void addUDFFunctionSet(std::string name, function::function_set func) {
 addScalarFunction(name, std::move(func));
 }
 
 void removeUDFFunction(std::string name) { removeScalarFunction(name); }
 
 template<typename TR, typename... Args>
 void createVectorizedFunction(std::string name, function::scalar_func_exec_t scalarFunc) {
 addScalarFunction(name,
 function::UDF::getVectorizedFunction<TR, Args...>(name, std::move(scalarFunc)));
 }
 
 void createVectorizedFunction(std::string name,
 std::vector<common::LogicalTypeID> parameterTypes, common::LogicalTypeID returnType,
 function::scalar_func_exec_t scalarFunc) {
 addScalarFunction(name, function::UDF::getVectorizedFunction(name, std::move(scalarFunc),
 std::move(parameterTypes), returnType));
 }
 
 ClientContext* getClientContext() { return clientContext.get(); };
 
private:
 std::unique_ptr<QueryResult> query(std::string_view query, std::string_view encodedJoin,
 bool enumerateAllPlans = true);
 
 std::unique_ptr<QueryResult> queryResultWithError(std::string_view errMsg);
 
 std::unique_ptr<PreparedStatement> preparedStatementWithError(std::string_view errMsg);
 
 std::unique_ptr<PreparedStatement> prepareNoLock(
 std::shared_ptr<parser::Statement> parsedStatement, bool enumerateAllPlans = false,
 std::string_view joinOrder = std::string_view());
 
 template<typename T, typename... Args>
 std::unique_ptr<QueryResult> executeWithParams(PreparedStatement* preparedStatement,
 std::unordered_map<std::string, std::unique_ptr<common::Value>> params,
 std::pair<std::string, T> arg, std::pair<std::string, Args>... args) {
 return clientContext->executeWithParams(preparedStatement, std::move(params), arg, args...);
 }
 
 void bindParametersNoLock(PreparedStatement* preparedStatement,
 const std::unordered_map<std::string, std::unique_ptr<common::Value>>& inputParams);
 
 std::unique_ptr<QueryResult> executeAndAutoCommitIfNecessaryNoLock(
 PreparedStatement* preparedStatement, uint32_t planIdx = 0u);
 
 KUZU_API void addScalarFunction(std::string name, function::function_set definitions);
 KUZU_API void removeScalarFunction(std::string name);
 
 std::unique_ptr<QueryResult> queryWithID(std::string_view query, uint64_t queryID);
 
 std::unique_ptr<QueryResult> executeWithParamsWithID(PreparedStatement* preparedStatement,
 std::unordered_map<std::string, std::unique_ptr<common::Value>> inputParams,
 uint64_t queryID);
 
private:
 Database* database;
 std::unique_ptr<ClientContext> clientContext;
};
 
} // namespace main
} // namespace kuzu