duckdb::DefaultFunctionGenerator Class Reference

Inheritance diagram for duckdb::DefaultFunctionGenerator:

Collaboration diagram for duckdb::DefaultFunctionGenerator:

Public Member Functions
	DefaultFunctionGenerator (Catalog &catalog, SchemaCatalogEntry &schema)
unique_ptr< CatalogEntry >	CreateDefaultEntry (ClientContext &context, const string &entry_name) override
	Creates a default entry with the specified name, or returns nullptr if no such entry can be generated.
vector< string >	GetDefaultEntries () override
	Get a list of all default entries in the generator.
Public Member Functions inherited from duckdb::DefaultGenerator
	DefaultGenerator (Catalog &catalog)
virtual unique_ptr< CatalogEntry >	CreateDefaultEntry (CatalogTransaction transaction, const string &entry_name)
virtual bool	LockDuringCreate () const

Static Public Member Functions
static DUCKDB_API unique_ptr< CreateMacroInfo >	CreateInternalMacroInfo (const DefaultMacro &default_macro)
static DUCKDB_API unique_ptr< CreateMacroInfo >	CreateInternalMacroInfo (array_ptr< const DefaultMacro > macro)

Public Attributes
SchemaCatalogEntry &	schema
Public Attributes inherited from duckdb::DefaultGenerator
Catalog &	catalog
atomic< bool >	created_all_entries

Constructor & Destructor Documentation

DefaultFunctionGenerator()

duckdb::DefaultFunctionGenerator::DefaultFunctionGenerator	(	Catalog &	catalog,
		SchemaCatalogEntry &	schema
	)

    : DefaultGenerator(catalog), schema(schema) {
}

Member Function Documentation

CreateInternalMacroInfo() [1/2]

unique_ptr< CreateMacroInfo > duckdb::DefaultFunctionGenerator::CreateInternalMacroInfo ( const DefaultMacro &  default_macro )

static

                                                                                                               {
    return CreateInternalMacroInfo(array_ptr<const DefaultMacro>(default_macro));
}

CreateInternalMacroInfo() [2/2]

unique_ptr< CreateMacroInfo > duckdb::DefaultFunctionGenerator::CreateInternalMacroInfo ( array_ptr< const DefaultMacro >  macro )

static

                                                                                                                  {
    auto type = CatalogType::MACRO_ENTRY;
    auto bind_info = make_uniq<CreateMacroInfo>(type);
    for(auto &default_macro : macros) {
        // parse the expression
        auto expressions = Parser::ParseExpressionList(default_macro.macro);
        D_ASSERT(expressions.size() == 1);
 
        auto function = make_uniq<ScalarMacroFunction>(std::move(expressions[0]));
        for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
            function->parameters.push_back(
                make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
        }
        for (idx_t named_idx = 0; default_macro.named_parameters[named_idx].name != nullptr; named_idx++) {
            const auto &named_param = default_macro.named_parameters[named_idx];
            auto expr_list = Parser::ParseExpressionList(named_param.default_value);
            if (expr_list.size() != 1) {
                throw InternalException("Expected a single expression");
            }
            function->parameters.push_back(make_uniq<ColumnRefExpression>(named_param.name));
            function->default_parameters.insert(make_pair(named_param.name, std::move(expr_list[0])));
        }
        D_ASSERT(function->type == MacroType::SCALAR_MACRO);
        bind_info->macros.push_back(std::move(function));
    }
    bind_info->schema = macros[0].schema;
    bind_info->name = macros[0].name;
    bind_info->temporary = true;
    bind_info->internal = true;
    return bind_info;
}

CreateDefaultEntry()

unique_ptr< CatalogEntry > duckdb::DefaultFunctionGenerator::CreateDefaultEntry ( ClientContext &  context, const string &  entry_name  )

overridevirtual

Creates a default entry with the specified name, or returns nullptr if no such entry can be generated.

Reimplemented from duckdb::DefaultGenerator.

                                                                                                {
    auto info = GetDefaultFunction(schema.name, entry_name);
    if (info) {
        return make_uniq_base<CatalogEntry, ScalarMacroCatalogEntry>(catalog, schema, info->Cast<CreateMacroInfo>());
    }
    return nullptr;
}

GetDefaultEntries()

vector< string > duckdb::DefaultFunctionGenerator::GetDefaultEntries ( )

overridevirtual

Get a list of all default entries in the generator.

Implements duckdb::DefaultGenerator.

                                                           {
    vector<string> result;
    for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
        if (StringUtil::Lower(internal_macros[index].name) != internal_macros[index].name) {
            throw InternalException("Default macro name %s should be lowercase", internal_macros[index].name);
        }
        if (internal_macros[index].schema == schema.name) {
            result.emplace_back(internal_macros[index].name);
        }
    }
    return result;
}

Here is the call graph for this function:

---

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

• external/duckdb/duckdb.cpp