duckdb::CSVOption< T > Struct Template Reference

#include <duckdb.hpp>

Collaboration diagram for duckdb::CSVOption< T >:

Public Member Functions
	CSVOption (T value_p)
	CSVOption (T value_p, bool set_by_user_p)
void	Set (T value_p, bool by_user=true)
void	Set (CSVOption value_p, bool by_user=true)
void	ChangeSetByUserTrue ()
bool	operator== (const CSVOption &other) const
bool	operator!= (const CSVOption &other) const
bool	operator== (const T &other) const
bool	operator!= (const T &other) const
const T &	GetValue () const
	Returns CSV Option value.
bool	IsSetByUser () const
string	FormatSet () const
	Returns a formatted string with information regarding how this option was set.
string	FormatValue () const
	Returns a formatted string with the actual value of this option.
DUCKDB_API void	Serialize (Serializer &serializer) const
	Serializes CSV Option.

Static Public Member Functions
static DUCKDB_API CSVOption< T >	Deserialize (Deserializer &deserializer)
	Deserializes CSV Option.

Private Member Functions
template<typename U >
std::string	FormatValueInternal (const U &val) const
std::string	FormatValueInternal (const std::string &val) const
std::string	FormatValueInternal (const idx_t &val) const
std::string	FormatValueInternal (const char &val) const
std::string	FormatValueInternal (const NewLineIdentifier &val) const
std::string	FormatValueInternal (const StrpTimeFormat &val) const
std::string	FormatValueInternal (const bool &val) const

Private Attributes
bool	set_by_user = false
	If this option was manually set by the user.
T	value

Detailed Description

template<typename T>
struct duckdb::CSVOption< T >

Wrapper for CSV Options that can be manually set by the user It is important to make this difference for options that can be automatically sniffed AND manually set.

Constructor & Destructor Documentation

CSVOption() [1/3]

template<typename T >

duckdb::CSVOption< T >::CSVOption ( T  value_p )

inline

                         : value(value_p) { // NOLINT: allow implicit conversion from value
    }

CSVOption() [2/3]

template<typename T >

duckdb::CSVOption< T >::CSVOption ( T  value_p, bool  set_by_user_p  )

inline

                                             : set_by_user(set_by_user_p), value(value_p) {
    }

CSVOption() [3/3]

template<typename T >

duckdb::CSVOption< T >::CSVOption ( )

inline

{};

Member Function Documentation

Set() [1/2]

template<typename T >

void duckdb::CSVOption< T >::Set ( T  value_p, bool  by_user = true  )

inline

Sets value. If by user it also toggles the set_by user flag

                                             {
        D_ASSERT(!(by_user && set_by_user));
        if (!set_by_user) {
            // If it's not set by user we can change the value
            value = value_p;
            set_by_user = by_user;
        }
    }

Set() [2/2]

template<typename T >

void duckdb::CSVOption< T >::Set ( CSVOption< T >  value_p, bool  by_user = true  )

inline

Sets value. If by user it also toggles the set_by user flag

                                                     {
        D_ASSERT(!(by_user && set_by_user));
        if (!set_by_user) {
            // If it's not set by user we can change the value
            value = value_p;
            set_by_user = by_user;
        }
    }

ChangeSetByUserTrue()

template<typename T >

void duckdb::CSVOption< T >::ChangeSetByUserTrue ( )

inline

                               {
        set_by_user = true;
    }

operator==() [1/2]

template<typename T >

bool duckdb::CSVOption< T >::operator== ( const CSVOption< T > &  other ) const

inline

                                                  {
        return value == other.value;
    }

operator!=() [1/2]

template<typename T >

bool duckdb::CSVOption< T >::operator!= ( const CSVOption< T > &  other ) const

inline

                                                  {
        return value != other.value;
    }

operator==() [2/2]

template<typename T >

bool duckdb::CSVOption< T >::operator== ( const T &  other ) const

inline

                                          {
        return value == other;
    }

operator!=() [2/2]

template<typename T >

bool duckdb::CSVOption< T >::operator!= ( const T &  other ) const

inline

                                          {
        return value != other;
    }

GetValue()

template<typename T >

const T & duckdb::CSVOption< T >::GetValue ( ) const

inline

Returns CSV Option value.

                                     {
        return value;
    }

IsSetByUser()

template<typename T >

bool duckdb::CSVOption< T >::IsSetByUser ( ) const

inline

                             {
        return set_by_user;
    }

FormatSet()

template<typename T >

string duckdb::CSVOption< T >::FormatSet ( ) const

inline

Returns a formatted string with information regarding how this option was set.

                             {
        if (set_by_user) {
            return "(Set By User)";
        }
        return "(Auto-Detected)";
    }

FormatValue()

template<typename T >

string duckdb::CSVOption< T >::FormatValue ( ) const

inline

Returns a formatted string with the actual value of this option.

                               {
        return FormatValueInternal(value);
    }

Here is the call graph for this function:

FormatValueInternal() [1/7]

template<typename T >

template<typename U >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const U &  val ) const

inlineprivate

------------------------------------------------— // Functions used to convert a value to a string ------------------------------------------------— //

                                                      {
        throw InternalException("Type not accepted as CSV Option.");
    }

Here is the caller graph for this function:

FormatValueInternal() [2/7]

template<typename T >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const std::string &  val ) const

inlineprivate

                                                              {
        return val;
    }

FormatValueInternal() [3/7]

template<typename T >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const idx_t &  val ) const

inlineprivate

                                                          {
        return to_string(val);
    }

FormatValueInternal() [4/7]

template<typename T >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const char &  val ) const

inlineprivate

                                                         {
        string char_val;
        if (val == '\0') {
            char_val = "(empty)";
            return char_val;
        }
        char_val += val;
        return char_val;
    }

FormatValueInternal() [5/7]

template<typename T >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const NewLineIdentifier &  val ) const

inlineprivate

                                                                      {
        switch (val) {
        case NewLineIdentifier::SINGLE_N:
            return "\\n";
        case NewLineIdentifier::SINGLE_R:
            return "\\r";
        case NewLineIdentifier::CARRY_ON:
            return "\\r\\n";
        case NewLineIdentifier::NOT_SET:
            return "Single-Line File";
        default:
            throw InternalException("Invalid Newline Detected.");
        }
    }

FormatValueInternal() [6/7]

template<typename T >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const StrpTimeFormat &  val ) const

inlineprivate

                                                                   {
        return val.format_specifier;
    }

FormatValueInternal() [7/7]

template<typename T >

std::string duckdb::CSVOption< T >::FormatValueInternal ( const bool &  val ) const

inlineprivate

                                                         {
        if (val) {
            return "true";
        }
        return "false";
    }

---

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

• external/duckdb/duckdb.hpp