Tablas comodín

Una tabla comodín te permite consultar varias tablas con instrucciones de SQL concisas. Una tabla comodín representa una unión de todas las tablas que coinciden con la expresión de comodín.

Las tablas comodín solo están disponibles en SQL estándar. Para obtener una funcionalidad equivalente en SQL heredado, consulta Funciones de comodín de tablas.

Para obtener una descripción general de las tablas comodín, visita Consulta varias tablas con una tabla comodín.

Sintaxis de la tabla comodín

Sintaxis de la tabla comodín:

SELECT
FROM
  `<project-id>.<dataset-id>.<table-prefix>*`
WHERE
  bool_expression

<project-id>: ID del proyecto de Cloud Platform. Es opcional si usas tu ID del proyecto predeterminado.
<dataset-id>: ID del conjunto de datos de BigQuery.
<table-prefix>: Una string que se usa para todas las tablas que coinciden con el carácter comodín. El prefijo de tabla es opcional. Si se omite el prefijo de tabla, coincide con todas las tablas del conjunto de datos.
* (carácter comodín): El carácter comodín, “*”, representa uno o más caracteres del nombre de una tabla. El carácter comodín solo puede aparecer al final del nombre de una tabla comodín.

Las consultas con tablas comodín admiten la seudocolumna _TABLE_SUFFIX en la cláusula WHERE. Esta columna contiene los valores que coinciden con el carácter comodín, de modo que, en las consultas, se puede filtrar a qué tablas se accede. Por ejemplo, las siguientes cláusulas WHERE usan operadores de comparación para filtrar las tablas coincidentes:

WHERE
  _TABLE_SUFFIX BETWEEN '29' AND '40'

WHERE
  _TABLE_SUFFIX = '1929'

WHERE
  _TABLE_SUFFIX < '1941'

Para obtener más información sobre la seudocolumna _TABLE_SUFFIX, consulta Filtra tablas seleccionadas con _TABLE_SUFFIX.

Escribe nombres de tablas con comodines entre acentos graves

El nombre de la tabla comodín contiene el carácter especial (*), lo que significa que debes escribir el nombre de la tabla comodín entre caracteres de acento grave (`). Por ejemplo, la siguiente consulta es válida porque usa acentos graves:

#standardSQL
/* Valid standard SQL query */
SELECT
  max
FROM
  `bigquery-public-data.noaa_gsod.gsod*`
WHERE
  max != 9999.9 # code for missing data
  AND _TABLE_SUFFIX = '1929'
ORDER BY
  max DESC

La siguiente consulta NO es válida porque no se encuentra entre acentos graves:

#standardSQL
/* Syntax error: Expected end of statement but got "-" at [4:11] */
SELECT
  max
FROM
  # missing backticks
  bigquery-public-data.noaa_gsod.gsod*
WHERE
  max != 9999.9 # code for missing data
  AND _TABLE_SUFFIX = '1929'
ORDER BY
  max DESC

Las comillas no funcionan:

#standardSQL
/* Syntax error: Unexpected string literal: 'bigquery-public-data.noaa_gsod.gsod*' at [4:3] */
SELECT
  max
FROM
  # quotes are not backticks
  'bigquery-public-data.noaa_gsod.gsod*'
WHERE
  max != 9999.9 # code for missing data
  AND _TABLE_SUFFIX = '1929'
ORDER BY
  max DESC

Migra funciones de comodín de tabla de SQL heredado

En SQL heredado, puedes usar las siguientes funciones de comodín de tabla para consultar varias tablas.

TABLE_DATE_RANGE() y TABLE_DATE_RANGE_STRICT()
TABLE_QUERY()

Las funciones TABLE_DATE_RANGE()

Las funciones TABLE_DATE_RANGE() de SQL heredado funcionan en tablas que cumplen con un esquema de nombres específico: <prefix>YYYYMMDD, en el que <prefix> representa la primera parte de un nombre de tabla y YYYYMMDD representa la fecha asociada con los datos de esa tabla.

Por ejemplo, la consulta siguiente de SQL heredado busca la temperatura promedio de un conjunto de tablas diarias que contienen los datos meteorológicos del área de Seattle:

#legacySQL
SELECT
  ROUND(AVG(TemperatureF),1) AS AVG_TEMP_F
FROM
  TABLE_DATE_RANGE([mydataset.sea_weather_],
                    TIMESTAMP("2016-05-01"),
                    TIMESTAMP("2016-05-09"))

En SQL estándar, una consulta equivalente usa un comodín de tabla y la cláusula BETWEEN.

#standardSQL
SELECT
  ROUND(AVG(TemperatureF),1) AS AVG_TEMP_F
FROM
  `mydataset.sea_weather_*`
WHERE
  _TABLE_SUFFIX BETWEEN '20160501' AND '20160509'

La función TABLE_QUERY()

La función TABLE_QUERY() de SQL heredado te permite encontrar nombres de tablas en función de patrones. Cuando migras una función TABLE_QUERY() a SQL estándar, que no admite la función TABLE_QUERY(), puedes filtrar con la seudocolumna _TABLE_SUFFIX. Ten en cuenta las siguientes diferencias cuando realices migraciones:

En SQL heredado, debes colocar la función TABLE_QUERY() en la cláusula FROM, mientras que en SQL estándar, debes filtrar con la seudocolumna _TABLE_SUFFIX en la cláusula WHERE.
En SQL heredado, la función TABLE_QUERY() opera en todo el nombre de la tabla (o table_id), mientras que en SQL estándar, la _TABLE_SUFFIX seudocolumna contiene parte o todo el nombre de la tabla, según la manera en que uses el carácter comodín.

Filtra en la cláusula WHERE

Cuando migres de SQL heredado a SQL estándar, mueve el filtro a la cláusula WHERE. Por ejemplo, la consulta siguiente busca las temperaturas máximas en todos los años que terminan con el número 0:

#legacySQL
SELECT
  max,
  ROUND((max-32)*5/9,1) celsius,
  year
FROM
  TABLE_QUERY([bigquery-public-data:noaa_gsod],
               'REGEXP_MATCH(table_id, r"0$")')
WHERE
  max != 9999.9 # code for missing data
  AND max > 100 # to improve ORDER BY performance
ORDER BY
  max DESC

En SQL estándar, una consulta equivalente usa un comodín de tabla y coloca la función de expresión regular, REGEXP_CONTAINS(), en la cláusula WHERE:

#standardSQL
SELECT
  max,
  ROUND((max-32)*5/9,1) celsius,
  year
FROM
  `bigquery-public-data.noaa_gsod.gsod*`
WHERE
  max != 9999.9 # code for missing data
  AND max > 100 # to improve ORDER BY performance
  AND REGEXP_CONTAINS(_TABLE_SUFFIX, r"0$")
ORDER BY
  max DESC

Diferencias entre table_id y _TABLE_SUFFIX

En la función TABLE_QUERY(dataset, expr) de SQL heredado, el segundo parámetro es una expresión que opera en todo el nombre de la tabla, con el valor table_id. Cuando migras a SQL estándar, el filtro que creas en la cláusula WHERE opera en el valor de _TABLE_SUFFIX, que puede incluir todo el nombre de la tabla o una parte de él, en función de la manera en que uses el carácter comodín.

Por ejemplo, la siguiente consulta de SQL heredado usa el nombre completo de la tabla en una expresión regular para buscar las temperaturas máximas en todos los años que terminan con el número 0:

#legacySQL
SELECT
  max,
  ROUND((max-32)*5/9,1) celsius,
  year
FROM
  TABLE_QUERY([bigquery-public-data:noaa_gsod],
               'REGEXP_MATCH(table_id, r"gsod\d{3}0")')
WHERE
  max != 9999.9 # code for missing data
  AND max > 100 # to improve ORDER BY performance
ORDER BY
  max DESC

En SQL estándar, una consulta equivalente puede usar el nombre completo de la tabla o solo una parte de él. Puedes usar un prefijo vacío en SQL estándar para que tu filtro funcione con el nombre completo de la tabla:

# Standard SQL empty prefix
FROM
  `bigquery-public-data.noaa_gsod.*`

Sin embargo, los prefijos más largos funcionan mejor que los vacíos, por lo que en el siguiente ejemplo, se usa un prefijo más largo. Esto significa que el valor de _TABLE_SUFFIX es solo una parte del nombre de la tabla.

#standardSQL
SELECT
  max,
  ROUND((max-32)*5/9,1) celsius,
  year
FROM
  `bigquery-public-data.noaa_gsod.gsod*`
WHERE
  max != 9999.9 # code for missing data
  AND max > 100 # to improve ORDER BY performance
  AND REGEXP_CONTAINS(_TABLE_SUFFIX, r"\d{3}0")
ORDER BY
  max DESC

Limitaciones

Consulta la sección de limitación en Consulta varias tablas mediante una tabla comodín.