duckdb::FileHandle Struct Reference

Inheritance diagram for duckdb::FileHandle:

Collaboration diagram for duckdb::FileHandle:

Public Member Functions
DUCKDB_API	FileHandle (FileSystem &file_system, string path, FileOpenFlags flags)
	FileHandle (const FileHandle &)=delete
DUCKDB_API int64_t	Read (void *buffer, idx_t nr_bytes)
DUCKDB_API int64_t	Read (QueryContext context, void *buffer, idx_t nr_bytes)
DUCKDB_API int64_t	Write (void *buffer, idx_t nr_bytes)
DUCKDB_API int64_t	Write (QueryContext context, void *buffer, idx_t nr_bytes)
DUCKDB_API void	Read (void *buffer, idx_t nr_bytes, idx_t location)
DUCKDB_API void	Read (QueryContext context, void *buffer, idx_t nr_bytes, idx_t location)
DUCKDB_API void	Write (QueryContext context, void *buffer, idx_t nr_bytes, idx_t location)
DUCKDB_API void	Seek (idx_t location)
DUCKDB_API void	Reset ()
DUCKDB_API idx_t	SeekPosition ()
DUCKDB_API void	Sync ()
DUCKDB_API void	Truncate (int64_t new_size)
DUCKDB_API string	ReadLine ()
DUCKDB_API string	ReadLine (QueryContext context)
DUCKDB_API bool	Trim (idx_t offset_bytes, idx_t length_bytes)
virtual DUCKDB_API idx_t	GetProgress ()
virtual DUCKDB_API FileCompressionType	GetFileCompressionType ()
DUCKDB_API bool	CanSeek ()
DUCKDB_API bool	IsPipe ()
DUCKDB_API bool	OnDiskFile ()
DUCKDB_API idx_t	GetFileSize ()
DUCKDB_API FileType	GetType ()
DUCKDB_API FileMetadata	Stats ()
DUCKDB_API void	TryAddLogger (FileOpener &opener)
virtual DUCKDB_API void	Close ()=0
	Closes the file handle.
string	GetPath () const
FileOpenFlags	GetFlags () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Public Attributes
FileSystem &	file_system
string	path
FileOpenFlags	flags
shared_ptr< Logger >	logger

Constructor & Destructor Documentation

FileHandle()

duckdb::FileHandle::FileHandle	(	FileSystem &	file_system,
		string	path,
		FileOpenFlags	flags
	)

    : file_system(file_system), path(std::move(path_p)), flags(flags) {
}

~FileHandle()

duckdb::FileHandle::~FileHandle ( )

virtual

                        {
}

Member Function Documentation

Read() [1/4]

int64_t duckdb::FileHandle::Read	(	void *	buffer,
		idx_t	nr_bytes
	)

                                                     {
    return file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
}

Read() [2/4]

int64_t duckdb::FileHandle::Read	(	QueryContext	context,
		void *	buffer,
		idx_t	nr_bytes
	)

                                                                           {
    if (context.GetClientContext() != nullptr) {
        context.GetClientContext()->client_data->profiler->AddToCounter(MetricType::TOTAL_BYTES_READ, nr_bytes);
    }
 
    return file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
}

Write() [1/3]

int64_t duckdb::FileHandle::Write	(	void *	buffer,
		idx_t	nr_bytes
	)

                                                      {
    return file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
}

Write() [2/3]

int64_t duckdb::FileHandle::Write	(	QueryContext	context,
		void *	buffer,
		idx_t	nr_bytes
	)

                                                                            {
    if (context.GetClientContext() != nullptr) {
        context.GetClientContext()->client_data->profiler->AddToCounter(MetricType::TOTAL_BYTES_WRITTEN, nr_bytes);
    }
 
    return file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
}

Read() [3/4]

void duckdb::FileHandle::Read	(	void *	buffer,
		idx_t	nr_bytes,
		idx_t	location
	)

                                                                  {
    file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
}

Read() [4/4]

void duckdb::FileHandle::Read	(	QueryContext	context,
		void *	buffer,
		idx_t	nr_bytes,
		idx_t	location
	)

                                                                                        {
    if (context.GetClientContext() != nullptr) {
        context.GetClientContext()->client_data->profiler->AddToCounter(MetricType::TOTAL_BYTES_READ, nr_bytes);
    }
 
    file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
}

Write() [3/3]

void duckdb::FileHandle::Write	(	QueryContext	context,
		void *	buffer,
		idx_t	nr_bytes,
		idx_t	location
	)

                                                                                         {
    if (context.GetClientContext() != nullptr) {
        context.GetClientContext()->client_data->profiler->AddToCounter(MetricType::TOTAL_BYTES_WRITTEN, nr_bytes);
    }
 
    file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
}

Seek()

void duckdb::FileHandle::Seek

(

idx_t

location

)

                                    {
    file_system.Seek(*this, location);
}

Reset()

void duckdb::FileHandle::Reset

(

)

                       {
    file_system.Reset(*this);
}

SeekPosition()

idx_t duckdb::FileHandle::SeekPosition

(

)

                               {
    return file_system.SeekPosition(*this);
}

Sync()

void duckdb::FileHandle::Sync

(

)

                      {
    file_system.FileSync(*this);
}

Truncate()

void duckdb::FileHandle::Truncate

(

int64_t

new_size

)

                                          {
    file_system.Truncate(*this, new_size);
}

ReadLine() [1/2]

string duckdb::FileHandle::ReadLine

(

)

                            {
    string result;
    char buffer[1];
    while (true) {
        auto tuples_read = UnsafeNumericCast<idx_t>(Read(buffer, 1));
        if (tuples_read == 0 || buffer[0] == '\n') {
            return result;
        }
        if (buffer[0] != '\r') {
            result += buffer[0];
        }
    }
}

ReadLine() [2/2]

string duckdb::FileHandle::ReadLine

(

QueryContext

context

)

                                                {
    string result;
    char buffer[1];
    while (true) {
        auto tuples_read = UnsafeNumericCast<idx_t>(Read(context, buffer, 1));
        if (tuples_read == 0 || buffer[0] == '\n') {
            return result;
        }
        if (buffer[0] != '\r') {
            result += buffer[0];
        }
    }
}

Trim()

bool duckdb::FileHandle::Trim	(	idx_t	offset_bytes,
		idx_t	length_bytes
	)

                                                            {
    return file_system.Trim(*this, offset_bytes, length_bytes);
}

GetProgress()

idx_t duckdb::FileHandle::GetProgress ( )

virtual

                              {
    throw NotImplementedException("GetProgress is not implemented for this file handle");
}

GetFileCompressionType()

FileCompressionType duckdb::FileHandle::GetFileCompressionType ( )

virtual

                                                       {
    return FileCompressionType::UNCOMPRESSED;
}

CanSeek()

bool duckdb::FileHandle::CanSeek

(

)

                         {
    return file_system.CanSeek();
}

IsPipe()

bool duckdb::FileHandle::IsPipe

(

)

                        {
    return file_system.IsPipe(path);
}

OnDiskFile()

bool duckdb::FileHandle::OnDiskFile

(

)

                            {
    return file_system.OnDiskFile(*this);
}

GetFileSize()

idx_t duckdb::FileHandle::GetFileSize

(

)

                              {
    return NumericCast<idx_t>(file_system.GetFileSize(*this));
}

GetType()

FileType duckdb::FileHandle::GetType

(

)

                             {
    return file_system.GetFileType(*this);
}

Stats()

FileMetadata duckdb::FileHandle::Stats

(

)

                               {
    return file_system.Stats(*this);
}

TryAddLogger()

void duckdb::FileHandle::TryAddLogger

(

FileOpener &

opener

)

                                                {
    if (flags.DisableLogging()) {
        return;
    }
 
    auto context = opener.TryGetClientContext();
    if (context && Logger::Get(*context).ShouldLog(FileSystemLogType::NAME, FileSystemLogType::LEVEL)) {
        logger = context->logger;
        return;
    }
 
    auto database = opener.TryGetDatabase();
    if (database && Logger::Get(*database).ShouldLog(FileSystemLogType::NAME, FileSystemLogType::LEVEL)) {
        logger = database->GetLogManager().GlobalLoggerReference();
    }
}

Close()

virtual DUCKDB_API void duckdb::FileHandle::Close ( )

pure virtual

Closes the file handle.

Implemented in duckdb::CompressedFile, and duckdb::UnixFileHandle.

GetPath()

string duckdb::FileHandle::GetPath ( ) const

inline

                           {
        return path;
    }

GetFlags()

FileOpenFlags duckdb::FileHandle::GetFlags ( ) const

inline

                                   {
        return flags;
    }

Cast() [1/2]

template<class TARGET >

TARGET & duckdb::FileHandle::Cast ( )

inline

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

Cast() [2/2]

template<class TARGET >

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

inline

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

---

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

• external/duckdb/duckdb.hpp
• external/duckdb/duckdb.cpp