package com.smtaiserver.smtaiserver.javaai.ast;
|
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
import org.apache.ibatis.ognl.Ognl;
|
|
import java.util.Map.Entry;
|
import java.util.Set;
|
import com.smtaiserver.smtaiserver.core.SMTAIServerApp;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecord;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecords;
|
import com.smtaiserver.smtaiserver.javaai.SMTJavaAIError;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTCubeRecs.ASTCubeRecsType;
|
import com.smtaiserver.smtaiserver.javaai.metrics.base.SMTDimensionDef;
|
import com.smtservlet.util.SMTStatic;
|
import com.smtservlet.util.SMTStatic.SMTCalcTime;
|
|
public class ASTCubeRecsValue
|
{
|
private enum GROUP_OP
|
{
|
MIN,
|
MAX,
|
AVG,
|
SUM,
|
COUNT
|
}
|
|
private enum GROUP_UNIT
|
{
|
NONE,
|
MINUTE,
|
MONTH,
|
}
|
|
private enum DIFF_OP
|
{
|
ADD,
|
SUB,
|
YOY
|
}
|
|
private static class TimeGroupInfo
|
{
|
public GROUP_OP _op;
|
public GROUP_UNIT _unit;
|
public int _step;
|
}
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
public String _countField;
|
public String _groupField;
|
public char _groupType;
|
public String _chartType = null;
|
public DBRecords _recsValue;
|
public String _title;
|
public ASTTimeRange _timeRange = null;
|
|
private static Date _baseTime = SMTStatic.toDate("1980-01-01");
|
|
public ASTCubeRecsValue cloneCubeRecsValue()
|
{
|
ASTCubeRecsValue newRecsValue = new ASTCubeRecsValue();
|
|
newRecsValue._countField = this._countField;
|
newRecsValue._groupField = this._groupField;
|
newRecsValue._groupType = this._groupType;
|
newRecsValue._chartType = this._chartType;
|
newRecsValue._title = this._title;
|
if(_timeRange != null)
|
newRecsValue._timeRange = _timeRange.cloneTimeRange();
|
|
newRecsValue._recsValue = new DBRecords();
|
newRecsValue._recsValue.initColumn(this._recsValue.getFieldMap());
|
for(DBRecord rec : _recsValue.getRecords())
|
{
|
newRecsValue._recsValue.addRecord(rec.getValues());
|
}
|
|
return newRecsValue;
|
}
|
|
public void distinctRecTime() throws Exception
|
{
|
if(_timeRange == null)
|
return;
|
|
List<DBRecord> recs = _recsValue.getRecords();
|
|
Set<Date> setExistTime = new HashSet<>();
|
for(int recIndex = recs.size() - 1; recIndex >= 0; recIndex --)
|
{
|
Date curTime = recs.get(recIndex).getDate(_timeRange._timeField);
|
if(setExistTime.contains(curTime))
|
{
|
recs.remove(recIndex);
|
continue;
|
}
|
else
|
{
|
setExistTime.add(curTime);
|
}
|
}
|
}
|
|
|
public void limitRecords(int limit)
|
{
|
_recsValue.limitRecord(limit);
|
}
|
|
private Object convGroupTypeValue(char groupType, Object value) throws Exception
|
{
|
if(value == null)
|
return null;
|
switch(groupType)
|
{
|
case 'D':
|
return SMTStatic.toDouble(value);
|
case 'S':
|
return SMTStatic.toString(value);
|
case 'L':
|
return SMTStatic.toLong(value);
|
case 'I':
|
return SMTStatic.toInt(value);
|
case 'T':
|
return SMTStatic.toDate(value);
|
|
default:
|
throw new Exception("can't convert to type : " + groupType);
|
}
|
}
|
|
private int compGroupTypeValue(char groupType, Object v1, Object v2) throws Exception
|
{
|
switch(groupType)
|
{
|
case 'I':
|
return Integer.compare(SMTStatic.toInt(v1), SMTStatic.toInt(v2));
|
case 'L':
|
return Long.compare(SMTStatic.toLong(v1), SMTStatic.toLong(v2));
|
case 'D':
|
return Double.compare(SMTStatic.toDouble(v1), SMTStatic.toDouble(v2));
|
case 'S':
|
return ((String)v1).compareTo((String)v2);
|
case 'T':
|
return ((Date)v1).compareTo((Date)v2);
|
|
default:
|
throw new Exception("can't convert to type : " + groupType);
|
}
|
}
|
|
private Date alignGroupTime(TimeGroupInfo timeGroupInfo, Date time)
|
{
|
if(timeGroupInfo._unit == GROUP_UNIT.NONE)
|
return _baseTime;
|
else if(timeGroupInfo._unit == GROUP_UNIT.MINUTE)
|
{
|
long minutes = (time.getTime() - _baseTime.getTime()) / 1000 / 60;
|
return new Date(_baseTime.getTime() + (minutes / timeGroupInfo._step) * timeGroupInfo._step * 1000 * 60);
|
}
|
else if(timeGroupInfo._unit == GROUP_UNIT.MONTH)
|
{
|
int subMonths = ((time.getYear() + 1900) * 12 + time.getMonth()) % timeGroupInfo._step;
|
return SMTStatic.calculateTime(time, SMTCalcTime.ZERO_TIME, 0, SMTCalcTime.SET_DATE, 1, SMTCalcTime.ADD_MONTH, - subMonths);
|
}
|
|
return null;
|
}
|
|
public SMTJavaAIError groupEvalValueRecords(ASTEvalColInfo evalColInfo, String sGroupOP, String sGroupStep, ASTCubeRecsType[] r_isSummary, String[][] r_colNames) throws Exception
|
{
|
if(_recsValue == null)
|
return null;
|
|
if(!SMTStatic.isNullOrEmpty(sGroupStep) && SMTStatic.isNullOrEmpty(_timeRange._timeField))
|
return new SMTJavaAIError("未指定时间字段无法聚合");
|
|
TimeGroupInfo timeGroupInfo = new TimeGroupInfo();
|
|
if(SMTStatic.isNullOrEmpty(sGroupStep))
|
{
|
timeGroupInfo._unit = GROUP_UNIT.NONE;
|
if(r_isSummary[0] != ASTCubeRecsType.RECORD)
|
r_isSummary[0] = ASTCubeRecsType.SUMMARY;
|
if(r_colNames != null && r_colNames[0] != null)
|
r_colNames[0] = new String[] {"值"};
|
}
|
else
|
{
|
int[] aTimeStep = SMTAIServerApp.convStrToTimeStep(sGroupStep);
|
if(aTimeStep == null)
|
return new SMTJavaAIError("无法辨认分组步长：" + sGroupStep);
|
|
timeGroupInfo._unit = aTimeStep[0] == 0 ? GROUP_UNIT.MINUTE : GROUP_UNIT.MONTH;
|
timeGroupInfo._step = aTimeStep[1];
|
|
if(SMTStatic.isNullOrEmpty(this._chartType) && (aTimeStep[0] == 1 || aTimeStep[1] >= 24 * 60))
|
{
|
this._chartType = "bar";
|
}
|
|
if(r_colNames != null && r_colNames[0] != null)
|
r_colNames[0] = new String[] {"时间", "值"};
|
|
}
|
|
TreeMap<Date, Map<String, Object>> mapTime2Recs = new TreeMap<>();
|
SMTJavaAIError errors[] = new SMTJavaAIError[1];
|
DBRecords[] recsGroups = new DBRecords[1];
|
|
if(_timeRange == null)
|
{
|
throw new Exception("_timeRange can't null");
|
}
|
else
|
{
|
for(DBRecord rec : _recsValue.getRecords())
|
{
|
// 初始化字段名
|
if(recsGroups[0] == null)
|
{
|
recsGroups[0] = new DBRecords();
|
|
if(r_isSummary[0] == ASTCubeRecsType.RECORD && timeGroupInfo._unit == GROUP_UNIT.NONE)
|
recsGroups[0].initColumn(new String[] {_groupField});
|
else
|
recsGroups[0].initColumn(new String[] {_timeRange._timeField, _groupField});
|
}
|
|
// 对齐时间
|
Date time = alignGroupTime(timeGroupInfo, rec.getDate(_timeRange._timeField));
|
|
for(SMTDimensionDef dimDef : evalColInfo._setDimDef)
|
{
|
char valueType = dimDef.getType();
|
|
// 获取原始值，忽略空值
|
Object curValue = convGroupTypeValue(valueType, rec.getValue(dimDef.getId()));
|
|
Map<String, Object> orgValueMap = mapTime2Recs.get(time);
|
if(orgValueMap == null)
|
{
|
orgValueMap = new HashMap<>();
|
mapTime2Recs.put(time, orgValueMap);
|
}
|
|
Object orgValue;
|
|
// 进行统计计算
|
orgValue = orgValueMap.get("min$" + dimDef.getId());
|
if(orgValue == null || compGroupTypeValue(valueType, orgValue, curValue) > 0)
|
orgValueMap.put("min$" + dimDef.getId(), SMTStatic.toDouble(curValue));
|
|
orgValue = orgValueMap.get("max$" + dimDef.getId());
|
if(orgValue == null || compGroupTypeValue(valueType, orgValue, curValue) < 0)
|
orgValueMap.put("max$" + dimDef.getId(), SMTStatic.toDouble(curValue));
|
|
orgValue = orgValueMap.get("count$" + dimDef.getId());
|
if(orgValue == null)
|
{
|
orgValueMap.put("count$" + dimDef.getId(), 1);
|
}
|
else
|
{
|
orgValueMap.put("count$" + dimDef.getId(), SMTStatic.toInt(orgValue) + 1);
|
}
|
|
orgValue = orgValueMap.get("sum$" + dimDef.getId());
|
if(orgValue == null)
|
orgValue = (double)0;
|
orgValueMap.put("sum$" + dimDef.getId(), SMTStatic.toDouble(orgValue) + SMTStatic.toDouble(curValue));
|
|
}
|
}
|
|
|
if(errors[0] != null)
|
return errors[0];
|
|
// 汇总成记录
|
for(Entry<Date, Map<String, Object>> entry : mapTime2Recs.entrySet())
|
{
|
Object[] values = new Object[2];
|
values[0] = entry.getKey();
|
values[1] = Ognl.getValue(evalColInfo._evalBin, entry.getValue());
|
|
if(r_isSummary[0] == ASTCubeRecsType.RECORD && timeGroupInfo._unit == GROUP_UNIT.NONE)
|
recsGroups[0].addRecord(new Object[] {values[1]});
|
else
|
recsGroups[0].addRecord(values);
|
}
|
|
// 输出结果
|
if(recsGroups[0] == null)
|
{
|
recsGroups[0] = new DBRecords();
|
|
if(r_isSummary[0] == ASTCubeRecsType.RECORD && timeGroupInfo._unit == GROUP_UNIT.NONE)
|
recsGroups[0].initColumn(new String[] {_groupField});
|
else
|
recsGroups[0].initColumn(new String[] {_timeRange._timeField, _groupField});
|
|
recsGroups[0].addRecord(new Object[] {0});
|
|
}
|
|
_recsValue = recsGroups[0];
|
}
|
|
return null;
|
}
|
|
public SMTJavaAIError groupValueRecords(String sGroupOP, String sGroupStep, ASTCubeRecsType[] r_isSummary, String[][] r_colNames) throws Exception
|
{
|
if(_recsValue == null)
|
return null;
|
|
if(!SMTStatic.isNullOrEmpty(sGroupStep) && SMTStatic.isNullOrEmpty(_timeRange._timeField))
|
return new SMTJavaAIError("未指定时间字段无法聚合");
|
|
TimeGroupInfo timeGroupInfo = new TimeGroupInfo();
|
|
boolean noGroupField = SMTStatic.isNullOrEmpty(_groupField);
|
|
String sGroupTitle;
|
if("MAX".equalsIgnoreCase(sGroupOP))
|
{
|
timeGroupInfo._op = GROUP_OP.MAX;
|
sGroupTitle = "最大值";
|
}
|
else if("MIN".equalsIgnoreCase(sGroupOP))
|
{
|
timeGroupInfo._op = GROUP_OP.MIN;
|
sGroupTitle = "最小值";
|
}
|
else if("AVG".equalsIgnoreCase(sGroupOP))
|
{
|
timeGroupInfo._op = GROUP_OP.AVG;
|
sGroupTitle = "平均值";
|
}
|
else if("SUM".equalsIgnoreCase(sGroupOP))
|
{
|
timeGroupInfo._op = GROUP_OP.SUM;
|
sGroupTitle = "累计值";
|
}
|
else if("COUNT".equalsIgnoreCase(sGroupOP))
|
{
|
timeGroupInfo._op = GROUP_OP.COUNT;
|
sGroupTitle = "个数";
|
}
|
else
|
return new SMTJavaAIError("无法辨认分组操作符：" + sGroupOP);
|
|
if(timeGroupInfo._op != GROUP_OP.COUNT && SMTStatic.isNullOrEmpty(_groupField))
|
return new SMTJavaAIError("未指定值字段无法统计");
|
|
|
if(SMTStatic.isNullOrEmpty(sGroupStep))
|
{
|
timeGroupInfo._unit = GROUP_UNIT.NONE;
|
if(r_isSummary[0] != ASTCubeRecsType.RECORD)
|
r_isSummary[0] = ASTCubeRecsType.SUMMARY;
|
if(r_colNames != null && r_colNames[0] != null)
|
r_colNames[0] = new String[] {sGroupTitle};
|
}
|
else
|
{
|
int[] aTimeStep = SMTAIServerApp.convStrToTimeStep(sGroupStep);
|
if(aTimeStep == null)
|
return new SMTJavaAIError("无法辨认分组步长：" + sGroupStep);
|
|
timeGroupInfo._unit = aTimeStep[0] == 0 ? GROUP_UNIT.MINUTE : GROUP_UNIT.MONTH;
|
timeGroupInfo._step = aTimeStep[1];
|
|
if(SMTStatic.isNullOrEmpty(this._chartType) && (aTimeStep[0] == 1 || aTimeStep[1] >= 24 * 60))
|
{
|
this._chartType = "bar";
|
}
|
|
if(r_colNames != null && r_colNames[0] != null)
|
r_colNames[0] = new String[] {"时间", sGroupTitle};
|
|
}
|
|
TreeMap<Date, Object> mapTime2Recs = new TreeMap<>();
|
TreeMap<Date, Integer> mapTime2Count = new TreeMap<>();
|
SMTJavaAIError errors[] = new SMTJavaAIError[1];
|
DBRecords[] recsGroups = new DBRecords[1];
|
|
if(_timeRange == null)
|
{
|
DBRecords recsValue = new DBRecords();
|
if(noGroupField)
|
_groupField = "CNT";
|
recsValue.initColumn(new String[] {_groupField});
|
recsValue.addRecord(new Object[] {_recsValue.getRowCount()});
|
_recsValue = recsValue;
|
}
|
else
|
{
|
for(DBRecord rec : _recsValue.getRecords())
|
{
|
// 初始化字段名
|
if(recsGroups[0] == null)
|
{
|
recsGroups[0] = new DBRecords();
|
|
if(r_isSummary[0] == ASTCubeRecsType.RECORD && timeGroupInfo._unit == GROUP_UNIT.NONE)
|
recsGroups[0].initColumn(new String[] {noGroupField ? "CNT" : _groupField});
|
else
|
recsGroups[0].initColumn(new String[] {_timeRange._timeField, noGroupField ? "CNT" : _groupField});
|
}
|
|
// 获取原始值，忽略空值
|
Object curValue = noGroupField ? 0 : convGroupTypeValue(_groupType, rec.getValue(_groupField));
|
if(curValue == null)
|
continue;
|
|
// 对齐时间
|
Date time = alignGroupTime(timeGroupInfo, rec.getDate(_timeRange._timeField));
|
Object orgValue = mapTime2Recs.get(time);
|
|
// 进行统计计算
|
switch(timeGroupInfo._op)
|
{
|
case MIN:
|
if(orgValue == null || compGroupTypeValue(_groupType, orgValue, curValue) > 0)
|
mapTime2Recs.put(time, curValue);
|
break;
|
|
case MAX:
|
if(orgValue == null || compGroupTypeValue(_groupType, orgValue, curValue) < 0)
|
mapTime2Recs.put(time, curValue);
|
break;
|
|
case SUM:
|
case AVG:
|
case COUNT:
|
if(orgValue == null)
|
{
|
if(!noGroupField)
|
mapTime2Recs.put(time, curValue);
|
else
|
mapTime2Recs.put(time, 0);
|
mapTime2Count.put(time, 1);
|
}
|
else
|
{
|
mapTime2Count.put(time, mapTime2Count.get(time) + 1);
|
|
if(!noGroupField)
|
{
|
switch(_groupType)
|
{
|
case 'I':
|
mapTime2Recs.put(time, (int)orgValue + (int)curValue);
|
break;
|
case 'L':
|
mapTime2Recs.put(time, (long)orgValue + (long)curValue);
|
break;
|
case 'D':
|
mapTime2Recs.put(time, (double)orgValue + (double)curValue);
|
break;
|
}
|
}
|
}
|
break;
|
|
}
|
}
|
|
|
if(errors[0] != null)
|
return errors[0];
|
|
// 汇总成记录
|
for(Entry<Date, Object> entry : mapTime2Recs.entrySet())
|
{
|
Object[] values = new Object[2];
|
values[0] = entry.getKey();
|
|
switch(timeGroupInfo._op)
|
{
|
case MIN:
|
case MAX:
|
case SUM:
|
values[1] = entry.getValue();
|
break;
|
|
case AVG:
|
{
|
int count = mapTime2Count.get(entry.getKey());
|
switch(_groupType)
|
{
|
case 'I':
|
values[1] = (int)((int)entry.getValue() / count);
|
break;
|
case 'L':
|
values[1] = (long)((long)entry.getValue() / count);
|
break;
|
case 'D':
|
values[1] = (double)((double)entry.getValue() / count);
|
break;
|
}
|
}
|
break;
|
|
case COUNT:
|
values[1] = mapTime2Count.get(entry.getKey());
|
break;
|
|
default:
|
break;
|
}
|
|
if(r_isSummary[0] == ASTCubeRecsType.RECORD && timeGroupInfo._unit == GROUP_UNIT.NONE)
|
recsGroups[0].addRecord(new Object[] {values[1]});
|
else
|
recsGroups[0].addRecord(values);
|
|
}
|
|
if(recsGroups[0] == null)
|
{
|
recsGroups[0] = new DBRecords();
|
|
if(r_isSummary[0] == ASTCubeRecsType.RECORD && timeGroupInfo._unit == GROUP_UNIT.NONE)
|
recsGroups[0].initColumn(new String[] {noGroupField ? "CNT" : _groupField});
|
else
|
recsGroups[0].initColumn(new String[] {_timeRange._timeField, noGroupField ? "CNT" : _groupField});
|
|
recsGroups[0].addRecord(new Object[] {0});
|
|
}
|
|
_recsValue = recsGroups[0];
|
}
|
|
return null;
|
|
}
|
|
public SMTJavaAIError diffValueRecords(String strDiffOP, ASTCubeRecsValue tagASTRecsValue) throws Exception
|
{
|
DIFF_OP diffOP;
|
if("ADD".equals(strDiffOP))
|
diffOP = DIFF_OP.ADD;
|
else if("SUB".equals(strDiffOP))
|
diffOP = DIFF_OP.SUB;
|
else if("YOY".equals(strDiffOP))
|
diffOP = DIFF_OP.YOY;
|
else if("MOM".equals(strDiffOP))
|
diffOP = DIFF_OP.YOY;
|
else
|
throw new Exception("未支持的差分:" + strDiffOP);
|
|
if(_timeRange._startTime == null || tagASTRecsValue._timeRange._startTime == null)
|
return new SMTJavaAIError("无延时数据可对比");
|
|
if(SMTStatic.isNullOrEmpty(_groupField) || SMTStatic.isNullOrEmpty(tagASTRecsValue._groupField))
|
return new SMTJavaAIError("无延时字段可对比");
|
|
_timeRange.copyToTimeRange2(tagASTRecsValue._timeRange);
|
|
// 计算时间偏差
|
long subTime = tagASTRecsValue._timeRange._startTime.getTime() - this._timeRange._startTime.getTime();
|
|
// 将目标延时数据转换成映射表
|
HashMap<Date, Object> mapTime2Value = new HashMap<>();
|
for(DBRecord recTag : tagASTRecsValue._recsValue.getRecords())
|
{
|
mapTime2Value.put(
|
new Date(recTag.getDate(tagASTRecsValue._timeRange._timeField).getTime() - subTime),
|
recTag.getValue(tagASTRecsValue._groupField)
|
);
|
}
|
|
// 创建新的结果集
|
DBRecords recsDiff = new DBRecords();
|
recsDiff.initColumn(new String[] {this._timeRange._timeField, this._groupField});
|
|
// 扫描源表记录
|
for(DBRecord recSrc : this._recsValue.getRecords())
|
{
|
Date time = recSrc.getDate(this._timeRange._timeField);
|
Object srcValue= recSrc.getValue(this._groupField);
|
if(srcValue == null)
|
continue;
|
|
Object tagValue = mapTime2Value.get(time);
|
if(tagValue == null)
|
continue;
|
|
Object diffValue = null;
|
switch(diffOP)
|
{
|
case ADD:
|
switch(_groupType)
|
{
|
case 'I':
|
diffValue = (int)srcValue + (int)tagValue;
|
break;
|
case 'L':
|
diffValue = (long)srcValue + (long)tagValue;
|
break;
|
case 'D':
|
diffValue = (double)srcValue + (double)tagValue;
|
break;
|
}
|
break;
|
|
case SUB:
|
switch(_groupType)
|
{
|
case 'I':
|
diffValue = (int)srcValue - (int)tagValue;
|
break;
|
case 'L':
|
diffValue = (long)srcValue - (long)tagValue;
|
break;
|
case 'D':
|
diffValue = (double)srcValue - (double)tagValue;
|
break;
|
}
|
break;
|
|
case YOY:
|
switch(_groupType)
|
{
|
case 'I':
|
diffValue = (((int)tagValue == 0) ? 0 : (double)((int)srcValue - (int)tagValue) / (int)tagValue);
|
break;
|
case 'L':
|
diffValue = (((long)tagValue == 0) ? 0 : (double)((long)srcValue - (long)tagValue) / (long)tagValue);
|
break;
|
case 'D':
|
diffValue = (((double)tagValue == 0) ? 0 : ((double)srcValue - (double)tagValue) / (double)tagValue);
|
break;
|
}
|
break;
|
}
|
|
recsDiff.addRecord(new Object[] {time, diffValue});
|
}
|
|
this._recsValue = recsDiff;
|
|
return null;
|
}
|
}
|
