duckdb::DefaultTableFunctionGenerator Class Reference

Inheritance diagram for duckdb::DefaultTableFunctionGenerator:

Collaboration diagram for duckdb::DefaultTableFunctionGenerator:

Public Member Functions
	DefaultTableFunctionGenerator (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 unique_ptr< CreateMacroInfo >	CreateTableMacroInfo (const DefaultTableMacro &default_macro)

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

Static Private Member Functions
static unique_ptr< CreateMacroInfo >	CreateInternalTableMacroInfo (const DefaultTableMacro &default_macro, unique_ptr< MacroFunction > function)

Constructor & Destructor Documentation

DefaultTableFunctionGenerator()

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

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

Member Function Documentation

CreateDefaultEntry()

unique_ptr< CatalogEntry > duckdb::DefaultTableFunctionGenerator::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 = GetDefaultTableFunction(schema.name, entry_name);
    if (info) {
        return make_uniq_base<CatalogEntry, TableMacroCatalogEntry>(catalog, schema, info->Cast<CreateMacroInfo>());
    }
    return nullptr;
}

GetDefaultEntries()

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

overridevirtual

Get a list of all default entries in the generator.

Implements duckdb::DefaultGenerator.

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

Here is the call graph for this function:

CreateTableMacroInfo()

unique_ptr< CreateMacroInfo > duckdb::DefaultTableFunctionGenerator::CreateTableMacroInfo ( const DefaultTableMacro &  default_macro )

static

                                                                                          {
    Parser parser;
    parser.ParseQuery(default_macro.macro);
    if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
        throw InternalException("Expected a single select statement in CreateTableMacroInfo internal");
    }
    auto node = std::move(parser.statements[0]->Cast<SelectStatement>().node);
 
    auto result = make_uniq<TableMacroFunction>(std::move(node));
    return CreateInternalTableMacroInfo(default_macro, std::move(result));
}

CreateInternalTableMacroInfo()

unique_ptr< CreateMacroInfo > duckdb::DefaultTableFunctionGenerator::CreateInternalTableMacroInfo ( const DefaultTableMacro &  default_macro, unique_ptr< MacroFunction >  function  )

staticprivate

                                                                                                {
    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])));
    }
 
    auto type = CatalogType::TABLE_MACRO_ENTRY;
    auto bind_info = make_uniq<CreateMacroInfo>(type);
    bind_info->schema = default_macro.schema;
    bind_info->name = default_macro.name;
    bind_info->temporary = true;
    bind_info->internal = true;
    bind_info->macros.push_back(std::move(function));
    return bind_info;
}

---

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

• external/duckdb/duckdb.cpp