Documentation PostgreSQL 14.22 » Langage SQL » Fonctions et opérateurs » Fonctions et opérateurs sur les intervalles simple/multiple

Précédent | Niveau supérieur | Suivant
9.19. Fonctions et opérateurs tableau | Sommaire | 9.21. Fonctions d'agrégat

## 9.20. Fonctions et opérateurs sur les intervalles simple/multiple

Voir Section 8.17 pour un aperçu les types d'intervalle.

Tableau 9.53 montre les opérateurs spécialisés disponibles pour les types d'intervalle simple. Tableau 9.54 montre les opérateurs spécialisés disponibles pour les types d'intervalle multiple. En plus de ces derniers, les opérateurs de comparaison habituels montrés dans Tableau 9.1 sont disponibles pour les types d'intervalle simple et multiple. Les opérateurs de comparaison trient d'abord par les limites basses de l'intervalle simple et seulement si ces dernières sont identiques, par les limites hautes. Les opérateurs de comparaison multiple comparent chaque intervalle jusqu'à ce qu'au moins un ne corresponde pas. Ceci ne donne généralement pas de résultat utile pour un tri, mais les opérateurs sont fournis pour autoriser la création d'index d'unicité sur des intervalles.

Tableau 9.53. Opérateurs sur les intervalles simples

Opérateur Description Exemple(s)
`anyrange` `@>` `anyrange` → `boolean` Est-ce que le premier intervalle contient le second ? `int4range(2,4) @> int4range(2,3)` → `t`
`anyrange` `@>` `anyelement` → `boolean` Est-ce que l'intervalle contient l'élément ? `'[2011-01-01,2011-03-01)'::tsrange @> '2011-01-10'::timestamp` → `t`
`anyrange` `<@` `anyrange` → `boolean` Est-ce que le premier intervalle est contenu par le second ? `int4range(2,4) <@ int4range(1,7)` → `t`
`anyelement` `<@` `anyrange` → `boolean` Est-ce que l'élément est contenu dans l'intervalle ? `42 <@ int4range(1,7)` → `f`
`anyrange` `&&` `anyrange` → `boolean` Est-ce que les intervalles se surchargent, c'est-à-dire ont-ils des éléments en commun ? `int8range(3,7) && int8range(4,12)` → `t`
`anyrange` `<<` `anyrange` → `boolean` Est-ce que le premier intervalle se trouve strictement à gauche du second ? `int8range(1,10) << int8range(100,110)` → `t`
`anyrange` `>>` `anyrange` → `boolean` Est-ce que le premier intervalle est strictement à droite du second ? `int8range(50,60) >> int8range(20,30)` → `t`
`anyrange` `&<` `anyrange` → `boolean` Est-ce que le premier intervalle ne s'étend pas à droite du second ? `int8range(1,20) &< int8range(18,20)` → `t`
`anyrange` `&>` `anyrange` → `boolean` Est-ce que le premier intervalle ne s'étend pas à gauche du second ? `int8range(7,20) &> int8range(5,10)` → `t`
`anyrange` `-|-` `anyrange` → `boolean` Est-ce que les intervalles sont adjacents ? `numrange(1.1,2.2) -|- numrange(2.2,3.3)` → `t`
`anyrange` `+` `anyrange` → `anyrange` Calcule l'union des intervalles. Les intervalles doivent se superposer ou être adjacents, pour que l'union résultante soit un intervalle simple (mais voir `range_merge()`). `numrange(5,15) + numrange(10,20)` → `[5,20)`
`anyrange` `*` `anyrange` → `anyrange` Calcule l'intersection des intervalles. `int8range(5,15) * int8range(10,20)` → `[10,15)`
`anyrange` `-` `anyrange` → `anyrange` Calcule la différence des intervalles. Le deuxième intervalle ne doit pas être contenu dans le premier de façon à ce que la différence ne soit pas un intervalle simple. `int8range(5,15) - int8range(10,20)` → `[5,10)`

Tableau 9.54. Opérateurs sur les intervalles multiples

Opérateur Description Exemple(s)
`anymultirange` `@>` `anymultirange` → `boolean` Est-ce que le premier intervalle multiple contient le second ? `'{[2,4)}'::int4multirange @> '{[2,3)}'::int4multirange` → `t`
`anymultirange` `@>` `anyrange` → `boolean` Est-ce que l'intervalle multiple contient l'intervalle simple ? `'{[2,4)}'::int4multirange @> int4range(2,3)` → `t`
`anymultirange` `@>` `anyelement` → `boolean` Est-ce que l'intervalle multiple contient l'élément ? `'{[2011-01-01,2011-03-01)}'::tsmultirange @> '2011-01-10'::timestamp` → `t`
`anyrange` `@>` `anymultirange` → `boolean` Est-ce que l'intervalle simple contient l'intervalle multiple ? `'[2,4)'::int4range @> '{[2,3)}'::int4multirange` → `t`
`anymultirange` `<@` `anymultirange` → `boolean` Est-ce que le premier intervalle multiple est contenu par le second ? `'{[2,4)}'::int4multirange <@ '{[1,7)}'::int4multirange` → `t`
`anymultirange` `<@` `anyrange` → `boolean` Est-ce que l'intervalle multiple est contenu par l'intervalle simple ? `'{[2,4)}'::int4multirange <@ int4range(1,7)` → `t`
`anyrange` `<@` `anymultirange` → `boolean` Est-ce que l'intervalle simple est contenu par l'intervalle multiple ? `int4range(2,4) <@ '{[1,7)}'::int4multirange` → `t`
`anyelement` `<@` `anymultirange` → `boolean` Est-ce que l'élément est contenu dans l'intervalle multiple ? `4 <@ '{[1,7)}'::int4multirange` → `t`
`anymultirange` `&&` `anymultirange` → `boolean` Est-ce que les intervalles multiples se recouvrent, c'est-à-dire, contiennent des éléments communs ? `'{[3,7)}'::int8multirange && '{[4,12)}'::int8multirange` → `t`
`anymultirange` `&&` `anyrange` → `boolean` Est-ce que l'intervalle multiple recouvre l'intervalle simple ? `'{[3,7)}'::int8multirange && int8range(4,12)` → `t`
`anyrange` `&&` `anymultirange` → `boolean` Est-ce que l'intervalle simple recouvre l'intervalle multiple ? `int8range(3,7) && '{[4,12)}'::int8multirange` → `t`
`anymultirange` `<<` `anymultirange` → `boolean` Est-ce que le premier intervalle multiple est strictement à gauche du second ? `'{[1,10)}'::int8multirange << '{[100,110)}'::int8multirange` → `t`
`anymultirange` `<<` `anyrange` → `boolean` Est-ce que l'intervalle multiple est strictement à gauche de l'intervalle simple ? `'{[1,10)}'::int8multirange << int8range(100,110)` → `t`
`anyrange` `<<` `anymultirange` → `boolean` Est-ce que l'intervalle simple est strictement à gauche de l'intervalle multiple ? `int8range(1,10) << '{[100,110)}'::int8multirange` → `t`
`anymultirange` `>>` `anymultirange` → `boolean` Est-ce que le premier intervalle multiple est strictement à droite du second ? Is the first multirange strictly right of the second? `'{[50,60)}'::int8multirange >> '{[20,30)}'::int8multirange` → `t`
`anymultirange` `>>` `anyrange` → `boolean` Est-ce que l'intervalle multiple est strictement à droite de l'intervalle simple ? `'{[50,60)}'::int8multirange >> int8range(20,30)` → `t`
`anyrange` `>>` `anymultirange` → `boolean` Est-ce que l'intervalle simple est strictement à droite de l'intervalle multiple ? `int8range(50,60) >> '{[20,30)}'::int8multirange` → `t`
`anymultirange` `&<` `anymultirange` → `boolean` Est-ce que le premier intervalle multiple ne s'étend pas à droite du second ? `'{[1,20)}'::int8multirange &< '{[18,20)}'::int8multirange` → `t`
`anymultirange` `&<` `anyrange` → `boolean` Est-ce que l'intervalle multiple ne s'étend pas à droite de l'intervalle simple ? `'{[1,20)}'::int8multirange &< int8range(18,20)` → `t`
`anyrange` `&<` `anymultirange` → `boolean` Est-ce que l'intervalle simple ne s'étend pas à droite de l'intervalle multiple ? `int8range(1,20) &< '{[18,20)}'::int8multirange` → `t`
`anymultirange` `&>` `anymultirange` → `boolean` Est-ce que l'intervalle multiple ne s'étend pas à gauche du second ? `'{[7,20)}'::int8multirange &> '{[5,10)}'::int8multirange` → `t`
`anymultirange` `&>` `anyrange` → `boolean` Est-ce que l'intervalle multiple ne s'étend pas à gauche de l'intervalle simple ? `'{[7,20)}'::int8multirange &> int8range(5,10)` → `t`
`anyrange` `&>` `anymultirange` → `boolean` Est-ce que l'intervalle simple ne s'étend pas à gauche de l'intervalle multiple ? `int8range(7,20) &> '{[5,10)}'::int8multirange` → `t`
`anymultirange` `-|-` `anymultirange` → `boolean` Est-ce que les intervalles multiples sont adjacents ? `'{[1.1,2.2)}'::nummultirange -|- '{[2.2,3.3)}'::nummultirange` → `t`
`anymultirange` `-|-` `anyrange` → `boolean` Est-ce que l'intervalle multiple est adjacent à l'intervalle simple ? `'{[1.1,2.2)}'::nummultirange -|- numrange(2.2,3.3)` → `t`
`anyrange` `-|-` `anymultirange` → `boolean` Est-ce que l'intervalle simple est adjacent à l'intervalle multiple ? `numrange(1.1,2.2) -|- '{[2.2,3.3)}'::nummultirange` → `t`
`anymultirange` `+` `anymultirange` → `anymultirange` Calcule l'union des intervalles multiples. Les intervalles multiples ne doivent pas se recouvrir, ni être adjacents. `'{[5,10)}'::nummultirange + '{[15,20)}'::nummultirange` → `{[5,10), [15,20)}`
`anymultirange` `*` `anymultirange` → `anymultirange` Calcule l'intersection des intervalles multiples. `'{[5,15)}'::int8multirange * '{[10,20)}'::int8multirange` → `{[10,15)}`
`anymultirange` `-` `anymultirange` → `anymultirange` Calcule la différence des intervalles multiples. `'{[5,20)}'::int8multirange - '{[10,15)}'::int8multirange` → `{[5,10), [15,20)}`

Les opérateurs à gauche/à droite/adjacent retournent toujours false quand un intervalle vide simple ou multiple est impliqué ; c'est-à-dire qu'un intervalle vide n'est pas considéré comme étant avant ou après n'importe quel autre intervalle.

D'autre part, les intervalles vides simples et multiples sont traités comme l’identité additive : tout ce qui est uni à une valeur vide reste identique. Tout ce à quoi est soustrait une valeur vide reste identique. Un intervalle multiple vide a exactement les mêmes effets qu'un intervalle simple vide. Tout intervalle simple contient l'intervalle vide. Tout intervalle multiple contient autant d'intervalles vides que souhaité.

Les opérateurs d'union et de différence d'intervalle échoueront si la plage résultante doit contenir deux sous-plages disjointes, car un tel intervalle ne peut pas être représenté. Il y a des opérateurs séparés pour union et différence qui prennent des paramètres intervalles multiples et retournent un intervalle multiple, et qui n’échouent pas même si leurs arguments sont disjoints. Donc, si vous avez besoin d’une opération d’union ou de différence pour des intervalles qui peuvent être disjoints, vous pouvez éviter les erreurs en transformant d’abord vos intervalles simples en multiples.

Tableau 9.55 montre les fonctions utilisables avec des intervalles simples. Tableau 9.56 montre les fonctions utilisables avec des intervalles multiples.

Tableau 9.55. Fonctions sur intervalles simples

Fonction Description Exemple(s)
`lower` ( `anyrange` ) → `anyelement` Extrait la limite inférieure de l'intervalle (`NULL` si l'intervalle est vide ou que la limite inférieure est l'infini). `lower(numrange(1.1,2.2))` → `1.1`
`upper` ( `anyrange` ) → `anyelement` Extrait la limite supérieure de l'intervalle (`NULL` si l'intervalle est vide ou que la limite supérieure est l'infini). `upper(numrange(1.1,2.2))` → `2.2`
`isempty` ( `anyrange` ) → `boolean` Est-ce que l'intervalle est vide ? `isempty(numrange(1.1,2.2))` → `f`
`lower_inc` ( `anyrange` ) → `boolean` Est-ce que la limite inférieure de l'intervalle est inclusive ? `lower_inc(numrange(1.1,2.2))` → `t`
`upper_inc` ( `anyrange` ) → `boolean` Est-ce que la limite supérieure de l'intervalle est inclusive ? `upper_inc(numrange(1.1,2.2))` → `f`
`lower_inf` ( `anyrange` ) → `boolean` Est-ce que la limite inférieure de l'intervalle est infinie ? `lower_inf('(,)'::daterange)` → `t`
`upper_inf` ( `anyrange` ) → `boolean` Est-ce que la limite supérieure de l'intervalle est infinie ? `upper_inf('(,)'::daterange)` → `t`
`range_merge` ( `anyrange`, `anyrange` ) → `anyrange` Calcule le plus petit intervalle qui inclut les deux intervalles fournis. `range_merge('[1,2)'::int4range, '[3,4)'::int4range)` → `[1,4)`

Tableau 9.56. Fonctions sur intervalles multiples

Fonction Description Exemple(s)
`lower` ( `anymultirange` ) → `anyelement` Extrait la limite inférieure de l'intervalle multiple (`NULL` si l'intervalle multiple est vide ou que la limite inférieure est l'infini). `lower('{[1.1,2.2)}'::nummultirange)` → `1.1`
`upper` ( `anymultirange` ) → `anyelement` Extrait la limite supérieur de l'intervalle multiple (`NULL` si l'intervalle multiple est vide ou que la limite supérieure est l'infini). `upper('{[1.1,2.2)}'::nummultirange)` → `2.2`
`isempty` ( `anymultirange` ) → `boolean` Est-ce que l'intervalle multiple est vide ? `isempty('{[1.1,2.2)}'::nummultirange)` → `f`
`lower_inc` ( `anymultirange` ) → `boolean` Est-ce que la limite inférieure de l'intervalle multiple est inclusive ? `lower_inc('{[1.1,2.2)}'::nummultirange)` → `t`
`upper_inc` ( `anymultirange` ) → `boolean` Est-ce que la limite supérieure de l'intervalle multiple est inclusive ? `upper_inc('{[1.1,2.2)}'::nummultirange)` → `f`
`lower_inf` ( `anymultirange` ) → `boolean` Est-ce que la limite inférieure de l'intervalle multiple est infinie ? `lower_inf('{(,)}'::datemultirange)` → `t`
`upper_inf` ( `anymultirange` ) → `boolean` Est-ce que la limite supérieure de l'intervalle multiple est infinie ? `upper_inf('{(,)}'::datemultirange)` → `t`
`range_merge` ( `anymultirange` ) → `anyrange` Calcule le plus petit intervalle simple qui inclut entièrement l'intervalle multiple. `range_merge('{[1,2), [3,4)}'::int4multirange)` → `[1,4)`
`multirange` ( `anyrange` ) → `anymultirange` Retourne un intervalle multiple contenant seulement l'intervalle simple fourni. `multirange('[1,2)'::int4range)` → `{[1,2)}`
`unnest` ( `anymultirange` ) → `setof anyrange` Étend un intervalle multiple en un ensemble d'intervalles simples. Les intervalles simples sont lus dans l'ordre de stockage (croissant). `unnest('{[1,2), [3,4)}'::int4multirange)` → ``
     [1,2)
     [3,4)

Les fonctions `lower_inc`, `upper_inc`, `lower_inf` et `upper_inf` renvoient toutes false pour un intervalle simple ou multiple vide.