Administra datos de tablas

En este documento, se describe cómo administrar datos de tablas en BigQuery. Puedes trabajar con datos de tablas de BigQuery de las siguientes maneras:

  • Cargar datos en una tabla
  • Explorar datos de tablas (o bien, obtener una vista previa)
  • Consultar datos de tablas
  • Adjuntar datos de tablas o reemplazarlos
  • Modificar datos de tablas con el uso del lenguaje de manipulación de datos
  • Copiar datos de tablas
  • Exportar datos de tablas

Para obtener más información sobre cómo administrar esquemas de tablas, consulta Modifica esquemas de tablas.

Cómo cargar datos en una tabla

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

A fin de obtener más información sobre la carga de datos, consulta la documentación para el formato y la ubicación de tus datos de origen:

Cómo explorar datos de tablas

Puedes explorar los datos de tablas de las siguientes maneras:

  • Con Cloud Console o la IU web clásica de BigQuery
  • Mediante el comando bq de la herramienta de línea de comandos bq head
  • Mediante una llamada tabledata.list al método de la API
  • Mediante bibliotecas cliente

Permisos necesarios

Como mínimo, para examinar los datos de la tabla y la partición, debes contar con permisos bigquery.tables.getData. Las siguientes funciones predefinidas de IAM incluyen los permisos bigquery.tables.getData:

  • bigquery.dataViewer
  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. El acceso bigquery.dataOwner le permite al usuario explorar los datos de las tablas y particiones en el conjunto de datos.

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Funciones y permisos predefinidos.

Explora datos de la tabla

Para explorar datos de tablas:

Console

  1. Abre la IU web de BigQuery en Cloud Console.
    Ir a Cloud Console

  2. En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos. Mediante esta acción, se muestran las tablas y vistas del conjunto de datos.

  3. Haz clic en una tabla de la lista.

  4. Haz clic en Detalles y anota el valor de Número de filas. Es posible que necesites este valor para controlar el punto de partida de tus resultados mediante la herramienta de línea de comandos de bq o la API.

  5. Haz clic en Vista previa (Preview). Verás un conjunto de datos de muestra.

    Vista previa de la tabla

IU clásica

  1. En la IU web clásica de BigQuery, en el panel de navegación, haz clic en la flecha azul que se encuentra a la izquierda del conjunto de datos para expandirlo o haz doble clic en el nombre del conjunto de datos. Mediante esta acción, se muestran las tablas y vistas del conjunto de datos.

  2. Haz clic en una tabla de la lista.

  3. Haz clic en Detalles y anota el valor de Número de filas. Es posible que necesites este valor para controlar el punto de partida de tus resultados mediante la herramienta de línea de comandos de bq o la API.

  4. Haz clic en Vista previa (Preview). Verás un conjunto de datos de muestra.

    Vista previa de la tabla

Línea de comandos

Emite el comando bq head con la marca --max_rows para enumerar todas las columnas en una cantidad determinada de filas de la tabla. Si no se especifica --max_rows, el valor predeterminado es 100.

Para explorar un subconjunto de columnas en la tabla (incluidas las columnas anidadas y repetidas), usa la marca --selected_fields y, luego, ingresa las columnas como una lista separada por comas.

Para especificar la cantidad de filas que se deben omitir antes de mostrar los datos de la tabla, usa la marca --start_row=integer (o la combinación de teclas -s). El valor predeterminado es 0. Puedes recuperar la cantidad de filas de una tabla si usas el comando bq show para recuperar la información de la tabla.

Si la tabla que exploras está en un proyecto que no es el predeterminado, debes agregar el ID del proyecto al comando con el formato siguiente: project_id:dataset.table.

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

En el ejemplo anterior, se ilustra lo siguiente:

  • integer1 es el número de filas para mostrar.
  • integer2 es el número de filas que se deben omitir antes de mostrar los datos.
  • columns es una lista de columnas separadas por comas.
  • project_id es el ID del proyecto.
  • dataset es el nombre del conjunto de datos que contiene la tabla.
  • table es el nombre de la tabla que se explorará.

Ejemplos:

Ingresa el siguiente comando para enumerar todas las columnas de las primeras 10 filas de mydataset.mytable. mydataset está en tu proyecto predeterminado.

bq head --max_rows=10 mydataset.mytable

Ingresa el siguiente comando para enumerar todas las columnas de las primeras 100 filas de mydataset.mytable. mydataset se encuentra en myotherproject, no en el proyecto predeterminado.

bq head myotherproject:mydataset.mytable

Ingresa el siguiente comando para mostrar solo field1 y field2 en mydataset.mytable. El comando usa la marca --start_row para saltar a la fila 100. mydataset.mytable está en tu proyecto predeterminado.

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

Debido a que el comando bq head no crea un trabajo de consulta, los comandos bq head no aparecen en tu historial de consultas y no se te cobra por ellos.

API

Explora los datos de una tabla mediante una llamada a tabledata.list. Especifica el nombre de la tabla en el parámetro tableId.

Configura estos parámetros opcionales para controlar la salida:

  • maxResults: cantidad máxima de resultados que se mostrarán
  • selectedFields: lista de columnas separadas por comas que se mostrará; si no se especifica, se mostrarán todas las columnas
  • startIndex: índice basado en cero de la primera fila que debe leerse

Los valores se muestran unidos en un objeto JSON que debes analizar, como se describe en la documentación de referencia de tabledata.list.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.


using Google.Api.Gax;
using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
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"]}");
        }
    }
}

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Las bibliotecas cliente de Google Cloud para Go se paginan automáticamente de forma predeterminada, por lo que no necesitas implementarla. Por ejemplo:

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
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

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());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

La biblioteca cliente de Google Cloud para Node.js se paginan de forma automática según la configuración predeterminada, por lo que no necesitas implementarla por tu cuenta, por ejemplo:


// 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));
}

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

La paginación se realiza de forma automática en las bibliotecas cliente de Cloud para PHP mediante la función de generador rows, que recupera la siguiente página de resultados durante la iteración.

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

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.


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.

Ruby

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

La paginación se realiza de forma automática en las Bibliotecas cliente de Cloud para Ruby mediante Table#data y Data#next.

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

Consulta datos de tablas

Después de cargar tus datos en BigQuery, puedes consultar los datos en tus tablas. BigQuery admite dos tipos de consultas:

BigQuery ejecuta consultas interactivas de forma predeterminada, lo que significa que la consulta se ejecuta lo antes posible.

BigQuery también ofrece consultas por lotes. BigQuery pone en cola cada consulta por lotes en tu nombre y, luego, inicia la consulta en cuanto los recursos inactivos estén disponibles, lo que, por lo general, toma unos minutos.

Puedes ejecutar consultas interactivas y por lotes con las siguientes opciones:

Si deseas obtener más información sobre cómo consultar las tablas de BigQuery, revisa Descripción general de consultas de datos de BigQuery.

Además de consultar los datos almacenados en las tablas de BigQuery, puedes consultar los datos almacenados de forma externa. Para obtener más información, consulta Introducción a las fuentes de datos externas.

Cómo adjuntar y reemplazar datos de tablas

Puedes reemplazar los datos de las tablas mediante una operación de carga o consulta. Puedes agregar datos adicionales a una tabla existente; para ello, realiza una operación de adición de carga o agrega los resultados de la consulta a la tabla.

Si deseas obtener más información sobre cómo agregar o reemplazar una tabla cuando se cargan datos, consulta la documentación para el formato de datos de origen:

Para agregar o reemplazar una tabla mediante los resultados de la consulta, especifica una tabla de destino y configura la disposición de escritura en:

  • Agregar a la tabla: Agrega los resultados de la consulta a una tabla existente.
  • Reemplazar datos: reemplaza los datos existentes de una tabla con el mismo nombre por los resultados de la consulta.

Si quieres obtener más información sobre cómo usar los resultados de la consulta para agregar o reemplazar datos, consulta Escribe resultados de consultas.

Cómo modificar los datos de tablas

Puedes modificar los datos de una tabla mediante declaraciones DML en el dialecto SQL estándar. Las declaraciones DML te permiten realizar actualizaciones, inserciones y eliminaciones de filas de forma masiva. Si deseas obtener ejemplos sobre el uso de DML, consulta Actualiza datos de tablas con el lenguaje de manipulación de datos.

El dialecto SQL heredado no es compatible con declaraciones DML. Para actualizar o borrar datos con SQL heredado, debes borrar la tabla y, a continuación, volver a crearla con datos nuevos. También puedes escribir una consulta que modifique los datos y escribir los resultados de la consulta en una tabla de destino nueva.

Cómo copiar los datos de tablas

Puedes copiar una tabla de las maneras siguientes:

  • Con Cloud Console o la IU web clásica de BigQuery
  • Mediante el comando bq de la herramienta de línea de comandos bq cp
  • Mediante llamadas al método de API jobs.insert y la configuración de un trabajo de copia
  • Mediante bibliotecas cliente

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

Cómo exportar datos de tablas

Puedes exportar datos de tablas en formato CSV, JSON o Avro. Por el momento, debes exportar datos a un depósito de Cloud Storage. No se admite la exportación a tu máquina local; sin embargo, puedes descargar y guardar los resultados de la consulta con Cloud Console o con la IU web clásica de BigQuery.

Para obtener más información, consulta Exporta datos de tabla.

Próximos pasos