BaseDao (openapi 1.7.0 API)

java.lang.Object
- cn.mapway.dao.BaseDao<T>

```
public class BaseDao<T>
extends Object
```
BaseDao

作者:

zhangjianshe@gmail.com

字段概要

字段
限定符和类型字段和说明

protected org.nutz.dao.Dao dao

字段
限定符和类型	字段和说明
`protected org.nutz.dao.Dao`	`dao`

构造器概要

构造器
构造器和说明

BaseDao()

构造器
构造器和说明
`BaseDao()`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`int`	`clear(org.nutz.dao.Condition cnd)` 清晰的根据一个 WHERE 条件，清除一组对象。
`int`	`count()` 计算某个对象在数据库中有多少条记录
`int`	`count(org.nutz.dao.Condition cnd)` 数根据条件，计算某个对象在数据库中有多少条记录
`org.nutz.dao.pager.Pager`	`createPager(int pageNumber, int pageSize)` 创建寻呼机根据数据源的类型，创建一个翻页对象
`int`	`delete(long id)` 删除根据对象 ID 删除一个对象。
`int`	`delete(String name)` 删除根据对象 Name 删除一个对象。
`int`	`deletex(Object... pks)` deletex 根据复合主键，删除一个对象。
`int`	`each(org.nutz.dao.Condition cnd, org.nutz.lang.Each<T> callback)` 每一个对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
`int`	`each(org.nutz.dao.Condition cnd, org.nutz.dao.pager.Pager pager, org.nutz.lang.Each<T> callback)` 每一个对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
`void`	`execute(org.nutz.dao.sql.Sql... sqls)` 执行执行一组 Sql，这些 Sql 将会一起被提交
`org.nutz.dao.sql.Sql`	`execute(org.nutz.dao.sql.Sql sql)` 执行执行单条自定义SQL
`T`	`fastInsert(T obj)` 快速插入快速插入一个对象。
`T`	`fetch(org.nutz.dao.Condition cnd)` 获取根据 WHERE 条件获取一个对象。
`T`	`fetch(long id)` 获取根据对象 ID 获取一个对象。
`T`	`fetch(String name)` 获取根据对象 Name 获取一个对象。
`T`	`fetchx(Object... pks)` fetchx 根据复合主键，获取一个对象。
`org.nutz.dao.Dao`	`getDao()` 把刀
`org.nutz.dao.entity.Entity<T>`	`getEntity()` 得到实体获取实体描述, 其中包含了Java Pojo数据库的全部映射信息
`int`	`getMaxId()` 得到最大id 获取某个对象，最大的 ID 值。
`T`	`getObject(ResultSet rs, org.nutz.dao.FieldMatcher fm)` 得到对象从一个 ResultSet 中获取一个对象。
`T`	`getObject(ResultSet rs, org.nutz.dao.FieldMatcher fm, String prefix)` 得到对象
`void`	`insert(org.nutz.dao.Chain chain)` 插入与 insert(String tableName, Chain chain) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明
`void`	`insert(String tableName, org.nutz.dao.Chain chain)` 插入自由的向一个数据表插入一条数据。
`T`	`insert(T obj)` 插入将一个对象插入到一个数据源。
`T`	`insert(T t, boolean ignoreNull, boolean ignoreZero, boolean ignoreBlankStr)` 插入以特殊规则执行insert
`T`	`insert(T obj, org.nutz.dao.FieldFilter filter)` 插入将一个对象按FieldFilter过滤后,插入到一个数据源。
`T`	`insert(T obj, String actived)` 插入
`T`	`insertLinks(T obj, String regex)` 插入链接根据一个正则表达式，仅将对象所有的关联字段插入到数据库中，并不包括对象本身
`T`	`insertOrUpdate(T t)` 插入或更新根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入
`T`	`insertOrUpdate(T t, org.nutz.dao.FieldFilter insertFieldFilter, org.nutz.dao.FieldFilter updateFieldFilter)` 插入或更新根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入
`T`	`insertRelation(T obj, String regex)` 插入的关系将对象的一个或者多个，多对多的关联信息，插入数据表
`T`	`insertWith(T obj, String regex)` 插入与将对象插入数据库同时，也将符合一个正则表达式的所有关联字段关联的对象统统插入相应的数据库关于关联字段更多信息，请参看 '@One' \| '@Many' \| '@ManyMany' 更多的描述
`org.nutz.dao.DatabaseMeta`	`meta()` 元
`org.nutz.dao.sql.PojoMaker`	`pojoMaker()`
`List<T>`	`query(org.nutz.dao.Condition cnd)` 查询查询一组对象。
`List<T>`	`query(org.nutz.dao.Condition cnd, org.nutz.dao.pager.Pager pager)` 查询查询一组对象。
`List<T>`	`query(org.nutz.dao.Condition cnd, org.nutz.dao.pager.Pager pager, org.nutz.dao.FieldMatcher matcher)` 查询
`List<T>`	`query(org.nutz.dao.Condition cnd, org.nutz.dao.pager.Pager pager, String regex)` 查询
`void`	`run(org.nutz.dao.ConnCallback callback)` 运行这个方法试图给你最大的灵活性，因为你的 ConnCallback 实现类将得到一个 Connection 接口的实例。
`org.nutz.dao.SqlManager`	`sqls()` 中的
`int`	`update(org.nutz.dao.Chain chain, org.nutz.dao.Condition cnd)` 更新与 update(String tableName, Chain chain, Condition cnd) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明
`int`	`update(T obj)` 更新更新一个对象。
`int`	`update(T obj, org.nutz.dao.Condition cnd)` 更新
`int`	`update(T obj, org.nutz.dao.FieldFilter fieldFilter)` 更新
`int`	`update(T obj, org.nutz.dao.FieldFilter fieldFilter, org.nutz.dao.Condition cnd)` 更新
`int`	`update(T obj, String actived)` 更新更新对象一部分字段
`int`	`update(T obj, String actived, String locked, boolean ignoreNull)` 更新更新对象一部分字段
`int`	`updateAndIncrIfMatch(T obj, org.nutz.dao.FieldFilter fieldFilter, String fieldName)` 如果匹配更新和增加乐观锁, 以特定字段的值作为限制条件,更新对象,并自增该字段.
`int`	`updateIgnoreNull(T obj)` 更新忽略空更新一个对象，并且忽略所有 null 字段。
`T`	`updateLinks(T obj, String regex)` 更新的链接根据一个正则表达式，仅更新对象所有的关联字段，并不包括对象本身
`int`	`updateRelation(String regex, org.nutz.dao.Chain chain, org.nutz.dao.Condition cnd)` 更新关系多对多关联是通过一个中间表将两条数据表记录关联起来。
`T`	`updateWith(T obj, String regex)` 更新与将对象更新的同时，也将符合一个正则表达式的所有关联字段关联的对象统统更新关于关联字段更多信息，请参看 '@One' \| '@Many' \| '@ManyMany' 更多的描述

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - dao
```
protected org.nutz.dao.Dao dao
```
- 构造器详细资料
  - BaseDao
```
public BaseDao()
```
- 方法详细资料
  - getDao
```
public org.nutz.dao.Dao getDao()
```
    把刀
    
    返回:
    
    Dao
  - meta
```
public org.nutz.dao.DatabaseMeta meta()
```
    元
    
    返回:
    
    数据源的元数据
  - sqls
```
public org.nutz.dao.SqlManager sqls()
```
    中的
    
    返回:
    
    一个 Sql 管理接口，你可以通过这个接口管理你自定义的 SQL
    
    另请参阅:
    
    SqlManager
  - pojoMaker
```
public org.nutz.dao.sql.PojoMaker pojoMaker()
```
  - execute
```
public void execute(org.nutz.dao.sql.Sql... sqls)
```
    执行执行一组 Sql，这些 Sql 将会一起被提交
    
    参数:
    
    sqls - 要被执行的 Sql 数组
  - run
```
public void run(org.nutz.dao.ConnCallback callback)
```
    运行这个方法试图给你最大的灵活性，因为你的 ConnCallback 实现类将得到一个 Connection 接口的实例。请注意，你不需要关闭这个连接，这个函数在退出时会替你关闭连接。
    如果你从当前连接对象中创建了ResultSet对象或者 Statement对象，请自行关闭。Nutz.Dao 的原则是：
    - Nutz.Dao 创建维护的东西 Nutz.Dao 来维护其生命周期
    - 你创建的东西（比如 ResultSet）你来维护其生命周期
    参数:
    
    callback - 回调
  - getObject
```
public T getObject(ResultSet rs,
                   org.nutz.dao.FieldMatcher fm)
```
    得到对象从一个 ResultSet 中获取一个对象。
    因为 Dao 接口可以知道一个 POJO 的映射细节，这个函数可以帮你节省一点体力。
    
    参数:
    
    rs - 结果集
    
    fm - 字段过滤器
    
    返回:
    
    对象
  - getObject
```
public T getObject(ResultSet rs,
                   org.nutz.dao.FieldMatcher fm,
                   String prefix)
```
    得到对象
    
    参数:
    
    rs - rs
    
    fm - 调频
    
    prefix - 前缀
    
    返回:
    
    T
  - insert
```
public T insert(T obj)
```
    插入将一个对象插入到一个数据源。
    声明了 '@Id'的字段会在插入数据库时被忽略，因为数据库会自动为其设值。如果想手动设置，请设置 '@Id(auto=false)'
    插入之前，会检查声明了 '@Default(@SQL("SELECT ..."))' 的字段，预先执行 SQL 为字段设置。
    插入之后，会检查声明了 '@Next(@SQL("SELECT ..."))' 的字段，通过执行 SQL 将值取回
    如果你的字段仅仅声明了 '@Id(auto=true)'，没有声明 '@Next'，则认为你还是想取回插入后最新的 ID 值，因为自动为你添加类似 @Next(@SQL("SELECT MAX(id) FROM tableName")) 的设置
    参数:
    obj - 要被插入的对象
    它可以是：
    
    普通 POJO
    集合
    数组
    Map
    注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错
    返回:
    
    插入后的对象
    
    另请参阅:
    
    Id, Default, Next
  - insert
```
public T insert(T obj,
                org.nutz.dao.FieldFilter filter)
```
    插入将一个对象按FieldFilter过滤后,插入到一个数据源。 dao.insert(pet, FieldFilter.create(Pet.class, FieldMatcher.create(false)));
    
    参数:
    
    obj - 要被插入的对象
    
    filter - 字段过滤器, 其中FieldMatcher.isIgnoreId生效
    
    返回:
    
    插入后的对象
    
    另请参阅:
    
    Dao.insert(Object)
  - insert
```
public T insert(T obj,
                String actived)
```
    插入
    
    参数:
    
    obj - obj
    
    actived - 中共
    
    返回:
    
    T
  - insert
```
public void insert(String tableName,
                   org.nutz.dao.Chain chain)
```
    插入自由的向一个数据表插入一条数据。数据用名值链描述
    
    参数:
    
    tableName - 数据表名
    
    chain - 数据名值链
  - insert
```
public void insert(org.nutz.dao.Chain chain)
```
    插入与 insert(String tableName, Chain chain) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明
    
    参数:
    
    chain - 数据名值链
    
    另请参阅:
    
    Table
  - fastInsert
```
public T fastInsert(T obj)
```
    快速插入快速插入一个对象。对象的 '@Prev' 以及 '@Next' 在这个函数里不起作用。
    即，你必须为其设置好值，它会统一采用 batch 的方法插入
    参数:
    obj - 要被插入的对象
    它可以是：
    
    普通 POJO
    集合
    数组
    Map
    注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错
    返回:
    
    T
  - insertWith
```
public T insertWith(T obj,
                    String regex)
```
    插入与将对象插入数据库同时，也将符合一个正则表达式的所有关联字段关联的对象统统插入相应的数据库
    关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述
    
    参数:
    
    obj - 数据对象
    
    regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被插入
    
    返回:
    
    数据对象本身
    
    另请参阅:
    
    One, Many, ManyMany
  - insertLinks
```
public T insertLinks(T obj,
                     String regex)
```
    插入链接根据一个正则表达式，仅将对象所有的关联字段插入到数据库中，并不包括对象本身
    
    参数:
    
    obj - 数据对象
    
    regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被插入
    
    返回:
    
    数据对象本身
    
    另请参阅:
    
    One, Many, ManyMany
  - insertRelation
```
public T insertRelation(T obj,
                        String regex)
```
    插入的关系将对象的一个或者多个，多对多的关联信息，插入数据表
    
    参数:
    
    obj - 对象
    
    regex - 正则表达式，描述了那种多对多关联字段将被执行该操作
    
    返回:
    
    对象自身
    
    另请参阅:
    
    ManyMany
  - update
```
public int update(T obj)
```
    更新更新一个对象。对象必须有 '@Id' 或者 '@Name' 或者 '@PK' 声明。
    并且调用这个函数前，主键的值必须保证是有效，否则会更新失败
    这个对象所有的字段都会被更新，即，所有的没有被设值的字段，都会被置成 NULL，如果遇到 NOT NULL 约束，则会引发异常。如果想有选择的更新个别字段，请使用 org.nutz.dao.FieldFilter
    如果仅仅想忽略所有的 null 字段，请使用 updateIgnoreNull 方法更新对象
    参数:
    obj - 要被更新的对象
    它可以是：
    
    普通 POJO
    集合
    数组
    Map
    注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错
    返回:
    
    返回实际被更新的记录条数，一般的情况下，如果更新成功，返回 1，否则，返回 0
    
    另请参阅:
    
    FieldFilter
  - update
```
public int update(T obj,
                  String actived)
```
    更新更新对象一部分字段
    
    参数:
    
    obj - 对象
    
    actived - 正则表达式描述要被更新的字段
    
    返回:
    
    返回实际被更新的记录条数，一般的情况下，如果更新成功，返回 1，否则，返回 0
  - update
```
public int update(T obj,
                  String actived,
                  String locked,
                  boolean ignoreNull)
```
    更新更新对象一部分字段
    
    参数:
    
    obj - 对象
    
    actived - 正则表达式描述要被更新的字段
    
    locked - 锁着的
    
    ignoreNull - 忽略空
    
    返回:
    
    返回实际被更新的记录条数，一般的情况下，如果更新成功，返回 1，否则，返回 0
  - update
```
public int update(T obj,
                  org.nutz.dao.FieldFilter fieldFilter)
```
    更新
    
    参数:
    
    obj - obj
    
    fieldFilter - 字段过滤
    
    返回:
    
    int
  - update
```
public int update(T obj,
                  org.nutz.dao.FieldFilter fieldFilter,
                  org.nutz.dao.Condition cnd)
```
    更新
    
    参数:
    
    obj - obj
    
    fieldFilter - 字段过滤
    
    cnd - cnd
    
    返回:
    
    int
  - update
```
public int update(T obj,
                  org.nutz.dao.Condition cnd)
```
    更新
    
    参数:
    
    obj - obj
    
    cnd - cnd
    
    返回:
    
    int
  - updateIgnoreNull
```
public int updateIgnoreNull(T obj)
```
    更新忽略空更新一个对象，并且忽略所有 null 字段。
    注意: 基本数据类型都是不可能为null的,这些字段肯定会更新
    参数:
    obj - 要被更新的对象
    它可以是：
    
    普通 POJO
    集合
    数组
    Map
    注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错
    返回:
    
    返回实际被更新的记录条数，一般的情况下，如果是单一Pojo,更新成功，返回 1，否则，返回 0
  - update
```
public int update(org.nutz.dao.Chain chain,
                  org.nutz.dao.Condition cnd)
```
    更新与 update(String tableName, Chain chain, Condition cnd) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明
    
    参数:
    
    chain - 数据名值链
    
    cnd - WHERE 条件
    
    返回:
    
    有多少条记录被更新了
    
    另请参阅:
    
    Table
  - updateWith
```
public T updateWith(T obj,
                    String regex)
```
    更新与将对象更新的同时，也将符合一个正则表达式的所有关联字段关联的对象统统更新
    关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述
    
    参数:
    
    obj - 数据对象
    
    regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被更新
    
    返回:
    
    数据对象本身
    
    另请参阅:
    
    One, Many, ManyMany
  - updateLinks
```
public T updateLinks(T obj,
                     String regex)
```
    更新的链接根据一个正则表达式，仅更新对象所有的关联字段，并不包括对象本身
    
    参数:
    
    obj - 数据对象
    
    regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被更新
    
    返回:
    
    数据对象本身
    
    另请参阅:
    
    One, Many, ManyMany
  - updateRelation
```
public int updateRelation(String regex,
                          org.nutz.dao.Chain chain,
                          org.nutz.dao.Condition cnd)
```
    更新关系多对多关联是通过一个中间表将两条数据表记录关联起来。
    而这个中间表可能还有其他的字段，比如描述关联的权重等
    这个操作可以让你一次更新某一个对象中多个多对多关联的数据
    
    参数:
    
    regex - 正则表达式，描述了那种多对多关联字段将被执行该操作
    
    chain - 针对中间关联表的名值链。
    
    cnd - 针对中间关联表的 WHERE 条件
    
    返回:
    
    共有多少条数据被更新
    
    另请参阅:
    
    ManyMany
  - query
```
public List<T> query(org.nutz.dao.Condition cnd,
                     org.nutz.dao.pager.Pager pager,
                     org.nutz.dao.FieldMatcher matcher)
```
    查询
    
    参数:
    
    cnd - cnd
    
    pager - 寻呼机
    
    matcher - 匹配器
    
    返回:
    
    List
  - query
```
public List<T> query(org.nutz.dao.Condition cnd,
                     org.nutz.dao.pager.Pager pager,
                     String regex)
```
    查询
    
    参数:
    
    cnd - cnd
    
    pager - 寻呼机
    
    regex - 正则表达式
    
    返回:
    
    List
  - query
```
public List<T> query(org.nutz.dao.Condition cnd,
                     org.nutz.dao.pager.Pager pager)
```
    查询查询一组对象。你可以为这次查询设定条件，并且只获取一部分对象（翻页）
    
    参数:
    
    cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序
    
    pager - 翻页信息。如果为 null，则一次全部返回. 不会使用cnd中的pager!!!
    
    返回:
    
    对象列表
  - query
```
public List<T> query(org.nutz.dao.Condition cnd)
```
    查询查询一组对象。你可以为这次查询设定条件
    
    参数:
    
    cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序
    只有在调用这个函数的时候， cnd.limit 才会生效
    
    返回:
    
    对象列表
  - each
```
public int each(org.nutz.dao.Condition cnd,
                org.nutz.dao.pager.Pager pager,
                org.nutz.lang.Each<T> callback)
```
    每一个对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
    
    参数:
    
    cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序
    
    pager - 翻页信息。如果为 null，则一次全部返回
    
    callback - 处理回调
    
    返回:
    
    一共迭代的数量
  - each
```
public int each(org.nutz.dao.Condition cnd,
                org.nutz.lang.Each<T> callback)
```
    每一个对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
    
    参数:
    
    cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序
    
    callback - 处理回调
    
    返回:
    
    一共迭代的数量
  - delete
```
public int delete(long id)
```
    删除根据对象 ID 删除一个对象。它只会删除这个对象，关联对象不会被删除。
    你的对象必须在某个字段声明了注解 '@Id'，否则本操作会抛出一个运行时异常
    如果你设定了外键约束，没有正确的清除关联对象会导致这个操作失败
    
    参数:
    
    id - 对象 ID
    
    返回:
    
    影响的行数
    
    另请参阅:
    
    Id
  - delete
```
public int delete(String name)
```
    删除根据对象 Name 删除一个对象。它只会删除这个对象，关联对象不会被删除。
    你的对象必须在某个字段声明了注解 '@Name'，否则本操作会抛出一个运行时异常
    如果你设定了外键约束，没有正确的清除关联对象会导致这个操作失败
    
    参数:
    
    name - 对象 Name
    
    返回:
    
    影响的行数
    
    另请参阅:
    
    Name
  - deletex
```
public int deletex(Object... pks)
```
    deletex 根据复合主键，删除一个对象。该对象必须声明 '@PK'，并且，给定的参数顺序必须同 '@PK' 中声明的顺序一致，否则会产生不可预知的错误。
    
    参数:
    
    pks - 复合主键需要的参数，必须同 '@PK'中声明的顺序一致
    
    返回:
    
    int
  - fetch
```
public T fetch(long id)
```
    获取根据对象 ID 获取一个对象。它只会获取这个对象，关联对象不会被获取。
    你的对象必须在某个字段声明了注解 '@Id'，否则本操作会抛出一个运行时异常
    
    参数:
    
    id - 对象 ID
    
    返回:
    
    T
    
    另请参阅:
    
    Id
  - fetch
```
public T fetch(String name)
```
    获取根据对象 Name 获取一个对象。它只会获取这个对象，关联对象不会被获取。
    你的对象必须在某个字段声明了注解 '@Name'，否则本操作会抛出一个运行时异常
    
    参数:
    
    name - 对象 Name
    
    返回:
    
    对象本身
    
    另请参阅:
    
    Name
  - fetchx
```
public T fetchx(Object... pks)
```
    fetchx 根据复合主键，获取一个对象。该对象必须声明 '@PK'，并且，给定的参数顺序必须同 '@PK' 中声明的顺序一致，否则会产生不可预知的错误。
    
    参数:
    
    pks - 复合主键需要的参数，必须同 '@PK'中声明的顺序一致
    
    返回:
    
    T
  - fetch
```
public T fetch(org.nutz.dao.Condition cnd)
```
    获取根据 WHERE 条件获取一个对象。如果有多个对象符合条件，将只获取 ResultSet 第一个记录
    
    参数:
    
    cnd - WHERE 条件
    
    返回:
    
    对象本身
    
    另请参阅:
    
    Condition, Name
  - clear
```
public int clear(org.nutz.dao.Condition cnd)
```
    清晰的根据一个 WHERE 条件，清除一组对象。只包括对象本身，不包括关联字段
    
    参数:
    
    cnd - 查询条件，如果为 null，则全部清除
    
    返回:
    
    影响的行数
  - getEntity
```
public org.nutz.dao.entity.Entity<T> getEntity()
```
    得到实体获取实体描述, 其中包含了Java Pojo数据库的全部映射信息
    
    返回:
    
    实体描述
  - count
```
public int count(org.nutz.dao.Condition cnd)
```
    数根据条件，计算某个对象在数据库中有多少条记录
    
    参数:
    
    cnd - WHERE 条件
    
    返回:
    
    数量
  - count
```
public int count()
```
    计算某个对象在数据库中有多少条记录
    
    返回:
    
    数量
  - getMaxId
```
public int getMaxId()
```
    得到最大id 获取某个对象，最大的 ID 值。这个对象必须声明了 '@Id'
    
    返回:
    
    最大 ID 值
  - createPager
```
public org.nutz.dao.pager.Pager createPager(int pageNumber,
                                            int pageSize)
```
    创建寻呼机根据数据源的类型，创建一个翻页对象
    
    参数:
    
    pageNumber - 第几页，从 1 开始。
    
    pageSize - 每页可以有多少条记录
    
    返回:
    
    翻页对象
  - execute
```
public org.nutz.dao.sql.Sql execute(org.nutz.dao.sql.Sql sql)
```
    执行执行单条自定义SQL
    
    参数:
    
    sql - 自定义SQL对象
    
    返回:
    
    传入的SQL对象, 方便链式调用
  - insert
```
public T insert(T t,
                boolean ignoreNull,
                boolean ignoreZero,
                boolean ignoreBlankStr)
```
    插入以特殊规则执行insert
    
    参数:
    
    t - 实例对象
    
    ignoreNull - 忽略空值
    
    ignoreZero - 忽略0值
    
    ignoreBlankStr - 忽略空白字符串
    
    返回:
    
    传入的实例变量
  - insertOrUpdate
```
public T insertOrUpdate(T t)
```
    插入或更新根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入
    
    参数:
    
    t - 对象
    
    返回:
    
    原对象
  - insertOrUpdate
```
public T insertOrUpdate(T t,
                        org.nutz.dao.FieldFilter insertFieldFilter,
                        org.nutz.dao.FieldFilter updateFieldFilter)
```
    插入或更新根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入
    
    参数:
    
    t - 对象
    
    insertFieldFilter - 插入时的字段过滤, 可以是null
    
    updateFieldFilter - 更新时的字段过滤,可以是null
    
    返回:
    
    原对象
  - updateAndIncrIfMatch
```
public int updateAndIncrIfMatch(T obj,
                                org.nutz.dao.FieldFilter fieldFilter,
                                String fieldName)
```
    如果匹配更新和增加乐观锁, 以特定字段的值作为限制条件,更新对象,并自增该字段. 执行的sql如下: update t_user set age=30, city="广州", version=version+1 where name="wendal" and version=124;
    
    参数:
    
    obj - 需要更新的对象, 必须带@Id/@Name/@Pk中的其中一种.
    
    fieldFilter - 需要过滤的属性. 若设置了哪些字段不更新,那务必确保过滤掉fieldName的字段
    
    fieldName - 参考字段的Java属性名.默认是"version",可以是任意数值字段
    
    返回:
    
    若更新成功, 返回值大于0, 否则小于等于0

类 BaseDao<T>

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

dao

构造器详细资料

BaseDao

方法详细资料

getDao

meta

sqls

pojoMaker

execute

run

getObject

getObject

insert

insert

insert

insert

insert

fastInsert

insertWith

insertLinks

insertRelation

update

update

update

update

update

update

updateIgnoreNull

update

updateWith

updateLinks

updateRelation

query

query

query

query

each

each

delete

delete

deletex

fetch

fetch

fetchx

fetch

clear

getEntity

count

count

getMaxId

createPager

execute

insert

insertOrUpdate

insertOrUpdate

updateAndIncrIfMatch