package biz.report.agg;
|
|
|
import java.text.MessageFormat;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
|
import foundation.data.entity.Entity;
|
import foundation.data.entity.EntitySet;
|
import foundation.data.entity.Filter;
|
import foundation.data.entity.GroupBy;
|
import foundation.data.entity.OrderBy;
|
import foundation.data.object.DataObject;
|
import foundation.data.object.EntitySaver;
|
import foundation.engine.Engine;
|
import foundation.persist.NamedSQL;
|
import foundation.persist.SQLRunner;
|
import foundation.util.ContentBuilder;
|
import foundation.util.ID;
|
import foundation.util.MapList;
|
import foundation.util.Util;
|
|
/**
|
* @author kimi
|
* @description 绩效计算执行器
|
* @date 2024-09-19 9:40
|
*/
|
|
|
public class PerformanceEngine extends Engine {
|
private AggPeroid peroid;
|
private String resultId;
|
private String stepCode;
|
private String resultStepId;
|
private String dataName;
|
private String sourceDataName;
|
private MapList<String, AggDimension> dimensionList;
|
private List<AggDimension> peroidDimensionList;
|
private List<AggDimension> territoryDimensionList;
|
|
public PerformanceEngine(String resultId) {
|
this.resultId = resultId;
|
}
|
|
//同步执行
|
@Override
|
protected void sameThreadRun(String operator, Object... args) throws Exception {
|
//获取系统支持的维度
|
//获取系统支持的度量
|
|
//获取报表数据范围
|
|
//获取可查看的维度
|
//获取可查看的度量
|
//获取当前的数据
|
|
}
|
|
//异步执行
|
@Override
|
protected void newThreadRun(String operator, Object... args) {
|
//流向预处理
|
|
//流向汇总
|
|
//聚合计算
|
if (Constant.OPERATE_AGG.equalsIgnoreCase(operator)) {
|
try {
|
doAgg(args);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
if (Constant.OPERATE_IO.equalsIgnoreCase(operator)) {
|
try {
|
doIO(args);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
public void init(Object... args) throws Exception {
|
DataObject aggResultDataObject = DataObject.getInstance(Constant.DATANAME_AGG_RESULT);
|
Entity resultEntity = aggResultDataObject.getTableEntity(resultId);
|
if (resultEntity == null || resultEntity.isEmpty()) {
|
return;
|
}
|
|
String dimensionKey = resultEntity.getString(Constant.FIELD_Dimension_Key);
|
parseAggDimension(dimensionKey);
|
dataName = resultEntity.getString("table_name");
|
stepCode = resultEntity.getString("step_code");
|
sourceDataName = resultEntity.getString("source_data_name");
|
}
|
|
public void setPeroid(AggPeroid aggPeroid) {
|
this.peroid = aggPeroid;
|
}
|
|
private void doAgg(Object... args) throws Exception {
|
doAggOneResult();
|
}
|
|
private void doAggOneResult() throws Exception {
|
//1. load steps
|
List<AggStep> steps = initResultStep();
|
|
//0 获取本期间
|
//0.1 清空历史周期数据
|
resetDataByStep();
|
|
//1.添加维度
|
createDimensionLines();
|
|
//2. execute
|
for (AggStep step : steps) {
|
doAggOneResultStep(step);
|
}
|
}
|
|
private void doIO(Object[] args) throws Exception {
|
//0. load steps
|
List<AggStep> steps = initResultStep();
|
|
//1. 清空历史周期数据
|
resetDataByStep();
|
|
//2.添加维度
|
initLines();
|
|
//2. execute
|
for (AggStep step : steps) {
|
doAggOneResultStep(step);
|
}
|
}
|
|
private void initLines() throws Exception {
|
DataObject dataObject = DataObject.getInstance(Constant.DATANAME_AGG_RESULT_FILED);
|
Filter fieldFilter = new Filter();
|
fieldFilter.add("result_id", resultId);
|
fieldFilter.add("step_id is null");
|
EntitySet fieldMappingSet = dataObject.getTableEntitySet(fieldFilter);
|
|
List<AggField> fields = new ArrayList<AggField>();
|
for (Entity entity : fieldMappingSet) {
|
AggField field = new AggField();
|
field.load(entity);
|
|
fields.add(field);
|
}
|
|
ContentBuilder fromFields = new ContentBuilder(",");
|
ContentBuilder toFields = new ContentBuilder(",");
|
|
for (AggField field : fields) {
|
fromFields.append(field.getMeasureField());
|
toFields.append(field.getFieldName());
|
}
|
|
NamedSQL namedSql = NamedSQL.getInstance("initLines");
|
namedSql.setTableName(dataName);
|
namedSql.setParam(Constant.FIELD_SOURCE_TABLE_NAME, sourceDataName);
|
namedSql.setParam("toFields", toFields.toString());
|
namedSql.setParam("fromFields", fromFields.toString());
|
|
Filter filter = getUpdateFilter();
|
namedSql.setFilter(filter);
|
|
int cnt = namedSql.execute();
|
//todo 日志
|
}
|
|
private void createDimensionLines() throws Exception {
|
List<String> groupFields = new ArrayList<String>();
|
Map<String, String> groupMap = new HashMap<String, String>();
|
|
for (AggDimension dimension : dimensionList) {
|
String dataName = dimension.getDataName();
|
String sqlSegment = dimension.getSqlSegment();
|
String codeField = dimension.getCodeField();
|
groupFields.add(sqlSegment);
|
|
if (!groupMap.containsKey(dataName)) {
|
groupMap.put(dataName, dataName + "." + sqlSegment + " " + codeField);
|
continue;
|
}
|
|
String fields = groupMap.get(dataName);
|
fields = fields + "," + dataName + "." + sqlSegment + " " + codeField;
|
groupMap.replace(dataName, fields);
|
}
|
|
ContentBuilder groupFieldBuilder = new ContentBuilder(",");
|
ContentBuilder tableJoinsBuilder = new ContentBuilder(" join ");
|
for(Entry<String, String> entry : groupMap.entrySet()) {
|
String dataName = entry.getKey();
|
String fields = entry.getValue();
|
|
groupFieldBuilder.append(fields);
|
|
DataObject dimensionDataObject = DataObject.getInstance(dataName);
|
String dataNameSql = "(" + dimensionDataObject.getBatchBrowseSQL().toString() + ") " + dataName;
|
tableJoinsBuilder.append(dataNameSql);
|
}
|
|
NamedSQL namedSQL = NamedSQL.getInstance(Constant.NAMEDSQL_GETDIMENSIONDATA);
|
namedSQL.setParam(Constant.FIELD_FIELDS, groupFieldBuilder.toString());
|
namedSQL.setTableName(tableJoinsBuilder.toString());
|
namedSQL.setGroupBy(new GroupBy(String.join(",", groupFields)));
|
|
Filter filter = new Filter();
|
for (AggDimension peroidDimension : peroidDimensionList) {
|
String code = peroidDimension.getCodeField();
|
AggPeroidType peroidTypeByDimension = AggPeroidType.parse(code);
|
String peroidValue = peroid.getValueByType(peroidTypeByDimension);
|
filter.add(peroidDimension.getDataName() + "." + code, peroidValue);
|
}
|
|
namedSQL.setFilter(filter);
|
|
EntitySet entitySet = SQLRunner.getEntitySet(namedSQL);
|
|
DataObject targetDataObject = DataObject.getInstance(dataName);
|
EntitySet dimensionLines = targetDataObject.createTableEntitySet();
|
|
for (Entity entity : entitySet) {
|
Entity line = targetDataObject.createTableEntity(true);
|
line.setId(ID.newValue());
|
|
for (AggDimension dimension : dimensionList) {
|
String fieldName = dimension.getCodeField();
|
line.set(fieldName, entity.getString(fieldName,"--"));
|
}
|
|
dimensionLines.append(line);
|
}
|
|
int cnt = targetDataObject.batchInsertEntitySet(dimensionLines);
|
|
//todo 日志cnt
|
}
|
|
private Filter getUpdateFilter() {
|
Filter filter = new Filter();
|
for (AggDimension peroidDimension : peroidDimensionList) {
|
String code = peroidDimension.getCodeField();
|
AggPeroidType peroidTypeByDimension = AggPeroidType.parse(code);
|
String peroidValue = peroid.getValueByType(peroidTypeByDimension);
|
filter.add(code, peroidValue);
|
}
|
return filter;
|
}
|
|
private List<AggStep> initResultStep() throws Exception {
|
List<AggStep> steps = new ArrayList<AggStep>();
|
|
DataObject resultStepDataObject = DataObject.getInstance(Constant.DATANAME_AGG_RESULT_STEP);
|
Filter filter = new Filter();
|
filter.add(Constant.FIELD_PARENT_ID, resultId);
|
if (!Util.isEmpty(resultStepId)) {
|
filter.add("id", resultStepId);
|
}
|
|
EntitySet resultStepSet = resultStepDataObject.getTableEntitySet(filter, new OrderBy(Constant.FIELD_ORDER_NO));
|
|
for (Entity stepEntity : resultStepSet) {
|
AggStep aggStep = AggStep.createByEntity(stepEntity);
|
if (aggStep == null) {
|
continue;
|
}
|
steps.add(aggStep);
|
}
|
|
return steps;
|
}
|
|
//执行单个 汇总步骤
|
private void doAggOneResultStep(AggStep aggStep) throws Exception {
|
updateDataByStep(aggStep);
|
}
|
|
private void updateDataByStep(AggStep aggStep) throws Exception {
|
AggPattern pattern = aggStep.getPattern();
|
|
switch (pattern) {
|
case agg:
|
updateAggStep(aggStep);
|
break;
|
case achieve:
|
updateAchieveStep(aggStep);
|
break;
|
case yoy:
|
updateYOYStep(aggStep);
|
break;
|
case mom:
|
updateMOMStep(aggStep);
|
break;
|
case contribution:
|
updateContributionStep(aggStep);
|
break;
|
case ranking:
|
updateRankingStep(aggStep);
|
break;
|
default:
|
updateSupplementaryStep(aggStep);
|
}
|
}
|
|
//排名计算
|
private void updateRankingStep(AggStep aggStep) throws Exception {
|
NamedSQL getRankStepSql = NamedSQL.getInstance(Constant.NAMEDSQL_UPDATERANKBYDATA);
|
getRankStepSql.setTableName(dataName);
|
|
//filter 期间
|
Filter filter = createUpdateFilter(aggStep);
|
|
//rank 的范围
|
// filter = addRankScope(aggStep, filter);
|
|
// 排名的字段
|
OrderBy orderBy = getOrderByForRank(aggStep);
|
getRankStepSql.setOrderBy(orderBy);
|
|
//分组字段
|
ContentBuilder builder = new ContentBuilder(",");
|
List<String> groupFields = getAggGroup(aggStep);
|
for (String field : groupFields) {
|
builder.append(Util.quotedStr("-"));
|
builder.append(field);
|
}
|
|
String groupFieldsConcat = Util.stringJoin("concat(", builder.toString(), ")");
|
getRankStepSql.setParam("groupFieldsConcat", groupFieldsConcat);
|
|
String updateSegment = createUpdateSegment(aggStep);
|
getRankStepSql.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
getRankStepSql.setFilter(filter);
|
|
int cnt = getRankStepSql.execute();
|
// todo 日志
|
}
|
|
private OrderBy getOrderByForRank(AggStep aggStep) {
|
MapList<String, AggDimension> dimensions = aggStep.getDimensions();
|
|
if (dimensions == null) {
|
dimensions = dimensionList;
|
}
|
|
ContentBuilder builder = new ContentBuilder(",");
|
for (AggDimension dimension : dimensions) {
|
builder.append(dimension.getCodeField() + " asc");
|
}
|
|
List<AggField> fields = aggStep.getUpdateMeasureList();
|
for (AggField field : fields) {
|
builder.append(field.getMeasureField() + " desc");
|
}
|
|
return new OrderBy(builder.toString());
|
}
|
|
//贡献计算
|
private void updateContributionStep(AggStep aggStep) throws Exception {
|
NamedSQL contributionStepNamedSql = NamedSQL.getInstance(Constant.NAMEDSQL_UPDATECONTRIBUTIONDATABYAGG);
|
|
//tablename
|
contributionStepNamedSql.setTableName(dataName);
|
|
// 差别是添加了架构的层级关系架构
|
List<String> groupNameList = getAggGroup(aggStep);
|
String groupNameStr = String.join(",", groupNameList);
|
contributionStepNamedSql.setGroupBy(new GroupBy(groupNameStr));
|
|
String joinSegment = createJoinSegment(aggStep);
|
contributionStepNamedSql.setParam(Constant.FIELD_JOIN_SEGMENT, joinSegment);
|
|
//update segment
|
String updateSegment = createUpdateSegment(aggStep);
|
contributionStepNamedSql.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
//filter 期间
|
//filter 根据区间获取辖区版本 根据辖区版本获取上下级树 根据树 循环更新
|
Filter filter = createUpdateFilter(aggStep);
|
contributionStepNamedSql.setFilter(filter);
|
|
List<AggField> fieldList = aggStep.getUpdateMeasureList();
|
ContentBuilder builder = new ContentBuilder(",");
|
|
for (AggField field : fieldList) {
|
String fieldName = field.getMeasureField();
|
builder.append(MessageFormat.format("sum({0}) as {0} ", fieldName));
|
}
|
|
contributionStepNamedSql.setParam(Constant.FIELD_FIELDS, Util.stringJoin(groupNameStr, ",", builder.toString()));
|
|
int cnt = contributionStepNamedSql.execute();
|
}
|
|
//环比计算
|
private void updateMOMStep(AggStep aggStep) throws Exception {
|
NamedSQL momStepNamedSql = NamedSQL.getInstance(Constant.NAMEDSQL_UPDATEAGGDATABYAGG);
|
//tablename
|
momStepNamedSql.setTableName(dataName);
|
|
String joinSegment = createJoinSegment(aggStep);
|
momStepNamedSql.setParam(Constant.FIELD_JOIN_SEGMENT, joinSegment);
|
|
//update segment
|
String updateSegment = createUpdateSegment(aggStep);
|
momStepNamedSql.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
//filter 期间
|
Filter filter = createUpdateFilter(aggStep);
|
momStepNamedSql.setFilter(filter);
|
|
momStepNamedSql.setParam(Constant.FIELD_JOIN_FILTER, "1=1");
|
momStepNamedSql.execute();
|
}
|
|
//同比计算
|
private void updateYOYStep(AggStep aggStep) throws Exception {
|
NamedSQL yoyStepNamedSql = NamedSQL.getInstance(Constant.NAMEDSQL_UPDATEAGGDATABYAGG);
|
//tablename
|
yoyStepNamedSql.setTableName(dataName);
|
|
//join segment
|
String joinSegment = createJoinSegment(aggStep);
|
yoyStepNamedSql.setParam(Constant.FIELD_JOIN_SEGMENT, joinSegment);
|
|
//update segment
|
String updateSegment = createUpdateSegment(aggStep);
|
yoyStepNamedSql.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
//filter 期间
|
Filter filter = createUpdateFilter(aggStep);
|
yoyStepNamedSql.setFilter(filter);
|
yoyStepNamedSql.setParam(Constant.FIELD_JOIN_FILTER, "1=1");
|
|
yoyStepNamedSql.execute();
|
}
|
|
|
//达成计算
|
private void updateAchieveStep(AggStep aggStep) throws Exception {
|
NamedSQL achieveStep = NamedSQL.getInstance(Constant.NAMEDSQL_UPDATEACHIEVEDATA);
|
//tablename
|
achieveStep.setTableName(dataName);
|
|
//update segment
|
String updateSegment = createUpdateSegment(aggStep);
|
achieveStep.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
//filter 期间
|
Filter filter = createUpdateFilter(aggStep);
|
|
achieveStep.setFilter(filter);
|
|
achieveStep.execute();
|
}
|
|
private void updateSupplementaryStep(AggStep aggStep) throws Exception {
|
NamedSQL supplementaryStep = NamedSQL.getInstance(Constant.NAMEDSQL_UpdateSupplementaryData);
|
supplementaryStep.setTableName(dataName);
|
|
// source_tablename
|
MapList<String, AggDimension> dimensions = aggStep.getDimensions();
|
AggDimension dimension = dimensions.get(0);
|
String sourceDataName = dimension.getDataName();
|
DataObject sourceDataObject = DataObject.getInstance(sourceDataName);
|
String dataNameSql = sourceDataObject.getBatchBrowseSQL().toString();
|
supplementaryStep.setParam(Constant.FIELD_SOURCE_TABLE_NAME, dataNameSql);
|
|
//join segment
|
String joinSegment = createJoinSegment(aggStep);
|
supplementaryStep.setParam(Constant.FIELD_JOIN_SEGMENT, joinSegment);
|
|
//update segment
|
String updateSegment = createUpdateSegment(aggStep);
|
supplementaryStep.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
//filter 期间
|
Filter filter = createUpdateFilter(aggStep);
|
supplementaryStep.setFilter(filter);
|
|
int cnt = supplementaryStep.execute();
|
// todo 日志
|
}
|
|
private String createJoinSegment(AggStep aggStep) {
|
String joinSegment = aggStep.getJoinSegment();
|
|
if (Util.isEmpty(joinSegment)) {
|
joinSegment = standardJoinSegment(aggStep);
|
}
|
|
return joinSegment;
|
}
|
|
private Filter createUpdateFilter(AggStep aggStep) {
|
Filter filter = new Filter();
|
for (AggDimension peroidDimension : peroidDimensionList) {
|
String code = peroidDimension.getCodeField();
|
AggPeroidType peroidTypeByDimension = AggPeroidType.parse(code);
|
String peroidValue = peroid.getValueByType(peroidTypeByDimension);
|
filter.add("a." + code, peroidValue);
|
}
|
|
String type = aggStep.getType();
|
if (aggStep.isRollUp()) {
|
String filterStr = type.substring(8, type.length() - 1);
|
AggDimension deimension = AggDimensionBucket.getOne(filterStr);
|
|
if (deimension != null) {
|
// 字段汇总
|
filter.add(deimension.getCodeField(), "--");
|
}
|
else {
|
//层级
|
filter.add(filterStr + " - 1");
|
}
|
}
|
|
if (aggStep.hasExFilter()) {
|
String filterStr = type.substring(7, type.length() - 1);
|
filter.add(filterStr);
|
}
|
|
return filter;
|
}
|
|
private String createUpdateSegment(AggStep aggStep) {
|
return createUpdateSegment(aggStep, null);
|
}
|
|
private String createUpdateSegment(AggStep aggStep, String brand) {
|
List<AggField> fieldList = aggStep.getUpdateMeasureList();
|
|
if (aggStep.getPattern() == AggPattern.agg) {
|
MapList<String, List<AggField>> measureList = aggStep.getMeasureList();
|
fieldList = measureList.get(brand);
|
}
|
|
ContentBuilder builder = new ContentBuilder(", ");
|
|
for (AggField field: fieldList) {
|
builder.append(aggStep.getMeasureSql(field));
|
}
|
|
String updateSegment = builder.toString();
|
|
return updateSegment;
|
}
|
|
private void resetDataByStep() throws Exception {
|
Filter filter = getUpdateFilter();
|
DataObject targetDataObject = DataObject.getInstance(dataName);
|
targetDataObject.deleteEntitySet(filter);
|
}
|
|
|
private void updateAggStep(AggStep aggStep) throws Exception {
|
//2 检查是否包含BY每条计算的维度
|
//聚合的字段
|
MapList<String, String> dataNameFieldsMap = getAggFields(aggStep);
|
|
//聚合的分组
|
List<String> groupNameList = getAggGroup(aggStep);
|
ContentBuilder groupNameBuilder = new ContentBuilder(", ");
|
for (String oneGroupByName : groupNameList) {
|
groupNameBuilder.append(oneGroupByName);
|
}
|
String groupNameStr = groupNameBuilder.toString();
|
|
NamedSQL getGroupDataNamedSql = NamedSQL.getInstance(Constant.NAMEDSQL_UPDATEAGGDATA);
|
getGroupDataNamedSql.setTableName(dataName);
|
getGroupDataNamedSql.setGroupBy(new GroupBy(groupNameStr));
|
|
String joinSegment = createJoinSegment(aggStep);
|
getGroupDataNamedSql.setParam(Constant.FIELD_JOIN_SEGMENT, joinSegment);
|
|
//聚合的过滤条件
|
Filter aggFilter = getAggFilter(aggStep);
|
getGroupDataNamedSql.setParam("dataFilter", aggFilter.toString());
|
|
for (String dataName : dataNameFieldsMap.getKeySet()) {
|
String fields = dataNameFieldsMap.get(dataName);
|
getGroupDataNamedSql.setParam(Constant.FIELD_FIELDS, Util.stringJoin(groupNameStr, ",", fields));
|
|
DataObject sourceDataObject = DataObject.getInstance(dataName);
|
String dataNameSql = "(" + sourceDataObject.getBatchBrowseSQL().toString() + ") " + dataName;
|
getGroupDataNamedSql.setParam("source_tablename", dataNameSql);
|
|
String updateSegment = createUpdateSegment(aggStep, dataName);
|
getGroupDataNamedSql.setParam(Constant.FIELD_UPDATE_SEGMENT, updateSegment);
|
|
Filter filter = createUpdateFilter(aggStep);
|
getGroupDataNamedSql.setFilter(filter);
|
|
int cnt = getGroupDataNamedSql.execute();
|
// todo 日志cnt
|
}
|
}
|
|
private String standardJoinSegment(AggStep aggStep) {
|
ContentBuilder builder = new ContentBuilder(" and ");
|
|
for (AggDimension dimension : dimensionList) {
|
if (dimension.isPeroid()) {
|
continue;
|
}
|
|
String dimensionFieldName = dimension.getCodeField();
|
builder.append(MessageFormat.format("a.{0} = ifnull(a1.{0},''--'')", dimensionFieldName));
|
}
|
|
AggPattern pattern = aggStep.getPattern();
|
String type = aggStep.getType();
|
switch (pattern) {
|
case agg:
|
case count:
|
for (AggDimension peroid : peroidDimensionList) {
|
String dimensionFieldName = peroid.getCodeField();
|
builder.append(MessageFormat.format("a.{0} = a1.{0}", dimensionFieldName));
|
}
|
|
for (AggDimension territory : territoryDimensionList) {
|
String dimensionFieldName = territory.getCodeField();
|
builder.append(MessageFormat.format("a.{0} = ifnull(a1.{0},''--'')", dimensionFieldName));
|
}
|
|
break;
|
case mom:
|
AggPeroidType peroidType = AggPeroidType.parse(type);
|
int yearPeroidCount = 12/peroidType.getCycleNum();
|
for (AggDimension peroid : peroidDimensionList) {
|
String dimensionFieldName = peroid.getCodeField();
|
|
if (peroid.getCodeField().equalsIgnoreCase(type)) {
|
builder.append(MessageFormat.format("a.year * {1} + a.{0} = a1.year * {1} + a1.{0} - 1", dimensionFieldName, yearPeroidCount));
|
}
|
else {
|
builder.append(MessageFormat.format("a.{0} = a1.{0}", dimensionFieldName));
|
}
|
}
|
|
for (AggDimension territory : territoryDimensionList) {
|
String dimensionFieldName = territory.getCodeField();
|
builder.append(MessageFormat.format("a.{0} = ifnull(a1.{0}, ''--'')", dimensionFieldName));
|
}
|
|
break;
|
case yoy:
|
for (AggDimension peroid : peroidDimensionList) {
|
String dimensionFieldName = peroid.getCodeField();
|
|
if (peroid.isYear()) {
|
builder.append(MessageFormat.format("a.{0} = a1.{0} - 1", dimensionFieldName));
|
}
|
else {
|
builder.append(MessageFormat.format("a.{0} = a1.{0}", dimensionFieldName));
|
}
|
}
|
|
for (AggDimension territory : territoryDimensionList) {
|
String dimensionFieldName = territory.getCodeField();
|
builder.append(MessageFormat.format("a.{0} = ifnull(a1.{0}, ''--'')", dimensionFieldName));
|
}
|
|
break;
|
case contribution:
|
case ranking:
|
for (AggDimension peroid : peroidDimensionList) {
|
String dimensionFieldName = peroid.getCodeField();
|
builder.append(MessageFormat.format("a.{0} = a1.{0}", dimensionFieldName));
|
}
|
|
if (Integer.parseInt(type) > 1) {
|
builder.append(MessageFormat.format("a.position_level{0} = ifnull(a1.position_level{0}, ''--'')", type));
|
}
|
|
break;
|
default:
|
break;
|
}
|
|
return builder.toString();
|
}
|
|
private List<String> getAggGroup(AggStep aggStep) {
|
List<String> fieldNameList = new ArrayList<>();
|
List<String> dimensionFieldNameList = getDbDimensionFieldNames(aggStep);
|
fieldNameList.addAll(dimensionFieldNameList);
|
|
return fieldNameList;
|
}
|
|
private List<String> getDbDimensionFieldNames(AggStep aggStep) {
|
List<String> fieldNameList = new ArrayList<>();
|
|
MapList<String, AggDimension> dimensions = aggStep.getDimensions();
|
if (dimensions == null) {
|
dimensions = dimensionList;
|
}
|
|
for (AggDimension aggDimension : dimensions) {
|
DimensionAggType aggType = aggDimension.getAggType();
|
if (DimensionAggType.db.equals(aggType)) {
|
fieldNameList.add(aggDimension.getCodeField());
|
}
|
}
|
return fieldNameList;
|
}
|
|
private Filter getAggFilter(AggStep aggStep) throws Exception {
|
// 向上汇总
|
if (!aggStep.isRollUp()) {
|
return new Filter("1=1");
|
}
|
|
String type = aggStep.getType();
|
String filterStr = type.substring(8, type.length() - 1);
|
AggDimension deimension = AggDimensionBucket.getOne(filterStr);
|
Filter filter = new Filter();
|
|
if (deimension != null) {
|
// 字段汇总
|
filter.add(deimension.getCodeField() + " != '--'");
|
}
|
else {
|
//层级
|
filter.add(filterStr);
|
}
|
return filter;
|
}
|
|
private MapList<String, String> getAggFields(AggStep aggStep) {
|
MapList<String, String> fieldNameList = new MapList<String, String>();
|
AggPattern pattern = aggStep.getPattern();
|
|
MapList<String, List<AggField>> measureList = aggStep.getMeasureList();
|
for (String key : measureList.getKeySet()) {
|
List<AggField> brandMeasures = measureList.get(key);
|
|
ContentBuilder builder = new ContentBuilder(",");
|
for (AggField field : brandMeasures) {
|
String measureField = field.getMeasureField();
|
String fieldName = field.getFieldName();
|
String level1FieldSegment = pattern.getLevel1FieldSegment();
|
if (Util.isEmpty(level1FieldSegment)) {
|
builder.append(measureField);
|
continue;
|
}
|
|
builder.append(MessageFormat.format(level1FieldSegment, measureField, fieldName));
|
}
|
|
fieldNameList.add(key, builder.toString());
|
}
|
|
return fieldNameList;
|
}
|
|
// private void doAggTotalResult() throws Exception {
|
// DataObject aggResultDataObject = DataObject.getInstance(Constant.DATANAME_AGG_RESULT);
|
// EntitySet tableEntitySet = aggResultDataObject.getTableEntitySet();
|
// for (Entity entity : tableEntitySet) {
|
// doAggOneResult(entity, null);
|
// }
|
// }
|
|
private void parseAggDimension(String dimensionKey) throws Exception {
|
dimensionList = new MapList<String, AggDimension>();
|
peroidDimensionList = new ArrayList<AggDimension>();
|
territoryDimensionList = new ArrayList<AggDimension>();
|
|
if (Util.isEmpty(dimensionKey)){
|
return ;
|
}
|
|
String[] dimensions = dimensionKey.split(",");
|
|
for (String dimension : dimensions) {
|
AggDimension aggDimension = AggDimensionBucket.getOne(dimension);
|
dimensionList.add(aggDimension.getCode(), aggDimension);
|
|
if (aggDimension.isPeroid()) {
|
peroidDimensionList.add(aggDimension);
|
}
|
|
else if (DimensionGroup.territory == aggDimension.getDimensionGroup()) {
|
territoryDimensionList.add(aggDimension);
|
}
|
}
|
}
|
|
public String getStepCode() {
|
return stepCode;
|
}
|
|
public List<AggDimension> getPeroidDimensionList() {
|
return peroidDimensionList;
|
}
|
|
public void writeLog(int orderNo, String sqlName, int execCnt) throws Exception {
|
DataObject logObject = DataObject.getInstance("report_log");
|
EntitySaver saver = logObject.createEntitySaver();
|
|
saver.set("report_name", resultId);
|
saver.set("dataname", dataName);
|
saver.set("order_no", orderNo);
|
saver.set("sql_name", sqlName);
|
saver.set("exec_cnt", execCnt);
|
|
saver.insert();
|
}
|
}
|
