Read data with BigQuery API using pagination

usingGoogle.Api.Gax ;
usingGoogle.Apis.Bigquery.v2.Data;
usingGoogle.Cloud.BigQuery.V2 ;
usingSystem;
usingSystem.Linq;
publicclassBigQueryBrowseTable
{
publicvoidBrowseTable(
stringprojectId="your-project-id"
)
{
BigQueryClient client=BigQueryClient .Create (projectId);
TableReferencetableReference=newTableReference()
{
TableId="shakespeare",
DatasetId="samples",
ProjectId="bigquery-public-data"
};
// Load all rows from a table
PagedEnumerable<TableDataList,BigQueryRow>result=client.ListRows (
tableReference:tableReference,
schema:null
);
// Print the first 10 rows
foreach(BigQueryRow rowinresult.Take(10))
{
Console.WriteLine($"{row["corpus"]}: {row["word_count"]}");
}
}
}

importcom.google.cloud.bigquery.BigQuery ;
importcom.google.cloud.bigquery.BigQuery.TableDataListOption ;
importcom.google.cloud.bigquery.BigQueryException ;
importcom.google.cloud.bigquery.BigQueryOptions ;
importcom.google.cloud.bigquery.TableId ;
importcom.google.cloud.bigquery.TableResult ;
// Sample to directly browse a table with optional paging
publicclass BrowseTable{
publicstaticvoidrunBrowseTable(){
// TODO(developer): Replace these variables before running the sample.
Stringtable="MY_TABLE_NAME";
Stringdataset="MY_DATASET_NAME";
browseTable(dataset,table);
}
publicstaticvoidbrowseTable(Stringdataset,Stringtable){
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.
BigQuerybigquery=BigQueryOptions.getDefaultInstance().getService();
// Identify the table itself
TableIdtableId=TableId.of(dataset,table);
// Page over 100 records. If you don't need pagination, remove the pageSize parameter.
TableResultresult=bigquery.listTableData(tableId,TableDataListOption.pageSize(100));
// Print the records
result
.iterateAll()
.forEach(
row->{
row.forEach(fieldValue->System.out.print(fieldValue.toString()+", "));
System.out.println();
});
System.out.println("Query ran successfully");
}catch(BigQueryException e){
System.out.println("Query failed to run \n"+e.toString());
}
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/bigquery"
"google.golang.org/api/iterator"
)
// browseTable demonstrates reading data from a BigQuery table directly without the use of a query.
// For large tables, we also recommend the BigQuery Storage API.
funcbrowseTable(wio.Writer,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)
it:=table.Read(ctx)
for{
varrow[]bigquery.Value
err:=it.Next(&row)
iferr==iterator.Done{
break
}
iferr!=nil{
returnerr
}
fmt.Fprintln(w,row)
}
returnnil
}

// Import the Google Cloud client library using default credentials
const{BigQuery}=require('@google-cloud/bigquery');
constbigquery=newBigQuery ();
asyncfunctionbrowseTable(){
// Retrieve a table's rows using manual pagination.
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = 'my_dataset'; // Existing dataset
// const tableId = 'my_table'; // Table to create
constquery=`SELECT name, SUM(number) as total_people
 FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
 GROUP BY name 
 ORDER BY total_people 
 DESC LIMIT 100`;
// Create table reference.
constdataset=bigquery.dataset(datasetId);
constdestinationTable=dataset.table(tableId);
// For all options, see https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfigurationquery
constqueryOptions={
query:query,
destination:destinationTable,
};
// Run the query as a job
const[job]=awaitbigquery.createQueryJob(queryOptions);
// For all options, see https://cloud.google.com/bigquery/docs/reference/v2/jobs/getQueryResults
constqueryResultsOptions={
// Retrieve zero resulting rows.
maxResults:0,
};
// Wait for the job to finish.
awaitjob .getQueryResults (queryResultsOptions);
functionmanualPaginationCallback(err,rows,nextQuery){
rows.forEach(row=>{
console.log(`name: ${row.name}, ${row.total_people} total people`);
});
if(nextQuery){
// More results exist.
destinationTable.getRows(nextQuery,manualPaginationCallback);
}
}
// For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tabledata/list
constgetRowsOptions={
autoPaginate:false,
maxResults:20,
};
// Retrieve all rows.
destinationTable.getRows(getRowsOptions,manualPaginationCallback);
}
browseTable();

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';
// $maxResults = 10;
$maxResults = 10;
$startIndex = 0;
$options = [
 'maxResults' => $maxResults,
 'startIndex' => $startIndex
];
$bigQuery = new BigQueryClient([
 'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$numRows = 0;
foreach ($table->rows($options) as $row) {
 print('---');
 foreach ($row as $column => $value) {
 printf('%s: %s' . PHP_EOL, $column, $value);
 }
 $numRows++;
}

fromgoogle.cloudimport bigquery
# Construct a BigQuery client object.
client = bigquery .Client ()
# TODO(developer): Set table_id to the ID of the table to browse data rows.
# table_id = "your-project.your_dataset.your_table_name"
# Download all rows from a table.
rows_iter = client.list_rows (table_id) # Make an API request.
# Iterate over rows to make the API requests to fetch row data.
rows = list(rows_iter)
print("Downloaded {} rows from table {}".format(len(rows), table_id))
# Download at most 10 rows.
rows_iter = client.list_rows (table_id, max_results=10)
rows = list(rows_iter)
print("Downloaded {} rows from table {}".format(len(rows), table_id))
# Specify selected fields to limit the results to certain columns.
table = client.get_table (table_id) # Make an API request.
fields = table.schema[:2] # First two columns.
rows_iter = client.list_rows (table_id, selected_fields=fields, max_results=10)
rows = list(rows_iter)
print("Selected {} columns from table {}.".format(len(rows_iter.schema), table_id))
print("Downloaded {} rows from table {}".format(len(rows), table_id))
# Print row data in tabular format.
rows = client.list_rows (table, max_results=10)
format_string = "{!s:<16} " * len(rows .schema)
field_names = [field.name for field in rows .schema]
print(format_string.format(*field_names)) # Prints column headers.
for row in rows:
 print(format_string.format(*row)) # Prints row data.

require"google/cloud/bigquery"
defbrowse_table
bigquery=Google::Cloud::Bigquery .new project_id:"bigquery-public-data"
dataset=bigquery.dataset"samples"
table=dataset.table"shakespeare"
# Load all rows from a table
rows=table.data
# Load the first 10 rows
rows=table.datamax:10
# Print row data
rows.each{|row|putsrow}
end