ביצוע שאילתות SQL חכמות באמצעות פונקציות AI

פונקציות AI של AlloyDB משלבות מודלים גדולים של שפה (LLM) כמו Gemini ישירות עם הנתונים של AlloyDB ל-PostgreSQL, כדי שתוכלו לשלב שפה טבעית עם שאילתות SQL. בעזרת פונקציות מובנות לסינון סמנטי (ai.if), דירוג סמנטי (ai.rank) ויצירת טקסט (ai.generate), האפליקציה יכולה לעבד נתונים באמצעות מודלי AI גם בחיפושים בשורה אחת וגם בפעולות במסד נתונים בקנה מידה גדול.

הערה: ב-AlloyDB לא נגבה תשלום על קריאות לפונקציות AI. עם זאת, כשאתם קוראים למודלים ולשירותים של Gemini Enterprise Agent Platform, של צד שלישי או באירוח עצמי (למשל, לחיפוש היברידי) ממסד הנתונים שלכם, ספק המודל או התשתית מחייב אתכם ישירות. למידע נוסף על העלויות של Gemini Enterprise Agent Platform, קראו את המאמר תמחור.

יש שלוש קטגוריות של פונקציות AI, והן נבדלות זו מזו באופן שבו הן מטפלות בנתוני הקלט ובהקצאת הזיכרון: פונקציות סקלריות, פונקציות מבוססות-מערך ופונקציות סמן. הבחירה בפונקציית ה-AI המתאימה תלויה בהיקף הנתונים ובדרישות הביצועים שלכם. בטבלה הבאה מפורט מידע על הפונקציות האלה ועל תרחישי השימוש שלהן:

קטגוריה	תיאור	תרחיש שימוש מומלץ
סקלר	מיועד לעיבוד בסיסי, אחד על אחד. מקבלת קלט יחיד ומחזירה פלט יחיד.	השימוש בפונקציה הזו מתאים כשרוצים פונקציה בסיסית שמספקת ביצועים סבירים לשאילתות שמבצעות מספר קטן – פחות מ-50 – של בקשות להפעלת פונקציה סקלרית.
מבוסס-מערך	מעבדת נתונים כמערך של שורות בקריאה אחת לפונקציה. מקבלת מערך כקלט ומחזירה מערך כפלט.	השימוש מתאים למערכי נתונים קטנים עד בינוניים, שבהם כל מערך השורות שעומדות בדרישות יכול להיכנס למגבלות הזיכרון. התכונה הזו מספקת תפוקה גבוהה לפעולות שמבוססות על קבוצות.
סמן	מקבלת סמן כקלט ומחזירה סמן כפלט.	הפונקציה מתאימה לעיבוד של מספר גדול של שורות – למשל, 10,000 שורות.

לפני שמתחילים

• מוודאים שהתוסף google_ml_integration מותקן ושהגרסה שלו היא 1.5.2 ואילך. כדי לשפר עוד יותר את הביצועים באמצעות פונקציות מבוססות-מערך, צריך להשתמש בגרסה 1.5.4 ואילך.
• מוודאים שהדגל google_ml_integration.enable_ai_query_engine מוגדר לערך on.
• איך משלבים עם Gemini Enterprise Agent Platform
• להשתמש במודל Gemini שנתמך באזור שלכם. ‫Gemini 2.5 Flash Lite הוא המודל שמוגדר כברירת מחדל במנוע השאילתות של ה-AI. אם לא מציינים מודל Gemini בשאילתה, מנוע השאילתות של ה-AI בוחר את מודל ברירת המחדל עבור השאילתות.

איך משלבים את Agent Platform ומתקינים את התוסף

1. להגדיר את הגישה של המשתמשים למודלים של Agent Platform.
2. מוודאים שמותקנת הגרסה העדכנית של google_ml_integration.

   1. כדי לבדוק את הגרסה המותקנת, מריצים את הפקודה הבאה:

      SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
      extversion 
      ------------
      1.5.2
      (1 row)

   2. אם התוסף לא מותקן או שהגרסה המותקנת היא גרסה ישנה יותר מ-1.5.2, צריך לעדכן את התוסף.

      CREATE EXTENSION IF NOT EXISTS google_ml_integration;
      ALTER EXTENSION google_ml_integration UPDATE;

      אם נתקלתם בבעיות בהרצת הפקודות הקודמות, או אם התוסף לא עודכן לגרסה 1.5.2 אחרי שהרצתם את הפקודות הקודמות, פנו אל Google Cloud התמיכה.

3. כדי להשתמש בפונקציונליות של מנוע השאילתות של AlloyDB AI, מגדירים את הדגל google_ml_integration.enable_ai_query_engine לערך on.

   SQL

   1. הפעלת מנוע השאילתות מבוסס ה-AI בסשן הנוכחי.
      

      SET google_ml_integration.enable_ai_query_engine = on;

   2. הפעלת תכונות במסד נתונים ספציפי בכל הסשנים.
      

      ALTER DATABASE DATABASE_NAME SET google_ml_integration.enable_ai_query_engine = 'on';

   3. הפעלת מנוע השאילתות מבוסס ה-AI למשתמש ספציפי בכל הסשנים ומסדי הנתונים.
      

      ALTER ROLE postgres SET google_ml_integration.enable_ai_query_engine = 'on';

   המסוף

   כדי לשנות את הערך של הדגל google_ml_integration.enable_ai_query_engine, פועלים לפי השלבים במאמר הגדרת דגלים של מסד נתונים במופע.

   gcloud

   כדי להשתמש ב-ה-CLI של gcloud, אפשר להתקין ולהפעיל את Google Cloud CLI, או להשתמש ב-Cloud Shell.

   אפשר לשנות את הערך של הדגל google_ml_integration.enable_ai_query_engine. מידע נוסף זמין במאמר הגדרת דגלים לניהול מסד נתונים של מכונה.

   gcloud alloydb instances update INSTANCE_ID \
     --database-flags google_ml_integration.enable_ai_query_engine=on \
     --region=REGION_ID \
     --cluster=CLUSTER_ID \
     --project=PROJECT_ID

להשתמש במודל Gemini שנתמך באזור שלכם

אם אשכול AlloyDB ל-PostgreSQL שלכם נמצא באזור שבו אין תמיכה ב-gemini-2.5-flash-lite אתם יכולים להשתמש באחד ממודלי Gemini האחרים שזמינים באזור שלכם באמצעות model_id parameter.

הערה: חשוב לוודא שהמודל זמין באזור שלכם. מידע נוסף זמין במאמר Gemini 2.5 Flash Lite.

לחלופין, אפשר לרשום נקודת קצה של מודל Gemini ולספק את מזהה המודל הזה למפעילי ה-AI. מידע נוסף זמין במאמר רישום וקריאה למודלים מרוחקים של AI באמצעות ניהול נקודות קצה של מודלים.

בדוגמה הבאה אפשר לראות איך רושמים עוד נקודת קצה של Gemini. בדוגמה הזו, נקודת הקצה השנייה של Gemini היא נקודת הקצה הגלובלית של gemini-2.5-flash-lite. אתם יכולים להשתמש במודל הרשום הזה עם אופרטורים של AI על ידי העברת model_id => 'gemini-2.5-flash-lite-global' כארגומנט נוסף.

CALL
  google_ml.create_model(
    model_id => 'gemini-2.5-flash-lite-global',
    model_type => 'llm',
    model_provider => 'google',
    model_qualified_name => 'gemini-2.5-flash-lite',
    model_request_url =>  'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-2.5-flash-lite:generateContent',
    model_auth_type => 'alloydb_service_agent_iam'
);

שימוש במודלים של Gemini 3.0

חלק מהמודלים של Gemini, כמו gemini-3.0-pro-preview, זמינים רק דרך נקודת הקצה הגלובלית. כדי לרשום מודלים כאלה:

CALL
  google_ml.create_model(
    model_id => 'gemini-3-preview-model',
    model_request_url => 'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3-pro-preview:generateContent',
    model_qualified_name => 'gemini-3-pro-preview',
    model_provider => 'google',
    model_type => 'llm',
    model_auth_type => 'alloydb_service_agent_iam'
);

מחליפים את PROJECT_ID במזהה הפרויקט שבו זמין מודל Agent Platform. לחשבון השירות של AlloyDB צריך להיות תפקיד משתמש ב-Vertex AI בפרויקט הזה.

אחרי שרושמים את המודל, אפשר להשתמש בו בפונקציות AI באופן הבא:

SELECT ai.generate(prompt => 'What is AlloyDB?', model_id => 'gemini-3-preview-model');

שימוש במסננים בשאילתות

ב-AlloyDB AI יש פונקציות SQL מבוססות-AI שמאפשרות להשתמש בעיבוד שפה טבעית (NLP) ובמודלים גדולים של שפה (LLM) ישירות בשאילתות של מסד הנתונים, כולל האופרטורים ai.if ו-ai.rank.

הערה: אם לא מציינים את גודל האצווה בשאילתות, גודל האצווה שמוגדר כברירת מחדל הוא 10.

סינון באמצעות פונקציות סקלריות

כדי להעריך אם תנאי שצוין בשפה טבעית מתקיים, משתמשים באופרטור ai.if/google_ml.if. הפונקציה מחזירה ערך בוליאני True או False, ומחזירה את הערך false אם הפלט לא מזוהה בבירור.

- Function signature
FUNCTION ai.if(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS bool

בדוגמה הבאה מוצג השימוש באופרטור ai.if כמסנן למציאת מסעדות עם יותר מ-500 ביקורות חיוביות, שנמצאות בערים עם אוכלוסייה של יותר מ-100,000 תושבים. בדוגמה נעשה שימוש ב-restaurant_reviews והיא מכילה נתונים כמו ביקורות ומיקום העיר. האופרטור ai.if עוזר לכם להבין את הסנטימנט של הביקורות ולשלב את המיקומים ממסד הנתונים עם הידע הכללי של Gemini על האוכלוסייה במיקומים האלה.

SELECT r.name, r.location_city
FROM restaurant_reviews r
WHERE
  AI.IF(r.location_city || ' has a population OF more than 100,000 AND the following is a positive review; Review: ' || r.review)
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

בדוגמה הבאה מוצג אותו תרחיש שימוש באמצעות המודל שרשמתם במאמר שימוש במודל Gemini שנתמך באזור שלכם.

SELECT r.name, r.location_city
FROM restaurant_reviews r
WHERE
  AI.IF(r.location_city || ' has a population of more than 100,000 AND the following is a positive review; Review: ' || r.review, model_id => 'gemini-2.5-flash-lite')
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

ביצוע צירוף בשאילתה שמשתמשת באופרטור if

כדי לבצע פעולת איחוד, משתמשים באופרטור ai.if/google_ml.if עם join. השאילתה לדוגמה הבאה מוצאת את מספר הביקורות שבהן מוזכר כל פריט בתפריט של המסעדה.

    SELECT item_name, COUNT(*)
    FROM menu_items JOIN user_reviews
      ON ai.if(
        prompt => 'Does the following user review talk about the menu item mentioned ? review: ' || user_reviews.review_text || ' menu item: ' || item_name)
    GROUP BY item_name;

סינון באמצעות פונקציות מבוססות-מערך

בדוגמה הבאה, מסעדות עם יותר מ-10 ביקורות חיוביות מזוהות באמצעות מודל AI‏ (gemini-2.5-flash-lite) כדי לנתח את הסנטימנט של הביקורות ולסנן את התוצאות. הפונקציה ARRAY_AGG משמשת להמרת שורות נתונים בודדות למערכים מובְנים, כדי שמודל ה-AI יוכל לעבד אותן בכמות גדולה במקום שורה אחת בכל פעם.

WITH initial_arrays AS (
  SELECT
    ARRAY_AGG(r.id ORDER BY r.id) AS review_ids,
    -- Assuming ai.if takes an array of prompts and returns a boolean array
    ai.if(
      prompts => ARRAY_AGG('Is the review positive: ' || r.review ORDER BY r.id),
      model_id => 'gemini-2.5-flash-lite',
      batch_size => 20
    ) AS truth_values
  FROM restaurant_reviews r
),
reviews AS (
SELECT
  initial_arrays.review_ids[i] AS review_id,
  initial_arrays.truth_values[i] AS truth_value
FROM
  initial_arrays,
  generate_series(1, array_length(initial_arrays.review_ids, 1)) AS i
)
SELECT rest_review.location_city, rest_review.name
FROM restaurant_reviews rest_review JOIN reviews review ON rest_review.id=review.review_id
WHERE review.truth_value = 't'
GROUP BY rest_review.location_city, rest_review.name
HAVING COUNT(*) > 10;

סינון באמצעות סמנים

בדוגמה הבאה אפשר לראות איך לסנן קבוצה גדולה של ביקורות על מסעדות באמצעות סטרימינג דרך סמן.

הערה: אם לא מציינים גודל אצווה, גודל ברירת המחדל הוא 10.

CREATE TABLE filtered_results(input text, result bool);

DO $$
DECLARE
    prompt_cursor REFCURSOR;
    result_cursor REFCURSOR;
    rec RECORD;
BEGIN
    -- 1. Open a cursor for the input data
    OPEN prompt_cursor FOR
        SELECT r.location_city || ' has a population of > 100,000 and is a positive review; Review: ' || r.review
        FROM restaurant_reviews r;

    -- 2. Call the array-based function using the input cursor
    result_cursor := ai.if(
        'Is the given statement true? ',
        prompt_cursor,
        model_id => 'gemini-2.5-flash-lite'
    );

    -- 3. Fetch results from the output cursor and store them
    LOOP
        FETCH result_cursor INTO rec;
        EXIT WHEN NOT FOUND;
        INSERT INTO filtered_results VALUES(rec.input, rec.output);
    END LOOP;

    CLOSE result_cursor;
END $$;

יצירת טקסט וסיכום

ב-AlloyDB AI יש אופרטורים ליצירת טקסט, כמו ai.generate סקלרי ו-ai.generate מבוסס-מערך ומבוסס-סמן.

מידע נוסף על פונקציות ופרמטרים של אופרטורים זמין בחומר העזר בנושא פונקציות של אופרטורים. מדריכים ייעודיים למשימות ספציפיות שקשורות לטקסט זמינים במאמרים סיכום תוכן וניתוח סנטימנט של טקסט.

יצירת טקסט באמצעות פונקציות סקלריות

הפונקציה ai.generate יוצרת טקסט על ידי שילוב של הנתונים שסופקו עם ההנחיה של המשתמש.

-- Function signature
FUNCTION ai.generate(
  prompt TEXT,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS TEXT

לדוגמה, אפשר להשתמש בשאילתה הבאה כדי ליצור סיכום תמציתי של כל ביקורת משתמשים.

SELECT
  ai.generate(
    prompt => 'Summarize the review in 20 words or less. Review: ' || review) AS review_summary
FROM user_reviews;

יצירת טקסט באמצעות פונקציות מבוססות-מערך

הפונקציה ai.generate מאפשרת ליצור טקסט דינמי מבוסס-AI לכמה פרומפטים בקבוצות.

-- Function signature
FUNCTION ai.generate(
  prompts TEXT[],
  batch_size INT DEFAULT NULL,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS TEXT[]

השאילתה הבאה משתמשת ב-UNNEST וב-ai.generate כדי לסכם כמה ביקורות בצורה יעילה.

SELECT
  UNNEST(
    ai.generate(
      prompts => ARRAY_AGG('Summarize the review in 20 words or less. Review: ' || review),
      model_id => 'gemini-2.5-flash-lite'
    )
  ) AS review_summary
FROM user_reviews;

יצירת טקסט באמצעות סמנים

כדי ליצור סיכומים או תרגומים למיליוני שורות בלי להיתקל בצווארי בקבוק בזיכרון, השתמשו ביצירת אצווה עם סמנים.

-- Function signature
FUNCTION ai.generate(
  prompt TEXT,
  input_cursor REFCURSOR,
  batch_size INT DEFAULT NULL,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS REFCURSOR

הדוגמה הבאה ממחישה איך ליצור סיכומים של כמויות גדולות של טקסט באמצעות סמנים.

CREATE TABLE summary_results(summary text);

DO $$
DECLARE
    prompt_cursor REFCURSOR;
    summary_cursor REFCURSOR;
    rec RECORD;
BEGIN
    OPEN prompt_cursor FOR SELECT review_text FROM user_reviews ORDER BY id;

    summary_cursor := ai.generate(
        'Summarize the review in 20 words or less. Review:',
        prompt_cursor
    );

    LOOP
        FETCH summary_cursor INTO rec;
        EXIT WHEN NOT FOUND;
        INSERT INTO summary_results VALUES(rec.output);
    END LOOP;

    CLOSE summary_cursor;
END $$;

הוספת ניקוד לתוצאות השאילתה

אם אתם צריכים למיין את תוצאות השאילתה באמצעות הוראות מותאמות בשפה טבעית, אתם יכולים להשתמש באופרטור ai.rank.

ביצוע ניקוד באמצעות פונקציות סקלריות

הפונקציה הבאה מאפשרת לכם לספק הנחיה שמתארת את הקריטריונים לדירוג, ומחזירה ציון לכל פריט.

-- Function signature
FUNCTION ai.rank(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS real

לדוגמה, השאילתה הבאה מחזירה את 20 הביקורות הכי חיוביות על מסעדות, באמצעות ציונים מ-LLM.

SELECT review AS top20
FROM user_reviews
ORDER BY ai.rank(
  'Score the following review according to these rules:
  (1) Score OF 8 to 10 IF the review says the food IS excellent.
  (2) 4 to 7 IF the review says the food is ok.
  (3) 1 to 3 IF the review says the food is not good. Here is the review:' || review) DESC
LIMIT 20;

איך מבצעים ניקוד באמצעות פונקציות מבוססות-מערך

הפונקציה הזו של ai.rank מאפשרת לכם לדרג תוצאות של שאילתות על סמך הוראות מותאמות אישית בשפה טבעית.

-- Function signature
FUNCTION ai.rank(
  prompts TEXT[],
  batch_size INT DEFAULT NULL,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS real[]

השאילתה הבאה משתמשת ב-UNNEST וב-ai.rank כדי לדרג כמה ביקורות ביעילות.

SELECT
  UNNEST(
    ai.rank(
      ARRAY_AGG('Score the following review according to these rules:
  (1) Score OF 8 to 10 IF the review says the food IS excellent.
  (2) 4 to 7 IF the review says the food is ok.
  (3) 1 to 3 IF the review says the food is not good. Here is the review:' || review)
    )
  ) as review_scores
FROM user_reviews;

מתן ציונים באמצעות סמנים

הפונקציה הזו משמשת לניקוד של מערכי נתונים גדולים בלי לחרוג ממגבלות הזיכרון.

-- Function signature
FUNCTION ai.rank(
  prompt TEXT,
  input_cursor REFCURSOR,
  batch_size INT DEFAULT NULL,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS REFCURSOR

בדוגמה הבאה אפשר לראות איך נותנים ציון לכמויות גדולות של טקסט לפי קריטריונים ספציפיים של שפה טבעית.

CREATE TABLE scored_results(input text, score real);

DO $$
DECLARE
    prompt_cursor REFCURSOR;
    score_cursor REFCURSOR;
    rec RECORD;
BEGIN
    OPEN prompt_cursor FOR SELECT review FROM user_reviews ORDER BY id;

    score_cursor := ai.rank(
        'Score the following review: (1) 8-10 if excellent, (2) 4-7 if ok, (3) 1-3 if not good. Review:',
        prompt_cursor
    );

    LOOP
        FETCH score_cursor INTO rec;
        EXIT WHEN NOT FOUND;
        INSERT INTO scored_results VALUES(rec.input, rec.output);
    END LOOP;

    CLOSE score_cursor;
END $$;

המאמרים הבאים

• רישום נקודת קצה של מודל באמצעות ניהול נקודות קצה של מודלים.

• דירוג וניקוד של תוצאות חיפוש ל-RAG.

• סינון סמנטי של שאילתות SQL ודירוג התוצאות.

• ביצוע חיזוי של סדרות עתיות.

• האצת שאילתות באמצעות פונקציות AI.

• מידע נוסף על ניהול נקודות קצה של מודלים