Dao

概述

软件包

类

树

已过时

索引

帮助

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

org.nutz.dao
接口 Dao

所有已知实现类：: LazyNutDao, NutDao

public interface Dao

Nutz.Dao 核心接口。封装了所有的数据库操作

作者：: zozoh(zozohtnt@gmail.com)

方法摘要

int clear(java.lang.Class<?> classOfT)
清除对象所有的记录

int clear(java.lang.Class<?> classOfT, Condition cnd)
根据一个 WHERE 条件，清除一组对象。

int clear(java.lang.String tableName)
清除数据表所有记录

int clear(java.lang.String tableName, Condition cnd)
根据一个 WHERE 条件，清除一组记录





<T> T

clearLinks(T obj,
           java.lang.String regex)

根据正则表达式，清除对象的关联。

int count(java.lang.Class<?> classOfT)
计算某个对象在数据库中有多少条记录

int count(java.lang.Class<?> classOfT, Condition cnd)
根据条件，计算某个对象在数据库中有多少条记录

int count(java.lang.String tableName)
计算某个数据表或视图中有多少条记录

int count(java.lang.String tableName, Condition cnd)
根据条件，计算某个数据表或视图中有多少条记录





<T> Entity<T>

create(java.lang.Class<T> classOfT,
       boolean dropIfExists)

根据一个实体的配置信息为其创建一张表

Pager createPager(int pageNumber, int pageSize)
根据数据源的类型，创建一个翻页对象

int delete(java.lang.Class<?> classOfT, long id)
根据对象 ID 删除一个对象。

int delete(java.lang.Class<?> classOfT, java.lang.String name)
根据对象 Name 删除一个对象。

int delete(java.lang.Object obj)
自动判断如何删除一个对象。

int deleteLinks(java.lang.Object obj, java.lang.String regex)
根据一个正则表达式，仅删除对象所有的关联字段，并不包括对象本身。

int deleteWith(java.lang.Object obj, java.lang.String regex)
将对象删除的同时，也将符合一个正则表达式的所有关联字段关联的对象统统删除 注意： Java 对象的字段会被保留，这里的删除，将只会删除数据库中的记录关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述





<T> int

deletex(java.lang.Class<T> classOfT,
        java.lang.Object... pks)

根据复合主键，删除一个对象。

boolean drop(java.lang.Class<?> classOfT)
如果一个实体的数据表存在，移除它

boolean drop(java.lang.String tableName)
如果一个数据表存在，移除它





<T> int

each(java.lang.Class<T> classOfT,
     Condition cnd,
     Each<T> callback)

对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里





<T> int

each(java.lang.Class<T> classOfT,
     Condition cnd,
     Pager pager,
     Each<T> callback)

对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

int each(java.lang.String tableName, Condition cnd, Each<Record> callback)
对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

int each(java.lang.String tableName, Condition cnd, Pager pager, Each<Record> callback)
对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

void execute(Sql... sqls)
执行一组 Sql，这些 Sql 将会一起被提交

boolean exists(java.lang.Class<?> classOfT)

boolean exists(java.lang.String tableName)





<T> T

fastInsert(T obj)
快速插入一个对象。





<T> T

fetch(java.lang.Class<T> classOfT)
随便获取一个对象。





<T> T

fetch(java.lang.Class<T> classOfT,
      Condition cnd)

根据 WHERE 条件获取一个对象。





<T> T

fetch(java.lang.Class<T> classOfT,
      long id)

根据对象 ID 获取一个对象。





<T> T

fetch(java.lang.Class<T> classOfT,
      java.lang.String name)

根据对象 Name 获取一个对象。

Record fetch(java.lang.String tableName, Condition cnd)
根据条件获取一个 Record 对象





<T> T

fetch(T obj)
根据一个参考对象自动判断如何获取一个对象。





<T> T

fetchLinks(T obj,
           java.lang.String regex)

根据一个正则表达式，获取对象所有的关联字段





<T> T

fetchx(java.lang.Class<T> classOfT,
       java.lang.Object... pks)

根据复合主键，获取一个对象。

int func(java.lang.Class<?> classOfT, java.lang.String funcName, java.lang.String fieldName)
对某一个对象字段，进行计算。

int func(java.lang.Class<?> classOfT, java.lang.String funcName, java.lang.String fieldName, Condition cnd)
对某一个对象字段，进行计算。

int func(java.lang.String tableName, java.lang.String funcName, java.lang.String colName)
对某一个数据表字段，进行计算。

int func(java.lang.String tableName, java.lang.String funcName, java.lang.String colName, Condition cnd)
对某一个数据表字段，进行计算。





<T> Entity<T>

getEntity(java.lang.Class<T> classOfT)

int getMaxId(java.lang.Class<?> classOfT)
获取某个对象，最大的 ID 值。





<T> T

getObject(java.lang.Class<T> classOfT,
          java.sql.ResultSet rs,
          FieldMatcher fm)

从一个 ResultSet 中获取一个对象。

void insert(java.lang.Class<?> classOfT, Chain chain)
与 insert(String tableName, Chain chain) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明

void insert(java.lang.String tableName, Chain chain)
自由的向一个数据表插入一条数据。





<T> T

insert(T obj)
将一个对象插入到一个数据源。





<T> T

insertLinks(T obj,
            java.lang.String regex)

根据一个正则表达式，仅将对象所有的关联字段插入到数据库中，并不包括对象本身





<T> T

insertRelation(T obj,
               java.lang.String regex)

将对象的一个或者多个，多对多的关联信息，插入数据表





<T> T

insertWith(T obj,
           java.lang.String regex)

将对象插入数据库同时，也将符合一个正则表达式的所有关联字段关联的对象统统插入相应的数据库关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述

DatabaseMeta meta()





<T> java.util.List<T>

query(java.lang.Class<T> classOfT,
      Condition cnd)

查询一组对象。





<T> java.util.List<T>

query(java.lang.Class<T> classOfT,
      Condition cnd,
      Pager pager)

查询一组对象。

java.util.List<Record> query(java.lang.String tableName, Condition cnd)
查询出一组记录。

java.util.List<Record> query(java.lang.String tableName, Condition cnd, Pager pager)
查询出一组记录。

void run(ConnCallback callback)
这个方法试图给你最大的灵活性，因为你的 ConnCallback 实现类将得到一个 Connection 接口的实例。

SqlManager sqls()

int update(java.lang.Class<?> classOfT, Chain chain, Condition cnd)
与 update(String tableName, Chain chain, Condition cnd) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明

int update(java.lang.Object obj)
更新一个对象。

int update(java.lang.Object obj, java.lang.String regex)
更新对象一部分字段

int update(java.lang.String tableName, Chain chain, Condition cnd)
自由的更新多条数据

int updateIgnoreNull(java.lang.Object obj)
更新一个对象，并且忽略所有非 null 字段。





<T> T

updateLinks(T obj,
            java.lang.String regex)

根据一个正则表达式，仅更新对象所有的关联字段，并不包括对象本身

int updateRelation(java.lang.Class<?> classOfT, java.lang.String regex, Chain chain, Condition cnd)
多对多关联是通过一个中间表将两条数据表记录关联起来。





<T> T

updateWith(T obj,
           java.lang.String regex)

将对象更新的同时，也将符合一个正则表达式的所有关联字段关联的对象统统更新关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述

方法详细信息

sqls

SqlManager sqls()

返回：: 一个 Sql 管理接口，你可以通过这个接口管理你自定义的 SQL
另请参见：: SqlManager

execute

void execute(Sql... sqls)

执行一组 Sql，这些 Sql 将会一起被提交

参数：: sqls - 要被执行的 Sql 数组

run

void run(ConnCallback callback)

这个方法试图给你最大的灵活性，因为你的 ConnCallback 实现类将得到一个 Connection 接口的实例。请注意，你不需要关闭这个连接，这个函数在退出时会替你关闭连接。

如果你从当前连接对象中创建了ResultSet对象或者 Statement对象，请自行关闭。Nutz.Dao 的原则是：

Nutz.Dao 创建维护的东西 Nutz.Dao 来维护其生命周期
你创建的东西（比如 ResultSet）你来维护其生命周期

参数：: callback -

getObject

<T> T getObject(java.lang.Class<T> classOfT,
                java.sql.ResultSet rs,
                FieldMatcher fm)

从一个 ResultSet 中获取一个对象。

因为 Dao 接口可以知道一个 POJO 的映射细节，这个函数可以帮你节省一点体力。

参数：: classOfT - 对象类型; rs - 结果集; fm - 字段过滤器
返回：: 对象

insert

<T> 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

void insert(java.lang.String tableName,
            Chain chain)

自由的向一个数据表插入一条数据。数据用名值链描述

参数：: tableName - 数据表名; chain - 数据名值链

insert

void insert(java.lang.Class<?> classOfT,
            Chain chain)

与 insert(String tableName, Chain chain) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明

参数：: classOfT - 实体类型; chain - 数据名值链
另请参见：: Table

fastInsert

<T> T fastInsert(T obj)

快速插入一个对象。对象的 '@Prev' 以及 '@Next' 在这个函数里不起作用。

即，你必须为其设置好值，它会统一采用 batch 的方法插入

参数：

obj - 要被插入的对象

它可以是：

普通 POJO
集合
数组
Map

注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错

insertWith

<T> T insertWith(T obj,
                 java.lang.String regex)

将对象插入数据库同时，也将符合一个正则表达式的所有关联字段关联的对象统统插入相应的数据库

关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被插入
返回：: 数据对象本身
另请参见：: One, Many, ManyMany

insertLinks

<T> T insertLinks(T obj,
                  java.lang.String regex)

根据一个正则表达式，仅将对象所有的关联字段插入到数据库中，并不包括对象本身

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被插入
返回：: 数据对象本身
另请参见：: One, Many, ManyMany

insertRelation

<T> T insertRelation(T obj,
                     java.lang.String regex)

将对象的一个或者多个，多对多的关联信息，插入数据表

参数：: obj - 对象; regex - 正则表达式，描述了那种多对多关联字段将被执行该操作
返回：: 对象自身
另请参见：: ManyMany

update

int update(java.lang.Object obj)

更新一个对象。对象必须有 '@Id' 或者 '@Name' 或者 '@PK' 声明。

并且调用这个函数前，主键的值必须保证是有效，否则会更新失败

这个对象所有的字段都会被更新，即，所有的没有被设值的字段，都会被置成 NULL，如果遇到 NOT NULL 约束，则会引发异常。如果想有选择的更新个别字段，请使用 org.nutz.dao.FieldFilter

如果仅仅想忽略所有的 null 字段，请使用 updateIgnoreNull 方法更新对象

参数：

obj - 要被更新的对象

它可以是：

普通 POJO
集合
数组
Map

注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错

返回：

返回实际被更新的记录条数，一般的情况下，如果更新成功，返回 1，否则，返回 0

另请参见：

FieldFilter

update

int update(java.lang.Object obj,
           java.lang.String regex)

更新对象一部分字段

参数：: obj - 对象; regex - 正则表达式描述要被更新的字段
返回：: 返回实际被更新的记录条数，一般的情况下，如果更新成功，返回 1，否则，返回 0

updateIgnoreNull

int updateIgnoreNull(java.lang.Object obj)

更新一个对象，并且忽略所有非 null 字段。

参数：

obj - 要被更新的对象

它可以是：

普通 POJO
集合
数组
Map

注意： 如果是集合，数组或者 Map，所有的对象必须类型相同，否则可能会出错

返回：

返回实际被更新的记录条数，一般的情况下，如果更新成功，返回 1，否则，返回 0

update

int update(java.lang.String tableName,
           Chain chain,
           Condition cnd)

自由的更新多条数据

参数：: tableName - 数据表名; chain - 数据名值链。; cnd - WHERE 条件
返回：: 有多少条记录被更新了

update

int update(java.lang.Class<?> classOfT,
           Chain chain,
           Condition cnd)

与 update(String tableName, Chain chain, Condition cnd) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明

参数：: classOfT - 实体类型; chain - 数据名值链; cnd - WHERE 条件
返回：: 有多少条记录被更新了
另请参见：: Table

updateWith

<T> T updateWith(T obj,
                 java.lang.String regex)

将对象更新的同时，也将符合一个正则表达式的所有关联字段关联的对象统统更新

关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被更新
返回：: 数据对象本身
另请参见：: One, Many, ManyMany

updateLinks

<T> T updateLinks(T obj,
                  java.lang.String regex)

根据一个正则表达式，仅更新对象所有的关联字段，并不包括对象本身

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被更新
返回：: 数据对象本身
另请参见：: One, Many, ManyMany

updateRelation

int updateRelation(java.lang.Class<?> classOfT,
                   java.lang.String regex,
                   Chain chain,
                   Condition cnd)

多对多关联是通过一个中间表将两条数据表记录关联起来。

而这个中间表可能还有其他的字段，比如描述关联的权重等

这个操作可以让你一次更新某一个对象中多个多对多关联的数据

参数：: classOfT - 对象类型; regex - 正则表达式，描述了那种多对多关联字段将被执行该操作; chain - 针对中间关联表的名值链。; cnd - 针对中间关联表的 WHERE 条件
返回：: 共有多少条数据被更新
另请参见：: ManyMany

query

<T> java.util.List<T> query(java.lang.Class<T> classOfT,
                            Condition cnd,
                            Pager pager)

查询一组对象。你可以为这次查询设定条件，并且只获取一部分对象（翻页）

参数：: classOfT - 对象类型; cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序; pager - 翻页信息。如果为 null，则一次全部返回
返回：: 对象列表

query

<T> java.util.List<T> query(java.lang.Class<T> classOfT,
                            Condition cnd)

查询一组对象。你可以为这次查询设定条件，并且只获取一部分对象（翻页）

参数：: classOfT - 对象类型; cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序
返回：: 对象列表

query

java.util.List<Record> query(java.lang.String tableName,
                             Condition cnd,
                             Pager pager)

查询出一组记录。

参数：: tableName - 表名 - 格式为 tableName[:idName] 比如： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则不能分页; cnd - 条件 - 请注意： 你传入的 Criteria 实现必须考虑到没有 'Entity' 传入。即 toSql 函数的参数永远为 null。; pager - 翻页信息
返回：: Record 对象。实际上是一个 Map 的包裹类
另请参见：: Condition

query

java.util.List<Record> query(java.lang.String tableName,
                             Condition cnd)

查询出一组记录。

参数：: tableName - 表名 - 格式为 tableName[:idName] 比如： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则不能分页; cnd - 条件 - 请注意： 你传入的 Criteria 实现必须考虑到没有 'Entity' 传入。即 toSql 函数的参数永远为 null。
返回：: Record 对象。实际上是一个 Map 的包裹类
另请参见：: Condition

each

<T> int each(java.lang.Class<T> classOfT,
             Condition cnd,
             Pager pager,
             Each<T> callback)

对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

参数：: classOfT - 对象类型; cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序; pager - 翻页信息。如果为 null，则一次全部返回; callback - 处理回调
返回：: 一共迭代的数量

each

<T> int each(java.lang.Class<T> classOfT,
             Condition cnd,
             Each<T> callback)

对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

参数：: classOfT - 对象类型; cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序; callback - 处理回调
返回：: 一共迭代的数量

each

int each(java.lang.String tableName,
         Condition cnd,
         Pager pager,
         Each<Record> callback)

对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

参数：: tableName - 表名 - 格式为 tableName[:idName] 比如： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则不能分页; cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序; pager - 翻页信息。如果为 null，则一次全部返回; callback - 处理回调
返回：: 一共迭代的数量

each

int each(java.lang.String tableName,
         Condition cnd,
         Each<Record> callback)

对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里

参数：: tableName - 表名 - 格式为 tableName[:idName] 比如： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则不能分页; cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序; callback - 处理回调
返回：: 一共迭代的数量

delete

int delete(java.lang.Class<?> classOfT,
           long id)

根据对象 ID 删除一个对象。它只会删除这个对象，关联对象不会被删除。

你的对象必须在某个字段声明了注解 '@Id'，否则本操作会抛出一个运行时异常

如果你设定了外键约束，没有正确的清除关联对象会导致这个操作失败

参数：: classOfT - 对象类型; id - 对象 ID
返回：: 影响的行数
另请参见：: Id

delete

int delete(java.lang.Class<?> classOfT,
           java.lang.String name)

根据对象 Name 删除一个对象。它只会删除这个对象，关联对象不会被删除。

你的对象必须在某个字段声明了注解 '@Name'，否则本操作会抛出一个运行时异常

如果你设定了外键约束，没有正确的清除关联对象会导致这个操作失败

参数：: classOfT - 对象类型; name - 对象 Name
返回：: 影响的行数
另请参见：: Name

deletex

<T> int deletex(java.lang.Class<T> classOfT,
                java.lang.Object... pks)

根据复合主键，删除一个对象。该对象必须声明 '@PK'，并且，给定的参数顺序必须同 '@PK' 中声明的顺序一致，否则会产生不可预知的错误。

参数：: classOfT -; pks - 复合主键需要的参数，必须同 '@PK'中声明的顺序一致

delete

int delete(java.lang.Object obj)

自动判断如何删除一个对象。

如果声明了 '@Id' 则相当于 delete(Class,long)
如果声明了 '@Name'，则相当于 delete(Class,String)
如果声明了 '@PK'，则 deletex(Class,Object ...)
如果没声明任何上面三个注解，则会抛出一个运行时异常

参数：: obj - 要被删除的对象

deleteWith

int deleteWith(java.lang.Object obj,
               java.lang.String regex)

将对象删除的同时，也将符合一个正则表达式的所有关联字段关联的对象统统删除

注意：

Java 对象的字段会被保留，这里的删除，将只会删除数据库中的记录

关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被删除
返回：: 被影响的记录行数
另请参见：: One, Many, ManyMany

deleteLinks

int deleteLinks(java.lang.Object obj,
                java.lang.String regex)

根据一个正则表达式，仅删除对象所有的关联字段，并不包括对象本身。

注意：

Java 对象的字段会被保留，这里的删除，将只会删除数据库中的记录

关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被删除
返回：: 被影响的记录行数
另请参见：: One, Many, ManyMany

fetch

<T> T fetch(java.lang.Class<T> classOfT,
            long id)

根据对象 ID 获取一个对象。它只会获取这个对象，关联对象不会被获取。

你的对象必须在某个字段声明了注解 '@Id'，否则本操作会抛出一个运行时异常

参数：: classOfT - 对象类型; id - 对象 ID
另请参见：: Id

fetch

<T> T fetch(java.lang.Class<T> classOfT,
            java.lang.String name)

根据对象 Name 获取一个对象。它只会获取这个对象，关联对象不会被获取。

你的对象必须在某个字段声明了注解 '@Name'，否则本操作会抛出一个运行时异常

参数：: classOfT - 对象类型; name - 对象 Name
返回：: 对象本身
另请参见：: Name

fetchx

<T> T fetchx(java.lang.Class<T> classOfT,
             java.lang.Object... pks)

根据复合主键，获取一个对象。该对象必须声明 '@PK'，并且，给定的参数顺序必须同 '@PK' 中声明的顺序一致，否则会产生不可预知的错误。

参数：: classOfT -; pks - 复合主键需要的参数，必须同 '@PK'中声明的顺序一致

fetch

<T> T fetch(java.lang.Class<T> classOfT,
            Condition cnd)

根据 WHERE 条件获取一个对象。如果有多个对象符合条件，将只获取 ResultSet 第一个记录

参数：: classOfT - 对象类型; cnd - WHERE 条件
返回：: 对象本身
另请参见：: Condition, Name

fetch

Record fetch(java.lang.String tableName,
             Condition cnd)

根据条件获取一个 Record 对象

参数：: tableName - 表名; cnd - 条件
返回：: Record 对象

fetch

<T> T fetch(java.lang.Class<T> classOfT)

随便获取一个对象。某些时候，你的数据表永远只有一条记录，这个操作就很适合你

参数：: classOfT - 对象类型
返回：: 对象本身

fetch

<T> T fetch(T obj)

根据一个参考对象自动判断如何获取一个对象。

如果声明了 '@Id' 则相当于 fetch(Class,long)
如果声明了 '@Name'，则相当于 fetch(Class,String)
如果声明了 '@PK'，则 fetchx(Class,Object ...)
如果没声明任何上面三个注解，则会抛出一个运行时异常

参数：: obj - 参考对象
返回：: 对象本身

fetchLinks

<T> T fetchLinks(T obj,
                 java.lang.String regex)

根据一个正则表达式，获取对象所有的关联字段

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被查询
返回：: 更新后的数据对象本身
另请参见：: One, Many, ManyMany

clear

int clear(java.lang.Class<?> classOfT,
          Condition cnd)

根据一个 WHERE 条件，清除一组对象。只包括对象本身，不包括关联字段

参数：: classOfT - 对象类型; cnd - 查询条件，如果为 null，则全部清除
返回：: 影响的行数

clear

int clear(java.lang.String tableName,
          Condition cnd)

根据一个 WHERE 条件，清除一组记录

参数：: tableName -; cnd -
返回：: 影响的行数

clear

int clear(java.lang.Class<?> classOfT)

清除对象所有的记录

参数：: classOfT - 对象类型
返回：: 影响的行数

clear

int clear(java.lang.String tableName)

清除数据表所有记录

参数：: tableName - 表名
返回：: 影响的行数

clearLinks

<T> T clearLinks(T obj,
                 java.lang.String regex)

根据正则表达式，清除对象的关联。

对于 '@One' 和 '@Many'，对应的记录将会删除
而 '@ManyMay' 对应的字段，只会清除关联表中的记录

参数：: obj - 数据对象; regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被清除
返回：: 数据对象本身

getEntity

<T> Entity<T> getEntity(java.lang.Class<T> classOfT)

参数：: classOfT - 对象类型
返回：: 实体描述

count

int count(java.lang.Class<?> classOfT,
          Condition cnd)

根据条件，计算某个对象在数据库中有多少条记录

参数：: classOfT - 对象类型; cnd - WHERE 条件
返回：: 数量

count

int count(java.lang.Class<?> classOfT)

计算某个对象在数据库中有多少条记录

参数：: classOfT - 对象类型
返回：: 数量

count

int count(java.lang.String tableName,
          Condition cnd)

根据条件，计算某个数据表或视图中有多少条记录

参数：: tableName - 表名; cnd - WHERE 条件
返回：: 数量

count

int count(java.lang.String tableName)

计算某个数据表或视图中有多少条记录

参数：: tableName - 表名
返回：: 数量

getMaxId

int getMaxId(java.lang.Class<?> classOfT)

获取某个对象，最大的 ID 值。这个对象必须声明了 '@Id'

参数：: classOfT -
返回：: 最大 ID 值

func

int func(java.lang.Class<?> classOfT,
         java.lang.String funcName,
         java.lang.String fieldName)

对某一个对象字段，进行计算。

参数：: classOfT - 对象类型; funcName - 计算函数名，请确保你的数据是支持这个函数的; fieldName - 对象 java 字段名
返回：: 计算结果

func

int func(java.lang.String tableName,
         java.lang.String funcName,
         java.lang.String colName)

对某一个数据表字段，进行计算。

参数：: tableName - 表名; funcName - 计算函数名，请确保你的数据是支持这个函数的; colName - 数据库字段名
返回：: 计算结果

func

int func(java.lang.Class<?> classOfT,
         java.lang.String funcName,
         java.lang.String fieldName,
         Condition cnd)

对某一个对象字段，进行计算。

参数：: classOfT - 对象类型; funcName - 计算函数名，请确保你的数据是支持这个函数的; fieldName - 对象 java 字段名; cnd - 过滤条件
返回：: 计算结果

func

int func(java.lang.String tableName,
         java.lang.String funcName,
         java.lang.String colName,
         Condition cnd)

对某一个数据表字段，进行计算。

参数：: tableName - 表名; funcName - 计算函数名，请确保你的数据是支持这个函数的; colName - 数据库字段名; cnd - 过滤条件
返回：: 计算结果

createPager

Pager createPager(int pageNumber,
                  int pageSize)

根据数据源的类型，创建一个翻页对象

参数：: pageNumber - 第几页，从 1 开始。; pageSize - 每页可以有多少条记录
返回：: 翻页对象

exists

boolean exists(java.lang.Class<?> classOfT)

参数：: classOfT - 对象类型
返回：: 该类型对象是否在数据库中存在数据表

exists

boolean exists(java.lang.String tableName)

参数：: tableName - 表名
返回：: 数据库中是否存在这张数据表

create

<T> Entity<T> create(java.lang.Class<T> classOfT,
                     boolean dropIfExists)

根据一个实体的配置信息为其创建一张表

参数：: classOfT - 实体类型; dropIfExists - 如果表存在是否强制移除
返回：: 实体对象

drop

boolean drop(java.lang.Class<?> classOfT)

如果一个实体的数据表存在，移除它

参数：: classOfT - 实体类型
返回：: 是否移除成功

drop

boolean drop(java.lang.String tableName)

如果一个数据表存在，移除它

参数：: tableName - 表名
返回：: 是否移除成功

概述

软件包

类

树

已过时

索引

帮助

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

org.nutz.dao 接口 Dao

meta

sqls

execute

run

getObject

insert

insert

insert

fastInsert

insertWith

insertLinks

insertRelation

update

update

updateIgnoreNull

update

update

updateWith

updateLinks

updateRelation

query

query

query

query

each

each

each

each

delete

delete

deletex

delete

deleteWith

deleteLinks

fetch

fetch

fetchx

fetch

fetch

fetch

fetch

fetchLinks

clear

clear

clear

clear

clearLinks

getEntity

count

count

count

count

getMaxId

func

func

func

func

createPager

exists

exists

create

drop

drop

org.nutz.dao
接口 Dao