duckdb::FilenamePattern Class Reference

Collaboration diagram for duckdb::FilenamePattern:

Public Member Functions
	FilenamePattern (string base, idx_t pos, bool uuid, vector< FileNameSegment > segments)
void	SetFilenamePattern (const string &pattern)
string	CreateFilename (FileSystem &fs, const string &path, const string &extension, idx_t offset) const
void	Serialize (Serializer &serializer) const
bool	HasUUID () const
string	SerializeBase () const
idx_t	SerializePos () const
vector< FileNameSegment >	SerializeSegments () const

Static Public Member Functions
static FilenamePattern	Deserialize (Deserializer &deserializer)

Private Attributes
vector< FileNameSegment >	segments

Constructor & Destructor Documentation

FilenamePattern() [1/2]

duckdb::FilenamePattern::FilenamePattern

(

)

                                 {
    segments.emplace_back("data_");
    segments.emplace_back(FileNameSegmentType::OFFSET);
}

FilenamePattern() [2/2]

duckdb::FilenamePattern::FilenamePattern	(	string	base,
		idx_t	pos,
		bool	uuid,
		vector< FileNameSegment >	segments
	)

                                                                                                      {
    if (!segments_p.empty()) {
        segments = std::move(segments_p);
        return;
    }
    // deserialize from legacy pattern
    if (pos > 0) {
        segments.emplace_back(base.substr(0, pos));
    }
    if (uuid) {
        segments.emplace_back(FileNameSegmentType::UUID_V4);
    } else {
        segments.emplace_back(FileNameSegmentType::OFFSET);
    }
    if (pos == 0 && !base.empty()) {
        segments.emplace_back(std::move(base));
    } else if (pos < base.size()) {
        segments.emplace_back(base.substr(pos, base.size() - pos));
    }
}

Member Function Documentation

SetFilenamePattern()

void duckdb::FilenamePattern::SetFilenamePattern

(

const string &

pattern

)

                                                              {
    struct StringPattern {
        StringPattern(string pattern_p, FileNameSegmentType type) : pattern(std::move(pattern_p)), type(type) {
        }
 
        string pattern;
        FileNameSegmentType type;
    };
    vector<StringPattern> patterns;
    patterns.emplace_back("{i}", FileNameSegmentType::OFFSET);
    patterns.emplace_back("{uuid}", FileNameSegmentType::UUID_V4);
    patterns.emplace_back("{uuidv4}", FileNameSegmentType::UUID_V4);
    patterns.emplace_back("{uuidv7}", FileNameSegmentType::UUID_V7);
 
    idx_t current_pos = 0;
    segments.clear();
    for (idx_t i = 0; i < pattern.size(); i++) {
        if (pattern[i] != '{') {
            continue;
        }
        // found a { - check if this is one of the supported pattern
        idx_t remaining_length = pattern.size() - i;
        for (auto &pat : patterns) {
            if (remaining_length < pat.pattern.size()) {
                // cannot match
                continue;
            }
            if (memcmp(pat.pattern.c_str(), pattern.c_str() + i, pat.pattern.size()) != 0) {
                // no match
                continue;
            }
            // found a match!
            if (i > current_pos) {
                // add a literal pattern
                segments.emplace_back(pattern.substr(current_pos, i - current_pos));
            }
            // add the pattern here
            segments.emplace_back(pat.type);
 
            // advance the search forward
            i += pat.pattern.size() - 1;
            current_pos = i + 1;
            break;
        }
    }
    // add the final pattern (if any)
    if (current_pos < pattern.size()) {
        segments.emplace_back(pattern.substr(current_pos));
    }
    if (segments.size() == 1 && segments[0].type == FileNameSegmentType::LITERAL) {
        // if we have ONLY a literal we add an offset at the end
        segments.emplace_back(FileNameSegmentType::OFFSET);
    }
}

CreateFilename()

string duckdb::FilenamePattern::CreateFilename	(	FileSystem &	fs,
		const string &	path,
		const string &	extension,
		idx_t	offset
	)		const

                                                           {
    string result;
    for (auto &segment : segments) {
        switch (segment.type) {
        case FileNameSegmentType::LITERAL:
            result += segment.data;
            break;
        case FileNameSegmentType::UUID_V4:
            result += UUID::ToString(UUID::GenerateRandomUUID());
            break;
        case FileNameSegmentType::UUID_V7:
            result += UUID::ToString(UUIDv7::GenerateRandomUUID());
            break;
        case FileNameSegmentType::OFFSET:
            result += std::to_string(offset);
            break;
        default:
            throw InternalException("Unsupported type for Filename Pattern");
        }
    }
    return fs.JoinPath(path, result + "." + extension);
}

HasUUID()

bool duckdb::FilenamePattern::HasUUID

(

)

const

                                    {
    for (auto &segment : segments) {
        if (segment.type == FileNameSegmentType::UUID_V4 || segment.type == FileNameSegmentType::UUID_V7) {
            return true;
        }
    }
    return false;
}

SerializeBase()

string duckdb::FilenamePattern::SerializeBase

(

)

const

                                            {
    if (!SupportsLegacyFilenamePattern(segments)) {
        return string();
    }
    return GetLegacyFilenamePattern(segments).base;
}

SerializePos()

idx_t duckdb::FilenamePattern::SerializePos

(

)

const

                                          {
    if (!SupportsLegacyFilenamePattern(segments)) {
        return 0;
    }
    return GetLegacyFilenamePattern(segments).pos;
}

SerializeSegments()

vector< FileNameSegment > duckdb::FilenamePattern::SerializeSegments

(

)

const

                                                                 {
    if (SupportsLegacyFilenamePattern(segments)) {
        // for legacy mode we don't serialize the segments
        return vector<FileNameSegment>();
    }
    return segments;
}

---

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

• external/duckdb/duckdb.cpp