QGIS API Documentation  3.5.0-Master (bc98f86)
qgsfeaturerequest.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsfeaturerequest.cpp
3  ---------------------
4  begin : Mai 2012
5  copyright : (C) 2012 by Martin Dobias
6  email : wonder dot sk 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 #include "qgsfeaturerequest.h"
16 
17 #include "qgsfields.h"
18 #include "qgsgeometry.h"
19 
20 #include <QStringList>
21 
22 //constants
23 const QString QgsFeatureRequest::ALL_ATTRIBUTES = QStringLiteral( "#!allattributes!#" );
24 
26  : mFlags( nullptr )
27 {
28 }
29 
31  : mFilter( FilterFid )
32  , mFilterFid( fid )
33  , mFlags( nullptr )
34 {
35 }
36 
38  : mFilter( FilterFids )
39  , mFilterFids( fids )
40  , mFlags( nullptr )
41 {
42 
43 }
44 
46  : mFilterRect( rect )
47  , mFlags( nullptr )
48 {
49 }
50 
53  , mFilterExpression( new QgsExpression( expr ) )
54  , mExpressionContext( context )
55  , mFlags( nullptr )
56 {
57 }
58 
60 {
61  operator=( rh );
62 }
63 
65 {
66  mFlags = rh.mFlags;
67  mFilter = rh.mFilter;
71  if ( rh.mFilterExpression )
72  {
74  }
75  else
76  {
77  mFilterExpression.reset( nullptr );
78  }
82  mAttrs = rh.mAttrs;
84  mLimit = rh.mLimit;
85  mOrderBy = rh.mOrderBy;
86  mCrs = rh.mCrs;
88  mTimeout = rh.mTimeout;
90  return *this;
91 }
92 
94 {
95  mFilterRect = rect;
96  return *this;
97 }
98 
100 {
101  mFilter = FilterFid;
102  mFilterFid = fid;
103  return *this;
104 }
105 
107 {
109  mFilterFids = fids;
110  return *this;
111 }
112 
114 {
115  mInvalidGeometryFilter = check;
116  return *this;
117 }
118 
119 QgsFeatureRequest &QgsFeatureRequest::setInvalidGeometryCallback( const std::function<void ( const QgsFeature & )> &callback )
120 {
121  mInvalidGeometryCallback = callback;
122  return *this;
123 }
124 
126 {
128  mFilterExpression.reset( new QgsExpression( expression ) );
129  return *this;
130 }
131 
133 {
134  if ( mFilterExpression )
135  {
136  setFilterExpression( QStringLiteral( "(%1) AND (%2)" ).arg( mFilterExpression->expression(), expression ) );
137  }
138  else
139  {
140  setFilterExpression( expression );
141  }
142  return *this;
143 }
144 
146 {
147  mExpressionContext = context;
148  return *this;
149 }
150 
151 QgsFeatureRequest &QgsFeatureRequest::addOrderBy( const QString &expression, bool ascending )
152 {
153  mOrderBy.append( OrderByClause( expression, ascending ) );
154  return *this;
155 }
156 
157 QgsFeatureRequest &QgsFeatureRequest::addOrderBy( const QString &expression, bool ascending, bool nullsfirst )
158 {
159  mOrderBy.append( OrderByClause( expression, ascending, nullsfirst ) );
160  return *this;
161 }
162 
164 {
165  return mOrderBy;
166 }
167 
169 {
170  mOrderBy = orderBy;
171  return *this;
172 }
173 
175 {
176  mLimit = limit;
177  return *this;
178 }
179 
181 {
182  mFlags = flags;
183  return *this;
184 }
185 
187 {
189  mAttrs = attrs;
190  return *this;
191 }
192 
194 {
196 }
197 
198 QgsFeatureRequest &QgsFeatureRequest::setSubsetOfAttributes( const QStringList &attrNames, const QgsFields &fields )
199 {
200  if ( attrNames.contains( QgsFeatureRequest::ALL_ATTRIBUTES ) )
201  {
202  //attribute string list contains the all attributes flag, so we must fetch all attributes
203  return *this;
204  }
205 
207  mAttrs.clear();
208 
209  Q_FOREACH ( const QString &attrName, attrNames )
210  {
211  int attrNum = fields.lookupField( attrName );
212  if ( attrNum != -1 && !mAttrs.contains( attrNum ) )
213  mAttrs.append( attrNum );
214  }
215 
216  return *this;
217 }
218 
219 QgsFeatureRequest &QgsFeatureRequest::setSubsetOfAttributes( const QSet<QString> &attrNames, const QgsFields &fields )
220 {
221  if ( attrNames.contains( QgsFeatureRequest::ALL_ATTRIBUTES ) )
222  {
223  //attribute string list contains the all attributes flag, so we must fetch all attributes
224  return *this;
225  }
226 
228  mAttrs.clear();
229 
230  Q_FOREACH ( const QString &attrName, attrNames )
231  {
232  int attrNum = fields.lookupField( attrName );
233  if ( attrNum != -1 && !mAttrs.contains( attrNum ) )
234  mAttrs.append( attrNum );
235  }
236 
237  return *this;
238 }
239 
241 {
243  return *this;
244 }
245 
246 
248 {
249  return mCrs;
250 }
251 
253 {
254  return mTransformContext;
255 }
256 
258 {
259  mCrs = crs;
260  mTransformContext = context;
261  return *this;
262 }
263 
264 QgsFeatureRequest &QgsFeatureRequest::setTransformErrorCallback( const std::function<void ( const QgsFeature & )> &callback )
265 {
266  mTransformErrorCallback = callback;
267  return *this;
268 }
269 
271 {
272  if ( !mFilterRect.isNull() )
273  {
274  if ( !feature.hasGeometry() || !feature.geometry().intersects( mFilterRect ) )
275  return false;
276  }
277 
278  switch ( mFilter )
279  {
281  return true;
282 
284  return ( feature.id() == mFilterFid );
285 
287  mExpressionContext.setFeature( feature );
288  return ( mFilterExpression->evaluate( &mExpressionContext ).toBool() );
289 
291  return ( mFilterFids.contains( feature.id() ) );
292  }
293 
294  return true;
295 }
296 
298 {
299  return mTimeout;
300 }
301 
303 {
305  return *this;
306 }
307 
309 {
310  return mTimeout;
311 }
312 
314 {
315  mTimeout = timeout;
316  return *this;
317 }
318 
320 {
321  return mRequestMayBeNested;
322 }
323 
325 {
327  return *this;
328 }
329 
330 
331 #include "qgsfeatureiterator.h"
332 #include "qgslogger.h"
333 
335 {
336  while ( !mActiveIterators.empty() )
337  {
338  QgsAbstractFeatureIterator *it = *mActiveIterators.begin();
339  QgsDebugMsg( QStringLiteral( "closing active iterator" ) );
340  it->close();
341  }
342 }
343 
345 {
346  mActiveIterators.insert( it );
347 }
348 
350 {
351  mActiveIterators.remove( it );
352 }
353 
354 
355 
356 QgsFeatureRequest::OrderByClause::OrderByClause( const QString &expression, bool ascending )
357  : mExpression( expression )
358  , mAscending( ascending )
359 {
360  // postgres behavior: default for ASC: NULLS LAST, default for DESC: NULLS FIRST
361  mNullsFirst = !ascending;
362 }
363 
365  : mExpression( expression )
366  , mAscending( ascending )
367  , mNullsFirst( nullsfirst )
368 {
369 }
370 
372  : mExpression( expression )
373  , mAscending( ascending )
374 {
375  // postgres behavior: default for ASC: NULLS LAST, default for DESC: NULLS FIRST
376  mNullsFirst = !ascending;
377 }
378 
380  : mExpression( expression )
381  , mAscending( ascending )
382  , mNullsFirst( nullsfirst )
383 {
384 
385 }
386 
388 {
389  return mAscending;
390 }
391 
393 {
394  mAscending = ascending;
395 }
396 
398 {
399  return mNullsFirst;
400 }
401 
403 {
404  mNullsFirst = nullsFirst;
405 }
406 
408 {
409  return QStringLiteral( "%1 %2 %3" )
410  .arg( mExpression.expression(),
411  mAscending ? "ASC" : "DESC",
412  mNullsFirst ? "NULLS FIRST" : "NULLS LAST" );
413 }
414 
416 {
417  return mExpression;
418 }
419 
421 {
422  return mExpression.prepare( context );
423 }
424 
426 
427 QgsFeatureRequest::OrderBy::OrderBy( const QList<QgsFeatureRequest::OrderByClause> &other )
428 {
429  Q_FOREACH ( const QgsFeatureRequest::OrderByClause &clause, other )
430  {
431  append( clause );
432  }
433 }
434 
435 QList<QgsFeatureRequest::OrderByClause> QgsFeatureRequest::OrderBy::list() const
436 {
437  return *this;
438 }
439 
440 void QgsFeatureRequest::OrderBy::save( QDomElement &elem ) const
441 {
442  QDomDocument doc = elem.ownerDocument();
443  QList<OrderByClause>::ConstIterator it;
444  for ( it = constBegin(); it != constEnd(); ++it )
445  {
446  const OrderByClause &clause = *it;
447  QDomElement clauseElem = doc.createElement( QStringLiteral( "orderByClause" ) );
448  clauseElem.setAttribute( QStringLiteral( "asc" ), clause.ascending() );
449  clauseElem.setAttribute( QStringLiteral( "nullsFirst" ), clause.nullsFirst() );
450  clauseElem.appendChild( doc.createTextNode( clause.expression().expression() ) );
451 
452  elem.appendChild( clauseElem );
453  }
454 }
455 
456 void QgsFeatureRequest::OrderBy::load( const QDomElement &elem )
457 {
458  clear();
459 
460  QDomNodeList clauses = elem.childNodes();
461 
462  for ( int i = 0; i < clauses.size(); ++i )
463  {
464  QDomElement clauseElem = clauses.at( i ).toElement();
465  QString expression = clauseElem.text();
466  bool asc = clauseElem.attribute( QStringLiteral( "asc" ) ).toInt() != 0;
467  bool nullsFirst = clauseElem.attribute( QStringLiteral( "nullsFirst" ) ).toInt() != 0;
468 
469  append( OrderByClause( expression, asc, nullsFirst ) );
470  }
471 }
472 
474 {
475  QSet<QString> usedAttributes;
476 
477  QList<OrderByClause>::ConstIterator it;
478  for ( it = constBegin(); it != constEnd(); ++it )
479  {
480  const OrderByClause &clause = *it;
481 
482  usedAttributes.unite( clause.expression().referencedColumns() );
483  }
484 
485  return usedAttributes;
486 }
487 
489 {
490  QStringList results;
491 
492  QList<OrderByClause>::ConstIterator it;
493  for ( it = constBegin(); it != constEnd(); ++it )
494  {
495  const OrderByClause &clause = *it;
496 
497  results << clause.dump();
498  }
499 
500  return results.join( QStringLiteral( ", " ) );
501 }
int lookupField(const QString &fieldName) const
Look up field&#39;s index from the field name.
Definition: qgsfields.cpp:303
Class for parsing and evaluation of expressions (formerly called "search strings").
QgsFeatureRequest & setDestinationCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets the destination crs for feature&#39;s geometries.
QgsFeatureId id
Definition: qgsfeature.h:64
QgsCoordinateReferenceSystem mCrs
QgsFeatureIds mFilterFids
virtual bool close()=0
end of iterating: free the resources / lock
A rectangle specified with double values.
Definition: qgsrectangle.h:40
long limit() const
Returns the maximum number of features to request, or -1 if no limit set.
bool nullsFirst() const
Set if NULLS should be returned first.
bool acceptFeature(const QgsFeature &feature)
Check if a feature is accepted by this requests filter.
QSet< QString > CORE_EXPORT usedAttributes() const
Returns a set of used attributes.
Filter using feature ID.
Filter using feature IDs.
QgsSimplifyMethod mSimplifyMethod
QSet< QgsFeatureId > QgsFeatureIds
Definition: qgsfeatureid.h:34
QgsFeatureRequest & setInvalidGeometryCallback(const std::function< void(const QgsFeature &)> &callback)
Sets a callback function to use when encountering an invalid geometry and invalidGeometryCheck() is s...
bool ascending() const
Order ascending.
const Flags & flags() const
QString dump() const
Dumps the content to an SQL equivalent.
void iteratorClosed(QgsAbstractFeatureIterator *it)
QgsFeatureRequest & setInvalidGeometryCheck(InvalidGeometryCheck check)
Sets invalid geometry checking behavior.
InvalidGeometryCheck mInvalidGeometryFilter
QList< QgsFeatureRequest::OrderByClause > CORE_EXPORT list() const
Gets a copy as a list of OrderByClauses.
QString CORE_EXPORT dump() const
Dumps the content to an SQL equivalent syntax.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
#define QgsDebugMsg(str)
Definition: qgslogger.h:38
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for feature&#39;s geometries, or an invalid QgsCoordi...
qint64 QgsFeatureId
Definition: qgsfeatureid.h:25
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
Container of fields for a vector layer.
Definition: qgsfields.h:42
void CORE_EXPORT load(const QDomElement &elem)
Deserialize from XML.
QgsFeatureRequest & addOrderBy(const QString &expression, bool ascending=true)
Adds a new OrderByClause, appending it as the least important one.
Q_DECL_DEPRECATED QgsFeatureRequest & setConnectionTimeout(int connectionTimeout)
Sets the timeout (in milliseconds) for how long we should wait for a connection if none is available ...
QSet< QString > referencedColumns() const
Gets list of columns referenced by the expression.
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:55
const QgsCoordinateReferenceSystem & crs
QgsFeatureRequest & operator=(const QgsFeatureRequest &rh)
Assignment operator.
bool hasGeometry() const
Returns true if the feature has an associated geometry.
Definition: qgsfeature.cpp:197
int timeout() const
Returns the timeout (in milliseconds) for the maximum time we should wait during feature requests bef...
QgsExpressionContext mExpressionContext
InvalidGeometryCheck
Handling of features with invalid geometries.
bool intersects(const QgsRectangle &rectangle) const
Returns true if this geometry exactly intersects with a rectangle.
QgsFeatureRequest & combineFilterExpression(const QString &expression)
Modifies the existing filter expression to add an additional expression filter.
QgsFeatureRequest & setExpressionContext(const QgsExpressionContext &context)
Sets the expression context used to evaluate filter expressions.
QgsFeatureRequest & setFilterFid(QgsFeatureId fid)
Sets feature ID that should be fetched.
CORE_EXPORT OrderBy()
Create a new empty order by.
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
OrderByClause(const QString &expression, bool ascending=true)
Creates a new OrderByClause for a QgsFeatureRequest.
QgsFeatureRequest & setNoAttributes()
Set that no attributes will be fetched.
std::unique_ptr< QgsExpression > mFilterExpression
Internal feature iterator to be implemented within data providers.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
bool requestMayBeNested() const
In case this request may be run nested within another already running iteration on the same connectio...
This class wraps a request for features to a vector layer (or directly its vector data provider)...
QgsFeatureRequest()
construct a default request: for all features get attributes and geometries
QgsFeatureRequest & setFilterRect(const QgsRectangle &rectangle)
Sets the rectangle from which features will be taken.
static const QString ALL_ATTRIBUTES
A special attribute that if set matches all attributes.
QgsRectangle mFilterRect
Fetch only a subset of attributes (setSubsetOfAttributes sets this flag)
Contains information about the context in which a coordinate transform is executed.
QgsFeatureRequest & setTransformErrorCallback(const std::function< void(const QgsFeature &)> &callback)
Sets a callback function to use when encountering a transform error when iterating features and a des...
QString expression() const
Returns the original, unmodified expression string.
QgsFeatureRequest & setSimplifyMethod(const QgsSimplifyMethod &simplifyMethod)
Set a simplification method for geometries that will be fetched.
bool prepare(QgsExpressionContext *context)
Prepare the expression with the given context.
The OrderByClause class represents an order by clause for a QgsFeatureRequest.
QgsFeatureId mFilterFid
QgsExpression expression() const
The expression.
No filter is applied.
std::function< void(const QgsFeature &) > mInvalidGeometryCallback
QgsFeatureRequest & setFilterFids(const QgsFeatureIds &fids)
Sets feature IDs that should be fetched.
QgsCoordinateTransformContext mTransformContext
std::function< void(const QgsFeature &) > mTransformErrorCallback
bool prepare(const QgsExpressionContext *context)
Gets the expression ready for evaluation - find out column indexes.
void setAscending(bool ascending)
Set if ascending order is requested.
QgsFeatureRequest & setTimeout(int timeout)
Sets the timeout (in milliseconds) for the maximum time we should wait during feature requests before...
QgsAttributeList mAttrs
This class represents a coordinate reference system (CRS).
void CORE_EXPORT save(QDomElement &elem) const
Serialize to XML.
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
Definition: qgsrectangle.h:435
QgsFeatureRequest & setLimit(long limit)
Set the maximum number of features to request.
This class contains information about how to simplify geometries fetched from a QgsFeatureIterator.
QgsFeatureRequest & setOrderBy(const OrderBy &orderBy)
Set a list of order by clauses.
QgsGeometry geometry
Definition: qgsfeature.h:67
QgsFeatureRequest & setRequestMayBeNested(bool requestMayBeNested)
In case this request may be run nested within another already running iteration on the same connectio...
QList< int > QgsAttributeList
Definition: qgsfield.h:27
Q_DECL_DEPRECATED int connectionTimeout() const
Returns the timeout (in milliseconds) for how long we should wait for a connection if none is availab...
OrderBy orderBy() const
Returns a list of order by clauses specified for this feature request.
QgsCoordinateTransformContext transformContext() const
Returns the transform context, for use when a destinationCrs() has been set and reprojection is requi...
const QgsSimplifyMethod & simplifyMethod() const
Gets simplification method for geometries that will be fetched.
Represents a list of OrderByClauses, with the most important first and the least important last...
QgsFeatureRequest & setFlags(QgsFeatureRequest::Flags flags)
Sets flags that affect how features will be fetched.
void iteratorOpened(QgsAbstractFeatureIterator *it)
void setNullsFirst(bool nullsFirst)
Set if NULLS should be returned first.