Contient des fonctions qui agrègent des valeurs sur des couches et des champs.
Renvoie une valeur agrégée calculée en utilisant les entités d'une autre couche.
aggregate
(
layer
,
aggregate
,
expression
[,
filter
][,
concatenator
][,
order_by
])
| layer | une chaîne de caractères représentant soit un nom de couche ou un ID de couche |
| aggregate |
une chaîne correspondant à l'agrégat à calculer. Les options valides sont les suivantes:
|
| expression | sous-expression ou nom de champ à aggréger |
| filter | expression de filtrage optionelle pour limiter les entiés utilisées pour le calcul d'agrégation. Les champs et la géométrie proviennent des entités de la couche jointe. L'entité source peut être accédée avec la variable @parent. |
| concatenator | chaîne de caractères optionnelle utilisée pour joindre les valeurs pour l'aggrégat 'concatenate' |
| order_by | expression de filtre optionnelle pour ordonner les entités utilisées pour le calcul de l'agrégat. Les champs et la géométrie proviennent des entités de la couche jointe. |
aggregate(layer:='stations_trains',aggregate:='sum',expression:="passagers")
→
somme des valeurs du champ passagers dans la couche stations_trains
aggregate('stations_trains','sum', "passagers"/7)
→
calcule une moyenne journalière de "passagers" en divisant le champ "passagers" par 7 avant de faire la somme des valeurs
aggregate(layer:='rail_stations',aggregate:='sum',expression:="passengers",filter:="class">3)
→
fait la somme de toutes les valeurs du champ "passagers" des entités où l'attribut "classe" est supérieur à 3 seulement
aggregate(layer:='rail_stations',aggregate:='concatenate', expression:="name", concatenator:=',')
→
liste séparée par des virgules de noms de champs pour toutes les entités dans la couche trains_stations
aggregate(layer:='countries', aggregate:='max', expression:="code", filter:=intersects( $geometry, geometry(@parent) ) )
→
Le code d'un pays sécant dans la couche 'countries'
Renvoie un tableau de valeurs agrégées à partir d'un champ ou d'une expression.
array_agg
(
expression
[,
group_by
][,
filter
][,
order_by
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
| order_by | expression facultative pour ordonner les entités utilisées pour calculer l'agrégat |
array_agg("nom",group_by:="état")
→
liste des valeurs de nom, regroupées par champ d'état
Renvoie la géométrie multipartie des géométries agrégées à partir d'une expression
collect
(
expression
[,
group_by
][,
filter
])
| expression | expression géométrie pour aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
collect( $geometry )
→
géométrie multipartie de géométries agrégées
Renvoie toutes les chaînes de caractères aggrégées d'un champ ou d'une expression, jointes par un délimiteur.
concatenate
(
expression
[,
group_by
][,
filter
][,
concatenator
][,
order_by
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
| concatenator | chaîne de caractères optionnelle utilisée pour joindre les valeurs |
| order_by | expression facultative pour ordonner les entités utilisées pour calculer l'agrégat |
concatenate("nom_ville",group_by:="etat",concatenator:=',')
→
liste séparée par des virgules des valeurs du champ nom_ville, groupés sur le champ état
Retourne toutes les chaînes uniques d'un champ ou d'une expression jointes par un délimiteur.
concatenate_unique
(
expression
[,
group_by
][,
filter
][,
concatenator
][,
order_by
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
| concatenator | chaîne de caractères optionnelle utilisée pour joindre les valeurs |
| order_by | expression facultative pour ordonner les entités utilisées pour calculer l'agrégat |
concatenate("nom_ville",group_by:="etat",concatenator:=',')
→
liste séparée par des virgules des valeurs des nom de villes uniques, groupés sur le champ état
Renvoie le décompte des entités correspondantes.
count
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
count("stations",group_by:="état")
→
compte des stations, regroupées par le champ état
Renvoie le décompte des valeurs distinctes.
count_distinct
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
count_distinct("stations",group_by:="etat")
→
compte des valeurs distinctes de stations, regroupées par le champ état
Renvoie le décompte des valeurs manquantes (null).
count_missing
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
count_missing("stations",group_by:="etat")
→
compte des valeurs manquantes (null) des stations, regroupées par le champ état
Renvoie la plage inter-quartiles d'un champ ou d'une expression.
iqr
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
iqr("population",group_by:="etat")
→
plage inter-quartiles des valeurs de population, regroupées par le champ état
Renvoie l'aggrégat des valeurs majeures (les valeurs les plus fréquentes) d'un champ ou d'une expression.
majority
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
majority("classe",group_by:="état")
→
valeur de classe rencontrée la plus fréquemment, groupées selon le champ état
Renvoie la longueur maximale des chaînes de caractères d'un champ ou d'une expression.
max_length
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
max_length("nom_ville",group_by:="etat")
→
longueur maximale de nom_ville, groupée selon le champ état
Renvoie l'aggrégat de la valeur maximale d'un champ ou d'une expression.
maximum
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
maximum("population",group_by:="etat")
→
valeur maximale de population, groupée selon le champ état
Renvoie la valeur moyenne de l'aggrégat d'un champ ou d'une expression.
mean
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
mean("population",group_by:="etat)
→
valeur moyenne de population, groupée selon le champ état
Renvoie l'aggrégat de la valeur médiane d'un champ ou d'une expression.
median
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
median("population",group_by:="etat")
→
valeur médianne de population, groupée selon le champ état
Renvoie la longueur minimale des chaînes de caractères d'un champ ou d'une expression.
min_length
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
min_length("nom_ville",group_by:="etat")
→
longueur minimale des valeurs de nom_ville, groupées selon le champ état
Renvoie l'aggrégat de la valeur minimale d'un champ ou d'une expression.
minimum
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
minimum("population",group_by:="etat")
→
valeur minimale de population, groupées selon le champ etat
Renvoie l'aggrégat des valeurs mineures (les moins fréquentes) d'un champ ou d'une expression.
minority
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
minority("classe",group_by:="etat")
→
valeur de classe la moins rencontrée, regroupée par le champ état
Renvoie le premier quartile d'un champ ou d'une expression.
q1
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
q1("population",group_by:="etat")
→
premier quartile de la population, groupé selon le champ etat
Renvoie le troisième quartile d'un champ ou d'une expression.
q3
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
q3("population",group_by:="etat")
→
troisième quartile de la population, groupé selon le champ etat
Renvoie l'aggrégat de plage de valeur (maximum - minimum) d'un champ ou d'une expression.
range
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
range("population",group_by:="etat")
→
plage des valeurs de population, groupées selon le champ état
Renvoie une valeur agrégée, calculée à partir de toutes les entités enfants correspondantes dans la couche en relation.
relation_aggregate
(
relation
,
aggregate
,
expression
[,
concatenator
][,
order_by
])
| relation | un texte, représentant un identifiant de relation |
| aggregate |
une chaîne correspondant à l'agrégat à calculer. Les options valides sont les suivantes:
|
| expression | sous-expression ou nom de champ à aggréger |
| concatenator | chaîne de caractères optionnelle utilisée pour joindre les valeurs pour l'aggrégat 'concatenate' |
| order_by | optional expression to order the features used for calculating the aggregate. Fields and geometry are from the features on the joined layer. |
relation_aggregate(relation:='ma_relation',aggregate:='mean',expression:="passagers")
→
valeur moyenne de toutes les entités enfants correspondantes, dans la relation 'ma_relation'
relation_aggregate('ma_relation','sum', "passagers"/7)
→
Somme divisée par 7 des passagers de toutes les entités enfants correspondantes, dans la relation 'ma_relation'
relation_aggregate('ma_relation','concatenate', "villes", concatenator:=',')
→
liste séparée par des virgules des valeurs du champ villes pour toutes les entités correspondantes à la relation 'ma_relation'
relation_aggregate('my_relation','array_agg', "id")
→
tableau du champ id de toutes les entités enfant correspondantes liées par la relation 'ma_relation'
Renvoie l'aggrégat de l'écart-type des valeurs d'un champ ou d'une expression.
stdev
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
stdev("population",group_by:="etat")
→
écart-type des valeurs de population, groupées selon le champ état
Renvoie l'aggrégat des sommes de valeurs d'un champ ou d'une expression.
sum
(
expression
[,
group_by
][,
filter
])
| expression | sous-expression du champ à aggréger |
| group_by | expression optionnelle utilisée pour grouper les calculs d'aggrégats |
| filter | expression optionnelle utilisée pour filtrer les entités utilisées lors du calcul d'aggrégat |
sum("population",group_by:="etat")
→
somme des valeurs de population, groupée selon le champ 'etat'
Ce groupe contient des fonctions d'expression pour la création et la manipulation de tableaux (également appelés structures de données de liste). L'ordre des valeurs dans le tableau importe, contrairement à la structure de données «carte», où l'ordre des paires de valeurs-clés n'est pas pertinent et les valeurs sont identifiées par leurs clés.
Renvoie un tableau contenant toutes les valeurs passées comme paramètre.
array
(
value1
,
value2
…)
| value | une valeur |
array(2,10)
→
[ 2, 10 ]
retourne vrai si un tableau contient toutes les valeurs d'un tableau donné.
array_all
(
array_a
,
array_b
)
| array_a | un tableau |
| array_b | La liste des valeurs à chercher |
array_all(array(1,2,3),array(2,3))
→
vrai
array_all(array(1,2,3),array(1,2,4))
→
false
Renvoie un tableau avec la valeur donnée ajoutée à la fin.
array_append
(
array
,
value
)
| array | un tableau |
| value | la valeur à ajouter |
array_append(array(1,2,3),4)
→
[ 1, 2, 3, 4 ]
Renvoie un tableau contenant tous les tableaux donnés concaténés.
array_cat
(
array1
,
array2
…)
| array | un tableau |
array_cat(array(1,2),array(2,3))
→
[ 1, 2, 2, 3 ]
Renvoie vrai si un tableau contient la valeur donnée.
array_contains
(
array
,
value
)
| array | un tableau |
| value | la valeur à chercher |
array_contains(array(1,2,3),2)
→
vrai
Renvoie un tableau contenant les valeurs distinctes du tableau donné.
array_distinct
(
array
)
| array | un tableau |
array_distinct(array(1,2,3,2,1))
→
[ 1, 2, 3 ]
Retourne une liste avec l'expression évaluée pour chaque élément.
array_filter
(
array
,
expression
)
| array | un tableau |
| expression | une expression à évaluer sur chaque élément. La variable `@element` sera remplacée par la valeur courante. |
array_filter(array(1,2,3),@element < 3)
→
[ 1, 2 ]
Renvoie l'index (0 pour le premier) d'une valeur dans un tableau. Renvoie -1 si la valeur n'est pas trouvée.
array_find
(
array
,
value
)
| array | un tableau |
| value | la valeur à chercher |
array_find(array(1,2,3),2)
→
1
Retourne la première valeur d'un tableau
array_first
(
array
)
| array | un tableau |
array_first(array('a','b','c'))
→
'a'
Retourne une liste avec l'expression évaluée pour chaque élément.
array_foreach
(
array
,
expression
)
| array | un tableau |
| expression | une expression à évaluer sur chaque élément. La variable `@element` sera remplacée par la valeur courante. |
array_foreach(array('a','b','c'),upper(@element))
→
[ 'A', 'B', 'C' ]
array_foreach(array(1,2,3),@element + 10)
→
[ 11, 12, 13 ]
Renvoie la Nième (0 correspondant à la première) valeur d'une liste.
array_get
(
array
,
index
)
| array | un tableau |
| index | l'index à obtenir (basé sur 0) |
array_get(array('a','b','c'),1)
→
'b'
Renvoie un tableau avec la valeur ajoutée donnée à la position donnée.
array_insert
(
array
,
pos
,
value
)
| array | un tableau |
| pos | la position où réaliser l'ajout (basée sur 0) |
| value | la valeur à ajouter |
array_insert(array(1,2,3),1,100)
→
[ 1, 100, 2, 3 ]
Renvoie true si au moins un élément de array1 est présent dans array2.
array_intersect
(
array1
,
array2
)
| array1 | un tableau |
| array2 | un autre tableau |
array_intersect(array(1,2,3,4),array(4,0,2,5))
→
vrai
Renvoie la première valeur d'un tableau.
array_last
(
array
)
| array | un tableau |
array_last(array('a','b','c'))
→
'c'
Renvoie le nombre d'éléments d'un tableau
array_length
(
array
)
| array | un tableau |
array_length(array(1,2,3))
→
3
Renvoie un tableau avec la valeur donnée ajoutée à son début.
array_prepend
(
array
,
value
)
| array | un tableau |
| value | la valeur à ajouter |
array_prepend(array(1,2,3),0)
→
[ 0, 1, 2, 3 ]
Renvoie un tableau dont les entrées correspondantes à la valeur donnée ont été supprimées.
array_remove_all
(
array
,
value
)
| array | un tableau |
| value | la valeur à supprimer |
array_remove_all(array('a','b','c','b'),'b')
→
[ 'a', 'c' ]
Renvoie un tableau dont les index donnés ont été supprimés.
array_remove_at
(
array
,
pos
)
| array | un tableau |
| pos | la position à supprimer (basée sur 0) |
array_remove_at(array(1,2,3),1)
→
[ 1, 3 ]
Renvoie le tableau donné avec des valeurs dans l'ordre inverse.
array_reverse
(
array
)
| array | un tableau |
array_reverse(array(2,4,0,10))
→
[ 10, 0, 4, 2 ]
Renvoie une partie du tableau. La tranche est définie par les arguments start_pos et end_pos.
array_slice
(
array
,
start_pos
,
end_pos
)
| array | un tableau |
| start_pos | l'index de la position de début de la tranche (basée sur 0). L'index start_pos est inclus dans la tranche. Si vous utilisez un start_pos négatif, l'index est compté à partir de la fin de la liste (basée sur -1). |
| end_pos | l'index de la position de début de la tranche (basée sur 0). L'index end_pos est inclus dans la tranche. Si vous utilisez un end_pos négatif, l'index est compté à partir de la fin de la liste (basée sur -1). |
array_slice(array(1,2,3,4,5),0,3)
→
[ 1, 2, 3, 4 ]
array_slice(array(1,2,3,4,5),0,-1)
→
[ 1, 2, 3, 4, 5 ]
array_slice(array(1,2,3,4,5),-5,-1)
→
[ 1, 2, 3, 4, 5 ]
array_slice(array(1,2,3,4,5),0,0)
→
[ 1 ]
array_slice(array(1,2,3,4,5),-2,-1)
→
[ 4, 5 ]
array_slice(array(1,2,3,4,5),-1,-1)
→
[ 5 ]
array_slice(array('Dufour','Valmiera','Chugiak','Brighton'),1,2)
→
[ 'Valmiera', 'Chugiak' ]
array_slice(array_slice(array('Dufour','Valmiera','Chugiak','Brighton'),-2,-1)
→
[ 'Chugiak', 'Brighton' ]
Renvoie le tableau fourni avec ses éléments triés.
array_sort
(
array
[,
ascending=true
])
| array | un tableau |
| ascending | mettre ce paramètre à false pour trier le tableau par ordre décroissant |
array_sort(array(3,2,1))
→
[ 1, 2, 3 ]
Concatène les éléments d'un tableau en une chaîne de caractères séparée par un délimiteur et utilisant en option une chaîne de caractères pour les valeurs vides.
array_to_string
(
array
[,
delimiter=','
][,
empty_value=''
])
| array | le tableau initial |
| delimiter | la chaîne de caractères utilisée pour délimiter les éléments concaténés dans un tableau |
| empty_value | la chaîne de caractères optionnelle à utiliser en remplacement des résultats vides (longueur nulle) |
array_to_string(array('1','2','3'))
→
'1, 2, 3'
array_to_string(array(1,2,3),'-')
→
'1-2-3'
array_to_string(array('1','','3'),',','0')
→
'1, 0, 3'
Crée un tableau contenant la suite de chiffres.
generate_series
(
start
,
stop
[,
step=1
])
| start | la première valeur de la suite |
| stop | la dernière valeur qui provoque la fin de la suite |
| step | valeur de l'incrémentation entre les différentes valeurs |
generate_series(1,5)
→
[ 1, 2, 3, 4, 5 ]
generate_series(5,1,-1)
→
[ 5, 4, 3, 2, 1 ]
Renvoie un tableau de toutes les chaînes capturées par des groupes de capture, dans l'ordre dans lequel les groupes eux-mêmes apparaissent dans l'expression régulière fournie par une chaîne.
regexp_matches
(
string
,
regex
[,
empty_value=''
])
| string | la chaîne de caractères à tester par l'expression régulière pour capturer des groupes |
| regex | l'expression régulière utilisée pour capturer des groupes |
| empty_value | la chaîne de caractères optionnelle à utiliser en remplacement des résultats vides (longueur nulle) |
regexp_matches('qgis=>déchire','(.*)=>(.*)')
→
[ 'QGIS', 'déchire' ]
regexp_matches('key=>','(.*)=>(.*)','empty value')
→
[ 'clé', 'valeur vide' ]
Découpe une chaîne de caractères en un tableau en utilisant le délimiteur et l'éventuelle chaîne de remplacement pour les valeurs vides.
string_to_array
(
string
[,
delimiter=','
][,
empty_value=''
])
| string | la chaîne en entrée |
| delimiter | la chaîne de caractères utilisée pour découper la chaîne de caractères d'entrée |
| empty_value | la chaîne de caractères optionnelle à utiliser en remplacement des résultats vides (longueur nulle) |
string_to_array('1,2,3',',')
→
[ '1', '2', '3' ]
string_to_array('1,,3',',','0')
→
[ '1', '0', '3' ]
Ce groupe contient des fonctions pour manipuler des couleurs
Renvoie une chaîne de caractères représentant une couleur basée sur ses composantes cyan, magenta, jaune et noire
color_cmyk
(
cyan
,
magenta
,
yellow
,
black
)
| cyan | composante cyan de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| magenta | composante magenta de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| yellow | composante jaune de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| black | composante noire de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
color_cmyk(100,50,0,10)
→
0,115,230
Renvoie une chaîne de caractères représentant une couleur basée sur ses composantes cyan, magenta, jaune et noire et alpha (transparence)
color_cmyka
(
cyan
,
magenta
,
yellow
,
black
,
alpha
)
| cyan | composante cyan de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| magenta | composante magenta de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| yellow | composante jaune de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| black | composante noire de la couleur sous forme d'une valeur de pourcentage comprise entre 0 et 100 |
| alpha | composante alpha sous la forme d'un entier dont la valeur varie de 0 (complètement transparent) à 255 (opaque). |
color_cmyk(100,50,0,10,200)
→
0,115,230,200
Applique un filtre par niveau de gris et renvoie une représentation chaîne depuis une couleur en entrée.
color_grayscale_average
(
color
)
| color | une chaîne de caractères de couleur |
color_grayscale_average('255,100,50')
→
127,127,127,255
Renvoie une chaîne de caractères représentant une couleur basée sur ses attributs de teinte, de saturation et de luminosité.
color_hsl
(
hue
,
saturation
,
lightness
)
| hue | teinte de la couleur, sous la forme d'un entier compris entre 0 et 360 |
| saturation | pourcentage de saturation de la couleur sous forme d'un entier compris entre 0 et 100 |
| lightness | pourcentage de luminosité de la couleur sous forme d'un entier compris entre 0 et 100 |
color_hsl(100,50,70)
→
166,217,140
Renvoie une chaîne de caractères représentant une couleur basée sur ses attributs de teinte, de saturation, de luminosité et alpha (transparence).
color_hsla
(
hue
,
saturation
,
lightness
,
alpha
)
| hue | teinte de la couleur, sous la forme d'un entier compris entre 0 et 360 |
| saturation | pourcentage de saturation de la couleur sous forme d'un entier compris entre 0 et 100 |
| lightness | pourcentage de luminosité de la couleur sous forme d'un entier compris entre 0 et 100 |
| alpha | composante alpha sous la forme d'un entier dont la valeur varie de 0 (complètement transparent) à 255 (opaque). |
color_hsla(100,50,70,200)
→
166,217,140,200
Renvoie une chaîne de caractères représentant une couleur basée sur ses attributs de teinte, de saturation et de valeur.
color_hsv
(
hue
,
saturation
,
value
)
| hue | teinte de la couleur, sous la forme d'un entier compris entre 0 et 360 |
| saturation | pourcentage de saturation de la couleur sous forme d'un entier compris entre 0 et 100 |
| value | pourcentage de valeur de la couleur sous la forme d'un entier compris entre 0 et 100 |
color_hsv(40,100,100)
→
255,170,0
Renvoie une chaîne de caractères représentant une couleur basée sur ses attributs de teinte, de saturation, de valeur et alpha (transparence).
color_hsva
(
hue
,
saturation
,
value
,
alpha
)
| hue | teinte de la couleur, sous la forme d'un entier compris entre 0 et 360 |
| saturation | pourcentage de saturation de la couleur sous forme d'un entier compris entre 0 et 100 |
| value | pourcentage de valeur de la couleur sous la forme d'un entier compris entre 0 et 100 |
| alpha | composante alpha sous la forme d'un entier dont la valeur varie de 0 (complètement transparent) à 255 (opaque) |
color_hsva(40,100,100,200)
→
255,170,0,200
Renvoie une chaîne de caractères représentant une couleur basée sur ses composantes rouge, verte, bleue et sur la valeur alpha (transparence).
color_mix_rgb
(
color1
,
color2
,
ratio
)
| color1 | une chaîne de caractères de couleur |
| color2 | une chaîne de caractères de couleur |
| ratio | un ratio |
color_mix_rgb('0,0,0','255,255,255',0.5)
→
127,127,127,255
Renvoie une composante spécifique d'une chaîne de caractères de couleur, ex: la composante rouge ou la composante alpha.
color_part
(
color
,
component
)
| color | une chaîne de caractères de couleur |
| component |
une chaîne de caractère correspondant à la composante de la couleur à renvoyer. Les options valide sont :
|
color_part('200,10,30','green')
→
10
Renvoie une chaîne de caractères représentant une couleur basée sur ses composantes rouge, verte, bleue.
color_rgb
(
red
,
green
,
blue
)
| red | composante rouge sous la forme d'un entier entre 0 et 255 |
| green | composante verte sous la forme d'un entier entre 0 et 255 |
| blue | composante bleue sous la forme d'un entier entre 0 et 255 |
color_rgb(255,127,0)
→
255,127,0
Renvoie une chaîne de caractères représentant une couleur basée sur ses composantes rouge, verte, bleue et sur la valeur alpha (transparence).
color_rgba
(
red
,
green
,
blue
,
alpha
)
| red | composante rouge sous la forme d'un entier entre 0 et 255 |
| green | composante verte sous la forme d'un entier entre 0 et 255 |
| blue | composante bleue sous la forme d'un entier entre 0 et 255 |
| alpha | composante alpha sous la forme d'un entier dont la valeur varie de 0 (complètement transparent) à 255 (opaque). |
color_rgba(255,127,0,200)
→
255,127,0,200
Renvoie une rampe de dégradé à partir d'une carte de chaînes de couleurs et d'étapes.
create_ramp
(
map
[,
discrete
])
| map | une carte de cordes de couleurs et d'étapes |
| discrete | déclarer si la palette de couleur est discrète |
ramp_color(create_array(map(0,'0,0,0',1,'255,0,0')),1)
→
'255, 0, 0, 255'
Renvoie une chaîne de caractères de couleur plus sombre (ou plus claire)
darker
(
color
,
factor
)
| color | une chaîne de caractères de couleur |
| factor |
un nombre entier correspondant au facteur d'assombrissement.
|
darker('200,10,30',300)
→
'66,3,10,255'
Renvoie une chaîne de caractères de couleur plus claire (ou plus sombre)
lighter
(
color
,
factor
)
| color | une chaîne de caractères de couleur |
| factor |
un nombre entier correspondant au facteur de clarification:
|
lighter('200,10,30',200)
→
'255,158,168,255'
Renvoie une couleur du jeu de couleurs du projet.
project_color
(
name
)
| name | un nom de couleur |
project_color('Couleur Logo')
→
20,140,50
Renvoie une chaîne de caractères représentant la couleur d'une palette de couleur.
ramp_color
(
ramp_name
,
value
)
| ramp_name | le nom de la palette de couleur sous la forme d'une chaîne de caractères, par exemple: 'Spectral' |
| value | la position dans la palette de couleur à partir d'un nombre réel compris entre 0 et 1 |
ramp_color('Spectral',0.3)
→
'253,190,115,255'
Les palettes de couleur disponibles varient selon les installations de QGIS. Cette fonction peut renvoyer des valeurs erronées si vous utilisez un projet QGIS sur plusieurs installations différentes.
ramp_color
(
ramp
,
value
)
| ramp | la palette de couleurs |
| value | la position dans la palette de couleur à partir d'un nombre réel compris entre 0 et 1 |
ramp_color(create_ramp(map(0,'0,0,0',1,'255,0,0')),1)
→
'255, 0, 0, 255'
Définit une composante spécifique d'une chaîne de caractères de couleur, ex: la composante rouge ou la composante alpha.
set_color_part
(
color
,
component
,
value
)
| color | une chaîne de caractères de couleur |
| component |
une chaîne de caractère correspondant à la composante de la couleur à définir. Les options valide sont :
|
| value | nouvelle valeur pour la composante de couleur, en respectant les plages listées ci-dessus |
set_color_part('200,10,30','green',50)
→
200,50,30
Ce groupe contient des fonctions permettant de gérer des conditions dans les expressions.
Renvoie la première valeur non-NULL de la liste en expression.
Cette fonction peut prendre n'importe quel nombre d'arguments.
coalesce
(
expression1
,
expression2
…)
| expression | toute expression ou valeur valide, quel que soit le type. |
coalesce(NULL, 2)
→
2
coalesce(NULL, 2, 3)
→
2
coalesce(7, NULL, 3*2)
→
7
coalesce("fieldA", "fallbackField", 'ERROR')
→
la valeur de fieldA si celle-ci est non NULL, sinon la valeur de "fallbackfield" ou la chaîne de caractères 'ERROR' si les deux sont nulles
Teste une condition et renvoie un résultat selon la condition de vérification.
if
(
condition
,
result_when_true
,
result_when_false
)
| condition | la condition à vérifier |
| result_when_true | le résultat renvoyé lorsque la condition est évaluée à vrai ou à une valeur non convertible en faux. |
| result_when_false | le résultat renvoyé lorsque la condition est évaluée à faux ou à une valeur convertible en faux, telle que 0 ou ''. NULL est aussi convertie en faux. |
if( 1+1=2, 'Oui', 'Non' )
→
'Oui'
if( 1+1=3, 'Oui', 'Non' )
→
'Non'
if( 5 > 3, 1, 0)
→
1
if( '', 'Vrai (non vide)', 'Faux (vide)' )
→
'Faux (vide)'
if( ' ', 'Vrai (non vide)', 'Faux (vide)' )
→
'Vrai (non vide)'
if( 0, 'Un', 'Zéro' )
→
'Zéro'
if( 10, 'Un', 'Zéro' )
→
'One'
Renvoie la valeur NULL si valeur1 est égale à valeur2 ; sinon, renvoie valeur1. Cela peut être utilisé pour substituer conditionnellement des valeurs par NULL.
nullif
(
value1
,
value2
)
| value1 | La valeur qui doit être utilisée ou substituée par NULL. |
| value2 | La valeur de contrôle qui déclenchera la substitution NULL. |
nullif('(none)', '(none)')
→
NULL
nullif('text', '(none)')
→
'texte'
nullif("name", '')
→
NULL, si le nom est une chaîne de caractères vide (ou déjà NULL), le nom dans tous les autres cas.
Renvoie la première occurrence correspondante à une expression régulière dans une chaîne de caractères, ou 0 si la sous-chaîne n'a pas été trouvée.
regexp_match
(
input_string
,
regex
)
| input_string | la chaîne à tester selon l'expression rationnelle |
| regex | L'expression régulière de test. Les caractères antislash doivent être échappés deux fois (ex: "\s" correspond à un caractère d'espace). |
regexp_match('QGIS ROCKS','\sROCKS')
→
4
Essaye une expression et retourne sa valeur si elle est exempte d'erreur. Si l'expression retourne une erreur, une valeur alternative sera retournée, dans le cas contraire la fonction retournera null.
try
(
expression
[,
alternative
])
| expression | l'expression à exécuter |
| alternative | le résultat à afficher lorsque l'expression renvoie une erreur. |
try( to_int( '1' ), 0 )
→
1
try( to_int( 'a' ), 0 )
→
0
try( to_date( 'date_invalide' ) )
→
NULL
Cette catégorie contient des fonctions permettant d'effectuer des conversions de types de données telles que la conversion de textes en entiers, d'entiers en textes, etc.
Decodes a string in the Base64 encoding into a binary value.
from_base64
(
string
)
| string | the string to decode |
from_base64('UUdJUw==')
→
'QGIS'
Crée un hachage depuis une chaîne de caractères avec une méthode donnée
hash
(
string
,
method
)
| string | la chaîne à hacher |
| method | La méthode de hachage parmi 'md4', 'md5', 'sha1', 'sha224', 'sha384', 'sha512', 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512', 'keccak_224', 'keccak_256', 'keccak_384', 'keccak_512' |
hash('QGIS', md4)
→
'c0fc71c241cdebb6e888cbac0e2b68eb'
hash('QGIS', md5)
→
'57470aaa9e22adaefac7f5f342f1c6da'
hash('QGIS', sha1)
→
'f87cfb2b74cdd5867db913237024e7001e62b114'
hash('QGIS', sha224)
→
'4093a619ada631c770f44bc643ead18fb393b93d6a6af1861fcfece0'
hash('QGIS', sha256)
→
'eb045cba7a797aaa06ac58830846e40c8e8c780bc0676d3393605fae50c05309'
hash('QGIS', sha384)
→
'91c1de038cc3d09fdd512e99f9dd9922efadc39ed21d3922e69a4305cc25506033aee388e554b78714c8734f9cd7e610'
hash('QGIS', sha512)
→
'c2c092f2ab743bf8edbeb6d028a745f30fc720408465ed369421f0a4e20fa5e27f0c90ad72d3f1d836eaa5d25cd39897d4cf77e19984668ef58da6e3159f18ac'
hash('QGIS', sha3_224)
→
'467f49a5039e7280d5d42fd433e80d203439e338eaabd701f0d6c17d'
hash('QGIS', sha3_256)
→
'540f7354b6b8a6e735f2845250f15f4f3ba4f666c55574d9e9354575de0e980f'
hash('QGIS', sha3_384)
→
'96052da1e77679e9a65f60d7ead961b287977823144786386eb43647b0901fd8516fa6f1b9d243fb3f28775e6dde6107'
hash('QGIS', sha3_512)
→
'900d079dc69761da113980253aa8ac0414a8bd6d09879a916228f8743707c4758051c98445d6b8945ec854ff90655005e02aceb0a2ffc6a0ebf818745d665349'
hash('QGIS', keccak_224)
→
'5b0ce6acef8b0a121d4ac4f3eaa8503c799ad4e26a3392d1fb201478'
hash('QGIS', keccak_256)
→
'991c520aa6815392de24087f61b2ae0fd56abbfeee4a8ca019c1011d327c577e'
hash('QGIS', keccak_384)
→
'c57a3aed9d856fa04e5eeee9b62b6e027cca81ba574116d3cc1f0d48a1ef9e5886ff463ea8d0fac772ee473bf92f810d'
keccak_512('QGIS')
→
'6f0f751776b505e317de222508fa5d3ed7099d8f07c74fed54ccee6e7cdc6b89b4a085e309f2ee5210c9'
Crée un hachage md5 depuis une chaîne de caractères
md5
(
string
)
| string | la chaîne à hacher |
md5('QGIS')
→
'57470aaa9e22adaefac7f5f342f1c6da'
Crée un hash sha256 depuis une chaîne de caractères.
sha256
(
string
)
| string | la chaîne à hacher |
sha256('QGIS')
→
'eb045cba7a797aaa06ac58830846e40c8e8c780bc0676d3393605fae50c05309'
Encodes a binary value into a string, using the Base64 encoding.
to_base64
(
value
)
| value | the binary value to encode |
to_base64('QGIS')
→
'UUdJUw=='
Convertit une chaîne de caractères en objet date. Une chaîne de formatage optionnelle peut être fournie pour traiter la chaîne de caractères; voir QDateTime::fromString pour plus d'information sur ce formatage.
to_date
(
string
[,
format
][,
language
])
| string | la chaîne représentant la valeur de date |
| format | format utilisé pour convertir la chaîne de caractères en date |
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour convertir une chaîne de caractères en date |
to_date('2012-05-04')
→
2012-05-04
to_date('June 29, 2019','MMMM d, yyyy')
→
2019-06-29
to_date('29 juin, 2019','d MMMM, yyyy','fr')
→
2019-06-29
Convertit une chaîne de caractères en objet date-heure. Une chaîne de formatage optionnelle peut être fournie pour traiter la chaîne de caractères; voir QDateTime::fromString pour plus d'information sur ce formatage.
to_datetime
(
string
[,
format
][,
language
])
| string | la chaîne représentant la valeur de date et de temps |
| format | format utilisé pour convertir la chaîne de caractères en date-heure |
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour convertir une chaîne en date-heure |
to_datetime('2012-05-04 12:50:00')
→
2012-05-04T12:50:00
to_datetime('June 29, 2019 @ 12:34','MMMM d, yyyy @ HH:mm')
→
2019-06-29T12:34
to_datetime('29 juin, 2019 @ 12:34','d MMMM, yyyy @ HH:mm','fr')
→
2019-06-29T12:34
Convertir une coordonnée en degrés, minutes.
to_dm
(
coordinate
,
axis
,
precision
[,
formatting
])
| coordinate | Une longitude ou une latitude. |
| axis | L'axe de la coordonnée. Soit 'x' ou 'y'. |
| precision | Nombre de décimales |
| formatting | Désigne le type de formatage. Les valeurs acceptées sont NULL, 'aligned' ou 'suffix'. |
to_dm(6.3545681, 'x', 3)
→
6°21.274′
to_dm(6.3545681, 'y', 4, 'suffix')
→
6°21.2741′N
Convertir une coordonnée en degrés, minutes, secondes.
to_dms
(
coordinate
,
axis
,
precision
[,
formatting
])
| coordinate | Une longitude ou une latitude. |
| axis | L'axe de la coordonnée. Soit 'x' ou 'y'. |
| precision | Nombre de décimales |
| formatting | Désigne le type de formatage. Les valeurs acceptées sont NULL, 'aligned' ou 'suffix'. |
to_dms(6.3545681, 'x', 3)
→
6°21′16.445″
to_dms(6.3545681, 'y', 4, 'suffix')
→
6°21′16.4452″N
Convertit une chaîne de caractère en nombre entier. Si la valeur ne peut pas être convertie (ex: '123asd' est invalide), cette fonction ne renvoie rien.
to_int
(
string
)
| string | la chaîne à convertir en nombre entier |
to_int('123')
→
123
Convertit une chaîne de caractère en objet d'intervalle de temps. Cette fonction peut être utilisée pour récupérer les jours, heures, mois, etc. d'une date.
to_interval
(
string
)
| string | une chaîne de caractères représentant un intervalle de temps. Les formats disponibles incluent {n} jours {n} heures {n} mois. |
to_datetime('2012-05-05 12:00:00') - to_interval('1 day 2 hours')
→
2012-05-04T10:00:00
Convertit une chaîne de caractères en nombre réel. Si la valeur ne peut pas être convertie (ex: '123.56asd' est invalide), cette fonction ne renvoie rien. Les nombres sont arrondis après enregistrement si la précision est inférieure à celle du résultat après conversion.
to_real
(
string
)
| string | la chaîne de caractères à convertir en nombre réel |
to_real('123.45')
→
123.45
Convertit un nombre en chaîne de caractères.
to_string
(
number
)
| number | Valeur entière ou réelle. Le nombre à convertir en chaîne de caractères. |
to_string(123)
→
'123'
Convertit une chaîne de caractères en objet temporel. Une chaîne de format optionnelle peut être fournie pour analyser la chaîne ; voir QTime::fromString pour plus de documentation sur le format.
to_time
(
string
[,
format
][,
language
])
| string | la chaîne de caractères représentant une valeur de temps |
| format | Format utilisé pour convertir une chaîne en heure |
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour convertir une chaîne en heure |
to_time('12:30:01')
→
12:30:01
to_time('12:34','HH:mm')
→
12:34:00
to_time('12:34','HH:mm','fr')
→
12:34:00
Ce groupe contient des fonctions permettant de gérer des données de date et d'heure.
Renvoie la différence entre deux dates ou deux dates et heures.
La différence est renvoyée sous la forme d'un objet
Interval
et doit être utilisée avec une des fonctions qui suivent pour pouvoir extraire les informations utiles :
year
month
week
day
hour
minute
second
age
(
datetime1
,
datetime2
)
| datetime1 | une chaîne de caractères, une date ou une date et un temps représentant la date la plus éloignée dans le temps |
| datetime2 | une chaîne de caractères; une date ou une date et un temps représentant la date la moins éloignée dans le temps |
day(age('2012-05-12','2012-05-02'))
→
10
hour(age('2012-05-12','2012-05-02'))
→
240
Returns a datetime whose date and time are the number of milliseconds, msecs, that have passed since 1970-01-01T00:00:00.000, Coordinated Universal Time (Qt.UTC), and converted to Qt.LocalTime.
datetime_from_epoch
(
int
)
| int | nombre (millisecondes) |
datetime_from_epoch(1483225200000)
→
2017-01-01T00:00:00
Extrait le jour d'une date ou un nombre de jours depuis un intervalle.
day
(
date
)
| date | une valeur date ou datetime |
day('2012-05-12')
→
12
day
(
interval
)
| interval | Valeur d'intervalle d'où il faut extraire le nombre de jours |
day(to_interval('3 days'))
→
3
day(to_interval('3 weeks 2 days'))
→
23
day(age('2012-01-01','2010-01-01'))
→
730
Renvoie le jour de la semaine pour une date ou une valeur date et temps. La valeur retournée est comprise entre 0 et 6 où 0 correspond à dimanche et 6 à samedi.
day_of_week
(
date
)
| date | valeur de date ou de date et de temps |
day_of_week(to_date('2015-09-21'))
→
1
Retourne l'intervale en millisecondes entre l'epoch unix et une date donnée.
epoch
(
date
)
| date | une valeur date ou datetime |
epoch(to_date('2017-01-01'))
→
1483203600000
Formate une date ou une chaîne de caractères selon un format personnalisé. Utilise le formatage des dates/temps de Qt. Consultez QDateTime::toString .
format_date
(
datetime
,
format
[,
language
])
| datetime | valeur de date, de temps ou de date et de temps | ||||||||||||||||||||||||||||||||||||||||||||||||
| format |
String template used to format the string.
These expressions may be used for the time part of the format string:
|
||||||||||||||||||||||||||||||||||||||||||||||||
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour formater la date en une chaîne personnalisée |
format_date('2012-05-15','dd.MM.yyyy')
→
'15.05.2012'
format_date('2012-05-15','d MMMM yyyy','fr')
→
'15 juin 2012'
Extrait l'heure d'une variable temps ou de date-heure, ou le nombre d'heures d'un intervalle.
hour
(
datetime
)
| datetime | une valeur de temps ou de date et de temps |
hour('2012-07-22T13:24:57')
→
13
hour
(
interval
)
| interval | valeur d'intervalle où calculer le nombre d'heures |
hour(tointerval('3 hours'))
→
3
hour(age('2012-07-22T13:00:00','2012-07-22T10:00:00'))
→
3
hour(age('2012-01-01','2010-01-01'))
→
17520
Creates a date value from year, month and day numbers.
make_date
(
year
,
month
,
day
)
| year | Year number. Years 1 to 99 are interpreted as is. Year 0 is invalid. |
| month | Month number, where 1=January |
| day | Day number, beginning with 1 for the first day in the month |
make_date(2020,5,4)
→
date value 2020-05-04
Creates a datetime value from year, month, day, hour, minute and second numbers.
make_datetime
(
year
,
month
,
day
,
hour
,
minute
,
second
)
| year | Year number. Years 1 to 99 are interpreted as is. Year 0 is invalid. |
| month | Month number, where 1=January |
| day | Day number, beginning with 1 for the first day in the month |
| hour | Hour number |
| minute | Minutes |
| second | Seconds (fractional values include milliseconds) |
make_datetime(2020,5,4,13,45,30.5)
→
datetime value 2020-05-04 13:45:30.500
Creates an interval value from year, month, weeks, days, hours, minute and seconds values.
make_interval
([
years=0
][,
months=0
][,
weeks=0
][,
days=0
][,
hours=0
][,
minutes=0
][,
seconds=0
])
| years | Number of years (assumes a 365.25 day year length). |
| months | Number of months (assumes a 30 day month length) |
| weeks | Number of weeks |
| days | Number of days |
| hours | Number of hours |
| minutes | Number of minutes |
| seconds | Number of seconds |
make_interval(hours:=3)
→
3 hour interval
make_interval(days:=2, hours:=3)
→
2 day, 3 hour interval
Creates a time value from hour, minute and second numbers.
make_time
(
hour
,
minute
,
second
)
| hour | Hour number |
| minute | Minutes |
| second | Seconds (fractional values include milliseconds) |
make_time(13,45,30.5)
→
time value 13:45:30.500
Extrait les minutes composant un temps ou une date ainsi que le nombre de minutes dans un intervalle.
minute
(
datetime
)
| datetime | une valeur de temps ou de date et de temps |
minute('2012-07-22T13:24:57')
→
24
minute
(
interval
)
| interval | valeur d'intervalle à convertir en minutes |
minute(tointerval('3 minutes'))
→
3
minute(age('2012-07-22T00:20:00','2012-07-22T00:00:00'))
→
20
minute(age('2012-01-01','2010-01-01'))
→
1051200
Extrait le mois depuis une date ou le nombre de mois dans un intervalle.
month
(
date
)
| date | une valeur date ou datetime |
month('2012-05-12')
→
05
month
(
interval
)
| interval | valeur d'intervalle à convertir en nombre de mois |
month(to_interval('3 months'))
→
3
month(age('2012-01-01','2010-01-01'))
→
4.03333
Renvoie la date et l'heure courante. C'est une fonction statique qui renvoie des résultats cohérents pendant son évaluation. L'heure renvoyée est celle du moment ou l'expression est préparée.
now
()
now()
→
2012-07-22T13:24:57
Extrait les secondes d'un temps ou d'une date et d'un temps. Extrait le nombres de secondes dans un intervalle.
second
(
datetime
)
| datetime | une valeur de temps ou de date et de temps |
second('2012-07-22T13:24:57')
→
57
second
(
interval
)
| interval | valeur d'intervalle où calculer le nombre de secondes |
second(age('2012-07-22T00:20:00','2012-07-22T00:00:00'))
→
1200
second(age('2012-01-01','2010-01-01'))
→
63072000
Convertit une chaîne de caractères en objet date. Une chaîne de formatage optionnelle peut être fournie pour traiter la chaîne de caractères; voir QDateTime::fromString pour plus d'information sur ce formatage.
to_date
(
string
[,
format
][,
language
])
| string | la chaîne représentant la valeur de date |
| format | format utilisé pour convertir la chaîne de caractères en date |
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour convertir une chaîne de caractères en date |
to_date('2012-05-04')
→
2012-05-04
to_date('June 29, 2019','MMMM d, yyyy')
→
2019-06-29
to_date('29 juin, 2019','d MMMM, yyyy','fr')
→
2019-06-29
Convertit une chaîne de caractères en objet date-heure. Une chaîne de formatage optionnelle peut être fournie pour traiter la chaîne de caractères; voir QDateTime::fromString pour plus d'information sur ce formatage.
to_datetime
(
string
[,
format
][,
language
])
| string | la chaîne représentant la valeur de date et de temps |
| format | format utilisé pour convertir la chaîne de caractères en date-heure |
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour convertir une chaîne en date-heure |
to_datetime('2012-05-04 12:50:00')
→
2012-05-04T12:50:00
to_datetime('June 29, 2019 @ 12:34','MMMM d, yyyy @ HH:mm')
→
2019-06-29T12:34
to_datetime('29 juin, 2019 @ 12:34','d MMMM, yyyy @ HH:mm','fr')
→
2019-06-29T12:34
Convertit une chaîne de caractère en objet d'intervalle de temps. Cette fonction peut être utilisée pour récupérer les jours, heures, mois, etc. d'une date.
to_interval
(
string
)
| string | une chaîne de caractères représentant un intervalle de temps. Les formats disponibles incluent {n} jours {n} heures {n} mois. |
to_datetime('2012-05-05 12:00:00') - to_interval('1 day 2 hours')
→
2012-05-04T10:00:00
Convertit une chaîne de caractères en objet temporel. Une chaîne de format optionnelle peut être fournie pour analyser la chaîne ; voir QTime::fromString pour plus de documentation sur le format.
to_time
(
string
[,
format
][,
language
])
| string | la chaîne de caractères représentant une valeur de temps |
| format | Format utilisé pour convertir une chaîne en heure |
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour convertir une chaîne en heure |
to_time('12:30:01')
→
12:30:01
to_time('12:34','HH:mm')
→
12:34:00
to_time('12:34','HH:mm','fr')
→
12:34:00
Extrait le numéro de semaine d'une date ou le nombre de semaines dans un intervalle de temps.
week
(
date
)
| date | une valeur date ou datetime |
week('2012-05-12')
→
19
week
(
interval
)
| interval | valeur d'intervalle à convertir en nombre de mois |
week(tointerval('3 weeks'))
→
3
week(age('2012-01-01','2010-01-01'))
→
104.285
Extrait l'année d'une date ou le nombre d'années d'un intervalle de temps.
year
(
date
)
| date | une valeur date ou datetime |
year('2012-05-12')
→
2012
year
(
interval
)
| interval | valeur d'intervalle où calculer le nombre d'années |
year(to_interval('3 years'))
→
3
year(age('2012-01-01','2010-01-01'))
→
1.9986
Contient des fonctions qui manipulent les noms de fichiers et de chemins.
Renvoie le nom du fichier sans le répertoire ou le suffixe du fichier.
base_file_name
(
path
)
| path | Un chemin de fichier |
base_file_name('/home/qgis/data/country_boundaries.shp')
→
'country_boundaries'
Renvoie vrai si un chemin de fichier existe
file_exists
(
path
)
| path | Un chemin de fichier |
file_exists('/home/qgis/data/country_boundaries.shp')
→
vrai
Renvoie le nom d'un fichier (y compris l'extension de fichier), à l'exclusion du répertoire.
file_name
(
path
)
| path | Un chemin de fichier |
file_name('/home/qgis/data/country_boundaries.shp')
→
'country_boundaries.shp'
Renvoie le répertoire d'un chemin de fichier. Ceci n'inclut pas le nom du fichier.
file_path
(
path
)
| path | Un chemin de fichier |
file_path('/home/qgis/data/country_boundaries.shp')
→
'/home/qgis/data'
Renvoie la taille (en octets) d'un fichier.
file_size
(
path
)
| path | Un chemin de fichier |
file_size('/home/qgis/data/country_boundaries.geojson')
→
5674
Renvoie le suffixe (l'extension) d'un chemin de fichier.
file_suffix
(
path
)
| path | Un chemin de fichier |
file_suffix('/home/qgis/data/country_boundaries.shp')
→
'shp'
Renvoie vrai si le chemin correspond à un dossier.
is_directory
(
path
)
| path | Un chemin de fichier |
is_directory('/home/qgis/data/country_boundaries.shp')
→
false
is_directory('/home/qgis/data/')
→
vrai
Renvoie vrai si le chemin correspond à un fichier.
is_file
(
path
)
| path | Un chemin de fichier |
is_file('/home/qgis/data/country_boundaries.shp')
→
vrai
is_file('/home/qgis/data/')
→
false
Only usable in an embedded form context, this function returns the current, unsaved value of a field in the parent form currently being edited. This will differ from the parent feature's actual attribute values for features which are currently being edited or have not yet been added to a parent layer. When used in a value-relation widget filter expression, this function should be wrapped into a 'coalesce()' that can retrieve the actual parent feature from the layer when the form is not used in an embedded context.
current_parent_value
(
field_name
)
| field_name | a field name in the current parent form |
current_parent_value( 'FIELD_NAME' )
→
The current value of a field 'FIELD_NAME' in the parent form.
Renvoie la valeur courante non sauvegardée du champ du formulaire ou de la ligne de table en cours d'édition. Ceci diffère des valeurs d'attribut réelles de l'entité pour les entités en cours d'édition ou qui n'ont pas encore été enregistrée dans une couche.
current_value
(
field_name
)
| field_name | un nom de champ dans le formulaire courant ou dans la ligne de la table |
current_value( 'NOM_DU_CHAMP' )
→
La valeur du champ 'NOM_DU_CHAMP'.
Ce groupe contient des fonctions destinées à réaliser des comparaisons floues entre les valeurs.
Renvoie la distance de Hamming entre deux chaînes. Elle correspond au nombre de caractères aux positions correspondantes des chaînes en entrées où les caractères sont différents. Les chaînes en entrée doivent avoir la même longueur et la comparaison est sensible à la casse.
hamming_distance
(
string1
,
string2
)
| string1 | une chaîne de caractères |
| string2 | une chaîne de caractères |
hamming_distance('abc','xec')
→
2
hamming_distance('abc','ABc')
→
2
hamming_distance(upper('abc'),upper('ABC'))
→
0
Renvoie la distance de Levenshtein entre deux chaînes de caractères. Cela correspond au nombre minimum de modifications (insertions, suppression ou substitution) de caractères pour passer d'une chaîne de caractères à une autre.
La distance de Levenshtein est une mesure de la similarité entre deux chaînes de caractères. Plus la distance est faible, plus les chaînes sont semblables et plus grande est la distance, plus les chaînes sont différentes. Cette distance est sensible à la casse.
levenshtein
(
string1
,
string2
)
| string1 | une chaîne de caractères |
| string2 | une chaîne de caractères |
levenshtein('chat','chaton')
→
2
levenshtein('Chat','chat')
→
1
levenshtein(upper('Chat'),upper('chat'))
→
0
Renvoie la sous-chaîne de caractères commune la plus longue entre deux chaînes de caractères. Cette sous-chaîne est la plus longue chaîne de caractères qui est une sous-chaîne des deux chaînes de caractères en entrée. Ex: la sous-chaîne la plus longue entre "ABABC" et "BABCA" est "ABC". La sous-chaîne est sensible à la casse.
longest_common_substring
(
string1
,
string2
)
| string1 | une chaîne de caractères |
| string2 | une chaîne de caractères |
longest_common_substring('ABABC','BABCA')
→
'ABC'
longest_common_substring('abcDeF','abcdef')
→
'abc'
longest_common_substring(upper('abcDeF'),upper('abcdex'))
→
'ABCDE'
Renvoie la représentation Soundex d'une chaîne de caractères. Soundex est un algorithme de correspondance phonétique. Les chaînes avec des sons semblables seront représentées avec le même code Soundex.
soundex
(
string
)
| string | une chaîne de caractères |
soundex('robert')
→
'R163'
soundex('rupert')
→
'R163'
soundex('rubin')
→
'R150'
Ce groupe contient des fonctions génériques.
Récupère une variable d'environnement et renvoie son contenu comme chaîne de caractères. Si la variable n'est pas trouvée, `NULL` sera renvoyé. Ceci est pratique pour injecter des configurations système spécifiques comme des lettres de lecteurs ou des préfixes de chemins. La définition des variables d'environnement dépend du système d'exploitation, merci de vérifier avec votre administrateur système ou dans la documentation comment ceci doit être défini.
env
(
name
)
| name | Le nom d'une variable d'environnement à récupérer. |
env( 'LANG' )
→
'en_US.UTF-8'
env( 'MY_OWN_PREFIX_VAR' )
→
'Z:'
env( 'JE_N_EXISTE_PAS' )
→
NULL
Évalue une expression passée en chaîne de caractères. Cette fonction est utilisée pour produire les paramètres dynamiques tels que les variables de contexte ou les champs.
eval
(
expression
)
| expression | une chaîne de caractère d'expression |
eval(''sympa'')
→
'sympa'
eval(@variable_expression)
→
[quel que soit le résultat de l'évaluation de @expression_var…]
Evaluates a template which is passed in a string. Useful to expand dynamic parameters passed as context variables or fields.
eval_template
(
template
)
| template | a template string |
eval_template('QGIS [% upper(\'rocks\') %]')
→
QGIS ROCKS
Renvoie «vrai» si un calque spécifié est visible.
is_layer_visible
(
layer
)
| layer | une chaîne de caractères représentant soit un nom de couche ou un ID de couche |
is_layer_visible('raster de base')
→
True
Renvoie une propriété de couche ou une valeur de métadonnée correspondante.
layer_property
(
layer
,
property
)
| layer | une chaîne de caractères représentant soit un nom de couche ou un ID de couche |
| property |
a string corresponding to the property to return. Valid options are:
|
layer_property('streets','title')
→
'Basemap Streets'
layer_property('airports','feature_count')
→
120
layer_property('landsat','crs')
→
'EPSG:4326'
Renvoie la valeur stockée dans une variable.
var
(
name
)
| name | un nom de variable |
var('qgis_version')
→
'2.12'
Cette fonction définit une variable pour tout code d'expression qui sera fourni comme troisième argument. Ceci n'est utile que pour des expressions compliquées, où la même valeur calculée doit être utilisée dans différents endroits.
with_variable
(
name
,
value
,
expression
)
| name | le nom de la variable à définir |
| value | la valeur à définir |
| expression | l'expression pour laquelle la variable sera disponible |
with_variable('my_sum', 1 + 2 + 3, @my_sum * 2 + @my_sum * 5)
→
42
Cette catégorie contient des fonctions utilisant la géométrie des entités comme la longueur, l'aire, etc.
Renvoie la surface de l'entité courante. La surface calculée par cette fonction respecte à la fois le paramétrage de l'ellipsoide du projet et l'unité de surface. Ex: si une ellipsoide a été paramétrée pour le projet alors la surface sera ellipsoidale, sinon, elle sera calculée selon un plan.
$area
$area
→
42
Renvoie la géométrie de l'entité courante. Cette fonction peut être utilisée en combinaison avec d'autres fonctions.
$geometry
geomToWKT( $geometry )
→
POINT(6 50)
Renvoie la longueur d'une polyligne. Si vous souhaitez récupérer la longueur de la bordure d'un polygone, utilisez $perimeter à la place. La longueur calculée par cette fonction respecte les paramètres d’ellipsoïde du projet ainsi que les unités de distances. Ex: si une ellipsoïde a été paramétrée pour le projet alors la longueur sera ellipsoïdale, sinon, elle sera calculée selon un plan.
$length
$length
→
42.4711
Renvoie le périmètre de l'entité courante. Le périmètre calculé par cette fonction respecte à la fois le paramétrage de l'ellipsoide du projet et l'unité de surface. Ex: si une ellipsoide a été paramétrée pour le projet alors le périmètre sera ellipsoidal, sinon, il sera calculé selon un plan.
$perimeter
$perimeter
→
42
Récupère une coordonnée en x de la géométrie de l'entité actuelle.
$x_at
(
i
)
| i | index du point de la ligne (les index commencent à 0, les valeurs négatives s'appliquent à partir de la fin et commence à -1) |
$x_at (1)
→
5
Renvoie la coordonnée y de la géométrie de l'entité courante.
$y_at
(
i
)
| i | index du point de la ligne (les index commencent à 0, les valeurs négatives s'appliquent à partir de la fin et commence à -1) |
$y_at (1)
→
2
Renvoie la bissectrice de l'angle (angle moyen) de la géométrie pour un sommet spécifique d'une géométrie de polyligne. Les angles sont en degrés dans le sens des aiguilles d'une montre à partir du nord.
angle_at_vertex
(
geometry
,
vertex
)
| geometry | une géométrie de polyligne |
| vertex | index du sommet, à partir de 0 ; si la valeur est négative, l'index du sommet sélectionné sera le nombre total moins la valeur absolue. |
angle_at_vertex(geometry:=geom_from_wkt('LineString(0 0, 10 0, 10 10)'),vertex:=1)
→
45.0
Renvoie la surface d'une géométrie polygonale. Les calculs sont toujours planimétriques dans le Système de Coordonnées de Référence (SCR) de la géométrie et les unités de la surface correspondent aux unités du SCR. Cette fonction est différente des caculs effectués par la fonction $area qui réalise des calculs ellipsoïdaux en se basant sur les paramètres d'ellipsoïde du projet et des unités de surface.
area
(
geometry
)
| geometry | objet géométrique polygonal |
area(geom_from_wkt('POLYGON((0 0, 4 0, 4 2, 0 2, 0 0))'))
→
8.0
Renvoie l'azimut par rapport au nord sous forme d'angle en radians mesuré dans le sens des aiguilles d'une montre à partir de la verticale entre point_a et point_b.
azimuth
(
point_a
,
point_b
)
| point_a | géométrie ponctuelle |
| point_b | géométrie ponctuelle |
degrees( azimuth( make_point(25, 45), make_point(75, 100) ) )
→
42.273689
degrees( azimuth( make_point(75, 100), make_point(25,45) ) )
→
222.273689
Renvoie la fermeture de la limite combinatoire de la géométrie (c'est-à-dire la limite topologique de la géométrie). Par exemple, une géométrie de polygone aura une frontière constituée de polylignes pour chaque anneau dans le polygone. Certains types de géométrie n'ont pas de limite définie, par exemple des points ou des collections de géométrie, et renvoient null.
boundary
(
geometry
)
| geometry | une géométrie |
geom_to_wkt(boundary(geom_from_wkt('Polygon((1 1, 0 0, -1 1, 1 1))')))
→
'LineString(1 1,0 0,-1 1,1 1)'
Renvoie une géométrie représentant l'emprise d'une géométrie en entrée. Les calculs sont effectués dans le Système Spatial de Référence de cette géométrie.
bounds
(
geom
)
| geom | une géométrie |
bounds($geometry)
→
emprise de $geometry
Renvoie la hauteur de l'emprise d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de cette géométrie.
bounds_height
(
geom
)
| geom | une géométrie |
bounds_height($geometry)
→
hauteur de l'emprise de $geometry
Renvoie la largeur de l'emprise d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de cette géométrie.
bounds_width
(
geom
)
| geom | une géométrie |
bounds_width($geometry)
→
largeur de l'emprise de $geometry
Renvoie une géométrie qui représente l'ensemble des points dont la distance est inférieure ou égale à la distance avec une géométrie en entrée. Les calculs sont effectués dans le Système Spatial de Référence de cette géométrie.
buffer
(
geom
,
distance
[,
segments=8
])
| geom | une géométrie |
| distance | distance tampon dans les unités de la couche |
| segments | nombre de segments utilisés pour représenter un quart de cercle quand le style de raccordement arrondi est actif. Plus le nombre est élevé, plus la ligne apparaitra lisse et contiendra des noeuds. |
buffer($geometry, 10.5)
→
polygone de $geometry avec un tampon de 10.5 unités
Crée autour d'une ligne une zone tampon dont le diamètre varie en fonction des mesures "m" à chaque vertex.
buffer_by_m
(
geometry
[,
segments=8
])
| geometry | géométrie en entrée. Doit être de type (multi)ligne avec mesures "m". |
| segments | nombre de segments pour approximer des courbes en quart de cercle dans le tampon. |
buffer_by_m(geometry:=geom_from_wkt('LINESTRINGM(1 2 0.5, 4 2 0.2)'),segments:=8)
→
Un tampon de taille variable avec un diamètre de 0.5 et finissant par un diamètre de 0.2 le long d'une géométrie de polyligne.
Renvoie le centre géométrique d'une géométrie.
centroid
(
geom
)
| geom | une géométrie |
centroid($geometry)
→
une géométrie ponctuelle
Returns a closed line string of the input line string by appending the first point to the end of the line, if it is not already closed. If the geometry is not a line string or multi line string then the result will be null.
close_line
(
geometry
)
| geometry | une géométrie linéaire |
geom_to_wkt(close_line(geom_from_wkt('LINESTRING(0 0, 1 0, 1 1)')))
→
LineString (0 0, 1 0, 1 1, 0 0)
geom_to_wkt(close_line(geom_from_wkt('LINESTRING(0 0, 1 0, 1 1, 0 0)')))
→
LineString (0 0, 1 0, 1 1, 0 0)
Renvoie le point de la géométrie1 qui est le plus proche de la géométrie2.
closest_point
(
geometry1
,
geometry2
)
| geometry1 | géométrie qui contiendra le point le plus proche |
| geometry2 | géométrie vers laquelle trouver le point le plus proche |
geom_to_wkt(closest_point(geom_from_wkt('LINESTRING (20 80, 98 190, 110 180, 50 75 )'),geom_from_wkt('POINT(100 100)')))
→
Point(73.0769 115.384)
Réunit un ensemble de géométries dans un objet géométrique multiparties.
collect_geometries
(
geometry1
,
geometry2
…)
| geometry | une géométrie |
geom_to_wkt(collect_geometries(make_point(1,2), make_point(3,4), make_point(5,6)))
→
'MultiPoint ((1 2),(3 4),(5 6))'
collect_geometries
(
array
)
| array | tableau d'objets géomatiques |
geom_to_wkt(collect_geometries(array(make_point(1,2), make_point(3,4), make_point(5,6))))
→
'MultiPoint ((1 2),(3 4),(5 6))'
Renvoie la combinaison de deux géométries.
combine
(
geometry1
,
geometry2
)
| geometry1 | une géométrie |
| geometry2 | une géométrie |
geom_to_wkt( combine( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 2 1)' ) ) )
→
MULTILINESTRING((4 4, 2 1), (3 3, 4 4), (4 4, 5 5))
geom_to_wkt( combine( geom_from_wkt( 'LINESTRING(3 3, 4 4)' ), geom_from_wkt( 'LINESTRING(3 3, 6 6, 2 1)' ) ) )
→
LINESTRING(3 3, 4 4, 6 6, 2 1)
Teste si une géométrie en contient une autre. Renvoie vraie si et seulement si aucun point de la géométrie b se situe à l'extérieur de la géométrie a et qu'au moins un point de l'intérieur de b est situé à l'intérieur de a.
contains
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
contains( geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' ), geom_from_wkt( 'POINT(0.5 0.5 )' ) )
→
vrai
contains( geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
false
Renvoie l'enveloppe convexe d'une géométrie. Elle représente la géométrie convexe minimale qui entoure toutes les géométries du jeu de données.
convex_hull
(
geometry
)
| geometry | une géométrie |
geom_to_wkt( convex_hull( geom_from_wkt( 'LINESTRING(3 3, 4 4, 4 10)' ) ) )
→
POLYGON((3 3,4 10,4 4,3 3))
Teste si une géométrie en croise une autre. Renvoie vrai si les géométries fournies contiennent quelques points intérieurs en commun sans que tous les points le soient.
crosses
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
crosses( geom_from_wkt( 'LINESTRING(3 5, 4 4, 5 3)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
vrai
crosses( geom_from_wkt( 'POINT(4 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
false
Renvoie une géométrie qui représente la partie de la géométrie a qui ne s'intersecte pas avec la géométrie b.
difference
(
geometry_a
,
geometry_b
)
| geometry_a | une géométrie |
| geometry_b | une géométrie |
geom_to_wkt( difference( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4)' ) ) )
→
LINESTRING(4 4, 5 5)
Teste si des géométries ne s'intersectent pas. Renvoie vrai si les géométries n'ont aucune surface en commun.
disjoint
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
disjoint( geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0 ))' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
vrai
disjoint( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'POINT(4 4)' ))
→
false
Renvoie la distance minimale (basée sur le référentiel spatial) entre deux géométries dans les unités de la projection.
distance
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
distance( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'POINT(4 8)' ) )
→
4
Renvoie la distance le long de la géométrie à un sommet spécifié.
distance_to_vertex
(
geometry
,
vertex
)
| geometry | une géométrie de polyligne |
| vertex | index du sommet, à partir de 0 ; si la valeur est négative, l'index du sommet sélectionné sera le nombre total moins la valeur absolue. |
distance_to_vertex(geometry:=geom_from_wkt('LineString(0 0, 10 0, 10 10)'),vertex:=1)
→
10.0
Renvoie le dernier nœud d'une géométrie.
end_point
(
geometry
)
| geometry | objet géométrique |
geom_to_wkt(end_point(geom_from_wkt('LINESTRING(4 0, 4 2, 0 2)')))
→
'Point (0 2)'
Étire d'une valeur spécifiée le début et la fin d'une géométrie de type polyligne. Les lignes sont étirées en prenant en compte l'inclinaison du premier et du dernier lien. Les distances sont exprimées dans le Système Spatial de Référence de cette géométrie.
extend
(
geometry
,
start_distance
,
end_distance
)
| geometry | une géométrie (multi)polyligne |
| start_distance | la distance d'étirement du début et de la fin de la ligne |
| end_distance | distance d'étirement de la fin de la ligne. |
geom_to_wkt(extend(geom_from_wkt('LineString(0 0, 1 0, 1 1)'),1,2))
→
LineString (-1 0, 1 0, 1 3)
Renvoie une ligne représentant l'anneau extérieur d'une géométrie de polygone. Si la géométrie n'est pas un polygone alors le resultat sera NULL.
exterior_ring
(
geom
)
| geom | une géométrie polygonale |
geom_to_wkt(exterior_ring(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),( 0.1 0.1, 0.1 0.2, 0.2 0.2, 0.2, 0.1, 0.1 0.1))')))
→
'LineString (-1 -1, 4 0, 4 2, 0 2, -1 -1)'
Renvoie une version extrudée d'une géométrie (Multi-)Courbe ou d'une (Multi-)Polyligne avec une extension indiquée par x et y.
extrude
(
geom
,
x
,
y
)
| geom | une géométrie polygonale |
| x | extension x, valeur numérique |
| y | extension y, valeur numérique |
extrude(geom_from_wkt('LineString(1 2, 3 2, 4 3)'), 1, 2)
→
Polygon ((1 2, 3 2, 4 3, 5 5, 4 4, 2 4, 1 2))
extrude(geom_from_wkt('MultiLineString((1 2, 3 2), (4 3, 8 3)'), 1, 2)
→
MultiPolygon (((1 2, 3 2, 4 4, 2 4, 1 2)),((4 3, 8 3, 9 5, 5 5, 4 3)))
Retourne une copie de la géométrie avec les valeurs de coordonnées X et Y inversées. Il peut être utilisé pour réparer des géométries dont les valeurs de latitude et de longitude ont été inversées.
flip_coordinates
(
geom
)
| geom | une géométrie |
geom_to_wkt(flip_coordinates(make_point(1, 2)))
→
Point (2 1)
Force une géométrie à respecter la règle de la main droite, dans laquelle la zone délimitée par un polygone se trouve à la droite de la frontière. En particulier, l'anneau extérieur est orienté dans le sens des aiguilles d'une montre et les anneaux intérieurs dans le sens inverse.
force_rhr
(
geom
)
| geom | Une géométrie. Toutes les géométries non polygonales sont renvoyées inchangées. |
geom_to_wkt(force_rhr(geometry:=geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1))')))
→
Polygon ((-1 -1, 0 2, 4 2, 4 0, -1 -1))
Renvoie une géométrie à partir d'une représentation géométrique GML.
geom_from_gml
(
gml
)
| gml | représentation GML d'une géométrie sous la forme d'une chaîne de caractères |
geom_from_gml('<gml:LineString srsName="EPSG:4326"><gml:coordinates>4,4 5,5 6,6</gml:coordinates></gml:LineString>')
→
un objet géométrique linéaire
Renvoie une géométrie créée depuis une représentation en Well-Known Binary (WKB).
geom_from_wkb
(
binary
)
| binary | Représentation en Well-Known Binary (WKB) d'une géométrie (comme un blob) |
geom_from_wkb( geom_to_wkb( make_point(4,5) ) )
→
un objet géométrique ponctuel
Renvoie une géométrie créée à partir d'une représentation Well-Known Text (WKT).
geom_from_wkt
(
text
)
| text | Représentation Well-Known Text (WKT) d'une géométrie |
geom_from_wkt( 'POINT(4 5)' )
→
un objet géométrique
Returns the Well-Known Binary (WKB) representation of a geometry
geom_to_wkb
(
geometry
)
| geometry | une géométrie |
geom_to_wkb( $geometry )
→
Un blob contenant un objet géométrique
Renvoie la représentation Well-Known Text (WKT) d'une géométrie sans les métadonnées de SRID.
geom_to_wkt
(
geometry
[,
precision
])
| geometry | une géométrie |
| precision | précision numérique |
geom_to_wkt( $geometry )
→
POINT(6 50)
Renvoie la géométrie d'une entité.
geometry
(
feature
)
| feature | un objet d'entité |
geom_to_wkt( geometry( get_feature( layer, attributeField, value ) ) )
→
'POINT(6 50)'
intersects( $geometry, geometry( get_feature( layer, attributeField, value ) ) )
→
vrai
Renvoie une géométrie donnée d'une collection de géométrie ou NULL si la géométrie en entrée n'est pas une collection.
geometry_n
(
geometry
,
index
)
| geometry | collection de géométrie |
| index | index de la géométrie à renvoyer où 1 est la première géométrie de la collection |
geom_to_wkt(geometry_n(geom_from_wkt('GEOMETRYCOLLECTION(POINT(0 1), POINT(0 0), POINT(1 0), POINT(1 1))'),3))
→
'Point (1 0)'
Renvoie la distance Hausdorff entre deux géométries. Il s'agit essentiellement d'une mesure de la géométrie similaire ou différente de deux géométries, avec une distance inférieure indiquant des géométries similaires.
La fonction peut être exécutée avec un argument de fraction de densité facultatif. Si elle n'est pas spécifiée, une approximation de la distance standard de Hausdorff est utilisée. Cette approximation est exacte ou assez proche pour un grand sous-ensemble de cas utiles. Des exemples sont:
hausdorff_distance
(
geometry a
,
geometry b
[,
densify_fraction
])
| geometry a | une géométrie |
| geometry b | une géométrie |
| densify_fraction | densifier le montant de la fraction |
hausdorff_distance( geometry1:= geom_from_wkt('LINESTRING (0 0, 2 1)'),geometry2:=geom_from_wkt('LINESTRING (0 0, 2 0)'))
→
2
hausdorff_distance( geom_from_wkt('LINESTRING (130 0, 0 0, 0 150)'),geom_from_wkt('LINESTRING (10 10, 10 150, 130 10)'))
→
14.142135623
hausdorff_distance( geom_from_wkt('LINESTRING (130 0, 0 0, 0 150)'),geom_from_wkt('LINESTRING (10 10, 10 150, 130 10)'),0.5)
→
70.0
Renvoie l'inclinaison mesurée du zénith (0) au nadir (180) du point_a au point_b.
inclination
(
point_a
,
point_b
)
| point_a | géométrie ponctuelle |
| point_b | géométrie ponctuelle |
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 5 ) )
→
0.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 50, 100, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, -5 ) )
→
180.0
Renvoie un anneau intérieur donné d'une géométrie polygonale ou NULL si la géométrie n'est pas un polygone.
interior_ring_n
(
geometry
,
index
)
| geometry | géométrie polygonale |
| index | index de l'anneau intérieur à renvoyer où 1 est le premier anneau intérieur |
geom_to_wkt(interior_ring_n(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),(-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1),(-1 -1, 4 0, 4 2, 0 2, -1 -1))'),1))
→
'LineString (-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1))'
Renvoie une géométrie qui représente la portion commune de deux géométries.
intersection
(
geometry1
,
geometry2
)
| geometry1 | une géométrie |
| geometry2 | une géométrie |
geom_to_wkt( intersection( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4)' ) ) )
→
LINESTRING(3 3, 4 4)
Teste si une géométrie en intersecte une autre. Renvoie vrai si les géométries s'intersectent (partage n'importe quelle portion de leur surface) et faux dans le cas contraire.
intersects
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
intersects( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
vrai
intersects( geom_from_wkt( 'POINT(4 5)' ), geom_from_wkt( 'POINT(5 5)' ) )
→
false
Teste si une emprise de géométrie en chevauche une autre. Renvoie vrai si la géométrie intersecte l'emprise définie et faux dans le cas contraire.
intersects_bbox
(
geometry
,
geometry
)
| geometry | une géométrie |
| geometry | une géométrie |
intersects_bbox( geom_from_wkt( 'POINT(4 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
vrai
intersects_bbox( geom_from_wkt( 'POINT(6 5)' ), geom_from_wkt( 'POLYGON((3 3, 4 4, 5 5, 3 3))' ) )
→
false
Renvoie true si une ligne est fermée (le point de début et le point de fin sont identiques) ou false si une ligne n'est pas fermée. Si la géométrie n'est pas une ligne, le résultat sera NULL.
is_closed
(
geom
)
| geom | une géométrie linéaire |
is_closed(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)'))
→
false
is_closed(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2, 0 0)'))
→
vrai
Renvoie true si une géométrie est vide (sans coordonnées), false si la géométrie n'est pas vide et NULL s'il y a aucune géométrie. Voir aussi `is_empty_or_null`.
is_empty
(
geom
)
| geom | une géométrie |
is_empty(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)'))
→
false
is_empty(geom_from_wkt('LINESTRING EMPTY'))
→
vrai
is_empty(geom_from_wkt('POINT(7 4)'))
→
false
is_empty(geom_from_wkt('POINT EMPTY'))
→
vrai
Renvoie true si une géométrie est NULL ou vide (sans coordonnées) ou sinon false. Cette fonction est comme l'expression '$geometry IS NULL or is_empty($geometry)'
is_empty_or_null
(
geom
)
| geom | une géométrie |
is_empty_or_null(NULL)
→
vrai
is_empty_or_null(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)'))
→
false
is_empty_or_null(geom_from_wkt('LINESTRING VIDE'))
→
vrai
is_empty_or_null(geom_from_wkt('POINT(7 4)'))
→
false
is_empty_or_null(geom_from_wkt('POINT VIDE'))
→
vrai
Returns true if the geometry is of Multi type.
is_multipart
(
geometry
)
| geometry | une géométrie |
is_multipart(geom_from_wkt('MULTIPOINT ((0 0),(1 1),(2 2))'))
→
vrai
is_multipart(geom_from_wkt('POINT (0 0)'))
→
false
Renvoie true si une géométrie est valide ; si elle est bien formée en 2D selon les règles de l'OGC.
is_valid
(
geom
)
| geom | une géométrie |
is_valid(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2, 0 0)'))
→
vrai
is_valid(geom_from_wkt('LINESTRING(0 0)'))
→
false
Renvoie le nombre de caractères d'une chaîne de caractères ou la longueur d'une géométrie de polylignes.
length
(
string
)
| string | chaîne de caractères dont il faut calculer la longueur |
length('salut')
→
5
length
(
geometry
)
| geometry | un objet géométrique linéaire |
length(geom_from_wkt('LINESTRING(0 0, 4 0)'))
→
4.0
Renvoie l'angle parallèle à la géométrie à une distance spécifiée le long d'une géométrie de polyligne. Les angles sont en degrés dans le sens des aiguilles d'une montre par rapport au nord.
line_interpolate_angle
(
geometry
,
distance
)
| geometry | une géométrie de polyligne |
| distance | distance le long de la ligne à laquelle l'interpolation de l'angle sera réalisée |
line_interpolate_angle(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),distance:=5)
→
90.0
Renvoie l'interpolation d'un point situé à une certaine distance le long d'une géométrie de type polyligne.
line_interpolate_point
(
geometry
,
distance
)
| geometry | une géométrie de polyligne |
| distance | Distance le long de la ligne à interpoler |
geom_to_wkt(line_interpolate_point(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),distance:=5))
→
'Point (5 0)'
Renvoie la distance le long d'une géométrie de type polyligne correspondant à la longueur de cette ligne à la plus proche position d'un point spécifié.
line_locate_point
(
geometry
,
point
)
| geometry | une géométrie de polyligne |
| point | géométrie de type point utilisée pour situer la plus proche position sur la polyligne |
line_locate_point(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),point:=geom_from_wkt('Point(5 0)'))
→
5.0
Renvoie une géométrie de type polyligne ou multi-polyligne dans laquelle toutes les polylignes connectées de la geométrie en entrée ont été fusionnées en une seule polyligne. Cette fonction renverra null si la géométrie en argument n'est pas du type polyligne/multi-polyligne.
line_merge
(
geometry
)
| geometry | une géométrie de type polyligne/multi-polyligne |
geom_to_wkt(line_merge(geom_from_wkt('MULTILINESTRING((0 0, 1 1),(1 1, 2 2))')))
→
'LineString(0 0,1 1,2 2)'
geom_to_wkt(line_merge(geom_from_wkt('MULTILINESTRING((0 0, 1 1),(11 1, 21 2))')))
→
'MultiLineString((0 0, 1 1),(11 1, 21 2)'
Cet algorithme renvoie la partie d'une ligne (ou courbe) comprise entre les distances de début et de fin spécifiées (mesurées à partir du début de la ligne). Les valeurs Z et M sont interpolées linéairement à partir des valeurs existantes.
line_substring
(
geometry
,
start_distance
,
end_distance
)
| geometry | une géométrie de polyligne ou de courbe |
| start_distance | distance pour le début d'un sous segment |
| end_distance | distance pour la fin d'un sous segment |
geom_to_wkt(line_substring(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),start_distance:=2,end_distance=6))
→
'LineString (2 0,6 0)'
Renvoie la valeur m d'une géométrie de type point.
m
(
geom
)
| geom | une géométrie ponctuelle |
m( geom_from_wkt( 'POINTM(2 5 4)' ) )
→
4
Returns the maximum m (measure) value of a geometry.
m_max
(
geometry
)
| geometry | a geometry containing m values |
m_max( make_point_m( 0,0,1 ) )
→
1
m_max(make_line( make_point_m( 0,0,1 ), make_point_m( -1,-1,2 ), make_point_m( -2,-2,0 ) ) )
→
2
Returns the minimum m (measure) value of a geometry.
m_min
(
geometry
)
| geometry | a geometry containing m values |
m_min( make_point_m( 0,0,1 ) )
→
1
m_min(make_line( make_point_m( 0,0,1 ), make_point_m( -1,-1,2 ), make_point_m( -2,-2,0 ) ) )
→
0
Crée un polygone circulaire.
make_circle
(
center
,
radius
[,
segment=36
]…)
| center | point du centre du cercle |
| radius | rayon du cercle |
| segment | argument en option pour la segmentation du polygone. Par défaut, cette valeur vaut 36 |
geom_to_wkt(make_circle(make_point(10,10), 5, 4))
→
'Polygon ((10 15, 15 10, 10 5, 5 10, 10 15))'
geom_to_wkt(make_circle(make_point(10,10,5), 5, 4))
→
'PolygonZ ((10 15 5, 15 10 5, 10 5 5, 5 10 5, 10 15 5))'
geom_to_wkt(make_circle(make_point(10,10,5,30), 5, 4))
→
'PolygonZM ((10 15 5 30, 15 10 5 30, 10 5 5 30, 5 10 5 30, 10 15 5 30))'
Créé un polygone elliptique.
make_ellipse
(
center
,
semi_major_axis
,
semi_minor_axis
,
azimuth
[,
segment=36
]…)
| center | point du centre de l'ellipse |
| semi_major_axis | demi-grand axe de l'ellipse |
| semi_minor_axis | demi-petit axe de l'ellipse |
| azimuth | orientation de l'ellipse |
| segment | argument en option pour la segmentation du polygone. Par défaut, cette valeur vaut 36 |
geom_to_wkt(make_ellipse(make_point(10,10), 5, 2, 90, 4))
→
'Polygon ((15 10, 10 8, 5 10, 10 12, 15 10))'
geom_to_wkt(make_ellipse(make_point(10,10,5), 5, 2, 90, 4))
→
'PolygonZ ((15 10 5, 10 8 5, 5 10 5, 10 12 5, 15 10 5))'
geom_to_wkt(make_ellipse(make_point(10,10,5,30), 5, 2, 90, 4))
→
'PolygonZM ((15 10 5 30, 10 8 5 30, 5 10 5 30, 10 12 5 30, 15 10 5 30))'
Créé une géométrie linéaire à partir d'une série de géométries ponctuelles.
make_line
(
point1
,
point2
…)
| point | une géométrie ponctuelle (ou un tableau de points) |
geom_to_wkt(make_line(make_point(2,4),make_point(3,5)))
→
'LineString (2 4, 3 5)'
geom_to_wkt(make_line(make_point(2,4),make_point(3,5),make_point(9,7)))
→
'LineString (2 4, 3 5, 9 7)'
make_line
(
array
)
| array | tableau de points |
geom_to_wkt(make_line(array(make_point(2,4),make_point(3,5),make_point(9,7))))
→
'LineString (2 4, 3 5, 9 7)'
Créé une géométrie ponctuelle à partir des valeurs x et y (et optionellement des valeurs z et m).
make_point
(
x
,
y
[,
z
][,
m
])
| x | coordonnée x du point |
| y | coordonnée y du point |
| z | coordonnée optionnelle z du point |
| m | valeur optionnelle m du point |
geom_to_wkt(make_point(2,4))
→
'Point (2 4)'
geom_to_wkt(make_point(2,4,6))
→
'PointZ (2 4 6)'
geom_to_wkt(make_point(2,4,6,8))
→
'PointZM (2 4 6 8)'
Créé une géométrie ponctuelle à partir d'une valeur en x et en y et d'une valeur m.
make_point_m
(
x
,
y
,
m
)
| x | coordonnée x du point |
| y | coordonnée y du point |
| m | valeur m du point |
geom_to_wkt(make_point_m(2,4,6))
→
'PointM (2 4 6)'
Créé une géométrie polygonale à partir d'un anneau externe et de séries optionnelles de géométries d'anneaux internes.
make_polygon
(
outerRing
[,
innerRing1
][,
innerRing2
]…)
| outerRing | géométrie linéaire fermée de l'anneau extérieur du polygone |
| innerRing | géométrie linéaire fermée optionnelle pour l'anneau intérieur |
geom_to_wkt(make_polygon(geom_from_wkt('LINESTRING( 0 0, 0 1, 1 1, 1 0, 0 0 )')))
→
'Polygon ((0 0, 0 1, 1 1, 1 0, 0 0))'
geom_to_wkt(make_polygon(geom_from_wkt('LINESTRING( 0 0, 0 1, 1 1, 1 0, 0 0 )'),geom_from_wkt('LINESTRING( 0.1 0.1, 0.1 0.2, 0.2 0.2, 0.2 0.1, 0.1 0.1 )'),geom_from_wkt('LINESTRING( 0.8 0.8, 0.8 0.9, 0.9 0.9, 0.9 0.8, 0.8 0.8 )')))
→
'Polygon ((0 0, 0 1, 1 1, 1 0, 0 0),(0.1 0.1, 0.1 0.2, 0.2 0.2, 0.2 0.1, 0.1 0.1),(0.8 0.8, 0.8 0.9, 0.9 0.9, 0.9 0.8, 0.8 0.8))'
Creates a rectangle from 3 points.
make_rectangle_3points
(
point1
,
point2
,
point3
[,
option=0
]…)
| point1 | Premier point. |
| point2 | Deuxième point. |
| point3 | Troisième point. |
| option | Un argument facultatif pour construire le rectangle. Par défaut, cette valeur est 0. La valeur peut être 0 (distance) ou 1 (projeté). Option distance : La seconde distance est égale à la distance entre le 2ème et le 3ème point. Option projeté : La seconde distance est égale à la distance de la projection perpendiculaire du 3ème point sur le segment ou son extension. |
geom_to_wkt(make_rectangle(make_point(0, 0), make_point(0,5), make_point(5, 5), 0)))
→
'Polygon ((0 0, 0 5, 5 5, 5 0, 0 0))'
geom_to_wkt(make_rectangle(make_point(0, 0), make_point(0,5), make_point(5, 3), 1)))
→
'Polygon ((0 0, 0 5, 5 5, 5 0, 0 0))'
Créé un polygone régulier.
make_regular_polygon
(
center
,
radius
,
number_sides
[,
circle=0
]…)
| center | centre du polygone régulier |
| radius | second point. Premier point si le polygone régulier est inscrit. Le point du milieu du premier côté si le polygone régulier est circonscrit |
| number_sides | Nombre de côtés/arrêtes du polygone régulier |
| circle | Argument optionnel pour la construction du polygone régulier. Par défaut, cette valeur vaut 0. Elle peut prendre la valeur 0 (inscrit) ou 1 (circonscrit) |
geom_to_wkt(make_regular_polygon(make_point(0,0), make_point(0,5), 5))
→
'Polygon ((0 5, 4.76 1.55, 2.94 -4.05, -2.94 -4.05, -4.76 1.55, 0 5))'
geom_to_wkt(make_regular_polygon(make_point(0,0), project(make_point(0,0), 4.0451, radians(36)), 5))
→
'Polygon ((0 5, 4.76 1.55, 2.94 -4.05, -2.94 -4.05, -4.76 1.55, 0 5))'
Crée un carré à partir d'une diagonale.
make_square
(
point1
,
point2
…)
| point1 | Premier point du polygone régulier |
| point2 | Deuxième point |
geom_to_wkt(make_square( make_point(0,0), make_point(5,5)))
→
'Polygon ((0 0, -0 5, 5 5, 5 0, 0 0))'
geom_to_wkt(make_square( make_point(5,0), make_point(5,5)))
→
'Polygon ((5 0, 2.5 2.5, 5 5, 7.5 2.5, 5 0))'
Créer un polygone triangle.
make_triangle
(
point 1
,
point 2
,
point 3
)
| point 1 | premier point du triangle |
| point 2 | second point du triangle |
| point 3 | troisième point du triangle |
geom_to_wkt(make_triangle(make_point(0,0), make_point(5,5), make_point(0,10)))
→
'Triangle ((0 0, 5 5, 0 10, 0 0))'
geom_to_wkt(boundary(make_triangle(make_point(0,0), make_point(5,5), make_point(0,10))))
→
'LineString (0 0, 5 5, 0 10, 0 0)'
Renvoie le cercle de fermeture minimal d'une géométrie. Il représente le cercle minimum qui renferme toutes les géométries dans l'ensemble.
minimal_circle
(
geometry
[,
segment=36
])
| geometry | une géométrie |
| segment | argument en option pour la segmentation du polygone. Par défaut, cette valeur vaut 36 |
geom_to_wkt( minimal_circle( geom_from_wkt( 'LINESTRING(0 5, 0 -5, 2 1)' ), 4 ) )
→
Polygon ((0 5, 5 -0, -0 -5, -5 0, 0 5))
geom_to_wkt( minimal_circle( geom_from_wkt( 'MULTIPOINT(1 2, 3 4, 3 2)' ), 4 ) )
→
Polygon ((3 4, 3 2, 1 2, 1 4, 3 4))
Renvoie une géométrie multi-point composée de chaque nœud de la géométrie en entrée.
nodes_to_points
(
geometry
[,
ignore_closing_nodes=false
])
| geometry | objet géométrique |
| ignore_closing_nodes | argument optionnel indiquant s'il faut inclure les nœuds dupliqués qui ferment les lignes ou les anneaux de polygones. La valeur par défaut est 'false' et modifiée à 'true' pour éviter que ces nœuds dupliqués soient présent dans la collection de géométrie en sortie. |
geom_to_wkt(nodes_to_points(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)')))
→
'MultiPoint ((0 0),(1 1),(2 2))'
geom_to_wkt(nodes_to_points(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1))'),true))
→
'MultiPoint ((-1 -1),(4 0),(4 2),(0 2))'
Renvoie le nombre de géométries dans une collection de géométrie ou NULL si la géométrie en entrée n'est pas une collection.
num_geometries
(
geometry
)
| geometry | collection de géométrie |
num_geometries(geom_from_wkt('GEOMETRYCOLLECTION(POINT(0 1), POINT(0 0), POINT(1 0), POINT(1 1))'))
→
4
Renvoie le nombre d'anneaux intérieurs dans un polygone ou dans une collection de géométrie ou NULL si la géométrie en entrée n'est pas un polygone ou une collection.
num_interior_rings
(
geometry
)
| geometry | géométrie en entrée |
num_interior_rings(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),(-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1))'))
→
1
Renvoie le nombre de sommets d'une géométrie.
num_points
(
geom
)
| geom | une géométrie |
num_points($geometry)
→
nombre de sommets dans $geometry
Renvoie le nombre d'anneaux (incluant les anneaux extérieurs) d'un polygone ou d'une collection de géométrie ou bien NULL si la géométrie en entrée n'est pas un polygone ou une collection.
num_rings
(
geometry
)
| geometry | géométrie en entrée |
num_rings(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),(-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1))'))
→
2
Renvoie une géométrie formée en décalant sur un côté une géométrie de type polyligne. Les distances sont exprimées dans le Système Spatial de Référence de cette géométrie.
offset_curve
(
geometry
,
distance
[,
segments=8
][,
join=1
][,
miter_limit=2.0
])
| geometry | une géométrie (multi)polyligne |
| distance | distance de décalage. Les valeurs positives produiront un tampon à gauche des lignes, les valeurs négatives, à droite |
| segments | nombre de segments utilisés pour représenter un quart de cercle quand le style de raccordement arrondi est actif. Plus le nombre est élevé, plus la ligne apparaitra lisse et contiendra des noeuds. |
| join | style de raccordement pour les angles, avec 1 = arrondi, 2 = angle droit, 3 = chanfreiné |
| miter_limit | valeur limite du ratio d'angle droit utilisé pour les angles très vifs (uniquement pour le style de raccordement par angle droit) |
offset_curve($geometry, 10.5)
→
décalage de ligne sur la gauche de 10.5 unités
offset_curve($geometry, -10.5)
→
décalage de ligne sur la droite de 10.5 unités
offset_curve($geometry, 10.5, segments=16, join=1)
→
Décalage de ligne vers la gauche de 10.5 unités, en utilisant plus de segments pour obtenir une courbe plus lisse
offset_curve($geometry, 10.5, join=3)
→
décalage de ligne sur la gauche de 10.5 unités, en utilisant une jointure biseautée
Ré-arrange les parties d'une géométrie multiple selon le critère donné
order_parts
(
geom
,
orderby
,
ascending
)
| geom | une géométrie multiple |
| orderby | une chaîne de caractères d'expression définissant le critère de tri |
| ascending | booléen, True pour ascendant, False pour descendant |
order_parts(geom_from_wkt('MultiPolygon (((1 1, 5 1, 5 5, 1 5, 1 1)),((1 1, 9 1, 9 9, 1 9, 1 1)))'), 'area($geometry)', False)
→
MultiPolygon (((1 1, 9 1, 9 9, 1 9, 1 1)),((1 1, 5 1, 5 5, 1 5, 1 1)))
order_parts(geom_from_wkt('LineString(1 2, 3 2, 4 3)'), '1', True)
→
LineString(1 2, 3 2, 4 3)
Renvoie une géométrie qui représente la zone de délimitation orientée minimale d'une géométrie en entrée.
oriented_bbox
(
geom
)
| geom | une géométrie |
geom_to_wkt( oriented_bbox( geom_from_wkt( 'MULTIPOINT(1 2, 3 4, 3 2)' ) ) )
→
Polygon ((1 4, 1 2, 3 2, 3 4, 1 4))
Teste si une géométrie recouvre totalement une autre. Renvoie vrai si les géométries partagent la même surface, sont de même dimension mais ne sont pas complètement contenues l'une dans l'autre.
overlaps
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
overlaps( geom_from_wkt( 'LINESTRING(3 5, 4 4, 5 5, 5 3)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
vrai
overlaps( geom_from_wkt( 'LINESTRING(0 0, 1 1)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
false
Renvoie le périmètre d'une géométrie polygonale. Les calculs sont toujours planimétriques dans le Système de Coordonnées de Référence (SCR) de la géométrie et les unités du périmètre correspondent aux unités du SCR. Cette fonction est différente des caculs effectués par la fonction $perimeter qui réalise des calculs ellipsoïdaux en se basant sur les paramètres d'ellipsoïde du projet et des unités de longueur.
perimeter
(
geometry
)
| geometry | objet géométrique polygonal |
perimeter(geom_from_wkt('POLYGON((0 0, 4 0, 4 2, 0 2, 0 0))'))
→
12.0
Renvoie un nœud donné d'une géométrie.
point_n
(
geometry
,
index
)
| geometry | objet géométrique |
| index | index du sommet à retourner, où 1 est le premier sommet; si la valeur est négative, l'index du sommet sélectionné sera le nombre total moins la valeur absolue |
geom_to_wkt(point_n(geom_from_wkt('POLYGON((0 0, 4 0, 4 2, 0 2, 0 0))'),2))
→
'Point (4 0)'
Renvoie un point qui est certainement situé à la surface d'une géométrie.
point_on_surface
(
geom
)
| geom | une géométrie |
point_on_surface($geometry)
→
une géométrie ponctuelle
Calcules le pôle d'inaccessibilité approximatif pour une surface, qui est le point le plus éloigné des frontières de cette surface. Cette fonction utilise l'algorithme 'polylabel' (Vladimir Agafonkin, 2016) qui fonctionne suivant une approche itérative afin de trouver le véritable pôle d'inaccessibilité avec une certaine tolérance. Des tolérances plus précises engendrent plus d'itérations et prennent plus de temps.
pole_of_inaccessibility
(
geometry
,
tolerance
)
| geometry | une géométrie |
| tolerance | distance maximale entre le point renvoyé et l'emplacement du vrai pôle |
geom_to_wkt(pole_of_inaccessibility( geom_from_wkt('POLYGON((0 1,0 9,3 10,3 3, 10 3, 10 1, 0 1))'), 0.1))
→
Point(1.55, 1.55)
Renvoie un point projeté depuis un point de départ en utilisant une distance et une direction (azimuth) en radians.
project
(
point
,
distance
,
azimuth
[,
elevation
])
| point | point de départ |
| distance | distance à projeter |
| azimuth | direction en radians dans le sens des aiguilles d'une montre, où 0 correspond au Nord |
| elevation | angle d'inclinaison en radians |
geom_to_wkt(project(make_point(1, 2), 3, radians(270)))
→
Point(-2, 2)
Teste la représentation du Modèle Dimensionnel Étendu à 9 Intersections (DE-9IM en anglais) de la relation entre deux géométries.
relate
(
geometry
,
geometry
)
| geometry | une géométrie |
| geometry | une géométrie |
relate( geom_from_wkt( 'LINESTRING(40 40,120 120)' ), geom_from_wkt( 'LINESTRING(40 40,60 120)' ) )
→
'FF1F00102'
relate
(
geometry
,
geometry
,
pattern
)
| geometry | une géométrie |
| geometry | une géométrie |
| pattern | motif de correspondance DE-9IM |
relate( geom_from_wkt( 'LINESTRING(40 40,120 120)' ), geom_from_wkt( 'LINESTRING(40 40,60 120)' ), '**1F001**' )
→
True
Inverse la direction d'une géométrie linéaire en inversant l'ordre de ses sommets.
reverse
(
geom
)
| geom | une géométrie |
geom_to_wkt(reverse(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)')))
→
'LINESTRING(2 2, 1 1, 0 0)'
Renvoie une version pivotée d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de cette géométrie.
rotate
(
geom
,
rotation
[,
point
])
| geom | une géométrie |
| rotation | rotation horaire en degrés |
| point | point central de rotation. S'il n'est pas spécifié, le centre de l'emprise de la géométrie sera utilisé. |
rotate($geometry, 45, make_point(4, 5))
→
géométrie pivotée de 45 degrés dans le sens horaire autour du point (4, 5)
rotate($geometry, 45)
→
géométrie pivotée de 45 degrés dans le sens horaire autour du centre de son emprise
Renvoie une géométrie multi-ligne composée d'une ligne pour chaque segment de la géométrie en entrée.
segments_to_lines
(
geometry
)
| geometry | objet géométrique |
geom_to_wkt(segments_to_lines(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)')))
→
'MultiLineString ((0 0, 1 1),(1 1, 2 2))'
Renvoie la plus courte ligne joignant la géométrie 1 à la géométrie 2. La ligne résultante commencera sur la géométrie 1 et se terminera sur la géométrie 2.
shortest_line
(
geometry1
,
geometry2
)
| geometry1 | géométrie à partir de laquelle trouver la ligne la plus courte |
| geometry2 | géométrie vers laquelle trouver la ligne la plus courte |
geom_to_wkt(shortest_line(geom_from_wkt('LINESTRING (20 80, 98 190, 110 180, 50 75 )'),geom_from_wkt('POINT(100 100)')))
→
LineString(73.0769 115.384, 100 100)
Simplifie une géométrie en supprimant les nœuds en utilisant un seuil basé sur la distance (c'est-à-dire l'algorithme de Douglas Peucker). L'algorithme conserve de grands écarts dans les géométries et réduit le nombre de noeuds dans les segments presque droits.
simplify
(
geometry
,
tolerance
)
| geometry | une géométrie |
| tolerance | Écart maximum par rapport aux segments droits pour les points devant être supprimés |
geom_to_wkt(simplify(geometry:=geom_from_wkt('LineString(0 0, 5 0.1, 10 0)'),tolerance:=5))
→
'LineString(0 0, 10 0)'
Simplifie une géométrie par suppression de noeuds en utilisant un seuil basé sur une zone (l'algorithme du Visvalingam-Whyatt). L'algorithme efface les arêtes qui correspondent à des zones trop petites, par exemple les pics très étroits ou les segments quasi alignés.
simplify_vw
(
geometry
,
tolerance
)
| geometry | une géométrie |
| tolerance | une mesure de la superficie maximale créée par un nœud pour le nœud à supprimer |
geom_to_wkt(simplify_vw(geometry:=geom_from_wkt('LineString(0 0, 5 0, 5.01 10, 5.02 0, 10 0)'),tolerance:=5))
→
'LineString(0 0, 10 0)'
Renvoie une géométrie formée par un tampon appliqué sur un seul côté d'une géométrie de type polyligne. Les distances sont exprimées dans le Système Spatial de Référence de cette géométrie.
single_sided_buffer
(
geometry
,
distance
[,
segments=8
][,
join=1
][,
miter_limit=2.0
])
| geometry | une géométrie (multi)polyligne |
| distance | distance du tampon. Les valeurs positives produiront un tampon sur la gauche et les négatives sur la droite |
| segments | nombre de segments utilisés pour représenter un quart de cercle quand le style de raccordement arrondi est actif. Plus le nombre est élevé, plus la ligne apparaitra lisse et contiendra des noeuds. |
| join | style de raccordement pour les angles, avec 1 = arrondi, 2 = angle droit, 3 = chanfreiné |
| miter_limit | valeur limite du ratio d'angle droit utilisé pour les angles très vifs (uniquement pour le style de raccordement par angle droit) |
single_sided_buffer($geometry, 10.5)
→
tampon de ligne sur la gauche de 10.5 unités
single_sided_buffer($geometry, -10.5)
→
tampon de ligne sur la droite de 10.5 unités
single_sided_buffer($geometry, 10.5, segments=16, join=1)
→
ligne dont un tampon de 10.5 unités a été généré sur la gauche en utilisant plus de segments pour un résultat plus lisse
single_sided_buffer($geometry, 10.5, join=3)
→
ligne dont un tampon de 10.5 unités a été généré sur la gauche en utilisant un raccordement chanfreiné
Lisse une géométrie an ajoutant des vertex supplémentaires qui arrondissent les angles de la géométrie. Si les géométries d'entrée contiennent des valeurs Z ou M, elles seront également lissées et la géométrie de sortie gardera la même dimension que celle d'entrée.
smooth
(
geometry
[,
iterations
][,
offset
][,
min_length
][,
max_angle
])
| geometry | une géométrie |
| iterations | Nombre d'itérations de lissage à appliquer. De plus grands nombres aboutissent à des géométries plus lisses mais plus complexes. |
| offset | valeur entre 0 et 0.5 qui détermine à quel point la géométrie lissée se rapproche de la géométrie originale. Des petites valeurs donnent un lissage plus serré, des grandes valeurs un lissage plus lâche. |
| min_length | longueur minimale des segments sur lesquels appliquer le lissage. Ce paramètre peut être utilisé pour éviter d'ajouter excessivement des noeuds aux plus petits segments de la géométrie. |
| max_angle | angle maximal au niveau d'un noeud poir appliquer le lissage (0-180). En diminuant volontairement l'angle maximal, les angles vifs de la géométrie peuvent être conservés. Par exemple, une valeur de 80 degrés conservera les angles droits de la géométrie. |
geom_to_wkt(smooth(geometry:=geom_from_wkt('LineString(0 0, 5 0, 5 5)'),iterations:=1,offset:=0.2,min_length:=-1,max_angle:=180))
→
'LineString (0 0, 4 0, 5 1, 5 5)'
Renvoie le premier nœud d'une géométrie.
start_point
(
geometry
)
| geometry | objet géométrique |
geom_to_wkt(start_point(geom_from_wkt('LINESTRING(4 0, 4 2, 0 2)')))
→
'Point (4 0)'
Renvoie une géométrie qui représente la portion non intersectées de deux géométries.
sym_difference
(
geometry1
,
geometry2
)
| geometry1 | une géométrie |
| geometry2 | une géométrie |
geom_to_wkt( sym_difference( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 8 8)' ) ) )
→
LINESTRING(5 5, 8 8)
Crée autour d'une ligne une zone tampon dont le diamètre varie uniformément du début jusqu'à la fin de la ligne.
tapered_buffer
(
geometry
,
start_width
,
end_width
[,
segments=8
])
| geometry | géométrie en entrée, de type (multi)ligne. |
| start_width | largeur de la zone tampon en début de ligne, |
| end_width | largeur de la zone tampon en fin de ligne. |
| segments | nombre de segments pour approximer des courbes en quart de cercle dans le tampon. |
tapered_buffer(geometry:=geom_from_wkt('LINESTRING(1 2, 4 2)'),start_width:=1,end_width:=2,segments:=8)
→
Un tampon de taille variable avec un diamètre de 1 et finissant par un diamètre de 2 le long d'une géométrie de polyligne.
Teste si deux géométries se touchent. Renvoie vrai si les géométries ont au moins un point en commun mais que leurs surface intérieures ne s'intersectent pas.
touches
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
touches( geom_from_wkt( 'LINESTRING(5 3, 4 4)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
vrai
touches( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'POINT(5 5)' ) )
→
false
Renvoie la géométrie transformée d'un SCR source vers un SCR cible.
transform
(
geom
,
source_auth_id
,
dest_auth_id
)
| geom | une géométrie |
| source_auth_id | Identifiant du SCR source |
| dest_auth_id | Identifiant du SCR cible |
geom_to_wkt( transform( $geometry, 'EPSG:2154', 'EPSG:4326' ) )
→
POINT(0 51)
Renvoie une version translatée d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de cette géométrie.
translate
(
geom
,
dx
,
dy
)
| geom | une géométrie |
| dx | delta x |
| dy | delta y |
translate($geometry, 5, 10)
→
une géométrie du même type que la géométrie d'origine
Renvoie une géométrie qui représente l'ensemble de points unis des géométries.
union
(
geometry1
,
geometry2
)
| geometry1 | une géométrie |
| geometry2 | une géométrie |
geom_to_wkt( union( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'POINT(5 5)' ) ) )
→
MULTIPOINT(4 4, 5 5)
Renvoie un tampon avec angles depuis une géométrie de point.
wedge_buffer
(
center
,
azimuth
,
width
,
outer_radius
[,
inner_radius=0.0
])
| center | point central (origine) d'un tampon. Doit être une géométrie ponctuelle. |
| azimuth | angle (en degrés) depuis le milieu du coin vers le point |
| width | largeur du tampon (en degrés). Notez que le coin s'étendra jusqu'à la moitié de la largeur angulaire de chaque côté de la direction de l'azimut. |
| outer_radius | rayon extérieur pour les tampons |
| inner_radius | rayon intérieur optionnel pour les tampons |
wedge_buffer(center:=geom_from_wkt('POINT(1 2)'),azimuth:=90,width:=180,outer_radius:=1)
→
Tampon en forme de coin centré sur le point (1,2), orienté vers l'est, d'une largeur de 180 degrés et d'un rayon extérieur de 1.
Teste si une géométrie est située complètement à l'intérieur d'une autre. Renvoie vrai si la géométrie a est contenue complètement dans la géométrie b.
within
(
geometry a
,
geometry b
)
| geometry a | une géométrie |
| geometry b | une géométrie |
within( geom_from_wkt( 'POINT( 0.5 0.5)' ), geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' ) )
→
vrai
within( geom_from_wkt( 'POINT( 5 5 )' ), geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0 ))' ) )
→
false
Renvoie la coordonnée x d'une géométrie ponctuelle ou la coordonnée x du centroïde d'une géométrie non ponctuelle.
x
(
geom
)
| geom | une géométrie |
x( geom_from_wkt( 'POINT(2 5)' ) )
→
2
x( $geometry )
→
coordonnée x du centroïde de l'entité courante
Renvoie la coordonnée x maximale d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de la géométrie.
x_max
(
geom
)
| geom | une géométrie |
x_max( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
4
Renvoie la coordonnée x minimale d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de la géométrie.
x_min
(
geom
)
| geom | une géométrie |
x_min( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
2
Renvoie la coordonnée y d'une géométrie ponctuelle ou la coordonnée y du centroïde d'une géométrie non ponctuelle.
y
(
geom
)
| geom | une géométrie |
y( geom_from_wkt( 'POINT(2 5)' ) )
→
5
y( $geometry )
→
coordonnée y du centroïde de l'entité courante
Renvoie la coordonnée y maximale d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de la géométrie.
y_max
(
geom
)
| geom | une géométrie |
y_max( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
8
Renvoie la coordonnée y minimale d'une géométrie. Les calculs sont effectués dans le Système Spatial de Référence de la géométrie.
y_min
(
geom
)
| geom | une géométrie |
y_min( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
5
Renvoie la coordonnée z d'une géométrie de type point.
z
(
geom
)
| geom | une géométrie ponctuelle |
z( geom_from_wkt( 'POINTZ(2 5 7)' ) )
→
7
Returns the maximum z coordinate of a geometry.
z_max
(
geometry
)
| geometry | a geometry with z coordinate |
z_max( geom_from_wkt( 'POINT ( 0 0 1 )' ) )
→
1
z_max( make_line( make_point( 0,0,0 ), make_point( -1,-1,-2 ) ) )
→
0
Returns the minimum z coordinate of a geometry.
z_min
(
geometry
)
| geometry | a geometry with z coordinate |
z_min( geom_from_wkt( 'POINT ( 0 0 1 )' ) )
→
1
z_min( make_line( make_point( 0,0,0 ), make_point( -1,-1,-2 ) ) )
→
-2
Renvoie une table de correspondance des variables d'un élément du composeur à l'intérieur de cette composition.
item_variables
(
id
)
| id | ID d'élément du composeur |
map_get(item_variables ('carte_principale'), 'map_scale')
→
2000
Contient une liste de couches cartographiques disponibles dans le projet en cours.
Prend une couche et décode l'uri du fournisseur de données sous-jacent. Cela dépend du fournisseur de données, des données qui sont disponibles.
decode_uri
(
layer
[,
part
])
| layer | La couche pour laquelle l'uri doit être décodé. |
| part | La partie de l'uri à retourner. Si elle n'est pas spécifiée, une carte avec toutes les parties de l'uri sera retournée. |
decode_uri(@layer)
→
{'layerId': '0', 'layerName': '', 'path': '/home/qgis/shapefile.shp'}
decode_uri(@layer)
→
{'layerId': NULL, 'layerName': 'layer', 'path': '/home/qgis/geopackage.gpkg'}
decode_uri(@layer, 'path')
→
'C:\my_data\qgis\shape.shp'
Ce groupe contient des fonctions d'expression pour la création et la manipulation de structures de données «table de correspondance» (également appelées objets de dictionnaire, paires de clés-valeurs ou tableaux associatifs). On peut assigner des valeurs à des clés données. L'ordre des paires clé-valeur dans l'objet cartographique n'est pas pertinent.
Charge une chaîne de caractères au format JSON.
from_json
(
string
)
| string | Chaîne de caractères au format JSON |
from_json('{"qgis":"rocks"}')
→
{ "qgis" : "déchire" }
from_json('[1,2,3]')
→
[1,2,3]
Créer une table de correspondance depuis une chaîne hstore.
hstore_to_map
(
string
)
| string | la chaîne en entrée |
hstore_to_map('qgis=>déchire')
→
{ "qgis" : "déchire" }
Créer une table de correspondance depuis une chaîne json.
json_to_map
(
string
)
| string | la chaîne en entrée |
json_to_map('{"qgis":"déchire"}')
→
{ "qgis" : "déchire" }
Renvoie une table de correspondance contenant toutes les clés et les valeurs passées en paramètres par paires.
map
(
key1
,
value1
,
key2
,
value2
…)
| key | une clé (chaîne de caractères) |
| value | une valeur |
map('1','un','2', 'deux')
→
{ '1': 'one', '2': 'two' }
Renvoie toutes les clés d'une table de correspondance sous la forme d'un tableau.
map_akeys
(
map
)
| map | une table de correspondance |
map_akeys(map('1','un','2','deux'))
→
[ '1', '2' ]
Renvoie toutes les valeurs d'une table de correspondance sous la forme d'un tableau.
map_avals
(
map
)
| map | une table de correspondance |
map_avals(map('1','un','2','deux'))
→
[ 'one', 'two' ]
Renvoie une table de correspondance contenant toutes les entrées des tables de correspondances données. Si les deux tables de correspondance contiennent la même clé, la valeur prise en compte sera celle de la seconde table de correspondance.
map_concat
(
map1
,
map2
…)
| map | une table de correspondance |
map_concat(map('1','un', '2','en plus'),map('2','deux', '3','trois'))
→
{ '1': 'one, '2': 'two', '3': 'three' }
Renvoie une table de correspondance dont la clé donnée et sa valeur correspondante a été supprimée.
map_delete
(
map
,
key
)
| map | une table de correspondance |
| key | la clé à supprimer |
map_delete(map('1','un','2','deux'),'2')
→
{ '1': 'one' }
Renvoie vrai si la clé donnée est présente dans la table de correspondance.
map_exist
(
map
,
key
)
| map | une table de correspondance |
| key | la clé à rechercher |
map_exist(map('1','un','2','deux'),'3')
→
false
Renvoie la valeur d'une table de correspondance, selon la clé.
map_get
(
map
,
key
)
| map | une table de correspondance |
| key | la clé à rechercher |
map_get(map('1','un','2','deux'),'2')
→
'deux'
Renvoie une table de correspondance avec un ensemble clé/valeur ajouté.
map_insert
(
map
,
key
,
value
)
| map | une table de correspondance |
| key | la clé à ajouter |
| value | la valeur à ajouter |
map_insert(map('1','un'),'3','trois')
→
{ '1': 'one', '3': 'three' }
Fusionne les éléments du tableau associatif dans une chaîne hstore.
map_to_hstore
(
map
)
| map | la table de correspondance en entrée |
map_to_hstore(map('qgis','déchire'))
→
"qgis"=>"déchire"}
Fusionne les éléments du tableau associatif dans une chaîne json.
map_to_json
(
map
)
| map | la table de correspondance en entrée |
map_to_json(map('qgis','déchire'))
→
{"qgis":"déchire"}
Crée une chaîne formattée JSON depuis une table de correspondance, un tableau, ou une autre valeur.
to_json
(
value
)
| value | La valeur en entrée |
to_json(map('qgis','rocks'))
→
{"qgis":"déchire"}
to_json(array(1,2,3))
→
[1,2,3]
Cette catégorie contient des fonctions mathématiques telles que la racine carrée, le sinus, le cosinus, etc.
Renvoie la valeur absolue d'un nombre.
abs
(
value
)
| value | un nombre |
abs(-2)
→
2
Renvoie le cosinus inverse d'une valeur en radians.
acos
(
value
)
| value | cosinus d'un angle en radians |
acos(0.5)
→
1.0471975511966
Renvoie le sinus inverse d'une valeur en radians.
asin
(
value
)
| value | sinus d'un angle en radians |
asin(1.0)
→
1.5707963267949
Renvoie la tangeante inverse d'une valeur en radians.
atan
(
value
)
| value | tan d'un angle en radians |
atan(0.5)
→
0.463647609000806
Renvoie la tangente inverse de dy/dx en utilisant les signes des deux arguments pour déterminer le quadrant du résultat.
atan2
(
dy
,
dx
)
| dy | différence de coordonnée y |
| dx | différence de coordonnée x |
atan2(1.0, 1.732)
→
0.523611477769969
Renvoie l'azimut par rapport au nord sous forme d'angle en radians mesuré dans le sens des aiguilles d'une montre à partir de la verticale entre point_a et point_b.
azimuth
(
point_a
,
point_b
)
| point_a | géométrie ponctuelle |
| point_b | géométrie ponctuelle |
degrees( azimuth( make_point(25, 45), make_point(75, 100) ) )
→
42.273689
degrees( azimuth( make_point(75, 100), make_point(25,45) ) )
→
222.273689
Arrondi un nombre vers le haut.
ceil
(
value
)
| value | un nombre |
ceil(4.9)
→
5
ceil(-4.9)
→
-4
Restreint une valeur d'entrée à une plage spécifique.
clamp
(
minimum
,
input
,
maximum
)
| minimum | la plus petite valeur que input peut prendre. |
| input | une valeur qui sera restreinte à la plage indiquée par minimum et maximum |
| maximum | la plus grande valeur que input peut prendre |
clamp(1,5,10)
→
5
(
input
se situe entre 1 et 10 donc la valeur est renvoyée inchangée)
clamp(1,0,10)
→
1
(
input
est inférieure à la valeur minimum de 1, la fonction renvoie 1)
clamp(1,11,10)
→
10
(
input
est supérieure à la valeur maximale de 10, la fonction renvoie 10)
Renvoie le cosinus d'un angle
cos
(
angle
)
| angle | angle en radians |
cos(1.571)
→
0.000796326710733263
Convertit des angles en radians vers des degrés.
degrees
(
radians
)
| radians | valeur numérique |
degrees(3.14159)
→
180
degrees(1)
→
57.2958
Renvoie l'exponentiel une valeur
exp
(
value
)
| value | nombre dont il faut renvoyer l'exponentiel |
exp(1.0)
→
2.71828182845905
Arrondit un nombre vers le bas.
floor
(
value
)
| value | un nombre |
floor(4.9)
→
4
floor(-4.9)
→
-5
Renvoie l'inclinaison mesurée du zénith (0) au nadir (180) du point_a au point_b.
inclination
(
point_a
,
point_b
)
| point_a | géométrie ponctuelle |
| point_b | géométrie ponctuelle |
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 5 ) )
→
0.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 50, 100, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, -5 ) )
→
180.0
Renvoie le logarithme népérien d'une valeur.
ln
(
value
)
| value | valeur numérique |
ln(1)
→
0
ln(2.7182818284590452354)
→
1
Renvoie la valeur du logarithme selon la valeur et la base en arguments.
log
(
base
,
value
)
| base | n'importe quel nombre positif |
| value | n'importe quel nombre positif |
log(2, 32)
→
5
log(0.5, 32)
→
-5
Renvoie la valeur du logarithme en base 10 de l'expression en argument.
log10
(
value
)
| value | n'importe quel nombre positif |
log10(1)
→
0
log10(100)
→
2
Renvoie la valeur la plus haute d'un ensemble de valeurs.
max
(
value1
,
value2
…)
| value | un nombre |
max(2,10.2,5.5)
→
10.2
max(20.5,NULL,6.2)
→
20.5
Renvoie la valeur la plus faible d'un ensemble de valeurs.
min
(
value1
,
value2
…)
| value | un nombre |
min(20.5,10,6.2)
→
6.2
min(2,-10.3,NULL)
→
-10.3
Renvoie la valeur de Pi pour utilisation dans d'autres calculs.
pi
()
pi()
→
3.14159265358979
Convertit des angles en degrés vers des radians.
radians
(
degrees
)
| degrees | valeur numérique |
radians(180)
→
3.14159
radians(57.2958)
→
1
Renvoie un entier aléatoire dans une plage spécifiée par les arguments minimum et maximum (inclus). Si une graine est fournie, le résultat sera toujours le même, en fonction de la graine.
rand
(
min
,
max
[,
seed=null
])
| min | un entier représentant la plus petite valeur aléatoire possible |
| max | un entier représentant la plus grande valeur aléatoire possible |
| seed | N'importe quelle valeur à utiliser comme graine |
rand(1, 10)
→
8
Renvoie un nombre flottant aléatoire dans une plage spécifiée par les arguments minimum et maximum (inclus). Si une graine est fournie, le résultat sera toujours le même, en fonction de la graine.
randf
([
min=0.0
][,
max=1.0
][,
seed=null
])
| min | un nombre décimal représentant la plus petite valeur aléatoire possible |
| max | un nombre décimal représentant la plus grande valeur aléatoire possible |
| seed | N'importe quelle valeur à utiliser comme graine |
randf(1, 10)
→
4.59258286403147
Arrondi un nombre au nombre de décimales indiqué.
round
(
value
[,
places=0
])
| value | nombre décimal à arrondir |
| places | Entier optionnel représentant le nombre de caractères après la virgule à arrondir. Peut être négatif. |
round(1234.567, 2)
→
1234.57
round(1234.567)
→
1235
Transforme une valeur donnée d'un domaine d'entrée à une plage de sortie en utilisant une courbe exponentielle. Cette fonction peut être utilisée pour supprimer les valeurs en dehors de la plage de sortie.
scale_exp
(
val
,
domain_min
,
domain_max
,
range_min
,
range_max
,
exponent
)
| val | Une valeur du domaine d'entrée. La fonction renverra une valeur correspondante à l'échelle dans la plage de sortie. |
| domain_min | Indique la valeur minimale dans le domaine d'entrée, la plus petite valeur que l'entrée peut prendre. |
| domain_max | Indique la valeur maximale dans le domaine d'entrée, la plus grande valeur que l'entrée peut prendre. |
| range_min | Indique la valeur minimale de la plage de sortie, la plus petite valeur qui doit être renvoyée par la fonction. |
| range_max | Indique la valeur maximale de la plage de sortie, la plus grande valeur qui doit être renvoyée par la fonction. |
| exponent | Une valeur positive (supérieure à 0) qui dirige la manière dont les valeurs d'entrée sont réparties dans la plage de sortie. De grands exposants entraîneront des valeurs de sortie en 'adoucissement en entrée', démarrant lentement avant d’accélérer à mesure que les valeurs d'entrées approcheront du maximum du domaine. Des exposants faibles (inférieurs à 1) entraîneront des valeurs de sortie en 'adoucissement en sortie' où la répartition commencera rapidement mais ralentira à mesure que l'on s'approche du maximum du domaine. |
scale_exp(5,0,10,0,100,2)
→
25
(adoucissement en entrée, en utilisant un exposant de 2)
scale_exp(3,0,10,0,100,0.5)
→
54.772
(adoucissement en sortie, en utilisant un exposant de 0.5)
Transforme une valeur donnée d'un domaine d'entrée à une plage de sortie en utilisant une interpolation linéaire.
scale_linear
(
val
,
domain_min
,
domain_max
,
range_min
,
range_max
)
| val | Une valeur du domaine d'entrée. La fonction renverra une valeur correspondante à l'échelle dans la plage de sortie. |
| domain_min | Indique la valeur minimale dans le domaine d'entrée, la plus petite valeur que l'entrée peut prendre. |
| domain_max | Indique la valeur maximale dans le domaine d'entrée, la plus grande valeur que l'entrée peut prendre. |
| range_min | Indique la valeur minimale de la plage de sortie, la plus petite valeur qui doit être renvoyée par la fonction. |
| range_max | Indique la valeur maximale de la plage de sortie, la plus grande valeur qui doit être renvoyée par la fonction. |
scale_linear(5,0,10,0,100)
→
50
scale_linear(0.2,0,1,0,360)
→
72
(échelonne une valeur entre 0 et 1 vers un angle entre 0 et 360)
scale_linear(1500,1000,10000,9,20)
→
9.6111111
(échelonne une population variant entre 1000 et 10000 vers une taille de police entre 9 et 20)
Renvoie le sinus d'un angle.
sin
(
angle
)
| angle | angle en radians |
sin(1.571)
→
0.999999682931835
Renvoie la racine carrée d'une valeur.
sqrt
(
value
)
| value | un nombre |
sqrt(9)
→
3
Renvoie la tangente d'un angle.
tan
(
angle
)
| angle | angle en radians |
tan(1.0)
→
1.5574077246549
Renvoie la valeur des paramètres d'entrée d'un algorithme de traitement
parameter
(
name
)
| name | Nom du paramètre d'entrée correspondant |
parameter('BUFFER_SIZE')
→
5.6
Aide manquante pour $mask_geometry
Aide manquante pour in_mask
Contient des fonctions qui calculent des statistiques et des valeurs sur les rasters.
Renvoie des statistiques depuis une couche raster.
raster_statistic
(
layer
,
band
,
property
)
| layer | une chaîne de caractères représentant soit un nom de couche raster ou un ID de couche |
| band | entier représentant le numéro de bande de la couche raster, commençant à 1 |
| property |
une chaîne de caractères correspondant à la propriété à retourner. Les options valides sont:
|
raster_statistic('lc',1,'avg')
→
Valeur moyenne de la bande 1 issue de la couche raster 'lc'
raster_statistic('ac2010',3,'min')
→
Valeur minimale de la bande 3 issue de la couche raster 'ac2010'
Retourne la valeur du pixel dans le raster aux coordonnées du point.
raster_value
(
layer
,
band
,
point
)
| layer | le nom ou l'identifiant de la couche raster |
| band | le numéro de la bande dans laquelle prélever la valeur. |
| point | Géométrie ponctuelle (Pour les géométries multi-parties ayant plus qu'une partie, une valeur nulle sera renvoyée) |
raster_value('dem', 1, make_point(1,1))
→
25
Ce groupe contient des fonctions qui permettent d'accéder aux identifiants des enregistrements.
Renvoie l'entité courante évaluée. Cette fonction peut être utilisée en combinaison avec la fonction 'attribute' pour renvoyer les valeurs d'attribut de l'entité courante.
$currentfeature
attribute( $currentfeature, 'name' )
→
valeur stockée dans l'attribut 'name' de l'entité courante
Renvoie un attribut d'une entité.
attribute
(
attribute_name
)
| attribute_name | nom de l'attribut qui sera retourné |
attribute( 'name' )
→
valeur stockée dans l'attribut 'name' de l'entité courante
attribute
(
feature
,
attribute_name
)
| feature | une entité |
| attribute_name | nom de l'attribut qui sera retourné |
attribute( @atlas_feature, 'name' )
→
valeur stockée dans l'attribut 'name' de l'entité courante de l'atlas
Retourne une table de correspondance contenant tous les attributs d'une entité, avec les noms d'attributs comme clés.
attributes
()
attributes()['name']
→
valeur stockée dans l'attribut 'name' de l'entité courante
attributes
(
feature
)
| feature | une entité |
attributes( @atlas_feature )['name']
→
valeur stockée dans l'attribut 'name' de l'entité courante de l'atlas
Returns the display expression for a given feature in a layer. If called with no parameters, it evaluates the current feature. The expression is evaluated by default.
display_expression
([
feature=current feature
][,
layer=current layer
][,
evaluate=true
])
| feature | The feature which should be evaluated. |
| layer | The layer (or its id or name). |
| evaluate | If the expression must be evaluated. If false, the expression will be returned as a string literal only (which could potentially be later evaluated using the 'eval' function). |
display_expression()
→
The display expression of the current feature.
display_expression(get_feature_by_id('streets', 1), 'streets')
→
The display expression of the feature with the ID 1 on the layer 'streets'.
display_expression('a_layer_id', $currentfeature, 'False')
→
The display expression of the given feature not evaluated.
Renvoie la première entité d'une couche qui correspond à la valeur d'un attribut donné.
get_feature
(
layer
,
attribute
,
value
)
| layer | nom de la couche ou ID |
| attribute | nom de l'attribut |
| value | valeur d'attribut à trouver |
get_feature('rue','nom','de la Libération')
→
Première entité trouvée dans la couche "rue" avec la valeur "de la Libération" dans le champ "nom"
Renvoie l'entité avec un identifiant sur une couche.
get_feature_by_id
(
layer
,
feature_id
)
| layer | la couche, son nom ou son identifiant |
| feature_id | L'identifiant de l'entité à renvoyer |
get_feature('streets', 1)
→
L'entité de la couche "streets" ayant l'identifiant 1
Returns True if a feature is selected. Can be used with zero, one or two arguments, see below for details.
is_selected
()
is_selected()
→
True if the current feature in the current layer is selected.
is_selected
(
feature
)
| feature | L'entité qui sera vérifiée pour sa sélection. |
is_selected(@atlas_feature)
→
True if the current atlas feature is selected.
is_selected
(
layer
,
feature
)
| layer | The layer (or its ID or name) on which the selection will be checked. |
| feature | L'entité qui sera vérifiée pour sa sélection. |
is_selected( 'streets', get_feature('streets', 'name', "street_name"))
→
True if the current building's street is selected (assuming the building layer has a field named 'street_name' and the 'streets' layer has a field called 'name').
Returns the maptip for a given feature in a layer. If called with no parameters, it evaluates the current feature. The maptip is evaluated by default.
maptip
([
feature=current feature
][,
layer=current layer
][,
evaluate=true
])
| feature | The feature which should be evaluated. |
| layer | The layer (or its id or name). |
| evaluate | If the expression must be evaluated. If false, the expression will be returned as a string literal only (which could potentially be later evaluated using the 'eval_template' function). |
maptip()
→
The maptip of the current feature.
maptip(get_feature('streets', 1), 'streets')
→
The maptip of the feature with the ID 1 on the layer 'streets'.
maptip('a_layer_id', $currentfeature, 'False')
→
The maptip of the given feature not evaluated.
Renvoie le nombre d'entités sélectionnées d'une couche donnée. Par défaut la fonction agit sur la couche sur laquelle l'expression est évaluée.
num_selected
([
layer=current layer
])
| layer | La couche (ou son identifiant ou nom) sur laquelle la sélection sera vérifiée. |
num_selected()
→
Le nombre d'entités sélectionnées sur la couche courante.
num_selected('streets')
→
Le nombre d'entités sélectionnées sur la couche des rues
Renvoie la valeur de représentation configurée pour une valeur de champ. Cela dépend du type de widget configuré. Souvent, cela est utile pour les widgets 'Carte de la valeur'.
represent_value
(
value
,
fieldName
)
| value | La valeur qui devrait être résolue. Très probablement un champ. |
| fieldName | Nom du champ pour lequel la configuration du widget doit être chargée. (Optionnel) |
represent_value("field_with_value_map")
→
Description de la valeur
represent_value('static value', 'field_name')
→
Description de la valeur statique
Manage autoincrementing values in sqlite databases.
SQlite default values can only be applied on insert and not prefetched.
This makes it impossible to acquire an incremented primary key via AUTO_INCREMENT before creating the row in the database. Sidenote: with postgres, this works via the option evaluate default values .
When adding new features with relations, it is really nice to be able to already add children for a parent, while the parents form is still open and hence the parent feature uncommitted.
To get around this limitation, this function can be used to manage sequence values in a separate table on sqlite based formats like gpkg.
The sequence table will be filtered for a sequence id (filter_attribute and filter_value) and the current value of the id_field will be incremented by 1 and the incremented value returned.
If additional columns require values to be specified, the default_value map can be used for this purpose.
Note
This function modifies the target sqlite table. It is intended for usage with default value configurations for attributes.
When the database parameter is a layer and the layer is in transaction mode, the value will only be retrieved once during the lifetime of a transaction and cached and incremented. This makes it unsafe to work on the same database from several processes in parallel.
sqlite_fetch_and_increment
(
database
,
table
,
id_field
,
filter_attribute
,
filter_value
[,
default_values
])
| database | Chemin vers le fichier sqlite ou la couche geopackage |
| table | Nom de la table qui gère les séquences |
| id_field | Nom du champ qui contient la valeur actuelle |
| filter_attribute | Nommez le champ qui contient un identifiant unique pour cette séquence. Doit avoir un index UNIQUE. |
| filter_value | Nom de la séquence à utiliser |
| default_values | Table de correspondance avec valeurs par défaut pour des colonnes supplémentaires dans la table. Les valeurs doivent être encadrées par des apostrophes. Les fonctions sont permises. |
sqlite_fetch_and_increment(@layer, 'sequence_table', 'last_unique_id', 'sequence_id', 'global', map('last_change','date(''now'')','user','''' || @user_account_name || ''''))
→
0
sqlite_fetch_and_increment(layer_property(@layer, 'path'), 'sequence_table', 'last_unique_id', 'sequence_id', 'global', map('last_change','date(''now'')','user','''' || @user_account_name || ''''))
→
0
Génère un Identifiant Universel Unique (UUID) pour chaque ligne en utilisant la méthode QT QUuid::createUuid . Chaque UUID occupe 38 caractères.
uuid
()
uuid()
→
'{0bd2f60f-f157-4a6d-96af-d4ba4cb366a1}'
Cette catégorie contient des fonctions opérant sur des chaînes de caractères par exemple le remplacement ou la conversion en majuscules.
Returns the unicode code associated with the first character of a string.
ascii
(
string
)
| string | the string to convert to unicode code |
ascii('Q')
→
81
Renvoie le caractère associé à un code Unicode.
char
(
code
)
| code | un code Unicode |
char(81)
→
'Q'
Concatène plusieurs chaînes de caractères en une seule. Les valeurs NULL sont converties en chaînes vides. Les autres valeurs (comme les nombres) sont converties en chaînes de caractères.
concat
(
string1
,
string2
…)
| string | une chaîne de caractères |
concat('pyj', 'ama')
→
'pyjama'
concat('a','b','c','d','e')
→
'abcde'
concat('Anno ', 1984)
→
'Anno 1984'
concat('The Wall', NULL)
→
'The Wall'
Formatte une chaîne de caractères en utilisant les arguments fournis.
format
(
string
,
arg1
,
arg2
…)
| string | Une chaîne de caractères avec des espaces réservés en arguments. Utilisez %1, %2, etc. comme espaces réservés. Les espaces réservés peuvent être utilisés plusieurs fois. |
| arg | tout type. Tout nombre d'arguments. |
format('Ceci %1 un %2', 'est', 'test')
→
'Ceci est un test''
Formate une date ou une chaîne de caractères selon un format personnalisé. Utilise le formatage des dates/temps de Qt. Consultez QDateTime::toString .
format_date
(
datetime
,
format
[,
language
])
| datetime | valeur de date, de temps ou de date et de temps | ||||||||||||||||||||||||||||||||||||||||||||||||
| format |
String template used to format the string.
These expressions may be used for the time part of the format string:
|
||||||||||||||||||||||||||||||||||||||||||||||||
| language | langue (minuscule, deux ou trois lettres, code de langue ISO 639) utilisée pour formater la date en une chaîne personnalisée |
format_date('2012-05-15','dd.MM.yyyy')
→
'15.05.2012'
format_date('2012-05-15','d MMMM yyyy','fr')
→
'15 juin 2012'
Returns a number formatted with the locale separator for thousands. Also truncates the decimal places to the number of supplied places.
format_number
(
number
,
places
[,
language
])
| number | nombre à formater |
| places | entier représentant le nombre d'espaces de décimales à tronquer. |
| language | language (lowercase, two- or three-letter, ISO 639 language code) used to format the number into a string |
format_number(10000000.332,2)
→
'10,000,000.33'
Renvoie un extrait de chaîne de caractères contenant les n caractères les plus à gauche de la chaîne initiale.
left
(
string
,
length
)
| string | une chaîne de caractères |
| length | entier. Le nombre de caractères depuis la gauche de la chaîne à renvoyer. |
left('Salut tout le monde',5)
→
'Salut'
Renvoie le nombre de caractères d'une chaîne de caractères ou la longueur d'une géométrie de polylignes.
length
(
string
)
| string | chaîne de caractères dont il faut calculer la longueur |
length('salut')
→
5
length
(
geometry
)
| geometry | un objet géométrique linéaire |
length(geom_from_wkt('LINESTRING(0 0, 4 0)'))
→
4.0
Convertit une chaîne de caractères en caractères minuscules.
lower
(
string
)
| string | la chaîne de caractères à convertir en minuscules |
lower('SALUT tout le monde')
→
'salut tout le monde'
Renvoie une chaîne de caractères complétée à sa gauche avec un caractère de remplissage à la largeur spécifiée. Si la largeur maximale possible est plus petite que la longueur renvoyée, le chaîne de caractères sera tronquée.
lpad
(
string
,
width
,
fill
)
| string | chaîne de caractères à remplir |
| width | longueur de la nouvelle chaîne de caractères |
| fill | caractère de remplissage |
lpad('Salut', 10, 'x')
→
'xxxxxSalut'
lpad('Hello', 3, 'x')
→
'Hel'
Renvoie la première occurrence correspondante à une expression régulière dans une chaîne de caractères, ou 0 si la sous-chaîne n'a pas été trouvée.
regexp_match
(
input_string
,
regex
)
| input_string | la chaîne à tester selon l'expression rationnelle |
| regex | L'expression régulière de test. Les caractères antislash doivent être échappés deux fois (ex: "\s" correspond à un caractère d'espace). |
regexp_match('QGIS ROCKS','\sROCKS')
→
4
Renvoie une chaîne de caractères en utilisant une expression rationnelle de substitution.
regexp_replace
(
input_string
,
regex
,
replacement
)
| input_string | la chaîne de caractères à remplacer en cas de correspondance |
| regex | L'expression régulière de remplacement. Les caractères antislash doivent être échappés deux fois (ex: "\\s" correspond à un caractère d'espace). |
| replacement | La chaîne de caractères utilisée en remplacement de chaque occurrence renvoyée en correspondance de l'expression régulière donnée. Les groupes capturés peuvent être insérés comme chaîne de remplacement en utilisant \\1, \\2, etc. |
regexp_replace('QGIS SHOULD ROCK','\\sSHOULD\\s',' DOES ')
→
'QGIS EST GENIAL'
Renvoie la portion d'une chaîne de caractères qui correspond à une expression rationnelle fournie.
regexp_substr
(
input_string
,
regex
)
| input_string | la chaîne où trouver la correspondance |
| regex | L'expression régulière à comparer. Les caractères antislash doivent être échappés deux fois (ex: "\\s" correspond à un caractère d'espace). |
regexp_substr('abc123','(\\d+)')
→
'123'
Renvoie une chaîne de caractères où la chaîne, le tableau ou la table de correspondance fournis ont été utilisés pour remplacer des caractères.
replace
(
string
,
before
,
after
)
| string | la chaîne en entrée |
| before | la chaîne de caractères ou le tableau de chaînes de caractères à remplacer |
| after | la chaîne de caractères ou le tableau de chaînes de caractères utilisés en remplacement |
replace('QGIS DOIT ÊTRE GENIAL','DOIT ÊTRE','EST')
→
'QGIS EST GENIAL'
replace('QGIS ABC',array('A','B','C'),array('X','Y','Z'))
→
'QGIS XYZ'
replace('QGIS',array('Q','S'),'')
→
'GI'
replace
(
string
,
map
)
| string | la chaîne en entrée |
| map | la table de correspondance contenant les clés et valeurs |
replace('APPLI DEVRAIT GENIAL',map('APPLI','QGIS','DEVRAIT','EST'))
→
'QGIS EST GENIAL'
Renvoie une sous-chaîne de caractères contenant les n caractères les plus à droite.
right
(
string
,
length
)
| string | une chaîne de caractères |
| length | entier. Le nombre de caractères à renvoyer depuis la droite de la chaîne. |
right('Salut tout le monde',5)
→
'Monde'
Renvoie une chaîne de caractères complétée à sa droite avec un caractère de remplissage à la largeur spécifiée. Si la largeur maximale possible est plus petite que la longueur renvoyée, le chaîne de caractères sera tronquée.
rpad
(
string
,
width
,
fill
)
| string | chaîne de caractères à remplir |
| width | longueur de la nouvelle chaîne de caractères |
| fill | caractère de remplissage |
rpad('Salut', 10, 'x')
→
'Salutxxxxx'
rpad('Hello', 3, 'x')
→
'Hel'
Renvoie la position de la première occurence d'une sous-chaîne dans une chaîne de caractères ou 0 si la sous-chaîne est introuvable.
strpos
(
haystack
,
needle
)
| haystack | la chaîne dans laquelle effectuer la recherche |
| needle | la chaîne de caractères recherchée |
strpos('SALUT TOUT LE MONDE','MONDE')
→
7
strpos('SALUT TOUT LE MONDE','AU REVOIR')
→
0
Renvoie une partie de chaîne de caractères.
substr
(
string
,
start
[,
length
])
| string | la chaîne complète en entrée |
| start | Entier représentant la position de départ à partir de laquelle procéder à l'extraction en commençant par 1; si la valeur de départ est négative, la chaîne de caractères renvoyée débutera à la fin de la chaîne moins la valeur de départ |
| length | entier représentant la longueur de la chaîne à extraire; si la longueur est négative, la chaîne renvoyée omettra le nombre de caractères correspondant à cette longueur à partir de la fin de la chaîne |
substr('SALUT TOUT LE MONDE',3,5)
→
'LUT T'
substr('HELLO WORLD', 6)
→
'WORLD'
substr('HELLO WORLD',-5)
→
'WORLD'
substr('HELLO',3,-1)
→
'LL'
substr('HELLO WORLD',-5,2)
→
'WO'
substr('HELLO WORLD',-5,-1)
→
'WORL'
Convertit l'ensemble des mots d'une chaîne de caractères en casse de titre (tous les mots sont en minuscule sauf la première lettre du mot qui est en majuscule).
title
(
string
)
| string | la chaîne à convertir en casse titre |
title('salut tout le MOnde')
→
'Salut Tout Le Monde'
Convertit un nombre en chaîne de caractères.
to_string
(
number
)
| number | Valeur entière ou réelle. Le nombre à convertir en chaîne de caractères. |
to_string(123)
→
'123'
Supprime tous les caractères d'espace (espaces, tabs, etc.) situés au début ou à la fin d'une chaîne de caractères.
trim
(
string
)
| string | la chaîne de caractères à nettoyer |
trim(' salut tout le monde ')
→
'salut tout le monde'
Convertit une chaîne de caractères en caractères majuscules.
upper
(
string
)
| string | la chaîne de caractères à convertir en majuscules |
upper('salut tout le MOnde')
→
'SALUT TOUT LE MONDE'
Renvoie une chaîne de caractères découpée par les caractères espace, selon un nombre minimum ou maximum de caractères
wordwrap
(
string
,
wrap_length
[,
delimiter_string
])
| string | la chaîne à découper |
| wrap_length | un entier. Si longueur_découpe est positif, le nombre représente le nombre maximum idéal de caractères à découper par des espaces; si négatif, le nombre représente le nombre minimum de caractères à découper par des espaces. |
| delimiter_string | Chaîne de caractères optionnelle de substitution pour générer un retour à la ligne. |
wordwrap('UNIVERSITE DE QGIS',13)
→
'UNIVERSITE DE
QGIS'
wordwrap('UNIVERSITE DE QGIS',-3)
→
'UNIVERSITE
DE QGIS'