qgsvectorfilewriter.cpp

Go to the documentation of this file.

/***************************************************************************
                          qgsvectorfilewriter.cpp
                          generic vector file writer
                             -------------------
    begin                : Sat Jun 16 2004
    copyright            : (C) 2004 by Tim Sutton
    email                : tim at linfiniti.com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsvectorfilewriter.h"
 
#include <cassert>
#include <cpl_conv.h>
#include <cpl_error.h>
#include <cpl_string.h>
#include <cstdlib>
#include <gdal.h>
#include <limits>
#include <memory>
#include <ogr_srs_api.h>
 
#include "qgsapplication.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsexpressioncontextutils.h"
#include "qgsfielddomain.h"
#include "qgsfields.h"
#include "qgsgdalutils.h"
#include "qgslocalec.h"
#include "qgslogger.h"
#include "qgsmaplayerutils.h"
#include "qgsmessagelog.h"
#include "qgsogrutils.h"
#include "qgsproviderregistry.h"
#include "qgsreadwritelocker.h"
#include "qgssettings.h"
#include "qgssymbol.h"
#include "qgssymbollayer.h"
#include "qgsvectorlayer.h"
 
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QJsonDocument>
#include <QMetaType>
#include <QMutex>
#include <QRegularExpression>
#include <QSet>
#include <QString>
#include <QTextCodec>
#include <QTextStream>
 
using namespace Qt::StringLiterals;
 
QgsField QgsVectorFileWriter::FieldValueConverter::fieldDefinition( const QgsField &field )
{
  return field;
}
 
QVariant QgsVectorFileWriter::FieldValueConverter::convert( int /*fieldIdxInLayer*/, const QVariant &value )
{
  return value;
}
 
QgsVectorFileWriter::FieldValueConverter *QgsVectorFileWriter::FieldValueConverter::clone() const
{
  return new FieldValueConverter( *this );
}
 
QgsVectorFileWriter::QgsVectorFileWriter(
  const QString &vectorFileName,
  const QString &fileEncoding,
  const QgsFields &fields,
  Qgis::WkbType geometryType,
  const QgsCoordinateReferenceSystem &srs,
  const QString &driverName,
  const QStringList &datasourceOptions,
  const QStringList &layerOptions,
  QString *newFilename,
  Qgis::FeatureSymbologyExport symbologyExport,
  QgsFeatureSink::SinkFlags sinkFlags,
  QString *newLayer,
  const QgsCoordinateTransformContext &transformContext,
  FieldNameSource fieldNameSource
)
  : mError( NoError )
  , mWkbType( geometryType )
  , mSymbologyExport( symbologyExport )
  , mSymbologyScale( 1.0 )
{
  init( vectorFileName, fileEncoding, fields, geometryType, srs, driverName, datasourceOptions, layerOptions, newFilename, nullptr, QString(), CreateOrOverwriteFile, newLayer, sinkFlags, transformContext, fieldNameSource, nullptr );
}
 
QgsVectorFileWriter::QgsVectorFileWriter(
  const QString &vectorFileName,
  const QString &fileEncoding,
  const QgsFields &fields,
  Qgis::WkbType geometryType,
  const QgsCoordinateReferenceSystem &srs,
  const QString &driverName,
  const QStringList &datasourceOptions,
  const QStringList &layerOptions,
  QString *newFilename,
  Qgis::FeatureSymbologyExport symbologyExport,
  FieldValueConverter *fieldValueConverter,
  const QString &layerName,
  ActionOnExistingFile action,
  QString *newLayer,
  const QgsCoordinateTransformContext &transformContext,
  QgsFeatureSink::SinkFlags sinkFlags,
  FieldNameSource fieldNameSource,
  bool includeConstraints,
  bool setFieldDomains,
  const QgsAbstractDatabaseProviderConnection *sourceDatabaseProviderConnection
)
  : mError( NoError )
  , mWkbType( geometryType )
  , mSymbologyExport( symbologyExport )
  , mSymbologyScale( 1.0 )
  , mIncludeConstraints( includeConstraints )
  , mSetFieldDomains( setFieldDomains )
{
  init( vectorFileName, fileEncoding, fields, geometryType, srs, driverName, datasourceOptions, layerOptions, newFilename, fieldValueConverter, layerName, action, newLayer, sinkFlags, transformContext, fieldNameSource, sourceDatabaseProviderConnection );
}
 
QgsVectorFileWriter *QgsVectorFileWriter::create(
  const QString &fileName,
  const QgsFields &fields,
  Qgis::WkbType geometryType,
  const QgsCoordinateReferenceSystem &srs,
  const QgsCoordinateTransformContext &transformContext,
  const QgsVectorFileWriter::SaveVectorOptions &options,
  QgsFeatureSink::SinkFlags sinkFlags,
  QString *newFilename,
  QString *newLayer
)
{
  Q_NOWARN_DEPRECATED_PUSH
  return new QgsVectorFileWriter(
    fileName,
    options.fileEncoding,
    fields,
    geometryType,
    srs,
    options.driverName,
    options.datasourceOptions,
    options.layerOptions,
    newFilename,
    options.symbologyExport,
    options.fieldValueConverter,
    options.layerName,
    options.actionOnExistingFile,
    newLayer,
    transformContext,
    sinkFlags,
    options.fieldNameSource,
    options.includeConstraints,
    options.setFieldDomains,
    options.sourceDatabaseProviderConnection
  );
  Q_NOWARN_DEPRECATED_POP
}
 
bool QgsVectorFileWriter::supportsFeatureStyles( const QString &driverName )
{
  if ( driverName == "MapInfo MIF"_L1 )
  {
    return true;
  }
  GDALDriverH gdalDriver = GDALGetDriverByName( driverName.toLocal8Bit().constData() );
  if ( !gdalDriver )
    return false;
 
  CSLConstList driverMetadata = GDALGetMetadata( gdalDriver, nullptr );
  if ( !driverMetadata )
    return false;
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )
  return CSLFetchBoolean( driverMetadata, GDAL_DCAP_FEATURE_STYLES_WRITE, false );
#else
  return CSLFetchBoolean( driverMetadata, GDAL_DCAP_FEATURE_STYLES, false );
#endif
}
 
void QgsVectorFileWriter::init(
  QString vectorFileName,
  QString fileEncoding,
  const QgsFields &fields,
  Qgis::WkbType geometryType,
  QgsCoordinateReferenceSystem srs,
  const QString &driverName,
  QStringList datasourceOptions,
  QStringList layerOptions,
  QString *newFilename,
  FieldValueConverter *fieldValueConverter,
  const QString &layerNameIn,
  ActionOnExistingFile action,
  QString *newLayer,
  SinkFlags sinkFlags,
  const QgsCoordinateTransformContext &transformContext,
  FieldNameSource fieldNameSource,
  const QgsAbstractDatabaseProviderConnection *sourceDatabaseProviderConnection
)
{
#if GDAL_VERSION_NUM < GDAL_COMPUTE_VERSION( 3, 5, 0 )
  ( void ) sourceDatabaseProviderConnection;
#endif
 
  mRenderContext.setRendererScale( mSymbologyScale );
 
  if ( vectorFileName.isEmpty() )
  {
    mErrorMessage = QObject::tr( "Empty filename given" );
    mError = ErrCreateDataSource;
    return;
  }
 
  if ( driverName == "MapInfo MIF"_L1 )
  {
    mOgrDriverName = u"MapInfo File"_s;
  }
  else if ( driverName == "SpatiaLite"_L1 )
  {
    mOgrDriverName = u"SQLite"_s;
    if ( !datasourceOptions.contains( u"SPATIALITE=YES"_s ) )
    {
      datasourceOptions.append( u"SPATIALITE=YES"_s );
    }
  }
  else if ( driverName == "DBF file"_L1 )
  {
    mOgrDriverName = u"ESRI Shapefile"_s;
    if ( !layerOptions.contains( u"SHPT=NULL"_s ) )
    {
      layerOptions.append( u"SHPT=NULL"_s );
    }
    srs = QgsCoordinateReferenceSystem();
  }
  else
  {
    mOgrDriverName = driverName;
  }
 
#if GDAL_VERSION_NUM < GDAL_COMPUTE_VERSION( 3, 3, 1 )
  QString fidFieldName;
  if ( mOgrDriverName == "GPKG"_L1 )
  {
    for ( const QString &layerOption : layerOptions )
    {
      if ( layerOption.startsWith( "FID="_L1 ) )
      {
        fidFieldName = layerOption.mid( 4 );
        break;
      }
    }
    if ( fidFieldName.isEmpty() )
      fidFieldName = u"fid"_s;
  }
#endif
 
  // find driver in OGR
  OGRSFDriverH poDriver;
  QgsApplication::registerOgrDrivers();
 
  poDriver = OGRGetDriverByName( mOgrDriverName.toLocal8Bit().constData() );
 
  if ( !poDriver )
  {
    mErrorMessage = QObject::tr( "OGR driver for '%1' not found (OGR error: %2)" ).arg( driverName, QString::fromUtf8( CPLGetLastErrorMsg() ) );
    mError = ErrDriverNotFound;
    return;
  }
 
  mOgrDriverLongName = QString( GDALGetMetadataItem( poDriver, GDAL_DMD_LONGNAME, nullptr ) );
 
  MetaData metadata;
  bool metadataFound = driverMetadata( driverName, metadata );
 
  if ( mOgrDriverName == "ESRI Shapefile"_L1 )
  {
    if ( layerOptions.join( QString() ).toUpper().indexOf( "ENCODING="_L1 ) == -1 )
    {
      layerOptions.append( "ENCODING=" + convertCodecNameForEncodingOption( fileEncoding ) );
    }
 
    if ( driverName == "ESRI Shapefile"_L1 && !vectorFileName.endsWith( ".shp"_L1, Qt::CaseInsensitive ) )
    {
      vectorFileName += ".shp"_L1;
    }
    else if ( driverName == "DBF file"_L1 && !vectorFileName.endsWith( ".dbf"_L1, Qt::CaseInsensitive ) )
    {
      vectorFileName += ".dbf"_L1;
    }
 
    if ( action == CreateOrOverwriteFile || action == CreateOrOverwriteLayer )
      deleteShapeFile( vectorFileName );
  }
  else
  {
    if ( metadataFound )
    {
      QStringList allExts = metadata.glob.split( ' ', Qt::SkipEmptyParts );
      bool found = false;
      const auto constAllExts = allExts;
      for ( const QString &ext : constAllExts )
      {
        // Remove the wildcard (*) at the beginning of the extension
        if ( vectorFileName.endsWith( ext.mid( 1 ), Qt::CaseInsensitive ) )
        {
          found = true;
          break;
        }
      }
 
      if ( !found )
      {
        allExts = metadata.ext.split( ' ', Qt::SkipEmptyParts );
        vectorFileName += '.' + allExts[0];
      }
    }
 
    if ( action == CreateOrOverwriteFile )
    {
      if ( vectorFileName.endsWith( ".gdb"_L1, Qt::CaseInsensitive ) )
      {
        QDir dir( vectorFileName );
        if ( dir.exists() )
        {
          QFileInfoList fileList = dir.entryInfoList( QDir::NoDotAndDotDot | QDir::System | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst );
          const auto constFileList = fileList;
          for ( const QFileInfo &info : constFileList )
          {
            QFile::remove( info.absoluteFilePath() );
          }
        }
        QDir().rmdir( vectorFileName );
      }
      else
      {
        QFile::remove( vectorFileName );
      }
    }
  }
 
  if ( metadataFound && !metadata.compulsoryEncoding.isEmpty() )
  {
    if ( fileEncoding.compare( metadata.compulsoryEncoding, Qt::CaseInsensitive ) != 0 )
    {
      QgsDebugMsgLevel( u"forced %1 encoding for %2"_s.arg( metadata.compulsoryEncoding, driverName ), 2 );
      fileEncoding = metadata.compulsoryEncoding;
    }
  }
 
  char **options = nullptr;
  if ( !datasourceOptions.isEmpty() )
  {
    options = new char *[datasourceOptions.size() + 1];
    for ( int i = 0; i < datasourceOptions.size(); i++ )
    {
      QgsDebugMsgLevel( u"-dsco=%1"_s.arg( datasourceOptions[i] ), 2 );
      options[i] = CPLStrdup( datasourceOptions[i].toUtf8().constData() );
    }
    options[datasourceOptions.size()] = nullptr;
  }
 
  // create the data source
  if ( action == CreateOrOverwriteFile )
    mDS.reset( OGR_Dr_CreateDataSource( poDriver, vectorFileName.toUtf8().constData(), options ) );
  else
    mDS.reset( OGROpen( vectorFileName.toUtf8().constData(), TRUE, nullptr ) );
 
  if ( options )
  {
    for ( int i = 0; i < datasourceOptions.size(); i++ )
      CPLFree( options[i] );
    delete[] options;
    options = nullptr;
  }
 
  if ( !mDS )
  {
    mError = ErrCreateDataSource;
    if ( action == CreateOrOverwriteFile )
      mErrorMessage = QObject::tr( "Creation of data source failed (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
    else
      mErrorMessage = QObject::tr( "Opening of data source in update mode failed (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
    return;
  }
 
  QString layerName( layerNameIn );
  if ( layerName.isEmpty() )
    layerName = QFileInfo( vectorFileName ).baseName();
 
  if ( action == CreateOrOverwriteLayer )
  {
    const int layer_count = OGR_DS_GetLayerCount( mDS.get() );
    for ( int i = 0; i < layer_count; i++ )
    {
      OGRLayerH hLayer = OGR_DS_GetLayer( mDS.get(), i );
      if ( EQUAL( OGR_L_GetName( hLayer ), layerName.toUtf8().constData() ) )
      {
        if ( OGR_DS_DeleteLayer( mDS.get(), i ) != OGRERR_NONE )
        {
          mError = ErrCreateLayer;
          mErrorMessage = QObject::tr( "Overwriting of existing layer failed (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
          return;
        }
        break;
      }
    }
  }
 
  if ( action == CreateOrOverwriteFile )
  {
    QgsDebugMsgLevel( u"Created data source"_s, 2 );
  }
  else
  {
    QgsDebugMsgLevel( u"Opened data source in update mode"_s, 2 );
  }
 
  // use appropriate codec
  mCodec = QTextCodec::codecForName( fileEncoding.toLocal8Bit().constData() );
  if ( !mCodec )
  {
    QgsDebugError( "error finding QTextCodec for " + fileEncoding );
 
    QgsSettings settings;
    QString enc = settings.value( u"UI/encoding"_s, "System" ).toString();
    mCodec = QTextCodec::codecForName( enc.toLocal8Bit().constData() );
    if ( !mCodec )
    {
      QgsDebugError( "error finding QTextCodec for " + enc );
      mCodec = QTextCodec::codecForLocale();
      Q_ASSERT( mCodec );
    }
  }
 
  // consider spatial reference system of the layer
  if ( driverName == "KML"_L1 || driverName == "LIBKML"_L1 || driverName == "GPX"_L1 )
  {
    if ( srs.authid() != "EPSG:4326"_L1 )
    {
      // Those drivers outputs WGS84 geometries, let's align our output CRS to have QGIS take charge of geometry transformation
      QgsCoordinateReferenceSystem wgs84 = QgsCoordinateReferenceSystem::fromEpsgId( 4326 );
      mCoordinateTransform = std::make_unique<QgsCoordinateTransform>( srs, wgs84, transformContext );
      srs = wgs84;
    }
  }
 
  mOgrRef = QgsOgrUtils::crsToOGRSpatialReference( srs );
 
  // datasource created, now create the output layer
  const OGRwkbGeometryType wkbType = ogrTypeFromWkbType( geometryType );
  if ( wkbType == wkbUnknown && geometryType != Qgis::WkbType::Unknown )
  {
    mError = ErrCreateLayer;
    mErrorMessage = QObject::tr( "QGIS geometry type %1 is not supported by GDAL" ).arg( QgsWkbTypes::translatedDisplayString( geometryType ) );
    return;
  }
 
  // Remove FEATURE_DATASET layer option (used for ESRI File GDB driver) if its value is not set
  int optIndex = layerOptions.indexOf( "FEATURE_DATASET="_L1 );
  if ( optIndex != -1 )
  {
    layerOptions.removeAt( optIndex );
  }
 
  if ( !layerOptions.isEmpty() )
  {
    options = new char *[layerOptions.size() + 1];
    for ( int i = 0; i < layerOptions.size(); i++ )
    {
      QgsDebugMsgLevel( u"-lco=%1"_s.arg( layerOptions[i] ), 2 );
      options[i] = CPLStrdup( layerOptions[i].toUtf8().constData() );
    }
    options[layerOptions.size()] = nullptr;
  }
 
  // disable encoding conversion of OGR Shapefile layer
  CPLSetConfigOption( "SHAPE_ENCODING", "" );
 
  if ( action == CreateOrOverwriteFile || action == CreateOrOverwriteLayer )
  {
    mLayer = OGR_DS_CreateLayer( mDS.get(), layerName.toUtf8().constData(), mOgrRef, wkbType, options );
    if ( newLayer && mLayer )
    {
      *newLayer = OGR_L_GetName( mLayer );
      if ( driverName == "GPX"_L1 )
      {
        // See logic in GDAL ogr/ogrsf_frmts/gpx/ogrgpxdatasource.cpp ICreateLayer()
        switch ( QgsWkbTypes::flatType( geometryType ) )
        {
          case Qgis::WkbType::Point:
          {
            if ( !EQUAL( layerName.toUtf8().constData(), "track_points" ) && !EQUAL( layerName.toUtf8().constData(), "route_points" ) )
            {
              *newLayer = u"waypoints"_s;
            }
          }
          break;
 
          case Qgis::WkbType::LineString:
          {
            const char *pszForceGPXTrack = CSLFetchNameValue( options, "FORCE_GPX_TRACK" );
            if ( pszForceGPXTrack && CPLTestBool( pszForceGPXTrack ) )
              *newLayer = u"tracks"_s;
            else
              *newLayer = u"routes"_s;
          }
          break;
 
          case Qgis::WkbType::MultiLineString:
          {
            const char *pszForceGPXRoute = CSLFetchNameValue( options, "FORCE_GPX_ROUTE" );
            if ( pszForceGPXRoute && CPLTestBool( pszForceGPXRoute ) )
              *newLayer = u"routes"_s;
            else
              *newLayer = u"tracks"_s;
          }
          break;
 
          default:
            break;
        }
      }
    }
  }
  else if ( driverName == "DGN"_L1 )
  {
    mLayer = OGR_DS_GetLayerByName( mDS.get(), "elements" );
  }
  else
  {
    mLayer = OGR_DS_GetLayerByName( mDS.get(), layerName.toUtf8().constData() );
  }
 
  if ( options )
  {
    for ( int i = 0; i < layerOptions.size(); i++ )
      CPLFree( options[i] );
    delete[] options;
    options = nullptr;
  }
 
  if ( srs.isValid() )
  {
    if ( mOgrDriverName == "ESRI Shapefile"_L1 )
    {
      QString layerName = vectorFileName.left( vectorFileName.indexOf( ".shp"_L1, Qt::CaseInsensitive ) );
      QFile prjFile( layerName + ".qpj" );
      if ( prjFile.exists() )
        prjFile.remove();
    }
  }
 
  if ( !mLayer )
  {
    if ( action == CreateOrOverwriteFile || action == CreateOrOverwriteLayer )
      mErrorMessage = QObject::tr( "Creation of layer failed (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
    else
      mErrorMessage = QObject::tr( "Opening of layer failed (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
    mError = ErrCreateLayer;
    return;
  }
 
  OGRFeatureDefnH defn = OGR_L_GetLayerDefn( mLayer );
 
  QgsDebugMsgLevel( u"created layer"_s, 2 );
 
  // create the fields
  QgsDebugMsgLevel( "creating " + QString::number( fields.size() ) + " fields", 2 );
 
  mFields = fields;
  mAttrIdxToProviderIdx.clear();
  mAttrIdxToOgrLayerIdx.clear();
  QSet<int> existingIdxs;
 
  mFieldValueConverter = fieldValueConverter;
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )
  if ( const char *pszCreateFieldDefnFlags = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATION_FIELD_DEFN_FLAGS, nullptr ) )
  {
    char **papszTokens = CSLTokenizeString2( pszCreateFieldDefnFlags, " ", 0 );
    if ( CSLFindString( papszTokens, "AlternativeName" ) >= 0 )
    {
      mCapabilities |= Qgis::VectorFileWriterCapability::FieldAliases;
    }
    if ( CSLFindString( papszTokens, "Comment" ) >= 0 )
    {
      mCapabilities |= Qgis::VectorFileWriterCapability::FieldComments;
    }
    CSLDestroy( papszTokens );
  }
#endif
 
  switch ( action )
  {
    case CreateOrOverwriteFile:
    case CreateOrOverwriteLayer:
    case AppendToLayerAddFields:
    {
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 5, 0 )
      QSet<QString> existingDestDomainNames;
      if ( sourceDatabaseProviderConnection )
      {
        char **domainNames = GDALDatasetGetFieldDomainNames( mDS.get(), nullptr );
        for ( const char *const *iterDomainNames = domainNames; iterDomainNames && *iterDomainNames; ++iterDomainNames )
        {
          existingDestDomainNames.insert( QString::fromUtf8( *iterDomainNames ) );
        }
        CSLDestroy( domainNames );
      }
#endif
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 6, 0 )
      QSet< QString > usedAlternativeNames;
#endif
 
      const QString ogrFidColumnName { OGR_L_GetFIDColumn( mLayer ) };
      const int fidNameIndex = OGR_FD_GetFieldIndex( defn, ogrFidColumnName.toUtf8() );
      // if native fid column in created layer matches an attribute from the user-specified fields, we'll be
      // promoting that to a real attribute.
      const bool promoteFidColumnToAttribute = !ogrFidColumnName.isEmpty() && fidNameIndex < 0 && fields.lookupField( ogrFidColumnName ) >= 0;
      int offsetRoomForFid = promoteFidColumnToAttribute ? 1 : 0;
 
      for ( int fldIdx = 0; fldIdx < fields.count(); ++fldIdx )
      {
        QgsField attrField = fields.at( fldIdx );
 
        if ( fieldValueConverter )
        {
          attrField = fieldValueConverter->fieldDefinition( fields.at( fldIdx ) );
        }
 
        if ( action == AppendToLayerAddFields )
        {
          int ogrIdx = OGR_FD_GetFieldIndex( defn, mCodec->fromUnicode( attrField.name() ) );
          if ( ogrIdx >= 0 )
          {
            mAttrIdxToProviderIdx.insert( fldIdx, ogrIdx );
            mAttrIdxToOgrLayerIdx.insert( fldIdx, ogrIdx );
            continue;
          }
        }
 
        QString name;
        switch ( fieldNameSource )
        {
          case Original:
            name = attrField.name();
            break;
 
          case PreferAlias:
            name = !attrField.alias().isEmpty() ? attrField.alias() : attrField.name();
            break;
        }
 
        OGRFieldType ogrType = OFTString; //default to string
        OGRFieldSubType ogrSubType = OFSTNone;
        int ogrWidth = attrField.length();
        int ogrPrecision = attrField.precision();
        if ( ogrPrecision > 0 )
          ++ogrWidth;
 
        switch ( attrField.type() )
        {
          case QMetaType::Type::LongLong:
          {
            const char *pszDataTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATATYPES, nullptr );
            if ( pszDataTypes && strstr( pszDataTypes, "Integer64" ) )
              ogrType = OFTInteger64;
            else
              ogrType = OFTReal;
            ogrWidth = ogrWidth > 0 && ogrWidth <= 20 ? ogrWidth : 20;
            ogrPrecision = 0;
            break;
          }
          case QMetaType::Type::QString:
            ogrType = OFTString;
            if ( ( ogrWidth <= 0 || ogrWidth > 255 ) && mOgrDriverName == "ESRI Shapefile"_L1 )
              ogrWidth = 255;
            break;
 
          case QMetaType::Type::Int:
            ogrType = OFTInteger;
            ogrWidth = ogrWidth > 0 && ogrWidth <= 10 ? ogrWidth : 10;
            ogrPrecision = 0;
            break;
 
          case QMetaType::Type::Bool:
            ogrType = OFTInteger;
            ogrSubType = OFSTBoolean;
            ogrWidth = 1;
            ogrPrecision = 0;
            break;
 
          case QMetaType::Type::Double:
#if GDAL_VERSION_NUM < GDAL_COMPUTE_VERSION( 3, 3, 1 )
            if ( mOgrDriverName == "GPKG"_L1 && attrField.precision() == 0 && attrField.name().compare( fidFieldName, Qt::CaseInsensitive ) == 0 )
            {
              // Convert field to match required FID type
              ogrType = OFTInteger64;
              break;
            }
#endif
            ogrType = OFTReal;
            break;
 
          case QMetaType::Type::QDate:
            ogrType = OFTDate;
            break;
 
          case QMetaType::Type::QTime:
            if ( mOgrDriverName == "ESRI Shapefile"_L1 )
            {
              ogrType = OFTString;
              ogrWidth = 12; // %02d:%02d:%06.3f
            }
            else
            {
              ogrType = OFTTime;
            }
            break;
 
          case QMetaType::Type::QDateTime:
            if ( mOgrDriverName == "ESRI Shapefile"_L1 )
            {
              ogrType = OFTString;
              ogrWidth = 24; // "%04d/%02d/%02d %02d:%02d:%06.3f"
            }
            else
            {
              ogrType = OFTDateTime;
            }
            break;
 
          case QMetaType::Type::QByteArray:
            ogrType = OFTBinary;
            break;
 
          case QMetaType::Type::QStringList:
          {
            // handle GPKG conversion to JSON
            if ( mOgrDriverName == "GPKG"_L1 )
            {
              ogrType = OFTString;
              ogrSubType = OFSTJSON;
              break;
            }
 
            const char *pszDataTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATATYPES, nullptr );
            if ( pszDataTypes && strstr( pszDataTypes, "StringList" ) )
            {
              ogrType = OFTStringList;
              mSupportedListSubTypes.insert( QMetaType::Type::QString );
            }
            else
            {
              ogrType = OFTString;
              ogrWidth = 255;
            }
            break;
          }
 
          case QMetaType::Type::QVariantMap:
          {
            // handle GPKG conversion to JSON
            const char *pszDataSubTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATASUBTYPES, nullptr );
            if ( pszDataSubTypes && strstr( pszDataSubTypes, "JSON" ) )
            {
              ogrType = OFTString;
              ogrSubType = OFSTJSON;
              break;
            }
          }
 
            //intentional fall-through
            [[fallthrough]];
 
          case QMetaType::Type::QVariantList:
            // handle GPKG conversion to JSON
            if ( mOgrDriverName == "GPKG"_L1 )
            {
              ogrType = OFTString;
              ogrSubType = OFSTJSON;
              break;
            }
 
            // fall through to default for other unsupported types
            if ( attrField.subType() == QMetaType::Type::QString )
            {
              const char *pszDataTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATATYPES, nullptr );
              if ( pszDataTypes && strstr( pszDataTypes, "StringList" ) )
              {
                ogrType = OFTStringList;
                mSupportedListSubTypes.insert( QMetaType::Type::QString );
              }
              else
              {
                ogrType = OFTString;
                ogrWidth = 255;
              }
              break;
            }
            else if ( attrField.subType() == QMetaType::Type::Int )
            {
              const char *pszDataTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATATYPES, nullptr );
              if ( pszDataTypes && strstr( pszDataTypes, "IntegerList" ) )
              {
                ogrType = OFTIntegerList;
                mSupportedListSubTypes.insert( QMetaType::Type::Int );
              }
              else
              {
                ogrType = OFTString;
                ogrWidth = 255;
              }
              break;
            }
            else if ( attrField.subType() == QMetaType::Type::Double )
            {
              const char *pszDataTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATATYPES, nullptr );
              if ( pszDataTypes && strstr( pszDataTypes, "RealList" ) )
              {
                ogrType = OFTRealList;
                mSupportedListSubTypes.insert( QMetaType::Type::Double );
              }
              else
              {
                ogrType = OFTString;
                ogrWidth = 255;
              }
              break;
            }
            else if ( attrField.subType() == QMetaType::Type::LongLong )
            {
              const char *pszDataTypes = GDALGetMetadataItem( poDriver, GDAL_DMD_CREATIONFIELDDATATYPES, nullptr );
              if ( pszDataTypes && strstr( pszDataTypes, "Integer64List" ) )
              {
                ogrType = OFTInteger64List;
                mSupportedListSubTypes.insert( QMetaType::Type::LongLong );
              }
              else
              {
                ogrType = OFTString;
                ogrWidth = 255;
              }
              break;
            }
            //intentional fall-through
            [[fallthrough]];
 
          default:
            //assert(0 && "invalid variant type!");
            mErrorMessage = QObject::tr( "Unsupported type for field %1" ).arg( attrField.name() );
            mError = ErrAttributeTypeUnsupported;
            return;
        }
 
        if ( mOgrDriverName == "SQLite"_L1 && name.compare( "ogc_fid"_L1, Qt::CaseInsensitive ) == 0 )
        {
          int i;
          for ( i = 0; i < 10; i++ )
          {
            name = u"ogc_fid%1"_s.arg( i );
 
            int j;
            for ( j = 0; j < fields.size() && name.compare( fields.at( j ).name(), Qt::CaseInsensitive ) != 0; j++ )
              ;
 
            if ( j == fields.size() )
              break;
          }
 
          if ( i == 10 )
          {
            mErrorMessage = QObject::tr( "No available replacement for internal fieldname ogc_fid found" ).arg( attrField.name() );
            mError = ErrAttributeCreationFailed;
            return;
          }
 
          QgsMessageLog::logMessage( QObject::tr( "Reserved attribute name ogc_fid replaced with %1" ).arg( name ), QObject::tr( "OGR" ) );
        }
 
        // create field definition
        gdal::ogr_field_def_unique_ptr fld( OGR_Fld_Create( mCodec->fromUnicode( name ), ogrType ) );
        if ( ogrWidth > 0 )
        {
          OGR_Fld_SetWidth( fld.get(), ogrWidth );
        }
 
        if ( ogrPrecision >= 0 )
        {
          OGR_Fld_SetPrecision( fld.get(), ogrPrecision );
        }
 
        if ( ogrSubType != OFSTNone )
          OGR_Fld_SetSubType( fld.get(), ogrSubType );
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 6, 0 )
        if ( !attrField.alias().isEmpty() )
        {
          QString alternativeName = attrField.alias();
          int counter = 1;
          while ( usedAlternativeNames.contains( alternativeName ) )
          {
            // field alternative names MUST be unique (at least for Geopackage, but let's apply the constraint universally)
            alternativeName = attrField.alias() + u" (%1)"_s.arg( ++counter );
          }
          OGR_Fld_SetAlternativeName( fld.get(), mCodec->fromUnicode( alternativeName ).constData() );
          usedAlternativeNames.insert( alternativeName );
        }
#endif
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )
        OGR_Fld_SetComment( fld.get(), mCodec->fromUnicode( attrField.comment() ).constData() );
#endif
 
        if ( mIncludeConstraints )
        {
          if ( attrField.constraints().constraints() & QgsFieldConstraints::ConstraintNotNull )
          {
            OGR_Fld_SetNullable( fld.get(), false );
          }
          if ( attrField.constraints().constraints() & QgsFieldConstraints::ConstraintUnique )
          {
            OGR_Fld_SetUnique( fld.get(), true );
          }
        }
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 5, 0 )
        if ( mSetFieldDomains && sourceDatabaseProviderConnection )
        {
          const QString domainName = attrField.constraints().domainName();
          if ( !domainName.isEmpty() )
          {
            bool canSetFieldDomainName = false;
            if ( existingDestDomainNames.contains( domainName ) )
            {
              // If the target dataset already knows this field domain,
              // we can directly assign its name to the new field.
              canSetFieldDomainName = true;
            }
            else if ( GDALDatasetTestCapability( mDS.get(), ODsCAddFieldDomain ) )
            {
              // Otherwise, if the output dataset can create field domains,
              // - convert the QGIS field domain to a GDAL one
              // - register it to the GDAL dataset
              // - if successful, note that we know that field domain (if it
              //   is shared by other fields)
              // - assign its name to the new field.
              try
              {
                std::unique_ptr<QgsFieldDomain> domain( sourceDatabaseProviderConnection->fieldDomain( domainName ) );
                if ( domain )
                {
                  OGRFieldDomainH hFieldDomain = QgsOgrUtils::convertFieldDomain( domain.get() );
                  if ( hFieldDomain )
                  {
                    char *pszFailureReason = nullptr;
                    if ( GDALDatasetAddFieldDomain( mDS.get(), hFieldDomain, &pszFailureReason ) )
                    {
                      existingDestDomainNames.insert( domainName );
                      canSetFieldDomainName = true;
                    }
                    else
                    {
                      QgsDebugError( u"cannot create field domain: %1"_s.arg( pszFailureReason ) );
                    }
                    CPLFree( pszFailureReason );
                    OGR_FldDomain_Destroy( hFieldDomain );
                  }
                }
              }
              catch ( QgsProviderConnectionException & )
              {
                QgsDebugError( u"Cannot retrieve field domain: %1"_s.arg( domainName ) );
              }
            }
            if ( canSetFieldDomainName )
            {
              OGR_Fld_SetDomainName( fld.get(), domainName.toUtf8().toStdString().c_str() );
            }
          }
        }
#endif
 
        // create the field
        QgsDebugMsgLevel( "creating field " + attrField.name() + " type " + QString( QVariant::typeToName( attrField.type() ) ) + " width " + QString::number( ogrWidth ) + " precision " + QString::number( ogrPrecision ), 2 );
        if ( OGR_L_CreateField( mLayer, fld.get(), true ) != OGRERR_NONE )
        {
          QgsDebugError( "error creating field " + attrField.name() );
          mErrorMessage = QObject::tr( "Creation of field %1 (%2) failed (OGR error: %3)" ).arg( attrField.name(), QVariant::typeToName( attrField.type() ), QString::fromUtf8( CPLGetLastErrorMsg() ) );
          mError = ErrAttributeCreationFailed;
          return;
        }
 
        int ogrIdx = OGR_FD_GetFieldIndex( defn, mCodec->fromUnicode( name ) );
        QgsDebugMsgLevel( u"returned field index for %1: %2"_s.arg( name ).arg( ogrIdx ), 2 );
        if ( ogrIdx < 0 || existingIdxs.contains( ogrIdx ) )
        {
          // GDAL 1.7 not just truncates, but launders more aggressivly.
          ogrIdx = OGR_FD_GetFieldCount( defn ) - 1;
 
          if ( ogrIdx < 0 )
          {
            QgsDebugError( "error creating field " + attrField.name() );
            mErrorMessage = QObject::tr( "Created field %1 not found (OGR error: %2)" ).arg( attrField.name(), QString::fromUtf8( CPLGetLastErrorMsg() ) );
            mError = ErrAttributeCreationFailed;
            return;
          }
        }
 
        existingIdxs.insert( ogrIdx );
        mAttrIdxToOgrLayerIdx.insert( fldIdx, ogrIdx );
 
        if ( promoteFidColumnToAttribute )
        {
          if ( ogrFidColumnName.compare( attrField.name(), Qt::CaseInsensitive ) == 0 )
          {
            ogrIdx = 0;
            offsetRoomForFid = 0;
          }
          else
          {
            // shuffle to make space for fid column
            ogrIdx += offsetRoomForFid;
          }
        }
 
        mAttrIdxToProviderIdx.insert( fldIdx, ogrIdx );
      }
    }
    break;
 
    case AppendToLayerNoNewFields:
    {
      for ( int fldIdx = 0; fldIdx < fields.count(); ++fldIdx )
      {
        QgsField attrField = fields.at( fldIdx );
        QString name( attrField.name() );
        int ogrIdx = OGR_FD_GetFieldIndex( defn, mCodec->fromUnicode( name ) );
        if ( ogrIdx >= 0 )
        {
          mAttrIdxToProviderIdx.insert( fldIdx, ogrIdx );
          mAttrIdxToOgrLayerIdx.insert( fldIdx, ogrIdx );
        }
      }
    }
    break;
  }
 
  // Geopackages require a unique feature id. If the input feature stream cannot guarantee
  // the uniqueness of the FID column, we drop it and let OGR generate new ones
  if ( sinkFlags.testFlag( QgsFeatureSink::RegeneratePrimaryKey ) && driverName == "GPKG"_L1 )
  {
    int fidIdx = fields.lookupField( u"FID"_s );
 
    if ( fidIdx >= 0 )
    {
      mAttrIdxToProviderIdx.remove( fidIdx );
      mAttrIdxToOgrLayerIdx.remove( fidIdx );
    }
  }
 
  QgsDebugMsgLevel( u"Done creating fields"_s, 2 );
 
  mWkbType = geometryType;
 
  if ( newFilename )
    *newFilename = vectorFileName;
 
  // enabling transaction on databases that support it
  mUsingTransaction = true;
  if ( OGRERR_NONE != OGR_L_StartTransaction( mLayer ) )
  {
    mUsingTransaction = false;
  }
}
 
OGRGeometryH QgsVectorFileWriter::createEmptyGeometry( Qgis::WkbType wkbType )
{
  return OGR_G_CreateGeometry( ogrTypeFromWkbType( wkbType ) );
}

class QgsVectorFileWriterMetadataContainer
{
  public:
    QgsVectorFileWriterMetadataContainer()
    {
      QMap<QString, QgsVectorFileWriter::Option *> datasetOptions;
      QMap<QString, QgsVectorFileWriter::Option *> layerOptions;
 
      // Arrow
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"COMPRESSION"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Compression method." ),
          QStringList() << u"UNCOMPRESSED"_s << u"ZSTD"_s << u"LZ4"_s,
          u"LZ4"_s, // Default value
          false     // Allow None
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_ENCODING"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Geometry encoding." ),
          QStringList() << u"GEOARROW"_s << u"WKB"_s << u"WKT"_s,
          u"GEOARROW"_s, // Default value
          false          // Allow None
        )
      );
 
      layerOptions.insert(
        u"BATCH_SIZE"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr( "Maximum number of rows per batch." ),
          65536 // Default value
        )
      );
 
      layerOptions.insert(
        u"FID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name for the feature identifier column" ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name for the geometry column" ),
          u"geometry"_s // Default value
        )
      );
 
      driverMetadata.insert( u"Arrow"_s, QgsVectorFileWriter::MetaData( u"(Geo)Arrow"_s, QObject::tr( "(Geo)Arrow" ), u"*.arrow *.feather *.arrows *.ipc"_s, u"arrow"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // Arc/Info ASCII Coverage
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata.insert( u"AVCE00"_s, QgsVectorFileWriter::MetaData( u"Arc/Info ASCII Coverage"_s, QObject::tr( "Arc/Info ASCII Coverage" ), u"*.e00"_s, u"e00"_s, datasetOptions, layerOptions ) );
 
      // Comma Separated Value
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"LINEFORMAT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default when creating new .csv files they "
            "are created with the line termination conventions "
            "of the local platform (CR/LF on Win32 or LF on all other systems). "
            "This may be overridden through the use of the LINEFORMAT option."
          ),
          QStringList() << u"CRLF"_s << u"LF"_s,
          QString(), // Default value
          true       // Allow None
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default, the geometry of a feature written to a .csv file is discarded. "
            "It is possible to export the geometry in its WKT representation by "
            "specifying GEOMETRY=AS_WKT. It is also possible to export point geometries "
            "into their X,Y,Z components by specifying GEOMETRY=AS_XYZ, GEOMETRY=AS_XY "
            "or GEOMETRY=AS_YX."
          ),
          QStringList() << u"AS_WKT"_s << u"AS_XYZ"_s << u"AS_XY"_s << u"AS_YX"_s,
          QString(), // Default value
          true       // Allow None
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name of geometry column. Only used if GEOMETRY=AS_WKT. Defaults to 'WKT'." ),
          u"WKT"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"CREATE_CSVT"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Create the associated .csvt file to describe the type of each "
            "column of the layer and its optional width and precision. "
            "This option also creates a .prj file which stores coordinate system information."
          ),
          false // Default value
        )
      );
 
      layerOptions.insert(
        u"SEPARATOR"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Field separator character." ),
          QStringList()
            << u"COMMA"_s
            << u"SEMICOLON"_s
            << u"TAB"_s
            << u"SPACE"_s
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 12, 0 )
            << u"PIPE"_s
#endif
          ,
          u"COMMA"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"STRING_QUOTING"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Double-quote strings. IF_AMBIGUOUS means that string values that look like numbers will be quoted." ),
          QStringList() << u"IF_NEEDED"_s << u"IF_AMBIGUOUS"_s << u"ALWAYS"_s,
          u"IF_AMBIGUOUS"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"WRITE_BOM"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Write a UTF-8 Byte Order Mark (BOM) at the start of the file." ),
          false // Default value
        )
      );
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 12, 0 )
      layerOptions.insert(
        u"HEADER"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Whether to write a header line with the field names." ),
          true // Default value
        )
      );
#endif
 
      driverMetadata.insert( u"CSV"_s, QgsVectorFileWriter::MetaData( u"Comma Separated Value [CSV]"_s, QObject::tr( "Comma Separated Value [CSV]" ), u"*.csv"_s, u"csv"_s, datasetOptions, layerOptions ) );
 
      // FlatGeobuf
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata.insert( u"FlatGeobuf"_s, QgsVectorFileWriter::MetaData( u"FlatGeobuf"_s, QObject::tr( "FlatGeobuf" ), u"*.fgb"_s, u"fgb"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // ESRI Shapefile
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"SHPT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "Override the type of shapefile created. "
            "Can be one of NULL for a simple .dbf file with no .shp file, POINT, "
            "ARC, POLYGON or MULTIPOINT for 2D, or POINTZ, ARCZ, POLYGONZ or "
            "MULTIPOINTZ for 3D;"
          )
            + QObject::tr(
              " POINTM, ARCM, POLYGONM or MULTIPOINTM for measured geometries"
              " and POINTZM, ARCZM, POLYGONZM or MULTIPOINTZM for 3D measured"
              " geometries."
            )
            + QObject::tr( " MULTIPATCH files are supported since GDAL 2.2." )
            + "",
          QStringList()
            << u"NULL"_s
            << u"POINT"_s
            << u"ARC"_s
            << u"POLYGON"_s
            << u"MULTIPOINT"_s
            << u"POINTZ"_s
            << u"ARCZ"_s
            << u"POLYGONZ"_s
            << u"MULTIPOINTZ"_s
            << u"POINTM"_s
            << u"ARCM"_s
            << u"POLYGONM"_s
            << u"MULTIPOINTM"_s
            << u"POINTZM"_s
            << u"ARCZM"_s
            << u"POLYGONZM"_s
            << u"MULTIPOINTZM"_s
            << u"MULTIPATCH"_s
            << QString(),
          QString(), // Default value
          true       // Allow None
        )
      );
 
      // there does not seem to be a reason to provide this option to the user again
      // as we set encoding for shapefiles based on "fileEncoding" parameter passed to the writer
#if 0
      layerOptions.insert( "ENCODING", new QgsVectorFileWriter::SetOption(
                             QObject::tr( "Set the encoding value in the DBF file. "
                                          "The default value is LDID/87. It is not clear "
                                          "what other values may be appropriate." ),
                             QStringList()
                             << "LDID/87",
                             "LDID/87" // Default value
                           ) );
#endif
 
      layerOptions.insert(
        u"RESIZE"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Set to YES to resize fields to their optimal size." ),
          false // Default value
        )
      );
 
      driverMetadata.insert( u"ESRI"_s, QgsVectorFileWriter::MetaData( u"ESRI Shapefile"_s, QObject::tr( "ESRI Shapefile" ), u"*.shp"_s, u"shp"_s, datasetOptions, layerOptions ) );
 
      // DBF File
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata.insert( u"DBF File"_s, QgsVectorFileWriter::MetaData( u"DBF File"_s, QObject::tr( "DBF File" ), u"*.dbf"_s, u"dbf"_s, datasetOptions, layerOptions ) );
 
      // GeoJSON
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"WRITE_BBOX"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Set to YES to write a bbox property with the bounding box "
            "of the geometries at the feature and feature collection level."
          ),
          false // Default value
        )
      );
 
      layerOptions.insert(
        u"COORDINATE_PRECISION"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr(
            "Maximum number of figures after decimal separator to write in coordinates. "
            "Defaults to 15. Truncation will occur to remove trailing zeros."
          ),
          15 // Default value
        )
      );
 
      layerOptions.insert(
        u"RFC7946"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Whether to use RFC 7946 standard. "
            "If disabled GeoJSON 2008 initial version will be used. "
            "Default is NO (thus GeoJSON 2008). See also Documentation (via Help button)"
          ),
          false // Default value
        )
      );
 
      driverMetadata.insert( u"GeoJSON"_s, QgsVectorFileWriter::MetaData( u"GeoJSON"_s, QObject::tr( "GeoJSON" ), u"*.geojson"_s, u"geojson"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // GeoJSONSeq
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"COORDINATE_PRECISION"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr(
            "Maximum number of figures after decimal separator to write in coordinates. "
            "Defaults to 15. Truncation will occur to remove trailing zeros."
          ),
          15 // Default value
        )
      );
 
      layerOptions.insert(
        u"RS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Whether to start records with the RS=0x1E character (RFC 8142 standard). "
            "Defaults to NO: Newline Delimited JSON (geojsonl). \n"
            "If set to YES:  RFC 8142 standard: GeoJSON Text Sequences  (geojsons)."
          ),
          false // Default value = NO
        )
      );
 
      driverMetadata
        .insert( u"GeoJSONSeq"_s, QgsVectorFileWriter::MetaData( u"GeoJSON - Newline Delimited"_s, QObject::tr( "GeoJSON - Newline Delimited" ), u"*.geojsonl *.geojsons *.json"_s, u"geojsonl geojsons json"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // GeoRSS
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"FORMAT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "whether the document must be in RSS 2.0 or Atom 1.0 format. "
            "Default value : RSS"
          ),
          QStringList() << u"RSS"_s << u"ATOM"_s,
          u"RSS"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"GEOM_DIALECT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "The encoding of location information. Default value : SIMPLE. "
            "W3C_GEO only supports point geometries. "
            "SIMPLE or W3C_GEO only support geometries in geographic WGS84 coordinates."
          ),
          QStringList() << u"SIMPLE"_s << u"GML"_s << u"W3C_GEO"_s,
          u"SIMPLE"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"USE_EXTENSIONS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "If defined to YES, extension fields will be written. "
            "If the field name not found in the base schema matches "
            "the foo_bar pattern, foo will be considered as the namespace "
            "of the element, and a <foo:bar> element will be written. "
            "Otherwise, elements will be written in the <ogr:> namespace."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"WRITE_HEADER_AND_FOOTER"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "If defined to NO, only <entry> or <item> elements will be written. "
            "The user will have to provide the appropriate header and footer of the document."
          ),
          true // Default value
        )
      );
 
      datasetOptions.insert(
        u"HEADER"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "XML content that will be put between the <channel> element and the "
            "first <item> element for a RSS document, or between the xml tag and "
            "the first <entry> element for an Atom document."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"TITLE"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Value put inside the <title> element in the header. "
            "If not provided, a dummy value will be used as that element is compulsory."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"DESCRIPTION"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Value put inside the <description> element in the header. "
            "If not provided, a dummy value will be used as that element is compulsory."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"LINK"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Value put inside the <link> element in the header. "
            "If not provided, a dummy value will be used as that element is compulsory."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"UPDATED"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Value put inside the <updated> element in the header. "
            "Should be formatted as a XML datetime. "
            "If not provided, a dummy value will be used as that element is compulsory."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"AUTHOR_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Value put inside the <author><name> element in the header. "
            "If not provided, a dummy value will be used as that element is compulsory."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"ID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Value put inside the <id> element in the header. "
            "If not provided, a dummy value will be used as that element is compulsory."
          ),
          QString() // Default value
        )
      );
 
      driverMetadata.insert( u"GeoRSS"_s, QgsVectorFileWriter::MetaData( u"GeoRSS"_s, QObject::tr( "GeoRSS" ), u"*.xml"_s, u"xml"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // Geography Markup Language [GML]
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"XSISCHEMAURI"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "If provided, this URI will be inserted as the schema location. "
            "Note that the schema file isn't actually accessed by OGR, so it "
            "is up to the user to ensure it will match the schema of the OGR "
            "produced GML data file."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"XSISCHEMA"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "This writes a GML application schema file to a corresponding "
            ".xsd file (with the same basename). If INTERNAL is used the "
            "schema is written within the GML file, but this is experimental "
            "and almost certainly not valid XML. "
            "OFF disables schema generation (and is implicit if XSISCHEMAURI is used)."
          ),
          QStringList() << u"EXTERNAL"_s << u"INTERNAL"_s << u"OFF"_s,
          u"EXTERNAL"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"PREFIX"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "This is the prefix for the application target namespace." ),
          u"ogr"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"STRIP_PREFIX"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Can be set to TRUE to avoid writing the prefix of the "
            "application target namespace in the GML file."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"TARGET_NAMESPACE"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Defaults to 'http://ogr.maptools.org/'. "
            "This is the application target namespace."
          ),
          u"http://ogr.maptools.org/"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"FORMAT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "GML version to use." ),
          QStringList() << u"GML2"_s << u"GML3"_s << u"GML3Deegree"_s << u"GML3.2"_s,
          u"GML3.2"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"GML3_LONGSRS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Only valid when FORMAT=GML3/GML3Degree/GML3.2. Default to YES. " //needs review here
            "If YES, SRS with EPSG authority will be written with the "
            "'urn:ogc:def:crs:EPSG::' prefix. In the case the SRS is a "
            "geographic SRS without explicit AXIS order, but that the same "
            "SRS authority code imported with ImportFromEPSGA() should be "
            "treated as lat/long, then the function will take care of coordinate "
            "order swapping. If set to NO, SRS with EPSG authority will be "
            "written with the 'EPSG:' prefix, even if they are in lat/long order."
          ),
          true // Default value
        )
      );
 
      datasetOptions.insert(
        u"WRITE_FEATURE_BOUNDED_BY"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "only valid when FORMAT=GML3/GML3Degree/GML3.2) Default to YES. "
            "If set to NO, the <gml:boundedBy> element will not be written for "
            "each feature."
          ),
          true // Default value
        )
      );
 
      datasetOptions.insert(
        u"SPACE_INDENTATION"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Default to YES. If YES, the output will be indented with spaces "
            "for more readability, but at the expense of file size."
          ),
          true // Default value
        )
      );
 
 
      driverMetadata
        .insert( u"GML"_s, QgsVectorFileWriter::MetaData( u"Geography Markup Language [GML]"_s, QObject::tr( "Geography Markup Language [GML]" ), u"*.gml"_s, u"gml"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // GeoPackage
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"IDENTIFIER"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Human-readable identifier (e.g. short name) for the layer content" ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"DESCRIPTION"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Human-readable description for the layer content" ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"FID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name for the feature identifier column" ),
          u"fid"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name for the geometry column" ),
          u"geom"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"SPATIAL_INDEX"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "If a spatial index must be created." ),
          true // Default value
        )
      );
 
      driverMetadata.insert(
        u"GPKG"_s,
        QgsVectorFileWriter::MetaData(
          u"GeoPackage"_s,
          QObject::tr( "GeoPackage" ),
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )
          u"*.gpkg *.gpkg.zip"_s,
#else
          u"*.gpkg"_s,
#endif
          u"gpkg"_s,
          datasetOptions,
          layerOptions,
          u"UTF-8"_s
        )
      );
 
      // Generic Mapping Tools [GMT]
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata.insert( u"GMT"_s, QgsVectorFileWriter::MetaData( u"Generic Mapping Tools [GMT]"_s, QObject::tr( "Generic Mapping Tools [GMT]" ), u"*.gmt"_s, u"gmt"_s, datasetOptions, layerOptions ) );
 
      // GPS eXchange Format [GPX]
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"FORCE_GPX_TRACK"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "By default when writing a layer whose features are of "
            "type wkbLineString, the GPX driver chooses to write "
            "them as routes. If FORCE_GPX_TRACK=YES is specified, "
            "they will be written as tracks."
          ),
          false // Default value
        )
      );
 
      layerOptions.insert(
        u"FORCE_GPX_ROUTE"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "By default when writing a layer whose features are of "
            "type wkbMultiLineString, the GPX driver chooses to write "
            "them as tracks. If FORCE_GPX_ROUTE=YES is specified, "
            "they will be written as routes, provided that the multilines "
            "are composed of only one single line."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"GPX_USE_EXTENSIONS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "If GPX_USE_EXTENSIONS=YES is specified, "
            "extra fields will be written inside the <extensions> tag."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"GPX_EXTENSIONS_NS"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Only used if GPX_USE_EXTENSIONS=YES and GPX_EXTENSIONS_NS_URL "
            "is set. The namespace value used for extension tags. By default, 'ogr'."
          ),
          u"ogr"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"GPX_EXTENSIONS_NS_URL"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Only used if GPX_USE_EXTENSIONS=YES and GPX_EXTENSIONS_NS "
            "is set. The namespace URI. By default, 'http://osgeo.org/gdal'."
          ),
          u"http://osgeo.org/gdal"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"LINEFORMAT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default files are created with the line termination "
            "conventions of the local platform (CR/LF on win32 or LF "
            "on all other systems). This may be overridden through use "
            "of the LINEFORMAT layer creation option which may have a value "
            "of CRLF (DOS format) or LF (Unix format)."
          ),
          QStringList() << u"CRLF"_s << u"LF"_s,
          QString(), // Default value
          true       // Allow None
        )
      );
 
      driverMetadata.insert( u"GPX"_s, QgsVectorFileWriter::MetaData( u"GPS eXchange Format [GPX]"_s, QObject::tr( "GPS eXchange Format [GPX]" ), u"*.gpx"_s, u"gpx"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // INTERLIS 1
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata.insert( u"Interlis 1"_s, QgsVectorFileWriter::MetaData( u"INTERLIS 1"_s, QObject::tr( "INTERLIS 1" ), u"*.itf *.xml *.ili"_s, u"ili"_s, datasetOptions, layerOptions ) );
 
      // INTERLIS 2
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata.insert( u"Interlis 2"_s, QgsVectorFileWriter::MetaData( u"INTERLIS 2"_s, QObject::tr( "INTERLIS 2" ), u"*.xtf *.xml *.ili"_s, u"ili"_s, datasetOptions, layerOptions ) );
 
      // Keyhole Markup Language [KML]
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"NameField"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Allows you to specify the field to use for the KML <name> element." ),
          u"Name"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"DescriptionField"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Allows you to specify the field to use for the KML <description> element." ),
          u"Description"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"AltitudeMode"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "Allows you to specify the AltitudeMode to use for KML geometries. "
            "This will only affect 3D geometries and must be one of the valid KML options."
          ),
          QStringList() << u"clampToGround"_s << u"relativeToGround"_s << u"absolute"_s,
          u"relativeToGround"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"DOCUMENT_ID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "The DOCUMENT_ID datasource creation option can be used to specified "
            "the id of the root <Document> node. The default value is root_doc."
          ),
          u"root_doc"_s // Default value
        )
      );
 
      driverMetadata
        .insert( u"KML"_s, QgsVectorFileWriter::MetaData( u"Keyhole Markup Language [KML]"_s, QObject::tr( "Keyhole Markup Language [KML]" ), u"*.kml"_s, u"kml"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // Mapinfo
      datasetOptions.clear();
      layerOptions.clear();
 
      auto insertMapInfoOptions = []( QMap<QString, QgsVectorFileWriter::Option *> &datasetOptions, QMap<QString, QgsVectorFileWriter::Option *> &layerOptions ) {
        datasetOptions.insert(
          u"SPATIAL_INDEX_MODE"_s,
          new QgsVectorFileWriter::SetOption(
            QObject::tr(
              "Use this to turn on 'quick spatial index mode'. "
              "In this mode writing files can be about 5 times faster, "
              "but spatial queries can be up to 30 times slower."
            ),
            QStringList() << u"QUICK"_s << u"OPTIMIZED"_s,
            u"QUICK"_s, // Default value
            true        // Allow None
          )
        );
 
        datasetOptions.insert(
          u"BLOCK_SIZE"_s,
          new QgsVectorFileWriter::IntOption(
            QObject::tr(
              "(multiples of 512): Block size for .map files. Defaults "
              "to 512. MapInfo 15.2 and above creates .tab files with a "
              "blocksize of 16384 bytes. Any MapInfo version should be "
              "able to handle block sizes from 512 to 32256."
            ),
            512
          )
        );
        layerOptions.insert(
          u"BOUNDS"_s,
          new QgsVectorFileWriter::StringOption(
            QObject::tr(
              "xmin,ymin,xmax,ymax: Define custom layer bounds to increase the "
              "accuracy of the coordinates. Note: the geometry of written "
              "features must be within the defined box."
            ),
            QString() // Default value
          )
        );
      };
      insertMapInfoOptions( datasetOptions, layerOptions );
 
      driverMetadata.insert( u"MapInfo File"_s, QgsVectorFileWriter::MetaData( u"Mapinfo"_s, QObject::tr( "Mapinfo TAB" ), u"*.tab"_s, u"tab"_s, datasetOptions, layerOptions ) );
      datasetOptions.clear();
      layerOptions.clear();
      insertMapInfoOptions( datasetOptions, layerOptions );
 
      // QGIS internal alias for MIF files
      driverMetadata.insert( u"MapInfo MIF"_s, QgsVectorFileWriter::MetaData( u"Mapinfo"_s, QObject::tr( "Mapinfo MIF" ), u"*.mif"_s, u"mif"_s, datasetOptions, layerOptions ) );
 
      // Microstation DGN
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"3D"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Determine whether 2D (seed_2d.dgn) or 3D (seed_3d.dgn) "
            "seed file should be used. This option is ignored if the SEED option is provided."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"SEED"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Override the seed file to use." ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"COPY_WHOLE_SEED_FILE"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Indicate whether the whole seed file should be copied. "
            "If not, only the first three elements will be copied."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"COPY_SEED_FILE_COLOR_TABLE"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Indicates whether the color table should be copied from the seed file." ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"MASTER_UNIT_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Override the master unit name from the seed file with "
            "the provided one or two character unit name."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"SUB_UNIT_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Override the sub unit name from the seed file with the provided "
            "one or two character unit name."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"SUB_UNITS_PER_MASTER_UNIT"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr(
            "Override the number of subunits per master unit. "
            "By default the seed file value is used."
          ),
          0 // Default value
        )
      );
 
      datasetOptions.insert(
        u"UOR_PER_SUB_UNIT"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr(
            "Override the number of UORs (Units of Resolution) "
            "per sub unit. By default the seed file value is used."
          ),
          0 // Default value
        )
      );
 
      datasetOptions.insert(
        u"ORIGIN"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "ORIGIN=x,y,z: Override the origin of the design plane. "
            "By default the origin from the seed file is used."
          ),
          QString() // Default value
        )
      );
 
      driverMetadata.insert( u"DGN"_s, QgsVectorFileWriter::MetaData( u"Microstation DGN"_s, QObject::tr( "Microstation DGN" ), u"*.dgn"_s, u"dgn"_s, datasetOptions, layerOptions ) );
 
      // S-57 Base file
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"UPDATES"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Should update files be incorporated into the base data on the fly." ),
          QStringList() << u"APPLY"_s << u"IGNORE"_s,
          u"APPLY"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"SPLIT_MULTIPOINT"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Should multipoint soundings be split into many single point sounding features. "
            "Multipoint geometries are not well handled by many formats, "
            "so it can be convenient to split single sounding features with many points "
            "into many single point features."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"ADD_SOUNDG_DEPTH"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Should a DEPTH attribute be added on SOUNDG features and assign the depth "
            "of the sounding. This should only be enabled when SPLIT_MULTIPOINT is "
            "also enabled."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"RETURN_PRIMITIVES"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Should all the low level geometry primitives be returned as special "
            "IsolatedNode, ConnectedNode, Edge and Face layers."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"PRESERVE_EMPTY_NUMBERS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "If enabled, numeric attributes assigned an empty string as a value will "
            "be preserved as a special numeric value. This option should not generally "
            "be needed, but may be useful when translated S-57 to S-57 losslessly."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"LNAM_REFS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Should LNAM and LNAM_REFS fields be attached to features capturing "
            "the feature to feature relationships in the FFPT group of the S-57 file."
          ),
          true // Default value
        )
      );
 
      datasetOptions.insert(
        u"RETURN_LINKAGES"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Should additional attributes relating features to their underlying "
            "geometric primitives be attached. These are the values of the FSPT group, "
            "and are primarily needed when doing S-57 to S-57 translations."
          ),
          false // Default value
        )
      );
 
      datasetOptions.insert(
        u"RECODE_BY_DSSI"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Should attribute values be recoded to UTF-8 from the character encoding "
            "specified in the S57 DSSI record."
          ),
          false // Default value
        )
      );
 
      // set OGR_S57_OPTIONS = "RETURN_PRIMITIVES=ON,RETURN_LINKAGES=ON,LNAM_REFS=ON"
 
      driverMetadata.insert( u"S57"_s, QgsVectorFileWriter::MetaData( u"S-57 Base file"_s, QObject::tr( "S-57 Base file" ), u"*.000"_s, u"000"_s, datasetOptions, layerOptions ) );
 
      // Spatial Data Transfer Standard [SDTS]
      datasetOptions.clear();
      layerOptions.clear();
 
      driverMetadata
        .insert( u"SDTS"_s, QgsVectorFileWriter::MetaData( u"Spatial Data Transfer Standard [SDTS]"_s, QObject::tr( "Spatial Data Transfer Standard [SDTS]" ), u"*catd.ddf"_s, u"ddf"_s, datasetOptions, layerOptions ) );
 
      // SQLite
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"METADATA"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Can be used to avoid creating the geometry_columns and spatial_ref_sys "
            "tables in a new database. By default these metadata tables are created "
            "when a new database is created."
          ),
          true // Default value
        )
      );
 
      // Will handle the SpatiaLite alias
      datasetOptions.insert( u"SPATIALITE"_s, new QgsVectorFileWriter::HiddenOption( u"NO"_s ) );
 
 
      datasetOptions.insert( u"INIT_WITH_EPSG"_s, new QgsVectorFileWriter::HiddenOption( u"NO"_s ) );
 
      layerOptions.insert(
        u"FORMAT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "Controls the format used for the geometry column. Defaults to WKB. "
            "This is generally more space and processing efficient, but harder "
            "to inspect or use in simple applications than WKT (Well Known Text)."
          ),
          QStringList() << u"WKB"_s << u"WKT"_s,
          u"WKB"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"LAUNDER"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Controls whether layer and field names will be laundered for easier use "
            "in SQLite. Laundered names will be converted to lower case and some special "
            "characters(' - #) will be changed to underscores."
          ),
          true // Default value
        )
      );
 
      layerOptions.insert( u"SPATIAL_INDEX"_s, new QgsVectorFileWriter::HiddenOption( u"NO"_s ) );
 
      layerOptions.insert( u"COMPRESS_GEOM"_s, new QgsVectorFileWriter::HiddenOption( u"NO"_s ) );
 
      layerOptions.insert( u"SRID"_s, new QgsVectorFileWriter::HiddenOption( QString() ) );
 
      layerOptions.insert(
        u"COMPRESS_COLUMNS"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "column_name1[,column_name2, …] A list of (String) columns that "
            "must be compressed with ZLib DEFLATE algorithm. This might be beneficial "
            "for databases that have big string blobs. However, use with care, since "
            "the value of such columns will be seen as compressed binary content with "
            "other SQLite utilities (or previous OGR versions). With OGR, when inserting, "
            "modifying or querying compressed columns, compression/decompression is "
            "done transparently. However, such columns cannot be (easily) queried with "
            "an attribute filter or WHERE clause. Note: in table definition, such columns "
            "have the 'VARCHAR_deflate' declaration type."
          ),
          QString() // Default value
        )
      );
 
      driverMetadata.insert( u"SQLite"_s, QgsVectorFileWriter::MetaData( u"SQLite"_s, QObject::tr( "SQLite" ), u"*.sqlite"_s, u"sqlite"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // SpatiaLite
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"METADATA"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Can be used to avoid creating the geometry_columns and spatial_ref_sys "
            "tables in a new database. By default these metadata tables are created "
            "when a new database is created."
          ),
          true // Default value
        )
      );
 
      datasetOptions.insert( u"SPATIALITE"_s, new QgsVectorFileWriter::HiddenOption( u"YES"_s ) );
 
      datasetOptions.insert(
        u"INIT_WITH_EPSG"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Insert the content of the EPSG CSV files into the spatial_ref_sys table. "
            "Set to NO for regular SQLite databases."
          ),
          true // Default value
        )
      );
 
      layerOptions.insert( u"FORMAT"_s, new QgsVectorFileWriter::HiddenOption( u"SPATIALITE"_s ) );
 
      layerOptions.insert(
        u"LAUNDER"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Controls whether layer and field names will be laundered for easier use "
            "in SQLite. Laundered names will be converted to lower case and some special "
            "characters(' - #) will be changed to underscores."
          ),
          true // Default value
        )
      );
 
      layerOptions.insert(
        u"SPATIAL_INDEX"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "If the database is of the SpatiaLite flavor, and if OGR is linked "
            "against libspatialite, this option can be used to control if a spatial "
            "index must be created."
          ),
          true // Default value
        )
      );
 
      layerOptions.insert(
        u"COMPRESS_GEOM"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "If the format of the geometry BLOB is of the SpatiaLite flavor, "
            "this option can be used to control if the compressed format for "
            "geometries (LINESTRINGs, POLYGONs) must be used."
          ),
          false // Default value
        )
      );
 
      layerOptions.insert(
        u"SRID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Used to force the SRID number of the SRS associated with the layer. "
            "When this option isn't specified and that a SRS is associated with the "
            "layer, a search is made in the spatial_ref_sys to find a match for the "
            "SRS, and, if there is no match, a new entry is inserted for the SRS in "
            "the spatial_ref_sys table. When the SRID option is specified, this "
            "search (and the eventual insertion of a new entry) will not be done: "
            "the specified SRID is used as such."
          ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"COMPRESS_COLUMNS"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "column_name1[,column_name2, …] A list of (String) columns that "
            "must be compressed with ZLib DEFLATE algorithm. This might be beneficial "
            "for databases that have big string blobs. However, use with care, since "
            "the value of such columns will be seen as compressed binary content with "
            "other SQLite utilities (or previous OGR versions). With OGR, when inserting, "
            "modifying or queryings compressed columns, compression/decompression is "
            "done transparently. However, such columns cannot be (easily) queried with "
            "an attribute filter or WHERE clause. Note: in table definition, such columns "
            "have the 'VARCHAR_deflate' declaration type."
          ),
          QString() // Default value
        )
      );
 
      driverMetadata.insert( u"SpatiaLite"_s, QgsVectorFileWriter::MetaData( u"SpatiaLite"_s, QObject::tr( "SpatiaLite" ), u"*.sqlite"_s, u"sqlite"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
      // AutoCAD DXF
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"HEADER"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Override the header file used - in place of header.dxf." ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"TRAILER"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Override the trailer file used - in place of trailer.dxf." ),
          QString() // Default value
        )
      );
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 11, 0 )
      datasetOptions.insert(
        u"INSUNITS"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Drawing units for the model space ($INSUNITS system variable)." ),
          QStringList() << u"AUTO"_s << u"HEADER_VALUE"_s << u"UNITLESS"_s << u"INCHES"_s << u"FEET"_s << u"MILLIMETERS"_s << u"CENTIMETERS"_s << u"METERS"_s << u"US_SURVEY_FEET"_s,
          u"AUTO"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"MEASUREMENT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "Whether the current drawing uses imperial or metric hatch "
            "pattern and linetype ($MEASUREMENT system variable)."
          ),
          QStringList() << u"HEADER_VALUE"_s << u"IMPERIAL"_s << u"METRIC"_s,
          u"HEADER_VALUE"_s // Default value
        )
      );
#endif
 
      driverMetadata.insert( u"DXF"_s, QgsVectorFileWriter::MetaData( u"AutoCAD DXF"_s, QObject::tr( "AutoCAD DXF" ), u"*.dxf"_s, u"dxf"_s, datasetOptions, layerOptions ) );
 
      // Geoconcept
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"EXTENSION"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "Indicates the GeoConcept export file extension. "
            "TXT was used by earlier releases of GeoConcept. GXT is currently used."
          ),
          QStringList() << u"GXT"_s << u"TXT"_s,
          u"GXT"_s // Default value
        )
      );
 
      datasetOptions.insert(
        u"CONFIG"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Path to the GCT: the GCT file describes the GeoConcept types definitions: "
            "In this file, every line must start with //# followed by a keyword. "
            "Lines starting with // are comments."
          ),
          QString() // Default value
        )
      );
 
      datasetOptions.insert(
        u"FEATURETYPE"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Defines the feature to be created. The TYPE corresponds to one of the Name "
            "found in the GCT file for a type section. The SUBTYPE corresponds to one of "
            "the Name found in the GCT file for a sub-type section within the previous "
            "type section."
          ),
          QString() // Default value
        )
      );
 
      driverMetadata.insert( u"Geoconcept"_s, QgsVectorFileWriter::MetaData( u"Geoconcept"_s, QObject::tr( "Geoconcept" ), u"*.gxt *.txt"_s, u"gxt"_s, datasetOptions, layerOptions ) );
 
      // ESRI OpenFileGDB
      datasetOptions.clear();
      layerOptions.clear();
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 9, 0 )
      layerOptions.insert(
        u"TARGET_ARCGIS_VERSION"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "Selects which ArcGIS version this dataset should be compatible with. ALL is used by default and means any ArcGIS 10.x or ArcGIS Pro version. Using ARCGIS_PRO_3_2_OR_LATER is required to "
            "export 64-bit integer fields as such, otherwise they will be converted as Real fields. ARCGIS_PRO_3_2_OR_LATER also supports proper Date and Time field types."
          ),
          QStringList() << u"ALL"_s << u"ARCGIS_PRO_3_2_OR_LATER"_s,
          u"ALL"_s // Default value
        )
      );
#endif
 
      layerOptions.insert(
        u"FEATURE_DATASET"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "When this option is set, the new layer will be created inside the named "
            "FeatureDataset folder. If the folder does not already exist, it will be created."
          ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"LAYER_ALIAS"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Set layer name alias." ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Set name of geometry column in new layer. Defaults to 'SHAPE'." ),
          u"SHAPE"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NULLABLE"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Whether the values of the geometry column can be NULL. Can be set to NO so that geometry is required. Default to 'YES'." ),
          true // Default value
        )
      );
 
      layerOptions.insert(
        u"FID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name of the OID column to create. Defaults to 'OBJECTID'." ),
          u"OBJECTID"_s // Default value
        )
      );
 
      // TODO missing options -- requires double option type
      // XYTOLERANCE
      // ZTOLERANCE
      // MTOLERANCE
      // XORIGIN
      // YORIGIN
      // ZORIGIN
      // MORIGIN
      // XYSCALE
      // ZSCALE
      // ZORIGIN
 
      layerOptions.insert(
        u"COLUMN_TYPES"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "A list of strings of format field_name=fgdb_field_type (separated by comma) to force the FileGDB column type of fields to be created." ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"DOCUMENTATION"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "XML documentation for the layer." ),
          QString() // Default value
        )
      );
      layerOptions.insert(
        u"CONFIGURATION_KEYWORD"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Customize how data is stored. By default text in UTF-8 and data up to 1TB." ),
          { u"DEFAULTS"_s, u"MAX_FILE_SIZE_4GB"_s, u"MAX_FILE_SIZE_256TB"_s },
          u"DEFAULTS"_s, // Default value
          false          // Allow None
        )
      );
 
      layerOptions.insert(
        u"CREATE_SHAPE_AREA_AND_LENGTH_FIELDS"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            " Defaults to NO (through CreateLayer() API). When this option is set, a Shape_Area and Shape_Length special fields will be created for polygonal layers (Shape_Length only for linear "
            "layers). These fields will automatically be populated with the feature’s area or length whenever a new feature is added to the dataset or an existing feature is amended. When using "
            "ogr2ogr with a source layer that has Shape_Area/Shape_Length special fields, and this option is not explicitly specified, it will be automatically set, so that the resulting "
            "FileGeodatabase has those fields properly tagged."
          ),
          false // Default value
        )
      );
 
      driverMetadata.insert( u"OpenFileGDB"_s, QgsVectorFileWriter::MetaData( u"ESRI File Geodatabase"_s, QObject::tr( "ESRI File Geodatabase" ), u"*.gdb"_s, u"gdb"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
#if GDAL_VERSION_NUM < GDAL_COMPUTE_VERSION( 3, 11, 0 )
      // ESRI FileGDB (using ESRI FileGDB API SDK)
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"FEATURE_DATASET"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "When this option is set, the new layer will be created inside the named "
            "FeatureDataset folder. If the folder does not already exist, it will be created."
          ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Set name of geometry column in new layer. Defaults to 'SHAPE'." ),
          u"SHAPE"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"FID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name of the OID column to create. Defaults to 'OBJECTID'." ),
          u"OBJECTID"_s // Default value
        )
      );
 
      driverMetadata.insert( u"FileGDB"_s, QgsVectorFileWriter::MetaData( u"ESRI FileGDB"_s, QObject::tr( "ESRI FileGDB" ), u"*.gdb"_s, u"gdb"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
#endif
 
      // XLSX
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"OGR_XLSX_FIELD_TYPES"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default, the driver will try to detect the data type of fields. If set "
            "to STRING, all fields will be of String type."
          ),
          QStringList() << u"AUTO"_s << u"STRING"_s,
          u"AUTO"_s, // Default value
          false      // Allow None
        )
      );
 
      layerOptions.insert(
        u"OGR_XLSX_HEADERS"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default, the driver will read the first lines of each sheet to detect "
            "if the first line might be the name of columns. If set to FORCE, the driver "
            "will consider the first line as the header line. If set to "
            "DISABLE, it will be considered as the first feature. Otherwise "
            "auto-detection will occur."
          ),
          QStringList() << u"FORCE"_s << u"DISABLE"_s << u"AUTO"_s,
          u"AUTO"_s, // Default value
          false      // Allow None
        )
      );
 
      driverMetadata
        .insert( u"XLSX"_s, QgsVectorFileWriter::MetaData( u"MS Office Open XML spreadsheet"_s, QObject::tr( "MS Office Open XML spreadsheet [XLSX]" ), u"*.xlsx"_s, u"xlsx"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // ODS
      datasetOptions.clear();
      layerOptions.clear();
 
      layerOptions.insert(
        u"OGR_ODS_FIELD_TYPES"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default, the driver will try to detect the data type of fields. If set "
            "to STRING, all fields will be of String type."
          ),
          QStringList() << u"AUTO"_s << u"STRING"_s,
          u"AUTO"_s, // Default value
          false      // Allow None
        )
      );
 
      layerOptions.insert(
        u"OGR_ODS_HEADERS"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr(
            "By default, the driver will read the first lines of each sheet to detect "
            "if the first line might be the name of columns. If set to FORCE, the driver "
            "will consider the first line as the header line. If set to "
            "DISABLE, it will be considered as the first feature. Otherwise "
            "auto-detection will occur."
          ),
          QStringList() << u"FORCE"_s << u"DISABLE"_s << u"AUTO"_s,
          u"AUTO"_s, // Default value
          false      // Allow None
        )
      );
 
      driverMetadata.insert( u"ODS"_s, QgsVectorFileWriter::MetaData( u"Open Document Spreadsheet"_s, QObject::tr( "Open Document Spreadsheet [ODS]" ), u"*.ods"_s, u"ods"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // Parquet
      datasetOptions.clear();
      layerOptions.clear();
 
      QStringList compressionMethods;
      const QStringList searchCompressions = { u"NONE"_s, u"SNAPPY"_s, u"BROTLI"_s, u"ZSTD"_s };
 
      if ( GDALDriverH hParquetDrv = GDALGetDriverByName( "PARQUET" ) )
      {
        if ( const char *xml = GDALGetMetadataItem( hParquetDrv, GDAL_DS_LAYER_CREATIONOPTIONLIST, nullptr ) )
        {
          for ( const QString &comp : searchCompressions )
          {
            QRegularExpression re( "<Value[^>]*>\\s*" + comp + "\\s*</Value>" );
            if ( re.match( QString::fromUtf8( xml ) ).hasMatch() )
            {
              compressionMethods << comp;
            }
          }
        }
      }
 
      layerOptions.insert(
        u"COMPRESSION"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Compression method." ),
          compressionMethods,
          u"SNAPPY"_s, // Default value
          false        // Allow None
        )
      );
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 12, 0 )
      layerOptions.insert(
        u"COMPRESSION_LEVEL"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr( "Compression level." ),
          -1 // Default value
        )
      );
#endif
 
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 9, 0 )
      layerOptions.insert(
        u"SORT_BY_BBOX"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Whether to sort by spatial location. Enables faster spatial filtering on reading." ),
          false // Default value
        )
      );
 
      layerOptions.insert(
        u"WRITE_COVERING_BBOX"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Whether to write the bounding box of geometries into columns." ),
          true // Default value
        )
      );
#endif
 
      layerOptions.insert(
        u"GEOMETRY_ENCODING"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Geometry encoding." ),
          QStringList() << u"WKB"_s << u"WKT"_s << u"GEOARROW"_s,
          u"WKB"_s, // Default value
          false     // Allow None
        )
      );
 
      layerOptions.insert(
        u"ROW_GROUP_SIZE"_s,
        new QgsVectorFileWriter::IntOption(
          QObject::tr( "Maximum number of rows per group." ),
          65536 // Default value
        )
      );
 
      layerOptions.insert(
        u"FID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name for the feature identifier column" ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr( "Name for the geometry column" ),
          u"geometry"_s // Default value
        )
      );
 
      layerOptions.insert(
        u"EDGES"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Name of the coordinate system for the edges." ),
          QStringList() << u"PLANAR"_s << u"SPHERICAL"_s,
          u"PLANAR"_s, // Default value
          false        // Allow None
        )
      );
 
      driverMetadata.insert( u"Parquet"_s, QgsVectorFileWriter::MetaData( u"(Geo)Parquet"_s, QObject::tr( "(Geo)Parquet" ), u"*.parquet"_s, u"parquet"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
 
      // PGDump
      datasetOptions.clear();
      layerOptions.clear();
 
      datasetOptions.insert(
        u"LINEFORMAT"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Line termination character sequence." ),
          QStringList() << u"CRLF"_s << u"LF"_s,
          u"LF"_s, // Default value
          false    // Allow None
        )
      );
 
 
      layerOptions.insert(
        u"GEOM_TYPE"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Format of geometry columns." ),
          QStringList() << u"geometry"_s << u"geography"_s,
          u"geometry"_s, // Default value
          false          // Allow None
        )
      );
 
      layerOptions.insert(
        u"LAUNDER"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr(
            "Controls whether layer and field names will be laundered for easier use. "
            "Laundered names will be converted to lower case and some special "
            "characters(' - #) will be changed to underscores."
          ),
          true // Default value
        )
      );
 
      layerOptions.insert(
        u"GEOMETRY_NAME"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Name for the geometry column. Defaults to wkb_geometry "
            "for GEOM_TYPE=geometry or the_geog for GEOM_TYPE=geography"
          )
        )
      );
 
      layerOptions.insert( u"SCHEMA"_s, new QgsVectorFileWriter::StringOption( QObject::tr( "Name of schema into which to create the new table" ) ) );
 
      layerOptions.insert(
        u"CREATE_SCHEMA"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Whether to explicitly emit the CREATE SCHEMA statement to create the specified schema." ),
          true // Default value
        )
      );
 
      layerOptions.insert(
        u"CREATE_TABLE"_s,
        new QgsVectorFileWriter::BoolOption(
          QObject::tr( "Whether to explicitly recreate the table if necessary." ),
          true // Default value
        )
      );
 
      layerOptions.insert(
        u"DROP_TABLE"_s,
        new QgsVectorFileWriter::SetOption(
          QObject::tr( "Whether to explicitly destroy tables before recreating them." ),
          QStringList() << u"YES"_s << u"NO"_s << u"IF_EXISTS"_s,
          u"YES"_s, // Default value
          false     // Allow None
        )
      );
 
      layerOptions.insert(
        u"SRID"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Used to force the SRID number of the SRS associated with the layer. "
            "When this option isn't specified and that a SRS is associated with the "
            "layer, a search is made in the spatial_ref_sys to find a match for the "
            "SRS, and, if there is no match, a new entry is inserted for the SRS in "
            "the spatial_ref_sys table. When the SRID option is specified, this "
            "search (and the eventual insertion of a new entry) will not be done: "
            "the specified SRID is used as such."
          ),
          QString() // Default value
        )
      );
 
      layerOptions.insert(
        u"POSTGIS_VERSION"_s,
        new QgsVectorFileWriter::StringOption(
          QObject::tr(
            "Can be set to 2.0 or 2.2 for PostGIS 2.0/2.2 compatibility. "
            "Important to set it correctly if using non-linear geometry types"
          ),
          u"2.2"_s // Default value
        )
      );
 
      driverMetadata.insert( u"PGDUMP"_s, QgsVectorFileWriter::MetaData( u"PostgreSQL SQL dump"_s, QObject::tr( "PostgreSQL SQL dump" ), u"*.sql"_s, u"sql"_s, datasetOptions, layerOptions, u"UTF-8"_s ) );
    }
 
    QgsVectorFileWriterMetadataContainer( const QgsVectorFileWriterMetadataContainer &other ) = delete;
    QgsVectorFileWriterMetadataContainer &operator=( const QgsVectorFileWriterMetadataContainer &other ) = delete;
    ~QgsVectorFileWriterMetadataContainer()
    {
      for ( auto it = driverMetadata.constBegin(); it != driverMetadata.constEnd(); ++it )
      {
        for ( auto optionIt = it.value().driverOptions.constBegin(); optionIt != it.value().driverOptions.constEnd(); ++optionIt )
          delete optionIt.value();
        for ( auto optionIt = it.value().layerOptions.constBegin(); optionIt != it.value().layerOptions.constEnd(); ++optionIt )
          delete optionIt.value();
      }
    }
 
    QMap<QString, QgsVectorFileWriter::MetaData> driverMetadata;
};
 
bool QgsVectorFileWriter::driverMetadata( const QString &driverName, QgsVectorFileWriter::MetaData &driverMetadata )
{
  static QgsVectorFileWriterMetadataContainer sDriverMetadata;
  QMap<QString, MetaData>::ConstIterator it = sDriverMetadata.driverMetadata.constBegin();
 
  for ( ; it != sDriverMetadata.driverMetadata.constEnd(); ++it )
  {
    if ( it.key() == "PGDUMP"_L1 && driverName != "PGDUMP"_L1 && driverName != "PostgreSQL SQL dump"_L1 )
    {
      // We do not want the 'PG' driver to be wrongly identified with PGDUMP
      continue;
    }
    if ( it.key().startsWith( driverName ) || it.value().longName.startsWith( driverName ) )
    {
      driverMetadata = it.value();
      return true;
    }
  }
 
  return false;
}
 
QStringList QgsVectorFileWriter::defaultDatasetOptions( const QString &driverName )
{
  MetaData metadata;
  bool ok = driverMetadata( driverName, metadata );
  if ( !ok )
    return QStringList();
  return concatenateOptions( metadata.driverOptions );
}
 
QStringList QgsVectorFileWriter::defaultLayerOptions( const QString &driverName )
{
  MetaData metadata;
  bool ok = driverMetadata( driverName, metadata );
  if ( !ok )
    return QStringList();
  return concatenateOptions( metadata.layerOptions );
}
 
OGRwkbGeometryType QgsVectorFileWriter::ogrTypeFromWkbType( Qgis::WkbType type )
{
  return QgsOgrUtils::qgsWkbTypeToOgrGeometryType( type, /* approx = */ true );
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::hasError() const
{
  return mError;
}
 
QString QgsVectorFileWriter::errorMessage() const
{
  return mErrorMessage;
}
 
QString QgsVectorFileWriter::driver() const
{
  return mOgrDriverName;
}
 
QString QgsVectorFileWriter::driverLongName() const
{
  return mOgrDriverLongName;
}
 
Qgis::VectorFileWriterCapabilities QgsVectorFileWriter::capabilities() const
{
  return mCapabilities;
}
 
bool QgsVectorFileWriter::addFeature( QgsFeature &feature, QgsFeatureSink::Flags )
{
  return addFeatureWithStyle( feature, nullptr, Qgis::DistanceUnit::Meters );
}
 
bool QgsVectorFileWriter::addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags )
{
  QgsFeatureList::iterator fIt = features.begin();
  bool result = true;
  for ( ; fIt != features.end(); ++fIt )
  {
    result = result && addFeatureWithStyle( *fIt, nullptr, Qgis::DistanceUnit::Meters );
  }
  return result;
}
 
QString QgsVectorFileWriter::lastError() const
{
  return mErrorMessage;
}
 
bool QgsVectorFileWriter::addFeatureWithStyle( QgsFeature &feature, QgsFeatureRenderer *renderer, Qgis::DistanceUnit outputUnit )
{
  // create the feature
  gdal::ogr_feature_unique_ptr poFeature = createFeature( feature );
  if ( !poFeature )
    return false;
 
  //add OGR feature style type
  if ( mSymbologyExport != Qgis::FeatureSymbologyExport::NoSymbology && renderer )
  {
    mRenderContext.expressionContext().setFeature( feature );
    //SymbolLayerSymbology: concatenate ogr styles of all symbollayers
    QgsSymbolList symbols = renderer->symbolsForFeature( feature, mRenderContext );
    QString styleString;
    QString currentStyle;
 
    QgsSymbolList::const_iterator symbolIt = symbols.constBegin();
    for ( ; symbolIt != symbols.constEnd(); ++symbolIt )
    {
      int nSymbolLayers = ( *symbolIt )->symbolLayerCount();
      for ( int i = 0; i < nSymbolLayers; ++i )
      {
#if 0
        QMap< QgsSymbolLayer *, QString >::const_iterator it = mSymbolLayerTable.find( ( *symbolIt )->symbolLayer( i ) );
        if ( it == mSymbolLayerTable.constEnd() )
        {
          continue;
        }
#endif
        double mmsf = mmScaleFactor( mSymbologyScale, ( *symbolIt )->outputUnit(), outputUnit );
        double musf = mapUnitScaleFactor( mSymbologyScale, ( *symbolIt )->outputUnit(), outputUnit );
 
        currentStyle = ( *symbolIt )->symbolLayer( i )->ogrFeatureStyle( mmsf, musf ); //"@" + it.value();
 
        switch ( mSymbologyExport )
        {
          case Qgis::FeatureSymbologyExport::PerFeature:
          {
            if ( symbolIt != symbols.constBegin() || i != 0 )
            {
              styleString.append( ';' );
            }
            styleString.append( currentStyle );
            break;
          }
          case Qgis::FeatureSymbologyExport::PerSymbolLayer:
          {
            OGR_F_SetStyleString( poFeature.get(), currentStyle.toLocal8Bit().constData() );
            if ( !writeFeature( mLayer, poFeature.get() ) )
            {
              return false;
            }
            break;
          }
 
          case Qgis::FeatureSymbologyExport::NoSymbology:
            break;
        }
      }
    }
    OGR_F_SetStyleString( poFeature.get(), styleString.toLocal8Bit().constData() );
  }
 
  switch ( mSymbologyExport )
  {
    case Qgis::FeatureSymbologyExport::NoSymbology:
    case Qgis::FeatureSymbologyExport::PerFeature:
    {
      if ( !writeFeature( mLayer, poFeature.get() ) )
      {
        return false;
      }
      break;
    }
 
    case Qgis::FeatureSymbologyExport::PerSymbolLayer:
      break;
  }
 
  return true;
}
 
gdal::ogr_feature_unique_ptr QgsVectorFileWriter::createFeature( const QgsFeature &feature )
{
  QgsLocaleNumC l; // Make sure the decimal delimiter is a dot
  Q_UNUSED( l )
 
  gdal::ogr_feature_unique_ptr poFeature( OGR_F_Create( OGR_L_GetLayerDefn( mLayer ) ) );
 
  // attribute handling
  for ( QMap<int, int>::const_iterator it = mAttrIdxToOgrLayerIdx.constBegin(); it != mAttrIdxToOgrLayerIdx.constEnd(); ++it )
  {
    int fldIdx = it.key();
    int ogrField = it.value();
 
    QVariant attrValue = feature.attribute( fldIdx );
    QgsField field = mFields.at( fldIdx );
 
    if ( feature.isUnsetValue( fldIdx ) )
    {
      OGR_F_UnsetField( poFeature.get(), ogrField );
      continue;
    }
    else if ( QgsVariantUtils::isNull( attrValue ) )
    {
// Starting with GDAL 2.2, there are 2 concepts: unset fields and null fields
// whereas previously there was only unset fields. For a GeoJSON output,
// leaving a field unset will cause it to not appear at all in the output
// feature.
// When all features of a layer have a field unset, this would cause the
// field to not be present at all in the output, and thus on reading to
// have disappeared. #16812
#ifdef OGRNullMarker
      OGR_F_SetFieldNull( poFeature.get(), ogrField );
#endif
      continue;
    }
 
    if ( mFieldValueConverter )
    {
      field = mFieldValueConverter->fieldDefinition( field );
      attrValue = mFieldValueConverter->convert( fldIdx, attrValue );
    }
 
    // Check type compatibility before passing attribute value to OGR
    QString errorMessage;
    if ( !field.convertCompatible( attrValue, &errorMessage ) )
    {
      mErrorMessage = QObject::tr( "Error converting value (%1) for attribute field %2: %3" ).arg( feature.attribute( fldIdx ).toString(), mFields.at( fldIdx ).name(), errorMessage );
      QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
      mError = ErrFeatureWriteFailed;
      return nullptr;
    }
 
    switch ( field.type() )
    {
      case QMetaType::Type::Int:
        OGR_F_SetFieldInteger( poFeature.get(), ogrField, attrValue.toInt() );
        break;
      case QMetaType::Type::LongLong:
        OGR_F_SetFieldInteger64( poFeature.get(), ogrField, attrValue.toLongLong() );
        break;
      case QMetaType::Type::Bool:
        OGR_F_SetFieldInteger( poFeature.get(), ogrField, attrValue.toInt() );
        break;
      case QMetaType::Type::QString:
        OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( attrValue.toString() ).constData() );
        break;
      case QMetaType::Type::Double:
        OGR_F_SetFieldDouble( poFeature.get(), ogrField, attrValue.toDouble() );
        break;
      case QMetaType::Type::QDate:
        OGR_F_SetFieldDateTime( poFeature.get(), ogrField, attrValue.toDate().year(), attrValue.toDate().month(), attrValue.toDate().day(), 0, 0, 0, 0 );
        break;
      case QMetaType::Type::QDateTime:
        if ( mOgrDriverName == "ESRI Shapefile"_L1 )
        {
          OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( attrValue.toDateTime().toString( u"yyyy/MM/dd hh:mm:ss.zzz"_s ) ).constData() );
        }
        else
        {
          const QDateTime dt = attrValue.toDateTime();
          const QDate date = dt.date();
          const QTime time = dt.time();
          OGR_F_SetFieldDateTimeEx( poFeature.get(), ogrField, date.year(), date.month(), date.day(), time.hour(), time.minute(), static_cast<float>( time.second() + static_cast< double >( time.msec() ) / 1000 ), QgsOgrUtils::OGRTZFlagFromQt( dt ) );
        }
        break;
      case QMetaType::Type::QTime:
        if ( mOgrDriverName == "ESRI Shapefile"_L1 )
        {
          OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( attrValue.toString() ).constData() );
        }
        else
        {
          const QTime time = attrValue.toTime();
          OGR_F_SetFieldDateTimeEx( poFeature.get(), ogrField, 0, 0, 0, time.hour(), time.minute(), static_cast<float>( time.second() + static_cast< double >( time.msec() ) / 1000 ), 0 );
        }
        break;
 
      case QMetaType::Type::QByteArray:
      {
        const QByteArray ba = attrValue.toByteArray();
        OGR_F_SetFieldBinary( poFeature.get(), ogrField, ba.size(), const_cast< GByte * >( reinterpret_cast< const GByte * >( ba.data() ) ) );
        break;
      }
 
      case QMetaType::Type::UnknownType:
        break;
 
      case QMetaType::Type::QStringList:
      {
        // handle GPKG conversion to JSON
        if ( mOgrDriverName == "GPKG"_L1 )
        {
          const QJsonDocument doc = QJsonDocument::fromVariant( attrValue );
          QString jsonString;
          if ( !doc.isNull() )
          {
            jsonString = QString::fromUtf8( doc.toJson( QJsonDocument::Compact ).constData() );
          }
          OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( jsonString.constData() ) );
          break;
        }
 
        QStringList list = attrValue.toStringList();
        if ( mSupportedListSubTypes.contains( QMetaType::Type::QString ) )
        {
          int count = list.count();
          char **lst = new char *[count + 1];
          if ( count > 0 )
          {
            int pos = 0;
            for ( const QString &string : list )
            {
              lst[pos] = CPLStrdup( mCodec->fromUnicode( string ).data() );
              pos++;
            }
          }
          lst[count] = nullptr;
          OGR_F_SetFieldStringList( poFeature.get(), ogrField, lst );
          CSLDestroy( lst );
        }
        else
        {
          OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( list.join( ',' ) ).constData() );
        }
        break;
      }
 
      case QMetaType::Type::QVariantList:
        // handle GPKG conversion to JSON
        if ( mOgrDriverName == "GPKG"_L1 )
        {
          const QJsonDocument doc = QJsonDocument::fromVariant( attrValue );
          QString jsonString;
          if ( !doc.isNull() )
          {
            jsonString = QString::fromUtf8( doc.toJson( QJsonDocument::Compact ).data() );
          }
          OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( jsonString.constData() ) );
          break;
        }
 
        // fall through to default for unsupported types
        if ( field.subType() == QMetaType::Type::QString )
        {
          QStringList list = attrValue.toStringList();
          if ( mSupportedListSubTypes.contains( QMetaType::Type::QString ) )
          {
            int count = list.count();
            char **lst = new char *[count + 1];
            if ( count > 0 )
            {
              int pos = 0;
              for ( const QString &string : list )
              {
                lst[pos] = CPLStrdup( mCodec->fromUnicode( string ).data() );
                pos++;
              }
            }
            lst[count] = nullptr;
            OGR_F_SetFieldStringList( poFeature.get(), ogrField, lst );
            CSLDestroy( lst );
          }
          else
          {
            OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( list.join( ',' ) ).constData() );
          }
          break;
        }
        else if ( field.subType() == QMetaType::Type::Int )
        {
          const QVariantList list = attrValue.toList();
          if ( mSupportedListSubTypes.contains( QMetaType::Type::Int ) )
          {
            const int count = list.count();
            int *lst = new int[count];
            if ( count > 0 )
            {
              int pos = 0;
              for ( const QVariant &value : list )
              {
                lst[pos] = value.toInt();
                pos++;
              }
            }
            OGR_F_SetFieldIntegerList( poFeature.get(), ogrField, count, lst );
            delete[] lst;
          }
          else
          {
            QStringList strings;
            strings.reserve( list.size() );
            for ( const QVariant &value : list )
            {
              strings << QString::number( value.toInt() );
            }
            OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( strings.join( ',' ) ).constData() );
          }
          break;
        }
        else if ( field.subType() == QMetaType::Type::Double )
        {
          const QVariantList list = attrValue.toList();
          if ( mSupportedListSubTypes.contains( QMetaType::Type::Double ) )
          {
            const int count = list.count();
            double *lst = new double[count];
            if ( count > 0 )
            {
              int pos = 0;
              for ( const QVariant &value : list )
              {
                lst[pos] = value.toDouble();
                pos++;
              }
            }
            OGR_F_SetFieldDoubleList( poFeature.get(), ogrField, count, lst );
            delete[] lst;
          }
          else
          {
            QStringList strings;
            strings.reserve( list.size() );
            for ( const QVariant &value : list )
            {
              strings << QString::number( value.toDouble() );
            }
            OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( strings.join( ',' ) ).constData() );
          }
          break;
        }
        else if ( field.subType() == QMetaType::Type::LongLong )
        {
          const QVariantList list = attrValue.toList();
          if ( mSupportedListSubTypes.contains( QMetaType::Type::LongLong ) )
          {
            const int count = list.count();
            long long *lst = new long long[count];
            if ( count > 0 )
            {
              int pos = 0;
              for ( const QVariant &value : list )
              {
                lst[pos] = value.toLongLong();
                pos++;
              }
            }
            OGR_F_SetFieldInteger64List( poFeature.get(), ogrField, count, lst );
            delete[] lst;
          }
          else
          {
            QStringList strings;
            strings.reserve( list.size() );
            for ( const QVariant &value : list )
            {
              strings << QString::number( value.toLongLong() );
            }
            OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( strings.join( ',' ) ).constData() );
          }
          break;
        }
        //intentional fall-through
        [[fallthrough]];
 
      case QMetaType::Type::QVariantMap:
      {
        // handle GPKG conversion to JSON
        const char *pszDataSubTypes = GDALGetMetadataItem( OGRGetDriverByName( mOgrDriverName.toLocal8Bit().constData() ), GDAL_DMD_CREATIONFIELDDATASUBTYPES, nullptr );
        if ( pszDataSubTypes && strstr( pszDataSubTypes, "JSON" ) )
        {
          const QJsonDocument doc = QJsonDocument::fromVariant( attrValue );
          QString jsonString;
          if ( !doc.isNull() )
          {
            const QByteArray json { doc.toJson( QJsonDocument::Compact ) };
            jsonString = QString::fromUtf8( json.data() );
          }
          OGR_F_SetFieldString( poFeature.get(), ogrField, mCodec->fromUnicode( jsonString.constData() ) );
          break;
        }
      }
 
        //intentional fall-through
        [[fallthrough]];
 
 
      default:
        mErrorMessage = QObject::tr( "Invalid variant type for field %1[%2]: received %3 with type %4" ).arg( mFields.at( fldIdx ).name() ).arg( ogrField ).arg( attrValue.typeName(), attrValue.toString() );
        QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
        mError = ErrFeatureWriteFailed;
        return nullptr;
    }
  }
 
  if ( mWkbType != Qgis::WkbType::NoGeometry )
  {
    if ( feature.hasGeometry() )
    {
      // build geometry from WKB
      QgsGeometry geom = feature.geometry();
      if ( mCoordinateTransform )
      {
        // output dataset requires coordinate transform
        try
        {
          geom.transform( *mCoordinateTransform );
        }
        catch ( QgsCsException & )
        {
          QgsLogger::warning( QObject::tr( "Feature geometry failed to transform" ) );
          return nullptr;
        }
      }
 
      // turn single geometry to multi geometry if needed
      if ( QgsWkbTypes::flatType( geom.wkbType() ) != QgsWkbTypes::flatType( mWkbType ) && QgsWkbTypes::flatType( geom.wkbType() ) == QgsWkbTypes::flatType( QgsWkbTypes::singleType( mWkbType ) ) )
      {
        geom.convertToMultiType();
      }
 
      // Turn NURBS to LineString
      if ( QgsWkbTypes::flatType( geom.wkbType() ) == Qgis::WkbType::NurbsCurve )
      {
        Qgis::WkbType coercedType = Qgis::WkbType::LineString;
        switch ( geom.wkbType() )
        {
          case Qgis::WkbType::NurbsCurve:
            break;
          case Qgis::WkbType::NurbsCurveZ:
            coercedType = Qgis::WkbType::LineStringZ;
            break;
          case Qgis::WkbType::NurbsCurveM:
            coercedType = Qgis::WkbType::LineStringM;
            break;
          case Qgis::WkbType::NurbsCurveZM:
            coercedType = Qgis::WkbType::LineStringZM;
            break;
          default:
            Q_ASSERT( false );
            break;
        }
        QVector<QgsGeometry> geoms = geom.coerceToType( coercedType );
        if ( geoms.size() == 1 )
          geom = geoms[0];
      }
 
      OGRGeometryH ogrGeom = nullptr;
      QgsAbstractGeometry::WkbFlags wkbFlags;
      if ( geom.wkbType() != mWkbType )
      {
        // If requested WKB type is 25D and geometry WKB type is 3D,
        // we must force the use of 25D.
        if ( mWkbType >= Qgis::WkbType::Point25D && mWkbType <= Qgis::WkbType::MultiPolygon25D )
        {
          //ND: I suspect there's a bug here, in that this is NOT converting the geometry's WKB type,
          //so the exported WKB has a different type to what the OGRGeometry is expecting.
          //possibly this is handled already in OGR, but it should be fixed regardless by actually converting
          //geom to the correct WKB type
          Qgis::WkbType wkbType = geom.wkbType();
          if ( wkbType >= Qgis::WkbType::PointZ && wkbType <= Qgis::WkbType::MultiPolygonZ )
          {
            Qgis::WkbType wkbType25d = static_cast<Qgis::WkbType>(
              static_cast< quint32>( geom.wkbType() ) - static_cast< quint32>( Qgis::WkbType::PointZ ) + static_cast<quint32>( Qgis::WkbType::Point25D )
            );
            ogrGeom = createEmptyGeometry( wkbType25d );
          }
        }
 
        // drop m/z value if not present in output wkb type
        if ( !QgsWkbTypes::hasZ( mWkbType ) && QgsWkbTypes::hasZ( geom.wkbType() ) )
          geom.get()->dropZValue();
        if ( !QgsWkbTypes::hasM( mWkbType ) && QgsWkbTypes::hasM( geom.wkbType() ) )
          geom.get()->dropMValue();
 
        // add m/z values if not present in the input wkb type -- this is needed for formats which determine
        // geometry type based on features, e.g. geojson
        if ( QgsWkbTypes::hasZ( mWkbType ) && !QgsWkbTypes::hasZ( geom.wkbType() ) )
        {
          if ( mOgrDriverName == "ESRI Shapefile"_L1 )
            geom.get()->addZValue( std::numeric_limits<double>::quiet_NaN() );
          else
            geom.get()->addZValue( 0 );
        }
        if ( QgsWkbTypes::hasM( mWkbType ) && !QgsWkbTypes::hasM( geom.wkbType() ) )
        {
          if ( mOgrDriverName == "ESRI Shapefile"_L1 )
            geom.get()->addMValue( std::numeric_limits<double>::quiet_NaN() );
          else
            geom.get()->addMValue( 0 );
        }
 
        if ( !ogrGeom )
        {
          // there's a problem when layer type is set as wkbtype Polygon
          // although there are also features of type MultiPolygon
          // (at least in OGR provider)
          // If the feature's wkbtype is different from the layer's wkbtype,
          // try to export it too.
          //
          // Btw. OGRGeometry must be exactly of the type of the geometry which it will receive
          // i.e. Polygons can't be imported to OGRMultiPolygon
          ogrGeom = createEmptyGeometry( geom.wkbType() );
        }
 
        if ( !ogrGeom )
        {
          mErrorMessage = QObject::tr( "Feature geometry not imported (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
          mError = ErrFeatureWriteFailed;
          QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
          return nullptr;
        }
      }
      else // wkb type matches
      {
        wkbFlags = QgsAbstractGeometry::FlagExportTrianglesAsPolygons;
 
        ogrGeom = createEmptyGeometry( mWkbType );
        if ( !ogrGeom )
        {
          mErrorMessage = QObject::tr( "Feature geometry type %1 not supported by GDAL" ).arg( QgsWkbTypes::translatedDisplayString( mWkbType ) );
          mError = ErrFeatureWriteFailed;
          QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
          return nullptr;
        }
      }
 
      if ( mOgrDriverName == "ESRI Shapefile"_L1 )
        wkbFlags |= QgsAbstractGeometry::FlagExportNanAsDoubleMin;
 
      QByteArray wkb( geom.asWkb( wkbFlags ) );
      if ( wkb.length() > std::numeric_limits<int>::max() )
      {
        mErrorMessage = QObject::tr( "Feature geometry not imported (too large geometry)" );
        mError = ErrFeatureWriteFailed;
        QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
        OGR_G_DestroyGeometry( ogrGeom );
        return nullptr;
      }
      OGRErr err = OGR_G_ImportFromWkb( ogrGeom, reinterpret_cast<unsigned char *>( const_cast<char *>( wkb.constData() ) ), static_cast<int>( wkb.length() ) );
      if ( err != OGRERR_NONE )
      {
        mErrorMessage = QObject::tr( "Feature geometry not imported (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
        mError = ErrFeatureWriteFailed;
        QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
        OGR_G_DestroyGeometry( ogrGeom );
        return nullptr;
      }
 
      // pass ownership to geometry
      OGR_F_SetGeometryDirectly( poFeature.get(), ogrGeom );
    }
    else
    {
      OGR_F_SetGeometryDirectly( poFeature.get(), createEmptyGeometry( mWkbType ) );
    }
  }
  return poFeature;
}
 
void QgsVectorFileWriter::resetMap( const QgsAttributeList &attributes )
{
  QMap<int, int> omap( mAttrIdxToOgrLayerIdx );
  mAttrIdxToOgrLayerIdx.clear();
  for ( int i = 0; i < attributes.size(); i++ )
  {
    if ( omap.find( i ) != omap.end() )
      mAttrIdxToOgrLayerIdx.insert( attributes[i], omap[i] );
  }
}
 
bool QgsVectorFileWriter::writeFeature( OGRLayerH layer, OGRFeatureH feature )
{
  if ( OGR_L_CreateFeature( layer, feature ) != OGRERR_NONE )
  {
    mErrorMessage = QObject::tr( "Feature creation error (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
    mError = ErrFeatureWriteFailed;
    QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
    return false;
  }
  return true;
}
 
QgsVectorFileWriter::~QgsVectorFileWriter()
{
  if ( mUsingTransaction )
  {
    if ( OGRERR_NONE != OGR_L_CommitTransaction( mLayer ) )
    {
      QgsDebugError( u"Error while committing transaction on OGRLayer."_s );
    }
  }
  mDS.reset();
 
  if ( mOgrRef )
  {
    OSRRelease( mOgrRef );
  }
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormat(
  QgsVectorLayer *layer,
  const QString &fileName,
  const QString &fileEncoding,
  const QgsCoordinateReferenceSystem &destCRS,
  const QString &driverName,
  bool onlySelected,
  QString *errorMessage,
  const QStringList &datasourceOptions,
  const QStringList &layerOptions,
  bool skipAttributeCreation,
  QString *newFilename,
  Qgis::FeatureSymbologyExport symbologyExport,
  double symbologyScale,
  const QgsRectangle *filterExtent,
  Qgis::WkbType overrideGeometryType,
  bool forceMulti,
  bool includeZ,
  const QgsAttributeList &attributes,
  FieldValueConverter *fieldValueConverter,
  QString *newLayer
)
{
  if ( !layer )
  {
    return QgsVectorFileWriter::WriterError::ErrInvalidLayer;
  }
 
  QgsCoordinateTransform ct;
  if ( destCRS.isValid() )
  {
    ct = QgsCoordinateTransform( layer->crs(), destCRS, layer->transformContext() );
  }
 
  SaveVectorOptions options;
  options.fileEncoding = fileEncoding;
  options.ct = ct;
  options.driverName = driverName;
  options.onlySelectedFeatures = onlySelected;
  options.datasourceOptions = datasourceOptions;
  options.layerOptions = layerOptions;
  options.skipAttributeCreation = skipAttributeCreation;
  options.symbologyExport = symbologyExport;
  options.symbologyScale = symbologyScale;
  if ( filterExtent )
    options.filterExtent = *filterExtent;
  options.overrideGeometryType = overrideGeometryType;
  options.forceMulti = forceMulti;
  options.includeZ = includeZ;
  options.attributes = attributes;
  options.fieldValueConverter = fieldValueConverter;
  return writeAsVectorFormatV3( layer, fileName, layer->transformContext(), options, errorMessage, newFilename, newLayer );
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormat(
  QgsVectorLayer *layer,
  const QString &fileName,
  const QString &fileEncoding,
  const QgsCoordinateTransform &ct,
  const QString &driverName,
  bool onlySelected,
  QString *errorMessage,
  const QStringList &datasourceOptions,
  const QStringList &layerOptions,
  bool skipAttributeCreation,
  QString *newFilename,
  Qgis::FeatureSymbologyExport symbologyExport,
  double symbologyScale,
  const QgsRectangle *filterExtent,
  Qgis::WkbType overrideGeometryType,
  bool forceMulti,
  bool includeZ,
  const QgsAttributeList &attributes,
  FieldValueConverter *fieldValueConverter,
  QString *newLayer
)
{
  SaveVectorOptions options;
  options.fileEncoding = fileEncoding;
  options.ct = ct;
  options.driverName = driverName;
  options.onlySelectedFeatures = onlySelected;
  options.datasourceOptions = datasourceOptions;
  options.layerOptions = layerOptions;
  options.skipAttributeCreation = skipAttributeCreation;
  options.symbologyExport = symbologyExport;
  options.symbologyScale = symbologyScale;
  if ( filterExtent )
    options.filterExtent = *filterExtent;
  options.overrideGeometryType = overrideGeometryType;
  options.forceMulti = forceMulti;
  options.includeZ = includeZ;
  options.attributes = attributes;
  options.fieldValueConverter = fieldValueConverter;
  return writeAsVectorFormatV3( layer, fileName, layer->transformContext(), options, errorMessage, newFilename, newLayer );
}
 
 
QgsVectorFileWriter::SaveVectorOptions::SaveVectorOptions()
  : driverName( u"GPKG"_s )
{}
 
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::prepareWriteAsVectorFormat(
  QgsVectorLayer *layer, const QgsVectorFileWriter::SaveVectorOptions &options, QgsVectorFileWriter::PreparedWriterDetails &details
)
{
  if ( !layer || !layer->isValid() )
  {
    return ErrInvalidLayer;
  }
 
  if ( layer->renderer() )
    details.renderer.reset( layer->renderer()->clone() );
  details.sourceCrs = layer->crs();
  details.sourceWkbType = layer->wkbType();
  details.sourceFields = layer->fields();
  details.providerType = layer->providerType();
  details.featureCount = options.onlySelectedFeatures ? layer->selectedFeatureCount() : layer->featureCount();
  if ( layer->dataProvider() )
    details.dataSourceUri = layer->dataProvider()->dataSourceUri();
  details.storageType = layer->storageType();
  details.selectedFeatureIds = layer->selectedFeatureIds();
  details.providerUriParams = QgsProviderRegistry::instance()->decodeUri( layer->providerType(), layer->dataProvider()->dataSourceUri() );
 
  if ( details.storageType == "ESRI Shapefile"_L1 )
  {
    QgsFeatureRequest req;
    if ( options.onlySelectedFeatures )
    {
      req.setFilterFids( details.selectedFeatureIds );
    }
    req.setNoAttributes();
    details.geometryTypeScanIterator = layer->getFeatures( req );
  }
 
  details.expressionContext = QgsExpressionContext( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
  details.renderContext.setExpressionContext( details.expressionContext );
  details.renderContext.setRendererScale( options.symbologyScale );
 
  details.shallTransform = false;
  if ( options.ct.isValid() )
  {
    // This means we should transform
    details.outputCrs = options.ct.destinationCrs();
    details.shallTransform = true;
  }
  else
  {
    // This means we shouldn't transform, use source CRS as output (if defined)
    details.outputCrs = details.sourceCrs;
  }
 
  details.destWkbType = details.sourceWkbType;
  if ( options.overrideGeometryType != Qgis::WkbType::Unknown )
  {
    details.destWkbType = QgsWkbTypes::flatType( options.overrideGeometryType );
    if ( QgsWkbTypes::hasZ( options.overrideGeometryType ) || options.includeZ )
      details.destWkbType = QgsWkbTypes::addZ( details.destWkbType );
  }
  if ( options.forceMulti )
  {
    details.destWkbType = QgsWkbTypes::multiType( details.destWkbType );
  }
 
  details.attributes = options.attributes;
  if ( options.skipAttributeCreation )
    details.attributes.clear();
  else if ( details.attributes.isEmpty() )
  {
    const QgsAttributeList allAttributes = details.sourceFields.allAttributesList();
    for ( int idx : allAttributes )
    {
      QgsField fld = details.sourceFields.at( idx );
      if ( details.providerType == "oracle"_L1 && fld.typeName().contains( "SDO_GEOMETRY"_L1 ) )
        continue;
      details.attributes.append( idx );
    }
  }
 
  if ( !details.attributes.isEmpty() )
  {
    for ( int attrIdx : std::as_const( details.attributes ) )
    {
      if ( details.sourceFields.exists( attrIdx ) )
      {
        QgsField field = details.sourceFields.at( attrIdx );
        field.setName( options.attributesExportNames.value( attrIdx, field.name() ) );
        details.outputFields.append( field );
      }
      else
      {
        QgsDebugError( u"No such source field with index '%1' available."_s.arg( attrIdx ) );
      }
    }
  }
 
  // not ideal - would be nice to avoid this happening in the preparation step if possible,
  // but currently requires access to the layer's minimumValue/maximumValue methods
  if ( details.providerType == "spatialite"_L1 )
  {
    for ( int i = 0; i < details.outputFields.size(); i++ )
    {
      if ( details.outputFields.at( i ).type() == QMetaType::Type::LongLong )
      {
        QVariant min;
        QVariant max;
        layer->minimumAndMaximumValue( i, min, max );
        if ( std::max( std::llabs( min.toLongLong() ), std::llabs( max.toLongLong() ) ) < std::numeric_limits<int>::max() )
        {
          details.outputFields[i].setType( QMetaType::Type::Int );
        }
      }
    }
  }
 
 
  //add possible attributes needed by renderer
  addRendererAttributes( details.renderer.get(), details.renderContext, details.sourceFields, details.attributes );
 
  QgsFeatureRequest req;
  req.setSubsetOfAttributes( details.attributes );
  if ( options.onlySelectedFeatures )
    req.setFilterFids( details.selectedFeatureIds );
 
  if ( !options.filterExtent.isNull() )
  {
    QgsRectangle filterRect = options.filterExtent;
    bool useFilterRect = true;
    if ( details.shallTransform )
    {
      try
      {
        // map filter rect back from destination CRS to layer CRS
        QgsCoordinateTransform extentTransform = options.ct;
        extentTransform.setBallparkTransformsAreAppropriate( true );
        filterRect = extentTransform.transformBoundingBox( filterRect, Qgis::TransformDirection::Reverse );
      }
      catch ( QgsCsException & )
      {
        useFilterRect = false;
      }
    }
    if ( useFilterRect )
    {
      req.setFilterRect( filterRect );
    }
    details.filterRectGeometry = QgsGeometry::fromRect( options.filterExtent );
    details.filterRectEngine.reset( QgsGeometry::createGeometryEngine( details.filterRectGeometry.constGet() ) );
    details.filterRectEngine->prepareGeometry();
  }
  details.sourceFeatureIterator = layer->getFeatures( req );
 
  if ( !options.sourceDatabaseProviderConnection )
  {
    details.sourceDatabaseProviderConnection.reset( QgsMapLayerUtils::databaseConnection( layer ) );
  }
 
  return NoError;
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormat(
  PreparedWriterDetails &details, const QString &fileName, const QgsVectorFileWriter::SaveVectorOptions &options, QString *newFilename, QString *errorMessage, QString *newLayer
)
{
  return writeAsVectorFormatV2( details, fileName, QgsCoordinateTransformContext(), options, newFilename, newLayer, errorMessage );
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormatV2(
  PreparedWriterDetails &details,
  const QString &fileName,
  const QgsCoordinateTransformContext &transformContext,
  const QgsVectorFileWriter::SaveVectorOptions &options,
  QString *newFilename,
  QString *newLayer,
  QString *errorMessage,
  SinkFlags sinkFlags
)
{
  Qgis::WkbType destWkbType = details.destWkbType;
 
  int lastProgressReport = 0;
  long long total = details.featureCount;
 
  // Special rules for OGR layers
  if ( details.providerType == "ogr"_L1 && !details.dataSourceUri.isEmpty() )
  {
    QString srcFileName( details.providerUriParams.value( u"path"_s ).toString() );
    if ( QFile::exists( srcFileName ) && QFileInfo( fileName ).canonicalFilePath() == QFileInfo( srcFileName ).canonicalFilePath() )
    {
      // Check the layer name too if it's a GPKG/SpatiaLite/SQLite OGR driver (pay attention: camel case in layerName)
      QgsDataSourceUri uri( details.dataSourceUri );
      if ( !( ( options.driverName == "GPKG"_L1 || options.driverName == "SpatiaLite"_L1 || options.driverName == "SQLite"_L1 )
              && options.layerName != details.providerUriParams.value( u"layerName"_s ) ) )
      {
        if ( errorMessage )
          *errorMessage = QObject::tr( "Cannot overwrite an OGR layer in place" );
        return ErrCreateDataSource;
      }
    }
 
    // Shapefiles might contain multi types although wkbType() only reports singles
    if ( details.storageType == "ESRI Shapefile"_L1 && !QgsWkbTypes::isMultiType( destWkbType ) )
    {
      QgsFeatureIterator fit = details.geometryTypeScanIterator;
      QgsFeature fet;
      long scanned = 0;
      while ( fit.nextFeature( fet ) )
      {
        if ( options.feedback && options.feedback->isCanceled() )
        {
          return Canceled;
        }
        if ( options.feedback )
        {
          //dedicate first 5% of progress bar to this scan
          int newProgress = static_cast<int>( ( 5.0 * scanned ) / total );
          if ( newProgress != lastProgressReport )
          {
            lastProgressReport = newProgress;
            options.feedback->setProgress( lastProgressReport );
          }
        }
 
        if ( fet.hasGeometry() && QgsWkbTypes::isMultiType( fet.geometry().wkbType() ) )
        {
          destWkbType = QgsWkbTypes::multiType( destWkbType );
          break;
        }
        scanned++;
      }
    }
  }
 
  QString tempNewFilename;
  QString tempNewLayer;
 
  QgsVectorFileWriter::SaveVectorOptions newOptions = options;
  if ( !newOptions.sourceDatabaseProviderConnection )
  {
    newOptions.sourceDatabaseProviderConnection = details.sourceDatabaseProviderConnection.get();
  }
 
  std::unique_ptr< QgsVectorFileWriter > writer( create( fileName, details.outputFields, destWkbType, details.outputCrs, transformContext, newOptions, sinkFlags, &tempNewFilename, &tempNewLayer ) );
  writer->setSymbologyScale( options.symbologyScale );
 
  if ( newFilename )
    *newFilename = tempNewFilename;
 
  if ( newLayer )
    *newLayer = tempNewLayer;
 
  if ( newFilename )
  {
    QgsDebugMsgLevel( "newFilename = " + *newFilename, 2 );
  }
 
  // check whether file creation was successful
  WriterError err = writer->hasError();
  if ( err != NoError )
  {
    if ( errorMessage )
      *errorMessage = writer->errorMessage();
    return err;
  }
 
  if ( errorMessage )
  {
    errorMessage->clear();
  }
 
  QgsFeature fet;
 
  //create symbol table if needed
  if ( writer->symbologyExport() != Qgis::FeatureSymbologyExport::NoSymbology )
  {
    //writer->createSymbolLayerTable( layer,  writer->mDS );
  }
 
  switch ( writer->symbologyExport() )
  {
    case Qgis::FeatureSymbologyExport::PerSymbolLayer:
    {
      QgsFeatureRenderer *r = details.renderer.get();
      if ( r && r->capabilities() & QgsFeatureRenderer::SymbolLevels && r->usingSymbolLevels() )
      {
        QgsVectorFileWriter::WriterError error = writer->exportFeaturesSymbolLevels( details, details.sourceFeatureIterator, options.ct, errorMessage );
        return ( error == NoError ) ? NoError : ErrFeatureWriteFailed;
      }
      break;
    }
    case Qgis::FeatureSymbologyExport::NoSymbology:
    case Qgis::FeatureSymbologyExport::PerFeature:
      break;
  }
 
  int n = 0, errors = 0;
 
  //unit type
  Qgis::DistanceUnit mapUnits = details.sourceCrs.mapUnits();
  if ( options.ct.isValid() )
  {
    mapUnits = options.ct.destinationCrs().mapUnits();
  }
 
  writer->startRender( details.renderer.get(), details.sourceFields );
 
  writer->resetMap( details.attributes );
  // Reset mFields to layer fields, and not just exported fields
  writer->mFields = details.sourceFields;
 
  // write all features
  long saved = 0;
  int initialProgress = lastProgressReport;
  while ( details.sourceFeatureIterator.nextFeature( fet ) )
  {
    if ( options.feedback && options.feedback->isCanceled() )
    {
      return Canceled;
    }
 
    saved++;
    if ( options.feedback )
    {
      //avoid spamming progress reports
      int newProgress = static_cast<int>( initialProgress + ( ( 100.0 - initialProgress ) * saved ) / total );
      if ( newProgress < 100 && newProgress != lastProgressReport )
      {
        lastProgressReport = newProgress;
        options.feedback->setProgress( lastProgressReport );
      }
    }
 
    if ( details.shallTransform )
    {
      try
      {
        if ( fet.hasGeometry() )
        {
          QgsGeometry g = fet.geometry();
          g.transform( options.ct );
          fet.setGeometry( g );
        }
      }
      catch ( QgsCsException &e )
      {
        const QString msg = QObject::tr( "Failed to transform feature with ID '%1'. Writing stopped. (Exception: %2)" ).arg( fet.id() ).arg( e.what() );
        QgsLogger::warning( msg );
        if ( errorMessage )
          *errorMessage = msg;
 
        return ErrProjection;
      }
    }
 
    if ( fet.hasGeometry() && details.filterRectEngine && !details.filterRectEngine->intersects( fet.geometry().constGet() ) )
      continue;
 
    if ( details.attributes.empty() && options.skipAttributeCreation )
    {
      fet.initAttributes( 0 );
    }
 
    if ( !writer->addFeatureWithStyle( fet, writer->mRenderer.get(), mapUnits ) )
    {
      WriterError err = writer->hasError();
      if ( err != NoError && errorMessage )
      {
        if ( errorMessage->isEmpty() )
        {
          *errorMessage = QObject::tr( "Feature write errors:" );
        }
        *errorMessage += '\n' + writer->errorMessage();
      }
      errors++;
 
      if ( errors > 1000 )
      {
        if ( errorMessage )
        {
          *errorMessage += QObject::tr( "Stopping after %n error(s)", nullptr, errors );
        }
 
        n = -1;
        break;
      }
    }
    n++;
  }
 
  writer->stopRender();
 
  if ( errors > 0 && errorMessage && n > 0 )
  {
    *errorMessage += QObject::tr( "\nOnly %1 of %2 features written." ).arg( n - errors ).arg( n );
  }
 
  writer.reset();
 
  bool metadataFailure = false;
  if ( options.saveMetadata )
  {
    QString uri = QgsProviderRegistry::instance()->encodeUri( u"ogr"_s, QVariantMap { { u"path"_s, tempNewFilename }, { u"layerName"_s, tempNewLayer } } );
 
    try
    {
      QString error;
      if ( !QgsProviderRegistry::instance()->saveLayerMetadata( u"ogr"_s, uri, options.layerMetadata, error ) )
      {
        if ( errorMessage )
        {
          if ( !errorMessage->isEmpty() )
            *errorMessage += '\n';
          *errorMessage += error;
        }
        metadataFailure = true;
      }
    }
    catch ( QgsNotSupportedException &e )
    {
      if ( errorMessage )
      {
        if ( !errorMessage->isEmpty() )
          *errorMessage += '\n';
        *errorMessage += e.what();
      }
      metadataFailure = true;
    }
  }
 
  return errors == 0 ? ( !metadataFailure ? NoError : ErrSavingMetadata ) : ErrFeatureWriteFailed;
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormat(
  QgsVectorLayer *layer, const QString &fileName, const SaveVectorOptions &options, QString *newFilename, QString *errorMessage, QString *newLayer
)
{
  QgsVectorFileWriter::PreparedWriterDetails details;
  WriterError err = prepareWriteAsVectorFormat( layer, options, details );
  if ( err != NoError )
    return err;
 
  return writeAsVectorFormatV2( details, fileName, layer->transformContext(), options, newFilename, newLayer, errorMessage );
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormatV2(
  QgsVectorLayer *layer, const QString &fileName, const QgsCoordinateTransformContext &transformContext, const SaveVectorOptions &options, QString *newFilename, QString *newLayer, QString *errorMessage
)
{
  QgsVectorFileWriter::PreparedWriterDetails details;
  WriterError err = prepareWriteAsVectorFormat( layer, options, details );
  if ( err != NoError )
    return err;
 
  return writeAsVectorFormatV2( details, fileName, transformContext, options, newFilename, newLayer, errorMessage );
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormatV3(
  QgsVectorLayer *layer,
  const QString &fileName,
  const QgsCoordinateTransformContext &transformContext,
  const QgsVectorFileWriter::SaveVectorOptions &options,
  QString *errorMessage,
  QString *newFilename,
  QString *newLayer
)
{
  QgsVectorFileWriter::PreparedWriterDetails details;
  WriterError err = prepareWriteAsVectorFormat( layer, options, details );
  if ( err != NoError )
    return err;
 
  return writeAsVectorFormatV2( details, fileName, transformContext, options, newFilename, newLayer, errorMessage );
}
 
bool QgsVectorFileWriter::deleteShapeFile( const QString &fileName )
{
  QFileInfo fi( fileName );
  QDir dir = fi.dir();
 
  QStringList filter;
  for ( const char *suffix : { ".shp", ".shx", ".dbf", ".prj", ".qix", ".qpj", ".cpg", ".sbn", ".sbx", ".idm", ".ind" } )
  {
    filter << fi.completeBaseName() + suffix;
  }
 
  bool ok = true;
  const auto constEntryList = dir.entryList( filter );
  for ( const QString &file : constEntryList )
  {
    QFile f( dir.canonicalPath() + '/' + file );
    if ( !f.remove() )
    {
      QgsDebugError( u"Removing file %1 failed: %2"_s.arg( file, f.errorString() ) );
      ok = false;
    }
  }
 
  return ok;
}
 
void QgsVectorFileWriter::setSymbologyScale( double d )
{
  mSymbologyScale = d;
  mRenderContext.setRendererScale( mSymbologyScale );
}
 
QStringList multiLayerFormats()
{
  QStringList driverNames;
  const QSet< QString > multiLayerExtensions = qgis::listToSet( QgsGdalUtils::multiLayerFileExtensions() );
 
  for ( int i = 0; i < GDALGetDriverCount(); ++i )
  {
    GDALDriverH driver = GDALGetDriver( i );
    if ( !driver )
    {
      QgsLogger::warning( "unable to get driver " + QString::number( i ) );
      continue;
    }
 
    const QString driverExtensions = GDALGetMetadataItem( driver, GDAL_DMD_EXTENSIONS, "" );
    if ( driverExtensions.isEmpty() )
      continue;
 
    const QSet< QString > splitExtensions = qgis::listToSet( driverExtensions.split( ' ', Qt::SkipEmptyParts ) );
    if ( splitExtensions.intersects( multiLayerExtensions ) )
    {
      driverNames << GDALGetDescription( driver );
    }
  }
  return driverNames;
}
 
QList< QgsVectorFileWriter::FilterFormatDetails > QgsVectorFileWriter::supportedFiltersAndFormats( const VectorFormatOptions options )
{
  static QReadWriteLock sFilterLock;
  static QMap< VectorFormatOptions, QList< QgsVectorFileWriter::FilterFormatDetails > > sFilters;
 
  QgsReadWriteLocker locker( sFilterLock, QgsReadWriteLocker::Read );
 
  const auto it = sFilters.constFind( options );
  if ( it != sFilters.constEnd() )
    return it.value();
 
  locker.changeMode( QgsReadWriteLocker::Write );
  QList< QgsVectorFileWriter::FilterFormatDetails > results;
 
  QgsApplication::registerOgrDrivers();
  int const drvCount = OGRGetDriverCount();
 
  const QStringList multiLayerDrivers = multiLayerFormats();
 
  for ( int i = 0; i < drvCount; ++i )
  {
    OGRSFDriverH drv = OGRGetDriver( i );
    if ( drv )
    {
      const QString drvName = GDALGetDescription( drv );
 
      if ( options & SupportsMultipleLayers )
      {
        if ( !multiLayerDrivers.contains( drvName ) )
          continue;
      }
 
      GDALDriverH gdalDriver = GDALGetDriverByName( drvName.toLocal8Bit().constData() );
      bool nonSpatialFormat = false;
      if ( gdalDriver )
      {
        nonSpatialFormat = GDALGetMetadataItem( gdalDriver, GDAL_DCAP_NONSPATIAL, nullptr );
      }
 
      if ( OGR_Dr_TestCapability( drv, "CreateDataSource" ) != 0 )
      {
        if ( options & SkipNonSpatialFormats )
        {
          // skip non-spatial formats
          if ( nonSpatialFormat )
            continue;
        }
 
        QString filterString = filterForDriver( drvName );
        if ( filterString.isEmpty() )
          continue;
 
        MetaData metadata;
        QStringList globs;
        if ( driverMetadata( drvName, metadata ) && !metadata.glob.isEmpty() )
        {
          globs = metadata.glob.toLower().split( ' ' );
        }
 
        FilterFormatDetails details;
        details.driverName = drvName;
        details.filterString = filterString;
        details.globs = globs;
 
        results << details;
      }
    }
  }
 
  std::sort( results.begin(), results.end(), [options]( const FilterFormatDetails &a, const FilterFormatDetails &b ) -> bool {
    if ( options & SortRecommended )
    {
      if ( a.driverName == "GPKG"_L1 )
        return true; // Make https://twitter.com/shapefiIe a sad little fellow
      else if ( b.driverName == "GPKG"_L1 )
        return false;
      else if ( a.driverName == "ESRI Shapefile"_L1 )
        return true;
      else if ( b.driverName == "ESRI Shapefile"_L1 )
        return false;
    }
 
    return a.filterString.toLower().localeAwareCompare( b.filterString.toLower() ) < 0;
  } );
 
  sFilters.insert( options, results );
  return results;
}
 
QStringList QgsVectorFileWriter::supportedFormatExtensions( const VectorFormatOptions options )
{
  const auto formats = supportedFiltersAndFormats( options );
  QSet< QString > extensions;
 
  const thread_local QRegularExpression rx( u"\\*\\.(.*)$"_s );
 
  for ( const FilterFormatDetails &format : formats )
  {
    for ( const QString &glob : format.globs )
    {
      const QRegularExpressionMatch match = rx.match( glob );
      if ( !match.hasMatch() )
        continue;
 
      const QString matched = match.captured( 1 );
      extensions.insert( matched );
    }
  }
 
  QStringList extensionList( extensions.constBegin(), extensions.constEnd() );
 
  std::sort( extensionList.begin(), extensionList.end(), [options]( const QString &a, const QString &b ) -> bool {
    if ( options & SortRecommended )
    {
      if ( a == "gpkg"_L1 )
        return true; // Make https://twitter.com/shapefiIe a sad little fellow
      else if ( b == "gpkg"_L1 )
        return false;
      else if ( a == "shp"_L1 )
        return true;
      else if ( b == "shp"_L1 )
        return false;
    }
 
    return a.toLower().localeAwareCompare( b.toLower() ) < 0;
  } );
 
  return extensionList;
}
 
QList< QgsVectorFileWriter::DriverDetails > QgsVectorFileWriter::ogrDriverList( const VectorFormatOptions options )
{
  QList< QgsVectorFileWriter::DriverDetails > results;
 
  QgsApplication::registerOgrDrivers();
  const int drvCount = OGRGetDriverCount();
 
  const QStringList multiLayerDrivers = multiLayerFormats();
 
  QStringList writableDrivers;
  for ( int i = 0; i < drvCount; ++i )
  {
    OGRSFDriverH drv = OGRGetDriver( i );
    if ( drv )
    {
      const QString drvName = GDALGetDescription( drv );
 
      if ( options & SupportsMultipleLayers )
      {
        if ( !multiLayerDrivers.contains( drvName ) )
          continue;
      }
 
      if ( options & SkipNonSpatialFormats )
      {
        // skip non-spatial formats
        // TODO - use GDAL metadata to determine this, when support exists in GDAL
        if ( drvName == "ODS"_L1 || drvName == "XLSX"_L1 || drvName == "XLS"_L1 )
          continue;
      }
 
      if ( drvName == "ESRI Shapefile"_L1 )
      {
        writableDrivers << u"DBF file"_s;
      }
      if ( OGR_Dr_TestCapability( drv, "CreateDataSource" ) != 0 )
      {
        // Add separate format for Mapinfo MIF (MITAB is OGR default)
        if ( drvName == "MapInfo File"_L1 )
        {
          writableDrivers << u"MapInfo MIF"_s;
        }
        else if ( drvName == "SQLite"_L1 )
        {
          // Unfortunately it seems that there is no simple way to detect if
          // OGR SQLite driver is compiled with SpatiaLite support.
          // We have HAVE_SPATIALITE in QGIS, but that may differ from OGR
          // http://lists.osgeo.org/pipermail/gdal-dev/2012-November/034580.html
          // -> test if creation fails
          QString option = u"SPATIALITE=YES"_s;
          char *options[2] = { CPLStrdup( option.toLocal8Bit().constData() ), nullptr };
          OGRSFDriverH poDriver;
          QgsApplication::registerOgrDrivers();
          poDriver = OGRGetDriverByName( drvName.toLocal8Bit().constData() );
          if ( poDriver )
          {
            gdal::ogr_datasource_unique_ptr ds( OGR_Dr_CreateDataSource( poDriver, u"/vsimem/spatialitetest.sqlite"_s.toUtf8().constData(), options ) );
            if ( ds )
            {
              writableDrivers << u"SpatiaLite"_s;
              OGR_Dr_DeleteDataSource( poDriver, u"/vsimem/spatialitetest.sqlite"_s.toUtf8().constData() );
            }
          }
          CPLFree( options[0] );
        }
        writableDrivers << drvName;
      }
    }
  }
 
  results.reserve( writableDrivers.count() );
  for ( const QString &drvName : std::as_const( writableDrivers ) )
  {
    MetaData metadata;
    if ( driverMetadata( drvName, metadata ) && !metadata.trLongName.isEmpty() )
    {
      DriverDetails details;
      details.driverName = drvName;
      details.longName = metadata.trLongName;
      results << details;
    }
  }
 
  std::sort( results.begin(), results.end(), [options]( const DriverDetails &a, const DriverDetails &b ) -> bool {
    if ( options & SortRecommended )
    {
      if ( a.driverName == "GPKG"_L1 )
        return true; // Make https://twitter.com/shapefiIe a sad little fellow
      else if ( b.driverName == "GPKG"_L1 )
        return false;
      else if ( a.driverName == "ESRI Shapefile"_L1 )
        return true;
      else if ( b.driverName == "ESRI Shapefile"_L1 )
        return false;
    }
 
    return a.longName.toLower().localeAwareCompare( b.longName.toLower() ) < 0;
  } );
  return results;
}
 
QString QgsVectorFileWriter::driverForExtension( const QString &extension )
{
  QString ext = extension.trimmed();
  if ( ext.isEmpty() )
    return QString();
 
  if ( ext.startsWith( '.' ) )
    ext.remove( 0, 1 );
 
  GDALAllRegister();
  int const drvCount = GDALGetDriverCount();
 
  for ( int i = 0; i < drvCount; ++i )
  {
    GDALDriverH drv = GDALGetDriver( i );
    if ( drv )
    {
      CSLConstList driverMetadata = GDALGetMetadata( drv, nullptr );
      if ( CSLFetchBoolean( driverMetadata, GDAL_DCAP_CREATE, false ) && CSLFetchBoolean( driverMetadata, GDAL_DCAP_VECTOR, false ) )
      {
        QString drvName = GDALGetDriverShortName( drv );
        QStringList driverExtensions = QString( GDALGetMetadataItem( drv, GDAL_DMD_EXTENSIONS, nullptr ) ).split( ' ' );
 
        const auto constDriverExtensions = driverExtensions;
        for ( const QString &driver : constDriverExtensions )
        {
          if ( driver.compare( ext, Qt::CaseInsensitive ) == 0 )
            return drvName;
        }
      }
    }
  }
  return QString();
}
 
QString QgsVectorFileWriter::fileFilterString( const VectorFormatOptions options )
{
  QString filterString;
  const auto driverFormats = supportedFiltersAndFormats( options );
  for ( const FilterFormatDetails &details : driverFormats )
  {
    if ( !filterString.isEmpty() )
      filterString += ";;"_L1;
 
    filterString += details.filterString;
  }
  return filterString;
}
 
QString QgsVectorFileWriter::filterForDriver( const QString &driverName )
{
  MetaData metadata;
  if ( !driverMetadata( driverName, metadata ) || metadata.trLongName.isEmpty() || metadata.glob.isEmpty() )
    return QString();
 
  return u"%1 (%2 %3)"_s.arg( metadata.trLongName, metadata.glob.toLower(), metadata.glob.toUpper() );
}
 
QString QgsVectorFileWriter::convertCodecNameForEncodingOption( const QString &codecName )
{
  if ( codecName == "System"_L1 )
    return u"LDID/0"_s;
 
  const thread_local QRegularExpression re( QRegularExpression::anchoredPattern( QString( "(CP|windows-|ISO[ -])(.+)" ) ), QRegularExpression::CaseInsensitiveOption );
  const QRegularExpressionMatch match = re.match( codecName );
  if ( match.hasMatch() )
  {
    QString c = match.captured( 2 ).remove( '-' );
    bool isNumber;
    ( void ) c.toInt( &isNumber );
    if ( isNumber )
      return c;
  }
  return codecName;
}
 
void QgsVectorFileWriter::createSymbolLayerTable( QgsVectorLayer *vl, const QgsCoordinateTransform &ct, OGRDataSourceH ds )
{
  if ( !vl || !ds )
  {
    return;
  }
 
  QgsFeatureRenderer *renderer = vl->renderer();
  if ( !renderer )
  {
    return;
  }
 
  //unit type
  Qgis::DistanceUnit mapUnits = vl->crs().mapUnits();
  if ( ct.isValid() )
  {
    mapUnits = ct.destinationCrs().mapUnits();
  }
 
  mSymbolLayerTable.clear();
  OGRStyleTableH ogrStyleTable = OGR_STBL_Create();
  OGRStyleMgrH styleManager = OGR_SM_Create( ogrStyleTable );
 
  //get symbols
  int nTotalLevels = 0;
  QgsSymbolList symbolList = renderer->symbols( mRenderContext );
  QgsSymbolList::iterator symbolIt = symbolList.begin();
  for ( ; symbolIt != symbolList.end(); ++symbolIt )
  {
    double mmsf = mmScaleFactor( mSymbologyScale, ( *symbolIt )->outputUnit(), mapUnits );
    double musf = mapUnitScaleFactor( mSymbologyScale, ( *symbolIt )->outputUnit(), mapUnits );
 
    int nLevels = ( *symbolIt )->symbolLayerCount();
    for ( int i = 0; i < nLevels; ++i )
    {
      mSymbolLayerTable.insert( ( *symbolIt )->symbolLayer( i ), QString::number( nTotalLevels ) );
      OGR_SM_AddStyle( styleManager, QString::number( nTotalLevels ).toLocal8Bit(), ( *symbolIt )->symbolLayer( i )->ogrFeatureStyle( mmsf, musf ).toLocal8Bit() );
      ++nTotalLevels;
    }
  }
  OGR_DS_SetStyleTableDirectly( ds, ogrStyleTable );
}
 
QgsVectorFileWriter::WriterError QgsVectorFileWriter::exportFeaturesSymbolLevels( const PreparedWriterDetails &details, QgsFeatureIterator &fit, const QgsCoordinateTransform &ct, QString *errorMessage )
{
  if ( !details.renderer )
    return ErrInvalidLayer;
 
  mRenderContext.expressionContext() = details.expressionContext;
 
  QHash< QgsSymbol *, QList<QgsFeature> > features;
 
  //unit type
  Qgis::DistanceUnit mapUnits = details.sourceCrs.mapUnits();
  if ( ct.isValid() )
  {
    mapUnits = ct.destinationCrs().mapUnits();
  }
 
  startRender( details.renderer.get(), details.sourceFields );
 
  //fetch features
  QgsFeature fet;
  QgsSymbol *featureSymbol = nullptr;
  while ( fit.nextFeature( fet ) )
  {
    if ( ct.isValid() )
    {
      try
      {
        if ( fet.hasGeometry() )
        {
          QgsGeometry g = fet.geometry();
          g.transform( ct );
          fet.setGeometry( g );
        }
      }
      catch ( QgsCsException &e )
      {
        QString msg = QObject::tr( "Failed to transform, writing stopped. (Exception: %1)" ).arg( e.what() );
        QgsLogger::warning( msg );
        if ( errorMessage )
          *errorMessage = msg;
 
        return ErrProjection;
      }
    }
    mRenderContext.expressionContext().setFeature( fet );
 
    featureSymbol = mRenderer->symbolForFeature( fet, mRenderContext );
    if ( !featureSymbol )
    {
      continue;
    }
 
    QHash< QgsSymbol *, QList<QgsFeature> >::iterator it = features.find( featureSymbol );
    if ( it == features.end() )
    {
      it = features.insert( featureSymbol, QList<QgsFeature>() );
    }
    it.value().append( fet );
  }
 
  //find out order
  QgsSymbolLevelOrder levels;
  QgsSymbolList symbols = mRenderer->symbols( mRenderContext );
  for ( int i = 0; i < symbols.count(); i++ )
  {
    QgsSymbol *sym = symbols[i];
    for ( int j = 0; j < sym->symbolLayerCount(); j++ )
    {
      int level = sym->symbolLayer( j )->renderingPass();
      if ( level < 0 || level >= 1000 ) // ignore invalid levels
        continue;
      QgsSymbolLevelItem item( sym, j );
      while ( level >= levels.count() ) // append new empty levels
        levels.append( QgsSymbolLevel() );
      levels[level].append( item );
    }
  }
 
  int nErrors = 0;
  int nTotalFeatures = 0;
 
  //export symbol layers and symbology
  for ( int l = 0; l < levels.count(); l++ )
  {
    QgsSymbolLevel &level = levels[l];
    for ( int i = 0; i < level.count(); i++ )
    {
      QgsSymbolLevelItem &item = level[i];
      QHash< QgsSymbol *, QList<QgsFeature> >::iterator levelIt = features.find( item.symbol() );
      if ( levelIt == features.end() )
      {
        ++nErrors;
        continue;
      }
 
      double mmsf = mmScaleFactor( mSymbologyScale, levelIt.key()->outputUnit(), mapUnits );
      double musf = mapUnitScaleFactor( mSymbologyScale, levelIt.key()->outputUnit(), mapUnits );
 
      int llayer = item.layer();
      QList<QgsFeature> &featureList = levelIt.value();
      QList<QgsFeature>::iterator featureIt = featureList.begin();
      for ( ; featureIt != featureList.end(); ++featureIt )
      {
        ++nTotalFeatures;
        gdal::ogr_feature_unique_ptr ogrFeature = createFeature( *featureIt );
        if ( !ogrFeature )
        {
          ++nErrors;
          continue;
        }
 
        QString styleString = levelIt.key()->symbolLayer( llayer )->ogrFeatureStyle( mmsf, musf );
        if ( !styleString.isEmpty() )
        {
          OGR_F_SetStyleString( ogrFeature.get(), styleString.toLocal8Bit().constData() );
          if ( !writeFeature( mLayer, ogrFeature.get() ) )
          {
            ++nErrors;
          }
        }
      }
    }
  }
 
  stopRender();
 
  if ( nErrors > 0 && errorMessage )
  {
    *errorMessage += QObject::tr( "\nOnly %1 of %2 features written." ).arg( nTotalFeatures - nErrors ).arg( nTotalFeatures );
  }
 
  return ( nErrors > 0 ) ? QgsVectorFileWriter::ErrFeatureWriteFailed : QgsVectorFileWriter::NoError;
}
 
double QgsVectorFileWriter::mmScaleFactor( double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits )
{
  if ( symbolUnits == Qgis::RenderUnit::Millimeters )
  {
    return 1.0;
  }
  else
  {
    //conversion factor map units -> mm
    if ( mapUnits == Qgis::DistanceUnit::Meters )
    {
      return 1000 / scale;
    }
  }
  return 1.0; //todo: map units
}
 
double QgsVectorFileWriter::mapUnitScaleFactor( double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits )
{
  if ( symbolUnits == Qgis::RenderUnit::MapUnits )
  {
    return 1.0;
  }
  else
  {
    if ( symbolUnits == Qgis::RenderUnit::Millimeters && mapUnits == Qgis::DistanceUnit::Meters )
    {
      return scale / 1000;
    }
  }
  return 1.0;
}
 
void QgsVectorFileWriter::startRender( QgsFeatureRenderer *sourceRenderer, const QgsFields &fields )
{
  mRenderer = createSymbologyRenderer( sourceRenderer );
  if ( !mRenderer )
  {
    return;
  }
 
  mRenderer->startRender( mRenderContext, fields );
}
 
void QgsVectorFileWriter::stopRender()
{
  if ( !mRenderer )
  {
    return;
  }
 
  mRenderer->stopRender( mRenderContext );
}
 
std::unique_ptr<QgsFeatureRenderer> QgsVectorFileWriter::createSymbologyRenderer( QgsFeatureRenderer *sourceRenderer ) const
{
  switch ( mSymbologyExport )
  {
    case Qgis::FeatureSymbologyExport::NoSymbology:
    {
      return nullptr;
    }
    case Qgis::FeatureSymbologyExport::PerFeature:
    case Qgis::FeatureSymbologyExport::PerSymbolLayer:
      break;
  }
 
  if ( !sourceRenderer )
  {
    return nullptr;
  }
 
  return std::unique_ptr< QgsFeatureRenderer >( sourceRenderer->clone() );
}
 
void QgsVectorFileWriter::addRendererAttributes( QgsFeatureRenderer *renderer, QgsRenderContext &context, const QgsFields &fields, QgsAttributeList &attList )
{
  if ( renderer )
  {
    const QSet<QString> rendererAttributes = renderer->usedAttributes( context );
    for ( const QString &attr : rendererAttributes )
    {
      int index = fields.lookupField( attr );
      if ( index != -1 )
      {
        attList.append( index );
      }
    }
  }
}
 
QStringList QgsVectorFileWriter::concatenateOptions( const QMap<QString, QgsVectorFileWriter::Option *> &options )
{
  QStringList list;
  QMap<QString, QgsVectorFileWriter::Option *>::ConstIterator it;
 
  for ( it = options.constBegin(); it != options.constEnd(); ++it )
  {
    QgsVectorFileWriter::Option *option = it.value();
    switch ( option->type )
    {
      case QgsVectorFileWriter::Int:
      {
        QgsVectorFileWriter::IntOption *opt = dynamic_cast<QgsVectorFileWriter::IntOption *>( option );
        if ( opt )
        {
          list.append( u"%1=%2"_s.arg( it.key() ).arg( opt->defaultValue ) );
        }
        break;
      }
 
      case QgsVectorFileWriter::Set:
      {
        QgsVectorFileWriter::SetOption *opt = dynamic_cast<QgsVectorFileWriter::SetOption *>( option );
        if ( opt && !opt->defaultValue.isEmpty() )
        {
          list.append( u"%1=%2"_s.arg( it.key(), opt->defaultValue ) );
        }
        break;
      }
 
      case QgsVectorFileWriter::String:
      {
        QgsVectorFileWriter::StringOption *opt = dynamic_cast<QgsVectorFileWriter::StringOption *>( option );
        if ( opt && !opt->defaultValue.isNull() )
        {
          list.append( u"%1=%2"_s.arg( it.key(), opt->defaultValue ) );
        }
        break;
      }
 
      case QgsVectorFileWriter::Hidden:
        QgsVectorFileWriter::HiddenOption *opt = dynamic_cast<QgsVectorFileWriter::HiddenOption *>( option );
        if ( opt && !opt->mValue.isEmpty() )
        {
          list.append( u"%1=%2"_s.arg( it.key(), opt->mValue ) );
        }
        break;
    }
  }
 
  return list;
}
 
QgsVectorFileWriter::EditionCapabilities QgsVectorFileWriter::editionCapabilities( const QString &datasetName )
{
  OGRSFDriverH hDriver = nullptr;
  gdal::ogr_datasource_unique_ptr hDS( OGROpen( datasetName.toUtf8().constData(), TRUE, &hDriver ) );
  if ( !hDS )
    return QgsVectorFileWriter::EditionCapabilities();
  const QString drvName = GDALGetDescription( hDriver );
  QgsVectorFileWriter::EditionCapabilities caps = QgsVectorFileWriter::EditionCapabilities();
  if ( OGR_DS_TestCapability( hDS.get(), ODsCCreateLayer ) )
  {
    // Shapefile driver returns True for a "foo.shp" dataset name,
    // creating "bar.shp" new layer, but this would be a bit confusing
    // for the user, so pretent that it does not support that
    if ( !( drvName == "ESRI Shapefile"_L1 && QFile::exists( datasetName ) ) )
      caps |= CanAddNewLayer;
  }
  if ( OGR_DS_TestCapability( hDS.get(), ODsCDeleteLayer ) )
  {
    caps |= CanDeleteLayer;
  }
  int layer_count = OGR_DS_GetLayerCount( hDS.get() );
  if ( layer_count )
  {
    OGRLayerH hLayer = OGR_DS_GetLayer( hDS.get(), 0 );
    if ( hLayer )
    {
      if ( OGR_L_TestCapability( hLayer, OLCSequentialWrite ) )
      {
        caps |= CanAppendToExistingLayer;
        if ( OGR_L_TestCapability( hLayer, OLCCreateField ) )
        {
          caps |= CanAddNewFieldsToExistingLayer;
        }
      }
    }
  }
  return caps;
}
 
bool QgsVectorFileWriter::targetLayerExists( const QString &datasetName, const QString &layerNameIn )
{
  OGRSFDriverH hDriver = nullptr;
  gdal::ogr_datasource_unique_ptr hDS( OGROpen( datasetName.toUtf8().constData(), TRUE, &hDriver ) );
  if ( !hDS )
    return false;
 
  QString layerName( layerNameIn );
  if ( layerName.isEmpty() )
    layerName = QFileInfo( datasetName ).baseName();
 
  return OGR_DS_GetLayerByName( hDS.get(), layerName.toUtf8().constData() );
}
 
 
bool QgsVectorFileWriter::areThereNewFieldsToCreate( const QString &datasetName, const QString &layerName, QgsVectorLayer *layer, const QgsAttributeList &attributes )
{
  OGRSFDriverH hDriver = nullptr;
  gdal::ogr_datasource_unique_ptr hDS( OGROpen( datasetName.toUtf8().constData(), TRUE, &hDriver ) );
  if ( !hDS )
    return false;
  OGRLayerH hLayer = OGR_DS_GetLayerByName( hDS.get(), layerName.toUtf8().constData() );
  if ( !hLayer )
  {
    return false;
  }
  bool ret = false;
  OGRFeatureDefnH defn = OGR_L_GetLayerDefn( hLayer );
  const auto constAttributes = attributes;
  for ( int idx : constAttributes )
  {
    QgsField fld = layer->fields().at( idx );
    if ( OGR_FD_GetFieldIndex( defn, fld.name().toUtf8().constData() ) < 0 )
    {
      ret = true;
      break;
    }
  }
  return ret;
}