/**
* 根据多个id 查询数据
*
* @param <T>
* @param ids 整形的id数组
* @param c 要查询的表信息
* @return List
*/
public <T> List<T> searchByIds(Class<T> c, int[] ids, String orderby) {
Entity<T> entity = dao.getEntity(c);
String id = entity.getIdField().getColumnName();
return dao.query(c, Cnd.where(id, "in", ids).desc(orderby), null);
}
/**
* 根据指定的字段模糊分页查询数据 记录总数
*
* @param <T>
* @param c 查询的表
* @param fieldName 字段名称
* @param value 模糊条件
* @param currentPage 当前页码
* @param pageSize 每页数据量
* @return List
*/
public <T> int searchByPageLike(Class<T> c, String fieldName, String value) {
Entity<T> entity = dao.getEntity(c);
String column = entity.getField(fieldName).getColumnName();
return dao.count(c, Cnd.where(column, "LIKE", "%" + value + "%"));
}
/**
* 根据多个id 查询数据条数
*
* @param <T>
* @param ids 要查询的id,多个用","（逗号）分隔
* @param c 要查询的表信息
* @return List
*/
public <T> int searchByIdsCount(Class<T> c, String ids, String orderby) {
Entity<T> entity = dao.getEntity(c);
String id = entity.getIdField().getColumnName();
String sql = " " + id + " in (" + ids + ") order by " + orderby + " desc";
return dao.count(c, Cnd.wrap(sql));
}
/**
* 根据多个id 查询数据
*
* @param <T>
* @param ids 要查询的id,多个用","（逗号）分隔
* @param c 要查询的表信息
* @return List
*/
public <T> List<T> searchByIds(Class<T> c, String ids, String orderby) {
Entity<T> entity = dao.getEntity(c);
String id = entity.getIdField().getColumnName();
String sql = " " + id + " in (" + ids + ") order by " + orderby + " desc";
return dao.query(c, Cnd.wrap(sql), null);
}
/**
* 根据某个条件分页查询数据
*
* @param <T>
* @param c 查询的表
* @param fieldName 匹配字段名
* @param value 匹配的值
* @param currentPage 当前页码
* @param pageSize 每页数据量
* @return List
*/
public <T> List<T> searchByPage(
Class<T> c, String fieldName, String value, int currentPage, int pageSize) {
Entity<T> entity = dao.getEntity(c);
String column = entity.getField(fieldName).getColumnName();
Pager pager = dao.createPager(currentPage, pageSize);
return dao.query(c, Cnd.where(column, "=", value), pager);
}
/**
* 根据多个id删除数据
*
* @param <T>
* @param c 要操作的表信息
* @param ids 要删除的id,多个用","（逗号）分隔
* @return true 成功,false 失败
*/
public <T> void deleteByIds(Class<T> c, String ids) {
Entity<T> entity = dao.getEntity(c);
String table = entity.getTableName();
String id = entity.getIdField().getColumnName();
Sql sql = Sqls.create("delete from " + table + " where " + id + " in(" + ids + ")");
dao.execute(sql);
}
/**
* 根据多个id 查询数据并且分页
*
* @param <T>
* @param ids 要查询的id,多个用","（逗号）分隔
* @param c 要查询的表信息
* @return List
*/
public <T> int searchByIdsCount(
Class<T> c, String ids, String orderby, int currentPage, int pageSize) {
// Pager pager = dao.createPager(currentPage, pageSize);
Entity<T> entity = dao.getEntity(c);
String id = entity.getIdField().getColumnName();
String sql = " " + id + " in (" + ids + ") order by " + orderby + " desc ";
return dao.query(c, Cnd.wrap(sql), null).size();
}
/**
* 检查分表中是否有字段变化 提示
*
* @param dao
* @param tableName
* @param clsType
*/
public static void checkTableColumn(Dao dao, Object tableName, final Class<?> clsType) {
final NutDao d = (NutDao) dao;
final JdbcExpert expert = d.getJdbcExpert();
ext(d, tableName)
.run(
new ConnCallback() {
public void invoke(Connection conn) throws Exception {
Entity<?> en = d.getEntity(clsType);
expert.setupEntityField(conn, en);
}
});
}
/**
* 根据用户ID查询出服务时数
*
* @return
*/
public double findTime(int uid) {
Sql sql =
Sqls.create(
"select sum(services_number) as w from t_personservices where uid="
+ uid
+ " and queren=1");
sql.setCallback(
new SqlCallback() {
public Object invoke(Connection arg0, ResultSet rs, Sql sql) throws SQLException {
Object o = new Object();
if (rs.next()) {
o = rs.getObject("w");
}
rs.close();
return o;
}
});
dao.execute(sql);
Object o = sql.getResult();
if (o != null) {
return Double.parseDouble(o.toString());
}
return 0;
}
/**
* 根据多个id 查询数据并且分页
*
* @param <T>
* @param ids 要查询的id,多个用","（逗号）分隔
* @param c 要查询的表信息
* @return List
*/
public <T> List<T> searchByIdsFenye(
Class<T> c, String ids, String orderby, int currentPage, int pageSize) {
// Pager pager = dao.createPager(currentPage, pageSize);
Entity<T> entity = dao.getEntity(c);
String id = entity.getIdField().getColumnName();
String sql =
" "
+ id
+ " in ("
+ ids
+ ") order by "
+ orderby
+ " desc limit "
+ (currentPage - 1) * pageSize
+ ", "
+ pageSize
+ "";
return dao.query(c, Cnd.wrap(sql), null);
}
/**
* 通过特定的sql查询出用户按服务时间大小倒叙排序的总条数
*
* @param str
* @return
*/
public int findSqlCount(String str, String table) {
Sql sql = Sqls.create("select count(*) from " + table + " where id in (" + str + ")");
sql.setCallback(
new SqlCallback() {
public Object invoke(Connection arg0, ResultSet rs, Sql sql) throws SQLException {
while (rs.next()) {
return rs.getInt(1);
}
return null;
}
});
dao.execute(sql);
return sql.getInt();
}
public <T> List<T> searchByConditionIdss(
Class<T> c, String column, String ids, String orderby, int curPage, int pagesize) {
String sql =
" "
+ column
+ " in ("
+ ids
+ ") order by "
+ orderby
+ " desc limit "
+ (curPage - 1) * pagesize
+ ", "
+ pagesize
+ "";
return dao.query(c, Cnd.wrap(sql), null);
}
/**
* 保存对象的多对多 关系
*
* @param <T>
* @param t
* @param fieldName
*/
public <T> T saveRelation(T t, String fieldName) {
return dao.insertRelation(t, fieldName);
}
/**
* 根据Id删除数据
*
* @param <T>
* @param id 持久化Id
* @return true 成功删除一条数据,false删除失败
*/
public <T> boolean delById(int id, Class<T> c) {
return dao.delete(c, id) == 1;
}
/**
* 根据ID查询一个对象
*
* @param <T>
* @param id 持久化Id
* @param c 要查询的表
* @return 查询到的对象
*/
public <T> T find(int id, Class<T> c) {
return dao.fetch(c, id);
}
public List<Record> query(String joinT, Condition condition) {
return dao.query(joinT, condition, null);
}
public void delete(String table, Condition condition) {
dao.clear(table, condition);
}
/**
* 对于 '@One' 和 '@Many'，对应的记录将会删除 而 '@ManyMay' 对应的字段，只会清除关联表中的记录
*
* @param <T>
* @param t
* @param fieldName
* @return
*/
public <T> T clearRelation(T t, String fieldName) {
return dao.clearLinks(t, fieldName);
}
/**
* 根据指定条件返回一个对象
*
* @param <T>
* @param fileName 匹配名称
* @param value 匹配值
* @return T
*/
public <T> T findByCondition(Class<T> c, String fileName, String value) {
return dao.fetch(c, Cnd.where(fileName, "=", value));
}
/** 根据Pojo生成数据字典,zdoc格式 */
public static StringBuilder dataDict(DataSource ds, String... packages) {
StringBuilder sb = new StringBuilder();
List<Class<?>> ks = new ArrayList<Class<?>>();
for (String packageName : packages) {
ks.addAll(Scans.me().scanPackage(packageName));
}
Iterator<Class<?>> it = ks.iterator();
while (it.hasNext()) {
Class<?> klass = it.next();
if (klass.getAnnotation(Table.class) == null) it.remove();
}
// log.infof("Found %d table class", ks.size());
JdbcExpert exp = Jdbcs.getExpert(ds);
NutDao dao = new NutDao(ds);
Method evalFieldType;
try {
evalFieldType = exp.getClass().getDeclaredMethod("evalFieldType", MappingField.class);
} catch (Throwable e) {
throw Lang.wrapThrow(e);
}
evalFieldType.setAccessible(true);
Entity<?> entity = null;
String line = "-------------------------------------------------------------------\n";
sb.append("#title:数据字典\n");
sb.append("#author:wendal\n");
sb.append("#index:0,1\n").append(line);
for (Class<?> klass : ks) {
sb.append(line);
entity = dao.getEntity(klass);
sb.append("表名 ").append(entity.getTableName()).append("\n\n");
if (!Strings.isBlank(entity.getTableComment()))
sb.append("表注释: ").append(entity.getTableComment());
sb.append("\t").append("Java类名 ").append(klass.getName()).append("\n\n");
sb.append("\t||序号||列名||数据类型||主键||非空||默认值||java属性名||java类型||注释||\n");
int index = 1;
for (MappingField field : entity.getMappingFields()) {
String dataType;
try {
dataType = (String) evalFieldType.invoke(exp, field);
} catch (Throwable e) {
throw Lang.wrapThrow(e); // 不可能发生的
}
sb.append("\t||")
.append(index++)
.append("||")
.append(field.getColumnName())
.append("||")
.append(dataType)
.append("||")
.append(field.isPk())
.append("||")
.append(field.isNotNull())
.append("||")
.append(field.getDefaultValue(null) == null ? " " : field.getDefaultValue(null))
.append("||")
.append(field.getName())
.append("||")
.append(field.getTypeClass().getName())
.append("||")
.append(field.getColumnComment() == null ? " " : field.getColumnComment())
.append("||\n");
}
}
return sb;
}
/**
* 根据ID查询一个对象
*
* @param <T>
* @param id 持久化Id
* @param c 要查询的表
* @return 查询到的对象
*/
public <T> T find(int id, Class<T> c, String feild) {
T t = dao.fetch(c, id);
dao.fetchLinks(t, feild);
return t;
}
/**
* 删除关联的对象，不删除自身
*
* @param <T>
* @param t 删除的条件
* @param fieldName 删除的关联对象
*/
public <T> void deleteLink(T t, String fieldName) {
dao.deleteLinks(t, fieldName);
}
/**
* 仅修改关联的对象的数据
*
* @param <T>
* @param t 查询条件
* @param fieldName 修改的对象
* @return T
*/
public <T> T updateLink(T t, String fieldName) {
return dao.updateLinks(t, fieldName);
}
/**
* 更新自身和关联的对象
*
* @param <T>
* @param t 修改的对象
* @param fieldName 关联对象
* @return T
*/
public <T> T updateWidth(T t, String fieldName) {
return dao.updateWith(t, fieldName);
}
/**
* 获取关联对象
*
* @param <T>
* @param t 查询的对象
* @param fieldName 关联的对象
* @return T
*/
public <T> T findLink(T t, String fieldName) {
return dao.fetchLinks(t, fieldName);
}
/**
* 添加一条数据到数据库中， 该数据包括关联的多个其他数据
*
* @param <T>
* @param t 插入数据库的对象
* @param fieldName 关联数据的字段名，一般为List对象
* @return T
*/
public <T> T saveWidth(T t, String fieldName) {
return dao.insertWith(t, fieldName);
}
/**
* 查询数据库中的全部数据
*
* @param <T>
* @param c 查询的表
* @param orderby desc 排序的条件
* @return List
*/
public <T> List<T> search(Class<T> c, String orderby) {
return dao.query(c, Cnd.orderBy().desc(orderby), null);
}
/**
* 保存对象的关联关系,不保存对象本身
*
* @param <T>
* @param t
* @param fieldName
* @return
*/
public <T> T saveLink(T t, String fieldName) {
return dao.insertLinks(t, fieldName);
}
/**
* 删除自身和关联对象
*
* @param <T>
* @param t 删除的对象
* @param fieldName 关联的对象
*/
public <T> void deleteWidth(T t, String fieldName) {
dao.deleteWith(t, fieldName);
}
/**
* 更新对象的多对多关系
*
* @param <T>
* @param c 更新的对象的类
* @param fieldName 更新的字段名称
* @param chain 更新的内容
* @param condition 更新的条件
* @return true 成功,false 失败
*/
public <T> boolean updateRelation(
Class<T> c, String fieldName, Chain chain, Condition condition) {
return dao.updateRelation(c, fieldName, chain, condition) > 0;
}