QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsvectordataprovider.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsvectordataprovider.cpp - DataProvider Interface for vector layers
3 --------------------------------------
4 Date : 26-Oct-2004
5 Copyright : (C) 2004 by Marco Hugentobler
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include <QTextCodec>
17
18#include <limits>
19
21#include "qgscircularstring.h"
22#include "qgscompoundcurve.h"
23#include "qgsfeature.h"
24#include "qgsfeatureiterator.h"
25#include "qgsfeaturerequest.h"
26#include "qgsfeedback.h"
27#include "qgsfields.h"
28#include "qgsgeometry.h"
30#include "qgsgeometryfactory.h"
31#include "qgslogger.h"
32#include "qgsmessagelog.h"
34#include "qgsthreadingutils.h"
35#include <mutex>
37
40 : QgsDataProvider( uri, options, flags )
41 , mTemporalCapabilities( std::make_unique< QgsVectorDataProviderTemporalCapabilities >() )
42 , mElevationProperties( std::make_unique< QgsDataProviderElevationProperties >() )
43{
44}
45
47{
49
50 return QStringLiteral( "Generic vector file" );
51}
52
54{
56
57 QgsFeature f;
58 QgsFeatureRequest request;
59 request.setNoAttributes();
61 request.setLimit( 1 );
62 if ( getFeatures( request ).nextFeature( f ) )
63 return false;
64 else
65 return true;
66}
67
74
81
91
98
105
112
114{
116
117 return QString();
118}
119
121{
123
124 Q_UNUSED( flist )
125 Q_UNUSED( flags )
126 return false;
127}
128
130{
132
133 return mErrors.isEmpty() ? QString() : mErrors.last();
134}
135
137{
139
140 Q_UNUSED( ids )
141 return false;
142}
143
145{
147
149 return false;
150
151 QgsFeatureIds toDelete;
153 QgsFeature f;
154 while ( it.nextFeature( f ) )
155 toDelete << f.id();
156
157 return deleteFeatures( toDelete );
158}
159
160bool QgsVectorDataProvider::addAttributes( const QList<QgsField> &attributes )
161{
163
164 Q_UNUSED( attributes )
165 return false;
166}
167
169{
171
172 Q_UNUSED( attributes )
173 return false;
174}
175
177{
179
180 Q_UNUSED( renamedAttributes )
181 return false;
182}
183
185{
187
188 Q_UNUSED( attr_map )
189 return false;
190}
191
192QVariant QgsVectorDataProvider::defaultValue( int fieldId ) const
193{
195
196 Q_UNUSED( fieldId )
197 return QVariant();
198}
199
200QString QgsVectorDataProvider::defaultValueClause( int fieldIndex ) const
201{
203
204 Q_UNUSED( fieldIndex )
205 return QString();
206}
207
209{
211
212 const QgsFields f = fields();
213 if ( fieldIndex < 0 || fieldIndex >= f.count() )
215
216 return f.at( fieldIndex ).constraints().constraints();
217}
218
220{
222
223 return false;
224}
225
227{
229
230 Q_UNUSED( geometry_map )
231 return false;
232}
233
235 const QgsGeometryMap &geometry_map )
236{
238
240 return false;
241
242 bool result = true;
243 result = result && changeAttributeValues( attr_map );
244 result = result && changeGeometryValues( geometry_map );
245 return result;
246}
247
254
256{
258
259 Q_UNUSED( field )
260 return true;
261}
262
269
271{
273
274 // Use UTF-8 if no encoding is specified
275 if ( e.isEmpty() )
276 {
277 mEncoding = QTextCodec::codecForName( "UTF-8" );
278 }
279 else
280 {
281 mEncoding = QTextCodec::codecForName( e.toLocal8Bit().constData() );
282 }
283 if ( !mEncoding && e != QLatin1String( "System" ) )
284 {
285 if ( !e.isEmpty() )
286 {
287 // can we use the OGR proxy codec?
288 if ( QgsOgrProxyTextCodec::supportedCodecs().contains( e, Qt::CaseInsensitive ) )
289 {
290 //from the Qt docs (https://doc.qt.io/qt-5/qtextcodec.html#QTextCodec-1)
291 // "The QTextCodec should always be constructed on the heap (i.e. with new).
292 // Qt takes ownership and will delete it when the application terminates."
293 mEncoding = new QgsOgrProxyTextCodec( e.toLocal8Bit() );
294 }
295 else
296 {
297 QgsMessageLog::logMessage( tr( "Codec %1 not found. Falling back to system locale" ).arg( e ) );
298 mEncoding = QTextCodec::codecForName( "System" );
299 }
300 }
301 }
302
303 if ( !mEncoding )
304 mEncoding = QTextCodec::codecForLocale();
305
306 Q_ASSERT( mEncoding );
307}
308
310{
312
313 if ( mEncoding )
314 {
315 return mEncoding->name();
316 }
317
318 return QString();
319}
320
322{
324
325 QStringList abilitiesList;
326
328
330 {
331 abilitiesList += tr( "Add Features" );
332 }
333
335 {
336 abilitiesList += tr( "Delete Features" );
337 }
338
340 {
341 abilitiesList += tr( "Change Attribute Values" );
342 }
343
345 {
346 abilitiesList += tr( "Add Attributes" );
347 }
348
350 {
351 abilitiesList += tr( "Delete Attributes" );
352 }
353
355 {
356 abilitiesList += tr( "Rename Attributes" );
357 }
358
360 {
361 // TODO: Tighten up this test. See QgsOgrProvider for details.
362 abilitiesList += tr( "Create Spatial Index" );
363 }
364
366 {
367 abilitiesList += tr( "Create Attribute Indexes" );
368 }
369
371 {
372 abilitiesList += tr( "Fast Access to Features at ID" );
373 }
374
376 {
377 abilitiesList += tr( "Change Geometries" );
378 }
379
381 {
382 abilitiesList += tr( "Presimplify Geometries" );
383 }
384
386 {
387 abilitiesList += tr( "Presimplify Geometries with Validity Check" );
388 }
389
391 {
392 abilitiesList += tr( "Simultaneous Geometry and Attribute Updates" );
393 }
394
396 {
397 abilitiesList += tr( "Transactions" );
398 }
399
401 {
402 abilitiesList += tr( "Curved Geometries" );
403 }
404
406 {
407 abilitiesList += tr( "Feature Symbology" );
408 }
409
410 return abilitiesList.join( QLatin1String( ", " ) );
411}
412
417
418int QgsVectorDataProvider::fieldNameIndex( const QString &fieldName ) const
419{
421
422 return fields().lookupField( fieldName );
423}
424
425QMap<QString, int> QgsVectorDataProvider::fieldNameMap() const
426{
428
429 QMap<QString, int> resultMap;
430
431 const QgsFields fieldsCopy = fields();
432 for ( int i = 0; i < fieldsCopy.count(); ++i )
433 {
434 resultMap.insert( fieldsCopy.at( i ).name(), i );
435 }
436
437 return resultMap;
438}
439
446
453
454QList<QgsVectorDataProvider::NativeType> QgsVectorDataProvider::nativeTypes() const
455{
457
458 return mNativeTypes;
459}
460
467
469{
471
472 QgsDebugMsgLevel( QStringLiteral( "field name = %1 type = %2 length = %3 precision = %4" )
473 .arg( field.name(),
474 QVariant::typeToName( field.type() ) )
475 .arg( field.length() )
476 .arg( field.precision() ), 2 );
477
478 for ( const NativeType &nativeType : mNativeTypes )
479 {
480 QgsDebugMsgLevel( QStringLiteral( "native field type = %1 min length = %2 max length = %3 min precision = %4 max precision = %5" )
481 .arg( QVariant::typeToName( nativeType.mType ) )
482 .arg( nativeType.mMinLen )
483 .arg( nativeType.mMaxLen )
484 .arg( nativeType.mMinPrec )
485 .arg( nativeType.mMaxPrec ), 2 );
486
487 if ( field.type() != nativeType.mType )
488 continue;
489
490 if ( field.length() > 0 )
491 {
492 // source length limited
493 if ( ( nativeType.mMinLen > 0 && field.length() < nativeType.mMinLen ) ||
494 ( nativeType.mMaxLen > 0 && field.length() > nativeType.mMaxLen ) )
495 {
496 // source length exceeds destination limits
497 continue;
498 }
499 }
500
501 if ( field.precision() > 0 )
502 {
503 // source precision limited
504 if ( ( nativeType.mMinPrec > 0 && field.precision() < nativeType.mMinPrec ) ||
505 ( nativeType.mMaxPrec > 0 && field.precision() > nativeType.mMaxPrec ) )
506 {
507 // source precision exceeds destination limits
508 continue;
509 }
510 }
511
512 QgsDebugMsgLevel( QStringLiteral( "native type matches" ), 3 );
513 return true;
514 }
515
516 QgsDebugError( QStringLiteral( "no sufficient native type found" ) );
517 return false;
518}
519
520QVariant QgsVectorDataProvider::minimumValue( int index ) const
521{
523
524 if ( index < 0 || index >= fields().count() )
525 {
526 QgsDebugError( "Warning: access requested to invalid field index: " + QString::number( index ) );
527 return QVariant();
528 }
529
531
532 if ( !mCacheMinValues.contains( index ) )
533 return QVariant();
534
535 return mCacheMinValues[index];
536}
537
538QVariant QgsVectorDataProvider::maximumValue( int index ) const
539{
541
542 if ( index < 0 || index >= fields().count() )
543 {
544 QgsDebugError( "Warning: access requested to invalid field index: " + QString::number( index ) );
545 return QVariant();
546 }
547
549
550 if ( !mCacheMaxValues.contains( index ) )
551 return QVariant();
552
553 return mCacheMaxValues[index];
554}
555
556QStringList QgsVectorDataProvider::uniqueStringsMatching( int index, const QString &substring, int limit, QgsFeedback *feedback ) const
557{
559
560 QStringList results;
561
562 // Safety belt
563 if ( index < 0 || index >= fields().count() )
564 return results;
565
566 QgsFeature f;
567 QgsAttributeList keys;
568 keys.append( index );
569
570 QgsFeatureRequest request;
571 request.setSubsetOfAttributes( keys );
573 const QString fieldName = fields().at( index ).name();
574 request.setFilterExpression( QStringLiteral( "\"%1\" ILIKE '%%2%'" ).arg( fieldName, substring ) );
575 QgsFeatureIterator fi = getFeatures( request );
576
577 QSet<QString> set;
578
579 while ( fi.nextFeature( f ) )
580 {
581 const QString value = f.attribute( index ).toString();
582 if ( !set.contains( value ) )
583 {
584 results.append( value );
585 set.insert( value );
586 }
587
588 if ( ( limit >= 0 && results.size() >= limit ) || ( feedback && feedback->isCanceled() ) )
589 break;
590 }
591 return results;
592}
593
595 const QgsAggregateCalculator::AggregateParameters &parameters, QgsExpressionContext *context, bool &ok, QgsFeatureIds *fids ) const
596{
597 // non fatal for now -- the "aggregate" functions are not thread safe and call this
599
600 //base implementation does nothing
601 Q_UNUSED( aggregate )
602 Q_UNUSED( index )
603 Q_UNUSED( parameters )
604 Q_UNUSED( context )
605 Q_UNUSED( fids )
606
607 ok = false;
608 return QVariant();
609}
610
612{
614
615 mCacheMinMaxDirty = true;
616 mCacheMinValues.clear();
617 mCacheMaxValues.clear();
618}
619
621{
623
624 if ( !mCacheMinMaxDirty )
625 return;
626
627 const QgsFields flds = fields();
628 for ( int i = 0; i < flds.count(); ++i )
629 {
630 if ( flds.at( i ).type() == QMetaType::Type::Int )
631 {
632 mCacheMinValues[i] = QVariant( std::numeric_limits<int>::max() );
633 mCacheMaxValues[i] = QVariant( std::numeric_limits<int>::lowest() );
634 }
635 else if ( flds.at( i ).type() == QMetaType::Type::LongLong )
636 {
637 mCacheMinValues[i] = QVariant( std::numeric_limits<qlonglong>::max() );
638 mCacheMaxValues[i] = QVariant( std::numeric_limits<qlonglong>::lowest() );
639 }
640 else if ( flds.at( i ).type() == QMetaType::Type::Double )
641 {
642 mCacheMinValues[i] = QVariant( std::numeric_limits<double>::max() );
643 mCacheMaxValues[i] = QVariant( std::numeric_limits<double>::lowest() );
644
645 }
646 else
647 {
648 mCacheMinValues[i] = QVariant();
649 mCacheMaxValues[i] = QVariant();
650 }
651 }
652
653 QgsFeature f;
654 const QgsAttributeList keys = mCacheMinValues.keys();
655 QgsFeatureIterator fi = getFeatures( QgsFeatureRequest().setSubsetOfAttributes( keys )
657
658 while ( fi.nextFeature( f ) )
659 {
660 const QgsAttributes attrs = f.attributes();
661 for ( const int attributeIndex : keys )
662 {
663 const QVariant &varValue = attrs.at( attributeIndex );
664
665 if ( QgsVariantUtils::isNull( varValue ) )
666 continue;
667
668 switch ( flds.at( attributeIndex ).type() )
669 {
670 case QMetaType::Type::Int:
671 {
672 const int value = varValue.toInt();
673 if ( value < mCacheMinValues[ attributeIndex ].toInt() )
674 mCacheMinValues[ attributeIndex ] = value;
675 if ( value > mCacheMaxValues[ attributeIndex ].toInt() )
676 mCacheMaxValues[ attributeIndex ] = value;
677 break;
678 }
679 case QMetaType::Type::LongLong:
680 {
681 const qlonglong value = varValue.toLongLong();
682 if ( value < mCacheMinValues[ attributeIndex ].toLongLong() )
683 mCacheMinValues[ attributeIndex ] = value;
684 if ( value > mCacheMaxValues[ attributeIndex ].toLongLong() )
685 mCacheMaxValues[ attributeIndex ] = value;
686 break;
687 }
688 case QMetaType::Type::Double:
689 {
690 const double value = varValue.toDouble();
691 if ( value < mCacheMinValues[ attributeIndex ].toDouble() )
692 mCacheMinValues[attributeIndex ] = value;
693 if ( value > mCacheMaxValues[ attributeIndex ].toDouble() )
694 mCacheMaxValues[ attributeIndex ] = value;
695 break;
696 }
697 case QMetaType::Type::QDateTime:
698 {
699 const QDateTime value = varValue.toDateTime();
700 if ( value < mCacheMinValues[ attributeIndex ].toDateTime() || !mCacheMinValues[ attributeIndex ].isValid() )
701 mCacheMinValues[attributeIndex ] = value;
702 if ( value > mCacheMaxValues[ attributeIndex ].toDateTime() || !mCacheMaxValues[ attributeIndex ].isValid() )
703 mCacheMaxValues[ attributeIndex ] = value;
704 break;
705 }
706 case QMetaType::Type::QDate:
707 {
708 const QDate value = varValue.toDate();
709 if ( value < mCacheMinValues[ attributeIndex ].toDate() || !mCacheMinValues[ attributeIndex ].isValid() )
710 mCacheMinValues[attributeIndex ] = value;
711 if ( value > mCacheMaxValues[ attributeIndex ].toDate() || !mCacheMaxValues[ attributeIndex ].isValid() )
712 mCacheMaxValues[ attributeIndex ] = value;
713 break;
714 }
715 case QMetaType::Type::QTime:
716 {
717 const QTime value = varValue.toTime();
718 if ( value < mCacheMinValues[ attributeIndex ].toTime() || !mCacheMinValues[ attributeIndex ].isValid() )
719 mCacheMinValues[attributeIndex ] = value;
720 if ( value > mCacheMaxValues[ attributeIndex ].toTime() || !mCacheMaxValues[ attributeIndex ].isValid() )
721 mCacheMaxValues[ attributeIndex ] = value;
722 break;
723 }
724 default:
725 {
726 const QString value = varValue.toString();
727 if ( QgsVariantUtils::isNull( mCacheMinValues[ attributeIndex ] ) || value < mCacheMinValues[attributeIndex ].toString() )
728 {
729 mCacheMinValues[attributeIndex] = value;
730 }
731 if ( QgsVariantUtils::isNull( mCacheMaxValues[attributeIndex] ) || value > mCacheMaxValues[attributeIndex].toString() )
732 {
733 mCacheMaxValues[attributeIndex] = value;
734 }
735 break;
736 }
737 }
738 }
739 }
740
741 mCacheMinMaxDirty = false;
742}
743
744QVariant QgsVectorDataProvider::convertValue( QMetaType::Type type, const QString &value )
745{
746 QVariant v( value );
747
748 if ( !v.convert( type ) || value.isNull() )
750
751 return v;
752}
753
754QVariant QgsVectorDataProvider::convertValue( QVariant::Type type, const QString &value )
755{
757}
758
765
766static bool _compareEncodings( const QString &s1, const QString &s2 )
767{
768 return s1.toLower() < s2.toLower();
769}
770
771static bool _removeDuplicateEncodings( const QString &s1, const QString &s2 )
772{
773 return s1.compare( s2, Qt::CaseInsensitive ) == 0;
774}
775
777{
778 static std::once_flag initialized;
779 std::call_once( initialized, [ = ]
780 {
781 const auto codecs { QTextCodec::availableCodecs() };
782 for ( const QByteArray &codec : codecs )
783 {
784 sEncodings << codec;
785 }
786#if 0
787 smEncodings << "BIG5";
788 smEncodings << "BIG5-HKSCS";
789 smEncodings << "EUCJP";
790 smEncodings << "EUCKR";
791 smEncodings << "GB2312";
792 smEncodings << "GBK";
793 smEncodings << "GB18030";
794 smEncodings << "JIS7";
795 smEncodings << "SHIFT-JIS";
796 smEncodings << "TSCII";
797 smEncodings << "UTF-8";
798 smEncodings << "UTF-16";
799 smEncodings << "KOI8-R";
800 smEncodings << "KOI8-U";
801 smEncodings << "ISO8859-1";
802 smEncodings << "ISO8859-2";
803 smEncodings << "ISO8859-3";
804 smEncodings << "ISO8859-4";
805 smEncodings << "ISO8859-5";
806 smEncodings << "ISO8859-6";
807 smEncodings << "ISO8859-7";
808 smEncodings << "ISO8859-8";
809 smEncodings << "ISO8859-8-I";
810 smEncodings << "ISO8859-9";
811 smEncodings << "ISO8859-10";
812 smEncodings << "ISO8859-11";
813 smEncodings << "ISO8859-12";
814 smEncodings << "ISO8859-13";
815 smEncodings << "ISO8859-14";
816 smEncodings << "ISO8859-15";
817 smEncodings << "IBM 850";
818 smEncodings << "IBM 866";
819 smEncodings << "CP874";
820 smEncodings << "CP1250";
821 smEncodings << "CP1251";
822 smEncodings << "CP1252";
823 smEncodings << "CP1253";
824 smEncodings << "CP1254";
825 smEncodings << "CP1255";
826 smEncodings << "CP1256";
827 smEncodings << "CP1257";
828 smEncodings << "CP1258";
829 smEncodings << "Apple Roman";
830 smEncodings << "TIS-620";
831 smEncodings << "System";
832#endif
833
834 // Do case-insensitive sorting of encodings then remove duplicates
835 std::sort( sEncodings.begin(), sEncodings.end(), _compareEncodings );
836 const auto last = std::unique( sEncodings.begin(), sEncodings.end(), _removeDuplicateEncodings );
837 sEncodings.erase( last, sEncodings.end() );
838
839 } );
840
841 return sEncodings;
842}
843
845{
847
848 mErrors.clear();
849}
850
852{
854
855 return !mErrors.isEmpty();
856}
857
859{
861
862 return mErrors;
863}
864
866{
868
869 return nullptr;
870}
871
873{
875
876 return nullptr;
877}
878
879void QgsVectorDataProvider::pushError( const QString &msg ) const
880{
882
883 QgsDebugError( msg );
884 mErrors << msg;
885 emit raiseError( msg );
886}
887
888QSet<QgsMapLayerDependency> QgsVectorDataProvider::dependencies() const
889{
891
892 return QSet<QgsMapLayerDependency>();
893}
894
903
904void QgsVectorDataProvider::setNativeTypes( const QList<NativeType> &nativeTypes )
905{
907
908 mNativeTypes = nativeTypes;
909}
910
912{
913 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
915
916 return mEncoding;
917}
918
920{
921 if ( geometry.isNull() )
922 {
923 return QgsGeometry();
924 }
925
926 const QgsAbstractGeometry *convertedGeometry = geometry.constGet();
927 if ( !convertedGeometry )
928 {
929 return QgsGeometry();
930 }
931
932
933 //geom is already in the provider geometry type
934 if ( convertedGeometry->wkbType() == providerGeometryType )
935 {
936 return QgsGeometry();
937 }
938
939 std::unique_ptr< QgsAbstractGeometry > outputGeom;
940
941 //convert compoundcurve to circularstring (possible if compoundcurve consists of one circular string)
942 if ( QgsWkbTypes::flatType( providerGeometryType ) == Qgis::WkbType::CircularString )
943 {
944 QgsCompoundCurve *compoundCurve = qgsgeometry_cast<QgsCompoundCurve *>( convertedGeometry );
945 if ( compoundCurve )
946 {
947 if ( compoundCurve->nCurves() == 1 )
948 {
949 const QgsCircularString *circularString = qgsgeometry_cast<const QgsCircularString *>( compoundCurve->curveAt( 0 ) );
950 if ( circularString )
951 {
952 outputGeom.reset( circularString->clone() );
953 }
954 }
955 }
956 }
957
958 //convert to curved type if necessary
959 if ( !QgsWkbTypes::isCurvedType( convertedGeometry->wkbType() ) && QgsWkbTypes::isCurvedType( providerGeometryType ) )
960 {
961 QgsAbstractGeometry *curveGeom = outputGeom ? outputGeom->toCurveType() : convertedGeometry->toCurveType();
962 if ( curveGeom )
963 {
964 outputGeom.reset( curveGeom );
965 }
966 }
967
968 //convert to linear type from curved type
969 if ( QgsWkbTypes::isCurvedType( convertedGeometry->wkbType() ) && !QgsWkbTypes::isCurvedType( providerGeometryType ) )
970 {
971 QgsAbstractGeometry *segmentizedGeom = outputGeom ? outputGeom->segmentize() : convertedGeometry->segmentize();
972 if ( segmentizedGeom )
973 {
974 outputGeom.reset( segmentizedGeom );
975 }
976 }
977
978 //convert to multitype if necessary
979 if ( QgsWkbTypes::isMultiType( providerGeometryType ) && !QgsWkbTypes::isMultiType( convertedGeometry->wkbType() ) )
980 {
981 std::unique_ptr< QgsAbstractGeometry > collGeom( QgsGeometryFactory::geomFromWkbType( providerGeometryType ) );
982 QgsGeometryCollection *geomCollection = qgsgeometry_cast<QgsGeometryCollection *>( collGeom.get() );
983 if ( geomCollection )
984 {
985 if ( geomCollection->addGeometry( outputGeom ? outputGeom->clone() : convertedGeometry->clone() ) )
986 {
987 outputGeom.reset( collGeom.release() );
988 }
989 }
990 }
991
992 //convert to single type if there's a single part of compatible type
993 if ( !QgsWkbTypes::isMultiType( providerGeometryType ) && QgsWkbTypes::isMultiType( convertedGeometry->wkbType() ) )
994 {
995 const QgsGeometryCollection *collection = qgsgeometry_cast<const QgsGeometryCollection *>( convertedGeometry );
996 if ( collection )
997 {
998 if ( collection->numGeometries() == 1 )
999 {
1000 const QgsAbstractGeometry *firstGeom = collection->geometryN( 0 );
1001 if ( firstGeom && firstGeom->wkbType() == providerGeometryType )
1002 {
1003 outputGeom.reset( firstGeom->clone() );
1004 }
1005 }
1006 }
1007 }
1008
1009 //set z/m types
1010 if ( QgsWkbTypes::hasZ( providerGeometryType ) )
1011 {
1012 if ( !outputGeom )
1013 {
1014 outputGeom.reset( convertedGeometry->clone() );
1015 }
1016 outputGeom->addZValue();
1017 }
1018
1019 if ( QgsWkbTypes::hasM( providerGeometryType ) )
1020 {
1021 if ( !outputGeom )
1022 {
1023 outputGeom.reset( convertedGeometry->clone() );
1024 }
1025 outputGeom->addMValue();
1026 }
1027
1028 if ( outputGeom )
1029 {
1030 return QgsGeometry( outputGeom.release() );
1031 }
1032
1033 return QgsGeometry();
1034}
1035
1037{
1039
1040 return false;
1041}
1042
1043QStringList QgsVectorDataProvider::sEncodings;
1044
1045QList<QgsRelation> QgsVectorDataProvider::discoverRelations( const QgsVectorLayer *, const QList<QgsVectorLayer *> & ) const
1046{
1048
1049 return QList<QgsRelation>();
1050}
1051
1057
1064
1071
1078
1080{
1082
1083 return mElevationProperties.get();
1084}
@ SelectAtId
Fast access to features using their ID.
@ ChangeFeatures
Supports joint updates for attributes and geometry. Providers supporting this should still define Cha...
@ SimplifyGeometries
Supports simplification of geometries on provider side according to a distance tolerance.
@ AddFeatures
Allows adding features.
@ SimplifyGeometriesWithTopologicalValidation
Supports topological simplification of geometries on provider side according to a distance tolerance.
@ CreateAttributeIndex
Can create indexes on provider's fields.
@ CircularGeometries
Supports circular geometry types (circularstring, compoundcurve, curvepolygon)
@ NoCapabilities
Provider has no capabilities.
@ ChangeGeometries
Allows modifications of geometries.
@ AddAttributes
Allows addition of new attributes (fields)
@ CreateSpatialIndex
Allows creation of spatial index.
@ RenameAttributes
Supports renaming attributes (fields)
@ DeleteFeatures
Allows deletion of features.
@ TransactionSupport
Supports transactions.
@ DeleteAttributes
Allows deletion of attributes (fields)
@ ChangeAttributeValues
Allows modification of attribute values.
@ FeatureSymbology
Provider is able retrieve embedded symbology associated with individual features.
QFlags< VectorLayerTypeFlag > VectorLayerTypeFlags
Vector layer type flags.
Definition qgis.h:395
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
QFlags< DataProviderReadFlag > DataProviderReadFlags
Flags which control data provider construction.
Definition qgis.h:450
FeatureAvailability
Possible return value for QgsFeatureSource::hasFeatures() to determine if a source is empty.
Definition qgis.h:541
@ FeaturesAvailable
There is at least one feature available in this source.
@ NoFeaturesAvailable
There are certainly no features available in this source.
QFlags< VectorProviderCapability > VectorProviderCapabilities
Vector data provider capabilities.
Definition qgis.h:500
Aggregate
Available aggregates to calculate.
Definition qgis.h:5400
@ SqlQuery
SQL query layer.
QFlags< VectorDataProviderAttributeEditCapability > VectorDataProviderAttributeEditCapabilities
Attribute editing capabilities which may be supported by vector data providers.
Definition qgis.h:566
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:256
@ CircularString
CircularString.
Abstract base class for all geometries.
virtual bool addZValue(double zValue=0)=0
Adds a z-dimension to the geometry, initialized to a preset value.
virtual QgsAbstractGeometry * segmentize(double tolerance=M_PI/180., SegmentationToleranceType toleranceType=MaximumAngle) const
Returns a version of the geometry without curves.
virtual QgsAbstractGeometry * toCurveType() const =0
Returns the geometry converted to the more generic curve type.
Qgis::WkbType wkbType() const
Returns the WKB type of the geometry.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
Abstract base class - its implementations define different approaches to the labeling of a vector lay...
A vector of attributes.
A 3-dimensional box composed of x, y, z coordinates.
Definition qgsbox3d.h:43
Circular string geometry type.
QgsCircularString * clone() const override
Clones the geometry by performing a deep copy.
Compound curve geometry type.
int nCurves() const
Returns the number of curves in the geometry.
const QgsCurve * curveAt(int i) const
Returns the curve at the specified index.
This class represents a coordinate reference system (CRS).
Base class for handling elevation related properties for a data provider.
Abstract base class for spatial data provider implementations.
virtual Qgis::DataProviderFlags flags() const
Returns the generic data provider flags.
virtual QgsCoordinateReferenceSystem crs() const =0
Returns the coordinate system for the data source.
virtual QgsBox3D extent3D() const
Returns the 3D extent of the layer.
virtual QgsRectangle extent() const =0
Returns the extent of the layer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Abstract base class for all 2D vector feature renderers.
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setFlags(Qgis::FeatureRequestFlags flags)
Sets flags that affect how features will be fetched.
QgsFeatureRequest & setLimit(long long limit)
Set the maximum number of features to request.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
QgsFeatureRequest & setNoAttributes()
Set that no attributes will be fetched.
QFlags< Flag > Flags
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
QgsAttributes attributes
Definition qgsfeature.h:67
QgsFeatureId id
Definition qgsfeature.h:66
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
Constraint
Constraints which may be present on a field.
QFlags< Constraint > Constraints
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
QMetaType::Type type
Definition qgsfield.h:60
QString name
Definition qgsfield.h:62
int precision
Definition qgsfield.h:59
int length
Definition qgsfield.h:58
Container of fields for a vector layer.
Definition qgsfields.h:46
int count
Definition qgsfields.h:50
QgsAttributeList allAttributesList() const
Utility function to get list of attribute indexes.
QgsField at(int i) const
Returns the field at particular index (must be in range 0..N-1).
Q_INVOKABLE int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
virtual bool addGeometry(QgsAbstractGeometry *g)
Adds a geometry and takes ownership. Returns true in case of success.
int numGeometries() const
Returns the number of geometries within the collection.
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
static std::unique_ptr< QgsAbstractGeometry > geomFromWkbType(Qgis::WkbType t)
Returns empty geometry from wkb type.
A geometry is the spatial representation of a feature.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
A QTextCodec implementation which relies on OGR to do the text conversion.
static QStringList supportedCodecs()
Returns a list of supported text codecs.
A rectangle specified with double values.
This class allows including a set of layers in a database-side transaction, provided the layer data p...
static QMetaType::Type variantTypeToMetaType(QVariant::Type variantType)
Converts a QVariant::Type to a QMetaType::Type.
static bool isNull(const QVariant &variant, bool silenceNullWarnings=false)
Returns true if the specified variant should be considered a NULL value.
static QVariant createNullVariant(QMetaType::Type metaType)
Helper method to properly create a null QVariant from a metaType Returns the created QVariant.
Implementation of data provider temporal properties for QgsVectorDataProviders.
This is the base class for vector data providers.
void pushError(const QString &msg) const
Push a notification about errors that happened in this providers scope.
QgsRectangle sourceExtent() const override
Returns the extent of all geometries from the source.
virtual bool cancelReload()
Cancels the current reloading of data.
QString lastError() const override
Returns the most recent error encountered by the sink, e.g.
void setNativeTypes(const QList< QgsVectorDataProvider::NativeType > &nativeTypes)
Set the list of native types supported by this provider.
virtual QList< QgsRelation > discoverRelations(const QgsVectorLayer *target, const QList< QgsVectorLayer * > &layers) const
Discover the available relations with the given layers.
static QStringList availableEncodings()
Returns a list of available encodings.
virtual QString dataComment() const override
Returns a short comment for the data that this provider is providing access to (e....
virtual QVariant aggregate(Qgis::Aggregate aggregate, int index, const QgsAggregateCalculator::AggregateParameters &parameters, QgsExpressionContext *context, bool &ok, QgsFeatureIds *fids=nullptr) const
Calculates an aggregated value from the layer's features.
bool supportedType(const QgsField &field) const
check if provider supports type of field
virtual bool changeGeometryValues(const QgsGeometryMap &geometry_map)
Changes geometries of existing features.
virtual bool createSpatialIndex()
Creates a spatial index on the datasource (if supported by the provider type).
Q_DECL_DEPRECATED QgsAttrPalIndexNameHash palAttributeIndexNames() const
Returns list of indexes to names for QgsPalLabeling fix.
QgsCoordinateReferenceSystem sourceCrs() const override
Returns the coordinate reference system for features in the source.
virtual QgsFeatureRenderer * createRenderer(const QVariantMap &configuration=QVariantMap()) const
Creates a new vector layer feature renderer, using provider backend specific information.
virtual QString storageType() const
Returns the permanent storage type for this layer as a friendly name.
void clearMinMaxCache()
Invalidates the min/max cache.
virtual bool truncate()
Removes all features from the layer.
virtual QStringList uniqueStringsMatching(int index, const QString &substring, int limit=-1, QgsFeedback *feedback=nullptr) const
Returns unique string values of an attribute which contain a specified subset string.
void raiseError(const QString &msg) const
Signals an error in this provider.
QTextCodec * textEncoding() const
Gets this providers encoding.
QgsVectorDataProvider(const QString &uri=QString(), const QgsDataProvider::ProviderOptions &providerOptions=QgsDataProvider::ProviderOptions(), Qgis::DataProviderReadFlags flags=Qgis::DataProviderReadFlags())
Constructor for a vector data provider.
virtual bool isSqlQuery() const
Returns true if the layer is a query (SQL) layer.
void clearErrors()
Clear recorded errors.
QStringList errors() const
Gets recorded errors.
virtual bool empty() const
Returns true if the layer does not contain any feature.
virtual Q_INVOKABLE Qgis::VectorProviderCapabilities capabilities() const
Returns flags containing the supported capabilities.
QList< QgsVectorDataProvider::NativeType > nativeTypes() const
Returns the names of the supported types.
QgsBox3D sourceExtent3D() const override
Returns the 3D extent of all geometries from the source.
virtual QgsAttributeList pkAttributeIndexes() const
Returns list of indexes of fields that make up the primary key.
virtual void handlePostCloneOperations(QgsVectorDataProvider *source)
Handles any post-clone operations required after this vector data provider was cloned from the source...
QgsGeometry convertToProviderType(const QgsGeometry &geom) const
Converts the geometry to the provider type if possible / necessary.
virtual bool changeFeatures(const QgsChangedAttributesMap &attr_map, const QgsGeometryMap &geometry_map)
Changes attribute values and geometries of existing features.
virtual QSet< QgsMapLayerDependency > dependencies() const
Gets the list of layer ids on which this layer depends.
int fieldNameIndex(const QString &fieldName) const
Returns the index of a field name or -1 if the field does not exist.
virtual QString defaultValueClause(int fieldIndex) const
Returns any default value clauses which are present at the provider for a specified field index.
virtual void setEncoding(const QString &e)
Set encoding used for accessing data from layer.
virtual bool changeAttributeValues(const QgsChangedAttributesMap &attr_map)
Changes attribute values of existing features.
virtual bool deleteFeatures(const QgsFeatureIds &id)
Deletes one or more features from the provider.
virtual Qgis::VectorLayerTypeFlags vectorLayerTypeFlags() const
Returns the vector layer type flags.
QVariant maximumValue(int index) const override
Returns the maximum value of an attribute.
virtual bool createAttributeIndex(int field)
Create an attribute index on the datasource.
bool addFeatures(QgsFeatureList &flist, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a list of features to the sink.
QgsDataProviderElevationProperties * elevationProperties() override
Returns the provider's elevation properties.
QgsFields fields() const override=0
Returns the fields associated with this data provider.
QMap< QString, int > fieldNameMap() const
Returns a map where the key is the name of the field and the value is its index.
Qgis::WkbType wkbType() const override=0
Returns the geometry type which is returned by this layer.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const override=0
Query the provider for features specified in request.
virtual QgsAttributeList attributeIndexes() const
Returns list of indexes to fetch all attributes in nextFeature()
virtual bool addAttributes(const QList< QgsField > &attributes)
Adds new attributes to the provider.
QVariant minimumValue(int index) const override
Returns the minimum value of an attribute.
void fillMinMaxCache() const
Populates the cache of minimum and maximum attribute values.
QString encoding() const
Returns the encoding which is used for accessing data.
virtual QVariant defaultValue(int fieldIndex) const
Returns any literal default values which are present at the provider for a specified field index.
QgsFieldConstraints::Constraints fieldConstraints(int fieldIndex) const
Returns any constraints which are present at the provider for a specified field index.
virtual QgsTransaction * transaction() const
Returns the transaction this data provider is included in, if any.
virtual QgsAbstractVectorLayerLabeling * createLabeling(const QVariantMap &configuration=QVariantMap()) const
Creates labeling settings, using provider backend specific information.
static QVariant convertValue(QMetaType::Type type, const QString &value)
Convert value to type.
Qgis::FeatureAvailability hasFeatures() const override
Will always return FeatureAvailability::FeaturesAvailable or FeatureAvailability::NoFeaturesAvailable...
virtual bool renameAttributes(const QgsFieldNameMap &renamedAttributes)
Renames existing attributes.
virtual bool deleteAttributes(const QgsAttributeIds &attributes)
Deletes existing attributes from the provider.
virtual bool skipConstraintCheck(int fieldIndex, QgsFieldConstraints::Constraint constraint, const QVariant &value=QVariant()) const
Returns true if a constraint check should be skipped for a specified field (e.g., if the value return...
virtual Qgis::VectorDataProviderAttributeEditCapabilities attributeEditCapabilities() const
Returns the provider's supported attribute editing capabilities.
bool hasErrors() const
Provider has errors to report.
QgsVectorDataProviderTemporalCapabilities * temporalCapabilities() override
Returns the provider's temporal capabilities.
QString capabilitiesString() const
Returns the above in friendly format.
Represents a vector layer which manages a vector based data sets.
static bool isMultiType(Qgis::WkbType type)
Returns true if the WKB type is a multi type.
static bool hasZ(Qgis::WkbType type)
Tests whether a WKB type contains the z-dimension.
static bool hasM(Qgis::WkbType type)
Tests whether a WKB type contains m values.
static bool isCurvedType(Qgis::WkbType type)
Returns true if the WKB type is a curved type or can contain curved geometries.
static Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
QMap< int, QString > QgsFieldNameMap
QMap< QgsFeatureId, QgsGeometry > QgsGeometryMap
QMap< QgsFeatureId, QgsAttributeMap > QgsChangedAttributesMap
QList< QgsFeature > QgsFeatureList
QSet< QgsFeatureId > QgsFeatureIds
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
#define QgsDebugError(str)
Definition qgslogger.h:38
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS_NON_FATAL
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
QList< int > QgsAttributeList
QSet< int > QgsAttributeIds
QHash< int, QString > QgsAttrPalIndexNameHash
A bundle of parameters controlling aggregate calculation.
Setting options for creating vector data providers.