protected function detectParameterKind(AbstractCubeQueryRequest $request, CubeMetaData $cube, $parameterName) {
$metamodel = data_controller_get_metamodel();
list($rootName, $leafName) = ParameterNameHelper::split($parameterName);
list($referencedDatasetName, $referencedRootName) = ReferencePathHelper::splitReference($rootName);
// checking that referenced cube exists
$referencedCube = isset($referencedDatasetName)
? $metamodel->getCubeByDatasetName($referencedDatasetName)
: NULL;
$selectedCube = isset($referencedCube) ? $referencedCube : $cube;
$selectedRequest = isset($referencedCube) ? $request->registerReferencedRequest($referencedCube->name) : $request;
// detecting type of the parameter: dimension or measure
$isDimension = $isMeasure = FALSE;
if (isset($leafName)) {
// if dimension column exists - dimension exists too :)
$isDimension = TRUE;
}
else {
// trying to find a measure
$measure = $selectedCube->findMeasure($referencedRootName);
if (isset($measure)) {
$isMeasure = TRUE;
}
else {
$formula = $request->findFormula($referencedRootName);
if (isset($formula)) {
if (isset($formula->isMeasure) && $formula->isMeasure) {
$isMeasure = TRUE;
}
else {
$isDimension = TRUE;
}
}
}
// trying to find a dimension
$dimension = $selectedCube->findDimension($referencedRootName);
if (isset($dimension)) {
$isDimension = TRUE;
}
}
if ($isDimension && $isMeasure) {
throw new IllegalArgumentException(t(
'The parameter refers to both a dimension and a measure: %parameterName',
array('%parameterName' => $parameterName)));
}
if ($isDimension) {
if (isset($referencedCube)) {
throw new IllegalArgumentException(t('Referenced dimensions are not supported yet'));
}
}
return array($selectedRequest, $isDimension, $isMeasure, $referencedRootName, $leafName);
}
protected function selectBoundary4CubeRequest(DataControllerCallContext $callcontext, AbstractCubeQueryRequest $request, $datasetName, $columnName) {
$isSortAscending = $this->isSortAscending();
$resultColumnName = NULL;
// preparing new cube meta data
$expressionRequest = new CubeQueryRequest($request->getCubeName());
// needs to be called before any additional methods are called
$expressionRequest->addOptions($request->options);
// copying ONLY some query objects (excluding at least a reference to this operator)
// -- dimension queries
$dimensionQueries = $request->findDimensionQueries();
if (isset($dimensionQueries)) {
foreach ($dimensionQueries as $query) {
foreach ($query->columns as $queryColumn) {
foreach ($queryColumn->values as $value) {
if ($this->shouldValueBeSkipped($value)) {
continue;
}
// updating request configuration for the value supported by this class
if ($this->operatorHandler === $value) {
$resultColumnName = ParameterNameHelper::assemble($query->name, $queryColumn->name);
// returning only observing column of the dimension
$expressionRequest->addDimensionColumn(0, $query->name, $queryColumn->name);
// ... and excluding NULL values from evaluation
$expressionRequest->addDimensionColumnQueryValue(
$query->name, $queryColumn->name,
OperatorFactory::getInstance()->initiateHandler(NotEqualOperatorHandler::OPERATOR__NAME, NULL));
// sorting data
$expressionRequest->addOrderByColumn(
ColumnBasedComparator_AbstractSortingConfiguration::assembleDirectionalColumnName($resultColumnName, $isSortAscending));
}
else {
$expressionRequest->addDimensionColumnQueryValue($query->name, $queryColumn->name, $value);
}
}
}
}
}
// -- facts dataset column queries
$factsDatasetColumnQueries = $request->findFactsDatasetColumnQueries();
if (isset($factsDatasetColumnQueries)) {
foreach ($factsDatasetColumnQueries as $query) {
$values = NULL;
foreach ($query->values as $value) {
if ($this->shouldValueBeSkipped($value)) {
continue;
}
if ($this->operatorHandler === $value) {
$metamodel = data_controller_get_metamodel();
$cube = $metamodel->getCube($expressionRequest->getCubeName());
// finding dimension associated with this fact column
$selectedDimension = NULL;
if (isset($cube->dimensions)) {
foreach ($cube->dimensions as $dimension) {
if ($dimension->attributeColumnName == $query->name) {
$selectedDimension = $dimension;
break;
}
}
}
if (!isset($selectedDimension)) {
throw new IllegalArgumentException(t(
'Boundary-related operator cannot be applied to the facts dataset column: %columnName',
array('%columnName' => $query->name)));
}
$resultColumnName = ParameterNameHelper::assemble($selectedDimension->name);
// returning only observing column from facts dataset
$expressionRequest->addDimension(0, $selectedDimension->name);
// ... and excluding NULL values from evaluation
$expressionRequest->addFactsDatasetColumnQueryValue(
$query->name,
OperatorFactory::getInstance()->initiateHandler(NotEqualOperatorHandler::OPERATOR__NAME, NULL));
// sorting data
$expressionRequest->addOrderByColumn(
ColumnBasedComparator_AbstractSortingConfiguration::assembleDirectionalColumnName($resultColumnName, $isSortAscending));
}
else {
$values[] = $value;
}
}
if (isset($values)) {
$expressionRequest->addFactsDatasetColumnQueryValues($query->name, $values);
}
}
}
// -- measure queries
$measureQueries = $request->findMeasureQueries();
if (isset($measureQueries)) {
foreach ($measureQueries as $query) {
foreach ($query->values as $value) {
if ($this->shouldValueBeSkipped($value)) {
throw new IllegalArgumentException(t('Boundary-related operator cannot be applied to measures'));
}
}
$expressionRequest->queries[] = clone $query;
}
}
// limiting response to one record
$expressionRequest->setPagination(1, 0);
return $this->processCubeExpressionRequest($callcontext, $expressionRequest, $resultColumnName);
}
public function importMeasureQueriesFrom(AbstractCubeQueryRequest $sourceQueryRequest) {
$sourceMeasureQueries = $sourceQueryRequest->findMeasureQueries();
if (isset($sourceMeasureQueries)) {
foreach ($sourceMeasureQueries as $sourceMeasureQuery) {
$this->importMeasureQueryFrom($sourceMeasureQuery);
}
}
}
protected function prepareSelectedCubeQueryStatement(AbstractSQLDataSourceQueryHandler $datasourceHandler, DataControllerCallContext $callcontext, AbstractCubeQueryRequest $request) {
$metamodel = data_controller_get_metamodel();
// loading cube configuration
$cubeName = $request->getCubeName();
$cube = $metamodel->getCube($cubeName);
$factsDataset = $metamodel->getDataset($cube->factsDatasetName);
$generationContext = $this->prepareStatementGenerationContext($request, $cube);
$TABLE_ALIAS__SOURCE = 's';
// to store configuration for each accessed table
$datasetConfigs = NULL;
// preparing facts dataset configuration
$this->registerDatasetConfig($datasetConfigs, 0, $factsDataset, NULL, NULL);
$columnReferenceFactory = new CompositeColumnReferenceFactory(array(
$cube->factsDataset,
new FormulaReferenceFactory($request->getFormulas())));
$expressionAssembler = new FormulaExpressionAssembler($columnReferenceFactory);
// statement for aggregation portion of final sql
$aggrStatement = new Statement();
// adding support for facts dataset column queries
$factsDatasetColumnQueries = $request->findFactsDatasetColumnQueries();
if (isset($factsDatasetColumnQueries)) {
foreach ($factsDatasetColumnQueries as $queryColumn) {
foreach ($queryColumn->values as $value) {
$this->registerDatasetConfig($datasetConfigs, 0, NULL, $queryColumn->name, NULL);
$aggrStatement->conditions[] = new WhereConditionSection(
$TABLE_ALIAS__SOURCE . '0',
$queryColumn->name,
new ExactConditionSectionValue(
$datasourceHandler->formatOperatorValue($callcontext, $request, $factsDataset->name, $queryColumn->name, $value)));
}
}
}
$possibleDimensions = NULL;
// adding dimensions from a cube
if (isset($cube->dimensions)) {
foreach ($cube->dimensions as $dimension) {
$possibleDimensions[$dimension->name] = $dimension;
}
}
// creating 'virtual' dimensions from formulas
if (isset($request->dimensions)) {
foreach ($request->dimensions as $selectedDimension) {
// it is predefined dimension
if (isset($possibleDimensions[$selectedDimension->name])) {
continue;
}
// it could be a 'virtual' dimension defined by a formula
$formula = $request->findFormula($selectedDimension->name);
if (!isset($formula)) {
continue;
}
// defining 'virtual dimension'
$formulaDimension = new DimensionMetaData();
$formulaDimension->name = $selectedDimension->name;
$formulaDimension->attributeColumnName = $selectedDimension->name;
$possibleDimensions[$formulaDimension->name] = $formulaDimension;
}
}
// FIXME why do we start with 1?
$tableIndex = 1 + count($possibleDimensions);
// preparing list of columns which are required to group data for the aggregation
$aggrSelectColumns = NULL;
// preparing list of measures which are calculated in the aggregation, preparing support for measure conditions
$aggrSelectMeasureColumns = NULL;
if (isset($possibleDimensions)) {
foreach ($possibleDimensions as $dimension) {
$dimensionName = $dimension->name;
$selectedDimension = $request->findDimension($dimensionName);
$queriedDimension = $request->findDimensionQuery($dimensionName);
if (!isset($selectedDimension) && !isset($queriedDimension)) {
continue;
}
$factsColumn = $factsDataset->findColumn($dimension->attributeColumnName);
$selectedColumnNames = isset($selectedDimension) ? $selectedDimension->getColumnNames() : NULL;
list($selectedFactsColumnNames, $selectedDimensionColumnNames) = isset($selectedColumnNames) && isset($factsColumn)
? $this->detectColumnNameOwner($factsColumn, $selectedColumnNames)
: array(NULL, $selectedColumnNames);
$queriedColumnNames = isset($queriedDimension) ? $queriedDimension->getColumnNames() : NULL;
list($queriedFactsColumnNames, $queriedDimensionColumnNames) = isset($queriedColumnNames) && isset($factsColumn)
? $this->detectColumnNameOwner($factsColumn, $queriedColumnNames)
: array(NULL, $queriedColumnNames);
$isJoinWithDimensionDatasetRequired = (isset($queriedDimension) && isset($queriedColumnNames) && (isset($dimension->datasetName) || isset($queriedDimensionColumnNames)))
|| (
isset($generationContext->dimensionJoinPhase[__DefaultQueryEngine_StatementGenerationContext::DIMENSION_JOIN_PHASE__GROUPING_INITIAL][$dimensionName])
&& $generationContext->dimensionJoinPhase[__DefaultQueryEngine_StatementGenerationContext::DIMENSION_JOIN_PHASE__GROUPING_INITIAL][$dimensionName]);
$dimensionDataset = NULL;
if (isset($dimension->datasetName)) {
$dimensionDataset = $metamodel->getDataset($dimension->datasetName);
}
elseif ($isJoinWithDimensionDatasetRequired) {
// 02/26/2014 there could be a case when dimension dataset does not exist but we try to connect with extension table using PK-to-PK connection
$dimensionDataset = $factsDataset;
}
$keyColumnName = isset($dimensionDataset)
? $dimensionDataset->getKeyColumn()->name
: (isset($dimension->key) ? $dimension->key : NULL);
// joining with dimension dataset ... if necessary
if ($isJoinWithDimensionDatasetRequired) {
// registering the dimension dataset
$tableIndex--;
$this->registerDatasetConfig($datasetConfigs, $tableIndex, $dimensionDataset, NULL, NULL);
if (isset($queriedDimensionColumnNames)) {
foreach ($queriedDimension->columns as $queryColumn) {
if (!isset($queryColumn->name)) {
continue;
}
if (!in_array($queryColumn->name, $queriedDimensionColumnNames)) {
continue;
}
$this->registerDatasetConfig($datasetConfigs, $tableIndex, NULL, $queryColumn->name, NULL);
foreach ($queryColumn->values as $value) {
$aggrStatement->conditions[] = new WhereConditionSection(
$TABLE_ALIAS__SOURCE . $tableIndex,
$queryColumn->name,
new ExactConditionSectionValue(
$datasourceHandler->formatOperatorValue($callcontext, $request, $dimensionDataset->name, $queryColumn->name, $value)));
}
}
}
// selected columns are part of the dimension dataset
if (isset($selectedDimensionColumnNames)) {
foreach ($selectedDimensionColumnNames as $columnName) {
$responseColumnName = ParameterNameHelper::assemble($dimensionName, $columnName);
$databaseColumnName = DataSourceColumnNameHelper::generateFromParameterElements(
$datasourceHandler->getMaximumEntityNameLength(),
($request->referenced ? ReferencePathHelper::assembleReference($factsDataset->name, $dimensionName) : $dimensionName),
$columnName);
$callcontext->columnMapping[$databaseColumnName] = $responseColumnName;
$this->registerDatasetConfig($datasetConfigs, $tableIndex, $dimensionDataset, $columnName, NULL);
$aggrSelectColumns[$tableIndex][] = new ColumnSection($columnName, $databaseColumnName);
}
}
}
if (isset($selectedFactsColumnNames) || isset($selectedDimension->requestColumnIndex)) {
$responseColumnName = ParameterNameHelper::assemble($dimensionName);
$databaseColumnName = DataSourceColumnNameHelper::generateFromParameterElements(
$datasourceHandler->getMaximumEntityNameLength(),
($request->referenced ? ReferencePathHelper::assembleReference($factsDataset->name, $dimensionName) : $dimensionName));
$callcontext->columnMapping[$databaseColumnName] = $responseColumnName;
// selected columns are part of facts table
if (isset($selectedFactsColumnNames)) {
foreach ($selectedFactsColumnNames as $columnName) {
$responseSelectedColumnName = ParameterNameHelper::assemble($dimensionName, $columnName);
$databaseSelectedColumnName = DataSourceColumnNameHelper::generateFromParameterElements(
$datasourceHandler->getMaximumEntityNameLength(),
($request->referenced ? ReferencePathHelper::assembleReference($factsDataset->name, $dimensionName) : $dimensionName),
$columnName);
$callcontext->columnMapping[$databaseSelectedColumnName] = $responseSelectedColumnName;
$this->registerDatasetConfig($datasetConfigs, 0, NULL, $columnName, NULL);
$aggrSelectColumns[0][] = new ColumnSection($columnName, $databaseSelectedColumnName);
}
}
elseif (isset($selectedDimension->requestColumnIndex)) {
$formula = $request->findFormula($dimension->name);
if (isset($formula)) {
$expression = $expressionAssembler->assemble($formula);
$column = new CompositeColumnSection($expression, $databaseColumnName);
if (isset($formula->isMeasure) && !$formula->isMeasure) {
$aggrSelectColumns[0][] = $column;
}
else {
$aggrSelectMeasureColumns[] = $column;
}
}
else {
$column = new ColumnSection(
DataSourceColumnNameHelper::generateFromParameterElements($datasourceHandler->getMaximumEntityNameLength(), $dimension->attributeColumnName),
$databaseColumnName);
$aggrSelectColumns[0][] = $column;
}
$this->registerDatasetConfig($datasetConfigs, 0, NULL, $dimension->attributeColumnName, NULL);
}
}
// adding facts table conditions
if (isset($queriedDimension)) {
foreach ($queriedDimension->columns as $queryColumn) {
if (isset($queryColumn->name)) {
if (!isset($queriedFactsColumnNames) || !in_array($queryColumn->name, $queriedFactsColumnNames)) {
continue;
}
}
$queryColumnName = isset($queryColumn->name) ? $queryColumn->name : $dimension->attributeColumnName;
$this->registerDatasetConfig($datasetConfigs, 0, NULL, $queryColumnName, NULL);
foreach ($queryColumn->values as $value) {
$aggrStatement->conditions[] = new WhereConditionSection(
$TABLE_ALIAS__SOURCE . 0,
$queryColumnName,
new ExactConditionSectionValue(
$datasourceHandler->formatOperatorValue($callcontext, $request, $factsDataset->name, $queryColumnName, $value)));
}
}
}
// linking the dimension dataset with master source
if ($isJoinWithDimensionDatasetRequired) {
$this->registerDatasetConfig($datasetConfigs, 0, NULL, $dimension->attributeColumnName, NULL);
$this->registerDatasetConfig(
$datasetConfigs,
$tableIndex, NULL,
$keyColumnName,
new JoinConditionSection(
$keyColumnName,
new TableColumnConditionSectionValue($TABLE_ALIAS__SOURCE . '0', $dimension->attributeColumnName)));
}
}
}
// preparing a list of required measures
$selectedMeasureNames = NULL;
if (isset($request->measures)) {
foreach ($request->measures as $measure) {
$selectedMeasureNames[$measure->name] = TRUE;
}
}
$measureQueries = $request->findMeasureQueries();
if (isset($measureQueries)) {
foreach ($measureQueries as $query) {
$selectedMeasureNames[$query->name] = TRUE;
}
}
// adding measures to the statement
if (isset($selectedMeasureNames)) {
foreach ($selectedMeasureNames as $measureName => $flag) {
$measureExpression = NULL;
// checking cube first
$cubeMeasure = $cube->findMeasure($measureName);
if (isset($cubeMeasure)) {
$measureExpression = $cubeMeasure->getFunction();
}
else {
$formula = $request->findFormula($measureName);
$measureExpression = $expressionAssembler->assemble($formula);
}
$selectedMeasure = $request->findMeasure($measureName);
$queriedMeasure = $request->findMeasureQuery($measureName);
if ($request->referenced) {
$measureName = ReferencePathHelper::assembleReference($factsDataset->name, $measureName);
}
$databaseColumnName = DataSourceColumnNameHelper::generateFromParameterElements(
$datasourceHandler->getMaximumEntityNameLength(), $measureName);
$columnSection = new CompositeColumnSection($measureExpression, $databaseColumnName);
if (isset($selectedMeasure)) {
$callcontext->columnMapping[$databaseColumnName] = $measureName;
$aggrSelectMeasureColumns[] = $columnSection;
}
if (isset($queriedMeasure)) {
foreach ($queriedMeasure->values as $value) {
$aggrStatement->havingConditions[] = new HavingConditionSection(
$columnSection,
new ExactConditionSectionValue(
$datasourceHandler->formatOperatorValue($callcontext, $request, $factsDataset->name, NULL, $value)));
}
}
// looking for possible columns in the measure function. We need to retrieve those from the database
$columnNames = $columnSection->parseColumns();
if (isset($columnNames)) {
foreach ($columnNames as $columnName) {
$this->registerDatasetConfig($datasetConfigs, 0, NULL, $columnName, NULL);
}
}
}
}
// sorting configuration to support joins in correct order
ksort($datasetConfigs, SORT_NUMERIC);
// preparing dataset source statements
foreach ($datasetConfigs as $orderIndex => $datasetConfig) {
$tableStatement = $datasourceHandler->prepareDatasetSourceStatement($callcontext, $request, $datasetConfig->dataset, $datasetConfig->usedColumnNames);
// adding join conditions
if (isset($datasetConfig->conditions)) {
foreach ($datasetConfig->conditions as $condition) {
$tableStatement->getColumnTable($condition->subjectColumnName)->conditions[] = $condition;
}
}
// BLOCK 1: finding tables to which we want to attach columns which participate in aggregation
// the code would be simpler if we supported several aliases per column
// if we move the logic to BLOCK 3 getColumnTable(, TRUE) will not work
$selectedAggregationTables = NULL;
if (isset($aggrSelectColumns[$orderIndex])) {
$tableSelectColumns = $aggrSelectColumns[$orderIndex];
foreach ($tableSelectColumns as $aggrColumnIndex => $tableSelectColumn) {
// FIXME check other places to understand why I need to use parameter with TRUE value
// looking for a table in the statement which provides the column for SELECT section
if ($tableSelectColumn instanceof CompositeColumnSection) {
$tableSection = $tableStatement->tables[0];
}
else {
$tableSection = $tableStatement->getColumnTable($tableSelectColumn->name, TRUE);
}
$selectedAggregationTables[$orderIndex][$aggrColumnIndex] = $tableSection;
}
}
// BLOCK 2: we do not need to return any columns from the table by default
foreach ($tableStatement->tables as $table) {
if (isset($table->columns)) {
foreach ($table->columns as $column) {
$column->visible = FALSE;
}
}
else {
$table->columns = array(); // We do not need any columns
}
}
// preparing measures which we want to return. Adding those measures to facts table
if (($orderIndex == 0) && isset($aggrSelectMeasureColumns)) {
foreach ($aggrSelectMeasureColumns as $tableSelectMeasureColumn) {
$columnNames = $tableSelectMeasureColumn->parseColumns();
// searching which table contains the column
$tableSection = NULL;
if (isset($columnNames)) {
foreach ($columnNames as $columnName) {
$formattedColumnAlias = DataSourceColumnNameHelper::generateFromParameterElements(
$datasourceHandler->getMaximumEntityNameLength(), $columnName);
foreach ($tableStatement->tables as $table) {
if ($table->findColumnByAlias($formattedColumnAlias) != NULL) {
if (isset($tableSection)) {
if ($tableSection->alias !== $table->alias) {
// FIXME we should not have such functionality
// checking if the same column is used for several times in a table under different aliases
$tableSectionColumns = $tableSection->findColumns($formattedColumnAlias);
$tableColumns = $table->findColumns($formattedColumnAlias);
$isTableSelected = FALSE;
if (($tableSectionColumns > 0) && ($tableColumns > 0)) {
if ($tableSectionColumns > $tableColumns) {
$tableSection = $table;
$isTableSelected = TRUE;
}
elseif ($tableColumns > $tableSectionColumns) {
$isTableSelected = TRUE;
}
}
if (!$isTableSelected) {
throw new UnsupportedOperationException(t('Aggregation function bases on several tables'));
}
}
}
else {
$tableSection = $table;
}
}
}
}
}
if (!isset($tableSection)) {
$tableSection = $tableStatement->tables[0];
}
$tableSelectMeasureColumn->attachTo($tableSection);
}
}
// updating join statement table aliases
$sourceTableAlias = $TABLE_ALIAS__SOURCE . $orderIndex;
foreach ($tableStatement->tables as $table) {
$oldTableAlias = $table->alias;
$newTableAlias = $sourceTableAlias . (isset($oldTableAlias) ? '_' . $oldTableAlias : '');
$tableStatement->updateTableAlias($oldTableAlias, $newTableAlias);
// TODO Review. Probably is not needed anymore. Updating statement conditions which are used to join levels
foreach ($datasetConfigs as $nextOrderIndex => $nextDatasetConfig) {
if (($nextOrderIndex <= $orderIndex) || !isset($nextDatasetConfig->conditions)) {
continue;
}
foreach ($nextDatasetConfig->conditions as $condition) {
if (($condition instanceof JoinConditionSection)
&& ($condition->joinValue instanceof TableColumnConditionSectionValue)
&& ($condition->joinValue->tableAlias === $sourceTableAlias)
&& (($table->findColumn($condition->joinValue->columnName) != NULL) || (count($tableStatement->tables) === 1))) {
$condition->joinValue->tableAlias = $newTableAlias;
}
}
}
// updating aggregation statement conditions
if (isset($aggrStatement->conditions)) {
foreach ($aggrStatement->conditions as $condition) {
if ($condition->subjectTableAlias != $sourceTableAlias) {
continue;
}
$tableColumn = $table->findColumn($condition->subjectColumnName);
if (!isset($tableColumn)) {
continue;
}
// checking if any other table in the statement support the column as an alias
$otherColumnFound = FALSE;
foreach ($tableStatement->tables as $subjectColumnTable) {
$subjectColumn = $subjectColumnTable->findColumnByAlias($condition->subjectColumnName);
if (isset($subjectColumn) && ($subjectColumn instanceof ColumnSection)) {
if ($subjectColumnTable->alias != $table->alias) {
$condition->subjectTableAlias = $sourceTableAlias . (isset($subjectColumnTable->alias) ? '_' . $subjectColumnTable->alias : '');
$condition->subjectColumnName = $subjectColumn->name;
$otherColumnFound = TRUE;
}
}
}
if (!$otherColumnFound) {
$condition->subjectTableAlias = $newTableAlias;
if ($tableColumn instanceof ColumnSection) {
// $condition->subjectColumnName = $tableColumn->name;
}
}
}
}
}
// BLOCK 3: preparing the table columns which we want to return
if (isset($aggrSelectColumns[$orderIndex])) {
$tableSelectColumns = $aggrSelectColumns[$orderIndex];
foreach ($tableSelectColumns as $aggrColumnIndex => $tableSelectColumn) {
$tableSection = $selectedAggregationTables[$orderIndex][$aggrColumnIndex];
$relatedConditions = NULL;
if (isset($aggrStatement->conditions)) {
foreach ($aggrStatement->conditions as $condition) {
if (($tableSelectColumn instanceof ColumnSection)
&& ($condition->subjectColumnName == $tableSelectColumn->name)
&& ($condition->subjectTableAlias == $tableSection->alias)) {
$relatedConditions[] = $condition;
}
}
}
$attachedColumn = $tableSelectColumn->attachTo($tableSection);
if (isset($relatedConditions)) {
foreach ($relatedConditions as $relatedCondition) {
$relatedCondition->subjectColumnName = $attachedColumn->alias;
}
}
$aggrStatement->groupByColumns[] = new GroupByColumnSection($attachedColumn);
}
}
$aggrStatement->merge($tableStatement);
}
return $aggrStatement;
}
protected function prepareCubeRequestMetaData(AbstractCubeQueryRequest $request) {
$metamodel = data_controller_get_metamodel();
$cube = $metamodel->getCube($request->getCubeName());
$this->getDatasetMetaData($cube->factsDatasetName);
if (isset($request->referencedRequests)) {
foreach ($request->referencedRequests as $referencedRequest) {
$referencedCube = $metamodel->getCube($referencedRequest->getCubeName());
$this->getDatasetMetaData($referencedCube->factsDatasetName);
}
}
}
