duckdb::ScalarFunction Class Reference

Inheritance diagram for duckdb::ScalarFunction:

Collaboration diagram for duckdb::ScalarFunction:

Public Member Functions
DUCKDB_API	ScalarFunction (string name, vector< LogicalType > arguments, LogicalType return_type, scalar_function_t function, bind_scalar_function_t bind=nullptr, bind_scalar_function_extended_t bind_extended=nullptr, function_statistics_t statistics=nullptr, init_local_state_t init_local_state=nullptr, LogicalType varargs=LogicalType(LogicalTypeId::INVALID), FunctionStability stability=FunctionStability::CONSISTENT, FunctionNullHandling null_handling=FunctionNullHandling::DEFAULT_NULL_HANDLING, bind_lambda_function_t bind_lambda=nullptr)
DUCKDB_API	ScalarFunction (vector< LogicalType > arguments, LogicalType return_type, scalar_function_t function, bind_scalar_function_t bind=nullptr, bind_scalar_function_extended_t bind_extended=nullptr, function_statistics_t statistics=nullptr, init_local_state_t init_local_state=nullptr, LogicalType varargs=LogicalType(LogicalTypeId::INVALID), FunctionStability stability=FunctionStability::CONSISTENT, FunctionNullHandling null_handling=FunctionNullHandling::DEFAULT_NULL_HANDLING, bind_lambda_function_t bind_lambda=nullptr)
bool	HasFunctionCallback () const
scalar_function_t	GetFunctionCallback () const
void	SetFunctionCallback (scalar_function_t callback)
bool	HasBindCallback () const
bind_scalar_function_t	GetBindCallback () const
void	SetBindCallback (bind_scalar_function_t callback)
bool	HasBindExtendedCallback () const
bind_scalar_function_extended_t	GetBindExtendedCallback () const
void	SetBindExtendedCallback (bind_scalar_function_extended_t callback)
bool	HasBindLambdaCallback () const
bind_lambda_function_t	GetBindLambdaCallback () const
void	SetBindLambdaCallback (bind_lambda_function_t callback)
bool	HasBindExpressionCallback () const
function_bind_expression_t	GetBindExpressionCallback () const
void	SetBindExpressionCallback (function_bind_expression_t callback)
bool	HasInitStateCallback () const
init_local_state_t	GetInitStateCallback () const
void	SetInitStateCallback (init_local_state_t callback)
bool	HasStatisticsCallback () const
function_statistics_t	GetStatisticsCallback () const
void	SetStatisticsCallback (function_statistics_t callback)
bool	HasModifiedDatabasesCallback () const
get_modified_databases_t	GetModifiedDatabasesCallback () const
void	SetModifiedDatabasesCallback (get_modified_databases_t callback)
bool	HasSerializationCallbacks () const
void	SetSerializeCallback (function_serialize_t callback)
void	SetDeserializeCallback (function_deserialize_t callback)
function_serialize_t	GetSerializeCallback () const
function_deserialize_t	GetDeserializeCallback () const
bool	HasExtraFunctionInfo () const
ScalarFunctionInfo &	GetExtraFunctionInfo () const
void	SetExtraFunctionInfo (shared_ptr< ScalarFunctionInfo > info)
template<class T , class... ARGS>
void	SetExtraFunctionInfo (ARGS &&... args)
DUCKDB_API bool	operator== (const ScalarFunction &rhs) const
DUCKDB_API bool	operator!= (const ScalarFunction &rhs) const
DUCKDB_API bool	Equal (const ScalarFunction &rhs) const
Public Member Functions inherited from duckdb::BaseScalarFunction
DUCKDB_API	BaseScalarFunction (string name, vector< LogicalType > arguments, LogicalType return_type, FunctionStability stability, LogicalType varargs=LogicalType(LogicalTypeId::INVALID), FunctionNullHandling null_handling=FunctionNullHandling::DEFAULT_NULL_HANDLING, FunctionErrors errors=FunctionErrors::CANNOT_ERROR)
void	SetReturnType (LogicalType return_type_p)
const LogicalType &	GetReturnType () const
LogicalType &	GetReturnType ()
FunctionStability	GetStability () const
void	SetStability (FunctionStability stability_p)
FunctionNullHandling	GetNullHandling () const
void	SetNullHandling (FunctionNullHandling null_handling_p)
FunctionErrors	GetErrorMode () const
void	SetErrorMode (FunctionErrors errors_p)
void	SetFallible ()
	Set this functions error-mode as fallible (can throw runtime errors)
void	SetVolatile ()
	Set this functions stability as volatile (can not be cached per row)
void	SetCollationHandling (FunctionCollationHandling collation_handling_p)
FunctionCollationHandling	GetCollationHandling () const
DUCKDB_API hash_t	Hash () const
DUCKDB_API string	ToString () const override
Public Member Functions inherited from duckdb::SimpleFunction
DUCKDB_API	SimpleFunction (string name, vector< LogicalType > arguments, LogicalType varargs=LogicalType(LogicalTypeId::INVALID))
DUCKDB_API bool	HasVarArgs () const
Public Member Functions inherited from duckdb::Function
DUCKDB_API	Function (string name)

Static Public Member Functions
static DUCKDB_API void	NopFunction (DataChunk &input, ExpressionState &state, Vector &result)
template<class TA , class TR , class OP >
static void	UnaryFunction (DataChunk &input, ExpressionState &state, Vector &result)
template<class TA , class TB , class TR , class OP >
static void	BinaryFunction (DataChunk &input, ExpressionState &state, Vector &result)
template<class TA , class TB , class TC , class TR , class OP >
static void	TernaryFunction (DataChunk &input, ExpressionState &state, Vector &result)
template<class OP >
static scalar_function_t	GetScalarUnaryFunction (const LogicalType &type)
template<class TR , class OP >
static scalar_function_t	GetScalarUnaryFunctionFixedReturn (const LogicalType &type)
Static Public Member Functions inherited from duckdb::BaseScalarFunction
static BaseScalarFunction	SetReturnsError (BaseScalarFunction &function)
Static Public Member Functions inherited from duckdb::Function
static DUCKDB_API string	CallToString (const string &catalog_name, const string &schema_name, const string &name, const vector< LogicalType > &arguments, const LogicalType &varargs=LogicalType::INVALID)
	Returns the formatted string name(arg1, arg2, ...)
static DUCKDB_API string	CallToString (const string &catalog_name, const string &schema_name, const string &name, const vector< LogicalType > &arguments, const LogicalType &varargs, const LogicalType &return_type)
	Returns the formatted string name(arg1, arg2..) -> return_type.
static DUCKDB_API string	CallToString (const string &catalog_name, const string &schema_name, const string &name, const vector< LogicalType > &arguments, const named_parameter_type_map_t &named_parameters)
	Returns the formatted string name(arg1, arg2.., np1=a, np2=b, ...)
static DUCKDB_API void	EraseArgument (SimpleFunction &bound_function, vector< unique_ptr< Expression > > &arguments, idx_t argument_index)
	Used in the bind to erase an argument from a function.

Public Attributes
scalar_function_t	function
	The main scalar function to execute.
bind_scalar_function_t	bind
	The bind function (if any)
bind_scalar_function_extended_t	bind_extended = nullptr
	The bind function that receives extra input to perform more complex binding operations (if any)
init_local_state_t	init_local_state
	Init thread local state for the function (if any)
function_statistics_t	statistics
	The statistics propagation function (if any)
bind_lambda_function_t	bind_lambda
	The lambda bind function (if any)
function_bind_expression_t	bind_expression
	Function to bind the result function expression directly (if any)
get_modified_databases_t	get_modified_databases
	Gets the modified databases (if any)
function_serialize_t	serialize
function_deserialize_t	deserialize
shared_ptr< ScalarFunctionInfo >	function_info
	Additional function info, passed to the bind.
Public Attributes inherited from duckdb::BaseScalarFunction
LogicalType	return_type
	Return type of the function.
FunctionStability	stability
	The stability of the function (see FunctionStability enum for more info)
FunctionNullHandling	null_handling
	How this function handles NULL values.
FunctionErrors	errors
	Whether or not this function can throw an error.
FunctionCollationHandling	collation_handling
	Collation handling of the function.
Public Attributes inherited from duckdb::SimpleFunction
vector< LogicalType >	arguments
	The set of arguments of the function.
vector< LogicalType >	original_arguments
LogicalType	varargs
Public Attributes inherited from duckdb::Function
string	name
	The name of the function.
string	extra_info
	Additional Information to specify function from it's name.
string	catalog_name
string	schema_name

Member Function Documentation

HasFunctionCallback()

bool duckdb::ScalarFunction::HasFunctionCallback ( ) const

inline

{ return function != nullptr; }

GetFunctionCallback()

scalar_function_t duckdb::ScalarFunction::GetFunctionCallback ( ) const

inline

{ return function; }

SetFunctionCallback()

void duckdb::ScalarFunction::SetFunctionCallback ( scalar_function_t  callback )

inline

{ function = std::move(callback); }

HasBindCallback()

bool duckdb::ScalarFunction::HasBindCallback ( ) const

inline

{ return bind != nullptr; };

GetBindCallback()

bind_scalar_function_t duckdb::ScalarFunction::GetBindCallback ( ) const

inline

{ return bind; };

SetBindCallback()

void duckdb::ScalarFunction::SetBindCallback ( bind_scalar_function_t  callback )

inline

{ bind = callback; }

HasBindExtendedCallback()

bool duckdb::ScalarFunction::HasBindExtendedCallback ( ) const

inline

{ return bind_extended != nullptr; }

GetBindExtendedCallback()

bind_scalar_function_extended_t duckdb::ScalarFunction::GetBindExtendedCallback ( ) const

inline

{ return bind_extended; }

SetBindExtendedCallback()

void duckdb::ScalarFunction::SetBindExtendedCallback ( bind_scalar_function_extended_t  callback )

inline

{ bind_extended = callback; }

HasBindLambdaCallback()

bool duckdb::ScalarFunction::HasBindLambdaCallback ( ) const

inline

{ return bind_lambda != nullptr; }

GetBindLambdaCallback()

bind_lambda_function_t duckdb::ScalarFunction::GetBindLambdaCallback ( ) const

inline

{ return bind_lambda; }

SetBindLambdaCallback()

void duckdb::ScalarFunction::SetBindLambdaCallback ( bind_lambda_function_t  callback )

inline

{ bind_lambda = callback; }

HasBindExpressionCallback()

bool duckdb::ScalarFunction::HasBindExpressionCallback ( ) const

inline

{ return bind_expression != nullptr; }

GetBindExpressionCallback()

function_bind_expression_t duckdb::ScalarFunction::GetBindExpressionCallback ( ) const

inline

{ return bind_expression; }

SetBindExpressionCallback()

void duckdb::ScalarFunction::SetBindExpressionCallback ( function_bind_expression_t  callback )

inline

{ bind_expression = callback; }

HasInitStateCallback()

bool duckdb::ScalarFunction::HasInitStateCallback ( ) const

inline

{ return init_local_state != nullptr; }

GetInitStateCallback()

init_local_state_t duckdb::ScalarFunction::GetInitStateCallback ( ) const

inline

{ return init_local_state; }

SetInitStateCallback()

void duckdb::ScalarFunction::SetInitStateCallback ( init_local_state_t  callback )

inline

{ init_local_state = callback; }

HasStatisticsCallback()

bool duckdb::ScalarFunction::HasStatisticsCallback ( ) const

inline

{ return statistics != nullptr; }

GetStatisticsCallback()

function_statistics_t duckdb::ScalarFunction::GetStatisticsCallback ( ) const

inline

{ return statistics; }

SetStatisticsCallback()

void duckdb::ScalarFunction::SetStatisticsCallback ( function_statistics_t  callback )

inline

{ statistics = callback; }

HasModifiedDatabasesCallback()

bool duckdb::ScalarFunction::HasModifiedDatabasesCallback ( ) const

inline

{ return get_modified_databases != nullptr; }

GetModifiedDatabasesCallback()

get_modified_databases_t duckdb::ScalarFunction::GetModifiedDatabasesCallback ( ) const

inline

{ return get_modified_databases; }

SetModifiedDatabasesCallback()

void duckdb::ScalarFunction::SetModifiedDatabasesCallback ( get_modified_databases_t  callback )

inline

{ get_modified_databases = callback; }

HasSerializationCallbacks()

bool duckdb::ScalarFunction::HasSerializationCallbacks ( ) const

inline

{ return serialize != nullptr && deserialize != nullptr; }

SetSerializeCallback()

void duckdb::ScalarFunction::SetSerializeCallback ( function_serialize_t  callback )

inline

{ serialize = callback; }

SetDeserializeCallback()

void duckdb::ScalarFunction::SetDeserializeCallback ( function_deserialize_t  callback )

inline

{ deserialize = callback; }

GetSerializeCallback()

function_serialize_t duckdb::ScalarFunction::GetSerializeCallback ( ) const

inline

{ return serialize; }

GetDeserializeCallback()

function_deserialize_t duckdb::ScalarFunction::GetDeserializeCallback ( ) const

inline

{ return deserialize; }

HasExtraFunctionInfo()

bool duckdb::ScalarFunction::HasExtraFunctionInfo ( ) const

inline

                                      {
        return function_info != nullptr;
    }

GetExtraFunctionInfo()

ScalarFunctionInfo & duckdb::ScalarFunction::GetExtraFunctionInfo ( ) const

inline

                                                     {
        D_ASSERT(function_info.get());
        return *function_info;
    }

SetExtraFunctionInfo() [1/2]

void duckdb::ScalarFunction::SetExtraFunctionInfo ( shared_ptr< ScalarFunctionInfo >  info )

inline

                                                                   {
        function_info = std::move(info);
    }

SetExtraFunctionInfo() [2/2]

template<class T , class... ARGS>

void duckdb::ScalarFunction::SetExtraFunctionInfo ( ARGS &&...  args )

inline

                                               {
        function_info = make_shared_ptr<T>(std::forward<ARGS>(args)...);
    }

UnaryFunction()

template<class TA , class TR , class OP >

static void duckdb::ScalarFunction::UnaryFunction ( DataChunk &  input, ExpressionState &  state, Vector &  result  )

inlinestatic

                                                                                        {
        D_ASSERT(input.ColumnCount() >= 1);
        UnaryExecutor::Execute<TA, TR, OP>(input.data[0], result, input.size());
    }

BinaryFunction()

template<class TA , class TB , class TR , class OP >

static void duckdb::ScalarFunction::BinaryFunction ( DataChunk &  input, ExpressionState &  state, Vector &  result  )

inlinestatic

                                                                                         {
        D_ASSERT(input.ColumnCount() == 2);
        BinaryExecutor::ExecuteStandard<TA, TB, TR, OP>(input.data[0], input.data[1], result, input.size());
    }

TernaryFunction()

template<class TA , class TB , class TC , class TR , class OP >

static void duckdb::ScalarFunction::TernaryFunction ( DataChunk &  input, ExpressionState &  state, Vector &  result  )

inlinestatic

                                                                                          {
        D_ASSERT(input.ColumnCount() == 3);
        TernaryExecutor::ExecuteStandard<TA, TB, TC, TR, OP>(input.data[0], input.data[1], input.data[2], result,
                                                             input.size());
    }

GetScalarUnaryFunction()

template<class OP >

static scalar_function_t duckdb::ScalarFunction::GetScalarUnaryFunction ( const LogicalType &  type )

inlinestatic

                                                                             {
        scalar_function_t function;
        switch (type.id()) {
        case LogicalTypeId::TINYINT:
            function = &ScalarFunction::UnaryFunction<int8_t, int8_t, OP>;
            break;
        case LogicalTypeId::SMALLINT:
            function = &ScalarFunction::UnaryFunction<int16_t, int16_t, OP>;
            break;
        case LogicalTypeId::INTEGER:
            function = &ScalarFunction::UnaryFunction<int32_t, int32_t, OP>;
            break;
        case LogicalTypeId::BIGINT:
            function = &ScalarFunction::UnaryFunction<int64_t, int64_t, OP>;
            break;
        case LogicalTypeId::UTINYINT:
            function = &ScalarFunction::UnaryFunction<uint8_t, uint8_t, OP>;
            break;
        case LogicalTypeId::USMALLINT:
            function = &ScalarFunction::UnaryFunction<uint16_t, uint16_t, OP>;
            break;
        case LogicalTypeId::UINTEGER:
            function = &ScalarFunction::UnaryFunction<uint32_t, uint32_t, OP>;
            break;
        case LogicalTypeId::UBIGINT:
            function = &ScalarFunction::UnaryFunction<uint64_t, uint64_t, OP>;
            break;
        case LogicalTypeId::HUGEINT:
            function = &ScalarFunction::UnaryFunction<hugeint_t, hugeint_t, OP>;
            break;
        case LogicalTypeId::UHUGEINT:
            function = &ScalarFunction::UnaryFunction<uhugeint_t, uhugeint_t, OP>;
            break;
        case LogicalTypeId::FLOAT:
            function = &ScalarFunction::UnaryFunction<float, float, OP>;
            break;
        case LogicalTypeId::DOUBLE:
            function = &ScalarFunction::UnaryFunction<double, double, OP>;
            break;
        default:
            throw InternalException("Unimplemented type for GetScalarUnaryFunction");
        }
        return function;
    }

GetScalarUnaryFunctionFixedReturn()

template<class TR , class OP >

static scalar_function_t duckdb::ScalarFunction::GetScalarUnaryFunctionFixedReturn ( const LogicalType &  type )

inlinestatic

                                                                                        {
        scalar_function_t function;
        switch (type.id()) {
        case LogicalTypeId::TINYINT:
            function = &ScalarFunction::UnaryFunction<int8_t, TR, OP>;
            break;
        case LogicalTypeId::SMALLINT:
            function = &ScalarFunction::UnaryFunction<int16_t, TR, OP>;
            break;
        case LogicalTypeId::INTEGER:
            function = &ScalarFunction::UnaryFunction<int32_t, TR, OP>;
            break;
        case LogicalTypeId::BIGINT:
            function = &ScalarFunction::UnaryFunction<int64_t, TR, OP>;
            break;
        case LogicalTypeId::UTINYINT:
            function = &ScalarFunction::UnaryFunction<uint8_t, TR, OP>;
            break;
        case LogicalTypeId::USMALLINT:
            function = &ScalarFunction::UnaryFunction<uint16_t, TR, OP>;
            break;
        case LogicalTypeId::UINTEGER:
            function = &ScalarFunction::UnaryFunction<uint32_t, TR, OP>;
            break;
        case LogicalTypeId::UBIGINT:
            function = &ScalarFunction::UnaryFunction<uint64_t, TR, OP>;
            break;
        case LogicalTypeId::HUGEINT:
            function = &ScalarFunction::UnaryFunction<hugeint_t, TR, OP>;
            break;
        case LogicalTypeId::UHUGEINT:
            function = &ScalarFunction::UnaryFunction<uhugeint_t, TR, OP>;
            break;
        case LogicalTypeId::FLOAT:
            function = &ScalarFunction::UnaryFunction<float, TR, OP>;
            break;
        case LogicalTypeId::DOUBLE:
            function = &ScalarFunction::UnaryFunction<double, TR, OP>;
            break;
        default:
            throw InternalException("Unimplemented type for GetScalarUnaryFunctionFixedReturn");
        }
        return function;
    }

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.hpp