@relq/orm 0.1.3 → 0.1.5

package/dist/esm/mysql/select/scalar-query-builder.js

@@ -0,0 +1,156 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+class MysqlScalarResultImpl {
+    sql;
+    params;
+    $scalar = true;
+    $type;
+    constructor(sql, params = []) {
+        this.sql = sql;
+        this.params = params;
+    }
+    toSQL() {
+        return this.sql;
+    }
+    getParams() {
+        return this.params;
+    }
+}
+export class MysqlScalarQueryBuilderImpl {
+    tableName;
+    tableSchema;
+    columnResolver;
+    whereConditions = [];
+    constructor(tableName, tableSchema, columnResolver) {
+        this.tableName = tableName;
+        this.tableSchema = tableSchema;
+        this.columnResolver = columnResolver;
+    }
+    where(callback) {
+        const conditionBuilder = new MysqlConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    count() {
+        const sql = this.buildSQL('COUNT(*)');
+        return new MysqlScalarResultImpl(sql);
+    }
+    sum(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(SUM(${mysqlFormat.ident(sqlColumn)}), 0)`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    avg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(AVG(${mysqlFormat.ident(sqlColumn)}), 0)`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    min(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MIN(${mysqlFormat.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    max(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MAX(${mysqlFormat.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    pick(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(mysqlFormat.ident(sqlColumn), true);
+        return new MysqlScalarResultImpl(sql);
+    }
+    exists() {
+        const whereClause = this.buildWhereClause();
+        const sql = `(EXISTS(SELECT 1 FROM ${mysqlFormat.ident(this.tableName)}${whereClause}))`;
+        return new MysqlScalarResultImpl(sql);
+    }
+    countDistinct(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COUNT(DISTINCT ${mysqlFormat.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    stringAgg(column, delimiter = ', ') {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`GROUP_CONCAT(${mysqlFormat.ident(sqlColumn)} SEPARATOR ${mysqlFormat.literal(delimiter)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    arrayAgg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(JSON_ARRAYAGG(${mysqlFormat.ident(sqlColumn)}), JSON_ARRAY())`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    jsonAgg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(JSON_ARRAYAGG(${mysqlFormat.ident(sqlColumn)}), JSON_ARRAY())`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    boolAnd(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MIN(${mysqlFormat.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    boolOr(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MAX(${mysqlFormat.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    resolveColumn(column) {
+        if (this.columnResolver) {
+            return this.columnResolver(column);
+        }
+        const columns = this.tableSchema?.$columns || this.tableSchema;
+        const columnDef = columns?.[column];
+        if (columnDef?.$columnName) {
+            return columnDef.$columnName;
+        }
+        return column.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
+    }
+    transformConditions(conditions) {
+        if (!this.columnResolver && !this.tableSchema) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditions(cond.values)
+                };
+            }
+            return {
+                ...cond,
+                column: this.resolveColumn(cond.column)
+            };
+        });
+    }
+    buildWhereClause() {
+        if (this.whereConditions.length === 0) {
+            return '';
+        }
+        const transformed = this.transformConditions(this.whereConditions);
+        return ` WHERE ${buildMysqlConditionsSQL(transformed)}`;
+    }
+    buildSQL(selectExpr, withLimit = false) {
+        const whereClause = this.buildWhereClause();
+        const limitClause = withLimit ? ' LIMIT 1' : '';
+        return `(SELECT ${selectExpr} FROM ${mysqlFormat.ident(this.tableName)}${whereClause}${limitClause})`;
+    }
+}
+export function createMysqlScalarTableAccessor(schema, getColumnResolver) {
+    return new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            const tables = schema?.tables || schema;
+            const tableDef = tables?.[prop];
+            const sqlTableName = tableDef?.$name || prop;
+            const columnResolver = getColumnResolver?.(sqlTableName);
+            return new MysqlScalarQueryBuilderImpl(sqlTableName, tableDef, columnResolver);
+        }
+    });
+}

package/dist/esm/mysql/select/scalar-select-builder.js

@@ -0,0 +1,70 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { createMysqlScalarTableAccessor } from "./scalar-query-builder.js";
+export class MysqlScalarSelectBuilder {
+    executeQuery;
+    scalarResults;
+    constructor(scalars, schema, executeQuery, getColumnResolver) {
+        this.executeQuery = executeQuery;
+        const tableAccessor = createMysqlScalarTableAccessor(schema, getColumnResolver);
+        this.scalarResults = {};
+        for (const [key, callback] of Object.entries(scalars)) {
+            this.scalarResults[key] = callback(tableAccessor);
+        }
+    }
+    toString() {
+        const columns = Object.entries(this.scalarResults)
+            .map(([alias, scalar]) => `${scalar.toSQL()} AS ${mysqlFormat.ident(alias)}`)
+            .join(', ');
+        return `SELECT ${columns}`;
+    }
+    async get(withMetadata) {
+        const sql = this.toString();
+        const { data, metadata } = await this.executeQuery(sql);
+        const row = Array.isArray(data) ? data[0] : data;
+        const result = this.transformResult(row);
+        if (withMetadata) {
+            return { data: result, metadata };
+        }
+        return result;
+    }
+    transformResult(row) {
+        if (!row) {
+            const result = {};
+            for (const key of Object.keys(this.scalarResults)) {
+                result[key] = null;
+            }
+            return result;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (typeof value === 'string' && /^\d+$/.test(value)) {
+                result[key] = parseInt(value, 10);
+            }
+            else if (typeof value === 'string' && /^\d+\.\d+$/.test(value)) {
+                result[key] = parseFloat(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+}
+export class MysqlConnectedScalarSelectBuilder extends MysqlScalarSelectBuilder {
+    constructor(scalars, schema, internal) {
+        const executeQuery = async (sql) => {
+            return internal.executeSelectOne(sql);
+        };
+        const getColumnResolver = (tableName) => {
+            if (internal.hasColumnMapping()) {
+                return (column) => {
+                    const transformed = internal.transformToDbColumns(tableName, { [column]: null });
+                    const keys = Object.keys(transformed);
+                    return keys.length > 0 ? keys[0] : column;
+                };
+            }
+            return undefined;
+        };
+        super(scalars, schema, executeQuery, getColumnResolver);
+    }
+}

package/dist/esm/mysql/select/select-builder.js

@@ -0,0 +1,407 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+export class MysqlSelectBuilder {
+    tableName;
+    tableAlias;
+    selectColumns = ['*'];
+    whereConditions = [];
+    havingConditions = [];
+    joinClauses = [];
+    structuredJoins = [];
+    groupByColumns = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    isDistinct = false;
+    lockingClause;
+    unionQueries = [];
+    includeExpressions = [];
+    columnResolver;
+    constructor(tableName, columns) {
+        this.tableName = tableName;
+        if (columns) {
+            this.selectColumns = Array.isArray(columns) ? columns : [columns];
+        }
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
+    setTableAlias(alias) {
+        this.tableAlias = alias;
+        return this;
+    }
+    getTableIdentifier() {
+        return this.tableAlias || this.tableName;
+    }
+    distinct() {
+        this.isDistinct = true;
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new MysqlConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    rightJoin(table, condition) {
+        this.joinClauses.push(`RIGHT JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    crossJoin(table) {
+        this.joinClauses.push(`CROSS JOIN ${mysqlFormat.ident(table)}`);
+        return this;
+    }
+    lateralJoin(subquery, left = false) {
+        const joinType = left ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+        this.joinClauses.push(`${joinType} ${subquery}`);
+        return this;
+    }
+    addRawJoin(joinSQL) {
+        this.joinClauses.push(joinSQL);
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    having(callback) {
+        const conditionBuilder = new MysqlConditionCollector();
+        callback(conditionBuilder);
+        this.havingConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    orderAsc(column) {
+        return this.orderBy(column, 'ASC');
+    }
+    orderDesc(column) {
+        return this.orderBy(column, 'DESC');
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    forUpdate() {
+        this.lockingClause = 'FOR UPDATE';
+        return this;
+    }
+    forUpdateNoWait() {
+        this.lockingClause = 'FOR UPDATE NOWAIT';
+        return this;
+    }
+    forUpdateSkipLocked() {
+        this.lockingClause = 'FOR UPDATE SKIP LOCKED';
+        return this;
+    }
+    forShare() {
+        this.lockingClause = 'FOR SHARE';
+        return this;
+    }
+    forShareNoWait() {
+        this.lockingClause = 'FOR SHARE NOWAIT';
+        return this;
+    }
+    forShareSkipLocked() {
+        this.lockingClause = 'FOR SHARE SKIP LOCKED';
+        return this;
+    }
+    lockInShareMode() {
+        this.lockingClause = 'LOCK IN SHARE MODE';
+        return this;
+    }
+    union(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'UNION'
+        });
+        return this;
+    }
+    unionAll(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'UNION ALL'
+        });
+        return this;
+    }
+    intersect(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'INTERSECT'
+        });
+        return this;
+    }
+    except(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'EXCEPT'
+        });
+        return this;
+    }
+    addStructuredJoin(join) {
+        this.structuredJoins.push(join);
+        return this;
+    }
+    getStructuredJoins() {
+        return [...this.structuredJoins];
+    }
+    addIncludeExpression(alias, sql) {
+        this.includeExpressions.push({ alias, sql });
+        return this;
+    }
+    qualifyWhereConditions(conditions, tableRef) {
+        return conditions.map(cond => {
+            if (!cond.column)
+                return cond;
+            if (cond.column.includes('.'))
+                return cond;
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.qualifyWhereConditions(cond.values, tableRef)
+                };
+            }
+            return {
+                ...cond,
+                column: `${tableRef}.${cond.column}`
+            };
+        });
+    }
+    buildStructuredJoinSQL(join) {
+        if ((join.type === 'LEFT JOIN LATERAL' || join.type === 'JOIN LATERAL') && join.lateralSubquery) {
+            return `${join.type} ${join.lateralSubquery} ON true`;
+        }
+        if (join.type === 'CROSS JOIN') {
+            const tableRef = join.alias !== join.table
+                ? `${mysqlFormat.ident(join.table)} AS ${mysqlFormat.ident(join.alias)}`
+                : mysqlFormat.ident(join.table);
+            return `CROSS JOIN ${tableRef}`;
+        }
+        const tableRef = join.alias !== join.table
+            ? `${mysqlFormat.ident(join.table)} AS ${mysqlFormat.ident(join.alias)}`
+            : mysqlFormat.ident(join.table);
+        if (join.usingColumns && join.usingColumns.length > 0) {
+            const usingSQL = join.usingColumns.map(c => mysqlFormat.ident(c)).join(', ');
+            return `${join.type} ${tableRef} USING (${usingSQL})`;
+        }
+        if (join.onClause) {
+            return `${join.type} ${tableRef} ON ${join.onClause}`;
+        }
+        return `${join.type} ${tableRef}`;
+    }
+    toString() {
+        const hasJoins = this.joinClauses.length > 0 || this.structuredJoins.length > 0;
+        const tableRef = this.tableAlias || this.tableName;
+        const columns = this.selectColumns.map(col => {
+            if (col === '*') {
+                return hasJoins ? `${mysqlFormat.ident(tableRef)}.*` : '*';
+            }
+            if (Array.isArray(col)) {
+                const [column, alias] = col;
+                if (hasJoins) {
+                    return `${mysqlFormat.ident(tableRef)}.${mysqlFormat.ident(column)} AS ${mysqlFormat.ident(alias)}`;
+                }
+                return `${mysqlFormat.ident(column)} AS ${mysqlFormat.ident(alias)}`;
+            }
+            if (col.includes('(') || col.includes('DISTINCT') || col.includes(' AS ') || col.includes('.')) {
+                return col;
+            }
+            if (hasJoins) {
+                return `${mysqlFormat.ident(tableRef)}.${mysqlFormat.ident(col)}`;
+            }
+            return mysqlFormat.ident(col);
+        });
+        const hasGroupBy = this.groupByColumns.length > 0
+            || (this.includeExpressions.length > 0 && this.selectColumns.some(c => typeof c === 'string' && c !== '*'));
+        for (const join of this.structuredJoins) {
+            if (join.selectColumns && join.selectColumns.length > 0) {
+                const jsonArgs = join.selectColumns
+                    .map(col => `'${col.property}', ${mysqlFormat.ident(join.alias)}.${mysqlFormat.ident(col.sqlName)}`)
+                    .join(', ');
+                if (hasGroupBy) {
+                    columns.push(`COALESCE(JSON_ARRAYAGG(JSON_OBJECT(${jsonArgs})), JSON_ARRAY()) AS ${mysqlFormat.ident(join.alias)}`);
+                }
+                else {
+                    columns.push(`JSON_OBJECT(${jsonArgs}) AS ${mysqlFormat.ident(join.alias)}`);
+                }
+            }
+        }
+        for (const expr of this.includeExpressions) {
+            columns.push(`${expr.sql} AS ${mysqlFormat.ident(expr.alias)}`);
+        }
+        const columnsSQL = columns.join(', ');
+        let query = 'SELECT';
+        if (this.isDistinct) {
+            query += ' DISTINCT';
+        }
+        if (this.tableAlias && this.tableAlias !== this.tableName) {
+            query += ` ${columnsSQL} FROM ${mysqlFormat.ident(this.tableName)} AS ${mysqlFormat.ident(this.tableAlias)}`;
+        }
+        else {
+            query += ` ${columnsSQL} FROM ${mysqlFormat.ident(this.tableName)}`;
+        }
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.structuredJoins.length > 0) {
+            const structuredJoinSQL = this.structuredJoins
+                .map(join => this.buildStructuredJoinSQL(join))
+                .join(' ');
+            query += ' ' + structuredJoinSQL;
+        }
+        if (this.whereConditions.length > 0) {
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
+            query += ' WHERE ' + buildMysqlConditionsSQL(conditions);
+        }
+        let effectiveGroupBy = this.groupByColumns;
+        if (effectiveGroupBy.length === 0 && this.includeExpressions.length > 0) {
+            effectiveGroupBy = this.selectColumns
+                .filter(col => typeof col === 'string' && col !== '*')
+                .map(col => col);
+        }
+        if (effectiveGroupBy.length > 0) {
+            const groupBySQL = effectiveGroupBy.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return `${mysqlFormat.ident(tableRef)}.${mysqlFormat.ident(col)}`;
+                return mysqlFormat.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
+        }
+        if (this.havingConditions.length > 0) {
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
+            query += ' HAVING ' + buildMysqlConditionsSQL(havingConds);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => `${mysqlFormat.ident(order.column)} ${order.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            query += ` OFFSET ${this.offsetValue}`;
+        }
+        if (this.lockingClause) {
+            query += ' ' + this.lockingClause;
+        }
+        if (this.unionQueries.length > 0) {
+            for (const unionQuery of this.unionQueries) {
+                query += ` ${unionQuery.type} ${unionQuery.query}`;
+            }
+        }
+        return query;
+    }
+    whereRaw(condition) {
+        this.whereConditions.push({
+            method: 'raw',
+            column: condition,
+            values: undefined
+        });
+        return this;
+    }
+    toCountSQL() {
+        const hasJoins = this.joinClauses.length > 0 || this.structuredJoins.length > 0;
+        const tableRef = this.tableAlias || this.tableName;
+        let query;
+        if (this.tableAlias && this.tableAlias !== this.tableName) {
+            query = `SELECT COUNT(*) AS \`count\` FROM ${mysqlFormat.ident(this.tableName)} AS ${mysqlFormat.ident(this.tableAlias)}`;
+        }
+        else {
+            query = `SELECT COUNT(*) AS \`count\` FROM ${mysqlFormat.ident(this.tableName)}`;
+        }
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.structuredJoins.length > 0) {
+            const structuredJoinSQL = this.structuredJoins
+                .map(join => this.buildStructuredJoinSQL(join))
+                .join(' ');
+            query += ' ' + structuredJoinSQL;
+        }
+        if (this.whereConditions.length > 0) {
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
+            query += ' WHERE ' + buildMysqlConditionsSQL(conditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            const groupBySQL = this.groupByColumns.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return `${mysqlFormat.ident(tableRef)}.${mysqlFormat.ident(col)}`;
+                return mysqlFormat.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
+        }
+        if (this.havingConditions.length > 0) {
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
+            query += ' HAVING ' + buildMysqlConditionsSQL(havingConds);
+        }
+        return query;
+    }
+}

package/dist/esm/mysql/select/sql-expression.js

@@ -0,0 +1,51 @@
+import { mysqlColumnRefToSQL } from "./table-proxy.js";
+export class MysqlSqlExpression {
+    sql;
+    _isSqlExpression = true;
+    constructor(sql) {
+        this.sql = sql;
+    }
+}
+export class MysqlAggregateFunctions {
+    count(ref) {
+        if (!ref)
+            return new MysqlSqlExpression('COALESCE(CAST(COUNT(*) AS SIGNED), 0)');
+        return new MysqlSqlExpression(`COALESCE(CAST(COUNT(${mysqlColumnRefToSQL(ref)}) AS SIGNED), 0)`);
+    }
+    countDistinct(ref) {
+        return new MysqlSqlExpression(`COALESCE(CAST(COUNT(DISTINCT ${mysqlColumnRefToSQL(ref)}) AS SIGNED), 0)`);
+    }
+    sum(ref) {
+        return new MysqlSqlExpression(`COALESCE(CAST(SUM(${mysqlColumnRefToSQL(ref)}) AS DOUBLE), 0)`);
+    }
+    avg(ref) {
+        return new MysqlSqlExpression(`CAST(AVG(${mysqlColumnRefToSQL(ref)}) AS DOUBLE)`);
+    }
+    min(ref) {
+        return new MysqlSqlExpression(`MIN(${mysqlColumnRefToSQL(ref)})`);
+    }
+    max(ref) {
+        return new MysqlSqlExpression(`MAX(${mysqlColumnRefToSQL(ref)})`);
+    }
+    stringAgg(ref, delimiter = ', ') {
+        return new MysqlSqlExpression(`COALESCE(GROUP_CONCAT(${mysqlColumnRefToSQL(ref)} SEPARATOR '${delimiter}'), '')`);
+    }
+    arrayAgg(ref) {
+        return new MysqlSqlExpression(`COALESCE(JSON_ARRAYAGG(${mysqlColumnRefToSQL(ref)}), JSON_ARRAY())`);
+    }
+    arrayAggDistinct(ref) {
+        return new MysqlSqlExpression(`COALESCE(JSON_ARRAYAGG(DISTINCT ${mysqlColumnRefToSQL(ref)}), JSON_ARRAY())`);
+    }
+    boolAnd(ref) {
+        return new MysqlSqlExpression(`CAST(COALESCE(MIN(${mysqlColumnRefToSQL(ref)}), 0) AS SIGNED)`);
+    }
+    boolOr(ref) {
+        return new MysqlSqlExpression(`CAST(COALESCE(MAX(${mysqlColumnRefToSQL(ref)}), 0) AS SIGNED)`);
+    }
+    stddev(ref) {
+        return new MysqlSqlExpression(`CAST(STDDEV(${mysqlColumnRefToSQL(ref)}) AS DOUBLE)`);
+    }
+    variance(ref) {
+        return new MysqlSqlExpression(`CAST(VARIANCE(${mysqlColumnRefToSQL(ref)}) AS DOUBLE)`);
+    }
+}