Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Textsentiment analysieren

Die Funktion ai.analyze_sentiment ist ein integriertes AlloyDB AI-Tool, mit dem die Stimmung von Text als positiv, negativ oder neutral klassifiziert wird. Durch die direkte Einbettung dieser Funktion in die Datenbank können Sie mit AlloyDB for PostgreSQL das Sprachverständnis von Gemini in Echtzeit auf unstrukturierte Unternehmensdaten anwenden. Dazu verwenden Sie SQL, das array- und cursorbasierte Batchverarbeitung über Tausende von Zeilen hinweg unterstützt, ohne dass komplexe ETL-Pipelines (Extrahieren, Transformieren und Laden) erforderlich sind.

Mit ai.analyze_sentiment können Sie unstrukturierte Produktrezensionen und Kundenfeedback klassifizieren oder Erwähnungen in sozialen Medien analysieren, um die Markenwahrnehmung zu messen.

Hinweis

Prüfen Sie, ob Sie die folgenden Anforderungen erfüllen, bevor Sie die Funktion ai.analyze_sentiment verwenden.

Erweiterung aktivieren

Prüfen Sie, ob die aktuelle Version der google_ml_integration.enable_preview_ai_functions-Erweiterung (Version 1.5.7 oder höher) installiert ist und die Vorschaufunktion aktiviert ist.

Verwenden Sie den Befehl SET, um das Flag google_ml_integration.enable_preview_ai_functions in AlloyDB zu aktivieren. Dieses Flag steuert den Zugriff auf KI-Funktionen in der Vorabversion, z. B. ai.analyze_sentiment.

Die google_ml_integration-Erweiterung muss mindestens die Version 1.6.1 haben. Sie können die Version mit dem folgenden Befehl prüfen:
```
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
```
Wenn Sie ein Upgrade auf eine Version durchführen müssen, die diese Vorabversionen enthält, rufen Sie Folgendes auf:
```
CALL google_ml.upgrade_to_preview_version();
```
Aktivieren Sie das Flag für die aktuelle Sitzung oder für die gesamte Datenbank. Führen Sie den folgenden Befehl aus, um das Flag für Ihre aktuelle Sitzung zu aktivieren:
```
SET google_ml_integration.enable_preview_ai_functions = 'on';
```
Für diese Änderung ist kein Neustart der Datenbank erforderlich. Der Standardwert dieses Flags ist off.

Beispieltabelle erstellen

Wenn Sie die Beispiele für die Funktion zur Sentimentanalyse in diesem Dokument nachvollziehen möchten, erstellen Sie eine Tabelle und füllen Sie sie mit den folgenden Filmrezensionen.

CREATE TABLE IF NOT EXISTS reviews (
    id INT PRIMARY KEY,
    review_content TEXT
);

INSERT INTO reviews (id, review_content) VALUES 
(1, 'This movie is very good'),
(2, 'The actors play the parts well'),
(3, 'I like the music in this film'),
(4, 'The story is easy to follow'),
(5, 'Many people will enjoy this show'),
(6, 'The film is too long'),
(7, 'I do not like the ending'),
(8, 'This movie is very boring'),
(9, 'The story is okay'),
(10, 'Some parts are fine');

Sentiment eines einzelnen Strings analysieren

Wenn Sie die Stimmung einer einzelnen Texteingabe bewerten möchten, verwenden Sie die skalare Version von ai.analyze_sentiment.

SELECT ai.analyze_sentiment(
  input => 'TEXT_CONTENT',
  model_id => 'MODEL_ID' -- Optional. The default value is gemini-3.5-flash-lite.
);

Im folgenden Beispiel wird gezeigt, wie Sie eine Sentimentanalyse auf Zeilenebene für Textdaten durchführen, die in einer Tabelle mit dem Namen reviews mit den Spalten id und review_content zum Speichern von Rezensionsdaten gespeichert sind. Im Beispiel wird eine SELECT-Abfrage ausgeführt, die die Funktion ai.analyze_sentiment() auf die Spalte review_content für jede Zeile in der Tabelle anwendet. Diese Funktion verarbeitet jede Rezension einzeln und gibt die berechnete Stimmung (positive, negative oder neutral) zurück.

--- Row Level sentiment analysis
SELECT ai.analyze_sentiment(review_content) FROM reviews;

Hier sehen Sie die Beispielausgabe:

 id | analyze_sentiment
----+-------------------
  1 | positive
  2 | positive
  3 | positive
  4 | positive
  5 | positive
  6 | negative
  7 | negative
  8 | negative
  9 | neutral
 10 | neutral

Sentiment in Batches analysieren

Für eine bessere Leistung bei größeren Datasets sollten Sie die arraybasierte Version der Funktion verwenden, um mehrere Strings in einem einzigen Aufruf zu verarbeiten.

SELECT ai.analyze_sentiment(
  inputs => ARRAY['TEXT_1', 'TEXT_2'],
  batch_size => BATCH_SIZE, -- Optional. The default value is 10.
  model_id => 'MODEL_ID' -- Optional. The default value is gemini-3.5-flash-lite.
);

Im folgenden Beispiel wird die Stimmung von Kundenrezensionen aus einer Tabelle namens reviews analysiert.

WITH sentiment_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.analyze_sentiment(
    inputs => array_agg( 'Please analyze the sentiment of this review: ' || review_content
      ORDER BY id),
    batch_size => 15) as sentiments 
FROM reviews
),
correlated_results AS (
    SELECT ids[i] as id, sentiments[i] as sentiment
    FROM sentiment_results,
    generate_series(1, array_length(ids, 1)) AS i
)
SELECT reviews.id, correlated_results.sentiment as sentiment
FROM reviews
JOIN correlated_results ON reviews.id = correlated_results.id
ORDER BY reviews.id DESC;

Hier sehen Sie die Beispielausgabe:

 id | sentiment
----+-----------
  1 | positive
  2 | positive
  3 | positive
  4 | positive
  5 | positive
  6 | negative
  7 | negative
  8 | negative
  9 | neutral
 10 | neutral

Stimmung mit Cursorn analysieren

Die cursorbasierte Funktion ist für die effiziente Verarbeitung großer Datasets gedacht, da das System Daten in überschaubaren Batches durch das KI-Modell streamen kann, ohne dass alle Daten auf einmal in den Arbeitsspeicher geladen werden müssen.

Die Funktionssignatur für die cursorbasierte Version von ai.analyze_sentiment sieht so aus:

CREATE OR REPLACE FUNCTION ai.analyze_sentiment(
    input_cursor REFCURSOR,
    batch_size INT DEFAULT NULL,
    model_id VARCHAR(100) DEFAULT NULL)
  RETURNS REFCURSOR

Sie können jetzt die Funktion ai.analyze_sentiment verwenden. Da ein REFCURSOR erwartet wird, müssen Sie einen Cursor für die Eingabedaten öffnen, die Sie analysieren möchten. In diesem Beispiel analysieren Sie die review_content aus der Tabelle reviews.

Im folgenden Beispiel wird gezeigt, wie Daten mithilfe eines Cursors Zeile für Zeile an die Funktion ai.analyze_sentiment übergeben werden:

-- Run the cursor logic in an anonymous PL/pgSQL block
DO $$
DECLARE
    -- Declare a cursor for the review content
    review_cursor REFCURSOR;
    result_cursor REFCURSOR;
    result_record RECORD;
BEGIN
    -- Open the cursor with the query to fetch the review content
    OPEN review_cursor FOR SELECT review_content FROM reviews;

    -- Call the AI function, passing the cursor
    -- This function will return another cursor containing the results
    result_cursor := ai.analyze_sentiment(
            input_cursor => review_cursor,
        batch_size => 5  -- Optional: Process in batches of 5. The default value is 10.
    );

    -- Fetch and display results from the result_cursor
    LOOP
        FETCH result_cursor INTO result_record;
        EXIT WHEN NOT FOUND;
        RAISE NOTICE '%', result_record;
    END LOOP;

    -- Close the cursors
    CLOSE review_cursor;
    CLOSE result_cursor;
-- End the anonymous block
END $$;

Die Ausgabe sieht so aus:

      review_content            | sentiment | score
------------------------------+-----------+-------
This movie is very good        | Positive  |   0.9
The actors play the parts well | Positive  |   0.8
I like the music in this film  | Positive  |   0.8
The story is easy to follow    | Positive  |   0.7
Many people will enjoy this show | Positive  |   0.8
The film is too long           | Negative  |  -0.6
I do not like the ending       | Negative  |  -0.8
This movie is very boring      | Negative  |  -0.9
The story is okay              | Neutral   |   0.1
Some parts are fine            | Neutral   |   0.2