{

static constexpr auto name = "eval";

std::string getName() const override { return name; }

/// `eval` must not be persisted through `CREATE TABLE ... AS eval(...)`: the source expression

/// would be re-evaluated on every `ATTACH`, so such a table could fail to attach after a restart

/// (the experimental setting might be disabled) or silently change if the expression depends on

/// parameters, settings, or time. There is no stable persisted representation, so forbid it.

bool canBeUsedToCreateTable() const override { return false; }

StoragePtr executeImpl(

const ASTPtr & ast_function,

ContextPtr context,

const std::string & table_name,

ColumnsDescription cached_columns,

bool is_insert_query) const override;

const char * getStorageEngineName() const override { return "View"; }

void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;

ColumnsDescription getActualTableStructure(ContextPtr context, bool is_insert_query) const override;

ASTCreateQuery create;

{

if (const auto * function = ast->as<ASTFunction>(); function && function->name == TableFunctionEval::name)

throw Exception(

ErrorCodes::BAD_ARGUMENTS, "The query generated by table function `eval` cannot use `eval` itself");

for (const auto & child : ast->children)

checkNoEval(child);

{

const auto & settings = context->getSettingsRef();

if (!settings[Setting::allow_experimental_eval_table_function])

throw Exception(

ErrorCodes::SUPPORT_IS_DISABLED,

"Table function `eval` is experimental. Set `allow_experimental_eval_table_function = 1` to enable it");

if (!settings[Setting::allow_experimental_analyzer])

throw Exception(

ErrorCodes::NOT_IMPLEMENTED,

"Table function `eval` is supported only with the analyzer. Set `enable_analyzer = 1` to use it");

/// The generated query can still reach `eval` indirectly, for example through the body

/// of a SQL user defined function, so recursion is bounded by the stack size check.

checkStackSize();

const auto * function = ast_function->as<ASTFunction>();

if (!function || !function->arguments || function->arguments->children.size() != 1)

throw Exception(

ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,

"Table function `eval` requires exactly one argument: a constant expression returning a query string");

const auto & [value, type] = evaluateConstantExpression(function->arguments->children[0], context);

if (!isString(removeLowCardinalityAndNullable(type)))

throw Exception(

ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,

"Table function `eval` requires the argument of type String (possibly Nullable or LowCardinality), got {}",

type->getName());

if (value.isNull())

throw Exception(ErrorCodes::BAD_ARGUMENTS, "The query text passed to table function `eval` cannot be NULL");

const auto & query_text = value.safeGet<String>();

ParserSelectWithUnionQuery parser;

ASTPtr query = parseQuery(

parser,

query_text.data(),

query_text.data() + query_text.size(),

"query generated by table function `eval`",

settings[Setting::max_query_size],

settings[Setting::max_parser_depth],

settings[Setting::max_parser_backtracks]);

checkNoEval(query);

/// The generated query cannot flip the `enable_analyzer` setting in a SETTINGS clause:

/// `eval` is analyzer-only, and the same validation rejects such a change for a usual query.

validateAnalyzerSettings(query, settings[Setting::allow_experimental_analyzer]);

/// The generated query does not go through `executeQuery`, so materialize the construction

/// settings a NON-last `UNION` arm carries in its own `SETTINGS` clause here, same as

/// `executeQueryImpl` does for a usual query (and in the same order: before the `UNION`

/// normalization visitors and before `wrapNestedConstructionSettings`). Without this the first

/// arm's settings in e.g. `eval('(SELECT … SETTINGS limit = 1) UNION ALL SELECT …')` would be

/// consumed by `takeNestedConstructionSettings` and re-scoped to the whole union, and the

/// ambiguous mix of non-last-arm and last-arm construction `SETTINGS` would not be rejected.

wrapPerArmConstructionSettings(

query,

settings[Setting::max_query_size],

settings[Setting::max_parser_depth],

settings[Setting::max_parser_backtracks]);

/// The generated query does not go through `executeQuery`, so resolve the INTERSECT/EXCEPT

/// operator precedence and the implicit UNION mode here, same as `executeQueryImpl` does

/// for a usual query.

{

SelectIntersectExceptQueryVisitor::Data data{

settings[Setting::intersect_default_mode], settings[Setting::except_default_mode]};

SelectIntersectExceptQueryVisitor{data}.visit(query);

}

{

NormalizeSelectWithUnionQueryVisitor::Data data{settings[Setting::union_default_mode]};

NormalizeSelectWithUnionQueryVisitor{data}.visit(query);

}

/// The generated query does not go through `executeQuery`, so materialize the query-construction

/// settings (`limit` / `offset` / `page` / `select` / `filter` / `order` / `sort`) it carries in

/// its own `SETTINGS` clause here, same as `executeQueryImpl` does for a usual query. Without this

/// they would be silently dropped: `QueryTreeBuilder` removes `limit` / `offset` from a query's

/// `SETTINGS` clause (expecting them already materialized into an outer `LIMIT` / `OFFSET`), so

/// e.g. `eval('SELECT number FROM numbers(3) SETTINGS limit = 1')` would ignore the limit. Only the

/// generated query's own `SETTINGS` clause is applied (its scope) — the session/user construction

/// settings shape the outer query that reads from `eval`, not the generated query.

wrapNestedConstructionSettings(

query,

settings[Setting::max_query_size],

settings[Setting::max_parser_depth],

settings[Setting::max_parser_backtracks]);

create.set(create.select, query);

{

chassert(create.select);

chassert(create.children.size() == 1);

chassert(create.children[0]->as<ASTSelectWithUnionQuery>());

auto sample_block = InterpreterSelectQueryAnalyzer::getSampleBlock(create.children[0], context);

return ColumnsDescription(sample_block->getNamesAndTypesList());

const ASTPtr & /*ast_function*/,

ContextPtr context,

const std::string & table_name,

ColumnsDescription /*cached_columns*/,

bool is_insert_query) const

{

auto columns = getActualTableStructure(context, is_insert_query);

auto res = std::make_shared<StorageView>(StorageID(getDatabaseName(), table_name), create, columns, "");

res->startup();

return res;

{

factory.registerFunction<TableFunctionEval>(

{

.description = R"(Evaluates a constant expression to a query string and executes the resulting `SELECT` query.)",

.category = FunctionDocumentation::Category::TableFunction,

},

{.allow_readonly = true});