Introdução ao SQL no BigQuery

Neste documento, você vai ter uma visão geral das instruções e dos dialetos SQL suportados no BigQuery.

Visão geral

O Google Standard SQL é uma Linguagem de consulta estruturada (SQL) em conformidade com o ANSI, que inclui os seguintes tipos de instruções compatíveis:

Dialetos SQL do BigQuery

O BigQuery é compatível com o dialeto SQL padrão do Google, mas um dialeto SQL legado também está disponível. Se você está começando a usar o BigQuery, use o SQL padrão do Google, que é compatível com o conjunto mais amplo de funcionalidades. Por exemplo, recursos como instruções DDL e DML são compatíveis somente com o SQL padrão do Google. O SQL legado é mantido para compatibilidade com versões anteriores. Recomendamos que os clientes migrem se estiverem usando o SQL legado.

Como mudar do dialeto padrão

A interface usada para consultar os dados determina qual dialeto de consulta é o padrão. Para trocar para outro dialeto:

Console

O dialeto padrão do console do Cloud é o SQL padrão do Google. Para alterar o dialeto para o SQL legado:

  1. Se necessário, clique em Escrever nova consulta para abrir a janela do editor de consultas.

  2. Clique no botão Mais > Configurações de consulta.

  3. Na seção Configurações extras, clique em Legado para Dialeto SQL. Isso define a opção de SQL legado para essa consulta. Ao clicar em Escrever nova consulta para criar uma nova consulta, será preciso selecionar a opção "SQL legado" novamente.

SQL

O dialeto SQL padrão é o SQL padrão do Google. É possível definir o dialeto SQL incluindo o prefixo #standardSQL ou #legacySQL como parte da consulta. Esses prefixos de consulta não diferenciam maiúsculas de minúsculas, precisam vir antes da consulta e precisam ser separados da consulta por um caractere de nova linha.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, adicione #legacySQL à consulta.

#legacySQL
SELECT
  weight_pounds, state, year, gestation_weeks
FROM
  [bigquery-public-data:samples.natality]
ORDER BY weight_pounds DESC
LIMIT 10;

bq

O dialeto de consulta padrão na ferramenta de linha de comando bq é o SQL legado. Para alternar para o dialeto SQL padrão do Google, adicione a sinalização --use_legacy_sql=false ou --nouse_legacy_sql à instrução de linha de comando.

Mudar para o dialeto SQL padrão do Google

Para usar a sintaxe SQL padrão do Google em um job de consulta, defina o parâmetro use_legacy_sql como false.

  bq query \
  --use_legacy_sql=false \
  'SELECT
    word
  FROM
    `bigquery-public-data.samples.shakespeare`'

Definir o SQL padrão do Google como o dialeto padrão

É possível definir o SQL padrão do Google como o dialeto padrão da ferramenta de linha de comando e do shell interativo editando o arquivo de configuração da ferramenta de linha de comando: .bigqueryrc.

Para mais informações sobre .bigqueryrc, consulte Como configurar valores padrão para sinalizações específicas de comando.

Para configurar --use_legacy_sql=false em .bigqueryrc:

  1. Abra .bigqueryrc em um editor de texto. Por padrão, .bigqueryrc deve estar em seu diretório de usuário. Por exemplo: $HOME/.bigqueryrc.
  2. Adicione o texto a seguir ao arquivo. Este exemplo define o SQL padrão como a sintaxe padrão para consultas e para o comando mk (usado ao criar uma visualização). Caso já tenha configurado valores padrão para sinalizações de comando query ou mk, não será preciso adicionar [query] ou [mk] novamente.

    [query]
    --use_legacy_sql=false
    [mk]
    --use_legacy_sql=false
    
  3. Salve e feche o arquivo.

  4. Se você estiver usando o shell interativo, precisará sair e reiniciar para que as mudanças sejam aplicadas.

Para mais informações sobre as sinalizações de linha de comando disponíveis, consulte a referência da ferramenta de linha de comando bq.

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em C#.

Por padrão, a biblioteca C# usa o SQL padrão do Google.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, defina o parâmetro UseLegacySql como true.


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

public class BigQueryQueryLegacy
{
    public void QueryLegacy(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        string query = @"
            SELECT name FROM [bigquery-public-data:usa_names.usa_1910_2013]
            WHERE state = 'TX'
            LIMIT 100";
        BigQueryJob job = client.CreateQueryJob(
            sql: query,
            parameters: null,
            options: new QueryOptions { UseLegacySql = true });
        // Wait for the job to complete.
        job = job.PollUntilCompleted().ThrowOnAnyError();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

Por padrão, a biblioteca de cliente do Go usa o SQL padrão do Google.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, defina a propriedade UseLegacySQL na configuração de consulta como true.

import (
	"context"
	"fmt"
	"io"

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

// queryLegacy demonstrates running a query using Legacy SQL.
func queryLegacy(w io.Writer, projectID, sqlString string) error {
	// projectID := "my-project-id"
	// sqlString = "SELECT 3 as somenum"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(sqlString)
	q.UseLegacySQL = true

	// Run the query and process the returned row iterator.
	it, err := q.Read(ctx)
	if err != nil {
		return fmt.Errorf("query.Read(): %v", err)
	}
	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
}

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

Por padrão, a biblioteca de cliente do Java usa o SQL padrão do Google.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, defina o parâmetro useLegacySql como true.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;

public class RunLegacyQuery {

  public static void main(String[] args) {
    runLegacyQuery();
  }

  public static void runLegacyQuery() {
    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();

      // To use legacy SQL syntax, set useLegacySql to true.
      String query =
          "SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;";
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setUseLegacySql(true).build();

      // Execute the query.
      TableResult result = bigquery.query(queryConfig);

      // Print the results.
      result.iterateAll().forEach(rows -> rows.forEach(row -> System.out.println(row.getValue())));

      System.out.println("Legacy query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Legacy query did not run \n" + e.toString());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

Por padrão, a biblioteca de cliente do Node.js usa o SQL padrão.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, defina o parâmetro useLegacySql como true.

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

async function queryLegacy() {
  // Queries the U.S. given names dataset for the state of Texas using legacy SQL.

  const query =
    'SELECT word FROM [bigquery-public-data:samples.shakespeare] LIMIT 10;';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    useLegacySql: true,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);
  console.log(`Job ${job.id} started.`);

  // Wait for the query to finish
  const [rows] = await job.getQueryResults();

  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

PHP

Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.

Por padrão, a biblioteca de cliente do PHP usa o SQL padrão do Google.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, defina o parâmetro useLegacySql como true.

use Google\Cloud\BigQuery\BigQueryClient;

$query = 'SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$jobConfig = $bigQuery->query($query)->useLegacySql(true);

$queryResults = $bigQuery->runQuery($jobConfig);

$i = 0;
foreach ($queryResults as $row) {
    printf('--- Row %s ---' . PHP_EOL, ++$i);
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, json_encode($value));
    }
}
printf('Found %s row(s)' . PHP_EOL, $i);

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.

Por padrão, a biblioteca de cliente do Python usa o SQL padrão do Google.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, defina o parâmetro use_legacy_sql como True.

from google.cloud import bigquery

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

query = (
    "SELECT name FROM [bigquery-public-data:usa_names.usa_1910_2013] "
    'WHERE state = "TX" '
    "LIMIT 100"
)

# Set use_legacy_sql to True to use legacy SQL syntax.
job_config = bigquery.QueryJobConfig(use_legacy_sql=True)

# Start the query, passing in the extra configuration.
query_job = client.query(query, job_config=job_config)  # Make an API request.

print("The query data:")
for row in query_job:
    print(row)

Ruby

Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de Referência da API BigQuery Ruby.

Por padrão, a biblioteca de cliente do Ruby usa o SQL padrão do Google.

Mudar para o dialeto SQL legado

Para usar a sintaxe do SQL legado em um job de consulta, transmita a opção legacy_sql: true com a consulta.

require "google/cloud/bigquery"

def query_legacy
  bigquery = Google::Cloud::Bigquery.new
  sql = "SELECT name FROM [bigquery-public-data:usa_names.usa_1910_2013] " \
        "WHERE state = 'TX' " \
        "LIMIT 100"

  results = bigquery.query sql, legacy_sql: true do |config|
    # Location must match that of the dataset(s) referenced in the query.
    config.location = "US"
  end

  results.each do |row|
    puts row.inspect
  end
end

A seguir