Verwendung von Anforderungs- und Antwortübersetzern mit Daten für einen Remotedienst

Mit Anforderungs- und Antwortübersetzern haben Sie die Möglichkeit, für Remotedienste, die von externen Funktionen verwendet werden, das Format der gesendeten oder empfangenen Daten zu verändern.

Unter diesem Thema:

Zweck

Wenn Snowflake Daten an einen Remotedienst sendet, formatiert Snowflake die Daten nach diesen Regeln. Wenn Snowflake Daten von einem Remotedienst empfängt, erwartet Snowflake, dass die Daten nach denselben Regeln formatiert werden.

Viele Remotedienste erwarten, dass sie Daten in einem anderen Format empfangen (und zurückgeben). Mit dem Feature „Anforderungs- und Antwortübersetzer für externe Funktionen“ können Sie auf bequeme Weise Anforderungen und Antworten übersetzen:

  • Konvertierung von Daten aus dem Snowflake-Format in das native Eingabeformat des Remotedienstes (Anforderungsübersetzer).

  • Konvertierung von Daten aus dem nativen Ausgabeformat des Remotedienstes in das Snowflake-Format (Antwortübersetzer).

SQL-Implementierung

Einführung

Die Übersetzung von Daten zwischen dem Snowflake-Format und dem nativen Eingabeformat des Remotedienstes erfolgt in JavaScript-UDFs (benutzerdefinierte Funktionen). In den meisten Fällen ist ein Paar von UDFs erforderlich: eine UDF zur Übersetzung der Anforderung und eine UDF zur Übersetzung der Antwort.

Snowflake ruft diese Funktionen als Teil jedes Aufrufs einer externen Funktion auf. Konkret ruft Snowflake die Funktion für den Anforderungsübersetzer (request_translator) auf, übergibt ihr die Snowflake-formatierten Daten, nimmt die zurückgegebenen Daten entgegen und sendet diese an den Remotedienst. Nachdem der Remotedienst Daten zurückgegeben hat, ruft Snowflake die Funktion für den Antwortübersetzer (response_translator) auf, um die Daten wieder in das für Snowflake verständliche Format zu konvertieren.

Aus Sicht des Benutzers ist der Aufruf einer externen Funktion mit einem Anforderungsübersetzer (request_translator) oder einem Antwortübersetzer (response_translator) derselbe wie der Aufruf jeder anderen externen Funktion. Nachdem das Programm für Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) geschrieben und als Teil der CREATE EXTERNAL FUNCTION-Anweisung angegeben wurden, werden sie automatisch aufgerufen.

Um anzugeben, welches Programm für Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) mit einer externen Funktion verwendet werden soll, fügen Sie die Klauseln REQUEST_TRANSLATOR und RESPONSE_TRANSLATOR in die CREATE EXTERNAL FUNCTION-Anweisung ein.

Beispiel:

CREATE EXTERNAL FUNCTION f(...)
    RETURNS OBJECT
    ...
    REQUEST_TRANSLATOR = my_request_translator_udf
    RESPONSE_TRANSLATOR = my_response_translator_udf
    ...
    AS <url_of_proxy_and_resource>;

Die Syntax für die Angabe des Programms für Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) als Teil einer CREATE EXTERNAL FUNCTION-Anweisung ist unten dargestellt:

CREATE EXTERNAL FUNCTION f(...)
    RETURNS OBJECT
    ...
    [ REQUEST_TRANSLATOR = <request_translator_udf_name> ]
    [ RESPONSE_TRANSLATOR = <response_translator_udf_name> ]
    ...

Wobei:

request_translator_udf_name

Der Name der Funktion mit dem Anforderungsübersetzer (request_translator).

response_translator_udf_name

Der Name der Funktion mit dem Antwortübersetzer (response_translator).

Der Anforderungsübersetzer (request_translator) und der Antwortübersetzer (response_translator) müssen jeweils einen Parameter vom Typ OBJECT aufnehmen.

Ein Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator) kann nicht nur in einem CREATE EXTERNAL FUNCTION-Befehl, sondern auch in einem ALTER EXTERNAL FUNCTION-Befehl angegeben werden. Folgende Aufgaben können ausgeführt werden:

  • Hinzufügen von Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator), wenn die externe Funktion noch keinen hat

  • Ersetzen eines vorhandenen Anforderungübersetzers (request_translator) oder Antwortübersetzers (response_translator)

  • Entfernen eines Anforderungübersetzers (request_translator) oder Antwortübersetzers (response_translator)

Das Schlüsselwort SET wird sowohl zum Hinzufügen eines neuen Anforderungsübersetzers (request_translator) bzw. Antwortübersetzers (response_translator) als auch zum Ersetzen eines vorhandenen Anforderungsübersetzers (request_translator) bzw. Antwortübersetzers (response_translator) verwendet. Die Syntax für das Hinzufügen, Ersetzen und Entfernen eines Anforderungsübersetzers (request_translator) ist unten dargestellt.

So fügen Sie einen Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator) hinzu oder ersetzen diesen:

ALTER FUNCTION ...
    SET [REQUEST_TRANSLATOR | RESPONSE_TRANSLATOR] = <udf_name>;

Wobei:

UDF-Name

Der Name einer vorher erstellten JavaScript-UDF.

So entfernen Sie einen Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator):

ALTER FUNCTION ...
    UNSET [REQUEST_TRANSLATOR | RESPONSE_TRANSLATOR];

Eine externe Funktion kann maximal einen Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) gleichzeitig haben.

Die UDFs für Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) können sichere UDFs sein.

Anforderungen

Jeder Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) muss die folgenden Anforderungen erfüllen:

  • Muss eine JavaScript-UDF sein.

  • Muss genau einen Parameter vom Typ OBJECT enthalten, der einen Batch von Zeilen repräsentiert.

  • Muss genau einen Wert vom Typ OBJECT zurückgeben, der ebenfalls einen Batch von Zeilen repräsentiert.

  • Die UDF muss skalar sein, d. h. sie gibt für jede übergebene Zeile (OBJECT) genau eine Zeile zurück.

    Bemerkung

    Obwohl Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) skalar sind, kann der an den Anforderungs- oder Antwortübersetzer übergebene OBJECT-Wert mehrere in den JSON-Code von OBJECT eingebettete Zeilen enthalten (und tut dies normalerweise auch).

  • Anzahl und Reihenfolge der vom Antwortübersetzer (request_translator) zurückgegebenen Zeilen (innerhalb des OBJECT-Werts) müssen mit Anzahl und Reihenfolge der an den Anforderungsübersetzer (response_translator) übergebenen Zeilen (innerhalb der OBJECT-Werts) übereinstimmen.

  • Der Name der Funktion von Anforderungsübersetzer (request_translator) bzw. Antwortübersetzer (response_translator) in der CREATE EXTERNAL FUNCTION- oder ALTER FUNCTION-Anweisung muss eine der folgenden Anforderungen erfüllen:

    • Der Name muss qualifiziert sein (z. B. MyDatabase.MySchema.MyJavaScriptUDF).

    • Der Name muss in derselben Datenbank und demselben Schema definiert sein wie die externe Funktion, in der er verwendet wird.

  • Bei der Angabe des Anforderungsübersetzers (request_translator) oder Antwortübersetzers (response_translator) in einer CREATE EXTERNAL FUNCTION- oder ALTER FUNCTION-Anweisung muss die UDF von Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator) bereits vorhanden sein. (Sie können nicht zuerst den Namen angeben und später die UDF erstellen – auch nicht, wenn Sie die externe Funktion erst aufrufen, wenn Sie die UDF erstellt haben.)

  • Eine UDF für Anforderungsübersetzer (request_translator) bzw. eine UDF für Antwortübersetzer (response_translator), die in einem benutzerdefinierten Übersetzungsprogramm verwendet wird, darf erst gelöscht werden, wenn sie vorher aus allen externen Funktionen entfernt wurde, in denen sie verwendet wird. (Zum Zeitpunkt des Aufrufs der externen Funktion schlägt Snowflake mit einem Fehler fehl, wenn der Anforderungsübersetzer (request_translator) bzw. der Antwortübersetzer (response_translator) nicht vorhanden ist).

  • Wenn die UDF von Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator) über ALTER FUNCTION geändert wird, muss sie dieselben Schnittstellenanforderungen erfüllen. Wenn die Schnittstellenanforderungen nicht erfüllt werden, wird vor Ausführung der externen Funktion eine Ausnahme ausgelöst.

JavaScript-Implementierung

Auf SQL-Seite wird ein OBJECT-Wert an die UDF übergegeben. Der JavaScript-Code erhält diesen Wert als JavaScript-Objekt.

Eingabeeigenschaften des Anforderungsübersetzers (request_translator)

Das JavaScript-Objekt des Anforderungsübersetzers (request_translator) heißt event und enthält die folgenden Eigenschaften:

  • „body“: Das Format des Datenfelds entspricht dem des bestehenden Snowflake-Rowset-Batches (d. h. ein Array von Zeilen).

    Beispiel:

    {
      "body": {
              "data": [
                        [0,"cat"],
                        [1,"dog"]
                      ]
              }
    }
    

    Die vorhandenen Daten werden unter dem äußeren Text geschachtelt.

  • „serviceUrl“: Die serviceUrl ist die definierte URL der externen Funktion, die aufgerufen werden soll.

  • „contextHeaders“: Das Feld contextHeaders ist ein Objekt, das alle kontextbezogenen Kopfzeilen enthält, wobei die Namen die Feldnamen sind. Das Objekt könnte zum Beispiel den Feldnamen „SF_CONTEXT_CURRENT_DATABASE“ enthalten, und der entsprechende Wert wäre eine Zeichenfolge, die den aktuellen Datenbanknamen enthält.

Eingabeeigenschaften des Antwortübersetzers (response_translator)

Das Anforderungsübersetzer (request_translator) gibt ein Objekt mit Feldern zurück, die für die Kommunikation mit dem API-Gateway des externen Dienstes verwendet werden. Dieses Objekt hat drei optionale Felder:

  • „body“: Das Feld body definiert den eigentlichen Text, der an den Dienst übergeben werden soll. Wenn dies nicht definiert ist, ist kein Text vorhanden. Dieser Wert für den Text muss eine Zeichenfolge oder ein JSON-Objekt in dem Format sein, das der Remotedienst erwartet. Wenn der Wert eine Zeichenfolge ist, kann diese Zeichenfolge eine interne Struktur enthalten (z. B. JSON-kompatibel sein). Handelt es sich bei dem Wert um ein JSON-Objekt, wird dieses Objekt in eine Zeichenfolge umgewandelt, sodass es als Teil der HTTP POST-Befehlszeichenfolge eingefügt werden kann.

  • „urlSuffix“: Der Anforderungsübersetzer (request_translator) kann das Suffix von „serviceUrl“ festlegen, das an das Ende der „serviceUrl“ angehängt wird. Dieses Suffix darf auch Abfrageparameter enthalten. Parameternamen und -werte müssen URL-codiert sein. Wenn Sie z. B. einen Parameter mit dem Namen a auf den Wert my param setzen möchten, müssen Sie das Leerzeichen URL-codieren, sodass der Parameter ?a=my%20param lauten würde.

  • translatorData: Dieses Feld wird vom Anforderungsübersetzer (request_translator) an den Antwortübersetzer (response_translator) übergeben. Dieses Feld kann Kontextinformationen übergeben, wie z. B. den Eingabetext, die Dienst-URL oder das Suffix oder die Kontext-Header.

Alle drei Felder sind optional. In der Praxis geben die meisten Anforderungsübersetzer (request_translator) jedoch zumindest die „body“-Daten zurück.

Eingabeeigenschaften des Antwortübersetzers (response_translator)

Der Eingabeparameter für den Antwortübersetzer (response_translator) ist ein Objekt. In diesem Beispiel wird EVENT verwendet, das zwei Eigenschaften enthält:

  • „body“: Die Antwort, die aus der Antwort des externen Dienstes decodiert werden muss.

  • „translatorData“: Wenn dieses Feld vom Anforderungsübersetzer (request_translator) zurückgegeben wird, übergibt Snowflake es an den Antwortübersetzer (response_translator).

Ausgabeeigenschaften des Antwortübersetzers (response_translator)

Die Antwort des Antwortübersetzers (response_translator) wird als Objekt unter dem „body“-Element zurückgegeben. Das Format ist das vorhandene Format der externen Funktion (Array von Zeilen). Beispiel:

{
  "body": {
          "data": [
                    [0, "Life"],
                    [1, "the universe"],
                    [2, "and everything"]
                  ]
           }
}

Beispiel für Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator)

Dieses Beispiel zeigt, wie ein Anforderungsübersetzer (request_translator) und ein Antwortübersetzer (response_translator) verwendet werden, um Daten in das Format zu konvertieren, das von einem externen Dienst zur Ausführung von Stimmungsanalysen benötigt wird, wie z. B. Amazon Comprehend BatchDetectSentiment. Der Anforderungsübersetzer (request_translator) formt die HTTP-Anfrage so, dass sie mit dem Format übereinstimmt, das der Backend-Dienst erwartet.

Setup

Wählen Sie eine Rolle, die über die Berechtigung zum Erstellen externer Funktionen verfügt.

USE ROLE ACCOUNTADMIN;

Geben Sie an, welches Warehouse, welche Datenbank und welches Schema verwendet werden sollen.

USE WAREHOUSE w;
USE DATABASE a;
USE SCHEMA b;

Erstellen Sie eine Tabelle, die Ihre Testsätze enthält.

CREATE TABLE demo(vc varchar);
INSERT INTO demo VALUES('Today is a good day'),('I am feeling mopey');

Für die Verwendung von Übersetzerprogrammen ist ein API-Gateway erforderlich. In diesem Beispiel wird ein API-Gateway verwendet, das bereits so konfiguriert ist, dass es mit dem Stimmungsanalyse-Dienst kommunizieren kann. Weitere Informationen zur Integration mit einem Amazon Web Services (AWS)-Service als Backend finden Sie unter API-Integrationsanforderung mit API-Gateway-Konsole einrichten in der AWS-Dokumentation.

Es empfiehlt sich, erst die API-Integration erfolgreich einzurichten, bevor Sie Übersetzerprogramme hinzufügen.

Der Anforderungstext vor dem Hinzufügen eines Anforderungsübersetzers (request_translator)

Hier ein Beispiel für eine externe Funktion, die keinen Anforderungsübersetzer (request_translator) oder Antwortübersetzer (response_translator) hat.

CREATE OR REPLACE EXTERNAL FUNCTION ComprehendSentiment(thought varchar)
RETURNS VARIANT
API_INTEGRATION = aws_comprehend_gateway
AS 'https://<MY_GATEWAY>.execute-api.us-east-1.amazonaws.com/test/comprehend_proxy';

Rufen Sie die externe Funktion mit Ihren Testdaten aus der Demo-Tabelle auf.

SELECT ComprehendSentiment(vc), vc FROM demo;

Der generierte Anforderungstext verwendet das Snowflake-Datenformat für externe Funktionen, das wie folgt aussieht:

{"body":{"data:" [[0, "Today is a good day"],[1,"I am feeling mopey"]]}}

Der externe Stimmungsanalyse-Dienst erwartet jedoch ein anderes Format, das die Sprache und ein Array von Zeichenfolgen angibt.

{"body": { Language: "en", TextList: [ "Today is a good day", "I am feeling mopey"]}}

Im nächsten Abschnitt fügen Sie einen Anforderungsübersetzer (request_translator) hinzu, um den Anforderungstext in das gewünschte Format zu ändern.

Anforderungsübersetzer (request_translator)

Der Anforderungsübersetzer (request_translator) empfängt Eingaben im Snowflake-Datenformat und konvertiert diese in das Format, das der externe Dienst benötigt.

CREATE OR REPLACE FUNCTION AWSComprehendrequest_translator(EVENT OBJECT)
RETURNS OBJECT
LANGUAGE JAVASCRIPT AS
'
var textlist = []
for(i = 0; i < EVENT.body.data.length; i++) {
   let row = EVENT.body.data[i];
   // row[0] is the row number and row[1] is the input text.
   textlist.push(row[1]); //put text into the textlist
}
// create the request for the service. Also pass the input request as part of the output.
return { "body": { "LanguageCode": "en", "TextList" : textlist }, "translatorData": EVENT.body }
';

Der Anforderungsübersetzer (request_translator) durchläuft jede der Eingabezeilen in einer Schleife. Für jede Zeile wird die Zeichenfolge, die sich in Zeile[1] befindet, dem Array textlist hinzugefügt. Der Wert in Zeile[0] ist die Zeilennummer, er kann ignoriert werden.

Der Anforderungsübersetzer (request_translator) gibt JSON-Text zurück, der den Sprachcode und die Textliste enthält, die mit den Anforderungen des externen Dienstes übereinstimmen. Der Anforderungsübersetzer (request_translator) gibt auch Daten über das Feld translatorData zurück. Dieses wird vom Antwortübersetzer (response_translator) verwendet. In diesem Beispiel senden Sie die ursprünglichen Eingabedaten. Sie verwenden die Länge der Eingabedaten im Antwortübersetzer (response_translator), um zu wissen, wie viele Eingabeanforderungen es gab.

Testen Sie den Anforderungsübersetzer (request_translator), indem Sie ihn direkt aufrufen.

SELECT AWSComprehendrequest_translator(parse_json('{"body":{"data": [[0, "I am so happy we got a sunny day for my birthday."], [1, "$$$$$."], [2, "Today is my last day in the old house."]]}}'));

Der Anforderungsübersetzer (request_translator) bringt den Text in die Form, die der externe Dienst erwartet.

{"body":{
   "LanguageCode": "en",
   "TextList": [
      "I am so happy we got a sunny day for my birthday.",
      "$$$$$.",
      "Today is my last day in the old house."
               ]
         },
   "translatorData": {
      "data": [[0, "I am so happy we got a sunny day for my birthday."],
               [1, "$$$$$."],
               [2, "Today is my last day in the old house."]]
                     }
}

Der Antworttext vor dem Hinzufügen eines Antwortübersetzers (response_translator)

Ein Antworttext des externen Dienstes sieht etwa wie folgt aus.

{"body":{
   "ErrorList": [ { "ErrorCode": 57, "ErrorMessage": "Language unknown", "Index": 1} ],
   "ResultList":[ { "Index": 0, "Sentiment": "POSITIVE",
                    "SentimentScore": { "Mixed": 25, "Negative": 5, "Neutral": 1, "Positive": 90 }},
                  { "Index": 2, "Sentiment": "NEGATIVE",
                    "SentimentScore": { "Mixed": 25, "Negative": 75, "Neutral": 30, "Positive": 20 }}
                ]
         }
}

Antwortübersetzer (response_translator)

Der Antwortübersetzer (response_translator) verarbeitet die Ergebnisse, die Sie vom externen Dienst zurückerhalten. Die Ergebnisse enthalten eine Kombination aus Fehlern im ErrorList-Objekt und Ergebnissen im ResultList-Objekt. Der Code des Antwortübersetzers (response_translator) kombiniert diese Ergebnisse zu einem vollständigen Set, das mit der Reihenfolge der Zeilen übereinstimmt, die an den externen Dienst übergeben wurden. Der Antwortübersetzer (response_translator) liefert die Ergebnisse im Snowflake-Format.

CREATE OR REPLACE FUNCTION AWSComprehendresponse_translator(EVENT OBJECT)
RETURNS OBJECT
LANGUAGE JAVASCRIPT AS
'
// Combine the scored results and the errors into a single list.
var responses = new Array(EVENT.translatorData.data.length);
// output format: array of {
// "Sentiment": (POSITIVE, NEUTRAL, MIXED, NEGATIVE, or ERROR),
// "SentimentScore": <score>, "ErrorMessage": ErrorMessage }.
// If error, errorMessage is set, otherwise sentimentScore is set.
// Insert good results into proper position.
for(i = 0; i < EVENT.body.ResultList.length; i++) {
   let row = EVENT.body.ResultList[i];
   let result = [row.Index, {"Sentiment": row.Sentiment, "SentimentScore": row.SentimentScore}]
   responses[row.Index] = result
}
// Insert errors.
for(i = 0; i < EVENT.body.ErrorList.length; i++) {
   let row = EVENT.body.ErrorList[i];
   let result = [row.Index, {"Sentiment": "Error", "ErrorMessage": row.ErrorMessage}]
   responses[row.Index] = result
}
return { "body": { "data" : responses } };
';

Der Antwortübersetzer (response_translator) initialisiert ein Array namens responses mit der Größe der Eingabe aus der Länge des Arrays translatorData. Sie haben translatorData vom Anforderungsübersetzer (request_translator) an den Antwortübersetzer (response_translator) gesendet, um die ursprüngliche Liste der Testzeichenfolgen zu übergeben.

Der Antwortübersetzer (response_translator) durchläuft alle Ergebnisse, die keine Fehler sind, in einer Schleife und trägt sie in die Ergebnisliste ein. Anschließend werden die Fehlerergebnisse in einer Schleife durchlaufen und in die Ergebnisliste aufgenommen. Die Ergebnisliste hat eine Indexposition, die darüber informiert, um welchen Eintrag es sich handelt. Die Reihenfolge der erstellten Ergebnisse muss mit der Eingabereihenfolge übereinstimmen. Die Ergebnisliste enthält auch die Stimmungsinformationen.

Nachdem alle Antworten gesammelt wurden, werden sie in einem JSON-Text in dem von Snowflake erwarteten Format zurückgegeben.

Testen Sie den Antwortübersetzer (response_translator), indem Sie ihn direkt aufrufen.

SELECT AWSComprehendresponse_translator(
    parse_json('{
        "translatorData": {
            "data": [[0, "I am so happy we got a sunny day for my birthday."],
                    [1, "$$$$$."],
                    [2, "Today is my last day in the old house."]]
                          }
        "body": {
            "ErrorList":  [ { "ErrorCode": 57,  "ErrorMessage": "Language unknown",  "Index": 1 } ],
            "ResultList": [
                            { "Index": 0,  "Sentiment": "POSITIVE",
                              "SentimentScore": { "Mixed": 25,  "Negative": 5,  "Neutral": 1,  "Positive": 90 }
                            },
                            { "Index": 2, "Sentiment": "NEGATIVE",
                              "SentimentScore": { "Mixed": 25,  "Negative": 75,  "Neutral": 30,  "Positive": 20 }
                            }
                          ]
            },
        }'
    )
);

Es wird ein JSON-Text mit dem korrekten Format zurückgegeben.

Anforderungsübersetzer (request_translator) und Antwortübersetzer (response_translator) zu externer Funktion hinzufügen

Fügen Sie in der externen Funktion den Anforderungsübersetzer (request_translator) und den Antwortübersetzer (response_translator) hinzu, sodass sie automatisch aufgerufen werden, wenn die externe Funktion ausgeführt wird.

CREATE OR REPLACE EXTERNAL FUNCTION ComprehendSentiment(thought varchar)
RETURNS VARIANT
API_INTEGRATION = aws_comprehend_gateway
Request_translator = db_name.schema_name.AWSComprehendrequest_translator
Response_translator = db_name.schema_name.AWSComprehendresponse_translator
AS 'https://<MY_GATEWAY>.execute-api.us-east-1.amazonaws.com/test/comprehend_proxy';

Sie können die Funktion beschreiben, um Informationen über sie zu erhalten.

DESCRIBE FUNCTION ComprehendSentiment(VARCHAR);

Externe Funktion aufrufen

Testen Sie die externe Funktion, indem Sie sie mit einem einzelnen Satz aufrufen.

SELECT ComprehendSentiment('Today is a good day');

Sie sehen die Ergebnisse der Stimmungsanalyse.

{"Sentiment": "POSITIVE",
 "SentimentScore":{"Mixed":0.002436627633869648,
                   "Negative":0.0014803812373429537,
                   "Neutral":0.015923455357551575,
                   "Positive": 0.9801595211029053}}

Testen Sie die externe Funktion, indem Sie sie mit mehreren Sätzen aufrufen. Verwenden Sie dieselbe Tabelle demo, die Sie zuvor erstellt haben.

SELECT ComprehendSentiment(vc), vc FROM demo;

Die Ergebnisse der Stimmungsanalyse werden angezeigt.

A table showing the sentiment analysis results.

Beim Aufruf der externen Funktion konvertierte der Anforderungsübersetzer (request_translator) die Daten automatisch in das für den externen Dienst erforderliche Format. Anschließend konvertierte der Antwortübersetzer (response_translator) die Antwort des externen Dienstes automatisch zurück in das von Snowflake benötigte Format.

Tipps zum Testen von Anforderungsübersetzern (request_translator) und Antwortübersetzern (response_translator)

  • Testfallwerte sind in der Regel OBJECT-Werte (Collections von Schlüssel-Wert-Paaren). Diese sollten so formatiert werden, dass sie die Anforderungen dieser Regeln erfüllen.

  • Sie können das Testen des Programms Ihres Anforderungsübersetzers (request_translator) oder Antwortübersetzers (response_translator) damit beginnen, dass Sie eine in eine Zeichenfolge konvertierte Beispieleingabe übergeben. Beispiel:

    select my_request_translator_function(parse_json('{"body": {"data": [ [0,"cat",867], [1,"dog",5309] ] } }'));
    

    (Die Eingabe für PARSE_JSON() muss eine JSON-formatierte Zeichenfolge sein).

  • Testen Sie falls erforderlich mit NULL-Werten.

    • Fügen Sie mindestens einen SQL NULL-Wert in Ihre Testfälle ein.

    • Fügen Sie mindestens einen JSON NULL-Wert in Ihre Testfälle ein.

  • Das Übersetzen einer Anforderung und das Übersetzen einer Antwort sind oft gegenläufige Prozesse. Konzeptionell:

    my_response_translator_udf(my_request_translator_udf(x)) = x
    

    Mithilfe dieser Eigenschaft können Sie testen, ob die Datenformate der Programme für Anforderungsübersetzer (request_translator) und zugehörigem Antwortübersetzer (response_translator) übereinstimmen. Erstellen Sie eine Tabelle mit guten Testwerten, und führen Sie dann einen Befehl ähnlich wie dem folgenden aus:

    SELECT test_case_column
        FROM test_table
        WHERE my_response_translator_udf(my_request_translator_udf(x)) != x;
    

    Die Abfrage sollte keine Zeilen zurückgeben.

    Beachten Sie, dass das Übersetzen einer Anforderung und das Übersetzen einer Antwort nicht immer genau umgekehrt sind. Ein Beispiel dafür, dass sie nicht umgekehrt sein können, finden Sie in der Dokumentation zur Funktion TO_JSON() im Abschnitt „Nutzungshinweise“.