QGIS API Documentation 3.99.0-Master (8e76e220402)
Loading...
Searching...
No Matches
qgsaggregatecalculator.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsaggregatecalculator.cpp
3 --------------------------
4 begin : May 2016
5 copyright : (C) 2016 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
18#include "qgsaggregatecalculator.h"
19
20#include <memory>
21
22#include "qgsdatetimestatisticalsummary.h"
23#include "qgsexpressionutils.h"
24#include "qgsfeature.h"
25#include "qgsfeatureiterator.h"
26#include "qgsfeaturerequest.h"
27#include "qgsgeometry.h"
28#include "qgsstatisticalsummary.h"
29#include "qgsstringstatisticalsummary.h"
30#include "qgsvectorlayer.h"
31
32#include <QString>
33
34using namespace Qt::StringLiterals;
35
41
42const QgsVectorLayer *QgsAggregateCalculator::layer() const
43{
44 return mLayer;
45}
46
47void QgsAggregateCalculator::setParameters( const AggregateParameters &parameters )
48{
49 mFilterExpression = parameters.filter;
50 mDelimiter = parameters.delimiter;
51 mOrderBy = parameters.orderBy;
52}
53
54void QgsAggregateCalculator::setFidsFilter( const QgsFeatureIds &fids )
55{
56 mFidsSet = true;
57 mFidsFilter = fids;
58}
59
60QVariant QgsAggregateCalculator::calculate( Qgis::Aggregate aggregate,
61 const QString &fieldOrExpression, QgsExpressionContext *context, bool *ok, QgsFeedback *feedback ) const
62{
63 mLastError.clear();
64 if ( ok )
65 *ok = false;
66
67 QgsFeatureRequest request = QgsFeatureRequest();
68
69 if ( !mLayer )
70 return QVariant();
71
72 QgsExpressionContext defaultContext = mLayer->createExpressionContext();
73 context = context ? context : &defaultContext;
74
75 std::unique_ptr<QgsExpression> expression;
76
77 const int attrNum = QgsExpression::expressionToLayerFieldIndex( fieldOrExpression, mLayer );
78 if ( attrNum == -1 )
79 {
80 Q_ASSERT( context );
81 context->setFields( mLayer->fields() );
82 // try to use expression
83 expression = std::make_unique<QgsExpression>( fieldOrExpression );
84
85 if ( expression->hasParserError() || !expression->prepare( context ) )
86 {
87 mLastError = !expression->parserErrorString().isEmpty() ? expression->parserErrorString() : expression->evalErrorString();
88 return QVariant();
89 }
90 }
91
92 QSet<QString> lst;
93 if ( !expression )
94 lst.insert( mLayer->fields().at( attrNum ).name() );
95 else
96 lst = expression->referencedColumns();
97
98 bool expressionNeedsGeometry { expression &&expression->needsGeometry() };
99
100 if ( !mOrderBy.empty() )
101 {
102 request.setOrderBy( mOrderBy );
103 for ( const QgsFeatureRequest::OrderByClause &orderBy : std::as_const( mOrderBy ) )
104 {
105 if ( orderBy.expression().needsGeometry() )
106 {
107 expressionNeedsGeometry = true;
108 break;
109 }
110 }
111 }
112
113 request.setFlags( expressionNeedsGeometry ?
114 Qgis::FeatureRequestFlag::NoFlags :
115 Qgis::FeatureRequestFlag::NoGeometry )
116 .setSubsetOfAttributes( lst, mLayer->fields() );
117
118 if ( mFidsSet )
119 request.setFilterFids( mFidsFilter );
120
121 if ( !mFilterExpression.isEmpty() )
122 request.setFilterExpression( mFilterExpression );
123 if ( context )
124 request.setExpressionContext( *context );
125
126 request.setFeedback( feedback ? feedback : context->feedback() );
127
128 //determine result type
129 QMetaType::Type resultType = QMetaType::Type::Double;
130 if ( attrNum == -1 )
131 {
132 if ( aggregate == Qgis::Aggregate::GeometryCollect )
133 {
134 // in this case we know the result should be a geometry value, so no need to sniff it out...
135 resultType = QMetaType::Type::User;
136 }
137 else
138 {
139 // check expression result type
140 bool foundFeatures = false;
141 std::tuple<QMetaType::Type, int> returnType = QgsExpressionUtils::determineResultType( fieldOrExpression, mLayer, request, *context, &foundFeatures );
142 if ( !foundFeatures )
143 {
144 if ( ok )
145 *ok = true;
146 return defaultValue( aggregate );
147 }
148
149 resultType = std::get<0>( returnType );
150 if ( resultType == QMetaType::Type::UnknownType )
151 {
152 QVariant v;
153 switch ( aggregate )
154 {
155 // string
156 case Qgis::Aggregate::StringConcatenate:
157 case Qgis::Aggregate::StringConcatenateUnique:
158 case Qgis::Aggregate::StringMinimumLength:
159 case Qgis::Aggregate::StringMaximumLength:
160 v = QString();
161 break;
162
163 // numerical
164 case Qgis::Aggregate::Sum:
165 case Qgis::Aggregate::Mean:
166 case Qgis::Aggregate::Median:
167 case Qgis::Aggregate::StDev:
168 case Qgis::Aggregate::StDevSample:
169 case Qgis::Aggregate::Range:
170 case Qgis::Aggregate::FirstQuartile:
171 case Qgis::Aggregate::ThirdQuartile:
172 case Qgis::Aggregate::InterQuartileRange:
173 // mixed type, fallback to numerical
174 case Qgis::Aggregate::Count:
175 case Qgis::Aggregate::CountDistinct:
176 case Qgis::Aggregate::CountMissing:
177 case Qgis::Aggregate::Minority:
178 case Qgis::Aggregate::Majority:
179 case Qgis::Aggregate::Min:
180 case Qgis::Aggregate::Max:
181 v = 0.0;
182 break;
183
184 // geometry
185 case Qgis::Aggregate::GeometryCollect:
186 v = QgsGeometry();
187 break;
188
189 // list, fallback to string
190 case Qgis::Aggregate::ArrayAggregate:
191 v = QString();
192 break;
193 }
194 resultType = static_cast<QMetaType::Type>( v.userType() );
195 }
196 }
197 }
198 else
199 resultType = mLayer->fields().at( attrNum ).type();
200
201 QgsFeatureIterator fit = mLayer->getFeatures( request );
202 return calculate( aggregate, fit, resultType, attrNum, expression.get(), mDelimiter, context, ok, &mLastError );
203}
204
205Qgis::Aggregate QgsAggregateCalculator::stringToAggregate( const QString &string, bool *ok )
206{
207 const QString normalized = string.trimmed().toLower();
208
209 if ( ok )
210 *ok = true;
211
212 if ( normalized == "count"_L1 )
213 return Qgis::Aggregate::Count;
214 else if ( normalized == "count_distinct"_L1 )
215 return Qgis::Aggregate::CountDistinct;
216 else if ( normalized == "count_missing"_L1 )
217 return Qgis::Aggregate::CountMissing;
218 else if ( normalized == "min"_L1 || normalized == "minimum"_L1 )
219 return Qgis::Aggregate::Min;
220 else if ( normalized == "max"_L1 || normalized == "maximum"_L1 )
221 return Qgis::Aggregate::Max;
222 else if ( normalized == "sum"_L1 )
223 return Qgis::Aggregate::Sum;
224 else if ( normalized == "mean"_L1 )
225 return Qgis::Aggregate::Mean;
226 else if ( normalized == "median"_L1 )
227 return Qgis::Aggregate::Median;
228 else if ( normalized == "stdev"_L1 )
229 return Qgis::Aggregate::StDev;
230 else if ( normalized == "stdevsample"_L1 )
231 return Qgis::Aggregate::StDevSample;
232 else if ( normalized == "range"_L1 )
233 return Qgis::Aggregate::Range;
234 else if ( normalized == "minority"_L1 )
235 return Qgis::Aggregate::Minority;
236 else if ( normalized == "majority"_L1 )
237 return Qgis::Aggregate::Majority;
238 else if ( normalized == "q1"_L1 )
239 return Qgis::Aggregate::FirstQuartile;
240 else if ( normalized == "q3"_L1 )
241 return Qgis::Aggregate::ThirdQuartile;
242 else if ( normalized == "iqr"_L1 )
243 return Qgis::Aggregate::InterQuartileRange;
244 else if ( normalized == "min_length"_L1 )
245 return Qgis::Aggregate::StringMinimumLength;
246 else if ( normalized == "max_length"_L1 )
247 return Qgis::Aggregate::StringMaximumLength;
248 else if ( normalized == "concatenate"_L1 )
249 return Qgis::Aggregate::StringConcatenate;
250 else if ( normalized == "concatenate_unique"_L1 )
251 return Qgis::Aggregate::StringConcatenateUnique;
252 else if ( normalized == "collect"_L1 )
253 return Qgis::Aggregate::GeometryCollect;
254 else if ( normalized == "array_agg"_L1 )
255 return Qgis::Aggregate::ArrayAggregate;
256
257 if ( ok )
258 *ok = false;
259
260 return Qgis::Aggregate::Count;
261}
262
263QString QgsAggregateCalculator::displayName( Qgis::Aggregate aggregate )
264{
265 switch ( aggregate )
266 {
267 case Qgis::Aggregate::Count:
268 return QObject::tr( "count" );
269 case Qgis::Aggregate::CountDistinct:
270 return QObject::tr( "count distinct" );
271 case Qgis::Aggregate::CountMissing:
272 return QObject::tr( "count missing" );
273 case Qgis::Aggregate::Min:
274 return QObject::tr( "minimum" );
275 case Qgis::Aggregate::Max:
276 return QObject::tr( "maximum" );
277 case Qgis::Aggregate::Sum:
278 return QObject::tr( "sum" );
279 case Qgis::Aggregate::Mean:
280 return QObject::tr( "mean" );
281 case Qgis::Aggregate::Median:
282 return QObject::tr( "median" );
283 case Qgis::Aggregate::StDev:
284 return QObject::tr( "standard deviation" );
285 case Qgis::Aggregate::StDevSample:
286 return QObject::tr( "standard deviation (sample)" );
287 case Qgis::Aggregate::Range:
288 return QObject::tr( "range" );
289 case Qgis::Aggregate::Minority:
290 return QObject::tr( "minority" );
291 case Qgis::Aggregate::Majority:
292 return QObject::tr( "majority" );
293 case Qgis::Aggregate::FirstQuartile:
294 return QObject::tr( "first quartile" );
295 case Qgis::Aggregate::ThirdQuartile:
296 return QObject::tr( "third quartile" );
297 case Qgis::Aggregate::InterQuartileRange:
298 return QObject::tr( "inter quartile range" );
299 case Qgis::Aggregate::StringMinimumLength:
300 return QObject::tr( "minimum length" );
301 case Qgis::Aggregate::StringMaximumLength:
302 return QObject::tr( "maximum length" );
303 case Qgis::Aggregate::StringConcatenate:
304 return QObject::tr( "concatenate" );
305 case Qgis::Aggregate::GeometryCollect:
306 return QObject::tr( "collection" );
307 case Qgis::Aggregate::ArrayAggregate:
308 return QObject::tr( "array aggregate" );
309 case Qgis::Aggregate::StringConcatenateUnique:
310 return QObject::tr( "concatenate (unique)" );
311 }
312 return QString();
313}
314
315QList<QgsAggregateCalculator::AggregateInfo> QgsAggregateCalculator::aggregates()
316{
317 QList< AggregateInfo > aggregates;
318 aggregates
319 << AggregateInfo
320 {
321 u"count"_s,
322 QCoreApplication::tr( "Count" ),
323 QSet<QMetaType::Type>()
324 << QMetaType::Type::QDateTime
325 << QMetaType::Type::QDate
326 << QMetaType::Type::Int
327 << QMetaType::Type::UInt
328 << QMetaType::Type::LongLong
329 << QMetaType::Type::ULongLong
330 << QMetaType::Type::QString
331 }
332 << AggregateInfo
333 {
334 u"count_distinct"_s,
335 QCoreApplication::tr( "Count Distinct" ),
336 QSet<QMetaType::Type>()
337 << QMetaType::Type::QDateTime
338 << QMetaType::Type::QDate
339 << QMetaType::Type::UInt
340 << QMetaType::Type::Int
341 << QMetaType::Type::LongLong
342 << QMetaType::Type::ULongLong
343 << QMetaType::Type::QString
344 }
345 << AggregateInfo
346 {
347 u"count_missing"_s,
348 QCoreApplication::tr( "Count Missing" ),
349 QSet<QMetaType::Type>()
350 << QMetaType::Type::QDateTime
351 << QMetaType::Type::QDate
352 << QMetaType::Type::Int
353 << QMetaType::Type::UInt
354 << QMetaType::Type::LongLong
355 << QMetaType::Type::QString
356 }
357 << AggregateInfo
358 {
359 u"min"_s,
360 QCoreApplication::tr( "Min" ),
361 QSet<QMetaType::Type>()
362 << QMetaType::Type::QDateTime
363 << QMetaType::Type::QDate
364 << QMetaType::Type::Int
365 << QMetaType::Type::UInt
366 << QMetaType::Type::LongLong
367 << QMetaType::Type::ULongLong
368 << QMetaType::Type::Double
369 << QMetaType::Type::QString
370 }
371 << AggregateInfo
372 {
373 u"max"_s,
374 QCoreApplication::tr( "Max" ),
375 QSet<QMetaType::Type>()
376 << QMetaType::Type::QDateTime
377 << QMetaType::Type::QDate
378 << QMetaType::Type::Int
379 << QMetaType::Type::UInt
380 << QMetaType::Type::LongLong
381 << QMetaType::Type::ULongLong
382 << QMetaType::Type::Double
383 << QMetaType::Type::QString
384 }
385 << AggregateInfo
386 {
387 u"sum"_s,
388 QCoreApplication::tr( "Sum" ),
389 QSet<QMetaType::Type>()
390 << QMetaType::Type::Int
391 << QMetaType::Type::UInt
392 << QMetaType::Type::LongLong
393 << QMetaType::Type::ULongLong
394 << QMetaType::Type::Double
395 }
396 << AggregateInfo
397 {
398 u"mean"_s,
399 QCoreApplication::tr( "Mean" ),
400 QSet<QMetaType::Type>()
401 << QMetaType::Type::Int
402 << QMetaType::Type::UInt
403 << QMetaType::Type::LongLong
404 << QMetaType::Type::ULongLong
405 << QMetaType::Type::Double
406 }
407 << AggregateInfo
408 {
409 u"median"_s,
410 QCoreApplication::tr( "Median" ),
411 QSet<QMetaType::Type>()
412 << QMetaType::Type::Int
413 << QMetaType::Type::UInt
414 << QMetaType::Type::Double
415 }
416 << AggregateInfo
417 {
418 u"stdev"_s,
419 QCoreApplication::tr( "Stdev" ),
420 QSet<QMetaType::Type>()
421 << QMetaType::Type::Int
422 << QMetaType::Type::UInt
423 << QMetaType::Type::LongLong
424 << QMetaType::Type::ULongLong
425 << QMetaType::Type::Double
426 }
427 << AggregateInfo
428 {
429 u"stdevsample"_s,
430 QCoreApplication::tr( "Stdev Sample" ),
431 QSet<QMetaType::Type>()
432 << QMetaType::Type::Int
433 << QMetaType::Type::UInt
434 << QMetaType::Type::LongLong
435 << QMetaType::Type::ULongLong
436 << QMetaType::Type::Double
437 }
438 << AggregateInfo
439 {
440 u"range"_s,
441 QCoreApplication::tr( "Range" ),
442 QSet<QMetaType::Type>()
443 << QMetaType::Type::QDate
444 << QMetaType::Type::QDateTime
445 << QMetaType::Type::Int
446 << QMetaType::Type::UInt
447 << QMetaType::Type::LongLong
448 << QMetaType::Type::ULongLong
449 << QMetaType::Type::Double
450 }
451 << AggregateInfo
452 {
453 u"minority"_s,
454 QCoreApplication::tr( "Minority" ),
455 QSet<QMetaType::Type>()
456 << QMetaType::Type::Int
457 << QMetaType::Type::UInt
458 << QMetaType::Type::LongLong
459 << QMetaType::Type::ULongLong
460 << QMetaType::Type::Double
461 << QMetaType::Type::QString
462 }
463 << AggregateInfo
464 {
465 u"majority"_s,
466 QCoreApplication::tr( "Majority" ),
467 QSet<QMetaType::Type>()
468 << QMetaType::Type::Int
469 << QMetaType::Type::UInt
470 << QMetaType::Type::LongLong
471 << QMetaType::Type::ULongLong
472 << QMetaType::Type::Double
473 << QMetaType::Type::QString
474 }
475 << AggregateInfo
476 {
477 u"q1"_s,
478 QCoreApplication::tr( "Q1" ),
479 QSet<QMetaType::Type>()
480 << QMetaType::Type::Int
481 << QMetaType::Type::UInt
482 << QMetaType::Type::LongLong
483 << QMetaType::Type::ULongLong
484 << QMetaType::Type::Double
485 }
486 << AggregateInfo
487 {
488 u"q3"_s,
489 QCoreApplication::tr( "Q3" ),
490 QSet<QMetaType::Type>()
491 << QMetaType::Type::Int
492 << QMetaType::Type::UInt
493 << QMetaType::Type::LongLong
494 << QMetaType::Type::ULongLong
495 << QMetaType::Type::Double
496 }
497 << AggregateInfo
498 {
499 u"iqr"_s,
500 QCoreApplication::tr( "InterQuartileRange" ),
501 QSet<QMetaType::Type>()
502 << QMetaType::Type::Int
503 << QMetaType::Type::UInt
504 << QMetaType::Type::LongLong
505 << QMetaType::Type::ULongLong
506 << QMetaType::Type::Double
507 }
508 << AggregateInfo
509 {
510 u"min_length"_s,
511 QCoreApplication::tr( "Min Length" ),
512 QSet<QMetaType::Type>()
513 << QMetaType::Type::QString
514 }
515 << AggregateInfo
516 {
517 u"max_length"_s,
518 QCoreApplication::tr( "Max Length" ),
519 QSet<QMetaType::Type>()
520 << QMetaType::Type::QString
521 }
522 << AggregateInfo
523 {
524 u"concatenate"_s,
525 QCoreApplication::tr( "Concatenate" ),
526 QSet<QMetaType::Type>()
527 << QMetaType::Type::QString
528 }
529 << AggregateInfo
530 {
531 u"collect"_s,
532 QCoreApplication::tr( "Collect" ),
533 QSet<QMetaType::Type>()
534 }
535 << AggregateInfo
536 {
537 u"array_agg"_s,
538 QCoreApplication::tr( "Array Aggregate" ),
539 QSet<QMetaType::Type>()
540 };
541
542 return aggregates;
543}
544
545QVariant QgsAggregateCalculator::calculate( Qgis::Aggregate aggregate, QgsFeatureIterator &fit, QMetaType::Type resultType,
546 int attr, QgsExpression *expression, const QString &delimiter, QgsExpressionContext *context, bool *ok, QString *error )
547{
548 if ( ok )
549 *ok = false;
550
551 if ( aggregate == Qgis::Aggregate::ArrayAggregate )
552 {
553 if ( ok )
554 *ok = true;
555 return calculateArrayAggregate( fit, attr, expression, context );
556 }
557
558 switch ( resultType )
559 {
560 case QMetaType::Type::Int:
561 case QMetaType::Type::UInt:
562 case QMetaType::Type::LongLong:
563 case QMetaType::Type::ULongLong:
564 case QMetaType::Type::Double:
565 {
566 bool statOk = false;
567 const Qgis::Statistic stat = numericStatFromAggregate( aggregate, &statOk );
568 if ( !statOk )
569 {
570 if ( error )
571 *error = expression ? QObject::tr( "Cannot calculate %1 on numeric values" ).arg( displayName( aggregate ) )
572 : QObject::tr( "Cannot calculate %1 on numeric fields" ).arg( displayName( aggregate ) );
573 return QVariant();
574 }
575
576 if ( ok )
577 *ok = true;
578 return calculateNumericAggregate( fit, attr, expression, context, stat );
579 }
580
581 case QMetaType::Type::QDate:
582 case QMetaType::Type::QDateTime:
583 {
584 bool statOk = false;
585 const Qgis::DateTimeStatistic stat = dateTimeStatFromAggregate( aggregate, &statOk );
586 if ( !statOk )
587 {
588 if ( error )
589 *error = ( expression ? QObject::tr( "Cannot calculate %1 on %2 values" ).arg( displayName( aggregate ) ) :
590 QObject::tr( "Cannot calculate %1 on %2 fields" ).arg( displayName( aggregate ) ) ).arg( resultType == QMetaType::Type::QDate ? QObject::tr( "date" ) : QObject::tr( "datetime" ) );
591 return QVariant();
592 }
593
594 if ( ok )
595 *ok = true;
596 return calculateDateTimeAggregate( fit, attr, expression, context, stat );
597 }
598
599 case QMetaType::Type::User:
600 {
601 if ( aggregate == Qgis::Aggregate::GeometryCollect )
602 {
603 if ( ok )
604 *ok = true;
605 return calculateGeometryAggregate( fit, expression, context );
606 }
607 else
608 {
609 return QVariant();
610 }
611 }
612
613 default:
614 {
615 // treat as string
616 if ( aggregate == Qgis::Aggregate::StringConcatenate )
617 {
618 //special case
619 if ( ok )
620 *ok = true;
621 return concatenateStrings( fit, attr, expression, context, delimiter );
622 }
623 else if ( aggregate == Qgis::Aggregate::StringConcatenateUnique )
624 {
625 //special case
626 if ( ok )
627 *ok = true;
628 return concatenateStrings( fit, attr, expression, context, delimiter, true );
629 }
630
631 bool statOk = false;
632 const Qgis::StringStatistic stat = stringStatFromAggregate( aggregate, &statOk );
633 if ( !statOk )
634 {
635 QString typeString;
636 if ( resultType == QMetaType::Type::UnknownType )
637 typeString = QObject::tr( "null" );
638 else
639 typeString = resultType == QMetaType::Type::QString ? QObject::tr( "string" ) : QVariant::typeToName( resultType );
640
641 if ( error )
642 *error = expression ? QObject::tr( "Cannot calculate %1 on %3 values" ).arg( displayName( aggregate ), typeString )
643 : QObject::tr( "Cannot calculate %1 on %3 fields" ).arg( displayName( aggregate ), typeString );
644 return QVariant();
645 }
646
647 if ( ok )
648 *ok = true;
649 return calculateStringAggregate( fit, attr, expression, context, stat );
650 }
651 }
652
653#ifndef _MSC_VER
654 return QVariant();
655#endif
656}
657
658Qgis::Statistic QgsAggregateCalculator::numericStatFromAggregate( Qgis::Aggregate aggregate, bool *ok )
659{
660 if ( ok )
661 *ok = true;
662
663 switch ( aggregate )
664 {
665 case Qgis::Aggregate::Count:
666 return Qgis::Statistic::Count;
667 case Qgis::Aggregate::CountDistinct:
668 return Qgis::Statistic::Variety;
669 case Qgis::Aggregate::CountMissing:
670 return Qgis::Statistic::CountMissing;
671 case Qgis::Aggregate::Min:
672 return Qgis::Statistic::Min;
673 case Qgis::Aggregate::Max:
674 return Qgis::Statistic::Max;
675 case Qgis::Aggregate::Sum:
676 return Qgis::Statistic::Sum;
677 case Qgis::Aggregate::Mean:
678 return Qgis::Statistic::Mean;
679 case Qgis::Aggregate::Median:
680 return Qgis::Statistic::Median;
681 case Qgis::Aggregate::StDev:
682 return Qgis::Statistic::StDev;
683 case Qgis::Aggregate::StDevSample:
684 return Qgis::Statistic::StDevSample;
685 case Qgis::Aggregate::Range:
686 return Qgis::Statistic::Range;
687 case Qgis::Aggregate::Minority:
688 return Qgis::Statistic::Minority;
689 case Qgis::Aggregate::Majority:
690 return Qgis::Statistic::Majority;
691 case Qgis::Aggregate::FirstQuartile:
692 return Qgis::Statistic::FirstQuartile;
693 case Qgis::Aggregate::ThirdQuartile:
694 return Qgis::Statistic::ThirdQuartile;
695 case Qgis::Aggregate::InterQuartileRange:
696 return Qgis::Statistic::InterQuartileRange;
697 case Qgis::Aggregate::StringMinimumLength:
698 case Qgis::Aggregate::StringMaximumLength:
699 case Qgis::Aggregate::StringConcatenate:
700 case Qgis::Aggregate::StringConcatenateUnique:
701 case Qgis::Aggregate::GeometryCollect:
702 case Qgis::Aggregate::ArrayAggregate:
703 {
704 if ( ok )
705 *ok = false;
706 return Qgis::Statistic::Count;
707 }
708 }
709
710 if ( ok )
711 *ok = false;
712 return Qgis::Statistic::Count;
713}
714
715Qgis::StringStatistic QgsAggregateCalculator::stringStatFromAggregate( Qgis::Aggregate aggregate, bool *ok )
716{
717 if ( ok )
718 *ok = true;
719
720 switch ( aggregate )
721 {
722 case Qgis::Aggregate::Count:
723 return Qgis::StringStatistic::Count;
724 case Qgis::Aggregate::CountDistinct:
725 return Qgis::StringStatistic::CountDistinct;
726 case Qgis::Aggregate::CountMissing:
727 return Qgis::StringStatistic::CountMissing;
728 case Qgis::Aggregate::Min:
729 return Qgis::StringStatistic::Min;
730 case Qgis::Aggregate::Max:
731 return Qgis::StringStatistic::Max;
732 case Qgis::Aggregate::StringMinimumLength:
733 return Qgis::StringStatistic::MinimumLength;
734 case Qgis::Aggregate::StringMaximumLength:
735 return Qgis::StringStatistic::MaximumLength;
736 case Qgis::Aggregate::Minority:
737 return Qgis::StringStatistic::Minority;
738 case Qgis::Aggregate::Majority:
739 return Qgis::StringStatistic::Majority;
740
741 case Qgis::Aggregate::Sum:
742 case Qgis::Aggregate::Mean:
743 case Qgis::Aggregate::Median:
744 case Qgis::Aggregate::StDev:
745 case Qgis::Aggregate::StDevSample:
746 case Qgis::Aggregate::Range:
747 case Qgis::Aggregate::FirstQuartile:
748 case Qgis::Aggregate::ThirdQuartile:
749 case Qgis::Aggregate::InterQuartileRange:
750 case Qgis::Aggregate::StringConcatenate:
751 case Qgis::Aggregate::StringConcatenateUnique:
752 case Qgis::Aggregate::GeometryCollect:
753 case Qgis::Aggregate::ArrayAggregate:
754 {
755 if ( ok )
756 *ok = false;
757 return Qgis::StringStatistic::Count;
758 }
759 }
760
761 if ( ok )
762 *ok = false;
763 return Qgis::StringStatistic::Count;
764}
765
766Qgis::DateTimeStatistic QgsAggregateCalculator::dateTimeStatFromAggregate( Qgis::Aggregate aggregate, bool *ok )
767{
768 if ( ok )
769 *ok = true;
770
771 switch ( aggregate )
772 {
773 case Qgis::Aggregate::Count:
774 return Qgis::DateTimeStatistic::Count;
775 case Qgis::Aggregate::CountDistinct:
776 return Qgis::DateTimeStatistic::CountDistinct;
777 case Qgis::Aggregate::CountMissing:
778 return Qgis::DateTimeStatistic::CountMissing;
779 case Qgis::Aggregate::Min:
780 return Qgis::DateTimeStatistic::Min;
781 case Qgis::Aggregate::Max:
782 return Qgis::DateTimeStatistic::Max;
783 case Qgis::Aggregate::Range:
784 return Qgis::DateTimeStatistic::Range;
785
786 case Qgis::Aggregate::Sum:
787 case Qgis::Aggregate::Mean:
788 case Qgis::Aggregate::Median:
789 case Qgis::Aggregate::StDev:
790 case Qgis::Aggregate::StDevSample:
791 case Qgis::Aggregate::Minority:
792 case Qgis::Aggregate::Majority:
793 case Qgis::Aggregate::FirstQuartile:
794 case Qgis::Aggregate::ThirdQuartile:
795 case Qgis::Aggregate::InterQuartileRange:
796 case Qgis::Aggregate::StringMinimumLength:
797 case Qgis::Aggregate::StringMaximumLength:
798 case Qgis::Aggregate::StringConcatenate:
799 case Qgis::Aggregate::StringConcatenateUnique:
800 case Qgis::Aggregate::GeometryCollect:
801 case Qgis::Aggregate::ArrayAggregate:
802 {
803 if ( ok )
804 *ok = false;
805 return Qgis::DateTimeStatistic::Count;
806 }
807 }
808
809 if ( ok )
810 *ok = false;
811 return Qgis::DateTimeStatistic::Count;
812}
813
814QVariant QgsAggregateCalculator::calculateNumericAggregate( QgsFeatureIterator &fit, int attr, QgsExpression *expression,
815 QgsExpressionContext *context, Qgis::Statistic stat )
816{
817 Q_ASSERT( expression || attr >= 0 );
818
819 QgsStatisticalSummary s( stat );
820 QgsFeature f;
821
822 while ( fit.nextFeature( f ) )
823 {
824 if ( expression )
825 {
826 Q_ASSERT( context );
827 context->setFeature( f );
828 const QVariant v = expression->evaluate( context );
829 s.addVariant( v );
830 }
831 else
832 {
833 s.addVariant( f.attribute( attr ) );
834 }
835 }
836 s.finalize();
837 const double val = s.statistic( stat );
838 return std::isnan( val ) ? QVariant() : val;
839}
840
841QVariant QgsAggregateCalculator::calculateStringAggregate( QgsFeatureIterator &fit, int attr, QgsExpression *expression,
842 QgsExpressionContext *context, Qgis::StringStatistic stat )
843{
844 Q_ASSERT( expression || attr >= 0 );
845
846 QgsStringStatisticalSummary s( stat );
847 QgsFeature f;
848
849 while ( fit.nextFeature( f ) )
850 {
851 if ( expression )
852 {
853 Q_ASSERT( context );
854 context->setFeature( f );
855 const QVariant v = expression->evaluate( context );
856 s.addValue( v );
857 }
858 else
859 {
860 s.addValue( f.attribute( attr ) );
861 }
862 }
863 s.finalize();
864 return s.statistic( stat );
865}
866
867QVariant QgsAggregateCalculator::calculateGeometryAggregate( QgsFeatureIterator &fit, QgsExpression *expression, QgsExpressionContext *context )
868{
869 Q_ASSERT( expression );
870
871 QgsFeature f;
872 QVector< QgsGeometry > geometries;
873 while ( fit.nextFeature( f ) )
874 {
875 Q_ASSERT( context );
876 context->setFeature( f );
877 const QVariant v = expression->evaluate( context );
878 if ( v.userType() == qMetaTypeId< QgsGeometry>() )
879 {
880 geometries << v.value<QgsGeometry>();
881 }
882 }
883
884 return QVariant::fromValue( QgsGeometry::collectGeometry( geometries ) );
885}
886
887QVariant QgsAggregateCalculator::concatenateStrings( QgsFeatureIterator &fit, int attr, QgsExpression *expression,
888 QgsExpressionContext *context, const QString &delimiter, bool unique )
889{
890 Q_ASSERT( expression || attr >= 0 );
891
892 QgsFeature f;
893 QStringList results;
894 while ( fit.nextFeature( f ) )
895 {
896 QString result;
897 if ( expression )
898 {
899 Q_ASSERT( context );
900 context->setFeature( f );
901 const QVariant v = expression->evaluate( context );
902 result = v.toString();
903 }
904 else
905 {
906 result = f.attribute( attr ).toString();
907 }
908
909 if ( !unique || !results.contains( result ) )
910 results << result;
911 }
912
913 return results.join( delimiter );
914}
915
916QVariant QgsAggregateCalculator::defaultValue( Qgis::Aggregate aggregate ) const
917{
918 // value to return when NO features are aggregated:
919 switch ( aggregate )
920 {
921 // sensible values:
922 case Qgis::Aggregate::Count:
923 case Qgis::Aggregate::CountDistinct:
924 case Qgis::Aggregate::CountMissing:
925 return 0;
926
927 case Qgis::Aggregate::StringConcatenate:
928 case Qgis::Aggregate::StringConcatenateUnique:
929 return ""; // zero length string - not null!
930
931 case Qgis::Aggregate::ArrayAggregate:
932 return QVariantList(); // empty list
933
934 // undefined - nothing makes sense here
935 case Qgis::Aggregate::Sum:
936 case Qgis::Aggregate::Min:
937 case Qgis::Aggregate::Max:
938 case Qgis::Aggregate::Mean:
939 case Qgis::Aggregate::Median:
940 case Qgis::Aggregate::StDev:
941 case Qgis::Aggregate::StDevSample:
942 case Qgis::Aggregate::Range:
943 case Qgis::Aggregate::Minority:
944 case Qgis::Aggregate::Majority:
945 case Qgis::Aggregate::FirstQuartile:
946 case Qgis::Aggregate::ThirdQuartile:
947 case Qgis::Aggregate::InterQuartileRange:
948 case Qgis::Aggregate::StringMinimumLength:
949 case Qgis::Aggregate::StringMaximumLength:
950 case Qgis::Aggregate::GeometryCollect:
951 return QVariant();
952 }
953 return QVariant();
954}
955
956QVariant QgsAggregateCalculator::calculateDateTimeAggregate( QgsFeatureIterator &fit, int attr, QgsExpression *expression,
957 QgsExpressionContext *context, Qgis::DateTimeStatistic stat )
958{
959 Q_ASSERT( expression || attr >= 0 );
960
961 QgsDateTimeStatisticalSummary s( stat );
962 QgsFeature f;
963
964 while ( fit.nextFeature( f ) )
965 {
966 if ( expression )
967 {
968 Q_ASSERT( context );
969 context->setFeature( f );
970 const QVariant v = expression->evaluate( context );
971 s.addValue( v );
972 }
973 else
974 {
975 s.addValue( f.attribute( attr ) );
976 }
977 }
978 s.finalize();
979 return s.statistic( stat );
980}
981
982QVariant QgsAggregateCalculator::calculateArrayAggregate( QgsFeatureIterator &fit, int attr, QgsExpression *expression,
983 QgsExpressionContext *context )
984{
985 Q_ASSERT( expression || attr >= 0 );
986
987 QgsFeature f;
988
989 QVariantList array;
990
991 while ( fit.nextFeature( f ) )
992 {
993 if ( expression )
994 {
995 Q_ASSERT( context );
996 context->setFeature( f );
997 const QVariant v = expression->evaluate( context );
998 array.append( v );
999 }
1000 else
1001 {
1002 array.append( f.attribute( attr ) );
1003 }
1004 }
1005 return array;
1006}
1007
Qgis::Statistic
Statistic
Available generic statistics.
Definition qgis.h:6149
Qgis::Statistic::StDev
@ StDev
Standard deviation of values.
Definition qgis.h:6155
Qgis::Statistic::FirstQuartile
@ FirstQuartile
First quartile.
Definition qgis.h:6163
Qgis::Statistic::Mean
@ Mean
Mean of values.
Definition qgis.h:6153
Qgis::Statistic::Median
@ Median
Median of values.
Definition qgis.h:6154
Qgis::Statistic::Max
@ Max
Max of values.
Definition qgis.h:6158
Qgis::Statistic::Min
@ Min
Min of values.
Definition qgis.h:6157
Qgis::Statistic::Range
@ Range
Range of values (max - min).
Definition qgis.h:6159
Qgis::Statistic::Sum
@ Sum
Sum of values.
Definition qgis.h:6152
Qgis::Statistic::Minority
@ Minority
Minority of values.
Definition qgis.h:6160
Qgis::Statistic::CountMissing
@ CountMissing
Number of missing (null) values.
Definition qgis.h:6151
Qgis::Statistic::Majority
@ Majority
Majority of values.
Definition qgis.h:6161
Qgis::Statistic::Variety
@ Variety
Variety (count of distinct) values.
Definition qgis.h:6162
Qgis::Statistic::StDevSample
@ StDevSample
Sample standard deviation of values.
Definition qgis.h:6156
Qgis::Statistic::Count
@ Count
Count.
Definition qgis.h:6150
Qgis::Statistic::ThirdQuartile
@ ThirdQuartile
Third quartile.
Definition qgis.h:6164
Qgis::Statistic::InterQuartileRange
@ InterQuartileRange
Inter quartile range (IQR).
Definition qgis.h:6165
Qgis::FeatureRequestFlag::NoGeometry
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
Definition qgis.h:2254
Qgis::FeatureRequestFlag::NoFlags
@ NoFlags
No flags are set.
Definition qgis.h:2253
Qgis::StringStatistic
StringStatistic
Available string statistics.
Definition qgis.h:6211
Qgis::StringStatistic::Max
@ Max
Maximum string value.
Definition qgis.h:6216
Qgis::StringStatistic::Min
@ Min
Minimum string value.
Definition qgis.h:6215
Qgis::StringStatistic::MaximumLength
@ MaximumLength
Maximum length of string.
Definition qgis.h:6218
Qgis::StringStatistic::Minority
@ Minority
Minority of strings.
Definition qgis.h:6220
Qgis::StringStatistic::CountMissing
@ CountMissing
Number of missing (null) values.
Definition qgis.h:6214
Qgis::StringStatistic::Majority
@ Majority
Majority of strings.
Definition qgis.h:6221
Qgis::StringStatistic::CountDistinct
@ CountDistinct
Number of distinct string values.
Definition qgis.h:6213
Qgis::StringStatistic::MinimumLength
@ MinimumLength
Minimum length of string.
Definition qgis.h:6217
Qgis::Aggregate
Aggregate
Available aggregates to calculate.
Definition qgis.h:6117
Qgis::Aggregate::StDev
@ StDev
Standard deviation of values (numeric fields only).
Definition qgis.h:6126
Qgis::Aggregate::StringMinimumLength
@ StringMinimumLength
Minimum length of string (string fields only).
Definition qgis.h:6134
Qgis::Aggregate::FirstQuartile
@ FirstQuartile
First quartile (numeric fields only).
Definition qgis.h:6131
Qgis::Aggregate::Mean
@ Mean
Mean of values (numeric fields only).
Definition qgis.h:6124
Qgis::Aggregate::Median
@ Median
Median of values (numeric fields only).
Definition qgis.h:6125
Qgis::Aggregate::Max
@ Max
Max of values.
Definition qgis.h:6122
Qgis::Aggregate::Min
@ Min
Min of values.
Definition qgis.h:6121
Qgis::Aggregate::StringMaximumLength
@ StringMaximumLength
Maximum length of string (string fields only).
Definition qgis.h:6135
Qgis::Aggregate::Range
@ Range
Range of values (max - min) (numeric and datetime fields only).
Definition qgis.h:6128
Qgis::Aggregate::StringConcatenateUnique
@ StringConcatenateUnique
Concatenate unique values with a joining string (string fields only). Specify the delimiter using set...
Definition qgis.h:6139
Qgis::Aggregate::Sum
@ Sum
Sum of values.
Definition qgis.h:6123
Qgis::Aggregate::Minority
@ Minority
Minority of values.
Definition qgis.h:6129
Qgis::Aggregate::CountMissing
@ CountMissing
Number of missing (null) values.
Definition qgis.h:6120
Qgis::Aggregate::ArrayAggregate
@ ArrayAggregate
Create an array of values.
Definition qgis.h:6138
Qgis::Aggregate::Majority
@ Majority
Majority of values.
Definition qgis.h:6130
Qgis::Aggregate::StDevSample
@ StDevSample
Sample standard deviation of values (numeric fields only).
Definition qgis.h:6127
Qgis::Aggregate::Count
@ Count
Count.
Definition qgis.h:6118
Qgis::Aggregate::ThirdQuartile
@ ThirdQuartile
Third quartile (numeric fields only).
Definition qgis.h:6132
Qgis::Aggregate::CountDistinct
@ CountDistinct
Number of distinct values.
Definition qgis.h:6119
Qgis::Aggregate::StringConcatenate
@ StringConcatenate
Concatenate values with a joining string (string fields only). Specify the delimiter using setDelimit...
Definition qgis.h:6136
Qgis::Aggregate::GeometryCollect
@ GeometryCollect
Create a multipart geometry from aggregated geometries.
Definition qgis.h:6137
Qgis::Aggregate::InterQuartileRange
@ InterQuartileRange
Inter quartile range (IQR) (numeric fields only).
Definition qgis.h:6133
Qgis::DateTimeStatistic
DateTimeStatistic
Available date/time statistics.
Definition qgis.h:6186
Qgis::DateTimeStatistic::Max
@ Max
Maximum (latest) datetime value.
Definition qgis.h:6191
Qgis::DateTimeStatistic::Min
@ Min
Minimum (earliest) datetime value.
Definition qgis.h:6190
Qgis::DateTimeStatistic::Range
@ Range
Interval between earliest and latest datetime value.
Definition qgis.h:6192
Qgis::DateTimeStatistic::CountMissing
@ CountMissing
Number of missing (null) values.
Definition qgis.h:6189
Qgis::DateTimeStatistic::CountDistinct
@ CountDistinct
Number of distinct datetime values.
Definition qgis.h:6188
QgsAggregateCalculator::layer
const QgsVectorLayer * layer() const
Returns the associated vector layer.
Definition qgsaggregatecalculator.cpp:42
QgsAggregateCalculator::setParameters
void setParameters(const AggregateParameters &parameters)
Sets all aggregate parameters from a parameter bundle.
Definition qgsaggregatecalculator.cpp:47
QgsAggregateCalculator::setFidsFilter
void setFidsFilter(const QgsFeatureIds &fids)
Sets a filter to limit the features used during the aggregate calculation.
Definition qgsaggregatecalculator.cpp:54
QgsAggregateCalculator::aggregates
static QList< QgsAggregateCalculator::AggregateInfo > aggregates()
Structured information for available aggregates.
Definition qgsaggregatecalculator.cpp:315
QgsAggregateCalculator::calculate
QVariant calculate(Qgis::Aggregate aggregate, const QString &fieldOrExpression, QgsExpressionContext *context=nullptr, bool *ok=nullptr, QgsFeedback *feedback=nullptr) const
Calculates the value of an aggregate.
Definition qgsaggregatecalculator.cpp:60
QgsAggregateCalculator::delimiter
QString delimiter() const
Returns the delimiter used for joining values with the StringConcatenate aggregate.
Definition qgsaggregatecalculator.h:142
QgsAggregateCalculator::displayName
static QString displayName(Qgis::Aggregate aggregate)
Returns the friendly display name for a aggregate.
Definition qgsaggregatecalculator.cpp:263
QgsAggregateCalculator::stringToAggregate
static Qgis::Aggregate stringToAggregate(const QString &string, bool *ok=nullptr)
Converts a string to a aggregate type.
Definition qgsaggregatecalculator.cpp:205
QgsAggregateCalculator::QgsAggregateCalculator
QgsAggregateCalculator(const QgsVectorLayer *layer)
Constructor for QgsAggregateCalculator.
Definition qgsaggregatecalculator.cpp:36
QgsExpressionContext
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Definition qgsexpressioncontext.h:474
QgsExpressionContext::feedback
QgsFeedback * feedback() const
Returns the feedback object that can be queried regularly by the expression to check if evaluation sh...
Definition qgsexpressioncontext.cpp:820
QgsExpressionContext::setFeature
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Definition qgsexpressioncontext.cpp:685
QgsExpressionContext::setFields
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the context.
Definition qgsexpressioncontext.cpp:747
QgsExpressionUtils::determineResultType
static std::tuple< QMetaType::Type, int > determineResultType(const QString &expression, const QgsVectorLayer *layer, const QgsFeatureRequest &request=QgsFeatureRequest(), const QgsExpressionContext &context=QgsExpressionContext(), bool *foundFeatures=nullptr)
Returns a value type and user type for a given expression.
Definition qgsexpressionutils.cpp:404
QgsExpression
Handles parsing and evaluation of expressions (formerly called "search strings").
Definition qgsexpression.h:193
QgsExpression::expressionToLayerFieldIndex
static int expressionToLayerFieldIndex(const QString &expression, const QgsVectorLayer *layer)
Attempts to resolve an expression to a field index from the given layer.
Definition qgsexpression.cpp:1486
QgsExpression::evaluate
QVariant evaluate()
Evaluate the feature and return the result.
Definition qgsexpression.cpp:390
QgsFeatureIterator
Wrapper for iterator of features from vector data provider or vector layer.
Definition qgsfeatureiterator.h:290
QgsFeatureIterator::nextFeature
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Definition qgsfeatureiterator.h:407
QgsFeatureRequest::OrderByClause
The OrderByClause class represents an order by clause for a QgsFeatureRequest.
Definition qgsfeaturerequest.h:111
QgsFeatureRequest
Wraps a request for features to a vector layer (or directly its vector data provider).
Definition qgsfeaturerequest.h:85
QgsFeatureRequest::setFlags
QgsFeatureRequest & setFlags(Qgis::FeatureRequestFlags flags)
Sets flags that affect how features will be fetched.
Definition qgsfeaturerequest.cpp:348
QgsFeatureRequest::setFilterFids
QgsFeatureRequest & setFilterFids(const QgsFeatureIds &fids)
Sets the feature IDs that should be fetched.
Definition qgsfeaturerequest.cpp:274
QgsFeatureRequest::setSubsetOfAttributes
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
Definition qgsfeaturerequest.cpp:354
QgsFeatureRequest::setFilterExpression
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
Definition qgsfeaturerequest.cpp:293
QgsFeatureRequest::setFeedback
void setFeedback(QgsFeedback *feedback)
Attach a feedback object that can be queried regularly by the iterator to check if it should be cance...
Definition qgsfeaturerequest.cpp:551
QgsFeatureRequest::setExpressionContext
QgsFeatureRequest & setExpressionContext(const QgsExpressionContext &context)
Sets the expression context used to evaluate filter expressions.
Definition qgsfeaturerequest.cpp:313
QgsFeatureRequest::setOrderBy
QgsFeatureRequest & setOrderBy(const OrderBy &orderBy)
Set a list of order by clauses.
Definition qgsfeaturerequest.cpp:336
QgsFeature::attribute
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
Definition qgsfeature.cpp:344
QgsFeedback
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
QgsGeometry
A geometry is the spatial representation of a feature.
Definition qgsgeometry.h:178
QgsGeometry::collectGeometry
static QgsGeometry collectGeometry(const QVector< QgsGeometry > &geometries)
Creates a new multipart geometry from a list of QgsGeometry objects.
Definition qgsgeometry.cpp:389
QgsVectorLayer
Represents a vector layer which manages a vector based dataset.
Definition qgsvectorlayer.h:409
QgsFeatureIds
QSet< QgsFeatureId > QgsFeatureIds
Definition qgsfeatureid.h:41
QgsAggregateCalculator::AggregateInfo
Structured information about the available aggregates.
Definition qgsaggregatecalculator.h:51
QgsAggregateCalculator::AggregateParameters
A bundle of parameters controlling aggregate calculation.
Definition qgsaggregatecalculator.h:62
QgsAggregateCalculator::AggregateParameters::filter
QString filter
Optional filter for calculating aggregate over a subset of features, or an empty string to use all fe...
Definition qgsaggregatecalculator.h:70
QgsAggregateCalculator::AggregateParameters::delimiter
QString delimiter
Delimiter to use for joining values with the StringConcatenate aggregate.
Definition qgsaggregatecalculator.h:77
QgsAggregateCalculator::AggregateParameters::orderBy
QgsFeatureRequest::OrderBy orderBy
Optional order by clauses.
Definition qgsaggregatecalculator.h:83
Generated on for QGIS API Documentation by doxygen 1.15.0