duckdb::FunctionSet< T > Class Template Reference

Collaboration diagram for duckdb::FunctionSet< T >:

Public Member Functions
	FunctionSet (string name)
void	AddFunction (T function)
idx_t	Size ()
T	GetFunctionByOffset (idx_t offset)
T &	GetFunctionReferenceByOffset (idx_t offset)
bool	MergeFunctionSet (FunctionSet< T > new_functions, bool override=false)

Public Attributes
string	name
	The name of the function set.
vector< T >	functions
	The set of functions.

Constructor & Destructor Documentation

FunctionSet()

template<class T >

duckdb::FunctionSet< T >::FunctionSet ( string  name )

inlineexplicit

                                      : name(std::move(name)) {
    }

Member Function Documentation

AddFunction()

template<class T >

void duckdb::FunctionSet< T >::AddFunction ( T  function )

inline

                                 {
        functions.push_back(std::move(function));
    }

Size()

template<class T >

idx_t duckdb::FunctionSet< T >::Size ( )

inline

                 {
        return functions.size();
    }

GetFunctionByOffset()

template<class T >

T duckdb::FunctionSet< T >::GetFunctionByOffset ( idx_t  offset )

inline

                                        {
        D_ASSERT(offset < functions.size());
        return functions[offset];
    }

GetFunctionReferenceByOffset()

template<class T >

T & duckdb::FunctionSet< T >::GetFunctionReferenceByOffset ( idx_t  offset )

inline

                                                  {
        D_ASSERT(offset < functions.size());
        return functions[offset];
    }

MergeFunctionSet()

template<class T >

bool duckdb::FunctionSet< T >::MergeFunctionSet ( FunctionSet< T >  new_functions, bool  override = false  )

inline

                                                                               {
        D_ASSERT(!new_functions.functions.empty());
        for (auto &new_func : new_functions.functions) {
            bool overwritten = false;
            for (auto &func : functions) {
                if (new_func.Equal(func)) {
                    // function overload already exists
                    if (override) {
                        // override it
                        overwritten = true;
                        func = new_func;
                    } else {
                        // throw an error
                        return false;
                    }
                    break;
                }
            }
            if (!overwritten) {
                functions.push_back(new_func);
            }
        }
        return true;
    }

---

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

• external/duckdb/duckdb.hpp