public static function getNamedArguments() { global $argv; $datatypeFactory = DataTypeFactory::getInstance(); $namedArguments = NULL; foreach ($argv as $argument) { $index = strpos($argument, '='); if ($index === FALSE) { continue; } // preparing name of the argument $name = trim(substr($argument, 0, $index)); // preparing value of the argument $value = substr($argument, $index + 1); if ($value === FALSE) { continue; } else { $value = $datatypeFactory->getHandler($datatypeFactory->autoDetectDataType($value))->castValue($value); } if (isset($namedArguments[$name])) { $oldValue = $namedArguments[$name]; if (is_array($oldValue)) { $oldValue[] = $value; $namedArguments[$name] = $oldValue; } else { $namedArguments[$name] = array($oldValue, $value); } } else { $namedArguments[$name] = $value; } } return $namedArguments; }
protected function offsetLatestValue($latestQuarterValue, $offset) { // converting number of quarters to number of months $monthOffset = $offset * 3; $datetime = new DateTime($latestQuarterValue); $datetime->sub(new DateInterval("P{$monthOffset}M")); $dateDataTypeHandler = DataTypeFactory::getInstance()->getHandler(DateDataTypeHandler::DATA_TYPE); return $datetime->format($dateDataTypeHandler->getFormat()); }
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) { $datatypeFactory = DataTypeFactory::getInstance(); foreach ($recordMetaData->getColumns() as $column) { if (!isset($record[$column->columnIndex])) { continue; } // FIXME convert data to data type of corresponding lookup dataset column if ($column->type->getReferencedDatasetName() != NULL) { continue; } $handler = $datatypeFactory->getHandler($column->type->applicationType); try { $record[$column->columnIndex] = $handler->castValue($record[$column->columnIndex]); } catch (Exception $e) { $this->exceptionPool[$recordNumber][$column->publicName] = array( 'file' => $e->getFile(), 'line' => $e->getLine(), 'message' => ExceptionHelper::getExceptionMessage($e)); $this->exceptionCount++; if ($this->exceptionCount >= $this->exceptionPoolSize) { $this->publishExceptions(TRUE); } } } $result = !isset($this->exceptionPool); } return $result; }
public function doAfterProcessingRecords(RecordMetaData $recordMetaData, $fileProcessedCompletely) { parent::doAfterProcessingRecords($recordMetaData, $fileProcessedCompletely); $datatypeFactory = DataTypeFactory::getInstance(); // converting sample data to appropriate type & reformatting array structure if (isset($this->records)) { $columns = $recordMetaData->getColumns(FALSE); foreach ($this->records as &$record) { foreach ($columns as $column) { $value = isset($record[$column->columnIndex]) ? $record[$column->columnIndex] : NULL; $index = $column->columnIndex; if ($this->provideInAssociativeArray) { unset($record[$column->columnIndex]); $index = $column->name; } if (isset($value)) { if (!isset($column->type->applicationType)) { throw new IllegalStateException(t( 'Could not prepare %value for preview of %columnName column because column data type is not defined', array('%columnName' => $column->publicName, '%value' => $value))); } $record[$index] = $datatypeFactory->getHandler($column->type->applicationType)->castValue($value); } else { $record[$index] = NULL; } } } unset($record); } }
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; }
public function formatValue($datatype, $value) { $adjustedDataType = $this->prepareDataType4Casting($datatype); $castValue = $this->castValue($adjustedDataType, $value); if (isset($castValue)) { $datatypeHandler = DataTypeFactory::getInstance()->getHandler($adjustedDataType); // database-specific data adjustment switch ($datatypeHandler->getStorageDataType()) { case StringDataTypeHandler::$DATA_TYPE: $formattedValue = $this->formatStringValue($castValue); break; case IntegerDataTypeHandler::$DATA_TYPE: case NumberDataTypeHandler::$DATA_TYPE: case CurrencyDataTypeHandler::$DATA_TYPE: case PercentDataTypeHandler::$DATA_TYPE: $formattedValue = $castValue; break; case DateDataTypeHandler::$DATA_TYPE: case TimeDataTypeHandler::$DATA_TYPE: case DateTimeDataTypeHandler::$DATA_TYPE: $formattedValue = $this->formatStringValue($castValue); $formattedValue = $this->formatDateValue($formattedValue, $datatypeHandler->getStorageMask()); break; case BooleanDataTypeHandler::$DATA_TYPE: $formattedValue = is_int($castValue) ? $castValue : $this->formatStringValue($castValue); break; default: throw new UnsupportedOperationException(t("Unsupported data type '@datatype' to format the value: @value", array('@datatype' => $adjustedDataType, '@value' => $value))); } } else { $formattedValue = 'NULL'; } return $formattedValue; }
public function getParameterDataType() { return DataTypeFactory::getInstance()->autoDetectCompatibleDataType(array($this->from, $this->to)); }
public function callback(DataControllerCallContext $callcontext, $connection, $statement) { $records = NULL; $datatypeFactory = DataTypeFactory::getInstance(); $dataset = $this->prepareMetaData($callcontext, $connection, $statement); while ($record = $this->callback->fetchNextRecord($connection, $statement)) { // post-processing the record $adjustedRecord = NULL; foreach ($dataset->columns as $column) { $columnValue = $record[$column->columnIndex]; $propertyValue = $datatypeFactory->getHandler($column->type->applicationType)->castValue($columnValue); $this->resultFormatter->setRecordPropertyValue($adjustedRecord, $column->alias, $propertyValue); } if (!$this->resultFormatter->formatRecord($records, $adjustedRecord)) { $records[] = $adjustedRecord; } } $this->resultFormatter->postFormatRecords($records); return $records; }
public function formatValue($datatype, $value) { if (!isset($value)) { return 'null'; } // data type specific adjustments $datatypeHandler = DataTypeFactory::getInstance()->getHandler($datatype); $formattedValue = $datatypeHandler->castValue($value); // CouchDB-driven adjustments switch ($datatypeHandler->getStorageDataType()) { case StringDataTypeHandler::$DATA_TYPE: case DateDataTypeHandler::$DATA_TYPE: case TimeDataTypeHandler::$DATA_TYPE: case DateTimeDataTypeHandler::$DATA_TYPE: $formattedValue = '"' . $value . '"'; break; case IntegerDataTypeHandler::$DATA_TYPE: case NumberDataTypeHandler::$DATA_TYPE: case CurrencyDataTypeHandler::$DATA_TYPE: case PercentDataTypeHandler::$DATA_TYPE: break; case BooleanDataTypeHandler::$DATA_TYPE: break; default: throw new UnsupportedOperationException(t( "Unsupported data type '@datatype' to format the value: @value", array('@datatype' => $datatype, '@value' => $value))); } return $formattedValue; }
public function callback(DataControllerCallContext $callcontext, $connection, $statement) { $datatypeFactory = DataTypeFactory::getInstance(); $dataset = $this->prepareMetaData($callcontext, $connection, $statement); $records = NULL; $this->callback->fetchAllRecords($connection, $statement, $records); if (isset($records)) { foreach ($records as &$record) { foreach ($dataset->columns as $column) { $record[$column->alias] = $datatypeFactory->getHandler($column->type->applicationType)->castValue($record[$column->columnIndex]); unset($record[$column->columnIndex]); } } } return $records; }
protected function formatDate(DateTime $datetime) { $dateDataTypeHandler = DataTypeFactory::getInstance()->getHandler(DateDataTypeHandler::DATA_TYPE); return $datetime->format($dateDataTypeHandler->getFormat()); }
public function formatValue($datatype, $value) { $adjustedDataType = $this->prepareDataType4Casting($datatype); $datatypeHandler = DataTypeFactory::getInstance()->getHandler($adjustedDataType); // converting value to format 'common' for server side $castValue = $datatypeHandler->castValue($value); // converting value to format which is appropriate for storage $storageValue = $datatypeHandler->castToStorageValue($castValue); if (isset($storageValue)) { $datatypeHandler = DataTypeFactory::getInstance()->getHandler($adjustedDataType); // database-specific storage value adjustment $storageDataType = $datatypeHandler->getStorageDataType(); switch ($storageDataType) { case StringDataTypeHandler::DATA_TYPE: $formattedValue = $this->formatStringValue($storageValue); break; case IntegerDataTypeHandler::DATA_TYPE: case NumberDataTypeHandler::DATA_TYPE: case CurrencyDataTypeHandler::DATA_TYPE: case PercentDataTypeHandler::DATA_TYPE: $formattedValue = $storageValue; break; case DateDataTypeHandler::DATA_TYPE: case TimeDataTypeHandler::DATA_TYPE: case DateTimeDataTypeHandler::DATA_TYPE: $formattedValue = $this->formatStringValue($storageValue); $formattedValue = $this->formatDateValue($formattedValue, $datatypeHandler->getStorageFormat(), $storageDataType); break; case BooleanDataTypeHandler::DATA_TYPE: $formattedValue = is_int($storageValue) ? $storageValue : $this->formatStringValue($storageValue); break; default: throw new UnsupportedOperationException(t( "Unsupported data type %datatype to format the value: %value", array('%datatype' => $adjustedDataType, '%value' => $value))); } } else { $formattedValue = 'NULL'; } return $formattedValue; }
protected function prepareRegisteredDataTypes() { return DataTypeFactory::getInstance()->getSupportedDataTypes(); }
public function getParameterDataType() { $parameterName = $this->getParameterName(); $value = $this->$parameterName; return DataTypeFactory::getInstance()->autoDetectDataType($value); }
public function queryDataset(DataControllerCallContext $callcontext, DatasetQueryRequest $request) { $datasetName = $request->getDatasetName(); LogHelper::log_info(t('Querying script-based dataset: @datasetName', array('@datasetName' => $datasetName))); $metamodel = data_controller_get_metamodel(); $dataset = $metamodel->getDataset($datasetName); $serializer = new DatasetQueryUIRequestSerializer(); $parameters = $serializer->serialize($request); $records = $this->executeScriptFunction($dataset, 'queryDataset', $parameters); LogHelper::log_info(t('Received @count records(s)', array('@count' => count($records)))); // converting type of returned values if (isset($records)) { $columnTypeHandlers = NULL; foreach ($records as &$record) { foreach ($record as $columnName => $columnValue) { if (!isset($columnTypeHandlers[$columnName])) { $type = $dataset->getColumn($columnName)->type->applicationType; $columnTypeHandlers[$columnName] = DataTypeFactory::getInstance()->getHandler($type); } $record[$columnName] = $columnTypeHandlers[$columnName]->castValue($columnValue); } } unset($record); } LogHelper::log_debug($records); return $records; }
public static function checkPositiveInteger($value) { if (!isset($value)) { return; } DataTypeFactory::getInstance()->checkValueType(self::DATA_TYPE, $value); if ($value <= 0) { LogHelper::log_error(t("'@value' has to be positive integer", array('@value' => $value))); throw new IllegalArgumentException(t('Value has to be positive integer')); } }