io.polaris.mybatis.mapper

接口 EntitySelectListMapper<E>

所有超级接口:

EntityMapper<E>

public interface EntitySelectListMapper<E>
extends EntityMapper<E>

从以下版本开始:

Aug 25, 2023

作者:

Qt

方法概要

限定符和类型	方法和说明
default List<E>	selectEntityList(E entity)
default List<E>	selectEntityList(E entity, OrderBy orderBy)
default List<E>	selectEntityList(E entity, OrderBy orderBy, boolean includeEmpty)
List<E>	selectEntityList(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityList(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<E>	selectEntityList(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListByCriteria(Criteria criteria)
default List<E>	selectEntityListByCriteria(Criteria criteria, OrderBy orderBy)
default List<E>	selectEntityListByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
List<E>	selectEntityListByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default List<E>	selectEntityListByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListByMap(Map<String,Object> entity)
default List<E>	selectEntityListByMap(Map<String,Object> entity, OrderBy orderBy)
default List<E>	selectEntityListByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
List<E>	selectEntityListByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<E>	selectEntityListByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListExceptLogicDeleted(E entity)
default List<E>	selectEntityListExceptLogicDeleted(E entity, OrderBy orderBy)
default List<E>	selectEntityListExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty)
List<E>	selectEntityListExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<E>	selectEntityListExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListExceptLogicDeletedByCriteria(Criteria criteria)
default List<E>	selectEntityListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy)
default List<E>	selectEntityListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
List<E>	selectEntityListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default List<E>	selectEntityListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity)
default List<E>	selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy)
default List<E>	selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
List<E>	selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<E>	selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<E>	selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapList(E entity)
default List<Map<String,Object>>	selectMapList(E entity, OrderBy orderBy)
default List<Map<String,Object>>	selectMapList(E entity, OrderBy orderBy, boolean includeEmpty)
List<Map<String,Object>>	selectMapList(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapList(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<Map<String,Object>>	selectMapList(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListByCriteria(Criteria criteria)
default List<Map<String,Object>>	selectMapListByCriteria(Criteria criteria, OrderBy orderBy)
default List<Map<String,Object>>	selectMapListByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
List<Map<String,Object>>	selectMapListByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default List<Map<String,Object>>	selectMapListByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListByMap(Map<String,Object> entity)
default List<Map<String,Object>>	selectMapListByMap(Map<String,Object> entity, OrderBy orderBy)
default List<Map<String,Object>>	selectMapListByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
List<Map<String,Object>>	selectMapListByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<Map<String,Object>>	selectMapListByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeleted(E entity)
default List<Map<String,Object>>	selectMapListExceptLogicDeleted(E entity, OrderBy orderBy)
default List<Map<String,Object>>	selectMapListExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty)
List<Map<String,Object>>	selectMapListExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByCriteria(Criteria criteria)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
List<Map<String,Object>>	selectMapListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByMap(Map<String,Object> entity)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
List<Map<String,Object>>	selectMapListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default List<Map<String,Object>>	selectMapListExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)

方法详细资料

selectEntityList

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
List<E> selectEntityList(@Param(value="_w")
                                                                                                              E entity,
                                                                                                              @Param(value="_o")
                                                                                                              OrderBy orderBy,
                                                                                                              @Param(value="_w_ie")
                                                                                                              boolean includeEmpty,
                                                                                                              @Param(value="_w_iec")
                                                                                                              Set<String> includeEmptyFields,
                                                                                                              @Param(value="_w_xc")
                                                                                                              Set<String> excludeFields)

selectEntityList

default List<E> selectEntityList(E entity,
                                 OrderBy orderBy,
                                 Set<String> includeEmptyFields,
                                 Set<String> excludeFields)

selectEntityList

default List<E> selectEntityList(E entity,
                                 OrderBy orderBy,
                                 Set<String> includeEmptyFields)

selectEntityList

default List<E> selectEntityList(E entity,
                                 OrderBy orderBy,
                                 boolean includeEmpty)

selectEntityList

default List<E> selectEntityList(E entity,
                                 OrderBy orderBy)

selectEntityList

default List<E> selectEntityList(E entity)

selectEntityListByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
List<E> selectEntityListByMap(@Param(value="_w")
                                                                                                                   Map<String,Object> entity,
                                                                                                                   @Param(value="_o")
                                                                                                                   OrderBy orderBy,
                                                                                                                   @Param(value="_w_ie")
                                                                                                                   boolean includeEmpty,
                                                                                                                   @Param(value="_w_iec")
                                                                                                                   Set<String> includeEmptyFields,
                                                                                                                   @Param(value="_w_xc")
                                                                                                                   Set<String> excludeFields)

selectEntityListByMap

default List<E> selectEntityListByMap(Map<String,Object> entity,
                                      OrderBy orderBy,
                                      Set<String> includeEmptyFields,
                                      Set<String> excludeFields)

selectEntityListByMap

default List<E> selectEntityListByMap(Map<String,Object> entity,
                                      OrderBy orderBy,
                                      Set<String> includeEmptyFields)

selectEntityListByMap

default List<E> selectEntityListByMap(Map<String,Object> entity,
                                      OrderBy orderBy,
                                      boolean includeEmpty)

selectEntityListByMap

default List<E> selectEntityListByMap(Map<String,Object> entity,
                                      OrderBy orderBy)

selectEntityListByMap

default List<E> selectEntityListByMap(Map<String,Object> entity)

selectEntityListByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
List<E> selectEntityListByCriteria(@Param(value="_w")
                                                                                                                        Criteria criteria,
                                                                                                                        @Param(value="_o")
                                                                                                                        OrderBy orderBy,
                                                                                                                        @Param(value="_w_ie")
                                                                                                                        boolean includeEmpty,
                                                                                                                        @Param(value="_w_iec")
                                                                                                                        Set<String> includeEmptyFields,
                                                                                                                        @Param(value="_w_xc")
                                                                                                                        Set<String> excludeFields)

selectEntityListByCriteria

default List<E> selectEntityListByCriteria(Criteria criteria,
                                           OrderBy orderBy,
                                           Set<String> includeEmptyFields,
                                           Set<String> excludeFields)

selectEntityListByCriteria

default List<E> selectEntityListByCriteria(Criteria criteria,
                                           OrderBy orderBy,
                                           Set<String> includeEmptyFields)

selectEntityListByCriteria

default List<E> selectEntityListByCriteria(Criteria criteria,
                                           OrderBy orderBy,
                                           boolean includeEmpty)

selectEntityListByCriteria

default List<E> selectEntityListByCriteria(Criteria criteria,
                                           OrderBy orderBy)

selectEntityListByCriteria

default List<E> selectEntityListByCriteria(Criteria criteria)

selectMapList

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
List<Map<String,Object>> selectMapList(@Param(value="_w")
                                                                                                                            E entity,
                                                                                                                            @Param(value="_o")
                                                                                                                            OrderBy orderBy,
                                                                                                                            @Param(value="_w_ie")
                                                                                                                            boolean includeEmpty,
                                                                                                                            @Param(value="_w_iec")
                                                                                                                            Set<String> includeEmptyFields,
                                                                                                                            @Param(value="_w_xc")
                                                                                                                            Set<String> excludeFields)

selectMapList

default List<Map<String,Object>> selectMapList(E entity,
                                               OrderBy orderBy,
                                               Set<String> includeEmptyFields,
                                               Set<String> excludeFields)

selectMapList

default List<Map<String,Object>> selectMapList(E entity,
                                               OrderBy orderBy,
                                               Set<String> includeEmptyFields)

selectMapList

default List<Map<String,Object>> selectMapList(E entity,
                                               OrderBy orderBy,
                                               boolean includeEmpty)

selectMapList

default List<Map<String,Object>> selectMapList(E entity,
                                               OrderBy orderBy)

selectMapList

default List<Map<String,Object>> selectMapList(E entity)

selectMapListByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
List<Map<String,Object>> selectMapListByMap(@Param(value="_w")
                                                                                                                                 Map<String,Object> entity,
                                                                                                                                 @Param(value="_o")
                                                                                                                                 OrderBy orderBy,
                                                                                                                                 @Param(value="_w_ie")
                                                                                                                                 boolean includeEmpty,
                                                                                                                                 @Param(value="_w_iec")
                                                                                                                                 Set<String> includeEmptyFields,
                                                                                                                                 @Param(value="_w_xc")
                                                                                                                                 Set<String> excludeFields)

selectMapListByMap

default List<Map<String,Object>> selectMapListByMap(Map<String,Object> entity,
                                                    OrderBy orderBy,
                                                    Set<String> includeEmptyFields,
                                                    Set<String> excludeFields)

selectMapListByMap

default List<Map<String,Object>> selectMapListByMap(Map<String,Object> entity,
                                                    OrderBy orderBy,
                                                    Set<String> includeEmptyFields)

selectMapListByMap

default List<Map<String,Object>> selectMapListByMap(Map<String,Object> entity,
                                                    OrderBy orderBy,
                                                    boolean includeEmpty)

selectMapListByMap

default List<Map<String,Object>> selectMapListByMap(Map<String,Object> entity)

selectMapListByMap

default List<Map<String,Object>> selectMapListByMap(Map<String,Object> entity,
                                                    OrderBy orderBy)

selectMapListByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
List<Map<String,Object>> selectMapListByCriteria(@Param(value="_w")
                                                                                                                                      Criteria criteria,
                                                                                                                                      @Param(value="_o")
                                                                                                                                      OrderBy orderBy,
                                                                                                                                      @Param(value="_w_ie")
                                                                                                                                      boolean includeEmpty,
                                                                                                                                      @Param(value="_w_iec")
                                                                                                                                      Set<String> includeEmptyFields,
                                                                                                                                      @Param(value="_w_xc")
                                                                                                                                      Set<String> excludeFields)

selectMapListByCriteria

default List<Map<String,Object>> selectMapListByCriteria(Criteria criteria,
                                                         OrderBy orderBy,
                                                         Set<String> includeEmptyFields,
                                                         Set<String> excludeFields)

selectMapListByCriteria

default List<Map<String,Object>> selectMapListByCriteria(Criteria criteria,
                                                         OrderBy orderBy,
                                                         Set<String> includeEmptyFields)

selectMapListByCriteria

default List<Map<String,Object>> selectMapListByCriteria(Criteria criteria,
                                                         OrderBy orderBy,
                                                         boolean includeEmpty)

selectMapListByCriteria

default List<Map<String,Object>> selectMapListByCriteria(Criteria criteria)

selectMapListByCriteria

default List<Map<String,Object>> selectMapListByCriteria(Criteria criteria,
                                                         OrderBy orderBy)

selectEntityListExceptLogicDeleted

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
List<E> selectEntityListExceptLogicDeleted(@Param(value="_w")
                                                                                                                                                  E entity,
                                                                                                                                                  @Param(value="_o")
                                                                                                                                                  OrderBy orderBy,
                                                                                                                                                  @Param(value="_w_ie")
                                                                                                                                                  boolean includeEmpty,
                                                                                                                                                  @Param(value="_w_iec")
                                                                                                                                                  Set<String> includeEmptyFields,
                                                                                                                                                  @Param(value="_w_xc")
                                                                                                                                                  Set<String> excludeFields)

selectEntityListExceptLogicDeleted

default List<E> selectEntityListExceptLogicDeleted(E entity,
                                                   OrderBy orderBy,
                                                   Set<String> includeEmptyFields,
                                                   Set<String> excludeFields)

selectEntityListExceptLogicDeleted

default List<E> selectEntityListExceptLogicDeleted(E entity,
                                                   OrderBy orderBy,
                                                   Set<String> includeEmptyFields)

selectEntityListExceptLogicDeleted

default List<E> selectEntityListExceptLogicDeleted(E entity,
                                                   OrderBy orderBy,
                                                   boolean includeEmpty)

selectEntityListExceptLogicDeleted

default List<E> selectEntityListExceptLogicDeleted(E entity,
                                                   OrderBy orderBy)

selectEntityListExceptLogicDeleted

default List<E> selectEntityListExceptLogicDeleted(E entity)

selectEntityListExceptLogicDeletedByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
List<E> selectEntityListExceptLogicDeletedByMap(@Param(value="_w")
                                                                                                                                                       Map<String,Object> entity,
                                                                                                                                                       @Param(value="_o")
                                                                                                                                                       OrderBy orderBy,
                                                                                                                                                       @Param(value="_w_ie")
                                                                                                                                                       boolean includeEmpty,
                                                                                                                                                       @Param(value="_w_iec")
                                                                                                                                                       Set<String> includeEmptyFields,
                                                                                                                                                       @Param(value="_w_xc")
                                                                                                                                                       Set<String> excludeFields)

selectEntityListExceptLogicDeletedByMap

default List<E> selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                        OrderBy orderBy,
                                                        Set<String> includeEmptyFields,
                                                        Set<String> excludeFields)

selectEntityListExceptLogicDeletedByMap

default List<E> selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                        OrderBy orderBy,
                                                        Set<String> includeEmptyFields)

selectEntityListExceptLogicDeletedByMap

default List<E> selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                        OrderBy orderBy,
                                                        boolean includeEmpty)

selectEntityListExceptLogicDeletedByMap

default List<E> selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                        OrderBy orderBy)

selectEntityListExceptLogicDeletedByMap

default List<E> selectEntityListExceptLogicDeletedByMap(Map<String,Object> entity)

selectEntityListExceptLogicDeletedByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
List<E> selectEntityListExceptLogicDeletedByCriteria(@Param(value="_w")
                                                                                                                                                            Criteria criteria,
                                                                                                                                                            @Param(value="_o")
                                                                                                                                                            OrderBy orderBy,
                                                                                                                                                            @Param(value="_w_ie")
                                                                                                                                                            boolean includeEmpty,
                                                                                                                                                            @Param(value="_w_iec")
                                                                                                                                                            Set<String> includeEmptyFields,
                                                                                                                                                            @Param(value="_w_xc")
                                                                                                                                                            Set<String> excludeFields)

selectEntityListExceptLogicDeletedByCriteria

default List<E> selectEntityListExceptLogicDeletedByCriteria(Criteria criteria,
                                                             OrderBy orderBy,
                                                             Set<String> includeEmptyFields,
                                                             Set<String> excludeFields)

selectEntityListExceptLogicDeletedByCriteria

default List<E> selectEntityListExceptLogicDeletedByCriteria(Criteria criteria,
                                                             OrderBy orderBy,
                                                             Set<String> includeEmptyFields)

selectEntityListExceptLogicDeletedByCriteria

default List<E> selectEntityListExceptLogicDeletedByCriteria(Criteria criteria,
                                                             OrderBy orderBy,
                                                             boolean includeEmpty)

selectEntityListExceptLogicDeletedByCriteria

default List<E> selectEntityListExceptLogicDeletedByCriteria(Criteria criteria,
                                                             OrderBy orderBy)

selectEntityListExceptLogicDeletedByCriteria

default List<E> selectEntityListExceptLogicDeletedByCriteria(Criteria criteria)

selectMapListExceptLogicDeleted

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
List<Map<String,Object>> selectMapListExceptLogicDeleted(@Param(value="_w")
                                                                                                                                                                E entity,
                                                                                                                                                                @Param(value="_o")
                                                                                                                                                                OrderBy orderBy,
                                                                                                                                                                @Param(value="_w_ie")
                                                                                                                                                                boolean includeEmpty,
                                                                                                                                                                @Param(value="_w_iec")
                                                                                                                                                                Set<String> includeEmptyFields,
                                                                                                                                                                @Param(value="_w_xc")
                                                                                                                                                                Set<String> excludeFields)

selectMapListExceptLogicDeleted

default List<Map<String,Object>> selectMapListExceptLogicDeleted(E entity,
                                                                 OrderBy orderBy,
                                                                 Set<String> includeEmptyFields,
                                                                 Set<String> excludeFields)

selectMapListExceptLogicDeleted

default List<Map<String,Object>> selectMapListExceptLogicDeleted(E entity,
                                                                 OrderBy orderBy,
                                                                 Set<String> includeEmptyFields)

selectMapListExceptLogicDeleted

default List<Map<String,Object>> selectMapListExceptLogicDeleted(E entity,
                                                                 OrderBy orderBy,
                                                                 boolean includeEmpty)

selectMapListExceptLogicDeleted

default List<Map<String,Object>> selectMapListExceptLogicDeleted(E entity,
                                                                 OrderBy orderBy)

selectMapListExceptLogicDeleted

default List<Map<String,Object>> selectMapListExceptLogicDeleted(E entity)

selectMapListExceptLogicDeletedByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
List<Map<String,Object>> selectMapListExceptLogicDeletedByMap(@Param(value="_w")
                                                                                                                                                                     Map<String,Object> entity,
                                                                                                                                                                     @Param(value="_o")
                                                                                                                                                                     OrderBy orderBy,
                                                                                                                                                                     @Param(value="_w_ie")
                                                                                                                                                                     boolean includeEmpty,
                                                                                                                                                                     @Param(value="_w_iec")
                                                                                                                                                                     Set<String> includeEmptyFields,
                                                                                                                                                                     @Param(value="_w_xc")
                                                                                                                                                                     Set<String> excludeFields)

selectMapListExceptLogicDeletedByMap

default List<Map<String,Object>> selectMapListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                      OrderBy orderBy,
                                                                      Set<String> includeEmptyFields,
                                                                      Set<String> excludeFields)

selectMapListExceptLogicDeletedByMap

default List<Map<String,Object>> selectMapListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                      OrderBy orderBy,
                                                                      Set<String> includeEmptyFields)

selectMapListExceptLogicDeletedByMap

default List<Map<String,Object>> selectMapListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                      OrderBy orderBy,
                                                                      boolean includeEmpty)

selectMapListExceptLogicDeletedByMap

default List<Map<String,Object>> selectMapListExceptLogicDeletedByMap(Map<String,Object> entity)

selectMapListExceptLogicDeletedByMap

default List<Map<String,Object>> selectMapListExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                      OrderBy orderBy)

selectMapListExceptLogicDeletedByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
List<Map<String,Object>> selectMapListExceptLogicDeletedByCriteria(@Param(value="_w")
                                                                                                                                                                          Criteria criteria,
                                                                                                                                                                          @Param(value="_o")
                                                                                                                                                                          OrderBy orderBy,
                                                                                                                                                                          @Param(value="_w_ie")
                                                                                                                                                                          boolean includeEmpty,
                                                                                                                                                                          @Param(value="_w_iec")
                                                                                                                                                                          Set<String> includeEmptyFields,
                                                                                                                                                                          @Param(value="_w_xc")
                                                                                                                                                                          Set<String> excludeFields)

selectMapListExceptLogicDeletedByCriteria

default List<Map<String,Object>> selectMapListExceptLogicDeletedByCriteria(Criteria criteria,
                                                                           OrderBy orderBy,
                                                                           Set<String> includeEmptyFields,
                                                                           Set<String> excludeFields)

selectMapListExceptLogicDeletedByCriteria

default List<Map<String,Object>> selectMapListExceptLogicDeletedByCriteria(Criteria criteria,
                                                                           OrderBy orderBy,
                                                                           Set<String> includeEmptyFields)

selectMapListExceptLogicDeletedByCriteria

default List<Map<String,Object>> selectMapListExceptLogicDeletedByCriteria(Criteria criteria,
                                                                           OrderBy orderBy,
                                                                           boolean includeEmpty)

selectMapListExceptLogicDeletedByCriteria

default List<Map<String,Object>> selectMapListExceptLogicDeletedByCriteria(Criteria criteria)

selectMapListExceptLogicDeletedByCriteria

default List<Map<String,Object>> selectMapListExceptLogicDeletedByCriteria(Criteria criteria,
                                                                           OrderBy orderBy)