protected function finishImpl(array &$records = NULL) {
parent::finishImpl($records);
if (!isset($records)) {
return;
}
$valueMin = $valueMax = NULL;
// preparing minimum and maximum values
foreach ($records as $record) {
if (!isset($record[$this->valueColumnName])) {
continue;
}
$value = $record[$this->valueColumnName];
$valueMin = MathHelper::min($valueMin, $value);
$valueMax = MathHelper::max($value, $valueMax);
}
$valueRange = $valueMax - $valueMin;
// generating weighted grade
foreach ($records as &$record) {
if (!isset($record[$this->valueColumnName])) {
continue;
}
$value = $record[$this->valueColumnName];
$rank = ($valueRange == 0) ? 1 : ($value - $valueMin) / $valueRange;
$record[$this->memberRankColumnName] = $rank;
}
unset($record);
}
public function postFormatRecords(array &$records = NULL)
{
parent::postFormatRecords($records);
if (!isset($records)) {
return;
}
$valueMin = NULL;
$valueMax = NULL;
// preparing minimum and maximum values
foreach ($records as $record) {
if (!isset($record[$this->valuePropertyName])) {
continue;
}
$value = $record[$this->valuePropertyName];
$valueMin = MathHelper::min($valueMin, $value);
$valueMax = MathHelper::max($value, $valueMax);
}
// generating weighted grade
foreach ($records as &$record) {
if (!isset($record[$this->valuePropertyName])) {
continue;
}
$value = $record[$this->valuePropertyName];
$weightedGrade = ($value - $valueMin) / ($valueMax - $valueMin);
$record[$this->weightedGradeProperyName] = $weightedGrade;
}
}
protected function removeTraceFilePath($message) {
$prefix = 'File "';
$suffix = '"';
$index = 0;
while (($startIndex = strpos($message, $prefix, $index)) !== FALSE) {
$startIndex += strlen($prefix);
$endIndex = strpos($message, $suffix, $startIndex);
$fileName = substr($message, $startIndex, $endIndex - $startIndex);
$p1 = strrpos($fileName, '\\');
if ($p1 === FALSE) {
$p1 = NULL;
}
$p2 = strrpos($fileName, '/');
if ($p2 === FALSE) {
$p2 = NULL;
}
$p = MathHelper::max($p1, $p2);
if (isset($p)) {
$message = substr_replace($message, '', $startIndex, $p + 1);
}
$index = $endIndex + 1;
}
return $message;
}
protected function submitRecordImpl(RecordMetaData $recordMetaData, $recordNumber, array &$record) {
$datatypeFactory = DataTypeFactory::getInstance();
foreach ($recordMetaData->getColumns(FALSE) as $column) {
if (!isset($record[$column->columnIndex])) {
continue;
}
$columnValue = $record[$column->columnIndex];
// calculating length of the column value
$column->type->length = MathHelper::max(
(isset($column->type->length) ? $column->type->length : NULL),
strlen($columnValue));
if (isset($column->type->applicationType) && ($column->type->applicationType === StringDataTypeHandler::DATA_TYPE)) {
continue;
}
$columnDataType = $datatypeFactory->autoDetectDataType($columnValue, DATA_TYPE__ALL);
if (isset($column->type->applicationType)) {
try {
$column->type->applicationType = $datatypeFactory->selectCompatibleDataType(
array($column->type->applicationType, $columnDataType));
}
catch (IncompatibleDataTypeException $e) {
// if the two types are incompatible only 'string' type can resolve the problem
$column->type->applicationType = StringDataTypeHandler::DATA_TYPE;
}
}
else {
$column->type->applicationType = $columnDataType;
}
// calculating scale for numeric columns
$handler = $datatypeFactory->getHandler($column->type->applicationType);
if ($handler instanceof AbstractNumberDataTypeHandler) {
$numericColumnValue = $handler->castValue($columnValue);
$decimalSeparatorIndex = strpos($numericColumnValue, $handler->decimalSeparatorSymbol);
if ($decimalSeparatorIndex !== FALSE) {
$scale = strlen($numericColumnValue) - $decimalSeparatorIndex - 1;
if (!isset($column->type->scale) || ($column->type->scale < $scale)) {
$column->type->scale = $scale;
}
}
}
}
}
public function doBeforeRecordSubmitted(RecordMetaData $recordMetaData, $recordNumber, array &$record) {
$result = parent::doBeforeRecordSubmitted($recordMetaData, $recordNumber, $record);
if ($result) {
foreach ($record as &$columnValue) {
if (!is_string($columnValue)) {
continue;
}
if (strlen($columnValue) > $this->maxValueLength) {
$columnValue = substr($columnValue, 0, MathHelper::max($this->maxValueLength - 3, 0)) . '...';
}
}
unset($columnValue);
}
return $result;
}
public function getMaximumColumnCount() {
$count = isset($this->columnNames) ? count($this->columnNames) : NULL;
if (isset($this->nestedLinks)) {
foreach ($this->nestedLinks as $nestedLink) {
$count = MathHelper::max($count, $nestedLink->getMaximumColumnCount());
}
}
return $count;
}
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 prepareDatasetSequence(ReferenceCallContext $callcontext, MetaModel $metamodel, ReferenceLink $link, $referencePath) {
$referenceParts = ReferencePathHelper::splitReference($referencePath);
$parentColumnName = array_pop($referenceParts);
$parentDatasetName = array_pop($referenceParts);
$referencedColumnName = $referencedDatasetName = NULL;
$leftReferencePartCount = count($referenceParts);
$nestedReferencePath = $referencePath;
if ($link->dataset->name == $parentDatasetName) {
// dataset is there and it is link's dataset
if ($leftReferencePartCount == 0) {
return;
}
// assembling new reference path
$nestedReferencePath = ReferencePathHelper::assembleReferenceParts($referenceParts);
$referencedColumnName = array_pop($referenceParts);
$referencedDatasetName = array_pop($referenceParts);
if (!isset($referencedDatasetName)) {
throw new UnsupportedOperationException(t(
'Dataset name is not set in the reference path: %referencePath',
array('%referencePath' => $referencePath)));
}
}
elseif (isset($parentDatasetName)) {
$referencedColumnName = $parentColumnName;
$referencedDatasetName = $parentDatasetName;
$parentColumnName = $parentDatasetName = NULL;
}
else {
if ($leftReferencePartCount > 0) {
throw new UnsupportedOperationException(t(
'Dataset name is not set in the reference path: %referencePath',
array('%referencePath' => $referencePath)));
}
// it means that we just point to column in link's dataset
return;
}
// checking if there any references which could be used to find required dataset
$references = $metamodel->findReferencesByDatasetName($link->dataset->name);
if (!isset($references)) {
return;
}
// maximum number of columns in direct references
$directReferencePointColumnCount = NULL;
// checking if there is any reference which directly link to referenced dataset
$parentReferencePointIndex4References = $directReferencePointIndex4References = $transitionalReferencePointIndexes4References = NULL;
foreach ($references as $reference) {
$referencePointColumnCount = $reference->getPointColumnCount();
// checking if the reference can be used to link with other datasets
$parentReferencePointIndex4Reference = $directReferencePointIndex4Reference = $transitionalReferencePointIndexes4Reference = NULL;
for ($referencePointColumnIndex = 0; $referencePointColumnIndex < $referencePointColumnCount; $referencePointColumnIndex++) {
$parentReferencePointIndex = $directReferencePointIndex = $transitionalReferencePointIndexes = NULL;
foreach ($reference->points as $referencePointIndex => $referencePoint) {
$datasetName = $referencePoint->columns[$referencePointColumnIndex]->datasetName;
if (($link->dataset->name == $datasetName)
&& (!isset($parentColumnName) || ($parentColumnName == $referencePoint->columns[$referencePointColumnIndex]->columnName))) {
if (isset($parentReferencePointIndex)) {
// Found several possible ways to start a join from the referring dataset.
// That happens because we do not have parent column name and possible join is ambiguous
// We cannot use this way to proceed
continue 3;
}
else {
$parentReferencePointIndex = $referencePointIndex;
}
}
elseif ($datasetName == $referencedDatasetName) {
if (isset($directReferencePointIndex)) {
// found several possible ways to join with the referenced dataset
continue 3;
}
else {
$directReferencePointIndex[$referencePointIndex] = TRUE;
}
}
else {
$transitionalReferencePointIndexes[$referencePointIndex] = FALSE;
}
}
// this reference cannot be used because none of the reference points linked with parent dataset
if (!isset($parentReferencePointIndex)) {
continue 2;
}
if (isset($directReferencePointIndex)) {
// if we have direct reference we do not care about indirect ones
$transitionalReferencePointIndexes = NULL;
}
else {
// there is no direct or indirect ways. This reference is useless :)
if (!isset($transitionalReferencePointIndexes)) {
continue 2;
}
}
$parentReferencePointIndex4Reference[$referencePointColumnIndex] = $parentReferencePointIndex;
if (isset($directReferencePointIndex)) {
$directReferencePointIndex4Reference[$referencePointColumnIndex] = $directReferencePointIndex;
}
if (isset($transitionalReferencePointIndexes)) {
$transitionalReferencePointIndexes4Reference[$referencePointColumnIndex] = $transitionalReferencePointIndexes;
}
}
// we support only direct references between datasets
// in this case we have direct reference based on some columns only. Rest columns are connected indirectly
if (isset($directReferencePointIndex4Reference) && isset($transitionalReferencePointIndexes4Reference)) {
continue;
}
$parentReferencePointIndex4References[$reference->name] = $parentReferencePointIndex4Reference;
if (isset($directReferencePointIndex4Reference)) {
$directReferencePointIndex4References[$reference->name] = $directReferencePointIndex4Reference;
$directReferencePointColumnCount = MathHelper::max($directReferencePointColumnCount, $referencePointColumnCount);
}
if (isset($transitionalReferencePointIndexes4Reference)) {
$transitionalReferencePointIndexes4References[$reference->name] = $transitionalReferencePointIndexes4Reference;
}
}
// we could use none of the selected references
if (!isset($parentReferencePointIndex4References)) {
return;
}
// removing all useless direct and indirect references if there is a direct way
if (isset($directReferencePointColumnCount)) {
foreach ($parentReferencePointIndex4References as $referenceName => $parentReferencePointIndex4Reference) {
$referencePointColumnCount = count($parentReferencePointIndex4Reference);
if (isset($directReferencePointIndex4References[$referenceName])) {
// we preserve only direct ways with maximum number of columns
if ($referencePointColumnCount == $directReferencePointColumnCount) {
continue;
}
}
else {
// we preserve only indirect ways with more columns than in direct way
if ($referencePointColumnCount > $directReferencePointColumnCount) {
continue;
}
}
unset($parentReferencePointIndex4References[$referenceName]);
unset($directReferencePointIndex4References[$referenceName]);
unset($transitionalReferencePointIndexes4References[$referenceName]);
}
}
foreach ($parentReferencePointIndex4References as $referenceName => $parentReferencePointIndex4Reference) {
$reference = $references[ArrayHelper::search($references, 'name', $referenceName)];
$referencePointColumnCount = $reference->getPointColumnCount();
$referencePointIndexes4Reference = isset($directReferencePointIndex4References[$referenceName])
? $directReferencePointIndex4References[$referenceName]
: NULL;
$isDirectReference = isset($referencePointIndexes4Reference);
if (!$isDirectReference) {
// 01/09/2014 reference can be reused only for direct references
if (isset($callcontext->referenceNameStack[$referenceName])) {
continue;
}
$referencePointIndexes4Reference = isset($transitionalReferencePointIndexes4References[$referenceName])
? $transitionalReferencePointIndexes4References[$referenceName]
: NULL;
}
// registering the reference in a stack to avoid excessive calls
// registration was moved here because we could have date[->month->quarter->year] and year columns in one dataset
// if references related to date and year are registered before we start to process individual references
// we will end up with nested links for date->month->quarter->year which do not contain a reference to year
// which leads to GOVDB-1313 issue
$callcontext->referenceNameStack[$reference->name] = TRUE;
// preparing dataset names for each reference point
$referencePointDatasetNames = NULL;
for ($referencePointColumnIndex = 0; $referencePointColumnIndex < $referencePointColumnCount; $referencePointColumnIndex++) {
foreach ($referencePointIndexes4Reference[$referencePointColumnIndex] as $referencePointIndex => $directReferencePointFlag) {
$referencePointColumn = $reference->points[$referencePointIndex]->columns[$referencePointColumnIndex];
$datasetName = $referencePointColumn->datasetName;
// it is expected that dataset name is the same for all columns in a reference point
if (isset($referencePointDatasetNames[$referencePointIndex])) {
if ($referencePointDatasetNames[$referencePointIndex] != $datasetName) {
// Dataset name is not the same for all columns for the reference point
$referencePointDatasetNames[$referencePointIndex] = FALSE;
}
}
else {
$referencePointDatasetNames[$referencePointIndex] = $datasetName;
}
}
}
// removing all reference points which we cannot support now
foreach ($referencePointDatasetNames as $referencePointIndex => $datasetName) {
if ($datasetName === FALSE) {
unset($referencePointDatasetNames[$referencePointIndex]);
}
}
// if nothing left there is not need to proceed
if (count($referencePointDatasetNames) == 0) {
continue;
}
// preparing list of parent column names
$parentColumnNames = NULL;
for ($referencePointColumnIndex = 0; $referencePointColumnIndex < $referencePointColumnCount; $referencePointColumnIndex++) {
$parentReferencePointIndex = $parentReferencePointIndex4Reference[$referencePointColumnIndex];
$parentReferencePointColumnName = $reference->points[$parentReferencePointIndex]->columns[$referencePointColumnIndex]->columnName;
$parentColumnNames[$referencePointColumnIndex] = $parentReferencePointColumnName;
}
$referenceCallContext = $isDirectReference ? $callcontext : (clone $callcontext);
// adding all indirect datasets in stack to prevent recursive calls
if (!$isDirectReference) {
foreach ($referencePointDatasetNames as $referencePointIndex => $datasetName) {
if (isset($referenceCallContext->datasetNameStack[$datasetName])) {
unset($referencePointDatasetNames[$referencePointIndex]);
}
else {
$referenceCallContext->datasetNameStack[$datasetName] = TRUE;
}
}
}
foreach ($referencePointDatasetNames as $referencePointIndex => $datasetName) {
// looking for existing link
$referencedLink = $link->findNestedLinkByDatasetNameAndParentColumnNames($datasetName, $parentColumnNames);
if (!isset($referencedLink)) {
$dataset = $metamodel->getDataset($datasetName);
$referencedLink = new ReferenceLink($dataset);
foreach ($parentColumnNames as $referencePointColumnIndex => $parentReferencePointColumnName) {
$referencePointColumn = $reference->points[$referencePointIndex]->columns[$referencePointColumnIndex];
$referencedLink->linkColumnWithParent($referencePointColumnIndex, $parentReferencePointColumnName, $referencePointColumn->columnName);
}
$link->registerNestedLink($referencedLink);
}
ArrayHelper::addUniqueValue($referencedLink->referenceNames, $referenceName);
// marking the link as required for the branch so it will not be deleted by the optimizer later
if ($isDirectReference) {
$referencedLink->required = TRUE;
}
// because this reference path is not processed completely we need to continue scanning this branch
if (isset($nestedReferencePath)) {
LogHelper::log_debug(t(
'Checking sub-path[linkId: @linkId; stackSize: @stackSize]: @referencePath',
array('@linkId' => $referencedLink->linkId, '@stackSize' => count($callcontext->referenceNameStack), '@referencePath' => $referencePath)));
$referencePointCallContext = clone $referenceCallContext;
$this->prepareDatasetSequence($referencePointCallContext, $metamodel, $referencedLink, $nestedReferencePath);
}
}
}
}
public function findLastColumnIndex()
{
$lastColumnIndex = NULL;
foreach ($this->columns as $column) {
$lastColumnIndex = MathHelper::max($lastColumnIndex, $column->columnIndex);
}
return $lastColumnIndex;
}
