테이블 만들기 및 사용

이 문서에서는 BigQuery에서 표준 테이블이나 '기본' 테이블을 만들고 사용하는 방법을 설명합니다. 다른 테이블 유형 만들기에 대한 자세한 내용은 다음을 참조하세요.

테이블을 만든 후에는 다음과 같은 작업을 수행할 수 있습니다.

  • 테이블 데이터에 대한 액세스 제어
  • 테이블에 대한 정보 가져오기
  • 데이터세트의 테이블 나열
  • 테이블 메타데이터 가져오기

테이블 속성 업데이트, 테이블 복사, 테이블 삭제를 비롯한 테이블 관리에 대한 자세한 내용은 테이블 관리를 참조하세요.

시작하기 전에

BigQuery에서 테이블을 만들기 전에 먼저 다음을 수행하세요.

테이블 제한사항

BigQuery 테이블에는 다음 제한사항이 적용됩니다.

  • 데이터세트마다 테이블 이름이 고유해야 합니다.
  • Cloud Console 및 기본 BigQuery 웹 UI는 테이블을 한 번에 한 개만 복사 할 수 있습니다.
  • 테이블을 복사할 때는 대상 데이터세트가 복사 중인 테이블과 같은 위치에 있어야 합니다. 예를 들어 EU 기반 데이터세트의 테이블을 US 기반 데이터세트에 복사할 수 없습니다.
  • CLI, API 또는 클라이언트 라이브러리를 사용하여 소스 테이블 여러 개를 단일 대상 테이블에 복사할 때는 모든 소스 테이블의 스키마가 같아야 합니다.
  • Cloud Console, 기본 BigQuery 웹 UI, 명령줄 도구, API 또는 클라이언트 라이브러리를 사용하여 테이블을 한 번에 한 개만 삭제할 수 있습니다.
  • 테이블 데이터를 내보낼 때는 Cloud Storage만 대상으로 지원됩니다.
  • 데이터세트의 테이블이 50,000개 이상이 되면 이를 열거하는 속도가 느려집니다. API 호출 또는 기본 BigQuery 웹 UI를 사용할 경우 열거 성능이 저하됩니다. 현재 Cloud Console에서 BigQuery 웹 UI는 데이터세트당 테이블을 50,000개까지만 표시할 수 있습니다.

    기본 BigQuery 웹 UI의 성능 향상을 위해 ?minimal 매개변수를 사용하여 프로젝트당 표시되는 테이블 수를 30,000개로 제한할 수 있습니다. 기본 BigQuery 웹 UI URL에 매개변수를 https://bigquery.cloud.google.com/queries/project_id?minimal 형식으로 추가합니다.

테이블 이름 지정

BigQuery에서 테이블을 만들 때 테이블 이름은 데이터세트마다 고유해야 합니다. 다음과 같은 테이블 이름을 사용할 수 있습니다.

  • 최대 1,024자
  • 문자(대소문자), 숫자, 밑줄 포함

테이블 만들기

BigQuery에서는 다음과 같은 방법으로 테이블을 만들 수 있습니다.

  • Cloud Console, 기본 BigQuery 웹 UI, 명령줄 도구의 bq mk 명령어를 수동으로 사용
  • tables.insert API 메서드를 호출하여 프로그래매틱 방식으로 만들기
  • 클라이언트 라이브러리를 사용하여 만들기
  • 쿼리 결과에서
  • 외부 데이터 소스를 참조하는 테이블을 정의합니다.
  • 데이터를 로드할 때
  • CREATE TABLE DDL 문을 사용하여 만들기

필수 권한

테이블을 만들려면 최소한 다음 권한이 부여되어 있어야 합니다.

  • 테이블을 만들 수 있는 bigquery.tables.create 권한
  • 로드 작업, 쿼리 작업 또는 복사 작업을 사용하여 테이블에 데이터를 쓸 수 있는 bigquery.tables.updateData 권한
  • 테이블에 데이터를 쓰는 쿼리 작업, 로드 작업, 복사 작업을 실행할 수 있는 bigquery.jobs.create 권한

테이블에 쓰려는 데이터에 액세스하려면 bigquery.tables.getData와 같은 추가 권한이 필요할 수 있습니다.

다음과 같은 사전 정의된 Cloud IAM 역할에는 bigquery.tables.createbigquery.tables.updateData 권한이 모두 포함되어 있습니다.

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

다음과 같은 사전 정의된 Cloud IAM 역할에는 bigquery.jobs.create 권한이 포함되어 있습니다.

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

또한 bigquery.datasets.create 권한이 있는 사용자는 데이터세트를 만들 때 해당 데이터세트에 대한 bigquery.dataOwner 액세스 권한을 부여받습니다. bigquery.dataOwner 액세스 권한이 있는 사용자는 데이터세트에서 테이블을 만들고 업데이트할 수 있습니다.

BigQuery의 Cloud IAM 역할 및 권한에 대한 자세한 내용은 사전 정의된 역할 및 권한을 참조하세요.

스키마 정의가 있는 빈 테이블 만들기

스키마 정의가 있는 빈 테이블을 만들 때는 다음과 같은 작업을 수행할 수 있습니다.

  • Cloud Console 또는 기본 BigQuery 웹 UI를 사용하여 스키마 입력
  • 명령줄 도구를 사용하여 스키마를 인라인으로 제공
  • 명령줄 도구를 사용하여 JSON 스키마 파일 제출
  • API의 tables.insert 메서드를 호출할 때 테이블 리소스에 스키마 제공

테이블 스키마 지정에 대한 자세한 내용은 스키마 지정을 참조하세요.

테이블을 만든 후에는 테이블에 데이터를 로드하거나 쿼리 결과를 쓰는 방법으로 테이블을 채울 수 있습니다.

스키마 정의가 있는 빈 테이블을 만들려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.
    BigQuery 웹 UI로 이동

  2. 탐색 패널의 리소스 섹션에서 프로젝트를 펼치고 데이터세트를 선택합니다.

  3. 창 오른쪽에 있는 세부정보 패널에서 테이블 만들기를 클릭합니다.

    테이블 만들기

  4. 테이블 만들기 페이지의 소스 섹션에서 빈 테이블을 선택합니다.

  5. 테이블 만들기 페이지의 대상 섹션에서 다음을 수행합니다.

    • 데이터세트 이름에서 적절한 데이터세트를 선택합니다.

      데이터세트 선택

    • 테이블 이름 필드에 BigQuery에 만들려는 테이블의 이름을 입력합니다.

    • 테이블 유형이 기본 테이블로 설정되어 있는지 확인합니다.

  6. 스키마 섹션에 스키마 정의를 입력합니다.

    • 다음과 같이 스키마 정보를 직접 입력합니다.

      • 텍스트로 편집을 사용 설정하고 테이블 스키마를 JSON 배열로 입력합니다.

      • 필드 추가를 사용하여 스키마를 수동으로 입력합니다.

  7. 파티션 및 클러스터 설정에서 기본값(No partitioning)을 그대로 둡니다.

  8. 고급 옵션 섹션에서 암호화의 기본값(Google-managed key)을 그대로 둡니다. 기본적으로 BigQuery는 비활성 상태로 저장된 고객 콘텐츠를 암호화합니다.

  9. 테이블 만들기를 클릭합니다.

DDL

데이터 정의 언어(DDL) 문을 사용하면 표준 SQL 쿼리 구문으로 테이블과 뷰를 만들고 수정할 수 있습니다.

자세한 내용은 데이터 정의 언어 문 사용을 참조하세요.

DDL 문을 사용하여 Cloud Console에서 테이블을 만들려면 다음 단계를 따르세요.

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.
    Cloud Console로 이동

  2. 새 쿼리 작성을 클릭합니다.

  3. 쿼리 편집기 텍스트 영역에 CREATE TABLE DDL 문을 입력합니다.

    다음 쿼리는 2020년 1월 1일에 만료되는 newtable이라는 테이블을 만듭니다. 테이블 설명은 'a table that expires in 2020(2020년에 만료되는 테이블)'이며, 테이블 라벨은 org_unit:development입니다.

     CREATE TABLE mydataset.newtable
     (
       x INT64 OPTIONS(description="An optional INTEGER field"),
       y STRUCT<
         a ARRAY<STRING> OPTIONS(description="A repeated STRING field"),
         b BOOL
       >
     )
     OPTIONS(
       expiration_timestamp=TIMESTAMP "2020-01-01 00:00:00 UTC",
       description="a table that expires in 2020",
       labels=[("org_unit", "development")]
     )

  4. (선택사항) 더보기를 클릭하고 쿼리 설정을 선택합니다. 쿼리 설정

  5. (선택사항) 처리 위치에서 자동 선택을 클릭하고 데이터의 위치를 선택합니다. 처리 위치 설정을 지정하지 않으면 처리 위치가 자동으로 감지됩니다. 쿼리 처리 위치

  6. 실행을 클릭합니다. 쿼리가 완료되면 테이블이 리소스 창에 나타납니다.

기본 UI

  1. 탐색 패널에서 데이터세트 이름 옆에 있는 아래쪽 화살표 아이콘(아래쪽 화살표 아이콘)을 클릭하고 새 테이블 만들기를 클릭합니다.

  2. 테이블 만들기 페이지의 소스 데이터 섹션에서 빈 테이블 만들기를 클릭합니다.

  3. 테이블 만들기 페이지의 대상 테이블 섹션에서 다음을 수행합니다.

    • 테이블 이름으로 적절한 데이터세트를 선택하고 테이블 이름 필드에 생성 중인 테이블 이름을 입력합니다.
    • 테이블 유형이 기본 테이블로 설정되어 있는지 확인합니다.
  4. 스키마 섹션에서 스키마 정의를 수동으로 입력합니다.

    • 스키마 정보를 직접 입력하는 방법은 다음과 같습니다.

      • 텍스트로 편집을 클릭하고 테이블 스키마를 JSON 배열로 입력합니다.

        JSON 배열로 스키마 추가

      • 필드 추가를 사용하여 스키마를 입력합니다.

        필드 추가를 사용해 스키마 추가

  5. 옵션 섹션에서 기본값을 그대로 둡니다.

  6. 테이블 만들기를 클릭합니다.

CLI

mk 명령어를 --table 또는 -t 플래그와 함께 사용합니다. 인라인으로 또는 JSON 스키마 파일을 통해 테이블 스키마 정보를 제공할 수 있습니다. 선택적 매개변수는 다음과 같습니다.

  • --expiration
  • --description
  • --time_partitioning_type
  • --destination_kms_key
  • --label

여기서는 --time_partitioning_type--destination_kms_key를 설명하지 않습니다. --time_partitioning_type에 대한 자세한 내용은 수집 시간으로 파티션을 나눈 테이블이나 파티션을 나눈 테이블을 참조하세요. --destination_kms_key에 대한 자세한 내용은 고객 관리 암호화 키를 참조하세요.

기본 프로젝트가 아닌 다른 프로젝트에서 테이블을 만드는 경우 프로젝트 ID를 project_id:dataset 형식으로 데이터세트에 추가합니다.

기존 데이터세트에 스키마 정의가 있는 빈 테이블을 만들려면 다음 명령어를 입력합니다.

bq mk \
--table \
--expiration integer \
--description description \
--label key:value, key:value \
project_id:dataset.table \
schema

각 항목의 의미는 다음과 같습니다.

  • integer는 테이블의 기본 수명(단위: 초)입니다. 최솟값은 3,600초(1시간)입니다. 만료 시간은 현재 UTC 시간과 정수 값을 더한 값으로 계산됩니다. 테이블을 만들 때 만료 시간을 설정하면 데이터세트의 기본 테이블 만료 시간 설정이 무시됩니다.
  • description은 따옴표로 묶은 테이블 설명입니다.
  • key:value라벨을 나타내는 키:값 쌍입니다. 쉼표로 구분된 목록을 사용하여 라벨을 여러 개 입력할 수 있습니다.
  • project_id는 프로젝트 ID입니다.
  • dataset는 프로젝트의 데이터세트입니다.
  • table은 만들고 있는 테이블의 이름입니다.
  • schema는 field:data_type,field:data_type 형식의 인라인 스키마 정의이거나 로컬 머신의 JSON 스키마 파일의 경로입니다.

명령줄에서 스키마를 지정할 때는 RECORD(STRUCT) 유형을 포함하거나, 열 설명을 포함하거나, 열 모드를 지정할 수 없습니다. 모든 모드는 기본적으로 NULLABLE로 설정됩니다. 설명, 모드, RECORD 유형을 포함하려면 대신 JSON 스키마 파일을 지정해야 합니다.

예시:

인라인 스키마 정의를 사용하여 테이블을 만들려면 다음 명령어를 입력합니다. 이 명령어는 기본 프로젝트의 mydatasetmytable이라는 테이블을 만듭니다. 테이블 만료는 3,600초(1시간)로, 설명은 This is my table로, 라벨은 organization:development로 설정됩니다. 이 명령어는 --table 대신 단축형 -t를 사용합니다. 스키마는 qtr:STRING,sales:FLOAT,year:STRING과 같이 인라인으로 지정됩니다.

bq mk \
-t \
--expiration 3600 \
--description "This is my table" \
--label organization:development \
mydataset.mytable \
qtr:STRING,sales:FLOAT,year:STRING

JSON 스키마 파일을 사용하여 테이블을 만들려면 다음 명령어를 입력합니다. 이 명령어는 기본 프로젝트의 mydatasetmytable이라는 테이블을 만듭니다. 테이블 만료는 3,600초(1시간)로, 설명은 This is my table로, 라벨은 organization:development로 설정됩니다. 스키마 파일의 경로는 /tmp/myschema.json입니다.

bq mk \
--table \
--expiration 3600 \
--description "This is my table" \
--label organization:development \
mydataset.mytable \
/tmp/myschema.json

JSON 스키마 파일을 사용하여 테이블을 만들려면 다음 명령어를 입력합니다. 이 명령어는 myotherprojectmydatasetmytable이라는 테이블을 만듭니다. 테이블 만료는 3,600초(1시간)로, 설명은 This is my table로, 라벨은 organization:development로 설정됩니다. 스키마 파일의 경로는 /tmp/myschema.json입니다.

bq mk \
--table \
--expiration 3600 \
--description "This is my table" \
--label organization:development \
myotherproject:mydataset.mytable \
/tmp/myschema.json

테이블을 만든 후 테이블의 만료 시간, 설명, 라벨을 업데이트할 수 있습니다. 또한 스키마 정의를 수정할 수 있습니다.

API

테이블 리소스가 정의된 tables.insert 메서드를 호출합니다.

C#

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 C# 설정 안내를 따르세요. 자세한 내용은 BigQuery C# API 참조 문서를 확인하세요.


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

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Go

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Go 설정 안내를 따르세요. 자세한 내용은 BigQuery Go API 참조 문서를 확인하세요.

import (
	"context"
	"fmt"
	"time"

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

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

자바

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 자바 설정 안내를 따르세요. 자세한 내용은 BigQuery Java API 참조 문서를 확인하세요.

TableId tableId = TableId.of(datasetName, tableName);
// Table field definition
Field field = Field.of(fieldName, LegacySQLTypeName.STRING);
// Table schema definition
Schema schema = Schema.of(field);
TableDefinition tableDefinition = StandardTableDefinition.of(schema);
TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();
Table table = bigquery.create(tableInfo);

Node.js

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Node.js 설정 안내를 따르세요. 자세한 내용은 BigQuery Node.js API 참조 문서를 확인하세요.

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

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

PHP

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 PHP 설정 안내를 따르세요. 자세한 내용은 BigQuery PHP API 참조 문서를 확인하세요.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

Python

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Python 설정 안내를 따르세요. 자세한 내용은 BigQuery Python API 참조 문서를 확인하세요.

from google.cloud import bigquery

# TODO(developer): 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"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Ruby 설정 안내를 따르세요. 자세한 내용은 BigQuery Ruby API 참조 문서를 확인하세요.

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

쿼리 결과에서 테이블 만들기

쿼리 결과에서 테이블을 만들려면 결과를 대상 테이블에 써야 합니다.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 탐색 패널의 리소스 섹션에서 프로젝트를 펼치고 데이터세트를 선택합니다.

  3. 쿼리 편집기가 숨겨져 있으면 창 오른쪽 상단에 있는 편집기 표시를 클릭합니다.

  4. 쿼리 편집기 텍스트 영역에 유효한 SQL 쿼리를 입력합니다.

  5. 편집기 아래에서 더보기를 클릭하고 쿼리 설정을 선택합니다.

    쿼리 설정

  6. 쿼리 결과의 대상 테이블 설정 체크박스를 선택합니다.

    대상 설정

  7. 대상 섹션에서 테이블을 만들 적절한 프로젝트 이름과 데이터세트 이름을 선택하고 테이블 이름을 선택합니다.

  8. 대상 테이블 쓰기 환경설정 섹션에서 다음 중 하나를 선택합니다.

    • 비어 있으면 쓰기 — 테이블이 비어 있는 경우에만 쿼리 결과를 테이블에 씁니다.
    • 테이블에 추가 — 쿼리 결과를 기존 테이블에 추가합니다.
    • 테이블 덮어쓰기 — 쿼리 결과를 사용하여 기존 테이블을 같은 이름으로 덮어씁니다.
  9. (선택사항) 처리 위치에서 자동 선택을 클릭하고 사용자의 위치를 선택합니다.

  10. 쿼리 실행을 클릭합니다. 그러면 지정한 테이블에 쿼리 결과를 쓰는 쿼리 작업이 생성됩니다.

또는 쿼리를 실행하기 전에 대상 테이블 지정을 잊은 경우 편집기 아래의 결과 저장 버튼을 클릭하여 캐시된 결과 테이블을 영구 테이블에 복사할 수 있습니다.

DDL

데이터 정의 언어(DDL) 문을 사용하면 표준 SQL 쿼리 구문으로 테이블을 만들고 수정할 수 있습니다.

자세한 내용은 CREATE TABLE 페이지와 CREATE TABLE 예시인 기존 테이블에서 새 테이블 만들기를 참조하세요.

기본 UI

  1. 기본 BigQuery 웹 UI로 이동합니다.
    기본 BigQuery 웹 UI로 이동

  2. 쿼리 작성 버튼을 클릭합니다.

  3. 새 쿼리 텍스트 영역에 유효한 SQL 쿼리를 입력합니다.

  4. 옵션 표시를 클릭합니다.

  5. 대상 테이블 섹션에서 테이블 선택을 클릭합니다.

  6. 대상 테이블 선택 대화상자에서 다음을 수행합니다.

    1. 프로젝트에서 데이터세트 및 테이블을 저장할 프로젝트를 선택합니다.

    2. 데이터세트에서 테이블을 저장할 데이터세트를 선택합니다.

    3. 테이블 ID 필드에 테이블 이름을 입력합니다. 대상 데이터세트 내에서 고유한 이름이어야 합니다. 테이블 이름은 최대 1,024자까지 허용되며 a-z, A-Z, 0-9 또는 _(밑줄 문자)만 포함할 수 있습니다.

    4. 확인을 클릭합니다.

  7. 대상 테이블 섹션의 쓰기 환경설정에서 다음 중 하나를 선택합니다.

    • 비어 있으면 쓰기 — 테이블이 비어 있는 경우에만 쿼리 결과를 테이블에 씁니다.
    • 테이블에 추가 — 쿼리 결과를 기존 테이블에 추가합니다.
    • 테이블 덮어쓰기 — 쿼리 결과를 사용하여 기존 테이블을 같은 이름으로 덮어씁니다.
  8. (선택사항) 처리 위치에서 미지정을 클릭하고 데이터의 위치를 선택합니다.

  9. 쿼리 실행을 클릭합니다. 그러면 지정한 테이블에 쿼리 결과를 쓰는 쿼리 작업이 생성됩니다.

또는 쿼리를 실행하기 전에 대상 테이블을 지정하지 않은 경우 결과 창에서 테이블로 저장 버튼을 클릭하여 임시 테이블을 영구 테이블에 복사할 수 있습니다.

CLI

bq query 명령어를 입력하고 --destination_table 플래그를 지정하여 쿼리 결과에 기반한 영구 테이블을 만듭니다. 표준 SQL 구문을 사용하려면 use_legacy_sql=false 플래그를 지정합니다. 기본 프로젝트에 없는 테이블에 쿼리 결과를 쓰려면 프로젝트 ID를 project_id:dataset 형식으로 데이터세트 이름에 추가합니다.

(선택사항) --location 플래그를 지정하고 값을 사용자의 위치로 설정합니다.

기존 대상 테이블의 쓰기 처리를 제어하려면 다음 플래그 옵션 중 하나를 지정합니다.

  • --append_table — 대상 테이블이 있으면 쿼리 결과가 테이블에 추가됩니다.
  • --replace — 대상 테이블이 있으면 쿼리 결과로 테이블을 덮어씁니다.
bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

각 항목의 의미는 다음과 같습니다.

  • location은 쿼리 처리에 사용되는 위치의 이름입니다. --location 플래그는 선택사항입니다. 예를 들어 도쿄 리전에서 BigQuery를 사용하는 경우 플래그 값을 asia-northeast1로 설정하면 됩니다. .bigqueryrc 파일을 사용하여 위치 기본값을 설정할 수 있습니다.
  • project_id는 프로젝트 ID입니다.
  • dataset는 쿼리 결과를 쓰는 테이블이 포함된 데이터세트의 이름입니다.
  • table은 쿼리 결과를 쓰는 테이블의 이름입니다.
  • query는 표준 SQL 구문의 쿼리입니다.

쓰기 처리 플래그를 지정하지 않으면 비어 있는 경우에만 테이블에 결과를 쓰는 것이 기본 동작입니다. 테이블이 있지만 비어 있지 않으면 다음 오류가 반환됩니다. `BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

예:

mydataset에 있는 mytable이라는 대상 테이블에 쿼리 결과를 쓰려면 다음 명령어를 입력합니다. 데이터세트는 기본 프로젝트에 있습니다. 명령어에 쓰기 처리 플래그가 지정되지 않았으므로 테이블은 새 테이블이거나 비어 있어야 합니다. 그렇지 않으면 Already exists 오류가 반환됩니다. 쿼리는 미국 이름 데이터 공개 데이터세트에서 데이터를 검색합니다.

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=false \
'SELECT
  name,
  number
FROM
  `bigquery-public-data`.usa_names.usa_1910_current
WHERE
  gender = "M"
ORDER BY
  number DESC'

쿼리 결과를 사용하여 mydataset에 있는 mytable이라는 대상 테이블을 덮어쓰려면 다음 명령어를 입력합니다. 데이터세트는 기본 프로젝트에 있습니다. 이 명령어는 --replace 플래그를 사용하여 대상 테이블을 덮어씁니다.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=false \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

mydataset에 있는 mytable이라는 대상 테이블에 쿼리 결과를 추가하려면 다음 명령어를 입력합니다. 데이터세트는 기본 프로젝트가 아닌 my-other-project에 있습니다. 이 명령어는 --append 플래그를 사용하여 쿼리 결과를 대상 테이블에 추가합니다.

bq query \
--append \
--use_legacy_sql=false \
--destination_table my-other-project:mydataset.mytable \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

이러한 각 예시의 출력은 다음과 같이 표시됩니다. 읽기 편하도록 출력 일부는 잘려 있습니다.

Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+

API

쿼리 결과를 영구 테이블에 저장하려면 jobs.insert 메서드를 호출하고, query 작업을 구성하고, destinationTable 속성의 값을 포함합니다. 기존 대상 테이블의 쓰기 처리를 제어하려면 writeDisposition 속성을 구성합니다.

쿼리 작업의 처리 위치를 제어하려면 작업 리소스jobReference 섹션에 location 속성을 지정합니다.

Go

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Go 설정 안내를 따르세요. 자세한 내용은 BigQuery Go API 참조 문서를 확인하세요.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID 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)
	}

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.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
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

자바

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 자바 설정 안내를 따르세요. 자세한 내용은 BigQuery Java API 참조 문서를 확인하세요.

쿼리 결과를 영구 테이블에 저장하려면 QueryJobConfiguration에서 대상 테이블을 원하는 TableId로 설정합니다.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
// String destinationDataset = 'my_destination_dataset';
// String destinationTable = 'my_destination_table';
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    // Note that setUseLegacySql is set to false by default
    QueryJobConfiguration.newBuilder(query)
        // Save the results of the query to a permanent table.
        .setDestinationTable(TableId.of(destinationDataset, destinationTable))
        .build();

// Print the results.
for (FieldValueList row : bigquery.query(queryConfig).iterateAll()) {
  for (FieldValue val : row) {
    System.out.printf("%s,", val.toString());
  }
  System.out.printf("\n");
}

Python

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Python 설정 안내를 따르세요. 자세한 내용은 BigQuery Python API 참조 문서를 확인하세요.

쿼리 결과를 영구 테이블에 저장하려면 QueryJobConfig를 만들고 대상을 원하는 TableReference로 설정합니다. 작업 구성을 쿼리 메서드에 전달합니다.
from google.cloud import bigquery

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

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

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

외부 데이터 소스를 참조하는 테이블 만들기

외부 데이터 소스(제휴 데이터 소스라고도 함)는 데이터가 BigQuery에 저장되어 있지 않더라도 직접 쿼리할 수 있는 데이터 소스입니다. 데이터를 로드 또는 스트리밍하는 대신 외부 데이터 소스를 참조하는 테이블을 만들 수 있습니다.

BigQuery에서 직접적으로 데이터 쿼리를 지원하는 외부 소스는 다음과 같습니다.

지원되는 외부 데이터 소스에 저장된 데이터를 참조하는 임시 또는 영구 테이블을 만들어 외부 데이터 소스의 데이터를 쿼리할 수 있습니다. 외부 데이터 소스 작업에 대한 자세한 내용은 다음 항목을 참조하세요.

데이터 로드 시 테이블 만들기

BigQuery로 데이터를 로드할 때 데이터를 새 테이블 또는 파티션으로 로드할 수도 있고, 데이터를 기존 테이블 또는 파티션에 추가할 수도 있으며, 테이블 또는 파티션을 덮어쓸 수도 있습니다. 데이터를 로드하기 전에 빈 테이블을 만들지 않아도 됩니다. 새 테이블을 만들면서 동시에 데이터를 로드할 수 있습니다.

데이터를 BigQuery로 로드하면 테이블 또는 파티션 스키마를 제공할 수 있으며, 지원되는 데이터 형식인 경우에는 스키마 자동 감지를 사용할 수 있습니다.

데이터 로드에 대한 자세한 내용은 BigQuery에 데이터 로드 소개를 참조하세요.

테이블에 대한 액세스 권한 제어

테이블이나 뷰에 대한 액세스 제어를 직접 할당할 수 없습니다. 액세스 권한을 부여할 수 있는 최저 BigQuery 리소스 수준은 데이터세트 수준입니다. 테이블 및 뷰에 대한 액세스 권한을 구성하려면 데이터세트 수준 이상에서 항목에 Cloud IAM 역할을 부여합니다.

데이터세트 수준에서 역할을 부여하면 특정 데이터세트의 테이블과 뷰에서 항목이 수행할 수 있는 작업이 지정됩니다. 데이터세트 수준의 액세스 권한 제어 구성에 대한 자세한 내용은 데이터세트에 대한 액세스 제어를 참조하세요.

프로젝트, 폴더, 조직 수준과 같이 Google Cloud 리소스 계층 구조의 상위 수준에서 Cloud IAM 역할을 부여할 수도 있습니다. 상위 수준에서 역할을 부여하면 항목이 더욱 다양한 리소스에 액세스할 수 있습니다. 예를 들어 프로젝트 수준에서 항목에 역할을 부여하면 프로젝트의 모든 데이터세트에 적용되는 권한이 항목에 부여됩니다. 리소스에 대한 액세스 권한 부여 방법에 대한 자세한 내용은 Cloud IAM 문서의 리소스에 대한 액세스 권한 부여, 변경, 취소를 참조하세요.

Cloud IAM 커스텀 역할을 만들 수도 있습니다. 커스텀 역할을 만들 경우 항목이 수행하도록 하려는 특정 작업에 따라 권한을 부여합니다.

역할과 권한에 대한 자세한 내용은 다음을 참조하세요.

테이블 사용

테이블 정보 가져오기

다음과 같은 방법으로 테이블에 대한 정보 또는 메타데이터를 가져올 수 있습니다.

  • Cloud Console 또는 기본 BigQuery 웹 UI 사용
  • bq show CLI 명령어 사용
  • tables.get API 메서드 호출
  • 클라이언트 라이브러리 사용
  • INFORMATION_SCHEMA 뷰 쿼리(베타)

필수 권한

테이블에 대한 정보를 가져오려면 최소한 bigquery.tables.get 권한이 부여되어 있어야 합니다. 다음과 같은 사전 정의된 Cloud IAM 역할에는 bigquery.tables.get 권한이 포함되어 있습니다.

  • bigquery.metadataViewer
  • bigquery.dataViewer
  • bigquery.dataOwner
  • bigquery.dataEditor
  • bigquery.admin

또한 bigquery.datasets.create 권한이 있는 사용자는 데이터세트를 만들 때 해당 데이터세트에 대한 bigquery.dataOwner 액세스 권한을 부여받습니다. bigquery.dataOwner 액세스 권한이 있으면 사용자가 테이블 메타데이터를 검색할 수 있습니다.

BigQuery의 Cloud IAM 역할 및 권한에 대한 자세한 내용은 액세스 제어를 참조하세요.

테이블 정보 가져오기

테이블에 대한 정보를 가져오려면 다음 안내를 따르세요.

Console

  1. 탐색 패널의 리소스 섹션에서 프로젝트를 확장하고 데이터세트를 선택합니다. 데이터세트 이름을 클릭하여 확장합니다. 그러면 데이터세트에 있는 테이블과 뷰가 표시됩니다.

  2. 테이블 이름을 클릭합니다.

  3. 편집기 아래에서 세부정보를 클릭합니다. 이 페이지에 테이블의 설명과 테이블 정보가 표시됩니다.

  4. 스키마 탭을 클릭하여 테이블의 스키마 정의를 확인합니다.

기본 UI

  1. 탐색창에서 데이터세트 왼쪽에 있는 아래쪽 화살표 아이콘(아래쪽 화살표 아이콘)을 클릭하여 확장하거나 데이터세트 이름을 더블클릭합니다. 그러면 데이터세트에 있는 테이블과 뷰가 표시됩니다.

  2. 테이블 이름을 클릭합니다.

  3. 세부정보를 클릭하면 테이블 세부정보 페이지에 테이블 설명과 테이블 정보가 표시됩니다.

    테이블 세부정보 보기

  4. 스키마 탭을 클릭하여 테이블의 스키마 정의를 확인합니다.

CLI

bq show 명령어를 실행하여 모든 테이블 정보를 표시합니다. 테이블 스키마 정보만 표시하려면 --schema 플래그를 사용합니다. --format 플래그를 사용하면 출력을 제어할 수 있습니다.

기본 프로젝트가 아닌 프로젝트의 테이블에 대한 정보를 가져오려면 프로젝트 ID를 project_id:dataset 형식으로 데이터세트에 추가합니다.

bq show \
--schema \
--format=prettyjson \
project_id:dataset.table

각 항목의 의미는 다음과 같습니다.

  • project_id는 프로젝트 ID입니다.
  • dataset는 데이터세트 이름입니다.
  • table은 테이블 이름입니다.

예시:

다음 명령어를 입력하여 mydatasetmytable 관련 정보를 모두 표시합니다. 여기서 mydataset는 기본 프로젝트에 있습니다.

bq show --format=prettyjson mydataset.mytable

다음 명령어를 입력하여 mydatasetmytable 관련 정보를 모두 표시합니다. mydataset는 기본 프로젝트가 아닌 myotherproject에 있습니다.

bq show --format=prettyjson myotherproject:mydataset.mytable

mydatasetmytable 관련 스키마 정보만 표시하려면 다음 명령어를 입력합니다. mydataset는 기본 프로젝트가 아닌 myotherproject에 있습니다.

bq show --schema --format=prettyjson myotherproject:mydataset.mytable

API

tables.get 메서드를 호출하고 관련 매개변수를 모두 제공합니다.

Go

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Go 설정 안내를 따르세요. 자세한 내용은 BigQuery Go API 참조 문서를 확인하세요.

import (
	"context"
	"fmt"
	"io"

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

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, 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)
	}

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	// Print basic information about the table.
	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
	fmt.Fprintf(w, "Description: %s\n", meta.Description)
	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
	return nil
}

자바

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 자바 설정 안내를 따르세요. 자세한 내용은 BigQuery Java API 참조 문서를 확인하세요.

TableId tableId = TableId.of(projectId, datasetName, tableName);
Table table = bigquery.getTable(tableId);

Node.js

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Node.js 설정 안내를 따르세요. 자세한 내용은 BigQuery Node.js API 참조 문서를 확인하세요.

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

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

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

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

PHP

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 PHP 설정 안내를 따르세요. 자세한 내용은 BigQuery PHP API 참조 문서를 확인하세요.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
//$projectId = 'The Google project ID';
//$datasetId = 'The BigQuery dataset ID';
//$tableId   = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

Python

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Python 설정 안내를 따르세요. 자세한 내용은 BigQuery Python API 참조 문서를 확인하세요.

# TODO(developer): Import the client library.
# from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

INFORMATION_SCHEMA(베타)를 사용하여 테이블 정보 가져오기

INFORMATION_SCHEMA는 데이터세트, 루틴, 테이블, 뷰의 메타데이터에 액세스할 수 있는 일련의 뷰입니다.

INFORMATION_SCHEMA.TABLESINFORMATION_SCHEMA.TABLE_OPTIONS 뷰를 쿼리하여 프로젝트의 테이블 및 뷰에 대한 메타데이터를 검색할 수 있습니다. 또한 INFORMATION_SCHEMA.COLUMNSINFORMATION_SCHEMA.COLUMN_FIELD_PATHS 뷰를 쿼리하여 테이블의 열(필드)에 대한 메타데이터를 검색할 수 있습니다.

TABLESTABLE_OPTIONS 뷰에는 뷰에 대한 대략적인 정보도 포함되어 있습니다. 자세한 정보를 보려면 INFORMATION_SCHEMA.VIEWS 뷰를 대신 쿼리하세요.

TABLES

INFORMATION_SCHEMA.TABLES 뷰를 쿼리하면 데이터세트의 각 테이블 또는 뷰당 하나의 행이 쿼리 결과에 포함됩니다.

INFORMATION_SCHEMA.TABLES 뷰에는 다음과 같은 스키마가 있습니다.

열 이름 데이터 유형
TABLE_CATALOG STRING 데이터세트가 포함된 프로젝트 이름
TABLE_SCHEMA STRING 테이블이나 뷰가 포함된 데이터세트 이름(또는 datasetId라고 함)
TABLE_NAME STRING 테이블 또는 뷰의 이름(또는 tableId라고 함)
TABLE_TYPE STRING 테이블 유형:
IS_INSERTABLE_INTO STRING 테이블의 DML INSERT 문 지원 여부에 따라 YES 또는 NO
IS_TYPED STRING 값이 항상 NO
CREATION_TIME TIMESTAMP 테이블 생성 시간

예시

예시 1:

다음 예시는 나중에 사용할 수 있도록 예약된 is_typed를 제외하고 INFORMATION_SCHEMA.TABLES 뷰에서 모든 열을 검색합니다. 반환되는 메타데이터는 기본 프로젝트인 myprojectmydataset에 있는 모든 테이블의 메타데이터입니다.

mydataset에는 다음 테이블이 포함되어 있습니다.

  • mytable1: 표준 BigQuery 테이블
  • myview1: BigQuery 뷰

기본 프로젝트가 아닌 프로젝트에 쿼리를 실행하려면 프로젝트 ID를 `project_id`.dataset.INFORMATION_SCHEMA.view 형식으로 데이터세트에 추가합니다(예: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES).

쿼리를 실행하려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 쿼리 편집기 상자에 다음과 같은 표준 SQL 쿼리를 입력합니다. INFORMATION_SCHEMA에는 표준 SQL 구문이 필요합니다. 표준 SQL은 Cloud Console의 기본 구문입니다.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    
  3. 실행을 클릭합니다.

명령줄

query 명령어를 사용하고 --nouse_legacy_sql 또는 --use_legacy_sql=false 플래그를 사용하여 표준 SQL 구문을 지정합니다. INFORMATION_SCHEMA 쿼리에는 표준 SQL 구문이 필요합니다.

쿼리를 실행하려면 다음을 입력하세요.

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_typed)
 FROM
   mydataset.INFORMATION_SCHEMA.TABLES'

결과는 다음과 같이 표시됩니다.

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 |
  | myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

예 2:

다음 예시는 INFORMATION_SCHEMA.TABLES 뷰에서 BASE TABLE 유형의 모든 테이블을 검색합니다. is_typed 열은 제외됩니다. 반환되는 메타데이터는 기본 프로젝트인 myprojectmydataset에 있는 테이블의 메타데이터입니다.

기본 프로젝트가 아닌 프로젝트에 쿼리를 실행하려면 프로젝트 ID를 `project_id`.dataset.INFORMATION_SCHEMA.view 형식으로 데이터세트에 추가합니다(예: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES).

쿼리를 실행하려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 쿼리 편집기 상자에 다음과 같은 표준 SQL 쿼리를 입력합니다. INFORMATION_SCHEMA에는 표준 SQL 구문이 필요합니다. 표준 SQL은 Cloud Console의 기본 구문입니다.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    WHERE
     table_type="BASE TABLE"
    
  3. 실행을 클릭합니다.

명령줄

query 명령어를 사용하고 --nouse_legacy_sql 또는 --use_legacy_sql=false 플래그를 사용하여 표준 SQL 구문을 지정합니다. INFORMATION_SCHEMA 쿼리에는 표준 SQL 구문이 필요합니다.

쿼리를 실행하려면 다음을 입력하세요.

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_typed)
 FROM
   mydataset.INFORMATION_SCHEMA.TABLES
 WHERE
   table_type="BASE TABLE"'

결과는 다음과 같이 표시됩니다.

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | NO                 | 2018-10-31 22:40:05 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

TABLE_OPTIONS

INFORMATION_SCHEMA.TABLE_OPTIONS 뷰를 쿼리하면 데이터세트의 각 테이블 또는 뷰당 하나의 행이 쿼리 결과에 포함됩니다.

INFORMATION_SCHEMA.TABLE_OPTIONS 뷰에는 다음과 같은 스키마가 있습니다.

열 이름 데이터 유형
TABLE_CATALOG STRING 데이터세트가 포함된 프로젝트 이름
TABLE_SCHEMA STRING 테이블이나 뷰가 포함된 데이터세트 이름(또는 datasetId라고 함)
TABLE_NAME STRING 테이블 또는 뷰의 이름(또는 tableId라고 함)
OPTION_NAME STRING 옵션 테이블의 이름 값 중 하나
OPTION_TYPE STRING 옵션 테이블의 데이터 유형 값 중 하나
OPTION_VALUE STRING 옵션 테이블의 값 옵션 중 하나
옵션 표
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 파티션을 나눈 테이블의 모든 파티션 기본 수명(일)
expiration_timestamp FLOAT64 테이블의 기본 수명(일)
kms_key_name STRING 테이블을 암호화하는 데 사용된 Cloud KMS 키의 이름
friendly_name STRING 테이블을 설명하는 이름
description STRING 테이블 설명
labels ARRAY<STRUCT<STRING, STRING>> 테이블의 라벨을 나타내는 STRUCT 배열
require_partition_filter BOOL 테이블에 대한 쿼리에 파티션 필터가 필요한지 여부

예시

예 1:

다음 예시에서는 INFORMATION_SCHEMA.TABLE_OPTIONS 뷰를 쿼리하여 기본 프로젝트(myproject)의 mydataset에 있는 모든 테이블의 기본 테이블 만료 시간을 검색합니다.

기본 프로젝트가 아닌 프로젝트에 쿼리를 실행하려면 프로젝트 ID를 `project_id`.dataset.INFORMATION_SCHEMA.view 형식으로 데이터세트에 추가합니다(예: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS).

쿼리를 실행하려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 쿼리 편집기 상자에 다음과 같은 표준 SQL 쿼리를 입력합니다. INFORMATION_SCHEMA에는 표준 SQL 구문이 필요합니다. 표준 SQL은 Cloud Console의 기본 구문입니다.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="expiration_timestamp"
    
  3. 실행을 클릭합니다.

명령줄

query 명령어를 사용하고 --nouse_legacy_sql 또는 --use_legacy_sql=false 플래그를 사용하여 표준 SQL 구문을 지정합니다. INFORMATION_SCHEMA 쿼리에는 표준 SQL 구문이 필요합니다.

쿼리를 실행하려면 다음을 입력하세요.

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
 WHERE
   option_name="expiration_timestamp"'

결과는 다음과 같이 표시됩니다.

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

예 2:

다음 예시는 테스트 데이터가 포함된 mydataset의 모든 테이블에 대한 메타데이터를 검색합니다. 이 쿼리는 description 옵션의 값을 사용하여 설명의 아무 곳에서나 'test'가 포함된 테이블을 찾습니다. mydataset는 기본 프로젝트 myproject에 있습니다.

기본 프로젝트가 아닌 프로젝트에 쿼리를 실행하려면 프로젝트 ID를 `project_id`.dataset.INFORMATION_SCHEMA.view 형식으로 데이터세트에 추가합니다(예: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS).

쿼리를 실행하려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 쿼리 편집기 상자에 다음과 같은 표준 SQL 쿼리를 입력합니다. INFORMATION_SCHEMA에는 표준 SQL 구문이 필요합니다. 표준 SQL은 Cloud Console의 기본 구문입니다.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="description" AND option_value LIKE "%test%"
    
  3. 실행을 클릭합니다.

명령줄

query 명령어를 사용하고 --nouse_legacy_sql 또는 --use_legacy_sql=false 플래그를 사용하여 표준 SQL 구문을 지정합니다. INFORMATION_SCHEMA 쿼리에는 표준 SQL 구문이 필요합니다.

쿼리를 실행하려면 다음을 입력하세요.

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
 WHERE
   option_name="description" AND option_value LIKE "%test%"'

결과는 다음과 같이 표시됩니다.

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

COLUMNS

INFORMATION_SCHEMA.COLUMNS 뷰를 쿼리하면 테이블의 각 열(필드)당 하나의 행이 쿼리 결과에 포함됩니다.

INFORMATION_SCHEMA.COLUMNS 뷰에는 다음과 같은 스키마가 있습니다.

열 이름 데이터 유형
TABLE_CATALOG STRING 데이터세트가 포함된 프로젝트 이름
TABLE_SCHEMA STRING 테이블이 포함된 데이터세트 이름(또는 datasetId라고 함)
TABLE_NAME STRING 테이블 또는 뷰의 이름(또는 tableId라고 함)
COLUMN_NAME STRING 열 이름
ORDINAL_POSITION INT64 테이블에 있는 열의 1부터 시작하는 오프셋. _PARTITIONTIME 또는 _PARTITIONDATE와 같은 의사 열이면 값은 NULL입니다.
IS_NULLABLE STRING 열의 모드가 NULL 값을 허용하는지 여부에 따라 YES 또는 NO
DATA_TYPE STRING 열의 표준 SQL 데이터 유형
IS_GENERATED STRING 값이 항상 NEVER
GENERATION_EXPRESSION STRING 값이 항상 NULL
IS_STORED STRING 값이 항상 NULL
IS_HIDDEN STRING 열이 _PARTITIONTIME 또는 _PARTITIONDATE와 같은 의사 열인지 여부에 따라 YES 또는 NO
IS_UPDATABLE STRING 값이 항상 NULL
IS_SYSTEM_DEFINED STRING 열이 _PARTITIONTIME 또는 _PARTITIONDATE와 같은 의사 열인지 여부에 따라 YES 또는 NO
IS_PARTITIONING_COLUMN STRING 열이 파티션 나누기 열인지 여부에 따라 YES 또는 NO
CLUSTERING_ORDINAL_POSITION STRING 테이블 클러스터링 열에 있는 해당 열의 1부터 시작하는 오프셋. 테이블이 클러스터링된 테이블이 아니면 값은 NULL입니다.

예시

다음 예시는 census_bureau_usa 데이터세트에 있는 population_by_zip_2010 테이블의 INFORMATION_SCHEMA.COLUMNS 뷰에서 메타데이터를 검색합니다. 이 데이터세트는 BigQuery 공개 데이터세트 프로그램의 일부입니다.

쿼리하려는 테이블이 bigquery-public-data 프로젝트라는 다른 프로젝트에 있으므로 프로젝트 ID를 `project_id`.dataset.INFORMATION_SCHEMA.view 형식으로 데이터세트에 추가합니다(예: `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES).

다음 열은 현재 나중에 사용하도록 예약되어 있으므로 쿼리 결과에서 제외됩니다.

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE

쿼리를 실행하려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 쿼리 편집기 상자에 다음과 같은 표준 SQL 쿼리를 입력합니다. INFORMATION_SCHEMA에는 표준 SQL 구문이 필요합니다. 표준 SQL은 Cloud Console의 기본 구문입니다.

    SELECT
     * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
    FROM
     `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
    WHERE
     table_name="population_by_zip_2010"
    
  3. 실행을 클릭합니다.

명령줄

query 명령어를 사용하고 --nouse_legacy_sql 또는 --use_legacy_sql=false 플래그를 사용하여 표준 SQL 구문을 지정합니다. INFORMATION_SCHEMA 쿼리에는 표준 SQL 구문이 필요합니다.

쿼리를 실행하려면 다음을 입력하세요.

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
 FROM
   `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
 WHERE
   table_name="population_by_zip_2010"'

결과는 다음과 같이 표시됩니다. 가독성을 위해 table_catalogtable_schema는 결과에서 제외됩니다.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
  

COLUMN_FIELD_PATHS

INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 뷰를 쿼리하면 RECORD(또는 STRUCT) 열 내에 중첩된 각 열당 하나의 행이 쿼리 결과에 포함됩니다.

INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 뷰에는 다음과 같은 스키마가 있습니다.

열 이름 데이터 유형
TABLE_CATALOG >STRING 데이터세트가 포함된 프로젝트 이름
TABLE_SCHEMA STRING 테이블이 포함된 데이터세트 이름(또는 datasetId라고 함)
TABLE_NAME STRING 테이블 또는 뷰의 이름(또는 tableId라고 함)
COLUMN_NAME STRING 열 이름
FIELD_PATH STRING `RECORD` 또는 `STRUCT` 열에 있는 중첩된 열 경로
DATA_TYPE STRING 열의 표준 SQL 데이터 유형
DESCRIPTION STRING 열 설명

예시

다음 예시는 github_repos 데이터세트에 있는 commits 테이블의 INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 뷰에서 메타데이터를 검색합니다. 이 데이터세트는 BigQuery 공개 데이터세트 프로그램의 일부입니다.

쿼리하려는 테이블이 bigquery-public-data 프로젝트라는 다른 프로젝트에 있으므로 프로젝트 ID를 `project_id`.dataset.INFORMATION_SCHEMA.view 형식으로 데이터세트에 추가합니다(예: `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS).

commits 테이블에는 다음과 같은 중첩 열과 중첩 및 반복 열이 포함됩니다.

  • author: 중첩 RECORD
  • committer: 중첩 RECORD
  • trailer: 중첩 및 반복 RECORD
  • difference: 중첩 및 반복 RECORD

이 쿼리는 authordifference 열에 대한 메타데이터를 검색합니다.

쿼리를 실행하려면 다음 안내를 따르세요.

Console

  1. Cloud Console에서 BigQuery 웹 UI를 엽니다.

    Cloud Console로 이동

  2. 쿼리 편집기 상자에 다음과 같은 표준 SQL 쿼리를 입력합니다. INFORMATION_SCHEMA에는 표준 SQL 구문이 필요합니다. 표준 SQL은 Cloud Console의 기본 구문입니다.

    SELECT
     *
    FROM
     `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
    WHERE
     table_name="commits"
     AND column_name="author"
     OR column_name="difference"
    
  3. 실행을 클릭합니다.

명령줄

query 명령어를 사용하고 --nouse_legacy_sql 또는 --use_legacy_sql=false 플래그를 사용하여 표준 SQL 구문을 지정합니다. INFORMATION_SCHEMA 쿼리에는 표준 SQL 구문이 필요합니다.

쿼리를 실행하려면 다음을 입력하세요.

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
 WHERE
   table_name="commits"
   AND column_name="author"
   OR column_name="difference"'

결과는 다음과 같이 표시됩니다. 가독성을 위해 table_catalogtable_schema는 결과에서 제외됩니다.

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  

데이터세트의 테이블 나열

다음과 같은 방법으로 데이터세트의 테이블을 나열할 수 있습니다.

  • Cloud Console 또는 기본 BigQuery 웹 UI 사용
  • bq ls CLI 명령어 사용
  • tables.list API 메서드 호출
  • 클라이언트 라이브러리 사용

필수 권한

데이터세트의 테이블을 나열하려면 최소한 bigquery.tables.list 권한이 부여되어 있어야 합니다. 다음과 같은 사전 정의된 Cloud IAM 역할에는 bigquery.tables.list 권한이 포함되어 있습니다.

  • bigquery.user
  • bigquery.metadataViewer
  • bigquery.dataViewer
  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

BigQuery의 Cloud IAM 역할 및 권한에 대한 자세한 내용은 액세스 제어를 참조하세요.

테이블 나열

데이터세트의 테이블을 나열하려면 다음 안내를 따르세요.

Console

  1. Cloud Console의 탐색창에서 데이터세트를 클릭하여 확장합니다. 그러면 데이터세트에 있는 테이블과 뷰가 표시됩니다.

  2. 목록을 스크롤하여 데이터세트의 테이블을 확인합니다. 테이블과 뷰는 서로 다른 아이콘으로 구분됩니다.

기본 UI

  1. 웹 UI의 탐색창에서 데이터세트 왼쪽에 있는 아래쪽 화살표 아이콘 아래쪽 화살표 아이콘을 클릭하여 확장하거나 데이터세트 이름을 더블클릭합니다. 그러면 데이터세트에 있는 테이블과 뷰가 표시됩니다.

  2. 목록을 스크롤하여 데이터세트의 테이블을 확인합니다. 테이블과 뷰는 서로 다른 아이콘으로 구분됩니다.

    테이블 보기

CLI

bq ls 명령어를 실행합니다. --format 플래그를 사용하면 출력을 제어할 수 있습니다. 기본 프로젝트가 아닌 다른 프로젝트의 테이블을 나열하는 경우 프로젝트 ID를 project_id:dataset 형식으로 데이터세트에 추가합니다.

추가 플래그에는 다음이 포함됩니다.

  • --max_results 또는 -n: 결과의 최대 수를 나타내는 정수입니다. 기본값은 50입니다.
bq ls \
--format=pretty \
--max_results integer \
project_id:dataset

각 항목의 의미는 다음과 같습니다.

  • integer는 나열할 테이블 수를 나타내는 정수입니다.
  • project_id는 프로젝트 ID입니다.
  • dataset는 데이터세트 이름입니다.

명령어를 실행하면 Type 필드에 TABLE 또는 VIEW가 표시됩니다. 예를 들면 다음과 같습니다.

+-------------------------+-------+----------------------+-------------------+
|         tableId         | Type  |        Labels        | Time Partitioning |
+-------------------------+-------+----------------------+-------------------+
| mytable                 | TABLE | department:shipping  |                   |
| myview                  | VIEW  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

예:

다음 명령어를 입력하면 기본 프로젝트의 데이터세트 mydataset에 있는 테이블이 나열됩니다.

bq ls --format=pretty mydataset

다음 명령어를 입력하여 mydataset에서 50개의 기본 테이블 출력을 반환합니다. 여기서 mydataset는 기본 프로젝트에 있습니다.

bq ls --format=pretty --max_results 60 mydataset

myotherproject의 데이터세트 mydataset에 있는 테이블을 나열하려면 다음 명령어를 입력합니다.

bq ls --format=pretty myotherproject:mydataset

API

API를 사용하여 테이블을 나열하려면 tables.list 메서드를 호출합니다.

C#

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 C# 설정 안내를 따르세요. 자세한 내용은 BigQuery C# API 참조 문서를 확인하세요.


using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

Go

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Go 설정 안내를 따르세요. 자세한 내용은 BigQuery Go API 참조 문서를 확인하세요.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID 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)
	}

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

자바

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 자바 설정 안내를 따르세요. 자세한 내용은 BigQuery Java API 참조 문서를 확인하세요.

DatasetId datasetId = DatasetId.of(projectId, datasetName);
Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
for (Table table : tables.iterateAll()) {
  // do something with the table
}

Node.js

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Node.js 설정 안내를 따르세요. 자세한 내용은 BigQuery Node.js API 참조 문서를 확인하세요.

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

async function listTables() {
  // Lists tables in 'my_dataset'.

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

  // List all tables in the dataset
  const [tables] = await bigquery.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}

PHP

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 PHP 설정 안내를 따르세요. 자세한 내용은 BigQuery PHP API 참조 문서를 확인하세요.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

Python

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Python 설정 안내를 따르세요. 자세한 내용은 BigQuery Python API 참조 문서를 확인하세요.

# TODO(developer): Import the client library.
# from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

이 샘플을 시도하기 전에 BigQuery 빠른 시작: 클라이언트 라이브러리 사용의 Ruby 설정 안내를 따르세요. 자세한 내용은 BigQuery Ruby API 참조 문서를 확인하세요.

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

다음 단계

이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...

도움이 필요하시나요? 지원 페이지를 방문하세요.