

 Amazon Redshift ne prendra plus en charge l'utilisation des UDF Python après le 30 juin 2026. Nous allons commencer à l'appliquer par étapes. Pour plus d'informations sur les détails de la fin de vie et des options de migration de Python, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/) qui a été publié le 30 juin 2025. 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Appel de procédures stockées dans des bases de données et via le partage de données

Avec Amazon Redshift, vous pouvez appeler des procédures stockées dans des bases de données et via le partage de données. Lorsque vous êtes connecté à une base de données, vous pouvez appeler une procédure stockée dans une autre base de données du même cluster. Vous pouvez également appeler une procédure qu'un producteur partage avec vous via un partage de données. Cette rubrique explique comment utiliser cette fonctionnalité et ses limites.

Les exemples de cette section utilisent une base de données de producteurs nommée `producer_db` qui est partagé via le partage de données `salesshare`. En ce qui concerne le consommateur, `datashare_db` est la base de données créée à partir de ce partage de données, et `consumer_db` est une base de données locale pour le consommateur.

## Partage et appel d'une procédure
<a name="stored-procedure-data-sharing-call"></a>

Pour partager une procédure, accordez `EXECUTE` sur celui-ci au partage de données, et donnez au consommateur l'accès au partage de données.

Pour appeler une procédure stockée à distance, exécutez d'abord `USE` pour définir le contexte de la base de données en fonction de la base de données qui contient la procédure. Pour une procédure partagée via un partage de données, il s'agit de la base de données que vous avez créée à partir de ce partage de données. Appelez ensuite la procédure par son nom en une, deux ou trois parties. Tu dois courir `USE` même si vous appelez la procédure par son nom en trois parties.

```
-- On the producer, in producer_db
CREATE PROCEDURE public.refresh_summary(p_region varchar)
AS $$
BEGIN
  DELETE FROM public.sales_summary WHERE region = p_region;
  INSERT INTO public.sales_summary
    SELECT region, SUM(amount) FROM public.sales WHERE region = p_region GROUP BY region;
END;
$$ LANGUAGE plpgsql;

CREATE DATASHARE salesshare;
GRANT USAGE ON SCHEMA public TO DATASHARE salesshare;
GRANT SELECT ON public.sales TO DATASHARE salesshare;
GRANT SELECT, INSERT, DELETE ON public.sales_summary TO DATASHARE salesshare;
GRANT EXECUTE ON PROCEDURE public.refresh_summary(varchar) TO DATASHARE salesshare;
GRANT USAGE ON DATASHARE salesshare TO NAMESPACE 'consumer-namespace-id';
```

Sur le consommateur, créez une base de données à partir du partage de données, définissez le contexte de la base de données et appelez la procédure.

```
-- On the consumer, in consumer_db
CREATE DATABASE datashare_db FROM DATASHARE salesshare OF NAMESPACE 'producer-namespace-id';

USE datashare_db;

-- Three-part name
CALL datashare_db.public.refresh_summary('WEST');

-- Two-part name
CALL public.refresh_summary('WEST');

-- One-part name
SET search_path TO public;
CALL refresh_summary('WEST');
```

Pour arrêter de partager la procédure, révoquez `EXECUTE` dessus depuis le partage de données.

```
-- On the producer
REVOKE EXECUTE ON PROCEDURE public.refresh_summary(varchar) FROM DATASHARE salesshare;
```

## Comment se résolvent les noms d'objets
<a name="stored-procedure-data-sharing-names"></a>
+ One-part et les noms en deux parties dans le corps de la procédure sont résolus dans la base de données définie par `USE`, donc `public.sales` fait référence à `datashare_db.public.sales`.
+ Three-part les noms se résolvent de la même manière que dans toute autre déclaration que vous envoyez au consommateur. Utilisez le nom côté client d'une base de données partagée, tel que `datashare_db`, ou le nom d'une base de données locale pour le consommateur.
+ Les mêmes règles s'appliquent au SQL dynamique avec lequel la procédure s'exécute. `EXECUTE` et aux procédures qu'il appelle.

La procédure suivante compare un total dans la table partagée avec un total dans une table locale au consommateur.

```
-- On the producer, in producer_db
CREATE PROCEDURE public.compare_totals(p_region varchar)
AS $$
DECLARE
  shared_total decimal(12,2);
  local_total decimal(12,2);
BEGIN
  SELECT SUM(amount) INTO shared_total
    FROM datashare_db.public.sales WHERE region = p_region;
  SELECT SUM(total) INTO local_total
    FROM consumer_db.public.regional_totals WHERE region = p_region;
  RAISE INFO 'shared: %, local: %', shared_total, local_total;
END;
$$ LANGUAGE plpgsql;

GRANT EXECUTE ON PROCEDURE public.compare_totals(varchar) TO DATASHARE salesshare;
```

```
-- On the consumer, in consumer_db
USE datashare_db;
CALL datashare_db.public.compare_totals('WEST');

INFO:  shared: 150.00, local: 150.00
```

## Écrire dans plusieurs bases de données
<a name="stored-procedure-data-sharing-writes"></a>

Une transaction ne peut écrire que dans une seule base de données. Après `USE datashare_db`, les écritures qui utilisent des noms en une ou deux parties accèdent à la base de données partagée. Pour écrire dans une autre base de données, la procédure valide la transaction en cours, exécute `USE` pour modifier le contexte de la base de données, puis écrit avec des noms en une ou deux parties. Courez `COMMIT` immédiatement avant chaque `USE` dans le corps de la procédure.

UNE `USE` ou `RESET USE` dans le corps de la procédure s'applique aux instructions qui la suivent et restent en vigueur pendant votre session une fois la procédure revenue. Après `RESET USE`, les instructions sont exécutées dans la base de données à laquelle vous êtes connecté sur le consommateur.

La procédure suivante met à jour un résumé dans la base de données partagée, puis écrit une ligne de journal dans une base de données locale du client.

```
-- On the producer, in producer_db
CREATE PROCEDURE public.summarize_and_log(p_region varchar)
AS $$
BEGIN
  DELETE FROM public.sales_summary WHERE region = p_region;
  INSERT INTO public.sales_summary
    SELECT region, SUM(amount) FROM public.sales WHERE region = p_region GROUP BY region;
  COMMIT;
  USE consumer_db;
  INSERT INTO public.run_log VALUES (p_region, GETDATE());
END;
$$ LANGUAGE plpgsql;

GRANT EXECUTE ON PROCEDURE public.summarize_and_log(varchar) TO DATASHARE salesshare;
```

```
-- On the consumer, in consumer_db
USE datashare_db;
CALL datashare_db.public.summarize_and_log('EAST');
SHOW USE;

 Use Database
--------------
 consumer_db
```

## Limitations
<a name="stored-procedure-data-sharing-limitations"></a>

Les limites suivantes s'appliquent aux procédures que vous appelez via des bases de données ou via le partage de données :
+ Vous ne pouvez pas appeler une procédure créée avec `SECURITY DEFINER`.
+ Vous ne pouvez pas appeler un `NONATOMIC` procédure par le biais du partage de données.
+ Vous ne pouvez pas appeler une procédure via un partage de données partagé avec un autre AWS compte, ou via un partage de données géré par Lake Formation.
+ Vous ne pouvez pas appeler une procédure dans une base de données créée à partir d'un partage de données avec `WITH PERMISSIONS` clause.
+ Vous ne pouvez pas créer, remplacer ou supprimer une procédure dans une autre base de données. Exécutez ces commandes dans la base de données qui contient la procédure.
+ Vous ne pouvez pas appeler une procédure via un schéma externe. Courez `USE` au lieu de cela.
+ La procédure ne peut pas utiliser `%TYPE` attribut.
+ Les instructions de la procédure se comportent de la même manière que lorsque vous les exécutez sur l'autre base de données ou par le biais du partage de données, et non comme des instructions locales. Par exemple, `TRUNCATE` sur une table de la base de données partagée ne valide pas la transaction, donc une date ultérieure `ROLLBACK` dans la procédure annule également `TRUNCATE`.