

 Amazon Redshift unterstützt die Verwendung von Python-UDFs nach dem 30. Juni 2026 nicht mehr. Wir werden damit beginnen, es schrittweise durchzusetzen. Weitere Informationen zu den Details zum Ende der Lebensdauer von Python und zu den Migrationsoptionen finden Sie auf der [ Blogbeitrag ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/) das wurde am 30. Juni 2025 veröffentlicht. 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Aufrufen gespeicherter Prozeduren datenbankübergreifend und durch gemeinsame Nutzung von Daten

Mit Amazon Redshift können Sie gespeicherte Prozeduren datenbankübergreifend und durch gemeinsame Datennutzung aufrufen. Während Sie mit einer Datenbank verbunden sind, können Sie eine gespeicherte Prozedur in einer anderen Datenbank auf demselben Cluster aufrufen. Sie können auch eine Prozedur aufrufen, die ein Producer über einen Datashare mit Ihnen gemeinsam nutzt. In diesem Thema werden die Verwendung dieser Funktion und ihre Einschränkungen erläutert.

Die Beispiele in diesem Abschnitt verwenden eine Producer-Datenbank mit dem Namen `producer_db` die über den Datashare gemeinsam genutzt wird `salesshare`. Was den Verbraucher betrifft, `datashare_db` ist die Datenbank, die aus diesem Datashare erstellt wurde, und `consumer_db` ist eine lokale Datenbank für den Verbraucher.

## Eine Prozedur teilen und aufrufen
<a name="stored-procedure-data-sharing-call"></a>

Um eine Prozedur gemeinsam zu nutzen, gewähren Sie `EXECUTE` auf das Datensharing übertragen und dem Verbraucher Zugriff auf den Datenaustausch gewähren.

Um eine remote gespeicherte Prozedur aufzurufen, führen Sie zunächst Folgendes aus `USE` um den Datenbankkontext auf die Datenbank festzulegen, die die Prozedur enthält. Bei einer Prozedur, die über ein Datashare gemeinsam genutzt wird, ist dies die Datenbank, die Sie aus dem Datashare erstellt haben. Rufen Sie dann die Prozedur mit ihrem einteiligen, zweiteiligen oder dreiteiligen Namen auf. Sie müssen rennen `USE` auch wenn Sie die Prozedur mit ihrem dreiteiligen Namen aufrufen.

```
-- 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';
```

Erstellen Sie auf dem Consumer eine Datenbank aus dem Datashare, legen Sie den Datenbankkontext fest und rufen Sie die Prozedur auf.

```
-- 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');
```

Um die gemeinsame Nutzung der Prozedur zu beenden, widerrufen Sie `EXECUTE` darauf aus dem Datashare.

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

## Wie werden Objektnamen aufgelöst
<a name="stored-procedure-data-sharing-names"></a>
+ One-part und zweiteilige Namen im Prozedurtext werden in der Datenbank aufgelöst, festgelegt durch `USE`, also `public.sales` bezieht sich auf `datashare_db.public.sales`.
+ Three-part Namen werden auf dieselbe Weise aufgelöst wie in jeder anderen Anweisung, die Sie auf dem Consumer ausführen. Verwenden Sie den benutzerspezifischen Namen einer gemeinsam genutzten Datenbank, z. B. `datashare_db`, oder der Name einer lokalen Datenbank für den Verbraucher.
+ Für dynamisches SQL, mit dem die Prozedur ausgeführt wird, gelten dieselben Regeln `EXECUTE` und für Prozeduren, die sie aufruft.

Das folgende Verfahren vergleicht eine Summe in der gemeinsam genutzten Tabelle mit einer Summe in einer Tabelle, die für den Verbraucher lokal ist.

```
-- 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
```

## In mehr als eine Datenbank schreiben
<a name="stored-procedure-data-sharing-writes"></a>

Eine Transaktion kann nur in eine Datenbank schreiben. Nachher `USE datashare_db`, werden Schreibvorgänge, die ein- oder zweiteilige Namen verwenden, in die gemeinsam genutzte Datenbank geleitet. Um in eine andere Datenbank zu schreiben, schreibt die Prozedur die aktuelle Transaktion fest und wird ausgeführt `USE` um den Datenbankkontext zu ändern, und schreibt dann mit ein- oder zweiteiligen Namen. Führen Sie aus `COMMIT` unmittelbar vor jedem `USE` im Verfahrenskörper.

EIN `USE` oder `RESET USE` im Hauptteil der Prozedur gilt für die darauf folgenden Anweisungen und bleibt in Ihrer Sitzung gültig, nachdem die Prozedur erneut gestartet wurde. Danach `RESET USE`werden die Kontoauszüge in der Datenbank ausgeführt, mit der Sie auf dem Verbraucher verbunden sind.

Das folgende Verfahren aktualisiert eine Zusammenfassung in der gemeinsam genutzten Datenbank und schreibt dann eine Protokollzeile in eine lokale Datenbank für den Verbraucher.

```
-- 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
```

## Einschränkungen
<a name="stored-procedure-data-sharing-limitations"></a>

Die folgenden Einschränkungen gelten für Prozeduren, die Sie datenbankübergreifend oder durch gemeinsame Datennutzung aufrufen:
+ Sie können keine Prozedur aufrufen, die mit erstellt wurde `SECURITY DEFINER`.
+ Du kannst keinen anrufen `NONATOMIC` Verfahren durch Datenaustausch.
+ Sie können eine Prozedur nicht über einen Datenaustausch aufrufen, der mit einem anderen gemeinsam genutzt wird AWS Konto oder über einen von Lake Formation verwalteten Datashare.
+ Sie können keine Prozedur in einer Datenbank aufrufen, die aus einem Datashare erstellt wurde, mit dem `WITH PERMISSIONS` Klausel.
+ Sie können eine Prozedur in einer anderen Datenbank nicht erstellen, ersetzen oder löschen. Führen Sie diese Befehle in der Datenbank aus, die die Prozedur enthält.
+ Sie können eine Prozedur nicht über ein externes Schema aufrufen. Führen Sie aus `USE` stattdessen.
+ Das Verfahren kann das nicht verwenden `%TYPE` Attribut.
+ Anweisungen in der Prozedur verhalten sich genauso, als würden Sie sie für die andere Datenbank oder durch gemeinsame Datennutzung ausführen, nicht wie lokale Anweisungen. Zum Beispiel `TRUNCATE` an einer Tabelle in der gemeinsam genutzten Datenbank wird die Transaktion nicht festgeschrieben, also eine spätere `ROLLBACK` in der Prozedur macht auch das rückgängig `TRUNCATE`.