public function generate(array $possiblyLinkableDatasetNames = NULL) { $adjustedPossiblyLinkableDatasetNames = NULL; if (isset($possiblyLinkableDatasetNames)) { foreach ($possiblyLinkableDatasetNames as $possiblyLinkableDatasetName) { $adjustedPossiblyLinkableDatasetName = $this->adjustDatasetName($possiblyLinkableDatasetName); // we should not try to link with itself if ($adjustedPossiblyLinkableDatasetName == $this->primaryDatasetName) { continue; } ArrayHelper::addUniqueValue($adjustedPossiblyLinkableDatasetNames, $adjustedPossiblyLinkableDatasetName); } } // preparing reference paths for all datasets which we need to test for possible linkage $referencePaths = NULL; if (isset($adjustedPossiblyLinkableDatasetNames)) { foreach ($adjustedPossiblyLinkableDatasetNames as $adjustedPossiblyLinkableDatasetName) { // column name should not be provided because we just try to link with the dataset $referencePath = ReferencePathHelper::assembleReference($adjustedPossiblyLinkableDatasetName, NULL); $referencePaths[$referencePath] = FALSE; // FALSE - if we cannot find link it is ok. Not everything could be connected } } $linkBuilder = new ReferenceLinkBuilder(); $link = $linkBuilder->prepareReferenceBranches($this->primaryDatasetName, $referencePaths); return $link; }
protected static function prepareReferencedElementName($referencePath, $datasetName, $elementName) { $referencedElementName = $elementName; if (isset($referencePath)) { $nestedReference = ReferencePathHelper::assembleReference($datasetName, $elementName); $referencedElementName = ReferencePathHelper::assembleReferencePath(array($nestedReference, $referencePath)); } return $referencedElementName; }
protected function prepareColumnUIMetaData(array $datasetStack, $referencePath, DatasetMetaData $dataset, $columnName) { $column = $dataset->getColumn($columnName); $columnUIMetaData = new AttributeUIMetaData(); $columnUIMetaData->name = self::prepareColumnUIMetaDataName($referencePath, $dataset->name, $column->name); $columnUIMetaData->publicName = $column->publicName; $columnUIMetaData->description = $column->description; $columnUIMetaData->columnIndex = $column->columnIndex; $columnUIMetaData->type = clone $column->type; list($referencedDatasetName) = ReferencePathHelper::splitReference($column->type->getLogicalApplicationType()); if (isset($referencedDatasetName)) { $metamodel = data_controller_get_metamodel(); $referencedDataset = $metamodel->getDataset($referencedDatasetName); if (!isset($datasetStack[$referencedDataset->name])) { $datasetStack[$referencedDataset->name] = TRUE; $branchReferencePath = isset($referencePath) ? self::prepareReferencedElementName($referencePath, $dataset->name, $column->name) : ReferencePathHelper::assembleReference($dataset->name, $column->name); foreach ($referencedDataset->getColumns() as $referencedColumn) { if (!$referencedColumn->isVisible()) { continue; } $referencedColumnMetaData = $this->prepareColumnUIMetaData($datasetStack, $branchReferencePath, $referencedDataset, $referencedColumn->name); if ($referencedColumn->isKey()) { if (count($referencedColumnMetaData->elements) == 0) { continue; } $referencedColumnMetaData->publicName = $referencedDataset->publicName; $referencedColumnMetaData->description = $referencedDataset->description; $referencedColumnMetaData->isSelectable = FALSE; } $columnUIMetaData->registerElement($referencedColumnMetaData); } } } return $columnUIMetaData; }
public static function getExportColumnName ( $uiMetaDataName, MetaModel $metamodel ) { if ( trim($uiMetaDataName) == '' ) { $message = t('Empty columnName discovered'); drupal_set_message($message, 'warning'); LogHelper::log_warn($message); return $uiMetaDataName; } list($elementNameSpace, $name) = AbstractDatasetUIMetaDataGenerator::splitElementUIMetaDataName($uiMetaDataName); switch ( $elementNameSpace ) { case AbstractAttributeUIMetaData::NAME_SPACE: list($referencedDimensionName, $dimensionColumnName) = ParameterNameHelper::split($name); list($datasetName, $dimensionName) = ReferencePathHelper::splitReference($referencedDimensionName); if (isset($datasetName)) { $adjustedReferencedDimensionName = ReferencePathHelper::assembleReference(self::getExportDatasetName($datasetName,$metamodel), $dimensionName); $name = ParameterNameHelper::assemble($adjustedReferencedDimensionName, $dimensionColumnName); } break; case AbstractMeasureUIMetaData::NAME_SPACE: list($datasetName, $measureName) = ReferencePathHelper::splitReference($name); if (isset($datasetName)) { $name = ReferencePathHelper::assembleReference(self::getExportDatasetName($datasetName,$metamodel), $measureName); } break; case FormulaUIMetaData::NAME_SPACE: list($datasetName, $formulaName) = ReferencePathHelper::splitReference($name); if (isset($datasetName)) { $name = ReferencePathHelper::assembleReference(self::getExportDatasetName($datasetName,$metamodel), $formulaName); } break; default: $message = t('Unsupported UI Meta Data name space: @uiMetaDataName', array('@uiMetaDataName' => $uiMetaDataName)); LogHelper::log_error($message); throw new UnsupportedOperationException($message); } return AbstractDatasetUIMetaDataGenerator::prepareElementUIMetaDataName($elementNameSpace, $name); }
protected function generateLogicalDatasets(SystemTableMetaModelLoaderCallContext $callcontext, AbstractMetaModel $metamodel) { $datasetCount = 0; foreach ($callcontext->datasets as $tableAccessKey => $dataset) { $logicalDataset = new DatasetMetaData(); $logicalDataset->name = $this->generateLogicalDatasetName($dataset->name); $logicalDataset->publicName = $dataset->publicName; $logicalDataset->description = $dataset->description; $logicalDataset->datasourceName = $dataset->datasourceName; $logicalDataset->sourceType = StarSchemaDatasetSourceTypeHandler::SOURCE_TYPE; $callcontext->logicalDatasetNameMappings[$logicalDataset->name] = $tableAccessKey; foreach ($dataset->columns as $column) { $logicalColumn = $logicalDataset->initiateColumn(); $logicalColumn->name = $column->name; $logicalColumn->publicName = $column->publicName; $logicalColumn->description = $column->description; $logicalColumn->persistence = $column->persistence; $logicalColumn->columnIndex = $column->columnIndex; $logicalColumn->key = $column->key; $logicalColumn->visible = $column->visible; $logicalColumn->used = $column->used; if (isset($column->type->logicalApplicationType)) { list($refDatasetName, $refColumnName) = ReferencePathHelper::splitReference($column->type->logicalApplicationType); $refDataset = $metamodel->getDataset($refDatasetName); $refColumn = $refDataset->getColumn($refColumnName); $logicalColumn->type->databaseType = $refColumn->type->databaseType; $logicalColumn->type->length = $refColumn->type->length; $logicalColumn->type->precision = $refColumn->type->precision; $logicalColumn->type->scale = $refColumn->type->scale; $logicalColumn->type->applicationType = ReferencePathHelper::assembleReference( $this->generateLogicalDatasetName($refDataset->name), $refColumnName); } else { $logicalColumn->initializeTypeFrom($column->type); } $logicalDataset->registerColumnInstance($logicalColumn); } $callcontext->logicalDatasets[$tableAccessKey] = $logicalDataset; $datasetCount++; } LogHelper::log_info(t('Generated @datasetCount logical datasets', array('@datasetCount' => $datasetCount))); }
protected function prepareAttributeColumnUIMetaData(array $datasetStack, $referencePath, CubeMetaData $cube, $dimensionName, $dimensionReferencePath, DatasetMetaData $dataset = NULL, ColumnMetaData $column) { $dimensionColumnName = isset($dimensionReferencePath) ? self::prepareReferencedElementName($dimensionReferencePath, $dataset->name, $column->name) : $column->name; $attributeUIMetaData = new AttributeColumnUIMetaData(); $attributeUIMetaData->name = self::prepareAttributeUIMetaDataName($referencePath, $cube->factsDatasetName, $dimensionName, $dimensionColumnName); $attributeUIMetaData->publicName = $column->publicName; $attributeUIMetaData->description = $column->description; $attributeUIMetaData->columnIndex = $column->columnIndex; $attributeUIMetaData->type = clone $column->type; $attributeUIMetaData->datasetName = $cube->factsDatasetName; if ($column->isKey()) { $attributeUIMetaData->isSelectable = FALSE; } if (!$column->isUsed()) { $attributeUIMetaData->isSelectable = FALSE; } if (!$column->isKey()) { $this->prepareAttributeColumnUIMetaData4ColumnBranch($datasetStack, $attributeUIMetaData, $referencePath, $cube, $dimensionName, $dimensionReferencePath, $dataset, $column); } list($referencedDatasetName) = ReferencePathHelper::splitReference($column->type->getLogicalApplicationType()); if (isset($referencedDatasetName)) { $branchReferencePath = NULL; if (isset($dataset)) { $branchReferencePath = isset($dimensionReferencePath) ? self::prepareReferencedElementName($dimensionReferencePath, $dataset->name, $column->name) : ReferencePathHelper::assembleReference($dataset->name, $column->name); } $this->generateColumnUIMetaData4DimensionDataset( $datasetStack, $attributeUIMetaData, $referencePath, $cube, $dimensionName, $branchReferencePath, $referencedDatasetName); } return $attributeUIMetaData; }
protected function assembleConnectedDatasetSourceStatement(DataControllerCallContext $callcontext, ReferenceLink $link, array $columnNames, array $linkExecutionStack = NULL) { $TABLE_ALIAS__LINK = 'l'; $nestedLinkExecutionStack = $linkExecutionStack; $nestedLinkExecutionStack[] = $link; $selectedColumnNames = ReferenceLinkBuilder::selectReferencedColumnNames4ReferenceLink($nestedLinkExecutionStack, $columnNames); $linkTableAliasPrefix = $TABLE_ALIAS__LINK . $link->linkId; $statement = $this->assembleDatasetSourceStatement($callcontext, $link->dataset, $selectedColumnNames); $statement->addTableAliasPrefix($linkTableAliasPrefix); // adding columns which we use to join with parent dataset if (!$link->isRoot()) { foreach ($link->columnNames as $columnName) { $joinColumnAlias = ReferencePathHelper::assembleDatabaseColumnName($this->getMaximumEntityNameLength(), ReferencePathHelper::assembleReference($link->dataset->name, $columnName)); $joinTable = $statement->findColumnTable($columnName); if (!isset($joinTable)) { $joinTable = $statement->tables[0]; } $joinColumn = $joinTable->findColumnByAlias($joinColumnAlias); if (!isset($joinColumn)) { $joinTable->columns[] = new ColumnSection($columnName, $joinColumnAlias); } } } // adding columns which we use to join with nested datasets if (isset($link->nestedLinks)) { foreach ($link->nestedLinks as $nestedLink) { foreach ($nestedLink->parentColumnNames as $parentColumnName) { $parentColumnAlias = ReferencePathHelper::assembleDatabaseColumnName($this->getMaximumEntityNameLength(), ReferencePathHelper::assembleReference($link->dataset->name, $parentColumnName)); $joinTable = $statement->getColumnTable($parentColumnName); $joinColumn = $joinTable->findColumnByAlias($parentColumnAlias); if (!isset($joinColumn)) { $joinTable->columns[] = new ColumnSection($parentColumnName, $parentColumnAlias); } } } } // collecting columns which we need to mark as invisible $shouldBeInvisibleColumns = NULL; foreach ($statement->tables as $table) { if (isset($table->columns)) { foreach ($table->columns as $column) { $shouldBeInvisibleColumns[$table->alias][$column->alias] = $column; } } else { $table->columns = array(); // We do not need any columns } } // adding or making as visible columns which we need to return if (isset($selectedColumnNames)) { foreach ($selectedColumnNames as $originalColumnName => $selectedColumnName) { // we need to show only those columns which are requested. // All intermediate columns (which are used to link with nested datasets) will not be shown if (array_search($originalColumnName, $columnNames) !== FALSE) { $databaseColumnName = ReferencePathHelper::assembleDatabaseColumnName($this->getMaximumEntityNameLength(), $originalColumnName); $table = $statement->getColumnTable($selectedColumnName, TRUE); $column = $table->findColumnByAlias($databaseColumnName); if (isset($column)) { $column->visible = TRUE; unset($shouldBeInvisibleColumns[$table->alias][$column->alias]); } else { $column = $table->findColumnByAlias($selectedColumnName); if (isset($column)) { // adding clone of the same column with another alias $column = clone $column; $column->visible = TRUE; $column->alias = $databaseColumnName; } else { $column = new ColumnSection($selectedColumnName, $databaseColumnName); } $table->columns[] = $column; } $callcontext->columnMapping[$databaseColumnName] = $originalColumnName; } } } if (isset($shouldBeInvisibleColumns)) { foreach ($shouldBeInvisibleColumns as $tableColumns) { foreach ($tableColumns as $column) { $column->visible = FALSE; } } } // supporting nested links if (isset($link->nestedLinks)) { foreach ($link->nestedLinks as $nestedLink) { $nestedStatement = $this->assembleConnectedDatasetSourceStatement($callcontext, $nestedLink, $columnNames, $nestedLinkExecutionStack); foreach ($nestedLink->parentColumnNames as $referencePointColumnIndex => $parentColumnName) { // preparing parent table alias $parentColumnAlias = ReferencePathHelper::assembleDatabaseColumnName($this->getMaximumEntityNameLength(), ReferencePathHelper::assembleReference($link->dataset->name, $parentColumnName)); $parentTableAlias = $statement->getColumnTable($parentColumnAlias)->alias; // linking with parent $nestedColumnName = $nestedLink->columnNames[$referencePointColumnIndex]; $nestedColumnAlias = ReferencePathHelper::assembleDatabaseColumnName($this->getMaximumEntityNameLength(), ReferencePathHelper::assembleReference($nestedLink->dataset->name, $nestedColumnName)); $nestedStatement->getColumnTable($nestedColumnAlias)->conditions[] = new JoinConditionSection($nestedColumnName, new TableColumnConditionSectionValue($parentTableAlias, $parentColumnName)); } $statement->merge($nestedStatement); } } return $statement; }
protected static function prepareListColumnMappings(array $cubes = NULL, array $parsedUIMetaDataNames) { $columnMappings = NULL; foreach ($parsedUIMetaDataNames as $columnName => $parsedUIMetaDataName) { $datasetColumnName = NULL; if ($parsedUIMetaDataName instanceof AttributeParsedUIMetaDataName) { $cube = isset($cubes[$parsedUIMetaDataName->datasetName]) ? $cubes[$parsedUIMetaDataName->datasetName] : NULL; if (isset($cube)) { $dimension = $cube->getDimension($parsedUIMetaDataName->name); $references = NULL; if (isset($parsedUIMetaDataName->columnName)) { $column = $cube->factsDataset->getColumn($dimension->attributeColumnName); $branch = $column->findBranch($parsedUIMetaDataName->columnName); // the dimension column can be a branch, not a dimension dataset column if (!isset($branch) && isset($dimension->datasetName)) { list($adjustedDimensionDatasetName) = gd_data_controller_metamodel_adjust_dataset_name($dimension->datasetName); $references[] = ReferencePathHelper::assembleReference($adjustedDimensionDatasetName, $parsedUIMetaDataName->columnName); } } if (isset($references)) { $references[] = ReferencePathHelper::assembleReference($cube->factsDatasetName, $dimension->attributeColumnName); $datasetColumnName = ReferencePathHelper::assembleReferencePath($references); } else { $datasetColumnName = isset($parsedUIMetaDataName->columnName) ? $parsedUIMetaDataName->columnName : $dimension->attributeColumnName; } } else { $datasetColumnName = $parsedUIMetaDataName->name; } } elseif ($parsedUIMetaDataName instanceof FormulaAttributeParsedUIMetaDataName) { $datasetColumnName = $parsedUIMetaDataName->name; } elseif ($parsedUIMetaDataName instanceof FormulaMeasureParsedUIMetaDataName) { $datasetColumnName = $parsedUIMetaDataName->name; } if (isset($datasetColumnName)) { $columnMappings[$columnName] = $datasetColumnName; } } return $columnMappings; }
public function generateStatement(AbstractSQLDataSourceQueryHandler $datasourceHandler, DataControllerCallContext $callcontext, AbstractCubeQueryRequest $request) { $statement = $this->prepareSelectedCubeQueryStatement($datasourceHandler, $callcontext, $request); if (!isset($request->referencedRequests)) { return $statement; } $combinedStatement = new Statement(); $metamodel = data_controller_get_metamodel(); $cubeName = $request->getCubeName(); $cube = $metamodel->getCube($cubeName); $datasetMappedCubeRequests = array($cube->factsDatasetName => $request); // preparing list of reference paths $referencePaths = NULL; foreach ($request->referencedRequests as $referencedRequest) { $referencedCubeName = $referencedRequest->getCubeName(); $referencedCube = $metamodel->getCube($referencedCubeName); $referencedDatasetName = $referencedCube->factsDatasetName; $referencePath = ReferencePathHelper::assembleReference($referencedDatasetName, NULL); $referencePaths[$referencePath] = TRUE; // TRUE - required reference $datasetMappedCubeRequests[$referencedDatasetName] = $referencedRequest; } // finding ways to link the referenced cubes $linkBuilder = new ReferenceLinkBuilder(); $link = $linkBuilder->prepareReferenceBranches($cube->factsDatasetName, $referencePaths); // preparing primary cube aggregation statement list($isSubqueryRequired, $assembledPrimaryCubeAggregationSections) = $statement->prepareSections(NULL); $primaryCubeAggregationTableSection = new SubquerySection( Statement::assemble($isSubqueryRequired, NULL, $assembledPrimaryCubeAggregationSections, SelectStatementPrint::INDENT__SUBQUERY, FALSE), self::$TABLE_ALIAS__REFERENCED . $link->linkId); // adding columns which are returned by primary aggregation foreach ($statement->tables as $table) { if (!isset($table->columns)) { continue; } foreach ($table->columns as $column) { if (!$column->visible) { continue; } $primaryCubeAggregationTableSection->columns[] = new ColumnSection($column->alias); } } // registering primary cube statement in resulting statement $combinedStatement->tables[] = $primaryCubeAggregationTableSection; $this->prepareReferencedCubeQueryStatement($datasourceHandler, $callcontext, $combinedStatement, $datasetMappedCubeRequests, $link); return $combinedStatement; }
protected function prepareColumns(&$datasets) { // prepare dataset columns for import $datasetCount = count($datasets); for ( $i = 0; $i < $datasetCount; $i++ ) { foreach ( $datasets[$i]->columns as &$column ) { // unset private properties. TODO export only public properties unset($column->type->referencedApplicationType); unset($column->type->referencedDatasetName); unset($column->type->referencedColumnName); // reset storage flags if ($column->persistence == ColumnMetaData::PERSISTENCE__STORAGE_CREATED) { $column->persistence = ColumnMetaData::PERSISTENCE__NO_STORAGE; } // re-link column references list($datasetName, $columnName) = ReferencePathHelper::splitReference($column->type->applicationType); if ( !empty($datasetName) ) { $reference_datatype = null; for ( $j = 0; $j < $datasetCount; $j++ ) { if ( empty($reference_datatype) && $datasetName == $datasets[$j]->originalName ) { $reference_datatype = ReferencePathHelper::assembleReference($datasets[$j]->name,$columnName); } } if ( empty($reference_datatype) ) { throw new Exception('Dataset column reference lookup failed. Dataset: '.$datasets[$j]->name.' Column: '.$column->name.' Type: '.$column->type->applicationType); } else { $column->type->applicationType = $reference_datatype; } } } } }
protected function processLookupDataTypes(DataTypeUIMetaData $rootDataType, array $lookupDataTypes) { $metamodel = data_controller_get_metamodel(); $datatypeMappings = &drupal_static(__CLASS__ . '::datatypeMappings'); foreach ($lookupDataTypes as $datasetName) { $dataset = $metamodel->getDataset($datasetName); $datasetElement = new DataTypeUIMetaData(); $datasetElement->name = $dataset->name; $datasetElement->publicName = $dataset->publicName; $datasetElement->description = $dataset->description; // processing primary key and columns which contain unique values foreach ($dataset->getColumns() as $column) { if (!$column->isVisible()) { continue; } if (!isset($column->type->applicationType)) { continue; } if (!$column->isKey()) { if (!isset($datatypeMappings[$column->type->applicationType])) { continue; } $datatypeMapping = $datatypeMappings[$column->type->applicationType]; if (!$datatypeMapping->isVisible) { continue; } if (!$datatypeMapping->isKeyCompatible) { continue; } } $columnElement = new DataTypeUIMetaData(); $columnElement->name = ReferencePathHelper::assembleReference($dataset->name, $column->name); $columnElement->publicName = $column->publicName; $columnElement->description = $column->description; $columnElement->isSelectable = TRUE; $columnElement->parentName = $datasetElement->name; $columnElement->isParentShownOnSelect = TRUE; $columnElement->isKeyCompatible = TRUE; $datasetElement->registerElement($columnElement); } $rootDataType->registerElement($datasetElement); } }