QGIS API Documentation 3.34.0-Prizren (ffbdd678812)
Loading...
Searching...
No Matches
qgsvectorlayerutils.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsvectorlayerutils.cpp
3 -----------------------
4 Date : October 2016
5 Copyright : (C) 2016 by Nyall Dawson
6 Email : nyall dot dawson at gmail dot com
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 <QRegularExpression>
17
19#include "qgsfeatureiterator.h"
20#include "qgsfeaturerequest.h"
21#include "qgsvectorlayerutils.h"
23#include "qgsproject.h"
24#include "qgsrelationmanager.h"
25#include "qgsfeedback.h"
26#include "qgsvectorlayer.h"
27#include "qgsthreadingutils.h"
31#include "qgspallabeling.h"
32#include "qgsrenderer.h"
33#include "qgssymbollayer.h"
35#include "qgsstyle.h"
36#include "qgsauxiliarystorage.h"
38#include "qgspainteffect.h"
39
40QgsFeatureIterator QgsVectorLayerUtils::getValuesIterator( const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly )
41{
42 std::unique_ptr<QgsExpression> expression;
44
45 int attrNum = layer->fields().lookupField( fieldOrExpression );
46 if ( attrNum == -1 )
47 {
48 // try to use expression
49 expression.reset( new QgsExpression( fieldOrExpression ) );
51
52 if ( expression->hasParserError() || !expression->prepare( &context ) )
53 {
54 ok = false;
55 return QgsFeatureIterator();
56 }
57 }
58
59 QSet<QString> lst;
60 if ( !expression )
61 lst.insert( fieldOrExpression );
62 else
63 lst = expression->referencedColumns();
64
66 .setFlags( ( expression && expression->needsGeometry() ) ?
69 .setSubsetOfAttributes( lst, layer->fields() );
70
71 ok = true;
72 if ( !selectedOnly )
73 {
74 return layer->getFeatures( request );
75 }
76 else
77 {
78 return layer->getSelectedFeatures( request );
79 }
80}
81
82QList<QVariant> QgsVectorLayerUtils::getValues( const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly, QgsFeedback *feedback )
83{
84 QList<QVariant> values;
85 QgsFeatureIterator fit = getValuesIterator( layer, fieldOrExpression, ok, selectedOnly );
86 if ( ok )
87 {
88 std::unique_ptr<QgsExpression> expression;
90
91 int attrNum = layer->fields().lookupField( fieldOrExpression );
92 if ( attrNum == -1 )
93 {
94 // use expression, already validated in the getValuesIterator() function
95 expression.reset( new QgsExpression( fieldOrExpression ) );
97 }
98
99 QgsFeature f;
100 while ( fit.nextFeature( f ) )
101 {
102 if ( expression )
103 {
104 context.setFeature( f );
105 QVariant v = expression->evaluate( &context );
106 values << v;
107 }
108 else
109 {
110 values << f.attribute( attrNum );
111 }
112 if ( feedback && feedback->isCanceled() )
113 {
114 ok = false;
115 return values;
116 }
117 }
118 }
119 return values;
120}
121
122QList<double> QgsVectorLayerUtils::getDoubleValues( const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly, int *nullCount, QgsFeedback *feedback )
123{
124 QList<double> values;
125
126 if ( nullCount )
127 *nullCount = 0;
128
129 QList<QVariant> variantValues = getValues( layer, fieldOrExpression, ok, selectedOnly, feedback );
130 if ( !ok )
131 return values;
132
133 bool convertOk;
134 const auto constVariantValues = variantValues;
135 for ( const QVariant &value : constVariantValues )
136 {
137 double val = value.toDouble( &convertOk );
138 if ( convertOk )
139 values << val;
140 else if ( QgsVariantUtils::isNull( value ) )
141 {
142 if ( nullCount )
143 *nullCount += 1;
144 }
145 if ( feedback && feedback->isCanceled() )
146 {
147 ok = false;
148 return values;
149 }
150 }
151 return values;
152}
153
154bool QgsVectorLayerUtils::valueExists( const QgsVectorLayer *layer, int fieldIndex, const QVariant &value, const QgsFeatureIds &ignoreIds )
155{
156 if ( !layer )
157 return false;
158
159 QgsFields fields = layer->fields();
160
161 if ( fieldIndex < 0 || fieldIndex >= fields.count() )
162 return false;
163
164 // If it's a joined field search the value in the source layer
165 if ( fields.fieldOrigin( fieldIndex ) == QgsFields::FieldOrigin::OriginJoin )
166 {
167 int srcFieldIndex;
168 const QgsVectorLayerJoinInfo *joinInfo { layer->joinBuffer()->joinForFieldIndex( fieldIndex, fields, srcFieldIndex ) };
169 if ( ! joinInfo )
170 {
171 return false;
172 }
173 fieldIndex = srcFieldIndex;
174 layer = joinInfo->joinLayer();
175 if ( ! layer )
176 {
177 return false;
178 }
179 fields = layer->fields();
180 }
181
182 QString fieldName = fields.at( fieldIndex ).name();
183
184 // build up an optimised feature request
185 QgsFeatureRequest request;
186 request.setNoAttributes();
188
189 // at most we need to check ignoreIds.size() + 1 - the feature not in ignoreIds is the one we're interested in
190 int limit = ignoreIds.size() + 1;
191 request.setLimit( limit );
192
193 request.setFilterExpression( QStringLiteral( "%1=%2" ).arg( QgsExpression::quotedColumnRef( fieldName ),
194 QgsExpression::quotedValue( value ) ) );
195
196 QgsFeature feat;
197 QgsFeatureIterator it = layer->getFeatures( request );
198 while ( it.nextFeature( feat ) )
199 {
200 if ( ignoreIds.contains( feat.id() ) )
201 continue;
202
203 return true;
204 }
205
206 return false;
207}
208
209QVariant QgsVectorLayerUtils::createUniqueValue( const QgsVectorLayer *layer, int fieldIndex, const QVariant &seed )
210{
211 if ( !layer )
212 return QVariant();
213
214 QgsFields fields = layer->fields();
215
216 if ( fieldIndex < 0 || fieldIndex >= fields.count() )
217 return QVariant();
218
219 QgsField field = fields.at( fieldIndex );
220
221 if ( field.isNumeric() )
222 {
223 QVariant maxVal = layer->maximumValue( fieldIndex );
224 QVariant newVar( maxVal.toLongLong() + 1 );
225 if ( field.convertCompatible( newVar ) )
226 return newVar;
227 else
228 return QVariant();
229 }
230 else
231 {
232 switch ( field.type() )
233 {
234 case QVariant::String:
235 {
236 QString base;
237 if ( seed.isValid() )
238 base = seed.toString();
239
240 if ( !base.isEmpty() )
241 {
242 // strip any existing _1, _2 from the seed
243 const thread_local QRegularExpression rx( QStringLiteral( "(.*)_\\d+" ) );
244 QRegularExpressionMatch match = rx.match( base );
245 if ( match.hasMatch() )
246 {
247 base = match.captured( 1 );
248 }
249 }
250 else
251 {
252 // no base seed - fetch first value from layer
254 req.setLimit( 1 );
255 req.setSubsetOfAttributes( QgsAttributeList() << fieldIndex );
257 QgsFeature f;
258 layer->getFeatures( req ).nextFeature( f );
259 base = f.attribute( fieldIndex ).toString();
260 }
261
262 // try variants like base_1, base_2, etc until a new value found
263 QStringList vals = layer->uniqueStringsMatching( fieldIndex, base );
264
265 // might already be unique
266 if ( !base.isEmpty() && !vals.contains( base ) )
267 return base;
268
269 for ( int i = 1; i < 10000; ++i )
270 {
271 QString testVal = base + '_' + QString::number( i );
272 if ( !vals.contains( testVal ) )
273 return testVal;
274 }
275
276 // failed
277 return QVariant();
278 }
279
280 default:
281 // todo other types - dates? times?
282 break;
283 }
284 }
285
286 return QVariant();
287}
288
289QVariant QgsVectorLayerUtils::createUniqueValueFromCache( const QgsVectorLayer *layer, int fieldIndex, const QSet<QVariant> &existingValues, const QVariant &seed )
290{
291 if ( !layer )
292 return QVariant();
293
294 QgsFields fields = layer->fields();
295
296 if ( fieldIndex < 0 || fieldIndex >= fields.count() )
297 return QVariant();
298
299 QgsField field = fields.at( fieldIndex );
300
301 if ( field.isNumeric() )
302 {
303 QVariant maxVal = existingValues.isEmpty() ? 0 : *std::max_element( existingValues.begin(), existingValues.end(), []( const QVariant & a, const QVariant & b ) { return a.toLongLong() < b.toLongLong(); } );
304 QVariant newVar( maxVal.toLongLong() + 1 );
305 if ( field.convertCompatible( newVar ) )
306 return newVar;
307 else
308 return QVariant();
309 }
310 else
311 {
312 switch ( field.type() )
313 {
314 case QVariant::String:
315 {
316 QString base;
317 if ( seed.isValid() )
318 base = seed.toString();
319
320 if ( !base.isEmpty() )
321 {
322 // strip any existing _1, _2 from the seed
323 const thread_local QRegularExpression rx( QStringLiteral( "(.*)_\\d+" ) );
324 QRegularExpressionMatch match = rx.match( base );
325 if ( match.hasMatch() )
326 {
327 base = match.captured( 1 );
328 }
329 }
330 else
331 {
332 // no base seed - fetch first value from layer
334 base = existingValues.isEmpty() ? QString() : existingValues.constBegin()->toString();
335 }
336
337 // try variants like base_1, base_2, etc until a new value found
338 QStringList vals;
339 for ( const auto &v : std::as_const( existingValues ) )
340 {
341 if ( v.toString().startsWith( base ) )
342 vals.push_back( v.toString() );
343 }
344
345 // might already be unique
346 if ( !base.isEmpty() && !vals.contains( base ) )
347 return base;
348
349 for ( int i = 1; i < 10000; ++i )
350 {
351 QString testVal = base + '_' + QString::number( i );
352 if ( !vals.contains( testVal ) )
353 return testVal;
354 }
355
356 // failed
357 return QVariant();
358 }
359
360 default:
361 // todo other types - dates? times?
362 break;
363 }
364 }
365
366 return QVariant();
367
368}
369
370bool QgsVectorLayerUtils::attributeHasConstraints( const QgsVectorLayer *layer, int attributeIndex )
371{
372 if ( !layer )
373 return false;
374
375 if ( attributeIndex < 0 || attributeIndex >= layer->fields().count() )
376 return false;
377
378 const QgsFieldConstraints constraints = layer->fields().at( attributeIndex ).constraints();
379 return ( constraints.constraints() & QgsFieldConstraints::ConstraintNotNull ||
382}
383
384bool QgsVectorLayerUtils::validateAttribute( const QgsVectorLayer *layer, const QgsFeature &feature, int attributeIndex, QStringList &errors,
386{
387 if ( !layer )
388 return false;
389
390 if ( attributeIndex < 0 || attributeIndex >= layer->fields().count() )
391 return false;
392
393 QgsFields fields = layer->fields();
394 QgsField field = fields.at( attributeIndex );
395 const QVariant value = feature.attribute( attributeIndex );
396 bool valid = true;
397 errors.clear();
398
399 QgsFieldConstraints constraints = field.constraints();
400
401 if ( constraints.constraints() & QgsFieldConstraints::ConstraintExpression && !constraints.constraintExpression().isEmpty()
404 {
406 context.setFeature( feature );
407
408 QgsExpression expr( constraints.constraintExpression() );
409
410 valid = expr.evaluate( &context ).toBool();
411
412 if ( expr.hasParserError() )
413 {
414 errors << QObject::tr( "parser error: %1" ).arg( expr.parserErrorString() );
415 }
416 else if ( expr.hasEvalError() )
417 {
418 errors << QObject::tr( "evaluation error: %1" ).arg( expr.evalErrorString() );
419 }
420 else if ( !valid )
421 {
422 errors << QObject::tr( "%1 check failed" ).arg( constraints.constraintDescription() );
423 }
424 }
425
426 bool notNullConstraintViolated { false };
427
431 {
432 bool exempt = false;
433 if ( fields.fieldOrigin( attributeIndex ) == QgsFields::OriginProvider
435 {
436 int providerIdx = fields.fieldOriginIndex( attributeIndex );
437 exempt = layer->dataProvider()->skipConstraintCheck( providerIdx, QgsFieldConstraints::ConstraintNotNull, value );
438 }
439
440 if ( !exempt )
441 {
442 valid = valid && !QgsVariantUtils::isNull( value );
443
444 if ( QgsVariantUtils::isNull( value ) )
445 {
446 errors << QObject::tr( "value is NULL" );
447 notNullConstraintViolated = true;
448 }
449 }
450 }
451
452 // if a NOT NULL constraint is violated we don't need to check for UNIQUE
453 if ( ! notNullConstraintViolated )
454 {
455
459 {
460 bool exempt = false;
461 if ( fields.fieldOrigin( attributeIndex ) == QgsFields::OriginProvider
463 {
464 int providerIdx = fields.fieldOriginIndex( attributeIndex );
465 exempt = layer->dataProvider()->skipConstraintCheck( providerIdx, QgsFieldConstraints::ConstraintUnique, value );
466 }
467
468 if ( !exempt )
469 {
470
471 bool alreadyExists = QgsVectorLayerUtils::valueExists( layer, attributeIndex, value, QgsFeatureIds() << feature.id() );
472 valid = valid && !alreadyExists;
473
474 if ( alreadyExists )
475 {
476 errors << QObject::tr( "value is not unique" );
477 }
478 }
479 }
480 }
481
482 return valid;
483}
484
486 const QgsAttributeMap &attributes, QgsExpressionContext *context )
487{
488 QgsFeatureList features { createFeatures( layer, QgsFeaturesDataList() << QgsFeatureData( geometry, attributes ), context ) };
489 return features.isEmpty() ? QgsFeature() : features.first();
490}
491
493{
494 if ( !layer )
495 return QgsFeatureList();
496
497 QgsFeatureList result;
498 result.reserve( featuresData.length() );
499
500 QgsExpressionContext *evalContext = context;
501 std::unique_ptr< QgsExpressionContext > tempContext;
502 if ( !evalContext )
503 {
504 // no context passed, so we create a default one
506 evalContext = tempContext.get();
507 }
508
509 QgsFields fields = layer->fields();
510
511 // Cache unique values
512 QMap<int, QSet<QVariant>> uniqueValueCache;
513
514 auto checkUniqueValue = [ & ]( const int fieldIdx, const QVariant & value )
515 {
516 if ( ! uniqueValueCache.contains( fieldIdx ) )
517 {
518 // If the layer is filtered, get unique values from an unfiltered clone
519 if ( ! layer->subsetString().isEmpty() )
520 {
521 std::unique_ptr<QgsVectorLayer> unfilteredClone { layer->clone( ) };
522 unfilteredClone->setSubsetString( QString( ) );
523 uniqueValueCache[ fieldIdx ] = unfilteredClone->uniqueValues( fieldIdx );
524 }
525 else
526 {
527 uniqueValueCache[ fieldIdx ] = layer->uniqueValues( fieldIdx );
528 }
529 }
530 return uniqueValueCache[ fieldIdx ].contains( value );
531 };
532
533 for ( const auto &fd : std::as_const( featuresData ) )
534 {
535
536 QgsFeature newFeature( fields );
537 newFeature.setValid( true );
538 newFeature.setGeometry( fd.geometry() );
539
540 // initialize attributes
541 newFeature.initAttributes( fields.count() );
542 for ( int idx = 0; idx < fields.count(); ++idx )
543 {
544 QVariant v;
545 bool checkUnique = true;
546 const bool hasUniqueConstraint { static_cast<bool>( fields.at( idx ).constraints().constraints() & QgsFieldConstraints::ConstraintUnique ) };
547
548 // in order of priority:
549 // 1. passed attribute value and if field does not have a unique constraint like primary key
550 if ( fd.attributes().contains( idx ) )
551 {
552 v = fd.attributes().value( idx );
553 }
554
555 // 2. client side default expression
556 // note - deliberately not using else if!
557 QgsDefaultValue defaultValueDefinition = layer->defaultValueDefinition( idx );
558 if ( ( QgsVariantUtils::isNull( v ) || ( hasUniqueConstraint
559 && checkUniqueValue( idx, v ) )
560 || defaultValueDefinition.applyOnUpdate() )
561 && defaultValueDefinition.isValid() )
562 {
563 // client side default expression set - takes precedence over all. Why? Well, this is the only default
564 // which QGIS users have control over, so we assume that they're deliberately overriding any
565 // provider defaults for some good reason and we should respect that
566 v = layer->defaultValue( idx, newFeature, evalContext );
567 }
568
569 // 3. provider side default value clause
570 // note - not an else if deliberately. Users may return null from a default value expression to fallback to provider defaults
571 if ( ( QgsVariantUtils::isNull( v ) || ( hasUniqueConstraint
572 && checkUniqueValue( idx, v ) ) )
573 && fields.fieldOrigin( idx ) == QgsFields::OriginProvider )
574 {
575 int providerIndex = fields.fieldOriginIndex( idx );
576 QString providerDefault = layer->dataProvider()->defaultValueClause( providerIndex );
577 if ( !providerDefault.isEmpty() )
578 {
579 v = providerDefault;
580 checkUnique = false;
581 }
582 }
583
584 // 4. provider side default literal
585 // note - deliberately not using else if!
586 if ( ( QgsVariantUtils::isNull( v ) || ( checkUnique
587 && hasUniqueConstraint
588 && checkUniqueValue( idx, v ) ) )
589 && fields.fieldOrigin( idx ) == QgsFields::OriginProvider )
590 {
591 int providerIndex = fields.fieldOriginIndex( idx );
592 v = layer->dataProvider()->defaultValue( providerIndex );
593 if ( v.isValid() )
594 {
595 //trust that the provider default has been sensibly set not to violate any constraints
596 checkUnique = false;
597 }
598 }
599
600 // 5. passed attribute value
601 // note - deliberately not using else if!
602 if ( QgsVariantUtils::isNull( v ) && fd.attributes().contains( idx ) )
603 {
604 v = fd.attributes().value( idx );
605 }
606
607 // last of all... check that unique constraints are respected if the value is valid
608 if ( v.isValid() )
609 {
610 // we can't handle not null or expression constraints here, since there's no way to pick a sensible
611 // value if the constraint is violated
612 if ( checkUnique && hasUniqueConstraint )
613 {
614 if ( checkUniqueValue( idx, v ) )
615 {
616 // unique constraint violated
617 QVariant uniqueValue = QgsVectorLayerUtils::createUniqueValueFromCache( layer, idx, uniqueValueCache[ idx ], v );
618 if ( uniqueValue.isValid() )
619 v = uniqueValue;
620 }
621 }
622 if ( hasUniqueConstraint )
623 {
624 uniqueValueCache[ idx ].insert( v );
625 }
626 }
627 newFeature.setAttribute( idx, v );
628 }
629 result.append( newFeature );
630 }
631 return result;
632}
633
634QgsFeature QgsVectorLayerUtils::duplicateFeature( QgsVectorLayer *layer, const QgsFeature &feature, QgsProject *project, QgsDuplicateFeatureContext &duplicateFeatureContext, const int maxDepth, int depth, QList<QgsVectorLayer *> referencedLayersBranch )
635{
636 if ( !layer )
637 return QgsFeature();
638
639 if ( !layer->isEditable() )
640 return QgsFeature();
641
642 //get context from layer
644 context.setFeature( feature );
645
646 QgsFeature newFeature = createFeature( layer, feature.geometry(), feature.attributes().toMap(), &context );
647 layer->addFeature( newFeature );
648
649 const QList<QgsRelation> relations = project->relationManager()->referencedRelations( layer );
650
651 const int effectiveMaxDepth = maxDepth > 0 ? maxDepth : 100;
652
653 for ( const QgsRelation &relation : relations )
654 {
655 //check if composition (and not association)
656 if ( relation.strength() == Qgis::RelationshipStrength::Composition && !referencedLayersBranch.contains( relation.referencedLayer() ) && depth < effectiveMaxDepth )
657 {
658 depth++;
659 referencedLayersBranch << layer;
660
661 //get features connected over this relation
662 QgsFeatureIterator relatedFeaturesIt = relation.getRelatedFeatures( feature );
663 QgsFeatureIds childFeatureIds;
664 QgsFeature childFeature;
665 while ( relatedFeaturesIt.nextFeature( childFeature ) )
666 {
667 //set childlayer editable
668 relation.referencingLayer()->startEditing();
669 //change the fk of the child to the id of the new parent
670 const auto pairs = relation.fieldPairs();
671 for ( const QgsRelation::FieldPair &fieldPair : pairs )
672 {
673 childFeature.setAttribute( fieldPair.first, newFeature.attribute( fieldPair.second ) );
674 }
675 //call the function for the child
676 childFeatureIds.insert( duplicateFeature( relation.referencingLayer(), childFeature, project, duplicateFeatureContext, maxDepth, depth, referencedLayersBranch ).id() );
677 }
678
679 //store for feedback
680 duplicateFeatureContext.setDuplicatedFeatures( relation.referencingLayer(), childFeatureIds );
681 }
682 }
683
684
685 return newFeature;
686}
687
688std::unique_ptr<QgsVectorLayerFeatureSource> QgsVectorLayerUtils::getFeatureSource( QPointer<QgsVectorLayer> layer, QgsFeedback *feedback )
689{
690 std::unique_ptr<QgsVectorLayerFeatureSource> featureSource;
691
692 auto getFeatureSource = [ layer, &featureSource, feedback ]
693 {
694 Q_ASSERT( QThread::currentThread() == qApp->thread() || feedback );
695 QgsVectorLayer *lyr = layer.data();
696
697 if ( lyr )
698 {
699 featureSource.reset( new QgsVectorLayerFeatureSource( lyr ) );
700 }
701 };
702
704
705 return featureSource;
706}
707
709{
710 if ( !feature.fields().isEmpty() )
711 {
712 QgsAttributes attributes;
713 attributes.reserve( fields.size() );
714 // feature has a field mapping, so we can match attributes to field names
715 for ( const QgsField &field : fields )
716 {
717 int index = feature.fields().lookupField( field.name() );
718 attributes.append( index >= 0 ? feature.attribute( index ) : QVariant( field.type() ) );
719 }
720 feature.setAttributes( attributes );
721 }
722 else
723 {
724 // no field name mapping in feature, just use order
725 const int lengthDiff = feature.attributes().count() - fields.count();
726 if ( lengthDiff > 0 )
727 {
728 // truncate extra attributes
729 QgsAttributes attributes = feature.attributes().mid( 0, fields.count() );
730 feature.setAttributes( attributes );
731 }
732 else if ( lengthDiff < 0 )
733 {
734 // add missing null attributes
735 QgsAttributes attributes = feature.attributes();
736 attributes.reserve( fields.count() );
737 for ( int i = feature.attributes().count(); i < fields.count(); ++i )
738 {
739 attributes.append( QVariant( fields.at( i ).type() ) );
740 }
741 feature.setAttributes( attributes );
742 }
743 }
744 feature.setFields( fields );
745}
746
747QgsFeatureList QgsVectorLayerUtils::makeFeatureCompatible( const QgsFeature &feature, const QgsVectorLayer *layer, QgsFeatureSink::SinkFlags sinkFlags )
748{
749 Qgis::WkbType inputWkbType( layer->wkbType( ) );
750 QgsFeatureList resultFeatures;
751 QgsFeature newF( feature );
752 // Fix attributes
754
755 if ( sinkFlags & QgsFeatureSink::RegeneratePrimaryKey )
756 {
757 // drop incoming primary key values, let them be regenerated
758 const QgsAttributeList pkIndexes = layer->dataProvider()->pkAttributeIndexes();
759 for ( int index : pkIndexes )
760 {
761 if ( index >= 0 )
762 newF.setAttribute( index, QVariant() );
763 }
764 }
765
766 // Does geometry need transformations?
768 bool newFHasGeom = newFGeomType !=
770 newFGeomType != Qgis::GeometryType::Null;
771 bool layerHasGeom = inputWkbType !=
773 inputWkbType != Qgis::WkbType::Unknown;
774 // Drop geometry if layer is geometry-less
775 if ( ( newFHasGeom && !layerHasGeom ) || !newFHasGeom )
776 {
777 QgsFeature _f = QgsFeature( layer->fields() );
778 _f.setAttributes( newF.attributes() );
779 resultFeatures.append( _f );
780 }
781 else
782 {
783 // Geometry need fixing?
784 const QVector< QgsGeometry > geometries = newF.geometry().coerceToType( inputWkbType );
785
786 if ( geometries.count() != 1 )
787 {
788 QgsAttributeMap attrMap;
789 for ( int j = 0; j < newF.fields().count(); j++ )
790 {
791 attrMap[j] = newF.attribute( j );
792 }
793 resultFeatures.reserve( geometries.size() );
794 for ( const QgsGeometry &geometry : geometries )
795 {
796 QgsFeature _f( createFeature( layer, geometry, attrMap ) );
797 resultFeatures.append( _f );
798 }
799 }
800 else
801 {
802 newF.setGeometry( geometries.at( 0 ) );
803 resultFeatures.append( newF );
804 }
805 }
806 return resultFeatures;
807}
808
809QgsFeatureList QgsVectorLayerUtils::makeFeaturesCompatible( const QgsFeatureList &features, const QgsVectorLayer *layer, QgsFeatureSink::SinkFlags sinkFlags )
810{
811 QgsFeatureList resultFeatures;
812 for ( const QgsFeature &f : features )
813 {
814 const QgsFeatureList features( makeFeatureCompatible( f, layer, sinkFlags ) );
815 for ( const auto &_f : features )
816 {
817 resultFeatures.append( _f );
818 }
819 }
820 return resultFeatures;
821}
822
824{
825 QList<QgsVectorLayer *> layers;
826 QMap<QgsVectorLayer *, QgsFeatureIds>::const_iterator i;
827 for ( i = mDuplicatedFeatures.begin(); i != mDuplicatedFeatures.end(); ++i )
828 layers.append( i.key() );
829 return layers;
830}
831
833{
834 return mDuplicatedFeatures[layer];
835}
836
837void QgsVectorLayerUtils::QgsDuplicateFeatureContext::setDuplicatedFeatures( QgsVectorLayer *layer, const QgsFeatureIds &ids )
838{
839 if ( mDuplicatedFeatures.contains( layer ) )
840 mDuplicatedFeatures[layer] += ids;
841 else
842 mDuplicatedFeatures.insert( layer, ids );
843}
844/*
845QMap<QgsVectorLayer *, QgsFeatureIds> QgsVectorLayerUtils::QgsDuplicateFeatureContext::duplicateFeatureContext() const
846{
847 return mDuplicatedFeatures;
848}
849*/
850
852 mGeometry( geometry ),
853 mAttributes( attributes )
854{}
855
857{
858 return mGeometry;
859}
860
862{
863 return mAttributes;
864}
865
866bool _fieldIsEditable( const QgsVectorLayer *layer, int fieldIndex, const QgsFeature &feature )
867{
868 return layer->isEditable() &&
869 !layer->editFormConfig().readOnly( fieldIndex ) &&
870 // Provider permissions
871 layer->dataProvider() &&
873 ( layer->dataProvider()->capabilities() & QgsVectorDataProvider::AddFeatures && ( FID_IS_NULL( feature.id() ) || FID_IS_NEW( feature.id() ) ) ) ) &&
874 // Field must not be read only
875 !layer->fields().at( fieldIndex ).isReadOnly();
876}
877
878bool QgsVectorLayerUtils::fieldIsReadOnly( const QgsVectorLayer *layer, int fieldIndex )
879{
880 if ( layer->fields().fieldOrigin( fieldIndex ) == QgsFields::OriginJoin )
881 {
882 int srcFieldIndex;
883 const QgsVectorLayerJoinInfo *info = layer->joinBuffer()->joinForFieldIndex( fieldIndex, layer->fields(), srcFieldIndex );
884
885 if ( !info || !info->isEditable() || !info->joinLayer() )
886 return true;
887
888 return fieldIsReadOnly( info->joinLayer(), srcFieldIndex );
889 }
890 else
891 {
892 // any of these properties makes the field read only
893 if ( !layer->isEditable() ||
894 layer->editFormConfig().readOnly( fieldIndex ) ||
895 !layer->dataProvider() ||
898 layer->fields().at( fieldIndex ).isReadOnly() )
899 return true;
900
901 return false;
902 }
903}
904
906{
907 // editability will vary feature-by-feature only for joined fields
908 if ( layer->fields().fieldOrigin( fieldIndex ) == QgsFields::OriginJoin )
909 {
910 int srcFieldIndex;
911 const QgsVectorLayerJoinInfo *info = layer->joinBuffer()->joinForFieldIndex( fieldIndex, layer->fields(), srcFieldIndex );
912
913 if ( !info || !info->isEditable() || info->hasUpsertOnEdit() )
914 return false;
915
916 // join does not have upsert capabilities, so the ability to edit the joined field will
917 // vary feature-by-feature, depending on whether the join target feature already exists
918 return true;
919 }
920 else
921 {
922 return false;
923 }
924}
925
926bool QgsVectorLayerUtils::fieldIsEditable( const QgsVectorLayer *layer, int fieldIndex, const QgsFeature &feature )
927{
928 if ( layer->fields().fieldOrigin( fieldIndex ) == QgsFields::OriginJoin )
929 {
930 int srcFieldIndex;
931 const QgsVectorLayerJoinInfo *info = layer->joinBuffer()->joinForFieldIndex( fieldIndex, layer->fields(), srcFieldIndex );
932
933 if ( !info || !info->isEditable() )
934 return false;
935
936 // check that joined feature exist, else it is not editable
937 if ( !info->hasUpsertOnEdit() )
938 {
939 const QgsFeature joinedFeature = layer->joinBuffer()->joinedFeatureOf( info, feature );
940 if ( !joinedFeature.isValid() )
941 return false;
942 }
943
944 return _fieldIsEditable( info->joinLayer(), srcFieldIndex, feature );
945 }
946 else
947 return _fieldIsEditable( layer, fieldIndex, feature );
948}
949
950
951QHash<QString, QgsMaskedLayers> QgsVectorLayerUtils::labelMasks( const QgsVectorLayer *layer )
952{
953 class LabelMasksVisitor : public QgsStyleEntityVisitorInterface
954 {
955 public:
956 bool visitEnter( const QgsStyleEntityVisitorInterface::Node &node ) override
957 {
959 {
960 currentRule = node.identifier;
961 return true;
962 }
963 return false;
964 }
965 bool visit( const QgsStyleEntityVisitorInterface::StyleLeaf &leaf ) override
966 {
967 if ( leaf.entity && leaf.entity->type() == QgsStyle::LabelSettingsEntity )
968 {
969 auto labelSettingsEntity = static_cast<const QgsStyleLabelSettingsEntity *>( leaf.entity );
970 const QgsTextMaskSettings &maskSettings = labelSettingsEntity->settings().format().mask();
971 if ( maskSettings.enabled() )
972 {
973 // transparency is considered has effects because it implies rasterization when masking
974 // is involved
975 const bool hasEffects = maskSettings.opacity() < 1 ||
976 ( maskSettings.paintEffect() && maskSettings.paintEffect()->enabled() );
977 for ( const auto &r : maskSettings.maskedSymbolLayers() )
978 {
979 QgsMaskedLayer &maskedLayer = maskedLayers[currentRule][r.layerId()];
980 maskedLayer.symbolLayerIds.insert( r.symbolLayerIdV2() );
981 maskedLayer.hasEffects = hasEffects;
982 }
983 }
984 }
985 return true;
986 }
987
988 QHash<QString, QgsMaskedLayers> maskedLayers;
989 // Current label rule, empty string for a simple labeling
990 QString currentRule;
991 };
992
993 if ( ! layer->labeling() )
994 return {};
995
996 LabelMasksVisitor visitor;
997 layer->labeling()->accept( &visitor );
998 return std::move( visitor.maskedLayers );
999}
1000
1002{
1003 if ( ! layer->renderer() )
1004 return {};
1005
1006 class SymbolLayerVisitor : public QgsStyleEntityVisitorInterface
1007 {
1008 public:
1009 bool visitEnter( const QgsStyleEntityVisitorInterface::Node &node ) override
1010 {
1012 }
1013
1014 // Returns true if the visited symbol has effects
1015 bool visitSymbol( const QgsSymbol *symbol )
1016 {
1017 // transparency is considered has effects because it implies rasterization when masking
1018 // is involved
1019 bool symbolHasEffect = symbol->opacity() < 1;
1020 for ( int idx = 0; idx < symbol->symbolLayerCount(); idx++ )
1021 {
1022 const QgsSymbolLayer *sl = symbol->symbolLayer( idx );
1023 bool slHasEffects = sl->paintEffect() && sl->paintEffect()->enabled();
1024 symbolHasEffect |= slHasEffects;
1025
1026 // recurse over sub symbols
1027 const QgsSymbol *subSymbol = const_cast<QgsSymbolLayer *>( sl )->subSymbol();
1028 if ( subSymbol )
1029 slHasEffects |= visitSymbol( subSymbol );
1030
1031 for ( const auto &mask : sl->masks() )
1032 {
1033 QgsMaskedLayer &maskedLayer = maskedLayers[mask.layerId()];
1034 maskedLayer.hasEffects |= slHasEffects;
1035 maskedLayer.symbolLayerIds.insert( mask.symbolLayerIdV2() );
1036 }
1037 }
1038
1039 return symbolHasEffect;
1040 }
1041
1042 bool visit( const QgsStyleEntityVisitorInterface::StyleLeaf &leaf ) override
1043 {
1044 if ( leaf.entity && leaf.entity->type() == QgsStyle::SymbolEntity )
1045 {
1046 auto symbolEntity = static_cast<const QgsStyleSymbolEntity *>( leaf.entity );
1047 if ( symbolEntity->symbol() )
1048 visitSymbol( symbolEntity->symbol() );
1049 }
1050 return true;
1051 }
1052 QgsMaskedLayers maskedLayers;
1053 };
1054
1055 SymbolLayerVisitor visitor;
1056 layer->renderer()->accept( &visitor );
1057 return visitor.maskedLayers;
1058}
1059
1061{
1063
1064 QgsExpression exp( layer->displayExpression() );
1065 context.setFeature( feature );
1066 exp.prepare( &context );
1067 QString displayString = exp.evaluate( &context ).toString();
1068
1069 return displayString;
1070}
1071
1072bool QgsVectorLayerUtils::impactsCascadeFeatures( const QgsVectorLayer *layer, const QgsFeatureIds &fids, const QgsProject *project, QgsDuplicateFeatureContext &context, CascadedFeatureFlags flags )
1073{
1074 if ( !layer )
1075 return false;
1076
1077 const QList<QgsRelation> relations = project->relationManager()->referencedRelations( layer );
1078 for ( const QgsRelation &relation : relations )
1079 {
1080 switch ( relation.strength() )
1081 {
1083 {
1084 QgsFeatureIds childFeatureIds;
1085
1086 const auto constFids = fids;
1087 for ( const QgsFeatureId fid : constFids )
1088 {
1089 //get features connected over this relation
1090 QgsFeatureIterator relatedFeaturesIt = relation.getRelatedFeatures( layer->getFeature( fid ) );
1091 QgsFeature childFeature;
1092 while ( relatedFeaturesIt.nextFeature( childFeature ) )
1093 {
1094 childFeatureIds.insert( childFeature.id() );
1095 }
1096 }
1097
1098 if ( childFeatureIds.count() > 0 )
1099 {
1100 if ( context.layers().contains( relation.referencingLayer() ) )
1101 {
1102 QgsFeatureIds handledFeatureIds = context.duplicatedFeatures( relation.referencingLayer() );
1103 // add feature ids
1104 handledFeatureIds.unite( childFeatureIds );
1105 context.setDuplicatedFeatures( relation.referencingLayer(), handledFeatureIds );
1106 }
1107 else
1108 {
1109 // add layer and feature id
1110 context.setDuplicatedFeatures( relation.referencingLayer(), childFeatureIds );
1111 }
1112 }
1113 break;
1114 }
1115
1117 break;
1118 }
1119 }
1120
1121 if ( layer->joinBuffer()->containsJoins() )
1122 {
1123 const QgsVectorJoinList joins = layer->joinBuffer()->vectorJoins();
1124 for ( const QgsVectorLayerJoinInfo &info : joins )
1125 {
1126 if ( qobject_cast< QgsAuxiliaryLayer * >( info.joinLayer() ) && flags & IgnoreAuxiliaryLayers )
1127 continue;
1128
1129 if ( info.isEditable() && info.hasCascadedDelete() )
1130 {
1131 QgsFeatureIds joinFeatureIds;
1132 const auto constFids = fids;
1133 for ( const QgsFeatureId &fid : constFids )
1134 {
1135 const QgsFeature joinFeature = layer->joinBuffer()->joinedFeatureOf( &info, layer->getFeature( fid ) );
1136 if ( joinFeature.isValid() )
1137 joinFeatureIds.insert( joinFeature.id() );
1138 }
1139
1140 if ( joinFeatureIds.count() > 0 )
1141 {
1142 if ( context.layers().contains( info.joinLayer() ) )
1143 {
1144 QgsFeatureIds handledFeatureIds = context.duplicatedFeatures( info.joinLayer() );
1145 // add feature ids
1146 handledFeatureIds.unite( joinFeatureIds );
1147 context.setDuplicatedFeatures( info.joinLayer(), handledFeatureIds );
1148 }
1149 else
1150 {
1151 // add layer and feature id
1152 context.setDuplicatedFeatures( info.joinLayer(), joinFeatureIds );
1153 }
1154 }
1155 }
1156 }
1157 }
1158
1159 return !context.layers().isEmpty();
1160}
1161
1162QString QgsVectorLayerUtils::guessFriendlyIdentifierField( const QgsFields &fields, bool *foundFriendly )
1163{
1164 if ( foundFriendly )
1165 *foundFriendly = false;
1166
1167 if ( fields.isEmpty() )
1168 return QString();
1169
1170 // Check the fields and keep the first one that matches.
1171 // We assume that the user has organized the data with the
1172 // more "interesting" field names first. As such, name should
1173 // be selected before oldname, othername, etc.
1174 // This candidates list is a prioritized list of candidates ranked by "interestingness"!
1175 // See discussion at https://github.com/qgis/QGIS/pull/30245 - this list must NOT be translated,
1176 // but adding hardcoded localized variants of the strings is encouraged.
1177 static QStringList sCandidates{ QStringLiteral( "name" ),
1178 QStringLiteral( "title" ),
1179 QStringLiteral( "heibt" ),
1180 QStringLiteral( "desc" ),
1181 QStringLiteral( "nom" ),
1182 QStringLiteral( "street" ),
1183 QStringLiteral( "road" ),
1184 QStringLiteral( "label" ),
1185 // German candidates
1186 QStringLiteral( "titel" ), //#spellok
1187 QStringLiteral( "beschreibung" ),
1188 QStringLiteral( "strasse" ),
1189 QStringLiteral( "beschriftung" ) };
1190
1191 // anti-names
1192 // this list of strings indicates parts of field names which make the name "less interesting".
1193 // For instance, we'd normally like to default to a field called "name" or "title", but if instead we
1194 // find one called "typename" or "typeid", then that's most likely a classification of the feature and not the
1195 // best choice to default to
1196 static QStringList sAntiCandidates{ QStringLiteral( "type" ),
1197 QStringLiteral( "class" ),
1198 QStringLiteral( "cat" ),
1199 // German anti-candidates
1200 QStringLiteral( "typ" ),
1201 QStringLiteral( "klasse" ),
1202 QStringLiteral( "kategorie" )
1203 };
1204
1205 QString bestCandidateName;
1206 QString bestCandidateNameWithAntiCandidate;
1207
1208 for ( const QString &candidate : sCandidates )
1209 {
1210 for ( const QgsField &field : fields )
1211 {
1212 const QString fldName = field.name();
1213 if ( fldName.contains( candidate, Qt::CaseInsensitive ) )
1214 {
1215 bool isAntiCandidate = false;
1216 for ( const QString &antiCandidate : sAntiCandidates )
1217 {
1218 if ( fldName.contains( antiCandidate, Qt::CaseInsensitive ) )
1219 {
1220 isAntiCandidate = true;
1221 break;
1222 }
1223 }
1224
1225 if ( isAntiCandidate )
1226 {
1227 if ( bestCandidateNameWithAntiCandidate.isEmpty() )
1228 {
1229 bestCandidateNameWithAntiCandidate = fldName;
1230 }
1231 }
1232 else
1233 {
1234 bestCandidateName = fldName;
1235 break;
1236 }
1237 }
1238 }
1239
1240 if ( !bestCandidateName.isEmpty() )
1241 break;
1242 }
1243
1244 const QString candidateName = bestCandidateName.isEmpty() ? bestCandidateNameWithAntiCandidate : bestCandidateName;
1245 if ( !candidateName.isEmpty() )
1246 {
1247 if ( foundFriendly )
1248 *foundFriendly = true;
1249 return candidateName;
1250 }
1251 else
1252 {
1253 // no good matches found by name, so scan through and look for the first string field
1254 for ( const QgsField &field : fields )
1255 {
1256 if ( field.type() == QVariant::String )
1257 return field.name();
1258 }
1259
1260 // no string fields found - just return first field
1261 return fields.at( 0 ).name();
1262 }
1263}
@ Composition
Fix relation, related elements are part of the parent and a parent copy will copy any children or del...
@ Association
Loose relation, related elements are not part of the parent and a parent copy will not copy any child...
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:255
@ Unknown
Unknown types.
@ Null
No geometry.
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:182
@ NoGeometry
No geometry.
@ Unknown
Unknown.
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified symbology visitor, causing it to visit all symbols associated with the labeling...
A vector of attributes.
CORE_EXPORT QgsAttributeMap toMap() const
Returns a QgsAttributeMap of the attribute values.
The QgsDefaultValue class provides a container for managing client side default values for fields.
bool isValid() const
Returns if this default value should be applied.
bool readOnly(int idx) const
This returns true if the field is manually set to read only or if the field does not support editing ...
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
void appendScopes(const QList< QgsExpressionContextScope * > &scopes)
Appends a list of scopes to the end of the context.
Class for parsing and evaluation of expressions (formerly called "search strings").
bool prepare(const QgsExpressionContext *context)
Gets the expression ready for evaluation - find out column indexes.
static QString quotedValue(const QVariant &value)
Returns a string representation of a literal value, including appropriate quotations where required.
bool hasParserError() const
Returns true if an error occurred when parsing the input expression.
QString evalErrorString() const
Returns evaluation error.
QString parserErrorString() const
Returns parser error.
static QString quotedColumnRef(QString name)
Returns a quoted column reference (in double quotes)
bool hasEvalError() const
Returns true if an error occurred when evaluating last input.
QVariant evaluate()
Evaluate the feature and return the result.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified symbology visitor, causing it to visit all symbols associated with the renderer...
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setLimit(long long limit)
Set the maximum number of features to request.
QgsFeatureRequest & setFlags(QgsFeatureRequest::Flags flags)
Sets flags that affect how features will be fetched.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
QgsFeatureRequest & setNoAttributes()
Set that no attributes will be fetched.
@ RegeneratePrimaryKey
This flag indicates, that a primary key field cannot be guaranteed to be unique and the sink should i...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:56
bool setAttribute(int field, const QVariant &attr)
Sets an attribute's value by field index.
QgsAttributes attributes
Definition qgsfeature.h:65
QgsFields fields
Definition qgsfeature.h:66
void initAttributes(int fieldCount)
Initialize this feature with the given number of fields.
QgsFeatureId id
Definition qgsfeature.h:64
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
void setFields(const QgsFields &fields, bool initAttributes=false)
Assigns a field map with the feature to allow attribute access by attribute name.
QgsGeometry geometry
Definition qgsfeature.h:67
void setValid(bool validity)
Sets the validity of the feature.
bool isValid() const
Returns the validity of this feature.
QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:45
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:54
Stores information about constraints which may be present on a field.
ConstraintStrength
Strength of constraints.
@ ConstraintStrengthNotSet
Constraint is not set.
ConstraintOrigin
Origin of constraints.
@ ConstraintOriginNotSet
Constraint is not set.
@ ConstraintOriginProvider
Constraint was set at data provider.
ConstraintStrength constraintStrength(Constraint constraint) const
Returns the strength of a field constraint, or ConstraintStrengthNotSet if the constraint is not pres...
ConstraintOrigin constraintOrigin(Constraint constraint) const
Returns the origin of a field constraint, or ConstraintOriginNotSet if the constraint is not present ...
QString constraintExpression() const
Returns the constraint expression for the field, if set.
@ ConstraintNotNull
Field may not be null.
@ ConstraintUnique
Field must have a unique value.
@ ConstraintExpression
Field has an expression constraint set. See constraintExpression().
QString constraintDescription() const
Returns the descriptive name for the constraint expression.
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
QString name
Definition qgsfield.h:62
bool convertCompatible(QVariant &v, QString *errorMessage=nullptr) const
Converts the provided variant to a compatible format.
Definition qgsfield.cpp:452
QVariant::Type type
Definition qgsfield.h:60
bool isNumeric
Definition qgsfield.h:56
QgsFieldConstraints constraints
Definition qgsfield.h:65
bool isReadOnly
Definition qgsfield.h:67
Container of fields for a vector layer.
Definition qgsfields.h:45
@ OriginJoin
Field comes from a joined layer (originIndex / 1000 = index of the join, originIndex % 1000 = index w...
Definition qgsfields.h:52
@ OriginProvider
Field comes from the underlying data provider of the vector layer (originIndex = index in provider's ...
Definition qgsfields.h:51
int count() const
Returns number of items.
FieldOrigin fieldOrigin(int fieldIdx) const
Returns the field's origin (value from an enumeration).
bool isEmpty() const
Checks whether the container is empty.
int size() const
Returns number of items.
QgsField at(int i) const
Returns the field at particular index (must be in range 0..N-1).
int fieldOriginIndex(int fieldIdx) const
Returns the field's origin index (its meaning is specific to each type of origin).
int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
A geometry is the spatial representation of a feature.
QVector< QgsGeometry > coerceToType(Qgis::WkbType type, double defaultZ=0, double defaultM=0) const
Attempts to coerce this geometry into the specified destination type.
Qgis::WkbType wkbType() const
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
bool enabled() const
Returns whether the effect is enabled.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
QgsRelationManager * relationManager
Definition qgsproject.h:117
QList< QgsRelation > referencedRelations(const QgsVectorLayer *layer=nullptr) const
Gets all relations where this layer is the referenced part (i.e.
Defines a relation between matching fields of the two involved tables of a relation.
Definition qgsrelation.h:67
virtual QgsStyle::StyleEntity type() const =0
Returns the type of style entity.
An interface for classes which can visit style entity (e.g.
@ SymbolRule
Rule based symbology or label child rule.
A label settings entity for QgsStyle databases.
Definition qgsstyle.h:1434
A symbol entity for QgsStyle databases.
Definition qgsstyle.h:1341
@ LabelSettingsEntity
Label settings.
Definition qgsstyle.h:185
@ SymbolEntity
Symbols.
Definition qgsstyle.h:180
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
virtual QList< QgsSymbolLayerReference > masks() const
Returns masks defined by this symbol layer.
Abstract base class for all rendered symbols.
Definition qgssymbol.h:94
QgsSymbolLayer * symbolLayer(int layer)
Returns the symbol layer at the specified index.
qreal opacity() const
Returns the opacity for the symbol.
Definition qgssymbol.h:497
int symbolLayerCount() const
Returns the total number of symbol layers contained in the symbol.
Definition qgssymbol.h:216
Container for settings relating to a selective masking around a text.
QList< QgsSymbolLayerReference > maskedSymbolLayers() const
Returns a list of references to symbol layers that are masked by this buffer.
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the mask.
double opacity() const
Returns the mask's opacity.
bool enabled() const
Returns whether the mask is enabled.
static bool runOnMainThread(const Func &func, QgsFeedback *feedback=nullptr)
Guarantees that func is executed on the main thread.
static bool isNull(const QVariant &variant)
Returns true if the specified variant should be considered a NULL value.
@ ChangeAttributeValues
Allows modification of attribute values.
@ AddFeatures
Allows adding features.
virtual QgsAttributeList pkAttributeIndexes() const
Returns list of indexes of fields that make up the primary key.
virtual QString defaultValueClause(int fieldIndex) const
Returns any default value clauses which are present at the provider for a specified field index.
virtual QVariant defaultValue(int fieldIndex) const
Returns any literal default values which are present at the provider for a specified field index.
virtual Q_INVOKABLE QgsVectorDataProvider::Capabilities capabilities() const
Returns flags containing the supported capabilities.
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...
Partial snapshot of vector layer's state (only the members necessary for access to features)
const QgsVectorLayerJoinInfo * joinForFieldIndex(int index, const QgsFields &fields, int &sourceFieldIndex) const
Finds the vector join for a layer field index.
bool containsJoins() const
Quick way to test if there is any join at all.
QgsFeature joinedFeatureOf(const QgsVectorLayerJoinInfo *info, const QgsFeature &feature) const
Returns the joined feature corresponding to the feature.
const QgsVectorJoinList & vectorJoins() const
Defines left outer join from our vector layer to some other vector layer.
bool hasUpsertOnEdit() const
Returns whether a feature created on the target layer has to impact the joined layer by creating a ne...
bool isEditable() const
Returns whether joined fields may be edited through the form of the target layer.
QgsVectorLayer * joinLayer() const
Returns joined layer (may be nullptr if the reference was set by layer ID and not resolved yet)
Contains mainly the QMap with QgsVectorLayer and QgsFeatureIds do list all the duplicated features.
QgsFeatureIds duplicatedFeatures(QgsVectorLayer *layer) const
Returns the duplicated features in the given layer.
QList< QgsVectorLayer * > layers() const
Returns all the layers on which features have been duplicated.
Encapsulate geometry and attributes for new features, to be passed to createFeatures.
QgsGeometry geometry() const
Returns geometry.
QgsAttributeMap attributes() const
Returns attributes.
QgsFeatureData(const QgsGeometry &geometry=QgsGeometry(), const QgsAttributeMap &attributes=QgsAttributeMap())
Constructs a new QgsFeatureData with given geometry and attributes.
static QgsFeature duplicateFeature(QgsVectorLayer *layer, const QgsFeature &feature, QgsProject *project, QgsDuplicateFeatureContext &duplicateFeatureContext, const int maxDepth=0, int depth=0, QList< QgsVectorLayer * > referencedLayersBranch=QList< QgsVectorLayer * >())
Duplicates a feature and it's children (one level deep).
QList< QgsVectorLayerUtils::QgsFeatureData > QgsFeaturesDataList
Alias for list of QgsFeatureData.
static bool valueExists(const QgsVectorLayer *layer, int fieldIndex, const QVariant &value, const QgsFeatureIds &ignoreIds=QgsFeatureIds())
Returns true if the specified value already exists within a field.
static QgsFeatureList makeFeatureCompatible(const QgsFeature &feature, const QgsVectorLayer *layer, QgsFeatureSink::SinkFlags sinkFlags=QgsFeatureSink::SinkFlags())
Converts input feature to be compatible with the given layer.
static QgsMaskedLayers symbolLayerMasks(const QgsVectorLayer *)
Returns all masks that may be defined on symbol layers for a given vector layer.
static QString guessFriendlyIdentifierField(const QgsFields &fields, bool *foundFriendly=nullptr)
Given a set of fields, attempts to pick the "most useful" field for user-friendly identification of f...
static QgsFeatureIterator getValuesIterator(const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly)
Create a feature iterator for a specified field name or expression.
static bool fieldEditabilityDependsOnFeature(const QgsVectorLayer *layer, int fieldIndex)
Returns true if the editability of the field at index fieldIndex from layer may vary feature by featu...
static QgsFeatureList makeFeaturesCompatible(const QgsFeatureList &features, const QgsVectorLayer *layer, QgsFeatureSink::SinkFlags sinkFlags=QgsFeatureSink::SinkFlags())
Converts input features to be compatible with the given layer.
static std::unique_ptr< QgsVectorLayerFeatureSource > getFeatureSource(QPointer< QgsVectorLayer > layer, QgsFeedback *feedback=nullptr)
Gets the feature source from a QgsVectorLayer pointer.
static QString getFeatureDisplayString(const QgsVectorLayer *layer, const QgsFeature &feature)
static QgsFeature createFeature(const QgsVectorLayer *layer, const QgsGeometry &geometry=QgsGeometry(), const QgsAttributeMap &attributes=QgsAttributeMap(), QgsExpressionContext *context=nullptr)
Creates a new feature ready for insertion into a layer.
static bool fieldIsEditable(const QgsVectorLayer *layer, int fieldIndex, const QgsFeature &feature)
Tests whether a field is editable for a particular feature.
static bool attributeHasConstraints(const QgsVectorLayer *layer, int attributeIndex)
Returns true if a feature attribute has active constraints.
static QList< double > getDoubleValues(const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly=false, int *nullCount=nullptr, QgsFeedback *feedback=nullptr)
Fetches all double values from a specified field name or expression.
static bool fieldIsReadOnly(const QgsVectorLayer *layer, int fieldIndex)
static QHash< QString, QgsMaskedLayers > labelMasks(const QgsVectorLayer *)
Returns masks defined in labeling options of a layer.
static QgsFeatureList createFeatures(const QgsVectorLayer *layer, const QgsFeaturesDataList &featuresData, QgsExpressionContext *context=nullptr)
Creates a set of new features ready for insertion into a layer.
static QVariant createUniqueValue(const QgsVectorLayer *layer, int fieldIndex, const QVariant &seed=QVariant())
Returns a new attribute value for the specified field index which is guaranteed to be unique.
static bool impactsCascadeFeatures(const QgsVectorLayer *layer, const QgsFeatureIds &fids, const QgsProject *project, QgsDuplicateFeatureContext &context, QgsVectorLayerUtils::CascadedFeatureFlags flags=QgsVectorLayerUtils::CascadedFeatureFlags())
static QList< QVariant > getValues(const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly=false, QgsFeedback *feedback=nullptr)
Fetches all values from a specified field name or expression.
static QVariant createUniqueValueFromCache(const QgsVectorLayer *layer, int fieldIndex, const QSet< QVariant > &existingValues, const QVariant &seed=QVariant())
Returns a new attribute value for the specified field index which is guaranteed to be unique within r...
static bool validateAttribute(const QgsVectorLayer *layer, const QgsFeature &feature, int attributeIndex, QStringList &errors, QgsFieldConstraints::ConstraintStrength strength=QgsFieldConstraints::ConstraintStrengthNotSet, QgsFieldConstraints::ConstraintOrigin origin=QgsFieldConstraints::ConstraintOriginNotSet)
Tests a feature attribute value to check whether it passes all constraints which are present on the c...
static void matchAttributesToFields(QgsFeature &feature, const QgsFields &fields)
Matches the attributes in feature to the specified fields.
@ IgnoreAuxiliaryLayers
Ignore auxiliary layers.
Represents a vector layer which manages a vector based data sets.
QVariant maximumValue(int index) const FINAL
Returns the maximum value for an attribute column or an invalid variant in case of error.
QgsDefaultValue defaultValueDefinition(int index) const
Returns the definition of the expression used when calculating the default value for a field.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
QgsFields fields() const FINAL
Returns the list of fields of this layer.
QgsExpressionContext createExpressionContext() const FINAL
This method needs to be reimplemented in all classes which implement this interface and return an exp...
const QgsAbstractVectorLayerLabeling * labeling() const
Access to const labeling configuration.
bool isEditable() const FINAL
Returns true if the provider is in editing mode.
Q_INVOKABLE Qgis::WkbType wkbType() const FINAL
Returns the WKBType or WKBUnknown in case of error.
QgsFeatureRenderer * renderer()
Returns the feature renderer used for rendering the features in the layer in 2D map views.
QString displayExpression
QgsFeatureIterator getSelectedFeatures(QgsFeatureRequest request=QgsFeatureRequest()) const
Returns an iterator of the selected features.
QgsVectorDataProvider * dataProvider() FINAL
Returns the layer's data provider, it may be nullptr.
QgsVectorLayerJoinBuffer * joinBuffer()
Returns the join buffer object.
QgsVectorLayer * clone() const override
Returns a new instance equivalent to this one.
QgsFeature getFeature(QgsFeatureId fid) const
Queries the layer for the feature with the given id.
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.
bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) FINAL
Adds a single feature to the sink.
virtual bool setSubsetString(const QString &subset)
Sets the string (typically sql) used to define a subset of the layer.
QVariant defaultValue(int index, const QgsFeature &feature=QgsFeature(), QgsExpressionContext *context=nullptr) const
Returns the calculated default value for the specified field index.
QgsEditFormConfig editFormConfig
QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const FINAL
Calculates a list of unique values contained within an attribute in the layer.
static Qgis::GeometryType geometryType(Qgis::WkbType type)
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
QMap< int, QVariant > QgsAttributeMap
QList< QgsFeature > QgsFeatureList
Definition qgsfeature.h:920
#define FID_IS_NULL(fid)
QSet< QgsFeatureId > QgsFeatureIds
#define FID_IS_NEW(fid)
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
QList< int > QgsAttributeList
Definition qgsfield.h:27
QList< QgsVectorLayerJoinInfo > QgsVectorJoinList
bool _fieldIsEditable(const QgsVectorLayer *layer, int fieldIndex, const QgsFeature &feature)
QHash< QString, QgsMaskedLayer > QgsMaskedLayers
masked layers where key is the layer id
QSet< QString > symbolLayerIds
Contains information relating to a node (i.e.
QString identifier
A string identifying the node.
QgsStyleEntityVisitorInterface::NodeType type
Node type.
Contains information relating to the style entity currently being visited.
const QgsStyleEntityInterface * entity
Reference to style entity being visited.