Algoritmos

Un algoritmo es una operación que defines en Flex y que el sistema convierte en una consulta SQL optimizada. Lo usas para calcular un valor automáticamente: el total de una línea, la suma de una factura, el precio de un producto en catálogo o un dato del usuario que tiene la sesión abierta.

La sintaxis con la que escribes la lógica es DinaScript. Esta página explica los tipos de algoritmo, las partes que lo componen y cuándo usar cada cosa; la referencia del lenguaje (operadores, funciones, control de flujo) está en su propia sección.

Tipos de algoritmo

Cada tipo se diferencia por sobre qué datos opera: una sola fila, registros relacionados, otra sección o ningún contexto de fila. Elige el tipo según el alcance del cálculo.

Matices de cada tipo

Lineal

Trabaja sobre una única fila y puede acceder a sus relaciones directas para traer datos de registros enlazados. No agrega: el resultado sale de los campos de ese mismo registro y de los que cuelgan de él por una relación.

Por ejemplo, en una línea de venta puedes calcular la comisión combinando un campo propio con un campo del empleado relacionado:

venta.total * venta.empleado.comision / 100

Es el tipo que alimenta la mayoría de campos auto-calculados (⚙️), porque el cálculo vive y muere en la misma fila que se guarda.

→ Más sobre relaciones y campos auto-calculados en Campos.

Cruzado

Agrega registros relacionados con la fila actual y devuelve un único valor. Es el tipo que usas cuando un registro "padre" necesita un total que vive en sus "hijos": una factura que suma sus líneas, un proyecto que suma sus tareas.

Para agregar usa las funciones de agregación del espacio F de DinaScript (sumar, contar, máximo, etc.). El patrón conceptual es siempre el mismo: indicas qué registros relacionados recorrer y qué campo agregar.

Búsqueda

Recorre otra sección aplicando un filtro y devuelve el id del registro que coincide. No trae el dato final directamente: te da la referencia al registro encontrado, que luego usas para enlazar o para leer sus campos.

El caso típico es resolver una relación por una clave de negocio: dado un código de producto, encontrar el registro de catálogo correspondiente.

Datos

Agrega sobre todos los registros de una sección, sin limitarse a los relacionados con una fila. Es el motor de los dashboards y los widgets: total facturado del periodo, número de oportunidades abiertas, importe medio de pedido.

Usa también las funciones de agregación del espacio F, pero el conjunto de datos es toda la sección (con los filtros que definas), no el subconjunto relacionado con un registro concreto.

→ Estos cálculos suelen consumirse desde Informes y Documentos dinámicos.

Independiente

No tiene contexto de fila. No opera sobre un registro ni sobre una sección concreta: resuelve un valor del entorno de ejecución, como el usuario o la empresa de la sesión actual, o se apoya en otros algoritmos para componer su resultado.

Lo usas cuando el cálculo no depende de "dónde estás" sino de "quién eres" o de un dato global del sistema.

Las partes de un algoritmo

Un algoritmo no siempre es una sola fórmula. Los tipos que recorren varios registros (Cruzado, Búsqueda y Datos) se construyen por partes, cada una con un papel distinto en la consulta que Flex genera. Defines solo las que necesitas: en un cálculo simple basta con la fórmula principal; en un cruzado fino completas las demás para acotar exactamente qué registros entran.

El orden conceptual sigue al de una consulta SQL: primero el prefiltrado poda lo evidente, luego los filtrados izquierda y derecha acotan cada lado del cruce, la fórmula principal agrega, y por último el Having descarta grupos enteros según el resultado.

Cómo encaja en un cruzado

En un algoritmo Cruzado o de Búsqueda estás relacionando dos lados (el registro de origen y los registros enlazados) y cada filtrado actúa sobre un lado concreto:

• Izquierda = el origen del cruce (la factura, el proyecto, la sección de partida).
• Derecha = lo que cruzas contra él (sus líneas, sus tareas, los cobros relacionados).
• Having = la condición sobre el agregado final (solo facturas cuya suma de líneas pase de cierto importe).

Así puedes, por ejemplo, sumar solo las líneas confirmadas (filtrado derecha) de solo las facturas de este año (filtrado izquierda), descartando de entrada los registros anulados (prefiltrado), y quedarte únicamente con los grupos relevantes (Having).

Variables: convertir un algoritmo en parametrizable

Un algoritmo puede declarar variables (preguntas que se resuelven en tiempo de ejecución) y tratarlas como parámetros de entrada. Así el mismo algoritmo sirve para varios casos sin duplicarlo: en lugar de fijar un umbral en el código, lo recibes desde fuera.

Las variables locales se referencian con el prefijo v. (igual que en DinaScript). Por ejemplo, un algoritmo que cuenta registros por encima de una duración mínima recibe esa duración como variable:

v.DuracionMinima

Quien consume el algoritmo (un informe, un campo, un documento) aporta el valor de v.DuracionMinima, y el cálculo se ajusta sin tocar la lógica.

Dónde se usan

Un mismo algoritmo se puede reutilizar en varios sitios:

• Campos auto-calculados (⚙️): el valor del campo se recalcula al guardar el registro. Suelen ser algoritmos Lineales o Cruzados.
• Columnas de informes: columnas calculadas que no existen como campo de la sección. Aquí encajan los algoritmos Cruzados, de Búsqueda y de Datos.
• Documentos dinámicos: datos calculados que se insertan en una plantilla (factura, presupuesto, email).

Cómo se ejecutan

Los algoritmos se compilan a SQL nativo y se ejecutan directamente en PostgreSQL. No hay procesamiento en memoria intermedia, lo que aporta:

• Rendimiento: el cálculo ocurre en la base de datos, junto a los datos.
• Consistencia: siempre usan la versión más reciente de los datos.
• Escalabilidad: rinden bien aunque la sección tenga millones de registros.

Preguntas frecuentes

→ DinaScript → Campos → Informes → Documentos dinámicos