public function __clone() {
parent::__clone();
$this->datasets = ArrayHelper::copy($this->datasets);
$this->references = ArrayHelper::copy($this->references);
$this->cubes = ArrayHelper::copy($this->cubes);
}
public function __clone() {
parent::__clone();
$this->groupByColumnNames = ArrayHelper::copy($this->groupByColumnNames);
$this->subjectColumnNames = ArrayHelper::copy($this->subjectColumnNames);
$this->formattedGroupByColumnNames = ArrayHelper::copy($this->formattedGroupByColumnNames);
$this->formattedSubjectColumnNames = ArrayHelper::copy($this->formattedSubjectColumnNames);
}
public function __clone() {
parent::__clone();
$this->formattedColumnNames = ArrayHelper::copy($this->formattedColumnNames);
if (isset($this->parent)) {
$this->parent = clone $this->parent;
}
}
public function __clone() {
parent::__clone();
$this->datasources = ArrayHelper::copy($this->datasources);
}
public function __clone() {
parent::__clone();
$this->type = clone $this->type;
$this->branches = ArrayHelper::copy($this->branches);
}
public function __clone() {
parent::__clone();
$this->keyColumnNames = ArrayHelper::copy($this->keyColumnNames);
}
public function __clone() {
parent::__clone();
$this->queries = ArrayHelper::copy($this->queries);
$this->sortingConfigurations = ArrayHelper::copy($this->sortingConfigurations);
}
public function __clone() {
parent::__clone();
$this->segmentLinkIds = ArrayHelper::copy($this->segmentLinkIds);
}
public function __clone() {
parent::__clone();
$this->dimensions = ArrayHelper::copy($this->dimensions);
$this->measures = ArrayHelper::copy($this->measures);
}
public function __clone() {
parent::__clone();
$this->referencedRequests = ArrayHelper::copy($this->referencedRequests);
}
public function __clone() {
parent::__clone();
$this->points = ArrayHelper::copy($this->points);
}
public function __clone() {
parent::__clone();
$this->columnMappings = ArrayHelper::copy($this->columnMappings);
}
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 prepareRequest4Total(AbstractQueryRequest $request) {
$expressions = $this->collectTotalExpressions($request);
if (!isset($expressions)) {
return NULL;
}
$uniqueExpressions = NULL;
foreach ($expressions as $formulaName => $totalExpressions) {
ArrayHelper::addUniqueValues($uniqueExpressions, $totalExpressions);
}
// initializing request object
$request4Total = $this->initializeRequest4Total($request);
// preparing options
$request4Total->addOptions(ArrayHelper::copy($request->options));
// adding total expressions
$totalExpressionColumnMapping = NULL;
foreach ($uniqueExpressions as $index => $expression) {
$expressionColumnName = 'sm_total_' . $index;
$formula = new FormulaMetaData();
$formula->name = $expressionColumnName;
$formula->type->applicationType = NumberDataTypeHandler::DATA_TYPE;
$formula->source = $expression;
$request4Total->addFormula($formula);
$totalExpressionColumnMapping[$expressionColumnName] = $expression;
}
$request4Total->addOption(self::OPTION__TOTAL_FORMULA_EXPRESSION, $expressions);
$request4Total->addOption(self::OPTION__TOTAL_EXPRESSION_COLUMN_MAPPING, $totalExpressionColumnMapping);
// finalizing the request
$this->finalizeRequest4Total($request, $request4Total, array_keys($totalExpressionColumnMapping));
return $request4Total;
}
public static function initializeFromDataset(MetaModel $metamodel, DatasetMetaData $dataset)
{
$cubeName = $dataset->name;
$cube = $metamodel->unregisterCube($cubeName);
// preparing cube properties
$cube->description = $dataset->description;
// preparing facts dataset
$factsDataset = $cube->initiateFactsDataset();
$factsDataset->name = $cube->factsDatasetName;
$factsDataset->publicName = $dataset->publicName;
$factsDataset->description = $dataset->description;
$factsDataset->datasourceName = $dataset->datasourceName;
$factsDataset->markAsPrivate();
$factsDataset->source = StarSchemaNamingConvention::getFactsRelatedName($dataset->source);
// calculating facts dataset aliases
if (isset($dataset->aliases)) {
foreach ($dataset->aliases as $alias) {
$factsDataset->aliases[] = StarSchemaNamingConvention::getFactsRelatedName($alias);
}
}
// preparing facts dataset columns and cube dimensions
foreach ($dataset->getColumns(FALSE) as $logicalColumn) {
// we need to preserve original column index
$column = $factsDataset->initiateColumn();
$column->name = $logicalColumn->name;
$column->columnIndex = $logicalColumn->columnIndex;
$column->publicName = $logicalColumn->publicName;
$column->description = $logicalColumn->description;
$column->key = $logicalColumn->key;
$column->persistence = $logicalColumn->persistence;
$column->source = $logicalColumn->source;
$column->visible = $logicalColumn->visible;
$column->used = $logicalColumn->used;
$column->branches = ArrayHelper::copy($logicalColumn->branches);
$factsDataset->registerColumnInstance($column);
self::initializeDimensionFromColumn($metamodel, $cube, $dataset, $logicalColumn->name);
if (isset($column->type->applicationType)) {
$column->type->logicalApplicationType = $logicalColumn->type->applicationType;
} else {
// setting column type to original column type
$column->type->applicationType = $logicalColumn->type->applicationType;
}
}
// preparing cube measures
// we do that in a separate loop because a calculated column can point to another calculated column with higher column index
foreach ($dataset->getColumns(FALSE) as $logicalColumn) {
self::initializeMeasuresFromColumn($cube, $dataset, $logicalColumn->name);
}
// marking that the facts dataset object contains complete meta data & registering it in meta model
$factsDataset->markAsComplete();
$metamodel->registerDataset($factsDataset);
// preparing cube measures
self::registerCubeMeasures($cube);
$metamodel->registerCube($cube);
return $cube;
}