duckdb::ViewCatalogEntry Class Reference

A view catalog entry. More...

Inheritance diagram for duckdb::ViewCatalogEntry:

Collaboration diagram for duckdb::ViewCatalogEntry:

Public Member Functions
	ViewCatalogEntry (Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info)
	Create a real TableCatalogEntry and initialize storage for it.
virtual shared_ptr< ViewColumnInfo >	GetColumnInfo () const
	Returns the view column info, if the view is bound. Otherwise returns nullptr
virtual void	BindView (ClientContext &context, BindViewAction action=BindViewAction::BIND_IF_UNBOUND)
	Bind a view so we know the types / names returned by it.
virtual void	UpdateBinding (const vector< LogicalType > &types, const vector< string > &names)
	Update the view with a new set of types / names.
Value	GetColumnComment (idx_t column_index)
unique_ptr< CreateInfo >	GetInfo () const override
unique_ptr< CatalogEntry >	AlterEntry (ClientContext &context, AlterInfo &info) override
unique_ptr< CatalogEntry >	Copy (ClientContext &context) const override
virtual const SelectStatement &	GetQuery ()
string	ToSQL () const override
	Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry.
Public Member Functions inherited from duckdb::StandardEntry
	StandardEntry (CatalogType type, SchemaCatalogEntry &schema, Catalog &catalog, string name)
SchemaCatalogEntry &	ParentSchema () override
const SchemaCatalogEntry &	ParentSchema () const override
Public Member Functions inherited from duckdb::InCatalogEntry
	InCatalogEntry (CatalogType type, Catalog &catalog, string name)
Catalog &	ParentCatalog () override
const Catalog &	ParentCatalog () const override
void	Verify (Catalog &catalog) override
Public Member Functions inherited from duckdb::CatalogEntry
	CatalogEntry (CatalogType type, Catalog &catalog, string name)
	CatalogEntry (CatalogType type, string name, idx_t oid)
virtual unique_ptr< CatalogEntry >	AlterEntry (CatalogTransaction transaction, AlterInfo &info)
virtual void	UndoAlter (ClientContext &context, AlterInfo &info)
virtual void	Rollback (CatalogEntry &prev_entry)
virtual void	OnDrop ()
virtual void	SetAsRoot ()
	Sets the CatalogEntry as the new root entry (i.e. the newest entry)
void	Serialize (Serializer &serializer) const
void	SetChild (unique_ptr< CatalogEntry > child)
unique_ptr< CatalogEntry >	TakeChild ()
bool	HasChild () const
bool	HasParent () const
CatalogEntry &	Child ()
CatalogEntry &	Parent ()
const CatalogEntry &	Parent () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Public Attributes
unique_ptr< SelectStatement >	query
	The query of the view.
string	sql
	The SQL query (if any)
vector< string >	aliases
	The set of aliases associated with the view.
Public Attributes inherited from duckdb::StandardEntry
SchemaCatalogEntry &	schema
	The schema the entry belongs to.
LogicalDependencyList	dependencies
	The dependencies of the entry, can be empty.
Public Attributes inherited from duckdb::InCatalogEntry
Catalog &	catalog
	The catalog the entry belongs to.
Public Attributes inherited from duckdb::CatalogEntry
idx_t	oid
	The oid of the entry.
CatalogType	type
	The type of this catalog entry.
optional_ptr< CatalogSet >	set
	Reference to the catalog set this entry is stored in.
string	name
	The name of the entry.
bool	deleted
	Whether or not the object is deleted.
bool	temporary
	Whether or not the object is temporary and should not be added to the WAL.
bool	internal
	Whether or not the entry is an internal entry (cannot be deleted, not dumped, etc)
atomic< transaction_t >	timestamp
	Timestamp at which the catalog entry was created.
Value	comment
	(optional) comment on this entry
InsertionOrderPreservingMap< string >	tags
	(optional) extra data associated with this entry

Static Public Attributes
static constexpr const CatalogType	Type = CatalogType::VIEW_ENTRY
static constexpr const char *	Name = "view"

Private Member Functions
void	Initialize (CreateViewInfo &info)

Private Attributes
mutex	bind_lock
shared_ptr< ViewColumnInfo >	view_columns
	Columns returned by the view, if bound.
atomic< ViewBindState >	bind_state
	The current bind state of the view.
atomic< thread_id >	bind_thread
	Current binding thread.
unordered_map< string, Value >	column_comments
	The comments on the columns of the view: can be empty if there are no comments.

Additional Inherited Members
Static Public Member Functions inherited from duckdb::CatalogEntry
static unique_ptr< CreateInfo >	Deserialize (Deserializer &deserializer)

Detailed Description

A view catalog entry.

Constructor & Destructor Documentation

ViewCatalogEntry()

duckdb::ViewCatalogEntry::ViewCatalogEntry	(	Catalog &	catalog,
		SchemaCatalogEntry &	schema,
		CreateViewInfo &	info
	)

Create a real TableCatalogEntry and initialize storage for it.

    : StandardEntry(CatalogType::VIEW_ENTRY, schema, catalog, info.view_name), bind_state(ViewBindState::UNBOUND) {
    Initialize(info);
}

Member Function Documentation

GetColumnInfo()

shared_ptr< ViewColumnInfo > duckdb::ViewCatalogEntry::GetColumnInfo ( ) const

virtual

Returns the view column info, if the view is bound. Otherwise returns nullptr

                                                                 {
    return view_columns.atomic_load();
}

BindView()

void duckdb::ViewCatalogEntry::BindView ( ClientContext &  context, BindViewAction  action = BindViewAction::BIND_IF_UNBOUND  )

virtual

Bind a view so we know the types / names returned by it.

                                                                             {
    if (bind_state == ViewBindState::BINDING && bind_thread == ThreadUtil::GetThreadId()) {
        throw InvalidInputException("View \"%s\" was requested to be bound but this thread is already binding that "
                                    "view - this likely means the view was attempted to be bound recursively",
                                    name);
    }
    lock_guard<mutex> guard(bind_lock);
    if (action == BindViewAction::BIND_IF_UNBOUND && view_columns) {
        // already bound
        return;
    }
    auto prev_bind_state = bind_state.load();
    bind_state = ViewBindState::BINDING;
    bind_thread = ThreadUtil::GetThreadId();
    try {
        auto columns = make_shared_ptr<ViewColumnInfo>();
        Binder::BindView(context, GetQuery(), ParentCatalog().GetName(), ParentSchema().name, nullptr, aliases,
                         columns->types, columns->names);
        view_columns.atomic_store(columns);
    } catch (...) {
        bind_state = prev_bind_state;
        bind_thread = thread_id {};
        throw;
    }
    bind_state = ViewBindState::BOUND;
    bind_thread = thread_id {};
}

UpdateBinding()

void duckdb::ViewCatalogEntry::UpdateBinding ( const vector< LogicalType > &  types, const vector< string > &  names  )

virtual

Update the view with a new set of types / names.

                                                                                                      {
    auto columns = view_columns.atomic_load();
    if (columns && columns->types == types_p && columns->names == names_p) {
        // already bound with the current info
        return;
    }
    lock_guard<mutex> guard(bind_lock);
    auto new_columns = make_shared_ptr<ViewColumnInfo>();
    new_columns->types = types_p;
    new_columns->names = names_p;
    view_columns.atomic_store(new_columns);
    bind_state = ViewBindState::BOUND;
}

GetColumnComment()

Value duckdb::ViewCatalogEntry::GetColumnComment

(

idx_t

column_index

)

                                                           {
    auto view_columns = GetColumnInfo();
    if (!view_columns) {
        throw InternalException("ViewCatalogEntry::GetColumnComment called - but view has not been bound yet");
    }
    auto &names = view_columns->names;
    if (column_index >= names.size()) {
        return Value();
    }
    auto &name = names[column_index];
    auto entry = column_comments.find(name);
    if (entry != column_comments.end()) {
        return entry->second;
    }
    return Value();
}

GetInfo()

unique_ptr< CreateInfo > duckdb::ViewCatalogEntry::GetInfo ( ) const

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                       {
    auto result = make_uniq<CreateViewInfo>();
    result->schema = schema.name;
    result->view_name = name;
    result->sql = sql;
    result->query = query ? unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy()) : nullptr;
    result->aliases = aliases;
    auto view_columns = GetColumnInfo();
    if (view_columns) {
        result->names = view_columns->names;
        result->types = view_columns->types;
    }
    result->temporary = temporary;
    result->dependencies = dependencies;
    result->comment = comment;
    result->tags = tags;
    result->column_comments_map = column_comments;
    return std::move(result);
}

AlterEntry()

unique_ptr< CatalogEntry > duckdb::ViewCatalogEntry::AlterEntry ( ClientContext &  context, AlterInfo &  info  )

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                                             {
    D_ASSERT(!internal);
 
    // Column comments have a special alter type
    if (info.type == AlterType::SET_COLUMN_COMMENT) {
        auto &comment_on_column_info = info.Cast<SetColumnCommentInfo>();
        auto copied_view = Copy(context);
 
        auto view_columns = GetColumnInfo();
        if (view_columns) {
            // if the view is bound - verify the name we are commenting on exists
            auto &names = view_columns->names;
            auto entry = std::find(names.begin(), names.end(), comment_on_column_info.column_name);
            if (entry == names.end()) {
                throw BinderException("View \"%s\" does not have a column with name \"%s\"", name,
                                      comment_on_column_info.column_name);
            }
        }
        // apply the comment to the view
        auto &copied_view_entry = copied_view->Cast<ViewCatalogEntry>();
        copied_view_entry.column_comments[comment_on_column_info.column_name] = comment_on_column_info.comment_value;
        return copied_view;
    }
 
    if (info.type != AlterType::ALTER_VIEW) {
        throw CatalogException("Can only modify view with ALTER VIEW statement");
    }
    auto &view_info = info.Cast<AlterViewInfo>();
    switch (view_info.alter_view_type) {
    case AlterViewType::RENAME_VIEW: {
        auto &rename_info = view_info.Cast<RenameViewInfo>();
        auto copied_view = Copy(context);
        copied_view->name = rename_info.new_view_name;
        return copied_view;
    }
    default:
        throw InternalException("Unrecognized alter view type!");
    }
}

Copy()

unique_ptr< CatalogEntry > duckdb::ViewCatalogEntry::Copy ( ClientContext &  context ) const

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                            {
    D_ASSERT(!internal);
    auto create_info = GetInfo();
 
    return make_uniq<ViewCatalogEntry>(catalog, schema, create_info->Cast<CreateViewInfo>());
}

GetQuery()

const SelectStatement & duckdb::ViewCatalogEntry::GetQuery ( )

virtual

                                                  {
    return *query;
}

ToSQL()

string duckdb::ViewCatalogEntry::ToSQL ( ) const

overridevirtual

Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry.

Return empty sql with view name so pragma view_tables don't complain

Reimplemented from duckdb::CatalogEntry.

                                     {
    if (sql.empty()) {
        return sql;
    }
    auto info = GetInfo();
    auto result = info->ToString();
    return result;
}

Initialize()

void duckdb::ViewCatalogEntry::Initialize ( CreateViewInfo &  info )

private

                                                      {
    query = std::move(info.query);
    this->aliases = info.aliases;
    if (!info.types.empty()) {
        bind_state = ViewBindState::BOUND;
        view_columns = make_shared_ptr<ViewColumnInfo>();
        view_columns->types = info.types;
        view_columns->names = info.names;
        if (view_columns->names.empty()) {
            // DuckDB v0.9.2 and below store their names in the "aliases" field
            view_columns->names = info.aliases;
        }
        if (view_columns->types.size() != view_columns->names.size()) {
            throw InvalidInputException(
                "Error creating view %s - view types / names size mismatch (%d types, %d names)", name,
                view_columns->types.size(), view_columns->names.size());
        }
    }
    this->temporary = info.temporary;
    this->sql = info.sql;
    this->internal = info.internal;
    this->dependencies = info.dependencies;
    this->comment = info.comment;
    this->tags = info.tags;
    this->column_comments = info.column_comments_map;
}

---

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

• external/duckdb/duckdb.cpp