Comment éviter les évaluations de fonctions multiples avec la syntaxe `(func()).*` de PostgreSQL ?

Optimiser les requêtes PostgreSQL : éviter les appels de fonctions redondants avec (func()).*

L'utilisation de la syntaxe (func()).* dans PostgreSQL pour accéder aux résultats d'une fonction renvoyant un type composite ou TABLE peut entraîner des problèmes de performances en raison d'évaluations répétées de la fonction. Cela se produit car la syntaxe se développe en plusieurs références de colonnes, chacune déclenchant un appel de fonction distinct. Le nombre d'appels est égal au nombre de colonnes dans l'ensemble de résultats.

Le problème : Appels à fonctions multiples inefficaces

L'approche (func()).* est inefficace car elle n'optimise pas les appels de fonction minimaux. Idéalement, la fonction ne devrait être appelée qu'une seule fois pour récupérer l'intégralité du jeu de résultats.

Solutions :

PostgreSQL 9.3 et versions ultérieures offrent une solution simple utilisant les LATERAL jointures :

<code class="language-sql">SELECT mf.*
FROM some_table
LEFT JOIN LATERAL my_func(some_table.x) AS mf ON true;</code>

LATERAL garantit que my_func n'est exécuté qu'une seule fois par ligne dans some_table, améliorant considérablement les performances.

Pour les anciennes versions de PostgreSQL (antérieures à 9.3), des solutions de contournement sont nécessaires :

Solution 1 : OFFSET 0Piratage

Cette méthode exploite la clause OFFSET 0 pour forcer une seule évaluation de fonction :

<code class="language-sql">SELECT (mf).* FROM (
    SELECT my_func(x) AS mf FROM some_table OFFSET 0
) sub;</code>

Solution de contournement 2 : expression de table commune (CTE)

Un CTE offre une alternative plus propre :

<code class="language-sql">WITH tmp AS (
    SELECT my_func(x) FROM some_table
)
SELECT (mf).* FROM tmp;</code>

Les deux solutions de contournement garantissent que my_func n'est appelé qu'une seule fois, récupérant l'ensemble de résultats complet avant d'accéder aux colonnes individuelles.

Cause fondamentale : Extension de l'analyseur

Les multiples évaluations découlent de la façon dont l'analyseur PostgreSQL interprète (func()).*. Cela traduit cela en accès à des colonnes séparées, ce qui entraîne plusieurs invocations de fonctions. Cette limitation a été résolue dans les versions plus récentes avec l'introduction des LATERAL jointures.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!