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

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

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

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

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

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

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

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

כש-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. בחלונית השמאלית, לוחצים על Explorer:

   

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

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

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

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

   • בקטע Create table from, בוחרים את סוג המקור.

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

     

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

6. בדף Create table, בקטע Destination:

   • בקטע Dataset name, בוחרים את מערך הנתונים המתאים.

     

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

   • מוודאים שהשדה Table type מוגדר ל-Native table.

7. לוחצים על Create table.

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 במדריך למתחילים של 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 , מסמנים את האפשרות Auto detect בקטע Schema and input parameters.

באמצעות כלי שורת הפקודה של 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
• 19/08/2018 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, ולא מפרש את תו השורה החדשה במירכאות כגבול של שורה.

פתרון בעיות

כשמזהים באופן אוטומטי סכימה של קובצי CSV, יכול להיות שתופיע השגיאה הבאה:

שגיאה: Error while reading data, error message: CSV processing encountered too many errors, giving up.

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

זיהוי אוטומטי של סכימה לנתוני 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.