Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

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.

# Benutzerdefinierte Funktionen in Amazon Redshift
<a name="user-defined-functions"></a>

Sie können eine benutzerdefinierte Skalar-UDF (user-defined function) erstellen, indem Sie entweder eine SQL SELECT-Klausel oder ein Python-Programm verwenden. Die neue Funktion ist in der Datenbank gespeichert und steht jedem Benutzer mit ausreichenden Berechtigungen zur Ausführung zur Verfügung. Sie führen eine benutzerdefinierte skalare UDF genauso aus wie bestehende Amazon-Redshift-Funktionen. 

Für Python UDFs können Sie nicht nur die Standard-Python-Funktionalität verwenden, sondern auch Ihre eigenen benutzerdefinierten Python-Module importieren. Weitere Informationen finden Sie unter [Python-Sprachunterstützung für UDFs](udf-python-language-support.md). Beachten Sie, dass Python 3 nicht für Python verfügbar ist UDFs. Um Python 3-Unterstützung für Amazon Redshift zu erhalten UDFs, verwenden Sie [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md) stattdessen.

Sie können auch erstellen AWS Lambda UDFs , die benutzerdefinierte Funktionen verwenden, die in Lambda als Teil Ihrer SQL-Abfragen definiert sind. Mit Lambda UDFs können Sie komplexe Komponenten schreiben UDFs und diese in Komponenten von Drittanbietern integrieren. Sie können Ihnen auch dabei helfen, einige der Einschränkungen der aktuellen Python- und SQL-Version zu überwinden UDFs. So können Sie beispielsweise auf Netzwerk- und Speicherressourcen zugreifen und vollwertige SQL-Anweisungen schreiben. Sie können Lambda UDFs in jeder der von Lambda unterstützten Programmiersprachen wie Java, Go, Node.js, C\$1 PowerShell, Python und Ruby erstellen. Sie können auch eine benutzerdefinierte Laufzeit verwenden.

Standardmäßig können alle Benutzer ausführen. UDFs Weitere Informationen zu Rechten finden Sie in [UDF-Sicherheit und -Berechtigungen](udf-security-and-privileges.md).

**Topics**
+ [UDF-Sicherheit und -Berechtigungen](udf-security-and-privileges.md)
+ [Verhindern von UDF-Namenskonflikten](udf-naming-udfs.md)
+ [Skalares SQL UDFs](udf-creating-a-scalar-sql-udf.md)
+ [Skalares Python UDFs](udf-creating-a-scalar-udf.md)
+ [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md)
+ [Anwendungsbeispiele für benutzerdefinierte Funktionen () UDFs](udf-example-uses.md)

# UDF-Sicherheit und -Berechtigungen
<a name="udf-security-and-privileges"></a>

Zum Erstellen einer UDF müssen Sie eine Berechtigung für die Nutzung in der Sprache für SQL oder plpythonu (Python) besitzen. Standardmäßig wird USAGE ON LANGUAGE SQL für PUBLIC gewährt. Sie müssen jedoch USAGE ON LANGUAGE PLPYTHONU spezifischen Benutzern oder Gruppen explizit gewähren. 

Um die Nutzung für SQL zu widerrufen, widerrufen Sie zuerst die Nutzung von PUBLIC. Gewähren Sie dann nur den bestimmten Benutzern oder Gruppen, die SQL erstellen dürfen, die Verwendung von SQL UDFs. Beim folgenden Beispiel wird die Nutzung von SQL durch Benutzer mit Berechtigungen der Gruppe „PUBLIC“ untersagt. Daraufhin wird die Nutzung der Benutzergruppe erlaubt `udf_devs`.

```
revoke usage on language sql from PUBLIC;
grant usage on language sql to group udf_devs;
```

Um eine UDF auszuführen, benötigen Sie für die jeweilige Funktion eine Ausführungsberechtigung. Standardmäßig wird PUBLIC die Berechtigung zum Ausführen von new UDFs erteilt. Um die Nutzung einzuschränken, widerrufen Sie diese Berechtigung für die Funktion von PUBLIC. Gewähren Sie die Berechtigung anschließend den spezifischen Einzelpersonen oder Gruppen. 

Beim folgenden Beispiel wird die Ausführung der Funktion `f_py_greater` durch Benutzer mit Berechtigungen der Gruppe „PUBLIC“ untersagt. Daraufhin wird die Nutzung der Benutzergruppe erlaubt `udf_devs`.

```
revoke execute on function f_py_greater(a float, b float) from PUBLIC;
grant execute on function f_py_greater(a float, b float) to group udf_devs;
```

Superuser haben standardmäßig alle Berechtigungen. 

Weitere Informationen erhalten Sie unter [GRANT](r_GRANT.md) und [REVOKE](r_REVOKE.md).

# Verhindern von UDF-Namenskonflikten
<a name="udf-naming-udfs"></a>

Sie können Namenskonflikte und unerwartete Ergebnisse verhindern, wenn Sie sich bei der Implementation an Namenskonventionen halten. Da Funktionsnamen überladen sein können, besteht die Möglichkeit, dass Namenskonflikte mit anderen Amazon-Redshift-Funktionen auftreten oder sich zu einem späteren Zeitpunkt ergeben können. In diesem Thema werden überladene Funktionen und eine Strategie zur Vermeidung von Namenskonflikten besprochen.

## Überladen von Funktionsnamen
<a name="udf-naming-overloading-function-names"></a>

Eine Funktion wird anhand Ihres Namens und ihrer *Signatur* identifiziert, wobei die Signatur im Wesentlichen die Anzahl und die Datentypen der Eingabeparameter ist. Solange sich zwei Funktionen in demselben Schema bezüglich ihrer Signatur unterscheiden, können sie denselben Namen haben. Mit anderen Worten, die Funktionsnamen können *überladen* sein.

Wenn Sie eine Abfrage ausführen, identifiziert die Abfrage-Engine auf der Grundlage des übergebenen Namens und der Datentypen der Parameter, welche Funktion aufgerufen werden soll. Sie können das Überladen nutzen, um Funktionen mit einer variablen Anzahl von Argumenten bis zur maximal durch den Befehl [CREATE FUNCTION](r_CREATE_FUNCTION.md) zugelassen Anzahl zu simulieren. 

## Vermeidung von Konflikten mit integrierten Amazon-Redshift-Funktionen
<a name="udf-naming-preventing-udf-naming-conflicts"></a>

Wir empfehlen, dass Sie alle UDFs mit dem Präfix benennen`f_`. Amazon Redshift reserviert das `f_` Präfix ausschließlich für UDFs und indem Sie Ihren UDF-Namen das Präfix voranstellen, stellen Sie sicher`f_`, dass Ihr UDF-Name nicht mit bestehenden oder future Namen der integrierten SQL-Funktionen von Amazon Redshift kollidiert. Wenn Sie eine neue UDF beispielsweise `f_sum` benennen, vermeiden Sie einen Konflikt mit der SUM-Funktion von Amazon Redshift. Wenn Sie eine neue Funktion mit `f_fibonacci` benennen, vermeiden Sie einen Konflikt, wenn Amazon Redshift in einer zukünftigen Version eine Funktion mit dem Namen FIBONACCI hinzufügt.

Sie können eine UDF mit demselben Namen und derselben Signatur wie eine vorhandene integrierte Amazon-Redshift-SQL-Funktion erstellen, ohne dass der Funktionsname überladen ist, wenn sich die UDF und die integrierte Funktion in verschiedenen Schemata befinden. Integrierte Funktionen befinden sich im Systemschema „pg\$1catalog“, daher können Sie UDFs mit demselben Namen wie integrierte Funktionen in einem anderen Schema erstellen, beispielsweise in einem öffentlichen oder in einem benutzerdefinierten Schema. In einigen Fällen können Sie möglicherweise eine Funktion aufrufen, die nicht explizit mit einem Schemanamen qualifiziert ist. Wenn ja, durchsucht Amazon Redshift standardmäßig zuerst das Schema pg\$1catalog. Daher läuft eine eingebaute Funktion vor einer neuen UDF mit dem gleichen Namen.

Sie können dieses Verhalten ändern, indem Sie den Suchpfad so angeben, dass „pg\$1catalog“ ans Ende gestellt ist. Wenn Sie dies tun, haben Sie UDFs Vorrang vor integrierten Funktionen, aber diese Vorgehensweise kann zu unerwarteten Ergebnissen führen. Es wird stattdessen geraten, eine Namenskonvention zu verwenden, beispielsweise das reservierte Präfix `f_`, weil diese Vorgehensweise zuverlässiger ist. Weitere Informationen erhalten Sie unter [SET](r_SET.md) und [search\$1path](r_search_path.md).

# Skalares SQL UDFs
<a name="udf-creating-a-scalar-sql-udf"></a>

Eine skalare SQL-UDF enthält eine SQL-SELECT-Klausel, die ausgeführt wird, wenn die Funktion aufgerufen wird, und einen einzelnen Wert zurückgibt. Der Befehl [CREATE FUNCTION](r_CREATE_FUNCTION.md) wird mit den folgenden Parametern aufgerufen:
+ (Optional) Eingabeparameter, Jedes Argument muss einen Datentyp aufweisen. 
+ Ein Rückgabedatentyp
+ Eine SQL-SELECT-Klausel. Nutzen Sie in Übereinstimmung mit der Reihenfolge der Argumente in der Funktionsdefinition die Elemente „\$11“, „\$12“ usw. zur Benennung der Eingabeargumente in der SELECT-Klausel. 

Ein- und Rückgabedaten können jeden standardmäßigen Amazon-Redshift-Datentyp verwenden.

Die SELECT-Klausel darf keine FROM-Klausel enthalten. Bauen Sie die FROM-Klausel stattdessen in die SQL-Anweisung ein, die die SQL-UDF aufruft. 

Die SELECT-Klausel darf keinen der folgenden Klausel-Typen enthalten:
+ FROM
+ INTO
+ WHERE
+ GROUP BY
+ ORDER BY
+ LIMIT

# Beispiel für eine skalare SQL-Funktion
<a name="udf-scalar-sql-function-example"></a>

Im folgenden Beispiel wird eine Funktion erstellt, die zwei Zahlen vergleicht und die größere zurückgibt. Weitere Informationen finden Sie unter [CREATE FUNCTION](r_CREATE_FUNCTION.md).

```
create function f_sql_greater (float, float)
  returns float
stable
as $$
  select case when $1 > $2 then $1
    else $2
  end
$$ language sql;
```

In der folgenden Abfrage wird die neue Funktion „f\$1sql\$1greater“ aufgerufen, um eine Abfrage über der Tabelle „SALES“ auszuführen und entweder „COMMISSION“ oder 20 Prozent von „PRICEPAID“ zurückzugeben, je nachdem, welcher Wert größer ist.

```
select f_sql_greater(commission, pricepaid*0.20) from sales;
```

# Skalares Python UDFs
<a name="udf-creating-a-scalar-udf"></a>

Eine skalare Python-UDF enthält ein Python-Programm, das ausgeführt wird, wenn die Funktion aufgerufen wird, und die Funktion gibt dann einen einzelnen Wert zurück. Der Befehl [CREATE FUNCTION](r_CREATE_FUNCTION.md) wird mit den folgenden Parametern aufgerufen:
+ (Optional) Eingabeparameter, jeweils mit Namen und Datentyp 
+ Ein Rückgabedatentyp
+ Ein ausführbares Python-Programm

Bei den Eingabe- und Rückgabedatentypen für Python UDFs kann es sich um einen der folgenden Typen handeln:
+  SMALLINT 
+  INTEGER 
+  BIGINT 
+  DECIMAL 
+  REAL 
+  DOUBLE PRECISION 
+  BOOLEAN 
+  CHAR 
+  VARCHAR 
+  DATE 
+  TIMESTAMP (ZEITSTEMPEL) 
+  ANYELEMENT 

Die Aliase für diese Typen sind ebenfalls gültig. Die vollständige Liste der Datentypen und ihrer Aliase finden Sie unter [Datentypen](c_Supported_data_types.md).

Wenn Python den Datentyp ANYELEMENT UDFs verwendet, konvertiert Amazon Redshift automatisch in einen Standarddatentyp, der auf den zur Laufzeit bereitgestellten Argumenten basiert. Weitere Informationen finden Sie unter [Datentyp ANYELEMENT](udf-data-types.md#udf-anyelement-data-type).

Wenn eine Amazon-Redshift-Abfrage eine skalare UDF aufruft, wird zur Laufzeit Folgendes durchgeführt.

1. Die Funktion wandelt die Eingabeparameter werden in Python-Datentypen um.

   Ein Mapping von Amazon-Redshift-Datentypen zu Python-Datentypen finden Sie in [Python-UDF-Datentypen](udf-data-types.md).

1. Die Funktion führt das Python-Programm mit den umgewandelten Eingabeparametern aus.

1. Das Python-Programm gibt einen einzelnen Wert zurück. Der Datentyp des Rückgabewerts muss dem RETURNS-Datentyp in der Funktionsdefinition entsprechen.

1. Die Funktion wandelt den Python-Rückgabewert in den angegebenen Amazon-Redshift-Datentyp um und gibt diesen Wert an die Abfrage zurück.

**Anmerkung**  
Python 3 ist für Python nicht verfügbar UDFs. Um Python 3-Unterstützung für Amazon Redshift zu erhalten UDFs, verwenden Sie [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md) stattdessen.

# Beispiel für eine skalare Python-UDF
<a name="udf-scalar-function-example"></a>

Im folgenden Beispiel wird eine Funktion erstellt, die zwei Zahlen vergleicht und die größere zurückgibt. Beachten Sie, dass es sich bei der Einrückung des Codes zwischen den doppelten Dollarzeichen (\$1\$1) um eine Python-Anforderung handelt. Weitere Informationen finden Sie unter [CREATE FUNCTION](r_CREATE_FUNCTION.md).

```
create function f_py_greater (a float, b float)
  returns float
stable
as $$
  if a > b:
    return a
  return b
$$ language plpythonu;
```

In der folgenden Abfrage wird die neue Funktion `f_greater` aufgerufen, um eine Abfrage über der Tabelle SALES auszuführen und entweder COMMISSION oder 20 Prozent von PRICEPAID zurückzugeben, je nachdem, welcher Wert größer ist.

```
select f_py_greater (commission, pricepaid*0.20) from sales;
```

# Python-UDF-Datentypen
<a name="udf-data-types"></a>

Python UDFs kann jeden standardmäßigen Amazon Redshift Redshift-Datentyp für die Eingabeargumente und den Rückgabewert der Funktion verwenden. UDFs Unterstützt zusätzlich zu den Standarddatentypen den Datentyp *ANYELEMENT*, den Amazon Redshift auf der Grundlage der zur Laufzeit bereitgestellten Argumente automatisch in einen Standarddatentyp konvertiert. Scalar UDFs kann den Datentyp ANYELEMENT zurückgeben. Weitere Informationen finden Sie unter [Datentyp ANYELEMENT](#udf-anyelement-data-type).

Während der Ausführung konvertiert Amazon Redshift die Argumente von Amazon-Redshift-Datentypen zu Python-Datentypen zur Verarbeitung. Anschließend wird der Rückgabewert vom Python-Datentyp in den entsprechenden Amazon-Redshift-Datentyp konvertiert. Weitere Informationen zu Amazon-Redshift-Datentypen finden Sie unter [Datentypen](c_Supported_data_types.md).

Die folgende Tabelle enthält eine Zuordnung von Amazon-Redshift-Datentypen und Python-Datentypen.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/udf-data-types.html)

## Datentyp ANYELEMENT
<a name="udf-anyelement-data-type"></a>

ANYELEMENT ist ein *polymorpher Datentyp*. Wenn eine Funktion unter Verwendung von ANYELEMENT für den Datentyp eines Arguments deklariert wird, kann die Funktion alle Amazon-Redshift-Standarddatentypen als Eingabe für das betreffende Argument akzeptieren, wenn die Funktion aufgerufen wird. Der ANYELEMENT-Parameter wird auf den übergebenen Datentyp gesetzt, wenn die Funktion aufgerufen wird.

Wenn eine Funktion mehrere ANYELEMENT-Datentypen verwendet, werden sie beim Funktionsaufruf alle in denselben Datentyp aufgelöst. Alle ANYELEMENT-Parameter werden auf den Datentyp gesetzt, in den der erste übergebene ANYELEMENT-Parameter aufgelöst wird. Wenn eine Funktion beispielsweise als `f_equal(anyelement, anyelement)` deklariert ist, kann sie zwei beliebige Eingabewerte entgegennehmen, solange diese vom selben Datentyp sind.

Wenn Sie eine Funktion selbst als ANYELEMENT deklarieren, muss mindestens einer der Eingabeparameter vom Typ ANYELEMENT sein. Der tatsächliche Datentyp für den Rückgabewert ist identisch mit dem tatsächlichen Datentyp, der für das ANYELEMENT-Eingabeargument bereitgestellt wird. 

# Python-Sprachunterstützung für UDFs
<a name="udf-python-language-support"></a>

Sie können auf der Basis von Python benutzerdefinierte Funktionen (UDFs, User-Defined Functions) erstellen. Die [Python 2.7-Standardbibliothek](https://docs.python.org/2/library/index.html) ist für die Verwendung in verfügbar UDFs, mit Ausnahme der folgenden Module:
+ ScrolledText
+ Tix
+ Tkinter
+ tk
+ turtle
+ smtpd

Neben der Python-Standardbibliothek sind in die Amazon-Redshift-Implementation die folgenden Module integriert:
+ [numpy 1.8.2](http://www.numpy.org/)
+ [pandas 0.14.1](https://pandas.pydata.org/)
+ [python-dateutil 2.2](https://dateutil.readthedocs.org/en/latest/)
+ [pytz 2014.7](https://pypi.org/project/pytz/2014.7/)
+ [scipy 0.12.1](https://www.scipy.org/)
+ [six 1.3.0](https://pypi.org/project/six/1.3.0/)
+ [wsgiref 0.1.2](https://pypi.python.org/pypi/wsgiref)

Sie können auch Ihre eigenen benutzerdefinierten Python-Module importieren und sie für die Verwendung in verfügbar machen, UDFs indem Sie einen [CREATE LIBRARY](r_CREATE_LIBRARY.md) Befehl ausführen. Weitere Informationen finden Sie unter [Beispiel: Importieren von benutzerdefinierten Python-Bibliotheksmodulen](udf-importing-custom-python-library-modules.md).

**Wichtig**  
Amazon Redshift blockiert den gesamten Netzwerkzugriff und Schreibzugriff auf das Dateisystem durch UDFs.

**Anmerkung**  
Python 3 ist für Python nicht verfügbar UDFs. Um Python 3-Unterstützung für Amazon Redshift zu erhalten UDFs, verwenden Sie [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md) stattdessen.

# Beispiel: Importieren von benutzerdefinierten Python-Bibliotheksmodulen
<a name="udf-importing-custom-python-library-modules"></a>

Skalare Funktionen werden entsprechend der Syntax von Python definiert. Sie können Module der Python-Standardbibliothek und vorinstallierte Amazon-Redshift-Module verwenden. Sie können auch eigene benutzerdefinierte Python-Bibliotheksmodule erstellen und zusammen mit anderen Bibliotheken von Python oder Drittanbietern in Ihre Cluster importieren. 

Die erstellten Bibliotheken dürfen jedoch nicht genau so heißen wie die integrierten Python-Standardbibliotheksmodule oder die vorinstallierten Amazon-Redshift-Python-Module. Wenn eine vorhandene, benutzerinstallierte Bibliothek dasselbe Python-Paket wie eine von Ihnen erstellte Bibliothek verwendet, müssen Sie die vorhandene Bibliothek entfernen, bevor Sie die neue Bibliothek installieren. 

Sie müssen Superuser sein oder über die Berechtigung `USAGE ON LANGUAGE plpythonu` verfügen, um benutzerdefinierte Bibliotheken installieren zu können. Die installierten Bibliotheken können anschließend von allen Benutzern mit der Berechtigung zum Erstellen von Funktionen verwendet werden. Um Informationen zu den in Ihrem Cluster installierten Bibliotheken anzuzeigen, führen Sie eine Abfrage über dem Systemkatalog [PG\$1LIBRARY](r_PG_LIBRARY.md) aus.

## So importieren Sie ein benutzerdefiniertes Python-Modul in Ihren Cluster:
<a name="udf-import-custom-python-module-procedure"></a>

Dieser Abschnitt enthält ein Beispiel zum Importieren eines benutzerdefiniertes Python-Moduls in Ihren Cluster. Für die Durchführung der Schritte in diesem Abschnitt benötigen Sie einen Amazon S3 Bucket, in den Sie das Bibliothekspaket hochladen. Dann installieren Sie das Paket in Ihrem Cluster. Weitere Informationen zum Erstellen von Buckets finden Sie unter [Erstellen von Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*.

Nehmen wir in diesem Beispiel an, Sie erstellen, UDFs um mit Positionen und Entfernungen in Ihren Daten zu arbeiten. Stellen Sie mit einem SQL-Client-Tool eine Verbindung zu Ihrem Amazon-Redshift-Cluster her und führen die folgenden Befehle aus, um die Funktionen zu erstellen. 

```
CREATE FUNCTION f_distance (x1 float, y1 float, x2 float, y2 float) RETURNS float IMMUTABLE as $$
    def distance(x1, y1, x2, y2):
        import math
        return math.sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
 
    return distance(x1, y1, x2, y2)
$$ LANGUAGE plpythonu;
 
CREATE FUNCTION f_within_range (x1 float, y1 float, x2 float, y2 float) RETURNS bool IMMUTABLE as $$ 
    def distance(x1, y1, x2, y2):
        import math
        return math.sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
 
    return distance(x1, y1, x2, y2) < 20
$$ LANGUAGE plpythonu;
```

Beachten Sie, dass in den Funktionen oben einige Codezeilen mehrmals vorkommen. Dies ist notwendig, weil UDFs nicht den Inhalt anderer UDFs referenzieren können, aber beide Funktionen dieselbe Funktionalität benötigen. Natürlich können Sie auch eine benutzerdefinierte Bibliothek mit dem mehrfach verwendeten Code erstellen und Ihre Funktionen so schrieben, dass sie diese Bibliothek verwenden. 

Dazu erstellen Sie zuerst das Bibliothekspaket, indem Sie die folgenden Schritte ausführen: 

1. Erstellen Sie einen Ordner mit dem Namen **geometry**. Dieser Ordner ist das Bibliothekspaket der obersten Ebene.

1. Erstellen Sie im Ordner **geometry** eine Datei mit dem Namen `__init__.py`. Beachten Sie, dass die Unterstriche in dem Dateinamen jeweils doppelte Unterstriche sind. Diese Datei weist Python darauf hin, dass das Paket initialisiert werden kann.

1. Erstellen Sie im Ordner **geometry** außerdem einen Ordner mit dem Namen **trig**. Dieser Ordner ist das Unterpaket der Bibliothek.

1. Erstellen Sie im Ordner **trig** eine Datei mit dem Namen `__init__.py` und eine Datei mit dem Namen `line.py`. Mit der Datei `__init__.py` wird Python wieder darauf hingewiesen, dass das Unterpaket initialisiert werden kann, und dass die Datei `line.py` den Bibliothekscode enthält.

   Ihr Ordner sollte nun eine Dateistruktur wie folgt enthalten: 

   ```
   geometry/
      __init__.py
      trig/
         __init__.py
         line.py
   ```

    Weitere Informationen über die Struktur von Paketen finden Sie unter [Modules](https://docs.python.org/2/tutorial/modules.html) im Python-Tutorial auf der Python-Website. 

1.  Der folgende Quellcode enthält eine Klasse und zugehörige Mitgliedsfunktionen für die Bibliothek. Kopieren Sie den Code und fügen Sie ihn in ein `line.py`. 

   ```
   class LineSegment:
     def __init__(self, x1, y1, x2, y2):
       self.x1 = x1
       self.y1 = y1
       self.x2 = x2
       self.y2 = y2
     def angle(self):
       import math
       return math.atan2(self.y2 - self.y1, self.x2 - self.x1)
     def distance(self):
       import math
       return math.sqrt((self.y2 - self.y1) ** 2 + (self.x2 - self.x1) ** 2)
   ```

 Nachdem Sie das Paket erstellt haben, gehen Sie wie folgt vor, um das Paket vorzubereiten und in Amazon S3 hochzuladen. 

1. Komprimieren Sie den Inhalt des Ordners **geometry** in einer ZIP-Datei mit dem Namen **geometry.zip**. Der Ordner **geometry** selbst darf nicht in der ZIP-Datei enthalten sein, sondern nur der Inhalt des Ordners wie im Folgenden gezeigt: 

   ```
   geometry.zip
      __init__.py
      trig/
         __init__.py
         line.py
   ```

1. Laden Sie **geometry.zip** in Ihren Amazon S3 Bucket hoch.
**Wichtig**  
 Wenn sich der Amazon-S3-Bucket nicht in derselben Region wie Ihr Amazon-Redshift-Cluster befindet, müssen Sie die Option REGION verwenden, um die Region anzugeben, in der sich die Daten befinden. Weitere Informationen finden Sie unter [CREATE LIBRARY](r_CREATE_LIBRARY.md).

1.  Führen Sie in Ihrem SQL-Client-Tool den folgenden Befehl aus, um die Bibliothek zu installieren. *<bucket\$1name>*Ersetzen Sie es durch den Namen Ihres Buckets und ersetzen Sie *<access key id>* und *<secret key>* durch einen Zugriffsschlüssel und einen geheimen Zugriffsschlüssel aus Ihren AWS Identity and Access Management (IAM-) Benutzeranmeldedaten. 

   ```
   CREATE LIBRARY geometry LANGUAGE plpythonu FROM 's3://<bucket_name>/geometry.zip' CREDENTIALS 'aws_access_key_id=<access key id>;aws_secret_access_key=<secret key>';
   ```

 Nach der Installation der Bibliothek in Ihrem Cluster müssen Sie die Funktionen so konfigurieren, dass sie die Bibliothek verwenden. Führen Sie dazu die folgenden Befehle aus. 

```
CREATE OR REPLACE FUNCTION f_distance (x1 float, y1 float, x2 float, y2 float) RETURNS float IMMUTABLE as $$ 
    from trig.line import LineSegment
 
    return LineSegment(x1, y1, x2, y2).distance()
$$ LANGUAGE plpythonu;
 
CREATE OR REPLACE FUNCTION f_within_range (x1 float, y1 float, x2 float, y2 float) RETURNS bool IMMUTABLE as $$ 
    from trig.line import LineSegment
 
    return LineSegment(x1, y1, x2, y2).distance() < 20
$$ LANGUAGE plpythonu;
```

In den Befehlen oben können durch die Anweisung `import trig/line` die doppelten Vorkommen des Codes wie in der ersten Version dieser Funktionen am Anfang dieses Abschnitts vermieden werden. Sie können die von dieser Bibliothek bereitgestellten Funktionen mehrfach UDFs wiederverwenden. Beachten Sie, dass Sie beim Importieren des Moduls lediglich den Pfad zu dem Unterpaket und den Modulnamen angeben (`trig/line`). 

# Einschränkungen für Python-UDFs
<a name="udf-constraints"></a>

Innerhalb der in diesem Thema aufgeführten Einschränkungen können Sie die integrierten Skalarfunktionen von Amazon Redshift UDFs überall verwenden. Weitere Informationen finden Sie unter [SQL-Funktionsreferenz](c_SQL_functions.md).

Amazon Redshift Python UDFs hat die folgenden Einschränkungen:
+ Python UDFs kann nicht auf das Netzwerk zugreifen oder in das Dateisystem lesen oder schreiben.
+ Die Gesamtgröße von Python-Bibliotheken, die von Benutzern installiert werden, darf 100 MB nicht überschreiten.
+ Amazon Redshift kann jeweils nur eine Python-UDF für bereitgestellte Cluster mit automatischem Workload-Management (WLM) und für Serverless-Arbeitsgruppen ausführen. Wenn Sie versuchen, mehr als eine UDF gleichzeitig auszuführen, stellt Amazon Redshift das verbleibende Python UDFs zur Ausführung in die Warteschlangen für die Arbeitslastverwaltung. SQL hat UDFs kein Parallelitätslimit, wenn automatisches WLM verwendet wird. 
+  Bei der Verwendung von manuellem WLM für bereitgestellte Cluster ist die Anzahl von Python, UDFs die pro Cluster gleichzeitig ausgeführt werden können, auf ein Viertel der gesamten Parallelitätsstufe des Clusters begrenzt. Beispielsweise kann ein bereitgestellter Cluster mit einer Parallelität von 15 maximal drei Python gleichzeitig ausführen. UDFs 
+ Bei Verwendung von Python UDFs unterstützt Amazon Redshift die Datentypen SUPER und HLLSKETCH nicht.

# Fehler und Warnungen in Python protokollieren UDFs
<a name="udf-logging-messages"></a>

Sie können das Python-Logging-Modul verwenden, um benutzerdefinierte Fehler- und Warnmeldungen in Ihrem UDFs zu erstellen. Nach der Abfrageausführung können Sie die Systemansicht [SVL\$1UDF\$1LOG](r_SVL_UDF_LOG.md) abfragen, um protokollierte Meldungen abzurufen.

**Anmerkung**  
Beachten Sie, dass die Protokollierung von UDFs Clusterressourcen verbraucht und die Systemleistung beeinträchtigen kann. Wir empfehlen, die Protokollierung nur in der Entwicklung und zur Problembehandlung zu implementieren. 

Wenn eine Abfrage ausgeführt wird, schreibt der Protokollhandler Meldungen in die Systemansicht SVL\$1UDF\$1LOG, jeweils mit dem betreffenden Funktionsnamen, dem Knoten und der Slice. Der Protokollhandler schreibt jeweils pro Meldung und Slice eine Zeile in SVL\$1UDF\$1LOG. Meldungen werden jeweils auf eine maximale Länge von 4096 Bytes gekürzt. Das UDF-Protokoll ist auf 500 Zeilen pro Slice begrenzt. Wenn das Protokoll voll ist, werden alte Meldungen gelöscht und eine entsprechende Warnmeldung in SVL\$1UDF\$1LOG hinzugefügt.

**Anmerkung**  
Der Amazon-Redshift-UDF-Protokollhandler kodiert Zeilenenden ( `\n` ), Pipe-Zeichen ( `|` ) und umgekehrte Schrägstriche ( `\` ) mit einem umgekehrten Schrägstrich ( `\` ).

Standardmäßig ist die Protokollierungsstufe für UDFs auf WARNING festgelegt. Dies bedeutet, dass Meldungen mit den Protokollierungsstufen WARNING, ERROR und CRITICAL protokolliert werden. Meldungen mit geringerem Schweregrad wie INFO, DEBUG und NOTSET werden ignoriert. Sie können die Protokollierungsstufe für UDF mittels der Python-Methode „logger“ einstellen. Mit dem folgenden Aufruf können Sie beispielsweise die Protokollierungsstufe auf INFO festlegen.

```
logger.setLevel(logging.INFO)
```

Weitere Informationen zur Verwendung des Python-Protokollierungsmoduls finden unter [Logging facility for Python](https://docs.python.org/2.7/library/logging.html) in der Python-Dokumentation.

In dem folgenden Beispiel wird eine Funktion namens „f\$1pyerror“ erstellt, die das Python-Modul zur Protokollierung importiert, das „logger“-Objekt instanziiert und einen Fehler protokolliert.

```
CREATE OR REPLACE FUNCTION f_pyerror() 
RETURNS INTEGER
VOLATILE AS
$$
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)
logger.info('Your info message here') 
return 0
$$ language plpythonu;
```

Das folgende Beispiel ist eine SVL\$1UDF\$1LOG-Abfrage zur Anzeige der in dem vorangehenden Beispiel protokollierten Meldung.

```
select funcname, node, slice, trim(message) as message 
from svl_udf_log;

  funcname  | query | node | slice |   message  
------------+-------+------+-------+------------------
  f_pyerror | 12345 |     1|     1 | Your info message here
```

# Skalares Lambda UDFs
<a name="udf-creating-a-lambda-sql-udf"></a>

Amazon Redshift kann benutzerdefinierte Funktionen verwenden, die AWS Lambda als Teil von SQL-Abfragen definiert sind. Sie können skalares Lambda UDFs in allen von Lambda unterstützten Programmiersprachen wie Java, Go, Node.js, C\$1 PowerShell, Python und Ruby schreiben. Sie können auch eine benutzerdefinierte Laufzeit verwenden.

Der Befehl [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md) erstellt die folgenden Parameter:
+ (Optional) Eine Liste von Argumenten mit Datentyp. 
+ Ein Rückgabedatentyp
+ Ein Funktionsname der externen Funktion, die von Amazon Redshift aufgerufen wird. 
+ Eine IAM-Rolle, die der Amazon-Redshift-Cluster übernehmen und Lambda aufrufen darf.
+ Ein Lambda-Funktionsname, den die Lambda-UDF aufruft.

Weitere Hinweise zu CREATE EXTERNAL FUNCTION finden Sie unter [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md).

Bei den Eingabe- und Rückgabedatentypen für Lambda UDFs kann es sich um einen der folgenden Typen handeln:
+  SMALLINT 
+  INTEGER 
+  BIGINT 
+  DECIMAL 
+  REAL 
+  DOUBLE PRECISION 
+  CHAR 
+  VARCHAR 
+  BOOLEAN 
+  DATE 
+  TIMESTAMP (ZEITSTEMPEL) 

Die Aliase für diese Typen sind ebenfalls gültig. Die vollständige Liste der Datentypen und ihrer Aliase finden Sie unter [Datentypen](c_Supported_data_types.md).

Amazon Redshift stellt sicher, dass die externe Funktion Batch-Argumente und -Ergebnisse senden und empfangen kann. 

Lambda UDFs wird in Lambda definiert und verwaltet, und Sie können die Zugriffsrechte steuern, um diese UDFs in Amazon Redshift aufzurufen. Sie können mehrere Lambda-Funktionen in derselben Abfrage aufrufen oder die gleiche Funktion mehrmals aufrufen.

Verwenden Sie Lambda UDFs in allen Klauseln der SQL-Anweisungen, in denen Skalarfunktionen unterstützt werden. Sie können Lambda auch UDFs in jeder SQL-Anweisung wie SELECT, UPDATE, INSERT oder DELETE verwenden. 

**Anmerkung**  
Für die Nutzung von Lambda UDFs können zusätzliche Gebühren durch den Lambda-Service anfallen. Ob dies geschieht, hängt von Faktoren wie der Anzahl der Lambda-Anforderungen (UDF-Aufrufe) und der Gesamtdauer der Lambda-Programmausführung ab. Für die Verwendung von Lambda UDFs in Amazon Redshift fallen jedoch keine zusätzlichen Gebühren an. Informationen zu den AWS Lambda-Preisen finden Sie unter [AWS Lambda Preise](https://aws.amazon.com/lambda/pricing).  
Die Anzahl der Lambda-Anforderungen hängt von der spezifischen SQL-Anweisungsklausel ab, in der die Lambda-UDF verwendet wird. Angenommen, die Funktion wird in einer WHERE-Klausel wie der folgenden verwendet. ``  
`SELECT a, b FROM t1 WHERE lambda_multiply(a, b) = 64; SELECT a, b FROM t1 WHERE a*b = lambda_multiply(2, 32) `  
In diesem Fall ruft Amazon Redshift die erste SELECT-Anweisung für jede und ruft die zweite SELECT-Anweisung nur einmal auf.  
Wenn Sie jedoch ein UDF im Projektionsteil der Abfrage verwenden, wird die Lambda-Funktion möglicherweise nur einmal für jede qualifizierte oder aggregierte Zeile in der Ergebnismenge aufgerufen. 

## UDF-Sicherheit und -Berechtigungen
<a name="udf-lambda-security"></a>

Um eine Lambda-UDF zu erstellen, stellen Sie sicher, dass Sie über Berechtigungen für die Verwendung auf LANGUAGE EXFUNC verfügen. Sie müssen USAGE ON LANGUAGE EXFUNC explizit gewähren oder USAGE ON LANGUAGE EXFUNC für bestimmte Benutzer, Gruppen oder öffentliche Benutzer widerrufen.

Im folgenden Beispiel wird PUBLIC die Verwendung auf EXFUNC gewährt.

```
grant usage on language exfunc to PUBLIC; 
```

Im folgenden Beispiel wird die Verwendung auf exfunc von PUBLIC widerrufen. Anschließend wird die Nutzung der Benutzergruppe lambda\$1udf\$1devs erlaubt.

```
revoke usage on language exfunc from PUBLIC;
grant usage on language exfunc to group lambda_udf_devs;
```

Stellen Sie zum Ausführen einer Lambda-UDF sicher, dass Sie die Berechtigung für jede aufgerufene Funktion haben. Standardmäßig wird PUBLIC die Erlaubnis erteilt, neues Lambda UDFs auszuführen. Um die Nutzung einzuschränken, widerrufen Sie diese Berechtigung für die Funktion von PUBLIC. Gewähren Sie die Berechtigung anschließend den spezifischen Benutzern oder Gruppen.

Beim folgenden Beispiel wird die Ausführung der Funktion exfunc\$1sum durch Benutzer mit Berechtigungen der Gruppe PUBLIC untersagt. Daraufhin wird die Nutzung der Benutzergruppe lambda\$1udf\$1devs erlaubt.

```
revoke execute on function exfunc_sum(int, int) from PUBLIC;
grant execute on function exfunc_sum(int, int) to group lambda_udf_devs;
```

Superuser haben standardmäßig alle Berechtigungen.

Weitere Informationen zum Erteilen und Widerrufen von Berechtigungen finden Sie unter [GRANT](r_GRANT.md) und [REVOKE](r_REVOKE.md).

## Konfiguration des Autorisierungsparameters für Lambda UDFs
<a name="udf-lambda-authorization"></a>

Der Befehl CREATE EXTERNAL FUNCTION erfordert die Autorisierung, Lambda-Funktionen in AWS Lambda aufzurufen. Um die Autorisierung zu starten, geben Sie eine AWS Identity and Access Management (IAM-) Rolle an, wenn Sie den Befehl CREATE EXTERNAL FUNCTION ausführen. Weitere Informationen zu IAM-Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles.html) im *IAM-Benutzerhandbuch*.

Wenn bereits eine IAM-Rolle mit Berechtigungen zum Aufrufen von Lambda-Funktionen vorhanden ist, können Sie den Befehl durch Ihre Rolle Amazon-Ressourcenname (ARN) im Parameter IAM\$1ROLE ersetzen. Die folgenden Abschnitte beschreiben die Schritte zur Verwendung einer IAM-Rolle im Befehl CREATE EXTERNAL FUNCTION.

### Erstellen einer IAM-Rolle für Lambda
<a name="udf-lambda-create-iam"></a>

Die IAM-Rolle erfordert die Berechtigung zum Aufrufen von Lambda-Funktionen. Geben Sie beim Erstellen der IAM-Rolle die Berechtigung auf eine der folgenden Arten an:
+ Fügen Sie die `AWSLambdaRole`-Richtlinie auf der Seite **Berechtigungsrichtlinie anfügen** an, während Sie eine IAM-Rolle erstellen. Die`AWSLambdaRole`-Richtlinie erteilt Berechtigungen zum Aufrufen von Lambda-Funktionen, was die minimale Anforderung ist. Weitere Informationen und andere Richtlinien finden Sie unter [Identitätsbasierte IAM-Richtlinien für AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html) im *AWS Lambda -Entwicklerhandbuch*.
+ Erstellen Sie Ihre eigene benutzerdefinierte Richtlinie, die Sie Ihrer IAM-Rolle mit der `lambda:InvokeFunction`-Berechtigung entweder für alle Ressourcen oder eine bestimmten Lambda-Funktion mit dem ARN dieser Funktion anfügen. Weitere Informationen zum Erstellen von Richtlinien finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.

  Die folgende Beispielrichtlinie ermöglicht das Aufrufen von Lambda für eine bestimmte Lambda-Funktion.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "Invoke",
              "Effect": "Allow",
              "Action": [
                  "lambda:InvokeFunction"
              ],
              "Resource": "arn:aws:lambda:us-west-2:123456789012:function:my-function"
          }
      ]
  }
  ```

------

  Weitere Informationen zu Ressourcen für Lambda Funktionen finden Sie unter [Ressourcen und Bedingungen für Lambda-Aktionen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html) in der *IAM-API-Referenz*.

  Nachdem Sie Ihre benutzerdefinierte Richtlinie mit den erforderlichen Berechtigungen erstellt haben, können Sie Ihre Richtlinie der IAM-Rolle auf der Registerkarte **Berechtigungsrichtlinie anfügen** anfügen, während Sie eine IAM-Rolle erstellen.

Schritte zum Erstellen einer IAM-Rolle finden Sie unter [Autorisieren von Amazon Redshift für den Zugriff auf andere AWS Services in Ihrem Namen im](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) *Amazon Redshift* Management Guide.

Wenn Sie keine neue IAM-Rolle erstellen möchten, können Sie die zuvor genannten Berechtigungen zu Ihrer vorhandenen IAM-Rolle hinzufügen.

### Zuweisen einer IAM-Rolle zum Cluster
<a name="udf-lambda-associate-iam"></a>

Fügen Sie die IAM-Rolle an Ihren Cluster an. Sie können über die Amazon-Redshift-Managementkonsole, die CLI oder eine API einem Cluster eine Rolle hinzufügen oder die Rollen anzeigen, die mit einem Cluster verknüpft sind. Weitere Informationen finden Sie unter [Verknüpfen einer IAM-Rolle mit einem Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) im *Amazon-Redshift-Verwaltungshandbuch*.

### Einschließen der IAM-Rolle in den Befehl
<a name="udf-lambda-include-iam"></a>

Schließen Sie die IAM-Rolle ARN in den Befehl CREATE EXTERNAL FUNCTION ein. Beim Erstellen einer IAM-Rolle gibt IAM einen Amazon-Ressourcennamen (ARN) für die Rolle zurück. Um eine IAM-Rolle anzugeben, geben Sie für den ARN der Rolle den Parameter `IAM_ROLE` an. Im Folgenden wird die Syntax für den Parameter `IAM_ROLE` gezeigt.

```
IAM_ROLE 'arn:aws:iam::aws-account-id:role/role-name'
```

Informationen zum Aufrufen von Lambda-Funktionen, die sich in anderen Konten innerhalb derselben Region befinden, finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles.html).

## Verwendung der JSON-Schnittstelle zwischen Amazon Redshift und AWS Lambda
<a name="udf-lambda-json"></a>

Amazon Redshift verwendet eine gemeinsame Schnittstelle für alle Lambda-Funktionen, mit denen Amazon Redshift kommuniziert.

Die folgende Tabelle zeigt die Liste der Eingabefelder, die die designierten Lambda-Funktionen für die JSON-Payload erwarten können.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/udf-creating-a-lambda-sql-udf.html)

Die Reihenfolge des JSON-Arrays bestimmt die Reihenfolge der Batch-Verarbeitung. Die Lambda Funktion muss die Argumente iterativ wiederholen und die genaue Anzahl von Datensätzen erzeugen. Im Folgenden sehen Sie ein Beispiel für eine Nutzlast. 

```
{
  "request_id" : "23FF1F97-F28A-44AA-AB67-266ED976BF40",
  "cluster" : "arn:aws:redshift:xxxx",
  "user" : "adminuser",
  "database" : "db1",
  "external_function": "public.foo",
  "query_id" : 5678234,
  "num_records" : 4,
  "arguments" : [
     [ 1, 2 ],
     [ 3, null],
     null,
     [ 4, 6]
   ]
 }
```

Die Ausgabe der Lambda-Funktion sollte folgende Felder umfassen.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/udf-creating-a-lambda-sql-udf.html)

Im Folgenden sehen Sie ein Beispiel für die Ausgabe der Lambda-Funktion.

```
{
  "success": true,   // true indicates the call succeeded
  "error_msg" : "my function isn't working",  // shall only exist when success != true
  "num_records": 4,      // number of records in this payload
  "results" : [
     1,
     4,
     null,
     7
   ]
}
```

Wenn Sie Lambda-Funktionen aus SQL-Abfragen aufrufen, stellt Amazon Redshift die Sicherheit der Verbindung mit den folgenden Überlegungen sicher:
+ GRANT- und REVOKE-Berechtigungen. Weitere Informationen zu UDF-Sicherheit und -Berechtigungen finden Sie in [UDF-Sicherheit und -Berechtigungen](udf-security-and-privileges.md).
+ Amazon Redshift sendet nur den Mindestdatensatz an die dafür vorgesehene Lambda-Funktion.
+ Amazon Redshift ruft nur die designierte Lambda-Funktion mit der angegebenen IAM-Rolle auf.

# Anwendungsbeispiele für benutzerdefinierte Funktionen () UDFs
<a name="udf-example-uses"></a>

**Anmerkung**  
Ab dem 1. November 2025 unterstützt Amazon Redshift die Erstellung von neuem Python UDFs nicht mehr. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Ab dem 1. Juli 2026 wird Amazon Redshift Python nicht mehr unterstützen. UDFs Wir empfehlen, dass Sie Ihr vorhandenes Python UDFs vor dem 1. November 2025 UDFs auf Lambda migrieren. Informationen zur Erstellung und Verwendung von Lambda finden Sie UDFs unter[Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md). Informationen zur Konvertierung von vorhandenem Python UDFs nach Lambda UDFs finden Sie im [Blogbeitrag](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).

Sie können benutzerdefinierte Funktionen verwenden, um Geschäftsprobleme zu lösen, indem Sie Amazon Redshift mit anderen Komponenten integrieren. Im Folgenden finden Sie einige Beispiele dafür, wie andere Benutzer sie UDFs für ihre Anwendungsfälle verwendet haben: 
+ [Zugreifen auf externe Komponenten mit Amazon Redshift Lambda UDFs](https://aws.amazon.com/blogs/big-data/accessing-external-components-using-amazon-redshift-lambda-udfs/) — beschreibt, wie Amazon Redshift Lambda UDFs funktioniert, und führt die Erstellung einer Lambda-UDF durch.
+ [Übersetzen und analysieren Sie Text mithilfe von SQL-Funktionen mit Amazon Redshift, Amazon Translate und Amazon Comprehend](https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-redshift-amazon-translate-and-amazon-comprehend/) — bietet vorkonfiguriertes Amazon Redshift Lambda UDFs , das Sie mit wenigen Klicks installieren können, um Textfelder zu übersetzen, zu redigieren und zu analysieren.
+ [Zugriff auf Amazon Location Service von Amazon Redshift aus](https://aws.amazon.com/blogs/big-data/access-amazon-location-service-from-amazon-redshift/) — beschreibt, wie Amazon Redshift Lambda UDFs für die Integration mit Amazon Location Service verwendet wird.
+ [Daten-Tokenisierung mit Amazon Redshift und Protegrity](https://aws.amazon.com/blogs/apn/data-tokenization-with-amazon-redshift-and-protegrity/) — beschreibt, wie Amazon Redshift UDFs Lambda in das Protegrity Serverless-Produkt integriert wird.
+ [Amazon Redshift UDFs](https://github.com/aws-samples/amazon-redshift-udfs) — eine Sammlung von Amazon Redshift SQL, Lambda und Python. UDFs