QGIS API Documentation 3.39.0-Master (67e056379ed)
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
99QgsJoinByAttributeAlgorithm *QgsJoinByAttributeAlgorithm::createInstance() const
100{
101 return new QgsJoinByAttributeAlgorithm();
102}
103
104QVariantMap QgsJoinByAttributeAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
105{
106 const int joinMethod = parameterAsEnum( parameters, QStringLiteral( "METHOD" ), context );
107 const bool discardNonMatching = parameterAsBoolean( parameters, QStringLiteral( "DISCARD_NONMATCHING" ), context );
108
109 std::unique_ptr< QgsProcessingFeatureSource > input( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
110 if ( !input )
111 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
112
113 std::unique_ptr< QgsProcessingFeatureSource > input2( parameterAsSource( parameters, QStringLiteral( "INPUT_2" ), context ) );
114 if ( !input2 )
115 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT_2" ) ) );
116
117 const QString prefix = parameterAsString( parameters, QStringLiteral( "PREFIX" ), context );
118
119 const QString field1Name = parameterAsString( parameters, QStringLiteral( "FIELD" ), context );
120 const QString field2Name = parameterAsString( parameters, QStringLiteral( "FIELD_2" ), context );
121 const QStringList fieldsToCopy = parameterAsStrings( parameters, QStringLiteral( "FIELDS_TO_COPY" ), context );
122
123 const int joinField1Index = input->fields().lookupField( field1Name );
124 if ( joinField1Index < 0 )
125 throw QgsProcessingException( QObject::tr( "Invalid join field from layer 1: “%1” does not exist" ).arg( field1Name ) );
126
127 const int joinField2Index = input2->fields().lookupField( field2Name );
128 if ( joinField2Index < 0 )
129 throw QgsProcessingException( QObject::tr( "Invalid join field from layer 2: “%1” does not exist" ).arg( field2Name ) );
130
131 QgsFields outFields2;
132 QgsAttributeList fields2Indices;
133 if ( fieldsToCopy.empty() )
134 {
135 outFields2 = input2->fields();
136 fields2Indices.reserve( outFields2.count() );
137 for ( int i = 0; i < outFields2.count(); ++i )
138 {
139 fields2Indices << i;
140 }
141 }
142 else
143 {
144 fields2Indices.reserve( fieldsToCopy.count() );
145 for ( const QString &field : fieldsToCopy )
146 {
147 const int index = input2->fields().lookupField( field );
148 if ( index >= 0 )
149 {
150 fields2Indices << index;
151 outFields2.append( input2->fields().at( index ) );
152 }
153 }
154 }
155
156 if ( !prefix.isEmpty() )
157 {
158 for ( int i = 0; i < outFields2.count(); ++i )
159 {
160 outFields2.rename( i, prefix + outFields2[ i ].name() );
161 }
162 }
163
164 QgsAttributeList fields2Fetch = fields2Indices;
165 fields2Fetch << joinField2Index;
166
167 const QgsFields outFields = QgsProcessingUtils::combineFields( input->fields(), outFields2 );
168
169 QString dest;
170 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, outFields,
171 input->wkbType(), input->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
172 if ( parameters.value( QStringLiteral( "OUTPUT" ) ).isValid() && !sink )
173 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
174
175 QString destNonMatching1;
176 std::unique_ptr< QgsFeatureSink > sinkNonMatching1( parameterAsSink( parameters, QStringLiteral( "NON_MATCHING" ), context, destNonMatching1, input->fields(),
177 input->wkbType(), input->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
178 if ( parameters.value( QStringLiteral( "NON_MATCHING" ) ).isValid() && !sinkNonMatching1 )
179 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "NON_MATCHING" ) ) );
180
181 // cache attributes of input2
182 QMultiHash< QVariant, QgsAttributes > input2AttributeCache;
183 QgsFeatureIterator features = input2->getFeatures( QgsFeatureRequest().setFlags( Qgis::FeatureRequestFlag::NoGeometry ).setSubsetOfAttributes( fields2Fetch ), Qgis::ProcessingFeatureSourceFlag::SkipGeometryValidityChecks );
184 double step = input2->featureCount() > 0 ? 50.0 / input2->featureCount() : 1;
185 int i = 0;
186 QgsFeature feat;
187 while ( features.nextFeature( feat ) )
188 {
189 i++;
190 if ( feedback->isCanceled() )
191 {
192 break;
193 }
194
195 feedback->setProgress( i * step );
196
197 if ( joinMethod == 1 && input2AttributeCache.contains( feat.attribute( joinField2Index ) ) )
198 continue;
199
200 // only keep selected attributes
201 QgsAttributes attributes;
202 const int attributeCount = feat.attributeCount();
203 for ( int j = 0; j < attributeCount; ++j )
204 {
205 if ( ! fields2Indices.contains( j ) )
206 continue;
207 attributes << feat.attribute( j );
208 }
209
210 input2AttributeCache.insert( feat.attribute( joinField2Index ), attributes );
211 }
212
213 // Create output vector layer with additional attribute
214 step = input->featureCount() > 0 ? 50.0 / input->featureCount() : 1;
216 i = 0;
217 long long joinedCount = 0;
218 long long unjoinedCount = 0;
219 while ( features.nextFeature( feat ) )
220 {
221 i++;
222 if ( feedback->isCanceled() )
223 {
224 break;
225 }
226
227 feedback->setProgress( 50 + i * step );
228
229 if ( input2AttributeCache.count( feat.attribute( joinField1Index ) ) > 0 )
230 {
231 joinedCount++;
232 if ( sink )
233 {
234 const QgsAttributes attrs = feat.attributes();
235
236 QList< QgsAttributes > attributes = input2AttributeCache.values( feat.attribute( joinField1Index ) );
237 QList< QgsAttributes >::iterator attrsIt = attributes.begin();
238 for ( ; attrsIt != attributes.end(); ++attrsIt )
239 {
240 QgsAttributes newAttrs = attrs;
241 newAttrs.append( *attrsIt );
242 feat.setAttributes( newAttrs );
243 if ( !sink->addFeature( feat, QgsFeatureSink::FastInsert ) )
244 throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
245 }
246 }
247 }
248 else
249 {
250 // no matching for input feature
251 if ( sink && !discardNonMatching )
252 {
253 if ( !sink->addFeature( feat, QgsFeatureSink::FastInsert ) )
254 throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
255 }
256 if ( sinkNonMatching1 )
257 {
258 if ( !sinkNonMatching1->addFeature( feat, QgsFeatureSink::FastInsert ) )
259 throw QgsProcessingException( writeFeatureError( sinkNonMatching1.get(), parameters, QStringLiteral( "NON_MATCHING" ) ) );
260 }
261 unjoinedCount++;
262 }
263 }
264
265 feedback->pushInfo( QObject::tr( "%n feature(s) from input layer were successfully matched", nullptr, joinedCount ) );
266 if ( unjoinedCount > 0 )
267 feedback->reportError( QObject::tr( "%n feature(s) from input layer could not be matched", nullptr, unjoinedCount ) );
268
269 QVariantMap outputs;
270 if ( sink )
271 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
272 outputs.insert( QStringLiteral( "JOINED_COUNT" ), joinedCount );
273 outputs.insert( QStringLiteral( "UNJOINABLE_COUNT" ), unjoinedCount );
274 if ( sinkNonMatching1 )
275 outputs.insert( QStringLiteral( "NON_MATCHING" ), destNonMatching1 );
276 return outputs;
277}
278
279
@ 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.
@ 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