Node.js中基于函数式编程实现MySQL灵活复杂查询的技术咨询

这问题问到点子上了！在Node.js里用函数式风格构建SQL查询，既要保持简洁的FP体验，又要兼容MySQL的复杂语法（比如拼接表达式、JOIN关联），其实可以通过扩展你的基础函数体系来实现，既灵活又能避免SQL注入风险。下面一步步来拆解实现思路：

1. 重构基础查询配置：用对象承载查询元数据 #

首先，把你的select函数改成返回一个查询配置对象，而不是直接拼字符串。这样后续的where、join等函数都可以通过修改这个对象来叠加查询条件，完全符合FP的纯函数风格：

function select(table, columns = '*') {
  return {
    type: 'SELECT',
    table,
    columns: Array.isArray(columns) ? columns.join(', ') : columns,
    joins: [],
    where: []
  };
}

2. 让where支持多类型条件：从简单键值到复杂表达式 #

原来的where只处理{active: 1}这种简单键值对，现在我们扩展它，让它能接受字符串表达式、参数化数组甚至动态生成条件的函数，同时严格做参数化防止注入：

function where(condition) {
  return query => {
    const newQuery = {...query}; // 纯函数：不修改原对象，返回新对象
    let clauseConfig = { clauses: [], params: [] };

    if (typeof condition === 'object' && !Array.isArray(condition)) {
      // 处理简单键值对：{active: 1, role: 'admin'}
      clauseConfig.clauses = Object.entries(condition).map(([key, val]) => `${key} = ?`);
      clauseConfig.params = Object.values(condition);
    } else if (typeof condition === 'string') {
      // 处理纯SQL表达式：比如 "first_name + ' ' + last_name = 'John Smith'"
      // 注意：直接写字符串要避免注入，尽量用下面的参数化写法！
      clauseConfig.clauses = [condition];
    } else if (Array.isArray(condition)) {
      // 处理参数化表达式：[SQL模板, 参数数组]
      // 例如：["num_comments > STRLEN(CONCAT(first_name, ' ', last_name))", [10]]
      const [sqlTemplate, params] = condition;
      clauseConfig.clauses = [sqlTemplate];
      clauseConfig.params = params || [];
    } else if (typeof condition === 'function') {
      // 支持动态条件：比如根据上下文生成表达式
      clauseConfig = condition();
    }

    if (clauseConfig.clauses.length > 0) {
      newQuery.where.push(clauseConfig);
    }
    return newQuery;
  };
}

这样你就能灵活写复杂条件了：

// 简单键值
where({active: 1})
// 纯表达式（不推荐硬编码值，尽量用参数化）
where("first_name + ' ' + last_name = 'John Smith'")
// 参数化复杂表达式（安全！）
where(["num_comments > STRLEN(CONCAT(first_name, ' ', last_name))", [10]])

3. 新增join系列函数：支持各种关联类型 #

要处理JOIN，我们可以新增join、leftJoin等函数，同样支持简单关联和复杂参数化条件：

// 基础JOIN函数，支持自定义关联类型
function join(type, table, onCondition) {
  return query => {
    const newQuery = {...query};
    let onClause = '';
    let params = [];

    if (typeof onCondition === 'object') {
      // 简单关联：{users.id: 'posts.user_id'}
      onClause = Object.entries(onCondition).map(([left, right]) => `${left} = ${right}`).join(' AND ');
    } else if (typeof onCondition === 'string') {
      // 纯SQL关联条件
      onClause = onCondition;
    } else if (Array.isArray(onCondition)) {
      // 参数化关联条件：["users.id = posts.user_id AND posts.status = ?", ['published']]
      [onClause, params] = onCondition;
    }

    newQuery.joins.push({ type, table, onClause, params });
    return newQuery;
  };
}

// 封装常用的关联类型，简化调用
function innerJoin(table, onCondition) {
  return join('INNER JOIN', table, onCondition);
}

function leftJoin(table, onCondition) {
  return join('LEFT JOIN', table, onCondition);
}

调用示例：

leftJoin('posts', ["users.id = posts.user_id AND posts.created_at > ?", [new Date('2024-01-01')]])

4. 核心exec函数：把配置转换成可执行的SQL #

最后，exec函数要把所有查询配置拼接成完整的SQL语句，收集所有参数，然后调用MySQL驱动执行：

const mysql = require('mysql2/promise');

// 假设你已经初始化了数据库连接池
const dbPool = mysql.createPool({
  host: 'localhost',
  user: 'your_user',
  password: 'your_pass',
  database: 'your_db',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
});

async function exec(...queryModifiers) {
  // 初始化基础查询
  let query = {
    type: 'SELECT',
    table: '',
    columns: '*',
    joins: [],
    where: []
  };

  // 应用所有查询修改器（select、where、join等）
  queryModifiers.forEach(modifier => {
    query = modifier(query);
  });

  // 构建SQL语句
  let sql = `SELECT ${query.columns} FROM ${query.table}`;

  // 拼接JOIN语句
  if (query.joins.length > 0) {
    sql += ' ' + query.joins.map(j => `${j.type} ${j.table} ON ${j.onClause}`).join(' ');
  }

  // 拼接WHERE条件
  if (query.where.length > 0) {
    const allClauses = query.where.flatMap(w => w.clauses);
    sql += ' WHERE ' + allClauses.join(' AND ');
  }

  // 收集所有参数（防止注入的关键）
  const allParams = query.where.flatMap(w => w.params).concat(query.joins.flatMap(j => j.params));

  // 执行查询并返回结果
  const [rows] = await dbPool.execute(sql, allParams);
  return rows;
}

5. 完整复杂场景示例 #

现在你可以组合这些函数，实现任意复杂的查询了：

async function getActiveUsersWithPosts() {
  const result = await exec(
    select('users', ['users.id', 'CONCAT(users.first_name, " ", users.last_name) AS full_name']),
    leftJoin('posts', ["users.id = posts.user_id AND posts.status = ?", ['published']]),
    where({users.active: 1}),
    where(["COUNT(posts.id) > STRLEN(users.first_name)", []]),
    where(["posts.created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY)", []])
  );
  return result;
}

进阶优化建议 #

• 新增orWhere函数：实现OR连接的条件，只需要修改where的拼接逻辑，用OR替代AND。
• 支持排序、分页：新增orderBy、limit函数，扩展查询配置对象。
• 用管道函数组合：比如用pipe函数把多个修改器链式组合，更符合FP风格：pipe(select('users'), where(...), leftJoin(...))()

内容的提问来源于stack exchange，提问作者user2693928