#include "node_sqlite.h"

#include <path.h>

#include "base_object-inl.h"

#include "debug_utils-inl.h"

#include "env-inl.h"

#include "memory_tracker-inl.h"

#include "node.h"

#include "node_diagnostics_channel.h"

#include "node_errors.h"

#include "node_external_reference.h"

#include "node_mem-inl.h"

#include "node_url.h"

#include "simdutf.h"

#include "sqlite3.h"

#include "threadpoolwork-inl.h"

#include "util-inl.h"

#include <array>

#include <charconv>

#include <cinttypes>

#include <cmath>

#include <cstring>

#include <limits>

#include <string>

#include <string_view>

namespace node {

namespace sqlite {

using v8::Array;

using v8::ArrayBuffer;

using v8::BackingStore;

using v8::BackingStoreInitializationMode;

using v8::BackingStoreOnFailureMode;

using v8::BigInt;

using v8::Boolean;

using v8::ConstructorBehavior;

using v8::Context;

using v8::DictionaryTemplate;

using v8::DontDelete;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::Function;

using v8::FunctionCallback;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Global;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Intercepted;

using v8::Isolate;

using v8::JustVoid;

using v8::Local;

using v8::LocalVector;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Name;

using v8::NamedPropertyHandlerConfiguration;

using v8::NewStringType;

using v8::Nothing;

using v8::Null;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::Promise;

using v8::PropertyCallbackInfo;

using v8::PropertyHandlerFlags;

using v8::SideEffectType;

using v8::String;

using v8::TryCatch;

using v8::Uint8Array;

using v8::Value;

inline MaybeLocal<String> Utf8StringMaybeOneByte(Isolate* isolate,

}

BindingData::BindingData(Realm* realm, Local<Object> wrap)

: BaseObject(realm, wrap) {

MakeWeak();

}

void BindingData::MemoryInfo(MemoryTracker* tracker) const {

}

void BindingData::CreatePerContextProperties(Local<Object> target,

}

inline MaybeLocal<Value> IntegerToValue(Isolate* isolate,

}

#define CHECK_ERROR_OR_THROW(isolate, db, expr, expected, ret) \

do { \

int r_ = (expr); \

if (r_ != (expected)) { \

THROW_ERR_SQLITE_ERROR((isolate), (db)); \

return (ret); \

} \

} while (0)

#define RESET_OR_THROW(isolate, db, stmt, ret) \

CHECK_ERROR_OR_THROW((isolate), (db), sqlite3_reset((stmt)), SQLITE_OK, (ret))

#define RESET_AND_CHECK(isolate, db, stmt, needs_reset, ret) \

do { \

(needs_reset) = false; \

RESET_OR_THROW((isolate), (db), (stmt), (ret)); \

} while (0)

#define THROW_AND_RETURN_ON_BAD_STATE(env, condition, msg) \

do { \

if ((condition)) { \

THROW_ERR_INVALID_STATE((env), (msg)); \

return; \

} \

} while (0)

#define THROW_AND_RETURN_IF_IN_AUTHORIZER(env, db) \

THROW_AND_RETURN_ON_BAD_STATE( \

(env), \

(db)->IsInAuthorizerCallback(), \

"database cannot be accessed from an authorizer callback")

#define THROW_AND_RETURN_IF_BUSY_IN_AUTHORIZER(env, stmt) \

THROW_AND_RETURN_ON_BAD_STATE( \

(env), \

(stmt)->db_->IsInAuthorizerCallback() && \

sqlite3_stmt_busy((stmt)->statement_.get()), \

"database cannot be accessed from an authorizer callback")

#define THROW_AND_RETURN_IF_SESSION_IN_CALLBACK(env, session) \

THROW_AND_RETURN_ON_BAD_STATE( \

(env), \

(session)->database_->IsInCallback(), \

"session cannot be closed while in a callback")

#define THROW_AND_RETURN_IF_STEPPING(env, stmt) \

THROW_AND_RETURN_ON_BAD_STATE( \

(env), \

(stmt)->db_->IsSteppingStatement((stmt)->statement_.get()), \

"statement is already being executed")

#define SQLITE_VALUE_TO_JS(from, isolate, use_big_int_args, result, ...) \

do { \

switch (sqlite3_##from##_type(__VA_ARGS__)) { \

case SQLITE_INTEGER: { \

sqlite3_int64 val = sqlite3_##from##_int64(__VA_ARGS__); \

(result) = IntegerToValue((isolate), val, (use_big_int_args)); \

break; \

} \

case SQLITE_FLOAT: { \

(result) = \

Number::New((isolate), sqlite3_##from##_double(__VA_ARGS__)); \

break; \

} \

case SQLITE_TEXT: { \

const char* v = \

reinterpret_cast<const char*>(sqlite3_##from##_text(__VA_ARGS__)); \

if (v == nullptr) [[unlikely]] { \

THROW_ERR_MEMORY_ALLOCATION_FAILED((isolate)); \

break; \

} \

const int v_len = sqlite3_##from##_bytes(__VA_ARGS__); \

(result) = \

Utf8StringMaybeOneByte((isolate), std::string_view(v, v_len)) \

.As<Value>(); \

break; \

} \

case SQLITE_NULL: { \

(result) = Null((isolate)); \

break; \

} \

case SQLITE_BLOB: { \

size_t size = \

static_cast<size_t>(sqlite3_##from##_bytes(__VA_ARGS__)); \

auto data = reinterpret_cast<const uint8_t*>( \

sqlite3_##from##_blob(__VA_ARGS__)); \

auto store = ArrayBuffer::NewBackingStore( \

(isolate), size, BackingStoreInitializationMode::kUninitialized); \

if (data != nullptr) [[likely]] { \

memcpy(store->Data(), data, size); \

} \

auto ab = ArrayBuffer::New((isolate), std::move(store)); \

(result) = Uint8Array::New(ab, 0, size); \

break; \

} \

default: \

UNREACHABLE("Bad SQLite value"); \

} \

} while (0)

namespace {

Local<DictionaryTemplate> getLazyIterTemplate(Environment* env) {

}

} // namespace

template <typename T, size_t N>

static constexpr const T* FindByJsName(const std::array<T, N>& mapping,

std::string_view name) {

for (const auto& info : mapping) {

if (name == info.js_name) {

return &info;

}

}

return nullptr;

}

namespace {

MaybeLocal<Object> CreateSQLiteErrorImpl(Isolate* isolate,

}

} // namespace

inline MaybeLocal<Object> CreateSQLiteError(Isolate* isolate,

const char* message) {

return CreateSQLiteErrorImpl(isolate, message, nullptr, 0);

}

inline MaybeLocal<Object> CreateSQLiteError(Isolate* isolate, int errcode) {

const char* errstr = sqlite3_errstr(errcode);

return CreateSQLiteErrorImpl(isolate, errstr, errstr, errcode);

}

inline MaybeLocal<Object> CreateSQLiteError(Isolate* isolate, sqlite3* db) {

}

void JSValueToSQLiteResult(Isolate* isolate,

}

class Database;

inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, Database* db) {

}

inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, const char* message) {

}

inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, int errcode) {

}

inline MaybeLocal<Value> NullableSQLiteStringToValue(Isolate* isolate,

}

class CustomAggregate {

};

class BackupJob : public ThreadPoolWork {

};

UserDefinedFunction::UserDefinedFunction(Environment* env,

}

UserDefinedFunction::~UserDefinedFunction() {

if (db_) db_->user_defined_functions_.erase(this);

}

void UserDefinedFunction::xFunc(sqlite3_context* ctx,

}

void UserDefinedFunction::xDestroy(void* self) {

delete static_cast<UserDefinedFunction*>(self);

}

DatabaseLimits::DatabaseLimits(Environment* env,

}

DatabaseLimits::~DatabaseLimits() = default;

void DatabaseLimits::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("database", database_);

}

Local<ObjectTemplate> DatabaseLimits::GetTemplate(Environment* env) {

}

Intercepted DatabaseLimits::LimitsGetter(

}

Intercepted DatabaseLimits::LimitsSetter(

}

Intercepted DatabaseLimits::LimitsQuery(