代码拉取完成，页面将自动刷新
更新失败，请稍后重试！
/
详情
BindQuery字段排序异常，生成的SQL使用字段别名导致无效 （v2.9）
评论 (2)
Vincent Van
创建了任务
误判申诉
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
取消
提交
原值
BindQuery字段排序异常：column "XXX" does not exist （v2.9）
新值
BindQuery字段排序异常，生成的SQL使用字段别名导致无效 （v2.9）
原值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
新值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
原值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
新值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
问题1： 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
问题2： 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
```
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
```
加粗部分是缺失的，加上后才可以生成正确SQL。
原值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
问题1： 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
问题2： 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
```
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
```
加粗部分是缺失的，加上后才可以生成正确SQL。
新值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
**问题1：** 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
**问题2：** 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
```
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
```
加粗部分是缺失的，加上后才可以生成正确SQL。
原值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
**问题1：** 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
**问题2：** 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
```
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
```
加粗部分是缺失的，加上后才可以生成正确SQL。
新值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
**问题1：** 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
**问题2：** 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
加粗部分是缺失的，加上后才可以生成正确SQL。
原值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
**问题1：** 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
**问题2：** 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
加粗部分是缺失的，加上后才可以生成正确SQL。
新值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
**问题1：** 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
**问题2：** 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
```
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
```
加粗部分是缺失的，加上“self.” + 后才可以生成正确SQL。
原值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
**问题1：** 存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
**问题2：** 当排序操作的列为关联表绑定列且关联表包含与主表同名字段，且该字段同时被查询时，导致SQL无法确认需要查询的字段属于哪个表。
```
DynamicSqlProvider的buildDynamicSql方法内部行 123 开始：
String normalSql = segments.getNormal().getSqlSegment();
if (V.notEmpty(normalSql)) {
WHERE( **"self." + ** formatNormalSql(normalSql));
```
加粗部分是缺失的，加上“self.” + 后才可以生成正确SQL。
新值
已经配置了如下查询绑定字段
```
@BindQuery(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
@BindField(entity = Product.class, field = "productName", condition = "this.product_id=product_x.old_part_id and product_x.loc_id=this.loc_id and product_x.new_product_id=id")
private String newProductName;
```
当按newProductName进行排序且包含任意一个字段的查询的情况下（无查询时不会触发Bug）
DynamicSqlProvider的buildDynamicSql方法内部行 177 开始：
存在查询字段的情况下会有以下部分的代码对排序字段重新处理，但是该部分代码未处理排序字段的别名，导致无法找到需要排序的字段。
```
if(segments.getOrderBy() != null && !segments.getOrderBy().isEmpty()){
String orderBySql = segments.getOrderBy().getSqlSegment();
int beginIndex = S.indexOfIgnoreCase(orderBySql,"ORDER BY ");
if(beginIndex >= 0){
orderBySql = S.substring(orderBySql, beginIndex+"ORDER BY ".length());
ORDER_BY(orderBySql);
}
}
```
生成的错误SQL如下：
SELECT DISTINCT self.*,r3.product_name AS **r3_product_name__**
FROM stock self
LEFT OUTER JOIN product_rel r3m ON self.product_id = r3m.orig_product_id
LEFT OUTER JOIN product r3 ON r3m.tmr_product_id = r3.id
WHERE (self.loc_id = #{ew.paramNameValuePairs.MPGENVAL1})
ORDER BY **new_product_name** DESC
dibo-software
将任务状态从 待办的 修改为进行中
dibo-software
将任务状态从 进行中 修改为已完成
登录 后才可以发表评论