2024-02-23 20:48:38 +00:00
|
|
|
#include <DataTypes/DataTypeFixedString.h>
|
|
|
|
#include <DataTypes/DataTypeLowCardinality.h>
|
|
|
|
#include <DataTypes/DataTypeNullable.h>
|
|
|
|
#include <DataTypes/DataTypeVariant.h>
|
|
|
|
#include <DataTypes/getLeastSupertype.h>
|
|
|
|
#include <Interpreters/Context.h>
|
|
|
|
#include <Interpreters/InterpreterCreateQuery.h>
|
|
|
|
#include <Interpreters/parseColumnsListForTableFunction.h>
|
2019-07-31 15:36:10 +00:00
|
|
|
#include <Parsers/ASTExpressionList.h>
|
|
|
|
#include <Parsers/ParserCreateQuery.h>
|
2020-06-08 22:49:19 +00:00
|
|
|
#include <Parsers/parseQuery.h>
|
2019-07-31 15:36:10 +00:00
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace ErrorCodes
|
|
|
|
{
|
2024-02-23 20:48:38 +00:00
|
|
|
extern const int LOGICAL_ERROR;
|
|
|
|
extern const int SUSPICIOUS_TYPE_FOR_LOW_CARDINALITY;
|
|
|
|
extern const int ILLEGAL_COLUMN;
|
2022-12-21 21:21:30 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2024-02-15 13:19:02 +00:00
|
|
|
void validateDataType(const DataTypePtr & type_to_check, const DataTypeValidationSettings & settings)
|
2022-12-21 21:21:30 +00:00
|
|
|
{
|
2024-02-15 13:19:02 +00:00
|
|
|
auto validate_callback = [&](const IDataType & data_type)
|
2022-12-21 21:21:30 +00:00
|
|
|
{
|
2024-02-15 13:19:02 +00:00
|
|
|
if (!settings.allow_suspicious_low_cardinality_types)
|
2022-12-21 21:21:30 +00:00
|
|
|
{
|
2024-02-15 13:19:02 +00:00
|
|
|
if (const auto * lc_type = typeid_cast<const DataTypeLowCardinality *>(&data_type))
|
|
|
|
{
|
|
|
|
if (!isStringOrFixedString(*removeNullable(lc_type->getDictionaryType())))
|
|
|
|
throw Exception(
|
|
|
|
ErrorCodes::SUSPICIOUS_TYPE_FOR_LOW_CARDINALITY,
|
|
|
|
"Creating columns of type {} is prohibited by default due to expected negative impact on performance. "
|
|
|
|
"It can be enabled with the \"allow_suspicious_low_cardinality_types\" setting.",
|
|
|
|
lc_type->getName());
|
|
|
|
}
|
2022-12-21 21:21:30 +00:00
|
|
|
}
|
|
|
|
|
2024-02-15 13:19:02 +00:00
|
|
|
if (!settings.allow_experimental_object_type)
|
2022-12-21 21:21:30 +00:00
|
|
|
{
|
2024-02-15 13:19:02 +00:00
|
|
|
if (data_type.hasDynamicSubcolumns())
|
|
|
|
{
|
|
|
|
throw Exception(
|
|
|
|
ErrorCodes::ILLEGAL_COLUMN,
|
|
|
|
"Cannot create column with type '{}' because experimental Object type is not allowed. "
|
|
|
|
"Set setting allow_experimental_object_type = 1 in order to allow it",
|
|
|
|
data_type.getName());
|
|
|
|
}
|
2022-12-21 21:21:30 +00:00
|
|
|
}
|
|
|
|
|
2024-02-15 13:19:02 +00:00
|
|
|
if (!settings.allow_suspicious_fixed_string_types)
|
2022-12-21 21:22:26 +00:00
|
|
|
{
|
2024-02-15 13:19:02 +00:00
|
|
|
if (const auto * fixed_string = typeid_cast<const DataTypeFixedString *>(&data_type))
|
|
|
|
{
|
|
|
|
if (fixed_string->getN() > MAX_FIXEDSTRING_SIZE_WITHOUT_SUSPICIOUS)
|
|
|
|
throw Exception(
|
|
|
|
ErrorCodes::ILLEGAL_COLUMN,
|
|
|
|
"Cannot create column with type '{}' because fixed string with size > {} is suspicious. "
|
|
|
|
"Set setting allow_suspicious_fixed_string_types = 1 in order to allow it",
|
|
|
|
data_type.getName(),
|
|
|
|
MAX_FIXEDSTRING_SIZE_WITHOUT_SUSPICIOUS);
|
|
|
|
}
|
2022-12-21 21:22:26 +00:00
|
|
|
}
|
2023-12-19 16:43:30 +00:00
|
|
|
|
2024-02-15 13:19:02 +00:00
|
|
|
if (!settings.allow_experimental_variant_type)
|
2023-12-19 16:43:30 +00:00
|
|
|
{
|
2024-02-15 13:19:02 +00:00
|
|
|
if (isVariant(data_type))
|
|
|
|
{
|
|
|
|
throw Exception(
|
|
|
|
ErrorCodes::ILLEGAL_COLUMN,
|
|
|
|
"Cannot create column with type '{}' because experimental Variant type is not allowed. "
|
|
|
|
"Set setting allow_experimental_variant_type = 1 in order to allow it",
|
|
|
|
data_type.getName());
|
|
|
|
}
|
2023-12-19 16:43:30 +00:00
|
|
|
}
|
2024-02-23 20:48:38 +00:00
|
|
|
|
|
|
|
if (!settings.allow_suspicious_variant_types)
|
|
|
|
{
|
|
|
|
if (const auto * variant_type = typeid_cast<const DataTypeVariant *>(&data_type))
|
|
|
|
{
|
|
|
|
const auto & variants = variant_type->getVariants();
|
|
|
|
chassert(!variants.empty());
|
|
|
|
for (size_t i = 0; i < variants.size() - 1; ++i)
|
|
|
|
{
|
|
|
|
for (size_t j = i + 1; j < variants.size(); ++j)
|
|
|
|
{
|
2024-03-27 19:19:08 +00:00
|
|
|
/// Don't consider bool as similar to something (like number).
|
|
|
|
if (isBool(variants[i]) || isBool(variants[j]))
|
|
|
|
continue;
|
|
|
|
|
2024-02-23 20:48:38 +00:00
|
|
|
if (auto supertype = tryGetLeastSupertype(DataTypes{variants[i], variants[j]}))
|
|
|
|
{
|
|
|
|
throw Exception(
|
|
|
|
ErrorCodes::ILLEGAL_COLUMN,
|
|
|
|
"Cannot create column with type '{}' because variants '{}' and '{}' have similar types and working with values "
|
|
|
|
"of these types may lead to ambiguity. "
|
|
|
|
"Consider using common single variant '{}' instead of these 2 variants or set setting allow_suspicious_variant_types = 1 "
|
|
|
|
"in order to allow it",
|
|
|
|
data_type.getName(),
|
|
|
|
variants[i]->getName(),
|
|
|
|
variants[j]->getName(),
|
|
|
|
supertype->getName());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-02-15 13:19:02 +00:00
|
|
|
};
|
2024-01-30 15:21:58 +00:00
|
|
|
|
2024-02-15 13:19:02 +00:00
|
|
|
validate_callback(*type_to_check);
|
2024-02-23 13:45:03 +00:00
|
|
|
if (settings.validate_nested_types)
|
|
|
|
type_to_check->forEachChild(validate_callback);
|
2019-07-31 15:36:10 +00:00
|
|
|
}
|
|
|
|
|
2022-12-21 21:21:30 +00:00
|
|
|
ColumnsDescription parseColumnsListFromString(const std::string & structure, const ContextPtr & context)
|
2019-07-31 15:36:10 +00:00
|
|
|
{
|
2022-07-04 14:46:10 +00:00
|
|
|
ParserColumnDeclarationList parser(true, true);
|
2021-04-10 23:33:54 +00:00
|
|
|
const Settings & settings = context->getSettingsRef();
|
2019-07-31 15:36:10 +00:00
|
|
|
|
2024-03-17 18:53:58 +00:00
|
|
|
ASTPtr columns_list_raw = parseQuery(parser, structure, "columns declaration list", settings.max_query_size, settings.max_parser_depth, settings.max_parser_backtracks);
|
2019-07-31 15:36:10 +00:00
|
|
|
|
|
|
|
auto * columns_list = dynamic_cast<ASTExpressionList *>(columns_list_raw.get());
|
|
|
|
if (!columns_list)
|
2023-01-23 21:13:58 +00:00
|
|
|
throw Exception(ErrorCodes::LOGICAL_ERROR, "Could not cast AST to ASTExpressionList");
|
2019-07-31 15:36:10 +00:00
|
|
|
|
2024-03-22 23:03:31 +00:00
|
|
|
auto columns = InterpreterCreateQuery::getColumnsDescription(*columns_list, context, LoadingStrictnessLevel::CREATE);
|
2022-12-21 21:23:12 +00:00
|
|
|
auto validation_settings = DataTypeValidationSettings(context->getSettingsRef());
|
2022-12-21 21:21:30 +00:00
|
|
|
for (const auto & [name, type] : columns.getAll())
|
2022-12-21 21:23:12 +00:00
|
|
|
validateDataType(type, validation_settings);
|
2022-12-21 21:21:30 +00:00
|
|
|
return columns;
|
2019-07-31 15:36:10 +00:00
|
|
|
}
|
|
|
|
|
2023-02-27 15:20:56 +00:00
|
|
|
bool tryParseColumnsListFromString(const std::string & structure, ColumnsDescription & columns, const ContextPtr & context, String & error)
|
2022-01-26 13:29:33 +00:00
|
|
|
{
|
2022-07-04 14:46:10 +00:00
|
|
|
ParserColumnDeclarationList parser(true, true);
|
2022-01-26 13:29:33 +00:00
|
|
|
const Settings & settings = context->getSettingsRef();
|
|
|
|
|
|
|
|
const char * start = structure.data();
|
|
|
|
const char * end = structure.data() + structure.size();
|
2024-02-23 20:48:38 +00:00
|
|
|
ASTPtr columns_list_raw = tryParseQuery(
|
2024-03-17 18:53:58 +00:00
|
|
|
parser, start, end, error, false, "columns declaration list", false, settings.max_query_size, settings.max_parser_depth, settings.max_parser_backtracks, true);
|
2022-01-26 13:29:33 +00:00
|
|
|
if (!columns_list_raw)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto * columns_list = dynamic_cast<ASTExpressionList *>(columns_list_raw.get());
|
|
|
|
if (!columns_list)
|
2023-02-27 15:20:56 +00:00
|
|
|
{
|
|
|
|
error = fmt::format("Invalid columns declaration list: \"{}\"", structure);
|
2022-01-26 13:29:33 +00:00
|
|
|
return false;
|
2023-02-27 15:20:56 +00:00
|
|
|
}
|
2022-01-26 13:29:33 +00:00
|
|
|
|
2022-08-16 09:41:32 +00:00
|
|
|
try
|
|
|
|
{
|
2024-03-22 23:03:31 +00:00
|
|
|
columns = InterpreterCreateQuery::getColumnsDescription(*columns_list, context, LoadingStrictnessLevel::CREATE);
|
2022-12-21 21:23:12 +00:00
|
|
|
auto validation_settings = DataTypeValidationSettings(context->getSettingsRef());
|
2022-12-21 21:21:30 +00:00
|
|
|
for (const auto & [name, type] : columns.getAll())
|
2022-12-21 21:23:12 +00:00
|
|
|
validateDataType(type, validation_settings);
|
2022-08-16 09:41:32 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
catch (...)
|
|
|
|
{
|
2023-02-27 15:20:56 +00:00
|
|
|
error = getCurrentExceptionMessage(false);
|
2022-08-16 09:41:32 +00:00
|
|
|
return false;
|
|
|
|
}
|
2022-01-26 13:29:33 +00:00
|
|
|
}
|
|
|
|
|
2019-07-31 15:58:28 +00:00
|
|
|
}
|