Represents a read/write query to an archive database. Statements are expensive to create and must be cached for as long as possible. More...

#include <archive_statement.h>

Classes
struct	Handle

Public Types
enum	Result { Result::kDone, Result::kRow, Result::kFailure }

Public Member Functions
	~ArchiveStatement ()

bool	IsValid () const

Result	Execute ()
	Execute the given statement with the provided data. More...

bool	Reset ()
	All writes after the last successfull `Run` call are reset. Since statements are expensive to create, reset them for new writes instead of creating new statements. More...

bool	WriteValue (size_t index, const std::string &item)

template<class T , class = std::enable_if<std::is_integral<T>::value>>
bool	WriteValue (size_t index, T item)

bool	WriteValue (size_t index, double item)

bool	WriteValue (size_t index, const Allocation &item)

template<class T , class = std::enable_if<std::is_integral<T>::value>>
bool	ReadValue (size_t index, T &item)

bool	ReadValue (size_t index, double &item)

bool	ReadValue (size_t index, std::string &item)

bool	ReadValue (size_t index, Allocation &item)

size_t	GetColumnCount ()

Friends
class	ArchiveDatabase

Detailed Description

Represents a read/write query to an archive database. Statements are expensive to create and must be cached for as long as possible.

Definition at line 20 of file archive_statement.h.

Member Enumeration Documentation

◆ Result

enum impeller::ArchiveStatement::Result

strong

Enumerator
kDone	The statement is done executing.
kRow	The statement found a row of information ready for reading.
kFailure	Statement execution was a failure.

Definition at line 26 of file archive_statement.h.

                     {
     //--------------------------------------------------------------------------
     /// The statement is done executing.
     ///
     kDone,
     //--------------------------------------------------------------------------
     /// The statement found a row of information ready for reading.
     ///
     kRow,
     //--------------------------------------------------------------------------
     /// Statement execution was a failure.
     ///
     kFailure,
   };

Constructor & Destructor Documentation

◆ ~ArchiveStatement()

impeller::ArchiveStatement::~ArchiveStatement ( )

default

Member Function Documentation

◆ Execute()

ArchiveStatement::Result impeller::ArchiveStatement::Execute ( )

Execute the given statement with the provided data.

Returns: Is the execution was succeessful.

Definition at line 215 of file archive_statement.cc.

                                                  {
   if (!IsValid()) {
     return Result::kFailure;
   }
   switch (::sqlite3_step(statement_handle_->Get())) {
     case SQLITE_DONE:
       return Result::kDone;
     case SQLITE_ROW:
       return Result::kRow;
     default:
       return Result::kFailure;
   }
 }

References IsValid(), kDone, kFailure, and kRow.

Referenced by impeller::ArchiveTransaction::~ArchiveTransaction().

◆ GetColumnCount()

size_t impeller::ArchiveStatement::GetColumnCount ( )

Definition at line 89 of file archive_statement.cc.

                                         {
   if (!IsValid()) {
     return 0u;
   }
   return ::sqlite3_column_count(statement_handle_->Get());
 }

References IsValid().

◆ IsValid()

bool impeller::ArchiveStatement::IsValid ( ) const

Definition at line 56 of file archive_statement.cc.

                                      {
   return statement_handle_ != nullptr;
 }

Referenced by Execute(), GetColumnCount(), ReadValue(), Reset(), and WriteValue().

◆ ReadValue() [1/4]

bool impeller::ArchiveStatement::ReadValue	(	size_t	index,
		Allocation &	item
	)

Definition at line 188 of file archive_statement.cc.

                                                                {
   if (!IsValid()) {
     return false;
   }
   /*
    *  Get a blob pointer
    */
   auto blob = reinterpret_cast<const uint8_t*>(
       ::sqlite3_column_blob(statement_handle_->Get(), ToColumn(index)));
  
   /*
    *  Decode the number of bytes in the blob
    */
   size_t byteSize =
       ::sqlite3_column_bytes(statement_handle_->Get(), ToColumn(index));
  
   /*
    *  Reszie the host allocation and move the blob contents into it
    */
   if (!item.Truncate(byteSize, false /* npot */)) {
     return false;
   }
  
   memmove(item.GetBuffer(), blob, byteSize);
   return true;
 }

References impeller::Allocation::GetBuffer(), IsValid(), impeller::ToColumn(), and impeller::Allocation::Truncate().

◆ ReadValue() [2/4]

bool impeller::ArchiveStatement::ReadValue	(	size_t	index,
		double &	item
	)

Definition at line 150 of file archive_statement.cc.

                                                            {
   if (!IsValid()) {
     return false;
   }
   item = ::sqlite3_column_double(statement_handle_->Get(), ToColumn(index));
   return true;
 }

References IsValid(), and impeller::ToColumn().

◆ ReadValue() [3/4]

bool impeller::ArchiveStatement::ReadValue	(	size_t	index,
		std::string &	item
	)

Definition at line 166 of file archive_statement.cc.

                                                               {
   if (!IsValid()) {
     return false;
   }
   /*
    *  Get the character data
    */
   auto chars = reinterpret_cast<const char*>(
       ::sqlite3_column_text(statement_handle_->Get(), ToColumn(index)));
  
   /*
    *  Get the length of the string (in bytes)
    */
   size_t textByteSize =
       ::sqlite3_column_bytes(statement_handle_->Get(), ToColumn(index));
  
   std::string text(chars, textByteSize);
   item.swap(text);
  
   return true;
 }

References IsValid(), and impeller::ToColumn().

◆ ReadValue() [4/4]

template<class T , class = std::enable_if<std::is_integral<T>::value>>

bool impeller::ArchiveStatement::ReadValue	(	size_t	index,
		T &	item
	)

inline

Definition at line 69 of file archive_statement.h.

                                         {
     return ColumnIntegral(index, item);
   }

Referenced by impeller::ArchiveLocation::Read().

◆ Reset()

bool impeller::ArchiveStatement::Reset ( )

All writes after the last successfull Run call are reset. Since statements are expensive to create, reset them for new writes instead of creating new statements.

Returns: If the statement writes were reset.

Definition at line 60 of file archive_statement.cc.

                              {
   if (!IsValid()) {
     return false;
   }
   if (::sqlite3_reset(statement_handle_->Get()) != SQLITE_OK) {
     return false;
   }
  
   if (::sqlite3_clear_bindings(statement_handle_->Get()) != SQLITE_OK) {
     return false;
   }
  
   return true;
 }

References IsValid().

◆ WriteValue() [1/4]

bool impeller::ArchiveStatement::WriteValue	(	size_t	index,
		const Allocation &	item
	)

Definition at line 128 of file archive_statement.cc.

                                                                       {
   if (!IsValid()) {
     return false;
   }
   return ::sqlite3_bind_blob(statement_handle_->Get(),            //
                              ToParam(index),                      //
                              item.GetBuffer(),                    //
                              static_cast<int>(item.GetLength()),  //
                              SQLITE_TRANSIENT) == SQLITE_OK;
 }

References impeller::Allocation::GetBuffer(), impeller::Allocation::GetLength(), IsValid(), and impeller::ToParam().

◆ WriteValue() [2/4]

bool impeller::ArchiveStatement::WriteValue	(	size_t	index,
		const std::string &	item
	)

Definition at line 99 of file archive_statement.cc.

                                                                      {
   if (!IsValid()) {
     return false;
   }
   return ::sqlite3_bind_text(statement_handle_->Get(),       //
                              ToParam(index),                 //
                              item.data(),                    //
                              static_cast<int>(item.size()),  //
                              SQLITE_TRANSIENT) == SQLITE_OK;
 }

References IsValid(), and impeller::ToParam().

Referenced by impeller::ArchiveLocation::Write().

◆ WriteValue() [3/4]

bool impeller::ArchiveStatement::WriteValue	(	size_t	index,
		double	item
	)

Definition at line 119 of file archive_statement.cc.

                                                            {
   if (!IsValid()) {
     return false;
   }
   return ::sqlite3_bind_double(statement_handle_->Get(),  //
                                ToParam(index),            //
                                item) == SQLITE_OK;
 }

References IsValid(), and impeller::ToParam().

◆ WriteValue() [4/4]

template<class T , class = std::enable_if<std::is_integral<T>::value>>

bool impeller::ArchiveStatement::WriteValue	(	size_t	index,
		T	item
	)

inline

Definition at line 60 of file archive_statement.h.

                                         {
     return BindIntegral(index, static_cast<int64_t>(item));
   }

Friends And Related Function Documentation

◆ ArchiveDatabase

friend class ArchiveDatabase

friend

Definition at line 85 of file archive_statement.h.

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

impeller/archivist/archive_statement.h
impeller/archivist/archive_statement.cc

Classes

Public Types

Public Member Functions

Friends