Postgres analogue à CROSS APPLY dans SQL Server

J'ai besoin de migrer des requêtes SQL écrite pour MS SQL Server 2005 pour Postgres 9.1.
Quelle est la meilleure façon de remplacer CROSS APPLY dans cette requête?

SELECT *
FROM V_CitizenVersions         
CROSS APPLY     
       dbo.GetCitizenRecModified(Citizen, LastName, FirstName, MiddleName,
BirthYear, BirthMonth, BirthDay, ..... ) -- lots of params

GetCitizenRecModified() fonction est une fonction à valeur de table. Je ne peux pas mettre de code de cette fonction parce que c'est vraiment énorme, c'est un peu difficile de calculs et je ne peux pas l'abandonner.

source d'informationauteur user1178399

12

Dans Postgres 9.3 ou tard utiliser un LATERAL rejoindre:
```
SELECT v.col_a, v.col_b, f.*  -- no parentheses here, f is a table alias
FROM   v_citizenversions v
LEFT   JOIN LATERAL f_citizen_rec_modified(v.col1, v.col2) f ON true
WHERE  f.col_c = _col_c;
```
Pourquoi LEFT JOIN LATERAL ... ON true?
- Enregistrement retourné à partir de la fonction a des colonnes concaténées
Pour les anciennes versionsil y a un moyen très simple pour accomplir ce que je pense que vous essayez avec un retour de fonction (RETOURNE la TABLE ou RETOURNE SETOF enregistrement OU RETOURNE enregistrement):
```
SELECT *, (f_citizen_rec_modified(col1, col2)).*
FROM   v_citizenversions v
```
La fonction calcule les valeurs une fois pour chaque ligne de la requête externe. Si la fonction retourne plusieurs lignes, lignes obtenues sont multipliés en conséquence. Tous les parenthèses sont syntaxiquement obligatoire de décomposer un type de ligne. La fonction de table pourrait ressembler à quelque chose comme ceci:
```
CREATE OR REPLACE FUNCTION f_citizen_rec_modified(_col1 int, _col2 text)
  RETURNS TABLE(col_c integer, col_d text) AS
$func$
SELECT s.col_c, s.col_d
FROM   some_tbl s
WHERE  s.col_a = $1
AND    s.col_b = $2
$func$ LANGUAGE sql;
```
Vous avez besoin pour habiller cette dans une sous-requête ou CTE, si vous souhaitez appliquer un WHERE clause, car les colonnes ne sont pas visibles sur le même niveau. (Et c'est mieux pour la performance de toute façon, parce que vous empêcher d'évaluations répétées pour chaque colonne de sortie de la fonction):
```
SELECT col_a, col_b, (f_row).*
FROM (
   SELECT col_a, col_b, f_citizen_rec_modified(col1, col2) AS f_row
   FROM   v_citizenversions v
   ) x
WHERE (f_row).col_c = _col_c;
```
Il y a plusieurs autres façons de le faire ou quelque chose de similaire. Tout dépend de ce que vous voulez exactement.

Necromancing:

Nouveau dans PostgreSQL 9.3:

Le LATÉRAL mot-clé

gauche | droite | inner JOIN LATÉRALE

INNER JOIN LATERAL est le même que CROSS APPLY

et LEFT JOIN LATERAL est le même que OUTER APPLY

Exemple d'utilisation:

SELECT * FROM T_Contacts 

--LEFT JOIN T_MAP_Contacts_Ref_OrganisationalUnit ON MAP_CTCOU_CT_UID = T_Contacts.CT_UID AND MAP_CTCOU_SoftDeleteStatus = 1 
--WHERE T_MAP_Contacts_Ref_OrganisationalUnit.MAP_CTCOU_UID IS NULL -- 989


LEFT JOIN LATERAL 
(
    SELECT 
         --MAP_CTCOU_UID    
         MAP_CTCOU_CT_UID   
        ,MAP_CTCOU_COU_UID  
        ,MAP_CTCOU_DateFrom 
        ,MAP_CTCOU_DateTo   
   FROM T_MAP_Contacts_Ref_OrganisationalUnit 
   WHERE MAP_CTCOU_SoftDeleteStatus = 1 
   AND MAP_CTCOU_CT_UID = T_Contacts.CT_UID 

    /*  
    AND 
    ( 
        (__in_DateFrom <= T_MAP_Contacts_Ref_OrganisationalUnit.MAP_KTKOE_DateTo) 
        AND 
        (__in_DateTo >= T_MAP_Contacts_Ref_OrganisationalUnit.MAP_KTKOE_DateFrom) 
    ) 
    */
   ORDER BY MAP_CTCOU_DateFrom 
   LIMIT 1 
) AS FirstOE

1

Ce lien semble montrer comment le faire dans Postgresql 9.0+:

PostgreSQL: paramétrage d'une expression de table commune récursive

C'est en bas de la page dans la section intitulée "l'Émulation de la CROIX APPLIQUER avec le retour des fonctions". Assurez-vous de noter la liste des limitations d'après l'exemple.
1

J'aime Erwin Brandstetter la réponse de l'cependant, j'ai découvert un problème de performance:
lors de l'exécution de
```
SELECT *, (f_citizen_rec_modified(col1, col2)).*
FROM   v_citizenversions v
```
La f_citizen_rec_modified fonction sera couru 1 heure pour chaque colonne, il retourne (multiplié par chaque ligne de v_citizenversions). Je n'ai pas trouver de la documentation pour cet effet, mais a été en mesure de déduire par le débogage. Maintenant, la question devient, comment pouvons-nous obtenir cet effet (avant 9.3 dans le cas où latéral de joint sont disponibles) sans cette performance voler des effets secondaires?

Mise à jour: il me semble avoir trouvé une réponse. Réécriture de la requête comme suit:
```
select x.col1, x.col2, x.col3, (x.func).* 
FROM (select SELECT v.col1, v.col2, v.col3, f_citizen_rec_modified(col1, col2) func
FROM   v_citizenversions v) x
```
La différence essentielle étant l'obtention de la fonction raw résultats de la première (intérieur de la sous-requête) puis d'emballage que dans un autre sélectionner que les bustes de ces résultats dans les colonnes. Cela a été testé sur PG 9.2

Vous devez vous connecter pour publier un commentaire.