PHP Sequence::getSequenceColumnType方法代码示例

 public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube)
 {
     $column = $dataset->getColumn($columnName);
     $sourceDatasetColumn = $cube->sourceDataset->getColumn($columnName);
     $dimension = $cube->getDimension($columnName);
     $this->prepareYearLevel($dimension, $column);
     // cube source dataset column contains a reference to year identifier
     $sourceDatasetColumn->initializeTypeFrom(Sequence::getSequenceColumnType());
     // adding a reference to date dataset
     $referenceName = DateDimensionDatasetNames::LEVEL_YEARS;
     $metamodel->registerSimpleReferencePoint($referenceName, DateDimensionDatasetNames::LEVEL_YEARS, 'year_id');
     $metamodel->registerSimpleReferencePoint($referenceName, $cube->sourceDatasetName, $columnName);
 }

    public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube) {
        $logicalColumn = $dataset->getColumn($columnName);
        $column = $cube->factsDataset->getColumn($columnName);
        $dimension = $cube->getDimension($columnName);

        // preparing the dimension properties
        $dimension->attributeColumnName = $columnName;
        $dimension->setDatasetName(StarSchemaNamingConvention::getAttributeRelatedName($dataset->name, $columnName));

        // preparing dimension dataset
        $dimension->dataset = new DatasetMetaData();
        $dimension->dataset->name = $dimension->datasetName;
        $dimension->dataset->publicName = $dataset->publicName . " [$logicalColumn->publicName]";
        $dimension->dataset->description = t("Lookup table to store unique values from '@columnName' column", array('@columnName' => $logicalColumn->publicName));
        $dimension->dataset->datasourceName = $dataset->datasourceName;
        $dimension->dataset->source = StarSchemaNamingConvention::getAttributeRelatedName($dataset->source, $columnName);
        $dimension->dataset->markAsPrivate();
        // adding dimension dataset aliases
        if (isset($dataset->aliases)) {
            foreach ($dataset->aliases as $alias) {
                $dimension->dataset->aliases[] = StarSchemaNamingConvention::getAttributeRelatedName($alias, $columnName);
            }
        }

        // adding key column
        $keyColumn = $dimension->dataset->registerColumn($columnName);
        $keyColumn->publicName = $logicalColumn->publicName;
        $keyColumn->description = t("System generated ID to identify each unique value from '@columnName' column", array('@columnName' => $logicalColumn->publicName));
        $keyColumn->initializeTypeFrom(Sequence::getSequenceColumnType());
        $keyColumn->key = TRUE;
        $keyColumn->visible = FALSE;
        
        // adding 'value' column
        $valueColumn = $dimension->dataset->registerColumn('value');
        $valueColumn->publicName = $logicalColumn->publicName;
        $valueColumn->description = t("Actual value from '@columnName' column", array('@columnName' => $logicalColumn->publicName));
        $valueColumn->initializeTypeFrom($logicalColumn->type);

        // facts dataset column contains a reference to lookup
        $column->initializeTypeFrom(Sequence::getSequenceColumnType());
        $column->type->logicalApplicationType = StringDataTypeHandler::DATA_TYPE;

        // marking that the dimension dataset object contains complete meta data & registering it in meta model
        $dimension->dataset->markAsComplete();
        $metamodel->registerDataset($dimension->dataset);

        // adding a reference to the dimension dataset
        $referenceName = $dimension->datasetName;
        $metamodel->registerSimpleReferencePoint($referenceName, $dimension->datasetName, $columnName);
        $metamodel->registerSimpleReferencePoint($referenceName, $cube->factsDatasetName, $columnName);
    }

 protected function adjustReferencedDataType4Casting($datasetName, $columnName) {
     return Sequence::getSequenceColumnType()->applicationType;
 }

 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 function generateAndStoreIdentifiers($lookupDatasetName, array $uniqueSetColumns, array $nonKeyColumns = NULL, $sequenceName, array &$lookupValues) {
        $dataManipulationController = data_controller_dml_get_instance();
        $metamodel = data_controller_get_metamodel();

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

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

        // preparing insert operation meta data
        $recordsHolder = new IndexedRecordsHolder();
        $recordsHolder->recordMetaData = new RecordMetaData();
        // registering 'identifier' column
        $column = $recordsHolder->recordMetaData->registerColumn($identifierColumnName);
        $column->initializeTypeFrom(Sequence::getSequenceColumnType());
        // registering columns which represent lookup key
        foreach ($uniqueSetColumns as $uniqueSetColumn) {
            $column = $recordsHolder->recordMetaData->registerColumn($uniqueSetColumn->name);
            $column->initializeTypeFrom($uniqueSetColumn->type);
            $column->key = TRUE;
        }
        // registering non key columns
        if (isset($nonKeyColumns)) {
            foreach ($nonKeyColumns as $nonKeyColumn) {
                $column = $recordsHolder->recordMetaData->registerColumn($nonKeyColumn->name);
                $column->initializeTypeFrom($nonKeyColumn->type);
            }
        }

        // generating identifiers for source table
        $identifiers = Sequence::getNextSequenceValues($sequenceName, count($lookupValues));

        // preparing records for insert operation
        foreach ($lookupValues as $lookupKey => $lookupValue) {
            $identifier = array_pop($identifiers);

            $record = array($identifier);

            foreach ($uniqueSetColumns as $uniqueSetColumn) {
                $columnName = $uniqueSetColumn->name;
                $record[] = $lookupValue->$columnName;
            }

            if (isset($nonKeyColumns)) {
                $lookupValue = $lookupValues[$lookupKey];
                foreach ($nonKeyColumns as $nonKeyColumn) {
                    $record[] = $lookupValue->{$nonKeyColumn->name};
                }
            }

            $recordInstance = $recordsHolder->initiateRecordInstance();
            $recordInstance->initializeFrom($record);
            $recordsHolder->registerRecordInstance($recordInstance);

            $lookupValue->identifier = $identifier;
            $this->cachedIdentifiers[$lookupCacheKey][$lookupKey] = $identifier;
        }

        $this->freeSpaceInIdentifierCache($lookupDataset->name);

        // storing 'missing' records
        $dataManipulationController->insertDatasetRecordBatch($lookupDataset->name, $recordsHolder);
    }

    public function prepareDimension(MetaModel $metamodel, DatasetMetaData $dataset, $columnName, CubeMetaData $cube) {
        $column = $cube->factsDataset->getColumn($columnName);
        $dimension = $cube->getDimension($columnName);

        $referencedCube = $metamodel->findCube($this->datasetName);
        // TODO DHS Management Cube (we do not have cubes for lookups)
        $referencedDatasetName = isset($referencedCube) ? $referencedCube->factsDatasetName : $this->datasetName;

        // preparing dimension properties
        $dimension->attributeColumnName = $columnName;

        // preparing dimension dataset
        $dimension->setDatasetName($this->datasetName);
        $dimension->dataset = $metamodel->getDataset($dimension->datasetName);

        // facts dataset column contains a reference to lookup
        // TODO DHS Management Cube (column type has been already prepared)
        if (!isset($column->type->applicationType)) {
            $column->initializeTypeFrom(Sequence::getSequenceColumnType());
        }

        // adding a reference to dimension dataset
        $referenceName = $referencedDatasetName;
        $metamodel->registerSimpleReferencePoint($referenceName, $referencedDatasetName, NULL);
        $metamodel->registerSimpleReferencePoint($referenceName, $cube->factsDatasetName, $columnName);
        // ... to support retrieving properties of the dimension dataset
        $metamodel->registerSimpleReferencePoint($referenceName, $dimension->datasetName, $dimension->dataset->getKeyColumn()->name);
    }