1. 前提
public class PmbfWorkCenter extends BaseEntity implements Serializable
{
private static final long serialVersionUID = 1L;
private String locationGid;
private PmbfLocation location;//[]冗余字段，用于查询
private String workCenterClassGid;
private PmbfWorkCenterClass workCenterClass;//[]冗余字段，用于查询
private String pid;
private String code;
private String name;
private String siteGid;
private PmbfSite site;//[]冗余字段，用于查询
private Integer classFlag; // 工作中心标识， 0:生产类工作中心，1:仓库类工作中心，2:线边库工作中心
private Integer isRun;
private Integer isCritical;
private Integer isOutsourcing;
private Integer isDecompose;
private String calendarGid;
private MbfCalendar calendar;//[]冗余字段，用于查询
private Integer cycleTime = 0;
private Integer protectQty;// 计划模块保护区
private Integer storeMode;// 仓库模块管理模式1:无货物，2:有货位，不需要上下架，3:有货位，需要上下架
public PmbfWorkCenter()
{
}
public PmbfWorkCenter(String gid)
{
super();
this.id = gid;
}
}
public class PmbfWorkCell extends BaseEntity implements Serializable
{
private static final long serialVersionUID = 1L;
private String workCenterGid;
private PmbfWorkCenter workCenter;//[]冗余字段，用于查询
private String workCellClassGid;
private PmbfWorkCellClass workCellClass;//[]冗余字段，用于查询
private String code;
private String name;
private String siteGid;
private PmbfSite site;//[]冗余字段，用于查询
private String defaultEquipGid;
private MbfEquipment defaultEquip;
private String calendarGid;
private MbfCalendar calendar;//[]冗余字段，用于查询
private Integer attibuteFlag; // 0——生产，1——仓储，2——生产/仓储，3——道口，4——上线工位
private Integer planCycleTime;
private Integer lastCycleTime;
private Integer setupTime;
public PmbfWorkCell()
{
}
public PmbfWorkCell(String gid)
{
super();
this.id = gid;
}
}
public class MbfWorkCellBO implements Serializable
{
private static final long serialVersionUID = -7180441653442587971L;
/** 工位表的信息MBF_WORK_CELL */
private String workCellGid; // 主鍵
private String workCellCode; // 工位編碼
private String workCellName; // 工位描述
private String state; // 工位状态
private String siteId; // 所属工厂
private Integer planCycleTime; //
private Integer lastCycleTime; //
private Integer attrFlag; //
private String externalCode; // 工位外部系统编码
private String workCenterGid; // 所属工作中心主键
private String workCenterCode;
private String workCenterName; // 所属工作中心名称，部分方法获取该属性
private String siteCode;// 工厂编码
private String siteName;// 工厂名称
public MbfWorkCellBO()
{
}
public MbfWorkCellBO(String gid,String code,String name,String workCenterCode,String workCenterName)
{
this.workCellGid = gid;
this.workCellCode = code;
this.workCellName = name;
this.workCenterGid = workCenterGid;
this.workCenterCode = workCenterCode;
this.workCenterName = workCenterName;
}
public MbfWorkCellBO(PmbfWorkCell cell)
{
this.workCellGid = cell.getId();
this.workCellCode = cell.getCode();
this.workCellName = cell.getName();
this.workCenterGid = cell.getWorkCenterGid();
this.workCenterCode=cell.getWorkCenter().getCode();
this.workCenterName=cell.getWorkCenter().getName();
this.attrFlag = cell.getAttibuteFlag();
}
}
2. 查询
2.1. Named Parameter and Position Parameter,命名参数与占位参数
我们查询的时候，一般用问号，或者命名参数作为占位符
区别是Position Parameter，可以直接在createQuery，findHql中根据参数的顺序决定赋值的顺序，也可以通过但通常直接用setParameter，有几个?，相应的需要有几个参数赋值
另一种则完全根据名称匹配，同一个命名参数可以在查询语句中多次出现，而只需要一次赋值
赋值时，既可以通过setParameter，也可以根据参数类型，直接setString，SetInteger，但通常直接用setParameter，如果是列表参数，直接用SetParameterList
String workCenterGid = ""; // **equal**
String code = ""; // **start with**
String hql1 = "from PmbfWorkCell a where a.code like ? and a.workCenterGid =? and a.isActive=0 and a.isDelete=0";
List<PmbfWorkCell> list1 = dao.createQuery(hql1, "%"+code, workCenterGid).list();
List<PmbfWorkCell> list2 = dao.createQuery(hql1).setParameter(0, "%"+code).setParameter(1, workCenterGid).list();
List<PmbfWorkCell> list3 = findHql(hql1, code, workCenterGid);
String hql2 = "from PmbfWorkCell a where a.code like :code and a.workCenterGid =:workCenterGid and a.isActive=0 and a.isDelete=0";
List<PmbfWorkCell> list4 = dao.createQuery(hql2).setParameter("code", "%"+code).setParameter("workCenterGid", workCenterGid).list();
2.2. 返回值类型
createQuery之后，如果返回多个结果，可以createQuery.list()，如果返回单一结果或者null，可以createQuery().uniqueResult()
通常我们的返回值是List泛型，但是根据select语句的不同，会得到不同的返回值类型，需要按照需要去写自己的select部分
如果我们需要返回BO，最直接的是通过第三，第四量种类型的语句完成，或者通过第五种，得到实体后遍历再去拼成需要的BO，但这几种方式都有自己的局限性
或者要求你有相应的构造函数，一旦需要增加一个字段，那么不仅仅要改变HQL语句，还需要修改BO的构造函数，或者会把所有的字段查询出来，而往往你并不需要那么多
比较高级点的写法是直接用第一种类型的语句，但是在结果返回的时候，通过ResultTransformer转换成我们小的BO类型
如果我们不想得到List
String hql1 = "select a.code,a.name,a.attibuteFlag,workCenter.code as workCenterCode,workCenter.name as workCenterName from PmbfWorkCell a left join a.workCenter as workCenter where a.isActive=0 and a.isDelete=0";
String hql2 = "select new map(a.code,a.name,a.attibuteFlag,a.workCenter.code as workCenterCode,a.workCenter.name as workCenterName) from PmbfWorkCell a where a.isActive=0 and a.isDelete=0";
String hql3 = "select new com.epichust.bo.unimax.MbfWorkCellBO(a.id,a.code,a.name,a.workCenterGid,workCenter.code as workCenterCode,workCenter.name as workCenterName from PmbfWorkCell a left join a.workCenter as workCenter where a.isActive=0 and a.isDelete=0";
String hql4 = "select new com.epichust.bo.unimax.MbfWorkCellBO(a) from PmbfWorkCell a where a.isActive=0 and a.isDelete=0";
String hql5 = "from PmbfWorkCell a where a.isActive=0 and a.isDelete=0";
String hql6 = "select a.code,a.name,a.attibuteFlag,workCenter.code as workCenterCode,workCenter.name as workCenterName from PmbfWorkCell a left join a.workCenter as workCenter where a.isActive=0 and a.isDelete=0";
List<MbfWorkCellBO> list6 =dao.createQuery(hql6).setResultTransformer(Transformers.aliasToBean(MbfWorkCellBO.class)).list()
String hql7 = "select site.id,site.name from PmbfSite site where site.isDelete=0";
Map<String, String> map = (Map<String, String>) this.createQuery(hql7).setResultTransformer(new MapResultTransformer<String, String>()).uniqueResult();
list1------->List<Object[]>
list2------->List<Map<String,Object>>
list3------->List<MbfWorkCellBO>
list4------->List<MbfWorkCellBO>
list5------->List<PmbfWorkCell>
2.3. SQL查询
通过DAO，不能直接进行SQL查询，必须dao.getCurrentSession().createSQLQuery(sql)，得到SQLQuery对象后，才能像Query对象一样进行后面的赋值等操作
但是通过SQL的查询，如果想得到BO的返回值，需要对执行的结果addScalar，转换为对应的字段，如果类型不匹配，还需要在addScalar时，指定对应的字段类型
String sql = "select s.code as siteCode,s.name as siteName,center.code as workCenterCode,center.name as workCenterName,wc.work_center_gid as workCenterGid,wc.gid as workCellGid,wc.code as workCellCode,wc.name as workCellName,eq.gid as equipGid,eq.code as equipCode,eq.name as equipName from pmbf_work_cell wc "
+ " inner join pmbf_site s on wc.site_gid=s.gid"
+ " inner join pmbf_work_center center on wc.work_center_gid=center.gid"
+ " left join mbf_equipment eq on eq.work_cell_gid=wc.gid and eq.is_active=0 and eq.is_delete=0"
+ " where wc.attibute_flag = 0 and wc.is_active=0 and wc.is_delete=0"
+ " order by wc.site_gid,wc.work_center_gid,wc.code ";
List<MbfWorkCellBO> mbclist = getCurrentSession().createSQLQuery(sql)
.addScalar("siteCode")
.addScalar("siteName")
.addScalar("workCenterCode")
.addScalar("workCenterName")
.addScalar("workCenterGid")
.addScalar("workCellGid")
.addScalar("workCellCode")
.addScalar("workCellName")
.addScalar("equipGid")
.addScalar("equipCode")
.addScalar("equipName")
.setResultTransformer(Transformers.aliasToBean(MbfWorkCellBO.class)).list();
List<Object[]> list = getCurrentSession().createSQLQuery(sql).list();
SQL查找中，另一个比较重要的问题是,ORACLE和MYSQL对SQL语句大小写处理的不同
这种情况下，为了兼容两种数据库，比较简便的做法是直接对select返回结果全部用大写，可以参考ReportForPlanOrderMakingService
对平台的查询比较熟悉后，可以了解这部分内容，如果不甚了解，可以直接pass
String queryRecordSql = "select code,name from pmbf_work_center";
String queryCountSql = "select count(*) from pmbf_work_center";
selectData.setQueryLang(SelectData.QUERY_LANGUAGE_SQL);//设置使用原始查询SQL
selectData.setSelectRecordsQueryString(queryRecordSql);
selectData.setSelectCountQueryString(queryCountSql);
IReturnData returnData = this.selectService.process(selectData);
GridDataMode gridData = (GridDataMode) returnData.getData();
List<Map<String,Object>> list = gridData.getRows();
以上的查询，在不同数据库下的结果分别为
ORACLE
[{NAME=1号车间, CODE=010101}, {NAME=A线, CODE=010101A}, {NAME=B线, CODE=010101B}]
MYSQL
[{name=1号车间, code=010101}, {name=A线, code=010101A}, {name=B线, code=010101B}]
2.4. HQL执行update,delete操作
通过createSQLQuery或者createQuery，得到SQLQuery或者Query对象后，执行executeUpdate
String sql = "update mbf_equipment set work_cell_gid =?, site_gid =? where gid =? and is_active =0 and is_delete =0";
dao.getCurrentSession().createSQLQuery(sql).setParameter(0, workCellId)
.setParameter(1, siteGid)
.setParameter(2, equipId)
.executeUpdate();
String sql = " delete from PmbfWorkCenterGroup a ";
dao.createQuery(sql.toString()).executeUpdate();
2.5. 查询结果限定
查询结果的限制条件，可以通过设置如下的属性，来设置查询的批量，以及返回的最大结果
setMaxResults：返回结果的条数
setFetchSize：数据库执行的分批数，与返回结果没有关系
query.setResultTransformer(transformer)
.setFetchSize(fetchSize)
.setFirstResult(firstResult)
.setMaxResults(maxResults)
Java代码：
createQuery(hql).setFirstResult(10).setMaxResults(15)
执行的SQL：
select * from ( select row_.*, rownum rownum_ from ( select * from pmbf_work_cell pmbfworkce0_ where pmbfworkce0_.is_delete=0 ) row_ where rownum <= 25) where rownum_ > 10
Java代码：
createQuery(hql).setFetchSize(50)
执行的SQL
from pmbf_work_cell pmbfworkce0_ where pmbfworkce0_.is_delete=0
2.6. 关联的实体，是否都要JOIN
关联实体的HQL查询，什么时候需要JOIN，什么时候不需要，下面的写法最后得到的SQL会有哪些不一样，可以先思考
前提需要熟悉SQL中的LEFT JOIN,RIGHT JOIN关联查询
String hql = "select mrl.id as groupMaterialGid,mrl.code as groupMaterialCode,mrl.name as groupMaterialName,mrl.specification as specification,mrl.model as model,mrl.breed as breed,mrl.chkBatch as chkBatch,mrl.mrlType as mrlType, mrl.mbbMrlClass.id as mrlClassGid,mrl.length as length,mrl.width as width,mrl.height as height from MbbBdMrl mrl where mrl.isActive=0 and mrl.isDelete=0 "
+ " and mrl.code=? )";
MbbMaterialBO mbo = (MbbMaterialBO) mbbGroupMaterialDao.createQuery(hql, materialCode).setResultTransformer(Transformers.aliasToBean(MbbMaterialBO.class))
.uniqueResult();
hql = "select mrl.id as groupMaterialGid,mrl.code as groupMaterialCode,mrl.name as groupMaterialName,mrl.specification as specification,mrl.model as model,mrl.breed as breed,mrl.chkBatch as chkBatch,mrl.mrlType as mrlType, mrl.mbbMrlClass.id as mrlClassGid,mrl.length as length,mrl.width as width,mrl.height as height,mrl.mbbMrlClass.code as optionalTypeGid from MbbBdMrl mrl where mrl.isActive=0 and mrl.isDelete=0 "
+ " and mrl.code=? )";
MbbMaterialBO mbo2 = (MbbMaterialBO) mbbGroupMaterialDao.createQuery(hql, materialCode).setResultTransformer(Transformers.aliasToBean(MbbMaterialBO.class))
.uniqueResult();
hql = "select mrl.id as groupMaterialGid,mrl.code as groupMaterialCode,mrl.name as groupMaterialName,mrl.specification as specification,mrl.model as model,mrl.breed as breed,mrl.chkBatch as chkBatch,mrl.mrlType as mrlType, t.id as mrlClassGid,mrl.length as length,mrl.width as width,mrl.height as height,t.code as optionalTypeGid from MbbBdMrl mrl left join mrl.mbbMrlClass as t where mrl.isActive=0 and mrl.isDelete=0 "
+ " and mrl.code=? )";
MbbMaterialBO mbo3 = (MbbMaterialBO) mbbGroupMaterialDao.createQuery(hql, materialCode).setResultTransformer(Transformers.aliasToBean(MbbMaterialBO.class))
.uniqueResult();
select mbbbdmrl0_.gid as col_0_0_, mbbbdmrl0_.code as col_1_0_, mbbbdmrl0_.name as col_2_0_, mbbbdmrl0_.specification as col_3_0_, mbbbdmrl0_.model as col_4_0_, mbbbdmrl0_.breed as col_5_0_, mbbbdmrl0_.chk_batch as col_6_0_, mbbbdmrl0_.mrl_type as col_7_0_, mbbbdmrl0_.mrl_class_gid as col_8_0_, mbbbdmrl0_.length as col_9_0_, mbbbdmrl0_.width as col_10_0_, mbbbdmrl0_.height as col_11_0_
from mbb_bd_mrl mbbbdmrl0_
where mbbbdmrl0_.is_active=0 and mbbbdmrl0_.is_delete=0 and mbbbdmrl0_.code='4001903U9080'
select mbbbdmrl0_.gid as col_0_0_, mbbbdmrl0_.code as col_1_0_, mbbbdmrl0_.name as col_2_0_, mbbbdmrl0_.specification as col_3_0_, mbbbdmrl0_.model as col_4_0_, mbbbdmrl0_.breed as col_5_0_, mbbbdmrl0_.chk_batch as col_6_0_, mbbbdmrl0_.mrl_type as col_7_0_, mbbbdmrl0_.mrl_class_gid as col_8_0_, mbbbdmrl0_.length as col_9_0_, mbbbdmrl0_.width as col_10_0_, mbbbdmrl0_.height as col_11_0_, mbbmrlclas1_.code as col_12_0_
from mbb_bd_mrl mbbbdmrl0_, mbb_mrl_class mbbmrlclas1_
where mbbbdmrl0_.mrl_class_gid=mbbmrlclas1_.gid and mbbbdmrl0_.is_active=0 and mbbbdmrl0_.is_delete=0 and mbbbdmrl0_.code='4001903U9080'
select mbbbdmrl0_.gid as col_0_0_, mbbbdmrl0_.code as col_1_0_, mbbbdmrl0_.name as col_2_0_, mbbbdmrl0_.specification as col_3_0_, mbbbdmrl0_.model as col_4_0_, mbbbdmrl0_.breed as col_5_0_, mbbbdmrl0_.chk_batch as col_6_0_, mbbbdmrl0_.mrl_type as col_7_0_, mbbmrlclas1_.gid as col_8_0_, mbbbdmrl0_.length as col_9_0_, mbbbdmrl0_.width as col_10_0_, mbbbdmrl0_.height as col_11_0_, mbbmrlclas1_.code as col_12_0_
from mbb_bd_mrl mbbbdmrl0_
left outer join mbb_mrl_class mbbmrlclas1_ on mbbbdmrl0_.mrl_class_gid=mbbmrlclas1_.gid
where mbbbdmrl0_.is_active=0 and mbbbdmrl0_.is_delete=0 and mbbbdmrl0_.code='4001903U9080'
2.7. 如何优雅的得到BO对象，效率
方式一 HQL直接查询出实体对象，然后遍历生成BO对象
缺点：如果实体存在多个关联对象，转换构建BO的时候，如果用到关联对象的属性，而关联对象的ID又不一样，那么会对每个关联对象去执行一下Proxy对象的取值，产生一个SQL执行
String hql = "from PmbfWorkCell a where a.isActive=0 and a.isDelete=0";
List<PmbfWorkCell> list = dao.createQuery(hql).list();
List<MbfWorkCellBO> res = new ArrayList<>();
for(PmbfWorkCell cell : list)
{
MbfWorkCellBO bo = new MbfWorkCellBO(cell);
res.add(bo);
}
方式二 HQL直接查询出BO对象
缺点：如果实体存在多个关联对象，转换构建BO的时候，如果用到关联对象的属性，而关联对象的ID又不一样，那么会对每个关联对象去执行一下Proxy对象的取值，产生一个SQL执行，更悲剧的是，对象自身执行了一个批量的查询，然后又会循环去根据ID再查询一下自身，最最不建议的方式
String hql = "select new com.epichust.bo.unimax.MbfWorkCellBO(a) from PmbfWorkCell a where a.isActive=0 and a.isDelete=0";
List<MbfWorkCellBO> res = dao.createQuery(hql).list();
方式三 HQL直接查询出属性，然后转换为BO对象
缺点：需要根据BO的属性进行查询，可以实现按需加载，但一旦BO的结构修改，需要改动的地方都会涉及到，不便于修改
String hql6 = "select a.code,a.name,a.attibuteFlag,workCenter.code as workCenterCode,workCenter.name as workCenterName from PmbfWorkCell a left join a.workCenter as workCenter where a.isActive=0 and a.isDelete=0";
List<MbfWorkCellBO> list6 =dao.createQuery(hql6).setResultTransformer(Transformers.aliasToBean(MbfWorkCellBO.class)).list()
方式四 HQL直接查询出实体对象，但是对lazy对象主动join fetch
最优的方式，通过一个SQL加载延迟对象
String hql = "from PmbfWorkCell a left join fetch a.workCenter as workCenter where a.isActive=0 and a.isDelete=0";
List<PmbfWorkCell> list = dao.createQuery(hql).list();
List<MbfWorkCellBO> res = new ArrayList<>();
for(PmbfWorkCell cell : list)
{
MbfWorkCellBO bo = new MbfWorkCellBO(cell);
res.add(bo);
}
2.8. 外键字段的保存
外键字段通过实体关联
外键字段通过实体关联，但实体注解为insertable = false, updatable = false
//采集工位
if(workCellId!=null && !"".equals(workCellId)){
PmbfWorkCell workCell = this.dao.get(PmbfWorkCell.class,workCellId);
record.setWorkCell(workCell);
track.setWorkCell(workCell);//更新派工单的工位信息
}
//采集人
if(acqEmpId!=null && !"".equals(acqEmpId)){//采集人
PmbbEmployee acqEmployee = this.dao.get(PmbbEmployee.class,acqEmpId);
record.setAcqEmployee(acqEmployee);
track.setAcqEmployee(acqEmployee);//更新派工单的采集人信息
}
//相比较上面，减少两次SQL查询，循环里面的话，可能减少更多
record.setAcqEmployee(new PmbbEmployee(acqEmpId));
record.setWorkCell(new PmbfWorkCell(workCellId));
2.9. 时间与时间戳
setParameter
setTimestamp
setTime
setDate
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "EFFECTIVE_DATE", length = 7)
public Date getEffectiveDate()
mbbruleset0_.effective_date > to_timestamp('11/15/2016 17:16:55.599', 'mm/dd/yyyy hh24:mi:ss.ff3')
mbbruleset0_.effective_date > to_timestamp('11/15/2016 17:16:55.599', 'mm/dd/yyyy hh24:mi:ss.ff3')
mbbruleset0_.effective_date > to_date('11/15/2016 17:16:55', 'mm/dd/yyyy hh24:mi:ss')
mbbruleset0_.effective_date > to_date('11/15/2016 17:16:55', 'mm/dd/yyyy hh24:mi:ss')
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "EFFECTIVE_DATE1")
public Date getEffectiveDate1()
mbbruleset0_.effective_date1 > to_timestamp('11/15/2016 17:21:30.645', 'mm/dd/yyyy hh24:mi:ss.ff3')
AND mbbruleset0_.effective_date1 > to_timestamp('11/15/2016 17:21:30.645', 'mm/dd/yyyy hh24:mi:ss.ff3')
AND mbbruleset0_.effective_date1 > to_date('11/15/2016 17:21:30', 'mm/dd/yyyy hh24:mi:ss')
AND mbbruleset0_.effective_date1 > to_date('11/15/2016 17:21:30', 'mm/dd/yyyy hh24:mi:ss')
@Temporal(TemporalType.DATE)
@Column(name = "EFFECTIVE_DATE2")
public Date getEffectiveDate2()
mbbruleset0_.effective_date2 > to_date('11/15/2016 17:23:31', 'mm/dd/yyyy hh24:mi:ss')
AND mbbruleset0_.effective_date2 > to_timestamp('11/15/2016 17:23:31.097', 'mm/dd/yyyy hh24:mi:ss.ff3')
AND mbbruleset0_.effective_date2 > to_date('11/15/2016 17:23:31', 'mm/dd/yyyy hh24:mi:ss')
AND mbbruleset0_.effective_date2 > to_date('11/15/2016 17:23:31', 'mm/dd/yyyy hh24:mi:ss')
@Temporal(TemporalType.TIME)
@Column(name = "EFFECTIVE_DATE3")
public Date getEffectiveDate3()
mbbruleset0_.effective_date3 > to_date('11/15/2016 17:25:26', 'mm/dd/yyyy hh24:mi:ss')
AND mbbruleset0_.effective_date3 > to_timestamp('11/15/2016 17:25:26.205', 'mm/dd/yyyy hh24:mi:ss.ff3')
AND mbbruleset0_.effective_date3 > to_date('11/15/2016 17:25:26', 'mm/dd/yyyy hh24:mi:ss')
AND mbbruleset0_.effective_date3 > to_date('11/15/2016 17:25:26', 'mm/dd/yyyy hh24:mi:ss')
数据库定义
EFFECTIVE_DATE N DATE N 生效日期
EFFECTIVE_DATE1 N DATE Y 生效日期
EFFECTIVE_DATE2 N DATE Y 生效日期
EFFECTIVE_DATE3 N DATE Y 生效日期
数据库赋值
EFFECTIVE_DATE 2016-11-15 17:31:19
EFFECTIVE_DATE1 2016-11-15 17:31:19
EFFECTIVE_DATE2 2016-11-15
EFFECTIVE_DATE3 1970-01-01 17:31:19
用to_date与to_timestamp的时间相差几十倍
SELECT to_char(uexptrackr0_.daq_date, 'hh24 MM-dd') AS col_0_0_,
SUM(uexptrackr0_.effective_qty) AS col_1_0_
FROM uex_daq_info uexptrackr0_,
pmbf_work_center pmbfworkce1_,
mbf_route_operation mbfrouteop2_
WHERE uexptrackr0_.work_center_gid = pmbfworkce1_.gid
AND uexptrackr0_.op_gid = mbfrouteop2_.gid
AND pmbfworkce1_.site_gid = '2c942a6a50c620400150c62b5814000a'
AND uexptrackr0_.is_delete = 0
AND mbfrouteop2_.begin_flag = 1
AND (uexptrackr0_.operate_type = 3 OR uexptrackr0_.operate_type = 4)
AND uexptrackr0_.daq_date <= to_timestamp('11/14/2016 17:00:00.000', 'mm/dd/yyyy hh24:mi:ss.ff3')
AND uexptrackr0_.daq_date >= to_timestamp('11/13/2016 17:00:00.000', 'mm/dd/yyyy hh24:mi:ss.ff3')
GROUP BY to_char(uexptrackr0_.daq_date, 'hh24 MM-dd')
扫一扫
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
