public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube)
{
$column = $dataset->getColumn($columnName);
$sourceDatasetColumn = $cube->sourceDataset->getColumn($columnName);
$dimension = $cube->getDimension($columnName);
$this->prepareYearLevel($dimension, $column);
// cube source dataset column contains a reference to year identifier
$sourceDatasetColumn->initializeTypeFrom(Sequence::getSequenceColumnType());
// adding a reference to date dataset
$referenceName = DateDimensionDatasetNames::LEVEL_YEARS;
$metamodel->registerSimpleReferencePoint($referenceName, DateDimensionDatasetNames::LEVEL_YEARS, 'year_id');
$metamodel->registerSimpleReferencePoint($referenceName, $cube->sourceDatasetName, $columnName);
}
public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube) {
$logicalColumn = $dataset->getColumn($columnName);
$column = $cube->factsDataset->getColumn($columnName);
$dimension = $cube->getDimension($columnName);
// preparing the dimension properties
$dimension->attributeColumnName = $columnName;
$dimension->setDatasetName(StarSchemaNamingConvention::getAttributeRelatedName($dataset->name, $columnName));
// preparing dimension dataset
$dimension->dataset = new DatasetMetaData();
$dimension->dataset->name = $dimension->datasetName;
$dimension->dataset->publicName = $dataset->publicName . " [$logicalColumn->publicName]";
$dimension->dataset->description = t("Lookup table to store unique values from '@columnName' column", array('@columnName' => $logicalColumn->publicName));
$dimension->dataset->datasourceName = $dataset->datasourceName;
$dimension->dataset->source = StarSchemaNamingConvention::getAttributeRelatedName($dataset->source, $columnName);
$dimension->dataset->markAsPrivate();
// adding dimension dataset aliases
if (isset($dataset->aliases)) {
foreach ($dataset->aliases as $alias) {
$dimension->dataset->aliases[] = StarSchemaNamingConvention::getAttributeRelatedName($alias, $columnName);
}
}
// adding key column
$keyColumn = $dimension->dataset->registerColumn($columnName);
$keyColumn->publicName = $logicalColumn->publicName;
$keyColumn->description = t("System generated ID to identify each unique value from '@columnName' column", array('@columnName' => $logicalColumn->publicName));
$keyColumn->initializeTypeFrom(Sequence::getSequenceColumnType());
$keyColumn->key = TRUE;
$keyColumn->visible = FALSE;
// adding 'value' column
$valueColumn = $dimension->dataset->registerColumn('value');
$valueColumn->publicName = $logicalColumn->publicName;
$valueColumn->description = t("Actual value from '@columnName' column", array('@columnName' => $logicalColumn->publicName));
$valueColumn->initializeTypeFrom($logicalColumn->type);
// facts dataset column contains a reference to lookup
$column->initializeTypeFrom(Sequence::getSequenceColumnType());
$column->type->logicalApplicationType = StringDataTypeHandler::DATA_TYPE;
// marking that the dimension dataset object contains complete meta data & registering it in meta model
$dimension->dataset->markAsComplete();
$metamodel->registerDataset($dimension->dataset);
// adding a reference to the dimension dataset
$referenceName = $dimension->datasetName;
$metamodel->registerSimpleReferencePoint($referenceName, $dimension->datasetName, $columnName);
$metamodel->registerSimpleReferencePoint($referenceName, $cube->factsDatasetName, $columnName);
}
public function prepareCubeMetaData(DataControllerCallContext $callcontext, CubeMetaData $cube) {
$measureNames = NULL;
if (isset($cube->measures)) {
foreach ($cube->measures as $measure) {
if ($measure->isComplete()) {
continue;
}
$measureNames[] = $measure->name;
}
}
// we need at least one incomplete measure to proceed
if (!isset($measureNames)) {
return;
}
$environment_metamodel = data_controller_get_environment_metamodel();
$datasource = $environment_metamodel->getDataSource($cube->factsDataset->datasourceName);
$queryRequest = new CubeQueryRequest($cube->name);
// requesting all measures to get their type
foreach ($measureNames as $requestColumnIndex => $measureName) {
$queryRequest->addMeasure($requestColumnIndex, $measureName);
}
// we do not need to return any records, we just analyze structure
$queryRequest->setPagination(0);
$aggrStatement = $this->prepareCubeQueryStatement($callcontext, $queryRequest);
list($isSubqueryRequired, $assembledAggregationSections) = $aggrStatement->prepareSections(NULL);
$sql = Statement::assemble(
$isSubqueryRequired,
NULL, // assembling all columns
$assembledAggregationSections);
// applying pagination
$this->applyPagination($queryRequest, $sql);
$measureDatasetMetaData = $this->processDatasetMetaData($callcontext, $datasource, $sql);
// processing all measures and setting up types
foreach ($measureNames as $measureName) {
$column = $measureDatasetMetaData->getColumn($measureName);
$cube->getMeasure($measureName)->initializeTypeFrom($column->type);
}
}
protected function mergeWithCube(AbstractMetaModel $metamodel, array $filters = NULL, $namespace, $sourceCubeName, $sourceCube)
{
$cubeName = NameSpaceHelper::resolveNameSpace($namespace, $sourceCubeName);
// cube/sourceDataset/Name
if (!isset($sourceCube->sourceDatasetName)) {
throw new IllegalStateException(t("'@cubeName' cube definition does not contain a reference to source dataset", array('@cubeName' => isset($sourceCube->publicName) ? $sourceCube->publicName : $cubeName)));
}
$sourceCube->sourceDatasetName = NameSpaceHelper::resolveNameSpace($namespace, $sourceCube->sourceDatasetName);
// fix dimensions
if (isset($sourceCube->dimensions)) {
foreach ($sourceCube->dimensions as $dimension) {
if (isset($dimension->levels)) {
foreach ($dimension->levels as $level) {
// cube/dimension/level/dataset/name
if (!isset($level->datasetName)) {
continue;
}
$level->datasetName = NameSpaceHelper::resolveNameSpace($namespace, $level->datasetName);
}
}
}
}
// cube/region/dataset/name
if (isset($sourceCube->regions)) {
foreach ($sourceCube->regions as $regionName => $region) {
if (!isset($region->datasetName)) {
throw new IllegalStateException(t("'@regionName' region of '@cubeName' cube does not contain a reference to dataset", array('@cubeName' => isset($sourceCube->publicName) ? $sourceCube->publicName : $cubeName, '@regionName' => $regionName)));
}
$region->datasetName = NameSpaceHelper::resolveNameSpace($namespace, $region->datasetName);
}
}
$cube = new CubeMetaData();
$cube->name = $cubeName;
$cube->initializeFrom($sourceCube);
$metamodel->registerCube($cube);
return $cube;
}
public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube) {
$column = $dataset->getColumn($columnName);
$dimension = $cube->getDimension($columnName);
$dimension->attributeColumnName = $column->name;
}
protected function prepareAttributeCustomMeasure(AbstractAttributeUIMetaData $attributeUIMetaData, $referencePath, CubeMetaData $cube, $measureName) {
$measure = $cube->getMeasure($measureName);
$measureUIMetaData = new FactMeasureUIMetaData();
$measureUIMetaData->name = self::prepareMeasureUIMetaDataName($referencePath, $cube, $measureName);
$measureUIMetaData->publicName = $measure->publicName;
$measureUIMetaData->description = $measure->description;
$measureUIMetaData->type = clone $measure->type;
$attributeUIMetaData->registerElement($measureUIMetaData);
}
protected function mergeWithCube(AbstractMetaModel $metamodel, array $filters = NULL, $namespace, $sourceCubeName, $sourceCube) {
$cubeName = NameSpaceHelper::resolveNameSpace($namespace, $sourceCubeName);
// cube/sourceDataset/Name
if (!isset($sourceCube->factsDatasetName)) {
throw new IllegalStateException(t(
'%cubeName cube definition does not contain a reference to facts dataset',
array('%cubeName' => (isset($sourceCube->publicName) ? $sourceCube->publicName : $cubeName))));
}
$sourceCube->factsDatasetName = NameSpaceHelper::resolveNameSpace($namespace, $sourceCube->factsDatasetName);
// fix dimensions
if (isset($sourceCube->dimensions)) {
foreach ($sourceCube->dimensions as $dimension) {
// cube/dimension/dataset/name
if (!isset($dimension->datasetName)) {
continue;
}
$dimension->datasetName = NameSpaceHelper::resolveNameSpace($namespace, $dimension->datasetName);
}
}
$cube = new CubeMetaData();
$cube->name = $cubeName;
$cube->initializeFrom($sourceCube);
$isCubeAcceptable = $this->isMetaDataAcceptable($cube, $filters);
// TODO eliminate this check in the future. Use different approach
if ($isCubeAcceptable) {
$isCubeAcceptable = $metamodel->findDataset($cube->factsDatasetName) !== NULL;
}
if ($isCubeAcceptable) {
$metamodel->registerCube($cube);
}
return $cube;
}
protected function excludeIneligibleRegions(CubeMetaData $cube, &$eligibleRegionNames, array $requestDimensions, $isExactMatchRequired)
{
// checking each request dimension
foreach ($requestDimensions as $requestDimension) {
$requestDimensionName = $requestDimension->dimensionName;
$requestDimensionLevelName = $requestDimension->levelName;
// checking each eligible region
foreach ($eligibleRegionNames as $eligibleRegionNameIndex => $eligibleRegionName) {
$eligibleRegion = $cube->regions->{$eligibleRegionName};
$isRegionEligible = FALSE;
// is the dimension present in the region?
if (isset($eligibleRegion->dimensions->{$requestDimensionName})) {
$eligibleRegionDimension = $eligibleRegion->dimensions->{$requestDimensionName};
// if levels are defined we need to check if any aggregation is done on required level or any lower level
if (isset($eligibleRegionDimension->levels)) {
$dimension = $cube->findDimension($requestDimensionName);
if (isset($dimension)) {
$matchingLevelName = NULL;
foreach ($dimension->levels as $level) {
$levelName = $level->name;
if (isset($eligibleRegionDimension->levels->{$levelName})) {
$matchingLevelName = $levelName;
}
if ($requestDimensionLevelName === $levelName) {
if (isset($matchingLevelName)) {
if ($isExactMatchRequired) {
if ($requestDimensionLevelName === $matchingLevelName) {
$isRegionEligible = TRUE;
}
} else {
$isRegionEligible = TRUE;
}
}
break;
}
}
}
} else {
$isRegionEligible = TRUE;
}
}
if (!$isRegionEligible) {
unset($eligibleRegionNames[$eligibleRegionNameIndex]);
}
}
}
}
public static function registerCubeMeasures(CubeMetaData $cube)
{
$measureRecordCount = $cube->registerMeasure(StarSchemaNamingConvention::$MEASURE_NAME__RECORD_COUNT);
$measureRecordCount->publicName = t('Record Count');
$measureRecordCount->description = t('System generated measure to count records');
$measureRecordCount->function = 'COUNT(*)';
$measureRecordCount->additivity = MeasureAdditivity::ADDITIVE;
$measureRecordCount->type->applicationType = IntegerDataTypeHandler::DATA_TYPE;
}
public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube) {
$column = $cube->factsDataset->getColumn($columnName);
$dimension = $cube->getDimension($columnName);
$referencedCube = $metamodel->findCube($this->datasetName);
// TODO DHS Management Cube (we do not have cubes for lookups)
$referencedDatasetName = isset($referencedCube) ? $referencedCube->factsDatasetName : $this->datasetName;
// preparing dimension properties
$dimension->attributeColumnName = $columnName;
// preparing dimension dataset
$dimension->setDatasetName($this->datasetName);
$dimension->dataset = $metamodel->getDataset($dimension->datasetName);
// facts dataset column contains a reference to lookup
// TODO DHS Management Cube (column type has been already prepared)
if (!isset($column->type->applicationType)) {
$column->initializeTypeFrom(Sequence::getSequenceColumnType());
}
// adding a reference to dimension dataset
$referenceName = $referencedDatasetName;
$metamodel->registerSimpleReferencePoint($referenceName, $referencedDatasetName, NULL);
$metamodel->registerSimpleReferencePoint($referenceName, $cube->factsDatasetName, $columnName);
// ... to support retrieving properties of the dimension dataset
$metamodel->registerSimpleReferencePoint($referenceName, $dimension->datasetName, $dimension->dataset->getKeyColumn()->name);
}
