b75c6c9ef7
Every expression in Alternator's requests is parsed from string to adequate structure. This patch implements a caching structure (input expression strings mapping to parsed 'template' structures), which will be used for handling requests in following commits. If the reqested expression is valid (parsable) the cache will always return a value - if it is not already in the cache it will be created and stored. The cache has limited (live configurable) size - when it is reached, the least recently used entry is removed. The copy of the template in cache is returned - individual instances still need to be resolved (placeholders substituted with names and values). Invalid requests will have no effect on the cache - the parser throws an exception. Caching is implemented for all expression types. Internally it is based on helper structure `lru_string_map`. Basic metrics (total count of hits and misses for each expression type and number of evictions) are implemented. Metrics are used in boost unit tests.
110 lines
4.6 KiB
C++
110 lines
4.6 KiB
C++
/*
|
|
* Copyright 2025-present ScyllaDB
|
|
*/
|
|
|
|
/*
|
|
* SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
|
|
*/
|
|
|
|
#include "expressions.hh"
|
|
#include "utils/log.hh"
|
|
|
|
#include "utils/lru_string_map.hh"
|
|
#include <variant>
|
|
|
|
static logging::logger logger_("parsed-expression-cache");
|
|
|
|
namespace alternator::parsed {
|
|
|
|
struct expression_cache_impl {
|
|
stats& _stats;
|
|
|
|
using cached_expressions_types = std::variant<
|
|
update_expression,
|
|
condition_expression,
|
|
std::vector<path>
|
|
>;
|
|
sized_lru_string_map<cached_expressions_types> _cached_entries;
|
|
utils::observable<uint32_t>::observer _max_cache_entries_observer;
|
|
|
|
expression_cache_impl(expression_cache::config cfg, stats& stats);
|
|
|
|
// to define the specialized return type of `get_or_create()`
|
|
template <typename Func, typename... Args>
|
|
using ParseResult = std::invoke_result_t<Func, std::string_view, Args...>;
|
|
|
|
// Caching layer for parsed expressions
|
|
// The expression type is determined by the type of the parsing function passed as a parameter,
|
|
// and the return type is exactly the same as the return type of this parsing function.
|
|
// StatsType is used only to update appropriate statistics - currently it is aligned with the expression type,
|
|
// but it could be extended in the future if needed, e.g. split per operation.
|
|
template <stats::expression_types StatsType, typename Func, typename... Args>
|
|
ParseResult<Func, Args...> get_or_create(std::string_view query, Func&& parse_func, Args&&... other_args) {
|
|
if (_cached_entries.disabled()) {
|
|
return parse_func(query, std::forward<Args>(other_args)...);
|
|
}
|
|
if (!_cached_entries.sanity_check()) {
|
|
_stats.expression_cache.requests[StatsType].misses++;
|
|
return parse_func(query, std::forward<Args>(other_args)...);
|
|
}
|
|
auto value = _cached_entries.find(query);
|
|
if (value) {
|
|
logger_.trace("Cache hit for query: {}", query);
|
|
_stats.expression_cache.requests[StatsType].hits++;
|
|
try {
|
|
return std::get<ParseResult<Func, Args...>>(value->get());
|
|
} catch (const std::bad_variant_access&) {
|
|
// User can reach this code, by sending the same query string as a different expression type.
|
|
// In practice valid queries are different enough to not collide.
|
|
// Entries in cache are only valid queries.
|
|
// This request will fail at parsing below.
|
|
// If, by any chance this is a valid query, it will be updated below with the new value.
|
|
logger_.trace("Cache hit for '{}', but type mismatch.", query);
|
|
_stats.expression_cache.requests[StatsType].hits--;
|
|
}
|
|
} else {
|
|
logger_.trace("Cache miss for query: {}", query);
|
|
}
|
|
ParseResult<Func, Args...> expr = parse_func(query, std::forward<Args>(other_args)...);
|
|
// Invalid query will throw here ^
|
|
|
|
_stats.expression_cache.requests[StatsType].misses++;
|
|
if (value) [[unlikely]] {
|
|
value->get() = cached_expressions_types{expr};
|
|
} else {
|
|
_cached_entries.insert(query, cached_expressions_types{expr});
|
|
}
|
|
return expr;
|
|
}
|
|
};
|
|
|
|
expression_cache_impl::expression_cache_impl(expression_cache::config cfg, stats& stats) :
|
|
_stats(stats), _cached_entries(logger_, _stats.expression_cache.evictions),
|
|
_max_cache_entries_observer(cfg.max_cache_entries.observe([this] (uint32_t max_value) {
|
|
_cached_entries.set_max_size(max_value);
|
|
})) {
|
|
_cached_entries.set_max_size(cfg.max_cache_entries());
|
|
}
|
|
|
|
expression_cache::expression_cache(expression_cache::config cfg, stats& stats) :
|
|
_impl(std::make_unique<expression_cache_impl>(std::move(cfg), stats)) {
|
|
}
|
|
expression_cache::~expression_cache() = default;
|
|
future<> expression_cache::stop() {
|
|
return _impl->_cached_entries.stop();
|
|
}
|
|
|
|
update_expression expression_cache::parse_update_expression(std::string_view query) {
|
|
return _impl->get_or_create<stats::expression_types::UPDATE_EXPRESSION>(query, alternator::parse_update_expression);
|
|
}
|
|
|
|
std::vector<path> expression_cache::parse_projection_expression(std::string_view query) {
|
|
return _impl->get_or_create<stats::expression_types::PROJECTION_EXPRESSION>(query, alternator::parse_projection_expression);
|
|
}
|
|
|
|
condition_expression expression_cache::parse_condition_expression(std::string_view query, const char* caller) {
|
|
return _impl->get_or_create<stats::expression_types::CONDITION_EXPRESSION>(query, alternator::parse_condition_expression, caller);
|
|
}
|
|
|
|
} // namespace alternator::parsed
|