Gestionar datos de tablas

En este documento se describe cómo gestionar los datos de las tablas en BigQuery. Puedes trabajar con los datos de las tablas de BigQuery de las siguientes formas:

• Cargar datos en una tabla
• Añadir o sobrescribir datos de una tabla
• Consultar (o previsualizar) los datos de una tabla
• Consultar datos de tablas
• Modificar datos de tablas mediante el lenguaje de manipulación de datos (DML)
• Copiar datos de una tabla
• Exportar datos de una tabla

Para obtener información sobre cómo gestionar los esquemas de tabla, consulta el artículo Modificar los esquemas de tabla.

Antes de empezar

Concede los roles que otorgan los permisos necesarios a los usuarios que deban realizar cada tarea de este documento. Los permisos necesarios (si los hay) para realizar una tarea se indican en la sección "Permisos necesarios" de la tarea.

Cargar datos en una tabla

Puedes cargar datos al crear una tabla o crear una tabla vacía y cargar los datos más adelante. Cuando cargues datos, puedes usar la detección automática de esquemas para los formatos de datos admitidos o especificar el esquema.

Para obtener más información sobre cómo cargar datos, consulta la documentación sobre el formato y la ubicación de los datos de tu fuente:

• Para obtener más información sobre cómo cargar datos desde Cloud Storage, consulta los siguientes artículos:

  • Cargar datos de Avro
  • Cargar datos de CSV
  • Cargar datos de JSON
  • Cargar datos de Parquet
  • Cargar datos de ORC
  • Cargar datos desde exportaciones de Datastore
  • Cargar datos desde exportaciones de Firestore

• Para obtener más información sobre cómo cargar datos desde una fuente local, consulta el artículo Cargar datos desde archivos locales.

Añadir y sobrescribir datos de tablas

Puede sobrescribir los datos de una tabla mediante una operación de carga o de consulta. Puedes añadir datos a una tabla ya creada realizando una operación de carga y anexión o añadiendo los resultados de una consulta a la tabla.

Para obtener más información sobre cómo añadir datos a una tabla o sobrescribirla al cargar datos, consulta la documentación del formato de los datos de origen:

• Añadir datos de Avro a una tabla o sobrescribirla
• Añadir datos CSV a una tabla o sobrescribirla
• Añadir datos JSON a una tabla o sobrescribirla
• Añadir datos Parquet a una tabla o sobrescribirla
• Añadir datos ORC a una tabla o sobrescribirla
• Añadir datos de Datastore a una tabla o sobrescribirla

Para añadir datos a una tabla o sobrescribirla con los resultados de una consulta, especifica una tabla de destino y define la disposición de escritura como:

• Añadir a tabla: añade los resultados de la consulta a una tabla.
• Sobrescribir tabla: sobrescribe una tabla con el mismo nombre con los resultados de la consulta.

Puedes usar la siguiente consulta para añadir registros de una tabla a otra:

  INSERT INTO <projectID>.<datasetID>.<table1> (
    <column2>,
    <column3>) (SELECT * FROM <projectID>.<datasetID>.<table2>)

Para obtener más información sobre cómo usar los resultados de las consultas para añadir o sobrescribir datos, consulta el artículo Escribir resultados de consultas.

Consultar datos de tablas

Puedes consultar o leer los datos de una tabla de las siguientes formas:

• Usar la Google Cloud consola
• Usar el comando bq head de la herramienta de línea de comandos bq
• Llamar al método de API tabledata.list
• Usar las bibliotecas de cliente

Permisos obligatorios

Para leer los datos de una tabla y una partición, necesitas el permiso de gestión de identidades y accesos (IAM) bigquery.tables.getData.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para consultar datos de tablas y particiones:

• roles/bigquery.dataViewer
• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin

Si tienes el permiso bigquery.datasets.create, puedes consultar los datos de las tablas y particiones de los conjuntos de datos que crees.

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta el artículo sobre funciones y permisos predefinidos.

Consultar datos de tablas

Para consultar los datos de una tabla, sigue estos pasos:

bq head \
--max_rows integer1 \
--start_row integer2 \
--selected_fields "columns" \
project_id:dataset.table

bq head --max_rows=10 mydataset.mytable

bq head myotherproject:mydataset.mytable

bq head --start_row 100 --selected_fields "field1,field2" mydataset.mytable

using Google.Api.Gax;
using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;
using System.Linq;

public class BigQueryBrowseTable
{
    public void BrowseTable(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference tableReference = new TableReference()
        {
            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 row in result.Take(10))
        {
            Console.WriteLine($"{row["corpus"]}: {row["word_count"]}");
        }
    }
}

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.
func browseTable(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	table := client.Dataset(datasetID).Table(tableID)
	it := table.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
}

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableDataListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableResult;

// Sample to directly browse a table with optional paging
public class BrowseTable {

  public static void runBrowseTable() {
    // TODO(developer): Replace these variables before running the sample.
    String table = "MY_TABLE_NAME";
    String dataset = "MY_DATASET_NAME";
    browseTable(dataset, table);
  }

  public static void browseTable(String dataset, String table) {
    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();

      // Identify the table itself
      TableId tableId = TableId.of(dataset, table);

      // Page over 100 records. If you don't need pagination, remove the pageSize parameter.
      TableResult result = 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 the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function browseRows() {
  // Displays rows from "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // List rows in the table
  const [rows] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .getRows();

  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

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++;
}

from google.cloud import 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"

def browse_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.data max: 10

  # Print row data
  rows.each { |row| puts row }
end

Consultar datos de tablas

Puedes consultar datos de BigQuery con uno de los siguientes tipos de trabajo de consulta:

• Trabajos de consulta interactiva. De forma predeterminada, BigQuery ejecuta las consultas como tareas de consulta interactivas, que están diseñadas para empezar a ejecutarse lo antes posible.

• Consultas por lotes. Las consultas por lotes tienen una prioridad inferior a las consultas interactivas. Cuando un proyecto o una reserva utiliza todos los recursos de computación disponibles, es más probable que las consultas por lotes se pongan en cola y permanezcan en ella. Una vez que se inicia una consulta por lotes, se ejecuta igual que una consulta interactiva. Para obtener más información, consulta el artículo sobre colas de consultas.

• Trabajos de consulta continua. Con estas tareas, la consulta se ejecuta de forma continua, lo que te permite analizar los datos entrantes en BigQuery en tiempo real y, a continuación, escribir los resultados en una tabla de BigQuery o exportarlos a Bigtable o Pub/Sub. Puedes usar esta función para llevar a cabo tareas urgentes, como crear estadísticas y actuar en consecuencia de inmediato, aplicar inferencias de aprendizaje automático (ML) en tiempo real y crear flujos de datos basados en eventos.

Puedes ejecutar trabajos de consulta con los siguientes métodos:

• Redacta y ejecuta una consulta en la Google Cloud consola.
• Ejecuta el comando bq query en la herramienta de línea de comandos bq.
• Llama mediante programación al método jobs.query o jobs.insert en la API REST de BigQuery.
• Usa las bibliotecas de cliente de BigQuery.

Para obtener más información sobre cómo consultar tablas de BigQuery, consulta la introducción a la consulta de datos de BigQuery.

Además de consultar datos almacenados en tablas de BigQuery, puedes consultar datos almacenados externamente. Para obtener más información, consulta el artículo Introducción a las fuentes de datos externas.

Modificar datos de tablas

Puedes modificar los datos de una tabla mediante instrucciones del lenguaje de manipulación de datos (DML) en SQL. Las instrucciones DML te permiten actualizar, combinar, insertar y eliminar filas en tablas. Para consultar la referencia de sintaxis y ejemplos de cada tipo de instrucción DML, consulta Instrucciones del lenguaje de manipulación de datos en GoogleSQL.

El dialecto de SQL antiguo no admite instrucciones DML. Para actualizar o eliminar datos con SQL antiguo, debe eliminar la tabla y volver a crearla con datos nuevos. También puedes escribir una consulta que modifique los datos y escriba los resultados de la consulta en una tabla de destino nueva.

Copiar datos de una tabla

Puedes copiar una tabla de las siguientes formas:

• Usar la Google Cloud consola
• Usar el comando bq cp de la herramienta de línea de comandos bq
• Llamar al método de API jobs.insert y configurar una tarea de copia
• Usar las bibliotecas de cliente

Para obtener más información sobre cómo copiar tablas, consulta Copiar una tabla.

Exportar datos de tablas

Puede exportar datos de tablas a un segmento de Cloud Storage en formato CSV, JSON, Avro o Parquet (vista previa). No se admite la exportación a tu máquina local. Sin embargo, puedes descargar y guardar los resultados de las consultas con la consola Google Cloud .

Para obtener más información, consulta el artículo Exportar datos de una tabla.

Seguridad de las tablas

Para controlar el acceso a las tablas de BigQuery, consulta el artículo sobre cómo controlar el acceso a los recursos con la gestión de identidades y accesos.

Siguientes pasos

• Para obtener más información sobre la carga de datos, consulta el artículo Introducción a la carga de datos.
• Para obtener más información sobre cómo consultar datos, consulta la introducción a la consulta de datos de BigQuery.
• Para obtener más información sobre cómo modificar los esquemas de tabla, consulta Modificar los esquemas de tabla.
• Para obtener más información sobre cómo crear y usar tablas, consulta el artículo Crear y usar tablas.
• Para obtener más información sobre cómo gestionar tablas, consulta el artículo Gestionar tablas.