mirrors/scylladb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
debug_formatting
scylladb/cql3/expr/prepare_expr.cc
Nadav Har'El 34eec020b3 cql3: replace abort() by throwing_assert() 
After the previous patch replaced all SCYLLA_ASSERT() calls by
throwing_assert(), this patch also replaces all calls to abort().

All these abort() calls are supposedly cases that can never happen,
but if they ever do happen because of a bug, in none of these places
we absolutely need to crash - and exception that aborts the current
operation should be enough.

Signed-off-by: Nadav Har'El <nyh@scylladb.com>
2026-03-11 09:43:11 +02:00

1891 lines
88 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) 2021-present ScyllaDB
*/
/*
* SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
*/
#include "expression.hh"
#include "expr-utils.hh"
#include "evaluate.hh"
#include "cql3/functions/functions.hh"
#include "cql3/functions/aggregate_fcts.hh"
#include "cql3/functions/castas_fcts.hh"
#include "cql3/functions/scalar_function.hh"
#include "cql3/column_identifier.hh"
#include "cql3/lists.hh"
#include "cql3/maps.hh"
#include "cql3/sets.hh"
#include "cql3/user_types.hh"
#include "types/list.hh"
#include "types/set.hh"
#include "types/map.hh"
#include "types/vector.hh"
#include "types/user.hh"
#include "exceptions/unrecognized_entity_exception.hh"
#include "utils/like_matcher.hh"
#include <ranges>
namespace cql3::expr {
static const column_value resolve_column(const unresolved_identifier& col_ident, const schema& schema);
static assignment_testable::test_result expression_test_assignment(const data_type& expr_type,
const column_specification& receiver);
static
lw_shared_ptr<column_specification>
column_specification_of(const expression& e) {
return visit(overloaded_functor{
[] (const column_value& cv) {
return cv.col->column_specification;
},
[&] (const ExpressionElement auto& other) {
auto type = type_of(e);
if (!type) {
throw exceptions::invalid_request_exception(fmt::format("cannot infer type of {}", e));
}
// Fake out a column_identifier
//
// FIXME: come up with something better
// This works for now because the we only call this when preparing
// a subscript, and the grammar only allows column_values to be subscripted.
// So we never end up in this branch. In case we do, we'll see the internal
// representation of the expression, rather than what the user typed in.
//
// The correct fix is to augment expressions with a source_location member so
// we can just point at the line and column (and quote the text) of the expression
// we're naming. As an example, if we allow
//
// WHERE {'a': 3, 'b': 5}[19.5] = 3
//
// then the column_identifier should be "key type of {'a': 3, 'b': 5}" - it
// doesn't identify a column but some subexpression that we're using to infer the
// type of the "19.5" (and failing).
auto col_id = ::make_shared<column_identifier>(fmt::format("{}", e), true);
return make_lw_shared<column_specification>("", "", std::move(col_id), std::move(type));
}
}, e);
}
static
lw_shared_ptr<column_specification>
usertype_field_spec_of(const column_specification& column, size_t field) {
auto&& ut = static_pointer_cast<const user_type_impl>(column.type);
auto&& name = ut->field_name(field);
auto&& sname = sstring(reinterpret_cast<const char*>(name.data()), name.size());
return make_lw_shared<column_specification>(
column.ks_name,
column.cf_name,
::make_shared<column_identifier>(column.name->to_string() + "." + sname, true),
ut->field_type(field));
}
static
void
usertype_constructor_validate_assignable_to(const usertype_constructor& u, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
if (!receiver.type->is_user_type()) {
throw exceptions::invalid_request_exception(format("Invalid user type literal for {} of type {}", *receiver.name, receiver.type->as_cql3_type()));
}
auto ut = static_pointer_cast<const user_type_impl>(receiver.type);
for (size_t i = 0; i < ut->size(); i++) {
column_identifier field(to_bytes(ut->field_name(i)), utf8_type);
if (!u.elements.contains(field)) {
continue;
}
const expression& value = u.elements.at(field);
auto&& field_spec = usertype_field_spec_of(receiver, i);
if (!assignment_testable::is_assignable(test_assignment(value, db, keyspace, schema_opt, *field_spec))) {
throw exceptions::invalid_request_exception(format("Invalid user type literal for {}: field {} is not of type {}", *receiver.name, field, field_spec->type->as_cql3_type()));
}
}
}
static
assignment_testable::test_result
usertype_constructor_test_assignment(const usertype_constructor& u, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
try {
usertype_constructor_validate_assignable_to(u, db, keyspace, schema_opt, receiver);
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
} catch (exceptions::invalid_request_exception& e) {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
}
static
std::optional<expression>
usertype_constructor_prepare_expression(const usertype_constructor& u, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
if (!receiver) {
return std::nullopt; // cannot infer type from {field: value}
}
usertype_constructor_validate_assignable_to(u, db, keyspace, schema_opt, *receiver);
auto&& ut = static_pointer_cast<const user_type_impl>(receiver->type);
bool all_terminal = true;
usertype_constructor::elements_map_type prepared_elements;
size_t found_values = 0;
for (size_t i = 0; i < ut->size(); ++i) {
auto&& field = column_identifier(to_bytes(ut->field_name(i)), utf8_type);
auto iraw = u.elements.find(field);
expression raw = expr::make_untyped_null();
if (iraw != u.elements.end()) {
raw = iraw->second;
++found_values;
}
expression value = prepare_expression(raw, db, keyspace, schema_opt, usertype_field_spec_of(*receiver, i));
if (!is<constant>(value)) {
all_terminal = false;
}
prepared_elements.emplace(std::move(field), std::move(value));
}
if (found_values != u.elements.size()) {
// We had some field that are not part of the type
for (auto&& id_val : u.elements) {
auto&& id = id_val.first;
if (!std::ranges::contains(ut->field_names(), id.bytes_)) {
throw exceptions::invalid_request_exception(format("Unknown field '{}' in value of user defined type {}", id, ut->get_name_as_string()));
}
}
}
usertype_constructor value {
.elements = std::move(prepared_elements),
.type = ut
};
if (all_terminal) {
return constant(evaluate(value, query_options::DEFAULT), value.type);
} else {
return value;
}
}
extern logging::logger expr_logger;
static
lw_shared_ptr<column_specification>
map_key_spec_of(const column_specification& column) {
return make_lw_shared<column_specification>(column.ks_name, column.cf_name,
::make_shared<column_identifier>(format("key({})", *column.name), true),
dynamic_cast<const map_type_impl&>(column.type->without_reversed()).get_keys_type());
}
static
lw_shared_ptr<column_specification>
list_key_spec_of(const column_specification& column) {
return make_lw_shared<column_specification>(column.ks_name, column.cf_name,
::make_shared<column_identifier>(format("index({})", *column.name), true),
int32_type);
}
static
lw_shared_ptr<column_specification>
map_value_spec_of(const column_specification& column) {
return make_lw_shared<column_specification>(column.ks_name, column.cf_name,
::make_shared<column_identifier>(format("value({})", *column.name), true),
dynamic_cast<const map_type_impl&>(column.type->without_reversed()).get_values_type());
}
static
void
map_validate_assignable_to(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
if (!receiver.type->without_reversed().is_map()) {
throw exceptions::invalid_request_exception(format("Invalid map literal for {} of type {}", *receiver.name, receiver.type->as_cql3_type()));
}
auto&& key_spec = map_key_spec_of(receiver);
auto&& value_spec = map_value_spec_of(receiver);
for (auto&& entry : c.elements) {
auto& entry_tuple = expr::as<tuple_constructor>(entry);
if (entry_tuple.elements.size() != 2) {
on_internal_error(expr_logger, "map element is not a tuple of arity 2");
}
if (!is_assignable(test_assignment(entry_tuple.elements[0], db, keyspace, schema_opt, *key_spec))) {
throw exceptions::invalid_request_exception(format("Invalid map literal for {}: key {} is not of type {}", *receiver.name, entry_tuple.elements[0], key_spec->type->as_cql3_type()));
}
if (!is_assignable(test_assignment(entry_tuple.elements[1], db, keyspace, schema_opt, *value_spec))) {
throw exceptions::invalid_request_exception(format("Invalid map literal for {}: value {} is not of type {}", *receiver.name, entry_tuple.elements[1], value_spec->type->as_cql3_type()));
}
}
}
static
assignment_testable::test_result
map_test_assignment(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
if (!dynamic_pointer_cast<const map_type_impl>(receiver.type)) {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
// If there is no elements, we can't say it's an exact match (an empty map if fundamentally polymorphic).
if (c.elements.empty()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
auto key_spec = maps::key_spec_of(receiver);
auto value_spec = maps::value_spec_of(receiver);
// It's an exact match if all are exact match, but is not assignable as soon as any is non assignable.
auto res = assignment_testable::test_result::EXACT_MATCH;
for (auto entry : c.elements) {
auto& entry_tuple = expr::as<tuple_constructor>(entry);
if (entry_tuple.elements.size() != 2) {
on_internal_error(expr_logger, "map element is not a tuple of arity 2");
}
auto t1 = test_assignment(entry_tuple.elements[0], db, keyspace, schema_opt, *key_spec);
auto t2 = test_assignment(entry_tuple.elements[1], db, keyspace, schema_opt, *value_spec);
if (t1 == assignment_testable::test_result::NOT_ASSIGNABLE || t2 == assignment_testable::test_result::NOT_ASSIGNABLE)
return assignment_testable::test_result::NOT_ASSIGNABLE;
if (t1 != assignment_testable::test_result::EXACT_MATCH || t2 != assignment_testable::test_result::EXACT_MATCH)
res = assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
return res;
}
static
std::optional<expression>
map_prepare_expression(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
if (!receiver) {
// TODO: It is possible to infer the type of a map from the types of the key/value pairs
return std::nullopt;
}
map_validate_assignable_to(c, db, keyspace, schema_opt, *receiver);
auto key_spec = maps::key_spec_of(*receiver);
auto value_spec = maps::value_spec_of(*receiver);
const map_type_impl* map_type = dynamic_cast<const map_type_impl*>(&receiver->type->without_reversed());
if (map_type == nullptr) {
on_internal_error(expr_logger,
format("map_prepare_expression bad non-map receiver type: {}", receiver->type->name()));
}
data_type map_element_tuple_type = tuple_type_impl::get_instance({map_type->get_keys_type(), map_type->get_values_type()});
// In Cassandra, an empty (unfrozen) map/set/list is equivalent to the column being null. In
// other words a non-frozen collection only exists if it has elements. Return nullptr right
// away to simplify predicate evaluation. See also
// https://issues.apache.org/jira/browse/CASSANDRA-5141
if (map_type->is_multi_cell() && c.elements.empty()) {
return constant::make_null(receiver->type);
}
std::vector<expression> values;
values.reserve(c.elements.size());
bool all_terminal = true;
for (auto&& entry : c.elements) {
auto& entry_tuple = expr::as<tuple_constructor>(entry);
if (entry_tuple.elements.size() != 2) {
on_internal_error(expr_logger, "map element is not a tuple of arity 2");
}
expression k = prepare_expression(entry_tuple.elements[0], db, keyspace, schema_opt, key_spec);
expression v = prepare_expression(entry_tuple.elements[1], db, keyspace, schema_opt, value_spec);
// Check if one of values contains a nonpure function
if (!is<constant>(k) || !is<constant>(v)) {
all_terminal = false;
}
values.emplace_back(tuple_constructor {
.elements = {std::move(k), std::move(v)},
.type = map_element_tuple_type
});
}
collection_constructor map_value {
.style = collection_constructor::style_type::map,
.elements = std::move(values),
.type = receiver->type
};
if (all_terminal) {
return constant(evaluate(map_value, query_options::DEFAULT), map_value.type);
} else {
return map_value;
}
}
static
lw_shared_ptr<column_specification>
set_value_spec_of(const column_specification& column) {
return make_lw_shared<column_specification>(column.ks_name, column.cf_name,
::make_shared<column_identifier>(format("value({})", *column.name), true),
dynamic_cast<const set_type_impl&>(column.type->without_reversed()).get_elements_type());
}
static
void
set_validate_assignable_to(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
if (!receiver.type->without_reversed().is_set()) {
// We've parsed empty maps as a set literal to break the ambiguity so
// handle that case now
if (dynamic_pointer_cast<const map_type_impl>(receiver.type) && c.elements.empty()) {
return;
}
throw exceptions::invalid_request_exception(format("Invalid set literal for {} of type {}", *receiver.name, receiver.type->as_cql3_type()));
}
auto&& value_spec = set_value_spec_of(receiver);
for (auto& e: c.elements) {
if (!is_assignable(test_assignment(e, db, keyspace, schema_opt, *value_spec))) {
throw exceptions::invalid_request_exception(format("Invalid set literal for {}: value {} is not of type {}", *receiver.name, e, value_spec->type->as_cql3_type()));
}
}
}
static
assignment_testable::test_result
set_test_assignment(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
if (!receiver.type->without_reversed().is_set()) {
// We've parsed empty maps as a set literal to break the ambiguity so handle that case now
if (dynamic_pointer_cast<const map_type_impl>(receiver.type) && c.elements.empty()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
// If there is no elements, we can't say it's an exact match (an empty set if fundamentally polymorphic).
if (c.elements.empty()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
auto&& value_spec = set_value_spec_of(receiver);
return test_assignment_all(c.elements, db, keyspace, schema_opt, *value_spec);
}
static
std::optional<expression>
set_prepare_expression(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
if (!receiver) {
// TODO: It is possible to infer the type of a set from the types of the values
return std::nullopt;
}
set_validate_assignable_to(c, db, keyspace, schema_opt, *receiver);
if (c.elements.empty()) {
// In Cassandra, an empty (unfrozen) map/set/list is equivalent to the column being null. In
// other words a non-frozen collection only exists if it has elements. Return nullptr right
// away to simplify predicate evaluation. See also
// https://issues.apache.org/jira/browse/CASSANDRA-5141
if (receiver->type->is_multi_cell()) {
return constant::make_null(receiver->type);
}
// We've parsed empty maps as a set literal to break the ambiguity so
// handle that case now. This branch works for frozen sets/maps only.
const map_type_impl* maybe_map_type = dynamic_cast<const map_type_impl*>(receiver->type.get());
if (maybe_map_type != nullptr) {
collection_constructor map_value {
.style = collection_constructor::style_type::map,
.elements = {},
.type = receiver->type
};
return constant(expr::evaluate(map_value, query_options::DEFAULT), map_value.type);
}
}
auto value_spec = set_value_spec_of(*receiver);
std::vector<expression> values;
values.reserve(c.elements.size());
bool all_terminal = true;
for (auto& e : c.elements)
{
expression elem = prepare_expression(e, db, keyspace, schema_opt, value_spec);
if (!is<constant>(elem)) {
all_terminal = false;
}
values.push_back(std::move(elem));
}
collection_constructor value {
.style = collection_constructor::style_type::set,
.elements = std::move(values),
.type = receiver->type
};
if (all_terminal) {
return constant(evaluate(value, query_options::DEFAULT), value.type);
} else {
return value;
}
}
static
lw_shared_ptr<column_specification>
list_value_spec_of(const column_specification& column) {
return make_lw_shared<column_specification>(column.ks_name, column.cf_name,
::make_shared<column_identifier>(format("value({})", *column.name), true),
dynamic_cast<const list_type_impl&>(column.type->without_reversed()).get_elements_type());
}
static
void
list_validate_assignable_to(const collection_constructor& c, data_dictionary::database db, const sstring keyspace, const schema* schema_opt, const column_specification& receiver) {
if (!receiver.type->without_reversed().is_list()) {
throw exceptions::invalid_request_exception(format("Invalid list literal for {} of type {}",
*receiver.name, receiver.type->as_cql3_type()));
}
auto&& value_spec = list_value_spec_of(receiver);
for (auto& e : c.elements) {
if (!is_assignable(test_assignment(e, db, keyspace, schema_opt, *value_spec))) {
throw exceptions::invalid_request_exception(format("Invalid list literal for {}: value {} is not of type {}",
*receiver.name, e, value_spec->type->as_cql3_type()));
}
}
}
static
assignment_testable::test_result
list_test_assignment(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
// If there is no elements, we can't say it's an exact match (an empty list if fundamentally polymorphic).
if (c.elements.empty()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
auto&& value_spec = list_value_spec_of(receiver);
return test_assignment_all(c.elements, db, keyspace, schema_opt, *value_spec);
}
static
std::optional<expression>
list_prepare_expression(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
list_validate_assignable_to(c, db, keyspace, schema_opt, *receiver);
// In Cassandra, an empty (unfrozen) map/set/list is equivalent to the column being null. In
// other words a non-frozen collection only exists if it has elements. Return nullptr right
// away to simplify predicate evaluation. See also
// https://issues.apache.org/jira/browse/CASSANDRA-5141
if (receiver->type->is_multi_cell() && c.elements.empty()) {
return constant::make_null(receiver->type);
}
auto&& value_spec = list_value_spec_of(*receiver);
std::vector<expression> values;
values.reserve(c.elements.size());
bool all_terminal = true;
for (auto& e : c.elements) {
expression elem = prepare_expression(e, db, keyspace, schema_opt, value_spec);
if (!is<constant>(elem)) {
all_terminal = false;
}
values.push_back(std::move(elem));
}
collection_constructor value {
.style = collection_constructor::style_type::list_or_vector,
.elements = std::move(values),
.type = receiver->type
};
if (all_terminal) {
return constant(evaluate(value, query_options::DEFAULT), value.type);
} else {
return value;
}
}
static
lw_shared_ptr<column_specification>
vector_value_spec_of(const column_specification& column) {
return make_lw_shared<column_specification>(column.ks_name, column.cf_name,
::make_shared<column_identifier>(format("value({})", *column.name), true),
dynamic_cast<const vector_type_impl&>(column.type->without_reversed()).get_elements_type());
}
static
void
vector_validate_assignable_to(const collection_constructor& c, data_dictionary::database db, const sstring keyspace, const schema* schema_opt, const column_specification& receiver) {
auto vt = dynamic_pointer_cast<const vector_type_impl>(receiver.type->underlying_type());
if (!vt) {
throw exceptions::invalid_request_exception(format("Invalid vector type literal for {} of type {}", *receiver.name, receiver.type->as_cql3_type()));
}
vector_dimension_t expected_size = vt->get_dimension();
if (expected_size == 0) {
throw exceptions::invalid_request_exception(format("Invalid vector type literal for {}: type {} expects at least one element",
*receiver.name, receiver.type->as_cql3_type()));
}
size_t received_size = c.elements.size();
if (expected_size != received_size) {
throw exceptions::invalid_request_exception(format("Invalid vector literal for {}: type {} expects {:d} elements but got {:d}",
*receiver.name, receiver.type->as_cql3_type(), expected_size, received_size));
}
auto&& value_spec = vector_value_spec_of(receiver);
for (auto& e : c.elements) {
if (!is_assignable(test_assignment(e, db, keyspace, schema_opt, *value_spec))) {
throw exceptions::invalid_request_exception(format("Invalid vector literal for {}: value {} is not of type {}",
*receiver.name, e, value_spec->type->as_cql3_type()));
}
}
}
static
assignment_testable::test_result
vector_test_assignment(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
// If there is no elements, we can't say it's an exact match (an empty vector if fundamentally polymorphic).
if (c.elements.empty()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
auto&& value_spec = vector_value_spec_of(receiver);
return test_assignment_all(c.elements, db, keyspace, schema_opt, *value_spec);
}
static
std::optional<expression>
vector_prepare_expression(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
vector_validate_assignable_to(c, db, keyspace, schema_opt, *receiver);
auto&& value_spec = vector_value_spec_of(*receiver);
std::vector<expression> values;
values.reserve(c.elements.size());
bool all_terminal = true;
for (auto& e : c.elements) {
expression elem = prepare_expression(e, db, keyspace, schema_opt, value_spec);
if (!is<constant>(elem)) {
all_terminal = false;
}
values.push_back(std::move(elem));
}
// Here we convert from list_or_vector to vector style, as we know that we received a vector type.
collection_constructor value {
.style = collection_constructor::style_type::vector,
.elements = std::move(values),
.type = receiver->type
};
if (all_terminal) {
return constant(evaluate(value, query_options::DEFAULT), value.type);
} else {
return value;
}
}
static
assignment_testable::test_result
list_or_vector_test_assignment(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
if (dynamic_pointer_cast<const vector_type_impl>(receiver.type)) {
return vector_test_assignment(c, db, keyspace, schema_opt, receiver);
} else if (dynamic_pointer_cast<const list_type_impl>(receiver.type)) {
return list_test_assignment(c, db, keyspace, schema_opt, receiver);
} else {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
}
static
std::optional<expression>
list_or_vector_prepare_expression(const collection_constructor& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
if (!receiver) {
// TODO: It is possible to infer the type of a list or vector from the types of the key/value pairs
return std::nullopt;
}
// We do not check if the receiver is a list because it is checked later in the list_prepare_expression.
if (receiver->type->is_vector()) {
return vector_prepare_expression(c, db, keyspace, schema_opt, receiver);
} else {
return list_prepare_expression(c, db, keyspace, schema_opt, receiver);
}
}
static
lw_shared_ptr<column_specification>
component_spec_of(const column_specification& column, size_t component) {
return make_lw_shared<column_specification>(
column.ks_name,
column.cf_name,
::make_shared<column_identifier>(format("{}[{:d}]", column.name, component), true),
static_pointer_cast<const tuple_type_impl>(column.type->underlying_type())->type(component));
}
static
void
tuple_constructor_validate_assignable_to(const tuple_constructor& tc, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
auto tt = dynamic_pointer_cast<const tuple_type_impl>(receiver.type->underlying_type());
if (!tt) {
throw exceptions::invalid_request_exception(format("Invalid tuple type literal for {} of type {}", *receiver.name, receiver.type->as_cql3_type()));
}
for (size_t i = 0; i < tc.elements.size(); ++i) {
if (i >= tt->size()) {
throw exceptions::invalid_request_exception(format("Invalid tuple literal for {}: too many elements. Type {} expects {:d} but got {:d}",
*receiver.name, tt->as_cql3_type(), tt->size(), tc.elements.size()));
}
auto&& value = tc.elements[i];
auto&& spec = component_spec_of(receiver, i);
if (!assignment_testable::is_assignable(test_assignment(value, db, keyspace, schema_opt, *spec))) {
throw exceptions::invalid_request_exception(format("Invalid tuple literal for {}: component {:d} is not of type {}", *receiver.name, i, spec->type->as_cql3_type()));
}
}
}
static
assignment_testable::test_result
tuple_constructor_test_assignment(const tuple_constructor& tc, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
try {
tuple_constructor_validate_assignable_to(tc, db, keyspace, schema_opt, receiver);
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
} catch (exceptions::invalid_request_exception& e) {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
}
static
std::optional<expression>
tuple_constructor_prepare_nontuple(const tuple_constructor& tc, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
if (receiver) {
tuple_constructor_validate_assignable_to(tc, db, keyspace, schema_opt, *receiver);
}
std::vector<expression> values;
bool all_terminal = true;
for (size_t i = 0; i < tc.elements.size(); ++i) {
lw_shared_ptr<column_specification> component_receiver;
if (receiver) {
component_receiver = component_spec_of(*receiver, i);
}
std::optional<expression> value_opt = try_prepare_expression(tc.elements[i], db, keyspace, schema_opt, component_receiver);
if (!value_opt) {
return std::nullopt;
}
auto& value = *value_opt;
if (!is<constant>(value)) {
all_terminal = false;
}
values.push_back(std::move(value));
}
data_type type;
if (receiver) {
type = receiver->type;
} else {
type = tuple_type_impl::get_instance(
values
| std::views::transform(type_of)
| std::ranges::to<std::vector>());
}
tuple_constructor value {
.elements = std::move(values),
.type = std::move(type),
};
if (all_terminal) {
return constant(evaluate(value, query_options::DEFAULT), value.type);
} else {
return value;
}
}
}
template <> struct fmt::formatter<cql3::expr::untyped_constant::type_class> : fmt::formatter<string_view> {
auto format(cql3::expr::untyped_constant::type_class t, fmt::format_context& ctx) const {
using enum cql3::expr::untyped_constant::type_class;
std::string_view name;
switch (t) {
case string: name = "STRING"; break;
case integer: name = "INTEGER"; break;
case uuid: name = "UUID"; break;
case floating_point: name = "FLOAT"; break;
case boolean: name = "BOOLEAN"; break;
case hex: name = "HEX"; break;
case duration: name = "DURATION"; break;
case null: name = "NULL"; break;
}
return fmt::format_to(ctx.out(), "{}", name);
}
};
namespace cql3::expr {
static
bytes
untyped_constant_parsed_value(const untyped_constant uc, data_type validator)
{
try {
if (uc.partial_type == untyped_constant::type_class::hex && validator == bytes_type) {
auto v = static_cast<std::string_view>(uc.raw_text);
v.remove_prefix(2);
return validator->from_string(v);
}
if (validator->is_counter()) {
return long_type->from_string(uc.raw_text);
}
return validator->from_string(uc.raw_text);
} catch (const marshal_exception& e) {
throw exceptions::invalid_request_exception(e.what());
}
}
static
assignment_testable::test_result
untyped_constant_test_assignment(const untyped_constant& uc, data_dictionary::database db, const sstring& keyspace, const column_specification& receiver)
{
bool uc_is_null = uc.partial_type == untyped_constant::type_class::null;
auto receiver_type = receiver.type->as_cql3_type();
if ((receiver_type.is_collection() || receiver_type.is_user_type() || receiver_type.is_vector()) && !uc_is_null) {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
if (!receiver_type.is_native()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
auto kind = receiver_type.get_kind();
switch (uc.partial_type) {
case untyped_constant::type_class::string:
if (cql3_type::kind_enum_set::frozen<
cql3_type::kind::ASCII,
cql3_type::kind::TEXT,
cql3_type::kind::INET,
cql3_type::kind::TIMESTAMP,
cql3_type::kind::DATE,
cql3_type::kind::TIME>::contains(kind)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
break;
case untyped_constant::type_class::integer:
if (cql3_type::kind_enum_set::frozen<
cql3_type::kind::BIGINT,
cql3_type::kind::COUNTER,
cql3_type::kind::DECIMAL,
cql3_type::kind::DOUBLE,
cql3_type::kind::FLOAT,
cql3_type::kind::INT,
cql3_type::kind::SMALLINT,
cql3_type::kind::TIMESTAMP,
cql3_type::kind::DATE,
cql3_type::kind::TINYINT,
cql3_type::kind::VARINT>::contains(kind)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
break;
case untyped_constant::type_class::uuid:
if (cql3_type::kind_enum_set::frozen<
cql3_type::kind::UUID,
cql3_type::kind::TIMEUUID>::contains(kind)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
break;
case untyped_constant::type_class::floating_point:
if (cql3_type::kind_enum_set::frozen<
cql3_type::kind::DECIMAL,
cql3_type::kind::DOUBLE,
cql3_type::kind::FLOAT>::contains(kind)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
break;
case untyped_constant::type_class::boolean:
if (kind == cql3_type::kind_enum_set::prepare<cql3_type::kind::BOOLEAN>()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
break;
case untyped_constant::type_class::hex:
if (kind == cql3_type::kind_enum_set::prepare<cql3_type::kind::BLOB>()) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
break;
case untyped_constant::type_class::duration:
if (kind == cql3_type::kind_enum_set::prepare<cql3_type::kind::DURATION>()) {
return assignment_testable::test_result::EXACT_MATCH;
}
break;
case untyped_constant::type_class::null:
return receiver.type->is_counter()
? assignment_testable::test_result::NOT_ASSIGNABLE
: assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
static
std::optional<expression>
untyped_constant_prepare_expression(const untyped_constant& uc, data_dictionary::database db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver)
{
if (!receiver) {
// TODO: It is possible to infer the type of a constant by looking at the value and selecting the smallest fit
return std::nullopt;
}
if (!is_assignable(untyped_constant_test_assignment(uc, db, keyspace, *receiver))) {
if (uc.partial_type != untyped_constant::type_class::null) {
throw exceptions::invalid_request_exception(format("Invalid {} constant ({}) for \"{}\" of type {}",
uc.partial_type, uc.raw_text, *receiver->name, receiver->type->as_cql3_type().to_string()));
} else {
throw exceptions::invalid_request_exception("Invalid null value for counter increment/decrement");
}
}
if (uc.partial_type == untyped_constant::type_class::null) {
return constant::make_null(receiver->type);
}
raw_value raw_val = cql3::raw_value::make_value(untyped_constant_parsed_value(uc, receiver->type));
return constant(std::move(raw_val), receiver->type);
}
static
assignment_testable::test_result
bind_variable_test_assignment(const bind_variable& bv, data_dictionary::database db, const sstring& keyspace, const column_specification& receiver) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
static
std::optional<bind_variable>
bind_variable_prepare_expression(const bind_variable& bv, data_dictionary::database db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver)
{
if (!receiver) {
return std::nullopt;
}
return bind_variable {
.bind_index = bv.bind_index,
.receiver = receiver
};
}
static data_type cast_get_prepared_type(const cast& c, data_dictionary::database db, const sstring& keyspace) {
data_type cast_type = std::visit(overloaded_functor {
[&](const shared_ptr<cql3_type::raw>& raw_type) { return raw_type->prepare(db, keyspace).get_type(); },
[](const data_type& prepared_type) {return prepared_type;}
}, c.type);
return cast_type;
}
static
lw_shared_ptr<column_specification>
casted_spec_of(const cast& c, data_dictionary::database db, const sstring& keyspace, const column_specification& receiver) {
data_type cast_type = cast_get_prepared_type(c, db, keyspace);
sstring display_name = format("({}){:user}", cast_type->cql3_type_name(), c.arg);
return make_lw_shared<column_specification>(receiver.ks_name, receiver.cf_name,
::make_shared<column_identifier>(display_name, true), cast_type);
}
static
assignment_testable::test_result
cast_test_assignment(const cast& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
try {
data_type casted_type = cast_get_prepared_type(c, db, keyspace);
if (receiver.type == casted_type) {
return assignment_testable::test_result::EXACT_MATCH;
} else if (receiver.type->is_value_compatible_with(*casted_type)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
} else {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
} catch (exceptions::invalid_request_exception& e) {
throwing_assert(0 && "cast_test_assignment exception");
}
}
// expr::cast shows up when the user uses a C-style cast with destination type in parenthesis.
// For example: `(int)1242` or `(blob)(int)1337`.
// Currently such casts are very limited. Casting using this syntax is only allowed when the
// binary representation doesn't change during the cast. This means that it's legal to cast
// an int to blob (the bytes don't change), but it's illegal to cast an int to bigint (4 bytes -> 8 bytes).
// This limitation simplifies things - we can just reinterpret the value as the destination type.
static
std::optional<expression>
c_cast_prepare_expression(const cast& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
data_type cast_type = cast_get_prepared_type(c, db, keyspace);
if (!receiver) {
sstring receiver_name = format("cast({}){:user}", cast_type->cql3_type_name(), c.arg);
receiver = make_lw_shared<column_specification>(
keyspace, "unknown_cf", ::make_shared<column_identifier>(receiver_name, true), cast_type);
}
// casted_spec_of creates a receiver with type equal to c.type
lw_shared_ptr<column_specification> cast_type_receiver = casted_spec_of(c, db, keyspace, *receiver);
// First check if the casted expression can be assigned(converted) to the type specified in the cast.
// test_assignment uses is_value_compatible_with to check if the binary representation is compatible
// between the two types.
if (!is_assignable(test_assignment(c.arg, db, keyspace, schema_opt, *cast_type_receiver))) {
throw exceptions::invalid_request_exception(format("Cannot cast value {:user} to type {}", c.arg, cast_type->as_cql3_type()));
}
// Then check if a value of type c.type can be assigned(converted) to the receiver type.
// cast_test_assignment also uses is_value_compatible_with to check binary representation compatibility.
if (!is_assignable(cast_test_assignment(c, db, keyspace, schema_opt, *receiver))) {
throw exceptions::invalid_request_exception(format("Cannot assign value {:user} to {} of type {}", c, receiver->name, receiver->type->as_cql3_type()));
}
// Now we know that c.arg is compatible with c.type, and c.type is compatible with receiver->type.
// This means that the cast is correct - we can take the binary representation of c.arg value and
// reinterpret it as a value of type receiver->type without any problems.
// Prepare the argument using cast_type_receiver.
// Using this receiver makes it possible to write things like: (blob)(int)1234
// Using the original receiver wouldn't work in such cases - it would complain
// that untyped_constant(1234) isn't a valid blob constant.
return cast{
.style = cast::cast_style::c,
.arg = prepare_expression(c.arg, db, keyspace, schema_opt, cast_type_receiver),
.type = receiver->type,
};
}
static
std::optional<expression>
sql_cast_prepare_expression(const cast& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
data_type cast_type = cast_get_prepared_type(c, db, keyspace);
if (!receiver) {
sstring receiver_name = format("cast({}){:user}", cast_type->cql3_type_name(), c.arg);
receiver = make_lw_shared<column_specification>(
keyspace, "unknown_cf", ::make_shared<column_identifier>(receiver_name, true), cast_type);
}
auto prepared_arg = try_prepare_expression(c.arg, db, keyspace, schema_opt, nullptr);
if (!prepared_arg) {
throw exceptions::invalid_request_exception(fmt::format("Could not infer type of cast argument {}", c.arg));
}
// cast to the same type should be omitted
if (cast_type == type_of(*prepared_arg)) {
return prepared_arg;
}
// This will throw if a cast is impossible
auto fun = functions::get_castas_fctn_as_cql3_function(cast_type, type_of(*prepared_arg));
// We implement the cast to a function_call.
return function_call{
.func = std::move(fun),
.args = std::vector({*prepared_arg}),
};
}
std::optional<expression>
cast_prepare_expression(const cast& c, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
switch (c.style) {
case cast::cast_style::c:
return c_cast_prepare_expression(c, db, keyspace, schema_opt, std::move(receiver));
case cast::cast_style::sql:
return sql_cast_prepare_expression(c, db, keyspace, schema_opt, std::move(receiver));
}
on_internal_error(expr_logger, "Illegal cast style");
}
std::optional<expression>
field_selection_prepare_expression(const field_selection& fs, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
// We can't infer the type of the user defined type from the field being selected
auto prepared_structure = try_prepare_expression(fs.structure, db, keyspace, schema_opt, nullptr);
if (!prepared_structure) {
throw exceptions::invalid_request_exception(fmt::format("Cannot infer type of {}", fs.structure));
}
auto type = type_of(*prepared_structure);
if (!type->underlying_type()->is_user_type()) {
throw exceptions::invalid_request_exception(
format("Invalid field selection: {} of type {} is not a user type", fs.structure, type->as_cql3_type()));
}
auto ut = static_pointer_cast<const user_type_impl>(type->underlying_type());
// FIXME: this check is artificial: prepare() below requires a schema even though one isn't
// necessary for to prepare a field name. Luckily we'll always have a schema here, since there's
// no way to get a user-defined type value other than by reading it from a table.
if (!schema_opt) {
throw exceptions::invalid_request_exception(fmt::format("Unable to prepare {} without schema", *fs.field));
}
auto prepared_field = fs.field->prepare(*schema_opt);
auto idx = ut->idx_of_field(prepared_field->bytes_);
if (!idx) {
throw exceptions::invalid_request_exception(format("{} of type {} has no field {}",
fs.structure, ut->as_cql3_type(), fs.field));
}
return field_selection{
.structure = std::move(*prepared_structure),
.field = fs.field,
.field_idx = *idx,
.type = ut->type(*idx),
};
}
assignment_testable::test_result
field_selection_test_assignment(const field_selection& fs, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
// We can't infer the type of the user defined type from the field being selected
auto prepared_structure = try_prepare_expression(fs.structure, db, keyspace, schema_opt, nullptr);
if (!prepared_structure) {
throw exceptions::invalid_request_exception(fmt::format("Cannot infer type of {}", fs.structure));
}
auto type = type_of(*prepared_structure);
if (!type->underlying_type()->is_user_type()) {
throw exceptions::invalid_request_exception(
format("Invalid field selection: {} of type {} is not a user type", fs.structure, type->as_cql3_type()));
}
auto ut = static_pointer_cast<const user_type_impl>(type->underlying_type());
// FIXME: this check is artificial: prepare() below requires a schema even though one isn't
// necessary for to prepare a field name. Luckily we'll always have a schema here, since there's
// no way to get a user-defined type value other than by reading it from a table.
if (!schema_opt) {
throw exceptions::invalid_request_exception(fmt::format("Unable to prepare {} without schema", *fs.field));
}
auto prepared_field = fs.field->prepare(*schema_opt);
auto idx = ut->idx_of_field(prepared_field->bytes_);
if (!idx) {
throw exceptions::invalid_request_exception(format("{} of type {} has no field {}",
fs.structure, ut->as_cql3_type(), fs.field));
}
auto field_type = ut->type(*idx);
return expression_test_assignment(field_type, receiver);
}
static
std::vector<::shared_ptr<assignment_testable>>
prepare_function_args_for_type_inference(std::span<const expression> args, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt) {
// Prepare the arguments that can be prepared without a receiver.
// Prepared expressions have a known type, which helps with finding the right function.
std::vector<shared_ptr<assignment_testable>> partially_prepared_args;
for (const expression& argument : args) {
std::optional<expression> prepared_arg_opt = try_prepare_expression(argument, db, keyspace, schema_opt, nullptr);
auto type = prepared_arg_opt ? std::optional(type_of(*prepared_arg_opt)) : std::nullopt;
auto expr = prepared_arg_opt ? std::move(*prepared_arg_opt) : argument;
partially_prepared_args.emplace_back(as_assignment_testable(std::move(expr), std::move(type)));
}
return partially_prepared_args;
}
// Special case for count(1) - recognize it as the countRows() function. Note it is quite
// artificial and we might relax it to the more general count(expression) later.
static
std::optional<expression>
try_prepare_count_rows(const expr::function_call& fc, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
return std::visit(overloaded_functor{
[&] (const functions::function_name& name) -> std::optional<expression> {
auto native_name = name;
if (!native_name.has_keyspace()) {
native_name = name.as_native_function();
}
// Collapse count(1) into countRows()
if (native_name == functions::function_name::native_function("count")) {
if (fc.args.size() == 1) {
if (auto uc_arg = expr::as_if<expr::untyped_constant>(&fc.args[0])) {
if (uc_arg->partial_type == expr::untyped_constant::type_class::integer
&& uc_arg->raw_text == "1") {
return expr::function_call{
.func = functions::aggregate_fcts::make_count_rows_function(),
.args = {},
};
} else {
throw exceptions::invalid_request_exception(format("count() expects a column or the literal 1 as an argument", fc.args[0]));
}
}
}
}
return std::nullopt;
},
[] (const shared_ptr<functions::function>&) -> std::optional<expression> {
// Already prepared, nothing to do
return std::nullopt;
},
}, fc.func);
}
std::optional<expression>
prepare_function_call(const expr::function_call& fc, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
if (auto prepared = try_prepare_count_rows(fc, db, keyspace, schema_opt, receiver)) {
return prepared;
}
// Try to extract a column family name from the available information.
// Most functions can be prepared without information about the column family, usually just the keyspace is enough.
// One exception is the token() function - in order to prepare system.token() we have to know the partition key of the table,
// which can only be known when the column family is known.
// In cases when someone calls prepare_function_call on a token() function without a known column_family, an exception is thrown by functions::get.
std::optional<std::string_view> cf_name;
if (schema_opt != nullptr) {
cf_name = std::string_view(schema_opt->cf_name());
} else if (receiver.get() != nullptr) {
cf_name = receiver->cf_name;
}
// Prepare the arguments that can be prepared without a receiver.
// Prepared expressions have a known type, which helps with finding the right function.
auto partially_prepared_args = prepare_function_args_for_type_inference(fc.args, db, keyspace, schema_opt);
auto&& fun = std::visit(overloaded_functor{
[] (const shared_ptr<functions::function>& func) {
return func;
},
[&] (const functions::function_name& name) {
auto fun = functions::instance().get(db, keyspace, name, partially_prepared_args, keyspace, cf_name, receiver.get());
if (!fun) {
throw exceptions::invalid_request_exception(format("Unknown function {} called", name));
}
return fun;
},
}, fc.func);
// Functions.get() will complain if no function "name" type check with the provided arguments.
// We still have to validate that the return type matches however
if (receiver && !receiver->type->is_value_compatible_with(*fun->return_type())) {
throw exceptions::invalid_request_exception(format("Type error: cannot assign result of function {} (type {}) to {} (type {})",
fun->name(), fun->return_type()->as_cql3_type(),
receiver->name, receiver->type->as_cql3_type()));
}
if (fun->arg_types().size() != fc.args.size()) {
throw exceptions::invalid_request_exception(format("Incorrect number of arguments specified for function {} (expected {:d}, found {:d})",
fun->name(), fun->arg_types().size(), fc.args.size()));
}
std::vector<expr::expression> parameters;
parameters.reserve(partially_prepared_args.size());
bool all_terminal = true;
for (size_t i = 0; i < partially_prepared_args.size(); ++i) {
expr::expression e = prepare_expression(fc.args[i], db, keyspace, schema_opt,
functions::instance().make_arg_spec(keyspace, cf_name, *fun, i));
if (!expr::is<expr::constant>(e)) {
all_terminal = false;
}
parameters.push_back(std::move(e));
}
// If all parameters are terminal and the function is pure and scalar, we can
// evaluate it now, otherwise we'd have to wait execution time
expr::function_call fun_call {
.func = fun,
.args = std::move(parameters),
.lwt_cache_id = fc.lwt_cache_id
};
if (all_terminal && fun->is_pure() && !fun->is_aggregate() && !fun->requires_thread()) {
return constant(expr::evaluate(fun_call, query_options::DEFAULT), fun->return_type());
} else {
return fun_call;
}
}
assignment_testable::test_result
test_assignment_function_call(const cql3::expr::function_call& fc, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
// Note: Functions.get() will return null if the function doesn't exist, or throw is no function matching
// the arguments can be found. We may get one of those if an undefined/wrong function is used as argument
// of another, existing, function. In that case, we return true here because we'll throw a proper exception
// later with a more helpful error message that if we were to return false here.
try {
auto&& fun = std::visit(overloaded_functor{
[&] (const functions::function_name& name) {
auto args = prepare_function_args_for_type_inference(fc.args, db, keyspace, schema_opt);
return functions::instance().get(db, keyspace, name, args, receiver.ks_name, receiver.cf_name, &receiver);
},
[] (const shared_ptr<functions::function>& func) {
return func;
},
}, fc.func);
if (fun && receiver.type == fun->return_type()) {
return assignment_testable::test_result::EXACT_MATCH;
} else if (!fun || receiver.type->is_value_compatible_with(*fun->return_type())) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
} else {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
} catch (exceptions::invalid_request_exception& e) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
}
}
static assignment_testable::test_result expression_test_assignment(const data_type& expr_type,
const column_specification& receiver) {
if (receiver.type->underlying_type() == expr_type->underlying_type() || (receiver.type == long_type && expr_type->is_counter())) {
return assignment_testable::test_result::EXACT_MATCH;
} else if (receiver.type->is_value_compatible_with(*expr_type)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
} else {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
}
std::optional<expression> prepare_conjunction(const conjunction& conj,
data_dictionary::database db,
const sstring& keyspace,
const schema* schema_opt,
lw_shared_ptr<column_specification> receiver) {
if (receiver.get() != nullptr && receiver->type->without_reversed().get_kind() != abstract_type::kind::boolean) {
throw exceptions::invalid_request_exception(
format("AND conjunction produces a boolean value, which doesn't match the type: {} of {}",
receiver->type->name(), receiver->name->text()));
}
lw_shared_ptr<column_specification> child_receiver;
if (receiver.get() != nullptr) {
::shared_ptr<column_identifier> child_receiver_name =
::make_shared<column_identifier>(format("AND_element({})", receiver->name->text()), true);
child_receiver = make_lw_shared<column_specification>(receiver->ks_name, receiver->cf_name,
std::move(child_receiver_name), boolean_type);
} else {
::shared_ptr<column_identifier> child_receiver_name =
::make_shared<column_identifier>("AND_element(unknown)", true);
sstring cf_name = schema_opt ? schema_opt->cf_name() : "unknown_cf";
child_receiver = make_lw_shared<column_specification>(keyspace, std::move(cf_name),
std::move(child_receiver_name), boolean_type);
}
std::vector<expression> prepared_children;
bool all_terminal = true;
for (const expression& child : conj.children) {
std::optional<expression> prepared_child =
try_prepare_expression(child, db, keyspace, schema_opt, child_receiver);
if (!prepared_child.has_value()) {
throw exceptions::invalid_request_exception(fmt::format("Could not infer type of {}", child));
}
if (!is<constant>(*prepared_child)) {
all_terminal = false;
}
prepared_children.push_back(std::move(*prepared_child));
}
conjunction result = conjunction{std::move(prepared_children)};
if (all_terminal) {
return constant(evaluate(result, evaluation_inputs{}), boolean_type);
}
return result;
}
static
std::optional<expression>
prepare_column_mutation_attribute(
const column_mutation_attribute& cma,
data_dictionary::database db,
const sstring& keyspace,
const schema* schema_opt,
lw_shared_ptr<column_specification> receiver) {
auto result_type = expr::column_mutation_attribute_type(cma);
if (receiver.get() != nullptr && receiver->type->without_reversed().get_kind() != result_type->get_kind()) {
throw exceptions::invalid_request_exception(
format("A {} produces a {} value, which doesn't match the type: {} of {}",
cma.kind, result_type->name(),
receiver->type->name(), receiver->name->text()));
}
auto column = prepare_expression(cma.column, db, keyspace, schema_opt, nullptr);
auto cval = expr::as_if<column_value>(&column);
if (!cval) {
throw exceptions::invalid_request_exception(fmt::format("{} expects a column, but {} is a general expression", cma.kind, column));
}
if (!cval->col->is_atomic()) {
throw exceptions::invalid_request_exception(fmt::format("{} expects an atomic column, but {} is a non-frozen collection", cma.kind, column));
}
if (cval->col->is_primary_key()) {
throw exceptions::invalid_request_exception(fmt::format("{} is not legal on partition key component {}", cma.kind, column));
}
return column_mutation_attribute{
.kind = cma.kind,
.column = std::move(column),
};
}
std::optional<expression>
try_prepare_expression(const expression& expr, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
return expr::visit(overloaded_functor{
[&] (const constant& value) -> std::optional<expression> {
if (receiver && !is_assignable(expression_test_assignment(value.type, *receiver))) {
throw exceptions::invalid_request_exception(
format("cannot assign a constant {:user} of type {} to receiver {} of type {}", value,
value.type->as_cql3_type(), receiver->name, receiver->type->as_cql3_type()));
}
constant result = value;
if (receiver) {
// The receiver might have a different type from the constant, but this is allowed if the types are compatible.
// In such case the type is implicitly converted to receiver type.
result.type = receiver->type;
}
return result;
},
[&] (const binary_operator& binop) -> std::optional<expression> {
if (receiver.get() != nullptr && &receiver->type->without_reversed() != boolean_type.get()) {
throw exceptions::invalid_request_exception(
format("binary operator produces a boolean value, which doesn't match the type: {} of {}",
receiver->type->name(), receiver->name->text()));
}
binary_operator result = prepare_binary_operator(binop, db, *schema_opt);
// A binary operator where both sides of the equation are known can be evaluated to a boolean value.
// This only applies to operators in the CQL order, operations in the clustering order should only be
// of form (clustering_column1, colustering_column2) < SCYLLA_CLUSTERING_BOUND(1, 2).
if (is<constant>(result.lhs) && is<constant>(result.rhs) && result.order == comparison_order::cql) {
return constant(evaluate(result, query_options::DEFAULT), boolean_type);
}
return result;
},
[&] (const conjunction& conj) -> std::optional<expression> {
return prepare_conjunction(conj, db, keyspace, schema_opt, receiver);
},
[] (const column_value& cv) -> std::optional<expression> {
return cv;
},
[&] (const subscript& sub) -> std::optional<expression> {
if (!schema_opt) {
throw exceptions::invalid_request_exception("cannot process subscript operation without schema");
}
auto& schema = *schema_opt;
auto sub_col_opt = try_prepare_expression(sub.val, db, keyspace, schema_opt, receiver);
if (!sub_col_opt) {
return std::nullopt;
}
auto& sub_col = *sub_col_opt;
const abstract_type& sub_col_type = type_of(sub_col)->without_reversed();
auto col_spec = column_specification_of(sub_col);
lw_shared_ptr<column_specification> subscript_column_spec;
data_type value_cmp;
if (sub_col_type.is_map()) {
subscript_column_spec = map_key_spec_of(*col_spec);
value_cmp = static_cast<const collection_type_impl&>(sub_col_type).value_comparator();
} else if (sub_col_type.is_set()) {
subscript_column_spec = set_value_spec_of(*col_spec);
value_cmp = static_cast<const collection_type_impl&>(sub_col_type).name_comparator();
} else if (sub_col_type.is_list()) {
subscript_column_spec = list_key_spec_of(*col_spec);
value_cmp = static_cast<const collection_type_impl&>(sub_col_type).value_comparator();
} else {
throw exceptions::invalid_request_exception(format("Column {} is not a map/set/list, cannot be subscripted", col_spec->name->text()));
}
return subscript {
.val = sub_col,
.sub = prepare_expression(sub.sub, db, schema.ks_name(), &schema, std::move(subscript_column_spec)),
.type = value_cmp,
};
},
[&] (const unresolved_identifier& unin) -> std::optional<expression> {
if (!schema_opt) {
throw exceptions::invalid_request_exception(fmt::format("Cannot resolve column {} without schema", unin.ident->to_cql_string()));
}
return resolve_column(unin, *schema_opt);
},
[&] (const column_mutation_attribute& cma) -> std::optional<expression> {
return prepare_column_mutation_attribute(cma, db, keyspace, schema_opt, std::move(receiver));
},
[&] (const function_call& fc) -> std::optional<expression> {
return prepare_function_call(fc, db, keyspace, schema_opt, std::move(receiver));
},
[&] (const cast& c) -> std::optional<expression> {
return cast_prepare_expression(c, db, keyspace, schema_opt, receiver);
},
[&] (const field_selection& fs) -> std::optional<expression> {
return field_selection_prepare_expression(fs, db, keyspace, schema_opt, receiver);
},
[&] (const bind_variable& bv) -> std::optional<expression> {
return bind_variable_prepare_expression(bv, db, keyspace, receiver);
},
[&] (const untyped_constant& uc) -> std::optional<expression> {
return untyped_constant_prepare_expression(uc, db, keyspace, receiver);
},
[&] (const tuple_constructor& tc) -> std::optional<expression> {
return tuple_constructor_prepare_nontuple(tc, db, keyspace, schema_opt, receiver);
},
[&] (const collection_constructor& c) -> std::optional<expression> {
switch (c.style) {
case collection_constructor::style_type::list_or_vector: return list_or_vector_prepare_expression(c, db, keyspace, schema_opt, receiver);
case collection_constructor::style_type::set: return set_prepare_expression(c, db, keyspace, schema_opt, receiver);
case collection_constructor::style_type::map: return map_prepare_expression(c, db, keyspace, schema_opt, receiver);
case collection_constructor::style_type::vector:
on_internal_error(expr_logger, "vector style type found during prepare, should have been introduced post-prepare");
}
on_internal_error(expr_logger, fmt::format("unexpected collection_constructor style {}", static_cast<unsigned>(c.style)));
},
[&] (const usertype_constructor& uc) -> std::optional<expression> {
return usertype_constructor_prepare_expression(uc, db, keyspace, schema_opt, receiver);
},
[&] (const temporary& t) -> std::optional<expression> {
on_internal_error(expr_logger, "temporary found during prepare, should have been introduced post-prepare");
},
}, expr);
}
static
assignment_testable::test_result
unresolved_identifier_test_assignment(const unresolved_identifier& ui, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
auto prepared = prepare_expression(ui, db, keyspace, schema_opt, make_lw_shared<column_specification>(receiver));
return test_assignment(prepared, db, keyspace, schema_opt, receiver);
}
static
assignment_testable::test_result
column_mutation_attribute_test_assignment(const column_mutation_attribute& cma, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
auto type = column_mutation_attribute_type(cma);
return expression_test_assignment(std::move(type), std::move(receiver));
}
assignment_testable::test_result
test_assignment(const expression& expr, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
using test_result = assignment_testable::test_result;
return expr::visit(overloaded_functor{
[&] (const constant& value) -> test_result {
return expression_test_assignment(value.type, receiver);
},
[&] (const binary_operator&) -> test_result {
on_internal_error(expr_logger, "binary_operators are not yet reachable via test_assignment()");
},
[&] (const conjunction&) -> test_result {
on_internal_error(expr_logger, "conjunctions are not yet reachable via test_assignment()");
},
[&] (const column_value& col_val) -> test_result {
return expression_test_assignment(col_val.col->type, receiver);
},
[&] (const subscript&) -> test_result {
// not implemented. issue #22075
return assignment_testable::test_result::NOT_ASSIGNABLE;
},
[&] (const unresolved_identifier& ui) -> test_result {
return unresolved_identifier_test_assignment(ui, db, keyspace, schema_opt, receiver);
},
[&] (const column_mutation_attribute& cma) -> test_result {
return column_mutation_attribute_test_assignment(cma, db, keyspace, schema_opt, receiver);
},
[&] (const function_call& fc) -> test_result {
return test_assignment_function_call(fc, db, keyspace, schema_opt, receiver);
},
[&] (const cast& c) -> test_result {
return cast_test_assignment(c, db, keyspace, schema_opt, receiver);
},
[&] (const field_selection& fs) -> test_result {
return field_selection_test_assignment(fs, db, keyspace, schema_opt, receiver);
},
[&] (const bind_variable& bv) -> test_result {
return bind_variable_test_assignment(bv, db, keyspace, receiver);
},
[&] (const untyped_constant& uc) -> test_result {
return untyped_constant_test_assignment(uc, db, keyspace, receiver);
},
[&] (const tuple_constructor& tc) -> test_result {
return tuple_constructor_test_assignment(tc, db, keyspace, schema_opt, receiver);
},
[&] (const collection_constructor& c) -> test_result {
switch (c.style) {
case collection_constructor::style_type::list_or_vector: return list_or_vector_test_assignment(c, db, keyspace, schema_opt, receiver);
case collection_constructor::style_type::set: return set_test_assignment(c, db, keyspace, schema_opt, receiver);
case collection_constructor::style_type::map: return map_test_assignment(c, db, keyspace, schema_opt, receiver);
case collection_constructor::style_type::vector:
on_internal_error(expr_logger, "vector style type found in test_assignment, should have been introduced post-prepare");
}
on_internal_error(expr_logger, fmt::format("unexpected collection_constructor style {}", static_cast<unsigned>(c.style)));
},
[&] (const usertype_constructor& uc) -> test_result {
return usertype_constructor_test_assignment(uc, db, keyspace, schema_opt, receiver);
},
[&] (const temporary& t) -> test_result {
on_internal_error(expr_logger, "temporary found in test_assignment, should have been introduced post-prepare");
},
}, expr);
}
template <cql3_type::kind... Kinds>
assignment_testable::vector_test_result
test_assignment_any_size_float_vector(const expression& expr) {
using test_result = assignment_testable::vector_test_result;
const test_result NOT_ASSIGNABLE = {assignment_testable::test_result::NOT_ASSIGNABLE, std::nullopt};
const test_result WEAKLY_ASSIGNABLE = {assignment_testable::test_result::WEAKLY_ASSIGNABLE, std::nullopt};
auto is_float_or_bind = [] (const expression& e) {
return expr::visit(overloaded_functor{
[] (const bind_variable&) {
return true;
},
[] (const untyped_constant& uc) {
return uc.partial_type == untyped_constant::type_class::floating_point
|| uc.partial_type == untyped_constant::type_class::integer;
},
[] (const constant& value) {
auto kind = value.type->as_cql3_type().get_kind();
return cql3_type::kind_enum_set::frozen<Kinds...>().contains(kind);
},
[] (const auto&) {
return false;
},
}, e);
};
auto validate_assignment = [&] (const data_type& dt) -> test_result {
auto vt = dynamic_pointer_cast<const vector_type_impl>(dt->underlying_type());
if (!vt) {
return NOT_ASSIGNABLE;
}
auto elem_kind = vt->get_elements_type()->as_cql3_type().get_kind();
if (cql3_type::kind_enum_set::frozen<Kinds...>().contains(elem_kind)) {
return {assignment_testable::test_result::WEAKLY_ASSIGNABLE, vt->get_dimension()};
}
return NOT_ASSIGNABLE;
};
return expr::visit(overloaded_functor{
[&] (const constant& value) -> test_result {
return validate_assignment(value.type);
},
[&] (const binary_operator&) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const conjunction&) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const column_value& col_val) -> test_result {
return validate_assignment(col_val.col->type);
},
[&] (const subscript&) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const unresolved_identifier& ui) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const column_mutation_attribute& cma) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const function_call& fc) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const cast& c) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const field_selection& fs) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const bind_variable& bv) -> test_result {
return WEAKLY_ASSIGNABLE;
},
[&] (const untyped_constant& uc) -> test_result {
return uc.partial_type == untyped_constant::type_class::null
? WEAKLY_ASSIGNABLE
: NOT_ASSIGNABLE;
},
[&] (const tuple_constructor& tc) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const collection_constructor& c) -> test_result {
switch (c.style) {
case collection_constructor::style_type::list_or_vector: {
if(std::ranges::all_of(c.elements, is_float_or_bind)) {
return {assignment_testable::test_result::WEAKLY_ASSIGNABLE, c.elements.size()};
}
return NOT_ASSIGNABLE;
}
case collection_constructor::style_type::set: return NOT_ASSIGNABLE;
case collection_constructor::style_type::map: return NOT_ASSIGNABLE;
case collection_constructor::style_type::vector:
on_internal_error(expr_logger, "vector style type found in test_assignment, should have been introduced post-prepare");
}
on_internal_error(expr_logger, fmt::format("unexpected collection_constructor style {}", static_cast<unsigned>(c.style)));
},
[&] (const usertype_constructor& uc) -> test_result {
return NOT_ASSIGNABLE;
},
[&] (const temporary& t) -> test_result {
return NOT_ASSIGNABLE;
},
}, expr);
}
assignment_testable::vector_test_result
test_assignment_any_size_float_vector(const expression& expr) {
return test_assignment_any_size_float_vector<cql3_type::kind::FLOAT, cql3_type::kind::DOUBLE>(expr);
}
expression
prepare_expression(const expression& expr, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, lw_shared_ptr<column_specification> receiver) {
auto e_opt = try_prepare_expression(expr, db, keyspace, schema_opt, std::move(receiver));
if (!e_opt) {
throw exceptions::invalid_request_exception(fmt::format("Could not infer type of {}", expr));
}
return std::move(*e_opt);
}
assignment_testable::test_result
test_assignment_all(const std::vector<expression>& to_test, data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) {
using test_result = assignment_testable::test_result;
test_result res = test_result::EXACT_MATCH;
for (auto&& e : to_test) {
test_result t = test_assignment(e, db, keyspace, schema_opt, receiver);
if (t == test_result::NOT_ASSIGNABLE) {
return test_result::NOT_ASSIGNABLE;
}
if (t == test_result::WEAKLY_ASSIGNABLE) {
res = test_result::WEAKLY_ASSIGNABLE;
}
}
return res;
}
class assignment_testable_expression : public assignment_testable {
expression _e;
std::optional<data_type> _type_opt;
public:
explicit assignment_testable_expression(expression e, std::optional<data_type> type_opt) : _e(std::move(e)), _type_opt(std::move(type_opt)) {}
virtual test_result test_assignment(data_dictionary::database db, const sstring& keyspace, const schema* schema_opt, const column_specification& receiver) const override {
return expr::test_assignment(_e, db, keyspace, schema_opt, receiver);
}
virtual vector_test_result test_assignment_any_size_float_vector() const override {
return expr::test_assignment_any_size_float_vector(_e);
}
virtual sstring assignment_testable_source_context() const override {
return fmt::format("{}", _e);
}
virtual std::optional<data_type> assignment_testable_type_opt() const override {
return _type_opt;
}
};
::shared_ptr<assignment_testable> as_assignment_testable(expression e, std::optional<data_type> type_opt) {
return ::make_shared<assignment_testable_expression>(std::move(e), std::move(type_opt));
}
// Finds column_defintion for given column name in the schema.
static const column_value resolve_column(const unresolved_identifier& col_ident, const schema& schema) {
::shared_ptr<column_identifier> id = col_ident.ident->prepare_column_identifier(schema);
const column_definition* def = get_column_definition(schema, *id);
if (!def || def->is_hidden_from_cql()) {
throw exceptions::unrecognized_entity_exception(*id);
}
return column_value(def);
}
// Finds the type of a prepared LHS of binary_operator and creates a receiver with it.
static lw_shared_ptr<column_specification> get_lhs_receiver(const expression& prepared_lhs, const schema& schema) {
return expr::visit(overloaded_functor{
[](const column_value& col_val) -> lw_shared_ptr<column_specification> {
return col_val.col->column_specification;
},
[](const subscript& col_val) -> lw_shared_ptr<column_specification> {
const column_value& sub_col = get_subscripted_column(col_val);
if (sub_col.col->type->is_map()) {
return map_value_spec_of(*sub_col.col->column_specification);
} else if (sub_col.col->type->is_set()) {
return set_value_spec_of(*sub_col.col->column_specification);
} else {
return list_value_spec_of(*sub_col.col->column_specification);
}
},
[&](const tuple_constructor& tup) -> lw_shared_ptr<column_specification> {
std::ostringstream tuple_name;
tuple_name << "(";
std::vector<data_type> tuple_types;
tuple_types.reserve(tup.elements.size());
for (std::size_t i = 0; i < tup.elements.size(); i++) {
lw_shared_ptr<column_specification> elem_receiver = get_lhs_receiver(tup.elements[i], schema);
tuple_name << elem_receiver->name->text();
if (i+1 != tup.elements.size()) {
tuple_name << ",";
}
tuple_types.push_back(elem_receiver->type->underlying_type());
}
tuple_name << ")";
shared_ptr<column_identifier> identifier = ::make_shared<column_identifier>(tuple_name.str(), true);
data_type tuple_type = tuple_type_impl::get_instance(tuple_types);
return make_lw_shared<column_specification>(schema.ks_name(), schema.cf_name(), std::move(identifier), std::move(tuple_type));
},
[&](const function_call& fun_call) -> lw_shared_ptr<column_specification> {
// In case of an expression like `token(p1, p2, p3) = ?` the receiver name should be "partition key token".
// This is required for compatibality with the java driver, it breaks with a receiver name like "token(p1, p2, p3)".
if (is_partition_token_for_schema(fun_call, schema)) {
return make_lw_shared<column_specification>(
schema.ks_name(),
schema.cf_name(),
::make_shared<column_identifier>("partition key token", true),
long_type);
}
data_type return_type = std::visit(
overloaded_functor{
[](const shared_ptr<db::functions::function>& fun) -> data_type { return fun->return_type(); },
[&](const functions::function_name&) -> data_type {
on_internal_error(expr_logger,
format("get_lhs_receiver: unprepared function call {:debug}", fun_call));
}},
fun_call.func);
return make_lw_shared<column_specification>(
schema.ks_name(), schema.cf_name(),
::make_shared<column_identifier>(format("{:user}", fun_call), true),
return_type);
},
[](const auto& other) -> lw_shared_ptr<column_specification> {
on_internal_error(expr_logger, format("get_lhs_receiver: unexpected expression: {}", other));
},
}, prepared_lhs);
}
// Given type of LHS and the operation finds the expected type of RHS.
// The type will be the same as LHS for simple operations like =, but it will be different for more complex ones like IN or CONTAINS.
static lw_shared_ptr<column_specification> get_rhs_receiver(lw_shared_ptr<column_specification>& lhs_receiver, oper_t oper) {
const data_type lhs_type = lhs_receiver->type->underlying_type();
if (oper == oper_t::IN || oper == oper_t::NOT_IN) {
data_type rhs_receiver_type = list_type_impl::get_instance(std::move(lhs_type), false);
auto in_name = ::make_shared<column_identifier>(format("{}({})", oper, lhs_receiver->name->text()), true);
return make_lw_shared<column_specification>(lhs_receiver->ks_name,
lhs_receiver->cf_name,
in_name,
std::move(rhs_receiver_type));
} else if (oper == oper_t::CONTAINS) {
if (lhs_type->is_list()) {
return list_value_spec_of(*lhs_receiver);
} else if (lhs_type->is_set()) {
return set_value_spec_of(*lhs_receiver);
} else if (lhs_type->is_map()) {
return map_value_spec_of(*lhs_receiver);
} else {
throw exceptions::invalid_request_exception(format("Cannot use CONTAINS on non-collection column \"{}\"",
lhs_receiver->name));
}
} else if (oper == oper_t::CONTAINS_KEY) {
if (lhs_type->is_map()) {
return map_key_spec_of(*lhs_receiver);
} else {
throw exceptions::invalid_request_exception(format("Cannot use CONTAINS KEY on non-map column {}",
lhs_receiver->name));
}
} else if (oper == oper_t::LIKE) {
if (!lhs_type->is_string()) {
throw exceptions::invalid_request_exception(
format("LIKE is allowed only on string types, which {} is not", lhs_receiver->name->text()));
}
return lhs_receiver;
} else {
return lhs_receiver;
}
}
class like_constant_function : public cql3::functions::scalar_function {
functions::function_name _name;
like_matcher _matcher;
std::vector<data_type> _lhs_types;
public:
like_constant_function(data_type arg_type, bytes_view pattern)
: _name("system", fmt::format("like({})",
std::string_view(reinterpret_cast<const char*>(pattern.data()), pattern.size())))
, _matcher(pattern) {
_lhs_types.push_back(std::move(arg_type));
}
virtual const functions::function_name& name() const override {
return _name;
}
virtual const std::vector<data_type>& arg_types() const override {
return _lhs_types;
}
virtual const data_type& return_type() const override {
return boolean_type;
}
virtual bool is_pure() const override {
return true;
}
virtual bool is_native() const override {
return true;
}
virtual bool requires_thread() const override {
return false;
}
virtual bool is_aggregate() const override {
return false;
}
virtual void print(std::ostream& os) const override {
os << "LIKE(compiled)";
}
virtual sstring column_name(const std::vector<sstring>& column_names) const override {
return "LIKE";
}
virtual bytes_opt execute(std::span<const bytes_opt> parameters) override {
auto& str_opt = parameters[0];
if (!str_opt) {
return std::nullopt;
}
bool match_result = _matcher(*str_opt);
return data_value(match_result).serialize();
}
};
expression
optimize_like(const expression& e) {
// Check for LIKE with constant pattern; replace with anonymous
// function that contains the compiled regex.
return search_and_replace(e, [] (const expression& subexpression) -> std::optional<expression> {
if (auto* binop = as_if<binary_operator>(&subexpression)) {
if (binop->op == oper_t::LIKE) {
if (auto* rhs = as_if<constant>(&binop->rhs)) {
if ((type_of(*rhs) == utf8_type || type_of(*rhs) == ascii_type) && !rhs->is_null()) {
auto pattern = to_bytes(rhs->value.view());
auto func = ::make_shared<like_constant_function>(type_of(binop->lhs), pattern);
auto args = std::vector<expression>();
args.push_back(binop->lhs);
return function_call{std::move(func), std::move(args)};
}
}
}
}
return std::nullopt;
});
}
binary_operator prepare_binary_operator(binary_operator binop, data_dictionary::database db, const schema& table_schema) {
std::optional<expression> prepared_lhs_opt = try_prepare_expression(binop.lhs, db, table_schema.ks_name(), &table_schema, {});
if (!prepared_lhs_opt) {
throw exceptions::invalid_request_exception(fmt::format("Could not infer type of {}", binop.lhs));
}
auto& prepared_lhs = *prepared_lhs_opt;
lw_shared_ptr<column_specification> lhs_receiver = get_lhs_receiver(prepared_lhs, table_schema);
if (type_of(prepared_lhs)->references_duration() && is_slice(binop.op)) {
throw exceptions::invalid_request_exception(fmt::format("Duration type is unordered for {}", lhs_receiver->name));
}
lw_shared_ptr<column_specification> rhs_receiver = get_rhs_receiver(lhs_receiver, binop.op);
expression prepared_rhs = prepare_expression(binop.rhs, db, table_schema.ks_name(), &table_schema, rhs_receiver);
// IS NOT NULL requires an additional check that the RHS is NULL.
// Otherwise things like `int_col IS NOT 123` would be allowed - the types match, but the value is wrong.
if (binop.op == oper_t::IS_NOT) {
bool rhs_is_null = is<constant>(prepared_rhs) && as<constant>(prepared_rhs).is_null();
if (!rhs_is_null) {
throw exceptions::invalid_request_exception(format(
"IS NOT NULL is the only expression that is allowed when using IS NOT. Invalid binary operator: {:user}",
binop));
}
}
return binary_operator(std::move(prepared_lhs), binop.op, std::move(prepared_rhs), binop.order);
}
}
namespace cql3 {
lw_shared_ptr<column_specification>
lists::value_spec_of(const column_specification& column) {
return cql3::expr::list_value_spec_of(column);
}
lw_shared_ptr<column_specification>
maps::key_spec_of(const column_specification& column) {
return cql3::expr::map_key_spec_of(column);
}
lw_shared_ptr<column_specification>
maps::value_spec_of(const column_specification& column) {
return cql3::expr::map_value_spec_of(column);
}
lw_shared_ptr<column_specification>
sets::value_spec_of(const column_specification& column) {
return cql3::expr::set_value_spec_of(column);
}
lw_shared_ptr<column_specification>
user_types::field_spec_of(const column_specification& column, size_t field) {
return cql3::expr::usertype_field_spec_of(column, field);
}
}
Reference in New Issue View Git Blame Copy Permalink