v2.0-beta1

全部细节优化

easy-es-common/src/main/java/cn/easyes/common/enums/EsQueryTypeEnum.java

@@ -92,19 +92,19 @@ public enum EsQueryTypeEnum {
     /**
      * 与条件,相当于MYSQL中的AND，必须满足且返回得分
      */
-    AND_MUST,
+    NESTED_AND,
     /**
      * 取反的与条件，必须不满足
      */
-    MUST_NOT,
+    NESTED_NOT,
     /**
      * 与条件必须满足，但不返回得分，效率更高
      */
-    AND_FILTER,
+    NESTED_FILTER,
     /**
      * 或条件，相当于MYSQL中的OR 和MP中的or嵌套用法一致
      */
-    OR_SHOULD,
+    NESTED_OR,
     /**
      * 嵌套查询 ES独有 对嵌套类型的查询
      */

easy-es-core/src/main/java/cn/easyes/core/conditions/function/Index.java

@@ -17,7 +17,7 @@ public interface Index<Children, R> extends Serializable {
      * 设置索引名称
      *
      * @param indexNames 索引名称
-     * @return 泛型
+     * @return wrapper
      */
     Children indexName(String... indexNames);
 
@@ -25,7 +25,7 @@ public interface Index<Children, R> extends Serializable {
      * 设置最大返回数
      *
      * @param maxResultWindow 最大返回数
-     * @return 泛型
+     * @return wrapper
      */
     Children maxResultWindow(Integer maxResultWindow);
 
@@ -34,7 +34,7 @@ public interface Index<Children, R> extends Serializable {
      *
      * @param shards   分片数
      * @param replicas 副本数
-     * @return 泛型
+     * @return wrapper
      */
     Children settings(Integer shards, Integer replicas);
 
@@ -42,7 +42,7 @@ public interface Index<Children, R> extends Serializable {
      * 用户手动指定的settings
      *
      * @param settings settings
-     * @return 泛型
+     * @return wrapper
      */
     Children settings(Settings settings);
 
@@ -50,39 +50,107 @@ public interface Index<Children, R> extends Serializable {
      * 用户自行指定mapping
      *
      * @param mapping mapping信息
-     * @return 泛型
+     * @return wrapper
      */
     Children mapping(Map<String, Object> mapping);
 
-
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列
+     * @param fieldType es中的索引类型
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType) {
         return mapping(column, fieldType, null, null, null, null, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列
+     * @param fieldType es中的类型
+     * @param fieldData 是否支持text字段聚合
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, Boolean fieldData) {
         return mapping(column, fieldType, null, null, null, fieldData, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column
+     * @param fieldType es中的类型
+     * @param boost     权重
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, Float boost) {
         return mapping(column, fieldType, null, null, null, null, boost);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列
+     * @param fieldType es中的类型
+     * @param fieldData 是否支持text字段聚合
+     * @param boost     权重
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, Boolean fieldData, Float boost) {
         return mapping(column, fieldType, null, null, null, fieldData, boost);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column     列
+     * @param fieldType  es中的类型
+     * @param dateFormat 日期格式
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, String dateFormat) {
         return mapping(column, fieldType, null, null, dateFormat, null, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column         列
+     * @param fieldType      es中的类型
+     * @param analyzer       索引分词器
+     * @param searchAnalyzer 查询分词器
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, String analyzer, String searchAnalyzer) {
         return mapping(column, fieldType, analyzer, searchAnalyzer, null, null, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column         列
+     * @param fieldType      es中的类型
+     * @param analyzer       索引分词器
+     * @param searchAnalyzer 查询分词器
+     * @param dateFormat     日期格式
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, String analyzer, String searchAnalyzer, String dateFormat) {
         return mapping(column, fieldType, analyzer, searchAnalyzer, dateFormat, null, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column         列名
+     * @param fieldType      es中的类型
+     * @param analyzer       索引分词器
+     * @param searchAnalyzer 查询分词器
+     * @param boost          权重
+     * @return wrapper
+     */
     default Children mapping(R column, FieldType fieldType, String analyzer, String searchAnalyzer, Float boost) {
         return mapping(column, fieldType, analyzer, searchAnalyzer, null, null, boost);
     }
@@ -97,38 +165,97 @@ public interface Index<Children, R> extends Serializable {
      * @param dateFormat     日期格式
      * @param fieldData      是否支持text字段聚合
      * @param boost          权重值
-     * @return 泛型
+     * @return wrapper
      */
     default Children mapping(R column, FieldType fieldType, String analyzer, String searchAnalyzer, String dateFormat, Boolean fieldData, Float boost) {
         return mapping(FieldUtils.getFieldName(column), fieldType, analyzer, searchAnalyzer, dateFormat, fieldData, boost);
     }
 
-
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列名 字符串
+     * @param fieldType es中的类型
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType) {
         return mapping(column, fieldType, null, null, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列名 字符串
+     * @param fieldType es中的类型
+     * @param fieldData 是否支持text字段聚合
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType, Boolean fieldData) {
         return mapping(column, fieldType, null, null, fieldData, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列名 字符串
+     * @param fieldType es中的类型
+     * @param boost     权重
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType, Float boost) {
         return mapping(column, fieldType, null, null, null, boost);
     }
 
-
+    /**
+     * 设置mapping信息
+     *
+     * @param column    列名 字符串
+     * @param fieldType es中的类型
+     * @param analyzer  索引分词器
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType, String analyzer) {
         return mapping(column, fieldType, analyzer, null, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column         列名 字符串
+     * @param fieldType      es中的类型
+     * @param analyzer       索引分词器
+     * @param searchAnalyzer 查询分词器
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType, String analyzer, String searchAnalyzer) {
         return mapping(column, fieldType, analyzer, searchAnalyzer, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column         列名 字符串
+     * @param fieldType      es中的类型
+     * @param analyzer       索引分词器
+     * @param searchAnalyzer 查询分词器
+     * @param fieldData      是否支持text字段聚合
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType, String analyzer, String searchAnalyzer, Boolean fieldData) {
         return mapping(column, fieldType, analyzer, searchAnalyzer, fieldData, null);
     }
 
+    /**
+     * 设置mapping信息
+     *
+     * @param column         列名 字符串
+     * @param fieldType      es中的类型
+     * @param analyzer       索引分词器类型
+     * @param searchAnalyzer 查询分词器类型
+     * @param fieldData      是否支持text字段聚合
+     * @param boost          权重
+     * @return wrapper
+     */
     default Children mapping(String column, FieldType fieldType, String analyzer, String searchAnalyzer, Boolean fieldData, Float boost) {
         return mapping(column, fieldType, analyzer, searchAnalyzer, null, fieldData, boost);
     }
@@ -137,14 +264,14 @@ public interface Index<Children, R> extends Serializable {
     /**
      * 设置mapping信息
      *
-     * @param column         列名
+     * @param column         列名 字符串
      * @param fieldType      es中的类型
-     * @param analyzer       分词器类型
+     * @param analyzer       索引分词器类型
      * @param searchAnalyzer 查询分词器类型
      * @param dateFormat     日期格式
      * @param fieldData      是否支持text字段聚合
      * @param boost          字段权重值
-     * @return 泛型
+     * @return wrapper
      */
     Children mapping(String column, FieldType fieldType, String analyzer, String searchAnalyzer, String dateFormat, Boolean fieldData, Float boost);
 
@@ -152,11 +279,18 @@ public interface Index<Children, R> extends Serializable {
      * 设置创建别名信息
      *
      * @param aliasName 别名
-     * @return 泛型
+     * @return wrapper
      */
     Children createAlias(String aliasName);
 
-
+    /**
+     * 设置父子类型信息
+     *
+     * @param column     列
+     * @param parentName 父名称
+     * @param childName  子名称
+     * @return wrapper
+     */
     default Children join(R column, String parentName, String childName) {
         return join(FieldUtils.getFieldName(childName), parentName, childName);
     }
@@ -164,10 +298,10 @@ public interface Index<Children, R> extends Serializable {
     /**
      * 设置父子类型信息
      *
-     * @param column     列名
+     * @param column     列名 字符串
      * @param parentName 父名称
      * @param childName  子名称
-     * @return 泛型
+     * @return wrapper
      */
     Children join(String column, String parentName, String childName);
 }

easy-es-core/src/main/java/cn/easyes/core/conditions/function/Join.java

@@ -11,7 +11,7 @@ public interface Join<Children> extends Serializable {
     /**
      * 拼接filter
      *
-     * @return 泛型
+     * @return wrapper
      */
     default Children filter() {
         return filter(true);
@@ -20,15 +20,15 @@ public interface Join<Children> extends Serializable {
     /**
      * 拼接filter
      *
-     * @param condition 条件
+     * @param condition 执行条件
-     * @return 泛型
+     * @return wrapper
      */
     Children filter(boolean condition);
 
     /**
      * 拼接or
      *
-     * @return 泛型
+     * @return wrapper
      */
     default Children or() {
         return or(true);
@@ -37,15 +37,15 @@ public interface Join<Children> extends Serializable {
     /**
      * 拼接 OR
      *
-     * @param condition 条件
+     * @param condition 执行条件
-     * @return 泛型
+     * @return wrapper
      */
     Children or(boolean condition);
 
     /**
      * 拼接not
      *
-     * @return 泛型
+     * @return wrapper
      */
     default Children not() {
         return not(true);
@@ -54,8 +54,8 @@ public interface Join<Children> extends Serializable {
     /**
      * 拼接not
      *
-     * @param condition 条件
+     * @param condition 执行条件
-     * @return 泛型
+     * @return wrapper
      */
     Children not(boolean condition);
 }

easy-es-core/src/main/java/cn/easyes/core/conditions/function/Nested.java

@@ -11,6 +11,12 @@ import java.util.function.Consumer;
  * Copyright © 2021 xpc1024 All Rights Reserved
  **/
 public interface Nested<Param, Children> extends Serializable {
+    /**
+     * AND 嵌套 保留mp用户习惯
+     *
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
     default Children and(Consumer<Param> consumer) {
         return and(true, consumer);
     }
@@ -19,11 +25,17 @@ public interface Nested<Param, Children> extends Serializable {
      * AND 嵌套 保留mp用户习惯
      *
      * @param condition 条件
-     * @param consumer  条件函数
+     * @param consumer  嵌套条件函数
-     * @return 泛型
+     * @return wrapper
      */
     Children and(boolean condition, Consumer<Param> consumer);
 
+    /**
+     * OR 嵌套 保留mp用户习惯
+     *
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
     default Children or(Consumer<Param> consumer) {
         return or(true, consumer);
     }
@@ -32,11 +44,17 @@ public interface Nested<Param, Children> extends Serializable {
      * OR 嵌套 保留mp用户习惯
      *
      * @param condition 条件
-     * @param consumer  条件函数
+     * @param consumer  嵌套条件函数
-     * @return 泛型
+     * @return wrapper
      */
     Children or(boolean condition, Consumer<Param> consumer);
 
+    /**
+     * must 嵌套 等价于and
+     *
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
     default Children must(Consumer<Param> consumer) {
         return must(true, consumer);
     }
@@ -45,12 +63,17 @@ public interface Nested<Param, Children> extends Serializable {
      * must 嵌套 等价于and
      *
      * @param condition 条件
-     * @param consumer  条件函数
+     * @param consumer  嵌套条件函数
-     * @return 泛型
+     * @return wrapper
      */
     Children must(boolean condition, Consumer<Param> consumer);
 
-
+    /**
+     * should 嵌套 等价于or
+     *
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
     default Children should(Consumer<Param> consumer) {
         return should(true, consumer);
     }
@@ -59,11 +82,17 @@ public interface Nested<Param, Children> extends Serializable {
      * should 嵌套 等价于or
      *
      * @param condition 条件
-     * @param consumer  条件函数
+     * @param consumer  嵌套条件函数
-     * @return 泛型
+     * @return wrapper
      */
     Children should(boolean condition, Consumer<Param> consumer);
 
+    /**
+     * filter 嵌套 和and及must功能基本一致，但filter不返回得分，效率更高
+     *
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
     default Children filter(Consumer<Param> consumer) {
         return filter(true, consumer);
     }
@@ -77,40 +106,66 @@ public interface Nested<Param, Children> extends Serializable {
      */
     Children filter(boolean condition, Consumer<Param> consumer);
 
-    default Children mustNot(Consumer<Param> consumer) {
+    /**
-        return mustNot(true, consumer);
+     * must not 嵌套 等价于 must条件取反，即 非must
+     *
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
+    default Children not(Consumer<Param> consumer) {
+        return not(true, consumer);
     }
 
     /**
      * must not 嵌套 等价于 must条件取反，即 非must
      *
      * @param condition 条件
-     * @param consumer  条件函数
+     * @param consumer  嵌套条件函数
-     * @return 泛型
+     * @return wrapper
      */
-    Children mustNot(boolean condition, Consumer<Param> consumer);
+    Children not(boolean condition, Consumer<Param> consumer);
-
 
+    /**
+     * @param path     上级路径
+     * @param consumer 嵌套条件函数
+     * @return wrapper
+     */
     default Children nested(String path, Consumer<Param> consumer) {
         return nested(true, path, consumer);
     }
 
+    /**
+     * 嵌套类型查询
+     *
+     * @param path      上级路径
+     * @param consumer  嵌套条件函数
+     * @param scoreMode 得分模式
+     * @return wrapper
+     */
     default Children nested(String path, Consumer<Param> consumer, ScoreMode scoreMode) {
         return nested(true, path, consumer, scoreMode);
     }
 
+    /**
+     * 嵌套类型查询
+     *
+     * @param condition 执行条件
+     * @param path      上级路径
+     * @param consumer  嵌套条件函数
+     * @return wrapper
+     */
     default Children nested(boolean condition, String path, Consumer<Param> consumer) {
         return nested(condition, path, consumer, ScoreMode.None);
     }
 
     /**
-     * 嵌套查询
+     * 嵌套类型查询
      *
-     * @param condition 条件
+     * @param condition 执行条件
      * @param path      上级路径
-     * @param consumer  嵌套里的条件函数
+     * @param consumer  嵌套条件函数
-     * @return 泛型
+     * @param scoreMode 得分模式
-     * @author 此方法由社区开发者lym于1.x贡献，EE作者负责调整及整合至2.0
+     * @return wrapper
      */
     Children nested(boolean condition, String path, Consumer<Param> consumer, ScoreMode scoreMode);
 }

easy-es-core/src/main/java/cn/easyes/core/conditions/function/Query.java

@@ -13,11 +13,22 @@ import java.util.function.Predicate;
  * Copyright © 2021 xpc1024 All Rights Reserved
  **/
 public interface Query<Children, T, R> extends Serializable {
-
+    /**
+     * 设置查询字段
+     *
+     * @param column 查询列
+     * @return wrapper
+     */
     default Children select(R column) {
         return select(FieldUtils.getFieldNameNotConvertId(column));
     }
 
+    /**
+     * 设置查询字段
+     *
+     * @param columns 查询列
+     * @return wrapper
+     */
     default Children select(R... columns) {
         return select(Arrays.stream(columns).map(FieldUtils::getFieldNameNotConvertId).toArray(String[]::new));
     }
@@ -27,7 +38,7 @@ public interface Query<Children, T, R> extends Serializable {
      * 设置查询字段
      *
      * @param columns 查询列,支持多字段
-     * @return 泛型
+     * @return wrapper
      */
     Children select(String... columns);
 
@@ -35,7 +46,7 @@ public interface Query<Children, T, R> extends Serializable {
      * 查询字段
      *
      * @param predicate 预言
-     * @return 泛型
+     * @return wrapper
      */
     Children select(Predicate<EntityFieldInfo> predicate);
 
@@ -44,14 +55,26 @@ public interface Query<Children, T, R> extends Serializable {
      *
      * @param entityClass 实体类
      * @param predicate   预言
-     * @return 泛型
+     * @return wrapper
      */
     Children select(Class<T> entityClass, Predicate<EntityFieldInfo> predicate);
 
+    /**
+     * 设置不查询字段
+     *
+     * @param column 不查询列
+     * @return wrapper
+     */
     default Children notSelect(R column) {
         return notSelect(FieldUtils.getFieldNameNotConvertId(column));
     }
 
+    /**
+     * 设置不查询字段
+     *
+     * @param columns 不查询列
+     * @return wrapper
+     */
     default Children notSelect(R... columns) {
         return notSelect(Arrays.stream(columns).map(FieldUtils::getFieldNameNotConvertId).toArray(String[]::new));
     }
@@ -60,14 +83,26 @@ public interface Query<Children, T, R> extends Serializable {
      * 设置不查询字段
      *
      * @param columns 不查询字段,支持多字段
-     * @return 泛型
+     * @return wrapper
      */
     Children notSelect(String... columns);
 
+    /**
+     * 设置当前操作的索引名称
+     *
+     * @param indexName 索引名
+     * @return wrapper
+     */
     default Children index(String indexName) {
         return index(true, indexName);
     }
 
+    /**
+     * 设置当前操作的索引名称
+     *
+     * @param indexNames 索引名
+     * @return wrapper
+     */
     default Children index(String... indexNames) {
         return index(true, indexNames);
     }
@@ -77,7 +112,7 @@ public interface Query<Children, T, R> extends Serializable {
      *
      * @param condition  条件
      * @param indexNames 索引名
-     * @return 泛型
+     * @return wrapper
      */
     Children index(boolean condition, String... indexNames);
 

easy-es-core/src/main/java/cn/easyes/core/conditions/function/Update.java

@@ -10,14 +10,36 @@ import java.io.Serializable;
  * Copyright © 2021 xpc1024 All Rights Reserved
  **/
 public interface Update<Children, R> extends Serializable {
+    /**
+     * 设置 更新 字段 的 SET 片段
+     *
+     * @param column 列
+     * @param val    值
+     * @return wrapper
+     */
     default Children set(R column, Object val) {
         return set(true, column, val);
     }
 
+    /**
+     * 设置 更新 字段 的 SET 片段
+     *
+     * @param column 列名 字符串
+     * @param val    值
+     * @return wrapper
+     */
     default Children set(String column, Object val) {
         return set(true, column, val);
     }
 
+    /**
+     * 设置 更新 字段 的 SET 片段
+     *
+     * @param condition 执行条件
+     * @param column    列
+     * @param val       值
+     * @return wrapper
+     */
     default Children set(boolean condition, R column, Object val) {
         return set(condition, FieldUtils.getFieldName(column), val);
     }
@@ -28,7 +50,7 @@ public interface Update<Children, R> extends Serializable {
      * @param condition 条件
      * @param column    列
      * @param val       值
-     * @return 泛型
+     * @return wrapper
      */
     Children set(boolean condition, String column, Object val);
 }

easy-es-core/src/main/java/cn/easyes/core/core/AbstractChainWrapper.java

@@ -606,8 +606,8 @@ public abstract class AbstractChainWrapper<T, R, Children extends AbstractChainW
     }
 
     @Override
-    public Children mustNot(boolean condition, Consumer<Param> consumer) {
+    public Children not(boolean condition, Consumer<Param> consumer) {
-        getWrapper().mustNot(condition, consumer);
+        getWrapper().not(condition, consumer);
         return typedThis;
     }
 

easy-es-core/src/main/java/cn/easyes/core/core/AbstractWrapper.java

@@ -91,7 +91,7 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
         baseSortParams = new ArrayList<>();
         aggregationParamList = new ArrayList<>();
         paramQueue = new LinkedList<>();
-        prevQueryType = AND_MUST;
+        prevQueryType = NESTED_AND;
         parentIdQueue = new LinkedList<>();
         prevQueryTypeQueue = new LinkedList<>();
     }
@@ -125,12 +125,12 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
 
     @Override
     public Children and(boolean condition, Consumer<Children> consumer) {
-        return addNested(condition, AND_MUST, consumer);
+        return addNested(condition, NESTED_AND, consumer);
     }
 
     @Override
     public Children or(boolean condition, Consumer<Children> consumer) {
-        return addNested(condition, OR_SHOULD, consumer);
+        return addNested(condition, NESTED_OR, consumer);
     }
 
     @Override
@@ -139,7 +139,7 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
         for (int i = paramQueue.size() - 1; i >= 0; i--) {
             Param param = paramQueue.get(i);
             if (Objects.equals(level, param.getLevel())) {
-                param.setPrevQueryType(OR_SHOULD);
+                param.setPrevQueryType(NESTED_OR);
                 break;
             }
         }
@@ -148,17 +148,17 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
 
     @Override
     public Children must(boolean condition, Consumer<Children> consumer) {
-        return addNested(condition, AND_MUST, consumer);
+        return addNested(condition, NESTED_AND, consumer);
     }
 
     @Override
     public Children should(boolean condition, Consumer<Children> consumer) {
-        return addNested(condition, OR_SHOULD, consumer);
+        return addNested(condition, NESTED_OR, consumer);
     }
 
     @Override
     public Children filter(boolean condition, Consumer<Children> consumer) {
-        return addNested(condition, AND_FILTER, consumer);
+        return addNested(condition, NESTED_FILTER, consumer);
     }
 
     @Override
@@ -172,8 +172,8 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
     }
 
     @Override
-    public Children mustNot(boolean condition, Consumer<Children> consumer) {
+    public Children not(boolean condition, Consumer<Children> consumer) {
-        return addNested(condition, MUST_NOT, consumer);
+        return addNested(condition, NESTED_NOT, consumer);
     }
 
     @Override
@@ -701,10 +701,10 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
         processJoin(param);
 
         // 这两种情况需要重置其prevType
-        if (MUST_NOT.equals(queryTypeEnum)) {
+        if (NESTED_NOT.equals(queryTypeEnum)) {
-            prevQueryType = MUST_NOT;
+            prevQueryType = NESTED_NOT;
-        } else if (FILTER.equals(queryTypeEnum)) {
+        } else if (NESTED_FILTER.equals(queryTypeEnum)) {
-            prevQueryType = FILTER;
+            prevQueryType = NESTED_FILTER;
         }
 
         paramQueue.add(param);
@@ -734,13 +734,13 @@ public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T,
             Param prev = paramQueue.peekLast();
             if (OR.equals(prev.getQueryTypeEnum())) {
                 // 上一节点是拼接or() 需要重置其prevQueryType类型,让其走should查询
-                param.setPrevQueryType(OR_SHOULD);
+                param.setPrevQueryType(NESTED_OR);
             } else if (NOT.equals(prev.getQueryTypeEnum())) {
                 // 上一节点是拼接not() 需要重置其prevQueryType类型,让其走must_not查询
-                param.setPrevQueryType(MUST_NOT);
+                param.setPrevQueryType(NESTED_NOT);
             } else if (FILTER.equals(prev.getPrevQueryType())) {
                 // 上一节点是拼接filter() 需要重置其prevQueryType类型,让其走filter查询
-                param.setPrevQueryType(AND_FILTER);
+                param.setPrevQueryType(NESTED_FILTER);
             }
         }
     }

easy-es-core/src/main/java/cn/easyes/core/core/BaseEsMapper.java

@@ -125,7 +125,7 @@ public interface BaseEsMapper<T> {
     String executeDSL(String dsl, String indexName);
 
     /**
-     * 标准查询
+     * 混合查询
      *
      * @param wrapper 条件
      * @return es标准结果

easy-es-core/src/main/java/cn/easyes/core/core/WrapperProcessor.java

@@ -234,10 +234,10 @@ public class WrapperProcessor {
                 setBool(bool, queryBuilder, param.getPrevQueryType());
                 break;
             // 下面五种嵌套类型 需要对孩子节点递归处理
-            case AND_MUST:
+            case NESTED_AND:
-            case AND_FILTER:
+            case NESTED_FILTER:
-            case MUST_NOT:
+            case NESTED_NOT:
-            case OR_SHOULD:
+            case NESTED_OR:
                 queryBuilder = getBool(children, QueryBuilders.boolQuery(), entityInfo, null);
                 setBool(bool, queryBuilder, param.getPrevQueryType());
                 break;
@@ -262,13 +262,13 @@ public class WrapperProcessor {
      * @param parentType   查询类型
      */
     private static void setBool(BoolQueryBuilder bool, QueryBuilder queryBuilder, EsQueryTypeEnum parentType) {
-        if (AND_MUST.equals(parentType)) {
+        if (NESTED_AND.equals(parentType)) {
             bool.must(queryBuilder);
-        } else if (OR_SHOULD.equals(parentType)) {
+        } else if (NESTED_OR.equals(parentType)) {
             bool.should(queryBuilder);
-        } else if (AND_FILTER.equals(parentType)) {
+        } else if (NESTED_FILTER.equals(parentType)) {
             bool.filter(queryBuilder);
-        } else if (MUST_NOT.equals(parentType)) {
+        } else if (NESTED_NOT.equals(parentType)) {
             bool.mustNot(queryBuilder);
         } else {
             // by default

easy-es-sample/src/main/resources/application.yml

@@ -11,7 +11,7 @@ easy-es:
     print-dsl: false
     db-config:
       map-underscore-to-camel-case: true
-      #      table-prefix: dev_
+      table-prefix: dev_
       id-type: customize
       field-strategy: not_empty
       refresh-policy: immediate

easy-es-test/src/main/java/cn/easyes/test/entity/Document.java

@@ -46,6 +46,11 @@ public class Document {
      */
     @IndexField(fieldType = FieldType.TEXT, fieldData = true)
     private String filedData;
+    /**
+     * ip字段
+     */
+    @IndexField(fieldType = FieldType.IP)
+    private String ipAddress;
     /**
      * 创建时间
      */

easy-es-test/src/main/java/cn/easyes/test/entity/Faq.java

@@ -26,7 +26,6 @@ import lombok.NoArgsConstructor;
 @NoArgsConstructor
 @AllArgsConstructor
 public class Faq {
-    @IndexField(value = "faq_name", fieldType = FieldType.TEXT)
     private String faqName;
     @IndexField(value = "answer")
     private String faqAnswer;

easy-es-test/src/test/java/cn/easyes/test/all/AllTest.java

@@ -66,6 +66,7 @@ public class AllTest {
         document.setTitle("测试文档1");
         document.setContent("测试内容1");
         document.setCreator("老汉1");
+        document.setIpAddress("192.168.1.1");
         document.setLocation("40.171975,116.587105");
         document.setGmtCreate(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
         document.setCustomField("自定义字段1");
@@ -187,6 +188,7 @@ public class AllTest {
     @Order(6)
     public void testSelectOne() {
         LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+
         wrapper.match(Document::getContent, "内容")
                 .orderByAsc(Document::getStarNum, Document::getEsId)
                 .limit(1);
@@ -226,6 +228,15 @@ public class AllTest {
         Assertions.assertEquals(22, documents.size());
     }
 
+    @Test
+    @Order(6)
+    public void testIp(){
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.eq(Document::getIpAddress,"192.168.0.0/16");
+        List<Document> documents = documentMapper.selectList(wrapper);
+        Assertions.assertEquals(documents.size(),1);
+    }
+
     @Test
     @Order(6)
     public void testSelectCount() {
@@ -525,10 +536,10 @@ public class AllTest {
 
     @Test
     @Order(6)
-    public void testConditionMustNot() {
+    public void testConditionNot() {
         LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
         wrapper.in(Document::getStarNum, 10,11,12,13)
-                .mustNot(i->i.eq(Document::getTitle,"测试文档10").eq(Document::getTitle,"测试文档11"));
+                .not(i->i.eq(Document::getTitle,"测试文档10").eq(Document::getTitle,"测试文档11"));
         List<Document> documents = documentMapper.selectList(wrapper);
         Assertions.assertEquals(2, documents.size());
     }
@@ -876,7 +887,7 @@ public class AllTest {
     @Order(9)
     public void testComplex() {
         // SQL写法
-        // where business_type = 1 and (state = 9 or (state = 8 and bidding_sign = 1)) or business_type = 2 and state in (2,3)
+        // where business_type = 1 and (state = 9 or (state = 8 and bidding_sign = 1)) or (business_type = 2 and state in (2,3))
 
         // RestHighLevelClient写法
         List<Integer> values = Arrays.asList(2, 3);

easy-es-test/src/test/java/cn/easyes/test/mix/MixTest.java

@@ -0,0 +1,162 @@
+package cn.easyes.test.mix;
+
+import cn.easyes.core.conditions.select.LambdaEsQueryWrapper;
+import cn.easyes.test.TestEasyEsApplication;
+import cn.easyes.test.entity.Document;
+import cn.easyes.test.mapper.DocumentMapper;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.core.TimeValue;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.script.Script;
+import org.elasticsearch.search.aggregations.AggregationBuilder;
+import org.elasticsearch.search.aggregations.AggregationBuilders;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.elasticsearch.search.sort.ScriptSortBuilder;
+import org.elasticsearch.search.sort.SortBuilders;
+import org.elasticsearch.search.sort.SortOrder;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 混合查询几种使用案例
+ *
+ * @ProductName: Hundsun HEP
+ * @ProjectName: easy-es
+ * @Package: cn.easyes.test.mix
+ * @Description: note
+ * @Author: xingpc37977
+ * @Date: 2023/3/13 10:48
+ * @UpdateUser: xingpc37977
+ * @UpdateDate: 2023/3/13 10:48
+ * @UpdateRemark: The modified content
+ * @Version: 1.0
+ * <p>
+ * Copyright © 2023 Hundsun Technologies Inc. All Rights Reserved
+ **/
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+@SpringBootTest(classes = TestEasyEsApplication.class)
+public class MixTest {
+    @Resource
+    private DocumentMapper documentMapper;
+
+    /**
+     * 混合查询正确使用姿势1: EE提供的功能不支持某些过细粒度的功能,所有查询条件通过原生语法构造,仅利用EE提供的数据解析功能
+     */
+    @Test
+    public void testMix1() {
+        // RestHighLevelClient原生语法
+        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
+        searchSourceBuilder.query(QueryBuilders.matchQuery("content", "推*").minimumShouldMatch("80%"));
+
+        // 仅利用EE查询并解析数据功能
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.setSearchSourceBuilder(searchSourceBuilder);
+        List<Document> documents = documentMapper.selectList(wrapper);
+        System.out.println(documents);
+    }
+
+
+    /**
+     * 混合查询正确使用姿势2: 其它都能支持,仅排序器不支持,这种情况可以只按ES原生语法构造所需排序器SortBuilder,其它用EE完成
+     */
+    @Test
+    public void testMix2() {
+        // EE满足的语法
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.eq(Document::getTitle, "老汉")
+                .match(Document::getContent, "推*");
+
+        // RestHighLevelClient原生语法
+        Script script = new Script("doc['star_num'].value");
+        ScriptSortBuilder scriptSortBuilder = SortBuilders.scriptSort(script, ScriptSortBuilder.ScriptSortType.NUMBER).order(SortOrder.DESC);
+
+        // 利用EE查询并解析数据
+        wrapper.sort(scriptSortBuilder);
+        List<Document> documents = documentMapper.selectList(wrapper);
+        System.out.println(documents);
+    }
+
+    /**
+     * 混合查询正确使用姿势3: 其它功能都能支持,但需要向SearchSourceBuilder中追加非query参数
+     */
+    @Test
+    public void testMix3() {
+        // EE满足的语法
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.eq(Document::getTitle, "老汉")
+                .match(Document::getContent, "推*");
+        SearchSourceBuilder searchSourceBuilder = documentMapper.getSearchSourceBuilder(wrapper);
+
+        // 追加或者设置一些SearchSourceBuilder支持但EE暂不支持的参数 不建议追加query参数,因为如果追加query参数会直接覆盖上面EE已经帮你生成好的query,以最后set的query为准
+        searchSourceBuilder.timeout(TimeValue.timeValueSeconds(3L));
+        wrapper.setSearchSourceBuilder(searchSourceBuilder);
+        List<Document> documents = documentMapper.selectList(wrapper);
+        System.out.println(documents);
+    }
+
+
+    /**
+     * 查询条件中可以利用大多数基本查询,但EE提供的聚合功能不能满足需求的情况下,需要自定义聚合器
+     */
+    @Test
+    public void textMix4() {
+        // EE满足的语法
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.eq(Document::getTitle, "老汉")
+                .match(Document::getContent, "推*");
+        SearchSourceBuilder searchSourceBuilder = documentMapper.getSearchSourceBuilder(wrapper);
+
+        // RestHighLevelClient原生语法
+        AggregationBuilder aggregation = AggregationBuilders.terms("titleAgg")
+                .field("title");
+        searchSourceBuilder.aggregation(aggregation);
+        wrapper.setSearchSourceBuilder(searchSourceBuilder);
+        SearchResponse searchResponse = documentMapper.search(wrapper);
+        // tip: 聚合后的信息是动态的,框架无法解析,需要用户根据聚合器类型自行从桶中解析,参考RestHighLevelClient官方Aggregation解析文档
+    }
+
+
+    /**
+     * 不支持的混合查询1: 追加覆盖问题
+     */
+    @Test
+    public void textNotSupportMix() {
+        // EE满足的语法
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.eq(Document::getTitle, "老汉")
+                .match(Document::getContent, "推*");
+        SearchSourceBuilder searchSourceBuilder = documentMapper.getSearchSourceBuilder(wrapper);
+
+        // 用户又想在上面的基础上,再追加一些个性化的查询参数进去 但实际上此时执行查询时,查询条件仅仅是最后设置的title=隔壁老王,前面的老汉推*会被覆盖
+        searchSourceBuilder.query(QueryBuilders.matchQuery("title", "隔壁老王"));
+        wrapper.setSearchSourceBuilder(searchSourceBuilder);
+        List<Document> documents = documentMapper.selectList(wrapper);
+        System.out.println(documents);
+        // 思考: 为什么会被覆盖? 因为目前技术上做不到,查询树已经建立好了,es底层并没有提供向树的指定层级上继续追加查询条件的API
+    }
+
+    /**
+     * 不支持的混合查询2: 脱裤子放P 自欺欺人系列
+     */
+    @Test
+    public void testNotSupportMix2() {
+        // EE满足的语法
+        LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
+        wrapper.eq(Document::getTitle, "老汉")
+                .match(Document::getContent, "推*");
+
+        // SearchSourceBuilder的构造是自己new出来的,不是通过mapper.getSearchSourceBuilder(wrapper)构造 相当于脱裤子放P,那么上面的查询条件老汉推*自然不会生效
+        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
+        searchSourceBuilder.minScore(10.5f);
+        wrapper.setSearchSourceBuilder(searchSourceBuilder);
+        List<Document> documents = documentMapper.selectList(wrapper);
+        System.out.println(documents);
+    }
+
+
+}

easy-es-test/src/test/java/cn/easyes/test/nested/NestedTest.java

@@ -78,31 +78,36 @@ public class NestedTest {
 
     @Test
     public void testNestedMatch() {
-        // 嵌套查询 查询年龄等于18或8，且密码等于123的数据
+        // 嵌套查询 查询年龄等于18或8，且密码等于12345的数据
         LambdaEsQueryWrapper<Document> wrapper = new LambdaEsQueryWrapper<>();
         wrapper.nested(FieldUtils.val(Document::getUsers), w ->
-                w.in(FieldUtils.val(User::getAge), 18, 8)
+                w.in("users.age", 8)
-                        .eq(FieldUtils.val(User::getPassword), "123"));
+                        .eq("users.password", "12345"));
         List<Document> documents = documentMapper.selectList(wrapper);
         System.out.println(documents);
 
         // 嵌套类型中的字段获取可以用FieldUtils.val或直接传入字符串
         LambdaEsQueryWrapper<Document> wrapper1 = new LambdaEsQueryWrapper<>();
-        wrapper1.match(Document::getContent, "人才")
+        wrapper1.eq(Document::getTitle,"老汉")
-                .nested("users.faqs", w -> w.eq(FieldUtils.val(Faq::getFaqAnswer), "回答4")
+                .nested("users.faqs", w -> w.eq("users.faqs.answer", "a4")
-                        .match("faqName", "问题3"))
+                        .match("users.faqs.faq_name", "q4"))
-                .nested("users", w -> w.between("age", 10, 19))
+                .nested("users", w -> w.between("users.age", 1, 30))
                 .match(Document::getCreator, "吃饭");
         List<Document> documents1 = documentMapper.selectList(wrapper1);
         System.out.println(documents1);
 
         LambdaEsQueryWrapper<Document> wrapper2 = new LambdaEsQueryWrapper<>();
-        wrapper2.nested("users", w -> w.in("age", 18))
+        wrapper2.nested("users", w -> w.in("users.age", 18))
                 .or()
-                .nested("users.faqs", w -> w.match("faq_name", "q3"));
+                .nested("users.faqs", w -> w.match("users.faqs.faq_name", "q3"));
         List<Document> documents2 = documentMapper.selectList(wrapper2);
 
         System.out.println(documents2);
+
+        LambdaEsQueryWrapper<Document> wrapper3 = new LambdaEsQueryWrapper<>();
+        wrapper3.nested("users.faqs",w->w.match("users.faqs.faq_name", "q3").or().match("users.faqs.faq_name","q4"));
+        List<Document> documents3 = documentMapper.selectList(wrapper3);
+        System.out.println(documents3);
     }
 
 }