Where

La operación Where te permite filtrar tu conjunto de datos creando consultas que incluyan solo los registros que coinciden con condiciones específicas. Esta operación se aplica antes de cualquier operación de transformación en el pipeline.

En la cuadrícula de operaciones aparece en Operaciones de consulta como Donde ("Filtrar registros por valor").

Resumen

La operación Where te permite:

• Filtrar registros basados en valores de campos
• Quedarte con los registros cuyo campo está vacío (NULL) o descartarlos
• Crear condiciones complejas usando lógica And/Or
• Aplicar diferentes filtros a diferentes tipos de entidades
• Trabajar con varios tipos de datos (cadenas, números, fechas, booleanos)

Configuración

Filtrado a Nivel de Entidad

La operación Where se configura a nivel de entidad, lo que significa que puedes aplicar diferentes filtros a cada entidad en tu conjunto de datos. Para cada entidad, puedes:

1. Añadir múltiples reglas de filtrado
2. Agrupar reglas con operadores And/Or
3. Anidar grupos para crear lógica de filtrado compleja

Las entidades sin configuración Where se leen completas.

Elige las entidades en la caja Buscar entidades (hace falta al menos una: "Debe seleccionar al menos una entidad"). Cada entidad elegida aparece con un lápiz (Editar configuración de la entidad) que abre su filtro, y una papelera (Eliminar la configuración de la entidad). Una entidad sin filtro muestra un aviso ("La operación Where no está establecida, por favor haga clic para editar esta entidad"), y la operación no se puede guardar hasta que lo tenga ("Hay entidades no configuradas. Por favor, compruebe su configuración").

Configuración de Reglas

Cada regla es una fila con tres componentes:

• Campo: El campo por el que quieres filtrar. Se pueden filtrar los campos de tipo cadena, número (entero o decimal, como las columnas float, double o decimal), fecha y booleano. Los campos de otros tipos aparecen deshabilitados, con su tipo detrás del nombre (por ejemplo photo (buffer)) y el tooltip "Los campos de tipo buffer no se pueden filtrar". Si la entidad no tiene campos, el panel muestra "No se han encontrado campos para esta entidad", y si ninguno de sus campos se puede filtrar, "Ninguno de los campos de esta entidad se puede filtrar".
• Operador: El operador de comparación a usar. La lista depende del tipo de campo y del driver del tap (ver la tabla siguiente).
• Valor: El valor con el que comparar. La entrada depende del tipo de campo: una caja de texto para cadenas, una caja numérica para números (también los decimales) y un selector de fecha y hora para fechas. Los campos booleanos y los operadores es nulo / no es nulo no tienen caja de valor.

Cada regla tiene un valor desde el principio: una regla nueva toma el valor por defecto de su tipo de campo, que es un texto vacío para las cadenas, 0 para los números y hoy a las 00:00 para las fechas. Al abrir el filtro de una entidad, las reglas guardadas sin valor también reciben el valor por defecto. En el selector de fecha la hora empieza en 00:00:00, y la fecha elegida se guarda sin milisegundos.

Al cambiar el campo de una regla, el operador vuelve al primer operador del nuevo tipo de campo, y el valor al valor por defecto de ese tipo.

Operadores

Estos son los operadores que ofrece la interfaz, por tipo de campo:

Qué hace cada operador:

Cómo se envían los valores

• Las cadenas se envían tal como se escriben. Con like también puedes usar los comodines de la base de datos dentro del valor (%, _).
• Los números se envían como números.
• Las fechas se eligen con fecha y hora y se envían como fecha y hora ISO 8601 en UTC, por ejemplo 2026-10-21T13:45:00.000Z. Después cada base de datos la compara según el tipo de la columna, ver Fechas.
• Los booleanos se envían como true / false.
• En las bases de datos SQL los valores se envían como parámetros de la consulta, no se pegan en el texto SQL, así que las comillas de un valor no rompen la consulta. La excepción es Garantizar integridad referencial, descrita más abajo.
• Un valor de texto no puede empezar por __: ni por ~~ (estos prefijos significan SQL literal en el generador de consultas). Una regla así hace fallar la regla con el error Where value for field '<field>' cannot start with '<prefix>'.
• Un campo numérico o de fecha no se puede comparar con un valor vacío. Una regla guardada así hace fallar la regla con el error Where value for field '<field>' is empty.

Fechas

La fecha y hora que eliges es un instante. Se compara con las columnas de fecha así:

• Una columna con zona horaria (por ejemplo un timestamptz de Postgres, un TIMESTAMP de Databricks, un campo Date/Time de Salesforce o una fecha de MongoDB) se compara con ese mismo instante.
• Una columna sin zona horaria se compara con la fecha y hora de ese instante en la zona horaria del servidor de Gigantics. Esto se aplica a timestamp de Postgres, DATETIME de MySQL, TIMESTAMP_NTZ de Databricks, TIMESTAMP de DB2 y las fechas de SQLite.
• Una columna DATE se compara con el día de ese instante en la zona horaria del servidor de Gigantics en Postgres, Databricks, DB2, SQLite y Salesforce. En MySQL el día de la columna cuenta como las 00:00 de ese día, así que usa 00:00 como hora con es.
• Una columna TIME se compara con la hora del día de ese instante en la zona horaria del servidor de Gigantics en Postgres, MySQL, DB2 y Salesforce.

En las columnas con hora, es y no es comparan la fecha y hora exactas, al segundo. Para filtrar un periodo, como un día entero, combina después de y antes de en un grupo Y.

Drivers soportados

La misma configuración Where funciona en todos los taps, pero cada driver la aplica en un sitio distinto:

Algunos tipos de columna necesitan un tratamiento especial en cada base de datos:

• Postgres: like, empieza por y termina en también funcionan en columnas que no son de texto (como uuid, inet o enums), que se comparan como texto. Un valor decimal comparado con una columna entera se compara como decimal.
• MySQL: los nombres de columna van entre comillas, así que funcionan las palabras reservadas y los nombres con espacios.
• Oracle: es y no es funcionan en columnas CLOB / NCLOB. En las columnas CHAR / NCHAR se ignoran los espacios de relleno (en es, no es y termina en). Oracle guarda un texto vacío como NULL, así que es con un valor vacío funciona como es nulo, y no es con un valor vacío como no es nulo.
• MSSQL: los valores decimales conservan sus decimales, y se admiten enteros fuera del rango de 32 bits.
• DB2 for i y DB2 for z: termina en ignora los espacios de relleno de las columnas CHAR.
• Databricks: se admiten enteros fuera del rango de 32 bits, y las columnas BOOLEAN son booleanas.
• SQLite: las fechas se comparan como fechas tanto si se guardan como texto como si se guardan en segundos o milisegundos epoch. Las columnas TIMESTAMP son fechas y las columnas BOOLEAN son booleanas.
• Salesforce: los campos Date se comparan con una fecha, los campos Time con una hora y los campos Date/Time con una fecha y hora. Los valores de texto van siempre entre comillas.

Filtros aplicados por Gigantics

Cuando el filtro se ejecuta en Gigantics (CSV, File Storage y Redis), se lee cada registro y después se comprueba:

• es y no es comparan los valores como texto. Cuando el valor es un número comparan como números (5 es 5.0), y cuando es una fecha comparan como fechas.
• menor que / antes de y mayor que / después de comparan las fechas como fechas, los números como números y el resto como texto. Se entienden las fechas guardadas como texto ISO 8601, con o sin hora y zona horaria, y en otros formatos habituales. Una fecha sin zona horaria se lee en la zona horaria del servidor de Gigantics. Un campo vacío nunca cumple estos operadores.
• like no distingue mayúsculas de minúsculas y funciona en valores de varias líneas. % coincide con cualquier texto y _ con un solo carácter cualquiera. * es un carácter normal.
• empieza por y termina en no distinguen mayúsculas de minúsculas.
• es nulo coincide con un campo que no existe o con un valor null. En los ficheros CSV (taps CSV y ficheros CSV de File Storage) una celda vacía también es nula. En otros formatos y en Redis una cadena vacía no es nula.

Lógica de Agrupación

Cada entidad empieza con un grupo (Grupo 1). En un grupo puedes añadir reglas con Regla + y grupos anidados con Grupo +. Un grupo vacío muestra "Grupo vacío, Haga clic aquí para añadir una nueva regla".

Cada grupo tiene un selector Y / O:

• Grupos Y: Todas las reglas del grupo deben ser verdaderas
• Grupos O: Al menos una regla del grupo debe ser verdadera

Los grupos anidados se numeran a partir de su padre (Grupo 1.1, Grupo 1.2, ...) y se pueden quitar con el botón - junto al selector. Los grupos vacíos se ignoran al ejecutar la regla.

Garantizar integridad referencial

Marca Garantizar integridad referencial para mantener el subconjunto consistente: una fila hija solo se extrae si también se extrae la fila padre a la que referencia. Con esta opción, el filtro Where de una tabla padre también se aplica al filtrar sus hijas, así que las hijas solo referencian filas padre que pasan el filtro (y el Límite, si lo hay).

La casilla solo se muestra en taps SQL: Postgres, MySQL, Google Cloud SQL, Oracle, MSSQL, DB2, SQLite y Databricks.

En este modo las condiciones de las tablas hijas, y de las tablas padre con las que se comprueban, se escriben como texto en el SQL generado, así que:

• El texto se pone entre comillas simples (una comilla del valor se duplica). En MySQL, Google Cloud SQL y Databricks también se escapan las barras invertidas.
• Los booleanos se escriben como 1 / 0 en Oracle, MSSQL y DB2, y como TRUE / FALSE en el resto.
• Las fechas se escriben en el formato de cada base de datos, según el tipo de la columna, como se describe en Fechas.
• Los nombres de tabla y de columna van entre comillas: comillas invertidas en MySQL, Google Cloud SQL y Databricks, [...] en MSSQL y "..." en el resto.
• En Oracle las tablas se cualifican con el Owner del tap, en mayúsculas (por ejemplo "SALES"."CUSTOMERS"). Sin Owner no se cualifican.
• % y _ en un valor de empieza por o termina en se buscan como caracteres normales. En like siguen siendo comodines.

Ejemplos

Filtro Simple

Para filtrar registros de clientes donde el estado es "activo":

1. Selecciona la entidad cliente
2. Añade una regla con:
   • Campo: estado
   • Operador: es
   • Valor: activo

Registros sin valor

Para quedarte solo con los clientes que tienen email:

1. Selecciona la entidad cliente
2. Añade una regla con:
   • Campo: email
   • Operador: no es nulo

No hace falta valor.

Filtro Complejo con Grupos

Para filtrar registros de órdenes donde:

• El monto de la orden es mayor que 1000 O
• La fecha de la orden es posterior a una fecha dada Y el estado de la orden es "pendiente"

1. Selecciona la entidad orden
2. Pon Grupo 1 en O
3. Añade una regla al grupo:
   • Campo: monto
   • Operador: mayor que
   • Valor: 1000
4. Añade un grupo anidado (Grupo 1.1) y ponlo en Y
5. Añade dos reglas a Grupo 1.1:
   • Campo: fecha, Operador: después de, Valor: 2026-09-21 00:00:00
   • Campo: estado, Operador: es, Valor: pendiente

Grupo 1                         [O]
├── monto    mayor que   1000
└── Grupo 1.1                   [Y]
    ├── fecha    después de   2026-09-21 00:00:00
    └── estado   es           pendiente

Equivalente SQL:
WHERE monto > 1000
   OR (fecha > '2026-09-21T00:00:00.000Z' AND estado = 'pendiente')

La fecha se muestra aquí tal como se envía. Cada base de datos la compara según el tipo de la columna (ver Fechas).

Esto crea un sistema de filtrado flexible que puede manejar requisitos complejos de lógica empresarial.