diff options
| -rw-r--r-- | data/sql/customizations.sql | 3 | ||||
| -rw-r--r-- | include/proj/io.hpp | 13 | ||||
| -rw-r--r-- | scripts/reference_exported_symbols.txt | 9 | ||||
| -rw-r--r-- | src/iso19111/c_api.cpp | 221 | ||||
| -rw-r--r-- | src/iso19111/crs.cpp | 16 | ||||
| -rw-r--r-- | src/iso19111/factory.cpp | 1514 | ||||
| -rw-r--r-- | src/proj.h | 24 | ||||
| -rw-r--r-- | test/unit/test_c_api.cpp | 88 | ||||
| -rw-r--r-- | test/unit/test_factory.cpp | 573 |
9 files changed, 2446 insertions, 15 deletions
diff --git a/data/sql/customizations.sql b/data/sql/customizations.sql index 63780e3a..b14add32 100644 --- a/data/sql/customizations.sql +++ b/data/sql/customizations.sql @@ -1,5 +1,8 @@ -- This file is hand generated. +INSERT INTO "extent" VALUES('PROJ','EXTENT_UNKNOWN','Not specified','Not specified.',-90.0,90.0,-180.0,180.0,0); +INSERT INTO "scope" VALUES('PROJ','SCOPE_UNKNOWN','Not known.',0); + -- grid_alternatives entries created from existing ones INSERT INTO grid_alternatives(original_grid_name, diff --git a/include/proj/io.hpp b/include/proj/io.hpp index 2f935a0c..5f0dd475 100644 --- a/include/proj/io.hpp +++ b/include/proj/io.hpp @@ -838,6 +838,19 @@ class PROJ_GCC_DLL DatabaseContext { PROJ_DLL std::vector<std::string> getDatabaseStructure() const; + PROJ_DLL void startInsertStatementsSession(); + + PROJ_DLL std::string + suggestsCodeFor(const common::IdentifiedObjectNNPtr &object, + const std::string &authName, bool numericCode); + + PROJ_DLL std::vector<std::string> + getInsertStatementsFor(const common::IdentifiedObjectNNPtr &object, + const std::string &authName, const std::string &code, + bool numericCode); + + PROJ_DLL void stopInsertStatementsSession(); + PROJ_PRIVATE : //! @cond Doxygen_Suppress PROJ_DLL void * diff --git a/scripts/reference_exported_symbols.txt b/scripts/reference_exported_symbols.txt index c6ddc03a..798f515e 100644 --- a/scripts/reference_exported_symbols.txt +++ b/scripts/reference_exported_symbols.txt @@ -359,10 +359,14 @@ osgeo::proj::io::DatabaseContext::create(void*) osgeo::proj::io::DatabaseContext::~DatabaseContext() osgeo::proj::io::DatabaseContext::getAuthorities() const osgeo::proj::io::DatabaseContext::getDatabaseStructure() const +osgeo::proj::io::DatabaseContext::getInsertStatementsFor(dropbox::oxygen::nn<std::shared_ptr<osgeo::proj::common::IdentifiedObject> > const&, std::string const&, std::string const&, bool) osgeo::proj::io::DatabaseContext::getMetadata(char const*) const osgeo::proj::io::DatabaseContext::getPath() const osgeo::proj::io::DatabaseContext::getSqliteHandle() const osgeo::proj::io::DatabaseContext::lookForGridInfo(std::string const&, bool, std::string&, std::string&, std::string&, bool&, bool&, bool&) const +osgeo::proj::io::DatabaseContext::startInsertStatementsSession() +osgeo::proj::io::DatabaseContext::stopInsertStatementsSession() +osgeo::proj::io::DatabaseContext::suggestsCodeFor(dropbox::oxygen::nn<std::shared_ptr<osgeo::proj::common::IdentifiedObject> > const&, std::string const&, bool) osgeo::proj::io::FactoryException::~FactoryException() osgeo::proj::io::FactoryException::FactoryException(char const*) osgeo::proj::io::FactoryException::FactoryException(osgeo::proj::io::FactoryException const&) @@ -960,6 +964,7 @@ proj_get_crs_list_parameters_destroy proj_get_ellipsoid proj_get_id_auth_name proj_get_id_code +proj_get_insert_statements proj_get_name proj_get_non_deprecated proj_get_prime_meridian @@ -980,6 +985,8 @@ proj_grid_info proj_identify proj_info proj_init_info +proj_insert_object_session_create +proj_insert_object_session_destroy proj_int_list_destroy proj_is_crs proj_is_deprecated @@ -1017,7 +1024,9 @@ proj_prime_meridian_get_parameters proj_query_geodetic_crs_from_datum proj_roundtrip proj_rtodms +proj_string_destroy proj_string_list_destroy +proj_suggests_code_for proj_todeg proj_torad proj_trans diff --git a/src/iso19111/c_api.cpp b/src/iso19111/c_api.cpp index 8f1fac70..b97e7300 100644 --- a/src/iso19111/c_api.cpp +++ b/src/iso19111/c_api.cpp @@ -8727,3 +8727,224 @@ PJ *proj_concatoperation_get_step(PJ_CONTEXT *ctx, const PJ *concatoperation, } return pj_obj_create(ctx, steps[i_step]); } +// --------------------------------------------------------------------------- + +/** \brief Opaque object representing an insertion session. */ +struct PJ_INSERT_SESSION { + //! @cond Doxygen_Suppress + PJ_CONTEXT *ctx = nullptr; + //! @endcond +}; + +// --------------------------------------------------------------------------- + +/** \brief Starts a session for proj_get_insert_statements() + * + * Starts a new session for one or several calls to + * proj_get_insert_statements(). + * + * An insertion session guarantees that the inserted objects will not create + * conflicting intermediate objects. + * + * The session must be stopped with proj_insert_object_session_destroy(). + * + * Only one session may be active at a time for a given context. + * + * @param ctx PROJ context, or NULL for default context + * @return the session, or NULL in case of error. + * + * @since 8.1 + */ +PJ_INSERT_SESSION *proj_insert_object_session_create(PJ_CONTEXT *ctx) { + SANITIZE_CTX(ctx); + try { + auto dbContext = getDBcontext(ctx); + dbContext->startInsertStatementsSession(); + PJ_INSERT_SESSION *session = new PJ_INSERT_SESSION; + session->ctx = ctx; + return session; + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + +/** \brief Stops an insertion session started with + * proj_insert_object_session_create() + * + * @param ctx PROJ context, or NULL for default context + * @param session The insertion session. + * @since 8.1 + */ +void proj_insert_object_session_destroy(PJ_CONTEXT *ctx, + PJ_INSERT_SESSION *session) { + SANITIZE_CTX(ctx); + if (session) { + try { + if (session->ctx != ctx) { + proj_log_error(ctx, __FUNCTION__, + "proj_insert_object_session_destroy() called " + "with a context different from the one of " + "proj_insert_object_session_create()"); + } else { + auto dbContext = getDBcontext(ctx); + dbContext->stopInsertStatementsSession(); + } + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + delete session; + } +} + +// --------------------------------------------------------------------------- + +/** \brief Suggests a database code for the passed object. + * + * Supported type of objects are PrimeMeridian, Ellipsoid, Datum, DatumEnsemble, + * GeodeticCRS, ProjectedCRS, VerticalCRS, CompoundCRS, BoundCRS, Conversion. + * + * @param ctx PROJ context, or NULL for default context + * @param object Object for which to suggest a code. + * @param authority Authority name into which the object will be inserted. + * @param numeric_code Whether the code should be numeric, or derived from the + * object name. + * @param options NULL terminated list of options, or NULL. + * No options are supported currently. + * @return the suggested code, that is guaranteed to not conflict with an + * existing one (to be freed with proj_string_destroy), + * or nullptr in case of error. + * + * @since 8.1 + */ +char *proj_suggests_code_for(PJ_CONTEXT *ctx, const PJ *object, + const char *authority, int numeric_code, + const char *const *options) { + SANITIZE_CTX(ctx); + (void)options; + + if (!object || !authority) { + proj_context_errno_set(ctx, PROJ_ERR_OTHER_API_MISUSE); + proj_log_error(ctx, __FUNCTION__, "missing required input"); + return nullptr; + } + auto identifiedObject = + std::dynamic_pointer_cast<IdentifiedObject>(object->iso_obj); + if (!identifiedObject) { + proj_context_errno_set(ctx, PROJ_ERR_OTHER_API_MISUSE); + proj_log_error(ctx, __FUNCTION__, "Object is not a IdentifiedObject"); + return nullptr; + } + + try { + auto dbContext = getDBcontext(ctx); + return pj_strdup(dbContext + ->suggestsCodeFor(NN_NO_CHECK(identifiedObject), + std::string(authority), + numeric_code != FALSE) + .c_str()); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} + +// --------------------------------------------------------------------------- + +/** \brief Free a string. + * + * Only to be used with functions that document using this function. + * + * @param str String to free. + * + * @since 8.1 + */ +void proj_string_destroy(char *str) { free(str); } + +// --------------------------------------------------------------------------- + +/** \brief Returns SQL statements needed to insert the passed object into the + * database. + * + * proj_insert_object_session_create() may have been called previously. + * + * @param ctx PROJ context, or NULL for default context + * @param session The insertion session. May be NULL if a single object must be + * inserted. + * @param object The object to insert into the database. Currently only + * PrimeMeridian, Ellipsoid, Datum, GeodeticCRS, ProjectedCRS, + * VerticalCRS, CompoundCRS or BoundCRS are supported. + * @param authority Authority name into which the object will be inserted. + * Must not be NULL. + * @param code Code with which the object will be inserted.Must not be NULL. + * @param numeric_codes Whether intermediate objects that can be created should + * use numeric codes (true), or may be alphanumeric (false) + * @param options NULL terminated list of options, or NULL. + * No options are supported currently. + * + * @return a list of insert statements (to be freed with + * proj_string_list_destroy()), or NULL in case of error. + * @since 8.1 + */ +PROJ_STRING_LIST proj_get_insert_statements(PJ_CONTEXT *ctx, + PJ_INSERT_SESSION *session, + const PJ *object, + const char *authority, + const char *code, int numeric_codes, + const char *const *options) { + SANITIZE_CTX(ctx); + (void)options; + + struct TempSessionHolder { + PJ_CONTEXT *m_ctx; + PJ_INSERT_SESSION *m_tempSession = nullptr; + TempSessionHolder(const TempSessionHolder &) = delete; + TempSessionHolder &operator=(const TempSessionHolder &) = delete; + + TempSessionHolder(PJ_CONTEXT *ctx, PJ_INSERT_SESSION *session) + : m_ctx(ctx), + m_tempSession(session ? nullptr + : proj_insert_object_session_create(ctx)) {} + + ~TempSessionHolder() { + if (m_tempSession) { + proj_insert_object_session_destroy(m_ctx, m_tempSession); + } + } + }; + + try { + TempSessionHolder oHolder(ctx, session); + if (!session) { + session = oHolder.m_tempSession; + if (!session) { + return nullptr; + } + } + + if (!object || !authority || !code) { + proj_context_errno_set(ctx, PROJ_ERR_OTHER_API_MISUSE); + proj_log_error(ctx, __FUNCTION__, "missing required input"); + return nullptr; + } + auto identifiedObject = + std::dynamic_pointer_cast<IdentifiedObject>(object->iso_obj); + if (!identifiedObject) { + proj_context_errno_set(ctx, PROJ_ERR_OTHER_API_MISUSE); + proj_log_error(ctx, __FUNCTION__, + "Object is not a IdentifiedObject"); + return nullptr; + } + + auto dbContext = getDBcontext(ctx); + auto statements = dbContext->getInsertStatementsFor( + NN_NO_CHECK(identifiedObject), authority, code, + numeric_codes != FALSE); + return to_string_list(std::move(statements)); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} diff --git a/src/iso19111/crs.cpp b/src/iso19111/crs.cpp index 73c61e2c..65f2087d 100644 --- a/src/iso19111/crs.cpp +++ b/src/iso19111/crs.cpp @@ -4829,7 +4829,14 @@ CompoundCRS::identify(const io::AuthorityFactoryPtr &authorityFactory) const { const auto &thisName(nameStr()); const auto &components = componentReferenceSystems(); - const bool l_implicitCS = components[0]->hasImplicitCS(); + bool l_implicitCS = components[0]->hasImplicitCS(); + if (!l_implicitCS) { + const auto projCRS = + dynamic_cast<const ProjectedCRS *>(components[0].get()); + if (projCRS) { + l_implicitCS = projCRS->baseCRS()->hasImplicitCS(); + } + } const auto crsCriterion = l_implicitCS ? util::IComparable::Criterion::EQUIVALENT_EXCEPT_AXIS_ORDER_GEOGCRS @@ -4949,6 +4956,13 @@ CompoundCRS::identify(const io::AuthorityFactoryPtr &authorityFactory) const { } res.sort(lambdaSort); + + // If there's a single candidate at 90% confidence with same name, + // then promote it to 100% + if (res.size() == 1 && res.front().second == 90 && + thisName == res.front().first->nameStr()) { + res.front().second = 100; + } } // If we didn't find a match for the CompoundCRS, check if the diff --git a/src/iso19111/factory.cpp b/src/iso19111/factory.cpp index fbe88dda..36ef217d 100644 --- a/src/iso19111/factory.cpp +++ b/src/iso19111/factory.cpp @@ -52,6 +52,7 @@ #include <cmath> #include <cstdlib> #include <cstring> +#include <functional> #include <iomanip> #include <limits> #include <locale> @@ -101,15 +102,20 @@ constexpr int DATABASE_LAYOUT_VERSION_MAJOR = 1; // must be incremented. constexpr int DATABASE_LAYOUT_VERSION_MINOR = 0; +constexpr size_t N_MAX_PARAMS = 7; + // --------------------------------------------------------------------------- struct SQLValues { - enum class Type { STRING, DOUBLE }; + 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_; } @@ -118,11 +124,15 @@ struct SQLValues { 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; }; @@ -255,7 +265,12 @@ struct DatabaseContext::Private { 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_{}; bool close_handle_ = true; sqlite3 *sqlite_handle_{}; std::map<std::string, sqlite3_stmt *> mapSqlToStatement_{}; @@ -265,6 +280,10 @@ struct DatabaseContext::Private { std::string lastMetadataValue_{}; std::map<std::string, std::list<SQLRow>> mapCanonicalizeGRFName_{}; + // Used by startInsertStatementsSession() and related functions + std::string memoryDbForInsertPath_{}; + sqlite3 *memoryDbHandle_ = nullptr; + using LRUCacheOfObjects = lru11::Cache<std::string, util::BaseObjectPtr>; static constexpr size_t CACHE_SIZE = 128; @@ -296,9 +315,84 @@ struct DatabaseContext::Private { void closeDB() noexcept; + void clearCaches(); + // cppcheck-suppress functionStatic void registerFunctions(); + 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, + std::vector<std::string> &sqlStatements); + + std::vector<std::string> + getInsertStatementsFor(const datum::PrimeMeridianNNPtr &pm, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const datum::EllipsoidNNPtr &ellipsoid, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const datum::GeodeticReferenceFrameNNPtr &datum, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const crs::GeodeticCRSNNPtr &crs, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const crs::ProjectedCRSNNPtr &crs, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const datum::VerticalReferenceFrameNNPtr &datum, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const crs::VerticalCRSNNPtr &crs, + const std::string &authName, const std::string &code, + bool numericCode); + + std::vector<std::string> + getInsertStatementsFor(const crs::CompoundCRSNNPtr &crs, + const std::string &authName, const std::string &code, + bool numericCode); + #ifdef ENABLE_CUSTOM_LOCKLESS_VFS std::unique_ptr<SQLite3VFS> vfs_{}; #endif @@ -355,6 +449,24 @@ void DatabaseContext::Private::closeDB() noexcept { // --------------------------------------------------------------------------- +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(); +} + +// --------------------------------------------------------------------------- + void DatabaseContext::Private::insertIntoCache(LRUCacheOfObjects &cache, const std::string &code, const util::BaseObjectPtr &obj) { @@ -684,6 +796,10 @@ void DatabaseContext::Private::attachExtraDatabases( } closeDB(); + if (auxiliaryDatabasePaths.empty()) { + open(databasePath_, pjCtxt()); + return; + } sqlite3_open_v2( ":memory:", &sqlite_handle_, @@ -850,13 +966,16 @@ SQLResultSet DatabaseContext::Private::run(const std::string &sql, int nBindField = 1; for (const auto ¶m : parameters) { - if (param.type() == SQLValues::Type::STRING) { + const auto paramType = param.type(); + if (paramType == SQLValues::Type::STRING) { 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(param.type() == SQLValues::Type::DOUBLE); + assert(paramType == SQLValues::Type::DOUBLE); sqlite3_bind_double(stmt, nBindField, param.doubleValue()); } nBindField++; @@ -869,8 +988,11 @@ SQLResultSet DatabaseContext::Private::run(const std::string &sql, nPos = sqlSubst.find('?', nPos); assert(nPos != std::string::npos); std::string strValue; - if (param.type() == SQLValues::Type::STRING) { + 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()); } @@ -915,12 +1037,1117 @@ SQLResultSet DatabaseContext::Private::run(const std::string &sql, return result; } +// --------------------------------------------------------------------------- + +static std::string formatStatement(const char *fmt, ...) { + std::string res; + va_list args; + va_start(args, fmt); + for (int i = 0; fmt[i] != '\0'; ++i) { + if (fmt[i] == '%') { + if (fmt[i + 1] == '%') { + res += '%'; + } else if (fmt[i + 1] == 'q') { + const char *arg = va_arg(args, const char *); + for (int j = 0; arg[j] != '\0'; ++j) { + if (arg[j] == '\'') + res += arg[j]; + res += arg[j]; + } + } else if (fmt[i + 1] == 's') { + const char *arg = va_arg(args, const char *); + res += arg; + } else if (fmt[i + 1] == 'f') { + const double arg = va_arg(args, double); + res += toString(arg); + } else if (fmt[i + 1] == 'd') { + const int arg = va_arg(args, int); + res += toString(arg); + } else { + va_end(args); + throw FactoryException( + "Unsupported formatter in formatStatement()"); + } + ++i; + } else { + res += fmt[i]; + } + } + va_end(args); + return res; +} + +// --------------------------------------------------------------------------- + +void DatabaseContext::Private::appendSql( + std::vector<std::string> &sqlStatements, const std::string &sql) { + sqlStatements.emplace_back(sql); + char *errMsg = nullptr; + if (sqlite3_exec(memoryDbHandle_, sql.c_str(), nullptr, nullptr, &errMsg) != + SQLITE_OK) { + std::string s("Cannot execute " + sql); + if (errMsg) { + s += " : "; + s += errMsg; + } + sqlite3_free(errMsg); + throw FactoryException(s); + } + sqlite3_free(errMsg); +} + +// --------------------------------------------------------------------------- + +static void identifyFromNameOrCode( + const DatabaseContextNNPtr &dbContext, + const AuthorityFactoryNNPtr &allAuthFactory, + const common::IdentifiedObjectNNPtr &obj, + std::function<std::shared_ptr<util::IComparable>( + const AuthorityFactoryNNPtr &authFactory, const std::string &)> + instantiateFunc, + AuthorityFactory::ObjectType objType, std::string &authName, + std::string &code) { + for (const auto &id : obj->identifiers()) { + try { + const auto tmpAuthFactory = + AuthorityFactory::create(dbContext, *(id->codeSpace())); + if (instantiateFunc(tmpAuthFactory, id->code()) + ->isEquivalentTo( + obj.get(), util::IComparable::Criterion::EQUIVALENT)) { + authName = *(id->codeSpace()); + code = id->code(); + return; + } + } catch (const std::exception &) { + } + } + + const auto candidates = allAuthFactory->createObjectsFromName( + obj->nameStr(), {objType}, false, 0); + for (const auto &candidate : candidates) { + const auto &ids = candidate->identifiers(); + if (!ids.empty() && + candidate->isEquivalentTo( + obj.get(), util::IComparable::Criterion::EQUIVALENT)) { + const auto &id = ids.front(); + authName = *(id->codeSpace()); + code = id->code(); + } + } +} + +// --------------------------------------------------------------------------- + +static void identifyFromNameOrCode(const DatabaseContextNNPtr &dbContext, + const AuthorityFactoryNNPtr &allAuthFactory, + const datum::DatumEnsembleNNPtr &obj, + std::string &authName, std::string &code) { + const auto instantiateFunc = [](const AuthorityFactoryNNPtr &authFactory, + const std::string &lCode) { + return util::nn_static_pointer_cast<util::IComparable>( + authFactory->createDatumEnsemble(lCode, "geodetic_datum")); + }; + identifyFromNameOrCode(dbContext, allAuthFactory, obj, instantiateFunc, + AuthorityFactory::ObjectType::DATUM_ENSEMBLE, + authName, code); +} + +// --------------------------------------------------------------------------- + +static void +identifyFromNameOrCode(const DatabaseContextNNPtr &dbContext, + const AuthorityFactoryNNPtr &allAuthFactory, + const datum::GeodeticReferenceFrameNNPtr &obj, + std::string &authName, std::string &code) { + const auto instantiateFunc = [](const AuthorityFactoryNNPtr &authFactory, + const std::string &lCode) { + return util::nn_static_pointer_cast<util::IComparable>( + authFactory->createGeodeticDatum(lCode)); + }; + identifyFromNameOrCode( + dbContext, allAuthFactory, obj, instantiateFunc, + AuthorityFactory::ObjectType::GEODETIC_REFERENCE_FRAME, authName, code); +} + +// --------------------------------------------------------------------------- + +static void identifyFromNameOrCode(const DatabaseContextNNPtr &dbContext, + const AuthorityFactoryNNPtr &allAuthFactory, + const datum::EllipsoidNNPtr &obj, + std::string &authName, std::string &code) { + const auto instantiateFunc = [](const AuthorityFactoryNNPtr &authFactory, + const std::string &lCode) { + return util::nn_static_pointer_cast<util::IComparable>( + authFactory->createEllipsoid(lCode)); + }; + identifyFromNameOrCode(dbContext, allAuthFactory, obj, instantiateFunc, + AuthorityFactory::ObjectType::ELLIPSOID, authName, + code); +} + +// --------------------------------------------------------------------------- + +static void identifyFromNameOrCode(const DatabaseContextNNPtr &dbContext, + const AuthorityFactoryNNPtr &allAuthFactory, + const datum::PrimeMeridianNNPtr &obj, + std::string &authName, std::string &code) { + const auto instantiateFunc = [](const AuthorityFactoryNNPtr &authFactory, + const std::string &lCode) { + return util::nn_static_pointer_cast<util::IComparable>( + authFactory->createPrimeMeridian(lCode)); + }; + identifyFromNameOrCode(dbContext, allAuthFactory, obj, instantiateFunc, + AuthorityFactory::ObjectType::PRIME_MERIDIAN, + authName, code); +} + +// --------------------------------------------------------------------------- + +static void +identifyFromNameOrCode(const DatabaseContextNNPtr &dbContext, + const AuthorityFactoryNNPtr &allAuthFactory, + const datum::VerticalReferenceFrameNNPtr &obj, + std::string &authName, std::string &code) { + const auto instantiateFunc = [](const AuthorityFactoryNNPtr &authFactory, + const std::string &lCode) { + return util::nn_static_pointer_cast<util::IComparable>( + authFactory->createVerticalDatum(lCode)); + }; + identifyFromNameOrCode( + dbContext, allAuthFactory, obj, instantiateFunc, + AuthorityFactory::ObjectType::VERTICAL_REFERENCE_FRAME, authName, code); +} + +// --------------------------------------------------------------------------- + +static const char *getCSDatabaseType(const cs::CoordinateSystemNNPtr &obj) { + if (dynamic_cast<const cs::EllipsoidalCS *>(obj.get())) { + return "ellipsoidal"; + } else if (dynamic_cast<const cs::CartesianCS *>(obj.get())) { + return "Cartesian"; + } else if (dynamic_cast<const cs::VerticalCS *>(obj.get())) { + return "vertical"; + } + return nullptr; +} + +// --------------------------------------------------------------------------- + +std::string +DatabaseContext::Private::findFreeCode(const std::string &tableName, + const std::string &authName, + const std::string &codePrototype) { + std::string code(codePrototype); + if (run("SELECT 1 FROM " + tableName + " WHERE auth_name = ? AND code = ?", + {authName, code}) + .empty()) { + return code; + } + + for (int counter = 2; counter < 10; counter++) { + code = codePrototype + '_' + toString(counter); + if (run("SELECT 1 FROM " + tableName + + " WHERE auth_name = ? AND code = ?", + {authName, code}) + .empty()) { + return code; + } + } + + // shouldn't happen hopefully... + throw FactoryException("Cannot insert " + tableName + + ": too many similar codes"); +} + +// --------------------------------------------------------------------------- + +static const char *getUnitDatabaseType(const common::UnitOfMeasure &unit) { + switch (unit.type()) { + case common::UnitOfMeasure::Type::LINEAR: + return "length"; + + case common::UnitOfMeasure::Type::ANGULAR: + return "angle"; + + case common::UnitOfMeasure::Type::SCALE: + return "scale"; + + case common::UnitOfMeasure::Type::TIME: + return "time"; + + default: + break; + } + return nullptr; +} + +// --------------------------------------------------------------------------- + +void DatabaseContext::Private::identify(const DatabaseContextNNPtr &dbContext, + const common::UnitOfMeasure &obj, + std::string &authName, + std::string &code) { + // Identify quickly a few well-known units + const double convFactor = obj.conversionToSI(); + switch (obj.type()) { + case common::UnitOfMeasure::Type::LINEAR: { + if (convFactor == 1.0) { + authName = "EPSG"; + code = "9001"; + return; + } + break; + } + case common::UnitOfMeasure::Type::ANGULAR: { + constexpr double CONV_FACTOR_DEGREE = 1.74532925199432781271e-02; + if (std::abs(convFactor - CONV_FACTOR_DEGREE) <= + 1e-10 * CONV_FACTOR_DEGREE) { + authName = "EPSG"; + code = "9102"; + return; + } + break; + } + case common::UnitOfMeasure::Type::SCALE: { + if (convFactor == 1.0) { + authName = "EPSG"; + code = "9201"; + return; + } + break; + } + default: + break; + } + + std::string sql("SELECT auth_name, code FROM unit_of_measure " + "WHERE abs(conv_factor - ?) <= 1e-10 * conv_factor"); + ListOfParams params{convFactor}; + const char *type = getUnitDatabaseType(obj); + if (type) { + sql += " AND type = ?"; + params.emplace_back(std::string(type)); + } + sql += " ORDER BY auth_name, code"; + const auto res = run(sql, params); + for (const auto &row : res) { + const auto &rowAuthName = row[0]; + const auto &rowCode = row[1]; + const auto tmpAuthFactory = + AuthorityFactory::create(dbContext, rowAuthName); + try { + tmpAuthFactory->createUnitOfMeasure(rowCode); + authName = rowAuthName; + code = rowCode; + return; + } catch (const std::exception &) { + } + } +} + +// --------------------------------------------------------------------------- + +void DatabaseContext::Private::identifyOrInsert( + const DatabaseContextNNPtr &dbContext, const common::UnitOfMeasure &unit, + const std::string &ownerAuthName, std::string &authName, std::string &code, + std::vector<std::string> &sqlStatements) { + authName = unit.codeSpace(); + code = unit.code(); + if (authName.empty()) { + identify(dbContext, unit, authName, code); + } + if (!authName.empty()) { + return; + } + const char *type = getUnitDatabaseType(unit); + if (type == nullptr) { + throw FactoryException("Cannot insert this type of UnitOfMeasure"); + } + + // Insert new record + authName = ownerAuthName; + const std::string codePrototype(replaceAll(toupper(unit.name()), " ", "_")); + code = findFreeCode("unit_of_measure", authName, codePrototype); + + const auto sql = formatStatement( + "INSERT INTO unit_of_measure VALUES('%q','%q','%q','%q',%f,NULL,0);", + authName.c_str(), code.c_str(), unit.name().c_str(), type, + unit.conversionToSI()); + appendSql(sqlStatements, sql); +} + +// --------------------------------------------------------------------------- + +void DatabaseContext::Private::identify(const DatabaseContextNNPtr &dbContext, + const cs::CoordinateSystemNNPtr &obj, + std::string &authName, + std::string &code) { + + const auto &axisList = obj->axisList(); + if (axisList.size() == 1U && + axisList[0]->unit()._isEquivalentTo(UnitOfMeasure::METRE) && + &(axisList[0]->direction()) == &cs::AxisDirection::UP && + (axisList[0]->nameStr() == "Up" || + axisList[0]->nameStr() == "Gravity-related height")) { + // preferred coordinate system for gravity-related height + authName = "EPSG"; + code = "6499"; + return; + } + + std::string sql( + "SELECT auth_name, code FROM coordinate_system WHERE dimension = ?"); + ListOfParams params{static_cast<int>(axisList.size())}; + const char *type = getCSDatabaseType(obj); + if (type) { + sql += " AND type = ?"; + params.emplace_back(std::string(type)); + } + sql += " ORDER BY auth_name, code"; + const auto res = run(sql, params); + for (const auto &row : res) { + const auto &rowAuthName = row[0]; + const auto &rowCode = row[1]; + const auto tmpAuthFactory = + AuthorityFactory::create(dbContext, rowAuthName); + try { + const auto cs = tmpAuthFactory->createCoordinateSystem(rowCode); + if (cs->_isEquivalentTo(obj.get(), + util::IComparable::Criterion::EQUIVALENT)) { + authName = rowAuthName; + code = rowCode; + if (authName == "EPSG" && code == "4400") { + // preferred coordinate system for cartesian + // Easting, Northing + return; + } + if (authName == "EPSG" && code == "6422") { + // preferred coordinate system for geographic lat, lon + return; + } + if (authName == "EPSG" && code == "6423") { + // preferred coordinate system for geographic lat, lon, h + return; + } + } + } catch (const std::exception &) { + } + } +} + +// --------------------------------------------------------------------------- + +void DatabaseContext::Private::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) { + + identify(dbContext, obj, authName, code); + if (!authName.empty()) { + return; + } + + const char *type = getCSDatabaseType(obj); + if (type == nullptr) { + throw FactoryException("Cannot insert this type of CoordinateSystem"); + } + + // Insert new record in coordinate_system + authName = ownerAuthName; + const std::string codePrototype("CS_" + ownerType + '_' + ownerCode); + code = findFreeCode("coordinate_system", authName, codePrototype); + + const auto &axisList = obj->axisList(); + { + const auto sql = formatStatement( + "INSERT INTO coordinate_system VALUES('%q','%q','%q',%d);", + authName.c_str(), code.c_str(), type, + static_cast<int>(axisList.size())); + appendSql(sqlStatements, sql); + } + + // Insert new records for the axis + for (int i = 0; i < static_cast<int>(axisList.size()); ++i) { + const auto &axis = axisList[i]; + std::string uomAuthName; + std::string uomCode; + identifyOrInsert(dbContext, axis->unit(), ownerAuthName, uomAuthName, + uomCode, sqlStatements); + const auto sql = formatStatement( + "INSERT INTO axis VALUES(" + "'%q','%q','%q','%q','%q','%q','%q',%d,'%q','%q');", + authName.c_str(), (code + "_AXIS_" + toString(i + 1)).c_str(), + axis->nameStr().c_str(), axis->abbreviation().c_str(), + axis->direction().toString().c_str(), authName.c_str(), + code.c_str(), i + 1, uomAuthName.c_str(), uomCode.c_str()); + appendSql(sqlStatements, sql); + } +} + +// --------------------------------------------------------------------------- + +void DatabaseContext::Private::identifyOrInsertUsages( + const common::ObjectUsageNNPtr &obj, const std::string &tableName, + const std::string &authName, const std::string &code, + std::vector<std::string> &sqlStatements) { + + std::string usageCode("USAGE_"); + const std::string upperTableName(toupper(tableName)); + if (!starts_with(code, upperTableName)) { + usageCode += upperTableName; + usageCode += '_'; + } + usageCode += code; + + const auto &domains = obj->domains(); + if (domains.empty()) { + const auto sql = + formatStatement("INSERT INTO usage VALUES('%q','%q','%q','%q','%q'," + "'PROJ','EXTENT_UNKNOWN','PROJ','SCOPE_UNKNOWN');", + authName.c_str(), usageCode.c_str(), + tableName.c_str(), authName.c_str(), code.c_str()); + appendSql(sqlStatements, sql); + return; + } + + int usageCounter = 1; + for (const auto &domain : domains) { + std::string scopeAuthName; + std::string scopeCode; + const auto &scope = domain->scope(); + if (scope.has_value()) { + const auto rows = + run("SELECT auth_name, code, " + "(CASE WHEN auth_name = 'EPSG' THEN 0 ELSE 1 END) " + "AS order_idx " + "FROM scope WHERE scope = ? AND deprecated = 0 " + "ORDER BY order_idx", + {*scope}); + if (!rows.empty()) { + const auto &row = rows.front(); + scopeAuthName = row[0]; + scopeCode = row[1]; + } else { + scopeAuthName = authName; + scopeCode = "SCOPE_" + tableName + "_" + code; + const auto sql = formatStatement( + "INSERT INTO scope VALUES('%q','%q','%q',0);", + scopeAuthName.c_str(), scopeCode.c_str(), scope->c_str()); + appendSql(sqlStatements, sql); + } + } else { + scopeAuthName = "PROJ"; + scopeCode = "SCOPE_UNKNOWN"; + } + + std::string extentAuthName("PROJ"); + std::string extentCode("EXTENT_UNKNOWN"); + const auto &extent = domain->domainOfValidity(); + if (extent) { + const auto &geogElts = extent->geographicElements(); + if (!geogElts.empty()) { + const auto bbox = + dynamic_cast<const metadata::GeographicBoundingBox *>( + geogElts.front().get()); + if (bbox) { + const auto rows = run( + "SELECT auth_name, code, " + "(CASE WHEN auth_name = 'EPSG' THEN 0 ELSE 1 END) " + "AS order_idx " + "FROM extent WHERE south_lat = ? AND north_lat = ? " + "AND west_lon = ? AND east_lon = ? AND deprecated = 0 " + "ORDER BY order_idx", + {bbox->southBoundLatitude(), bbox->northBoundLatitude(), + bbox->westBoundLongitude(), + bbox->eastBoundLongitude()}); + if (!rows.empty()) { + const auto &row = rows.front(); + extentAuthName = row[0]; + extentCode = row[1]; + } else { + extentAuthName = authName; + extentCode = "EXTENT_" + tableName + "_" + code; + std::string description(*(extent->description())); + if (description.empty()) { + description = "unknown"; + } + const auto sql = formatStatement( + "INSERT INTO extent " + "VALUES('%q','%q','%q','%q',%f,%f,%f,%f,0);", + extentAuthName.c_str(), extentCode.c_str(), + description.c_str(), description.c_str(), + bbox->southBoundLatitude(), + bbox->northBoundLatitude(), + bbox->westBoundLongitude(), + bbox->eastBoundLongitude()); + appendSql(sqlStatements, sql); + } + } + } + } + + if (domains.size() > 1) { + usageCode += '_'; + usageCode += toString(usageCounter); + } + const auto sql = formatStatement( + "INSERT INTO usage VALUES('%q','%q','%q','%q','%q'," + "'%q','%q','%q','%q');", + authName.c_str(), usageCode.c_str(), tableName.c_str(), + authName.c_str(), code.c_str(), extentAuthName.c_str(), + extentCode.c_str(), scopeAuthName.c_str(), scopeCode.c_str()); + appendSql(sqlStatements, sql); + + usageCounter++; + } +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const datum::PrimeMeridianNNPtr &pm, const std::string &authName, + const std::string &code, bool /*numericCode*/) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + // Check if the object is already known under that code + std::string pmAuthName; + std::string pmCode; + identifyFromNameOrCode(self, allAuthFactory, pm, pmAuthName, pmCode); + if (pmAuthName == authName && pmCode == code) { + return {}; + } + + std::vector<std::string> sqlStatements; + + // Insert new record in prime_meridian table + std::string uomAuthName; + std::string uomCode; + identifyOrInsert(self, pm->longitude().unit(), authName, uomAuthName, + uomCode, sqlStatements); + + const auto sql = formatStatement( + "INSERT INTO prime_meridian VALUES(" + "'%q','%q','%q',%f,'%q','%q',0);", + authName.c_str(), code.c_str(), pm->nameStr().c_str(), + pm->longitude().value(), uomAuthName.c_str(), uomCode.c_str()); + appendSql(sqlStatements, sql); + + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const datum::EllipsoidNNPtr &ellipsoid, const std::string &authName, + const std::string &code, bool /*numericCode*/) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + // Check if the object is already known under that code + std::string ellipsoidAuthName; + std::string ellipsoidCode; + identifyFromNameOrCode(self, allAuthFactory, ellipsoid, ellipsoidAuthName, + ellipsoidCode); + if (ellipsoidAuthName == authName && ellipsoidCode == code) { + return {}; + } + + std::vector<std::string> sqlStatements; + + // Find or insert celestial body + const auto &semiMajorAxis = ellipsoid->semiMajorAxis(); + const double semiMajorAxisMetre = semiMajorAxis.getSIValue(); + constexpr double tolerance = 0.005; + std::string bodyAuthName; + std::string bodyCode; + auto res = run("SELECT auth_name, code, " + "(ABS(semi_major_axis - ?) / semi_major_axis ) " + "AS rel_error FROM celestial_body WHERE rel_error <= ?", + {semiMajorAxisMetre, tolerance}); + if (!res.empty()) { + const auto &row = res.front(); + bodyAuthName = row[0]; + bodyCode = row[1]; + } else { + bodyAuthName = authName; + bodyCode = "BODY_" + code; + const auto bodyName = "Body of " + ellipsoid->nameStr(); + const auto sql = formatStatement( + "INSERT INTO celestial_body VALUES('%q','%q','%q',%f);", + bodyAuthName.c_str(), bodyCode.c_str(), bodyName.c_str(), + semiMajorAxisMetre); + appendSql(sqlStatements, sql); + } + + // Insert new record in ellipsoid table + std::string uomAuthName; + std::string uomCode; + identifyOrInsert(self, semiMajorAxis.unit(), authName, uomAuthName, uomCode, + sqlStatements); + std::string invFlattening("NULL"); + std::string semiMinorAxis("NULL"); + if (ellipsoid->isSphere() || ellipsoid->semiMinorAxis().has_value()) { + semiMinorAxis = toString(ellipsoid->computeSemiMinorAxis().value()); + } else { + invFlattening = toString(ellipsoid->computedInverseFlattening()); + } + + const auto sql = formatStatement( + "INSERT INTO ellipsoid VALUES(" + "'%q','%q','%q','%q','%q','%q',%f,'%q','%q',%s,%s,0);", + authName.c_str(), code.c_str(), ellipsoid->nameStr().c_str(), + "", // description + bodyAuthName.c_str(), bodyCode.c_str(), semiMajorAxis.value(), + uomAuthName.c_str(), uomCode.c_str(), invFlattening.c_str(), + semiMinorAxis.c_str()); + appendSql(sqlStatements, sql); + + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const datum::GeodeticReferenceFrameNNPtr &datum, + const std::string &authName, const std::string &code, bool numericCode) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + // Check if the object is already known under that code + std::string datumAuthName; + std::string datumCode; + identifyFromNameOrCode(self, allAuthFactory, datum, datumAuthName, + datumCode); + if (datumAuthName == authName && datumCode == code) { + return {}; + } + + std::vector<std::string> sqlStatements; + + // Find or insert ellipsoid + std::string ellipsoidAuthName; + std::string ellipsoidCode; + const auto &ellipsoidOfDatum = datum->ellipsoid(); + identifyFromNameOrCode(self, allAuthFactory, ellipsoidOfDatum, + ellipsoidAuthName, ellipsoidCode); + if (ellipsoidAuthName.empty()) { + ellipsoidAuthName = authName; + if (numericCode) { + ellipsoidCode = self->suggestsCodeFor(ellipsoidOfDatum, + ellipsoidAuthName, true); + } else { + ellipsoidCode = "ELLPS_" + code; + } + sqlStatements = self->getInsertStatementsFor( + ellipsoidOfDatum, ellipsoidAuthName, ellipsoidCode, numericCode); + } + + // Find or insert prime meridian + std::string pmAuthName; + std::string pmCode; + const auto &pmOfDatum = datum->primeMeridian(); + identifyFromNameOrCode(self, allAuthFactory, pmOfDatum, pmAuthName, pmCode); + if (pmAuthName.empty()) { + pmAuthName = authName; + if (numericCode) { + pmCode = self->suggestsCodeFor(pmOfDatum, pmAuthName, true); + } else { + pmCode = "PM_" + code; + } + const auto sqlStatementsTmp = self->getInsertStatementsFor( + pmOfDatum, pmAuthName, pmCode, numericCode); + sqlStatements.insert(sqlStatements.end(), sqlStatementsTmp.begin(), + sqlStatementsTmp.end()); + } + + // Insert new record in geodetic_datum table + const auto sql = formatStatement( + "INSERT INTO geodetic_datum VALUES(" + "'%q','%q','%q','%q','%q','%q','%q','%q',NULL,NULL,NULL,0);", + authName.c_str(), code.c_str(), datum->nameStr().c_str(), + "", // description + ellipsoidAuthName.c_str(), ellipsoidCode.c_str(), pmAuthName.c_str(), + pmCode.c_str()); + appendSql(sqlStatements, sql); + + identifyOrInsertUsages(datum, "geodetic_datum", authName, code, + sqlStatements); + + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const crs::GeodeticCRSNNPtr &crs, const std::string &authName, + const std::string &code, bool numericCode) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + std::vector<std::string> sqlStatements; + + // Find or insert datum/datum ensemble + std::string datumAuthName; + std::string datumCode; + const auto &ensemble = crs->datumEnsemble(); + if (ensemble) { + identifyFromNameOrCode(self, allAuthFactory, NN_NO_CHECK(ensemble), + datumAuthName, datumCode); + if (datumAuthName.empty()) { + throw FactoryException( + "Unhandled yet: insertion of new DatumEnsemble"); + } + } else { + const auto &datum = crs->datum(); + assert(datum); + const auto datumNN = NN_NO_CHECK(datum); + identifyFromNameOrCode(self, allAuthFactory, datumNN, datumAuthName, + datumCode); + if (datumAuthName.empty()) { + datumAuthName = authName; + if (numericCode) { + datumCode = self->suggestsCodeFor(datumNN, datumAuthName, true); + } else { + datumCode = "GEODETIC_DATUM_" + code; + } + sqlStatements = self->getInsertStatementsFor( + datumNN, datumAuthName, datumCode, numericCode); + } + } + + // Find or insert coordinate system + const auto &coordinateSystem = crs->coordinateSystem(); + std::string csAuthName; + std::string csCode; + identifyOrInsert(self, coordinateSystem, "GEODETIC_CRS", authName, code, + csAuthName, csCode, sqlStatements); + + const char *type = GEOG_2D; + if (coordinateSystem->axisList().size() == 3) { + if (dynamic_cast<const crs::GeographicCRS *>(crs.get())) { + type = GEOG_3D; + } else { + type = GEOCENTRIC; + } + } + + // Insert new record in geodetic_crs table + const auto sql = + formatStatement("INSERT INTO geodetic_crs VALUES(" + "'%q','%q','%q','%q','%q','%q','%q','%q','%q',NULL,0);", + authName.c_str(), code.c_str(), crs->nameStr().c_str(), + "", // description + type, csAuthName.c_str(), csCode.c_str(), + datumAuthName.c_str(), datumCode.c_str()); + appendSql(sqlStatements, sql); + + identifyOrInsertUsages(crs, "geodetic_crs", authName, code, sqlStatements); + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const crs::ProjectedCRSNNPtr &crs, const std::string &authName, + const std::string &code, bool numericCode) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + std::vector<std::string> sqlStatements; + + // Find or insert base geodetic CRS + const auto &baseCRS = crs->baseCRS(); + std::string geodAuthName; + std::string geodCode; + const auto candidates = baseCRS->identify(allAuthFactory); + for (const auto &candidate : candidates) { + if (candidate.second == 100) { + const auto &ids = candidate.first->identifiers(); + for (const auto &id : ids) { + geodAuthName = *(id->codeSpace()); + geodCode = id->code(); + break; + } + } + } + if (geodAuthName.empty()) { + geodAuthName = authName; + geodCode = "GEODETIC_CRS_" + code; + sqlStatements = self->getInsertStatementsFor(baseCRS, geodAuthName, + geodCode, numericCode); + } + + // Insert new record in conversion table + const auto &conversion = crs->derivingConversionRef(); + std::string convAuthName(authName); + std::string convCode("CONVERSION_" + code); + if (numericCode) { + convCode = self->suggestsCodeFor(conversion, convAuthName, true); + } + { + const auto &method = conversion->method(); + const auto &methodIds = method->identifiers(); + if (methodIds.empty()) { + throw FactoryException( + "Cannot insert projection with method without identifier"); + } + const auto &methodId = methodIds.front(); + const auto &methodAuthName = *(methodId->codeSpace()); + const auto &methodCode = methodId->code(); + auto sql = formatStatement("INSERT INTO conversion VALUES(" + "'%q','%q','%q','','%q','%q','%q'", + convAuthName.c_str(), convCode.c_str(), + conversion->nameStr().c_str(), + methodAuthName.c_str(), methodCode.c_str(), + method->nameStr().c_str()); + const auto &values = conversion->parameterValues(); + if (values.size() > N_MAX_PARAMS) { + throw FactoryException("Cannot insert projection with more than " + + toString(static_cast<int>(N_MAX_PARAMS)) + + " parameters"); + } + for (const auto &genOpParamvalue : values) { + auto opParamValue = + dynamic_cast<const operation::OperationParameterValue *>( + genOpParamvalue.get()); + if (!opParamValue) { + throw FactoryException("Cannot insert projection with " + "non-OperationParameterValue"); + } + const auto ¶m = opParamValue->parameter(); + const auto ¶mIds = param->identifiers(); + if (paramIds.empty()) { + throw FactoryException( + "Cannot insert projection with method parameter " + "without identifier"); + } + const auto ¶mId = paramIds.front(); + const auto ¶mAuthName = *(paramId->codeSpace()); + const auto ¶mCode = paramId->code(); + const auto &value = opParamValue->parameterValue()->value(); + const auto &unit = value.unit(); + std::string uomAuthName; + std::string uomCode; + identifyOrInsert(self, unit, authName, uomAuthName, uomCode, + sqlStatements); + sql += formatStatement(",'%q','%q','%q',%f,'%q','%q'", + paramAuthName.c_str(), paramCode.c_str(), + param->nameStr().c_str(), value.value(), + uomAuthName.c_str(), uomCode.c_str()); + } + for (size_t i = values.size(); i < N_MAX_PARAMS; ++i) { + sql += ",NULL,NULL,NULL,NULL,NULL,NULL"; + } + sql += ",0);"; + appendSql(sqlStatements, sql); + identifyOrInsertUsages(crs, "conversion", convAuthName, convCode, + sqlStatements); + } + + // Find or insert coordinate system + const auto &coordinateSystem = crs->coordinateSystem(); + std::string csAuthName; + std::string csCode; + identifyOrInsert(self, coordinateSystem, "PROJECTED_CRS", authName, code, + csAuthName, csCode, sqlStatements); + + // Insert new record in projected_crs table + const auto sql = formatStatement( + "INSERT INTO projected_crs VALUES(" + "'%q','%q','%q','%q','%q','%q','%q','%q','%q','%q',NULL,0);", + authName.c_str(), code.c_str(), crs->nameStr().c_str(), + "", // description + csAuthName.c_str(), csCode.c_str(), geodAuthName.c_str(), + geodCode.c_str(), convAuthName.c_str(), convCode.c_str()); + appendSql(sqlStatements, sql); + + identifyOrInsertUsages(crs, "projected_crs", authName, code, sqlStatements); + + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const datum::VerticalReferenceFrameNNPtr &datum, + const std::string &authName, const std::string &code, + bool /* numericCode */) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + std::vector<std::string> sqlStatements; + + // Check if the object is already known under that code + std::string datumAuthName; + std::string datumCode; + identifyFromNameOrCode(self, allAuthFactory, datum, datumAuthName, + datumCode); + if (datumAuthName == authName && datumCode == code) { + return {}; + } + + // Insert new record in vertical_datum table + const auto sql = formatStatement("INSERT INTO vertical_datum VALUES(" + "'%q','%q','%q','%q',NULL,NULL,NULL,0);", + authName.c_str(), code.c_str(), + datum->nameStr().c_str(), + "" // description + ); + appendSql(sqlStatements, sql); + + identifyOrInsertUsages(datum, "vertical_datum", authName, code, + sqlStatements); + + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const crs::VerticalCRSNNPtr &crs, const std::string &authName, + const std::string &code, bool numericCode) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + std::vector<std::string> sqlStatements; + + // Find or insert datum/datum ensemble + std::string datumAuthName; + std::string datumCode; + const auto &ensemble = crs->datumEnsemble(); + if (ensemble) { + identifyFromNameOrCode(self, allAuthFactory, NN_NO_CHECK(ensemble), + datumAuthName, datumCode); + if (datumAuthName.empty()) { + throw FactoryException( + "Unhandled yet: insertion of new DatumEnsemble"); + } + } else { + const auto &datum = crs->datum(); + assert(datum); + const auto datumNN = NN_NO_CHECK(datum); + identifyFromNameOrCode(self, allAuthFactory, datumNN, datumAuthName, + datumCode); + if (datumAuthName.empty()) { + datumAuthName = authName; + if (numericCode) { + datumCode = self->suggestsCodeFor(datumNN, datumAuthName, true); + } else { + datumCode = "VERTICAL_DATUM_" + code; + } + sqlStatements = self->getInsertStatementsFor( + datumNN, datumAuthName, datumCode, numericCode); + } + } + + // Find or insert coordinate system + const auto &coordinateSystem = crs->coordinateSystem(); + std::string csAuthName; + std::string csCode; + identifyOrInsert(self, coordinateSystem, "VERTICAL_CRS", authName, code, + csAuthName, csCode, sqlStatements); + + // Insert new record in vertical_crs table + const auto sql = + formatStatement("INSERT INTO vertical_crs VALUES(" + "'%q','%q','%q','%q','%q','%q','%q','%q',0);", + authName.c_str(), code.c_str(), crs->nameStr().c_str(), + "", // description + csAuthName.c_str(), csCode.c_str(), + datumAuthName.c_str(), datumCode.c_str()); + appendSql(sqlStatements, sql); + + identifyOrInsertUsages(crs, "vertical_crs", authName, code, sqlStatements); + + return sqlStatements; +} + +// --------------------------------------------------------------------------- + +std::vector<std::string> DatabaseContext::Private::getInsertStatementsFor( + const crs::CompoundCRSNNPtr &crs, const std::string &authName, + const std::string &code, bool numericCode) { + + const auto self = NN_NO_CHECK(self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + + std::vector<std::string> sqlStatements; + + int counter = 1; + std::vector<std::pair<std::string, std::string>> componentsId; + const auto &components = crs->componentReferenceSystems(); + if (components.size() != 2) { + throw FactoryException( + "Cannot insert compound CRS with number of components != 2"); + } + for (const auto &component : components) { + std::string compAuthName; + std::string compCode; + const auto candidates = component->identify(allAuthFactory); + for (const auto &candidate : candidates) { + if (candidate.second == 100) { + const auto &ids = candidate.first->identifiers(); + for (const auto &id : ids) { + compAuthName = *(id->codeSpace()); + compCode = id->code(); + break; + } + } + } + if (compAuthName.empty()) { + compAuthName = authName; + if (numericCode) { + compCode = self->suggestsCodeFor(component, compAuthName, true); + } else { + compCode = "COMPONENT_" + code + '_' + toString(counter); + } + const auto sqlStatementsTmp = self->getInsertStatementsFor( + component, compAuthName, compCode, numericCode); + sqlStatements.insert(sqlStatements.end(), sqlStatementsTmp.begin(), + sqlStatementsTmp.end()); + } + + componentsId.emplace_back( + std::pair<std::string, std::string>(compAuthName, compCode)); + + ++counter; + } + + // Insert new record in compound_crs table + const auto sql = formatStatement( + "INSERT INTO compound_crs VALUES(" + "'%q','%q','%q','%q','%q','%q','%q','%q',0);", + authName.c_str(), code.c_str(), crs->nameStr().c_str(), + "", // description + componentsId[0].first.c_str(), componentsId[0].second.c_str(), + componentsId[1].first.c_str(), componentsId[1].second.c_str()); + appendSql(sqlStatements, sql); + + identifyOrInsertUsages(crs, "compound_crs", authName, code, sqlStatements); + + return sqlStatements; +} + //! @endcond // --------------------------------------------------------------------------- //! @cond Doxygen_Suppress -DatabaseContext::~DatabaseContext() = default; +DatabaseContext::~DatabaseContext() { + try { + stopInsertStatementsSession(); + } catch (const std::exception &) { + } +} //! @endcond // --------------------------------------------------------------------------- @@ -945,11 +2172,14 @@ DatabaseContext::create(const std::string &databasePath, const std::vector<std::string> &auxiliaryDatabasePaths, PJ_CONTEXT *ctx) { auto dbCtx = DatabaseContext::nn_make_shared<DatabaseContext>(); - dbCtx->getPrivate()->open(databasePath, ctx); + auto dbCtxPrivate = dbCtx->getPrivate(); + dbCtxPrivate->open(databasePath, ctx); if (!auxiliaryDatabasePaths.empty()) { - dbCtx->getPrivate()->attachExtraDatabases(auxiliaryDatabasePaths); + dbCtxPrivate->attachExtraDatabases(auxiliaryDatabasePaths); + dbCtxPrivate->auxiliaryDatabasePaths_ = auxiliaryDatabasePaths; } - dbCtx->getPrivate()->checkDatabaseLayout(); + dbCtxPrivate->checkDatabaseLayout(); + dbCtxPrivate->self_ = dbCtx.as_nullable(); return dbCtx; } @@ -999,6 +2229,259 @@ const char *DatabaseContext::getMetadata(const char *key) const { // --------------------------------------------------------------------------- +/** \brief Starts a session for getInsertStatementsFor() + * + * Starts a new session for one or several calls to getInsertStatementsFor(). + * An insertion session guarantees that the inserted objects will not create + * conflicting intermediate objects. + * + * The session must be stopped with stopInsertStatementsSession(). + * + * Only one session may be active at a time for a given database context. + * + * @throw FactoryException + * @since 8.1 + */ +void DatabaseContext::startInsertStatementsSession() { + if (d->memoryDbHandle_) { + throw FactoryException( + "startInsertStatementsSession() cannot be invoked until " + "stopInsertStatementsSession() is."); + } + + // Create a in-memory temporary sqlite3 database + std::ostringstream buffer; + buffer << "file:temp_db_for_insert_statements_"; + buffer << this; + buffer << ".db?mode=memory&cache=shared"; + d->memoryDbForInsertPath_ = buffer.str(); + sqlite3_open_v2( + d->memoryDbForInsertPath_.c_str(), &d->memoryDbHandle_, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_URI, nullptr); + if (d->memoryDbHandle_ == nullptr) { + throw FactoryException("Cannot create in-memory database"); + } + + // Fill the structure of this database + const auto sqlStatements = getDatabaseStructure(); + for (const auto &sql : sqlStatements) { + if (sqlite3_exec(d->memoryDbHandle_, sql.c_str(), nullptr, nullptr, + nullptr) != SQLITE_OK) { + throw FactoryException("Cannot execute " + sql); + } + } + + // Attach this database to the current one(s) + auto auxiliaryDatabasePaths(d->auxiliaryDatabasePaths_); + auxiliaryDatabasePaths.push_back(d->memoryDbForInsertPath_); + d->attachExtraDatabases(auxiliaryDatabasePaths); +} + +// --------------------------------------------------------------------------- + +/** \brief Suggests a database code for the passed object. + * + * Supported type of objects are PrimeMeridian, Ellipsoid, Datum, DatumEnsemble, + * GeodeticCRS, ProjectedCRS, VerticalCRS, CompoundCRS, BoundCRS, Conversion. + * + * @param object Object for which to suggest a code. + * @param authName Authority name into which the object will be inserted. + * @param numericCode Whether the code should be numeric, or derived from the + * object name. + * @return the suggested code, that is guaranteed to not conflict with an + * existing one. + * + * @throw FactoryException + * @since 8.1 + */ +std::string +DatabaseContext::suggestsCodeFor(const common::IdentifiedObjectNNPtr &object, + const std::string &authName, + bool numericCode) { + const char *tableName = ""; + if (dynamic_cast<const datum::PrimeMeridian *>(object.get())) { + tableName = "prime_meridian"; + } else if (dynamic_cast<const datum::Ellipsoid *>(object.get())) { + tableName = "ellipsoid"; + } else if (dynamic_cast<const datum::GeodeticReferenceFrame *>( + object.get())) { + tableName = "geodetic_datum"; + } else if (dynamic_cast<const datum::VerticalReferenceFrame *>( + object.get())) { + tableName = "vertical_datum"; + } else if (const auto ensemble = + dynamic_cast<const datum::DatumEnsemble *>(object.get())) { + const auto &datums = ensemble->datums(); + if (!datums.empty() && + dynamic_cast<const datum::GeodeticReferenceFrame *>( + datums[0].get())) { + tableName = "geodetic_datum"; + } else { + tableName = "vertical_datum"; + } + } else if (const auto boundCRS = + dynamic_cast<const crs::BoundCRS *>(object.get())) { + return suggestsCodeFor(boundCRS->baseCRS(), authName, numericCode); + } else if (dynamic_cast<const crs::CRS *>(object.get())) { + tableName = "crs_view"; + } else if (dynamic_cast<const operation::Conversion *>(object.get())) { + tableName = "conversion"; + } else { + throw FactoryException("suggestsCodeFor(): unhandled type of object"); + } + + if (numericCode) { + std::string sql("SELECT MAX(code) FROM "); + sql += tableName; + sql += " WHERE auth_name = ? AND code >= '1' AND code <= '999999999' " + "AND upper(code) = lower(code)"; + const auto res = d->run(sql, {authName}); + if (res.empty()) { + return "1"; + } + return toString(atoi(res.front()[0].c_str()) + 1); + } + + std::string code; + code.reserve(object->nameStr().size()); + bool insertUnderscore = false; + for (const auto ch : toupper(object->nameStr())) { + if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z')) { + if (insertUnderscore && code.back() != '_') + code += '_'; + code += ch; + insertUnderscore = false; + } else { + insertUnderscore = true; + } + } + return d->findFreeCode(tableName, authName, code); +} + +// --------------------------------------------------------------------------- + +/** \brief Returns SQL statements needed to insert the passed object into the + * database. + * + * startInsertStatementsSession() must have been called previously. + * + * @param object The object to insert into the database. Currently only + * PrimeMeridian, Ellipsoid, Datum, GeodeticCRS, ProjectedCRS, + * VerticalCRS, CompoundCRS or BoundCRS are supported. + * @param authName Authority name into which the object will be inserted. + * @param code Code with which the object will be inserted. + * @param numericCode Whether intermediate objects that can be created should + * use numeric codes (true), or may be alphanumeric (false) + * @throw FactoryException + * @since 8.1 + */ +std::vector<std::string> DatabaseContext::getInsertStatementsFor( + const common::IdentifiedObjectNNPtr &object, const std::string &authName, + const std::string &code, bool numericCode) { + if (d->memoryDbHandle_ == nullptr) { + throw FactoryException( + "startInsertStatementsSession() should be invoked first"); + } + + const auto self = NN_NO_CHECK(d->self_.lock()); + const auto allAuthFactory = AuthorityFactory::create(self, std::string()); + const auto crs = util::nn_dynamic_pointer_cast<crs::CRS>(object); + if (crs) { + // Check if the object is already known under that code + const auto candidates = crs->identify(allAuthFactory); + for (const auto &candidate : candidates) { + if (candidate.second == 100) { + const auto &ids = candidate.first->identifiers(); + for (const auto &id : ids) { + if (*(id->codeSpace()) == authName && id->code() == code) { + return {}; + } + } + } + } + } + + if (const auto pm = + util::nn_dynamic_pointer_cast<datum::PrimeMeridian>(object)) { + return d->getInsertStatementsFor(NN_NO_CHECK(pm), authName, code, + numericCode); + } + + else if (const auto ellipsoid = + util::nn_dynamic_pointer_cast<datum::Ellipsoid>(object)) { + return d->getInsertStatementsFor(NN_NO_CHECK(ellipsoid), authName, code, + numericCode); + } + + else if (const auto geodeticDatum = + util::nn_dynamic_pointer_cast<datum::GeodeticReferenceFrame>( + object)) { + return d->getInsertStatementsFor(NN_NO_CHECK(geodeticDatum), authName, + code, numericCode); + } + + else if (const auto geodCRS = + std::dynamic_pointer_cast<crs::GeodeticCRS>(crs)) { + return d->getInsertStatementsFor(NN_NO_CHECK(geodCRS), authName, code, + numericCode); + } + + else if (const auto projCRS = + std::dynamic_pointer_cast<crs::ProjectedCRS>(crs)) { + return d->getInsertStatementsFor(NN_NO_CHECK(projCRS), authName, code, + numericCode); + } + + else if (const auto verticalDatum = + util::nn_dynamic_pointer_cast<datum::VerticalReferenceFrame>( + object)) { + return d->getInsertStatementsFor(NN_NO_CHECK(verticalDatum), authName, + code, numericCode); + } + + else if (const auto vertCRS = + std::dynamic_pointer_cast<crs::VerticalCRS>(crs)) { + return d->getInsertStatementsFor(NN_NO_CHECK(vertCRS), authName, code, + numericCode); + } + + else if (const auto compoundCRS = + std::dynamic_pointer_cast<crs::CompoundCRS>(crs)) { + return d->getInsertStatementsFor(NN_NO_CHECK(compoundCRS), authName, + code, numericCode); + } + + else if (const auto boundCRS = + std::dynamic_pointer_cast<crs::BoundCRS>(crs)) { + return getInsertStatementsFor(boundCRS->baseCRS(), authName, code, + numericCode); + } + + else { + throw FactoryException( + "getInsertStatementsFor(): unhandled type of object"); + } +} + +// --------------------------------------------------------------------------- + +/** \brief Stops an insertion session started with + * startInsertStatementsSession() + * + * @since 8.1 + */ +void DatabaseContext::stopInsertStatementsSession() { + if (d->memoryDbHandle_) { + d->clearCaches(); + d->attachExtraDatabases(d->auxiliaryDatabasePaths_); + sqlite3_close(d->memoryDbHandle_); + d->memoryDbHandle_ = nullptr; + d->memoryDbForInsertPath_.clear(); + } +} + +// --------------------------------------------------------------------------- + //! @cond Doxygen_Suppress DatabaseContextNNPtr DatabaseContext::create(void *sqlite_handle) { @@ -1518,7 +3001,12 @@ util::PropertyMap AuthorityFactory::Private::createPropertiesSearchUsages( "JOIN scope ON usage.scope_auth_name = scope.auth_name AND " "usage.scope_code = scope.code " "WHERE object_table_name = ? AND object_auth_name = ? AND " - "object_code = ? " + "object_code = ? AND " + // We voluntary exclude extent and scope with a specific code + "NOT (usage.extent_auth_name = 'PROJ' AND " + "usage.extent_code = 'EXTENT_UNKNOWN') AND " + "NOT (usage.scope_auth_name = 'PROJ' AND " + "usage.scope_code = 'SCOPE_UNKNOWN') " "ORDER BY score, usage.auth_name, usage.code"); auto res = run(sql, {table_name, authority(), code}); std::vector<ObjectDomainNNPtr> usages; @@ -2802,8 +4290,7 @@ AuthorityFactory::createConversion(const std::string &code) const { const size_t base_param_idx = idx; std::vector<operation::OperationParameterNNPtr> parameters; std::vector<operation::ParameterValueNNPtr> values; - constexpr int N_MAX_PARAMS = 7; - for (int i = 0; i < N_MAX_PARAMS; ++i) { + for (size_t i = 0; i < N_MAX_PARAMS; ++i) { const auto ¶m_auth_name = row[base_param_idx + i * 6 + 0]; if (param_auth_name.empty()) { break; @@ -3523,8 +5010,7 @@ operation::CoordinateOperationNNPtr AuthorityFactory::createCoordinateOperation( "target_crs_code, " "interpolation_crs_auth_name, interpolation_crs_code, " "operation_version, accuracy, deprecated"; - constexpr int N_MAX_PARAMS = 7; - for (int i = 1; i <= N_MAX_PARAMS; ++i) { + for (size_t i = 1; i <= N_MAX_PARAMS; ++i) { buffer << ", param" << i << "_auth_name"; buffer << ", param" << i << "_code"; buffer << ", param" << i << "_name"; @@ -3563,7 +5049,7 @@ operation::CoordinateOperationNNPtr AuthorityFactory::createCoordinateOperation( const size_t base_param_idx = idx; std::vector<operation::OperationParameterNNPtr> parameters; std::vector<operation::ParameterValueNNPtr> values; - for (int i = 0; i < N_MAX_PARAMS; ++i) { + for (size_t i = 0; i < N_MAX_PARAMS; ++i) { const auto ¶m_auth_name = row[base_param_idx + i * 6 + 0]; if (param_auth_name.empty()) { break; @@ -1180,8 +1180,32 @@ PROJ_UNIT_INFO PROJ_DLL **proj_get_units_from_database( void PROJ_DLL proj_unit_list_destroy(PROJ_UNIT_INFO** list); /* ------------------------------------------------------------------------- */ +/*! @cond Doxygen_Suppress */ +typedef struct PJ_INSERT_SESSION PJ_INSERT_SESSION; +/*! @endcond */ + +PJ_INSERT_SESSION PROJ_DLL *proj_insert_object_session_create(PJ_CONTEXT *ctx); + +void PROJ_DLL proj_insert_object_session_destroy(PJ_CONTEXT *ctx, + PJ_INSERT_SESSION *session); +PROJ_STRING_LIST PROJ_DLL proj_get_insert_statements(PJ_CONTEXT *ctx, + PJ_INSERT_SESSION *session, + const PJ *object, + const char *authority, + const char *code, + int numeric_codes, + const char *const *options); +char PROJ_DLL *proj_suggests_code_for(PJ_CONTEXT *ctx, + const PJ *object, + const char *authority, + int numeric_code, + const char *const *options); + +void PROJ_DLL proj_string_destroy(char* str); + +/* ------------------------------------------------------------------------- */ /*! @cond Doxygen_Suppress */ typedef struct PJ_OPERATION_FACTORY_CONTEXT PJ_OPERATION_FACTORY_CONTEXT; /*! @endcond */ diff --git a/test/unit/test_c_api.cpp b/test/unit/test_c_api.cpp index 1b08e884..120f8627 100644 --- a/test/unit/test_c_api.cpp +++ b/test/unit/test_c_api.cpp @@ -5227,4 +5227,92 @@ TEST_F(CApi, proj_crs_is_derived) { } } +// --------------------------------------------------------------------------- + +TEST_F(CApi, proj_suggests_code_for) { + { + auto session = proj_insert_object_session_create(nullptr); + EXPECT_NE(session, nullptr); + + EXPECT_EQ(proj_insert_object_session_create(nullptr), nullptr); + + proj_insert_object_session_destroy(nullptr, session); + } + + { proj_insert_object_session_destroy(nullptr, nullptr); } + { + auto wkt = "GEOGCRS[\"myGDA2020\",\n" + " DATUM[\"GDA2020\",\n" + " ELLIPSOID[\"GRS_1980\",6378137,298.257222101,\n" + " LENGTHUNIT[\"metre\",1]]],\n" + " PRIMEM[\"Greenwich\",0,\n" + " ANGLEUNIT[\"Degree\",0.0174532925199433]],\n" + " CS[ellipsoidal,2],\n" + " AXIS[\"geodetic latitude (Lat)\",north,\n" + " ORDER[1],\n" + " ANGLEUNIT[\"degree\",0.0174532925199433]],\n" + " AXIS[\"geodetic longitude (Lon)\",east,\n" + " ORDER[2],\n" + " ANGLEUNIT[\"degree\",0.0174532925199433]]]"; + auto crs = proj_create_from_wkt(m_ctxt, wkt, nullptr, nullptr, nullptr); + ObjectKeeper keeper_from_wkt(crs); + EXPECT_NE(crs, nullptr); + + { + char *code = + proj_suggests_code_for(m_ctxt, crs, "HOBU", false, nullptr); + ASSERT_NE(code, nullptr); + EXPECT_EQ(std::string(code), "MYGDA2020"); + proj_string_destroy(code); + } + + { + char *code = + proj_suggests_code_for(m_ctxt, crs, "HOBU", true, nullptr); + ASSERT_NE(code, nullptr); + EXPECT_EQ(std::string(code), "1"); + proj_string_destroy(code); + } + + // No session specified: we use a temporary session + for (int i = 0; i < 2; i++) { + auto list = proj_get_insert_statements(m_ctxt, nullptr, crs, "HOBU", + "XXXX", false, nullptr); + ASSERT_NE(list, nullptr); + ASSERT_NE(list[0], nullptr); + EXPECT_EQ(std::string(list[0]), + "INSERT INTO geodetic_datum VALUES('HOBU'," + "'GEODETIC_DATUM_XXXX','GDA2020','','EPSG','7019'," + "'EPSG','8901',NULL,NULL,NULL,0);"); + proj_string_list_destroy(list); + } + + auto session = proj_insert_object_session_create(m_ctxt); + EXPECT_NE(session, nullptr); + + { + auto list = proj_get_insert_statements(m_ctxt, session, crs, "HOBU", + "XXXX", false, nullptr); + ASSERT_NE(list, nullptr); + ASSERT_NE(list[0], nullptr); + EXPECT_EQ(std::string(list[0]), + "INSERT INTO geodetic_datum VALUES('HOBU'," + "'GEODETIC_DATUM_XXXX','GDA2020','','EPSG','7019'," + "'EPSG','8901',NULL,NULL,NULL,0);"); + proj_string_list_destroy(list); + } + + // Object already inserted: return empty list + { + auto list = proj_get_insert_statements(m_ctxt, session, crs, "HOBU", + "XXXX", false, nullptr); + ASSERT_NE(list, nullptr); + ASSERT_EQ(list[0], nullptr); + proj_string_list_destroy(list); + } + + proj_insert_object_session_destroy(m_ctxt, session); + } +} + } // namespace diff --git a/test/unit/test_factory.cpp b/test/unit/test_factory.cpp index 454e4f2e..55378134 100644 --- a/test/unit/test_factory.cpp +++ b/test/unit/test_factory.cpp @@ -3434,4 +3434,577 @@ TEST(factory, getUnitList) { } } +// --------------------------------------------------------------------------- + +TEST(factory, objectInsertion) { + + // Cannot nest startInsertStatementsSession + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + EXPECT_THROW(ctxt->startInsertStatementsSession(), FactoryException); + } + + { + auto ctxt = DatabaseContext::create(); + // Tolerated withtout explicit stop + ctxt->startInsertStatementsSession(); + } + + { + auto ctxt = DatabaseContext::create(); + // Tolerated + ctxt->stopInsertStatementsSession(); + } + + // getInsertStatementsFor() must be preceded with + // startInsertStatementsSession() + { + auto ctxt = DatabaseContext::create(); + EXPECT_THROW(ctxt->getInsertStatementsFor(GeographicCRS::EPSG_4326, + "EPSG", "4326", true), + FactoryException); + } + + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + // Nothing to do + EXPECT_TRUE(ctxt->getInsertStatementsFor(GeographicCRS::EPSG_4326, + "EPSG", "4326", true) + .empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + GeographicCRS::EPSG_4326->datum(), + GeographicCRS::EPSG_4326->datumEnsemble(), + GeographicCRS::EPSG_4326->coordinateSystem()); + + EXPECT_EQ(ctxt->suggestsCodeFor(crs, "HOBU", true), "1"); + EXPECT_EQ(ctxt->suggestsCodeFor(crs, "HOBU", false), "MY_EPSG_4326"); + + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "1234", true); + + EXPECT_EQ(ctxt->suggestsCodeFor(crs, "HOBU", true), "1235"); + + ASSERT_EQ(sql.size(), 2U); + EXPECT_EQ(sql[0], "INSERT INTO geodetic_crs VALUES('HOBU','1234','my " + "EPSG:4326','','geographic " + "2D','EPSG','6422','EPSG','6326',NULL,0);"); + EXPECT_EQ( + sql[1], + "INSERT INTO usage " + "VALUES('HOBU','USAGE_GEODETIC_CRS_1234','geodetic_crs','HOBU','" + "1234','PROJ','EXTENT_UNKNOWN','PROJ','SCOPE_UNKNOWN');"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "1234", true).empty()); + ctxt->stopInsertStatementsSession(); + AuthorityFactory::create(ctxt, std::string("EPSG")) + ->createGeographicCRS("4326"); + EXPECT_THROW(AuthorityFactory::create(ctxt, std::string("HOBU")) + ->createGeographicCRS("1234"), + NoSuchAuthorityCodeException); + } + + // Geographic 3D CRS, with known usage + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto usages = AuthorityFactory::create(ctxt, std::string("EPSG")) + ->createGeographicCRS("4979") + ->domains(); + auto array(ArrayOfBaseObject::create()); + for (const auto &usage : usages) { + array->add(usage); + } + auto props = + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4979"); + props.set(ObjectUsage::OBJECT_DOMAIN_KEY, + nn_static_pointer_cast<BaseObject>(array)); + const auto crs = + GeographicCRS::create(props, GeographicCRS::EPSG_4979->datum(), + GeographicCRS::EPSG_4979->datumEnsemble(), + GeographicCRS::EPSG_4979->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "4979", false); + ASSERT_EQ(sql.size(), 2U); + EXPECT_EQ(sql[0], "INSERT INTO geodetic_crs VALUES('HOBU','4979','my " + "EPSG:4979','','geographic " + "3D','EPSG','6423','EPSG','6326',NULL,0);"); + EXPECT_EQ( + sql[1], + "INSERT INTO usage " + "VALUES('HOBU','USAGE_GEODETIC_CRS_4979','geodetic_crs','HOBU','" + "4979','EPSG','1262','EPSG','1176');"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "4979", false).empty()); + ctxt->stopInsertStatementsSession(); + } + + // BoundCRS of Geocentric CRS, with new usage + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + auto props = + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4978"); + auto array(ArrayOfBaseObject::create()); + const auto extent = Extent::createFromBBOX(1, 2, 3, 4); + optional<std::string> scope; + scope = "my scope"; + array->add(ObjectDomain::create(scope, extent)); + props.set(ObjectUsage::OBJECT_DOMAIN_KEY, + nn_static_pointer_cast<BaseObject>(array)); + const auto crs = GeodeticCRS::create( + props, NN_NO_CHECK(GeodeticCRS::EPSG_4978->datum()), + NN_NO_CHECK(nn_dynamic_pointer_cast<CartesianCS>( + GeodeticCRS::EPSG_4978->coordinateSystem()))); + const auto boundCRS = BoundCRS::createFromTOWGS84( + crs, std::vector<double>{1, 2, 3, 4, 5, 6, 7}); + const auto sql = + ctxt->getInsertStatementsFor(boundCRS, "HOBU", "4978", false); + ASSERT_EQ(sql.size(), 4U); + EXPECT_EQ( + sql[0], + "INSERT INTO geodetic_crs VALUES('HOBU','4978','my " + "EPSG:4978','','geocentric','EPSG','6500','EPSG','6326',NULL,0);"); + EXPECT_EQ(sql[1], + "INSERT INTO scope VALUES('HOBU','SCOPE_geodetic_crs_4978'," + "'my scope',0);"); + EXPECT_EQ(sql[2], + "INSERT INTO extent VALUES('HOBU','EXTENT_geodetic_crs_4978'," + "'unknown','unknown',2,4,1,3,0);"); + EXPECT_EQ( + sql[3], + "INSERT INTO usage VALUES('HOBU','USAGE_GEODETIC_CRS_4978'," + "'geodetic_crs','HOBU','4978','HOBU'," + "'EXTENT_geodetic_crs_4978','HOBU','SCOPE_geodetic_crs_4978');"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(boundCRS, "HOBU", "4978", false) + .empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS with unknown datum, numeric code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto datum = GeodeticReferenceFrame::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my datum"), + Ellipsoid::WGS84, optional<std::string>(), + PrimeMeridian::GREENWICH); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + datum, GeographicCRS::EPSG_4326->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true); + ASSERT_EQ(sql.size(), 4U); + EXPECT_EQ(sql[0], + "INSERT INTO geodetic_datum VALUES('HOBU','1','my " + "datum','','EPSG','7030','EPSG','8901',NULL,NULL,NULL,0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS with unknown datum, alpha code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto datum = GeodeticReferenceFrame::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my datum"), + Ellipsoid::WGS84, optional<std::string>(), + PrimeMeridian::GREENWICH); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + datum, GeographicCRS::EPSG_4326->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "MY_EPSG_4326", false); + + EXPECT_EQ(ctxt->suggestsCodeFor(crs, "HOBU", false), "MY_EPSG_4326_2"); + + ASSERT_EQ(sql.size(), 4U); + EXPECT_EQ(sql[0], + "INSERT INTO geodetic_datum " + "VALUES('HOBU','GEODETIC_DATUM_MY_EPSG_4326','my " + "datum','','EPSG','7030','EPSG','8901',NULL,NULL,NULL,0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "MY_EPSG_4326", false) + .empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS with unknown ellipsoid, numeric code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto ellipsoid = Ellipsoid::createFlattenedSphere( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my ellipsoid"), + Length(6378137), Scale(295)); + const auto datum = GeodeticReferenceFrame::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my datum"), + ellipsoid, optional<std::string>(), PrimeMeridian::GREENWICH); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + datum, GeographicCRS::EPSG_4326->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true); + ASSERT_EQ(sql.size(), 5U); + EXPECT_EQ( + sql[0], + "INSERT INTO ellipsoid VALUES('HOBU','1','my " + "ellipsoid','','PROJ','EARTH',6378137,'EPSG','9001',295,NULL,0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS with unknown ellipsoid, alpha code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto ellipsoid = Ellipsoid::createTwoAxis( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my ellipsoid"), + Length(6378137), Length(6378136)); + const auto datum = GeodeticReferenceFrame::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my datum"), + ellipsoid, optional<std::string>(), PrimeMeridian::GREENWICH); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + datum, GeographicCRS::EPSG_4326->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", false); + ASSERT_EQ(sql.size(), 5U); + EXPECT_EQ(sql[0], "INSERT INTO ellipsoid " + "VALUES('HOBU','ELLPS_GEODETIC_DATUM_XXXX','my " + "ellipsoid','','PROJ','EARTH',6378137,'EPSG','9001'," + "NULL,6378136,0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", false).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS with unknown prime meridian, numeric code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto pm = PrimeMeridian::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "My meridian"), + Angle(10)); + const auto datum = GeodeticReferenceFrame::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my datum"), + Ellipsoid::WGS84, optional<std::string>(), pm); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + datum, GeographicCRS::EPSG_4326->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true); + ASSERT_EQ(sql.size(), 5U); + EXPECT_EQ(sql[0], "INSERT INTO prime_meridian VALUES('HOBU','1','My " + "meridian',10,'EPSG','9122',0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Geographic 2D CRS with unknown prime meridian, alpha code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto pm = PrimeMeridian::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "My meridian"), + Angle(10)); + const auto datum = GeodeticReferenceFrame::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my datum"), + Ellipsoid::WGS84, optional<std::string>(), pm); + const auto crs = GeographicCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my EPSG:4326"), + datum, GeographicCRS::EPSG_4326->coordinateSystem()); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", false); + ASSERT_EQ(sql.size(), 5U); + EXPECT_EQ(sql[0], "INSERT INTO prime_meridian " + "VALUES('HOBU','PM_GEODETIC_DATUM_XXXX','My " + "meridian',10,'EPSG','9122',0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", false).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Projected CRS, numeric code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto crs = ProjectedCRS::create( + PropertyMap().set(IdentifiedObject::NAME_KEY, "my projected CRS"), + GeographicCRS::EPSG_4807, + Conversion::createUTM(PropertyMap(), 31, true), + CartesianCS::createEastingNorthing(UnitOfMeasure::METRE)); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true); + ASSERT_EQ(sql.size(), 4U); + EXPECT_EQ(sql[0], + "INSERT INTO conversion VALUES('HOBU','1'," + "'UTM zone 31N',''," + "'EPSG','9807','Transverse Mercator'," + "'EPSG','8801','Latitude of natural origin',0,'EPSG','9122'," + "'EPSG','8802','Longitude of natural origin',3,'EPSG','9122'," + "'EPSG','8805','Scale factor at natural origin',0.9996," + "'EPSG','9201'," + "'EPSG','8806','False easting',500000,'EPSG','9001'," + "'EPSG','8807','False northing',0,'EPSG','9001'," + "NULL,NULL,NULL,NULL,NULL,NULL," + "NULL,NULL,NULL,NULL,NULL,NULL,0);"); + EXPECT_EQ(sql[1], + "INSERT INTO usage " + "VALUES('HOBU','USAGE_CONVERSION_1','conversion','HOBU','1','" + "PROJ','EXTENT_UNKNOWN','PROJ','SCOPE_UNKNOWN');"); + EXPECT_EQ( + sql[2], + "INSERT INTO projected_crs VALUES('HOBU','XXXX','my projected " + "CRS','','EPSG','4400','EPSG','4807','HOBU','1',NULL,0);"); + EXPECT_EQ( + sql[3], + "INSERT INTO usage " + "VALUES('HOBU','USAGE_PROJECTED_CRS_XXXX','projected_crs','HOBU','" + "XXXX','PROJ','EXTENT_UNKNOWN','PROJ','SCOPE_UNKNOWN');"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Vertical CRS, known vertical datum, numeric code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + PropertyMap propertiesVDatum; + propertiesVDatum.set(Identifier::CODESPACE_KEY, "EPSG") + .set(Identifier::CODE_KEY, 5101) + .set(IdentifiedObject::NAME_KEY, "Ordnance Datum Newlyn"); + auto vdatum = VerticalReferenceFrame::create(propertiesVDatum); + PropertyMap propertiesCRS; + propertiesCRS.set(IdentifiedObject::NAME_KEY, "my height"); + const auto uom = + UnitOfMeasure("my unit", 3.0, UnitOfMeasure::Type::LINEAR); + const auto crs = VerticalCRS::create( + propertiesCRS, vdatum, VerticalCS::createGravityRelatedHeight(uom)); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true); + ASSERT_EQ(sql.size(), 5U); + EXPECT_EQ(sql[0], "INSERT INTO coordinate_system VALUES" + "('HOBU','CS_VERTICAL_CRS_XXXX','vertical',1);"); + EXPECT_EQ(sql[1], "INSERT INTO unit_of_measure VALUES" + "('HOBU','MY_UNIT','my unit','length',3,NULL,0);"); + EXPECT_EQ(sql[2], + "INSERT INTO axis VALUES('HOBU'," + "'CS_VERTICAL_CRS_XXXX_AXIS_1','Gravity-related height','H'," + "'up','HOBU','CS_VERTICAL_CRS_XXXX',1,'HOBU','MY_UNIT');"); + EXPECT_EQ(sql[3], + "INSERT INTO vertical_crs VALUES('HOBU','XXXX','my height'," + "'','HOBU','CS_VERTICAL_CRS_XXXX','EPSG','5101',0);"); + EXPECT_EQ(sql[4], + "INSERT INTO usage VALUES('HOBU','USAGE_VERTICAL_CRS_XXXX'," + "'vertical_crs','HOBU','XXXX','PROJ','EXTENT_UNKNOWN'," + "'PROJ','SCOPE_UNKNOWN');"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", true).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Vertical CRS, unknown vertical datum, alpha code + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + PropertyMap propertiesVDatum; + propertiesVDatum.set(IdentifiedObject::NAME_KEY, "my datum"); + auto vdatum = VerticalReferenceFrame::create(propertiesVDatum); + PropertyMap propertiesCRS; + propertiesCRS.set(IdentifiedObject::NAME_KEY, "my height"); + const auto crs = VerticalCRS::create( + propertiesCRS, vdatum, + VerticalCS::createGravityRelatedHeight(UnitOfMeasure::METRE)); + const auto sql = + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", false); + ASSERT_EQ(sql.size(), 4U); + EXPECT_EQ(sql[0], + "INSERT INTO vertical_datum VALUES('HOBU'," + "'VERTICAL_DATUM_XXXX','my datum','',NULL,NULL,NULL,0);"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), IComparable::Criterion::EQUIVALENT)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE( + ctxt->getInsertStatementsFor(crs, "HOBU", "XXXX", false).empty()); + ctxt->stopInsertStatementsSession(); + } + + // Compound CRS + { + auto ctxt = DatabaseContext::create(); + ctxt->startInsertStatementsSession(); + const auto wkt = + "COMPD_CS[\"unknown\"," + "PROJCS[\"NAD_1983_2011_StatePlane_South_Carolina_FIPS_3900_USFT\"," + "GEOGCS[\"NAD83(2011)\"," + "DATUM[\"NAD83_National_Spatial_Reference_System_2011\"," + "SPHEROID[\"GRS 1980\",6378137,298.257222101004," + "AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"1116\"]]," + "PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433," + "AUTHORITY[\"EPSG\",\"9122\"]]]," + "PROJECTION[\"Lambert_Conformal_Conic_2SP\"]," + "PARAMETER[\"latitude_of_origin\",31.8333333333333]," + "PARAMETER[\"central_meridian\",-81]," + "PARAMETER[\"standard_parallel_1\",32.5]," + "PARAMETER[\"standard_parallel_2\",34.8333333333333]," + "PARAMETER[\"false_easting\",1999996]," + "PARAMETER[\"false_northing\",0]," + "UNIT[\"US survey foot\",0.304800609601219," + "AUTHORITY[\"EPSG\",\"9003\"]]," + "AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]," + "VERT_CS[\"NAVD88 height (ftUS)\"," + "VERT_DATUM[\"North American Vertical Datum 1988\",2005," + "AUTHORITY[\"EPSG\",\"5103\"]]," + "UNIT[\"US survey foot\",0.304800609601219," + "AUTHORITY[\"EPSG\",\"9003\"]]," + "AXIS[\"Up\",UP],AUTHORITY[\"EPSG\",\"6360\"]]]"; + const auto crs = + nn_dynamic_pointer_cast<CRS>(WKTParser().createFromWKT(wkt)); + ASSERT_TRUE(crs != nullptr); + const auto sql = ctxt->getInsertStatementsFor(NN_NO_CHECK(crs), "HOBU", + "XXXX", false); + ASSERT_EQ(sql.size(), 6U); + EXPECT_EQ(sql[4], + "INSERT INTO compound_crs VALUES('HOBU','XXXX','unknown'," + "'','HOBU','COMPONENT_XXXX_1','EPSG','6360',0);"); + EXPECT_EQ(sql[5], + "INSERT INTO usage VALUES('HOBU','USAGE_COMPOUND_CRS_XXXX'," + "'compound_crs','HOBU','XXXX','PROJ','EXTENT_UNKNOWN'," + "'PROJ','SCOPE_UNKNOWN');"); + const auto identified = + crs->identify(AuthorityFactory::create(ctxt, std::string())); + ASSERT_EQ(identified.size(), 1U); + EXPECT_EQ( + *(identified.front().first->identifiers().front()->codeSpace()), + "HOBU"); + EXPECT_TRUE(identified.front().first->isEquivalentTo( + crs.get(), + IComparable::Criterion::EQUIVALENT_EXCEPT_AXIS_ORDER_GEOGCRS)); + EXPECT_EQ(identified.front().second, 100); + EXPECT_TRUE(ctxt->getInsertStatementsFor(NN_NO_CHECK(crs), "HOBU", + "XXXX", false) + .empty()); + ctxt->stopInsertStatementsSession(); + } +} + } // namespace |