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

 *

 * Project:  OpenGIS Simple Features Reference Implementation

 * Purpose:  Simple client for translating between formats.

 * Author:   Frank Warmerdam, warmerdam@pobox.com

 *

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

 * Copyright (c) 1999, Frank Warmerdam

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

 * Copyright (c) 2015, Faza Mahamood

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "gdal_utils.h"

#include "gdal_utils_priv.h"

#include "gdalargumentparser.h"

#include <cassert>

#include <climits>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <algorithm>

#include <atomic>

#include <future>

#include <limits>

#include <map>

#include <memory>

#include <mutex>

#include <set>

#include <unordered_set>

#include <string>

#include <utility>

#include <vector>

#include "commonutils.h"

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_multiproc.h"

#include "cpl_progress.h"

#include "cpl_string.h"

#include "cpl_time.h"

#include "cpl_vsi.h"

#include "gdal.h"

#include "gdal_alg.h"

#include "gdal_alg_priv.h"

#include "gdal_priv.h"

#include "gdal_thread_pool.h"

#include "ogr_api.h"

#include "ogr_core.h"

#include "ogr_feature.h"

#include "ogr_featurestyle.h"

#include "ogr_geometry.h"

#include "ogr_p.h"

#include "ogr_recordbatch.h"

#include "ogr_spatialref.h"

#include "ogrlayerarrow.h"

#include "ogrlayerdecorator.h"

#include "ogrsf_frmts.h"

#include "ogr_wkb.h"

#include "ogrct_priv.h"

typedef enum

{

    GEOMOP_NONE,

    GEOMOP_SEGMENTIZE,

    GEOMOP_SIMPLIFY_PRESERVE_TOPOLOGY,

} GeomOperation;

typedef enum

{

    GTC_DEFAULT,

    GTC_PROMOTE_TO_MULTI,

    GTC_CONVERT_TO_LINEAR,

    GTC_CONVERT_TO_CURVE,

    GTC_PROMOTE_TO_MULTI_AND_CONVERT_TO_LINEAR,

} GeomTypeConversion;

#define GEOMTYPE_UNCHANGED -2

#define COORD_DIM_UNCHANGED -1

#define COORD_DIM_LAYER_DIM -2

#define COORD_DIM_XYM -3

#define TZ_OFFSET_INVALID INT_MIN

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

/*                      GDALVectorTranslateOptions                      */

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

/** Options for use with GDALVectorTranslate(). GDALVectorTranslateOptions* must

 * be allocated and freed with GDALVectorTranslateOptionsNew() and

 * GDALVectorTranslateOptionsFree() respectively.

 */

struct GDALVectorTranslateOptions

{

    // All arguments passed to GDALVectorTranslate() except the positional

    // ones (that is dataset names and layer names)

    CPLStringList aosArguments{};

    /*! continue after a failure, skipping the failed feature */

    bool bSkipFailures = false;

    /*! use layer level transaction. If set to FALSE, then it is interpreted as

     * dataset level transaction. */

    int nLayerTransaction = -1;

    /*! force the use of particular transaction type based on

     * GDALVectorTranslate::nLayerTransaction */

    bool bForceTransaction = false;

    /*! group nGroupTransactions features per transaction.

       Increase the value for better performance when writing into DBMS drivers

       that have transaction support. nGroupTransactions can be set to -1 to

       load the data into a single transaction */

    int nGroupTransactions = 100 * 1000;

    /*! If provided, only the feature with this feature id will be reported.

       Operates exclusive of the spatial or attribute queries. Note: if you want

       to select several features based on their feature id, you can also use

       the fact the 'fid' is a special field recognized by OGR SQL. So

       GDALVectorTranslateOptions::pszWHERE = "fid in (1,3,5)" would select

       features 1, 3 and 5. */

    GIntBig nFIDToFetch = OGRNullFID;

    /*! allow or suppress progress monitor and other non-error output */

    bool bQuiet = false;

    /*! output file format name */

    std::string osFormat{};

    /*! list of layers of the source dataset which needs to be selected */

    CPLStringList aosLayers{};

    /*! dataset creation option (format specific) */

    CPLStringList aosDSCO{};

    /*! layer creation option (format specific) */

    CPLStringList aosLCO{};

    /*! access modes */

    GDALVectorTranslateAccessMode eAccessMode = ACCESS_CREATION;

    /*! whether to use UpsertFeature() instead of CreateFeature() */

    bool bUpsert = false;

    /*! It has the effect of adding, to existing target layers, the new fields

       found in source layers. This option is useful when merging files that

       have non-strictly identical structures. This might not work for output

       formats that don't support adding fields to existing non-empty layers. */

    bool bAddMissingFields = false;

    /*! It must be set to true to trigger reprojection, otherwise only SRS

     * assignment is done. */

    bool bTransform = false;

    /*! output SRS. GDALVectorTranslateOptions::bTransform must be set to true

       to trigger reprojection, otherwise only SRS assignment is done. */

    std::string osOutputSRSDef{};

    /*! Coordinate epoch of source SRS */

    double dfSourceCoordinateEpoch = 0;

    /*! Coordinate epoch of output SRS */

    double dfOutputCoordinateEpoch = 0;

    /*! override source SRS */

    std::string osSourceSRSDef{};

    /*! PROJ pipeline */

    std::string osCTPipeline{};

    /*! Transform options. */

    CPLStringList aosCTOptions{};

    bool bNullifyOutputSRS = false;

    /*! If set to false, then field name matching between source and existing

       target layer is done in a more relaxed way if the target driver has an

       implementation for it. */

    bool bExactFieldNameMatch = true;

    /*! an alternate name to the new layer */

    std::string osNewLayerName{};

    /*! attribute query (like SQL WHERE) */

    std::string osWHERE{};

    /*! name of the geometry field on which the spatial filter operates on. */

    std::string osGeomField{};

    /*! whether osGeomField is set (useful for empty strings) */

    bool bGeomFieldSet = false;

    /*! whether -select has been specified. This is of course true when

     * !aosSelFields.empty(), but this can also be set when an empty string

     * has been to disable fields. */

    bool bSelFieldsSet = false;

    /*! list of fields from input layer to copy to the new layer.

     * Geometry fields can also be specified in the list. */

    CPLStringList aosSelFields{};

    /*! SQL statement to execute. The resulting table/layer will be saved to the

     * output. */

    std::string osSQLStatement{};

    /*! SQL dialect. In some cases can be used to use (unoptimized) OGR SQL

       instead of the native SQL of an RDBMS by using "OGRSQL". The "SQLITE"

       dialect can also be used with any datasource. */

    std::string osDialect{};

    /*! the geometry type for the created layer */

    int eGType = GEOMTYPE_UNCHANGED;

    GeomTypeConversion eGeomTypeConversion = GTC_DEFAULT;

    /*! Geometric operation to perform */

    GeomOperation eGeomOp = GEOMOP_NONE;

    /*! the parameter to geometric operation */

    double dfGeomOpParam = 0;

    /*! Whether to run MakeValid */

    bool bMakeValid = false;

    /*! Whether to run OGRGeometry::IsValid */

    bool bSkipInvalidGeom = false;

    /*! list of field types to convert to a field of type string in the

       destination layer. Valid types are: Integer, Integer64, Real, String,

       Date, Time, DateTime, Binary, IntegerList, Integer64List, RealList,

       StringList. Special value "All" can be used to convert all fields to

       strings. This is an alternate way to using the CAST operator of OGR SQL,

       that may avoid typing a long SQL query. Note that this does not influence

       the field types used by the source driver, and is only an afterwards

        conversion. */

    CPLStringList aosFieldTypesToString{};

    /*! list of field types and the field type after conversion in the

       destination layer.

        ("srctype1=dsttype1","srctype2=dsttype2",...).

        Valid types are : Integer, Integer64, Real, String, Date, Time,

       DateTime, Binary, IntegerList, Integer64List, RealList, StringList. Types

       can also include subtype between parenthesis, such as Integer(Boolean),

       Real(Float32), ... Special value "All" can be used to convert all fields

       to another type. This is an alternate way to using the CAST operator of

       OGR SQL, that may avoid typing a long SQL query. This is a generalization

       of GDALVectorTranslateOptions::papszFieldTypeToString. Note that this

       does not influence the field types used by the source driver, and is only

       an afterwards conversion. */

    CPLStringList aosMapFieldType{};

    /*! set field width and precision to 0 */

    bool bUnsetFieldWidth = false;

    /*! display progress on terminal. Only works if input layers have the "fast

    feature count" capability */

    bool bDisplayProgress = false;

    /*! split geometries crossing the dateline meridian */

    bool bWrapDateline = false;

    /*! offset from dateline in degrees (default long. = +/- 10deg, geometries

    within 170deg to -170deg will be split) */

    double dfDateLineOffset = 10.0;

    /*! clip geometries when it is set to true */

    bool bClipSrc = false;

    std::shared_ptr<OGRGeometry> poClipSrc{};

    /*! clip datasource */

    std::string osClipSrcDS{};

    /*! select desired geometries using an SQL query */

    std::string osClipSrcSQL{};

    /*! selected named layer from the source clip datasource */

    std::string osClipSrcLayer{};

    /*! restrict desired geometries based on attribute query */

    std::string osClipSrcWhere{};

    std::shared_ptr<OGRGeometry> poClipDst{};

    /*! destination clip datasource */

    std::string osClipDstDS{};

    /*! select desired geometries using an SQL query */

    std::string osClipDstSQL{};

    /*! selected named layer from the destination clip datasource */

    std::string osClipDstLayer{};

    /*! restrict desired geometries based on attribute query */

    std::string osClipDstWhere{};

    /*! split fields of type StringList, RealList or IntegerList into as many

       fields of type String, Real or Integer as necessary. */

    bool bSplitListFields = false;

    /*! limit the number of subfields created for each split field. */

    int nMaxSplitListSubFields = -1;

    /*! produce one feature for each geometry in any kind of geometry collection

       in the source file */

    bool bExplodeCollections = false;

    /*! uses the specified field to fill the Z coordinates of geometries */

    std::string osZField{};

    /*! the list of field indexes to be copied from the source to the

       destination. The (n)th value specified in the list is the index of the

       field in the target layer definition in which the n(th) field of the

       source layer must be copied. Index count starts at zero. There must be

        exactly as many values in the list as the count of the fields in the

       source layer. We can use the "identity" option to specify that the fields

       should be transferred by using the same order. This option should be used

       along with the GDALVectorTranslateOptions::eAccessMode = ACCESS_APPEND

       option. */

    CPLStringList aosFieldMap{};

    /*! force the coordinate dimension to nCoordDim (valid values are 2 or 3).

       This affects both the layer geometry type, and feature geometries. */

    int nCoordDim = COORD_DIM_UNCHANGED;

    /*! destination dataset open option (format specific), only valid in update

     * mode */

    CPLStringList aosDestOpenOptions{};

    /*! If set to true, does not propagate not-nullable constraints to target

       layer if they exist in source layer */

    bool bForceNullable = false;

    /*! If set to true, for each field with a coded field domains, create a

       field that contains the description of the coded value. */

    bool bResolveDomains = false;

    /*! If set to true, empty string values will be treated as null */

    bool bEmptyStrAsNull = false;

    /*! If set to true, does not propagate default field values to target layer

       if they exist in source layer */

    bool bUnsetDefault = false;

    /*! to prevent the new default behavior that consists in, if the output

       driver has a FID layer creation option and we are not in append mode, to

       preserve the name of the source FID column and source feature IDs */

    bool bUnsetFid = false;

    /*! use the FID of the source features instead of letting the output driver

       to automatically assign a new one. If not in append mode, this behavior

       becomes the default if the output driver has a FID layer creation option.

       In which case the name of the source FID column will be used and source

       feature IDs will be attempted to be preserved. This behavior can be

        disabled by option GDALVectorTranslateOptions::bUnsetFid */

    bool bPreserveFID = false;

    /*! set it to false to disable copying of metadata from source dataset and

       layers into target dataset and layers, when supported by output driver.

     */

    bool bCopyMD = true;

    /*! list of metadata key and value to set on the output dataset, when

       supported by output driver.

        ("META-TAG1=VALUE1","META-TAG2=VALUE2") */

    CPLStringList aosMetadataOptions{};

    /*! override spatial filter SRS */

    std::string osSpatSRSDef{};

    /*! list of ground control points to be added */

    std::vector<gdal::GCP> asGCPs{};

    /*! order of polynomial used for warping (1 to 3). The default is to select

       a polynomial order based on the number of GCPs */

    int nTransformOrder = 0;

    /*! spatial query extents, in the SRS of the source layer(s) (or the one

       specified with GDALVectorTranslateOptions::pszSpatSRSDef). Only features

       whose geometry intersects the extents will be selected. The geometries

       will not be clipped unless GDALVectorTranslateOptions::bClipSrc is true.

     */

    std::shared_ptr<OGRGeometry> poSpatialFilter{};

    /*! the progress function to use */

    GDALProgressFunc pfnProgress = nullptr;

    /*! pointer to the progress data variable */

    void *pProgressData = nullptr;

    /*! Whether layer and feature native data must be transferred. */

    bool bNativeData = true;

    /*! Maximum number of features, or -1 if no limit. */

    GIntBig nLimit = -1;

    /*! Wished offset w.r.t UTC of dateTime */

    int nTZOffsetInSec = TZ_OFFSET_INVALID;

    /*! Geometry X,Y coordinate resolution */

    double dfXYRes = OGRGeomCoordinatePrecision::UNKNOWN;

    /*! Unit of dXYRes. empty string, "m", "mm" or "deg" */

    std::string osXYResUnit{};

    /*! Geometry Z coordinate resolution */

    double dfZRes = OGRGeomCoordinatePrecision::UNKNOWN;

    /*! Unit of dfZRes. empty string, "m" or "mm" */

    std::string osZResUnit{};

    /*! Geometry M coordinate resolution */

    double dfMRes = OGRGeomCoordinatePrecision::UNKNOWN;

    /*! Whether to unset geometry coordinate precision */

    bool bUnsetCoordPrecision = false;

    /*! set to true to prevent overwriting existing dataset */

    bool bNoOverwrite = false;

    /*! set to true to customize error messages when called from "new" (GDAL 3.11) CLI or Algorithm API */

    bool bInvokedFromGdalAlgorithm = false;

};

struct TargetLayerInfo

{

    OGRLayer *m_poSrcLayer = nullptr;

    GIntBig m_nFeaturesRead = 0;

    bool m_bPerFeatureCT = 0;

    OGRLayer *m_poDstLayer = nullptr;

    bool m_bUseWriteArrowBatch = false;

    struct ReprojectionInfo

    {

        std::unique_ptr<OGRCoordinateTransformation> m_poCT{};

        CPLStringList m_aosTransformOptions{};

        bool m_bCanInvalidateValidity = true;

        bool m_bWarnAboutDifferentCoordinateOperations = false;

        double m_dfLeftX = std::numeric_limits<double>::max();

        double m_dfLeftY = 0;

        double m_dfLeftZ = 0;

        double m_dfRightX = -std::numeric_limits<double>::max();

        double m_dfRightY = 0;

        double m_dfRightZ = 0;

        double m_dfBottomX = 0;

        double m_dfBottomY = std::numeric_limits<double>::max();

        double m_dfBottomZ = 0;

        double m_dfTopX = 0;

        double m_dfTopY = -std::numeric_limits<double>::max();

        double m_dfTopZ = 0;

        void UpdateExtremePoints(double dfX, double dfY, double dfZ)

        {

            if (dfX < m_dfLeftX)

            {

                m_dfLeftX = dfX;

                m_dfLeftY = dfY;

                m_dfLeftZ = dfZ;

            }

            if (dfX > m_dfRightX)

            {

                m_dfRightX = dfX;

                m_dfRightY = dfY;

                m_dfRightZ = dfZ;

            }

            if (dfY < m_dfBottomY)

            {

                m_dfBottomX = dfX;

                m_dfBottomY = dfY;

                m_dfBottomZ = dfZ;

            }

            if (dfY > m_dfTopY)

            {

                m_dfTopX = dfX;

                m_dfTopY = dfY;

                m_dfTopZ = 0;

            }

        }

    };

    std::vector<ReprojectionInfo> m_aoReprojectionInfo{};

    std::vector<int> m_anMap{};

    struct ResolvedInfo

    {

        int nSrcField;

        const OGRFieldDomain *poDomain;

    };

    std::map<int, ResolvedInfo> m_oMapResolved{};

    std::map<const OGRFieldDomain *, std::map<std::string, std::string>>

        m_oMapDomainToKV{};

    int m_iSrcZField = -1;

    int m_iSrcFIDField = -1;

    int m_iRequestedSrcGeomField = -1;

    bool m_bPreserveFID = false;

    const char *m_pszCTPipeline = nullptr;

    CPLStringList m_aosCTOptions{};

    bool m_bCanAvoidSetFrom = false;

    const char *m_pszSpatSRSDef = nullptr;

    OGRGeometryH m_hSpatialFilter = nullptr;

    const char *m_pszGeomField = nullptr;

    std::vector<int> m_anDateTimeFieldIdx{};

    bool m_bSupportCurves = false;

    bool m_bSupportZ = false;

    bool m_bSupportM = false;

    bool m_bHasWarnedAboutCurves = false;

    bool m_bHasWarnedAboutZ = false;

    bool m_bHasWarnedAboutM = false;

    OGRArrowArrayStream m_sArrowArrayStream{};

    void CheckSameCoordinateOperation() const;

};

struct AssociatedLayers

{

    OGRLayer *poSrcLayer = nullptr;

    std::unique_ptr<TargetLayerInfo> psInfo{};

};

class SetupTargetLayer

{

  public:

    GDALDataset *m_poSrcDS = nullptr;

    GDALDataset *m_poDstDS = nullptr;

    CSLConstList m_papszLCO = nullptr;

    const OGRSpatialReference *m_poUserSourceSRS = nullptr;

    const OGRSpatialReference *m_poOutputSRS = nullptr;

    bool m_bTransform = false;

    bool m_bNullifyOutputSRS = false;

    bool m_bSelFieldsSet = false;

    CSLConstList m_papszSelFields = nullptr;

    bool m_bAppend = false;

    bool m_bAddMissingFields = false;

    int m_eGType = 0;

    GeomTypeConversion m_eGeomTypeConversion = GTC_DEFAULT;

    int m_nCoordDim = 0;

    bool m_bOverwrite = false;

    CSLConstList m_papszFieldTypesToString = nullptr;

    CSLConstList m_papszMapFieldType = nullptr;

    bool m_bUnsetFieldWidth = false;

    bool m_bExplodeCollections = false;

    const char *m_pszZField = nullptr;

    CSLConstList m_papszFieldMap = nullptr;

    const char *m_pszWHERE = nullptr;

    bool m_bExactFieldNameMatch = false;

    bool m_bQuiet = false;

    bool m_bForceNullable = false;

    bool m_bResolveDomains = false;

    bool m_bUnsetDefault = false;

    bool m_bUnsetFid = false;

    bool m_bPreserveFID = false;

    bool m_bCopyMD = false;

    bool m_bNativeData = false;

    bool m_bNewDataSource = false;

    const char *m_pszCTPipeline = nullptr;

    CPLStringList m_aosCTOptions{};

    std::unique_ptr<TargetLayerInfo>

    Setup(OGRLayer *poSrcLayer, const char *pszNewLayerName,

          GDALVectorTranslateOptions *psOptions, GIntBig &nTotalEventsDone);

  private:

    bool CanUseWriteArrowBatch(OGRLayer *poSrcLayer, OGRLayer *poDstLayer,

                               bool bJustCreatedLayer,

                               const GDALVectorTranslateOptions *psOptions,

                               bool bPreserveFID, bool &bError,

                               OGRArrowArrayStream &streamSrc);

    void SetIgnoredFields(OGRLayer *poSrcLayer);

};

class LayerTranslator

{

    bool TranslateArrow(TargetLayerInfo *psInfo, GIntBig nCountLayerFeatures,

                        GIntBig *pnReadFeatureCount,

                        GDALProgressFunc pfnProgress, void *pProgressArg,

                        const GDALVectorTranslateOptions *psOptions);

  public:

    GDALDataset *m_poSrcDS = nullptr;

    GDALDataset *m_poODS = nullptr;

    bool m_bTransform = false;

    bool m_bWrapDateline = false;

    CPLString m_osDateLineOffset{};

    const OGRSpatialReference *m_poOutputSRS = nullptr;

    bool m_bNullifyOutputSRS = false;

    const OGRSpatialReference *m_poUserSourceSRS = nullptr;

    OGRCoordinateTransformation *m_poGCPCoordTrans = nullptr;

    int m_eGType = -1;

    GeomTypeConversion m_eGeomTypeConversion = GTC_DEFAULT;

    bool m_bMakeValid = false;

    bool m_bSkipInvalidGeom = false;

    int m_nCoordDim = 0;

    GeomOperation m_eGeomOp = GEOMOP_NONE;

    double m_dfGeomOpParam = 0;

    OGRGeometry *m_poClipSrcOri = nullptr;

    bool m_bWarnedClipSrcSRS = false;

    std::unique_ptr<OGRGeometry> m_poClipSrcReprojectedToSrcSRS{};

    const OGRSpatialReference *m_poClipSrcReprojectedToSrcSRS_SRS = nullptr;

    OGREnvelope m_oClipSrcEnv{};

    bool m_bClipSrcIsRectangle = false;

    OGRGeometry *m_poClipDstOri = nullptr;

    bool m_bWarnedClipDstSRS = false;

    std::unique_ptr<OGRGeometry> m_poClipDstReprojectedToDstSRS{};

    const OGRSpatialReference *m_poClipDstReprojectedToDstSRS_SRS = nullptr;

    OGREnvelope m_oClipDstEnv{};

    bool m_bClipDstIsRectangle = false;

    bool m_bExplodeCollections = false;

    bool m_bNativeData = false;

    GIntBig m_nLimit = -1;

    OGRGeometryFactory::TransformWithOptionsCache m_transformWithOptionsCache{};

    bool Translate(std::unique_ptr<OGRFeature> poFeatureIn,

                   TargetLayerInfo *psInfo, GIntBig nCountLayerFeatures,

                   GIntBig *pnReadFeatureCount, GIntBig &nTotalEventsDone,

                   GDALProgressFunc pfnProgress, void *pProgressArg,

                   const GDALVectorTranslateOptions *psOptions);

  private:

    struct ClipGeomDesc

    {

        const OGRGeometry *poGeom = nullptr;

        const OGREnvelope *poEnv = nullptr;

        bool bGeomIsRectangle = false;

    };

    ClipGeomDesc GetDstClipGeom(const OGRSpatialReference *poGeomSRS);

    ClipGeomDesc GetSrcClipGeom(const OGRSpatialReference *poGeomSRS);

};

static OGRLayer *GetLayerAndOverwriteIfNecessary(GDALDataset *poDstDS,

                                                 const char *pszNewLayerName,

                                                 bool bOverwrite,

                                                 bool *pbErrorOccurred,

                                                 bool *pbOverwriteActuallyDone,

                                                 bool *pbAddOverwriteLCO);

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

/*                            LoadGeometry()                            */

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

static std::unique_ptr<OGRGeometry> LoadGeometry(const std::string &osDS,

                                                 const std::string &osSQL,

                                                 const std::string &osLyr,

                                                 const std::string &osWhere,

                                                 bool bMakeValid)

{

    auto poDS = std::unique_ptr<GDALDataset>(

        GDALDataset::Open(osDS.c_str(), GDAL_OF_VECTOR));

    if (poDS == nullptr)

        return nullptr;

    OGRLayer *poLyr = nullptr;

    if (!osSQL.empty())

        poLyr = poDS->ExecuteSQL(osSQL.c_str(), nullptr, nullptr);

    else if (!osLyr.empty())

        poLyr = poDS->GetLayerByName(osLyr.c_str());

    else

        poLyr = poDS->GetLayer(0);

    if (poLyr == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Failed to identify source layer from datasource.");

        return nullptr;

    }

    if (!osWhere.empty())

        poLyr->SetAttributeFilter(osWhere.c_str());

    OGRGeometryCollection oGC;

    const auto poSRSSrc = poLyr->GetSpatialRef();

    if (poSRSSrc)

    {

        auto poSRSClone = poSRSSrc->Clone();

        oGC.assignSpatialReference(poSRSClone);

        poSRSClone->Release();

    }

    for (auto &poFeat : poLyr)

    {

        auto poSrcGeom = std::unique_ptr<OGRGeometry>(poFeat->StealGeometry());

        if (poSrcGeom)

        {

            // Only take into account areal geometries.

            if (poSrcGeom->getDimension() == 2)

            {

                if (!poSrcGeom->IsValid())

                {

                    if (!bMakeValid)

                    {

                        CPLError(CE_Failure, CPLE_AppDefined,

                                 "Geometry of feature " CPL_FRMT_GIB " of %s "

                                 "is invalid. You can try to make it valid by "

                                 "specifying -makevalid, but the results of "

                                 "the operation should be manually inspected.",

                                 poFeat->GetFID(), osDS.c_str());

                        oGC.empty();

                        break;

                    }

                    auto poValid =

                        std::unique_ptr<OGRGeometry>(poSrcGeom->MakeValid());

                    if (poValid)

                    {

                        CPLError(CE_Warning, CPLE_AppDefined,

                                 "Geometry of feature " CPL_FRMT_GIB " of %s "

                                 "was invalid and has been made valid, "

                                 "but the results of the operation "

                                 "should be manually inspected.",

                                 poFeat->GetFID(), osDS.c_str());

                        oGC.addGeometry(std::move(poValid));

                    }

                    else

                    {

                        CPLError(CE_Failure, CPLE_AppDefined,

                                 "Geometry of feature " CPL_FRMT_GIB " of %s "

                                 "is invalid, and could not be made valid.",

                                 poFeat->GetFID(), osDS.c_str());

                        oGC.empty();

                        break;

                    }

                }

                else

                {

                    oGC.addGeometry(std::move(poSrcGeom));

                }

            }

        }

    }

    if (!osSQL.empty())

        poDS->ReleaseResultSet(poLyr);

    if (oGC.IsEmpty())

        return nullptr;

    return std::unique_ptr<OGRGeometry>(oGC.UnaryUnion());

}

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

/*                        OGRSplitListFieldLayer                        */

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

class OGRSplitListFieldLayer : public OGRLayer

{

    struct ListFieldDesc

    {

        int iSrcIndex = -1;

        OGRFieldType eType = OFTMaxType;

        int nMaxOccurrences = 0;

        int nWidth = 0;

    };

    OGRLayer *poSrcLayer = nullptr;

    OGRFeatureDefn *poFeatureDefn = nullptr;

    std::vector<ListFieldDesc> asListFields{};

    const int nMaxSplitListSubFields;

    std::unique_ptr<OGRFeature>

    TranslateFeature(std::unique_ptr<OGRFeature> poSrcFeature) const;

    CPL_DISALLOW_COPY_ASSIGN(OGRSplitListFieldLayer)

  public:

    OGRSplitListFieldLayer(OGRLayer *poSrcLayer, int nMaxSplitListSubFields);

    ~OGRSplitListFieldLayer() override;

    bool BuildLayerDefn(GDALProgressFunc pfnProgress, void *pProgressArg);

    OGRFeature *GetNextFeature() override;

    OGRFeature *GetFeature(GIntBig nFID) override;

    const OGRFeatureDefn *GetLayerDefn() const override;

    void ResetReading() override

    {

        poSrcLayer->ResetReading();

    }

    int TestCapability(const char *) const override

    {

        return FALSE;

    }

    GIntBig GetFeatureCount(int bForce = TRUE) override

    {

        return poSrcLayer->GetFeatureCount(bForce);

    }

    const OGRSpatialReference *GetSpatialRef() const override

    {

        return poSrcLayer->GetSpatialRef();

    }

    OGRGeometry *GetSpatialFilter() override

    {

        return poSrcLayer->GetSpatialFilter();

    }

    OGRStyleTable *GetStyleTable() override

    {

        return poSrcLayer->GetStyleTable();

    }

    virtual OGRErr ISetSpatialFilter(int iGeom,

                                     const OGRGeometry *poGeom) override

    {

        return poSrcLayer->SetSpatialFilter(iGeom, poGeom);

    }

    OGRErr SetAttributeFilter(const char *pszFilter) override

    {

        return poSrcLayer->SetAttributeFilter(pszFilter);

    }

};

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

/*                       OGRSplitListFieldLayer()                       */

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

OGRSplitListFieldLayer::OGRSplitListFieldLayer(OGRLayer *poSrcLayerIn,

                                               int nMaxSplitListSubFieldsIn)

    : poSrcLayer(poSrcLayerIn),

      nMaxSplitListSubFields(

          nMaxSplitListSubFieldsIn < 0 ? INT_MAX : nMaxSplitListSubFieldsIn)

{

}

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

/*                      ~OGRSplitListFieldLayer()                       */

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

OGRSplitListFieldLayer::~OGRSplitListFieldLayer()

{

    if (poFeatureDefn)

        poFeatureDefn->Release();

}

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

/*                           BuildLayerDefn()                           */

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

bool OGRSplitListFieldLayer::BuildLayerDefn(GDALProgressFunc pfnProgress,

                                            void *pProgressArg)

{

    CPLAssert(poFeatureDefn == nullptr);

    const OGRFeatureDefn *poSrcFeatureDefn = poSrcLayer->GetLayerDefn();

    const int nSrcFields = poSrcFeatureDefn->GetFieldCount();

    asListFields.reserve(nSrcFields);

    /* Establish the list of fields of list type */

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

    {

        OGRFieldType eType = poSrcFeatureDefn->GetFieldDefn(i)->GetType();

        if (eType == OFTIntegerList || eType == OFTInteger64List ||

            eType == OFTRealList || eType == OFTStringList)

        {

            asListFields.resize(asListFields.size() + 1);

            asListFields.back().iSrcIndex = i;

            asListFields.back().eType = eType;

            if (nMaxSplitListSubFields == 1)

                asListFields.back().nMaxOccurrences = 1;

        }

    }

    if (asListFields.empty())

        return false;

    /* No need for full scan if the limit is 1. We just to have to create */

    /* one and a single one field */

    if (nMaxSplitListSubFields != 1)

    {

        poSrcLayer->ResetReading();

        const GIntBig nFeatureCount =

            poSrcLayer->TestCapability(OLCFastFeatureCount)

                ? poSrcLayer->GetFeatureCount()

                : 0;

        GIntBig nFeatureIndex = 0;

        /* Scan the whole layer to compute the maximum number of */

        /* items for each field of list type */

        for (const auto &poSrcFeature : poSrcLayer)

        {

            for (auto &sListField : asListFields)

            {

                int nCount = 0;

                const OGRField *psField =

                    poSrcFeature->GetRawFieldRef(sListField.iSrcIndex);

                switch (sListField.eType)

                {

                    case OFTIntegerList:

                        nCount = psField->IntegerList.nCount;

                        break;

                    case OFTRealList:

                        nCount = psField->RealList.nCount;

                        break;

                    case OFTStringList:

                    {

                        nCount = psField->StringList.nCount;

                        char **paList = psField->StringList.paList;

                        for (int j = 0; j < nCount; j++)

                        {

                            int nWidth = static_cast<int>(strlen(paList[j]));

                            if (nWidth > sListField.nWidth)

                                sListField.nWidth = nWidth;

                        }

                        break;

                    }

                    default:

                        // cppcheck-suppress knownConditionTrueFalse

                        CPLAssert(false);

                        break;

                }

                if (nCount > sListField.nMaxOccurrences)

                {

                    if (nCount > nMaxSplitListSubFields)

                        nCount = nMaxSplitListSubFields;

                    sListField.nMaxOccurrences = nCount;

                }

            }

            nFeatureIndex++;

            if (pfnProgress != nullptr && nFeatureCount != 0)

                pfnProgress(nFeatureIndex * 1.0 / nFeatureCount, "",

                            pProgressArg);

        }

    }

    /* Now let's build the target feature definition */

    poFeatureDefn =

        OGRFeatureDefn::CreateFeatureDefn(poSrcFeatureDefn->GetName());

    poFeatureDefn->Reference();

    poFeatureDefn->SetGeomType(wkbNone);

    for (const auto poSrcGeomFieldDefn : poSrcFeatureDefn->GetGeomFields())

    {

        poFeatureDefn->AddGeomFieldDefn(poSrcGeomFieldDefn);

    }

    int iListField = 0;

    for (const auto poSrcFieldDefn : poSrcFeatureDefn->GetFields())

    {

        const OGRFieldType eType = poSrcFieldDefn->GetType();

        if (eType == OFTIntegerList || eType == OFTInteger64List ||

            eType == OFTRealList || eType == OFTStringList)

        {

            const int nMaxOccurrences =

                asListFields[iListField].nMaxOccurrences;

            const int nWidth = asListFields[iListField].nWidth;

            iListField++;

            if (nMaxOccurrences == 1)

            {

                OGRFieldDefn oFieldDefn(poSrcFieldDefn->GetNameRef(),

                                        (eType == OFTIntegerList) ? OFTInteger

                                        : (eType == OFTInteger64List)

                                            ? OFTInteger64

                                        : (eType == OFTRealList) ? OFTReal

                                                                 : OFTString);

                poFeatureDefn->AddFieldDefn(&oFieldDefn);

            }

            else

            {

                for (int j = 0; j < nMaxOccurrences; j++)

                {

                    CPLString osFieldName;

                    osFieldName.Printf("%s%d", poSrcFieldDefn->GetNameRef(),

                                       j + 1);

                    OGRFieldDefn oFieldDefn(

                        osFieldName.c_str(),

                        (eType == OFTIntegerList)     ? OFTInteger

                        : (eType == OFTInteger64List) ? OFTInteger64

                        : (eType == OFTRealList)      ? OFTReal

                                                      : OFTString);

                    oFieldDefn.SetWidth(nWidth);

                    poFeatureDefn->AddFieldDefn(&oFieldDefn);

                }

            }

        }

        else

        {

            poFeatureDefn->AddFieldDefn(poSrcFieldDefn);

        }

    }

    return true;

}

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

/*                          TranslateFeature()                          */

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

std::unique_ptr<OGRFeature> OGRSplitListFieldLayer::TranslateFeature(

    std::unique_ptr<OGRFeature> poSrcFeature) const

{

    if (poSrcFeature == nullptr)

        return nullptr;

    if (poFeatureDefn == nullptr)

        return poSrcFeature;

    auto poFeature = std::make_unique<OGRFeature>(poFeatureDefn);

    poFeature->SetFID(poSrcFeature->GetFID());

    for (int i = 0; i < poFeature->GetGeomFieldCount(); i++)

    {

        poFeature->SetGeomFieldDirectly(i, poSrcFeature->StealGeometry(i));

    }

    poFeature->SetStyleString(poFeature->GetStyleString());

    const OGRFeatureDefn *poSrcFieldDefn = poSrcLayer->GetLayerDefn();

    const int nSrcFields = poSrcFeature->GetFieldCount();