Crea y usa tablas
En este documento, se describe cómo crear y usar tablas estándar (integradas) en BigQuery. Para obtener información sobre cómo crear otros tipos de tablas, consulta las siguientes páginas:
Después de crear una tabla, puedes hacer lo siguiente:
- Controlar el acceso a los datos de tus tablas
- Obtener información sobre tus tablas
- Enumerar las tablas en un conjunto de datos
- Obtener metadatos de tablas
Para obtener más información sobre la administración de tablas, lo que incluye actualizar sus propiedades, copiarlas y borrarlas, consulta Administra tablas.
Antes de comenzar
Antes de crear una tabla en BigQuery, primero haz lo siguiente:
- Configura un proyecto con una guía de introducción de BigQuery.
- Crea un conjunto de datos de BigQuery.
- De forma opcional, puedes leer Introducción a las tablas para comprender las limitaciones, las cuotas y los precios de las tablas.
Nombres de las tablas
Cuando creas una tabla en BigQuery, el nombre de la tabla debe ser único en cada conjunto de datos. El nombre de la tabla puede contener lo siguiente:
- Hasta 1,024 caracteres
- Caracteres Unicode en la categoría L (letra), M (marca), N (número), Pc (conector, incluido el guion bajo), Pd (raya) y Zs (espacio) Para obtener más información, consulta la Categoría general.
A continuación, se muestran todos los ejemplos de nombres de tabla válidos: table 01
, ग्राहक
, 00_お客様
y étudiant-01
.
Advertencias:
- Los nombres de tablas distinguen entre mayúsculas y minúsculas de forma predeterminada.
mytable
yMyTable
pueden coexistir en el mismo conjunto de datos, a menos que sean parte de un conjunto de datos con la distinción entre mayúsculas y minúsculas desactivada. - Algunos nombres de tablas y prefijos de nombres de tablas están reservados. Si recibes un error que indica que el nombre o prefijo de la tabla está reservado, selecciona un nombre diferente y vuelve a intentarlo.
Si incluyes múltiples operadores de punto (
.
) en una secuencia, los operadores duplicados se quitan de forma implícita.Por ejemplo, esto:
project_name....datasest_name..table_name
Se convierte en esto:
project_name.dataset_name.table_name
Crear tablas
Puedes crear una tabla en BigQuery de las siguientes maneras:
- De forma manual, con la consola de Google Cloud o el comando
bq mk
de la herramienta de línea de comandos debq
. - De manera programática, con una llamada al método
tables.insert
de la API - Mediante las bibliotecas cliente
- Desde resultados de consultas.
- Mediante la definición de una tabla que hace referencia a una fuente de datos externa.
- Cuando cargas datos.
- Mediante una declaración de lenguaje de definición de datos (DDL)
CREATE TABLE
Permisos necesarios
Para crear una tabla, necesitas los siguientes permisos de IAM:
bigquery.tables.create
bigquery.tables.updateData
bigquery.jobs.create
Además, es posible que necesites el permiso bigquery.tables.getData
para acceder a los datos que escribas en la tabla.
Cada una de las siguientes funciones predefinidas de IAM incluye los permisos que necesitas para crear una tabla:
roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin
(incluye el permisobigquery.jobs.create
)roles/bigquery.user
(incluye el permisobigquery.jobs.create
)roles/bigquery.jobUser
(incluye el permisobigquery.jobs.create
)
Además, si tienes el permiso bigquery.datasets.create
, puedes crear y actualizar tablas en los conjuntos de datos que crees.
Para obtener más información sobre los roles de IAM y los permisos en BigQuery, consulta Roles y permisos predefinidos.
Crea una tabla vacía con una definición de esquema
Puedes crear una tabla vacía con una definición de esquema de las siguientes maneras:
- Ingresa el esquema con la consola de Google Cloud.
- Proporciona el esquema intercalado con la herramienta de línea de comandos de
bq
. - Envía un archivo de esquema JSON con la herramienta de línea de comandos de
bq
. - Proporciona el esquema en un recurso de tabla cuando llames al método
tables.insert
de la API.
Si quieres obtener más información acerca de cómo especificar un esquema de tabla, consulta Especifica un esquema.
Después de crear la tabla, puedes cargarle datos o propagar contenidos en ella mediante la escritura de resultados de consulta.
Para crear una tabla vacía con una definición de esquema, haz lo siguiente:
Console
En la consola de Google Cloud, ve a la página de BigQuery.
- En el panel Explorador, expande tu proyecto y, luego, selecciona un conjunto de datos.
- En la sección Información del conjunto de datos, haz clic en Crear tabla.
- En el panel Crear tabla, especifica los siguientes detalles:
- En la sección Fuente, selecciona Tabla vacía en la lista Crear tabla desde.
- En la sección Destino, especifica los siguientes detalles:
- En Conjunto de datos, selecciona el conjunto de datos en el que deseas crear la tabla.
- En el campo Tabla, ingresa el nombre de la tabla que deseas crear.
- Verifica que el campo Tipo de tabla esté configurado como Tabla nativa.
- En la sección Esquema, ingresa la definición del esquema.
Puedes ingresar la información del esquema de forma manual mediante uno de los siguientes métodos:
- Opción 1: Haz clic en Editar como texto y pega el esquema con el formato de un array JSON. Cuando usas un array JSON, generas el esquema mediante el mismo proceso que se usa para crear un archivo de esquema JSON.
Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando:
bq show --format=prettyjson dataset.table
- Opción 2: Haz clic en Tipo y el Modo de cada campo. Agregar campo y, luego, ingresa el esquema de la tabla. Especifica el Nombre, el
- Opción 1: Haz clic en Editar como texto y pega el esquema con el formato de un array JSON. Cuando usas un array JSON, generas el esquema mediante el mismo proceso que se usa para crear un archivo de esquema JSON.
Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando:
- Opcional: Especifica Configuración de particiones y clústeres. Para obtener más información, consulta Crea tablas particionadas y Crea y usa tablas agrupadas en clústeres.
- Opcional: En la sección Opciones avanzadas, si deseas usar una clave de encriptación administrada por el cliente, selecciona la opción Usar una clave de encriptación administrada por el cliente (CMEK). De forma predeterminada, BigQuery encripta contenido de clientes almacenado en reposo mediante una clave administrada por Google.
- Haga clic en Crear tabla.
SQL
En el siguiente ejemplo, se crea una tabla con el nombre newtable
que vence el 1 de enero de 2023.
En la consola de Google Cloud, ve a la página de BigQuery.
En el editor de consultas, ingresa la siguiente sentencia:
CREATE TABLE mydataset.newtable ( x INT64 OPTIONS (description = 'An optional INTEGER field'), y STRUCT < a ARRAY <STRING> OPTIONS (description = 'A repeated STRING field'), b BOOL > ) OPTIONS ( expiration_timestamp = TIMESTAMP '2023-01-01 00:00:00 UTC', description = 'a table that expires in 2023', labels = [('org_unit', 'development')]);
Haz clic en
Ejecutar.
Si quieres obtener información para ejecutar consultas, visita Ejecuta consultas interactivas.
bq
Usa el comando bq mk
con la marca --table
o -t
. Puedes suministrar la información del esquema de la tabla de forma intercalada o con un archivo de esquema JSON. Entre los parámetros opcionales se incluyen los siguientes:
--expiration
--description
--time_partitioning_field
--time_partitioning_type
--range_partitioning
--clustering_fields
--destination_kms_key
--label
--time_partitioning_field
, --time_partitioning_type
,
--range_partitioning
, --clustering_fields
y --destination_kms_key
no se demuestran aquí. Consulta los siguientes vínculos para obtener más información sobre estos parámetros opcionales:
- Para obtener más información sobre
--time_partitioning_field
,--time_partitioning_type
y--range_partitioning
, consulta tablas particionadas. - Para obtener más información sobre
--clustering_fields
, consulta tablas agrupadas en clústeres. - Para obtener más información sobre
--destination_kms_key
, consulta las claves de encriptación administradas por el cliente.
Si creas una tabla en otro proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el formato siguiente: project_id:dataset
.
Para crear una tabla vacía en un conjunto de datos existente con una definición de esquema, ingresa lo siguiente:
bq mk \ --table \ --expiration integer \ --description description \ --label key_1:value_1 \ --label key_2:value_2 \ project_id:dataset.table \ schema
Reemplaza lo siguiente:
- integer es el ciclo de vida predeterminado (en segundos) de la tabla. El valor mínimo es 3,600 segundos (una hora). La hora de vencimiento se evalúa según la hora UTC actual más el número entero. Si configuras el vencimiento cuando creas una tabla, se ignora la configuración predeterminada de vencimiento de tablas del conjunto de datos.
- description es una descripción de la tabla entre comillas.
- key_1:value_1 y key_2:value_2 son pares clave-valor que especifican etiquetas.
- project_id es el ID del proyecto.
- dataset es un conjunto de datos en tu proyecto.
- table es el nombre de la tabla que crearás.
- schema es una definición de esquema intercalado en el formato field:data_type,field:data_type o la ruta al archivo de esquema JSON en tu máquina local.
Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo RECORD
(STRUCT
) ni una descripción de la columna, ni tampoco puedes especificar el modo de la columna. Todos los modos están establecidos como NULLABLE
de forma predeterminada. Para incluir descripciones, modos y tipos de RECORD
, proporciona un archivo de esquema JSON en su lugar.
Ejemplos:
Ingresa el siguiente comando para crear una tabla con una definición de esquema intercalada. Este comando crea una tabla llamada mytable
en mydataset
en tu proyecto predeterminado. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción como This is my table
y la etiqueta como organization:development
. El comando usa el acceso directo -t
en lugar de --table
. El esquema está especificado de forma intercalada como: qtr:STRING,sales:FLOAT,year:STRING
.
bq mk \ -t \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ mydataset.mytable \ qtr:STRING,sales:FLOAT,year:STRING
Ingresa el siguiente comando para crear una tabla con un archivo de esquema JSON. Este comando crea una tabla llamada mytable
en mydataset
en tu proyecto predeterminado. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción como This is my table
y la etiqueta como organization:development
. La ruta al archivo del esquema es /tmp/myschema.json
.
bq mk \ --table \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ mydataset.mytable \ /tmp/myschema.json
Ingresa el siguiente comando para crear una tabla con un archivo de esquema JSON.
Este comando crea una tabla llamada mytable
en mydataset
en myotherproject
. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción como This is my table
y la etiqueta como organization:development
. La ruta al archivo del esquema es /tmp/myschema.json
.
bq mk \ --table \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ myotherproject:mydataset.mytable \ /tmp/myschema.json
Una vez que se crea la tabla, puedes actualizar el vencimiento, la descripción y las etiquetas. También puedes modificar la definición de esquema.
API
Realiza una llamada al método tables.insert
con un recurso de tabla definido.
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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.
Go
Antes de probar este ejemplo, sigue las instrucciones de configuración para Go incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.
Java
Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.
Node.js
Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.
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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.
Python
Antes de probar este ejemplo, 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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.
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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.
Crea una tabla vacía sin una definición de esquema
Java
Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.
Crea una tabla a partir de un resultado de consulta.
Para crear una tabla a partir de un resultado de consulta, escribe los resultados en una tabla de destino.
Console
Abre la página BigQuery en la consola de Google Cloud.
En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.
Ingresa una consulta de SQL válida.
Haz clic en Más y, luego, selecciona Opciones de consulta.
Selecciona la opción Set a destination table for query results (Establecer una tabla de destino para los resultados de la consulta).
En la sección Destino, selecciona el Conjunto de datos en el que deseas crear la tabla y, luego, elige un ID de la tabla.
En la sección Preferencia de escritura para la tabla de destino, elige una de las siguientes opciones:
- Escribir si está vacía: escribe los resultados de las consultas en la tabla solo si está vacía.
- Agregar a la tabla: Agrega los resultados de las consultas a una tabla existente.
- Reemplazar la tabla: Se reemplaza una tabla existente que tiene el mismo nombre con los resultados de las consultas.
Opcional: En Ubicación de los datos, elige tu ubicación.
Para actualizar la configuración de la consulta, haz clic en Guardar.
Haga clic en Ejecutar. Esta acción crea un trabajo de consulta que escribe los resultados de las consultas en la tabla que especificaste.
Como alternativa, si te olvidas de especificar una tabla de destino antes de ejecutar la consulta, puedes hacer clic en el botón Guardar los resultados encima del editor para copiar la tabla de resultados almacenados en caché en una tabla permanente.
SQL
En el siguiente ejemplo, se usa la declaración CREATE TABLE
para crear la tabla trips
a partir de los datos de la tabla bikeshare_trips
pública:
En la consola de Google Cloud, ve a la página de BigQuery.
En el editor de consultas, ingresa la siguiente sentencia:
CREATE TABLE mydataset.trips AS ( SELECT bikeid, start_time, duration_minutes FROM bigquery-public-data.austin_bikeshare.bikeshare_trips );
Haz clic en
Ejecutar.
Si deseas obtener más información para ejecutar consultas, visita Ejecuta consultas interactivas.
Para obtener más información, consulta Crea una tabla nueva a partir de una tabla existente.
bq
Ingresa el comando bq query
y especifica la marca --destination_table
para crear una tabla permanente basada en los resultados de las consultas. Especifica la marca use_legacy_sql=false
para usar la sintaxis GoogleSQL. Para escribir los resultados de las consultas en una tabla que no se encuentra en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos con el formato siguiente: project_id:dataset
.
Opcional: Proporciona la marca --location
y establece el valor en tu ubicación.
Para controlar la disposición de escritura de una tabla de destino existente, especifica una de las marcas opcionales siguientes:
--append_table
: Si existe la tabla de destino, los resultados de las consultas se agregan a esta tabla.--replace
: Si existe la tabla de destino, se reemplaza por los resultados de las consultas.
bq --location=location query \ --destination_table project_id:dataset.table \ --use_legacy_sql=false 'query'
Reemplaza lo siguiente:
location
es el nombre de la ubicación que se usa para procesar la consulta. La marca--location
es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes configurar el valor de la marca comoasia-northeast1
. Puedes configurar un valor predeterminado para la ubicación mediante el archivo.bigqueryrc
.project_id
es el ID del proyecto.dataset
es el nombre del conjunto de datos que contiene la tabla en la que escribes los resultados de la consulta.table
es el nombre de la tabla en la que escribes los resultados de las consultas.query
es una consulta en la sintaxis de Google SQL.
Si no se especifica una marca de disposición de escritura, el comportamiento predeterminado es escribir los resultados en la tabla solo si está vacía. Si la tabla existe y no está vacía, se muestra el error siguiente: Error de BigQuery en la operación de consulta: error durante el procesamiento del trabajo project_id:bqjob_123abc456789_00000e1234f_1': Already
Exists: Table project_id:dataset.table
.
Por ejemplo:
Ingresa el comando siguiente para escribir los resultados de las consultas en una tabla de destino llamada mytable
en mydataset
. El conjunto de datos se encuentra en tu proyecto predeterminado.
Debido a que no se especifica ninguna marca de disposición de escritura en el comando, la tabla debe ser nueva o estar vacía. De lo contrario, se muestra un error Already exists
. Con la consulta, se recuperan datos del conjunto de datos públicos Datos de nombres de EE.UU.
bq query \ --destination_table mydataset.mytable \ --use_legacy_sql=false \ 'SELECT name, number FROM `bigquery-public-data`.usa_names.usa_1910_current WHERE gender = "M" ORDER BY number DESC'
Ingresa el comando siguiente para usar los resultados de las consultas a fin de reemplazar una tabla de destino llamada mytable
en mydataset
. El conjunto de datos se encuentra en tu proyecto predeterminado. En el comando, se usa la marca --replace
para reemplazar la tabla de destino.
bq query \ --destination_table mydataset.mytable \ --replace \ --use_legacy_sql=false \ 'SELECT name, number FROM `bigquery-public-data`.usa_names.usa_1910_current WHERE gender = "M" ORDER BY number DESC'
Ingresa el comando siguiente para agregar los resultados de las consultas a una tabla de destino llamada mytable
en mydataset
. El conjunto de datos está en my-other-project
, no en tu proyecto predeterminado. En el comando, se usa la marca --append_table
para agregar los resultados de las consultas a la tabla de destino.
bq query \ --append_table \ --use_legacy_sql=false \ --destination_table my-other-project:mydataset.mytable \ 'SELECT name, number FROM `bigquery-public-data`.usa_names.usa_1910_current WHERE gender = "M" ORDER BY number DESC'
El resultado de cada uno de estos ejemplos se verá de la manera siguiente. Para facilitar la lectura, algunos resultados se truncaron.
Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE +---------+--------+ | name | number | +---------+--------+ | Robert | 10021 | | John | 9636 | | Robert | 9297 | | ... | +---------+--------+
API
Si deseas guardar los resultados de las consultas en una tabla permanente, realiza una llamada al método jobs.insert
, configura un trabajo query
y, por último, incluye un valor para la propiedad destinationTable
. Para controlar la disposición de escritura de una tabla de destino existente, configura la propiedad writeDisposition
.
Si deseas controlar la ubicación de procesamiento para el trabajo de consulta, especifica la propiedad location
en la sección jobReference
del recurso de trabajo.
Go
Antes de probar este ejemplo, sigue las instrucciones de configuración para Go incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.
Java
Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.
Para guardar los resultados de las consultas en una tabla permanente, configura la tabla de destino con el valor TableId que desees en una QueryJobConfiguration.
Node.js
Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.
Python
Antes de probar este ejemplo, 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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.
Para guardar los resultados de las consultas en una tabla permanente, crea una QueryJobConfig y configura el destino con el valor TableReference que desees. Pasa la configuración del trabajo al método de consulta.Crea una tabla que hace referencia a una fuente de datos externa
Una fuente de datos externa es una fuente de datos que puedes consultar directamente desde BigQuery, aunque los datos no estén almacenados en BigQuery. Por ejemplo, es posible que tengas datos en una base de datos diferente de Google Cloud, en archivos en Cloud Storage o en otro producto en la nube que desees analizar en BigQuery, pero no lo hagas. Prepárate para migrar.
Para obtener más información, consulta Introducción a las fuentes de datos externas.
Crea una tabla cuando cargas datos
Cuando cargas datos en BigQuery, puedes cargarlos en una nueva tabla o partición, puedes agregar datos a una tabla o partición existentes, o puedes reemplazar una tabla o partición. No es necesario crear una tabla vacía antes de cargarle datos. Puedes crear la tabla nueva y cargar tus datos al mismo tiempo.
Cuando cargas datos en BigQuery, puedes suministrar el esquema de tabla o de partición; si el formato de los datos es compatible, puedes usar la detección automática de esquemas.
Para obtener más información sobre la carga de datos, consulta Introducción a la carga de datos en BigQuery.
Controla el acceso a las tablas
Para configurar el acceso a las tablas y vistas, puedes otorgar un rol de IAM a una entidad en los siguientes niveles, ordenados según el rango de recursos permitidos (de mayor a menor):
- un nivel alto en la jerarquía de recursos de Google Cloud, como el nivel de proyecto, organización o carpeta
- el nivel del conjunto de datos
- el nivel de la tabla o la vista
También puedes restringir el acceso a los datos dentro de las tablas con los siguientes métodos:
El acceso con cualquier recurso protegido por IAM es aditivo. Por ejemplo, si una entidad no tiene acceso en un nivel alto, como un proyecto, podrías otorgar acceso a la entidad a nivel del conjunto de datos. Luego, la entidad tendrá acceso a las tablas y vistas del conjunto de datos. Del mismo modo, si la entidad no tiene acceso en el nivel alto o en el de conjunto de datos, puedes otorgar acceso a la entidad a nivel de tabla o de vista.
Si otorgas funciones de IAM en un nivel superior en la jerarquía de recursos de Google Cloud, como el nivel de proyecto, de carpeta o de organización, la entidad tiene acceso a un amplio conjunto de recursos. Por ejemplo, cuando se otorga una función a una entidad en el nivel de proyecto, se le brindan permisos que se aplican a todos los conjuntos de datos del proyecto.
Si se otorga una función a nivel de conjunto de datos, se especifican las operaciones que una entidad puede realizar en las tablas y vistas de ese conjunto de datos específico, incluso si la entidad no tiene acceso a un nivel superior. Para obtener información sobre la configuración de los controles de acceso a nivel de conjunto de datos, consulta Controla el acceso a los conjuntos de datos.
Cuando se otorga una función a nivel de tabla o vista, se especifican las operaciones que una entidad puede realizar en las tablas y vistas específicas, incluso si la entidad no tiene acceso a un nivel superior. Para obtener información sobre la configuración de los controles de acceso a nivel de tabla, consulta Controla el acceso a las tablas y vistas.
También puedes crear funciones de IAM personalizadas. Si creas una función personalizada, los permisos que otorgas dependerán de las operaciones específicas que deseas que la entidad pueda realizar.
No puedes establecer un permiso de denegación en ningún recurso protegido por IAM.
Para obtener más información sobre los roles y los permisos, consulta Comprende los roles en la documentación de IAM y los roles y permisos de IAM de BigQuery.
Obtén información sobre las tablas
Puedes obtener información o metadatos sobre las tablas de las siguientes maneras:
- Usa la consola de Google Cloud.
- Usa el comando
bq
de la herramienta de línea de comandosbq show
. - Mediante una llamada al método de la API
tables.get
- Usa las bibliotecas cliente.
- Consulta las vistas
INFORMATION_SCHEMA
(beta).
Permisos necesarios
Como mínimo, para obtener información sobre las tablas, debes tener permisos bigquery.tables.get
. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.get
:
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
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 otorga al usuario la capacidad de recuperar los metadatos de la tabla.
Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta Control de acceso.
Obtén información de tablas
Para obtener información sobre las tablas, haz lo siguiente:
Console
En el panel de navegación, en la sección Recursos, expande tu proyecto y, luego, selecciona un conjunto de datos.
Haz clic en el nombre del conjunto de datos para expandirlo. Aparecerán las tablas y vistas del conjunto de datos.
Haz clic en el nombre de la tabla.
En el panel Detalles, haz clic en Detalles para mostrar la descripción y la información de la tabla.
De manera opcional, cambia a la pestaña Esquema para ver la definición del esquema de la tabla.
bq
Emite el comando bq show
para mostrar toda la información de la tabla. Usa la marca --schema
para mostrar solo la información del esquema de la tabla. Se puede usar la marca --format
para controlar el resultado.
Si quieres obtener información sobre una tabla en un proyecto que no sea tu proyecto predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: project_id:dataset
.
bq show \ --schema \ --format=prettyjson \ project_id:dataset.table
En el ejemplo anterior, se ilustra lo siguiente:
- project_id es el ID del proyecto.
- dataset es el nombre del conjunto de datos.
- table es el nombre de la tabla.
Por ejemplo:
Ingresa el siguiente comando para mostrar toda la información sobre mytable
en mydataset
. mydataset
está en tu proyecto predeterminado.
bq show --format=prettyjson mydataset.mytable
Ingresa el siguiente comando para mostrar toda la información sobre mytable
en mydataset
. mydataset
está en myotherproject
, no en tu proyecto predeterminado.
bq show --format=prettyjson myotherproject:mydataset.mytable
Ingresa el comando siguiente para mostrar solo la información del esquema sobre mytable
en mydataset
. mydataset
está en myotherproject
, no en tu proyecto predeterminado.
bq show --schema --format=prettyjson myotherproject:mydataset.mytable
API
Llama al método tables.get
y proporciona los parámetros relevantes.
Go
Antes de probar este ejemplo, sigue las instrucciones de configuración para Go incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.
Java
Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.
Node.js
Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.
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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.
Python
Antes de probar este ejemplo, 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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.
Obtén información de tablas mediante INFORMATION_SCHEMA
INFORMATION_SCHEMA
es una serie de vistas que proporcionan acceso a metadatos sobre conjuntos de datos, rutinas, tablas, vistas, trabajos, reservas y datos de transmisión.
Puedes consultar las siguientes vistas para obtener información de la tabla:
- Usa las vistas
INFORMATION_SCHEMA.TABLES
yINFORMATION_SCHEMA.TABLE_OPTIONS
para recuperar metadatos sobre las tablas y las vistas en un proyecto. - Usa las vistas
INFORMATION_SCHEMA.COLUMNS
yINFORMATION_SCHEMA.COLUMN_FIELD_PATHS
para recuperar metadatos sobre las columnas (campos) en una tabla. - Usa las vistas
INFORMATION_SCHEMA.TABLE_STORAGE
para recuperar metadatos sobre el uso del almacenamiento histórico y actual de una tabla.
Las vistas TABLES
y TABLE_OPTIONS
también contienen información de alto nivel sobre las vistas. Para obtener información detallada, consulta la vista INFORMATION_SCHEMA.VIEWS
.
Vista TABLES
Cuando consultas la vista INFORMATION_SCHEMA.TABLES
, los resultados contienen una fila por cada tabla o vista de un conjunto de datos. Para obtener información detallada sobre las vistas, consulta la vista INFORMATION_SCHEMA.VIEWS
en su lugar.
La vista INFORMATION_SCHEMA.TABLES
tiene el siguiente esquema:
Nombre de la columna | Tipo de datos | Valor |
---|---|---|
table_catalog |
STRING |
El ID del proyecto que contiene el conjunto de datos. |
table_schema |
STRING |
El nombre del conjunto de datos que contiene la tabla o la vista, también denominado datasetId . |
table_name |
STRING |
El nombre de la tabla o la vista, también denominado tableId . |
table_type |
STRING |
El tipo de tabla, que es una de las siguientes opciones:
|
is_insertable_into |
STRING |
YES o NO , lo que depende de si la tabla admite declaraciones DML INSERT |
is_typed |
STRING |
El valor es siempre NO |
creation_time |
TIMESTAMP |
La fecha y hora de creación de la tabla |
ddl |
STRING |
La declaración DDL que se puede usar para volver a crear la tabla, como CREATE TABLE o CREATE VIEW . |
clone_time |
TIMESTAMP |
En el caso de las clonaciones de tabla (vista previa), el momento en que la tabla base se clonó para crear esta tabla. Si se usó el viaje en el tiempo, este campo contiene la marca de tiempo del viaje en el tiempo. De lo contrario, el campo clone_time es igual al campo creation_time . Solo se aplica a las tablas que tienen table_type configurado como CLONE .
|
base_table_catalog |
STRING |
Para las clonaciones de tabla (vista previa), es el proyecto de la tabla base. Solo se aplica a las tablas que tienen table_type configurado como CLONE .
|
base_table_schema |
STRING |
Para las clonaciones de tabla (vista previa), es el conjunto de datos de la tabla base. Solo se aplica a las tablas que tienen table_type configurado como CLONE . |
base_table_name |
STRING |
Para las clonaciones de tabla (vista previa), es el nombre de la tabla base. Solo se aplica a las tablas que tienen table_type configurado como CLONE . |
default_collation_name |
STRING |
El nombre de la especificación de la intercalación predeterminada, si existe; en caso contrario, NULL .
|
Ejemplos
Ejemplo 1:
En el ejemplo siguiente, se recuperan los metadatos de todas las tablas en el conjunto de datos llamado mydataset
. La consulta selecciona todas las columnas de la vista INFORMATION_SCHEMA.TABLES
, excepto is_typed
, que se reserva para uso futuro. Los metadatos que se muestran corresponden a todos los tipos de tablas de mydataset
en tu proyecto predeterminado.
mydataset
contiene las tablas siguientes:
mytable1
: Una tabla de BigQuery estándarmyview1
: una vista de BigQuery
Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en este formato: `project_id`.dataset.INFORMATION_SCHEMA.view
(por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES
).
SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES;
El resultado es similar al siguiente. Para facilitar la lectura, algunas columnas se excluyen del resultado.
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+ | table_catalog | table_schema | table_name | table_type | is_insertable_into | creation_time | ddl | +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+ | myproject | mydataset | mytable1 | BASE TABLE | YES | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` | | | | | | | | ( | | | | | | | | id INT64 | | | | | | | | ); | | myproject | mydataset | myview1 | VIEW | NO | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1` | | | | | | | | AS SELECT 100 as id; | +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Ejemplo 2:
En el ejemplo siguiente, se recuperan todas las tablas de tipo BASE TABLE
de la vista INFORMATION_SCHEMA.TABLES
. La columna is_typed
queda excluida.
Los metadatos que se muestran corresponden a las tablas de mydataset
en tu proyecto predeterminado.
Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en este formato: `project_id`.dataset.INFORMATION_SCHEMA.view
(por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES
).
SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES WHERE table_type = 'BASE TABLE';
El resultado es similar al siguiente. Para facilitar la lectura, algunas columnas se excluyen del resultado.
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog | table_schema | table_name | table_type | is_insertable_into | creation_time | ddl |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject | mydataset | mytable1 | BASE TABLE | YES | 2018-10-31 22:40:05 | CREATE TABLE myproject.mydataset.mytable1
|
| | | | | | | ( |
| | | | | | | id INT64 |
| | | | | | | ); |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Ejemplo 3:
En el siguiente ejemplo, se recuperan las columnas table_name
y ddl
de la vista INFORMATION_SCHEMA.TABLES
para la tabla population_by_zip_2010
en el conjunto de datos census_bureau_usa
. Este conjunto de datos es parte del programa de conjuntos de datos públicos de BigQuery.
Debido a que la tabla que consultas está en otro proyecto, debes agregar el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view
.
En este ejemplo, el valor es
`bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
.
SELECT table_name, ddl FROM `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES WHERE table_name = 'population_by_zip_2010';
El resultado es similar al siguiente:
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | table_name | ddl | +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010` | | | ( | | | geo_id STRING OPTIONS(description="Geo code"), | | | zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"), | | | population INT64 OPTIONS(description="The total count of the population for this segment."), | | | minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."), | | | maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), | | | gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.") | | | ) | | | OPTIONS( | | | labels=[("freebqcovid", "")] | | | ); | +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
Vista TABLE_OPTIONS
Cuando consultas la vista INFORMATION_SCHEMA.TABLE_OPTIONS
, los resultados contienen una fila por cada opción, por cada tabla o vista de un conjunto de datos. Para obtener información detallada sobre las vistas, consulta la vista INFORMATION_SCHEMA.VIEWS
en su lugar.
La vista INFORMATION_SCHEMA.TABLE_OPTIONS
tiene el siguiente esquema:
Nombre de la columna | Tipo de datos | Valor |
---|---|---|
TABLE_CATALOG |
STRING |
El ID del proyecto que contiene el conjunto de datos |
TABLE_SCHEMA |
STRING |
El nombre del conjunto de datos que contiene la tabla o la vista (también denominado datasetId ) |
TABLE_NAME |
STRING |
El nombre de la tabla o la vista (también denominado tableId ) |
OPTION_NAME |
STRING |
Uno de los valores de nombre de la tabla de opciones |
OPTION_TYPE |
STRING |
Uno de los valores de tipo de datos en la tabla de opciones |
OPTION_VALUE |
STRING |
Una de las opciones de valor en la tabla de opciones |
Tabla de opciones
OPTION_NAME |
OPTION_TYPE |
OPTION_VALUE |
---|---|---|
partition_expiration_days |
FLOAT64 |
El ciclo de vida predeterminado de todas las particiones de una tabla particionada, expresado en días |
expiration_timestamp |
FLOAT64 |
La hora a la que vence esta tabla |
kms_key_name |
STRING |
El nombre de la clave de Cloud KMS que se usa para encriptar la tabla |
friendly_name |
STRING |
El nombre descriptivo de la tabla |
description |
STRING |
Una descripción de la tabla |
labels |
ARRAY<STRUCT<STRING, STRING>> |
Un arreglo de STRUCT que representa las etiquetas de la tabla |
require_partition_filter |
BOOL |
Si las consultas sobre la tabla requieren un filtro de partición |
enable_refresh |
BOOL |
Indica si la actualización automática está habilitada para una vista materializada |
refresh_interval_minutes |
FLOAT64 |
Frecuencia con la que se actualiza una vista materializada |
En el caso de las tablas externas, son posibles las siguientes opciones:
Opciones | |
---|---|
allow_jagged_rows |
Si es Se aplica a los datos CSV. |
allow_quoted_newlines |
Si es Se aplica a los datos CSV. |
bigtable_options |
Solo es necesaria cuando se crea una tabla externa de Bigtable. Especifica el esquema de la tabla externa de Bigtable en formato JSON. Para obtener una lista de las opciones de definición de tablas de Bigtable, consulta |
compression |
El tipo de compresión de la fuente de datos. Entre los valores admitidos, se incluyen los siguientes: Se aplica a los datos CSV y JSON. |
decimal_target_types |
Determina cómo convertir un tipo Ejemplo: |
description |
Una descripción de esta tabla. |
enable_list_inference |
Si es Se aplica a los datos de Parquet. |
enable_logical_types |
Si es Se aplica a los datos de Avro. |
encoding |
La codificación de caracteres de los datos. Los valores admitidos son los siguientes: Se aplica a los datos CSV. |
enum_as_string |
Si es Se aplica a los datos de Parquet. |
expiration_timestamp |
La hora a la que vence esta tabla. Si no se especifica, la tabla no expira. Ejemplo: |
field_delimiter |
El separador de campos de un archivo CSV (opcional). Se aplica a los datos CSV. |
format |
El formato de los datos externos.
Los valores admitidos para
Los valores admitidos para
El valor |
hive_partition_uri_prefix |
Prefijo común para todos los URI de origen antes de que comience la codificación de la clave de partición. Se aplica solo a las tablas externas particionadas de subárbol. Se aplica a los datos de Avro, CSV, JSON, Parquet y ORC. Ejemplo: |
ignore_unknown_values |
Si es Se aplica a los datos CSV y JSON. |
json_extension |
Para los datos JSON, indica un formato de intercambio JSON en particular. Si no se especifica, BigQuery lee los datos como registros JSON genéricos. Entre los valores admitidos, se incluyen los siguientes: |
max_bad_records |
La cantidad máxima de registros erróneos que se deben ignorar cuando se leen los datos. Se aplica a los datos CSV, JSON y de Hojas de cálculo de Google. |
max_staleness |
Aplicable a las tablas de BigLake y las tablas de objetos. En vista previa. Especifica si las operaciones en la tabla usan los metadatos almacenados en caché y qué tan recientes deben ser los metadatos almacenados en caché para que la operación los use. Para inhabilitar el almacenamiento en caché de metadatos, especifica 0. Esta es la opción predeterminada. Para habilitar el almacenamiento en caché de metadatos, especifica un valor de intervalo literal entre 30 minutos y 7 días. Por ejemplo, especifica |
metadata_cache_mode |
Aplicable a las tablas de BigLake y las tablas de objetos. En vista previa. Especifica si la caché de metadatos de la tabla se actualiza de forma automática o manual. Configúralo como Configúralo como Debes configurar |
null_marker |
La string que representa los valores Se aplica a los datos CSV. |
object_metadata |
Solo es necesaria cuando se crea una tabla de objetos. En vista previa. Establece el valor de esta opción en |
preserve_ascii_control_characters |
Si es Se aplica a los datos CSV. |
projection_fields |
Una lista de propiedades de entidad para cargar. Se aplica a los datos de Datastore. |
quote |
La string que se usa para entrecomillar secciones de datos en un archivo de CSV. Si tus datos contienen caracteres de salto de línea entrecomillados, también establece la propiedad Se aplica a los datos CSV. |
reference_file_schema_uri |
El archivo de referencia proporcionado por el usuario con el esquema de tabla. Se aplica a los datos de Parquet/ORC/AVRO. Ejemplo: |
require_hive_partition_filter |
Si es Se aplica a los datos de Avro |