11. Expressies, filteren en waarden berekenen

Hint

De codesnippers op deze pagina hebben de volgende import nodig als u buiten de console van PyQGIS bent:

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

QGIS heeft enige ondersteuning voor het parsen van SQL-achtige expressies. Alleen een klein deel van de syntaxis voor SQL wordt ondersteund. De expressies kunnen worden geëvalueerd ófwel als Booleaanse uitdrukkingen (die True of False teruggeven) of als functies (die een scalaire waarde teruggeven). Bekijk Expressies in de Gebruikershandleiding voor een volledige lijst van beschikbare functies.

Drie basistypen worden ondersteund:

• number — zowel gehele getallen als decimale getallen, bijv. 123, 3.14

• string — zij moeten zijn omsloten door enkele aanhalingstekens: 'hallo wereld'

• kolomverwijzing — tijdens evaluatie wordt de verwijzing vervangen door de actuele waarde van het veld. De namen worden niet geëscaped.

De volgende bewerkingen zijn beschikbaar:

• rekenkundige operatoren: +, -, *, /, ^

• haakjes: voor het forceren van de voorrang van de operator: (1 + 1) * 3

• unaire plus en minus: -12, +5

• wiskundige functies: sqrt, sin, cos, tan, asin, acos, atan

• functies voor conversie: to_int, to_real, to_string, to_date

• geometrische functies: $area, $length

• functies voor afhandelen van geometrie: $x, $y, $geometry, num_geometries, centroid

En de volgende termen worden ondersteund:

• vergelijking: =, !=, >, >=, <, <=

• overeenkomst van patroon: LIKE (gebruiken van % en _), ~ (reguliere expressies)

• logische termen: AND, OR, NOT

• controle op waarde NULL: IS NULL, IS NOT NULL

Voorbeelden van termen:

• 1 + 2 = 3

• sin(hoek) > 0

• 'Hallo' LIKE 'Ha%'

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

Voorbeelden van scalaire expressies:

• 2 ^ 10

• sqrt(waarde)

• $length + 1

11.1. Parsen van expressies

Het volgende voorbeeld laat zien hoe te controleren of een bepaalde expressie juist kan worden geparsd:

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. Evalueren van expressies

Expressies kunnen in verschillende contexten worden gebruikt, bijvoorbeeld om objecten te filteren of om nieuwe veldwaarden te berekenen. In alle gevallen moet de expressie worden geëvalueerd. Dat betekent dat de waarde ervan wordt berekent door de gespecificeerde stappen voor de berekening uit te voeren, wat eenvoudige rekenkundige of samengestelde expressies kunnen zijn.

11.2.1. Basisexpressies

Deze basis expressie evalueert een eenvoudige rekenkundige bewerking:

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

<QgsExpression: '2 * 3'>
6

Expressie mag ook gebruikt worden voor vergelijking, evalueert tot 1 (True) of 0 (False)

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

11.2.2. Expressies met objecten

Voor het evalueren van een expressie ten opzichte van een object dient een object QgsExpressionContext te worden gemaakt en doorgegeven aan de functie evaluate om de expressie toe te staan toegang te krijgen tot de veldwaarden van het object.

Het volgende voorbeeld laat zien hoe een object te maken met een veld “Column” en hoe dit object toe te voegen aan de context van de expressie.

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

Het volgende is een meer compleet voorbeeld van hoe expressies te gebruiken in de context van een vectorlaag, om nieuwe veldwaarden te kunnen berekenen:

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. Een laag filteren met expressies

Het volgende voorbeeld kan worden gebruikt om een laag te filteren en elk object terug te geven dat overeenkomt met een term.

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. Fouten in expressies afhandelen

Fouten die gerelateerd zijn aan expressies kunnen optreden tijdens het parsen of evalueren van de expressie:

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

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