QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsalgorithmjoinbyattribute.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmjoinbyattribute.cpp
3 ---------------------
4 begin : April 2017
5 copyright : (C) 2017 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
20
22
23QString QgsJoinByAttributeAlgorithm::name() const
24{
25 return QStringLiteral( "joinattributestable" );
26}
27
28QString QgsJoinByAttributeAlgorithm::displayName() const
29{
30 return QObject::tr( "Join attributes by field value" );
31}
32
33QStringList QgsJoinByAttributeAlgorithm::tags() const
34{
35 return QObject::tr( "join,connect,attributes,values,fields,tables" ).split( ',' );
36}
37
38QString QgsJoinByAttributeAlgorithm::group() const
39{
40 return QObject::tr( "Vector general" );
41}
42
43QString QgsJoinByAttributeAlgorithm::groupId() const
44{
45 return QStringLiteral( "vectorgeneral" );
46}
47
48void QgsJoinByAttributeAlgorithm::initAlgorithm( const QVariantMap & )
49{
50 QStringList methods;
51 methods << QObject::tr( "Create separate feature for each matching feature (one-to-many)" )
52 << QObject::tr( "Take attributes of the first matching feature only (one-to-one)" );
53
54 addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ),
55 QObject::tr( "Input layer" ), QList< int>() << static_cast< int >( Qgis::ProcessingSourceType::Vector ) ) );
56 addParameter( new QgsProcessingParameterField( QStringLiteral( "FIELD" ),
57 QObject::tr( "Table field" ), QVariant(), QStringLiteral( "INPUT" ) ) );
58
59 addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT_2" ),
60 QObject::tr( "Input layer 2" ), QList< int>() << static_cast< int >( Qgis::ProcessingSourceType::Vector ) ) );
61 addParameter( new QgsProcessingParameterField( QStringLiteral( "FIELD_2" ),
62 QObject::tr( "Table field 2" ), QVariant(), QStringLiteral( "INPUT_2" ) ) );
63
64 addParameter( new QgsProcessingParameterField( QStringLiteral( "FIELDS_TO_COPY" ),
65 QObject::tr( "Layer 2 fields to copy (leave empty to copy all fields)" ),
66 QVariant(), QStringLiteral( "INPUT_2" ), Qgis::ProcessingFieldParameterDataType::Any,
67 true, true ) );
68
69 addParameter( new QgsProcessingParameterEnum( QStringLiteral( "METHOD" ),
70 QObject::tr( "Join type" ),
71 methods, false, 1 ) );
72 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "DISCARD_NONMATCHING" ),
73 QObject::tr( "Discard records which could not be joined" ),
74 false ) );
75
76 addParameter( new QgsProcessingParameterString( QStringLiteral( "PREFIX" ),
77 QObject::tr( "Joined field prefix" ), QVariant(), false, true ) );
78
79 addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Joined layer" ), Qgis::ProcessingSourceType::VectorAnyGeometry, QVariant(), true, true ) );
80
81 std::unique_ptr< QgsProcessingParameterFeatureSink > nonMatchingSink = std::make_unique< QgsProcessingParameterFeatureSink >(
82 QStringLiteral( "NON_MATCHING" ), QObject::tr( "Unjoinable features from first layer" ), Qgis::ProcessingSourceType::VectorAnyGeometry, QVariant(), true, false );
83 // TODO GUI doesn't support advanced outputs yet
84 //nonMatchingSink->setFlags(nonMatchingSink->flags() | Qgis::ProcessingParameterFlag::Advanced );
85 addParameter( nonMatchingSink.release() );
86
87 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "JOINED_COUNT" ), QObject::tr( "Number of joined features from input table" ) ) );
88 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "UNJOINABLE_COUNT" ), QObject::tr( "Number of unjoinable features from input table" ) ) );
89}
90
91QString QgsJoinByAttributeAlgorithm::shortHelpString() const
92{
93 return QObject::tr( "This algorithm takes an input vector layer and creates a new vector layer that is an extended version of the "
94 "input one, with additional attributes in its attribute table.\n\n"
95 "The additional attributes and their values are taken from a second vector layer. An attribute is selected "
96 "in each of them to define the join criteria." );
97}
98
99Qgis::ProcessingAlgorithmDocumentationFlags QgsJoinByAttributeAlgorithm::documentationFlags() const
100{
102}
103
104QgsJoinByAttributeAlgorithm *QgsJoinByAttributeAlgorithm::createInstance() const
105{
106 return new QgsJoinByAttributeAlgorithm();
107}
108
109QVariantMap QgsJoinByAttributeAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
110{
111 const int joinMethod = parameterAsEnum( parameters, QStringLiteral( "METHOD" ), context );
112 const bool discardNonMatching = parameterAsBoolean( parameters, QStringLiteral( "DISCARD_NONMATCHING" ), context );
113
114 std::unique_ptr< QgsProcessingFeatureSource > input( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
115 if ( !input )
116 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
117
118 std::unique_ptr< QgsProcessingFeatureSource > input2( parameterAsSource( parameters, QStringLiteral( "INPUT_2" ), context ) );
119 if ( !input2 )
120 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT_2" ) ) );
121
122 const QString prefix = parameterAsString( parameters, QStringLiteral( "PREFIX" ), context );
123
124 const QString field1Name = parameterAsString( parameters, QStringLiteral( "FIELD" ), context );
125 const QString field2Name = parameterAsString( parameters, QStringLiteral( "FIELD_2" ), context );
126 const QStringList fieldsToCopy = parameterAsStrings( parameters, QStringLiteral( "FIELDS_TO_COPY" ), context );
127
128 const int joinField1Index = input->fields().lookupField( field1Name );
129 if ( joinField1Index < 0 )
130 throw QgsProcessingException( QObject::tr( "Invalid join field from layer 1: “%1” does not exist" ).arg( field1Name ) );
131
132 const int joinField2Index = input2->fields().lookupField( field2Name );
133 if ( joinField2Index < 0 )
134 throw QgsProcessingException( QObject::tr( "Invalid join field from layer 2: “%1” does not exist" ).arg( field2Name ) );
135
136 QgsFields outFields2;
137 QgsAttributeList fields2Indices;
138 if ( fieldsToCopy.empty() )
139 {
140 outFields2 = input2->fields();
141 fields2Indices.reserve( outFields2.count() );
142 for ( int i = 0; i < outFields2.count(); ++i )
143 {
144 fields2Indices << i;
145 }
146 }
147 else
148 {
149 fields2Indices.reserve( fieldsToCopy.count() );
150 for ( const QString &field : fieldsToCopy )
151 {
152 const int index = input2->fields().lookupField( field );
153 if ( index >= 0 )
154 {
155 fields2Indices << index;
156 outFields2.append( input2->fields().at( index ) );
157 }
158 }
159 }
160
161 if ( !prefix.isEmpty() )
162 {
163 for ( int i = 0; i < outFields2.count(); ++i )
164 {
165 outFields2.rename( i, prefix + outFields2[ i ].name() );
166 }
167 }
168
169 QgsAttributeList fields2Fetch = fields2Indices;
170 fields2Fetch << joinField2Index;
171
172 const QgsFields outFields = QgsProcessingUtils::combineFields( input->fields(), outFields2 );
173
174 QString dest;
175 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, outFields,
176 input->wkbType(), input->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
177 if ( parameters.value( QStringLiteral( "OUTPUT" ) ).isValid() && !sink )
178 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
179
180 QString destNonMatching1;
181 std::unique_ptr< QgsFeatureSink > sinkNonMatching1( parameterAsSink( parameters, QStringLiteral( "NON_MATCHING" ), context, destNonMatching1, input->fields(),
182 input->wkbType(), input->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
183 if ( parameters.value( QStringLiteral( "NON_MATCHING" ) ).isValid() && !sinkNonMatching1 )
184 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "NON_MATCHING" ) ) );
185
186 // cache attributes of input2
187 QMultiHash< QVariant, QgsAttributes > input2AttributeCache;
188 QgsFeatureIterator features = input2->getFeatures( QgsFeatureRequest().setFlags( Qgis::FeatureRequestFlag::NoGeometry ).setSubsetOfAttributes( fields2Fetch ), Qgis::ProcessingFeatureSourceFlag::SkipGeometryValidityChecks );
189 double step = input2->featureCount() > 0 ? 50.0 / input2->featureCount() : 1;
190 int i = 0;
191 QgsFeature feat;
192 while ( features.nextFeature( feat ) )
193 {
194 i++;
195 if ( feedback->isCanceled() )
196 {
197 break;
198 }
199
200 feedback->setProgress( i * step );
201
202 if ( joinMethod == 1 && input2AttributeCache.contains( feat.attribute( joinField2Index ) ) )
203 continue;
204
205 // only keep selected attributes
206 QgsAttributes attributes;
207 const int attributeCount = feat.attributeCount();
208 for ( int j = 0; j < attributeCount; ++j )
209 {
210 if ( ! fields2Indices.contains( j ) )
211 continue;
212 attributes << feat.attribute( j );
213 }
214
215 input2AttributeCache.insert( feat.attribute( joinField2Index ), attributes );
216 }
217
218 // Create output vector layer with additional attribute
219 step = input->featureCount() > 0 ? 50.0 / input->featureCount() : 1;
221 i = 0;
222 long long joinedCount = 0;
223 long long unjoinedCount = 0;
224 while ( features.nextFeature( feat ) )
225 {
226 i++;
227 if ( feedback->isCanceled() )
228 {
229 break;
230 }
231
232 feedback->setProgress( 50 + i * step );
233
234 if ( input2AttributeCache.count( feat.attribute( joinField1Index ) ) > 0 )
235 {
236 joinedCount++;
237 if ( sink )
238 {
239 const QgsAttributes attrs = feat.attributes();
240
241 QList< QgsAttributes > attributes = input2AttributeCache.values( feat.attribute( joinField1Index ) );
242 QList< QgsAttributes >::iterator attrsIt = attributes.begin();
243 for ( ; attrsIt != attributes.end(); ++attrsIt )
244 {
245 QgsAttributes newAttrs = attrs;
246 newAttrs.append( *attrsIt );
247 feat.setAttributes( newAttrs );
248 if ( !sink->addFeature( feat, QgsFeatureSink::FastInsert ) )
249 throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
250 }
251 }
252 }
253 else
254 {
255 // no matching for input feature
256 if ( sink && !discardNonMatching )
257 {
258 if ( !sink->addFeature( feat, QgsFeatureSink::FastInsert ) )
259 throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
260 }
261 if ( sinkNonMatching1 )
262 {
263 if ( !sinkNonMatching1->addFeature( feat, QgsFeatureSink::FastInsert ) )
264 throw QgsProcessingException( writeFeatureError( sinkNonMatching1.get(), parameters, QStringLiteral( "NON_MATCHING" ) ) );
265 }
266 unjoinedCount++;
267 }
268 }
269
270 feedback->pushInfo( QObject::tr( "%n feature(s) from input layer were successfully matched", nullptr, joinedCount ) );
271 if ( unjoinedCount > 0 )
272 feedback->reportError( QObject::tr( "%n feature(s) from input layer could not be matched", nullptr, unjoinedCount ) );
273
274 QVariantMap outputs;
275 if ( sink )
276 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
277 outputs.insert( QStringLiteral( "JOINED_COUNT" ), joinedCount );
278 outputs.insert( QStringLiteral( "UNJOINABLE_COUNT" ), unjoinedCount );
279 if ( sinkNonMatching1 )
280 outputs.insert( QStringLiteral( "NON_MATCHING" ), destNonMatching1 );
281 return outputs;
282}
283
284
@ Vector
Tables (i.e. vector layers with or without geometry). When used for a sink this indicates the sink ha...
@ VectorAnyGeometry
Any vector layer with geometry.
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
@ RegeneratesPrimaryKey
Algorithm always drops any existing primary keys or FID values and regenerates them in outputs.
QFlags< ProcessingAlgorithmDocumentationFlag > ProcessingAlgorithmDocumentationFlags
Flags describing algorithm behavior for documentation purposes.
Definition qgis.h:3359
@ SkipGeometryValidityChecks
Invalid geometry checks should always be skipped. This flag can be useful for algorithms which always...
A vector of attributes.
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.
This class wraps a request for features to a vector layer (or directly its vector data provider).
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
@ 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:58
QgsAttributes attributes
Definition qgsfeature.h:67
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
int attributeCount() const
Returns the number of attributes attached to the feature.
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61
Container of fields for a vector layer.
Definition qgsfields.h:46
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Definition qgsfields.cpp:69
int count
Definition qgsfields.h:50
Q_INVOKABLE int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
bool rename(int fieldIdx, const QString &name)
Renames a name of field.
Contains information about the context in which a processing algorithm is executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void pushInfo(const QString &info)
Pushes a general informational message from the algorithm.
virtual void reportError(const QString &error, bool fatalError=false)
Reports that the algorithm encountered an error while executing.
A numeric output for processing algorithms.
A boolean parameter for processing algorithms.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
A feature sink output for processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
A string parameter for processing algorithms.
static QgsFields combineFields(const QgsFields &fieldsA, const QgsFields &fieldsB, const QString &fieldsBPrefix=QString())
Combines two field lists, avoiding duplicate field names (in a case-insensitive manner).
QList< int > QgsAttributeList
Definition qgsfield.h:27