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

 *

 * Project:  OpenGIS Simple Features Reference Implementation

 * Purpose:  Implements Open FileGDB OGR driver.

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

 *

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

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

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "ogr_openfilegdb.h"

#include <cmath>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cwchar>

#include <algorithm>

#include <limits>

#include <string>

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_minixml.h"

#include "cpl_quad_tree.h"

#include "cpl_string.h"

#include "ogr_api.h"

#include "ogr_core.h"

#include "ogr_feature.h"

#include "ogr_geometry.h"

#include "ogr_spatialref.h"

#include "ogr_srs_api.h"

#include "ogrsf_frmts.h"

#include "filegdbtable.h"

#include "ogr_swq.h"

#include "filegdb_coordprec_read.h"

OGROpenFileGDBGeomFieldDefn::~OGROpenFileGDBGeomFieldDefn() = default;

OGROpenFileGDBFeatureDefn::~OGROpenFileGDBFeatureDefn() = default;

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

/*                        OGROpenFileGDBLayer()                         */

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

OGROpenFileGDBLayer::OGROpenFileGDBLayer(

    OGROpenFileGDBDataSource *poDS, const char *pszGDBFilename,

    const char *pszName, const std::string &osDefinition,

    const std::string &osDocumentation, bool bEditable,

    OGRwkbGeometryType eGeomType, const std::string &osParentDefinition)

    : m_poDS(poDS), m_osGDBFilename(pszGDBFilename), m_osName(pszName),

      m_bEditable(bEditable), m_osDefinition(osDefinition),

      m_osDocumentation(osDocumentation)

{

    // TODO(rouault): What error on compiler versions?  r33032 does not say.

    // We cannot initialize m_poFeatureDefn in above list. MSVC doesn't like

    // this to be used in initialization list.

    m_poFeatureDefn = new OGROpenFileGDBFeatureDefn(this, pszName, false);

    SetDescription(m_poFeatureDefn->GetName());

    m_poFeatureDefn->SetGeomType(wkbNone);

    m_poFeatureDefn->Reference();

    m_eGeomType = eGeomType;

    if (!m_osDefinition.empty())

    {

        BuildGeometryColumnGDBv10(osParentDefinition);

    }

    // bSealFields = false because we do lazy resolution of fields

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

}

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

/*                        OGROpenFileGDBLayer()                         */

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

OGROpenFileGDBLayer::OGROpenFileGDBLayer(OGROpenFileGDBDataSource *poDS,

                                         const char *pszGDBFilename,

                                         const char *pszName,

                                         OGRwkbGeometryType eType,

                                         CSLConstList papszOptions)

    : m_poDS(poDS), m_osGDBFilename(pszGDBFilename), m_osName(pszName),

      m_aosCreationOptions(papszOptions), m_eGeomType(eType),

      m_bArcGISPro32OrLater(

          EQUAL(CSLFetchNameValueDef(papszOptions, "TARGET_ARCGIS_VERSION", ""),

                "ARCGIS_PRO_3_2_OR_LATER"))

{

}

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

/*                        ~OGROpenFileGDBLayer()                        */

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

OGROpenFileGDBLayer::~OGROpenFileGDBLayer()

{

    OGROpenFileGDBLayer::SyncToDisk();

    if (m_poFeatureDefn)

    {

        m_poFeatureDefn->UnsetLayer();

        m_poFeatureDefn->Release();

    }

    delete m_poLyrTable;

    delete m_poAttributeIterator;

    delete m_poIterMinMax;

    delete m_poSpatialIndexIterator;

    delete m_poCombinedIterator;

    if (m_pQuadTree != nullptr)

        CPLQuadTreeDestroy(m_pQuadTree);

    CPLFree(m_pahFilteredFeatures);

}

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

/*                               Close()                                */

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

void OGROpenFileGDBLayer::Close()

{

    delete m_poLyrTable;

    m_poLyrTable = nullptr;

    m_bValidLayerDefn = FALSE;

}

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

/*                     BuildGeometryColumnGDBv10()                      */

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

int OGROpenFileGDBLayer::BuildGeometryColumnGDBv10(

    const std::string &osParentDefinition)

{

    CPLXMLNode *psTree = CPLParseXMLString(m_osDefinition.c_str());

    if (psTree == nullptr)

    {

        m_osDefinition = "";

        return FALSE;

    }

    CPLStripXMLNamespace(psTree, nullptr, TRUE);

    /* CPLSerializeXMLTreeToFile( psTree, "/dev/stderr" ); */

    const CPLXMLNode *psInfo = CPLSearchXMLNode(psTree, "=DEFeatureClassInfo");

    if (psInfo == nullptr)

        psInfo = CPLSearchXMLNode(psTree, "=DETableInfo");

    if (psInfo == nullptr)

    {

        m_osDefinition = "";

        CPLDestroyXMLNode(psTree);

        return FALSE;

    }

    const char *pszAliasName = CPLGetXMLValue(psInfo, "AliasName", nullptr);

    if (pszAliasName && strcmp(pszAliasName, GetDescription()) != 0)

    {

        SetMetadataItem("ALIAS_NAME", pszAliasName);

    }

    m_bTimeInUTC = CPLTestBool(CPLGetXMLValue(psInfo, "IsTimeInUTC", "false"));

    /* We cannot trust the XML definition to build the field definitions. */

    /* It sometimes misses a few fields ! */

    const bool bHasZ = CPLTestBool(CPLGetXMLValue(psInfo, "HasZ", "NO"));

    const bool bHasM = CPLTestBool(CPLGetXMLValue(psInfo, "HasM", "NO"));

    const char *pszShapeType = CPLGetXMLValue(psInfo, "ShapeType", nullptr);

    const char *pszShapeFieldName =

        CPLGetXMLValue(psInfo, "ShapeFieldName", nullptr);

    if (pszShapeType != nullptr && pszShapeFieldName != nullptr)

    {

        m_eGeomType =

            FileGDBOGRGeometryConverter::GetGeometryTypeFromESRI(pszShapeType);

        if (EQUAL(pszShapeType, "esriGeometryMultiPatch"))

        {

            if (m_poLyrTable == nullptr)

            {

                m_poLyrTable = new FileGDBTable();

                if (!(m_poLyrTable->Open(m_osGDBFilename, m_bEditable,

                                         GetDescription())))

                {

                    Close();

                }

            }

            if (m_poLyrTable != nullptr)

            {

                m_iGeomFieldIdx = m_poLyrTable->GetGeomFieldIdx();

                if (m_iGeomFieldIdx >= 0)

                {

                    FileGDBGeomField *poGDBGeomField =

                        reinterpret_cast<FileGDBGeomField *>(

                            m_poLyrTable->GetField(m_iGeomFieldIdx));

                    m_poGeomConverter.reset(

                        FileGDBOGRGeometryConverter::BuildConverter(

                            poGDBGeomField));

                    TryToDetectMultiPatchKind();

                }

            }

        }

        if (bHasZ)

            m_eGeomType = wkbSetZ(m_eGeomType);

        if (bHasM)

            m_eGeomType = wkbSetM(m_eGeomType);

        auto poGeomFieldDefn = std::make_unique<OGROpenFileGDBGeomFieldDefn>(

            nullptr, pszShapeFieldName, m_eGeomType);

        const CPLXMLNode *psGPFieldInfoExs =

            CPLGetXMLNode(psInfo, "GPFieldInfoExs");

        if (psGPFieldInfoExs)

        {

            for (const CPLXMLNode *psChild = psGPFieldInfoExs->psChild; psChild;

                 psChild = psChild->psNext)

            {

                if (psChild->eType != CXT_Element)

                    continue;

                if (EQUAL(psChild->pszValue, "GPFieldInfoEx") &&

                    EQUAL(CPLGetXMLValue(psChild, "Name", ""),

                          pszShapeFieldName))

                {

                    poGeomFieldDefn->SetNullable(CPLTestBool(

                        CPLGetXMLValue(psChild, "IsNullable", "TRUE")));

                    break;

                }

            }

        }

        const CPLXMLNode *psSpatialReference =

            CPLGetXMLNode(psInfo, "SpatialReference");

        if (psSpatialReference)

        {

            poGeomFieldDefn->SetCoordinatePrecision(

                GDBGridSettingsToOGR(psSpatialReference));

        }

        OGRSpatialReferenceRefCountedPtr poParentSRS;

        if (!osParentDefinition.empty())

        {

            CPLXMLNode *psParentTree =

                CPLParseXMLString(osParentDefinition.c_str());

            if (psParentTree != nullptr)

            {

                CPLStripXMLNamespace(psParentTree, nullptr, TRUE);

                CPLXMLNode *psParentInfo =

                    CPLSearchXMLNode(psParentTree, "=DEFeatureDataset");

                if (psParentInfo != nullptr)

                {

                    poParentSRS = m_poDS->BuildSRS(psParentInfo);

                }

                CPLDestroyXMLNode(psParentTree);

            }

            if (poParentSRS == nullptr)

            {

                CPLDebug("OpenFileGDB", "Cannot get SRS from feature dataset");

            }

        }

        auto poSRS = m_poDS->BuildSRS(psInfo);

        if (poParentSRS)

        {

            if (poSRS)

            {

                if (!poSRS->IsSame(poParentSRS.get()))

                {

                    // Not sure this situation is really valid (seems more a

                    // bug of the editing software), but happens with

                    // https://github.com/OSGeo/gdal/issues/5747

                    // In the situation of

                    // https://github.com/OSGeo/gdal/issues/5747, the SRS inside

                    // the .gdbtable is consistent with the XML definition of

                    // the feature dataset, so it seems that the XML

                    // definition of the feature table lacked an update.

                    CPLDebug(

                        "OpenFileGDB",

                        "Table %s declare a CRS '%s' in its XML definition, "

                        "but its feature dataset declares '%s'. "

                        "Using the later",

                        GetDescription(), poSRS->GetName(),

                        poParentSRS->GetName());

                }

            }

            // Always use the SRS of the feature dataset

            poSRS = std::move(poParentSRS);

        }

        if (poSRS != nullptr)

        {

            poGeomFieldDefn->SetSpatialRef(std::move(poSRS));

        }

        m_poFeatureDefn->AddGeomFieldDefn(std::move(poGeomFieldDefn));

    }

    else

    {

        m_eGeomType = wkbNone;

    }

    CPLDestroyXMLNode(psTree);

    return TRUE;

}

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

/*                     TryToDetectMultiPatchKind()                      */

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

// If the first and last feature have the same geometry type, then use

// it for the whole layer.

void OGROpenFileGDBLayer::TryToDetectMultiPatchKind()

{

    CPLAssert(m_poLyrTable != nullptr);

    CPLAssert(m_iGeomFieldIdx >= 0);

    if (m_poLyrTable->GetTotalRecordCount() == 0)

        return;

    const int64_t nFirstIdx = m_poLyrTable->GetAndSelectNextNonEmptyRow(0);

    if (nFirstIdx < 0)

        return;

    const OGRField *psField = m_poLyrTable->GetFieldValue(m_iGeomFieldIdx);

    if (psField == nullptr)

        return;

    OGRGeometry *poGeom = m_poGeomConverter->GetAsGeometry(psField);

    if (poGeom == nullptr)

        return;

    const OGRwkbGeometryType eType = poGeom->getGeometryType();

    delete poGeom;

    int64_t nLastIdx = m_poLyrTable->GetTotalRecordCount() - 1;

    const GUInt32 nErrorCount = CPLGetErrorCounter();

    while (nLastIdx > nFirstIdx &&

           m_poLyrTable->GetOffsetInTableForRow(nLastIdx) == 0 &&

           nErrorCount == CPLGetErrorCounter())

    {

        nLastIdx--;

    }

    if (nLastIdx > nFirstIdx && m_poLyrTable->SelectRow(nLastIdx))

    {

        psField = m_poLyrTable->GetFieldValue(m_iGeomFieldIdx);

        if (psField == nullptr)

        {

            m_eGeomType = eType;

            return;

        }

        poGeom = m_poGeomConverter->GetAsGeometry(psField);

        if (poGeom == nullptr)

        {

            m_eGeomType = eType;

            return;

        }

        if (eType == poGeom->getGeometryType())

            m_eGeomType = eType;

        delete poGeom;

    }

}

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

/*                        BuildLayerDefinition()                        */

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

int OGROpenFileGDBLayer::BuildLayerDefinition()

{

    if (m_bValidLayerDefn >= 0)

        return m_bValidLayerDefn;

    if (m_poLyrTable == nullptr)

    {

        m_poLyrTable = new FileGDBTable();

        if (!(m_poLyrTable->Open(m_osGDBFilename, m_bEditable,

                                 GetDescription())))

        {

            if (m_bEditable)

            {

                // Retry in read-only mode

                m_bEditable = false;

                delete m_poLyrTable;

                m_poLyrTable = new FileGDBTable();

                if (!(m_poLyrTable->Open(m_osGDBFilename, m_bEditable,

                                         GetDescription())))

                {

                    Close();

                    return FALSE;

                }

                else

                {

                    CPLError(

                        CE_Failure, CPLE_FileIO,

                        "Cannot open %s in update mode, but only in read-only",

                        GetDescription());

                }

            }

            else

            {

                Close();

                return FALSE;

            }

        }

    }

    m_bValidLayerDefn = TRUE;

    auto oTemporaryUnsealer(m_poFeatureDefn->GetTemporaryUnsealer());

    m_iGeomFieldIdx = m_poLyrTable->GetGeomFieldIdx();

    if (m_iGeomFieldIdx >= 0)

    {

        FileGDBGeomField *poGDBGeomField = cpl::down_cast<FileGDBGeomField *>(

            m_poLyrTable->GetField(m_iGeomFieldIdx));

        m_poGeomConverter.reset(

            FileGDBOGRGeometryConverter::BuildConverter(poGDBGeomField));

#ifdef DEBUG

        const auto poSRS = GetSpatialRef();

        if (poSRS != nullptr && !poGDBGeomField->GetWKT().empty() &&

            poGDBGeomField->GetWKT()[0] != '{')

        {

            auto poSRSFromGDBTable =

                m_poDS->BuildSRS(poGDBGeomField->GetWKT().c_str());

            if (poSRSFromGDBTable)

            {

                if (!poSRS->IsSame(poSRSFromGDBTable.get()))

                {

                    CPLDebug("OpenFileGDB",

                             "Table %s declare a CRS '%s' in its XML "

                             "definition (or in its parent's one), "

                             "but its .gdbtable declares '%s'. "

                             "Using the former",

                             GetDescription(), poSRS->GetName(),

                             poSRSFromGDBTable->GetName());

                }

            }

        }

#endif

        if (!(m_poLyrTable->CanUseIndices() &&

              m_poLyrTable->HasSpatialIndex() &&

              CPLTestBool(CPLGetConfigOption("OPENFILEGDB_USE_SPATIAL_INDEX",

                                             "YES"))) &&

            CPLTestBool(CPLGetConfigOption("OPENFILEGDB_IN_MEMORY_SPI", "YES")))

        {

            CPLRectObj sGlobalBounds;

            sGlobalBounds.minx = poGDBGeomField->GetXMin();

            sGlobalBounds.miny = poGDBGeomField->GetYMin();

            sGlobalBounds.maxx = poGDBGeomField->GetXMax();

            sGlobalBounds.maxy = poGDBGeomField->GetYMax();

            m_pQuadTree = CPLQuadTreeCreate(&sGlobalBounds, nullptr);

            CPLQuadTreeSetMaxDepth(

                m_pQuadTree,

                CPLQuadTreeGetAdvisedMaxDepth(

                    static_cast<int>(std::min<int64_t>(

                        INT_MAX, m_poLyrTable->GetValidRecordCount()))));

        }

        else

        {

            m_eSpatialIndexState = SPI_INVALID;

        }

    }

    if (m_iGeomFieldIdx >= 0 &&

        (m_osDefinition.empty() ||

         m_poFeatureDefn->OGRFeatureDefn::GetGeomFieldCount() == 0))

    {

        /* FileGDB v9 case */

        FileGDBGeomField *poGDBGeomField = reinterpret_cast<FileGDBGeomField *>(

            m_poLyrTable->GetField(m_iGeomFieldIdx));

        const char *pszName = poGDBGeomField->GetName().c_str();

        const FileGDBTableGeometryType eGDBGeomType =

            m_poLyrTable->GetGeometryType();

        OGRwkbGeometryType eGeomType = wkbUnknown;

        switch (eGDBGeomType)

        {

            case FGTGT_NONE: /* doesn't make sense ! */

                break;

            case FGTGT_POINT:

                eGeomType = wkbPoint;

                break;

            case FGTGT_MULTIPOINT:

                eGeomType = wkbMultiPoint;

                break;

            case FGTGT_LINE:

                eGeomType = wkbMultiLineString;

                break;

            case FGTGT_POLYGON:

                eGeomType = wkbMultiPolygon;

                break;

            case FGTGT_MULTIPATCH:

                eGeomType = wkbUnknown;

                break;

        }

        if (m_eGeomType != wkbUnknown &&

            wkbFlatten(eGeomType) != wkbFlatten(m_eGeomType))

        {

            CPLError(CE_Warning, CPLE_AppDefined,

                     "Inconsistency for layer geometry type");

        }

        m_eGeomType = eGeomType;

        if (eGDBGeomType == FGTGT_MULTIPATCH)

        {

            TryToDetectMultiPatchKind();

        }

        if (m_poLyrTable->GetGeomTypeHasZ())

            m_eGeomType = wkbSetZ(m_eGeomType);

        if (m_poLyrTable->GetGeomTypeHasM())

            m_eGeomType = wkbSetM(m_eGeomType);

        {

            auto poGeomFieldDefn =

                std::make_unique<OGROpenFileGDBGeomFieldDefn>(nullptr, pszName,

                                                              m_eGeomType);

            poGeomFieldDefn->SetNullable(poGDBGeomField->IsNullable());

            m_poFeatureDefn->AddGeomFieldDefn(std::move(poGeomFieldDefn));

        }

        auto poGeomFieldDefn = m_poFeatureDefn->GetGeomFieldDefn(0);

        OGRSpatialReferenceRefCountedPtr poSRS;

        if (!poGDBGeomField->GetWKT().empty() &&

            poGDBGeomField->GetWKT()[0] != '{')

        {

            poSRS = m_poDS->BuildSRS(poGDBGeomField->GetWKT().c_str());

        }

        if (poSRS != nullptr)

        {

            poGeomFieldDefn->SetSpatialRef(poSRS.get());

        }

    }

    else if (m_osDefinition.empty() && m_iGeomFieldIdx < 0)

    {

        m_eGeomType = wkbNone;

    }

    CPLXMLTreeCloser oTree(nullptr);

    const CPLXMLNode *psGPFieldInfoExs = nullptr;

    std::string osAreaFieldName;

    std::string osLengthFieldName;

    if (!m_osDefinition.empty())

    {

        oTree.reset(CPLParseXMLString(m_osDefinition.c_str()));

        if (oTree != nullptr)

        {

            CPLStripXMLNamespace(oTree.get(), nullptr, TRUE);

            CPLXMLNode *psInfo =

                CPLSearchXMLNode(oTree.get(), "=DEFeatureClassInfo");

            if (psInfo == nullptr)

                psInfo = CPLSearchXMLNode(oTree.get(), "=DETableInfo");

            if (psInfo != nullptr)

            {

                psGPFieldInfoExs = CPLGetXMLNode(psInfo, "GPFieldInfoExs");

                osAreaFieldName = CPLGetXMLValue(psInfo, "AreaFieldName", "");

                osLengthFieldName =

                    CPLGetXMLValue(psInfo, "LengthFieldName", "");

                m_osPath = CPLGetXMLValue(psInfo, "CatalogPath", "");

            }

        }

    }

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

    {

        if (i == m_iGeomFieldIdx)

            continue;

        if (i == m_poLyrTable->GetObjectIdFieldIdx())

            continue;

        FileGDBField *poGDBField = m_poLyrTable->GetField(i);

        OGRFieldType eType = OFTString;

        OGRFieldSubType eSubType = OFSTNone;

        int nWidth = poGDBField->GetMaxWidth();

        switch (poGDBField->GetType())

        {

            case FGFT_INT16:

                eType = OFTInteger;

                eSubType = OFSTInt16;

                break;

            case FGFT_INT32:

                eType = OFTInteger;

                break;

            case FGFT_FLOAT32:

                eType = OFTReal;

                eSubType = OFSTFloat32;

                break;

            case FGFT_FLOAT64:

                eType = OFTReal;

                break;

            case FGFT_STRING:

                /* nWidth = poGDBField->GetMaxWidth(); */

                eType = OFTString;

                break;

            case FGFT_GUID:

            case FGFT_GLOBALID:

            case FGFT_XML:

                eType = OFTString;

                break;

            case FGFT_DATETIME:

                eType = OFTDateTime;

                break;

            case FGFT_UNDEFINED:

            case FGFT_OBJECTID:

            case FGFT_GEOMETRY:

                CPLAssert(false);

                break;

            case FGFT_BINARY:

            {

                /* Special case for v9 GDB_UserMetadata table */

                if (m_iFieldToReadAsBinary < 0 &&

                    poGDBField->GetName() == "Xml" &&

                    poGDBField->GetType() == FGFT_BINARY)

                {

                    m_iFieldToReadAsBinary = i;

                    eType = OFTString;

                }

                else

                {

                    eType = OFTBinary;

                }

                break;

            }

            case FGFT_RASTER:

            {

                const FileGDBRasterField *rasterField =

                    cpl::down_cast<const FileGDBRasterField *>(poGDBField);

                if (rasterField->GetRasterType() ==

                    FileGDBRasterField::Type::MANAGED)

                    eType = OFTInteger;

                else if (rasterField->GetRasterType() ==

                         FileGDBRasterField::Type::EXTERNAL)

                    eType = OFTString;

                else

                    eType = OFTBinary;

                break;

            }

            case FGFT_INT64:

                m_bArcGISPro32OrLater = true;

                eType = OFTInteger64;

                break;

            case FGFT_DATE:

                m_bArcGISPro32OrLater = true;

                eType = OFTDate;

                break;

            case FGFT_TIME:

                m_bArcGISPro32OrLater = true;

                eType = OFTTime;

                break;

            case FGFT_DATETIME_WITH_OFFSET:

                m_bArcGISPro32OrLater = true;

                eType = OFTDateTime;

                break;

        }

        OGRFieldDefn oFieldDefn(poGDBField->GetName().c_str(), eType);

        oFieldDefn.SetAlternativeName(poGDBField->GetAlias().c_str());

        oFieldDefn.SetSubType(eSubType);

        // On creation in the FileGDB driver (GDBFieldTypeToLengthInBytes) if

        // string width is 0, we pick up DEFAULT_STRING_WIDTH=65536 by default

        // to mean unlimited string length, but we do not want to advertise

        // such a big number.

        if (eType == OFTString &&

            (nWidth < DEFAULT_STRING_WIDTH ||

             CPLTestBool(CPLGetConfigOption(

                 "OPENFILEGDB_REPORT_GENUINE_FIELD_WIDTH", "NO"))))

        {

            oFieldDefn.SetWidth(nWidth);

        }

        oFieldDefn.SetNullable(poGDBField->IsNullable());

        const CPLXMLNode *psFieldDef = nullptr;

        if (psGPFieldInfoExs != nullptr)

        {

            for (const CPLXMLNode *psChild = psGPFieldInfoExs->psChild;

                 psChild != nullptr; psChild = psChild->psNext)

            {

                if (psChild->eType != CXT_Element)

                    continue;

                if (EQUAL(psChild->pszValue, "GPFieldInfoEx") &&

                    EQUAL(CPLGetXMLValue(psChild, "Name", ""),

                          poGDBField->GetName().c_str()))

                {

                    psFieldDef = psChild;

                    break;

                }

            }

        }

        if (psFieldDef && poGDBField->GetType() == FGFT_DATETIME)

        {

            if (EQUAL(CPLGetXMLValue(psFieldDef, "HighPrecision", ""), "true"))

            {

                poGDBField->SetHighPrecision();

            }

        }

        const OGRField *psDefault = poGDBField->GetDefault();

        if (!OGR_RawField_IsUnset(psDefault) && !OGR_RawField_IsNull(psDefault))

        {

            if (eType == OFTString)

            {

                CPLString osDefault("'");

                char *pszTmp =

                    CPLEscapeString(psDefault->String, -1, CPLES_SQL);

                osDefault += pszTmp;

                CPLFree(pszTmp);

                osDefault += "'";

                oFieldDefn.SetDefault(osDefault);

            }

            else if (eType == OFTInteger || eType == OFTReal ||

                     eType == OFTInteger64)

            {

                // GDBs and the FileGDB SDK are not always reliable for

                // numeric values It often occurs that the XML definition in

                // a00000004.gdbtable does not match the default values (in

                // binary) found in the field definition section of the

                // .gdbtable of the layers themselves So check consistency.

                const char *pszDefaultValue = nullptr;

                if (psFieldDef)

                {

                    // From ArcGIS this is called DefaultValueNumeric

                    // for integer and real.

                    // From FileGDB API this is

                    // called DefaultValue xsi:type=xs:int for integer

                    // and DefaultValueNumeric for real ...

                    pszDefaultValue = CPLGetXMLValue(

                        psFieldDef, "DefaultValueNumeric", nullptr);

                    if (pszDefaultValue == nullptr)

                        pszDefaultValue =

                            CPLGetXMLValue(psFieldDef, "DefaultValue", nullptr);

                    // For ArcGIS Pro 3.2 and esriFieldTypeBigInteger, this is

                    // DefaultValueInteger

                    if (pszDefaultValue == nullptr)

                        pszDefaultValue = CPLGetXMLValue(

                            psFieldDef, "DefaultValueInteger", nullptr);

                }

                if (pszDefaultValue != nullptr)

                {

                    if (eType == OFTInteger)

                    {

                        if (atoi(pszDefaultValue) != psDefault->Integer)

                        {

                            CPLDebug(

                                "OpenFileGDB",

                                "For field %s, XML definition mentions %s "

                                "as default value whereas .gdbtable header "

                                "mentions %d. Using %s",

                                poGDBField->GetName().c_str(), pszDefaultValue,

                                psDefault->Integer, pszDefaultValue);

                        }

                        oFieldDefn.SetDefault(pszDefaultValue);

                    }

                    else if (eType == OFTReal)

                    {

                        if (fabs(CPLAtof(pszDefaultValue) - psDefault->Real) >

                            1e-15)

                        {

                            CPLDebug(

                                "OpenFileGDB",

                                "For field %s, XML definition "

                                "mentions %s as default value whereas "

                                ".gdbtable header mentions %.17g. Using %s",

                                poGDBField->GetName().c_str(), pszDefaultValue,

                                psDefault->Real, pszDefaultValue);

                        }

                        oFieldDefn.SetDefault(pszDefaultValue);

                    }

                    else if (eType == OFTInteger64)

                    {

                        if (CPLAtoGIntBig(pszDefaultValue) !=

                            psDefault->Integer64)

                        {

                            CPLDebug(

                                "OpenFileGDB",

                                "For field %s, XML definition mentions %s "

                                "as default value whereas .gdbtable header "

                                "mentions " CPL_FRMT_GIB ". Using %s",

                                poGDBField->GetName().c_str(), pszDefaultValue,

                                psDefault->Integer64, pszDefaultValue);

                        }

                        oFieldDefn.SetDefault(pszDefaultValue);

                    }

                }

            }

            else if (eType == OFTDateTime)

            {

                if (poGDBField->GetType() == FGFT_DATETIME_WITH_OFFSET)

                {

                    oFieldDefn.SetDefault(CPLSPrintf(

                        "'%04d/%02d/%02d %02d:%02d:%06.03f%c%02d:%02d'",

                        psDefault->Date.Year, psDefault->Date.Month,

                        psDefault->Date.Day, psDefault->Date.Hour,

                        psDefault->Date.Minute, psDefault->Date.Second,

                        psDefault->Date.TZFlag >= 100 ? '+' : '-',

                        std::abs(psDefault->Date.TZFlag - 100) / 4,

                        (std::abs(psDefault->Date.TZFlag - 100) % 4) * 15));

                }

                else

                {

                    oFieldDefn.SetDefault(CPLSPrintf(

                        "'%04d/%02d/%02d %02d:%02d:%02d'", psDefault->Date.Year,

                        psDefault->Date.Month, psDefault->Date.Day,

                        psDefault->Date.Hour, psDefault->Date.Minute,

                        static_cast<int>(psDefault->Date.Second)));

                }

            }

            else if (eType == OFTDate)

                oFieldDefn.SetDefault(

                    CPLSPrintf("'%04d/%02d/%02d'", psDefault->Date.Year,

                               psDefault->Date.Month, psDefault->Date.Day));

            else if (eType == OFTTime)

                oFieldDefn.SetDefault(

                    CPLSPrintf("'%02d:%02d:%02d'", psDefault->Date.Hour,

                               psDefault->Date.Minute,

                               static_cast<int>(psDefault->Date.Second)));

        }

        if (psFieldDef)

        {

            const char *pszDomainName =

                CPLGetXMLValue(psFieldDef, "DomainName", nullptr);

            if (pszDomainName)

                oFieldDefn.SetDomainName(pszDomainName);

        }

        if (osAreaFieldName == poGDBField->GetName() &&

            oFieldDefn.GetType() == OFTReal)

        {

            m_iAreaField = m_poFeatureDefn->GetFieldCount();

            oFieldDefn.SetDefault("FILEGEODATABASE_SHAPE_AREA");

        }

        else if (osLengthFieldName == poGDBField->GetName() &&

                 oFieldDefn.GetType() == OFTReal)

        {

            m_iLengthField = m_poFeatureDefn->GetFieldCount();

            oFieldDefn.SetDefault("FILEGEODATABASE_SHAPE_LENGTH");

        }

        m_poFeatureDefn->AddFieldDefn(&oFieldDefn);

    }

    if (m_poLyrTable->HasDeletedFeaturesListed())

    {

        OGRFieldDefn oFieldDefn("_deleted_", OFTInteger);

        m_poFeatureDefn->AddFieldDefn(&oFieldDefn);

    }

    return TRUE;

}

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

/*                            GetGeomType()                             */

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

OGRwkbGeometryType OGROpenFileGDBLayer::GetGeomType() const

{

    if (m_eGeomType == wkbUnknown ||

        m_osDefinition.empty() /* FileGDB v9 case */)

    {

        (void)const_cast<OGROpenFileGDBLayer *>(this)->BuildLayerDefinition();

    }

    return m_eGeomType;

}

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

/*                            GetLayerDefn()                            */

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

const OGRFeatureDefn *OGROpenFileGDBLayer::GetLayerDefn() const

{

    return m_poFeatureDefn;

}

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

/*                            GetFIDColumn()                            */

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

const char *OGROpenFileGDBLayer::GetFIDColumn() const

{

    if (!const_cast<OGROpenFileGDBLayer *>(this)->BuildLayerDefinition())

        return "";

    int iIdx = m_poLyrTable->GetObjectIdFieldIdx();

    if (iIdx < 0)

        return "";

    return m_poLyrTable->GetField(iIdx)->GetName().c_str();

}

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

/*                            ResetReading()                            */

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

void OGROpenFileGDBLayer::ResetReading()

{

    if (m_iCurFeat != 0)

    {

        if (m_eSpatialIndexState == SPI_IN_BUILDING)

            m_eSpatialIndexState = SPI_INVALID;

    }

    m_bEOF = FALSE;

    m_iCurFeat = 0;

    if (m_poAttributeIterator)

        m_poAttributeIterator->Reset();

    if (m_poSpatialIndexIterator)

        m_poSpatialIndexIterator->Reset();

    if (m_poCombinedIterator)

        m_poCombinedIterator->Reset();

}

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

/*                         ISetSpatialFilter()                          */

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

OGRErr OGROpenFileGDBLayer::ISetSpatialFilter(int iGeomField,

                                              const OGRGeometry *poGeom)

{

    if (!BuildLayerDefinition())

        return OGRERR_FAILURE;

    OGRLayer::ISetSpatialFilter(iGeomField, poGeom);

    if (m_bFilterIsEnvelope)

    {

        OGREnvelope sLayerEnvelope;

        if (GetExtent(&sLayerEnvelope, FALSE) == OGRERR_NONE)

        {

            if (m_sFilterEnvelope.MinX <= sLayerEnvelope.MinX &&

                m_sFilterEnvelope.MinY <= sLayerEnvelope.MinY &&

                m_sFilterEnvelope.MaxX >= sLayerEnvelope.MaxX &&

                m_sFilterEnvelope.MaxY >= sLayerEnvelope.MaxY)

            {

#ifdef DEBUG

                CPLDebug("OpenFileGDB", "Disabling spatial filter since it "

                                        "contains the layer spatial extent");

#endif

                poGeom = nullptr;

                OGRLayer::ISetSpatialFilter(iGeomField, poGeom);

            }

        }

    }

    if (poGeom != nullptr)

    {

        if (m_poSpatialIndexIterator == nullptr &&

            m_poLyrTable->CanUseIndices() && m_poLyrTable->HasSpatialIndex() &&

            CPLTestBool(

                CPLGetConfigOption("OPENFILEGDB_USE_SPATIAL_INDEX", "YES")))

        {

            m_poSpatialIndexIterator = FileGDBSpatialIndexIterator::Build(

                m_poLyrTable, m_sFilterEnvelope);

        }

        else if (m_poSpatialIndexIterator != nullptr)

        {

            if (!m_poSpatialIndexIterator->SetEnvelope(m_sFilterEnvelope))

            {

                delete m_poSpatialIndexIterator;

                m_poSpatialIndexIterator = nullptr;

            }

        }

        else if (m_eSpatialIndexState == SPI_COMPLETED)

        {

            CPLRectObj aoi;

            aoi.minx = m_sFilterEnvelope.MinX;

            aoi.miny = m_sFilterEnvelope.MinY;

            aoi.maxx = m_sFilterEnvelope.MaxX;

            aoi.maxy = m_sFilterEnvelope.MaxY;

            CPLFree(m_pahFilteredFeatures);

            m_nFilteredFeatureCount = -1;

            m_pahFilteredFeatures =

                CPLQuadTreeSearch(m_pQuadTree, &aoi, &m_nFilteredFeatureCount);

            if (m_nFilteredFeatureCount >= 0)

            {

                size_t *panStart =

                    reinterpret_cast<size_t *>(m_pahFilteredFeatures);

                std::sort(panStart, panStart + m_nFilteredFeatureCount);

            }

        }

        m_poLyrTable->InstallFilterEnvelope(&m_sFilterEnvelope);

    }

    else

    {