פתרון בעיות בשאילתות
כשמריצים שאילתות ב-BigQuery, יכול להיות שזמני הביצוע יהיו איטיים, שיופיעו שגיאות במכסות המשאבים או שמשימות השאילתות ייכשלו. כדי לאבחן ולפתור את הבעיות הנפוצות האלה בשאילתות, אתם יכולים לבדוק את פרטי ההפעלה של השאילתות, להשתמש בכלי אבחון אוטומטיים וליישם תיקונים ממוקדים.
פתרון בעיות שקשורות לשאילתות איטיות
כדי לפתור בעיות של ביצועי שאילתות איטיים, מבצעים את הפעולות הבאות:
בדף Google Cloud Service Health מפורטות הפסקות ידועות בשירות של BigQuery, שיכולות להשפיע על ביצועי השאילתות.
בודקים את ציר הזמן של המשימה של השאילתה בסייר המשימות כדי לראות כמה זמן נמשך כל שלב בהרצת השאילתה.
אם רוב הזמן שחלף נבע מזמני יצירה ארוכים, פנו ל-Cloud Customer Care לקבלת עזרה.
אם רוב הזמן שחלף נבע מזמני ביצוע ארוכים, כדאי לעיין בתובנות לגבי ביצועי השאילתות. תובנות לגבי ביצועי השאילתות יכולות להודיע לכם אם השאילתה שלכם רצה יותר זמן מזמן הביצוע הממוצע, ולהציע סיבות אפשריות לכך. הסיבות האפשריות יכולות להיות תחרות על משבצות שאילתות או מכסת ערבוב לא מספיקה. במאמר פרשנות של תובנות לגבי ביצועי שאילתות תוכלו לקרוא מידע נוסף על כל בעיה בביצועי השאילתות ועל פתרונות אפשריים.
בודקים את השדה
finalExecutionDurationMsבסוג האובייקטJobStatisticsשל משימת השאילתה. יכול להיות שהשאילתה נשלחה שוב. השדהfinalExecutionDurationMsמכיל את משך הזמן במילי-שניות של ביצוע הניסיון האחרון של המשימה הזו.בודקים את הבייטים שעובדו בדף הפרטים של משימת השאילתה כדי לראות אם הוא גבוה מהצפוי. כדי לעשות זאת, אפשר להשוות את מספר הבייטים שעובדו בשאילתה הנוכחית למספר הבייטים שעובדו במשימת שאילתה אחרת שהושלמה בפרק זמן סביר. אם יש פער גדול בין מספר הבייטים שעובדו בשתי השאילתות, יכול להיות שהשאילתה הייתה איטית בגלל נפח נתונים גדול. במאמר אופטימיזציה של חישוב שאילתות מוסבר איך לבצע אופטימיזציה של שאילתות כדי לטפל בנפחי נתונים גדולים.
אתם יכולים גם לזהות שאילתות בפרויקט שמעבדות כמות גדולה של נתונים, על ידי חיפוש השאילתות היקרות ביותר באמצעות התצוגה
INFORMATION_SCHEMA.JOBS.בודקים את השימוש בהזמנות ובודקים אם יש תחרות על משבצות. מידע נוסף זמין במאמר ניתוח הנתונים הסטטיסטיים של עומסי העבודה.
בודקים את ההרצות הקודמות והאחרונות של אותו גיבוב שאילתה כדי לראות אם יש תובנות לגבי ביצועי השאילתה חדשות במשימות האיטיות יותר, כמו שינוי בקנה המידה של קלט הנתונים. אפשר לסנן לפי גיבוב (hash) של שאילתה בכלי לניהול משימות.
השוואה בין הרצה איטית ומהירה של אותה שאילתה
אם שאילתה שרצה בעבר במהירות רצה עכשיו לאט, בדקו את הפלט של אובייקט Job API כדי לזהות שינויים בהרצה שלה.
מציאות במטמון (cache hits)
כדי לוודא שהביצוע המהיר של המשימה היה מציאה במטמון, בודקים את הערך של cacheHit. אם הערך הוא true, השאילתה בוצעה במהירות כי היא השתמשה בתוצאות שנשמרו במטמון במקום להריץ את השאילתה.
אם אתם מצפים שהמשימה האיטית תשתמש בתוצאות שנשמרו במטמון, בדקו למה השאילתה כבר לא משתמשת בתוצאות שנשמרו במטמון. אם אתם לא מצפים שהשאילתה תאחזר נתונים מהמטמון, חפשו דוגמה להרצת שאילתה מהירה שלא פגעה במטמון לצורך החקירה.
עיכובים שקשורים למכסה
כדי לבדוק אם ההאטה נגרמה בגלל דחייה של מכסות, בודקים את השדה quotaDeferments בשני המשימות. משווים בין הערכים כדי לבדוק אם שעת ההתחלה של השאילתה האיטית יותר נדחתה בגלל דחיות של מכסות שלא השפיעו על המשימה המהירה יותר.
משך הביצוע
כדי להבין את ההבדל בין משך הביצוע של הניסיון האחרון של שתי המשימות, משווים את הערכים שלהן בשדה finalExecutionDurationMs.
אם הערכים של finalExecutionDurationMs די דומים, אבל ההבדל בזמן הביצוע בפועל בין שתי השאילתות, שמחושב כ-startTime - endTime, גדול בהרבה, יכול להיות שהיה ניסיון חוזר פנימי להרצת השאילתה של המשימה האיטית בגלל בעיה זמנית. אם אתם רואים את דפוס ההבדלים הזה שוב ושוב, פנו ל-Cloud Customer Care כדי לקבל עזרה.
בייטים שעובדו
בודקים את הבייטים שעובדו בדף הפרטים של משימת השאילתה או בודקים את totalBytesProcessed מ-JobStatistics כדי לראות אם הוא גבוה מהצפוי. אם יש פער גדול בין מספר הבייטים שעובדו בשתי השאילתות, יכול להיות שהשאילתה איטית בגלל שינוי בנפח הנתונים שעובדו. במאמר אופטימיזציה של חישוב שאילתות מוסבר איך לבצע אופטימיזציה של שאילתות כדי לטפל בנפחי נתונים גדולים.
הסיבות הבאות יכולות לגרום לעלייה במספר הבייטים שמעובדים על ידי שאילתה:
- גודל הטבלאות שהשאילתה מפנה אליהן גדל.
- השאילתה קוראת עכשיו מחיצה גדולה יותר של הטבלה.
- השאילתה מפנה לתצוגה שההגדרה שלה השתנתה.
טבלאות שהוזכרו
כדי לבדוק אם השאילתות קוראות את אותן טבלאות, מנתחים את הפלט של השדה referencedTables ב-JobStatistics2.
ההבדלים בין הטבלאות שצוינו יכולים לנבוע מהסיבות הבאות:
- שאילתת ה-SQL שונתה כדי לקרוא טבלאות שונות. כדי לוודא את זה, השוו את הטקסט של השאילתה.
- הגדרת התצוגה השתנתה בין ההרצות של השאילתה. בודקים את ההגדרות של התצוגות שמוזכרות בשאילתה הזו ומעדכנים אותן לפי הצורך.
הבדלים בטבלאות שאליהן מפנים יכולים להסביר שינויים ב-totalBytesProcessed.
שימוש בתצוגות מהותיות
אם השאילתה מפנה לתצוגות מהותיות, ההבדלים בביצועים יכולים לנבוע מבחירה או מדחייה של תצוגות מהותיות במהלך הרצת השאילתה. בודקים את MaterializedViewStatistics כדי להבין אם תצוגות מהותיות ששימשו בשאילתה המהירה נדחו בשאילתה האיטית. בודקים את השדות chosen ו-rejectedReason באובייקט MaterializedView.
נתונים סטטיסטיים של שמירת מטא-נתונים במטמון
בשאילתות שכוללות טבלאות BigLake של Amazon S3 או טבלאות BigLake של Cloud Storage עם שמירת מטא-נתונים במטמון, משווים את הפלט של MetadataCacheStatistics כדי לבדוק אם יש הבדל בשימוש במטמון של המטא-נתונים בין השאילתה האיטית למהירה, ואת הסיבות לכך. לדוגמה, יכול להיות שהמטמון של המטא-נתונים נמצא מחוץ למרווח הזמן maxStaleness שהוגדר לטבלה.
השוואה בין הנתונים הסטטיסטיים של BigQuery BI Engine
אם השאילתה משתמשת ב-BigQuery BI Engine, מנתחים את הפלט של BiEngineStatistics כדי לקבוע אם אותם מצבי האצה הופעלו גם על השאילתה האיטית וגם על השאילתה המהירה. בשדה BiEngineReason אפשר לראות את הסיבה הכללית להאצה חלקית או להיעדר האצה, כמו זיכרון לא מספיק, חוסר בהזמנה או קלט גדול מדי.
בדיקת ההבדלים בתובנות לגבי ביצועי השאילתות
משווים בין התובנות לגבי ביצועי השאילתות של כל אחת מהשאילתות, על ידי עיון בתרשים הביצוע במסוף Google Cloud או באובייקט StagePerformanceStandaloneInsight, כדי להבין את הבעיות האפשריות הבאות:
- אין מספיק יחידות קיבולת (
slotContention) - שאילתות איחוד בעוצמה גבוהה (
highCardinalityJoins) - מכסת ה-shuffle לא מספיקה (
insufficientShuffleQuota) - חלוקת נתונים לא מאוזנת (
partitionSkew)
שימו לב לתובנות שסופקו לגבי המשימה האיטית וגם להבדלים בין התובנות שהופקו לגבי המשימה המהירה, כדי לזהות שינויים בשלבים שמשפיעים על הביצועים.
הקצאת הזמנה
בודקים אם יש הבדלים בהזמנה שהוקצתה לשתי המשימות. שינוי בהזמנה או מעבר מ-on-demand להזמנה יכולים להשפיע על הביצועים. מידע נוסף זמין במאמר מודלים של ניהול עומסי עבודה וגודל ההזמנה.
כדי לבצע ניתוח מעמיק יותר של המטא-נתונים של ביצוע המשימה, צריך לעבור על השלבים הבודדים של ביצוע השאילתה ולהשוות בין האובייקטים של ExplainQueryStage בשתי המשימות.
כדי להתחיל, עיינו במדדים Wait ms ו-Shuffle output bytes שמתוארים בקטע פירוש המידע על שלבי השאילתה.
אזהרות לגבי משאבים בתצוגה INFORMATION_SCHEMA.JOBS
שולחים שאילתה לשדה query_info.resource_warning של התצוגה INFORMATION_SCHEMA.JOBS כדי לבדוק אם יש הבדל באזהרות שנותחו על ידי BigQuery ביחס למשאבים שבהם נעשה שימוש.
ניתוח הנתונים הסטטיסטיים של עומס העבודה
משאבי ה-slot הזמינים והתחרות על ה-slots יכולים להשפיע על זמן הביצוע של השאילתה. בקטעים הבאים מוסבר איך להבין את השימוש בחריצים ואת הזמינות שלהם להרצה מסוימת של שאילתה.
ממוצע משבצות לשנייה
כדי לחשב את המספר הממוצע של משבצות שהשאילתה השתמשה בהן בכל אלפית שנייה, מחלקים את הערך של משבצות-אלפיות השנייה של המשימה, totalSlotMs מ-JobStatistics2, במשך הזמן באלפיות השנייה של ביצוע הניסיון האחרון של המשימה, finalExecutionDurationMs מ-JobStatistics.
אפשר גם לחשב את המספר הממוצע של משבצות לכל אלפית שנייה שבהן נעשה שימוש במשימה, על ידי שליחת שאילתה לתצוגה INFORMATION_SCHEMA.JOBS.
משימה שמבצעת כמות דומה של עבודה עם כמות גדולה יותר של משבצות בממוצע לשנייה, מסתיימת מהר יותר. הסיבות הבאות יכולות לגרום לשימוש ממוצע נמוך יותר במשבצות לשנייה:
- לא היו משאבים נוספים זמינים בגלל תחרות על משאבים בין משימות שונות – המקום השמור נוצל עד הסוף.
- במהלך חלק גדול מהביצוע, לא נשלחה בקשה להקצאת עוד משבצות בשביל המשימה. לדוגמה, זה יכול לקרות כשיש חלוקת נתונים לא מאוזנת (partition skew).
מודלים של ניהול עומסי עבודה וגודל ההזמנה
אם אתם משתמשים במודל החיוב על פי דרישה, מספר ה-slots שבהם אתם יכולים להשתמש בכל פרויקט מוגבל. יכול להיות שלפעמים יהיו פחות משבצות זמינות בפרויקט, אם יש תחרות גבוהה על קיבולת לפי דרישה במיקום ספציפי.
המודל שמבוסס על קיבולת הוא צפוי יותר, ומאפשר לכם לציין מספר מאושר של משבצות בסיסיות.
חשוב להביא בחשבון את ההבדלים האלה כשמשווים בין הרצת שאילתה על פי דרישה לבין הרצת שאילתה באמצעות הזמנה.
כדי לקבל ביצועים יציבים וצפויים של הרצת שאילתות, מומלץ להשתמש בהזמנה. למידע נוסף על ההבדלים בין עומסי עבודה על פי דרישה לבין עומסי עבודה מבוססי-קיבולת, קראו את המאמר מבוא לניהול עומסי עבודה.
הפעלות בו-זמניות של משימות
הפעלה בו-זמנית של משימות מייצגת את התחרות בין משימות על משאבי חריצים במהלך הרצת השאילתה. בדרך כלל, ככל שיש יותר משימות בו-זמניות, כך הן מבוצעות לאט יותר, כי למשימה יש גישה לפחות משבצות.
אתם יכולים להריץ שאילתה בתצוגה INFORMATION_SCHEMA.JOBS כדי למצוא את המספר הממוצע של משימות בו-זמניות שפועלות במקביל לשאילתה מסוימת בפרויקט.
אם יש יותר מפרויקט אחד שמוקצה להזמנה, צריך לשנות את השאילתה כך שתשתמש ב-JOBS_BY_ORGANIZATION במקום ב-JOBS_BY_PROJECT כדי לקבל נתונים מדויקים ברמת ההזמנה.
אם הממוצע של מספר המשימות שפועלות בו-זמנית גבוה יותר במשימה האיטית בהשוואה למשימה המהירה, זה גורם לאיטיות הכוללת.
כדי לצמצם את מספר השאילתות שפועלות בו-זמנית בפרויקט או בהזמנה, אפשר לפזר את השאילתות שצורכות הרבה משאבים לאורך זמן בהזמנה או בפרויקט, או לפזר אותן בין הזמנות או פרויקטים שונים.
פתרון אחר הוא לרכוש הזמנה או להגדיל את הגודל של הזמנה קיימת. כדאי לאפשר להקצאה להשתמש במשבצות לא פעילות.
כדי להבין כמה חריצים צריך להוסיף, קראו על הערכת הדרישות לקיבולת חריצים.
משימות שפועלות בהזמנות עם יותר מפרויקט אחד שהוקצה יכולות להניב תוצאות שונות של הקצאת משבצות עם אותו מספר ממוצע של משימות בו-זמניות, בהתאם לפרויקט שמריץ אותן. מידע נוסף זמין במאמר בנושא תזמון הוגן.
ניצול ההזמנות
אפשר להשתמש בתרשימי משאבים של אדמינים וב-Cloud Monitoring של BigQuery כדי לעקוב אחרי ניצול המשאבים שהוקצו. למידע נוסף, קראו את המאמר מעקב אחרי הזמנות ב-BigQuery.
כדי להבין אם המשימה ביקשה משבצות נוספות, בודקים את המדד של היחידות המשוערות שאפשר להריץ, שהוא estimatedRunnableUnits מהתגובה של Job API, או period_estimated_runnable_units בתצוגה INFORMATION_SCHEMA.JOBS_TIMELINE.
אם הערך של המדד הזה גדול מ-0, יכול להיות שהמשימה הייתה יכולה להפיק תועלת מ-slots נוספים באותו זמן.
כדי להעריך את אחוז זמן הביצוע של המשימה שבו המשימה הייתה יכולה להפיק תועלת מ-slots נוספים, מריצים את השאילתה הבאה בתצוגה INFORMATION_SCHEMA.JOBS_TIMELINE:
SELECT ROUND(COUNTIF(period_estimated_runnable_units > 0) / COUNT(*) * 100, 1) AS execution_duration_percentage FROM `myproject`.`region-us`.INFORMATION_SCHEMA.JOBS_TIMELINE WHERE job_id = 'my_job_id' GROUP BY job_id;
+---------------------------------+ | execution_duration_percentage | +---------------------------------+ | 96.7 | +---------------------------------+
אחוז נמוך מצביע על כך שזמינות משאבי המשבצות היא לא גורם משמעותי לאיטיות השאילתה בתרחיש הזה.
אם האחוז גבוה וההזמנה לא נוצלה במלואה במהלך הזמן הזה, פנו ל-Cloud Customer Care כדי לבדוק את הנושא.
אם ההזמנה נוצלה במלואה במהלך הרצת המשימה האיטית והאחוז גבוה, המשימה הוגבלה במשאבים. כדי לפתור את הבעיה, אפשר להפחית את מספר המשימות שפועלות בו-זמנית, להגדיל את ההזמנה, לאפשר להזמנה להשתמש במשבצות לא פעילות או לרכוש הזמנה אם המשימה הופעלה על פי דרישה.
המטא-נתונים של המשימה וממצאי הניתוח של עומס העבודה לא חד-משמעיים
אם אתם עדיין לא מצליחים להבין למה ביצועי השאילתה איטיים מהצפוי, תוכלו לפנות ל-Cloud Customer Care כדי לקבל עזרה.
פתרון בעיות בשאילתות באמצעות Gemini Cloud Assist
כדי להיעזר ב-Gemini Cloud Assist בפתרון בעיות שקשורות לשאילתות שנכשלו או לבעיות בביצועים:
נכנסים לדף BigQuery במסוף Google Cloud .
בסרגל הכלים של Google Cloud , לוחצים על spark Open or close Gemini Cloud Assist chat.
בחלונית Cloud Assist, כותבים הנחיה שכוללת את מזהה המשימה כדי לבדוק את ההרצה, מדדי הביצועים או הסיבות לכישלון. לדוגמה:
למה JOB_ID נכשל?למה המשימה הזו נמשכת כל כך הרבה זמן? JOB_IDתסכם את הביצועים שלי בעבודה ב-24 השעות האחרונות.
פתרון בעיות שקשורות לשאילתות שנכשלו באמצעות gcpdiag
gcpdiag הוא כלי בקוד פתוח. זה לא מוצר של Google Cloud שנתמך באופן רשמי.
אתם יכולים להשתמש בכלי gcpdiag כדי לזהות ולתקן בעיות בפרויקט Google Cloud. מידע נוסף זמין בפרויקט gcpdiag ב-GitHub.
הכלי gcpdiag עוזר לנתח שאילתות BigQuery שנכשלו, כדי להבין אם יש סיבה ידועה לבעיה ופתרון ספציפי.
מריצים את הפקודה gcpdiag
אפשר להריץ את הפקודה gcpdiag מ-Google Cloud CLI:
מסוףGoogle Cloud
- משלימים את הפקודה הבאה ומעתיקים אותה.
- פותחים את מסוף Google Cloud ומפעילים את Cloud Shell. פתיחת מסוף Cloud
- מדביקים את הפקודה שהועתקה.
- מריצים את הפקודה
gcpdiag, שמורידה את קובץ האימג' של Dockergcpdiag, ואז מבצעים בדיקות אבחון. אם רלוונטי, פועלים לפי ההוראות שמופיעות בפלט כדי לתקן את הבדיקות שנכשלו.
gcpdiag runbook bigquery/failed-query \
--parameter project_id=PROJECT_ID \
--parameter bigquery_job_region=JOB_REGION \
--parameter bigquery_job_id=JOB_ID \
--parameter bigquery_skip_permission_check=SKIP_PERMISSION_CHECKDocker
אתם יכולים
להריץ את gcpdiag באמצעות wrapper שמפעיל את gcpdiag בקונטיינר של Docker. צריך להתקין את Docker או את Podman.
- מעתיקים את הפקודה הבאה ומריצים אותה בתחנת העבודה המקומית.
curl https://gcpdiag.dev/gcpdiag.sh >gcpdiag && chmod +x gcpdiag
- מפעילים את הפקודה
gcpdiag../gcpdiag runbook bigquery/failed-query \ --parameter project_id=PROJECT_ID \ --parameter bigquery_job_region=JOB_REGION \ --parameter bigquery_job_id=JOB_ID \ --parameter bigquery_skip_permission_check=SKIP_PERMISSION_CHECK
הפרמטרים הזמינים למדריך ההפעלה הזה.
מחליפים את מה שכתוב בשדות הבאים:
- PROJECT_ID: מזהה הפרויקט שמכיל את המשאב.
- JOB_REGION: האזור שבו בוצעה המשימה ב-BigQuery.
- JOB_ID: מזהה המשימה ב-BigQuery.
- SKIP_PERMISSION_CHECK: (אופציונלי) מגדירים את הערך
Trueכדי לדלג על בדיקת ההרשאות הרלוונטיות ולהאיץ את ההפעלה של קובץ ה-runbook (ערך ברירת המחדל הואFalse).
דגלים שימושיים:
-
--universe-domain: אם רלוונטי, הדומיין של Trusted Partner Sovereign Cloud שמארח את המשאב -
--parameterאו-p: פרמטרים של מדריך הפעלה
רשימה ותיאור של כל הדגלים של הכלי gcpdiag מופיעים בהוראות השימוש ב-gcpdiag.
רזולוציית סכימה של Avro
מחרוזת השגיאה: Cannot skip stream
השגיאה הזו יכולה להתרחש כשמנסים לטעון כמה קובצי Avro עם סכימות שונות, מה שגורם לבעיה בפתרון הסכימה ולכך שמשימת הייבוא נכשלת בקובץ אקראי.
כדי לפתור את השגיאה הזו, ודאו שהקובץ האחרון בסדר האלפביתי במשימת הטעינה מכיל את קבוצת-העל (איחוד) של הסכימות השונות. זו דרישה שמבוססת על האופן שבו Avro מטפל ברזולוציית הסכימה.
שאילתות מתנגשות בו-זמנית
מחרוזות שגיאה:
Resources exceeded during query execution: Another job JOB_ID is currently running in the session SESSION_ID. Concurrent jobs in the same session are not allowed.Session SESSION_ID has expired and is no longer available.
השגיאה הזו מתרחשת כשמריצים כמה שאילתות בו-זמנית באותו סשן, וזה לא נתמך, או כשסשן מסתיים באופן אוטומטי אחרי 24 שעות של חוסר פעילות או 7 ימים אחרי היצירה. מגבלות הסשן וסיום אוטומטי של סשן.
כדי לפתור את הבעיה תוכלו לנסות אחד מהפתרונות הבאים:
- כדאי להגדיל את המרווח בין שאילתות שמשתפות
session_idולהתחיל את השאילתה הבאה רק אחרי שהמשימה הקודמת (JOB_ID) מסתיימת, או להריץ שאילתות בו-זמנית בסשנים נפרדים. - אם פג התוקף של הסשן או שהוא הסתיים, יוצרים סשן חדש (ומעדכנים את
--session_idב-.bigqueryrcאו ב-connectionPropertiesאם הם מוגדרים). איך יוצרים סשן
פקודות DML מתנגשות
מחרוזת השגיאה: Could not serialize access to table due to concurrent update
השגיאה הזו מתרחשת כשפקודות בו-זמניות של שפת טיפול בנתונים (DML) לשינוי נתונים (UPDATE, DELETE או MERGE) מנסות לשנות נתונים באותה מחיצת טבלה בו-זמנית, או כשהטבלה נחתכת בזמן שפקודת DML פועלת.
ב-BigQuery אפשר להריץ בו-זמנית פקודות DML לשינוי באותה טבלה, כל עוד הן משנות מחיצות שונות. עם זאת, אם שתי משימות מנסות לשנות את אותה מחיצה, המשימה הראשונה שמושלמת מצליחה, והמשימות הבאות נכשלות עם השגיאה הזו.
כדי לפתור את השגיאה, נסו את הפתרונות הבאים:
- מנסים שוב להריץ את המשימה שנכשלה: אם ההתנגשות נגרמה בגלל חפיפה זמנית עם משימה אחרת, מנסים שוב להריץ את השאילתה אחרי שהמשימה שגרמה להתנגשות מסתיימת.
- זיהוי ותיאום של משימות מתנגשות: מריצים את שאילתת האבחון שבקטע הבא כדי לזהות את המשימה המתחרה, ואז מתאמים את לוחות הזמנים כך שפעולות DML שמשנות את אותו המחיצה לא ירוצו בו-זמנית.
- חלוקת הטבלאות למחיצות: אם משימות DML בו-זמניות מעדכנות פלחים שונים של נתונים, חלקו את הטבלה למחיצות לפי תאריך או טווח של מספרים שלמים. הצהרות DML לשינוי בו-זמני מצליחות בלי התנגשות אם הן משנות מחיצות שונות.
- פעולות DML באצווה: שילוב של כמה פעולות
UPDATEאוDELETEנפרדות בהצהרתMERGEאחת או במשימת אצווה אחת, כדי לצמצם את התקורה של בו-זמניות ושל ביצוע שינויים. למידע נוסף, קראו את השיטות המומלצות.
זיהוי המשימה שגורמת להתנגשות
כדי לזהות איזו משימה עדכנה את הטבלה בו-זמנית כשהשגיאה התרחשה, מריצים שאילתה בתצוגה INFORMATION_SCHEMA.JOBS:
SELECT job_id, query, start_time, end_time FROM `region-REGION`.INFORMATION_SCHEMA.JOBS WHERE creation_time BETWEEN TIMESTAMP_SUB(TIMESTAMP 'FAILED_JOB_START_TIME', INTERVAL 1 DAY) AND TIMESTAMP 'FAILED_JOB_END_TIME' AND destination_table.table_id = 'TABLE_NAME' AND destination_table.dataset_id = 'DATASET_NAME' AND statement_type IN ('UPDATE', 'DELETE', 'MERGE') AND start_time <= 'FAILED_JOB_END_TIME' AND (end_time >= 'FAILED_JOB_START_TIME' OR end_time IS NULL) ORDER BY start_time;
מחליפים את מה שכתוב בשדות הבאים:
-
REGION: שם האזור שבו נמצא מערך הנתונים, לדוגמהus. -
FAILED_JOB_START_TIME: חותמת הזמן של תחילת המשימה שנכשלה, לדוגמה2026-09-01 09:55:00 UTC. -
FAILED_JOB_END_TIME: חותמת הזמן של סיום המשימה שנכשלה, לדוגמה2026-09-01 10:00:00 UTC. -
TABLE_NAME: שם הטבלה שפקודת ה-DML שנכשלה ניסתה לעדכן. -
DATASET_NAME: השם של קבוצת הנתונים שמכילה את הטבלה.
אם השאילתה לא מחזירה משימות מתנגשות שהמשתמש יזם, יכול להיות שההתנגשות נגרמה בגלל פעולה אחרת ברקע, כמו תפוגה של מחיצה.
סיבות אחרות להתנגשויות בעדכונים בו-זמניים
- תפוגת תוקף של מחיצות: משימות מערכת ברקע שמסיימות את תוקף המחיצות יכולות להתנגש עם פקודת DML, אם הן משנות את אותה מחיצה במהלך ביצוע המשימה. אם אתם משתמשים בתפוגת תוקף של מחיצות, תזמנו משימות DML מחוץ לזמנים שבהם פג התוקף של המחיצות.
- טרנזקציות עם כמה הצהרות: כשטרנזקציה עם כמה הצהרות משנה טבלה, היא חוסמת את כל שאר פקודות ה-DML שפועלות בו-זמנית על הטבלה הזו עד שהטרנזקציה מסתיימת.
- הצהרות DML שמשפיעות על אפס שורות: הצהרת
UPDATE,DELETEאוMERGEרוכשת נעילות במחיצות מטורגטות ויכולה לגרום להתנגשויות בסריאליזציה, גם אם אין שורות שתואמות לתנאי הסינון.
מידע נוסף מופיע בקטע התנגשויות בין פקודות DML.
שאילתות משנה קשורות
מחרוזת השגיאה: Correlated subqueries that reference other tables are not
supported unless they can be de-correlated
השגיאה הזו יכולה להתרחש כשהשאילתה מכילה שאילתת משנה שמפנה לעמודה מחוץ לשאילתת המשנה, שנקראת עמודת קורלציה. שאילתת המשנה המתואמת מוערכת באמצעות אסטרטגיית ביצוע מקוננת ולא יעילה, שבה שאילתת המשנה מוערכת לכל שורה מהשאילתה החיצונית שמפיקה את עמודות המתאם. לפעמים BigQuery יכול לשכתב באופן פנימי שאילתות עם שאילתות משנה מתואמות, כדי שהן יפעלו בצורה יעילה יותר. השגיאה הזו מתרחשת כש-BigQuery לא יכול לבצע אופטימיזציה מספקת של השאילתה.
כדי לפתור את השגיאה, נסו את הפתרונות הבאים:
- מסירים את הסעיפים
ORDER BY,LIMIT,EXISTS,NOT EXISTSאוINמשאילתת המשנה. - משתמשים בשאילתה עם כמה הצהרות כדי ליצור טבלה זמנית שאפשר להפנות אליה בשאילתת המשנה.
- צריך לשכתב את השאילתה כדי להשתמש ב-
CROSS JOINבמקום זאת.
הרשאות לא מספיקות לבקרת גישה ברמת העמודה
מחרוזות שגיאה:
Access denied: Requires fineGrainedGet permission on the read columns to execute the DML statements- `Access denied: User does not have permission to access policy tag projects/PROJECT_ID/locations/LOCATION/taxonomies/TAXONOMY_ID/policyTags/POLICY_TAG_ID on column PROJECT_ID.DATASET.TABLE.COLUMN.'
השגיאות האלה מתרחשות כשמנסים להריץ שאילתת SQL או הצהרת DML מסוג DELETE, UPDATE או MERGE בלי לקבל את התפקיד קורא ברמת פירוט גבוהה בעמודות שמשתמשות בבקרת גישה ברמת העמודה. התפקיד הזה מוקצה לחשבונות משתמשים כחלק מהגדרת תג מדיניות. למידע נוסף, ראו ההשפעה של בקרת גישה ברמת העמודה על פעולות כתיבה.
כדי לעקוף את הבעיה, צריך לשנות את השאילתה כך שלא תכלול עמודות עם תגי מדיניות, או להקצות למשתמש את התפקיד קורא עם הרשאות מפורטות. התפקיד הזה מוקצה לחשבונות משתמשים כחלק מההגדרה של תג מדיניות. מידע נוסף זמין במאמר עדכון הרשאות בתגי מדיניות.
פתרון בעיות בשאילתות מתוזמנות
הבעיות הבאות עלולות להתרחש במהלך ההגדרה או ההפעלה של שאילתות מתוזמנות.
שאילתה מתוזמנת מפעילה הרצות כפולות
יכול להיות ששאילתה מתוזמנת תופעל יותר מפעם אחת בזמן המתוזמן.
ההתנהגות הזו צפויה להתרחש בשאילתות שתוזמנו בדיוק בשעה עגולה (למשל 09:00).
זה יכול להוביל לתוצאות לא צפויות, כמו נתונים כפולים אם השאילתה מבצעת פעולות INSERT.
כדי לצמצם את הסיכון להרצות כפולות, תזמנו את השאילתות לשעה לא עגולה, למשל כמה דקות לפני או אחרי השעה העגולה (לדוגמה, 08:58 או 09:03). מידע נוסף זמין במאמר תזמון שאילתות.
פרטי כניסה לא תקינים לשאילתות מתוזמנות
מחרוזות שגיאה:
Error code: INVALID_USERIDError code 5: Authentication failure: User Id not foundPERMISSION_DENIED: BigQuery: Permission denied while getting Drive credentials
השגיאה הזו יכולה להתרחש כששאילתה מתוזמנת נכשלת בגלל פרטי כניסה מיושנים, במיוחד כששולחים שאילתה לנתונים ב-Google Drive.
כדי לפתור את השגיאה הזו, מבצעים את השלבים הבאים:
- חשוב לוודא שהפעלתם את שירות העברת הנתונים ל-BigQuery, שהוא תנאי מוקדם לשימוש בשאילתות מתוזמנות.
- מעדכנים את פרטי הכניסה של השאילתה המתוזמנת.
פרטי כניסה לחשבון השירות לא תקינים
מחרוזת השגיאה: HttpError 403 when requesting returned: The caller does not have permission
השגיאה הזו עשויה להופיע כשמנסים להגדיר שאילתה מתוזמנת באמצעות חשבון שירות. כדי לפתור את השגיאה, אפשר לעיין בשלבים לפתרון בעיות בקטע בעיות שקשורות להרשאות.
טבלת היעד נמחקה או שהתוקף שלה פג
מחרוזת השגיאה: Destination deleted/expired during operation: DETAILS
שגיאת ה-HTTP 400 Bad Request (reason: invalid) מתרחשת כשמנסים לכתוב לטבלת יעד שהוסרה לפני שהסתיימה ההפעלה של משימת השאילתה, הטעינה או ההעתקה.
אבחון
השגיאה הזו מתרחשת בדרך כלל בגלל אחת משתי סיבות:
- הטבלה או מערך הנתונים הגיעו לתאריך התפוגה (TTL). בטבלת היעד (או בתפוגת ברירת המחדל של הטבלה במערך הנתונים) מוגדרת חותמת זמן של תפוגה. אם משימה ארוכה ממשיכה לפעול אחרי חותמת הזמן של תפוגת התוקף של הטבלה, BigQuery מוחק את הטבלה שפג תוקפה בזמן שהמשימה עדיין פועלת.
- מחיקה מפורשת בו-זמנית. משתמש אחר, חשבון שירות או תהליך עבודה אוטומטי (כמו DAG של תזמור או סקריפט ניקוי) מריצים הצהרת
DROP TABLEאו קריאה ל-API שלtables.deleteבטבלת היעד בזמן שהמשימה שלכם פועלת.
כדי לברר למה טבלת היעד נמחקה, שולחים שאילתה לתצוגה INFORMATION_SCHEMA.TABLE_STORAGE:
SELECT table_name, deleted, table_deletion_time, table_deletion_reason FROM `PROJECT_ID`.`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE WHERE table_schema = "DATASET_ID" AND table_name = "TABLE_ID"
מחליפים את מה שכתוב בשדות הבאים:
PROJECT_ID: מזהה הפרויקט.-
REGION: האזור של מערך הנתונים שמכיל את הטבלה. -
DATASET_ID: המזהה של קבוצת הנתונים שמכילה את הטבלה. -
TABLE_ID: המזהה של טבלת היעד.
העמודה table_deletion_reason מכילה את הערך TABLE_EXPIRATION אם פג התוקף של הטבלה, את הערך USER_DELETED אם משתמש מחק את הטבלה, או את הערך DATASET_DELETION אם משתמש מחק את קבוצת הנתונים שמכילה את הטבלה. מידע נוסף זמין במאמר זיהוי הסיבה למחיקת טבלה.
אם הסיבה היא USER_DELETED, שלחו שאילתה ליומני הביקורת של Cloud ב-Logs Explorer כדי למצוא מי מחק את הטבלה. מסננים את הרשומות לפי הזמן שבו המשימה נכשלה:
resource.type=("bigquery_resource" OR "bigquery_dataset")
protoPayload.methodName=("tableservice.delete" OR "google.cloud.bigquery.v2.TableService.DeleteTable")
protoPayload.resourceName:"YOUR_TABLE_NAME"
מחליפים את YOUR_TABLE_NAME במזהה של טבלת היעד.
בודקים את השדה protoPayload.authenticationInfo.principalEmail ברשומות היומן התואמות כדי לזהות את המשתמש או את חשבון השירות שמחק את הטבלה.
אם הסיבה היא DATASET_DELETION, משתמשים במסנן של מערך הנתונים בזיהוי מתי טבלה נמחקה.
רזולוציה
כדי לפתור את השגיאה:
- להאריך את זמני התפוגה של הטבלאות ושל מערכי הנתונים. בודקים את זמן התפוגה של טבלת היעד ואת הגדרת ברירת המחדל של זמן התפוגה של הטבלה במערך הנתונים. חשוב לוודא שכל TTL שהוגדר ארוך מספיק כדי לשרוד את זמן הריצה המקסימלי הצפוי (כולל זמן התור והניסיונות החוזרים) של משימות שכותבות לטבלה הזו. להוראות, ראו עדכון זמן התפוגה של טבלה.
- להריץ משימות בצינור עיבוד הנתונים לפי סדר. אם צינור עיבוד נתונים אוטומטי של ETL (כמו Managed Service for Apache Airflow, Apache Airflow או Dataform) יוצר מחדש או מנקה טבלאות של אזור ביניים, צריך להגדיר יחסי תלות מחמירים בין המשימות כדי שמשימות ה-
DROP TABLEאו הניקוי אף פעם לא יפעלו במקביל למשימות כתיבה פעילות שמטרגטות את אותה טבלה. - השתמשו בשמות ייחודיים לטבלאות ה-staging. כשמריצים כמה מופעים של צינור עיבוד נתונים במקביל, כותבים תוצאות ביניים לטבלאות זמניות או לטבלאות של שלבי ביניים עם שמות ייחודיים (לדוגמה, באמצעות
CREATE TEMP TABLEבשאילתה עם כמה הצהרות או הוספה של מזהה הרצה ייחודי), במקום לשתף טבלה אחת של שלבי ביניים שניתן לשנות בין הרצות בו-זמניות.
פקודות DML בטבלאות עם מאגר נתונים זמני (buffer) של סטרימינג
מחרוזת השגיאה:
UPDATE or DELETE statement over table
PROJECT_ID.DATASET_ID.TABLE_NAME would affect
rows in the streaming buffer, which is not supported
שגיאת ה-HTTP 400 Bad Request (reason: invalidQuery) מתרחשת כשפקודת DML לשינוי (UPDATE, DELETE או MERGE) מנסה לשנות או למחוק שורות שנוספו לאחרונה באמצעות ה-API הקודם של tabledata.insertAll לסטרימינג, ועדיין נמצאות במאגר הנתונים הזמני של הסטרימינג. שורות יכולות להישאר במאגר הנתונים הזמני של הסטרימינג למשך כמה דקות, ובמקרים נדירים עד 90 דקות. מידע נוסף זמין במאמרים זמינות של נתונים בסטרימינג ומגבלות DML.
כדי לפתור את השגיאה הזו, מבצעים אחת מהפעולות הבאות:
- מעבר ל-BigQuery Storage Write API (gRPC). להעביר נתונים בסטרימינג באמצעות BigQuery Storage Write API (gRPC), שמאפשר לשורות שנכתבו לאחרונה להיות זמינות באופן מיידי לשינוי של פקודות DML (
UPDATE,DELETEו-MERGE) ללא הגבלות של מאגר נתונים זמני (buffer) בסטרימינג. - צריך להמתין עד שהמאגר הזמני של הסטרימינג יתרוקן, או לסנן את השורות האחרונות. בודקים את התשובה של
tables.getבקטעstreamingBuffer. אםstreamingBufferלא קיים, כל השורות זמינות ל-DML. אפשר גם לבדוק אתstreamingBuffer.oldestEntryTimeולהוסיף מסנןWHEREלפקודת ה-DML, כך שהיא תטרגט רק שורות ישנות יותר מחלון מאגר הנתונים (buffer) של הסטרימינג.
שגיאות של שאילתות לא תקינות
כש-BigQuery מחזיר שגיאת HTTP 400 Bad Request עם סיבת השגיאה invalidQuery, המשמעות היא ששאילתת ה-SQL נכשלה בבדיקות האימות או הביצוע.
כדי לאבחן את הבעיה, אתם יכולים להשתמש בהודעת השגיאה הספציפית שמוחזרת על ידי BigQuery בארבע הקטגוריות הבאות:
שגיאות תחביר ודקדוק
מחרוזות שגיאה:
Syntax error: Expected TOKEN but got INPUT at [LINE:COLUMN]Syntax error: Unexpected keyword KEYWORD at [LINE:COLUMN]Unrecognized name: IDENTIFIER at [LINE:COLUMN]אוFunction not found: FUNCTION_NAME at [LINE:COLUMN]
כדי לפתור שגיאות שקשורות לתחביר ולמזהים:
- בודקים את המיקום של
[LINE:COLUMN]. בודקים את השורה והעמודה בהודעת השגיאה (ואת האסימון שמופיע מיד לפניה) כדי לראות אם יש סוגריים לא סגורים, פסיקים חסרים, פסיקים נגררים, מירכאות ללא תו בריחה (escape) או מילות מפתח חסרות שלENDבביטויים שלCASE. - בודקים את הסדר והניב של פסוקית ה-SQL. מוודאים שסעיפי ה-SQL תואמים לסדר הנדרש של תחביר השאילתות של GoogleSQL (
SELECT←FROM←WHERE←GROUP BY←HAVING←QUALIFY←ORDER BY←LIMIT), ומוודאים שהבקשה משתמשת ב-GoogleSQL (useLegacySql=false). לשגיאות SQL מדור קודם, ראו שגיאות SQL מדור קודם. - בודקים את העמודה, השם החלופי והיקף הפונקציה. אם השגיאה היא
Unrecognized nameאוFunction not found, צריך לבדוק את המקרים הבאים:- שגיאת כתיב או חוסר התאמה באותיות רישיות במזהה. בודקים את האיות ואת השימוש באותיות רישיות בעמודה או בטבלה, בהתאם לסכימה של הטבלה.
- הכינוי
SELECTאוזכר ב-WHERE. אל תפנו לכינויים שהוגדרו ברשימהSELECTבתוך אותו משפטWHERE. צריך לחזור על הביטוי, להשתמש בשאילתת משנה או ב-CTE, או לסנן ב-QUALIFY(לפונקציות אנליטיות). - פונקציה מתמידה בהגדרת המשתמש (UDF) ללא הרשאות. מגדירים פונקציות UDF מתמידות באמצעות
PROJECT_ID.DATASET_ID.FUNCTION_NAME. - תווים מיוחדים או מילות מפתח שמורות. תחמו במירכאות הפוכות (
`) שמות של טבלאות או עמודות שמכילים תווים מיוחדים או מילות מפתח שמורות. אתם יכולים גם להשתמש בכלי לאימות שאילתות ב-BigQuery Studio כדי לזהות בעיות בתחביר לפני הרצת השאילתה.
שגיאות תאימות של סוגי נתונים
מחרוזות שגיאה:
No matching signature for operator OPERATOR for argument types: TYPE_A, TYPE_BNo matching signature for function FUNCTION_NAME for argument types: ARG_TYPESQuery column COLUMN_NUMBER has type SOURCE_TYPE which cannot be inserted into column TARGET_COLUMN, which has type TARGET_TYPEUnsupported type TYPE
כדי לפתור חוסר התאמה בסוגי הנתונים, מבצעים את הפעולות הבאות:
- התאמת סוגים בהשוואות, בצירופים ובפונקציות. שולחים שאילתה ל-
INFORMATION_SCHEMA.COLUMNSאו בודקים את סכימת הטבלה במסוףGoogle Cloud כדי לוודא שכל הקלטים משתמשים בסוגי נתונים תואמים של GoogleSQL במיקומים הבאים:WHEREמסננים ו-JOIN ... ONמפתחות- הארגומנטים
COALESCEו-IFNULL - מיקומי העמודות
UNIONו-INSERT ... SELECT - ארגומנטים של פונקציות UDF וסוגי החזרה (כולל סוגי
RETURNSשל פונקציות UDF ב-JavaScript) - פונקציות של BigQuery ML (
ML.EVALUATE,ML.PREDICT)
- החלת המרות סוג מפורשות. כדי להמיר ערכים באופן מפורש במקום להסתמך על המרה משתמעת, השתמשו ב-
CAST()או ב-SAFE_CAST()או בפונקציות לניתוח תאריך ושעה (כמוPARSE_DATE,PARSE_TIMESTAMPו-TIMESTAMP_SECONDS). - טיפול בסוגי ייצוא או בסוגים מאוחדים שלא נתמכים כשמריצים שאילתות
EXPORT DATAאו שאילתות לכמה מסדי נתונים על סוגים גיאוגרפיים או מורכבים שלא נתמכים (כמוGEOGRAPHY,INTERVALאוBIGNUMERIC), בוחרים באחת מהאפשרויות הבאות:- צריך להמיר את העמודה ל-
STRINGברשימהSELECT. - כדי לשמור על נאמנות לסוג, צריך להחליף את הפורמט
EXPORT DATAל-AVROאו ל-PARQUET.
- צריך להמיר את העמודה ל-
הגבלות על תכונות וארכיטקטורה
מחרוזות שגיאה:
Invalid table-valued function FUNCTION_NAMEאוMissing required option OPTION_NAMEUnsupported aggregate function in materialized viewCannot query over table 'TABLE_NAME' without a filter over column(s) 'COLUMN_NAME' that can be used for partition eliminationUPDATE/MERGE must match at most one source row for each target rowInvalid snapshot timeToo many nested views/persistent user-defined functions...Too many partitions produced by query, allowed LIMIT, query produces at least COUNT partitionsResource exhausted. The model might be too large.
כדי לפתור שגיאות שקשורות לתכונות, ל-DDL ולהגבלות על שאילתות, מבצעים את הפעולות הבאות:
- מוודאים ש-
OPTIONS(...)נדרש בהצהרות DDL. כשיוצרים טבלאות חיצוניות, פונקציות מרוחקות או מודלים, צריך לוודא שכל האפשרויות הנדרשות (כמוformatו-urisלטבלאות חיצוניות) מצוינות עם סוגים חוקיים בסעיףOPTIONS. הצהרות של שפת הגדרת נתונים (DDL) - בדיקת המגבלות של SQL בתצוגות המהותיות תצוגות מהותיות תומכות בקבוצת משנה מוגבלת של צבירות SQL, ולא יכולות להפנות לפונקציות לא דטרמיניסטיות כמו
CURRENT_DATE(),RAND()אוSESSION_USER(). תצוגות מהותיות נתמכות - לכלול מסנני מחיצות נדרשים. אם טבלת היעד אוכפת את
require_partition_filter = true, צריך לכלול פרדיקטWHEREבעמודת החלוקה למחיצות שיכולה לגזום מחיצות. שאילתות בטבלאות מחולקות למחיצות - ביטול כפילויות ב-
UPDATEאו ב-MERGEשורות מקור. אם הצהרתUPDATEאוMERGEנכשלת כי כמה שורות מקור תואמות לשורת יעד אחת, צריך לצבור או לבטל כפילויות במקורFROMאוUSING(לדוגמה, באמצעותGROUP BYאוQUALIFY ROW_NUMBER() OVER (...) = 1). מידע נוסף זמין במאמר מגבלות DML. - לא לחרוג מהמגבלות של המחיצות ושל המודלים של BigQuery ML. אם שאילתה נכשלת עם השגיאה
Too many partitions produced by query, allowed LIMIT, query produces at least COUNT partitions, צריך לפצל את השאילתה לקבוצות קטנות יותר שמשנות עד 4,000 מחיצות לכל משימה. אפשר גם להשתמש בחלוקה פחות מפורטת, כמו חלוקה חודשית במקום יומית, עם אשכולות, כך שכל משימה תשנה פחות מחיצות והטבלה תישאר במגבלה של 10,000 מחיצות. אם הצהרתCREATE MODELנכשלת עם השגיאהResource exhausted. The model might be too large, צריך לצמצם את מאפייני הקלט, לקבץ או לסנן ערכים קטגוריים עם עוצמה גבוהה, או לפשט את ארכיטקטורת המודל כשיוצרים מודל BigQuery ML. לדוגמה, אפשר להקטין את עומק העץ או את מספר העצים או היחידות הנסתרות. - בדיקת המגבלות של Time Travel, תצוגות מקוננות ושאילתות משנה בהתאם להודעת השגיאה, עיינו באחד מהקטעים הבאים:
FOR SYSTEM_TIME AS OFמחוץ לחלון השמירה. מידע נוסף זמין במאמר זמן לא חוקי של קובץ snapshot.- תצוגות או שגרות שחורגות ממגבלת עומק ההטמעה של 16 רמות. יותר מדי תצוגות בתוך תצוגות או פונקציות מתמידות בהגדרת המשתמש.
- שאילתות משנה מתואמות שלא נתמכות. למידע נוסף, קראו על שאילתות משנה מתואמות.
מצב הביצוע ומגבלות על בו-זמניות
מחרוזות שגיאה:
Concurrent conflicting update to DML transaction conflictאוCould not serialize access to table TABLE_NAME due to concurrent updateTransaction is aborted due to concurrent update against table TABLE_NAMEUPDATE or DELETE statement over table TABLE_NAME would affect rows in the streaming buffer, which is not supported
כדי לפתור שגיאות שקשורות למצב הביצוע ולביצוע בו-זמני, עיינו בקטע הרלוונטי להודעת השגיאה שקיבלתם:
- התנגשויות בין עסקאות או DML בו-זמניים. אפשר לקרוא מידע נוסף במאמרים הצהרות DML מתנגשות והעסקה בוטלה בגלל עדכון בו-זמני.
- DML בטבלאות עם מאגרי סטרימינג פעילים. למידע נוסף, קראו את המאמר פקודות DML בטבלאות עם מאגר נתונים זמני (buffer) להעברה בסטרימינג.
זמן לא תקין של תמונת המצב
מחרוזת השגיאה: Invalid snapshot time
השגיאה הזו יכולה להתרחש כשמנסים לשלוח שאילתה על נתונים היסטוריים שנמצאים מחוץ לחלון הזמן של Time Travel של מערך הנתונים. כדי לפתור את השגיאה, צריך לשנות את השאילתה כך שתיגש לנתונים היסטוריים בחלון הזמן של המסע בזמן של מערך הנתונים.
השגיאה הזו יכולה להופיע גם אם אחת מהטבלאות שמשמשות בשאילתה נמחקת ונוצרת מחדש אחרי שהשאילתה מתחילה. בדקו אם יש שאילתה או אפליקציה מתוזמנת שמבצעת את הפעולה הזו, שפעלה באותו זמן כמו השאילתה שנכשלה. אם כן, נסו להעביר את התהליך שמבצע את פעולת ההסרה והיצירה מחדש, כך שיפעל בזמן שלא מתנגש עם שאילתות שקוראות את הטבלה הזו.
המשרה כבר קיימת
מחרוזת השגיאה: Already Exists: Job <job name>
השגיאה הזו יכולה להתרחש במשימות של שאילתות שצריכות להעריך מערכים גדולים, כך שיצירת משימת השאילתה נמשכת יותר זמן מהממוצע. לדוגמה, שאילתה עם משפט WHERE כמו WHERE column IN (<2000+ elements array>).
כדי לפתור את השגיאה הזו, מבצעים את השלבים הבאים:
- אתם יכולים לאפשר ל-BigQuery ליצור ערך
jobIdאקראי במקום לציין ערך. - משתמשים בשאילתה עם פרמטרים כדי לטעון את המערך.
השגיאה הזו יכולה להתרחש גם כשמגדירים מזהה משימה באופן ידני, אבל המשימה לא מחזירה הצלחה בתוך פרק זמן קצוב. במקרה כזה, אפשר להוסיף handler של חריגות כדי לבדוק אם המשימה קיימת. אם כן, אפשר לשלוף את תוצאות השאילתה מהמשימה.
המשרה לא נמצאה
מחרוזת השגיאה: Job not found
השגיאה הזו יכולה להתרחש בתגובה לקריאה ל-getQueryResults, כשלא צוין ערך בשדה location. במקרה כזה, נסו לשלוח שוב את הקריאה ולספק ערך location.
מידע נוסף זמין במאמר הימנעות מהערכות מרובות של אותם ביטויי טבלה נפוצים (CTEs).
המיקום לא נמצא
מחרוזת השגיאה: Dataset [project_id]:[dataset_id] was not found in location [region]
השגיאה הזו מוחזרת כשמפנים למשאב של מערך נתונים שלא קיים, או כשהמיקום בבקשה לא תואם למיקום של מערך הנתונים.
כדי לפתור את הבעיה, צריך לציין את המיקום של מערך הנתונים בשאילתה או לוודא שמערך הנתונים זמין באותו מיקום.
השאילתה חורגת ממגבלת זמן ההרצה
מחרוזת השגיאה: Query fails due to reaching the execution time limit או Operation timed out after 6.0 hours. Consider reducing the amount of work
performed by your operation so that it can complete within this limit.
אם השאילתה מגיעה למגבלת זמן הביצוע של השאילתה, בודקים את זמן הביצוע של הרצות קודמות של השאילתה על ידי שליחת שאילתה לתצוגה INFORMATION_SCHEMA.JOBS באמצעות שאילתה שדומה לדוגמה הבאה:
SELECT TIMESTAMP_DIFF(end_time, start_time, SECOND) AS runtime_in_seconds FROM `region-us`.INFORMATION_SCHEMA.JOBS WHERE statement_type = 'QUERY' AND query = "my query string";
אם הרצות קודמות של השאילתה נמשכו הרבה פחות זמן, השתמשו בתובנות לגבי ביצועי השאילתה כדי לזהות את הבעיה הבסיסית ולטפל בה.
השאילתה חורגת ממגבלת הבייטים המקסימלית לחיוב
מחרוזת השגיאה: Query exceeded limit for bytes billed: LIMIT_BYTES. REQUIRED_BYTES or higher required.
שגיאת ה-HTTP 400 Bad Request (reason: bytesBilledLimitExceeded) מתרחשת כשהאומדן של מספר הבייטים לחיוב לפני הרצת השאילתה (REQUIRED_BYTES) חורג ממגבלת הבייטים שהוגדרה ב-maximumBytesBilled (LIMIT_BYTES). המערכת של BigQuery נכשלת בביצוע המשימה לפני ההרצה, ולא מחייבת על השאילתה.
בתמחור על פי דרישה יש מינימום של 10MB (10,485,760 בייטים) לכל טבלה שאליה מפנים, וההערכה לפני ההפעלה של טבלאות מסודרות באשכולות מחשבת גבול עליון בכל המחיצות התואמות לפני שמתרחש גיזום אשכולות. לכן, הערך של REQUIRED_BYTES יכול להיות גבוה יותר ממספר הבייטים שנסרקו בפועל כשהשאילתה פועלת.
כדי לפתור את הבעיה תוכלו לנסות אחד מהפתרונות הבאים:
- תצוגה מקדימה של כמות הבייטים המשוערת באמצעות הרצה יבשה. מריצים הרצת בדיקה (
bq query --dry_runב-CLI של bq אוconfiguration.dryRun = trueב-API) או בודקים את הכלי לתיקוף שאילתות במסוף Google Cloud כדי לבדוק אתtotalBytesProcessedלפני שמריצים את השאילתה. - לבצע אופטימיזציה של השאילתה כדי לסרוק פחות בייטים. בחרו רק את העמודות שהשאילתה צריכה במקום להריץ את
SELECT *, וסננו לפי עמודות מחולקות למחיצות כדי ש-BigQuery יוכל לקצץ מחיצות במהלך ההערכה שלפני ההפעלה. סינון של עמודות מקובצות מפחית את מספר הבייטים בפועל שמחויבים כשהשאילתה פועלת, אבל לא מפחית את האומדן של הגבול העליון לפני ההפעלה שנבדק מולmaximumBytesBilled. למידע נוסף, ראו צמצום הנתונים שעוברים עיבוד. - להגדיל את המגבלה של
maximumBytesBilled. מגדירים את מגבלת הבייטים שלmaximumBytesBilledלערך ששווה לערך שלREQUIRED_BYTESשדווח בהודעת השגיאה או גבוה ממנו, באמצעות Maximum bytes billed (בקטע Query settings > Advanced options) במסוף Google Cloud , הדגל--maximum_bytes_billedב-CLI של bq או מאפיין הגדרת המשימהconfiguration.query.maximumBytesBilledב-API.
התגובה לשאילתה גדולה מדי
מחרוזת השגיאה: responseTooLarge
השגיאה הזו מתרחשת כשתוצאות השאילתה גדולות מגודל התגובה המקסימלי, או כששורה אחת חורגת ממגבלת גודל השורה של ה-API בארכיטקטורת REST.
חלק מהשאילתות מבוצעות בכמה שלבים, והשגיאה הזו מתרחשת כששלב כלשהו מחזיר תגובה בגודל גדול מדי, גם אם התוצאה הסופית קטנה מהמקסימום. השגיאה הזו מתרחשת בדרך כלל כששאילתות משתמשות בסעיף ORDER BY. לפעמים אפשר לפתור את הבעיה על ידי הסרת הסעיף ORDER BY או הוספת הסעיף LIMIT. כדי להבטיח שתוצאות גדולות יוכלו לחזור, ציינו טבלת יעד בהגדרות של המשימה. בשאילתות SQL מדור קודם, צריך גם להגדיר את המאפיין configuration.query.allowLargeResults כ-true. למידע נוסף, קראו את המאמר כתיבת תוצאות של שאילתות גדולות.
חרגת ממגבלת הגודל של תשובה בשורה אחת
מחרוזות שגיאה:
Response too large to return. Message before conversion exceeds max row limit, limit: LIMIT actual: ACTUALResponse too large to return. single row too big to return due to byte limit, actual: ACTUAL limit: LIMIT
שגיאת ה-HTTP 403 Forbidden (reason: responseTooLarge) מתרחשת כשקוראים תוצאות של שאילתות או שורות בטבלה באמצעות ה-methods jobs.getQueryResults או tabledata.list של ה-API בארכיטקטורת REST (כולל הצגת תוצאות במסוף Google Cloud או בכלי שורת הפקודה של BigQuery), ושורה אחת שעברה סריאליזציה ולא עברה הטמעה חורגת מהגודל המקסימלי של שורה שנתמך על ידי נקודת הקצה של עימוד ב-REST (20MB ל-jobs.getQueryResults או 100MB ל-tabledata.list). בדרך כלל זה קורה בטבלאות עם סכימות רחבות, שדות ARRAY או STRUCT חוזרים עם הטמעה עמוקה, או ערכים גדולים של STRING או BYTES.
כדי לקרוא שורות שחורגות ממגבלות הגודל של API בארכיטקטורת REST, אתם יכולים:
- להשתמש ב-BigQuery Storage Read API. קוראים את הטבלה או את טבלת היעד של השאילתה הזמנית באמצעות Storage Read API, שמזרים נתונים בפורמט בינארי של Apache Arrow או Avro ותומך בקריאות של מבני שורות גדולים ומורכבים עם תפוקה גבוהה.
- מייצאים את הטבלה ל-Cloud Storage. מייצאים את הטבלה או את תוצאות השאילתה ל-Cloud Storage באמצעות הצהרת
EXPORT DATAאו משימת חילוץ (לדוגמה, בפורמט Avro, Parquet או JSON) וקוראים את הקבצים שיוצאו מ-Cloud Storage. - להקרין או לצבור פחות עמודות. במקום להריץ את
SELECT *, בחרו רק את העמודות או שדות המשנה הספציפיים שנדרשים לאפליקציה, או בטלו את הקינון של מערכים חוזרים בשאילתה כדי ששורות הפלט הנפרדות לא יחרגו ממגבלת הגודל.
חסר פרמטר חובה
מחרוזת השגיאה: Required parameter is missing: PARAMETER_NAME
שגיאת ה-HTTP 400 Bad Request (reason: required) היא שגיאת אימות של ה-API לפני ההפעלה. היא מתרחשת כשלא מספקים שדה חובה במטען הייעודי (payload) של בקשת ה-API או בכתובת ה-URL, או כשמאפיין חובה באובייקט ההגדרה של ספריית הלקוח הוא null או None.
כדי לפתור את השגיאה:
- לעיון במאמרי העזרה של ה-API בארכיטקטורת REST בודקים את
PARAMETER_NAMEבהודעת השגיאה, ומוודאים שהקוד מאכלס את כל שדות החובה. לשם כך, בודקים את גוף הבקשה ואת הפרמטרים של השאילתה שנדרשים לשיטה במאמרי העזרה של BigQuery REST API. - אימות הפרמטרים של ספריית הלקוח. אם אתם משתמשים בספריית לקוח של BigQuery (כמו ספריית הלקוח של Java או Python), עיינו במסמכי התיעוד של ספריית הלקוח כדי לבדוק מהם הפרמטרים הנדרשים של ה-method שאתם קוראים לה.
- בודקים את אובייקט ההגדרות האישיות לפני שקוראים ל-API. משתמשים בכלי לניפוי באגים או בפקודת רישום ביומן כדי לבדוק את אובייקט ההגדרה של המשימה או הבקשה מיד לפני שהקריאה ל-API מתבצעת, ובודקים אם יש ערכי
Noneאוnullשהוקצו למאפיינים הנדרשים כמוdestinationTable.
ההזמנה לא נמצאה או שחסרים בה משבצות זמן
מחרוזת השגיאה: Cannot run query: project does not have the reservation in the data region or no slots are configured
השגיאה הזו מתרחשת כשההקצאה שמוקצית לפרויקט באזור של השאילתה מכילה אפס מיקומים שהוקצו. אתם יכולים להוסיף משבצות למערך, לאפשר למערך להשתמש במשבצות פנויות, להשתמש במערך אחר או להסיר את ההקצאה ולהריץ את השאילתה על פי דרישה.
הטבלה לא נמצאה
מחרוזת השגיאה: Not found: Table [project_id]:[dataset].[table_name] was not found in location [region]
השגיאה הזו מתרחשת כשאי אפשר למצוא טבלה בשאילתה במערך הנתונים או באזור שציינתם. כדי לפתור את השגיאה הזו:
- בודקים שהשאילתה מכילה את השמות הנכונים של הפרויקט, מערך הנתונים והטבלה, ומוודאים שהמזהה משתמש באותיות רישיות או קטנות בדיוק כמו שצריך (ראו תלוי אותיות רישיות).
אם לא מציינים את מזהה הפרויקט בשאילתה, BigQuery בוחר כברירת מחדל את הפרויקט לחיוב שבו מבוצעת המשימה. כששולחים שאילתות לטבלאות בפרויקט אחר, צריך לציין את ה-
PROJECT_ID.DATASET_ID.TABLE_NAMEהמלא. - צריך לוודא שהטבלה קיימת במיקום שבו השאילתה פועלת. כברירת מחדל, כל מערך נתונים שהשאילתה קוראת ממנו או כותבת אליו חייב להיות באותו מיקום של משימת השאילתה. אם אתם מגדירים את מיקום המשימה בעצמכם (לדוגמה, באמצעות הדגל
--locationאו המאפייןlocationבהפניה למשימה), ודאו שהוא תואם למיקום של מערכי הנתונים. אזור יחיד, כמוus-central1, לא תואם למספר אזורים, כמוUS. מידע נוסף זמין במאמר ציון מיקומים. - כדי לשלוח שאילתות לטבלאות במיקומים שונים בשאילתה אחת, משתמשים בשאילתות עם אחזור נתונים גלובלי (גרסת טרום-השקה (Preview)). כדי להריץ שאילתות עם אחזור נתונים גלובלי, צריך להפעיל אותן בפרויקט שמריץ את השאילתה ובפרויקט שמכיל את הנתונים. אי אפשר להריץ אותן במצב Sandbox.
- כדי לבדוק אם פג התוקף של הטבלה או של מערך הנתונים, או אם הם נמחקו, שולחים שאילתה אל
INFORMATION_SCHEMA.TABLE_STORAGEאו בודקים ביומני הביקורת של Cloud אם יש אירועים מסוגDeleteTableאוInternalTableExpired. אם הטבלה נמחקה בתוך חלון הזמן של Time Travel (עד 7 ימים), אפשר לשחזר את הטבלה שנמחקה. אם גם קבוצת הנתונים הראשית נמחקה, צריך ליצור מחדש קבוצת נתונים ריקה עם אותו שם ומיקום בדיוק לפני שמעתיקים את תמונת המצב ההיסטורית. - אם אתם שולחים שאילתה לטבלת תוצאות אנונימית שנשמרה במטמון במערך נתונים מוסתר שמתחיל בקו תחתון (
_), שימו לב שהתוקף של טבלאות תוצאות שנשמרו במטמון פג אחרי כ-24 שעות. מריצים מחדש את השאילתה המקורית או כותבים את הפלט בטבלת יעדים קבועה. - אם אתם שולחים שאילתה לטבלה חיצונית שמגובה ב-Cloud Storage או ב-Google Drive, ודאו שקובצי המקור הבסיסיים עדיין קיימים בנתיב ה-URI שהוגדר (
Not found: URI,Not found: UrisאוNot found: Files). - חשוב לוודא שהטבלה לא נמחקה ונוצרה מחדש במהלך ביצוע המשימה. אחרת, השגיאה הזו יכולה להיגרם מהפצה חלקית של המטא-נתונים.
יותר מדי פקודות DML
מחרוזת השגיאה: Too many DML statements outstanding against <table-name>, limit is 20
השגיאה הזו מתרחשת כשחורגים מהמגבלה של 20 פקודות DML לשינוי בסטטוס PENDING בתור לטבלה אחת. השגיאה הזו בדרך כלל מתרחשת כששולחים משימות DML לטבלה אחת בקצב מהיר יותר מהקצב שבו BigQuery יכול לעבד אותן.
כדי לבדוק את המשימות בסטטוס PENDING שממלאות את התור לצד המשימות בסטטוס RUNNING שעשויות לחסום את ההוצאה שלהן מהתור, שולחים שאילתה לתצוגה INFORMATION_SCHEMA.JOBS:
SELECT
project_id,
job_id,
creation_time,
user_email,
statement_type,
state
FROM
`region-us`.INFORMATION_SCHEMA.JOBS
WHERE
statement_type IN ('UPDATE', 'DELETE', 'MERGE', 'TRUNCATE_TABLE')
AND state IN ('RUNNING', 'PENDING')
ORDER BY
creation_time DESC;
פתרון אפשרי אחד הוא לקבץ כמה פעולות DML קטנות יותר למשימות גדולות יותר אך מעטות יותר – לדוגמה, על ידי חבילת עדכונים והוספות. כשמקבלים משימות קטנות יותר למשימות גדולות יותר, עלות ההרצה של המשימות הגדולות יותר מופחתת והביצוע מהיר יותר. איחוד של פקודות DML שמשפיעות על אותם נתונים בדרך כלל משפר את היעילות של משימות DML, ומקטין את הסיכוי לחרוג ממגבלת המכסה של גודל התור. למידע נוסף על אופטימיזציה של פעולות DML, ראו הימנעות מהצהרות DML שמעדכנות או מוסיפות שורות בודדות.
פתרונות אחרים לשיפור היעילות של DML יכולים להיות חלוקה למחיצות או אשכולות של הטבלאות. מידע נוסף זמין בקטע בנושא שיטות מומלצות.
שגיאה 403: חריגה מהמכסה
מחרוזת השגיאה: 403 Quota exceeded: Your table exceeded quota for total number of
DML jobs writing to a table, pending + running.
השגיאה הזו מתרחשת כשמספר המשימות הכולל של DML (INSERT, UPDATE, DELETE ו-MERGE) שכותבות לטבלה אחת – גם במצב PENDING וגם במצב RUNNING – חורג ממכסת המשימות בו-זמנית של הטבלה.
השגיאה limit is 20 מגבילה באופן ספציפי את התור PENDING להצהרות DML שמשנות נתונים (UPDATE, DELETE ו-MERGE), אבל השגיאה 403 Quota
exceeded חלה על המספר הכולל של כל משימות ה-DML (INSERT וגם DML שמשנה נתונים) שכותבות לטבלה בו-זמנית. מכיוון ש-DML לשינוי נתונים כבר מוגבל על ידי מגבלת התור של 20 משימות, שגיאת המכסה 403 מתרחשת בדרך כלל כששולחים יותר מדי שאילתות INSERT בו-זמנית בטבלה אחת. כדי לפתור את השגיאה:
- הגדלת מספר המשבצות בהזמנה: הגדלת מספר המשבצות בהזמנה כדי לעזור למשימות להסתיים מהר יותר ולהפחית את מספר המשימות שפועלות בו-זמנית. כך אפשר לצמצם את מספר המשימות הממתינות בתור ולהימנע מהגעה למגבלה.
- אופטימיזציה של תזמור תהליכי עבודה: הגבילו את מספר משימות ה-DML שפועלות בו-זמנית בכלי התזמור, כדי להימנע מחריגה ממגבלות הפעולות בו-זמנית ברמת הטבלה (כולל שאילתות
INSERTבתדירות גבוהה שמטרגטות את אותה טבלה). - פעולות DML באצווה: משלבים כמה פקודות DML קטנות יותר לפחות פקודות גדולות יותר, כדי לצמצם את המספר הכולל של המשימות בתור לטבלה.
יותר מדי תצוגות בתצוגות או פונקציות מתמידות בהגדרת המשתמש
מחרוזת השגיאה: Too many nested views/persistent user-defined functions or possible circular reference of views/persistent user-defined functions referenced in query. Only 16 levels of nested views/persistent user-defined functions are allowed.
שגיאת ה-HTTP 400 Bad Request (reason: invalidQuery) מתרחשת כששאילתה או יצירת תצוגה מפנות לשרשרת של תצוגות או פונקציות מתמידות בהגדרת המשתמש (UDF) שחורגות מעומק ההטמעה המקסימלי הנתמך של 16 רמות, או כששאילתה מפנה לתצוגות או לפונקציות UDF שמפנות זו לזו בלולאת תלות מעגלית (לדוגמה, view_a שולחת שאילתה ל-view_b, ששולחת שאילתה ל-view_a). לפרטים על מגבלות של תצוגות ופונקציות, ראו מגבלות של תצוגות ומגבלות של פונקציות UDF. אם השגיאות נגרמות בגלל חריגה ממגבלת ההטמעה של 15 רמות בעמודות STRUCT (RECORD), בקובצי טעינה או בסוגי החזרה וארגומנטים של שגרות מוטמעות, קראו את המאמר פתרון שגיאות שקשורות למגבלת ההטמעה של סכימות, קבצים ושגרות.
אפשר ליצור תצוגות עם עד 16 רמות של היררכיה, אבל שאילתות יכולות להפנות רק לתצוגות עם עד 15 רמות של היררכיה.
אי אפשר להגדיל את המכסה הזו. כדי לפתור את השגיאה:
- בודקים אם יש הפניות מעגליות. בודקים את ההגדרות של התצוגות והפונקציות המתמידות בשרשרת השאילתות, כדי לוודא שאף תצוגה או פונקציה לא מפנה לעצמה באופן ישיר או עקיף.
- איחוד תצוגות עם היררכיית כללים כדי לשנות את המבנה של שרשראות של תצוגות בתצוגות, צריך לשלב לוגיקת ביניים בביטויים נפוצים של טבלאות (סעיפי
WITH) בתצוגה או בשאילתה אחת. - התממשות של שכבות ביניים. החליפו שכבות ביניים בהיררכיית תצוגות עמוקה בשאילתות מתוזמנות שכותבות לטבלאות פיזיות, או השתמשו בתצוגות מהותיות אם יש תמיכה בהן.
העסקה בוטלה בגלל עדכון שמתבצע בו-זמנית
מחרוזת השגיאה: Transaction is aborted due to concurrent update against table [table_name]
השגיאה הזו יכולה להתרחש כששתי פקודות DML שונות לשינוי מנסות לעדכן בו-זמנית את אותה טבלה. לדוגמה, נניח שאתם מתחילים טרנזקציה בסשן שמכיל פקודת DML לשינוי, ואחריה שגיאה. אם אין מטפל חריגים, BigQuery מחזיר את הטרנזקציה למצב הקודם באופן אוטומטי כשהסשן מסתיים, תוך עד 24 שעות. במהלך הזמן הזה, ניסיונות אחרים להריץ פקודת DML לשינוי בטבלה ייכשלו.
כדי לפתור את השגיאה, מציגים את הסשנים הפעילים ובודקים אם אחד מהם מכיל משימת שאילתה בסטטוס ERROR שהריצה פקודת DML לשינוי בטבלה. מבטלים את הטרנזקציה שלא אושרה על ידי הפעלת ROLLBACK TRANSACTION; באותו סשן, או מסיימים את הסשן על ידי הפעלת CALL BQ.ABORT_SESSION(SESSION_ID);. כדי למנוע מצב שבו טרנזקציות עם כמה הצהרות שנכשלו ינעלו טבלאות עד שהסשן יסתיים, צריך לכלול handler של EXCEPTION WHEN ERROR THEN ROLLBACK TRANSACTION; בטרנזקציות עם כמה הצהרות.
שגיאה 412: המשימה מפנה לטבלה ששייכת למערך נתונים של יתירות כשל
מחרוזת השגיאה: Error 412: The job references a table that belongs to a failover dataset in the ... region (PROJECT_ID:DATASET_ID). However, only jobs that run on a reservation with the "ENTERPRISE_PLUS" edition can modify or write to failover datasets. Please also make sure that the job that is writing to the failover dataset is running in the current primary location.
זה אומר שהמשימה לא הופעלה במהדורת BigQuery Enterprise Plus, או שהיא הופעלה באזור שהוא לא המיקום הראשי של מערך הנתונים לגיבוי. פרטים נוספים זמינים במאמר תוכנית התאוששות מאסון (DR) מנוהלת.
שגיאה בטעינת התצוגה כשמשתמשים בתוצאות שנשמרו במטמון
מחרוזת השגיאה: BigQuery data export: There was an error loading this view. IAM
setPolicy failed for Dataset <PROJECT_ID>. One or more users named in the policy
do not belong to a permitted customer.
השגיאה הזו מעידה על כך שמספרי הלקוח שלכם ב-Google Workspace לא קיבלו גישה באילוץ של מדיניות הארגון.
iam.allowedPolicyMemberDomains
איך משתמשים באילוץ iam.allowedPolicyMemberDomains כדי להטמיע הגבלת שיתוף
בדומיין
שגיאות ב-SQL מדור קודם
השגיאות הבאות יכולות להתרחש כשמשתמשים ב-SQL מדור קודם.
Cannot be queried with legacy SQL
מחרוזת השגיאה: cannot be queried with legacy SQL. Please consider switching to standard SQL
השגיאה הזו יכולה להופיע באחד משני תרחישים:
השאילתה נכתבה ב-SQL סטנדרטי, אבל הוגדרה האפשרות להשתמש ב-SQL מדור קודם. חשוב להריץ את השאילתה באמצעות SQL סטנדרטי, לפי המסמכים שזמינים לכולם. לדוגמה, אפשר להוסיף את
--use_legacy_sql=falseבאמצעות כלי שורת הפקודה של BigQuery.אתם מנסים לשלוח שאילתה לטבלה עם איסוף באמצעות SQL מדור קודם, וזה לא נתמך.
אי אפשר להריץ שאילתות על טבלאות עם עמודות ששמן השתנה באמצעות SQL מדור קודם
מחרוזת השגיאה: Table project:dataset.table with renamed columns cannot be queried with legacy SQL. Please consider switching to standard SQL or dropping column my_column
השגיאה הזו מתרחשת אם שולחים שאילתה לטבלה עם עמודה ששמה השתנה באמצעות SQL מדור קודם. במקום זאת, אתם צריכים להשתמש ב-SQL סטנדרטי.
למשתמש אין הרשאה
מחרוזות שגיאה:
Access Denied: Project [project_id]: User does not have bigquery.jobs.create permission in project [project_id].User does not have permission to query table project-id:dataset.table.Access Denied: User does not have permission to query table or perhaps it does not exist.
השגיאות האלה יכולות להתרחש כשמריצים שאילתה בלי ההרשאה bigquery.jobs.create בפרויקט שממנו מריצים את השאילתה, בלי קשר להרשאות בפרויקט שמכיל את הנתונים.
השגיאות האלה יכולות להופיע גם אם לחשבון השירות, למשתמש או לקבוצה אין את ההרשאה bigquery.tables.getData בכל הטבלאות והתצוגות שהשאילתה מפנה אליהן. למידע נוסף על ההרשאות הנדרשות להרצת שאילתה, קראו את המאמר התפקידים הנדרשים.
השגיאות האלה יכולות להתרחש גם אם הטבלה לא קיימת באזור שבו בוצעה השאילתה, כמו asia-south1. כדי לאמת את האזור, בודקים את מיקום קבוצת הנתונים.
כשמטפלים בשגיאות האלה, חשוב לזכור:
חשבונות שירות: לחשבונות השירות צריכה להיות ההרשאה
bigquery.jobs.createבפרויקט שממנו הם פועלים, וההרשאהbigquery.tables.getDataבכל הטבלאות והתצוגות שאליהן מתייחסת השאילתה.תפקידים בהתאמה אישית: בתפקידי IAM בהתאמה אישית, ההרשאה
bigquery.jobs.createצריכה להיכלל באופן מפורש בתפקיד הרלוונטי, וצריכה להיות להם ההרשאהbigquery.tables.getDataבכל הטבלאות והתצוגות שהשאילתה מפנה אליהן.מערכי נתונים משותפים: כשעובדים עם מערכי נתונים משותפים בפרויקט נפרד, יכול להיות שעדיין תצטרכו את ההרשאה
bigquery.jobs.createבפרויקט כדי להריץ שאילתות או משימות במערך הנתונים הזה.
כדי לתת הרשאת גישה לטבלה או לתצוגה, קראו את המאמר מתן גישה לטבלה או לתצוגה.
ההרשאה bigquery.reservations.use נדחתה בהזמנה
מחרוזת השגיאה:
Access Denied: Reservation projects/project/locations/region/reservations/reservation_name: Permission bigquery.reservations.use denied on reservation projects/project/locations/region/reservations/reservation_name (or it may not exist)
השגיאה הזו מתרחשת כששאילתה מוקצית להרצה בהזמנה ספציפית באמצעות ההצהרה SET @@reservation, ולחשבון המשתמש או לחשבון השירות חסרה ההרשאה bigquery.reservations.use. כדי לזהות את החשבון הראשי שניסה לבצע את הפעולה, אתם יכולים לבדוק את השגיאה ב-Cloud Logging או בדף המשימות של BigQuery.
שגיאות אחרות ב-Access Denied
מחרוזות שגיאה:
Access Denied: Dataset project_id:dataset_id: Permission bigquery.datasets.get denied on dataset project_id:dataset_id (or it may not exist).Access Denied: Dataset project_id:dataset_id: Permission bigquery.datasets.update denied on dataset project_id:dataset_id (or it may not exist).Access Denied: BigQuery BigQuery: User does not have permission to access data protected by policy tag
כדי לפתור שגיאות כלליות של Access Denied ב-BigQuery, אתם יכולים להשתמש בכלי הניתוח למדיניות כדי לקבוע איזו גישה יש לחשבון משתמש במשאב.
בכלי הניתוח למדיניות, מציינים את המשאב ב-BigQuery שמנסים לגשת אליו (לדוגמה, //bigquery.googleapis.com/projects/YOUR_PROJECT/datasets/YOUR_DATASET/tables/YOUR_TABLE) ואת כתובת האימייל של המשתמש או של חשבון השירות שמופיעה בהם השגיאה Access Denied בתור חשבון המשתמש. בניתוח מוצגות ההרשאות של חשבון המשתמש במשאב, ואפשר להשוות אותן להרשאות החסרות שמופיעות בהודעת השגיאה.
אין תמיכה בהצפנת יעד בסקריפטים
מחרוזת השגיאה: configuration.query.destinationEncryptionConfiguration cannot be set for scripts
השגיאה הזו מתרחשת כשמנסים להגדיר את ההצפנה של היעד למשימת סקריפט ב-BigQuery, וזה לא נתמך.
הגישה נדחתה בגלל מדיניות הארגון
מחרוזת השגיאה:
IAM setPolicy failed for Dataset DATASET: Operation
denied by org policy on resource.
השגיאה הזו מתרחשת כשמדיניות הארגון מונעת מחשבון המשתמש לשלוח שאילתות למשאב BigQuery. שירות מדיניות הארגון מאפשר לאכוף אילוצים על משאבים נתמכים בהיררכיית הארגון.
אם לחשבון המשתמש צריכה להיות גישה למשאב, תצטרכו להשתמש בכלים הזמינים לפתרון בעיות ב-VPC כדי לאבחן את הבעיה במדיניות הארגון.
בעיות של חריגה מהמשאבים
הבעיות הבאות נגרמות כשאין ל-BigQuery מספיק משאבים כדי להשלים את השאילתה.
השאילתה חורגת ממשאבי המעבד (CPU)
מחרוזת השגיאה: Query exceeded resource limits. This query used
CPU_SECONDS_USED CPU seconds but would charge only
ANALYSIS_MEGABYTES_BILLEDM Analysis bytes. This exceeds the ratio
supported by the on-demand pricing model. Please consider moving this workload
to a capacity-based pricing model, which does not have this limit.
CPU_SECONDS_USED CPU seconds were used, and this query must use less
than CPU_SECONDS_LIMIT CPU seconds.
השגיאה הזו (billingTierLimitExceeded) מתרחשת כששאילתה שמשתמשת בתמחור על פי דרישה חורגת מהמגבלה המקסימלית של שימוש במעבד (CPU) לנתונים שנסרקו, שהיא בערך 256 שניות מעבד לכל MiB של נתונים שנסרקו. זה קורה כששאילתה על פי דרישה מבצעת פעולות שדורשות הרבה משאבי מעבד (CPU), כמו פעולות CROSS
JOIN לא מוגבלות, תנאי איחוד לא מדויקים, ביטויים רגולריים מורכבים, פונקציות אנליטיות (window functions) לא מחולקות למחיצות או פונקציות JavaScript UDF שדורשות הרבה משאבי מחשוב, על כמות קטנה יחסית של נתונים סרוקים.
כדי לפתור את השגיאה הזו, מבצעים אחת מהפעולות הבאות:
- מבצעים אופטימיזציה של השאילתה. משכתבים את קוד ה-SQL כדי להפחית את התקורה של החישוב ביחס לנתונים שנסרקו. למשל, מסירים מכפלות קרטזיות לא מכוונות (פעולות
CROSS JOINללא סינון), מחליפים פרדיקטים לא מדויקים של צירוף, מפשטים ביטויים רגולריים מורכבים, מוסיפים משפטיPARTITION BYלפונקציות אנליטיות בחלונות גדולים ללא חלוקה למחיצות או מבצעים אופטימיזציה של פונקציות JavaScript בהגדרת המשתמש (UDF). למידע נוסף, קראו את המאמרים הימנעות מדפוסי אנטי-SQL, מבוא לאופטימיזציה של ביצועי שאילתות ופתרון בעיות של חריגה מהמשאבים. - עוברים לתמחור מבוסס-קיבולת. מריצים את עומס העבודה באמצעות תמחור מבוסס-קיבולת (משבצות). בתמחור מבוסס-קיבולת, השאילתות לא כפופות למגבלת היחס בין מעבד (CPU) לבייטים על פי דרישה.
השאילתה חורגת ממשאבי הזיכרון
מחרוזת השגיאה: Resources exceeded during query execution: The query could not be executed in the allotted memory
בהצהרות SELECT, השגיאה הזו מתרחשת כשהשאילתה משתמשת ביותר מדי משאבים.
כדי לפתור את הבעיה, קראו את המאמר פתרון בעיות שקשורות לחריגה מהמשאבים.
נגמר המקום במחסנית
מחרוזת השגיאה: Out of stack space due to deeply nested query expression during query resolution.
השגיאה הזו יכולה לקרות כששאילתה מכילה יותר מדי קריאות להפעלת פונקציות בתצורה של עץ.
לפעמים, חלקים משאילתה מתורגמים לקריאות להפעלת פונקציות במהלך הניתוח.
לדוגמה, ביטוי עם אופרטורים חוזרים של שרשור, כמו A || B || C || ...CONCAT(A, CONCAT(B, CONCAT(C, ...)))
כדי לפתור את השגיאה הזו, צריך לשכתב את השאילתה כך שתכיל פחות רמות של הטמעה.
חריגה מהמשאבים במהלך הרצת השאילתה
מחרוזת השגיאה: Resources exceeded during query execution: The query could not be executed in the allotted memory. Peak usage: [percentage]% of limit. Top memory consumer(s): ORDER BY operations.
זה יכול לקרות עם שאילתות של ORDER BY ... LIMIT ... OFFSET .... בגלל פרטי ההטמעה, יכול להיות שהמיון יתבצע ביחידת מחשוב אחת, שעלולה לחרוג ממגבלת הזיכרון אם היא צריכה לעבד יותר מדי שורות לפני החלת LIMIT ו-OFFSET, במיוחד עם OFFSET גדול.
כדי לפתור את השגיאה הזו, צריך להימנע מערכים גדולים של OFFSET בשאילתות ORDER BY ... LIMIT. לחלופין, אפשר להשתמש בפונקציה האנליטית (window function) הניתנת להתאמה ROW_NUMBER() כדי להקצות דירוגים על סמך הסדר שנבחר, ואז לסנן את הדירוגים האלה בסעיף WHERE. לדוגמה:
SELECT ...
FROM (
SELECT ROW_NUMBER() OVER (ORDER BY ...) AS rn
FROM ...
)
WHERE rn > @start_index AND rn <= @page_size + @start_index -- note that row_number() starts with 1
נגמר הזיכרון של ה-worker ב-TensorFlow
מחרוזת השגיאה: Resources exceeded during query execution: TENSORFLOW worker out
of memory.
השגיאה הזו יכולה להופיע במודלים שחורגים ממגבלת הזיכרון (בדרך כלל 250MB), במיוחד כשמשתמשים בפונקציות שצורכות הרבה משאבים כמו ML.EXPLAIN_PREDICT.
כדי לפתור את השגיאה הזו:
שימוש במודלים מרוחקים של Gemini Enterprise Agent Platform: אם המודלים חורגים ממגבלות הזיכרון, אתם יכולים לפרוס את המודל ב-Agent Platform באמצעות השלבים של Vertex AI SDK ל-Python כדי לפרוס מודל, ואז לגשת אליו באמצעות מודלים מרוחקים. כך דרישות הזיכרון מועברות לתשתית ייעודית של Agent Platform.
אופטימיזציה של המודל: מפחיתים את נפח ה-RAM שהמודל תופס באמצעות פישוט, כימות או גיזום של הארכיטקטורה.
שימוש בפונקציות פחות אינטנסיביות: אם השגיאה מתרחשת במהלך קריאה ל-
ML.EXPLAIN_PREDICT, נסו להריץ את המשימה עםML.PREDICTכדי לקבוע אם המודל יכול לפעול בלי התקורה הנוספת של תכונות ההסבר.ניתוח גודל נתוני הקלט: שורות בודדות גדולות יכולות לגרום לניצול יתר של הזיכרון. כדי לבדוק את הגודל של השורות הכי גדולות, משתמשים בפקודה:
SELECT BYTE_LENGTH(TO_JSON_STRING(t)) AS row_size FROM your_table AS t ORDER BY row_size DESC LIMIT 10
השאילתה חורגת ממשאבי ה-shuffle
מחרוזת השגיאה: Resources exceeded during query execution: Your project or organization exceeded the maximum disk and memory limit available for shuffle operations
השגיאה הזו מתרחשת כששאילתה לא יכולה לגשת למספיק משאבי ערבוב.
כדי לפתור את השגיאה הזו, צריך להקצות יותר יחידות קיבולת (Slots) או להפחית את כמות הנתונים שעוברים עיבוד נתונים על ידי השאילתה. למידע נוסף על דרכים לעשות זאת, ראו מכסת ערבוב לא מספיקה.
אם אתם משתמשים במודל התמחור על פי דרישה, אתם מוגבלים למקסימום של 2,000 משבצות. כדי להגדיל את מספר המשבצות, צריך לעבור למודל תמחור מבוסס-קיבולת.
למידע נוסף על פתרון הבעיות האלה, ראו פתרון בעיות של חריגה מהמשאבים.
השאילתה מורכבת מדי
מחרוזות שגיאה:
Resources exceeded during query execution: Not enough resources for query planning - too many subqueries or query is too complex.Resources exceeded during query execution: Not enough resources for query planning - too many fields accessed or query is too complex.Resources exceeded during query execution: Not enough resources for query planning - query is too complex.Resources exceeded during query execution: The query is too complex.
השגיאה הזו מתרחשת כשהשאילתה מורכבת מדי אחרי הרחבה של תצוגות, משפטי WITH ופונקציות SQL בהגדרת המשתמש (UDF) במהלך תכנון השאילתה. הסיבות העיקריות למורכבות הן:
- פסוקיות
WITHשמוטמעות עמוק או שנעשה בהן שימוש חוזר. - תצוגות שמוטמעות עמוק או שנעשה בהן שימוש חוזר.
- שימוש חוזר באופרטור
UNION ALL. - פונקציות מוגדרות-משתמש (UDF) מורכבות ב-SQL או טבלאות רחבות עם הפניות שנוספו להן הרבה עמודות.
כדי לפתור את השגיאה, נסו את האפשרויות הבאות:
- לפצל את השאילתה לכמה שאילתות, ואז להשתמש בשפה פרוצדורלית כדי להריץ את השאילתות האלה ברצף עם מצב משותף.
- השתמשו בטבלאות זמניות במקום בסעיפי
WITHאו בתצוגות עם רמות עמוקות של בתצוגות בתצוגות. איך נמנעים מהערכות מרובות של אותם ביטויי CTE - לשכתב את השאילתה כדי לצמצם את מספר האובייקטים, העמודות וההשוואות שאליהם היא מפנה.
כדי לעקוב באופן יזום אחרי שאילתות שמתקרבות למגבלת המורכבות, אפשר להשתמש בשדה query_info.resource_warning בתצוגה INFORMATION_SCHEMA.JOBS.
בדוגמה הבאה מוחזרות שאילתות עם שימוש גבוה במשאבים בשלושת הימים האחרונים:
SELECT
ANY_VALUE(query) AS query,
MAX(query_info.resource_warning) AS resource_warning
FROM
<your_project_id>.`region-us`.INFORMATION_SCHEMA.JOBS
WHERE
creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 3 DAY)
AND query_info.resource_warning IS NOT NULL
GROUP BY
query_info.query_hashes.normalized_literals
LIMIT
1000
למידע נוסף על פתרון הבעיות האלה, ראו פתרון בעיות של חריגה מהמשאבים.
פתרון בעיות שקשורות לחריגה מהמשאבים
למשימות של שאילתות:
כדי לשפר את השאילתות, נסו את השלבים הבאים:
- אם מדווחת השגיאה
Top memory consumer(s): ORDER BY operations, נסו להסיר פסוקיתORDER BY(במיוחד בתוך שאילתות משנה או פסוקיותWITH), להוסיף פסוקיתLIMITאו להוסיף עימוד באמצעותROW_NUMBER() OVER (ORDER BY ...)במקוםOFFSETגדול. למידע נוסף, קראו את המאמר השאילתה חורגת ממשאבי הזיכרון. - אם השאילתה נכשלת עם
Top memory consumer(s): sort operations used for analytic OVER() clausesאוanalytic OVER() clauses, צריך לשכתב את השאילתה כדי להפחית את כמות הנתונים בכל מחיצת חלון (להוסיף או לחדד את המפתחPARTITION BY), או להחליף אתRANGE BETWEENבמסגרת חלוןROWS BETWEENמוגבלת, אם רלוונטי. - אם השאילתה משתמשת ב-
JOIN(או נכשלת עםTop memory consumer(s): JOIN operations), ודאו שהטבלה הגדולה יותר נמצאת בצד שמאל של הסעיף, ושהנתונים לא מכילים מפתחות צירוף כפולים. אםCROSS JOINואחריוGROUP BYחורגים מהזיכרון, צריך לשמור את תוצאת הביניים שלCROSS JOINבטבלה זמנית לפני שמריצים אתGROUP BY. - אם פקודת DML לשינוי נכשלת עם
Top memory consumer(s): sort operation used for table update (UPDATE/DELETE/MERGE), צריך לפצל את הפקודהUPDATEאוMERGEכדי לעדכן פחות שורות או עמודות בכל פעם (או להחליף אתMERGEשמשתמשת ב-ON FALSEב-INSERTוב-DELETEבתוך טרנזקציה עם כמה פקודות). - אם השאילתה נכשלת עם
Top memory consumer(s): query parsing and optimization, צריך לאחסן רשימות גדולות של ערכים מילוליים בטבלה זמנית במקום בתוך הטקסט של השאילתה, או לפצל את השאילתה לשאילתות קטנות יותר. - אם השאילתה נכשלת עם השגיאה
UDF out of memoryאוTop memory consumer(s): non-SQL user-defined functions, אל תצברו יותר מדי מצבים מקומיים בפונקציות UDF ב-JavaScript, עבדו את נתוני הקלט בחלקים קטנים יותר או כתבו מחדש את פונקציית ה-UDF באמצעות פונקציות UDF ב-SQL או פונקציות GoogleSQL מובנות. שיטות מומלצות לפונקציות JavaScript מוגדרות-משתמש - אם השאילתה משתמשת ב-
FLATTEN, צריך לבדוק אם זה נחוץ לתרחיש לדוגמה. מידע נוסף זמין במאמר נתונים בתצוגת עץ ונתונים חוזרים. - אם השאילתה משתמשת ב-
EXACT_COUNT_DISTINCT, כדאי להשתמש במקום זאת ב-COUNT(DISTINCT). - אם השאילתה משתמשת ב-
COUNT(DISTINCT <value>, <n>)עם ערך<n>גדול, כדאי להשתמש ב-GROUP BYבמקום זאת. מידע נוסף זמין במאמרCOUNT(DISTINCT). - אם השאילתה משתמשת ב-
UNIQUE, כדאי להשתמש ב-GROUP BYבמקום זאת, או בפונקציה אנליטית (window function) בתוך בחירת משנה. - אם השאילתה שלכם יוצרת שורות רבות באמצעות סעיף
LIMIT, כדאי לסנן לפי עמודה אחרת, למשלROW_NUMBER(), או להסיר את הסעיףLIMITלגמרי כדי לאפשר כתיבה במקביל. - אם השאילתה השתמשה בתצוגות עם רמות עמוקות של הטמעה ובסעיף
WITH, זה יכול לגרום לעלייה חדה במורכבות, וכך להגיע למגבלות. - להשתמש בטבלאות זמניות במקום בסעיפי
WITH. יכול להיות שיהיה צורך לחשב מחדש כמה פעמים משפטWITH, מה שעלול להפוך את השאילתה למורכבת ולכן לאיטית. שמירת תוצאות ביניים בטבלאות זמניות מפחיתה את המורכבות. - מומלץ להימנע משימוש בשאילתות
UNION ALL. - אם השאילתה משתמשת ב-
MATCH_RECOGNIZE, צריך לשנות את הסעיףPARTITION BYכדי להקטין את המחיצות, או להוסיף סעיףPARTITION BYאם הוא לא קיים. - אם המשימה נכשלת עם השגיאה
Table TABLE_NAME will have N partitions when the job finishes, exceeding limit 10000, סימן שהשלמת המשימה חורגת ממגבלת 10,000 המחיצות של טבלת היעד. אם משימת העתקה עם כמה טבלאות מקור נכשלת עם השגיאהCOUNT partitions will be copied to the table TABLE_NAME, which exceeds the limit 10000 for number of partitions in the table, סימן שטבלאות המקור מכילות יותר מ-10,000 מחיצות נפרדות. בודקים את מספר המחיצות בטבלה ב-INFORMATION_SCHEMA.PARTITIONS, מגדירים תפוגת תוקף למחיצה, מוחקים באופן מפורש מחיצות מיותרות או משתמשים במחיצות גסות יותר, כמו חודשיות במקום יומיות, עם אשכולות. יכול להיות שיעבור זמן עד שמחיצות שתוקפן פג לאחרונה יופיעו בספירת המחיצות, אלא אם תמחקו אותן באופן מפורש. אם השאילתה נכשלת עם השגיאהToo many partitions produced by query, allowed LIMIT, query produces at least COUNT partitions, עיינו בקטע מגבלות ארכיטקטוניות ומגבלות על תכונות. - אם המשימה נכשלת עם השגיאה
Too many output columns, בחרו רק את העמודות הנדרשות במקום להשתמש ב-SELECT *, או צמצמו את מספר עמודות הפלט והשדות בתצוגת עץ בתוצאה. תוצאות רחבות או מקוננות עמוקות יכולות לחרוג מתקציב הזיכרון לכתיבת הפלט, גם במסגרת המגבלה של 10,000 עמודות. - אם המשימה נכשלת עם השגיאה
Cloud KMS Error: Project 'PROJECT_NUMBER' exceeded limit for metric METRIC_NAME, למשלcloudkms.googleapis.com/hsm_symmetric_requests, כשניגשים לטבלאות שמוגנות באמצעות מפתחות הצפנה בניהול הלקוח (CMEK), המשימה חרגה ממגבלת הקצב של Cloud Key Management Service (Cloud KMS). כדאי להריץ את השאילתות במקביל על טבלאות שמוצפנות באמצעות CMEK, או לבקש להגדיל את המכסה ב-Cloud KMS למדד שמופיע בהודעת השגיאה. - אם המשימה נכשלת עם השגיאה
Streaming read system resources exceeded, table: TABLE_NAME, נסו שוב את השאילתה באמצעות השהיה מעריכית קטועה לפני ניסיון חוזר (truncated exponential backoff). - אם שאילתה עם אחזור נתונים גלובלי נכשלת עם השגיאה
Global query response is too large. Query returned more than BYTES bytes. Consider editing your query to return smaller results., סימן ששאילתת משנה מרוחקת בין אזורים חרגה ממגבלת העברת הנתונים בין אזורים. מוסיפים מסנניWHEREובוחרים רק את העמודות הנדרשות בטבלאות המרוחקות כדי להקטין את גודל התוצאה של שאילתת המשנה שמועברת בין אזורים. אפשר גם ליצור תצוגה באזור המרוחק כדי להכיל ביטויים מורכבים או להחזיר שדותSTRUCTנדרשים כעמודות נפרדות ללא סוגיSTRUCT, כך שניתן יהיה להעביר את המסננים למטה. אפשר גם לפצל את השאילתה לשאילתות קטנות יותר עם טווחי סינון צרים יותר. - אם המשימה נכשלת עם השגיאה
Too many DML statements outstanding against table TABLE_NAME, limit is 20, קבצו כמה הצהרותUPDATE,DELETEאוMERGEקטנות יותר למספר קטן יותר של משימות גדולות יותר, או חלקו את טבלת היעד למחיצות ולאשכולות. אפשר לקרוא מידע נוסף במאמרים יותר מדי פקודות DML ויותר מדי פקודות DML ממתינות לטבלה. - אם המשימה נכשלת עם השגיאה
All our servers are busy processing data transferred between regions. Please try again shortly., נסו שוב את השאילתה או הפחיתו את הקצב של שאילתות ה-JOIN בו-זמנית חוצות-עננים (BigQuery Omni),CREATE TABLE AS SELECT,INSERT INTO SELECTאוLOAD DATA(או פנו לתמיכה כדי לבקש מגבלה גבוהה יותר על קצב השאילתות להעברה בין אזורים). למידע נוסף, קראו את המאמרים מגבלות על צירוף ב-BigQuery Omni וטעינת נתונים באמצעות העברה חוצת-עננים. - אם המשימה נכשלת עם השגיאה
Google Sheets service overloaded for spreadsheet id: SPREADSHEET_ID, נסו שוב את עומס היתר הזמני ב-Google Sheets, או העתיקו את נתוני הגיליון האלקטרוני לטבלה קבועה ב-BigQuery (ושנו את המבנה של התצוגות או פזרו את השאילתות המתוזמנות כדי לצמצם את הקריאות בו-זמנית לאותו גיליון אלקטרוני). - אם שאילתת BigQuery Omni נכשלת עם השגיאה
Response too large. Query returned ACTUAL_MBMB, and limit is LIMIT_MBMB., סימן שפלט השאילתה חרג מהגודל המקסימלי של תוצאת שאילתה ב-BigQuery Omni או ממגבלת ההעברה חוצת-העננים. מסננים או צוברים את השאילתה כדי להחזיר תוצאות קטנות יותר, או משתמשים בהצהרהEXPORT DATAכדי לייצא תוצאות גדולות ישירות לאחסון חיצוני במקום לטבלת יעד.
מידע נוסף זמין במקורות המידע הבאים:
במשימות טעינה:
אם אתם טוענים קובצי Avro או Parquet, הקטינו את גודל השורות בקבצים. בדקו אם יש מגבלות גודל ספציפיות לפורמט הקובץ שאתם טוענים:
אם השגיאה הזו מופיעה כשאתם טוענים קובצי ORC, פנו לתמיכה.
ב-Storage API:
מחרוזת השגיאה: Stream memory usage exceeded
במהלך קריאה ל-Storage Read API ReadRows, יכול להיות שחלק מהסטרימינג עם שימוש גבוה בזיכרון יקבלו שגיאת RESOURCE_EXHAUSTED עם ההודעה הזו.
זה יכול לקרות כשקוראים מטבלאות רחבות או מטבלאות עם סכימה מורכבת. כדי לפתור את הבעיה, צריך להקטין את גודל שורת התוצאות על ידי בחירה של פחות עמודות לקריאה (באמצעות הפרמטר selected_fields) או על ידי פישוט הסכימה של הטבלה.
פתרון בעיות בקישוריות
בקטעים הבאים מוסבר איך לפתור בעיות בקישוריות כשמנסים לבצע פעולות ב-BigQuery:
הוספת Google DNS לרשימת ההיתרים
משתמשים בכלי Google IP Dig כדי לפתור את נקודת הקצה (endpoint) של BigQuery DNS bigquery.googleapis.com לכתובת IP של רשומת "A" אחת. חשוב לוודא שכתובת ה-IP הזו לא חסומה בהגדרות של חומת האש.
באופן כללי, מומלץ להוסיף לרשימת ההיתרים את שמות ה-DNS של Google. טווחי כתובות ה-IP שמשותפים בקבצים https://www.gstatic.com/ipranges/goog.json ו-https://www.gstatic.com/ipranges/cloud.json משתנים לעיתים קרובות, ולכן אנחנו ממליצים להוסיף לרשימת ההיתרים את שמות ה-DNS של Google. ריכזנו כאן רשימה של שמות DNS נפוצים שמומלץ להוסיף לרשימת ההיתרים:
*.1e100.net*.google.com*.gstatic.com*.googleapis.com*.googleusercontent.com*.appspot.com*.gvt1.com
זיהוי שרת ה-Proxy או חומת האש שגורמים לאובדן מנות
כדי לזהות את כל הדילוגים של החבילות בין הלקוח לבין ממשק הקצה של Google (GFE), מריצים את הפקודה traceroute במכונת הלקוח. הפקודה הזו יכולה להדגיש את השרת שמפיל חבילות שמכוונות ל-GFE. הנה דוגמה לפקודת traceroute:
traceroute -T -p 443 bigquery.googleapis.com
אם הבעיה קשורה לכתובת IP מסוימת, אפשר גם לזהות דילוגים של חבילות בכתובות IP ספציפיות של GFE:
traceroute -T -p 443 142.250.178.138
אם יש בעיה של זמן קצוב לתפוגה בצד של Google, הבקשה תגיע עד ל-GFE.
אם אתם רואים שהחבילות אף פעם לא מגיעות ל-GFE, פנו למנהל הרשת כדי לפתור את הבעיה.
יצירת קובץ PCAP וניתוח חומת האש או שרת ה-Proxy
יוצרים קובץ תיעוד מנות (PCAP) ומנתחים אותו כדי לוודא שחומת האש או שרת ה-proxy לא מסננים מנות לכתובות ה-IP של Google, ומאפשרים למנות להגיע ל-GFE.
הנה דוגמה לפקודה שאפשר להריץ באמצעות הכלי tcpdump:
tcpdump -s 0 -w debug.pcap -K -n host bigquery.googleapis.com
הגדרת ניסיונות חוזרים לפתרון בעיות קישוריות לסירוגין
יש מצבים שבהם מאזני העומסים של GFE עשויים להשמיט חיבורים מכתובת IP של לקוח. לדוגמה, אם הם מזהים דפוסי תעבורת נתונים של DDoS, או אם המכונה עם איזון עומסים מצומצמת אנכית בהתאם לעומס (scale down), מה שעלול לגרום למיחזור של כתובת ה-IP של נקודת הקצה. אם מאזני העומסים של GFE מנתקים את החיבור, הלקוח צריך לתפוס את הבקשה שזמן הקצוב שלה לתפוגה חלף ולנסות שוב את הבקשה לנקודת הקצה של ה-DNS. חשוב לוודא שלא משתמשים באותה כתובת IP עד שהבקשה תצליח, כי יכול להיות שכתובת ה-IP השתנתה.
אם זיהיתם בעיה של פסקי זמן עקביים בצד של Google, וניסיונות חוזרים לא עוזרים, פנו ל-Cloud Customer Care וצרפו קובץ PCAP עדכני שנוצר על ידי הפעלת כלי לתיעוד חבילות כמו tcpdump.