Skip to content

Agregaciones SQL ​

Usa expresiones agregadas en la lista SELECT de db.query<T>. Declara cada campo de resultado en T con el tipo indicado abajo y asigna a cada expresión un alias explícito con AS que coincida con el campo.

ExpresiónArgumentoCampo de resultado
COUNT(*) AS totalTodas las filas coincidentestotal: i64
COUNT(column) AS totalValores presentes en la columnatotal: i64
SUM(column) AS sumColumna i64 o f64sum: i64? o sum: f64?
AVG(column) AS averageColumna i64 o f64average: f64?
MIN(column) AS minimumColumna i64, f64 o stringTipo opcional de la columna
MAX(column) AS maximumColumna i64, f64 o stringTipo opcional de la columna

COUNT(*) cuenta filas; COUNT(column) cuenta filas con un valor en esa columna. Ambos devuelven 0 cuando no hay valores coincidentes. Las demás agregaciones devuelven un opcional vacío en ese caso; usa ?? o estrecha el tipo antes de usar el valor. Una consulta agregada sin GROUP BY devuelve una fila aunque no coincida ninguna fila de origen.

Ejemplo ​

Este ejemplo supone que el snapshot local del schema contiene db_examples(id: i64) y que la base de datos en ejecución tiene la misma tabla.

tyrus
import { DbError, db } from "tyrus:db";

interface CountRow {
    total: i64;
}

interface StatsRow {
    sum: i64?;
    average: f64?;
    minimum: i64?;
    maximum: i64?;
}

interface GroupRow {
    groupId: i64;
    total: i64;
}

async function countExamples(): Promise<Result<CountRow[], DbError>> {
    const rows = await db.query<CountRow>("SELECT COUNT(*) AS total FROM db_examples", []) onfail {
        return Err(data);
    };
    return Ok(rows);
}

async function readStats(): Promise<Result<StatsRow[], DbError>> {
    const rows = await db.query<StatsRow>("""
        SELECT SUM(id) AS sum,
               AVG(id) AS average,
               MIN(id) AS minimum,
               MAX(id) AS maximum
        FROM db_examples
    """, []) onfail {
        return Err(data);
    };
    return Ok(rows);
}

async function listGroups(): Promise<Result<GroupRow[], DbError>> {
    const rows = await db.query<GroupRow>("SELECT id AS groupId, COUNT(*) AS total FROM db_examples GROUP BY groupId ORDER BY total DESC", []) onfail {
        return Err(data);
    };
    return Ok(rows);
}

Puedes combinar varias agregaciones en un SELECT.

GROUP BY ​

Usa GROUP BY para combinar columnas normales y agregaciones. Toda columna normal seleccionada debe aparecer en la lista de agrupación, mediante su nombre, su nombre calificado o su alias explícito de SELECT. SELECT * no se admite con GROUP BY; enumera las columnas de resultado de forma explícita. HAVING filtra grupos después de la agregación y puede referirse a columnas agrupadas o alias de agregación. Vincula los valores mediante parámetros ?. ORDER BY puede referirse a una columna agrupada o a un alias de agregación. El resultado contiene una fila por grupo o un array vacío si no hay grupos coincidentes.

Este ejemplo devuelve una fila por cada valor de id:

tyrus
import { DbError, db } from "tyrus:db";

interface GroupRow {
    groupId: i64;
    total: i64;
}

async function listGroups(): Promise<Result<GroupRow[], DbError>> {
    const minimumTotal: i64 = 1;
    const rows = await db.query<GroupRow>("""
        SELECT id AS groupId, COUNT(*) AS total
        FROM db_examples
        GROUP BY groupId
        HAVING total > ?
        ORDER BY total DESC
    """, [minimumTotal]) onfail {
        return Err(data);
    };
    return Ok(rows);
}

El SQL debe ser un literal de cadena, y los valores dinámicos van en el array separado de parámetros.