@relq/orm 0.1.2 → 0.1.4

package/dist/cjs/mysql/insert/insert-builder.cjs

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlInsertBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const case_converter_1 = require("../../utils/case-converter.cjs");
+const duplicate_key_builder_1 = require("./duplicate-key-builder.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlInsertBuilder {
+    tableName;
+    insertData;
+    insertMode = 'INSERT';
+    duplicateKeyBuilder;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    originalColumns;
+    columnResolver;
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        const normalized = this.normalizeData(data);
+        this.insertData = [normalized];
+        this.originalColumns = Object.keys(normalized).sort();
+    }
+    normalizeData(data) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(data)) {
+            normalized[key] = value === undefined ? null : value;
+        }
+        return normalized;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    convertCase(type, conversionCase = '2snake') {
+        this._case = type;
+        this._convertCase = conversionCase;
+        return this;
+    }
+    validateColumns(row) {
+        const newColumns = Object.keys(row).sort();
+        if (newColumns.length !== this.originalColumns.length) {
+            throw new relq_errors_1.RelqBuilderError(`Column count mismatch: expected ${this.originalColumns.length} columns, got ${newColumns.length}`, { builder: 'MysqlInsertBuilder', hint: `Expected columns: [${this.originalColumns.join(', ')}]` });
+        }
+        for (let i = 0; i < this.originalColumns.length; i++) {
+            if (this.originalColumns[i] !== newColumns[i]) {
+                throw new relq_errors_1.RelqBuilderError('Column name mismatch: all rows must have the exact same column names', { builder: 'MysqlInsertBuilder', hint: `Expected columns: [${this.originalColumns.join(', ')}]` });
+            }
+        }
+    }
+    addRow(row) {
+        const normalized = this.normalizeData(row);
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(normalized).sort();
+        }
+        else {
+            this.validateColumns(normalized);
+        }
+        this.insertData.push(normalized);
+        return this;
+    }
+    addRows(rows) {
+        if (rows.length === 0)
+            return this;
+        const normalizedRows = rows.map(row => this.normalizeData(row));
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(normalizedRows[0]).sort();
+        }
+        if (normalizedRows.length > 0) {
+            this.validateColumns(normalizedRows[0]);
+            if (normalizedRows.length > 1) {
+                this.validateColumns(normalizedRows[normalizedRows.length - 1]);
+            }
+        }
+        this.insertData.push(...normalizedRows);
+        return this;
+    }
+    clear() {
+        this.insertData = [];
+        this.originalColumns = [];
+        return this;
+    }
+    get total() {
+        return this.insertData.length;
+    }
+    ignore() {
+        this.insertMode = 'INSERT IGNORE';
+        return this;
+    }
+    replace() {
+        this.insertMode = 'REPLACE';
+        return this;
+    }
+    onDuplicateKeyUpdate(callback) {
+        this.duplicateKeyBuilder = new duplicate_key_builder_1.MysqlDuplicateKeyBuilder(this.tableName);
+        if (this.columnResolver) {
+            this.duplicateKeyBuilder.setColumnResolver(this.columnResolver);
+        }
+        callback(this.duplicateKeyBuilder);
+        return this;
+    }
+    convertColumnName(name) {
+        if (this._case === 'to-lower')
+            return name.toLowerCase();
+        if (this._case === 'to-upper')
+            return name.toUpperCase();
+        if (this._case === 'convert-case')
+            return (0, case_converter_1.convertCase)(name, this._convertCase);
+        return name;
+    }
+    formatMysqlValue(value) {
+        if (value === null || value === undefined) {
+            return { formatted: 'NULL', isRaw: true };
+        }
+        if (Array.isArray(value) || (typeof value === 'object' && !(value instanceof Date))) {
+            const json = JSON.stringify(value).replace(/'/g, "''").replace(/\\/g, '\\\\');
+            return { formatted: `CAST('${json}' AS JSON)`, isRaw: true };
+        }
+        return { formatted: mysql_format_1.default.literal(value), isRaw: true };
+    }
+    buildDuplicateKeyClause() {
+        if (!this.duplicateKeyBuilder)
+            return '';
+        const updateSql = (0, duplicate_key_builder_1.buildDuplicateKeyUpdateSql)(this.duplicateKeyBuilder.updateData, this.tableName, (col) => this.resolveColumnName(col));
+        return ` ON DUPLICATE KEY UPDATE ${updateSql}`;
+    }
+    toString() {
+        if (this.insertData.length === 0) {
+            throw new relq_errors_1.RelqBuilderError('Cannot generate INSERT query: no rows to insert', { builder: 'MysqlInsertBuilder', missing: 'data', hint: 'Add rows using addRow() or addRows() first' });
+        }
+        const originalColumns = Object.keys(this.insertData[0]);
+        const columns = originalColumns.map(name => this.resolveColumnName(name));
+        const columnsSQL = columns.map(c => mysql_format_1.default.ident(c)).join(', ');
+        const allValuesGroups = [];
+        for (const row of this.insertData) {
+            const vals = [];
+            for (const colName of originalColumns) {
+                const { formatted } = this.formatMysqlValue(row[colName]);
+                vals.push(formatted);
+            }
+            allValuesGroups.push(`(${vals.join(', ')})`);
+        }
+        let keyword;
+        switch (this.insertMode) {
+            case 'INSERT IGNORE':
+                keyword = 'INSERT IGNORE INTO';
+                break;
+            case 'REPLACE':
+                keyword = 'REPLACE INTO';
+                break;
+            default:
+                keyword = 'INSERT INTO';
+        }
+        let query = `${keyword} ${mysql_format_1.default.ident(this.tableName)} (${columnsSQL}) VALUES ${allValuesGroups.join(', ')}`;
+        if (this.insertMode === 'INSERT' && this.duplicateKeyBuilder) {
+            query += this.buildDuplicateKeyClause();
+        }
+        return query;
+    }
+}
+exports.MysqlInsertBuilder = MysqlInsertBuilder;

package/dist/cjs/mysql/insert/insert-from-select-builder.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlInsertFromSelectBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const duplicate_key_builder_1 = require("./duplicate-key-builder.cjs");
+class MysqlInsertFromSelectBuilder {
+    tableName;
+    columns;
+    selectSQL;
+    insertMode = 'INSERT';
+    duplicateKeyBuilder;
+    columnResolver;
+    constructor(tableName, columns, selectSQL) {
+        this.tableName = tableName;
+        this.columns = columns;
+        this.selectSQL = selectSQL;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    ignore() {
+        this.insertMode = 'INSERT IGNORE';
+        return this;
+    }
+    replace() {
+        this.insertMode = 'REPLACE';
+        return this;
+    }
+    onDuplicateKeyUpdate(callback) {
+        this.duplicateKeyBuilder = new duplicate_key_builder_1.MysqlDuplicateKeyBuilder(this.tableName);
+        if (this.columnResolver) {
+            this.duplicateKeyBuilder.setColumnResolver(this.columnResolver);
+        }
+        callback(this.duplicateKeyBuilder);
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return name;
+    }
+    buildDuplicateKeyClause() {
+        if (!this.duplicateKeyBuilder)
+            return '';
+        const updateSql = (0, duplicate_key_builder_1.buildDuplicateKeyUpdateSql)(this.duplicateKeyBuilder.updateData, this.tableName, (col) => this.resolveColumnName(col));
+        return ` ON DUPLICATE KEY UPDATE ${updateSql}`;
+    }
+    toString() {
+        const resolvedColumns = this.columns.map(c => this.resolveColumnName(c));
+        const columnsSQL = resolvedColumns.map(c => mysql_format_1.default.ident(c)).join(', ');
+        let keyword;
+        switch (this.insertMode) {
+            case 'INSERT IGNORE':
+                keyword = 'INSERT IGNORE INTO';
+                break;
+            case 'REPLACE':
+                keyword = 'REPLACE INTO';
+                break;
+            default:
+                keyword = 'INSERT INTO';
+        }
+        let query = `${keyword} ${mysql_format_1.default.ident(this.tableName)} (${columnsSQL}) ${this.selectSQL}`;
+        if (this.insertMode === 'INSERT' && this.duplicateKeyBuilder) {
+            query += this.buildDuplicateKeyClause();
+        }
+        return query;
+    }
+}
+exports.MysqlInsertFromSelectBuilder = MysqlInsertFromSelectBuilder;

package/dist/cjs/mysql/raw/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSqlFragment = exports.mysqlSql = exports.MysqlRawQueryBuilder = void 0;
+var raw_query_builder_1 = require("./raw-query-builder.cjs");
+Object.defineProperty(exports, "MysqlRawQueryBuilder", { enumerable: true, get: function () { return raw_query_builder_1.MysqlRawQueryBuilder; } });
+var sql_template_1 = require("./sql-template.cjs");
+Object.defineProperty(exports, "mysqlSql", { enumerable: true, get: function () { return sql_template_1.mysqlSql; } });
+Object.defineProperty(exports, "MysqlSqlFragment", { enumerable: true, get: function () { return sql_template_1.MysqlSqlFragment; } });

package/dist/cjs/mysql/raw/raw-query-builder.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlRawQueryBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlRawQueryBuilder {
+    query;
+    params;
+    constructor(query, params = []) {
+        this.query = query;
+        this.params = params;
+    }
+    toString() {
+        if (!this.query || typeof this.query !== 'string' || this.query.trim() === '') {
+            throw new relq_errors_1.RelqQueryError(`Invalid query provided: ${this.query === null ? 'null' : this.query === undefined ? 'undefined' : 'empty string'}`, { hint: 'Provide a valid SQL query string' });
+        }
+        const result = this.params.length > 0 ? (0, mysql_format_1.default)(this.query, ...this.params) : this.query;
+        if (!result || typeof result !== 'string') {
+            throw new relq_errors_1.RelqQueryError(`mysqlFormat() returned invalid result: ${result === null ? 'null' : result === undefined ? 'undefined' : typeof result}`, { sql: this.query });
+        }
+        return result;
+    }
+}
+exports.MysqlRawQueryBuilder = MysqlRawQueryBuilder;

package/dist/cjs/mysql/raw/sql-template.cjs

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSqlFragment = void 0;
+exports.mysqlSql = mysqlSql;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+class MysqlSqlFragment {
+    text;
+    _isSqlFragment = true;
+    constructor(text) {
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
+}
+exports.MysqlSqlFragment = MysqlSqlFragment;
+function sqlIdentifier(name) {
+    return new MysqlSqlFragment(mysql_format_1.default.ident(name));
+}
+function mysqlSql(strings, ...values) {
+    let result = '';
+    for (let i = 0; i < strings.length; i++) {
+        result += strings[i];
+        if (i < values.length) {
+            result += formatValue(values[i]);
+        }
+    }
+    return new MysqlSqlFragment(result);
+}
+function formatValue(value) {
+    if (value && value._isSqlFragment === true) {
+        return value.text;
+    }
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (value instanceof Date) {
+        return mysql_format_1.default.literal(value.toISOString());
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return "CAST('[]' AS JSON)";
+        }
+        const escaped = value.map(v => formatValue(v)).join(', ');
+        return `(${escaped})`;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number' || typeof value === 'bigint') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return mysql_format_1.default.literal(value);
+    }
+    if (typeof value === 'object') {
+        const json = JSON.stringify(value).replace(/'/g, "''").replace(/\\/g, '\\\\');
+        return `CAST('${json}' AS JSON)`;
+    }
+    return mysql_format_1.default.literal(String(value));
+}
+mysqlSql.id = sqlIdentifier;

package/dist/cjs/mysql/select/aggregate-builder.cjs

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlAggregateQueryBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const NUMERIC_FUNCS = new Set(['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']);
+class MysqlAggregateQueryBuilder {
+    tableName;
+    groupByColumns = [];
+    entries = [];
+    whereConditions = [];
+    havingConditions = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    count(alias = 'count') {
+        this.entries.push({ func: 'COUNT', column: '*', alias });
+        return this;
+    }
+    countColumn(column, alias) {
+        this.entries.push({ func: 'COUNT', column, alias: alias || column });
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.entries.push({ func: 'COUNT', column, alias: alias || column, distinct: true });
+        return this;
+    }
+    sum(column, alias, filter) {
+        const entry = { func: 'SUM', column, alias: alias || column };
+        if (filter) {
+            const collector = new condition_collector_1.MysqlConditionCollector();
+            filter(collector);
+            entry.filterConditions = collector.getConditions();
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    avg(column, alias, filter) {
+        const entry = { func: 'AVG', column, alias: alias || column };
+        if (filter) {
+            const collector = new condition_collector_1.MysqlConditionCollector();
+            filter(collector);
+            entry.filterConditions = collector.getConditions();
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    min(column, alias) {
+        this.entries.push({ func: 'MIN', column, alias: alias || column });
+        return this;
+    }
+    max(column, alias) {
+        this.entries.push({ func: 'MAX', column, alias: alias || column });
+        return this;
+    }
+    groupConcat(column, separator = ', ', alias, orderBy, orderDir = 'ASC') {
+        const entry = {
+            func: 'GROUP_CONCAT',
+            column,
+            alias: alias || column,
+            separator,
+        };
+        if (orderBy) {
+            entry.orderByColumn = orderBy;
+            entry.orderByDirection = orderDir;
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    jsonArrayAgg(column, alias) {
+        this.entries.push({ func: 'JSON_ARRAYAGG', column, alias: alias || column });
+        return this;
+    }
+    bitAnd(column, alias) {
+        this.entries.push({ func: 'BIT_AND', column, alias: alias || column });
+        return this;
+    }
+    bitOr(column, alias) {
+        this.entries.push({ func: 'BIT_OR', column, alias: alias || column });
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const collector = new condition_collector_1.MysqlConditionCollector();
+            callbackOrCondition(collector);
+            this.whereConditions.push(...collector.getConditions());
+        }
+        return this;
+    }
+    having(callback) {
+        const collector = new condition_collector_1.MysqlConditionCollector();
+        callback(collector);
+        this.havingConditions.push(...collector.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    getNumericAliases() {
+        return this.entries
+            .filter(e => NUMERIC_FUNCS.has(e.func))
+            .map(e => e.alias);
+    }
+    getGroupByColumns() {
+        return this.groupByColumns;
+    }
+    toString() {
+        const selectParts = [];
+        for (const col of this.groupByColumns) {
+            selectParts.push(mysql_format_1.default.ident(col));
+        }
+        for (const entry of this.entries) {
+            selectParts.push(this.buildEntrySQL(entry));
+        }
+        if (selectParts.length === 0) {
+            selectParts.push('COUNT(*) AS `count`');
+        }
+        let query = `SELECT ${selectParts.join(', ')} FROM ${mysql_format_1.default.ident(this.tableName)}`;
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + (0, condition_collector_1.buildMysqlConditionsSQL)(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => mysql_format_1.default.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + (0, condition_collector_1.buildMysqlConditionsSQL)(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(o => `${mysql_format_1.default.ident(o.column)} ${o.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            query += ` OFFSET ${this.offsetValue}`;
+        }
+        return query;
+    }
+    buildEntrySQL(entry) {
+        let columnExpr;
+        if (entry.column === '*') {
+            columnExpr = '*';
+        }
+        else if (entry.distinct) {
+            columnExpr = `DISTINCT ${mysql_format_1.default.ident(entry.column)}`;
+        }
+        else {
+            columnExpr = mysql_format_1.default.ident(entry.column);
+        }
+        if (entry.filterConditions && entry.filterConditions.length > 0) {
+            const filterSQL = (0, condition_collector_1.buildMysqlConditionsSQL)(entry.filterConditions);
+            return this.buildFilteredAggregateSQL(entry.func, columnExpr, filterSQL, entry.alias);
+        }
+        if (entry.func === 'GROUP_CONCAT') {
+            return this.buildGroupConcatSQL(entry);
+        }
+        let sql = `${entry.func}(${columnExpr})`;
+        sql += ` AS ${mysql_format_1.default.ident(entry.alias)}`;
+        return sql;
+    }
+    buildGroupConcatSQL(entry) {
+        let inner = entry.distinct
+            ? `DISTINCT ${mysql_format_1.default.ident(entry.column)}`
+            : mysql_format_1.default.ident(entry.column);
+        if (entry.orderByColumn) {
+            inner += ` ORDER BY ${mysql_format_1.default.ident(entry.orderByColumn)} ${entry.orderByDirection || 'ASC'}`;
+        }
+        if (entry.separator !== undefined) {
+            inner += ` SEPARATOR ${mysql_format_1.default.literal(entry.separator)}`;
+        }
+        return `GROUP_CONCAT(${inner}) AS ${mysql_format_1.default.ident(entry.alias)}`;
+    }
+    buildFilteredAggregateSQL(func, columnExpr, filterSQL, alias) {
+        let caseExpr;
+        if (func === 'COUNT') {
+            caseExpr = `SUM(CASE WHEN ${filterSQL} THEN 1 ELSE 0 END)`;
+        }
+        else if (func === 'AVG' || func === 'MIN' || func === 'MAX') {
+            caseExpr = `${func}(CASE WHEN ${filterSQL} THEN ${columnExpr} ELSE NULL END)`;
+        }
+        else {
+            caseExpr = `${func}(CASE WHEN ${filterSQL} THEN ${columnExpr} ELSE 0 END)`;
+        }
+        return `${caseExpr} AS ${mysql_format_1.default.ident(alias)}`;
+    }
+}
+exports.MysqlAggregateQueryBuilder = MysqlAggregateQueryBuilder;

package/dist/cjs/mysql/select/index.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedScalarSelectBuilder = exports.MysqlScalarSelectBuilder = exports.createMysqlScalarTableAccessor = exports.MysqlScalarQueryBuilderImpl = exports.MysqlAggregateQueryBuilder = exports.createMysqlJoinManyBuilder = exports.MysqlJoinManyBuilder = exports.createMysqlJoinConditionBuilder = exports.MysqlJoinConditionBuilder = exports.MysqlAggregateFunctions = exports.MysqlSqlExpression = exports.isMysqlColumnRef = exports.mysqlColumnRefsEqual = exports.mysqlColumnRefToSQLUnqualified = exports.mysqlColumnRefToSQL = exports.createMysqlJoinCallbackParams = exports.createMysqlTableProxy = exports.MYSQL_JOIN_SETUP = exports.MYSQL_JOIN_INTERNAL = exports.MysqlSelectBuilder = void 0;
+var select_builder_1 = require("./select-builder.cjs");
+Object.defineProperty(exports, "MysqlSelectBuilder", { enumerable: true, get: function () { return select_builder_1.MysqlSelectBuilder; } });
+var join_internals_1 = require("./join-internals.cjs");
+Object.defineProperty(exports, "MYSQL_JOIN_INTERNAL", { enumerable: true, get: function () { return join_internals_1.MYSQL_JOIN_INTERNAL; } });
+Object.defineProperty(exports, "MYSQL_JOIN_SETUP", { enumerable: true, get: function () { return join_internals_1.MYSQL_JOIN_SETUP; } });
+var table_proxy_1 = require("./table-proxy.cjs");
+Object.defineProperty(exports, "createMysqlTableProxy", { enumerable: true, get: function () { return table_proxy_1.createMysqlTableProxy; } });
+Object.defineProperty(exports, "createMysqlJoinCallbackParams", { enumerable: true, get: function () { return table_proxy_1.createMysqlJoinCallbackParams; } });
+Object.defineProperty(exports, "mysqlColumnRefToSQL", { enumerable: true, get: function () { return table_proxy_1.mysqlColumnRefToSQL; } });
+Object.defineProperty(exports, "mysqlColumnRefToSQLUnqualified", { enumerable: true, get: function () { return table_proxy_1.mysqlColumnRefToSQLUnqualified; } });
+Object.defineProperty(exports, "mysqlColumnRefsEqual", { enumerable: true, get: function () { return table_proxy_1.mysqlColumnRefsEqual; } });
+Object.defineProperty(exports, "isMysqlColumnRef", { enumerable: true, get: function () { return table_proxy_1.isMysqlColumnRef; } });
+var sql_expression_1 = require("./sql-expression.cjs");
+Object.defineProperty(exports, "MysqlSqlExpression", { enumerable: true, get: function () { return sql_expression_1.MysqlSqlExpression; } });
+Object.defineProperty(exports, "MysqlAggregateFunctions", { enumerable: true, get: function () { return sql_expression_1.MysqlAggregateFunctions; } });
+var join_condition_builder_1 = require("./join-condition-builder.cjs");
+Object.defineProperty(exports, "MysqlJoinConditionBuilder", { enumerable: true, get: function () { return join_condition_builder_1.MysqlJoinConditionBuilder; } });
+Object.defineProperty(exports, "createMysqlJoinConditionBuilder", { enumerable: true, get: function () { return join_condition_builder_1.createMysqlJoinConditionBuilder; } });
+var join_builder_1 = require("./join-builder.cjs");
+Object.defineProperty(exports, "MysqlJoinManyBuilder", { enumerable: true, get: function () { return join_builder_1.MysqlJoinManyBuilder; } });
+Object.defineProperty(exports, "createMysqlJoinManyBuilder", { enumerable: true, get: function () { return join_builder_1.createMysqlJoinManyBuilder; } });
+var aggregate_builder_1 = require("./aggregate-builder.cjs");
+Object.defineProperty(exports, "MysqlAggregateQueryBuilder", { enumerable: true, get: function () { return aggregate_builder_1.MysqlAggregateQueryBuilder; } });
+var scalar_query_builder_1 = require("./scalar-query-builder.cjs");
+Object.defineProperty(exports, "MysqlScalarQueryBuilderImpl", { enumerable: true, get: function () { return scalar_query_builder_1.MysqlScalarQueryBuilderImpl; } });
+Object.defineProperty(exports, "createMysqlScalarTableAccessor", { enumerable: true, get: function () { return scalar_query_builder_1.createMysqlScalarTableAccessor; } });
+var scalar_select_builder_1 = require("./scalar-select-builder.cjs");
+Object.defineProperty(exports, "MysqlScalarSelectBuilder", { enumerable: true, get: function () { return scalar_select_builder_1.MysqlScalarSelectBuilder; } });
+Object.defineProperty(exports, "MysqlConnectedScalarSelectBuilder", { enumerable: true, get: function () { return scalar_select_builder_1.MysqlConnectedScalarSelectBuilder; } });