@relq/orm 0.1.3 → 0.1.5

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

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlJoinManyBuilder = void 0;
+exports.createMysqlJoinManyBuilder = createMysqlJoinManyBuilder;
+const join_condition_builder_1 = require("./join-condition-builder.cjs");
+const table_proxy_1 = require("./table-proxy.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+class MysqlJoinManyBuilder extends join_condition_builder_1.MysqlJoinConditionBuilder {
+    orderBySpecs = [];
+    selectColumns = [];
+    limitValue;
+    offsetValue;
+    groupByColumns = [];
+    havingConditions = [];
+    selectRefs(columns) {
+        this.selectColumns = columns;
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderBySpecs.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    having(callback) {
+        const collector = new condition_collector_1.MysqlConditionCollector();
+        callback(collector);
+        this.havingConditions.push(...collector.getConditions());
+        return this;
+    }
+    hasQueryModifiers() {
+        return (this.orderBySpecs.length > 0 ||
+            this.selectColumns.length > 0 ||
+            this.limitValue !== undefined ||
+            this.offsetValue !== undefined ||
+            this.groupByColumns.length > 0 ||
+            this.havingConditions.length > 0);
+    }
+    getSelectColumns() {
+        return [...this.selectColumns];
+    }
+    getOrderBySpecs() {
+        return [...this.orderBySpecs];
+    }
+    getLimit() {
+        return this.limitValue;
+    }
+    getOffset() {
+        return this.offsetValue;
+    }
+    toCorrelatedSubquerySQL(rightTable, rightAlias, leftAlias) {
+        const selectPart = this.buildSelectPart();
+        const fromPart = mysql_format_1.default.ident(rightTable);
+        const wherePart = this.buildWherePart(leftAlias);
+        const groupByPart = this.buildGroupByPart();
+        const havingPart = this.buildHavingPart();
+        const orderByPart = this.buildOrderByPart();
+        const limitPart = this.buildLimitPart();
+        let innerQuery = `SELECT ${selectPart} FROM ${fromPart}`;
+        if (wherePart) {
+            innerQuery += ` WHERE ${wherePart}`;
+        }
+        if (groupByPart) {
+            innerQuery += ` GROUP BY ${groupByPart}`;
+        }
+        if (havingPart) {
+            innerQuery += ` HAVING ${havingPart}`;
+        }
+        if (orderByPart) {
+            innerQuery += ` ORDER BY ${orderByPart}`;
+        }
+        if (limitPart) {
+            innerQuery += limitPart;
+        }
+        const jsonObjectParts = this.buildJsonObjectParts();
+        let wrappedQuery;
+        if (jsonObjectParts) {
+            wrappedQuery = `SELECT COALESCE(JSON_ARRAYAGG(JSON_OBJECT(${jsonObjectParts})), CAST('[]' AS JSON)) AS ${mysql_format_1.default.ident(rightAlias)} FROM (${innerQuery}) AS \`sub\``;
+        }
+        else {
+            wrappedQuery = `SELECT COALESCE(JSON_ARRAYAGG(\`sub\`.\`__json\`), CAST('[]' AS JSON)) AS ${mysql_format_1.default.ident(rightAlias)} FROM (SELECT JSON_OBJECT(${this.buildAutoJsonObjectSQL(rightTable)}) AS \`__json\` FROM (${innerQuery}) AS \`inner_sub\`) AS \`sub\``;
+        }
+        return `(${wrappedQuery})`;
+    }
+    toSubquerySQL(rightTable, leftAlias) {
+        const selectPart = this.buildSelectPart();
+        const fromPart = mysql_format_1.default.ident(rightTable);
+        const wherePart = this.buildWherePart(leftAlias);
+        const groupByPart = this.buildGroupByPart();
+        const havingPart = this.buildHavingPart();
+        const orderByPart = this.buildOrderByPart();
+        const limitPart = this.buildLimitPart();
+        let query = `SELECT ${selectPart} FROM ${fromPart}`;
+        if (wherePart) {
+            query += ` WHERE ${wherePart}`;
+        }
+        if (groupByPart) {
+            query += ` GROUP BY ${groupByPart}`;
+        }
+        if (havingPart) {
+            query += ` HAVING ${havingPart}`;
+        }
+        if (orderByPart) {
+            query += ` ORDER BY ${orderByPart}`;
+        }
+        if (limitPart) {
+            query += limitPart;
+        }
+        return query;
+    }
+    buildSelectPart() {
+        if (this.selectColumns.length === 0) {
+            return '*';
+        }
+        return this.selectColumns
+            .map(col => (0, table_proxy_1.mysqlColumnRefToSQLUnqualified)(col))
+            .join(', ');
+    }
+    buildWherePart(_leftAlias) {
+        const parts = [];
+        for (const cond of this.conditions) {
+            if (cond.type === 'using' || cond.type === 'raw') {
+                if (cond.raw)
+                    parts.push(cond.raw);
+                continue;
+            }
+            if (cond.type === 'ilike') {
+                const leftSQL = (0, table_proxy_1.mysqlColumnRefToSQL)(cond.left);
+                const rightSQL = this.formatRightSide(cond.right);
+                parts.push(`LOWER(${leftSQL}) LIKE LOWER(${rightSQL})`);
+                continue;
+            }
+            const leftSQL = (0, table_proxy_1.mysqlColumnRefToSQL)(cond.left);
+            const rightSQL = this.formatRightSide(cond.right);
+            parts.push(`${leftSQL} ${cond.operator} ${rightSQL}`);
+        }
+        if (this.whereConditions.length > 0) {
+            const whereSQL = (0, condition_collector_1.buildMysqlConditionsSQL)(this.whereConditions);
+            if (whereSQL) {
+                parts.push(whereSQL);
+            }
+        }
+        return parts.length > 0 ? parts.join(' AND ') : null;
+    }
+    buildGroupByPart() {
+        if (this.groupByColumns.length === 0) {
+            return null;
+        }
+        return this.groupByColumns
+            .map(col => (0, table_proxy_1.mysqlColumnRefToSQLUnqualified)(col))
+            .join(', ');
+    }
+    buildHavingPart() {
+        if (this.havingConditions.length === 0) {
+            return null;
+        }
+        return (0, condition_collector_1.buildMysqlConditionsSQL)(this.havingConditions);
+    }
+    buildOrderByPart() {
+        if (this.orderBySpecs.length === 0) {
+            return null;
+        }
+        return this.orderBySpecs
+            .map(spec => `${(0, table_proxy_1.mysqlColumnRefToSQLUnqualified)(spec.column)} ${spec.direction}`)
+            .join(', ');
+    }
+    buildLimitPart() {
+        let sql = '';
+        if (this.limitValue !== undefined) {
+            sql += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            sql += ` OFFSET ${this.offsetValue}`;
+        }
+        return sql;
+    }
+    buildJsonObjectParts() {
+        if (this.selectColumns.length === 0) {
+            return null;
+        }
+        return this.selectColumns
+            .map(col => `${mysql_format_1.default.literal(col.$sqlColumn)}, \`sub\`.${(0, table_proxy_1.mysqlColumnRefToSQLUnqualified)(col)}`)
+            .join(', ');
+    }
+    buildAutoJsonObjectSQL(_rightTable) {
+        return "'__all', \`inner_sub\`.*";
+    }
+}
+exports.MysqlJoinManyBuilder = MysqlJoinManyBuilder;
+function createMysqlJoinManyBuilder() {
+    return new MysqlJoinManyBuilder();
+}

package/dist/cjs/mysql/select/join-condition-builder.cjs

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlJoinConditionBuilder = void 0;
+exports.createMysqlJoinConditionBuilder = createMysqlJoinConditionBuilder;
+const table_proxy_1 = require("./table-proxy.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const join_internals_1 = require("./join-internals.cjs");
+class MysqlJoinConditionBuilder {
+    conditions = [];
+    whereConditions = [];
+    selectedColumns;
+    flatConfig;
+    equal(left, right) {
+        this.conditions.push({
+            type: 'equal',
+            left,
+            right,
+            operator: '='
+        });
+        return this;
+    }
+    notEqual(left, right) {
+        this.conditions.push({
+            type: 'notEqual',
+            left,
+            right,
+            operator: '!='
+        });
+        return this;
+    }
+    greaterThan(left, right) {
+        this.conditions.push({
+            type: 'greaterThan',
+            left,
+            right,
+            operator: '>'
+        });
+        return this;
+    }
+    lessThan(left, right) {
+        this.conditions.push({
+            type: 'lessThan',
+            left,
+            right,
+            operator: '<'
+        });
+        return this;
+    }
+    greaterThanOrEqual(left, right) {
+        this.conditions.push({
+            type: 'greaterThanOrEqual',
+            left,
+            right,
+            operator: '>='
+        });
+        return this;
+    }
+    lessThanOrEqual(left, right) {
+        this.conditions.push({
+            type: 'lessThanOrEqual',
+            left,
+            right,
+            operator: '<='
+        });
+        return this;
+    }
+    like(left, right) {
+        this.conditions.push({
+            type: 'like',
+            left,
+            right,
+            operator: 'LIKE'
+        });
+        return this;
+    }
+    ilike(left, right) {
+        this.conditions.push({
+            type: 'ilike',
+            left,
+            right,
+            operator: 'LIKE'
+        });
+        return this;
+    }
+    using(...columns) {
+        this.conditions.push({
+            type: 'using',
+            columns: columns
+        });
+        return this;
+    }
+    where(callback) {
+        const collector = new condition_collector_1.MysqlConditionCollector();
+        callback(collector);
+        this.whereConditions.push(...collector.getConditions());
+        return this;
+    }
+    select(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            this.selectedColumns = args[0];
+        }
+        else {
+            this.selectedColumns = args;
+        }
+        return this;
+    }
+    flat() {
+        if (!this.selectedColumns || this.selectedColumns.length === 0) {
+            throw new Error('Relq: .flat() requires .select() with explicit columns.');
+        }
+        this.flatConfig = { mode: 'prefix' };
+        return this;
+    }
+    get [join_internals_1.MYSQL_JOIN_INTERNAL]() {
+        return {
+            toSQL: () => this.internalToSQL(),
+            isUsingJoin: () => this.internalIsUsingJoin(),
+            getUsingColumns: () => this.internalGetUsingColumns(),
+            toUsingSQL: () => this.internalToUsingSQL(),
+            getConditions: () => [...this.conditions],
+            getWhereConditions: () => [...this.whereConditions],
+            hasConditions: () => this.conditions.length > 0,
+            hasWhereConditions: () => this.whereConditions.length > 0,
+            getSelectedColumns: () => this.selectedColumns ?? null,
+            getFlatConfig: () => this.flatConfig ?? null,
+        };
+    }
+    internalToSQL() {
+        const parts = [];
+        for (const cond of this.conditions) {
+            switch (cond.type) {
+                case 'using':
+                    break;
+                case 'raw':
+                    parts.push(cond.raw);
+                    break;
+                case 'ilike': {
+                    const leftSQL = (0, table_proxy_1.mysqlColumnRefToSQL)(cond.left);
+                    const rightSQL = this.formatRightSide(cond.right);
+                    parts.push(`LOWER(${leftSQL}) LIKE LOWER(${rightSQL})`);
+                    break;
+                }
+                default: {
+                    const leftSQL = (0, table_proxy_1.mysqlColumnRefToSQL)(cond.left);
+                    const rightSQL = this.formatRightSide(cond.right);
+                    parts.push(`${leftSQL} ${cond.operator} ${rightSQL}`);
+                    break;
+                }
+            }
+        }
+        if (this.whereConditions.length > 0) {
+            const whereSQL = (0, condition_collector_1.buildMysqlConditionsSQL)(this.whereConditions);
+            if (whereSQL) {
+                parts.push(whereSQL);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    internalIsUsingJoin() {
+        return this.conditions.length === 1 && this.conditions[0].type === 'using';
+    }
+    internalGetUsingColumns() {
+        if (!this.internalIsUsingJoin())
+            return null;
+        return this.conditions[0].columns || null;
+    }
+    internalToUsingSQL() {
+        const columns = this.internalGetUsingColumns();
+        if (!columns)
+            return null;
+        return `USING (${columns.map(c => mysql_format_1.default.ident(c)).join(', ')})`;
+    }
+    formatRightSide(right) {
+        if ((0, table_proxy_1.isMysqlColumnRef)(right)) {
+            return (0, table_proxy_1.mysqlColumnRefToSQL)(right);
+        }
+        if (right === null) {
+            return 'NULL';
+        }
+        if (typeof right === 'boolean') {
+            return right ? 'true' : 'false';
+        }
+        if (typeof right === 'number') {
+            return String(right);
+        }
+        if (typeof right === 'string') {
+            return mysql_format_1.default.literal(right);
+        }
+        if (right instanceof Date) {
+            return mysql_format_1.default.literal(right.toISOString());
+        }
+        if (Array.isArray(right)) {
+            return `(${right.map(v => this.formatRightSide(v)).join(', ')})`;
+        }
+        return mysql_format_1.default.literal(JSON.stringify(right));
+    }
+}
+exports.MysqlJoinConditionBuilder = MysqlJoinConditionBuilder;
+function createMysqlJoinConditionBuilder() {
+    return new MysqlJoinConditionBuilder();
+}

package/dist/cjs/mysql/select/join-internals.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MYSQL_JOIN_SETUP = exports.MYSQL_JOIN_INTERNAL = void 0;
+exports.MYSQL_JOIN_INTERNAL = Symbol.for('mysql-join-internal');
+exports.MYSQL_JOIN_SETUP = Symbol.for('mysql-join-setup');

package/dist/cjs/mysql/select/scalar-query-builder.cjs

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlScalarQueryBuilderImpl = void 0;
+exports.createMysqlScalarTableAccessor = createMysqlScalarTableAccessor;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+class MysqlScalarResultImpl {
+    sql;
+    params;
+    $scalar = true;
+    $type;
+    constructor(sql, params = []) {
+        this.sql = sql;
+        this.params = params;
+    }
+    toSQL() {
+        return this.sql;
+    }
+    getParams() {
+        return this.params;
+    }
+}
+class MysqlScalarQueryBuilderImpl {
+    tableName;
+    tableSchema;
+    columnResolver;
+    whereConditions = [];
+    constructor(tableName, tableSchema, columnResolver) {
+        this.tableName = tableName;
+        this.tableSchema = tableSchema;
+        this.columnResolver = columnResolver;
+    }
+    where(callback) {
+        const conditionBuilder = new condition_collector_1.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(${mysql_format_1.default.ident(sqlColumn)}), 0)`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    avg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(AVG(${mysql_format_1.default.ident(sqlColumn)}), 0)`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    min(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MIN(${mysql_format_1.default.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    max(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MAX(${mysql_format_1.default.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    pick(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(mysql_format_1.default.ident(sqlColumn), true);
+        return new MysqlScalarResultImpl(sql);
+    }
+    exists() {
+        const whereClause = this.buildWhereClause();
+        const sql = `(EXISTS(SELECT 1 FROM ${mysql_format_1.default.ident(this.tableName)}${whereClause}))`;
+        return new MysqlScalarResultImpl(sql);
+    }
+    countDistinct(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COUNT(DISTINCT ${mysql_format_1.default.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    stringAgg(column, delimiter = ', ') {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`GROUP_CONCAT(${mysql_format_1.default.ident(sqlColumn)} SEPARATOR ${mysql_format_1.default.literal(delimiter)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    arrayAgg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(JSON_ARRAYAGG(${mysql_format_1.default.ident(sqlColumn)}), JSON_ARRAY())`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    jsonAgg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(JSON_ARRAYAGG(${mysql_format_1.default.ident(sqlColumn)}), JSON_ARRAY())`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    boolAnd(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MIN(${mysql_format_1.default.ident(sqlColumn)})`);
+        return new MysqlScalarResultImpl(sql);
+    }
+    boolOr(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MAX(${mysql_format_1.default.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 ${(0, condition_collector_1.buildMysqlConditionsSQL)(transformed)}`;
+    }
+    buildSQL(selectExpr, withLimit = false) {
+        const whereClause = this.buildWhereClause();
+        const limitClause = withLimit ? ' LIMIT 1' : '';
+        return `(SELECT ${selectExpr} FROM ${mysql_format_1.default.ident(this.tableName)}${whereClause}${limitClause})`;
+    }
+}
+exports.MysqlScalarQueryBuilderImpl = MysqlScalarQueryBuilderImpl;
+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/cjs/mysql/select/scalar-select-builder.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedScalarSelectBuilder = exports.MysqlScalarSelectBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const scalar_query_builder_1 = require("./scalar-query-builder.cjs");
+class MysqlScalarSelectBuilder {
+    executeQuery;
+    scalarResults;
+    constructor(scalars, schema, executeQuery, getColumnResolver) {
+        this.executeQuery = executeQuery;
+        const tableAccessor = (0, scalar_query_builder_1.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 ${mysql_format_1.default.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;
+    }
+}
+exports.MysqlScalarSelectBuilder = MysqlScalarSelectBuilder;
+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);
+    }
+}
+exports.MysqlConnectedScalarSelectBuilder = MysqlConnectedScalarSelectBuilder;