

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.

# Einen externen Hive-Metastore verwenden
<a name="connect-to-data-source-hive"></a>

Sie können den Amazon-Athena-Daten-Connector für den externen Hive-Metastore verwenden, um Datensätze in Amazon S3 abzufragen in denen ein Apache-Hive-Metastore verwendet wird. Eine Migration von Metadaten zum AWS Glue Data Catalog ist nicht erforderlich. In der Athena-Verwaltungskonsole konfigurieren Sie eine Lambda-Funktion für die Kommunikation mit dem Hive-Metastore in Ihrer privaten VPC und verbinden sie dann mit dem Metastore. Die Verbindung von Lambda zu Ihrem Hive-Metastore wird durch einen privaten Amazon-VPC-Kanal gesichert und nutzt nicht das öffentliche Internet. Sie können Ihren eigenen Lambda-Funktionscode angeben oder die Standardimplementierung des Athena-Daten-Connectors für externen Hive-Metastore verwenden.

**Topics**
+ [Übersicht über die Funktionen](#connect-to-a-data-source-hive-features)
+ [Workflow](#connect-to-data-source-hive-workflow)
+ [Überlegungen und Einschränkungen](#connect-to-a-data-source-hive-considerations)
+ [Verbinden Sie Athena zu einem Apache Hive-Metastore](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md)
+ [Verwenden Sie den AWS Serverless Application Repository , um einen Hive-Datenquellenconnector bereitzustellen](connect-data-source-sar-hive.md)
+ [Athena mit einem Hive-Metastore mithilfe einer vorhandenen IAM-Ausführungsrolle verbinden](connect-data-source-hive-existing-iam-role.md)
+ [Konfigurieren Sie Athena für die Verwendung eines bereitgestellten Hive-Metastore-Connectors](connect-data-source-hive-existing-lambda.md)
+ [Den Katalognamen in externen Hive-Metastore-Abfragen weglassen](datastores-hive-default-catalog.md)
+ [Arbeiten mit Hive-Ansichten](hive-views.md)
+ [Verwenden Sie die AWS CLI mit Hive-Metastoren](datastores-hive-cli.md)
+ [Den externen Hive-Metastore-Konnektor von Athena ändern](datastores-hive-reference-implementation.md)

## Übersicht über die Funktionen
<a name="connect-to-a-data-source-hive-features"></a>

Mit dem Athena-Daten-Connector für den externen Hive-Metastore können Sie die folgenden Aufgaben ausführen:
+ Verwenden Sie die Athena-Konsole, um benutzerdefinierte Kataloge zu registrieren und Abfragen damit auszuführen.
+ Definieren Sie Lambda-Funktionen für verschiedene externe Hive-Metastores und verbinden Sie sie in Athena-Abfragen.
+ Verwenden Sie die AWS Glue Data Catalog und Ihre externen Hive-Metastore in derselben Athena-Abfrage.
+ Geben Sie einen Katalog im Kontext der Abfrageausführung als aktuellen Standardkatalog an. Dadurch entfällt die Notwendigkeit, Datenbanknamen in Ihren Abfragen Katalognamen voranzustellen. Anstatt die Syntax `catalog.database.table` zu verwenden, können Sie `database.table` verwenden.
+ Verwenden Sie eine Vielzahl von Tools, um Abfragen auszuführen, die auf externe Hive-Metastores verweisen. Sie können die Athena-Konsole, das AWS CLI AWS SDK, Athena und die aktualisierten Athena APIs JDBC- und ODBC-Treiber verwenden. Die aktualisierten Treiber unterstützen benutzerdefinierte Kataloge.

### API-Unterstützung
<a name="connect-to-a-data-source-hive-features-api"></a>

Der Athena-Daten-Connector für den externen Hive-Metastore bietet Unterstützung für Katalogregistrierungs-API-Operationen und Metadaten-API-Operationen.
+ **Katalogregistrierung** – Registrieren Sie benutzerdefinierte Kataloge für externe Hive-Metastores und [Verbunddatenquellen](federated-queries.md). 
+ **Metadaten** — Verwenden Sie Metadaten APIs , um Datenbank- und Tabelleninformationen für AWS Glue alle Kataloge bereitzustellen, die Sie bei Athena registrieren.
+ **Athena JAVA SDK-Client** — Verwenden Sie die Katalogregistrierung APIs APIs, Metadaten und Unterstützung für Kataloge beim `StartQueryExecution` Betrieb im aktualisierten Athena Java SDK-Client.

### Referenz-Implementierung
<a name="connect-to-a-data-source-hive-features-reference-implementation"></a>

Athena bietet eine Referenzimplementierung für die Lambda-Funktion, die sich mit externen Hive-Metastores verbindet. Die Referenzimplementierung wird GitHub als Open-Source-Projekt bei [Athena Hive](https://github.com/awslabs/aws-athena-hive-metastore) Metastore bereitgestellt.

Die Referenzimplementierung ist als die folgenden beiden AWS SAM Anwendungen in der AWS Serverless Application Repository (SAR) verfügbar. Sie können eine dieser Anwendungen im SAR verwenden, um eigene Lambda-Funktionen zu erstellen.
+ `AthenaHiveMetastoreFunction` – Uber-Lambda-Funktion `.jar`-Datei. Ein „uber“ JAR (auch bekannt als Fat JAR oder JAR mit Abhängigkeiten) ist eine `.jar`-Datei, die sowohl ein Java-Programm als auch seine Abhängigkeiten in einer einzigen Datei enthält. 
+ `AthenaHiveMetastoreFunctionWithLayer` – Lambda-Ebene und dünne Lambda-Funktions-`.jar`-Datei.

## Workflow
<a name="connect-to-data-source-hive-workflow"></a>

Das folgende Diagramm zeigt, wie Athena mit Ihrem externen Hive-Metastore interagiert.

![\[Wie Athena mit Ihrem externen Hive-Metastore interagiert.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/connect-to-data-source-hive-workflow.png)


In diesem Workflow befindet sich Ihr mit der Datenbank verbundener Hive-Metastore in Ihrer VPC. Sie verwenden Hive Server2, um Ihren Hive-Metastore mithilfe der Hive-CLI zu verwalten.

Der Workflow für die Verwendung externer Hive-Metastores von Athena beinhaltet die folgenden Schritte.

1. Sie erstellen eine Lambda-Funktion, die eine Athena-Verbindung mit dem Hive-Metastore innerhalb Ihrer VPC herstellt.

1. Sie registrieren einen eindeutigen Katalognamen für Ihren Hive-Metastore und einen entsprechenden Funktionsnamen in Ihrem Konto.

1. Wenn Sie eine Athena-DML- oder DDL-Abfrage ausführen, die den Katalognamen verwendet, ruft die Athena-Abfrage-Engine den Lambda-Funktionsnamen auf, den Sie dem Katalognamen zugeordnet haben.

1. Mithilfe dieser AWS PrivateLink Funktion kommuniziert die Lambda-Funktion mit dem externen Hive-Metastore in Ihrer VPC und empfängt Antworten auf Metadatenanfragen. Athena verwendet die Metadaten Ihres externen Hive-Metastores genauso wie die Metadaten des Standard- AWS Glue Data Catalog.

## Überlegungen und Einschränkungen
<a name="connect-to-a-data-source-hive-considerations"></a>

Berücksichtigen Sie bei der Verwendung des Athena-Daten-Connectors für den externen Hive-Metastore die folgenden Punkte:
+ Sie können CTAS verwenden, um eine Tabelle auf einem externen Hive-Metastore zu erstellen.
+ Sie können INSERT INTO verwenden, um Daten in einen externen Hive-Metastore einzufügen.
+ Die DDL-Unterstützung für externe Hive-Metastores ist auf die folgenden Anweisungen beschränkt.
  + ALTER DATABASE SET DBPROPERTIES
  + TABELLE ÄNDERN SPALTEN HINZUFÜGEN
  + ALTER TABLE ADD PARTITION
  + ALTER TABLE DROP PARTITION
  + ALTER TABLE RENAME PARTITION
  + ALTER TABLE REPLACE COLUMNS
  + ALTER TABLE SET LOCATION
  + ALTER TABLE SET TBLPROPERTIES
  + CREATE DATABASE
  + CREATE TABLE
  + CREATE TABLE AS
  + DESCRIBE TABLE
  + DROP DATABASE
  + DROP TABLE
  + SHOW\$1COLUMNS
  + SHOW CREATE TABLE
  + SHOW PARTITIONS
  + SHOW SCHEMAS
  + SHOW TABLES
  + SHOW TBLPROPERTIES
+ Die maximale Anzahl registrierter Kataloge beträgt 1.000.
+ Die Kerberos-Authentifizierung wird für Hive-Metastores nicht unterstützt.
+ Um den JDBC-Treiber mit einem externen Hive-Metastore oder [Verbundabfragen](federated-queries.md) zu verwenden, schließen Sie `MetadataRetrievalMethod=ProxyAPI` in Ihre JDBC-Verbindungszeichenfolge ein. Informationen zum JDBC-Treiber finden Sie unter [Verbindung zu Amazon Athena mit JDBC herstellen](connect-with-jdbc.md).
+ Die ausgeblendeten Hive-Spalten `$path`, `$bucket`, `$file_size`, `$file_modified_time`, `$partition`, `$row_id` können nicht für eine differenzierte Filterung der Zugriffskontrolle verwendet werden. 
+ In Hive ausgeblendete Systemtabellen wie `example_table$partitions` oder `example_table$properties` werden von der detaillierten Zugriffskontrolle nicht unterstützt.

### Berechtigungen
<a name="connect-to-a-data-source-hive-considerations-permissions"></a>

Vorab erstellte und benutzerdefinierte Daten-Connectors benötigen möglicherweise Zugriff auf die folgenden Ressourcen, um ordnungsgemäß zu funktionieren. Überprüfen Sie die Informationen für den von Ihnen verwendeten Connector, um sicherzustellen, dass die VPC korrekt konfiguriert ist. Informationen zu den erforderlichen IAM-Berechtigungen zum Ausführen von Abfragen und zum Erstellen eines Datenquellen-Connectors in Athena finden Sie unter [Zugriff auf den Athena-Daten-Connector für externen Hive-Metastore zulassen](hive-metastore-iam-access.md) und [Gewährung von Lambda-Funktionszugriff auf externe Hive-Metastores](hive-metastore-iam-access-lambda.md).
+ **Amazon S3** – Zusätzlich zum Schreiben von Abfrageergebnissen zum Athena-Abfrageergebnisspeicherort in Amazon S3 schreiben Daten-Connectors auch zu einem Spill-Bucket in Amazon S3. Konnektivität und Berechtigungen für diesen Amazon-S3-Standort sind erforderlich. Weitere Informationen finden Sie unter [Spill-Speicherort in Amazon S3](#connect-to-data-source-hive-spill-location) an späterer Stelle in diesem Thema.
+ **Athena** – Zugriff ist erforderlich, um den Abfragestatus zu überprüfen und das Overscanning zu verhindern.
+ **AWS Glue**— Zugriff ist erforderlich, wenn Ihr Connector zusätzliche oder primäre Metadaten AWS Glue verwendet.
+ **AWS Key Management Service**
+ **Richtlinien** — Hive Metastore, Athena Query Federation und UDFs erfordern Richtlinien zusätzlich zu den. [AWS verwaltete Richtlinie: AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy) Weitere Informationen finden Sie unter [Identity and Access Management in Athena](security-iam-athena.md).

### Spill-Speicherort in Amazon S3
<a name="connect-to-data-source-hive-spill-location"></a>

Aufgrund des [Grenzwerts](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) für Lambda-Funktionsantwortgrößen werden Antworten, die größer als der Schwellenwert sind, an einen Amazon-S3-Speicherort übertragen, den Sie beim Erstellen der Lambda-Funktion angeben. Athena liest diese Antworten direkt von Amazon S3. 

**Anmerkung**  
Athena entfernt die Antwortdateien nicht von Amazon S3. Es wird empfohlen, eine Aufbewahrungsrichtlinie einzurichten, um Antwortdateien automatisch zu löschen. 

# Verbinden Sie Athena zu einem Apache Hive-Metastore
<a name="connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore"></a>

Um eine Verbindung von Athena zu einem Apache-Hive-Metastore herzustellen, müssen Sie eine Lambda-Funktion erstellen und konfigurieren. Für eine grundlegende Implementierung können Sie alle erforderlichen Schritte zum Start von der Athena-Verwaltungskonsole aus ausführen.

**Anmerkung**  
Das folgende Verfahren erfordert, dass Sie über die Berechtigung verfügen, eine benutzerdefinierte IAM-Rolle für die Lambda-Funktion zu erstellen. Wenn Sie nicht berechtigt sind, eine benutzerdefinierte Rolle zu erstellen, können Sie die [Athena-Referenzimplementierung](connect-to-data-source-hive.md#connect-to-a-data-source-hive-features-reference-implementation) verwenden, um eine Lambda-Funktion separat zu erstellen, und dann die AWS Lambda Konsole verwenden, um eine vorhandene IAM-Rolle für die Funktion auszuwählen. Weitere Informationen finden Sie unter [Athena mit einem Hive-Metastore mithilfe einer vorhandenen IAM-Ausführungsrolle verbinden](connect-data-source-hive-existing-iam-role.md).

**So stellen Sie eine Verbindung von Athena zu einem Hive-Metastore her:**

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.  
![\[Wählen Sie das Erweiterungsmenü aus.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/nav-pane-expansion.png)

1. Wählen Sie **Datenquellen und Kataloge** aus.

1. Wählen Sie oben rechts in der Konsole **Datenquelle erstellen** aus.

1. Wählen Sie auf der Seite **Eine Datenquelle wählen** für **Datenquelle** **S3 - Apache Hive Metastore**.

1. Wählen Sie **Weiter** aus.

1. Geben Sie im Abschnitt **Details zur Datenquelle** für **Datenquellenname** den Namen ein, den Sie in Ihren SQL-Anweisungen verwenden möchten, wenn Sie die Datenquelle von Athena abfragen. Der Name kann bis zu 127 Zeichen lang sein und muss innerhalb Ihres Kontos eindeutig sein. Er kann nicht mehr geändert werden, nachdem Sie ihn erstellt haben. Gültige Zeichen sind a-z, A-Z, 0-9, \$1 (Unterstrich), @ (At-Zeichen) und - (Bindestrich). Die Namen `awsdatacatalog`, `hive`, `jmx` und `system` sind von Athena reserviert und können nicht für Datenquellennamen verwendet werden. 

1. Wählen Sie für **Lambda-Funktion** die Option **Lambda-Funktion erstellen** und dann **Neue Lambda-Funktion erstellen** in AWS Lambda

   Die **AthenaHiveMetastoreFunction**Seite wird in der Konsole geöffnet. AWS Lambda Die Seite enthält detaillierte Informationen zum Connector.  
![\[Die AthenaHiveMetastoreFunctionSeite in der AWS Lambda Konsole.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/connect-to-data-source-hive-4.png)

1. Geben Sie unter **Application settings** (Anwendungseinstellungen) die Parameter für Ihre Lambda-Funktion ein.
   + **LambdaFuncName**— Geben Sie einen Namen für die Funktion ein. Beispiel, **myHiveMetastore**.
   + **SpillLocation**— Geben Sie in diesem Konto einen Amazon S3 S3-Standort an, um Spillover-Metadaten zu speichern, falls die Antwortgröße der Lambda-Funktion 4 MB überschreitet.
   + **HMSUris**— Geben Sie die URI Ihres Hive-Metastore-Hosts, der das Thrift-Protokoll verwendet, an Port 9083 ein. Verwenden der Syntax `thrift://<host_name>:9083`.
   + **LambdaMemory**— Geben Sie einen Wert zwischen 128 MB und 3008 MB an. Der Lambda-Funktion werden CPU-Zyklen proportional zur von Ihnen konfigurierten Speichermenge zugewiesen. Der Standardwert ist 1024.
   + **LambdaTimeout**— Geben Sie die maximal zulässige Laufzeit für Lambda-Aufrufe in Sekunden von 1 bis 900 an (900 Sekunden sind 15 Minuten). Der Standardwert ist 300 Sekunden (5 Minuten).
   + **VPCSecurityGroupIds**— Geben Sie eine durch Kommas getrennte Liste der VPC-Sicherheitsgruppen IDs für den Hive-Metastore ein.
   + **VPCSubnetIds** — Geben Sie eine durch Kommas getrennte Liste von VPC-Subnetzen IDs für den Hive-Metastore ein.

1. Wählen Sie **Ich bestätige, dass diese Anwendung benutzerdefinierte IAM-Rollen erstellt** und dann **Bereitstellen**.  
![\[Bereitstellen der Lambda Funktions-App über die AWS Lambda -Konsole.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/connect-to-data-source-hive-4a.png)

   Wenn die Bereitstellung abgeschlossen ist, wird Ihre Funktion in Ihrer Liste der Lambda-Anwendungen angezeigt. Nachdem die Hive-Metastore-Funktion für Ihr Konto bereitgestellt wurde, können Sie Athena für die Verwendung konfigurieren.

1. Kehren Sie zur Seite **Datenquellendetails eingeben** der Athena-Konsole zurück.

1. Wählen Sie im Abschnitt **Lambada-Funktion** das Symbol Aktualisieren neben dem Lambda-Funktionssuchfeld aus. Wenn Sie die Liste der verfügbaren Funktionen aktualisieren, wird Ihre neu erstellte Funktion in der Liste angezeigt.

1. Wählen Sie den Namen der Funktion aus, die Sie gerade in der Lambda-Konsole erstellt haben. Der ARN der Lambda-Funktion wird angezeigt.

1. (Optional) Fügen Sie für **Tags** Schlüssel-Wert-Paare hinzu, die mit dieser Datenquelle verknüpft werden sollen. Weitere Informationen zu Tags erhalten Sie unter [Athena-Ressourcen markieren](tags.md).

1. Wählen Sie **Weiter** aus.

1. Auf der Seite **Überprüfen und erstellen** prüfen Sie die Datenquellendetails und wählen Sie dann **Datenquelle erstellen** aus. 

1. Der Abschnitt **Datenquellendetails** auf der Seite für Ihre Datenquelle zeigt Informationen über Ihren neuen Connector an. 

   Sie können nun den **Data source name** (Datenquellennamen) verwenden, den Sie angegeben haben, um auf den Hive-Metastore in Ihren SQL-Abfragen in Athena zu verweisen. Verwenden Sie in Ihren SQL-Abfragen die folgende Beispielsyntax und ersetzen Sie `hms-catalog-1` durch den zuvor angegebenen Katalognamen.

   ```
   SELECT * FROM hms-catalog-1.CustomerData.customers 
   ```

1. Informationen zum Anzeigen, Bearbeiten oder Löschen der von Ihnen erstellten Datenquellen finden Sie unter [Ihre Datenquellen verwalten](data-sources-managing.md).

# Verwenden Sie den AWS Serverless Application Repository , um einen Hive-Datenquellenconnector bereitzustellen
<a name="connect-data-source-sar-hive"></a>

Um einen Athena-Datenquellen-Connector für Hive bereitzustellen, können Sie die[AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) verwenden anstatt mit der Athena-Konsole zu beginnen. Verwenden Sie den AWS Serverless Application Repository , um den Connector zu finden, den Sie verwenden möchten, geben Sie die Parameter an, die der Connector benötigt, und stellen Sie dann den Connector für Ihr Konto bereit. Nachdem Sie den Connector bereitgestellt haben, verwenden Sie die Athena-Konsole, um die Datenquelle für Athena verfügbar zu machen.

**Um den zu verwenden AWS Serverless Application Repository , um einen Datenquellen-Connector für Hive für Ihr Konto bereitzustellen**

1. Melden Sie sich beim **Serverless App** Repository an AWS-Managementkonsole und öffnen Sie es.

1. Wählen Sie im Navigationsbereich **Available applications (Verfügbare Anwendungen)** aus.

1. Wählen Sie die Option **Apps anzeigen, die benutzerdefinierte IAM-Rollen oder Ressourcenrichtlinien erstellen**.

1. Geben Sie in das Suchfeld **Hive** ein. Zu den angezeigten Connectors gehören die folgenden zwei:
   + **AthenaHiveMetastoreFunction** – Uber-Lambda-Funktion `.jar`-Datei.
   + **AthenaHiveMetastoreFunctionWithLayer** – Lambda-Ebene und dünne Lambda-Funktions-`.jar`-Datei.

    Die beiden Anwendungen besitzen dieselbe Funktionalität und unterscheiden sich nur in der Implementierung. Sie können beide für die Erstellung einer Lambda-Funktion verwenden, die Athena mit Ihrem Hive-Metastore verbindet.

1. Wählen Sie den Namen des Connectors aus, den Sie verwenden möchten. In diesem Tutorial wird ein **AthenaHiveMetastoreFunction** verwendet.  
![\[Auswahl des Namens des Athena-Datenquellen-Connectors für Hive.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/connect-data-source-sar-hive-1.png)

1. Geben Sie unter **Application settings** (Anwendungseinstellungen) die Parameter für Ihre Lambda-Funktion ein.
   + **LambdaFuncName**— Geben Sie einen Namen für die Funktion ein. Beispiel, **myHiveMetastore**.
   + **SpillLocation**— Geben Sie in diesem Konto einen Amazon S3 S3-Standort an, um Spillover-Metadaten zu speichern, falls die Antwortgröße der Lambda-Funktion 4 MB überschreitet.
   + **HMSUris**— Geben Sie die URI Ihres Hive-Metastore-Hosts, der das Thrift-Protokoll verwendet, an Port 9083 ein. Verwenden der Syntax `thrift://<host_name>:9083`.
   + **LambdaMemory**— Geben Sie einen Wert zwischen 128 MB und 3008 MB an. Der Lambda-Funktion werden CPU-Zyklen proportional zur von Ihnen konfigurierten Speichermenge zugewiesen. Der Standardwert ist 1024.
   + **LambdaTimeout**— Geben Sie die maximal zulässige Laufzeit des Lambda-Aufrufs in Sekunden von 1 bis 900 an (900 Sekunden sind 15 Minuten). Der Standardwert ist 300 Sekunden (5 Minuten).
   + **VPCSecurityGroupIds**— Geben Sie eine durch Kommas getrennte Liste der VPC-Sicherheitsgruppen IDs für den Hive-Metastore ein.
   + **VPCSubnetIds** — Geben Sie eine durch Kommas getrennte Liste von VPC-Subnetzen IDs für den Hive-Metastore ein.

1. Wählen Sie unten rechts auf der Seite **Anwendungsdetails** die Option **Ich bestätige, dass diese App benutzerdefinierte IAM-Rollen erstellt** und wählen Sie dann **Bereitstellen** aus.

An diesem Punkt können Sie Athena so konfigurieren, dass Ihre Lambda-Funktion zur Verbindung mit Ihrem Hive-Metastore verwendet wird. Informationen zu den erforderlichen Schritten finden Sie unter [Konfigurieren Sie Athena für die Verwendung eines bereitgestellten Hive-Metastore-Connectors](connect-data-source-hive-existing-lambda.md).

# Athena mit einem Hive-Metastore mithilfe einer vorhandenen IAM-Ausführungsrolle verbinden
<a name="connect-data-source-hive-existing-iam-role"></a>

Um Ihren externen Hive-Metastore mit Athena über eine Lambda-Funktion zu verbinden, die eine vorhandene IAM-Rolle verwendet, können Sie die Referenzimplementierung des Athena-Connectors für externen Hive-Metastore von Athena verwenden.

Die drei wichtigsten Schritte sind wie folgt:

1. **[Klonen und Entwickeln](#connect-data-source-hive-existing-iam-role-clone-and-build-the-lambda-function)** – Klonen Sie die Athena Referenzimplementierung und erstellen Sie die JAR-Datei, die den Lambda-Funktionscode enthält.

1. **[AWS Lambda console](#connect-data-source-hive-existing-iam-role-aws-lambda-console)** — Erstellen Sie in der AWS Lambda Konsole eine Lambda-Funktion, weisen Sie ihr eine bestehende IAM-Ausführungsrolle zu und laden Sie den von Ihnen generierten Funktionscode hoch.

1. **[Amazon-Athena-Konsole](connect-data-source-hive-existing-lambda.md)** – Erstellen Sie in der Amazon-Athena-Konsole einen Datenquellennamen, mit dem Sie in Ihren Athena-Abfragen auf Ihren externen Hive-Metastore verweisen können.

Wenn Sie bereits über die Berechtigungen zum Erstellen einer benutzerdefinierten IAM-Rolle verfügen, können Sie einen einfacheren Workflow verwenden, der die Athena-Konsole und die AWS Serverless Application Repository zum Erstellen und Konfigurieren einer Lambda-Funktion verwendet. Weitere Informationen finden Sie unter [Verbinden Sie Athena zu einem Apache Hive-Metastore](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md).

## Voraussetzungen
<a name="connect-data-source-hive-existing-iam-role-prerequisites"></a>
+ Git muss auf Ihrem System installiert sein.
+ Sie müssen [Apache Maven](https://maven.apache.org/) installiert haben.
+ Sie haben eine IAM-Ausführungsrolle, die Sie der Lambda-Funktion zuweisen können. Weitere Informationen finden Sie unter [Gewährung von Lambda-Funktionszugriff auf externe Hive-Metastores](hive-metastore-iam-access-lambda.md).

## Klonen und entwickeln Sie die Lambda-Funktion
<a name="connect-data-source-hive-existing-iam-role-clone-and-build-the-lambda-function"></a>

[Der Funktionscode für die Athena-Referenzimplementierung ist ein Maven-Projekt GitHub unter awslabs/. aws-athena-hive-metastore](https://github.com/awslabs/aws-athena-hive-metastore) Ausführliche Informationen über das Projekt finden Sie in der entsprechenden README-Datei oder im Thema GitHub in dieser Dokumentation. [Den externen Hive-Metastore-Konnektor von Athena ändern](datastores-hive-reference-implementation.md)

**So Klonen und erstellen Sie den Lambda-Funktionscode**

1. Geben Sie den folgenden Befehl ein, um die Athena Referenzimplementierung zu klonen:

   ```
   git clone https://github.com/awslabs/aws-athena-hive-metastore
   ```

1. Führen Sie den folgenden Befehl aus, um die `.jar`-Datei für die Lambda-Funktion zu entwickeln:

   ```
   mvn clean install
   ```

   Nachdem das Projekt erfolgreich erstellt wurde, wird die folgende `.jar`-Datei im Zielordner Ihres Projekts erstellt:

   `hms-lambda-func-1.0-SNAPSHOT-withdep.jar`

   Im nächsten Abschnitt verwenden Sie die AWS Lambda Konsole, um diese Datei auf Ihr Amazon Web Services Services-Konto hochzuladen.

## Erstellen und konfigurieren Sie die Lambda-Funktion in der Konsole AWS Lambda
<a name="connect-data-source-hive-existing-iam-role-aws-lambda-console"></a>

In diesem Abschnitt verwenden Sie die AWS Lambda Konsole, um eine Funktion zu erstellen, die eine vorhandene IAM-Ausführungsrolle verwendet. Nachdem Sie eine VPC für die Funktion konfiguriert haben, laden Sie den Funktionscode hoch und konfigurieren die Umgebungsvariablen für die Funktion.

### So erstellen Sie die Lambda-Funktion:
<a name="connect-data-source-hive-existing-iam-role-create-the-lambda-function"></a>

In diesem Schritt erstellen Sie eine Funktion in der AWS Lambda Konsole, die eine vorhandene IAM-Rolle verwendet.

**So erstellen Sie eine Lambda-Funktion, die eine vorhandene IAM-Rolle verwendet**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Wählen Sie im Navigationsbereich **Funktionen** aus.

1. Wählen Sie **Create function** (Funktion erstellen).

1. Wählen Sie **Von Grund auf neu schreiben** aus.

1. Geben Sie für **Funktionsname** den Namen Ihrer Lambda-Funktion ein (z. B. **EHMSBasedLambda**).

1. Wählen Sie für **Runtime** die Option **Java 8**.

1. Erweitern Sie unter **Berechtigungen** die Option **Standardausführungsrolle ändern**.

1. Wählen Sie für **Execution role (Ausführungsrolle)** die Option **Use an existing role (Vorhandene Rolle verwenden)** aus.

1. Wählen Sie für **Vorhandene Rolle** die IAM-Ausführungsrolle aus, die Ihre Lambda-Funktion für Athena verwendet (in diesem Beispiel wird eine Rolle namens `AthenaLambdaExecutionRole` verwendet).

1. Erweiterten Sie **Advanced settings (Erweiterte Einstellungen)**.

1. Wählen Sie **Netzwerk aktivieren** aus.

1. Wählen Sie für **VPC** die VPC aus, auf die Ihre Funktion Zugriff hat.

1. Wählen Sie für **Subnetze** die VPC-Subnetze aus, die Lambda verwenden soll.

1. Wählen Sie für **Sicherheitsgruppen** die VPC-Sicherheitsgruppen aus, die Lambda verwenden soll.

1. Wählen Sie **Funktion erstellen**. Die AWS Lambda Konsole und öffnet die Konfigurationsseite für Ihre Funktion und beginnt mit der Erstellung Ihrer Funktion.

### Laden Sie den Code hoch und konfigurieren Sie die Lambda-Funktion
<a name="connect-data-source-hive-existing-iam-role-upload-and-configure"></a>

Wenn die Konsole Sie darüber informiert, dass Ihre Funktion erfolgreich erstellt wurde, können Sie den Funktionscode hochladen und seine Umgebungsvariablen konfigurieren.

**So laden Sie Ihren Lambda-Funktionscode hoch und konfigurieren die Umgebungsvariablen**

1. Stellen Sie in der Lambda-Konsole sicher, dass Sie sich auf der Seite der von Ihnen angegebenen Funktion auf der Registerkarte **Code** befinden.

1. Wählen Sie für **Code source** (Quellcode) **Upload from** (Hochladen von) und anschließend **.zip or .jar file** (.zip- oder .jar-Datei) aus.

1. Laden Sie die zuvor erstellte `hms-lambda-func-1.0-SNAPSHOT-withdep.jar`-Datei hoch.

1. Wählen Sie auf der Seite der Lambda-Funktion den Tab **Konfiguration**.

1. Wählen Sie im Bereich auf der linken Seite **Umgebungsvariablen** aus.

1. Wählen Sie im Abschnitt **Environment variables** (Umgebungsvariablen) **Edit** (Bearbeiten) aus.  
![\[Wählen Sie Edit (Bearbeiten), um die Umgebungsvariablen für die Lambda-Funktion zu bearbeiten.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/connect-data-source-hive-existing-iam-role-5.png)

1. Verwenden Sie auf der Seite **Edit environment variables** (Umgebungsvariablen bearbeiten) die Option **Add environment variable** (Umgebungsvariable hinzufügen), um die folgenden Umgebungsvariablenschlüssel und -werte hinzuzufügen:
   + **HMS\$1URIS** – Verwenden Sie die folgende Syntax, um den URI Ihres Hive-Metastore-Hosts einzugeben, der das Thrift-Protokoll an Port 9083 verwendet.

     ```
     thrift://<host_name>:9083
     ```
   + **SPILL\$1LOCATION** – Geben Sie in Ihrem Amazon-Web-Services-Konto einen Amazon-S3-Speicherort an, um Spillover-Metadaten zu speichern, wenn die Antwortgröße der Lambda-Funktion 4 MB überschreitet.  
![\[Angeben von Werten für die Umgebungsvariablen der Lambda-Funktion.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/connect-data-source-hive-existing-iam-role-6.png)

1. Wählen Sie **Save** (Speichern) aus.

Zu diesem Zeitpunkt können Sie Athena so konfigurieren, dass Ihre Lambda-Funktion zum Herstellen einer Verbindung mit Ihrem Hive-Metastore verwendet wird. Informationen zu den erforderlichen Schritten finden Sie unter [Konfigurieren Sie Athena für die Verwendung eines bereitgestellten Hive-Metastore-Connectors](connect-data-source-hive-existing-lambda.md).

# Konfigurieren Sie Athena für die Verwendung eines bereitgestellten Hive-Metastore-Connectors
<a name="connect-data-source-hive-existing-lambda"></a>

Nachdem Sie einen Lambda-Datenquellen-Connector wie `AthenaHiveMetastoreFunction` in Ihrem Konto bereitgestellt haben, können Sie Athena für die Verwendung konfigurieren. Dazu erstellen Sie einen Datenquellennamen, der auf Ihren externen Hive-Metastore verweist, der in Ihren Athena-Abfragen verwendet werden soll.

**So verbinden Sie Athena mit Ihrem Hive-Metastore über eine vorhandene Lambda-Funktion**

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.  
![\[Wählen Sie das Erweiterungsmenü aus.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/nav-pane-expansion.png)

1. Wählen Sie **Datenquellen und Kataloge** aus.

1. Wählen Sie auf der Seite **Datenquellen und Kataloge** die Option **Datenquellen erstellen** aus.

1. Wählen Sie auf der Seite **Eine Datenquelle wählen** für **Datenquelle** **S3 - Apache Hive Metastore**.

1. Wählen Sie **Weiter** aus.

1. Geben Sie im Abschnitt **Data source details** (Details zur Datenquelle) für **Data source name** (Datenquellenname) den Namen ein, den Sie in Ihren SQL-Anweisungen verwenden möchten, wenn Sie die Datenquelle von Athena abfragen (z. B `MyHiveMetastore`). Der Name kann bis zu 127 Zeichen lang sein und muss innerhalb Ihres Kontos eindeutig sein. Er kann nicht mehr geändert werden, nachdem Sie ihn erstellt haben. Gültige Zeichen sind a-z, A-Z, 0-9, \$1 (Unterstrich), @ (At-Zeichen) und - (Bindestrich). Die Namen `awsdatacatalog`, `hive`, `jmx` und `system` sind von Athena reserviert und können nicht für Datenquellennamen verwendet werden. 

1. Im Abschnitt **Verbindungsdetails** verwenden Sie das Feld **Auswählen oder Eingeben einer Lambda-Funktion**, um den Namenn der Funktion, die Sie soeben erstellt haben, auszuwählen. Der ARN der Lambda-Funktion wird angezeigt.

1. (Optional) Fügen Sie für **Tags** Schlüssel-Wert-Paare hinzu, die mit dieser Datenquelle verknüpft werden sollen. Weitere Informationen zu Tags erhalten Sie unter [Athena-Ressourcen markieren](tags.md).

1. Wählen Sie **Weiter** aus.

1. Auf der Seite **Überprüfen und erstellen** prüfen Sie die Datenquellendetails und wählen Sie dann **Datenquelle erstellen** aus. 

1. Der Abschnitt **Datenquellendetails** auf der Seite für Ihre Datenquelle zeigt Informationen über Ihren neuen Connector an.

   Sie können nun den **Data source name** (Datenquellennamen) verwenden, den Sie angegeben haben, um auf den Hive-Metastore in Ihren SQL-Abfragen in Athena zu verweisen.

   Verwenden Sie in Ihren SQL-Abfragen die folgende Beispielsyntax und ersetzen Sie `ehms-catalog` durch den zuvor angegebenen Datenquellennamen.

   ```
   SELECT * FROM ehms-catalog.CustomerData.customers 
   ```

1. Informationen zum Anzeigen, Bearbeiten oder Löschen der von Ihnen erstellten Datenquellen finden Sie unter [Ihre Datenquellen verwalten](data-sources-managing.md).

# Den Katalognamen in externen Hive-Metastore-Abfragen weglassen
<a name="datastores-hive-default-catalog"></a>

Wenn Sie DML- und DDL-Abfragen für externe Hive-Metastores ausführen, können Sie die Abfragesyntax vereinfachen, indem Sie den Katalognamen weglassen, wenn dieser Name im Abfrage-Editor ausgewählt ist. Für diese Funktionalität gelten bestimmte Einschränkungen.

## DML-Anweisungen.
<a name="datastores-hive-default-catalog-dml-statements"></a>

**So führen Sie Abfragen mit registrierten Katalogen aus:**

1. Sie können den Datenquellennamen mithilfe der Syntax `[[data_source_name].database_name].table_name` vor die Datenbank einfügen, wie im folgenden Beispiel gezeigt.

   ```
   select * from  "hms-catalog-1".hms_tpch.customer limit 10;
   ```

1. Wenn die Datenquelle, die Sie verwenden möchten, in dem Abfrage-Editor bereits ausgewählt ist, können Sie den Namen wie im folgenden Beispiel aus der Abfrage weglassen.

   ```
   select * from hms_tpch.customer limit 10:
   ```  
![\[Eine DML-Abfrage, die eine Standarddatenquelle verwendet.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/datastores-hive-default-catalog-2.png)

1. Wenn Sie mehrere Datenquellen in einer Abfrage verwenden, können Sie nur den Standarddatenquellennamen weglassen und müssen den vollständigen Namen für alle nicht standardmäßigen Datenquellen angeben. 

   Angenommen, `AwsDataCatalog` ist im Abfrage-Editor als Standarddatenquelle ausgewählt. Die `FROM` Anweisung im folgenden Abfrageauszug qualifiziert die ersten beiden Datenquellennamen vollständig, lässt jedoch den Namen für die dritte Datenquelle weg, da sie sich im AWS Glue Datenkatalog befindet.

   ```
   ...
   FROM ehms01.hms_tpch.customer,
            "hms-catalog-1".hms_tpch.orders,
            hms_tpch.lineitem
   ...
   ```

## DDL-Anweisungen
<a name="datastores-hive-default-catalog-ddl-statements"></a>

Die folgenden Athena-DDL-Anweisungen unterstützen Katalognamenpräfixe. Katalognamenpräfixe in anderen DDL-Anweisungen verursachen Syntaxfehler.

```
SHOW TABLES [IN [catalog_name.]database_name] ['regular_expression']

SHOW TBLPROPERTIES [[catalog_name.]database_name.]table_name [('property_name')]

SHOW COLUMNS IN [[catalog_name.]database_name.]table_name

SHOW PARTITIONS [[catalog_name.]database_name.]table_name

SHOW CREATE TABLE [[catalog_name.][database_name.]table_name

DESCRIBE [EXTENDED | FORMATTED] [[catalog_name.][database_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]
```

Wie bei DML-Anweisungen können Sie die Datenquelle und die Datenbankpräfixe aus der Abfrage weglassen, wenn die Datenquelle und die Datenbank im Abfrage-Editor ausgewählt werden.

Im folgenden Bild werden die `hms-catalog-1`-Datenquelle und die `hms_tpch`-Datenbank im Abfrage-Editor ausgewählt. Die `show create table customer`-Anweisung ist erfolgreich, obwohl das `hms-catalog-1`-Präfix und der `hms_tpch`-Datenbankname von der Abfrage selbst weggelassen werden.

![\[Eine DDL-Anweisung, die den Standardkatalog verwendet.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/datastores-hive-default-catalog-4.png)


## Angeben einer Standard-Datenquelle in einer JDBC-Verbindungszeichenfolge
<a name="datastores-hive-default-catalog-jdbc"></a>

Wenn Sie den Athena-JDBC-Treiber verwenden, um Athena mit einem externen Hive-Metastore zu verbinden, können Sie den `Catalog`-Parameter verwenden, um den Standard-Namen der Datenquelle in Ihrer Verbindungszeichenfolge in einem SQL-Editor wie [SQL Workbench](https://www.sql-workbench.eu/index.html) anzugeben.

**Anmerkung**  
Informationen zum Herunterladen des neuesten Athena-JDBC-Treibers finden Sie unter [Verwenden von Athena mit dem JDBC-Treiber](https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html).

Die folgende Verbindungszeichenfolge gibt die Standarddatenquelle an. *hms-catalog-name*

```
    jdbc:awsathena://AwsRegion=us-east-1;S3OutputLocation=s3://amzn-s3-demo-bucket/lambda/results/;Workgroup=AmazonAthenaPreviewFunctionality;Catalog=hms-catalog-name;
```

Das folgende Image zeigt ein Beispiel für eine JDBC-Verbindungs-URL, wie sie in SQL Workbench konfiguriert ist.

![\[Konfigurieren einer JDBC-Verbindungs-URL in SQL Workbench.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/datastores-hive-default-catalog-jdbc-1.jpg)


# Arbeiten mit Hive-Ansichten
<a name="hive-views"></a>

Sie können Athena verwenden, um vorhandene Ansichten in Ihren externen Apache-Hive-Metaspeichern abzufragen. Athena übersetzt Ihre Ansichten zur on-the-fly Laufzeit für Sie, ohne die ursprüngliche Ansicht zu ändern oder die Übersetzung zu speichern.

Angenommen, Sie haben eine Hive-Ansicht wie die folgende, die eine Syntax verwendet, die in Athena nicht unterstützt wird, wie `LATERAL VIEW explode()`:

```
CREATE VIEW team_view AS 
SELECT team, score 
FROM matches 
LATERAL VIEW explode(scores) m AS score
```

Athena übersetzt die Hive-View-Abfragezeichenfolge in eine Anweisung wie die folgende, die Athena ausführen kann:

```
SELECT team, score
FROM matches
CROSS JOIN UNNEST(scores) AS m (score)
```

Informationen zum Verbinden eines externen Hive-Metastores mit Athena finden Sie unter [Einen externen Hive-Metastore verwenden](connect-to-data-source-hive.md).

## Überlegungen und Einschränkungen
<a name="hive-views-considerations-and-limitations"></a>

Berücksichtigen Sie bei der Abfrage von Hive-Ansichten von Athena die folgenden Punkte:
+ Athena unterstützt das Erstellen von Hive-Ansichten nicht. Sie können Hive-Ansichten in Ihrem externen Hive-Metastore erstellen, die Sie dann von Athena abfragen können.
+ Athena unterstützt keine benutzerdefinierten Ansichten UDFs für Hive-Ansichten.
+ Aufgrund eines bekannten Problems in der Athena-Konsole werden Hive-Ansichten unter der Tabellenliste anstelle der Liste der Ansichten angezeigt.
+ Obwohl der Übersetzungsprozess automatisch abläuft, werden bestimmte Hive-Funktionen für Hive-Ansichten nicht unterstützt oder erfordern eine spezielle Handhabung. Weitere Informationen finden Sie im folgenden Abschnitt.

## Einschränkungen bei der Unterstützung von Hive-Funktionen
<a name="hive-views-function-limitations"></a>

In diesem Abschnitt werden die Hive-Funktionen hervorgehoben, die Athena nicht für Hive-Ansichten unterstützt oder die eine spezielle Behandlung erfordern. Da Athena hauptsächlich Funktionen von Hive 2.2.0 unterstützt, sind derzeit Funktionen, die nur in höheren Versionen (wie Hive 4.0.0) verfügbar sind, nicht verfügbar. Eine vollständige Liste der Hive-Funktionen finden Sie unter [Hive Sprachhandbuch UDF](https://cwiki.apache.org/confluence/display/hive/languagemanual+udf).

### Aggregationsfunktionen
<a name="hive-views-aggregate-functions"></a>

#### Aggregatfunktionen, die eine besondere Handhabung erfordern
<a name="hive-views-aggregate-functions-special-handling"></a>

Die folgende Aggregatfunktion für Hive-Ansichten erfordert eine besondere Handhabung.
+ **Avg** – Verwenden Sie `avg(CAST(i AS DOUBLE))` anstelle von `avg(INT i)`.

#### Aggregatfunktionen werden nicht unterstützt
<a name="hive-views-aggregate-functions-not-supported"></a>

Die folgenden Hive-Aggregatfunktionen werden in Athena für Hive-Ansichten nicht unterstützt.

```
covar_pop
histogram_numeric
ntile
percentile
percentile_approx
```

Regressionsfunktionen wie `regr_count`, `regr_r2` und `regr_sxx` werden in Athena für Hive-Ansichten nicht unterstützt.q

### Datumsfunktionen werden nicht unterstützt
<a name="hive-views-date-functions-not-supported"></a>

Die folgenden Hive-Datumsfunktionen werden in Athena für Hive-Ansichten nicht unterstützt.

```
date_format(date/timestamp/string ts, string fmt)
day(string date)
dayofmonth(date)
extract(field FROM source)
hour(string date)
minute(string date)
month(string date)
quarter(date/timestamp/string)
second(string date)
weekofyear(string date)
year(string date)
```

### Maskierungsfunktionen werden nicht unterstützt
<a name="hive-views-masking-functions-not-supported"></a>

Hive-Maskierungsfunktionen wie `mask()` und `mask_first_n()` werden in Athena für Hive-Ansichten nicht unterstützt.

### Verschiedene Funktionen
<a name="hive-views-miscellaneous-functions"></a>

#### Aggregatfunktionen, die eine besondere Handhabung erfordern
<a name="hive-views-supported-miscellaneous-functions-special-handling"></a>

Die folgenden verschiedenen Funktionen für Hive-Ansichten erfordern eine besondere Handhabung.
+ **md5** .. Athena unterstützt `md5(binary)` aber nicht `md5(varchar)`.
+ **Explode** – Athena unterstützt `explode`, wenn es in der folgenden Syntax verwendet wird:

  ```
  LATERAL VIEW [OUTER] EXPLODE(<argument>)
  ```
+ **Postexplode** – Athena unterstützt `posexplode`, wenn es in der folgenden Syntax verwendet wird:

  ```
  LATERAL VIEW [OUTER] POSEXPLODE(<argument>)           
  ```

  In der `(pos, val)`-Ausgabe behandelt Athena die `pos`-Spalte als `BIGINT`. Aus diesem Grund müssen Sie möglicherweise die `pos`-Spalte in `BIGINT` umwandeln, um eine veraltete Ansicht zu vermeiden. Das folgende Beispiel illustriert diese Technik.

  ```
  SELECT CAST(c AS BIGINT) AS c_bigint, d 
  FROM table LATERAL VIEW POSEXPLODE(<argument>) t AS c, d
  ```

#### Verschiedene Funktionen werden nicht unterstützt
<a name="hive-views-unsupported-miscellaneous-functions-not-supported"></a>

Die folgenden Hive-Funktionen werden in Athena für Hive-Ansichten nicht unterstützt.

```
aes_decrypt
aes_encrypt
current_database
current_user
inline
java_method
logged_in_user
reflect
sha/sha1/sha2
stack
version
```

### Betreiber
<a name="hive-views-operators"></a>

#### Betreiber, die eine Sonderverarbeitung benötigen
<a name="hive-views-operators-special-handling"></a>

Die folgenden Operatoren für Hive-Ansichten erfordern eine besondere Handhabung.
+ **Mod-Operator (%)** – Da der `DOUBLE`-Typ implizit in `DECIMAL(x,y)` umgewandelt wird, kann die folgende Syntax zu einer View is stale-Fehlermeldung führen:

  ```
  a_double % 1.0 AS column
  ```

  Um dieses Problem zu umgehen, verwenden Sie `CAST`, wie im folgenden Beispiel.

  ```
  CAST(a_double % 1.0 as DOUBLE) AS column
  ```
+ **Divisionsbetreiber (/)** – In Hive produziert `int` geteilt durch `int` `double`. In Athena erzeugt dieselbe Operation einen abgeschnittenen `int`.

#### Operatoren werden nicht unterstützt
<a name="hive-views-operators-not-supported"></a>

Athena unterstützt die folgenden Operatoren für Hive-Ansichten nicht.

**\$1A** – Bitwise `NOT`

**A ^ b** – Bitwise `XOR`

**A & b** – Bitwise `AND`

**A \$1 b** – Bitwise `OR`

**A <=> b** – Gibt das gleiche Ergebnis wie der Operator Gleich (`=`) für Nicht-Null-Operanden zurück. Gibt `TRUE` zurück, wenn beide `NULL` sind, `FALSE`, wenn einer von ihnen `NULL` ist.

### Zeichenfolgenfunktionen
<a name="hive-views-string-functions"></a>

#### Zeichenfolgen-Funktionen, die eine besondere Handhabung erfordern
<a name="hive-views-string-functions-special-handling"></a>

Die folgenden Hive-Zeichenfolgen-Funktionen für Hive-Ansichten erfordern eine besondere Handhabung.
+ **chr(bigint\$1double a)** – Hive erlaubt negative Argumente; Athena nicht.
+ **instr(string str, string substr)** – Da das Athena-Mapping für die `instr`-Funktion `BIGINT` statt `INT` zurückgibt, verwenden Sie die folgende Syntax:

  ```
  CAST(instr(string str, string substr) as INT)         
  ```

  Ohne diesen Schritt wird die Ansicht als abgestanden angesehen.
+ **length(string a)** – Da das Athena-Mapping für die `length`-Funktion `BIGINT` anstelle von `INT` zurückgibt, verwenden Sie die folgende Syntax, damit die Ansicht nicht als veraltet betrachtet wird:

  ```
  CAST(length(string str) as INT)
  ```

#### Zeichenfolgen-Funktionen werden nicht unterstützt
<a name="hive-views-string-functions-not-supported"></a>

Die folgenden Hive-Zeichenfolgen-Funktionen werden in Athena für Hive-Ansichten nicht unterstützt.

```
ascii(string str)
character_length(string str)
decode(binary bin, string charset)
encode(string src, string charset)
elt(N int,str1 string,str2 string,str3 string,...)
field(val T,val1 T,val2 T,val3 T,...)
find_in_set(string str, string strList)
initcap(string A)
levenshtein(string A, string B)
locate(string substr, string str[, int pos])
octet_length(string str)
parse_url(string urlString, string partToExtract [, string keyToExtract])
printf(String format, Obj... args)
quote(String text)
regexp_extract(string subject, string pattern, int index)
repeat(string str, int n)
sentences(string str, string lang, string locale)
soundex(string A)
space(int n)
str_to_map(text[, delimiter1, delimiter2])
substring_index(string A, string delim, int count)
```

### XPath Funktionen werden nicht unterstützt
<a name="hive-views-xpath-functions-not-supported"></a>

 XPath Hive-Funktionen wie `xpath``xpath_short`, und `xpath_int` werden in Athena for Hive-Ansichten nicht unterstützt.

## Fehlerbehebung
<a name="hive-views-troubleshooting"></a>

Wenn Sie Hive-Ansichten in Athena verwenden, treten möglicherweise die folgenden Probleme auf:
+ **Ansicht *<view name>* ist veraltet** — Diese Meldung weist normalerweise auf einen Typkonflikt zwischen der Ansicht in Hive und Athena hin. Wenn dieselbe Funktion in der Dokumentation zu [ LanguageManual Hive-UDF](https://cwiki.apache.org/confluence/display/hive/languagemanual+udf) - und [Presto-Funktionen und -Operatoren](https://prestodb.io/docs/current/functions.html) unterschiedliche Signaturen hat, versuchen Sie, den nicht übereinstimmenden Datentyp umzuwandeln.
+ **Funktion nicht registriert** – Athena unterstützt die Funktion derzeit nicht. Einzelheiten finden Sie weiter oben in diesem Dokument.

# Verwenden Sie die AWS CLI mit Hive-Metastoren
<a name="datastores-hive-cli"></a>

Sie können `aws athena`-CLI-Befehle verwenden, um die Hive-Metastore-Datenkataloge zu verwalten, die Sie mit Athena verwenden. Nach der Definition eines oder mehrerer Kataloge für die Verwendung mit Athena können Sie in den `aws athena`-DDL- und -DML-Befehlen auf diese Kataloge verweisen.

## Verwenden von zur Verwaltung von AWS CLI Hive-Metastore-Katalogen
<a name="datastores-hive-cli-manage-hive-catalogs"></a>

### Registrierung eines Katalogs: Create-data-catalog
<a name="datastores-hive-cli-registering-a-catalog"></a>

Um einen Datenkatalog zu registrieren, verwenden Sie den Befehl `create-data-catalog`. Sie verwenden den Parameter `name`, um den Namen anzugeben, den Sie für den Katalog verwenden möchten. Sie übergeben den ARN der Lambda-Funktion an die Option `metadata-function` des Arguments `parameters`. Um Tags für den neuen Katalog zu erstellen, verwenden Sie den Parameter `tags` mit einem oder mehreren, durch Leerzeichen getrennten Argumentpaaren `Key=key,Value=value`.

Im folgenden Beispiel wird ein Hive-Metastore-Katalog mit dem Namen `hms-catalog-1` registriert. Der Befehl wurde zur besseren Lesbarkeit formatiert.

```
$ aws athena create-data-catalog 
 --name "hms-catalog-1" 
 --type "HIVE"
 --description "Hive Catalog 1"
 --parameters "metadata-function=arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3,sdk-version=1.0" 
 --tags Key=MyKey,Value=MyValue
 --region us-east-1
```

### Katalogdetails werden angezeigt: Get-data-catalog
<a name="datastores-hive-cli-showing-details-of-a-catalog"></a>

Um die Details eines Katalogs anzuzeigen, übergeben Sie den Namen des Katalogs an den Befehl `get-data-catalog` wie im folgenden Beispiel gezeigt.

```
$ aws athena get-data-catalog --name "hms-catalog-1" --region us-east-1
```

Das folgende Beispielergebnis verwendet das JSON-Format.

```
{
    "DataCatalog": {
        "Name": "hms-catalog-1",
        "Description": "Hive Catalog 1",
        "Type": "HIVE",
        "Parameters": {
            "metadata-function": "arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3",
            "sdk-version": "1.0"
        }
    }
}
```

### Liste registrierter Kataloge: List-data-catalogs
<a name="datastores-hive-cli-listing-registered-catalogs"></a>

Um die registrierten Kataloge aufzulisten, verwenden Sie den Befehl `list-data-catalogs` und geben optional eine Region an, wie im folgenden Beispiel gezeigt. Die aufgelisteten Kataloge enthalten stets AWS Glue.

```
$ aws athena list-data-catalogs --region us-east-1
```

Das folgende Beispielergebnis verwendet das JSON-Format.

```
{
    "DataCatalogs": [
        {
            "CatalogName": "AwsDataCatalog",
            "Type": "GLUE"
        },
        {
            "CatalogName": "hms-catalog-1",
            "Type": "HIVE",
            "Parameters": {
                "metadata-function": "arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3",
                "sdk-version": "1.0"
            }
        }
    ]
}
```

### Einen Katalog aktualisieren: Update-data-catalog
<a name="datastores-hive-cli-updating-a-catalog"></a>

Um einen Datenkatalog zu aktualisieren, verwenden Sie den Befehl `update-data-catalog` wie im folgenden Beispiel gezeigt. Der Befehl wurde zur besseren Lesbarkeit formatiert.

```
$ aws athena update-data-catalog 
 --name "hms-catalog-1" 
 --type "HIVE"
 --description "My New Hive Catalog Description" 
 --parameters "metadata-function=arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new,sdk-version=1.0" 
 --region us-east-1
```

### Einen Katalog löschen: Delete-data-catalog
<a name="datastores-hive-cli-deleting-a-catalog"></a>

Um einen Datenkatalog zu löschen, verwenden Sie den Befehl `delete-data-catalog` wie im folgenden Beispiel gezeigt.

```
$ aws athena delete-data-catalog --name "hms-catalog-1" --region us-east-1
```

### Anzeige von Datenbankdetails: Get-database
<a name="datastores-hive-cli-showing-details-of-a-database"></a>

Um die Details einer Datenbank anzuzeigen, übergeben Sie den Namen des Katalogs und der Datenbank an den Befehl `get-database` wie im folgenden Beispiel gezeigt.

```
$ aws athena get-database --catalog-name hms-catalog-1 --database-name mydb
```

Das folgende Beispielergebnis verwendet das JSON-Format.

```
{
    "Database": {
        "Name": "mydb",
        "Description": "My database",
        "Parameters": {
            "CreatedBy": "Athena",
            "EXTERNAL": "TRUE"
        }
    }
}
```

### Auflistung von Datenbanken in einem Katalog: List-databases
<a name="datastores-hive-cli-listing-databases"></a>

Um die Datenbanken in einem Katalog aufzulisten, verwenden Sie den Befehl `list-databases` und geben optional eine Region an, wie im folgenden Beispiel gezeigt.

```
$ aws athena list-databases --catalog-name AwsDataCatalog --region us-west-2
```

Das folgende Beispielergebnis verwendet das JSON-Format.

```
{
    "DatabaseList": [
        {
            "Name": "default"
        },
        {
            "Name": "mycrawlerdatabase"
        },
        {
            "Name": "mydatabase"
        },
        {
            "Name": "sampledb",
            "Description": "Sample database",
            "Parameters": {
                "CreatedBy": "Athena",
                "EXTERNAL": "TRUE"
            }
        },
        {
            "Name": "tpch100"
        }
    ]
}
```

### Tabellendetails anzeigen: Get-table-metadata
<a name="datastores-hive-cli-showing-details-of-a-table"></a>

Um die Metadaten für eine Tabelle einschließlich Spaltennamen und Datentypen anzuzeigen, übergeben Sie den Namen des Katalogs, der Datenbank und der Tabelle an den Befehl `get-table-metadata` wie im folgenden Beispiel gezeigt.

```
$ aws athena get-table-metadata --catalog-name AwsDataCatalog --database-name mydb --table-name cityuseragent
```

Das folgende Beispielergebnis verwendet das JSON-Format.

```
{
    "TableMetadata": {
        "Name": "cityuseragent",
            "CreateTime": 1586451276.0,
            "LastAccessTime": 0.0,
            "TableType": "EXTERNAL_TABLE",
            "Columns": [
                {
                    "Name": "city",
                    "Type": "string"
                },
                {
                    "Name": "useragent1",
                    "Type": "string"
                }
            ],
            "PartitionKeys": [],
            "Parameters": {
                "COLUMN_STATS_ACCURATE": "false",
                "EXTERNAL": "TRUE",
                "inputformat": "org.apache.hadoop.mapred.TextInputFormat",
                "last_modified_by": "hadoop",
                "last_modified_time": "1586454879",
                "location": "s3://amzn-s3-demo-bucket/",
                "numFiles": "1",
                "numRows": "-1",
                "outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
                "rawDataSize": "-1",
                "serde.param.serialization.format": "1",
                "serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
                "totalSize": "61"
            }
        }
}
```

### Metadaten für alle Tabellen in einer Datenbank anzeigen: List-table-metadata
<a name="datastores-hive-cli-showing-all-table-metadata"></a>

Um die Metadaten für alle Tabellen in einer Datenbank anzuzeigen, übergeben Sie den Namen des Katalogs und der Datenbank an den Befehl `list-table-metadata`. Der Befehl `list-table-metadata` ist dem Befehl `get-table-metadata` vergleichbar, abgesehen davon, dass kein Tabellenname angegeben wird. Um die Anzahl der Ergebnisse zu begrenzen, können Sie die Option `--max-results`verwenden wie im folgenden Beispiel gezeigt. 

```
$ aws athena list-table-metadata --catalog-name AwsDataCatalog --database-name sampledb --region us-east-1 --max-results 2
```

Das folgende Beispielergebnis verwendet das JSON-Format.

```
{
    "TableMetadataList": [
        {
            "Name": "cityuseragent",
            "CreateTime": 1586451276.0,
            "LastAccessTime": 0.0,
            "TableType": "EXTERNAL_TABLE",
            "Columns": [
                {
                    "Name": "city",
                    "Type": "string"
                },
                {
                    "Name": "useragent1",
                    "Type": "string"
                }
            ],
            "PartitionKeys": [],
            "Parameters": {
                "COLUMN_STATS_ACCURATE": "false",
                "EXTERNAL": "TRUE",
                "inputformat": "org.apache.hadoop.mapred.TextInputFormat",
                "last_modified_by": "hadoop",
                "last_modified_time": "1586454879",
                "location": "s3://amzn-s3-demo-bucket/",
                "numFiles": "1",
                "numRows": "-1",
                "outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
                "rawDataSize": "-1",
                "serde.param.serialization.format": "1",
                "serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
                "totalSize": "61"
            }
        },
        {
            "Name": "clearinghouse_data",
            "CreateTime": 1589255544.0,
            "LastAccessTime": 0.0,
            "TableType": "EXTERNAL_TABLE",
            "Columns": [
                {
                    "Name": "location",
                    "Type": "string"
                },
                {
                    "Name": "stock_count",
                    "Type": "int"
                },
                {
                    "Name": "quantity_shipped",
                    "Type": "int"
                }
            ],
            "PartitionKeys": [],
            "Parameters": {
                "EXTERNAL": "TRUE",
                "inputformat": "org.apache.hadoop.mapred.TextInputFormat",
                "location": "s3://amzn-s3-demo-bucket/",
                "outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
                "serde.param.serialization.format": "1",
                "serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
                "transient_lastDdlTime": "1589255544"
            }
        }
    ],
    "NextToken": "eyJsYXN0RXZhbHVhdGVkS2V5Ijp7IkhBU0hfS0VZIjp7InMiOiJ0Ljk0YWZjYjk1MjJjNTQ1YmU4Y2I5OWE5NTg0MjFjYTYzIn0sIlJBTkdFX0tFWSI6eyJzIjoiY2xlYXJpbmdob3VzZV9kYXRhIn19LCJleHBpcmF0aW9uIjp7InNlY29uZHMiOjE1ODkzNDIwMjIsIm5hbm9zIjo2NTUwMDAwMDB9fQ=="
}
```

## Ausführung von DDL- und DML-Anweisungen
<a name="datastores-hive-cli-running-ddl-and-dml"></a>

Wenn Sie die AWS CLI DDL- und DML-Anweisungen ausführen, können Sie den Namen des Hive-Metastore-Katalogs auf zwei Arten übergeben:
+ Direkt an die Anweisungen, die ihn unterstützen.
+ An den Parameter `--query-execution-context` `Catalog`.

### DDL-Anweisungen
<a name="datastores-hive-cli-ddl-statements"></a>

Im folgenden Beispiel wird der Katalogname direkt als Teil der DDL-Anweisung `show create table` übergeben. Der Befehl wurde zur besseren Lesbarkeit formatiert.

```
$ aws athena start-query-execution 
 --query-string "show create table hms-catalog-1.hms_tpch_partitioned.lineitem" 
 --result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```

In der folgenden DDL-Beispielanweisung `show create table` wird der Parameter `Catalog` von `--query-execution-context` verwendet, um den Namen des Hive-Metastore-Katalogs `hms-catalog-1` zu übergeben. Der Befehl wurde zur besseren Lesbarkeit formatiert.

```
$ aws athena start-query-execution 
 --query-string "show create table lineitem" 
 --query-execution-context "Catalog=hms-catalog-1,Database=hms_tpch_partitioned" 
 --result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```

### DML-Anweisungen.
<a name="datastores-hive-cli-dml-statements"></a>

Die folgende DML-Beispielanweisung `select` übergibt den Katalognamen direkt an die Abfrage. Der Befehl wurde zur besseren Lesbarkeit formatiert.

```
$ aws athena start-query-execution
 --query-string "select * from hms-catalog-1.hms_tpch_partitioned.customer limit 100" 
 --result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```

In der folgenden DML-Beispielanweisung `select` wird der Parameter `Catalog` von `--query-execution-context` verwendet, um den Namen des Hive-Metastore-Katalogs `hms-catalog-1` zu übergeben. Der Befehl wurde zur besseren Lesbarkeit formatiert.

```
$ aws athena start-query-execution 
 --query-string "select * from customer limit 100" 
 --query-execution-context "Catalog=hms-catalog-1,Database=hms_tpch_partitioned" 
 --result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```

# Den externen Hive-Metastore-Konnektor von Athena ändern
<a name="datastores-hive-reference-implementation"></a>

Wenn Sie spezielle Anforderungen haben, können Sie den Athena-Connector für den externen Hive-Metastore für Ihren eigenen Gebrauch modifizieren. Athena bietet eine Referenzimplementierung des Connectors auf GitHub .com unter [https://github.com/awslabs/aws-athena-hive-metastore](https://github.com/awslabs/aws-athena-hive-metastore). In den meisten Anwendungsfällen ist es nicht erforderlich, die Referenzimplementierung zu ändern. Bei Bedarf können Sie jedoch den Quellcode ändern und die Artefakte selbst erstellen.

Die Referenzimplementierung ist ein [Apache-Maven](https://maven.apache.org/)-Projekt das die folgenden Module hat:
+ `hms-service-api` – Enthält die API-Operationen zwischen der Lambda-Funktion und den Athena-Serviceclients. Diese API-Operationen sind in der `HiveMetaStoreService`-Schnittstelle definiert. Da es sich um einen Servicevertrag handelt, sollten Sie in diesem Modul nichts ändern.
+ `hms-lambda-handler` – Eine Reihe von Standard-Lambda-Handlern, die alle Hive-Metastore-API-Aufrufe verarbeiten. Die Klasse `MetadataHandler` ist der Dispatcher für alle API-Aufrufe. Sie müssen dieses Paket nicht ändern.
+ `hms-lambda-func` – Eine Lambda-Beispielfunktion mit den folgenden Komponenten.
  + `HiveMetaStoreLambdaFunc` – Eine Lambda-Beispielfunktion, die `MetadataHandler` erweitert.
  + `ThriftHiveMetaStoreClient` – Ein Thrift-Client, der mit dem Hive-Metastore kommuniziert. Dieser Client ist für Hive 2.3.0 geschrieben. Wenn Sie eine andere Hive-Version verwenden, müssen Sie diese Klasse möglicherweise aktualisieren, um sicherzustellen, dass die Antwortobjekte kompatibel sind.
  + `ThriftHiveMetaStoreClientFactory` – Steuert das Verhalten der Lambda-Funktion. Beispielsweise können Sie Ihre eigene Gruppe von Handler-Anbietern bereitstellen, indem Sie die `getHandlerProvider()`-Methode überschreiben.
  + `hms.properties` – Konfigurieren Sie die Lambda-Funktion In den meisten Fällen müssen nur die folgenden beiden Eigenschaften aktualisiert werden.
    + `hive.metastore.uris` – der URI des Hive-Metastores im Format `thrift://<host_name>:9083`.
    + `hive.metastore.response.spill.location`: Der Amazon-S3-Speicherort zum Speichern von Antwortobjekten, wenn ihre Größe einen bestimmten Schwellenwert überschreitet (z. B. 4 MB). Der Schwellenwert wird in der Eigenschaft `hive.metastore.response.spill.threshold` definiert. Das Ändern des Standardwerts wird nicht empfohlen.
**Anmerkung**  
Diese beiden Eigenschaften können von den [Lambda-Umgebungsvariablen](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html) `HMS_URIS` und `SPILL_LOCATION` überschrieben werden. Verwenden Sie diese Variablen, anstatt den Quellcode für die Lambda-Funktion neu zu kompilieren, wenn Sie die Funktion mit einem anderen Hive-Metastore oder Überlaufspeicherort verwenden möchten.
+ `hms-lambda-layer` – Ein Maven-Assemblyprojekt, das `hms-service-api`, `hms-lambda-handler` und ihre Abhängigkeiten in eine `.zip`-Datei setzt. Die `.zip`-Datei wird als Lambda-Ebene für die Verwendung durch mehrere Lambda-Funktionen registriert.
+ `hms-lambda-rnp` – Zeichnet die Antworten einer Lambda-Funktion auf und verwendet sie dann zur Wiedergabe der Antwort. Sie können dieses Modell verwenden, um Lambda-Antworten zu Testzwecken zu simulieren.

## Entwickeln der Artefakte
<a name="datastores-hive-reference-implementation-building-the-artifacts-yourself"></a>

Nachdem Sie den Quellcode geändert haben, können Sie die Artefakte selbst erstellen und zu einem Amazon-S3-Speicherort hochladen.

Bevor Sie die Artefakte erstellen, aktualisieren Sie die Eigenschaften `hive.metastore.uris` und `hive.metastore.response.spill.location` in der `hms.properties`-Datei im `hms-lambda-func`-Modul.

Um die Artefakte zu erstellen, müssen Sie Apache Maven installiert haben und den Befehl `mvn install` ausführen. Dies erzeugt die Ebene-`.zip`-Datei im Ausgabeordner mit dem Namen `target` im Modul `hms-lambda-layer` und die Lambda-Funktions-`.jar`-Datei im Modul `hms-lambd-func`.