ביצוע שאילתות 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 3.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 שנתמך באזור שלכם

מודל ברירת המחדל של מנוע השאילתות של AI הוא gemini-3.5-flash-lite. אם לא תציינו model_id בפונקציות ה-AI, השאילתות ישתמשו במודל הזה. כדי לבדוק את זמינות המודל, עיינו באזורים נתמכים. לפרטים על המחירים, קראו את התמחור של Agent Platform.

אם אשכול AlloyDB ל-PostgreSQL נמצא באזור שבו אין תמיכה ב-gemini-3.5-flash-lite, אתם יכולים לציין מודל Gemini זמין אחר באמצעות הפרמטר model_id. מידע נוסף זמין במאמר מיקומי נקודות קצה של מודלים של Google.

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

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

CALL
  google_ml.create_model(
    model_id => 'gemini-3.5-flash-lite-global',
    model_type => 'llm',
    model_provider => 'google',
    model_qualified_name => 'gemini-3.5-flash-lite',
    model_request_url =>  'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.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 צריך להיות התפקיד "משתמש בפלטפורמת הסוכן" בפרויקט הזה.

אחרי שרושמים את המודל, אפשר להשתמש בו בפונקציות 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-3.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-3.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-3.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-3.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-3.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.

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