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;
}
/**
* @static
* @return DataTypeFactory
*/
public static function getInstance()
{
if (!isset(self::$factory)) {
self::$factory = new DefaultDataTypeFactory();
}
return self::$factory;
}
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 __construct()
{
parent::__construct();
$this->handlerConfigurations = module_invoke_all('dc_data_type');
}
public function getParameterDataType() {
return DataTypeFactory::getInstance()->autoDetectCompatibleDataType(array($this->from, $this->to));
}
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 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;
}
protected function prepareRegisteredDataTypes() {
return DataTypeFactory::getInstance()->getSupportedDataTypes();
}
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 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;
}
public function getParameterDataType() {
$parameterName = $this->getParameterName();
$value = $this->$parameterName;
return DataTypeFactory::getInstance()->autoDetectDataType($value);
}
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 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'));
}
}
