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);
}
