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.

# Arbeiten mit Prozeduren von Babelfish für Aurora PostgreSQL
<a name="Appendix.Babelfish.Functions"></a>

## Übersicht
<a name="Appendix.Babelfish.Functions.Overview"></a>

Sie können das folgende Verfahren für DB-Instances von Amazon RDS verwenden, auf denen Babelfish für Aurora PostgreSQL ausgeführt wird, um eine bessere Abfrageleistung zu erzielen:
+ [sp\$1babelfish\$1volatility](sp_babelfish_volatility.md)
+ [sp\$1execute\$1postgresql](sp_execute_postgresql.md)

# sp\$1babelfish\$1volatility
<a name="sp_babelfish_volatility"></a>

Die Volatilität von PostgreSQL-Funktionen hilft dem Optimierer bei der Ausführung von Abfragen. Dies hat bei Verwendung in bestimmten Klauseln erhebliche Auswirkungen auf die Abfrageleistung. 

## Syntax
<a name="sp_babelfish_volatility-syntax"></a>

 

```
sp_babelfish_volatility ‘function_name’, ‘volatility’
```

## Argumente
<a name="sp_babelfish_volatility-arguments"></a>

 *function\$1name (optional)*   
Sie können den Wert dieses Arguments entweder mit einem zweiteiligen Namen wie `schema_name.function_name` oder nur mit `function_name` angeben. Wenn Sie nur `function_name` angeben, ist der Schemaname das Standardschema für den aktuellen Benutzer.

 *volatility (optional)*   
Die gültigen PostgreSQL-Werte für die Volatilität sind `stable`, `volatile` oder `immutable`. Weitere Informationen finden Sie unter [https://www.postgresql.org/docs/current/xfunc-volatility.html](https://www.postgresql.org/docs/current/xfunc-volatility.html).

**Anmerkung**  
Wenn `sp_babelfish_volatility` mit `function_name` aufgerufen wird und dieser mehrere Definitionen hat, wird ein Fehler ausgegeben.

## Ergebnismenge
<a name="sp_babelfish_volatility-return-type"></a>

Wenn die Parameter nicht angegeben werden, wird die Ergebnismenge unter den folgenden Spalten angezeigt: `schemaname`, `functionname`, `volatility`.

## Nutzungshinweise
<a name="sp_babelfish_volatility-usage-notes"></a>

Die Volatilität von PostgreSQL-Funktionen hilft dem Optimierer bei der Ausführung von Abfragen. Dies hat bei Verwendung in bestimmten Klauseln erhebliche Auswirkungen auf die Abfrageleistung. 

## Beispiele
<a name="sp_babelfish_volatility-examples"></a>

Die folgenden Beispielen veranschaulichen das Erstellen einfacher Funktionen und die Anwendung von `sp_babelfish_volatility` auf diese Funktionen mit verschiedenen Methoden.

```
1> create function f1() returns int as begin return 0 end
2> go
```

```
1> create schema test_schema
2> go
```

```
1> create function test_schema.f1() returns int as begin return 0 end
2> go
```

Das folgende Beispiel zeigt die Volatilität der Funktionen:

```
1> exec sp_babelfish_volatility
2> go
            
schemaname  functionname volatility
----------- ------------ ----------
dbo         f1           volatile
test_schema f1           volatile
```

Das folgende Beispiel zeigt, wie Sie die Volatilität der Funktionen ändern können:

```
1> exec sp_babelfish_volatility 'f1','stable'
2> go
1> exec sp_babelfish_volatility 'test_schema.f1','immutable'
2> go
```

Wenn Sie nur function\$1name angeben, werden der Schemaname, der Funktionsname und die Volatilität dieser Funktion angezeigt. Das folgende Beispiel zeigt die Volatilität der Funktionen nach Änderung der Werte:

```
1> exec sp_babelfish_volatility 'test_schema.f1'
2> go
            
schemaname  functionname volatility
----------- ------------ ----------
test_schema f1           immutable
```

```
1> exec sp_babelfish_volatility 'f1'
2> go
            
schemaname  functionname volatility
----------- ------------ ----------
dbo         f1           stable
```

Wenn Sie kein Argument angeben, wird eine Liste der Funktionen (Schemaname, Funktionsname, Volatilität der Funktionen) angezeigt, die in der aktuellen Datenbank vorhanden sind:

```
1> exec sp_babelfish_volatility 
2> go
            
schemaname  functionname volatility
----------- ------------ ----------
dbo         f1           stable
test_schema f1           immutable
```

# sp\$1execute\$1postgresql
<a name="sp_execute_postgresql"></a>

Sie können PostgreSQL-Anweisungen vom T-SQL-Endpunkt aus ausführen. Dies vereinfacht Ihre Anwendungen, da Sie den T-SQL-Port nicht verlassen müssen, um diese Anweisungen auszuführen. 

## Syntax
<a name="sp_execute_postgresql-syntax"></a>

 

```
sp_execute_postgresql [ @stmt = ] statement
```

## Argumente
<a name="sp_execute_postgresql-arguments"></a>

 *[ @stmt ]-Anweisung*   
Das Argument hat den Datentyp „varchar“. Dieses Argument akzeptiert Anweisungen im PG-Dialekt.

**Anmerkung**  
Sie können nur eine Anweisung im PG-Dialekt als Argument übergeben, andernfalls wird der folgende Fehler ausgelöst.

```
1>exec sp_execute_postgresql 'create extension pg_stat_statements; drop extension pg_stat_statements'
2>go
```

```
Msg 33557097, Level 16, State 1, Server BABELFISH, Line 1
expected 1 statement but got 2 statements after parsing
```

## Nutzungshinweise
<a name="sp_execute_postgresql-statements"></a>

### CREATE EXTENSION
<a name="sp_execute_postgresql-statements-create"></a>

Erstellt eine neue Erweiterung und lädt diese in die aktuelle Datenbank. 

```
1>EXEC sp_execute_postgresql 'create extension [ IF NOT EXISTS ] <extension name> [ WITH ] [SCHEMA schema_name] [VERSION version]';
2>go
```

Im folgenden Beispiel sehen Sie, wie eine Erweiterung erstellt wird:

```
1>EXEC sp_execute_postgresql 'create extension pg_stat_statements with schema sys version "1.10"';
2>go
```

Verwenden Sie den folgenden Befehl für den Zugriff auf Erweiterungsobjekte:

```
1>select * from pg_stat_statements;
2>go
```

**Anmerkung**  
 Wenn der Schemaname bei der Erstellung der Erweiterung nicht explizit angegeben wird, werden die Erweiterungen standardmäßig im öffentlichen Schema installiert. Sie müssen den Schemaqualifizierer angeben, um auf die Erweiterungsobjekte zuzugreifen, wie unten dargestellt:

```
1>select * from [public].pg_stat_statements;
2>go
```

**Unterstützte Erweiterungen**

Die folgenden mit Aurora PostgreSQL verfügbaren Erweiterungen können mit Babelfish verwendet werden.
+ `pg_stat_statements`
+ `tds_fdw`
+ `fuzzystrmatch`

**Einschränkungen**
+ Benutzer müssen in T-SQL über die Rolle „sysadmin“ und in Postgres über die Rolle „rds\$1superuser“ verfügen, um die Erweiterungen installieren zu können.
+ Es ist nicht möglich, Erweiterungen in vom Benutzer erstellten Schemas sowie in dbo- und Gastschemas für die Masterdatenbank, die Datenbank „tempdb“ und die Datenbank „msdb“ zu installieren. 
+ Die Option CASCADE wird nicht unterstützt.

## ALTER EXTENSION
<a name="sp_execute_postgresql-alter"></a>

Mit ALTER EXTENSION können Sie eine Aktualisierung auf eine neue Erweiterungsversion vornehmen. 

```
1>EXEC sp_execute_postgresql 'alter extension <extension name> UPDATE TO <new_version>';
2>go
```

**Einschränkungen**
+ Sie können die Version Ihrer Erweiterung nur mit der Anweisung ALTER EXTENSION aktualisieren. Andere Operationen werden nicht unterstützt.

## DROP EXTENSION
<a name="sp_execute_postgresql-drop"></a>

Löscht die angegebene Erweiterung. Sie können auch die Optionen `if exists` oder `restrict` verwenden, um die Erweiterung zu löschen. 

```
1>EXEC sp_execute_postgresql 'drop extension <extension name>';
2>go
```

**Einschränkungen**
+ Die Option CASCADE wird nicht unterstützt.