仿hibernate的Criteria 查询GHql

来源：互联网发布：软件的可靠性测试编辑：程序博客网时间：2024/06/05 19:22

仿hibernate的Criteria

package org.gingko.db.hql;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import org.gingko.db.dao.GKDao;
/**
* 用于创建查询hql
* @author administrator
*
*/
public class GHql {
private String[] selList;
private String[] selObj;
private List<HqlExp> selWhere;
private List<Object> obj;
private String order;
private String group;
private GKDao dao;
private Field[] f;
public String[] getSelList() {
return selList;
}
/**
* 设置查询列可以是聚合函数
* @param selList
* @return
*/
public GHql selList(String ... selList) {
for(int i=0;i<selList.length;i++){
if(selList[i].indexOf(".")==-1 ){
if( selList[i].indexOf("(")==-1)
selList[i] = "[0]."+selList[i];
else{
String[] s = selList[i].split("(");
selList[i] = s[0]+"([0]."+s[1];
}
}
}
this.selList = selList;
return this;
}
public String[] getSelObj() {
return selObj;
}
public GHql setSelObj(String ... selObj) {
this.selObj = selObj;
return this;
}
private GHql(){
obj = new ArrayList<Object> ();
this.selWhere = new ArrayList<HqlExp>();
}
/**
* 创建不查询结果的GHql 只着输出Hql用
* @param selObjs 带查询的对象
* @return
*/
public static GHql from(Class<?>... selObjs){
GHql h = new GHql();
h.selObj = new String[selObjs.length];
h.f = selObjs[0].getDeclaredFields();
for(int i=0;i<selObjs.length;i++) h.selObj[i] = selObjs[i].getSimpleName();
return h;
}
/**
* 创建带查询结果的GHql
* @param dao 查询dao
* @param selObjs 带查询的对象
* @return
*/
public static GHql from(GKDao dao,Class<?>... selObjs){
GHql h = new GHql();
h.selObj = new String[selObjs.length];
h.f = selObjs[0].getDeclaredFields();
for(int i=0;i<selObjs.length;i++) h.selObj[i] = selObjs[i].getSimpleName();
h.dao = dao;
return h;
}
private StringBuffer h;
/**
* 输出最终HQL
* @return
*/
public String outHql(){
h = new StringBuffer();
if(selList !=null && selList.length>0){
h.append("select ");
for(String li:selList) h.append(li+",");
h.setLength(h.length()-1);
}
h.append(" from ");
for(String obj : selObj ){
h.append(obj+" ");
h.append(obj.toLowerCase()+",");
}
h.setLength(h.length()-1);
if(selWhere !=null && selWhere.size()>0){
h.append(" where ");
for(HqlExp w:selWhere){
setWhere(w);
};
h.setLength(h.length()-4);
}
String hql = h.toString();
if(group!=null && group.trim().length()>0)
{
hql += " group by "+ group;
}
if(order!=null && order.trim().length()>0)
{
hql += " order by "+ order;
}
for(int i=0;i<this.selObj.length ;i++){
hql = hql.replace("["+i+"]", this.selObj[i].toLowerCase());
}
return hql;
}
/**
* 得到查询条件
* @param w
*/
private void setWhere(HqlExp w){
if(!w.isKH()){
h.append(w.getProName()+" ");
h.append(w.getEq()+" ");
if(!w.isIspro()){
if(!w.isHql()){
if(!w.isTv()){
h.append("?");
obj.add(w.getValue());
}else
{
h.append("? and ?");
obj.add(w.getValue());
obj.add(w.getValue1());
}
}
else{
if(!w.isHd())
{
GHql l = w.getHql();
h.append("(");
h.append(l.outHql());
h.append(")");
Object[] os = l.getObject();
for(Object o:os ) obj.add(o);
}else{
Object[] os = (Object[])w.getValue();
h.append("(");
for(Object o:os){
h.append("?,");
obj.add(o);
}
h.setLength(h.length()-1);
h.append(")");
}
}
}else
{
h.append(w.getProName1());
}
h.append(w.getLink());
}else{
if(w.getProName().equals("L"))
h.append(" ( ");
else{
h.setLength(h.length()-4);
h.append(" ) ");
h.append(w.getLink());
}
}
}
/**
* 获取查询条件的值
* @return
*/
public Object[] getObject(){
return obj.toArray();
}
/**
* 判断给定的字段是否是当前对象的属性
* @param fieldName 字段名称
* @return
*/
public boolean isObjField(String fieldName){
for(Field fs:f ){
if(fs.getName().equals(fieldName)) return true;
}
return false;
}
/**
* 得到当前对象的字段类型
* @param fieldName 字段名称
* @return
*/
public String getFieldType(String fieldName){
for(Field fs:f ){
if(fs.getName().equals(fieldName)) return fs.getType().getSimpleName();
}
return null;
}
/**
* 添加查询条件该条件和下一个查询条件用 and 连接
* @param hqlw
* @return
*/
public GHql add(HqlExp hqlw){
if(hqlw ==null )return this;
hqlw.setLink(" and ");
this.selWhere.add(hqlw);
return this;
}
/**
* 添加左括号
* @return
*/
public GHql L(){
HqlExp hqlw =Exp.L();
hqlw.setLink(" and ");
this.selWhere.add(hqlw);
return this;
}
/**
* 添加右括号
* @return
*/
public GHql R(){
HqlExp hqlw =Exp.R();
hqlw.setLink(" and ");
this.selWhere.add(hqlw);
return this;
}
/**
* 添加查询条件该条件和下一个查询条件用 or 连接
* @param hqlw
* @return
*/
public GHql or(HqlExp hqlw){
if(hqlw ==null )return this;
hqlw.setLink(" or ");
this.selWhere.add(hqlw);
return this;
}
/**
* 添加排序条件
* @param objName 排序对象
* @param proName 排序属性名
* @param asc 是否升序
* @return
*/
public GHql order(String objName,String proName,boolean asc){
if(order==null || order.trim().length()==0){
order = objName+"."+proName+" " +(asc?"asc":"desc");
}else
{
order += ","+ objName+"."+proName+" " +(asc?"asc":"desc");
}
return this;
}
/**
* 添加排序条件
* @param proName 排序属性名
* @param asc 是否升序
* @return
*/
public GHql order(String proName,boolean asc){
return order("[0]",proName,asc);
}
/**
* 添加排序条件
* @param index 对象索引
* @param proName 排序属性名
* @param asc 是否升序
* @return
*/
public GHql order(int index,String proName,boolean asc){
return order("["+index+"]",proName,asc);
}
/**
* 添加分组条件
* @param objName 分组对象
* @param proName 分组属性名
* @return
*/
public GHql group(String objName,String proName){
group = objName+"."+proName;
return this;
}
/**
* 添加分组条件
* @param proName 分组属性名
* @return
*/
public GHql group(String proName){
return group("[0]",proName);
}
/**
* 添加分组条件
* @param index 对象索引
* @param proName 分组属性名
* @return
*/
public GHql group(int index,String proName){
return group("["+index+"]",proName);
}
public static void main(String[] s){
}
public GKDao getDao() {
return dao;
}
public GHql setDao(GKDao dao) {
this.dao = dao;
return this;
}
/**
* 获取查询结果
* @return
*/
public List<?> find(){
dao.Hql = this.outHql();
return dao.find(this.getObject());
}
/**
* 带分页的查询结果
* @param pagesize
* @param startRow
* @return
*/
public List<?> find(int pagesize,int startRow){
dao.Hql = this.outHql();
return dao.find(pagesize,startRow,this.getObject());
}
/**
* 获取查询对象
* @return
*/
public Object get(){
dao.Hql = this.outHql();
return dao.get(this.getObject());
}
/**
* 获取去查询数
* @return
*/
public int count(){
if(this.selList==null || this.selList.length==0){
this.selList = new String[]{Exp.count()};
}
dao.countHql = this.outHql();
return dao.count(this.getObject());
}
/**
* 查询数据是否存在
* @return
*/
public boolean have(){
if(this.count()>0)return true;
return false;
}
/**
* 获取首行首列
* @return
*/
public Object executeScalar(){
dao.Hql = this.outHql();
return dao.executeScalar(this.getObject());
}
}

package org.gingko.db.hql;
public class Exp {
/**
* 默认表属性和值的比较
* @param eq 操作符
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp exp(String eq,String proName,Object value){
return exp_(0,proName,eq,value);
}
/**
* 指定表属性和值的比较
* @param eq 操作符
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp exp(String eq,String objName,String proName,Object value){
return exp_(objName,proName,eq,value);
}
/**
* 指定表属性和值的比较
* @param eq 操作符
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp exp(String eq,int index,String proName,Object value){
return exp_(index,proName,eq,value);
}
/**
* 默认表和指定表属性的比较
* @param eq 操作符
* @param proName 属性名
* @param objName1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp exp(String eq,String proName,String objName1, String proName1){
return exp_(0,proName,eq,objName1+"."+proName1);
}
/**
* 默认表和指定表属性的比较
* @param eq 操作符
* @param proName 属性名
* @param index1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp exp(String eq,String proName,int index1, String proName1){
return exp_(0,proName,eq,"["+index1+"]."+proName1);
}
/**
* 指定表和指定表属性的比较
* @param eq 操作符
* @param objName 表1
* @param proName 属性
* @param objName1 表2
* @param proName1 属性
* @return
*/
public static HqlExp exp(String eq,String objName,String proName,String objName1, String proName1){
return exp_(objName,proName,eq,objName1+"."+proName1);
}
/**
* 指定表和指定表属性的比较
* @param eq 操作符
* @param index 表1索引
* @param proName 属性
* @param index1 表2索引
* @param proName1 属性
* @return
*/
public static HqlExp exp(String eq,int index,String proName,int index1, String proName1){
return exp_(index,proName,eq,"["+index1+"]."+proName1);
}
private static HqlExp exp_(String objName,String proName,String eq,Object value){
return new HqlExp(objName+"."+proName,eq,value);
}
private static HqlExp exp_(int index,String proName,String eq,Object value){
return new HqlExp("["+index+"]."+proName,eq,value);
}
private static HqlExp exp_(int index,String proName,String eq,String proName1){
return new HqlExp("["+index+"]."+proName,eq,proName1);
}
/**
* 默认表属性和值的等于比较
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp eq(String proName,Object value){
return exp("=",proName,value);
}
/**
* 指定表属性和值的等于比较
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp eq(String objName,String proName,Object value){
return exp("=",objName,proName,value);
}
/**
* 指定表属性和值的等于比较
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp eq(int index,String proName,Object value){
return exp("=",index,proName,value);
}
/**
* 默认表和指定表属性的等于比较
* @param proName 属性名
* @param objName1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp eq(String proName,String objName1, String proName1){
return exp("=",proName,objName1,proName1);
}
/**
* 默认表和指定表属性的等于比较
* @param proName 属性名
* @param index1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp eq(String proName,int index1, String proName1){
return exp("=",proName,index1,proName1);
}
/**
* 指定表和指定表属性的等于比较
* @param objName 表1
* @param proName 属性
* @param objName1 表2
* @param proName1 属性
* @return
*/
public static HqlExp eq(String objName,String proName,String objName1, String proName1){
return exp("=",objName,proName,objName1,proName1);
}
/**
* 指定表和指定表属性的等于比较
* @param index 表1索引
* @param proName 属性
* @param index1 表2索引
* @param proName1 属性
* @return
*/
public static HqlExp eq(int index,String proName,int index1, String proName1){
return exp("=",index,proName,index1,proName1);
}
/**
* 默认表属性和值的大于比较
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp gt(String proName,Object value){
return exp(">",proName,value);
}
/**
* 指定表属性和值的大于比较
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp gt(String objName,String proName,Object value){
return exp(">",objName,proName,value);
}
/**
* 指定表属性和值的大于比较
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp gt(int index,String proName,Object value){
return exp(">",index,proName,value);
}
/**
* 默认表和指定表属性的大于比较
* @param proName 属性名
* @param objName1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp gt(String proName,String objName1, String proName1){
return exp(">",proName,objName1,proName1);
}
/**
* 默认表和指定表属性的大于比较
* @param proName 属性名
* @param index1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp gt(String proName,int index1, String proName1){
return exp(">",proName,index1,proName1);
}
/**
* 指定表和指定表属性的大于比较
* @param objName 表1
* @param proName 属性
* @param objName1 表2
* @param proName1 属性
* @return
*/
public static HqlExp gt(String objName,String proName,String objName1, String proName1){
return exp(">",objName,proName,objName1,proName1);
}
/**
* 指定表和指定表属性的大于比较
* @param index 表1索引
* @param proName 属性
* @param index1 表2索引
* @param proName1 属性
* @return
*/
public static HqlExp gt(int index,String proName,int index1, String proName1){
return exp(">",index,proName,index1,proName1);
}
/**
* 默认表属性和值的大于等于比较
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp ge(String proName,Object value){
return exp(">=",proName,value);
}
/**
* 指定表属性和值的大于等于比较
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp ge(String objName,String proName,Object value){
return exp(">=",objName,proName,value);
}
/**
* 指定表属性和值的大于等于比较
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp ge(int index,String proName,Object value){
return exp(">=",index,proName,value);
}
/**
* 默认表和指定表属性的大于等于比较
* @param proName 属性名
* @param objName1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp ge(String proName,String objName1, String proName1){
return exp(">=",proName,objName1,proName1);
}
/**
* 默认表和指定表属性的大于等于比较
* @param proName 属性名
* @param index1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp ge(String proName,int index1, String proName1){
return exp(">=",proName,index1,proName1);
}
/**
* 指定表和指定表属性的大于等于比较
* @param objName 表1
* @param proName 属性
* @param objName1 表2
* @param proName1 属性
* @return
*/
public static HqlExp ge(String objName,String proName,String objName1, String proName1){
return exp(">=",objName,proName,objName1,proName1);
}
/**
* 指定表和指定表属性的大于等于比较
* @param index 表1索引
* @param proName 属性
* @param index1 表2索引
* @param proName1 属性
* @return
*/
public static HqlExp ge(int index,String proName,int index1, String proName1){
return exp(">=",index,proName,index1,proName1);
}
/**
* 默认表属性和值的小于比较
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp lt(String proName,Object value){
return exp("<",proName,value);
}
/**
* 指定表属性和值的小于比较
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp lt(String objName,String proName,Object value){
return exp("<",objName,proName,value);
}
/**
* 指定表属性和值的小于比较
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp lt(int index,String proName,Object value){
return exp("<",index,proName,value);
}
/**
* 默认表和指定表属性的小于比较
* @param proName 属性名
* @param objName1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp lt(String proName,String objName1, String proName1){
return exp("<",proName,objName1,proName1);
}
/**
* 默认表和指定表属性的小于比较
* @param proName 属性名
* @param index1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp lt(String proName,int index1, String proName1){
return exp("<",proName,index1,proName1);
}
/**
* 指定表和指定表属性的小于比较
* @param objName 表1
* @param proName 属性
* @param objName1 表2
* @param proName1 属性
* @return
*/
public static HqlExp lt(String objName,String proName,String objName1, String proName1){
return exp("<",objName,proName,objName1,proName1);
}
/**
* 指定表和指定表属性的小于比较
* @param index 表1索引
* @param proName 属性
* @param index1 表2索引
* @param proName1 属性
* @return
*/
public static HqlExp lt(int index,String proName,int index1, String proName1){
return exp("<",index,proName,index1,proName1);
}
/**
* 默认表属性和值的小于等于比较
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp le(String proName,Object value){
return exp("<=",proName,value);
}
/**
* 指定表属性和值的小于等于比较
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp le(String objName,String proName,Object value){
return exp("<=",objName,proName,value);
}
/**
* 指定表属性和值的小于等于比较
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp le(int index,String proName,Object value){
return exp("<=",index,proName,value);
}
/**
* 默认表和指定表属性的小于等于比较
* @param proName 属性名
* @param objName1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp le(String proName,String objName1, String proName1){
return exp("<=",proName,objName1,proName1);
}
/**
* 默认表和指定表属性的小于等于比较
* @param proName 属性名
* @param index1 指定表
* @param proName1 属性名
* @return
*/
public static HqlExp le(String proName,int index1, String proName1){
return exp("<=",proName,index1,proName1);
}
/**
* 指定表和指定表属性的小于等于比较
* @param objName 表1
* @param proName 属性
* @param objName1 表2
* @param proName1 属性
* @return
*/
public static HqlExp le(String objName,String proName,String objName1, String proName1){
return exp("<=",objName,proName,objName1,proName1);
}
/**
* 指定表和指定表属性的小于等于比较
* @param index 表1索引
* @param proName 属性
* @param index1 表2索引
* @param proName1 属性
* @return
*/
public static HqlExp le(int index,String proName,int index1, String proName1){
return exp("<=",index,proName,index1,proName1);
}
/**
* 默认表属性和值的like比较
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp like(String proName,Object value){
return exp("like",proName,value);
}
/**
* 指定表属性和值的like比较
* @param objName 表名
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp like(String objName,String proName,Object value){
return exp("like",objName,proName,value);
}
/**
* 指定表属性和值的like比较
* @param index 表索引
* @param proName 属性名
* @param value 值
* @return
*/
public static HqlExp like(int index,String proName,Object value){
return exp("like",index,proName,value);
}
/**
* 添加右括号
* @return
*/
public static HqlExp R(){
return new HqlExp("R");
}
/**
* 添加左括号
* @return
*/
public static HqlExp L(){
return new HqlExp("L");
}
/**
* 默认表属性和指定GHql的in 包含关系
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp in(String proName,GHql hql){
return new HqlExp("[0]."+proName,"in",hql);
}
/**
* 指定表属性和指定GHql的in 包含关系
* @param objName 对象名
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp in(String objName,String proName,GHql hql){
return new HqlExp(objName+"."+proName,"in",hql);
}
/**
* 指定表属性和指定GHql的in 包含关系
* @param index 对象索引
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp in(int index,String proName,GHql hql){
return new HqlExp("["+index+"]."+proName,"in",hql);
}
/**
* 默认表属性和指定GHql的in 包含关系
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp in(String proName,Object[] values){
return new HqlExp("[0]."+proName,"in",values);
}
/**
* 指定表属性和指定GHql的in 包含关系
* @param objName 对象名
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp in(String objName,String proName,Object[] values){
return new HqlExp(objName+"."+proName,"in",values);
}
/**
* 指定表属性和指定GHql的in 包含关系
* @param index 对象索引
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp in(int index,String proName,Object[] values){
return new HqlExp("["+index+"]."+proName,"in",values);
}
/**
* 默认表属性和指定GHql的not in 包含关系
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp notin(String proName,GHql hql){
return new HqlExp("[0]."+proName,"not in",hql);
}
/**
* 指定表属性和指定GHql的not in 包含关系
* @param objName 对象名
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp notin(String objName,String proName,GHql hql){
return new HqlExp(objName+"."+proName,"not in",hql);
}
/**
* 指定表属性和指定GHql的not in 包含关系
* @param index 对象索引
* @param proName 属性名
* @param hql GHql
* @return
*/
public static HqlExp notin(int index,String proName,GHql hql){
return new HqlExp("["+index+"]."+proName,"not in",hql);
}
/**
* 默认表属性的 between 查询
* @param proName 属性名
* @param value 值1
* @param value1 值2
* @return
*/
public static HqlExp between(String proName ,Object value ,Object value1){
return new HqlExp("[0]."+proName,"between",value,value1);
}
/**
* 指定表属性的 between 查询
* @param objName 对象名
* @param proName 属性名
* @param value 值1
* @param value1 值2
* @return
*/
public static HqlExp between(String objName,String proName ,Object value ,Object value1){
return new HqlExp(objName+"."+proName,"between",value,value1);
}
/**
* 指定表属性的 between 查询
* @param index 对象索引
* @param proName 属性名
* @param value 值1
* @param value1 值2
* @return
*/
public static HqlExp between(int index,String proName ,Object value ,Object value1){
return new HqlExp("["+index+"]."+proName,"between",value,value1);
}
/**
* 用于执行聚合相关函数
* @param methodName 聚合函数名称
* @param proName 属性名
* @return
*/
public static String method(String methodName,String proName){
return methodName+"("+proName+")";
}
/**
* 求总数
* @return
*/
public static String count(){
return "count(*)";
}
/**
* 求总数
* @param proName 属性名
* @return
*/
public static String count(String proName){
return method("count",proName);
}
/**
* 求最大值
* @param proName
* @return
*/
public static String max(String proName){
return method("max",proName);
}
/**
* 求最小值
* @param proName
* @return
*/
public static String min(String proName){
return method("min",proName);
}
/**
* 求最和
* @param proName
* @return
*/
public static String sum(String proName){
return method("sum",proName);
}
}