duckdb::SequenceCatalogEntry Class Reference

A sequence catalog entry. More...

Inheritance diagram for duckdb::SequenceCatalogEntry:

Collaboration diagram for duckdb::SequenceCatalogEntry:

Public Member Functions
	SequenceCatalogEntry (Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info)
	Create a real TableCatalogEntry and initialize storage for it.
unique_ptr< CatalogEntry >	Copy (ClientContext &context) const override
unique_ptr< CreateInfo >	GetInfo () const override
SequenceData	GetData () const
int64_t	CurrentValue ()
int64_t	NextValue (DuckTransaction &transaction)
void	ReplayValue (uint64_t usage_count, int64_t counter)
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 (ClientContext &context, AlterInfo &info)
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

Static Public Attributes
static constexpr const CatalogType	Type = CatalogType::SEQUENCE_ENTRY
static constexpr const char *	Name = "sequence"

Private Attributes
mutex	lock
	Lock for getting a value on the sequence.
SequenceData	data
	Sequence data.

Additional Inherited Members
Static Public Member Functions inherited from duckdb::CatalogEntry
static unique_ptr< CreateInfo >	Deserialize (Deserializer &deserializer)
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

Detailed Description

A sequence catalog entry.

Constructor & Destructor Documentation

SequenceCatalogEntry()

duckdb::SequenceCatalogEntry::SequenceCatalogEntry	(	Catalog &	catalog,
		SchemaCatalogEntry &	schema,
		CreateSequenceInfo &	info
	)

Create a real TableCatalogEntry and initialize storage for it.

    : StandardEntry(CatalogType::SEQUENCE_ENTRY, schema, catalog, info.name), data(info) {
    this->temporary = info.temporary;
    this->comment = info.comment;
    this->tags = info.tags;
}

Member Function Documentation

Copy()

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

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                                {
    auto info_copy = GetInfo();
    auto &cast_info = info_copy->Cast<CreateSequenceInfo>();
 
    auto result = make_uniq<SequenceCatalogEntry>(catalog, schema, cast_info);
    result->data = GetData();
 
    return std::move(result);
}

GetInfo()

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

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                           {
    auto seq_data = GetData();
 
    auto result = make_uniq<CreateSequenceInfo>();
    result->catalog = catalog.GetName();
    result->schema = schema.name;
    result->name = name;
    result->usage_count = seq_data.usage_count;
    result->increment = seq_data.increment;
    result->min_value = seq_data.min_value;
    result->max_value = seq_data.max_value;
    result->start_value = seq_data.counter;
    result->cycle = seq_data.cycle;
    result->dependencies = dependencies;
    result->comment = comment;
    result->tags = tags;
    return std::move(result);
}

GetData()

SequenceData duckdb::SequenceCatalogEntry::GetData

(

)

const

                                                 {
    lock_guard<mutex> seqlock(lock);
    return data;
}

CurrentValue()

int64_t duckdb::SequenceCatalogEntry::CurrentValue

(

)

                                           {
    lock_guard<mutex> seqlock(lock);
    int64_t result;
    if (data.usage_count == 0u) {
        throw SequenceException("currval: sequence is not yet defined in this session");
    }
    result = data.last_value;
    return result;
}

NextValue()

int64_t duckdb::SequenceCatalogEntry::NextValue

(

DuckTransaction &

transaction

)

                                                                    {
    lock_guard<mutex> seqlock(lock);
    int64_t result;
    result = data.counter;
    bool overflow = !TryAddOperator::Operation(data.counter, data.increment, data.counter);
    if (data.cycle) {
        if (overflow) {
            data.counter = data.increment < 0 ? data.max_value : data.min_value;
        } else if (data.counter < data.min_value) {
            data.counter = data.max_value;
        } else if (data.counter > data.max_value) {
            data.counter = data.min_value;
        }
    } else {
        if (result < data.min_value || (overflow && data.increment < 0)) {
            throw SequenceException("nextval: reached minimum value of sequence \"%s\" (%lld)", name, data.min_value);
        }
        if (result > data.max_value || overflow) {
            throw SequenceException("nextval: reached maximum value of sequence \"%s\" (%lld)", name, data.max_value);
        }
    }
    data.last_value = result;
    data.usage_count++;
    if (!temporary) {
        transaction.PushSequenceUsage(*this, data);
    }
    return result;
}

ReplayValue()

void duckdb::SequenceCatalogEntry::ReplayValue	(	uint64_t	usage_count,
		int64_t	counter
	)

                                                                                {
    if (v_usage_count > data.usage_count) {
        data.usage_count = v_usage_count;
        data.counter = v_counter;
    }
}

ToSQL()

string duckdb::SequenceCatalogEntry::ToSQL ( ) const

overridevirtual

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

Reimplemented from duckdb::CatalogEntry.

                                         {
    auto seq_data = GetData();
 
    duckdb::stringstream ss;
    ss << "CREATE SEQUENCE ";
    ss << name;
    ss << " INCREMENT BY " << seq_data.increment;
    ss << " MINVALUE " << seq_data.min_value;
    ss << " MAXVALUE " << seq_data.max_value;
    ss << " START " << seq_data.counter;
    ss << " " << (seq_data.cycle ? "CYCLE" : "NO CYCLE") << ";";
    return ss.str();
}

---

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

• external/duckdb/duckdb.hpp
• external/duckdb/duckdb.cpp