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 function checkDatasetStructurePermission($datasetName) { $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $this->checkDataSourceStructurePermission($dataset->datasourceName); }
/** * Retrieves dataset metadata object and checks if the dataset source is a database table * * @param $datasetName * @return DatasetMetaData */ public static function getTableDataset($datasetName) { $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); self::checkDatasetTableName($dataset); return $dataset; }
public function __construct(DatasetMetaData $newLogicalDataset) { parent::__construct($newLogicalDataset); $metamodel = data_controller_get_metamodel(); $this->originalLogicalDataset = $metamodel->getDataset($newLogicalDataset->name); }
/** * @param string $cubeName * @return DataSourceQueryHandler */ protected function getDataSourceQueryHandlerByCubeName($cubeName) { $metamodel = data_controller_get_metamodel(); $cube = $metamodel->getCube($cubeName); return $this->getDataSourceQueryHandlerByCube($cube); }
/** * @param string $datasetName * @return DataSourceHandler */ protected function getDataSourceHandlerByDatasetName($datasetName) { $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); return $this->getDataSourceHandlerByDataset($dataset); }
public function prepareDatasetColumnLookupIds($datasetName, ColumnMetaData $column, array &$lookupValues) { $metamodel = data_controller_get_metamodel(); $logicalDataset = $metamodel->getDataset($this->datasetName); $logicalColumn = $logicalDataset->getColumn($this->columnName); $cubeName = $logicalDataset->name; $cube = $metamodel->getCube($cubeName); $factsDataset = $metamodel->getDataset($cube->factsDatasetName); $attributeColumn = $factsDataset->getColumn($this->columnName); $lookupHandler = DimensionLookupFactory::getInstance()->getHandler($logicalColumn->type->getLogicalApplicationType()); list($adjustedDatasetName, $adjustedColumnName) = $lookupHandler->adjustReferencePointColumn($metamodel, $factsDataset->name, $attributeColumn->name); $adjustedDataset = $metamodel->getDataset($adjustedDatasetName); $adjustedColumn = $adjustedDataset->getColumn($adjustedColumnName); // this request is part of chain of references $adjustedLookupValues = NULL; if (($factsDataset->name != $adjustedDataset->name) || ($attributeColumn->name != $adjustedColumnName)) { $nestedLookupHandler = DimensionLookupFactory::getInstance()->getHandler($adjustedColumn->type->getLogicalApplicationType()); // preparing list of lookup object for nested reference $nestedLookupValues = NULL; foreach ($lookupValues as $lookupKey => $lookupValue) { $value = $lookupValue->getPropertyValue($attributeColumn->name); $nestedLookupValues[$lookupKey] = $nestedLookupHandler->prepareLookupValue($value); } // loading identifiers from nested reference if ($logicalColumn->type->getReferencedDatasetName() == NULL) { $nestedLookupHandler->loadIdentifiers($adjustedDataset->name, array($adjustedColumn), $nestedLookupValues); } else { $nestedLookupHandler->prepareDatasetColumnLookupIds($adjustedDataset->name, $adjustedColumn, $nestedLookupValues); } // using loaded identifiers foreach ($lookupValues as $lookupKey => $lookupValue) { $nestedLookupValue = $nestedLookupValues[$lookupKey]; if (!isset($nestedLookupValue->identifier)) { continue; } $adjustedLookupKey = self::prepareLookupKey($nestedLookupValue->identifier); $lookupValue->setPropertyValue($attributeColumn->name, $nestedLookupValue->identifier); $adjustedLookupValues[$adjustedLookupKey] = $lookupValue; } } else { $adjustedLookupValues = $lookupValues; } // do not use prepareIdentifiers() because new records will be inserted if (isset($adjustedLookupValues)) { $this->loadIdentifiers($factsDataset->name, array($attributeColumn), $adjustedLookupValues); } }
protected function initializeRequest4Total(AbstractQueryRequest $request) { $metamodel = data_controller_get_metamodel(); $datasetName = $request->getDatasetName(); $cube = $metamodel->getCubeByDatasetName($datasetName); return new CubeQueryRequest($cube->name); }
protected function prepareRequestDataset(AbstractQueryRequest $request) { $metamodel = data_controller_get_metamodel(); $cubeName = $request->getCubeName(); $cube = $metamodel->getCube($cubeName); $datasetName = $cube->factsDatasetName; return $metamodel->getDataset($datasetName); }
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 update(Import\ImportStream $stream, Import\ImportContext $context) { $references = $stream->get('references'); if (empty($references)) { return; } $metamodel = data_controller_get_metamodel(); $this->datasets = $metamodel->datasets; foreach ( $references as $referenceKey => $reference ) { // rename reference point datasets foreach ( $reference->referencePoints as $referencePoint ) { foreach ( $this->datasets as $dataset ) { if ( isset($dataset->uuid) && $dataset->uuid == $referencePoint->dataset ) { $referencePoint->dataset = $dataset->name; } } } $existingReferenceNode = $this->findExistingReference($reference); if ( !$existingReferenceNode ) { // create $node = $this->createReference($reference); if ( !empty($node->nid ) ) { $references[$referenceKey] = $node; } else { throw new Exception('Reference node creation failed'); } } else { $existingReferenceNode->title = $reference->title; // really, just update columns $existingReferencePointNids = get_node_field_node_ref($existingReferenceNode,'field_reference_point',null); foreach ( $existingReferencePointNids as $existingReferencePointNid ) { $existingReferencePointNode = node_load($existingReferencePointNid); foreach ( $reference->referencePoints as $referencePoint ) { if ( $referencePoint->dataset == get_node_field_value($existingReferencePointNode,'field_ref_point_dataset_sysname') ) { $existingReferencePointNode->field_ref_point_column_sysname[$existingReferencePointNode->language] = array(); foreach ( $referencePoint->columns as $column ) { $existingReferencePointNode->field_ref_point_column_sysname[$existingReferencePointNode->language][] = array('value' => $column); } } } node_save($existingReferencePointNode); } node_save($existingReferenceNode); $references[$referenceKey] = $existingReferenceNode; } } $stream->set('references',$references); }
public function __construct(DatasetMetaData $newLogicalDataset) { parent::__construct(); $metamodel = data_controller_get_metamodel(); $this->newLogicalDataset = $newLogicalDataset; $cubeName = $newLogicalDataset->name; $this->newCube = $metamodel->getCube($cubeName); }
public function execute(DataControllerCallContext $callcontext, $datasetName, array $observers = NULL) { $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $this->initialize($callcontext, $dataset, $observers); $this->truncateDatasetStorage($callcontext, $dataset, $observers); $this->finalize($callcontext, $dataset, $observers); }
public static function prepareTableSection(AbstractSQLDataSourceQueryHandler $datasourceHandler, DataControllerCallContext $callcontext, array &$requestedColumnNames = NULL) { $metamodel = data_controller_get_metamodel(); $tableYears = new DatasetSection($metamodel->getDataset(DateDimensionDatasetNames::YEARS), self::$TABLE_ALIAS_SUFFIX__YEARS); self::selectColumn($tableYears, $requestedColumnNames, FALSE, 'entry_year', FALSE); $columnYearId = self::selectColumn($tableYears, $requestedColumnNames, isset($tableYears->columns), 'year_id', FALSE); if (isset($columnYearId)) { $columnYearId->key = TRUE; } return $tableYears; }
public static function prepareDefTableSection(AbstractSQLDataSourceQueryHandler $datasourceHandler, DataControllerCallContext $callcontext, array &$requestedColumnNames = NULL) { $metamodel = data_controller_get_metamodel(); $tableDayOfWeek = new DatasetSection($metamodel->getDataset(DateDimensionDatasetNames::DAY_OF_WEEK_DEF), self::$TABLE_ALIAS_SUFFIX__DAY_OF_WEEK); self::selectColumn($tableDayOfWeek, $requestedColumnNames, FALSE, 'code', FALSE, 'day_of_week_code'); self::selectColumn($tableDayOfWeek, $requestedColumnNames, FALSE, 'name', FALSE, 'day_of_week_name'); $columnDateOfWeekDefId = self::selectColumn($tableDayOfWeek, $requestedColumnNames, isset($tableDayOfWeek->columns), 'day_of_week_def_id', FALSE); if (isset($columnDateOfWeekDefId)) { $columnDateOfWeekDefId->key = TRUE; } return $tableDayOfWeek; }
public static function prepareDefTableSection(AbstractSQLDataSourceQueryHandler $datasourceHandler, DataControllerCallContext $callcontext, array &$requestedColumnNames = NULL) { $metamodel = data_controller_get_metamodel(); $tableQuarterDef = new DatasetSection($metamodel->getDataset(DateDimensionDatasetNames::QUARTER_DEF), self::$TABLE_ALIAS_SUFFIX__QUARTER_DEF); self::selectColumn($tableQuarterDef, $requestedColumnNames, FALSE, 'series', FALSE, 'quarter_series'); self::selectColumn($tableQuarterDef, $requestedColumnNames, FALSE, 'code', FALSE, 'quarter_code'); self::selectColumn($tableQuarterDef, $requestedColumnNames, FALSE, 'name', FALSE, 'quarter_name'); $columnQuarterDefId = self::selectColumn($tableQuarterDef, $requestedColumnNames, isset($tableQuarterDef->columns), 'quarter_def_id', FALSE); if (isset($columnQuarterDefId)) { $columnQuarterDefId->key = TRUE; } return $tableQuarterDef; }
protected function checkDatasetManipulationPermission($datasetName) { $environment_metamodel = data_controller_get_environment_metamodel(); $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $datasource = $environment_metamodel->getDataSource($dataset->datasourceName); if ($datasource->isReadOnly()) { throw new IllegalStateException(t( 'Data manipulation is not permitted for the data source: %datasourceName', array('%datasourceName' => $datasource->publicName))); } }
public function getTableDataset($datasetName) { $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $datasetSourceType = $this->detectSourceType($dataset); if ($datasetSourceType != TableDatasetSourceTypeHandler::SOURCE_TYPE) { throw new IllegalArgumentException(t( 'Only a table can be used as a source for %datasetName dataset: %datasetSourceType', array('%datasetName' => $dataset->publicName, '%datasetSourceType' => $datasetSourceType))); } return $dataset; }
public static function getExportables($datasourceName) { if ( $datasourceName != gd_datasource_get_active() ) { gd_datasource_set_active($datasourceName); } $metamodel = data_controller_get_metamodel(); // get datasets $datasetNids = array(); foreach ($metamodel->datasets as $dataset) { if (!isset($dataset->nid)) { continue; } $datasetNids[] = $dataset->nid; } return node_load_multiple($datasetNids); }
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 function processConfig ( $export ) { $metamodel = data_controller_get_metamodel(); // replace report nid with report uuid foreach ( $export->config->items as $key => $item ) { if ( $item->type == 'report' ) { $reportNode = node_load($item->content); $export->config->items[$key]->content = get_node_field_value($reportNode,'field_report_uuid',0,'value',true); } } // array cast to deal with json decoder creating objects for arrays with missing keys $export->config->drilldowns = (array) $export->config->drilldowns; // replace report nid with report uuid // replace dashboard nid with dashboard uuid // replace dataset column reference with dataset uuid $updated_drilldowns = array(); foreach ( $export->config->drilldowns as $drilldown ) { $reportNode = gd_report_get_by_nid($drilldown->report); $dashboardNode = gd_dashboard_get_by_nid($drilldown->dashboard); if ( !$reportNode || !$dashboardNode ) { $message = t('Skipping corrupt drilldown for node: @nodeId.',array('@nodeId' => $export->id)); drupal_set_message($message, 'warning'); LogHelper::log_warn($message); } else { $updated_drilldown = $drilldown; $updated_drilldown->report = get_node_field_value($reportNode,'field_report_uuid',0,'value',true); $updated_drilldown->column = DatasetExportHelper::getExportColumnName($drilldown->column,$metamodel); $updated_drilldown->dashboard = get_node_field_value($dashboardNode,'field_dashboard_uuid',0,'value',true); $updated_drilldown->id = count($updated_drilldowns); $updated_drilldowns[] = $updated_drilldown; } } $export->config->drilldowns = $updated_drilldowns; }
protected function getDatasetHandler(DataControllerCallContext $callcontext, $datasetName) { $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $namespace = NameSpaceHelper::getNameSpace($dataset->datasourceName); $classname = $dataset->source; $foundScriptName = NULL; // TODO load the configuration only once when instance of the class is initialized // reuse the cached data here to look for PHP script $metamodelConfigurations = module_invoke_all('dp_metamodel'); foreach ($metamodelConfigurations as $metamodelConfiguration) { $path = $metamodelConfiguration['path']; $scriptName = "$path/metamodel/metamodel/$namespace/php/" . $classname . '.php'; if (file_exists($scriptName)) { if (isset($foundScriptName)) { throw new IllegalStateException(t( "Found several PHP scripts to support '@className' dataset: [@previousScriptName, @scriptName]", array('@className' => $classname, '@previousScriptName' => $foundScriptName, '@scriptName' => $scriptName))); } $foundScriptName = $scriptName; } } if (isset($foundScriptName)) { require_once($foundScriptName); } else { throw new IllegalStateException(t("Could not find PHP script to support '@datasetName' dataset", array('@datasetName' => $dataset->publicName))); } return new $classname; }
public function insertOrUpdateOrDeleteDatasetRecords(DataControllerCallContext $callcontext, AbstractDatasetManipulationRequest $request) { $environment_metamodel = data_controller_get_environment_metamodel(); $metamodel = data_controller_get_metamodel(); $datasourceQueryHandler = DataSourceQueryFactory::getInstance()->getHandler($this->getDataSourceType()); $dataset = $metamodel->getDataset($request->datasetName); $datasource = $environment_metamodel->getDataSource($dataset->datasourceName); $recordMetaData = isset($request->recordsHolder->recordMetaData) ? $request->recordsHolder->recordMetaData : $dataset; $isRecordIndexed = $request->recordsHolder instanceof IndexedRecordsHolder; $keyColumnNames = $recordMetaData->getKeyColumnNames(); $nonkeyColumnNames = $recordMetaData->findNonKeyColumnNames(); // preparing a request to find existing records $queryRequest = new DatasetQueryRequest($request->datasetName); // loading only key columns from database $queryRequest->addColumns($keyColumnNames); // a request can be more efficient for single column key if (count($keyColumnNames) == 1) { list($keyColumnIndex, $keyColumnName) = each($keyColumnNames); $keyColumnIdentifier = $isRecordIndexed ? $keyColumnIndex : $keyColumnName; $keyValues = NULL; foreach ($request->recordsHolder->records as $record) { ArrayHelper::addUniqueValue($keyValues, $record->getColumnValue($keyColumnIdentifier, TRUE)); } $queryRequest->addQueryValue( 0, $keyColumnName, OperatorFactory::getInstance()->initiateHandler(EqualOperatorHandler::OPERATOR__NAME, array($keyValues))); } else { for ($i = 0, $count = count($request->recordsHolder->records); $i < $count; $i++) { $record = $request->recordsHolder->records[$i]; foreach ($keyColumnNames as $keyColumnIndex => $keyColumnName) { $keyColumnIdentifier = $isRecordIndexed ? $keyColumnIndex : $keyColumnName; $keyColumnValue = $record->getColumnValue($keyColumnIdentifier, TRUE); $queryRequest->addQueryValue( $i, $keyColumnName, OperatorFactory::getInstance()->initiateHandler(EqualOperatorHandler::OPERATOR__NAME, $keyColumnValue)); } } } // loading existing records ... if any $existingRecordFormatter = new QueryKeyResultFormatter($keyColumnNames); $existingRecords = $existingRecordFormatter->formatRecords($datasourceQueryHandler->queryDataset($callcontext, $queryRequest)); // sorting out records for insert, update and delete operations $keyedRecords = $insertedRecordKeys = $updatedRecordKeys = $deletedRecordKeys = NULL; foreach ($request->recordsHolder->records as $record) { $keyParts = NULL; foreach ($keyColumnNames as $keyColumnIndex => $keyColumnName) { $keyColumnIdentifier = $isRecordIndexed ? $keyColumnIndex : $keyColumnName; $keyParts[] = $record->getColumnValue($keyColumnIdentifier, TRUE); } $key = ArrayHelper::prepareCompositeKey($keyParts); $keyedRecords[$key] = $record; // checking if the record has to be deleted $isDeletable = TRUE; if (isset($nonkeyColumnNames)) { foreach ($nonkeyColumnNames as $columnIndex => $columnName) { $columnIdentifier = $isRecordIndexed ? $columnIndex : $columnName; if ($record->getColumnValue($columnIdentifier) != NULL) { $isDeletable = FALSE; break; } } } else { // the dataset has NO non-key columns. We should not delete these records $isDeletable = FALSE; } if ($isDeletable) { unset($insertedRecordKeys[$key]); unset($updatedRecordKeys[$key]); // the record physically present in database and needs to be deleted if (isset($existingRecords[$key])) { unset($existingRecords[$key]); $deletedRecordKeys[$key] = TRUE; } } elseif (isset($insertedRecordKeys[$key])) { // the key has been already used to insert a record within this batch. This record needs to be part of update operation $updatedRecordKeys[$key] = TRUE; } elseif (isset($existingRecords[$key])) { $updatedRecordKeys[$key] = TRUE; } else { $insertedRecordKeys[$key] = TRUE; } } $sqls = NULL; // deleting existing records $deletedRecordCount = 0; if (isset($deletedRecordKeys)) { $deleteRecordHolder = $this->prepareRecordHolder($request, $keyedRecords, $deletedRecordKeys); // preparing request $deleteRequest = new DatasetDeleteRequest($request->datasetName, $deleteRecordHolder); // preparing statements to delete records from the database ArrayHelper::appendValue($sqls, $this->prepareDeleteDatasetRecordStatements($callcontext, $deleteRequest)); $deletedRecordCount = count($deleteRecordHolder->records); } // inserting new records $insertedRecordCount = 0; if (isset($insertedRecordKeys)) { $insertRecordHolder = $this->prepareRecordHolder($request, $keyedRecords, $insertedRecordKeys); // preparing request $insertRequest = new DatasetInsertRequest($request->datasetName, $insertRecordHolder); // preparing statements to insert records into the database ArrayHelper::appendValue($sqls, $this->prepareInsertDatasetRecordStatements($callcontext, $insertRequest)); $insertedRecordCount = count($insertRecordHolder->records); } // updating existing records $updatedRecordCount = 0; if (isset($updatedRecordKeys)) { $updateRecordHolder = $this->prepareRecordHolder($request, $keyedRecords, $updatedRecordKeys); // preparing request $updateRequest = new DatasetUpdateRequest($request->datasetName, $updateRecordHolder); // preparing statements to update records in the database ArrayHelper::appendValue($sqls, $this->prepareUpdateDatasetRecordStatements($callcontext, $updateRequest)); $updatedRecordCount = count($updateRecordHolder->records); } $affectedRecordCount = isset($sqls) ? $this->executeManipulationStatementBatch($datasource, $sqls) : 0; if (($insertedRecordCount + $updatedRecordCount + $deletedRecordCount) < $affectedRecordCount) { throw new IllegalStateException(t('Number of affected records is greater than expected number of inserted, updated and deleted records')); } return array($insertedRecordCount, $updatedRecordCount, $deletedRecordCount); }
public function countDatasetRecords(DataControllerCallContext $callcontext, DatasetCountRequest $request) { $datasetName = $request->getDatasetName(); LogHelper::log_notice(t('Counting script-based dataset records: @datasetName', array('@datasetName' => $datasetName))); $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $serializer = new DatasetCountUIRequestSerializer(); $parameters = $serializer->serialize($request); $count = $this->executeScriptFunction($dataset, 'countDatasetRecords', $parameters); LogHelper::log_info(t('Counted @count record(s)', array('@count' => $count))); return $count; }
protected function processConfig ( &$config ) { $metamodel = data_controller_get_metamodel(); if ( !empty($config->model->datasets) ) { foreach ( $config->model->datasets as $key => $datasetName ) { $dataset = $metamodel->getDataset($datasetName); if (isset($dataset->uuid)) { $config->model->datasets[$key] = $dataset->uuid; } else { $config->model->datasets[$key] = NameSpaceHelper::removeNameSpace($dataset->name); } } } // update columns if ( !empty($config->model->columns) ) { foreach ( $config->model->columns as $key => $value ) { $config->model->columns[$key] = DatasetExportHelper::getExportColumnName($value,$metamodel); } } // update column configs if ( !empty($config->columnConfigs) ) { foreach ( $config->columnConfigs as $key => $value ) { $config->columnConfigs[$key]->columnId = DatasetExportHelper::getExportColumnName($value->columnId,$metamodel); } } // update column orders if ( !empty($config->model->columnOrder) ) { foreach ( $config->model->columnOrder as $key => $value ) { $config->model->columnOrder[$key] = DatasetExportHelper::getExportColumnName($value,$metamodel); } } // update column sorts if ( !empty($config->model->orderBy) ) { foreach ( $config->model->orderBy as $key => $value ) { $config->model->orderBy[$key]->column = DatasetExportHelper::getExportColumnName($value->column,$metamodel); } } // update visual series if ( !empty($config->visual->series) ) { $newSeries = array(); foreach ( $config->visual->series as $key => $value ) { $newSeries[DatasetExportHelper::getExportColumnName($key,$metamodel)] = $value; } $config->visual->series = $newSeries; } // update traffic column if ( !empty($config->visual->trafficColumn) ) { $config->visual->trafficColumn = DatasetExportHelper::getExportColumnName($config->visual->trafficColumn,$metamodel); } // update color column if ( !empty($config->visual->useColumnDataForColor) ) { $config->visual->useColumnDataForColor = DatasetExportHelper::getExportColumnName($config->visual->useColumnDataForColor,$metamodel); } // update traffic columns if ( !empty($config->visual->traffic) ) { $newTraffic = array(); foreach ( $config->visual->traffic as $key => $value ) { $value->trafficColumn = DatasetExportHelper::getExportColumnName($key,$metamodel); $newTraffic[DatasetExportHelper::getExportColumnName($key,$metamodel)] = $value; } $config->visual->traffic = $newTraffic; } // update filters if ( !empty($config->model->filters) ) { foreach ( $config->model->filters as $key => $value ) { $config->model->filters[$key]->column = DatasetExportHelper::getExportColumnName($value->column,$metamodel); } } }
protected function prepareCubeRequestMetaData(CubeQueryRequest $request) { $metamodel = data_controller_get_metamodel(); $cube = $metamodel->getCube($request->getCubeName()); $this->getDatasetMetaData($cube->sourceDatasetName); if (isset($request->referencedRequests)) { foreach ($request->referencedRequests as $referencedRequest) { $referencedCube = $metamodel->getCube($referencedRequest->getCubeName()); $this->getDatasetMetaData($referencedCube->sourceDatasetName); } } }
protected function populateDatasets() { $metamodel = data_controller_get_metamodel(); $namespaceParts = explode(NameSpaceHelper::NAME_SPACE_SEPARATOR, DATASOURCE_NAME__TEST); $path = realpath(drupal_get_path('module', 'gd_test')) . DIRECTORY_SEPARATOR . '_db' . DIRECTORY_SEPARATOR . 'data' . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $namespaceParts); $handle = opendir($path); if ($handle !== FALSE) { while (($name = readdir($handle)) !== FALSE) { if ($name[0] == '.') { continue; } $fullname = $path . DIRECTORY_SEPARATOR . $name; if (!is_dir($fullname)) { continue; } $datasetName = NameSpaceHelper::addNameSpace(DATASOURCE_NAME__TEST, $name); $dataset = $metamodel->findDataset($datasetName); if (!isset($dataset)) { continue; } $folderName = $fullname; $this->populateDataset($dataset, $folderName); } closedir($handle); } }
protected function assembleForeignKeyConstraints(DataSourceHandler $handler, DatasetMetaData $dataset, $indent, &$sql) { $metamodel = data_controller_get_metamodel(); foreach ($dataset->getColumns() as $column) { $columnName = $column->name; if (!isset($column->type->sourceApplicationType)) { continue; } // the column has to contain a reference to another dataset $dimensionLookupHandler = DimensionLookupFactory::getInstance()->getHandler($column->type->sourceApplicationType); list($referencedDatasetName) = $dimensionLookupHandler->adjustReferencePointColumn($metamodel, $dataset->name, $column->name); if ($dataset->name == $referencedDatasetName) { continue; } $referencedDataset = $metamodel->getDataset($referencedDatasetName); // we can create a foreign key constraint referenced to a table only $referencedDatasetSourceType = DatasetTypeHelper::detectDatasetSourceType($referencedDataset); if ($referencedDatasetSourceType != DatasetTypeHelper::DATASET_SOURCE_TYPE__TABLE) { continue; } $referencedOwner = NULL; if ($dataset->datasourceName != $referencedDataset->datasourceName) { // if we cannot join datasets we cannot create a foreign key constraint $datasourceQueryHandler = DataSourceQueryFactory::getInstance()->getHandler($handler->getDataSourceType()); if (!$datasourceQueryHandler->isJoinSupported($dataset->datasourceName, $referencedDataset->datasourceName)) { continue; } $referencedOwner = $handler->getDataSourceOwner($referencedDataset->datasourceName); } $referencedTableName = $referencedDataset->source; $referencedColumnName = $referencedDataset->getKeyColumn()->name; $sql .= ",\n{$indent}CONSTRAINT fk_{$dataset->source}_{$columnName} FOREIGN KEY ({$columnName}) REFERENCES " . (isset($referencedOwner) ? $referencedOwner . '.' : '') . "{$referencedTableName} ({$referencedColumnName})"; } }
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 static function getExportables($datasourceName) { if ( $datasourceName != gd_datasource_get_active() ) { gd_datasource_set_active($datasourceName); } $metamodel = data_controller_get_metamodel(); // get datasets $datasetNames = array(); foreach ($metamodel->datasets as $dataset) { if (!isset($dataset->nid)) { continue; } $datasetNames[] = $dataset->name; } $referencePointNids = gd_reference_get_reference_points_by_dataset($datasetNames); return gd_reference_get_references_by_reference_points($referencePointNids,LOAD_ENTITY); }