DataTypePtr recursiveRemoveLowCardinality(const DataTypePtr & type)
{
if (!type)
return type;
if (const auto * array_type = typeid_cast<const DataTypeArray *>(type.get()))
return std::make_shared<DataTypeArray>(recursiveRemoveLowCardinality(array_type->getNestedType()));
if (const auto * tuple_type = typeid_cast<const DataTypeTuple *>(type.get()))
{
DataTypes elements = tuple_type->getElements();
for (auto & element : elements)
element = recursiveRemoveLowCardinality(element);
if (tuple_type->haveExplicitNames())
return std::make_shared<DataTypeTuple>(elements, tuple_type->getElementNames());
else
return std::make_shared<DataTypeTuple>(elements);
}
if (const auto * low_cardinality_type = typeid_cast<const DataTypeLowCardinality *>(type.get()))
return low_cardinality_type->getDictionaryType();
return type;
}
EntityPropertyTypeParserPtr create( const std::string& name, DataTypePtr dataType )
{
if ( dataType->typeName().substr(0, 4) == "INT8" ||
dataType->typeName().substr(0, 5) == "UINT8" )
return new EntityIntParser();
else
return NULL;
}
DataArg::DataArg(const std::string &name, const DataTypePtr &type,
size_t elements) : TypeStorage(name, type) {
_elements=elements;
_data=(char *)malloc(type->objectSize()*_elements);
// fprintf(stderr, "malloc %p %s/(%d of %s (%d))\n", _data,
// name.c_str(), elements, type->asString().c_str(),
// type->objectSize());
memset(_data, 0, type->objectSize()*_elements);
}
void DataTypeManager::load(const std::string& _fileName)
{
std::string fileName = MyGUI::DataManager::getInstance().getDataPath(_fileName);
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(fileName.c_str());
if (result)
{
pugi::xpath_node_set nodes = doc.select_nodes("Document/DataTypes/DataType");
for (pugi::xpath_node_set::const_iterator node = nodes.begin(); node != nodes.end(); node ++)
{
DataTypePtr data = DataTypePtr(new DataType());
data->deserialization((*node).node());
mDataInfos.push_back(data);
}
}
}
EntityPropertyTypeParserPtr create( const std::string& name, DataTypePtr dataType )
{
if ( dataType->typeName().substr(0, 5) == "ARRAY" )
return new EntityArrayParser();
else
return NULL;
}
EntityPropertyTypeParserPtr create( const std::string& name, DataTypePtr dataType )
{
if ( dataType->typeName().substr(0, 6) == "STRING" )
return new EntityStringParser();
else
return NULL;
}
ColumnPtr FunctionArrayIntersect::castRemoveNullable(const ColumnPtr & column, const DataTypePtr & data_type) const
{
if (auto column_nullable = checkAndGetColumn<ColumnNullable>(column.get()))
{
auto nullable_type = checkAndGetDataType<DataTypeNullable>(data_type.get());
const auto & nested = column_nullable->getNestedColumnPtr();
if (nullable_type)
{
auto casted_column = castRemoveNullable(nested, nullable_type->getNestedType());
return ColumnNullable::create(casted_column, column_nullable->getNullMapColumnPtr());
}
return castRemoveNullable(nested, data_type);
}
else if (auto column_array = checkAndGetColumn<ColumnArray>(column.get()))
{
auto array_type = checkAndGetDataType<DataTypeArray>(data_type.get());
if (!array_type)
throw Exception{"Cannot cast array column to column with type "
+ data_type->getName() + " in function " + getName(), ErrorCodes::LOGICAL_ERROR};
auto casted_column = castRemoveNullable(column_array->getDataPtr(), array_type->getNestedType());
return ColumnArray::create(casted_column, column_array->getOffsetsPtr());
}
else if (auto column_tuple = checkAndGetColumn<ColumnTuple>(column.get()))
{
auto tuple_type = checkAndGetDataType<DataTypeTuple>(data_type.get());
if (!tuple_type)
throw Exception{"Cannot cast tuple column to type "
+ data_type->getName() + " in function " + getName(), ErrorCodes::LOGICAL_ERROR};
auto columns_number = column_tuple->getColumns().size();
Columns columns(columns_number);
const auto & types = tuple_type->getElements();
for (auto i : ext::range(0, columns_number))
{
columns[i] = castRemoveNullable(column_tuple->getColumnPtr(i), types[i]);
}
return ColumnTuple::create(columns);
}
return column;
}
std::shared_ptr<FloatValue> FloatValue::Create(DataTypePtr data_type,
double value) {
TypeSpecifier type = data_type->GetType();
if (type == F32 || type == F64) {
return std::shared_ptr<FloatValue>(new FloatValue(data_type, value));
}
return nullptr;
}
bool
ValueNode::checkElementTypesRec (const DataTypePtr &dataType,
LContext &lcontext,
int &eIndex) const
{
//
// recursively iterate through nested structs and arrays
// in this data type, checking element types along the way
//
assert(eIndex < (int)elements.size());
if( StructTypePtr structType = dataType.cast<StructType>() )
{
for(MemberVectorConstIterator it = structType->members().begin();
it != structType->members().end();
it++)
{
if(!checkElementTypesRec(it->type, lcontext, eIndex))
return false;
}
}
else if( ArrayTypePtr arrayType = dataType.cast<ArrayType>() )
{
for (int i = 0; i < arrayType->size(); ++i)
{
if( !checkElementTypesRec(arrayType->elementType(), lcontext, eIndex) )
return false;
}
}
else if (!dataType->canCastFrom (elements[eIndex++]->type))
{
string fromType = "unknown";
if( elements[eIndex-1]->type)
fromType = elements[eIndex-1]->type->asString();
MESSAGE_LE (lcontext, ERR_ARR_EL_TYPE,
elements[eIndex-1]->lineNumber,
"Cannot convert the type of value element "
<< eIndex-1 << " "
"(" << fromType << ") "
"to type " << dataType->asString() << ".");
return false;
}
return true;
}
DataPtr DataUtility::getSelectedParentDataByType(DataPtr _data, DataTypePtr _info)
{
if (_data == nullptr)
return NULL;
for (DataType::VectorString::const_iterator child = _data->getType()->getChilds().begin(); child != _data->getType()->getChilds().end(); child ++)
{
if ((*child) == _info->getName())
return _data;
}
return getSelectedParentDataByType(_data->getChildSelected(), _info);
}
Columns FunctionArrayIntersect::castColumns(
Block & block, const ColumnNumbers & arguments, const DataTypePtr & return_type,
const DataTypePtr & return_type_with_nulls) const
{
size_t num_args = arguments.size();
Columns columns(num_args);
auto type_array = checkAndGetDataType<DataTypeArray>(return_type.get());
auto & type_nested = type_array->getNestedType();
auto type_not_nullable_nested = removeNullable(type_nested);
const bool is_numeric_or_string = isNumber(type_not_nullable_nested)
|| isDateOrDateTime(type_not_nullable_nested)
|| isStringOrFixedString(type_not_nullable_nested);
DataTypePtr nullable_return_type;
if (is_numeric_or_string)
{
auto type_nullable_nested = makeNullable(type_nested);
nullable_return_type = std::make_shared<DataTypeArray>(type_nullable_nested);
}
const bool nested_is_nullable = type_nested->isNullable();
for (size_t i = 0; i < num_args; ++i)
{
const ColumnWithTypeAndName & arg = block.getByPosition(arguments[i]);
auto & column = columns[i];
if (is_numeric_or_string)
{
/// Cast to Array(T) or Array(Nullable(T)).
if (nested_is_nullable)
{
if (arg.type->equals(*return_type))
column = arg.column;
else
column = castColumn(arg, return_type, context);
}
else
{
/// If result has array type Array(T) still cast Array(Nullable(U)) to Array(Nullable(T))
/// because cannot cast Nullable(T) to T.
if (arg.type->equals(*return_type) || arg.type->equals(*nullable_return_type))
column = arg.column;
else if (static_cast<const DataTypeArray &>(*arg.type).getNestedType()->isNullable())
column = castColumn(arg, nullable_return_type, context);
else
column = castColumn(arg, return_type, context);
}
}
else
{
/// return_type_with_nulls is the most common subtype with possible nullable parts.
if (arg.type->equals(*return_type_with_nulls))
column = arg.column;
else
column = castColumn(arg, return_type_with_nulls, context);
}
}
return columns;
}
Workflow::ActorPrototype *ScriptWorkerSerializer::string2actor(const QString data, const QString actorName, QString &error, const QString actorFilePath) {
QDomDocument xml;
xml.setContent(data,false,&error);
if(!error.isEmpty()) {
return NULL;
}
QDomElement doc = xml.documentElement();
DataTypeRegistry *dtr = Workflow::WorkflowEnv::getDataTypeRegistry();
assert(dtr);
QDomNodeList inputs = doc.elementsByTagName(IN_SLOT_ELEMENT);
QList<DataTypePtr> inputTypes;
for(int i = 0; i < inputs.size(); i++) {
QDomElement slot = inputs.item(i).toElement();
QString id = slot.attribute(SLOT_ID);
inputTypes << dtr->getById(id);
}
QDomNodeList outputs = doc.elementsByTagName(OUT_SLOT_ELEMENT);
QList<DataTypePtr> outputTypes;
for(int i = 0; i < outputs.size(); i++) {
QDomElement slot = outputs.item(i).toElement();
QString id = slot.attribute(SLOT_ID);
outputTypes << dtr->getById(id);
}
QDomNodeList attributes = doc.elementsByTagName(ATTR_ELEMENT);
QList<Attribute *>attrs;
for(int i = 0;i < attributes.size(); i++) {
QDomElement attr = attributes.item(i).toElement();
QString typeId = attr.attribute(TYPE_ID);
QString name = attr.attribute(NAME_ID);
DataTypePtr ptr = dtr->getById(typeId);
Descriptor desc(name, name, ptr->getDisplayName());
if(ptr == BaseTypes::BOOL_TYPE()) {
attrs << new Attribute(desc, ptr, false, QVariant(false));
}
else {
attrs << new Attribute(desc, ptr);
}
}
QString newActorName = actorName;
if (newActorName.isEmpty()) {
QDomElement name = doc.elementsByTagName(NAME_ELEMENT).item(0).toElement();
newActorName = name.attribute(NAME_ID);
}
QDomElement descr = doc.elementsByTagName(DESCR_ELEMENT).item(0).toElement();
QString actorDesc = descr.attribute(DESCR_ID);
// if actorName is not set then it is not alias name
bool isAliasName = !actorName.isEmpty();
Workflow::ActorPrototype *proto = Workflow::IncludedProtoFactory::getScriptProto(inputTypes, outputTypes, attrs, newActorName, actorDesc, actorFilePath, isAliasName);
if (NULL == proto) {
error = QObject::tr("UGENE external error. Please, try again");
return NULL;
}
return proto;
}
ColumnPtr recursiveLowCardinalityConversion(const ColumnPtr & column, const DataTypePtr & from_type, const DataTypePtr & to_type)
{
if (!column)
return column;
if (from_type->equals(*to_type))
return column;
if (const auto * column_const = typeid_cast<const ColumnConst *>(column.get()))
return ColumnConst::create(recursiveLowCardinalityConversion(column_const->getDataColumnPtr(), from_type, to_type),
column_const->size());
if (const auto * low_cardinality_type = typeid_cast<const DataTypeLowCardinality *>(from_type.get()))
{
if (to_type->equals(*low_cardinality_type->getDictionaryType()))
return column->convertToFullColumnIfLowCardinality();
}
if (const auto * low_cardinality_type = typeid_cast<const DataTypeLowCardinality *>(to_type.get()))
{
if (from_type->equals(*low_cardinality_type->getDictionaryType()))
{
auto col = low_cardinality_type->createColumn();
static_cast<ColumnLowCardinality &>(*col).insertRangeFromFullColumn(*column, 0, column->size());
return std::move(col);
}
}
if (const auto * from_array_type = typeid_cast<const DataTypeArray *>(from_type.get()))
{
if (const auto * to_array_type = typeid_cast<const DataTypeArray *>(to_type.get()))
{
const auto * column_array = typeid_cast<const ColumnArray *>(column.get());
if (!column_array)
throw Exception("Unexpected column " + column->getName() + " for type " + from_type->getName(),
ErrorCodes::ILLEGAL_COLUMN);
auto & nested_from = from_array_type->getNestedType();
auto & nested_to = to_array_type->getNestedType();
return ColumnArray::create(
recursiveLowCardinalityConversion(column_array->getDataPtr(), nested_from, nested_to),
column_array->getOffsetsPtr());
}
}
if (const auto * from_tuple_type = typeid_cast<const DataTypeTuple *>(from_type.get()))
{
if (const auto * to_tuple_type = typeid_cast<const DataTypeTuple *>(to_type.get()))
{
const auto * column_tuple = typeid_cast<const ColumnTuple *>(column.get());
if (!column_tuple)
throw Exception("Unexpected column " + column->getName() + " for type " + from_type->getName(),
ErrorCodes::ILLEGAL_COLUMN);
Columns columns = column_tuple->getColumns();
auto & from_elements = from_tuple_type->getElements();
auto & to_elements = to_tuple_type->getElements();
for (size_t i = 0; i < columns.size(); ++i)
{
auto & element = columns[i];
element = recursiveLowCardinalityConversion(element, from_elements.at(i), to_elements.at(i));
}
return ColumnTuple::create(columns);
}
}
throw Exception("Cannot convert: " + from_type->getName() + " to " + to_type->getName(), ErrorCodes::TYPE_MISMATCH);
}
void
CallNode::computeType (LContext &lcontext, const SymbolInfoPtr &initInfo)
{
//
// Compute the type of a function call. This is the same type
// as the function's return type, provided the call is valid.
//
//
// Verify that what we are trying to call is actually a function.
//
if (!function)
return;
function->computeType (lcontext, initInfo);
if (!function->type)
return;
FunctionTypePtr functionType = function->type.cast <FunctionType>();
if (!functionType)
{
MESSAGE_LE (lcontext, ERR_NON_FUNC, function->lineNumber,
"Invalid function call to call non-function "
"(" << function->name << " is of type " <<
function->type->asString() << ").");
return;
}
//
// We shouldn't have more function call arguments than parameters.
//
const ParamVector ¶meters = functionType->parameters();
if (arguments.size() > parameters.size())
{
MESSAGE_LE (lcontext, ERR_FUNC_ARG_NUM, function->lineNumber,
"Too many arguments in call to function " << function->name << ".");
return;
}
//
// Compare the types of the arguments to the call with
// the types of the function's parameters.
//
for (int i = 0; i < (int)parameters.size(); ++i)
{
if (i < (int)arguments.size())
{
//
// We have a function call argument for parameter i.
//
arguments[i]->computeType (lcontext, initInfo);
TypePtr argType = arguments[i]->type;
if (!argType)
return;
DataTypePtr paramType = parameters[i].type;
if (parameters[i].isWritable())
{
//
// output parameter -- argument must be an lvalue
// of the same type as the parameter
//
if (!arguments[i]->isLvalue (initInfo))
{
MESSAGE_LE (lcontext, ERR_FUNC_ARG_LVAL, arguments[i]->lineNumber,
"Argument " << i+1 << " in call to function " <<
function->name << " corresponds to an output "
"parameter but it is not an lvalue.");
return;
}
if (!paramType->isSameTypeAs (argType))
{
MESSAGE_LE (lcontext,
ERR_FUNC_ARG_TYPE, arguments[i]->lineNumber,
"Type of argument " << i+1 << " in call to "
"function " << function->name << " is not the "
"same as the type of the function's parameter "
"(" << argType->asString() << " value "
"for " << paramType->asString() << " parameter.)");
return;
}
}
else
{
//
// input parameter -- it must be possible to cast
// the argument type to the parameter type
//
if (!paramType->canCastFrom (argType))
{
MESSAGE_LE (lcontext, ERR_FUNC_ARG_TYPE,
arguments[i]->lineNumber,
"Cannot convert the type of argument " << i+1 << " "
"in call to function " << function->name << " "
"to the type of the function's parameter "
"(" << argType->asString() << " value "
"for " << paramType->asString() << " parameter.)");
return;
}
}
}
else
{
//
// We have no function call argument for parameter i.
// The parameter must have a default value.
//
if (!parameters[i].defaultValue)
{
MESSAGE_LE (lcontext, ERR_FUNC_ARG_NUM,
function->lineNumber,
"Not enough arguments in call to "
"function " << function->name << ".");
return;
}
}
}
//
// If we get here, then the call is valid.
//
type = functionType->returnType();
}
DataTypePtr removeNullable(const DataTypePtr & type)
{
if (type->isNullable())
return static_cast<const DataTypeNullable &>(*type).getNestedType();
return type;
}
DataTypePtr makeNullable(const DataTypePtr & type)
{
if (type->isNullable())
return type;
return std::make_shared<DataTypeNullable>(type);
}
