protected function formatColumnNameImpl($uiMetaDataName) { $columnName = NULL; $formattedUIMetaDataName = parent::formatColumnNameImpl($uiMetaDataName); list($elementNameSpace, $elementName) = AbstractDatasetUIMetaDataGenerator::splitElementUIMetaDataName($formattedUIMetaDataName); switch ($elementNameSpace) { case AbstractAttributeUIMetaData::NAME_SPACE: list($dimensionName, $dimensionColumnName) = ParameterNameHelper::split($elementName); // TODO do we need to check for resource? list(, $columnName) = ReferencePathHelper::splitReference($dimensionName); $column = $this->dataset->getColumn($dimensionName); if ($column->type->getReferencedDatasetName() != NULL) { // this column should not be used if (isset($dimensionColumnName) && $column->type->getReferencedColumnName() != $dimensionColumnName) { $columnName = NULL; } } break; case AbstractMeasureUIMetaData::NAME_SPACE: throw new IllegalArgumentException(t('Measures are not supported by this result formatter')); } return $columnName; }
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; }
public function findHandler($datatype) { // checking internal cache if (isset($this->handlers[$datatype])) { return $this->handlers[$datatype]; } // looking for configuration for the type $handlerConfiguration = isset($this->handlerConfigurations[$datatype]) ? $this->handlerConfigurations[$datatype] : NULL; if (!isset($handlerConfiguration)) { // checking if data type is a reference to lookup dataset column list($datasetName) = ReferencePathHelper::splitReference($datatype); if (isset($datasetName)) { $handlerConfiguration = $this->prepareHandlerConfiguration($datatype, 'LookupDatasetColumnDimensionLookupHandler'); } } if (isset($handlerConfiguration)) { // initializing handler based on configuration $classname = $handlerConfiguration['classname']; $handler = new $classname($datatype); } else { $handler = new SimpleDimensionLookupHandler($datatype); } $this->handlers[$datatype] = $handler; return $handler; }
final public function format(DataControllerCallContext $callcontext, AbstractRequest $request, $datasetName, $columnName, $columnDataType = NULL) { if (!isset($columnDataType)) { $metamodel = data_controller_get_metamodel(); // trying to detect data type for the value list($referencedDatasetName, $referencedColumnName) = ReferencePathHelper::splitReference($columnName); $selectedDatasetName = isset($referencedDatasetName) ? $referencedDatasetName : $datasetName; $selectedColumnName = isset($referencedColumnName) ? $referencedColumnName : $columnName; $dataset = $metamodel->getDataset($selectedDatasetName); $column = $dataset->findColumn($selectedColumnName); // could be formula if (!isset($column)) { $column = $request->findFormula($selectedColumnName); } $columnDataType = isset($column) ? $column->type->applicationType : NULL; // preparing column data type based on operator parameter data type if (!isset($columnDataType) && ($this->operatorHandler instanceof ParameterBasedOperatorHandler)) { $columnDataType = $this->operatorHandler->getParameterDataType(); } } return $this->prepareExpression($callcontext, $request, $datasetName, $columnName, $columnDataType); }
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 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); }
public static function assembleDatabaseColumnName($maximumLength, $elementName, $subElementName = NULL, $elementPropertyName = NULL) { $databaseColumnName = ReferencePathHelper::generateDatabaseColumnName($elementName); if (isset($subElementName)) { $databaseColumnName .= self::$COLUMN_NAME_DELIMITER__DATABASE . strtolower($subElementName); } if (isset($elementPropertyName)) { $databaseColumnName .= self::$COLUMN_NAME_DELIMITER__DATABASE . strtolower($elementPropertyName); } return ParameterNameTruncater::truncateParameterName($databaseColumnName, $maximumLength); }
protected function prepareDataType4Casting($datatype) { if (isset($datatype)) { list($datasetName, $columnName) = ReferencePathHelper::splitReference($datatype); if (isset($datasetName)) { $adjustedDataType = isset($this->originalDataType4ReferencedDataTypes[$datatype]) ? $this->originalDataType4ReferencedDataTypes[$datatype] : NULL; if (!isset($adjustedDataType)) { $adjustedDataType = $this->adjustReferencedDataType4Casting($datasetName, $columnName); $this->originalDataType4ReferencedDataTypes[$datatype] = $adjustedDataType; } return $adjustedDataType; } } return $datatype; }
protected function isDependent(DatasetMetaData $dataset, DatasetMetaData $datasetB) { $referenceCount = 0; foreach ($dataset->getColumns() as $column) { list($referencedDatasetName) = ReferencePathHelper::splitReference($column->type->applicationType); if (isset($referencedDatasetName)) { $referenceCount++; } else { continue; } if ($referencedDatasetName == $datasetB->name) { return array(TRUE, NULL); } } return array(FALSE, $referenceCount); }
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 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; }
protected static function generateFromReference($reference) { if (!isset($reference)) { return NULL; } $parts = ReferencePathHelper::splitReference($reference); $databaseColumnName = NULL; for ($i = 0, $count = count($parts); $i < $count; $i += 2) { $resource = $parts[$i]; $name = $parts[$i + 1]; $columnNameSegment = $name; if (isset($resource)) { list($namespace, $resourceName) = NameSpaceHelper::splitAlias($resource); $columnNameSegment .= '_'; if (isset($namespace)) { $columnNameSegment .= $namespace . '_'; } $columnNameSegment .= $resourceName; } if (isset($databaseColumnName)) { $databaseColumnName .= '_'; } $databaseColumnName .= $columnNameSegment; } // replacing non-word characters with '_' $databaseColumnName = preg_replace('#\W+#', '_', $databaseColumnName); // removing several subsequent instances of '_' $databaseColumnName = preg_replace('#_{2,}#', '_', $databaseColumnName); // fixing possibility for leading digits if ((strlen($databaseColumnName) > 0) && is_numeric(substr($databaseColumnName, 0, 1))) { $databaseColumnName = 'fix_' . $databaseColumnName; } $databaseColumnName = strtolower($databaseColumnName); return $databaseColumnName; }
public static function containsCategory(ColumnMetaData $column, $category) { if (!isset($column->type->applicationType)) { return FALSE; } $type = $column->type->applicationType; if ($type == NumberDataTypeHandler::DATA_TYPE || $type == CurrencyDataTypeHandler::DATA_TYPE || $type == PercentDataTypeHandler::DATA_TYPE) { return $category == self::FACT; } elseif ($type == IntegerDataTypeHandler::DATA_TYPE) { $calculatedCategory = $column->isKey() ? self::ATTRIBUTE : self::FACT; // if logical application type is a reference this column is an attribute if ($calculatedCategory != self::ATTRIBUTE && isset($column->type->logicalApplicationType)) { list($referencedDatasetName) = ReferencePathHelper::splitReference($column->type->logicalApplicationType); if (isset($referencedDatasetName)) { $calculatedCategory = self::ATTRIBUTE; } } return $category == $calculatedCategory; } else { return $category == self::ATTRIBUTE; } }
public function initiateSortingConfiguration($columnName, $isSortAscending = TRUE) { list($rootName, $leafName) = ParameterNameHelper::split($columnName); $isFormula = $this->findFormula($rootName) != NULL; if (!$isFormula) { StringDataTypeHandler::checkValueAsWord($rootName); ReferencePathHelper::checkReference($leafName); } return new __AbstractCubeQueryRequest_SortingConfiguration($rootName, $leafName, $isSortAscending); }
public function registerDataset(DatasetMetaData $dataset) { $this->checkAssemblingStarted(); if (!isset($dataset->name)) { LogHelper::log_error($dataset); throw new IllegalArgumentException(t('Dataset name has not been defined')); } $datasetName = $dataset->name; NameSpaceHelper::checkAlias($datasetName); if (isset($this->datasets[$datasetName])) { if ($dataset->temporary) { unset($this->datasets[$datasetName]); } else { throw new IllegalArgumentException(t('Dataset with name @datasetName has already been defined', array('@datasetName' => $dataset->publicName))); } } // registering references to lookups based on column type foreach ($dataset->getColumns() as $column) { list($lookupDatasetName) = ReferencePathHelper::splitReference($column->type->applicationType); if (isset($lookupDatasetName)) { $referenceName = $lookupDatasetName; // FIXME it would be better if we provide the primary key (check findReferencesByDatasetName where we fix this issue) $this->registerSimpleReferencePoint($referenceName, $lookupDatasetName, NULL); $this->registerSimpleReferencePoint($referenceName, $dataset->name, $column->name); } } $this->datasets[$datasetName] = $dataset; }
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 findColumnTableByReferencePath($referencePath) { $tableCount = count($this->tables); $references = ReferencePathHelper::splitReferencePath($referencePath); $references = array_reverse($references); $tableIndex = NULL; for ($i = 0, $refcount = count($references); $i < $refcount - 1; $i++) { $reference = $references[$i]; list($referencedDatasetName, $referencedColumnName) = ReferencePathHelper::splitReference($reference); if (!isset($referencedDatasetName)) { continue; } $nextReference = $references[$i + 1]; list($nextReferencedDatasetName, $nextReferencedColumnName) = ReferencePathHelper::splitReference($nextReference); if (!isset($nextReferencedDatasetName)) { continue; } $branchIndex = NULL; for ($j = (isset($tableIndex) ? $tableIndex : 0); $j < $tableCount; $j++) { $table = $this->tables[$j]; if ($table->dataset->name == $referencedDatasetName) { for ($k = $j + 1; $k < $tableCount; $k++) { $nextTable = $this->tables[$k]; if (($nextTable->dataset->name == $nextReferencedDatasetName) && ($nextTable->conditions[0]->joinValue->tableAlias == $table->alias) && ($nextTable->conditions[0]->joinValue->columnName == $referencedColumnName)) { $branchIndex = $k; break 2; } } } } if (!isset($branchIndex)) { return NULL; } $tableIndex = $branchIndex; } return isset($tableIndex) ? $this->tables[$tableIndex] : NULL; }
public function addColumn($column) { $isFormula = $this->findFormula($column) != NULL; ReferencePathHelper::checkReference($column, TRUE, !$isFormula); ArrayHelper::addUniqueValue($this->columns, $column); }
public function initiateSortingConfiguration($columnName, $isSortAscending = TRUE) { $isFormula = $this->findFormula($columnName) != NULL; ReferencePathHelper::checkReference($columnName, TRUE, !$isFormula); return new ColumnBasedComparator_DefaultSortingConfiguration($columnName, $isSortAscending); }
public function registerDataset(DatasetMetaData $dataset) { $this->checkAssemblingStarted(); if (!isset($dataset->name)) { LogHelper::log_debug($dataset); throw new IllegalArgumentException(t('Dataset name has not been defined')); } $datasetName = $dataset->name; NameSpaceHelper::checkAlias($datasetName); $existingDataset = $this->findDataset($datasetName, TRUE); if (isset($existingDataset)) { if ($dataset->isTemporary()) { $this->unregisterDataset($datasetName); } else { LogHelper::log_debug($existingDataset); LogHelper::log_debug($dataset); throw new IllegalArgumentException(t( 'Dataset with name %datasetName has already been defined', array('%datasetName' => $dataset->publicName))); } } // registering references to lookups based on column type foreach ($dataset->getColumns() as $column) { $lookupDatasetName = $column->type->getReferencedDatasetName(); if (isset($lookupDatasetName)) { $referenceName = $lookupDatasetName; // FIXME it would be better if we provide the primary key (check findReferencesByDatasetName where we fix this issue) $this->registerSimpleReferencePoint($referenceName, $lookupDatasetName, /* Primary Key */ NULL); $this->registerSimpleReferencePoint($referenceName, $dataset->name, $column->name); } if (isset($column->type->logicalApplicationType)) { list($refDatasetName, $refColumnName) = ReferencePathHelper::splitReference($column->type->logicalApplicationType); if (isset($refDatasetName)) { $referenceName = $refDatasetName; // FIXME it would be better if we provide the primary key (check findReferencesByDatasetName where we fix this issue) $this->registerSimpleReferencePoint($referenceName, $refDatasetName, /* Primary Key */ NULL); $this->registerSimpleReferencePoint($referenceName, $dataset->name, $column->name); } } } $this->datasets[$datasetName] = $dataset; }
public function addColumn($column) { ReferencePathHelper::checkReference($column); ArrayHelper::addUniqueValue($this->columns, $column); }
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; }
public function assembleColumnName($tableAlias) { $selectedTableAlias = $this->tableAlias; if (isset($selectedTableAlias)) { if (isset($tableAlias) && ($selectedTableAlias != $tableAlias)) { throw new UnsupportedOperationException(); } } else { $this->tableAlias = $tableAlias; $selectedTableAlias = $tableAlias; } list(, $columnName) = ReferencePathHelper::splitReference($this->name); return ColumnNameHelper::combineColumnName($selectedTableAlias, $columnName); }
protected function detectRoutes(ReferenceLink $rootLink, array $referencePaths) { $routeId = 0; foreach ($referencePaths as $referencePath => $required) { // preparing possible routes $referenceRoutes = $rootLink->prepareRoutes($referencePath); // selecting 'the best' route $selectedRoute = NULL; if (isset($referenceRoutes)) { foreach ($referenceRoutes as $directReferenceFlag => $routes) { foreach ($routes as $route) { if (!isset($selectedRoute) || ($selectedRoute->weight > $route->weight)) { $selectedRoute = $route; } } } } if (isset($selectedRoute)) { $rootLink->assignRouteId($selectedRoute, $routeId); $routeId++; } elseif ($required) { $metamodel = data_controller_get_metamodel(); LogHelper::log_error(t('Could not execute reference path: @referencePath', array('@referencePath' => $referencePath))); list($referencedDatasetName) = ReferencePathHelper::splitReference($referencePath); $referencedDataset = $metamodel->getDataset($referencedDatasetName); throw new IllegalArgumentException(t( '%datasetNameA and %datasetNameB datasets are not connected', array('%datasetNameA' => $rootLink->dataset->publicName, '%datasetNameB' => $referencedDataset->publicName))); } } }
protected function prepareColumnDatabaseType(DataSourceHandler $handler, ColumnMetaData $column) { if (isset($column->type->applicationType)) { $storageDataType = NULL; list($datasetName) = ReferencePathHelper::splitReference($column->type->applicationType); if (isset($datasetName)) { $storageDataType = Sequence::getSequenceColumnType()->applicationType; } else { $datatypeHandler = DataTypeFactory::getInstance()->getHandler($column->type->applicationType); $storageDataType = $datatypeHandler->getStorageDataType(); } switch ($storageDataType) { case StringDataTypeHandler::$DATA_TYPE: break; case IntegerDataTypeHandler::$DATA_TYPE: $this->prepareInteger($column); break; case NumberDataTypeHandler::$DATA_TYPE: case CurrencyDataTypeHandler::$DATA_TYPE: case PercentDataTypeHandler::$DATA_TYPE: $this->prepareNumber($column); break; case BooleanDataTypeHandler::$DATA_TYPE: // calculating length of mapping of TRUE and FALSE values $valueTrue = $handler->castValue(BooleanDataTypeHandler::$DATA_TYPE, TRUE); $valueFalse = $handler->castValue(BooleanDataTypeHandler::$DATA_TYPE, FALSE); // length of the field depends on length of the mappings $lengthValueTrue = strlen($valueTrue); $lengthValueFalse = strlen($valueFalse); $length = MathHelper::max($lengthValueTrue, $lengthValueFalse); // detecting type for each value and selecting primary type $datatype = DataTypeFactory::getInstance()->selectDataType(array(DataTypeFactory::getInstance()->autoDetectDataType($valueTrue), DataTypeFactory::getInstance()->autoDetectDataType($valueFalse))); // for numeric values we use integer storage type, for rest - string if ($datatype === IntegerDataTypeHandler::$DATA_TYPE) { $this->prepareInteger($column, $length); } elseif ($lengthValueTrue === $lengthValueFalse) { $this->prepareFixedLengthString($column, $length); } else { $this->prepareVariableLengthString($column, $length); } break; case DateTimeDataTypeHandler::$DATA_TYPE: $this->prepareDate($column, TRUE, TRUE); break; case DateDataTypeHandler::$DATA_TYPE: $this->prepareDate($column); break; case TimeDataTypeHandler::$DATA_TYPE: $this->prepareDate($column, FALSE, TRUE); break; default: throw new UnsupportedOperationException(t("Unsupported data type for '@columnName' column: @columnType", array('@columnName' => $column->publicName, '@columnType' => $column->type->applicationType))); } } if (!isset($column->type->databaseType)) { $this->prepareVariableLengthString($column); } return $column->type->databaseType; }
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; }
/** * @param $referencePath * @param null $parentColumnName * @return ReferenceRoute[] */ public function prepareRoutes($referencePath, $parentColumnName = NULL) { $routes = NULL; $referenceParts = ReferencePathHelper::splitReference($referencePath); $columnName = array_pop($referenceParts); $datasetName = array_pop($referenceParts); // checking that dataset is the same and parent column name is the same $isReferenceFound = ($this->dataset->name == $datasetName) && (!isset($parentColumnName) || in_array($parentColumnName, $this->parentColumnNames)); $nestedReferencePath = $isReferenceFound ? ReferencePathHelper::assembleReferenceParts($referenceParts) : $referencePath; // it is possible that not full execution path is provided if (isset($nestedReferencePath)) { if (isset($this->nestedLinks)) { $nestedRoutes = NULL; foreach ($this->nestedLinks as $nestedLink) { $nestedLinkRoutes = $nestedLink->prepareRoutes($nestedReferencePath, ($isReferenceFound ? $columnName : NULL)); if (isset($nestedLinkRoutes)) { // current reference could not be found. We mark nested found reference as not direct if (!$isReferenceFound && isset($nestedLinkRoutes[TRUE])) { $adjustedNestedLinkRoutes = NULL; $adjustedNestedLinkRoutes[FALSE] = $nestedLinkRoutes[TRUE]; $nestedRoutes[] = $adjustedNestedLinkRoutes; } else { $nestedRoutes[] = $nestedLinkRoutes; } } } if (isset($nestedRoutes)) { // checking if we found direct route $isNestedReferenceFound = FALSE; foreach ($nestedRoutes as $nestedLinkRoutes) { if (isset($nestedLinkRoutes[TRUE])) { $isNestedReferenceFound = TRUE; break; } } foreach ($nestedRoutes as $nestedLinkRoutes) { if (!isset($nestedLinkRoutes[$isNestedReferenceFound])) { continue; } foreach ($nestedLinkRoutes[$isNestedReferenceFound] as $nestedLinkRoute) { $route = new ReferenceRoute($this->linkId, $this->weight); $route->combineFrom($nestedLinkRoute); $routes[$isNestedReferenceFound][] = $route; } } } } } elseif ($isReferenceFound) { $routes[$isReferenceFound][] = new ReferenceRoute($this->linkId, $this->weight); } return $routes; }
public function addQueryValue($index, $name, $value) { $isFormula = $this->findFormula($name) != NULL; ReferencePathHelper::checkReference($name, TRUE, !$isFormula); $this->queries[$index][$name][] = $value; }
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 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; }