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