PHP ArrayHelper::serialize方法代码示例

    protected function registerRecordImpl(array &$records = NULL, $record) {
        parent::registerRecordImpl($records, $record);

        $recordKey = NULL;
        foreach ($this->keyColumnNames as $keyColumnName) {
            $recordKey[] = isset($record[$keyColumnName]) ? $record[$keyColumnName] : NULL;
        }

        $key = ArrayHelper::prepareCompositeKey($recordKey);
        if (isset($records[$key])) {
            if ($this->isColumnValueUnique) {
                throw new IllegalArgumentException(t(
                	'Found several records for the key: %key',
                    array('%key' => ArrayHelper::serialize($recordKey, ', ', TRUE, TRUE))));
            }

            $records[$key][] = $record;
        }
        else {
            if ($this->isColumnValueUnique) {
                $records[$key] = $record;
            }
            else {
                $records[$key][] = $record;
            }
        }

        return TRUE;
    }

    public function replaceColumnNames(ParserCallback $callback, &$callerSession) {
        $columnName = $callback->marker;

        $column = $this->columnReferenceFactory->getColumn($columnName);
        $this->approveColumn4ParticipationInExpression($column);

        if ($column->persistence == FormulaMetaData::PERSISTENCE__CALCULATED) {
            // checking if the column is already in the stack
            if (in_array($column->name, $this->columnAssemblingStack)) {
                $columnPublicNames = NULL;
                // adding columns from stack
                foreach ($this->columnAssemblingStack as $stackColumnName) {
                    $stackColumn = $this->dataset->getColumn($stackColumnName);
                    $columnPublicNames[] = $stackColumn->publicName;
                }
                // adding current processed column
                $columnPublicNames[] = $column->publicName;

                throw new IllegalStateException(t(
                    'Circular reference in formula expression is not allowed: %stack',
                    array('%stack' => ArrayHelper::serialize($columnPublicNames, ', ', TRUE, FALSE))));
            }

            array_push($this->columnAssemblingStack, $column->name);

            $language = isset($column->expressionLanguage) ? $column->expressionLanguage : NULL;
            $parser = new FormulaExpressionParser($language);

            $expression = $parser->expressionLanguageHandler->clean($column->source);

            $callback->marker = $parser->parse($expression, array($this, 'replaceColumnNames'));

            array_pop($this->columnAssemblingStack);

            $callback->removeDelimiters = TRUE;
        }
    }

    protected function loadColumnsProperties(SystemTableMetaModelLoaderCallContext $callcontext, DataSourceMetaData $datasource) {
        $tableNames = NULL;
        foreach ($callcontext->datasets as $dataset) {
            $tableNames[] = $dataset->sourse;
        }
        if (!isset($tableNames)) {
            return NULL;
        }

        $sql =
            'SELECT c.relname AS ' . self::CN_TABLE_NAME . ",\n" .
            '       a.attname AS ' . self::CN_COLUMN_NAME . ",\n" .
            '       a.attnum AS ' . self::CN_COLUMN_INDEX . ",\n" .
            '       t.typname AS ' . self::CN_COLUMN_TYPE .
            "  FROM pg_class c INNER JOIN pg_namespace ns ON ns.oid = c.relnamespace\n" .
            "       INNER JOIN pg_attribute a ON a.attrelid = c.oid\n" .
            "       INNER JOIN pg_type t ON t.oid = a.atttypid\n" .
            " WHERE c.relkind IN ('r','v')\n" .
            "   AND ns.nspname = '$datasource->schema'\n" .
            "   AND a.attnum > 0\n" .
            '   AND c.relname IN (' .  ArrayHelper::serialize($tableNames) . ')';

        return $this->executeQuery($datasource, 'table.column', $sql);
    }

    protected function loadConstraintColumnsProperties(SystemTableMetaModelLoaderCallContext $callcontext, DataSourceMetaData $datasource, array $constraintTypes) {
        $eligibleOwners = $this->getEligibleOwners(
            $callcontext,
            (isset($datasource->schema) ? $datasource->schema : NULL));
        $ineligibleOwners = $this->getIneligibleOwners($callcontext);

        $types = $this->convertConstraintTypes($constraintTypes);

        $sql =
            'SELECT c.constraint_schema AS ' . self::CN_TABLE_OWNER . ",\n" .
            '       cu.constraint_name AS ' . self::CN_OBJECT_NAME . ",\n" .
            '       cu.table_name AS ' . self::CN_TABLE_NAME . ",\n" .
            '       cu.column_name AS ' . self::CN_COLUMN_NAME . ",\n" .
            '       (cu.ordinal_position - 1) AS ' . self::CN_COLUMN_INDEX . "\n" .
            "  FROM information_schema.key_column_usage cu JOIN information_schema.table_constraints c ON cu.constraint_name = c.constraint_name AND cu.constraint_catalog = c.constraint_catalog\n" .
            " WHERE cu.table_catalog = '{$datasource->database}'\n" .
            "   AND cu.constraint_catalog = cu.table_catalog\n" .
            '   AND c.constraint_type IN (' . ArrayHelper::serialize($types) . ')';
        $this->appendOwnerStatementCondition($sql, TRUE, 'c.constraint_schema', $eligibleOwners, $ineligibleOwners);

        return $this->executeQuery($datasource, 'constraint.column', $sql);
    }

    public function findNestedLinkByDatasetNameAndParentColumnNames($datasetName, $parentColumnNames) {
        $selectedNestedLink = NULL;

        if (isset($this->nestedLinks)) {
            $parentColumnCount = count($parentColumnNames);
            foreach ($this->nestedLinks as $nestedLink) {
                if ($nestedLink->dataset->name !== $datasetName) {
                    continue;
                }

                $nestedLinkParentColumnCount = count($nestedLink->parentColumnNames);
                if ($nestedLinkParentColumnCount != $parentColumnCount) {
                    continue;
                }

                foreach ($nestedLink->parentColumnNames as $parentColumnIndex => $nestedLinkParentColumnName) {
                    if (!isset($parentColumnNames[$parentColumnIndex])) {
                        continue 2;
                    }

                    if ($nestedLinkParentColumnName != $parentColumnNames[$parentColumnIndex]) {
                        continue 2;
                    }
                }

                if (isset($selectedNestedLink)) {
                    throw new UnsupportedOperationException(t(
                        'Found several nested reference links for %datasetName dataset by the parent columns: %parentColumns',
                        array(
                            '%datasetName' => $datasetName,
                            '%parentColumns' => ArrayHelper::serialize($parentColumnNames, ', ', TRUE, FALSE))));
                }

                $selectedNestedLink = $nestedLink;
            }
        }

        return $selectedNestedLink;
    }

    protected function loadConstraintColumnsProperties(SystemTableMetaModelLoaderCallContext $callcontext, DataSourceMetaData $datasource, array $constraintTypes) {
        $eligibleOwners = $this->getEligibleOwners($callcontext, $datasource->username);
        $ineligibleOwners = $this->getIneligibleOwners($callcontext);

        $types = $this->convertConstraintTypes($constraintTypes);

        $sql =
            'SELECT c.owner AS ' . self::CN_TABLE_OWNER . ",\n" .
            '       cc.constraint_name AS ' . self::CN_OBJECT_NAME . ",\n" .
            '       cc.table_name AS ' . self::CN_TABLE_NAME . ",\n" .
            '       cc.column_name AS ' . self::CN_COLUMN_NAME . ",\n" .
            '       (cc.position - 1) AS ' . self::CN_COLUMN_INDEX . "\n" .
            "  FROM all_cons_columns cc JOIN all_constraints c ON cc.constraint_name = c.constraint_name AND cc.owner = c.owner\n" .
            ' WHERE c.constraint_type IN (' . ArrayHelper::serialize($types) . ')';
        $this->appendOwnerStatementCondition($sql, TRUE, 'c.owner', $eligibleOwners, $ineligibleOwners);

        return $this->executeQuery($datasource, 'constraint.column', $sql);
    }

    protected function prepareCacheEntryName() {
        $entryName = NULL;

        $filters = $this->getMetaModelFilters();
        if (isset($filters)) {
            $suffix = NULL;

            ksort($filters);
            foreach ($filters as $className => $properties) {
                if (isset($suffix)) {
                    $suffix .= ',';
                }
                $suffix .= $className . '{';

                $propertySuffix = NULL;

                ksort($properties);
                foreach ($properties as $propertyName => $filterValues) {
                    sort($filterValues);

                    if (isset($propertySuffix)) {
                        $propertySuffix .= ',';
                    }
                    $propertySuffix .= $propertyName . '=' . ArrayHelper::serialize($filterValues, ',', TRUE, FALSE);
                }

                $suffix .= $propertySuffix . '}';
            }

            $entryName = $suffix;
        }

        return $entryName;
    }

    public function getValues(array $names, array $options = NULL) {
        $timeStart = microtime(TRUE);

        $values = parent::getValues($names, $options);

        $nameCount = count($names);
        $loadedValueCount = count($values);

        LogHelper::log_debug(t(
            '[@cacheType] Requested entries: @entryNames',
            array(
                '@cacheType' => $this->getCacheType(),
                '@entryNames' => ArrayHelper::serialize(array_values($names), ', ', TRUE, FALSE))));
        LogHelper::log_debug(
            t('[@cacheType] Retrieved entries: @entryNames',
                array(
                    '@cacheType' => $this->getCacheType(),
                    '@entryNames' => (($nameCount == $loadedValueCount)
                        ? 'ALL'
                        : (isset($values) ? ArrayHelper::serialize(array_keys($values), ', ', TRUE, FALSE) : t('NONE'))))));
        LogHelper::log_info(t(
            '[@cacheType] Execution time for retrieving @entryCount entry(-ies) is !executionTime@successFlag',
            array(
                '@cacheType' => $this->getCacheType(),
                '@entryCount' => $nameCount,
                '!executionTime' => LogHelper::formatExecutionTime($timeStart),
                '@successFlag' => (
                    isset($values)
                        ? (($nameCount == $loadedValueCount)
                            ? ''
                            : t(" (cache hit for ONLY @loadedValueCount entry(-ies) out of @nameCount)", array('@loadedValueCount' => $loadedValueCount, '@nameCount' => $nameCount)))
                        : (' (' . t('cache was NOT hit') . ')')))));

        return $values;
    }

    protected function selectDataType(array $datatypes, $selectCompatible = TRUE) {
        // eliminating null records from the array
        if (isset($datatypes)) {
            foreach ($datatypes as $index => $datatype) {
                if (!isset($datatype)) {
                    unset($datatypes[$index]);
                }
            }
            if (count($datatypes) == 0) {
                $datatypes = NULL;
            }
        }
        if (!isset($datatypes)) {
            return NULL;
        }

        // checking if all elements are equal
        $selectedDataType = NULL;
        foreach ($datatypes as $datatype) {
            if (isset($selectedDataType)) {
                if ($selectedDataType != $datatype) {
                    $selectedDataType = NULL;
                    break;
                }
            }
            else {
                $selectedDataType = $datatype;
            }
        }

        if (isset($selectedDataType)) {
            return $selectedDataType;
        }

        // checking if we need to return compatible type
        if (!$selectCompatible) {
            // if some types are not compatible we need to return the lowest compatible type
            if (!$this->areCompatible($datatypes)) {
                $selectCompatible = TRUE;
            }
        }

        $selectedDataTypes = $datatypes;
        if ($selectCompatible) {
            do {
                $initialDataTypeCount = count($selectedDataTypes);
                $selectedDataTypes = $this->selectCompatible($selectedDataTypes);
                $selectedDataTypeCount = count($selectedDataTypes);
                if (($initialDataTypeCount > 1) && ($initialDataTypeCount == $selectedDataTypeCount)) {
                    throw new IncompatibleDataTypeException(t(
                    	'Data types are inter-compatible. Single type could not be selected: %datatypes',
                        array('%datatypes' => ArrayHelper::serialize($datatypes, ',', TRUE, FALSE))));
                }
            }
            while ($selectedDataTypeCount > 1);
        }
        else {
            // it is expected that we have only 2 types here
            while (($datatypeCount = count($selectedDataTypes)) >= 2) {
                $datatypeA = $selectedDataTypes[0];
                $datatypeB = $selectedDataTypes[1];
                $selectedByDataTypeA = $this->getHandler($datatypeA)->selectCompatible($datatypeB);
                $selectedByDataTypeB = $this->getHandler($datatypeB)->selectCompatible($datatypeA);

                $selectedDataType = NULL;
                if (isset($selectedByDataTypeA)) {
                    if (isset($selectedByDataTypeB)) {
                        throw new IncompatibleDataTypeException(t(
                        	'%datatypeA and %datatypeB data types are inter-compatible. Single type could not be selected',
                            array('%datatypeA' => $datatypeA, '%datatypeB' => $datatypeB)));
                    }
                    else {
                        $selectedDataType = $selectedByDataTypeA;
                    }
                }
                elseif (isset($selectedByDataTypeB)) {
                    $selectedDataType = $selectedByDataTypeB;
                }
                else {
                    throw new UnsupportedOperationException();
                }

                $selectedDataTypes = array_slice($selectedDataTypes, 2);
                // selecting opposite data type. We do not need the lowest compatible type
                $selectedDataTypes[] = ($selectedDataType == $datatypeA) ? $datatypeB : $datatypeA;
            }
        }

        if (count($selectedDataTypes) == 1) {
            return $selectedDataTypes[0];
        }
        else {
            throw new IncompatibleDataTypeException(t(
            	'Incompatible data types: %datatypes',
                array('%datatypes' => ArrayHelper::serialize($datatypes, ',', TRUE, FALSE))));
        }
    }

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

//.........这里部分代码省略.........

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

    public function getValues(array $names, array $options = NULL) {
        $this->checkAccessibility(TRUE);

        $cacheEntryNameMap = NULL;
        foreach ($names as $name) {
            $cacheEntryName = $this->assembleCacheEntryName($name);
            $cacheEntryNameMap[$cacheEntryName] = $name;
        }
        if (!isset($cacheEntryNameMap)) {
            return NULL;
        }

        $result = NULL;
        try {
            $cacheEntries = $this->loadValues(array_keys($cacheEntryNameMap), $options);

            foreach ($cacheEntryNameMap as $cacheEntryName => $name) {
                if (!isset($cacheEntries[$cacheEntryName])) {
                    continue;
                }

                $value = $cacheEntries[$cacheEntryName];

                $result[$name] = $value;

                unset($cacheEntries[$cacheEntryName]);
            }

            // checking for unknown returned entries which are still in the list (were not processed)
            if (isset($cacheEntries)) {
                $unrequestedCacheEntryNames = array_keys($cacheEntries);
                if (count($unrequestedCacheEntryNames) > 0) {
                    throw new IllegalStateException(t(
                        'Received unrequested data for the cache entry names: %cacheEntryName',
                        array('%cacheEntryName' => ArrayHelper::serialize($unrequestedCacheEntryNames, ', ', TRUE, FALSE))));
                }
            }
        }
        catch (Exception $e) {
            LogHelper::log_error($e);
        }

        return $result;
    }