/******************************************************************************

 *

 * Project:  PROJ

 * Purpose:  ISO19111:2019 implementation

 * Author:   Even Rouault <even dot rouault at spatialys dot com>

 *

 ******************************************************************************

 * Copyright (c) 2018, Even Rouault <even dot rouault at spatialys dot com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 ****************************************************************************/

#ifndef FROM_PROJ_CPP

#define FROM_PROJ_CPP

#endif

#include "proj/common.hpp"

#include "proj/coordinateoperation.hpp"

#include "proj/coordinates.hpp"

#include "proj/coordinatesystem.hpp"

#include "proj/crs.hpp"

#include "proj/datum.hpp"

#include "proj/io.hpp"

#include "proj/metadata.hpp"

#include "proj/util.hpp"

#include "proj/internal/internal.hpp"

#include "proj/internal/io_internal.hpp"

#include "proj/internal/lru_cache.hpp"

#include "proj/internal/tracing.hpp"

#include "operation/coordinateoperation_internal.hpp"

#include "operation/parammappings.hpp"

#include "filemanager.hpp"

#include "sqlite3_utils.hpp"

#include <algorithm>

#include <cmath>

#include <cstdlib>

#include <cstring>

#include <functional>

#include <iomanip>

#include <limits>

#include <locale>

#include <map>

#include <memory>

#include <mutex>

#include <sstream> // std::ostringstream

#include <stdexcept>

#include <string>

#include "proj_constants.h"

// PROJ include order is sensitive

// clang-format off

#include "proj.h"

#include "proj_internal.h"

// clang-format on

#include <sqlite3.h>

#ifdef EMBED_RESOURCE_FILES

#include "embedded_resources.h"

#endif

// Custom SQLite VFS as our database is not supposed to be modified in

// parallel. This is slightly faster

#define ENABLE_CUSTOM_LOCKLESS_VFS

#if defined(_WIN32) && defined(PROJ_HAS_PTHREADS)

#undef PROJ_HAS_PTHREADS

#endif

/* SQLite3 might use seak()+read() or pread[64]() to read data */

/* The later allows the same SQLite handle to be safely used in forked */

/* children of a parent process, while the former doesn't. */

/* So we use pthread_atfork() to set a flag in forked children, to ask them */

/* to close and reopen their database handle. */

#if defined(PROJ_HAS_PTHREADS) && !defined(SQLITE_USE_PREAD)

#include <pthread.h>

#define REOPEN_SQLITE_DB_AFTER_FORK

#endif

using namespace NS_PROJ::internal;

using namespace NS_PROJ::common;

NS_PROJ_START

namespace io {

//! @cond Doxygen_Suppress

#define GEOG_2D_SINGLE_QUOTED "'geographic 2D'"

#define GEOG_3D_SINGLE_QUOTED "'geographic 3D'"

#define GEOCENTRIC_SINGLE_QUOTED "'geocentric'"

// Coordinate system types

constexpr const char *CS_TYPE_ELLIPSOIDAL = cs::EllipsoidalCS::WKT2_TYPE;

constexpr const char *CS_TYPE_CARTESIAN = cs::CartesianCS::WKT2_TYPE;

constexpr const char *CS_TYPE_SPHERICAL = cs::SphericalCS::WKT2_TYPE;

constexpr const char *CS_TYPE_VERTICAL = cs::VerticalCS::WKT2_TYPE;

constexpr const char *CS_TYPE_ORDINAL = cs::OrdinalCS::WKT2_TYPE;

// See data/sql/metadata.sql for the semantics of those constants

constexpr int DATABASE_LAYOUT_VERSION_MAJOR = 1;

// If the code depends on the new additions, then DATABASE_LAYOUT_VERSION_MINOR

// must be incremented.

constexpr int DATABASE_LAYOUT_VERSION_MINOR = 7;

constexpr size_t N_MAX_PARAMS = 7;

#ifdef EMBED_RESOURCE_FILES

constexpr const char *EMBEDDED_PROJ_DB = "__embedded_proj_db__";

#endif

// ---------------------------------------------------------------------------

struct SQLValues {

    enum class Type { STRING, INT, DOUBLE };

    // cppcheck-suppress noExplicitConstructor

    SQLValues(const std::string &value) : type_(Type::STRING), str_(value) {}

    // cppcheck-suppress noExplicitConstructor

    SQLValues(int value) : type_(Type::INT), int_(value) {}

    // cppcheck-suppress noExplicitConstructor

    SQLValues(double value) : type_(Type::DOUBLE), double_(value) {}

    const Type &type() const { return type_; }

    // cppcheck-suppress functionStatic

    const std::string &stringValue() const { return str_; }

    // cppcheck-suppress functionStatic

    int intValue() const { return int_; }

    // cppcheck-suppress functionStatic

    double doubleValue() const { return double_; }

  private:

    Type type_;

    std::string str_{};

    int int_ = 0;

    double double_ = 0.0;

};

// ---------------------------------------------------------------------------

using SQLRow = std::vector<std::string>;

using SQLResultSet = std::list<SQLRow>;

using ListOfParams = std::list<SQLValues>;

// ---------------------------------------------------------------------------

static double PROJ_SQLITE_GetValAsDouble(sqlite3_value *val, bool &gotVal) {

    switch (sqlite3_value_type(val)) {

    case SQLITE_FLOAT:

        gotVal = true;

        return sqlite3_value_double(val);

    case SQLITE_INTEGER:

        gotVal = true;

        return static_cast<double>(sqlite3_value_int64(val));

    default:

        gotVal = false;

        return 0.0;

    }

}

// ---------------------------------------------------------------------------

static void PROJ_SQLITE_pseudo_area_from_swne(sqlite3_context *pContext,

                                              int /* argc */,

                                              sqlite3_value **argv) {

    bool b0, b1, b2, b3;

    double south_lat = PROJ_SQLITE_GetValAsDouble(argv[0], b0);

    double west_lon = PROJ_SQLITE_GetValAsDouble(argv[1], b1);

    double north_lat = PROJ_SQLITE_GetValAsDouble(argv[2], b2);

    double east_lon = PROJ_SQLITE_GetValAsDouble(argv[3], b3);

    if (!b0 || !b1 || !b2 || !b3) {

        sqlite3_result_null(pContext);

        return;

    }

    // Deal with area crossing antimeridian

    if (east_lon < west_lon) {

        east_lon += 360.0;

    }

    // Integrate cos(lat) between south_lat and north_lat

    double pseudo_area = (east_lon - west_lon) *

                         (std::sin(common::Angle(north_lat).getSIValue()) -

                          std::sin(common::Angle(south_lat).getSIValue()));

    sqlite3_result_double(pContext, pseudo_area);

}

// ---------------------------------------------------------------------------

static void PROJ_SQLITE_intersects_bbox(sqlite3_context *pContext,

                                        int /* argc */, sqlite3_value **argv) {

    bool b0, b1, b2, b3, b4, b5, b6, b7;

    double south_lat1 = PROJ_SQLITE_GetValAsDouble(argv[0], b0);

    double west_lon1 = PROJ_SQLITE_GetValAsDouble(argv[1], b1);

    double north_lat1 = PROJ_SQLITE_GetValAsDouble(argv[2], b2);

    double east_lon1 = PROJ_SQLITE_GetValAsDouble(argv[3], b3);

    double south_lat2 = PROJ_SQLITE_GetValAsDouble(argv[4], b4);

    double west_lon2 = PROJ_SQLITE_GetValAsDouble(argv[5], b5);

    double north_lat2 = PROJ_SQLITE_GetValAsDouble(argv[6], b6);

    double east_lon2 = PROJ_SQLITE_GetValAsDouble(argv[7], b7);

    if (!b0 || !b1 || !b2 || !b3 || !b4 || !b5 || !b6 || !b7) {

        sqlite3_result_null(pContext);

        return;

    }

    auto bbox1 = metadata::GeographicBoundingBox::create(west_lon1, south_lat1,

                                                         east_lon1, north_lat1);

    auto bbox2 = metadata::GeographicBoundingBox::create(west_lon2, south_lat2,

                                                         east_lon2, north_lat2);

    sqlite3_result_int(pContext, bbox1->intersects(bbox2) ? 1 : 0);

}

// ---------------------------------------------------------------------------

class SQLiteHandle {

    std::string path_{};

    sqlite3 *sqlite_handle_ = nullptr;

    bool close_handle_ = true;

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

    bool is_valid_ = true;

#endif

    int nLayoutVersionMajor_ = 0;

    int nLayoutVersionMinor_ = 0;

#if defined(ENABLE_CUSTOM_LOCKLESS_VFS) || defined(EMBED_RESOURCE_FILES)

    std::unique_ptr<SQLite3VFS> vfs_{};

#endif

    SQLiteHandle(const SQLiteHandle &) = delete;

    SQLiteHandle &operator=(const SQLiteHandle &) = delete;

    SQLiteHandle(sqlite3 *sqlite_handle, bool close_handle)

        : sqlite_handle_(sqlite_handle), close_handle_(close_handle) {

        assert(sqlite_handle_);

    }

    // cppcheck-suppress functionStatic

    void initialize();

    SQLResultSet run(const std::string &sql,

                     const ListOfParams &parameters = ListOfParams(),

                     bool useMaxFloatPrecision = false);

  public:

    ~SQLiteHandle();

    const std::string &path() const { return path_; }

    sqlite3 *handle() { return sqlite_handle_; }

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

    bool isValid() const { return is_valid_; }

    void invalidate() { is_valid_ = false; }

#endif

    static std::shared_ptr<SQLiteHandle> open(PJ_CONTEXT *ctx,

                                              const std::string &path);

    // might not be shared between thread depending how the handle was opened!

    static std::shared_ptr<SQLiteHandle>

    initFromExisting(sqlite3 *sqlite_handle, bool close_handle,

                     int nLayoutVersionMajor, int nLayoutVersionMinor);

    static std::unique_ptr<SQLiteHandle>

    initFromExistingUniquePtr(sqlite3 *sqlite_handle, bool close_handle);

    void checkDatabaseLayout(const std::string &mainDbPath,

                             const std::string &path,

                             const std::string &dbNamePrefix);

    SQLResultSet run(sqlite3_stmt *stmt, const std::string &sql,

                     const ListOfParams &parameters = ListOfParams(),

                     bool useMaxFloatPrecision = false);

    inline int getLayoutVersionMajor() const { return nLayoutVersionMajor_; }

    inline int getLayoutVersionMinor() const { return nLayoutVersionMinor_; }

};

// ---------------------------------------------------------------------------

SQLiteHandle::~SQLiteHandle() {

    if (close_handle_) {

        sqlite3_close(sqlite_handle_);

    }

}

// ---------------------------------------------------------------------------

std::shared_ptr<SQLiteHandle> SQLiteHandle::open(PJ_CONTEXT *ctx,

                                                 const std::string &pathIn) {

    std::string path(pathIn);

    const int sqlite3VersionNumber = sqlite3_libversion_number();

    // Minimum version for correct performance: 3.11

    if (sqlite3VersionNumber < 3 * 1000000 + 11 * 1000) {

        pj_log(ctx, PJ_LOG_ERROR,

               "SQLite3 version is %s, whereas at least 3.11 should be used",

               sqlite3_libversion());

    }

    std::string vfsName;

#if defined(ENABLE_CUSTOM_LOCKLESS_VFS) || defined(EMBED_RESOURCE_FILES)

    std::unique_ptr<SQLite3VFS> vfs;

#endif

#ifdef EMBED_RESOURCE_FILES

    if (path == EMBEDDED_PROJ_DB && ctx->custom_sqlite3_vfs_name.empty()) {

        unsigned int proj_db_size = 0;

        const unsigned char *proj_db = pj_get_embedded_proj_db(&proj_db_size);

        vfs = SQLite3VFS::createMem(proj_db, proj_db_size);

        if (vfs == nullptr) {

            throw FactoryException("Open of " + path + " failed");

        }

        std::ostringstream buffer;

        buffer << "file:/proj.db?immutable=1&ptr=";

        buffer << reinterpret_cast<uintptr_t>(proj_db);

        buffer << "&sz=";

        buffer << proj_db_size;

        buffer << "&max=";

        buffer << proj_db_size;

        buffer << "&vfs=";

        buffer << vfs->name();

        path = buffer.str();

    } else

#endif

#ifdef ENABLE_CUSTOM_LOCKLESS_VFS

        if (ctx->custom_sqlite3_vfs_name.empty()) {

        vfs = SQLite3VFS::create(false, true, true);

        if (vfs == nullptr) {

            throw FactoryException("Open of " + path + " failed");

        }

        vfsName = vfs->name();

    } else

#endif

    {

        vfsName = ctx->custom_sqlite3_vfs_name;

    }

    sqlite3 *sqlite_handle = nullptr;

    // SQLITE_OPEN_FULLMUTEX as this will be used from concurrent threads

    if (sqlite3_open_v2(

            path.c_str(), &sqlite_handle,

            SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_URI,

            vfsName.empty() ? nullptr : vfsName.c_str()) != SQLITE_OK ||

        !sqlite_handle) {

        if (sqlite_handle != nullptr) {

            sqlite3_close(sqlite_handle);

        }

        throw FactoryException("Open of " + path + " failed");

    }

    auto handle =

        std::shared_ptr<SQLiteHandle>(new SQLiteHandle(sqlite_handle, true));

#if defined(ENABLE_CUSTOM_LOCKLESS_VFS) || defined(EMBED_RESOURCE_FILES)

    handle->vfs_ = std::move(vfs);

#endif

    handle->initialize();

    handle->path_ = path;

    handle->checkDatabaseLayout(path, path, std::string());

    return handle;

}

// ---------------------------------------------------------------------------

std::shared_ptr<SQLiteHandle>

SQLiteHandle::initFromExisting(sqlite3 *sqlite_handle, bool close_handle,

                               int nLayoutVersionMajor,

                               int nLayoutVersionMinor) {

    auto handle = std::shared_ptr<SQLiteHandle>(

        new SQLiteHandle(sqlite_handle, close_handle));

    handle->nLayoutVersionMajor_ = nLayoutVersionMajor;

    handle->nLayoutVersionMinor_ = nLayoutVersionMinor;

    handle->initialize();

    return handle;

}

// ---------------------------------------------------------------------------

std::unique_ptr<SQLiteHandle>

SQLiteHandle::initFromExistingUniquePtr(sqlite3 *sqlite_handle,

                                        bool close_handle) {

    auto handle = std::unique_ptr<SQLiteHandle>(

        new SQLiteHandle(sqlite_handle, close_handle));

    handle->initialize();

    return handle;

}

// ---------------------------------------------------------------------------

SQLResultSet SQLiteHandle::run(sqlite3_stmt *stmt, const std::string &sql,

                               const ListOfParams &parameters,

                               bool useMaxFloatPrecision) {

    int nBindField = 1;

    for (const auto &param : parameters) {

        const auto &paramType = param.type();

        if (paramType == SQLValues::Type::STRING) {

            const auto &strValue = param.stringValue();

            sqlite3_bind_text(stmt, nBindField, strValue.c_str(),

                              static_cast<int>(strValue.size()),

                              SQLITE_TRANSIENT);

        } else if (paramType == SQLValues::Type::INT) {

            sqlite3_bind_int(stmt, nBindField, param.intValue());

        } else {

            assert(paramType == SQLValues::Type::DOUBLE);

            sqlite3_bind_double(stmt, nBindField, param.doubleValue());

        }

        nBindField++;

    }

#ifdef TRACE_DATABASE

    size_t nPos = 0;

    std::string sqlSubst(sql);

    for (const auto &param : parameters) {

        nPos = sqlSubst.find('?', nPos);

        assert(nPos != std::string::npos);

        std::string strValue;

        const auto paramType = param.type();

        if (paramType == SQLValues::Type::STRING) {

            strValue = '\'' + param.stringValue() + '\'';

        } else if (paramType == SQLValues::Type::INT) {

            strValue = toString(param.intValue());

        } else {

            strValue = toString(param.doubleValue());

        }

        sqlSubst =

            sqlSubst.substr(0, nPos) + strValue + sqlSubst.substr(nPos + 1);

        nPos += strValue.size();

    }

    logTrace(sqlSubst, "DATABASE");

#endif

    SQLResultSet result;

    const int column_count = sqlite3_column_count(stmt);

    while (true) {

        int ret = sqlite3_step(stmt);

        if (ret == SQLITE_ROW) {

            SQLRow row(column_count);

            for (int i = 0; i < column_count; i++) {

                if (useMaxFloatPrecision &&

                    sqlite3_column_type(stmt, i) == SQLITE_FLOAT) {

                    // sqlite3_column_text() does not use maximum precision

                    std::ostringstream buffer;

                    buffer.imbue(std::locale::classic());

                    buffer << std::setprecision(18);

                    buffer << sqlite3_column_double(stmt, i);

                    row[i] = buffer.str();

                } else {

                    const char *txt = reinterpret_cast<const char *>(

                        sqlite3_column_text(stmt, i));

                    if (txt) {

                        row[i] = txt;

                    }

                }

            }

            result.emplace_back(std::move(row));

        } else if (ret == SQLITE_DONE) {

            break;

        } else {

            throw FactoryException(std::string("SQLite error [ ")

                                       .append("code = ")

                                       .append(internal::toString(ret))

                                       .append(", msg = ")

                                       .append(sqlite3_errmsg(sqlite_handle_))

                                       .append(" ] on ")

                                       .append(sql));

        }

    }

    return result;

}

// ---------------------------------------------------------------------------

SQLResultSet SQLiteHandle::run(const std::string &sql,

                               const ListOfParams &parameters,

                               bool useMaxFloatPrecision) {

    sqlite3_stmt *stmt = nullptr;

    try {

        if (sqlite3_prepare_v2(sqlite_handle_, sql.c_str(),

                               static_cast<int>(sql.size()), &stmt,

                               nullptr) != SQLITE_OK) {

            throw FactoryException(std::string("SQLite error [ ")

                                       .append(sqlite3_errmsg(sqlite_handle_))

                                       .append(" ] on ")

                                       .append(sql));

        }

        auto ret = run(stmt, sql, parameters, useMaxFloatPrecision);

        sqlite3_finalize(stmt);

        return ret;

    } catch (const std::exception &) {

        if (stmt)

            sqlite3_finalize(stmt);

        throw;

    }

}

// ---------------------------------------------------------------------------

void SQLiteHandle::checkDatabaseLayout(const std::string &mainDbPath,

                                       const std::string &path,

                                       const std::string &dbNamePrefix) {

    if (!dbNamePrefix.empty() && run("SELECT 1 FROM " + dbNamePrefix +

                                     "sqlite_master WHERE name = 'metadata'")

                                     .empty()) {

        // Accept auxiliary databases without metadata table (sparse DBs)

        return;

    }

    auto res = run("SELECT key, value FROM " + dbNamePrefix +

                   "metadata WHERE key IN "

                   "('DATABASE.LAYOUT.VERSION.MAJOR', "

                   "'DATABASE.LAYOUT.VERSION.MINOR')");

    if (res.empty() && !dbNamePrefix.empty()) {

        // Accept auxiliary databases without layout metadata.

        return;

    }

    if (res.size() != 2) {

        throw FactoryException(

            path + " lacks DATABASE.LAYOUT.VERSION.MAJOR / "

                   "DATABASE.LAYOUT.VERSION.MINOR "

                   "metadata. It comes from another PROJ installation.");

    }

    int major = 0;

    int minor = 0;

    for (const auto &row : res) {

        if (row[0] == "DATABASE.LAYOUT.VERSION.MAJOR") {

            major = atoi(row[1].c_str());

        } else if (row[0] == "DATABASE.LAYOUT.VERSION.MINOR") {

            minor = atoi(row[1].c_str());

        }

    }

    if (major != DATABASE_LAYOUT_VERSION_MAJOR) {

        throw FactoryException(

            path +

            " contains DATABASE.LAYOUT.VERSION.MAJOR = " + toString(major) +

            " whereas " + toString(DATABASE_LAYOUT_VERSION_MAJOR) +

            " is expected. "

            "It comes from another PROJ installation.");

    }

    if (minor < DATABASE_LAYOUT_VERSION_MINOR) {

        throw FactoryException(

            path +

            " contains DATABASE.LAYOUT.VERSION.MINOR = " + toString(minor) +

            " whereas a number >= " + toString(DATABASE_LAYOUT_VERSION_MINOR) +

            " is expected. "

            "It comes from another PROJ installation.");

    }

    if (dbNamePrefix.empty()) {

        nLayoutVersionMajor_ = major;

        nLayoutVersionMinor_ = minor;

    } else if (nLayoutVersionMajor_ != major || nLayoutVersionMinor_ != minor) {

        throw FactoryException(

            "Auxiliary database " + path +

            " contains a DATABASE.LAYOUT.VERSION =  " + toString(major) + '.' +

            toString(minor) +

            " which is different from the one from the main database " +

            mainDbPath + " which is " + toString(nLayoutVersionMajor_) + '.' +

            toString(nLayoutVersionMinor_));

    }

}

// ---------------------------------------------------------------------------

#ifndef SQLITE_DETERMINISTIC

#define SQLITE_DETERMINISTIC 0

#endif

void SQLiteHandle::initialize() {

    // There is a bug in sqlite 3.38.0 with some complex queries.

    // Cf https://github.com/OSGeo/PROJ/issues/3077

    // Disabling Bloom-filter pull-down optimization as suggested in

    // https://sqlite.org/forum/forumpost/7d3a75438c

    const int sqlite3VersionNumber = sqlite3_libversion_number();

    if (sqlite3VersionNumber == 3 * 1000000 + 38 * 1000) {

        sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite_handle_,

                             0x100000);

    }

    sqlite3_create_function(sqlite_handle_, "pseudo_area_from_swne", 4,

                            SQLITE_UTF8 | SQLITE_DETERMINISTIC, nullptr,

                            PROJ_SQLITE_pseudo_area_from_swne, nullptr,

                            nullptr);

    sqlite3_create_function(sqlite_handle_, "intersects_bbox", 8,

                            SQLITE_UTF8 | SQLITE_DETERMINISTIC, nullptr,

                            PROJ_SQLITE_intersects_bbox, nullptr, nullptr);

}

// ---------------------------------------------------------------------------

class SQLiteHandleCache {

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

    bool firstTime_ = true;

#endif

    std::mutex sMutex_{};

    // Map dbname to SQLiteHandle

    lru11::Cache<std::string, std::shared_ptr<SQLiteHandle>> cache_{};

  public:

    static SQLiteHandleCache &get();

    std::shared_ptr<SQLiteHandle> getHandle(const std::string &path,

                                            PJ_CONTEXT *ctx);

    void clear();

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

    void invalidateHandles();

#endif

};

// ---------------------------------------------------------------------------

SQLiteHandleCache &SQLiteHandleCache::get() {

    // Global cache

    static SQLiteHandleCache gSQLiteHandleCache;

    return gSQLiteHandleCache;

}

// ---------------------------------------------------------------------------

void SQLiteHandleCache::clear() {

    std::lock_guard<std::mutex> lock(sMutex_);

    cache_.clear();

}

// ---------------------------------------------------------------------------

std::shared_ptr<SQLiteHandle>

SQLiteHandleCache::getHandle(const std::string &path, PJ_CONTEXT *ctx) {

    std::lock_guard<std::mutex> lock(sMutex_);

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

    if (firstTime_) {

        firstTime_ = false;

        pthread_atfork(

            []() {

                // This mutex needs to be acquired by 'invalidateHandles()'.

                // The forking thread needs to own this mutex during the fork.

                // Otherwise there's an opporunity for another thread to own

                // the mutex during the fork, leaving the child process unable

                // to acquire the mutex in invalidateHandles().

                SQLiteHandleCache::get().sMutex_.lock();

            },

            []() { SQLiteHandleCache::get().sMutex_.unlock(); },

            []() {

                SQLiteHandleCache::get().sMutex_.unlock();

                SQLiteHandleCache::get().invalidateHandles();

            });

    }

#endif

    std::shared_ptr<SQLiteHandle> handle;

    std::string key = path + ctx->custom_sqlite3_vfs_name;

    if (!cache_.tryGet(key, handle)) {

        handle = SQLiteHandle::open(ctx, path);

        cache_.insert(key, handle);

    }

    return handle;

}

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

// ---------------------------------------------------------------------------

void SQLiteHandleCache::invalidateHandles() {

    std::lock_guard<std::mutex> lock(sMutex_);

    const auto lambda =

        [](const lru11::KeyValuePair<std::string, std::shared_ptr<SQLiteHandle>>

               &kvp) { kvp.value->invalidate(); };

    cache_.cwalk(lambda);

    cache_.clear();

}

#endif

// ---------------------------------------------------------------------------

struct DatabaseContext::Private {

    Private();

    ~Private();

    void open(const std::string &databasePath, PJ_CONTEXT *ctx);

    void setHandle(sqlite3 *sqlite_handle);

    const std::shared_ptr<SQLiteHandle> &handle();

    PJ_CONTEXT *pjCtxt() const { return pjCtxt_; }

    void setPjCtxt(PJ_CONTEXT *ctxt) { pjCtxt_ = ctxt; }

    SQLResultSet run(const std::string &sql,

                     const ListOfParams &parameters = ListOfParams(),

                     bool useMaxFloatPrecision = false);

    std::vector<std::string> getDatabaseStructure();

    // cppcheck-suppress functionStatic

    const std::string &getPath() const { return databasePath_; }

    void attachExtraDatabases(

        const std::vector<std::string> &auxiliaryDatabasePaths);

    // Mechanism to detect recursion in calls from

    // AuthorityFactory::createXXX() -> createFromUserInput() ->

    // AuthorityFactory::createXXX()

    struct RecursionDetector {

        explicit RecursionDetector(const DatabaseContextNNPtr &context)

            : dbContext_(context) {

            if (dbContext_->getPrivate()->recLevel_ == 2) {

                // Throw exception before incrementing, since the destructor

                // will not be called

                throw FactoryException("Too many recursive calls");

            }

            ++dbContext_->getPrivate()->recLevel_;

        }

        ~RecursionDetector() { --dbContext_->getPrivate()->recLevel_; }

      private:

        DatabaseContextNNPtr dbContext_;

    };

    std::map<std::string, std::list<SQLRow>> &getMapCanonicalizeGRFName() {

        return mapCanonicalizeGRFName_;

    }

    // cppcheck-suppress functionStatic

    common::UnitOfMeasurePtr getUOMFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const common::UnitOfMeasureNNPtr &uom);

    // cppcheck-suppress functionStatic

    crs::CRSPtr getCRSFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const crs::CRSNNPtr &crs);

    datum::GeodeticReferenceFramePtr

    // cppcheck-suppress functionStatic

    getGeodeticDatumFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code,

               const datum::GeodeticReferenceFrameNNPtr &datum);

    datum::DatumEnsemblePtr

    // cppcheck-suppress functionStatic

    getDatumEnsembleFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code,

               const datum::DatumEnsembleNNPtr &datumEnsemble);

    datum::EllipsoidPtr

    // cppcheck-suppress functionStatic

    getEllipsoidFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const datum::EllipsoidNNPtr &ellipsoid);

    datum::PrimeMeridianPtr

    // cppcheck-suppress functionStatic

    getPrimeMeridianFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const datum::PrimeMeridianNNPtr &pm);

    // cppcheck-suppress functionStatic

    cs::CoordinateSystemPtr

    getCoordinateSystemFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const cs::CoordinateSystemNNPtr &cs);

    // cppcheck-suppress functionStatic

    metadata::ExtentPtr getExtentFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const metadata::ExtentNNPtr &extent);

    // cppcheck-suppress functionStatic

    bool getCRSToCRSCoordOpFromCache(

        const std::string &code,

        std::vector<operation::CoordinateOperationNNPtr> &list);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code,

               const std::vector<operation::CoordinateOperationNNPtr> &list);

    struct GridInfoCache {

        std::string fullFilename{};

        std::string packageName{};

        std::string url{};

        bool found = false;

        bool directDownload = false;

        bool openLicense = false;

        bool gridAvailable = false;

    };

    // cppcheck-suppress functionStatic

    bool getGridInfoFromCache(const std::string &code, GridInfoCache &info);

    // cppcheck-suppress functionStatic

    void evictGridInfoFromCache(const std::string &code);

    // cppcheck-suppress functionStatic

    void cache(const std::string &code, const GridInfoCache &info);

    struct VersionedAuthName {

        std::string versionedAuthName{};

        std::string authName{};

        std::string version{};

        int priority = 0;

    };

    const std::vector<VersionedAuthName> &getCacheAuthNameWithVersion();

  private:

    friend class DatabaseContext;

    // This is a manual implementation of std::enable_shared_from_this<> that

    // avoids publicly deriving from it.

    std::weak_ptr<DatabaseContext> self_{};

    std::string databasePath_{};

    std::vector<std::string> auxiliaryDatabasePaths_{};

    std::shared_ptr<SQLiteHandle> sqlite_handle_{};

    unsigned int queryCounter_ = 0;

    std::map<std::string, sqlite3_stmt *> mapSqlToStatement_{};

    PJ_CONTEXT *pjCtxt_ = nullptr;

    int recLevel_ = 0;

    bool detach_ = false;

    std::string lastMetadataValue_{};

    std::map<std::string, std::list<SQLRow>> mapCanonicalizeGRFName_{};

    // Used by startInsertStatementsSession() and related functions

    std::string memoryDbForInsertPath_{};

    std::unique_ptr<SQLiteHandle> memoryDbHandle_{};

    using LRUCacheOfObjects = lru11::Cache<std::string, util::BaseObjectPtr>;

    static constexpr size_t CACHE_SIZE = 128;

    LRUCacheOfObjects cacheUOM_{CACHE_SIZE};

    LRUCacheOfObjects cacheCRS_{CACHE_SIZE};

    LRUCacheOfObjects cacheEllipsoid_{CACHE_SIZE};

    LRUCacheOfObjects cacheGeodeticDatum_{CACHE_SIZE};

    LRUCacheOfObjects cacheDatumEnsemble_{CACHE_SIZE};

    LRUCacheOfObjects cachePrimeMeridian_{CACHE_SIZE};

    LRUCacheOfObjects cacheCS_{CACHE_SIZE};

    LRUCacheOfObjects cacheExtent_{CACHE_SIZE};

    lru11::Cache<std::string, std::vector<operation::CoordinateOperationNNPtr>>

        cacheCRSToCrsCoordOp_{CACHE_SIZE};

    lru11::Cache<std::string, GridInfoCache> cacheGridInfo_{CACHE_SIZE};

    std::map<std::string, std::vector<std::string>> cacheAllowedAuthorities_{};

    lru11::Cache<std::string, std::list<std::string>> cacheAliasNames_{

        CACHE_SIZE};

    lru11::Cache<std::string, std::string> cacheNames_{CACHE_SIZE};

    std::vector<VersionedAuthName> cacheAuthNameWithVersion_{};

    static void insertIntoCache(LRUCacheOfObjects &cache,

                                const std::string &code,

                                const util::BaseObjectPtr &obj);

    static void getFromCache(LRUCacheOfObjects &cache, const std::string &code,

                             util::BaseObjectPtr &obj);

    void closeDB() noexcept;

    void clearCaches();

    std::string findFreeCode(const std::string &tableName,

                             const std::string &authName,

                             const std::string &codePrototype);

    void identify(const DatabaseContextNNPtr &dbContext,

                  const cs::CoordinateSystemNNPtr &obj, std::string &authName,

                  std::string &code);

    void identifyOrInsert(const DatabaseContextNNPtr &dbContext,

                          const cs::CoordinateSystemNNPtr &obj,

                          const std::string &ownerType,

                          const std::string &ownerAuthName,

                          const std::string &ownerCode, std::string &authName,

                          std::string &code,

                          std::vector<std::string> &sqlStatements);

    void identify(const DatabaseContextNNPtr &dbContext,

                  const common::UnitOfMeasure &obj, std::string &authName,

                  std::string &code);

    void identifyOrInsert(const DatabaseContextNNPtr &dbContext,

                          const common::UnitOfMeasure &unit,

                          const std::string &ownerAuthName,

                          std::string &authName, std::string &code,

                          std::vector<std::string> &sqlStatements);

    void appendSql(std::vector<std::string> &sqlStatements,

                   const std::string &sql);

    void

    identifyOrInsertUsages(const common::ObjectUsageNNPtr &obj,

                           const std::string &tableName,

                           const std::string &authName, const std::string &code,

                           const std::vector<std::string> &allowedAuthorities,

                           std::vector<std::string> &sqlStatements);

    std::vector<std::string>

    getInsertStatementsFor(const datum::PrimeMeridianNNPtr &pm,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const datum::EllipsoidNNPtr &ellipsoid,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const datum::GeodeticReferenceFrameNNPtr &datum,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const datum::DatumEnsembleNNPtr &ensemble,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const crs::GeodeticCRSNNPtr &crs,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const crs::ProjectedCRSNNPtr &crs,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const datum::VerticalReferenceFrameNNPtr &datum,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const crs::VerticalCRSNNPtr &crs,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    std::vector<std::string>

    getInsertStatementsFor(const crs::CompoundCRSNNPtr &crs,

                           const std::string &authName, const std::string &code,

                           bool numericCode,

                           const std::vector<std::string> &allowedAuthorities);

    Private(const Private &) = delete;

    Private &operator=(const Private &) = delete;

};

// ---------------------------------------------------------------------------

DatabaseContext::Private::Private() = default;

// ---------------------------------------------------------------------------

DatabaseContext::Private::~Private() {

    assert(recLevel_ == 0);

    closeDB();

}

// ---------------------------------------------------------------------------

void DatabaseContext::Private::closeDB() noexcept {

    if (detach_) {

        // Workaround a bug visible in SQLite 3.8.1 and 3.8.2 that causes

        // a crash in TEST(factory, attachExtraDatabases_auxiliary)

        // due to possible wrong caching of key info.

        // The bug is specific to using a memory file with shared cache as an

        // auxiliary DB.

        // The fix was likely in 3.8.8

        // https://github.com/mackyle/sqlite/commit/d412d4b8731991ecbd8811874aa463d0821673eb

        // But just after 3.8.2,

        // https://github.com/mackyle/sqlite/commit/ccf328c4318eacedab9ed08c404bc4f402dcad19

        // also seemed to hide the issue.

        // Detaching a database hides the issue, not sure if it is by chance...

        try {

            run("DETACH DATABASE db_0");

        } catch (...) {

        }

        detach_ = false;

    }

    for (auto &pair : mapSqlToStatement_) {

        sqlite3_finalize(pair.second);

    }

    mapSqlToStatement_.clear();

    sqlite_handle_.reset();

}

// ---------------------------------------------------------------------------

void DatabaseContext::Private::clearCaches() {

    cacheUOM_.clear();

    cacheCRS_.clear();

    cacheEllipsoid_.clear();

    cacheGeodeticDatum_.clear();

    cacheDatumEnsemble_.clear();

    cachePrimeMeridian_.clear();

    cacheCS_.clear();

    cacheExtent_.clear();

    cacheCRSToCrsCoordOp_.clear();

    cacheGridInfo_.clear();

    cacheAllowedAuthorities_.clear();

    cacheAliasNames_.clear();

    cacheNames_.clear();

}

// ---------------------------------------------------------------------------

const std::shared_ptr<SQLiteHandle> &DatabaseContext::Private::handle() {

#ifdef REOPEN_SQLITE_DB_AFTER_FORK

    if (sqlite_handle_ && !sqlite_handle_->isValid()) {

        closeDB();

        open(databasePath_, pjCtxt_);