Cómo usar QUERY en Google Sheets paso a paso

¿Cómo usar QUERY en Google Sheets? Si trabajas con Excel o con hojas de cálculo a diario, tarde o temprano vas a necesitar algo más potente que simples filtros y sumas. La función QUERY de Google Sheets es justo esa navaja suiza que te permite tratar tus datos como si fueran una base de datos SQL, pero sin salir de la hoja ni montar nada raro. Es una de esas herramientas que, una vez la dominas, cambia por completo la forma en la que organizas tus informes.

En este artículo vas a ver, con todo detalle, cómo usar QUERY en Google Sheets para filtrar, ordenar, agrupar, pivotar, formatear y combinar datos de forma muy flexible. Verás la relación con SQL, qué hace exactamente cada cláusula (SELECT, WHERE, GROUP BY, PIVOT, ORDER BY, LIMIT, OFFSET, LABEL y FORMAT), cómo se comporta con fechas, horas y textos, y también cómo usarla con datos repartidos en varias hojas o incluso con rangos que tienen formato de Tabla de Google Sheets.

Qué es QUERY en Google Sheets y por qué se parece tanto a SQL

La función QUERY de Google Sheets es una fórmula que ejecuta una especie de lenguaje de consultas similar a SQL sobre un rango de celdas. Puedes imaginar tu hoja como una tabla de base de datos: cada columna es un campo y cada fila es un registro. Con QUERY puedes pedirle a Sheets que te devuelva sólo las filas y columnas que te interesan, que haga agregaciones, que cambie el formato, que renombre columnas, etc., sin tocar la tabla original.

Técnicamente, la función se basa en el lenguaje de consulta de la API de visualización de Google (Google Visualization API Query Language). Es muy parecido a SQL estándar, aunque con su propia sintaxis y algunas particularidades. Por ejemplo, utiliza identificadores de columna tipo A, B, C o Col1, Col2… en lugar de nombres de campo, y tiene funciones específicas para manejar fechas, horas o cadenas.

Una gran ventaja es que QUERY combina en una sola fórmula lo que normalmente harías con varias funciones como FILTRO, ORDENAR, SUMAR.SI.CONJUNTO, BUSCARV y compañía. Esto hace que tus hojas sean más limpias y fáciles de mantener, sobre todo cuando construyes paneles o informes que dependen de muchos datos.

Sintaxis básica de la función QUERY en Google Sheets

La estructura general de la función, en castellano, es:

=QUERY(datos; consulta; )

O, si tienes la interfaz en inglés:

=QUERY(data_range, query, )

Donde el argumento datos (o data_range) es el rango de celdas sobre el que quieres ejecutar la consulta. Puede ser algo como A2:E100, un rango en otra hoja (Datos!A1:F500) o incluso una combinación de rangos usando llaves para crear matrices. Lo importante es que en cada columna haya principalmente un único tipo de dato: texto, número/moneda o fecha/hora, porque QUERY infiere el tipo según la mayoría y trata lo minoritario como nulo.

El segundo argumento, consulta, es una cadena de texto que contiene la consulta en el lenguaje de la API de visualización. Va entre comillas dobles o puede ser una referencia a una celda que contenga el texto. Por ejemplo:
=QUERY(‘Datos’!A:L; «select *»)

El tercer parámetro, encabezados, es opcional y sirve para indicar cuántas filas superiores del rango se consideran cabecera. Si lo omites, Google Sheets intenta detectarlo automáticamente; si pones 0, tratará todo como datos; si pones 1, asumirá que la primera fila del rango son encabezados, y así sucesivamente.

Tipos de literales que entiende QUERY (texto, números y fechas)

Dentro de la parte de consulta, cuando filtras o comparas valores, necesitas usar literales. Son los valores directos que escribes en la cadena de consulta, y pueden ser de varios tipos: cadenas, números o fechas/horas, cada uno con su sintaxis particular.

Las cadenas de texto se encierran entre comillas simples o dobles, y la comparación distingue mayúsculas de minúsculas. Ejemplos: «primer día», ‘una persona’, «Hamburguesa». Cuando filtras con WHERE o utilizas operadores como starts with, ends with, contains, like o matches, trabajarás mayoritariamente con este tipo de literales.

Los números se escriben en notación decimal normal: 1, 2.5, 7.15, -20.0, 0.8… Son los que vas a pasar a operadores numéricos o a funciones de agregación como sum, avg, min, max. Recuerda que, si en una misma columna mezclas números con texto, QUERY intentará decidir qué tipo domina; lo que no cuadre con el tipo elegido se considerará valor nulo.

Las fechas y horas tienen una sintaxis algo más específica. Se construyen con palabras clave como DATE, TIMEOFDAY, TIMESTAMP o DATETIME seguidas del valor en formato ISO: aaaa-MM-dd para fechas, HH:mm:ss para horas y aaaa-MM-dd HH:mm:ss para marcas de fecha y hora. Esto es importante cuando escribes literales de fecha directamente en la consulta.

Cláusulas de QUERY: el orden correcto y qué hace cada una

El lenguaje de consulta que usa QUERY dispone de 9 cláusulas principales. No tienes que usarlas todas, pero si combinas varias, deben ir en un orden concreto. Ese orden es: SELECT, WHERE, GROUP BY, PIVOT, ORDER BY, LIMIT, OFFSET, LABEL y FORMAT. Cada una añade una capa de lógica sobre el resultado anterior.

La cláusula SELECT define qué columnas quieres devolver y en qué orden. Si no la escribes, QUERY se comporta como si hubieras puesto «select *» y te devuelve todas las columnas del rango de datos en su orden original.

La cláusula WHERE sirve para filtrar filas según condiciones. Puedes combinar condiciones con and, or y not, utilizar operadores numéricos como <, <=, >, >=, =, !=, <> y funciones de texto como starts with, ends with, contains, matches o like, además de comprobar nulos con is null e is not null.

La cláusula GROUP BY agrupa filas que comparten los mismos valores en una o más columnas, de forma muy similar a GROUP BY en SQL. Cada grupo se reduce a una única fila que contiene el resultado de funciones de agregación (sum, avg, count, max, min, etc.) aplicadas a las columnas numéricas.

Con PIVOT puedes convertir valores de una columna en encabezados de columna, creando tablas dinámicas a partir de tu rango original. Se usa casi siempre combinada con funciones de agregación y, a menudo, con GROUP BY para obtener tablas cruzadas más ricas.

ORDER BY ordena el resultado por una o varias columnas, en orden ascendente (ASC) o descendente (DESC). Si no indicas nada, el orden es ascendente por defecto. Puedes ordenar por identificadores de columna o por resultados de agregaciones.

LIMIT reduce el número de filas devueltas a un máximo determinado, mientras que OFFSET salta las primeras N filas del resultado antes de mostrarlo. Combinadas, permiten paginar o excluir cabeceras no deseadas dentro del propio resultado.

La cláusula LABEL te deja renombrar las cabeceras de las columnas en la tabla resultante. Es muy útil para que el informe final tenga nombres legibles en lugar de IDs como «sum(I)» o «G*H».

Por último, FORMAT aplica formatos específicos a columnas numéricas, de fecha, hora o datetime. Puedes definir patrones como «dd-mmm-aaaa» para fechas o «##.00» para números, de forma que la salida quede presentable directamente.

SELECT en QUERY: elegir y combinar columnas

La cláusula SELECT es la base de cualquier consulta. Indica qué columnas se devuelven y su orden. Puedes usar las letras de columna (A, B, C…) o identificadores genéricos como Col1, Col2, Col3, que se refieren a la primera, segunda, tercera columna del rango de datos, respectivamente.

El caso más sencillo es un SELECT de todo:

=QUERY(‘data from Airtable’!A:I; «select *»)

En este ejemplo, el rango A:I es la tabla de origen y la cadena «select *» indica que quieres todas las columnas. Si quieres que la salida no incluya cabeceras, puedes añadir el tercer parámetro a 0: =QUERY(‘data from Airtable’!A:I; «select *»; 0). Así obtendrás sólo datos, útil si vas a anidar esa salida en otra fórmula.

También puedes seleccionar columnas concretas, por ejemplo:

=QUERY(‘data from Airtable’!A:I; «select C, E, I»)

Esto devolverá únicamente las columnas C, E e I del rango de datos. Es muy común combinar esta selección con posteriores cláusulas WHERE, GROUP BY u ORDER BY para construir informes focalizados en unas pocas métricas clave.

Cuando tus datos están repartidos en varias pestañas, puedes unirlos verticalmente con llaves y luego consultarlos como si fueran una sola tabla. Por ejemplo:

=QUERY({‘data from Airtable’!A1:L; Sheet1!A1:L; Sheet2!A1:L}; «select * where Col1 is not null»)

Aquí se crea una matriz con tres rangos apilados (uno detrás de otro). Col1 hace referencia a la primera columna del rango combinado, y el WHERE Col1 is not null filtra las filas vacías. Si necesitas datos de otra hoja de cálculo distinta, puedes combinarlos primero con IMPORTRANGE y después aplicar QUERY sobre ese rango importado.

WHERE en QUERY: filtrar filas con condiciones simples y avanzadas

La cláusula WHERE es tu herramienta para extraer sólo las filas que cumplen unas condiciones determinadas. Funciona con números, textos, fechas y nulos, y soporta tanto operadores básicos como comparaciones más avanzadas con expresiones regulares.

Un ejemplo básico, filtrando por un valor numérico mínimo:

=QUERY(‘data from Airtable’!A:I; «select C, E, I where I >= 40»)

En este caso obtienes las columnas C, E e I, pero sólo de aquellas filas en las que la columna I (por ejemplo, precio total) es mayor o igual que 40. La clave está en usar los operadores >=, <=, >, <, = o != (o <>), todos ellos admitidos por QUERY.

Si quieres filtrar filas vacías o no vacías, no puedes usar comparaciones directas con null como harías con otros valores. En su lugar, toca usar is null o is not null. Por ejemplo: where A is not null fuerza a que la columna A tenga algún valor.

Para condiciones compuestas, utilizas and, or y not. Por ejemplo:

=QUERY(‘data from Airtable’!A:I; «select C, E, I where I >= 40 and not E = ‘Denver sandwich'»)

La consulta anterior filtra por dos criterios: que el valor de I sea mayor o igual a 40, y que la columna E no contenga exactamente «Denver sandwich». El not se aplica a la comparación E = ‘Denver sandwich’, así que excluyes esas filas.

Para búsquedas de texto algo más flexibles, dispones de operadores como starts with, ends with, contains, like y matches. Por ejemplo, si quieres los productos cuya descripción empieza por C y además el nombre del cliente comienza por K, puedes escribir:

=QUERY(‘data from Airtable’!A:I; «select C, E, I where E starts with ‘C’ and C like ‘K%'»)

Aquí starts with ‘C’ comprueba el comienzo exacto del texto y like ‘K%’ hace una comparación tipo comodín, donde % representa cualquier número de caracteres. Si necesitas algo todavía más potente, entra en juego matches, que permite usar expresiones regulares.

Por ejemplo, para obtener sólo filas en las que la columna E sea exactamente «Steak sandwich»:

=QUERY(‘data from Airtable’!A:L; «select C, E, I where E matches ‘Steak sandwich'»)

Y para aceptar cualquier variación que contenga la palabra «sandwich» en medio de la cadena, podrías escribir:

=QUERY(‘data from Airtable’!A:L; «select C, E, I where E matches ‘.*sandwich.*'»; 1)

En esta última versión, .* es un patrón estándar de RegEx que significa «cualquier secuencia de caracteres» antes o después de la palabra sandwich, permitiendo coincidencias parciales muy flexibles.

GROUP BY y funciones de agregación: resúmenes y totales con QUERY

Cuando necesitas resumir datos, por ejemplo calcular el total de ventas por cliente o el salario medio por departamento, la combinación de GROUP BY y funciones de agregación es lo que convierte a QUERY en una mini herramienta de BI dentro de Google Sheets.

Las funciones de agregación disponibles son, entre otras, sum(col), avg(col), min(col), max(col) y count(col). Se aplican normalmente a columnas numéricas y se usan en las cláusulas SELECT, ORDER BY, LABEL y FORMAT, y sobre conjuntos de datos que pueden estar ya agrupados o pivotados.

Un ejemplo sencillo: sumar el importe total por cliente. Imagina que la columna C es el nombre del cliente y la I el importe de cada pedido. Podrías escribir:

=QUERY(‘data from Airtable’!A:I; «select C, sum(I) group by C»)

Esta consulta agrupa todas las filas que comparten el mismo valor en C (cada cliente) y para cada grupo calcula la suma de la columna I. La salida es una tabla con dos columnas: el nombre del cliente y el total agregado.

Si quieres agrupar por más de un criterio, por ejemplo por cliente y por otra columna H (quizá una categoría o fecha), podrías usar:

=QUERY(‘data from Airtable’!A:I; «select C, H, sum(I) group by C, H»)

Ten en cuenta una regla importante: todas las columnas que pongas en SELECT tienen que aparecer en GROUP BY o estar envueltas en una función de agregación. Si seleccionas C, H y sum(I), entonces C y H deben estar en la lista de columnas de GROUP BY. De lo contrario, QUERY devolverá un error.

Si no incluyes ninguna cláusula GROUP BY pero usas funciones de agregación en SELECT, la agregación se hará sobre todo el conjunto de datos. Por ejemplo:

=QUERY(‘data from Airtable’!A:I; «select min(B), count(C), max(I), avg(G), sum(I)»)

Aquí obtienes en una sola fila cinco datos globales: la fecha mínima en B, el número de elementos no nulos en C, el valor máximo de I, la media de G y la suma total de I. Es una manera muy rápida de generar totales generales sin tener que usar cinco funciones separadas.

PIVOT en QUERY: convertir valores en columnas al estilo tabla dinámica

La cláusula PIVOT permite transformar valores distintos de una columna en nuevas columnas, de forma similar a lo que hace una tabla dinámica (pivot table). Es muy útil para obtener vistas cruzadas de tus datos, por ejemplo productos por cliente, meses por categoría, etc.

Si utilizas PIVOT sin GROUP BY, y los valores de la columna que usas para pivotar se repiten en distintas filas, QUERY agregará automáticamente esas filas usando las funciones especificadas. Si no hay GROUP BY, lo habitual es que acabes con una sola fila resultado que representa todos los datos combinados.

Un ejemplo sencillo: sumar una columna G de precios agrupándolos por producto E como columnas:

=QUERY(‘data from Airtable’!A:I; «select sum(G) pivot E»)

En este caso, cada valor distinto de la columna E se convertirá en una columna propia en la salida, y en la única fila obtenida verás la suma de G para cada producto. Es una especie de «total por columna».

Si quieres que cada fila represente un cliente y las columnas sean productos, puedes combinar GROUP BY y PIVOT a la vez. Por ejemplo:

=QUERY(‘data from Airtable’!A:I; «select C, sum(G) group by C pivot E»; 1)

Esta consulta devolverá una tabla donde en la primera columna tienes el cliente (C), y en el resto, una columna por cada producto E. En cada intersección cliente-producto, verás la suma de G (importe) para esa combinación. Es una forma muy potente de construir resúmenes cruzados directamente en la hoja.

ORDER BY en QUERY: ordenar resultados por texto, número o fecha

La cláusula ORDER BY se parece mucho a la de SQL y te permite ordenar los resultados según una o varias columnas. Si no indicas el orden, se tomará como ascendente (ASC) por defecto; para invertirlo, debes añadir DESC.

Un ejemplo típico: ordenar por el identificador de pedido en orden ascendente, ignorando filas vacías:

=QUERY(‘data from Airtable’!A:I; «select * where A is not null order by A»)

El añadido where A is not null es importante para evitar que las filas vacías (que QUERY a veces considera como parte del rango) se cuelen al principio o al final de tu tabla ordenada.

Si lo que quieres es un orden descendente, basta con añadir DESC tras el identificador de columna:

=QUERY(‘data from Airtable’!A:I; «select * order by A desc»)

También puedes ordenar por fechas. Si, por ejemplo, tu fecha de pedido está en la columna B, puedes hacer:

=QUERY(‘data from Airtable’!A1:L21; «select * order by B»; 1)

Esto organizará las filas de forma cronológica ascendente. Si quieres el registro más reciente primero, cambiarías la cláusula a order by B desc. QUERY entiende las fechas como números internos, por lo que el orden funciona exactamente igual que con números.

En consultas más complejas, puedes ordenar por más de una columna, indicando la dirección de cada una: por ejemplo, order by A, B desc ordena primero por A ascendente y, dentro de cada grupo de A, por B descendente. Es clave especificar la dirección para cada columna si quieres combinaciones de sentidos distintos.

LIMIT y OFFSET: controlar cuántas filas devuelve QUERY

Cuando manejas grandes volúmenes de información, puede que no quieras ver todo el resultado de golpe. Las cláusulas LIMIT y OFFSET te permiten recortar y desplazar el conjunto de filas devueltas de forma muy sencilla.

La cláusula LIMIT limita el número de filas que se muestran (sin contar la fila de cabecera original del rango, que se gestiona con el parámetro encabezados). Por ejemplo, para obtener sólo las 5 primeras filas de un rango:

=QUERY(‘data from Airtable’!A:I; «select * limit 5»)

Aquí te llegarán como máximo 5 filas de datos más la cabecera, si has definido alguno en el tercer argumento o lo ha detectado automáticamente.

La cláusula OFFSET, por su parte, indica cuántas filas de la parte superior del resultado deben saltarse antes de empezar a mostrar contenido. Por ejemplo, para omitir las 10 primeras filas:

=QUERY(‘data from Airtable’!A:I; «select * offset 10»)

Si combinas LIMIT y OFFSET, ojo a que, aunque OFFSET aparece después de LIMIT en la sintaxis, en realidad se aplica primero. Es decir, primero se saltan las filas indicadas por OFFSET y luego se cuentan las filas que marca LIMIT. Un ejemplo:

=QUERY(‘data from Airtable’!A:I; «select * limit 5 offset 10»)

Con esa consulta se omiten las 10 primeras filas del conjunto de datos original y, a partir de ahí, se devuelven 5 filas de resultado. Esto es útil, por ejemplo, para paginación o para saltarte bloques de datos que ya has tratado en otra parte.

LABEL y FORMAT: renombrar columnas y dar formato con QUERY

A menudo, después de aplicar funciones de agregación o calcular columnas derivadas, las cabeceras que devuelve QUERY no son muy amigables (por ejemplo, «sum(I)» o «G*H»). La cláusula LABEL permite asignar nombres más legibles a esas columnas directamente desde la consulta.

Por ejemplo, si tienes una consulta que devuelve todas las columnas y quieres renombrar C como «cliente», E como «Hamburguesa» e I como «Total pagado», puedes escribir:

=QUERY(‘data from Airtable’!A:I; «select * label C ‘cliente’, E ‘Hamburguesa’, I ‘Total pagado'»)

La sintaxis consiste en indicar el identificador de columna (o la expresión, como sum(I)) seguido de la palabra label y, entre comillas simples, el nuevo nombre. Puedes listar varias etiquetas separadas por comas en la misma cláusula.

La cláusula FORMAT, por otro lado, sirve para definir el formato de salida de columnas numéricas, de fecha, de hora y datetime. Se parece al formato personalizado de celdas de Google Sheets y se aplica sin tocar el formato de celdas de la hoja original.

Un ejemplo de uso combinado de LABEL y FORMAT sería:

=QUERY(‘data from Airtable’!A:J; «select B, G, I, J label J ‘Hora’ format B ‘dd-mmm-aaaa’, G ‘##.00’, I ‘##.000’, J ‘HH'»)

En este caso, la consulta extrae las columnas B, G, I y J. Después, cambia la etiqueta de J a «Hora» y aplica formatos: B como fecha con día-mes abreviado-año, G con dos decimales, I con tres decimales y J mostrando sólo la hora en formato 24h. De este modo, el resultado ya sale con un aspecto mucho más profesional.

Operadores aritméticos y funciones escalares en QUERY

Además de funciones de agregación, QUERY incluye operadores aritméticos básicos (+, -, *, /) y funciones escalares que sirven para transformar valores de una columna en otros tipos de datos o en derivados útiles (año, mes, día, hora, mayúsculas/minúsculas, etc.).

Los operadores aritméticos permiten hacer cálculos directamente en la consulta. Por ejemplo, si G es precio unitario y H cantidad, puedes crear una columna con el total multiplicando ambas:

=QUERY(‘data from Airtable’!A:I; «select C, I, G*H label G*H ‘Multiplicación aritmética'»)

La consulta extrae C, I y el resultado de G*H, y renombra esa última columna con LABEL. Esto evita tener que crear una columna auxiliar en la hoja para el cálculo; todo se resuelve en la propia QUERY.

Las funciones escalares se aplican a un valor y devuelven otro. Hay varias familias: las que trabajan con DATE o DATETIME, las que lo hacen con DATETIME o TIMEOFDAY, las que convierten a mayúsculas o minúsculas, las que calculan diferencias de fecha y las que convierten tipos.

Por ejemplo, para descomponer una fecha (columna B) en año, mes, día, trimestre y día de la semana, podrías escribir:

=QUERY(‘data from Airtable’!A:I; «select year(B), month(B), day(B), quarter(B), dayofweek(B)»)

Del mismo modo, si tienes valores datetime o timeofday en la columna K y quieres extraer la hora, el minuto, el segundo y el milisegundo, usarías:

=QUERY(‘data from Airtable’!A:K; «select hour(K), minute(K), second(K), millisecond(K)»)

Para manipular textos, están las funciones lower() y upper(), que convierten cadenas a minúsculas o mayúsculas. Por ejemplo, si quieres obtener el nombre del cliente en ambas variantes a partir de la columna C:

=QUERY(‘data from Airtable’!A:I; «select lower(C), upper(C)»)

Muy útil cuando vas a usar esos resultados como claves de unión más adelante y quieres evitar problemas con mayúsculas.

Calcular diferencias de fechas y trabajar con now() y toDate()

Otra función escalar muy práctica es dateDiff(), que calcula la diferencia entre dos fechas o datetimes y devuelve un número (en días). Acepta dos parámetros de tipo DATE o DATETIME. Si, por ejemplo, tus fechas están en las columnas B y K, puedes medir la diferencia entre ambas así:

=QUERY(‘data from Airtable’!A:K; «select dateDiff(B, K) label dateDiff(B, K) ‘Diferencia entre dos fechas, días'»)

Esta consulta devolverá una columna con el número de días entre la fecha de B y la de K para cada fila, y renombrará la columna con una etiqueta más explicativa. Es ideal para calcular duraciones, plazos o tiempos transcurridos.

Si quieres medir la diferencia entre una fecha de la tabla y el momento actual, entra en juego la función now(), que no requiere parámetros y devuelve la fecha/hora actual como datetime. Combinada con dateDiff, podrías tener algo así:

=QUERY(‘data from Airtable’!A:K; «select dateDiff(B, now()) label dateDiff(B, now()) ‘Diferencia entre fecha y ahora, días'»)

De este modo, cada recalculo de la hoja actualizará la diferencia de días entre la fecha de B y el momento presente, muy útil en seguimientos de vencimientos o tareas pendientes.

Por último, la función toDate() te permite convertir un valor que está en formato datetime o incluso un número en un tipo DATE puro. Si en la columna K tienes un datetime y sólo te interesa la fecha, puedes usar:

=QUERY(‘data from Airtable’!A:K; «select toDate(K)»)

La consulta devolverá únicamente la parte de fecha, olvidando la hora. Esto simplifica mucho comparaciones o agrupaciones por fecha sin tener que limpiar antes la columna original.

Usar QUERY con varias hojas, rangos combinados y Tablas de Google Sheets

QUERY no se limita a trabajar sobre una única hoja plana. Puedes referenciar hojas distintas dentro del mismo documento, combinar rangos horizontal o verticalmente y, muy importante, también puedes usarla sobre rangos que estén formateados como Tabla de Google Sheets: al final, lo que importa es el rango de celdas, no el formato visual.

Para usar datos de otra hoja del mismo archivo, basta con anteponer el nombre de la hoja y un signo de exclamación al rango. Ejemplo:

=QUERY(Datos!A1:E14; «select *»)

Si el nombre de la hoja lleva espacios o caracteres especiales, debes encerrarlo entre comillas simples, así:
=QUERY(‘Hoja con nombre raro’!A1:E14; «select *»)

Si quieres combinar varias fuentes de datos verticalmente (lo que en SQL equivaldría a un UNION), puedes usar llaves y punto y coma para apilar rangos con la misma estructura. Por ejemplo:

=QUERY({Hoja1!A1:E; Hoja2!A1:E}; «select *»)

Esto unirá las filas de Hoja1 y Hoja2 una debajo de la otra. Los identificadores de columna (A, B, C… o Col1, Col2…) se aplicarán al conjunto combinado. Por el contrario, si quieres combinar rangos horizontalmente (al estilo JOIN por índice de fila), usarías llaves con coma en vez de punto y coma:

=QUERY({Hoja1!A1:B; Hoja2!A1:B}; «select *»)

En este caso, las columnas de Hoja2 se añaden a la derecha de las de Hoja1, suponiendo que el número de filas coincide y que cada fila correspondiente se puede alinear de forma directa.

En cuanto a las Tablas de Google Sheets (los nuevos rangos con cabecera, filtros rápidos y formato propio), la clave es que internamente siguen siendo un rango de celdas normal. Sí, puedes usar QUERY sobre ellas sin problema. Lo único que tienes que hacer es usar el rango de celdas de la tabla como primer argumento de QUERY, por ejemplo A1:D500, aunque visualmente esté configurado como Tabla. Si quieres seleccionar filas donde la «Fecha de publicación» esté dentro de un rango concreto de fechas, bastará con indicar la columna correspondiente en el SELECT y WHERE y, si quieres, referenciar las fechas límite en celdas externas para no tener que escribirlas a mano en la cadena de consulta.

Si lo que quieres después es pasar esas filas filtradas a una función personalizada (por ejemplo, un script de Apps Script), puedes usar la salida de QUERY como entrada de esa función, ya que devuelve una matriz normal que las funciones personalizadas pueden procesar fila a fila.

QUERY frente a otras herramientas: cuándo usar fórmulas y cuándo usar ETL

Es cierto que QUERY resuelve una barbaridad de casos de uso, pero también es verdad que, cuando tus flujos de datos se vuelven complejos (múltiples orígenes, actualizaciones frecuentes, muchas reglas de transformación), gestionar todo únicamente con fórmulas puede volverse difícil de mantener y propenso a errores, y si trabajas con archivos en Excel conviene saber cómo evitar que Excel se bloquee al manejar hojas grandes.

En escenarios más avanzados, tiene sentido apoyarse en herramientas ETL o conectores que integran datos en tiempo real en Google Sheets y permiten hacer transformaciones sin escribir ni una fórmula. Plataformas como Coupler.io, por ejemplo, permiten importar datos de otras hojas, CRMs, bases de datos o aplicaciones SaaS, ocultar/mostrar columnas, definir filtros y ordenaciones y añadir columnas calculadas de forma visual.

Estas soluciones tienen ventajas claras: ahorras tiempo, reduces el riesgo de equivocarte en una fórmula compleja de QUERY, mantienes datos actualizados automáticamente (por ejemplo, cada 15 minutos) y, en general, facilitas que otros usuarios menos técnicos trabajen con los datos sin tener que aprender el lenguaje de consultas.

Aun así, dominar QUERY sigue siendo muy recomendable: te da un control fino sobre lo que ocurre en la hoja, te entrenas en sintaxis muy cercana a SQL (lo que te prepara para dar el salto a almacenes de datos como BigQuery) y, en muchos contextos, es la opción más rápida para construir informes potentes sin instalar nada adicional.

En definitiva, la función QUERY de Google Sheets es una de las herramientas más flexibles para manipular datos dentro de una hoja: reúne en una misma fórmula filtrado avanzado, ordenación, agregaciones, pivotes, formateo y combinación de rangos, todo ello con una sintaxis inspirada en SQL. Tanto si partes de una tabla sencilla como de varias hojas enlazadas, te permite modelar datos complejos, automatizar informes y, de paso, adquirir unos fundamentos sólidos de lenguaje de consultas que te servirán para trabajar con bases de datos más serias en el futuro.