#ifndef _QTL_SQLITE_H_
|
#define _QTL_SQLITE_H_
|
|
#include "sqlite3.h"
|
#include <algorithm>
|
#include <array>
|
#include <sstream>
|
#include "qtl_common.hpp"
|
|
namespace qtl
|
{
|
|
namespace sqlite
|
{
|
|
class error : public std::exception
|
{
|
public:
|
explicit error(int error_code) : m_errno(error_code)
|
{
|
m_errmsg = sqlite3_errstr(error_code);
|
}
|
explicit error(sqlite3 *db)
|
{
|
m_errno = sqlite3_errcode(db);
|
m_errmsg = sqlite3_errmsg(db);
|
}
|
error(const error &src) = default;
|
virtual ~error() throw() {}
|
virtual const char *what() const throw() override { return m_errmsg; }
|
int code() const throw() { return m_errno; }
|
|
private:
|
int m_errno;
|
const char *m_errmsg;
|
};
|
|
class statement final
|
{
|
public:
|
statement() : m_stmt(NULL), m_fetch_result(SQLITE_OK) {}
|
statement(const statement &) = delete;
|
statement(statement &&src)
|
: m_stmt(src.m_stmt), m_fetch_result(src.m_fetch_result),
|
m_tail_text(std::forward<std::string>(src.m_tail_text))
|
{
|
src.m_stmt = NULL;
|
src.m_fetch_result = SQLITE_OK;
|
}
|
statement &operator=(const statement &) = delete;
|
statement &operator=(statement &&src)
|
{
|
if (this != &src)
|
{
|
m_stmt = src.m_stmt;
|
m_fetch_result = src.m_fetch_result;
|
m_tail_text = std::forward<std::string>(src.m_tail_text);
|
src.m_stmt = NULL;
|
src.m_fetch_result = SQLITE_OK;
|
}
|
return *this;
|
}
|
~statement()
|
{
|
close();
|
}
|
|
void open(sqlite3 *db, const char *query_text, size_t text_length = -1)
|
{
|
const char *tail = NULL;
|
close();
|
verify_error(sqlite3_prepare_v2(db, query_text, (int)text_length, &m_stmt, &tail));
|
if (tail != NULL)
|
{
|
if (text_length == -1)
|
m_tail_text.assign(tail);
|
else
|
m_tail_text.assign(tail, query_text + text_length);
|
}
|
else
|
m_tail_text.clear();
|
}
|
|
void close()
|
{
|
if (m_stmt)
|
{
|
sqlite3_finalize(m_stmt);
|
m_stmt = NULL;
|
}
|
}
|
|
void bind_param(int index, int value)
|
{
|
verify_error(sqlite3_bind_int(m_stmt, index + 1, value));
|
}
|
void bind_param(int index, int64_t value)
|
{
|
verify_error(sqlite3_bind_int64(m_stmt, index + 1, value));
|
}
|
void bind_param(int index, double value)
|
{
|
verify_error(sqlite3_bind_double(m_stmt, index + 1, value));
|
}
|
void bind_param(int index, const char *value, size_t n = -1)
|
{
|
if (value)
|
verify_error(sqlite3_bind_text(m_stmt, index + 1, value, (int)n, NULL));
|
else
|
verify_error(sqlite3_bind_null(m_stmt, index + 1));
|
}
|
void bind_param(int index, const wchar_t *value, size_t n = -1)
|
{
|
if (value)
|
verify_error(sqlite3_bind_text16(m_stmt, index + 1, value, (int)n, NULL));
|
else
|
verify_error(sqlite3_bind_null(m_stmt, index + 1));
|
}
|
void bind_param(int index, const std::string &value)
|
{
|
bind_param(index, value.data(), value.size());
|
}
|
void bind_param(int index, const std::wstring &value)
|
{
|
bind_param(index, value.data(), value.size());
|
}
|
void bind_param(int index, const const_blob_data &value)
|
{
|
if (value.size)
|
{
|
if (value.data)
|
verify_error(sqlite3_bind_blob(m_stmt, index + 1, value.data, (int)value.size, NULL));
|
else
|
verify_error(sqlite3_bind_zeroblob(m_stmt, index + 1, (int)value.size));
|
}
|
else
|
verify_error(sqlite3_bind_null(m_stmt, index + 1));
|
}
|
void bind_zero_blob(int index, int n)
|
{
|
verify_error(sqlite3_bind_zeroblob(m_stmt, index + 1, (int)n));
|
}
|
// void bind_zero_blob(int index, sqlite3_uint64 n)
|
//{
|
// verify_error(sqlite3_bind_zeroblob64(m_stmt, index+1, (int)n));
|
// }
|
void bind_param(int index, qtl::null)
|
{
|
verify_error(sqlite3_bind_null(m_stmt, index + 1));
|
}
|
void bind_param(int index, std::nullptr_t)
|
{
|
verify_error(sqlite3_bind_null(m_stmt, index + 1));
|
}
|
int get_parameter_count() const
|
{
|
return sqlite3_bind_parameter_count(m_stmt);
|
}
|
const char *get_parameter_name(int i) const
|
{
|
return sqlite3_bind_parameter_name(m_stmt, i);
|
}
|
int get_parameter_index(const char *param_name) const
|
{
|
return sqlite3_bind_parameter_index(m_stmt, param_name);
|
}
|
|
template <class Type>
|
void bind_field(size_t index, Type &&value)
|
{
|
get_value((int)index, std::forward<Type>(value));
|
}
|
template <class Type>
|
void bind_field(size_t index, qtl::indicator<Type> &&value)
|
{
|
int type = get_column_type(index);
|
value.length = 0;
|
value.is_truncated = false;
|
qtl::bind_field(*this, index, value.data);
|
if (type == SQLITE_NULL)
|
{
|
value.is_null = true;
|
}
|
else
|
{
|
value.is_null = false;
|
if (type == SQLITE_TEXT || type == SQLITE_BLOB)
|
value.length = sqlite3_column_bytes(m_stmt, index);
|
}
|
}
|
void bind_field(size_t index, char *value, size_t length)
|
{
|
size_t col_length = get_column_length((int)index);
|
if (col_length > 0)
|
strncpy(value, (const char *)sqlite3_column_text(m_stmt, (int)index), std::min(length, col_length + 1));
|
else
|
memset(value, 0, length * sizeof(char));
|
}
|
void bind_field(size_t index, wchar_t *value, size_t length)
|
{
|
size_t col_length = sqlite3_column_bytes16(m_stmt, (int)index);
|
if (col_length > 0)
|
wcsncpy(value, (const wchar_t *)sqlite3_column_text16(m_stmt, (int)index), std::min(length, col_length + 1));
|
else
|
memset(value, 0, length * sizeof(wchar_t));
|
}
|
template <size_t N>
|
void bind_field(size_t index, char (&&value)[N])
|
{
|
bind_field(index, value, N);
|
}
|
template <size_t N>
|
void bind_field(size_t index, wchar_t (&&value)[N])
|
{
|
bind_field(index, value, N);
|
}
|
template <size_t N>
|
void bind_field(size_t index, std::array<char, N> &&value)
|
{
|
bind_field(index, value.data(), value.size());
|
}
|
template <size_t N>
|
void bind_field(size_t index, std::array<wchar_t, N> &&value)
|
{
|
bind_field(index, value.data(), value.size());
|
}
|
|
#ifdef _QTL_ENABLE_CPP17
|
|
template <typename T>
|
inline void bind_field(size_t index, std::optional<T> &&value)
|
{
|
int type = get_column_type(index);
|
if (type == SQLITE_NULL)
|
{
|
value.reset();
|
}
|
else
|
{
|
qtl::bind_field(*this, index, *value);
|
}
|
}
|
|
inline void bind_field(size_t index, std::any &&value)
|
{
|
int type = get_column_type(index);
|
switch (type)
|
{
|
case SQLITE_NULL:
|
value.reset();
|
case SQLITE_INTEGER:
|
value = sqlite3_column_int64(m_stmt, index);
|
break;
|
case SQLITE_FLOAT:
|
value = sqlite3_column_double(m_stmt, index);
|
break;
|
case SQLITE_TEXT:
|
value.emplace<std::string_view>((const char *)sqlite3_column_text(m_stmt, index), sqlite3_column_bytes(m_stmt, index));
|
break;
|
case SQLITE_BLOB:
|
value.emplace<const_blob_data>(sqlite3_column_text(m_stmt, index), sqlite3_column_bytes(m_stmt, index));
|
break;
|
default:
|
throw sqlite::error(SQLITE_MISMATCH);
|
}
|
}
|
|
#endif // C++17
|
|
size_t find_field(const char *name) const
|
{
|
size_t count = get_column_count();
|
for (size_t i = 0; i != count; i++)
|
{
|
if (strcmp(get_column_name(i), name) == 0)
|
return i;
|
}
|
return -1;
|
}
|
|
bool fetch()
|
{
|
m_fetch_result = sqlite3_step(m_stmt);
|
switch (m_fetch_result)
|
{
|
case SQLITE_ROW:
|
return true;
|
case SQLITE_DONE:
|
return false;
|
default:
|
throw sqlite::error(m_fetch_result);
|
}
|
}
|
int get_column_count() const
|
{
|
return sqlite3_column_count(m_stmt);
|
}
|
const char *get_column_name(int col) const
|
{
|
return sqlite3_column_name(m_stmt, col);
|
}
|
void get_value(int col, int &&value) const
|
{
|
value = sqlite3_column_int(m_stmt, col);
|
}
|
void get_value(int col, int64_t &&value) const
|
{
|
value = sqlite3_column_int64(m_stmt, col);
|
}
|
void get_value(int col, double &&value) const
|
{
|
value = sqlite3_column_double(m_stmt, col);
|
}
|
const unsigned char *get_value(int col) const
|
{
|
return sqlite3_column_text(m_stmt, col);
|
}
|
|
template <typename CharT>
|
const CharT *get_text_value(int col) const;
|
|
template <typename T>
|
void get_value(int col, qtl::bind_string_helper<T> &&value) const
|
{
|
typedef typename qtl::bind_string_helper<T>::char_type char_type;
|
int bytes = sqlite3_column_bytes(m_stmt, col);
|
if (bytes > 0)
|
value.assign(get_text_value<char_type>(col), bytes / sizeof(char_type));
|
else
|
value.clear();
|
}
|
void get_value(int col, const_blob_data &&value) const
|
{
|
value.data = sqlite3_column_blob(m_stmt, col);
|
value.size = sqlite3_column_bytes(m_stmt, col);
|
}
|
void get_value(int col, blob_data &&value) const
|
{
|
const void *data = sqlite3_column_blob(m_stmt, col);
|
size_t size = sqlite3_column_bytes(m_stmt, col);
|
if (value.size < size)
|
throw std::out_of_range("no enough buffer to receive blob data.");
|
memcpy(value.data, data, size);
|
value.size = size;
|
}
|
void get_value(int col, std::ostream &&value) const
|
{
|
const void *data = sqlite3_column_blob(m_stmt, col);
|
size_t size = sqlite3_column_bytes(m_stmt, col);
|
if (size > 0)
|
value.write((const char *)data, size);
|
}
|
|
int get_column_length(int col) const
|
{
|
return sqlite3_column_bytes(m_stmt, col);
|
}
|
int get_column_type(int col) const
|
{
|
return sqlite3_column_type(m_stmt, col);
|
}
|
void clear_bindings()
|
{
|
sqlite3_clear_bindings(m_stmt);
|
}
|
void reset()
|
{
|
sqlite3_reset(m_stmt);
|
}
|
|
template <typename Types>
|
void execute(const Types ¶ms)
|
{
|
unsigned long count = get_parameter_count();
|
if (count > 0)
|
{
|
qtl::bind_params(*this, params);
|
}
|
fetch();
|
}
|
|
template <typename Types>
|
bool fetch(Types &&values)
|
{
|
bool result = false;
|
if (m_fetch_result == SQLITE_OK)
|
fetch();
|
if (m_fetch_result == SQLITE_ROW)
|
{
|
result = true;
|
qtl::bind_record(*this, std::forward<Types>(values));
|
m_fetch_result = SQLITE_OK;
|
}
|
return result;
|
}
|
|
bool next_result()
|
{
|
sqlite3 *db = sqlite3_db_handle(m_stmt);
|
int count = 0;
|
do
|
{
|
trim_string(m_tail_text, " \t\r\n");
|
if (!m_tail_text.empty())
|
{
|
open(db, m_tail_text.data(), m_tail_text.size());
|
count = sqlite3_column_count(m_stmt);
|
m_fetch_result = SQLITE_OK;
|
}
|
} while (!m_tail_text.empty() && count == 0);
|
return count > 0;
|
;
|
}
|
|
int affetced_rows() const
|
{
|
sqlite3 *db = sqlite3_db_handle(m_stmt);
|
return db ? sqlite3_changes(db) : 0;
|
}
|
|
int64_t insert_id() const
|
{
|
sqlite3 *db = sqlite3_db_handle(m_stmt);
|
return db ? sqlite3_last_insert_rowid(db) : 0;
|
}
|
|
protected:
|
sqlite3_stmt *m_stmt;
|
std::string m_tail_text;
|
|
int m_fetch_result;
|
void verify_error(int e)
|
{
|
if (e != SQLITE_OK)
|
throw error(e);
|
}
|
};
|
|
class database final : public qtl::base_database<database, statement>
|
{
|
public:
|
typedef sqlite::error exception_type;
|
|
database() : m_db(NULL) {}
|
~database() { close(); }
|
database(const database &) = delete;
|
database(database &&src)
|
{
|
m_db = src.m_db;
|
src.m_db = NULL;
|
}
|
database &operator=(const database &) = delete;
|
database &operator=(database &&src)
|
{
|
if (this != &src)
|
{
|
close();
|
m_db = src.m_db;
|
src.m_db = NULL;
|
}
|
return *this;
|
}
|
|
void open(const char *filename, int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE)
|
{
|
int result = sqlite3_open_v2(filename, &m_db, flags, NULL);
|
if (result != SQLITE_OK)
|
throw sqlite::error(result);
|
}
|
void open(const wchar_t *filename)
|
{
|
int result = sqlite3_open16(filename, &m_db);
|
if (result != SQLITE_OK)
|
throw sqlite::error(result);
|
}
|
void close()
|
{
|
if (m_db)
|
{
|
sqlite3_close_v2(m_db);
|
m_db = NULL;
|
}
|
}
|
|
statement open_command(const char *query_text, size_t text_length)
|
{
|
statement stmt;
|
stmt.open(handle(), query_text, text_length);
|
return stmt;
|
}
|
statement open_command(const char *query_text)
|
{
|
return open_command(query_text, strlen(query_text));
|
}
|
statement open_command(const std::string &query_text)
|
{
|
return open_command(query_text.data(), query_text.length());
|
}
|
|
void simple_execute(const char *lpszSql)
|
{
|
int result = sqlite3_exec(m_db, lpszSql, NULL, NULL, NULL);
|
if (result != SQLITE_OK)
|
throw sqlite::error(result);
|
}
|
|
void begin_transaction()
|
{
|
simple_execute("BEGIN TRANSACTION");
|
}
|
void commit()
|
{
|
simple_execute("COMMIT TRANSACTION");
|
}
|
void rollback()
|
{
|
simple_execute("ROLLBACK TRANSACTION");
|
}
|
|
bool is_alive()
|
{
|
#ifdef _WIN32
|
return true;
|
#else
|
int has_moved = 0;
|
int result = sqlite3_file_control(m_db, NULL, SQLITE_FCNTL_HAS_MOVED, &has_moved);
|
if (result != SQLITE_OK)
|
throw sqlite::error(result);
|
return has_moved == 0;
|
#endif //_WIN32
|
}
|
const char *errmsg() const { return sqlite3_errmsg(m_db); }
|
int error() const { return sqlite3_errcode(m_db); }
|
uint64_t insert_id() { return sqlite3_last_insert_rowid(m_db); }
|
sqlite3 *handle() { return m_db; }
|
|
protected:
|
sqlite3 *m_db;
|
};
|
|
// stream for blob field
|
|
class blobbuf : public std::streambuf
|
{
|
public:
|
blobbuf()
|
{
|
init();
|
}
|
blobbuf(const blobbuf &) = delete;
|
blobbuf(blobbuf &&src) : std::streambuf(std::move(src))
|
{
|
init();
|
swap(src);
|
}
|
virtual ~blobbuf()
|
{
|
if (m_blob)
|
{
|
close();
|
}
|
}
|
|
blobbuf &operator=(const blobbuf &) = delete;
|
blobbuf &operator=(blobbuf &&src)
|
{
|
if (this != &src)
|
{
|
reset_back();
|
close();
|
swap(src);
|
}
|
return *this;
|
}
|
|
void swap(blobbuf &other)
|
{
|
std::swap(m_blob, other.m_blob);
|
std::swap(m_inbuf, other.m_inbuf);
|
std::swap(m_outbuf, other.m_outbuf);
|
std::swap(m_size, other.m_size);
|
std::swap(m_inpos, other.m_inpos);
|
std::swap(m_outpos, other.m_outpos);
|
|
std::streambuf::swap(other);
|
std::swap(m_back_char, other.m_back_char);
|
if (eback() == &other.m_back_char)
|
set_back();
|
else
|
reset_back();
|
|
if (other.eback() == &m_back_char)
|
other.set_back();
|
else
|
other.reset_back();
|
}
|
|
static void init_blob(database &db, const char *table, const char *column, int64_t row, int length)
|
{
|
statement stmt;
|
std::ostringstream oss;
|
oss << "UPDATE " << table << " SET " << column << "=? WHERE rowid=?";
|
stmt.open(db.handle(), oss.str().data());
|
stmt.bind_zero_blob(0, length);
|
stmt.bind_param(1, row);
|
stmt.fetch();
|
}
|
static void init_blob(database &db, const std::string &table, const std::string &column, int64_t row, int length)
|
{
|
return init_blob(db, table.c_str(), column.c_str(), row, length);
|
}
|
|
bool is_open() const { return m_blob != nullptr; }
|
|
blobbuf *open(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode, const char *dbname = "main")
|
{
|
int flags = 0;
|
if (mode & std::ios_base::out)
|
flags = 1;
|
if (sqlite3_blob_open(db.handle(), dbname, table, column, row, flags, &m_blob) == SQLITE_OK)
|
{
|
m_size = sqlite3_blob_bytes(m_blob) / sizeof(char);
|
// prepare buffer
|
size_t bufsize = std::min<size_t>(default_buffer_size, m_size);
|
if (mode & std::ios_base::in)
|
{
|
m_inbuf.resize(bufsize);
|
m_inpos = 0;
|
setg(m_inbuf.data(), m_inbuf.data(), m_inbuf.data());
|
}
|
if (mode & std::ios_base::out)
|
{
|
m_outbuf.resize(bufsize);
|
m_outpos = 0;
|
setp(m_outbuf.data(), m_outbuf.data() + bufsize);
|
}
|
}
|
return this;
|
}
|
blobbuf *open(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode, const char *dbname = "main")
|
{
|
return open(db, table.c_str(), column.c_str(), row, mode, dbname);
|
}
|
|
blobbuf *close()
|
{
|
if (m_blob == nullptr)
|
return nullptr;
|
|
overflow();
|
sqlite3_blob_close(m_blob);
|
init();
|
return this;
|
}
|
|
std::streamoff size() const { return std::streamoff(m_size); }
|
|
void flush()
|
{
|
if (m_blob)
|
overflow();
|
}
|
|
protected:
|
enum
|
{
|
default_buffer_size = 4096
|
};
|
|
virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir,
|
std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override
|
{
|
if (!is_open())
|
return pos_type(off_type(-1));
|
|
pos_type pos = 0;
|
if (which & std::ios_base::out)
|
{
|
pos = seekoff(m_outpos, off, dir);
|
}
|
else if (which & std::ios_base::in)
|
{
|
pos = seekoff(m_inpos, off, dir);
|
}
|
return seekpos(pos, which);
|
}
|
|
virtual pos_type seekpos(pos_type pos,
|
std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override
|
{
|
if (!is_open())
|
return pos_type(off_type(-1));
|
if (pos >= m_size)
|
return pos_type(off_type(-1));
|
|
if (which & std::ios_base::out)
|
{
|
if (pos < m_outpos || pos >= m_outpos + off_type(egptr() - pbase()))
|
{
|
overflow();
|
m_outpos = pos;
|
setp(m_outbuf.data(), m_outbuf.data() + m_outbuf.size());
|
}
|
else
|
{
|
pbump(off_type(pos - pabs()));
|
}
|
}
|
else if (which & std::ios_base::in)
|
{
|
if (pos < m_inpos || pos >= m_inpos + off_type(epptr() - eback()))
|
{
|
m_inpos = pos;
|
setg(m_inbuf.data(), m_inbuf.data(), m_inbuf.data());
|
}
|
else
|
{
|
gbump(off_type(pos - gabs()));
|
}
|
}
|
return pos;
|
}
|
|
virtual std::streamsize showmanyc() override
|
{
|
return m_size - pabs();
|
}
|
|
// reads characters from the associated input sequence to the get area
|
virtual int_type underflow() override
|
{
|
if (!is_open())
|
return traits_type::eof();
|
|
if (pptr() > pbase())
|
overflow();
|
|
off_type count = egptr() - eback();
|
pos_type next_pos = 0;
|
if (count == 0 && eback() == m_inbuf.data())
|
{
|
setg(m_inbuf.data(), m_inbuf.data(), m_inbuf.data() + m_inbuf.size());
|
count = m_inbuf.size();
|
}
|
else
|
{
|
next_pos = m_inpos + pos_type(count);
|
}
|
if (next_pos >= m_size)
|
return traits_type::eof();
|
|
count = std::min(count, m_size - next_pos);
|
m_inpos = next_pos;
|
if (sqlite3_blob_read(m_blob, eback(), count, m_inpos) != SQLITE_OK)
|
return traits_type::eof();
|
setg(eback(), eback(), eback() + count);
|
return traits_type::to_int_type(*gptr());
|
}
|
|
/*//reads characters from the associated input sequence to the get area and advances the next pointer
|
virtual int_type uflow() override
|
{
|
|
}*/
|
|
// writes characters to the associated output sequence from the put area
|
virtual int_type overflow(int_type ch = traits_type::eof()) override
|
{
|
if (!is_open())
|
return traits_type::eof();
|
|
if (pptr() != pbase())
|
{
|
size_t count = pptr() - pbase();
|
if (sqlite3_blob_write(m_blob, pbase(), count, m_outpos) != SQLITE_OK)
|
return traits_type::eof();
|
|
auto intersection = interval_intersection(m_inpos, egptr() - eback(), m_outpos, epptr() - pbase());
|
if (intersection.first != intersection.second)
|
{
|
commit(intersection.first, intersection.second);
|
}
|
|
m_outpos += count;
|
setp(pbase(), epptr());
|
}
|
if (!traits_type::eq_int_type(ch, traits_type::eof()))
|
{
|
char_type c = traits_type::to_char_type(ch);
|
if (m_outpos >= m_size)
|
return traits_type::eof();
|
if (sqlite3_blob_write(m_blob, &c, 1, m_outpos) != SQLITE_OK)
|
return traits_type::eof();
|
auto intersection = interval_intersection(m_inpos, egptr() - eback(), m_outpos, 1);
|
if (intersection.first != intersection.second)
|
{
|
eback()[intersection.first - m_inpos] = c;
|
}
|
m_outpos += 1;
|
}
|
return ch;
|
}
|
|
virtual int_type pbackfail(int_type c = traits_type::eof()) override
|
{
|
if (gptr() == 0 || gptr() <= eback() || (!traits_type::eq_int_type(traits_type::eof(), c) && !traits_type::eq(traits_type::to_char_type(c), gptr()[-1])))
|
{
|
return (traits_type::eof()); // can't put back, fail
|
}
|
else
|
{ // back up one position and store put-back character
|
gbump(-1);
|
if (!traits_type::eq_int_type(traits_type::eof(), c))
|
*gptr() = traits_type::to_char_type(c);
|
return (traits_type::not_eof(c));
|
}
|
}
|
|
private:
|
sqlite3_blob *m_blob;
|
std::vector<char> m_inbuf;
|
std::vector<char> m_outbuf;
|
pos_type m_size;
|
pos_type m_inpos; // position in the input sequence
|
pos_type m_outpos; // position in the output sequence
|
|
void init()
|
{
|
m_blob = nullptr;
|
m_size = 0;
|
m_inpos = m_outpos = 0;
|
m_set_eback = m_set_egptr = nullptr;
|
m_back_char = 0;
|
setg(nullptr, nullptr, nullptr);
|
setp(nullptr, nullptr);
|
}
|
|
off_type seekoff(off_type position, off_type off, std::ios_base::seekdir dir)
|
{
|
off_type result = 0;
|
switch (dir)
|
{
|
case std::ios_base::beg:
|
result = off;
|
break;
|
case std::ios_base::cur:
|
result = position + off;
|
break;
|
case std::ios_base::end:
|
result = m_size - off;
|
break;
|
}
|
if (result > m_size)
|
result = m_size;
|
return result;
|
}
|
|
void reset_back()
|
{ // restore buffer after putback
|
if (this->eback() == &m_back_char)
|
this->setg(m_set_eback, m_set_eback, m_set_egptr);
|
}
|
|
void set_back()
|
{ // set up putback area
|
if (this->eback() != &m_back_char)
|
{ // save current get buffer
|
m_set_eback = this->eback();
|
m_set_egptr = this->egptr();
|
}
|
this->setg(&m_back_char, &m_back_char, &m_back_char + 1);
|
}
|
|
char_type *m_set_eback{nullptr}; // saves eback() during one-element putback
|
char_type *m_set_egptr{nullptr}; // saves egptr()
|
char_type m_back_char{0};
|
|
void move_data(blobbuf &other)
|
{
|
m_blob = other.m_blob;
|
other.m_blob = nullptr;
|
m_size = other.m_size;
|
other.m_size = 0;
|
m_inpos = other.m_inpos;
|
other.m_inpos = 0;
|
m_outpos = other.m_outpos;
|
other.m_outpos = 0;
|
}
|
|
static std::pair<pos_type, pos_type> interval_intersection(pos_type first1, pos_type last1, pos_type first2, pos_type last2)
|
{
|
if (first1 > first2)
|
{
|
std::swap(first1, first2);
|
std::swap(last1, last2);
|
}
|
|
if (first2 < last1)
|
return std::make_pair(first2, std::min(last1, last2));
|
else
|
return std::make_pair(0, 0);
|
}
|
|
static std::pair<pos_type, pos_type> interval_intersection(pos_type first1, off_type count1, pos_type first2, off_type count2)
|
{
|
return interval_intersection(first1, first1 + count1, first2, first2 + count2);
|
}
|
|
void commit(off_type first, off_type last)
|
{
|
char_type *src = pbase() + (first - m_outpos);
|
char_type *dest = eback() + (first - m_inpos);
|
memmove(dest, src, last - first);
|
}
|
|
pos_type gabs() const // absolute offset of input pointer in blob field
|
{
|
return m_inpos + off_type(gptr() - eback());
|
}
|
|
pos_type pabs() const // absolute offset of output pointer in blob field
|
{
|
return m_outpos + off_type(pptr() - pbase());
|
}
|
};
|
|
class iblobstream : public std::istream
|
{
|
public:
|
iblobstream() : std::istream(&m_buffer) {}
|
iblobstream(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
: std::istream(&m_buffer)
|
{
|
open(db, table, column, row, mode, dbname);
|
}
|
iblobstream(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
: std::istream(&m_buffer)
|
{
|
open(db, table, column, row, mode, dbname);
|
}
|
iblobstream(const iblobstream &) = delete;
|
iblobstream(iblobstream &&src) : std::istream(&m_buffer), m_buffer(std::move(src.m_buffer)) {}
|
|
iblobstream &operator=(const iblobstream &) = delete;
|
iblobstream &operator=(iblobstream &&src)
|
{
|
m_buffer.operator=(std::move(src.m_buffer));
|
}
|
|
bool is_open() const { return m_buffer.is_open(); }
|
|
void open(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
{
|
if (m_buffer.open(db, table, column, row, mode | std::ios_base::in, dbname) == nullptr)
|
this->setstate(std::ios_base::failbit);
|
else
|
this->clear();
|
}
|
void open(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
{
|
open(db, table.c_str(), column.c_str(), row, mode, dbname);
|
}
|
|
void close()
|
{
|
if (m_buffer.close() == nullptr)
|
this->setstate(std::ios_base::failbit);
|
}
|
|
blobbuf *rdbuf() const
|
{
|
return const_cast<blobbuf *>(&m_buffer);
|
}
|
|
std::streamoff blob_size() const { return m_buffer.size(); }
|
|
private:
|
blobbuf m_buffer;
|
};
|
|
class oblobstream : public std::ostream
|
{
|
public:
|
oblobstream() : std::ostream(&m_buffer) {}
|
oblobstream(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
: std::ostream(&m_buffer)
|
{
|
open(db, table, column, row, mode, dbname);
|
}
|
oblobstream(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
: std::ostream(&m_buffer)
|
{
|
open(db, table, column, row, mode, dbname);
|
}
|
oblobstream(const oblobstream &) = delete;
|
oblobstream(oblobstream &&src) : std::ostream(&m_buffer), m_buffer(std::move(src.m_buffer)) {}
|
|
oblobstream &operator=(const oblobstream &) = delete;
|
oblobstream &operator=(oblobstream &&src)
|
{
|
m_buffer.operator=(std::move(src.m_buffer));
|
}
|
|
bool is_open() const { return m_buffer.is_open(); }
|
|
void open(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::out, const char *dbname = "main")
|
{
|
if (m_buffer.open(db, table, column, row, mode | std::ios_base::out, dbname) == nullptr)
|
this->setstate(std::ios_base::failbit);
|
else
|
this->clear();
|
}
|
void open(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::out, const char *dbname = "main")
|
{
|
open(db, table.c_str(), column.c_str(), row, mode, dbname);
|
}
|
|
void close()
|
{
|
if (m_buffer.close() == nullptr)
|
this->setstate(std::ios_base::failbit);
|
}
|
|
blobbuf *rdbuf() const
|
{
|
return const_cast<blobbuf *>(&m_buffer);
|
}
|
|
std::streamoff blob_size() const { return m_buffer.size(); }
|
|
private:
|
blobbuf m_buffer;
|
};
|
|
class blobstream : public std::iostream
|
{
|
public:
|
blobstream() : std::iostream(&m_buffer) {}
|
blobstream(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
: std::iostream(&m_buffer)
|
{
|
open(db, table, column, row, mode, dbname);
|
}
|
blobstream(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in, const char *dbname = "main")
|
: std::iostream(&m_buffer)
|
{
|
open(db, table, column, row, mode, dbname);
|
}
|
blobstream(const blobstream &) = delete;
|
blobstream(blobstream &&src) : std::iostream(&m_buffer), m_buffer(std::move(src.m_buffer)) {}
|
|
blobstream &operator=(const blobstream &) = delete;
|
blobstream &operator=(blobstream &&src)
|
{
|
m_buffer.operator=(std::move(src.m_buffer));
|
}
|
|
bool is_open() const { return m_buffer.is_open(); }
|
|
void open(database &db, const char *table, const char *column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out, const char *dbname = "main")
|
{
|
if (m_buffer.open(db, table, column, row, mode | std::ios_base::in | std::ios_base::out, dbname) == nullptr)
|
this->setstate(std::ios_base::failbit);
|
else
|
this->clear();
|
}
|
void open(database &db, const std::string &table, const std::string &column, sqlite3_int64 row,
|
std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out, const char *dbname = "main")
|
{
|
open(db, table.c_str(), column.c_str(), row, mode, dbname);
|
}
|
|
void close()
|
{
|
if (m_buffer.close() == nullptr)
|
this->setstate(std::ios_base::failbit);
|
}
|
|
blobbuf *rdbuf() const
|
{
|
return const_cast<blobbuf *>(&m_buffer);
|
}
|
|
std::streamoff blob_size() const { return m_buffer.size(); }
|
|
private:
|
blobbuf m_buffer;
|
};
|
|
typedef qtl::transaction<database> transaction;
|
|
template <typename Record>
|
using query_iterator = qtl::query_iterator<statement, Record>;
|
|
template <typename Record>
|
using query_result = qtl::query_result<statement, Record>;
|
|
template <typename Params>
|
inline statement &operator<<(statement &stmt, const Params ¶ms)
|
{
|
stmt.reset();
|
stmt.execute(params);
|
return stmt;
|
}
|
|
template <>
|
inline const char *statement::get_text_value<char>(int col) const
|
{
|
return (const char *)sqlite3_column_text(m_stmt, col);
|
}
|
template <>
|
inline const wchar_t *statement::get_text_value<wchar_t>(int col) const
|
{
|
return (const wchar_t *)sqlite3_column_text16(m_stmt, col);
|
}
|
|
}
|
|
}
|
|
#endif //_QTL_SQLITE_H_
|
