702b1b97bf
As reproduced in cql-pytest/test_json.py and reported in issue #7911, failing fromJson() calls should return a FUNCTION_FAILURE error, but currently produce a generic SERVER_ERROR, which can lead the client to think the server experienced some unknown internal error and the query can be retried on another server. This patch adds a new cassandra_exception subclass that we were missing - function_execution_exception - properly formats this error message (as described in the CQL protocol documentation), and uses this exception in two cases: 1. Parse errors in fromJson()'s parameters are converted into a function_execution_exception. 2. Any exceptions during the execute() of a native_scalar_function_for function is converted into a function_execution_exception. In particular, fromJson() uses a native_scalar_function_for. Note, however, that functions which already took care to produce a specific Cassandra error, this error is passed through and not converted to a function_execution_exception. An example is the blobAsText() which can return an invalid_request error, so it is left as such and not converted. This also happens in Cassandra. All relevant tests in cql-pytest/test_json.py now pass, and are no longer marked xfail. This patch also includes a few more improvements to test_json.py. Fixes #7911 Signed-off-by: Nadav Har'El <nyh@scylladb.com> Message-Id: <20210118140114.4149997-1-nyh@scylladb.com>
114 lines
4.1 KiB
C++
114 lines
4.1 KiB
C++
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* Modified by ScyllaDB
|
|
*
|
|
* Copyright (C) 2014 ScyllaDB
|
|
*/
|
|
|
|
/*
|
|
* This file is part of Scylla.
|
|
*
|
|
* Scylla is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Scylla is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "native_function.hh"
|
|
#include "scalar_function.hh"
|
|
#include <seastar/core/shared_ptr.hh>
|
|
|
|
namespace cql3 {
|
|
namespace functions {
|
|
|
|
/**
|
|
* Base class for the <code>ScalarFunction</code> native classes.
|
|
*/
|
|
class native_scalar_function : public native_function, public scalar_function {
|
|
protected:
|
|
native_scalar_function(sstring name, data_type return_type, std::vector<data_type> args_type)
|
|
: native_function(std::move(name), std::move(return_type), std::move(args_type)) {
|
|
}
|
|
|
|
public:
|
|
virtual bool is_aggregate() const override {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template <typename Func, bool Pure>
|
|
class native_scalar_function_for : public native_scalar_function {
|
|
Func _func;
|
|
public:
|
|
native_scalar_function_for(sstring name,
|
|
data_type return_type,
|
|
const std::vector<data_type> arg_types,
|
|
Func&& func)
|
|
: native_scalar_function(std::move(name), std::move(return_type), std::move(arg_types))
|
|
, _func(std::forward<Func>(func)) {
|
|
}
|
|
virtual bool is_pure() const override {
|
|
return Pure;
|
|
}
|
|
virtual bytes_opt execute(cql_serialization_format sf, const std::vector<bytes_opt>& parameters) override {
|
|
try {
|
|
return _func(sf, parameters);
|
|
} catch(exceptions::cassandra_exception&) {
|
|
// If the function's code took the time to produce an official
|
|
// cassandra_exception, pass it through. Otherwise, below we will
|
|
// wrap the unknown exception in a function_execution_exception.
|
|
throw;
|
|
} catch(...) {
|
|
std::vector<sstring> args;
|
|
args.reserve(arg_types().size());
|
|
for (const data_type& a : arg_types()) {
|
|
args.push_back(a->name());
|
|
}
|
|
throw exceptions::function_execution_exception(name().name,
|
|
format("Failed execution of function {}: {}", name(), std::current_exception()), name().keyspace, std::move(args));
|
|
}
|
|
}
|
|
};
|
|
|
|
template <bool Pure, typename Func>
|
|
shared_ptr<function>
|
|
make_native_scalar_function(sstring name,
|
|
data_type return_type,
|
|
std::vector<data_type> args_type,
|
|
Func&& func) {
|
|
return ::make_shared<native_scalar_function_for<Func, Pure>>(std::move(name),
|
|
std::move(return_type),
|
|
std::move(args_type),
|
|
std::forward<Func>(func));
|
|
}
|
|
|
|
}
|
|
}
|