363 lines
16 KiB
JavaScript
Generated
363 lines
16 KiB
JavaScript
Generated
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ecSimpleTransform = {}));
|
|
}(this, (function (exports) { 'use strict';
|
|
|
|
var transform = {
|
|
type: 'ecSimpleTransform:id',
|
|
transform: function (params) {
|
|
var upstream = params.upstream;
|
|
var config = params.config;
|
|
var dimensionIndex = config.dimensionIndex;
|
|
var dimensionName = config.dimensionName;
|
|
var dimsDef = upstream.cloneAllDimensionInfo();
|
|
dimsDef[dimensionIndex] = dimensionName;
|
|
var data = upstream.cloneRawData();
|
|
for (var i = 0, len = data.length; i < len; i++) {
|
|
var line = data[i];
|
|
line[dimensionIndex] = i;
|
|
}
|
|
return {
|
|
dimensions: dimsDef,
|
|
data: data
|
|
};
|
|
}
|
|
};
|
|
|
|
function assert(condition, message) {
|
|
if (!condition) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
function hasOwn(own, prop) {
|
|
return own.hasOwnProperty(prop);
|
|
}
|
|
function quantile(ascArr, p) {
|
|
var H = (ascArr.length - 1) * p + 1;
|
|
var h = Math.floor(H);
|
|
var v = +ascArr[h - 1];
|
|
var e = H - h;
|
|
return e ? v + e * (ascArr[h] - v) : v;
|
|
}
|
|
|
|
var METHOD_INTERNAL = {
|
|
'SUM': true,
|
|
'COUNT': true,
|
|
'FIRST': true,
|
|
'AVERAGE': true,
|
|
'Q1': true,
|
|
'Q2': true,
|
|
'Q3': true,
|
|
'MIN': true,
|
|
'MAX': true
|
|
};
|
|
var METHOD_NEEDS_COLLECT = {
|
|
AVERAGE: ['COUNT']
|
|
};
|
|
var METHOD_NEEDS_GATHER_VALUES = {
|
|
Q1: true,
|
|
Q2: true,
|
|
Q3: true
|
|
};
|
|
var METHOD_ALIAS = {
|
|
MEDIAN: 'Q2'
|
|
};
|
|
var ResultDimInfoInternal = (function () {
|
|
function ResultDimInfoInternal(index, indexInUpstream, method, name, needGatherValues) {
|
|
this.collectionInfoList = [];
|
|
this.gatheredValuesByGroup = {};
|
|
this.gatheredValuesNoGroup = [];
|
|
this.needGatherValues = false;
|
|
this._collectionInfoMap = {};
|
|
this.method = method;
|
|
this.name = name;
|
|
this.index = index;
|
|
this.indexInUpstream = indexInUpstream;
|
|
this.needGatherValues = needGatherValues;
|
|
}
|
|
ResultDimInfoInternal.prototype.addCollectionInfo = function (item) {
|
|
this._collectionInfoMap[item.method] = this.collectionInfoList.length;
|
|
this.collectionInfoList.push(item);
|
|
};
|
|
ResultDimInfoInternal.prototype.getCollectionInfo = function (method) {
|
|
return this.collectionInfoList[this._collectionInfoMap[method]];
|
|
};
|
|
ResultDimInfoInternal.prototype.gatherValue = function (groupByDimInfo, groupVal, value) {
|
|
value = +value;
|
|
if (groupByDimInfo) {
|
|
if (groupVal != null) {
|
|
var groupValStr = groupVal + '';
|
|
var values = this.gatheredValuesByGroup[groupValStr]
|
|
|| (this.gatheredValuesByGroup[groupValStr] = []);
|
|
values.push(value);
|
|
}
|
|
}
|
|
else {
|
|
this.gatheredValuesNoGroup.push(value);
|
|
}
|
|
};
|
|
return ResultDimInfoInternal;
|
|
}());
|
|
var transform$1 = {
|
|
type: 'ecSimpleTransform:aggregate',
|
|
transform: function (params) {
|
|
var upstream = params.upstream;
|
|
var config = params.config;
|
|
var groupByDimInfo = prepareGroupByDimInfo(config, upstream);
|
|
var _a = prepareDimensions(config, upstream, groupByDimInfo), finalResultDimInfoList = _a.finalResultDimInfoList, collectionDimInfoList = _a.collectionDimInfoList;
|
|
var collectionResult;
|
|
if (collectionDimInfoList.length) {
|
|
collectionResult = travel(groupByDimInfo, upstream, collectionDimInfoList, createCollectionResultLine, updateCollectionResultLine);
|
|
}
|
|
for (var i = 0; i < collectionDimInfoList.length; i++) {
|
|
var dimInfo = collectionDimInfoList[i];
|
|
dimInfo.__collectionResult = collectionResult;
|
|
asc(dimInfo.gatheredValuesNoGroup);
|
|
var gatheredValuesByGroup = dimInfo.gatheredValuesByGroup;
|
|
for (var key in gatheredValuesByGroup) {
|
|
if (hasOwn(gatheredValuesByGroup, key)) {
|
|
asc(gatheredValuesByGroup[key]);
|
|
}
|
|
}
|
|
}
|
|
var finalResult = travel(groupByDimInfo, upstream, finalResultDimInfoList, createFinalResultLine, updateFinalResultLine);
|
|
var dimensions = [];
|
|
for (var i = 0; i < finalResultDimInfoList.length; i++) {
|
|
dimensions.push(finalResultDimInfoList[i].name);
|
|
}
|
|
return {
|
|
dimensions: dimensions,
|
|
data: finalResult.outList
|
|
};
|
|
}
|
|
};
|
|
function prepareDimensions(config, upstream, groupByDimInfo) {
|
|
var resultDimensionsConfig = config.resultDimensions;
|
|
var finalResultDimInfoList = [];
|
|
var collectionDimInfoList = [];
|
|
var gIndexInLine = 0;
|
|
for (var i = 0; i < resultDimensionsConfig.length; i++) {
|
|
var resultDimInfoConfig = resultDimensionsConfig[i];
|
|
var dimInfoInUpstream = upstream.getDimensionInfo(resultDimInfoConfig.from);
|
|
assert(dimInfoInUpstream, 'Can not find dimension by `from`: ' + resultDimInfoConfig.from);
|
|
var rawMethod = resultDimInfoConfig.method;
|
|
assert(groupByDimInfo.index !== dimInfoInUpstream.index || rawMethod == null, "Dimension " + dimInfoInUpstream.name + " is the \"groupBy\" dimension, must not have any \"method\".");
|
|
var method = normalizeMethod(rawMethod);
|
|
assert(method, 'method is required');
|
|
var name_1 = resultDimInfoConfig.name != null ? resultDimInfoConfig.name : dimInfoInUpstream.name;
|
|
var finalResultDimInfo = new ResultDimInfoInternal(finalResultDimInfoList.length, dimInfoInUpstream.index, method, name_1, hasOwn(METHOD_NEEDS_GATHER_VALUES, method));
|
|
finalResultDimInfoList.push(finalResultDimInfo);
|
|
var needCollect = false;
|
|
if (hasOwn(METHOD_NEEDS_COLLECT, method)) {
|
|
needCollect = true;
|
|
var collectionTargetMethods = METHOD_NEEDS_COLLECT[method];
|
|
for (var j = 0; j < collectionTargetMethods.length; j++) {
|
|
finalResultDimInfo.addCollectionInfo({
|
|
method: collectionTargetMethods[j],
|
|
indexInLine: gIndexInLine++
|
|
});
|
|
}
|
|
}
|
|
if (hasOwn(METHOD_NEEDS_GATHER_VALUES, method)) {
|
|
needCollect = true;
|
|
}
|
|
if (needCollect) {
|
|
collectionDimInfoList.push(finalResultDimInfo);
|
|
}
|
|
}
|
|
return { collectionDimInfoList: collectionDimInfoList, finalResultDimInfoList: finalResultDimInfoList };
|
|
}
|
|
function prepareGroupByDimInfo(config, upstream) {
|
|
var groupByConfig = config.groupBy;
|
|
var groupByDimInfo;
|
|
if (groupByConfig != null) {
|
|
groupByDimInfo = upstream.getDimensionInfo(groupByConfig);
|
|
assert(groupByDimInfo, 'Can not find dimension by `groupBy`: ' + groupByConfig);
|
|
}
|
|
return groupByDimInfo;
|
|
}
|
|
function travel(groupByDimInfo, upstream, resultDimInfoList, doCreate, doUpdate) {
|
|
var outList = [];
|
|
var mapByGroup;
|
|
if (groupByDimInfo) {
|
|
mapByGroup = {};
|
|
for (var dataIndex = 0, len = upstream.count(); dataIndex < len; dataIndex++) {
|
|
var groupByVal = upstream.retrieveValue(dataIndex, groupByDimInfo.index);
|
|
if (groupByVal == null) {
|
|
continue;
|
|
}
|
|
var groupByValStr = groupByVal + '';
|
|
if (!hasOwn(mapByGroup, groupByValStr)) {
|
|
var newLine = doCreate(upstream, dataIndex, resultDimInfoList, groupByDimInfo, groupByVal);
|
|
outList.push(newLine);
|
|
mapByGroup[groupByValStr] = newLine;
|
|
}
|
|
else {
|
|
var targetLine = mapByGroup[groupByValStr];
|
|
doUpdate(upstream, dataIndex, targetLine, resultDimInfoList, groupByDimInfo, groupByVal);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
var targetLine = doCreate(upstream, 0, resultDimInfoList);
|
|
outList.push(targetLine);
|
|
for (var dataIndex = 1, len = upstream.count(); dataIndex < len; dataIndex++) {
|
|
doUpdate(upstream, dataIndex, targetLine, resultDimInfoList);
|
|
}
|
|
}
|
|
return { mapByGroup: mapByGroup, outList: outList };
|
|
}
|
|
function normalizeMethod(method) {
|
|
if (method == null) {
|
|
return 'FIRST';
|
|
}
|
|
var methodInternal = method.toUpperCase();
|
|
methodInternal = hasOwn(METHOD_ALIAS, methodInternal)
|
|
? METHOD_ALIAS[methodInternal]
|
|
: methodInternal;
|
|
assert(hasOwn(METHOD_INTERNAL, methodInternal), "Illegal method " + method + ".");
|
|
return methodInternal;
|
|
}
|
|
var createCollectionResultLine = function (upstream, dataIndex, collectionDimInfoList, groupByDimInfo, groupByVal) {
|
|
var newLine = [];
|
|
for (var i = 0; i < collectionDimInfoList.length; i++) {
|
|
var dimInfo = collectionDimInfoList[i];
|
|
var collectionInfoList = dimInfo.collectionInfoList;
|
|
for (var j = 0; j < collectionInfoList.length; j++) {
|
|
var collectionInfo = collectionInfoList[j];
|
|
newLine[collectionInfo.indexInLine] = +lineCreator[collectionInfo.method](upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
|
|
}
|
|
if (dimInfo.needGatherValues) {
|
|
var val = upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
|
|
dimInfo.gatherValue(groupByDimInfo, groupByVal, val);
|
|
}
|
|
}
|
|
return newLine;
|
|
};
|
|
var updateCollectionResultLine = function (upstream, dataIndex, targetLine, collectionDimInfoList, groupByDimInfo, groupByVal) {
|
|
for (var i = 0; i < collectionDimInfoList.length; i++) {
|
|
var dimInfo = collectionDimInfoList[i];
|
|
var collectionInfoList = dimInfo.collectionInfoList;
|
|
for (var j = 0; j < collectionInfoList.length; j++) {
|
|
var collectionInfo = collectionInfoList[j];
|
|
var indexInLine = collectionInfo.indexInLine;
|
|
targetLine[indexInLine] = +lineUpdater[collectionInfo.method](targetLine[indexInLine], upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
|
|
}
|
|
if (dimInfo.needGatherValues) {
|
|
var val = upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
|
|
dimInfo.gatherValue(groupByDimInfo, groupByVal, val);
|
|
}
|
|
}
|
|
};
|
|
var createFinalResultLine = function (upstream, dataIndex, finalResultDimInfoList, groupByDimInfo, groupByVal) {
|
|
var newLine = [];
|
|
for (var i = 0; i < finalResultDimInfoList.length; i++) {
|
|
var dimInfo = finalResultDimInfoList[i];
|
|
var method = dimInfo.method;
|
|
newLine[i] = isGroupByDimension(groupByDimInfo, dimInfo)
|
|
? groupByVal
|
|
: lineCreator[method](upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
|
|
}
|
|
return newLine;
|
|
};
|
|
var updateFinalResultLine = function (upstream, dataIndex, targetLine, finalResultDimInfoList, groupByDimInfo, groupByVal) {
|
|
for (var i = 0; i < finalResultDimInfoList.length; i++) {
|
|
var dimInfo = finalResultDimInfoList[i];
|
|
if (isGroupByDimension(groupByDimInfo, dimInfo)) {
|
|
continue;
|
|
}
|
|
var method = dimInfo.method;
|
|
targetLine[i] = lineUpdater[method](targetLine[i], upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
|
|
}
|
|
};
|
|
function isGroupByDimension(groupByDimInfo, targetDimInfo) {
|
|
return groupByDimInfo && targetDimInfo.indexInUpstream === groupByDimInfo.index;
|
|
}
|
|
function asc(list) {
|
|
list.sort(function (a, b) {
|
|
return a - b;
|
|
});
|
|
}
|
|
var lineCreator = {
|
|
'SUM': function () {
|
|
return 0;
|
|
},
|
|
'COUNT': function () {
|
|
return 1;
|
|
},
|
|
'FIRST': function (upstream, dataIndex, dimInfo) {
|
|
return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
|
|
},
|
|
'MIN': function (upstream, dataIndex, dimInfo) {
|
|
return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
|
|
},
|
|
'MAX': function (upstream, dataIndex, dimInfo) {
|
|
return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
|
|
},
|
|
'AVERAGE': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
|
|
var collectLine = groupByDimInfo
|
|
? dimInfo.__collectionResult.mapByGroup[groupByVal + '']
|
|
: dimInfo.__collectionResult.outList[0];
|
|
return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream)
|
|
/ collectLine[dimInfo.getCollectionInfo('COUNT').indexInLine];
|
|
},
|
|
'Q1': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
|
|
return lineCreatorForQ(0.25, dimInfo, groupByDimInfo, groupByVal);
|
|
},
|
|
'Q2': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
|
|
return lineCreatorForQ(0.5, dimInfo, groupByDimInfo, groupByVal);
|
|
},
|
|
'Q3': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
|
|
return lineCreatorForQ(0.75, dimInfo, groupByDimInfo, groupByVal);
|
|
}
|
|
};
|
|
var lineUpdater = {
|
|
'SUM': function (val, upstream, dataIndex, dimInfo) {
|
|
return val + upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
|
|
},
|
|
'COUNT': function (val) {
|
|
return val + 1;
|
|
},
|
|
'FIRST': function (val) {
|
|
return val;
|
|
},
|
|
'MIN': function (val, upstream, dataIndex, dimInfo) {
|
|
return Math.min(val, upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream));
|
|
},
|
|
'MAX': function (val, upstream, dataIndex, dimInfo) {
|
|
return Math.max(val, upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream));
|
|
},
|
|
'AVERAGE': function (val, upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
|
|
var collectLine = groupByDimInfo
|
|
? dimInfo.__collectionResult.mapByGroup[groupByVal + '']
|
|
: dimInfo.__collectionResult.outList[0];
|
|
return val
|
|
+ upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream)
|
|
/ collectLine[dimInfo.getCollectionInfo('COUNT').indexInLine];
|
|
},
|
|
'Q1': function (val, upstream, dataIndex, dimInfo) {
|
|
return val;
|
|
},
|
|
'Q2': function (val, upstream, dataIndex, dimInfo) {
|
|
return val;
|
|
},
|
|
'Q3': function (val, upstream, dataIndex, dimInfo) {
|
|
return val;
|
|
}
|
|
};
|
|
function lineCreatorForQ(percent, dimInfo, groupByDimInfo, groupByVal) {
|
|
var gatheredValues = groupByDimInfo
|
|
? dimInfo.gatheredValuesByGroup[groupByVal + '']
|
|
: dimInfo.gatheredValuesNoGroup;
|
|
return quantile(gatheredValues, percent);
|
|
}
|
|
|
|
exports.aggregate = transform$1;
|
|
exports.id = transform;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|
|
//# sourceMappingURL=index.js.map
|