eric/duckdb-ui
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format

Browse Source
This commit is contained in:
Yves
2025-02-19 11:20:42 +01:00
parent 80df1f7ce1
commit 5811f237d8
11 changed files with 636 additions and 569 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
src/include/http_server.hpp
View File

@@ -20,63 +20,69 @@ namespace ui {
class EventDispatcher {
public:
bool WaitEvent(httplib::DataSink *sink);
void SendEvent(const std::string &message);
void Close();
bool WaitEvent(httplib::DataSink *sink);
void SendEvent(const std::string &message);
void Close();
private:
std::mutex mutex_;
std::condition_variable cv_;
std::atomic_int next_id_ {0};
std::atomic_int current_id_ {-1};
std::atomic_int wait_count_ {0};
std::string message_;
std::atomic_bool closed_ {false};
std::mutex mutex_;
std::condition_variable cv_;
std::atomic_int next_id_{0};
std::atomic_int current_id_{-1};
std::atomic_int wait_count_{0};
std::string message_;
std::atomic_bool closed_{false};
};
class HttpServer {
public:
static HttpServer* instance();
static bool Started();
static void StopInstance();
static HttpServer *instance();
static bool Started();
static void StopInstance();
bool Start(const uint16_t localPort, const std::string &remoteUrl,
const shared_ptr<DatabaseInstance> &ddbInstance);
bool Stop();
uint16_t LocalPort();
void SendConnectedEvent(const std::string &token);
void SendCatalogChangedEvent();
bool Start(const uint16_t localPort, const std::string &remoteUrl,
const shared_ptr<DatabaseInstance> &ddbInstance);
bool Stop();
uint16_t LocalPort();
void SendConnectedEvent(const std::string &token);
void SendCatalogChangedEvent();
private:
void SendEvent(const std::string &message);
void Run();
void HandleGetLocalEvents(const httplib::Request &req, httplib::Response &res);
void HandleGetLocalToken(const httplib::Request &req, httplib::Response &res);
void HandleGet(const httplib::Request &req, httplib::Response &res);
void HandleInterrupt(const httplib::Request &req, httplib::Response &res);
void HandleRun(const httplib::Request &req, httplib::Response &res, const httplib::ContentReader &contentReader);
void HandleTokenize(const httplib::Request &req, httplib::Response &res,
const httplib::ContentReader &contentReader);
std::string ReadContent(const httplib::ContentReader &contentReader);
shared_ptr<Connection> FindConnection(const std::string &connectionName);
shared_ptr<Connection> FindOrCreateConnection(const std::string &connectionName);
void SetResponseContent(httplib::Response &res, const MemoryStream &content);
void SetResponseEmptyResult(httplib::Response &res);
void SetResponseErrorResult(httplib::Response &res, const std::string &error);
void SendEvent(const std::string &message);
void Run();
void HandleGetLocalEvents(const httplib::Request &req,
httplib::Response &res);
void HandleGetLocalToken(const httplib::Request &req, httplib::Response &res);
void HandleGet(const httplib::Request &req, httplib::Response &res);
void HandleInterrupt(const httplib::Request &req, httplib::Response &res);
void DoHandleRun(const httplib::Request &req, httplib::Response &res,
const httplib::ContentReader &contentReader);
void HandleRun(const httplib::Request &req, httplib::Response &res,
const httplib::ContentReader &contentReader);
void HandleTokenize(const httplib::Request &req, httplib::Response &res,
const httplib::ContentReader &contentReader);
std::string ReadContent(const httplib::ContentReader &contentReader);
shared_ptr<Connection> FindConnection(const std::string &connectionName);
shared_ptr<Connection>
FindOrCreateConnection(const std::string &connectionName);
void SetResponseContent(httplib::Response &res, const MemoryStream &content);
void SetResponseEmptyResult(httplib::Response &res);
void SetResponseErrorResult(httplib::Response &res, const std::string &error);
uint16_t local_port_;
std::string remote_url_;
shared_ptr<DatabaseInstance> ddb_instance_;
std::string user_agent_;
httplib::Server server_;
unique_ptr<std::thread> thread_;
std::mutex connections_mutex_;
std::unordered_map<std::string, shared_ptr<Connection>> connections_;
unique_ptr<EventDispatcher> event_dispatcher_;
uint16_t local_port_;
std::string remote_url_;
shared_ptr<DatabaseInstance> ddb_instance_;
std::string user_agent_;
httplib::Server server_;
unique_ptr<std::thread> thread_;
std::mutex connections_mutex_;
std::unordered_map<std::string, shared_ptr<Connection>> connections_;
unique_ptr<EventDispatcher> event_dispatcher_;
static unique_ptr<HttpServer> instance_;
};;
static unique_ptr<HttpServer> instance_;
};
;
} // namespace ui
} // namespace duckdb

6
src/include/ui_extension.hpp
View File

@@ -6,9 +6,9 @@ namespace duckdb {
class UiExtension : public Extension {
public:
void Load(DuckDB &db) override;
std::string Name() override;
std::string Version() const override;
void Load(DuckDB &db) override;
std::string Name() override;
std::string Version() const override;
};
} // namespace duckdb

105
src/include/utils/helpers.hpp
View File

@@ -6,82 +6,95 @@
namespace duckdb {
typedef std::string (*simple_tf_t) (ClientContext &);
typedef std::string (*simple_tf_t)(ClientContext &);
struct RunOnceTableFunctionState : GlobalTableFunctionState {
RunOnceTableFunctionState() : run(false) {};
std::atomic<bool> run;
RunOnceTableFunctionState() : run(false){};
std::atomic<bool> run;
static unique_ptr<GlobalTableFunctionState> Init(ClientContext &,
TableFunctionInitInput &) {
return make_uniq<RunOnceTableFunctionState>();
}
static unique_ptr<GlobalTableFunctionState> Init(ClientContext &,
TableFunctionInitInput &) {
return make_uniq<RunOnceTableFunctionState>();
}
};
template <typename T>
T GetSetting(const ClientContext &context, const char *setting_name, const T default_value) {
Value value;
return context.TryGetCurrentSetting(setting_name, value) ? value.GetValue<T>() : default_value;
T GetSetting(const ClientContext &context, const char *setting_name,
const T default_value) {
Value value;
return context.TryGetCurrentSetting(setting_name, value) ? value.GetValue<T>()
: default_value;
}
namespace internal {
unique_ptr<FunctionData> ResultBind(ClientContext &, TableFunctionBindInput &,
vector<LogicalType> &,
vector<std::string> &);
vector<LogicalType> &,
vector<std::string> &);
bool ShouldRun(TableFunctionInput &input);
template <typename Func>
struct CallFunctionHelper;
template <typename Func> struct CallFunctionHelper;
template <>
struct CallFunctionHelper<std::string(*)()> {
static std::string call(ClientContext &context, TableFunctionInput &input, std::string(*f)()) {
return f();
}
template <> struct CallFunctionHelper<std::string (*)()> {
static std::string call(ClientContext &context, TableFunctionInput &input,
std::string (*f)()) {
return f();
}
};
template <> struct CallFunctionHelper<std::string (*)(ClientContext &)> {
static std::string call(ClientContext &context, TableFunctionInput &input,
std::string (*f)(ClientContext &)) {
return f(context);
}
};
template <>
struct CallFunctionHelper<std::string(*)(ClientContext &)> {
static std::string call(ClientContext &context, TableFunctionInput &input, std::string(*f)(ClientContext &)) {
return f(context);
}
};
template <>
struct CallFunctionHelper<std::string(*)(ClientContext &, TableFunctionInput &)> {
static std::string call(ClientContext &context, TableFunctionInput &input, std::string(*f)(ClientContext &, TableFunctionInput &)) {
return f(context, input);
}
struct CallFunctionHelper<std::string (*)(ClientContext &,
TableFunctionInput &)> {
static std::string call(ClientContext &context, TableFunctionInput &input,
std::string (*f)(ClientContext &,
TableFunctionInput &)) {
return f(context, input);
}
};
template <typename Func, Func func>
void TableFunc(ClientContext &context, TableFunctionInput &input, DataChunk &output) {
if (!ShouldRun(input)) {
return;
}
void TableFunc(ClientContext &context, TableFunctionInput &input,
DataChunk &output) {
if (!ShouldRun(input)) {
return;
}
const std::string result = CallFunctionHelper<Func>::call(context, input, func);
output.SetCardinality(1);
output.SetValue(0, 0, result);
const std::string result =
CallFunctionHelper<Func>::call(context, input, func);
output.SetCardinality(1);
output.SetValue(0, 0, result);
}
template <typename Func, Func func>
void RegisterTF(DatabaseInstance &instance, const char* name) {
TableFunction tf(name, {}, internal::TableFunc<Func, func>, internal::ResultBind, RunOnceTableFunctionState::Init);
ExtensionUtil::RegisterFunction(instance, tf);
void RegisterTF(DatabaseInstance &instance, const char *name) {
TableFunction tf(name, {}, internal::TableFunc<Func, func>,
internal::ResultBind, RunOnceTableFunctionState::Init);
ExtensionUtil::RegisterFunction(instance, tf);
}
template <typename Func, Func func>
void RegisterTFWithArgs(DatabaseInstance &instance, const char* name, vector<LogicalType> arguments, table_function_bind_t bind) {
TableFunction tf(name, arguments, internal::TableFunc<Func, func>, bind, RunOnceTableFunctionState::Init);
ExtensionUtil::RegisterFunction(instance, tf);
void RegisterTFWithArgs(DatabaseInstance &instance, const char *name,
vector<LogicalType> arguments,
table_function_bind_t bind) {
TableFunction tf(name, arguments, internal::TableFunc<Func, func>, bind,
RunOnceTableFunctionState::Init);
ExtensionUtil::RegisterFunction(instance, tf);
}
}
} // namespace internal
#define RESISTER_TF(name, func) internal::RegisterTF<decltype(&func), &func>(instance, name)
#define RESISTER_TF(name, func) \
internal::RegisterTF<decltype(&func), &func>(instance, name)
#define RESISTER_TF_ARGS(name, args, func, bind) internal::RegisterTFWithArgs<decltype(&func), &func>(instance, name, args, bind)
#define RESISTER_TF_ARGS(name, args, func, bind) \
internal::RegisterTFWithArgs<decltype(&func), &func>(instance, name, args, \
bind)
} // namespace duckdb

30
src/include/utils/serialization.hpp
View File

@@ -8,41 +8,41 @@ namespace duckdb {
namespace ui {
struct EmptyResult {
void Serialize(duckdb::Serializer &serializer) const;
void Serialize(duckdb::Serializer &serializer) const;
};
struct TokenizeResult {
duckdb::vector<idx_t> offsets;
duckdb::vector<duckdb::SimplifiedTokenType> types;
duckdb::vector<idx_t> offsets;
duckdb::vector<duckdb::SimplifiedTokenType> types;
void Serialize(duckdb::Serializer &serializer) const;
void Serialize(duckdb::Serializer &serializer) const;
};
struct ColumnNamesAndTypes {
duckdb::vector<std::string> names;
duckdb::vector<duckdb::LogicalType> types;
duckdb::vector<std::string> names;
duckdb::vector<duckdb::LogicalType> types;
void Serialize(duckdb::Serializer &serializer) const;
void Serialize(duckdb::Serializer &serializer) const;
};
struct Chunk {
uint16_t row_count;
duckdb::vector<duckdb::Vector> vectors;
uint16_t row_count;
duckdb::vector<duckdb::Vector> vectors;
void Serialize(duckdb::Serializer &serializer) const;
void Serialize(duckdb::Serializer &serializer) const;
};
struct SuccessResult {
ColumnNamesAndTypes column_names_and_types;
duckdb::vector<Chunk> chunks;
ColumnNamesAndTypes column_names_and_types;
duckdb::vector<Chunk> chunks;
void Serialize(duckdb::Serializer &serializer) const;
void Serialize(duckdb::Serializer &serializer) const;
};
struct ErrorResult {
std::string error;
std::string error;
void Serialize(duckdb::Serializer &serializer) const;
void Serialize(duckdb::Serializer &serializer) const;
};
} // namespace ui