protected function finalizeRequest4Total(AbstractQueryRequest $request, AbstractQueryRequest $request4Total, array $columnNames4Total) {
$totalExpressions = $request4Total->getOption(self::OPTION__TOTAL_FORMULA_EXPRESSION);
// preparing returned columns
$columnIndex = 0;
// ... TODO existing dimensions (to support non-additive measures)
/*
if (isset($request->dimensions)) {
foreach ($request->dimensions as $dimension) {
if (isset($dimension->columns)) {
foreach ($dimension->columns as $column) {
$request4Total->addDimensionColumn($columnIndex++, $dimension->name, $column->name);
}
}
else {
$formula = $request->getFormula($dimension->name);
if (isset($formula)) {
// checking if the formula contains reference to TOTAL function
if (isset($totalExpressions[$formula->name])) {
// excluding the formula
continue;
}
}
$request4Total->addDimension($columnIndex++, $dimension->name);
}
}
} */
// ... measures to calculate total
foreach ($columnNames4Total as $measureName) {
$formula = $request4Total->getFormula($measureName);
// TODO checking if the formula expression contains any aggregation functions (eliminate when non-additive measures are supported)
$handler = FormulaExpressionLanguageFactory::getInstance()->getHandler($formula->expressionLanguage);
$lexemes = $handler->lex($formula->source);
$syntaxTree = $handler->parse($lexemes);
$isMeasure = $handler->isMeasure($syntaxTree);
if (!isset($isMeasure) || !$isMeasure) {
// updating expression to summarize data for the expression
$formula->source = 'SUM(' . $formula->source . ')';
}
$formula->isMeasure = TRUE;
$request4Total->addMeasure($columnIndex++, $measureName);
}
// preparing data querying
$dimensionQueries = $request->findDimensionQueries();
if (isset($dimensionQueries)) {
foreach ($dimensionQueries as $query) {
foreach ($query->columns as $queryColumn) {
$request4Total->addDimensionColumnQueryValues($query->name, $queryColumn->name, $queryColumn->values);
}
}
}
$factsDatasetColumnQueries = $request->findFactsDatasetColumnQueries();
if (isset($factsDatasetColumnQueries)) {
foreach ($factsDatasetColumnQueries as $query) {
$request4Total->addFactsDatasetColumnQueryValues($query->name, $query->values);
}
}
$measureQueries = $request->findMeasureQueries();
if (isset($measureQueries)) {
foreach ($measureQueries as $query) {
$formula = $request->getFormula($query->name);
if (isset($formula)) {
// checking if the formula contains reference to TOTAL function
if (isset($totalExpressions[$formula->name])) {
// excluding the condition
continue;
}
}
$request4Total->addMeasureQueryValues($query->name, $query->values);
}
}
}
public function __construct($expressionLanguage = NULL) {
parent::__construct();
$this->expressionLanguageHandler = FormulaExpressionLanguageFactory::getInstance()->getHandler($expressionLanguage);
}
public static function cleanFunctionParameters($datasetName, $columns, $parameters, $orderBy, array $options = NULL) {
$metamodel = data_controller_get_metamodel();
$dataset = $metamodel->getDataset($datasetName);
$cleanedColumns = ArrayHelper::trim($columns);
$cleanedParameters = NULL;
if (isset($parameters)) {
foreach ($parameters as $key => $value) {
$key = StringHelper::trim($key);
// ignoring system parameters
list($elementNameSpace) = AbstractDatasetUIMetaDataGenerator::splitElementUIMetaDataName($key);
if (!isset($elementNameSpace)) {
continue;
}
$cleanedParameters[$key] = $value;
}
}
$cleanedOrderBy = NULL;
ArrayHelper::addUniqueValues($cleanedOrderBy, ArrayHelper::trim($orderBy));
$cleanedOptions = NULL;
if (isset($options)) {
foreach ($options as $name => $option) {
$cleanedOption = NULL;
if (isset($option)) {
if ($name == AbstractQueryRequest::OPTION__FORMULA_DEF) {
// cleaning all formulas
foreach ($option as $index => $formula) {
$cleanedFormula = clone $formula;
$parser = new FormulaExpressionParser($cleanedFormula->expressionLanguage);
$cleanedFormula->source = $parser->parse($cleanedFormula->source, 'DatasetUIMetaDataQueryHelper::cleanFormulaExpressionColumnNames');
$cleanedOption[$index] = $cleanedFormula;
}
// assembling clean formulas to calculate 'measure' flag
if (isset($cleanedOption)) {
$columnReferenceFactory = new CompositeColumnReferenceFactory(array(
$dataset,
new FormulaReferenceFactory($cleanedOption)));
$expressionAssembler = new FormulaExpressionAssembler($columnReferenceFactory);
foreach ($cleanedOption as $index => $cleanedFormula) {
// assembling full expressions to detect if any aggregation function present
$expression = $expressionAssembler->assemble($cleanedFormula);
// process the formula expression
$handler = FormulaExpressionLanguageFactory::getInstance()->getHandler($cleanedFormula->expressionLanguage);
$lexemes = $handler->lex($expression);
$syntaxTree = $handler->parse($lexemes);
// checking if the formula expression contains references to any aggregation functions
$cleanedFormula->isMeasure = $handler->isMeasure($syntaxTree);
}
}
}
elseif (is_array($option)) {
$cleanedOption = ArrayHelper::copy($option);
}
elseif (is_object($option)) {
$cleanedOption = clone $option;
}
else {
$cleanedOption = $option;
}
}
if (isset($cleanedOption)) {
$cleanedOptions[$name] = $cleanedOption;
}
}
}
// adjusting list of columns we need to return
$requestedColumnNames = NULL;
// preparing list of unique column names
ArrayHelper::addUniqueValues($requestedColumnNames, $cleanedColumns);
// adding columns which are used to sort result
if ($cleanedOrderBy) {
foreach ($cleanedOrderBy as $directionalColumnName) {
list($columnName, $isSortAscending) = ColumnBasedComparator_AbstractSortingConfiguration::parseDirectionalColumnName($directionalColumnName);
ArrayHelper::addUniqueValue($requestedColumnNames, $columnName);
}
}
return array($requestedColumnNames, $cleanedParameters, $cleanedOrderBy, $cleanedOptions);
}
public function __construct() {
parent::__construct();
$this->handlerConfigurations = module_invoke_all('dp_formula_expression_language');
}
