@aguesuka 是的，所以我采用的是比较迂回的方法，先解析表达式，然后在编译期覆盖代码实现的

期待 JDK 后续变化，我提个 issue 给 JDK

@cpstar 这是 OO 里最传统的想法，不能为了 OO 而去 OO，过于理论化的思考，而不考虑实际。

一个同环比的计算是最常见的：(sum(current) - sum(last)) / sum(last) * 100
这样的表达式用函数做就太复杂了

@ximigou007 我觉得是个人偏好的问题，只是 Java 的创始人不喜欢运算符重载，但它想的不够远

@Vedar 同意，我很敬佩 C++ 的设计者，他们能解决我们“不知道我们不知道的事情”

@no1xsyzy 不同的思考维度，肯定不是某一个，或某一些原因。

我们生活的世界有两个，一个是真实运行的世界，还有一个是脑子里的世界（也就是“应该”的世界），但两都往往偏差很大

@no1xsyzy 我相信 Java 后面必定会支持运算符重载，虽然现在没有真实的项目在用，我是第一个，国外有几篇论文在讨论。

DSL 是一个很泛的概念，SQL 是一个 DSL，基于 Java 的 API 封装的 SQL 不一定属于 DSL 的范畴，因为它是一个高度抽象的语言，存在的只是一堆 Interface，基于 Interface 可以实现很多特性

@no1xsyzy 小细节...

@no1xsyzy Smalltalk 是面向对象的鼻祖，很多概念都被借鉴了，为什么不能发展起来，也是有它内在的原因

@xzenge 有时候由不得你去选择，解决 Java 的运算符重载，也是被迫的

@lewis89 一个语言要能跟随的时代的发展，C++ 的设计就是为了解决“我们不知道的不知道的东西”，很伟大。

@PVG 认可你的想法，的确可以想干什么就干什么

没有运算符重载者是恶梦的开始

有兴趣的，可以交流

@zhangysh1995 [email protected]
ORM 性能问题不是慢 SQL，而是在大规模写和读时的性能，这块我还在优化，和 MyBatis 的性能差不多，但离 JDBC 原始 SQL 还是有差距。

我也在 gist 里回复了。

public List<User> searchUser(String name, Integer age) {
User.Table user = User.asTable();
Select select = new Select();
LogicalExpression predicate = new PolynaryExpression(EQ, $("1"), $("1"));

if(StringUtils.isNotBland(name)) {
predicate.and(user.name.eq(name));
}

if(age > 0) {
predicate.and(user.age.eq(age));
}

return select.orderBy(user.id.asc()).execute(User.class);
}

@beginor 所谓动态查询也就是根据不同的参数，join 不同的表，或者选择不同的条件，因为参与拼接的对象都是变量，本身就是动态的。

@beginor 给你一段项目的代码（计算一个商品销售的同环比），比较复杂：

你也可以把 SpringBoot 项目运行起来看效果：

https://github.com/braisdom/ObjectiveSql/blob/master/examples/springboot-sample/src/main/java/com/github/braisdom/objsql/sample/model/Product.java#L45


DateTime begin = DateTime.parse(rawBegin + " 00:00:00", DATE_TIME_FORMATTER);
DateTime end = DateTime.parse(rawEnd + " 23:59:59", DATE_TIME_FORMATTER);

// Creating dataset of target, last period and same period last year
Select target = createPeriodSales(rawBegin, rawEnd);
Select lp = createPeriodSales(minusMonths(begin, 1), minusMonths(end, 1));
Select sply = createPeriodSales(minusYears(begin, 1), minusYears(end, 1));

Select select = new Select();
select.from(target)
.leftOuterJoin(lp, createLPJoinCondition(target, lp))
.leftOuterJoin(sply, createSPLYJoinCondition(target, sply));

// Create calculation expression of last period
Expression lpAmount = createLPExpr(target, lp, "total_amount");
Expression lpOrderCount = createLPExpr(target, lp, "order_count");
Expression lpQuantity = createLPExpr(target, lp, "total_quantity");

// Create calculation expression of same period last year
Expression splyAmount = createSPLYExpr(target, sply, "total_amount");
Expression splyOrderCount = createSPLYExpr(target, sply, "order_count");
Expression splyQuantity = createSPLYExpr(target, sply, "total_quantity");

select.project(target.col("barcode"))
.project(target.col("sales_year"))
.project(target.col("sales_month"))
.project(formatMoney(lpAmount).as("amount_lp"))
.project(formatMoney(lpOrderCount).as("order_count_lp"))
.project(formatMoney(lpQuantity).as("quantity_lp"))
.project(formatMoney(splyAmount).as("amount_sply"))
.project(formatMoney(splyOrderCount).as("order_count_sply"))
.project(formatMoney(splyQuantity).as("quantity_sply"));

select.groupBy(target.col("barcode"),
target.col("sales_year"),
target.col("sales_month"));

return select.execute(Product.class);

@beginor

Order.Table orderTable = Order.asTable();
Select select = new Select();

select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between($("2020-10-10 00:00:00"), $("2020-10-30 23:59:59")))
.groupBy(orderTable.productId);

你可以看一下上述代码在 Jooq 中如果实现

JOOQ 称为动态查询，在 ObjectiveSQL 里称为复杂查询，详细请查询：2 复杂 SQL 查询