duckdb::MultiFileColumnDefinition Struct Reference

Collaboration diagram for duckdb::MultiFileColumnDefinition:

Public Member Functions
	MultiFileColumnDefinition (const string &name, const LogicalType &type)
	MultiFileColumnDefinition (const MultiFileColumnDefinition &other)
MultiFileColumnDefinition &	operator= (const MultiFileColumnDefinition &other)
int32_t	GetIdentifierFieldId () const
string	GetIdentifierName () const
Value	GetDefaultValue () const

Static Public Member Functions
static MultiFileColumnDefinition	CreateFromNameAndType (const string &name, const LogicalType &type)
static vector< MultiFileColumnDefinition >	ColumnsFromNamesAndTypes (const vector< string > &names, const vector< LogicalType > &types)
static void	ExtractNamesAndTypes (const vector< MultiFileColumnDefinition > &columns, vector< string > &names, vector< LogicalType > &types)

Public Attributes
string	name
LogicalType	type
vector< MultiFileColumnDefinition >	children
unique_ptr< ParsedExpression >	default_expression
Value	identifier
	Either the field_id or the name to map on.

Constructor & Destructor Documentation

MultiFileColumnDefinition() [1/2]

duckdb::MultiFileColumnDefinition::MultiFileColumnDefinition ( const string &  name, const LogicalType &  type  )

inline

                                                                           : name(name), type(type) {
    }

MultiFileColumnDefinition() [2/2]

duckdb::MultiFileColumnDefinition::MultiFileColumnDefinition ( const MultiFileColumnDefinition &  other )

inline

        : name(other.name), type(other.type), children(other.children),
          default_expression(other.default_expression ? other.default_expression->Copy() : nullptr),
          identifier(other.identifier) {
    }

Member Function Documentation

operator=()

MultiFileColumnDefinition & duckdb::MultiFileColumnDefinition::operator= ( const MultiFileColumnDefinition &  other )

inline

                                                                                 {
        if (this != &other) {
            name = other.name;
            type = other.type;
            children = other.children;
            default_expression = other.default_expression ? other.default_expression->Copy() : nullptr;
            identifier = other.identifier;
        }
        return *this;
    }

CreateFromNameAndType()

static MultiFileColumnDefinition duckdb::MultiFileColumnDefinition::CreateFromNameAndType ( const string &  name, const LogicalType &  type  )

inlinestatic

                                                                                                        {
        MultiFileColumnDefinition result(name, type);
        if (type.id() == LogicalTypeId::STRUCT) {
            // recursively create for children
            for (auto &child_entry : StructType::GetChildTypes(type)) {
                result.children.push_back(CreateFromNameAndType(child_entry.first, child_entry.second));
            }
        }
        return result;
    }

ColumnsFromNamesAndTypes()

static vector< MultiFileColumnDefinition > duckdb::MultiFileColumnDefinition::ColumnsFromNamesAndTypes ( const vector< string > &  names, const vector< LogicalType > &  types  )

inlinestatic

                                                                                                        {
        vector<MultiFileColumnDefinition> columns;
        D_ASSERT(names.size() == types.size());
        for (idx_t i = 0; i < names.size(); i++) {
            auto &name = names[i];
            auto &type = types[i];
            columns.push_back(CreateFromNameAndType(name, type));
        }
        return columns;
    }

ExtractNamesAndTypes()

static void duckdb::MultiFileColumnDefinition::ExtractNamesAndTypes ( const vector< MultiFileColumnDefinition > &  columns, vector< string > &  names, vector< LogicalType > &  types  )

inlinestatic

                                                                 {
        D_ASSERT(names.empty());
        D_ASSERT(types.empty());
        for (auto &column : columns) {
            names.push_back(column.name);
            types.push_back(column.type);
        }
    }

GetIdentifierFieldId()

int32_t duckdb::MultiFileColumnDefinition::GetIdentifierFieldId ( ) const

inline

                                         {
        D_ASSERT(!identifier.IsNull());
        D_ASSERT(identifier.type().id() == LogicalTypeId::INTEGER);
        return identifier.GetValue<int32_t>();
    }

GetIdentifierName()

string duckdb::MultiFileColumnDefinition::GetIdentifierName ( ) const

inline

                                     {
        if (identifier.IsNull()) {
            // No identifier was provided, assume the name as the identifier
            return name;
        }
        D_ASSERT(identifier.type().id() == LogicalTypeId::VARCHAR);
        return identifier.GetValue<string>();
    }

GetDefaultValue()

Value duckdb::MultiFileColumnDefinition::GetDefaultValue ( ) const

inline

                                  {
        D_ASSERT(default_expression);
        if (default_expression->type != ExpressionType::VALUE_CONSTANT) {
            throw NotImplementedException("Default expression that isn't constant is not supported yet");
        }
        auto &constant_expr = default_expression->Cast<ConstantExpression>();
        return constant_expr.value;
    }

---

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

• external/duckdb/duckdb.cpp