Las declaraciones del lenguaje de definición de datos (DDL) te permiten crear y modificar recursos de BigQuery mediante la sintaxis de consultas SQL estándar. Actualmente, puedes usar comandos de DDL en BigQuery para las siguientes tareas:
- Crear tablas, vistas y funciones definidas por el usuario (UDF)
- Alterar tablas
- Borrar tablas y vistas
Ejecuta declaraciones de DDL
Puedes ejecutar declaraciones de DDL con Cloud Console, con la herramienta de línea de comandos de bq, una llamada a la API de REST de jobs.query o de manera programática con las bibliotecas cliente de la API de BigQuery.
Console
Ve a la página de BigQuery en Cloud Console.
Haz clic en Redactar consulta nueva.
Ingresa la declaración DDL en el área de texto Editor de consultas. Por ejemplo:
CREATE TABLE mydataset.newtable ( x INT64 )
Haz clic en Ejecutar.
bq
Ingresa el comando bq query y proporciona la declaración DDL como parámetro de consulta. Establece la marca use_legacy_sql en false.
bq query --use_legacy_sql=false \ 'CREATE TABLE mydataset.newtable ( x INT64 )'
API
Llama al método jobs.query y proporciona la declaración de DDL en la propiedad query del cuerpo de la solicitud.
La funcionalidad de DDL amplía la información que muestra un recurso Jobs.
statistics.query.statementType incluye los siguientes valores adicionales para la compatibilidad con DDL:
CREATE_TABLECREATE_TABLE_AS_SELECTDROP_TABLECREATE_VIEWDROP_VIEW
statistics.query tiene 2 campos adicionales:
ddlOperationPerformed: la operación de DDL realizada, que posiblemente depende de la existencia del objetivo de DDL. Entre los valores actuales, se incluyen los siguientes:CREATE: la consulta creó el objetivo de DDL.SKIP: no-ops. Ejemplos: se envióCREATE TABLE IF NOT EXISTSy la tabla existe. O se envióDROP TABLE IF EXISTSy la tabla no existe.REPLACE: la consulta reemplazó el objetivo de DDL. Ejemplo: se envióCREATE OR REPLACE TABLEy la tabla ya existe.DROP: la consulta borró el objetivo de DDL.
ddlTargetTable: cuando envías una declaraciónCREATE TABLE/VIEWoDROP TABLE/VIEW, la tabla de destino se muestra como un objeto con 3 campos:- "projectId": string
- "datasetId": string
- "tableId": string
Java
Llama al método BigQuery.create() para iniciar un trabajo de consulta. Llama al método Job.waitFor() para esperar a que finalice la consulta de DDL.
Node.js
Python
Llama al método Client.query() para iniciar un trabajo de consulta. Llama al método QueryJob.result() para esperar a que finalice la consulta de DDL.
Declaración CREATE SCHEMA
Crea un conjunto de datos.
Para ejecutar esta declaración, debes tener permisos bigquery.datasets.create. El conjunto de datos se crea en la ubicación que especificas en la configuración de la consulta. Para obtener más información, consulta Especifica tu ubicación.
Para obtener más información sobre la creación de un conjunto de datos, consulta Crea conjuntos de datos. Para obtener más información sobre las cuotas, consulta Límites de conjuntos de datos.
CREATE SCHEMA [IF NOT EXISTS] [project_name.]dataset_name [OPTIONS(schema_option_list)]
Aquí:
IF NOT EXISTS: si incluyes esta cláusula y el conjunto de datos ya existe, la declaración se realiza de forma correcta y no realiza ninguna acción. Si omites esta cláusula y el conjunto de datos ya existe, la declaración muestra un error.project_namees el nombre del proyecto en el que crearás el procedimiento. La configuración predeterminada es el proyecto que ejecuta esta declaración de DDL.dataset_namees el nombre del conjunto de datos que se creará.schema_option_listespecifica una lista de opciones para crear el conjunto de datos.
schema_option_list
La lista de opciones especifica las opciones para el conjunto de datos. Especifica las opciones en el siguiente formato: NAME=VALUE, ...
Se admiten las siguientes opciones:
NAME |
VALUE |
Detalles |
|---|---|---|
default_kms_key_name |
STRING |
Especifica la clave predeterminada de Cloud KMS para encriptar los datos de la tabla en este conjunto de datos. Puedes anular este valor cuando creas una tabla. |
default_partition_expiration_days |
FLOAT64 |
Especifica el tiempo de vencimiento predeterminado (en días) de las particiones de tabla en este conjunto de datos. Puedes anular este valor cuando creas una tabla. |
default_table_expiration_days |
FLOAT64 |
Especifica el tiempo de vencimiento predeterminado (en días) de las tablas de este conjunto de datos. Puedes anular este valor cuando creas una tabla. |
description |
STRING |
Es la descripción del conjunto de datos. |
friendly_name |
STRING |
Es un nombre descriptivo para el conjunto de datos. |
labels |
<ARRAY<STRUCT<STRING, STRING>>> |
Un arreglo de etiquetas para el conjunto de datos, expresado como pares clave-valor. |
Ejemplo
En el ejemplo siguiente, se crea un conjunto de datos con un vencimiento predeterminado de la tabla y un conjunto de etiquetas.
CREATE SCHEMA mydataset
OPTIONS(
default_table_expiration_days=3.75,
labels=[("label1","value1"),("label2","value2")]
)
Declaración CREATE TABLE
Para crear una tabla en BigQuery, usa la declaración DDL CREATE TABLE.
{CREATE TABLE | CREATE TABLE IF NOT EXISTS | CREATE OR REPLACE TABLE}
[[project_name.]dataset_name.]table_name
[(
column_name column_schema[, ...]
)]
[PARTITION BY partition_expression]
[CLUSTER BY clustering_column_list]
[OPTIONS(table_option_list)]
[AS query_statement]
Aquí:
{CREATE TABLE | CREATE TABLE IF NOT EXISTS | CREATE OR REPLACE TABLE} es una de las siguientes declaraciones:
CREATE TABLE: crea una nueva tabla.CREATE TABLE IF NOT EXISTS: crea una nueva tabla solo si la tabla no existe actualmente en el conjunto de datos especificado.CREATE OR REPLACE TABLE: crea una tabla y reemplaza una tabla existente con el mismo nombre en el conjunto de datos especificado.
Las declaraciones CREATE TABLE deben cumplir con las siguientes reglas:
- Se permite solo una declaración
CREATE. - La lista de columnas, la cláusula
as query_statemento ambas deben estar presentes. - Cuando tanto la lista de columnas como la cláusula
as query_statementestán presentes, BigQuery ignora los nombres en la cláusulaas query_statementy hace coincidir las columnas con la lista de columnas por posición. - Cuando la cláusula
as query_statementestá presente, pero la lista de columnas está ausente, BigQuery determina los nombres y tipos de columnas a partir de la cláusulaas query_statement. - Los nombres de las columnas deben especificarse mediante la lista de columnas o con la cláusula
as query_statement. - No se permiten nombres de columnas duplicados.
Ruta de acceso de la tabla
project_name es el nombre del proyecto en el que crearás la tabla.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos en el que crearás la tabla.
El valor predeterminado es defaultDataset en la solicitud.
table_name es el nombre de la tabla que creas.
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.
Por ejemplo, los siguientes son nombres de tabla válidos: table-01, ग्राहक, 00_お客様, étudiant.
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.
column_name y column_schema
(column_name column_schema[, ...]) contiene la información de esquema de la tabla en una lista separada por comas:
column_namees el nombre de la columna. Los nombres de columnas deben tener las siguientes características:- Contener solo letras (a-z, A-Z), números (0-9) o guiones bajos (_)
- Comenzar con una letra o un guion bajo
- Tener un máximo de 300 caracteres
column_schemaes similar a un tipo de datos, pero admite una restricciónNOT NULLopcional para tipos distintos deARRAY.column_schematambién admite opciones en columnas de nivel superior y camposSTRUCT.
column_schema :=
{simple_type [NOT NULL] |
STRUCT<field_list> [NOT NULL] |
ARRAY<array_element_schema>}
[OPTIONS(column_option_list)]
field_list := field_name column_schema [, ...]
array_element_schema := {simple_type | STRUCT<field_list>} [NOT NULL]
simple_type es cualquier tipo de datos compatible aparte de STRUCT y ARRAY.
field_name es el nombre del campo struct. Los nombres de los campos struct tienen las mismas restricciones que los nombres de columnas.
Cuando la restricción NOT NULL está presente para una columna o un campo, la columna o el campo se crean con el modo REQUIRED. Por el contrario, cuando la restricción NOT NULL está ausente, la columna o el campo se crean con el modo NULLABLE.
Las columnas y los campos del tipo ARRAY no son compatibles con el modificador NOT NULL. Por ejemplo, un column_schema de ARRAY<INT64> NOT NULL no es válido, ya que las columnas ARRAY tienen el modo REPEATED y pueden estar vacías, pero no pueden ser NULL. Un elemento ARRAY en una tabla nunca puede ser NULL, independientemente de si se especifica la restricción NOT NULL. Por ejemplo, ARRAY<INT64> es equivalente a ARRAY<INT64 NOT NULL>.
El atributo NOT NULL del column_schema de una tabla no se propaga a través de las consultas en la tabla. Si la tabla T contiene una columna declarada como x INT64 NOT NULL, por ejemplo, CREATE TABLE dataset.newtable AS SELECT x FROM T crea una tabla llamada dataset.newtable en la que x es NULLABLE.
column_schema solo se puede usar en la lista de definición de columnas de las declaraciones CREATE TABLE. No se puede utilizar como tipo en las expresiones. Por ejemplo, CAST(1 AS INT64 NOT NULL) no es válido.
partition_expression
PARTITION BY es una cláusula opcional que controla la partición de la tabla. partition_expression es una expresión que determina cómo particionar la tabla. La expresión de partición puede contener los siguientes valores:
_PARTITIONDATE”. Partición por tiempo de transferencia con particiones diarias Esta sintaxis no se puede usar con la cláusulaAS query_statement.DATE(_PARTITIONTIME): Equivale a_PARTITIONDATE. Esta sintaxis no se puede usar con la cláusulaAS query_statement.<date_column>. Partición por una columnaDATEcon particiones diarias.DATE({ <timestamp_column> | <datetime_column> }). Partición por una columnaTIMESTAMPoDATETIMEcon particiones diarias.DATETIME_TRUNC(<datetime_column>, { DAY | HOUR | MONTH | YEAR }). Partición por una columnaDATETIMEcon el tipo de partición especificado.TIMESTAMP_TRUNC(<timestamp_column>, { DAY | HOUR | MONTH | YEAR }). Partición por una columnaTIMESTAMPcon el tipo de partición especificado.TIMESTAMP_TRUNC(_PARTITIONTIME, { DAY | HOUR | MONTH | YEAR })”. Partición por tiempo de transferencia con el tipo de partición especificado. Esta sintaxis no se puede usar con la cláusulaAS query_statement.DATE_TRUNC(<date_column>, { MONTH | YEAR }). Partición por una columnaDATEcon el tipo de partición especificado.RANGE_BUCKET(<int64_column>, GENERATE_ARRAY(<start>, <end>[, <interval>])). Partición por una columna de números enteros con el rango especificado, en el que:startes el inicio de la partición por rango (inclusivo).endes el final de la partición por rango (exclusivo).intervales el ancho de cada rango dentro de la partición. El valor predeterminado es 1.
clustering_column_list
CLUSTER BY es una cláusula opcional que controla el agrupamiento en clústeres de la tabla.
clustering_column_list es una lista separada por comas que determina cómo agrupar la tabla. La lista de columnas de agrupación en clústeres puede contener un máximo de cuatro de estas columnas.
table_option_list
La lista de opciones te permite establecer las opciones de la tabla, como una etiqueta y una fecha y hora de vencimiento. Puedes incluir varias opciones mediante una lista separada por comas.
Especifica una lista de opciones de la tabla con el siguiente formato:
NAME=VALUE, ...
La combinación de NAME y VALUE debe ser una de las siguientes:
NAME |
VALUE |
Detalles |
|---|---|---|
expiration_timestamp |
TIMESTAMP |
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla expirationTime. |
partition_expiration_days |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla timePartitioning.expirationMs, pero utiliza días en lugar de milisegundos. Un día equivale a 86,400,000 milisegundos o 24 horas. Esta propiedad solo se puede configurar si la tabla está particionada. |
require_partition_filter |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla timePartitioning.requirePartitionFilter. Esta propiedad solo se puede configurar si la tabla está particionada. |
kms_key_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla encryptionConfiguration.kmsKeyName. Para obtener más detalles, consulta Cómo proteger los datos con claves de Cloud KMS. |
friendly_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla friendlyName. |
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla description. |
labels |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla labels. |
VALUE es una expresión constante que contiene solo literales, parámetros de búsqueda y funciones escalares. Si la expresión constante se evalúa como null, el NAME de la opción correspondiente se ignora.
La expresión constante no puede contener lo siguiente:
- Una referencia a una tabla
- Subconsultas o instrucciones de SQL, como
SELECT,CREATEyUPDATE - Funciones definidas por el usuario, funciones agregadas o funciones estadísticas
- Las siguientes funciones escalares:
ARRAY_TO_STRINGREPLACEREGEXP_REPLACERANDFORMATLPADRPADREPEATSESSION_USERGENERATE_ARRAYGENERATE_DATE_ARRAY
column_option_list
La column_option_list de column_schema te permite especificar opciones de campo o columna opcionales. Las opciones de columna tienen la misma sintaxis y los mismos requisitos que las opciones de tabla, pero la lista de elementos NAME y VALUE difiere:
NAME |
VALUE |
Detalles |
|---|---|---|
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla schema.fields[].description. |
query_statement
La cláusula AS query_statement especifica la consulta a partir de la cual se debe crear la tabla. Consulta la Sintaxis de consultas de SQL estándar para conocer la forma compatible de query_statement.
Limitaciones conocidas:
- No es posible crear una tabla particionada por tiempo de transferencia a partir del resultado de una consulta. En cambio, usa una declaración DDL
CREATE TABLEpara crear la tabla y, luego, utiliza una Declaración DMLINSERTa fin de ingresar datos. - No es posible utilizar el modificador
OR REPLACEpara reemplazar una tabla con un tipo diferente de partición. En su lugar, descarta la tabla (conDROP) y usa una declaraciónCREATE TABLE ... AS SELECT ...para volver a crearla.
Tablas temporales
Para crear una tabla temporal, usa la palabra clave TEMP o TEMPORARY cuando uses la declaración CREATE TABLE.
Sintaxis
{ CREATE {TEMP|TEMPORARY} TABLE |
CREATE {TEMP|TEMPORARY} TABLE IF NOT EXISTS |
CREATE OR REPLACE {TEMP|TEMPORARY} TABLE } ...
Además del uso de TEMP o TEMPORARY, la sintaxis es idéntica a la sintaxis CREATE TABLE.
No califiques los nombres de tablas temporales, es decir, no uses un calificador de proyecto o de conjunto de datos. Las tablas temporales se crean automáticamente en un conjunto de datos especial.
Puedes hacer referencia a una tabla temporal por nombre mientras dure la secuencia de comandos actual. Para obtener más información, consulta Secuencias de comandos en SQL estándar. También se incluyen las tablas creadas por un procedimiento dentro de la secuencia de comandos. No puedes consultar una tabla una vez que se creó la secuencia de comandos en su totalidad.
Cuando finaliza una secuencia de comandos, la tabla temporal existe por hasta 24 horas. No se guarda con el nombre que le asignaste, sino que se le asigna uno aleatorio. Para ver los datos y la estructura de la tabla, ve a Consola de BigQuery, haz clic en Historial de consultas y elige la consulta que creó la tabla temporal. Luego, en la fila Tabla de destino, haz clic en Tabla temporal.
No puedes compartir tablas temporales y no son visibles con ninguno de los métodos de lista estándar o de manipulación de tablas. No se te cobrará por almacenar tablas temporales.
Para crear una tabla temporal, sigue estos pasos:
CREATE TEMP TABLE Example
(
x INT64,
y STRING
);
INSERT INTO Example
VALUES (5, 'foo');
INSERT INTO Example
VALUES (6, 'bar');
SELECT *
FROM Example;
Esta secuencia de comandos muestra el siguiente resultado:
+-----+---+-----+
| Row | x | y |
+-----+---|-----+
| 1 | 5 | foo |
| 2 | 6 | bar |
+-----+---|-----+
Puedes eliminar una tabla temporal explícitamente antes de que se complete la secuencia de comandos mediante la ejecución de una declaración DROP TABLE:
CREATE TEMP TABLE foo(x INT64);
SELECT * FROM foo; -- Succeeds
DROP TABLE foo;
SELECT * FROM foo; -- Results in an error
Cuando se usan tablas temporales con un conjunto de datos predeterminado, los nombres de tablas no calificados se refieren a lo siguiente:
- una tabla temporal, si existe una
- de lo contrario, una tabla en el conjunto de datos predeterminado
La excepción es para las declaraciones CREATE TABLE, en las que la tabla de destino se considera una tabla temporal solo si está presente la palabra clave TEMP o TEMPORARY.
Por ejemplo, considera la siguiente secuencia de comandos:
-- Create table t1 in the default dataset
CREATE TABLE t1 (x INT64);
-- Create temporary table t1
CREATE TEMP TABLE t1 (x INT64);
-- This statement will select from the temporary table
SELECT * FROM t1;
-- Drop the temporary table
DROP TABLE t1;
-- Now that the temporary table is dropped, this statement will select from
-- the table in the default dataset
SELECT * FROM t1;
Puedes indicar explícitamente que se refiere a una tabla temporal si calificas el nombre de la tabla con _SESSION:
-- Create a temp table CREATE TEMP TABLE t1 (x INT64); -- Create a temp table using the `_SESSION` qualifier CREATE TEMP TABLE _SESSION.t2 (x INT64); -- Select from a temporary table using the `_SESSION` qualifier SELECT * FROM _SESSION.t1;
Si usas el calificador _SESSION para una consulta de una tabla temporal que no existe, recibirás un error que indica que la tabla no existe. Por ejemplo, si no hay una tabla temporal llamada t3, recibirás el error incluso si existe una tabla llamada t3 en el conjunto de datos predeterminado.
No puedes usar _SESSION para crear una tabla no temporal:
CREATE TABLE _SESSION.t4 (x INT64); -- Fails
Ejemplos
Crea una tabla nueva
En el siguiente ejemplo, se crea una tabla particionada llamada newtable en mydataset.
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
>
)
PARTITION BY _PARTITIONDATE
OPTIONS(
expiration_timestamp=TIMESTAMP "2025-01-01 00:00:00 UTC",
partition_expiration_days=1,
description="a table that expires in 2025, with each partition living for 24 hours",
labels=[("org_unit", "development")]
)
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.newtable, el calificador de tabla podría ser `myproject.mydataset.newtable`.
Si el nombre de la tabla ya existe en el conjunto de datos, se muestra el siguiente error:
Already Exists: project_id:dataset.table
La tabla usa las siguientes partition_expression para particionar la tabla: PARTITION BY _PARTITIONDATE. Esta expresión particiona la tabla con la fecha en la seudocolumna _PARTITIONDATE.
El esquema de la tabla contiene dos columnas:
- x: un número entero, con la descripción “Un campo opcional de NÚMERO ENTERO”
y: UNA STRUCT que contiene dos columnas:
- a: un arreglo de strings, con la descripción “Un campo de STRING repetido”
- b: un valor booleano
La lista de opciones de la tabla especifica lo siguiente:
- Fecha y hora de vencimiento de la tabla: 1 de enero de 2025, a las 00:00:00 UTC
- Vencimiento de la partición: 1 día
- Descripción: Una tabla que vence en 2025
- Etiqueta: org_unit = desarrollo
Crea una tabla nueva a partir de una tabla existente
En el siguiente ejemplo, se crea una tabla llamada top_words en mydataset a partir de una consulta:
CREATE TABLE mydataset.top_words OPTIONS( description="Top ten words per Shakespeare corpus" ) AS SELECT corpus, ARRAY_AGG(STRUCT(word, word_count) ORDER BY word_count DESC LIMIT 10) AS top_words FROM bigquery-public-data.samples.shakespeare GROUP BY corpus;
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.top_words, el calificador de tabla podría ser `myproject.mydataset.top_words`.
Si el nombre de la tabla ya existe en el conjunto de datos, se muestra el siguiente error:
Already Exists: project_id:dataset.table
El esquema de la tabla contiene 2 columnas:
- corpus: el nombre de un corpus de Shakespeare
top_words : un
ARRAYdeSTRUCTque contiene 2 campos:word(unaSTRING) yword_count(unINT64con el recuento de palabras )
La lista de opciones de la tabla especifica lo siguiente:
- Descripción: diez palabras más frecuentes según el corpus de Shakespeare
Crea una tabla solo si no existe
En el siguiente ejemplo, se crea una tabla llamada newtable en mydataset solo si no existe una tabla llamada newtable en mydataset. Si el nombre de la tabla existe en el conjunto de datos, no se muestra ningún error y no se realiza ninguna acción.
CREATE TABLE IF NOT EXISTS mydataset.newtable (x INT64, y STRUCT<a ARRAY<STRING>, b BOOL>)
OPTIONS(
expiration_timestamp=TIMESTAMP "2025-01-01 00:00:00 UTC",
description="a table that expires in 2025",
labels=[("org_unit", "development")]
)
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.newtable, el calificador de tabla podría ser `myproject.mydataset.newtable`.
El esquema de la tabla contiene 2 columnas:
- x: un número entero
y: un STRUCT que contiene a (un arreglo de strings) y b (un valor booleano)
La lista de opciones de la tabla especifica lo siguiente:
- Fecha y hora de vencimiento: 1 de enero de 2025, a las 00:00:00 UTC
- Descripción: Una tabla que vence en 2025
- Etiqueta: org_unit = desarrollo
Crea o reemplaza una tabla
En el siguiente ejemplo, se crea una tabla llamada newtable en mydataset y, si newtable existe en mydataset, se la reemplaza por una tabla vacía.
CREATE OR REPLACE TABLE mydataset.newtable (x INT64, y STRUCT<a ARRAY<STRING>, b BOOL>)
OPTIONS(
expiration_timestamp=TIMESTAMP "2025-01-01 00:00:00 UTC",
description="a table that expires in 2025",
labels=[("org_unit", "development")]
)
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.newtable, el calificador de tabla podría ser `myproject.mydataset.newtable`.
El esquema de la tabla contiene 2 columnas:
- x: un número entero
y: un STRUCT que contiene a (un arreglo de strings) y b (un valor booleano)
La lista de opciones de la tabla especifica lo siguiente:
- Fecha y hora de vencimiento: 1 de enero de 2025, a las 00:00:00 UTC
- Descripción: Una tabla que vence en 2025
- Etiqueta: org_unit = desarrollo
Crea una tabla con columnas REQUIRED
En el siguiente ejemplo, se crea una tabla llamada newtable en mydataset. El modificador NOT
NULL en la lista de definición de columnas de una declaración CREATE TABLE especifica que una columna o un campo se crea en modo REQUIRED.
CREATE TABLE my_dataset.new_table (
x INT64 NOT NULL,
y STRUCT<
a ARRAY<STRING>,
b BOOL NOT NULL,
c FLOAT64
> NOT NULL,
z STRING
)
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de my_dataset.new_table, el calificador de tabla podría ser `myproject.my_dataset.new_table`.
Si el nombre de la tabla ya existe en el conjunto de datos, se muestra el siguiente error:
Already Exists: project_id:dataset.table
El esquema de la tabla contiene 3 columnas:
- x: un número entero
REQUIRED - y: un STRUCT
REQUIREDque contiene a (un arreglo de strings), b (un valor booleanoREQUIRED) y c (un valor flotanteNULLABLE) z: una string
NULLABLE
Crea una tabla con particiones
En el siguiente ejemplo, se crea una tabla particionada llamada newtable en mydataset mediante una columna DATE.
CREATE TABLE mydataset.newtable (transaction_id INT64, transaction_date DATE) PARTITION BY transaction_date OPTIONS( partition_expiration_days=3, description="a table partitioned by transaction_date" )
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.newtable, el calificador de tabla podría ser `myproject.mydataset.newtable`.
El esquema de la tabla contiene 2 columnas:
- transaction_id: un número entero
- transaction_date: una fecha
La lista de opciones de la tabla especifica lo siguiente:
- Vencimiento de la partición: tres días
- Descripción : una tabla particionada por
transaction_date
Crea una tabla con particiones a partir del resultado de una consulta
En el siguiente ejemplo, se crea una tabla particionada llamada days_with_rain en mydataset mediante una columna DATE.
CREATE TABLE mydataset.days_with_rain PARTITION BY date OPTIONS ( partition_expiration_days=365, description="weather stations with precipitation, partitioned by day" ) AS SELECT DATE(CAST(year AS INT64), CAST(mo AS INT64), CAST(da AS INT64)) AS date, (SELECT ANY_VALUE(name) FROM `bigquery-public-data.noaa_gsod.stations` AS stations WHERE stations.usaf = stn) AS station_name, -- Stations can have multiple names prcp FROM `bigquery-public-data.noaa_gsod.gsod2017` AS weather WHERE prcp != 99.9 -- Filter unknown values AND prcp > 0 -- Filter stations/days with no precipitation
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.days_with_rain, el calificador de tabla podría ser `myproject.mydataset.days_with_rain`.
El esquema de la tabla contiene 2 columnas:
- date: la
DATEde recopilación de los datos - station_name: el nombre de la estación meteorológica como un valor
STRING - prcp: el volumen de precipitaciones en pulgadas como un valor
FLOAT64
La lista de opciones de la tabla especifica lo siguiente:
- Vencimiento de la partición: un año
- Descripción: estaciones meteorológicas con precipitaciones, particionada por día
Crea una tabla agrupada en clústeres
Ejemplo 1
En el siguiente ejemplo, se crea una tabla agrupada en clústeres llamada myclusteredtable en mydataset. La tabla es una tabla particionada; particionada por una columna TIMESTAMP y agrupada por una columna STRING llamada customer_id.
CREATE TABLE mydataset.myclusteredtable ( timestamp TIMESTAMP, customer_id STRING, transaction_amount NUMERIC ) PARTITION BY DATE(timestamp) CLUSTER BY customer_id OPTIONS ( partition_expiration_days=3, description="a table clustered by customer_id" )
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.myclusteredtable, el calificador de tabla podría ser `myproject.mydataset.myclusteredtable`.
El esquema de la tabla contiene 3 columnas:
- timestamp: la fecha y hora de recopilación de los datos como
TIMESTAMP - customer_id: El ID de cliente como
STRING - transaction_amount: el importe de la transacción como
NUMERIC
La lista de opciones de la tabla especifica lo siguiente:
- Vencimiento de la partición: 3 días
- Descripción: "Una tabla agrupada en clústeres por customer_id"
Ejemplo 2
En el siguiente ejemplo, se crea una tabla agrupada en clústeres llamada myclusteredtable en mydataset. Es una tabla particionada por tiempo de transferencia.
CREATE TABLE mydataset.myclusteredtable ( customer_id STRING, transaction_amount NUMERIC ) PARTITION BY DATE(_PARTITIONTIME) CLUSTER BY customer_id OPTIONS ( partition_expiration_days=3, description="a table clustered by customer_id" )
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.myclusteredtable, el calificador de tabla podría ser `myproject.mydataset.myclusteredtable`.
El esquema de la tabla contiene 2 columnas:
- customer_id: El ID de cliente como
STRING - transaction_amount: el importe de la transacción como
NUMERIC
La lista de opciones de la tabla especifica lo siguiente:
- Vencimiento de la partición: 3 días
- Descripción: "Una tabla agrupada en clústeres por customer_id"
Ejemplo 3
En el siguiente ejemplo, se crea una tabla agrupada en clústeres llamada myclusteredtable en mydataset. La tabla no está particionada.
CREATE TABLE mydataset.myclusteredtable ( customer_id STRING, transaction_amount NUMERIC ) CLUSTER BY customer_id OPTIONS ( description="a table clustered by customer_id" )
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.myclusteredtable, el calificador de tabla podría ser `myproject.mydataset.myclusteredtable`.
El esquema de la tabla contiene 2 columnas:
- customer_id: El ID de cliente como
STRING - transaction_amount: el importe de la transacción como
NUMERIC
La lista de opciones de la tabla especifica lo siguiente:
- Descripción: "Una tabla agrupada en clústeres por customer_id"
Crea una tabla agrupada en clústeres a partir del resultado de una consulta
Ejemplo 1
En el siguiente ejemplo, se crea una tabla agrupada en clústeres llamada myclusteredtable en mydataset con el resultado de una consulta. Se trata de una tabla particionada por una columna TIMESTAMP.
CREATE TABLE mydataset.myclusteredtable ( timestamp TIMESTAMP, customer_id STRING, transaction_amount NUMERIC ) PARTITION BY DATE(timestamp) CLUSTER BY customer_id OPTIONS ( partition_expiration_days=3, description="a table clustered by customer_id" ) AS SELECT * FROM mydataset.myothertable
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.myclusteredtable, el calificador de tabla podría ser `myproject.mydataset.myclusteredtable`.
El esquema de la tabla contiene 3 columnas:
- timestamp: la fecha y hora de recopilación de los datos como
TIMESTAMP - customer_id: El ID de cliente como
STRING - transaction_amount: el importe de la transacción como
NUMERIC
La lista de opciones de la tabla especifica lo siguiente:
- Vencimiento de la partición: 3 días
- Descripción: "Una tabla agrupada en clústeres por customer_id"
Ejemplo 2
En el siguiente ejemplo, se crea una tabla agrupada en clústeres llamada myclusteredtable en mydataset con el resultado de una consulta. La tabla no está particionada.
CREATE TABLE mydataset.myclusteredtable ( customer_id STRING, transaction_amount NUMERIC ) CLUSTER BY customer_id OPTIONS ( description="a table clustered by customer_id" ) AS SELECT * FROM mydataset.myothertable
Si no configuraste un proyecto predeterminado, antepón un ID del proyecto al nombre del conjunto de datos en el SQL de ejemplo y escribe el nombre entre acentos graves si project_id contiene caracteres especiales: `project_id.dataset.table`. Por lo tanto, en lugar de mydataset.myclusteredtable, el calificador de tabla podría ser `myproject.mydataset.myclusteredtable`.
El esquema de la tabla contiene 2 columnas:
- customer_id: El ID de cliente como
STRING - transaction_amount: el importe de la transacción como
NUMERIC
La lista de opciones de la tabla especifica lo siguiente:
- Descripción: "Una tabla agrupada en clústeres por customer_id"
Declaración CREATE VIEW
Para crear una vista en BigQuery, usa la declaración DDL CREATE VIEW.
{CREATE VIEW | CREATE VIEW IF NOT EXISTS | CREATE OR REPLACE VIEW}
[[project_name.]dataset_name.]view_name
[OPTIONS(view_option_list)]
AS query_expression
Aquí:
{CREATE VIEW | CREATE VIEW IF NOT EXISTS | CREATE OR REPLACE VIEW} es una de las siguientes declaraciones:
CREATE VIEW: crea una nueva vista.CREATE VIEW IF NOT EXISTS: crea una nueva vista solo si la vista no existe actualmente en el conjunto de datos especificado.CREATE OR REPLACE VIEW: crea una vista y reemplaza una existente con el mismo nombre en el conjunto de datos especificado.
project_name es el nombre del proyecto en el que crearás la vista.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos en el que crearás la vista.
El valor predeterminado es defaultDataset en la solicitud.
view_name es el nombre de la vista que crearás. El nombre de la vista debe ser único por conjunto de datos. El nombre de la vista debe cumplir los siguientes requisitos:
- Contiene hasta 1,024 caracteres
- Contener letras (mayúsculas o minúsculas), números y guiones bajos
view_option_list te permite especificar opciones adicionales de creación de vistas, como una etiqueta y una fecha y hora de vencimiento.
Las declaraciones CREATE VIEW deben cumplir con las siguientes reglas:
- Se permite solo una declaración
CREATE.
query_expression es la expresión de consulta de SQL estándar utilizada para definir la vista.
view_option_list
La lista de opciones te permite establecer las opciones de la vista, como una etiqueta y una fecha y hora de vencimiento. Puedes incluir varias opciones mediante una lista separada por comas.
Especifica una lista de opciones de la vista en el siguiente formato:
NAME=VALUE, ...
La combinación de NAME y VALUE debe ser una de las siguientes:
NAME |
VALUE |
Detalles |
|---|---|---|
expiration_timestamp |
TIMESTAMP |
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla expirationTime. |
friendly_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla friendlyName. |
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla description. |
labels |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla labels. |
VALUE es una expresión constante que contiene solo literales, parámetros de búsqueda y funciones escalares. Si la expresión constante se evalúa como null, el NAME de la opción correspondiente se ignora.
La expresión constante no puede contener lo siguiente:
- Una referencia a una tabla
- Subconsultas o instrucciones de SQL, como
SELECT,CREATEyUPDATE - Funciones definidas por el usuario, funciones agregadas o funciones estadísticas
- Las siguientes funciones escalares:
ARRAY_TO_STRINGREPLACEREGEXP_REPLACERANDFORMATLPADRPADREPEATSESSION_USERGENERATE_ARRAYGENERATE_DATE_ARRAY
Proyecto predeterminado en el cuerpo de la vista
Si la vista se crea en el mismo proyecto que se usa para ejecutar la declaración CREATE VIEW, el cuerpo de la vista query_expression puede hacer referencia a entidades sin especificar el proyecto. El proyecto predeterminado es aquel al que pertenece la vista. Considera la siguiente consulta de muestra.
CREATE VIEW myProject.myDataset.myView AS SELECT * FROM anotherDataset.myTable;
Después de ejecutar la consulta CREATE VIEW anterior en el proyecto myProject, puedes ejecutar la consulta SELECT * FROM myProject.myDataset.myView. Sin importar qué proyecto elijas para ejecutar esta consulta SELECT, la tabla anotherDataset.myTable a la que se hace referencia siempre se resuelve en el proyecto myProject.
Si la vista no se crea en el mismo proyecto que se usa para ejecutar la declaración CREATE VIEW, todas las referencias en el cuerpo de la vista query_expression deben calificarse con los ID del proyecto. Por ejemplo, la consulta CREATE VIEW de muestra anterior no es válida si se ejecuta en un proyecto diferente de myProject.
Ejemplos
Crea una vista nueva
En el siguiente ejemplo, se crea una vista llamada newview en mydataset.
CREATE VIEW `myproject.mydataset.newview`
OPTIONS(
expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR),
friendly_name="newview",
description="a view that expires in 2 days",
labels=[("org_unit", "development")]
)
AS SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
Si el nombre de la vista existe en el conjunto de datos, se muestra el siguiente error:
Already Exists: project_id:dataset.table
La vista se define con la siguiente consulta de SQL estándar:
SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La lista de opciones de vista especifica lo siguiente:
- Vencimiento: 48 horas después de la creación de la vista
- Nombre descriptivo: newview
- Descripción: una vista que vence en 2 días
- Etiqueta: org_unit = desarrollo
Crea una vista solo si no existe
En el siguiente ejemplo, se crea una vista llamada newview en mydataset solo si no existe una vista con el nombre newview en mydataset. Si el nombre de la vista existe en el conjunto de datos, no se muestra ningún error ni se realiza ninguna acción.
CREATE VIEW IF NOT EXISTS `myproject.mydataset.newview`
OPTIONS(
expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR),
friendly_name="newview",
description="a view that expires in 2 days",
labels=[("org_unit", "development")]
)
AS SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La vista se define con la siguiente consulta de SQL estándar:
SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La lista de opciones de vista especifica lo siguiente:
- Vencimiento: 48 horas después de la creación de la vista
- Nombre descriptivo: newview
- Descripción: una vista que vence en 2 días
- Etiqueta: org_unit = desarrollo
Crea o reemplaza una vista
En el siguiente ejemplo, se crea una vista llamada newview en mydataset y, si newview existe en mydataset, se reemplaza mediante la expresión de consulta especificada.
CREATE OR REPLACE VIEW `myproject.mydataset.newview`
OPTIONS(
expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR),
friendly_name="newview",
description="a view that expires in 2 days",
labels=[("org_unit", "development")]
)
AS SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La vista se define con la siguiente consulta de SQL estándar:
SELECT column_1, column_2, column_3 FROM myproject.mydataset.mytable
La lista de opciones de vista especifica lo siguiente:
- Vencimiento: 48 horas después de la creación de la vista
- Nombre descriptivo: newview
- Descripción: una vista que vence en 2 días
- Etiqueta: org_unit = desarrollo
Declaración CREATE MATERIALIZED VIEW
Para crear una vista materializada en BigQuery, usa la declaración DDL CREATE
MATERIALIZED VIEW.
{CREATE MATERIALIZED VIEW | CREATE MATERIALIZED VIEW IF NOT EXISTS }
[[project_name.]dataset_name.]materialized_view_name
[PARTITION BY partition_expression]
[CLUSTER BY clustering_column_list]
[OPTIONS(materialized_view_option_list)]
AS query_expression
Aquí:
{CREATE MATERIALIZED VIEW | CREATE MATERIALIZED VIEW IF NOT EXISTS } es una de las siguientes declaraciones:
CREATE MATERIALIZED VIEW: Crea una vista materializada nueva.CREATE MATERIALIZED VIEW IF NOT EXISTS: Crea una vista materializada nueva solo si esta no existe en el conjunto de datos especificado.
project_name es el nombre del proyecto en el que crearás la vista materializada.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
Si se omite project_name o es el mismo que el proyecto que ejecuta esta consulta de DDL, este último también se usa como el proyecto predeterminado de las referencias a tablas, funciones, etc., en query_expression (el proyecto predeterminado de las referencias es fijo y no depende de las consultas futuras que invoquen la vista materializada nueva). De lo contrario, todas las referencias en query_expression deben calificarse con proyectos.
dataset_name es el nombre del conjunto de datos en el que crearás la vista materializada.
El valor predeterminado es defaultDataset en la solicitud.
materialized_view_name es el nombre de la vista materializada que crearás.
El nombre de la vista materializada debe ser único en cada conjunto de datos. El nombre de la vista materializada tiene las siguientes características:
- Contiene hasta 1,024 caracteres
- Contener letras (mayúsculas o minúsculas), números y guiones bajos
Las cláusulas PARTITION BY y CLUSTER BY se usan como se usarían en una declaración CREATE TABLE.
Una vista materializada solo se puede particionar de la misma manera que la tabla en query expression (la tabla base).
materialized_view_option_list te permite especificar opciones adicionales de las vistas materializadas, como la habilitación de las actualizaciones, el intervalo de actualización, una etiqueta, y una fecha y hora de vencimiento.
Las declaraciones CREATE MATERIALIZED VIEW deben cumplir con la siguiente regla:
- Se permite solo una declaración
CREATE.
query_expression es la expresión de consulta de SQL estándar que se usa para definir la vista materializada.
materialized_view_option_list
La lista de opciones te permite establecer las opciones de la vista materializada, como la habilitación de las actualizaciones, el intervalo de actualización, una etiqueta, y una fecha y hora de vencimiento. Puedes incluir varias opciones mediante una lista separada por comas.
Especifica una lista de opciones de la vista materializada en el siguiente formato:
NAME=VALUE, ...
La combinación de NAME y VALUE debe ser una de las siguientes:
NAME |
VALUE |
Detalles |
|---|---|---|
enable_refresh |
BOOLEAN |
Ejemplo: |
refresh_interval_minutes |
FLOAT64 |
Ejemplo: |
expiration_timestamp |
TIMESTAMP |
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla expirationTime. |
friendly_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla friendlyName. |
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla description. |
labels |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla labels. |
Proyecto predeterminado en el cuerpo de la vista materializada
Si la vista materializada se crea en el mismo proyecto que se usa para ejecutar la declaración CREATE MATERIALIZED VIEW, el cuerpo de la vista materializada query_expression puede hacer referencia a entidades sin especificar el proyecto. El proyecto predeterminado es aquel al que pertenece la vista materializada. Considera la siguiente consulta de muestra.
CREATE MATERIALIZED VIEW myProject.myDataset.myView AS SELECT * FROM anotherDataset.myTable;
Después de ejecutar la consulta CREATE MATERIALIZED VIEW anterior en el proyecto myProject, puedes ejecutar la consulta SELECT * FROM myProject.myDataset.myView. Sin importar qué proyecto elijas para ejecutar esta consulta SELECT, la tabla anotherDataset.myTable a la que se hace referencia siempre se resuelve en el proyecto myProject.
Si la vista materializada no se crea en el mismo proyecto que se usa para ejecutar la declaración CREATE VIEW, todas las referencias en el cuerpo de la vista materializada query_expression deben calificarse con los ID del proyecto. Por ejemplo, la consulta CREATE MATERIALIZED VIEW de muestra anterior no es válida si se ejecuta en un proyecto diferente de myProject.
Ejemplos
Crea una vista materializada nueva
En el siguiente ejemplo, se crea una vista materializada llamada new_mv en mydataset.
CREATE MATERIALIZED VIEW `myproject.mydataset.new_mv`
OPTIONS(
expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR),
friendly_name="new_mv",
description="a materialized view that expires in 2 days",
labels=[("org_unit", "development")],
enable_refresh=true,
refresh_interval_minutes=20
)
AS SELECT column_1, SUM(column_2) AS sum_2, AVG(column_3) AS avg_3
FROM `myproject.mydataset.mytable`
GROUP BY column_1
Si el nombre de la vista materializada ya existe en el conjunto de datos, se muestra el siguiente error:
Already Exists: project_id:dataset.materialized_view
Cuando usas una declaración DDL para crear una vista materializada, debes especificar el proyecto, el conjunto de datos y la vista materializada en el siguiente formato: `project_id.dataset.materialized_view` (incluidos los acentos graves si project_id contiene caracteres especiales); por ejemplo, `myproject.mydataset.new_mv`.
La vista materializada se define mediante la siguiente consulta de SQL estándar:
SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La lista materializada de opciones de vista especifica lo siguiente:
- Vencimiento: 48 horas después de la creación de la vista materializada
- Nombre descriptivo: new_mv
- Descripción: una vista materializada que vence en 2 días
- Etiqueta: org_unit = desarrollo
- Actualización habilitada: verdadero
- Intervalo de actualización: 20 minutos
Crea una vista materializada solo si esta no existe
En el siguiente ejemplo, se crea una vista materializada llamada new_mv en mydataset solo si no existe una que se llame new_mv en mydataset. Si el nombre de la vista materializada ya existe en el conjunto de datos, no se muestra ningún error ni se realiza ninguna acción.
CREATE MATERIALIZED VIEW IF NOT EXISTS `myproject.mydataset.new_mv`
OPTIONS(
expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR),
friendly_name="new_mv",
description="a view that expires in 2 days",
labels=[("org_unit", "development")],
enable_refresh=false
)
AS SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La vista materializada se define mediante la siguiente consulta de SQL estándar:
SELECT column_1, column_2, column_3 FROM `myproject.mydataset.mytable`
La lista materializada de opciones de vista especifica lo siguiente:
- Vencimiento: 48 horas después de la creación de la vista
- Nombre descriptivo: new_mv
- Descripción: una vista que vence en 2 días
- Etiqueta: org_unit = desarrollo
- Actualización habilitada: falso
Crea una vista materializada con particiones y agrupamiento en clústeres
En el siguiente ejemplo, se crea una vista materializada llamada new_mv en mydataset, particionada por la columna col_datetime y agrupada por la columna col_int:
CREATE MATERIALIZED VIEW `myproject.mydataset.new_mv`
PARTITION BY DATE(col_datetime)
CLUSTER BY col_int
AS SELECT col_int, col_datetime, COUNT(1) as cnt
FROM `myproject.mydataset.mv_base_table`
GROUP BY col_int, col_datetime
La tabla base, mv_base_table, también debe particionarse con la columna col_datetime. Para obtener más información, consulta Trabaja con tablas particionadas y agrupadas.
Declaración CREATE EXTERNAL TABLE
La declaración CREATE EXTERNAL TABLE crea una tabla externa. Las tablas externas permiten que los datos de consulta de BigQuery se almacenen fuera del almacenamiento de BigQuery. Para obtener más información sobre las tablas externas, consulta Introducción a las fuentes de datos externas.
CREATE [OR REPLACE] EXTERNAL TABLE [IF NOT EXISTS] [[project_name.]dataset_name.]table_name
[(
column_name column_schema,
...
)]
[WITH PARTITION COLUMNS
[(
partition_column_name partition_column_type,
...
)]
]
OPTIONS (
external_table_option_list,
...
);
Aquí:
project_namees el nombre del proyecto en el que crearás la tabla. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL.dataset_namees el nombre del conjunto de datos en el que crearás la tabla.table_namees el nombre de la tabla externa.column_namees el nombre de una columna en la tabla.column_schemaespecifica el esquema de la columna. Usa la misma sintaxis que la definicióncolumn_schemaen la instrucciónCREATE TABLE. Si no incluyes esta cláusula, BigQuery detecta el esquema de forma automática.partition_column_namees el nombre de una columna de partición. Incluye este campo si tus datos externos usan un diseño particionado de subárbol. Para obtener más información, consulta Diseños de datos admitidos.partition_column_typees el tipo de columna de partición.external_table_option_listespecifica una lista de opciones para crear la tabla externa.
external_table_option_list
La lista de opciones especifica las opciones para crear la tabla externa. Las opciones format y uris son obligatorias. Especifica la lista de opciones en el siguiente formato: NAME=VALUE, ...
| Opciones | |
|---|---|
allow_jagged_rows |
Si es Se aplica a los datos CSV. |
allow_quoted_newlines |
Si es Se aplica a los datos CSV. |
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. |
description |
Una descripción de esta tabla. |
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. |
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 son los siguientes: El valor |
decimal_target_types |
Determina cómo convertir un tipo Ejemplo: |
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. |
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. |
null_marker |
La string que representa los valores 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. |
require_hive_partition_filter |
Si es Se aplica a los datos de Avro, CSV, JSON, Parquet y ORC. |
sheet_range |
Rango de Hojas de cálculo desde el que se realiza la búsqueda. Se aplica a los datos de Hojas de cálculo. Ejemplo: |
skip_leading_rows |
La cantidad de filas en la parte superior de un archivo que se deben omitir cuando se leen los datos. Se aplica a los datos CSV y Hojas de cálculo. |
uris |
Un arreglo de URI completamente calificados para las ubicaciones de datos externas. Ejemplo: |
La declaración CREATE EXTERNAL TABLE no admite la creación de tablas externas temporales.
Para crear una tabla particionada de forma externa, usa la cláusula WITH PARTITION COLUMNS a fin de especificar los detalles del esquema de partición. BigQuery valida las definiciones de la columna contra la ubicación de los datos externos. La declaración del esquema debe seguir estrictamente el orden de los campos en la ruta externa. Para obtener más información sobre la partición externa, visita Busca datos particionados de forma externa.
Ejemplos
En el siguiente ejemplo, se crea una tabla externa a partir de varios URI. El formato de los datos es CSV. En este ejemplo, se usa la detección automática de esquemas.
CREATE EXTERNAL TABLE dataset.CsvTable OPTIONS (
format = 'CSV',
uris = ['gs://bucket/path1.csv', 'gs://bucket/path2.csv']
);
En el siguiente ejemplo, se crea una tabla externa a partir de un archivo CSV y se especifica el esquema de forma explícita. También especifica el delimitador de campo ('|') y establece la cantidad máxima de registros erróneos permitidos.
CREATE OR REPLACE EXTERNAL TABLE dataset.CsvTable
(
x INT64,
y STRING
)
OPTIONS (
format = 'CSV',
uris = ['gs://bucket/path1.csv'],
field_delimiter = '|',
max_bad_records = 5
);
En el siguiente ejemplo, se crea una tabla particionada de forma externa. Usa la detección automática de esquemas para detectar el esquema de archivos y el diseño de partición de subárbol.
Por ejemplo, si la ruta de acceso externa es gs://bucket/path/field_1=first/field_2=1/data.csv, las columnas de partición serían field_1 (STRING) y field_2 (INT64).
CREATE EXTERNAL TABLE dataset.AutoHivePartitionedTable
WITH PARTITION COLUMNS
OPTIONS (
uris=['gs://bucket/path/*'],
format=csv,
hive_partition_uri_prefix='gs://bucket/path'
);
En el siguiente ejemplo, se crean una tabla particionada de forma externa mediante la especificación explícita de las columnas de partición. En este ejemplo, se supone que la ruta de acceso al archivo externo tiene el patrón gs://bucket/path/field_1=first/field_2=1/data.csv.
CREATE EXTERNAL TABLE dataset.CustomHivePartitionedTable
WITH PARTITION COLUMNS (
field_1 STRING, -- column order must match the external path
field_2 INT64
)
OPTIONS (
uris=['gs://bucket/path/*'],
format=csv,
hive_partition_uri_prefix='gs://bucket/path'
);
Declaración CREATE FUNCTION
BigQuery admite funciones definidas por el usuario (UDF). Una UDF te permite crear una función mediante una expresión SQL o JavaScript. Estas funciones aceptan columnas de entrada y realizan acciones, para luego mostrar el resultado de esas acciones como un valor.
Las UDF pueden ser persistentes o temporales. Puedes reutilizar las UDF persistentes en varias consultas, mientras que solo puedes usar las UDF temporales en una única consulta. Para obtener más información sobre las UDF, consulta las funciones definidas por el usuario.
Sintaxis de las UDF
Para crear una UDF persistente, usa la siguiente sintaxis:
CREATE [OR REPLACE] FUNCTION [IF NOT EXISTS] [[project_name.]dataset_name.]function_name ([named_parameter[, ...]]) [RETURNS data_type] { sql_function_definition | javascript_function_definition }
Para crear una UDF temporal, usa la siguiente sintaxis:
CREATE [OR REPLACE] {TEMPORARY | TEMP} FUNCTION [IF NOT EXISTS] function_name ([named_parameter[, ...]]) [RETURNS data_type] { sql_function_definition | javascript_function_definition }
named_parameter: param_name param_type sql_function_definition: AS (sql_expression) javascript_function_definition: [determinism_specifier] LANGUAGE js [OPTIONS (library = library_array)] AS javascript_code determinism_specifier: { DETERMINISTIC | NOT DETERMINISTIC }
Esta sintaxis consta de los siguientes componentes:
CREATE { FUNCTION | OR REPLACE FUNCTION | FUNCTION IF NOT EXISTS }. Crea una función o la actualiza. Para reemplazar una función existente con el mismo nombre, usa la palabra clave
OR REPLACE. Usa la cláusulaIF NOT EXISTSsi deseas tratar la consulta como completada y quieres que no se realice ninguna acción en el caso de que ya exista una función con el mismo nombre.project_name es el nombre del proyecto en el que crearás la función. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves
`(ejemplo:`google.com:my_project`).dataset_name es el nombre del conjunto de datos en el que crearás la función. El valor predeterminado es
defaultDataseten la solicitud.named_parameter. Consiste en un par de
param_nameyparam_typeseparados por comas. El valor deparam_typees un tipo de datos de BigQuery. Para una UDF de SQL, el valor deparam_typetambién puede serANY TYPE.determinism_specifier. Solo se aplica a las funciones definidas por el usuario de JavaScript. Proporciona una sugerencia a BigQuery para decidir si el resultado de la consulta se puede almacenar en caché. Puede ser uno de los siguientes valores:
DETERMINISTIC: La función siempre muestra el mismo resultado cuando se pasan los mismos argumentos. El resultado de la consulta puede almacenarse en caché. Por ejemplo, si la funciónadd_one(i)siempre muestrai + 1, la función es determinista.NOT DETERMINISTIC: La función no siempre muestra el mismo resultado cuando se pasa los mismos argumentos y, por lo tanto, no se puede almacenar en caché. Por ejemplo, siadd_random(i)muestrai + rand(), la función no es determinista y BigQuery no usará resultados almacenados en caché.Si todas las funciones invocadas son DETERMINISTAS, BigQuery intentará almacenar en caché el resultado, a menos que los resultados no se puedan almacenar en caché por otros motivos. Para obtener más información, consulta la sección sobre cómo usar resultados de consultas almacenados en caché.
[RETURNS data_type]. Especifica el tipo de datos que muestra la función.
- Si la función está definida en SQL, la cláusula
RETURNSes opcional. Si se omite la cláusulaRETURNS, BigQuery deduce el tipo de resultado de la función a partir del cuerpo de la función SQL cuando una consulta llama a la función. - Si la función está definida en JavaScript, la cláusula
RETURNSes obligatoria. Si deseas obtener más información sobre los valores permitidos paradata_type, consulta Tipos de datos de UDF de JavaScript admitidos.
- Si la función está definida en SQL, la cláusula
AS (sql_expression). Especifica la expresión SQL que define la función.
[OPTIONS (library = library_array)]. Para una UDF de JavaScript, especifica un arreglo de bibliotecas de JavaScript para incluir en la definición de función.
AS javascript_code. Especifica la definición de una función de JavaScript.
javascript_codees un literal de string.- Si el código incluye comillas y barras invertidas, se debe escapar
o representar como una string sin procesar. Por ejemplo, el código
return "\n";se puede representar como una de las siguientes opciones:- String entrecomillada
"return \"\\n\";". Se deben escapar las comillas y las barras invertidas. - String entre comillas triples:
"""return "\\n";""". Las barras invertidas deben escaparse, mientras que las comillas no. - String sin procesar:
r"""return "\n";""". No se necesita escape.
- String entrecomillada
- Si el código incluye comillas y barras invertidas, se debe escapar
o representar como una string sin procesar. Por ejemplo, el código
Estructura de UDF de SQL
Crea UDF de SQL con la siguiente sintaxis:
CREATE [OR REPLACE] [TEMPORARY | TEMP] FUNCTION [IF NOT EXISTS] [[`project_name`.]dataset_name.]function_name ([named_parameter[, ...]]) [RETURNS data_type] AS (sql_expression) named_parameter: param_name param_type
Parámetros de UDF de SQL con plantilla
Un parámetro con plantilla con param_type = ANY TYPE puede coincidir con más de un tipo de argumento cuando se llama a la función.
- Si hay más de un parámetro con el tipo
ANY TYPE, BigQuery no impone ninguna relación entre estos argumentos. - La función tipo de datos que se muestra no puede ser
ANY TYPE. Debe omitirse, lo que significa que se determina de forma automática en función desql_expression, o debe ser un tipo explícito. - Si pasas los argumentos de funciones de tipos que son incompatibles con la definición de la función, se producirá un error durante la llamada.
Proyecto predeterminado en el cuerpo de la UDF de SQL
Si la UDF de SQL se crea en el mismo proyecto que se usa para ejecutar la declaración CREATE FUNCTION, el cuerpo de la UDF sql_expression puede hacer referencia a entidades sin especificar el proyecto. El proyecto predeterminado es aquel al que pertenece la UDF. Considera la siguiente consulta de muestra.
CREATE FUNCTION myProject.myDataset.myFunction() AS (anotherDataset.anotherFunction());
Después de ejecutar la consulta CREATE FUNCTION anterior en el proyecto myProject, puedes ejecutar la consulta SELECT myProject.myDataset.myFunction(). Sin importar qué proyecto elijas para ejecutar esta consulta SELECT, la función anotherDataset.anotherFunction a la que se hace referencia siempre se resuelve en el proyecto myProject.
Si la UDF no se crea en el mismo proyecto que se usa para ejecutar la declaración CREATE FUNCTION, todas las referencias en el cuerpo de la UDF sql_expression deben calificarse con los ID del proyecto. Por ejemplo, la consulta CREATE FUNCTION de muestra anterior no es válida si se ejecuta en un proyecto diferente de myProject.
Ejemplos de UDF de SQL
En el siguiente ejemplo, se crea una UDF de SQL persistente. Supone que existe un conjunto de datos llamado mydataset en el proyecto activo. Si no existe un conjunto de datos con este nombre, consulta la documentación sobre cómo crear conjuntos de datos.
CREATE FUNCTION mydataset.multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
AS (x * y);
Después de ejecutar la declaración CREATE FUNCTION, puedes usar la nueva función persistente definida por el usuario en una consulta separada. Reemplaza el editor de consultas con los siguientes contenidos y, luego, ejecuta la consulta:
WITH numbers AS
(SELECT 1 AS x, 5 as y
UNION ALL
SELECT 2 AS x, 10 as y
UNION ALL
SELECT 3 as x, 15 as y)
SELECT x, y, mydataset.multiplyInputs(x, y) as product
FROM numbers;
En el ejemplo anterior, se produce el siguiente resultado:
+-----+-----+--------------+
| x | y | product |
+-----+-----+--------------+
| 1 | 5 | 5 |
| 2 | 10 | 20 |
| 3 | 15 | 45 |
+-----+-----+--------------+
En el siguiente ejemplo se muestra una UDF persistente de SQL que usa un parámetro con plantilla. La función resultante acepta argumentos de varios tipos.
CREATE FUNCTION mydataset.addFourAndDivideAny(x ANY TYPE, y ANY TYPE) AS (
(x + 4) / y
);
Después de ejecutar la declaración CREATE FUNCTION, puedes usar la nueva función persistente definida por el usuario en una consulta separada:
SELECT addFourAndDivideAny(3, 4) AS integer_output,
addFourAndDivideAny(1.59, 3.14) AS floating_point_output;
Esta consulta muestra el siguiente resultado:
+----------------+-----------------------+
| integer_output | floating_point_output |
+----------------+-----------------------+
| 1.75 | 1.7802547770700636 |
+----------------+-----------------------+
En el siguiente ejemplo, se puede ver una UDF de SQL que usa un parámetro con plantilla para mostrar el último elemento de un arreglo de cualquier tipo.
CREATE FUNCTION mydataset.lastArrayElement(arr ANY TYPE) AS (
arr[ORDINAL(ARRAY_LENGTH(arr))]
);
Después de ejecutar la declaración CREATE FUNCTION, puedes usar la nueva función persistente definida por el usuario en una consulta separada:
SELECT
names[OFFSET(0)] AS first_name,
lastArrayElement(names) AS last_name
FROM (
SELECT ['Fred', 'McFeely', 'Rogers'] AS names UNION ALL
SELECT ['Marie', 'Skłodowska', 'Curie']
);
La consulta anterior muestra el siguiente resultado:
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| Fred | Rogers |
| Marie | Curie |
+------------+-----------+
Estructura de una UDF de JavaScript
Crea UDF persistentes de JavaScript con la siguiente sintaxis.
CREATE [OR REPLACE] [TEMPORARY | TEMP] FUNCTION [IF NOT EXISTS] [[`project_name`.]dataset_name.]function_name ([named_parameter[, ...]]) RETURNS data_type [DETERMINISTIC | NOT DETERMINISTIC] LANGUAGE js [OPTIONS (library = library_array)] AS javascript_code
Consulta los tipos de datos compatibles con la UDF de JavaScript con el fin de obtener más información sobre los valores permitidos para data_type y los tipos de parámetros.
Ejemplos de UDF de JavaScript
CREATE TEMP FUNCTION mydataset.multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS r"""
return x*y;
""";
Después de ejecutar la declaración CREATE FUNCTION, puedes usar la UDF nueva y persistente de JavaScript en una consulta separada:
WITH numbers AS
(SELECT 1 AS x, 5 as y
UNION ALL
SELECT 2 AS x, 10 as y
UNION ALL
SELECT 3 as x, 15 as y)
SELECT x, y, multiplyInputs(x, y) as product
FROM numbers;
En el ejemplo anterior, se muestra el siguiente resultado:
+-----+-----+--------------+
| x | y | product |
+-----+-----+--------------+
| 1 | 5 | 5 |
| 2 | 10 | 20 |
| 3 | 15 | 45 |
+-----+-----+--------------+
Puedes pasar el resultado de una UDF como entrada para otra UDF. Por ejemplo, crea una UDF persistente con la siguiente consulta:
CREATE FUNCTION mydataset.multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS r"""
return x*y;
""";
Luego, ejecuta otra consulta para crear una segunda UDF persistente:
CREATE FUNCTION mydataset.divideByTwo(x FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS r"""
return x/2;
""";
Ahora, ejecuta la siguiente consulta para usar ambas UDF persistentes en la misma consulta:
WITH numbers AS
(SELECT 1 AS x, 5 as y
UNION ALL
SELECT 2 AS x, 10 as y
UNION ALL
SELECT 3 as x, 15 as y)
SELECT x,
y,
mydataset.multiplyInputs(
mydataset.divideByTwo(x), mydataset.divideByTwo(y)) as half_product
FROM numbers;
En el ejemplo anterior, se muestra el siguiente resultado:
+-----+-----+--------------+
| x | y | half_product |
+-----+-----+--------------+
| 1 | 5 | 1.25 |
| 2 | 10 | 5 |
| 3 | 15 | 11.25 |
+-----+-----+--------------+
El siguiente ejemplo suma los valores de todos los campos llamados “foo” en la string de JSON dada.
CREATE FUNCTION mydataset.SumFieldsNamedFoo(json_row STRING)
RETURNS FLOAT64
LANGUAGE js
AS r"""
function SumFoo(obj) {
var sum = 0;
for (var field in obj) {
if (obj.hasOwnProperty(field) && obj[field] != null) {
if (typeof obj[field] == "object") {
sum += SumFoo(obj[field]);
} else if (field == "foo") {
sum += obj[field];
}
}
}
return sum;
}
var row = JSON.parse(json_row);
return SumFoo(row);
""";
Después de ejecutar la declaración CREATE FUNCTION, puedes usar la nueva función persistente definida por el usuario en una consulta separada:
WITH Input AS (
SELECT STRUCT(1 AS foo, 2 AS bar, STRUCT('foo' AS x, 3.14 AS foo) AS baz) AS s, 10 AS foo UNION ALL
SELECT NULL, 4 AS foo UNION ALL
SELECT STRUCT(NULL, 2 AS bar, STRUCT('fizz' AS x, 1.59 AS foo) AS baz) AS s, NULL AS foo
)
SELECT
TO_JSON_STRING(t) AS json_row,
mydataset.SumFieldsNamedFoo(TO_JSON_STRING(t)) AS foo_sum
FROM Input AS t;
En el ejemplo anterior, se muestra el siguiente resultado:
+---------------------------------------------------------------------+---------+
| json_row | foo_sum |
+---------------------------------------------------------------------+---------+
| {"s":{"foo":1,"bar":2,"baz":{"x":"foo","foo":3.14}},"foo":10} | 14.14 |
| {"s":null,"foo":4} | 4 |
| {"s":{"foo":null,"bar":2,"baz":{"x":"fizz","foo":1.59}},"foo":null} | 1.59 |
+---------------------------------------------------------------------+---------+
Reglas de entrecomillado
Debes encerrar el código de JavaScript entre comillas. Para fragmentos de código simples de una línea, puedes usar una string entre comillas estándar:
CREATE FUNCTION mydataset.plusOne(x FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS "return x+1;";
En los casos en que el fragmento contiene comillas o consta de varias líneas, usa bloques con comillas triples:
CREATE FUNCTION mydataset.customGreeting(a STRING)
RETURNS STRING
LANGUAGE js AS r"""
var d = new Date();
if (d.getHours() < 12) {
return 'Good Morning, ' + a + '!';
} else {
return 'Good Evening, ' + a + '!';
}
""";
Incluye bibliotecas de JavaScript
Puedes extender tus UDF de JavaScript mediante la sección OPTIONS. Esta sección te permite especificar bibliotecas de código de JavaScript para la UDF.
CREATE FUNCTION mydataset.myFunc(a FLOAT64, b STRING)
RETURNS STRING
LANGUAGE js
OPTIONS (
library=["gs://my-bucket/path/to/lib1.js", "gs://my-bucket/path/to/lib2.js"]
)
AS
r"""
// Assumes 'doInterestingStuff' is defined in one of the library files.
return doInterestingStuff(a, b);
""";
SELECT mydataset.myFunc(3.14, 'foo');
En el ejemplo anterior, el código en lib1.js y lib2.js está disponible para cualquier código en la sección javascript_code de la UDF. Ten en cuenta que puedes especificar archivos de biblioteca mediante sintaxis de elemento único o arreglo.
Las UDF y Cloud Console
Puedes usar Cloud Console para crear funciones persistentes definidas por el usuario.
Ejecuta una consulta para crear una UDF persistente
Ve a la página de BigQuery en Cloud Console.
Haz clic en Redactar consulta nueva.
Ingresa la declaración de UDF en el área de texto del Editor de consultas. Por ejemplo:
CREATE FUNCTION mydataset.timesTwo(x FLOAT64) RETURNS FLOAT64 LANGUAGE js AS r""" return x*2; """;Haz clic en ejecutar.
Después de crear la función persistente definida por el usuario, reemplaza el contenido del editor con una nueva consulta que la use:
SELECT mydataset.timesTwo(numbers) AS doubles FROM UNNEST([1, 2, 3, 4, 5]) AS numbers;Haz clic en ejecutar.
Las UDF y la herramienta de línea de comandos de bq
Puedes usar la herramienta de línea de comandos bq del SDK de Cloud para crear UDF persistentes.
Usa la siguiente sintaxis a fin de ejecutar una consulta para crear una UDF persistente:
bq query --use_legacy_sql=false '
CREATE FUNCTION mydataset.AddTwo(x INT64) AS (x + 2);
'
Declaración CREATE PROCEDURE
Crea un procedimiento, que es un bloque de declaraciones a las que se puede llamar desde otras consultas.
CREATE [OR REPLACE] PROCEDURE [IF NOT EXISTS] [[project_name.]dataset_name.]procedure_name (procedure_argument[, ...] ) [OPTIONS(procedure_option_list)] BEGIN statement_list END; procedure_argument: [procedure_argument_mode] argument_name argument_type
procedure_argument_mode: IN | OUT | INOUT
Descripción
project_name es el nombre del proyecto en el que crearás el procedimiento.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos en el que crearás el procedimiento.
El valor predeterminado es defaultDataset en la solicitud.
statement_list es una lista de declaraciones de BigQuery. Una lista de declaraciones es una serie de declaraciones que terminan con punto y coma.
argument_type es cualquier tipo de BigQuery válido.
procedure_argument_mode especifica si un argumento es una entrada, una salida o ambas.
Los procedimientos pueden llamarse a sí mismos de forma recursiva.
procedure_option_list
procedure_option_list te permite especificar opciones de procedimiento. Las opciones de procedimiento tienen los mismos requisitos y la misma sintaxis que las opciones de tabla, pero con una lista diferente de NAME y VALUE:
NAME |
VALUE |
Detalles |
|---|---|---|
strict_mode |
|
Ejemplo: Si Si bien Si El valor predeterminado es |
Modo de argumento
IN indica que el argumento es solo una entrada del procedimiento. Puedes especificar una variable o una expresión de valor para los argumentos IN.
OUT indica que el argumento es un resultado del procedimiento. Un argumento OUT se inicializa en NULL cuando comienza el procedimiento. Debes especificar una variable para los argumentos OUT.
INOUT indica que el argumento es tanto una entrada como un resultado del procedimiento. Debes especificar una variable para los argumentos INOUT. En el cuerpo de un procedimiento, se puede hacer referencia a un argumento INOUT como una variable y asignarle valores nuevos.
Si no se especifica IN, OUT ni INOUT, el argumento se trata como un argumento IN.
Alcance de la variable
Si una variable se declara fuera de un procedimiento, si se pasa como un argumento INOUT o OUT a un procedimiento, y el procedimiento asigna un valor nuevo a esa variable, ese valor nuevo es visible fuera del procedimiento.
Las variables declaradas en un procedimiento no son visibles fuera de este y viceversa.
A los argumentos OUT o INOUT se les puede asignar un valor mediante SET, en cuyo caso el valor modificado es visible fuera del procedimiento. Si el procedimiento sale correctamente, entonces el valor del argumento OUT o INOUT es el valor final asignado a esa variable INOUT.
Las tablas temporales duran lo mismo que la secuencia de comandos, por lo que si un procedimiento crea una tabla temporal, el emisor del procedimiento también podrá hacer referencia a esa tabla.
Proyecto predeterminado en el cuerpo del procedimiento
Los cuerpos de procedimientos pueden hacer referencia a entidades sin especificar el proyecto. El proyecto predeterminado es aquel al que pertenece el procedimiento, no siempre se trata del que se usó para ejecutar la declaración CREATE PROCEDURE. Considera la siguiente consulta de muestra.
CREATE PROCEDURE myProject.myDataset.QueryTable()
BEGIN
SELECT * FROM anotherDataset.myTable;
END;
Después de crear el procedimiento anterior, puedes ejecutar la consulta CALL myProject.myDataset.QueryTable(). Sin importar qué proyecto elijas para ejecutar esta consulta CALL, la tabla anotherDataset.myTable a la que se hace referencia siempre se resuelve en el proyecto myProject.
Ejemplos
En el siguiente ejemplo, se crea un procedimiento que toma x como argumento de entrada y muestra x como resultado. Como no hay modo de argumento presente para el argumento delta, es un argumento de entrada. El procedimiento consiste en un bloque que contiene una sola declaración, que asigna la suma de los dos argumentos de entrada a x.
CREATE PROCEDURE mydataset.AddDelta(INOUT x INT64, delta INT64)
BEGIN
SET x = x + delta;
END;
En el siguiente ejemplo, se llama al procedimiento AddDelta del ejemplo anterior, pasándole la variable accumulator ambas veces. Como los cambios a x dentro de AddDelta son visibles fuera de AddDelta, este procedimiento llama al incremento accumulator en un total de 8.
DECLARE accumulator INT64 DEFAULT 0;
CALL mydataset.AddDelta(accumulator, 5);
CALL mydataset.AddDelta(accumulator, 3);
SELECT accumulator;
Esto muestra lo siguiente:
+-------------+
| accumulator |
+-------------+
| 8 |
+-------------+
En el siguiente ejemplo, se crea el procedimiento SelectFromTablesAndAppend, que toma target_date como argumento de entrada y muestra rows_added como resultado.
El procedimiento crea una tabla temporal DataForTargetDate a partir de una consulta; luego, calcula la cantidad de filas en DataForTargetDate y asigna el resultado a rows_added. A continuación, inserta una nueva fila en TargetTable y pasa el valor de target_date como uno de los nombres de columna. Por último, descarta la tabla DataForTargetDate y muestra rows_added.
CREATE PROCEDURE mydataset.SelectFromTablesAndAppend(
target_date DATE, OUT rows_added INT64)
BEGIN
CREATE TEMP TABLE DataForTargetDate AS
SELECT t1.id, t1.x, t2.y
FROM dataset.partitioned_table1 AS t1
JOIN dataset.partitioned_table2 AS t2
ON t1.id = t2.id
WHERE t1.date = target_date
AND t2.date = target_date;
SET rows_added = (SELECT COUNT(*) FROM DataForTargetDate);
SELECT id, x, y, target_date -- note that target_date is a parameter
FROM DataForTargetDate;
DROP TABLE DataForTargetDate;
END;
En el siguiente ejemplo, se declara una variable rows_added. Luego, se la pasa como argumento al procedimiento SelectFromTablesAndAppend del ejemplo anterior, junto con el valor de CURRENT_DATE. Después, se muestra un mensaje que indica cuántas filas se agregaron.
DECLARE rows_added INT64;
CALL mydataset.SelectFromTablesAndAppend(CURRENT_DATE(), rows_added);
SELECT FORMAT('Added %d rows', rows_added);
Declaración ALTER SCHEMA SET OPTIONS
Establece opciones en un conjunto de datos.
Para ejecutar esta declaración, debes tener permisos bigquery.datasets.update. La instrucción se ejecuta en la ubicación del conjunto de datos si el conjunto de datos existe, a menos que especifiques la ubicación en la configuración de la consulta. Para obtener más información, consulta Cómo especificar tu ubicación.
ALTER SCHEMA [IF EXISTS] [project_name.]dataset_name SET OPTIONS(schema_set_options_list)
Aquí:
IF EXISTS: si incluyes esta cláusula y el conjunto de datos especificado no existe, la declaración se realiza correctamente sin ninguna acción. Si omites esta cláusula y el conjunto de datos no existe, la declaración muestra un error.project_namees el nombre del proyecto que contiene el conjunto de datos. La configuración predeterminada es el proyecto que ejecuta esta declaración de DDL.dataset_namees el nombre del conjunto de datos.schema_set_options_listespecifica la lista de opciones que se deben establecer.
schema_set_options_list
La lista de opciones especifica las opciones para el conjunto de datos. Especifica las opciones en el siguiente formato: NAME=VALUE, ...
Se admiten las siguientes opciones:
NAME |
VALUE |
Detalles |
|---|---|---|
default_kms_key_name |
STRING |
Especifica la clave predeterminada de Cloud KMS para encriptar los datos de la tabla en este conjunto de datos. Puedes anular este valor cuando creas una tabla. |
default_partition_expiration_days |
FLOAT64 |
Especifica el tiempo de vencimiento predeterminado (en días) de las particiones de tabla en este conjunto de datos. Puedes anular este valor cuando creas una tabla. |
default_table_expiration_days |
FLOAT64 |
Especifica el tiempo de vencimiento predeterminado (en días) de las tablas de este conjunto de datos. Puedes anular este valor cuando creas una tabla. |
description |
STRING |
Es la descripción del conjunto de datos. |
friendly_name |
STRING |
Es un nombre descriptivo para el conjunto de datos. |
labels |
<ARRAY<STRUCT<STRING, STRING>>> |
Un arreglo de etiquetas para el conjunto de datos, expresado como pares clave-valor. |
Ejemplo
En el ejemplo siguiente, se establece el vencimiento predeterminado de las tablas.
ALTER SCHEMA mydataset SET OPTIONS( default_table_expiration_days=3.75 )
Declaración ALTER TABLE SET OPTIONS
Para configurar las opciones de una tabla en BigQuery, usa la declaración DDL ALTER TABLE SET OPTIONS.
ALTER TABLE [IF EXISTS] [[project_name.]dataset_name.]table_name SET OPTIONS(table_set_options_list)
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la tabla especificada no existe. Si está ausente, la consulta falla cuando la tabla especificada no existe.
project_name es el nombre del proyecto que contiene la tabla que modificarás. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la tabla que modificarás. El valor predeterminado es defaultDataset en la solicitud.
table_name es el nombre de la tabla que se modificará.
table_set_options_list
La lista de opciones te permite configurar las opciones de la tabla, como una etiqueta y una fecha y hora de vencimiento. Puedes incluir varias opciones mediante una lista separada por comas.
Especifica una lista de opciones de la tabla con el siguiente formato:
NAME=VALUE, ...
La combinación de NAME y VALUE debe ser una de las siguientes:
NAME |
VALUE |
Detalles |
|---|---|---|
expiration_timestamp |
TIMESTAMP |
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla expirationTime. |
partition_expiration_days |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla timePartitioning.expirationMs, pero utiliza días en lugar de milisegundos. Un día equivale a 86,400,000 milisegundos o 24 horas. Esta propiedad solo se puede configurar si la tabla está particionada. |
require_partition_filter |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla timePartitioning.requirePartitionFilter. Esta propiedad solo se puede configurar si la tabla está particionada. |
kms_key_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla encryptionConfiguration.kmsKeyName. Para obtener más detalles, consulta Cómo proteger los datos con claves de Cloud KMS. |
friendly_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla friendlyName. |
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla description. |
labels |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla labels. |
VALUE es una expresión constante que contiene solo literales, parámetros de búsqueda y funciones escalares. Si la expresión constante se evalúa como null, el NAME de la opción correspondiente se ignora.
La expresión constante no puede contener lo siguiente:
- Una referencia a una tabla
- Subconsultas o instrucciones de SQL, como
SELECT,CREATEyUPDATE - Funciones definidas por el usuario, funciones agregadas o funciones estadísticas
- Las siguientes funciones escalares:
ARRAY_TO_STRINGREPLACEREGEXP_REPLACERANDFORMATLPADRPADREPEATSESSION_USERGENERATE_ARRAYGENERATE_DATE_ARRAY
Cuando se establece el VALUE, se reemplaza el valor existente de esa opción para la tabla, si había uno. Cuando se establece el VALUE como NULL, se borra el valor de la tabla para esa opción.
Ejemplos
Configura la marca de tiempo de vencimiento y la descripción en una tabla
En el siguiente ejemplo, se establece la marca de tiempo de vencimiento en una tabla a siete días desde el tiempo de ejecución de la declaración ALTER TABLE, además de la descripción:
ALTER TABLE mydataset.mytable SET OPTIONS ( expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 7 DAY), description="Table that expires seven days from now" )
Configura el atributo de filtro de partición requerido en una tabla particionada
En el siguiente ejemplo, se configura el atributo timePartitioning.requirePartitionFilter en una tabla particionada.
ALTER TABLE mydataset.mypartitionedtable SET OPTIONS (require_partition_filter=true)
Las consultas que hacen referencia a esta tabla deben usar un filtro en la columna de partición; de lo contrario, BigQuery mostrará un error. Configurar esta opción como true puede ayudar a evitar errores cuando se consultan más datos de lo previsto.
Borra la marca de tiempo de vencimiento en una tabla
En el siguiente ejemplo, se borra la marca de tiempo de vencimiento en una tabla para que no caduque:
ALTER TABLE mydataset.mytable SET OPTIONS (expiration_timestamp=NULL)
Declaración ALTER TABLE ADD COLUMN
La declaración ALTER TABLE ADD COLUMN agrega una o más columnas nuevas a un esquema de tabla existente. Para obtener más información sobre las modificaciones de esquema en BigQuery, consulta Modifica esquemas de tablas.
ALTER TABLE [[project_name.]dataset_name.]table_name
ADD COLUMN [IF NOT EXISTS] column_name column_schema [, ...]
Aquí:
project_namees el nombre del proyecto que contiene la tabla. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL.dataset_namees el nombre del conjunto de datos que contiene la tabla.table_namees el nombre de la tabla que se explorará. La tabla ya debe existir y tener un esquema.column_namees el nombre de la columna que deseas agregar.column_schemaes el esquema de la columna. En este esquema, se usa la misma sintaxis que el esquema de columna para la instrucciónCREATE TABLE.
No puedes usar esta declaración para crear los siguientes tipos de columnas:
- Columnas particionadas
- Columnas agrupadas
- Columnas anidadas dentro de los campos
RECORDexistentes
No puedes agregar una columna REQUIRED a un esquema de tabla existente. Sin embargo, puedes crear una columna REQUIRED anidada como parte de un campo RECORD nuevo.
Sin la cláusula IF NOT EXISTS, si la tabla ya contiene una columna con ese nombre, la declaración muestra un error. Si se incluye la cláusula IF NOT EXISTS y el nombre de la columna ya existe, no se mostrará ningún error ni se realizará ninguna acción.
El valor de la columna nueva para las filas existentes se establece en uno de los siguientes valores:
NULLsi la columna nueva se agregó con el modoNULLABLE. Este es el modo predeterminado.- Un
ARRAYvacío si la columna nueva se agregó con el modoREPEATED.
Ejemplos
Agrega columnas
En el siguiente ejemplo, se agregan las siguientes columnas a una tabla existente llamada mytable:
- Columna
Ade tipoSTRING - Columna
Bde tipoGEOGRAPHY - Columna
Cde tipoNUMERICcon el modoREPEATED - Columna
Dde tipoDATEcon una descripción
ALTER TABLE mydataset.mytable
ADD COLUMN A STRING,
ADD COLUMN IF NOT EXISTS B GEOGRAPHY,
ADD COLUMN C ARRAY<NUMERIC>,
ADD COLUMN D DATE OPTIONS(description="my description")
Si alguna de las columnas llamadas A, C o D ya existe, la declaración fallará.
Si la columna B ya existe, la declaración se realiza de forma correcta debido a la cláusula IF NOT
EXISTS.
Agrega una columna RECORD
En el siguiente ejemplo, se agrega una columna llamada A de tipo STRUCT que contiene las siguientes columnas anidadas:
- Columna
Bde tipoGEOGRAPHY - Columna
Cde tipoINT64con el modoREPEATED - Columna
Dde tipoINT64con el modoREQUIRED - Columna
Ede tipoTIMESTAMPcon una descripción
ALTER TABLE mydataset.mytable
ADD COLUMN A STRUCT<
B GEOGRAPHY,
C ARRAY<INT64>,
D INT64 NOT NULL,
E TIMESTAMP OPTIONS(description="creation time")
>
La consulta fallará si la tabla ya tiene una columna llamada A, incluso si esa columna no contiene ninguna de las columnas anidadas que se especifican.
La STRUCT nueva llamada A es anulable, pero la columna anidada D dentro de A es obligatoria para cualquier valor STRUCT de A.
Declaración ALTER TABLE DROP COLUMN
La declaración ALTER TABLE DROP COLUMN descarta una o más columnas de un esquema de tabla existente. La instrucción no libera de inmediato el almacenamiento asociado con la columna descartada. El almacenamiento se reclama en segundo plano durante el período de 7 días desde el día en que se descarta una columna.
Para obtener información sobre cómo reclamar un almacenamiento de forma inmediata, consulta Borra una columna de un esquema de tabla.
Para obtener más información sobre las modificaciones de esquema en BigQuery, consulta Modifica esquemas de tablas.
ALTER TABLE [[project_name.]dataset_name.]table_name
DROP COLUMN [IF EXISTS] column_name [, ...]
Aquí:
project_namees el nombre del proyecto que contiene la tabla. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL.dataset_namees el nombre del conjunto de datos que contiene la tabla.table_namees el nombre de la tabla que se explorará. La tabla ya debe existir y tener un esquema.column_namees el nombre de la columna que deseas eliminar.
No puedes usar esta declaración para descartar lo siguiente:
- Columnas particionadas
- Columnas agrupadas
- Columnas anidadas dentro de los campos
RECORDexistentes
Sin la cláusula IF EXISTS, si la tabla no contiene una columna con ese nombre, la declaración muestra un error. Si se incluye la cláusula IF EXISTS y el nombre de la columna no existe, no se muestra ningún error ni se realiza ninguna acción.
Esta declaración solo quita la columna de la tabla. Cualquier objeto que haga referencia a la columna, como vistas o vistas materializadas, se debe actualizar o volver a crear por separado.
Ejemplos
Descartar columnas
En el siguiente ejemplo, se descartan las siguientes columnas de una tabla existente llamada mytable:
- Columna
A - Columna
B
ALTER TABLE mydataset.mytable
DROP COLUMN A,
DROP COLUMN IF EXISTS B
Si la columna llamada A no existe, la declaración falla. Si la columna B no existe, la declaración aún se realiza de forma correcta debido a la cláusula IF EXISTS.
Declaración ALTER VIEW SET OPTIONS
Para configurar las opciones en una vista en BigQuery, usa la declaración DDL ALTER VIEW SET OPTIONS.
ALTER VIEW [IF EXISTS] [[project_name.]dataset_name.]view_name SET OPTIONS(view_set_options_list)
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la vista especificada no existe. Si está ausente, la consulta falla cuando la vista especificada no existe.
project_name es el nombre del proyecto que contiene la vista que modificarás. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la vista que modificarás. El valor predeterminado es defaultDataset en la solicitud.
view_name es el nombre de la vista que se modificará.
view_set_options_list
La lista de opciones te permite establecer las opciones de la vista, como una etiqueta y una fecha y hora de vencimiento. Puedes incluir varias opciones mediante una lista separada por comas.
Especifica una lista de opciones de la vista en el siguiente formato:
NAME=VALUE, ...
La combinación de NAME y VALUE debe ser una de las siguientes:
NAME |
VALUE |
Detalles |
|---|---|---|
expiration_timestamp |
TIMESTAMP |
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla expirationTime. |
friendly_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla friendlyName. |
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla description. |
labels |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla labels. |
VALUE es una expresión constante que contiene solo literales, parámetros de búsqueda y funciones escalares. Si la expresión constante se evalúa como null, el NAME de la opción correspondiente se ignora.
La expresión constante no puede contener lo siguiente:
- Una referencia a una tabla
- Subconsultas o instrucciones de SQL, como
SELECT,CREATEyUPDATE - Funciones definidas por el usuario, funciones agregadas o funciones estadísticas
- Las siguientes funciones escalares:
ARRAY_TO_STRINGREPLACEREGEXP_REPLACERANDFORMATLPADRPADREPEATSESSION_USERGENERATE_ARRAYGENERATE_DATE_ARRAY
Cuando se establece el VALUE, se reemplaza el valor existente de esa opción para la vista, si había uno. Cuando se configura el VALUE como NULL, se borra el valor de la vista para esa opción.
Ejemplos
Configura la marca de tiempo de vencimiento y la descripción en una vista
En el siguiente ejemplo, se establece la marca de tiempo de vencimiento de una vista en siete días desde el momento de ejecución de la declaración ALTER VIEW y también se establece la descripción:
ALTER VIEW mydataset.myview SET OPTIONS ( expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 7 DAY), description="View that expires seven days from now" )
Declaración ALTER MATERIALIZED VIEW SET OPTIONS
Para configurar las opciones de una vista materializada en BigQuery, usa la declaración DDL ALTER MATERIALIZED VIEW SET OPTIONS.
ALTER MATERIALIZED VIEW [IF EXISTS] [[project_name.]dataset_name.]materialized_view_name SET OPTIONS(materialized_view_set_options_list)
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la vista especificada no existe. Si está ausente, la consulta falla cuando la vista especificada no existe.
project_name es el nombre del proyecto que contiene la vista materializada que modificarás. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la vista materializada que modificarás. El valor predeterminado es defaultDataset en la solicitud.
materialized_view_name es el nombre de la vista materializada que modificarás.
materialized_view_set_options_list
La lista de opciones te permite establecer las opciones de la vista materializada, como la habilitación de las actualizaciones, el intervalo de actualización, una etiqueta, y una fecha y hora de vencimiento. Puedes incluir varias opciones mediante una lista separada por comas.
Especifica una lista de opciones de la vista materializada en el siguiente formato:
NAME=VALUE, ...
La combinación de NAME y VALUE debe ser una de las siguientes:
NAME |
VALUE |
Detalles |
|---|---|---|
enable_refresh |
BOOLEAN |
Ejemplo: |
refresh_interval_minutes |
FLOAT64 |
Ejemplo: |
expiration_timestamp |
TIMESTAMP |
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla expirationTime. |
friendly_name |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla friendlyName. |
description |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla description. |
labels |
|
Ejemplo: Esta propiedad es equivalente a la propiedad de recurso de tabla labels. |
Cuando se establece el VALUE, se reemplaza el valor existente de esa opción para la vista materializada, si es que había uno. Cuando se configura el VALUE como NULL, se borra el valor de la vista materializada para esa opción.
Ejemplos
Configura el estado de habilitación de actualizaciones y el intervalo de actualización en una vista materializada
En el siguiente ejemplo, se habilita la actualización y se establece un intervalo de actualización de 20 minutos para una vista materializada:
ALTER MATERIALIZED VIEW mydataset.my_mv
SET OPTIONS (
enable_refresh=true,
refresh_interval_minutes=20
)
Declaración DROP SCHEMA
Borra un conjunto de datos.
Para ejecutar esta declaración, debes tener permisos bigquery.datasets.delete. La instrucción se ejecuta en la ubicación del conjunto de datos, si existe, a menos que especifiques la ubicación en la configuración de la consulta. Para obtener más información, consulta Cómo especificar tu ubicación.
DROP SCHEMA [IF EXISTS]
[project_name.]dataset_name
[ CASCADE | RESTRICT ]
Aquí:
IF EXISTS: si incluyes esta cláusula y el conjunto de datos especificado no existe, la declaración se realiza correctamente sin ninguna acción. Si omites esta cláusula y el conjunto de datos no existe, la declaración muestra un error.project_namees el nombre del proyecto que contiene el conjunto de datos. La configuración predeterminada es el proyecto que ejecuta esta declaración de DDL.dataset_namees el nombre del conjunto de datos que se borrará.CASCADE: borra el conjunto de datos y todos los recursos dentro del conjunto de datos, como tablas, vistas y funciones. Debes tener permiso para borrar los recursos o, en caso contrario, la declaración muestra un error. Para obtener una lista de los permisos de BigQuery, consulta Funciones y permisos predefinidos.RESTRICT: borra el conjunto de datos solo si está vacío. De lo contrario, muestra un error.
Si no especificas CASCADE o RESTRICT, el comportamiento predeterminado es RESTRICT.
Ejemplos
En el siguiente ejemplo, se borra un conjunto de datos llamado mydataset. Si el conjunto de datos no existe o no está vacío, la declaración muestra un error.
DROP SCHEMA mydataset
En el siguiente ejemplo, se descarta el conjunto de datos llamado mydataset y cualquier recurso en ese conjunto de datos. Si el conjunto de datos no existe, no se muestra ningún error.
DROP SCHEMA IF EXISTS mydataset CASCADE
Declaración DROP TABLE
Para borrar una tabla en BigQuery, usa la declaración DDL DROP TABLE.
DROP TABLE [IF EXISTS] [[project_name.]dataset_name.]table_name
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la tabla especificada no existe. Si está ausente, la consulta falla cuando la tabla especificada no existe.
project_name es el nombre del proyecto que contiene la tabla que se borrará.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la tabla que se borrará.
El valor predeterminado es defaultDataset en la solicitud.
table_name es el nombre de la tabla que se borrará.
Ejemplos
Borra una tabla
En el siguiente ejemplo, se borra una tabla llamada mytable en mydataset:
DROP TABLE mydataset.mytable
Si el nombre de la tabla no existe en el conjunto de datos, se muestra el siguiente error:
Error: Not found: Table myproject:mydataset.mytable
Borra una tabla solo si existe
En el siguiente ejemplo, se borra una tabla llamada mytable en mydataset solo si la tabla existe. Si el nombre de la tabla no existe en el conjunto de datos, no se muestra ningún error y no se realiza ninguna acción.
DROP TABLE IF EXISTS mydataset.mytable
Declaración DROP EXTERNAL TABLE
La declaración DROP EXTERNAL TABLE borra una tabla externa.
DROP EXTERNAL TABLE [IF EXISTS] [[project_name.]dataset_name.]table_name
Aquí:
project_namees el nombre del proyecto que contiene la tabla. La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL.dataset_namees el nombre del conjunto de datos que contiene la tabla.table_namees el nombre de la tabla que deseas borrar.
Sin la cláusula IF EXISTS, si la tabla externa no existe, la declaración mostrará un error. Si se incluye la cláusula IF EXISTS y la tabla no existe, no se muestra ningún error ni se realiza ninguna acción.
Si table_name existe, pero no es una tabla externa, la declaración muestra el siguiente error:
Cannot drop table_name which has type TYPE. An
external table was expected.
La declaración DROP EXTERNAL solo quita la definición de la tabla externa de BigQuery. Los datos almacenados en la ubicación externa no se ven afectados.
Ejemplos
En el siguiente ejemplo, se descarta la tabla externa llamada external_table del conjunto de datos mydataset. Muestra un error si la tabla externa no existe.
DROP EXTERNAL TABLE mydataset.external_table
En el siguiente ejemplo, se descarta la tabla externa llamada external_table del conjunto de datos mydataset. Si la tabla externa no existe, no se muestra ningún error.
DROP EXTERNAL TABLE IF EXISTS mydataset.external_table
Declaración DROP VIEW
Para borrar una vista en BigQuery, usa la declaración DDL DROP VIEW.
DROP VIEW [IF EXISTS] [[project_name.]dataset_name.]view_name
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la vista especificada no existe. Si está ausente, la consulta falla cuando la vista especificada no existe.
project_name es el nombre del proyecto que contiene la vista que se borrará.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la vista que se borrará.
El valor predeterminado es defaultDataset en la solicitud.
view_name es el nombre de la vista que borrarás.
Ejemplos
Borra una vista
En el siguiente ejemplo, se borra una vista llamada myview en mydataset:
DROP VIEW mydataset.myview
Si el nombre de la vista no existe en el conjunto de datos, se muestra el siguiente error:
Error: Not found: Table myproject:mydataset.myview
Borra una vista solo si existe
En el siguiente ejemplo, se borra una vista llamada myview en mydataset solo si la vista existe. Si el nombre de la vista no existe en el conjunto de datos, no se muestra ningún error y no se realiza ninguna acción.
DROP VIEW IF EXISTS mydataset.myview
Declaración DROP MATERIALIZED VIEW
Para borrar una vista materializada en BigQuery, usa la declaración DDL DROP
MATERIALIZED VIEW.
DROP MATERIALIZED VIEW [IF EXISTS] [[project_name.]dataset_name.]mv_name
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la vista materializada especificada no existe. Si está ausente, la consulta falla cuando la vista materializada especificada no existe.
project_name es el nombre del proyecto que contiene la vista materializada que se borrará.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la vista materializada que se borrará.
El valor predeterminado es defaultDataset en la solicitud.
mv_name es el nombre de la vista materializada que borrarás.
Ejemplos
Borra una vista materializada
En el siguiente ejemplo, se borra una vista materializada llamada my_mv en mydataset:
DROP MATERIALIZED VIEW mydataset.my_mv
Si el nombre de la vista materializada no existe en el conjunto de datos, se muestra el siguiente error:
Error: Not found: Table myproject:mydataset.my_mv
Si borras una vista materializada en otro proyecto, debes especificar el proyecto, el conjunto de datos y la vista materializada en el siguiente formato: `project_id.dataset.materialized_view` (incluidos los acentos graves si project_id contiene caracteres especiales); por ejemplo, `myproject.mydataset.my_mv`.
Borra una vista materializada solo si esta existe
En el siguiente ejemplo, se borra una vista materializada llamada my_mv en mydataset solo si la vista materializada existe. Si el nombre de la vista materializada no existe en el conjunto de datos, no se muestra ningún error ni se realiza ninguna acción.
DROP MATERIALIZED VIEW IF EXISTS mydataset.my_mv
Si borras una vista materializada en otro proyecto, debes especificar el proyecto, el conjunto de datos y la vista materializada en el siguiente formato: `project_id.dataset.materialized_view`, (incluidos los acentos graves si project_id contiene caracteres especiales); por ejemplo, `myproject.mydataset.my_mv`.
Declaración DROP FUNCTION
DROP FUNCTION [IF EXISTS] [[project_name.]dataset_name.]function_name
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando la función especificada no existe. Si está ausente, la consulta falla cuando la función especificada no existe.
project_name es el nombre del proyecto que contiene la función que se borrará.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene la función que se borrará.
El valor predeterminado es defaultDataset en la solicitud.
function_name es el nombre de la función que borrarás.
Ejemplos
La siguiente declaración de ejemplo borra la función parseJsonAsStruct contenida en el conjunto de datos mydataset.
DROP FUNCTION mydataset.parseJsonAsStruct;
La siguiente declaración de ejemplo borra la función parseJsonAsStruct del conjunto de datos sample_dataset en el proyecto other_project.
DROP FUNCTION `other_project`.sample_dataset.parseJsonAsStruct;
Declaración DROP PROCEDURE
DROP PROCEDURE [IF EXISTS] [[project_name.]dataset_name.]procedure_name
Aquí:
IF EXISTS: si está presente, la consulta se realiza de forma correcta cuando el procedimiento especificado no existe. Si está ausente, la consulta falla cuando el procedimiento especificado no existe.
project_name es el nombre del proyecto que contiene el procedimiento que se borrará.
La configuración predeterminada es el proyecto que ejecuta esta consulta de DDL. Si el nombre del proyecto contiene caracteres especiales, como dos puntos, debe estar entre acentos graves ` (ejemplo: `google.com:my_project`).
dataset_name es el nombre del conjunto de datos que contiene el procedimiento que se borrará.
El valor predeterminado es defaultDataset en la solicitud.
procedure_name es el nombre del procedimiento que borrarás.
Ejemplos
La siguiente declaración de ejemplo borra el procedimiento myprocedure contenido en el conjunto de datos mydataset.
DROP PROCEDURE mydataset.myProcedure;
La siguiente declaración de ejemplo borra el procedimiento myProcedure del conjunto de datos sample_dataset en el proyecto other_project.
DROP PROCEDURE `other-project`.sample_dataset.myprocedure;