Analisar o sentimento do texto

A função ai.analyze_sentiment é uma ferramenta de IA integrada do AlloyDB AI que classifica o sentimento do texto como positivo, negativo ou neutro. Ao incorporar esse recurso diretamente no banco de dados, o AlloyDB para PostgreSQL permite aplicar a compreensão de linguagem do Gemini a dados empresariais não estruturados em tempo real usando SQL, com suporte ao processamento em lote baseado em matriz e cursor em milhares de linhas sem pipelines complexos de extração, transformação e carregamento (ETL).

É possível usar ai.analyze_sentiment para classificar avaliações do produto não estruturadas e feedback dos clientes ou analisar menções de redes sociais para avaliar a percepção da marca.

Antes de começar

Confira se você atende aos requisitos a seguir antes de usar a função ai.analyze_sentiment.

Ativar a extensão

Confira se você tem a versão mais recente da extensão google_ml_integration.enable_preview_ai_functions (versão 1.5.7 ou mais recente) instalada com a funcionalidade de visualização ativada.

Para ativar a flag google_ml_integration.enable_preview_ai_functions no AlloyDB, use o comando SET. Essa flag controla o acesso a funções de IA de visualização, como ai.analyze_sentiment.

  1. Confira se a google_ml_integration extension é a versão 1.5.7 ou mais recente. Para verificar a versão, execute o seguinte:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Se você precisar fazer upgrade para uma versão que inclua essas funções de visualização, chame o seguinte:

    CALL google_ml.upgrade_to_preview_version();

  2. Ative a flag para a sessão atual ou para todo o banco de dados. Para ativar a flag da sessão atual, execute o seguinte:

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Essa mudança não exige a reinicialização do banco de dados. O valor padrão dessa flag é off.

Criar uma tabela de exemplo

Para seguir os exemplos de função de análise de sentimento neste documento, crie uma tabela e preencha-a com as seguintes avaliações de filmes.

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');

Analisar o sentimento de uma única string

Para avaliar o sentimento de uma única entrada de texto, use a versão escalar de ai.analyze_sentiment.

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

O exemplo a seguir mostra como realizar a análise de sentimento no nível da linha em dados de texto armazenados em uma tabela chamada reviews com colunas id e review_content para armazenar dados de avaliação. O exemplo executa uma consulta SELECT que aplica a função ai.analyze_sentiment() à coluna review_content de cada linha na tabela. Essa função processa cada avaliação individualmente e retorna o sentimento calculado (positive, negative ou neutral).

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

Confira abaixo um exemplo da saída:

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

Analisar o sentimento em lotes

Para melhorar a performance em conjuntos de dados maiores, use a versão baseada em matriz da função para processar várias strings em uma única chamada.

SELECT ai.analyze_sentiment(
  prompts => 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-2.5-flash-lite.
);

O exemplo a seguir analisa o sentimento das avaliações de clientes de uma tabela chamada reviews.

WITH sentiment_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.analyze_sentiment( 
    prompts => 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;

Confira abaixo um exemplo da saída:

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

Analisar o sentimento usando cursores

A função baseada em cursor é destinada ao processamento eficiente de grandes conjuntos de dados, porque permite que o sistema transmita dados pelo modelo de IA em lotes gerenciáveis sem exigir que todos os dados sejam carregados na memória de uma só vez.

A assinatura da função para a versão baseada em cursor de ai.analyze_sentiment é a seguinte:

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

Agora é possível usar a função ai.analyze_sentiment. Como ela espera um REFCURSOR, é necessário abrir um cursor para os dados de entrada que você quer analisar. Neste exemplo, você analisa o review_content da tabela reviews.

O exemplo a seguir mostra como transmitir dados para a função ai.analyze_sentiment linha por linha usando um cursor:

-- 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(
        prompt => 'Analyze the sentiment of the following movie review:',
        input_cursor => review_cursor,
        batch_size => 5  -- Optional: Process in batches of 5
    );

    -- 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 $$;

Confira abaixo a saída:

      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

A seguir