duckdb::BaseAppender Class Reference

The Appender class can be used to append elements to a table. More...

#include <duckdb.hpp>

Inheritance diagram for duckdb::BaseAppender:

Collaboration diagram for duckdb::BaseAppender:

Public Member Functions
DUCKDB_API void	BeginRow ()
DUCKDB_API void	EndRow ()
	Finishes appending the current row.
template<class T >
void	Append (T value)=delete
DUCKDB_API void	Append (DataChunk &target, const Value &value, idx_t col, idx_t row)
DUCKDB_API void	Append (const char *value, uint32_t length)
template<typename... ARGS>
void	AppendRow (ARGS... args)
DUCKDB_API void	Flush ()
	Commit the changes made by the appender.
DUCKDB_API void	Close ()
	Flush the changes made by the appender and close it. The appender cannot be used after this point.
DUCKDB_API void	Clear ()
	Clears any appended data (without flushing).
const vector< LogicalType > &	GetActiveTypes () const
	Returns the active types of the appender.
idx_t	CurrentColumn () const
DUCKDB_API void	AppendDataChunk (DataChunk &value)
virtual void	AppendDefault ()
virtual void	AppendDefault (DataChunk &chunk, idx_t col, idx_t row)
virtual void	AddColumn (const string &name)
virtual void	ClearColumns ()
template<>
DUCKDB_API void	Append (bool value)
template<>
DUCKDB_API void	Append (int8_t value)
template<>
DUCKDB_API void	Append (int16_t value)
template<>
DUCKDB_API void	Append (int32_t value)
template<>
DUCKDB_API void	Append (int64_t value)
template<>
DUCKDB_API void	Append (hugeint_t value)
template<>
DUCKDB_API void	Append (uhugeint_t value)
template<>
DUCKDB_API void	Append (uint8_t value)
template<>
DUCKDB_API void	Append (uint16_t value)
template<>
DUCKDB_API void	Append (uint32_t value)
template<>
DUCKDB_API void	Append (uint64_t value)
template<>
DUCKDB_API void	Append (float value)
template<>
DUCKDB_API void	Append (double value)
template<>
DUCKDB_API void	Append (date_t value)
template<>
DUCKDB_API void	Append (dtime_t value)
template<>
DUCKDB_API void	Append (timestamp_t value)
template<>
DUCKDB_API void	Append (interval_t value)
template<>
DUCKDB_API void	Append (const char *value)
template<>
DUCKDB_API void	Append (string_t value)
template<>
DUCKDB_API void	Append (Value value)
template<>
DUCKDB_API void	Append (std::nullptr_t value)

Static Public Member Functions
static unique_ptr< TableRef >	GetColumnDataTableRef (ColumnDataCollection &collection, const string &table_name, const vector< string > &expected_names)
	Returns a table reference to the appended data.
static unique_ptr< SQLStatement >	ParseStatement (unique_ptr< TableRef > table_ref, const string &query, const string &table_name)
	Parses the statement to append data.

Static Public Attributes
static constexpr const idx_t	DEFAULT_FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100ULL
	The amount of tuples that are gathered in the column data collection before flushing.

Protected Member Functions
DUCKDB_API	BaseAppender (Allocator &allocator, const AppenderType type)
DUCKDB_API	BaseAppender (Allocator &allocator, vector< LogicalType > types, const AppenderType type, const idx_t flush_count=DEFAULT_FLUSH_COUNT)
void	Destructor ()
virtual void	FlushInternal (ColumnDataCollection &collection)=0
void	InitializeChunk ()
void	FlushChunk ()
bool	ShouldFlushChunk () const
bool	ShouldFlush () const
template<class T >
void	AppendValueInternal (T value)
template<class SRC , class DST >
void	AppendValueInternal (Vector &vector, SRC input)
template<class SRC , class DST >
void	AppendDecimalValueInternal (Vector &vector, SRC input)
void	AppendRowRecursive ()
template<typename T , typename... ARGS>
void	AppendRowRecursive (T value, ARGS... args)
void	AppendValue (const Value &value)
void	AppendValue (DataChunk target, const Value &value)

Protected Attributes
Allocator &	allocator
	The allocator for the column data collection.
vector< LogicalType >	types
	The column types of the associated table.
vector< LogicalType >	active_types
	The active column types.
unique_ptr< ColumnDataCollection >	collection
	The buffered to-be-appended data.
DataChunk	chunk
	The active chunk for row-based appends.
idx_t	column = 0
	The currently active column of row-based appends.
AppenderType	appender_type
	The type of the appender.
idx_t	flush_count = DEFAULT_FLUSH_COUNT
	The amount of rows after which the appender flushes automatically.
optional_idx	flush_memory_threshold
	Peak allocation threshold at which to flush the allocator when appender flushs chunk.

Detailed Description

The Appender class can be used to append elements to a table.

Member Function Documentation

BeginRow()

DUCKDB_API void duckdb::BaseAppender::BeginRow

(

)

Begins a new row append, after calling this the other AppendX() functions should be called the correct amount of times. After that, EndRow() should be called.

AppendRow()

template<typename... ARGS>

void duckdb::BaseAppender::AppendRow ( ARGS...  args )

inline

                                 {
        BeginRow();
        AppendRowRecursive(args...);
    }

CurrentColumn()

idx_t duckdb::BaseAppender::CurrentColumn ( ) const

inline

                                {
        return column;
    }

AddColumn()

virtual void duckdb::BaseAppender::AddColumn ( const string &  name )

virtual

Appends a column to the active column list. Immediately flushes all previous data.

Reimplemented in duckdb::Appender.

ClearColumns()

virtual void duckdb::BaseAppender::ClearColumns ( )

virtual

Removes all columns from the active column list. Immediately flushes all previous data.

Reimplemented in duckdb::Appender.

AppendRowRecursive() [1/2]

void duckdb::BaseAppender::AppendRowRecursive ( )

inlineprotected

                              {
        EndRow();
    }

AppendRowRecursive() [2/2]

template<typename T , typename... ARGS>

void duckdb::BaseAppender::AppendRowRecursive ( T  value, ARGS...  args  )

inlineprotected

                                                   {
        Append<T>(value);
        AppendRowRecursive(args...);
    }

---

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

• external/duckdb/duckdb.hpp