טעינת נתונים באצווה

אפשר לטעון נתונים ב-BigQuery מ-Cloud Storage או מקובץ מקומי כפעולת אצווה. נתוני המקור יכולים להיות בכל אחד מהפורמטים הבאים:

• Avro
• ערכים מופרדים בפסיקים (‎CSV)
• ‫JSON (מופרד בתו שורה חדשה)
• ORC
• Parquet
• ייצוא של Datastore שמאוחסן ב-Cloud Storage
• ייצוא מ-Firestore שמאוחסן ב-Cloud Storage

אפשר גם להשתמש בשירות העברת הנתונים ל-BigQuery כדי להגדיר טעינות חוזרות מ-Cloud Storage ל-BigQuery.

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

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

ההרשאות הנדרשות

כדי לטעון נתונים ל-BigQuery, אתם צריכים הרשאות IAM להרצת משימת טעינה ולטעינת נתונים לטבלאות ולמחיצות ב-BigQuery. אם אתם טוענים נתונים מ-Cloud Storage, אתם צריכים גם הרשאות IAM כדי לגשת לקטגוריה שמכילה את הנתונים.

הרשאות לטעינת נתונים ל-BigQuery

כדי לטעון נתונים לטבלה או למחיצה חדשה ב-BigQuery, או כדי לצרף נתונים לטבלה או למחיצה קיימת או להחליף אותם, אתם צריכים את הרשאות ה-IAM הבאות:

• bigquery.tables.create
• bigquery.tables.updateData
• bigquery.tables.update
• bigquery.jobs.create

כל אחד מהתפקידים הבאים שמוגדרים מראש ב-IAM כולל את ההרשאות שנדרשות לטעינת נתונים לטבלה או למחיצה ב-BigQuery:

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• ‫roles/bigquery.admin (כולל את ההרשאה bigquery.jobs.create)
• ‫bigquery.user (כולל את ההרשאה bigquery.jobs.create)
• ‫bigquery.jobUser (כולל את ההרשאה bigquery.jobs.create)

בנוסף, אם יש לכם הרשאה של bigquery.datasets.create, אתם יכולים ליצור ולעדכן טבלאות באמצעות משימת טעינה במערכי הנתונים שאתם יוצרים.

במאמר תפקידים והרשאות מוגדרים מראש יש מידע נוסף על תפקידים והרשאות ב-IAM ב-BigQuery.

הרשאות לטעינת נתונים מ-Cloud Storage

כדי לקבל את ההרשאות שדרושות לטעינת נתונים מקטגוריה של Cloud Storage, צריך לבקש מהאדמין להקצות לכם את תפקיד ה-IAM אדמין לניהול אחסון (roles/storage.admin) בקטגוריה. להסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

זהו תפקיד מוגדר מראש שכולל את ההרשאות שנדרשות לטעינת נתונים מקטגוריה של Cloud Storage. כדי לראות בדיוק אילו הרשאות נדרשות, אפשר להרחיב את הקטע ההרשאות הנדרשות:

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

יצירת מערך נתונים

יוצרים מערך נתונים ב-BigQuery לאחסון הנתונים.

טעינת נתונים מ-Cloud Storage

אפשר לטעון נתונים ל-BigQuery מכל סוגי האחסון הבאים ב-Cloud Storage:

• רגילה
• Nearline
• Coldline
• העברה לארכיון

כדי ללמוד איך לטעון נתונים ל-BigQuery, אפשר לעיין בדף שמתאים לפורמט הנתונים שלכם:

• CSV
• JSON
• Avro
• Parquet
• ORC
• ייצואים של Datastore
• ייצוא מ-Firestore

כאן מוסבר איך להגדיר טעינה חוזרת מ-Cloud Storage ל-BigQuery.

שיקולים בקשר למיקום

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

• העתקת מערכי נתונים
• העברה של מערך נתונים

אחזור URI של Cloud Storage

כדי לטעון נתונים ממקור נתונים ב-Cloud Storage, צריך לספק את ה-URI של Cloud Storage.

נתיב המשאב ב-Cloud Storage מכיל את שם הקטגוריה ואת האובייקט (שם הקובץ). לדוגמה, אם קטגוריית Cloud Storage נקראת mybucket וקובץ הנתונים נקרא myfile.csv, נתיב המשאב יהיה gs://mybucket/myfile.csv.

‫BigQuery לא תומך בנתיבי משאבים ב-Cloud Storage שכוללים כמה לוכסנים עוקבים אחרי שני הלכסנים הראשוניים. שמות של אובייקטים ב-Cloud Storage יכולים להכיל כמה תווים עוקבים של לוכסן (/). עם זאת, BigQuery ממיר כמה לוכסנים עוקבים ללוכסן אחד. לדוגמה, נתיב המשאב הבא, למרות שהוא תקין ב-Cloud Storage, לא פועל ב-BigQuery:‏ gs://bucket/my//object//name.

כדי לאחזר את נתיב המשאב ב-Cloud Storage:

1. פותחים את מסוף Cloud Storage.

   Cloud Storage console

2. עוברים למיקום של האובייקט (הקובץ) שמכיל את נתוני המקור.

3. לוחצים על שם האובייקט.

   הדף Object details נפתח.

4. מעתיקים את הערך שמופיע בשדה gsutil URI, שמתחיל ב-gs://.

בייצוא של Google Datastore אפשר לציין רק URI אחד, והוא חייב להסתיים ב-.backup_info או ב-.export_metadata.

תמיכה בתווים כלליים לחיפוש ב-Cloud Storage URI

אם הנתונים שלכם מפוצלים לכמה קבצים, אתם יכולים להשתמש בתו כללי של כוכבית (*) כדי לבחור כמה קבצים. השימוש בתו הכללי לחיפוש כוכבית צריך לעמוד בכללים הבאים:

• הכוכבית יכולה להופיע בתוך שם האובייקט או בסוף שם האובייקט.
• אי אפשר להשתמש בכמה כוכביות. לדוגמה, הנתיב gs://mybucket/fed-*/temp/*.csv לא תקין.
• אי אפשר להשתמש בכוכבית עם שם הקטגוריה.

דוגמאות:

• בדוגמה הבאה אפשר לראות איך בוחרים את כל הקבצים בכל התיקיות שמתחילות בקידומת gs://mybucket/fed-samples/fed-sample:

  gs://mybucket/fed-samples/fed-sample*
  

• בדוגמה הבאה אפשר לראות איך בוחרים רק קבצים עם הסיומת .csv בתיקייה בשם fed-samples ובכל תיקיות המשנה של fed-samples:

  gs://mybucket/fed-samples/*.csv
  

• בדוגמה הבאה אפשר לראות איך בוחרים קבצים עם תבנית שמות של fed-sample*.csv בתיקייה בשם fed-samples. בדוגמה הזו לא נבחרו קבצים בתיקיות משנה של fed-samples.

  gs://mybucket/fed-samples/fed-sample*.csv
  

כשמשתמשים בכלי שורת הפקודה של BigQuery, יכול להיות שיהיה צורך להוסיף תו בריחה לכוכבית בפלטפורמות מסוימות.

אי אפשר להשתמש בתו כללי של כוכבית כשמטעינים נתוני ייצוא של Datastore או Firestore מ-Cloud Storage.

מגבלות

כשאתם טוענים נתונים ל-BigQuery מקטגוריה של Cloud Storage, אתם כפופים למגבלות הבאות:

• ‫BigQuery לא מבטיח עקביות נתונים במקורות נתונים חיצוניים. שינויים בנתוני הבסיס בזמן הפעלת שאילתה עלולים לגרום להתנהגות לא צפויה.
• ‫BigQuery לא תומך בניהול גרסאות של אובייקטים ב-Cloud Storage. אם כוללים מספר דור ב-URI של Cloud Storage, עבודת הטעינה נכשלת.

יכול להיות שיש מגבלות נוספות, בהתאם לפורמט של נתוני המקור ב-Cloud Storage. למידע נוסף:

• מגבלות של קובץ CSV
• מגבלות של JSON
• מגבלות בייצוא של Datastore
• מגבלות של ייצוא מ-Firestore
• מגבלות על נתונים בתצוגת עץ ועל נתונים חוזרים

טעינת נתונים מקבצים מקומיים

אפשר לטעון נתונים ממקור נתונים שניתן לקריאה (כמו המחשב המקומי) באמצעות אחת מהאפשרויות הבאות:

• מסוף Cloud de Confiance
• הפקודה bq load בכלי שורת הפקודה bq
• ‫API
• ספריות הלקוח

כשמעלים נתונים באמצעות מסוף Cloud de Confiance או כלי שורת הפקודה של BigQuery, נוצר באופן אוטומטי תהליך העלאה.

כדי לטעון נתונים מחנויות מקומיות:

bq --location=LOCATION load \
--source_format=FORMAT \
PROJECT_ID:DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    ./mydata.json \
    ./myschema.json

    bq load \
    --source_format=CSV \
    myotherproject:mydataset.mytable \
    ./mydata.csv \
    qtr:STRING,sales:FLOAT,year:STRING

    bq load \
    --autodetect \
    --source_format=CSV \
    mydataset.mytable \
    ./mydata.csv

using Google.Cloud.BigQuery.V2;
using System;
using System.IO;

public class BigQueryLoadFromFile
{
    public void LoadFromFile(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id",
        string filePath = "path/to/file.csv"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Create job configuration
        var uploadCsvOptions = new UploadCsvOptions()
        {
            SkipLeadingRows = 1,  // Skips the file headers
            Autodetect = true
        };
        using (FileStream stream = File.Open(filePath, FileMode.Open))
        {
            // Create and run job
            // Note that there are methods available for formats other than CSV
            BigQueryJob job = client.UploadCsv(
                datasetId, tableId, null, stream, uploadCsvOptions);
            job = job.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.

            // Display the number of rows uploaded
            BigQueryTable table = client.GetTable(datasetId, tableId);
            Console.WriteLine(
                $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
        }
    }
}

import (
	"context"
	"fmt"
	"os"

	"cloud.google.com/go/bigquery"
)

// importCSVFromFile demonstrates loading data into a BigQuery table using a file on the local filesystem.
func importCSVFromFile(projectID, datasetID, tableID, filename string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	source := bigquery.NewReaderSource(f)
	source.AutoDetect = true   // Allow BigQuery to determine schema.
	source.SkipLeadingRows = 1 // CSV has a single header line.

	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(source)

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

TableId tableId = TableId.of(datasetName, tableName);
WriteChannelConfiguration writeChannelConfiguration =
    WriteChannelConfiguration.newBuilder(tableId).setFormatOptions(FormatOptions.csv()).build();
// The location must be specified; other fields can be auto-detected.
JobId jobId = JobId.newBuilder().setLocation(location).build();
TableDataWriteChannel writer = bigquery.writer(jobId, writeChannelConfiguration);
// Write data to writer
try (OutputStream stream = Channels.newOutputStream(writer)) {
  Files.copy(csvPath, stream);
}
// Get load job
Job job = writer.getJob();
job = job.waitFor();
LoadStatistics stats = job.getStatistics();
return stats.getOutputRows();

// Imports the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function loadLocalFile() {
  // Imports a local file into a table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const filename = '/path/to/file.csv';
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Load data from a local file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(filename);

  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';
// $tableId    = 'The BigQuery table ID';
// $source     = 'The path to the CSV source file to import';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
// create the import job
$loadConfig = $table->load(fopen($source, 'r'))->sourceFormat('CSV');

$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    printf('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.LoadJobConfig(
    source_format=bigquery.SourceFormat.CSV, skip_leading_rows=1, autodetect=True,
)

with open(file_path, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_id, job_config=job_config)

job.result()  # Waits for the job to complete.

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

require "google/cloud/bigquery"

def load_from_file dataset_id = "your_dataset_id",
                   file_path  = "path/to/file.csv"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "new_table_id"

  # Infer the config.location based on the location of the referenced dataset.
  load_job = dataset.load_job table_id, file_path do |config|
    config.skip_leading = 1
    config.autodetect   = true
  end
  load_job.wait_until_done! # Waits for table load to complete.

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows into #{table.id}"
end

מגבלות

טעינת נתונים מחנויות מקומיות כפופה למגבלות הבאות:

• תווים כלליים לחיפוש ורשימות מופרדות בפסיקים לא אפשריים כשמעלים קבצים ממקור נתונים מחנויות מקומיות. צריך לטעון כל קובץ בנפרד.
• כשמשתמשים במסוף Cloud de Confiance , קבצים שנטענים ממקור נתונים מקומי לא יכולים להיות גדולים מ-100MB. אם הקבצים גדולים, טוענים אותם מ-Cloud Storage.

טעינת קיבולת המשרה

בדומה למצב על פי דרישה של שאילתות, כברירת מחדל, עבודות טעינה משתמשות במאגר משותף של משבצות. אם עבודת טעינה משתמשת במאגר המשותף, ההזמנה default-pipeline מוצגת בפרטי העבודה. ‫BigQuery לא מבטיח את הקיבולת הזמינה של המאגר המשותף הזה או את קצב העברת הנתונים של עבודת הטעינה.

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

טעינת נתונים דחוסים ולא דחוסים

בפורמטים Avro,‏ Parquet ו-ORC,‏ BigQuery תומך בטעינת קבצים שבהם הנתונים דחוסים באמצעות codec נתמך. עם זאת, BigQuery לא תומך בטעינת קבצים בפורמטים האלה שנדחסו בעצמם, למשל באמצעות כלי השירות gzip.

פורמט Avro בינארי הוא הפורמט המועדף לטעינת נתונים דחוסים ולא דחוסים. טעינת נתוני Avro מהירה יותר כי אפשר לקרוא את הנתונים במקביל, גם כשבלוקי הנתונים דחוסים. רשימה של קודקים נתמכים לדחיסה מופיעה במאמר בנושא דחיסת Avro.

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

הפורמט הבינארי ORC מציע יתרונות דומים לאלה של פורמט Parquet. טעינת הנתונים בקובצי ORC מהירה כי אפשר לקרוא את רצועות הנתונים במקביל. השורה בכל פס נתונים נטענת ברצף. כדי לשפר את זמן הטעינה, מומלץ להשתמש בגודל פס נתונים של כ-256MB או פחות. רשימה של קודקים נתמכים לדחיסה מופיעה במאמר בנושא דחיסת ORC.

בפורמטים אחרים של נתונים, כמו CSV ו-JSON, מערכת BigQuery יכולה לטעון קבצים לא דחוסים הרבה יותר מהר מקבצים דחוסים, כי אפשר לקרוא קבצים לא דחוסים במקביל. קובצי נתונים לא דחוסים גדולים יותר, ולכן השימוש בהם עלול להוביל למגבלות על רוחב הפס ולעלויות גבוהות יותר ב-Cloud Storage עבור נתונים שמועברים ל-Cloud Storage לפני הטעינה ל-BigQuery. חשוב לזכור שאין הבטחה לגבי סדר השורות בקבצים דחוסים או לא דחוסים. חשוב לשקול את היתרונות והחסרונות האלה בהתאם לתרחיש השימוש.

באופן כללי, אם רוחב הפס מוגבל, כדאי לדחוס את קובצי ה-CSV וה-JSON באמצעות gzip לפני שמעלים אותם ל-Cloud Storage. ‫gzip הוא סוג הדחיסה היחיד של קובצי CSV ו-JSON שנתמך כשמעלים נתונים ל-BigQuery. אם מהירות הטעינה חשובה לאפליקציה שלכם ויש לכם רוחב פס גדול לטעינת הנתונים, אל תדחסו את הקבצים.

הוספה לטבלה או החלפה של טבלה

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

אם מעדכנים את הסכימה כשמוסיפים נתונים, BigQuery מאפשר:

• הוספת שדות חדשים
• רגיעה REQUIRED שדות לNULLABLE

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

במסוף Cloud de Confiance , משתמשים באפשרות Write preference כדי לציין איזו פעולה לבצע כשמעלים נתונים מקובץ מקור או מתוצאה של שאילתה. כלי שורת הפקודה של BigQuery וה-API כוללים את האפשרויות הבאות:

מדיניות בנושא מכסה

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

צפייה בשימוש הנוכחי במכסה

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

SELECT
  sum(case  when job_type="QUERY" then 1 else 0 end) as QRY_CNT,
  sum(case  when job_type="LOAD" then 1 else 0 end) as LOAD_CNT,
  sum(case  when job_type="EXTRACT" then 1 else 0 end) as EXT_CNT,
  sum(case  when job_type="COPY" then 1 else 0 end) as CPY_CNT
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE date(creation_time)= CURRENT_DATE()

תמחור

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

תרחיש שימוש לדוגמה

נניח שיש צינור לעיבוד ברצף (batch processing) שפועל מדי לילה וצריך להסתיים עד למועד יעד קבוע. הנתונים צריכים להיות זמינים עד למועד האחרון הזה כדי לעבור עיבוד נוסף בתהליך אצווה אחר, שמטרתו ליצור דוחות שיישלחו לרשות רגולטורית. תרחיש השימוש הזה נפוץ בתעשיות מפוקחות כמו פיננסים.

טעינת נתונים באצווה באמצעות משימות טעינה היא הגישה הנכונה לתרחיש השימוש הזה, כי זמן האחזור לא משמעותי כל עוד אפשר לעמוד במועד האחרון. חשוב לוודא שדלי Cloud Storage עומדים בדרישות המיקום לטעינת נתונים למערך הנתונים ב-BigQuery.

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

בהנחה שהנתונים להטמעה כבר הועתקו בהצלחה ל-Cloud Storage, ניסיון חוזר עם השהיה מעריכית לפני ניסיון חוזר (exponential backoff) מספיק כדי לפתור בעיות בהטמעה.

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