Run parameterized queries

When querying BigQuery data using GoogleSQL syntax, you can use parameters to protect queries made from user input against SQL injection . The parameters substitute arbitrary expressions in your GoogleSQL queries.

You pass query parameters for various data types, including the following:

  • Arrays
  • Timestamps
  • Structs
  • Ranges

Pass a parameter in a query

Query parameters are only supported in GoogleSQL syntax . 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. A query can use positional or named parameters, but not both.

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

  • The BigQuery Studio query editor in the Google Cloud console
  • The bq command-line tool's bq query command
  • The API
  • The client libraries

The following examples show how to pass parameter values to a parameterized query:

Console

To run a parameterized query in the Google Cloud console, configure parameters in Query settings, and then reference them in your SQL query by prefixing each parameter name with the @ character.

Supported data types:the Google Cloud console only supports parameterized queries of primitive data types, such as BIGNUMERIC , BOOL , BYTES , DATE , DATETIME , FLOAT64 , GEOGRAPHY , INT64 , INTERVAL , NUMERIC , STRING , TIME , or TIMESTAMP . Complex data types, such as ARRAY and STRUCT , aren't supported in the Google Cloud console.

Add the parameters in the Google Cloud console

  1. Go to the BigQuerypage.

    Go to BigQuery

  2. In the query editor toolbar, click Moreand select Query settings.

  3. In the Query settingspane, locate the Query parameterssection and click Add parameter.

  4. For each parameter in your query, provide the following:

    • Name: Enter the parameter name (don't include the @ character).
    • Type: Select the data type for the parameter.
    • Value: Enter the value you want to use for this execution.
  5. Click Save.

Pass parameter values to a query in the Google Cloud console

  1. In the query editor, enter a SQL query using the parameters you configured in the previous step. Reference them by prefixing their names with the @ character, as shown in the example.

    Example:

      SELECT 
      
     word 
     , 
      
     word_count 
      
     FROM 
      
     ` 
     bigquery 
     - 
     public 
     - 
     data 
     . 
     samples 
     . 
     shakespeare 
     ` 
      
     WHERE 
      
     corpus 
      
     = 
      
     @ 
     corpus 
      
     AND 
      
     word_count 
      
    > = 
      
     @ 
     min_word_count 
      
     ORDER 
      
     BY 
      
     word_count 
      
     DESC 
     ; 
     
    

    For this example, you would add the corpus parameter as a STRING with value romeoandjuliet , and the min_word_count parameter as an INT64 with value 250 .

    If the query contains a missing or invalid parameter, an error message is displayed. Click Set parameterin the error message to adjust the parameter settings.

  2. To run the parameterized query in the query editor, click Run.

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

Use 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

Arrays in parameterized queries aren't 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 
 )) 
 

Use 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

Follow the steps for adding parameters in the Google Cloud console described earlier in this document. Select TIMESTAMP for the parameter type and enter the timestamp value in the format YYYY-MM-DD HH:MM:SS.DDDDDD time_zone .

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 
 ) 
 

Use 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

Structs in parameterized queries aren't 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 
 ) 
 

Use ranges in parameterized queries

To use a range in a query parameter, set the type field to RANGE .

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

Console

Ranges in parameterized queries aren't 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 demonstrates the use of range types by returning the parameter value:

    bq  
    query  
     \ 
      
    --use_legacy_sql = 
     false 
      
     \ 
      
    --parameter = 
     'my_param:RANGE<DATE>:[2020-01-01, 2020-12-31)' 
      
     \ 
      
     'SELECT @my_param AS foo;' 
    

API

To use a range parameter, in the parameterType set the type field to RANGE and set the rangeElementType field to the type of range you want to use.

This query shows how to use the RANGE parameter type by returning the parameter value.

  { 
  
 "query" 
 : 
  
 "SELECT @my_param AS value_of_range_parameter;" 
 , 
  
 "queryParameters" 
 : 
  
 [ 
  
 { 
  
 "name" 
 : 
  
 "range_param" 
 , 
  
 "parameterType" 
 : 
  
 { 
  
 "type" 
 : 
  
 "RANGE" 
 , 
  
 "rangeElementTYpe" 
 : 
  
 { 
  
 "type" 
 : 
  
 "DATE" 
  
 } 
  
 }, 
  
 "parameterValue" 
 : 
  
 { 
  
 "rangeValue" 
 : 
  
 { 
  
 "start" 
 : 
  
 { 
  
 "value" 
 : 
  
 "2020-01-01" 
  
 }, 
  
 "end" 
 : 
  
 { 
  
 "value" 
 : 
  
 "2020-12-31" 
  
 } 
  
 } 
  
 } 
  
 } 
  
 ], 
  
 "useLegacySql" 
 : 
  
 false 
 , 
  
 "parameterMode" 
 : 
  
 "NAMED" 
 } 
 
Create a Mobile Website
View Site in Mobile | Classic
Share by: