コード例 #1
0
function testDatasetUploader_createDatasetStorage($dataset)
{
    $dataController = data_controller_get_instance();
    echo "<h2>Creaing dataset storage</h2>\n";
    $dataController->createDatasetStorage($dataset->name);
    $dataController->createCubeStorage($dataset->name);
    echo "Completed\n";
}
コード例 #2
0
    public static function getNextSequenceValues($sequenceName, $quantity, $datasourceName = NULL) {
        $dataQueryController = data_controller_get_instance();

        $registration = isset($datasourceName) ? self::getRegistration($datasourceName) : self::getDefaultRegistration();

        return $dataQueryController->getNextSequenceValues($registration->datasourceName, $sequenceName, $quantity);
    }
コード例 #3
0
 protected function guaranteeDayOfWeekDefinitionInCache()
 {
     $lookupCacheKey = DateDimensionDatasetNames::DAY_OF_WEEK_DEF;
     if (!isset($this->cachedLookupValues[$lookupCacheKey])) {
         $dataQueryController = data_controller_get_instance();
         $definitionProperties = $dataQueryController->queryDataset(DateDimensionDatasetNames::DAY_OF_WEEK_DEF, array('day_of_week_def_id', 'code'));
         foreach ($definitionProperties as $properties) {
             $key = $properties['code'];
             $value = $properties['day_of_week_def_id'];
             $this->cachedLookupValues[$lookupCacheKey][$key] = $value;
         }
     }
 }
コード例 #4
0
ファイル: Sequence.php プロジェクト: ecs-hk/Checkbook
 /**
  * @static
  * @param $sequenceName
  * @param $quantity
  * @return array
  */
 public static function getNextSequenceValues($sequenceName, $quantity)
 {
     self::checkDataSourceName();
     $dataQueryController = data_controller_get_instance();
     return $dataQueryController->getNextSequenceValues(self::$DATA_SOURCE_NAME, $sequenceName, $quantity);
 }
    protected function loadIdentifiers($lookupDatasetName, array $uniqueSetColumns, array &$lookupValues) {
        $dataQueryController = data_controller_get_instance();
        $metamodel = data_controller_get_metamodel();

        $lookupDataset = $metamodel->getDataset($lookupDatasetName);
        $identifierColumnName = $lookupDataset->getKeyColumn()->name;

        $lookupCacheKey = $this->prepareLookupCacheKey($lookupDataset->name);

        $isCompositeUniqueSet = count($uniqueSetColumns) > 1;

        // preparing parameters for the query
        $queryParameters = NULL;
        foreach ($lookupValues as $lookupKey => $lookupValue) {
            if (isset($lookupValue->identifier)) {
                continue;
            }

            if (isset($this->cachedIdentifiers[$lookupCacheKey][$lookupKey])) {
                $lookupValues[$lookupKey]->identifier = $this->cachedIdentifiers[$lookupCacheKey][$lookupKey];
                continue;
            }

            if ($isCompositeUniqueSet) {
                $keyColumnValues = NULL;
                foreach ($uniqueSetColumns as $column) {
                    $columnName = $column->name;
                    $keyColumnValues[$columnName] = $lookupValue->$columnName;
                }

                $queryParameters[] = $keyColumnValues;
            }
            else {
                $columnName = $uniqueSetColumns[0]->name;
                $queryParameters[$columnName][] = $lookupValue->$columnName;
            }
        }
        if (!isset($queryParameters)) {
            return;
        }

        // preparing columns for the query
        $queryColumns = array($identifierColumnName);
        foreach ($uniqueSetColumns as $column) {
            ArrayHelper::addUniqueValue($queryColumns, $column->name);
        }

        // loading data from database for 'missing' records
        $loadedLookupProperties = $dataQueryController->queryDataset($lookupDataset->name, $queryColumns, $queryParameters);

        // processing found records
        if (isset($loadedLookupProperties)) {
            $foundUnmatchedIdentifiers = FALSE;
            foreach ($loadedLookupProperties as $lookupProperties) {
                $identifier = $lookupProperties[$identifierColumnName];

                // preparing lookup key
                $keyItems = NULL;
                foreach ($uniqueSetColumns as $column) {
                    $keyItems[] = $lookupProperties[$column->name];
                }
                $lookupKey = self::prepareLookupKey($keyItems);

                if (!isset($lookupValues[$lookupKey])) {
                    if (count($lookupValues) == 1) {
                        // 04/23/2014 if only one record requested and one record received, but the received key does not match the request
                        // it means that character encoding functionality is more sophisticated on server and we actually have a match

                        // storing the value into cache for further usage
                        $this->cachedIdentifiers[$lookupCacheKey][$lookupKey] = $identifier;

                        reset($lookupValues);
                        $alternativeLookupKey = key($lookupValues);
                        $lookupKey = $alternativeLookupKey;
                    }
                    else {
                        $foundUnmatchedIdentifiers = TRUE;
                        continue;
                    }
                }
                if (isset($lookupValues[$lookupKey]->identifier)) {
                    $searchCriteria = array();
                    foreach ($uniqueSetColumns as $column) {
                        $searchCriteria[$column->name] = $lookupProperties[$column->name];
                    }
                    LogHelper::log_error(t(
                        'Key: @searchCriteria. Loaded identifiers: @identifiers',
                        array(
                            '@searchCriteria' => ArrayHelper::serialize($searchCriteria, ', ', TRUE, FALSE),
                            '@identifiers' => ArrayHelper::serialize(array($lookupValues[$lookupKey]->identifier, $identifier), ', ', TRUE, FALSE))));
                    throw new IllegalArgumentException(t(
                        'Several records in %datasetName dataset match search criteria',
                        array('%datasetName' => $lookupDataset->publicName)));
                }
                $lookupValues[$lookupKey]->identifier = $identifier;

                // storing the value into cache for further usage
                $this->cachedIdentifiers[$lookupCacheKey][$lookupKey] = $identifier;
            }

            // found unmatched values. Processing unprocessed lookups one by one
            if ($foundUnmatchedIdentifiers) {
                foreach ($lookupValues as $lookupKey => $lookupValue) {
                    if (!isset($lookupValue->identifier)) {
                        $singleLookupValue = array($lookupKey => $lookupValue);
                        $this->loadIdentifiers($lookupDatasetName, $uniqueSetColumns, $singleLookupValue);
                    }
                }
            }

            $this->freeSpaceInIdentifierCache($lookupDataset->name);
        }
    }
    public function permitDatasetStorageTruncation(DataControllerCallContext $callcontext, DatasetMetaData $logicalDataset) {
        parent::permitDatasetStorageTruncation($callcontext, $logicalDataset);

        if (!self::isLookupDataset($logicalDataset)) {
            return;
        }

        $dataQueryController = data_controller_get_instance();
        $metamodel = data_controller_get_metamodel();

        // checking of the reference datasets have any NOT NULL data in reference columns
        $populatedReferenceDatasetPublicNames = NULL;
        foreach ($metamodel->datasets as $dataset) {
            foreach ($dataset->getColumns(FALSE, TRUE) as $column) {
                if ($column->persistence != ColumnMetaData::PERSISTENCE__STORAGE_CREATED) {
                    continue;
                }
                if ($column->type->getReferencedDatasetName() == $logicalDataset->name) {
                    $recordCount = $dataQueryController->countDatasetRecords(
                        $dataset->name,
                        array($column->name => OperatorFactory::getInstance()->initiateHandler(NotEmptyOperatorHandler::OPERATOR__NAME)));
                    if ($recordCount > 0) {
                        $populatedReferenceDatasetPublicNames[] = $dataset->publicName;
                        break;
                    }
                }
            }
        }

        // we should not allow to truncate the dataset if there is any data in any reference datasets
        if (isset($populatedReferenceDatasetPublicNames)) {
            throw new IllegalArgumentException(t(
                "%datasetName dataset is referenced by other datasets. The dataset truncation is not permitted unless records in %referenceDatasetNames datasets are deleted first",
                array(
                    '%datasetName' => $logicalDataset->publicName,
                    '%referenceDatasetNames' => ArrayHelper::serialize($populatedReferenceDatasetPublicNames))));
        }
    }
    /**
     * @param DataControllerCallContext $callcontext
     * @param DatasetMetaData $modifiedDataset
     * @param DatasetStorageObserver[] $observers
     */
    public function execute(DataControllerCallContext $callcontext, DatasetMetaData $modifiedDataset, array $observers = NULL) {
        $dataQueryController = data_controller_get_instance();

        $this->revertIneligibleColumnPropertyValues($modifiedDataset);

        $callcontext->changeAction = new DatasetStorageChangeAction();

        $originalDataset = $dataQueryController->getDatasetMetaData($modifiedDataset->name);

        $this->gatherChanges($callcontext, $originalDataset, $modifiedDataset, $observers);

        if ($callcontext->changeAction->isUpdated()) {
            $this->initialize($callcontext, $originalDataset, $observers);
            $this->validate($callcontext, $modifiedDataset, $observers);

            LogHelper::log_debug($callcontext->changeAction);

            $this->disableColumns($callcontext, $originalDataset, $modifiedDataset, $observers);
            $this->dropDatasetKey($callcontext, $originalDataset, $modifiedDataset, $observers);
            $this->dropColumnStorage($callcontext, $originalDataset, $modifiedDataset, $observers);
            $this->updateColumnList($callcontext, $originalDataset, $modifiedDataset, $observers);
            $this->createColumnStorage($callcontext, $originalDataset, $modifiedDataset, $observers);
            $this->updateProperties($callcontext, $originalDataset, $modifiedDataset, $observers);

            $this->finalize($callcontext, $originalDataset, $observers);
        }
    }
    protected function generateDatasetUIMetaData($datasetName, $referencePath = NULL) {
        $dataQueryController = data_controller_get_instance();
        $metamodel = data_controller_get_metamodel();

        $uiMetaData = new DatasetUIMetaData();

        $cube = $metamodel->findCubeByDatasetName($datasetName);
        if (isset($cube)) {
            // loading full meta data for the cube
            $cube = $dataQueryController->getCubeMetaData($cube->name);

            $generator = new CubeUIMetaDataGenerator();
            $generator->generate($uiMetaData, $cube, $referencePath);
        }
        else {
            $dataset = $metamodel->getDataset($datasetName);
            // loading full meta data for the dataset
            $dataset = $dataQueryController->getDatasetMetaData($dataset->name);

            $generator = new DatasetUIMetaDataGenerator();
            $generator->generate($uiMetaData, $dataset, $referencePath);
        }

        return $uiMetaData;
    }