Manage logical views

import(
"context"
"fmt"
"cloud.google.com/go/bigquery"
)
// updateView demonstrates updating the query metadata that defines a logical view.
funcupdateView(projectID,datasetID,viewIDstring)error{
// projectID := "my-project-id"
// datasetID := "mydataset"
// viewID := "myview"
ctx:=context.Background()
client,err:=bigquery.NewClient(ctx,projectID)
iferr!=nil{
returnfmt.Errorf("bigquery.NewClient: %v",err)
}
deferclient.Close()
view:=client.Dataset(datasetID).Table(viewID)
meta,err:=view.Metadata(ctx)
iferr!=nil{
returnerr
}
newMeta:=bigquery.TableMetadataToUpdate {
// This example updates a view into the shakespeare dataset to exclude works named after kings.
ViewQuery:"SELECT word, word_count, corpus, corpus_date FROM `bigquery-public-data.samples.shakespeare` WHERE corpus NOT LIKE '%king%'",
}
if_,err:=view.Update(ctx,newMeta,meta.ETag);err!=nil{
returnerr
}
returnnil
}

importcom.google.cloud.bigquery.BigQuery ;
importcom.google.cloud.bigquery.BigQueryException ;
importcom.google.cloud.bigquery.BigQueryOptions ;
importcom.google.cloud.bigquery.TableId ;
importcom.google.cloud.bigquery.TableInfo ;
importcom.google.cloud.bigquery.ViewDefinition ;
// Sample to update query on a view
publicclass UpdateViewQuery{
publicstaticvoidrunUpdateViewQuery(){
// TODO(developer): Replace these variables before running the sample.
StringdatasetName="MY_DATASET_NAME";
StringtableName="MY_TABLE_NAME";
StringviewName="MY_VIEW_NAME";
StringupdateQuery=
String.format("SELECT TimestampField, StringField FROM %s.%s",datasetName,tableName);
updateViewQuery(datasetName,viewName,updateQuery);
}
publicstaticvoidupdateViewQuery(StringdatasetName,StringviewName,Stringquery){
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();
// Retrieve existing view metadata
TableInfo viewMetadata=bigquery.getTable (TableId.of(datasetName,viewName));
// Update view query
ViewDefinition viewDefinition=viewMetadata.getDefinition ();
viewDefinition.toBuilder ().setQuery(query).build();
// Set metadata
bigquery.update (viewMetadata.toBuilder().setDefinition(viewDefinition).build());
System.out.println("View query updated successfully");
}catch(BigQueryException e){
System.out.println("View query was not updated. \n"+e.toString());
}
}
}

// Import the Google Cloud client library and create a client
const{BigQuery}=require('@google-cloud/bigquery');
constbigquery=newBigQuery ();
asyncfunctionupdateViewQuery(){
// Updates a view named "my_existing_view" in "my_dataset".
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = "my_existing_dataset"
// const tableId = "my_existing_table"
constdataset=awaitbigquery.dataset(datasetId);
// This example updates a view into the USA names dataset to include state.
constnewViewQuery=`SELECT name, state 
 FROM \`bigquery-public-data.usa_names.usa_1910_current\`
 LIMIT 10`;
// Retrieve existing view
const[view]=awaitdataset.table(tableId).get();
// Retrieve existing view metadata
const[metadata]=awaitview.getMetadata();
// Update view query
metadata.view=newViewQuery;
// Set metadata
awaitview.setMetadata(metadata);
console.log(`View ${tableId} updated.`);
}

fromgoogle.cloudimport bigquery
client = bigquery .Client ()
view_id = "my-project.my_dataset.my_view"
source_id = "my-project.my_dataset.my_table"
view = bigquery .Table (view_id)
# The source table in this example is created from a CSV file in Google
# Cloud Storage located at
# `gs://cloud-samples-data/bigquery/us-states/us-states.csv`. It contains
# 50 US states, while the view returns only those states with names
# starting with the letter 'M'.
view .view_query = f"SELECT name, post_abbr FROM `{source_id}` WHERE name LIKE 'M%'"
# Make an API request to update the query property of the view.
view = client.update_table (view, ["view_query"])
print(f"Updated {view .table_type}: {str(view .reference)}")

import(
"context"
"fmt"
"time"
"cloud.google.com/go/bigquery"
)
// updateTableExpiration demonstrates setting the table expiration of a table to a specific point in time
// in the future, at which time it will be deleted.
funcupdateTableExpiration(projectID,datasetID,tableIDstring)error{
// projectID := "my-project-id"
// datasetID := "mydataset"
// tableID := "mytable"
ctx:=context.Background()
client,err:=bigquery.NewClient(ctx,projectID)
iferr!=nil{
returnfmt.Errorf("bigquery.NewClient: %v",err)
}
deferclient.Close()
tableRef:=client.Dataset(datasetID).Table(tableID)
meta,err:=tableRef.Metadata(ctx)
iferr!=nil{
returnerr
}
update:=bigquery.TableMetadataToUpdate {
ExpirationTime:time.Now().Add(time.Duration(5*24)*time.Hour),// table expiration in 5 days.
}
if_,err=tableRef.Update(ctx,update,meta.ETag);err!=nil{
returnerr
}
returnnil
}

TablebeforeTable=bigquery.getTable(datasetName,tableName);
// Set table to expire 5 days from now.
longexpirationMillis=DateTime.now().plusDays(5).getMillis();
TableInfotableInfo=beforeTable.toBuilder()
.setExpirationTime(expirationMillis)
.build();
TableafterTable=bigquery.update(tableInfo);

// Import the Google Cloud client library
const{BigQuery}=require('@google-cloud/bigquery');
constbigquery=newBigQuery ();
asyncfunctionupdateTableExpiration(){
// Updates a table's expiration.
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = 'my_dataset', // Existing dataset
// const tableId = 'my_table', // Existing table
// const expirationTime = Date.now() + 1000 * 60 * 60 * 24 * 5 // 5 days from current time in ms
// Retreive current table metadata
consttable=bigquery.dataset(datasetId).table(tableId);
const[metadata]=awaittable.getMetadata();
// Set new table expiration to 5 days from current time
metadata.expirationTime=expirationTime.toString();
const[apiResponse]=awaittable.setMetadata(metadata);
constnewExpirationTime=apiResponse.expirationTime;
console.log(`${tableId} expiration: ${newExpirationTime}`);
}

fromgoogle.cloudimport bigquery
client = bigquery .Client ()
# TODO(dev): Change table_id to the full name of the table you want to update.
table_id = "your-project.your_dataset.your_table_name"
# TODO(dev): Set table to expire for desired days days from now.
expiration = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(
 days=5
)
table = client.get_table (table_id) # Make an API request.
table.expires = expiration
table = client.update_table (table, ["expires"]) # API request
print(f"Updated {table_id}, expires {table.expires}.")

import(
"context"
"fmt"
"cloud.google.com/go/bigquery"
)
// updateTableDescription demonstrates how to fetch a table's metadata and updates the Description metadata.
funcupdateTableDescription(projectID,datasetID,tableIDstring)error{
// projectID := "my-project-id"
// datasetID := "mydataset"
// tableID := "mytable"
ctx:=context.Background()
client,err:=bigquery.NewClient(ctx,projectID)
iferr!=nil{
returnfmt.Errorf("bigquery.NewClient: %v",err)
}
deferclient.Close()
tableRef:=client.Dataset(datasetID).Table(tableID)
meta,err:=tableRef.Metadata(ctx)
iferr!=nil{
returnerr
}
update:=bigquery.TableMetadataToUpdate {
Description:"Updated description.",
}
if_,err=tableRef.Update(ctx,update,meta.ETag);err!=nil{
returnerr
}
returnnil
}

// String datasetName = "my_dataset_name";
// String tableName = "my_table_name";
// String newDescription = "new_description";
TablebeforeTable=bigquery.getTable(datasetName,tableName);
TableInfotableInfo=beforeTable.toBuilder()
.setDescription(newDescription)
.build();
TableafterTable=bigquery.update(tableInfo);

// Import the Google Cloud client library
const{BigQuery}=require('@google-cloud/bigquery');
constbigquery=newBigQuery ();
asyncfunctionupdateTableDescription(){
// Updates a table's description.
// Retreive current table metadata
consttable=bigquery.dataset(datasetId).table(tableId);
const[metadata]=awaittable.getMetadata();
// Set new table description
constdescription='New table description.';
metadata.description=description;
const[apiResponse]=awaittable.setMetadata(metadata);
constnewDescription=apiResponse.description;
console.log(`${tableId} description: ${newDescription}`);
}

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, dataset_id)
# table_ref = dataset_ref.table('my_table')
# table = client.get_table(table_ref) # API request
assert table.description == "Original description."
table.description = "Updated description."
table = client.update_table(table, ["description"]) # API request
assert table.description == "Updated description."

usingGoogle.Cloud.BigQuery.V2 ;
usingSystem;
publicclassBigQueryDeleteTable
{
publicvoidDeleteTable(
stringprojectId="your-project-id",
stringdatasetId="your_dataset_id",
stringtableId="your_table_id"
)
{
BigQueryClient client=BigQueryClient .Create (projectId);
client.DeleteTable (datasetId,tableId);
Console.WriteLine($"Table {tableId} deleted.");
}
}

import(
"context"
"fmt"
"cloud.google.com/go/bigquery"
)
// deleteTable demonstrates deletion of a BigQuery table.
funcdeleteTable(projectID,datasetID,tableIDstring)error{
// projectID := "my-project-id"
// datasetID := "mydataset"
// tableID := "mytable"
ctx:=context.Background()
client,err:=bigquery.NewClient(ctx,projectID)
iferr!=nil{
returnfmt.Errorf("bigquery.NewClient: %v",err)
}
deferclient.Close()
table:=client.Dataset(datasetID).Table(tableID)
iferr:=table.Delete(ctx);err!=nil{
returnerr
}
returnnil
}

TableIdtableId=TableId.of(projectId,datasetName,tableName);
booleandeleted=bigquery.delete(tableId);
if(deleted){
// the table was deleted
}else{
// the table was not found
}

// Import the Google Cloud client library
const{BigQuery}=require('@google-cloud/bigquery');
constbigquery=newBigQuery ();
asyncfunctiondeleteTable(){
// Deletes "my_table" from "my_dataset".
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = "my_dataset";
// const tableId = "my_table";
// Delete the table
awaitbigquery
.dataset(datasetId)
.table(tableId)
.delete();
console.log(`Table ${tableId} deleted.`);
}

use Google\Cloud\BigQuery\BigQueryClient;
/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
$bigQuery = new BigQueryClient([
 'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$table->delete();
printf('Deleted table %s.%s' . PHP_EOL, $datasetId, $tableId);

fromgoogle.cloudimport bigquery
# Construct a BigQuery client object.
client = bigquery .Client ()
# TODO(developer): Set table_id to the ID of the table to fetch.
# table_id = 'your-project.your_dataset.your_table'
# If the table does not exist, delete_table raises
# google.api_core.exceptions.NotFound unless not_found_ok is True.
client.delete_table (table_id, not_found_ok=True) # Make an API request.
print("Deleted table '{}'.".format(table_id))

require"google/cloud/bigquery"
defdelete_tabledataset_id="my_dataset_id",table_id="my_table_id"
bigquery=Google::Cloud::Bigquery .new
dataset=bigquery.datasetdataset_id
table=dataset.tabletable_id
table.delete
puts"Table #{table_id} deleted."
end