Query with BOOL parameter

voidQueryWithBoolParameter(google::cloud::spanner::Clientclient){
namespacespanner=::google::cloud::spanner;
boolexample_bool=true;
spanner::SqlStatementselect(
"SELECT VenueId, VenueName, OutdoorVenue FROM Venues"
" WHERE OutdoorVenue = @outdoor_venue",
{{"outdoor_venue", spanner::Value(example_bool)}});
usingRowType=std::tuple<std::int64_t,absl::optional<std::string>,
absl::optional<bool>>;
autorows=client.ExecuteQuery(std::move(select));
for(auto&row:spanner::StreamOf<RowType>(rows)){
if(!row)throwstd::move(row).status();
std::cout << "VenueId: " << std::get<0>(*row) << "\t";
std::cout << "VenueName: " << std::get<1>(*row).value() << "\t";
std::cout << "OutdoorVenue: " << std::get<2>(*row).value() << "\n";
}
std::cout << "Query completed for [spanner_query_with_bool_parameter]\n";
}

usingGoogle.Cloud.Spanner.Data ;
usingSystem.Collections.Generic;
usingSystem.Threading.Tasks;
publicclassQueryWithBoolAsyncSample
{
publicclassVenue
{
publicintVenueId{get;set;}
publicstringVenueName{get;set;}
publicboolOutdoorVenue{get;set;}
}
publicasyncTask<List<Venue>>QueryWithBoolAsync(stringprojectId,stringinstanceId,stringdatabaseId)
{
stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
boolexampleBool=true;
usingvarconnection=newSpannerConnection (connectionString);
varcmd=connection.CreateSelectCommand (
"SELECT VenueId, VenueName, OutdoorVenue FROM Venues "
+"WHERE OutdoorVenue = @ExampleBool");
cmd.Parameters .Add("ExampleBool",SpannerDbType .Bool ,exampleBool);
varvenues=newList<Venue>();
usingvarreader=awaitcmd.ExecuteReaderAsync ();
while(awaitreader.ReadAsync ())
{
venues.Add(newVenue
{
VenueId=reader.GetFieldValue<int>("VenueId"),
VenueName=reader.GetFieldValue<string>("VenueName"),
OutdoorVenue=reader.GetFieldValue<bool>("OutdoorVenue")
});
}
returnvenues;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/spanner"
"google.golang.org/api/iterator"
)
funcqueryWithBool(wio.Writer,dbstring)error{
ctx:=context.Background()
client,err:=spanner.NewClient(ctx,db)
iferr!=nil{
returnerr
}
deferclient.Close()
varexampleBool=true
stmt:=spanner.Statement {
SQL:`SELECT VenueId, VenueName, OutdoorVenue FROM Venues
 	WHERE OutdoorVenue = @outdoorVenue`,
Params:map[string]interface{}{
"outdoorVenue":exampleBool,
},
}
iter:=client.Single ().Query(ctx,stmt)
deferiter.Stop()
for{
row,err:=iter.Next()
iferr==iterator.Done{
returnnil
}
iferr!=nil{
returnerr
}
varvenueIDint64
varvenueNamestring
varoutdoorVenuebool
iferr:=row.Columns (&venueID,&venueName,&outdoorVenue);err!=nil{
returnerr
}
fmt.Fprintf(w,"%d %s %t\n",venueID,venueName,outdoorVenue)
}
}

staticvoidqueryWithBool(DatabaseClientdbClient){
booleanexampleBool=true;
Statementstatement=
Statement.newBuilder(
"SELECT VenueId, VenueName, OutdoorVenue FROM Venues "
+"WHERE OutdoorVenue = @outdoorVenue")
.bind("outdoorVenue")
.to(exampleBool)
.build();
try(ResultSetresultSet=dbClient.singleUse().executeQuery(statement)){
while(resultSet.next()){
System.out.printf(
"%d %s %b\n",
resultSet.getLong("VenueId"),
resultSet.getString("VenueName"),
resultSet.getBoolean("OutdoorVenue"));
}
}
}

// Imports the Google Cloud client library.
const{Spanner}=require('@google-cloud/spanner');
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
// Gets a reference to a Cloud Spanner instance and database.
constinstance=spanner.instance(instanceId);
constdatabase=instance.database(databaseId);
constfieldType={
type:'bool',
};
constexampleBool=true;
constquery={
sql:`SELECT VenueId, VenueName, OutdoorVenue FROM Venues
 WHERE OutdoorVenue = @outdoorVenue`,
params:{
outdoorVenue:exampleBool,
},
types:{
outdoorVenue:fieldType,
},
};
// Queries rows from the Venues table.
try{
const[rows]=awaitdatabase.run(query);
rows.forEach(row=>{
constjson=row.toJSON();
console.log(
`VenueId: ${json.VenueId}, VenueName: ${json.VenueName},`+
` OutdoorVenue: ${json.OutdoorVenue}`,
);
});
}catch(err){
console.error('ERROR:',err);
}finally{
// Close the database when finished.
database.close();
}

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\Database;
/**
 * Queries sample data from the database using SQL with a BOOL parameter.
 * Example:
 * ```
 * query_data_with_bool_parameter($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function query_data_with_bool_parameter(string $instanceId, string $databaseId): void
{
 $spanner = new SpannerClient();
 $instance = $spanner->instance($instanceId);
 $database = $instance->database($databaseId);
 $exampleBool = true;
 $results = $database->execute(
 'SELECT VenueId, VenueName, OutdoorVenue FROM Venues ' .
 'WHERE OutdoorVenue = @outdoorVenue',
 [
 'parameters' => [
 'outdoorVenue' => $exampleBool
 ]
 ]
 );
 foreach ($results as $row) {
 printf('VenueId: %s, VenueName: %s, OutdoorVenue: %s' . PHP_EOL,
 $row['VenueId'], $row['VenueName'],
 $row['OutdoorVenue'] ? 'True' : 'False');
 }
}

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
exampleBool = True
param = {"outdoor_venue": exampleBool}
param_type = {"outdoor_venue": param_types.BOOL}
with database.snapshot() as snapshot:
 results = snapshot.execute_sql(
 "SELECT VenueId, VenueName, OutdoorVenue FROM Venues "
 "WHERE OutdoorVenue = @outdoor_venue",
 params=param,
 param_types=param_type,
 )
 for row in results:
 print("VenueId: {}, VenueName: {}, OutdoorVenue: {}".format(*row))

# project_id = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"
require"google/cloud/spanner"
spanner=Google::Cloud::Spanner .newproject:project_id
client=spanner.client instance_id,database_id
sql_query="SELECT VenueId, VenueName, OutdoorVenue FROM Venues
 WHERE OutdoorVenue = @outdoor_venue"
params={outdoor_venue:true}
param_types={outdoor_venue::BOOL}
client.execute(sql_query,params:params,types:param_types).rows.each do|row|
puts"#{row[:VenueId]}#{row[:VenueName]}#{row[:OutdoorVenue]}"
end