11. Espressioni, Filtraggio e Calcolo di Valori

Suggerimento

I frammenti di codice di questa pagina necessitano delle seguenti importazioni se sei al di fuori della console pyqgis:

from qgis.core import (
    edit,
    QgsExpression,
    QgsExpressionContext,
    QgsFeature,
    QgsFeatureRequest,
    QgsField,
    QgsFields,
    QgsVectorLayer,
    QgsPointXY,
    QgsGeometry,
    QgsProject,
    QgsExpressionContextUtils
)

QGIS ha un qualche supporto per l’analisi di espressioni di tipo SQL. È supportato solo un piccolo sottoinsieme della sintassi SQL. Le espressioni possono essere valutate come predicati booleani (restituendo True o False) o come funzioni (restituendo un valore scalare). Per un elenco completo delle funzioni disponibili, vedere Espressioni nel Manuale utente.

Sono supportati tre tipi base:

• numero – sia numeri interi che decimali, e.g. 123, 3.14

• stringa – devono essere racchiuse tra apici singoli: 'hello world'

• riferimento a colonna – durante la valutazione, il riferimento é sostituito con il valore del campo. I nomi non sono racchiusi tra apici.

Sono disponibili le seguenti operazioni:

• operatori aritmetici: +, -, *, /, ^

• parentesi: per forzare la precedenza tra operatori: (1 + 1) * 3

• somma e sottrazione unari: -12, +5

• funzioni matematiche: sqrt, sin, cos, tan, asin, acos, atan

• funzioni di conversione: to_int, to_real, to_string, to_date

• funzioni sulla geometria: $area, $length

• funzioni di manipolazione della geometria: $x, $y, $geometry, num_geometries, centroid

Sono supportati i seguenti predicati:

• comparazione: =, !=, >, >=, <, <=

• pattern matching: LIKE (usando % e _), ~ (espressioni regolari)

• predicati logici: AND, OR, NOT

• controllo di valori NULL: IS NULL, IS NOT NULL

Esempi di predicati:

• 1 + 2 = 3

• sin(angolo) > 0

• 'Hello' LIKE 'He%'

• (x > 10 AND y > 10) OR z = 0

Esempi di espressioni scalari:

• 2 ^ 10

• sqrt(val)

• $length + 1

11.1. Analisi di Espressioni

L’esempio seguente mostra come verificare se una determinata espressione può essere analizzata correttamente:

exp = QgsExpression('1 + 1 = 2')
assert(not exp.hasParserError())

exp = QgsExpression('1 + 1 = ')
assert(exp.hasParserError())

assert(exp.parserErrorString() == '\nsyntax error, unexpected end of file')

11.2. Valutazione di Espressioni

Le espressioni possono essere utilizzate in diversi contesti, ad esempio per filtrare gli elementi o per calcolare i valori di nuovi campi. In ogni caso, l’espressione deve essere valorizzata. Ciò significa che il suo valore viene calcolato eseguendo le fasi di calcolo specificate, che possono andare dalla semplice aritmetica alle espressioni aggregate.

11.2.1. Espressioni Base

Questa espressione di base valuta una semplice operazione aritmetica:

exp = QgsExpression('2 * 3')
print(exp)
print(exp.evaluate())

<QgsExpression: '2 * 3'>
6

L’espressione può essere utilizzata anche per il confronto, fornendo una risposta pari a 1 (True) o a 0 (False).

exp = QgsExpression('1 + 1 = 2')
exp.evaluate()
# 1

11.2.2. Espressioni con geometrie

Per valutare un’espressione rispetto a un elemento, è necessario creare un oggetto QgsExpressionContext e passarlo alla funzione evaluate, per consentire all’espressione di accedere ai valori dei campi dell’elemento.

L’esempio seguente mostra come creare un elemento con un campo chiamato «Column» e come aggiungere questo elemento al contesto dell’espressione.

fields = QgsFields()
field = QgsField('Column')
fields.append(field)
feature = QgsFeature()
feature.setFields(fields)
feature.setAttribute(0, 99)

exp = QgsExpression('"Column"')
context = QgsExpressionContext()
context.setFeature(feature)
exp.evaluate(context)
# 99

Di seguito è riportato un esempio più completo di come utilizzare le espressioni nel contesto di un layer vettoriale, al fine di calcolare nuovi valori di campo:

from qgis.PyQt.QtCore import QVariant

# create a vector layer
vl = QgsVectorLayer("Point", "Companies", "memory")
pr = vl.dataProvider()
pr.addAttributes([QgsField("Name", QVariant.String),
                  QgsField("Employees",  QVariant.Int),
                  QgsField("Revenue", QVariant.Double),
                  QgsField("Rev. per employee", QVariant.Double),
                  QgsField("Sum", QVariant.Double),
                  QgsField("Fun", QVariant.Double)])
vl.updateFields()

# add data to the first three fields
my_data = [
    {'x': 0, 'y': 0, 'name': 'ABC', 'emp': 10, 'rev': 100.1},
    {'x': 1, 'y': 1, 'name': 'DEF', 'emp': 2, 'rev': 50.5},
    {'x': 5, 'y': 5, 'name': 'GHI', 'emp': 100, 'rev': 725.9}]

for rec in my_data:
    f = QgsFeature()
    pt = QgsPointXY(rec['x'], rec['y'])
    f.setGeometry(QgsGeometry.fromPointXY(pt))
    f.setAttributes([rec['name'], rec['emp'], rec['rev']])
    pr.addFeature(f)

vl.updateExtents()
QgsProject.instance().addMapLayer(vl)

# The first expression computes the revenue per employee.
# The second one computes the sum of all revenue values in the layer.
# The final third expression doesn’t really make sense but illustrates
# the fact that we can use a wide range of expression functions, such
# as area and buffer in our expressions:
expression1 = QgsExpression('"Revenue"/"Employees"')
expression2 = QgsExpression('sum("Revenue")')
expression3 = QgsExpression('area(buffer($geometry,"Employees"))')

# QgsExpressionContextUtils.globalProjectLayerScopes() is a convenience
# function that adds the global, project, and layer scopes all at once.
# Alternatively, those scopes can also be added manually. In any case,
# it is important to always go from “most generic” to “most specific”
# scope, i.e. from global to project to layer
context = QgsExpressionContext()
context.appendScopes(QgsExpressionContextUtils.globalProjectLayerScopes(vl))

with edit(vl):
    for f in vl.getFeatures():
        context.setFeature(f)
        f['Rev. per employee'] = expression1.evaluate(context)
        f['Sum'] = expression2.evaluate(context)
        f['Fun'] = expression3.evaluate(context)
        vl.updateFeature(f)

print(f['Sum'])

876.5

11.2.3. Filtrare un layer con le espressioni

L’esempio seguente puó essere usato per filtrare un layer e restituire qualsiasi geometria che soddisfi il predicato.

layer = QgsVectorLayer("Point?field=Test:integer",
                           "addfeat", "memory")

layer.startEditing()

for i in range(10):
    feature = QgsFeature()
    feature.setAttributes([i])
    assert(layer.addFeature(feature))
layer.commitChanges()

expression = 'Test >= 3'
request = QgsFeatureRequest().setFilterExpression(expression)

matches = 0
for f in layer.getFeatures(request):
   matches += 1

print(matches)

7

11.3. Gestione degli errori delle espressioni

Gli errori relativi alle espressioni possono verificarsi durante l’analisi o la valutazione delle stesse:

exp = QgsExpression("1 + 1 = 2")
if exp.hasParserError():
   raise Exception(exp.parserErrorString())

value = exp.evaluate()
if exp.hasEvalError():
   raise ValueError(exp.evalErrorString())