QGIS API Documentation  2.99.0-Master (585a4d3)
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
6  email : [email protected]
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 <cfloat> // for DBL_MAX
19 #include <climits>
20 #include <limits>
21 
22 #include "qgsvectordataprovider.h"
23 #include "qgscircularstring.h"
24 #include "qgscompoundcurve.h"
25 #include "qgsfeature.h"
26 #include "qgsfeatureiterator.h"
27 #include "qgsfeaturerequest.h"
28 #include "qgsfeedback.h"
29 #include "qgsfields.h"
30 #include "qgsgeometry.h"
31 #include "qgsgeometrycollection.h"
32 #include "qgsgeometryfactory.h"
33 #include "qgslogger.h"
34 #include "qgsmessagelog.h"
35 #include "qgssettings.h"
36 
38  : QgsDataProvider( uri )
39 {
40  QgsSettings settings;
41  setEncoding( settings.value( QStringLiteral( "UI/encoding" ), "System" ).toString() );
42 }
43 
45 {
46  return QStringLiteral( "Generic vector file" );
47 }
48 
50 {
51  return crs();
52 }
53 
55 {
56  return extent();
57 }
58 
60 {
61  return QString();
62 }
63 
65 {
66  Q_UNUSED( flist );
67  Q_UNUSED( flags );
68  return false;
69 }
70 
72 {
73  Q_UNUSED( ids );
74  return false;
75 }
76 
78 {
79  if ( !( capabilities() & DeleteFeatures ) )
80  return false;
81 
82  QgsFeatureIds toDelete;
84  QgsFeature f;
85  while ( it.nextFeature( f ) )
86  toDelete << f.id();
87 
88  return deleteFeatures( toDelete );
89 }
90 
91 bool QgsVectorDataProvider::addAttributes( const QList<QgsField> &attributes )
92 {
93  Q_UNUSED( attributes );
94  return false;
95 }
96 
98 {
99  Q_UNUSED( attributes );
100  return false;
101 }
102 
104 {
105  Q_UNUSED( renamedAttributes );
106  return false;
107 }
108 
110 {
111  Q_UNUSED( attr_map );
112  return false;
113 }
114 
115 QVariant QgsVectorDataProvider::defaultValue( int fieldId ) const
116 {
117  Q_UNUSED( fieldId );
118  return QVariant();
119 }
120 
121 QString QgsVectorDataProvider::defaultValueClause( int fieldIndex ) const
122 {
123  Q_UNUSED( fieldIndex );
124  return QString();
125 }
126 
127 QgsFieldConstraints::Constraints QgsVectorDataProvider::fieldConstraints( int fieldIndex ) const
128 {
129  QgsFields f = fields();
130  if ( fieldIndex < 0 || fieldIndex >= f.count() )
131  return nullptr;
132 
133  return f.at( fieldIndex ).constraints().constraints();
134 }
135 
137 {
138  return false;
139 }
140 
142 {
143  Q_UNUSED( geometry_map );
144  return false;
145 }
146 
148  const QgsGeometryMap &geometry_map )
149 {
151  return false;
152 
153  bool result = true;
154  result = result && changeAttributeValues( attr_map );
155  result = result && changeGeometryValues( geometry_map );
156  return result;
157 }
158 
160 {
161  return false;
162 }
163 
165 {
166  Q_UNUSED( field );
167  return true;
168 }
169 
170 QgsVectorDataProvider::Capabilities QgsVectorDataProvider::capabilities() const
171 {
173 }
174 
175 
176 void QgsVectorDataProvider::setEncoding( const QString &e )
177 {
178  mEncoding = QTextCodec::codecForName( e.toLocal8Bit().constData() );
179 
180  if ( !mEncoding && e != QLatin1String( "System" ) )
181  {
182  QgsMessageLog::logMessage( tr( "Codec %1 not found. Falling back to system locale" ).arg( e ) );
183  mEncoding = QTextCodec::codecForName( "System" );
184  }
185 
186  if ( !mEncoding )
187  mEncoding = QTextCodec::codecForLocale();
188 
189  Q_ASSERT( mEncoding );
190 }
191 
193 {
194  if ( mEncoding )
195  {
196  return mEncoding->name();
197  }
198 
199  return QLatin1String( "" );
200 }
201 
203 {
204  QStringList abilitiesList;
205 
206  int abilities = capabilities();
207 
208  if ( abilities & QgsVectorDataProvider::AddFeatures )
209  {
210  abilitiesList += tr( "Add Features" );
211  }
212 
213  if ( abilities & QgsVectorDataProvider::DeleteFeatures )
214  {
215  abilitiesList += tr( "Delete Features" );
216  }
217 
219  {
220  abilitiesList += tr( "Change Attribute Values" );
221  }
222 
223  if ( abilities & QgsVectorDataProvider::AddAttributes )
224  {
225  abilitiesList += tr( "Add Attributes" );
226  }
227 
228  if ( abilities & QgsVectorDataProvider::DeleteAttributes )
229  {
230  abilitiesList += tr( "Delete Attributes" );
231  }
232 
233  if ( abilities & QgsVectorDataProvider::RenameAttributes )
234  {
235  abilitiesList += tr( "Rename Attributes" );
236  }
237 
239  {
240  // TODO: Tighten up this test. See QgsOgrProvider for details.
241  abilitiesList += tr( "Create Spatial Index" );
242  }
243 
245  {
246  abilitiesList += tr( "Create Attribute Indexes" );
247  }
248 
249  if ( abilities & QgsVectorDataProvider::SelectAtId )
250  {
251  abilitiesList += tr( "Fast Access to Features at ID" );
252  }
253 
254  if ( abilities & QgsVectorDataProvider::ChangeGeometries )
255  {
256  abilitiesList += tr( "Change Geometries" );
257  }
258 
260  {
261  abilitiesList += tr( "Presimplify Geometries" );
262  }
263 
265  {
266  abilitiesList += tr( "Presimplify Geometries with Validity Check" );
267  }
268 
269  if ( abilities & QgsVectorDataProvider::ChangeFeatures )
270  {
271  abilitiesList += tr( "Simultaneous Geometry and Attribute Updates" );
272  }
273 
275  {
276  abilitiesList += tr( "Transactions" );
277  }
278 
280  {
281  abilitiesList += tr( "Curved Geometries" );
282  }
283 
284  return abilitiesList.join( QStringLiteral( ", " ) );
285 }
286 
287 
288 int QgsVectorDataProvider::fieldNameIndex( const QString &fieldName ) const
289 {
290  return fields().lookupField( fieldName );
291 }
292 
293 QMap<QString, int> QgsVectorDataProvider::fieldNameMap() const
294 {
295  QMap<QString, int> resultMap;
296 
297  QgsFields fieldsCopy = fields();
298  for ( int i = 0; i < fieldsCopy.count(); ++i )
299  {
300  resultMap.insert( fieldsCopy.at( i ).name(), i );
301  }
302 
303  return resultMap;
304 }
305 
307 {
308  return fields().allAttributesList();
309 }
310 
312 {
313  return QgsAttributeList();
314 }
315 
316 QList<QgsVectorDataProvider::NativeType> QgsVectorDataProvider::nativeTypes() const
317 {
318  return mNativeTypes;
319 }
320 
322 {
323  return QgsAttrPalIndexNameHash();
324 }
325 
327 {
328  QgsDebugMsgLevel( QString( "field name = %1 type = %2 length = %3 precision = %4" )
329  .arg( field.name(),
330  QVariant::typeToName( field.type() ) )
331  .arg( field.length() )
332  .arg( field.precision() ), 2 );
333 
334  Q_FOREACH ( const NativeType &nativeType, mNativeTypes )
335  {
336  QgsDebugMsgLevel( QString( "native field type = %1 min length = %2 max length = %3 min precision = %4 max precision = %5" )
337  .arg( QVariant::typeToName( nativeType.mType ) )
338  .arg( nativeType.mMinLen )
339  .arg( nativeType.mMaxLen )
340  .arg( nativeType.mMinPrec )
341  .arg( nativeType.mMaxPrec ), 2 );
342 
343  if ( field.type() != nativeType.mType )
344  continue;
345 
346  if ( field.length() == -1 )
347  {
348  // source length unlimited
349  if ( nativeType.mMinLen > -1 || nativeType.mMaxLen > -1 )
350  {
351  // destination limited
352  continue;
353  }
354  }
355  else
356  {
357  // source length limited
358  if ( nativeType.mMinLen > -1 && nativeType.mMaxLen > -1 &&
359  ( field.length() < nativeType.mMinLen || field.length() > nativeType.mMaxLen ) )
360  {
361  // source length exceeds destination limits
362  continue;
363  }
364  }
365 
366  if ( field.precision() == -1 )
367  {
368  // source precision unlimited / n/a
369  if ( nativeType.mMinPrec > -1 || nativeType.mMaxPrec > -1 )
370  {
371  // destination limited
372  continue;
373  }
374  }
375  else
376  {
377  // source precision unlimited / n/a
378  if ( nativeType.mMinPrec > -1 && nativeType.mMaxPrec > -1 &&
379  ( field.precision() < nativeType.mMinPrec || field.precision() > nativeType.mMaxPrec ) )
380  {
381  // source precision exceeds destination limits
382  continue;
383  }
384  }
385 
386  QgsDebugMsg( "native type matches" );
387  return true;
388  }
389 
390  QgsDebugMsg( "no sufficient native type found" );
391  return false;
392 }
393 
394 QVariant QgsVectorDataProvider::minimumValue( int index ) const
395 {
396  if ( index < 0 || index >= fields().count() )
397  {
398  QgsDebugMsg( "Warning: access requested to invalid field index: " + QString::number( index ) );
399  return QVariant();
400  }
401 
402  fillMinMaxCache();
403 
404  if ( !mCacheMinValues.contains( index ) )
405  return QVariant();
406 
407  return mCacheMinValues[index];
408 }
409 
410 QVariant QgsVectorDataProvider::maximumValue( int index ) const
411 {
412  if ( index < 0 || index >= fields().count() )
413  {
414  QgsDebugMsg( "Warning: access requested to invalid field index: " + QString::number( index ) );
415  return QVariant();
416  }
417 
418  fillMinMaxCache();
419 
420  if ( !mCacheMaxValues.contains( index ) )
421  return QVariant();
422 
423  return mCacheMaxValues[index];
424 }
425 
426 
427 QStringList QgsVectorDataProvider::uniqueStringsMatching( int index, const QString &substring, int limit, QgsFeedback *feedback ) const
428 {
429  QgsFeature f;
430  QgsAttributeList keys;
431  keys.append( index );
432 
433  QgsFeatureRequest request;
434  request.setSubsetOfAttributes( keys );
436  QString fieldName = fields().at( index ).name();
437  request.setFilterExpression( QStringLiteral( "\"%1\" ILIKE '%%2%'" ).arg( fieldName, substring ) );
438  QgsFeatureIterator fi = getFeatures( request );
439 
440  QSet<QString> set;
441  QStringList results;
442 
443  while ( fi.nextFeature( f ) )
444  {
445  QString value = f.attribute( index ).toString();
446  if ( !set.contains( value ) )
447  {
448  results.append( value );
449  set.insert( value );
450  }
451 
452  if ( ( limit >= 0 && results.size() >= limit ) || ( feedback && feedback->isCanceled() ) )
453  break;
454  }
455  return results;
456 }
457 
459  const QgsAggregateCalculator::AggregateParameters &parameters, QgsExpressionContext *context, bool &ok ) const
460 {
461  //base implementation does nothing
462  Q_UNUSED( aggregate );
463  Q_UNUSED( index );
464  Q_UNUSED( parameters );
465  Q_UNUSED( context );
466 
467  ok = false;
468  return QVariant();
469 }
470 
472 {
473  mCacheMinMaxDirty = true;
474 }
475 
477 {
478  if ( !mCacheMinMaxDirty )
479  return;
480 
481  QgsFields flds = fields();
482  for ( int i = 0; i < flds.count(); ++i )
483  {
484  if ( flds.at( i ).type() == QVariant::Int )
485  {
486  mCacheMinValues[i] = QVariant( std::numeric_limits<int>::max() );
487  mCacheMaxValues[i] = QVariant( std::numeric_limits<int>::lowest() );
488  }
489  else if ( flds.at( i ).type() == QVariant::LongLong )
490  {
491  mCacheMinValues[i] = QVariant( std::numeric_limits<qlonglong>::max() );
492  mCacheMaxValues[i] = QVariant( std::numeric_limits<qlonglong>::lowest() );
493  }
494  else if ( flds.at( i ).type() == QVariant::Double )
495  {
496  mCacheMinValues[i] = QVariant( std::numeric_limits<double>::max() );
497  mCacheMaxValues[i] = QVariant( std::numeric_limits<double>::lowest() );
498 
499  }
500  else
501  {
502  mCacheMinValues[i] = QVariant();
503  mCacheMaxValues[i] = QVariant();
504  }
505  }
506 
507  QgsFeature f;
508  const QgsAttributeList keys = mCacheMinValues.keys();
509  QgsFeatureIterator fi = getFeatures( QgsFeatureRequest().setSubsetOfAttributes( keys )
510  .setFlags( QgsFeatureRequest::NoGeometry ) );
511 
512  while ( fi.nextFeature( f ) )
513  {
514  QgsAttributes attrs = f.attributes();
515  for ( int attributeIndex : keys )
516  {
517  const QVariant &varValue = attrs.at( attributeIndex );
518 
519  if ( varValue.isNull() )
520  continue;
521 
522  switch ( flds.at( attributeIndex ).type() )
523  {
524  case QVariant::Int:
525  {
526  int value = varValue.toInt();
527  if ( value < mCacheMinValues[ attributeIndex ].toInt() )
528  mCacheMinValues[ attributeIndex ] = value;
529  if ( value > mCacheMaxValues[ attributeIndex ].toInt() )
530  mCacheMaxValues[ attributeIndex ] = value;
531  break;
532  }
533  case QVariant::LongLong:
534  {
535  qlonglong value = varValue.toLongLong();
536  if ( value < mCacheMinValues[ attributeIndex ].toLongLong() )
537  mCacheMinValues[ attributeIndex ] = value;
538  if ( value > mCacheMaxValues[ attributeIndex ].toLongLong() )
539  mCacheMaxValues[ attributeIndex ] = value;
540  break;
541  }
542  case QVariant::Double:
543  {
544  double value = varValue.toDouble();
545  if ( value < mCacheMinValues[ attributeIndex ].toDouble() )
546  mCacheMinValues[attributeIndex ] = value;
547  if ( value > mCacheMaxValues[ attributeIndex ].toDouble() )
548  mCacheMaxValues[ attributeIndex ] = value;
549  break;
550  }
551  default:
552  {
553  QString value = varValue.toString();
554  if ( mCacheMinValues[ attributeIndex ].isNull() || value < mCacheMinValues[attributeIndex ].toString() )
555  {
556  mCacheMinValues[attributeIndex] = value;
557  }
558  if ( mCacheMaxValues[attributeIndex].isNull() || value > mCacheMaxValues[attributeIndex].toString() )
559  {
560  mCacheMaxValues[attributeIndex] = value;
561  }
562  break;
563  }
564  }
565  }
566  }
567 
568  mCacheMinMaxDirty = false;
569 }
570 
571 QVariant QgsVectorDataProvider::convertValue( QVariant::Type type, const QString &value )
572 {
573  QVariant v( value );
574 
575  if ( !v.convert( type ) || value.isNull() )
576  v = QVariant( type );
577 
578  return v;
579 }
580 
582 {
583  return nullptr;
584 }
585 
587 {
588  emit dataChanged();
589 }
590 
591 static bool _compareEncodings( const QString &s1, const QString &s2 )
592 {
593  return s1.toLower() < s2.toLower();
594 }
595 
597 {
598  if ( sEncodings.isEmpty() )
599  {
600  Q_FOREACH ( const QString &codec, QTextCodec::availableCodecs() )
601  {
602  sEncodings << codec;
603  }
604 #if 0
605  smEncodings << "BIG5";
606  smEncodings << "BIG5-HKSCS";
607  smEncodings << "EUCJP";
608  smEncodings << "EUCKR";
609  smEncodings << "GB2312";
610  smEncodings << "GBK";
611  smEncodings << "GB18030";
612  smEncodings << "JIS7";
613  smEncodings << "SHIFT-JIS";
614  smEncodings << "TSCII";
615  smEncodings << "UTF-8";
616  smEncodings << "UTF-16";
617  smEncodings << "KOI8-R";
618  smEncodings << "KOI8-U";
619  smEncodings << "ISO8859-1";
620  smEncodings << "ISO8859-2";
621  smEncodings << "ISO8859-3";
622  smEncodings << "ISO8859-4";
623  smEncodings << "ISO8859-5";
624  smEncodings << "ISO8859-6";
625  smEncodings << "ISO8859-7";
626  smEncodings << "ISO8859-8";
627  smEncodings << "ISO8859-8-I";
628  smEncodings << "ISO8859-9";
629  smEncodings << "ISO8859-10";
630  smEncodings << "ISO8859-11";
631  smEncodings << "ISO8859-12";
632  smEncodings << "ISO8859-13";
633  smEncodings << "ISO8859-14";
634  smEncodings << "ISO8859-15";
635  smEncodings << "IBM 850";
636  smEncodings << "IBM 866";
637  smEncodings << "CP874";
638  smEncodings << "CP1250";
639  smEncodings << "CP1251";
640  smEncodings << "CP1252";
641  smEncodings << "CP1253";
642  smEncodings << "CP1254";
643  smEncodings << "CP1255";
644  smEncodings << "CP1256";
645  smEncodings << "CP1257";
646  smEncodings << "CP1258";
647  smEncodings << "Apple Roman";
648  smEncodings << "TIS-620";
649  smEncodings << "System";
650 #endif
651  }
652 
653  // Do case-insensitive sorting of encodings
654  std::sort( sEncodings.begin(), sEncodings.end(), _compareEncodings );
655 
656  return sEncodings;
657 }
658 
660 {
661  mErrors.clear();
662 }
663 
665 {
666  return !mErrors.isEmpty();
667 }
668 
669 QStringList QgsVectorDataProvider::errors() const
670 {
671  return mErrors;
672 }
673 
675 {
676  return false;
677 }
678 
680 {
681  return false;
682 }
683 
684 void QgsVectorDataProvider::pushError( const QString &msg ) const
685 {
686  QgsDebugMsg( msg );
687  mErrors << msg;
688  emit raiseError( msg );
689 }
690 
691 QSet<QgsMapLayerDependency> QgsVectorDataProvider::dependencies() const
692 {
693  return QSet<QgsMapLayerDependency>();
694 }
695 
697 {
698  if ( geom.isNull() )
699  {
700  return QgsGeometry();
701  }
702 
703  const QgsAbstractGeometry *geometry = geom.constGet();
704  if ( !geometry )
705  {
706  return QgsGeometry();
707  }
708 
709  QgsWkbTypes::Type providerGeomType = wkbType();
710 
711  //geom is already in the provider geometry type
712  if ( geometry->wkbType() == providerGeomType )
713  {
714  return QgsGeometry();
715  }
716 
717  std::unique_ptr< QgsAbstractGeometry > outputGeom;
718 
719  //convert compoundcurve to circularstring (possible if compoundcurve consists of one circular string)
720  if ( QgsWkbTypes::flatType( providerGeomType ) == QgsWkbTypes::CircularString )
721  {
722  QgsCompoundCurve *compoundCurve = qgsgeometry_cast<QgsCompoundCurve *>( geometry );
723  if ( compoundCurve )
724  {
725  if ( compoundCurve->nCurves() == 1 )
726  {
727  const QgsCircularString *circularString = qgsgeometry_cast<const QgsCircularString *>( compoundCurve->curveAt( 0 ) );
728  if ( circularString )
729  {
730  outputGeom.reset( circularString->clone() );
731  }
732  }
733  }
734  }
735 
736  //convert to curved type if necessary
737  if ( !QgsWkbTypes::isCurvedType( geometry->wkbType() ) && QgsWkbTypes::isCurvedType( providerGeomType ) )
738  {
739  QgsAbstractGeometry *curveGeom = outputGeom ? outputGeom->toCurveType() : geometry->toCurveType();
740  if ( curveGeom )
741  {
742  outputGeom.reset( curveGeom );
743  }
744  }
745 
746  //convert to linear type from curved type
747  if ( QgsWkbTypes::isCurvedType( geometry->wkbType() ) && !QgsWkbTypes::isCurvedType( providerGeomType ) )
748  {
749  QgsAbstractGeometry *segmentizedGeom = outputGeom ? outputGeom->segmentize() : geometry->segmentize();
750  if ( segmentizedGeom )
751  {
752  outputGeom.reset( segmentizedGeom );
753  }
754  }
755 
756  //convert to multitype if necessary
757  if ( QgsWkbTypes::isMultiType( providerGeomType ) && !QgsWkbTypes::isMultiType( geometry->wkbType() ) )
758  {
759  std::unique_ptr< QgsAbstractGeometry > collGeom( QgsGeometryFactory::geomFromWkbType( providerGeomType ) );
760  QgsGeometryCollection *geomCollection = qgsgeometry_cast<QgsGeometryCollection *>( collGeom.get() );
761  if ( geomCollection )
762  {
763  if ( geomCollection->addGeometry( outputGeom ? outputGeom->clone() : geometry->clone() ) )
764  {
765  outputGeom.reset( collGeom.release() );
766  }
767  }
768  }
769 
770  //set z/m types
771  if ( QgsWkbTypes::hasZ( providerGeomType ) )
772  {
773  if ( !outputGeom )
774  {
775  outputGeom.reset( geometry->clone() );
776  }
777  outputGeom->addZValue();
778  }
779 
780  if ( QgsWkbTypes::hasM( providerGeomType ) )
781  {
782  if ( !outputGeom )
783  {
784  outputGeom.reset( geometry->clone() );
785  }
786  outputGeom->addMValue();
787  }
788 
789  if ( outputGeom )
790  {
791  return QgsGeometry( outputGeom.release() );
792  }
793 
794  return QgsGeometry();
795 }
796 
797 void QgsVectorDataProvider::setNativeTypes( const QList<NativeType> &nativeTypes )
798 {
799  mNativeTypes = nativeTypes;
800 }
801 
803 {
804  return mEncoding;
805 }
806 
807 QStringList QgsVectorDataProvider::sEncodings;
808 
809 QList<QgsRelation> QgsVectorDataProvider::discoverRelations( const QgsVectorLayer *, const QList<QgsVectorLayer *> & ) const
810 {
811  return QList<QgsRelation>();
812 }
int lookupField(const QString &fieldName) const
Look up field&#39;s index from the field name.
Definition: qgsfields.cpp:299
QgsFeatureId id
Definition: qgsfeature.h:71
QString encoding() const
Get encoding which is used for accessing data.
Wrapper for iterator of features from vector data provider or vector layer.
QMap< QgsFeatureId, QgsGeometry > QgsGeometryMap
Definition: qgsfeature.h:537
static QVariant convertValue(QVariant::Type type, const QString &value)
A rectangle specified with double values.
Definition: qgsrectangle.h:39
QVariant maximumValue(int index) const override
Returns the maximum value of an attribute.
static std::unique_ptr< QgsAbstractGeometry > geomFromWkbType(QgsWkbTypes::Type t)
Return empty geometry from wkb type.
bool addZValue(double zValue=0) override
Adds a z-dimension to the geometry, initialized to a preset value.
virtual QgsVectorDataProvider::Capabilities capabilities() const
Returns flags containing the supported capabilities.
QgsWkbTypes::Type wkbType() const override=0
Returns the geometry type which is returned by this layer.
QMap< QString, int > fieldNameMap() const
Return a map where the key is the name of the field and the value is its index.
virtual QgsAbstractGeometry * toCurveType() const =0
Returns the geometry converted to the more generic curve type.
QString name
Definition: qgsfield.h:57
QVariant minimumValue(int index) const override
Returns the minimum value of an attribute.
int precision
Definition: qgsfield.h:54
virtual bool addAttributes(const QList< QgsField > &attributes)
Adds new attributes to the provider.
bool isNull() const
Returns true if the geometry is null (ie, contains no underlying geometry accessible via geometry() )...
virtual QVariant aggregate(QgsAggregateCalculator::Aggregate aggregate, int index, const QgsAggregateCalculator::AggregateParameters &parameters, QgsExpressionContext *context, bool &ok) const
Calculates an aggregated value from the layer&#39;s features.
This class is a composition of two QSettings instances:
Definition: qgssettings.h:57
static bool isMultiType(Type type)
Returns true if the WKB type is a multi type.
Definition: qgswkbtypes.h:557
Constraint
Constraints which may be present on a field.
#define QgsDebugMsg(str)
Definition: qgslogger.h:38
QSet< QgsFeatureId > QgsFeatureIds
Definition: qgsfeature.h:544
QgsFieldConstraints::Constraints fieldConstraints(int fieldIndex) const
Returns any constraints which are present at the provider for a specified field index.
bool addFeatures(QgsFeatureList &flist, QgsFeatureSink::Flags flags=nullptr) override
Adds a list of features to the sink.
QList< QgsFeature > QgsFeatureList
Definition: qgsfeature.h:549
Supports simplification of geometries on provider side according to a distance tolerance.
virtual QSet< QgsMapLayerDependency > dependencies() const
Get the list of layer ids on which this layer depends.
virtual bool deleteFeatures(const QgsFeatureIds &id)
Deletes one or more features from the provider.
virtual void setEncoding(const QString &e)
Set encoding used for accessing data from layer.
virtual QgsAttributeList pkAttributeIndexes() const
Return list of indexes of fields that make up the primary key.
virtual bool renameAttributes(const QgsFieldNameMap &renamedAttributes)
Renames existing attributes.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
void pushError(const QString &msg) const
Push a notification about errors that happened in this providers scope.
void raiseError(const QString &msg) const
Signals an error in this provider.
Container of fields for a vector layer.
Definition: qgsfields.h:42
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:111
Abstract base class for spatial data provider implementations.
Allows deletion of attributes (fields)
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:62
QList< QgsVectorDataProvider::NativeType > nativeTypes() const
Returns the names of the supported types.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
int count() const
Return number of items.
Definition: qgsfields.cpp:115
static bool hasZ(Type type)
Tests whether a WKB type contains the z-dimension.
Definition: qgswkbtypes.h:768
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::Warning)
add a message to the instance (and create it if necessary)
virtual bool createAttributeIndex(int field)
Create an attribute index on the datasource.
bool supportedType(const QgsField &field) const
check if provider supports type of field
QgsField at(int i) const
Get field at particular index (must be in range 0..N-1)
Definition: qgsfields.cpp:145
int length
Definition: qgsfield.h:53
void dataChanged()
This is emitted whenever an asynchronous operation has finished and the data should be redrawn...
Base class for feedback objects to be used for cancelation of something running in a worker thread...
Definition: qgsfeedback.h:44
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...
void setNativeTypes(const QList< QgsVectorDataProvider::NativeType > &nativeTypes)
Set the list of native types supported by this provider.
Allows creation of spatial index.
QSet< int > QgsAttributeIds
virtual bool createSpatialIndex()
Creates a spatial index on the datasource (if supported by the provider type).
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
Type
The WKB type describes the number of dimensions a geometry has.
Definition: qgswkbtypes.h:67
Can create indexes on provider&#39;s fields.
QgsAttributeList allAttributesList() const
Utility function to get list of attribute indexes.
Definition: qgsfields.cpp:326
void fillMinMaxCache() const
Populates the cache of minimum and maximum attribute values.
Allows addition of new attributes (fields)
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
void clearMinMaxCache()
Invalidates the min/max cache.
Geometry collection.
virtual QgsCoordinateReferenceSystem crs() const =0
Returns the coordinate system for the data source.
QgsFields fields() const override=0
Returns the fields associated with this data provider.
virtual bool changeAttributeValues(const QgsChangedAttributesMap &attr_map)
Changes attribute values of existing features.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
virtual bool changeFeatures(const QgsChangedAttributesMap &attr_map, const QgsGeometryMap &geometry_map)
Changes attribute values and geometries of existing features.
QStringList errors() const
Get recorded errors.
This class wraps a request for features to a vector layer (or directly its vector data provider)...
virtual QString defaultValueClause(int fieldIndex) const
Returns any default value clauses which are present at the provider for a specified field index...
T qgsgeometry_cast(const QgsAbstractGeometry *geom)
int fieldNameIndex(const QString &fieldName) const
Returns the index of a field name or -1 if the field does not exist.
Allows modifications of geometries.
void clearErrors()
Clear recorded errors.
QgsGeometry convertToProviderType(const QgsGeometry &geom) const
Converts the geometry to the provider type if possible / necessary.
virtual bool isDeleteStyleFromDatabaseSupported() const
It returns false by default.
virtual QgsTransaction * transaction() const
Returns the transaction this data provider is included in, if any.
Encapsulate a field in an attribute table or data source.
Definition: qgsfield.h:48
QgsCoordinateReferenceSystem sourceCrs() const override
Returns the coordinate reference system for features in the source.
virtual bool isSaveAndLoadStyleToDatabaseSupported() const
It returns false by default.
Abstract base class for all geometries.
Fast access to features using their ID.
virtual bool changeGeometryValues(const QgsGeometryMap &geometry_map)
Changes geometries of existing features.
QgsWkbTypes::Type wkbType() const
Returns the WKB type of the geometry.
QgsVectorDataProvider(const QString &uri=QString())
Constructor of the vector provider.
QMap< int, QString > QgsFieldNameMap
Definition: qgsattributes.h:45
Supports circular geometry types (circularstring, compoundcurve, curvepolygon)
virtual void forceReload()
Forces a reload of the underlying datasource if the provider implements this method.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
int nCurves() const
Returns the number of curves in the geometry.
Supports topological simplification of geometries on provider side according to a distance tolerance...
QString capabilitiesString() const
Returns the above in friendly format.
QgsFieldConstraints constraints
Definition: qgsfield.h:60
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition: qgsfeedback.h:54
QMap< QgsFeatureId, QgsAttributeMap > QgsChangedAttributesMap
Definition: qgsfeature.h:528
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const override=0
Query the provider for features specified in request.
This class allows including a set of layers in a database-side transaction, provided the layer data p...
static bool isCurvedType(Type type)
Returns true if the WKB type is a curved type or can contain curved geometries.
Definition: qgswkbtypes.h:606
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), const Section section=NoSection) const
Returns the value for setting key.
QgsCircularString * clone() const override
Clones the geometry by performing a deep copy.
bool hasErrors() const
Provider has errors to report.
virtual bool truncate()
Removes all features from the layer.
virtual QString dataComment() const
Return a short comment for the data that this provider is providing access to (e.g.
This class represents a coordinate reference system (CRS).
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.
const QgsCurve * curveAt(int i) const
Returns the curve at the specified index.
virtual QgsAttributeList attributeIndexes() const
Return list of indexes to fetch all attributes in nextFeature()
virtual bool deleteAttributes(const QgsAttributeIds &attributes)
Deletes existing attributes from the provider.
static bool hasM(Type type)
Tests whether a WKB type contains m values.
Definition: qgswkbtypes.h:818
Compound curve geometry type.
Circular string geometry type.
virtual QgsRectangle extent() const =0
Returns the extent of the layer.
virtual QString storageType() const
Returns the permanent storage type for this layer as a friendly name.
QList< int > QgsAttributeList
Definition: qgsfield.h:27
bool nextFeature(QgsFeature &f)
Provider has no capabilities.
virtual QgsAttrPalIndexNameHash palAttributeIndexNames() const
Return list of indexes to names for QgsPalLabeling fix.
Geometry is not required. It may still be returned if e.g. required for a filter condition.
A vector of attributes.
Definition: qgsattributes.h:58
Represents a vector layer which manages a vector based data sets.
QTextCodec * textEncoding() const
Get this providers encoding.
QVariant attribute(const QString &name) const
Lookup attribute value from attribute name.
Definition: qgsfeature.cpp:255
static Type flatType(Type type)
Returns the flat type for a WKB type.
Definition: qgswkbtypes.h:427
virtual QgsAbstractGeometry * segmentize(double tolerance=M_PI/180., SegmentationToleranceType toleranceType=MaximumAngle) const
Returns a version of the geometry without curves.
QHash< int, QString > QgsAttrPalIndexNameHash
Allows modification of attribute values.
QVariant::Type type
Definition: qgsfield.h:55
QgsAttributes attributes
Definition: qgsfeature.h:72
static QStringList availableEncodings()
Returns a list of available encodings.
Aggregate
Available aggregates to calculate.
virtual bool addGeometry(QgsAbstractGeometry *g)
Adds a geometry and takes ownership. Returns true in case of success.
Supports joint updates for attributes and geometry Providers supporting this should still define Chan...
QgsFeatureRequest & setFlags(QgsFeatureRequest::Flags flags)
Set flags that affect how features will be fetched.
QgsRectangle sourceExtent() const override
Returns the extent of all geometries from the source.
A bundle of parameters controlling aggregate calculation.
virtual QVariant defaultValue(int fieldIndex) const
Returns any literal default values which are present at the provider for a specified field index...
virtual QList< QgsRelation > discoverRelations(const QgsVectorLayer *self, const QList< QgsVectorLayer *> &layers) const
Discover the available relations with the given layers.