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

 *

 * Project:  GeoPackage Translator

 * Purpose:  Implements OGRGeoPackageTableLayer class

 * Author:   Paul Ramsey <pramsey@boundlessgeo.com>

 *

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

 * Copyright (c) 2013, Paul Ramsey <pramsey@boundlessgeo.com>

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

 *

 * SPDX-License-Identifier: MIT

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

#include "ogr_geopackage.h"

#include "ogrgeopackageutility.h"

#include "ogrlayerarrow.h"

#include "ogrsqliteutility.h"

#include "cpl_md5.h"

#include "cpl_multiproc.h"  // CPLSleep()

#include "cpl_time.h"

#include "ogr_p.h"

#include "sqlite_rtree_bulk_load/wrapper.h"

#include "gdal_priv_templates.hpp"

#include <algorithm>

#include <cassert>

#include <cerrno>

#include <cinttypes>

#include <climits>

#include <cmath>

#include <limits>

#include <mutex>

#undef SQLITE_STATIC

#define SQLITE_STATIC static_cast<sqlite3_destructor_type>(nullptr)

#undef SQLITE_TRANSIENT

#define SQLITE_TRANSIENT reinterpret_cast<sqlite3_destructor_type>(-1)

static const char UNSUPPORTED_OP_READ_ONLY[] =

    "%s : unsupported operation on a read-only datasource.";

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

// SaveExtent()

//

// Write the current contents of the layer envelope down to the

// gpkg_contents metadata table.

//

OGRErr OGRGeoPackageTableLayer::SaveExtent()

{

    if (!m_poDS->GetUpdate() || !m_bExtentChanged || !m_poExtent)

        return OGRERR_NONE;

    sqlite3 *poDb = m_poDS->GetDB();

    if (!poDb)

        return OGRERR_FAILURE;

    char *pszSQL =

        sqlite3_mprintf("UPDATE gpkg_contents SET "

                        "min_x = %.17g, min_y = %.17g, "

                        "max_x = %.17g, max_y = %.17g "

                        "WHERE lower(table_name) = lower('%q') AND "

                        "Lower(data_type) = 'features'",

                        m_poExtent->MinX, m_poExtent->MinY, m_poExtent->MaxX,

                        m_poExtent->MaxY, m_pszTableName);

    OGRErr err = SQLCommand(poDb, pszSQL);

    sqlite3_free(pszSQL);

    m_bExtentChanged = false;

    return err;

}

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

// SaveTimestamp()

//

// Update the last_change column of the gpkg_contents metadata table.

//

OGRErr OGRGeoPackageTableLayer::SaveTimestamp()

{

    if (!m_poDS->GetUpdate() || !m_bContentChanged)

        return OGRERR_NONE;

    m_bContentChanged = false;

    OGRErr err = m_poDS->UpdateGpkgContentsLastChange(m_pszTableName);

#ifdef ENABLE_GPKG_OGR_CONTENTS

    if (m_bIsTable && err == OGRERR_NONE && m_poDS->m_bHasGPKGOGRContents &&

        !m_bOGRFeatureCountTriggersEnabled && m_nTotalFeatureCount >= 0)

    {

        CPLString osFeatureCount;

        osFeatureCount.Printf(CPL_FRMT_GIB, m_nTotalFeatureCount);

        char *pszSQL = sqlite3_mprintf("UPDATE gpkg_ogr_contents SET "

                                       "feature_count = %s "

                                       "WHERE lower(table_name) = lower('%q')",

                                       osFeatureCount.c_str(), m_pszTableName);

        err = SQLCommand(m_poDS->GetDB(), pszSQL);

        sqlite3_free(pszSQL);

    }

#endif

    return err;

}

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

// UpdateExtent()

//

// Expand the layer envelope if necessary to reflect the bounds

// of new features being added to the layer.

//

OGRErr OGRGeoPackageTableLayer::UpdateExtent(const OGREnvelope *poExtent)

{

    if (!m_poExtent)

    {

        m_poExtent = std::make_unique<OGREnvelope>(*poExtent);

    }

    m_poExtent->Merge(*poExtent);

    m_bExtentChanged = true;

    return OGRERR_NONE;

}

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

// BuildColumns()

//

// Save a list of columns (fid, geometry, attributes) suitable

// for use in a SELECT query that retrieves all fields.

//

OGRErr OGRGeoPackageTableLayer::BuildColumns()

{

    if (m_bDeferredCreation && RunDeferredCreationIfNecessary() != OGRERR_NONE)

        return OGRERR_FAILURE;

    if (!m_bFeatureDefnCompleted)

        GetLayerDefn();

    m_anFieldOrdinals.resize(m_poFeatureDefn->GetFieldCount());

    int iCurCol = 0;

    /* Always start with a primary key */

    CPLString soColumns;

    if (m_bIsTable || m_pszFidColumn != nullptr)

    {

        soColumns += "m.";

        soColumns += m_pszFidColumn

                         ? "\"" + SQLEscapeName(m_pszFidColumn) + "\""

                         : "_rowid_";

        m_iFIDCol = iCurCol;

        iCurCol++;

    }

    /* Add a geometry column if there is one (just one) */

    if (m_poFeatureDefn->GetGeomFieldCount())

    {

        const auto poFieldDefn = m_poFeatureDefn->GetGeomFieldDefn(0);

        if (poFieldDefn->IsIgnored())

        {

            m_iGeomCol = -1;

        }

        else

        {

            if (!soColumns.empty())

                soColumns += ", ";

            soColumns += "m.\"";

            soColumns += SQLEscapeName(poFieldDefn->GetNameRef());

            soColumns += "\"";

            m_iGeomCol = iCurCol;

            iCurCol++;

        }

    }

    /* Add all the attribute columns */

    for (int i = 0; i < m_poFeatureDefn->GetFieldCount(); i++)

    {

        const auto poFieldDefn = m_poFeatureDefn->GetFieldDefn(i);

        if (poFieldDefn->IsIgnored())

        {

            m_anFieldOrdinals[i] = -1;

        }

        else

        {

            if (!soColumns.empty())

                soColumns += ", ";

            soColumns += "m.\"";

            soColumns += SQLEscapeName(poFieldDefn->GetNameRef());

            soColumns += "\"";

            m_anFieldOrdinals[i] = iCurCol;

            iCurCol++;

        }

    }

    if (soColumns.empty())

    {

        // Can happen if ignoring all fields on a view...

        soColumns = "NULL";

    }

    m_soColumns = std::move(soColumns);

    return OGRERR_NONE;

}

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

// IsGeomFieldSet()

//

// Utility method to determine if there is a non-Null geometry

// in an OGRGeometry.

//

bool OGRGeoPackageTableLayer::IsGeomFieldSet(OGRFeature *poFeature)

{

    return poFeature->GetDefnRef()->GetGeomFieldCount() &&

           poFeature->GetGeomFieldRef(0);

}

OGRErr OGRGeoPackageTableLayer::FeatureBindParameters(

    OGRFeature *poFeature, sqlite3_stmt *poStmt, int *pnColCount, bool bAddFID,

    bool bBindUnsetFields, int nUpdatedFieldsCount,

    const int *panUpdatedFieldsIdx, int nUpdatedGeomFieldsCount,

    const int * /*panUpdatedGeomFieldsIdx*/)

{

    const OGRFeatureDefn *poFeatureDefn = poFeature->GetDefnRef();

    int nColCount = 1;

    if (bAddFID)

    {

        int err = sqlite3_bind_int64(poStmt, nColCount++, poFeature->GetFID());

        if (err != SQLITE_OK)

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "sqlite3_bind_int64() failed");

            return OGRERR_FAILURE;

        }

    }

    // Bind data values to the statement, here bind the blob for geometry.

    // We bind only if there's a geometry column (poFeatureDefn->GetGeomFieldCount() > 0)

    // and if we are:

    // - either in CreateFeature/SetFeature mode: nUpdatedGeomFieldsCount < 0

    // - or in UpdateFeature mode with nUpdatedGeomFieldsCount == 1, which

    //   implicitly involves that panUpdatedGeomFieldsIdx[0] == 0, so we don't

    //   need to test this condition.

    if ((nUpdatedGeomFieldsCount < 0 || nUpdatedGeomFieldsCount == 1) &&

        poFeatureDefn->GetGeomFieldCount())

    {

        // Non-NULL geometry.

        OGRGeometry *poGeom = poFeature->GetGeomFieldRef(0);

        if (poGeom)

        {

            size_t szWkb = 0;

            GByte *pabyWkb = GPkgGeometryFromOGR(poGeom, m_iSrs,

                                                 &m_sBinaryPrecision, &szWkb);

            if (!pabyWkb)

                return OGRERR_FAILURE;

            int err = sqlite3_bind_blob(poStmt, nColCount++, pabyWkb,

                                        static_cast<int>(szWkb), CPLFree);

            if (err != SQLITE_OK)

            {

                if (err == SQLITE_TOOBIG)

                {

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "sqlite3_bind_blob() failed: too big");

                }

                else

                {

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "sqlite3_bind_blob() failed");

                }

                return OGRERR_FAILURE;

            }

            CreateGeometryExtensionIfNecessary(poGeom);

        }

        /* NULL geometry */

        else

        {

            int err = sqlite3_bind_null(poStmt, nColCount++);

            if (err != SQLITE_OK)

            {

                CPLError(CE_Failure, CPLE_AppDefined,

                         "sqlite3_bind_null() failed");

                return OGRERR_FAILURE;

            }

        }

    }

    /* Bind the attributes using appropriate SQLite data types */

    const int nFieldCount = poFeatureDefn->GetFieldCount();

    size_t nInsertionBufferPos = 0;

    if (m_osInsertionBuffer.empty())

        m_osInsertionBuffer.resize(OGR_SIZEOF_ISO8601_DATETIME_BUFFER *

                                   nFieldCount);

    for (int idx = 0;

         idx < (nUpdatedFieldsCount < 0 ? nFieldCount : nUpdatedFieldsCount);

         idx++)

    {

        const int iField =

            nUpdatedFieldsCount < 0 ? idx : panUpdatedFieldsIdx[idx];

        assert(iField >= 0);

        const auto &oFieldDefn = poFeatureDefn->GetFieldDefn(iField);

        if (iField == m_iFIDAsRegularColumnIndex || oFieldDefn->IsGenerated())

            continue;

        if (!poFeature->IsFieldSetUnsafe(iField))

        {

            if (bBindUnsetFields)

            {

                int err = sqlite3_bind_null(poStmt, nColCount++);

                if (err != SQLITE_OK)

                {

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "sqlite3_bind_null() failed");

                    return OGRERR_FAILURE;

                }

            }

            continue;

        }

        const OGRFieldDefn *poFieldDefn =

            poFeatureDefn->GetFieldDefnUnsafe(iField);

        int err = SQLITE_OK;

        if (!poFeature->IsFieldNullUnsafe(iField))

        {

            const auto eType = poFieldDefn->GetType();

            switch (eType)

            {

                case OFTInteger:

                {

                    err = sqlite3_bind_int(

                        poStmt, nColCount++,

                        poFeature->GetFieldAsIntegerUnsafe(iField));

                    break;

                }

                case OFTInteger64:

                {

                    err = sqlite3_bind_int64(

                        poStmt, nColCount++,

                        poFeature->GetFieldAsInteger64Unsafe(iField));

                    break;

                }

                case OFTReal:

                {

                    err = sqlite3_bind_double(

                        poStmt, nColCount++,

                        poFeature->GetFieldAsDoubleUnsafe(iField));

                    break;

                }

                case OFTBinary:

                {

                    int szBlob = 0;

                    GByte *pabyBlob =

                        poFeature->GetFieldAsBinary(iField, &szBlob);

                    err = sqlite3_bind_blob(poStmt, nColCount++, pabyBlob,

                                            szBlob, SQLITE_STATIC);

                    break;

                }

                default:

                {

                    const char *pszVal = "";

                    CPL_IGNORE_RET_VAL(pszVal);  // Make CSA happy

                    int nValLengthBytes = -1;

                    sqlite3_destructor_type destructorType = SQLITE_TRANSIENT;

                    if (eType == OFTDate)

                    {

                        destructorType = SQLITE_STATIC;

                        const auto psFieldRaw =

                            poFeature->GetRawFieldRef(iField);

                        char *pszValEdit =

                            &m_osInsertionBuffer[nInsertionBufferPos];

                        pszVal = pszValEdit;

                        if (psFieldRaw->Date.Year < 0 ||

                            psFieldRaw->Date.Year >= 10000)

                        {

                            CPLError(

                                CE_Failure, CPLE_AppDefined,

                                "OGRGetISO8601DateTime(): year %d unsupported ",

                                psFieldRaw->Date.Year);

                            nValLengthBytes = 0;

                        }

                        else

                        {

                            int nYear = psFieldRaw->Date.Year;

                            pszValEdit[3] = (nYear % 10) + '0';

                            nYear /= 10;

                            pszValEdit[2] = (nYear % 10) + '0';

                            nYear /= 10;

                            pszValEdit[1] = (nYear % 10) + '0';

                            nYear /= 10;

                            pszValEdit[0] =

                                static_cast<char>(nYear /*% 10*/ + '0');

                            pszValEdit[4] = '-';

                            pszValEdit[5] =

                                ((psFieldRaw->Date.Month / 10) % 10) + '0';

                            pszValEdit[6] = (psFieldRaw->Date.Month % 10) + '0';

                            pszValEdit[7] = '-';

                            pszValEdit[8] =

                                ((psFieldRaw->Date.Day / 10) % 10) + '0';

                            pszValEdit[9] = (psFieldRaw->Date.Day % 10) + '0';

                            nValLengthBytes = 10;

                            nInsertionBufferPos += 10;

                        }

                    }

                    else if (eType == OFTDateTime)

                    {

                        destructorType = SQLITE_STATIC;

                        const auto psFieldRaw =

                            poFeature->GetRawFieldRef(iField);

                        char *pszValEdit =

                            &m_osInsertionBuffer[nInsertionBufferPos];

                        pszVal = pszValEdit;

                        if (m_poDS->m_bDateTimeWithTZ ||

                            psFieldRaw->Date.TZFlag == 100)

                        {

                            nValLengthBytes = OGRGetISO8601DateTime(

                                psFieldRaw, m_sDateTimeFormat, pszValEdit);

                        }

                        else

                        {

                            OGRField sField(*psFieldRaw);

                            if (sField.Date.TZFlag == 0 ||

                                sField.Date.TZFlag == 1)

                            {

                                sField.Date.TZFlag = 100;

                            }

                            else

                            {

                                struct tm brokendowntime;

                                brokendowntime.tm_year =

                                    sField.Date.Year - 1900;

                                brokendowntime.tm_mon = sField.Date.Month - 1;

                                brokendowntime.tm_mday = sField.Date.Day;

                                brokendowntime.tm_hour = sField.Date.Hour;

                                brokendowntime.tm_min = sField.Date.Minute;

                                brokendowntime.tm_sec = 0;

                                GIntBig nDT =

                                    CPLYMDHMSToUnixTime(&brokendowntime);

                                const int TZOffset =

                                    std::abs(sField.Date.TZFlag - 100) * 15;

                                nDT -= TZOffset * 60;

                                CPLUnixTimeToYMDHMS(nDT, &brokendowntime);

                                sField.Date.Year = static_cast<GInt16>(

                                    brokendowntime.tm_year + 1900);

                                sField.Date.Month = static_cast<GByte>(

                                    brokendowntime.tm_mon + 1);

                                sField.Date.Day =

                                    static_cast<GByte>(brokendowntime.tm_mday);

                                sField.Date.Hour =

                                    static_cast<GByte>(brokendowntime.tm_hour);

                                sField.Date.Minute =

                                    static_cast<GByte>(brokendowntime.tm_min);

                                sField.Date.TZFlag = 100;

                            }

                            nValLengthBytes = OGRGetISO8601DateTime(

                                &sField, m_sDateTimeFormat, pszValEdit);

                        }

                        nInsertionBufferPos += nValLengthBytes;

                    }

                    else if (eType == OFTString)

                    {

                        pszVal = poFeature->GetFieldAsStringUnsafe(iField);

                        if (poFieldDefn->GetWidth() > 0)

                        {

                            if (!CPLIsUTF8(pszVal, -1))

                            {

                                CPLError(CE_Warning, CPLE_AppDefined,

                                         "Value of field '%s' is not a valid "

                                         "UTF-8 string.%s",

                                         poFeatureDefn->GetFieldDefn(iField)

                                             ->GetNameRef(),

                                         m_bTruncateFields

                                             ? " Value will be laundered."

                                             : "");

                                if (m_bTruncateFields)

                                {

                                    pszVal = CPLForceToASCII(pszVal, -1, '_');

                                    destructorType = CPLFree;

                                }

                            }

                            if (CPLStrlenUTF8Ex(pszVal) >

                                static_cast<size_t>(poFieldDefn->GetWidth()))

                            {

                                CPLError(CE_Warning, CPLE_AppDefined,

                                         "Value of field '%s' has %" PRIu64

                                         " characters, "

                                         "whereas maximum allowed is %d.%s",

                                         poFeatureDefn->GetFieldDefn(iField)

                                             ->GetNameRef(),

                                         static_cast<uint64_t>(

                                             CPLStrlenUTF8Ex(pszVal)),

                                         poFieldDefn->GetWidth(),

                                         m_bTruncateFields

                                             ? " Value will be truncated."

                                             : "");

                                if (m_bTruncateFields)

                                {

                                    size_t countUTF8Chars = 0;

                                    nValLengthBytes = 0;

                                    while (pszVal[nValLengthBytes])

                                    {

                                        if ((pszVal[nValLengthBytes] & 0xc0) !=

                                            0x80)

                                        {

                                            // Stop at the start of the

                                            // character just beyond the maximum

                                            // accepted

                                            if (countUTF8Chars ==

                                                static_cast<size_t>(

                                                    poFieldDefn->GetWidth()))

                                            {

                                                break;

                                            }

                                            countUTF8Chars++;

                                        }

                                        nValLengthBytes++;

                                    }

                                }

                            }

                        }

                        else

                        {

                            destructorType = SQLITE_STATIC;

                        }

                    }

                    else

                    {

                        pszVal = poFeature->GetFieldAsString(iField);

                    }

                    err = sqlite3_bind_text(poStmt, nColCount++, pszVal,

                                            nValLengthBytes, destructorType);

                    break;

                }

            }

        }

        else

        {

            err = sqlite3_bind_null(poStmt, nColCount++);

        }

        if (err != SQLITE_OK)

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "sqlite3_bind_() for column %s failed: %s",

                     poFieldDefn->GetNameRef(),

                     sqlite3_errmsg(m_poDS->GetDB()));

            return OGRERR_FAILURE;

        }

    }

    if (pnColCount != nullptr)

        *pnColCount = nColCount;

    return OGRERR_NONE;

}

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

// FeatureBindUpdateParameters()

//

// Selectively bind the values of an OGRFeature to a prepared

// statement, prior to execution. Carefully binds exactly the

// same parameters that have been set up by FeatureGenerateUpdateSQL()

// as bindable.

//

OGRErr

OGRGeoPackageTableLayer::FeatureBindUpdateParameters(OGRFeature *poFeature,

                                                     sqlite3_stmt *poStmt)

{

    int nColCount = 0;

    const OGRErr err = FeatureBindParameters(

        poFeature, poStmt, &nColCount, false, false, -1, nullptr, -1, nullptr);

    if (err != OGRERR_NONE)

        return err;

    // Bind the FID to the "WHERE" clause.

    const int sqlite_err =

        sqlite3_bind_int64(poStmt, nColCount, poFeature->GetFID());

    if (sqlite_err != SQLITE_OK)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "failed to bind FID '" CPL_FRMT_GIB "' to statement: %s",

                 poFeature->GetFID(), sqlite3_errmsg(m_poDS->GetDB()));

        return OGRERR_FAILURE;

    }

    return OGRERR_NONE;

}

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

// FeatureBindInsertParameters()

//

// Selectively bind the values of an OGRFeature to a prepared

// statement, prior to execution. Carefully binds exactly the

// same parameters that have been set up by FeatureGenerateInsertSQL()

// as bindable.

//

OGRErr OGRGeoPackageTableLayer::FeatureBindInsertParameters(

    OGRFeature *poFeature, sqlite3_stmt *poStmt, bool bAddFID,

    bool bBindUnsetFields)

{

    return FeatureBindParameters(poFeature, poStmt, nullptr, bAddFID,

                                 bBindUnsetFields, -1, nullptr, -1, nullptr);

}

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

// FeatureGenerateInsertSQL()

//

// Build a SQL INSERT statement that references all the columns in

// the OGRFeatureDefn, then prepare it for repeated use in a prepared

// statement. All statements start off with geometry (if it exists)

// then reference each column in the order it appears in the OGRFeatureDefn.

// FeatureBindParameters operates on the expectation of this

// column ordering.

//

CPLString OGRGeoPackageTableLayer::FeatureGenerateInsertSQL(

    OGRFeature *poFeature, bool bAddFID, bool bBindUnsetFields, bool bUpsert,

    const std::string &osUpsertUniqueColumnName)

{

    bool bNeedComma = false;

    const OGRFeatureDefn *poFeatureDefn = poFeature->GetDefnRef();

    if (poFeatureDefn->GetFieldCount() ==

            ((m_iFIDAsRegularColumnIndex >= 0) ? 1 : 0) &&

        poFeatureDefn->GetGeomFieldCount() == 0 && !bAddFID)

        return CPLSPrintf("INSERT INTO \"%s\" DEFAULT VALUES",

                          SQLEscapeName(m_pszTableName).c_str());

    /* Set up our SQL string basics */

    CPLString osSQLFront("INSERT");

    if (bUpsert && osUpsertUniqueColumnName.empty())

        osSQLFront += " OR REPLACE";

    osSQLFront +=

        CPLSPrintf(" INTO \"%s\" ( ", SQLEscapeName(m_pszTableName).c_str());

    CPLString osSQLBack;

    osSQLBack = ") VALUES (";

    CPLString osSQLColumn;

    if (bAddFID)

    {

        osSQLColumn.Printf("\"%s\"", SQLEscapeName(GetFIDColumn()).c_str());

        osSQLFront += osSQLColumn;

        osSQLBack += "?";

        bNeedComma = true;

    }

    if (poFeatureDefn->GetGeomFieldCount())

    {

        if (bNeedComma)

        {

            osSQLFront += ", ";

            osSQLBack += ", ";

        }

        osSQLColumn.Printf(

            "\"%s\"",

            SQLEscapeName(poFeatureDefn->GetGeomFieldDefn(0)->GetNameRef())

                .c_str());

        osSQLFront += osSQLColumn;

        osSQLBack += "?";

        bNeedComma = true;

    }

    /* Add attribute column names (except FID) to the SQL */

    for (int i = 0; i < poFeatureDefn->GetFieldCount(); i++)

    {

        const auto &oFieldDefn = poFeatureDefn->GetFieldDefn(i);

        if (i == m_iFIDAsRegularColumnIndex || oFieldDefn->IsGenerated())

            continue;

        if (!bBindUnsetFields && !poFeature->IsFieldSet(i))

            continue;

        if (!bNeedComma)

        {

            bNeedComma = true;

        }

        else

        {

            osSQLFront += ", ";

            osSQLBack += ", ";

        }

        osSQLColumn.Printf(

            "\"%s\"",

            SQLEscapeName(poFeatureDefn->GetFieldDefn(i)->GetNameRef())

                .c_str());

        osSQLFront += osSQLColumn;

        osSQLBack += "?";

    }

    osSQLBack += ")";

    if (!bNeedComma)

        return CPLSPrintf("INSERT INTO \"%s\" DEFAULT VALUES",

                          SQLEscapeName(m_pszTableName).c_str());

    if (bUpsert && !osUpsertUniqueColumnName.empty())

    {

        osSQLBack += " ON CONFLICT ";

#if SQLITE_VERSION_NUMBER < 3035000L

        osSQLBack += "(\"";

        osSQLBack += SQLEscapeName(osUpsertUniqueColumnName.c_str());

        osSQLBack += "\") ";

#endif

        osSQLBack += "DO UPDATE SET ";

        bNeedComma = false;

        if (poFeatureDefn->GetGeomFieldCount())

        {

            osSQLBack += CPLSPrintf(

                "\"%s\" = excluded.\"%s\"",

                SQLEscapeName(poFeatureDefn->GetGeomFieldDefn(0)->GetNameRef())

                    .c_str(),

                SQLEscapeName(poFeatureDefn->GetGeomFieldDefn(0)->GetNameRef())

                    .c_str());

            bNeedComma = true;

        }

        for (int i = 0; i < poFeatureDefn->GetFieldCount(); i++)

        {

            if (i == m_iFIDAsRegularColumnIndex)

                continue;

            if (!bBindUnsetFields && !poFeature->IsFieldSet(i))

                continue;

            if (!bNeedComma)

            {

                bNeedComma = true;

            }

            else

            {

                osSQLBack += ", ";

            }

            osSQLBack += CPLSPrintf(

                "\"%s\" = excluded.\"%s\"",

                SQLEscapeName(poFeatureDefn->GetFieldDefn(i)->GetNameRef())

                    .c_str(),

                SQLEscapeName(poFeatureDefn->GetFieldDefn(i)->GetNameRef())

                    .c_str());

        }

#if SQLITE_VERSION_NUMBER >= 3035000L

        osSQLBack += " RETURNING \"";

        osSQLBack += SQLEscapeName(GetFIDColumn()).c_str();

        osSQLBack += "\"";

#endif

    }

    return osSQLFront + osSQLBack;

}

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

// FeatureGenerateUpdateSQL()

//

// Build a SQL UPDATE statement that references all the columns in

// the OGRFeatureDefn, then prepare it for repeated use in a prepared

// statement. All statements start off with geometry (if it exists)

// then reference each column in the order it appears in the OGRFeatureDefn.

// FeatureBindParameters operates on the expectation of this

// column ordering.

//

std::string OGRGeoPackageTableLayer::FeatureGenerateUpdateSQL(

    const OGRFeature *poFeature) const

{

    bool bNeedComma = false;

    const OGRFeatureDefn *poFeatureDefn = poFeature->GetDefnRef();

    /* Set up our SQL string basics */

    std::string osUpdate("UPDATE \"");

    osUpdate += SQLEscapeName(m_pszTableName);

    osUpdate += "\" SET ";

    if (poFeatureDefn->GetGeomFieldCount() > 0)

    {

        osUpdate += '"';

        osUpdate +=

            SQLEscapeName(poFeatureDefn->GetGeomFieldDefn(0)->GetNameRef());

        osUpdate += "\"=?";

        bNeedComma = true;

    }

    /* Add attribute column names (except FID) to the SQL */

    const int nFieldCount = poFeatureDefn->GetFieldCount();

    for (int i = 0; i < nFieldCount; i++)

    {

        const auto &oFieldDefn = poFeatureDefn->GetFieldDefn(i);

        if (i == m_iFIDAsRegularColumnIndex || oFieldDefn->IsGenerated())

            continue;

        if (!poFeature->IsFieldSet(i))

            continue;

        if (!bNeedComma)

            bNeedComma = true;

        else

            osUpdate += ", ";

        osUpdate += '"';

        osUpdate += SQLEscapeName(poFeatureDefn->GetFieldDefn(i)->GetNameRef());

        osUpdate += "\"=?";

    }

    if (!bNeedComma)

        return CPLString();

    osUpdate += " WHERE \"";

    osUpdate += SQLEscapeName(m_pszFidColumn);

    osUpdate += "\" = ?";

    return osUpdate;

}

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

/*                            GetLayerDefn()                            */

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

const OGRFeatureDefn *OGRGeoPackageTableLayer::GetLayerDefn() const

{

    if (!m_bFeatureDefnCompleted)

    {

        m_bFeatureDefnCompleted = true;

        const_cast<OGRGeoPackageTableLayer *>(this)->ReadTableDefinition();

        m_poFeatureDefn->Seal(/* bSealFields = */ true);

    }

    return m_poFeatureDefn;

}

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

/*                      GetFIDColumn()                                  */

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

const char *OGRGeoPackageTableLayer::GetFIDColumn() const

{

    if (!m_bFeatureDefnCompleted)

        GetLayerDefn();

    return OGRGeoPackageLayer::GetFIDColumn();

}

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

/*                            GetGeomType()                             */

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

OGRwkbGeometryType OGRGeoPackageTableLayer::GetGeomType() const

{

    return m_poFeatureDefn->GetGeomType();

}

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

/*                         GetGeometryColumn()                          */

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

const char *OGRGeoPackageTableLayer::GetGeometryColumn() const

{

    if (m_poFeatureDefn->GetGeomFieldCount() > 0)

        return m_poFeatureDefn->GetGeomFieldDefn(0)->GetNameRef();

    else

        return "";

}

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

// ReadTableDefinition()

//

// Initialization routine. Read all the metadata about a table,

// starting from just the table name. Reads information from GPKG

// metadata tables and from SQLite table metadata. Uses it to

// populate OGRSpatialReference information and OGRFeatureDefn objects,

// among others.

//

OGRErr OGRGeoPackageTableLayer::ReadTableDefinition()

{

    m_poDS->IncrementReadTableDefCounter();

    bool bReadExtent = false;

    sqlite3 *poDb = m_poDS->GetDB();

    OGREnvelope oExtent;

    CPLString osGeomColumnName;

    CPLString osGeomColsType;

    bool bHasZ = false;

    bool bHasM = false;

#ifdef ENABLE_GPKG_OGR_CONTENTS

    if (m_poDS->m_bHasGPKGOGRContents)

    {

        CPLString osTrigger1Name(

            CPLSPrintf("trigger_insert_feature_count_%s", m_pszTableName));

        CPLString osTrigger2Name(

            CPLSPrintf("trigger_delete_feature_count_%s", m_pszTableName));

        const std::map<CPLString, CPLString> &oMap =

            m_poDS->GetNameTypeMapFromSQliteMaster();

        if (cpl::contains(oMap, osTrigger1Name.toupper()) &&

            cpl::contains(oMap, osTrigger2Name.toupper()))

        {

            m_bOGRFeatureCountTriggersEnabled = true;

        }

        else if (m_bIsTable)

        {

            CPLDebug("GPKG",

                     "Insert/delete feature_count triggers "

                     "missing on %s",

                     m_pszTableName);

        }

    }

#endif

#ifdef ENABLE_GPKG_OGR_CONTENTS

    if (m_poDS->m_bHasGPKGOGRContents)

    {

        char *pszSQL = sqlite3_mprintf("SELECT feature_count "

                                       "FROM gpkg_ogr_contents "

                                       "WHERE table_name = '%q'"

#ifdef WORKAROUND_SQLITE3_BUGS

                                       " OR 0"

#endif

                                       " LIMIT 2",

                                       m_pszTableName);

        auto oResultFeatureCount = SQLQuery(poDb, pszSQL);

        sqlite3_free(pszSQL);

        if (oResultFeatureCount && oResultFeatureCount->RowCount() == 0)

        {

            pszSQL = sqlite3_mprintf("SELECT feature_count "

                                     "FROM gpkg_ogr_contents "

                                     "WHERE lower(table_name) = lower('%q')"

#ifdef WORKAROUND_SQLITE3_BUGS

                                     " OR 0"

#endif

                                     " LIMIT 2",

                                     m_pszTableName);

            oResultFeatureCount = SQLQuery(poDb, pszSQL);

            sqlite3_free(pszSQL);

        }

        if (oResultFeatureCount && oResultFeatureCount->RowCount() == 1)

        {

            const char *pszFeatureCount = oResultFeatureCount->GetValue(0, 0);

            if (pszFeatureCount)

            {

                m_nTotalFeatureCount =

                    std::max<GIntBig>(0, CPLAtoGIntBig(pszFeatureCount));

            }

        }

    }

#endif

    bool bHasPreexistingSingleGeomColumn =

        m_poFeatureDefn->GetGeomFieldCount() == 1;

    bool bHasMultipleGeomColsInGpkgGeometryColumns = false;

    if (m_bIsInGpkgContents)

    {

        /* Check that the table name is registered in gpkg_contents */

        const std::map<CPLString, GPKGContentsDesc> &oMapContents =

            m_poDS->GetContents();

        const auto oIterContents =

            oMapContents.find(CPLString(m_pszTableName).toupper());

        if (oIterContents == oMapContents.end())

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "layer '%s' is not registered in gpkg_contents",

                     m_pszTableName);

            return OGRERR_FAILURE;

        }

        const GPKGContentsDesc &oContents = oIterContents->second;

        const char *pszIdentifier = oContents.osIdentifier.c_str();

        if (pszIdentifier[0] != 0 && strcmp(pszIdentifier, m_pszTableName) != 0)

            OGRLayer::SetMetadataItem("IDENTIFIER", pszIdentifier);

        const char *pszDescription = oContents.osDescription.c_str();

        if (pszDescription[0])

            OGRLayer::SetMetadataItem("DESCRIPTION", pszDescription);

        if (m_bIsSpatial)

        {

            /* All the extrema have to be non-NULL for this to make sense */

            if (!oContents.osMinX.empty() && !oContents.osMinY.empty() &&

                !oContents.osMaxX.empty() && !oContents.osMaxY.empty())

            {