Running parameterized queries

BigQuery supports query parameters to help prevent SQL injection when queries are constructed using user input. This feature is only available with GoogleSQL syntax . Query parameters can be used as substitutes for arbitrary expressions. Parameters cannot be used as substitutes for identifiers, column names, table names, or other parts of the query.

To specify a named parameter, use the @ character followed by an identifier , such as @param_name . Alternatively, use the placeholder value ? to specify a positional parameter. Note that a query can use positional or named parameters but not both.

When using a parameter, the provided value itself is not logged in the BigQuery logs to protect potentially sensitive information.

You can run a parameterized query in BigQuery in the following ways:

  • the bq command-line tool's bq query command
  • the API
  • the client libraries

The following example shows how to pass parameter values to a parameterized query:

Console

Parameterized queries are not supported by the Google Cloud console.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Use --parameter to provide values for parameters in the form name:type:value . An empty name produces a positional parameter. The type may be omitted to assume STRING .

    The --parameter flag must be used in conjunction with the flag --use_legacy_sql=false to specify GoogleSQL syntax.

    (Optional) Specify your location using the --location flag.

    bq  
    query  
     \ 
      
    --use_legacy_sql = 
     false 
      
     \ 
      
    --parameter = 
    corpus::romeoandjuliet  
     \ 
      
    --parameter = 
    min_word_count:INT64:250  
     \ 
      
     'SELECT 
     word, 
     word_count 
     FROM 
     `bigquery-public-data.samples.shakespeare` 
     WHERE 
     corpus = @corpus 
     AND 
     word_count >= @min_word_count 
     ORDER BY 
     word_count DESC;' 
    

API

To use named parameters, set the parameterMode to NAMED in the query job configuration.

Populate queryParameters with the list of parameters in the query job configuration. Set the name of each parameter with the @param_name used in the query.

Enable GoogleSQL syntax by setting useLegacySql to false .

  { 
  
 "query" 
 : 
  
 "SELECT word, word_count FROM `bigquery-public-data.samples.shakespeare` WHERE corpus = @corpus AND word_count >= @min_word_count ORDER BY word_count DESC;" 
 , 
  
 "queryParameters" 
 : 
  
 [ 
  
 { 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "STRING" 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "value" 
 : 
  
 "romeoandjuliet" 
  
 }, 
  
 "name" 
 : 
  
 "corpus" 
  
 }, 
  
 { 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "INT64" 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "value" 
 : 
  
 "250" 
  
 }, 
  
 "name" 
 : 
  
 "min_word_count" 
  
 } 
  
 ], 
  
 "useLegacySql" 
 : 
  
 false 
 , 
  
 "parameterMode" 
 : 
  
 "NAMED" 
 } 
 

Try it in the Google APIs Explorer .

To use positional parameters, set the parameterMode to POSITIONAL in the query job configuration.

C#

Before trying this sample, follow the C# setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery C# API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

To use named parameters:
  using 
  
  Google.Cloud.BigQuery.V2 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 BigQueryQueryWithNamedParameters 
 { 
  
 public 
  
 void 
  
 QueryWithNamedParameters 
 ( 
 string 
  
 projectId 
  
 = 
  
 "your-project-id" 
 ) 
  
 { 
  
 var 
  
 corpus 
  
 = 
  
 "romeoandjuliet" 
 ; 
  
 var 
  
 minWordCount 
  
 = 
  
 250 
 ; 
  
 // Note: Standard SQL is required to use query parameters. 
  
 var 
  
 query 
  
 = 
  
 @" 
 SELECT word, word_count 
 FROM `bigquery-public-data.samples.shakespeare` 
 WHERE corpus = @corpus 
 AND word_count >= @min_word_count 
 ORDER BY word_count DESC" 
 ; 
  
 // Initialize client that will be used to send requests. 
  
 var 
  
 client 
  
 = 
  
  BigQueryClient 
 
 . 
  Create 
 
 ( 
 projectId 
 ); 
  
 var 
  
 parameters 
  
 = 
  
 new 
  
  BigQueryParameter 
 
 [] 
  
 { 
  
 new 
  
  BigQueryParameter 
 
 ( 
 "corpus" 
 , 
  
  BigQueryDbType 
 
 . 
  String 
 
 , 
  
 corpus 
 ), 
  
 new 
  
  BigQueryParameter 
 
 ( 
 "min_word_count" 
 , 
  
  BigQueryDbType 
 
 . 
  Int64 
 
 , 
  
 minWordCount 
 ) 
  
 }; 
  
 var 
  
 job 
  
 = 
  
 client 
 . 
 CreateQueryJob 
 ( 
  
 sql 
 : 
  
 query 
 , 
  
 parameters 
 : 
  
 parameters 
 , 
  
 options 
 : 
  
 new 
  
  QueryOptions 
 
  
 { 
  
 UseQueryCache 
  
 = 
  
 false 
  
 }); 
  
 // Wait for the job to complete. 
  
 job 
  
 = 
  
 job 
 . 
  PollUntilCompleted 
 
 (). 
 ThrowOnAnyError 
 (); 
  
 // Display the results 
  
 foreach 
  
 ( 
  BigQueryRow 
 
  
 row 
  
 in 
  
 client 
 . 
 GetQueryResults 
 ( 
 job 
 . 
 Reference 
 )) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"{row[" 
 word 
 "]}: {row[" 
 word_count 
 "]}" 
 ); 
  
 } 
  
 } 
 } 
 

Before trying this sample, follow the C# setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery C# API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

To use positional parameters:
  using 
  
  Google.Cloud.BigQuery.V2 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 BigQueryQueryWithPositionalParameters 
 { 
  
 public 
  
 void 
  
 QueryWithPositionalParameters 
 ( 
 string 
  
 projectId 
  
 = 
  
 "project-id" 
 ) 
  
 { 
  
 var 
  
 corpus 
  
 = 
  
 "romeoandjuliet" 
 ; 
  
 var 
  
 minWordCount 
  
 = 
  
 250 
 ; 
  
 // Note: Standard SQL is required to use query parameters. 
  
 var 
  
 query 
  
 = 
  
 @" 
 SELECT word, word_count 
 FROM `bigquery-public-data.samples.shakespeare` 
 WHERE corpus = ? 
 AND word_count >= ? 
 ORDER BY word_count DESC;" 
 ; 
  
 // Initialize client that will be used to send requests. 
  
 var 
  
 client 
  
 = 
  
  BigQueryClient 
 
 . 
  Create 
 
 ( 
 projectId 
 ); 
  
 // Set the name to None to use positional parameters. 
  
 // Note that you cannot mix named and positional parameters. 
  
 var 
  
 parameters 
  
 = 
  
 new 
  
  BigQueryParameter 
 
 [] 
  
 { 
  
 new 
  
  BigQueryParameter 
 
 ( 
 null 
 , 
  
  BigQueryDbType 
 
 . 
  String 
 
 , 
  
 corpus 
 ), 
  
 new 
  
  BigQueryParameter 
 
 ( 
 null 
 , 
  
  BigQueryDbType 
 
 . 
  Int64 
 
 , 
  
 minWordCount 
 ) 
  
 }; 
  
 var 
  
 job 
  
 = 
  
 client 
 . 
 CreateQueryJob 
 ( 
  
 sql 
 : 
  
 query 
 , 
  
 parameters 
 : 
  
 parameters 
 , 
  
 options 
 : 
  
 new 
  
  QueryOptions 
 
  
 { 
  
 UseQueryCache 
  
 = 
  
 false 
 , 
  
 ParameterMode 
  
 = 
  
  BigQueryParameterMode 
 
 . 
  Positional 
 
  
 }); 
  
 // Wait for the job to complete. 
  
 job 
  
 = 
  
 job 
 . 
  PollUntilCompleted 
 
 (). 
 ThrowOnAnyError 
 (); 
  
 // Display the results 
  
 foreach 
  
 ( 
  BigQueryRow 
 
  
 row 
  
 in 
  
 client 
 . 
 GetQueryResults 
 ( 
 job 
 . 
 Reference 
 )) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"{row[" 
 word 
 "]}: {row[" 
 word_count 
 "]}" 
 ); 
  
 } 
  
 } 
 } 
 

Go

Before trying this sample, follow the Go setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Go API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

To use named parameters:
  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "cloud.google.com/go/bigquery" 
  
 "google.golang.org/api/iterator" 
 ) 
 // queryWithNamedParams demonstrate issuing a query using named query parameters. 
 func 
  
 queryWithNamedParams 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "my-project-id" 
  
 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 
 ( 
  
 `SELECT word, word_count 
 FROM ` 
  
 + 
  
 "`bigquery-public-data.samples.shakespeare`" 
  
 + 
  
 ` 
 WHERE corpus = @corpus 
 AND word_count >= @min_word_count 
 ORDER BY word_count DESC;` 
 ) 
  
 q 
 . 
 Parameters 
  
 = 
  
 [] 
 bigquery 
 . 
  QueryParameter 
 
 { 
  
 { 
  
 Name 
 : 
  
 "corpus" 
 , 
  
 Value 
 : 
  
 "romeoandjuliet" 
 , 
  
 }, 
  
 { 
  
 Name 
 : 
  
 "min_word_count" 
 , 
  
 Value 
 : 
  
 250 
 , 
  
 }, 
  
 } 
  
 // 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 
 } 
 
To use positional parameters:
  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "cloud.google.com/go/bigquery" 
  
 "google.golang.org/api/iterator" 
 ) 
 // queryWithPostionalParams demonstrate issuing a query using positional query parameters. 
 func 
  
 queryWithPositionalParams 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "my-project-id" 
  
 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 
 ( 
  
 `SELECT word, word_count 
 FROM ` 
  
 + 
  
 "`bigquery-public-data.samples.shakespeare`" 
  
 + 
  
 ` 
 WHERE corpus = ? 
 AND word_count >= ? 
 ORDER BY word_count DESC;` 
 ) 
  
 q 
 . 
 Parameters 
  
 = 
  
 [] 
 bigquery 
 . 
  QueryParameter 
 
 { 
  
 { 
  
 Value 
 : 
  
 "romeoandjuliet" 
 , 
  
 }, 
  
 { 
  
 Value 
 : 
  
 250 
 , 
  
 }, 
  
 } 
  
 // 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 
 } 
 

Java

Before trying this sample, follow the Java setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Java API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

To use named parameters:
  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. QueryParameterValue 
 
 ; 
 import 
  
 com.google.cloud.bigquery. TableResult 
 
 ; 
 public 
  
 class 
 QueryWithNamedParameters 
  
 { 
  
 public 
  
 static 
  
 void 
  
 queryWithNamedParameters 
 () 
  
 { 
  
 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 
 (); 
  
 String 
  
 corpus 
  
 = 
  
 "romeoandjuliet" 
 ; 
  
 long 
  
 minWordCount 
  
 = 
  
 250 
 ; 
  
 String 
  
 query 
  
 = 
  
 "SELECT word, word_count\n" 
  
 + 
  
 "FROM `bigquery-public-data.samples.shakespeare`\n" 
  
 + 
  
 "WHERE corpus = @corpus\n" 
  
 + 
  
 "AND word_count >= @min_word_count\n" 
  
 + 
  
 "ORDER BY word_count DESC" 
 ; 
  
 // Note: Standard SQL is required to use query parameters. 
  
  QueryJobConfiguration 
 
  
 queryConfig 
  
 = 
  
  QueryJobConfiguration 
 
 . 
 newBuilder 
 ( 
 query 
 ) 
  
 . 
  addNamedParameter 
 
 ( 
 "corpus" 
 , 
  
  QueryParameterValue 
 
 . 
  string 
 
 ( 
 corpus 
 )) 
  
 . 
  addNamedParameter 
 
 ( 
 "min_word_count" 
 , 
  
  QueryParameterValue 
 
 . 
  int64 
 
 ( 
 minWordCount 
 )) 
  
 . 
 build 
 (); 
  
  TableResult 
 
  
 results 
  
 = 
  
 bigquery 
 . 
  query 
 
 ( 
 queryConfig 
 ); 
  
 results 
  
 . 
  iterateAll 
 
 () 
  
 . 
 forEach 
 ( 
 row 
  
 - 
>  
 row 
 . 
 forEach 
 ( 
 val 
  
 - 
>  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "%s," 
 , 
  
 val 
 . 
 toString 
 ()))); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query with named parameters performed successfully." 
 ); 
  
 } 
  
 catch 
  
 ( 
  BigQueryException 
 
  
 | 
  
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query not performed \n" 
  
 + 
  
 e 
 . 
 toString 
 ()); 
  
 } 
  
 } 
 } 
 
To use positional parameters:
  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. QueryParameterValue 
 
 ; 
 import 
  
 com.google.cloud.bigquery. TableResult 
 
 ; 
 public 
  
 class 
 QueryWithPositionalParameters 
  
 { 
  
 public 
  
 static 
  
 void 
  
 queryWithPositionalParameters 
 () 
  
 { 
  
 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 
 (); 
  
 String 
  
 corpus 
  
 = 
  
 "romeoandjuliet" 
 ; 
  
 long 
  
 minWordCount 
  
 = 
  
 250 
 ; 
  
 String 
  
 query 
  
 = 
  
 "SELECT word, word_count\n" 
  
 + 
  
 "FROM `bigquery-public-data.samples.shakespeare`\n" 
  
 + 
  
 "WHERE corpus = ?\n" 
  
 + 
  
 "AND word_count >= ?\n" 
  
 + 
  
 "ORDER BY word_count DESC" 
 ; 
  
 // Note: Standard SQL is required to use query parameters. 
  
  QueryJobConfiguration 
 
  
 queryConfig 
  
 = 
  
  QueryJobConfiguration 
 
 . 
 newBuilder 
 ( 
 query 
 ) 
  
 . 
  addPositionalParameter 
 
 ( 
  QueryParameterValue 
 
 . 
  string 
 
 ( 
 corpus 
 )) 
  
 . 
  addPositionalParameter 
 
 ( 
  QueryParameterValue 
 
 . 
  int64 
 
 ( 
 minWordCount 
 )) 
  
 . 
 build 
 (); 
  
  TableResult 
 
  
 results 
  
 = 
  
 bigquery 
 . 
  query 
 
 ( 
 queryConfig 
 ); 
  
 results 
  
 . 
  iterateAll 
 
 () 
  
 . 
 forEach 
 ( 
 row 
  
 - 
>  
 row 
 . 
 forEach 
 ( 
 val 
  
 - 
>  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "%s," 
 , 
  
 val 
 . 
 toString 
 ()))); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query with positional parameters performed successfully." 
 ); 
  
 } 
  
 catch 
  
 ( 
  BigQueryException 
 
  
 | 
  
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query not performed \n" 
  
 + 
  
 e 
 . 
 toString 
 ()); 
  
 } 
  
 } 
 } 
 

Node.js

Before trying this sample, follow the Node.js setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Node.js API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

To use named parameters:
  // Run a query using named query parameters 
 // Import the Google Cloud client library 
 const 
  
 { 
 BigQuery 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/bigquery 
' 
 ); 
 const 
  
 bigquery 
  
 = 
  
 new 
  
  BigQuery 
 
 (); 
 async 
  
 function 
  
 queryParamsNamed 
 () 
  
 { 
  
 // The SQL query to run 
  
 const 
  
 sqlQuery 
  
 = 
  
 `SELECT word, word_count 
 FROM \`bigquery-public-data.samples.shakespeare\` 
 WHERE corpus = @corpus 
 AND word_count >= @min_word_count 
 ORDER BY word_count DESC` 
 ; 
  
 const 
  
 options 
  
 = 
  
 { 
  
 query 
 : 
  
 sqlQuery 
 , 
  
 // Location must match that of the dataset(s) referenced in the query. 
  
 location 
 : 
  
 'US' 
 , 
  
 params 
 : 
  
 { 
 corpus 
 : 
  
 'romeoandjuliet' 
 , 
  
 min_word_count 
 : 
  
 250 
 }, 
  
 }; 
  
 // Run the query 
  
 const 
  
 [ 
 rows 
 ] 
  
 = 
  
 await 
  
 bigquery 
 . 
 query 
 ( 
 options 
 ); 
  
 console 
 . 
 log 
 ( 
 'Rows:' 
 ); 
  
 rows 
 . 
 forEach 
 ( 
 row 
  
 = 
>  
 console 
 . 
 log 
 ( 
 row 
 )); 
 } 
 
To use positional parameters:
  // Run a query using positional query parameters 
 // Import the Google Cloud client library 
 const 
  
 { 
 BigQuery 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/bigquery 
' 
 ); 
 const 
  
 bigquery 
  
 = 
  
 new 
  
  BigQuery 
 
 (); 
 async 
  
 function 
  
 queryParamsPositional 
 () 
  
 { 
  
 // The SQL query to run 
  
 const 
  
 sqlQuery 
  
 = 
  
 `SELECT word, word_count 
 FROM \`bigquery-public-data.samples.shakespeare\` 
 WHERE corpus = ? 
 AND word_count >= ? 
 ORDER BY word_count DESC` 
 ; 
  
 const 
  
 options 
  
 = 
  
 { 
  
 query 
 : 
  
 sqlQuery 
 , 
  
 // Location must match that of the dataset(s) referenced in the query. 
  
 location 
 : 
  
 'US' 
 , 
  
 params 
 : 
  
 [ 
 'romeoandjuliet' 
 , 
  
 250 
 ], 
  
 }; 
  
 // Run the query 
  
 const 
  
 [ 
 rows 
 ] 
  
 = 
  
 await 
  
 bigquery 
 . 
 query 
 ( 
 options 
 ); 
  
 console 
 . 
 log 
 ( 
 'Rows:' 
 ); 
  
 rows 
 . 
 forEach 
 ( 
 row 
  
 = 
>  
 console 
 . 
 log 
 ( 
 row 
 )); 
 } 
 

Python

Before trying this sample, follow the Python setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Python API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

To use named parameters:
  from 
  
 google.cloud 
  
 import 
  bigquery 
 
 # Construct a BigQuery client object. 
 client 
 = 
  bigquery 
 
 . 
  Client 
 
 () 
 query 
 = 
 """ 
 SELECT word, word_count 
 FROM `bigquery-public-data.samples.shakespeare` 
 WHERE corpus = @corpus 
 AND word_count >= @min_word_count 
 ORDER BY word_count DESC; 
 """ 
 job_config 
 = 
  bigquery 
 
 . 
  QueryJobConfig 
 
 ( 
 query_parameters 
 = 
 [ 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 "corpus" 
 , 
 "STRING" 
 , 
 "romeoandjuliet" 
 ), 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 "min_word_count" 
 , 
 "INT64" 
 , 
 250 
 ), 
 ] 
 ) 
 results 
 = 
 client 
 . 
  query_and_wait 
 
 ( 
 query 
 , 
 job_config 
 = 
 job_config 
 ) 
 # Make an API request. 
 for 
 row 
 in 
 results 
 : 
 print 
 ( 
 " 
 {} 
 : 
 \t 
 {} 
 " 
 . 
 format 
 ( 
 row 
 . 
 word 
 , 
 row 
 . 
 word_count 
 )) 
 
To use positional parameters:
  from 
  
 google.cloud 
  
 import 
  bigquery 
 
 # Construct a BigQuery client object. 
 client 
 = 
  bigquery 
 
 . 
  Client 
 
 () 
 query 
 = 
 """ 
 SELECT word, word_count 
 FROM `bigquery-public-data.samples.shakespeare` 
 WHERE corpus = ? 
 AND word_count >= ? 
 ORDER BY word_count DESC; 
 """ 
 # Set the name to None to use positional parameters. 
 # Note that you cannot mix named and positional parameters. 
 job_config 
 = 
  bigquery 
 
 . 
  QueryJobConfig 
 
 ( 
 query_parameters 
 = 
 [ 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 None 
 , 
 "STRING" 
 , 
 "romeoandjuliet" 
 ), 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 None 
 , 
 "INT64" 
 , 
 250 
 ), 
 ] 
 ) 
 results 
 = 
 client 
 . 
  query_and_wait 
 
 ( 
 query 
 , 
 job_config 
 = 
 job_config 
 ) 
 # Make an API request. 
 for 
 row 
 in 
 results 
 : 
 print 
 ( 
 " 
 {} 
 : 
 \t 
 {} 
 " 
 . 
 format 
 ( 
 row 
 . 
 word 
 , 
 row 
 . 
 word_count 
 )) 
 

Using arrays in parameterized queries

To use an array type in a query parameter set the type to ARRAY<T> where T is the type of the elements in the array. Construct the value as a comma-separated list of elements enclosed in square brackets, such as [1, 2, 3] .

See the data types reference for more information about the array type .

Console

Parameterized queries are not supported by the Google Cloud console.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. This query selects the most popular names for baby boys born in US states starting with the letter W:

    bq  
    query  
     \ 
      
    --use_legacy_sql = 
     false 
      
     \ 
      
    --parameter = 
     'gender::M' 
      
     \ 
      
    --parameter = 
     'states:ARRAY<STRING>:["WA", "WI", "WV", "WY"]' 
      
     \ 
      
     'SELECT 
     name, 
     SUM(number) AS count 
     FROM 
     `bigquery-public-data.usa_names.usa_1910_2013` 
     WHERE 
     gender = @gender 
     AND state IN UNNEST(@states) 
     GROUP BY 
     name 
     ORDER BY 
     count DESC 
     LIMIT 
     10;' 
    

    Be careful to enclose the array type declaration in single quotes so that the command output is not accidentally redirected to a file by the > character.

API

To use an array-valued parameter set the parameterType to ARRAY in the query job configuration.

If the array values are scalars set the parameterType to the type of the values, such as STRING . If the array values are structures set this to STRUCT and add the needed field definitions to structTypes .

For example, this query selects the most popular names for baby boys born in US states starting with the letter W.

  { 
  
 "query" 
 : 
  
 "SELECT name, sum(number) as count\nFROM `bigquery-public-data.usa_names.usa_1910_2013`\nWHERE gender = @gender\nAND state IN UNNEST(@states)\nGROUP BY name\nORDER BY count DESC\nLIMIT 10;" 
 , 
  
 "queryParameters" 
 : 
  
 [ 
  
 { 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "STRING" 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "value" 
 : 
  
 "M" 
  
 }, 
  
 "name" 
 : 
  
 "gender" 
  
 }, 
  
 { 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "ARRAY" 
 , 
  
 "arrayType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "STRING" 
  
 } 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "arrayValues" 
 : 
  
 [ 
  
 { 
  
 "value" 
 : 
  
 "WA" 
  
 }, 
  
 { 
  
 "value" 
 : 
  
 "WI" 
  
 }, 
  
 { 
  
 "value" 
 : 
  
 "WV" 
  
 }, 
  
 { 
  
 "value" 
 : 
  
 "WY" 
  
 } 
  
 ] 
  
 }, 
  
 "name" 
 : 
  
 "states" 
  
 } 
  
 ], 
  
 "useLegacySql" 
 : 
  
 false 
 , 
  
 "parameterMode" 
 : 
  
 "NAMED" 
 } 
 

Try it in the Google APIs Explorer .

C#

Before trying this sample, follow the C# setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery C# API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  using 
  
  Google.Cloud.BigQuery.V2 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 BigQueryQueryWithArrayParameters 
 { 
  
 public 
  
 void 
  
 QueryWithArrayParameters 
 ( 
 string 
  
 projectId 
  
 = 
  
 "your-project-id" 
 ) 
  
 { 
  
 var 
  
 gender 
  
 = 
  
 "M" 
 ; 
  
 string 
 [] 
  
 states 
  
 = 
  
 { 
  
 "WA" 
 , 
  
 "WI" 
 , 
  
 "WV" 
 , 
  
 "WY" 
  
 }; 
  
 // Note: Standard SQL is required to use query parameters. 
  
 var 
  
 query 
  
 = 
  
 @" 
 SELECT name, sum(number) as count 
 FROM `bigquery-public-data.usa_names.usa_1910_2013` 
 WHERE gender = @gender 
 AND state IN UNNEST(@states) 
 GROUP BY name 
 ORDER BY count DESC 
 LIMIT 10;" 
 ; 
  
 // Initialize client that will be used to send requests. 
  
 var 
  
 client 
  
 = 
  
  BigQueryClient 
 
 . 
  Create 
 
 ( 
 projectId 
 ); 
  
 var 
  
 parameters 
  
 = 
  
 new 
  
  BigQueryParameter 
 
 [] 
  
 { 
  
 new 
  
  BigQueryParameter 
 
 ( 
 "gender" 
 , 
  
  BigQueryDbType 
 
 . 
  String 
 
 , 
  
 gender 
 ), 
  
 new 
  
  BigQueryParameter 
 
 ( 
 "states" 
 , 
  
  BigQueryDbType 
 
 . 
  Array 
 
 , 
  
 states 
 ) 
  
 }; 
  
 var 
  
 job 
  
 = 
  
 client 
 . 
 CreateQueryJob 
 ( 
  
 sql 
 : 
  
 query 
 , 
  
 parameters 
 : 
  
 parameters 
 , 
  
 options 
 : 
  
 new 
  
  QueryOptions 
 
  
 { 
  
 UseQueryCache 
  
 = 
  
 false 
  
 }); 
  
 // 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 
 "]}: {row[" 
 count 
 "]}" 
 ); 
  
 } 
  
 } 
 } 
 

Go

Before trying this sample, follow the Go setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Go API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "cloud.google.com/go/bigquery" 
  
 "google.golang.org/api/iterator" 
 ) 
 // queryWithArrayParams demonstrates issuing a query and specifying query parameters that include an 
 // array of strings. 
 func 
  
 queryWithArrayParams 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "my-project-id" 
  
 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 
 ( 
  
 `SELECT 
 name, 
 sum(number) as count 
 FROM ` 
  
 + 
  
 "`bigquery-public-data.usa_names.usa_1910_2013`" 
  
 + 
  
 ` 
 WHERE 
 gender = @gender 
 AND state IN UNNEST(@states) 
 GROUP BY 
 name 
 ORDER BY 
 count DESC 
 LIMIT 10;` 
 ) 
  
 q 
 . 
 Parameters 
  
 = 
  
 [] 
 bigquery 
 . 
  QueryParameter 
 
 { 
  
 { 
  
 Name 
 : 
  
 "gender" 
 , 
  
 Value 
 : 
  
 "M" 
 , 
  
 }, 
  
 { 
  
 Name 
 : 
  
 "states" 
 , 
  
 Value 
 : 
  
 [] 
 string 
 { 
 "WA" 
 , 
  
 "WI" 
 , 
  
 "WV" 
 , 
  
 "WY" 
 }, 
  
 }, 
  
 } 
  
 // 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 
 } 
 

Java

Before trying this sample, follow the Java setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Java API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  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. QueryParameterValue 
 
 ; 
 import 
  
 com.google.cloud.bigquery. TableResult 
 
 ; 
 // Sample to running a query with array query parameters. 
 public 
  
 class 
 QueryWithArrayParameters 
  
 { 
  
 public 
  
 static 
  
 void 
  
 runQueryWithArrayParameters 
 () 
  
 { 
  
 String 
  
 gender 
  
 = 
  
 "M" 
 ; 
  
 String 
 [] 
  
 states 
  
 = 
  
 { 
 "WA" 
 , 
  
 "WI" 
 , 
  
 "WV" 
 , 
  
 "WY" 
 }; 
  
 String 
  
 query 
  
 = 
  
 "SELECT name, sum(number) as count\n" 
  
 + 
  
 "FROM `bigquery-public-data.usa_names.usa_1910_2013`\n" 
  
 + 
  
 "WHERE gender = @gender\n" 
  
 + 
  
 "AND state IN UNNEST(@states)\n" 
  
 + 
  
 "GROUP BY name\n" 
  
 + 
  
 "ORDER BY count DESC\n" 
  
 + 
  
 "LIMIT 10;" 
 ; 
  
 queryWithArrayParameters 
 ( 
 query 
 , 
  
 gender 
 , 
  
 states 
 ); 
  
 } 
  
 public 
  
 static 
  
 void 
  
 queryWithArrayParameters 
 ( 
 String 
  
 query 
 , 
  
 String 
  
 gender 
 , 
  
 String 
 [] 
  
 states 
 ) 
  
 { 
  
 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 
 (); 
  
 // Note: Standard SQL is required to use query parameters. 
  
  QueryJobConfiguration 
 
  
 queryConfig 
  
 = 
  
  QueryJobConfiguration 
 
 . 
 newBuilder 
 ( 
 query 
 ) 
  
 . 
  addNamedParameter 
 
 ( 
 "gender" 
 , 
  
  QueryParameterValue 
 
 . 
  string 
 
 ( 
 gender 
 )) 
  
 . 
  addNamedParameter 
 
 ( 
 "states" 
 , 
  
  QueryParameterValue 
 
 . 
  array 
 
 ( 
 states 
 , 
  
 String 
 . 
 class 
 )) 
  
 . 
 build 
 (); 
  
  TableResult 
 
  
 results 
  
 = 
  
 bigquery 
 . 
  query 
 
 ( 
 queryConfig 
 ); 
  
 // Print the results. 
  
 results 
  
 . 
  iterateAll 
 
 () 
  
 . 
 forEach 
 ( 
 row 
  
 - 
>  
 row 
 . 
 forEach 
 ( 
 val 
  
 - 
>  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "%s," 
 , 
  
 val 
 . 
 toString 
 ()))); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query with arrays parameters performed successfully" 
 ); 
  
 } 
  
 catch 
  
 ( 
  BigQueryException 
 
  
 | 
  
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query not performed \n" 
  
 + 
  
 e 
 . 
 toString 
 ()); 
  
 } 
  
 } 
 } 
 

Node.js

Before trying this sample, follow the Node.js setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Node.js API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  // Run a query using array query parameters 
 // Import the Google Cloud client library 
 const 
  
 { 
 BigQuery 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/bigquery 
' 
 ); 
 const 
  
 bigquery 
  
 = 
  
 new 
  
  BigQuery 
 
 (); 
 async 
  
 function 
  
 queryParamsArrays 
 () 
  
 { 
  
 // The SQL query to run 
  
 const 
  
 sqlQuery 
  
 = 
  
 `SELECT name, sum(number) as count 
 FROM \`bigquery-public-data.usa_names.usa_1910_2013\` 
 WHERE gender = @gender 
 AND state IN UNNEST(@states) 
 GROUP BY name 
 ORDER BY count DESC 
 LIMIT 10;` 
 ; 
  
 const 
  
 options 
  
 = 
  
 { 
  
 query 
 : 
  
 sqlQuery 
 , 
  
 // Location must match that of the dataset(s) referenced in the query. 
  
 location 
 : 
  
 'US' 
 , 
  
 params 
 : 
  
 { 
 gender 
 : 
  
 'M' 
 , 
  
 states 
 : 
  
 [ 
 'WA' 
 , 
  
 'WI' 
 , 
  
 'WV' 
 , 
  
 'WY' 
 ]}, 
  
 }; 
  
 // Run the query 
  
 const 
  
 [ 
 rows 
 ] 
  
 = 
  
 await 
  
 bigquery 
 . 
 query 
 ( 
 options 
 ); 
  
 console 
 . 
 log 
 ( 
 'Rows:' 
 ); 
  
 rows 
 . 
 forEach 
 ( 
 row 
  
 = 
>  
 console 
 . 
 log 
 ( 
 row 
 )); 
 } 
 

Python

Before trying this sample, follow the Python setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Python API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  from 
  
 google.cloud 
  
 import 
  bigquery 
 
 # Construct a BigQuery client object. 
 client 
 = 
  bigquery 
 
 . 
  Client 
 
 () 
 query 
 = 
 """ 
 SELECT name, sum(number) as count 
 FROM `bigquery-public-data.usa_names.usa_1910_2013` 
 WHERE gender = @gender 
 AND state IN UNNEST(@states) 
 GROUP BY name 
 ORDER BY count DESC 
 LIMIT 10; 
 """ 
 job_config 
 = 
  bigquery 
 
 . 
  QueryJobConfig 
 
 ( 
 query_parameters 
 = 
 [ 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 "gender" 
 , 
 "STRING" 
 , 
 "M" 
 ), 
  bigquery 
 
 . 
  ArrayQueryParameter 
 
 ( 
 "states" 
 , 
 "STRING" 
 , 
 [ 
 "WA" 
 , 
 "WI" 
 , 
 "WV" 
 , 
 "WY" 
 ]), 
 ] 
 ) 
 rows 
 = 
 client 
 . 
  query_and_wait 
 
 ( 
 query 
 , 
 job_config 
 = 
 job_config 
 ) 
 # Make an API request. 
 for 
 row 
 in 
 rows 
 : 
 print 
 ( 
 " 
 {} 
 : 
 \t 
 {} 
 " 
 . 
 format 
 ( 
 row 
 . 
 name 
 , 
 row 
 . 
 count 
 )) 
 

Using timestamps in parameterized queries

To use a timestamp in a query parameter, the underlying REST API takes a value of type TIMESTAMP in the format YYYY-MM-DD HH:MM:SS.DDDDDD time_zone . If you are using the client libraries, you create a built-in date object in that language, and the library converts it to the right format. For more information, see the following language-specific examples.

For more information about the TIMESTAMP type, see the data types reference .

Console

Parameterized queries are not supported by the Google Cloud console.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. This query adds an hour to the timestamp parameter value:

    bq  
    query  
     \ 
      
    --use_legacy_sql = 
     false 
      
     \ 
      
    --parameter = 
     'ts_value:TIMESTAMP:2016-12-07 08:00:00' 
      
     \ 
      
     'SELECT 
     TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);' 
    

API

To use a timestamp parameter set the parameterType to TIMESTAMP in the query job configuration.

This query adds an hour to the timestamp parameter value.

  { 
  
 "query" 
 : 
  
 "SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);" 
 , 
  
 "queryParameters" 
 : 
  
 [ 
  
 { 
  
 "name" 
 : 
  
 "ts_value" 
 , 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "TIMESTAMP" 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "value" 
 : 
  
 "2016-12-07 08:00:00" 
  
 } 
  
 } 
  
 ], 
  
 "useLegacySql" 
 : 
  
 false 
 , 
  
 "parameterMode" 
 : 
  
 "NAMED" 
 } 
 

Try it in the Google APIs Explorer .

C#

Before trying this sample, follow the C# setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery C# API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  using 
  
  Google.Cloud.BigQuery.V2 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 BigQueryQueryWithTimestampParameters 
 { 
  
 public 
  
 void 
  
 QueryWithTimestampParameters 
 ( 
 string 
  
 projectId 
  
 = 
  
 "project-id" 
 ) 
  
 { 
  
 var 
  
 timestamp 
  
 = 
  
 new 
  
  DateTime 
 
 ( 
 2016 
 , 
  
 12 
 , 
  
 7 
 , 
  
 8 
 , 
  
 0 
 , 
  
 0 
 , 
  
 DateTimeKind 
 . 
 Utc 
 ); 
  
 // Note: Standard SQL is required to use query parameters. 
  
 var 
  
 query 
  
 = 
  
 "SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);" 
 ; 
  
 // Initialize client that will be used to send requests. 
  
 var 
  
 client 
  
 = 
  
  BigQueryClient 
 
 . 
  Create 
 
 ( 
 projectId 
 ); 
  
 var 
  
 parameters 
  
 = 
  
 new 
  
  BigQueryParameter 
 
 [] 
  
 { 
  
 new 
  
  BigQueryParameter 
 
 ( 
 "ts_value" 
 , 
  
  BigQueryDbType 
 
 . 
  Timestamp 
 
 , 
  
 timestamp 
 ), 
  
 }; 
  
 var 
  
 job 
  
 = 
  
 client 
 . 
 CreateQueryJob 
 ( 
  
 sql 
 : 
  
 query 
 , 
  
 parameters 
 : 
  
 parameters 
 , 
  
 options 
 : 
  
 new 
  
  QueryOptions 
 
  
 { 
  
 UseQueryCache 
  
 = 
  
 false 
  
 }); 
  
 // Wait for the job to complete. 
  
 job 
  
 = 
  
 job 
 . 
  PollUntilCompleted 
 
 (). 
 ThrowOnAnyError 
 (); 
  
 // Display the results 
  
 foreach 
  
 ( 
  BigQueryRow 
 
  
 row 
  
 in 
  
 client 
 . 
 GetQueryResults 
 ( 
 job 
 . 
 Reference 
 )) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 row 
 [ 
 0 
 ]); 
  
 } 
  
 } 
 } 
 

Go

Before trying this sample, follow the Go setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Go API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "time" 
  
 "cloud.google.com/go/bigquery" 
  
 "google.golang.org/api/iterator" 
 ) 
 // queryWithTimestampParam demonstrates issuing a query and supplying a timestamp query parameter. 
 func 
  
 queryWithTimestampParam 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "my-project-id" 
  
 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 
 ( 
  
 `SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);` 
 ) 
  
 q 
 . 
 Parameters 
  
 = 
  
 [] 
 bigquery 
 . 
  QueryParameter 
 
 { 
  
 { 
  
 Name 
 : 
  
 "ts_value" 
 , 
  
 Value 
 : 
  
 time 
 . 
 Date 
 ( 
 2016 
 , 
  
 12 
 , 
  
 7 
 , 
  
 8 
 , 
  
 0 
 , 
  
 0 
 , 
  
 0 
 , 
  
 time 
 . 
 UTC 
 ), 
  
 }, 
  
 } 
  
 // 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 
 } 
 

Java

Before trying this sample, follow the Java setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Java API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  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. QueryParameterValue 
 
 ; 
 import 
  
 com.google.cloud.bigquery. TableResult 
 
 ; 
 import 
  
 org.threeten.bp.LocalDateTime 
 ; 
 import 
  
 org.threeten.bp.ZoneOffset 
 ; 
 import 
  
 org.threeten.bp.ZonedDateTime 
 ; 
 // Sample to running a query with timestamp query parameters. 
 public 
  
 class 
 QueryWithTimestampParameters 
  
 { 
  
 public 
  
 static 
  
 void 
  
 runQueryWithTimestampParameters 
 () 
  
 { 
  
 queryWithTimestampParameters 
 (); 
  
 } 
  
 public 
  
 static 
  
 void 
  
 queryWithTimestampParameters 
 () 
  
 { 
  
 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 
 (); 
  
 ZonedDateTime 
  
 timestamp 
  
 = 
  
 LocalDateTime 
 . 
 of 
 ( 
 2016 
 , 
  
 12 
 , 
  
 7 
 , 
  
 8 
 , 
  
 0 
 , 
  
 0 
 ). 
 atZone 
 ( 
 ZoneOffset 
 . 
 UTC 
 ); 
  
 String 
  
 query 
  
 = 
  
 "SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);" 
 ; 
  
 // Note: Standard SQL is required to use query parameters. 
  
  QueryJobConfiguration 
 
  
 queryConfig 
  
 = 
  
  QueryJobConfiguration 
 
 . 
 newBuilder 
 ( 
 query 
 ) 
  
 . 
  addNamedParameter 
 
 ( 
  
 "ts_value" 
 , 
  
  QueryParameterValue 
 
 . 
  timestamp 
 
 ( 
  
 // Timestamp takes microseconds since 1970-01-01T00:00:00 UTC 
  
  timestamp 
 
 . 
 toInstant 
 (). 
 toEpochMilli 
 () 
  
 * 
  
 1000 
 )) 
  
 . 
 build 
 (); 
  
  TableResult 
 
  
 results 
  
 = 
  
 bigquery 
 . 
  query 
 
 ( 
 queryConfig 
 ); 
  
 results 
  
 . 
  iterateAll 
 
 () 
  
 . 
 forEach 
 ( 
 row 
  
 - 
>  
 row 
 . 
 forEach 
 ( 
 val 
  
 - 
>  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "%s" 
 , 
  
 val 
 . 
 toString 
 ()))); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query with timestamp parameter performed successfully." 
 ); 
  
 } 
  
 catch 
  
 ( 
  BigQueryException 
 
  
 | 
  
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query not performed \n" 
  
 + 
  
 e 
 . 
 toString 
 ()); 
  
 } 
  
 } 
 } 
 

Node.js

Before trying this sample, follow the Node.js setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Node.js API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  // Run a query using timestamp parameters 
 // Import the Google Cloud client library 
 const 
  
 { 
 BigQuery 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/bigquery 
' 
 ); 
 const 
  
 bigquery 
  
 = 
  
 new 
  
  BigQuery 
 
 (); 
 async 
  
 function 
  
 queryParamsTimestamps 
 () 
  
 { 
  
 // The SQL query to run 
  
 const 
  
 sqlQuery 
  
 = 
  
 `SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);` 
 ; 
  
 const 
  
 options 
  
 = 
  
 { 
  
 query 
 : 
  
 sqlQuery 
 , 
  
 // Location must match that of the dataset(s) referenced in the query. 
  
 location 
 : 
  
 'US' 
 , 
  
 params 
 : 
  
 { 
 ts_value 
 : 
  
 new 
  
 Date 
 ()}, 
  
 }; 
  
 // Run the query 
  
 const 
  
 [ 
 rows 
 ] 
  
 = 
  
 await 
  
 bigquery 
 . 
 query 
 ( 
 options 
 ); 
  
 console 
 . 
 log 
 ( 
 'Rows:' 
 ); 
  
 rows 
 . 
 forEach 
 ( 
 row 
  
 = 
>  
 console 
 . 
 log 
 ( 
 row 
 . 
 f0_ 
 )); 
 } 
 

Python

Before trying this sample, follow the Python setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Python API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  import 
  
 datetime 
 from 
  
 google.cloud 
  
 import 
  bigquery 
 
 # Construct a BigQuery client object. 
 client 
 = 
  bigquery 
 
 . 
  Client 
 
 () 
 query 
 = 
 "SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);" 
 job_config 
 = 
  bigquery 
 
 . 
  QueryJobConfig 
 
 ( 
 query_parameters 
 = 
 [ 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 "ts_value" 
 , 
 "TIMESTAMP" 
 , 
 datetime 
 . 
 datetime 
 ( 
 2016 
 , 
 12 
 , 
 7 
 , 
 8 
 , 
 0 
 , 
 tzinfo 
 = 
 datetime 
 . 
 timezone 
 . 
 utc 
 ), 
 ) 
 ] 
 ) 
 results 
 = 
 client 
 . 
  query_and_wait 
 
 ( 
 query 
 , 
 job_config 
 = 
 job_config 
 ) 
 # Make an API request. 
 for 
 row 
 in 
 results 
 : 
 print 
 ( 
 row 
 ) 
 

Using structs in parameterized queries

To use a struct in a query parameter set the type to STRUCT<T> where T defines the fields and types within the struct. Field definitions are separated by commas and are of the form field_name TF where TF is the type of the field. For example, STRUCT<x INT64, y STRING> defines a struct with a field named x of type INT64 and a second field named y of type STRING .

For more information about the STRUCT type, see the data types reference .

Console

Parameterized queries are not supported by the Google Cloud console.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. This trivial query demonstrates the use of structured types by returning the parameter value:

    bq  
    query  
     \ 
      
    --use_legacy_sql = 
     false 
      
     \ 
      
    --parameter = 
     'struct_value:STRUCT<x INT64, y STRING>:{"x": 1, "y": "foo"}' 
      
     \ 
      
     'SELECT 
     @struct_value AS s;' 
    

API

To use a struct parameter set the parameterType to STRUCT in the query job configuration.

Add an object for each field of the struct to structTypes in the job's queryParameters . If the struct values are scalars set the type to the type of the values, such as STRING . If the struct values are arrays set this to ARRAY , and set the nested arrayType field to the appropriate type. If the struct values are structures set type to STRUCT and add the needed structTypes .

This trivial query demonstrates the use of structured types by returning the parameter value.

  { 
  
 "query" 
 : 
  
 "SELECT @struct_value AS s;" 
 , 
  
 "queryParameters" 
 : 
  
 [ 
  
 { 
  
 "name" 
 : 
  
 "struct_value" 
 , 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "STRUCT" 
 , 
  
 "structTypes" 
 : 
  
 [ 
  
 { 
  
 "name" 
 : 
  
 "x" 
 , 
  
 "type" 
 : 
  
 { 
  
 "type" 
 : 
  
 "INT64" 
  
 } 
  
 }, 
  
 { 
  
 "name" 
 : 
  
 "y" 
 , 
  
 "type" 
 : 
  
 { 
  
 "type" 
 : 
  
 "STRING" 
  
 } 
  
 } 
  
 ] 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "structValues" 
 : 
  
 { 
  
 "x" 
 : 
  
 { 
  
 "value" 
 : 
  
 "1" 
  
 }, 
  
 "y" 
 : 
  
 { 
  
 "value" 
 : 
  
 "foo" 
  
 } 
  
 } 
  
 } 
  
 } 
  
 ], 
  
 "useLegacySql" 
 : 
  
 false 
 , 
  
 "parameterMode" 
 : 
  
 "NAMED" 
 } 
 

Try it in the Google APIs Explorer .

C#

The BigQuery client library for .NET does not support struct parameters .

Go

Before trying this sample, follow the Go setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Go API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "cloud.google.com/go/bigquery" 
  
 "google.golang.org/api/iterator" 
 ) 
 // queryWithStructParam demonstrates running a query and providing query parameters that include struct 
 // types. 
 func 
  
 queryWithStructParam 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "my-project-id" 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 bigquery 
 . 
 NewClient 
 ( 
 ctx 
 , 
  
 projectID 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "bigquery.NewClient: %v" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
 Close 
 () 
  
 type 
  
 MyStruct 
  
 struct 
  
 { 
  
 X 
  
 int64 
  
 Y 
  
 string 
  
 } 
  
 q 
  
 := 
  
 client 
 . 
 Query 
 ( 
  
 `SELECT @struct_value as s;` 
 ) 
  
 q 
 . 
 Parameters 
  
 = 
  
 [] 
 bigquery 
 . 
  QueryParameter 
 
 { 
  
 { 
  
 Name 
 : 
  
 "struct_value" 
 , 
  
 Value 
 : 
  
 MyStruct 
 { 
 X 
 : 
  
 1 
 , 
  
 Y 
 : 
  
 "foo" 
 }, 
  
 }, 
  
 } 
  
 // 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 
 } 
 

Java

Before trying this sample, follow the Java setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Java API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  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. QueryParameterValue 
 
 ; 
 import 
  
 com.google.cloud.bigquery. TableResult 
 
 ; 
 import 
  
 java.util.HashMap 
 ; 
 import 
  
 java.util.Map 
 ; 
 public 
  
 class 
 QueryWithStructsParameters 
  
 { 
  
 public 
  
 static 
  
 void 
  
 queryWithStructsParameters 
 () 
  
 { 
  
 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 
 (); 
  
 // Create struct 
  
 Map<String 
 , 
  
 QueryParameterValue 
>  
 struct 
  
 = 
  
 new 
  
 HashMap 
<> (); 
  
  struct 
 
 . 
 put 
 ( 
 "booleanField" 
 , 
  
  QueryParameterValue 
 
 . 
  bool 
 
 ( 
 true 
 )); 
  
  struct 
 
 . 
 put 
 ( 
 "integerField" 
 , 
  
  QueryParameterValue 
 
 . 
  string 
 
 ( 
 "test-stringField" 
 )); 
  
  struct 
 
 . 
 put 
 ( 
 "stringField" 
 , 
  
  QueryParameterValue 
 
 . 
  int64 
 
 ( 
 10 
 )); 
  
  QueryParameterValue 
 
  
 recordValue 
  
 = 
  
  QueryParameterValue 
 
 . 
  struct 
 
 ( 
 struct 
 ); 
  
 String 
  
 query 
  
 = 
  
 "SELECT STRUCT(@recordField) AS record" 
 ; 
  
  QueryJobConfiguration 
 
  
 queryConfig 
  
 = 
  
  QueryJobConfiguration 
 
 . 
 newBuilder 
 ( 
 query 
 ) 
  
 . 
 setUseLegacySql 
 ( 
 false 
 ) 
  
 . 
  addNamedParameter 
 
 ( 
 "recordField" 
 , 
  
 recordValue 
 ) 
  
 . 
 build 
 (); 
  
  TableResult 
 
  
 results 
  
 = 
  
 bigquery 
 . 
  query 
 
 ( 
 queryConfig 
 ); 
  
 results 
  
 . 
  iterateAll 
 
 () 
  
 . 
 forEach 
 ( 
 row 
  
 - 
>  
 row 
 . 
 forEach 
 ( 
 val 
  
 - 
>  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "%s" 
 , 
  
 val 
 . 
 toString 
 ()))); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query with struct parameter performed successfully." 
 ); 
  
 } 
  
 catch 
  
 ( 
  BigQueryException 
 
  
 | 
  
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Query not performed \n" 
  
 + 
  
 e 
 . 
 toString 
 ()); 
  
 } 
  
 } 
 } 
 

Node.js

Before trying this sample, follow the Node.js setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Node.js API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  // Run a query using struct query parameters 
 // Import the Google Cloud client library 
 const 
  
 { 
 BigQuery 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/bigquery 
' 
 ); 
 const 
  
 bigquery 
  
 = 
  
 new 
  
  BigQuery 
 
 (); 
 async 
  
 function 
  
 queryParamsStructs 
 () 
  
 { 
  
 // The SQL query to run 
  
 const 
  
 sqlQuery 
  
 = 
  
 `SELECT @struct_value AS struct_obj;` 
 ; 
  
 const 
  
 options 
  
 = 
  
 { 
  
 query 
 : 
  
 sqlQuery 
 , 
  
 // Location must match that of the dataset(s) referenced in the query. 
  
 location 
 : 
  
 'US' 
 , 
  
 params 
 : 
  
 { 
 struct_value 
 : 
  
 { 
 x 
 : 
  
 1 
 , 
  
 y 
 : 
  
 'foo' 
 }}, 
  
 }; 
  
 // Run the query 
  
 const 
  
 [ 
 rows 
 ] 
  
 = 
  
 await 
  
 bigquery 
 . 
 query 
 ( 
 options 
 ); 
  
 console 
 . 
 log 
 ( 
 'Rows:' 
 ); 
  
 rows 
 . 
 forEach 
 ( 
 row 
  
 = 
>  
 console 
 . 
 log 
 ( 
 row 
 . 
 struct_obj 
 . 
 y 
 )); 
 } 
 

Python

Before trying this sample, follow the Python setup instructions in the BigQuery quickstart using client libraries . For more information, see the BigQuery Python API reference documentation .

To authenticate to BigQuery, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

  from 
  
 google.cloud 
  
 import 
  bigquery 
 
 # Construct a BigQuery client object. 
 client 
 = 
  bigquery 
 
 . 
  Client 
 
 () 
 query 
 = 
 "SELECT @struct_value AS s;" 
 job_config 
 = 
  bigquery 
 
 . 
  QueryJobConfig 
 
 ( 
 query_parameters 
 = 
 [ 
  bigquery 
 
 . 
  StructQueryParameter 
 
 ( 
 "struct_value" 
 , 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 "x" 
 , 
 "INT64" 
 , 
 1 
 ), 
  bigquery 
 
 . 
  ScalarQueryParameter 
 
 ( 
 "y" 
 , 
 "STRING" 
 , 
 "foo" 
 ), 
 ) 
 ] 
 ) 
 results 
 = 
 client 
 . 
  query_and_wait 
 
 ( 
 query 
 , 
 job_config 
 = 
 job_config 
 ) 
 # Make an API request and waits for results. 
 for 
 row 
 in 
 results 
 : 
 print 
 ( 
 row 
 . 
 s 
 ) 
 
Design a Mobile Site
View Site in Mobile | Classic
Share by: