io.polaris.mybatis.mapper

接口 EntitySelectCursorMapper<E>

所有超级接口:

EntityMapper<E>

public interface EntitySelectCursorMapper<E>
extends EntityMapper<E>

从以下版本开始:

Aug 25, 2023

作者:

Qt

方法概要

限定符和类型	方法和说明
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursor(E entity)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursor(E entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursor(E entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<E>	selectEntityCursor(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursor(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursor(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByCriteria(Criteria criteria)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByCriteria(Criteria criteria, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByMap(Map<String,Object> entity)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByMap(Map<String,Object> entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeleted(E entity)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeleted(E entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<E>	selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursor(E entity)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursor(E entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursor(E entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursor(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursor(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursor(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByCriteria(Criteria criteria)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByCriteria(Criteria criteria, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByMap(Map<String,Object> entity)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByMap(Map<String,Object> entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeleted(E entity)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeleted(E entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeleted(E entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeleted(E entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty)
org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, boolean includeEmpty, Set<String> includeEmptyFields, Set<String> excludeFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields)
default org.apache.ibatis.cursor.Cursor<Map<String,Object>>	selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity, OrderBy orderBy, Set<String> includeEmptyFields, Set<String> excludeFields)

方法详细资料

selectEntityCursor

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<E> selectEntityCursor(@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)

selectEntityCursor

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursor(E entity,
                                                              OrderBy orderBy,
                                                              Set<String> includeEmptyFields,
                                                              Set<String> excludeFields)

selectEntityCursor

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursor(E entity,
                                                              OrderBy orderBy,
                                                              Set<String> includeEmptyFields)

selectEntityCursor

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursor(E entity,
                                                              OrderBy orderBy,
                                                              boolean includeEmpty)

selectEntityCursor

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursor(E entity,
                                                              OrderBy orderBy)

selectEntityCursor

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursor(E entity)

selectEntityCursorByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByMap(@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)

selectEntityCursorByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByMap(Map<String,Object> entity,
                                                                   OrderBy orderBy,
                                                                   Set<String> includeEmptyFields,
                                                                   Set<String> excludeFields)

selectEntityCursorByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByMap(Map<String,Object> entity,
                                                                   OrderBy orderBy,
                                                                   Set<String> includeEmptyFields)

selectEntityCursorByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByMap(Map<String,Object> entity,
                                                                   OrderBy orderBy,
                                                                   boolean includeEmpty)

selectEntityCursorByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByMap(Map<String,Object> entity,
                                                                   OrderBy orderBy)

selectEntityCursorByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByMap(Map<String,Object> entity)

selectEntityCursorByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByCriteria(@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)

selectEntityCursorByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByCriteria(Criteria criteria,
                                                                        OrderBy orderBy,
                                                                        Set<String> includeEmptyFields,
                                                                        Set<String> excludeFields)

selectEntityCursorByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByCriteria(Criteria criteria,
                                                                        OrderBy orderBy,
                                                                        Set<String> includeEmptyFields)

selectEntityCursorByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByCriteria(Criteria criteria,
                                                                        OrderBy orderBy,
                                                                        boolean includeEmpty)

selectEntityCursorByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByCriteria(Criteria criteria,
                                                                        OrderBy orderBy)

selectEntityCursorByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorByCriteria(Criteria criteria)

selectMapCursor

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursor(@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)

selectMapCursor

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursor(E entity,
                                                                            OrderBy orderBy,
                                                                            Set<String> includeEmptyFields,
                                                                            Set<String> excludeFields)

selectMapCursor

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursor(E entity,
                                                                            OrderBy orderBy,
                                                                            Set<String> includeEmptyFields)

selectMapCursor

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursor(E entity,
                                                                            OrderBy orderBy,
                                                                            boolean includeEmpty)

selectMapCursor

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursor(E entity,
                                                                            OrderBy orderBy)

selectMapCursor

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursor(E entity)

selectMapCursorByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByMap(@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)

selectMapCursorByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByMap(Map<String,Object> entity,
                                                                                 OrderBy orderBy,
                                                                                 Set<String> includeEmptyFields,
                                                                                 Set<String> excludeFields)

selectMapCursorByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByMap(Map<String,Object> entity,
                                                                                 OrderBy orderBy,
                                                                                 Set<String> includeEmptyFields)

selectMapCursorByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByMap(Map<String,Object> entity,
                                                                                 OrderBy orderBy,
                                                                                 boolean includeEmpty)

selectMapCursorByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByMap(Map<String,Object> entity)

selectMapCursorByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByMap(Map<String,Object> entity,
                                                                                 OrderBy orderBy)

selectMapCursorByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntity")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByCriteria(@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)

selectMapCursorByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByCriteria(Criteria criteria,
                                                                                      OrderBy orderBy,
                                                                                      Set<String> includeEmptyFields,
                                                                                      Set<String> excludeFields)

selectMapCursorByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByCriteria(Criteria criteria,
                                                                                      OrderBy orderBy,
                                                                                      Set<String> includeEmptyFields)

selectMapCursorByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByCriteria(Criteria criteria,
                                                                                      OrderBy orderBy,
                                                                                      boolean includeEmpty)

selectMapCursorByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByCriteria(Criteria criteria)

selectMapCursorByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorByCriteria(Criteria criteria,
                                                                                      OrderBy orderBy)

selectEntityCursorExceptLogicDeleted

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeleted(@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)

selectEntityCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeleted(E entity,
                                                                                OrderBy orderBy,
                                                                                Set<String> includeEmptyFields,
                                                                                Set<String> excludeFields)

selectEntityCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeleted(E entity,
                                                                                OrderBy orderBy,
                                                                                Set<String> includeEmptyFields)

selectEntityCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeleted(E entity,
                                                                                OrderBy orderBy,
                                                                                boolean includeEmpty)

selectEntityCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeleted(E entity,
                                                                                OrderBy orderBy)

selectEntityCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeleted(E entity)

selectEntityCursorExceptLogicDeletedByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByMap(@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)

selectEntityCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                     OrderBy orderBy,
                                                                                     Set<String> includeEmptyFields,
                                                                                     Set<String> excludeFields)

selectEntityCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                     OrderBy orderBy,
                                                                                     Set<String> includeEmptyFields)

selectEntityCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                     OrderBy orderBy,
                                                                                     boolean includeEmpty)

selectEntityCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                     OrderBy orderBy)

selectEntityCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByMap(Map<String,Object> entity)

selectEntityCursorExceptLogicDeletedByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByCriteria(@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)

selectEntityCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                          OrderBy orderBy,
                                                                                          Set<String> includeEmptyFields,
                                                                                          Set<String> excludeFields)

selectEntityCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                          OrderBy orderBy,
                                                                                          Set<String> includeEmptyFields)

selectEntityCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                          OrderBy orderBy,
                                                                                          boolean includeEmpty)

selectEntityCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                          OrderBy orderBy)

selectEntityCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<E> selectEntityCursorExceptLogicDeletedByCriteria(Criteria criteria)

selectMapCursorExceptLogicDeleted

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeleted(@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)

selectMapCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeleted(E entity,
                                                                                              OrderBy orderBy,
                                                                                              Set<String> includeEmptyFields,
                                                                                              Set<String> excludeFields)

selectMapCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeleted(E entity,
                                                                                              OrderBy orderBy,
                                                                                              Set<String> includeEmptyFields)

selectMapCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeleted(E entity,
                                                                                              OrderBy orderBy,
                                                                                              boolean includeEmpty)

selectMapCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeleted(E entity,
                                                                                              OrderBy orderBy)

selectMapCursorExceptLogicDeleted

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeleted(E entity)

selectMapCursorExceptLogicDeletedByMap

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByMap(@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)

selectMapCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                                   OrderBy orderBy,
                                                                                                   Set<String> includeEmptyFields,
                                                                                                   Set<String> excludeFields)

selectMapCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                                   OrderBy orderBy,
                                                                                                   Set<String> includeEmptyFields)

selectMapCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                                   OrderBy orderBy,
                                                                                                   boolean includeEmpty)

selectMapCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity)

selectMapCursorExceptLogicDeletedByMap

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByMap(Map<String,Object> entity,
                                                                                                   OrderBy orderBy)

selectMapCursorExceptLogicDeletedByCriteria

@SelectProvider(type=MapperProviders.class,
                method="selectEntityExceptLogicDeleted")
 @Options(fetchSize=1000)
org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByCriteria(@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)

selectMapCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                                        OrderBy orderBy,
                                                                                                        Set<String> includeEmptyFields,
                                                                                                        Set<String> excludeFields)

selectMapCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                                        OrderBy orderBy,
                                                                                                        Set<String> includeEmptyFields)

selectMapCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                                        OrderBy orderBy,
                                                                                                        boolean includeEmpty)

selectMapCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria)

selectMapCursorExceptLogicDeletedByCriteria

default org.apache.ibatis.cursor.Cursor<Map<String,Object>> selectMapCursorExceptLogicDeletedByCriteria(Criteria criteria,
                                                                                                        OrderBy orderBy)