Changer de dialecte SQL

Cet article explique comment définir le dialecte des requêtes lorsque vous interrogez des données BigQuery. Vous pouvez utiliser le dialecte SQL standard ou l'ancien dialecte SQL.

Pour découvrir comment interroger des données à l'aide de l'UI Web de BigQuery, consultez le guide de démarrage rapide à l'aide de l'interface utilisateur Web.

Pour découvrir comment interroger des données à l'aide de l'outil de ligne de commande bq, consultez le guide de démarrage rapide avec l'outil de ligne de commande bq.

Changer le dialecte par défaut

L'interface que vous utilisez pour interroger vos données détermine le dialecte de requête par défaut :

  • Dans la console GCP et les bibliothèques clientes, c'est le dialecte SQL standard qui est utilisé par défaut.
  • Dans l'UI Web classique de BigQuery, l'outil de ligne de commande bq et l'API REST, c'est l'ancien dialecte SQL qui est utilisé par défaut.

Pour basculer d'un dialecte à l'autre :

Console

Le dialecte par défaut de la console GCP est le dialecte SQL standard. Pour remplacer cette valeur par l'ancien dialecte SQL :

  1. Si nécessaire, cliquez sur Saisir une nouvelle requête pour ouvrir la fenêtre de l'éditeur de requête.

  2. Sous l'éditeur de requête, cliquez sur Plus > Paramètres de requête.

  3. Cliquez sur Options avancées.

  4. Dans la section Paramètres supplémentaires, cliquez sur Ancien pour l'option Dialecte SQL. Cela définit l'ancien dialecte SQL comme dialecte à utiliser pour cette requête. Si vous cliquez sur Saisir une nouvelle requête pour rédiger une autre requête, vous devrez à nouveau définir l'option de dialecte SQL.

UI classique

Le dialecte par défaut de l'UI Web BigQuery classique est l'ancien dialecte SQL. Pour remplacer cette valeur par le dialecte SQL standard :

  1. Dans l'UI Web classique de BigQuery, cliquez sur Saisir une requête.

  2. Cliquez sur Afficher les options.

  3. Pour l'option Dialecte SQL, décochez la case Utiliser l'ancien SQL. Cela définit le dialecte SQL standard comme dialecte à utiliser tant que l'éditeur de requête est ouvert. Si vous fermez et rouvrez ultérieurement l'éditeur de requête, vous devrez à nouveau décocher l'option Utiliser l'ancien SQL.

CLI

Le dialecte de requête par défaut dans l'outil de ligne de commande bq est l'ancien dialecte SQL. Pour basculer vers le dialecte SQL standard, ajoutez l'indicateur --use_legacy_sql=false ou --nouse_legacy_sql à votre instruction de ligne de commande.

Exemple :

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

C#

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour C# décrite dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery C#.

Lors de l'exécution d'une requête, le langage SQL standard est utilisé par défaut.


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

public class BigQueryQuery
{
    public void Query(
        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 { UseQueryCache = false });
        // Wait for the job to complete.
        job.PollUntilCompleted();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

Utiliser l'ancien SQL

Pour utiliser l'ancien SQL lors de l'exécution de requêtes, définissez le paramètre "UseLegacySql" sur "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.PollUntilCompleted();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go décrite dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Go.

Par défaut, la bibliothèque cliente Go utilise le langage SQL standard.


q := client.Query(
	"SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
		"WHERE state = \"TX\" " +
		"LIMIT 100")
// Location must match that of the dataset(s) referenced in the query.
q.Location = "US"
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.Println(row)
}

Utiliser l'ancien SQL

Pour faire revenir une requête à l'ancien SQL, servez-vous de la propriété UseLegacySQL dans la configuration de la requête.

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

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.Println(row)
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Java.

Par défaut, la bibliothèque cliente Java utilise le langage SQL standard.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).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");
}

Utiliser l'ancien SQL

Définissez le paramètre useLegacySql sur true pour utiliser la syntaxe de l'ancien SQL dans une tâche de requête.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
String query = "SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    // To use legacy SQL syntax, set useLegacySql to true.
    QueryJobConfiguration.newBuilder(query).setUseLegacySql(true).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");
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Node.js dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Node.js.

Par défaut, la bibliothèque cliente Node.js utilise le langage SQL standard.

// Import the Google Cloud client library using default credentials
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();
async function query() {
  // Queries the U.S. given names dataset for the state of Texas.

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // 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',
  };

  // 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));
}

Utiliser l'ancien SQL

Définissez le paramètre useLegacySql sur true pour utiliser la syntaxe de l'ancien SQL dans une tâche de requête.

PHP

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour PHP dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery PHP.

Par défaut, la bibliothèque cliente PHP utilise le langage SQL standard.

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

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

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

$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
$queryResults = $job->queryResults();

$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);

Utiliser l'ancien SQL

Définissez le paramètre useLegacySql sur true pour utiliser la syntaxe de l'ancien SQL dans une tâche de requête.

Python

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Python décrite dans le guide de démarrage rapide de BigQuery relatif à l'utilisation des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Python.

Par défaut, la bibliothèque cliente Python utilise le langage SQL standard.

# from google.cloud import bigquery
# client = bigquery.Client()

query = (
    "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` "
    'WHERE state = "TX" '
    "LIMIT 100"
)
query_job = client.query(
    query,
    # Location must match that of the dataset(s) referenced in the query.
    location="US",
)  # API request - starts the query

for row in query_job:  # API request - fetches results
    # Row values can be accessed by field name or index
    assert row[0] == row.name == row["name"]
    print(row)

Utiliser l'ancien SQL

Définissez le paramètre use_legacy_sql sur True pour utiliser la syntaxe de l'ancien SQL dans une tâche de requête.

# from google.cloud import bigquery
# 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()
job_config.use_legacy_sql = True

query_job = client.query(
    query,
    # Location must match that of the dataset(s) referenced in the query.
    location="US",
    job_config=job_config,
)  # API request - starts the query

# Print the results.
for row in query_job:  # API request - fetches results
    print(row)

Ruby

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Ruby dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Ruby.

Par défaut, la bibliothèque cliente Ruby utilise le langage SQL standard.

require "google/cloud/bigquery"

def query
  bigquery = Google::Cloud::Bigquery.new
  sql = "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
        "WHERE state = 'TX' " +
        "LIMIT 100"

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

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

Utiliser un préfixe de requête dans l'UI

Vous pouvez également définir le dialecte SQL dans la console GCP ou dans l'UI Web classique en intégrant à votre requête un préfixe qui indique le dialecte SQL.

Les préfixes suivants vous permettent de définir le dialecte SQL à utiliser :

Préfixe Description
#legacySQL Exécute la requête en utilisant l'ancien SQL.
#standardSQL Exécute la requête en utilisant le langage SQL standard.

Dans la console GCP, lorsque vous utilisez un préfixe de requête, l'option de Dialecte SQL des Paramètres de requête est désactivée.

Dans l'UI Web classique, lorsque vous utilisez un préfixe de requête, celui-ci doit correspondre à l'option de Dialecte SQL. Par exemple, si vous décochez l'option Utiliser l'ancien SQL dans l'UI Web classique, vous ne pouvez pas utiliser le préfixe #legacySQL.

Par exemple, si vous copiez et collez la requête suivante dans la console GCP, BigQuery l'exécute dans l'ancien dialecte SQL et ignore le paramètre par défaut. Dans la console GCP, il s'agit du SQL standard.

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

Les préfixes de requête #legacySQL et #standardSQL :

  • ne sont PAS sensibles à la casse ;
  • doivent précéder la requête ;
  • doivent être séparés de la requête par un caractère de nouvelle ligne.

Certains outils tiers peuvent ne pas accepter ce préfixe s'ils modifient par exemple le texte de la requête avant de l'envoyer à BigQuery.

Définir le langage SQL standard comme option par défaut pour l'outil de ligne de commande

Vous pouvez définir le langage SQL standard comme syntaxe par défaut pour l'outil de ligne de commande et l'interface système interactive en modifiant le fichier de configuration de l'outil de ligne de commande : .bigqueryrc.

Pour plus d'informations sur .bigqueryrc, consultez la section Définir des valeurs par défaut pour les indicateurs spécifiques aux commandes.

Pour définir --use_legacy_sql=false dans .bigqueryrc :

  1. Ouvrez .bigqueryrc dans un éditeur de texte. Par défaut, .bigqueryrc devrait figurer dans votre répertoire utilisateur, par exemple $HOME/.bigqueryrc.

  2. Ajoutez ce qui suit au fichier. Cet exemple définit le langage SQL standard comme syntaxe par défaut pour les requêtes et pour la commande mk (utilisée lors de la création d'une vue). Si vous avez déjà configuré des valeurs par défaut pour les indicateurs de commande query ou mk, il n'est pas nécessaire d'ajouter à nouveau [query] ou [mk].

    [query]
    --use_legacy_sql=false
    
    [mk]
    --use_legacy_sql=false
    
  3. Enregistrez et fermez le fichier.

  4. Si vous utilisez l'interface système interactive, vous devez en sortir et la redémarrer pour que les modifications soient appliquées.

Pour plus d'informations sur les indicateurs de ligne de commande disponibles, consultez la documentation de référence sur l'outil de ligne de commande bq.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.