org.nutz.dao.impl

类 NutDao

java.lang.Object

org.nutz.dao.impl.DaoSupport

org.nutz.dao.impl.NutDao

所有已实现的接口:

Dao

直接已知子类:

NutTxDao

public class NutDao
extends DaoSupport
implements Dao

字段概要

从类继承的字段 org.nutz.dao.impl.DaoSupport

_interceptors, autoTransLevel, dataSource, executor, expert, holder, meta, pojoMaker, runner, sqlManager

构造器概要

构造器

构造器和说明
NutDao()
NutDao(DataSource dataSource)
NutDao(DataSource dataSource, EntityMaker maker)
NutDao(DataSource dataSource, SqlManager sqlManager)

方法概要

限定符和类型	方法和说明
protected Object	_fetchLinks(Object t, String regex, boolean visitOne, boolean visitMany, boolean visitManyMany, Condition cnd)
int	clear(Class<?> classOfT) 清除对象所有的记录
int	clear(Class<?> classOfT, Condition cnd) 根据一个 WHERE 条件，清除一组对象。
int	clear(String tableName) 清除数据表所有记录
int	clear(String tableName, Condition cnd) 根据一个 WHERE 条件，清除一组记录
<T> T	clearLinks(T obj, String regex) 根据正则表达式，清除对象的关联。
int	count(Class<?> classOfT) 计算某个对象在数据库中有多少条记录
int	count(Class<?> classOfT, Condition cnd) 根据条件，计算某个对象在数据库中有多少条记录
int	count(String tableName) 计算某个数据表或视图中有多少条记录
int	count(String tableName, Condition cnd) 根据条件，计算某个数据表或视图中有多少条记录
<T> Entity<T>	create(Class<T> classOfT, boolean dropIfExists) 根据一个实体的配置信息为其创建一张表
Pager	createPager(int pageNumber, int pageSize) 根据数据源的类型，创建一个翻页对象
int	delete(Class<?> classOfT, long id) 根据对象 ID 删除一个对象。
int	delete(Class<?> classOfT, String name) 根据对象 Name 删除一个对象。
int	delete(Object obj) 自动判断如何删除一个对象。
int	deleteLinks(Object obj, String regex) 根据一个正则表达式，仅删除对象所有的关联字段，并不包括对象本身。
int	deleteWith(Object obj, String regex) 将对象删除的同时，也将符合一个正则表达式的所有关联字段关联的对象统统删除 注意： Java 对象的字段会被保留，这里的删除，将只会删除数据库中的记录 关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述
<T> int	deletex(Class<T> classOfT, Object... pks) 根据复合主键，删除一个对象。
boolean	drop(Class<?> classOfT) 如果一个实体的数据表存在，移除它
boolean	drop(String tableName) 如果一个数据表存在，移除它
<T> int	each(Class<T> classOfT, Condition cnd, Each<T> callback) 对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
<T> int	each(Class<T> classOfT, Condition cnd, Pager pager, Each<T> callback) 对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
int	each(String tableName, Condition cnd, Each<Record> callback) 对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
int	each(String tableName, Condition cnd, Pager pager, Each<Record> callback) 对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
int	each(String tableName, Condition cnd, Pager pager, Each<Record> callback, String fields) 对一组对象进行迭代，这个接口函数非常适用于很大的数据量的集合，因为你不可能把他们都读到内存里
Sql	execute(Sql sql) 执行单条自定义SQL
boolean	exists(Class<?> classOfT)
boolean	exists(String tableName)
<T> T	fastInsert(T obj) 快速插入一个对象。
<T> T	fetch(Class<T> classOfT) 随便获取一个对象。
<T> T	fetch(Class<T> classOfT, Condition cnd) 根据 WHERE 条件获取一个对象。
<T> T	fetch(Class<T> classOfT, long id) 根据对象 ID 获取一个对象。
<T> T	fetch(Class<T> classOfT, String name) 根据对象 Name 获取一个对象。
Record	fetch(String tableName, Condition cnd) 根据条件获取一个 Record 对象
Record	fetch(String tableName, Condition cnd, String fields)
<T> T	fetch(T obj) 根据一个参考对象自动判断如何获取一个对象。
<T> T	fetchByJoin(Class<T> classOfT, String regex, Condition cnd) 根据查询条件获取一个对象.
<T> T	fetchByJoin(Class<T> klass, String regex, Entity<T> en, MappingField mf, Object value)
<T> T	fetchByJoin(Class<T> klass, String regex, long id) 根据对象 ID 获取一个对象。
<T> T	fetchByJoin(Class<T> klass, String regex, String name) 根据对象 NAME 获取一个对象。
<T> T	fetchLinks(T obj, String regex) 根据一个正则表达式，获取对象所有的关联字段
<T> T	fetchLinks(T obj, String regex, Condition cnd) 根据一个正则表达式，获取对象所有的关联字段, 并按Condition进行数据过滤排序 严重提醒,当使用Condition进行数据过滤排序时,应当使regex只匹配特定的映射字段
<T> T	fetchx(Class<T> classOfT, Object... pks) 根据复合主键，获取一个对象。
int	func(Class<?> classOfT, String funcName, String fieldName) 对某一个对象字段，进行计算。
int	func(Class<?> classOfT, String funcName, String colName, Condition cnd) 对某一个对象字段，进行计算。
int	func(String tableName, String funcName, String colName) 对某一个数据表字段，进行计算。
int	func(String tableName, String funcName, String colName, Condition cnd) 对某一个数据表字段，进行计算。
Object	func2(Class<?> classOfT, String func2Name, String fieldName) 对某一个对象字段，进行计算。
Object	func2(Class<?> classOfT, String func2Name, String colName, Condition cnd) 对某一个对象字段，进行计算。
Object	func2(String tableName, String func2Name, String colName) 对某一个数据表字段，进行计算。
Object	func2(String tableName, String func2Name, String colName, Condition cnd) 对某一个数据表字段，进行计算。
<T> Entity<T>	getEntity(Class<T> classOfT) 获取实体描述, 其中包含了Java Pojo<-->数据库的全部映射信息
int	getMaxId(Class<?> classOfT) 获取某个对象，最大的 ID 值。
<T> T	getObject(Class<T> classOfT, ResultSet rs, FieldMatcher fm) 从一个 ResultSet 中获取一个对象。
<T> T	getObject(Class<T> classOfT, ResultSet rs, FieldMatcher fm, String prefix)
void	insert(Class<?> classOfT, Chain chain) 与 insert(String tableName, Chain chain) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明
void	insert(String tableName, Chain chain) 自由的向一个数据表插入一条数据。
<T> T	insert(T obj) 将一个对象插入到一个数据源。
<T> T	insert(T t, boolean ignoreNull, boolean ignoreZero, boolean ignoreBlankStr) 以特殊规则执行insert
<T> T	insert(T obj, FieldFilter filter) 将一个对象按FieldFilter过滤后,插入到一个数据源。
<T> T	insertLinks(T obj, String regex) 根据一个正则表达式，仅将对象所有的关联字段插入到数据库中，并不包括对象本身
<T> T	insertOrUpdate(T t) 根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入
<T> T	insertOrUpdate(T t, FieldFilter insertFieldFilter, FieldFilter updateFieldFilter) 根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入
<T> T	insertRelation(T obj, String regex) 将对象的一个或者多个，多对多的关联信息，插入数据表
<T> T	insertWith(T obj, String regex) 将对象插入数据库同时，也将符合一个正则表达式的所有关联字段关联的对象统统插入相应的数据库 关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述
<T> List<T>	query(Class<T> classOfT, Condition cnd) 查询一组对象。
<T> List<T>	query(Class<T> classOfT, Condition cnd, Pager pager) 查询一组对象。
<T> List<T>	query(Class<T> classOfT, Condition cnd, Pager pager, FieldMatcher matcher)
<T> List<T>	query(Class<T> classOfT, Condition cnd, Pager pager, String regex)
List<Record>	query(String tableName, Condition cnd) 查询出一组记录。
List<Record>	query(String tableName, Condition cnd, Pager pager) 查询出一组记录。
List<Record>	query(String tableName, Condition cnd, Pager pager, String fields) 查询出一组记录。
<T> List<T>	queryByJoin(Class<T> classOfT, String regex, Condition cnd) 根据查询条件获取一个对象.
void	setExpert(Object obj) 设置数据库方言.
int	update(Class<?> classOfT, Chain chain, Condition cnd) 与 update(String tableName, Chain chain, Condition cnd) 一样，不过，数据表名，将取自 POJO 的数据表声明，请参看 '@Table' 注解的详细说明
int	update(Object obj) 更新一个对象。
int	update(Object obj, Condition cnd)
int	update(Object obj, FieldFilter fieldFilter)
int	update(Object obj, FieldFilter fieldFilter, Condition cnd)
int	update(Object obj, String actived) 更新对象一部分字段
int	update(Object obj, String actived, String locked, boolean ignoreNull) 更新对象一部分字段
int	update(String tableName, Chain chain, Condition cnd) 自由的更新多条数据
int	updateAndIncrIfMatch(Object obj, FieldFilter fieldFilter, String fieldName) 乐观锁, 以特定字段的值作为限制条件,更新对象,并自增该字段.
int	updateIgnoreNull(Object obj) 更新一个对象，并且忽略所有 null 字段。
<T> T	updateLinks(T obj, String regex) 根据一个正则表达式，仅更新对象所有的关联字段，并不包括对象本身
int	updateRelation(Class<?> classOfT, String regex, Chain chain, Condition cnd) 多对多关联是通过一个中间表将两条数据表记录关联起来。
<T> T	updateWith(T obj, String regex) 将对象更新的同时，也将符合一个正则表达式的所有关联字段关联的对象统统更新 关于关联字段更多信息，请参看 '@One' | '@Many' | '@ManyMany' 更多的描述
int	updateWithVersion(Object obj) 基于版本的更新，版本不一样无法更新到数据
int	updateWithVersion(Object obj, FieldFilter fieldFilter) 基于版本的更新，版本不一样无法更新到数据

从类继承的方法 org.nutz.dao.impl.DaoSupport

_exec, addInterceptor, createEntityMaker, execute, getDataSource, getJdbcExpert, makeInterceptor, meta, pojoMaker, run, setAutoTransLevel, setDataSource, setDataSource, setExecutor, setInterceptors, setPojoMaker, setRunner, setSqlManager, sqls

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

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 org.nutz.dao.Dao

execute, getJdbcExpert, meta, pojoMaker, run, sqls

构造器详细资料

NutDao

public NutDao()

NutDao

public NutDao(DataSource dataSource)

NutDao

public NutDao(DataSource dataSource,
              SqlManager sqlManager)

NutDao

public NutDao(DataSource dataSource,
              EntityMaker maker)

方法详细资料

getObject

public <T> T getObject(Class<T> classOfT,
                       ResultSet rs,
                       FieldMatcher fm)

从接口复制的说明: Dao

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

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

指定者:

getObject 在接口中 Dao

参数:

classOfT - 对象类型

rs - 结果集

fm - 字段过滤器

返回:

对象

getObject

public <T> T getObject(Class<T> classOfT,
                       ResultSet rs,
                       FieldMatcher fm,
                       String prefix)

指定者:

getObject 在接口中 Dao

insert

public <T> T insert(T obj)

从接口复制的说明: Dao

将一个对象插入到一个数据源。

声明了 '@Id'的字段会在插入数据库时被忽略，因为数据库会自动为其设值。如果想手动设置，请设置 '@Id(auto=false)'

插入之前，会检查声明了 '@Default(@SQL("SELECT ..."))' 的字段，预先执行 SQL 为字段设置。

插入之后，会检查声明了 '@Next(@SQL("SELECT ..."))' 的字段，通过执行 SQL 将值取回

如果你的字段仅仅声明了 '@Id(auto=true)'，没有声明 '@Next'，则认为你还是想取回插入后最新的 ID 值，因为 自动为你添加类似 @Next(@SQL("SELECT MAX(id) FROM tableName")) 的设置

指定者:

insert 在接口中 Dao

参数:

obj - 要被插入的对象

它可以是：

• 普通 POJO
• 集合
• 数组
• Map

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

返回:

插入后的对象

另请参阅:

Id, Default, Next

insert

public <T> T insert(T obj,
                    FieldFilter filter)

从接口复制的说明: Dao

将一个对象按FieldFilter过滤后,插入到一个数据源。

dao.insert(pet, FieldFilter.create(Pet.class, FieldMatcher.create(false)));

指定者:

insert 在接口中 Dao

参数:

obj - 要被插入的对象

filter - 字段过滤器, 其中FieldMatcher.isIgnoreId生效

返回:

插入后的对象

另请参阅:

Dao.insert(Object)

insert

public void insert(String tableName,
                   Chain chain)

从接口复制的说明: Dao

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

指定者:

insert 在接口中 Dao

参数:

tableName - 数据表名

chain - 数据名值链

insert

public void insert(Class<?> classOfT,
                   Chain chain)

从接口复制的说明: Dao

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

指定者:

insert 在接口中 Dao

参数:

classOfT - 实体类型

chain - 数据名值链

另请参阅:

Table

fastInsert

public <T> T fastInsert(T obj)

从接口复制的说明: Dao

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

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

指定者:

fastInsert 在接口中 Dao

参数:

obj - 要被插入的对象

它可以是：

• 普通 POJO
• 集合
• 数组
• Map

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

insertWith

public <T> T insertWith(T obj,
                        String regex)

从接口复制的说明: Dao

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

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

指定者:

insertWith 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被插入

返回:

数据对象本身

另请参阅:

One, Many, ManyMany

insertLinks

public <T> T insertLinks(T obj,
                         String regex)

从接口复制的说明: Dao

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

指定者:

insertLinks 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被插入

返回:

数据对象本身

另请参阅:

One, Many, ManyMany

insertRelation

public <T> T insertRelation(T obj,
                            String regex)

从接口复制的说明: Dao

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

指定者:

insertRelation 在接口中 Dao

参数:

obj - 对象

regex - 正则表达式，描述了那种多对多关联字段将被执行该操作

返回:

对象自身

另请参阅:

ManyMany

update

public int update(Object obj)

从接口复制的说明: Dao

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

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

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

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

指定者:

update 在接口中 Dao

参数:

obj - 要被更新的对象

它可以是：

• 普通 POJO
• 集合
• 数组
• Map

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

返回:

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

另请参阅:

FieldFilter

update

public int update(Object obj,
                  String actived)

从接口复制的说明: Dao

更新对象一部分字段

指定者:

update 在接口中 Dao

参数:

obj - 对象

actived - 正则表达式描述要被更新的字段

返回:

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

update

public int update(Object obj,
                  String actived,
                  String locked,
                  boolean ignoreNull)

从接口复制的说明: Dao

更新对象一部分字段

指定者:

update 在接口中 Dao

参数:

obj - 对象

actived - 正则表达式描述要被更新的字段

返回:

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

update

public int update(Object obj,
                  FieldFilter fieldFilter)

指定者:

update 在接口中 Dao

update

public int update(Object obj,
                  FieldFilter fieldFilter,
                  Condition cnd)

指定者:

update 在接口中 Dao

update

public int update(Object obj,
                  Condition cnd)

指定者:

update 在接口中 Dao

updateIgnoreNull

public int updateIgnoreNull(Object obj)

从接口复制的说明: Dao

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

注意: 基本数据类型都是不可能为null的,这些字段肯定会更新

指定者:

updateIgnoreNull 在接口中 Dao

参数:

obj - 要被更新的对象

它可以是：

• 普通 POJO
• 集合
• 数组
• Map

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

返回:

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

update

public int update(String tableName,
                  Chain chain,
                  Condition cnd)

从接口复制的说明: Dao

自由的更新多条数据

指定者:

update 在接口中 Dao

参数:

tableName - 数据表名

chain - 数据名值链。

cnd - WHERE 条件

返回:

有多少条记录被更新了

update

public int update(Class<?> classOfT,
                  Chain chain,
                  Condition cnd)

从接口复制的说明: Dao

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

指定者:

update 在接口中 Dao

参数:

classOfT - 实体类型

chain - 数据名值链

cnd - WHERE 条件

返回:

有多少条记录被更新了

另请参阅:

Table

updateWith

public <T> T updateWith(T obj,
                        String regex)

从接口复制的说明: Dao

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

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

指定者:

updateWith 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被更新

返回:

数据对象本身

另请参阅:

One, Many, ManyMany

updateLinks

public <T> T updateLinks(T obj,
                         String regex)

从接口复制的说明: Dao

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

指定者:

updateLinks 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被更新

返回:

数据对象本身

另请参阅:

One, Many, ManyMany

updateRelation

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

从接口复制的说明: Dao

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

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

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

指定者:

updateRelation 在接口中 Dao

参数:

classOfT - 对象类型

regex - 正则表达式，描述了那种多对多关联字段将被执行该操作

chain - 针对中间关联表的名值链。

cnd - 针对中间关联表的 WHERE 条件

返回:

共有多少条数据被更新

另请参阅:

ManyMany

delete

public int delete(Class<?> classOfT,
                  long id)

从接口复制的说明: Dao

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

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

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

指定者:

delete 在接口中 Dao

参数:

classOfT - 对象类型

id - 对象 ID

返回:

影响的行数

另请参阅:

Id

delete

public int delete(Class<?> classOfT,
                  String name)

从接口复制的说明: Dao

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

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

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

指定者:

delete 在接口中 Dao

参数:

classOfT - 对象类型

name - 对象 Name

返回:

影响的行数

另请参阅:

Name

deletex

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

从接口复制的说明: Dao

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

指定者:

deletex 在接口中 Dao

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

delete

public int delete(Object obj)

从接口复制的说明: Dao

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

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

指定者:

delete 在接口中 Dao

参数:

obj - 要被删除的对象

deleteWith

public int deleteWith(Object obj,
                      String regex)

从接口复制的说明: Dao

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

注意：

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

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

指定者:

deleteWith 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被删除

返回:

被影响的记录行数

另请参阅:

One, Many, ManyMany

deleteLinks

public int deleteLinks(Object obj,
                       String regex)

从接口复制的说明: Dao

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

注意：

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

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

指定者:

deleteLinks 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被删除

返回:

被影响的记录行数

另请参阅:

One, Many, ManyMany

query

public <T> List<T> query(Class<T> classOfT,
                         Condition cnd,
                         Pager pager)

从接口复制的说明: Dao

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

指定者:

query 在接口中 Dao

参数:

classOfT - 对象类型

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序

pager - 翻页信息。如果为 null，则一次全部返回. 不会使用cnd中的pager!!!

返回:

对象列表

query

public <T> List<T> query(Class<T> classOfT,
                         Condition cnd)

从接口复制的说明: Dao

查询一组对象。你可以为这次查询设定条件

指定者:

query 在接口中 Dao

参数:

classOfT - 对象类型

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序
只有在调用这个函数的时候， cnd.limit 才会生效

返回:

对象列表

each

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

从接口复制的说明: Dao

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

指定者:

each 在接口中 Dao

参数:

classOfT - 对象类型

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序

pager - 翻页信息。如果为 null，则一次全部返回

callback - 处理回调

返回:

一共迭代的数量

each

public <T> int each(Class<T> classOfT,
                    Condition cnd,
                    Each<T> callback)

从接口复制的说明: Dao

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

指定者:

each 在接口中 Dao

参数:

classOfT - 对象类型

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序

callback - 处理回调

返回:

一共迭代的数量

query

public List<Record> query(String tableName,
                          Condition cnd,
                          Pager pager)

从接口复制的说明: Dao

查询出一组记录。

指定者:

query 在接口中 Dao

参数:

tableName - 表名 - 格式为 tableName[:idName] 比如 ： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则 不能分页

cnd - 条件 - 请注意： 你传入的 Criteria 实现必须考虑到 没有 'Entity' 传入。即 toSql 函数的参数永远为 null。

pager - 翻页信息

返回:

Record 对象。实际上是一个 Map 的包裹类

另请参阅:

Condition

query

public List<Record> query(String tableName,
                          Condition cnd,
                          Pager pager,
                          String fields)

从接口复制的说明: Dao

查询出一组记录。

指定者:

query 在接口中 Dao

参数:

tableName - 表名 - 格式为 tableName[:idName] 比如 ： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则 不能分页

cnd - 条件 - 请注意： 你传入的 Criteria 实现必须考虑到 没有 'Entity' 传入。即 toSql 函数的参数永远为 null。

pager - 翻页信息

fields - 需要查询的列, 将直接拼入SQL中.由于不会提前探知表结构,所以这fields并非正则表达式,务必留意.

返回:

数据库记录

query

public List<Record> query(String tableName,
                          Condition cnd)

从接口复制的说明: Dao

查询出一组记录。

指定者:

query 在接口中 Dao

参数:

tableName - 表名 - 格式为 tableName[:idName] 比如 ： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则 不能分页

cnd - 条件 - 请注意： 你传入的 Criteria 实现必须考虑到 没有 'Entity' 传入。即 toSql 函数的参数永远为 null。

返回:

Record 对象。实际上是一个 Map 的包裹类

另请参阅:

Condition

each

public int each(String tableName,
                Condition cnd,
                Pager pager,
                Each<Record> callback,
                String fields)

从接口复制的说明: Dao

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

指定者:

each 在接口中 Dao

参数:

tableName - 表名 - 格式为 tableName[:idName] 比如 ： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则 不能分页

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序

callback - 处理回调

fields - 需要查询的列, 将直接拼入SQL中.由于不会提前探知表结构,所以这fields并非正则表达式,务必留意.

返回:

一共迭代的数量

each

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

从接口复制的说明: Dao

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

指定者:

each 在接口中 Dao

参数:

tableName - 表名 - 格式为 tableName[:idName] 比如 ： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则 不能分页

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序

pager - 翻页信息。如果为 null，则一次全部返回

callback - 处理回调

返回:

一共迭代的数量

each

public int each(String tableName,
                Condition cnd,
                Each<Record> callback)

从接口复制的说明: Dao

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

指定者:

each 在接口中 Dao

参数:

tableName - 表名 - 格式为 tableName[:idName] 比如 ： t_pet 或者 t_pet:id 尤其在 SqlServer2005 的环境下，需要用 t_pet:id 的形式来指明 ID 字段，否则 不能分页

cnd - WHERE 条件。如果为 null，将获取全部数据，顺序为数据库原生顺序

callback - 处理回调

返回:

一共迭代的数量

fetch

public <T> T fetch(Class<T> classOfT,
                   long id)

从接口复制的说明: Dao

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

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

指定者:

fetch 在接口中 Dao

参数:

classOfT - 对象类型

id - 对象 ID

另请参阅:

Id

fetch

public <T> T fetch(Class<T> classOfT,
                   String name)

从接口复制的说明: Dao

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

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

指定者:

fetch 在接口中 Dao

参数:

classOfT - 对象类型

name - 对象 Name

返回:

对象本身

另请参阅:

Name

fetchx

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

从接口复制的说明: Dao

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

指定者:

fetchx 在接口中 Dao

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

fetch

public <T> T fetch(Class<T> classOfT,
                   Condition cnd)

从接口复制的说明: Dao

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

指定者:

fetch 在接口中 Dao

参数:

classOfT - 对象类型

cnd - WHERE 条件

返回:

对象本身

另请参阅:

Condition, Name

fetch

public Record fetch(String tableName,
                    Condition cnd)

从接口复制的说明: Dao

根据条件获取一个 Record 对象

指定者:

fetch 在接口中 Dao

参数:

tableName - 表名

cnd - 条件

返回:

Record 对象

fetch

public Record fetch(String tableName,
                    Condition cnd,
                    String fields)

指定者:

fetch 在接口中 Dao

参数:

tableName - 表名

cnd - 条件

fields - 需要select的属性, 不可以是null!!!

返回:

Record 对象

fetch

public <T> T fetch(T obj)

从接口复制的说明: Dao

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

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

指定者:

fetch 在接口中 Dao

参数:

obj - 参考对象

返回:

对象本身

fetch

public <T> T fetch(Class<T> classOfT)

从接口复制的说明: Dao

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

指定者:

fetch 在接口中 Dao

参数:

classOfT - 对象类型

返回:

对象本身

fetchLinks

public <T> T fetchLinks(T obj,
                        String regex)

从接口复制的说明: Dao

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

指定者:

fetchLinks 在接口中 Dao

参数:

obj - 数据对象,不可以是Class啊!!!传对象或集合啊!!!

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被查询

返回:

更新后的数据对象本身

另请参阅:

One, Many, ManyMany

fetchLinks

public <T> T fetchLinks(T obj,
                        String regex,
                        Condition cnd)

从接口复制的说明: Dao

根据一个正则表达式，获取对象所有的关联字段, 并按Condition进行数据过滤排序

严重提醒,当使用Condition进行数据过滤排序时,应当使regex只匹配特定的映射字段

指定者:

fetchLinks 在接口中 Dao

参数:

obj - 数据对象,可以是普通对象或集合,但不是类

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被查询

cnd - 关联字段的过滤(排序,条件语句,分页等)

返回:

传入的数据对象

clear

public int clear(Class<?> classOfT,
                 Condition cnd)

从接口复制的说明: Dao

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

指定者:

clear 在接口中 Dao

参数:

classOfT - 对象类型

cnd - 查询条件，如果为 null，则全部清除

返回:

影响的行数

clear

public int clear(String tableName,
                 Condition cnd)

从接口复制的说明: Dao

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

指定者:

clear 在接口中 Dao

返回:

影响的行数

clear

public int clear(Class<?> classOfT)

从接口复制的说明: Dao

清除对象所有的记录

指定者:

clear 在接口中 Dao

参数:

classOfT - 对象类型

返回:

影响的行数

clear

public int clear(String tableName)

从接口复制的说明: Dao

清除数据表所有记录

指定者:

clear 在接口中 Dao

参数:

tableName - 表名

返回:

影响的行数

clearLinks

public <T> T clearLinks(T obj,
                        String regex)

从接口复制的说明: Dao

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

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

指定者:

clearLinks 在接口中 Dao

参数:

obj - 数据对象

regex - 正则表达式，描述了什么样的关联字段将被关注。如果为 null，则表示全部的关联字段都会被清除

返回:

数据对象本身

getEntity

public <T> Entity<T> getEntity(Class<T> classOfT)

从接口复制的说明: Dao

获取实体描述, 其中包含了Java Pojo<-->数据库的全部映射信息

指定者:

getEntity 在接口中 Dao

参数:

classOfT - 对象类型

返回:

实体描述

count

public int count(Class<?> classOfT,
                 Condition cnd)

从接口复制的说明: Dao

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

指定者:

count 在接口中 Dao

参数:

classOfT - 对象类型

cnd - WHERE 条件

返回:

数量

count

public int count(Class<?> classOfT)

从接口复制的说明: Dao

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

指定者:

count 在接口中 Dao

参数:

classOfT - 对象类型

返回:

数量

count

public int count(String tableName)

从接口复制的说明: Dao

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

指定者:

count 在接口中 Dao

参数:

tableName - 表名

返回:

数量

count

public int count(String tableName,
                 Condition cnd)

从接口复制的说明: Dao

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

指定者:

count 在接口中 Dao

参数:

tableName - 表名

cnd - WHERE 条件

返回:

数量

getMaxId

public int getMaxId(Class<?> classOfT)

从接口复制的说明: Dao

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

指定者:

getMaxId 在接口中 Dao

返回:

最大 ID 值

func

public int func(Class<?> classOfT,
                String funcName,
                String fieldName)

从接口复制的说明: Dao

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

指定者:

func 在接口中 Dao

参数:

classOfT - 对象类型

funcName - 计算函数名，请确保你的数据库是支持这个函数的

fieldName - 对象 java 字段名

返回:

计算结果

func

public int func(String tableName,
                String funcName,
                String colName)

从接口复制的说明: Dao

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

指定者:

func 在接口中 Dao

参数:

tableName - 表名

funcName - 计算函数名，请确保你的数据是支持库这个函数的

colName - 数据库字段名

返回:

计算结果

func

public int func(Class<?> classOfT,
                String funcName,
                String colName,
                Condition cnd)

从接口复制的说明: Dao

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

指定者:

func 在接口中 Dao

参数:

classOfT - 对象类型

funcName - 计算函数名，请确保你的数据库是支持这个函数的

colName - 对象 java 字段名

cnd - 过滤条件

返回:

计算结果

func

public int func(String tableName,
                String funcName,
                String colName,
                Condition cnd)

从接口复制的说明: Dao

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

指定者:

func 在接口中 Dao

参数:

tableName - 表名

funcName - 计算函数名，请确保你的数据库是支持这个函数的

colName - 数据库字段名

cnd - 过滤条件

返回:

计算结果

func2

public Object func2(Class<?> classOfT,
                    String func2Name,
                    String fieldName)

从接口复制的说明: Dao

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

指定者:

func2 在接口中 Dao

参数:

classOfT - 对象类型

func2Name - 计算函数名，请确保你的数据库是支持这个函数的

fieldName - 对象 java 字段名

返回:

计算结果

func2

public Object func2(String tableName,
                    String func2Name,
                    String colName)

从接口复制的说明: Dao

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

指定者:

func2 在接口中 Dao

参数:

tableName - 表名

func2Name - 计算函数名，请确保你的数据是支持库这个函数的

colName - 数据库字段名

返回:

计算结果

func2

public Object func2(Class<?> classOfT,
                    String func2Name,
                    String colName,
                    Condition cnd)

从接口复制的说明: Dao

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

指定者:

func2 在接口中 Dao

参数:

classOfT - 对象类型

func2Name - 计算函数名，请确保你的数据库是支持这个函数的

colName - 对象 java 字段名

cnd - 过滤条件

返回:

计算结果

func2

public Object func2(String tableName,
                    String func2Name,
                    String colName,
                    Condition cnd)

从接口复制的说明: Dao

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

指定者:

func2 在接口中 Dao

参数:

tableName - 表名

func2Name - 计算函数名，请确保你的数据库是支持这个函数的

colName - 数据库字段名

cnd - 过滤条件

返回:

计算结果

createPager

public Pager createPager(int pageNumber,
                         int pageSize)

从接口复制的说明: Dao

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

指定者:

createPager 在接口中 Dao

参数:

pageNumber - 第几页 ，从 1 开始。

pageSize - 每页可以有多少条记录

返回:

翻页对象

create

public <T> Entity<T> create(Class<T> classOfT,
                            boolean dropIfExists)

从接口复制的说明: Dao

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

指定者:

create 在接口中 Dao

参数:

classOfT - 实体类型

dropIfExists - 如果表存在是否强制移除

返回:

实体对象

drop

public boolean drop(Class<?> classOfT)

从接口复制的说明: Dao

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

指定者:

drop 在接口中 Dao

参数:

classOfT - 实体类型

返回:

是否移除成功

drop

public boolean drop(String tableName)

从接口复制的说明: Dao

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

指定者:

drop 在接口中 Dao

参数:

tableName - 表名

返回:

是否移除成功

exists

public boolean exists(Class<?> classOfT)

指定者:

exists 在接口中 Dao

参数:

classOfT - 对象类型

返回:

该类型对象是否在数据库中存在数据表

exists

public boolean exists(String tableName)

指定者:

exists 在接口中 Dao

参数:

tableName - 表名

返回:

数据库中是否存在这张数据表

setExpert

public void setExpert(Object obj)
               throws Exception

从接口复制的说明: Dao

设置数据库方言.

指定者:

setExpert 在接口中 Dao

参数:

obj - 可以是类名,JdbcExpert实例,或者数据库名称

抛出:

Exception - 类名不合法/不存在的时抛出异常

execute

public Sql execute(Sql sql)

从接口复制的说明: Dao

执行单条自定义SQL

指定者:

execute 在接口中 Dao

参数:

sql - 自定义SQL对象

返回:

传入的SQL对象,方便链式调用

insert

public <T> T insert(T t,
                    boolean ignoreNull,
                    boolean ignoreZero,
                    boolean ignoreBlankStr)

从接口复制的说明: Dao

以特殊规则执行insert

指定者:

insert 在接口中 Dao

参数:

t - 实例对象

ignoreNull - 忽略空值

ignoreZero - 忽略0值

ignoreBlankStr - 忽略空白字符串

返回:

传入的实例变量

query

public <T> List<T> query(Class<T> classOfT,
                         Condition cnd,
                         Pager pager,
                         FieldMatcher matcher)

指定者:

query 在接口中 Dao

query

public <T> List<T> query(Class<T> classOfT,
                         Condition cnd,
                         Pager pager,
                         String regex)

指定者:

query 在接口中 Dao

insertOrUpdate

public <T> T insertOrUpdate(T t)

从接口复制的说明: Dao

根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入

指定者:

insertOrUpdate 在接口中 Dao

参数:

t - 对象

返回:

原对象

insertOrUpdate

public <T> T insertOrUpdate(T t,
                            FieldFilter insertFieldFilter,
                            FieldFilter updateFieldFilter)

从接口复制的说明: Dao

根据对象的主键(@Id/@Name/@Pk)先查询, 如果存在就更新, 不存在就插入

指定者:

insertOrUpdate 在接口中 Dao

参数:

t - 对象

insertFieldFilter - 插入时的字段过滤, 可以是null

updateFieldFilter - 更新时的字段过滤,可以是null

返回:

原对象

updateAndIncrIfMatch

public int updateAndIncrIfMatch(Object obj,
                                FieldFilter fieldFilter,
                                String fieldName)

从接口复制的说明: Dao

乐观锁, 以特定字段的值作为限制条件,更新对象,并自增该字段.

执行的sql如下:

update t_user set age=30, city="广州", version=version+1 where name="wendal" and version=124;

指定者:

updateAndIncrIfMatch 在接口中 Dao

参数:

obj - 需要更新的对象, 必须带@Id/@Name/@Pk中的其中一种.

fieldFilter - 需要过滤的属性. 若设置了哪些字段不更新,那务必确保过滤掉fieldName的字段

fieldName - 参考字段的Java属性名.默认是"version",可以是任意数值字段

返回:

若更新成功,返回值大于0, 否则小于等于0

updateWithVersion

public int updateWithVersion(Object obj)

从接口复制的说明: Dao

基于版本的更新，版本不一样无法更新到数据

指定者:

updateWithVersion 在接口中 Dao

参数:

obj - 需要更新的对象, 必须有version属性

返回:

若更新成功,大于0, 否则小于0

updateWithVersion

public int updateWithVersion(Object obj,
                             FieldFilter fieldFilter)

从接口复制的说明: Dao

基于版本的更新，版本不一样无法更新到数据

指定者:

updateWithVersion 在接口中 Dao

参数:

obj - 需要更新的对象, 必须有version属性

fieldFilter - 需要过滤的字段设置

返回:

若更新成功,大于0, 否则小于0

fetchByJoin

public <T> T fetchByJoin(Class<T> klass,
                         String regex,
                         long id)

从接口复制的说明: Dao

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

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

这个方法是让@One关联的属性,通过left join一次性取出. 与fetch+fetchLinks是等价的

指定者:

fetchByJoin 在接口中 Dao

参数:

klass - 实体类

regex - 需要取出的关联属性,是正则表达式哦,匹配的是Java属性名

id - 对象id

返回:

实体

fetchByJoin

public <T> T fetchByJoin(Class<T> klass,
                         String regex,
                         String name)

从接口复制的说明: Dao

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

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

这个方法是让@One关联的属性,通过left join一次性取出. 与fetch+fetchLinks是等价的

指定者:

fetchByJoin 在接口中 Dao

参数:

klass - 实体类

regex - 需要取出的关联属性,是正则表达式哦,匹配的是Java属性名

name - 对象name

返回:

实体

fetchByJoin

public <T> T fetchByJoin(Class<T> klass,
                         String regex,
                         Entity<T> en,
                         MappingField mf,
                         Object value)

fetchByJoin

public <T> T fetchByJoin(Class<T> classOfT,
                         String regex,
                         Condition cnd)

从接口复制的说明: Dao

根据查询条件获取一个对象.注意: 条件语句需要加上表名!!!

这个方法是让@One关联的属性,通过left join一次性取出. 与fetch+fetchLinks是等价的

指定者:

fetchByJoin 在接口中 Dao

参数:

classOfT - 实体类

regex - 需要过滤的关联属性,可以是null,取出全部关联属性.

cnd - 查询条件,必须带表名!!!

返回:

实体对象,符合regex的关联属性也会取出

queryByJoin

public <T> List<T> queryByJoin(Class<T> classOfT,
                               String regex,
                               Condition cnd)

从接口复制的说明: Dao

根据查询条件获取一个对象.注意: 条件语句需要加上表名!!!

这个方法是让@One关联的属性,通过left join一次性取出. 与query+fetchLinks是等价的

指定者:

queryByJoin 在接口中 Dao

参数:

classOfT - 实体类

regex - 需要过滤的关联属性,可以是null,取出全部关联属性.

cnd - 查询条件,必须带表名!!!

返回:

实体对象的列表,符合regex的关联属性也会取出

_fetchLinks

protected Object _fetchLinks(Object t,
                             String regex,
                             boolean visitOne,
                             boolean visitMany,
                             boolean visitManyMany,
                             Condition cnd)