Expressions

Author:Dirk Tilger
Contact:dirk at MIRIUP.DE
Author:Umberto Nicoletti
Contact:umberto.nicoletti at gmail.com
Last Updated:2016-11-26

Introduction

A partir de la version 6.0, les expressions sont utilisées à quatre endroits :

  • Dans le FILTER de l’objet LAYER pour spécifier les entités du jeu de de données qui doivent être inclus dans la couche.

  • Dans une EXPRESSION de l’objet CLASS spécifier à quelles entités du jeu de données la CLASS s’applique.

  • Dans le TEXT de l’objet CLASS pour spécifier le texte pour l’étiquetage des entités.

  • Dans GEOMTRANSFORM de l’objet STYLE.

Guillemets pour les chaînes de caractères

Les chaînes peuvent être entourées en utilisant de guillemets simples ou doubles:

'This is a string'
"And this is also a string"

Echappement des guillemets dans les chaînes

Note

L’échappement des guillemets n’est pas supporté dans MapServer pour les versions inférieures à la version 5.0.

A partir de MapServer 5.0, si votre jeu de données contient des guillemets doubles, vous pouvez utilisez une séquence d’échappement similaire à celle du langage C :

"National \"hero\" statue"

Pour échapper un guillemet simple, utilisez la séquence suivante à la place :

"National \'hero\' statue"

Starting with MapServer 6.0 you don’t need to escape single quotes within double quoted strings and you don’t need to escape double quotes within single quoted strings. In 6.0 you can also write the string as follows:

'National "hero" statue'
...

Pour échapper un guillemet simple, utilisez la séquence suivante à la place :

"National 'hero' statue"

Utiliser les attributs

Des valeurs d’attributs peuvent être référencées dans le mapfile et utilisées dans les expressions. Les références d’attributs sont sensibles à la casse et peuvent être utilisées dans les types d’expressions suivants

  • Dans le FILTER de l’objet LAYER

  • Dans l’`EXPRESSION` de l’objet CLASS

  • Dans le TEXT de l’objet CLASS

Référencer un attribut se fait en trourant le nom de l’attribut entre crochets, comme ceci : [ATTRIBUTENAME]. Ensuite, chaque occurrence de “[NOMATTRIBUT]” sera remplacée par la valeur actuelle de l’attribut “NOMATTRIBUT”.

Example: The data set of our layer has the attribute “BUILDING_NAME”. We want the value of this attribute to appear inside a string. This can be accomplished as follows (single or double quotes):

'The [BUILDING_NAME] building'

Pour la bâtiment qui a son attribut BUILDING_NAME défini à “Historical Museum”, la chaîne résultante est :

'The Historical Museum building'

Pour les couches Données Raster, des attributs spéciaux ont été définis pour être utiliser pour de la classification, par exemple :

  • [PIXEL] ... va devenir la valeur du pixel sous forme d’un nombre

  • [RED], [GREEN], [BLUE] ... deviendront, respectivement, les valeur des couleurs pour la composante rouge (red), verte (green) et bleue (blue) de la valeur du pixel.

Types d’expression

Les expressions sont utilisées pour faire correspondre les valeurs d’attributs avec certaines vérifications logiques. Il y a troistypes différents d’expression que vous pouvez utiliser avec MapServer

  • Comparaisons de chaînes: un attribut simple est comparé avec une valeur de chaîne.

  • Expressions régulières: un attribut seul est comparé via une expression régulière.

  • List expressions: Compare a string attribute to a list of multiple possible values
  • “Expressions MapServer” logiques : un ou plusieurs attributs sont comparés en utilisant des expressions logiques.

Comparaison de chaînes (égalité)

La comparaison de chaînes signifie que, comme le nom le suggère, que les valeurs d’attributs sont vérifiées si elles sont égales à une valeur donnée. Les comparaisons de chaînes sont la forme la plus simple des expressions MapServer et aussi l’option la plus rapide.

Pour utiliser une comparaison de chaînes pour filtrer une LAYER, FILTERITEM et FILTER doivent tous les deux être définis. Le FILTERITEM est défini au nom de l’attribut. Le FILTER est défini à la valeur pour la comparaison. La même règle s’applique au CLASSITEM dans l’objet LAYER et à l’`EXPRESSION` dans l’objet CLASS.

Exemple pour un filtre de comparaison de chaînes simple

FILTER "2005"
FILTERITEM "year"

devrait correspondre tous les enregistrements qui ont l’attribut “year” défini à “2005”. La carte générée apparaitra comme si le jeu de données contenait seulement les éléments qui ont leur “year” défini à “2005”.

De manière similaire, une classification des éléments correspondants à ci-dessus serait faite en définisssant la CLASSITEM dans la LAYER et l’`EXPRESSION` dans la CLASS:

LAYER
    NAME "example"
    CLASSITEM "year"
    ...
    CLASS
        NAME "year-2005"
        EXPRESSION "2005"
        ...
    END
END

Pour des raions que nous expliqueront plus tard, les valeurs pour à la fois CLASSITEM et FILTERITEM ne devront ni commencé avec un caractère ‘/’ ni avec un caractère ‘(‘.

Comparaison d’expressions régulières

Les expressions régulières sont un mécanisme de comparaison de motifs texte venant du monde Unix. La fonctionnalité de correspondance des expressions régulières est fournie par le système d’exploitation sous UNIX et donc est peu dépendante du système d’exploitation. Cependant, leurs fonctionnalités minimum sont celles définies par celles associées au standard POSIX. La documentation sur la bibliothèque d’expressions régulières est d’habitude dans la page de manuel “regex” (“man regex”) sur les systèmes Unix.

Les expressions régulières avec MapServer fonctionnent de manière similaire à la comparaison de chaîne, mais permettent des opérations plus complexes. Elles sont plus lentes que les comparaisons de chaîne pures, mais restent plus rapides que des expressions logiques. Comme pour les comparaisons de chaîne, quand vous utilisez des expressions régulières, le FILTERITEM (FILTER de LAYER) ou le CLASSITEM (EXPRESSION de CLASS) doivent être défini si les éléments ne sont pas inclus dans le FILTER de la LAYER ou de l’EXPRESSION de CLASS.

Une expression regulière consiste typiquement de caractères avec des significations spéciales et des caractères interprétés en tant que tels. Les caractères alphanumériques (A-Z, a-z et 0-9) sont pris tels quels. Les caractères avec une signification spéciale sont :

  • . correspondra à un seul caractère.

  • [ et ] sont utilisés pour le groupage. Par exemple [A-Z] correspondra aux caractères A,B,C,...,X,Y,Z.

  • {, }, et * sont utilisés pour spécifier avec le nombre de fois la correspondance doit être testée.

  • ^ fait la correspondance avec le début de la valeur, $ le fait lui avec la fin de la valeur.

  • L’antislash \ est utilisé pour échapper le comportement du caractère spécial. Par exemple \$ correspondra au signe dollar.

MapServer supporte deux opérateurs de regex:

  • ~ expression régulière sensible à la casse

  • ~* expression régulière insensible à la casse

La configuration de la LAYER suivante aura tous les enregistrements rendus sur la carte qui ont “hotel” pour l’attribut nommé “placename”

LAYER
    NAME 'regexp-example'
    FILTERITEM 'placename'
    FILTER /hotel/
    ...
END

Note

Pour le FILTER, l’expression régulière est sensible à la casse, par conséquent, les enregistrements ayant “Hotel” dans leur attribut ne correspondront pas.

Exemple: vérifie tous les enregistrements qui ont une valeur de 2000 à 2010 dans l’attribut “year” :

FILTERITEM "year"
FILTER /^20[0-9][0-9]/

Exemple: Vérifie tous les enregistrements qui sont purement numériques ou vides

FILTER /^[0-9]*$/

Exemple: vérifie tous les objets où l’attribut name finit par “by”, “BY”, “By” ou “bY” (vérification insensible à la casse):

EXPRESSION ('[name]' ~* 'by$')

Exemple: vérifie tous les objets dont l’attribut rdname débute avec “Main”.

LAYER
...
CLASSITEM 'rdname'
CLASS

  EXPRESSION /^Main.*$/

Note

Si vous expérimentez fréquemment des erreurs de segmentation quand vous travailler avec MapServer et les expressions régulières, cela peut être dû au fait que votre environnement de travail courant est associé à plus d’une seule bibliothèque d’expressions régulières. Cela peut avoir lieu quand MapServer est “linké” avec ces composants qui apportent leur propre copie, comme le serveur httpd Apache ou PHP. Dans ces cas, l’auteur a eu les meilleurs résultats en compilant tous ces composants en utilisant la bibliothèque d’expressions régulières du système d’exploitation (c’est à dire celui qui est dans libc). Cela implique d’éditer les fichiers de compilation de quelques composants cependant.

Expressions de liste

Nouveau dans la version 6.4.

Les expressions de listes (voir rfc95) sont une manière performante de comparer une chaîne de caractères à des valeurs multiples. Elles dupliquent les expressions regex ou mapserver existantes mais sont significativement plus performantes. Pour les utiliser, délimitez une liste de valeurs séparées par des virgules entre {}, sans ajouter de guillemets ou d’espaces supplémentaires.

LAYER
    NAME 'list-example'
    CLASSITEM 'roadtype'
    ...
    CLASS
      EXPRESSION {motorway,trunk}
      #equivalent to regex EXPRESSION /motorway|trunk/
      #equivalent to mapserver EXPRESSION ("[roadtype]" IN "motorway,trunk")
      ...
    END
    CLASS
      EXPRESSION {primary,secondary}
      ...
    END
END

Avertissement

List expressions do not support quote escaping, or attribute values that contain a comma in them.

“Expressions MapServer”

Les expressions MapServer sont les plus complexes et en fonction de comment elles sont écrites peuvent devenir plutôt lentes. Elles peuvent correspondre à n’importe quel attribut et en plus permettent un filtrage et une classification dépendante de plus d’un seul attribut. En plus des opérations logiques, il y a aussi des expressions qui permettent certaines opérations arithmétiques, de chaînes et de temps.

Pour être capable d’utiliser une expression MapServer pour une valeur FILTER ou EXPRESSION, l’expression doit à la fin devenir une valeur logique.

Typing

The type of attributes and literals is determined as followed :

  • Strings: enclosed in quote or single quote characters
"[string_attribute]" or '[string_attribute]'
"string_literal" or 'string_literal'
  • Numbers: no quoting
[numeric_attribute]
numeric_value
  • Date-time: enclosed in backquote characters
`[date_time_attribute]`
`date_time_literal`

Expressions logiques

Syntactiquement, une expression logique est tout ce qui est encapsulé dans des parenthèses. Les expressions logiques prennent des valeurs logiques comme entrée et retourne des valeurs logiques. Une expression logique est soit ‘true’, soit ‘false’.

  • ( ( Expression1 ) AND ( Expression2 ) )

    ( ( Expression1 ) && ( Expression2 ) )

    retourne vrai quand les deux expressions logiques (Expression1 ou Expression2) sont à vrai.

  • ( ( Expression1 ) OR ( Expression2 ) )

    ( ( Expression1 ) || ( Expression2 ) )

    retourne vrai quand au moins une des expressions logiques (Expression1 ou Expression2) est à vrai.

  • NOT ( Expression1 )

    ! ( Expression1 )

    retourne vrai quand l’Expression1 est à faux

Expressions de chaîne qui retourne une valeur logique

Syntaxiquement, une chaîne est quelque choses d’entouré de guillemets simples ou doubles.

  • ( “Chaine1” eq “Chaine2” )

    ( “Chaine1” == “Chaine2” ) - déprécié depuis la version 6.0

    ( “Chaine1” = “Chaine2” )

    retourne vrai quand les chaînes sont égales. Sensible à la casse.

  • ( “Chaine1” =* “Chaine2” )

    retourne vrai quand les chaînes sont égales. Insensible à la casse.

  • ( “Chaine1” != “Chaine2” )

    ( “Chaine1” ne “Chaine2” )

    retourne vrai quand les chaînes ne sont pas égales.

  • ( “Chaine1” < “Chaine2” )

    ( “Chaine1” lt “Chaine2” )

    retourne vrai quand la “Chaine1” est lexicographiquement plus petite que la “Chaine2”.

  • ( “Chaine1” > “Chaine2” )

    ( “Chaine1” gt “Chaine2” )

    retourne vrai quand la “Chaine1” est lexicographiquement plus grande que la “Chaine2”.

  • ( “Chaine1” <= “Chaine2” )

    ( “Chaine1” le “Chaine2” )

    retourne vrai quand la “Chaine1” est lexicographiquement plus petite ou égale à la “Chaine2”.

  • ( “Chaine1” >= “Chaine2” )

    ( “Chaine1” ge “Chaine2” )

    retourne vrai quand la “Chaine1” est lexicographiquement plus grande ou égale à la “Chaine2”.

  • ( “Chaine1” IN “token1,token2,...,tokenN” )

    retourne vrai quand la “Chaine1” est égale à l’un des tokens passés.

    Note

    Le séparateur pour les tokens est la virgule. Cela signifie qu’il ne peut pas y avoir d’espace blanc dans la liste et que les tokens qui contiennent des virgules ne peuvent pas être comparés.

  • ( “Chaine1” ~ “regexp” )

    retourne vrai quand “Chaine1” correspond à l’expression régulière “regexp”. Cette opération est identique à celle de correspondance d’expression régulière décrite plus tôt.

  • ( “Chaine1” ~* “regexp” )

    retourne vrai quand “Chaine1” correspond à l’expression régulière “regexp” (insensible à la casse). Cette opération est identique à celle de correspondance d’expression régulière décrite plus tôt.

Expressions arithmétiques qui retourne une valeur logique

L’élément basique pour les opérations arithmétiques est le nombre. Les opérations arithmétiques qui renvoient des nombres seront abordées dans la section suivante.

  • ( n1 eq n2 )

    ( n1 == n2 ) - déprécié depuis la version 6.0

    ( n1 = n2 )

    retourne vrai quand les nombres sont égaux

  • ( n1 != n2 )

    ( n1 ne n2 )

    retourne vrai quand les nombres ne sont pas égaux.

  • ( n1 < n2 )

    ( n1 lt n2 )

    retourne vrai quand n1 est plus petit que n2.

  • ( n1 > n2 )

    ( n1 gt n2 )

    retourne vrai quand n1 est plus grand que n2.

  • ( n1 <= n2 )

    ( n1 le n2 )

    retourne vrai quand n1 est plus petit que ou égal à n2.

  • ( n1 >= n2 )

    ( n1 ge n2 )

    retourne vrai quand n1 est plus grand que ou égal à n2.

  • ( n1 IN “number1,number2,...,numberN” )

    retourne vrai quand n1 est égal à l’un des nombres donnés.

Expressions spatiales qui retournent une valeur logique (GEOS)

  • ( forme1 eq forme2 )

    retourne vrai si la forme1 et la forme2 sont égales

  • ( forme1 intersects forme2 )

    retourne vrai si la forme1 et la forme2 s’intersectent

    Nouveau dans la version 6.0.

  • ( forme1 disjoint forme2 )

    retourne vrai si la forme1 et la forme2 sont disjointes

    Nouveau dans la version 6.0.

  • ( forme1 touches forme2 )

    retourne vrai si la forme1 et la forme2 se touchent

    Nouveau dans la version 6.0.

  • ( forme1 overlaps forme2 )

    retourne vrai si la forme1 et la forme2 se recouvrent

    Nouveau dans la version 6.0.

  • ( forme1 crosses forme2 )

    retourne vrai si la forme1 et la forme2 se croisent

    Nouveau dans la version 6.0.

  • ( forme1 within forme2 )

    retourne vrai si la forme1 est à l’intérieur de la forme2

    Nouveau dans la version 6.0.

  • ( forme1 contains forme2 )

    retourne vrai si la forme1 contient la forme2

    Nouveau dans la version 6.0.

  • ( forme1 dwithin forme2 )

    retourne vrai si la distance entre la forme1 et la forme2 est égale à 0

    Nouveau dans la version 6.0.

  • ( forme1 beyond forme2 )

    retourne vrai si la distance entre la forme1 et la forme2 est supérieure à 0

    Nouveau dans la version 6.0.

Opérations sur les chaînes qui retournent un chaîne

  • “Chaine1” + “Chaine2’

    retourne “Chaine1Chaine2”, qui sont les deux chaînes concaténées l’une avec l’autre.

Fonctions qui retournent une chaîne

  • tostring ( n1, “Format1” )

    utilise “Format1” pour formater le nombre n1 (formatage en style C - sprintf).

    Nouveau dans la version 6.0.

  • commify ( “Chaine1” )

    ajoute le séparateur de milliers (virgule) à un nombre long pour le rendre plus lisible

    Nouveau dans la version 6.0.

  • upper ( “Chaîne1” )

    force tous les caractères en majuscule

    Nouveau dans la version 7.0.

  • lower ( “Chaîne1” )

    force tous les caractères en minuscule

    Nouveau dans la version 7.0.

  • initcap ( “String1” )

    force the first character to uppercase and the rest of the characters to lower case for EACH word in the string.

    Nouveau dans la version 7.0.

  • firstcap ( “String1” )

    force the first character to uppercase and the rest of the characters to lower case in the first word in the string.

    Nouveau dans la version 7.0.

Fonctions de chaînes qui retournent un nombre

  • length ( “Chaine1” )

    retourne le nombre de caractères de “Chaine1”

Opérations arithmétiques et fonctions qui retournent un nombre

  • round ( n1 , n2 )

    retourne n1 arrondi à un multiple de n2: n2 * round(n1/n2)

    Nouveau dans la version 6.0.

  • n1 + n2

    retourne la somme de n1 et n2

  • n1 - n2

    retourne n2 soustrait de n1

  • n1 * n2

    retourne n1 multiplié par n2

  • n1 / n2>

    retourne n1 divisé par n2

  • -n1

    retourne l’opposé de n1

  • n1 ^ n2

    retourne n1 à la puissance n2

Note

Quand les opérations numériques ci-dessus sont utilisées comme des opérations logiques, la régle suivante s’applique : les valeurs égales à zéro seront prises comme ‘false’ et tous les autres cas renvoierons ‘true’. Ce qui signifie que l’expression

( 6 + 5 )

devrait retourner vrai, mais

( 5 - 5 )

retournera en fait faux

Fonctions spatiales qui retournent un nombre (GEOS)

  • area ( forme1 )

    retourne l’aire de forme1

    Nouveau dans la version 6.0.

Fonctions spatiales qui retournent une forme (GEOS)

  • fromtext ( “Chaine1” )

    retourne la forme correspondante à la Chaine1 (WKT - well known text)

    fromText('POINT(500000 5000000)')
    

    Nouveau dans la version 6.0.

  • buffer (forme1 , n1 )

    retourne la forme qui résulte quand on appliqué à la forme1 un tampon d’une distance n1

    Nouveau dans la version 6.0.

  • difference ( forme1 , forme2 )

    retourne la forme qui résulte quand l’aire commune à la forme1 et à la forme2 est soustraite de la forme1

    Nouveau dans la version 6.0.

Expressions temporelles

MapServer utilise un type temps interne pour faire la comparaison. Pour convertir une chaîne dans ce type temps, Mapserver va vérifier dans la liste suivante du haut vers le bas si le temps spécifié correspond, et dans ce cas, il fera la conversion. Pour les valeurs entières, on utilise: YYYY - année, MM - mois, DD - jour, hh - heures, mm - minutes, ss - secondes. Lss caractères servant à renseigner les éléments de formatage sont : - (tiret) - séparateur de date, : (deux-points) - séparateur de temps, T - marque le début du composant temps (ISO 8601), espace - marque la fin de la date et le début du composant temps, Z - GMT (Ligne de temps du méridien de Greenwich).

  • `YYYY-MM-DDThh:mm:ssZ`
  • `YYYY-MM-DDThh:mm:ss`
  • `YYYY-MM-DD hh:mm:ss`
  • `YYYY-MM-DDThh:mm`
  • `YYYY-MM-DD hh:mm`
  • `YYYY-MM-DDThh`
  • `YYYY-MM-DD hh`
  • `YYYY-MM-DD`
  • `YYYY-MM`
  • `YYYY`
  • `Thh:mm:ssZ`
  • `Thh:mm:ss`

Pour les valeurs temporelles obtenues de cette manière, les opérations suivantes sont supportées :

  • ( t1 eq t2 )

    ( n1 == n2 ) - déprécié depuis la version 6.0

    ( t1 = t2 )

    retourne vrai quand les deux temps sont égaux.

  • ( t1 != t2 )

    ( t1 ne t2 )

    retourne vrai quand les deux temps ne sont pas égaux.

  • ( t1 < t2 )

    ( t1 lt t2 )

    retourne vrai quand t1 est plus tôt que t2.

  • ( t1 > t2 )

    ( t1 gt t2 )

    retourne vrai quand t1 est plus tard que t2.

  • ( t1 <= t2 )

    ( t1 le t2 )

    retourne vrai quand t1 est plus tôt ou égal à t2.

  • ( t1 >= t2 )

    ( t1 ge t2 )

    retourne vrai quand t1 est plus tard ou égal à t2.