1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
#pragma once
#include "sqlitedatabasebackend.h"
#include "sqlitedatabaseinterface.h"
#include "sqliteglobal.h"
#include "sqlitereadstatement.h"
#include "sqlitereadwritestatement.h"
#include "sqlitesessionchangeset.h"
#include "sqlitetable.h"
#include "sqlitetransaction.h"
#include "sqlitewritestatement.h"
#include <utils/smallstring.h>
#include <chrono>
#include <mutex>
#include <vector>
namespace Sqlite {
using namespace std::chrono_literals;
template<int ResultCount, int BindParameterCount>
class ReadStatement;
template<int BindParameterCount>
class WriteStatement;
template<int ResultCount, int BindParameterCount>
class ReadWriteStatement;
class SQLITE_EXPORT Database final : public TransactionInterface, public DatabaseInterface
{
template <typename Database>
friend class Statement;
friend class Backend;
public:
using MutexType = std::mutex;
template<int ResultCount, int BindParameterCount = 0>
using ReadStatement = Sqlite::ReadStatement<ResultCount, BindParameterCount>;
template<int BindParameterCount>
using WriteStatement = Sqlite::WriteStatement<BindParameterCount>;
template<int ResultCount = 0, int BindParameterCount = 0>
using ReadWriteStatement = Sqlite::ReadWriteStatement<ResultCount, BindParameterCount>;
using BusyHandler = DatabaseBackend::BusyHandler;
Database();
Database(Utils::PathString databaseFilePath,
JournalMode journalMode = JournalMode::Wal,
LockingMode lockingMode = LockingMode::Default);
Database(Utils::PathString databaseFilePath,
std::chrono::milliseconds busyTimeout,
JournalMode journalMode = JournalMode::Wal,
LockingMode lockingMode = LockingMode::Default);
~Database();
Database(const Database &) = delete;
Database &operator=(const Database &) = delete;
static void activateLogging();
void open(LockingMode lockingMode = LockingMode::Default);
void open(Utils::PathString &&databaseFilePath, LockingMode lockingMode = LockingMode::Default);
void close();
bool isInitialized() const;
void setIsInitialized(bool isInitialized);
bool isOpen() const;
void setDatabaseFilePath(Utils::PathString databaseFilePath);
const Utils::PathString &databaseFilePath() const;
void setJournalMode(JournalMode journalMode);
JournalMode journalMode() const;
LockingMode lockingMode() const;
void setOpenMode(OpenMode openMode);
OpenMode openMode() const;
void execute(Utils::SmallStringView sqlStatement) override;
DatabaseBackend &backend();
int64_t lastInsertedRowId() const
{
return m_databaseBackend.lastInsertedRowId();
}
void setLastInsertedRowId(int64_t rowId)
{
m_databaseBackend.setLastInsertedRowId(rowId);
}
int changesCount()
{
return m_databaseBackend.changesCount();
}
int totalChangesCount() { return m_databaseBackend.totalChangesCount(); }
void walCheckpointFull() override
{
std::lock_guard<std::mutex> lock{m_databaseMutex};
m_databaseBackend.walCheckpointFull();
}
void setUpdateHook(void *object,
void (*callback)(void *object,
int,
char const *database,
char const *,
long long rowId)) override
{
m_databaseBackend.setUpdateHook(object, callback);
}
void resetUpdateHook() override { m_databaseBackend.resetUpdateHook(); }
void setAttachedTables(const Utils::SmallStringVector &tables) override;
void applyAndUpdateSessions() override;
void setBusyHandler(BusyHandler busyHandler)
{
m_databaseBackend.setBusyHandler(std::move(busyHandler));
}
SessionChangeSets changeSets() const;
bool isLocked() const
{
#ifdef QT_DEBUG
return m_isLocked;
#else
return true;
#endif
}
void lock() override
{
m_databaseMutex.lock();
#ifdef QT_DEBUG
m_isLocked = true;
#endif
}
void unlock() override
{
#ifdef QT_DEBUG
m_isLocked = false;
#endif
m_databaseMutex.unlock();
}
void deferredBegin() override;
void immediateBegin() override;
void exclusiveBegin() override;
void commit() override;
void rollback() override;
void immediateSessionBegin() override;
void sessionCommit() override;
void sessionRollback() override;
private:
void initializeTables();
void registerTransactionStatements();
void deleteTransactionStatements();
std::mutex &databaseMutex() { return m_databaseMutex; }
class Statements;
private:
Utils::PathString m_databaseFilePath;
DatabaseBackend m_databaseBackend;
std::mutex m_databaseMutex;
std::unique_ptr<Statements> m_statements;
std::chrono::milliseconds m_busyTimeout;
JournalMode m_journalMode = JournalMode::Wal;
OpenMode m_openMode = OpenMode::ReadWrite;
bool m_isOpen = false;
bool m_isInitialized = false;
bool m_isLocked = false;
};
} // namespace Sqlite
|
