duckdb::ConflictManager Class Reference

Collaboration diagram for duckdb::ConflictManager:

Classes
struct	ConflictData

Public Member Functions
	ConflictManager (const VerifyExistenceType lookup_type, const idx_t chunk_size, optional_ptr< ConflictInfo > conflict_info=nullptr)
bool	AddHit (const idx_t index_in_chunk, const row_t row_id)
	Returns true, if we need to throw, otherwise, adds the hit and returns false.
bool	AddSecondHit (const idx_t index_in_chunk, const row_t row_id)
	Returns true, if we need to throw, otherwise, adds the second hit and returns false.
bool	AddNull (const idx_t index_in_chunk)
	Returns true, if we need to throw, otherwise, adds the NULL and returns false.
optional_idx	GetFirstInvalidIndex (const idx_t count, const bool negate=false)
	Returns the index of the first (in)valid row, if any.
void	FinalizeGlobal (DuckTransaction &transaction, DataTable &table)
	Finalizes a global conflict manager.
void	FinalizeLocal (DataTable &table, LocalStorage &storage)
	Finalizes a local conflict manager.
void	FinishLookup ()
	Determines if we are finished registering conflicts.
const ConflictInfo &	GetConflictInfo () const
	Get the conflict information.
void	SetMode (const ConflictManagerMode mode_p)
	Sets the mode of the conflict manager.
void	AddIndex (BoundIndex &index, optional_ptr< BoundIndex > delete_index)
	Adds an index and its respective delete_index.
bool	IndexMatches (BoundIndex &index)
	Returns true, if the index is in this conflict manager.
const vector< reference< BoundIndex > > &	MatchingIndexes () const
	Returns a reference to the matching indexes.
const vector< optional_ptr< BoundIndex > > &	MatchingDeleteIndexes () const
	Returns a reference to the matching delete indexes.
VerifyExistenceType	GetVerifyExistenceType () const
	Returns the existence verification type.
bool	HasConflicts () const
	Returns true, if there are any conflicts, else false.
idx_t	ConflictCount () const
	Returns the number of conflicts.
Vector &	GetRowIds ()
SelectionVector &	GetInvertedSel () const
idx_t	GetFirstIndex () const
	Returns the first index in a chunk with a conflict.
ValidityArray &	GetFirstValidity ()
	Returns the validity array of the first conflict data.

Static Public Attributes
static constexpr uint8_t	FIRST = 0
static constexpr uint8_t	SECOND = 1

Private Member Functions
bool	IsConflict (LookupResultType type)
	Returns true, if we register a conflict for the lookup type.
bool	AddHit (const idx_t index_in_chunk, const std::function< void()> &callback)
	Adds a hit to the conflicts.
void	Finalize (const std::function< bool(const row_t row_id)> &callback)
	Determine visible row ID for each index with two possible row IDs.
bool	ShouldThrow (const idx_t index_in_chunk) const
	Returns true, if the conflict manager should throw an exception, else false.
bool	IgnoreNulls () const
	Returns true, if we ignore NULLs, else false.
ConflictData &	GetConflictData (const idx_t i)
void	AddRowId (const idx_t index_in_chunk, const row_t row_id)
	Adds a row ID to the primary conflict data.
void	AddSecondRowId (const idx_t index_in_chunk, const row_t row_id)
	Adds a row ID to the secondary conflict data.

Private Attributes
VerifyExistenceType	verify_existence_type
	The type of constraint verification for which we're using the conflict manager.
idx_t	chunk_size
	The count of the data chunk for which we've created the conflict manager.
optional_ptr< ConflictInfo >	conflict_info
	Optional information to match indexes to the conflict target.
ConflictManagerMode	mode
	The mode of the conflict manager.
vector< reference< BoundIndex > >	matching_indexes
	Indexes matching the conflict target.
vector< optional_ptr< BoundIndex > >	matching_delete_indexes
	Delete indexes matching the conflict target.
case_insensitive_set_t	index_names
	All matching indexes by their name (unique identifier).
unordered_set< idx_t >	conflict_rows
	Registers all conflicting rows in a data chunk.
bool	finished = false
	True, if we can skip recording any further conflicts.
array< ConflictData, 2 >	conflict_data

Detailed Description

The conflict manager tracks conflicts during constraint verification. It decides when/if to throw, and records conflicts to be used later in case of ON CONFLICT DO. The conflict manager operates on a per-chunk basis, i.e., we construct a new conflict manager per incoming chunk. On conflict manager can gather conflicts across multiple indexes, if they match the ON CONFLICT DO target.

Member Function Documentation

GetConflictInfo()

const ConflictInfo & duckdb::ConflictManager::GetConflictInfo ( ) const

inline

Get the conflict information.

                                                {
        return *conflict_info;
    }

SetMode()

void duckdb::ConflictManager::SetMode ( const ConflictManagerMode  mode_p )

inline

Sets the mode of the conflict manager.

                                                   {
        D_ASSERT(mode_p != ConflictManagerMode::SCAN || conflict_info != nullptr);
        mode = mode_p;
    }

AddIndex()

void duckdb::ConflictManager::AddIndex ( BoundIndex &  index, optional_ptr< BoundIndex >  delete_index  )

inline

Adds an index and its respective delete_index.

                                                                            {
        matching_indexes.push_back(index);
        matching_delete_indexes.push_back(delete_index);
        index_names.insert(index.name);
    }

IndexMatches()

bool duckdb::ConflictManager::IndexMatches ( BoundIndex &  index )

inline

Returns true, if the index is in this conflict manager.

                                         {
        return index_names.find(index.name) != index_names.end();
    }

MatchingIndexes()

const vector< reference< BoundIndex > > & duckdb::ConflictManager::MatchingIndexes ( ) const

inline

Returns a reference to the matching indexes.

                                                                 {
        return matching_indexes;
    }

MatchingDeleteIndexes()

const vector< optional_ptr< BoundIndex > > & duckdb::ConflictManager::MatchingDeleteIndexes ( ) const

inline

Returns a reference to the matching delete indexes.

                                                                          {
        return matching_delete_indexes;
    }

GetVerifyExistenceType()

VerifyExistenceType duckdb::ConflictManager::GetVerifyExistenceType ( ) const

inline

Returns the existence verification type.

                                                       {
        return verify_existence_type;
    }

HasConflicts()

bool duckdb::ConflictManager::HasConflicts ( ) const

inline

Returns true, if there are any conflicts, else false.

                              {
        return conflict_data[FIRST].sel != nullptr;
    }

Here is the caller graph for this function:

ConflictCount()

idx_t duckdb::ConflictManager::ConflictCount ( ) const

inline

Returns the number of conflicts.

                                {
        if (!HasConflicts()) {
            return 0;
        }
        return conflict_data[FIRST].count;
    }

Here is the call graph for this function:

GetRowIds()

Vector & duckdb::ConflictManager::GetRowIds ( )

inline

Returns a reference to the row IDs. Must be called after Finalize[Global|Local].

                        {
        D_ASSERT(!conflict_data[SECOND].sel);
        return *GetConflictData(FIRST).row_ids;
    }

Here is the call graph for this function:

GetInvertedSel()

SelectionVector & duckdb::ConflictManager::GetInvertedSel ( ) const

inline

Returns a reference to the inverted selection vector. Must be called after Finalize[Global|Local].

                                            {
        D_ASSERT(!conflict_data[SECOND].sel);
        return *conflict_data[FIRST].inverted_sel;
    }

Here is the caller graph for this function:

GetFirstIndex()

idx_t duckdb::ConflictManager::GetFirstIndex ( ) const

inline

Returns the first index in a chunk with a conflict.

                                {
        return GetInvertedSel().get_index(0);
    }

Here is the call graph for this function:

GetFirstValidity()

ValidityArray & duckdb::ConflictManager::GetFirstValidity ( )

inline

Returns the validity array of the first conflict data.

                                      {
        D_ASSERT(HasConflicts());
        return conflict_data[FIRST].validity;
    }

Here is the call graph for this function:

GetConflictData()

ConflictData & duckdb::ConflictManager::GetConflictData ( const idx_t  i )

inlineprivate

Returns a reference to the conflict data (FIRST or SECOND), and initializes it, if uninitialized.

                                                 {
        if (conflict_data[i].sel) {
            return conflict_data[i];
        }
        conflict_data[i].sel = make_uniq<SelectionVector>(chunk_size);
        conflict_data[i].inverted_sel = make_uniq<SelectionVector>(chunk_size);
        conflict_data[i].validity.Initialize(chunk_size, false);
        conflict_data[i].row_ids = make_uniq<Vector>(LogicalType::ROW_TYPE, chunk_size);
        conflict_data[i].row_ids_data = FlatVector::GetData<row_t>(*conflict_data[i].row_ids);
        return conflict_data[i];
    }

Here is the caller graph for this function:

AddRowId()

void duckdb::ConflictManager::AddRowId ( const idx_t  index_in_chunk, const row_t  row_id  )

inlineprivate

Adds a row ID to the primary conflict data.

                                                                  {
        // Only ON CONFLICT DO NOTHING can have multiple conflict targets,
        // which can cause multiple row IDs per index_in_chunk.
        // We let them overwrite each other, as we don't need the row IDs later.
        auto elem = conflict_rows.find(index_in_chunk);
        if (elem == conflict_rows.end()) {
            // We have not yet seen this conflict: insert.
            conflict_rows.insert(index_in_chunk);
            GetConflictData(FIRST).Insert(index_in_chunk, row_id);
        }
    }

Here is the call graph for this function:

AddSecondRowId()

void duckdb::ConflictManager::AddSecondRowId ( const idx_t  index_in_chunk, const row_t  row_id  )

inlineprivate

Adds a row ID to the secondary conflict data.

                                                                        {
        D_ASSERT(conflict_rows.find(index_in_chunk) != conflict_rows.end());
        GetConflictData(SECOND).Insert(index_in_chunk, row_id);
    }

Here is the call graph for this function:

Member Data Documentation

conflict_data

array<ConflictData, 2> duckdb::ConflictManager::conflict_data

private

With the introduction of delete indexes, it is now possible to have up to two row IDs in a UNIQUE/PRIMARY KEY leaf. Only one of the row IDs is visible to the transaction in which we're using the conflict manager. Thus, we need to register both row IDs when scanning, and later Finalize the conflict data to only contain the visible row ID.

---

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

• external/duckdb/duckdb.cpp