DBConnection Class Reference

#include <DBConnection.h>

Collaboration diagram for DBConnection:

Public Types
enum	StatementID {   GetSamples , GetSummary256 , GetSummary64k , LoadSampleBlock ,   InsertSampleBlock , DeleteSampleBlock , GetSampleBlockSize , GetAllSampleBlocksSize }
using	CheckpointFailureCallback = std::function< void()>

Public Member Functions
	DBConnection (const std::weak_ptr< AudacityProject > &pProject, const std::shared_ptr< DBConnectionErrors > &pErrors, CheckpointFailureCallback callback)
	~DBConnection ()
int	Open (const FilePath fileName)
bool	Close ()
void	ThrowException (bool write) const
	throw and show appropriate message box More...
int	SafeMode (const char *schema="main")
int	FastMode (const char *schema="main")
int	SetPageSize (const char *schema="main")
bool	Assign (sqlite3 *handle)
sqlite3 *	Detach ()
sqlite3 *	DB ()
int	GetLastRC () const
const wxString	GetLastMessage () const
sqlite3_stmt *	Prepare (enum StatementID id, const char *sql)
void	SetBypass (bool bypass)
bool	ShouldBypass ()
void	SetError (const TranslatableString &msg, const TranslatableString &libraryError={}, int errorCode={})
	Just set stored errors. More...
void	SetDBError (const TranslatableString &msg, const TranslatableString &libraryError={}, int errorCode=-1)
	Set stored errors and write to log; and default libraryError to what database library reports. More...

Private Types
using	StatementIndex = std::pair< enum StatementID, std::thread::id >

Private Member Functions
int	OpenStepByStep (const FilePath fileName)
int	ModeConfig (sqlite3 *db, const char *schema, const char *config)
void	CheckpointThread (sqlite3 *db, const FilePath &fileName)

Static Private Member Functions
static int	CheckpointHook (void *data, sqlite3 *db, const char *schema, int pages)

Private Attributes
std::weak_ptr< AudacityProject >	mpProject
sqlite3 *	mDB
sqlite3 *	mCheckpointDB
std::thread	mCheckpointThread
std::condition_variable	mCheckpointCondition
std::mutex	mCheckpointMutex
std::atomic_bool	mCheckpointStop { false }
std::atomic_bool	mCheckpointPending { false }
std::atomic_bool	mCheckpointActive { false }
std::mutex	mStatementMutex
std::map< StatementIndex, sqlite3_stmt * >	mStatements
std::shared_ptr< DBConnectionErrors >	mpErrors
CheckpointFailureCallback	mCallback
bool	mBypass

Detailed Description

Definition at line 39 of file DBConnection.h.

Member Typedef Documentation

CheckpointFailureCallback

using DBConnection::CheckpointFailureCallback = std::function<void()>

Definition at line 42 of file DBConnection.h.

StatementIndex

using DBConnection::StatementIndex = std::pair<enum StatementID, std::thread::id>

private

Definition at line 122 of file DBConnection.h.

Member Enumeration Documentation

StatementID

enum DBConnection::StatementID

Enumerator
GetSamples
GetSummary256
GetSummary64k
LoadSampleBlock
InsertSampleBlock
DeleteSampleBlock
GetSampleBlockSize
GetAllSampleBlocksSize

Definition at line 74 of file DBConnection.h.

   {
      GetSamples,
      GetSummary256,
      GetSummary64k,
      LoadSampleBlock,
      InsertSampleBlock,
      DeleteSampleBlock,
      GetSampleBlockSize,
      GetAllSampleBlocksSize
   };

Constructor & Destructor Documentation

DBConnection()

DBConnection::DBConnection	(	const std::weak_ptr< AudacityProject > &	pProject,
		const std::shared_ptr< DBConnectionErrors > &	pErrors,
		CheckpointFailureCallback	callback
	)

Parameters

callback

Invoked in the main thread in idle time after detection of checkpoint failure, which might have been in a worker thread

Definition at line 51 of file DBConnection.cpp.

: mpProject{ pProject }
, mpErrors{ pErrors }
, mCallback{ std::move(callback) }
{
   mDB = nullptr;
   mCheckpointDB = nullptr;
   mBypass = false;
}

References mBypass, mCheckpointDB, and mDB.

~DBConnection()

DBConnection::~DBConnection

(

)

Definition at line 64 of file DBConnection.cpp.

{
   wxASSERT(mDB == nullptr);
   if (mDB)
   {
      wxLogMessage("Database left open at connection destruction %s\n",
                   sqlite3_db_filename(mDB, nullptr));
   }
}

References mDB.

Member Function Documentation

Assign()

bool DBConnection::Assign

(

sqlite3 *

handle

)

CheckpointHook()

int DBConnection::CheckpointHook ( void *  data, sqlite3 *  db, const char *  schema, int  pages  )

staticprivate

Definition at line 587 of file DBConnection.cpp.

{
   // Get access to our object
   DBConnection *that = static_cast<DBConnection *>(data);
 
   // Queue the database pointer for our checkpoint thread to process
   std::lock_guard<std::mutex> guard(that->mCheckpointMutex);
   that->mCheckpointPending = true;
   that->mCheckpointCondition.notify_one();
 
   return SQLITE_OK;
}

References mCheckpointCondition, mCheckpointMutex, and mCheckpointPending.

Referenced by OpenStepByStep().

Here is the caller graph for this function:

CheckpointThread()

void DBConnection::CheckpointThread ( sqlite3 *  db, const FilePath &  fileName  )

private

Definition at line 493 of file DBConnection.cpp.

{
   int rc = SQLITE_OK;
   bool giveUp = false;
 
   while (true)
   {
      {
         // Wait for work or the stop signal
         std::unique_lock<std::mutex> lock(mCheckpointMutex);
         mCheckpointCondition.wait(lock,
                                   [&]
                                   {
                                      return mCheckpointPending || mCheckpointStop;
                                   });
 
         // Requested to stop, so bail
         if (mCheckpointStop)
         {
            break;
         }
 
         // Capture the number of pages that need checkpointing and reset
         mCheckpointActive = true;
         mCheckpointPending = false;
      }
 
      // And kick off the checkpoint. This may not checkpoint ALL frames
      // in the WAL.  They'll be gotten the next time around.
      using namespace std::chrono;
      do {
         rc = giveUp ? SQLITE_OK :
            sqlite3_wal_checkpoint_v2(
               db, nullptr, SQLITE_CHECKPOINT_PASSIVE, nullptr, nullptr);
      }
      // Contentions for an exclusive lock on the database are possible,
      // even while the main thread is merely drawing the tracks, which
      // may perform reads
      while (rc == SQLITE_BUSY && (std::this_thread::sleep_for(1ms), true));
 
      // Reset
      mCheckpointActive = false;
 
      if (rc != SQLITE_OK)
      {
         ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
         ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::CheckpointThread");
 
         wxLogMessage("Failed to perform checkpoint on %s\n"
                      "\tErrCode: %d\n"
                      "\tErrMsg: %s",
                      fileName,
                      sqlite3_errcode(db),
                      sqlite3_errmsg(db));
 
         // Can't checkpoint -- maybe the device has too little space
         wxFileNameWrapper fName{ fileName };
         auto path = FileNames::AbbreviatePath(fName);
         auto name = fName.GetFullName();
         auto longname = name + "-wal";
 
         // TODO: Should we return the actual error message if it's not a
         // disk full condition?
         auto message1 = rc == SQLITE_FULL
            ? XO("Could not write to %s.\n").Format(path)
            : TranslatableString{};
         auto message = XO(
            "Disk is full.\n"
            "%s"
         ).Format(message1);
 
         // Stop trying to checkpoint
         giveUp = true;
 
         // Stop the audio.
         GuardedCall(
            [&message, rc] {
            throw SimpleMessageBoxException{ rc != SQLITE_FULL ? ExceptionType::Internal : ExceptionType::BadEnvironment,
               message, XO("Warning"), "Error:_Disk_full_or_not_writable" }; },
            SimpleGuard<void>{},
            [this](AudacityException * e) {
               // This executes in the main thread.
               if (mCallback)
                  mCallback();
               if (e)
                  e->DelayedHandlerAction();
            }
         );
      }
   }
 
   return;
}

References FileNames::AbbreviatePath(), ADD_EXCEPTION_CONTEXT, BadEnvironment, GuardedCall(), Internal, mCallback, mCheckpointActive, mCheckpointCondition, mCheckpointMutex, mCheckpointPending, mCheckpointStop, name, and XO().

Referenced by OpenStepByStep().

Here is the call graph for this function:

Here is the caller graph for this function:

Close()

bool DBConnection::Close

(

)

Definition at line 233 of file DBConnection.cpp.

{
   wxASSERT(mDB != nullptr);
   int rc;
 
   // Protect...
   if (mDB == nullptr)
   {
      return true;
   }
 
   // Uninstall our checkpoint hook so that no additional checkpoints
   // are sent our way.  (Though this shouldn't really happen.)
   sqlite3_wal_hook(mDB, nullptr, nullptr);
 
   // Display a progress dialog if there's active or pending checkpoints
   if (mCheckpointPending || mCheckpointActive)
   {
      TranslatableString title = XO("Checkpointing project");
 
      // Get access to the active project
      auto project = mpProject.lock();
      if (project)
      {
         title = XO("Checkpointing %s").Format(project->GetProjectName());
      }
 
      // Provides a progress dialog with indeterminate mode
      using namespace BasicUI;
      auto pd = MakeGenericProgress({},
         title, XO("This may take several seconds"));
      wxASSERT(pd);
 
      // Wait for the checkpoints to end
      while (mCheckpointPending || mCheckpointActive)
      {
         using namespace std::chrono;
         std::this_thread::sleep_for(50ms);
         pd->Pulse();
      }
   }
 
   // Tell the checkpoint thread to shutdown
   {
      std::lock_guard<std::mutex> guard(mCheckpointMutex);
      mCheckpointStop = true;
      mCheckpointCondition.notify_one();
   }
 
   // And wait for it to do so
   if (mCheckpointThread.joinable())
   {
      mCheckpointThread.join();
   }
 
   // We're done with the prepared statements
   {
      std::lock_guard<std::mutex> guard(mStatementMutex);
      for (auto stmt : mStatements)
      {
         // No need to process return code, but log it for diagnosis
         rc = sqlite3_finalize(stmt.second);
         if (rc != SQLITE_OK)
         {
            wxLogMessage("Failed to finalize statement on %s\n"
                         "\tErrMsg: %s\n"
                         "\tSQL: %s",
                         sqlite3_db_filename(mDB, nullptr), 
                         sqlite3_errmsg(mDB),
                         stmt.second);
         }
      }
      mStatements.clear();
   }
 
   // Not much we can do if the closes fail, so just report the error
 
   // Close the checkpoint connection
   rc = sqlite3_close(mCheckpointDB);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::Close::close_checkpoint");
 
      wxLogMessage("Failed to close checkpoint connection for %s\n"
                   "\tError: %s\n",
                   sqlite3_db_filename(mCheckpointDB, nullptr),
                   sqlite3_errmsg(mCheckpointDB));
   }
   mCheckpointDB = nullptr;
 
   // Close the primary connection
   rc = sqlite3_close(mDB);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::OpenStepByStep::close");
 
      wxLogMessage("Failed to close %s\n"
                   "\tError: %s\n",
                   sqlite3_db_filename(mDB, nullptr),
                   sqlite3_errmsg(mDB));
   }
   mDB = nullptr;
 
   return true;
}

References ADD_EXCEPTION_CONTEXT, BasicUI::MakeGenericProgress(), mCheckpointActive, mCheckpointCondition, mCheckpointDB, mCheckpointMutex, mCheckpointPending, mCheckpointStop, mCheckpointThread, mDB, mpProject, mStatementMutex, mStatements, project, title, and XO().

Here is the call graph for this function:

DB()

sqlite3 * DBConnection::DB

(

)

Definition at line 422 of file DBConnection.cpp.

{
   wxASSERT(mDB != nullptr);
 
   return mDB;
}

References mDB.

Referenced by ProjectFileIO::DB(), SqliteSampleBlock::DB(), SetDBError(), DBConnectionTransactionScopeImpl::TransactionCommit(), DBConnectionTransactionScopeImpl::TransactionRollback(), and DBConnectionTransactionScopeImpl::TransactionStart().

Here is the caller graph for this function:

Detach()

sqlite3 * DBConnection::Detach

(

)

FastMode()

int DBConnection::FastMode

(

const char *

schema = "main"

)

Definition at line 360 of file DBConnection.cpp.

{
   return ModeConfig(mDB, schema, FastConfig);
}

References FastConfig, mDB, and ModeConfig().

Here is the call graph for this function:

GetLastMessage()

const wxString DBConnection::GetLastMessage

(

)

const

Definition at line 434 of file DBConnection.cpp.

{
   return sqlite3_errmsg(mDB);
}

References mDB.

GetLastRC()

int DBConnection::GetLastRC

(

)

const

Definition at line 429 of file DBConnection.cpp.

{
   return sqlite3_errcode(mDB);
}

References mDB.

ModeConfig()

int DBConnection::ModeConfig ( sqlite3 *  db, const char *  schema, const char *  config  )

private

Definition at line 393 of file DBConnection.cpp.

{
   // Ensure attached DB connection gets configured
   int rc;
 
   // Replace all schema "keywords" with the schema name
   wxString sql = config;
   sql.Replace(wxT("<schema>"), schema);
 
   // Set the configuration
   rc = sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::ModeConfig");
      ADD_EXCEPTION_CONTEXT("sqlite3.mode", config);
 
      // Don't store in connection, just report it
      wxLogMessage("Failed to set mode on %s\n"
                   "\tError: %s\n"
                   "\tSQL: %s",
                   sqlite3_db_filename(mDB, nullptr), 
                   sqlite3_errmsg(mDB),
                   sql);
   }
 
   return rc;
}

References ADD_EXCEPTION_CONTEXT, mDB, and wxT().

Referenced by FastMode(), OpenStepByStep(), SafeMode(), and SetPageSize().

Here is the call graph for this function:

Here is the caller graph for this function:

Open()

int DBConnection::Open

(

const FilePath

fileName

)

Definition at line 142 of file DBConnection.cpp.

{
   wxASSERT(mDB == nullptr);
   int rc;
 
   // Initialize checkpoint controls
   mCheckpointStop = false;
   mCheckpointPending = false;
   mCheckpointActive = false;
   rc = OpenStepByStep( fileName );
   if ( rc != SQLITE_OK)
   {
      if (mCheckpointDB)
      {
         sqlite3_close(mCheckpointDB);
         mCheckpointDB = nullptr;
      }
 
      if (mDB)
      {
         sqlite3_close(mDB);
         mDB = nullptr;
      }
   }
   return rc;
}

References mCheckpointActive, mCheckpointDB, mCheckpointPending, mCheckpointStop, mDB, and OpenStepByStep().

Here is the call graph for this function:

OpenStepByStep()

int DBConnection::OpenStepByStep ( const FilePath  fileName )

private

Definition at line 169 of file DBConnection.cpp.

{
   const char *name = fileName.ToUTF8();
 
   bool success = false;
   int rc = sqlite3_open(name, &mDB);
   if (rc != SQLITE_OK) 
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::OpenStepByStep::open");
 
      wxLogMessage("Failed to open primary connection to %s: %d, %s\n",
         fileName,
         rc,
         sqlite3_errstr(rc));
      return rc;
   }
 
   rc = SetPageSize();
 
   if (rc != SQLITE_OK)
   {
      SetDBError(XO("Failed to set page size for database %s")
                    .Format(fileName));
      return rc;
   }
 
   // Set default mode
   // (See comments in ProjectFileIO::SaveProject() about threading
   rc = SafeMode();
   if (rc != SQLITE_OK)
   {
      SetDBError(XO("Failed to set safe mode on primary connection to %s").Format(fileName));
      return rc;
   }
 
   rc = sqlite3_open(name, &mCheckpointDB);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::OpenStepByStep::open_checkpoint");
 
      wxLogMessage("Failed to open checkpoint connection to %s: %d, %s\n",
         fileName,
         rc,
         sqlite3_errstr(rc));
      return rc;
   }
 
   rc = ModeConfig(mCheckpointDB, "main", SafeConfig);
   if (rc != SQLITE_OK) {
      SetDBError(XO("Failed to set safe mode on checkpoint connection to %s").Format(fileName));
      return rc;
   }
 
   auto db = mCheckpointDB;
   mCheckpointThread = std::thread(
      [this, db, fileName]{ CheckpointThread(db, fileName); });
 
   // Install our checkpoint hook
   sqlite3_wal_hook(mDB, CheckpointHook, this);
   return rc;
}

References ADD_EXCEPTION_CONTEXT, CheckpointHook(), CheckpointThread(), mCheckpointDB, mCheckpointThread, mDB, ModeConfig(), name, SafeConfig, SafeMode(), SetDBError(), SetPageSize(), and XO().

Referenced by Open().

Here is the call graph for this function:

Here is the caller graph for this function:

Prepare()

sqlite3_stmt * DBConnection::Prepare	(	enum StatementID	id,
		const char *	sql
	)

Definition at line 439 of file DBConnection.cpp.

{
   std::lock_guard<std::mutex> guard(mStatementMutex);
 
   int rc;
   // See bug 2673
   // We must not use the same prepared statement from two different threads.
   // Therefore, in the cache, use the thread id too.
   StatementIndex ndx(id, std::this_thread::get_id());
 
   // Return an existing statement if it's already been prepared
   auto iter = mStatements.find(ndx);
   if (iter != mStatements.end())
   {
      return iter->second;
   }
 
   // Prepare the statement
   sqlite3_stmt *stmt = nullptr;
   rc = sqlite3_prepare_v3(mDB, sql, -1, SQLITE_PREPARE_PERSISTENT, &stmt, 0);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.query", sql);
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "DBConnection::Prepare");
 
      wxLogMessage("Failed to prepare statement for %s\n"
                   "\tError: %s\n"
                   "\tSQL: %s",
                   sqlite3_db_filename(mDB, nullptr), 
                   sqlite3_errmsg(mDB),
                   sql);
 
      // TODO: Look into why this causes an access violation
      THROW_INCONSISTENCY_EXCEPTION;
   }
 
   // There are a small number (10 or so) of different id's corresponding 
   // to different SQL statements, see enum StatementID
   // We have relatively few threads running at any one time,
   // e.g. main gui thread, a playback thread, a thread for compacting.
   // However the cache might keep growing, as we start/stop audio,
   // perhaps, if we chose to use a new thread each time.
   // For 3.0.0 I think that's OK.  If it's a data leak it's a slow 
   // enough one.  wxLogDebugs seem to show that the audio play thread
   // is being reused, not recreated with a new ID, i.e. no leak at all.
   // ANSWER-ME Just how serious is the data leak?  How best to fix?
 
   // Remember the cached statement.
   mStatements.insert({ndx, stmt});
 
   return stmt;
}

References ADD_EXCEPTION_CONTEXT, mDB, mStatementMutex, mStatements, and THROW_INCONSISTENCY_EXCEPTION.

Referenced by SqliteSampleBlock::Commit(), SqliteSampleBlock::Delete(), SqliteSampleBlock::DoGetSamples(), ProjectFileIO::GetDiskUsage(), SqliteSampleBlock::GetSummary(), and SqliteSampleBlock::Load().

Here is the caller graph for this function:

SafeMode()

int DBConnection::SafeMode

(

const char *

schema = "main"

)

Definition at line 355 of file DBConnection.cpp.

{
   return ModeConfig(mDB, schema, SafeConfig);
}

References mDB, ModeConfig(), and SafeConfig.

Referenced by OpenStepByStep().

Here is the call graph for this function:

Here is the caller graph for this function:

SetBypass()

void DBConnection::SetBypass

(

bool

bypass

)

Definition at line 74 of file DBConnection.cpp.

{
   mBypass = bypass;
}

References mBypass.

SetDBError()

void DBConnection::SetDBError	(	const TranslatableString &	msg,
		const TranslatableString &	libraryError = {},
		int	errorCode = -1
	)

Set stored errors and write to log; and default libraryError to what database library reports.

Definition at line 110 of file DBConnection.cpp.

{
   auto db = DB();
 
   mpErrors->mErrorCode = errorCode < 0 && db
      ? sqlite3_errcode(db)
      : errorCode;
 
   mpErrors->mLastError = msg.empty()
      ? XO("(%d): %s").Format(mpErrors->mErrorCode, sqlite3_errstr(mpErrors->mErrorCode))
      : msg;
 
   mpErrors->mLibraryError = libraryError.empty() && db
      ? Verbatim(sqlite3_errmsg(db))
      : libraryError;
 
   wxLogMessage("DBConnection SetDBError\n"
                "\tErrorCode: %d\n"
                "\tLastError: %s\n"
                "\tLibraryError: %s",
                 mpErrors->mErrorCode,
                 mpErrors->mLastError.Debug(),
                 mpErrors->mLibraryError.Debug());
 
   auto logger = AudacityLogger::Get();
   if (logger)
   {
      mpErrors->mLog = logger->GetLog(10);
   }
}

References DB(), TranslatableString::empty(), AudacityLogger::Get(), mpErrors, Verbatim(), and XO().

Referenced by OpenStepByStep(), DBConnectionTransactionScopeImpl::TransactionCommit(), DBConnectionTransactionScopeImpl::TransactionRollback(), and DBConnectionTransactionScopeImpl::TransactionStart().

Here is the call graph for this function:

Here is the caller graph for this function:

SetError()

void DBConnection::SetError	(	const TranslatableString &	msg,
		const TranslatableString &	libraryError = {},
		int	errorCode = {}
	)

Just set stored errors.

Definition at line 84 of file DBConnection.cpp.

{
   mpErrors->mErrorCode = errorCode;
 
   mpErrors->mLastError = msg;
 
   mpErrors->mLibraryError = errorCode && libraryError.empty()
      ? XO("(%d): %s").Format(errorCode, sqlite3_errstr(errorCode))
      : libraryError;
 
   wxLogMessage("DBConnection SetError\n"
                "\tErrorCode: %d\n"
                "\tLastError: %s\n"
                "\tLibraryError: %s",
                 mpErrors->mErrorCode,
                 mpErrors->mLastError.Debug(),
                 mpErrors->mLibraryError.Debug());
 
   auto logger = AudacityLogger::Get();
   if (logger)
   {
      mpErrors->mLog = logger->GetLog(10);
   }
}

References TranslatableString::empty(), AudacityLogger::Get(), mpErrors, and XO().

Here is the call graph for this function:

SetPageSize()

int DBConnection::SetPageSize

(

const char *

schema = "main"

)

Definition at line 365 of file DBConnection.cpp.

{
   // First of all - let's check if the database is empty.
   // Otherwise, VACUUM can take a significant amount of time.
   // VACUUM is required to force SQLite3 to change the page size.
   // This function will be the first called on the connection,
   // so if DB is empty we can assume that journal was not
   // set to WAL yet.
   sqlite3_stmt *stmt = nullptr;
   int rc = sqlite3_prepare_v2(mDB, "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'project')", -1, &stmt, nullptr);
 
   if (rc == SQLITE_OK)
   {
      auto finalizer = finally([&stmt] { sqlite3_finalize(stmt); });
      rc = sqlite3_step(stmt);
      if (rc == SQLITE_ROW)
      {
         if (sqlite3_column_int (stmt, 0) == 1)
         {
            // Project table exists, too late to VACUUM now
            return SQLITE_OK;
         }
      }
   }
 
   return ModeConfig(mDB, schema, PageSizeConfig);
}

References mDB, ModeConfig(), and PageSizeConfig.

Referenced by OpenStepByStep().

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldBypass()

bool DBConnection::ShouldBypass

(

)

Definition at line 79 of file DBConnection.cpp.

{
   return mBypass;
}

References mBypass.

ThrowException()

void DBConnection::ThrowException

(

bool

write

)

const

throw and show appropriate message box

Parameters

write

If true, a database update failed; if false, only a SELECT failed

Definition at line 341 of file DBConnection.cpp.

{
   // Sqlite3 documentation says returned character string
   // does NOT require freeing by us.
   wxString dbName{ sqlite3_db_filename(mDB, "main") };
   // Now we have an absolute path.  Throw a message box exception that
   // formats a helpful message just as used to be done before sqlite3
   // was used for projects.
   throw FileException{
      write ? FileException::Cause::Write : FileException::Cause::Read,
      dbName
   };
}

References mDB, FileException::Read, and FileException::Write.

Referenced by SqliteSampleBlock::Commit(), SqliteSampleBlock::Delete(), SqliteSampleBlock::GetBlob(), ProjectFileIO::GetDiskUsage(), and SqliteSampleBlock::Load().

Here is the caller graph for this function:

Member Data Documentation

mBypass

bool DBConnection::mBypass

private

Definition at line 129 of file DBConnection.h.

Referenced by DBConnection(), SetBypass(), and ShouldBypass().

mCallback

CheckpointFailureCallback DBConnection::mCallback

private

Definition at line 126 of file DBConnection.h.

Referenced by CheckpointThread().

mCheckpointActive

std::atomic_bool DBConnection::mCheckpointActive { false }

private

Definition at line 119 of file DBConnection.h.

Referenced by CheckpointThread(), Close(), and Open().

mCheckpointCondition

std::condition_variable DBConnection::mCheckpointCondition

private

Definition at line 115 of file DBConnection.h.

Referenced by CheckpointHook(), CheckpointThread(), and Close().

mCheckpointDB

sqlite3* DBConnection::mCheckpointDB

private

Definition at line 112 of file DBConnection.h.

Referenced by Close(), DBConnection(), Open(), and OpenStepByStep().

mCheckpointMutex

std::mutex DBConnection::mCheckpointMutex

private

Definition at line 116 of file DBConnection.h.

Referenced by CheckpointHook(), CheckpointThread(), and Close().

mCheckpointPending

std::atomic_bool DBConnection::mCheckpointPending { false }

private

Definition at line 118 of file DBConnection.h.

Referenced by CheckpointHook(), CheckpointThread(), Close(), and Open().

mCheckpointStop

std::atomic_bool DBConnection::mCheckpointStop { false }

private

Definition at line 117 of file DBConnection.h.

Referenced by CheckpointThread(), Close(), and Open().

mCheckpointThread

std::thread DBConnection::mCheckpointThread

private

Definition at line 114 of file DBConnection.h.

Referenced by Close(), and OpenStepByStep().

mDB

sqlite3* DBConnection::mDB

private

Definition at line 111 of file DBConnection.h.

Referenced by Close(), DB(), DBConnection(), FastMode(), GetLastMessage(), GetLastRC(), ModeConfig(), Open(), OpenStepByStep(), Prepare(), SafeMode(), SetPageSize(), ThrowException(), and ~DBConnection().

mpErrors

std::shared_ptr<DBConnectionErrors> DBConnection::mpErrors

private

Definition at line 125 of file DBConnection.h.

Referenced by SetDBError(), and SetError().

mpProject

std::weak_ptr<AudacityProject> DBConnection::mpProject

private

Definition at line 110 of file DBConnection.h.

Referenced by Close().

mStatementMutex

std::mutex DBConnection::mStatementMutex

private

Definition at line 121 of file DBConnection.h.

Referenced by Close(), and Prepare().

mStatements

std::map<StatementIndex, sqlite3_stmt *> DBConnection::mStatements

private

Definition at line 123 of file DBConnection.h.

Referenced by Close(), and Prepare().

---

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

• DBConnection.h
• DBConnection.cpp