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()
yTABLE_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áusulaFROM
, mientras que en SQL estándar, debes filtrar con la seudocolumna_TABLE_SUFFIX
en la cláusulaWHERE
.En SQL heredado, la función
TABLE_QUERY()
opera en todo el nombre de la tabla (otable_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.