public function assembleColumnName($tableAlias) {
$callback = new ColumnStatementCompositeEntityParser__TableAliasUpdater(NULL, $tableAlias, TRUE);
$parser = new FormulaExpressionParser(SQLFormulaExpressionHandler::LANGUAGE__SQL);
return $parser->parse($this->function, array($callback, 'updateTableAlias'));
}
protected function generateFunction($columnPrefix, ColumnMetaData $parentColumn, $configuration, $allowDate, $allowTime) {
if (($configuration['part'] == 'date') && !$allowDate) {
return;
}
if (($configuration['part'] == 'date:fiscal') && (!$allowDate || (FiscalYearConfiguration::$FIRST_MONTH == 1))) {
return;
}
if (($configuration['part'] == 'time') && !$allowTime) {
return;
}
// preparing extension for date value formatting
$key = $this->datasourceHandler->getDataSourceType();
if (!isset($this->dateFormatExtensions[$key])) {
$this->dateFormatExtensions[$key] = $this->datasourceHandler->getExtension('formatDateValue');
}
$dateFormatExtension = $this->dateFormatExtensions[$key];
// preparing expression for calculated column
$extensionMethodName = $configuration['methodName'];
try {
$expression = $dateFormatExtension->$extensionMethodName($this->datasourceHandler);
}
catch (UnsupportedOperationException $e) {
$expression = FALSE;
}
if ($expression === FALSE) {
$column = new ColumnMetaData();
$column->used = FALSE;
}
else {
$formulaExpressionParser = new FormulaExpressionParser(SQLFormulaExpressionHandler::LANGUAGE__SQL);
$column = new FormulaMetaData();
$column->type->applicationType = $configuration['datatype'];
$column->source = str_replace(
array('<columnName>', '<fiscalYearOffset>'),
array(
$formulaExpressionParser->assemble($columnPrefix),
(12 - FiscalYearConfiguration::$FIRST_MONTH + 1)),
$expression);
}
$column->name = $columnPrefix . '__' . $configuration['name'];
$column->publicName = t($configuration['publicName']);
$column->loaderName = get_class($this);
// processing nested elements
if (isset($configuration['elements'])) {
foreach ($configuration['elements'] as $nestedConfiguration) {
$this->generateFunction($columnPrefix, $column, $nestedConfiguration, $allowDate, $allowTime);
}
}
if (($expression !== FALSE) || (count($column->branches) != 0)) {
$parentColumn->branches[] = $column;
}
}
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 replaceColumnNames(ParserCallback $callback, &$callerSession) {
$columnName = $callback->marker;
$column = $this->columnReferenceFactory->getColumn($columnName);
$this->approveColumn4ParticipationInExpression($column);
if ($column->persistence == FormulaMetaData::PERSISTENCE__CALCULATED) {
// checking if the column is already in the stack
if (in_array($column->name, $this->columnAssemblingStack)) {
$columnPublicNames = NULL;
// adding columns from stack
foreach ($this->columnAssemblingStack as $stackColumnName) {
$stackColumn = $this->dataset->getColumn($stackColumnName);
$columnPublicNames[] = $stackColumn->publicName;
}
// adding current processed column
$columnPublicNames[] = $column->publicName;
throw new IllegalStateException(t(
'Circular reference in formula expression is not allowed: %stack',
array('%stack' => ArrayHelper::serialize($columnPublicNames, ', ', TRUE, FALSE))));
}
array_push($this->columnAssemblingStack, $column->name);
$language = isset($column->expressionLanguage) ? $column->expressionLanguage : NULL;
$parser = new FormulaExpressionParser($language);
$expression = $parser->expressionLanguageHandler->clean($column->source);
$callback->marker = $parser->parse($expression, array($this, 'replaceColumnNames'));
array_pop($this->columnAssemblingStack);
$callback->removeDelimiters = TRUE;
}
}
public function assemble(Statement $statement, $useTableNameAsAlias) {
$callback = new ColumnStatementCompositeEntityParser__ColumnNameAdjuster(TRUE);
$parser = new FormulaExpressionParser(SQLFormulaExpressionHandler::LANGUAGE__SQL);
return $parser->parse($this->value, array($callback, 'adjustCallbackObject'));
}
protected static function registerFactMeasure(CubeMetaData $cube, ColumnMetaData $column, $functionName, $additivity, $selectedApplicationType = NULL)
{
$measureName = StarSchemaNamingConvention::getFactRelatedMeasureName($column->name, $functionName);
$measure = $cube->registerMeasure($measureName);
$measure->publicName = t($functionName);
$measure->description = t("System generated '@functionName' measure for '@columnName' column", array('@functionName' => $measure->publicName, '@columnName' => $column->publicName));
$measure->used = FALSE;
$expression = FALSE;
if ($column->persistence == FormulaMetaData::PERSISTENCE__CALCULATED) {
if ($column->isUsed()) {
try {
$expressionAssembler = new FormulaExpressionAssembler($cube->factsDataset);
$expression = $expressionAssembler->assemble($column);
$measure->used = TRUE;
} catch (Exception $e) {
$message = t("@functionName measure assembled with errors. @error", array('@functionName' => $functionName, '@error' => $e->getMessage()));
$measure->functionError = $message;
LogHelper::log_warn($message);
}
} else {
$measure->functionError = t("@functionName measure was not assembled for the unused column", array('@functionName' => $functionName));
}
} else {
$formulaExpressionParser = new FormulaExpressionParser(SQLFormulaExpressionHandler::LANGUAGE__SQL);
$expression = $formulaExpressionParser->assemble($column->name);
$measure->used = TRUE;
}
$measure->function = $expression === FALSE ? FALSE : $functionName . '(' . $expression . ')';
$measure->additivity = $additivity;
$measure->type->applicationType = isset($selectedApplicationType) ? $selectedApplicationType : $column->type->applicationType;
$measure->type->scale = $column->type->scale;
}
