#ifndef SRC_NODE_SQLITE_H_

#define SRC_NODE_SQLITE_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "base_object.h"

#include "lru_cache-inl.h"

#include "node_mem.h"

#include "sqlite3.h"

#include "util.h"

#include <list>

#include <map>

#include <unordered_set>

namespace node {

namespace sqlite {

class DatabaseOpenConfiguration {

public:

explicit DatabaseOpenConfiguration(std::string&& location)

: location_(std::move(location)) {}

inline const std::string& location() const { return location_; }

inline bool get_read_only() const { return read_only_; }

inline void set_read_only(bool flag) { read_only_ = flag; }

inline bool get_enable_foreign_keys() const { return enable_foreign_keys_; }

inline void set_enable_foreign_keys(bool flag) {

enable_foreign_keys_ = flag;

}

inline bool get_enable_dqs() const { return enable_dqs_; }

inline void set_enable_dqs(bool flag) { enable_dqs_ = flag; }

inline void set_timeout(int timeout) { timeout_ = timeout; }

inline int get_timeout() { return timeout_; }

inline void set_use_big_ints(bool flag) { use_big_ints_ = flag; }

inline bool get_use_big_ints() const { return use_big_ints_; }

inline void set_return_arrays(bool flag) { return_arrays_ = flag; }

inline bool get_return_arrays() const { return return_arrays_; }

inline void set_allow_bare_named_params(bool flag) {

allow_bare_named_params_ = flag;

}

inline bool get_allow_bare_named_params() const {

return allow_bare_named_params_;

}

inline void set_allow_unknown_named_params(bool flag) {

allow_unknown_named_params_ = flag;

}

inline bool get_allow_unknown_named_params() const {

return allow_unknown_named_params_;

}

inline void set_enable_defensive(bool flag) { defensive_ = flag; }

inline bool get_enable_defensive() const { return defensive_; }

private:

std::string location_;

bool read_only_ = false;

bool enable_foreign_keys_ = true;

bool enable_dqs_ = false;

int timeout_ = 0;

bool use_big_ints_ = false;

bool return_arrays_ = false;

bool allow_bare_named_params_ = true;

bool allow_unknown_named_params_ = false;

bool defensive_ = true;

};

class DatabaseSync;

class StatementSyncIterator;

class StatementSync;

class BackupJob;

class StatementExecutionHelper {

public:

static v8::MaybeLocal<v8::Value> All(Environment* env,

DatabaseSync* db,

sqlite3_stmt* stmt,

bool return_arrays,

bool use_big_ints);

static v8::MaybeLocal<v8::Object> Run(Environment* env,

DatabaseSync* db,

sqlite3_stmt* stmt,

bool use_big_ints);

static BaseObjectPtr<StatementSyncIterator> Iterate(

Environment* env, BaseObjectPtr<StatementSync> stmt);

static v8::MaybeLocal<v8::Value> ColumnToValue(Environment* env,

sqlite3_stmt* stmt,

const int column,

bool use_big_ints);

static v8::MaybeLocal<v8::Name> ColumnNameToName(Environment* env,

sqlite3_stmt* stmt,

const int column);

static v8::MaybeLocal<v8::Value> Get(Environment* env,

DatabaseSync* db,

sqlite3_stmt* stmt,

bool return_arrays,

bool use_big_ints);

};

class DatabaseSync : public BaseObject {

public:

enum InternalFields {

kAuthorizerCallback = BaseObject::kInternalFieldCount,

kInternalFieldCount

};

DatabaseSync(Environment* env,

v8::Local<v8::Object> object,

DatabaseOpenConfiguration&& open_config,

bool open,

bool allow_load_extension);

void MemoryInfo(MemoryTracker* tracker) const override;

static void New(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);

static void IsOpenGetter(const v8::FunctionCallbackInfo<v8::Value>& args);

static void IsTransactionGetter(

const v8::FunctionCallbackInfo<v8::Value>& args);

static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Dispose(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Prepare(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Exec(const v8::FunctionCallbackInfo<v8::Value>& args);

static void CreateTagStore(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Location(const v8::FunctionCallbackInfo<v8::Value>& args);

static void CustomFunction(const v8::FunctionCallbackInfo<v8::Value>& args);

static void AggregateFunction(

const v8::FunctionCallbackInfo<v8::Value>& args);

static void CreateSession(const v8::FunctionCallbackInfo<v8::Value>& args);

static void ApplyChangeset(const v8::FunctionCallbackInfo<v8::Value>& args);

static void EnableLoadExtension(

const v8::FunctionCallbackInfo<v8::Value>& args);

static void EnableDefensive(const v8::FunctionCallbackInfo<v8::Value>& args);

static void LoadExtension(const v8::FunctionCallbackInfo<v8::Value>& args);

static void SetAuthorizer(const v8::FunctionCallbackInfo<v8::Value>& args);

static int AuthorizerCallback(void* user_data,

int action_code,

const char* param1,

const char* param2,

const char* param3,

const char* param4);

void FinalizeStatements();

void RemoveBackup(BackupJob* backup);

void AddBackup(BackupJob* backup);

void FinalizeBackups();

void UntrackStatement(StatementSync* statement);

bool IsOpen();

bool use_big_ints() const { return open_config_.get_use_big_ints(); }

bool return_arrays() const { return open_config_.get_return_arrays(); }

bool allow_bare_named_params() const {

return open_config_.get_allow_bare_named_params();

}

bool allow_unknown_named_params() const {

return open_config_.get_allow_unknown_named_params();

}

sqlite3* Connection();

// In some situations, such as when using custom functions, it is possible

// that SQLite reports an error while JavaScript already has a pending

// exception. In this case, the SQLite error should be ignored. These methods

// enable that use case.

void SetIgnoreNextSQLiteError(bool ignore);

bool ShouldIgnoreSQLiteError();

SET_MEMORY_INFO_NAME(DatabaseSync)

SET_SELF_SIZE(DatabaseSync)

private:

bool Open();

void DeleteSessions();

~DatabaseSync() override;

DatabaseOpenConfiguration open_config_;

bool allow_load_extension_;

bool enable_load_extension_;

sqlite3* connection_;

bool ignore_next_sqlite_error_;

std::set<BackupJob*> backups_;

std::set<sqlite3_session*> sessions_;

std::unordered_set<StatementSync*> statements_;

friend class Session;

friend class SQLTagStore;

friend class StatementExecutionHelper;

};

class StatementSync : public BaseObject {

public:

StatementSync(Environment* env,

v8::Local<v8::Object> object,

BaseObjectPtr<DatabaseSync> db,

sqlite3_stmt* stmt);

void MemoryInfo(MemoryTracker* tracker) const override;

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

Environment* env);

static BaseObjectPtr<StatementSync> Create(Environment* env,

BaseObjectPtr<DatabaseSync> db,

sqlite3_stmt* stmt);

static void All(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Iterate(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Get(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Run(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Columns(const v8::FunctionCallbackInfo<v8::Value>& args);

static void SourceSQLGetter(const v8::FunctionCallbackInfo<v8::Value>& args);

static void ExpandedSQLGetter(

const v8::FunctionCallbackInfo<v8::Value>& args);

static void SetAllowBareNamedParameters(

const v8::FunctionCallbackInfo<v8::Value>& args);

static void SetAllowUnknownNamedParameters(

const v8::FunctionCallbackInfo<v8::Value>& args);

static void SetReadBigInts(const v8::FunctionCallbackInfo<v8::Value>& args);

static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);

v8::MaybeLocal<v8::Value> ColumnToValue(const int column);

v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);

void Finalize();

bool IsFinalized();

SET_MEMORY_INFO_NAME(StatementSync)

SET_SELF_SIZE(StatementSync)

private:

~StatementSync() override;

BaseObjectPtr<DatabaseSync> db_;

sqlite3_stmt* statement_;

bool return_arrays_ = false;

bool use_big_ints_;

bool allow_bare_named_params_;

bool allow_unknown_named_params_;

std::optional<std::map<std::string, std::string>> bare_named_params_;

bool BindParams(const v8::FunctionCallbackInfo<v8::Value>& args);

bool BindValue(const v8::Local<v8::Value>& value, const int index);

friend class DatabaseSync;

friend class StatementSyncIterator;

friend class SQLTagStore;

friend class StatementExecutionHelper;

};

class StatementSyncIterator : public BaseObject {

public:

StatementSyncIterator(Environment* env,

v8::Local<v8::Object> object,

BaseObjectPtr<StatementSync> stmt);

void MemoryInfo(MemoryTracker* tracker) const override;

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

Environment* env);

static BaseObjectPtr<StatementSyncIterator> Create(

Environment* env, BaseObjectPtr<StatementSync> stmt);

static void Next(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Return(const v8::FunctionCallbackInfo<v8::Value>& args);

SET_MEMORY_INFO_NAME(StatementSyncIterator)

SET_SELF_SIZE(StatementSyncIterator)

private:

~StatementSyncIterator() override;

BaseObjectPtr<StatementSync> stmt_;

bool done_;

};

using Sqlite3ChangesetGenFunc = int (*)(sqlite3_session*, int*, void**);

class Session : public BaseObject {

public:

Session(Environment* env,

v8::Local<v8::Object> object,

BaseObjectWeakPtr<DatabaseSync> database,

sqlite3_session* session);

~Session() override;

template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>

static void Changeset(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Dispose(const v8::FunctionCallbackInfo<v8::Value>& args);

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

Environment* env);

static BaseObjectPtr<Session> Create(Environment* env,

BaseObjectWeakPtr<DatabaseSync> database,

sqlite3_session* session);

void MemoryInfo(MemoryTracker* tracker) const override;

SET_MEMORY_INFO_NAME(Session)

SET_SELF_SIZE(Session)

private:

void Delete();

sqlite3_session* session_;

BaseObjectWeakPtr<DatabaseSync> database_; // The Parent Database

};

class SQLTagStore : public BaseObject {

public:

enum InternalFields {

kDatabaseObject = BaseObject::kInternalFieldCount,

kInternalFieldCount

};

SQLTagStore(Environment* env,

v8::Local<v8::Object> object,

BaseObjectWeakPtr<DatabaseSync> database,

int capacity);

~SQLTagStore() override;

static BaseObjectPtr<SQLTagStore> Create(

Environment* env, BaseObjectWeakPtr<DatabaseSync> database, int capacity);

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

Environment* env);

static void All(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Get(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Iterate(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Run(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);

static void CapacityGetter(const v8::FunctionCallbackInfo<v8::Value>& args);

static void DatabaseGetter(const v8::FunctionCallbackInfo<v8::Value>& args);

static void SizeGetter(const v8::FunctionCallbackInfo<v8::Value>& args);

void MemoryInfo(MemoryTracker* tracker) const override;

SET_MEMORY_INFO_NAME(SQLTagStore)

SET_SELF_SIZE(SQLTagStore)

private:

static BaseObjectPtr<StatementSync> PrepareStatement(

const v8::FunctionCallbackInfo<v8::Value>& args);

BaseObjectWeakPtr<DatabaseSync> database_;

LRUCache<std::string, BaseObjectPtr<StatementSync>> sql_tags_;

friend class StatementExecutionHelper;

};

class UserDefinedFunction {

public:

UserDefinedFunction(Environment* env,

v8::Local<v8::Function> fn,

DatabaseSync* db,

bool use_bigint_args);

~UserDefinedFunction();

static void xFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv);

static void xDestroy(void* self);

private:

Environment* env_;

v8::Global<v8::Function> fn_;

DatabaseSync* db_;

bool use_bigint_args_;

};

} // namespace sqlite

} // namespace node

#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif // SRC_NODE_SQLITE_H_