Botan::Sqlite3_Database Class Reference

#include <sqlite3.h>

Inheritance diagram for Botan::Sqlite3_Database:

Public Member Functions
void	create_table (std::string_view table_schema) override
virtual size_t	exec (std::string_view sql)
bool	is_threadsafe () const override
std::shared_ptr< Statement >	new_statement (std::string_view sql) const override
Sqlite3_Database &	operator= (const Sqlite3_Database &other)=delete
Sqlite3_Database &	operator= (Sqlite3_Database &&other)=delete
size_t	row_count (std::string_view table_name) override
size_t	rows_changed_by_last_statement () override
	Sqlite3_Database (const Sqlite3_Database &other)=delete
	Sqlite3_Database (Sqlite3_Database &&other)=delete
BOTAN_FUTURE_EXPLICIT	Sqlite3_Database (std::string_view file, std::optional< int > sqlite_open_flags=std::nullopt)
	~Sqlite3_Database () override

Detailed Description

Definition at line 21 of file sqlite3.h.

Constructor & Destructor Documentation

Sqlite3_Database() [1/3]

Botan::Sqlite3_Database::Sqlite3_Database	(	std::string_view	file,
		std::optional< int >	sqlite_open_flags = std::nullopt )

Create a new SQLite database handle from a file.

Parameters

file	path to the database file be opened and/or created
sqlite_open_flags	flags that will be passed to sqlite3_open_v2() (default: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX)

Definition at line 18 of file sqlite3.cpp.

                                                                                                 {
   // SQLITE_OPEN_FULLMUTEX ensures that the database object can be used
   // concurrently from multiple threads.
   const int open_flags =
      sqlite_open_flags.value_or(SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX);
   int rc = ::sqlite3_open_v2(std::string(db_filename).c_str(), &m_db, open_flags, nullptr);
 
   if(rc != 0) [[unlikely]] {
      const std::string err_msg = ::sqlite3_errmsg(m_db);
      ::sqlite3_close(m_db);
      m_db = nullptr;
      throw SQL_DB_Error("sqlite3_open failed - " + err_msg);
   }
}

~Sqlite3_Database()

Botan::Sqlite3_Database::~Sqlite3_Database ( )

override

Definition at line 33 of file sqlite3.cpp.

                                    {
   if(m_db != nullptr) [[likely]] {
      ::sqlite3_close(m_db);
   }
   m_db = nullptr;
}

Sqlite3_Database() [2/3]

Botan::Sqlite3_Database::Sqlite3_Database ( const Sqlite3_Database & other )

delete

Sqlite3_Database() [3/3]

Botan::Sqlite3_Database::Sqlite3_Database ( Sqlite3_Database && other )

delete

Member Function Documentation

create_table()

void Botan::Sqlite3_Database::create_table ( std::string_view table_schema )

overridevirtual

Implements Botan::SQL_Database.

Definition at line 54 of file sqlite3.cpp.

                                                               {
   char* errmsg = nullptr;
   int rc = ::sqlite3_exec(m_db, std::string(table_schema).c_str(), nullptr, nullptr, &errmsg);
 
   if(rc != SQLITE_OK) {
      const std::string err_msg = errmsg;
      ::sqlite3_free(errmsg);
      ::sqlite3_close(m_db);
      m_db = nullptr;
      throw SQL_DB_Error("sqlite3_exec for table failed - " + err_msg);
   }
}

exec()

virtual size_t Botan::SQL_Database::exec ( std::string_view sql )

inlinevirtualinherited

Definition at line 77 of file database.h.

{ return new_statement(sql)->spin(); }

is_threadsafe()

bool Botan::Sqlite3_Database::is_threadsafe ( ) const

overridevirtual

Reimplemented from Botan::SQL_Database.

Definition at line 73 of file sqlite3.cpp.

                                           {
   const int flag = sqlite3_threadsafe();
 
   // `flag` can have three values:
   //
   // 0 - single threaded:  no locking is done inside the SQLite code
   // 1 - serialized:       all SQLite database features can be used safely
   //                       from multiple threads
   // 2 - reduced locking:  application must ensure not to use a single
   //                       database connection across threads
   //
   // https://www.sqlite.org/c3ref/threadsafe.html
 
   // When opening the database connection we explicitly request
   // SQLITE_OPEN_FULLMUTEX to ensure restrictive locking in SQLite.
   return flag >= 1;
}

new_statement()

std::shared_ptr< SQL_Database::Statement > Botan::Sqlite3_Database::new_statement ( std::string_view sql ) const

overridevirtual

Implements Botan::SQL_Database.

Definition at line 40 of file sqlite3.cpp.

                                                                                                  {
   return std::make_shared<Sqlite3_Statement>(m_db, base_sql);
}

Referenced by row_count().

operator=() [1/2]

Sqlite3_Database & Botan::Sqlite3_Database::operator= ( const Sqlite3_Database & other )

delete

operator=() [2/2]

Sqlite3_Database & Botan::Sqlite3_Database::operator= ( Sqlite3_Database && other )

delete

row_count()

size_t Botan::Sqlite3_Database::row_count ( std::string_view table_name )

overridevirtual

Implements Botan::SQL_Database.

Definition at line 44 of file sqlite3.cpp.

                                                            {
   auto stmt = new_statement(fmt("select count(*) from {}", table_name));
 
   if(stmt->step()) {
      return stmt->get_size_t(0);
   } else {
      throw SQL_DB_Error(fmt("Querying size of table '{}' failed", table_name));
   }
}

References Botan::fmt(), and new_statement().

rows_changed_by_last_statement()

size_t Botan::Sqlite3_Database::rows_changed_by_last_statement ( )

overridevirtual

Implements Botan::SQL_Database.

Definition at line 67 of file sqlite3.cpp.

                                                        {
   const auto result = ::sqlite3_changes64(m_db);
   BOTAN_ASSERT_NOMSG(result >= 0);
   return static_cast<size_t>(result);
}

References BOTAN_ASSERT_NOMSG.

---

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

• src/lib/utils/sqlite3/sqlite3.h
• src/lib/utils/sqlite3/sqlite3.cpp