Inheritance diagram for duckdb::Relation:

Collaboration diagram for duckdb::Relation:

[legend]

Public Member Functions
	Relation (const shared_ptr< ClientContext > &context_p, const RelationType type)

	Relation (const shared_ptr< ClientContextWrapper > &context, RelationType type, const string &alias_p="")

	Relation (const shared_ptr< RelationContextWrapper > &context, RelationType type, const string &alias_p="")

virtual DUCKDB_API const vector< ColumnDefinition > &	Columns ()=0

virtual DUCKDB_API unique_ptr< QueryNode >	GetQueryNode ()=0

virtual DUCKDB_API string	GetQuery ()

virtual DUCKDB_API BoundStatement	Bind (Binder &binder)

virtual DUCKDB_API string	GetAlias ()

DUCKDB_API unique_ptr< QueryResult >	ExecuteOrThrow ()

DUCKDB_API unique_ptr< QueryResult >	Execute ()

DUCKDB_API string	ToString ()

virtual DUCKDB_API string	ToString (idx_t depth)=0

DUCKDB_API void	Print ()

DUCKDB_API void	Head (idx_t limit=10)

DUCKDB_API shared_ptr< Relation >	CreateView (const string &name, bool replace=true, bool temporary=false)

DUCKDB_API shared_ptr< Relation >	CreateView (const string &schema_name, const string &name, bool replace=true, bool temporary=false)

DUCKDB_API unique_ptr< QueryResult >	Query (const string &sql) const

DUCKDB_API unique_ptr< QueryResult >	Query (const string &name, const string &sql)

DUCKDB_API unique_ptr< QueryResult >	Explain (ExplainType type=ExplainType::EXPLAIN_STANDARD, ExplainFormat explain_format=ExplainFormat::DEFAULT)
	Explain the query plan of this relation.

virtual DUCKDB_API unique_ptr< TableRef >	GetTableRef ()

virtual bool	IsReadOnly ()

DUCKDB_API void	TryBindRelation (vector< ColumnDefinition > &columns)

DUCKDB_API shared_ptr< Relation >	Project (const string &select_list)

DUCKDB_API shared_ptr< Relation >	Project (const string &expression, const string &alias)

DUCKDB_API shared_ptr< Relation >	Project (const string &select_list, const vector< string > &aliases)

DUCKDB_API shared_ptr< Relation >	Project (const vector< string > &expressions)

DUCKDB_API shared_ptr< Relation >	Project (const vector< string > &expressions, const vector< string > &aliases)

DUCKDB_API shared_ptr< Relation >	Project (vector< unique_ptr< ParsedExpression > > expressions, const vector< string > &aliases)

DUCKDB_API shared_ptr< Relation >	Filter (const string &expression)

DUCKDB_API shared_ptr< Relation >	Filter (unique_ptr< ParsedExpression > expression)

DUCKDB_API shared_ptr< Relation >	Filter (const vector< string > &expressions)

DUCKDB_API shared_ptr< Relation >	Limit (int64_t n, int64_t offset=0)

DUCKDB_API shared_ptr< Relation >	Order (const string &expression)

DUCKDB_API shared_ptr< Relation >	Order (const vector< string > &expressions)

DUCKDB_API shared_ptr< Relation >	Order (vector< OrderByNode > expressions)

DUCKDB_API shared_ptr< Relation >	Join (const shared_ptr< Relation > &other, const string &condition, JoinType type=JoinType::INNER, JoinRefType ref_type=JoinRefType::REGULAR)

shared_ptr< Relation >	Join (const shared_ptr< Relation > &other, vector< unique_ptr< ParsedExpression > > condition, JoinType type=JoinType::INNER, JoinRefType ref_type=JoinRefType::REGULAR)

DUCKDB_API shared_ptr< Relation >	CrossProduct (const shared_ptr< Relation > &other, JoinRefType join_ref_type=JoinRefType::CROSS)

DUCKDB_API shared_ptr< Relation >	Union (const shared_ptr< Relation > &other)

DUCKDB_API shared_ptr< Relation >	Except (const shared_ptr< Relation > &other)

DUCKDB_API shared_ptr< Relation >	Intersect (const shared_ptr< Relation > &other)

DUCKDB_API shared_ptr< Relation >	Distinct ()

DUCKDB_API shared_ptr< Relation >	Aggregate (const string &aggregate_list)

DUCKDB_API shared_ptr< Relation >	Aggregate (const vector< string > &aggregates)

DUCKDB_API shared_ptr< Relation >	Aggregate (vector< unique_ptr< ParsedExpression > > expressions)

DUCKDB_API shared_ptr< Relation >	Aggregate (const string &aggregate_list, const string &group_list)

DUCKDB_API shared_ptr< Relation >	Aggregate (const vector< string > &aggregates, const vector< string > &groups)

DUCKDB_API shared_ptr< Relation >	Aggregate (vector< unique_ptr< ParsedExpression > > expressions, const string &group_list)

DUCKDB_API shared_ptr< Relation >	Alias (const string &alias)

DUCKDB_API shared_ptr< Relation >	InsertRel (const string &schema_name, const string &table_name)
	Insert the data from this relation into a table.

DUCKDB_API shared_ptr< Relation >	InsertRel (const string &catalog_name, const string &schema_name, const string &table_name)

DUCKDB_API void	Insert (const string &table_name)

DUCKDB_API void	Insert (const string &schema_name, const string &table_name)

DUCKDB_API void	Insert (const string &catalog_name, const string &schema_name, const string &table_name)

virtual DUCKDB_API void	Insert (const vector< vector< Value > > &values)
	Insert a row (i.e.,list of values) into a table.

virtual DUCKDB_API void	Insert (vector< vector< unique_ptr< ParsedExpression > > > &&expressions)

DUCKDB_API shared_ptr< Relation >	CreateRel (const string &schema_name, const string &table_name, bool temporary=false, OnCreateConflict on_conflict=OnCreateConflict::ERROR_ON_CONFLICT)
	Create a table and insert the data from this relation into that table.

DUCKDB_API shared_ptr< Relation >	CreateRel (const string &catalog_name, const string &schema_name, const string &table_name, bool temporary=false, OnCreateConflict on_conflict=OnCreateConflict::ERROR_ON_CONFLICT)

DUCKDB_API void	Create (const string &table_name, bool temporary=false, OnCreateConflict on_conflict=OnCreateConflict::ERROR_ON_CONFLICT)

DUCKDB_API void	Create (const string &schema_name, const string &table_name, bool temporary=false, OnCreateConflict on_conflict=OnCreateConflict::ERROR_ON_CONFLICT)

DUCKDB_API void	Create (const string &catalog_name, const string &schema_name, const string &table_name, bool temporary=false, OnCreateConflict on_conflict=OnCreateConflict::ERROR_ON_CONFLICT)

DUCKDB_API shared_ptr< Relation >	WriteCSVRel (const string &csv_file, case_insensitive_map_t< vector< Value > > options=case_insensitive_map_t< vector< Value > >())
	Write a relation to a CSV file.

DUCKDB_API void	WriteCSV (const string &csv_file, case_insensitive_map_t< vector< Value > > options=case_insensitive_map_t< vector< Value > >())

DUCKDB_API shared_ptr< Relation >	WriteParquetRel (const string &parquet_file, case_insensitive_map_t< vector< Value > > options=case_insensitive_map_t< vector< Value > >())
	Write a relation to a Parquet file.

DUCKDB_API void	WriteParquet (const string &parquet_file, case_insensitive_map_t< vector< Value > > options=case_insensitive_map_t< vector< Value > >())

virtual DUCKDB_API void	Update (const string &update, const string &condition=string())
	Update a table, can only be used on a TableRelation.

virtual DUCKDB_API void	Update (vector< string > column_names, vector< unique_ptr< ParsedExpression > > &&update, unique_ptr< ParsedExpression > condition=nullptr)

virtual DUCKDB_API void	Delete (const string &condition=string())
	Delete from a table, can only be used on a TableRelation.

DUCKDB_API shared_ptr< Relation >	TableFunction (const std::string &fname, const vector< Value > &values)

DUCKDB_API shared_ptr< Relation >	TableFunction (const std::string &fname, const vector< Value > &values, const named_parameter_map_t &named_parameters)

virtual bool	InheritsColumnBindings ()
	Whether or not the relation inherits column bindings from its child or not, only relevant for binding.

virtual Relation *	ChildRelation ()

void	AddExternalDependency (shared_ptr< ExternalDependency > dependency)

DUCKDB_API vector< shared_ptr< ExternalDependency > >	GetAllDependencies ()

template<class TARGET >
TARGET &	Cast ()

template<class TARGET >
const TARGET &	Cast () const

Public Member Functions inherited from duckdb::enable_shared_from_this< Relation >
shared_ptr< Relation >	shared_from_this ()

shared_ptr< Relation const >	shared_from_this () const

Public Attributes
shared_ptr< ClientContextWrapper >	context

RelationType	type

const string	alias

vector< shared_ptr< ExternalDependency > >	external_dependencies

Static Protected Member Functions
static DUCKDB_API string	RenderWhitespace (idx_t depth)

Additional Inherited Members
Protected Member Functions inherited from duckdb::enable_shared_from_this< Relation >
	enable_shared_from_this (enable_shared_from_this const &) noexcept

enable_shared_from_this &	operator= (enable_shared_from_this const &) noexcept

Constructor & Destructor Documentation

◆ Relation() [1/3]

duckdb::Relation::Relation	(	const shared_ptr< ClientContext > &	context_p,
		const RelationType	type
	)

inline

                                                                                  : type(type) {
        context = make_shared_ptr<ClientContextWrapper>(context_p);
    }

◆ Relation() [2/3]

duckdb::Relation::Relation	(	const shared_ptr< ClientContextWrapper > &	context,
		RelationType	type,
		const string &	alias_p = `""`
	)

inline

42087 : context(context), type(type), alias(CreateRelationAlias(type, alias_p)) {

42088 }

◆ Relation() [3/3]

duckdb::Relation::Relation	(	const shared_ptr< RelationContextWrapper > &	context,
		RelationType	type,
		const string &	alias_p = `""`
	)

inline

42091 : context(context), type(type), alias(CreateRelationAlias(type, alias_p)) {

42092 }

Member Function Documentation

◆ IsReadOnly()

virtual bool duckdb::Relation::IsReadOnly ( )

inlinevirtual

                              {
        return true;
    }

◆ TableFunction()

DUCKDB_API shared_ptr< Relation > duckdb::Relation::TableFunction	(	const std::string &	fname,
		const vector< Value > &	values
	)

Create a relation from calling a table in/out function on the input relation Create a relation from calling a table in/out function on the input relation

◆ InheritsColumnBindings()

virtual bool duckdb::Relation::InheritsColumnBindings ( )

inlinevirtual

Whether or not the relation inherits column bindings from its child or not, only relevant for binding.

                                          {
        return false;
    }

◆ ChildRelation()

virtual Relation * duckdb::Relation::ChildRelation ( )

inlinevirtual

                                      {
        return nullptr;
    }

◆ Cast() [1/2]

template<class TARGET >

TARGET & duckdb::Relation::Cast ( )

inline

                   {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<TARGET &>(*this);
    }

◆ Cast() [2/2]

template<class TARGET >

const TARGET & duckdb::Relation::Cast ( ) const

inline

                               {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<const TARGET &>(*this);
    }

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

external/duckdb/duckdb.hpp

Public Member Functions

Public Attributes

Static Protected Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

◆ Relation() [1/3]

◆ Relation() [2/3]

◆ Relation() [3/3]

Member Function Documentation

◆ IsReadOnly()

◆ TableFunction()

◆ InheritsColumnBindings()

◆ ChildRelation()

◆ Cast() [1/2]

◆ Cast() [2/2]