duckdb::DefaultTypeGenerator Class Reference

Inheritance diagram for duckdb::DefaultTypeGenerator:

Collaboration diagram for duckdb::DefaultTypeGenerator:

Public Member Functions
	DefaultTypeGenerator (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 LogicalTypeId	GetDefaultType (const string &name)
static DUCKDB_API LogicalType	TryDefaultBind (const string &name, const vector< pair< string, Value > > &params)

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

Constructor & Destructor Documentation

DefaultTypeGenerator()

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

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

Member Function Documentation

GetDefaultType()

LogicalTypeId duckdb::DefaultTypeGenerator::GetDefaultType ( const string &  name )

static

                                                                     {
    auto &internal_types = BUILTIN_TYPES;
    for (auto &type : internal_types) {
        if (StringUtil::CIEquals(name, type.name)) {
            return type.type;
        }
    }
    return LogicalType::INVALID;
}

TryDefaultBind()

LogicalType duckdb::DefaultTypeGenerator::TryDefaultBind ( const string &  name, const vector< pair< string, Value > > &  params  )

static

                                                                                                              {
    auto entry = TryGetDefaultTypeEntry(name);
    if (!entry) {
        return LogicalTypeId::INVALID;
    }
 
    if (!entry->bind_function) {
        if (params.empty()) {
            return LogicalType(entry->type);
        } else {
            throw InvalidInputException("Type '%s' does not take any type parameters", name);
        }
    }
 
    vector<TypeArgument> args;
    for (auto &param : params) {
        args.emplace_back(param.first, param.second);
    }
 
    BindLogicalTypeInput input {nullptr, LogicalType(entry->type), args};
    return entry->bind_function(input);
}

CreateDefaultEntry()

unique_ptr< CatalogEntry > duckdb::DefaultTypeGenerator::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.

                                                                                                                  {
    if (schema.name != DEFAULT_SCHEMA) {
        return nullptr;
    }
    auto entry = TryGetDefaultTypeEntry(entry_name);
    if (!entry || entry->type == LogicalTypeId::INVALID) {
        return nullptr;
    }
    CreateTypeInfo info;
    info.name = entry_name;
    info.type = LogicalType(entry->type);
    info.internal = true;
    info.temporary = true;
    info.bind_function = entry->bind_function;
    return make_uniq_base<CatalogEntry, TypeCatalogEntry>(catalog, schema, info);
}

GetDefaultEntries()

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

overridevirtual

Get a list of all default entries in the generator.

Implements duckdb::DefaultGenerator.

                                                       {
    vector<string> result;
    if (schema.name != DEFAULT_SCHEMA) {
        return result;
    }
    auto &internal_types = BUILTIN_TYPES;
    for (auto &type : internal_types) {
        result.emplace_back(StringUtil::Lower(type.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