fcb8d040e8
Instead of lengthy blurbs, switch to single-line, machine-readable standardized (https://spdx.dev) license identifiers. The Linux kernel switched long ago, so there is strong precedent. Three cases are handled: AGPL-only, Apache-only, and dual licensed. For the latter case, I chose (AGPL-3.0-or-later and Apache-2.0), reasoning that our changes are extensive enough to apply our license. The changes we applied mechanically with a script, except to licenses/README.md. Closes #9937
102 lines
2.3 KiB
C++
102 lines
2.3 KiB
C++
/*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2014-present ScyllaDB
|
|
*
|
|
* Modified by ScyllaDB
|
|
*/
|
|
|
|
/*
|
|
* SPDX-License-Identifier: (AGPL-3.0-or-later and Apache-2.0)
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "function.hh"
|
|
#include "types.hh"
|
|
#include "cql3/cql3_type.hh"
|
|
#include <vector>
|
|
#include <iosfwd>
|
|
#include <boost/functional/hash.hpp>
|
|
|
|
#include "cql3/functions/function_name.hh"
|
|
|
|
namespace std {
|
|
std::ostream& operator<<(std::ostream& os, const std::vector<data_type>& arg_types);
|
|
}
|
|
|
|
namespace cql3 {
|
|
|
|
namespace functions {
|
|
|
|
/**
|
|
* Base class for our native/hardcoded functions.
|
|
*/
|
|
class abstract_function : public virtual function {
|
|
protected:
|
|
function_name _name;
|
|
std::vector<data_type> _arg_types;
|
|
data_type _return_type;
|
|
|
|
abstract_function(function_name name, std::vector<data_type> arg_types, data_type return_type)
|
|
: _name(std::move(name)), _arg_types(std::move(arg_types)), _return_type(std::move(return_type)) {
|
|
}
|
|
|
|
public:
|
|
|
|
virtual bool requires_thread() const override;
|
|
|
|
virtual const function_name& name() const override {
|
|
return _name;
|
|
}
|
|
|
|
virtual const std::vector<data_type>& arg_types() const override {
|
|
return _arg_types;
|
|
}
|
|
|
|
virtual const data_type& return_type() const override {
|
|
return _return_type;
|
|
}
|
|
|
|
bool operator==(const abstract_function& x) const {
|
|
return _name == x._name
|
|
&& _arg_types == x._arg_types
|
|
&& _return_type == x._return_type;
|
|
}
|
|
|
|
virtual sstring column_name(const std::vector<sstring>& column_names) const override {
|
|
return format("{}({})", _name, join(", ", column_names));
|
|
}
|
|
|
|
virtual void print(std::ostream& os) const override;
|
|
};
|
|
|
|
inline
|
|
void
|
|
abstract_function::print(std::ostream& os) const {
|
|
os << _name << " : (";
|
|
os << _arg_types;
|
|
os << ") -> " << _return_type->as_cql3_type().to_string();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
namespace std {
|
|
|
|
template <>
|
|
struct hash<cql3::functions::abstract_function> {
|
|
size_t operator()(const cql3::functions::abstract_function& f) const {
|
|
using namespace cql3::functions;
|
|
size_t v = 0;
|
|
boost::hash_combine(v, std::hash<function_name>()(f.name()));
|
|
boost::hash_combine(v, boost::hash_value(f.arg_types()));
|
|
// FIXME: type hash
|
|
//boost::hash_combine(v, std::hash<shared_ptr<abstract_type>>()(f.return_type()));
|
|
return v;
|
|
}
|
|
};
|
|
|
|
}
|