Statement.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: GPL-2.0-or-later
 * SPDX-FileName: Statement.h
 * SPDX-FileContributor: Dmitry Vedenko
 */
 
#pragma once
 
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "Error.h"
 
 
struct sqlite3_stmt;
 
namespace audacity::sqlite
{
struct StatementHandle;
using StatementHandlePtr = std::shared_ptr<StatementHandle>;
 
class RowIterator;
 
 
class SQLITE_HELPERS_API Row final
{
   friend class RowIterator;
   explicit Row(
      StatementHandlePtr statement, std::vector<Error>& errors) noexcept;
   Row() = default;
 
public:
   bool Get(int columnIndex, bool& value) const;
   bool Get(int columnIndex, int& value) const;
   bool Get(int columnIndex, long& value) const;
   bool Get(int columnIndex, long long& value) const;
   bool Get(int columnIndex, float& value) const;
   bool Get(int columnIndex, double& value) const;
   bool Get(int columnIndex, std::string& value) const;
 
   template <typename T> T GetOr(int columnIndex, T defaultValue = T()) const
   {
      T value;
      return Get(columnIndex, value) ? value : defaultValue;
   }
 
   int GetColumnCount() const;
 
   int64_t GetColumnBytes(int columnIndex) const;
   int64_t ReadData(int columnIndex, void* buffer, int64_t maxSize) const;
 
private:
   template <typename Reader>
   bool DoGet(Reader reader, int columnIndex) const;
 
   StatementHandlePtr mStatement {};
   std::vector<Error>* mErrors {};
   int mColumnsCount { 0 };
};
 
class SQLITE_HELPERS_API RowIterator final
{
   friend class RunResult;
   RowIterator(
      StatementHandlePtr statement, std::vector<Error>& errors) noexcept;
 
   RowIterator() noexcept;
 
public:
   RowIterator(const RowIterator&) = delete;
   RowIterator(RowIterator&&) noexcept;
   RowIterator& operator=(const RowIterator&) = delete;
   RowIterator& operator=(RowIterator&&) noexcept;
 
   RowIterator& operator++() noexcept;
 
   bool operator==(const RowIterator& other) const noexcept;
   bool operator!=(const RowIterator& other) const noexcept;
 
   Row operator*() const noexcept;
 
private:
   StatementHandlePtr mStatement {};
   std::vector<Error>* mErrors {};
 
   int mRowIndex { 0 };
   bool mDone { false };
};
 
class SQLITE_HELPERS_API RunResult final
{
   friend class RunContext;
   RunResult(StatementHandlePtr statement, std::vector<Error> errors) noexcept;
 
public:
   RunResult(const RunResult&) = delete;
   RunResult(RunResult&&) noexcept;
   RunResult& operator=(const RunResult&) = delete;
   RunResult& operator=(RunResult&&) noexcept;
 
   ~RunResult();
 
   bool IsOk() const noexcept;
   bool HasRows() const noexcept;
 
   int GetModifiedRowsCount() const noexcept;
 
   const std::vector<Error>& GetErrors() const noexcept;
 
   RowIterator begin() noexcept;
   RowIterator end() noexcept;
 
private:
   StatementHandlePtr mStatement;
   std::vector<Error> mErrors {};
   int mModifiedRowsCount { 0 };
   bool mHasRows { false };
};
 
 
class SQLITE_HELPERS_API RunContext final
{
   friend class Statement;
   explicit RunContext(StatementHandlePtr statement) noexcept;
 
public:
   RunContext(const RunContext&) = delete;
   RunContext(RunContext&&) noexcept;
   RunContext& operator=(const RunContext&) = delete;
   RunContext& operator=(RunContext&&) noexcept;
 
   RunContext&
   Bind(int index, const void* data, int64_t size, bool makeCopy = true);
 
   RunContext& Bind(int index, const std::string& value, bool makeCopy = true);
   RunContext& Bind(int index, std::string_view value, bool makeCopy = true);
   RunContext& Bind(int index, const char* value, bool makeCopy = true);
 
   RunContext& Bind(int index, bool value);
   RunContext& Bind(int index, int value);
   RunContext& Bind(int index, long value);
   RunContext& Bind(int index, long long value);
   RunContext& Bind(int index, std::size_t value);
   RunContext& Bind(int index, float value);
   RunContext& Bind(int index, double value);
 
   RunContext& Bind(int index, std::nullptr_t);
 
   RunContext& BindZeroBlob(int index, int64_t size);
 
   template <typename T> RunContext& Bind(const std::string& name, const T& value)
   {
      return Bind(GetParameterIndex(name), value);
   }
 
   template <typename T>
   RunContext& Bind(const std::string& name, const T& value, bool make_copy)
   {
      return Bind(GetParameterIndex(name), value, make_copy);
   }
 
   template <typename... Args> RunContext& BindAll(Args&&... args)
   {
      int index = 0;
      (Bind(++index, std::forward<Args>(args)), ...);
      return *this;
   }
 
   int GetParameterIndex(const std::string& name) const noexcept;
 
   RunResult Run();
 
private:
   template <typename Binder> RunContext& DoBind(Binder binder);
 
   StatementHandlePtr mStatement {};
   std::vector<Error> mErrors {};
   bool mNeedsReset { false };
};
 
 
class SQLITE_HELPERS_API Statement final
{
   explicit Statement(sqlite3_stmt* stmt);
 
public:
 
   Statement(const Statement&) = delete;
   Statement(Statement&&) noexcept;
 
   Statement& operator=(const Statement&) = delete;
   Statement& operator=(Statement&&) noexcept;
 
   RunContext& Prepare() noexcept;
 
   template<typename... Args>
   RunContext& Prepare(Args&&... args)
   {
      return Prepare().BindAll(std::forward<Args>(args)...);
   }
 
private:
   StatementHandlePtr mStatement {};
   std::optional<RunContext> mRunContext {};
 
   friend class Connection;
};
 
} // namespace audacity::sqlite