שימוש בזיהוי אוטומטי של סכימה

זיהוי אוטומטי של סכימות

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

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

אם לא מפעילים זיהוי אוטומטי של סכימה לנתוני CSV,‏ JSON או Google Sheets, צריך לספק את הסכימה באופן ידני כשיוצרים את הטבלה.

אין צורך להפעיל זיהוי אוטומטי של סכימה עבור קובצי Avro,‏ Parquet,‏ ORC,‏ Firestore export או Datastore export. הפורמטים האלה הם בעלי תיאור עצמי, ולכן BigQuery מסיק באופן אוטומטי את סכימת הטבלה מנתוני המקור. בקבצים מסוג Parquet,‏ Avro ו-Orc, אפשר לספק סכימה מפורשת כדי לבטל את הסכימה שהמערכת הסיקה.

אפשר לראות את הסכימה שזוהתה עבור טבלה בדרכים הבאות:

• משתמשים במסוף Google Cloud .
• משתמשים בפקודה bq show של כלי שורת הפקודה של bq.

כש-BigQuery מזהה סכימות, יכול להיות שבמקרים נדירים הוא ישנה שם של שדה כדי שיתאים לתחביר של GoogleSQL.

מידע על המרות של סוגי נתונים מפורט במאמרים הבאים:

• המרת סוגי נתונים כשמטעינים נתונים מ-Datastore
• המרת סוגי נתונים כשמטעינים נתונים מ-Firestore
• המרות של קובצי Avro
• המרות בפורמט Parquet
• המרות של ORC

טעינת נתונים באמצעות זיהוי אוטומטי של סכימה

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

• במסוף Google Cloud , בקטע Schema, מסמנים את האפשרות Schema and input parameters לצד Auto detect.
• בכלי שורת הפקודה של BigQuery, משתמשים בפקודה bq load עם הפרמטר --autodetect.

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

לא נעשה שימוש בזיהוי אוטומטי של סכימה בקובצי Avro, בקובצי Parquet, בקובצי ORC, בקובצי ייצוא של Firestore או בקובצי ייצוא של Datastore. כשאתם טוענים את הקבצים האלה ל-BigQuery, סכימת הטבלה מאוחזרת באופן אוטומטי מנתוני המקור שמתארים את עצמם.

כדי להשתמש בזיהוי אוטומטי של סכימה כשמעלים נתוני JSON או CSV:

המסוף

1. נכנסים לדף BigQuery במסוף Google Cloud .

   כניסה ל-BigQuery

2. בחלונית הימנית, לוחצים על כלי הניתוחים:

   

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

3. בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets (מערכי נתונים) ואז לוחצים על מערך הנתונים.

4. בחלונית הפרטים, לוחצים על יצירת טבלה.

5. בדף Create table, בקטע Source:

   • בקטע יצירת טבלה מ, בוחרים את סוג המקור הרצוי.

   • בשדה המקור, מחפשים את הקובץ או את הקטגוריה של Cloud Storage, או מזינים את URI של Cloud Storage. שימו לב: אי אפשר לכלול כמה מזהי URI במסוף Google Cloud , אבל יש תמיכה בתווים כלליים. הקטגוריה של Cloud Storage צריכה להיות באותו מיקום כמו מערך הנתונים שמכיל את הטבלה שאתם יוצרים.

     

   • בקטע פורמט קובץ, בוחרים באפשרות CSV או JSON.

6. בדף יצירת טבלה, בקטע יעד:

   • בשדה Dataset name (שם קבוצת הנתונים), בוחרים את קבוצת הנתונים המתאימה.

     

   • בשדה Table name (שם הטבלה), מזינים את שם הטבלה שיוצרים.

   • מוודאים שסוג הטבלה מוגדר לטבלה מקורית.

7. לוחצים על יצירת טבלה.

BQ

מריצים את הפקודה bq load עם הפרמטר --autodetect.

(אופציונלי) מציינים את הדגל --location ומגדירים את הערך למיקום.

הפקודה הבאה טוענת קובץ באמצעות זיהוי אוטומטי של סכימה:

bq --location=LOCATION load \
--autodetect \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE

מחליפים את מה שכתוב בשדות הבאים:

• ‫LOCATION: שם המיקום. הדגל --location הוא אופציונלי. לדוגמה, אם אתם משתמשים ב-BigQuery באזור טוקיו, צריך להגדיר את הערך של הדגל ל-asia-northeast1. אפשר להגדיר ערך ברירת מחדל למיקום באמצעות הקובץ ‎.bigqueryrc.
• ‫FORMAT: NEWLINE_DELIMITED_JSON או CSV.
• ‫DATASET: מערך הנתונים שמכיל את הטבלה שאליה טוענים את הנתונים.
• ‫TABLE: שם הטבלה שאליה טוענים את הנתונים.
• ‫PATH_TO_SOURCE: הוא המיקום של קובץ ה-CSV או ה-JSON.

דוגמאות:

מזינים את הפקודה הבאה כדי לטעון את myfile.csv מהמחשב המקומי לטבלה בשם mytable שמאוחסנת במערך נתונים בשם mydataset.

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

מזינים את הפקודה הבאה כדי לטעון את myfile.json מהמחשב המקומי לטבלה בשם mytable שמאוחסנת במערך נתונים בשם mydataset.

bq load --autodetect --source_format=NEWLINE_DELIMITED_JSON \
mydataset.mytable ./myfile.json

API

1. יוצרים משימת load שמצביעה על נתוני המקור. מידע על יצירת משימות זמין במאמר הפעלת משימות BigQuery באופן פרוגרמטי. מציינים את המיקום שלכם במאפיין location בקטע jobReference.

2. מגדירים את פורמט הנתונים באמצעות הנכס sourceFormat. כדי להשתמש בזיהוי אוטומטי של סכימה, צריך להגדיר את הערך הזה ל-NEWLINE_DELIMITED_JSON או ל-CSV.

3. משתמשים במאפיין autodetect כדי להגדיר את האפשרות 'זיהוי אוטומטי של סכימה' לערך true.

Go

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Goהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Go API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import (
	"context"
	"fmt"

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

// importJSONAutodetectSchema demonstrates loading data from newline-delimited JSON data in Cloud Storage
// and using schema autodetection to identify the available columns.
func importJSONAutodetectSchema(projectID, datasetID, tableID 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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty

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

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;

// Sample to load JSON data with autodetect schema from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCSAutodetect {

  public static void runLoadJsonFromGCSAutodetect() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    loadJsonFromGCSAutodetect(datasetName, tableName, sourceUri);
  }

  public static void loadJsonFromGCSAutodetect(
      String datasetName, String tableName, String sourceUri) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              .setAutodetect(true)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Json Autodetect from GCS successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CsvOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;

// Sample to load CSV data with autodetect schema from Cloud Storage into a new BigQuery table
public class LoadCsvFromGcsAutodetect {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv";
    loadCsvFromGcsAutodetect(datasetName, tableName, sourceUri);
  }

  public static void loadCsvFromGcsAutodetect(
      String datasetName, String tableName, String sourceUri) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);

      // Skip header row in the file.
      CsvOptions csvOptions = CsvOptions.newBuilder().setSkipLeadingRows(1).build();

      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(csvOptions)
              .setAutodetect(true)
              .build();

      // Load data from a GCS CSV file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("CSV Autodetect from GCS successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Node.js API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = "my_dataset";
// const tableId = "my_table";

/**
 * This sample loads the JSON file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCSAutodetect() {
  // Imports a GCS file into a table with autodetected schema.

  // Instantiate clients
  const bigquery = new BigQuery();
  const storage = new Storage();

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    autodetect: true,
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  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;
  }
}
loadJSONFromGCSAutodetect();

PHP

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי PHPהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery PHP API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

use Google\Cloud\BigQuery\BigQueryClient;

/**
 * Imports data to the given table from json file present in GCS by auto
 * detecting options and schema.
 *
 * @param string $projectId The project Id of your Google Cloud Project.
 * @param string $datasetId The BigQuery dataset ID.
 * @param string $tableId The BigQuery table ID.
 */
function import_from_storage_json_autodetect(
    string $projectId,
    string $datasetId,
    string $tableId = 'us_states'
): void {
    // instantiate the bigquery table service
    $bigQuery = new BigQueryClient([
      'projectId' => $projectId,
    ]);
    $dataset = $bigQuery->dataset($datasetId);
    $table = $dataset->table($tableId);

    // create the import job
    $gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
    $loadConfig = $table->loadFromStorage($gcsUri)->autodetect(true)->sourceFormat('NEWLINE_DELIMITED_JSON');
    $job = $table->runJob($loadConfig);

    // check if the job is complete
    $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);
    }
}

Python

כדי להפעיל זיהוי אוטומטי של סכימה, מגדירים את המאפיין LoadJobConfig.autodetect לערך True.

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Pythonהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Python API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

# Set the encryption key to use for the destination.
# TODO: Replace this key with a key you have created in KMS.
# kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
#     "cloud-samples-tests", "us", "test", "test"
# )
job_config = bigquery.LoadJobConfig(
    autodetect=True, source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.
load_job.result()  # Waits for the job to complete.
destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Rubyהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Ruby API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

require "google/cloud/bigquery"

def load_table_gcs_json_autodetect dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
  table_id = "us_states"

  load_job = dataset.load_job table_id,
                              gcs_uri,
                              format:     "json",
                              autodetect: true
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done! # Waits for table load to complete.
  puts "Job finished."

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

זיהוי אוטומטי של סכמה במקורות נתונים חיצוניים

אפשר להשתמש בזיהוי אוטומטי של סכימה עם מקורות נתונים חיצוניים בפורמטים CSV,‏ JSON ו-Google Sheets. כשמפעילים זיהוי אוטומטי של סכימה, מערכת BigQuery מנסה להסיק את הסכימה מנתוני המקור באופן אוטומטי. אם לא מפעילים זיהוי אוטומטי של סכימה במקורות האלה, צריך לספק סכימה מפורשת.

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

כדי להפעיל זיהוי אוטומטי של סכימה באמצעות מסוף Google Cloud , מסמנים את האפשרות Schema and input parameters (סכימה ופרמטרים של קלט) בקטע Auto detect (זיהוי אוטומטי).

באמצעות כלי שורת הפקודה של BigQuery, אפשר להפעיל זיהוי אוטומטי של סכימה כשיוצרים קובץ הגדרת טבלה לנתוני CSV,‏ JSON או Google Sheets. כשמשתמשים בכלי bq כדי ליצור קובץ הגדרת טבלה, מעבירים את הדגל --autodetect לפקודה mkdef כדי להפעיל זיהוי אוטומטי של הסכימה, או מעבירים את הדגל --noautodetect כדי להשבית את הזיהוי האוטומטי.

כשמשתמשים בדגל --autodetect, ההגדרה autodetect מוגדרת ל-true בקובץ הגדרת הטבלה. כשמשתמשים בדגל --noautodetect, ההגדרה autodetect מוגדרת לערך false. אם לא מספקים הגדרת סכימה למקור הנתונים החיצוני כשיוצרים הגדרת טבלה, ולא משתמשים בדגל --noautodetect או --autodetect, הגדרת autodetect מוגדרת כברירת מחדל ל-true.

כשיוצרים קובץ הגדרת טבלה באמצעות ה-API, צריך להגדיר את הערך של המאפיין autodetect ל-true או ל-false. הגדרה של autodetect ל-true מפעילה זיהוי אוטומטי. הגדרה של autodetect לערך false משביתה את הזיהוי האוטומטי.

פרטים על הזיהוי האוטומטי

בנוסף לזיהוי פרטי סכימה, הזיהוי האוטומטי מזהה את הפריטים הבאים:

דחיסה

מערכת BigQuery מזהה דחיסת קבצים שתואמת ל-gzip כשפותחים קובץ.

ערכי תאריך ושעה

מערכת BigQuery מזהה ערכי תאריך ושעה על סמך הפורמט של נתוני המקור.

הערכים בעמודות DATE צריכים להיות בפורמט הבא: YYYY-MM-DD.

הערכים בעמודות TIME צריכים להיות בפורמט הבא: HH:MM:SS[.SSSSSS] (החלק של שבריר השנייה הוא אופציונלי).

עבור עמודות TIMESTAMP, ‏ BigQuery מזהה מגוון רחב של פורמטים של חותמות זמן, כולל, בין היתר:

• YYYY-MM-DD HH:MM
• YYYY-MM-DD HH:MM:SS
• YYYY-MM-DD HH:MM:SS.SSSSSS
• YYYY/MM/DD HH:MM

חותמת זמן יכולה להכיל גם היסט מ-UTC או את המזהה של אזור הזמן UTC ‏(Z).

הנה כמה דוגמאות לערכים ש-BigQuery יזהה אוטומטית כערכים של חותמות זמן:

• 2018-08-19 12:11
• 2018-08-19 12:11:35.22
• 2018/08/19 12:11
• 2018-08-19 07:11:35.220 -05:00

אם הזיהוי האוטומטי לא מופעל, והערך שלכם הוא בפורמט שלא מופיע בדוגמאות הקודמות, BigQuery יכול לטעון את העמודה רק כסוג נתונים STRING. אפשר להפעיל זיהוי אוטומטי כדי ש-BigQuery יזהה את העמודות האלה כחותמות זמן. לדוגמה, אם מפעילים את האפשרות לזיהוי אוטומטי, BigQuery יטען את הערך 2025-06-16T16:55:22Z רק כחותמת זמן.

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

זיהוי אוטומטי של סכמה לנתוני CSV

תו מפריד ב-CSV

מערכת BigQuery מזהה את התווים הבאים להפרדה:

• פסיק ( , )
• קו אנכי ( | )
• טאב ( ‎\t )

כותרת CSV

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

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

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

שורות חדשות עם מרכאות בקובץ CSV

‫BigQuery מזהה תווים של שורה חדשה בתוך שדה CSV עם מרכאות, ולא מפרש את התו של השורה החדשה כגבול של שורה.

זיהוי אוטומטי של סכימה לנתוני JSON

שדות בתוך שדות ושדות חוזרים ב-JSON

מערכת BigQuery מסיקה שדות מקוננים ושדות חוזרים בקובצי JSON. אם ערך השדה הוא אובייקט JSON, ‏ BigQuery טוען את העמודה כסוג RECORD. אם ערך של שדה הוא מערך, המערכת של BigQuery טוענת את העמודה כעמודה חוזרת. דוגמה לנתוני JSON עם נתונים חוזרים ונתונים בתצוגת עץ מופיעה במאמר טעינת נתוני JSON חוזרים ונתונים בתצוגת עץ.

המרה של מחרוזת

אם מפעילים זיהוי אוטומטי של סכימה, מערכת BigQuery ממירה מחרוזות לערכים בוליאניים, מספריים או מסוג תאריך/שעה, אם אפשר. לדוגמה, באמצעות נתוני ה-JSON הבאים, זיהוי הסכימה האוטומטי ממיר את השדה id לעמודה INTEGER:

{ "name":"Alice","id":"12"}
{ "name":"Bob","id":"34"}
{ "name":"Charles","id":"45"}

מידע נוסף זמין במאמר בנושא טעינת נתונים בפורמט JSON מ-Cloud Storage.

זיהוי אוטומטי של סכימה ב-Google Sheets

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

אבטחת טבלאות

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